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