ENH: Further cleanup of installation script generation. The per-component and per-configuration testing is now done in cmake code instead of in the FILE(INSTALL) command. The generation of the cmake code to do these tests is centralized in cmInstallGenerator. Old-style shared library versioning and component/config support code has been removed from FILE(INSTALL). This commit is surrounded by the tags CMake-InstallGeneratorCleanup2-pre and CMake-InstallGeneratorCleanup2-post.

This commit is contained in:
Brad King 2007-07-02 14:56:57 -04:00
parent fda7753f5c
commit 7f29f8966d
14 changed files with 222 additions and 336 deletions

View File

@ -1241,20 +1241,17 @@ bool cmFileCommand::HandleInstallCommand(std::vector<std::string> const& args)
std::string rename = ""; std::string rename = "";
std::string destination = ""; std::string destination = "";
std::set<cmStdString> components;
std::set<cmStdString> configurations;
std::vector<std::string> files; std::vector<std::string> files;
int itype = cmTarget::INSTALL_FILES; int itype = cmTarget::INSTALL_FILES;
std::map<cmStdString, const char*> properties; std::map<cmStdString, const char*> properties;
bool optional = false; bool optional = false;
bool result = this->ParseInstallArgs(args, installer, components, bool result = this->ParseInstallArgs(args, installer, properties,
configurations, properties,
itype, rename, destination, files, itype, rename, destination, files,
optional); optional);
if (result == true) if (result == true)
{ {
result = this->DoInstall(installer, components, configurations, properties, result = this->DoInstall(installer, properties,
itype, rename, destination, files, optional); itype, rename, destination, files, optional);
} }
return result; return result;
@ -1263,8 +1260,6 @@ bool cmFileCommand::HandleInstallCommand(std::vector<std::string> const& args)
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args, bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
cmFileInstaller& installer, cmFileInstaller& installer,
std::set<cmStdString>& components,
std::set<cmStdString>& configurations,
std::map<cmStdString, const char*>& properties, std::map<cmStdString, const char*>& properties,
int& itype, int& itype,
std::string& rename, std::string& rename,
@ -1278,8 +1273,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
bool doing_permissions_file = false; bool doing_permissions_file = false;
bool doing_permissions_dir = false; bool doing_permissions_dir = false;
bool doing_permissions_match = false; bool doing_permissions_match = false;
bool doing_components = false;
bool doing_configurations = false;
bool use_given_permissions_file = false; bool use_given_permissions_file = false;
bool use_given_permissions_dir = false; bool use_given_permissions_dir = false;
bool use_source_permissions = false; bool use_source_permissions = false;
@ -1308,8 +1301,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
doing_properties = false; doing_properties = false;
doing_permissions_file = false; doing_permissions_file = false;
doing_permissions_dir = false; doing_permissions_dir = false;
doing_components = false;
doing_configurations = false;
} }
else if ( *cstr == "TYPE" && i < args.size()-1 ) else if ( *cstr == "TYPE" && i < args.size()-1 )
{ {
@ -1332,8 +1323,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
doing_files = false; doing_files = false;
doing_permissions_file = false; doing_permissions_file = false;
doing_permissions_dir = false; doing_permissions_dir = false;
doing_components = false;
doing_configurations = false;
} }
else if ( *cstr == "RENAME" && i < args.size()-1 ) else if ( *cstr == "RENAME" && i < args.size()-1 )
{ {
@ -1351,8 +1340,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
doing_files = false; doing_files = false;
doing_permissions_file = false; doing_permissions_file = false;
doing_permissions_dir = false; doing_permissions_dir = false;
doing_components = false;
doing_configurations = false;
} }
else if ( *cstr == "REGEX" && i < args.size()-1 ) else if ( *cstr == "REGEX" && i < args.size()-1 )
{ {
@ -1370,8 +1357,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
doing_files = false; doing_files = false;
doing_permissions_file = false; doing_permissions_file = false;
doing_permissions_dir = false; doing_permissions_dir = false;
doing_components = false;
doing_configurations = false;
} }
else if ( *cstr == "EXCLUDE" ) else if ( *cstr == "EXCLUDE" )
{ {
@ -1401,8 +1386,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
doing_files = false; doing_files = false;
doing_permissions_file = false; doing_permissions_file = false;
doing_permissions_dir = false; doing_permissions_dir = false;
doing_components = false;
doing_configurations = false;
} }
else if ( *cstr == "PERMISSIONS" ) else if ( *cstr == "PERMISSIONS" )
{ {
@ -1420,8 +1403,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
doing_properties = false; doing_properties = false;
doing_files = false; doing_files = false;
doing_permissions_dir = false; doing_permissions_dir = false;
doing_components = false;
doing_configurations = false;
} }
else if ( *cstr == "DIR_PERMISSIONS" ) else if ( *cstr == "DIR_PERMISSIONS" )
{ {
@ -1438,8 +1419,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
doing_files = false; doing_files = false;
doing_permissions_file = false; doing_permissions_file = false;
doing_permissions_dir = true; doing_permissions_dir = true;
doing_components = false;
doing_configurations = false;
} }
else if ( *cstr == "USE_SOURCE_PERMISSIONS" ) else if ( *cstr == "USE_SOURCE_PERMISSIONS" )
{ {
@ -1455,43 +1434,25 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
doing_files = false; doing_files = false;
doing_permissions_file = false; doing_permissions_file = false;
doing_permissions_dir = false; doing_permissions_dir = false;
doing_components = false;
doing_configurations = false;
use_source_permissions = true; use_source_permissions = true;
} }
else if ( *cstr == "COMPONENTS" ) else if ( *cstr == "COMPONENTS" )
{ {
if(current_match_rule) cmOStringStream e;
{ e << "INSTALL called with old-style COMPONENTS argument. "
cmOStringStream e; << "This script was generated with an older version of CMake. "
e << "INSTALL does not allow \"" << *cstr << "\" after REGEX."; << "Re-run this cmake version on your build tree.";
this->SetError(e.str().c_str()); this->SetError(e.str().c_str());
return false; return false;
}
doing_properties = false;
doing_files = false;
doing_permissions_file = false;
doing_permissions_dir = false;
doing_components = true;
doing_configurations = false;
} }
else if ( *cstr == "CONFIGURATIONS" ) else if ( *cstr == "CONFIGURATIONS" )
{ {
if(current_match_rule) cmOStringStream e;
{ e << "INSTALL called with old-style CONFIGURATIONS argument. "
cmOStringStream e; << "This script was generated with an older version of CMake. "
e << "INSTALL does not allow \"" << *cstr << "\" after REGEX."; << "Re-run this cmake version on your build tree.";
this->SetError(e.str().c_str()); this->SetError(e.str().c_str());
return false; return false;
}
doing_properties = false;
doing_files = false;
doing_permissions_file = false;
doing_permissions_dir = false;
doing_components = false;
doing_configurations = true;
} }
else if ( *cstr == "FILES" && !doing_files) else if ( *cstr == "FILES" && !doing_files)
{ {
@ -1507,8 +1468,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
doing_properties = false; doing_properties = false;
doing_permissions_file = false; doing_permissions_file = false;
doing_permissions_dir = false; doing_permissions_dir = false;
doing_components = false;
doing_configurations = false;
} }
else if ( doing_properties && i < args.size()-1 ) else if ( doing_properties && i < args.size()-1 )
{ {
@ -1519,14 +1478,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
{ {
files.push_back(*cstr); files.push_back(*cstr);
} }
else if ( doing_components )
{
components.insert(*cstr);
}
else if ( doing_configurations )
{
configurations.insert(cmSystemTools::UpperCase(*cstr));
}
else if(doing_permissions_file) else if(doing_permissions_file)
{ {
if(!installer.CheckPermissions(args[i], permissions_file)) if(!installer.CheckPermissions(args[i], permissions_file))
@ -1587,6 +1538,25 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
return false; return false;
} }
if(properties.find("VERSION") != properties.end())
{
cmOStringStream e;
e << "INSTALL called with old-style VERSION property. "
<< "This script was generated with an older version of CMake. "
<< "Re-run this cmake version on your build tree.";
this->SetError(e.str().c_str());
return false;
}
if(properties.find("SOVERSION") != properties.end())
{
cmOStringStream e;
e << "INSTALL called with old-style SOVERSION property. "
<< "This script was generated with an older version of CMake. "
<< "Re-run this cmake version on your build tree.";
this->SetError(e.str().c_str());
return false;
}
this->GetTargetTypeFromString(stype, itype); this->GetTargetTypeFromString(stype, itype);
this->HandleInstallPermissions(installer, this->HandleInstallPermissions(installer,
@ -1602,8 +1572,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
bool cmFileCommand::DoInstall( cmFileInstaller& installer, bool cmFileCommand::DoInstall( cmFileInstaller& installer,
const std::set<cmStdString>& components,
const std::set<cmStdString>& configurations,
std::map<cmStdString, const char*>& properties, std::map<cmStdString, const char*>& properties,
const int itype, const int itype,
const std::string& rename, const std::string& rename,
@ -1612,38 +1580,6 @@ bool cmFileCommand::DoInstall( cmFileInstaller& installer,
const bool optional) const bool optional)
{ {
typedef std::set<cmStdString>::const_iterator iter_type; typedef std::set<cmStdString>::const_iterator iter_type;
// Check for component-specific installation.
const char* cmake_install_component =
this->Makefile->GetDefinition("CMAKE_INSTALL_COMPONENT");
if(cmake_install_component && *cmake_install_component)
{
// This install rule applies only if it is associated with the
// current component.
if(iter_type(components.find(cmake_install_component)) ==
components.end())
{
return true;
}
}
// Check for configuration-specific installation.
if(!configurations.empty())
{
std::string cmake_install_configuration = cmSystemTools::UpperCase(
this->Makefile->GetSafeDefinition("CMAKE_INSTALL_CONFIG_NAME"));
if(cmake_install_configuration.empty())
{
// No configuration specified for installation but this install
// rule is configuration-specific. Skip it.
return true;
}
else if(iter_type(configurations.find(cmake_install_configuration)) ==
configurations.end())
{
// This rule is specific to a configuration not being installed.
return true;
}
}
// Check whether files should be copied always or only if they have // Check whether files should be copied always or only if they have
// changed. // changed.
@ -1669,97 +1605,6 @@ bool cmFileCommand::DoInstall( cmFileInstaller& installer,
toFile += toName; toFile += toName;
} }
// Handle type-specific installation details.
switch(itype)
{
case cmTarget::MODULE_LIBRARY:
case cmTarget::STATIC_LIBRARY:
case cmTarget::SHARED_LIBRARY:
{
// Handle shared library versioning
const char* lib_version = 0;
const char* lib_soversion = 0;
if ( properties.find("VERSION") != properties.end() )
{
lib_version = properties["VERSION"];
}
if ( properties.find("SOVERSION") != properties.end() )
{
lib_soversion = properties["SOVERSION"];
}
if ( !lib_version && lib_soversion )
{
lib_version = lib_soversion;
}
if ( !lib_soversion && lib_version )
{
lib_soversion = lib_version;
}
if ( lib_version && lib_soversion )
{
std::string libname = toFile;
std::string soname = toFile;
std::string soname_nopath = fromName;
this->ComputeVersionedLibName(soname, lib_soversion);
this->ComputeVersionedLibName(soname_nopath, lib_soversion);
this->ComputeVersionedLibName(fromName, lib_version);
this->ComputeVersionedLibName(toFile, lib_version);
cmSystemTools::RemoveFile(soname.c_str());
cmSystemTools::RemoveFile(libname.c_str());
if (!cmSystemTools::CreateSymlink(soname_nopath.c_str(),
libname.c_str()) )
{
std::string errstring = "error when creating symlink from: "
+ libname + " to " + soname_nopath;
this->SetError(errstring.c_str());
return false;
}
installer.ManifestAppend(libname);
if ( toFile != soname )
{
if ( !cmSystemTools::CreateSymlink(fromName.c_str(),
soname.c_str()) )
{
std::string errstring = "error when creating symlink from: "
+ soname + " to " + fromName;
this->SetError(errstring.c_str());
return false;
}
installer.ManifestAppend(soname);
}
}
}
break;
case cmTarget::EXECUTABLE:
{
// Handle executable versioning
const char* exe_version = 0;
if ( properties.find("VERSION") != properties.end() )
{
exe_version = properties["VERSION"];
}
if ( exe_version )
{
std::string exename = toFile;
this->ComputeVersionedExeName(fromName, exe_version);
this->ComputeVersionedExeName(toFile, exe_version);
cmSystemTools::RemoveFile(exename.c_str());
if(!cmSystemTools::CreateSymlink(fromName.c_str(),
exename.c_str()))
{
std::string errstring = "error when creating symlink from: "
+ exename + " to " + fromName;
this->SetError(errstring.c_str());
return false;
}
installer.ManifestAppend(exename);
}
}
break;
}
// Construct the full path to the source file. The file name may // Construct the full path to the source file. The file name may
// have been changed above. // have been changed above.
std::string fromFile = fromDir; std::string fromFile = fromDir;
@ -1806,41 +1651,6 @@ bool cmFileCommand::DoInstall( cmFileInstaller& installer,
return true; return true;
} }
//----------------------------------------------------------------------------
void cmFileCommand::ComputeVersionedLibName(std::string& name,
const char* version)
{
#if defined(__APPLE__)
std::string ext;
cmsys_stl::string::size_type dot_pos = name.rfind(".");
if(dot_pos != name.npos)
{
ext = name.substr(dot_pos, name.npos);
name = name.substr(0, dot_pos);
}
#endif
name += ".";
name += version;
#if defined(__APPLE__)
name += ext;
#endif
}
//----------------------------------------------------------------------------
void cmFileCommand::ComputeVersionedExeName(std::string& name,
const char* version)
{
std::string ext;
if(name.size() > 4 && name.substr(name.size()-4) == ".exe")
{
ext = ".exe";
name = name.substr(0, name.size()-4);
}
name += "-";
name += version;
name += ext;
}
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
bool cmFileCommand::HandleRelativePathCommand( bool cmFileCommand::HandleRelativePathCommand(
std::vector<std::string> const& args) std::vector<std::string> const& args)

View File

@ -159,15 +159,11 @@ protected:
bool HandleRelativePathCommand(std::vector<std::string> const& args); bool HandleRelativePathCommand(std::vector<std::string> const& args);
bool HandleCMakePathCommand(std::vector<std::string> const& args, bool HandleCMakePathCommand(std::vector<std::string> const& args,
bool nativePath); bool nativePath);
void ComputeVersionedLibName(std::string& name, const char* version);
void ComputeVersionedExeName(std::string& name, const char* version);
// FILE(INSTALL ...) related functions // FILE(INSTALL ...) related functions
bool HandleInstallCommand(std::vector<std::string> const& args); bool HandleInstallCommand(std::vector<std::string> const& args);
bool ParseInstallArgs(std::vector<std::string> const& args, bool ParseInstallArgs(std::vector<std::string> const& args,
cmFileInstaller& installer, cmFileInstaller& installer,
std::set<cmStdString>& components,
std::set<cmStdString>& configurations,
std::map<cmStdString, const char*>& properties, std::map<cmStdString, const char*>& properties,
int& itype, int& itype,
std::string& destination, std::string& destination,
@ -176,8 +172,6 @@ protected:
bool& optional bool& optional
); );
bool DoInstall(cmFileInstaller& installer, bool DoInstall(cmFileInstaller& installer,
const std::set<cmStdString>& components,
const std::set<cmStdString>& configurations,
std::map<cmStdString, const char*>& properties, std::map<cmStdString, const char*>& properties,
const int itype, const int itype,
const std::string& rename, const std::string& rename,

View File

@ -1295,7 +1295,7 @@ bool cmInstallCommand::HandleExportMode(std::vector<std::string> const& args)
// Create the export install generator. // Create the export install generator.
cmInstallExportGenerator* exportGenerator = new cmInstallExportGenerator( cmInstallExportGenerator* exportGenerator = new cmInstallExportGenerator(
destination, permissions.c_str(), configurations, destination, permissions.c_str(), configurations, 0,
filename.c_str(), prefix.c_str(), cmakeDir.c_str()); filename.c_str(), prefix.c_str(), cmakeDir.c_str());
if (exportGenerator->SetExportSet(exportIt->c_str(),exportSet)) if (exportGenerator->SetExportSet(exportIt->c_str(),exportSet))

View File

@ -27,9 +27,8 @@ cmInstallDirectoryGenerator
std::vector<std::string> const& configurations, std::vector<std::string> const& configurations,
const char* component, const char* component,
const char* literal_args): const char* literal_args):
cmInstallGenerator(dest), Directories(dirs), cmInstallGenerator(dest, configurations, component), Directories(dirs),
FilePermissions(file_permissions), DirPermissions(dir_permissions), FilePermissions(file_permissions), DirPermissions(dir_permissions),
Configurations(configurations), Component(component),
LiteralArguments(literal_args) LiteralArguments(literal_args)
{ {
} }
@ -41,7 +40,9 @@ cmInstallDirectoryGenerator
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmInstallDirectoryGenerator::GenerateScript(std::ostream& os) void
cmInstallDirectoryGenerator::GenerateScriptActions(std::ostream& os,
Indent const& indent)
{ {
// Write code to install the directories. // Write code to install the directories.
bool not_optional = false; bool not_optional = false;
@ -53,6 +54,6 @@ void cmInstallDirectoryGenerator::GenerateScript(std::ostream& os)
not_optional, no_properties, not_optional, no_properties,
this->FilePermissions.c_str(), this->FilePermissions.c_str(),
this->DirPermissions.c_str(), this->DirPermissions.c_str(),
this->Configurations, this->Component.c_str(), no_rename, this->LiteralArguments.c_str(),
no_rename, this->LiteralArguments.c_str()); indent);
} }

View File

@ -35,12 +35,11 @@ public:
virtual ~cmInstallDirectoryGenerator(); virtual ~cmInstallDirectoryGenerator();
protected: protected:
virtual void GenerateScript(std::ostream& os); typedef cmInstallGeneratorIndent Indent;
virtual void GenerateScriptActions(std::ostream& os, Indent const& indent);
std::vector<std::string> Directories; std::vector<std::string> Directories;
std::string FilePermissions; std::string FilePermissions;
std::string DirPermissions; std::string DirPermissions;
std::vector<std::string> Configurations;
std::string Component;
std::string LiteralArguments; std::string LiteralArguments;
}; };

View File

@ -23,13 +23,14 @@
#include "cmInstallExportGenerator.h" #include "cmInstallExportGenerator.h"
cmInstallExportGenerator::cmInstallExportGenerator(const char* destination, cmInstallExportGenerator::cmInstallExportGenerator(
const char* file_permissions, const char* destination,
std::vector<std::string> const& configurations, const char* file_permissions,
const char* filename, const char* prefix, const char* tempOutputDir) std::vector<std::string> const& configurations,
:cmInstallGenerator(destination) const char* component,
const char* filename, const char* prefix, const char* tempOutputDir)
:cmInstallGenerator(destination, configurations, component)
,FilePermissions(file_permissions) ,FilePermissions(file_permissions)
,Configurations(configurations)
,Filename(filename) ,Filename(filename)
,Prefix(prefix) ,Prefix(prefix)
,TempOutputDir(tempOutputDir) ,TempOutputDir(tempOutputDir)
@ -221,13 +222,19 @@ void cmInstallExportGenerator::GenerateScript(std::ostream& os)
exportFileStream << " )\n\n"; exportFileStream << " )\n\n";
} }
// Perform the main install script generation.
this->cmInstallGenerator::GenerateScript(os);
}
//----------------------------------------------------------------------------
void cmInstallExportGenerator::GenerateScriptActions(std::ostream& os,
Indent const& indent)
{
// install rule for the file created above // install rule for the file created above
std::vector<std::string> exportFile; std::vector<std::string> exportFile;
exportFile.push_back(this->ExportFilename); exportFile.push_back(this->ExportFilename);
this->AddInstallRule(os, this->Destination.c_str(), cmTarget::INSTALL_FILES, this->AddInstallRule(os, this->Destination.c_str(), cmTarget::INSTALL_FILES,
exportFile, false, 0, exportFile, false, 0,
this->FilePermissions.c_str(), 0, this->Configurations, this->FilePermissions.c_str(),
0, this->Filename.c_str(), 0); 0, this->Filename.c_str(), 0, indent);
} }

