You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
620 lines
23 KiB
620 lines
23 KiB
/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
|
|
file Copyright.txt or https://cmake.org/licensing for details. */
|
|
|
|
#include <algorithm>
|
|
#include <cstddef>
|
|
#include <functional>
|
|
#include <iostream>
|
|
#include <iterator>
|
|
#include <map>
|
|
#include <memory>
|
|
#include <sstream>
|
|
#include <string>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include <cm/optional>
|
|
#include <cmext/algorithm>
|
|
|
|
#include "cmsys/Encoding.hxx"
|
|
|
|
#include "cmCMakePresetsGraph.h"
|
|
#include "cmCPackGenerator.h"
|
|
#include "cmCPackGeneratorFactory.h"
|
|
#include "cmCPackLog.h"
|
|
#include "cmCommandLineArgument.h"
|
|
#include "cmConsoleBuf.h"
|
|
#include "cmDocumentation.h"
|
|
#include "cmDocumentationEntry.h"
|
|
#include "cmGlobalGenerator.h"
|
|
#include "cmJSONState.h"
|
|
#include "cmList.h"
|
|
#include "cmMakefile.h"
|
|
#include "cmState.h"
|
|
#include "cmStateSnapshot.h"
|
|
#include "cmStringAlgorithms.h"
|
|
#include "cmSystemTools.h"
|
|
#include "cmValue.h"
|
|
#include "cmake.h"
|
|
|
|
namespace {
|
|
const cmDocumentationEntry cmDocumentationName = {
|
|
{},
|
|
" cpack - Packaging driver provided by CMake."
|
|
};
|
|
|
|
const cmDocumentationEntry cmDocumentationUsage = { {}, " cpack [options]" };
|
|
|
|
const cmDocumentationEntry cmDocumentationOptions[14] = {
|
|
{ "-G <generators>", "Override/define CPACK_GENERATOR" },
|
|
{ "-C <Configuration>", "Specify the project configuration" },
|
|
{ "-D <var>=<value>", "Set a CPack variable." },
|
|
{ "--config <configFile>", "Specify the config file." },
|
|
{ "-V,--verbose", "Enable verbose output" },
|
|
{ "--trace", "Put underlying cmake scripts in trace mode." },
|
|
{ "--trace-expand", "Put underlying cmake scripts in expanded trace mode." },
|
|
{ "--debug", "Enable debug output (for CPack developers)" },
|
|
{ "-P <packageName>", "Override/define CPACK_PACKAGE_NAME" },
|
|
{ "-R <packageVersion>", "Override/define CPACK_PACKAGE_VERSION" },
|
|
{ "-B <packageDirectory>", "Override/define CPACK_PACKAGE_DIRECTORY" },
|
|
{ "--vendor <vendorName>", "Override/define CPACK_PACKAGE_VENDOR" },
|
|
{ "--preset", "Read arguments from a package preset" },
|
|
{ "--list-presets", "List available package presets" }
|
|
};
|
|
|
|
void cpackProgressCallback(const std::string& message, float /*unused*/)
|
|
{
|
|
std::cout << "-- " << message << '\n';
|
|
}
|
|
|
|
std::vector<cmDocumentationEntry> makeGeneratorDocs(
|
|
const cmCPackGeneratorFactory& gf)
|
|
{
|
|
const auto& generators = gf.GetGeneratorsList();
|
|
|
|
std::vector<cmDocumentationEntry> docs;
|
|
docs.reserve(generators.size());
|
|
|
|
std::transform(
|
|
generators.cbegin(), generators.cend(), std::back_inserter(docs),
|
|
[](const std::decay<decltype(generators)>::type::value_type& gen) {
|
|
return cmDocumentationEntry{ gen.first, gen.second };
|
|
});
|
|
return docs;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
// this is CPack.
|
|
int main(int argc, char const* const* argv)
|
|
{
|
|
cmSystemTools::EnsureStdPipes();
|
|
|
|
// Replace streambuf so we can output Unicode to console
|
|
cmConsoleBuf consoleBuf;
|
|
consoleBuf.SetUTF8Pipes();
|
|
|
|
cmsys::Encoding::CommandLineArguments args =
|
|
cmsys::Encoding::CommandLineArguments::Main(argc, argv);
|
|
argc = args.argc();
|
|
argv = args.argv();
|
|
|
|
std::vector<std::string> inputArgs;
|
|
inputArgs.reserve(argc - 1);
|
|
cm::append(inputArgs, argv + 1, argv + argc);
|
|
|
|
cmSystemTools::InitializeLibUV();
|
|
cmSystemTools::FindCMakeResources(argv[0]);
|
|
cmCPackLog log;
|
|
|
|
log.SetErrorPrefix("CPack Error: ");
|
|
log.SetWarningPrefix("CPack Warning: ");
|
|
log.SetOutputPrefix("CPack: ");
|
|
log.SetVerbosePrefix("CPack Verbose: ");
|
|
|
|
if (cmSystemTools::GetCurrentWorkingDirectory().empty()) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"Current working directory cannot be established.\n");
|
|
return 1;
|
|
}
|
|
|
|
std::string generator;
|
|
bool help = false;
|
|
bool helpVersion = false;
|
|
std::string helpFull;
|
|
std::string helpMAN;
|
|
std::string helpHTML;
|
|
|
|
std::string cpackProjectName;
|
|
std::string cpackProjectDirectory;
|
|
std::string cpackBuildConfig;
|
|
std::string cpackProjectVersion;
|
|
std::string cpackProjectPatch;
|
|
std::string cpackProjectVendor;
|
|
std::string cpackConfigFile;
|
|
|
|
std::string preset;
|
|
bool listPresets = false;
|
|
|
|
std::map<std::string, std::string> definitions;
|
|
|
|
auto const verboseLambda = [&log](const std::string&, cmake*,
|
|
cmMakefile*) -> bool {
|
|
log.SetVerbose(true);
|
|
cmCPack_Log(&log, cmCPackLog::LOG_OUTPUT, "Enable Verbose\n");
|
|
return true;
|
|
};
|
|
|
|
auto const debugLambda = [&log](const std::string&, cmake*,
|
|
cmMakefile*) -> bool {
|
|
log.SetDebug(true);
|
|
cmCPack_Log(&log, cmCPackLog::LOG_OUTPUT, "Enable Debug\n");
|
|
return true;
|
|
};
|
|
|
|
auto const traceLambda = [](const std::string&, cmake* state,
|
|
cmMakefile*) -> bool {
|
|
state->SetTrace(true);
|
|
return true;
|
|
};
|
|
|
|
auto const traceExpandLambda = [](const std::string&, cmake* state,
|
|
cmMakefile*) -> bool {
|
|
state->SetTrace(true);
|
|
state->SetTraceExpand(true);
|
|
return true;
|
|
};
|
|
|
|
using CommandArgument =
|
|
cmCommandLineArgument<bool(std::string const&, cmake*, cmMakefile*)>;
|
|
|
|
std::vector<CommandArgument> arguments = {
|
|
CommandArgument{ "--help", CommandArgument::Values::Zero,
|
|
CommandArgument::setToTrue(help) },
|
|
CommandArgument{ "--help-full", CommandArgument::Values::Zero,
|
|
CommandArgument::setToValue(helpFull) },
|
|
CommandArgument{ "--help-html", CommandArgument::Values::Zero,
|
|
CommandArgument::setToValue(helpHTML) },
|
|
CommandArgument{ "--help-man", CommandArgument::Values::Zero,
|
|
CommandArgument::setToValue(helpMAN) },
|
|
CommandArgument{ "--version", CommandArgument::Values::Zero,
|
|
CommandArgument::setToTrue(helpVersion) },
|
|
CommandArgument{ "-V", CommandArgument::Values::Zero, verboseLambda },
|
|
CommandArgument{ "--verbose", CommandArgument::Values::Zero,
|
|
verboseLambda },
|
|
CommandArgument{ "--debug", CommandArgument::Values::Zero, debugLambda },
|
|
CommandArgument{ "--config", CommandArgument::Values::One,
|
|
CommandArgument::setToValue(cpackConfigFile) },
|
|
CommandArgument{ "--trace", CommandArgument::Values::Zero, traceLambda },
|
|
CommandArgument{ "--trace-expand", CommandArgument::Values::Zero,
|
|
traceExpandLambda },
|
|
CommandArgument{ "-C", CommandArgument::Values::One,
|
|
CommandArgument::setToValue(cpackBuildConfig) },
|
|
CommandArgument{ "-G", CommandArgument::Values::One,
|
|
CommandArgument::setToValue(generator) },
|
|
CommandArgument{ "-P", CommandArgument::Values::One,
|
|
CommandArgument::setToValue(cpackProjectName) },
|
|
CommandArgument{ "-R", CommandArgument::Values::One,
|
|
CommandArgument::setToValue(cpackProjectVersion) },
|
|
CommandArgument{ "-B", CommandArgument::Values::One,
|
|
CommandArgument::setToValue(cpackProjectDirectory) },
|
|
CommandArgument{ "--patch", CommandArgument::Values::One,
|
|
CommandArgument::setToValue(cpackProjectPatch) },
|
|
CommandArgument{ "--vendor", CommandArgument::Values::One,
|
|
CommandArgument::setToValue(cpackProjectVendor) },
|
|
CommandArgument{ "--preset", CommandArgument::Values::One,
|
|
CommandArgument::setToValue(preset) },
|
|
CommandArgument{ "--list-presets", CommandArgument::Values::Zero,
|
|
CommandArgument::setToTrue(listPresets) },
|
|
CommandArgument{ "-D", CommandArgument::Values::One,
|
|
[&log, &definitions](const std::string& arg, cmake*,
|
|
cmMakefile*) -> bool {
|
|
std::string value = arg;
|
|
size_t pos = value.find_first_of('=');
|
|
if (pos == std::string::npos) {
|
|
cmCPack_Log(
|
|
&log, cmCPackLog::LOG_ERROR,
|
|
"Please specify CPack definitions as: KEY=VALUE\n");
|
|
return false;
|
|
}
|
|
std::string key = value.substr(0, pos);
|
|
value.erase(0, pos + 1);
|
|
definitions[key] = value;
|
|
cmCPack_Log(&log, cmCPackLog::LOG_DEBUG,
|
|
"Set CPack variable: " << key << " to \""
|
|
<< value << "\"\n");
|
|
return true;
|
|
} },
|
|
};
|
|
|
|
cmake cminst(cmake::RoleScript, cmState::CPack);
|
|
cminst.SetHomeDirectory("");
|
|
cminst.SetHomeOutputDirectory("");
|
|
cminst.SetProgressCallback(cpackProgressCallback);
|
|
cminst.GetCurrentSnapshot().SetDefaultDefinitions();
|
|
cmGlobalGenerator cmgg(&cminst);
|
|
cmMakefile globalMF(&cmgg, cminst.GetCurrentSnapshot());
|
|
|
|
bool parsed = true;
|
|
for (std::size_t i = 0; i < inputArgs.size(); i++) {
|
|
auto const& arg = inputArgs[i];
|
|
for (auto const& m : arguments) {
|
|
if (m.matches(arg)) {
|
|
if (!m.parse(arg, i, inputArgs, &cminst, &globalMF)) {
|
|
parsed = false;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
cmCPackGeneratorFactory generators;
|
|
generators.SetLogger(&log);
|
|
|
|
// Set up presets
|
|
if (!preset.empty() || listPresets) {
|
|
const auto workingDirectory = cmSystemTools::GetCurrentWorkingDirectory();
|
|
|
|
auto const presetGeneratorsPresent =
|
|
[&generators](const cmCMakePresetsGraph::PackagePreset& p) {
|
|
return std::all_of(p.Generators.begin(), p.Generators.end(),
|
|
[&generators](const std::string& gen) {
|
|
return generators.GetGeneratorsList().count(
|
|
gen) != 0;
|
|
});
|
|
};
|
|
|
|
cmCMakePresetsGraph presetsGraph;
|
|
auto result = presetsGraph.ReadProjectPresets(workingDirectory);
|
|
if (result != true) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"Could not read presets from "
|
|
<< workingDirectory << ":"
|
|
<< presetsGraph.parseState.GetErrorMessage() << '\n');
|
|
return 1;
|
|
}
|
|
|
|
if (listPresets) {
|
|
presetsGraph.PrintPackagePresetList(presetGeneratorsPresent);
|
|
return 0;
|
|
}
|
|
|
|
auto presetPair = presetsGraph.PackagePresets.find(preset);
|
|
if (presetPair == presetsGraph.PackagePresets.end()) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"No such package preset in " << workingDirectory << ": \""
|
|
<< preset << "\"\n");
|
|
presetsGraph.PrintPackagePresetList(presetGeneratorsPresent);
|
|
return 1;
|
|
}
|
|
|
|
if (presetPair->second.Unexpanded.Hidden) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"Cannot use hidden package preset in "
|
|
<< workingDirectory << ": \"" << preset << "\"\n");
|
|
presetsGraph.PrintPackagePresetList(presetGeneratorsPresent);
|
|
return 1;
|
|
}
|
|
|
|
auto const& expandedPreset = presetPair->second.Expanded;
|
|
if (!expandedPreset) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"Could not evaluate package preset \""
|
|
<< preset << "\": Invalid macro expansion\n");
|
|
presetsGraph.PrintPackagePresetList(presetGeneratorsPresent);
|
|
return 1;
|
|
}
|
|
|
|
if (!expandedPreset->ConditionResult) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"Cannot use disabled package preset in "
|
|
<< workingDirectory << ": \"" << preset << "\"\n");
|
|
presetsGraph.PrintPackagePresetList(presetGeneratorsPresent);
|
|
return 1;
|
|
}
|
|
|
|
if (!presetGeneratorsPresent(presetPair->second.Unexpanded)) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR, "Cannot use preset");
|
|
presetsGraph.PrintPackagePresetList(presetGeneratorsPresent);
|
|
return 1;
|
|
}
|
|
|
|
auto configurePresetPair =
|
|
presetsGraph.ConfigurePresets.find(expandedPreset->ConfigurePreset);
|
|
if (configurePresetPair == presetsGraph.ConfigurePresets.end()) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"No such configure preset in "
|
|
<< workingDirectory << ": \""
|
|
<< expandedPreset->ConfigurePreset << "\"\n");
|
|
presetsGraph.PrintConfigurePresetList();
|
|
return 1;
|
|
}
|
|
|
|
if (configurePresetPair->second.Unexpanded.Hidden) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"Cannot use hidden configure preset in "
|
|
<< workingDirectory << ": \""
|
|
<< expandedPreset->ConfigurePreset << "\"\n");
|
|
presetsGraph.PrintConfigurePresetList();
|
|
return 1;
|
|
}
|
|
|
|
auto const& expandedConfigurePreset = configurePresetPair->second.Expanded;
|
|
if (!expandedConfigurePreset) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"Could not evaluate configure preset \""
|
|
<< expandedPreset->ConfigurePreset
|
|
<< "\": Invalid macro expansion\n");
|
|
return 1;
|
|
}
|
|
|
|
cmSystemTools::ChangeDirectory(expandedConfigurePreset->BinaryDir);
|
|
|
|
auto presetEnvironment = expandedPreset->Environment;
|
|
for (auto const& var : presetEnvironment) {
|
|
if (var.second) {
|
|
cmSystemTools::PutEnv(cmStrCat(var.first, '=', *var.second));
|
|
}
|
|
}
|
|
|
|
if (!expandedPreset->ConfigFile.empty() && cpackConfigFile.empty()) {
|
|
cpackConfigFile = expandedPreset->ConfigFile;
|
|
}
|
|
|
|
if (!expandedPreset->Generators.empty() && generator.empty()) {
|
|
generator = cmList::to_string(expandedPreset->Generators);
|
|
}
|
|
|
|
if (!expandedPreset->Configurations.empty() && cpackBuildConfig.empty()) {
|
|
cpackBuildConfig = cmList::to_string(expandedPreset->Configurations);
|
|
}
|
|
|
|
definitions.insert(expandedPreset->Variables.begin(),
|
|
expandedPreset->Variables.end());
|
|
|
|
if (expandedPreset->DebugOutput == true) {
|
|
debugLambda("", &cminst, &globalMF);
|
|
}
|
|
|
|
if (expandedPreset->VerboseOutput == true) {
|
|
verboseLambda("", &cminst, &globalMF);
|
|
}
|
|
|
|
if (!expandedPreset->PackageName.empty() && cpackProjectName.empty()) {
|
|
cpackProjectName = expandedPreset->PackageName;
|
|
}
|
|
|
|
if (!expandedPreset->PackageVersion.empty() &&
|
|
cpackProjectVersion.empty()) {
|
|
cpackProjectVersion = expandedPreset->PackageVersion;
|
|
}
|
|
|
|
if (!expandedPreset->PackageDirectory.empty() &&
|
|
cpackProjectDirectory.empty()) {
|
|
cpackProjectDirectory = expandedPreset->PackageDirectory;
|
|
}
|
|
|
|
if (!expandedPreset->VendorName.empty() && cpackProjectVendor.empty()) {
|
|
cpackProjectVendor = expandedPreset->VendorName;
|
|
}
|
|
}
|
|
|
|
cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
|
|
"Read CPack config file: " << cpackConfigFile << '\n');
|
|
|
|
bool cpackConfigFileSpecified = true;
|
|
if (!cpackConfigFile.empty()) {
|
|
cpackConfigFile = cmSystemTools::CollapseFullPath(cpackConfigFile);
|
|
} else {
|
|
cpackConfigFile = cmStrCat(cmSystemTools::GetCurrentWorkingDirectory(),
|
|
"/CPackConfig.cmake");
|
|
cpackConfigFileSpecified = false;
|
|
}
|
|
|
|
cmDocumentation doc;
|
|
doc.addCPackStandardDocSections();
|
|
/* Were we invoked to display doc or to do some work ?
|
|
* Unlike cmake launching cpack with zero argument
|
|
* should launch cpack using "cpackConfigFile" if it exists
|
|
* in the current directory.
|
|
*/
|
|
help = doc.CheckOptions(argc, argv, "-G") && argc != 1;
|
|
|
|
// This part is used for cpack documentation lookup as well.
|
|
cminst.AddCMakePaths();
|
|
|
|
if (parsed && !help) {
|
|
// find out which system cpack is running on, so it can setup the search
|
|
// paths, so FIND_XXX() commands can be used in scripts
|
|
std::string systemFile =
|
|
globalMF.GetModulesFile("CMakeDetermineSystem.cmake");
|
|
if (!globalMF.ReadListFile(systemFile)) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"Error reading CMakeDetermineSystem.cmake\n");
|
|
return 1;
|
|
}
|
|
|
|
systemFile =
|
|
globalMF.GetModulesFile("CMakeSystemSpecificInformation.cmake");
|
|
if (!globalMF.ReadListFile(systemFile)) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"Error reading CMakeSystemSpecificInformation.cmake\n");
|
|
return 1;
|
|
}
|
|
|
|
if (!cpackBuildConfig.empty()) {
|
|
globalMF.AddDefinition("CPACK_BUILD_CONFIG", cpackBuildConfig);
|
|
}
|
|
|
|
if (cmSystemTools::FileExists(cpackConfigFile)) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
|
|
"Read CPack configuration file: " << cpackConfigFile
|
|
<< '\n');
|
|
if (!globalMF.ReadListFile(cpackConfigFile)) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"Problem reading CPack config file: \"" << cpackConfigFile
|
|
<< "\"\n");
|
|
return 1;
|
|
}
|
|
} else if (cpackConfigFileSpecified) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"Cannot find CPack config file: \"" << cpackConfigFile
|
|
<< "\"\n");
|
|
return 1;
|
|
}
|
|
|
|
if (!generator.empty()) {
|
|
globalMF.AddDefinition("CPACK_GENERATOR", generator);
|
|
}
|
|
if (!cpackProjectName.empty()) {
|
|
globalMF.AddDefinition("CPACK_PACKAGE_NAME", cpackProjectName);
|
|
}
|
|
if (!cpackProjectVersion.empty()) {
|
|
globalMF.AddDefinition("CPACK_PACKAGE_VERSION", cpackProjectVersion);
|
|
}
|
|
if (!cpackProjectVendor.empty()) {
|
|
globalMF.AddDefinition("CPACK_PACKAGE_VENDOR", cpackProjectVendor);
|
|
}
|
|
if (!cpackProjectDirectory.empty()) {
|
|
// The value has been set on the command line. Ensure it is absolute.
|
|
cpackProjectDirectory =
|
|
cmSystemTools::CollapseFullPath(cpackProjectDirectory);
|
|
} else {
|
|
// The value has not been set on the command line. Check config file.
|
|
if (cmValue pd = globalMF.GetDefinition("CPACK_PACKAGE_DIRECTORY")) {
|
|
// The value has been set in the config file. Ensure it is absolute.
|
|
cpackProjectDirectory = cmSystemTools::CollapseFullPath(*pd);
|
|
} else {
|
|
// Default to the current working directory.
|
|
cpackProjectDirectory = cmSystemTools::GetCurrentWorkingDirectory();
|
|
}
|
|
}
|
|
globalMF.AddDefinition("CPACK_PACKAGE_DIRECTORY", cpackProjectDirectory);
|
|
|
|
for (auto const& cd : definitions) {
|
|
globalMF.AddDefinition(cd.first, cd.second);
|
|
}
|
|
|
|
cmValue cpackModulesPath = globalMF.GetDefinition("CPACK_MODULE_PATH");
|
|
if (cpackModulesPath) {
|
|
globalMF.AddDefinition("CMAKE_MODULE_PATH", *cpackModulesPath);
|
|
}
|
|
cmValue genList = globalMF.GetDefinition("CPACK_GENERATOR");
|
|
if (!genList) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"CPack generator not specified\n");
|
|
} else {
|
|
cmList generatorsList{ *genList };
|
|
for (std::string const& gen : generatorsList) {
|
|
cmMakefile::ScopePushPop raii(&globalMF);
|
|
cmMakefile* mf = &globalMF;
|
|
cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
|
|
"Specified generator: " << gen << '\n');
|
|
if (!mf->GetDefinition("CPACK_PACKAGE_NAME")) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"CPack project name not specified" << '\n');
|
|
parsed = false;
|
|
}
|
|
if (parsed &&
|
|
!(mf->GetDefinition("CPACK_PACKAGE_VERSION") ||
|
|
(mf->GetDefinition("CPACK_PACKAGE_VERSION_MAJOR") &&
|
|
mf->GetDefinition("CPACK_PACKAGE_VERSION_MINOR") &&
|
|
mf->GetDefinition("CPACK_PACKAGE_VERSION_PATCH")))) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"CPack project version not specified\n"
|
|
"Specify CPACK_PACKAGE_VERSION, or "
|
|
"CPACK_PACKAGE_VERSION_MAJOR, "
|
|
"CPACK_PACKAGE_VERSION_MINOR, and "
|
|
"CPACK_PACKAGE_VERSION_PATCH.\n");
|
|
parsed = false;
|
|
}
|
|
if (parsed) {
|
|
std::unique_ptr<cmCPackGenerator> cpackGenerator =
|
|
generators.NewGenerator(gen);
|
|
if (cpackGenerator) {
|
|
cpackGenerator->SetTrace(cminst.GetTrace());
|
|
cpackGenerator->SetTraceExpand(cminst.GetTraceExpand());
|
|
} else {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"Could not create CPack generator: " << gen << '\n');
|
|
// Print out all the valid generators
|
|
cmDocumentation generatorDocs;
|
|
generatorDocs.SetSection("Generators",
|
|
makeGeneratorDocs(generators));
|
|
std::cerr << '\n';
|
|
generatorDocs.PrintDocumentation(cmDocumentation::ListGenerators,
|
|
std::cerr);
|
|
parsed = false;
|
|
}
|
|
|
|
if (parsed && !cpackGenerator->Initialize(gen, mf)) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"Cannot initialize the generator " << gen << '\n');
|
|
parsed = false;
|
|
}
|
|
|
|
if (!mf->GetDefinition("CPACK_INSTALL_COMMANDS") &&
|
|
!mf->GetDefinition("CPACK_INSTALL_SCRIPT") &&
|
|
!mf->GetDefinition("CPACK_INSTALLED_DIRECTORIES") &&
|
|
!mf->GetDefinition("CPACK_INSTALL_CMAKE_PROJECTS")) {
|
|
cmCPack_Log(
|
|
&log, cmCPackLog::LOG_ERROR,
|
|
"Please specify build tree of the project that uses CMake "
|
|
"using CPACK_INSTALL_CMAKE_PROJECTS, specify "
|
|
"CPACK_INSTALL_COMMANDS, CPACK_INSTALL_SCRIPT, or "
|
|
"CPACK_INSTALLED_DIRECTORIES.\n");
|
|
parsed = false;
|
|
}
|
|
if (parsed) {
|
|
cmValue projName = mf->GetDefinition("CPACK_PACKAGE_NAME");
|
|
cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
|
|
"Use generator: " << cpackGenerator->GetNameOfClass()
|
|
<< '\n');
|
|
cmCPack_Log(&log, cmCPackLog::LOG_VERBOSE,
|
|
"For project: " << *projName << '\n');
|
|
|
|
cmValue projVersion = mf->GetDefinition("CPACK_PACKAGE_VERSION");
|
|
if (!projVersion) {
|
|
cmValue projVersionMajor =
|
|
mf->GetDefinition("CPACK_PACKAGE_VERSION_MAJOR");
|
|
cmValue projVersionMinor =
|
|
mf->GetDefinition("CPACK_PACKAGE_VERSION_MINOR");
|
|
cmValue projVersionPatch =
|
|
mf->GetDefinition("CPACK_PACKAGE_VERSION_PATCH");
|
|
std::ostringstream ostr;
|
|
ostr << *projVersionMajor << '.' << *projVersionMinor << '.'
|
|
<< *projVersionPatch;
|
|
mf->AddDefinition("CPACK_PACKAGE_VERSION", ostr.str());
|
|
}
|
|
|
|
int res = cpackGenerator->DoPackage();
|
|
if (!res) {
|
|
cmCPack_Log(&log, cmCPackLog::LOG_ERROR,
|
|
"Error when generating package: " << *projName
|
|
<< '\n');
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* In this case we are building the documentation object
|
|
* instance in order to create appropriate structure
|
|
* in order to satisfy the appropriate --help-xxx request
|
|
*/
|
|
if (help) {
|
|
// Construct and print requested documentation.
|
|
doc.SetName("cpack");
|
|
doc.SetSection("Name", cmDocumentationName);
|
|
doc.SetSection("Usage", cmDocumentationUsage);
|
|
doc.PrependSection("Options", cmDocumentationOptions);
|
|
doc.SetSection("Generators", makeGeneratorDocs(generators));
|
|
return !doc.PrintRequestedDocumentation(std::cout);
|
|
}
|
|
|
|
return int(cmSystemTools::GetErrorOccurredFlag());
|
|
}
|