mirror/CMake
1
0
Fork 0
mirror of https://github.com/Kitware/CMake.git synced 2026-03-06 06:38:37 -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

341
Source/cmAddLibraryCommand.cxx
View File

@@ -15,21 +15,20 @@
#include "cmake.h"
// cmLibraryCommand
bool cmAddLibraryCommand
::InitialPass(std::vector<std::string> const& args, cmExecutionStatus &)
bool cmAddLibraryCommand::InitialPass(std::vector<std::string> const& args,
cmExecutionStatus&)
{
if(args.size() < 1 )
{
if (args.size() < 1) {
this->SetError("called with incorrect number of arguments");
return false;
}
}
// Library type defaults to value of BUILD_SHARED_LIBS, if it exists,
// otherwise it defaults to static library.
cmState::TargetType type = cmState::SHARED_LIBRARY;
if (cmSystemTools::IsOff(this->Makefile->GetDefinition("BUILD_SHARED_LIBS")))
{
if (cmSystemTools::IsOff(
this->Makefile->GetDefinition("BUILD_SHARED_LIBS"))) {
type = cmState::STATIC_LIBRARY;
}
}
bool excludeFromAll = false;
bool importTarget = false;
bool importGlobal = false;
@@ -45,186 +44,145 @@ bool cmAddLibraryCommand
// source list name. There may be two keyword arguments, check for them
bool haveSpecifiedType = false;
bool isAlias = false;
while ( s != args.end() )
{
while (s != args.end()) {
std::string libType = *s;
if(libType == "STATIC")
{
if (type == cmState::INTERFACE_LIBRARY)
{
if (libType == "STATIC") {
if (type == cmState::INTERFACE_LIBRARY) {
std::ostringstream e;
e << "INTERFACE library specified with conflicting STATIC type.";
this->SetError(e.str());
return false;
}
}
++s;
type = cmState::STATIC_LIBRARY;
haveSpecifiedType = true;
}
else if(libType == "SHARED")
{
if (type == cmState::INTERFACE_LIBRARY)
{
} else if (libType == "SHARED") {
if (type == cmState::INTERFACE_LIBRARY) {
std::ostringstream e;
e << "INTERFACE library specified with conflicting SHARED type.";
this->SetError(e.str());
return false;
}
}
++s;
type = cmState::SHARED_LIBRARY;
haveSpecifiedType = true;
}
else if(libType == "MODULE")
{
if (type == cmState::INTERFACE_LIBRARY)
{
} else if (libType == "MODULE") {
if (type == cmState::INTERFACE_LIBRARY) {
std::ostringstream e;
e << "INTERFACE library specified with conflicting MODULE type.";
this->SetError(e.str());
return false;
}
}
++s;
type = cmState::MODULE_LIBRARY;
haveSpecifiedType = true;
}
else if(libType == "OBJECT")
{
if (type == cmState::INTERFACE_LIBRARY)
{
} else if (libType == "OBJECT") {
if (type == cmState::INTERFACE_LIBRARY) {
std::ostringstream e;
e << "INTERFACE library specified with conflicting OBJECT type.";
this->SetError(e.str());
return false;
}
}
++s;
type = cmState::OBJECT_LIBRARY;
haveSpecifiedType = true;
}
else if(libType == "UNKNOWN")
{
if (type == cmState::INTERFACE_LIBRARY)
{
} else if (libType == "UNKNOWN") {
if (type == cmState::INTERFACE_LIBRARY) {
std::ostringstream e;
e << "INTERFACE library specified with conflicting UNKNOWN type.";
this->SetError(e.str());
return false;
}
}
++s;
type = cmState::UNKNOWN_LIBRARY;
haveSpecifiedType = true;
}
else if(libType == "ALIAS")
{
if (type == cmState::INTERFACE_LIBRARY)
{
} else if (libType == "ALIAS") {
if (type == cmState::INTERFACE_LIBRARY) {
std::ostringstream e;
e << "INTERFACE library specified with conflicting ALIAS type.";
this->SetError(e.str());
return false;
}
}
++s;
isAlias = true;
}
else if(libType == "INTERFACE")
{
if (haveSpecifiedType)
{
} else if (libType == "INTERFACE") {
if (haveSpecifiedType) {
std::ostringstream e;
e << "INTERFACE library specified with conflicting/multiple types.";
this->SetError(e.str());
return false;
}
if (isAlias)
{
}
if (isAlias) {
std::ostringstream e;
e << "INTERFACE library specified with conflicting ALIAS type.";
this->SetError(e.str());
return false;
}
if (excludeFromAll)
{
}
if (excludeFromAll) {
std::ostringstream e;
e << "INTERFACE library may not be used with EXCLUDE_FROM_ALL.";
this->SetError(e.str());
return false;
}
}
++s;
type = cmState::INTERFACE_LIBRARY;
haveSpecifiedType = true;
}
else if(*s == "EXCLUDE_FROM_ALL")
{
if (type == cmState::INTERFACE_LIBRARY)
{
} else if (*s == "EXCLUDE_FROM_ALL") {
if (type == cmState::INTERFACE_LIBRARY) {
std::ostringstream e;
e << "INTERFACE library may not be used with EXCLUDE_FROM_ALL.";
this->SetError(e.str());
return false;
}
}
++s;
excludeFromAll = true;
}
else if(*s == "IMPORTED")
{
} else if (*s == "IMPORTED") {
++s;
importTarget = true;
}
else if(importTarget && *s == "GLOBAL")
{
} else if (importTarget && *s == "GLOBAL") {
++s;
importGlobal = true;
}
else if(type == cmState::INTERFACE_LIBRARY && *s == "GLOBAL")
{
} else if (type == cmState::INTERFACE_LIBRARY && *s == "GLOBAL") {
std::ostringstream e;
e << "GLOBAL option may only be used with IMPORTED libraries.";
this->SetError(e.str());
return false;
}
else
{
} else {
break;
}
}
}
if (type == cmState::INTERFACE_LIBRARY)
{
if (s != args.end())
{
if (type == cmState::INTERFACE_LIBRARY) {
if (s != args.end()) {
std::ostringstream e;
e << "INTERFACE library requires no source arguments.";
this->SetError(e.str());
return false;
}
if (importGlobal && !importTarget)
{
}
if (importGlobal && !importTarget) {
std::ostringstream e;
e << "INTERFACE library specified as GLOBAL, but not as IMPORTED.";
this->SetError(e.str());
return false;
}
}
}
bool nameOk = cmGeneratorExpression::IsValidTargetName(libName) &&
!cmGlobalGenerator::IsReservedTarget(libName);
if (nameOk && !importTarget && !isAlias)
{
if (nameOk && !importTarget && !isAlias) {
nameOk = libName.find(":") == std::string::npos;
}
if (!nameOk)
{
}
if (!nameOk) {
cmake::MessageType messageType = cmake::AUTHOR_WARNING;
std::ostringstream e;
bool issueMessage = false;
switch(this->Makefile->GetPolicyStatus(cmPolicies::CMP0037))
{
switch (this->Makefile->GetPolicyStatus(cmPolicies::CMP0037)) {
case cmPolicies::WARN:
if(type != cmState::INTERFACE_LIBRARY)
{
if (type != cmState::INTERFACE_LIBRARY) {
e << cmPolicies::GetPolicyWarning(cmPolicies::CMP0037) << "\n";
issueMessage = true;
}
}
case cmPolicies::OLD:
break;
case cmPolicies::NEW:
@@ -232,208 +190,177 @@ bool cmAddLibraryCommand
case cmPolicies::REQUIRED_ALWAYS:
issueMessage = true;
messageType = cmake::FATAL_ERROR;
}
if (issueMessage)
{
e << "The target name \"" << libName <<
"\" is reserved or not valid for certain "
"CMake features, such as generator expressions, and may result "
"in undefined behavior.";
}
if (issueMessage) {
e << "The target name \"" << libName
<< "\" is reserved or not valid for certain "
"CMake features, such as generator expressions, and may result "
"in undefined behavior.";
this->Makefile->IssueMessage(messageType, e.str());
if (messageType == cmake::FATAL_ERROR)
{
if (messageType == cmake::FATAL_ERROR) {
return false;
}
}
}
}
if (isAlias)
{
if(!cmGeneratorExpression::IsValidTargetName(libName))
{
if (isAlias) {
if (!cmGeneratorExpression::IsValidTargetName(libName)) {
this->SetError("Invalid name for ALIAS: " + libName);
return false;
}
if(excludeFromAll)
{
}
if (excludeFromAll) {
this->SetError("EXCLUDE_FROM_ALL with ALIAS makes no sense.");
return false;
}
if(importTarget || importGlobal)
{
}
if (importTarget || importGlobal) {
this->SetError("IMPORTED with ALIAS is not allowed.");
return false;
}
if(args.size() != 3)
{
}
if (args.size() != 3) {
std::ostringstream e;
e << "ALIAS requires exactly one target argument.";
this->SetError(e.str());
return false;
}
}
const char *aliasedName = s->c_str();
if(this->Makefile->IsAlias(aliasedName))
{
const char* aliasedName = s->c_str();
if (this->Makefile->IsAlias(aliasedName)) {
std::ostringstream e;
e << "cannot create ALIAS target \"" << libName
<< "\" because target \"" << aliasedName << "\" is itself an ALIAS.";
e << "cannot create ALIAS target \"" << libName << "\" because target \""
<< aliasedName << "\" is itself an ALIAS.";
this->SetError(e.str());
return false;
}
cmTarget *aliasedTarget =
this->Makefile->FindTargetToUse(aliasedName, true);
if(!aliasedTarget)
{
}
cmTarget* aliasedTarget =
this->Makefile->FindTargetToUse(aliasedName, true);
if (!aliasedTarget) {
std::ostringstream e;
e << "cannot create ALIAS target \"" << libName
<< "\" because target \"" << aliasedName << "\" does not already "
"exist.";
e << "cannot create ALIAS target \"" << libName << "\" because target \""
<< aliasedName << "\" does not already "
"exist.";
this->SetError(e.str());
return false;
}
}
cmState::TargetType aliasedType = aliasedTarget->GetType();
if(aliasedType != cmState::SHARED_LIBRARY
&& aliasedType != cmState::STATIC_LIBRARY
&& aliasedType != cmState::MODULE_LIBRARY
&& aliasedType != cmState::OBJECT_LIBRARY
&& aliasedType != cmState::INTERFACE_LIBRARY)
{
if (aliasedType != cmState::SHARED_LIBRARY &&
aliasedType != cmState::STATIC_LIBRARY &&
aliasedType != cmState::MODULE_LIBRARY &&
aliasedType != cmState::OBJECT_LIBRARY &&
aliasedType != cmState::INTERFACE_LIBRARY) {
std::ostringstream e;
e << "cannot create ALIAS target \"" << libName
<< "\" because target \"" << aliasedName << "\" is not a library.";
e << "cannot create ALIAS target \"" << libName << "\" because target \""
<< aliasedName << "\" is not a library.";
this->SetError(e.str());
return false;
}
if(aliasedTarget->IsImported())
{
}
if (aliasedTarget->IsImported()) {
std::ostringstream e;
e << "cannot create ALIAS target \"" << libName
<< "\" because target \"" << aliasedName << "\" is IMPORTED.";
e << "cannot create ALIAS target \"" << libName << "\" because target \""
<< aliasedName << "\" is IMPORTED.";
this->SetError(e.str());
return false;
}
}
this->Makefile->AddAlias(libName, aliasedName);
return true;
}
}
if(importTarget && excludeFromAll)
{
if (importTarget && excludeFromAll) {
this->SetError("excludeFromAll with IMPORTED target makes no sense.");
return false;
}
}
/* ideally we should check whether for the linker language of the target
CMAKE_${LANG}_CREATE_SHARED_LIBRARY is defined and if not default to
STATIC. But at this point we know only the name of the target, but not
yet its linker language. */
if ((type == cmState::SHARED_LIBRARY ||
type == cmState::MODULE_LIBRARY) &&
(this->Makefile->GetState()->GetGlobalPropertyAsBool(
"TARGET_SUPPORTS_SHARED_LIBS") == false))
{
if ((type == cmState::SHARED_LIBRARY || type == cmState::MODULE_LIBRARY) &&
(this->Makefile->GetState()->GetGlobalPropertyAsBool(
"TARGET_SUPPORTS_SHARED_LIBS") == false)) {
std::ostringstream w;
w <<
"ADD_LIBRARY called with " <<
(type==cmState::SHARED_LIBRARY ? "SHARED" : "MODULE") <<
" option but the target platform does not support dynamic linking. "
"Building a STATIC library instead. This may lead to problems.";
w << "ADD_LIBRARY called with "
<< (type == cmState::SHARED_LIBRARY ? "SHARED" : "MODULE")
<< " option but the target platform does not support dynamic linking. "
"Building a STATIC library instead. This may lead to problems.";
this->Makefile->IssueMessage(cmake::AUTHOR_WARNING, w.str());
type = cmState::STATIC_LIBRARY;
}
}
// Handle imported target creation.
if(importTarget)
{
if (importTarget) {
// The IMPORTED signature requires a type to be specified explicitly.
if (!haveSpecifiedType)
{
if (!haveSpecifiedType) {
this->SetError("called with IMPORTED argument but no library type.");
return false;
}
if(type == cmState::OBJECT_LIBRARY)
{
}
if (type == cmState::OBJECT_LIBRARY) {
this->Makefile->IssueMessage(
cmake::FATAL_ERROR,
"The OBJECT library type may not be used for IMPORTED libraries."
);
"The OBJECT library type may not be used for IMPORTED libraries.");
return true;
}
if(type == cmState::INTERFACE_LIBRARY)
{
if (!cmGeneratorExpression::IsValidTargetName(libName))
{
}
if (type == cmState::INTERFACE_LIBRARY) {
if (!cmGeneratorExpression::IsValidTargetName(libName)) {
std::ostringstream e;
e << "Invalid name for IMPORTED INTERFACE library target: " << libName;
this->SetError(e.str());
return false;
}
}
}
// Make sure the target does not already exist.
if(this->Makefile->FindTargetToUse(libName))
{
if (this->Makefile->FindTargetToUse(libName)) {
std::ostringstream e;
e << "cannot create imported target \"" << libName
<< "\" because another target with the same name already exists.";
this->SetError(e.str());
return false;
}
}
// Create the imported target.
this->Makefile->AddImportedTarget(libName, type, importGlobal);
return true;
}
}
// A non-imported target may not have UNKNOWN type.
if(type == cmState::UNKNOWN_LIBRARY)
{
if (type == cmState::UNKNOWN_LIBRARY) {
this->Makefile->IssueMessage(
cmake::FATAL_ERROR,
"The UNKNOWN library type may be used only for IMPORTED libraries."
);
"The UNKNOWN library type may be used only for IMPORTED libraries.");
return true;
}
}
// Enforce name uniqueness.
{
std::string msg;
if(!this->Makefile->EnforceUniqueName(libName, msg))
{
this->SetError(msg);
return false;
std::string msg;
if (!this->Makefile->EnforceUniqueName(libName, msg)) {
this->SetError(msg);
return false;
}
}
std::vector<std::string> srclists;
if(type == cmState::INTERFACE_LIBRARY)
{
if (!cmGeneratorExpression::IsValidTargetName(libName)
|| libName.find("::") != std::string::npos)
{
if (type == cmState::INTERFACE_LIBRARY) {
if (!cmGeneratorExpression::IsValidTargetName(libName) ||
libName.find("::") != std::string::npos) {
std::ostringstream e;
e << "Invalid name for INTERFACE library target: " << libName;
this->SetError(e.str());
return false;
}
this->Makefile->AddLibrary(libName,
type,
srclists,
excludeFromAll);
return true;
}
if (s == args.end())
{
this->Makefile->AddLibrary(libName, type, srclists, excludeFromAll);
return true;
}
if (s == args.end()) {
std::string msg = "You have called ADD_LIBRARY for library ";
msg += args[0];
msg += " without any source files. This typically indicates a problem ";
msg += "with your CMakeLists.txt file";
cmSystemTools::Message(msg.c_str() ,"Warning");
}
cmSystemTools::Message(msg.c_str(), "Warning");
}
srclists.insert(srclists.end(), s, args.end());
@@ -441,5 +368,3 @@ bool cmAddLibraryCommand
return true;
}