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

Merge topic 'cmake-W-options' 

aac633d5 Explicitly enable deprecated warnings by default.
e8974b62 Modify dev warning options to affect deprecated warnings.
b146747e Consistent documentation for deprecation message variables.
da688bcb Add -W options to control deprecated warning messages.
07388f83 Refactor the -W options parser to be generic.
246b0bfb Explicitly enable author (dev) warnings by default.
deec3a3f Make message suppression more consistent.
aa427a42 Tests: Revise message in RunCMake.CommandLine -Wdev case
This commit is contained in:
Brad King 2015-12-02 08:42:06 -05:00 committed by CMake Topic Stage
parent da78a1648f aac633d5e5
commit 3fa2fc71b1
27 changed files with 396 additions and 77 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
Help/manual/OPTIONS_BUILD.txt
View File

@ -77,10 +77,23 @@
Suppress developer warnings.
Suppress warnings that are meant for the author of the
CMakeLists.txt files.
CMakeLists.txt files. By default this will also turn off
deprecation warnings.
``-Wdev``
Enable developer warnings.
Enable warnings that are meant for the author of the CMakeLists.txt
files.
files. By default this will also turn on deprecation warnings.
``-Wdeprecated``
Enable deprecated functionality warnings.
Enable warnings for usage of deprecated functionality, that are meant
for the author of the CMakeLists.txt files.
``-Wno-deprecated``
Suppress deprecated functionality warnings.
Suppress warnings for usage of deprecated functionality, that are meant
for the author of the CMakeLists.txt files.

12
Help/release/dev/cmake-W-options.rst Normal file
View File

@ -0,0 +1,12 @@
cmake-W-options
---------------
* The :variable:`CMAKE_WARN_DEPRECATED` variable can now be set using the
``-Wdeprecated`` and ``-Wno-deprecated`` :manual:`cmake(1)` options.
* The ``-Wdev`` and ``-Wno-dev`` :manual:`cmake(1)` options now also enable
and suppress the deprecated warnings output by default.
* Warnings about deprecated functionality are now enabled by default.
They may be suppressed with ``-Wno-deprecated`` or by setting the
:variable:`CMAKE_WARN_DEPRECATED` variable to false.

7
Help/variable/CMAKE_ERROR_DEPRECATED.rst
View File

@ -1,8 +1,7 @@
CMAKE_ERROR_DEPRECATED
----------------------
Whether to issue deprecation errors for macros and functions.
Whether to issue errors for deprecated functionality.
If ``TRUE``, this can be used by macros and functions to issue fatal
errors when deprecated macros or functions are used. This variable is
``FALSE`` by default.
If ``TRUE``, use of deprecated functionality will issue fatal errors.
If this variable is not set, CMake behaves as if it were set to ``FALSE``.

9
Help/variable/CMAKE_WARN_DEPRECATED.rst
View File

@ -1,7 +1,10 @@
CMAKE_WARN_DEPRECATED
---------------------
Whether to issue deprecation warnings for macros and functions.
Whether to issue warnings for deprecated functionality.
If ``TRUE``, this can be used by macros and functions to issue deprecation
warnings. This variable is ``FALSE`` by default.
If not ``FALSE``, use of deprecated functionality will issue warnings.
If this variable is not set, CMake behaves as if it were set to ``TRUE``.
When running :manual:`cmake(1)`, this option can be enabled with the
``-Wdeprecated`` option, or disabled with the ``-Wno-deprecated`` option.

8
Source/cmMakefile.cxx
View File

