kolan
/
CMake
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Avoid else after return

This commit is contained in:
Daniel Pfeifer 2016-09-16 22:45:24 +02:00
parent d9f5d3c50f
commit 516f8edb2e
30 changed files with 204 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
Source/cmCMakePolicyCommand.cxx
View File

@ -24,23 +24,27 @@ bool cmCMakePolicyCommand::InitialPass(std::vector<std::string> const& args,
if (args[0] == "SET") {
return this->HandleSetMode(args);
} else if (args[0] == "GET") {
}
if (args[0] == "GET") {
return this->HandleGetMode(args);
} else if (args[0] == "PUSH") {
}
if (args[0] == "PUSH") {
if (args.size() > 1) {
this->SetError("PUSH may not be given additional arguments.");
return false;
}
this->Makefile->PushPolicy();
return true;
} else if (args[0] == "POP") {
}
if (args[0] == "POP") {
if (args.size() > 1) {
this->SetError("POP may not be given additional arguments.");
return false;
}
this->Makefile->PopPolicy();
return true;
} else if (args[0] == "VERSION") {
}
if (args[0] == "VERSION") {
return this->HandleVersionMode(args);
}
@ -148,7 +152,8 @@ bool cmCMakePolicyCommand::HandleVersionMode(
if (args.size() <= 1) {
this->SetError("VERSION not given an argument");
return false;
} else if (args.size() >= 3) {
}
if (args.size() >= 3) {
this->SetError("VERSION given too many arguments");
return false;
}

9
Source/cmCPluginAPI.cxx
View File

@ -524,9 +524,8 @@ void CCONV* cmGetSource(void* arg, const char* name)
i = cmCPluginAPISourceFiles.insert(entry).first;
}
return (void*)i->second;
} else {
return CM_NULLPTR;
}
return CM_NULLPTR;
}
void* CCONV cmAddSource(void* arg, void* arg2)
@ -574,22 +573,20 @@ const char* CCONV cmSourceFileGetProperty(void* arg, const char* prop)
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
if (cmSourceFile* rsf = sf->RealSourceFile) {
return rsf->GetProperty(prop);
} else {
}
if (!strcmp(prop, "LOCATION")) {
return sf->FullPath.c_str();
}
return sf->Properties.GetPropertyValue(prop);
}
}
int CCONV cmSourceFileGetPropertyAsBool(void* arg, const char* prop)
{
cmCPluginAPISourceFile* sf = static_cast<cmCPluginAPISourceFile*>(arg);
if (cmSourceFile* rsf = sf->RealSourceFile) {
return rsf->GetPropertyAsBool(prop) ? 1 : 0;
} else {
return cmSystemTools::IsOn(cmSourceFileGetProperty(arg, prop)) ? 1 : 0;
}
return cmSystemTools::IsOn(cmSourceFileGetProperty(arg, prop)) ? 1 : 0;
}
void CCONV cmSourceFileSetProperty(void* arg, const char* prop,

10
Source/cmConditionEvaluator.cxx
View File

@ -249,13 +249,13 @@ bool cmConditionEvaluator::GetBooleanValueOld(
// Old IsTrue behavior for single argument.
if (arg == "0") {
return false;
} else if (arg == "1") {
}
if (arg == "1") {
return true;
} else {
}
const char* def = this->GetDefinitionIfUnquoted(arg);
return !cmSystemTools::IsOff(def);
}
} else {
// Old GetVariableOrNumber behavior.
const char* def = this->GetDefinitionIfUnquoted(arg);
if (!def && atoi(arg.c_str())) {
@ -263,7 +263,6 @@ bool cmConditionEvaluator::GetBooleanValueOld(
}
return !cmSystemTools::IsOff(def);
}
}
//=========================================================================
// returns the resulting boolean value
@ -274,7 +273,8 @@ bool cmConditionEvaluator::GetBooleanValueWithAutoDereference(
// Use the policy if it is set.
if (this->Policy12Status == cmPolicies::NEW) {
return GetBooleanValue(newArg);
} else if (this->Policy12Status == cmPolicies::OLD) {
}
if (this->Policy12Status == cmPolicies::OLD) {
return GetBooleanValueOld(newArg, oneArg);
}

3
Source/cmCoreTryCompile.cxx
View File

@ -565,9 +565,8 @@ int cmCoreTryCompile::TryCompileCode(std::vector<std::string> const& argv,
if (copyFileError.empty()) {
this->Makefile->IssueMessage(cmake::FATAL_ERROR, emsg.str());
return -1;
} else {
copyFileErrorMessage = emsg.str();
}
copyFileErrorMessage = emsg.str();
}
}

