Merge topic 'message-new-types-and-logging'

599587feb1 message(): Minor code modernization
6cc93b370e message(): Add support for log levels
377d1b7896 cmSystemTools: Remove unused message-related code, simplify logic

Acked-by: Kitware Robot <kwrobot@kitware.com>
Acked-by: Brad King <brad.king@kitware.com>
Merge-request: !3268

6 files changed, 98 insertions, 14 deletions

diff --git a/Source/cmMessageCommand.cxx b/Source/cmMessageCommand.cxx
index 2724030..5320ec5 100644
--- a/Source/cmMessageCommand.cxx
+++ b/Source/cmMessageCommand.cxx
@@ -8,6 +8,9 @@
 #include "cmMessenger.h"
 #include "cmRange.h"
 #include "cmSystemTools.h"
+#include "cmake.h"
+
+#include <cassert>
 
 class cmExecutionStatus;
 
@@ -19,49 +22,88 @@ bool cmMessageCommand::InitialPass(std::vector<std::string> const& args,
     this->SetError("called with incorrect number of arguments");
     return false;
   }
-  std::vector<std::string>::const_iterator i = args.begin();
+  auto i = args.cbegin();
 
-  MessageType type = MessageType::MESSAGE;
-  bool status = false;
-  bool fatal = false;
+  auto type = MessageType::MESSAGE;
+  auto status = false;
+  auto fatal = false;
+  auto level = cmake::LogLevel::LOG_UNDEFINED;
   if (*i == "SEND_ERROR") {
     type = MessageType::FATAL_ERROR;
+    level = cmake::LogLevel::LOG_ERROR;
     ++i;
   } else if (*i == "FATAL_ERROR") {
     fatal = true;
     type = MessageType::FATAL_ERROR;
+    level = cmake::LogLevel::LOG_ERROR;
     ++i;
   } else if (*i == "WARNING") {
     type = MessageType::WARNING;
+    level = cmake::LogLevel::LOG_WARNING;
     ++i;
   } else if (*i == "AUTHOR_WARNING") {
     if (this->Makefile->IsSet("CMAKE_SUPPRESS_DEVELOPER_ERRORS") &&
         !this->Makefile->IsOn("CMAKE_SUPPRESS_DEVELOPER_ERRORS")) {
       fatal = true;
       type = MessageType::AUTHOR_ERROR;
+      level = cmake::LogLevel::LOG_ERROR;
     } else if (!this->Makefile->IsOn("CMAKE_SUPPRESS_DEVELOPER_WARNINGS")) {
       type = MessageType::AUTHOR_WARNING;
+      level = cmake::LogLevel::LOG_WARNING;
     } else {
       return true;
     }
     ++i;
   } else if (*i == "STATUS") {
     status = true;
+    level = cmake::LogLevel::LOG_STATUS;
+    ++i;
+  } else if (*i == "VERBOSE") {
+    status = true;
+    level = cmake::LogLevel::LOG_VERBOSE;
+    ++i;
+  } else if (*i == "DEBUG") {
+    status = true;
+    level = cmake::LogLevel::LOG_DEBUG;
+    ++i;
+  } else if (*i == "TRACE") {
+    status = true;
+    level = cmake::LogLevel::LOG_TRACE;
     ++i;
   } else if (*i == "DEPRECATION") {
     if (this->Makefile->IsOn("CMAKE_ERROR_DEPRECATED")) {
       fatal = true;
       type = MessageType::DEPRECATION_ERROR;
+      level = cmake::LogLevel::LOG_ERROR;
     } else if ((!this->Makefile->IsSet("CMAKE_WARN_DEPRECATED") ||
                 this->Makefile->IsOn("CMAKE_WARN_DEPRECATED"))) {
       type = MessageType::DEPRECATION_WARNING;
+      level = cmake::LogLevel::LOG_WARNING;
     } else {
       return true;
     }
     ++i;
+  } else if (*i == "NOTICE") {
+    // `NOTICE` message type is going to be output to stderr
+    level = cmake::LogLevel::LOG_NOTICE;
+    ++i;
+  } else {
+    // Messages w/o any type are `NOTICE`s
+    level = cmake::LogLevel::LOG_NOTICE;
+  }
+  assert("Message log level expected to be set" &&
+         level != cmake::LogLevel::LOG_UNDEFINED);
+
+  auto desiredLevel = this->Makefile->GetCMakeInstance()->GetLogLevel();
+  assert("Expected a valid log level here" &&
+         desiredLevel != cmake::LogLevel::LOG_UNDEFINED);
+
+  if (desiredLevel < level) {
+    // Suppress the message
+    return true;
   }
 