@ -105,7 +105,8 @@ cmMakefile::~cmMakefile()
//----------------------------------------------------------------------------
void cmMakefile::IssueMessage(cmake::MessageType t,
std::string const& text) const
std::string const& text,
bool force) const
{
// Collect context information.
if(!this->ExecutionStatusStack.empty())
@ -114,7 +115,8 @@ void cmMakefile::IssueMessage(cmake::MessageType t,
{
this->ExecutionStatusStack.back()->SetNestedError(true);
}
this->GetCMakeInstance()->IssueMessage(t, text, this->GetBacktrace());
this->GetCMakeInstance()->IssueMessage(t, text, this->GetBacktrace(),
force);
}
else
{
@ -129,7 +131,7 @@ void cmMakefile::IssueMessage(cmake::MessageType t,
lfc.FilePath = converter.Convert(lfc.FilePath, cmOutputConverter::HOME);
}
lfc.Line = 0;
this->GetCMakeInstance()->IssueMessage(t, text, lfc);
this->GetCMakeInstance()->IssueMessage(t, text, lfc, force);
}
}

3
Source/cmMakefile.h
View File

@ -709,7 +709,8 @@ public:
};
void IssueMessage(cmake::MessageType t,
std::string const& text) const;
std::string const& text,
bool force = false) const;
/** Set whether or not to report a CMP0000 violation. */
void SetCheckCMP0000(bool b) { this->CheckCMP0000 = b; }

27
Source/cmMessageCommand.cxx
View File

