Source/cmExportCommand.cxx - third_party/cmake - Git at Google

 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
    file Copyright.txt or https://cmake.org/licensing for details.  */
 #include "cmExportCommand.h"

 #include "cmsys/RegularExpression.hxx"
 #include <map>
 #include <sstream>

 #include "cmExportBuildAndroidMKGenerator.h"
 #include "cmExportBuildFileGenerator.h"
 #include "cmExportSetMap.h"
 #include "cmGeneratedFileStream.h"
 #include "cmGlobalGenerator.h"
 #include "cmMakefile.h"
 #include "cmStateTypes.h"
 #include "cmSystemTools.h"
 #include "cmTarget.h"
 #include "cmake.h"

 class cmExecutionStatus;

 #if defined(__HAIKU__)
 #  include <FindDirectory.h>
 #  include <StorageDefs.h>
 #endif

 cmExportCommand::cmExportCommand()
   : cmCommand()
   , ArgumentGroup()
   , Targets(&Helper, "TARGETS")
   , Append(&Helper, "APPEND", &ArgumentGroup)
   , ExportSetName(&Helper, "EXPORT", &ArgumentGroup)
   , Namespace(&Helper, "NAMESPACE", &ArgumentGroup)
   , Filename(&Helper, "FILE", &ArgumentGroup)
   , ExportOld(&Helper, "EXPORT_LINK_INTERFACE_LIBRARIES", &ArgumentGroup)
   , AndroidMKFile(&Helper, "ANDROID_MK")
 {
   this->ExportSet = nullptr;
 }

 // cmExportCommand
 bool cmExportCommand::InitialPass(std::vector<std::string> const& args,
                                   cmExecutionStatus&)
 {
   if (args.size() < 2) {
     this->SetError("called with too few arguments");
     return false;
   }

   if (args[0] == "PACKAGE") {
     return this->HandlePackage(args);
   }
   if (args[0] == "EXPORT") {
     this->ExportSetName.Follows(nullptr);
     this->ArgumentGroup.Follows(&this->ExportSetName);
   } else {
     this->Targets.Follows(nullptr);
     this->ArgumentGroup.Follows(&this->Targets);
   }

   std::vector<std::string> unknownArgs;
   this->Helper.Parse(&args, &unknownArgs);

   if (!unknownArgs.empty()) {
     this->SetError("Unknown arguments.");
     return false;
   }

   std::string fname;
   bool android = false;
   if (this->AndroidMKFile.WasFound()) {
     fname = this->AndroidMKFile.GetString();
     android = true;
   }
   if (!this->Filename.WasFound() && fname.empty()) {
     if (args[0] != "EXPORT") {
       this->SetError("FILE <filename> option missing.");
       return false;
     }
     fname = this->ExportSetName.GetString() + ".cmake";
   } else if (fname.empty()) {
     // Make sure the file has a .cmake extension.
     if (cmSystemTools::GetFilenameLastExtension(this->Filename.GetCString()) !=
         ".cmake") {
       std::ostringstream e;
       e << "FILE option given filename \"" << this->Filename.GetString()
         << "\" which does not have an extension of \".cmake\".\n";
       this->SetError(e.str());
       return false;
     }
     fname = this->Filename.GetString();
   }

   // Get the file to write.
   if (cmSystemTools::FileIsFullPath(fname)) {
     if (!this->Makefile->CanIWriteThisFile(fname)) {
       std::ostringstream e;
       e << "FILE option given filename \"" << fname
         << "\" which is in the source tree.\n";
       this->SetError(e.str());
       return false;
     }
   } else {
     // Interpret relative paths with respect to the current build dir.
     std::string dir = this->Makefile->GetCurrentBinaryDirectory();
     fname = dir + "/" + fname;
   }

   std::vector<std::string> targets;

   cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();

   if (args[0] == "EXPORT") {
     if (this->Append.IsEnabled()) {
       std::ostringstream e;
       e << "EXPORT signature does not recognise the APPEND option.";
       this->SetError(e.str());
       return false;
     }

     if (this->ExportOld.IsEnabled()) {
       std::ostringstream e;
       e << "EXPORT signature does not recognise the "
            "EXPORT_LINK_INTERFACE_LIBRARIES option.";
       this->SetError(e.str());
       return false;
     }

     cmExportSetMap& setMap = gg->GetExportSets();
     std::string setName = this->ExportSetName.GetString();
     if (setMap.find(setName) == setMap.end()) {
       std::ostringstream e;
       e << "Export set \"" << setName << "\" not found.";
       this->SetError(e.str());
       return false;
     }
     this->ExportSet = setMap[setName];
   } else if (this->Targets.WasFound()) {
     for (std::string const& currentTarget : this->Targets.GetVector()) {
       if (this->Makefile->IsAlias(currentTarget)) {
         std::ostringstream e;
         e << "given ALIAS target \"" << currentTarget
           << "\" which may not be exported.";
         this->SetError(e.str());
         return false;
       }

       if (cmTarget* target = gg->FindTarget(currentTarget)) {
         if (target->GetType() == cmStateEnums::UTILITY) {
           this->SetError("given custom target \"" + currentTarget +
                          "\" which may not be exported.");
           return false;
         }
       } else {
         std::ostringstream e;
         e << "given target \"" << currentTarget
           << "\" which is not built by this project.";
         this->SetError(e.str());
         return false;
       }
       targets.push_back(currentTarget);
     }
     if (this->Append.IsEnabled()) {
       if (cmExportBuildFileGenerator* ebfg =
             gg->GetExportedTargetsFile(fname)) {
         ebfg->AppendTargets(targets);
         return true;
       }
     }
   } else {
     this->SetError("EXPORT or TARGETS specifier missing.");
     return false;
   }

   // Setup export file generation.
   cmExportBuildFileGenerator* ebfg = nullptr;
   if (android) {
     ebfg = new cmExportBuildAndroidMKGenerator;
   } else {
     ebfg = new cmExportBuildFileGenerator;
   }
   ebfg->SetExportFile(fname.c_str());
   ebfg->SetNamespace(this->Namespace.GetCString());
   ebfg->SetAppendMode(this->Append.IsEnabled());
   if (this->ExportSet) {
     ebfg->SetExportSet(this->ExportSet);
   } else {
     ebfg->SetTargets(targets);
   }
   this->Makefile->AddExportBuildFileGenerator(ebfg);
   ebfg->SetExportOld(this->ExportOld.IsEnabled());

   // Compute the set of configurations exported.
   std::vector<std::string> configurationTypes;
   this->Makefile->GetConfigurations(configurationTypes);
   if (configurationTypes.empty()) {
     configurationTypes.emplace_back();
   }
   for (std::string const& ct : configurationTypes) {
     ebfg->AddConfiguration(ct);
   }
   if (this->ExportSet) {
     gg->AddBuildExportExportSet(ebfg);
   } else {
     gg->AddBuildExportSet(ebfg);
   }

   return true;
 }

 bool cmExportCommand::HandlePackage(std::vector<std::string> const& args)
 {
   // Parse PACKAGE mode arguments.
   enum Doing
   {
     DoingNone,
     DoingPackage
   };
   Doing doing = DoingPackage;
   std::string package;
   for (unsigned int i = 1; i < args.size(); ++i) {
     if (doing == DoingPackage) {
       package = args[i];
       doing = DoingNone;
     } else {
       std::ostringstream e;
       e << "PACKAGE given unknown argument: " << args[i];
       this->SetError(e.str());
       return false;
     }
   }

   // Verify the package name.
   if (package.empty()) {
     this->SetError("PACKAGE must be given a package name.");
     return false;
   }
   const char* packageExpr = "^[A-Za-z0-9_.-]+$";
   cmsys::RegularExpression packageRegex(packageExpr);
   if (!packageRegex.find(package)) {
     std::ostringstream e;
     e << "PACKAGE given invalid package name \"" << package << "\".  "
       << "Package names must match \"" << packageExpr << "\".";
     this->SetError(e.str());
     return false;
   }

   // If the CMAKE_EXPORT_NO_PACKAGE_REGISTRY variable is set the command
   // export(PACKAGE) does nothing.
   if (this->Makefile->IsOn("CMAKE_EXPORT_NO_PACKAGE_REGISTRY")) {
     return true;
   }

   // We store the current build directory in the registry as a value
   // named by a hash of its own content.  This is deterministic and is
   // unique with high probability.
   const std::string& outDir = this->Makefile->GetCurrentBinaryDirectory();
   std::string hash = cmSystemTools::ComputeStringMD5(outDir);
 #if defined(_WIN32) && !defined(__CYGWIN__)
   this->StorePackageRegistryWin(package, outDir.c_str(), hash.c_str());
 #else
   this->StorePackageRegistryDir(package, outDir.c_str(), hash.c_str());
 #endif

   return true;
 }

 #if defined(_WIN32) && !defined(__CYGWIN__)
 #  include <windows.h>

 void cmExportCommand::ReportRegistryError(std::string const& msg,
                                           std::string const& key, long err)
 {
   std::ostringstream e;
   e << msg << "\n"
     << "  HKEY_CURRENT_USER\\" << key << "\n";
   wchar_t winmsg[1024];
   if (FormatMessageW(
         FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0, err,
         MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), winmsg, 1024, 0) > 0) {
     e << "Windows reported:\n"
       << "  " << cmsys::Encoding::ToNarrow(winmsg);
   }
   this->Makefile->IssueMessage(cmake::WARNING, e.str());
 }

 void cmExportCommand::StorePackageRegistryWin(std::string const& package,
                                               const char* content,
                                               const char* hash)
 {
   std::string key = "Software\\Kitware\\CMake\\Packages\\";
   key += package;
   HKEY hKey;
   LONG err =
     RegCreateKeyExW(HKEY_CURRENT_USER, cmsys::Encoding::ToWide(key).c_str(), 0,
                     0, REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, 0, &hKey, 0);
   if (err != ERROR_SUCCESS) {
     this->ReportRegistryError("Cannot create/open registry key", key, err);
     return;
   }

   std::wstring wcontent = cmsys::Encoding::ToWide(content);
   err =
     RegSetValueExW(hKey, cmsys::Encoding::ToWide(hash).c_str(), 0, REG_SZ,
                    (BYTE const*)wcontent.c_str(),
                    static_cast<DWORD>(wcontent.size() + 1) * sizeof(wchar_t));
   RegCloseKey(hKey);
   if (err != ERROR_SUCCESS) {
     std::ostringstream msg;
     msg << "Cannot set registry value \"" << hash << "\" under key";
     this->ReportRegistryError(msg.str(), key, err);
     return;
   }
 }
 #else
 void cmExportCommand::StorePackageRegistryDir(std::string const& package,
                                               const char* content,
                                               const char* hash)
 {
 #  if defined(__HAIKU__)
   char dir[B_PATH_NAME_LENGTH];
   if (find_directory(B_USER_SETTINGS_DIRECTORY, -1, false, dir, sizeof(dir)) !=
       B_OK) {
     return;
   }
   std::string fname = dir;
   fname += "/cmake/packages/";
   fname += package;
 #  else
   std::string fname;
   if (!cmSystemTools::GetEnv("HOME", fname)) {
     return;
   }
   cmSystemTools::ConvertToUnixSlashes(fname);
   fname += "/.cmake/packages/";
   fname += package;
 #  endif
   cmSystemTools::MakeDirectory(fname);
   fname += "/";
   fname += hash;
   if (!cmSystemTools::FileExists(fname)) {
     cmGeneratedFileStream entry(fname, true);
     if (entry) {
       entry << content << "\n";
     } else {
       std::ostringstream e;
       /* clang-format off */
       e << "Cannot create package registry file:\n"
         << "  " << fname << "\n"
         << cmSystemTools::GetLastSystemError() << "\n";
       /* clang-format on */
       this->Makefile->IssueMessage(cmake::WARNING, e.str());
     }
   }
 }
 #endif
	/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying
	file Copyright.txt or https://cmake.org/licensing for details. */
	#include "cmExportCommand.h"

	#include "cmsys/RegularExpression.hxx"
	#include <map>
	#include <sstream>

	#include "cmExportBuildAndroidMKGenerator.h"
	#include "cmExportBuildFileGenerator.h"
	#include "cmExportSetMap.h"
	#include "cmGeneratedFileStream.h"
	#include "cmGlobalGenerator.h"
	#include "cmMakefile.h"
	#include "cmStateTypes.h"
	#include "cmSystemTools.h"
	#include "cmTarget.h"
	#include "cmake.h"

	class cmExecutionStatus;

	#if defined(__HAIKU__)
	# include <FindDirectory.h>
	# include <StorageDefs.h>
	#endif

	cmExportCommand::cmExportCommand()
	: cmCommand()
	, ArgumentGroup()
	, Targets(&Helper, "TARGETS")
	, Append(&Helper, "APPEND", &ArgumentGroup)
	, ExportSetName(&Helper, "EXPORT", &ArgumentGroup)
	, Namespace(&Helper, "NAMESPACE", &ArgumentGroup)
	, Filename(&Helper, "FILE", &ArgumentGroup)
	, ExportOld(&Helper, "EXPORT_LINK_INTERFACE_LIBRARIES", &ArgumentGroup)
	, AndroidMKFile(&Helper, "ANDROID_MK")
	{
	this->ExportSet = nullptr;
	}

	// cmExportCommand
	bool cmExportCommand::InitialPass(std::vector<std::string> const& args,
	cmExecutionStatus&)
	{
	if (args.size() < 2) {
	this->SetError("called with too few arguments");
	return false;
	}

	if (args[0] == "PACKAGE") {
	return this->HandlePackage(args);
	}
	if (args[0] == "EXPORT") {
	this->ExportSetName.Follows(nullptr);
	this->ArgumentGroup.Follows(&this->ExportSetName);
	} else {
	this->Targets.Follows(nullptr);
	this->ArgumentGroup.Follows(&this->Targets);
	}

	std::vector<std::string> unknownArgs;
	this->Helper.Parse(&args, &unknownArgs);

	if (!unknownArgs.empty()) {
	this->SetError("Unknown arguments.");
	return false;
	}

	std::string fname;
	bool android = false;
	if (this->AndroidMKFile.WasFound()) {
	fname = this->AndroidMKFile.GetString();
	android = true;
	}
	if (!this->Filename.WasFound() && fname.empty()) {
	if (args[0] != "EXPORT") {
	this->SetError("FILE <filename> option missing.");
	return false;
	}
	fname = this->ExportSetName.GetString() + ".cmake";
	} else if (fname.empty()) {
	// Make sure the file has a .cmake extension.
	if (cmSystemTools::GetFilenameLastExtension(this->Filename.GetCString()) !=
	".cmake") {
	std::ostringstream e;
	e << "FILE option given filename \"" << this->Filename.GetString()
	<< "\" which does not have an extension of \".cmake\".\n";
	this->SetError(e.str());
	return false;
	}
	fname = this->Filename.GetString();
	}

	// Get the file to write.
	if (cmSystemTools::FileIsFullPath(fname)) {
	if (!this->Makefile->CanIWriteThisFile(fname)) {
	std::ostringstream e;
	e << "FILE option given filename \"" << fname
	<< "\" which is in the source tree.\n";
	this->SetError(e.str());
	return false;
	}
	} else {
	// Interpret relative paths with respect to the current build dir.
	std::string dir = this->Makefile->GetCurrentBinaryDirectory();
	fname = dir + "/" + fname;
	}

	std::vector<std::string> targets;

	cmGlobalGenerator* gg = this->Makefile->GetGlobalGenerator();

	if (args[0] == "EXPORT") {
	if (this->Append.IsEnabled()) {
	std::ostringstream e;
	e << "EXPORT signature does not recognise the APPEND option.";
	this->SetError(e.str());
	return false;
	}

	if (this->ExportOld.IsEnabled()) {
	std::ostringstream e;
	e << "EXPORT signature does not recognise the "
	"EXPORT_LINK_INTERFACE_LIBRARIES option.";
	this->SetError(e.str());
	return false;
	}

	cmExportSetMap& setMap = gg->GetExportSets();
	std::string setName = this->ExportSetName.GetString();
	if (setMap.find(setName) == setMap.end()) {
	std::ostringstream e;
	e << "Export set \"" << setName << "\" not found.";
	this->SetError(e.str());
	return false;
	}
	this->ExportSet = setMap[setName];
	} else if (this->Targets.WasFound()) {
	for (std::string const& currentTarget : this->Targets.GetVector()) {
	if (this->Makefile->IsAlias(currentTarget)) {
	std::ostringstream e;
	e << "given ALIAS target \"" << currentTarget
	<< "\" which may not be exported.";
	this->SetError(e.str());
	return false;
	}

	if (cmTarget* target = gg->FindTarget(currentTarget)) {
	if (target->GetType() == cmStateEnums::UTILITY) {
	this->SetError("given custom target \"" + currentTarget +
	"\" which may not be exported.");
	return false;
	}
	} else {
	std::ostringstream e;
	e << "given target \"" << currentTarget
	<< "\" which is not built by this project.";
	this->SetError(e.str());
	return false;
	}
	targets.push_back(currentTarget);
	}
	if (this->Append.IsEnabled()) {
	if (cmExportBuildFileGenerator* ebfg =
	gg->GetExportedTargetsFile(fname)) {
	ebfg->AppendTargets(targets);
	return true;
	}
	}
	} else {
	this->SetError("EXPORT or TARGETS specifier missing.");
	return false;
	}

	// Setup export file generation.
	cmExportBuildFileGenerator* ebfg = nullptr;
	if (android) {
	ebfg = new cmExportBuildAndroidMKGenerator;
	} else {
	ebfg = new cmExportBuildFileGenerator;
	}
	ebfg->SetExportFile(fname.c_str());
	ebfg->SetNamespace(this->Namespace.GetCString());
	ebfg->SetAppendMode(this->Append.IsEnabled());
	if (this->ExportSet) {
	ebfg->SetExportSet(this->ExportSet);
	} else {
	ebfg->SetTargets(targets);
	}
	this->Makefile->AddExportBuildFileGenerator(ebfg);
	ebfg->SetExportOld(this->ExportOld.IsEnabled());

	// Compute the set of configurations exported.
	std::vector<std::string> configurationTypes;
	this->Makefile->GetConfigurations(configurationTypes);
	if (configurationTypes.empty()) {
	configurationTypes.emplace_back();
	}
	for (std::string const& ct : configurationTypes) {
	ebfg->AddConfiguration(ct);
	}
	if (this->ExportSet) {
	gg->AddBuildExportExportSet(ebfg);
	} else {
	gg->AddBuildExportSet(ebfg);
	}

	return true;
	}

	bool cmExportCommand::HandlePackage(std::vector<std::string> const& args)
	{
	// Parse PACKAGE mode arguments.
	enum Doing
	{
	DoingNone,
	DoingPackage
	};
	Doing doing = DoingPackage;
	std::string package;
	for (unsigned int i = 1; i < args.size(); ++i) {
	if (doing == DoingPackage) {
	package = args[i];
	doing = DoingNone;
	} else {
	std::ostringstream e;
	e << "PACKAGE given unknown argument: " << args[i];
	this->SetError(e.str());
	return false;
	}
	}

	// Verify the package name.
	if (package.empty()) {
	this->SetError("PACKAGE must be given a package name.");
	return false;
	}
	const char* packageExpr = "^[A-Za-z0-9_.-]+$";
	cmsys::RegularExpression packageRegex(packageExpr);
	if (!packageRegex.find(package)) {
	std::ostringstream e;
	e << "PACKAGE given invalid package name \"" << package << "\". "
	<< "Package names must match \"" << packageExpr << "\".";
	this->SetError(e.str());
	return false;
	}

	// If the CMAKE_EXPORT_NO_PACKAGE_REGISTRY variable is set the command
	// export(PACKAGE) does nothing.
	if (this->Makefile->IsOn("CMAKE_EXPORT_NO_PACKAGE_REGISTRY")) {
	return true;
	}

	// We store the current build directory in the registry as a value
	// named by a hash of its own content. This is deterministic and is
	// unique with high probability.
	const std::string& outDir = this->Makefile->GetCurrentBinaryDirectory();
	std::string hash = cmSystemTools::ComputeStringMD5(outDir);
	#if defined(_WIN32) && !defined(__CYGWIN__)
	this->StorePackageRegistryWin(package, outDir.c_str(), hash.c_str());
	#else
	this->StorePackageRegistryDir(package, outDir.c_str(), hash.c_str());
	#endif

	return true;
	}

	#if defined(_WIN32) && !defined(__CYGWIN__)
	# include <windows.h>

	void cmExportCommand::ReportRegistryError(std::string const& msg,
	std::string const& key, long err)
	{
	std::ostringstream e;
	e << msg << "\n"
	<< " HKEY_CURRENT_USER\\" << key << "\n";
	wchar_t winmsg[1024];
	if (FormatMessageW(
	FORMAT_MESSAGE_FROM_SYSTEM \| FORMAT_MESSAGE_IGNORE_INSERTS, 0, err,
	MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), winmsg, 1024, 0) > 0) {
	e << "Windows reported:\n"
	<< " " << cmsys::Encoding::ToNarrow(winmsg);
	}
	this->Makefile->IssueMessage(cmake::WARNING, e.str());
	}

	void cmExportCommand::StorePackageRegistryWin(std::string const& package,
	const char* content,
	const char* hash)
	{
	std::string key = "Software\\Kitware\\CMake\\Packages\\";
	key += package;
	HKEY hKey;
	LONG err =
	RegCreateKeyExW(HKEY_CURRENT_USER, cmsys::Encoding::ToWide(key).c_str(), 0,
	0, REG_OPTION_NON_VOLATILE, KEY_SET_VALUE, 0, &hKey, 0);
	if (err != ERROR_SUCCESS) {
	this->ReportRegistryError("Cannot create/open registry key", key, err);
	return;
	}

	std::wstring wcontent = cmsys::Encoding::ToWide(content);
	err =
	RegSetValueExW(hKey, cmsys::Encoding::ToWide(hash).c_str(), 0, REG_SZ,
	(BYTE const*)wcontent.c_str(),
	static_cast<DWORD>(wcontent.size() + 1) * sizeof(wchar_t));
	RegCloseKey(hKey);
	if (err != ERROR_SUCCESS) {
	std::ostringstream msg;
	msg << "Cannot set registry value \"" << hash << "\" under key";
	this->ReportRegistryError(msg.str(), key, err);
	return;
	}
	}
	#else
	void cmExportCommand::StorePackageRegistryDir(std::string const& package,
	const char* content,
	const char* hash)
	{
	# if defined(__HAIKU__)
	char dir[B_PATH_NAME_LENGTH];
	if (find_directory(B_USER_SETTINGS_DIRECTORY, -1, false, dir, sizeof(dir)) !=
	B_OK) {
	return;
	}
	std::string fname = dir;
	fname += "/cmake/packages/";
	fname += package;
	# else
	std::string fname;
	if (!cmSystemTools::GetEnv("HOME", fname)) {
	return;
	}
	cmSystemTools::ConvertToUnixSlashes(fname);
	fname += "/.cmake/packages/";
	fname += package;
	# endif
	cmSystemTools::MakeDirectory(fname);
	fname += "/";
	fname += hash;
	if (!cmSystemTools::FileExists(fname)) {
	cmGeneratedFileStream entry(fname, true);
	if (entry) {
	entry << content << "\n";
	} else {
	std::ostringstream e;
	/* clang-format off */
	e << "Cannot create package registry file:\n"
	<< " " << fname << "\n"
	<< cmSystemTools::GetLastSystemError() << "\n";
	/* clang-format on */
	this->Makefile->IssueMessage(cmake::WARNING, e.str());
	}
	}
	}
	#endif