3
Source/cmExecuteProcessCommand.cxx
View File

@ -159,11 +159,10 @@ bool cmExecuteProcessCommand::InitialPass(std::vector<std::string> const& args,
if (cmds[i].empty()) {
this->SetError(" given COMMAND argument with no value.");
return false;
} else {
}
// Add the null terminating pointer to the command argument list.
cmds[i].push_back(CM_NULLPTR);
}
}
// Parse the timeout string.
double timeout = -1;

3
Source/cmExportCommand.cxx
View File

@ -51,7 +51,8 @@ bool cmExportCommand::InitialPass(std::vector<std::string> const& args,
if (args[0] == "PACKAGE") {
return this->HandlePackage(args);
} else if (args[0] == "EXPORT") {
}
if (args[0] == "EXPORT") {
this->ExportSetName.Follows(CM_NULLPTR);
this->ArgumentGroup.Follows(&this->ExportSetName);
} else {

38
Source/cmFileCommand.cxx
View File

@ -104,19 +104,25 @@ bool cmFileCommand::InitialPass(std::vector<std::string> const& args,
std::string subCommand = args[0];
if (subCommand == "WRITE") {
return this->HandleWriteCommand(args, false);
} else if (subCommand == "APPEND") {
}
if (subCommand == "APPEND") {
return this->HandleWriteCommand(args, true);
} else if (subCommand == "DOWNLOAD") {
}
if (subCommand == "DOWNLOAD") {
return this->HandleDownloadCommand(args);
} else if (subCommand == "UPLOAD") {
}
if (subCommand == "UPLOAD") {
return this->HandleUploadCommand(args);
} else if (subCommand == "READ") {
}
if (subCommand == "READ") {
return this->HandleReadCommand(args);
} else if (subCommand == "MD5" || subCommand == "SHA1" ||
subCommand == "SHA224" || subCommand == "SHA256" ||
subCommand == "SHA384" || subCommand == "SHA512") {
}
if (subCommand == "MD5" || subCommand == "SHA1" || subCommand == "SHA224" ||
subCommand == "SHA256" || subCommand == "SHA384" ||
subCommand == "SHA512") {
return this->HandleHashCommand(args);
} else if (subCommand == "STRINGS") {
}
if (subCommand == "STRINGS") {
return this->HandleStringsCommand(args);
} else if (subCommand == "GLOB") {
return this->HandleGlobCommand(args, false);
@ -1408,11 +1414,14 @@ bool cmFileCopier::Install(const char* fromFile, const char* toFile)
if (cmSystemTools::SameFile(fromFile, toFile)) {
return true;
} else if (cmSystemTools::FileIsSymlink(fromFile)) {
}
if (cmSystemTools::FileIsSymlink(fromFile)) {
return this->InstallSymlink(fromFile, toFile);
} else if (cmSystemTools::FileIsDirectory(fromFile)) {
}
if (cmSystemTools::FileIsDirectory(fromFile)) {
return this->InstallDirectory(fromFile, toFile, match_properties);
} else if (cmSystemTools::FileExists(fromFile)) {
}
if (cmSystemTools::FileExists(fromFile)) {
return this->InstallFile(fromFile, toFile, match_properties);
}
return this->ReportMissing(fromFile);
@ -3129,7 +3138,7 @@ bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args)
if (i >= args.size()) {
this->Makefile->IssueMessage(cmake::FATAL_ERROR, merr);
return false;
} else {
}
if (args[i] == "FUNCTION") {
guard = GUARD_FUNCTION;
} else if (args[i] == "FILE") {
@ -3142,7 +3151,7 @@ bool cmFileCommand::HandleLockCommand(std::vector<std::string> const& args)
this->Makefile->IssueMessage(cmake::FATAL_ERROR, e.str());
return false;
}
}
} else if (args[i] == "RESULT_VARIABLE") {
++i;
if (i >= args.size()) {
@ -3259,7 +3268,8 @@ bool cmFileCommand::HandleTimestampCommand(
if (args.size() < 3) {
this->SetError("sub-command TIMESTAMP requires at least two arguments.");
return false;
} else if (args.size() > 5) {
}
if (args.size() > 5) {
this->SetError("sub-command TIMESTAMP takes at most four arguments.");
return false;
}

9
Source/cmFileLockUnix.cxx
View File

@ -37,9 +37,8 @@ cmFileLockResult cmFileLock::Release()
if (lockResult == 0) {
return cmFileLockResult::MakeOk();
} else {
return cmFileLockResult::MakeSystem();
}
return cmFileLockResult::MakeSystem();
}
cmFileLockResult cmFileLock::OpenFile()
@ -47,18 +46,16 @@ cmFileLockResult cmFileLock::OpenFile()
this->File = ::open(this->Filename.c_str(), O_RDWR);
if (this->File == -1) {
return cmFileLockResult::MakeSystem();
} else {
return cmFileLockResult::MakeOk();
}
return cmFileLockResult::MakeOk();
}
cmFileLockResult cmFileLock::LockWithoutTimeout()
{
if (this->LockFile(F_SETLKW, F_WRLCK) == -1) {
return cmFileLockResult::MakeSystem();
} else {
return cmFileLockResult::MakeOk();
}
return cmFileLockResult::MakeOk();
}
cmFileLockResult cmFileLock::LockWithTimeout(unsigned long seconds)

3
Source/cmFindBase.cxx
View File

@ -321,7 +321,8 @@ bool cmFindBase::CheckForVariableInCache()
this->AlreadyInCacheWithoutMetaInfo = true;
}
return true;
} else if (cached) {
}
if (cached) {
const char* hs =
state->GetCacheEntryProperty(this->VariableName, "HELPSTRING");
this->VariableDocumentation = hs ? hs : "(none)";

6
Source/cmFindLibraryCommand.cxx
View File

@ -378,9 +378,8 @@ std::string cmFindLibraryCommand::FindNormalLibrary()
{
if (this->NamesPerDir) {
return this->FindNormalLibraryNamesPerDir();
} else {
return this->FindNormalLibraryDirsPerName();
}
return this->FindNormalLibraryDirsPerName();
}
std::string cmFindLibraryCommand::FindNormalLibraryNamesPerDir()
@ -428,9 +427,8 @@ std::string cmFindLibraryCommand::FindFrameworkLibrary()
{
if (this->NamesPerDir) {
return this->FindFrameworkLibraryNamesPerDir();
} else {
return this->FindFrameworkLibraryDirsPerName();
}
return this->FindFrameworkLibraryDirsPerName();
}
std::string cmFindLibraryCommand::FindFrameworkLibraryNamesPerDir()

10
Source/cmFindPackageCommand.cxx
View File

@ -1308,19 +1308,17 @@ bool cmFindPackageCommand::CheckPackageRegistryEntry(const std::string& fname,
outPaths.AddPath(fname);
}
return true;
} else {
}
// The path does not exist. Assume the stream content is
// associated with an old package that no longer exists, and
// delete it to keep the package registry clean.
return false;
}
} else {
// The first line in the stream is not the full path to a file or
// directory. Assume the stream content was created by a future
// version of CMake that uses a different format, and leave it.
return true;
}
}
void cmFindPackageCommand::FillPrefixesCMakeSystemVariable()
{
@ -1628,9 +1626,8 @@ private:
{
if (this->UseSuffixes) {
return this->FPC->SearchDirectory(fullPath);
} else {
return this->FPC->CheckDirectory(fullPath);
}
return this->FPC->CheckDirectory(fullPath);
}
cmFindPackageCommand* FPC;
bool UseSuffixes;
@ -1653,9 +1650,8 @@ bool cmFileListGeneratorBase::Consider(std::string const& fullPath,
{
if (this->Next.get()) {
return this->Next->Search(fullPath + "/", listing);
} else {
return listing.Visit(fullPath + "/");
}
return listing.Visit(fullPath + "/");
}
class cmFileListGeneratorFixed : public cmFileListGeneratorBase

3
Source/cmFindPathCommand.cxx
View File

@ -136,9 +136,8 @@ std::string cmFindPathCommand::FindNormalHeader()
if (cmSystemTools::FileExists(tryPath.c_str())) {
if (this->IncludeFileInPath) {
return tryPath;
} else {
return *p;
}
return *p;
}
}
}

