contrib/llvm/tools/lldb/tools/driver/IOChannel.cpp

   1 //===-- IOChannel.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 "IOChannel.h"
  11
  12 #include <map>
  13
  14 #include "lldb/API/SBCommandInterpreter.h"
  15 #include "lldb/API/SBDebugger.h"
  16 #include "lldb/API/SBError.h"
  17 #include "lldb/API/SBEvent.h"
  18 #include "lldb/API/SBFileSpec.h"
  19 #include "lldb/API/SBHostOS.h"
  20 #include "lldb/API/SBListener.h"
  21 #include "lldb/API/SBStringList.h"
  22
  23 #include <string.h>
  24 #include <limits.h>
  25
  26 using namespace lldb;
  27
  28 typedef std::map<EditLine *, std::string> PromptMap;
  29 const char *g_default_prompt = "(lldb) ";
  30 PromptMap g_prompt_map;
  31
  32 // Printing the following string causes libedit to back up to the beginning of the line & blank it out.
  33 const char undo_prompt_string[4] = { (char) 13, (char) 27, (char) 91, (char) 75};
  34
  35 static const char*
  36 el_prompt(EditLine *el)
  37 {
  38     PromptMap::const_iterator pos = g_prompt_map.find (el);
  39     if (pos == g_prompt_map.end())
  40         return g_default_prompt;
  41     return pos->second.c_str();
  42 }
  43
  44 const char *
  45 IOChannel::GetPrompt ()
  46 {
  47     PromptMap::const_iterator pos = g_prompt_map.find (m_edit_line);
  48     if (pos == g_prompt_map.end())
  49         return g_default_prompt;
  50     return pos->second.c_str();
  51 }
  52
  53 bool
  54 IOChannel::EditLineHasCharacters ()
  55 {
  56     const LineInfo *line_info  = el_line(m_edit_line);
  57     if (line_info)
  58     {
  59         // Sometimes we get called after the user has submitted the line, but before editline has
  60         // cleared the buffer.  In that case the cursor will be pointing at the newline.  That's
  61         // equivalent to having no characters on the line, since it has already been submitted.
  62         if (*line_info->cursor == '\n')
  63             return false;
  64         else
  65             return line_info->cursor != line_info->buffer;
  66     }
  67     else
  68         return false;
  69 }
  70
  71
  72 void
  73 IOChannel::EraseCharsBeforeCursor ()
  74 {
  75     const LineInfo *line_info  = el_line(m_edit_line);
  76     el_deletestr(m_edit_line, line_info->cursor - line_info->buffer);
  77 }
  78
  79 unsigned char
  80 IOChannel::ElCompletionFn (EditLine *e, int ch)
  81 {
  82     IOChannel *io_channel;
  83     if (el_get(e, EL_CLIENTDATA, &io_channel) == 0)
  84     {
  85         return io_channel->HandleCompletion (e, ch);
  86     }
  87     else
  88     {
  89         return CC_ERROR;
  90     }
  91 }
  92
  93 void
  94 IOChannel::ElResize()
  95 {
  96     el_resize(m_edit_line);
  97 }
  98
  99 unsigned char
 100 IOChannel::HandleCompletion (EditLine *e, int ch)
 101 {
 102     assert (e == m_edit_line);
 103
 104     const LineInfo *line_info  = el_line(m_edit_line);
 105     SBStringList completions;
 106     int page_size = 40;
 107
 108     int num_completions = m_driver->GetDebugger().GetCommandInterpreter().HandleCompletion (line_info->buffer,
 109                                                                                             line_info->cursor,
 110                                                                                             line_info->lastchar,
 111                                                                                             0,
 112                                                                                             -1,
 113                                                                                             completions);
 114
 115     if (num_completions == -1)
 116     {
 117         el_insertstr (m_edit_line, m_completion_key);
 118         return CC_REDISPLAY;
 119     }
 120     else if (num_completions == -2)
 121     {
 122         el_deletestr (m_edit_line, line_info->cursor - line_info->buffer);
 123         el_insertstr (m_edit_line, completions.GetStringAtIndex(0));
 124         return CC_REDISPLAY;
 125     }
 126
 127     // If we get a longer match display that first.
 128     const char *completion_str = completions.GetStringAtIndex(0);
 129     if (completion_str != NULL && *completion_str != '\0')
 130     {
 131         el_insertstr (m_edit_line, completion_str);
 132         return CC_REDISPLAY;
 133     }
 134
 135     if (num_completions > 1)
 136     {
 137         const char *comment = "\nAvailable completions:";
 138
 139         int num_elements = num_completions + 1;
 140         OutWrite(comment,  strlen (comment), NO_ASYNC);
 141         if (num_completions < page_size)
 142         {
 143             for (int i = 1; i < num_elements; i++)
 144             {
 145                 completion_str = completions.GetStringAtIndex(i);
 146                 OutWrite("\n\t", 2, NO_ASYNC);
 147                 OutWrite(completion_str, strlen (completion_str), NO_ASYNC);
 148             }
 149             OutWrite ("\n", 1, NO_ASYNC);
 150         }
 151         else
 152         {
 153             int cur_pos = 1;
 154             char reply;
 155             int got_char;
 156             while (cur_pos < num_elements)
 157             {
 158                 int endpoint = cur_pos + page_size;
 159                 if (endpoint > num_elements)
 160                     endpoint = num_elements;
 161                 for (; cur_pos < endpoint; cur_pos++)
 162                 {
 163                     completion_str = completions.GetStringAtIndex(cur_pos);
 164                     OutWrite("\n\t", 2, NO_ASYNC);
 165                     OutWrite(completion_str, strlen (completion_str), NO_ASYNC);
 166                 }
 167
 168                 if (cur_pos >= num_elements)
 169                 {
 170                     OutWrite("\n", 1, NO_ASYNC);
 171                     break;
 172                 }
 173
 174                 OutWrite("\nMore (Y/n/a): ", strlen ("\nMore (Y/n/a): "), NO_ASYNC);
 175                 reply = 'n';
 176                 got_char = el_getc(m_edit_line, &reply);
 177                 if (got_char == -1 || reply == 'n')
 178                     break;
 179                 if (reply == 'a')
 180                     page_size = num_elements - cur_pos;
 181             }
 182         }
 183
 184     }
 185
 186     if (num_completions == 0)
 187         return CC_REFRESH_BEEP;
 188     else
 189         return CC_REDISPLAY;
 190 }
 191
 192 IOChannel::IOChannel
 193 (
 194     FILE *editline_in,
 195     FILE *editline_out,
 196     FILE *out,
 197     FILE *err,
 198     Driver *driver
 199 ) :
 200     SBBroadcaster ("IOChannel"),
 201     m_output_mutex (),
 202     m_enter_elgets_time (),
 203     m_driver (driver),
 204     m_read_thread (LLDB_INVALID_HOST_THREAD),
 205     m_read_thread_should_exit (false),
 206     m_out_file (out),
 207     m_err_file (err),
 208     m_command_queue (),
 209     m_completion_key ("\t"),
 210     m_edit_line (::el_init (SBHostOS::GetProgramFileSpec().GetFilename(), editline_in, editline_out,  editline_out)),
 211     m_history (history_init()),
 212     m_history_event(),
 213     m_getting_command (false),
 214     m_expecting_prompt (false),
 215         m_prompt_str (),
 216     m_refresh_request_pending (false)
 217 {
 218     assert (m_edit_line);
 219     ::el_set (m_edit_line, EL_PROMPT, el_prompt);
 220     ::el_set (m_edit_line, EL_EDITOR, "emacs");
 221     ::el_set (m_edit_line, EL_HIST, history, m_history);
 222
 223     el_set (m_edit_line, EL_ADDFN, "lldb_complete",
 224             "LLDB completion function",
 225             IOChannel::ElCompletionFn);
 226     el_set (m_edit_line, EL_BIND, m_completion_key, "lldb_complete", NULL);
 227     el_set (m_edit_line, EL_BIND, "^r", "em-inc-search-prev", NULL);  // Cycle through backwards search, entering string
 228     el_set (m_edit_line, EL_BIND, "^w", "ed-delete-prev-word", NULL); // Delete previous word, behave like bash does.
 229     el_set (m_edit_line, EL_BIND, "\e[3~", "ed-delete-next-char", NULL); // Fix the delete key.
 230     el_set (m_edit_line, EL_CLIENTDATA, this);
 231
 232     // Source $PWD/.editrc then $HOME/.editrc
 233     ::el_source (m_edit_line, NULL);
 234
 235     assert (m_history);
 236     ::history (m_history, &m_history_event, H_SETSIZE, 800);
 237     ::history (m_history, &m_history_event, H_SETUNIQUE, 1);
 238     // Load history
 239     HistorySaveLoad (false);
 240
 241     // Set up mutex to make sure OutErr, OutWrite and RefreshPrompt do not interfere
 242     // with each other when writing.
 243
 244     int error;
 245     ::pthread_mutexattr_t attr;
 246     error = ::pthread_mutexattr_init (&attr);
 247     assert (error == 0);
 248     error = ::pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
 249     assert (error == 0);
 250     error = ::pthread_mutex_init (&m_output_mutex, &attr);
 251     assert (error == 0);
 252     error = ::pthread_mutexattr_destroy (&attr);
 253     assert (error == 0);
 254
 255     // Initialize time that ::el_gets was last called.
 256
 257     m_enter_elgets_time.tv_sec = 0;
 258     m_enter_elgets_time.tv_usec = 0;
 259 }
 260
 261 IOChannel::~IOChannel ()
 262 {
 263     // Save history
 264     HistorySaveLoad (true);
 265
 266     if (m_history != NULL)
 267     {
 268         ::history_end (m_history);
 269         m_history = NULL;
 270     }
 271
 272     if (m_edit_line != NULL)
 273     {
 274         ::el_end (m_edit_line);
 275         m_edit_line = NULL;
 276     }
 277
 278     ::pthread_mutex_destroy (&m_output_mutex);
 279 }
 280
 281 void
 282 IOChannel::HistorySaveLoad (bool save)
 283 {
 284     if (m_history != NULL)
 285     {
 286         char history_path[PATH_MAX];
 287         ::snprintf (history_path, sizeof(history_path), "~/.%s-history", SBHostOS::GetProgramFileSpec().GetFilename());
 288         if ((size_t)SBFileSpec::ResolvePath (history_path, history_path, sizeof(history_path)) < sizeof(history_path) - 1)
 289         {
 290             const char *path_ptr = history_path;
 291             if (save)
 292                 ::history (m_history, &m_history_event, H_SAVE, path_ptr);
 293             else
 294                 ::history (m_history, &m_history_event, H_LOAD, path_ptr);
 295         }
 296     }
 297 }
 298
 299 void
 300 IOChannel::LibeditOutputBytesReceived (void *baton, const void *src, size_t src_len)
 301 {
 302         // Make this a member variable.
 303     // static std::string prompt_str;
 304     IOChannel *io_channel = (IOChannel *) baton;
 305     IOLocker locker (io_channel->m_output_mutex);
 306     const char *bytes = (const char *) src;
 307
 308     if (io_channel->IsGettingCommand() && io_channel->m_expecting_prompt)
 309     {
 310         io_channel->m_prompt_str.append (bytes, src_len);
 311                 // Log this to make sure the prompt is really what you think it is.
 312         if (io_channel->m_prompt_str.find (el_prompt(io_channel->m_edit_line)) == 0)
 313         {
 314             io_channel->m_expecting_prompt = false;
 315             io_channel->m_refresh_request_pending = false;
 316             io_channel->OutWrite (io_channel->m_prompt_str.c_str(),
 317                                   io_channel->m_prompt_str.size(), NO_ASYNC);
 318             io_channel->m_prompt_str.clear();
 319         }
 320     }
 321     else
 322     {
 323         if (io_channel->m_prompt_str.size() > 0)
 324             io_channel->m_prompt_str.clear();
 325         std::string tmp_str (bytes, src_len);
 326         if (tmp_str.find (el_prompt (io_channel->m_edit_line)) == 0)
 327             io_channel->m_refresh_request_pending = false;
 328         io_channel->OutWrite (bytes, src_len, NO_ASYNC);
 329     }
 330 }
 331
 332 IOChannel::LibeditGetInputResult
 333 IOChannel::LibeditGetInput (std::string &new_line)
 334 {
 335     IOChannel::LibeditGetInputResult retval = IOChannel::eLibeditGetInputResultUnknown;
 336     if (m_edit_line != NULL)
 337     {
 338         int line_len = 0;
 339
 340         // Set boolean indicating whether or not el_gets is trying to get input (i.e. whether or not to attempt
 341         // to refresh the prompt after writing data).
 342         SetGettingCommand (true);
 343         m_expecting_prompt = true;
 344
 345         // Call el_gets to prompt the user and read the user's input.
 346         const char *line = ::el_gets (m_edit_line, &line_len);
 347
 348         // Re-set the boolean indicating whether or not el_gets is trying to get input.
 349         SetGettingCommand (false);
 350
 351         if (line)
 352         {
 353             retval = IOChannel::eLibeditGetInputValid;
 354             // strip any newlines off the end of the string...
 355             while (line_len > 0 && (line[line_len - 1] == '\n' || line[line_len - 1] == '\r'))
 356                 --line_len;
 357             if (line_len > 0)
 358             {
 359                 ::history (m_history, &m_history_event, H_ENTER, line);
 360                 new_line.assign (line, line_len);   // Omit the newline
 361             }
 362             else
 363             {
 364                 retval = IOChannel::eLibeditGetInputEmpty;
 365                 // Someone just hit ENTER, return the empty string
 366                 new_line.clear();
 367             }
 368             // Return true to indicate success even if a string is empty
 369             return retval;
 370         }
 371         else
 372         {
 373             retval = (line_len == 0 ? IOChannel::eLibeditGetInputEOF : IOChannel::eLibeditGetInputResultError);
 374         }
 375     }
 376     // Return false to indicate failure. This can happen when the file handle
 377     // is closed (EOF).
 378     new_line.clear();
 379     return retval;
 380 }
 381
 382 void *
 383 IOChannel::IOReadThread (void *ptr)
 384 {
 385     IOChannel *myself = static_cast<IOChannel *> (ptr);
 386     myself->Run();
 387     return NULL;
 388 }
 389
 390 void
 391 IOChannel::Run ()
 392 {
 393     SBListener listener("IOChannel::Run");
 394     std::string new_line;
 395
 396     SBBroadcaster interpreter_broadcaster (m_driver->GetDebugger().GetCommandInterpreter().GetBroadcaster());
 397     listener.StartListeningForEvents (interpreter_broadcaster,
 398                                       SBCommandInterpreter::eBroadcastBitResetPrompt |
 399                                       SBCommandInterpreter::eBroadcastBitThreadShouldExit |
 400                                       SBCommandInterpreter::eBroadcastBitQuitCommandReceived);
 401
 402     listener.StartListeningForEvents (*this,
 403                                       IOChannel::eBroadcastBitThreadShouldExit);
 404
 405     listener.StartListeningForEvents (*m_driver,
 406                                       Driver::eBroadcastBitReadyForInput |
 407                                       Driver::eBroadcastBitThreadShouldExit);
 408
 409     // Let anyone know that the IO channel is up and listening and ready for events
 410     BroadcastEventByType (eBroadcastBitThreadDidStart);
 411     bool done = false;
 412     while (!done)
 413     {
 414         SBEvent event;
 415
 416         listener.WaitForEvent (UINT32_MAX, event);
 417         if (!event.IsValid())
 418             continue;
 419
 420         const uint32_t event_type = event.GetType();
 421
 422         if (event.GetBroadcaster().IsValid())
 423         {
 424             if (event.BroadcasterMatchesPtr (m_driver))
 425             {
 426                 if (event_type & Driver::eBroadcastBitReadyForInput)
 427                 {
 428                     std::string line;
 429
 430                     if (CommandQueueIsEmpty())
 431                     {
 432                         IOChannel::LibeditGetInputResult getline_result = LibeditGetInput(line);
 433                         if (getline_result == IOChannel::eLibeditGetInputEOF)
 434                         {
 435                             // EOF occurred
 436                             // pretend that a quit was typed so the user gets a potential
 437                             // chance to confirm
 438                             line.assign("quit");
 439                         }
 440                         else if (getline_result == IOChannel::eLibeditGetInputResultError || getline_result == IOChannel::eLibeditGetInputResultUnknown)
 441                         {
 442                             // some random error occurred, exit and don't ask because the state might be corrupt
 443                             done = true;
 444                             continue;
 445                         }
 446                     }
 447                     else
 448                     {
 449                         GetCommandFromQueue (line);
 450                     }
 451
 452                     // TO BE DONE: FIGURE OUT WHICH COMMANDS SHOULD NOT BE REPEATED IF USER PRESSES PLAIN 'RETURN'
 453                     // AND TAKE CARE OF THAT HERE.
 454
 455                     SBEvent line_event(IOChannel::eBroadcastBitHasUserInput,
 456                              line.c_str(),
 457                              line.size());
 458                     BroadcastEvent (line_event);
 459                 }
 460                 else if (event_type & Driver::eBroadcastBitThreadShouldExit)
 461                 {
 462                     done = true;
 463                     continue;
 464                 }
 465             }
 466             else if (event.BroadcasterMatchesRef (interpreter_broadcaster))
 467             {
 468                 switch (event_type)
 469                 {
 470                 case SBCommandInterpreter::eBroadcastBitResetPrompt:
 471                     {
 472                         const char *new_prompt = SBEvent::GetCStringFromEvent (event);
 473                         if (new_prompt)
 474                             g_prompt_map[m_edit_line] = new_prompt;
 475                     }
 476                     break;
 477
 478                 case SBCommandInterpreter::eBroadcastBitThreadShouldExit:
 479                 case SBCommandInterpreter::eBroadcastBitQuitCommandReceived:
 480                     done = true;
 481                     break;
 482                 }
 483             }
 484             else if (event.BroadcasterMatchesPtr (this))
 485             {
 486                 if (event_type & IOChannel::eBroadcastBitThreadShouldExit)
 487                 {
 488                     done = true;
 489                     continue;
 490                 }
 491             }
 492         }
 493     }
 494     BroadcastEventByType (IOChannel::eBroadcastBitThreadDidExit);
 495     m_driver = NULL;
 496     m_read_thread = 0;
 497 }
 498
 499 bool
 500 IOChannel::Start ()
 501 {
 502     if (IS_VALID_LLDB_HOST_THREAD(m_read_thread))
 503         return true;
 504
 505     m_read_thread = SBHostOS::ThreadCreate ("<lldb.driver.commandline_io>", IOChannel::IOReadThread, this,
 506                                             NULL);
 507
 508     return (IS_VALID_LLDB_HOST_THREAD(m_read_thread));
 509 }
 510
 511 bool
 512 IOChannel::Stop ()
 513 {
 514     if (!IS_VALID_LLDB_HOST_THREAD(m_read_thread))
 515         return true;
 516
 517     BroadcastEventByType (eBroadcastBitThreadShouldExit);
 518
 519     // Don't call Host::ThreadCancel since el_gets won't respond to this
 520     // function call -- the thread will just die and all local variables in
 521     // IOChannel::Run() won't get destructed down which is bad since there is
 522     // a local listener holding onto broadcasters... To ensure proper shutdown,
 523     // a ^D (control-D) sequence (0x04) should be written to other end of the
 524     // the "in" file handle that was passed into the contructor as closing the
 525     // file handle doesn't seem to make el_gets() exit....
 526     return SBHostOS::ThreadJoin (m_read_thread, NULL, NULL);
 527 }
 528
 529 void
 530 IOChannel::RefreshPrompt ()
 531 {
 532     // If we are not in the middle of getting input from the user, there is no need to
 533     // refresh the prompt.
 534     IOLocker locker (m_output_mutex);
 535     if (! IsGettingCommand())
 536         return;
 537
 538         // If we haven't finished writing the prompt, there's no need to refresh it.
 539     if (m_expecting_prompt)
 540         return;
 541
 542     if (m_refresh_request_pending)
 543         return;
 544
 545     ::el_set (m_edit_line, EL_REFRESH);
 546     m_refresh_request_pending = true;
 547 }
 548
 549 void
 550 IOChannel::OutWrite (const char *buffer, size_t len, bool asynchronous)
 551 {
 552     if (len == 0 || buffer == NULL)
 553         return;
 554
 555     // We're in the process of exiting -- IOChannel::Run() has already completed
 556     // and set m_driver to NULL - it is time for us to leave now.  We might not
 557     // print the final ^D to stdout in this case.  We need to do some re-work on
 558     // how the I/O streams are managed at some point.
 559     if (m_driver == NULL)
 560     {
 561         return;
 562     }
 563
 564     // Use the mutex to make sure OutWrite and ErrWrite do not interfere with each other's output.
 565     IOLocker locker (m_output_mutex);
 566     if (m_driver->EditlineReaderIsTop() && asynchronous)
 567         ::fwrite (undo_prompt_string, 1, 4, m_out_file);
 568     ::fwrite (buffer, 1, len, m_out_file);
 569     if (asynchronous)
 570         m_driver->GetDebugger().NotifyTopInputReader (eInputReaderAsynchronousOutputWritten);
 571 }
 572
 573 void
 574 IOChannel::ErrWrite (const char *buffer, size_t len, bool asynchronous)
 575 {
 576     if (len == 0 || buffer == NULL)
 577         return;
 578
 579     // Use the mutex to make sure OutWrite and ErrWrite do not interfere with each other's output.
 580     IOLocker locker (m_output_mutex);
 581     if (asynchronous)
 582         ::fwrite (undo_prompt_string, 1, 4, m_err_file);
 583     ::fwrite (buffer, 1, len, m_err_file);
 584     if (asynchronous)
 585         m_driver->GetDebugger().NotifyTopInputReader (eInputReaderAsynchronousOutputWritten);
 586 }
 587
 588 void
 589 IOChannel::AddCommandToQueue (const char *command)
 590 {
 591     m_command_queue.push (std::string(command));
 592 }
 593
 594 bool
 595 IOChannel::GetCommandFromQueue (std::string &cmd)
 596 {
 597     if (m_command_queue.empty())
 598         return false;
 599     cmd.swap(m_command_queue.front());
 600     m_command_queue.pop ();
 601     return true;
 602 }
 603
 604 int
 605 IOChannel::CommandQueueSize () const
 606 {
 607     return m_command_queue.size();
 608 }
 609
 610 void
 611 IOChannel::ClearCommandQueue ()
 612 {
 613     while (!m_command_queue.empty())
 614         m_command_queue.pop();
 615 }
 616
 617 bool
 618 IOChannel::CommandQueueIsEmpty () const
 619 {
 620     return m_command_queue.empty();
 621 }
 622
 623 bool
 624 IOChannel::IsGettingCommand () const
 625 {
 626     return m_getting_command;
 627 }
 628
 629 void
 630 IOChannel::SetGettingCommand (bool new_value)
 631 {
 632     m_getting_command = new_value;
 633 }
 634
 635 IOLocker::IOLocker (pthread_mutex_t &mutex) :
 636     m_mutex_ptr (&mutex)
 637 {
 638     if (m_mutex_ptr)
 639         ::pthread_mutex_lock (m_mutex_ptr);
 640
 641 }
 642
 643 IOLocker::~IOLocker ()
 644 {
 645     if (m_mutex_ptr)
 646         ::pthread_mutex_unlock (m_mutex_ptr);
 647 }