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

Add -Werror and -Wno-error command-line options 

Expand the -W set of cmake options to include support for the -Werror
and -Wno-error format, which is used to control upgrading and
downgrading warning and error messages. Implement support for these new
formats for the dev and deprecated message types.

Add tests and updated documentation for new options.
This commit is contained in:
Michael Scott 2015-12-21 21:39:27 +00:00 committed by Brad King
parent b5009720d3
commit 28f2d750ed
27 changed files with 371 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
Help/manual/OPTIONS_BUILD.txt
View File

@ -86,6 +86,18 @@
Enable warnings that are meant for the author of the CMakeLists.txt
files. By default this will also turn on deprecation warnings.
``-Werror=dev``
Make developer warnings errors.
Make warnings that are meant for the author of the CMakeLists.txt files
errors. By default this will also turn on deprecated warnings as errors.
``-Wno-error=dev``
Make developer warnings not errors.
Make warnings that are meant for the author of the CMakeLists.txt files not
errors. By default this will also turn off deprecated warnings as errors.
``-Wdeprecated``
Enable deprecated functionality warnings.
@ -97,3 +109,15 @@
Suppress warnings for usage of deprecated functionality, that are meant
for the author of the CMakeLists.txt files.
``-Werror=deprecated``
Make deprecated macro and function warnings errors.
Make warnings for usage of deprecated macros and functions, that are meant
for the author of the CMakeLists.txt files, errors.
``-Wno-error=deprecated``
Make deprecated macro and function warnings not errors.
Make warnings for usage of deprecated macros and functions, that are meant
for the author of the CMakeLists.txt files, not errors.

7
Help/release/dev/cmake-W-options.rst
View File

@ -13,3 +13,10 @@ cmake-W-options
* Warnings about deprecated functionality can now be controlled in the
:manual:`cmake-gui(1)` application.
* The suppression of developer warnings as errors can now be controlled with
the new ``-Werror=dev`` and ``-Wno-error=dev`` :manual:`cmake(1)` options.
* The :variable:`CMAKE_ERROR_DEPRECATED` variable can now be set using the
``-Werror=deprecated`` and ``-Wno-error=deprecated`` :manual:`cmake(1)`
options.

27
Source/cmMessageCommand.cxx
View File

