mirror of
https://github.com/reactos/CMake.git
synced 2024-12-11 21:34:32 +00:00
1370 lines
40 KiB
C++
1370 lines
40 KiB
C++
/*=========================================================================
|
|
|
|
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.
|
|
|
|
This software is distributed WITHOUT ANY WARRANTY; without even
|
|
the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
|
|
PURPOSE. See the above copyright notices for more information.
|
|
|
|
=========================================================================*/
|
|
#include "cmInstallCommand.h"
|
|
|
|
#include "cmInstallDirectoryGenerator.h"
|
|
#include "cmInstallFilesGenerator.h"
|
|
#include "cmInstallScriptGenerator.h"
|
|
#include "cmInstallTargetGenerator.h"
|
|
#include "cmInstallExportGenerator.h"
|
|
|
|
#include <cmsys/Glob.hxx>
|
|
|
|
// cmInstallCommand
|
|
bool cmInstallCommand::InitialPass(std::vector<std::string> const& args)
|
|
{
|
|
// Allow calling with no arguments so that arguments may be built up
|
|
// using a variable that may be left empty.
|
|
if(args.empty())
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// Enable the install target.
|
|
this->Makefile->GetLocalGenerator()
|
|
->GetGlobalGenerator()->EnableInstallTarget();
|
|
|
|
// Switch among the command modes.
|
|
if(args[0] == "SCRIPT")
|
|
{
|
|
return this->HandleScriptMode(args);
|
|
}
|
|
else if(args[0] == "CODE")
|
|
{
|
|
return this->HandleScriptMode(args);
|
|
}
|
|
else if(args[0] == "TARGETS")
|
|
{
|
|
return this->HandleTargetsMode(args);
|
|
}
|
|
else if(args[0] == "FILES")
|
|
{
|
|
return this->HandleFilesMode(args);
|
|
}
|
|
else if(args[0] == "PROGRAMS")
|
|
{
|
|
return this->HandleFilesMode(args);
|
|
}
|
|
else if(args[0] == "DIRECTORY")
|
|
{
|
|
return this->HandleDirectoryMode(args);
|
|
}
|
|
else if(args[0] == "EXPORT")
|
|
{
|
|
return this->HandleExportMode(args);
|
|
}
|
|
|
|
// Unknown mode.
|
|
cmStdString e = "called with unknown mode ";
|
|
e += args[0];
|
|
this->SetError(e.c_str());
|
|
return false;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmInstallCommand::HandleScriptMode(std::vector<std::string> const& args)
|
|
{
|
|
bool doing_script = false;
|
|
bool doing_code = false;
|
|
for(size_t i=0; i < args.size(); ++i)
|
|
{
|
|
if(args[i] == "SCRIPT")
|
|
{
|
|
doing_script = true;
|
|
doing_code = false;
|
|
}
|
|
else if(args[i] == "CODE")
|
|
{
|
|
doing_script = false;
|
|
doing_code = true;
|
|
}
|
|
else if(doing_script)
|
|
{
|
|
doing_script = false;
|
|
std::string script = args[i];
|
|
if(!cmSystemTools::FileIsFullPath(script.c_str()))
|
|
{
|
|
script = this->Makefile->GetCurrentDirectory();
|
|
script += "/";
|
|
script += args[i];
|
|
}
|
|
if(cmSystemTools::FileIsDirectory(script.c_str()))
|
|
{
|
|
this->SetError("given a directory as value of SCRIPT argument.");
|
|
return false;
|
|
}
|
|
this->Makefile->AddInstallGenerator(
|
|
new cmInstallScriptGenerator(script.c_str()));
|
|
}
|
|
else if(doing_code)
|
|
{
|
|
doing_code = false;
|
|
std::string code = args[i];
|
|
this->Makefile->AddInstallGenerator(
|
|
new cmInstallScriptGenerator(code.c_str(), true));
|
|
}
|
|
}
|
|
if(doing_script)
|
|
{
|
|
this->SetError("given no value for SCRIPT argument.");
|
|
return false;
|
|
}
|
|
if(doing_code)
|
|
{
|
|
this->SetError("given no value for CODE argument.");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
|
|
{
|
|
// This is the TARGETS mode.
|
|
bool doing_targets = true;
|
|
bool doing_destination = false;
|
|
bool doing_permissions = false;
|
|
bool doing_component = false;
|
|
bool doing_configurations = false;
|
|
bool doing_export = false;
|
|
bool archive_settings = true;
|
|
bool library_settings = true;
|
|
bool runtime_settings = true;
|
|
std::vector<cmTarget*> targets;
|
|
const char* archive_destination = 0;
|
|
const char* library_destination = 0;
|
|
const char* runtime_destination = 0;
|
|
std::string archive_permissions;
|
|
std::string library_permissions;
|
|
std::string runtime_permissions;
|
|
std::string archive_component;
|
|
std::string library_component;
|
|
std::string runtime_component;
|
|
std::string exportName;
|
|
std::vector<std::string> archive_configurations;
|
|
std::vector<std::string> library_configurations;
|
|
std::vector<std::string> runtime_configurations;
|
|
bool archive_optional = false;
|
|
bool library_optional = false;
|
|
bool runtime_optional = false;
|
|
for(unsigned int i=1; i < args.size(); ++i)
|
|
{
|
|
if(args[i] == "DESTINATION")
|
|
{
|
|
// Switch to setting the destination property.
|
|
doing_targets = false;
|
|
doing_destination = true;
|
|
doing_permissions = false;
|
|
doing_component = false;
|
|
doing_configurations = false;
|
|
doing_export = false;
|
|
}
|
|
else if(args[i] == "PERMISSIONS")
|
|
{
|
|
// Switch to setting the permissions property.
|
|
doing_targets = false;
|
|
doing_destination = false;
|
|
doing_permissions = true;
|
|
doing_component = false;
|
|
doing_configurations = false;
|
|
doing_export = false;
|
|
}
|
|
else if(args[i] == "COMPONENT")
|
|
{
|
|
// Switch to setting the component property.
|
|
doing_targets = false;
|
|
doing_destination = false;
|
|
doing_permissions = false;
|
|
doing_component = true;
|
|
doing_configurations = false;
|
|
doing_export = false;
|
|
}
|
|
else if(args[i] == "CONFIGURATIONS")
|
|
{
|
|
// Switch to setting the configurations property.
|
|
doing_targets = false;
|
|
doing_destination = false;
|
|
doing_permissions = false;
|
|
doing_component = false;
|
|
doing_configurations = true;
|
|
doing_export = false;
|
|
}
|
|
else if(args[i] == "ARCHIVE")
|
|
{
|
|
// Switch to setting only archive properties.
|
|
doing_targets = false;
|
|
doing_destination = false;
|
|
doing_permissions = false;
|
|
doing_component = false;
|
|
doing_configurations = false;
|
|
doing_export = false;
|
|
archive_settings = true;
|
|
library_settings = false;
|
|
runtime_settings = false;
|
|
}
|
|
else if(args[i] == "LIBRARY")
|
|
{
|
|
// Switch to setting only library properties.
|
|
doing_targets = false;
|
|
doing_destination = false;
|
|
doing_permissions = false;
|
|
doing_component = false;
|
|
doing_configurations = false;
|
|
doing_export = false;
|
|
archive_settings = false;
|
|
library_settings = true;
|
|
runtime_settings = false;
|
|
}
|
|
else if(args[i] == "RUNTIME")
|
|
{
|
|
// Switch to setting only runtime properties.
|
|
doing_targets = false;
|
|
doing_destination = false;
|
|
doing_permissions = false;
|
|
doing_component = false;
|
|
doing_configurations = false;
|
|
doing_export = false;
|
|
archive_settings = false;
|
|
library_settings = false;
|
|
runtime_settings = true;
|
|
}
|
|
else if(args[i] == "EXPORT")
|
|
{
|
|
// Switch to setting only runtime properties.
|
|
doing_targets = false;
|
|
doing_destination = false;
|
|
doing_permissions = false;
|
|
doing_component = false;
|
|
doing_configurations = false;
|
|
doing_export = true;
|
|
}
|
|
else if(args[i] == "OPTIONAL")
|
|
{
|
|
// Set the optional property.
|
|
doing_targets = false;
|
|
doing_destination = false;
|
|
doing_permissions = false;
|
|
doing_component = false;
|
|
doing_configurations = false;
|
|
if(archive_settings)
|
|
{
|
|
archive_optional = true;
|
|
}
|
|
if(library_settings)
|
|
{
|
|
library_optional = true;
|
|
}
|
|
if(runtime_settings)
|
|
{
|
|
runtime_optional = true;
|
|
}
|
|
}
|
|
else if(doing_targets)
|
|
{
|
|
// Lookup this target in the current directory.
|
|
if(cmTarget* target = this->Makefile->FindTarget(args[i].c_str(), false))
|
|
{
|
|
// Found the target. Check its type.
|
|
if(target->GetType() != cmTarget::EXECUTABLE &&
|
|
target->GetType() != cmTarget::STATIC_LIBRARY &&
|
|
target->GetType() != cmTarget::SHARED_LIBRARY &&
|
|
target->GetType() != cmTarget::MODULE_LIBRARY)
|
|
{
|
|
cmOStringStream e;
|
|
e << "TARGETS given target \"" << args[i]
|
|
<< "\" which is not an executable, library, or module.";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
// Store the target in the list to be installed.
|
|
targets.push_back(target);
|
|
}
|
|
else
|
|
{
|
|
// Did not find the target.
|
|
cmOStringStream e;
|
|
e << "TARGETS given target \"" << args[i]
|
|
<< "\" which does not exist in this directory.";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
else if(doing_destination)
|
|
{
|
|
// Set the destination in the active set(s) of properties.
|
|
if(archive_settings)
|
|
{
|
|
archive_destination = args[i].c_str();
|
|
}
|
|
if(library_settings)
|
|
{
|
|
library_destination = args[i].c_str();
|
|
}
|
|
if(runtime_settings)
|
|
{
|
|
runtime_destination = args[i].c_str();
|
|
}
|
|
doing_destination = false;
|
|
}
|
|
else if(doing_component)
|
|
{
|
|
// Set the component in the active set(s) of properties.
|
|
if(archive_settings)
|
|
{
|
|
archive_component = args[i];
|
|
}
|
|
if(library_settings)
|
|
{
|
|
library_component = args[i];
|
|
}
|
|
if(runtime_settings)
|
|
{
|
|
runtime_component = args[i];
|
|
}
|
|
doing_component = false;
|
|
}
|
|
else if(doing_permissions)
|
|
{
|
|
// Set the permissions in the active set(s) of properties.
|
|
if(archive_settings)
|
|
{
|
|
// Check the requested permission.
|
|
if(!this->CheckPermissions(args[i], archive_permissions))
|
|
{
|
|
cmOStringStream e;
|
|
e << args[0] << " given invalid permission \""
|
|
<< args[i] << "\".";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
if(library_settings)
|
|
{
|
|
// Check the requested permission.
|
|
if(!this->CheckPermissions(args[i], library_permissions))
|
|
{
|
|
cmOStringStream e;
|
|
e << args[0] << " given invalid permission \""
|
|
<< args[i] << "\".";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
if(runtime_settings)
|
|
{
|
|
// Check the requested permission.
|
|
if(!this->CheckPermissions(args[i], runtime_permissions))
|
|
{
|
|
cmOStringStream e;
|
|
e << args[0] << " given invalid permission \""
|
|
<< args[i] << "\".";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
else if(doing_configurations)
|
|
{
|
|
// Add the configuration in the active set(s) of properties.
|
|
if(archive_settings)
|
|
{
|
|
archive_configurations.push_back(args[i]);
|
|
}
|
|
if(library_settings)
|
|
{
|
|
library_configurations.push_back(args[i]);
|
|
}
|
|
if(runtime_settings)
|
|
{
|
|
runtime_configurations.push_back(args[i]);
|
|
}
|
|
}
|
|
else if(doing_export)
|
|
{
|
|
exportName = args[i];
|
|
doing_export = false;
|
|
}
|
|
else
|
|
{
|
|
// Unknown argument.
|
|
cmOStringStream e;
|
|
e << "TARGETS given unknown argument \"" << args[i] << "\".";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Check if there is something to do.
|
|
if(targets.empty())
|
|
{
|
|
return true;
|
|
}
|
|
if(!archive_destination && !library_destination && !runtime_destination)
|
|
{
|
|
this->SetError("TARGETS given no DESTINATION!");
|
|
return false;
|
|
}
|
|
|
|
// Check whether this is a DLL platform.
|
|
bool dll_platform = (this->Makefile->IsOn("WIN32") ||
|
|
this->Makefile->IsOn("CYGWIN") ||
|
|
this->Makefile->IsOn("MINGW"));
|
|
|
|
// Compute destination paths.
|
|
std::string archive_dest;
|
|
std::string library_dest;
|
|
std::string runtime_dest;
|
|
this->ComputeDestination(archive_destination, archive_dest);
|
|
this->ComputeDestination(library_destination, library_dest);
|
|
this->ComputeDestination(runtime_destination, runtime_dest);
|
|
|
|
// Generate install script code to install the given targets.
|
|
for(std::vector<cmTarget*>::iterator ti = targets.begin();
|
|
ti != targets.end(); ++ti)
|
|
{
|
|
// Handle each target type.
|
|
cmTarget& target = *(*ti);
|
|
cmInstallTargetGenerator* archiveGenerator = 0;
|
|
cmInstallTargetGenerator* runtimeGenerator = 0;
|
|
cmInstallTargetGenerator* libraryGenerator = 0;
|
|
|
|
switch(target.GetType())
|
|
{
|
|
case cmTarget::SHARED_LIBRARY:
|
|
{
|
|
// Shared libraries are handled differently on DLL and non-DLL
|
|
// platforms. All windows platforms are DLL platforms
|
|
// including cygwin. Currently no other platform is a DLL
|
|
// platform.
|
|
if(dll_platform)
|
|
{
|
|
// This is a DLL platform.
|
|
if(archive_destination)
|
|
{
|
|
// The import library uses the ARCHIVE properties.
|
|
archiveGenerator = new cmInstallTargetGenerator(target,
|
|
archive_dest.c_str(),
|
|
true,
|
|
archive_permissions.c_str(),
|
|
archive_configurations,
|
|
archive_component.c_str(),
|
|
archive_optional);
|
|
}
|
|
if(runtime_destination)
|
|
{
|
|
// The DLL uses the RUNTIME properties.
|
|
runtimeGenerator = new cmInstallTargetGenerator(target,
|
|
runtime_dest.c_str(),
|
|
false,
|
|
runtime_permissions.c_str(),
|
|
runtime_configurations,
|
|
runtime_component.c_str(),
|
|
runtime_optional);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// This is a non-DLL platform.
|
|
if(library_destination)
|
|
{
|
|
// The shared library uses the LIBRARY properties.
|
|
libraryGenerator = new cmInstallTargetGenerator(target,
|
|
library_dest.c_str(),
|
|
false,
|
|
library_permissions.c_str(),
|
|
library_configurations,
|
|
library_component.c_str(),
|
|
library_optional);
|
|
}
|
|
else
|
|
{
|
|
cmOStringStream e;
|
|
e << "TARGETS given no LIBRARY DESTINATION for shared library "
|
|
"target \"" << target.GetName() << "\".";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case cmTarget::STATIC_LIBRARY:
|
|
{
|
|
// Static libraries use ARCHIVE properties.
|
|
if(archive_destination)
|
|
{
|
|
archiveGenerator = new cmInstallTargetGenerator(target,
|
|
archive_dest.c_str(),
|
|
false,
|
|
archive_permissions.c_str(),
|
|
archive_configurations,
|
|
archive_component.c_str(),
|
|
archive_optional);
|
|
}
|
|
else
|
|
{
|
|
cmOStringStream e;
|
|
e << "TARGETS given no ARCHIVE DESTINATION for static library "
|
|
"target \"" << target.GetName() << "\".";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
break;
|
|
case cmTarget::MODULE_LIBRARY:
|
|
{
|
|
// Modules use LIBRARY properties.
|
|
if(library_destination)
|
|
{
|
|
libraryGenerator = new cmInstallTargetGenerator(target,
|
|
library_dest.c_str(),
|
|
false,
|
|
library_permissions.c_str(),
|
|
library_configurations,
|
|
library_component.c_str(),
|
|
library_optional);
|
|
}
|
|
else
|
|
{
|
|
cmOStringStream e;
|
|
e << "TARGETS given no LIBRARY DESTINATION for module target \""
|
|
<< target.GetName() << "\".";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
break;
|
|
case cmTarget::EXECUTABLE:
|
|
{
|
|
// Executables use the RUNTIME properties.
|
|
if(runtime_destination)
|
|
{
|
|
runtimeGenerator = new cmInstallTargetGenerator(target,
|
|
runtime_dest.c_str(),
|
|
false,
|
|
runtime_permissions.c_str(),
|
|
runtime_configurations,
|
|
runtime_component.c_str(),
|
|
runtime_optional);
|
|
}
|
|
else
|
|
{
|
|
cmOStringStream e;
|
|
e << "TARGETS given no RUNTIME DESTINATION for executable target \""
|
|
<< target.GetName() << "\".";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
// On DLL platforms an executable may also have an import
|
|
// library. Install it to the archive destination if it
|
|
// exists.
|
|
if(dll_platform && archive_destination)
|
|
{
|
|
// The import library uses the ARCHIVE properties.
|
|
archiveGenerator = new cmInstallTargetGenerator(target,
|
|
archive_dest.c_str(),
|
|
true,
|
|
archive_permissions.c_str(),
|
|
archive_configurations,
|
|
archive_component.c_str(),
|
|
true);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
// This should never happen due to the above type check.
|
|
// Ignore the case.
|
|
break;
|
|
}
|
|
this->Makefile->AddInstallGenerator(archiveGenerator);
|
|
this->Makefile->AddInstallGenerator(runtimeGenerator);
|
|
this->Makefile->AddInstallGenerator(libraryGenerator);
|
|
|
|
if (!exportName.empty())
|
|
{
|
|
this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
|
|
->AddTargetToExports(exportName.c_str(),
|
|
&target,
|
|
archiveGenerator,
|
|
runtimeGenerator,
|
|
libraryGenerator);
|
|
}
|
|
}
|
|
|
|
// Tell the global generator about any installation component names
|
|
// specified.
|
|
this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
|
|
->AddInstallComponent(archive_component.c_str());
|
|
this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
|
|
->AddInstallComponent(library_component.c_str());
|
|
this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
|
|
->AddInstallComponent(runtime_component.c_str());
|
|
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmInstallCommand::HandleFilesMode(std::vector<std::string> const& args)
|
|
{
|
|
// This is the FILES mode.
|
|
bool programs = (args[0] == "PROGRAMS");
|
|
bool doing_files = true;
|
|
bool doing_destination = false;
|
|
bool doing_permissions = false;
|
|
bool doing_configurations = false;
|
|
bool doing_component = false;
|
|
bool doing_rename = false;
|
|
std::vector<std::string> files;
|
|
const char* destination = 0;
|
|
std::string rename;
|
|
std::string permissions;
|
|
std::vector<std::string> configurations;
|
|
std::string component;
|
|
bool optional = false;
|
|
for(unsigned int i=1; i < args.size(); ++i)
|
|
{
|
|
if(args[i] == "DESTINATION")
|
|
{
|
|
// Switch to setting the destination property.
|
|
doing_files = false;
|
|
doing_destination = true;
|
|
doing_permissions = false;
|
|
doing_configurations = false;
|
|
doing_component = false;
|
|
doing_rename = false;
|
|
}
|
|
else if(args[i] == "PERMISSIONS")
|
|
{
|
|
// Switch to setting the permissions property.
|
|
doing_files = false;
|
|
doing_destination = false;
|
|
doing_permissions = true;
|
|
doing_configurations = false;
|
|
doing_component = false;
|
|
doing_rename = false;
|
|
}
|
|
else if(args[i] == "CONFIGURATIONS")
|
|
{
|
|
// Switch to setting the configurations property.
|
|
doing_files = false;
|
|
doing_destination = false;
|
|
doing_permissions = false;
|
|
doing_configurations = true;
|
|
doing_component = false;
|
|
doing_rename = false;
|
|
}
|
|
else if(args[i] == "COMPONENT")
|
|
{
|
|
// Switch to setting the component property.
|
|
doing_files = false;
|
|
doing_destination = false;
|
|
doing_permissions = false;
|
|
doing_configurations = false;
|
|
doing_component = true;
|
|
doing_rename = false;
|
|
}
|
|
else if(args[i] == "RENAME")
|
|
{
|
|
// Switch to setting the rename property.
|
|
doing_files = false;
|
|
doing_destination = false;
|
|
doing_permissions = false;
|
|
doing_configurations = false;
|
|
doing_component = false;
|
|
doing_rename = true;
|
|
}
|
|
else if(args[i] == "OPTIONAL")
|
|
{
|
|
// Set the optional property.
|
|
doing_files = false;
|
|
doing_destination = false;
|
|
doing_permissions = false;
|
|
doing_configurations = false;
|
|
doing_component = false;
|
|
doing_rename = false;
|
|
optional = true;
|
|
}
|
|
else if(doing_files)
|
|
{
|
|
// Convert this file to a full path.
|
|
std::string file = args[i];
|
|
if(!cmSystemTools::FileIsFullPath(file.c_str()))
|
|
{
|
|
file = this->Makefile->GetCurrentDirectory();
|
|
file += "/";
|
|
file += args[i];
|
|
}
|
|
|
|
// Make sure the file is not a directory.
|
|
if(cmSystemTools::FileIsDirectory(file.c_str()))
|
|
{
|
|
cmOStringStream e;
|
|
e << args[0] << " given directory \"" << args[i] << "\" to install.";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
// Store the file for installation.
|
|
files.push_back(file);
|
|
}
|
|
else if(doing_configurations)
|
|
{
|
|
configurations.push_back(args[i]);
|
|
}
|
|
else if(doing_destination)
|
|
{
|
|
destination = args[i].c_str();
|
|
doing_destination = false;
|
|
}
|
|
else if(doing_component)
|
|
{
|
|
component = args[i];
|
|
doing_component = false;
|
|
}
|
|
else if(doing_permissions)
|
|
{
|
|
// Check the requested permission.
|
|
if(!this->CheckPermissions(args[i], permissions))
|
|
{
|
|
cmOStringStream e;
|
|
e << args[0] << " given invalid permission \""
|
|
<< args[i] << "\".";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
else if(doing_rename)
|
|
{
|
|
rename = args[i];
|
|
doing_rename = false;
|
|
}
|
|
else
|
|
{
|
|
// Unknown argument.
|
|
cmOStringStream e;
|
|
e << args[0] << " given unknown argument \"" << args[i] << "\".";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Check if there is something to do.
|
|
if(files.empty())
|
|
{
|
|
return true;
|
|
}
|
|
if(!destination)
|
|
{
|
|
// A destination is required.
|
|
cmOStringStream e;
|
|
e << args[0] << " given no DESTINATION!";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
if(!rename.empty() && files.size() > 1)
|
|
{
|
|
// The rename option works only with one file.
|
|
cmOStringStream e;
|
|
e << args[0] << " given RENAME option with more than one file.";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
// Compute destination path.
|
|
std::string dest;
|
|
this->ComputeDestination(destination, dest);
|
|
|
|
// Create the files install generator.
|
|
this->Makefile->AddInstallGenerator(
|
|
new cmInstallFilesGenerator(files, dest.c_str(), programs,
|
|
permissions.c_str(), configurations,
|
|
component.c_str(), rename.c_str(),
|
|
optional));
|
|
|
|
// Tell the global generator about any installation component names
|
|
// specified.
|
|
this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
|
|
->AddInstallComponent(component.c_str());
|
|
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool
|
|
cmInstallCommand::HandleDirectoryMode(std::vector<std::string> const& args)
|
|
{
|
|
bool doing_dirs = true;
|
|
bool doing_destination = false;
|
|
bool doing_pattern = false;
|
|
bool doing_regex = false;
|
|
bool doing_permissions_file = false;
|
|
bool doing_permissions_dir = false;
|
|
bool doing_permissions_match = false;
|
|
bool doing_configurations = false;
|
|
bool doing_component = false;
|
|
bool in_match_mode = false;
|
|
std::vector<std::string> dirs;
|
|
const char* destination = 0;
|
|
std::string permissions_file;
|
|
std::string permissions_dir;
|
|
std::vector<std::string> configurations;
|
|
std::string component;
|
|
std::string literal_args;
|
|
for(unsigned int i=1; i < args.size(); ++i)
|
|
{
|
|
if(args[i] == "DESTINATION")
|
|
{
|
|
if(in_match_mode)
|
|
{
|
|
cmOStringStream e;
|
|
e << args[0] << " does not allow \""
|
|
<< args[i] << "\" after PATTERN or REGEX.";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
// Switch to setting the destination property.
|
|
doing_dirs = false;
|
|
doing_destination = true;
|
|
doing_pattern = false;
|
|
doing_regex = false;
|
|
doing_permissions_file = false;
|
|
doing_permissions_dir = false;
|
|
doing_configurations = false;
|
|
doing_component = false;
|
|
}
|
|
else if(args[i] == "PATTERN")
|
|
{
|
|
// Switch to a new pattern match rule.
|
|
doing_dirs = false;
|
|
doing_destination = false;
|
|
doing_pattern = true;
|
|
doing_regex = false;
|
|
doing_permissions_file = false;
|
|
doing_permissions_dir = false;
|
|
doing_permissions_match = false;
|
|
doing_configurations = false;
|
|
doing_component = false;
|
|
in_match_mode = true;
|
|
}
|
|
else if(args[i] == "REGEX")
|
|
{
|
|
// Switch to a new regex match rule.
|
|
doing_dirs = false;
|
|
doing_destination = false;
|
|
doing_pattern = false;
|
|
doing_regex = true;
|
|
doing_permissions_file = false;
|
|
doing_permissions_dir = false;
|
|
doing_permissions_match = false;
|
|
doing_configurations = false;
|
|
doing_component = false;
|
|
in_match_mode = true;
|
|
}
|
|
else if(args[i] == "EXCLUDE")
|
|
{
|
|
// Add this property to the current match rule.
|
|
if(!in_match_mode || doing_pattern || doing_regex)
|
|
{
|
|
cmOStringStream e;
|
|
e << args[0] << " does not allow \""
|
|
<< args[i] << "\" before a PATTERN or REGEX is given.";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
literal_args += " EXCLUDE";
|
|
doing_permissions_match = false;
|
|
}
|
|
else if(args[i] == "PERMISSIONS")
|
|
{
|
|
if(!in_match_mode)
|
|
{
|
|
cmOStringStream e;
|
|
e << args[0] << " does not allow \""
|
|
<< args[i] << "\" before a PATTERN or REGEX is given.";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
// Switch to setting the current match permissions property.
|
|
literal_args += " PERMISSIONS";
|
|
doing_permissions_match = true;
|
|
}
|
|
else if(args[i] == "FILE_PERMISSIONS")
|
|
{
|
|
if(in_match_mode)
|
|
{
|
|
cmOStringStream e;
|
|
e << args[0] << " does not allow \""
|
|
<< args[i] << "\" after PATTERN or REGEX.";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
// Switch to setting the file permissions property.
|
|
doing_dirs = false;
|
|
doing_destination = false;
|
|
doing_pattern = false;
|
|
doing_regex = false;
|
|
doing_permissions_file = true;
|
|
doing_permissions_dir = false;
|
|
doing_configurations = false;
|
|
doing_component = false;
|
|
}
|
|
else if(args[i] == "DIRECTORY_PERMISSIONS")
|
|
{
|
|
if(in_match_mode)
|
|
{
|
|
cmOStringStream e;
|
|
e << args[0] << " does not allow \""
|
|
<< args[i] << "\" after PATTERN or REGEX.";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
// Switch to setting the directory permissions property.
|
|
doing_dirs = false;
|
|
doing_destination = false;
|
|
doing_pattern = false;
|
|
doing_regex = false;
|
|
doing_permissions_file = false;
|
|
doing_permissions_dir = true;
|
|
doing_configurations = false;
|
|
doing_component = false;
|
|
}
|
|
else if(args[i] == "USE_SOURCE_PERMISSIONS")
|
|
{
|
|
if(in_match_mode)
|
|
{
|
|
cmOStringStream e;
|
|
e << args[0] << " does not allow \""
|
|
<< args[i] << "\" after PATTERN or REGEX.";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
// Add this option literally.
|
|
doing_dirs = false;
|
|
doing_destination = false;
|
|
doing_pattern = false;
|
|
doing_regex = false;
|
|
doing_permissions_file = false;
|
|
doing_permissions_dir = false;
|
|
doing_configurations = false;
|
|
doing_component = false;
|
|
literal_args += " USE_SOURCE_PERMISSIONS";
|
|
}
|
|
else if(args[i] == "CONFIGURATIONS")
|
|
{
|
|
if(in_match_mode)
|
|
{
|
|
cmOStringStream e;
|
|
e << args[0] << " does not allow \""
|
|
<< args[i] << "\" after PATTERN or REGEX.";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
// Switch to setting the configurations property.
|
|
doing_dirs = false;
|
|
doing_destination = false;
|
|
doing_pattern = false;
|
|
doing_regex = false;
|
|
doing_permissions_file = false;
|
|
doing_permissions_dir = false;
|
|
doing_configurations = true;
|
|
doing_component = false;
|
|
}
|
|
else if(args[i] == "COMPONENT")
|
|
{
|
|
if(in_match_mode)
|
|
{
|
|
cmOStringStream e;
|
|
e << args[0] << " does not allow \""
|
|
<< args[i] << "\" after PATTERN or REGEX.";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
// Switch to setting the component property.
|
|
doing_dirs = false;
|
|
doing_destination = false;
|
|
doing_pattern = false;
|
|
doing_regex = false;
|
|
doing_permissions_file = false;
|
|
doing_permissions_dir = false;
|
|
doing_configurations = false;
|
|
doing_component = true;
|
|
}
|
|
else if(doing_dirs)
|
|
{
|
|
// Convert this directory to a full path.
|
|
std::string dir = args[i];
|
|
if(!cmSystemTools::FileIsFullPath(dir.c_str()))
|
|
{
|
|
dir = this->Makefile->GetCurrentDirectory();
|
|
dir += "/";
|
|
dir += args[i];
|
|
}
|
|
|
|
// Make sure the name is a directory.
|
|
if(!cmSystemTools::FileIsDirectory(dir.c_str()))
|
|
{
|
|
cmOStringStream e;
|
|
e << args[0] << " given non-directory \""
|
|
<< args[i] << "\" to install.";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
// Store the directory for installation.
|
|
dirs.push_back(dir);
|
|
}
|
|
else if(doing_configurations)
|
|
{
|
|
configurations.push_back(args[i]);
|
|
}
|
|
else if(doing_destination)
|
|
{
|
|
destination = args[i].c_str();
|
|
doing_destination = false;
|
|
}
|
|
else if(doing_pattern)
|
|
{
|
|
// Convert the pattern to a regular expression. Require a
|
|
// leading slash and trailing end-of-string in the matched
|
|
// string to make sure the pattern matches only whole file
|
|
// names.
|
|
literal_args += " REGEX \"/";
|
|
std::string regex = cmsys::Glob::PatternToRegex(args[i], false);
|
|
cmSystemTools::ReplaceString(regex, "\\", "\\\\");
|
|
literal_args += regex;
|
|
literal_args += "$\"";
|
|
doing_pattern = false;
|
|
}
|
|
else if(doing_regex)
|
|
{
|
|
literal_args += " REGEX \"";
|
|
// Match rules are case-insensitive on some platforms.
|
|
#if defined(_WIN32) || defined(__APPLE__) || defined(__CYGWIN__)
|
|
std::string regex = cmSystemTools::LowerCase(args[i]);
|
|
#else
|
|
std::string regex = args[i];
|
|
#endif
|
|
cmSystemTools::ReplaceString(regex, "\\", "\\\\");
|
|
literal_args += regex;
|
|
literal_args += "\"";
|
|
doing_regex = false;
|
|
}
|
|
else if(doing_component)
|
|
{
|
|
component = args[i];
|
|
doing_component = false;
|
|
}
|
|
else if(doing_permissions_file)
|
|
{
|
|
// Check the requested permission.
|
|
if(!this->CheckPermissions(args[i], permissions_file))
|
|
{
|
|
cmOStringStream e;
|
|
e << args[0] << " given invalid file permission \""
|
|
<< args[i] << "\".";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
else if(doing_permissions_dir)
|
|
{
|
|
// Check the requested permission.
|
|
if(!this->CheckPermissions(args[i], permissions_dir))
|
|
{
|
|
cmOStringStream e;
|
|
e << args[0] << " given invalid directory permission \""
|
|
<< args[i] << "\".";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
else if(doing_permissions_match)
|
|
{
|
|
// Check the requested permission.
|
|
if(!this->CheckPermissions(args[i], literal_args))
|
|
{
|
|
cmOStringStream e;
|
|
e << args[0] << " given invalid permission \""
|
|
<< args[i] << "\".";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Unknown argument.
|
|
cmOStringStream e;
|
|
e << args[0] << " given unknown argument \"" << args[i] << "\".";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Support installing an empty directory.
|
|
if(dirs.empty() && destination)
|
|
{
|
|
dirs.push_back("");
|
|
}
|
|
|
|
// Check if there is something to do.
|
|
if(dirs.empty())
|
|
{
|
|
return true;
|
|
}
|
|
if(!destination)
|
|
{
|
|
// A destination is required.
|
|
cmOStringStream e;
|
|
e << args[0] << " given no DESTINATION!";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
|
|
// Compute destination path.
|
|
std::string dest;
|
|
this->ComputeDestination(destination, dest);
|
|
|
|
// Create the directory install generator.
|
|
this->Makefile->AddInstallGenerator(
|
|
new cmInstallDirectoryGenerator(dirs, dest.c_str(),
|
|
permissions_file.c_str(),
|
|
permissions_dir.c_str(),
|
|
configurations,
|
|
component.c_str(),
|
|
literal_args.c_str()));
|
|
|
|
// Tell the global generator about any installation component names
|
|
// specified.
|
|
this->Makefile->GetLocalGenerator()->GetGlobalGenerator()
|
|
->AddInstallComponent(component.c_str());
|
|
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmInstallCommand::HandleExportMode(std::vector<std::string> const& args)
|
|
{
|
|
// This is the EXPORT mode.
|
|
bool doing_exports = true;
|
|
bool doing_destination = false;
|
|
bool doing_permissions = false;
|
|
bool doing_configurations = false;
|
|
bool doing_filename = false;
|
|
bool doing_prefix = false;
|
|
std::vector<std::string> exports;
|
|
const char* destination = 0;
|
|
std::string filename;
|
|
std::string permissions;
|
|
std::string prefix;
|
|
std::vector<std::string> configurations;
|
|
for(unsigned int i=1; i < args.size(); ++i)
|
|
{
|
|
if(args[i] == "DESTINATION")
|
|
{
|
|
// Switch to setting the destination property.
|
|
doing_exports = false;
|
|
doing_destination = true;
|
|
doing_permissions = false;
|
|
doing_configurations = false;
|
|
doing_filename = false;
|
|
doing_prefix = false;
|
|
}
|
|
else if(args[i] == "PERMISSIONS")
|
|
{
|
|
// Switch to setting the permissions property.
|
|
doing_exports = false;
|
|
doing_destination = false;
|
|
doing_permissions = true;
|
|
doing_configurations = false;
|
|
doing_filename = false;
|
|
doing_prefix = false;
|
|
}
|
|
else if(args[i] == "CONFIGURATIONS")
|
|
{
|
|
// Switch to setting the configurations property.
|
|
doing_exports = false;
|
|
doing_destination = false;
|
|
doing_permissions = false;
|
|
doing_configurations = true;
|
|
doing_filename = false;
|
|
doing_prefix = false;
|
|
}
|
|
else if(args[i] == "FILENAME")
|
|
{
|
|
// Switch to setting the rename property.
|
|
doing_exports = false;
|
|
doing_destination = false;
|
|
doing_permissions = false;
|
|
doing_configurations = false;
|
|
doing_filename = true;
|
|
doing_prefix = false;
|
|
}
|
|
else if(args[i] == "PREFIX")
|
|
{
|
|
// Switch to setting the rename property.
|
|
doing_exports = false;
|
|
doing_destination = false;
|
|
doing_permissions = false;
|
|
doing_configurations = false;
|
|
doing_filename = false;
|
|
doing_prefix = true;
|
|
}
|
|
else if(doing_exports)
|
|
{
|
|
// Store the file for installation.
|
|
exports.push_back(args[i]);
|
|
}
|
|
else if(doing_configurations)
|
|
{
|
|
configurations.push_back(args[i]);
|
|
}
|
|
else if(doing_destination)
|
|
{
|
|
destination = args[i].c_str();
|
|
doing_destination = false;
|
|
}
|
|
else if(doing_permissions)
|
|
{
|
|
// Check the requested permission.
|
|
if(!this->CheckPermissions(args[i], permissions))
|
|
{
|
|
cmOStringStream e;
|
|
e << args[0] << " given invalid permission \""
|
|
<< args[i] << "\".";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
else if(doing_filename)
|
|
{
|
|
filename = args[i];
|
|
doing_filename = false;
|
|
}
|
|
else if(doing_prefix)
|
|
{
|
|
prefix = args[i];
|
|
doing_prefix = false;
|
|
}
|
|
else
|
|
{
|
|
// Unknown argument.
|
|
cmOStringStream e;
|
|
e << args[0] << " given unknown argument \"" << args[i] << "\".";
|
|
this->SetError(e.str().c_str());
|
|
return false;
|
|
}
|
|
}
|
|
|
|
std::string cmakeDir = this->Makefile->GetHomeOutputDirectory();
|
|
cmakeDir += cmake::GetCMakeFilesDirectory();
|
|
for(std::vector<std::string>::const_iterator exportIt = exports.begin();
|
|
exportIt != exports.end();
|
|
++exportIt)
|
|
{
|
|
|
|
const std::vector<cmTargetExport*>* exportSet = this->
|
|
Makefile->GetLocalGenerator()->GetGlobalGenerator()->
|
|
GetExportSet(exportIt->c_str());
|
|
if (exportSet == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Create the export install generator.
|
|
cmInstallExportGenerator* exportGenerator = new cmInstallExportGenerator(
|
|
destination, permissions.c_str(), configurations,
|
|
filename.c_str(), prefix.c_str(), cmakeDir.c_str());
|
|
|
|
if (exportGenerator->SetExportSet(exportIt->c_str(),exportSet))
|
|
{
|
|
this->Makefile->AddInstallGenerator(exportGenerator);
|
|
}
|
|
else
|
|
{
|
|
delete exportGenerator;
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
void cmInstallCommand::ComputeDestination(const char* destination,
|
|
std::string& dest) const
|
|
{
|
|
if(destination)
|
|
{
|
|
if(cmSystemTools::FileIsFullPath(destination))
|
|
{
|
|
// Full paths are absolute.
|
|
dest = destination;
|
|
}
|
|
else
|
|
{
|
|
// Relative paths are treated with respect to the installation prefix.
|
|
dest = "${CMAKE_INSTALL_PREFIX}/";
|
|
dest += destination;
|
|
}
|
|
|
|
// Format the path nicely. Note this also removes trailing
|
|
// slashes.
|
|
cmSystemTools::ConvertToUnixSlashes(dest);
|
|
}
|
|
else
|
|
{
|
|
dest = "";
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
bool cmInstallCommand::CheckPermissions(std::string const& arg,
|
|
std::string& permissions) const
|
|
{
|
|
// Table of valid permissions.
|
|
const char* table[] =
|
|
{
|
|
"OWNER_READ", "OWNER_WRITE", "OWNER_EXECUTE",
|
|
"GROUP_READ", "GROUP_WRITE", "GROUP_EXECUTE",
|
|
"WORLD_READ", "WORLD_WRITE", "WORLD_EXECUTE",
|
|
"SETUID", "SETGID", 0
|
|
};
|
|
|
|
// Check the permission against the table.
|
|
for(const char** valid = table; *valid; ++valid)
|
|
{
|
|
if(arg == *valid)
|
|
{
|
|
// This is a valid permission.
|
|
permissions += " ";
|
|
permissions += arg;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
// This is not a valid permission.
|
|
return false;
|
|
}
|