-  std::string message = cmJoin(cmMakeRange(i, args.end()), std::string());
+  auto message = cmJoin(cmMakeRange(i, args.cend()), "");
 
   if (type != MessageType::MESSAGE) {
     // we've overridden the message type, above, so display it directly
diff --git a/Source/cmSystemTools.cxx b/Source/cmSystemTools.cxx
index 212608d..bc853b7 100644
--- a/Source/cmSystemTools.cxx
+++ b/Source/cmSystemTools.cxx
@@ -168,7 +168,6 @@ bool cmSystemTools::s_RunCommandHideConsole = false;
 bool cmSystemTools::s_DisableRunCommandOutput = false;
 bool cmSystemTools::s_ErrorOccured = false;
 bool cmSystemTools::s_FatalErrorOccured = false;
-bool cmSystemTools::s_DisableMessages = false;
 bool cmSystemTools::s_ForceUnixPaths = false;
 
 // replace replace with with as many times as it shows up in source.
@@ -326,14 +325,11 @@ void cmSystemTools::Stdout(const std::string& s)
 
 void cmSystemTools::Message(const std::string& m, const char* title)
 {
-  if (s_DisableMessages) {
-    return;
-  }
   if (s_MessageCallback) {
     s_MessageCallback(m, title);
-    return;
+  } else {
+    std::cerr << m << std::endl;
   }
-  std::cerr << m << std::endl << std::flush;
 }
 
 void cmSystemTools::ReportLastSystemError(const char* msg)
diff --git a/Source/cmSystemTools.h b/Source/cmSystemTools.h
index a8b2d37..05bd351 100644
--- a/Source/cmSystemTools.h
+++ b/Source/cmSystemTools.h
@@ -266,8 +266,6 @@ public:
 
   static size_t CalculateCommandLineLengthLimit();
 
-  static void EnableMessages() { s_DisableMessages = false; }
-  static void DisableMessages() { s_DisableMessages = true; }
   static void DisableRunCommandOutput() { s_DisableRunCommandOutput = true; }
   static void EnableRunCommandOutput() { s_DisableRunCommandOutput = false; }
   static bool GetRunCommandOutput() { return s_DisableRunCommandOutput; }
@@ -540,7 +538,6 @@ private:
   static bool s_RunCommandHideConsole;
   static bool s_ErrorOccured;
   static bool s_FatalErrorOccured;
-  static bool s_DisableMessages;
   static bool s_DisableRunCommandOutput;
 };
 
diff --git a/Source/cmake.cxx b/Source/cmake.cxx
index fc24ac0..121d12d 100644
--- a/Source/cmake.cxx
+++ b/Source/cmake.cxx
@@ -718,6 +718,14 @@ void cmake::SetArgs(const std::vector<std::string>& args)
     } else if (arg.find("--debug-output", 0) == 0) {
       std::cout << "Running with debug output on.\n";
       this->SetDebugOutputOn(true);
+    } else if (arg.find("--loglevel=", 0) == 0) {
+      const auto logLevel =
+        StringToLogLevel(arg.substr(sizeof("--loglevel=") - 1));
+      if (logLevel == LogLevel::LOG_UNDEFINED) {
+        cmSystemTools::Error("Invalid level specified for --loglevel");
+        return;
+      }
+      this->SetLogLevel(logLevel);
     } else if (arg.find("--trace-expand", 0) == 0) {
       std::cout << "Running with expanded trace output on.\n";
       this->SetTrace(true);
@@ -828,6 +836,25 @@ void cmake::SetArgs(const std::vector<std::string>& args)
   }
 }
 
