CMake/Source/cmCacheManager.cxx

988 lines
27 KiB
C++
Raw Normal View History

/*=========================================================================
Program: CMake - Cross-Platform Makefile Generator
Module: $RCSfile$
Language: C++
Date: $Date$
Version: $Revision$
Copyright (c) 2002 Kitware, Inc., Insight Consortium. All rights reserved.
See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
2006-03-10 21:06:26 +03:00
This software is distributed WITHOUT ANY WARRANTY; without even
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
2002-01-21 23:30:43 +03:00
PURPOSE. See the above copyright notices for more information.
=========================================================================*/
#include "cmCacheManager.h"
#include "cmSystemTools.h"
#include "cmCacheManager.h"
#include "cmMakefile.h"
#include "cmake.h"
#include "cmVersion.h"
#include <cmsys/Directory.hxx>
#include <cmsys/Glob.hxx>
#include <cmsys/RegularExpression.hxx>
#if defined(_WIN32) || defined(__CYGWIN__)
# include <windows.h>
#endif // _WIN32
2006-03-10 21:06:26 +03:00
const char* cmCacheManagerTypes[] =
{ "BOOL",
"PATH",
"FILEPATH",
"STRING",
2001-04-12 23:34:09 +04:00
"INTERNAL",
2001-05-16 23:15:21 +04:00
"STATIC",
"UNINITIALIZED",
0
};
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::LoadCache(cmMakefile* mf)
{
return this->LoadCache(mf->GetHomeOutputDirectory());
}
bool cmCacheManager::LoadCache(const char* path)
2001-05-09 01:04:22 +04:00
{
return this->LoadCache(path,true);
2001-05-09 01:04:22 +04:00
}
2001-05-09 01:04:22 +04:00
bool cmCacheManager::LoadCache(const char* path,
2002-10-04 22:01:22 +04:00
bool internal)
{
std::set<cmStdString> emptySet;
2001-08-16 19:41:44 +04:00
return this->LoadCache(path, internal, emptySet, emptySet);
}
2006-03-10 21:06:26 +03:00
bool cmCacheManager::ParseEntry(const char* entry,
std::string& var,
std::string& value)
{
// input line is: key:type=value
2006-03-10 21:06:26 +03:00
static cmsys::RegularExpression reg(
"^([^:]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$");
// input line is: "key":type=value
2006-03-10 21:06:26 +03:00
static cmsys::RegularExpression regQuoted(
"^\"([^\"]*)\"=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$");
bool flag = false;
if(regQuoted.find(entry))
{
var = regQuoted.match(1);
value = regQuoted.match(2);
flag = true;
}
else if (reg.find(entry))
{
var = reg.match(1);
value = reg.match(2);
flag = true;
}
// if value is enclosed in single quotes ('foo') then remove them
// it is used to enclose trailing space or tab
2006-03-10 21:06:26 +03:00
if (flag &&
value.size() >= 2 &&
2006-03-10 21:06:26 +03:00
value[0] == '\'' &&
value[value.size() - 1] == '\'')
{
2006-03-10 21:06:26 +03:00
value = value.substr(1,
value.size() - 2);
}
return flag;
}
2006-03-10 21:06:26 +03:00
bool cmCacheManager::ParseEntry(const char* entry,
std::string& var,
std::string& value,
CacheEntryType& type)
{
// input line is: key:type=value
2006-03-10 21:06:26 +03:00
static cmsys::RegularExpression reg(
"^([^:]*):([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$");
// input line is: "key":type=value
2006-03-10 21:06:26 +03:00
static cmsys::RegularExpression regQuoted(
"^\"([^\"]*)\":([^=]*)=(.*[^\r\t ]|[\r\t ]*)[\r\t ]*$");
2001-12-05 23:29:36 +03:00
bool flag = false;
if(regQuoted.find(entry))
{
var = regQuoted.match(1);
type = cmCacheManager::StringToType(regQuoted.match(2).c_str());
value = regQuoted.match(3);
2001-12-05 23:29:36 +03:00
flag = true;
}
else if (reg.find(entry))
{
var = reg.match(1);
type = cmCacheManager::StringToType(reg.match(2).c_str());
value = reg.match(3);
2001-12-05 23:29:36 +03:00
flag = true;
}
2001-12-05 23:29:36 +03:00
// if value is enclosed in single quotes ('foo') then remove them
// it is used to enclose trailing space or tab
2006-03-10 21:06:26 +03:00
if (flag &&
2001-12-05 23:29:36 +03:00
value.size() >= 2 &&
2006-03-10 21:06:26 +03:00
value[0] == '\'' &&
value[value.size() - 1] == '\'')
2001-12-05 23:29:36 +03:00
{
2006-03-10 21:06:26 +03:00
value = value.substr(1,
2001-12-05 23:29:36 +03:00
value.size() - 2);
}
return flag;
}
void cmCacheManager::CleanCMakeFiles(const char* path)
{
std::string glob = path;
glob += cmake::GetCMakeFilesDirectory();
glob += "/*.cmake";
cmsys::Glob globIt;
globIt.FindFiles(glob);
std::vector<std::string> files = globIt.GetFiles();
for(std::vector<std::string>::iterator i = files.begin();
i != files.end(); ++i)
{
cmSystemTools::RemoveFile(i->c_str());
}
}
bool cmCacheManager::LoadCache(const char* path,
2002-10-04 22:01:22 +04:00
bool internal,
std::set<cmStdString>& excludes,
std::set<cmStdString>& includes)
{
std::string cacheFile = path;
cacheFile += "/CMakeCache.txt";
// clear the old cache, if we are reading in internal values
if ( internal )
{
2006-03-15 19:02:08 +03:00
this->Cache.clear();
}
if(!cmSystemTools::FileExists(cacheFile.c_str()))
{
this->CleanCMakeFiles(path);
return false;
}
2006-03-10 21:06:26 +03:00
std::ifstream fin(cacheFile.c_str());
if(!fin)
{
return false;
}
const char *realbuffer;
std::string buffer;
std::string entryKey;
while(fin)
{
// Format is key:type=value
CacheEntry e;
cmSystemTools::GetLineFromStream(fin, buffer);
realbuffer = buffer.c_str();
while(*realbuffer != '0' &&
(*realbuffer == ' ' ||
*realbuffer == '\t' ||
*realbuffer == '\r' ||
*realbuffer == '\n'))
{
realbuffer++;
}
2001-02-23 03:24:43 +03:00
// skip blank lines and comment lines
if(realbuffer[0] == '#' || realbuffer[0] == 0)
{
2001-02-23 03:24:43 +03:00
continue;
}
while(realbuffer[0] == '/' && realbuffer[1] == '/')
2001-04-26 22:53:44 +04:00
{
if ((realbuffer[2] == '\\') && (realbuffer[3]=='n'))
{
e.Properties["HELPSTRING"] += "\n";
e.Properties["HELPSTRING"] += &realbuffer[4];
}
else
{
e.Properties["HELPSTRING"] += &realbuffer[2];
}
cmSystemTools::GetLineFromStream(fin, buffer);
realbuffer = buffer.c_str();
2001-04-26 22:53:44 +04:00
if(!fin)
{
continue;
}
}
2006-03-15 19:02:08 +03:00
if(cmCacheManager::ParseEntry(realbuffer, entryKey, e.Value, e.Type))
{
if ( excludes.find(entryKey) == excludes.end() )
2002-10-04 22:01:22 +04:00
{
// Load internal values if internal is set.
// 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.
2006-03-15 19:02:08 +03:00
if ( internal || (e.Type != INTERNAL) ||
2002-10-04 22:01:22 +04:00
(includes.find(entryKey) != includes.end()) )
{
// If we are loading the cache from another project,
// make all loaded entries internal so that it is
// not visible in the gui
if (!internal)
{
2006-03-15 19:02:08 +03:00
e.Type = INTERNAL;
e.Properties["HELPSTRING"] = "DO NOT EDIT, ";
e.Properties["HELPSTRING"] += entryKey;
e.Properties["HELPSTRING"] += " loaded from external file. "
"To change this value edit this file: ";
2006-03-15 19:02:08 +03:00
e.Properties["HELPSTRING"] += path;
e.Properties["HELPSTRING"] += "/CMakeCache.txt" ;
2002-10-04 22:01:22 +04:00
}
2006-03-15 19:02:08 +03:00
if ( e.Type == cmCacheManager::INTERNAL &&
(entryKey.size() > strlen("-ADVANCED")) &&
2006-03-10 21:06:26 +03:00
strcmp(entryKey.c_str() + (entryKey.size() -
strlen("-ADVANCED")), "-ADVANCED") == 0 )
{
2006-03-15 19:02:08 +03:00
std::string value = e.Value;
std::string akey =
entryKey.substr(0, (entryKey.size() - strlen("-ADVANCED")));
cmCacheManager::CacheIterator it =
this->GetCacheIterator(akey.c_str());
if ( it.IsAtEnd() )
{
2006-03-15 19:02:08 +03:00
e.Type = cmCacheManager::UNINITIALIZED;
this->Cache[akey] = e;
}
2002-10-04 22:01:22 +04:00
if (!it.Find(akey.c_str()))
{
cmSystemTools::Error("Internal CMake error when reading cache");
}
it.SetProperty("ADVANCED", value.c_str());
}
2006-03-15 19:02:08 +03:00
else if ( e.Type == cmCacheManager::INTERNAL &&
(entryKey.size() > strlen("-MODIFIED")) &&
2006-03-10 21:06:26 +03:00
strcmp(entryKey.c_str() + (entryKey.size() -
strlen("-MODIFIED")), "-MODIFIED") == 0 )
{
2006-03-15 19:02:08 +03:00
std::string value = e.Value;
std::string akey =
entryKey.substr(0, (entryKey.size() - strlen("-MODIFIED")));
cmCacheManager::CacheIterator it =
this->GetCacheIterator(akey.c_str());
if ( it.IsAtEnd() )
{
2006-03-15 19:02:08 +03:00
e.Type = cmCacheManager::UNINITIALIZED;
this->Cache[akey] = e;
}
if (!it.Find(akey.c_str()))
{
cmSystemTools::Error("Internal CMake error when reading cache");
}
it.SetProperty("MODIFIED", value.c_str());
}
else
{
2006-03-15 19:02:08 +03:00
e.Initialized = true;
this->Cache[entryKey] = e;
}
2002-10-04 22:01:22 +04:00
}
}
}
2001-02-23 03:24:43 +03:00
else
{
cmSystemTools::Error("Parse error in cache file ", cacheFile.c_str(),
2002-10-04 22:01:22 +04:00
". Offending entry: ", realbuffer);
}
}
this->CacheMajorVersion = 0;
this->CacheMinorVersion = 0;
if(const char* cmajor = this->GetCacheValue("CMAKE_CACHE_MAJOR_VERSION"))
{
unsigned int v=0;
if(sscanf(cmajor, "%u", &v) == 1)
{
this->CacheMajorVersion = v;
}
if(const char* cminor = this->GetCacheValue("CMAKE_CACHE_MINOR_VERSION"))
{
if(sscanf(cminor, "%u", &v) == 1)
{
this->CacheMinorVersion = v;
}
}
}
else
{
// CMake version not found in the list file.
// 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);
this->AddCacheEntry("CMAKE_CACHE_MAJOR_VERSION", "0",
"Major version of cmake used to create the "
"current loaded cache", cmCacheManager::INTERNAL);
2006-03-10 21:06:26 +03:00
}
// check to make sure the cache directory has not
// been moved
2001-11-01 18:42:07 +03:00
if ( internal && this->GetCacheValue("CMAKE_CACHEFILE_DIR") )
{
2001-11-01 18:42:07 +03:00
std::string currentcwd = path;
std::string oldcwd = this->GetCacheValue("CMAKE_CACHEFILE_DIR");
cmSystemTools::ConvertToUnixSlashes(currentcwd);
2001-11-22 01:45:01 +03:00
currentcwd += "/CMakeCache.txt";
oldcwd += "/CMakeCache.txt";
if(!cmSystemTools::SameFile(oldcwd.c_str(), currentcwd.c_str()))
2006-03-10 21:06:26 +03:00
{
std::string message =
2001-11-22 01:45:01 +03:00
std::string("The current CMakeCache.txt directory ") +
2006-03-10 21:06:26 +03:00
currentcwd + std::string(" is different than the directory ") +
2001-11-22 01:45:01 +03:00
std::string(this->GetCacheValue("CMAKE_CACHEFILE_DIR")) +
std::string(" where CMackeCache.txt was created. This may result "
"in binaries being created in the wrong place. If you "
"are not sure, reedit the CMakeCache.txt");
2006-03-10 21:06:26 +03:00
cmSystemTools::Error(message.c_str());
2001-11-01 18:42:07 +03:00
}
}
return true;
}
2006-03-10 21:06:26 +03:00
bool cmCacheManager::SaveCache(cmMakefile* mf)
{
return this->SaveCache(mf->GetHomeOutputDirectory());
}
2006-03-10 21:06:26 +03:00
bool cmCacheManager::SaveCache(const char* path)
{
std::string cacheFile = path;
cacheFile += "/CMakeCache.txt";
2001-02-23 03:24:43 +03:00
std::string tempFile = cacheFile;
tempFile += ".tmp";
std::ofstream fout(tempFile.c_str());
if(!fout)
2006-03-10 21:06:26 +03:00
{
cmSystemTools::Error("Unable to open cache file for save. ",
cacheFile.c_str());
cmSystemTools::ReportLastSystemError("");
return false;
}
2005-07-06 23:51:11 +04:00
// before writing the cache, update the version numbers
2006-03-10 21:06:26 +03:00
// to the
char temp[1024];
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);
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);
2006-03-10 21:06:26 +03:00
this->AddCacheEntry("CMAKE_CACHE_RELEASE_VERSION",
cmVersion::GetReleaseVersion().c_str(),
"Major version of cmake used to create the "
"current loaded cache", cmCacheManager::INTERNAL);
// Let us store the current working directory so that if somebody
// Copies it, he will not be surprised
std::string currentcwd = path;
if ( currentcwd[0] >= 'A' && currentcwd[0] <= 'Z' &&
currentcwd[1] == ':' )
{
currentcwd[0] = currentcwd[0] - 'A' + 'a';
}
cmSystemTools::ConvertToUnixSlashes(currentcwd);
this->AddCacheEntry("CMAKE_CACHEFILE_DIR", currentcwd.c_str(),
"This is the directory where this CMakeCahe.txt"
" was created", cmCacheManager::INTERNAL);
2001-02-23 03:24:43 +03:00
fout << "# This is the CMakeCache file.\n"
<< "# For build in directory: " << currentcwd << "\n";
2006-03-10 21:06:26 +03:00
cmCacheManager::CacheEntry* cmakeCacheEntry
= this->GetCacheEntry("CMAKE_COMMAND");
if ( cmakeCacheEntry )
{
2006-03-15 19:02:08 +03:00
fout << "# It was generated by CMake: " <<
cmakeCacheEntry->Value << std::endl;
}
2006-03-10 21:06:26 +03:00
fout << "# You can edit this file to change values found and used by cmake."
<< std::endl
<< "# If you do not want to change any of the values, simply exit the "
"editor." << std::endl
<< "# If you do want to change a value, simply edit, save, and exit "
"the editor." << std::endl
2001-02-23 03:24:43 +03:00
<< "# The syntax for the file is as follows:\n"
<< "# KEY:TYPE=VALUE\n"
2003-02-14 17:54:15 +03:00
<< "# KEY is the name of a variable in the cache.\n"
2006-03-10 21:06:26 +03:00
<< "# TYPE is a hint to GUI's for the type of VALUE, DO NOT EDIT "
"TYPE!." << std::endl
2001-02-23 03:24:43 +03:00
<< "# VALUE is the current value for the KEY.\n\n";
2001-05-11 22:49:46 +04:00
fout << "########################\n";
fout << "# EXTERNAL cache entries\n";
fout << "########################\n";
fout << "\n";
2006-05-10 21:56:27 +04:00
for( std::map<cmStdString, CacheEntry>::const_iterator i =
this->Cache.begin(); i != this->Cache.end(); ++i)
2001-05-08 02:11:16 +04:00
{
2006-03-15 19:02:08 +03:00
const CacheEntry& ce = (*i).second;
CacheEntryType t = ce.Type;
if(!ce.Initialized)
{
/*
2002-10-04 22:01:22 +04:00
// This should be added in, but is not for now.
2006-03-10 21:06:26 +03:00
cmSystemTools::Error("Cache entry \"", (*i).first.c_str(),
"\" is uninitialized");
*/
}
else if(t != INTERNAL)
2001-05-08 02:11:16 +04:00
{
// Format is key:type=value
2006-03-15 19:02:08 +03:00
std::map<cmStdString,cmStdString>::const_iterator it =
ce.Properties.find("HELPSTRING");
if ( it == ce.Properties.end() )
{
cmCacheManager::OutputHelpString(fout, "Missing description");
}
else
{
cmCacheManager::OutputHelpString(fout, it->second);
}
std::string key;
2006-03-10 21:06:26 +03:00
// support : in key name by double quoting
if((*i).first.find(':') != std::string::npos ||
2002-10-04 22:01:22 +04:00
(*i).first.find("//") == 0)
{
key = "\"";
key += i->first;
key += "\"";
}
else
{
key = i->first;
}
fout << key.c_str() << ":"
2001-12-05 23:29:36 +03:00
<< cmCacheManagerTypes[t] << "=";
// if value has trailing space or tab, enclose it in single quotes
2006-03-15 19:02:08 +03:00
if (ce.Value.size() &&
(ce.Value[ce.Value.size() - 1] == ' ' ||
ce.Value[ce.Value.size() - 1] == '\t'))
2001-12-05 23:29:36 +03:00
{
2006-03-15 19:02:08 +03:00
fout << '\'' << ce.Value << '\'';
2001-12-05 23:29:36 +03:00
}
else
{
2006-03-15 19:02:08 +03:00
fout << ce.Value;
2001-12-05 23:29:36 +03:00
}
fout << "\n\n";
2001-05-08 02:11:16 +04:00
}
}
2001-05-11 22:49:46 +04:00
fout << "\n";
fout << "########################\n";
fout << "# INTERNAL cache entries\n";
fout << "########################\n";
fout << "\n";
for( cmCacheManager::CacheIterator i = this->NewIterator();
!i.IsAtEnd(); i.Next())
{
if ( !i.Initialized() )
{
continue;
}
CacheEntryType t = i.GetType();
bool advanced = i.PropertyExists("ADVANCED");
if ( advanced )
2001-05-08 02:11:16 +04:00
{
// Format is key:type=value
std::string key;
std::string rkey = i.GetName();
std::string helpstring;
// If this is advanced variable, we have to do some magic for
// backward compatibility
helpstring = "Advanced flag for variable: ";
helpstring += i.GetName();
rkey += "-ADVANCED";
cmCacheManager::OutputHelpString(fout, helpstring.c_str());
2006-03-10 21:06:26 +03:00
// support : in key name by double quoting
if(rkey.find(':') != std::string::npos ||
rkey.find("//") == 0)
{
key = "\"";
key += rkey;
key += "\"";
}
else
{
key = rkey;
}
fout << key.c_str() << ":INTERNAL="
<< (i.GetPropertyAsBool("ADVANCED") ? "1" : "0") << "\n";
}
bool modified = i.PropertyExists("MODIFIED");
if ( modified )
{
// Format is key:type=value
std::string key;
std::string rkey = i.GetName();
std::string helpstring;
// If this is advanced variable, we have to do some magic for
// backward compatibility
helpstring = "Modified flag for variable: ";
helpstring += i.GetName();
rkey += "-MODIFIED";
cmCacheManager::OutputHelpString(fout, helpstring.c_str());
2006-03-10 21:06:26 +03:00
// support : in key name by double quoting
if(rkey.find(':') != std::string::npos ||
rkey.find("//") == 0)
{
key = "\"";
key += rkey;
key += "\"";
}
else
{
key = rkey;
}
fout << key.c_str() << ":INTERNAL="
<< (i.GetPropertyAsBool("MODIFIED") ? "1" : "0") << "\n";
}
if(t == cmCacheManager::INTERNAL)
{
// Format is key:type=value
std::string key;
std::string rkey = i.GetName();
std::string helpstring;
2002-09-12 19:13:22 +04:00
const char* hs = i.GetProperty("HELPSTRING");
2002-09-12 19:12:31 +04:00
if ( hs )
{
helpstring = i.GetProperty("HELPSTRING");
}
else
{
helpstring = "";
}
cmCacheManager::OutputHelpString(fout, helpstring.c_str());
2006-03-10 21:06:26 +03:00
// support : in key name by double quoting
if(rkey.find(':') != std::string::npos ||
rkey.find("//") == 0)
{
key = "\"";
key += rkey;
key += "\"";
}
else
{
key = rkey;
}
fout << key.c_str() << ":"
2001-12-05 23:29:36 +03:00
<< cmCacheManagerTypes[t] << "=";
// if value has trailing space or tab, enclose it in single quotes
std::string value = i.GetValue();
if (value.size() &&
2006-03-10 21:06:26 +03:00
(value[value.size() - 1] == ' ' ||
value[value.size() - 1] == '\t'))
2001-12-05 23:29:36 +03:00
{
fout << '\'' << value << '\'';
}
2001-12-05 23:29:36 +03:00
else
{
fout << value;
2001-12-05 23:29:36 +03:00
}
2006-03-10 21:06:26 +03:00
fout << "\n";
2001-05-08 02:11:16 +04:00
}
}
fout << "\n";
2001-02-23 03:24:43 +03:00
fout.close();
cmSystemTools::CopyFileIfDifferent(tempFile.c_str(),
cacheFile.c_str());
cmSystemTools::RemoveFile(tempFile.c_str());
std::string checkCacheFile = path;
checkCacheFile += cmake::GetCMakeFilesDirectory();
cmSystemTools::MakeDirectory(checkCacheFile.c_str());
checkCacheFile += "/cmake.check_cache";
std::ofstream checkCache(checkCacheFile.c_str());
if(!checkCache)
{
2006-03-10 21:06:26 +03:00
cmSystemTools::Error("Unable to open check cache file for write. ",
checkCacheFile.c_str());
return false;
2001-12-05 23:29:36 +03:00
}
2006-03-10 21:06:26 +03:00
checkCache << "# This file is generated by cmake for dependency checking "
"of the CMakeCache.txt file\n";
return true;
}
2006-03-10 21:06:26 +03:00
bool cmCacheManager::DeleteCache(const char* path)
2004-05-20 23:08:18 +04:00
{
std::string cacheFile = path;
cmSystemTools::ConvertToUnixSlashes(cacheFile);
std::string cmakeFiles = cacheFile;
2004-05-20 23:08:18 +04:00
cacheFile += "/CMakeCache.txt";
cmSystemTools::RemoveFile(cacheFile.c_str());
// now remove the files in the CMakeFiles directory
// this cleans up language cache files
cmsys::Directory dir;
cmakeFiles += cmake::GetCMakeFilesDirectory();
dir.Load(cmakeFiles.c_str());
2006-03-10 21:06:26 +03:00
for (unsigned long fileNum = 0;
fileNum < dir.GetNumberOfFiles();
++fileNum)
{
if(!cmSystemTools::
FileIsDirectory(dir.GetFile(fileNum)))
{
std::string fullPath = cmakeFiles;
fullPath += "/";
fullPath += dir.GetFile(fileNum);
cmSystemTools::RemoveFile(fullPath.c_str());
}
}
2004-05-20 23:08:18 +04:00
return true;
}
2006-03-10 21:06:26 +03:00
void cmCacheManager::OutputHelpString(std::ofstream& fout,
2001-04-26 22:53:44 +04:00
const std::string& helpString)
{
2001-04-26 22:53:44 +04:00
std::string::size_type end = helpString.size();
if(end == 0)
{
return;
}
std::string oneLine;
std::string::size_type pos = 0;
for (std::string::size_type i=0; i<=end; i++)
2001-04-26 22:53:44 +04:00
{
if ((i==end)
|| (helpString[i]=='\n')
|| ((i-pos >= 60) && (helpString[i]==' ')))
2001-04-26 22:53:44 +04:00
{
fout << "//";
if (helpString[pos] == '\n')
2001-04-26 22:53:44 +04:00
{
pos++;
fout << "\\n";
2001-04-26 22:53:44 +04:00
}
oneLine = helpString.substr(pos, i - pos);
fout << oneLine.c_str() << "\n";
pos = i;
2001-04-26 22:53:44 +04:00
}
}
}
2001-04-26 22:53:44 +04:00
void cmCacheManager::RemoveCacheEntry(const char* key)
{
2006-03-15 19:02:08 +03:00
CacheEntryMap::iterator i = this->Cache.find(key);
if(i != this->Cache.end())
{
2006-03-15 19:02:08 +03:00
this->Cache.erase(i);
}
2001-10-29 18:19:34 +03:00
else
{
std::cerr << "Failed to remove entry:" << key << std::endl;
}
}
2001-04-26 22:53:44 +04:00
2001-04-25 00:49:12 +04:00
cmCacheManager::CacheEntry *cmCacheManager::GetCacheEntry(const char* key)
{
2006-03-15 19:02:08 +03:00
CacheEntryMap::iterator i = this->Cache.find(key);
if(i != this->Cache.end())
{
return &i->second;
2001-04-25 00:49:12 +04:00
}
return 0;
}
2006-03-10 21:06:26 +03:00
cmCacheManager::CacheIterator cmCacheManager::GetCacheIterator(
const char *key)
{
return CacheIterator(*this, key);
}
2001-04-25 00:49:12 +04:00
const char* cmCacheManager::GetCacheValue(const char* key) const
{
2006-03-15 19:02:08 +03:00
CacheEntryMap::const_iterator i = this->Cache.find(key);
if(i != this->Cache.end() &&
i->second.Initialized)
2001-04-25 00:49:12 +04:00
{
2006-03-15 19:02:08 +03:00
return i->second.Value.c_str();
}
return 0;
}
2001-02-23 03:24:43 +03:00
2001-04-25 00:49:12 +04:00
void cmCacheManager::PrintCache(std::ostream& out) const
2001-02-23 03:24:43 +03:00
{
out << "=================================================" << std::endl;
out << "CMakeCache Contents:" << std::endl;
2006-05-10 21:56:27 +04:00
for(std::map<cmStdString, CacheEntry>::const_iterator i =
this->Cache.begin(); i != this->Cache.end(); ++i)
2001-02-23 03:24:43 +03:00
{
2006-03-15 19:02:08 +03:00
if((*i).second.Type != INTERNAL)
2001-05-08 02:11:16 +04:00
{
2006-03-15 19:02:08 +03:00
out << (*i).first.c_str() << " = " << (*i).second.Value.c_str()
<< std::endl;
2001-05-08 02:11:16 +04:00
}
2001-02-23 03:24:43 +03:00
}
out << "\n\n";
2006-03-10 21:06:26 +03:00
out << "To change values in the CMakeCache, "
<< std::endl << "edit CMakeCache.txt in your output directory.\n";
2001-02-23 03:24:43 +03:00
out << "=================================================" << std::endl;
}
2006-03-10 21:06:26 +03:00
void cmCacheManager::AddCacheEntry(const char* key,
const char* value,
2001-04-26 22:53:44 +04:00
const char* helpString,
2002-10-04 22:01:22 +04:00
CacheEntryType type)
2001-04-26 22:53:44 +04:00
{
2006-03-15 19:02:08 +03:00
CacheEntry& e = this->Cache[key];
if ( value )
{
2006-03-15 19:02:08 +03:00
e.Value = value;
e.Initialized = true;
}
2006-03-10 21:06:26 +03:00
else
{
2006-03-15 19:02:08 +03:00
e.Value = "";
}
2006-03-15 19:02:08 +03:00
e.Type = type;
// make sure we only use unix style paths
if(type == FILEPATH || type == PATH)
{
2006-03-15 19:02:08 +03:00
cmSystemTools::ConvertToUnixSlashes(e.Value);
}
if ( helpString )
{
2006-03-15 19:02:08 +03:00
e.Properties["HELPSTRING"] = helpString;
}
2006-03-10 21:06:26 +03:00
else
{
2006-03-15 19:02:08 +03:00
e.Properties["HELPSTRING"] =
2007-09-07 19:10:46 +04:00
"(This variable does not exist and should not be used)";
}
2006-03-15 19:02:08 +03:00
this->Cache[key] = e;
2001-04-26 22:53:44 +04:00
}
2006-03-10 21:06:26 +03:00
void cmCacheManager::AddCacheEntry(const char* key, bool v,
2001-04-26 22:53:44 +04:00
const char* helpString)
2001-04-24 20:40:37 +04:00
{
if(v)
{
2001-04-26 22:53:44 +04:00
this->AddCacheEntry(key, "ON", helpString, cmCacheManager::BOOL);
2001-04-24 20:40:37 +04:00
}
else
{
2001-04-26 22:53:44 +04:00
this->AddCacheEntry(key, "OFF", helpString, cmCacheManager::BOOL);
2001-04-24 20:40:37 +04:00
}
}
bool cmCacheManager::CacheIterator::IsAtEnd() const
{
2006-03-15 19:02:08 +03:00
return this->Position == this->Container.Cache.end();
}
2006-03-10 21:06:26 +03:00
void cmCacheManager::CacheIterator::Begin()
{
2006-03-15 19:02:08 +03:00
this->Position = this->Container.Cache.begin();
}
bool cmCacheManager::CacheIterator::Find(const char* key)
{
2006-03-15 19:02:08 +03:00
this->Position = this->Container.Cache.find(key);
return !this->IsAtEnd();
}
2006-03-10 21:06:26 +03:00
void cmCacheManager::CacheIterator::Next()
{
if (!this->IsAtEnd())
{
2006-03-15 19:02:08 +03:00
++this->Position;
}
}
void cmCacheManager::CacheIterator::SetValue(const char* value)
{
if (this->IsAtEnd())
{
return;
}
CacheEntry* entry = &this->GetEntry();
if ( value )
{
2006-03-15 19:02:08 +03:00
entry->Value = value;
entry->Initialized = true;
}
else
{
2006-03-15 19:02:08 +03:00
entry->Value = "";
}
}
2006-03-10 21:06:26 +03:00
const char* cmCacheManager::CacheIterator::GetProperty(
const char* property) const
{
// make sure it is not at the end
if (this->IsAtEnd())
{
return 0;
}
2002-09-11 22:08:39 +04:00
if ( !strcmp(property, "TYPE") || !strcmp(property, "VALUE") )
{
2006-03-10 21:06:26 +03:00
cmSystemTools::Error("Property \"", property,
"\" cannot be accessed through the GetProperty()");
return 0;
}
const CacheEntry* ent = &this->GetEntry();
2006-03-15 19:02:08 +03:00
std::map<cmStdString,cmStdString>::const_iterator it =
ent->Properties.find(property);
if ( it == ent->Properties.end() )
{
return 0;
}
return it->second.c_str();
}
2002-08-21 19:57:12 +04:00
2006-03-10 21:06:26 +03:00
void cmCacheManager::CacheIterator::SetProperty(const char* p, const char* v)
2002-08-21 19:57:12 +04:00
{
// make sure it is not at the end
if (this->IsAtEnd())
{
return;
}
2002-09-11 22:08:39 +04:00
if ( !strcmp(p, "TYPE") || !strcmp(p, "VALUE") )
{
2006-03-10 21:06:26 +03:00
cmSystemTools::Error("Property \"", p,
"\" cannot be accessed through the SetProperty()");
return;
}
CacheEntry* ent = &this->GetEntry();
2006-03-15 19:02:08 +03:00
ent->Properties[p] = v;
2002-08-21 19:57:12 +04:00
}
2006-03-15 19:02:08 +03:00
bool cmCacheManager::CacheIterator::GetValueAsBool() const
{
return cmSystemTools::IsOn(this->GetEntry().Value.c_str());
}
2006-03-10 21:06:26 +03:00
bool cmCacheManager::CacheIterator::GetPropertyAsBool(
const char* property) const
2002-08-21 19:57:12 +04:00
{
// make sure it is not at the end
if (this->IsAtEnd())
{
return false;
}
2006-03-10 21:06:26 +03:00
2002-09-11 22:08:39 +04:00
if ( !strcmp(property, "TYPE") || !strcmp(property, "VALUE") )
{
2006-03-10 21:06:26 +03:00
cmSystemTools::Error("Property \"", property,
"\" cannot be accessed through the GetPropertyAsBool()");
return false;
}
const CacheEntry* ent = &this->GetEntry();
2006-03-15 19:02:08 +03:00
std::map<cmStdString,cmStdString>::const_iterator it =
ent->Properties.find(property);
if ( it == ent->Properties.end() )
{
return false;
}
return cmSystemTools::IsOn(it->second.c_str());
2002-08-21 19:57:12 +04:00
}
2006-03-10 21:06:26 +03:00
void cmCacheManager::CacheIterator::SetProperty(const char* p, bool v)
2002-08-21 19:57:12 +04:00
{
// make sure it is not at the end
if (this->IsAtEnd())
{
return;
}
2002-09-11 22:08:39 +04:00
if ( !strcmp(p, "TYPE") || !strcmp(p, "VALUE") )
{
2006-03-10 21:06:26 +03:00
cmSystemTools::Error("Property \"", p,
"\" cannot be accessed through the SetProperty()");
return;
}
CacheEntry* ent = &this->GetEntry();
2006-03-15 19:02:08 +03:00
ent->Properties[p] = v ? "ON" : "OFF";
2002-08-21 19:57:12 +04:00
}
bool cmCacheManager::CacheIterator::PropertyExists(const char* property) const
{
// make sure it is not at the end
if (this->IsAtEnd())
{
return false;
}
if ( !strcmp(property, "TYPE") || !strcmp(property, "VALUE") )
{
2006-03-10 21:06:26 +03:00
cmSystemTools::Error("Property \"", property,
"\" cannot be accessed through the PropertyExists()");
return false;
}
const CacheEntry* ent = &this->GetEntry();
2006-03-15 19:02:08 +03:00
std::map<cmStdString,cmStdString>::const_iterator it =
ent->Properties.find(property);
if ( it == ent->Properties.end() )
{
return false;
}
return true;
}
//----------------------------------------------------------------------------
bool cmCacheManager::NeedCacheCompatibility(int major, int minor)
{
// Compatibility is not needed if the cache version is zero because
// the cache was created or modified by the user.
if(this->CacheMajorVersion == 0)
{
return false;
}
// Compatibility is needed if the cache version is equal to or lower
// than the given version.
unsigned int actual_compat =
CMake_VERSION_ENCODE(this->CacheMajorVersion, this->CacheMinorVersion, 0);
return (actual_compat &&
actual_compat <= CMake_VERSION_ENCODE(major, minor, 0));
}