Source/cmMessenger.cxx

   1 /* Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
   2    file Copyright.txt or https://cmake.org/licensing for details.  */
   3 #include "cmMessenger.h"
   4
   5 #include "cmDocumentationFormatter.h"
   6 #include "cmMessageMetadata.h"
   7 #include "cmMessageType.h"
   8 #include "cmStringAlgorithms.h"
   9 #include "cmSystemTools.h"
  10
  11 #if !defined(CMAKE_BOOTSTRAP)
  12 #  include "cmsys/SystemInformation.hxx"
  13 #endif
  14
  15 #include <sstream>
  16 #include <utility>
  17
  18 #include "cmsys/Terminal.h"
  19
  20 #ifdef CMake_ENABLE_DEBUGGER
  21 #  include "cmDebuggerAdapter.h"
  22 #endif
  23
  24 MessageType cmMessenger::ConvertMessageType(MessageType t) const
  25 {
  26   if (t == MessageType::AUTHOR_WARNING || t == MessageType::AUTHOR_ERROR) {
  27     if (this->GetDevWarningsAsErrors()) {
  28       return MessageType::AUTHOR_ERROR;
  29     }
  30     return MessageType::AUTHOR_WARNING;
  31   }
  32   if (t == MessageType::DEPRECATION_WARNING ||
  33       t == MessageType::DEPRECATION_ERROR) {
  34     if (this->GetDeprecatedWarningsAsErrors()) {
  35       return MessageType::DEPRECATION_ERROR;
  36     }
  37     return MessageType::DEPRECATION_WARNING;
  38   }
  39   return t;
  40 }
  41
  42 bool cmMessenger::IsMessageTypeVisible(MessageType t) const
  43 {
  44   if (t == MessageType::DEPRECATION_ERROR) {
  45     return this->GetDeprecatedWarningsAsErrors();
  46   }
  47   if (t == MessageType::DEPRECATION_WARNING) {
  48     return !this->GetSuppressDeprecatedWarnings();
  49   }
  50   if (t == MessageType::AUTHOR_ERROR) {
  51     return this->GetDevWarningsAsErrors();
  52   }
  53   if (t == MessageType::AUTHOR_WARNING) {
  54     return !this->GetSuppressDevWarnings();
  55   }
  56
  57   return true;
  58 }
  59
  60 static bool printMessagePreamble(MessageType t, std::ostream& msg)
  61 {
  62   // Construct the message header.
  63   if (t == MessageType::FATAL_ERROR) {
  64     msg << "CMake Error";
  65   } else if (t == MessageType::INTERNAL_ERROR) {
  66     msg << "CMake Internal Error (please report a bug)";
  67   } else if (t == MessageType::LOG) {
  68     msg << "CMake Debug Log";
  69   } else if (t == MessageType::DEPRECATION_ERROR) {
  70     msg << "CMake Deprecation Error";
  71   } else if (t == MessageType::DEPRECATION_WARNING) {
  72     msg << "CMake Deprecation Warning";
  73   } else if (t == MessageType::AUTHOR_WARNING) {
  74     msg << "CMake Warning (dev)";
  75   } else if (t == MessageType::AUTHOR_ERROR) {
  76     msg << "CMake Error (dev)";
  77   } else {
  78     msg << "CMake Warning";
  79   }
  80   return true;
  81 }
  82
  83 static int getMessageColor(MessageType t)
  84 {
  85   switch (t) {
  86     case MessageType::INTERNAL_ERROR:
  87     case MessageType::FATAL_ERROR:
  88     case MessageType::AUTHOR_ERROR:
  89       return cmsysTerminal_Color_ForegroundRed;
  90     case MessageType::AUTHOR_WARNING:
  91     case MessageType::WARNING:
  92       return cmsysTerminal_Color_ForegroundYellow;
  93     default:
  94       return cmsysTerminal_Color_Normal;
  95   }
  96 }
  97
  98 static void printMessageText(std::ostream& msg, std::string const& text)
  99 {
 100   msg << ":\n";
 101   cmDocumentationFormatter formatter;
 102   formatter.SetIndent(2u);
 103   formatter.PrintFormatted(msg, text);
 104 }
 105
 106 static void displayMessage(MessageType t, std::ostringstream& msg)
 107 {
 108   // Add a note about warning suppression.
 109   if (t == MessageType::AUTHOR_WARNING) {
 110     msg << "This warning is for project developers.  Use -Wno-dev to suppress "
 111            "it.";
 112   } else if (t == MessageType::AUTHOR_ERROR) {
 113     msg << "This error is for project developers. Use -Wno-error=dev to "
 114            "suppress it.";
 115   }
 116
 117   // Add a terminating blank line.
 118   msg << "\n";
 119
 120 #if !defined(CMAKE_BOOTSTRAP)
 121   // Add a C++ stack trace to internal errors.
 122   if (t == MessageType::INTERNAL_ERROR) {
 123     std::string stack = cmsys::SystemInformation::GetProgramStack(0, 0);
 124     if (!stack.empty()) {
 125       if (cmHasLiteralPrefix(stack, "WARNING:")) {
 126         stack = "Note:" + stack.substr(8);
 127       }
 128       msg << stack << "\n";
 129     }
 130   }
 131 #endif
 132
 133   // Output the message.
 134   cmMessageMetadata md;
 135   md.desiredColor = getMessageColor(t);
 136   if (t == MessageType::FATAL_ERROR || t == MessageType::INTERNAL_ERROR ||
 137       t == MessageType::DEPRECATION_ERROR || t == MessageType::AUTHOR_ERROR) {
 138     cmSystemTools::SetErrorOccurred();
 139     md.title = "Error";
 140     cmSystemTools::Message(msg.str(), md);
 141   } else {
 142     md.title = "Warning";
 143     cmSystemTools::Message(msg.str(), md);
 144   }
 145 }
 146
 147 namespace {
 148 void PrintCallStack(std::ostream& out, cmListFileBacktrace bt,
 149                     cm::optional<std::string> const& topSource)
 150 {
 151   // The call stack exists only if we have at least two calls on top
 152   // of the bottom.
 153   if (bt.Empty()) {
 154     return;
 155   }
 156   bt = bt.Pop();
 157   if (bt.Empty()) {
 158     return;
 159   }
 160
 161   bool first = true;
 162   for (; !bt.Empty(); bt = bt.Pop()) {
 163     cmListFileContext lfc = bt.Top();
 164     if (lfc.Name.empty() &&
 165         lfc.Line != cmListFileContext::DeferPlaceholderLine) {
 166       // Skip this whole-file scope.  When we get here we already will
 167       // have printed a more-specific context within the file.
 168       continue;
 169     }
 170     if (first) {
 171       first = false;
 172       out << "Call Stack (most recent call first):\n";
 173     }
 174     if (topSource) {
 175       lfc.FilePath = cmSystemTools::RelativeIfUnder(*topSource, lfc.FilePath);
 176     }
 177     out << "  " << lfc << "\n";
 178   }
 179 }
 180 }
 181
 182 void cmMessenger::IssueMessage(MessageType t, const std::string& text,
 183                                const cmListFileBacktrace& backtrace) const
 184 {
 185   bool force = false;
 186   // override the message type, if needed, for warnings and errors
 187   MessageType override = this->ConvertMessageType(t);
 188   if (override != t) {
 189     t = override;
 190     force = true;
 191   }
 192
 193   if (force || this->IsMessageTypeVisible(t)) {
 194     this->DisplayMessage(t, text, backtrace);
 195   }
 196 }
 197
 198 void cmMessenger::DisplayMessage(MessageType t, const std::string& text,
 199                                  const cmListFileBacktrace& backtrace) const
 200 {
 201   std::ostringstream msg;
 202   if (!printMessagePreamble(t, msg)) {
 203     return;
 204   }
 205
 206   // Add the immediate context.
 207   this->PrintBacktraceTitle(msg, backtrace);
 208
 209   printMessageText(msg, text);
 210
 211   // Add the rest of the context.
 212   PrintCallStack(msg, backtrace, this->TopSource);
 213
 214   displayMessage(t, msg);
 215
 216 #ifdef CMake_ENABLE_DEBUGGER
 217   if (DebuggerAdapter != nullptr) {
 218     DebuggerAdapter->OnMessageOutput(t, msg.str());
 219   }
 220 #endif
 221 }
 222
 223 void cmMessenger::PrintBacktraceTitle(std::ostream& out,
 224                                       cmListFileBacktrace const& bt) const
 225 {
 226   // The title exists only if we have a call on top of the bottom.
 227   if (bt.Empty()) {
 228     return;
 229   }
 230   cmListFileContext lfc = bt.Top();
 231   if (this->TopSource) {
 232     lfc.FilePath =
 233       cmSystemTools::RelativeIfUnder(*this->TopSource, lfc.FilePath);
 234   }
 235   out << (lfc.Line ? " at " : " in ") << lfc;
 236 }
 237
 238 void cmMessenger::SetTopSource(cm::optional<std::string> topSource)
 239 {
 240   this->TopSource = std::move(topSource);
 241 }