mirror/CMake
1
0
Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2026-02-21 22:50:26 -06:00
Code Issues Packages Projects Releases Wiki Activity

Revise C++ coding style using clang-format

Browse Source 
Run the `Utilities/Scripts/clang-format.bash` script to update
all our C++ code to a new style defined by `.clang-format`.
Use `clang-format` version 3.8.

* If you reached this commit for a line in `git blame`, re-run the blame
  operation starting at the parent of this commit to see older history
  for the content.

* See the parent commit for instructions to rebase a change across this
  style transition commit.
This commit is contained in:
Kitware Robot
2016-05-16 10:34:04 -04:00
committed by Brad King
parent 82df6deaaf
commit d9fd2f5402
1450 changed files with 62404 additions and 83728 deletions
Download Patch File Download Diff File Expand all files Collapse all files

191
Source/cmFindProgramCommand.cxx
View File

@@ -20,15 +20,15 @@
struct cmFindProgramHelper
{
cmFindProgramHelper()
{
#if defined (_WIN32) || defined(__CYGWIN__) || defined(__MINGW32__)
{
#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;
@@ -42,47 +42,39 @@ struct cmFindProgramHelper
// Current full path under consideration.
std::string TestPath;
void AddName(std::string const& name)
{
this->Names.push_back(name);
}
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))
{
i != this->Names.end(); ++i) {
if (this->CheckDirectoryForName(path, *i)) {
return true;
}
}
return false;
}
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)
{
ext != this->Extensions.end(); ++ext) {
this->TestPath = path;
this->TestPath += name;
if (!ext->empty() && cmSystemTools::StringEndsWith(name, ext->c_str()))
{
if (!ext->empty() && cmSystemTools::StringEndsWith(name, ext->c_str())) {
continue;
}
}
this->TestPath += *ext;
if (cmSystemTools::FileExists(this->TestPath, true))
{
if (cmSystemTools::FileExists(this->TestPath, true)) {
this->BestPath = cmSystemTools::CollapseFullPath(this->TestPath);
return true;
}
}
return false;
}
return false;
}
};
cmFindProgramCommand::cmFindProgramCommand()
@@ -91,45 +83,39 @@ cmFindProgramCommand::cmFindProgramCommand()
}
// cmFindProgramCommand
bool cmFindProgramCommand
::InitialPass(std::vector<std::string> const& argsIn, cmExecutionStatus &)
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))
{
if (!this->ParseArguments(argsIn)) {
return false;
}
if(this->AlreadyInCache)
{
}
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)
{
if (this->AlreadyInCacheWithoutMetaInfo) {
this->Makefile->AddCacheDefinition(this->VariableName, "",
this->VariableDocumentation.c_str(),
cmState::FILEPATH);
}
return true;
}
return true;
}
std::string result = FindProgram();
if(result != "")
{
if (result != "") {
// Save the value in the cache
this->Makefile->AddCacheDefinition(this->VariableName,
result.c_str(),
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);
}
this->Makefile->AddCacheDefinition(
this->VariableName, (this->VariableName + "-NOTFOUND").c_str(),
this->VariableDocumentation.c_str(), cmState::FILEPATH);
return true;
}
@@ -137,32 +123,26 @@ std::string cmFindProgramCommand::FindProgram()
{
std::string program = "";
if(this->SearchAppBundleFirst || this->SearchAppBundleOnly)
{
if (this->SearchAppBundleFirst || this->SearchAppBundleOnly) {
program = FindAppBundle();
}
if(program.empty() && !this->SearchAppBundleOnly)
{
}
if (program.empty() && !this->SearchAppBundleOnly) {
program = this->FindNormalProgram();
}
}
if(program.empty() && this->SearchAppBundleLast)
{
if (program.empty() && this->SearchAppBundleLast) {
program = this->FindAppBundle();
}
}
return program;
}
std::string cmFindProgramCommand::FindNormalProgram()
{
if(this->NamesPerDir)
{
if (this->NamesPerDir) {
return this->FindNormalProgramNamesPerDir();
}
else
{
} else {
return this->FindNormalProgramDirsPerName();
}
}
}
std::string cmFindProgramCommand::FindNormalProgramNamesPerDir()
@@ -170,26 +150,22 @@ 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)
{
ni != this->Names.end(); ++ni) {
helper.AddName(*ni);
}
}
// Check for the names themselves (e.g. absolute paths).
if (helper.CheckDirectory(std::string()))
{
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))
{
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 "";
}
@@ -199,52 +175,44 @@ 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)
{
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()))
{
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))
{
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)
{
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);
std::string appPath =
cmSystemTools::FindDirectory(appName, this->SearchPaths, true);
if ( !appPath.empty() )
{
if (!appPath.empty()) {
std::string executable = GetBundleExecutable(appPath);
if (!executable.empty())
{
if (!executable.empty()) {
return cmSystemTools::CollapseFullPath(executable);
}
}
}
}
// Couldn't find app bundle
return "";
@@ -260,45 +228,40 @@ std::string cmFindProgramCommand::GetBundleExecutable(std::string bundlePath)
// 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 );
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 );
CFURLRef bundleURL = CFURLCreateWithFileSystemPath(
kCFAllocatorDefault, bundlePathCFS, kCFURLPOSIXPathStyle, true);
// Make a bundle instance using the URLRef.
CFBundleRef appBundle = CFBundleCreate( kCFAllocatorDefault, bundleURL );
CFBundleRef appBundle = CFBundleCreate(kCFAllocatorDefault, bundleURL);
// returned executableURL is relative to <appbundle>/Contents/MacOS/
CFURLRef executableURL = CFBundleCopyExecutableURL(appBundle);
if (executableURL != NULL)
{
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 );
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 );
}
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 );
CFRelease(bundlePathCFS);
CFRelease(bundleURL);
CFRelease(appBundle);
#endif
return executable;
}