kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

244
Source/cmFileCommand.cxx
View File

@ -1241,20 +1241,17 @@ bool cmFileCommand::HandleInstallCommand(std::vector<std::string> const& args)
std::string rename = "";
std::string destination = "";
std::set<cmStdString> components;
std::set<cmStdString> configurations;
std::vector<std::string> files;
int itype = cmTarget::INSTALL_FILES;
std::map<cmStdString, const char*> properties;
bool optional = false;
bool result = this->ParseInstallArgs(args, installer, components,
configurations, properties,
bool result = this->ParseInstallArgs(args, installer, properties,
itype, rename, destination, files,
optional);
if (result == true)
{
result = this->DoInstall(installer, components, configurations, properties,
result = this->DoInstall(installer, properties,
itype, rename, destination, files, optional);
}
return result;
@ -1263,8 +1260,6 @@ bool cmFileCommand::HandleInstallCommand(std::vector<std::string> const& args)
//----------------------------------------------------------------------------
bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
cmFileInstaller& installer,
std::set<cmStdString>& components,
std::set<cmStdString>& configurations,
std::map<cmStdString, const char*>& properties,
int& itype,
std::string& rename,
@ -1278,8 +1273,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
bool doing_permissions_file = false;
bool doing_permissions_dir = false;
bool doing_permissions_match = false;
bool doing_components = false;
bool doing_configurations = false;
bool use_given_permissions_file = false;
bool use_given_permissions_dir = false;
bool use_source_permissions = false;
@ -1308,8 +1301,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
doing_properties = false;
doing_permissions_file = false;
doing_permissions_dir = false;
doing_components = false;
doing_configurations = false;
}
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_permissions_file = false;
doing_permissions_dir = false;
doing_components = false;
doing_configurations = false;
}
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_permissions_file = false;
doing_permissions_dir = false;
doing_components = false;
doing_configurations = false;
}
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_permissions_file = false;
doing_permissions_dir = false;
doing_components = false;
doing_configurations = false;
}
else if ( *cstr == "EXCLUDE" )
{
@ -1401,8 +1386,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
doing_files = false;
doing_permissions_file = false;
doing_permissions_dir = false;
doing_components = false;
doing_configurations = false;
}
else if ( *cstr == "PERMISSIONS" )
{
@ -1420,8 +1403,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
doing_properties = false;
doing_files = false;
doing_permissions_dir = false;
doing_components = false;
doing_configurations = false;
}
else if ( *cstr == "DIR_PERMISSIONS" )
{
@ -1438,8 +1419,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
doing_files = false;
doing_permissions_file = false;
doing_permissions_dir = true;
doing_components = false;
doing_configurations = false;
}
else if ( *cstr == "USE_SOURCE_PERMISSIONS" )
{
@ -1455,44 +1434,26 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
doing_files = false;
doing_permissions_file = false;
doing_permissions_dir = false;
doing_components = false;
doing_configurations = false;
use_source_permissions = true;
}
else if ( *cstr == "COMPONENTS" )
{
if(current_match_rule)
{
cmOStringStream e;
e << "INSTALL does not allow \"" << *cstr << "\" after REGEX.";
e << "INSTALL called with old-style COMPONENTS argument. "
<< "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;
}
doing_properties = false;
doing_files = false;
doing_permissions_file = false;
doing_permissions_dir = false;
doing_components = true;
doing_configurations = false;
}
else if ( *cstr == "CONFIGURATIONS" )
{
if(current_match_rule)
{
cmOStringStream e;
e << "INSTALL does not allow \"" << *cstr << "\" after REGEX.";
e << "INSTALL called with old-style CONFIGURATIONS argument. "
<< "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;
}
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)
{
if(current_match_rule)
@ -1507,8 +1468,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
doing_properties = false;
doing_permissions_file = false;
doing_permissions_dir = false;
doing_components = false;
doing_configurations = false;
}
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);
}
else if ( doing_components )
{
components.insert(*cstr);
}
else if ( doing_configurations )
{
configurations.insert(cmSystemTools::UpperCase(*cstr));
}
else if(doing_permissions_file)
{
if(!installer.CheckPermissions(args[i], permissions_file))
@ -1587,6 +1538,25 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
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->HandleInstallPermissions(installer,
@ -1602,8 +1572,6 @@ bool cmFileCommand::ParseInstallArgs(std::vector<std::string> const& args,
//----------------------------------------------------------------------------
bool cmFileCommand::DoInstall( cmFileInstaller& installer,
const std::set<cmStdString>& components,
const std::set<cmStdString>& configurations,
std::map<cmStdString, const char*>& properties,
const int itype,
const std::string& rename,
@ -1612,38 +1580,6 @@ bool cmFileCommand::DoInstall( cmFileInstaller& installer,
const bool optional)
{
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
// changed.
@ -1669,97 +1605,6 @@ bool cmFileCommand::DoInstall( cmFileInstaller& installer,
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
// have been changed above.
std::string fromFile = fromDir;
@ -1806,41 +1651,6 @@ bool cmFileCommand::DoInstall( cmFileInstaller& installer,
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(
std::vector<std::string> const& args)

6
Source/cmFileCommand.h
View File

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

2
Source/cmInstallCommand.cxx
View File

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

11
Source/cmInstallDirectoryGenerator.cxx
View File

@ -27,9 +27,8 @@ cmInstallDirectoryGenerator
std::vector<std::string> const& configurations,
const char* component,
const char* literal_args):
cmInstallGenerator(dest), Directories(dirs),
cmInstallGenerator(dest, configurations, component), Directories(dirs),
FilePermissions(file_permissions), DirPermissions(dir_permissions),
Configurations(configurations), Component(component),
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.
bool not_optional = false;
@ -53,6 +54,6 @@ void cmInstallDirectoryGenerator::GenerateScript(std::ostream& os)
not_optional, no_properties,
this->FilePermissions.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);
}

5
Source/cmInstallDirectoryGenerator.h
View File

@ -35,12 +35,11 @@ public:
virtual ~cmInstallDirectoryGenerator();
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::string FilePermissions;
std::string DirPermissions;
std::vector<std::string> Configurations;
std::string Component;
std::string LiteralArguments;
};

21
Source/cmInstallExportGenerator.cxx
View File

@ -23,13 +23,14 @@
#include "cmInstallExportGenerator.h"
cmInstallExportGenerator::cmInstallExportGenerator(const char* destination,
cmInstallExportGenerator::cmInstallExportGenerator(
const char* destination,
const char* file_permissions,
std::vector<std::string> const& configurations,
const char* component,
const char* filename, const char* prefix, const char* tempOutputDir)
:cmInstallGenerator(destination)
:cmInstallGenerator(destination, configurations, component)
,FilePermissions(file_permissions)
,Configurations(configurations)
,Filename(filename)
,Prefix(prefix)
,TempOutputDir(tempOutputDir)
@ -221,13 +222,19 @@ void cmInstallExportGenerator::GenerateScript(std::ostream& os)
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
std::vector<std::string> exportFile;
exportFile.push_back(this->ExportFilename);
this->AddInstallRule(os, this->Destination.c_str(), cmTarget::INSTALL_FILES,
exportFile, false, 0,
this->FilePermissions.c_str(), 0, this->Configurations,
0, this->Filename.c_str(), 0);
this->FilePermissions.c_str(),
0, this->Filename.c_str(), 0, indent);
}

4
Source/cmInstallExportGenerator.h
View File

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

14
Source/cmInstallFilesGenerator.cxx
View File

@ -27,9 +27,10 @@ cmInstallFilesGenerator
const char* component,
const char* rename,
bool optional):
cmInstallGenerator(dest), Files(files), Programs(programs),
FilePermissions(file_permissions), Configurations(configurations),
Component(component), Rename(rename), Optional(optional)
cmInstallGenerator(dest, configurations, component),
Files(files), Programs(programs),
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.
const char* no_properties = 0;
@ -52,7 +54,5 @@ void cmInstallFilesGenerator::GenerateScript(std::ostream& os)
this->Files,
this->Optional, no_properties,
this->FilePermissions.c_str(), no_dir_permissions,
this->Configurations,
this->Component.c_str(),
this->Rename.c_str());
this->Rename.c_str(), 0, indent);
}