View File

@ -55,6 +55,7 @@ class cmInstallExportGenerator: public cmInstallGenerator
public: public:
cmInstallExportGenerator(const char* dest, const char* file_permissions, cmInstallExportGenerator(const char* dest, const char* file_permissions,
const std::vector<std::string>& configurations, const std::vector<std::string>& configurations,
const char* component,
const char* filename, const char* prefix, const char* filename, const char* prefix,
const char* tempOutputDir); const char* tempOutputDir);
@ -73,14 +74,15 @@ protected:
cmTargetWithProperties(); cmTargetWithProperties();
}; };
typedef cmInstallGeneratorIndent Indent;
virtual void GenerateScript(std::ostream& os); virtual void GenerateScript(std::ostream& os);
virtual void GenerateScriptActions(std::ostream& os, Indent const& indent);
static bool AddInstallLocations(cmTargetWithProperties *twp, static bool AddInstallLocations(cmTargetWithProperties *twp,
cmInstallTargetGenerator* generator, cmInstallTargetGenerator* generator,
const char* prefix); const char* prefix);
std::string Name; std::string Name;
std::string FilePermissions; std::string FilePermissions;
const std::vector<std::string> Configurations;
std::string Filename; std::string Filename;
std::string Prefix; std::string Prefix;
std::string TempOutputDir; std::string TempOutputDir;

