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/Status.h"
12#include "lldb/Utility/StreamString.h"
13
14using namespace lldb;
15using namespace lldb_private;
16
17static llvm::raw_ostream &error(Stream &strm) {
18  return llvm::WithColor(strm.AsRawOstream(), llvm::HighlightColor::Error,
19                         llvm::ColorMode::Enable)
20         << "error: ";
21}
22
23static llvm::raw_ostream &warning(Stream &strm) {
24  return llvm::WithColor(strm.AsRawOstream(), llvm::HighlightColor::Warning,
25                         llvm::ColorMode::Enable)
26         << "warning: ";
27}
28
29static void DumpStringToStreamWithNewline(Stream &strm, const std::string &s) {
30  bool add_newline = false;
31  if (!s.empty()) {
32    // We already checked for empty above, now make sure there is a newline in
33    // the error, and if there isn't one, add one.
34    strm.Write(s.c_str(), s.size());
35
36    const char last_char = *s.rbegin();
37    add_newline = last_char != '\n' && last_char != '\r';
38  }
39  if (add_newline)
40    strm.EOL();
41}
42
43CommandReturnObject::CommandReturnObject(bool colors)
44    : m_out_stream(colors), m_err_stream(colors) {}
45
46void CommandReturnObject::AppendErrorWithFormat(const char *format, ...) {
47  SetStatus(eReturnStatusFailed);
48
49  if (!format)
50    return;
51  va_list args;
52  va_start(args, format);
53  StreamString sstrm;
54  sstrm.PrintfVarArg(format, args);
55  va_end(args);
56
57  const std::string &s = std::string(sstrm.GetString());
58  if (!s.empty()) {
59    error(GetErrorStream());
60    DumpStringToStreamWithNewline(GetErrorStream(), s);
61  }
62}
63
64void CommandReturnObject::AppendMessageWithFormat(const char *format, ...) {
65  if (!format)
66    return;
67  va_list args;
68  va_start(args, format);
69  StreamString sstrm;
70  sstrm.PrintfVarArg(format, args);
71  va_end(args);
72
73  GetOutputStream() << sstrm.GetString();
74}
75
76void CommandReturnObject::AppendWarningWithFormat(const char *format, ...) {
77  if (!format)
78    return;
79  va_list args;
80  va_start(args, format);
81  StreamString sstrm;
82  sstrm.PrintfVarArg(format, args);
83  va_end(args);
84
85  warning(GetErrorStream()) << sstrm.GetString();
86}
87
88void CommandReturnObject::AppendMessage(llvm::StringRef in_string) {
89  if (in_string.empty())
90    return;
91  GetOutputStream() << in_string.rtrim() << '\n';
92}
93
94void CommandReturnObject::AppendWarning(llvm::StringRef in_string) {
95  if (in_string.empty())
96    return;
97  warning(GetErrorStream()) << in_string.rtrim() << '\n';
98}
99
100void CommandReturnObject::AppendError(llvm::StringRef in_string) {
101  SetStatus(eReturnStatusFailed);
102  if (in_string.empty())
103    return;
104  // Workaround to deal with already fully formatted compiler diagnostics.
105  llvm::StringRef msg(in_string.rtrim());
106  msg.consume_front("error: ");
107  error(GetErrorStream()) << msg << '\n';
108}
109
110void CommandReturnObject::SetError(const Status &error,
111                                   const char *fallback_error_cstr) {
112  if (error.Fail())
113    AppendError(error.AsCString(fallback_error_cstr));
114}
115
116void CommandReturnObject::SetError(llvm::Error error) {
117  if (error)
118    AppendError(llvm::toString(std::move(error)));
119}
120
121// Similar to AppendError, but do not prepend 'Status: ' to message, and don't
122// append "\n" to the end of it.
123
124void CommandReturnObject::AppendRawError(llvm::StringRef in_string) {
125  SetStatus(eReturnStatusFailed);
126  assert(!in_string.empty() && "Expected a non-empty error message");
127  GetErrorStream() << in_string;
128}
129
130void CommandReturnObject::SetStatus(ReturnStatus status) { m_status = status; }
131
132ReturnStatus CommandReturnObject::GetStatus() const { return m_status; }
133
134bool CommandReturnObject::Succeeded() const {
135  return m_status <= eReturnStatusSuccessContinuingResult;
136}
137
138bool CommandReturnObject::HasResult() const {
139  return (m_status == eReturnStatusSuccessFinishResult ||
140          m_status == eReturnStatusSuccessContinuingResult);
141}
142
143void CommandReturnObject::Clear() {
144  lldb::StreamSP stream_sp;
145  stream_sp = m_out_stream.GetStreamAtIndex(eStreamStringIndex);
146  if (stream_sp)
147    static_cast<StreamString *>(stream_sp.get())->Clear();
148  stream_sp = m_err_stream.GetStreamAtIndex(eStreamStringIndex);
149  if (stream_sp)
150    static_cast<StreamString *>(stream_sp.get())->Clear();
151  m_status = eReturnStatusStarted;
152  m_did_change_process_state = false;
153  m_suppress_immediate_output = false;
154  m_interactive = true;
155}
156
157bool CommandReturnObject::GetDidChangeProcessState() const {
158  return m_did_change_process_state;
159}
160
161void CommandReturnObject::SetDidChangeProcessState(bool b) {
162  m_did_change_process_state = b;
163}
164
165bool CommandReturnObject::GetInteractive() const { return m_interactive; }
166
167void CommandReturnObject::SetInteractive(bool b) { m_interactive = b; }
168
169bool CommandReturnObject::GetSuppressImmediateOutput() const {
170  return m_suppress_immediate_output;
171}
172
173void CommandReturnObject::SetSuppressImmediateOutput(bool b) {
174  m_suppress_immediate_output = b;
175}
176