LLDB mainline
IOHandler.cpp
Go to the documentation of this file.
1//===-- IOHandler.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#if defined(__APPLE__)
12#include <deque>
13#endif
14#include <string>
15
16#include "lldb/Core/Debugger.h"
18#include "lldb/Host/Config.h"
19#include "lldb/Host/File.h"
22#include "lldb/Utility/Status.h"
25#include "lldb/lldb-forward.h"
26
27#if LLDB_ENABLE_LIBEDIT
28#include "lldb/Host/Editline.h"
29#endif
32#include "llvm/ADT/StringRef.h"
33
34#ifdef _WIN32
36#endif
37
38#include <memory>
39#include <mutex>
40#include <optional>
41
42#include <cassert>
43#include <cctype>
44#include <cerrno>
45#include <clocale>
46#include <cstdint>
47#include <cstdio>
48#include <cstring>
49#include <type_traits>
50
51using namespace lldb;
52using namespace lldb_private;
53using llvm::StringRef;
54
56 : IOHandler(debugger, type,
57 FileSP(), // Adopt STDIN from top input reader
58 StreamFileSP(), // Adopt STDOUT from top input reader
59 StreamFileSP(), // Adopt STDERR from top input reader
60 0 // Flags
61
62 ) {}
63
65 const lldb::FileSP &input_sp,
66 const lldb::StreamFileSP &output_sp,
67 const lldb::StreamFileSP &error_sp, uint32_t flags)
68 : m_debugger(debugger), m_input_sp(input_sp), m_output_sp(output_sp),
69 m_error_sp(error_sp), m_popped(false), m_flags(flags), m_type(type),
70 m_user_data(nullptr), m_done(false), m_active(false) {
71 // If any files are not specified, then adopt them from the top input reader.
75}
76
77IOHandler::~IOHandler() = default;
78
80 return (m_input_sp ? m_input_sp->GetDescriptor() : -1);
81}
82
84 return (m_output_sp ? m_output_sp->GetFile().GetDescriptor() : -1);
85}
86
88 return (m_error_sp ? m_error_sp->GetFile().GetDescriptor() : -1);
89}
90
92 return (m_input_sp ? m_input_sp->GetStream() : nullptr);
93}
94
96 return (m_output_sp ? m_output_sp->GetFile().GetStream() : nullptr);
97}
98
100 return (m_error_sp ? m_error_sp->GetFile().GetStream() : nullptr);
101}
102
104
106
108
110 return GetInputFileSP() ? GetInputFileSP()->GetIsInteractive() : false;
111}
112
114 return GetInputFileSP() ? GetInputFileSP()->GetIsRealTerminal() : false;
115}
116
118
120
121void IOHandler::PrintAsync(const char *s, size_t len, bool is_stdout) {
122 std::lock_guard<std::recursive_mutex> guard(m_output_mutex);
123 lldb::StreamFileSP stream = is_stdout ? m_output_sp : m_error_sp;
124 stream->Write(s, len);
125 stream->Flush();
126}
127
128bool IOHandlerStack::PrintAsync(const char *s, size_t len, bool is_stdout) {
129 std::lock_guard<std::recursive_mutex> guard(m_mutex);
130 if (!m_top)
131 return false;
132 m_top->PrintAsync(s, len, is_stdout);
133 return true;
134}
135
136IOHandlerConfirm::IOHandlerConfirm(Debugger &debugger, llvm::StringRef prompt,
137 bool default_response)
139 debugger, IOHandler::Type::Confirm,
140 nullptr, // nullptr editline_name means no history loaded/saved
141 llvm::StringRef(), // No prompt
142 llvm::StringRef(), // No continuation prompt
143 false, // Multi-line
144 false, // Don't colorize the prompt (i.e. the confirm message.)
145 0, *this),
146 m_default_response(default_response), m_user_response(default_response) {
147 StreamString prompt_stream;
148 prompt_stream.PutCString(prompt);
150 prompt_stream.Printf(": [Y/n] ");
151 else
152 prompt_stream.Printf(": [y/N] ");
153
154 SetPrompt(prompt_stream.GetString());
155}
156
158
160 CompletionRequest &request) {
161 if (request.GetRawCursorPos() != 0)
162 return;
163 request.AddCompletion(m_default_response ? "y" : "n");
164}
165
167 std::string &line) {
168 if (line.empty()) {
169 // User just hit enter, set the response to the default
171 io_handler.SetIsDone(true);
172 return;
173 }
174
175 if (line.size() == 1) {
176 switch (line[0]) {
177 case 'y':
178 case 'Y':
179 m_user_response = true;
180 io_handler.SetIsDone(true);
181 return;
182 case 'n':
183 case 'N':
184 m_user_response = false;
185 io_handler.SetIsDone(true);
186 return;
187 default:
188 break;
189 }
190 }
191
192 if (line == "yes" || line == "YES" || line == "Yes") {
193 m_user_response = true;
194 io_handler.SetIsDone(true);
195 } else if (line == "no" || line == "NO" || line == "No") {
196 m_user_response = false;
197 io_handler.SetIsDone(true);
198 }
199}
200
201std::optional<std::string>
203 llvm::StringRef line) {
204 return io_handler.GetDebugger()
207}
208
210 CompletionRequest &request) {
211 switch (m_completion) {
212 case Completion::None:
213 break;
215 io_handler.GetDebugger().GetCommandInterpreter().HandleCompletion(request);
216 break;
219 io_handler.GetDebugger().GetCommandInterpreter(),
221 break;
222 }
223}
224
226 Debugger &debugger, IOHandler::Type type,
227 const char *editline_name, // Used for saving history files
228 llvm::StringRef prompt, llvm::StringRef continuation_prompt,
229 bool multi_line, bool color_prompts, uint32_t line_number_start,
230 IOHandlerDelegate &delegate)
231 : IOHandlerEditline(debugger, type,
232 FileSP(), // Inherit input from top input reader
233 StreamFileSP(), // Inherit output from top input reader
234 StreamFileSP(), // Inherit error from top input reader
235 0, // Flags
236 editline_name, // Used for saving history files
237 prompt, continuation_prompt, multi_line, color_prompts,
238 line_number_start, delegate) {}
239
241 Debugger &debugger, IOHandler::Type type, const lldb::FileSP &input_sp,
242 const lldb::StreamFileSP &output_sp, const lldb::StreamFileSP &error_sp,
243 uint32_t flags,
244 const char *editline_name, // Used for saving history files
245 llvm::StringRef prompt, llvm::StringRef continuation_prompt,
246 bool multi_line, bool color_prompts, uint32_t line_number_start,
247 IOHandlerDelegate &delegate)
248 : IOHandler(debugger, type, input_sp, output_sp, error_sp, flags),
249#if LLDB_ENABLE_LIBEDIT
250 m_editline_up(),
251#endif
252 m_delegate(delegate), m_prompt(), m_continuation_prompt(),
253 m_current_lines_ptr(nullptr), m_base_line_number(line_number_start),
254 m_curr_line_idx(UINT32_MAX), m_multi_line(multi_line),
255 m_color_prompts(color_prompts), m_interrupt_exits(true) {
256 SetPrompt(prompt);
257
258#if LLDB_ENABLE_LIBEDIT
259 bool use_editline = false;
260
261 use_editline = GetInputFILE() && GetOutputFILE() && GetErrorFILE() &&
262 m_input_sp && m_input_sp->GetIsRealTerminal();
263
264 if (use_editline) {
265 m_editline_up = std::make_unique<Editline>(
266 editline_name, GetInputFILE(), GetOutputFILE(), GetErrorFILE(),
268 m_editline_up->SetIsInputCompleteCallback(
269 [this](Editline *editline, StringList &lines) {
270 return this->IsInputCompleteCallback(editline, lines);
271 });
272
273 m_editline_up->SetAutoCompleteCallback([this](CompletionRequest &request) {
274 this->AutoCompleteCallback(request);
275 });
276
277 if (debugger.GetUseAutosuggestion()) {
278 m_editline_up->SetSuggestionCallback([this](llvm::StringRef line) {
279 return this->SuggestionCallback(line);
280 });
281 m_editline_up->SetSuggestionAnsiPrefix(ansi::FormatAnsiTerminalCodes(
282 debugger.GetAutosuggestionAnsiPrefix()));
283 m_editline_up->SetSuggestionAnsiSuffix(ansi::FormatAnsiTerminalCodes(
284 debugger.GetAutosuggestionAnsiSuffix()));
285 }
286 // See if the delegate supports fixing indentation
287 const char *indent_chars = delegate.IOHandlerGetFixIndentationCharacters();
288 if (indent_chars) {
289 // The delegate does support indentation, hook it up so when any
290 // indentation character is typed, the delegate gets a chance to fix it
291 FixIndentationCallbackType f = [this](Editline *editline,
292 const StringList &lines,
293 int cursor_position) {
294 return this->FixIndentationCallback(editline, lines, cursor_position);
295 };
296 m_editline_up->SetFixIndentationCallback(std::move(f), indent_chars);
297 }
298 }
299#endif
301 SetPrompt(prompt);
302 SetContinuationPrompt(continuation_prompt);
303}
304
306#if LLDB_ENABLE_LIBEDIT
307 m_editline_up.reset();
308#endif
309}
310
314}
315
319}
320
322#if LLDB_ENABLE_LIBEDIT
323 if (m_editline_up)
324 m_editline_up->TerminalSizeChanged();
325#endif
326}
327
328// Split out a line from the buffer, if there is a full one to get.
329static std::optional<std::string> SplitLine(std::string &line_buffer) {
330 size_t pos = line_buffer.find('\n');
331 if (pos == std::string::npos)
332 return std::nullopt;
333 std::string line =
334 std::string(StringRef(line_buffer.c_str(), pos).rtrim("\n\r"));
335 line_buffer = line_buffer.substr(pos + 1);
336 return line;
337}
338
339// If the final line of the file ends without a end-of-line, return
340// it as a line anyway.
341static std::optional<std::string> SplitLineEOF(std::string &line_buffer) {
342 if (llvm::all_of(line_buffer, llvm::isSpace))
343 return std::nullopt;
344 std::string line = std::move(line_buffer);
345 line_buffer.clear();
346 return line;
347}
348
349bool IOHandlerEditline::GetLine(std::string &line, bool &interrupted) {
350#if LLDB_ENABLE_LIBEDIT
351 if (m_editline_up) {
352 return m_editline_up->GetLine(line, interrupted);
353 }
354#endif
355
356 line.clear();
357
358 if (GetIsInteractive()) {
359 const char *prompt = nullptr;
360
361 if (m_multi_line && m_curr_line_idx > 0)
362 prompt = GetContinuationPrompt();
363
364 if (prompt == nullptr)
365 prompt = GetPrompt();
366
367 if (prompt && prompt[0]) {
368 if (m_output_sp) {
369 m_output_sp->Printf("%s", prompt);
370 m_output_sp->Flush();
371 }
372 }
373 }
374
375 std::optional<std::string> got_line = SplitLine(m_line_buffer);
376
377 if (!got_line && !m_input_sp) {
378 // No more input file, we are done...
379 SetIsDone(true);
380 return false;
381 }
382
383 FILE *in = GetInputFILE();
384 char buffer[256];
385
386 if (!got_line && !in && m_input_sp) {
387 // there is no FILE*, fall back on just reading bytes from the stream.
388 while (!got_line) {
389 size_t bytes_read = sizeof(buffer);
390 Status error = m_input_sp->Read((void *)buffer, bytes_read);
391 if (error.Success() && !bytes_read) {
392 got_line = SplitLineEOF(m_line_buffer);
393 break;
394 }
395 if (error.Fail())
396 break;
397 m_line_buffer += StringRef(buffer, bytes_read);
398 got_line = SplitLine(m_line_buffer);
399 }
400 }
401
402 if (!got_line && in) {
403 while (!got_line) {
404 char *r = fgets(buffer, sizeof(buffer), in);
405#ifdef _WIN32
406 // ReadFile on Windows is supposed to set ERROR_OPERATION_ABORTED
407 // according to the docs on MSDN. However, this has evidently been a
408 // known bug since Windows 8. Therefore, we can't detect if a signal
409 // interrupted in the fgets. So pressing ctrl-c causes the repl to end
410 // and the process to exit. A temporary workaround is just to attempt to
411 // fgets twice until this bug is fixed.
412 if (r == nullptr)
413 r = fgets(buffer, sizeof(buffer), in);
414 // this is the equivalent of EINTR for Windows
415 if (r == nullptr && GetLastError() == ERROR_OPERATION_ABORTED)
416 continue;
417#endif
418 if (r == nullptr) {
419 if (ferror(in) && errno == EINTR)
420 continue;
421 if (feof(in))
422 got_line = SplitLineEOF(m_line_buffer);
423 break;
424 }
425 m_line_buffer += buffer;
426 got_line = SplitLine(m_line_buffer);
427 }
428 }
429
430 if (got_line) {
431 line = *got_line;
432 }
433
434 return (bool)got_line;
435}
436
437#if LLDB_ENABLE_LIBEDIT
438bool IOHandlerEditline::IsInputCompleteCallback(Editline *editline,
439 StringList &lines) {
440 return m_delegate.IOHandlerIsInputComplete(*this, lines);
441}
442
443int IOHandlerEditline::FixIndentationCallback(Editline *editline,
444 const StringList &lines,
445 int cursor_position) {
446 return m_delegate.IOHandlerFixIndentation(*this, lines, cursor_position);
447}
448
449std::optional<std::string>
450IOHandlerEditline::SuggestionCallback(llvm::StringRef line) {
451 return m_delegate.IOHandlerSuggestion(*this, line);
452}
453
454void IOHandlerEditline::AutoCompleteCallback(CompletionRequest &request) {
455 m_delegate.IOHandlerComplete(*this, request);
456}
457#endif
458
460#if LLDB_ENABLE_LIBEDIT
461 if (m_editline_up) {
462 return m_editline_up->GetPrompt();
463 } else {
464#endif
465 if (m_prompt.empty())
466 return nullptr;
467#if LLDB_ENABLE_LIBEDIT
468 }
469#endif
470 return m_prompt.c_str();
471}
472
473bool IOHandlerEditline::SetPrompt(llvm::StringRef prompt) {
474 m_prompt = std::string(prompt);
475
476#if LLDB_ENABLE_LIBEDIT
477 if (m_editline_up)
478 m_editline_up->SetPrompt(m_prompt.empty() ? nullptr : m_prompt.c_str());
479#endif
480 return true;
481}
482
484 return (m_continuation_prompt.empty() ? nullptr
485 : m_continuation_prompt.c_str());
486}
487
488void IOHandlerEditline::SetContinuationPrompt(llvm::StringRef prompt) {
489 m_continuation_prompt = std::string(prompt);
490
491#if LLDB_ENABLE_LIBEDIT
492 if (m_editline_up)
493 m_editline_up->SetContinuationPrompt(m_continuation_prompt.empty()
494 ? nullptr
495 : m_continuation_prompt.c_str());
496#endif
497}
498
500 m_base_line_number = line;
501}
502
504#if LLDB_ENABLE_LIBEDIT
505 if (m_editline_up)
506 return m_editline_up->GetCurrentLine();
507#endif
508 return m_curr_line_idx;
509}
510
511bool IOHandlerEditline::GetLines(StringList &lines, bool &interrupted) {
512 m_current_lines_ptr = &lines;
513
514 bool success = false;
515#if LLDB_ENABLE_LIBEDIT
516 if (m_editline_up) {
517 return m_editline_up->GetLines(m_base_line_number, lines, interrupted);
518 } else {
519#endif
520 bool done = false;
522
523 while (!done) {
524 // Show line numbers if we are asked to
525 std::string line;
527 if (m_output_sp) {
528 m_output_sp->Printf("%u%s",
530 GetPrompt() == nullptr ? " " : "");
531 }
532 }
533
534 m_curr_line_idx = lines.GetSize();
535
536 bool interrupted = false;
537 if (GetLine(line, interrupted) && !interrupted) {
538 lines.AppendString(line);
539 done = m_delegate.IOHandlerIsInputComplete(*this, lines);
540 } else {
541 done = true;
542 }
543 }
544 success = lines.GetSize() > 0;
545#if LLDB_ENABLE_LIBEDIT
546 }
547#endif
548 return success;
549}
550
551// Each IOHandler gets to run until it is done. It should read data from the
552// "in" and place output into "out" and "err and return when done.
554 std::string line;
555 while (IsActive()) {
556 bool interrupted = false;
557 if (m_multi_line) {
558 StringList lines;
559 if (GetLines(lines, interrupted)) {
560 if (interrupted) {
563
564 } else {
565 line = lines.CopyList();
567 }
568 } else {
569 m_done = true;
570 }
571 } else {
572 if (GetLine(line, interrupted)) {
573 if (interrupted)
575 else
577 } else {
578 m_done = true;
579 }
580 }
581 }
582}
583
585#if LLDB_ENABLE_LIBEDIT
586 if (m_editline_up)
587 m_editline_up->Cancel();
588#endif
589}
590
592 // Let the delgate handle it first
594 return true;
595
596#if LLDB_ENABLE_LIBEDIT
597 if (m_editline_up)
598 return m_editline_up->Interrupt();
599#endif
600 return false;
601}
602
604#if LLDB_ENABLE_LIBEDIT
605 if (m_editline_up)
606 m_editline_up->Interrupt();
607#endif
608}
609
610void IOHandlerEditline::PrintAsync(const char *s, size_t len, bool is_stdout) {
611#if LLDB_ENABLE_LIBEDIT
612 if (m_editline_up) {
613 std::lock_guard<std::recursive_mutex> guard(m_output_mutex);
614 lldb::StreamFileSP stream = is_stdout ? m_output_sp : m_error_sp;
615 m_editline_up->PrintAsync(stream.get(), s, len);
616 } else
617#endif
618 {
619#ifdef _WIN32
620 const char *prompt = GetPrompt();
621 if (prompt) {
622 // Back up over previous prompt using Windows API
623 CONSOLE_SCREEN_BUFFER_INFO screen_buffer_info;
624 HANDLE console_handle = GetStdHandle(STD_OUTPUT_HANDLE);
625 GetConsoleScreenBufferInfo(console_handle, &screen_buffer_info);
626 COORD coord = screen_buffer_info.dwCursorPosition;
627 coord.X -= strlen(prompt);
628 if (coord.X < 0)
629 coord.X = 0;
630 SetConsoleCursorPosition(console_handle, coord);
631 }
632#endif
633 IOHandler::PrintAsync(s, len, is_stdout);
634#ifdef _WIN32
635 if (prompt)
636 IOHandler::PrintAsync(prompt, strlen(prompt), is_stdout);
637#endif
638 }
639}
static llvm::raw_ostream & error(Stream &strm)
static std::optional< std::string > SplitLine(std::string &line_buffer)
Definition: IOHandler.cpp:329
static std::optional< std::string > SplitLineEOF(std::string &line_buffer)
Definition: IOHandler.cpp:341
static bool InvokeCommonCompletionCallbacks(CommandInterpreter &interpreter, uint32_t completion_mask, lldb_private::CompletionRequest &request, SearchFilter *searcher)
std::optional< std::string > GetAutoSuggestionForCommand(llvm::StringRef line)
Returns the auto-suggestion string that should be added to the given command line.
void HandleCompletion(CompletionRequest &request)
"lldb/Utility/ArgCompletionRequest.h"
void AddCompletion(llvm::StringRef completion, llvm::StringRef description="", CompletionMode mode=CompletionMode::Normal)
Adds a possible completion string.
A class to manage flag bits.
Definition: Debugger.h:77
llvm::StringRef GetAutosuggestionAnsiPrefix() const
Definition: Debugger.cpp:417
CommandInterpreter & GetCommandInterpreter()
Definition: Debugger.h:170
llvm::StringRef GetAutosuggestionAnsiSuffix() const
Definition: Debugger.cpp:422
bool GetUseAutosuggestion() const
Definition: Debugger.cpp:411
void AdoptTopIOHandlerFilesIfInvalid(lldb::FileSP &in, lldb::StreamFileSP &out, lldb::StreamFileSP &err)
Definition: Debugger.cpp:1098
IOHandlerConfirm(Debugger &debugger, llvm::StringRef prompt, bool default_response)
Definition: IOHandler.cpp:136
void IOHandlerInputComplete(IOHandler &io_handler, std::string &data) override
Called when a line or lines have been retrieved.
Definition: IOHandler.cpp:166
void IOHandlerComplete(IOHandler &io_handler, CompletionRequest &request) override
Definition: IOHandler.cpp:159
A delegate class for use with IOHandler subclasses.
Definition: IOHandler.h:191
virtual void IOHandlerActivated(IOHandler &io_handler, bool interactive)
Definition: IOHandler.h:200
virtual void IOHandlerComplete(IOHandler &io_handler, CompletionRequest &request)
Definition: IOHandler.cpp:209
virtual const char * IOHandlerGetFixIndentationCharacters()
Definition: IOHandler.h:210
virtual void IOHandlerInputComplete(IOHandler &io_handler, std::string &data)=0
Called when a line or lines have been retrieved.
virtual bool IOHandlerInterrupt(IOHandler &io_handler)
Definition: IOHandler.h:286
virtual void IOHandlerDeactivated(IOHandler &io_handler)
Definition: IOHandler.h:202
virtual bool IOHandlerIsInputComplete(IOHandler &io_handler, StringList &lines)
Called to determine whether typing enter after the last line in lines should end input.
Definition: IOHandler.h:267
virtual std::optional< std::string > IOHandlerSuggestion(IOHandler &io_handler, llvm::StringRef line)
Definition: IOHandler.cpp:202
virtual int IOHandlerFixIndentation(IOHandler &io_handler, const StringList &lines, int cursor_position)
Called when a new line is created or one of an identified set of indentation characters is typed.
Definition: IOHandler.h:234
virtual void IOHandlerInputInterrupted(IOHandler &io_handler, std::string &data)
Definition: IOHandler.h:250
void PrintAsync(const char *s, size_t len, bool is_stdout) override
Definition: IOHandler.cpp:610
bool SetPrompt(llvm::StringRef prompt) override
Definition: IOHandler.cpp:473
bool GetLine(std::string &line, bool &interrupted)
Definition: IOHandler.cpp:349
void TerminalSizeChanged() override
Definition: IOHandler.cpp:321
bool GetLines(StringList &lines, bool &interrupted)
Definition: IOHandler.cpp:511
const char * GetContinuationPrompt()
Definition: IOHandler.cpp:483
void SetBaseLineNumber(uint32_t line)
Definition: IOHandler.cpp:499
void SetContinuationPrompt(llvm::StringRef prompt)
Definition: IOHandler.cpp:488
IOHandlerEditline(Debugger &debugger, IOHandler::Type type, const char *editline_name, llvm::StringRef prompt, llvm::StringRef continuation_prompt, bool multi_line, bool color_prompts, uint32_t line_number_start, IOHandlerDelegate &delegate)
Definition: IOHandler.cpp:225
IOHandlerDelegate & m_delegate
Definition: IOHandler.h:430
const char * GetPrompt() override
Definition: IOHandler.cpp:459
uint32_t GetCurrentLineIndex() const
Definition: IOHandler.cpp:503
bool PrintAsync(const char *s, size_t len, bool is_stdout)
Definition: IOHandler.cpp:128
std::recursive_mutex m_mutex
Definition: IOHandler.h:542
virtual void PrintAsync(const char *s, size_t len, bool is_stdout)
Definition: IOHandler.cpp:121
Predicate< bool > m_popped
Definition: IOHandler.h:173
virtual void Activate()
Definition: IOHandler.h:93
lldb::StreamFileSP GetErrorStreamFileSP()
Definition: IOHandler.cpp:107
bool GetIsRealTerminal()
Check if the input is coming from a real terminal.
Definition: IOHandler.cpp:113
lldb::FileSP GetInputFileSP()
Definition: IOHandler.cpp:103
std::recursive_mutex & GetOutputMutex()
Definition: IOHandler.h:165
Debugger & GetDebugger()
Definition: IOHandler.h:134
std::recursive_mutex m_output_mutex
Definition: IOHandler.h:172
virtual void Deactivate()
Definition: IOHandler.h:95
lldb::StreamFileSP m_error_sp
Definition: IOHandler.h:171
lldb::StreamFileSP GetOutputStreamFileSP()
Definition: IOHandler.cpp:105
IOHandler(Debugger &debugger, IOHandler::Type type)
Definition: IOHandler.cpp:55
bool GetIsInteractive()
Check if the input is being supplied interactively by a user.
Definition: IOHandler.cpp:109
lldb::FileSP m_input_sp
Definition: IOHandler.h:169
void SetPopped(bool b)
Definition: IOHandler.cpp:117
lldb::StreamFileSP m_output_sp
Definition: IOHandler.h:170
void SetIsDone(bool b)
Definition: IOHandler.h:87
void SetValue(T value, PredicateBroadcastType broadcast_type)
Value set accessor.
Definition: Predicate.h:90
bool WaitForValueEqualTo(T value, const Timeout< std::micro > &timeout=std::nullopt)
Wait for m_value to be equal to value.
Definition: Predicate.h:156
An error handling class.
Definition: Status.h:44
llvm::StringRef GetString() const
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:63
std::string CopyList(const char *item_preamble=nullptr, const char *items_sep="\n") const
Definition: StringList.cpp:198
void AppendString(const std::string &s)
Definition: StringList.cpp:43
size_t GetSize() const
Definition: StringList.cpp:74
#define UINT32_MAX
Definition: lldb-defines.h:19
std::string FormatAnsiTerminalCodes(llvm::StringRef format, bool do_color=true)
Definition: AnsiTerminal.h:83
A class that represents a running process on the host machine.
@ eBroadcastOnChange
Only broadcast if the value changes when the value is modified.
Definition: Predicate.h:30
Definition: SBAddress.h:15
Definition: Debugger.h:51