| /*============================================================================ |
| 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(); |
| } |
| 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"); |
| 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 |
| // bundle’s 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; |
| } |
| |