@ -43,7 +43,15 @@ bool cmMessageCommand
}
else if (*i == "AUTHOR_WARNING")
{
type = cmake::AUTHOR_WARNING;
if (this->Makefile->GetCMakeInstance()->GetSuppressDevWarnings(
this->Makefile))
{
return true;
}
else
{
type = cmake::AUTHOR_WARNING;
}
++i;
}
else if (*i == "STATUS")
@ -58,13 +66,17 @@ bool cmMessageCommand
fatal = true;
type = cmake::DEPRECATION_ERROR;
}
else if (this->Makefile->IsOn("CMAKE_WARN_DEPRECATED"))
{
type = cmake::DEPRECATION_WARNING;
}
else
{
return true;
if (this->Makefile->GetCMakeInstance()->GetSuppressDeprecatedWarnings(
this->Makefile))
{
return true;
}
else
{
type = cmake::DEPRECATION_WARNING;
}
}
++i;
}
@ -73,7 +85,8 @@ bool cmMessageCommand
if (type != cmake::MESSAGE)
{
this->Makefile->IssueMessage(type, message);
// we've overriden the message type, above, so force IssueMessage to use it
this->Makefile->IssueMessage(type, message, true);
}
else
{

251
Source/cmake.cxx
View File

@ -127,8 +127,6 @@ cmake::cmake()
this->WarnUnused = false;
this->WarnUnusedCli = true;
this->CheckSystemVars = false;
this->SuppressDevWarnings = false;
this->DoSuppressDevWarnings = false;
this->DebugOutput = false;
this->DebugTryCompile = false;
this->ClearBuildSystem = false;
@ -274,15 +272,51 @@ bool cmake::SetCacheArgs(const std::vector<std::string>& args)
return false;
}
}
else if(arg.find("-Wno-dev",0) == 0)
else if(cmHasLiteralPrefix(arg, "-W"))
{
this->SuppressDevWarnings = true;
this->DoSuppressDevWarnings = true;
}
else if(arg.find("-Wdev",0) == 0)
{
this->SuppressDevWarnings = false;
this->DoSuppressDevWarnings = true;
std::string entry = arg.substr(2);
if (entry.empty())
{
++i;
if (i < args.size())
{
entry = args[i];
}
else
{
cmSystemTools::Error("-W must be followed with [no-]<name>.");
return false;
}
}
std::string name;
bool foundNo = false;
unsigned int nameStartPosition = 0;
if (entry.find("no-", nameStartPosition) == 0)
{
foundNo = true;
nameStartPosition += 3;
}
name = entry.substr(nameStartPosition);
if (name.empty())
{
cmSystemTools::Error("No warning name provided.");
return false;
}
if (!foundNo)
{
// -W<name>
this->DiagLevels[name] = std::max(this->DiagLevels[name],
DIAG_WARN);
}
else
{
// -Wno<name>
this->DiagLevels[name] = DIAG_IGNORE;
}
}
else if(arg.find("-U",0) == 0)
{
@ -618,11 +652,7 @@ void cmake::SetArgs(const std::vector<std::string>& args,
// skip for now
i++;
}
else if(arg.find("-Wno-dev",0) == 0)
{
// skip for now
}
else if(arg.find("-Wdev",0) == 0)
else if(arg.find("-W",0) == 0)
{
// skip for now
}
@ -1231,25 +1261,74 @@ int cmake::HandleDeleteCacheVariables(const std::string& var)
int cmake::Configure()
{
if(this->DoSuppressDevWarnings)
DiagLevel diagLevel;
if (this->DiagLevels.count("deprecated") == 1)
{
if(this->SuppressDevWarnings)
diagLevel = this->DiagLevels["deprecated"];
if (diagLevel == DIAG_IGNORE)
{
this->
AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", "TRUE",
"Suppress Warnings that are meant for"
" the author of the CMakeLists.txt files.",
cmState::INTERNAL);
this->AddCacheEntry("CMAKE_WARN_DEPRECATED", "FALSE",
"Whether to issue warnings for deprecated "
"functionality.",
cmState::INTERNAL);
}
else
else if (diagLevel == DIAG_WARN)
{
this->
AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", "FALSE",
"Suppress Warnings that are meant for"
" the author of the CMakeLists.txt files.",
cmState::INTERNAL);
this->AddCacheEntry("CMAKE_WARN_DEPRECATED", "TRUE",
"Whether to issue warnings for deprecated "
"functionality.",
cmState::INTERNAL);
}
}
if (this->DiagLevels.count("dev") == 1)
{
bool setDeprecatedVariables = false;
const char* cachedWarnDeprecated =
this->State->GetCacheEntryValue("CMAKE_WARN_DEPRECATED");
// don't overwrite deprecated warning setting from a previous invocation
if (!cachedWarnDeprecated)
{
setDeprecatedVariables = true;
}
diagLevel = this->DiagLevels["dev"];
if (diagLevel == DIAG_IGNORE)
{
this->AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", "TRUE",
"Suppress Warnings that are meant for"
" the author of the CMakeLists.txt files.",
cmState::INTERNAL);
if (setDeprecatedVariables)
{
this->AddCacheEntry("CMAKE_WARN_DEPRECATED", "FALSE",
"Whether to issue warnings for deprecated "
"functionality.",
cmState::INTERNAL);
}
}
else if (diagLevel == DIAG_WARN)
{
this->AddCacheEntry("CMAKE_SUPPRESS_DEVELOPER_WARNINGS", "FALSE",
"Suppress Warnings that are meant for"
" the author of the CMakeLists.txt files.",
cmState::INTERNAL);
if (setDeprecatedVariables)
{
this->AddCacheEntry("CMAKE_WARN_DEPRECATED", "TRUE",
"Whether to issue warnings for deprecated "
"functionality.",
cmState::INTERNAL);
}
}
}
int ret = this->ActualConfigure();
const char* delCacheVars = this->State
->GetGlobalProperty("__CMAKE_DELETE_CACHE_CHANGE_VARS_");
@ -1580,6 +1659,7 @@ int cmake::Run(const std::vector<std::string>& args, bool noconfigure)
{
this->AddCMakePaths();
}
// Add any cache args
if ( !this->SetCacheArgs(args) )
{
@ -2485,6 +2565,38 @@ static bool cmakeCheckStampList(const char* stampList)
return true;
}
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))
{
isVisible = false;
}
}
else if (t == cmake::DEPRECATION_WARNING)
{
if (this->GetSuppressDeprecatedWarnings())
{
isVisible = false;
}
}
else if (t == cmake::AUTHOR_WARNING)
{
if (this->GetSuppressDevWarnings())
{
isVisible = false;
}
}
return isVisible;
}
bool cmake::PrintMessagePreamble(cmake::MessageType t, std::ostream& msg)
{
// Construct the message header.
@ -2508,20 +2620,13 @@ bool cmake::PrintMessagePreamble(cmake::MessageType t, std::ostream& msg)
{
msg << "CMake Deprecation Warning";
}
else if (t == cmake::AUTHOR_WARNING)
{
msg << "CMake Warning (dev)";
}
else
{
msg << "CMake Warning";
if(t == cmake::AUTHOR_WARNING)
{
// Allow suppression of these warnings.
const char* suppress = this->State->GetCacheEntryValue(
"CMAKE_SUPPRESS_DEVELOPER_WARNINGS");
if(suppress && cmSystemTools::IsOn(suppress))
{
return false;
}
msg << " (dev)";
}
}
return true;
}
@ -2579,10 +2684,16 @@ void displayMessage(cmake::MessageType t, std::ostringstream& msg)
//----------------------------------------------------------------------------
void cmake::IssueMessage(cmake::MessageType t, std::string const& text,
cmListFileBacktrace const& bt)
cmListFileBacktrace const& bt,
bool force)
{
cmListFileBacktrace backtrace = bt;
if (!force && !this->IsMessageTypeVisible(t))
{
return;
}
std::ostringstream msg;
if (!this->PrintMessagePreamble(t, msg))
{
@ -2602,8 +2713,14 @@ void cmake::IssueMessage(cmake::MessageType t, std::string const& text,
//----------------------------------------------------------------------------
void cmake::IssueMessage(cmake::MessageType t, std::string const& text,
cmListFileContext const& lfc)
cmListFileContext const& lfc,
bool force)
{
if (!force && !this->IsMessageTypeVisible(t))
{
return;
}
std::ostringstream msg;
if (!this->PrintMessagePreamble(t, msg))
{
@ -2763,3 +2880,55 @@ void cmake::RunCheckForUnusedVariables()
}
#endif
}
void cmake::SetSuppressDevWarnings(bool b)
{
// equivalent to -Wno-dev
if (b)
{
this->DiagLevels["dev"] = DIAG_IGNORE;
}
// equivalent to -Wdev
else
{
this->DiagLevels["dev"] = std::max(this->DiagLevels["dev"],
DIAG_WARN);
}
}
bool cmake::GetSuppressDevWarnings(cmMakefile const* mf)
{
/*
* The suppression CMake variable may be set in the CMake configuration file
* itself, so we have to check what its set to in the makefile if we can.
*/
if (mf)
{
return mf->IsOn("CMAKE_SUPPRESS_DEVELOPER_WARNINGS");
}
else
{
const char* cacheEntryValue = this->State->GetCacheEntryValue(
"CMAKE_SUPPRESS_DEVELOPER_WARNINGS");
return cmSystemTools::IsOn(cacheEntryValue);
}
}
bool cmake::GetSuppressDeprecatedWarnings(cmMakefile const* mf)
{
/*
* The suppression CMake variable may be set in the CMake configuration file
* itself, so we have to check what its set to in the makefile if we can.
*/
if (mf)
{
return (mf->IsSet("CMAKE_WARN_DEPRECATED") &&
!mf->IsOn("CMAKE_WARN_DEPRECATED"));
}
else
{
const char* cacheEntryValue = this->State->GetCacheEntryValue(
"CMAKE_WARN_DEPRECATED");
return cacheEntryValue && cmSystemTools::IsOff(cacheEntryValue);
}
}

43
Source/cmake.h
View File

@ -68,6 +68,11 @@ class cmake
DEPRECATION_WARNING
};
enum DiagLevel
{
DIAG_IGNORE,
DIAG_WARN
};
/** \brief Describes the working modes of cmake */
enum WorkingMode
@ -303,17 +308,28 @@ class cmake
std::string const& GetCMakeEditCommand() const
{ return this->CMakeEditCommand; }
void SetSuppressDevWarnings(bool v)
{
this->SuppressDevWarnings = v;
this->DoSuppressDevWarnings = true;
}
void SetSuppressDevWarnings(bool v);
/*
* Get the state of the suppression of developer (author) warnings.
* Returns false, by default, if developer warnings should be shown, true
* otherwise.
*/
bool GetSuppressDevWarnings(cmMakefile const* mf = NULL);
/*
* Get the state of the suppression of deprecated warnings.
* Returns false, by default, if deprecated warnings should be shown, true
* otherwise.
*/
bool GetSuppressDeprecatedWarnings(cmMakefile const* mf = NULL);
/** Display a message to the user. */
void IssueMessage(cmake::MessageType t, std::string const& text,
cmListFileBacktrace const& backtrace = cmListFileBacktrace());
cmListFileBacktrace const& backtrace = cmListFileBacktrace(),
bool force = false);
void IssueMessage(cmake::MessageType t, std::string const& text,
cmListFileContext const& lfc);
cmListFileContext const& lfc,
bool force = false);
///! run the --build option
int Build(const std::string& dir,
@ -351,8 +367,7 @@ protected:
cmGlobalGenerator *GlobalGenerator;
cmCacheManager *CacheManager;
bool SuppressDevWarnings;
bool DoSuppressDevWarnings;
std::map<std::string, DiagLevel> DiagLevels;
std::string GeneratorPlatform;
std::string GeneratorToolset;
@ -419,6 +434,12 @@ private:
// Print a list of valid generators to stderr.
void PrintGeneratorList();
/*
* Check if messages of this type should be output, based on the state of the
* warning and error output CMake variables, in the cache.
*/
bool IsMessageTypeVisible(cmake::MessageType t);
bool PrintMessagePreamble(cmake::MessageType t, std::ostream& msg);
};
@ -430,7 +451,9 @@ private:
{"-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."}
{"-Wdev", "Enable developer warnings."},\
{"-Wdeprecated", "Enable deprecation warnings."},\
{"-Wno-deprecated", "Suppress deprecation warnings."}
#define FOR_EACH_C_FEATURE(F) \
F(c_function_prototypes) \

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

