CMake/Source/cmFindProgramCommand.cxx

267 lines
7.9 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
This software is distributed WITHOUT ANY WARRANTY; without even the
implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
See the License for more information.
============================================================================*/
#include "cmFindProgramCommand.h"
#include <stdlib.h>
#if defined(__APPLE__)
#include <CoreFoundation/CoreFoundation.h>
#endif
struct cmFindProgramHelper
{
cmFindProgramHelper()
{
#if defined(_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
// Consider platform-specific extensions.
this->Extensions.push_back(".com");
this->Extensions.push_back(".exe");
#endif
// Consider original name with no extensions.
this->Extensions.push_back("");
}
// List of valid extensions.
std::vector<std::string> Extensions;
// Keep track of the best program file found so far.
std::string BestPath;
// Current names under consideration.
std::vector<std::string> Names;
// Current full path under consideration.
std::string TestPath;
void AddName(std::string const& name) { this->Names.push_back(name); }
void SetName(std::string const& name)
{
this->Names.clear();
this->AddName(name);
}
bool CheckDirectory(std::string const& path)
{
for (std::vector<std::string>::iterator i = this->Names.begin();
i != this->Names.end(); ++i) {
if (this->CheckDirectoryForName(path, *i)) {
return true;
}
}
return false;
}
bool CheckDirectoryForName(std::string const& path, std::string const& name)
{
for (std::vector<std::string>::iterator ext = this->Extensions.begin();
ext != this->Extensions.end(); ++ext) {
this->TestPath = path;
this->TestPath += name;
if (!ext->empty() && cmSystemTools::StringEndsWith(name, ext->c_str())) {
continue;
}
this->TestPath += *ext;
if (cmSystemTools::FileExists(this->TestPath, true)) {
this->BestPath = cmSystemTools::CollapseFullPath(this->TestPath);
return true;
}
}
return false;
}
};
cmFindProgramCommand::cmFindProgramCommand()
{
this->NamesPerDirAllowed = true;
}
// cmFindProgramCommand
bool cmFindProgramCommand::InitialPass(std::vector<std::string> const& argsIn,
cmExecutionStatus&)
{
this->VariableDocumentation = "Path to a program.";
this->CMakePathName = "PROGRAM";
// call cmFindBase::ParseArguments
if (!this->ParseArguments(argsIn)) {
return false;
}
if (this->AlreadyInCache) {
// If the user specifies the entry on the command line without a
// type we should add the type and docstring but keep the original
// value.
if (this->AlreadyInCacheWithoutMetaInfo) {
this->Makefile->AddCacheDefinition(this->VariableName, "",
this->VariableDocumentation.c_str(),
cmState::FILEPATH);
}
return true;
}
std::string result = FindProgram();
if (result != "") {
// Save the value in the cache
this->Makefile->AddCacheDefinition(this->VariableName, result.c_str(),
this->VariableDocumentation.c_str(),
cmState::FILEPATH);
return true;
}
this->Makefile->AddCacheDefinition(
this->VariableName, (this->VariableName + "-NOTFOUND").c_str(),
this->VariableDocumentation.c_str(), cmState::FILEPATH);
return true;
}
std::string cmFindProgramCommand::FindProgram()
{
std::string program = "";
if (this->SearchAppBundleFirst || this->SearchAppBundleOnly) {
program = FindAppBundle();
}
if (program.empty() && !this->SearchAppBundleOnly) {
program = this->FindNormalProgram();
}
if (program.empty() && this->SearchAppBundleLast) {
program = this->FindAppBundle();
}
return program;
}
std::string cmFindProgramCommand::FindNormalProgram()
{
if (this->NamesPerDir) {
return this->FindNormalProgramNamesPerDir();
}
return this->FindNormalProgramDirsPerName();
}
std::string cmFindProgramCommand::FindNormalProgramNamesPerDir()
{
// Search for all names in each directory.
cmFindProgramHelper helper;
for (std::vector<std::string>::const_iterator ni = this->Names.begin();
ni != this->Names.end(); ++ni) {
helper.AddName(*ni);
}
// Check for the names themselves (e.g. absolute paths).
if (helper.CheckDirectory(std::string())) {
return helper.BestPath;
}
// Search every directory.
for (std::vector<std::string>::const_iterator p = this->SearchPaths.begin();
p != this->SearchPaths.end(); ++p) {
if (helper.CheckDirectory(*p)) {
return helper.BestPath;
}
}
// Couldn't find the program.
return "";
}
std::string cmFindProgramCommand::FindNormalProgramDirsPerName()
{
// Search the entire path for each name.
cmFindProgramHelper helper;
for (std::vector<std::string>::const_iterator ni = this->Names.begin();
ni != this->Names.end(); ++ni) {
// Switch to searching for this name.
helper.SetName(*ni);
// Check for the name by itself (e.g. an absolute path).
if (helper.CheckDirectory(std::string())) {
return helper.BestPath;
}
// Search every directory.
for (std::vector<std::string>::const_iterator p =
this->SearchPaths.begin();
p != this->SearchPaths.end(); ++p) {
if (helper.CheckDirectory(*p)) {
return helper.BestPath;
}
}
}
// Couldn't find the program.
return "";
}
std::string cmFindProgramCommand::FindAppBundle()
{
for (std::vector<std::string>::const_iterator name = this->Names.begin();
name != this->Names.end(); ++name) {
std::string appName = *name + std::string(".app");
std::string appPath =
cmSystemTools::FindDirectory(appName, this->SearchPaths, true);
if (!appPath.empty()) {
std::string executable = GetBundleExecutable(appPath);
if (!executable.empty()) {
return cmSystemTools::CollapseFullPath(executable);
}
}
}
// Couldn't find app bundle
return "";
}
std::string cmFindProgramCommand::GetBundleExecutable(std::string bundlePath)
{
std::string executable = "";
(void)bundlePath;
#if defined(__APPLE__)
// Started with an example on developer.apple.com about finding bundles
// and modified from that.
// Get a CFString of the app bundle path
// XXX - Is it safe to assume everything is in UTF8?
CFStringRef bundlePathCFS = CFStringCreateWithCString(
kCFAllocatorDefault, bundlePath.c_str(), kCFStringEncodingUTF8);
// Make a CFURLRef from the CFString representation of the
// bundles path.
CFURLRef bundleURL = CFURLCreateWithFileSystemPath(
kCFAllocatorDefault, bundlePathCFS, kCFURLPOSIXPathStyle, true);
// Make a bundle instance using the URLRef.
CFBundleRef appBundle = CFBundleCreate(kCFAllocatorDefault, bundleURL);
// returned executableURL is relative to <appbundle>/Contents/MacOS/
CFURLRef executableURL = CFBundleCopyExecutableURL(appBundle);
if (executableURL != NULL) {
const int MAX_OSX_PATH_SIZE = 1024;
char buffer[MAX_OSX_PATH_SIZE];
// Convert the CFString to a C string
CFStringGetCString(CFURLGetString(executableURL), buffer,
MAX_OSX_PATH_SIZE, kCFStringEncodingUTF8);
// And finally to a c++ string
executable = bundlePath + "/Contents/MacOS/" + std::string(buffer);
// Only release CFURLRef if it's not null
CFRelease(executableURL);
}
// Any CF objects returned from functions with "create" or
// "copy" in their names must be released by us!
CFRelease(bundlePathCFS);
CFRelease(bundleURL);
CFRelease(appBundle);
#endif
return executable;
}