[Cmake-commits] CMake branch, next, updated. v3.2.1-1526-g9f0e946
Stephen Kelly
steveire at gmail.com
Mon Apr 6 11:56:52 EDT 2015
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "CMake".
The branch, next has been updated
via 9f0e9467f3cf7d2f72388512e477e7ddcaebd2ca (commit)
via ec181a24bac55d270e8a17eb16a807bdd65c2c4b (commit)
via b02569d78f292adf31efcb8f8f023d07462db1a8 (commit)
via e6eb16933aa26a8bda70caa1ff41498a0d62281b (commit)
via 9754cb6f804df5150a1f1fffed0e8eb3c0612e1c (commit)
via a94cddabb4f6be6d47ee9be31ec76fe483e85415 (commit)
via eb5090065e06b96f115d2f80872a97e098800d57 (commit)
via 59c9744d8cba44dc3b49f2cb1fb760dce008fc44 (commit)
via 3a909de726d66b4e2b0b06a7baefd366d040ce54 (commit)
via 8951b57dd03b3550a6f698aefe9e65435f933323 (commit)
via 2c4ff47867f0073865c16cc8e397fe5118b15f33 (commit)
via db25277da05b1f2c058635b76cf3f9d612784427 (commit)
via 6f3e57e98ce324d7afb7681647159029fb145634 (commit)
via 4cf211dcbaf1efaa082d281d1ff4d3755a108389 (commit)
via 883042c34e6270551907b5d43f300ad3193b83a8 (commit)
from 4bf326d69cf167d8deb892339d96dc44eddb416f (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=9f0e9467f3cf7d2f72388512e477e7ddcaebd2ca
commit 9f0e9467f3cf7d2f72388512e477e7ddcaebd2ca
Merge: 4bf326d ec181a2
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Mon Apr 6 11:56:49 2015 -0400
Commit: CMake Topic Stage <kwrobot at kitware.com>
CommitDate: Mon Apr 6 11:56:49 2015 -0400
Merge topic 'introduce-cmConfiguration' into next
ec181a24 cmConfiguration: Move CacheEntryType enum from cmCacheManager.
b02569d7 cmMakefile: Remove unused CacheManager accessor.
e6eb1693 Port to cmConfiguration.
9754cb6f Introduce cmConfiguration class.
a94cddab cmCacheManager: Port consumers to non-iterator API.
eb509006 Port QtDialog to non-iterator cache API.
59c9744d Port CursesDialog to non-iterator cache API.
3a909de7 cmMakefile: Port away from CacheEntry.Initialized.
8951b57d cmCacheManager: Add non-iterator-based API.
2c4ff478 cmCacheManager: Rename GetCacheValue to GetInitializedCacheValue.
db25277d Add API for cache loading, deleting and saving to the cmake class.
6f3e57e9 cmMakefile: Remove cache version accessors.
4cf211dc cmMakefile: Simplify GetDefinitions implementation.
883042c3 Remove unused includes.
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=ec181a24bac55d270e8a17eb16a807bdd65c2c4b
commit ec181a24bac55d270e8a17eb16a807bdd65c2c4b
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Mon Apr 6 13:40:24 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Mon Apr 6 16:57:39 2015 +0200
cmConfiguration: Move CacheEntryType enum from cmCacheManager.
diff --git a/Source/CursesDialog/cmCursesBoolWidget.cxx b/Source/CursesDialog/cmCursesBoolWidget.cxx
index fd15b99..d6329c5 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 = cmConfiguration::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 f2b5895..e388409 100644
--- a/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
+++ b/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
@@ -55,7 +55,7 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
assert(value);
switch (cm->GetConfiguration()->GetCacheEntryType(key))
{
- case cmCacheManager::BOOL:
+ case cmConfiguration::BOOL:
this->Entry = new cmCursesBoolWidget(this->EntryWidth, 1, 1, 1);
if (cmSystemTools::IsOn(value))
{
@@ -66,15 +66,15 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
static_cast<cmCursesBoolWidget*>(this->Entry)->SetValueAsBool(false);
}
break;
- case cmCacheManager::PATH:
+ case cmConfiguration::PATH:
this->Entry = new cmCursesPathWidget(this->EntryWidth, 1, 1, 1);
static_cast<cmCursesPathWidget*>(this->Entry)->SetString(value);
break;
- case cmCacheManager::FILEPATH:
+ case cmConfiguration::FILEPATH:
this->Entry = new cmCursesFilePathWidget(this->EntryWidth, 1, 1, 1);
static_cast<cmCursesFilePathWidget*>(this->Entry)->SetString(value);
break;
- case cmCacheManager::STRING:
+ case cmConfiguration::STRING:
{
const char* stringsProp = cm->GetConfiguration()
->GetCacheEntryProperty(key, "STRINGS");
@@ -99,7 +99,7 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
}
break;
}
- case cmCacheManager::UNINITIALIZED:
+ case cmConfiguration::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..0c5c09d 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 = cmConfiguration::INTERNAL;
}
diff --git a/Source/CursesDialog/cmCursesFilePathWidget.cxx b/Source/CursesDialog/cmCursesFilePathWidget.cxx
index 01db014..fb04b44 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 = cmConfiguration::FILEPATH;
}
diff --git a/Source/CursesDialog/cmCursesMainForm.cxx b/Source/CursesDialog/cmCursesMainForm.cxx
index 6df8e6d..f97ea36 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"
@@ -118,11 +117,11 @@ void cmCursesMainForm::InitializeUI()
for(std::vector<std::string>::const_iterator it = cacheKeys.begin();
it != cacheKeys.end(); ++it)
{
- cmCacheManager::CacheEntryType t = this->CMakeInstance->GetConfiguration()
+ cmConfiguration::CacheEntryType t = this->CMakeInstance->GetConfiguration()
->GetCacheEntryType(*it);
- if (t != cmCacheManager::INTERNAL &&
- t != cmCacheManager::STATIC &&
- t != cmCacheManager::UNINITIALIZED)
+ if (t != cmConfiguration::INTERNAL &&
+ t != cmConfiguration::STATIC &&
+ t != cmConfiguration::UNINITIALIZED)
{
++count;
}
@@ -148,11 +147,11 @@ void cmCursesMainForm::InitializeUI()
it != cacheKeys.end(); ++it)
{
std::string key = *it;
- cmCacheManager::CacheEntryType t = this->CMakeInstance->GetConfiguration()
+ cmConfiguration::CacheEntryType t = this->CMakeInstance->GetConfiguration()
->GetCacheEntryType(*it);
- if (t == cmCacheManager::INTERNAL ||
- t == cmCacheManager::STATIC ||
- t == cmCacheManager::UNINITIALIZED )
+ if (t == cmConfiguration::INTERNAL ||
+ t == cmConfiguration::STATIC ||
+ t == cmConfiguration::UNINITIALIZED )
{
continue;
}
@@ -172,11 +171,11 @@ void cmCursesMainForm::InitializeUI()
it != cacheKeys.end(); ++it)
{
std::string key = *it;
- cmCacheManager::CacheEntryType t = this->CMakeInstance->GetConfiguration()
+ cmConfiguration::CacheEntryType t = this->CMakeInstance->GetConfiguration()
->GetCacheEntryType(*it);
- if (t == cmCacheManager::INTERNAL ||
- t == cmCacheManager::STATIC ||
- t == cmCacheManager::UNINITIALIZED )
+ if (t == cmConfiguration::INTERNAL ||
+ t == cmConfiguration::STATIC ||
+ t == cmConfiguration::UNINITIALIZED )
{
continue;
}
@@ -294,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() == cmConfiguration::STRING ||
+ cw->GetType() == cmConfiguration::PATH ||
+ cw->GetType() == cmConfiguration::FILEPATH )
{
cmCursesStringWidget* sw = static_cast<cmCursesStringWidget*>(cw);
sw->SetInEdit(false);
@@ -823,7 +822,7 @@ void cmCursesMainForm::FillCacheManagerFromUI()
std::string newValue = (*this->Entries)[i]->Entry->GetValue();
std::string fixedOldValue;
std::string fixedNewValue;
- cmCacheManager::CacheEntryType t =
+ cmConfiguration::CacheEntryType t =
this->CMakeInstance->GetConfiguration()
->GetCacheEntryType(cacheKey);
this->FixValue(t, oldValue, fixedOldValue);
@@ -841,15 +840,15 @@ void cmCursesMainForm::FillCacheManagerFromUI()
}
}
-void cmCursesMainForm::FixValue(cmCacheManager::CacheEntryType type,
+void cmCursesMainForm::FixValue(cmConfiguration::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 == cmConfiguration::PATH || type == cmConfiguration::FILEPATH)
{
cmSystemTools::ConvertToUnixSlashes(out);
}
- if(type == cmCacheManager::BOOL)
+ if(type == cmConfiguration::BOOL)
{
if(cmSystemTools::IsOff(out.c_str()))
{
diff --git a/Source/CursesDialog/cmCursesMainForm.h b/Source/CursesDialog/cmCursesMainForm.h
index 6455252..d410a26 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(cmConfiguration::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..83b8b79 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 = cmConfiguration::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..c1d1c7c 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 = cmConfiguration::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 == cmConfiguration::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..ce7df27 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 = cmConfiguration::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..67b6876 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 "../cmConfiguration.h"
#include "cmCursesStandardIncludes.h"
class cmCursesMainForm;
@@ -46,7 +46,7 @@ public:
/**
* Get the type of the widget (STRING, PATH etc...)
*/
- cmCacheManager::CacheEntryType GetType()
+ cmConfiguration::CacheEntryType GetType()
{ return this->Type; }
/**
@@ -77,7 +77,7 @@ protected:
cmCursesWidget(const cmCursesWidget& from);
void operator=(const cmCursesWidget&);
- cmCacheManager::CacheEntryType Type;
+ cmConfiguration::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 4c9eb01..97e68e8 100644
--- a/Source/QtDialog/QCMake.cxx
+++ b/Source/QtDialog/QCMake.cxx
@@ -200,9 +200,9 @@ void QCMake::setProperties(const QCMakePropertyList& newProps)
for(std::vector<std::string>::const_iterator it = cacheKeys.begin();
it != cacheKeys.end(); ++it)
{
- cmCacheManager::CacheEntryType t = config->GetCacheEntryType(*it);
- if(t == cmCacheManager::INTERNAL ||
- t == cmCacheManager::STATIC)
+ cmConfiguration::CacheEntryType t = config->GetCacheEntryType(*it);
+ if(t == cmConfiguration::INTERNAL ||
+ t == cmConfiguration::STATIC)
{
continue;
}
@@ -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);
+ cmConfiguration::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);
+ cmConfiguration::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);
+ cmConfiguration::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);
+ cmConfiguration::FILEPATH);
}
}
@@ -286,10 +286,10 @@ QCMakePropertyList QCMake::properties() const
for (std::vector<std::string>::const_iterator i = cacheKeys.begin();
i != cacheKeys.end(); ++i)
{
- cmCacheManager::CacheEntryType t = config->GetCacheEntryType(*i);
- if(t == cmCacheManager::INTERNAL ||
- t == cmCacheManager::STATIC ||
- t == cmCacheManager::UNINITIALIZED)
+ cmConfiguration::CacheEntryType t = config->GetCacheEntryType(*i);
+ if(t == cmConfiguration::INTERNAL ||
+ t == cmConfiguration::STATIC ||
+ t == cmConfiguration::UNINITIALIZED)
{
continue;
}
@@ -302,20 +302,20 @@ QCMakePropertyList QCMake::properties() const
config->GetCacheEntryProperty(*i, "HELPSTRING"));
prop.Value = QString::fromLocal8Bit(cachedValue);
prop.Advanced = config->GetCacheEntryPropertyAsBool(*i, "ADVANCED");
- if(t == cmCacheManager::BOOL)
+ if(t == cmConfiguration::BOOL)
{
prop.Type = QCMakeProperty::BOOL;
prop.Value = cmSystemTools::IsOn(cachedValue);
}
- else if(t == cmCacheManager::PATH)
+ else if(t == cmConfiguration::PATH)
{
prop.Type = QCMakeProperty::PATH;
}
- else if(t == cmCacheManager::FILEPATH)
+ else if(t == cmConfiguration::FILEPATH)
{
prop.Type = QCMakeProperty::FILEPATH;
}
- else if(t == cmCacheManager::STRING)
+ else if(t == cmConfiguration::STRING)
{
prop.Type = QCMakeProperty::STRING;
const char* stringsProperty =
diff --git a/Source/cmBuildCommand.cxx b/Source/cmBuildCommand.cxx
index 5d32437..c83c41f 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);
+ cmConfiguration::STRING);
return true;
}
diff --git a/Source/cmBuildNameCommand.cxx b/Source/cmBuildNameCommand.cxx
index 171ed0f..257d62e 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);
+ cmConfiguration::STRING);
}
return true;
}
@@ -74,7 +74,7 @@ bool cmBuildNameCommand
this->Makefile->AddCacheDefinition(args[0],
buildname.c_str(),
"Name of build.",
- cmCacheManager::STRING);
+ cmConfiguration::STRING);
return true;
}
diff --git a/Source/cmCPluginAPI.cxx b/Source/cmCPluginAPI.cxx
index 987a7b1..d27d4f5 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);
+ cmConfiguration::BOOL);
break;
case CM_CACHE_PATH:
mf->AddCacheDefinition(name,value,doc,
- cmCacheManager::PATH);
+ cmConfiguration::PATH);
break;
case CM_CACHE_FILEPATH:
mf->AddCacheDefinition(name,value,doc,
- cmCacheManager::FILEPATH);
+ cmConfiguration::FILEPATH);
break;
case CM_CACHE_STRING:
mf->AddCacheDefinition(name,value,doc,
- cmCacheManager::STRING);
+ cmConfiguration::STRING);
break;
case CM_CACHE_INTERNAL:
mf->AddCacheDefinition(name,value,doc,
- cmCacheManager::INTERNAL);
+ cmConfiguration::INTERNAL);
break;
case CM_CACHE_STATIC:
mf->AddCacheDefinition(name,value,doc,
- cmCacheManager::STATIC);
+ cmConfiguration::STATIC);
break;
}
}
diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx
index 1db057b..364f767 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;
+ cmConfiguration::CacheEntryType type = cmConfiguration::UNINITIALIZED;
if (cmake::ParseCacheEntry(arg, name, value, type))
{
diff --git a/Source/cmCacheManager.cxx b/Source/cmCacheManager.cxx
index 5387d0c..a469f41 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)
+ cmConfiguration::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 = cmConfiguration::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 = cmConfiguration::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 != cmConfiguration::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 = cmConfiguration::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", cmConfiguration::INTERNAL);
this->AddCacheEntry("CMAKE_CACHE_MAJOR_VERSION", "0",
"Major version of cmake used to create the "
- "current loaded cache", cmCacheManager::INTERNAL);
+ "current loaded cache", cmConfiguration::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 != cmConfiguration::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 = cmConfiguration::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", cmConfiguration::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", cmConfiguration::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", cmConfiguration::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", cmConfiguration::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;
+ cmConfiguration::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 != cmConfiguration::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 << ":" << cmConfiguration::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();
+ cmConfiguration::CacheEntryType t = i.GetType();
this->WritePropertyEntries(fout, i);
- if(t == cmCacheManager::INTERNAL)
+ if(t == cmConfiguration::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 << ":" << cmConfiguration::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 != cmConfiguration::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)
+ cmConfiguration::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 == cmConfiguration::FILEPATH || type == cmConfiguration::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 cmConfiguration::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 = cmConfiguration::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 = cmConfiguration::StringToCacheEntryType(value? value : "STRING");
}
else if(prop == "VALUE")
{
diff --git a/Source/cmCacheManager.h b/Source/cmCacheManager.h
index 36848c4..927651f 100644
--- a/Source/cmCacheManager.h
+++ b/Source/cmCacheManager.h
@@ -14,6 +14,8 @@
#include "cmStandardIncludes.h"
#include "cmPropertyMap.h"
+#include "cmConfiguration.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;
+ cmConfiguration::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(cmConfiguration::UNINITIALIZED),
+ Initialized(false)
{}
};
@@ -68,8 +71,10 @@ public:
std::string GetValue() const { return this->GetEntry().Value; }
bool GetValueAsBool() const;
void SetValue(const char*);
- CacheEntryType GetType() const { return this->GetEntry().Type; }
- void SetType(CacheEntryType ty) { this->GetEntry().Type = ty; }
+ cmConfiguration::CacheEntryType GetType() const
+ { return this->GetEntry().Type; }
+ void SetType(cmConfiguration::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);
+ cmConfiguration::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)
+ cmConfiguration::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,
+ cmConfiguration::CacheEntryType type);
///! Get a cache entry object for a key
CacheEntry *GetCacheEntry(const std::string& key);
diff --git a/Source/cmConfiguration.cxx b/Source/cmConfiguration.cxx
index 7e89c09..209cdd9 100644
--- a/Source/cmConfiguration.cxx
+++ b/Source/cmConfiguration.cxx
@@ -2,26 +2,59 @@
#include "cmConfiguration.h"
#include "cmake.h"
+#include "cmCacheManager.h"
cmConfiguration::cmConfiguration(cmake* cm)
: CMakeInstance(cm)
{
}
-cmCacheManager::CacheEntryType
-cmConfiguration::StringToCacheEntryType(const char* s)
+
+const char* cmCacheEntryTypes[] =
+{ "BOOL",
+ "PATH",
+ "FILEPATH",
+ "STRING",
+ "INTERNAL",
+ "STATIC",
+ "UNINITIALIZED",
+ 0
+};
+
+const char*
+cmConfiguration::CacheEntryTypeToString(cmConfiguration::CacheEntryType type)
{
- return cmCacheManager::StringToType(s);
+ if ( type > 6 )
+ {
+ return cmCacheEntryTypes[6];
+ }
+ return cmCacheEntryTypes[type];
}
-const char*
-cmConfiguration::CacheEntryTypeToString(cmCacheManager::CacheEntryType t)
+cmConfiguration::CacheEntryType
+cmConfiguration::StringToCacheEntryType(const char* s)
{
- return cmCacheManager::TypeToString(t);
+ int i = 0;
+ while(cmCacheEntryTypes[i])
+ {
+ if(strcmp(s, cmCacheEntryTypes[i]) == 0)
+ {
+ return static_cast<cmConfiguration::CacheEntryType>(i);
+ }
+ ++i;
+ }
+ return STRING;
}
bool cmConfiguration::IsCacheEntryType(std::string const& key)
{
- return cmCacheManager::IsType(key.c_str());
+ for(int i=0; cmCacheEntryTypes[i]; ++i)
+ {
+ if(strcmp(key.c_str(), cmCacheEntryTypes[i]) == 0)
+ {
+ return true;
+ }
+ }
+ return false;
}
std::vector<std::string> cmConfiguration::GetCacheEntryKeys() const
@@ -54,7 +87,7 @@ cmConfiguration::GetInitializedCacheValue(std::string const& key) const
return this->CMakeInstance->GetCacheManager()->GetInitializedCacheValue(key);
}
-cmCacheManager::CacheEntryType
+cmConfiguration::CacheEntryType
cmConfiguration::GetCacheEntryType(std::string const& key) const
{
cmCacheManager::CacheIterator it =
@@ -107,7 +140,7 @@ bool cmConfiguration::GetCacheEntryPropertyAsBool(std::string const& key,
void cmConfiguration::AddCacheEntry(const std::string& key, const char* value,
const char* helpString,
- cmCacheManager::CacheEntryType type)
+ cmConfiguration::CacheEntryType type)
{
this->CMakeInstance->GetCacheManager()->AddCacheEntry(key, value,
helpString, type);
diff --git a/Source/cmConfiguration.h b/Source/cmConfiguration.h
index d8f5916..72149fb 100644
--- a/Source/cmConfiguration.h
+++ b/Source/cmConfiguration.h
@@ -2,7 +2,7 @@
#ifndef cmConfiguration_h
#define cmConfiguration_h
-#include "cmCacheManager.h"
+#include "cmStandardIncludes.h"
class cmake;
@@ -11,21 +11,21 @@ class cmConfiguration
public:
cmConfiguration(cmake* cm);
- static cmCacheManager::CacheEntryType StringToCacheEntryType(const char*);
- static const char* CacheEntryTypeToString(cmCacheManager::CacheEntryType);
+ 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;
- cmCacheManager::CacheEntryType
- GetCacheEntryType(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,
- cmCacheManager::CacheEntryType type);
+ const char* helpString, CacheEntryType type);
void RemoveCacheEntry(std::string const& key);
void SetCacheEntryProperty(std::string const& key,
diff --git a/Source/cmCoreTryCompile.cxx b/Source/cmCoreTryCompile.cxx
index 59efa52..7217ce6 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);
+ cmConfiguration::INTERNAL);
if (!outputVariable.empty())
{
diff --git a/Source/cmExtraEclipseCDT4Generator.cxx b/Source/cmExtraEclipseCDT4Generator.cxx
index 7e53be2..63de734 100644
--- a/Source/cmExtraEclipseCDT4Generator.cxx
+++ b/Source/cmExtraEclipseCDT4Generator.cxx
@@ -222,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(), cmConfiguration::STRING,
true);
mf->GetCMakeInstance()->SaveCache(mf->GetHomeOutputDirectory());
}
@@ -243,7 +243,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout,
{
valueToUse = envVarValue;
mf->AddCacheDefinition(cacheEntryName, valueToUse.c_str(),
- cacheEntryName.c_str(), cmCacheManager::STRING,
+ cacheEntryName.c_str(), cmConfiguration::STRING,
true);
mf->GetCMakeInstance()->SaveCache(mf->GetHomeOutputDirectory());
}
diff --git a/Source/cmFindBase.cxx b/Source/cmFindBase.cxx
index f13ac1e..7cc0cd2 100644
--- a/Source/cmFindBase.cxx
+++ b/Source/cmFindBase.cxx
@@ -378,7 +378,7 @@ bool cmFindBase::CheckForVariableInCache()
// original value. Tell the subclass implementations to do
// this.
if(cached && config->GetCacheEntryType(this->VariableName)
- == cmCacheManager::UNINITIALIZED)
+ == cmConfiguration::UNINITIALIZED)
{
this->AlreadyInCacheWithoutMetaInfo = true;
}
diff --git a/Source/cmFindLibraryCommand.cxx b/Source/cmFindLibraryCommand.cxx
index c499f61..649d00b 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);
+ cmConfiguration::FILEPATH);
}
return true;
}
@@ -72,14 +71,14 @@ bool cmFindLibraryCommand
this->Makefile->AddCacheDefinition(this->VariableName,
library.c_str(),
this->VariableDocumentation.c_str(),
- cmCacheManager::FILEPATH);
+ cmConfiguration::FILEPATH);
return true;
}
std::string notfound = this->VariableName + "-NOTFOUND";
this->Makefile->AddCacheDefinition(this->VariableName,
notfound.c_str(),
this->VariableDocumentation.c_str(),
- cmCacheManager::FILEPATH);
+ cmConfiguration::FILEPATH);
return true;
}
diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx
index 4d7fd60..6336ee4 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);
+ cmConfiguration::PATH, true);
return found;
}
diff --git a/Source/cmFindPathCommand.cxx b/Source/cmFindPathCommand.cxx
index 49fbf45..4317076 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)
+ cmConfiguration::FILEPATH :cmConfiguration::PATH)
);
}
return true;
@@ -54,7 +53,7 @@ bool cmFindPathCommand
(this->VariableName, result.c_str(),
this->VariableDocumentation.c_str(),
(this->IncludeFileInPath) ?
- cmCacheManager::FILEPATH :cmCacheManager::PATH);
+ cmConfiguration::FILEPATH :cmConfiguration::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);
+ cmConfiguration::FILEPATH :cmConfiguration::PATH);
return true;
}
diff --git a/Source/cmFindProgramCommand.cxx b/Source/cmFindProgramCommand.cxx
index 4ee419c..75fe29b 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);
+ cmConfiguration::FILEPATH);
}
return true;
}
@@ -49,14 +48,14 @@ bool cmFindProgramCommand
this->Makefile->AddCacheDefinition(this->VariableName,
result.c_str(),
this->VariableDocumentation.c_str(),
- cmCacheManager::FILEPATH);
+ cmConfiguration::FILEPATH);
return true;
}
this->Makefile->AddCacheDefinition(this->VariableName,
(this->VariableName + "-NOTFOUND").c_str(),
this->VariableDocumentation.c_str(),
- cmCacheManager::FILEPATH);
+ cmConfiguration::FILEPATH);
return true;
}
diff --git a/Source/cmGetFilenameComponentCommand.cxx b/Source/cmGetFilenameComponentCommand.cxx
index 9aceb39..979e756 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" ? cmConfiguration::FILEPATH
+ : cmConfiguration::STRING);
}
this->Makefile->AddCacheDefinition
(args[0], result.c_str(), "",
- args[2] == "PATH" ? cmCacheManager::FILEPATH
- : cmCacheManager::STRING);
+ args[2] == "PATH" ? cmConfiguration::FILEPATH
+ : cmConfiguration::STRING);
}
else
{
diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx
index 1a0b20c..a9c73a7 100644
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@@ -311,7 +311,7 @@ void cmGlobalGenerator::FindMakeProgram(cmMakefile* mf)
makeProgram += saveFile;
mf->AddCacheDefinition("CMAKE_MAKE_PROGRAM", makeProgram.c_str(),
"make program",
- cmCacheManager::FILEPATH);
+ cmConfiguration::FILEPATH);
}
}
@@ -1116,7 +1116,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", cmConfiguration::INTERNAL);
// check for link libraries and include directories containing "NOTFOUND"
// and for infinite loops
@@ -1894,7 +1894,7 @@ void cmGlobalGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator *gen,
gen->GetCMakeInstance()->GetCacheDefinition("CMAKE_MAKE_PROGRAM");
this->GetCMakeInstance()->AddCacheEntry("CMAKE_MAKE_PROGRAM", make,
"make program",
- cmCacheManager::FILEPATH);
+ cmConfiguration::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..d36a6fc 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.", cmConfiguration::INTERNAL);
}
}
const char* edit_cmd = cm->GetCacheDefinition("CMAKE_EDIT_COMMAND");
diff --git a/Source/cmGlobalVisualStudio7Generator.cxx b/Source/cmGlobalVisualStudio7Generator.cxx
index 0e0e63a..2108715 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);
+ cmConfiguration::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);
+ cmConfiguration::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);
+ cmConfiguration::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);
+ cmConfiguration::INTERNAL);
}
std::vector<std::string> *cmGlobalVisualStudio7Generator::GetConfigurations()
diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx
index 0561a05..33349d2 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);
+ cmConfiguration::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", cmConfiguration::INTERNAL);
return id;
}
diff --git a/Source/cmIncludeExternalMSProjectCommand.cxx b/Source/cmIncludeExternalMSProjectCommand.cxx
index d40d8fe..a8b8c2e 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", cmConfiguration::INTERNAL);
}
// Create a target instance for this utility.
diff --git a/Source/cmLoadCacheCommand.cxx b/Source/cmLoadCacheCommand.cxx
index e2ae901..256eb31 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;
+ cmConfiguration::CacheEntryType type = cmConfiguration::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..22abb79 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);
+ cmConfiguration::INTERNAL);
}
//----------------------------------------------------------------------------
diff --git a/Source/cmLocalVisualStudio7Generator.cxx b/Source/cmLocalVisualStudio7Generator.cxx
index c4abeb2..2bbaab1 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);
+ cmConfiguration::INTERNAL);
}
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 6d57cc5..941aaf1 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -18,7 +18,6 @@
#include "cmGlobalGenerator.h"
#include "cmLocalGenerator.h"
#include "cmCommands.h"
-#include "cmCacheManager.h"
#include "cmConfiguration.h"
#include "cmFunctionBlocker.h"
#include "cmListFileCache.h"
@@ -1806,7 +1805,7 @@ 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,
+ cmConfiguration::CacheEntryType type,
bool force)
{
bool haveVal = value ? true : false;
@@ -1815,7 +1814,7 @@ void cmMakefile::AddCacheDefinition(const std::string& name, const char* value,
this->GetConfiguration()->GetInitializedCacheValue(name);
if(existingValue
&& (this->GetConfiguration()->GetCacheEntryType(name)
- == cmCacheManager::UNINITIALIZED))
+ == cmConfiguration::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
@@ -1824,7 +1823,7 @@ void cmMakefile::AddCacheDefinition(const std::string& name, const char* value,
val = existingValue;
haveVal = true;
}
- if ( type == cmCacheManager::PATH || type == cmCacheManager::FILEPATH )
+ if ( type == cmConfiguration::PATH || type == cmConfiguration::FILEPATH )
{
std::vector<std::string>::size_type cc;
std::vector<std::string> files;
@@ -3617,7 +3616,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", cmConfiguration::STRING);
}
}
// if cmake args were provided then pass them in
@@ -3656,12 +3655,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", "", cmConfiguration::INTERNAL);
}
else
{
cm.AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS",
- "FALSE", "", cmCacheManager::INTERNAL);
+ "FALSE", "", cmConfiguration::INTERNAL);
}
if (cm.Configure() != 0)
{
@@ -4914,7 +4913,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);
+ cmConfiguration::STRING);
}
}
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index aa48e8a..5ba7d19 100644
--- a/Source/cmMakefile.h
+++ b/Source/cmMakefile.h
@@ -22,6 +22,7 @@
#include "cmGeneratorTarget.h"
#include "cmExpandedCommandArgument.h"
#include "cmake.h"
+#include "cmConfiguration.h"
#if defined(CMAKE_BUILD_WITH_CMAKE)
#include "cmSourceGroup.h"
@@ -305,7 +306,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,
+ cmConfiguration::CacheEntryType type,
bool force = false);
/**
diff --git a/Source/cmMarkAsAdvancedCommand.cxx b/Source/cmMarkAsAdvancedCommand.cxx
index e89cf99..5ed1ea1 100644
--- a/Source/cmMarkAsAdvancedCommand.cxx
+++ b/Source/cmMarkAsAdvancedCommand.cxx
@@ -39,7 +39,7 @@ bool cmMarkAsAdvancedCommand
cmConfiguration* config = this->Makefile->GetConfiguration();
if (!config->GetCacheEntryValue(variable))
{
- config->AddCacheEntry(variable, 0, 0, cmCacheManager::UNINITIALIZED);
+ config->AddCacheEntry(variable, 0, 0, cmConfiguration::UNINITIALIZED);
overwrite = true;
}
if (!config->GetCacheEntryValue(variable))
diff --git a/Source/cmOptionCommand.cxx b/Source/cmOptionCommand.cxx
index 64b3d39..c3d254f 100644
--- a/Source/cmOptionCommand.cxx
+++ b/Source/cmOptionCommand.cxx
@@ -46,7 +46,7 @@ bool cmOptionCommand
const char* existingValue = config->GetCacheEntryValue(args[0]);
if(existingValue)
{
- if (config->GetCacheEntryType(args[0]) != cmCacheManager::UNINITIALIZED)
+ if (config->GetCacheEntryType(args[0]) != cmConfiguration::UNINITIALIZED)
{
config->SetCacheEntryProperty(args[0], "HELPSTRING", args[1]);
return true;
@@ -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(), cmConfiguration::BOOL);
return true;
}
diff --git a/Source/cmProjectCommand.cxx b/Source/cmProjectCommand.cxx
index 61c0133..c26173e 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", cmConfiguration::STATIC);
this->Makefile->AddCacheDefinition
(srcdir,
this->Makefile->GetCurrentDirectory(),
- "Value Computed by CMake", cmCacheManager::STATIC);
+ "Value Computed by CMake", cmConfiguration::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", cmConfiguration::STATIC);
}
bool haveVersion = false;
diff --git a/Source/cmSetCommand.cxx b/Source/cmSetCommand.cxx
index ead2080..d74944e 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
+ cmConfiguration::CacheEntryType type
+ = cmConfiguration::STRING; // required if cache
const char* docstring = 0; // required if cache
unsigned int ignoreLastArgs = 0;
@@ -131,7 +131,7 @@ bool cmSetCommand
if(cache)
{
std::string::size_type cacheStart = args.size() - 3 - (force ? 1 : 0);
- type = cmCacheManager::StringToType(args[cacheStart+1].c_str());
+ type = cmConfiguration::StringToCacheEntryType(args[cacheStart+1].c_str());
docstring = args[cacheStart+2].c_str();
}
@@ -139,13 +139,13 @@ bool cmSetCommand
cmConfiguration* config = this->Makefile->GetConfiguration();
const char* existingValue = config->GetCacheEntryValue(variable);
if(existingValue &&
- (config->GetCacheEntryType(variable) != cmCacheManager::UNINITIALIZED))
+ (config->GetCacheEntryType(variable) != cmConfiguration::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 != cmConfiguration::INTERNAL && !force)
{
return true;
}
diff --git a/Source/cmSetPropertyCommand.cxx b/Source/cmSetPropertyCommand.cxx
index b6f8590..87fb475 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(!cmConfiguration::IsCacheEntryType(this->PropertyValue.c_str()))
{
std::ostringstream e;
e << "given invalid CACHE entry TYPE \"" << this->PropertyValue << "\"";
diff --git a/Source/cmSiteNameCommand.cxx b/Source/cmSiteNameCommand.cxx
index 927888b..836f342 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);
+ cmConfiguration::STRING);
return true;
}
diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx
index b3d1155..ad461f0 100644
--- a/Source/cmTarget.cxx
+++ b/Source/cmTarget.cxx
@@ -1181,7 +1181,7 @@ void cmTarget::ClearDependencyInformation( cmMakefile& mf,
if (this->RecordDependencies)
{
mf.AddCacheDefinition(depname, "",
- "Dependencies for target", cmCacheManager::STATIC);
+ "Dependencies for target", cmConfiguration::STATIC);
}
else
{
@@ -1369,7 +1369,7 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf,
dependencies += ";";
mf.AddCacheDefinition( targetEntry, dependencies.c_str(),
"Dependencies for the target",
- cmCacheManager::STATIC );
+ cmConfiguration::STATIC );
}
}
diff --git a/Source/cmTryRunCommand.cxx b/Source/cmTryRunCommand.cxx
index 60f48ae..3cd8291 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>
@@ -217,7 +216,7 @@ void cmTryRunCommand::RunExecutable(const std::string& runArgs,
}
this->Makefile->AddCacheDefinition(this->RunResultVariable, retChar,
"Result of TRY_RUN",
- cmCacheManager::INTERNAL);
+ cmConfiguration::INTERNAL);
}
/* This is only used when cross compiling. Instead of running the
@@ -262,7 +261,7 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
this->Makefile->AddCacheDefinition(this->RunResultVariable,
"PLEASE_FILL_OUT-FAILED_TO_RUN",
comment.c_str(),
- cmCacheManager::STRING);
+ cmConfiguration::STRING);
cmConfiguration* config = this->Makefile->GetConfiguration();
const char* existingValue
@@ -290,7 +289,7 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
this->Makefile->AddCacheDefinition(internalRunOutputName,
"PLEASE_FILL_OUT-NOTFOUND",
comment.c_str(),
- cmCacheManager::STRING);
+ cmConfiguration::STRING);
cmConfiguration* config = this->Makefile->GetConfiguration();
const char* existing =
config->GetCacheEntryValue(internalRunOutputName);
diff --git a/Source/cmUtilitySourceCommand.cxx b/Source/cmUtilitySourceCommand.cxx
index 2799a9b..b68afbc 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);
+ cmConfiguration::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);
+ cmConfiguration::INTERNAL);
return true;
}
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index 186b2de..328e273 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -338,7 +338,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
}
}
std::string var, value;
- cmCacheManager::CacheEntryType type = cmCacheManager::UNINITIALIZED;
+ cmConfiguration::CacheEntryType type = cmConfiguration::UNINITIALIZED;
if(cmCacheManager::ParseEntry(entry, var, value, type))
{
// The value is transformed if it is a filepath for example, so
@@ -412,9 +412,9 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
for (std::vector<std::string>::const_iterator it = cacheKeys.begin();
it != cacheKeys.end(); ++it)
{
- cmCacheManager::CacheEntryType t =
+ cmConfiguration::CacheEntryType t =
this->Configuration->GetCacheEntryType(*it);
- if(t != cmCacheManager::STATIC)
+ if(t != cmConfiguration::STATIC)
{
if (regex.find(it->c_str()))
{
@@ -979,14 +979,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.", cmConfiguration::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.", cmConfiguration::INTERNAL);
this->CacheManager->AddCacheEntry
("CMAKE_CPACK_COMMAND", cmSystemTools::GetCPackCommand().c_str(),
- "Path to cpack program executable.", cmCacheManager::INTERNAL);
+ "Path to cpack program executable.", cmConfiguration::INTERNAL);
#endif
if(!cmSystemTools::FileExists(
(cmSystemTools::GetCMakeRoot()+"/Modules/CMake.cmake").c_str()))
@@ -1000,7 +1000,7 @@ int cmake::AddCMakePaths()
}
this->CacheManager->AddCacheEntry
("CMAKE_ROOT", cmSystemTools::GetCMakeRoot().c_str(),
- "Path to CMake installation.", cmCacheManager::INTERNAL);
+ "Path to CMake installation.", cmConfiguration::INTERNAL);
return 1;
}
@@ -1242,7 +1242,7 @@ struct SaveCacheEntry
std::string key;
std::string value;
std::string help;
- cmCacheManager::CacheEntryType type;
+ cmConfiguration::CacheEntryType type;
};
int cmake::HandleDeleteCacheVariables(const std::string& var)
@@ -1315,7 +1315,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);
+ cmConfiguration::INTERNAL);
}
else
{
@@ -1323,7 +1323,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);
+ cmConfiguration::INTERNAL);
}
}
int ret = this->ActualConfigure();
@@ -1359,7 +1359,7 @@ int cmake::ActualConfigure()
this->GetHomeDirectory(),
"Start directory with the top level CMakeLists.txt file for this "
"project",
- cmCacheManager::INTERNAL);
+ cmConfiguration::INTERNAL);
}
// no generator specified on the command line
@@ -1468,11 +1468,11 @@ int cmake::ActualConfigure()
this->CacheManager->AddCacheEntry("CMAKE_GENERATOR",
this->GlobalGenerator->GetName().c_str(),
"Name of generator.",
- cmCacheManager::INTERNAL);
+ cmConfiguration::INTERNAL);
this->CacheManager->AddCacheEntry("CMAKE_EXTRA_GENERATOR",
this->GlobalGenerator->GetExtraGeneratorName().c_str(),
"Name of external makefile project generator.",
- cmCacheManager::INTERNAL);
+ cmConfiguration::INTERNAL);
}
if(const char* platformName =
@@ -1500,7 +1500,7 @@ int cmake::ActualConfigure()
this->CacheManager->AddCacheEntry("CMAKE_GENERATOR_PLATFORM",
this->GeneratorPlatform.c_str(),
"Name of generator platform.",
- cmCacheManager::INTERNAL);
+ cmConfiguration::INTERNAL);
}
if(const char* tsName =
@@ -1528,7 +1528,7 @@ int cmake::ActualConfigure()
this->CacheManager->AddCacheEntry("CMAKE_GENERATOR_TOOLSET",
this->GeneratorToolset.c_str(),
"Name of generator toolset.",
- cmCacheManager::INTERNAL);
+ cmConfiguration::INTERNAL);
}
// reset any system configuration information, except for when we are
@@ -1566,7 +1566,7 @@ int cmake::ActualConfigure()
this->Configuration->AddCacheEntry
("LIBRARY_OUTPUT_PATH", "",
"Single output directory for building all libraries.",
- cmCacheManager::PATH);
+ cmConfiguration::PATH);
}
if(!this->Configuration
->GetInitializedCacheValue("EXECUTABLE_OUTPUT_PATH"))
@@ -1574,7 +1574,7 @@ int cmake::ActualConfigure()
this->Configuration->AddCacheEntry
("EXECUTABLE_OUTPUT_PATH", "",
"Single output directory for building all executables.",
- cmCacheManager::PATH);
+ cmConfiguration::PATH);
}
}
if(!this->Configuration
@@ -1583,7 +1583,7 @@ int cmake::ActualConfigure()
this->Configuration->AddCacheEntry
("CMAKE_USE_RELATIVE_PATHS", "OFF",
"If true, cmake will use relative paths in makefiles and projects.",
- cmCacheManager::BOOL);
+ cmConfiguration::BOOL);
if (!this->Configuration->GetCacheEntryProperty("CMAKE_USE_RELATIVE_PATHS",
"ADVANCED"))
{
@@ -1808,7 +1808,7 @@ void cmake::AddCacheEntry(const std::string& key, const char* value,
{
this->CacheManager->AddCacheEntry(key, value,
helpString,
- cmCacheManager::CacheEntryType(type));
+ cmConfiguration::CacheEntryType(type));
}
const char* cmake::GetCacheDefinition(const std::string& name) const
@@ -1880,7 +1880,7 @@ void cmake::AddDefaultGenerators()
bool cmake::ParseCacheEntry(const std::string& entry,
std::string& var,
std::string& value,
- cmCacheManager::CacheEntryType& type)
+ cmConfiguration::CacheEntryType& type)
{
return cmCacheManager::ParseEntry(entry, var, value, type);
}
diff --git a/Source/cmake.h b/Source/cmake.h
index 5b10288..1debfeb 100644
--- a/Source/cmake.h
+++ b/Source/cmake.h
@@ -19,6 +19,7 @@
#include "cmPropertyMap.h"
#include "cmInstalledFile.h"
#include "cmCacheManager.h"
+#include "cmConfiguration.h"
class cmGlobalGeneratorFactory;
class cmGlobalGenerator;
@@ -178,7 +179,7 @@ class cmake
static bool ParseCacheEntry(const std::string& entry,
std::string& var,
std::string& value,
- cmCacheManager::CacheEntryType& type);
+ cmConfiguration::CacheEntryType& type);
int LoadCache();
bool LoadCache(const std::string& path);
diff --git a/Source/cmakemain.cxx b/Source/cmakemain.cxx
index 7960b47..9ab49ee 100644
--- a/Source/cmakemain.cxx
+++ b/Source/cmakemain.cxx
@@ -19,7 +19,6 @@
#include "cmake.h"
#include "cmcmd.h"
#include "cmConfiguration.h"
-#include "cmCacheManager.h"
#include "cmListFileCache.h"
#include "cmSourceFile.h"
#include "cmGlobalGenerator.h"
@@ -335,10 +334,10 @@ int do_cmake(int ac, char const* const* av)
for (std::vector<std::string>::const_iterator it = keys.begin();
it != keys.end(); ++it)
{
- cmCacheManager::CacheEntryType t =
+ cmConfiguration::CacheEntryType t =
cm.GetConfiguration()->GetCacheEntryType(*it);
- if ( t != cmCacheManager::INTERNAL && t != cmCacheManager::STATIC &&
- t != cmCacheManager::UNINITIALIZED )
+ if ( t != cmConfiguration::INTERNAL && t != cmConfiguration::STATIC &&
+ t != cmConfiguration::UNINITIALIZED )
{
const char* advancedProp =
cm.GetConfiguration()->GetCacheEntryProperty(*it, "ADVANCED");
@@ -351,7 +350,7 @@ int do_cmake(int ac, char const* const* av)
"HELPSTRING") << std::endl;
}
std::cout << *it << ":" <<
- cmCacheManager::TypeToString(t)
+ cmConfiguration::CacheEntryTypeToString(t)
<< "=" << cm.GetConfiguration()->GetCacheEntryValue(*it)
<< std::endl;
if ( list_help )
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=b02569d78f292adf31efcb8f8f023d07462db1a8
commit b02569d78f292adf31efcb8f8f023d07462db1a8
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Mon Apr 6 13:34:03 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Mon Apr 6 16:57:38 2015 +0200
cmMakefile: Remove unused CacheManager accessor.
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 0d847fa..6d57cc5 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -3735,11 +3735,6 @@ void cmMakefile::GetListOfMacros(std::string& macros) const
macros = cmJoin(this->MacrosList, ";");
}
-cmCacheManager *cmMakefile::GetCacheManager() const
-{
- return this->GetCMakeInstance()->GetCacheManager();
-}
-
cmConfiguration *cmMakefile::GetConfiguration() const
{
return this->GetCMakeInstance()->GetConfiguration();
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index 8c896e4..aa48e8a 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"
@@ -765,7 +764,6 @@ public:
///enabled.
void EnableLanguage(std::vector<std::string>const& languages, bool optional);
- cmCacheManager *GetCacheManager() const;
cmConfiguration *GetConfiguration() const;
/**
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=e6eb16933aa26a8bda70caa1ff41498a0d62281b
commit e6eb16933aa26a8bda70caa1ff41498a0d62281b
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Mon Apr 6 10:52:45 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Mon Apr 6 16:57:38 2015 +0200
Port to cmConfiguration.
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/cmCursesCacheEntryComposite.cxx b/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
index 4f028c4..f2b5895 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 "../cmConfiguration.h"
#include <assert.h>
@@ -50,9 +51,9 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
}
this->Entry = 0;
- const char* value = cm->GetCacheManager()->GetCacheEntryValue(key);
+ const char* value = cm->GetConfiguration()->GetCacheEntryValue(key);
assert(value);
- switch (cm->GetCacheManager()->GetCacheEntryType(key))
+ switch (cm->GetConfiguration()->GetCacheEntryType(key))
{
case cmCacheManager::BOOL:
this->Entry = new cmCursesBoolWidget(this->EntryWidth, 1, 1, 1);
@@ -75,7 +76,7 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
break;
case cmCacheManager::STRING:
{
- const char* stringsProp = cm->GetCacheManager()
+ const char* stringsProp = cm->GetConfiguration()
->GetCacheEntryProperty(key, "STRINGS");
if(stringsProp)
{
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..6df8e6d 100644
--- a/Source/CursesDialog/cmCursesMainForm.cxx
+++ b/Source/CursesDialog/cmCursesMainForm.cxx
@@ -23,6 +23,7 @@
#include "cmCursesCacheEntryComposite.h"
#include "cmCursesLongMessageForm.h"
#include "cmAlgorithms.h"
+#include "cmConfiguration.h"
inline int ctrl(int z)
@@ -107,17 +108,17 @@ 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->GetConfiguration()->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()
+ cmCacheManager::CacheEntryType t = this->CMakeInstance->GetConfiguration()
->GetCacheEntryType(*it);
if (t != cmCacheManager::INTERNAL &&
t != cmCacheManager::STATIC &&
@@ -147,7 +148,7 @@ void cmCursesMainForm::InitializeUI()
it != cacheKeys.end(); ++it)
{
std::string key = *it;
- cmCacheManager::CacheEntryType t = this->CMakeInstance->GetCacheManager()
+ cmCacheManager::CacheEntryType t = this->CMakeInstance->GetConfiguration()
->GetCacheEntryType(*it);
if (t == cmCacheManager::INTERNAL ||
t == cmCacheManager::STATIC ||
@@ -171,7 +172,7 @@ void cmCursesMainForm::InitializeUI()
it != cacheKeys.end(); ++it)
{
std::string key = *it;
- cmCacheManager::CacheEntryType t = this->CMakeInstance->GetCacheManager()
+ cmCacheManager::CacheEntryType t = this->CMakeInstance->GetConfiguration()
->GetCacheEntryType(*it);
if (t == cmCacheManager::INTERNAL ||
t == cmCacheManager::STATIC ||
@@ -225,10 +226,10 @@ void cmCursesMainForm::RePost()
for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
{
const char* existingValue =
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetConfiguration()
->GetCacheEntryValue((*it)->GetValue());
bool advanced =
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetConfiguration()
->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
if (!existingValue || (!this->AdvancedMode && advanced))
{
@@ -257,10 +258,10 @@ void cmCursesMainForm::RePost()
for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
{
const char* existingValue =
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetConfiguration()
->GetCacheEntryValue((*it)->GetValue());
bool advanced =
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetConfiguration()
->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
if (!existingValue || (!this->AdvancedMode && advanced))
{
@@ -329,10 +330,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->GetConfiguration()
->GetCacheEntryValue((*it)->GetValue());
bool advanced =
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetConfiguration()
->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
if (!existingValue || (!this->AdvancedMode && advanced))
{
@@ -352,10 +353,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->GetConfiguration()
->GetCacheEntryValue((*it)->GetValue());
bool advanced =
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetConfiguration()
->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
if (!existingValue || (!this->AdvancedMode && advanced))
{
@@ -516,10 +517,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->GetConfiguration()->GetCacheEntryValue(curField);
if (existingValue)
{
- const char* hs = this->CMakeInstance->GetCacheManager()
+ const char* hs = this->CMakeInstance->GetConfiguration()
->GetCacheEntryProperty(curField, "HELPSTRING");
if ( hs )
{
@@ -814,7 +815,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->GetConfiguration()
->GetCacheEntryValue(cacheKey);
if (existingValue)
{
@@ -823,7 +824,7 @@ void cmCursesMainForm::FillCacheManagerFromUI()
std::string fixedOldValue;
std::string fixedNewValue;
cmCacheManager::CacheEntryType t =
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetConfiguration()
->GetCacheEntryType(cacheKey);
this->FixValue(t, oldValue, fixedOldValue);
this->FixValue(t, newValue, fixedNewValue);
@@ -831,9 +832,9 @@ void cmCursesMainForm::FillCacheManagerFromUI()
if(!(fixedOldValue == fixedNewValue))
{
// The user has changed the value. Mark it as modified.
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetConfiguration()
->SetCacheEntryBoolProperty(cacheKey, "MODIFIED", true);
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetConfiguration()
->SetCacheEntryValue(cacheKey, fixedNewValue);
}
}
@@ -1046,11 +1047,11 @@ void cmCursesMainForm::HandleInput()
const char* helpString = 0;
const char* existingValue =
- this->CMakeInstance->GetCacheManager()
+ this->CMakeInstance->GetConfiguration()
->GetCacheEntryValue(curField);
if (existingValue)
{
- helpString = this->CMakeInstance->GetCacheManager()
+ helpString = this->CMakeInstance->GetConfiguration()
->GetCacheEntryProperty(curField, "HELPSTRING");
}
if (helpString)
@@ -1161,7 +1162,7 @@ void cmCursesMainForm::HandleInput()
field_userptr(this->Fields[findex-2]));
if ( lbl )
{
- this->CMakeInstance->GetCacheManager()->RemoveCacheEntry(lbl->GetValue());
+ this->CMakeInstance->GetConfiguration()->RemoveCacheEntry(lbl->GetValue());
std::string nextVal;
if (nextCur)
diff --git a/Source/QtDialog/QCMake.cxx b/Source/QtDialog/QCMake.cxx
index 08d53ce..4c9eb01 100644
--- a/Source/QtDialog/QCMake.cxx
+++ b/Source/QtDialog/QCMake.cxx
@@ -16,7 +16,7 @@
#include <QCoreApplication>
#include "cmake.h"
-#include "cmCacheManager.h"
+#include "cmConfiguration.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();
+ cmConfiguration *config = this->CMakeInstance->GetConfiguration();
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 = config->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
if (homeDir)
{
setSourceDirectory(QString::fromLocal8Bit(homeDir));
}
- const char* gen = cachem->GetCacheEntryValue("CMAKE_GENERATOR");
+ const char* gen = config->GetCacheEntryValue("CMAKE_GENERATOR");
if (gen)
{
- const char* extraGen = cachem
+ const char* extraGen = config
->GetInitializedCacheValue("CMAKE_EXTRA_GENERATOR");
std::string curGen = cmExternalMakefileProjectGenerator::
CreateFullGeneratorName(gen, extraGen? extraGen : "");
@@ -195,12 +195,12 @@ 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();
+ cmConfiguration *config = this->CMakeInstance->GetConfiguration();
+ std::vector<std::string> cacheKeys = config->GetCacheEntryKeys();
for(std::vector<std::string>::const_iterator it = cacheKeys.begin();
it != cacheKeys.end(); ++it)
{
- cmCacheManager::CacheEntryType t = cachem->GetCacheEntryType(*it);
+ cmCacheManager::CacheEntryType t = config->GetCacheEntryType(*it);
if(t == cmCacheManager::INTERNAL ||
t == cmCacheManager::STATIC)
{
@@ -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");
+ config->SetCacheEntryValue(*it, prop.Value.toBool() ? "ON" : "OFF");
}
else
{
- cachem->SetCacheEntryValue(*it,
+ config->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());
+ config->RemoveCacheEntry(s.toLocal8Bit().data());
}
// add some new properites
@@ -281,12 +281,12 @@ QCMakePropertyList QCMake::properties() const
{
QCMakePropertyList ret;
- cmCacheManager *cachem = this->CMakeInstance->GetCacheManager();
- std::vector<std::string> cacheKeys = cachem->GetCacheEntryKeys();
+ cmConfiguration *config = this->CMakeInstance->GetConfiguration();
+ std::vector<std::string> cacheKeys = config->GetCacheEntryKeys();
for (std::vector<std::string>::const_iterator i = cacheKeys.begin();
i != cacheKeys.end(); ++i)
{
- cmCacheManager::CacheEntryType t = cachem->GetCacheEntryType(*i);
+ cmCacheManager::CacheEntryType t = config->GetCacheEntryType(*i);
if(t == cmCacheManager::INTERNAL ||
t == cmCacheManager::STATIC ||
t == cmCacheManager::UNINITIALIZED)
@@ -294,14 +294,14 @@ QCMakePropertyList QCMake::properties() const
continue;
}
- const char* cachedValue = cachem->GetCacheEntryValue(*i);
+ const char* cachedValue = config->GetCacheEntryValue(*i);
QCMakeProperty prop;
prop.Key = QString::fromLocal8Bit(i->c_str());
prop.Help = QString::fromLocal8Bit(
- cachem->GetCacheEntryProperty(*i, "HELPSTRING"));
+ config->GetCacheEntryProperty(*i, "HELPSTRING"));
prop.Value = QString::fromLocal8Bit(cachedValue);
- prop.Advanced = cachem->GetCacheEntryPropertyAsBool(*i, "ADVANCED");
+ prop.Advanced = config->GetCacheEntryPropertyAsBool(*i, "ADVANCED");
if(t == cmCacheManager::BOOL)
{
prop.Type = QCMakeProperty::BOOL;
@@ -319,7 +319,7 @@ QCMakePropertyList QCMake::properties() const
{
prop.Type = QCMakeProperty::STRING;
const char* stringsProperty =
- cachem->GetCacheEntryProperty(*i, "STRINGS");
+ config->GetCacheEntryProperty(*i, "STRINGS");
if (stringsProperty)
{
prop.Strings = QString::fromLocal8Bit(stringsProperty).split(";");
diff --git a/Source/cmCommandArgumentParserHelper.cxx b/Source/cmCommandArgumentParserHelper.cxx
index 99bf5f5..0e4dd4b 100644
--- a/Source/cmCommandArgumentParserHelper.cxx
+++ b/Source/cmCommandArgumentParserHelper.cxx
@@ -13,6 +13,7 @@
#include "cmSystemTools.h"
#include "cmMakefile.h"
+#include "cmConfiguration.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->GetConfiguration()
->GetInitializedCacheValue(var))
{
if(this->EscapeQuotes)
diff --git a/Source/cmExtraEclipseCDT4Generator.cxx b/Source/cmExtraEclipseCDT4Generator.cxx
index 0d32e4b..7e53be2 100644
--- a/Source/cmExtraEclipseCDT4Generator.cxx
+++ b/Source/cmExtraEclipseCDT4Generator.cxx
@@ -16,6 +16,7 @@
#include "cmLocalUnixMakefileGenerator3.h"
#include "cmMakefile.h"
#include "cmGeneratedFileStream.h"
+#include "cmConfiguration.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->GetConfiguration()->GetInitializedCacheValue(
cacheEntryName);
// now we have both, decide which one to use
diff --git a/Source/cmFindBase.cxx b/Source/cmFindBase.cxx
index cc08052..f13ac1e 100644
--- a/Source/cmFindBase.cxx
+++ b/Source/cmFindBase.cxx
@@ -12,6 +12,7 @@
#include "cmFindBase.h"
#include "cmAlgorithms.h"
+#include "cmConfiguration.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);
+ cmConfiguration* config = this->Makefile->GetConfiguration();
+ const char* cacheEntry = config->GetCacheEntryValue(this->VariableName);
bool found = !cmSystemTools::IsNOTFOUND(cacheValue);
bool cached = cacheEntry ? true : false;
if(found)
@@ -376,7 +377,7 @@ 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)
+ if(cached && config->GetCacheEntryType(this->VariableName)
== cmCacheManager::UNINITIALIZED)
{
this->AlreadyInCacheWithoutMetaInfo = true;
@@ -385,7 +386,7 @@ bool cmFindBase::CheckForVariableInCache()
}
else if(cached)
{
- const char* hs = manager->GetCacheEntryProperty(this->VariableName,
+ const char* hs = config->GetCacheEntryProperty(this->VariableName,
"HELPSTRING");
this->VariableDocumentation = hs?hs:"(none)";
}
diff --git a/Source/cmGetPropertyCommand.cxx b/Source/cmGetPropertyCommand.cxx
index 0e6e0c2..1fe53ac 100644
--- a/Source/cmGetPropertyCommand.cxx
+++ b/Source/cmGetPropertyCommand.cxx
@@ -12,6 +12,7 @@
#include "cmGetPropertyCommand.h"
#include "cmake.h"
+#include "cmConfiguration.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->GetConfiguration()->GetCacheEntryValue(this->Name))
{
- value = this->Makefile->GetCacheManager()
+ value = this->Makefile->GetConfiguration()
->GetCacheEntryProperty(this->Name, this->PropertyName);
}
this->StoreResult(value);
diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx
index 35394b8..1a0b20c 100644
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@@ -20,6 +20,7 @@
#include "cmLocalGenerator.h"
#include "cmExternalMakefileProjectGenerator.h"
#include "cmake.h"
+#include "cmConfiguration.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);
+ GetConfiguration()->GetInitializedCacheValue(langComp);
std::string changeVars;
if(cname && !optional)
{
@@ -1537,7 +1538,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();
+ cmConfiguration* config = this->GetCMakeInstance()->GetConfiguration();
for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
{
this->LocalGenerators[i]->ConfigureFinalPass();
@@ -1559,7 +1560,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(config->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
{
varName += " (ADVANCED)";
}
@@ -1590,7 +1591,7 @@ void cmGlobalGenerator::CheckLocalGenerators()
cmSystemTools::IsNOTFOUND(incDir->c_str()))
{
std::string varName = incDir->substr(0, incDir->size()-9);
- if(manager->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
+ if(config->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
{
varName += " (ADVANCED)";
}
@@ -1637,7 +1638,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->GetConfiguration()->GetInitializedCacheValue
("CMAKE_NUMBER_OF_LOCAL_GENERATORS"))
{
// If CMAKE_NUMBER_OF_LOCAL_GENERATORS is not set
@@ -1835,7 +1836,7 @@ void cmGlobalGenerator::AddLocalGenerator(cmLocalGenerator *lg)
// update progress
// estimate how many lg there will be
const char *numGenC =
- this->CMakeInstance->GetCacheManager()->GetInitializedCacheValue
+ this->CMakeInstance->GetConfiguration()->GetInitializedCacheValue
("CMAKE_NUMBER_OF_LOCAL_GENERATORS");
if (!numGenC)
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index b1450a8..0d847fa 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -1812,9 +1812,9 @@ void cmMakefile::AddCacheDefinition(const std::string& name, const char* value,
bool haveVal = value ? true : false;
std::string val = haveVal ? value : "";
const char* existingValue =
- this->GetCacheManager()->GetInitializedCacheValue(name);
+ this->GetConfiguration()->GetInitializedCacheValue(name);
if(existingValue
- && (this->GetCacheManager()->GetCacheEntryType(name)
+ && (this->GetConfiguration()->GetCacheEntryType(name)
== cmCacheManager::UNINITIALIZED))
{
// if this is not a force, then use the value from the cache
@@ -1843,14 +1843,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->GetConfiguration()->AddCacheEntry(name, nvalue.c_str(), doc, type);
+ val = this->GetConfiguration()->GetInitializedCacheValue(name);
haveVal = true;
}
}
- this->GetCacheManager()->AddCacheEntry(name, haveVal ? val.c_str() : 0,
- doc, type);
+ this->GetConfiguration()->AddCacheEntry(name, haveVal ? val.c_str() : 0,
+ doc, type);
// if there was a definition then remove it
this->Internal->VarStack.top().Set(name, 0);
}
@@ -1977,7 +1977,7 @@ void cmMakefile::RemoveDefinition(const std::string& name)
void cmMakefile::RemoveCacheDefinition(const std::string& name)
{
- this->GetCacheManager()->RemoveCacheEntry(name);
+ this->GetConfiguration()->RemoveCacheEntry(name);
}
void cmMakefile::SetProjectName(const char* p)
@@ -2434,7 +2434,7 @@ bool cmMakefile::IsDefinitionSet(const std::string& name) const
this->Internal->VarUsageStack.top().insert(name);
if(!def)
{
- def = this->GetCacheManager()->GetInitializedCacheValue(name);
+ def = this->GetConfiguration()->GetInitializedCacheValue(name);
}
#ifdef CMAKE_BUILD_WITH_CMAKE
if(cmVariableWatch* vv = this->GetVariableWatch())
@@ -2459,7 +2459,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->GetConfiguration()->GetInitializedCacheValue(name);
}
#ifdef CMAKE_BUILD_WITH_CMAKE
cmVariableWatch* vv = this->GetVariableWatch();
@@ -2501,7 +2501,7 @@ std::vector<std::string> cmMakefile
res.insert(res.end(), definitions.begin(), definitions.end());
}
std::vector<std::string> cacheKeys =
- this->GetCacheManager()->GetCacheEntryKeys();
+ this->GetConfiguration()->GetCacheEntryKeys();
res.insert(res.end(), cacheKeys.begin(), cacheKeys.end());
std::sort(res.begin(), res.end());
@@ -2802,6 +2802,8 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringNew(
openstack.push(t_lookup());
cmake::MessageType mtype = cmake::LOG;
+ cmConfiguration* config = this->GetCMakeInstance()->GetConfiguration();
+
do
{
char inc = *in;
@@ -2835,8 +2837,7 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringNew(
value = cmSystemTools::GetEnv(lookup.c_str());
break;
case CACHE:
- value = this->GetCacheManager()
- ->GetInitializedCacheValue(lookup);
+ value = config->GetCacheEntryValue(lookup);
break;
}
// Get the string we're meant to append to.
@@ -4908,7 +4909,7 @@ bool cmMakefile::SetPolicy(cmPolicies::PolicyID id,
if(id == cmPolicies::CMP0001 &&
(status == cmPolicies::WARN || status == cmPolicies::OLD))
{
- if(!(this->GetCacheManager()
+ if(!(this->GetConfiguration()
->GetInitializedCacheValue("CMAKE_BACKWARDS_COMPATIBILITY")))
{
// Set it to 2.4 because that is the last version where the
diff --git a/Source/cmMarkAsAdvancedCommand.cxx b/Source/cmMarkAsAdvancedCommand.cxx
index cc094b1..e89cf99 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))
+ cmConfiguration* config = this->Makefile->GetConfiguration();
+ if (!config->GetCacheEntryValue(variable))
{
- manager->AddCacheEntry(variable, 0, 0, cmCacheManager::UNINITIALIZED);
+ config->AddCacheEntry(variable, 0, 0, cmCacheManager::UNINITIALIZED);
overwrite = true;
}
- if (!manager->GetCacheEntryValue(variable))
+ if (!config->GetCacheEntryValue(variable))
{
cmSystemTools::Error("This should never happen...");
return false;
}
- if (!manager->GetCacheEntryProperty(variable, "ADVANCED") || overwrite)
+ if (!config->GetCacheEntryProperty(variable, "ADVANCED") || overwrite)
{
- manager->SetCacheEntryProperty(variable, "ADVANCED", value);
+ config->SetCacheEntryProperty(variable, "ADVANCED", value);
}
}
return true;
diff --git a/Source/cmOptionCommand.cxx b/Source/cmOptionCommand.cxx
index baf5b1e..64b3d39 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]);
+ cmConfiguration* config = this->Makefile->GetConfiguration();
+ const char* existingValue = config->GetCacheEntryValue(args[0]);
if(existingValue)
{
- if (manager->GetCacheEntryType(args[0]) != cmCacheManager::UNINITIALIZED)
+ if (config->GetCacheEntryType(args[0]) != cmCacheManager::UNINITIALIZED)
{
- manager->SetCacheEntryProperty(args[0], "HELPSTRING", args[1]);
+ config->SetCacheEntryProperty(args[0], "HELPSTRING", args[1]);
return true;
}
initialValue = existingValue;
diff --git a/Source/cmSetCommand.cxx b/Source/cmSetCommand.cxx
index e17474b..ead2080 100644
--- a/Source/cmSetCommand.cxx
+++ b/Source/cmSetCommand.cxx
@@ -136,10 +136,10 @@ bool cmSetCommand
}
// see if this is already in the cache
- cmCacheManager* manager = this->Makefile->GetCacheManager();
- const char* existingValue = manager->GetCacheEntryValue(variable);
+ cmConfiguration* config = this->Makefile->GetConfiguration();
+ const char* existingValue = config->GetCacheEntryValue(variable);
if(existingValue &&
- (manager->GetCacheEntryType(variable) != cmCacheManager::UNINITIALIZED))
+ (config->GetCacheEntryType(variable) != cmCacheManager::UNINITIALIZED))
{
// if the set is trying to CACHE the value but the value
// is already in the cache and the type is not internal
diff --git a/Source/cmSetPropertyCommand.cxx b/Source/cmSetPropertyCommand.cxx
index 77f9fb9..b6f8590 100644
--- a/Source/cmSetPropertyCommand.cxx
+++ b/Source/cmSetPropertyCommand.cxx
@@ -453,7 +453,7 @@ bool cmSetPropertyCommand::HandleCacheMode()
cmMakefile* mf = this->GetMakefile();
cmake* cm = mf->GetCMakeInstance();
const char* existingValue
- = cm->GetCacheManager()->GetCacheEntryValue(*ni);
+ = cm->GetConfiguration()->GetCacheEntryValue(*ni);
if(existingValue)
{
if(!this->HandleCacheEntry(*ni))
@@ -479,20 +479,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();
+ cmConfiguration* config = this->Makefile->GetConfiguration();
if (this->Remove)
{
- manager->RemoveCacheEntryProperty(cacheKey, name);
- return true;
+ config->RemoveCacheEntryProperty(cacheKey, name);
}
if(this->AppendMode)
{
- manager->AppendCacheEntryProperty(cacheKey, name, value,
- this->AppendAsString);
+ config->AppendCacheEntryProperty(cacheKey, name, value,
+ this->AppendAsString);
}
else
{
- manager->SetCacheEntryProperty(cacheKey, name, value);
+ config->SetCacheEntryProperty(cacheKey, name, value);
}
return true;
diff --git a/Source/cmTryRunCommand.cxx b/Source/cmTryRunCommand.cxx
index 911ade8..60f48ae 100644
--- a/Source/cmTryRunCommand.cxx
+++ b/Source/cmTryRunCommand.cxx
@@ -264,12 +264,12 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
comment.c_str(),
cmCacheManager::STRING);
- cmCacheManager* manager = this->Makefile->GetCacheManager();
+ cmConfiguration* config = this->Makefile->GetConfiguration();
const char* existingValue
- = manager->GetCacheEntryValue(this->RunResultVariable);
+ = config->GetCacheEntryValue(this->RunResultVariable);
if (existingValue)
{
- manager->SetCacheEntryProperty(this->RunResultVariable, "ADVANCED", "1");
+ config->SetCacheEntryProperty(this->RunResultVariable, "ADVANCED", "1");
}
error = true;
@@ -291,13 +291,13 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
"PLEASE_FILL_OUT-NOTFOUND",
comment.c_str(),
cmCacheManager::STRING);
- cmCacheManager* manager = this->Makefile->GetCacheManager();
+ cmConfiguration* config = this->Makefile->GetConfiguration();
const char* existing =
- manager->GetCacheEntryValue(internalRunOutputName);
+ config->GetCacheEntryValue(internalRunOutputName);
if (existing)
{
- manager->SetCacheEntryProperty(internalRunOutputName,
- "ADVANCED", "1");
+ config->SetCacheEntryProperty(internalRunOutputName,
+ "ADVANCED", "1");
}
error = true;
diff --git a/Source/cmVariableRequiresCommand.cxx b/Source/cmVariableRequiresCommand.cxx
index dd2a682..bc6bc01 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 "cmConfiguration.h"
// cmLibraryCommand
bool cmVariableRequiresCommand
@@ -34,6 +34,7 @@ bool cmVariableRequiresCommand
bool requirementsMet = true;
std::string notSet;
bool hasAdvanced = false;
+ cmConfiguration* config = this->Makefile->GetConfiguration();
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(config->GetCacheEntryValue(args[i]) &&
+ config->GetCacheEntryPropertyAsBool(args[i], "ADVANCED"))
{
hasAdvanced = true;
}
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index 79fb2a5..186b2de 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -348,7 +348,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
std::string cachedValue;
if(this->WarnUnusedCli)
{
- if(const char *v = this->CacheManager
+ if(const char *v = this->Configuration
->GetInitializedCacheValue(var))
{
haveValue = true;
@@ -356,13 +356,13 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
}
}
- this->CacheManager->AddCacheEntry(var, value.c_str(),
+ this->Configuration->AddCacheEntry(var, value.c_str(),
"No help, variable specified on the command line.", type);
if(this->WarnUnusedCli)
{
if (!haveValue ||
- cachedValue != this->CacheManager
+ cachedValue != this->Configuration
->GetInitializedCacheValue(var))
{
this->WatchUnusedCli(var);
@@ -408,12 +408,12 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
//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();
+ this->Configuration->GetCacheEntryKeys();
for (std::vector<std::string>::const_iterator it = cacheKeys.begin();
it != cacheKeys.end(); ++it)
{
cmCacheManager::CacheEntryType t =
- this->CacheManager->GetCacheEntryType(*it);
+ this->Configuration->GetCacheEntryType(*it);
if(t != cmCacheManager::STATIC)
{
if (regex.find(it->c_str()))
@@ -429,7 +429,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
currentEntry != entriesToDelete.end();
++currentEntry)
{
- this->CacheManager->RemoveCacheEntry(*currentEntry);
+ this->Configuration->RemoveCacheEntry(*currentEntry);
}
}
else if(arg.find("-C",0) == 0)
@@ -925,7 +925,7 @@ void cmake::SetDirectoriesFromFile(const char* arg)
if(this->LoadCache(cachePath))
{
const char* existingValue =
- this->CacheManager->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
+ this->Configuration->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
if (existingValue)
{
this->SetHomeOutputDirectory(cachePath);
@@ -1255,7 +1255,6 @@ int cmake::HandleDeleteCacheVariables(const std::string& var)
{
return 0;
}
- cmCacheManager::CacheIterator ci = this->CacheManager->NewIterator();
std::vector<SaveCacheEntry> saved;
std::ostringstream warning;
warning
@@ -1271,10 +1270,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;
}
@@ -1556,49 +1558,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->Configuration
->GetInitializedCacheValue("CMAKE_BACKWARDS_COMPATIBILITY"))
{
- if(!this->CacheManager->GetInitializedCacheValue("LIBRARY_OUTPUT_PATH"))
+ if(!this->Configuration->GetInitializedCacheValue("LIBRARY_OUTPUT_PATH"))
{
- this->CacheManager->AddCacheEntry
+ this->Configuration->AddCacheEntry
("LIBRARY_OUTPUT_PATH", "",
"Single output directory for building all libraries.",
cmCacheManager::PATH);
}
- if(!this->CacheManager
+ if(!this->Configuration
->GetInitializedCacheValue("EXECUTABLE_OUTPUT_PATH"))
{
- this->CacheManager->AddCacheEntry
+ this->Configuration->AddCacheEntry
("EXECUTABLE_OUTPUT_PATH", "",
"Single output directory for building all executables.",
cmCacheManager::PATH);
}
}
- if(!this->CacheManager
+ if(!this->Configuration
->GetInitializedCacheValue("CMAKE_USE_RELATIVE_PATHS"))
{
- this->CacheManager->AddCacheEntry
+ this->Configuration->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"))
+ if (!this->Configuration->GetCacheEntryProperty("CMAKE_USE_RELATIVE_PATHS",
+ "ADVANCED"))
{
- this->CacheManager->SetCacheEntryProperty("CMAKE_USE_RELATIVE_PATHS",
- "ADVANCED", "1");
+ this->Configuration->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->Configuration->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->Configuration->RemoveCacheEntry("CMAKE_GENERATOR");
+ this->Configuration->RemoveCacheEntry("CMAKE_EXTRA_GENERATOR");
+ }
}
cmMakefile* mf=this->GlobalGenerator->GetLocalGenerators()[0]->GetMakefile();
@@ -2204,7 +2208,7 @@ void cmake::TruncateOutputLog(const char* fname)
{
return;
}
- if ( !this->CacheManager->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR") )
+ if (!this->Configuration->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR"))
{
cmSystemTools::RemoveFile(fullPath);
return;
@@ -2322,7 +2326,7 @@ const char *cmake::GetProperty(const std::string& prop,
if ( prop == "CACHE_VARIABLES" )
{
std::vector<std::string> cacheKeys =
- this->CacheManager->GetCacheEntryKeys();
+ this->Configuration->GetCacheEntryKeys();
this->SetProperty("CACHE_VARIABLES", cmJoin(cacheKeys, ";").c_str());
}
else if ( prop == "COMMANDS" )
@@ -2475,7 +2479,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->Configuration->GetInitializedCacheValue("CMAKE_ROOT");
modulesPath += "/Modules";
std::string inFile = modulesPath;
inFile += "/SystemInformation.cmake";
@@ -2685,7 +2689,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->Configuration->GetCacheEntryValue(
"CMAKE_SUPPRESS_DEVELOPER_WARNINGS");
if(suppress && cmSystemTools::IsOn(suppress))
{
@@ -2806,7 +2810,7 @@ int cmake::Build(const std::string& dir,
return 1;
}
const char* cachedGenerator =
- this->CacheManager->GetCacheEntryValue("CMAKE_GENERATOR");
+ this->Configuration->GetCacheEntryValue("CMAKE_GENERATOR");
if(!cachedGenerator)
{
std::cerr << "Error: could not find CMAKE_GENERATOR in Cache\n";
@@ -2823,7 +2827,7 @@ int cmake::Build(const std::string& dir,
std::string output;
std::string projName;
const char* cachedProjectName =
- this->CacheManager->GetCacheEntryValue("CMAKE_PROJECT_NAME");
+ this->Configuration->GetCacheEntryValue("CMAKE_PROJECT_NAME");
if(!cachedProjectName)
{
std::cerr << "Error: could not find CMAKE_PROJECT_NAME in Cache\n";
@@ -2832,7 +2836,7 @@ int cmake::Build(const std::string& dir,
projName = cachedProjectName;
bool verbose = false;
const char* cachedVerbose =
- this->CacheManager->GetCacheEntryValue("CMAKE_VERBOSE_MAKEFILE");
+ this->Configuration->GetCacheEntryValue("CMAKE_VERBOSE_MAKEFILE");
if(cachedVerbose)
{
verbose = cmSystemTools::IsOn(cachedVerbose);
diff --git a/Source/cmakemain.cxx b/Source/cmakemain.cxx
index 3b518be..7960b47 100644
--- a/Source/cmakemain.cxx
+++ b/Source/cmakemain.cxx
@@ -18,6 +18,7 @@
#include "cmake.h"
#include "cmcmd.h"
+#include "cmConfiguration.h"
#include "cmCacheManager.h"
#include "cmListFileCache.h"
#include "cmSourceFile.h"
@@ -330,28 +331,28 @@ int do_cmake(int ac, char const* const* av)
{
std::cout << "-- Cache values" << std::endl;
std::vector<std::string> keys =
- cm.GetCacheManager()->GetCacheEntryKeys();
+ cm.GetConfiguration()->GetCacheEntryKeys();
for (std::vector<std::string>::const_iterator it = keys.begin();
it != keys.end(); ++it)
{
cmCacheManager::CacheEntryType t =
- cm.GetCacheManager()->GetCacheEntryType(*it);
+ cm.GetConfiguration()->GetCacheEntryType(*it);
if ( t != cmCacheManager::INTERNAL && t != cmCacheManager::STATIC &&
t != cmCacheManager::UNINITIALIZED )
{
const char* advancedProp =
- cm.GetCacheManager()->GetCacheEntryProperty(*it, "ADVANCED");
+ cm.GetConfiguration()->GetCacheEntryProperty(*it, "ADVANCED");
if ( list_all_cached || !advancedProp)
{
if ( list_help )
{
std::cout << "// "
- << cm.GetCacheManager()->GetCacheEntryProperty(*it,
+ << cm.GetConfiguration()->GetCacheEntryProperty(*it,
"HELPSTRING") << std::endl;
}
std::cout << *it << ":" <<
cmCacheManager::TypeToString(t)
- << "=" << cm.GetCacheManager()->GetCacheEntryValue(*it)
+ << "=" << cm.GetConfiguration()->GetCacheEntryValue(*it)
<< std::endl;
if ( list_help )
{
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=9754cb6f804df5150a1f1fffed0e8eb3c0612e1c
commit 9754cb6f804df5150a1f1fffed0e8eb3c0612e1c
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Sat Apr 4 21:20:12 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Mon Apr 6 16:57:33 2015 +0200
Introduce cmConfiguration class.
At this point, it is an interface to the cache. It will be extended
to be a universal interface for access to and manipulation of
configuration-time data (defintions, properties on targets,
directories, source files etc).
This will allow porting all command implementations away
from the cmMakefile and cmTarget classes, and result in something
more-purely related to configuration-time processing of cmake
commands. That should serve at least the following goals:
* Split the CMake implementation more definitively into three
stages: Configuration, computation and generation, and be able to
implement each optimally for memory access patterns etc.
* Make better IDE integration possible by making more configuration
data available.
* Make it possiblte to use a smaller library than CMakeLib.a in
cpack and ctest, resulting in smaller executables.
* Make it possible to run the configure step multiple times in
the same CMake run (#14539).
Manage its lifetime in the cmake class, and add a convenience accessor
to cmMakefile.
diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt
index 04f6a81..8354fd9 100644
--- a/Source/CMakeLists.txt
+++ b/Source/CMakeLists.txt
@@ -171,6 +171,8 @@ set(SRCS
cmComputeLinkInformation.h
cmComputeTargetDepends.h
cmComputeTargetDepends.cxx
+ cmConfiguration.cxx
+ cmConfiguration.h
cmCPackPropertiesGenerator.h
cmCPackPropertiesGenerator.cxx
cmCryptoHash.cxx
diff --git a/Source/cmCacheManager.h b/Source/cmCacheManager.h
index 2d3f6e5..36848c4 100644
--- a/Source/cmCacheManager.h
+++ b/Source/cmCacheManager.h
@@ -249,6 +249,7 @@ private:
// Only cmake and cmMakefile should be able to add cache values
// the commands should never use the cmCacheManager directly
friend class cmMakefile; // allow access to add cache values
+ friend class cmConfiguration; // allow access to add cache values
friend class cmake; // allow access to add cache values
friend class cmMarkAsAdvancedCommand; // allow access to add cache values
};
diff --git a/Source/cmConfiguration.cxx b/Source/cmConfiguration.cxx
new file mode 100644
index 0000000..7e89c09
--- /dev/null
+++ b/Source/cmConfiguration.cxx
@@ -0,0 +1,137 @@
+
+#include "cmConfiguration.h"
+
+#include "cmake.h"
+
+cmConfiguration::cmConfiguration(cmake* cm)
+ : CMakeInstance(cm)
+{
+}
+cmCacheManager::CacheEntryType
+cmConfiguration::StringToCacheEntryType(const char* s)
+{
+ return cmCacheManager::StringToType(s);
+}
+
+const char*
+cmConfiguration::CacheEntryTypeToString(cmCacheManager::CacheEntryType t)
+{
+ return cmCacheManager::TypeToString(t);
+}
+
+bool cmConfiguration::IsCacheEntryType(std::string const& key)
+{
+ return cmCacheManager::IsType(key.c_str());
+}
+
+std::vector<std::string> cmConfiguration::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* cmConfiguration::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*
+cmConfiguration::GetInitializedCacheValue(std::string const& key) const
+{
+ return this->CMakeInstance->GetCacheManager()->GetInitializedCacheValue(key);
+}
+
+cmCacheManager::CacheEntryType
+cmConfiguration::GetCacheEntryType(std::string const& key) const
+{
+ cmCacheManager::CacheIterator it =
+ this->CMakeInstance->GetCacheManager()->GetCacheIterator(key.c_str());
+ return it.GetType();
+}
+
+void cmConfiguration::SetCacheEntryValue(std::string const& key,
+ std::string const& value)
+{
+ this->CMakeInstance->GetCacheManager()->SetCacheEntryValue(key, value);
+}
+
+void cmConfiguration::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 cmConfiguration::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* cmConfiguration::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 cmConfiguration::GetCacheEntryPropertyAsBool(std::string const& key,
+ std::string const& propertyName)
+{
+ return this->CMakeInstance->GetCacheManager()
+ ->GetCacheIterator(key.c_str()).GetPropertyAsBool(propertyName);
+}
+
+void cmConfiguration::AddCacheEntry(const std::string& key, const char* value,
+ const char* helpString,
+ cmCacheManager::CacheEntryType type)
+{
+ this->CMakeInstance->GetCacheManager()->AddCacheEntry(key, value,
+ helpString, type);
+}
+
+void cmConfiguration::RemoveCacheEntry(std::string const& key)
+{
+ this->CMakeInstance->GetCacheManager()->RemoveCacheEntry(key);
+}
+
+void cmConfiguration::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 cmConfiguration::RemoveCacheEntryProperty(std::string const& key,
+ std::string const& propertyName)
+{
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheIterator(key.c_str()).SetProperty(propertyName, (void*)0);
+}
diff --git a/Source/cmConfiguration.h b/Source/cmConfiguration.h
new file mode 100644
index 0000000..d8f5916
--- /dev/null
+++ b/Source/cmConfiguration.h
@@ -0,0 +1,52 @@
+
+#ifndef cmConfiguration_h
+#define cmConfiguration_h
+
+#include "cmCacheManager.h"
+
+class cmake;
+
+class cmConfiguration
+{
+public:
+ cmConfiguration(cmake* cm);
+
+ static cmCacheManager::CacheEntryType StringToCacheEntryType(const char*);
+ static const char* CacheEntryTypeToString(cmCacheManager::CacheEntryType);
+ static bool IsCacheEntryType(std::string const& key);
+
+ std::vector<std::string> GetCacheEntryKeys() const;
+ const char* GetCacheEntryValue(std::string const& key) const;
+ const char* GetInitializedCacheValue(std::string const& key) const;
+ cmCacheManager::CacheEntryType
+ GetCacheEntryType(std::string const& key) const;
+ void SetCacheEntryValue(std::string const& key, std::string const& value);
+ void SetCacheValue(std::string const& key, std::string const& value);
+
+ void AddCacheEntry(const std::string& key, const char* value,
+ const char* helpString,
+ cmCacheManager::CacheEntryType type);
+ void RemoveCacheEntry(std::string const& key);
+
+ void SetCacheEntryProperty(std::string const& key,
+ std::string const& propertyName,
+ std::string const& value);
+ void SetCacheEntryBoolProperty(std::string const& key,
+ std::string const& propertyName,
+ bool value);
+ const char* GetCacheEntryProperty(std::string const& key,
+ std::string const& propertyName);
+ bool GetCacheEntryPropertyAsBool(std::string const& key,
+ std::string const& propertyName);
+ void AppendCacheEntryProperty(std::string const& key,
+ const std::string& property,
+ const std::string& value,
+ bool asString = false);
+ void RemoveCacheEntryProperty(std::string const& key,
+ std::string const& propertyName);
+
+private:
+ cmake* CMakeInstance;
+};
+
+#endif
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 34b4621..b1450a8 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -19,6 +19,7 @@
#include "cmLocalGenerator.h"
#include "cmCommands.h"
#include "cmCacheManager.h"
+#include "cmConfiguration.h"
#include "cmFunctionBlocker.h"
#include "cmListFileCache.h"
#include "cmCommandArgumentParserHelper.h"
@@ -3738,6 +3739,11 @@ cmCacheManager *cmMakefile::GetCacheManager() const
return this->GetCMakeInstance()->GetCacheManager();
}
+cmConfiguration *cmMakefile::GetConfiguration() const
+{
+ return this->GetCMakeInstance()->GetConfiguration();
+}
+
void cmMakefile::DisplayStatus(const char* message, float s) const
{
cmake* cm = this->GetLocalGenerator()->GetGlobalGenerator()
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index 5209891..8c896e4 100644
--- a/Source/cmMakefile.h
+++ b/Source/cmMakefile.h
@@ -766,6 +766,7 @@ public:
void EnableLanguage(std::vector<std::string>const& languages, bool optional);
cmCacheManager *GetCacheManager() const;
+ cmConfiguration *GetConfiguration() const;
/**
* Get the variable watch. This is used to determine when certain variables
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index 64b332c..79fb2a5 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -21,6 +21,7 @@
#include "cmTest.h"
#include "cmDocumentationFormatter.h"
#include "cmAlgorithms.h"
+#include "cmConfiguration.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->Configuration = new cmConfiguration(this);
+
this->InitializeProperties();
#ifdef __APPLE__
@@ -171,6 +174,7 @@ cmake::~cmake()
{
delete this->CacheManager;
delete this->Policies;
+ delete this->Configuration;
if (this->GlobalGenerator)
{
delete this->GlobalGenerator;
diff --git a/Source/cmake.h b/Source/cmake.h
index 3acf4a8..5b10288 100644
--- a/Source/cmake.h
+++ b/Source/cmake.h
@@ -32,6 +32,7 @@ class cmDocumentationSection;
class cmPolicies;
class cmTarget;
class cmGeneratedFileStream;
+class cmConfiguration;
/** \brief Represents a cmake invocation.
*
@@ -387,6 +388,9 @@ class cmake
void UnwatchUnusedCli(const std::string& var);
void WatchUnusedCli(const std::string& var);
+
+ cmConfiguration* GetConfiguration() const { return this->Configuration; }
+
protected:
void RunCheckForUnusedVariables();
void InitializeProperties();
@@ -475,6 +479,8 @@ private:
std::vector<std::string> DebugConfigs;
InstalledFilesMap InstalledFiles;
+ cmConfiguration* Configuration;
+
void UpdateConversionPathTable();
};
diff --git a/bootstrap b/bootstrap
index 4239802..b8e9885 100755
--- a/bootstrap
+++ b/bootstrap
@@ -302,6 +302,7 @@ CMAKE_CXX_SOURCES="\
cmCommandsForBootstrap \
cmTarget \
cmTest \
+ cmConfiguration \
cmCustomCommand \
cmCustomCommandGenerator \
cmCacheManager \
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=a94cddabb4f6be6d47ee9be31ec76fe483e85415
commit a94cddabb4f6be6d47ee9be31ec76fe483e85415
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Sun Apr 5 10:48:04 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Mon Apr 6 16:52:27 2015 +0200
cmCacheManager: Port consumers to non-iterator API.
This simplifies reasoning about the follow-up commit which ports
away from cmCacheManager to a class with the same method names.
diff --git a/Source/cmFindBase.cxx b/Source/cmFindBase.cxx
index f63df61..cc08052 100644
--- a/Source/cmFindBase.cxx
+++ b/Source/cmFindBase.cxx
@@ -366,18 +366,18 @@ bool cmFindBase::CheckForVariableInCache()
if(const char* cacheValue =
this->Makefile->GetDefinition(this->VariableName))
{
- cmCacheManager::CacheIterator it =
- this->Makefile->GetCacheManager()->
- GetCacheIterator(this->VariableName.c_str());
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
+ const char* cacheEntry = manager->GetCacheEntryValue(this->VariableName);
bool found = !cmSystemTools::IsNOTFOUND(cacheValue);
- bool cached = !it.IsAtEnd();
+ bool cached = cacheEntry ? true : false;
if(found)
{
// If the user specifies the entry on the command line without a
// type we should add the type and docstring but keep the
// original value. Tell the subclass implementations to do
// this.
- if(cached && it.GetType() == cmCacheManager::UNINITIALIZED)
+ if(cached && manager->GetCacheEntryType(this->VariableName)
+ == cmCacheManager::UNINITIALIZED)
{
this->AlreadyInCacheWithoutMetaInfo = true;
}
@@ -385,7 +385,8 @@ bool cmFindBase::CheckForVariableInCache()
}
else if(cached)
{
- const char* hs = it.GetProperty("HELPSTRING");
+ const char* hs = manager->GetCacheEntryProperty(this->VariableName,
+ "HELPSTRING");
this->VariableDocumentation = hs?hs:"(none)";
}
}
diff --git a/Source/cmGetPropertyCommand.cxx b/Source/cmGetPropertyCommand.cxx
index f0b2686..0e6e0c2 100644
--- a/Source/cmGetPropertyCommand.cxx
+++ b/Source/cmGetPropertyCommand.cxx
@@ -391,11 +391,10 @@ bool cmGetPropertyCommand::HandleCacheMode()
}
const char* value = 0;
- cmCacheManager::CacheIterator it =
- this->Makefile->GetCacheManager()->GetCacheIterator(this->Name.c_str());
- if(!it.IsAtEnd())
+ if(this->Makefile->GetCacheManager()->GetCacheEntryValue(this->Name))
{
- value = it.GetProperty(this->PropertyName);
+ value = this->Makefile->GetCacheManager()
+ ->GetCacheEntryProperty(this->Name, this->PropertyName);
}
this->StoreResult(value);
return true;
diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx
index f23caa6..35394b8 100644
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@@ -1559,9 +1559,7 @@ void cmGlobalGenerator::CheckLocalGenerators()
cmSystemTools::IsNOTFOUND(lib->first.c_str()))
{
std::string varName = lib->first.substr(0, lib->first.size()-9);
- cmCacheManager::CacheIterator it =
- manager->GetCacheIterator(varName.c_str());
- if(it.GetPropertyAsBool("ADVANCED"))
+ if(manager->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
{
varName += " (ADVANCED)";
}
@@ -1592,9 +1590,7 @@ void cmGlobalGenerator::CheckLocalGenerators()
cmSystemTools::IsNOTFOUND(incDir->c_str()))
{
std::string varName = incDir->substr(0, incDir->size()-9);
- cmCacheManager::CacheIterator it =
- manager->GetCacheIterator(varName.c_str());
- if(it.GetPropertyAsBool("ADVANCED"))
+ if(manager->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
{
varName += " (ADVANCED)";
}
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 7c1b9c4..34b4621 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -1848,8 +1848,8 @@ void cmMakefile::AddCacheDefinition(const std::string& name, const char* value,
}
}
- this->GetCacheManager()->AddCacheEntry(name, haveVal ? val.c_str() : 0, doc,
- type);
+ this->GetCacheManager()->AddCacheEntry(name, haveVal ? val.c_str() : 0,
+ doc, type);
// if there was a definition then remove it
this->Internal->VarStack.top().Set(name, 0);
}
@@ -2499,12 +2499,10 @@ std::vector<std::string> cmMakefile
this->Internal->VarStack.top().ClosureKeys();
res.insert(res.end(), definitions.begin(), definitions.end());
}
- cmCacheManager::CacheIterator cit =
- this->GetCacheManager()->GetCacheIterator();
- for ( cit.Begin(); !cit.IsAtEnd(); cit.Next() )
- {
- res.push_back(cit.GetName());
- }
+ std::vector<std::string> cacheKeys =
+ this->GetCacheManager()->GetCacheEntryKeys();
+ res.insert(res.end(), cacheKeys.begin(), cacheKeys.end());
+
std::sort(res.begin(), res.end());
return res;
}
diff --git a/Source/cmMarkAsAdvancedCommand.cxx b/Source/cmMarkAsAdvancedCommand.cxx
index f6a2c26..cc094b1 100644
--- a/Source/cmMarkAsAdvancedCommand.cxx
+++ b/Source/cmMarkAsAdvancedCommand.cxx
@@ -37,24 +37,19 @@ bool cmMarkAsAdvancedCommand
{
std::string variable = args[i];
cmCacheManager* manager = this->Makefile->GetCacheManager();
- cmCacheManager::CacheIterator it =
- manager->GetCacheIterator(variable.c_str());
- if ( it.IsAtEnd() )
+ if (!manager->GetCacheEntryValue(variable))
{
- this->Makefile->GetCacheManager()
- ->AddCacheEntry(variable, 0, 0,
- cmCacheManager::UNINITIALIZED);
+ manager->AddCacheEntry(variable, 0, 0, cmCacheManager::UNINITIALIZED);
overwrite = true;
}
- it.Find(variable);
- if ( it.IsAtEnd() )
+ if (!manager->GetCacheEntryValue(variable))
{
cmSystemTools::Error("This should never happen...");
return false;
}
- if ( !it.PropertyExists("ADVANCED") || overwrite )
+ if (!manager->GetCacheEntryProperty(variable, "ADVANCED") || overwrite)
{
- it.SetProperty("ADVANCED", value);
+ manager->SetCacheEntryProperty(variable, "ADVANCED", value);
}
}
return true;
diff --git a/Source/cmOptionCommand.cxx b/Source/cmOptionCommand.cxx
index 60728ea..baf5b1e 100644
--- a/Source/cmOptionCommand.cxx
+++ b/Source/cmOptionCommand.cxx
@@ -42,16 +42,16 @@ 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::CacheIterator it =
- this->Makefile->GetCacheManager()->GetCacheIterator(args[0].c_str());
- if(!it.IsAtEnd())
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
+ const char* existingValue = manager->GetCacheEntryValue(args[0]);
+ if(existingValue)
{
- if ( it.GetType() != cmCacheManager::UNINITIALIZED )
+ if (manager->GetCacheEntryType(args[0]) != cmCacheManager::UNINITIALIZED)
{
- it.SetProperty("HELPSTRING", args[1].c_str());
+ manager->SetCacheEntryProperty(args[0], "HELPSTRING", args[1]);
return true;
}
- initialValue = it.GetValue();
+ initialValue = existingValue;
}
if(args.size() == 3)
{
diff --git a/Source/cmSetCommand.cxx b/Source/cmSetCommand.cxx
index 204d95b..e17474b 100644
--- a/Source/cmSetCommand.cxx
+++ b/Source/cmSetCommand.cxx
@@ -136,9 +136,10 @@ bool cmSetCommand
}
// see if this is already in the cache
- cmCacheManager::CacheIterator it =
- this->Makefile->GetCacheManager()->GetCacheIterator(variable);
- if(!it.IsAtEnd() && (it.GetType() != cmCacheManager::UNINITIALIZED))
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
+ const char* existingValue = manager->GetCacheEntryValue(variable);
+ if(existingValue &&
+ (manager->GetCacheEntryType(variable) != cmCacheManager::UNINITIALIZED))
{
// if the set is trying to CACHE the value but the value
// is already in the cache and the type is not internal
diff --git a/Source/cmSetPropertyCommand.cxx b/Source/cmSetPropertyCommand.cxx
index 1150bc7..77f9fb9 100644
--- a/Source/cmSetPropertyCommand.cxx
+++ b/Source/cmSetPropertyCommand.cxx
@@ -452,11 +452,11 @@ bool cmSetPropertyCommand::HandleCacheMode()
// Get the source file.
cmMakefile* mf = this->GetMakefile();
cmake* cm = mf->GetCMakeInstance();
- cmCacheManager::CacheIterator it =
- cm->GetCacheManager()->GetCacheIterator(ni->c_str());
- if(!it.IsAtEnd())
+ const char* existingValue
+ = cm->GetCacheManager()->GetCacheEntryValue(*ni);
+ if(existingValue)
{
- if(!this->HandleCacheEntry(it))
+ if(!this->HandleCacheEntry(*ni))
{
return false;
}
@@ -474,22 +474,25 @@ bool cmSetPropertyCommand::HandleCacheMode()
}
//----------------------------------------------------------------------------
-bool cmSetPropertyCommand::HandleCacheEntry(cmCacheManager::CacheIterator& it)
+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();
if (this->Remove)
{
- value = 0;
+ manager->RemoveCacheEntryProperty(cacheKey, name);
+ return true;
}
if(this->AppendMode)
{
- it.AppendProperty(name, value, this->AppendAsString);
+ manager->AppendCacheEntryProperty(cacheKey, name, value,
+ this->AppendAsString);
}
else
{
- it.SetProperty(name, value);
+ manager->SetCacheEntryProperty(cacheKey, name, value);
}
return true;
diff --git a/Source/cmSetPropertyCommand.h b/Source/cmSetPropertyCommand.h
index b06cb68..3285e60 100644
--- a/Source/cmSetPropertyCommand.h
+++ b/Source/cmSetPropertyCommand.h
@@ -61,7 +61,7 @@ private:
bool HandleTestMode();
bool HandleTest(cmTest* test);
bool HandleCacheMode();
- bool HandleCacheEntry(cmCacheManager::CacheIterator&);
+ bool HandleCacheEntry(std::string const&);
bool HandleInstallMode();
bool HandleInstall(cmInstalledFile* file);
};
diff --git a/Source/cmTryRunCommand.cxx b/Source/cmTryRunCommand.cxx
index b5280cf..911ade8 100644
--- a/Source/cmTryRunCommand.cxx
+++ b/Source/cmTryRunCommand.cxx
@@ -264,11 +264,12 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
comment.c_str(),
cmCacheManager::STRING);
- cmCacheManager::CacheIterator it = this->Makefile->GetCacheManager()->
- GetCacheIterator(this->RunResultVariable.c_str());
- if ( !it.IsAtEnd() )
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
+ const char* existingValue
+ = manager->GetCacheEntryValue(this->RunResultVariable);
+ if (existingValue)
{
- it.SetProperty("ADVANCED", "1");
+ manager->SetCacheEntryProperty(this->RunResultVariable, "ADVANCED", "1");
}
error = true;
@@ -290,11 +291,13 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
"PLEASE_FILL_OUT-NOTFOUND",
comment.c_str(),
cmCacheManager::STRING);
- cmCacheManager::CacheIterator it = this->Makefile->GetCacheManager()->
- GetCacheIterator(internalRunOutputName.c_str());
- if ( !it.IsAtEnd() )
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
+ const char* existing =
+ manager->GetCacheEntryValue(internalRunOutputName);
+ if (existing)
{
- it.SetProperty("ADVANCED", "1");
+ manager->SetCacheEntryProperty(internalRunOutputName,
+ "ADVANCED", "1");
}
error = true;
diff --git a/Source/cmVariableRequiresCommand.cxx b/Source/cmVariableRequiresCommand.cxx
index 80c1286..dd2a682 100644
--- a/Source/cmVariableRequiresCommand.cxx
+++ b/Source/cmVariableRequiresCommand.cxx
@@ -41,9 +41,9 @@ bool cmVariableRequiresCommand
requirementsMet = false;
notSet += args[i];
notSet += "\n";
- cmCacheManager::CacheIterator it =
- this->Makefile->GetCacheManager()->GetCacheIterator(args[i].c_str());
- if(!it.IsAtEnd() && it.GetPropertyAsBool("ADVANCED"))
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
+ if(manager->GetCacheEntryValue(args[i]) &&
+ manager->GetCacheEntryPropertyAsBool(args[i], "ADVANCED"))
{
hasAdvanced = true;
}
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index 210c0ef..64b332c 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -403,17 +403,18 @@ 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;
- cmCacheManager::CacheIterator it =
- this->CacheManager->GetCacheIterator();
- for ( it.Begin(); !it.IsAtEnd(); it.Next() )
+ std::vector<std::string> cacheKeys =
+ this->CacheManager->GetCacheEntryKeys();
+ for (std::vector<std::string>::const_iterator it = cacheKeys.begin();
+ it != cacheKeys.end(); ++it)
{
- cmCacheManager::CacheEntryType t = it.GetType();
+ cmCacheManager::CacheEntryType t =
+ this->CacheManager->GetCacheEntryType(*it);
if(t != cmCacheManager::STATIC)
{
- std::string entryName = it.GetName();
- if (regex.find(entryName.c_str()))
+ if (regex.find(it->c_str()))
{
- entriesToDelete.push_back(entryName);
+ entriesToDelete.push_back(*it);
}
}
}
@@ -917,16 +918,18 @@ void cmake::SetDirectoriesFromFile(const char* arg)
// If there is a CMakeCache.txt file, use its settings.
if(!cachePath.empty())
{
- cmCacheManager* cachem = this->GetCacheManager();
- cmCacheManager::CacheIterator it = cachem->NewIterator();
- if(this->LoadCache(cachePath) &&
- it.Find("CMAKE_HOME_DIRECTORY"))
+ if(this->LoadCache(cachePath))
{
- this->SetHomeOutputDirectory(cachePath);
- this->SetStartOutputDirectory(cachePath);
- this->SetHomeDirectory(it.GetValue());
- this->SetStartDirectory(it.GetValue());
- return;
+ const char* existingValue =
+ this->CacheManager->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
+ if (existingValue)
+ {
+ this->SetHomeOutputDirectory(cachePath);
+ this->SetStartOutputDirectory(cachePath);
+ this->SetHomeDirectory(existingValue);
+ this->SetStartDirectory(existingValue);
+ return;
+ }
}
}
@@ -1575,11 +1578,11 @@ int cmake::ActualConfigure()
("CMAKE_USE_RELATIVE_PATHS", "OFF",
"If true, cmake will use relative paths in makefiles and projects.",
cmCacheManager::BOOL);
- cmCacheManager::CacheIterator it =
- this->CacheManager->GetCacheIterator("CMAKE_USE_RELATIVE_PATHS");
- if ( !it.PropertyExists("ADVANCED") )
+ if (!this->CacheManager->GetCacheEntryProperty("CMAKE_USE_RELATIVE_PATHS",
+ "ADVANCED"))
{
- it.SetProperty("ADVANCED", "1");
+ this->CacheManager->SetCacheEntryProperty("CMAKE_USE_RELATIVE_PATHS",
+ "ADVANCED", "1");
}
}
@@ -2314,17 +2317,9 @@ const char *cmake::GetProperty(const std::string& prop,
std::string output = "";
if ( prop == "CACHE_VARIABLES" )
{
- cmCacheManager::CacheIterator cit =
- this->GetCacheManager()->GetCacheIterator();
- for ( cit.Begin(); !cit.IsAtEnd(); cit.Next() )
- {
- if (!output.empty())
- {
- output += ";";
- }
- output += cit.GetName();
- }
- this->SetProperty("CACHE_VARIABLES", output.c_str());
+ std::vector<std::string> cacheKeys =
+ this->CacheManager->GetCacheEntryKeys();
+ this->SetProperty("CACHE_VARIABLES", cmJoin(cacheKeys, ";").c_str());
}
else if ( prop == "COMMANDS" )
{
@@ -2686,9 +2681,9 @@ void cmake::IssueMessage(cmake::MessageType t, std::string const& text,
if(t == cmake::AUTHOR_WARNING)
{
// Allow suppression of these warnings.
- cmCacheManager::CacheIterator it = this->CacheManager
- ->GetCacheIterator("CMAKE_SUPPRESS_DEVELOPER_WARNINGS");
- if(!it.IsAtEnd() && it.GetValueAsBool())
+ const char* suppress = this->CacheManager->GetCacheEntryValue(
+ "CMAKE_SUPPRESS_DEVELOPER_WARNINGS");
+ if(suppress && cmSystemTools::IsOn(suppress))
{
return;
}
@@ -2801,37 +2796,42 @@ int cmake::Build(const std::string& dir,
}
std::string cachePath = dir;
cmSystemTools::ConvertToUnixSlashes(cachePath);
- cmCacheManager::CacheIterator it = this->GetCacheManager()->NewIterator();
if(!this->LoadCache(cachePath))
{
std::cerr << "Error: could not load cache\n";
return 1;
}
- if(!it.Find("CMAKE_GENERATOR"))
+ const char* cachedGenerator =
+ this->CacheManager->GetCacheEntryValue("CMAKE_GENERATOR");
+ if(!cachedGenerator)
{
std::cerr << "Error: could not find CMAKE_GENERATOR in Cache\n";
return 1;
}
cmsys::auto_ptr<cmGlobalGenerator> gen(
- this->CreateGlobalGenerator(it.GetValue()));
+ this->CreateGlobalGenerator(cachedGenerator));
if(!gen.get())
{
std::cerr << "Error: could create CMAKE_GENERATOR \""
- << it.GetValue() << "\"\n";
+ << cachedGenerator << "\"\n";
return 1;
}
std::string output;
std::string projName;
- if(!it.Find("CMAKE_PROJECT_NAME"))
+ const char* cachedProjectName =
+ this->CacheManager->GetCacheEntryValue("CMAKE_PROJECT_NAME");
+ if(!cachedProjectName)
{
std::cerr << "Error: could not find CMAKE_PROJECT_NAME in Cache\n";
return 1;
}
- projName = it.GetValue();
+ projName = cachedProjectName;
bool verbose = false;
- if(it.Find("CMAKE_VERBOSE_MAKEFILE"))
+ const char* cachedVerbose =
+ this->CacheManager->GetCacheEntryValue("CMAKE_VERBOSE_MAKEFILE");
+ if(cachedVerbose)
{
- verbose = it.GetValueAsBool();
+ verbose = cmSystemTools::IsOn(cachedVerbose);
}
return gen->Build("", dir,
projName, target,
diff --git a/Source/cmakemain.cxx b/Source/cmakemain.cxx
index ac73ad0..3b518be 100644
--- a/Source/cmakemain.cxx
+++ b/Source/cmakemain.cxx
@@ -328,25 +328,31 @@ int do_cmake(int ac, char const* const* av)
int res = cm.Run(args, view_only);
if ( list_cached || list_all_cached )
{
- cmCacheManager::CacheIterator it =
- cm.GetCacheManager()->GetCacheIterator();
std::cout << "-- Cache values" << std::endl;
- for ( it.Begin(); !it.IsAtEnd(); it.Next() )
+ std::vector<std::string> keys =
+ cm.GetCacheManager()->GetCacheEntryKeys();
+ for (std::vector<std::string>::const_iterator it = keys.begin();
+ it != keys.end(); ++it)
{
- cmCacheManager::CacheEntryType t = it.GetType();
+ cmCacheManager::CacheEntryType t =
+ cm.GetCacheManager()->GetCacheEntryType(*it);
if ( t != cmCacheManager::INTERNAL && t != cmCacheManager::STATIC &&
t != cmCacheManager::UNINITIALIZED )
{
- bool advanced = it.PropertyExists("ADVANCED");
- if ( list_all_cached || !advanced)
+ const char* advancedProp =
+ cm.GetCacheManager()->GetCacheEntryProperty(*it, "ADVANCED");
+ if ( list_all_cached || !advancedProp)
{
if ( list_help )
{
- std::cout << "// " << it.GetProperty("HELPSTRING") << std::endl;
+ std::cout << "// "
+ << cm.GetCacheManager()->GetCacheEntryProperty(*it,
+ "HELPSTRING") << std::endl;
}
- std::cout << it.GetName() << ":" <<
- cmCacheManager::TypeToString(it.GetType())
- << "=" << it.GetValue() << std::endl;
+ std::cout << *it << ":" <<
+ cmCacheManager::TypeToString(t)
+ << "=" << cm.GetCacheManager()->GetCacheEntryValue(*it)
+ << std::endl;
if ( list_help )
{
std::cout << std::endl;
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=eb5090065e06b96f115d2f80872a97e098800d57
commit eb5090065e06b96f115d2f80872a97e098800d57
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Mon Apr 6 12:14:40 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Mon Apr 6 16:52:26 2015 +0200
Port QtDialog to non-iterator cache API.
diff --git a/Source/QtDialog/QCMake.cxx b/Source/QtDialog/QCMake.cxx
index 009d06e..08d53ce 100644
--- a/Source/QtDialog/QCMake.cxx
+++ b/Source/QtDialog/QCMake.cxx
@@ -110,17 +110,18 @@ void QCMake::setBinaryDirectory(const QString& _dir)
QCMakePropertyList props = this->properties();
emit this->propertiesChanged(props);
- cmCacheManager::CacheIterator itm = cachem->NewIterator();
- if ( itm.Find("CMAKE_HOME_DIRECTORY"))
+ const char* homeDir = cachem->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
+ if (homeDir)
{
- setSourceDirectory(QString::fromLocal8Bit(itm.GetValue().c_str()));
+ setSourceDirectory(QString::fromLocal8Bit(homeDir));
}
- if ( itm.Find("CMAKE_GENERATOR"))
+ const char* gen = cachem->GetCacheEntryValue("CMAKE_GENERATOR");
+ if (gen)
{
const char* extraGen = cachem
->GetInitializedCacheValue("CMAKE_EXTRA_GENERATOR");
std::string curGen = cmExternalMakefileProjectGenerator::
- CreateFullGeneratorName(itm.GetValue(), extraGen? extraGen : "");
+ CreateFullGeneratorName(gen, extraGen? extraGen : "");
this->setGenerator(QString::fromLocal8Bit(curGen.c_str()));
}
}
@@ -195,33 +196,35 @@ void QCMake::setProperties(const QCMakePropertyList& newProps)
// set the value of properties
cmCacheManager *cachem = this->CMakeInstance->GetCacheManager();
- for(cmCacheManager::CacheIterator i = cachem->NewIterator();
- !i.IsAtEnd(); i.Next())
+ std::vector<std::string> cacheKeys = cachem->GetCacheEntryKeys();
+ for(std::vector<std::string>::const_iterator it = cacheKeys.begin();
+ it != cacheKeys.end(); ++it)
{
-
- if(i.GetType() == cmCacheManager::INTERNAL ||
- i.GetType() == cmCacheManager::STATIC)
+ cmCacheManager::CacheEntryType t = cachem->GetCacheEntryType(*it);
+ if(t == cmCacheManager::INTERNAL ||
+ t == cmCacheManager::STATIC)
{
continue;
}
QCMakeProperty prop;
- prop.Key = QString::fromLocal8Bit(i.GetName().c_str());
+ prop.Key = QString::fromLocal8Bit(it->c_str());
int idx = props.indexOf(prop);
if(idx == -1)
{
- toremove.append(QString::fromLocal8Bit(i.GetName().c_str()));
+ toremove.append(QString::fromLocal8Bit(it->c_str()));
}
else
{
prop = props[idx];
if(prop.Value.type() == QVariant::Bool)
{
- i.SetValue(prop.Value.toBool() ? "ON" : "OFF");
+ cachem->SetCacheEntryValue(*it, prop.Value.toBool() ? "ON" : "OFF");
}
else
{
- i.SetValue(prop.Value.toString().toLocal8Bit().data());
+ cachem->SetCacheEntryValue(*it,
+ prop.Value.toString().toLocal8Bit().data());
}
props.removeAt(idx);
}
@@ -279,42 +282,47 @@ QCMakePropertyList QCMake::properties() const
QCMakePropertyList ret;
cmCacheManager *cachem = this->CMakeInstance->GetCacheManager();
- for(cmCacheManager::CacheIterator i = cachem->NewIterator();
- !i.IsAtEnd(); i.Next())
+ std::vector<std::string> cacheKeys = cachem->GetCacheEntryKeys();
+ for (std::vector<std::string>::const_iterator i = cacheKeys.begin();
+ i != cacheKeys.end(); ++i)
{
-
- if(i.GetType() == cmCacheManager::INTERNAL ||
- i.GetType() == cmCacheManager::STATIC ||
- i.GetType() == cmCacheManager::UNINITIALIZED)
+ cmCacheManager::CacheEntryType t = cachem->GetCacheEntryType(*i);
+ if(t == cmCacheManager::INTERNAL ||
+ t == cmCacheManager::STATIC ||
+ t == cmCacheManager::UNINITIALIZED)
{
continue;
}
- QCMakeProperty prop;
- prop.Key = QString::fromLocal8Bit(i.GetName().c_str());
- prop.Help = QString::fromLocal8Bit(i.GetProperty("HELPSTRING"));
- prop.Value = QString::fromLocal8Bit(i.GetValue().c_str());
- prop.Advanced = i.GetPropertyAsBool("ADVANCED");
+ const char* cachedValue = cachem->GetCacheEntryValue(*i);
- if(i.GetType() == cmCacheManager::BOOL)
+ QCMakeProperty prop;
+ prop.Key = QString::fromLocal8Bit(i->c_str());
+ prop.Help = QString::fromLocal8Bit(
+ cachem->GetCacheEntryProperty(*i, "HELPSTRING"));
+ prop.Value = QString::fromLocal8Bit(cachedValue);
+ prop.Advanced = cachem->GetCacheEntryPropertyAsBool(*i, "ADVANCED");
+ if(t == cmCacheManager::BOOL)
{
prop.Type = QCMakeProperty::BOOL;
- prop.Value = cmSystemTools::IsOn(i.GetValue().c_str());
+ prop.Value = cmSystemTools::IsOn(cachedValue);
}
- else if(i.GetType() == cmCacheManager::PATH)
+ else if(t == cmCacheManager::PATH)
{
prop.Type = QCMakeProperty::PATH;
}
- else if(i.GetType() == cmCacheManager::FILEPATH)
+ else if(t == cmCacheManager::FILEPATH)
{
prop.Type = QCMakeProperty::FILEPATH;
}
- else if(i.GetType() == cmCacheManager::STRING)
+ else if(t == cmCacheManager::STRING)
{
prop.Type = QCMakeProperty::STRING;
- if (i.PropertyExists("STRINGS"))
+ const char* stringsProperty =
+ cachem->GetCacheEntryProperty(*i, "STRINGS");
+ if (stringsProperty)
{
- prop.Strings = QString::fromLocal8Bit(i.GetProperty("STRINGS")).split(";");
+ prop.Strings = QString::fromLocal8Bit(stringsProperty).split(";");
}
}
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=59c9744d8cba44dc3b49f2cb1fb760dce008fc44
commit 59c9744d8cba44dc3b49f2cb1fb760dce008fc44
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Mon Apr 6 12:01:35 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Mon Apr 6 16:52:26 2015 +0200
Port CursesDialog to non-iterator cache API.
diff --git a/Source/CursesDialog/cmCursesCacheEntryComposite.cxx b/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
index 682f95f..4f028c4 100644
--- a/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
+++ b/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
@@ -18,6 +18,9 @@
#include "cmCursesFilePathWidget.h"
#include "cmCursesDummyWidget.h"
#include "../cmSystemTools.h"
+#include "../cmake.h"
+
+#include <assert.h>
cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
const std::string& key,
@@ -32,7 +35,7 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
}
cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
- const std::string& key, const cmCacheManager::CacheIterator& it, bool isNew,
+ const std::string& key, cmake *cm, bool isNew,
int labelwidth, int entrywidth)
: Key(key), LabelWidth(labelwidth), EntryWidth(entrywidth)
{
@@ -47,11 +50,13 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
}
this->Entry = 0;
- switch ( it.GetType() )
+ const char* value = cm->GetCacheManager()->GetCacheEntryValue(key);
+ assert(value);
+ switch (cm->GetCacheManager()->GetCacheEntryType(key))
{
- case cmCacheManager::BOOL:
+ case cmCacheManager::BOOL:
this->Entry = new cmCursesBoolWidget(this->EntryWidth, 1, 1, 1);
- if (cmSystemTools::IsOn(it.GetValue().c_str()))
+ if (cmSystemTools::IsOn(value))
{
static_cast<cmCursesBoolWidget*>(this->Entry)->SetValueAsBool(true);
}
@@ -62,40 +67,40 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
break;
case cmCacheManager::PATH:
this->Entry = new cmCursesPathWidget(this->EntryWidth, 1, 1, 1);
- static_cast<cmCursesPathWidget*>(this->Entry)->SetString(
- it.GetValue());
+ static_cast<cmCursesPathWidget*>(this->Entry)->SetString(value);
break;
case cmCacheManager::FILEPATH:
this->Entry = new cmCursesFilePathWidget(this->EntryWidth, 1, 1, 1);
- static_cast<cmCursesFilePathWidget*>(this->Entry)->SetString(
- it.GetValue());
+ static_cast<cmCursesFilePathWidget*>(this->Entry)->SetString(value);
break;
case cmCacheManager::STRING:
- if(it.PropertyExists("STRINGS"))
+ {
+ const char* stringsProp = cm->GetCacheManager()
+ ->GetCacheEntryProperty(key, "STRINGS");
+ if(stringsProp)
{
cmCursesOptionsWidget* ow =
new cmCursesOptionsWidget(this->EntryWidth, 1, 1, 1);
this->Entry = ow;
std::vector<std::string> options;
- cmSystemTools::ExpandListArgument(
- std::string(it.GetProperty("STRINGS")), options);
+ cmSystemTools::ExpandListArgument(stringsProp, options);
for(std::vector<std::string>::iterator
si = options.begin(); si != options.end(); ++si)
{
ow->AddOption(*si);
}
- ow->SetOption(it.GetValue());
+ ow->SetOption(value);
}
else
{
this->Entry = new cmCursesStringWidget(this->EntryWidth, 1, 1, 1);
- static_cast<cmCursesStringWidget*>(this->Entry)->SetString(
- it.GetValue());
+ static_cast<cmCursesStringWidget*>(this->Entry)->SetString(value);
}
break;
+ }
case cmCacheManager::UNINITIALIZED:
cmSystemTools::Error("Found an undefined variable: ",
- it.GetName().c_str());
+ key.c_str());
break;
default:
// TODO : put warning message here
diff --git a/Source/CursesDialog/cmCursesCacheEntryComposite.h b/Source/CursesDialog/cmCursesCacheEntryComposite.h
index 7cdf13b..dc4ee4af 100644
--- a/Source/CursesDialog/cmCursesCacheEntryComposite.h
+++ b/Source/CursesDialog/cmCursesCacheEntryComposite.h
@@ -21,7 +21,7 @@ public:
cmCursesCacheEntryComposite(const std::string& key, int labelwidth,
int entrywidth);
cmCursesCacheEntryComposite(const std::string& key,
- const cmCacheManager::CacheIterator& it,
+ cmake *cm,
bool isNew, int labelwidth, int entrywidth);
~cmCursesCacheEntryComposite();
const char* GetValue();
diff --git a/Source/CursesDialog/cmCursesMainForm.cxx b/Source/CursesDialog/cmCursesMainForm.cxx
index 1217bda..833d540 100644
--- a/Source/CursesDialog/cmCursesMainForm.cxx
+++ b/Source/CursesDialog/cmCursesMainForm.cxx
@@ -111,13 +111,17 @@ void cmCursesMainForm::InitializeUI()
// Count non-internal and non-static entries
int count=0;
- for(cmCacheManager::CacheIterator i =
- this->CMakeInstance->GetCacheManager()->NewIterator();
- !i.IsAtEnd(); i.Next())
+ std::vector<std::string> cacheKeys =
+ this->CMakeInstance->GetCacheManager()->GetCacheEntryKeys();
+
+ for(std::vector<std::string>::const_iterator it = cacheKeys.begin();
+ it != cacheKeys.end(); ++it)
{
- if ( i.GetType() != cmCacheManager::INTERNAL &&
- i.GetType() != cmCacheManager::STATIC &&
- i.GetType() != cmCacheManager::UNINITIALIZED)
+ cmCacheManager::CacheEntryType t = this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryType(*it);
+ if (t != cmCacheManager::INTERNAL &&
+ t != cmCacheManager::STATIC &&
+ t != cmCacheManager::UNINITIALIZED)
{
++count;
}
@@ -139,45 +143,49 @@ void cmCursesMainForm::InitializeUI()
// Create the composites.
// First add entries which are new
- for(cmCacheManager::CacheIterator i =
- this->CMakeInstance->GetCacheManager()->NewIterator();
- !i.IsAtEnd(); i.Next())
+ for(std::vector<std::string>::const_iterator it = cacheKeys.begin();
+ it != cacheKeys.end(); ++it)
{
- std::string key = i.GetName();
- if ( i.GetType() == cmCacheManager::INTERNAL ||
- i.GetType() == cmCacheManager::STATIC ||
- i.GetType() == cmCacheManager::UNINITIALIZED )
+ std::string key = *it;
+ cmCacheManager::CacheEntryType t = this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryType(*it);
+ if (t == cmCacheManager::INTERNAL ||
+ t == cmCacheManager::STATIC ||
+ t == cmCacheManager::UNINITIALIZED )
{
continue;
}
if (!this->LookForCacheEntry(key))
{
- newEntries->push_back(new cmCursesCacheEntryComposite(key, i,
- true, 30,
- entrywidth));
+ newEntries->push_back(new cmCursesCacheEntryComposite(key,
+ this->CMakeInstance,
+ true, 30,
+ entrywidth));
this->OkToGenerate = false;
}
}
// then add entries which are old
- for(cmCacheManager::CacheIterator i =
- this->CMakeInstance->GetCacheManager()->NewIterator();
- !i.IsAtEnd(); i.Next())
+ for(std::vector<std::string>::const_iterator it = cacheKeys.begin();
+ it != cacheKeys.end(); ++it)
{
- std::string key = i.GetName();
- if ( i.GetType() == cmCacheManager::INTERNAL ||
- i.GetType() == cmCacheManager::STATIC ||
- i.GetType() == cmCacheManager::UNINITIALIZED )
+ std::string key = *it;
+ cmCacheManager::CacheEntryType t = this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryType(*it);
+ if (t == cmCacheManager::INTERNAL ||
+ t == cmCacheManager::STATIC ||
+ t == cmCacheManager::UNINITIALIZED )
{
continue;
}
if (this->LookForCacheEntry(key))
{
- newEntries->push_back(new cmCursesCacheEntryComposite(key, i,
- false, 30,
- entrywidth));
+ newEntries->push_back(new cmCursesCacheEntryComposite(key,
+ this->CMakeInstance,
+ false, 30,
+ entrywidth));
}
}
}
@@ -216,10 +224,13 @@ void cmCursesMainForm::RePost()
std::vector<cmCursesCacheEntryComposite*>::iterator it;
for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
{
- cmCacheManager::CacheIterator mit =
- this->CMakeInstance->GetCacheManager()->GetCacheIterator((*it)->GetValue());
- if (mit.IsAtEnd() ||
- (!this->AdvancedMode && mit.GetPropertyAsBool("ADVANCED")))
+ const char* existingValue =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryValue((*it)->GetValue());
+ bool advanced =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
+ if (!existingValue || (!this->AdvancedMode && advanced))
{
continue;
}
@@ -245,10 +256,13 @@ void cmCursesMainForm::RePost()
std::vector<cmCursesCacheEntryComposite*>::iterator it;
for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
{
- cmCacheManager::CacheIterator mit =
- this->CMakeInstance->GetCacheManager()->GetCacheIterator((*it)->GetValue());
- if (mit.IsAtEnd() ||
- (!this->AdvancedMode && mit.GetPropertyAsBool("ADVANCED")))
+ const char* existingValue =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryValue((*it)->GetValue());
+ bool advanced =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
+ if (!existingValue || (!this->AdvancedMode && advanced))
{
continue;
}
@@ -314,10 +328,13 @@ void cmCursesMainForm::Render(int left, int top, int width, int height)
std::vector<cmCursesCacheEntryComposite*>::iterator it;
for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
{
- cmCacheManager::CacheIterator mit =
- this->CMakeInstance->GetCacheManager()->GetCacheIterator((*it)->GetValue());
- if (mit.IsAtEnd() ||
- (!this->AdvancedMode && mit.GetPropertyAsBool("ADVANCED")))
+ const char* existingValue =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryValue((*it)->GetValue());
+ bool advanced =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
+ if (!existingValue || (!this->AdvancedMode && advanced))
{
continue;
}
@@ -334,10 +351,13 @@ void cmCursesMainForm::Render(int left, int top, int width, int height)
std::vector<cmCursesCacheEntryComposite*>::iterator it;
for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
{
- cmCacheManager::CacheIterator mit =
- this->CMakeInstance->GetCacheManager()->GetCacheIterator((*it)->GetValue());
- if (mit.IsAtEnd() ||
- (!this->AdvancedMode && mit.GetPropertyAsBool("ADVANCED")))
+ const char* existingValue =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryValue((*it)->GetValue());
+ bool advanced =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
+ if (!existingValue || (!this->AdvancedMode && advanced))
{
continue;
}
@@ -495,11 +515,12 @@ void cmCursesMainForm::UpdateStatusBar(const char* message)
// Get the help string of the current entry
// and add it to the help string
- cmCacheManager::CacheIterator it =
- this->CMakeInstance->GetCacheManager()->GetCacheIterator(curField);
- if (!it.IsAtEnd())
+ const char* existingValue =
+ this->CMakeInstance->GetCacheManager()->GetCacheEntryValue(curField);
+ if (existingValue)
{
- const char* hs = it.GetProperty("HELPSTRING");
+ const char* hs = this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryProperty(curField, "HELPSTRING");
if ( hs )
{
strncpy(help, hs, 127);
@@ -792,23 +813,28 @@ void cmCursesMainForm::FillCacheManagerFromUI()
size_t size = this->Entries->size();
for(size_t i=0; i < size; i++)
{
- cmCacheManager::CacheIterator it =
- this->CMakeInstance->GetCacheManager()->GetCacheIterator(
- (*this->Entries)[i]->Key.c_str());
- if (!it.IsAtEnd())
+ std::string cacheKey = (*this->Entries)[i]->Key;
+ const char* existingValue = this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryValue(cacheKey);
+ if (existingValue)
{
- std::string oldValue = it.GetValue();
+ std::string oldValue = existingValue;
std::string newValue = (*this->Entries)[i]->Entry->GetValue();
std::string fixedOldValue;
std::string fixedNewValue;
- this->FixValue(it.GetType(), oldValue, fixedOldValue);
- this->FixValue(it.GetType(), newValue, fixedNewValue);
+ cmCacheManager::CacheEntryType t =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryType(cacheKey);
+ this->FixValue(t, oldValue, fixedOldValue);
+ this->FixValue(t, newValue, fixedNewValue);
if(!(fixedOldValue == fixedNewValue))
{
// The user has changed the value. Mark it as modified.
- it.SetProperty("MODIFIED", true);
- it.SetValue(fixedNewValue.c_str());
+ this->CMakeInstance->GetCacheManager()
+ ->SetCacheEntryBoolProperty(cacheKey, "MODIFIED", true);
+ this->CMakeInstance->GetCacheManager()
+ ->SetCacheEntryValue(cacheKey, fixedNewValue);
}
}
}
@@ -1017,12 +1043,15 @@ void cmCursesMainForm::HandleInput()
cmCursesWidget* lbl = reinterpret_cast<cmCursesWidget*>(field_userptr(
this->Fields[findex-2]));
const char* curField = lbl->GetValue();
- const char* helpString=0;
- cmCacheManager::CacheIterator it =
- this->CMakeInstance->GetCacheManager()->GetCacheIterator(curField);
- if (!it.IsAtEnd())
+ const char* helpString = 0;
+
+ const char* existingValue =
+ this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryValue(curField);
+ if (existingValue)
{
- helpString = it.GetProperty("HELPSTRING");
+ helpString = this->CMakeInstance->GetCacheManager()
+ ->GetCacheEntryProperty(curField, "HELPSTRING");
}
if (helpString)
{
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=3a909de726d66b4e2b0b06a7baefd366d040ce54
commit 3a909de726d66b4e2b0b06a7baefd366d040ce54
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Mon Apr 6 10:46:25 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Mon Apr 6 16:52:26 2015 +0200
cmMakefile: Port away from CacheEntry.Initialized.
The API has no other external users.
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index b6eff3d..7c1b9c4 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -1810,16 +1810,17 @@ void cmMakefile::AddCacheDefinition(const std::string& name, const char* value,
{
bool haveVal = value ? true : false;
std::string val = haveVal ? value : "";
- cmCacheManager::CacheIterator it =
- this->GetCacheManager()->GetCacheIterator(name.c_str());
- if(!it.IsAtEnd() && (it.GetType() == cmCacheManager::UNINITIALIZED) &&
- it.Initialized())
+ const char* existingValue =
+ this->GetCacheManager()->GetInitializedCacheValue(name);
+ if(existingValue
+ && (this->GetCacheManager()->GetCacheEntryType(name)
+ == cmCacheManager::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
if(!force)
{
- val = it.GetValue();
+ val = existingValue;
haveVal = true;
}
if ( type == cmCacheManager::PATH || type == cmCacheManager::FILEPATH )
@@ -1842,7 +1843,7 @@ void cmMakefile::AddCacheDefinition(const std::string& name, const char* value,
}
this->GetCacheManager()->AddCacheEntry(name, nvalue.c_str(), doc, type);
- val = it.GetValue();
+ val = this->GetCacheManager()->GetInitializedCacheValue(name);
haveVal = true;
}
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=8951b57dd03b3550a6f698aefe9e65435f933323
commit 8951b57dd03b3550a6f698aefe9e65435f933323
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Sun Apr 5 19:50:05 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Mon Apr 6 16:52:26 2015 +0200
cmCacheManager: Add non-iterator-based API.
The iterator pattern is an unusual one for CMake, and it hinders
refactoring all configuration-time data manipulation into a
single class.
diff --git a/Source/cmCacheManager.h b/Source/cmCacheManager.h
index 31d302a..2d3f6e5 100644
--- a/Source/cmCacheManager.h
+++ b/Source/cmCacheManager.h
@@ -139,6 +139,81 @@ public:
///! Get a value from the cache given a key
const char* GetInitializedCacheValue(const std::string& key) const;
+ const char* GetCacheEntryValue(const std::string& key)
+ {
+ cmCacheManager::CacheIterator it = this->GetCacheIterator(key.c_str());
+ if (it.IsAtEnd())
+ {
+ return 0;
+ }
+ return it.GetValue().c_str();
+ }
+
+ const char* GetCacheEntryProperty(std::string const& key,
+ std::string const& propName)
+ {
+ return this->GetCacheIterator(key.c_str()).GetProperty(propName);
+ }
+
+ CacheEntryType GetCacheEntryType(std::string const& key)
+ {
+ return this->GetCacheIterator(key.c_str()).GetType();
+ }
+
+ bool GetCacheEntryPropertyAsBool(std::string const& key,
+ std::string const& propName)
+ {
+ return this->GetCacheIterator(key.c_str()).GetPropertyAsBool(propName);
+ }
+
+ void SetCacheEntryProperty(std::string const& key,
+ std::string const& propName,
+ std::string const& value)
+ {
+ this->GetCacheIterator(key.c_str()).SetProperty(propName, value.c_str());
+ }
+
+ void SetCacheEntryBoolProperty(std::string const& key,
+ std::string const& propName,
+ bool value)
+ {
+ this->GetCacheIterator(key.c_str()).SetProperty(propName, value);
+ }
+
+ void SetCacheEntryValue(std::string const& key,
+ std::string const& value)
+ {
+ this->GetCacheIterator(key.c_str()).SetValue(value.c_str());
+ }
+
+ void RemoveCacheEntryProperty(std::string const& key,
+ std::string const& propName)
+ {
+ this->GetCacheIterator(key.c_str()).SetProperty(propName, (void*)0);
+ }
+
+ void AppendCacheEntryProperty(std::string const& key,
+ std::string const& propName,
+ std::string const& value,
+ bool asString = false)
+ {
+ this->GetCacheIterator(key.c_str()).AppendProperty(propName,
+ value.c_str(),
+ asString);
+ }
+
+ std::vector<std::string> GetCacheEntryKeys()
+ {
+ std::vector<std::string> definitions;
+ definitions.reserve(this->GetSize());
+ cmCacheManager::CacheIterator cit = this->GetCacheIterator();
+ for ( cit.Begin(); !cit.IsAtEnd(); cit.Next() )
+ {
+ definitions.push_back(cit.GetName());
+ }
+ return definitions;
+ }
+
/** Get the version of CMake that wrote the cache. */
unsigned int GetCacheMajorVersion() const
{ return this->CacheMajorVersion; }
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=2c4ff47867f0073865c16cc8e397fe5118b15f33
commit 2c4ff47867f0073865c16cc8e397fe5118b15f33
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Sun Apr 5 10:28:34 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Mon Apr 6 16:52:25 2015 +0200
cmCacheManager: Rename GetCacheValue to GetInitializedCacheValue.
Being initialized is a requirement for this method to return something,
and is what differentiates it from using GetIterator with it.GetValue.
diff --git a/Source/QtDialog/QCMake.cxx b/Source/QtDialog/QCMake.cxx
index 3df48d1..009d06e 100644
--- a/Source/QtDialog/QCMake.cxx
+++ b/Source/QtDialog/QCMake.cxx
@@ -117,7 +117,8 @@ void QCMake::setBinaryDirectory(const QString& _dir)
}
if ( itm.Find("CMAKE_GENERATOR"))
{
- const char* extraGen = cachem->GetCacheValue("CMAKE_EXTRA_GENERATOR");
+ const char* extraGen = cachem
+ ->GetInitializedCacheValue("CMAKE_EXTRA_GENERATOR");
std::string curGen = cmExternalMakefileProjectGenerator::
CreateFullGeneratorName(itm.GetValue(), extraGen? extraGen : "");
this->setGenerator(QString::fromLocal8Bit(curGen.c_str()));
diff --git a/Source/cmCacheManager.cxx b/Source/cmCacheManager.cxx
index b8dfe04..5387d0c 100644
--- a/Source/cmCacheManager.cxx
+++ b/Source/cmCacheManager.cxx
@@ -283,14 +283,16 @@ bool cmCacheManager::LoadCache(const std::string& path,
}
this->CacheMajorVersion = 0;
this->CacheMinorVersion = 0;
- if(const char* cmajor = this->GetCacheValue("CMAKE_CACHE_MAJOR_VERSION"))
+ if(const char* cmajor =
+ this->GetInitializedCacheValue("CMAKE_CACHE_MAJOR_VERSION"))
{
unsigned int v=0;
if(sscanf(cmajor, "%u", &v) == 1)
{
this->CacheMajorVersion = v;
}
- if(const char* cminor = this->GetCacheValue("CMAKE_CACHE_MINOR_VERSION"))
+ if(const char* cminor =
+ this->GetInitializedCacheValue("CMAKE_CACHE_MINOR_VERSION"))
{
if(sscanf(cminor, "%u", &v) == 1)
{
@@ -312,10 +314,11 @@ bool cmCacheManager::LoadCache(const std::string& path,
}
// check to make sure the cache directory has not
// been moved
- if ( internal && this->GetCacheValue("CMAKE_CACHEFILE_DIR") )
+ const char* oldDir = this->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR");
+ if (internal && oldDir)
{
std::string currentcwd = path;
- std::string oldcwd = this->GetCacheValue("CMAKE_CACHEFILE_DIR");
+ std::string oldcwd = oldDir;
cmSystemTools::ConvertToUnixSlashes(currentcwd);
currentcwd += "/CMakeCache.txt";
oldcwd += "/CMakeCache.txt";
@@ -324,7 +327,7 @@ bool cmCacheManager::LoadCache(const std::string& path,
std::string message =
std::string("The current CMakeCache.txt directory ") +
currentcwd + std::string(" is different than the directory ") +
- std::string(this->GetCacheValue("CMAKE_CACHEFILE_DIR")) +
+ std::string(this->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR")) +
std::string(" where CMakeCache.txt was created. This may result "
"in binaries being created in the wrong place. If you "
"are not sure, reedit the CMakeCache.txt");
@@ -654,7 +657,8 @@ cmCacheManager::CacheIterator cmCacheManager::GetCacheIterator(
return CacheIterator(*this, key);
}
-const char* cmCacheManager::GetCacheValue(const std::string& key) const
+const char*
+cmCacheManager::GetInitializedCacheValue(const std::string& key) const
{
CacheEntryMap::const_iterator i = this->Cache.find(key);
if(i != this->Cache.end() &&
diff --git a/Source/cmCacheManager.h b/Source/cmCacheManager.h
index f7f8776..31d302a 100644
--- a/Source/cmCacheManager.h
+++ b/Source/cmCacheManager.h
@@ -137,7 +137,7 @@ public:
CacheEntryType& type);
///! Get a value from the cache given a key
- const char* GetCacheValue(const std::string& key) const;
+ const char* GetInitializedCacheValue(const std::string& key) const;
/** Get the version of CMake that wrote the cache. */
unsigned int GetCacheMajorVersion() const
diff --git a/Source/cmCommandArgumentParserHelper.cxx b/Source/cmCommandArgumentParserHelper.cxx
index 747b7e4..99bf5f5 100644
--- a/Source/cmCommandArgumentParserHelper.cxx
+++ b/Source/cmCommandArgumentParserHelper.cxx
@@ -90,7 +90,8 @@ char* cmCommandArgumentParserHelper::ExpandSpecialVariable(const char* key,
}
if ( strcmp(key, "CACHE") == 0 )
{
- if(const char* c = this->Makefile->GetCacheManager()->GetCacheValue(var))
+ if(const char* c = this->Makefile->GetCacheManager()
+ ->GetInitializedCacheValue(var))
{
if(this->EscapeQuotes)
{
diff --git a/Source/cmExtraEclipseCDT4Generator.cxx b/Source/cmExtraEclipseCDT4Generator.cxx
index 810ec57..0d32e4b 100644
--- a/Source/cmExtraEclipseCDT4Generator.cxx
+++ b/Source/cmExtraEclipseCDT4Generator.cxx
@@ -205,7 +205,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout,
std::string cacheEntryName = "CMAKE_ECLIPSE_ENVVAR_";
cacheEntryName += envVar;
- const char* cacheValue = mf->GetCacheManager()->GetCacheValue(
+ const char* cacheValue = mf->GetCacheManager()->GetInitializedCacheValue(
cacheEntryName);
// now we have both, decide which one to use
diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx
index 3c0a0e2..f23caa6 100644
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@@ -179,7 +179,7 @@ void cmGlobalGenerator::ResolveLanguageCompiler(const std::string &lang,
return;
}
const char* cname = this->GetCMakeInstance()->
- GetCacheManager()->GetCacheValue(langComp);
+ GetCacheManager()->GetInitializedCacheValue(langComp);
std::string changeVars;
if(cname && !optional)
{
@@ -1641,7 +1641,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()->GetCacheValue
+ if (!this->CMakeInstance->GetCacheManager()->GetInitializedCacheValue
("CMAKE_NUMBER_OF_LOCAL_GENERATORS"))
{
// If CMAKE_NUMBER_OF_LOCAL_GENERATORS is not set
@@ -1839,7 +1839,7 @@ void cmGlobalGenerator::AddLocalGenerator(cmLocalGenerator *lg)
// update progress
// estimate how many lg there will be
const char *numGenC =
- this->CMakeInstance->GetCacheManager()->GetCacheValue
+ this->CMakeInstance->GetCacheManager()->GetInitializedCacheValue
("CMAKE_NUMBER_OF_LOCAL_GENERATORS");
if (!numGenC)
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index ad4ad7c..b6eff3d 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -2432,7 +2432,7 @@ bool cmMakefile::IsDefinitionSet(const std::string& name) const
this->Internal->VarUsageStack.top().insert(name);
if(!def)
{
- def = this->GetCacheManager()->GetCacheValue(name);
+ def = this->GetCacheManager()->GetInitializedCacheValue(name);
}
#ifdef CMAKE_BUILD_WITH_CMAKE
if(cmVariableWatch* vv = this->GetVariableWatch())
@@ -2457,7 +2457,7 @@ const char* cmMakefile::GetDefinition(const std::string& name) const
const char* def = this->Internal->VarStack.top().Get(name);
if(!def)
{
- def = this->GetCacheManager()->GetCacheValue(name);
+ def = this->GetCacheManager()->GetInitializedCacheValue(name);
}
#ifdef CMAKE_BUILD_WITH_CMAKE
cmVariableWatch* vv = this->GetVariableWatch();
@@ -2835,7 +2835,8 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringNew(
value = cmSystemTools::GetEnv(lookup.c_str());
break;
case CACHE:
- value = this->GetCacheManager()->GetCacheValue(lookup);
+ value = this->GetCacheManager()
+ ->GetInitializedCacheValue(lookup);
break;
}
// Get the string we're meant to append to.
@@ -4903,7 +4904,7 @@ bool cmMakefile::SetPolicy(cmPolicies::PolicyID id,
(status == cmPolicies::WARN || status == cmPolicies::OLD))
{
if(!(this->GetCacheManager()
- ->GetCacheValue("CMAKE_BACKWARDS_COMPATIBILITY")))
+ ->GetInitializedCacheValue("CMAKE_BACKWARDS_COMPATIBILITY")))
{
// Set it to 2.4 because that is the last version where the
// variable had meaning.
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index e781417..210c0ef 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -344,7 +344,8 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
std::string cachedValue;
if(this->WarnUnusedCli)
{
- if(const char *v = this->CacheManager->GetCacheValue(var))
+ if(const char *v = this->CacheManager
+ ->GetInitializedCacheValue(var))
{
haveValue = true;
cachedValue = v;
@@ -357,7 +358,8 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
if(this->WarnUnusedCli)
{
if (!haveValue ||
- cachedValue != this->CacheManager->GetCacheValue(var))
+ cachedValue != this->CacheManager
+ ->GetInitializedCacheValue(var))
{
this->WatchUnusedCli(var);
}
@@ -1203,10 +1205,10 @@ int cmake::DoPreConfigureChecks()
}
// do a sanity check on some values
- if(this->CacheManager->GetCacheValue("CMAKE_HOME_DIRECTORY"))
+ if(this->CacheManager->GetInitializedCacheValue("CMAKE_HOME_DIRECTORY"))
{
std::string cacheStart =
- this->CacheManager->GetCacheValue("CMAKE_HOME_DIRECTORY");
+ this->CacheManager->GetInitializedCacheValue("CMAKE_HOME_DIRECTORY");
cacheStart += "/CMakeLists.txt";
std::string currentStart = this->GetHomeDirectory();
currentStart += "/CMakeLists.txt";
@@ -1355,9 +1357,9 @@ int cmake::ActualConfigure()
if(!this->GlobalGenerator)
{
const char* genName =
- this->CacheManager->GetCacheValue("CMAKE_GENERATOR");
+ this->CacheManager->GetInitializedCacheValue("CMAKE_GENERATOR");
const char* extraGenName =
- this->CacheManager->GetCacheValue("CMAKE_EXTRA_GENERATOR");
+ this->CacheManager->GetInitializedCacheValue("CMAKE_EXTRA_GENERATOR");
if(genName)
{
std::string fullName = cmExternalMakefileProjectGenerator::
@@ -1435,7 +1437,8 @@ int cmake::ActualConfigure()
}
}
- const char* genName = this->CacheManager->GetCacheValue("CMAKE_GENERATOR");
+ const char* genName = this->CacheManager
+ ->GetInitializedCacheValue("CMAKE_GENERATOR");
if(genName)
{
if(!this->GlobalGenerator->MatchesGeneratorName(genName))
@@ -1451,7 +1454,7 @@ int cmake::ActualConfigure()
return -2;
}
}
- if(!this->CacheManager->GetCacheValue("CMAKE_GENERATOR"))
+ if(!this->CacheManager->GetInitializedCacheValue("CMAKE_GENERATOR"))
{
this->CacheManager->AddCacheEntry("CMAKE_GENERATOR",
this->GlobalGenerator->GetName().c_str(),
@@ -1464,7 +1467,7 @@ int cmake::ActualConfigure()
}
if(const char* platformName =
- this->CacheManager->GetCacheValue("CMAKE_GENERATOR_PLATFORM"))
+ this->CacheManager->GetInitializedCacheValue("CMAKE_GENERATOR_PLATFORM"))
{
if(this->GeneratorPlatform.empty())
{
@@ -1492,7 +1495,7 @@ int cmake::ActualConfigure()
}
if(const char* tsName =
- this->CacheManager->GetCacheValue("CMAKE_GENERATOR_TOOLSET"))
+ this->CacheManager->GetInitializedCacheValue("CMAKE_GENERATOR_TOOLSET"))
{
if(this->GeneratorToolset.empty())
{
@@ -1546,16 +1549,18 @@ 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()->GetCacheValue("CMAKE_BACKWARDS_COMPATIBILITY"))
+ if(this->GetCacheManager()
+ ->GetInitializedCacheValue("CMAKE_BACKWARDS_COMPATIBILITY"))
{
- if(!this->CacheManager->GetCacheValue("LIBRARY_OUTPUT_PATH"))
+ if(!this->CacheManager->GetInitializedCacheValue("LIBRARY_OUTPUT_PATH"))
{
this->CacheManager->AddCacheEntry
("LIBRARY_OUTPUT_PATH", "",
"Single output directory for building all libraries.",
cmCacheManager::PATH);
}
- if(!this->CacheManager->GetCacheValue("EXECUTABLE_OUTPUT_PATH"))
+ if(!this->CacheManager
+ ->GetInitializedCacheValue("EXECUTABLE_OUTPUT_PATH"))
{
this->CacheManager->AddCacheEntry
("EXECUTABLE_OUTPUT_PATH", "",
@@ -1563,7 +1568,8 @@ int cmake::ActualConfigure()
cmCacheManager::PATH);
}
}
- if(!this->CacheManager->GetCacheValue("CMAKE_USE_RELATIVE_PATHS"))
+ if(!this->CacheManager
+ ->GetInitializedCacheValue("CMAKE_USE_RELATIVE_PATHS"))
{
this->CacheManager->AddCacheEntry
("CMAKE_USE_RELATIVE_PATHS", "OFF",
@@ -1578,9 +1584,9 @@ int cmake::ActualConfigure()
}
if(cmSystemTools::GetFatalErrorOccured() &&
- (!this->CacheManager->GetCacheValue("CMAKE_MAKE_PROGRAM") ||
+ (!this->CacheManager->GetInitializedCacheValue("CMAKE_MAKE_PROGRAM") ||
cmSystemTools::IsOff(this->CacheManager->
- GetCacheValue("CMAKE_MAKE_PROGRAM"))))
+ GetInitializedCacheValue("CMAKE_MAKE_PROGRAM"))))
{
// We must have a bad generator selection. Wipe the cache entry so the
// user can select another.
@@ -1796,7 +1802,7 @@ void cmake::AddCacheEntry(const std::string& key, const char* value,
const char* cmake::GetCacheDefinition(const std::string& name) const
{
- return this->CacheManager->GetCacheValue(name);
+ return this->CacheManager->GetInitializedCacheValue(name);
}
void cmake::AddDefaultCommands()
@@ -1956,7 +1962,8 @@ void cmake::UpdateConversionPathTable()
{
// Update the path conversion table with any specified file:
const char* tablepath =
- this->CacheManager->GetCacheValue("CMAKE_PATH_TRANSLATION_FILE");
+ this->CacheManager
+ ->GetInitializedCacheValue("CMAKE_PATH_TRANSLATION_FILE");
if(tablepath)
{
@@ -2190,7 +2197,7 @@ void cmake::TruncateOutputLog(const char* fname)
{
return;
}
- if ( !this->CacheManager->GetCacheValue("CMAKE_CACHEFILE_DIR") )
+ if ( !this->CacheManager->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR") )
{
cmSystemTools::RemoveFile(fullPath);
return;
@@ -2469,7 +2476,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->GetCacheValue("CMAKE_ROOT");
+ this->CacheManager->GetInitializedCacheValue("CMAKE_ROOT");
modulesPath += "/Modules";
std::string inFile = modulesPath;
inFile += "/SystemInformation.cmake";
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=db25277da05b1f2c058635b76cf3f9d612784427
commit db25277da05b1f2c058635b76cf3f9d612784427
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Sun Apr 5 00:07:04 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Mon Apr 6 16:52:25 2015 +0200
Add API for cache loading, deleting and saving to the cmake class.
Migrate existing users of the CacheManager API to use the new
API. The CacheManager will be going away soon.
diff --git a/Source/CTest/cmCTestBuildAndTestHandler.cxx b/Source/CTest/cmCTestBuildAndTestHandler.cxx
index 0827037..586070b 100644
--- a/Source/CTest/cmCTestBuildAndTestHandler.cxx
+++ b/Source/CTest/cmCTestBuildAndTestHandler.cxx
@@ -18,7 +18,6 @@
#include "cmGlobalGenerator.h"
#include <cmsys/Process.h>
#include "cmCTestTestHandler.h"
-#include "cmCacheManager.h"
//----------------------------------------------------------------------
cmCTestBuildAndTestHandler::cmCTestBuildAndTestHandler()
@@ -255,7 +254,7 @@ int cmCTestBuildAndTestHandler::RunCMakeAndTest(std::string* outstring)
cm.SetGeneratorToolset(this->BuildGeneratorToolset);
// Load the cache to make CMAKE_MAKE_PROGRAM available.
- cm.GetCacheManager()->LoadCache(this->BinaryDir);
+ cm.LoadCache(this->BinaryDir);
}
else
{
diff --git a/Source/CursesDialog/cmCursesMainForm.cxx b/Source/CursesDialog/cmCursesMainForm.cxx
index d60062e..1217bda 100644
--- a/Source/CursesDialog/cmCursesMainForm.cxx
+++ b/Source/CursesDialog/cmCursesMainForm.cxx
@@ -639,7 +639,7 @@ int cmCursesMainForm::Configure(int noconfigure)
// always save the current gui values to disk
this->FillCacheManagerFromUI();
- this->CMakeInstance->GetCacheManager()->SaveCache(
+ this->CMakeInstance->SaveCache(
this->CMakeInstance->GetHomeOutputDirectory());
this->LoadCache(0);
diff --git a/Source/QtDialog/QCMake.cxx b/Source/QtDialog/QCMake.cxx
index 996aa75..3df48d1 100644
--- a/Source/QtDialog/QCMake.cxx
+++ b/Source/QtDialog/QCMake.cxx
@@ -96,7 +96,7 @@ void QCMake::setBinaryDirectory(const QString& _dir)
emit this->binaryDirChanged(this->BinaryDirectory);
cmCacheManager *cachem = this->CMakeInstance->GetCacheManager();
this->setGenerator(QString());
- if(!this->CMakeInstance->GetCacheManager()->LoadCache(
+ if(!this->CMakeInstance->LoadCache(
this->BinaryDirectory.toLocal8Bit().data()))
{
QDir testDir(this->BinaryDirectory);
@@ -270,7 +270,7 @@ void QCMake::setProperties(const QCMakePropertyList& newProps)
}
}
- cachem->SaveCache(this->BinaryDirectory.toLocal8Bit().data());
+ this->CMakeInstance->SaveCache(this->BinaryDirectory.toLocal8Bit().data());
}
QCMakePropertyList QCMake::properties() const
@@ -397,9 +397,9 @@ QStringList QCMake::availableGenerators() const
void QCMake::deleteCache()
{
// delete cache
- this->CMakeInstance->GetCacheManager()->DeleteCache(this->BinaryDirectory.toLocal8Bit().data());
+ this->CMakeInstance->DeleteCache(this->BinaryDirectory.toLocal8Bit().data());
// reload to make our cache empty
- this->CMakeInstance->GetCacheManager()->LoadCache(this->BinaryDirectory.toLocal8Bit().data());
+ this->CMakeInstance->LoadCache(this->BinaryDirectory.toLocal8Bit().data());
// emit no generator and no properties
this->setGenerator(QString());
QCMakePropertyList props = this->properties();
@@ -412,7 +412,7 @@ void QCMake::reloadCache()
QCMakePropertyList props;
emit this->propertiesChanged(props);
// reload
- this->CMakeInstance->GetCacheManager()->LoadCache(this->BinaryDirectory.toLocal8Bit().data());
+ this->CMakeInstance->LoadCache(this->BinaryDirectory.toLocal8Bit().data());
// emit new cache properties
props = this->properties();
emit this->propertiesChanged(props);
diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx
index df61fe6..1db057b 100644
--- a/Source/cmCTest.cxx
+++ b/Source/cmCTest.cxx
@@ -2281,7 +2281,7 @@ bool cmCTest::AddVariableDefinition(const std::string &arg)
std::string value;
cmCacheManager::CacheEntryType type = cmCacheManager::UNINITIALIZED;
- if (cmCacheManager::ParseEntry(arg, name, value, type))
+ if (cmake::ParseCacheEntry(arg, name, value, type))
{
this->Definitions[name] = value;
return true;
diff --git a/Source/cmExtraEclipseCDT4Generator.cxx b/Source/cmExtraEclipseCDT4Generator.cxx
index d64b0d7..810ec57 100644
--- a/Source/cmExtraEclipseCDT4Generator.cxx
+++ b/Source/cmExtraEclipseCDT4Generator.cxx
@@ -223,7 +223,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout,
mf->AddCacheDefinition(cacheEntryName, valueToUse.c_str(),
cacheEntryName.c_str(), cmCacheManager::STRING,
true);
- mf->GetCacheManager()->SaveCache(mf->GetHomeOutputDirectory());
+ mf->GetCMakeInstance()->SaveCache(mf->GetHomeOutputDirectory());
}
else if (envVarValue==0 && cacheValue!=0)
{
@@ -244,7 +244,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout,
mf->AddCacheDefinition(cacheEntryName, valueToUse.c_str(),
cacheEntryName.c_str(), cmCacheManager::STRING,
true);
- mf->GetCacheManager()->SaveCache(mf->GetHomeOutputDirectory());
+ mf->GetCMakeInstance()->SaveCache(mf->GetHomeOutputDirectory());
}
}
diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx
index 5e584a4..0561a05 100644
--- a/Source/cmGlobalXCodeGenerator.cxx
+++ b/Source/cmGlobalXCodeGenerator.cxx
@@ -3703,7 +3703,7 @@ cmGlobalXCodeGenerator::OutputXCodeProject(cmLocalGenerator* root,
// Since this call may have created new cache entries, save the cache:
//
- root->GetMakefile()->GetCacheManager()->SaveCache(
+ root->GetMakefile()->GetCMakeInstance()->SaveCache(
root->GetMakefile()->GetHomeOutputDirectory());
}
diff --git a/Source/cmLoadCacheCommand.cxx b/Source/cmLoadCacheCommand.cxx
index 93aec32..e2ae901 100644
--- a/Source/cmLoadCacheCommand.cxx
+++ b/Source/cmLoadCacheCommand.cxx
@@ -81,8 +81,8 @@ bool cmLoadCacheCommand
{
break;
}
- this->Makefile->GetCacheManager()->LoadCache(args[i], false,
- excludes, includes);
+ this->Makefile->GetCMakeInstance()->LoadCache(args[i], false,
+ excludes, includes);
}
@@ -173,7 +173,7 @@ void cmLoadCacheCommand::CheckLine(const char* line)
std::string var;
std::string value;
cmCacheManager::CacheEntryType type = cmCacheManager::UNINITIALIZED;
- if(cmCacheManager::ParseEntry(line, var, value, type))
+ if(cmake::ParseCacheEntry(line, var, value, type))
{
// Found a real entry. See if this one was requested.
if(this->VariablesToRead.find(var) != this->VariablesToRead.end())
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index 5c52a1a..e781417 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -917,7 +917,7 @@ void cmake::SetDirectoriesFromFile(const char* arg)
{
cmCacheManager* cachem = this->GetCacheManager();
cmCacheManager::CacheIterator it = cachem->NewIterator();
- if(cachem->LoadCache(cachePath) &&
+ if(this->LoadCache(cachePath) &&
it.Find("CMAKE_HOME_DIRECTORY"))
{
this->SetHomeOutputDirectory(cachePath);
@@ -1860,10 +1860,18 @@ void cmake::AddDefaultGenerators()
#endif
}
+bool cmake::ParseCacheEntry(const std::string& entry,
+ std::string& var,
+ std::string& value,
+ cmCacheManager::CacheEntryType& type)
+{
+ return cmCacheManager::ParseEntry(entry, var, value, type);
+}
+
int cmake::LoadCache()
{
// could we not read the cache
- if (!this->CacheManager->LoadCache(this->GetHomeOutputDirectory()))
+ if (!this->LoadCache(this->GetHomeOutputDirectory()))
{
// if it does exist, but isn't readable then warn the user
std::string cacheFile = this->GetHomeOutputDirectory();
@@ -1886,6 +1894,28 @@ int cmake::LoadCache()
return 0;
}
+bool cmake::LoadCache(const std::string& path)
+{
+ return this->CacheManager->LoadCache(path);
+}
+
+bool cmake::LoadCache(const std::string& path, bool internal,
+ std::set<std::string>& excludes,
+ std::set<std::string>& includes)
+{
+ return this->CacheManager->LoadCache(path, internal, excludes, includes);
+}
+
+bool cmake::SaveCache(const std::string& path)
+{
+ return this->CacheManager->SaveCache(path);
+}
+
+bool cmake::DeleteCache(const std::string& path)
+{
+ return this->CacheManager->DeleteCache(path);
+}
+
void cmake::SetProgressCallback(ProgressCallbackType f, void *cd)
{
this->ProgressCallback = f;
@@ -2764,9 +2794,8 @@ int cmake::Build(const std::string& dir,
}
std::string cachePath = dir;
cmSystemTools::ConvertToUnixSlashes(cachePath);
- cmCacheManager* cachem = this->GetCacheManager();
- cmCacheManager::CacheIterator it = cachem->NewIterator();
- if(!cachem->LoadCache(cachePath))
+ cmCacheManager::CacheIterator it = this->GetCacheManager()->NewIterator();
+ if(!this->LoadCache(cachePath))
{
std::cerr << "Error: could not load cache\n";
return 1;
diff --git a/Source/cmake.h b/Source/cmake.h
index c22b329..3acf4a8 100644
--- a/Source/cmake.h
+++ b/Source/cmake.h
@@ -18,11 +18,11 @@
#include "cmPropertyDefinitionMap.h"
#include "cmPropertyMap.h"
#include "cmInstalledFile.h"
+#include "cmCacheManager.h"
class cmGlobalGeneratorFactory;
class cmGlobalGenerator;
class cmLocalGenerator;
-class cmCacheManager;
class cmMakefile;
class cmCommand;
class cmVariableWatch;
@@ -173,7 +173,19 @@ class cmake
int Configure();
int ActualConfigure();
+ ///! Break up a line like VAR:type="value" into var, type and value
+ static bool ParseCacheEntry(const std::string& entry,
+ std::string& var,
+ std::string& value,
+ cmCacheManager::CacheEntryType& type);
+
int LoadCache();
+ bool LoadCache(const std::string& path);
+ bool LoadCache(const std::string& path, bool internal,
+ std::set<std::string>& excludes,
+ std::set<std::string>& includes);
+ bool SaveCache(const std::string& path);
+ bool DeleteCache(const std::string& path);
void PreLoadCMakeFiles();
///! Create a GlobalGenerator
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=6f3e57e98ce324d7afb7681647159029fb145634
commit 6f3e57e98ce324d7afb7681647159029fb145634
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Mon Apr 6 13:32:00 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Mon Apr 6 16:52:25 2015 +0200
cmMakefile: Remove cache version accessors.
They are only used by legacy code. Inline them there to simplify
cmMakefile.
diff --git a/Source/cmCPluginAPI.cxx b/Source/cmCPluginAPI.cxx
index 691d80d..987a7b1 100644
--- a/Source/cmCPluginAPI.cxx
+++ b/Source/cmCPluginAPI.cxx
@@ -51,12 +51,14 @@ void CCONV cmSetError(void *info, const char *err)
unsigned int CCONV cmGetCacheMajorVersion(void *arg)
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
- return mf->GetCacheMajorVersion();
+ cmCacheManager *manager = mf->GetCMakeInstance()->GetCacheManager();
+ return manager->GetCacheMajorVersion();
}
unsigned int CCONV cmGetCacheMinorVersion(void *arg)
{
cmMakefile *mf = static_cast<cmMakefile *>(arg);
- return mf->GetCacheMinorVersion();
+ cmCacheManager *manager = mf->GetCMakeInstance()->GetCacheManager();
+ return manager->GetCacheMinorVersion();
}
unsigned int CCONV cmGetMajorVersion(void *)
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 7f44da2..ad4ad7c 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -174,16 +174,6 @@ void cmMakefile::Initialize()
this->CheckCMP0000 = false;
}
-unsigned int cmMakefile::GetCacheMajorVersion() const
-{
- return this->GetCacheManager()->GetCacheMajorVersion();
-}
-
-unsigned int cmMakefile::GetCacheMinorVersion() const
-{
- return this->GetCacheManager()->GetCacheMinorVersion();
-}
-
cmMakefile::~cmMakefile()
{
cmDeleteAll(this->InstallGenerators);
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index 920b6b7..5209891 100644
--- a/Source/cmMakefile.h
+++ b/Source/cmMakefile.h
@@ -62,14 +62,6 @@ class cmMakefile
class Internals;
cmsys::auto_ptr<Internals> Internal;
public:
- /**
- * Return the major and minor version of the cmake that
- * was used to write the currently loaded cache, note
- * this method will not work before the cache is loaded.
- */
- unsigned int GetCacheMajorVersion() const;
- unsigned int GetCacheMinorVersion() const;
-
/* Check for unused variables in this scope */
void CheckForUnusedVariables() const;
/* Mark a variable as used */
diff --git a/Source/cmUtilitySourceCommand.cxx b/Source/cmUtilitySourceCommand.cxx
index ee1ff29..2799a9b 100644
--- a/Source/cmUtilitySourceCommand.cxx
+++ b/Source/cmUtilitySourceCommand.cxx
@@ -52,11 +52,13 @@ bool cmUtilitySourceCommand
}
else
{
+ cmCacheManager *manager =
+ this->Makefile->GetCMakeInstance()->GetCacheManager();
haveCacheValue = (cacheValue &&
(strstr(cacheValue, "(IntDir)") == 0 ||
(intDir && strcmp(intDir, "$(IntDir)") == 0)) &&
- (this->Makefile->GetCacheMajorVersion() != 0 &&
- this->Makefile->GetCacheMinorVersion() != 0 ));
+ (manager->GetCacheMajorVersion() != 0 &&
+ manager->GetCacheMinorVersion() != 0 ));
}
if(haveCacheValue)
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=4cf211dcbaf1efaa082d281d1ff4d3755a108389
commit 4cf211dcbaf1efaa082d281d1ff4d3755a108389
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Mon Apr 6 12:30:21 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Mon Apr 6 16:52:25 2015 +0200
cmMakefile: Simplify GetDefinitions implementation.
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 215ee16..7f44da2 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -2501,20 +2501,20 @@ const char* cmMakefile::GetSafeDefinition(const std::string& def) const
std::vector<std::string> cmMakefile
::GetDefinitions(int cacheonly /* = 0 */) const
{
- std::set<std::string> definitions;
+ std::vector<std::string> res;
if ( !cacheonly )
{
- definitions = this->Internal->VarStack.top().ClosureKeys();
+ std::set<std::string> definitions =
+ this->Internal->VarStack.top().ClosureKeys();
+ res.insert(res.end(), definitions.begin(), definitions.end());
}
cmCacheManager::CacheIterator cit =
this->GetCacheManager()->GetCacheIterator();
for ( cit.Begin(); !cit.IsAtEnd(); cit.Next() )
{
- definitions.insert(cit.GetName());
+ res.push_back(cit.GetName());
}
-
- std::vector<std::string> res;
- res.insert(res.end(), definitions.begin(), definitions.end());
+ std::sort(res.begin(), res.end());
return res;
}
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=883042c34e6270551907b5d43f300ad3193b83a8
commit 883042c34e6270551907b5d43f300ad3193b83a8
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Mon Apr 6 14:41:05 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Mon Apr 6 16:52:24 2015 +0200
Remove unused includes.
diff --git a/Source/cmCacheManager.cxx b/Source/cmCacheManager.cxx
index fa7eff3..b8dfe04 100644
--- a/Source/cmCacheManager.cxx
+++ b/Source/cmCacheManager.cxx
@@ -12,7 +12,6 @@
#include "cmCacheManager.h"
#include "cmSystemTools.h"
-#include "cmCacheManager.h"
#include "cmGeneratedFileStream.h"
#include "cmMakefile.h"
#include "cmake.h"
diff --git a/Source/cmLocalVisualStudio6Generator.cxx b/Source/cmLocalVisualStudio6Generator.cxx
index 2b999eb..6844fee 100644
--- a/Source/cmLocalVisualStudio6Generator.cxx
+++ b/Source/cmLocalVisualStudio6Generator.cxx
@@ -14,7 +14,6 @@
#include "cmMakefile.h"
#include "cmSystemTools.h"
#include "cmSourceFile.h"
-#include "cmCacheManager.h"
#include "cmGeneratorTarget.h"
#include "cmCustomCommandGenerator.h"
#include "cmake.h"
-----------------------------------------------------------------------
Summary of changes:
Source/CMakeLists.txt | 2 +
Source/CTest/cmCTestBuildAndTestHandler.cxx | 3 +-
Source/CursesDialog/ccmake.cxx | 1 -
Source/CursesDialog/cmCursesBoolWidget.cxx | 2 +-
.../CursesDialog/cmCursesCacheEntryComposite.cxx | 44 ++--
Source/CursesDialog/cmCursesCacheEntryComposite.h | 3 +-
Source/CursesDialog/cmCursesDummyWidget.cxx | 2 +-
Source/CursesDialog/cmCursesFilePathWidget.cxx | 2 +-
Source/CursesDialog/cmCursesLongMessageForm.cxx | 1 -
Source/CursesDialog/cmCursesMainForm.cxx | 169 ++++++++------
Source/CursesDialog/cmCursesMainForm.h | 2 +-
Source/CursesDialog/cmCursesOptionsWidget.cxx | 2 +-
Source/CursesDialog/cmCursesPathWidget.cxx | 4 +-
Source/CursesDialog/cmCursesStringWidget.cxx | 2 +-
Source/CursesDialog/cmCursesWidget.h | 6 +-
Source/QtDialog/QCMake.cxx | 103 +++++----
Source/cmBuildCommand.cxx | 2 +-
Source/cmBuildNameCommand.cxx | 4 +-
Source/cmCPluginAPI.cxx | 18 +-
Source/cmCTest.cxx | 4 +-
Source/cmCacheManager.cxx | 112 +++------
Source/cmCacheManager.h | 111 +++++++--
Source/cmCommandArgumentParserHelper.cxx | 4 +-
Source/cmConfiguration.cxx | 170 ++++++++++++++
Source/cmConfiguration.h | 52 +++++
Source/cmCoreTryCompile.cxx | 3 +-
Source/cmExtraEclipseCDT4Generator.cxx | 11 +-
Source/cmFindBase.cxx | 14 +-
Source/cmFindLibraryCommand.cxx | 7 +-
Source/cmFindPackageCommand.cxx | 2 +-
Source/cmFindPathCommand.cxx | 7 +-
Source/cmFindProgramCommand.cxx | 7 +-
Source/cmGetFilenameComponentCommand.cxx | 8 +-
Source/cmGetPropertyCommand.cxx | 8 +-
Source/cmGlobalGenerator.cxx | 23 +-
Source/cmGlobalUnixMakefileGenerator3.cxx | 2 +-
Source/cmGlobalVisualStudio7Generator.cxx | 8 +-
Source/cmGlobalXCodeGenerator.cxx | 6 +-
Source/cmIncludeExternalMSProjectCommand.cxx | 2 +-
Source/cmLoadCacheCommand.cxx | 8 +-
Source/cmLocalVisualStudio10Generator.cxx | 2 +-
Source/cmLocalVisualStudio7Generator.cxx | 3 +-
Source/cmMakefile.cxx | 79 +++----
Source/cmMakefile.h | 14 +-
Source/cmMarkAsAdvancedCommand.cxx | 17 +-
Source/cmOptionCommand.cxx | 14 +-
Source/cmProjectCommand.cxx | 6 +-
Source/cmSetCommand.cxx | 15 +-
Source/cmSetPropertyCommand.cxx | 21 +-
Source/cmSetPropertyCommand.h | 2 +-
Source/cmSiteNameCommand.cxx | 2 +-
Source/cmTarget.cxx | 4 +-
Source/cmTryRunCommand.cxx | 26 ++-
Source/cmUtilitySourceCommand.cxx | 12 +-
Source/cmVariableRequiresCommand.cxx | 8 +-
Source/cmake.cxx | 240 ++++++++++++--------
Source/cmake.h | 21 +-
Source/cmakemain.cxx | 32 +--
bootstrap | 1 +
59 files changed, 904 insertions(+), 556 deletions(-)
create mode 100644 Source/cmConfiguration.cxx
create mode 100644 Source/cmConfiguration.h
hooks/post-receive
--
CMake
More information about the Cmake-commits
mailing list