LLDB mainline
CommandReturnObject.cpp
Go to the documentation of this file.
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
10
11#include "lldb/Utility/Status.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
44 : m_out_stream(colors), m_err_stream(colors) {}
45
46void CommandReturnObject::AppendErrorWithFormat(const char *format, ...) {
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()) {
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) {
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
111 const char *fallback_error_cstr) {
112 if (error.Fail())
113 AppendError(error.AsCString(fallback_error_cstr));
114}
115
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) {
126 assert(!in_string.empty() && "Expected a non-empty error message");
127 GetErrorStream() << in_string;
128}
129
131
133
136}
137
141}
142
144 lldb::StreamSP stream_sp;
146 if (stream_sp)
147 static_cast<StreamString *>(stream_sp.get())->Clear();
149 if (stream_sp)
150 static_cast<StreamString *>(stream_sp.get())->Clear();
154 m_interactive = true;
155}
156
159}
160
163}
164
166
168
171}
172
175}
static llvm::raw_ostream & error(Stream &strm)
static llvm::raw_ostream & warning(Stream &strm)
static void DumpStringToStreamWithNewline(Stream &strm, const std::string &s)
void AppendMessage(llvm::StringRef in_string)
void void AppendError(llvm::StringRef in_string)
void AppendWarningWithFormat(const char *format,...) __attribute__((format(printf
bool m_interactive
If true, then the input handle from the debugger will be hooked up.
void AppendRawError(llvm::StringRef in_string)
void SetStatus(lldb::ReturnStatus status)
void AppendErrorWithFormat(const char *format,...) __attribute__((format(printf
void AppendMessageWithFormat(const char *format,...) __attribute__((format(printf
lldb::ReturnStatus GetStatus() const
void void AppendWarning(llvm::StringRef in_string)
void SetError(const Status &error, const char *fallback_error_cstr=nullptr)
An error handling class.
Definition: Status.h:44
llvm::StringRef GetString() const
lldb::StreamSP GetStreamAtIndex(uint32_t idx)
Definition: StreamTee.h:88
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
size_t Write(const void *src, size_t src_len)
Output character bytes to the stream.
Definition: Stream.h:112
llvm::raw_ostream & AsRawOstream()
Returns a raw_ostream that forwards the data to this Stream object.
Definition: Stream.h:401
size_t size_t PrintfVarArg(const char *format, va_list args)
Definition: Stream.cpp:143
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:155
A class that represents a running process on the host machine.
Definition: SBAddress.h:15
std::shared_ptr< lldb_private::Stream > StreamSP
Definition: lldb-forward.h:426
ReturnStatus
Command Return Status Types.
@ eReturnStatusStarted
@ eReturnStatusSuccessContinuingResult
@ eReturnStatusFailed
@ eReturnStatusSuccessFinishResult