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