3
Source/cmFindProgramCommand.cxx
View File

@ -140,9 +140,8 @@ std::string cmFindProgramCommand::FindNormalProgram()
{
if (this->NamesPerDir) {
return this->FindNormalProgramNamesPerDir();
} else {
return this->FindNormalProgramDirsPerName();
}
return this->FindNormalProgramDirsPerName();
}
std::string cmFindProgramCommand::FindNormalProgramNamesPerDir()

3
Source/cmForEachCommand.cxx
View File

@ -81,11 +81,10 @@ bool cmForEachFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
// restore the variable to its prior value
mf.AddDefinition(this->Args[0], oldDef.c_str());
return true;
} else {
}
// close out a nested foreach
this->Depth--;
}
}
// record the command
this->Functions.push_back(lff);

3
Source/cmFunctionCommand.cxx
View File

@ -169,11 +169,10 @@ bool cmFunctionFunctionBlocker::IsFunctionBlocked(
// remove the function blocker now that the function is defined
mf.RemoveFunctionBlocker(this, lff);
return true;
} else {
}
// decrement for each nested function that ends
this->Depth--;
}
}
// if it wasn't an endfunction and we are not executing then we must be
// recording

18
Source/cmGetPropertyCommand.cxx
View File

@ -252,20 +252,18 @@ bool cmGetPropertyCommand::HandleTargetMode()
if (this->PropertyName == "ALIASED_TARGET") {
if (this->Makefile->IsAlias(this->Name)) {
return this->StoreResult(target->GetName().c_str());
} else {
return this->StoreResult(NULL);
}
return this->StoreResult(NULL);
}
return this->StoreResult(
target->GetProperty(this->PropertyName, this->Makefile));
} else {
}
std::ostringstream e;
e << "could not find TARGET " << this->Name
<< ". Perhaps it has not yet been created.";
this->SetError(e.str());
return false;
}
}
bool cmGetPropertyCommand::HandleSourceMode()
{
@ -277,14 +275,12 @@ bool cmGetPropertyCommand::HandleSourceMode()
// Get the source file.
if (cmSourceFile* sf = this->Makefile->GetOrCreateSource(this->Name)) {
return this->StoreResult(sf->GetPropertyForUser(this->PropertyName));
} else {
}
std::ostringstream e;
e << "given SOURCE name that could not be found or created: "
<< this->Name;
e << "given SOURCE name that could not be found or created: " << this->Name;
this->SetError(e.str());
return false;
}
}
bool cmGetPropertyCommand::HandleTestMode()
{
@ -347,11 +343,9 @@ bool cmGetPropertyCommand::HandleInstallMode()
bool isSet = file->GetProperty(this->PropertyName, value);
return this->StoreResult(isSet ? value.c_str() : CM_NULLPTR);
} else {
}
std::ostringstream e;
e << "given INSTALL name that could not be found or created: "
<< this->Name;
e << "given INSTALL name that could not be found or created: " << this->Name;
this->SetError(e.str());
return false;
}
}