@ -129,9 +129,47 @@ set(RunCMake_TEST_OPTIONS -Wno-dev)
run_cmake(Wno-dev)
unset(RunCMake_TEST_OPTIONS)
set(RunCMake_TEST_OPTIONS -Wdev)
run_cmake(Wdev)
unset(RunCMake_TEST_OPTIONS)
# -Wdev should not override deprecated options if specified
set(RunCMake_TEST_OPTIONS -Wdev -Wno-deprecated)
run_cmake(Wno-deprecated)
unset(RunCMake_TEST_OPTIONS)
set(RunCMake_TEST_OPTIONS -Wno-deprecated -Wdev)
run_cmake(Wno-deprecated)
unset(RunCMake_TEST_OPTIONS)
# -Wdev should enable deprecated warnings as well
set(RunCMake_TEST_OPTIONS -Wdev)
run_cmake(Wdeprecated)
unset(RunCMake_TEST_OPTIONS)
set(RunCMake_TEST_OPTIONS -Wdeprecated)
run_cmake(Wdeprecated)
unset(RunCMake_TEST_OPTIONS)
set(RunCMake_TEST_OPTIONS -Wno-deprecated)
run_cmake(Wno-deprecated)
unset(RunCMake_TEST_OPTIONS)
# Dev warnings should be on by default
run_cmake(Wdev)
# Deprecated warnings should be on by default
run_cmake(Wdeprecated)
# Conflicting -W options should honor the last value
set(RunCMake_TEST_OPTIONS -Wno-dev -Wdev)
run_cmake(Wdev)
unset(RunCMake_TEST_OPTIONS)
set(RunCMake_TEST_OPTIONS -Wdev -Wno-dev)
run_cmake(Wno-dev)
unset(RunCMake_TEST_OPTIONS)
run_cmake_command(W_bad-arg1 ${CMAKE_COMMAND} -W)
run_cmake_command(W_bad-arg2 ${CMAKE_COMMAND} -Wno-)
set(RunCMake_TEST_OPTIONS --debug-output)
run_cmake(debug-output)

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