View File

@ -27,9 +27,10 @@ cmInstallFilesGenerator
const char* component, const char* component,
const char* rename, const char* rename,
bool optional): bool optional):
cmInstallGenerator(dest), Files(files), Programs(programs), cmInstallGenerator(dest, configurations, component),
FilePermissions(file_permissions), Configurations(configurations), Files(files), Programs(programs),
Component(component), Rename(rename), Optional(optional) FilePermissions(file_permissions),
Rename(rename), Optional(optional)
{ {
} }
@ -40,7 +41,8 @@ cmInstallFilesGenerator
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmInstallFilesGenerator::GenerateScript(std::ostream& os) void cmInstallFilesGenerator::GenerateScriptActions(std::ostream& os,
Indent const& indent)
{ {
// Write code to install the files. // Write code to install the files.
const char* no_properties = 0; const char* no_properties = 0;
@ -52,7 +54,5 @@ void cmInstallFilesGenerator::GenerateScript(std::ostream& os)
this->Files, this->Files,
this->Optional, no_properties, this->Optional, no_properties,
this->FilePermissions.c_str(), no_dir_permissions, this->FilePermissions.c_str(), no_dir_permissions,
this->Configurations, this->Rename.c_str(), 0, indent);
this->Component.c_str(),
this->Rename.c_str());
} }