3
Source/cmHexFileConverter.cxx
View File

@ -89,7 +89,8 @@ static bool ConvertMotorolaSrecLine(const char* buf, FILE* outFile)
if ((buf[1] == '5') || (buf[1] == '7') || (buf[1] == '8') ||
(buf[1] == '9')) {
return true;
} else if (buf[1] == '1') {
}
if (buf[1] == '1') {
dataStart = 8;
} else if (buf[1] == '2') {
dataStart = 10;

3
Source/cmIfCommand.cxx
View File

@ -190,9 +190,8 @@ bool cmIfCommand::InvokeInitialPass(
this->Makefile->IssueMessage(cmake::FATAL_ERROR, err);
cmSystemTools::SetFatalErrorOccured();
return true;
} else {
this->Makefile->IssueMessage(status, err);
}
this->Makefile->IssueMessage(status, err);
}
cmIfFunctionBlocker* f = new cmIfFunctionBlocker();

24
Source/cmInstallCommand.cxx
View File

@ -71,19 +71,26 @@ bool cmInstallCommand::InitialPass(std::vector<std::string> const& args,
// Switch among the command modes.
if (args[0] == "SCRIPT") {
return this->HandleScriptMode(args);
} else if (args[0] == "CODE") {
}
if (args[0] == "CODE") {
return this->HandleScriptMode(args);
} else if (args[0] == "TARGETS") {
}
if (args[0] == "TARGETS") {
return this->HandleTargetsMode(args);
} else if (args[0] == "FILES") {
}
if (args[0] == "FILES") {
return this->HandleFilesMode(args);
} else if (args[0] == "PROGRAMS") {
}
if (args[0] == "PROGRAMS") {
return this->HandleFilesMode(args);
} else if (args[0] == "DIRECTORY") {
}
if (args[0] == "DIRECTORY") {
return this->HandleDirectoryMode(args);
} else if (args[0] == "EXPORT") {
}
if (args[0] == "EXPORT") {
return this->HandleExportMode(args);
} else if (args[0] == "EXPORT_ANDROID_MK") {
}
if (args[0] == "EXPORT_ANDROID_MK") {
return this->HandleExportAndroidMKMode(args);
}
@ -340,7 +347,8 @@ bool cmInstallCommand::HandleTargetsMode(std::vector<std::string> const& args)
<< "\" which is not an executable, library, or module.";
this->SetError(e.str());
return false;
} else if (target->GetType() == cmState::OBJECT_LIBRARY) {
}
if (target->GetType() == cmState::OBJECT_LIBRARY) {
std::ostringstream e;
e << "TARGETS given OBJECT library \"" << (*targetIt)
<< "\" which may not be installed.";

6
Source/cmInstallFilesCommand.cxx
View File

@ -143,12 +143,12 @@ std::string cmInstallFilesCommand::FindInstallSource(const char* name) const
if (cmSystemTools::FileExists(tb.c_str())) {
// The file exists in the binary tree. Use it.
return tb;
} else if (cmSystemTools::FileExists(ts.c_str())) {
}
if (cmSystemTools::FileExists(ts.c_str())) {
// The file exists in the source tree. Use it.
return ts;
} else {
}
// The file doesn't exist. Assume it will be present in the
// binary tree when the install occurs.
return tb;
}
}