@ -0,0 +1 @@
1

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

@ -0,0 +1,2 @@
CMake Error: -W must be followed with \[no-\]<name>.
CMake Error: Problem processing arguments. Aborting.

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

@ -0,0 +1 @@
1

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

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

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

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

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

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

2
Tests/RunCMake/CommandLine/Wdev-stderr.txt
View File

@ -1,5 +1,5 @@
^CMake Warning \(dev\) at Wdev.cmake:1 \(message\):
Some Author Warning
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.

2
Tests/RunCMake/CommandLine/Wdev.cmake
View File

@ -1,4 +1,4 @@
message(AUTHOR_WARNING "Some Author Warning")
message(AUTHOR_WARNING "Some author warning")
# with -Wdev this will also cause an AUTHOR_WARNING message, checks that
# messages issued outside of the message command, by other CMake commands, also

1
Tests/RunCMake/CommandLine/Wno-deprecated.cmake Normal file
View File

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

2
Tests/RunCMake/CommandLine/Wno-dev.cmake
View File

@ -1,4 +1,4 @@
message(AUTHOR_WARNING "Some Author Warning")
message(AUTHOR_WARNING "Some author warning")
# without -Wno-dev this will also cause an AUTHOR_WARNING message, checks that
# messages issued outside of the message command, by other CMake commands, also

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

