[Cmake-commits] CMake branch, next, updated. v3.2.1-1585-g8d04367
Stephen Kelly
steveire at gmail.com
Tue Apr 7 16:15:57 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 8d0436743079e56fc77d5352b62604266ddfc4f5 (commit)
via 1eb97ae2e275aa24f483673414931365ccc5134d (commit)
from c6f88a1227a80f74728efbf7525798c4884786a7 (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=8d0436743079e56fc77d5352b62604266ddfc4f5
commit 8d0436743079e56fc77d5352b62604266ddfc4f5
Merge: c6f88a1 1eb97ae
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Tue Apr 7 16:15:55 2015 -0400
Commit: CMake Topic Stage <kwrobot at kitware.com>
CommitDate: Tue Apr 7 16:15:55 2015 -0400
Merge topic 'introduce-cmConfiguration' into next
1eb97ae2 Revert topic.
http://cmake.org/gitweb?p=cmake.git;a=commitdiff;h=1eb97ae2e275aa24f483673414931365ccc5134d
commit 1eb97ae2e275aa24f483673414931365ccc5134d
Author: Stephen Kelly <steveire at gmail.com>
AuthorDate: Tue Apr 7 22:14:38 2015 +0200
Commit: Stephen Kelly <steveire at gmail.com>
CommitDate: Tue Apr 7 22:15:15 2015 +0200
Revert topic.
diff --git a/Source/CMakeLists.txt b/Source/CMakeLists.txt
index 8354fd9..04f6a81 100644
--- a/Source/CMakeLists.txt
+++ b/Source/CMakeLists.txt
@@ -171,8 +171,6 @@ set(SRCS
cmComputeLinkInformation.h
cmComputeTargetDepends.h
cmComputeTargetDepends.cxx
- cmConfiguration.cxx
- cmConfiguration.h
cmCPackPropertiesGenerator.h
cmCPackPropertiesGenerator.cxx
cmCryptoHash.cxx
diff --git a/Source/CursesDialog/ccmake.cxx b/Source/CursesDialog/ccmake.cxx
index e013f81..3d92a2d 100644
--- a/Source/CursesDialog/ccmake.cxx
+++ b/Source/CursesDialog/ccmake.cxx
@@ -9,6 +9,7 @@
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
+#include "../cmCacheManager.h"
#include "../cmSystemTools.h"
#include "../cmake.h"
#include "../cmDocumentation.h"
diff --git a/Source/CursesDialog/cmCursesBoolWidget.cxx b/Source/CursesDialog/cmCursesBoolWidget.cxx
index d6329c5..fd15b99 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 = cmConfiguration::BOOL;
+ this->Type = cmCacheManager::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 e388409..4f028c4 100644
--- a/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
+++ b/Source/CursesDialog/cmCursesCacheEntryComposite.cxx
@@ -19,7 +19,6 @@
#include "cmCursesDummyWidget.h"
#include "../cmSystemTools.h"
#include "../cmake.h"
-#include "../cmConfiguration.h"
#include <assert.h>
@@ -51,11 +50,11 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
}
this->Entry = 0;
- const char* value = cm->GetConfiguration()->GetCacheEntryValue(key);
+ const char* value = cm->GetCacheManager()->GetCacheEntryValue(key);
assert(value);
- switch (cm->GetConfiguration()->GetCacheEntryType(key))
+ switch (cm->GetCacheManager()->GetCacheEntryType(key))
{
- case cmConfiguration::BOOL:
+ case cmCacheManager::BOOL:
this->Entry = new cmCursesBoolWidget(this->EntryWidth, 1, 1, 1);
if (cmSystemTools::IsOn(value))
{
@@ -66,17 +65,17 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
static_cast<cmCursesBoolWidget*>(this->Entry)->SetValueAsBool(false);
}
break;
- case cmConfiguration::PATH:
+ case cmCacheManager::PATH:
this->Entry = new cmCursesPathWidget(this->EntryWidth, 1, 1, 1);
static_cast<cmCursesPathWidget*>(this->Entry)->SetString(value);
break;
- case cmConfiguration::FILEPATH:
+ case cmCacheManager::FILEPATH:
this->Entry = new cmCursesFilePathWidget(this->EntryWidth, 1, 1, 1);
static_cast<cmCursesFilePathWidget*>(this->Entry)->SetString(value);
break;
- case cmConfiguration::STRING:
+ case cmCacheManager::STRING:
{
- const char* stringsProp = cm->GetConfiguration()
+ const char* stringsProp = cm->GetCacheManager()
->GetCacheEntryProperty(key, "STRINGS");
if(stringsProp)
{
@@ -99,7 +98,7 @@ cmCursesCacheEntryComposite::cmCursesCacheEntryComposite(
}
break;
}
- case cmConfiguration::UNINITIALIZED:
+ case cmCacheManager::UNINITIALIZED:
cmSystemTools::Error("Found an undefined variable: ",
key.c_str());
break;
diff --git a/Source/CursesDialog/cmCursesCacheEntryComposite.h b/Source/CursesDialog/cmCursesCacheEntryComposite.h
index f280897..dc4ee4af 100644
--- a/Source/CursesDialog/cmCursesCacheEntryComposite.h
+++ b/Source/CursesDialog/cmCursesCacheEntryComposite.h
@@ -12,6 +12,7 @@
#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 0c5c09d..60086a5 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 = cmConfiguration::INTERNAL;
+ this->Type = cmCacheManager::INTERNAL;
}
diff --git a/Source/CursesDialog/cmCursesFilePathWidget.cxx b/Source/CursesDialog/cmCursesFilePathWidget.cxx
index fb04b44..01db014 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 = cmConfiguration::FILEPATH;
+ this->Type = cmCacheManager::FILEPATH;
}
diff --git a/Source/CursesDialog/cmCursesLongMessageForm.cxx b/Source/CursesDialog/cmCursesLongMessageForm.cxx
index 67e4aab..057f8f3 100644
--- a/Source/CursesDialog/cmCursesLongMessageForm.cxx
+++ b/Source/CursesDialog/cmCursesLongMessageForm.cxx
@@ -9,6 +9,7 @@
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 f97ea36..833d540 100644
--- a/Source/CursesDialog/cmCursesMainForm.cxx
+++ b/Source/CursesDialog/cmCursesMainForm.cxx
@@ -9,6 +9,7 @@
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"
@@ -22,7 +23,6 @@
#include "cmCursesCacheEntryComposite.h"
#include "cmCursesLongMessageForm.h"
#include "cmAlgorithms.h"
-#include "cmConfiguration.h"
inline int ctrl(int z)
@@ -107,21 +107,21 @@ void cmCursesMainForm::InitializeUI()
// which contain labels, entries and new entry markers
std::vector<cmCursesCacheEntryComposite*>* newEntries =
new std::vector<cmCursesCacheEntryComposite*>;
- std::vector<std::string> cacheKeys =
- this->CMakeInstance->GetConfiguration()->GetCacheEntryKeys();
- newEntries->reserve(cacheKeys.size());
+ newEntries->reserve(this->CMakeInstance->GetCacheManager()->GetSize());
// 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)
{
- cmConfiguration::CacheEntryType t = this->CMakeInstance->GetConfiguration()
+ cmCacheManager::CacheEntryType t = this->CMakeInstance->GetCacheManager()
->GetCacheEntryType(*it);
- if (t != cmConfiguration::INTERNAL &&
- t != cmConfiguration::STATIC &&
- t != cmConfiguration::UNINITIALIZED)
+ if (t != cmCacheManager::INTERNAL &&
+ t != cmCacheManager::STATIC &&
+ t != cmCacheManager::UNINITIALIZED)
{
++count;
}
@@ -147,11 +147,11 @@ void cmCursesMainForm::InitializeUI()
it != cacheKeys.end(); ++it)
{
std::string key = *it;
- cmConfiguration::CacheEntryType t = this->CMakeInstance->GetConfiguration()
+ cmCacheManager::CacheEntryType t = this->CMakeInstance->GetCacheManager()
->GetCacheEntryType(*it);
- if (t == cmConfiguration::INTERNAL ||
- t == cmConfiguration::STATIC ||
- t == cmConfiguration::UNINITIALIZED )
+ if (t == cmCacheManager::INTERNAL ||
+ t == cmCacheManager::STATIC ||
+ t == cmCacheManager::UNINITIALIZED )
{
continue;
}
@@ -171,11 +171,11 @@ void cmCursesMainForm::InitializeUI()
it != cacheKeys.end(); ++it)
{
std::string key = *it;
- cmConfiguration::CacheEntryType t = this->CMakeInstance->GetConfiguration()
+ cmCacheManager::CacheEntryType t = this->CMakeInstance->GetCacheManager()
->GetCacheEntryType(*it);
- if (t == cmConfiguration::INTERNAL ||
- t == cmConfiguration::STATIC ||
- t == cmConfiguration::UNINITIALIZED )
+ if (t == cmCacheManager::INTERNAL ||
+ t == cmCacheManager::STATIC ||
+ t == cmCacheManager::UNINITIALIZED )
{
continue;
}
@@ -225,10 +225,10 @@ void cmCursesMainForm::RePost()
for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
{
const char* existingValue =
- this->CMakeInstance->GetConfiguration()
+ this->CMakeInstance->GetCacheManager()
->GetCacheEntryValue((*it)->GetValue());
bool advanced =
- this->CMakeInstance->GetConfiguration()
+ this->CMakeInstance->GetCacheManager()
->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
if (!existingValue || (!this->AdvancedMode && advanced))
{
@@ -257,10 +257,10 @@ void cmCursesMainForm::RePost()
for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
{
const char* existingValue =
- this->CMakeInstance->GetConfiguration()
+ this->CMakeInstance->GetCacheManager()
->GetCacheEntryValue((*it)->GetValue());
bool advanced =
- this->CMakeInstance->GetConfiguration()
+ this->CMakeInstance->GetCacheManager()
->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
if (!existingValue || (!this->AdvancedMode && advanced))
{
@@ -293,9 +293,9 @@ void cmCursesMainForm::Render(int left, int top, int width, int height)
cmCursesWidget* cw = reinterpret_cast<cmCursesWidget*>
(field_userptr(currentField));
// If in edit mode, get out of it
- if ( cw->GetType() == cmConfiguration::STRING ||
- cw->GetType() == cmConfiguration::PATH ||
- cw->GetType() == cmConfiguration::FILEPATH )
+ if ( cw->GetType() == cmCacheManager::STRING ||
+ cw->GetType() == cmCacheManager::PATH ||
+ cw->GetType() == cmCacheManager::FILEPATH )
{
cmCursesStringWidget* sw = static_cast<cmCursesStringWidget*>(cw);
sw->SetInEdit(false);
@@ -329,10 +329,10 @@ void cmCursesMainForm::Render(int left, int top, int width, int height)
for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
{
const char* existingValue =
- this->CMakeInstance->GetConfiguration()
+ this->CMakeInstance->GetCacheManager()
->GetCacheEntryValue((*it)->GetValue());
bool advanced =
- this->CMakeInstance->GetConfiguration()
+ this->CMakeInstance->GetCacheManager()
->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
if (!existingValue || (!this->AdvancedMode && advanced))
{
@@ -352,10 +352,10 @@ void cmCursesMainForm::Render(int left, int top, int width, int height)
for (it = this->Entries->begin(); it != this->Entries->end(); ++it)
{
const char* existingValue =
- this->CMakeInstance->GetConfiguration()
+ this->CMakeInstance->GetCacheManager()
->GetCacheEntryValue((*it)->GetValue());
bool advanced =
- this->CMakeInstance->GetConfiguration()
+ this->CMakeInstance->GetCacheManager()
->GetCacheEntryPropertyAsBool((*it)->GetValue(), "ADVANCED");
if (!existingValue || (!this->AdvancedMode && advanced))
{
@@ -516,10 +516,10 @@ void cmCursesMainForm::UpdateStatusBar(const char* message)
// Get the help string of the current entry
// and add it to the help string
const char* existingValue =
- this->CMakeInstance->GetConfiguration()->GetCacheEntryValue(curField);
+ this->CMakeInstance->GetCacheManager()->GetCacheEntryValue(curField);
if (existingValue)
{
- const char* hs = this->CMakeInstance->GetConfiguration()
+ const char* hs = this->CMakeInstance->GetCacheManager()
->GetCacheEntryProperty(curField, "HELPSTRING");
if ( hs )
{
@@ -814,7 +814,7 @@ void cmCursesMainForm::FillCacheManagerFromUI()
for(size_t i=0; i < size; i++)
{
std::string cacheKey = (*this->Entries)[i]->Key;
- const char* existingValue = this->CMakeInstance->GetConfiguration()
+ const char* existingValue = this->CMakeInstance->GetCacheManager()
->GetCacheEntryValue(cacheKey);
if (existingValue)
{
@@ -822,8 +822,8 @@ void cmCursesMainForm::FillCacheManagerFromUI()
std::string newValue = (*this->Entries)[i]->Entry->GetValue();
std::string fixedOldValue;
std::string fixedNewValue;
- cmConfiguration::CacheEntryType t =
- this->CMakeInstance->GetConfiguration()
+ cmCacheManager::CacheEntryType t =
+ this->CMakeInstance->GetCacheManager()
->GetCacheEntryType(cacheKey);
this->FixValue(t, oldValue, fixedOldValue);
this->FixValue(t, newValue, fixedNewValue);
@@ -831,24 +831,24 @@ void cmCursesMainForm::FillCacheManagerFromUI()
if(!(fixedOldValue == fixedNewValue))
{
// The user has changed the value. Mark it as modified.
- this->CMakeInstance->GetConfiguration()
+ this->CMakeInstance->GetCacheManager()
->SetCacheEntryBoolProperty(cacheKey, "MODIFIED", true);
- this->CMakeInstance->GetConfiguration()
+ this->CMakeInstance->GetCacheManager()
->SetCacheEntryValue(cacheKey, fixedNewValue);
}
}
}
}
-void cmCursesMainForm::FixValue(cmConfiguration::CacheEntryType type,
+void cmCursesMainForm::FixValue(cmCacheManager::CacheEntryType type,
const std::string& in, std::string& out) const
{
out = in.substr(0,in.find_last_not_of(" ")+1);
- if(type == cmConfiguration::PATH || type == cmConfiguration::FILEPATH)
+ if(type == cmCacheManager::PATH || type == cmCacheManager::FILEPATH)
{
cmSystemTools::ConvertToUnixSlashes(out);
}
- if(type == cmConfiguration::BOOL)
+ if(type == cmCacheManager::BOOL)
{
if(cmSystemTools::IsOff(out.c_str()))
{
@@ -1046,11 +1046,11 @@ void cmCursesMainForm::HandleInput()
const char* helpString = 0;
const char* existingValue =
- this->CMakeInstance->GetConfiguration()
+ this->CMakeInstance->GetCacheManager()
->GetCacheEntryValue(curField);
if (existingValue)
{
- helpString = this->CMakeInstance->GetConfiguration()
+ helpString = this->CMakeInstance->GetCacheManager()
->GetCacheEntryProperty(curField, "HELPSTRING");
}
if (helpString)
@@ -1161,7 +1161,7 @@ void cmCursesMainForm::HandleInput()
field_userptr(this->Fields[findex-2]));
if ( lbl )
{
- this->CMakeInstance->GetConfiguration()->RemoveCacheEntry(lbl->GetValue());
+ this->CMakeInstance->GetCacheManager()->RemoveCacheEntry(lbl->GetValue());
std::string nextVal;
if (nextCur)
diff --git a/Source/CursesDialog/cmCursesMainForm.h b/Source/CursesDialog/cmCursesMainForm.h
index d410a26..6455252 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(cmConfiguration::CacheEntryType type,
+ void FixValue(cmCacheManager::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 83b8b79..2f4b59e 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 = cmConfiguration::BOOL; // this is a bit of a hack
+ this->Type = cmCacheManager::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 c1d1c7c..89e2238 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 = cmConfiguration::PATH;
+ this->Type = cmCacheManager::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 == cmConfiguration::PATH?-1:0));
+ cmSystemTools::SimpleGlob(glob, dirs, (this->Type == cmCacheManager::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 ce7df27..d25022d 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 = cmConfiguration::STRING;
+ this->Type = cmCacheManager::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 67b6876..7d82864 100644
--- a/Source/CursesDialog/cmCursesWidget.h
+++ b/Source/CursesDialog/cmCursesWidget.h
@@ -12,7 +12,7 @@
#ifndef cmCursesWidget_h
#define cmCursesWidget_h
-#include "../cmConfiguration.h"
+#include "../cmCacheManager.h"
#include "cmCursesStandardIncludes.h"
class cmCursesMainForm;
@@ -46,7 +46,7 @@ public:
/**
* Get the type of the widget (STRING, PATH etc...)
*/
- cmConfiguration::CacheEntryType GetType()
+ cmCacheManager::CacheEntryType GetType()
{ return this->Type; }
/**
@@ -77,7 +77,7 @@ protected:
cmCursesWidget(const cmCursesWidget& from);
void operator=(const cmCursesWidget&);
- cmConfiguration::CacheEntryType Type;
+ cmCacheManager::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 97e68e8..08d53ce 100644
--- a/Source/QtDialog/QCMake.cxx
+++ b/Source/QtDialog/QCMake.cxx
@@ -16,7 +16,7 @@
#include <QCoreApplication>
#include "cmake.h"
-#include "cmConfiguration.h"
+#include "cmCacheManager.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);
- cmConfiguration *config = this->CMakeInstance->GetConfiguration();
+ cmCacheManager *cachem = this->CMakeInstance->GetCacheManager();
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 = config->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
+ const char* homeDir = cachem->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
if (homeDir)
{
setSourceDirectory(QString::fromLocal8Bit(homeDir));
}
- const char* gen = config->GetCacheEntryValue("CMAKE_GENERATOR");
+ const char* gen = cachem->GetCacheEntryValue("CMAKE_GENERATOR");
if (gen)
{
- const char* extraGen = config
+ const char* extraGen = cachem
->GetInitializedCacheValue("CMAKE_EXTRA_GENERATOR");
std::string curGen = cmExternalMakefileProjectGenerator::
CreateFullGeneratorName(gen, extraGen? extraGen : "");
@@ -195,14 +195,14 @@ void QCMake::setProperties(const QCMakePropertyList& newProps)
QStringList toremove;
// set the value of properties
- cmConfiguration *config = this->CMakeInstance->GetConfiguration();
- std::vector<std::string> cacheKeys = config->GetCacheEntryKeys();
+ cmCacheManager *cachem = this->CMakeInstance->GetCacheManager();
+ std::vector<std::string> cacheKeys = cachem->GetCacheEntryKeys();
for(std::vector<std::string>::const_iterator it = cacheKeys.begin();
it != cacheKeys.end(); ++it)
{
- cmConfiguration::CacheEntryType t = config->GetCacheEntryType(*it);
- if(t == cmConfiguration::INTERNAL ||
- t == cmConfiguration::STATIC)
+ cmCacheManager::CacheEntryType t = cachem->GetCacheEntryType(*it);
+ if(t == cmCacheManager::INTERNAL ||
+ t == cmCacheManager::STATIC)
{
continue;
}
@@ -219,11 +219,11 @@ void QCMake::setProperties(const QCMakePropertyList& newProps)
prop = props[idx];
if(prop.Value.type() == QVariant::Bool)
{
- config->SetCacheEntryValue(*it, prop.Value.toBool() ? "ON" : "OFF");
+ cachem->SetCacheEntryValue(*it, prop.Value.toBool() ? "ON" : "OFF");
}
else
{
- config->SetCacheEntryValue(*it,
+ cachem->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());
- config->RemoveCacheEntry(s.toLocal8Bit().data());
+ cachem->RemoveCacheEntry(s.toLocal8Bit().data());
}
// add some new properites
@@ -249,28 +249,28 @@ void QCMake::setProperties(const QCMakePropertyList& newProps)
this->CMakeInstance->AddCacheEntry(s.Key.toLocal8Bit().data(),
s.Value.toBool() ? "ON" : "OFF",
s.Help.toLocal8Bit().data(),
- cmConfiguration::BOOL);
+ cmCacheManager::BOOL);
}
else if(s.Type == QCMakeProperty::STRING)
{
this->CMakeInstance->AddCacheEntry(s.Key.toLocal8Bit().data(),
s.Value.toString().toLocal8Bit().data(),
s.Help.toLocal8Bit().data(),
- cmConfiguration::STRING);
+ cmCacheManager::STRING);
}
else if(s.Type == QCMakeProperty::PATH)
{
this->CMakeInstance->AddCacheEntry(s.Key.toLocal8Bit().data(),
s.Value.toString().toLocal8Bit().data(),
s.Help.toLocal8Bit().data(),
- cmConfiguration::PATH);
+ cmCacheManager::PATH);
}
else if(s.Type == QCMakeProperty::FILEPATH)
{
this->CMakeInstance->AddCacheEntry(s.Key.toLocal8Bit().data(),
s.Value.toString().toLocal8Bit().data(),
s.Help.toLocal8Bit().data(),
- cmConfiguration::FILEPATH);
+ cmCacheManager::FILEPATH);
}
}
@@ -281,45 +281,45 @@ QCMakePropertyList QCMake::properties() const
{
QCMakePropertyList ret;
- cmConfiguration *config = this->CMakeInstance->GetConfiguration();
- std::vector<std::string> cacheKeys = config->GetCacheEntryKeys();
+ cmCacheManager *cachem = this->CMakeInstance->GetCacheManager();
+ std::vector<std::string> cacheKeys = cachem->GetCacheEntryKeys();
for (std::vector<std::string>::const_iterator i = cacheKeys.begin();
i != cacheKeys.end(); ++i)
{
- cmConfiguration::CacheEntryType t = config->GetCacheEntryType(*i);
- if(t == cmConfiguration::INTERNAL ||
- t == cmConfiguration::STATIC ||
- t == cmConfiguration::UNINITIALIZED)
+ cmCacheManager::CacheEntryType t = cachem->GetCacheEntryType(*i);
+ if(t == cmCacheManager::INTERNAL ||
+ t == cmCacheManager::STATIC ||
+ t == cmCacheManager::UNINITIALIZED)
{
continue;
}
- const char* cachedValue = config->GetCacheEntryValue(*i);
+ const char* cachedValue = cachem->GetCacheEntryValue(*i);
QCMakeProperty prop;
prop.Key = QString::fromLocal8Bit(i->c_str());
prop.Help = QString::fromLocal8Bit(
- config->GetCacheEntryProperty(*i, "HELPSTRING"));
+ cachem->GetCacheEntryProperty(*i, "HELPSTRING"));
prop.Value = QString::fromLocal8Bit(cachedValue);
- prop.Advanced = config->GetCacheEntryPropertyAsBool(*i, "ADVANCED");
- if(t == cmConfiguration::BOOL)
+ prop.Advanced = cachem->GetCacheEntryPropertyAsBool(*i, "ADVANCED");
+ if(t == cmCacheManager::BOOL)
{
prop.Type = QCMakeProperty::BOOL;
prop.Value = cmSystemTools::IsOn(cachedValue);
}
- else if(t == cmConfiguration::PATH)
+ else if(t == cmCacheManager::PATH)
{
prop.Type = QCMakeProperty::PATH;
}
- else if(t == cmConfiguration::FILEPATH)
+ else if(t == cmCacheManager::FILEPATH)
{
prop.Type = QCMakeProperty::FILEPATH;
}
- else if(t == cmConfiguration::STRING)
+ else if(t == cmCacheManager::STRING)
{
prop.Type = QCMakeProperty::STRING;
const char* stringsProperty =
- config->GetCacheEntryProperty(*i, "STRINGS");
+ cachem->GetCacheEntryProperty(*i, "STRINGS");
if (stringsProperty)
{
prop.Strings = QString::fromLocal8Bit(stringsProperty).split(";");
diff --git a/Source/cmBuildCommand.cxx b/Source/cmBuildCommand.cxx
index c83c41f..5d32437 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.",
- cmConfiguration::STRING);
+ cmCacheManager::STRING);
return true;
}
diff --git a/Source/cmBuildNameCommand.cxx b/Source/cmBuildNameCommand.cxx
index 257d62e..171ed0f 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.",
- cmConfiguration::STRING);
+ cmCacheManager::STRING);
}
return true;
}
@@ -74,7 +74,7 @@ bool cmBuildNameCommand
this->Makefile->AddCacheDefinition(args[0],
buildname.c_str(),
"Name of build.",
- cmConfiguration::STRING);
+ cmCacheManager::STRING);
return true;
}
diff --git a/Source/cmCPluginAPI.cxx b/Source/cmCPluginAPI.cxx
index d27d4f5..987a7b1 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,
- cmConfiguration::BOOL);
+ cmCacheManager::BOOL);
break;
case CM_CACHE_PATH:
mf->AddCacheDefinition(name,value,doc,
- cmConfiguration::PATH);
+ cmCacheManager::PATH);
break;
case CM_CACHE_FILEPATH:
mf->AddCacheDefinition(name,value,doc,
- cmConfiguration::FILEPATH);
+ cmCacheManager::FILEPATH);
break;
case CM_CACHE_STRING:
mf->AddCacheDefinition(name,value,doc,
- cmConfiguration::STRING);
+ cmCacheManager::STRING);
break;
case CM_CACHE_INTERNAL:
mf->AddCacheDefinition(name,value,doc,
- cmConfiguration::INTERNAL);
+ cmCacheManager::INTERNAL);
break;
case CM_CACHE_STATIC:
mf->AddCacheDefinition(name,value,doc,
- cmConfiguration::STATIC);
+ cmCacheManager::STATIC);
break;
}
}
diff --git a/Source/cmCTest.cxx b/Source/cmCTest.cxx
index 364f767..1db057b 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;
- cmConfiguration::CacheEntryType type = cmConfiguration::UNINITIALIZED;
+ cmCacheManager::CacheEntryType type = cmCacheManager::UNINITIALIZED;
if (cmake::ParseCacheEntry(arg, name, value, type))
{
diff --git a/Source/cmCacheManager.cxx b/Source/cmCacheManager.cxx
index 4734562..f8f2dbd 100644
--- a/Source/cmCacheManager.cxx
+++ b/Source/cmCacheManager.cxx
@@ -23,6 +23,17 @@
#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;
@@ -30,6 +41,41 @@ 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;
@@ -77,7 +123,7 @@ static bool ParseEntryWithoutType(const std::string& entry,
bool cmCacheManager::ParseEntry(const std::string& entry,
std::string& var,
std::string& value,
- cmConfiguration::CacheEntryType& type)
+ CacheEntryType& type)
{
// input line is: key:type=value
static cmsys::RegularExpression reg(
@@ -89,14 +135,14 @@ bool cmCacheManager::ParseEntry(const std::string& entry,
if(regQuoted.find(entry))
{
var = regQuoted.match(1);
- type = cmConfiguration::StringToCacheEntryType(regQuoted.match(2).c_str());
+ type = cmCacheManager::StringToType(regQuoted.match(2).c_str());
value = regQuoted.match(3);
flag = true;
}
else if (reg.find(entry))
{
var = reg.match(1);
- type = cmConfiguration::StringToCacheEntryType(reg.match(2).c_str());
+ type = cmCacheManager::StringToType(reg.match(2).c_str());
value = reg.match(3);
flag = true;
}
@@ -205,7 +251,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 != cmConfiguration::INTERNAL) ||
+ if ( internal || (e.Type != INTERNAL) ||
(includes.find(entryKey) != includes.end()) )
{
// If we are loading the cache from another project,
@@ -213,7 +259,7 @@ bool cmCacheManager::LoadCache(const std::string& path,
// not visible in the gui
if (!internal)
{
- e.Type = cmConfiguration::INTERNAL;
+ e.Type = INTERNAL;
helpString = "DO NOT EDIT, ";
helpString += entryKey;
helpString += " loaded from external file. "
@@ -261,10 +307,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", cmConfiguration::INTERNAL);
+ "current loaded cache", cmCacheManager::INTERNAL);
this->AddCacheEntry("CMAKE_CACHE_MAJOR_VERSION", "0",
"Major version of cmake used to create the "
- "current loaded cache", cmConfiguration::INTERNAL);
+ "current loaded cache", cmCacheManager::INTERNAL);
}
// check to make sure the cache directory has not
@@ -306,7 +352,7 @@ bool cmCacheManager::ReadPropertyEntry(std::string const& entryKey,
CacheEntry& e)
{
// All property entries are internal.
- if(e.Type != cmConfiguration::INTERNAL)
+ if(e.Type != cmCacheManager::INTERNAL)
{
return false;
}
@@ -325,7 +371,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 = cmConfiguration::UNINITIALIZED;
+ ne.Type = cmCacheManager::UNINITIALIZED;
ne.SetProperty(*p, e.Value.c_str());
}
else
@@ -382,15 +428,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", cmConfiguration::INTERNAL);
+ "current loaded cache", cmCacheManager::INTERNAL);
sprintf(temp, "%d", cmVersion::GetMajorVersion());
this->AddCacheEntry("CMAKE_CACHE_MAJOR_VERSION", temp,
"Major version of cmake used to create the "
- "current loaded cache", cmConfiguration::INTERNAL);
+ "current loaded cache", cmCacheManager::INTERNAL);
sprintf(temp, "%d", cmVersion::GetPatchVersion());
this->AddCacheEntry("CMAKE_CACHE_PATCH_VERSION", temp,
"Patch version of cmake used to create the "
- "current loaded cache", cmConfiguration::INTERNAL);
+ "current loaded cache", cmCacheManager::INTERNAL);
// Let us store the current working directory so that if somebody
// Copies it, he will not be surprised
@@ -405,7 +451,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", cmConfiguration::INTERNAL);
+ " was created", cmCacheManager::INTERNAL);
fout << "# This is the CMakeCache file.\n"
<< "# For build in directory: " << currentcwd << "\n";
@@ -439,7 +485,7 @@ bool cmCacheManager::SaveCache(const std::string& path)
this->Cache.begin(); i != this->Cache.end(); ++i)
{
const CacheEntry& ce = (*i).second;
- cmConfiguration::CacheEntryType t = ce.Type;
+ CacheEntryType t = ce.Type;
if(!ce.Initialized)
{
/*
@@ -448,7 +494,7 @@ bool cmCacheManager::SaveCache(const std::string& path)
"\" is uninitialized");
*/
}
- else if(t != cmConfiguration::INTERNAL)
+ else if(t != INTERNAL)
{
// Format is key:type=value
if(const char* help = ce.GetProperty("HELPSTRING"))
@@ -460,7 +506,7 @@ bool cmCacheManager::SaveCache(const std::string& path)
cmCacheManager::OutputHelpString(fout, "Missing description");
}
this->OutputKey(fout, i->first);
- fout << ":" << cmConfiguration::CacheEntryTypeToString(t) << "=";
+ fout << ":" << cmCacheManagerTypes[t] << "=";
this->OutputValue(fout, ce.Value);
fout << "\n\n";
}
@@ -480,9 +526,9 @@ bool cmCacheManager::SaveCache(const std::string& path)
continue;
}
- cmConfiguration::CacheEntryType t = i.GetType();
+ CacheEntryType t = i.GetType();
this->WritePropertyEntries(fout, i);
- if(t == cmConfiguration::INTERNAL)
+ if(t == cmCacheManager::INTERNAL)
{
// Format is key:type=value
if(const char* help = i.GetProperty("HELPSTRING"))
@@ -490,7 +536,7 @@ bool cmCacheManager::SaveCache(const std::string& path)
this->OutputHelpString(fout, help);
}
this->OutputKey(fout, i.GetName());
- fout << ":" << cmConfiguration::CacheEntryTypeToString(t) << "=";
+ fout << ":" << cmCacheManagerTypes[t] << "=";
this->OutputValue(fout, i.GetValue());
fout << "\n";
}
@@ -632,7 +678,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 != cmConfiguration::INTERNAL)
+ if((*i).second.Type != INTERNAL)
{
out << (*i).first << " = " << (*i).second.Value
<< std::endl;
@@ -648,7 +694,7 @@ void cmCacheManager::PrintCache(std::ostream& out) const
void cmCacheManager::AddCacheEntry(const std::string& key,
const char* value,
const char* helpString,
- cmConfiguration::CacheEntryType type)
+ CacheEntryType type)
{
CacheEntry& e = this->Cache[key];
e.Properties.SetCMakeInstance(this->CMakeInstance);
@@ -663,7 +709,7 @@ void cmCacheManager::AddCacheEntry(const std::string& key,
}
e.Type = type;
// make sure we only use unix style paths
- if(type == cmConfiguration::FILEPATH || type == cmConfiguration::PATH)
+ if(type == FILEPATH || type == PATH)
{
if(e.Value.find(';') != e.Value.npos)
{
@@ -744,7 +790,7 @@ cmCacheManager::CacheEntry::GetProperty(const std::string& prop) const
{
if(prop == "TYPE")
{
- return cmConfiguration::CacheEntryTypeToString(this->Type);
+ return cmCacheManagerTypes[this->Type];
}
else if(prop == "VALUE")
{
@@ -761,7 +807,7 @@ void cmCacheManager::CacheEntry::SetProperty(const std::string& prop,
{
if(prop == "TYPE")
{
- this->Type = cmConfiguration::StringToCacheEntryType(value? value : "STRING");
+ this->Type = cmCacheManager::StringToType(value? value : "STRING");
}
else if(prop == "VALUE")
{
@@ -780,7 +826,7 @@ void cmCacheManager::CacheEntry::AppendProperty(const std::string& prop,
{
if(prop == "TYPE")
{
- this->Type = cmConfiguration::StringToCacheEntryType(value? value : "STRING");
+ this->Type = cmCacheManager::StringToType(value? value : "STRING");
}
else if(prop == "VALUE")
{
diff --git a/Source/cmCacheManager.h b/Source/cmCacheManager.h
index 927651f..2d3f6e5 100644
--- a/Source/cmCacheManager.h
+++ b/Source/cmCacheManager.h
@@ -14,8 +14,6 @@
#include "cmStandardIncludes.h"
#include "cmPropertyMap.h"
-#include "cmConfiguration.h"
-
class cmMakefile;
class cmMarkAsAdvancedCommand;
class cmake;
@@ -32,22 +30,21 @@ 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;
- cmConfiguration::CacheEntryType Type;
+ 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(cmConfiguration::UNINITIALIZED),
- Initialized(false)
+ CacheEntry() : Value(""), Type(UNINITIALIZED), Initialized(false)
{}
};
@@ -71,10 +68,8 @@ public:
std::string GetValue() const { return this->GetEntry().Value; }
bool GetValueAsBool() const;
void SetValue(const char*);
- cmConfiguration::CacheEntryType GetType() const
- { return this->GetEntry().Type; }
- void SetType(cmConfiguration::CacheEntryType ty)
- { this->GetEntry().Type = ty; }
+ CacheEntryType GetType() const { return this->GetEntry().Type; }
+ void SetType(CacheEntryType ty) { this->GetEntry().Type = ty; }
bool Initialized() { return this->GetEntry().Initialized; }
cmCacheManager &Container;
std::map<std::string, CacheEntry>::iterator Position;
@@ -99,6 +94,17 @@ 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,
@@ -128,7 +134,7 @@ public:
static bool ParseEntry(const std::string& entry,
std::string& var,
std::string& value,
- cmConfiguration::CacheEntryType& type);
+ CacheEntryType& type);
///! Get a value from the cache given a key
const char* GetInitializedCacheValue(const std::string& key) const;
@@ -149,7 +155,7 @@ public:
return this->GetCacheIterator(key.c_str()).GetProperty(propName);
}
- cmConfiguration::CacheEntryType GetCacheEntryType(std::string const& key)
+ CacheEntryType GetCacheEntryType(std::string const& key)
{
return this->GetCacheIterator(key.c_str()).GetType();
}
@@ -217,8 +223,7 @@ public:
protected:
///! Add an entry into the cache
void AddCacheEntry(const std::string& key, const char* value,
- const char* helpString,
- cmConfiguration::CacheEntryType type);
+ const char* helpString, CacheEntryType type);
///! Get a cache entry object for a key
CacheEntry *GetCacheEntry(const std::string& key);
@@ -244,7 +249,6 @@ 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/cmCommandArgumentParserHelper.cxx b/Source/cmCommandArgumentParserHelper.cxx
index 0e4dd4b..99bf5f5 100644
--- a/Source/cmCommandArgumentParserHelper.cxx
+++ b/Source/cmCommandArgumentParserHelper.cxx
@@ -13,7 +13,6 @@
#include "cmSystemTools.h"
#include "cmMakefile.h"
-#include "cmConfiguration.h"
#include "cmCommandArgumentLexer.h"
@@ -91,7 +90,7 @@ char* cmCommandArgumentParserHelper::ExpandSpecialVariable(const char* key,
}
if ( strcmp(key, "CACHE") == 0 )
{
- if(const char* c = this->Makefile->GetConfiguration()
+ if(const char* c = this->Makefile->GetCacheManager()
->GetInitializedCacheValue(var))
{
if(this->EscapeQuotes)
diff --git a/Source/cmConfiguration.cxx b/Source/cmConfiguration.cxx
deleted file mode 100644
index 209cdd9..0000000
--- a/Source/cmConfiguration.cxx
+++ /dev/null
@@ -1,170 +0,0 @@
-
-#include "cmConfiguration.h"
-
-#include "cmake.h"
-#include "cmCacheManager.h"
-
-cmConfiguration::cmConfiguration(cmake* cm)
- : CMakeInstance(cm)
-{
-}
-
-const char* cmCacheEntryTypes[] =
-{ "BOOL",
- "PATH",
- "FILEPATH",
- "STRING",
- "INTERNAL",
- "STATIC",
- "UNINITIALIZED",
- 0
-};
-
-const char*
-cmConfiguration::CacheEntryTypeToString(cmConfiguration::CacheEntryType type)
-{
- if ( type > 6 )
- {
- return cmCacheEntryTypes[6];
- }
- return cmCacheEntryTypes[type];
-}
-
-cmConfiguration::CacheEntryType
-cmConfiguration::StringToCacheEntryType(const char* s)
-{
- 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)
-{
- 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
-{
- 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);
-}
-
-cmConfiguration::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,
- cmConfiguration::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
deleted file mode 100644
index 72149fb..0000000
--- a/Source/cmConfiguration.h
+++ /dev/null
@@ -1,52 +0,0 @@
-
-#ifndef cmConfiguration_h
-#define cmConfiguration_h
-
-#include "cmStandardIncludes.h"
-
-class cmake;
-
-class cmConfiguration
-{
-public:
- cmConfiguration(cmake* cm);
-
- enum CacheEntryType{ BOOL=0, PATH, FILEPATH, STRING, INTERNAL,STATIC,
- UNINITIALIZED };
- static CacheEntryType StringToCacheEntryType(const char*);
- static const char* CacheEntryTypeToString(CacheEntryType);
- static bool IsCacheEntryType(std::string const& key);
-
- std::vector<std::string> GetCacheEntryKeys() const;
- const char* GetCacheEntryValue(std::string const& key) const;
- const char* GetInitializedCacheValue(std::string const& key) const;
- CacheEntryType GetCacheEntryType(std::string const& key) const;
- void SetCacheEntryValue(std::string const& key, std::string const& value);
- void SetCacheValue(std::string const& key, std::string const& value);
-
- void AddCacheEntry(const std::string& key, const char* value,
- const char* helpString, CacheEntryType type);
- void RemoveCacheEntry(std::string const& key);
-
- void SetCacheEntryProperty(std::string const& key,
- std::string const& propertyName,
- std::string const& value);
- void SetCacheEntryBoolProperty(std::string const& key,
- std::string const& propertyName,
- bool value);
- const char* GetCacheEntryProperty(std::string const& key,
- std::string const& propertyName);
- bool GetCacheEntryPropertyAsBool(std::string const& key,
- std::string const& propertyName);
- void AppendCacheEntryProperty(std::string const& key,
- const std::string& property,
- const std::string& value,
- bool asString = false);
- void RemoveCacheEntryProperty(std::string const& key,
- std::string const& propertyName);
-
-private:
- cmake* CMakeInstance;
-};
-
-#endif
diff --git a/Source/cmCoreTryCompile.cxx b/Source/cmCoreTryCompile.cxx
index 7217ce6..59efa52 100644
--- a/Source/cmCoreTryCompile.cxx
+++ b/Source/cmCoreTryCompile.cxx
@@ -11,6 +11,7 @@
============================================================================*/
#include "cmCoreTryCompile.h"
#include "cmake.h"
+#include "cmCacheManager.h"
#include "cmLocalGenerator.h"
#include "cmGlobalGenerator.h"
#include "cmAlgorithms.h"
@@ -526,7 +527,7 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv)
this->Makefile->AddCacheDefinition(argv[0],
(res == 0 ? "TRUE" : "FALSE"),
"Result of TRY_COMPILE",
- cmConfiguration::INTERNAL);
+ cmCacheManager::INTERNAL);
if (!outputVariable.empty())
{
diff --git a/Source/cmExtraEclipseCDT4Generator.cxx b/Source/cmExtraEclipseCDT4Generator.cxx
index 63de734..0d32e4b 100644
--- a/Source/cmExtraEclipseCDT4Generator.cxx
+++ b/Source/cmExtraEclipseCDT4Generator.cxx
@@ -16,7 +16,6 @@
#include "cmLocalUnixMakefileGenerator3.h"
#include "cmMakefile.h"
#include "cmGeneratedFileStream.h"
-#include "cmConfiguration.h"
#include "cmTarget.h"
#include "cmSourceFile.h"
@@ -206,7 +205,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout,
std::string cacheEntryName = "CMAKE_ECLIPSE_ENVVAR_";
cacheEntryName += envVar;
- const char* cacheValue = mf->GetConfiguration()->GetInitializedCacheValue(
+ const char* cacheValue = mf->GetCacheManager()->GetInitializedCacheValue(
cacheEntryName);
// now we have both, decide which one to use
@@ -222,7 +221,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout,
// in the cache
valueToUse = envVarValue;
mf->AddCacheDefinition(cacheEntryName, valueToUse.c_str(),
- cacheEntryName.c_str(), cmConfiguration::STRING,
+ cacheEntryName.c_str(), cmCacheManager::STRING,
true);
mf->GetCMakeInstance()->SaveCache(mf->GetHomeOutputDirectory());
}
@@ -243,7 +242,7 @@ void cmExtraEclipseCDT4Generator::AddEnvVar(cmGeneratedFileStream& fout,
{
valueToUse = envVarValue;
mf->AddCacheDefinition(cacheEntryName, valueToUse.c_str(),
- cacheEntryName.c_str(), cmConfiguration::STRING,
+ cacheEntryName.c_str(), cmCacheManager::STRING,
true);
mf->GetCMakeInstance()->SaveCache(mf->GetHomeOutputDirectory());
}
diff --git a/Source/cmFindBase.cxx b/Source/cmFindBase.cxx
index 7cc0cd2..cc08052 100644
--- a/Source/cmFindBase.cxx
+++ b/Source/cmFindBase.cxx
@@ -12,7 +12,6 @@
#include "cmFindBase.h"
#include "cmAlgorithms.h"
-#include "cmConfiguration.h"
cmFindBase::cmFindBase()
{
@@ -367,8 +366,8 @@ bool cmFindBase::CheckForVariableInCache()
if(const char* cacheValue =
this->Makefile->GetDefinition(this->VariableName))
{
- cmConfiguration* config = this->Makefile->GetConfiguration();
- const char* cacheEntry = config->GetCacheEntryValue(this->VariableName);
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
+ const char* cacheEntry = manager->GetCacheEntryValue(this->VariableName);
bool found = !cmSystemTools::IsNOTFOUND(cacheValue);
bool cached = cacheEntry ? true : false;
if(found)
@@ -377,8 +376,8 @@ bool cmFindBase::CheckForVariableInCache()
// type we should add the type and docstring but keep the
// original value. Tell the subclass implementations to do
// this.
- if(cached && config->GetCacheEntryType(this->VariableName)
- == cmConfiguration::UNINITIALIZED)
+ if(cached && manager->GetCacheEntryType(this->VariableName)
+ == cmCacheManager::UNINITIALIZED)
{
this->AlreadyInCacheWithoutMetaInfo = true;
}
@@ -386,7 +385,7 @@ bool cmFindBase::CheckForVariableInCache()
}
else if(cached)
{
- const char* hs = config->GetCacheEntryProperty(this->VariableName,
+ const char* hs = manager->GetCacheEntryProperty(this->VariableName,
"HELPSTRING");
this->VariableDocumentation = hs?hs:"(none)";
}
diff --git a/Source/cmFindLibraryCommand.cxx b/Source/cmFindLibraryCommand.cxx
index 649d00b..c499f61 100644
--- a/Source/cmFindLibraryCommand.cxx
+++ b/Source/cmFindLibraryCommand.cxx
@@ -10,6 +10,7 @@
See the License for more information.
============================================================================*/
#include "cmFindLibraryCommand.h"
+#include "cmCacheManager.h"
#include <cmsys/Directory.hxx>
#include <cmsys/stl/algorithm>
@@ -38,7 +39,7 @@ bool cmFindLibraryCommand
{
this->Makefile->AddCacheDefinition(this->VariableName, "",
this->VariableDocumentation.c_str(),
- cmConfiguration::FILEPATH);
+ cmCacheManager::FILEPATH);
}
return true;
}
@@ -71,14 +72,14 @@ bool cmFindLibraryCommand
this->Makefile->AddCacheDefinition(this->VariableName,
library.c_str(),
this->VariableDocumentation.c_str(),
- cmConfiguration::FILEPATH);
+ cmCacheManager::FILEPATH);
return true;
}
std::string notfound = this->VariableName + "-NOTFOUND";
this->Makefile->AddCacheDefinition(this->VariableName,
notfound.c_str(),
this->VariableDocumentation.c_str(),
- cmConfiguration::FILEPATH);
+ cmCacheManager::FILEPATH);
return true;
}
diff --git a/Source/cmFindPackageCommand.cxx b/Source/cmFindPackageCommand.cxx
index 6336ee4..4d7fd60 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(),
- cmConfiguration::PATH, true);
+ cmCacheManager::PATH, true);
return found;
}
diff --git a/Source/cmFindPathCommand.cxx b/Source/cmFindPathCommand.cxx
index 4317076..49fbf45 100644
--- a/Source/cmFindPathCommand.cxx
+++ b/Source/cmFindPathCommand.cxx
@@ -10,6 +10,7 @@
See the License for more information.
============================================================================*/
#include "cmFindPathCommand.h"
+#include "cmCacheManager.h"
#include <cmsys/Glob.hxx>
@@ -40,7 +41,7 @@ bool cmFindPathCommand
this->VariableName, "",
this->VariableDocumentation.c_str(),
(this->IncludeFileInPath ?
- cmConfiguration::FILEPATH :cmConfiguration::PATH)
+ cmCacheManager::FILEPATH :cmCacheManager::PATH)
);
}
return true;
@@ -53,7 +54,7 @@ bool cmFindPathCommand
(this->VariableName, result.c_str(),
this->VariableDocumentation.c_str(),
(this->IncludeFileInPath) ?
- cmConfiguration::FILEPATH :cmConfiguration::PATH);
+ cmCacheManager::FILEPATH :cmCacheManager::PATH);
return true;
}
this->Makefile->AddCacheDefinition
@@ -61,7 +62,7 @@ bool cmFindPathCommand
(this->VariableName + "-NOTFOUND").c_str(),
this->VariableDocumentation.c_str(),
(this->IncludeFileInPath) ?
- cmConfiguration::FILEPATH :cmConfiguration::PATH);
+ cmCacheManager::FILEPATH :cmCacheManager::PATH);
return true;
}
diff --git a/Source/cmFindProgramCommand.cxx b/Source/cmFindProgramCommand.cxx
index 75fe29b..4ee419c 100644
--- a/Source/cmFindProgramCommand.cxx
+++ b/Source/cmFindProgramCommand.cxx
@@ -10,6 +10,7 @@
See the License for more information.
============================================================================*/
#include "cmFindProgramCommand.h"
+#include "cmCacheManager.h"
#include <stdlib.h>
#if defined(__APPLE__)
@@ -36,7 +37,7 @@ bool cmFindProgramCommand
{
this->Makefile->AddCacheDefinition(this->VariableName, "",
this->VariableDocumentation.c_str(),
- cmConfiguration::FILEPATH);
+ cmCacheManager::FILEPATH);
}
return true;
}
@@ -48,14 +49,14 @@ bool cmFindProgramCommand
this->Makefile->AddCacheDefinition(this->VariableName,
result.c_str(),
this->VariableDocumentation.c_str(),
- cmConfiguration::FILEPATH);
+ cmCacheManager::FILEPATH);
return true;
}
this->Makefile->AddCacheDefinition(this->VariableName,
(this->VariableName + "-NOTFOUND").c_str(),
this->VariableDocumentation.c_str(),
- cmConfiguration::FILEPATH);
+ cmCacheManager::FILEPATH);
return true;
}
diff --git a/Source/cmGetFilenameComponentCommand.cxx b/Source/cmGetFilenameComponentCommand.cxx
index 979e756..9aceb39 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" ? cmConfiguration::FILEPATH
- : cmConfiguration::STRING);
+ "", args[2] == "PATH" ? cmCacheManager::FILEPATH
+ : cmCacheManager::STRING);
}
this->Makefile->AddCacheDefinition
(args[0], result.c_str(), "",
- args[2] == "PATH" ? cmConfiguration::FILEPATH
- : cmConfiguration::STRING);
+ args[2] == "PATH" ? cmCacheManager::FILEPATH
+ : cmCacheManager::STRING);
}
else
{
diff --git a/Source/cmGetPropertyCommand.cxx b/Source/cmGetPropertyCommand.cxx
index 1fe53ac..0e6e0c2 100644
--- a/Source/cmGetPropertyCommand.cxx
+++ b/Source/cmGetPropertyCommand.cxx
@@ -12,7 +12,6 @@
#include "cmGetPropertyCommand.h"
#include "cmake.h"
-#include "cmConfiguration.h"
#include "cmTest.h"
#include "cmGlobalGenerator.h"
#include "cmLocalGenerator.h"
@@ -392,9 +391,9 @@ bool cmGetPropertyCommand::HandleCacheMode()
}
const char* value = 0;
- if(this->Makefile->GetConfiguration()->GetCacheEntryValue(this->Name))
+ if(this->Makefile->GetCacheManager()->GetCacheEntryValue(this->Name))
{
- value = this->Makefile->GetConfiguration()
+ value = this->Makefile->GetCacheManager()
->GetCacheEntryProperty(this->Name, this->PropertyName);
}
this->StoreResult(value);
diff --git a/Source/cmGlobalGenerator.cxx b/Source/cmGlobalGenerator.cxx
index a9c73a7..35394b8 100644
--- a/Source/cmGlobalGenerator.cxx
+++ b/Source/cmGlobalGenerator.cxx
@@ -20,7 +20,6 @@
#include "cmLocalGenerator.h"
#include "cmExternalMakefileProjectGenerator.h"
#include "cmake.h"
-#include "cmConfiguration.h"
#include "cmMakefile.h"
#include "cmQtAutoGenerators.h"
#include "cmSourceFile.h"
@@ -180,7 +179,7 @@ void cmGlobalGenerator::ResolveLanguageCompiler(const std::string &lang,
return;
}
const char* cname = this->GetCMakeInstance()->
- GetConfiguration()->GetInitializedCacheValue(langComp);
+ GetCacheManager()->GetInitializedCacheValue(langComp);
std::string changeVars;
if(cname && !optional)
{
@@ -311,7 +310,7 @@ void cmGlobalGenerator::FindMakeProgram(cmMakefile* mf)
makeProgram += saveFile;
mf->AddCacheDefinition("CMAKE_MAKE_PROGRAM", makeProgram.c_str(),
"make program",
- cmConfiguration::FILEPATH);
+ cmCacheManager::FILEPATH);
}
}
@@ -1116,7 +1115,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", cmConfiguration::INTERNAL);
+ "number of local generators", cmCacheManager::INTERNAL);
// check for link libraries and include directories containing "NOTFOUND"
// and for infinite loops
@@ -1538,7 +1537,7 @@ void cmGlobalGenerator::CheckLocalGenerators()
std::map<std::string, std::string> notFoundMap;
// std::set<std::string> notFoundMap;
// after it is all done do a ConfigureFinalPass
- cmConfiguration* config = this->GetCMakeInstance()->GetConfiguration();
+ cmCacheManager* manager = this->GetCMakeInstance()->GetCacheManager();
for (unsigned int i = 0; i < this->LocalGenerators.size(); ++i)
{
this->LocalGenerators[i]->ConfigureFinalPass();
@@ -1560,7 +1559,7 @@ void cmGlobalGenerator::CheckLocalGenerators()
cmSystemTools::IsNOTFOUND(lib->first.c_str()))
{
std::string varName = lib->first.substr(0, lib->first.size()-9);
- if(config->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
+ if(manager->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
{
varName += " (ADVANCED)";
}
@@ -1591,7 +1590,7 @@ void cmGlobalGenerator::CheckLocalGenerators()
cmSystemTools::IsNOTFOUND(incDir->c_str()))
{
std::string varName = incDir->substr(0, incDir->size()-9);
- if(config->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
+ if(manager->GetCacheEntryPropertyAsBool(varName, "ADVANCED"))
{
varName += " (ADVANCED)";
}
@@ -1638,7 +1637,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->GetConfiguration()->GetInitializedCacheValue
+ if (!this->CMakeInstance->GetCacheManager()->GetInitializedCacheValue
("CMAKE_NUMBER_OF_LOCAL_GENERATORS"))
{
// If CMAKE_NUMBER_OF_LOCAL_GENERATORS is not set
@@ -1836,7 +1835,7 @@ void cmGlobalGenerator::AddLocalGenerator(cmLocalGenerator *lg)
// update progress
// estimate how many lg there will be
const char *numGenC =
- this->CMakeInstance->GetConfiguration()->GetInitializedCacheValue
+ this->CMakeInstance->GetCacheManager()->GetInitializedCacheValue
("CMAKE_NUMBER_OF_LOCAL_GENERATORS");
if (!numGenC)
@@ -1894,7 +1893,7 @@ void cmGlobalGenerator::EnableLanguagesFromGenerator(cmGlobalGenerator *gen,
gen->GetCMakeInstance()->GetCacheDefinition("CMAKE_MAKE_PROGRAM");
this->GetCMakeInstance()->AddCacheEntry("CMAKE_MAKE_PROGRAM", make,
"make program",
- cmConfiguration::FILEPATH);
+ cmCacheManager::FILEPATH);
// copy the enabled languages
this->LanguageEnabled = gen->LanguageEnabled;
this->LanguagesReady = gen->LanguagesReady;
diff --git a/Source/cmGlobalUnixMakefileGenerator3.cxx b/Source/cmGlobalUnixMakefileGenerator3.cxx
index d36a6fc..7648813 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.", cmConfiguration::INTERNAL);
+ "Path to cache edit program executable.", cmCacheManager::INTERNAL);
}
}
const char* edit_cmd = cm->GetCacheDefinition("CMAKE_EDIT_COMMAND");
diff --git a/Source/cmGlobalVisualStudio7Generator.cxx b/Source/cmGlobalVisualStudio7Generator.cxx
index 2108715..0e0e63a 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.",
- cmConfiguration::STRING);
+ cmCacheManager::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",
- cmConfiguration::STATIC);
+ cmCacheManager::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.",
- cmConfiguration::STRING);
+ cmCacheManager::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",
- cmConfiguration::INTERNAL);
+ cmCacheManager::INTERNAL);
}
std::vector<std::string> *cmGlobalVisualStudio7Generator::GetConfigurations()
diff --git a/Source/cmGlobalXCodeGenerator.cxx b/Source/cmGlobalXCodeGenerator.cxx
index 33349d2..0561a05 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.",
- cmConfiguration::STRING);
+ cmCacheManager::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", cmConfiguration::INTERNAL);
+ id.c_str(), "Stored Xcode object GUID", cmCacheManager::INTERNAL);
return id;
}
diff --git a/Source/cmIncludeExternalMSProjectCommand.cxx b/Source/cmIncludeExternalMSProjectCommand.cxx
index a8b8c2e..d40d8fe 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", cmConfiguration::INTERNAL);
+ "Stored GUID", cmCacheManager::INTERNAL);
}
// Create a target instance for this utility.
diff --git a/Source/cmLoadCacheCommand.cxx b/Source/cmLoadCacheCommand.cxx
index 256eb31..e2ae901 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;
- cmConfiguration::CacheEntryType type = cmConfiguration::UNINITIALIZED;
+ cmCacheManager::CacheEntryType type = cmCacheManager::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 22abb79..aa70ab9 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",
- cmConfiguration::INTERNAL);
+ cmCacheManager::INTERNAL);
}
//----------------------------------------------------------------------------
diff --git a/Source/cmLocalVisualStudio7Generator.cxx b/Source/cmLocalVisualStudio7Generator.cxx
index 2bbaab1..c4abeb2 100644
--- a/Source/cmLocalVisualStudio7Generator.cxx
+++ b/Source/cmLocalVisualStudio7Generator.cxx
@@ -16,6 +16,7 @@
#include "cmMakefile.h"
#include "cmSystemTools.h"
#include "cmSourceFile.h"
+#include "cmCacheManager.h"
#include "cmGeneratorTarget.h"
#include "cmCustomCommandGenerator.h"
#include "cmake.h"
@@ -2330,7 +2331,7 @@ void cmLocalVisualStudio7Generator::ReadAndStoreExternalGUID(
AddCacheEntry(guidStoreName.c_str(),
parser.GUID.c_str(),
"Stored GUID",
- cmConfiguration::INTERNAL);
+ cmCacheManager::INTERNAL);
}
diff --git a/Source/cmMakefile.cxx b/Source/cmMakefile.cxx
index 941aaf1..34b4621 100644
--- a/Source/cmMakefile.cxx
+++ b/Source/cmMakefile.cxx
@@ -18,7 +18,7 @@
#include "cmGlobalGenerator.h"
#include "cmLocalGenerator.h"
#include "cmCommands.h"
-#include "cmConfiguration.h"
+#include "cmCacheManager.h"
#include "cmFunctionBlocker.h"
#include "cmListFileCache.h"
#include "cmCommandArgumentParserHelper.h"
@@ -1805,16 +1805,16 @@ void cmMakefile::AddDefinition(const std::string& name, const char* value)
void cmMakefile::AddCacheDefinition(const std::string& name, const char* value,
const char* doc,
- cmConfiguration::CacheEntryType type,
+ cmCacheManager::CacheEntryType type,
bool force)
{
bool haveVal = value ? true : false;
std::string val = haveVal ? value : "";
const char* existingValue =
- this->GetConfiguration()->GetInitializedCacheValue(name);
+ this->GetCacheManager()->GetInitializedCacheValue(name);
if(existingValue
- && (this->GetConfiguration()->GetCacheEntryType(name)
- == cmConfiguration::UNINITIALIZED))
+ && (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
@@ -1823,7 +1823,7 @@ void cmMakefile::AddCacheDefinition(const std::string& name, const char* value,
val = existingValue;
haveVal = true;
}
- if ( type == cmConfiguration::PATH || type == cmConfiguration::FILEPATH )
+ if ( type == cmCacheManager::PATH || type == cmCacheManager::FILEPATH )
{
std::vector<std::string>::size_type cc;
std::vector<std::string> files;
@@ -1842,14 +1842,14 @@ void cmMakefile::AddCacheDefinition(const std::string& name, const char* value,
nvalue += files[cc];
}
- this->GetConfiguration()->AddCacheEntry(name, nvalue.c_str(), doc, type);
- val = this->GetConfiguration()->GetInitializedCacheValue(name);
+ this->GetCacheManager()->AddCacheEntry(name, nvalue.c_str(), doc, type);
+ val = this->GetCacheManager()->GetInitializedCacheValue(name);
haveVal = true;
}
}
- this->GetConfiguration()->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);
}
@@ -1976,7 +1976,7 @@ void cmMakefile::RemoveDefinition(const std::string& name)
void cmMakefile::RemoveCacheDefinition(const std::string& name)
{
- this->GetConfiguration()->RemoveCacheEntry(name);
+ this->GetCacheManager()->RemoveCacheEntry(name);
}
void cmMakefile::SetProjectName(const char* p)
@@ -2433,7 +2433,7 @@ bool cmMakefile::IsDefinitionSet(const std::string& name) const
this->Internal->VarUsageStack.top().insert(name);
if(!def)
{
- def = this->GetConfiguration()->GetInitializedCacheValue(name);
+ def = this->GetCacheManager()->GetInitializedCacheValue(name);
}
#ifdef CMAKE_BUILD_WITH_CMAKE
if(cmVariableWatch* vv = this->GetVariableWatch())
@@ -2458,7 +2458,7 @@ const char* cmMakefile::GetDefinition(const std::string& name) const
const char* def = this->Internal->VarStack.top().Get(name);
if(!def)
{
- def = this->GetConfiguration()->GetInitializedCacheValue(name);
+ def = this->GetCacheManager()->GetInitializedCacheValue(name);
}
#ifdef CMAKE_BUILD_WITH_CMAKE
cmVariableWatch* vv = this->GetVariableWatch();
@@ -2500,7 +2500,7 @@ std::vector<std::string> cmMakefile
res.insert(res.end(), definitions.begin(), definitions.end());
}
std::vector<std::string> cacheKeys =
- this->GetConfiguration()->GetCacheEntryKeys();
+ this->GetCacheManager()->GetCacheEntryKeys();
res.insert(res.end(), cacheKeys.begin(), cacheKeys.end());
std::sort(res.begin(), res.end());
@@ -2801,8 +2801,6 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringNew(
openstack.push(t_lookup());
cmake::MessageType mtype = cmake::LOG;
- cmConfiguration* config = this->GetCMakeInstance()->GetConfiguration();
-
do
{
char inc = *in;
@@ -2836,7 +2834,8 @@ cmake::MessageType cmMakefile::ExpandVariablesInStringNew(
value = cmSystemTools::GetEnv(lookup.c_str());
break;
case CACHE:
- value = config->GetCacheEntryValue(lookup);
+ value = this->GetCacheManager()
+ ->GetInitializedCacheValue(lookup);
break;
}
// Get the string we're meant to append to.
@@ -3616,7 +3615,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", cmConfiguration::STRING);
+ "Build configuration", cmCacheManager::STRING);
}
}
// if cmake args were provided then pass them in
@@ -3655,12 +3654,12 @@ int cmMakefile::TryCompile(const std::string& srcdir,
if(this->IsOn("CMAKE_SUPPRESS_DEVELOPER_WARNINGS"))
{
cm.AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS",
- "TRUE", "", cmConfiguration::INTERNAL);
+ "TRUE", "", cmCacheManager::INTERNAL);
}
else
{
cm.AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS",
- "FALSE", "", cmConfiguration::INTERNAL);
+ "FALSE", "", cmCacheManager::INTERNAL);
}
if (cm.Configure() != 0)
{
@@ -3734,9 +3733,9 @@ void cmMakefile::GetListOfMacros(std::string& macros) const
macros = cmJoin(this->MacrosList, ";");
}
-cmConfiguration *cmMakefile::GetConfiguration() const
+cmCacheManager *cmMakefile::GetCacheManager() const
{
- return this->GetCMakeInstance()->GetConfiguration();
+ return this->GetCMakeInstance()->GetCacheManager();
}
void cmMakefile::DisplayStatus(const char* message, float s) const
@@ -4903,7 +4902,7 @@ bool cmMakefile::SetPolicy(cmPolicies::PolicyID id,
if(id == cmPolicies::CMP0001 &&
(status == cmPolicies::WARN || status == cmPolicies::OLD))
{
- if(!(this->GetConfiguration()
+ if(!(this->GetCacheManager()
->GetInitializedCacheValue("CMAKE_BACKWARDS_COMPATIBILITY")))
{
// Set it to 2.4 because that is the last version where the
@@ -4913,7 +4912,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.",
- cmConfiguration::STRING);
+ cmCacheManager::STRING);
}
}
diff --git a/Source/cmMakefile.h b/Source/cmMakefile.h
index 5ba7d19..5209891 100644
--- a/Source/cmMakefile.h
+++ b/Source/cmMakefile.h
@@ -12,6 +12,7 @@
#ifndef cmMakefile_h
#define cmMakefile_h
+#include "cmCacheManager.h"
#include "cmExecutionStatus.h"
#include "cmListFileCache.h"
#include "cmPolicies.h"
@@ -22,7 +23,6 @@
#include "cmGeneratorTarget.h"
#include "cmExpandedCommandArgument.h"
#include "cmake.h"
-#include "cmConfiguration.h"
#if defined(CMAKE_BUILD_WITH_CMAKE)
#include "cmSourceGroup.h"
@@ -306,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,
- cmConfiguration::CacheEntryType type,
+ cmCacheManager::CacheEntryType type,
bool force = false);
/**
@@ -765,7 +765,7 @@ public:
///enabled.
void EnableLanguage(std::vector<std::string>const& languages, bool optional);
- cmConfiguration *GetConfiguration() const;
+ cmCacheManager *GetCacheManager() const;
/**
* Get the variable watch. This is used to determine when certain variables
diff --git a/Source/cmMarkAsAdvancedCommand.cxx b/Source/cmMarkAsAdvancedCommand.cxx
index 5ed1ea1..cc094b1 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];
- cmConfiguration* config = this->Makefile->GetConfiguration();
- if (!config->GetCacheEntryValue(variable))
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
+ if (!manager->GetCacheEntryValue(variable))
{
- config->AddCacheEntry(variable, 0, 0, cmConfiguration::UNINITIALIZED);
+ manager->AddCacheEntry(variable, 0, 0, cmCacheManager::UNINITIALIZED);
overwrite = true;
}
- if (!config->GetCacheEntryValue(variable))
+ if (!manager->GetCacheEntryValue(variable))
{
cmSystemTools::Error("This should never happen...");
return false;
}
- if (!config->GetCacheEntryProperty(variable, "ADVANCED") || overwrite)
+ if (!manager->GetCacheEntryProperty(variable, "ADVANCED") || overwrite)
{
- config->SetCacheEntryProperty(variable, "ADVANCED", value);
+ manager->SetCacheEntryProperty(variable, "ADVANCED", value);
}
}
return true;
diff --git a/Source/cmOptionCommand.cxx b/Source/cmOptionCommand.cxx
index c3d254f..baf5b1e 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
- cmConfiguration* config = this->Makefile->GetConfiguration();
- const char* existingValue = config->GetCacheEntryValue(args[0]);
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
+ const char* existingValue = manager->GetCacheEntryValue(args[0]);
if(existingValue)
{
- if (config->GetCacheEntryType(args[0]) != cmConfiguration::UNINITIALIZED)
+ if (manager->GetCacheEntryType(args[0]) != cmCacheManager::UNINITIALIZED)
{
- config->SetCacheEntryProperty(args[0], "HELPSTRING", args[1]);
+ manager->SetCacheEntryProperty(args[0], "HELPSTRING", args[1]);
return true;
}
initialValue = existingValue;
@@ -59,6 +59,6 @@ bool cmOptionCommand
}
bool init = cmSystemTools::IsOn(initialValue.c_str());
this->Makefile->AddCacheDefinition(args[0], init? "ON":"OFF",
- args[1].c_str(), cmConfiguration::BOOL);
+ args[1].c_str(), cmCacheManager::BOOL);
return true;
}
diff --git a/Source/cmProjectCommand.cxx b/Source/cmProjectCommand.cxx
index c26173e..61c0133 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", cmConfiguration::STATIC);
+ "Value Computed by CMake", cmCacheManager::STATIC);
this->Makefile->AddCacheDefinition
(srcdir,
this->Makefile->GetCurrentDirectory(),
- "Value Computed by CMake", cmConfiguration::STATIC);
+ "Value Computed by CMake", cmCacheManager::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", cmConfiguration::STATIC);
+ "Value Computed by CMake", cmCacheManager::STATIC);
}
bool haveVersion = false;
diff --git a/Source/cmSetCommand.cxx b/Source/cmSetCommand.cxx
index d74944e..e17474b 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;
- cmConfiguration::CacheEntryType type
- = cmConfiguration::STRING; // required if cache
+ cmCacheManager::CacheEntryType type
+ = cmCacheManager::STRING; // required if cache
const char* docstring = 0; // required if cache
unsigned int ignoreLastArgs = 0;
@@ -131,21 +131,21 @@ bool cmSetCommand
if(cache)
{
std::string::size_type cacheStart = args.size() - 3 - (force ? 1 : 0);
- type = cmConfiguration::StringToCacheEntryType(args[cacheStart+1].c_str());
+ type = cmCacheManager::StringToType(args[cacheStart+1].c_str());
docstring = args[cacheStart+2].c_str();
}
// see if this is already in the cache
- cmConfiguration* config = this->Makefile->GetConfiguration();
- const char* existingValue = config->GetCacheEntryValue(variable);
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
+ const char* existingValue = manager->GetCacheEntryValue(variable);
if(existingValue &&
- (config->GetCacheEntryType(variable) != cmConfiguration::UNINITIALIZED))
+ (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
// then leave now without setting any definitions in the cache
// or the makefile
- if(cache && type != cmConfiguration::INTERNAL && !force)
+ if(cache && type != cmCacheManager::INTERNAL && !force)
{
return true;
}
diff --git a/Source/cmSetPropertyCommand.cxx b/Source/cmSetPropertyCommand.cxx
index 87fb475..77f9fb9 100644
--- a/Source/cmSetPropertyCommand.cxx
+++ b/Source/cmSetPropertyCommand.cxx
@@ -14,6 +14,7 @@
#include "cmSetTestsPropertiesCommand.h"
#include "cmSetSourceFilesPropertiesCommand.h"
+#include "cmCacheManager.h"
//----------------------------------------------------------------------------
cmSetPropertyCommand::cmSetPropertyCommand()
@@ -425,7 +426,7 @@ bool cmSetPropertyCommand::HandleCacheMode()
}
else if(this->PropertyName == "TYPE")
{
- if(!cmConfiguration::IsCacheEntryType(this->PropertyValue.c_str()))
+ if(!cmCacheManager::IsType(this->PropertyValue.c_str()))
{
std::ostringstream e;
e << "given invalid CACHE entry TYPE \"" << this->PropertyValue << "\"";
@@ -452,7 +453,7 @@ bool cmSetPropertyCommand::HandleCacheMode()
cmMakefile* mf = this->GetMakefile();
cmake* cm = mf->GetCMakeInstance();
const char* existingValue
- = cm->GetConfiguration()->GetCacheEntryValue(*ni);
+ = cm->GetCacheManager()->GetCacheEntryValue(*ni);
if(existingValue)
{
if(!this->HandleCacheEntry(*ni))
@@ -478,19 +479,20 @@ 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();
- cmConfiguration* config = this->Makefile->GetConfiguration();
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
if (this->Remove)
{
- config->RemoveCacheEntryProperty(cacheKey, name);
+ manager->RemoveCacheEntryProperty(cacheKey, name);
+ return true;
}
if(this->AppendMode)
{
- config->AppendCacheEntryProperty(cacheKey, name, value,
- this->AppendAsString);
+ manager->AppendCacheEntryProperty(cacheKey, name, value,
+ this->AppendAsString);
}
else
{
- config->SetCacheEntryProperty(cacheKey, name, value);
+ manager->SetCacheEntryProperty(cacheKey, name, value);
}
return true;
diff --git a/Source/cmSiteNameCommand.cxx b/Source/cmSiteNameCommand.cxx
index 836f342..927888b 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",
- cmConfiguration::STRING);
+ cmCacheManager::STRING);
return true;
}
diff --git a/Source/cmTarget.cxx b/Source/cmTarget.cxx
index ad461f0..b3d1155 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", cmConfiguration::STATIC);
+ "Dependencies for target", cmCacheManager::STATIC);
}
else
{
@@ -1369,7 +1369,7 @@ void cmTarget::AddLinkLibrary(cmMakefile& mf,
dependencies += ";";
mf.AddCacheDefinition( targetEntry, dependencies.c_str(),
"Dependencies for the target",
- cmConfiguration::STATIC );
+ cmCacheManager::STATIC );
}
}
diff --git a/Source/cmTryRunCommand.cxx b/Source/cmTryRunCommand.cxx
index 3cd8291..911ade8 100644
--- a/Source/cmTryRunCommand.cxx
+++ b/Source/cmTryRunCommand.cxx
@@ -10,6 +10,7 @@
See the License for more information.
============================================================================*/
#include "cmTryRunCommand.h"
+#include "cmCacheManager.h"
#include "cmTryCompileCommand.h"
#include <cmsys/FStream.hxx>
@@ -216,7 +217,7 @@ void cmTryRunCommand::RunExecutable(const std::string& runArgs,
}
this->Makefile->AddCacheDefinition(this->RunResultVariable, retChar,
"Result of TRY_RUN",
- cmConfiguration::INTERNAL);
+ cmCacheManager::INTERNAL);
}
/* This is only used when cross compiling. Instead of running the
@@ -261,14 +262,14 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
this->Makefile->AddCacheDefinition(this->RunResultVariable,
"PLEASE_FILL_OUT-FAILED_TO_RUN",
comment.c_str(),
- cmConfiguration::STRING);
+ cmCacheManager::STRING);
- cmConfiguration* config = this->Makefile->GetConfiguration();
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
const char* existingValue
- = config->GetCacheEntryValue(this->RunResultVariable);
+ = manager->GetCacheEntryValue(this->RunResultVariable);
if (existingValue)
{
- config->SetCacheEntryProperty(this->RunResultVariable, "ADVANCED", "1");
+ manager->SetCacheEntryProperty(this->RunResultVariable, "ADVANCED", "1");
}
error = true;
@@ -289,14 +290,14 @@ void cmTryRunCommand::DoNotRunExecutable(const std::string& runArgs,
this->Makefile->AddCacheDefinition(internalRunOutputName,
"PLEASE_FILL_OUT-NOTFOUND",
comment.c_str(),
- cmConfiguration::STRING);
- cmConfiguration* config = this->Makefile->GetConfiguration();
+ cmCacheManager::STRING);
+ cmCacheManager* manager = this->Makefile->GetCacheManager();
const char* existing =
- config->GetCacheEntryValue(internalRunOutputName);
+ manager->GetCacheEntryValue(internalRunOutputName);
if (existing)
{
- config->SetCacheEntryProperty(internalRunOutputName,
- "ADVANCED", "1");
+ manager->SetCacheEntryProperty(internalRunOutputName,
+ "ADVANCED", "1");
}
error = true;
diff --git a/Source/cmUtilitySourceCommand.cxx b/Source/cmUtilitySourceCommand.cxx
index b68afbc..2799a9b 100644
--- a/Source/cmUtilitySourceCommand.cxx
+++ b/Source/cmUtilitySourceCommand.cxx
@@ -11,8 +11,6 @@
============================================================================*/
#include "cmUtilitySourceCommand.h"
-#include "cmCacheManager.h"
-
// cmUtilitySourceCommand
bool cmUtilitySourceCommand
::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
@@ -120,14 +118,14 @@ bool cmUtilitySourceCommand
this->Makefile->AddCacheDefinition(cacheEntry,
utilityExecutable.c_str(),
"Path to an internal program.",
- cmConfiguration::FILEPATH);
+ cmCacheManager::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.",
- cmConfiguration::INTERNAL);
+ cmCacheManager::INTERNAL);
return true;
}
diff --git a/Source/cmVariableRequiresCommand.cxx b/Source/cmVariableRequiresCommand.cxx
index bc6bc01..dd2a682 100644
--- a/Source/cmVariableRequiresCommand.cxx
+++ b/Source/cmVariableRequiresCommand.cxx
@@ -10,7 +10,7 @@
See the License for more information.
============================================================================*/
#include "cmVariableRequiresCommand.h"
-#include "cmConfiguration.h"
+#include "cmCacheManager.h"
// cmLibraryCommand
bool cmVariableRequiresCommand
@@ -34,7 +34,6 @@ 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]))
@@ -42,8 +41,9 @@ bool cmVariableRequiresCommand
requirementsMet = false;
notSet += args[i];
notSet += "\n";
- if(config->GetCacheEntryValue(args[i]) &&
- config->GetCacheEntryPropertyAsBool(args[i], "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 328e273..64b332c 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -21,7 +21,6 @@
#include "cmTest.h"
#include "cmDocumentationFormatter.h"
#include "cmAlgorithms.h"
-#include "cmConfiguration.h"
#if defined(CMAKE_BUILD_WITH_CMAKE)
# include "cmGraphVizWriter.h"
@@ -134,8 +133,6 @@ cmake::cmake()
this->FileComparison = new cmFileTimeComparison;
this->Policies = new cmPolicies();
- this->Configuration = new cmConfiguration(this);
-
this->InitializeProperties();
#ifdef __APPLE__
@@ -174,7 +171,6 @@ cmake::~cmake()
{
delete this->CacheManager;
delete this->Policies;
- delete this->Configuration;
if (this->GlobalGenerator)
{
delete this->GlobalGenerator;
@@ -338,7 +334,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
}
}
std::string var, value;
- cmConfiguration::CacheEntryType type = cmConfiguration::UNINITIALIZED;
+ cmCacheManager::CacheEntryType type = cmCacheManager::UNINITIALIZED;
if(cmCacheManager::ParseEntry(entry, var, value, type))
{
// The value is transformed if it is a filepath for example, so
@@ -348,7 +344,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
std::string cachedValue;
if(this->WarnUnusedCli)
{
- if(const char *v = this->Configuration
+ if(const char *v = this->CacheManager
->GetInitializedCacheValue(var))
{
haveValue = true;
@@ -356,13 +352,13 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
}
}
- this->Configuration->AddCacheEntry(var, value.c_str(),
+ this->CacheManager->AddCacheEntry(var, value.c_str(),
"No help, variable specified on the command line.", type);
if(this->WarnUnusedCli)
{
if (!haveValue ||
- cachedValue != this->Configuration
+ cachedValue != this->CacheManager
->GetInitializedCacheValue(var))
{
this->WatchUnusedCli(var);
@@ -408,13 +404,13 @@ 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->Configuration->GetCacheEntryKeys();
+ this->CacheManager->GetCacheEntryKeys();
for (std::vector<std::string>::const_iterator it = cacheKeys.begin();
it != cacheKeys.end(); ++it)
{
- cmConfiguration::CacheEntryType t =
- this->Configuration->GetCacheEntryType(*it);
- if(t != cmConfiguration::STATIC)
+ cmCacheManager::CacheEntryType t =
+ this->CacheManager->GetCacheEntryType(*it);
+ if(t != cmCacheManager::STATIC)
{
if (regex.find(it->c_str()))
{
@@ -429,7 +425,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
currentEntry != entriesToDelete.end();
++currentEntry)
{
- this->Configuration->RemoveCacheEntry(*currentEntry);
+ this->CacheManager->RemoveCacheEntry(*currentEntry);
}
}
else if(arg.find("-C",0) == 0)
@@ -925,7 +921,7 @@ void cmake::SetDirectoriesFromFile(const char* arg)
if(this->LoadCache(cachePath))
{
const char* existingValue =
- this->Configuration->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
+ this->CacheManager->GetCacheEntryValue("CMAKE_HOME_DIRECTORY");
if (existingValue)
{
this->SetHomeOutputDirectory(cachePath);
@@ -979,14 +975,14 @@ int cmake::AddCMakePaths()
// Save the value in the cache
this->CacheManager->AddCacheEntry
("CMAKE_COMMAND", cmSystemTools::GetCMakeCommand().c_str(),
- "Path to CMake executable.", cmConfiguration::INTERNAL);
+ "Path to CMake executable.", cmCacheManager::INTERNAL);
#ifdef CMAKE_BUILD_WITH_CMAKE
this->CacheManager->AddCacheEntry
("CMAKE_CTEST_COMMAND", cmSystemTools::GetCTestCommand().c_str(),
- "Path to ctest program executable.", cmConfiguration::INTERNAL);
+ "Path to ctest program executable.", cmCacheManager::INTERNAL);
this->CacheManager->AddCacheEntry
("CMAKE_CPACK_COMMAND", cmSystemTools::GetCPackCommand().c_str(),
- "Path to cpack program executable.", cmConfiguration::INTERNAL);
+ "Path to cpack program executable.", cmCacheManager::INTERNAL);
#endif
if(!cmSystemTools::FileExists(
(cmSystemTools::GetCMakeRoot()+"/Modules/CMake.cmake").c_str()))
@@ -1000,7 +996,7 @@ int cmake::AddCMakePaths()
}
this->CacheManager->AddCacheEntry
("CMAKE_ROOT", cmSystemTools::GetCMakeRoot().c_str(),
- "Path to CMake installation.", cmConfiguration::INTERNAL);
+ "Path to CMake installation.", cmCacheManager::INTERNAL);
return 1;
}
@@ -1242,7 +1238,7 @@ struct SaveCacheEntry
std::string key;
std::string value;
std::string help;
- cmConfiguration::CacheEntryType type;
+ cmCacheManager::CacheEntryType type;
};
int cmake::HandleDeleteCacheVariables(const std::string& var)
@@ -1255,6 +1251,7 @@ int cmake::HandleDeleteCacheVariables(const std::string& var)
{
return 0;
}
+ cmCacheManager::CacheIterator ci = this->CacheManager->NewIterator();
std::vector<SaveCacheEntry> saved;
std::ostringstream warning;
warning
@@ -1270,13 +1267,10 @@ int cmake::HandleDeleteCacheVariables(const std::string& var)
i++;
save.value = *i;
warning << *i << "\n";
- const char* existingValue =
- this->CacheManager->GetCacheEntryValue(save.key);
- if(existingValue)
+ if(ci.Find(save.key))
{
- save.type = this->CacheManager->GetCacheEntryType(save.key);
- if(const char* help =
- this->CacheManager->GetCacheEntryProperty(save.key, "HELPSTRING"))
+ save.type = ci.GetType();
+ if(const char* help = ci.GetProperty("HELPSTRING"))
{
save.help = help;
}
@@ -1315,7 +1309,7 @@ int cmake::Configure()
AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", "TRUE",
"Suppress Warnings that are meant for"
" the author of the CMakeLists.txt files.",
- cmConfiguration::INTERNAL);
+ cmCacheManager::INTERNAL);
}
else
{
@@ -1323,7 +1317,7 @@ int cmake::Configure()
AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", "FALSE",
"Suppress Warnings that are meant for"
" the author of the CMakeLists.txt files.",
- cmConfiguration::INTERNAL);
+ cmCacheManager::INTERNAL);
}
}
int ret = this->ActualConfigure();
@@ -1359,7 +1353,7 @@ int cmake::ActualConfigure()
this->GetHomeDirectory(),
"Start directory with the top level CMakeLists.txt file for this "
"project",
- cmConfiguration::INTERNAL);
+ cmCacheManager::INTERNAL);
}
// no generator specified on the command line
@@ -1468,11 +1462,11 @@ int cmake::ActualConfigure()
this->CacheManager->AddCacheEntry("CMAKE_GENERATOR",
this->GlobalGenerator->GetName().c_str(),
"Name of generator.",
- cmConfiguration::INTERNAL);
+ cmCacheManager::INTERNAL);
this->CacheManager->AddCacheEntry("CMAKE_EXTRA_GENERATOR",
this->GlobalGenerator->GetExtraGeneratorName().c_str(),
"Name of external makefile project generator.",
- cmConfiguration::INTERNAL);
+ cmCacheManager::INTERNAL);
}
if(const char* platformName =
@@ -1500,7 +1494,7 @@ int cmake::ActualConfigure()
this->CacheManager->AddCacheEntry("CMAKE_GENERATOR_PLATFORM",
this->GeneratorPlatform.c_str(),
"Name of generator platform.",
- cmConfiguration::INTERNAL);
+ cmCacheManager::INTERNAL);
}
if(const char* tsName =
@@ -1528,7 +1522,7 @@ int cmake::ActualConfigure()
this->CacheManager->AddCacheEntry("CMAKE_GENERATOR_TOOLSET",
this->GeneratorToolset.c_str(),
"Name of generator toolset.",
- cmConfiguration::INTERNAL);
+ cmCacheManager::INTERNAL);
}
// reset any system configuration information, except for when we are
@@ -1558,51 +1552,49 @@ 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->Configuration
+ if(this->GetCacheManager()
->GetInitializedCacheValue("CMAKE_BACKWARDS_COMPATIBILITY"))
{
- if(!this->Configuration->GetInitializedCacheValue("LIBRARY_OUTPUT_PATH"))
+ if(!this->CacheManager->GetInitializedCacheValue("LIBRARY_OUTPUT_PATH"))
{
- this->Configuration->AddCacheEntry
+ this->CacheManager->AddCacheEntry
("LIBRARY_OUTPUT_PATH", "",
"Single output directory for building all libraries.",
- cmConfiguration::PATH);
+ cmCacheManager::PATH);
}
- if(!this->Configuration
+ if(!this->CacheManager
->GetInitializedCacheValue("EXECUTABLE_OUTPUT_PATH"))
{
- this->Configuration->AddCacheEntry
+ this->CacheManager->AddCacheEntry
("EXECUTABLE_OUTPUT_PATH", "",
"Single output directory for building all executables.",
- cmConfiguration::PATH);
+ cmCacheManager::PATH);
}
}
- if(!this->Configuration
+ if(!this->CacheManager
->GetInitializedCacheValue("CMAKE_USE_RELATIVE_PATHS"))
{
- this->Configuration->AddCacheEntry
+ this->CacheManager->AddCacheEntry
("CMAKE_USE_RELATIVE_PATHS", "OFF",
"If true, cmake will use relative paths in makefiles and projects.",
- cmConfiguration::BOOL);
- if (!this->Configuration->GetCacheEntryProperty("CMAKE_USE_RELATIVE_PATHS",
- "ADVANCED"))
+ cmCacheManager::BOOL);
+ if (!this->CacheManager->GetCacheEntryProperty("CMAKE_USE_RELATIVE_PATHS",
+ "ADVANCED"))
{
- this->Configuration->SetCacheEntryProperty("CMAKE_USE_RELATIVE_PATHS",
- "ADVANCED", "1");
+ this->CacheManager->SetCacheEntryProperty("CMAKE_USE_RELATIVE_PATHS",
+ "ADVANCED", "1");
}
}
- if(cmSystemTools::GetFatalErrorOccured())
+ if(cmSystemTools::GetFatalErrorOccured() &&
+ (!this->CacheManager->GetInitializedCacheValue("CMAKE_MAKE_PROGRAM") ||
+ cmSystemTools::IsOff(this->CacheManager->
+ GetInitializedCacheValue("CMAKE_MAKE_PROGRAM"))))
{
- 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");
- }
+ // 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");
}
cmMakefile* mf=this->GlobalGenerator->GetLocalGenerators()[0]->GetMakefile();
@@ -1808,7 +1800,7 @@ void cmake::AddCacheEntry(const std::string& key, const char* value,
{
this->CacheManager->AddCacheEntry(key, value,
helpString,
- cmConfiguration::CacheEntryType(type));
+ cmCacheManager::CacheEntryType(type));
}
const char* cmake::GetCacheDefinition(const std::string& name) const
@@ -1880,7 +1872,7 @@ void cmake::AddDefaultGenerators()
bool cmake::ParseCacheEntry(const std::string& entry,
std::string& var,
std::string& value,
- cmConfiguration::CacheEntryType& type)
+ cmCacheManager::CacheEntryType& type)
{
return cmCacheManager::ParseEntry(entry, var, value, type);
}
@@ -2208,7 +2200,7 @@ void cmake::TruncateOutputLog(const char* fname)
{
return;
}
- if (!this->Configuration->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR"))
+ if ( !this->CacheManager->GetInitializedCacheValue("CMAKE_CACHEFILE_DIR") )
{
cmSystemTools::RemoveFile(fullPath);
return;
@@ -2326,7 +2318,7 @@ const char *cmake::GetProperty(const std::string& prop,
if ( prop == "CACHE_VARIABLES" )
{
std::vector<std::string> cacheKeys =
- this->Configuration->GetCacheEntryKeys();
+ this->CacheManager->GetCacheEntryKeys();
this->SetProperty("CACHE_VARIABLES", cmJoin(cacheKeys, ";").c_str());
}
else if ( prop == "COMMANDS" )
@@ -2479,7 +2471,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->Configuration->GetInitializedCacheValue("CMAKE_ROOT");
+ this->CacheManager->GetInitializedCacheValue("CMAKE_ROOT");
modulesPath += "/Modules";
std::string inFile = modulesPath;
inFile += "/SystemInformation.cmake";
@@ -2689,7 +2681,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->Configuration->GetCacheEntryValue(
+ const char* suppress = this->CacheManager->GetCacheEntryValue(
"CMAKE_SUPPRESS_DEVELOPER_WARNINGS");
if(suppress && cmSystemTools::IsOn(suppress))
{
@@ -2810,7 +2802,7 @@ int cmake::Build(const std::string& dir,
return 1;
}
const char* cachedGenerator =
- this->Configuration->GetCacheEntryValue("CMAKE_GENERATOR");
+ this->CacheManager->GetCacheEntryValue("CMAKE_GENERATOR");
if(!cachedGenerator)
{
std::cerr << "Error: could not find CMAKE_GENERATOR in Cache\n";
@@ -2827,7 +2819,7 @@ int cmake::Build(const std::string& dir,
std::string output;
std::string projName;
const char* cachedProjectName =
- this->Configuration->GetCacheEntryValue("CMAKE_PROJECT_NAME");
+ this->CacheManager->GetCacheEntryValue("CMAKE_PROJECT_NAME");
if(!cachedProjectName)
{
std::cerr << "Error: could not find CMAKE_PROJECT_NAME in Cache\n";
@@ -2836,7 +2828,7 @@ int cmake::Build(const std::string& dir,
projName = cachedProjectName;
bool verbose = false;
const char* cachedVerbose =
- this->Configuration->GetCacheEntryValue("CMAKE_VERBOSE_MAKEFILE");
+ this->CacheManager->GetCacheEntryValue("CMAKE_VERBOSE_MAKEFILE");
if(cachedVerbose)
{
verbose = cmSystemTools::IsOn(cachedVerbose);
diff --git a/Source/cmake.h b/Source/cmake.h
index 1debfeb..3acf4a8 100644
--- a/Source/cmake.h
+++ b/Source/cmake.h
@@ -19,7 +19,6 @@
#include "cmPropertyMap.h"
#include "cmInstalledFile.h"
#include "cmCacheManager.h"
-#include "cmConfiguration.h"
class cmGlobalGeneratorFactory;
class cmGlobalGenerator;
@@ -33,7 +32,6 @@ class cmDocumentationSection;
class cmPolicies;
class cmTarget;
class cmGeneratedFileStream;
-class cmConfiguration;
/** \brief Represents a cmake invocation.
*
@@ -179,7 +177,7 @@ class cmake
static bool ParseCacheEntry(const std::string& entry,
std::string& var,
std::string& value,
- cmConfiguration::CacheEntryType& type);
+ cmCacheManager::CacheEntryType& type);
int LoadCache();
bool LoadCache(const std::string& path);
@@ -389,9 +387,6 @@ 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();
@@ -480,8 +475,6 @@ private:
std::vector<std::string> DebugConfigs;
InstalledFilesMap InstalledFiles;
- cmConfiguration* Configuration;
-
void UpdateConversionPathTable();
};
diff --git a/Source/cmakemain.cxx b/Source/cmakemain.cxx
index 9ab49ee..3b518be 100644
--- a/Source/cmakemain.cxx
+++ b/Source/cmakemain.cxx
@@ -18,7 +18,7 @@
#include "cmake.h"
#include "cmcmd.h"
-#include "cmConfiguration.h"
+#include "cmCacheManager.h"
#include "cmListFileCache.h"
#include "cmSourceFile.h"
#include "cmGlobalGenerator.h"
@@ -330,28 +330,28 @@ int do_cmake(int ac, char const* const* av)
{
std::cout << "-- Cache values" << std::endl;
std::vector<std::string> keys =
- cm.GetConfiguration()->GetCacheEntryKeys();
+ cm.GetCacheManager()->GetCacheEntryKeys();
for (std::vector<std::string>::const_iterator it = keys.begin();
it != keys.end(); ++it)
{
- cmConfiguration::CacheEntryType t =
- cm.GetConfiguration()->GetCacheEntryType(*it);
- if ( t != cmConfiguration::INTERNAL && t != cmConfiguration::STATIC &&
- t != cmConfiguration::UNINITIALIZED )
+ cmCacheManager::CacheEntryType t =
+ cm.GetCacheManager()->GetCacheEntryType(*it);
+ if ( t != cmCacheManager::INTERNAL && t != cmCacheManager::STATIC &&
+ t != cmCacheManager::UNINITIALIZED )
{
const char* advancedProp =
- cm.GetConfiguration()->GetCacheEntryProperty(*it, "ADVANCED");
+ cm.GetCacheManager()->GetCacheEntryProperty(*it, "ADVANCED");
if ( list_all_cached || !advancedProp)
{
if ( list_help )
{
std::cout << "// "
- << cm.GetConfiguration()->GetCacheEntryProperty(*it,
+ << cm.GetCacheManager()->GetCacheEntryProperty(*it,
"HELPSTRING") << std::endl;
}
std::cout << *it << ":" <<
- cmConfiguration::CacheEntryTypeToString(t)
- << "=" << cm.GetConfiguration()->GetCacheEntryValue(*it)
+ cmCacheManager::TypeToString(t)
+ << "=" << cm.GetCacheManager()->GetCacheEntryValue(*it)
<< std::endl;
if ( list_help )
{
diff --git a/bootstrap b/bootstrap
index b8e9885..4239802 100755
--- a/bootstrap
+++ b/bootstrap
@@ -302,7 +302,6 @@ CMAKE_CXX_SOURCES="\
cmCommandsForBootstrap \
cmTarget \
cmTest \
- cmConfiguration \
cmCustomCommand \
cmCustomCommandGenerator \
cmCacheManager \
-----------------------------------------------------------------------
Summary of changes:
Source/CMakeLists.txt | 2 -
Source/CursesDialog/ccmake.cxx | 1 +
Source/CursesDialog/cmCursesBoolWidget.cxx | 2 +-
.../CursesDialog/cmCursesCacheEntryComposite.cxx | 17 +-
Source/CursesDialog/cmCursesCacheEntryComposite.h | 1 +
Source/CursesDialog/cmCursesDummyWidget.cxx | 2 +-
Source/CursesDialog/cmCursesFilePathWidget.cxx | 2 +-
Source/CursesDialog/cmCursesLongMessageForm.cxx | 1 +
Source/CursesDialog/cmCursesMainForm.cxx | 80 ++++-----
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 | 62 +++----
Source/cmBuildCommand.cxx | 2 +-
Source/cmBuildNameCommand.cxx | 4 +-
Source/cmCPluginAPI.cxx | 12 +-
Source/cmCTest.cxx | 2 +-
Source/cmCacheManager.cxx | 96 ++++++++---
Source/cmCacheManager.h | 36 +++--
Source/cmCommandArgumentParserHelper.cxx | 3 +-
Source/cmConfiguration.cxx | 170 --------------------
Source/cmConfiguration.h | 52 ------
Source/cmCoreTryCompile.cxx | 3 +-
Source/cmExtraEclipseCDT4Generator.cxx | 7 +-
Source/cmFindBase.cxx | 11 +-
Source/cmFindLibraryCommand.cxx | 7 +-
Source/cmFindPackageCommand.cxx | 2 +-
Source/cmFindPathCommand.cxx | 7 +-
Source/cmFindProgramCommand.cxx | 7 +-
Source/cmGetFilenameComponentCommand.cxx | 8 +-
Source/cmGetPropertyCommand.cxx | 5 +-
Source/cmGlobalGenerator.cxx | 19 ++-
Source/cmGlobalUnixMakefileGenerator3.cxx | 2 +-
Source/cmGlobalVisualStudio7Generator.cxx | 8 +-
Source/cmGlobalXCodeGenerator.cxx | 4 +-
Source/cmIncludeExternalMSProjectCommand.cxx | 2 +-
Source/cmLoadCacheCommand.cxx | 2 +-
Source/cmLocalVisualStudio10Generator.cxx | 2 +-
Source/cmLocalVisualStudio7Generator.cxx | 3 +-
Source/cmMakefile.cxx | 47 +++---
Source/cmMakefile.h | 6 +-
Source/cmMarkAsAdvancedCommand.cxx | 12 +-
Source/cmOptionCommand.cxx | 10 +-
Source/cmProjectCommand.cxx | 6 +-
Source/cmSetCommand.cxx | 14 +-
Source/cmSetPropertyCommand.cxx | 16 +-
Source/cmSiteNameCommand.cxx | 2 +-
Source/cmTarget.cxx | 4 +-
Source/cmTryRunCommand.cxx | 21 +--
Source/cmUtilitySourceCommand.cxx | 6 +-
Source/cmVariableRequiresCommand.cxx | 8 +-
Source/cmake.cxx | 122 +++++++-------
Source/cmake.h | 9 +-
Source/cmakemain.cxx | 20 +--
bootstrap | 1 -
57 files changed, 389 insertions(+), 577 deletions(-)
delete mode 100644 Source/cmConfiguration.cxx
delete mode 100644 Source/cmConfiguration.h
hooks/post-receive
--
CMake
More information about the Cmake-commits
mailing list