6
Source/cmInstallProgramsCommand.cxx
View File

@ -113,12 +113,12 @@ std::string cmInstallProgramsCommand::FindInstallSource(const char* name) const
if (cmSystemTools::FileExists(tb.c_str())) {
// The file exists in the binary tree. Use it.
return tb;
} else if (cmSystemTools::FileExists(ts.c_str())) {
}
if (cmSystemTools::FileExists(ts.c_str())) {
// The file exists in the source tree. Use it.
return ts;
} else {
}
// The file doesn't exist. Assume it will be present in the
// binary tree when the install occurs.
return tb;
}
}

3
Source/cmMacroCommand.cxx
View File

@ -203,11 +203,10 @@ bool cmMacroFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
// remove the function blocker now that the macro is defined
mf.RemoveFunctionBlocker(this, lff);
return true;
} else {
}
// decrement for each nested macro that ends
this->Depth--;
}
}
// if it wasn't an endmacro and we are not executing then we must be
// recording

7
Source/cmOutputRequiredFilesCommand.cxx
View File

@ -307,10 +307,10 @@ protected:
// If dependencies are already done, stop now.
if (info->DependDone) {
return;
} else {
}
// Make sure we don't visit the same file more than once.
info->DependDone = true;
}
const char* path = info->FullPath.c_str();
if (!path) {
cmSystemTools::Error(
@ -405,7 +405,7 @@ protected:
if (result != this->DependInformationMap.end()) {
// Found an instance, return it.
return result->second;
} else {
}
// Didn't find an instance. Create a new one and save it.
cmDependInformation* info = new cmDependInformation;
info->FullPath = fullPath;
@ -414,7 +414,6 @@ protected:
this->DependInformationMap[fullPath] = info;
return info;
}
}
/**
* Find the full path name for the given file name.

3
Source/cmSearchPath.cxx
View File

@ -124,9 +124,8 @@ static std::string cmSearchPathStripBin(std::string const& s)
// If the path is a PREFIX/bin case then add its parent instead.
if ((cmHasLiteralSuffix(s, "/bin")) || (cmHasLiteralSuffix(s, "/sbin"))) {
return cmSystemTools::GetFilenamePath(s);
} else {
return s;
}
return s;
}
void cmSearchPath::AddEnvPrefixPath(const std::string& variable, bool stripBin)

2
Source/cmSetCommand.cxx
View File

@ -59,7 +59,7 @@ bool cmSetCommand::InitialPass(std::vector<std::string> const& args,
}
// SET (VAR PARENT_SCOPE) // Removes the definition of VAR
// in the parent scope.
else if (args.size() == 2 && args[args.size() - 1] == "PARENT_SCOPE") {
if (args.size() == 2 && args[args.size() - 1] == "PARENT_SCOPE") {
this->Makefile->RaiseScope(variable, CM_NULLPTR);
return true;
}

3
Source/cmSetDirectoryPropertiesCommand.cxx
View File

@ -45,7 +45,8 @@ bool cmSetDirectoryPropertiesCommand::RunCommand(
if (prop == "VARIABLES") {
errors = "Variables and cache variables should be set using SET command";
return false;
} else if (prop == "MACROS") {
}
if (prop == "MACROS") {
errors = "Commands and macros cannot be set using SET_CMAKE_PROPERTIES";
return false;
}

70
Source/cmStringCommand.cxx
View File

@ -34,43 +34,61 @@ bool cmStringCommand::InitialPass(std::vector<std::string> const& args,
const std::string& subCommand = args[0];
if (subCommand == "REGEX") {
return this->HandleRegexCommand(args);
} else if (subCommand == "REPLACE") {
}
if (subCommand == "REPLACE") {
return this->HandleReplaceCommand(args);
} else if (subCommand == "MD5" || subCommand == "SHA1" ||
subCommand == "SHA224" || subCommand == "SHA256" ||
subCommand == "SHA384" || subCommand == "SHA512") {
}
if (subCommand == "MD5" || subCommand == "SHA1" || subCommand == "SHA224" ||
subCommand == "SHA256" || subCommand == "SHA384" ||
subCommand == "SHA512") {
return this->HandleHashCommand(args);
} else if (subCommand == "TOLOWER") {
}
if (subCommand == "TOLOWER") {
return this->HandleToUpperLowerCommand(args, false);
} else if (subCommand == "TOUPPER") {
}
if (subCommand == "TOUPPER") {
return this->HandleToUpperLowerCommand(args, true);
} else if (subCommand == "COMPARE") {
}
if (subCommand == "COMPARE") {
return this->HandleCompareCommand(args);
} else if (subCommand == "ASCII") {
}
if (subCommand == "ASCII") {
return this->HandleAsciiCommand(args);
} else if (subCommand == "CONFIGURE") {
}
if (subCommand == "CONFIGURE") {
return this->HandleConfigureCommand(args);
} else if (subCommand == "LENGTH") {
}
if (subCommand == "LENGTH") {
return this->HandleLengthCommand(args);
} else if (subCommand == "APPEND") {
}
if (subCommand == "APPEND") {
return this->HandleAppendCommand(args);
} else if (subCommand == "CONCAT") {
}
if (subCommand == "CONCAT") {
return this->HandleConcatCommand(args);
} else if (subCommand == "SUBSTRING") {
}
if (subCommand == "SUBSTRING") {
return this->HandleSubstringCommand(args);
} else if (subCommand == "STRIP") {
}
if (subCommand == "STRIP") {
return this->HandleStripCommand(args);
} else if (subCommand == "RANDOM") {
}
if (subCommand == "RANDOM") {
return this->HandleRandomCommand(args);
} else if (subCommand == "FIND") {
}
if (subCommand == "FIND") {
return this->HandleFindCommand(args);
} else if (subCommand == "TIMESTAMP") {
}
if (subCommand == "TIMESTAMP") {
return this->HandleTimestampCommand(args);
} else if (subCommand == "MAKE_C_IDENTIFIER") {
}
if (subCommand == "MAKE_C_IDENTIFIER") {
return this->HandleMakeCIdentifierCommand(args);
} else if (subCommand == "GENEX_STRIP") {
}
if (subCommand == "GENEX_STRIP") {
return this->HandleGenexStripCommand(args);
} else if (subCommand == "UUID") {
}
if (subCommand == "UUID") {
return this->HandleUuidCommand(args);
}
@ -158,7 +176,8 @@ bool cmStringCommand::HandleConfigureCommand(
if (args.size() < 2) {
this->SetError("No input string specified.");
return false;
} else if (args.size() < 3) {
}
if (args.size() < 3) {
this->SetError("No output variable specified.");
return false;
}
@ -203,14 +222,16 @@ bool cmStringCommand::HandleRegexCommand(std::vector<std::string> const& args)
return false;
}
return this->RegexMatch(args);
} else if (mode == "MATCHALL") {
}
if (mode == "MATCHALL") {
if (args.size() < 5) {
this->SetError("sub-command REGEX, mode MATCHALL needs "
"at least 5 arguments total to command.");
return false;
}
return this->RegexMatchAll(args);
} else if (mode == "REPLACE") {
}
if (mode == "REPLACE") {
if (args.size() < 6) {
this->SetError("sub-command REGEX, mode REPLACE needs "
"at least 6 arguments total to command.");
@ -785,7 +806,8 @@ bool cmStringCommand::HandleTimestampCommand(
if (args.size() < 2) {
this->SetError("sub-command TIMESTAMP requires at least one argument.");
return false;
} else if (args.size() > 4) {
}
if (args.size() > 4) {
this->SetError("sub-command TIMESTAMP takes at most three arguments.");
return false;
}

7
Source/cmTargetLinkLibrariesCommand.cxx
View File

@ -353,10 +353,9 @@ bool cmTargetLinkLibrariesCommand::HandleLibrary(const std::string& lib,
"INTERFACE_LINK_LIBRARIES",
this->Target->GetDebugGeneratorExpressions(lib, llt).c_str());
return true;
} else if (this->CurrentProcessingState !=
ProcessingKeywordPublicInterface &&
this->CurrentProcessingState !=
ProcessingPlainPublicInterface) {
}
if (this->CurrentProcessingState != ProcessingKeywordPublicInterface &&
this->CurrentProcessingState != ProcessingPlainPublicInterface) {
if (this->Target->GetType() == cmState::STATIC_LIBRARY) {
std::string configLib =
this->Target->GetDebugGeneratorExpressions(lib, llt);

8
Source/cmUnsetCommand.cxx
View File

@ -36,23 +36,21 @@ bool cmUnsetCommand::InitialPass(std::vector<std::string> const& args,
return true;
}
// unset(VAR)
else if (args.size() == 1) {
if (args.size() == 1) {
this->Makefile->RemoveDefinition(variable);
return true;
}
// unset(VAR CACHE)
else if ((args.size() == 2) && (args[1] == "CACHE")) {
if ((args.size() == 2) && (args[1] == "CACHE")) {
this->Makefile->RemoveCacheDefinition(variable);
return true;
}
// unset(VAR PARENT_SCOPE)
else if ((args.size() == 2) && (args[1] == "PARENT_SCOPE")) {
if ((args.size() == 2) && (args[1] == "PARENT_SCOPE")) {
this->Makefile->RaiseScope(variable, CM_NULLPTR);
return true;
}
// ERROR: second argument isn't CACHE or PARENT_SCOPE
else {
this->SetError("called with an invalid second argument");
return false;
}
}

3
Source/cmWhileCommand.cxx
View File

@ -104,11 +104,10 @@ bool cmWhileFunctionBlocker::IsFunctionBlocked(const cmListFileFunction& lff,
messageType);
}
return true;
} else {
}
// decrement for each nested while that ends
this->Depth--;
}
}
// record the command
this->Functions.push_back(lff);