@ -1,5 +1,6 @@
include(RunCMake)
run_cmake(defaultmessage)
run_cmake(nomessage)
run_cmake(warnmessage)
run_cmake(errormessage)

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

@ -0,0 +1 @@
0

11
Tests/RunCMake/message/defaultmessage-stderr.txt Normal file
View File

@ -0,0 +1,11 @@
^CMake Deprecation Warning at defaultmessage.cmake:2 \(message\):
This is a deprecation warning
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)
CMake Warning \(dev\) at defaultmessage.cmake:4 \(message\):
This is a author warning
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)
This warning is for project developers. Use -Wno-dev to suppress it.$

4
Tests/RunCMake/message/defaultmessage.cmake Normal file
View File

@ -0,0 +1,4 @@
message(DEPRECATION "This is a deprecation warning")
message(AUTHOR_WARNING "This is a author warning")

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

@ -1,2 +1,8 @@
set(CMAKE_WARN_DEPRECATED OFF)
message(DEPRECATION "This is not issued")
set(CMAKE_SUPPRESS_DEVELOPER_WARNINGS ON)
message(AUTHOR_WARNING "This is not issued")

11
Tests/RunCMake/message/warnmessage-stderr.txt
View File

@ -1,4 +1,11 @@
CMake Deprecation Warning at warnmessage.cmake:4 \(message\):
This is a warning
^CMake Deprecation Warning at warnmessage.cmake:4 \(message\):
This is a deprecation warning
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)
CMake Warning \(dev\) at warnmessage.cmake:8 \(message\):
This is a author warning
Call Stack \(most recent call first\):
CMakeLists.txt:3 \(include\)
This warning is for project developers. Use -Wno-dev to suppress it.$

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

@ -1,4 +1,8 @@
set(CMAKE_WARN_DEPRECATED ON)
message(DEPRECATION "This is a warning")
message(DEPRECATION "This is a deprecation warning")
set(CMAKE_SUPPRESS_DEVELOPER_WARNINGS OFF)
message(AUTHOR_WARNING "This is a author warning")