1 //===-- CommandReturnObject.cpp ---------------------------------*- C++ -*-===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "lldb/Interpreter/CommandReturnObject.h"
11 
12 // C Includes
13 // C++ Includes
14 // Other libraries and framework includes
15 // Project includes
16 #include "lldb/Core/Error.h"
17 #include "lldb/Core/StreamString.h"
18 
19 using namespace lldb;
20 using namespace lldb_private;
21 
22 static void DumpStringToStreamWithNewline(Stream &strm, const std::string &s,
23                                           bool add_newline_if_empty) {
24   bool add_newline = false;
25   if (s.empty()) {
26     add_newline = add_newline_if_empty;
27   } else {
28     // We already checked for empty above, now make sure there is a newline
29     // in the error, and if there isn't one, add one.
30     strm.Write(s.c_str(), s.size());
31 
32     const char last_char = *s.rbegin();
33     add_newline = last_char != '\n' && last_char != '\r';
34   }
35   if (add_newline)
36     strm.EOL();
37 }
38 
39 CommandReturnObject::CommandReturnObject()
40     : m_out_stream(), m_err_stream(), m_status(eReturnStatusStarted),
41       m_did_change_process_state(false), m_interactive(true),
42       m_abnormal_stop_was_expected(false) {}
43 
44 CommandReturnObject::~CommandReturnObject() {}
45 
46 void CommandReturnObject::AppendErrorWithFormat(const char *format, ...) {
47   if (!format)
48     return;
49   va_list args;
50   va_start(args, format);
51   StreamString sstrm;
52   sstrm.PrintfVarArg(format, args);
53   va_end(args);
54 
55   const std::string &s = sstrm.GetString();
56   if (!s.empty()) {
57     Stream &error_strm = GetErrorStream();
58     error_strm.PutCString("error: ");
59     DumpStringToStreamWithNewline(error_strm, s, false);
60   }
61 }
62 
63 void CommandReturnObject::AppendMessageWithFormat(const char *format, ...) {
64   if (!format)
65     return;
66   va_list args;
67   va_start(args, format);
68   StreamString sstrm;
69   sstrm.PrintfVarArg(format, args);
70   va_end(args);
71 
72   GetOutputStream() << sstrm.GetString();
73 }
74 
75 void CommandReturnObject::AppendWarningWithFormat(const char *format, ...) {
76   if (!format)
77     return;
78   va_list args;
79   va_start(args, format);
80   StreamString sstrm;
81   sstrm.PrintfVarArg(format, args);
82   va_end(args);
83 
84   GetErrorStream() << "warning: " << sstrm.GetString();
85 }
86 
87 void CommandReturnObject::AppendMessage(llvm::StringRef in_string) {
88   if (in_string.empty())
89     return;
90   GetOutputStream() << in_string << "\n";
91 }
92 
93 void CommandReturnObject::AppendWarning(llvm::StringRef in_string) {
94   if (in_string.empty())
95     return;
96   GetErrorStream() << "warning: " << in_string << "\n";
97 }
98 
99 // Similar to AppendWarning, but do not prepend 'warning: ' to message, and
100 // don't append "\n" to the end of it.
101 
102 void CommandReturnObject::AppendRawWarning(llvm::StringRef in_string) {
103   if (in_string.empty())
104     return;
105   GetErrorStream() << in_string;
106 }
107 
108 void CommandReturnObject::AppendError(llvm::StringRef in_string) {
109   if (in_string.empty())
110     return;
111   GetErrorStream() << "error: " << in_string << "\n";
112 }
113 
114 void CommandReturnObject::SetError(const Error &error,
115                                    const char *fallback_error_cstr) {
116   const char *error_cstr = error.AsCString();
117   if (error_cstr == nullptr)
118     error_cstr = fallback_error_cstr;
119   SetError(error_cstr);
120 }
121 
122 void CommandReturnObject::SetError(llvm::StringRef error_str) {
123   if (error_str.empty())
124     return;
125 
126   AppendError(error_str);
127   SetStatus(eReturnStatusFailed);
128 }
129 
130 // Similar to AppendError, but do not prepend 'Error: ' to message, and
131 // don't append "\n" to the end of it.
132 
133 void CommandReturnObject::AppendRawError(llvm::StringRef in_string) {
134   if (in_string.empty())
135     return;
136   GetErrorStream() << in_string;
137 }
138 
139 void CommandReturnObject::SetStatus(ReturnStatus status) { m_status = status; }
140 
141 ReturnStatus CommandReturnObject::GetStatus() { return m_status; }
142 
143 bool CommandReturnObject::Succeeded() {
144   return m_status <= eReturnStatusSuccessContinuingResult;
145 }
146 
147 bool CommandReturnObject::HasResult() {
148   return (m_status == eReturnStatusSuccessFinishResult ||
149           m_status == eReturnStatusSuccessContinuingResult);
150 }
151 
152 void CommandReturnObject::Clear() {
153   lldb::StreamSP stream_sp;
154   stream_sp = m_out_stream.GetStreamAtIndex(eStreamStringIndex);
155   if (stream_sp)
156     static_cast<StreamString *>(stream_sp.get())->Clear();
157   stream_sp = m_err_stream.GetStreamAtIndex(eStreamStringIndex);
158   if (stream_sp)
159     static_cast<StreamString *>(stream_sp.get())->Clear();
160   m_status = eReturnStatusStarted;
161   m_did_change_process_state = false;
162   m_interactive = true;
163 }
164 
165 bool CommandReturnObject::GetDidChangeProcessState() {
166   return m_did_change_process_state;
167 }
168 
169 void CommandReturnObject::SetDidChangeProcessState(bool b) {
170   m_did_change_process_state = b;
171 }
172 
173 bool CommandReturnObject::GetInteractive() const { return m_interactive; }
174 
175 void CommandReturnObject::SetInteractive(bool b) { m_interactive = b; }
176