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 
14 using namespace lldb;
15 using namespace lldb_private;
16 
17 static llvm::raw_ostream &error(Stream &strm) {
18   return llvm::WithColor(strm.AsRawOstream(), llvm::HighlightColor::Error,
19                          llvm::ColorMode::Enable)
20          << "error: ";
21 }
22 
23 static llvm::raw_ostream &warning(Stream &strm) {
24   return llvm::WithColor(strm.AsRawOstream(), llvm::HighlightColor::Warning,
25                          llvm::ColorMode::Enable)
26          << "warning: ";
27 }
28 
29 static 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 
43 CommandReturnObject::CommandReturnObject(bool colors)
44     : m_out_stream(colors), m_err_stream(colors) {}
45 
46 void 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 
64 void 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 
76 void 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 
88 void CommandReturnObject::AppendMessage(llvm::StringRef in_string) {
89   if (in_string.empty())
90     return;
91   GetOutputStream() << in_string.rtrim() << '\n';
92 }
93 
94 void CommandReturnObject::AppendWarning(llvm::StringRef in_string) {
95   if (in_string.empty())
96     return;
97   warning(GetErrorStream()) << in_string.rtrim() << '\n';
98 }
99 
100 void CommandReturnObject::AppendError(llvm::StringRef in_string) {
101   SetStatus(eReturnStatusFailed);
102   if (in_string.empty())
103     return;
104   error(GetErrorStream()) << in_string.rtrim() << '\n';
105 }
106 
107 void CommandReturnObject::SetError(const Status &error,
108                                    const char *fallback_error_cstr) {
109   if (error.Fail())
110     AppendError(error.AsCString(fallback_error_cstr));
111 }
112 
113 void CommandReturnObject::SetError(llvm::Error error) {
114   if (error)
115     AppendError(llvm::toString(std::move(error)));
116 }
117 
118 // Similar to AppendError, but do not prepend 'Status: ' to message, and don't
119 // append "\n" to the end of it.
120 
121 void CommandReturnObject::AppendRawError(llvm::StringRef in_string) {
122   SetStatus(eReturnStatusFailed);
123   assert(!in_string.empty() && "Expected a non-empty error message");
124   GetErrorStream() << in_string;
125 }
126 
127 void CommandReturnObject::SetStatus(ReturnStatus status) { m_status = status; }
128 
129 ReturnStatus CommandReturnObject::GetStatus() const { return m_status; }
130 
131 bool CommandReturnObject::Succeeded() const {
132   return m_status <= eReturnStatusSuccessContinuingResult;
133 }
134 
135 bool CommandReturnObject::HasResult() const {
136   return (m_status == eReturnStatusSuccessFinishResult ||
137           m_status == eReturnStatusSuccessContinuingResult);
138 }
139 
140 void CommandReturnObject::Clear() {
141   lldb::StreamSP stream_sp;
142   stream_sp = m_out_stream.GetStreamAtIndex(eStreamStringIndex);
143   if (stream_sp)
144     static_cast<StreamString *>(stream_sp.get())->Clear();
145   stream_sp = m_err_stream.GetStreamAtIndex(eStreamStringIndex);
146   if (stream_sp)
147     static_cast<StreamString *>(stream_sp.get())->Clear();
148   m_status = eReturnStatusStarted;
149   m_did_change_process_state = false;
150   m_suppress_immediate_output = false;
151   m_interactive = true;
152 }
153 
154 bool CommandReturnObject::GetDidChangeProcessState() const {
155   return m_did_change_process_state;
156 }
157 
158 void CommandReturnObject::SetDidChangeProcessState(bool b) {
159   m_did_change_process_state = b;
160 }
161 
162 bool CommandReturnObject::GetInteractive() const { return m_interactive; }
163 
164 void CommandReturnObject::SetInteractive(bool b) { m_interactive = b; }
165 
166 bool CommandReturnObject::GetSuppressImmediateOutput() const {
167   return m_suppress_immediate_output;
168 }
169 
170 void CommandReturnObject::SetSuppressImmediateOutput(bool b) {
171   m_suppress_immediate_output = b;
172 }
173