CMake/Source/cmFindProgramCommand.cxx

308 lines
8.8 KiB
C++
Raw Normal View History

/*============================================================================
CMake - Cross Platform Makefile Generator
Copyright 2000-2009 Kitware, Inc., Insight Software Consortium
2001-01-11 22:55:47 +03:00
Distributed under the OSI-approved BSD License (the "License");
see accompanying file Copyright.txt for details.
2001-01-11 22:55:47 +03:00
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.
============================================================================*/
2001-01-18 19:20:24 +03:00
#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;
}
2001-01-18 19:20:24 +03:00
// cmFindProgramCommand
bool cmFindProgramCommand
::InitialPass(std::vector<std::string> const& argsIn, cmExecutionStatus &)
{
2006-03-02 21:30:22 +03:00
this->VariableDocumentation = "Path to a program.";
this->CMakePathName = "PROGRAM";
// call cmFindBase::ParseArguments
if(!this->ParseArguments(argsIn))
{
return false;
}
2006-03-02 21:30:22 +03:00
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();
2006-03-02 21:30:22 +03:00
if(result != "")
{
2006-03-02 21:30:22 +03:00
// Save the value in the cache
this->Makefile->AddCacheDefinition(this->VariableName,
2006-03-15 19:02:08 +03:00
result.c_str(),
this->VariableDocumentation.c_str(),
cmState::FILEPATH);
2006-03-02 21:30:22 +03:00
return true;
}
this->Makefile->AddCacheDefinition(this->VariableName,
2006-03-02 21:30:22 +03:00
(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();
}
else
{
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");
2014-11-23 13:05:50 +03:00
std::string appPath = cmSystemTools::FindDirectory(appName,
this->SearchPaths,
2006-05-10 23:46:45 +04:00
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 = "";
2006-04-14 07:24:09 +04:00
(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 ,
2006-05-10 23:46:45 +04:00
bundlePath.c_str(), kCFStringEncodingUTF8 );
2006-05-10 23:46:45 +04:00
// 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,
2006-05-10 23:46:45 +04:00
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;
}