lldb/source/Interpreter/CommandReturnObject.cpp

   1 //===-- CommandReturnObject.cpp -------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Interpreter/CommandReturnObject.h"
  10
  11 #include "lldb/Utility/DiagnosticsRendering.h"
  12 #include "lldb/Utility/Status.h"
  13 #include "lldb/Utility/StreamString.h"
  14
  15 using namespace lldb;
  16 using namespace lldb_private;
  17
  18 static llvm::raw_ostream &error(Stream &strm) {
  19   return llvm::WithColor(strm.AsRawOstream(), llvm::HighlightColor::Error,
  20                          llvm::ColorMode::Enable)
  21          << "error: ";
  22 }
  23
  24 static llvm::raw_ostream &warning(Stream &strm) {
  25   return llvm::WithColor(strm.AsRawOstream(), llvm::HighlightColor::Warning,
  26                          llvm::ColorMode::Enable)
  27          << "warning: ";
  28 }
  29
  30 static llvm::raw_ostream &note(Stream &strm) {
  31   return llvm::WithColor(strm.AsRawOstream(), llvm::HighlightColor::Note,
  32                          llvm::ColorMode::Enable)
  33          << "note: ";
  34 }
  35
  36 static void DumpStringToStreamWithNewline(Stream &strm, const std::string &s) {
  37   bool add_newline = false;
  38   if (!s.empty()) {
  39     // We already checked for empty above, now make sure there is a newline in
  40     // the error, and if there isn't one, add one.
  41     strm.Write(s.c_str(), s.size());
  42
  43     const char last_char = *s.rbegin();
  44     add_newline = last_char != '\n' && last_char != '\r';
  45   }
  46   if (add_newline)
  47     strm.EOL();
  48 }
  49
  50 CommandReturnObject::CommandReturnObject(bool colors)
  51     : m_out_stream(colors), m_err_stream(colors), m_colors(colors) {}
  52
  53 void CommandReturnObject::AppendErrorWithFormat(const char *format, ...) {
  54   SetStatus(eReturnStatusFailed);
  55
  56   if (!format)
  57     return;
  58   va_list args;
  59   va_start(args, format);
  60   StreamString sstrm;
  61   sstrm.PrintfVarArg(format, args);
  62   va_end(args);
  63
  64   const std::string &s = std::string(sstrm.GetString());
  65   if (!s.empty()) {
  66     error(GetErrorStream());
  67     DumpStringToStreamWithNewline(GetErrorStream(), s);
  68   }
  69 }
  70
  71 void CommandReturnObject::AppendMessageWithFormat(const char *format, ...) {
  72   if (!format)
  73     return;
  74   va_list args;
  75   va_start(args, format);
  76   StreamString sstrm;
  77   sstrm.PrintfVarArg(format, args);
  78   va_end(args);
  79
  80   GetOutputStream() << sstrm.GetString();
  81 }
  82
  83 void CommandReturnObject::AppendNoteWithFormat(const char *format, ...) {
  84   if (!format)
  85     return;
  86   va_list args;
  87   va_start(args, format);
  88   StreamString sstrm;
  89   sstrm.PrintfVarArg(format, args);
  90   va_end(args);
  91
  92   note(GetOutputStream()) << sstrm.GetString();
  93 }
  94
  95 void CommandReturnObject::AppendWarningWithFormat(const char *format, ...) {
  96   if (!format)
  97     return;
  98   va_list args;
  99   va_start(args, format);
 100   StreamString sstrm;
 101   sstrm.PrintfVarArg(format, args);
 102   va_end(args);
 103
 104   warning(GetErrorStream()) << sstrm.GetString();
 105 }
 106
 107 void CommandReturnObject::AppendMessage(llvm::StringRef in_string) {
 108   if (in_string.empty())
 109     return;
 110   GetOutputStream() << in_string.rtrim() << '\n';
 111 }
 112
 113 void CommandReturnObject::AppendNote(llvm::StringRef in_string) {
 114   if (in_string.empty())
 115     return;
 116   note(GetOutputStream()) << in_string.rtrim() << '\n';
 117 }
 118
 119 void CommandReturnObject::AppendWarning(llvm::StringRef in_string) {
 120   if (in_string.empty())
 121     return;
 122   warning(GetErrorStream()) << in_string.rtrim() << '\n';
 123 }
 124
 125 void CommandReturnObject::AppendError(llvm::StringRef in_string) {
 126   SetStatus(eReturnStatusFailed);
 127   if (in_string.empty())
 128     return;
 129   // Workaround to deal with already fully formatted compiler diagnostics.
 130   llvm::StringRef msg(in_string.rtrim());
 131   msg.consume_front("error: ");
 132   error(GetErrorStream()) << msg << '\n';
 133 }
 134
 135 void CommandReturnObject::SetError(Status error) {
 136   SetError(error.takeError());
 137 }
 138
 139 void CommandReturnObject::SetError(llvm::Error error) {
 140   // Retrieve any diagnostics.
 141   error = llvm::handleErrors(std::move(error), [&](DiagnosticError &error) {
 142     SetStatus(eReturnStatusFailed);
 143     m_diagnostics = error.GetDetails();
 144   });
 145   if (error) {
 146     AppendError(llvm::toString(std::move(error)));
 147   }
 148 }
 149
 150 std::string CommandReturnObject::GetInlineDiagnosticString(unsigned indent) {
 151   StreamString diag_stream(m_colors);
 152   RenderDiagnosticDetails(diag_stream, indent, true, m_diagnostics);
 153   // Duplex the diagnostics to the secondary stream (but not inlined).
 154   if (auto stream_sp = m_err_stream.GetStreamAtIndex(eImmediateStreamIndex))
 155     RenderDiagnosticDetails(*stream_sp, std::nullopt, false, m_diagnostics);
 156
 157   return diag_stream.GetString().str();
 158 }
 159
 160 std::string CommandReturnObject::GetErrorString(bool with_diagnostics) {
 161   StreamString stream(m_colors);
 162   if (with_diagnostics)
 163     RenderDiagnosticDetails(stream, std::nullopt, false, m_diagnostics);
 164
 165   lldb::StreamSP stream_sp(m_err_stream.GetStreamAtIndex(eStreamStringIndex));
 166   if (stream_sp)
 167     stream << std::static_pointer_cast<StreamString>(stream_sp)->GetString();
 168   return stream.GetString().str();
 169 }
 170
 171 StructuredData::ObjectSP CommandReturnObject::GetErrorData() {
 172   auto make_array = []() { return std::make_unique<StructuredData::Array>(); };
 173   auto make_bool = [](bool b) {
 174     return std::make_unique<StructuredData::Boolean>(b);
 175   };
 176   auto make_dict = []() {
 177     return std::make_unique<StructuredData::Dictionary>();
 178   };
 179   auto make_int = [](unsigned i) {
 180     return std::make_unique<StructuredData::UnsignedInteger>(i);
 181   };
 182   auto make_string = [](llvm::StringRef s) {
 183     return std::make_unique<StructuredData::String>(s);
 184   };
 185   auto dict_up = make_dict();
 186   dict_up->AddItem("version", make_int(1));
 187   auto array_up = make_array();
 188   for (const DiagnosticDetail &diag : m_diagnostics) {
 189     auto detail_up = make_dict();
 190     if (auto &sloc = diag.source_location) {
 191       auto sloc_up = make_dict();
 192       sloc_up->AddItem("file", make_string(sloc->file.GetPath()));
 193       sloc_up->AddItem("line", make_int(sloc->line));
 194       sloc_up->AddItem("length", make_int(sloc->length));
 195       sloc_up->AddItem("hidden", make_bool(sloc->hidden));
 196       sloc_up->AddItem("in_user_input", make_bool(sloc->in_user_input));
 197       detail_up->AddItem("source_location", std::move(sloc_up));
 198     }
 199     llvm::StringRef severity = "unknown";
 200     switch (diag.severity) {
 201     case lldb::eSeverityError:
 202       severity = "error";
 203       break;
 204     case lldb::eSeverityWarning:
 205       severity = "warning";
 206       break;
 207     case lldb::eSeverityInfo:
 208       severity = "note";
 209       break;
 210     }
 211     detail_up->AddItem("severity", make_string(severity));
 212     detail_up->AddItem("message", make_string(diag.message));
 213     detail_up->AddItem("rendered", make_string(diag.rendered));
 214     array_up->AddItem(std::move(detail_up));
 215   }
 216   dict_up->AddItem("details", std::move(array_up));
 217   if (auto stream_sp = m_err_stream.GetStreamAtIndex(eStreamStringIndex)) {
 218     auto text = std::static_pointer_cast<StreamString>(stream_sp)->GetString();
 219     if (!text.empty())
 220       dict_up->AddItem("text", make_string(text));
 221   }
 222   return dict_up;
 223 }
 224
 225 // Similar to AppendError, but do not prepend 'Status: ' to message, and don't
 226 // append "\n" to the end of it.
 227
 228 void CommandReturnObject::AppendRawError(llvm::StringRef in_string) {
 229   SetStatus(eReturnStatusFailed);
 230   assert(!in_string.empty() && "Expected a non-empty error message");
 231   GetErrorStream() << in_string;
 232 }
 233
 234 void CommandReturnObject::SetStatus(ReturnStatus status) { m_status = status; }
 235
 236 ReturnStatus CommandReturnObject::GetStatus() const { return m_status; }
 237
 238 bool CommandReturnObject::Succeeded() const {
 239   return m_status <= eReturnStatusSuccessContinuingResult;
 240 }
 241
 242 bool CommandReturnObject::HasResult() const {
 243   return (m_status == eReturnStatusSuccessFinishResult ||
 244           m_status == eReturnStatusSuccessContinuingResult);
 245 }
 246
 247 void CommandReturnObject::Clear() {
 248   lldb::StreamSP stream_sp;
 249   stream_sp = m_out_stream.GetStreamAtIndex(eStreamStringIndex);
 250   if (stream_sp)
 251     static_cast<StreamString *>(stream_sp.get())->Clear();
 252   stream_sp = m_err_stream.GetStreamAtIndex(eStreamStringIndex);
 253   if (stream_sp)
 254     static_cast<StreamString *>(stream_sp.get())->Clear();
 255   m_diagnostics.clear();
 256   m_status = eReturnStatusStarted;
 257   m_did_change_process_state = false;
 258   m_suppress_immediate_output = false;
 259   m_interactive = true;
 260 }
 261
 262 bool CommandReturnObject::GetDidChangeProcessState() const {
 263   return m_did_change_process_state;
 264 }
 265
 266 void CommandReturnObject::SetDidChangeProcessState(bool b) {
 267   m_did_change_process_state = b;
 268 }
 269
 270 bool CommandReturnObject::GetInteractive() const { return m_interactive; }
 271
 272 void CommandReturnObject::SetInteractive(bool b) { m_interactive = b; }
 273
 274 bool CommandReturnObject::GetSuppressImmediateOutput() const {
 275   return m_suppress_immediate_output;
 276 }
 277
 278 void CommandReturnObject::SetSuppressImmediateOutput(bool b) {
 279   m_suppress_immediate_output = b;
 280 }