5
Source/cmInstallFilesGenerator.h
View File

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

138
Source/cmInstallGenerator.cxx
View File

@ -21,10 +21,15 @@
//----------------------------------------------------------------------------
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* permissions_file /* = 0 */,
const char* permissions_dir /* = 0 */,
std::vector<std::string> const& configurations,
const char* component /* = 0 */,
const char* rename /* = 0 */,
const char* literal_args /* = 0 */,
cmInstallGeneratorIndent const& indent
@ -99,19 +102,6 @@ void cmInstallGenerator
{
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";
if(files.size() == 1)
{
@ -136,3 +126,115 @@ void cmInstallGenerator
}
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.
}

29
Source/cmInstallGenerator.h
View File

@ -54,8 +54,9 @@ inline std::ostream& operator<<(std::ostream& os,
class cmInstallGenerator
{
public:
cmInstallGenerator();
cmInstallGenerator(const char* dest):Destination(dest?dest:"") {}
cmInstallGenerator(const char* destination,
std::vector<std::string> const& configurations,
const char* component);
virtual ~cmInstallGenerator();
void Generate(std::ostream& os, const char* config,
@ -68,21 +69,33 @@ public:
const char* properties = 0,
const char* permissions_file = 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* literal_args = 0,
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:
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;
std::vector<std::string> const* ConfigurationTypes;
std::string Destination;
};
#endif

1
Source/cmInstallScriptGenerator.cxx
View File

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

52
Source/cmInstallTargetGenerator.cxx
View File

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

4
Source/cmInstallTargetGenerator.h
View File

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