summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
-rw-r--r--Source/CMakeLists.txt2
-rw-r--r--Source/CursesDialog/ccmake.cxx1
-rw-r--r--Source/CursesDialog/cmCursesBoolWidget.cxx2
-rw-r--r--Source/CursesDialog/cmCursesCacheEntryComposite.cxx17
-rw-r--r--Source/CursesDialog/cmCursesCacheEntryComposite.h1
-rw-r--r--Source/CursesDialog/cmCursesDummyWidget.cxx2
-rw-r--r--Source/CursesDialog/cmCursesFilePathWidget.cxx2
-rw-r--r--Source/CursesDialog/cmCursesLongMessageForm.cxx1
-rw-r--r--Source/CursesDialog/cmCursesMainForm.cxx80
-rw-r--r--Source/CursesDialog/cmCursesMainForm.h2
-rw-r--r--Source/CursesDialog/cmCursesOptionsWidget.cxx2
-rw-r--r--Source/CursesDialog/cmCursesPathWidget.cxx4
-rw-r--r--Source/CursesDialog/cmCursesStringWidget.cxx2
-rw-r--r--Source/CursesDialog/cmCursesWidget.h6
-rw-r--r--Source/QtDialog/QCMake.cxx62
-rw-r--r--Source/cmBuildCommand.cxx2
-rw-r--r--Source/cmBuildNameCommand.cxx4
-rw-r--r--Source/cmCPluginAPI.cxx12
-rw-r--r--Source/cmCTest.cxx2
-rw-r--r--Source/cmCacheManager.cxx96
-rw-r--r--Source/cmCacheManager.h38
-rw-r--r--Source/cmCommandArgumentParserHelper.cxx3
-rw-r--r--Source/cmCoreTryCompile.cxx3
-rw-r--r--Source/cmExtraEclipseCDT4Generator.cxx7
-rw-r--r--Source/cmFindBase.cxx11
-rw-r--r--Source/cmFindLibraryCommand.cxx7
-rw-r--r--Source/cmFindPackageCommand.cxx2
-rw-r--r--Source/cmFindPathCommand.cxx7
-rw-r--r--Source/cmFindProgramCommand.cxx7
-rw-r--r--Source/cmGetFilenameComponentCommand.cxx8
-rw-r--r--Source/cmGetPropertyCommand.cxx5
-rw-r--r--Source/cmGlobalGenerator.cxx19
-rw-r--r--Source/cmGlobalUnixMakefileGenerator3.cxx2
-rw-r--r--Source/cmGlobalVisualStudio7Generator.cxx8
-rw-r--r--Source/cmGlobalXCodeGenerator.cxx4
-rw-r--r--Source/cmIncludeExternalMSProjectCommand.cxx2
-rw-r--r--Source/cmLoadCacheCommand.cxx2
-rw-r--r--Source/cmLocalVisualStudio10Generator.cxx2
-rw-r--r--Source/cmLocalVisualStudio7Generator.cxx3
-rw-r--r--Source/cmMakefile.cxx47
-rw-r--r--Source/cmMakefile.h6
-rw-r--r--Source/cmMarkAsAdvancedCommand.cxx12
-rw-r--r--Source/cmOptionCommand.cxx10
-rw-r--r--Source/cmProjectCommand.cxx6
-rw-r--r--Source/cmSetCommand.cxx14
-rw-r--r--Source/cmSetPropertyCommand.cxx16
-rw-r--r--Source/cmSiteNameCommand.cxx2
-rw-r--r--Source/cmState.cxx180
-rw-r--r--Source/cmState.h62
-rw-r--r--Source/cmTarget.cxx4
-rw-r--r--Source/cmTryRunCommand.cxx21
-rw-r--r--Source/cmUtilitySourceCommand.cxx6
-rw-r--r--Source/cmVariableRequiresCommand.cxx8
-rw-r--r--Source/cmake.cxx125
-rw-r--r--Source/cmake.h9
-rw-r--r--Source/cmakemain.cxx20
-rwxr-xr-xbootstrap1
57 files changed, 595 insertions, 396 deletions
diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt
index 58c4ba9..786e3eb 100644
--- a/Source/CMakeLists.txt
+++ b/Source/CMakeLists.txt
@@ -329,6 +329,8 @@ set(SRCS
cmSourceFileLocation.h
cmSourceGroup.cxx
cmSourceGroup.h
+ cmState.cxx
+ cmState.h
cmSystemTools.cxx
cmSystemTools.h
cmTarget.cxx
diff --git a/Source/CursesDialog/ccmake.cxx b/Source/CursesDialog/ccmake.cxx
index 3d92a2d..e013f81 100644
--- a/Source/CursesDialog/ccmake.cxx
+++ b/Source/CursesDialog/ccmake.cxx
@@ -9,7 +9,6 @@
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
-#include "../cmCacheManager.h"
#include "../cmSystemTools.h"
#include "../cmake.h"
#include "../cmDocumentation.h"
diff --git a/Source/CursesDialog/cmCursesBoolWidget.cxx b/Source/CursesDialog/cmCursesBoolWidget.cxx
index fd15b99..29d9cb2 100644
--- a/Source/CursesDialog/cmCursesBoolWidget.cxx
+++ b/Source/CursesDialog/cmCursesBoolWidget.cxx
@@ -16,7 +16,7 @@ cmCursesBoolWidget::cmCursesBoolWidget(int width, int height,
int left, int top) :
cmCursesWidget(width, height, left, top)
{
- this->Type = cmCacheManager::BOOL;
+ this->Type = cmState::BOOL;
set_field_fore(this->Field, A_NORMAL);
set_field_back(this->Field, A_STANDOUT);
field_opts_off(this->Field, O_STATIC);
diff --git a/Source/CursesDialog/cmCursesCacheEntryComposite.cxx b/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
index 4f028c4..7e09242 100644
--- a/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
+++ b/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
@@ -19,6 +19,7 @@
#include "cmCursesDummyWidget.h"
#include "../cmSystemTools.h"
#include "../cmake.h"
+#include "../cmState.h"
#include <assert.h>
@@ -50,11 +51,11 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
}
this->Entry = 0;
- const char* value = cm->GetCacheManager()->GetCacheEntryValue(key);
+ const char* value = cm->GetState()->GetCacheEntryValue(key);
assert(value);
- switch (cm->GetCacheManager()->GetCacheEntryType(key))
+ switch (cm->GetState()->GetCacheEntryType(key))
{
- case cmCacheManager::BOOL:
+ case cmState::BOOL:
this->Entry = new cmCursesBoolWidget(this->EntryWidth, 1, 1, 1);
if (cmSystemTools::IsOn(value))
{
@@ -65,17 +66,17 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
static_cast<cmCursesBoolWidget*>(this->Entry)->SetValueAsBool(false);
}
break;
- case cmCacheManager::PATH:
+ case cmState::PATH:
this->Entry = new cmCursesPathWidget(this->EntryWidth, 1, 1, 1);
static_cast<cmCursesPathWidget*>(this->Entry)->SetString(value);
break;
- case cmCacheManager::FILEPATH:
+ case cmState::FILEPATH:
this->Entry = new cmCursesFilePathWidget(this->EntryWidth, 1, 1, 1);
static_cast<cmCursesFilePathWidget*>(this->Entry)->SetString(value);
break;
- case cmCacheManager::STRING:
+ case cmState::STRING:
{
- const char* stringsProp = cm->GetCacheManager()
+ const char* stringsProp = cm->GetState()
->GetCacheEntryProperty(key, "STRINGS");
if(stringsProp)
{
@@ -98,7 +99,7 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
}
break;
}
- case cmCacheManager::UNINITIALIZED:
+ case cmState::UNINITIALIZED:
cmSystemTools::Error("Found an undefined variable: ",
key.c_str());
break;
diff --git a/Source/CursesDialog/cmCursesCacheEntryComposite.h b/Source/CursesDialog/cmCursesCacheEntryComposite.h
index dc4ee4af..f280897 100644
--- a/Source/CursesDialog/cmCursesCacheEntryComposite.h
+++ b/Source/CursesDialog/cmCursesCacheEntryComposite.h
@@ -12,7 +12,6 @@
#ifndef cmCursesCacheEntryComposite_h
#define cmCursesCacheEntryComposite_h
-#include "../cmCacheManager.h"
#include "cmCursesLabelWidget.h"
class cmCursesCacheEntryComposite
diff --git a/Source/CursesDialog/cmCursesDummyWidget.cxx b/Source/CursesDialog/cmCursesDummyWidget.cxx
index 60086a5..9801e4d 100644
--- a/Source/CursesDialog/cmCursesDummyWidget.cxx
+++ b/Source/CursesDialog/cmCursesDummyWidget.cxx
@@ -15,7 +15,7 @@ cmCursesDummyWidget::cmCursesDummyWidget(int width, int height,
int left, int top) :
cmCursesWidget(width, height, left, top)
{
- this->Type = cmCacheManager::INTERNAL;
+ this->Type = cmState::INTERNAL;
}
diff --git a/Source/CursesDialog/cmCursesFilePathWidget.cxx b/Source/CursesDialog/cmCursesFilePathWidget.cxx
index 01db014..51ed670 100644
--- a/Source/CursesDialog/cmCursesFilePathWidget.cxx
+++ b/Source/CursesDialog/cmCursesFilePathWidget.cxx
@@ -15,6 +15,6 @@ cmCursesFilePathWidget::cmCursesFilePathWidget(int width, int height,
int left, int top) :
cmCursesPathWidget(width, height, left, top)
{
- this->Type = cmCacheManager::FILEPATH;
+ this->Type = cmState::FILEPATH;
}
diff --git a/Source/CursesDialog/cmCursesLongMessageForm.cxx b/Source/CursesDialog/cmCursesLongMessageForm.cxx
index 057f8f3..67e4aab 100644
--- a/Source/CursesDialog/cmCursesLongMessageForm.cxx
+++ b/Source/CursesDialog/cmCursesLongMessageForm.cxx
@@ -9,7 +9,6 @@
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
-#include "../cmCacheManager.h"
#include "../cmSystemTools.h"
#include "../cmake.h"
#include "../cmVersion.h"
diff --git a/Source/CursesDialog/cmCursesMainForm.cxx b/Source/CursesDialog/cmCursesMainForm.cxx
index 833d540..be17a9f 100644
--- a/Source/CursesDialog/cmCursesMainForm.cxx
+++ b/Source/CursesDialog/cmCursesMainForm.cxx
@@ -9,7 +9,6 @@
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
-#include "../cmCacheManager.h"
#include "../cmSystemTools.h"
#include "../cmVersion.h"
#include "../cmake.h"
@@ -23,6 +22,7 @@
#include "cmCursesCacheEntryComposite.h"
#include "cmCursesLongMessageForm.h"
#include "cmAlgorithms.h"
+#include "cmState.h"
inline int ctrl(int z)
@@ -107,21 +107,21 @@ void cmCursesMainForm::InitializeUI()
// which contain labels, entries and new entry markers
std::vector<cmCursesCacheEntryComposite*>* newEntries =
new std::vector<cmCursesCacheEntryComposite*>;
- newEntries->reserve(this->CMakeInstance->GetCacheManager()->GetSize());
+ std::vector<std::string> cacheKeys =
+ this->CMakeInstance->GetState()->GetCacheEntryKeys();
+ newEntries->reserve(cacheKeys.size());
// Count non-internal and non-static entries
int count=0;
- std::vector<std::string> cacheKeys =
- this->CMakeInstance->GetCacheManager()->GetCacheEntryKeys();
for(std::vector<std::string>::const_iterator it = cacheKeys.begin();
it != cacheKeys.end(); ++it)
{
- cmCacheManager::CacheEntryType t = this->CMakeInstance->GetCacheManager()
+ cmState::CacheEntryType t = this->CMakeInstance->GetState()
->GetCacheEntryType(*it);
- if (t != cmCacheManager::INTERNAL &&
- t != cmCacheManager::STATIC &&
- t != cmCacheManager::UNINITIALIZED)
+ if (t != cmState::INTERNAL &&
+ t != cmState::STATIC &&
+ t != cmState::UNINITIALIZED)
{
++count;
}
@@ -147,11 +147,11 @@ void cmCursesMainForm::InitializeUI()
it != cacheKeys.end(); ++it)
{
std::string key = *it;
- cmCacheManager::CacheEntryType t = this->CMakeInstance->GetCacheManager()
+ cmState::CacheEntryType t = this->CMakeInstance->GetState()
->GetCacheEntryType(*it);
- if (t == cmCacheManager::INTERNAL ||
- t == cmCacheManager::STATIC ||
- t == cmCacheManager::UNINITIALIZED )
+ if (t == cmState::INTERNAL ||
+ t == cmState::STATIC ||
+ t == cmState::UNINITIALIZED )
{
continue;
}
@@ -171,11 +171,11 @@ void cmCursesMainForm::InitializeUI()
it != cacheKeys.end(); ++it)
{
std::string key = *it;
- cmCacheManager::CacheEntryType t = this->CMakeInstance->GetCacheManager()
+ cmState::CacheEntryType t = this->CMakeInstance->GetState()
->GetCacheEntryType(*it);
- if (t == cmCacheManager::INTERNAL ||
- t == cmCacheManager::STATIC ||
- t == cmCacheManager::UNINITIALIZED )
+ if (t == cmState::INTERNAL ||
+ t == cmState::STATIC ||
+ t == cmState::UNINITIALIZED )
{
continue;
}
@@ -225,10 +225,10 @@ void cmCursesMainForm::RePost()
for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
{
const char* existingValue =
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetState()
->GetCacheEntryValue((*it)->GetValue());
bool advanced =
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetState()
->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
if (!existingValue || (!this->AdvancedMode && advanced))
{
@@ -257,10 +257,10 @@ void cmCursesMainForm::RePost()
for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
{
const char* existingValue =
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetState()
->GetCacheEntryValue((*it)->GetValue());
bool advanced =
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetState()
->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
if (!existingValue || (!this->AdvancedMode && advanced))
{
@@ -293,9 +293,9 @@ void cmCursesMainForm::Render(int left, int top, int width, int height)
cmCursesWidget* cw = reinterpret_cast<cmCursesWidget*>
(field_userptr(currentField));
// If in edit mode, get out of it
- if ( cw->GetType() == cmCacheManager::STRING ||
- cw->GetType() == cmCacheManager::PATH ||
- cw->GetType() == cmCacheManager::FILEPATH )
+ if ( cw->GetType() == cmState::STRING ||
+ cw->GetType() == cmState::PATH ||
+ cw->GetType() == cmState::FILEPATH )
{
cmCursesStringWidget* sw = static_cast<cmCursesStringWidget*>(cw);
sw->SetInEdit(false);
@@ -329,10 +329,10 @@ void cmCursesMainForm::Render(int left, int top, int width, int height)
for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
{
const char* existingValue =
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetState()
->GetCacheEntryValue((*it)->GetValue());
bool advanced =
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetState()
->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
if (!existingValue || (!this->AdvancedMode && advanced))
{
@@ -352,10 +352,10 @@ void cmCursesMainForm::Render(int left, int top, int width, int height)
for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
{
const char* existingValue =
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetState()
->GetCacheEntryValue((*it)->GetValue());
bool advanced =
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetState()
->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
if (!existingValue || (!this->AdvancedMode && advanced))
{
@@ -516,10 +516,10 @@ void cmCursesMainForm::UpdateStatusBar(const char* message)
// Get the help string of the current entry
// and add it to the help string
const char* existingValue =
- this->CMakeInstance->GetCacheManager()->GetCacheEntryValue(curField);
+ this->CMakeInstance->GetState()->GetCacheEntryValue(curField);
if (existingValue)
{
- const char* hs = this->CMakeInstance->GetCacheManager()
+ const char* hs = this->CMakeInstance->GetState()
->GetCacheEntryProperty(curField, "HELPSTRING");
if ( hs )
{
@@ -814,7 +814,7 @@ void cmCursesMainForm::FillCacheManagerFromUI()
for(size_t i=0; i < size; i++)
{
std::string cacheKey = (*this->Entries)[i]->Key;
- const char* existingValue = this->CMakeInstance->GetCacheManager()
+ const char* existingValue = this->CMakeInstance->GetState()
->GetCacheEntryValue(cacheKey);
if (existingValue)
{
@@ -822,8 +822,8 @@ void cmCursesMainForm::FillCacheManagerFromUI()
std::string newValue = (*this->Entries)[i]->Entry->GetValue();
std::string fixedOldValue;
std::string fixedNewValue;
- cmCacheManager::CacheEntryType t =
- this->CMakeInstance->GetCacheManager()
+ cmState::CacheEntryType t =
+ this->CMakeInstance->GetState()
->GetCacheEntryType(cacheKey);
this->FixValue(t, oldValue, fixedOldValue);
this->FixValue(t, newValue, fixedNewValue);
@@ -831,24 +831,24 @@ void cmCursesMainForm::FillCacheManagerFromUI()
if(!(fixedOldValue == fixedNewValue))
{
// The user has changed the value. Mark it as modified.
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetState()
->SetCacheEntryBoolProperty(cacheKey, "MODIFIED", true);
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetState()
->SetCacheEntryValue(cacheKey, fixedNewValue);
}
}
}
}
-void cmCursesMainForm::FixValue(cmCacheManager::CacheEntryType type,
+void cmCursesMainForm::FixValue(cmState::CacheEntryType type,
const std::string& in, std::string& out) const
{
out = in.substr(0,in.find_last_not_of(" ")+1);
- if(type == cmCacheManager::PATH || type == cmCacheManager::FILEPATH)
+ if(type == cmState::PATH || type == cmState::FILEPATH)
{
cmSystemTools::ConvertToUnixSlashes(out);
}
- if(type == cmCacheManager::BOOL)
+ if(type == cmState::BOOL)
{
if(cmSystemTools::IsOff(out.c_str()))
{
@@ -1046,11 +1046,11 @@ void cmCursesMainForm::HandleInput()
const char* helpString = 0;
const char* existingValue =
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetState()
->GetCacheEntryValue(curField);
if (existingValue)
{
- helpString = this->CMakeInstance->GetCacheManager()
+ helpString = this->CMakeInstance->GetState()
->GetCacheEntryProperty(curField, "HELPSTRING");
}
if (helpString)
@@ -1161,7 +1161,7 @@ void cmCursesMainForm::HandleInput()
field_userptr(this->Fields[findex-2]));
if ( lbl )
{
- this->CMakeInstance->GetCacheManager()->RemoveCacheEntry(lbl->GetValue());
+ this->CMakeInstance->GetState()->RemoveCacheEntry(lbl->GetValue());
std::string nextVal;
if (nextCur)
diff --git a/Source/CursesDialog/cmCursesMainForm.h b/Source/CursesDialog/cmCursesMainForm.h
index 6455252..255c823 100644
--- a/Source/CursesDialog/cmCursesMainForm.h
+++ b/Source/CursesDialog/cmCursesMainForm.h
@@ -113,7 +113,7 @@ protected:
// cache.
void FillCacheManagerFromUI();
// Fix formatting of values to a consistent form.
- void FixValue(cmCacheManager::CacheEntryType type,
+ void FixValue(cmState::CacheEntryType type,
const std::string& in, std::string& out) const;
// Re-post the existing fields. Used to toggle between
// normal and advanced modes. Render() should be called
diff --git a/Source/CursesDialog/cmCursesOptionsWidget.cxx b/Source/CursesDialog/cmCursesOptionsWidget.cxx
index 2f4b59e..30110a4 100644
--- a/Source/CursesDialog/cmCursesOptionsWidget.cxx
+++ b/Source/CursesDialog/cmCursesOptionsWidget.cxx
@@ -21,7 +21,7 @@ cmCursesOptionsWidget::cmCursesOptionsWidget(int width, int height,
int left, int top) :
cmCursesWidget(width, height, left, top)
{
- this->Type = cmCacheManager::BOOL; // this is a bit of a hack
+ this->Type = cmState::BOOL; // this is a bit of a hack
// there is no option type, and string type causes ccmake to cast
// the widget into a string widget at some point. BOOL is safe for
// now.
diff --git a/Source/CursesDialog/cmCursesPathWidget.cxx b/Source/CursesDialog/cmCursesPathWidget.cxx
index 89e2238..6116823 100644
--- a/Source/CursesDialog/cmCursesPathWidget.cxx
+++ b/Source/CursesDialog/cmCursesPathWidget.cxx
@@ -18,7 +18,7 @@ cmCursesPathWidget::cmCursesPathWidget(int width, int height,
int left, int top) :
cmCursesStringWidget(width, height, left, top)
{
- this->Type = cmCacheManager::PATH;
+ this->Type = cmState::PATH;
this->Cycle = false;
this->CurrentIndex = 0;
}
@@ -59,7 +59,7 @@ void cmCursesPathWidget::OnTab(cmCursesMainForm* fm, WINDOW* w)
}
std::vector<std::string> dirs;
- cmSystemTools::SimpleGlob(glob, dirs, (this->Type == cmCacheManager::PATH?-1:0));
+ cmSystemTools::SimpleGlob(glob, dirs, (this->Type == cmState::PATH?-1:0));
if ( this->CurrentIndex < dirs.size() )
{
cstr = dirs[this->CurrentIndex];
diff --git a/Source/CursesDialog/cmCursesStringWidget.cxx b/Source/CursesDialog/cmCursesStringWidget.cxx
index d25022d..acf262f 100644
--- a/Source/CursesDialog/cmCursesStringWidget.cxx
+++ b/Source/CursesDialog/cmCursesStringWidget.cxx
@@ -22,7 +22,7 @@ cmCursesStringWidget::cmCursesStringWidget(int width, int height,
cmCursesWidget(width, height, left, top)
{
this->InEdit = false;
- this->Type = cmCacheManager::STRING;
+ this->Type = cmState::STRING;
set_field_fore(this->Field, A_NORMAL);
set_field_back(this->Field, A_STANDOUT);
field_opts_off(this->Field, O_STATIC);
diff --git a/Source/CursesDialog/cmCursesWidget.h b/Source/CursesDialog/cmCursesWidget.h
index 7d82864..7bbdff1 100644
--- a/Source/CursesDialog/cmCursesWidget.h
+++ b/Source/CursesDialog/cmCursesWidget.h
@@ -12,7 +12,7 @@
#ifndef cmCursesWidget_h
#define cmCursesWidget_h
-#include "../cmCacheManager.h"
+#include "../cmState.h"
#include "cmCursesStandardIncludes.h"
class cmCursesMainForm;
@@ -46,7 +46,7 @@ public:
/**
* Get the type of the widget (STRING, PATH etc...)
*/
- cmCacheManager::CacheEntryType GetType()
+ cmState::CacheEntryType GetType()
{ return this->Type; }
/**
@@ -77,7 +77,7 @@ protected:
cmCursesWidget(const cmCursesWidget& from);
void operator=(const cmCursesWidget&);
- cmCacheManager::CacheEntryType Type;
+ cmState::CacheEntryType Type;
std::string Value;
FIELD* Field;
// The page in the main form this widget is in
diff --git a/Source/QtDialog/QCMake.cxx b/Source/QtDialog/QCMake.cxx
index 08d53ce..6524350 100644
--- a/Source/QtDialog/QCMake.cxx
+++ b/Source/QtDialog/QCMake.cxx
@@ -16,7 +16,7 @@
#include <QCoreApplication>
#include "cmake.h"
-#include "cmCacheManager.h"
+#include "cmState.h"
#include "cmSystemTools.h"
#include "cmExternalMakefileProjectGenerator.h"
@@ -94,7 +94,7 @@ void QCMake::setBinaryDirectory(const QString& _dir)
{
this->BinaryDirectory = QDir::fromNativeSeparators(dir);
emit this->binaryDirChanged(this->BinaryDirectory);
- cmCacheManager *cachem = this->CMakeInstance->GetCacheManager();
+ cmState* state = this->CMakeInstance->GetState();
this->setGenerator(QString());
if(!this->CMakeInstance->LoadCache(
this->BinaryDirectory.toLocal8Bit().data()))
@@ -110,15 +110,15 @@ void QCMake::setBinaryDirectory(const QString& _dir)
QCMakePropertyList props = this->properties();
emit this->propertiesChanged(props);
- const char* homeDir = cachem->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
+ const char* homeDir = state->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
if (homeDir)
{
setSourceDirectory(QString::fromLocal8Bit(homeDir));
}
- const char* gen = cachem->GetCacheEntryValue("CMAKE_GENERATOR");
+ const char* gen = state->GetCacheEntryValue("CMAKE_GENERATOR");
if (gen)
{
- const char* extraGen = cachem
+ const char* extraGen = state
->GetInitializedCacheValue("CMAKE_EXTRA_GENERATOR");
std::string curGen = cmExternalMakefileProjectGenerator::
CreateFullGeneratorName(gen, extraGen? extraGen : "");
@@ -195,14 +195,14 @@ void QCMake::setProperties(const QCMakePropertyList& newProps)
QStringList toremove;
// set the value of properties
- cmCacheManager *cachem = this->CMakeInstance->GetCacheManager();
- std::vector<std::string> cacheKeys = cachem->GetCacheEntryKeys();
+ cmState* state = this->CMakeInstance->GetState();
+ std::vector<std::string> cacheKeys = state->GetCacheEntryKeys();
for(std::vector<std::string>::const_iterator it = cacheKeys.begin();
it != cacheKeys.end(); ++it)
{
- cmCacheManager::CacheEntryType t = cachem->GetCacheEntryType(*it);
- if(t == cmCacheManager::INTERNAL ||
- t == cmCacheManager::STATIC)
+ cmState::CacheEntryType t = state->GetCacheEntryType(*it);
+ if(t == cmState::INTERNAL ||
+ t == cmState::STATIC)
{
continue;
}
@@ -219,11 +219,11 @@ void QCMake::setProperties(const QCMakePropertyList& newProps)
prop = props[idx];
if(prop.Value.type() == QVariant::Bool)
{
- cachem->SetCacheEntryValue(*it, prop.Value.toBool() ? "ON" : "OFF");
+ state->SetCacheEntryValue(*it, prop.Value.toBool() ? "ON" : "OFF");
}
else
{
- cachem->SetCacheEntryValue(*it,
+ state->SetCacheEntryValue(*it,
prop.Value.toString().toLocal8Bit().data());
}
props.removeAt(idx);
@@ -236,7 +236,7 @@ void QCMake::setProperties(const QCMakePropertyList& newProps)
{
this->CMakeInstance->UnwatchUnusedCli(s.toLocal8Bit().data());
- cachem->RemoveCacheEntry(s.toLocal8Bit().data());
+ state->RemoveCacheEntry(s.toLocal8Bit().data());
}
// add some new properites
@@ -249,28 +249,28 @@ void QCMake::setProperties(const QCMakePropertyList& newProps)
this->CMakeInstance->AddCacheEntry(s.Key.toLocal8Bit().data(),
s.Value.toBool() ? "ON" : "OFF",
s.Help.toLocal8Bit().data(),
- cmCacheManager::BOOL);
+ cmState::BOOL);
}
else if(s.Type == QCMakeProperty::STRING)
{
this->CMakeInstance->AddCacheEntry(s.Key.toLocal8Bit().data(),
s.Value.toString().toLocal8Bit().data(),
s.Help.toLocal8Bit().data(),
- cmCacheManager::STRING);
+ cmState::STRING);
}
else if(s.Type == QCMakeProperty::PATH)
{
this->CMakeInstance->AddCacheEntry(s.Key.toLocal8Bit().data(),
s.Value.toString().toLocal8Bit().data(),
s.Help.toLocal8Bit().data(),
- cmCacheManager::PATH);
+ cmState::PATH);
}
else if(s.Type == QCMakeProperty::FILEPATH)
{
this->CMakeInstance->AddCacheEntry(s.Key.toLocal8Bit().data(),
s.Value.toString().toLocal8Bit().data(),
s.Help.toLocal8Bit().data(),
- cmCacheManager::FILEPATH);
+ cmState::FILEPATH);
}
}
@@ -281,45 +281,45 @@ QCMakePropertyList QCMake::properties() const
{
QCMakePropertyList ret;
- cmCacheManager *cachem = this->CMakeInstance->GetCacheManager();
- std::vector<std::string> cacheKeys = cachem->GetCacheEntryKeys();
+ cmState* state = this->CMakeInstance->GetState();
+ std::vector<std::string> cacheKeys = state->GetCacheEntryKeys();
for (std::vector<std::string>::const_iterator i = cacheKeys.begin();
i != cacheKeys.end(); ++i)
{
- cmCacheManager::CacheEntryType t = cachem->GetCacheEntryType(*i);
- if(t == cmCacheManager::INTERNAL ||
- t == cmCacheManager::STATIC ||
- t == cmCacheManager::UNINITIALIZED)
+ cmState::CacheEntryType t = state->GetCacheEntryType(*i);
+ if(t == cmState::INTERNAL ||
+ t == cmState::STATIC ||
+ t == cmState::UNINITIALIZED)
{
continue;
}
- const char* cachedValue = cachem->GetCacheEntryValue(*i);
+ const char* cachedValue = state->GetCacheEntryValue(*i);
QCMakeProperty prop;
prop.Key = QString::fromLocal8Bit(i->c_str());
prop.Help = QString::fromLocal8Bit(
- cachem->GetCacheEntryProperty(*i, "HELPSTRING"));
+ state->GetCacheEntryProperty(*i, "HELPSTRING"));
prop.Value = QString::fromLocal8Bit(cachedValue);
- prop.Advanced = cachem->GetCacheEntryPropertyAsBool(*i, "ADVANCED");
- if(t == cmCacheManager::BOOL)
+ prop.Advanced = state->GetCacheEntryPropertyAsBool(*i, "ADVANCED");
+ if(t == cmState::BOOL)
{
prop.Type = QCMakeProperty::BOOL;
prop.Value = cmSystemTools::IsOn(cachedValue);
}
- else if(t == cmCacheManager::PATH)
+ else if(t == cmState::PATH)
{
prop.Type = QCMakeProperty::PATH;
}
- else if(t == cmCacheManager::FILEPATH)
+ else if(t == cmState::FILEPATH)
{
prop.Type = QCMakeProperty::FILEPATH;
}
- else if(t == cmCacheManager::STRING)
+ else if(t == cmState::STRING)
{
prop.Type = QCMakeProperty::STRING;
const char* stringsProperty =
- cachem->GetCacheEntryProperty(*i, "STRINGS");
+ state->GetCacheEntryProperty(*i, "STRINGS");
if (stringsProperty)
{
prop.Strings = QString::fromLocal8Bit(stringsProperty).split(";");
diff --git a/Source/cmBuildCommand.cxx b/Source/cmBuildCommand.cxx
index 5d32437..cdca792 100644
--- a/Source/cmBuildCommand.cxx
+++ b/Source/cmBuildCommand.cxx
@@ -147,6 +147,6 @@ bool cmBuildCommand
makecommand.c_str(),
"Command used to build entire project "
"from the command line.",
- cmCacheManager::STRING);
+ cmState::STRING);
return true;
}
diff --git a/Source/cmBuildNameCommand.cxx b/Source/cmBuildNameCommand.cxx
index 171ed0f..2a06574 100644
--- a/Source/cmBuildNameCommand.cxx
+++ b/Source/cmBuildNameCommand.cxx
@@ -39,7 +39,7 @@ bool cmBuildNameCommand
this->Makefile->AddCacheDefinition(args[0],
cv.c_str(),
"Name of build.",
- cmCacheManager::STRING);
+ cmState::STRING);
}
return true;
}
@@ -74,7 +74,7 @@ bool cmBuildNameCommand
this->Makefile->AddCacheDefinition(args[0],
buildname.c_str(),
"Name of build.",
- cmCacheManager::STRING);
+ cmState::STRING);
return true;
}
diff --git a/Source/cmCPluginAPI.cxx b/Source/cmCPluginAPI.cxx
index 987a7b1..5ae7d4c 100644
--- a/Source/cmCPluginAPI.cxx
+++ b/Source/cmCPluginAPI.cxx
@@ -87,27 +87,27 @@ void CCONV cmAddCacheDefinition(void *arg, const char* name,
{
case CM_CACHE_BOOL:
mf->AddCacheDefinition(name,value,doc,
- cmCacheManager::BOOL);
+ cmState::BOOL);
break;
case CM_CACHE_PATH:
mf->AddCacheDefinition(name,value,doc,
- cmCacheManager::PATH);
+ cmState::PATH);
break;
case CM_CACHE_FILEPATH:
mf->AddCacheDefinition(name,value,doc,
- cmCacheManager::FILEPATH);
+ cmState::FILEPATH);
break;
case CM_CACHE_STRING:
mf->AddCacheDefinition(name,value,doc,
- cmCacheManager::STRING);
+ cmState::STRING);
break;
case CM_CACHE_INTERNAL:
mf->AddCacheDefinition(name,value,doc,
- cmCacheManager::INTERNAL);
+ cmState::INTERNAL);
break;
case CM_CACHE_STATIC:
mf->AddCacheDefinition(name,value,doc,
- cmCacheManager::STATIC);
+ cmState::STATIC);
break;
}
}
diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx
index 1db057b..6715638 100644
--- a/Source/cmCTest.cxx
+++ b/Source/cmCTest.cxx
@@ -2279,7 +2279,7 @@ bool cmCTest::AddVariableDefinition(const std::string &arg)
{
std::string name;
std::string value;
- cmCacheManager::CacheEntryType type = cmCacheManager::UNINITIALIZED;
+ cmState::CacheEntryType type = cmState::UNINITIALIZED;
if (cmake::ParseCacheEntry(arg, name, value, type))
{
diff --git a/Source/cmCacheManager.cxx b/Source/cmCacheManager.cxx
index 5387d0c..289d0dc 100644
--- a/Source/cmCacheManager.cxx
+++ b/Source/cmCacheManager.cxx
@@ -22,17 +22,6 @@
#include <cmsys/FStream.hxx>
#include <cmsys/RegularExpression.hxx>
-const char* cmCacheManagerTypes[] =
-{ "BOOL",
- "PATH",
- "FILEPATH",
- "STRING",
- "INTERNAL",
- "STATIC",
- "UNINITIALIZED",
- 0
-};
-
cmCacheManager::cmCacheManager(cmake* cm)
{
this->CacheMajorVersion = 0;
@@ -40,41 +29,6 @@ cmCacheManager::cmCacheManager(cmake* cm)
this->CMakeInstance = cm;
}
-const char* cmCacheManager::TypeToString(cmCacheManager::CacheEntryType type)
-{
- if ( type > 6 )
- {
- return cmCacheManagerTypes[6];
- }
- return cmCacheManagerTypes[type];
-}
-
-cmCacheManager::CacheEntryType cmCacheManager::StringToType(const char* s)
-{
- int i = 0;
- while(cmCacheManagerTypes[i])
- {
- if(strcmp(s, cmCacheManagerTypes[i]) == 0)
- {
- return static_cast<CacheEntryType>(i);
- }
- ++i;
- }
- return STRING;
-}
-
-bool cmCacheManager::IsType(const char* s)
-{
- for(int i=0; cmCacheManagerTypes[i]; ++i)
- {
- if(strcmp(s, cmCacheManagerTypes[i]) == 0)
- {
- return true;
- }
- }
- return false;
-}
-
bool cmCacheManager::LoadCache(const std::string& path)
{
std::set<std::string> emptySet;
@@ -122,7 +76,7 @@ static bool ParseEntryWithoutType(const std::string& entry,
bool cmCacheManager::ParseEntry(const std::string& entry,
std::string& var,
std::string& value,
- CacheEntryType& type)
+ cmState::CacheEntryType& type)
{
// input line is: key:type=value
static cmsys::RegularExpression reg(
@@ -134,14 +88,14 @@ bool cmCacheManager::ParseEntry(const std::string& entry,
if(regQuoted.find(entry))
{
var = regQuoted.match(1);
- type = cmCacheManager::StringToType(regQuoted.match(2).c_str());
+ type = cmState::StringToCacheEntryType(regQuoted.match(2).c_str());
value = regQuoted.match(3);
flag = true;
}
else if (reg.find(entry))
{
var = reg.match(1);
- type = cmCacheManager::StringToType(reg.match(2).c_str());
+ type = cmState::StringToCacheEntryType(reg.match(2).c_str());
value = reg.match(3);
flag = true;
}
@@ -250,7 +204,7 @@ bool cmCacheManager::LoadCache(const std::string& path,
// If the entry is not internal to the cache being loaded
// or if it is in the list of internal entries to be
// imported, load it.
- if ( internal || (e.Type != INTERNAL) ||
+ if ( internal || (e.Type != cmState::INTERNAL) ||
(includes.find(entryKey) != includes.end()) )
{
// If we are loading the cache from another project,
@@ -258,7 +212,7 @@ bool cmCacheManager::LoadCache(const std::string& path,
// not visible in the gui
if (!internal)
{
- e.Type = INTERNAL;
+ e.Type = cmState::INTERNAL;
helpString = "DO NOT EDIT, ";
helpString += entryKey;
helpString += " loaded from external file. "
@@ -306,10 +260,10 @@ bool cmCacheManager::LoadCache(const std::string& path,
// Set as version 0.0
this->AddCacheEntry("CMAKE_CACHE_MINOR_VERSION", "0",
"Minor version of cmake used to create the "
- "current loaded cache", cmCacheManager::INTERNAL);
+ "current loaded cache", cmState::INTERNAL);
this->AddCacheEntry("CMAKE_CACHE_MAJOR_VERSION", "0",
"Major version of cmake used to create the "
- "current loaded cache", cmCacheManager::INTERNAL);
+ "current loaded cache", cmState::INTERNAL);
}
// check to make sure the cache directory has not
@@ -351,7 +305,7 @@ bool cmCacheManager::ReadPropertyEntry(std::string const& entryKey,
CacheEntry& e)
{
// All property entries are internal.
- if(e.Type != cmCacheManager::INTERNAL)
+ if(e.Type != cmState::INTERNAL)
{
return false;
}
@@ -370,7 +324,7 @@ bool cmCacheManager::ReadPropertyEntry(std::string const& entryKey,
// Create an entry and store the property.
CacheEntry& ne = this->Cache[key];
ne.Properties.SetCMakeInstance(this->CMakeInstance);
- ne.Type = cmCacheManager::UNINITIALIZED;
+ ne.Type = cmState::UNINITIALIZED;
ne.SetProperty(*p, e.Value.c_str());
}
else
@@ -427,15 +381,15 @@ bool cmCacheManager::SaveCache(const std::string& path)
sprintf(temp, "%d", cmVersion::GetMinorVersion());
this->AddCacheEntry("CMAKE_CACHE_MINOR_VERSION", temp,
"Minor version of cmake used to create the "
- "current loaded cache", cmCacheManager::INTERNAL);
+ "current loaded cache", cmState::INTERNAL);
sprintf(temp, "%d", cmVersion::GetMajorVersion());
this->AddCacheEntry("CMAKE_CACHE_MAJOR_VERSION", temp,
"Major version of cmake used to create the "
- "current loaded cache", cmCacheManager::INTERNAL);
+ "current loaded cache", cmState::INTERNAL);
sprintf(temp, "%d", cmVersion::GetPatchVersion());
this->AddCacheEntry("CMAKE_CACHE_PATCH_VERSION", temp,
"Patch version of cmake used to create the "
- "current loaded cache", cmCacheManager::INTERNAL);
+ "current loaded cache", cmState::INTERNAL);
// Let us store the current working directory so that if somebody
// Copies it, he will not be surprised
@@ -450,7 +404,7 @@ bool cmCacheManager::SaveCache(const std::string& path)
cmSystemTools::ConvertToUnixSlashes(currentcwd);
this->AddCacheEntry("CMAKE_CACHEFILE_DIR", currentcwd.c_str(),
"This is the directory where this CMakeCache.txt"
- " was created", cmCacheManager::INTERNAL);
+ " was created", cmState::INTERNAL);
fout << "# This is the CMakeCache file.\n"
<< "# For build in directory: " << currentcwd << "\n";
@@ -484,7 +438,7 @@ bool cmCacheManager::SaveCache(const std::string& path)
this->Cache.begin(); i != this->Cache.end(); ++i)
{
const CacheEntry& ce = (*i).second;
- CacheEntryType t = ce.Type;
+ cmState::CacheEntryType t = ce.Type;
if(!ce.Initialized)
{
/*
@@ -493,7 +447,7 @@ bool cmCacheManager::SaveCache(const std::string& path)
"\" is uninitialized");
*/
}
- else if(t != INTERNAL)
+ else if(t != cmState::INTERNAL)
{
// Format is key:type=value
if(const char* help = ce.GetProperty("HELPSTRING"))
@@ -505,7 +459,7 @@ bool cmCacheManager::SaveCache(const std::string& path)
cmCacheManager::OutputHelpString(fout, "Missing description");
}
this->OutputKey(fout, i->first);
- fout << ":" << cmCacheManagerTypes[t] << "=";
+ fout << ":" << cmState::CacheEntryTypeToString(t) << "=";
this->OutputValue(fout, ce.Value);
fout << "\n\n";
}
@@ -525,9 +479,9 @@ bool cmCacheManager::SaveCache(const std::string& path)
continue;
}
- CacheEntryType t = i.GetType();
+ cmState::CacheEntryType t = i.GetType();
this->WritePropertyEntries(fout, i);
- if(t == cmCacheManager::INTERNAL)
+ if(t == cmState::INTERNAL)
{
// Format is key:type=value
if(const char* help = i.GetProperty("HELPSTRING"))
@@ -535,7 +489,7 @@ bool cmCacheManager::SaveCache(const std::string& path)
this->OutputHelpString(fout, help);
}
this->OutputKey(fout, i.GetName());
- fout << ":" << cmCacheManagerTypes[t] << "=";
+ fout << ":" << cmState::CacheEntryTypeToString(t) << "=";
this->OutputValue(fout, i.GetValue());
fout << "\n";
}
@@ -677,7 +631,7 @@ void cmCacheManager::PrintCache(std::ostream& out) const
for(std::map<std::string, CacheEntry>::const_iterator i =
this->Cache.begin(); i != this->Cache.end(); ++i)
{
- if((*i).second.Type != INTERNAL)
+ if((*i).second.Type != cmState::INTERNAL)
{
out << (*i).first << " = " << (*i).second.Value
<< std::endl;
@@ -693,7 +647,7 @@ void cmCacheManager::PrintCache(std::ostream& out) const
void cmCacheManager::AddCacheEntry(const std::string& key,
const char* value,
const char* helpString,
- CacheEntryType type)
+ cmState::CacheEntryType type)
{
CacheEntry& e = this->Cache[key];
e.Properties.SetCMakeInstance(this->CMakeInstance);
@@ -708,7 +662,7 @@ void cmCacheManager::AddCacheEntry(const std::string& key,
}
e.Type = type;
// make sure we only use unix style paths
- if(type == FILEPATH || type == PATH)
+ if(type == cmState::FILEPATH || type == cmState::PATH)
{
if(e.Value.find(';') != e.Value.npos)
{
@@ -789,7 +743,7 @@ cmCacheManager::CacheEntry::GetProperty(const std::string& prop) const
{
if(prop == "TYPE")
{
- return cmCacheManagerTypes[this->Type];
+ return cmState::CacheEntryTypeToString(this->Type);
}
else if(prop == "VALUE")
{
@@ -806,7 +760,7 @@ void cmCacheManager::CacheEntry::SetProperty(const std::string& prop,
{
if(prop == "TYPE")
{
- this->Type = cmCacheManager::StringToType(value? value : "STRING");
+ this->Type = cmState::StringToCacheEntryType(value? value : "STRING");
}
else if(prop == "VALUE")
{
@@ -825,7 +779,7 @@ void cmCacheManager::CacheEntry::AppendProperty(const std::string& prop,
{
if(prop == "TYPE")
{
- this->Type = cmCacheManager::StringToType(value? value : "STRING");
+ this->Type = cmState::StringToCacheEntryType(value? value : "STRING");
}
else if(prop == "VALUE")
{
diff --git a/Source/cmCacheManager.h b/Source/cmCacheManager.h
index 3b02fa6..8462259 100644
--- a/Source/cmCacheManager.h
+++ b/Source/cmCacheManager.h
@@ -14,6 +14,8 @@
#include "cmStandardIncludes.h"
#include "cmPropertyMap.h"
+#include "cmState.h"
+
class cmMakefile;
class cmMarkAsAdvancedCommand;
class cmake;
@@ -30,21 +32,22 @@ public:
cmCacheManager(cmake* cm);
class CacheIterator;
friend class cmCacheManager::CacheIterator;
- enum CacheEntryType{ BOOL=0, PATH, FILEPATH, STRING, INTERNAL,STATIC,
- UNINITIALIZED };
private:
struct CacheEntry
{
std::string Value;
- CacheEntryType Type;
+ cmState::CacheEntryType Type;
cmPropertyMap Properties;
const char* GetProperty(const std::string&) const;
void SetProperty(const std::string& property, const char* value);
void AppendProperty(const std::string& property, const char* value,
bool asString=false);
bool Initialized;
- CacheEntry() : Value(""), Type(UNINITIALIZED), Initialized(false)
+ CacheEntry()
+ : Value(""),
+ Type(cmState::UNINITIALIZED),
+ Initialized(false)
{}
};
@@ -68,8 +71,10 @@ public:
const char* GetValue() const { return this->GetEntry().Value.c_str(); }
bool GetValueAsBool() const;
void SetValue(const char*);
- CacheEntryType GetType() const { return this->GetEntry().Type; }
- void SetType(CacheEntryType ty) { this->GetEntry().Type = ty; }
+ cmState::CacheEntryType GetType() const
+ { return this->GetEntry().Type; }
+ void SetType(cmState::CacheEntryType ty)
+ { this->GetEntry().Type = ty; }
bool Initialized() { return this->GetEntry().Initialized; }
cmCacheManager &Container;
std::map<std::string, CacheEntry>::iterator Position;
@@ -94,17 +99,6 @@ public:
return CacheIterator(*this);
}
- /**
- * Types for the cache entries. These are useful as
- * hints for a cache editor program. Path should bring
- * up a file chooser, BOOL a check box, and STRING a
- * text entry box, FILEPATH is a full path to a file which
- * can be different than just a path input
- */
- static CacheEntryType StringToType(const char*);
- static const char* TypeToString(CacheEntryType);
- static bool IsType(const char*);
-
///! Load a cache for given makefile. Loads from path/CMakeCache.txt.
bool LoadCache(const std::string& path);
bool LoadCache(const std::string& path, bool internal,
@@ -134,7 +128,7 @@ public:
static bool ParseEntry(const std::string& entry,
std::string& var,
std::string& value,
- CacheEntryType& type);
+ cmState::CacheEntryType& type);
///! Get a value from the cache given a key
const char* GetInitializedCacheValue(const std::string& key) const;
@@ -155,7 +149,7 @@ public:
return this->GetCacheIterator(key.c_str()).GetProperty(propName);
}
- CacheEntryType GetCacheEntryType(std::string const& key)
+ cmState::CacheEntryType GetCacheEntryType(std::string const& key)
{
return this->GetCacheIterator(key.c_str()).GetType();
}
@@ -223,7 +217,8 @@ public:
protected:
///! Add an entry into the cache
void AddCacheEntry(const std::string& key, const char* value,
- const char* helpString, CacheEntryType type);
+ const char* helpString,
+ cmState::CacheEntryType type);
///! Get a cache entry object for a key
CacheEntry *GetCacheEntry(const std::string& key);
@@ -248,9 +243,8 @@ private:
CacheEntryMap Cache;
// 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
};
#endif
diff --git a/Source/cmCommandArgumentParserHelper.cxx b/Source/cmCommandArgumentParserHelper.cxx
index 99bf5f5..0d1c86d 100644
--- a/Source/cmCommandArgumentParserHelper.cxx
+++ b/Source/cmCommandArgumentParserHelper.cxx
@@ -13,6 +13,7 @@
#include "cmSystemTools.h"
#include "cmMakefile.h"
+#include "cmState.h"
#include "cmCommandArgumentLexer.h"
@@ -90,7 +91,7 @@ char* cmCommandArgumentParserHelper::ExpandSpecialVariable(const char* key,
}
if ( strcmp(key, "CACHE") == 0 )
{
- if(const char* c = this->Makefile->GetCacheManager()
+ if(const char* c = this->Makefile->GetState()
->GetInitializedCacheValue(var))
{
if(this->EscapeQuotes)
diff --git a/Source/cmCoreTryCompile.cxx b/Source/cmCoreTryCompile.cxx
index 59efa52..56a884c 100644
--- a/Source/cmCoreTryCompile.cxx
+++ b/Source/cmCoreTryCompile.cxx
@@ -11,7 +11,6 @@
============================================================================*/
#include "cmCoreTryCompile.h"
#include "cmake.h"
-#include "cmCacheManager.h"
#include "cmLocalGenerator.h"
#include "cmGlobalGenerator.h"
#include "cmAlgorithms.h"
@@ -527,7 +526,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv)
this->Makefile->AddCacheDefinition(argv[0],
(res == 0 ? "TRUE" : "FALSE"),
"Result of TRY_COMPILE",
- cmCacheManager::INTERNAL);
+ cmState::INTERNAL);
if (!outputVariable.empty())
{
diff --git a/Source/cmExtraEclipseCDT4Generator.cxx b/Source/cmExtraEclipseCDT4Generator.cxx
index 0d32e4b..35b70e8 100644
--- a/Source/cmExtraEclipseCDT4Generator.cxx
+++ b/Source/cmExtraEclipseCDT4Generator.cxx
@@ -16,6 +16,7 @@
#include "cmLocalUnixMakefileGenerator3.h"
#include "cmMakefile.h"
#include "cmGeneratedFileStream.h"
+#include "cmState.h"
#include "cmTarget.h"
#include "cmSourceFile.h"
@@ -205,7 +206,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout,
std::string cacheEntryName = "CMAKE_ECLIPSE_ENVVAR_";
cacheEntryName += envVar;
- const char* cacheValue = mf->GetCacheManager()->GetInitializedCacheValue(
+ const char* cacheValue = mf->GetState()->GetInitializedCacheValue(
cacheEntryName);
// now we have both, decide which one to use
@@ -221,7 +222,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout,
// in the cache
valueToUse = envVarValue;
mf->AddCacheDefinition(cacheEntryName, valueToUse.c_str(),
- cacheEntryName.c_str(), cmCacheManager::STRING,
+ cacheEntryName.c_str(), cmState::STRING,
true);
mf->GetCMakeInstance()->SaveCache(mf->GetHomeOutputDirectory());
}
@@ -242,7 +243,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout,
{
valueToUse = envVarValue;
mf->AddCacheDefinition(cacheEntryName, valueToUse.c_str(),
- cacheEntryName.c_str(), cmCacheManager::STRING,
+ cacheEntryName.c_str(), cmState::STRING,
true);
mf->GetCMakeInstance()->SaveCache(mf->GetHomeOutputDirectory());
}
diff --git a/Source/cmFindBase.cxx b/Source/cmFindBase.cxx
index cc08052..add06a7 100644
--- a/Source/cmFindBase.cxx
+++ b/Source/cmFindBase.cxx
@@ -12,6 +12,7 @@
#include "cmFindBase.h"
#include "cmAlgorithms.h"
+#include "cmState.h"
cmFindBase::cmFindBase()
{
@@ -366,8 +367,8 @@ bool cmFindBase::CheckForVariableInCache()
if(const char* cacheValue =
this->Makefile->GetDefinition(this->VariableName))
{
- cmCacheManager* manager = this->Makefile->GetCacheManager();
- const char* cacheEntry = manager->GetCacheEntryValue(this->VariableName);
+ cmState* state = this->Makefile->GetState();
+ const char* cacheEntry = state->GetCacheEntryValue(this->VariableName);
bool found = !cmSystemTools::IsNOTFOUND(cacheValue);
bool cached = cacheEntry ? true : false;
if(found)
@@ -376,8 +377,8 @@ bool cmFindBase::CheckForVariableInCache()
// type we should add the type and docstring but keep the
// original value. Tell the subclass implementations to do
// this.
- if(cached && manager->GetCacheEntryType(this->VariableName)
- == cmCacheManager::UNINITIALIZED)
+ if(cached && state->GetCacheEntryType(this->VariableName)
+ == cmState::UNINITIALIZED)
{
this->AlreadyInCacheWithoutMetaInfo = true;
}
@@ -385,7 +386,7 @@ bool cmFindBase::CheckForVariableInCache()
}
else if(cached)
{
- const char* hs = manager->GetCacheEntryProperty(this->VariableName,
+ const char* hs = state->GetCacheEntryProperty(this->VariableName,
"HELPSTRING");
this->VariableDocumentation = hs?hs:"(none)";
}
diff --git a/Source/cmFindLibraryCommand.cxx b/Source/cmFindLibraryCommand.cxx
index c499f61..ef8340b 100644
--- a/Source/cmFindLibraryCommand.cxx
+++ b/Source/cmFindLibraryCommand.cxx
@@ -10,7 +10,6 @@
See the License for more information.
============================================================================*/
#include "cmFindLibraryCommand.h"
-#include "cmCacheManager.h"
#include <cmsys/Directory.hxx>
#include <cmsys/stl/algorithm>
@@ -39,7 +38,7 @@ bool cmFindLibraryCommand
{
this->Makefile->AddCacheDefinition(this->VariableName, "",
this->VariableDocumentation.c_str(),
- cmCacheManager::FILEPATH);
+ cmState::FILEPATH);
}
return true;
}
@@ -72,14 +71,14 @@ bool cmFindLibraryCommand
this->Makefile->AddCacheDefinition(this->VariableName,
library.c_str(),
this->VariableDocumentation.c_str(),
- cmCacheManager::FILEPATH);
+ cmState::FILEPATH);
return true;
}
std::string notfound = this->VariableName + "-NOTFOUND";
this->Makefile->AddCacheDefinition(this->VariableName,
notfound.c_str(),
this->VariableDocumentation.c_str(),
- cmCacheManager::FILEPATH);
+ cmState::FILEPATH);
return true;
}
diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx
index 4d7fd60..b32f5fd 100644
--- a/Source/cmFindPackageCommand.cxx
+++ b/Source/cmFindPackageCommand.cxx
@@ -947,7 +947,7 @@ bool cmFindPackageCommand::FindConfig()
// We force the value since we do not get here if it was already set.
this->Makefile->AddCacheDefinition(this->Variable,
init.c_str(), help.c_str(),
- cmCacheManager::PATH, true);
+ cmState::PATH, true);
return found;
}
diff --git a/Source/cmFindPathCommand.cxx b/Source/cmFindPathCommand.cxx
index 49fbf45..1f3d1a4 100644
--- a/Source/cmFindPathCommand.cxx
+++ b/Source/cmFindPathCommand.cxx
@@ -10,7 +10,6 @@
See the License for more information.
============================================================================*/
#include "cmFindPathCommand.h"
-#include "cmCacheManager.h"
#include <cmsys/Glob.hxx>
@@ -41,7 +40,7 @@ bool cmFindPathCommand
this->VariableName, "",
this->VariableDocumentation.c_str(),
(this->IncludeFileInPath ?
- cmCacheManager::FILEPATH :cmCacheManager::PATH)
+ cmState::FILEPATH :cmState::PATH)
);
}
return true;
@@ -54,7 +53,7 @@ bool cmFindPathCommand
(this->VariableName, result.c_str(),
this->VariableDocumentation.c_str(),
(this->IncludeFileInPath) ?
- cmCacheManager::FILEPATH :cmCacheManager::PATH);
+ cmState::FILEPATH :cmState::PATH);
return true;
}
this->Makefile->AddCacheDefinition
@@ -62,7 +61,7 @@ bool cmFindPathCommand
(this->VariableName + "-NOTFOUND").c_str(),
this->VariableDocumentation.c_str(),
(this->IncludeFileInPath) ?
- cmCacheManager::FILEPATH :cmCacheManager::PATH);
+ cmState::FILEPATH :cmState::PATH);
return true;
}
diff --git a/Source/cmFindProgramCommand.cxx b/Source/cmFindProgramCommand.cxx
index 4ee419c..fbd9fd3 100644
--- a/Source/cmFindProgramCommand.cxx
+++ b/Source/cmFindProgramCommand.cxx
@@ -10,7 +10,6 @@
See the License for more information.
============================================================================*/
#include "cmFindProgramCommand.h"
-#include "cmCacheManager.h"
#include <stdlib.h>
#if defined(__APPLE__)
@@ -37,7 +36,7 @@ bool cmFindProgramCommand
{
this->Makefile->AddCacheDefinition(this->VariableName, "",
this->VariableDocumentation.c_str(),
- cmCacheManager::FILEPATH);
+ cmState::FILEPATH);
}
return true;
}
@@ -49,14 +48,14 @@ bool cmFindProgramCommand
this->Makefile->AddCacheDefinition(this->VariableName,
result.c_str(),
this->VariableDocumentation.c_str(),
- cmCacheManager::FILEPATH);
+ cmState::FILEPATH);
return true;
}
this->Makefile->AddCacheDefinition(this->VariableName,
(this->VariableName + "-NOTFOUND").c_str(),
this->VariableDocumentation.c_str(),
- cmCacheManager::FILEPATH);
+ cmState::FILEPATH);
return true;
}
diff --git a/Source/cmGetFilenameComponentCommand.cxx b/Source/cmGetFilenameComponentCommand.cxx
index 9aceb39..6947a7f 100644
--- a/Source/cmGetFilenameComponentCommand.cxx
+++ b/Source/cmGetFilenameComponentCommand.cxx
@@ -117,13 +117,13 @@ bool cmGetFilenameComponentCommand
{
this->Makefile->AddCacheDefinition
(storeArgs, programArgs.c_str(),
- "", args[2] == "PATH" ? cmCacheManager::FILEPATH
- : cmCacheManager::STRING);
+ "", args[2] == "PATH" ? cmState::FILEPATH
+ : cmState::STRING);
}
this->Makefile->AddCacheDefinition
(args[0], result.c_str(), "",
- args[2] == "PATH" ? cmCacheManager::FILEPATH
- : cmCacheManager::STRING);
+ args[2] == "PATH" ? cmState::FILEPATH
+ : cmState::STRING);
}
else
{
diff --git a/Source/cmGetPropertyCommand.cxx b/Source/cmGetPropertyCommand.cxx
index 0e6e0c2..80edbcd 100644
--- a/Source/cmGetPropertyCommand.cxx
+++ b/Source/cmGetPropertyCommand.cxx
@@ -12,6 +12,7 @@
#include "cmGetPropertyCommand.h"
#include "cmake.h"
+#include "cmState.h"
#include "cmTest.h"
#include "cmGlobalGenerator.h"
#include "cmLocalGenerator.h"
@@ -391,9 +392,9 @@ bool cmGetPropertyCommand::HandleCacheMode()
}
const char* value = 0;
- if(this->Makefile->GetCacheManager()->GetCacheEntryValue(this->Name))
+ if(this->Makefile->GetState()->GetCacheEntryValue(this->Name))
{
- value = this->Makefile->GetCacheManager()
+ value = this->Makefile->GetState()
->GetCacheEntryProperty(this->Name, this->PropertyName);
}
this->StoreResult(value);
diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx
index 6a6a503..171d62a 100644
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@@ -20,6 +20,7 @@
#include "cmLocalGenerator.h"
#include "cmExternalMakefileProjectGenerator.h"
#include "cmake.h"
+#include "cmState.h"
#include "cmMakefile.h"
#include "cmQtAutoGenerators.h"
#include "cmSourceFile.h"
@@ -179,7 +180,7 @@ void cmGlobalGenerator::ResolveLanguageCompiler(const std::string &lang,
return;
}
const char* cname = this->GetCMakeInstance()->
- GetCacheManager()->GetInitializedCacheValue(langComp);
+ GetState()->GetInitializedCacheValue(langComp);
std::string changeVars;
if(cname && !optional)
{
@@ -310,7 +311,7 @@ void cmGlobalGenerator::FindMakeProgram(cmMakefile* mf)
makeProgram += saveFile;
mf->AddCacheDefinition("CMAKE_MAKE_PROGRAM", makeProgram.c_str(),
"make program",
- cmCacheManager::FILEPATH);
+ cmState::FILEPATH);
}
}
@@ -1122,7 +1123,7 @@ void cmGlobalGenerator::Configure()
sprintf(num,"%d",static_cast<int>(this->LocalGenerators.size()));
this->GetCMakeInstance()->AddCacheEntry
("CMAKE_NUMBER_OF_LOCAL_GENERATORS", num,
- "number of local generators", cmCacheManager::INTERNAL);
+ "number of local generators", cmState::INTERNAL);
// check for link libraries and include directories containing "NOTFOUND"
// and for infinite loops
@@ -1544,7 +1545,7 @@ void cmGlobalGenerator::CheckLocalGenerators()
std::map<std::string, std::string> notFoundMap;
// std::set<std::string> notFoundMap;
// after it is all done do a ConfigureFinalPass
- cmCacheManager* manager = this->GetCMakeInstance()->GetCacheManager();
+ cmState* state = this->GetCMakeInstance()->GetState();
for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
{
this->LocalGenerators[i]->ConfigureFinalPass();
@@ -1566,7 +1567,7 @@ void cmGlobalGenerator::CheckLocalGenerators()
cmSystemTools::IsNOTFOUND(lib->first.c_str()))
{
std::string varName = lib->first.substr(0, lib->first.size()-9);
- if(manager->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
+ if(state->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
{
varName += " (ADVANCED)";
}
@@ -1597,7 +1598,7 @@ void cmGlobalGenerator::CheckLocalGenerators()
cmSystemTools::IsNOTFOUND(incDir->c_str()))
{
std::string varName = incDir->substr(0, incDir->size()-9);
- if(manager->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
+ if(state->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
{
varName += " (ADVANCED)";
}
@@ -1644,7 +1645,7 @@ int cmGlobalGenerator::TryCompile(const std::string& srcdir,
// and there is a good chance that the try compile stuff will
// take the bulk of the time, so try and guess some progress
// by getting closer and closer to 100 without actually getting there.
- if (!this->CMakeInstance->GetCacheManager()->GetInitializedCacheValue
+ if (!this->CMakeInstance->GetState()->GetInitializedCacheValue
("CMAKE_NUMBER_OF_LOCAL_GENERATORS"))
{
// If CMAKE_NUMBER_OF_LOCAL_GENERATORS is not set
@@ -1842,7 +1843,7 @@ void cmGlobalGenerator::AddLocalGenerator(cmLocalGenerator *lg)
// update progress
// estimate how many lg there will be
const char *numGenC =
- this->CMakeInstance->GetCacheManager()->GetInitializedCacheValue
+ this->CMakeInstance->GetState()->GetInitializedCacheValue
("CMAKE_NUMBER_OF_LOCAL_GENERATORS");
if (!numGenC)
@@ -1900,7 +1901,7 @@ void cmGlobalGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator *gen,
gen->GetCMakeInstance()->GetCacheDefinition("CMAKE_MAKE_PROGRAM");
this->GetCMakeInstance()->AddCacheEntry("CMAKE_MAKE_PROGRAM", make,
"make program",
- cmCacheManager::FILEPATH);
+ cmState::FILEPATH);
// copy the enabled languages
this->LanguageEnabled = gen->LanguageEnabled;
this->LanguagesReady = gen->LanguagesReady;
diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx b/Source/cmGlobalUnixMakefileGenerator3.cxx
index 7648813..22d633c 100644
--- a/Source/cmGlobalUnixMakefileGenerator3.cxx
+++ b/Source/cmGlobalUnixMakefileGenerator3.cxx
@@ -97,7 +97,7 @@ std::string cmGlobalUnixMakefileGenerator3::GetEditCacheCommand() const
{
cm->AddCacheEntry
("CMAKE_EDIT_COMMAND", editCacheCommand.c_str(),
- "Path to cache edit program executable.", cmCacheManager::INTERNAL);
+ "Path to cache edit program executable.", cmState::INTERNAL);
}
}
const char* edit_cmd = cm->GetCacheDefinition("CMAKE_EDIT_COMMAND");
diff --git a/Source/cmGlobalVisualStudio7Generator.cxx b/Source/cmGlobalVisualStudio7Generator.cxx
index 0e0e63a..6a3a145 100644
--- a/Source/cmGlobalVisualStudio7Generator.cxx
+++ b/Source/cmGlobalVisualStudio7Generator.cxx
@@ -89,7 +89,7 @@ void cmGlobalVisualStudio7Generator
"Semicolon separated list of supported configuration types, "
"only supports Debug, Release, MinSizeRel, and RelWithDebInfo, "
"anything else will be ignored.",
- cmCacheManager::STRING);
+ cmState::STRING);
}
// Create list of configurations requested by user's cache, if any.
@@ -109,7 +109,7 @@ void cmGlobalVisualStudio7Generator
mf->AddCacheDefinition
("CMAKE_MSVCIDE_RUN_PATH", extraPath,
"Saved environment variable CMAKE_MSVCIDE_RUN_PATH",
- cmCacheManager::STATIC);
+ cmState::STATIC);
}
}
@@ -335,7 +335,7 @@ void cmGlobalVisualStudio7Generator::GenerateConfigurations(cmMakefile* mf)
"Semicolon separated list of supported configuration types, "
"only supports Debug, Release, MinSizeRel, and RelWithDebInfo, "
"anything else will be ignored.",
- cmCacheManager::STRING);
+ cmState::STRING);
}
void cmGlobalVisualStudio7Generator::Generate()
@@ -970,7 +970,7 @@ void cmGlobalVisualStudio7Generator::CreateGUID(const std::string& name)
ret = cmSystemTools::UpperCase(ret);
this->CMakeInstance->AddCacheEntry(guidStoreName.c_str(),
ret.c_str(), "Stored GUID",
- cmCacheManager::INTERNAL);
+ cmState::INTERNAL);
}
std::vector<std::string> *cmGlobalVisualStudio7Generator::GetConfigurations()
diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx
index 0561a05..7488386 100644
--- a/Source/cmGlobalXCodeGenerator.cxx
+++ b/Source/cmGlobalXCodeGenerator.cxx
@@ -285,7 +285,7 @@ void cmGlobalXCodeGenerator::EnableLanguage(std::vector<std::string>const&
"Semicolon separated list of supported configuration types, "
"only supports Debug, Release, MinSizeRel, and RelWithDebInfo, "
"anything else will be ignored.",
- cmCacheManager::STRING);
+ cmState::STRING);
}
}
mf->AddDefinition("CMAKE_GENERATOR_NO_COMPILER_ENV", "1");
@@ -2754,7 +2754,7 @@ std::string cmGlobalXCodeGenerator::GetOrCreateId(const std::string& name,
}
this->CMakeInstance->AddCacheEntry(guidStoreName.c_str(),
- id.c_str(), "Stored Xcode object GUID", cmCacheManager::INTERNAL);
+ id.c_str(), "Stored Xcode object GUID", cmState::INTERNAL);
return id;
}
diff --git a/Source/cmIncludeExternalMSProjectCommand.cxx b/Source/cmIncludeExternalMSProjectCommand.cxx
index d40d8fe..1e7258a 100644
--- a/Source/cmIncludeExternalMSProjectCommand.cxx
+++ b/Source/cmIncludeExternalMSProjectCommand.cxx
@@ -73,7 +73,7 @@ bool cmIncludeExternalMSProjectCommand
std::string guidVariable = utility_name + "_GUID_CMAKE";
this->Makefile->GetCMakeInstance()->AddCacheEntry(
guidVariable.c_str(), customGuid.c_str(),
- "Stored GUID", cmCacheManager::INTERNAL);
+ "Stored GUID", cmState::INTERNAL);
}
// Create a target instance for this utility.
diff --git a/Source/cmLoadCacheCommand.cxx b/Source/cmLoadCacheCommand.cxx
index e2ae901..6ade535 100644
--- a/Source/cmLoadCacheCommand.cxx
+++ b/Source/cmLoadCacheCommand.cxx
@@ -172,7 +172,7 @@ void cmLoadCacheCommand::CheckLine(const char* line)
// Check one line of the cache file.
std::string var;
std::string value;
- cmCacheManager::CacheEntryType type = cmCacheManager::UNINITIALIZED;
+ cmState::CacheEntryType type = cmState::UNINITIALIZED;
if(cmake::ParseCacheEntry(line, var, value, type))
{
// Found a real entry. See if this one was requested.
diff --git a/Source/cmLocalVisualStudio10Generator.cxx b/Source/cmLocalVisualStudio10Generator.cxx
index aa70ab9..2b67562 100644
--- a/Source/cmLocalVisualStudio10Generator.cxx
+++ b/Source/cmLocalVisualStudio10Generator.cxx
@@ -118,7 +118,7 @@ void cmLocalVisualStudio10Generator
AddCacheEntry(guidStoreName.c_str(),
parser.GUID.c_str(),
"Stored GUID",
- cmCacheManager::INTERNAL);
+ cmState::INTERNAL);
}
//----------------------------------------------------------------------------
diff --git a/Source/cmLocalVisualStudio7Generator.cxx b/Source/cmLocalVisualStudio7Generator.cxx
index c4abeb2..884212b 100644
--- a/Source/cmLocalVisualStudio7Generator.cxx
+++ b/Source/cmLocalVisualStudio7Generator.cxx
@@ -16,7 +16,6 @@
#include "cmMakefile.h"
#include "cmSystemTools.h"
#include "cmSourceFile.h"
-#include "cmCacheManager.h"
#include "cmGeneratorTarget.h"
#include "cmCustomCommandGenerator.h"
#include "cmake.h"
@@ -2331,7 +2330,7 @@ void cmLocalVisualStudio7Generator::ReadAndStoreExternalGUID(
AddCacheEntry(guidStoreName.c_str(),
parser.GUID.c_str(),
"Stored GUID",
- cmCacheManager::INTERNAL);
+ cmState::INTERNAL);
}
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 35fdd0c..ad3cce4 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -18,7 +18,7 @@
#include "cmGlobalGenerator.h"
#include "cmLocalGenerator.h"
#include "cmCommands.h"
-#include "cmCacheManager.h"
+#include "cmState.h"
#include "cmFunctionBlocker.h"
#include "cmListFileCache.h"
#include "cmCommandArgumentParserHelper.h"
@@ -1778,16 +1778,16 @@ void cmMakefile::AddDefinition(const std::string& name, const char* value)
void cmMakefile::AddCacheDefinition(const std::string& name, const char* value,
const char* doc,
- cmCacheManager::CacheEntryType type,
+ cmState::CacheEntryType type,
bool force)
{
bool haveVal = value ? true : false;
std::string val = haveVal ? value : "";
const char* existingValue =
- this->GetCacheManager()->GetInitializedCacheValue(name);
+ this->GetState()->GetInitializedCacheValue(name);
if(existingValue
- && (this->GetCacheManager()->GetCacheEntryType(name)
- == cmCacheManager::UNINITIALIZED))
+ && (this->GetState()->GetCacheEntryType(name)
+ == cmState::UNINITIALIZED))
{
// if this is not a force, then use the value from the cache
// if it is a force, then use the value being passed in
@@ -1796,7 +1796,7 @@ void cmMakefile::AddCacheDefinition(const std::string& name, const char* value,
val = existingValue;
haveVal = true;
}
- if ( type == cmCacheManager::PATH || type == cmCacheManager::FILEPATH )
+ if ( type == cmState::PATH || type == cmState::FILEPATH )
{
std::vector<std::string>::size_type cc;
std::vector<std::string> files;
@@ -1815,14 +1815,14 @@ void cmMakefile::AddCacheDefinition(const std::string& name, const char* value,
nvalue += files[cc];
}
- this->GetCacheManager()->AddCacheEntry(name, nvalue.c_str(), doc, type);
- val = this->GetCacheManager()->GetInitializedCacheValue(name);
+ this->GetState()->AddCacheEntry(name, nvalue.c_str(), doc, type);
+ val = this->GetState()->GetInitializedCacheValue(name);
haveVal = true;
}
}
- this->GetCacheManager()->AddCacheEntry(name, haveVal ? val.c_str() : 0,
- doc, type);
+ this->GetState()->AddCacheEntry(name, haveVal ? val.c_str() : 0,
+ doc, type);
// if there was a definition then remove it
this->Internal->VarStack.top().Set(name, 0);
}
@@ -1949,7 +1949,7 @@ void cmMakefile::RemoveDefinition(const std::string& name)
void cmMakefile::RemoveCacheDefinition(const std::string& name)
{
- this->GetCacheManager()->RemoveCacheEntry(name);
+ this->GetState()->RemoveCacheEntry(name);
}
void cmMakefile::SetProjectName(const char* p)
@@ -2406,7 +2406,7 @@ bool cmMakefile::IsDefinitionSet(const std::string& name) const
this->Internal->VarUsageStack.top().insert(name);
if(!def)
{
- def = this->GetCacheManager()->GetInitializedCacheValue(name);
+ def = this->GetState()->GetInitializedCacheValue(name);
}
#ifdef CMAKE_BUILD_WITH_CMAKE
if(cmVariableWatch* vv = this->GetVariableWatch())
@@ -2431,7 +2431,7 @@ const char* cmMakefile::GetDefinition(const std::string& name) const
const char* def = this->Internal->VarStack.top().Get(name);
if(!def)
{
- def = this->GetCacheManager()->GetInitializedCacheValue(name);
+ def = this->GetState()->GetInitializedCacheValue(name);
}
#ifdef CMAKE_BUILD_WITH_CMAKE
cmVariableWatch* vv = this->GetVariableWatch();
@@ -2473,7 +2473,7 @@ std::vector<std::string> cmMakefile
res.insert(res.end(), definitions.begin(), definitions.end());
}
std::vector<std::string> cacheKeys =
- this->GetCacheManager()->GetCacheEntryKeys();
+ this->GetState()->GetCacheEntryKeys();
res.insert(res.end(), cacheKeys.begin(), cacheKeys.end());
std::sort(res.begin(), res.end());
@@ -2774,6 +2774,8 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringNew(
openstack.push(t_lookup());
cmake::MessageType mtype = cmake::LOG;
+ cmState* state = this->GetCMakeInstance()->GetState();
+
do
{
char inc = *in;
@@ -2807,8 +2809,7 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringNew(
value = cmSystemTools::GetEnv(lookup.c_str());
break;
case CACHE:
- value = this->GetCacheManager()
- ->GetInitializedCacheValue(lookup);
+ value = state->GetCacheEntryValue(lookup);
break;
}
// Get the string we're meant to append to.
@@ -3598,7 +3599,7 @@ int cmMakefile::TryCompile(const std::string& srcdir,
// Add this before the user-provided CMake arguments in case
// one of the arguments is -DCMAKE_BUILD_TYPE=...
cm.AddCacheEntry("CMAKE_BUILD_TYPE", config,
- "Build configuration", cmCacheManager::STRING);
+ "Build configuration", cmState::STRING);
}
}
// if cmake args were provided then pass them in
@@ -3637,12 +3638,12 @@ int cmMakefile::TryCompile(const std::string& srcdir,
if(this->IsOn("CMAKE_SUPPRESS_DEVELOPER_WARNINGS"))
{
cm.AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS",
- "TRUE", "", cmCacheManager::INTERNAL);
+ "TRUE", "", cmState::INTERNAL);
}
else
{
cm.AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS",
- "FALSE", "", cmCacheManager::INTERNAL);
+ "FALSE", "", cmState::INTERNAL);
}
if (cm.Configure() != 0)
{
@@ -3716,9 +3717,9 @@ void cmMakefile::GetListOfMacros(std::string& macros) const
macros = cmJoin(this->MacrosList, ";");
}
-cmCacheManager *cmMakefile::GetCacheManager() const
+cmState *cmMakefile::GetState() const
{
- return this->GetCMakeInstance()->GetCacheManager();
+ return this->GetCMakeInstance()->GetState();
}
void cmMakefile::DisplayStatus(const char* message, float s) const
@@ -4885,7 +4886,7 @@ bool cmMakefile::SetPolicy(cmPolicies::PolicyID id,
if(id == cmPolicies::CMP0001 &&
(status == cmPolicies::WARN || status == cmPolicies::OLD))
{
- if(!(this->GetCacheManager()
+ if(!(this->GetState()
->GetInitializedCacheValue("CMAKE_BACKWARDS_COMPATIBILITY")))
{
// Set it to 2.4 because that is the last version where the
@@ -4895,7 +4896,7 @@ bool cmMakefile::SetPolicy(cmPolicies::PolicyID id,
"For backwards compatibility, what version of CMake "
"commands and "
"syntax should this version of CMake try to support.",
- cmCacheManager::STRING);
+ cmState::STRING);
}
}
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index b78f921..57a4180 100644
--- a/Source/cmMakefile.h
+++ b/Source/cmMakefile.h
@@ -12,7 +12,6 @@
#ifndef cmMakefile_h
#define cmMakefile_h
-#include "cmCacheManager.h"
#include "cmExecutionStatus.h"
#include "cmListFileCache.h"
#include "cmPolicies.h"
@@ -23,6 +22,7 @@
#include "cmGeneratorTarget.h"
#include "cmExpandedCommandArgument.h"
#include "cmake.h"
+#include "cmState.h"
#if defined(CMAKE_BUILD_WITH_CMAKE)
#include "cmSourceGroup.h"
@@ -305,7 +305,7 @@ public:
///! Add a definition to this makefile and the global cmake cache.
void AddCacheDefinition(const std::string& name, const char* value,
const char* doc,
- cmCacheManager::CacheEntryType type,
+ cmState::CacheEntryType type,
bool force = false);
/**
@@ -758,7 +758,7 @@ public:
///enabled.
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
diff --git a/Source/cmMarkAsAdvancedCommand.cxx b/Source/cmMarkAsAdvancedCommand.cxx
index cc094b1..10d30f3 100644
--- a/Source/cmMarkAsAdvancedCommand.cxx
+++ b/Source/cmMarkAsAdvancedCommand.cxx
@@ -36,20 +36,20 @@ bool cmMarkAsAdvancedCommand
for(; i < args.size(); ++i)
{
std::string variable = args[i];
- cmCacheManager* manager = this->Makefile->GetCacheManager();
- if (!manager->GetCacheEntryValue(variable))
+ cmState* state = this->Makefile->GetState();
+ if (!state->GetCacheEntryValue(variable))
{
- manager->AddCacheEntry(variable, 0, 0, cmCacheManager::UNINITIALIZED);
+ state->AddCacheEntry(variable, 0, 0, cmState::UNINITIALIZED);
overwrite = true;
}
- if (!manager->GetCacheEntryValue(variable))
+ if (!state->GetCacheEntryValue(variable))
{
cmSystemTools::Error("This should never happen...");
return false;
}
- if (!manager->GetCacheEntryProperty(variable, "ADVANCED") || overwrite)
+ if (!state->GetCacheEntryProperty(variable, "ADVANCED") || overwrite)
{
- manager->SetCacheEntryProperty(variable, "ADVANCED", value);
+ state->SetCacheEntryProperty(variable, "ADVANCED", value);
}
}
return true;
diff --git a/Source/cmOptionCommand.cxx b/Source/cmOptionCommand.cxx
index baf5b1e..92be5f1 100644
--- a/Source/cmOptionCommand.cxx
+++ b/Source/cmOptionCommand.cxx
@@ -42,13 +42,13 @@ bool cmOptionCommand
std::string initialValue = "Off";
// Now check and see if the value has been stored in the cache
// already, if so use that value and don't look for the program
- cmCacheManager* manager = this->Makefile->GetCacheManager();
- const char* existingValue = manager->GetCacheEntryValue(args[0]);
+ cmState* state = this->Makefile->GetState();
+ const char* existingValue = state->GetCacheEntryValue(args[0]);
if(existingValue)
{
- if (manager->GetCacheEntryType(args[0]) != cmCacheManager::UNINITIALIZED)
+ if (state->GetCacheEntryType(args[0]) != cmState::UNINITIALIZED)
{
- manager->SetCacheEntryProperty(args[0], "HELPSTRING", args[1]);
+ state->SetCacheEntryProperty(args[0], "HELPSTRING", args[1]);
return true;
}
initialValue = existingValue;
@@ -59,6 +59,6 @@ bool cmOptionCommand
}
bool init = cmSystemTools::IsOn(initialValue.c_str());
this->Makefile->AddCacheDefinition(args[0], init? "ON":"OFF",
- args[1].c_str(), cmCacheManager::BOOL);
+ args[1].c_str(), cmState::BOOL);
return true;
}
diff --git a/Source/cmProjectCommand.cxx b/Source/cmProjectCommand.cxx
index 61c0133..601dc54 100644
--- a/Source/cmProjectCommand.cxx
+++ b/Source/cmProjectCommand.cxx
@@ -30,11 +30,11 @@ bool cmProjectCommand
this->Makefile->AddCacheDefinition
(bindir,
this->Makefile->GetCurrentOutputDirectory(),
- "Value Computed by CMake", cmCacheManager::STATIC);
+ "Value Computed by CMake", cmState::STATIC);
this->Makefile->AddCacheDefinition
(srcdir,
this->Makefile->GetCurrentDirectory(),
- "Value Computed by CMake", cmCacheManager::STATIC);
+ "Value Computed by CMake", cmState::STATIC);
bindir = "PROJECT_BINARY_DIR";
srcdir = "PROJECT_SOURCE_DIR";
@@ -59,7 +59,7 @@ bool cmProjectCommand
this->Makefile->AddCacheDefinition
("CMAKE_PROJECT_NAME",
args[0].c_str(),
- "Value Computed by CMake", cmCacheManager::STATIC);
+ "Value Computed by CMake", cmState::STATIC);
}
bool haveVersion = false;
diff --git a/Source/cmSetCommand.cxx b/Source/cmSetCommand.cxx
index e17474b..bf9f42c 100644
--- a/Source/cmSetCommand.cxx
+++ b/Source/cmSetCommand.cxx
@@ -79,8 +79,8 @@ bool cmSetCommand
bool cache = false; // optional
bool force = false; // optional
bool parentScope = false;
- cmCacheManager::CacheEntryType type
- = cmCacheManager::STRING; // required if cache
+ cmState::CacheEntryType type
+ = cmState::STRING; // required if cache
const char* docstring = 0; // required if cache
unsigned int ignoreLastArgs = 0;
@@ -131,21 +131,21 @@ bool cmSetCommand
if(cache)
{
std::string::size_type cacheStart = args.size() - 3 - (force ? 1 : 0);
- type = cmCacheManager::StringToType(args[cacheStart+1].c_str());
+ type = cmState::StringToCacheEntryType(args[cacheStart+1].c_str());
docstring = args[cacheStart+2].c_str();
}
// see if this is already in the cache
- cmCacheManager* manager = this->Makefile->GetCacheManager();
- const char* existingValue = manager->GetCacheEntryValue(variable);
+ cmState* state = this->Makefile->GetState();
+ const char* existingValue = state->GetCacheEntryValue(variable);
if(existingValue &&
- (manager->GetCacheEntryType(variable) != cmCacheManager::UNINITIALIZED))
+ (state->GetCacheEntryType(variable) != cmState::UNINITIALIZED))
{
// if the set is trying to CACHE the value but the value
// is already in the cache and the type is not internal
// then leave now without setting any definitions in the cache
// or the makefile
- if(cache && type != cmCacheManager::INTERNAL && !force)
+ if(cache && type != cmState::INTERNAL && !force)
{
return true;
}
diff --git a/Source/cmSetPropertyCommand.cxx b/Source/cmSetPropertyCommand.cxx
index 77f9fb9..bb94a72 100644
--- a/Source/cmSetPropertyCommand.cxx
+++ b/Source/cmSetPropertyCommand.cxx
@@ -14,7 +14,6 @@
#include "cmSetTestsPropertiesCommand.h"
#include "cmSetSourceFilesPropertiesCommand.h"
-#include "cmCacheManager.h"
//----------------------------------------------------------------------------
cmSetPropertyCommand::cmSetPropertyCommand()
@@ -426,7 +425,7 @@ bool cmSetPropertyCommand::HandleCacheMode()
}
else if(this->PropertyName == "TYPE")
{
- if(!cmCacheManager::IsType(this->PropertyValue.c_str()))
+ if(!cmState::IsCacheEntryType(this->PropertyValue.c_str()))
{
std::ostringstream e;
e << "given invalid CACHE entry TYPE \"" << this->PropertyValue << "\"";
@@ -453,7 +452,7 @@ bool cmSetPropertyCommand::HandleCacheMode()
cmMakefile* mf = this->GetMakefile();
cmake* cm = mf->GetCMakeInstance();
const char* existingValue
- = cm->GetCacheManager()->GetCacheEntryValue(*ni);
+ = cm->GetState()->GetCacheEntryValue(*ni);
if(existingValue)
{
if(!this->HandleCacheEntry(*ni))
@@ -479,20 +478,19 @@ bool cmSetPropertyCommand::HandleCacheEntry(std::string const& cacheKey)
// Set or append the property.
const char* name = this->PropertyName.c_str();
const char* value = this->PropertyValue.c_str();
- cmCacheManager* manager = this->Makefile->GetCacheManager();
+ cmState* state = this->Makefile->GetState();
if (this->Remove)
{
- manager->RemoveCacheEntryProperty(cacheKey, name);
- return true;
+ state->RemoveCacheEntryProperty(cacheKey, name);
}
if(this->AppendMode)
{
- manager->AppendCacheEntryProperty(cacheKey, name, value,
- this->AppendAsString);
+ state->AppendCacheEntryProperty(cacheKey, name, value,
+ this->AppendAsString);
}
else
{
- manager->SetCacheEntryProperty(cacheKey, name, value);
+ state->SetCacheEntryProperty(cacheKey, name, value);
}
return true;
diff --git a/Source/cmSiteNameCommand.cxx b/Source/cmSiteNameCommand.cxx
index 927888b..20a61a0 100644
--- a/Source/cmSiteNameCommand.cxx
+++ b/Source/cmSiteNameCommand.cxx
@@ -88,7 +88,7 @@ bool cmSiteNameCommand
AddCacheDefinition(args[0],
siteName.c_str(),
"Name of the computer/site where compile is being run",
- cmCacheManager::STRING);
+ cmState::STRING);
return true;
}
diff --git a/Source/cmState.cxx b/Source/cmState.cxx
new file mode 100644
index 0000000..7602f63
--- /dev/null
+++ b/Source/cmState.cxx
@@ -0,0 +1,180 @@
+/*============================================================================
+ 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"
+#include "cmCacheManager.h"
+
+cmState::cmState(cmake* cm)
+ : CMakeInstance(cm)
+{
+}
+
+const char* cmCacheEntryTypes[] =
+{ "BOOL",
+ "PATH",
+ "FILEPATH",
+ "STRING",
+ "INTERNAL",
+ "STATIC",
+ "UNINITIALIZED",
+ 0
+};
+
+const char*
+cmState::CacheEntryTypeToString(cmState::CacheEntryType type)
+{
+ if ( type > 6 )
+ {
+ return cmCacheEntryTypes[6];
+ }
+ return cmCacheEntryTypes[type];
+}
+
+cmState::CacheEntryType
+cmState::StringToCacheEntryType(const char* s)
+{
+ int i = 0;
+ while(cmCacheEntryTypes[i])
+ {
+ if(strcmp(s, cmCacheEntryTypes[i]) == 0)
+ {
+ return static_cast<cmState::CacheEntryType>(i);
+ }
+ ++i;
+ }
+ return STRING;
+}
+
+bool cmState::IsCacheEntryType(std::string const& key)
+{
+ for(int i=0; cmCacheEntryTypes[i]; ++i)
+ {
+ if(strcmp(key.c_str(), cmCacheEntryTypes[i]) == 0)
+ {
+ return true;
+ }
+ }
+ return false;
+}
+
+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);
+}
+
+cmState::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,
+ cmState::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);
+}
diff --git a/Source/cmState.h b/Source/cmState.h
new file mode 100644
index 0000000..f2e8ef5
--- /dev/null
+++ b/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 "cmStandardIncludes.h"
+
+class cmake;
+
+class cmState
+{
+public:
+ cmState(cmake* cm);
+
+ enum CacheEntryType{ BOOL=0, PATH, FILEPATH, STRING, INTERNAL,STATIC,
+ UNINITIALIZED };
+ static CacheEntryType StringToCacheEntryType(const char*);
+ static const char* CacheEntryTypeToString(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;
+ 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, 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
diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx
index 745a84c..6711e86 100644
--- a/Source/cmTarget.cxx
+++ b/Source/cmTarget.cxx
@@ -1182,7 +1182,7 @@ void cmTarget::ClearDependencyInformation( cmMakefile& mf,
if (this->RecordDependencies)
{
mf.AddCacheDefinition(depname, "",
- "Dependencies for target", cmCacheManager::STATIC);
+ "Dependencies for target", cmState::STATIC);
}
else
{
@@ -1370,7 +1370,7 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf,
dependencies += ";";
mf.AddCacheDefinition( targetEntry, dependencies.c_str(),
"Dependencies for the target",
- cmCacheManager::STATIC );
+ cmState::STATIC );
}
}
diff --git a/Source/cmTryRunCommand.cxx b/Source/cmTryRunCommand.cxx
index 63109e0..c9e7a46 100644
--- a/Source/cmTryRunCommand.cxx
+++ b/Source/cmTryRunCommand.cxx
@@ -10,7 +10,6 @@
See the License for more information.
============================================================================*/
#include "cmTryRunCommand.h"
-#include "cmCacheManager.h"
#include "cmTryCompileCommand.h"
#include <cmsys/FStream.hxx>
@@ -239,7 +238,7 @@ void cmTryRunCommand::RunExecutable(const std::string& runArgs,
}
this->Makefile->AddCacheDefinition(this->RunResultVariable, retChar,
"Result of TRY_RUN",
- cmCacheManager::INTERNAL);
+ cmState::INTERNAL);
}
/* This is only used when cross compiling. Instead of running the
@@ -284,14 +283,14 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
this->Makefile->AddCacheDefinition(this->RunResultVariable,
"PLEASE_FILL_OUT-FAILED_TO_RUN",
comment.c_str(),
- cmCacheManager::STRING);
+ cmState::STRING);
- cmCacheManager* manager = this->Makefile->GetCacheManager();
+ cmState* state = this->Makefile->GetState();
const char* existingValue
- = manager->GetCacheEntryValue(this->RunResultVariable);
+ = state->GetCacheEntryValue(this->RunResultVariable);
if (existingValue)
{
- manager->SetCacheEntryProperty(this->RunResultVariable, "ADVANCED", "1");
+ state->SetCacheEntryProperty(this->RunResultVariable, "ADVANCED", "1");
}
error = true;
@@ -312,14 +311,14 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
this->Makefile->AddCacheDefinition(internalRunOutputName,
"PLEASE_FILL_OUT-NOTFOUND",
comment.c_str(),
- cmCacheManager::STRING);
- cmCacheManager* manager = this->Makefile->GetCacheManager();
+ cmState::STRING);
+ cmState* state = this->Makefile->GetState();
const char* existing =
- manager->GetCacheEntryValue(internalRunOutputName);
+ state->GetCacheEntryValue(internalRunOutputName);
if (existing)
{
- manager->SetCacheEntryProperty(internalRunOutputName,
- "ADVANCED", "1");
+ state->SetCacheEntryProperty(internalRunOutputName,
+ "ADVANCED", "1");
}
error = true;
diff --git a/Source/cmUtilitySourceCommand.cxx b/Source/cmUtilitySourceCommand.cxx
index 2799a9b..10122e9 100644
--- a/Source/cmUtilitySourceCommand.cxx
+++ b/Source/cmUtilitySourceCommand.cxx
@@ -11,6 +11,8 @@
============================================================================*/
#include "cmUtilitySourceCommand.h"
+#include "cmCacheManager.h"
+
// cmUtilitySourceCommand
bool cmUtilitySourceCommand
::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
@@ -118,14 +120,14 @@ bool cmUtilitySourceCommand
this->Makefile->AddCacheDefinition(cacheEntry,
utilityExecutable.c_str(),
"Path to an internal program.",
- cmCacheManager::FILEPATH);
+ cmState::FILEPATH);
// add a value into the cache that maps from the
// full path to the name of the project
cmSystemTools::ConvertToUnixSlashes(utilityExecutable);
this->Makefile->AddCacheDefinition(utilityExecutable,
utilityName.c_str(),
"Executable to project name.",
- cmCacheManager::INTERNAL);
+ cmState::INTERNAL);
return true;
}
diff --git a/Source/cmVariableRequiresCommand.cxx b/Source/cmVariableRequiresCommand.cxx
index dd2a682..1d33db1 100644
--- a/Source/cmVariableRequiresCommand.cxx
+++ b/Source/cmVariableRequiresCommand.cxx
@@ -10,7 +10,7 @@
See the License for more information.
============================================================================*/
#include "cmVariableRequiresCommand.h"
-#include "cmCacheManager.h"
+#include "cmState.h"
// cmLibraryCommand
bool cmVariableRequiresCommand
@@ -34,6 +34,7 @@ bool cmVariableRequiresCommand
bool requirementsMet = true;
std::string notSet;
bool hasAdvanced = false;
+ cmState* state = this->Makefile->GetState();
for(unsigned int i = 2; i < args.size(); ++i)
{
if(!this->Makefile->IsOn(args[i]))
@@ -41,9 +42,8 @@ bool cmVariableRequiresCommand
requirementsMet = false;
notSet += args[i];
notSet += "\n";
- cmCacheManager* manager = this->Makefile->GetCacheManager();
- if(manager->GetCacheEntryValue(args[i]) &&
- manager->GetCacheEntryPropertyAsBool(args[i], "ADVANCED"))
+ if(state->GetCacheEntryValue(args[i]) &&
+ state->GetCacheEntryPropertyAsBool(args[i], "ADVANCED"))
{
hasAdvanced = true;
}
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index ac0f5d0..8cdf96f 100644
--- a/Source/cmake.cxx
+++ b/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;
@@ -332,7 +336,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
}
}
std::string var, value;
- cmCacheManager::CacheEntryType type = cmCacheManager::UNINITIALIZED;
+ cmState::CacheEntryType type = cmState::UNINITIALIZED;
if(cmCacheManager::ParseEntry(entry, var, value, type))
{
// The value is transformed if it is a filepath for example, so
@@ -342,22 +346,20 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
std::string cachedValue;
if(this->WarnUnusedCli)
{
- if(const char *v = this->CacheManager
- ->GetInitializedCacheValue(var))
+ if(const char *v = this->State->GetInitializedCacheValue(var))
{
haveValue = true;
cachedValue = v;
}
}
- this->CacheManager->AddCacheEntry(var, value.c_str(),
+ this->State->AddCacheEntry(var, value.c_str(),
"No help, variable specified on the command line.", type);
if(this->WarnUnusedCli)
{
if (!haveValue ||
- cachedValue != this->CacheManager
- ->GetInitializedCacheValue(var))
+ cachedValue != this->State->GetInitializedCacheValue(var))
{
this->WatchUnusedCli(var);
}
@@ -401,14 +403,12 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
cmsys::Glob::PatternToRegex(entryPattern, true, true).c_str());
//go through all cache entries and collect the vars which will be removed
std::vector<std::string> entriesToDelete;
- std::vector<std::string> cacheKeys =
- this->CacheManager->GetCacheEntryKeys();
+ std::vector<std::string> cacheKeys = this->State->GetCacheEntryKeys();
for (std::vector<std::string>::const_iterator it = cacheKeys.begin();
it != cacheKeys.end(); ++it)
{
- cmCacheManager::CacheEntryType t =
- this->CacheManager->GetCacheEntryType(*it);
- if(t != cmCacheManager::STATIC)
+ cmState::CacheEntryType t = this->State->GetCacheEntryType(*it);
+ if(t != cmState::STATIC)
{
if (regex.find(it->c_str()))
{
@@ -423,7 +423,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
currentEntry != entriesToDelete.end();
++currentEntry)
{
- this->CacheManager->RemoveCacheEntry(*currentEntry);
+ this->State->RemoveCacheEntry(*currentEntry);
}
}
else if(arg.find("-C",0) == 0)
@@ -917,7 +917,7 @@ void cmake::SetDirectoriesFromFile(const char* arg)
if(this->LoadCache(cachePath))
{
const char* existingValue =
- this->CacheManager->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
+ this->State->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
if (existingValue)
{
this->SetHomeOutputDirectory(cachePath);
@@ -971,14 +971,14 @@ int cmake::AddCMakePaths()
// Save the value in the cache
this->CacheManager->AddCacheEntry
("CMAKE_COMMAND", cmSystemTools::GetCMakeCommand().c_str(),
- "Path to CMake executable.", cmCacheManager::INTERNAL);
+ "Path to CMake executable.", cmState::INTERNAL);
#ifdef CMAKE_BUILD_WITH_CMAKE
this->CacheManager->AddCacheEntry
("CMAKE_CTEST_COMMAND", cmSystemTools::GetCTestCommand().c_str(),
- "Path to ctest program executable.", cmCacheManager::INTERNAL);
+ "Path to ctest program executable.", cmState::INTERNAL);
this->CacheManager->AddCacheEntry
("CMAKE_CPACK_COMMAND", cmSystemTools::GetCPackCommand().c_str(),
- "Path to cpack program executable.", cmCacheManager::INTERNAL);
+ "Path to cpack program executable.", cmState::INTERNAL);
#endif
if(!cmSystemTools::FileExists(
(cmSystemTools::GetCMakeRoot()+"/Modules/CMake.cmake").c_str()))
@@ -992,7 +992,7 @@ int cmake::AddCMakePaths()
}
this->CacheManager->AddCacheEntry
("CMAKE_ROOT", cmSystemTools::GetCMakeRoot().c_str(),
- "Path to CMake installation.", cmCacheManager::INTERNAL);
+ "Path to CMake installation.", cmState::INTERNAL);
return 1;
}
@@ -1266,7 +1266,7 @@ struct SaveCacheEntry
std::string key;
std::string value;
std::string help;
- cmCacheManager::CacheEntryType type;
+ cmState::CacheEntryType type;
};
int cmake::HandleDeleteCacheVariables(const std::string& var)
@@ -1279,7 +1279,6 @@ int cmake::HandleDeleteCacheVariables(const std::string& var)
{
return 0;
}
- cmCacheManager::CacheIterator ci = this->CacheManager->NewIterator();
std::vector<SaveCacheEntry> saved;
std::ostringstream warning;
warning
@@ -1295,10 +1294,13 @@ int cmake::HandleDeleteCacheVariables(const std::string& var)
i++;
save.value = *i;
warning << *i << "\n";
- if(ci.Find(save.key))
+ const char* existingValue =
+ this->CacheManager->GetCacheEntryValue(save.key);
+ if(existingValue)
{
- save.type = ci.GetType();
- if(const char* help = ci.GetProperty("HELPSTRING"))
+ save.type = this->CacheManager->GetCacheEntryType(save.key);
+ if(const char* help =
+ this->CacheManager->GetCacheEntryProperty(save.key, "HELPSTRING"))
{
save.help = help;
}
@@ -1337,7 +1339,7 @@ int cmake::Configure()
AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", "TRUE",
"Suppress Warnings that are meant for"
" the author of the CMakeLists.txt files.",
- cmCacheManager::INTERNAL);
+ cmState::INTERNAL);
}
else
{
@@ -1345,7 +1347,7 @@ int cmake::Configure()
AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", "FALSE",
"Suppress Warnings that are meant for"
" the author of the CMakeLists.txt files.",
- cmCacheManager::INTERNAL);
+ cmState::INTERNAL);
}
}
int ret = this->ActualConfigure();
@@ -1381,7 +1383,7 @@ int cmake::ActualConfigure()
this->GetHomeDirectory(),
"Start directory with the top level CMakeLists.txt file for this "
"project",
- cmCacheManager::INTERNAL);
+ cmState::INTERNAL);
}
// no generator specified on the command line
@@ -1490,11 +1492,11 @@ int cmake::ActualConfigure()
this->CacheManager->AddCacheEntry("CMAKE_GENERATOR",
this->GlobalGenerator->GetName().c_str(),
"Name of generator.",
- cmCacheManager::INTERNAL);
+ cmState::INTERNAL);
this->CacheManager->AddCacheEntry("CMAKE_EXTRA_GENERATOR",
this->GlobalGenerator->GetExtraGeneratorName().c_str(),
"Name of external makefile project generator.",
- cmCacheManager::INTERNAL);
+ cmState::INTERNAL);
}
if(const char* platformName =
@@ -1522,7 +1524,7 @@ int cmake::ActualConfigure()
this->CacheManager->AddCacheEntry("CMAKE_GENERATOR_PLATFORM",
this->GeneratorPlatform.c_str(),
"Name of generator platform.",
- cmCacheManager::INTERNAL);
+ cmState::INTERNAL);
}
if(const char* tsName =
@@ -1550,7 +1552,7 @@ int cmake::ActualConfigure()
this->CacheManager->AddCacheEntry("CMAKE_GENERATOR_TOOLSET",
this->GeneratorToolset.c_str(),
"Name of generator toolset.",
- cmCacheManager::INTERNAL);
+ cmState::INTERNAL);
}
// reset any system configuration information, except for when we are
@@ -1576,49 +1578,51 @@ int cmake::ActualConfigure()
// project requires compatibility with CMake 2.4. We detect this
// here by looking for the old CMAKE_BACKWARDS_COMPATIBILITY
// variable created when CMP0001 is not set to NEW.
- if(this->GetCacheManager()
+ if(this->State
->GetInitializedCacheValue("CMAKE_BACKWARDS_COMPATIBILITY"))
{
- if(!this->CacheManager->GetInitializedCacheValue("LIBRARY_OUTPUT_PATH"))
+ if(!this->State->GetInitializedCacheValue("LIBRARY_OUTPUT_PATH"))
{
- this->CacheManager->AddCacheEntry
+ this->State->AddCacheEntry
("LIBRARY_OUTPUT_PATH", "",
"Single output directory for building all libraries.",
- cmCacheManager::PATH);
+ cmState::PATH);
}
- if(!this->CacheManager
+ if(!this->State
->GetInitializedCacheValue("EXECUTABLE_OUTPUT_PATH"))
{
- this->CacheManager->AddCacheEntry
+ this->State->AddCacheEntry
("EXECUTABLE_OUTPUT_PATH", "",
"Single output directory for building all executables.",
- cmCacheManager::PATH);
+ cmState::PATH);
}
}
- if(!this->CacheManager
+ if(!this->State
->GetInitializedCacheValue("CMAKE_USE_RELATIVE_PATHS"))
{
- this->CacheManager->AddCacheEntry
+ this->State->AddCacheEntry
("CMAKE_USE_RELATIVE_PATHS", "OFF",
"If true, cmake will use relative paths in makefiles and projects.",
- cmCacheManager::BOOL);
- if (!this->CacheManager->GetCacheEntryProperty("CMAKE_USE_RELATIVE_PATHS",
- "ADVANCED"))
+ cmState::BOOL);
+ if (!this->State->GetCacheEntryProperty("CMAKE_USE_RELATIVE_PATHS",
+ "ADVANCED"))
{
- this->CacheManager->SetCacheEntryProperty("CMAKE_USE_RELATIVE_PATHS",
- "ADVANCED", "1");
+ this->State->SetCacheEntryProperty("CMAKE_USE_RELATIVE_PATHS",
+ "ADVANCED", "1");
}
}
- if(cmSystemTools::GetFatalErrorOccured() &&
- (!this->CacheManager->GetInitializedCacheValue("CMAKE_MAKE_PROGRAM") ||
- cmSystemTools::IsOff(this->CacheManager->
- GetInitializedCacheValue("CMAKE_MAKE_PROGRAM"))))
+ if(cmSystemTools::GetFatalErrorOccured())
{
- // We must have a bad generator selection. Wipe the cache entry so the
- // user can select another.
- this->CacheManager->RemoveCacheEntry("CMAKE_GENERATOR");
- this->CacheManager->RemoveCacheEntry("CMAKE_EXTRA_GENERATOR");
+ const char* makeProgram =
+ this->State->GetInitializedCacheValue("CMAKE_MAKE_PROGRAM");
+ if (!makeProgram || cmSystemTools::IsOff(makeProgram))
+ {
+ // We must have a bad generator selection. Wipe the cache entry so the
+ // user can select another.
+ this->State->RemoveCacheEntry("CMAKE_GENERATOR");
+ this->State->RemoveCacheEntry("CMAKE_EXTRA_GENERATOR");
+ }
}
cmMakefile* mf=this->GlobalGenerator->GetLocalGenerators()[0]->GetMakefile();
@@ -1824,7 +1828,7 @@ void cmake::AddCacheEntry(const std::string& key, const char* value,
{
this->CacheManager->AddCacheEntry(key, value,
helpString,
- cmCacheManager::CacheEntryType(type));
+ cmState::CacheEntryType(type));
}
const char* cmake::GetCacheDefinition(const std::string& name) const
@@ -1896,7 +1900,7 @@ void cmake::AddDefaultGenerators()
bool cmake::ParseCacheEntry(const std::string& entry,
std::string& var,
std::string& value,
- cmCacheManager::CacheEntryType& type)
+ cmState::CacheEntryType& type)
{
return cmCacheManager::ParseEntry(entry, var, value, type);
}
@@ -2246,7 +2250,7 @@ void cmake::TruncateOutputLog(const char* fname)
{
return;
}
- if ( !this->CacheManager->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR") )
+ if (!this->State->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR"))
{
cmSystemTools::RemoveFile(fullPath);
return;
@@ -2351,8 +2355,7 @@ const char *cmake::GetProperty(const std::string& prop,
std::string output = "";
if ( prop == "CACHE_VARIABLES" )
{
- std::vector<std::string> cacheKeys =
- this->CacheManager->GetCacheEntryKeys();
+ std::vector<std::string> cacheKeys = this->State->GetCacheEntryKeys();
this->SetProperty("CACHE_VARIABLES", cmJoin(cacheKeys, ";").c_str());
}
else if ( prop == "COMMANDS" )
@@ -2507,7 +2510,7 @@ int cmake::GetSystemInformation(std::vector<std::string>& args)
// we have to find the module directory, so we can copy the files
this->AddCMakePaths();
std::string modulesPath =
- this->CacheManager->GetInitializedCacheValue("CMAKE_ROOT");
+ this->State->GetInitializedCacheValue("CMAKE_ROOT");
modulesPath += "/Modules";
std::string inFile = modulesPath;
inFile += "/SystemInformation.cmake";
@@ -2717,7 +2720,7 @@ void cmake::IssueMessage(cmake::MessageType t, std::string const& text,
if(t == cmake::AUTHOR_WARNING)
{
// Allow suppression of these warnings.
- const char* suppress = this->CacheManager->GetCacheEntryValue(
+ const char* suppress = this->State->GetCacheEntryValue(
"CMAKE_SUPPRESS_DEVELOPER_WARNINGS");
if(suppress && cmSystemTools::IsOn(suppress))
{
@@ -2835,7 +2838,7 @@ int cmake::Build(const std::string& dir,
return 1;
}
const char* cachedGenerator =
- this->CacheManager->GetCacheEntryValue("CMAKE_GENERATOR");
+ this->State->GetCacheEntryValue("CMAKE_GENERATOR");
if(!cachedGenerator)
{
std::cerr << "Error: could not find CMAKE_GENERATOR in Cache\n";
@@ -2852,7 +2855,7 @@ int cmake::Build(const std::string& dir,
std::string output;
std::string projName;
const char* cachedProjectName =
- this->CacheManager->GetCacheEntryValue("CMAKE_PROJECT_NAME");
+ this->State->GetCacheEntryValue("CMAKE_PROJECT_NAME");
if(!cachedProjectName)
{
std::cerr << "Error: could not find CMAKE_PROJECT_NAME in Cache\n";
@@ -2861,7 +2864,7 @@ int cmake::Build(const std::string& dir,
projName = cachedProjectName;
bool verbose = false;
const char* cachedVerbose =
- this->CacheManager->GetCacheEntryValue("CMAKE_VERBOSE_MAKEFILE");
+ this->State->GetCacheEntryValue("CMAKE_VERBOSE_MAKEFILE");
if(cachedVerbose)
{
verbose = cmSystemTools::IsOn(cachedVerbose);
diff --git a/Source/cmake.h b/Source/cmake.h
index 4c2ad29..e80cc1c 100644
--- a/Source/cmake.h
+++ b/Source/cmake.h
@@ -19,6 +19,7 @@
#include "cmPropertyMap.h"
#include "cmInstalledFile.h"
#include "cmCacheManager.h"
+#include "cmState.h"
class cmGlobalGeneratorFactory;
class cmGlobalGenerator;
@@ -32,6 +33,7 @@ class cmDocumentationSection;
class cmPolicies;
class cmTarget;
class cmGeneratedFileStream;
+class cmState;
/** \brief Represents a cmake invocation.
*
@@ -157,7 +159,7 @@ class cmake
static bool ParseCacheEntry(const std::string& entry,
std::string& var,
std::string& value,
- cmCacheManager::CacheEntryType& type);
+ cmState::CacheEntryType& type);
int LoadCache();
bool LoadCache(const std::string& path);
@@ -362,6 +364,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();
@@ -449,6 +454,8 @@ private:
std::string GraphVizFile;
InstalledFilesMap InstalledFiles;
+ cmState* State;
+
void UpdateConversionPathTable();
// Print a list of valid generators to stderr.
diff --git a/Source/cmakemain.cxx b/Source/cmakemain.cxx
index 3b518be..c8cf2d4 100644
--- a/Source/cmakemain.cxx
+++ b/Source/cmakemain.cxx
@@ -18,7 +18,7 @@
#include "cmake.h"
#include "cmcmd.h"
-#include "cmCacheManager.h"
+#include "cmState.h"
#include "cmListFileCache.h"
#include "cmSourceFile.h"
#include "cmGlobalGenerator.h"
@@ -329,29 +329,27 @@ int do_cmake(int ac, char const* const* av)
if ( list_cached || list_all_cached )
{
std::cout << "-- Cache values" << std::endl;
- std::vector<std::string> keys =
- cm.GetCacheManager()->GetCacheEntryKeys();
+ std::vector<std::string> keys = cm.GetState()->GetCacheEntryKeys();
for (std::vector<std::string>::const_iterator it = keys.begin();
it != keys.end(); ++it)
{
- cmCacheManager::CacheEntryType t =
- cm.GetCacheManager()->GetCacheEntryType(*it);
- if ( t != cmCacheManager::INTERNAL && t != cmCacheManager::STATIC &&
- t != cmCacheManager::UNINITIALIZED )
+ cmState::CacheEntryType t = cm.GetState()->GetCacheEntryType(*it);
+ if (t != cmState::INTERNAL && t != cmState::STATIC &&
+ t != cmState::UNINITIALIZED)
{
const char* advancedProp =
- cm.GetCacheManager()->GetCacheEntryProperty(*it, "ADVANCED");
+ cm.GetState()->GetCacheEntryProperty(*it, "ADVANCED");
if ( list_all_cached || !advancedProp)
{
if ( list_help )
{
std::cout << "// "
- << cm.GetCacheManager()->GetCacheEntryProperty(*it,
+ << cm.GetState()->GetCacheEntryProperty(*it,
"HELPSTRING") << std::endl;
}
std::cout << *it << ":" <<
- cmCacheManager::TypeToString(t)
- << "=" << cm.GetCacheManager()->GetCacheEntryValue(*it)
+ cmState::CacheEntryTypeToString(t)
+ << "=" << cm.GetState()->GetCacheEntryValue(*it)
<< std::endl;
if ( list_help )
{
diff --git a/bootstrap b/bootstrap
index c7c6613..ad02a82 100755
--- a/bootstrap
+++ b/bootstrap
@@ -287,6 +287,7 @@ CMAKE_CXX_SOURCES="\
cmScriptGenerator \
cmSourceFile \
cmSourceFileLocation \
+ cmState \
cmSystemTools \
cmTestGenerator \
cmVersion \