Commit 15a8af21 authored by Nils Gladitz's avatar Nils Gladitz Committed by Brad King
Browse files

Add an "installed file" property scope

Teach set_property and get_property an "INSTALL" property type to be
associated with install-tree file paths.  Make the properties available
to CPack for use during packaging.  Add a "prop_inst" Sphinx domain
object type for documentation of such properties.
parent 032961c6
......@@ -331,10 +331,10 @@ documentation:
See the :manual:`cmake-policies(7)` manual
and the :command:`cmake_policy` command.
``prop_cache, prop_dir, prop_gbl, prop_sf, prop_test, prop_tgt``
A CMake cache, directory, global, source file, test, or target
property, respectively. See the :manual:`cmake-properties(7)` manual
and the :command:`set_property` command.
``prop_cache, prop_dir, prop_gbl, prop_sf, prop_inst, prop_test, prop_tgt``
A CMake cache, directory, global, source file, installed file, test,
or target property, respectively. See the :manual:`cmake-properties(7)`
manual and the :command:`set_property` command.
``variable``
A CMake language variable.
......
......@@ -302,3 +302,9 @@ Properties on Cache Entries
/prop_cache/STRINGS
/prop_cache/TYPE
/prop_cache/VALUE
Properties on Installed Files
=============================
.. toctree::
:maxdepth: 1
......@@ -163,6 +163,8 @@ set(SRCS
cmComputeLinkInformation.h
cmComputeTargetDepends.h
cmComputeTargetDepends.cxx
cmCPackPropertiesGenerator.h
cmCPackPropertiesGenerator.cxx
cmCryptoHash.cxx
cmCryptoHash.h
cmCustomCommand.cxx
......@@ -243,6 +245,8 @@ set(SRCS
cmInstallGenerator.h
cmInstallGenerator.cxx
cmInstallExportGenerator.cxx
cmInstalledFile.h
cmInstalledFile.cxx
cmInstallFilesGenerator.h
cmInstallFilesGenerator.cxx
cmInstallScriptGenerator.h
......
......@@ -1313,6 +1313,14 @@ int cmCPackGenerator::CleanTemporaryDirectory()
return 1;
}
//----------------------------------------------------------------------
cmInstalledFile const* cmCPackGenerator::GetInstalledFile(
std::string const& name) const
{
cmake const* cm = this->MakefileMap->GetCMakeInstance();
return cm->GetInstalledFile(name);
}
//----------------------------------------------------------------------
int cmCPackGenerator::PrepareGroupingKind()
{
......
......@@ -47,6 +47,7 @@
class cmMakefile;
class cmCPackLog;
class cmInstalledFile;
/** \class cmCPackGenerator
* \brief A superclass of all CPack Generators
......@@ -129,6 +130,8 @@ protected:
int CleanTemporaryDirectory();
cmInstalledFile const* GetInstalledFile(std::string const& name) const;
virtual const char* GetOutputExtension() { return ".cpack"; }
virtual const char* GetOutputPostfix() { return 0; }
......
......@@ -257,6 +257,11 @@ int main (int argc, char const* const* argv)
return 1;
}
if ( !cpackBuildConfig.empty() )
{
globalMF->AddDefinition("CPACK_BUILD_CONFIG", cpackBuildConfig.c_str());
}
if ( cmSystemTools::FileExists(cpackConfigFile.c_str()) )
{
cpackConfigFile =
......@@ -317,10 +322,6 @@ int main (int argc, char const* const* argv)
cpackProjectDirectory.c_str());
}
}
if ( !cpackBuildConfig.empty() )
{
globalMF->AddDefinition("CPACK_BUILD_CONFIG", cpackBuildConfig.c_str());
}
cpackDefinitions::MapType::iterator cdit;
for ( cdit = definitions.Map.begin();
cdit != definitions.Map.end();
......
#include "cmCPackPropertiesGenerator.h"
#include "cmLocalGenerator.h"
cmCPackPropertiesGenerator::cmCPackPropertiesGenerator(
cmMakefile* mf,
cmInstalledFile const& installedFile,
std::vector<std::string> const& configurations):
cmScriptGenerator("CPACK_BUILD_CONFIG", configurations),
Makefile(mf),
InstalledFile(installedFile)
{
this->ActionsPerConfig = true;
}
void cmCPackPropertiesGenerator::GenerateScriptForConfig(std::ostream& os,
const std::string& config, Indent const& indent)
{
std::string const& expandedFileName =
this->InstalledFile.GetNameExpression().Evaluate(this->Makefile, config);
cmInstalledFile::PropertyMapType const& properties =
this->InstalledFile.GetProperties();
for(cmInstalledFile::PropertyMapType::const_iterator i = properties.begin();
i != properties.end(); ++i)
{
std::string const& name = i->first;
cmInstalledFile::Property const& property = i->second;
os << indent << "set_property(INSTALL " <<
cmLocalGenerator::EscapeForCMake(expandedFileName) << " PROPERTY " <<
cmLocalGenerator::EscapeForCMake(name);
for(cmInstalledFile::ExpressionVectorType::const_iterator
j = property.ValueExpressions.begin();
j != property.ValueExpressions.end(); ++j)
{
std::string value = (*j)->Evaluate(this->Makefile, config);
os << " " << cmLocalGenerator::EscapeForCMake(value);
}
os << ")\n";
}
}
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2014 Kitware, Inc., Insight Software Consortium
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 cmCPackPropertiesGenerator_h
#define cmCPackPropertiesGenerator_h
#include "cmScriptGenerator.h"
#include "cmInstalledFile.h"
/** \class cmCPackPropertiesGenerator
* \brief Support class for generating CPackProperties.cmake.
*
*/
class cmCPackPropertiesGenerator: public cmScriptGenerator
{
public:
cmCPackPropertiesGenerator(
cmMakefile* mf,
cmInstalledFile const& installedFile,
std::vector<std::string> const& configurations);
protected:
virtual void GenerateScriptForConfig(std::ostream& os,
const std::string& config, Indent const& indent);
cmMakefile* Makefile;
cmInstalledFile const& InstalledFile;
};
#endif
......@@ -67,12 +67,16 @@ bool cmGetPropertyCommand
{
scope = cmProperty::CACHE;
}
else if(args[1] == "INSTALL")
{
scope = cmProperty::INSTALL;
}
else
{
cmOStringStream e;
e << "given invalid scope " << args[1] << ". "
<< "Valid scopes are "
<< "GLOBAL, DIRECTORY, TARGET, SOURCE, TEST, VARIABLE, CACHE.";
<< "GLOBAL, DIRECTORY, TARGET, SOURCE, TEST, VARIABLE, CACHE, INSTALL.";
this->SetError(e.str());
return false;
}
......@@ -190,6 +194,7 @@ bool cmGetPropertyCommand
case cmProperty::TEST: return this->HandleTestMode();
case cmProperty::VARIABLE: return this->HandleVariableMode();
case cmProperty::CACHE: return this->HandleCacheMode();
case cmProperty::INSTALL: return this->HandleInstallMode();
case cmProperty::CACHED_VARIABLE:
break; // should never happen
......@@ -395,3 +400,33 @@ bool cmGetPropertyCommand::HandleCacheMode()
this->StoreResult(value);
return true;
}
//----------------------------------------------------------------------------
bool cmGetPropertyCommand::HandleInstallMode()
{
if(this->Name.empty())
{
this->SetError("not given name for INSTALL scope.");
return false;
}
// Get the installed file.
cmake* cm = this->Makefile->GetCMakeInstance();
if(cmInstalledFile* file = cm->GetOrCreateInstalledFile(
this->Makefile, this->Name))
{
std::string value;
bool isSet = file->GetProperty(this->PropertyName, value);
return this->StoreResult(isSet ? value.c_str() : 0);
}
else
{
cmOStringStream e;
e << "given INSTALL name that could not be found or created: "
<< this->Name;
this->SetError(e.str());
return false;
}
}
......@@ -60,6 +60,7 @@ private:
bool HandleTestMode();
bool HandleVariableMode();
bool HandleCacheMode();
bool HandleInstallMode();
};
#endif
......@@ -28,6 +28,7 @@
#include "cmGeneratorExpression.h"
#include "cmGeneratorExpressionEvaluationFile.h"
#include "cmExportBuildFileGenerator.h"
#include "cmCPackPropertiesGenerator.h"
#include <cmsys/Directory.hxx>
#include <cmsys/FStream.hxx>
......@@ -1269,6 +1270,13 @@ void cmGlobalGenerator::Generate()
}
this->SetCurrentLocalGenerator(0);
if(!this->GenerateCPackPropertiesFile())
{
this->GetCMakeInstance()->IssueMessage(
cmake::FATAL_ERROR, "Could not write CPack properties file.",
cmListFileBacktrace());
}
for (std::map<std::string, cmExportBuildFileGenerator*>::iterator
it = this->BuildExportSets.begin(); it != this->BuildExportSets.end();
++it)
......@@ -3014,3 +3022,39 @@ std::string cmGlobalGenerator::ExpandCFGIntDir(const std::string& str,
{
return str;
}
//----------------------------------------------------------------------------
bool cmGlobalGenerator::GenerateCPackPropertiesFile()
{
cmake::InstalledFilesMap const& installedFiles =
this->CMakeInstance->GetInstalledFiles();
cmMakefile* mf = this->LocalGenerators[0]->GetMakefile();
std::vector<std::string> configs;
std::string config = mf->GetConfigurations(configs, false);
std::string path = this->CMakeInstance->GetStartOutputDirectory();
path += "/CPackProperties.cmake";
if(!cmSystemTools::FileExists(path.c_str()) && installedFiles.empty())
{
return true;
}
cmGeneratedFileStream file(path.c_str());
file << "# CPack properties\n";
for(cmake::InstalledFilesMap::const_iterator i = installedFiles.begin();
i != installedFiles.end(); ++i)
{
cmInstalledFile const& installedFile = i->second;
cmCPackPropertiesGenerator cpackPropertiesGenerator(
mf, installedFile, configs);
cpackPropertiesGenerator.Generate(file, config, configs);
}
return true;
}
......@@ -329,6 +329,8 @@ public:
virtual void ComputeTargetObjectDirectory(cmGeneratorTarget* gt) const;
bool GenerateCPackPropertiesFile();
protected:
typedef std::vector<cmLocalGenerator*> GeneratorVector;
// for a project collect all its targets by following depend
......
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2014 Kitware, Inc., Insight Software Consortium
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 "cmInstalledFile.h"
#include "cmSystemTools.h"
#include "cmMakefile.h"
//----------------------------------------------------------------------------
cmInstalledFile::cmInstalledFile():
NameExpression(0)
{
}
//----------------------------------------------------------------------------
cmInstalledFile::~cmInstalledFile()
{
if(NameExpression)
{
delete NameExpression;
}
}
//----------------------------------------------------------------------------
void cmInstalledFile::SetName(cmMakefile* mf, const std::string& name)
{
cmListFileBacktrace backtrace;
mf->GetBacktrace(backtrace);
cmGeneratorExpression ge(backtrace);
this->Name = name;
this->NameExpression = ge.Parse(name).release();
}
//----------------------------------------------------------------------------
std::string const& cmInstalledFile::GetName() const
{
return this->Name;
}
//----------------------------------------------------------------------------
cmCompiledGeneratorExpression const& cmInstalledFile::GetNameExpression() const
{
return *(this->NameExpression);
}
//----------------------------------------------------------------------------
void cmInstalledFile::RemoveProperty(const std::string& prop)
{
this->Properties.erase(prop);
}
//----------------------------------------------------------------------------
void cmInstalledFile::SetProperty(cmMakefile const* mf,
const std::string& prop, const char* value)
{
this->RemoveProperty(prop);
this->AppendProperty(mf, prop, value);
}
//----------------------------------------------------------------------------
void cmInstalledFile::AppendProperty(cmMakefile const* mf,
const std::string& prop, const char* value, bool /*asString*/)
{
cmListFileBacktrace backtrace;
mf->GetBacktrace(backtrace);
cmGeneratorExpression ge(backtrace);
Property& property = this->Properties[prop];
property.ValueExpressions.push_back(ge.Parse(value).release());
}
//----------------------------------------------------------------------------
bool cmInstalledFile::GetProperty(
const std::string& prop, std::string& value) const
{
PropertyMapType::const_iterator i = this->Properties.find(prop);
if(i == this->Properties.end())
{
return false;
}
Property const& property = i->second;
std::string output;
std::string separator;
for(ExpressionVectorType::const_iterator
j = property.ValueExpressions.begin();
j != property.ValueExpressions.end(); ++j)
{
output += separator;
output += (*j)->GetInput();
separator = ";";
}
value = output;
return true;
}
//----------------------------------------------------------------------------
bool cmInstalledFile::GetPropertyAsBool(const std::string& prop) const
{
std::string value;
bool isSet = this->GetProperty(prop, value);
return isSet && cmSystemTools::IsOn(value.c_str());
}
/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2014 Kitware, Inc., Insight Software Consortium
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 cmInstalledFile_h
#define cmInstalledFile_h
#include "cmGeneratorExpression.h"
/** \class cmInstalledFile
* \brief Represents a file intended for installation.
*
* cmInstalledFile represents a file intended for installation.
*/
class cmInstalledFile
{
public:
typedef cmsys::auto_ptr<cmCompiledGeneratorExpression>
CompiledGeneratorExpressionPtrType;
typedef std::vector<cmCompiledGeneratorExpression*>
ExpressionVectorType;
struct Property
{
Property()
{
}
~Property()
{
for(ExpressionVectorType::iterator i = ValueExpressions.begin();
i != ValueExpressions.end(); ++i)
{
delete *i;
}
}
ExpressionVectorType ValueExpressions;
};
typedef std::map<std::string, Property> PropertyMapType;
cmInstalledFile();
~cmInstalledFile();
void RemoveProperty(const std::string& prop);
void SetProperty(cmMakefile const* mf,
const std::string& prop, const char *value);
void AppendProperty(cmMakefile const* mf,
const std::string& prop, const char* value,bool asString=false);
bool GetProperty(const std::string& prop, std::string& value) const;
bool GetPropertyAsBool(const std::string& prop) const;
void SetName(cmMakefile* mf, const std::string& name);
std::string const& GetName() const;
cmCompiledGeneratorExpression const& GetNameExpression() const;
PropertyMapType const& GetProperties() const { return this->Properties; }
private:
std::string Name;
cmCompiledGeneratorExpression* NameExpression;
PropertyMapType Properties;
};
#endif
......@@ -18,7 +18,7 @@ class cmProperty
{
public:
enum ScopeType { TARGET, SOURCE_FILE, DIRECTORY, GLOBAL, CACHE,
TEST, VARIABLE, CACHED_VARIABLE };
TEST, VARIABLE, CACHED_VARIABLE, INSTALL };
// set this property
void Set(const std::string& name, const char *value);
......
......@@ -39,7 +39,8 @@ cmRST::cmRST(std::ostream& os, std::string const& docroot):
ModuleRST("^#\\[(=*)\\[\\.rst:$"),
CMakeRole("(:cmake)?:("
"command|generator|variable|module|policy|"
"prop_cache|prop_dir|prop_gbl|prop_sf|prop_test|prop_tgt|"
"prop_cache|prop_dir|prop_gbl|prop_inst|prop_sf|"
"prop_test|prop_tgt|"
"manual"
"):`(<*([^`<]|[^` \t]<)*)([ \t]+<[^`]*>)?`"),
Substitution("(^|[^A-Za-z0-9_])"
......
......@@ -61,11 +61,16 @@ bool cmSetPropertyCommand
{
scope = cmProperty::CACHE;
}
else if(*arg == "INSTALL")
{
scope = cmProperty::INSTALL;
}
else
{
cmOStringStream e;
e << "given invalid scope " << *arg << ". "
<< "Valid scopes are GLOBAL, DIRECTORY, TARGET, SOURCE, TEST, CACHE.";
<< "Valid scopes are GLOBAL, DIRECTORY, "
"TARGET, SOURCE, TEST, CACHE, INSTALL.";
this->SetError(e.str());
return false;
}
......@@ -135,6 +140,7 @@ bool cmSetPropertyCommand
case cmProperty::SOURCE_FILE: return this->HandleSourceMode();
case cmProperty::TEST: return this->HandleTestMode();
case cmProperty::CACHE: return this->HandleCacheMode();
case cmProperty::INSTALL: return this->HandleInstallMode();
case cmProperty::VARIABLE:
case cmProperty::CACHED_VARIABLE:
......@@ -488,3 +494,54 @@ bool cmSetPropertyCommand::HandleCacheEntry(cmCacheManager::CacheIterator& it)
return true;
}
//----------------------------------------------------------------------------
bool cmSetPropertyCommand::HandleInstallMode()
{
cmake* cm = this->Makefile->GetCMakeInstance();
for(std::set<std::string>::const_iterator i = this->Names.begin();
i != this->Names.end(); ++i)
{
if(cmInstalledFile* file = cm->GetOrCreateInstalledFile(
this->Makefile, *i))
{
if(!this->HandleInstall(file))
{
return false;
}
}
else
{
cmOStringStream e;
e << "given INSTALL name that could not be found or created: " << *i;
this->SetError(e.str());
return false;
}
}
return true;
}
//----------------------------------------------------------------------------
bool cmSetPropertyCommand::HandleInstall(cmInstalledFile* file)
{
// Set or append the property.
std::string const& name = this->PropertyName;
cmMakefile* mf = this->Makefile;
const char *value = this->PropertyValue.c_str();
if (this->Remove)