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 9 #include "lldb/Core/IOHandler.h" 10 11 #if defined(__APPLE__) 12 #include <deque> 13 #endif 14 #include <string> 15 16 #include "lldb/Core/Debugger.h" 17 #include "lldb/Core/StreamFile.h" 18 #include "lldb/Host/Config.h" 19 #include "lldb/Host/File.h" 20 #include "lldb/Utility/AnsiTerminal.h" 21 #include "lldb/Utility/Predicate.h" 22 #include "lldb/Utility/Status.h" 23 #include "lldb/Utility/StreamString.h" 24 #include "lldb/Utility/StringList.h" 25 #include "lldb/lldb-forward.h" 26 27 #if LLDB_ENABLE_LIBEDIT 28 #include "lldb/Host/Editline.h" 29 #endif 30 #include "lldb/Interpreter/CommandCompletions.h" 31 #include "lldb/Interpreter/CommandInterpreter.h" 32 #include "llvm/ADT/StringRef.h" 33 34 #ifdef _WIN32 35 #include "lldb/Host/windows/windows.h" 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 51 using namespace lldb; 52 using namespace lldb_private; 53 using llvm::StringRef; 54 55 IOHandler::IOHandler(Debugger &debugger, IOHandler::Type type) 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 64 IOHandler::IOHandler(Debugger &debugger, IOHandler::Type type, 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. 72 if (!m_input_sp || !m_output_sp || !m_error_sp) 73 debugger.AdoptTopIOHandlerFilesIfInvalid(m_input_sp, m_output_sp, 74 m_error_sp); 75 } 76 77 IOHandler::~IOHandler() = default; 78 79 int IOHandler::GetInputFD() { 80 return (m_input_sp ? m_input_sp->GetDescriptor() : -1); 81 } 82 83 int IOHandler::GetOutputFD() { 84 return (m_output_sp ? m_output_sp->GetFile().GetDescriptor() : -1); 85 } 86 87 int IOHandler::GetErrorFD() { 88 return (m_error_sp ? m_error_sp->GetFile().GetDescriptor() : -1); 89 } 90 91 FILE *IOHandler::GetInputFILE() { 92 return (m_input_sp ? m_input_sp->GetStream() : nullptr); 93 } 94 95 FILE *IOHandler::GetOutputFILE() { 96 return (m_output_sp ? m_output_sp->GetFile().GetStream() : nullptr); 97 } 98 99 FILE *IOHandler::GetErrorFILE() { 100 return (m_error_sp ? m_error_sp->GetFile().GetStream() : nullptr); 101 } 102 103 FileSP IOHandler::GetInputFileSP() { return m_input_sp; } 104 105 StreamFileSP IOHandler::GetOutputStreamFileSP() { return m_output_sp; } 106 107 StreamFileSP IOHandler::GetErrorStreamFileSP() { return m_error_sp; } 108 109 bool IOHandler::GetIsInteractive() { 110 return GetInputFileSP() ? GetInputFileSP()->GetIsInteractive() : false; 111 } 112 113 bool IOHandler::GetIsRealTerminal() { 114 return GetInputFileSP() ? GetInputFileSP()->GetIsRealTerminal() : false; 115 } 116 117 void IOHandler::SetPopped(bool b) { m_popped.SetValue(b, eBroadcastOnChange); } 118 119 void IOHandler::WaitForPop() { m_popped.WaitForValueEqualTo(true); } 120 121 void 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 128 bool 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 136 IOHandlerConfirm::IOHandlerConfirm(Debugger &debugger, llvm::StringRef prompt, 137 bool default_response) 138 : IOHandlerEditline( 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); 149 if (m_default_response) 150 prompt_stream.Printf(": [Y/n] "); 151 else 152 prompt_stream.Printf(": [y/N] "); 153 154 SetPrompt(prompt_stream.GetString()); 155 } 156 157 IOHandlerConfirm::~IOHandlerConfirm() = default; 158 159 void IOHandlerConfirm::IOHandlerComplete(IOHandler &io_handler, 160 CompletionRequest &request) { 161 if (request.GetRawCursorPos() != 0) 162 return; 163 request.AddCompletion(m_default_response ? "y" : "n"); 164 } 165 166 void IOHandlerConfirm::IOHandlerInputComplete(IOHandler &io_handler, 167 std::string &line) { 168 if (line.empty()) { 169 // User just hit enter, set the response to the default 170 m_user_response = m_default_response; 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 201 std::optional<std::string> 202 IOHandlerDelegate::IOHandlerSuggestion(IOHandler &io_handler, 203 llvm::StringRef line) { 204 return io_handler.GetDebugger() 205 .GetCommandInterpreter() 206 .GetAutoSuggestionForCommand(line); 207 } 208 209 void IOHandlerDelegate::IOHandlerComplete(IOHandler &io_handler, 210 CompletionRequest &request) { 211 switch (m_completion) { 212 case Completion::None: 213 break; 214 case Completion::LLDBCommand: 215 io_handler.GetDebugger().GetCommandInterpreter().HandleCompletion(request); 216 break; 217 case Completion::Expression: 218 CommandCompletions::InvokeCommonCompletionCallbacks( 219 io_handler.GetDebugger().GetCommandInterpreter(), 220 CommandCompletions::eVariablePathCompletion, request, nullptr); 221 break; 222 } 223 } 224 225 IOHandlerEditline::IOHandlerEditline( 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 240 IOHandlerEditline::IOHandlerEditline( 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(), 267 GetOutputMutex(), m_color_prompts); 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 300 SetBaseLineNumber(m_base_line_number); 301 SetPrompt(prompt); 302 SetContinuationPrompt(continuation_prompt); 303 } 304 305 IOHandlerEditline::~IOHandlerEditline() { 306 #if LLDB_ENABLE_LIBEDIT 307 m_editline_up.reset(); 308 #endif 309 } 310 311 void IOHandlerEditline::Activate() { 312 IOHandler::Activate(); 313 m_delegate.IOHandlerActivated(*this, GetIsInteractive()); 314 } 315 316 void IOHandlerEditline::Deactivate() { 317 IOHandler::Deactivate(); 318 m_delegate.IOHandlerDeactivated(*this); 319 } 320 321 void IOHandlerEditline::TerminalSizeChanged() { 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. 329 static 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. 341 static 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 349 bool 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 438 bool IOHandlerEditline::IsInputCompleteCallback(Editline *editline, 439 StringList &lines) { 440 return m_delegate.IOHandlerIsInputComplete(*this, lines); 441 } 442 443 int IOHandlerEditline::FixIndentationCallback(Editline *editline, 444 const StringList &lines, 445 int cursor_position) { 446 return m_delegate.IOHandlerFixIndentation(*this, lines, cursor_position); 447 } 448 449 std::optional<std::string> 450 IOHandlerEditline::SuggestionCallback(llvm::StringRef line) { 451 return m_delegate.IOHandlerSuggestion(*this, line); 452 } 453 454 void IOHandlerEditline::AutoCompleteCallback(CompletionRequest &request) { 455 m_delegate.IOHandlerComplete(*this, request); 456 } 457 #endif 458 459 const char *IOHandlerEditline::GetPrompt() { 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 473 bool 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 483 const char *IOHandlerEditline::GetContinuationPrompt() { 484 return (m_continuation_prompt.empty() ? nullptr 485 : m_continuation_prompt.c_str()); 486 } 487 488 void 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 499 void IOHandlerEditline::SetBaseLineNumber(uint32_t line) { 500 m_base_line_number = line; 501 } 502 503 uint32_t IOHandlerEditline::GetCurrentLineIndex() const { 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 511 bool 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; 521 Status error; 522 523 while (!done) { 524 // Show line numbers if we are asked to 525 std::string line; 526 if (m_base_line_number > 0 && GetIsInteractive()) { 527 if (m_output_sp) { 528 m_output_sp->Printf("%u%s", 529 m_base_line_number + (uint32_t)lines.GetSize(), 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. 553 void IOHandlerEditline::Run() { 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) { 561 m_done = m_interrupt_exits; 562 m_delegate.IOHandlerInputInterrupted(*this, line); 563 564 } else { 565 line = lines.CopyList(); 566 m_delegate.IOHandlerInputComplete(*this, line); 567 } 568 } else { 569 m_done = true; 570 } 571 } else { 572 if (GetLine(line, interrupted)) { 573 if (interrupted) 574 m_delegate.IOHandlerInputInterrupted(*this, line); 575 else 576 m_delegate.IOHandlerInputComplete(*this, line); 577 } else { 578 m_done = true; 579 } 580 } 581 } 582 } 583 584 void IOHandlerEditline::Cancel() { 585 #if LLDB_ENABLE_LIBEDIT 586 if (m_editline_up) 587 m_editline_up->Cancel(); 588 #endif 589 } 590 591 bool IOHandlerEditline::Interrupt() { 592 // Let the delgate handle it first 593 if (m_delegate.IOHandlerInterrupt(*this)) 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 603 void IOHandlerEditline::GotEOF() { 604 #if LLDB_ENABLE_LIBEDIT 605 if (m_editline_up) 606 m_editline_up->Interrupt(); 607 #endif 608 } 609 610 void 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 } 640