View File

@ -35,12 +35,11 @@ public:
virtual ~cmInstallFilesGenerator(); virtual ~cmInstallFilesGenerator();
protected: protected:
virtual void GenerateScript(std::ostream& os); typedef cmInstallGeneratorIndent Indent;
virtual void GenerateScriptActions(std::ostream& os, Indent const& indent);
std::vector<std::string> Files; std::vector<std::string> Files;
bool Programs; bool Programs;
std::string FilePermissions; std::string FilePermissions;
std::vector<std::string> Configurations;
std::string Component;
std::string Rename; std::string Rename;
bool Optional; bool Optional;
}; };

View File

@ -21,10 +21,15 @@
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
cmInstallGenerator cmInstallGenerator
::cmInstallGenerator() ::cmInstallGenerator(const char* destination,
std::vector<std::string> const& configurations,
const char* component):
Destination(destination? destination:""),
Configurations(configurations),
Component(component? component:""),
ConfigurationName(0),
ConfigurationTypes(0)
{ {
this->ConfigurationName = 0;
this->ConfigurationTypes = 0;
} }
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -57,8 +62,6 @@ void cmInstallGenerator
const char* properties /* = 0 */, const char* properties /* = 0 */,
const char* permissions_file /* = 0 */, const char* permissions_file /* = 0 */,
const char* permissions_dir /* = 0 */, const char* permissions_dir /* = 0 */,
std::vector<std::string> const& configurations,
const char* component /* = 0 */,
const char* rename /* = 0 */, const char* rename /* = 0 */,
const char* literal_args /* = 0 */, const char* literal_args /* = 0 */,
cmInstallGeneratorIndent const& indent cmInstallGeneratorIndent const& indent
@ -99,19 +102,6 @@ void cmInstallGenerator
{ {
os << " RENAME \"" << rename << "\""; os << " RENAME \"" << rename << "\"";
} }
if(!configurations.empty())
{
os << " CONFIGURATIONS";
for(std::vector<std::string>::const_iterator c = configurations.begin();
c != configurations.end(); ++c)
{
os << " \"" << *c << "\"";
}
}
if(component && *component)
{
os << " COMPONENTS \"" << component << "\"";
}
os << " FILES"; os << " FILES";
if(files.size() == 1) if(files.size() == 1)
{ {
@ -136,3 +126,115 @@ void cmInstallGenerator
} }
os << ")\n"; os << ")\n";
} }
//----------------------------------------------------------------------------
static void cmInstallGeneratorEncodeConfig(const char* config,
std::string& result)
{
for(const char* c = config; *c; ++c)
{
if(*c >= 'a' && *c <= 'z')
{
result += "[";
result += *c + ('A' - 'a');
result += *c;
result += "]";
}
else if(*c >= 'A' && *c <= 'Z')
{
result += "[";
result += *c;
result += *c + ('a' - 'A');
result += "]";
}
else
{
result += *c;
}
}
}
//----------------------------------------------------------------------------
std::string
cmInstallGenerator::CreateConfigTest(const char* config)
{
std::string result = "\"${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"^(";
if(config && *config)
{
cmInstallGeneratorEncodeConfig(config, result);
}
result += ")$\"";
return result;
}
//----------------------------------------------------------------------------
std::string
cmInstallGenerator::CreateConfigTest(std::vector<std::string> const& configs)
{
std::string result = "\"${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"^(";
const char* sep = "";
for(std::vector<std::string>::const_iterator ci = configs.begin();
ci != configs.end(); ++ci)
{
result += sep;
sep = "|";
cmInstallGeneratorEncodeConfig(ci->c_str(), result);
}
result += ")$\"";
return result;
}
//----------------------------------------------------------------------------
std::string
cmInstallGenerator::CreateComponentTest(const char* component)
{
std::string result = "NOT CMAKE_INSTALL_COMPONENT OR "
"\"${CMAKE_INSTALL_COMPONENT}\" MATCHES \"^(";
result += component;
result += ")$\"";
return result;
}
//----------------------------------------------------------------------------
void cmInstallGenerator::GenerateScript(std::ostream& os)
{
// Track indentation.
Indent indent;
// Begin this block of installation.
std::string component_test =
this->CreateComponentTest(this->Component.c_str());
os << indent << "IF(" << component_test << ")\n";
// Generate the script possibly with per-configuration code.
this->GenerateScriptConfigs(os, indent.Next());
// End this block of installation.
os << indent << "ENDIF(" << component_test << ")\n";
}
//----------------------------------------------------------------------------
void
cmInstallGenerator::GenerateScriptConfigs(std::ostream& os,
Indent const& indent)
{
if(this->Configurations.empty())
{
// This rule is for all configurations.
this->GenerateScriptActions(os, indent);
}
else
{
// Generate a per-configuration block.
std::string config_test = this->CreateConfigTest(this->Configurations);
os << indent << "IF(" << config_test << ")\n";
this->GenerateScriptActions(os, indent.Next());
os << indent << "ENDIF(" << config_test << ")\n";
}
}
//----------------------------------------------------------------------------
void cmInstallGenerator::GenerateScriptActions(std::ostream&, Indent const&)
{
// No actions for this generator.
}

View File

@ -54,8 +54,9 @@ inline std::ostream& operator<<(std::ostream& os,
class cmInstallGenerator class cmInstallGenerator
{ {
public: public:
cmInstallGenerator(); cmInstallGenerator(const char* destination,
cmInstallGenerator(const char* dest):Destination(dest?dest:"") {} std::vector<std::string> const& configurations,
const char* component);
virtual ~cmInstallGenerator(); virtual ~cmInstallGenerator();
void Generate(std::ostream& os, const char* config, void Generate(std::ostream& os, const char* config,
@ -68,21 +69,33 @@ public:
const char* properties = 0, const char* properties = 0,
const char* permissions_file = 0, const char* permissions_file = 0,
const char* permissions_dir = 0, const char* permissions_dir = 0,
std::vector<std::string> const& configurations
= std::vector<std::string>(),
const char* component = 0,
const char* rename = 0, const char* rename = 0,
const char* literal_args = 0, const char* literal_args = 0,
cmInstallGeneratorIndent const& indent = cmInstallGeneratorIndent() cmInstallGeneratorIndent const& indent = cmInstallGeneratorIndent()
); );
const char* GetDestination() const {return this->Destination.c_str();} const char* GetDestination() const
{ return this->Destination.c_str(); }
const std::vector<std::string>& GetConfigurations() const
{ return this->Configurations; }
protected: protected:
virtual void GenerateScript(std::ostream& os)=0; typedef cmInstallGeneratorIndent Indent;
virtual void GenerateScript(std::ostream& os);
virtual void GenerateScriptConfigs(std::ostream& os, Indent const& indent);
virtual void GenerateScriptActions(std::ostream& os, Indent const& indent);
std::string CreateConfigTest(const char* config);
std::string CreateConfigTest(std::vector<std::string> const& configs);
std::string CreateComponentTest(const char* component);
// Information shared by most generator types.
std::string Destination;
std::vector<std::string> const Configurations;
std::string Component;
// Information used during generation.
const char* ConfigurationName; const char* ConfigurationName;
std::vector<std::string> const* ConfigurationTypes; std::vector<std::string> const* ConfigurationTypes;
std::string Destination;
}; };
#endif #endif

View File

@ -19,6 +19,7 @@
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
cmInstallScriptGenerator cmInstallScriptGenerator
::cmInstallScriptGenerator(const char* script, bool code): ::cmInstallScriptGenerator(const char* script, bool code):
cmInstallGenerator(0, std::vector<std::string>(), 0),
Script(script), Code(code) Script(script), Code(code)
{ {
} }

View File

@ -22,8 +22,6 @@
#include "cmake.h" #include "cmake.h"
// TODO: // TODO:
// - Consolidate component/configuration checks across multiple
// install generators
// - Skip IF(EXISTS) checks if nothing is done with the installed file // - Skip IF(EXISTS) checks if nothing is done with the installed file
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
@ -32,9 +30,8 @@ cmInstallTargetGenerator
const char* file_permissions, const char* file_permissions,
std::vector<std::string> const& configurations, std::vector<std::string> const& configurations,
const char* component, bool optional): const char* component, bool optional):
cmInstallGenerator(dest), Target(&t), ImportLibrary(implib), cmInstallGenerator(dest, configurations, component), Target(&t),
FilePermissions(file_permissions), Configurations(configurations), ImportLibrary(implib), FilePermissions(file_permissions), Optional(optional)
Component(component), Optional(optional)
{ {
this->Target->SetHaveInstallRule(true); this->Target->SetHaveInstallRule(true);
} }
@ -52,10 +49,8 @@ void cmInstallTargetGenerator::GenerateScript(std::ostream& os)
Indent indent; Indent indent;
// Begin this block of installation. // Begin this block of installation.
std::string component_test = "NOT CMAKE_INSTALL_COMPONENT OR " std::string component_test =
"\"${CMAKE_INSTALL_COMPONENT}\" MATCHES \"^("; this->CreateComponentTest(this->Component.c_str());
component_test += this->Component;
component_test += ")$\"";
os << indent << "IF(" << component_test << ")\n"; os << indent << "IF(" << component_test << ")\n";
// Compute the build tree directory from which to copy the target. // Compute the build tree directory from which to copy the target.
@ -94,34 +89,6 @@ void cmInstallTargetGenerator::GenerateScript(std::ostream& os)
os << indent << "ENDIF(" << component_test << ")\n"; os << indent << "ENDIF(" << component_test << ")\n";
} }
//----------------------------------------------------------------------------
static std::string cmInstallTargetGeneratorEncodeConfig(const char* config)
{
std::string result;
for(const char* c = config; *c; ++c)
{
if(*c >= 'a' && *c <= 'z')
{
result += "[";
result += *c + ('A' - 'a');
result += *c;
result += "]";
}
else if(*c >= 'A' && *c <= 'Z')
{
result += "[";
result += *c;
result += *c + ('a' - 'A');
result += "]";
}
else
{
result += *c;
}
}
return result;
}
//---------------------------------------------------------------------------- //----------------------------------------------------------------------------
void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os, void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
const char* fromDir, const char* fromDir,
@ -155,9 +122,7 @@ void cmInstallTargetGenerator::GenerateScriptForConfig(std::ostream& os,
} }
// Generate a per-configuration block. // Generate a per-configuration block.
config_test = "\"${CMAKE_INSTALL_CONFIG_NAME}\" MATCHES \"^("; std::string config_test = this->CreateConfigTest(config);
config_test += cmInstallTargetGeneratorEncodeConfig(config);
config_test += ")$\"";
os << indent << "IF(" << config_test << ")\n"; os << indent << "IF(" << config_test << ")\n";
this->GenerateScriptForConfigDir(os, fromDirConfig.c_str(), config, this->GenerateScriptForConfigDir(os, fromDirConfig.c_str(), config,
indent.Next()); indent.Next());
@ -221,12 +186,12 @@ cmInstallTargetGenerator
from1 += ".app"; from1 += ".app";
files.push_back(from1); files.push_back(from1);
type = cmTarget::INSTALL_DIRECTORY; type = cmTarget::INSTALL_DIRECTORY;
// Need to apply install_name_tool and stripping to binary
// inside bundle.
toFullPath += ".app/Contents/MacOS/"; toFullPath += ".app/Contents/MacOS/";
toFullPath += this->GetInstallFilename(this->Target, config, toFullPath += this->GetInstallFilename(this->Target, config,
this->ImportLibrary, false); this->ImportLibrary, false);
literal_args += " USE_SOURCE_PERMISSIONS"; literal_args += " USE_SOURCE_PERMISSIONS";
// TODO: Still need to apply install_name_tool and stripping
// to binaries inside bundle.
} }
else else
{ {
@ -284,13 +249,10 @@ cmInstallTargetGenerator
const char* no_dir_permissions = 0; const char* no_dir_permissions = 0;
const char* no_rename = 0; const char* no_rename = 0;
const char* no_properties = 0; const char* no_properties = 0;
const char* no_component = 0;
std::vector<std::string> no_configurations;
bool optional = this->Optional || this->ImportLibrary; bool optional = this->Optional || this->ImportLibrary;
this->AddInstallRule(os, this->Destination.c_str(), type, files, this->AddInstallRule(os, this->Destination.c_str(), type, files,
optional, no_properties, optional, no_properties,
this->FilePermissions.c_str(), no_dir_permissions, this->FilePermissions.c_str(), no_dir_permissions,
no_configurations, no_component,
no_rename, literal_args.c_str(), no_rename, literal_args.c_str(),
indent); indent);

View File

@ -40,8 +40,6 @@ public:
static std::string GetInstallFilename(cmTarget*target, const char* config, static std::string GetInstallFilename(cmTarget*target, const char* config,
bool implib, bool useSOName); bool implib, bool useSOName);
const std::vector<std::string>& GetConfigurations() const {return this->Configurations;}
protected: protected:
typedef cmInstallGeneratorIndent Indent; typedef cmInstallGeneratorIndent Indent;
virtual void GenerateScript(std::ostream& os); virtual void GenerateScript(std::ostream& os);
@ -66,8 +64,6 @@ protected:
cmTarget* Target; cmTarget* Target;
bool ImportLibrary; bool ImportLibrary;
std::string FilePermissions; std::string FilePermissions;
std::vector<std::string> Configurations;
std::string Component;
bool Optional; bool Optional;
}; };