@ -25,6 +25,7 @@ bool cmMessageCommand
cmake::MessageType type = cmake::MESSAGE;
bool status = false;
bool fatal = false;
cmake* cm = this->Makefile->GetCMakeInstance();
if (*i == "SEND_ERROR")
{
type = cmake::FATAL_ERROR;
@ -43,14 +44,18 @@ bool cmMessageCommand
}
else if (*i == "AUTHOR_WARNING")
{
if (this->Makefile->GetCMakeInstance()->GetSuppressDevWarnings(
this->Makefile))
if (cm->GetDevWarningsAsErrors(this->Makefile))
{
return true;
fatal = true;
type = cmake::AUTHOR_ERROR;
}
else if (!cm->GetSuppressDevWarnings(this->Makefile))
{
type = cmake::AUTHOR_WARNING;
}
else
{
type = cmake::AUTHOR_WARNING;
return true;
}
++i;
}
@ -61,22 +66,18 @@ bool cmMessageCommand
}
else if (*i == "DEPRECATION")
{
if (this->Makefile->IsOn("CMAKE_ERROR_DEPRECATED"))
if (cm->GetDeprecatedWarningsAsErrors(this->Makefile))
{
fatal = true;
type = cmake::DEPRECATION_ERROR;
}
else
{
if (this->Makefile->GetCMakeInstance()->GetSuppressDeprecatedWarnings(
this->Makefile))
{
return true;
}
else
else if (!cm->GetSuppressDeprecatedWarnings(this->Makefile))
{
type = cmake::DEPRECATION_WARNING;
}
else
{
return true;
}
++i;
}

198
Source/cmake.cxx
View File

@ -291,6 +291,7 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
std::string name;
bool foundNo = false;
bool foundError = false;
unsigned int nameStartPosition = 0;
if (entry.find("no-", nameStartPosition) == 0)
@ -299,6 +300,12 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
nameStartPosition += 3;
}
if (entry.find("error=", nameStartPosition) == 0)
{
foundError = true;
nameStartPosition += 6;
}
name = entry.substr(nameStartPosition);
if (name.empty())
{
@ -306,17 +313,28 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
return false;
}
if (!foundNo)
if (!foundNo && !foundError)
{
// -W<name>
this->DiagLevels[name] = std::max(this->DiagLevels[name],
DIAG_WARN);
}
else
else if (foundNo && !foundError)
{
// -Wno<name>
this->DiagLevels[name] = DIAG_IGNORE;
}
else if (!foundNo && foundError)
{
// -Werror=<name>
this->DiagLevels[name] = DIAG_ERROR;
}
else
{
// -Wno-error=<name>
this->DiagLevels[name] = std::min(this->DiagLevels[name],
DIAG_WARN);
}
}
else if(arg.find("-U",0) == 0)
{
@ -1270,10 +1288,17 @@ int cmake::Configure()
if (diagLevel == DIAG_IGNORE)
{
this->SetSuppressDeprecatedWarnings(true);
this->SetDeprecatedWarningsAsErrors(false);
}
else if (diagLevel == DIAG_WARN)
{
this->SetSuppressDeprecatedWarnings(false);
this->SetDeprecatedWarningsAsErrors(false);
}
else if (diagLevel == DIAG_ERROR)
{
this->SetSuppressDeprecatedWarnings(false);
this->SetDeprecatedWarningsAsErrors(true);
}
}
@ -1283,9 +1308,11 @@ int cmake::Configure()
const char* cachedWarnDeprecated =
this->State->GetCacheEntryValue("CMAKE_WARN_DEPRECATED");
const char* cachedErrorDeprecated =
this->State->GetCacheEntryValue("CMAKE_ERROR_DEPRECATED");
// don't overwrite deprecated warning setting from a previous invocation
if (!cachedWarnDeprecated)
if (!cachedWarnDeprecated && !cachedErrorDeprecated)
{
setDeprecatedVariables = true;
}
@ -1294,19 +1321,34 @@ int cmake::Configure()
if (diagLevel == DIAG_IGNORE)
{
this->SetSuppressDevWarnings(true);
this->SetDevWarningsAsErrors(false);
if (setDeprecatedVariables)
{
this->SetSuppressDeprecatedWarnings(true);
this->SetDeprecatedWarningsAsErrors(false);
}
}
else if (diagLevel == DIAG_WARN)
{
this->SetSuppressDevWarnings(false);
this->SetDevWarningsAsErrors(false);
if (setDeprecatedVariables)
{
this->SetSuppressDeprecatedWarnings(false);
this->SetDeprecatedWarningsAsErrors(false);
}
}
else if (diagLevel == DIAG_ERROR)
{
this->SetSuppressDevWarnings(false);
this->SetDevWarningsAsErrors(true);
if (setDeprecatedVariables)
{
this->SetSuppressDeprecatedWarnings(false);
this->SetDeprecatedWarningsAsErrors(true);
}
}
}
@ -2547,16 +2589,45 @@ static bool cmakeCheckStampList(const char* stampList)
return true;
}
cmake::MessageType cmake::ConvertMessageType(cmake::MessageType t)
{
bool warningsAsErrors;
if (t == cmake::AUTHOR_WARNING || t == cmake::AUTHOR_ERROR)
{
warningsAsErrors = this->GetDevWarningsAsErrors();
if (warningsAsErrors && t == cmake::AUTHOR_WARNING)
{
t = cmake::AUTHOR_ERROR;
}
else if (!warningsAsErrors && t == cmake::AUTHOR_ERROR)
{
t = cmake::AUTHOR_WARNING;
}
}
else if (t == cmake::DEPRECATION_WARNING || t == cmake::DEPRECATION_ERROR)
{
warningsAsErrors = this->GetDeprecatedWarningsAsErrors();
if (warningsAsErrors && t == cmake::DEPRECATION_WARNING)
{
t = cmake::DEPRECATION_ERROR;
}
else if (!warningsAsErrors && t == cmake::DEPRECATION_ERROR)
{
t = cmake::DEPRECATION_WARNING;
}
}
return t;
}
bool cmake::IsMessageTypeVisible(cmake::MessageType t)
{
bool isVisible = true;
if(t == cmake::DEPRECATION_ERROR)
{
// if CMAKE_ERROR_DEPRECATED is on, show the message, otherwise suppress it
const char* errorDeprecated = this->State->GetCacheEntryValue(
"CMAKE_ERROR_DEPRECATED");
if(cmSystemTools::IsOff(errorDeprecated))
if(!this->GetDeprecatedWarningsAsErrors())
{
isVisible = false;
}
@ -2568,6 +2639,13 @@ bool cmake::IsMessageTypeVisible(cmake::MessageType t)
isVisible = false;
}
}
else if (t == cmake::AUTHOR_ERROR)
{
if (!this->GetDevWarningsAsErrors())
{
isVisible = false;
}
}
else if (t == cmake::AUTHOR_WARNING)
{
if (this->GetSuppressDevWarnings())
@ -2606,6 +2684,10 @@ bool cmake::PrintMessagePreamble(cmake::MessageType t, std::ostream& msg)
{
msg << "CMake Warning (dev)";
}
else if (t == cmake::AUTHOR_ERROR)
{
msg << "CMake Error (dev)";
}
else
{
msg << "CMake Warning";
@ -2630,6 +2712,12 @@ void displayMessage(cmake::MessageType t, std::ostringstream& msg)
msg <<
"This warning is for project developers. Use -Wno-dev to suppress it.";
}
else if (t == cmake::AUTHOR_ERROR)
{
msg <<
"This error is for project developers. Use -Wno-error=dev to suppress "
"it.";
}
// Add a terminating blank line.
msg << "\n";
@ -2653,7 +2741,8 @@ void displayMessage(cmake::MessageType t, std::ostringstream& msg)
// Output the message.
if(t == cmake::FATAL_ERROR
|| t == cmake::INTERNAL_ERROR
|| t == cmake::DEPRECATION_ERROR)
|| t == cmake::DEPRECATION_ERROR
|| t == cmake::AUTHOR_ERROR)
{
cmSystemTools::SetErrorOccured();
cmSystemTools::Message(msg.str().c_str(), "Error");
@ -2671,6 +2760,17 @@ void cmake::IssueMessage(cmake::MessageType t, std::string const& text,
{
cmListFileBacktrace backtrace = bt;
if (!force)
{
// override the message type, if needed, for warnings and errors
cmake::MessageType override = this->ConvertMessageType(t);
if (override != t)
{
t = override;
force = true;
}
}
if (!force && !this->IsMessageTypeVisible(t))
{
return;
@ -2698,6 +2798,17 @@ void cmake::IssueMessage(cmake::MessageType t, std::string const& text,
cmListFileContext const& lfc,
bool force)
{
if (!force)
{
// override the message type, if needed, for warnings and errors
cmake::MessageType override = this->ConvertMessageType(t);
if (override != t)
{
t = override;
force = true;
}
}
if (!force && !this->IsMessageTypeVisible(t))
{
return;
@ -2941,3 +3052,74 @@ void cmake::SetSuppressDeprecatedWarnings(bool b)
"functionality.",
cmState::INTERNAL);
}
bool cmake::GetDevWarningsAsErrors(cmMakefile const* mf)
{
if (mf)
{
return (mf->IsSet("CMAKE_SUPPRESS_DEVELOPER_ERRORS") &&
!mf->IsOn("CMAKE_SUPPRESS_DEVELOPER_ERRORS"));
}
else
{
const char* cacheEntryValue = this->State->GetCacheEntryValue(
"CMAKE_SUPPRESS_DEVELOPER_ERRORS");
return cacheEntryValue && cmSystemTools::IsOff(cacheEntryValue);
}
}
void cmake::SetDevWarningsAsErrors(bool b)
{
std::string value;
// equivalent to -Werror=dev
if (b)
{
value = "FALSE";
}
// equivalent to -Wno-error=dev
else
{
value = "TRUE";
}
this->AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_ERRORS", value.c_str(),
"Suppress errors that are meant for"
" the author of the CMakeLists.txt files.",
cmState::INTERNAL);
}
bool cmake::GetDeprecatedWarningsAsErrors(cmMakefile const* mf)
{
if (mf)
{
return mf->IsOn("CMAKE_ERROR_DEPRECATED");
}
else
{
const char* cacheEntryValue = this->State->GetCacheEntryValue(
"CMAKE_ERROR_DEPRECATED");
return cmSystemTools::IsOn(cacheEntryValue);
}
}
void cmake::SetDeprecatedWarningsAsErrors(bool b)
{
std::string value;
// equivalent to -Werror=deprecated
if (b)
{
value = "TRUE";
}
// equivalent to -Wno-error=deprecated
else
{
value = "FALSE";
}
this->AddCacheEntry("CMAKE_ERROR_DEPRECATED", value.c_str(),
"Whether to issue deprecation errors for macros"
" and functions.",
cmState::INTERNAL);
}

42
Source/cmake.h
View File

@ -59,6 +59,7 @@ class cmake
public:
enum MessageType
{ AUTHOR_WARNING,
AUTHOR_ERROR,
FATAL_ERROR,
INTERNAL_ERROR,
MESSAGE,
@ -71,7 +72,8 @@ class cmake
enum DiagLevel
{
DIAG_IGNORE,
DIAG_WARN
DIAG_WARN,
DIAG_ERROR
};
/** \brief Describes the working modes of cmake */
@ -330,6 +332,28 @@ class cmake
*/
void SetSuppressDeprecatedWarnings(bool v);
/*
* Get the state of treating developer (author) warnings as errors.
* Returns false, by default, if warnings should not be treated as errors,
* true otherwise.
*/
bool GetDevWarningsAsErrors(cmMakefile const* mf = NULL);
/**
* Set the state of treating developer (author) warnings as errors.
*/
void SetDevWarningsAsErrors(bool v);
/*
* Get the state of treating deprecated warnings as errors.
* Returns false, by default, if warnings should not be treated as errors,
* true otherwise.
*/
bool GetDeprecatedWarningsAsErrors(cmMakefile const* mf = NULL);
/**
* Set the state of treating developer (author) warnings as errors.
*/
void SetDeprecatedWarningsAsErrors(bool v);
/** Display a message to the user. */
void IssueMessage(cmake::MessageType t, std::string const& text,
cmListFileBacktrace const& backtrace = cmListFileBacktrace(),
@ -441,6 +465,12 @@ private:
// Print a list of valid generators to stderr.
void PrintGeneratorList();
/**
* Convert a message type between a warning and an error, based on the state
* of the error output CMake variables, in the cache.
*/
cmake::MessageType ConvertMessageType(cmake::MessageType t);
/*
* Check if messages of this type should be output, based on the state of the
* warning and error output CMake variables, in the cache.
@ -457,10 +487,16 @@ private:
{"-G <generator-name>", "Specify a build system generator."},\
{"-T <toolset-name>", "Specify toolset name if supported by generator."}, \
{"-A <platform-name>", "Specify platform name if supported by generator."}, \
{"-Wno-dev", "Suppress developer warnings."},\
{"-Wdev", "Enable developer warnings."},\
{"-Wno-dev", "Suppress developer warnings."},\
{"-Werror=dev", "Make developer warnings errors."},\
{"-Wno-error=dev", "Make developer warnings not errors."},\
{"-Wdeprecated", "Enable deprecation warnings."},\
{"-Wno-deprecated", "Suppress deprecation warnings."}
{"-Wno-deprecated", "Suppress deprecation warnings."},\
{"-Werror=deprecated", "Make deprecated macro and function warnings " \
"errors."},\
{"-Wno-error=deprecated", "Make deprecated macro and function warnings " \
"not errors."}
#define FOR_EACH_C_FEATURE(F) \
F(c_function_prototypes) \

22
Tests/RunCMake/CommandLine/RunCMakeTest.cmake
View File

@ -187,6 +187,14 @@ set(RunCMake_TEST_OPTIONS -Wdev)
run_cmake(Wdev)
unset(RunCMake_TEST_OPTIONS)
set(RunCMake_TEST_OPTIONS -Werror=dev)
run_cmake(Werror_dev)
unset(RunCMake_TEST_OPTIONS)
set(RunCMake_TEST_OPTIONS -Wno-error=dev)
run_cmake(Wno-error_deprecated)
unset(RunCMake_TEST_OPTIONS)
# -Wdev should not override deprecated options if specified
set(RunCMake_TEST_OPTIONS -Wdev -Wno-deprecated)
run_cmake(Wno-deprecated)
@ -200,6 +208,11 @@ set(RunCMake_TEST_OPTIONS -Wdev)
run_cmake(Wdeprecated)
unset(RunCMake_TEST_OPTIONS)
# -Werror=dev should enable deprecated errors as well
set(RunCMake_TEST_OPTIONS -Werror=dev)
run_cmake(Werror_deprecated)
unset(RunCMake_TEST_OPTIONS)
set(RunCMake_TEST_OPTIONS -Wdeprecated)
run_cmake(Wdeprecated)
unset(RunCMake_TEST_OPTIONS)
@ -208,6 +221,14 @@ set(RunCMake_TEST_OPTIONS -Wno-deprecated)
run_cmake(Wno-deprecated)
unset(RunCMake_TEST_OPTIONS)
set(RunCMake_TEST_OPTIONS -Werror=deprecated)
run_cmake(Werror_deprecated)
unset(RunCMake_TEST_OPTIONS)
set(RunCMake_TEST_OPTIONS -Wno-error=deprecated)
run_cmake(Wno-error_deprecated)
unset(RunCMake_TEST_OPTIONS)
# Dev warnings should be on by default
run_cmake(Wdev)
@ -224,6 +245,7 @@ unset(RunCMake_TEST_OPTIONS)
run_cmake_command(W_bad-arg1 ${CMAKE_COMMAND} -W)
run_cmake_command(W_bad-arg2 ${CMAKE_COMMAND} -Wno-)
run_cmake_command(W_bad-arg3 ${CMAKE_COMMAND} -Werror=)
set(RunCMake_TEST_OPTIONS --debug-output)
run_cmake(debug-output)

0
Tests/RunCMake/message/errormessage-result.txt → Tests/RunCMake/CommandLine/W_bad-arg3-result.txt
View File

2
Tests/RunCMake/CommandLine/W_bad-arg3-stderr.txt Normal file
View File

@ -0,0 +1,2 @@
CMake Error: No warning name provided.
CMake Error: Problem processing arguments. Aborting.

1
Tests/RunCMake/CommandLine/Werror_deprecated-result.txt Normal file
View File

@ -0,0 +1 @@
1

4
Tests/RunCMake/CommandLine/Werror_deprecated-stderr.txt Normal file
View File

@ -0,0 +1,4 @@
^CMake Deprecation Error at Werror_deprecated.cmake:1 \(message\):
Some deprecated warning
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)

1
Tests/RunCMake/CommandLine/Werror_deprecated.cmake Normal file
View File

@ -0,0 +1 @@
message(DEPRECATION "Some deprecated warning")

1
Tests/RunCMake/CommandLine/Werror_dev-result.txt Normal file
View File

@ -0,0 +1 @@
1

11
Tests/RunCMake/CommandLine/Werror_dev-stderr.txt Normal file
View File

@ -0,0 +1,11 @@
^CMake Error \(dev\) at Werror_dev.cmake:4 \(include\):
include\(\) given empty file name \(ignored\).
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)
This error is for project developers. Use -Wno-error=dev to suppress it.
CMake Error \(dev\) at Werror_dev.cmake:7 \(message\):
Some author warning
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)
This error is for project developers. Use -Wno-error=dev to suppress it.$

7
Tests/RunCMake/CommandLine/Werror_dev.cmake Normal file
View File

@ -0,0 +1,7 @@
# with -Werror=dev this will also cause an (upgraded) AUTHOR_ERROR message,
# checks that messages issued outside of the message command, by other CMake
# commands, also are affected by -Werror=dev
include("")
# message command sets fatal occurred flag, so run it last
message(AUTHOR_WARNING "Some author warning")

4
Tests/RunCMake/CommandLine/Wno-error_deprecated-stderr.txt Normal file
View File

@ -0,0 +1,4 @@
^CMake Deprecation Warning at Wno-error_deprecated.cmake:2 \(message\):
Some deprecated warning
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)

2
Tests/RunCMake/CommandLine/Wno-error_deprecated.cmake Normal file
View File

@ -0,0 +1,2 @@
# This should still produce a warning when -Wno-error=deprecated is specified
message(DEPRECATION "Some deprecated warning")

11
Tests/RunCMake/CommandLine/Wno-error_dev-stderr.txt Normal file
View File

@ -0,0 +1,11 @@
^CMake Warning \(dev\) at Wno-error_dev.cmake:2 \(message\):
Some author warning
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)
This warning is for project developers. Use -Wno-dev to suppress it.
CMake Warning \(dev\) at Wno-error_dev.cmake:6 \(include\):
include\(\) given empty file name \(ignored\).
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)
This warning is for project developers. Use -Wno-dev to suppress it.$

7
Tests/RunCMake/CommandLine/Wno-error_dev.cmake Normal file
View File

@ -0,0 +1,7 @@
# This should still produce a warning when -Wno-error=dev is specified
message(AUTHOR_WARNING "Some author warning")
# with -Wno-error=dev this will also cause an AUTHOR_WARNING message, checks
# that messages issued outside of the message command, by other CMake commands,
# also are affected by -Wno-error=dev
include("")

6
Tests/RunCMake/message/RunCMakeTest.cmake
View File

@ -3,4 +3,8 @@ include(RunCMake)
run_cmake(defaultmessage)
run_cmake(nomessage)
run_cmake(warnmessage)
run_cmake(errormessage)
# message command sets fatal occurred flag, so check each type of error
# seperately
run_cmake(errormessage_deprecated)
run_cmake(errormessage_dev)

4
Tests/RunCMake/message/errormessage-stderr.txt
View File

@ -1,4 +0,0 @@
CMake Deprecation Error at errormessage.cmake:4 \(message\):
This is an error
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)

4
Tests/RunCMake/message/errormessage.cmake
View File

@ -1,4 +0,0 @@
set(CMAKE_ERROR_DEPRECATED ON)
message(DEPRECATION "This is an error")

1
Tests/RunCMake/message/errormessage_deprecated-result.txt Normal file
View File

@ -0,0 +1 @@
1

4
Tests/RunCMake/message/errormessage_deprecated-stderr.txt Normal file
View File

@ -0,0 +1,4 @@
^CMake Deprecation Error at errormessage_deprecated.cmake:3 \(message\):
This is a deprecation error
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)$

3
Tests/RunCMake/message/errormessage_deprecated.cmake Normal file
View File

@ -0,0 +1,3 @@
set(CMAKE_ERROR_DEPRECATED ON)
message(DEPRECATION "This is a deprecation error")

1
Tests/RunCMake/message/errormessage_dev-result.txt Normal file
View File

@ -0,0 +1 @@
1

5
Tests/RunCMake/message/errormessage_dev-stderr.txt Normal file
View File

@ -0,0 +1,5 @@
^CMake Error \(dev\) at errormessage_dev.cmake:3 \(message\):
This is a author error
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)
This error is for project developers. Use -Wno-error=dev to suppress it.$

3
Tests/RunCMake/message/errormessage_dev.cmake Normal file
View File

@ -0,0 +1,3 @@
set(CMAKE_SUPPRESS_DEVELOPER_ERRORS OFF)
message(AUTHOR_WARNING "This is a author error")