+cmake::LogLevel cmake::StringToLogLevel(const std::string& levelStr)
+{
+  using LevelsPair = std::pair<std::string, LogLevel>;
+  static const std::vector<LevelsPair> levels = {
+    { "error", LogLevel::LOG_ERROR },     { "warning", LogLevel::LOG_WARNING },
+    { "notice", LogLevel::LOG_NOTICE },   { "status", LogLevel::LOG_STATUS },
+    { "verbose", LogLevel::LOG_VERBOSE }, { "debug", LogLevel::LOG_DEBUG },
+    { "trace", LogLevel::LOG_TRACE }
+  };
+
+  const auto levelStrLowCase = cmSystemTools::LowerCase(levelStr);
+
+  const auto it = std::find_if(levels.cbegin(), levels.cend(),
+                               [&levelStrLowCase](const LevelsPair& p) {
+                                 return p.first == levelStrLowCase;
+                               });
+  return (it != levels.cend()) ? it->second : LogLevel::LOG_UNDEFINED;
+}
+
 void cmake::SetDirectoriesFromFile(const char* arg)
 {
   // Check if the argument refers to a CMakeCache.txt or
diff --git a/Source/cmake.h b/Source/cmake.h
index 8b4b396..4a345cf 100644
--- a/Source/cmake.h
+++ b/Source/cmake.h
@@ -96,6 +96,19 @@ public:
     FIND_PACKAGE_MODE
   };
 
+  /** \brief Define log level constants. */
+  enum LogLevel
+  {
+    LOG_UNDEFINED,
+    LOG_ERROR,
+    LOG_WARNING,
+    LOG_NOTICE,
+    LOG_STATUS,
+    LOG_VERBOSE,
+    LOG_DEBUG,
+    LOG_TRACE
+  };
+
   struct GeneratorInfo
   {
     std::string name;
@@ -331,6 +344,11 @@ public:
    */
   cmFileTimeCache* GetFileTimeCache() { return this->FileTimeCache; }
 
+  // Get the selected log level for `message()` commands during the cmake run.
+  LogLevel GetLogLevel() const { return this->MessageLogLevel; }
+  void SetLogLevel(LogLevel level) { this->MessageLogLevel = level; }
+  static LogLevel StringToLogLevel(const std::string& levelStr);
+
   // Do we want debug output during the cmake run.
   bool GetDebugOutput() { return this->DebugOutput; }
   void SetDebugOutputOn(bool b) { this->DebugOutput = b; }
@@ -524,6 +542,8 @@ private:
 
   std::vector<std::string> TraceOnlyThisSources;
 
+  LogLevel MessageLogLevel = LogLevel::LOG_STATUS;
+
   void UpdateConversionPathTable();
 
   // Print a list of valid generators to stderr.
diff --git a/Source/cmakemain.cxx b/Source/cmakemain.cxx
index d70c9d9..5631d10 100644
--- a/Source/cmakemain.cxx
+++ b/Source/cmakemain.cxx
@@ -95,6 +95,8 @@ static const char* cmDocumentationOptions[][2] = {
     "Generate graphviz of dependencies, see "
     "CMakeGraphVizOptions.cmake for more." },
   { "--system-information [file]", "Dump information about this system." },
+  { "--loglevel=<error|warn|notice|status|verbose|debug|trace>",
+    "Set the verbosity of messages from CMake files." },
   { "--debug-trycompile",
     "Do not delete the try_compile build tree. Only "
     "useful on one try_compile at a time." },