tools/driver/IOChannel.cpp - platform/external/lldb - Git at Google

 //===-- IOChannel.cpp -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

 #include "IOChannel.h"

 #include <map>

 #include "lldb/API/SBCommandInterpreter.h"
 #include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBEvent.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBHostOS.h"
 #include "lldb/API/SBListener.h"
 #include "lldb/API/SBStringList.h"

 #include <string.h>
 #include <limits.h>

 using namespace lldb;

 typedef std::map<EditLine *, std::string> PromptMap;
 const char *g_default_prompt = "(lldb) ";
 PromptMap g_prompt_map;

 // Printing the following string causes libedit to back up to the beginning of the line & blank it out.
 const char undo_prompt_string[4] = { (char) 13, (char) 27, (char) 91, (char) 75};

 static const char*
 el_prompt(EditLine *el)
 {
     PromptMap::const_iterator pos = g_prompt_map.find (el);
     if (pos == g_prompt_map.end())
         return g_default_prompt;
     return pos->second.c_str();
 }

 const char *
 IOChannel::GetPrompt ()
 {
     PromptMap::const_iterator pos = g_prompt_map.find (m_edit_line);
     if (pos == g_prompt_map.end())
         return g_default_prompt;
     return pos->second.c_str();
 }

 bool
 IOChannel::EditLineHasCharacters ()
 {
     const LineInfo *line_info  = el_line(m_edit_line);
     if (line_info)
     {
         // Sometimes we get called after the user has submitted the line, but before editline has
         // cleared the buffer.  In that case the cursor will be pointing at the newline.  That's
         // equivalent to having no characters on the line, since it has already been submitted.
         if (*line_info->cursor == '\n')
             return false;
         else
             return line_info->cursor != line_info->buffer;
     }
     else
         return false;
 }


 void
 IOChannel::EraseCharsBeforeCursor ()
 {
     const LineInfo *line_info  = el_line(m_edit_line);
     el_deletestr(m_edit_line, line_info->cursor - line_info->buffer);
 }

 unsigned char
 IOChannel::ElCompletionFn (EditLine *e, int ch)
 {
     IOChannel *io_channel;
     if (el_get(e, EL_CLIENTDATA, &io_channel) == 0)
     {
         return io_channel->HandleCompletion (e, ch);
     }
     else
     {
         return CC_ERROR;
     }
 }

 void
 IOChannel::ElResize()
 {
     el_resize(m_edit_line);
 }

 unsigned char
 IOChannel::HandleCompletion (EditLine *e, int ch)
 {
     assert (e == m_edit_line);

     const LineInfo *line_info  = el_line(m_edit_line);
     SBStringList completions;
     int page_size = 40;

     int num_completions = m_driver->GetDebugger().GetCommandInterpreter().HandleCompletion (line_info->buffer,
                                                                                             line_info->cursor,
                                                                                             line_info->lastchar,
                                                                                             0,
                                                                                             -1,
                                                                                             completions);

     if (num_completions == -1)
     {
         el_insertstr (m_edit_line, m_completion_key);
         return CC_REDISPLAY;
     }
     else if (num_completions == -2)
     {
         el_deletestr (m_edit_line, line_info->cursor - line_info->buffer);
         el_insertstr (m_edit_line, completions.GetStringAtIndex(0));
         return CC_REDISPLAY;
     }

     // If we get a longer match display that first.
     const char *completion_str = completions.GetStringAtIndex(0);
     if (completion_str != NULL && *completion_str != '\0')
     {
         el_insertstr (m_edit_line, completion_str);
         return CC_REDISPLAY;
     }

     if (num_completions > 1)
     {
         const char *comment = "\nAvailable completions:";

         int num_elements = num_completions + 1;
         OutWrite(comment,  strlen (comment), NO_ASYNC);
         if (num_completions < page_size)
         {
             for (int i = 1; i < num_elements; i++)
             {
                 completion_str = completions.GetStringAtIndex(i);
                 OutWrite("\n\t", 2, NO_ASYNC);
                 OutWrite(completion_str, strlen (completion_str), NO_ASYNC);
             }
             OutWrite ("\n", 1, NO_ASYNC);
         }
         else
         {
             int cur_pos = 1;
             char reply;
             int got_char;
             while (cur_pos < num_elements)
             {
                 int endpoint = cur_pos + page_size;
                 if (endpoint > num_elements)
                     endpoint = num_elements;
                 for (; cur_pos < endpoint; cur_pos++)
                 {
                     completion_str = completions.GetStringAtIndex(cur_pos);
                     OutWrite("\n\t", 2, NO_ASYNC);
                     OutWrite(completion_str, strlen (completion_str), NO_ASYNC);
                 }

                 if (cur_pos >= num_elements)
                 {
                     OutWrite("\n", 1, NO_ASYNC);
                     break;
                 }

                 OutWrite("\nMore (Y/n/a): ", strlen ("\nMore (Y/n/a): "), NO_ASYNC);
                 reply = 'n';
                 got_char = el_getc(m_edit_line, &reply);
                 if (got_char == -1 || reply == 'n')
                     break;
                 if (reply == 'a')
                     page_size = num_elements - cur_pos;
             }
         }

     }

     if (num_completions == 0)
         return CC_REFRESH_BEEP;
     else
         return CC_REDISPLAY;
 }

 IOChannel::IOChannel
 (
     FILE *editline_in,
     FILE *editline_out,
     FILE *out,
     FILE *err,
     Driver *driver
 ) :
     SBBroadcaster ("IOChannel"),
     m_output_mutex (),
     m_enter_elgets_time (),
     m_driver (driver),
     m_read_thread (LLDB_INVALID_HOST_THREAD),
     m_read_thread_should_exit (false),
     m_out_file (out),
     m_err_file (err),
     m_command_queue (),
     m_completion_key ("\t"),
     m_edit_line (::el_init (SBHostOS::GetProgramFileSpec().GetFilename(), editline_in, editline_out,  editline_out)),
     m_history (history_init()),
     m_history_event(),
     m_getting_command (false),
     m_expecting_prompt (false),
 	m_prompt_str (),
     m_refresh_request_pending (false)
 {
     assert (m_edit_line);
     ::el_set (m_edit_line, EL_PROMPT, el_prompt);
     ::el_set (m_edit_line, EL_EDITOR, "emacs");
     ::el_set (m_edit_line, EL_HIST, history, m_history);

     el_set (m_edit_line, EL_ADDFN, "lldb_complete",
             "LLDB completion function",
             IOChannel::ElCompletionFn);
     el_set (m_edit_line, EL_BIND, m_completion_key, "lldb_complete", NULL);
     el_set (m_edit_line, EL_BIND, "^r", "em-inc-search-prev", NULL);  // Cycle through backwards search, entering string
     el_set (m_edit_line, EL_BIND, "^w", "ed-delete-prev-word", NULL); // Delete previous word, behave like bash does.
     el_set (m_edit_line, EL_BIND, "\e[3~", "ed-delete-next-char", NULL); // Fix the delete key.
     el_set (m_edit_line, EL_CLIENTDATA, this);

     // Source $PWD/.editrc then $HOME/.editrc
     ::el_source (m_edit_line, NULL);

     assert (m_history);
     ::history (m_history, &m_history_event, H_SETSIZE, 800);
     ::history (m_history, &m_history_event, H_SETUNIQUE, 1);
     // Load history
     HistorySaveLoad (false);

     // Set up mutex to make sure OutErr, OutWrite and RefreshPrompt do not interfere
     // with each other when writing.

     int error;
     ::pthread_mutexattr_t attr;
     error = ::pthread_mutexattr_init (&attr);
     assert (error == 0);
     error = ::pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
     assert (error == 0);
     error = ::pthread_mutex_init (&m_output_mutex, &attr);
     assert (error == 0);
     error = ::pthread_mutexattr_destroy (&attr);
     assert (error == 0);

     // Initialize time that ::el_gets was last called.

     m_enter_elgets_time.tv_sec = 0;
     m_enter_elgets_time.tv_usec = 0;
 }

 IOChannel::~IOChannel ()
 {
     // Save history
     HistorySaveLoad (true);

     if (m_history != NULL)
     {
         ::history_end (m_history);
         m_history = NULL;
     }

     if (m_edit_line != NULL)
     {
         ::el_end (m_edit_line);
         m_edit_line = NULL;
     }

     ::pthread_mutex_destroy (&m_output_mutex);
 }

 void
 IOChannel::HistorySaveLoad (bool save)
 {
     if (m_history != NULL)
     {
         char history_path[PATH_MAX];
         ::snprintf (history_path, sizeof(history_path), "~/.%s-history", SBHostOS::GetProgramFileSpec().GetFilename());
         if ((size_t)SBFileSpec::ResolvePath (history_path, history_path, sizeof(history_path)) < sizeof(history_path) - 1)
         {
             const char *path_ptr = history_path;
             if (save)
                 ::history (m_history, &m_history_event, H_SAVE, path_ptr);
             else
                 ::history (m_history, &m_history_event, H_LOAD, path_ptr);
         }
     }
 }

 void
 IOChannel::LibeditOutputBytesReceived (void *baton, const void *src, size_t src_len)
 {
 	// Make this a member variable.
     // static std::string prompt_str;
     IOChannel *io_channel = (IOChannel *) baton;
     IOLocker locker (io_channel->m_output_mutex);
     const char *bytes = (const char *) src;

     if (io_channel->IsGettingCommand() && io_channel->m_expecting_prompt)
     {
         io_channel->m_prompt_str.append (bytes, src_len);
 		// Log this to make sure the prompt is really what you think it is.
         if (io_channel->m_prompt_str.find (el_prompt(io_channel->m_edit_line)) == 0)
         {
             io_channel->m_expecting_prompt = false;
             io_channel->m_refresh_request_pending = false;
             io_channel->OutWrite (io_channel->m_prompt_str.c_str(),
                                   io_channel->m_prompt_str.size(), NO_ASYNC);
             io_channel->m_prompt_str.clear();
         }
     }
     else
     {
         if (io_channel->m_prompt_str.size() > 0)
             io_channel->m_prompt_str.clear();
         std::string tmp_str (bytes, src_len);
         if (tmp_str.find (el_prompt (io_channel->m_edit_line)) == 0)
             io_channel->m_refresh_request_pending = false;
         io_channel->OutWrite (bytes, src_len, NO_ASYNC);
     }
 }

 IOChannel::LibeditGetInputResult
 IOChannel::LibeditGetInput (std::string &new_line)
 {
     IOChannel::LibeditGetInputResult retval = IOChannel::eLibeditGetInputResultUnknown;
     if (m_edit_line != NULL)
     {
         int line_len = 0;

         // Set boolean indicating whether or not el_gets is trying to get input (i.e. whether or not to attempt
         // to refresh the prompt after writing data).
         SetGettingCommand (true);
         m_expecting_prompt = true;

         // Call el_gets to prompt the user and read the user's input.
         const char *line = ::el_gets (m_edit_line, &line_len);

         // Re-set the boolean indicating whether or not el_gets is trying to get input.
         SetGettingCommand (false);

         if (line)
         {
             retval = IOChannel::eLibeditGetInputValid;
             // strip any newlines off the end of the string...
             while (line_len > 0 && (line[line_len - 1] == '\n' || line[line_len - 1] == '\r'))
                 --line_len;
             if (line_len > 0)
             {
                 ::history (m_history, &m_history_event, H_ENTER, line);
                 new_line.assign (line, line_len);   // Omit the newline
             }
             else
             {
                 retval = IOChannel::eLibeditGetInputEmpty;
                 // Someone just hit ENTER, return the empty string
                 new_line.clear();
             }
             // Return true to indicate success even if a string is empty
             return retval;
         }
         else
         {
             retval = (line_len == 0 ? IOChannel::eLibeditGetInputEOF : IOChannel::eLibeditGetInputResultError);
         }
     }
     // Return false to indicate failure. This can happen when the file handle
     // is closed (EOF).
     new_line.clear();
     return retval;
 }

 void *
 IOChannel::IOReadThread (void *ptr)
 {
     IOChannel *myself = static_cast<IOChannel *> (ptr);
     myself->Run();
     return NULL;
 }

 void
 IOChannel::Run ()
 {
     SBListener listener("IOChannel::Run");
     std::string new_line;

     SBBroadcaster interpreter_broadcaster (m_driver->GetDebugger().GetCommandInterpreter().GetBroadcaster());
     listener.StartListeningForEvents (interpreter_broadcaster,
                                       SBCommandInterpreter::eBroadcastBitResetPrompt |
                                       SBCommandInterpreter::eBroadcastBitThreadShouldExit |
                                       SBCommandInterpreter::eBroadcastBitQuitCommandReceived);

     listener.StartListeningForEvents (*this,
                                       IOChannel::eBroadcastBitThreadShouldExit);

     listener.StartListeningForEvents (*m_driver,
                                       Driver::eBroadcastBitReadyForInput |
                                       Driver::eBroadcastBitThreadShouldExit);

     // Let anyone know that the IO channel is up and listening and ready for events
     BroadcastEventByType (eBroadcastBitThreadDidStart);
     bool done = false;
     while (!done)
     {
         SBEvent event;

         listener.WaitForEvent (UINT32_MAX, event);
         if (!event.IsValid())
             continue;

         const uint32_t event_type = event.GetType();

         if (event.GetBroadcaster().IsValid())
         {
             if (event.BroadcasterMatchesPtr (m_driver))
             {
                 if (event_type & Driver::eBroadcastBitReadyForInput)
                 {
                     std::string line;

                     if (CommandQueueIsEmpty())
                     {
                         IOChannel::LibeditGetInputResult getline_result = LibeditGetInput(line);
                         if (getline_result == IOChannel::eLibeditGetInputEOF)
                         {
                             // EOF occurred
                             // pretend that a quit was typed so the user gets a potential
                             // chance to confirm
                             line.assign("quit");
                         }
                         else if (getline_result == IOChannel::eLibeditGetInputResultError || getline_result == IOChannel::eLibeditGetInputResultUnknown)
                         {
                             // some random error occurred, exit and don't ask because the state might be corrupt
                             done = true;
                             continue;
                         }
                     }
                     else
                     {
                         GetCommandFromQueue (line);
                     }

                     // TO BE DONE: FIGURE OUT WHICH COMMANDS SHOULD NOT BE REPEATED IF USER PRESSES PLAIN 'RETURN'
                     // AND TAKE CARE OF THAT HERE.

                     SBEvent line_event(IOChannel::eBroadcastBitHasUserInput,
                              line.c_str(),
                              line.size());
                     BroadcastEvent (line_event);
                 }
                 else if (event_type & Driver::eBroadcastBitThreadShouldExit)
                 {
                     done = true;
                     continue;
                 }
             }
             else if (event.BroadcasterMatchesRef (interpreter_broadcaster))
             {
                 switch (event_type)
                 {
                 case SBCommandInterpreter::eBroadcastBitResetPrompt:
                     {
                         const char *new_prompt = SBEvent::GetCStringFromEvent (event);
                         if (new_prompt)
                             g_prompt_map[m_edit_line] = new_prompt;
                     }
                     break;

                 case SBCommandInterpreter::eBroadcastBitThreadShouldExit:
                 case SBCommandInterpreter::eBroadcastBitQuitCommandReceived:
                     done = true;
                     break;
                 }
             }
             else if (event.BroadcasterMatchesPtr (this))
             {
                 if (event_type & IOChannel::eBroadcastBitThreadShouldExit)
                 {
                     done = true;
                     continue;
                 }
             }
         }
     }
     BroadcastEventByType (IOChannel::eBroadcastBitThreadDidExit);
     m_driver = NULL;
     m_read_thread = 0;
 }

 bool
 IOChannel::Start ()
 {
     if (IS_VALID_LLDB_HOST_THREAD(m_read_thread))
         return true;

     m_read_thread = SBHostOS::ThreadCreate ("<lldb.driver.commandline_io>", IOChannel::IOReadThread, this,
                                             NULL);

     return (IS_VALID_LLDB_HOST_THREAD(m_read_thread));
 }

 bool
 IOChannel::Stop ()
 {
     if (!IS_VALID_LLDB_HOST_THREAD(m_read_thread))
         return true;

     BroadcastEventByType (eBroadcastBitThreadShouldExit);

     // Don't call Host::ThreadCancel since el_gets won't respond to this
     // function call -- the thread will just die and all local variables in
     // IOChannel::Run() won't get destructed down which is bad since there is
     // a local listener holding onto broadcasters... To ensure proper shutdown,
     // a ^D (control-D) sequence (0x04) should be written to other end of the
     // the "in" file handle that was passed into the contructor as closing the
     // file handle doesn't seem to make el_gets() exit....
     return SBHostOS::ThreadJoin (m_read_thread, NULL, NULL);
 }

 void
 IOChannel::RefreshPrompt ()
 {
     // If we are not in the middle of getting input from the user, there is no need to
     // refresh the prompt.
     IOLocker locker (m_output_mutex);
     if (! IsGettingCommand())
         return;

 	// If we haven't finished writing the prompt, there's no need to refresh it.
     if (m_expecting_prompt)
         return;

     if (m_refresh_request_pending)
         return;

     ::el_set (m_edit_line, EL_REFRESH);
     m_refresh_request_pending = true;
 }

 void
 IOChannel::OutWrite (const char *buffer, size_t len, bool asynchronous)
 {
     if (len == 0 || buffer == NULL)
         return;

     // We're in the process of exiting -- IOChannel::Run() has already completed
     // and set m_driver to NULL - it is time for us to leave now.  We might not
     // print the final ^D to stdout in this case.  We need to do some re-work on
     // how the I/O streams are managed at some point.
     if (m_driver == NULL)
     {
         return;
     }

     // Use the mutex to make sure OutWrite and ErrWrite do not interfere with each other's output.
     IOLocker locker (m_output_mutex);
     if (m_driver->EditlineReaderIsTop() && asynchronous)
         ::fwrite (undo_prompt_string, 1, 4, m_out_file);
     ::fwrite (buffer, 1, len, m_out_file);
     if (asynchronous)
         m_driver->GetDebugger().NotifyTopInputReader (eInputReaderAsynchronousOutputWritten);
 }

 void
 IOChannel::ErrWrite (const char *buffer, size_t len, bool asynchronous)
 {
     if (len == 0 || buffer == NULL)
         return;

     // Use the mutex to make sure OutWrite and ErrWrite do not interfere with each other's output.
     IOLocker locker (m_output_mutex);
     if (asynchronous)
         ::fwrite (undo_prompt_string, 1, 4, m_err_file);
     ::fwrite (buffer, 1, len, m_err_file);
     if (asynchronous)
         m_driver->GetDebugger().NotifyTopInputReader (eInputReaderAsynchronousOutputWritten);
 }

 void
 IOChannel::AddCommandToQueue (const char *command)
 {
     m_command_queue.push (std::string(command));
 }

 bool
 IOChannel::GetCommandFromQueue (std::string &cmd)
 {
     if (m_command_queue.empty())
         return false;
     cmd.swap(m_command_queue.front());
     m_command_queue.pop ();
     return true;
 }

 int
 IOChannel::CommandQueueSize () const
 {
     return m_command_queue.size();
 }

 void
 IOChannel::ClearCommandQueue ()
 {
     while (!m_command_queue.empty())
         m_command_queue.pop();
 }

 bool
 IOChannel::CommandQueueIsEmpty () const
 {
     return m_command_queue.empty();
 }

 bool
 IOChannel::IsGettingCommand () const
 {
     return m_getting_command;
 }

 void
 IOChannel::SetGettingCommand (bool new_value)
 {
     m_getting_command = new_value;
 }

 IOLocker::IOLocker (pthread_mutex_t &mutex) :
     m_mutex_ptr (&mutex)
 {
     if (m_mutex_ptr)
         ::pthread_mutex_lock (m_mutex_ptr);

 }

 IOLocker::~IOLocker ()
 {
     if (m_mutex_ptr)
         ::pthread_mutex_unlock (m_mutex_ptr);
 }
	//===-- IOChannel.cpp -------------------------------------------- C++ --===//
	//
	// The LLVM Compiler Infrastructure
	//
	// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.
	//
	//===----------------------------------------------------------------------===//

	#include "IOChannel.h"

	#include <map>

	#include "lldb/API/SBCommandInterpreter.h"
	#include "lldb/API/SBDebugger.h"
	#include "lldb/API/SBError.h"
	#include "lldb/API/SBEvent.h"
	#include "lldb/API/SBFileSpec.h"
	#include "lldb/API/SBHostOS.h"
	#include "lldb/API/SBListener.h"
	#include "lldb/API/SBStringList.h"

	#include <string.h>
	#include <limits.h>

	using namespace lldb;

	typedef std::map<EditLine *, std::string> PromptMap;
	const char *g_default_prompt = "(lldb) ";
	PromptMap g_prompt_map;

	// Printing the following string causes libedit to back up to the beginning of the line & blank it out.
	const char undo_prompt_string[4] = { (char) 13, (char) 27, (char) 91, (char) 75};

	static const char*
	el_prompt(EditLine *el)
	{
	PromptMap::const_iterator pos = g_prompt_map.find (el);
	if (pos == g_prompt_map.end())
	return g_default_prompt;
	return pos->second.c_str();
	}

	const char *
	IOChannel::GetPrompt ()
	{
	PromptMap::const_iterator pos = g_prompt_map.find (m_edit_line);
	if (pos == g_prompt_map.end())
	return g_default_prompt;
	return pos->second.c_str();
	}

	bool
	IOChannel::EditLineHasCharacters ()
	{
	const LineInfo *line_info = el_line(m_edit_line);
	if (line_info)
	{
	// Sometimes we get called after the user has submitted the line, but before editline has
	// cleared the buffer. In that case the cursor will be pointing at the newline. That's
	// equivalent to having no characters on the line, since it has already been submitted.
	if (*line_info->cursor == '\n')
	return false;
	else
	return line_info->cursor != line_info->buffer;
	}
	else
	return false;
	}


	void
	IOChannel::EraseCharsBeforeCursor ()
	{
	const LineInfo *line_info = el_line(m_edit_line);
	el_deletestr(m_edit_line, line_info->cursor - line_info->buffer);
	}

	unsigned char
	IOChannel::ElCompletionFn (EditLine *e, int ch)
	{
	IOChannel *io_channel;
	if (el_get(e, EL_CLIENTDATA, &io_channel) == 0)
	{
	return io_channel->HandleCompletion (e, ch);
	}
	else
	{
	return CC_ERROR;
	}
	}

	void
	IOChannel::ElResize()
	{
	el_resize(m_edit_line);
	}

	unsigned char
	IOChannel::HandleCompletion (EditLine *e, int ch)
	{
	assert (e == m_edit_line);

	const LineInfo *line_info = el_line(m_edit_line);
	SBStringList completions;
	int page_size = 40;

	int num_completions = m_driver->GetDebugger().GetCommandInterpreter().HandleCompletion (line_info->buffer,
	line_info->cursor,
	line_info->lastchar,
	0,
	-1,
	completions);

	if (num_completions == -1)
	{
	el_insertstr (m_edit_line, m_completion_key);
	return CC_REDISPLAY;
	}
	else if (num_completions == -2)
	{
	el_deletestr (m_edit_line, line_info->cursor - line_info->buffer);
	el_insertstr (m_edit_line, completions.GetStringAtIndex(0));
	return CC_REDISPLAY;
	}

	// If we get a longer match display that first.
	const char *completion_str = completions.GetStringAtIndex(0);
	if (completion_str != NULL && *completion_str != '\0')
	{
	el_insertstr (m_edit_line, completion_str);
	return CC_REDISPLAY;
	}

	if (num_completions > 1)
	{
	const char *comment = "\nAvailable completions:";

	int num_elements = num_completions + 1;
	OutWrite(comment, strlen (comment), NO_ASYNC);
	if (num_completions < page_size)
	{
	for (int i = 1; i < num_elements; i++)
	{
	completion_str = completions.GetStringAtIndex(i);
	OutWrite("\n\t", 2, NO_ASYNC);
	OutWrite(completion_str, strlen (completion_str), NO_ASYNC);
	}
	OutWrite ("\n", 1, NO_ASYNC);
	}
	else
	{
	int cur_pos = 1;
	char reply;
	int got_char;
	while (cur_pos < num_elements)
	{
	int endpoint = cur_pos + page_size;
	if (endpoint > num_elements)
	endpoint = num_elements;
	for (; cur_pos < endpoint; cur_pos++)
	{
	completion_str = completions.GetStringAtIndex(cur_pos);
	OutWrite("\n\t", 2, NO_ASYNC);
	OutWrite(completion_str, strlen (completion_str), NO_ASYNC);
	}

	if (cur_pos >= num_elements)
	{
	OutWrite("\n", 1, NO_ASYNC);
	break;
	}

	OutWrite("\nMore (Y/n/a): ", strlen ("\nMore (Y/n/a): "), NO_ASYNC);
	reply = 'n';
	got_char = el_getc(m_edit_line, &reply);
	if (got_char == -1 \|\| reply == 'n')
	break;
	if (reply == 'a')
	page_size = num_elements - cur_pos;
	}
	}

	}

	if (num_completions == 0)
	return CC_REFRESH_BEEP;
	else
	return CC_REDISPLAY;
	}

	IOChannel::IOChannel
	(
	FILE *editline_in,
	FILE *editline_out,
	FILE *out,
	FILE *err,
	Driver *driver
	) :
	SBBroadcaster ("IOChannel"),
	m_output_mutex (),
	m_enter_elgets_time (),
	m_driver (driver),
	m_read_thread (LLDB_INVALID_HOST_THREAD),
	m_read_thread_should_exit (false),
	m_out_file (out),
	m_err_file (err),
	m_command_queue (),
	m_completion_key ("\t"),
	m_edit_line (::el_init (SBHostOS::GetProgramFileSpec().GetFilename(), editline_in, editline_out, editline_out)),
	m_history (history_init()),
	m_history_event(),
	m_getting_command (false),
	m_expecting_prompt (false),
	m_prompt_str (),
	m_refresh_request_pending (false)
	{
	assert (m_edit_line);
	::el_set (m_edit_line, EL_PROMPT, el_prompt);
	::el_set (m_edit_line, EL_EDITOR, "emacs");
	::el_set (m_edit_line, EL_HIST, history, m_history);

	el_set (m_edit_line, EL_ADDFN, "lldb_complete",
	"LLDB completion function",
	IOChannel::ElCompletionFn);
	el_set (m_edit_line, EL_BIND, m_completion_key, "lldb_complete", NULL);
	el_set (m_edit_line, EL_BIND, "^r", "em-inc-search-prev", NULL); // Cycle through backwards search, entering string
	el_set (m_edit_line, EL_BIND, "^w", "ed-delete-prev-word", NULL); // Delete previous word, behave like bash does.
	el_set (m_edit_line, EL_BIND, "\e[3~", "ed-delete-next-char", NULL); // Fix the delete key.
	el_set (m_edit_line, EL_CLIENTDATA, this);

	// Source $PWD/.editrc then $HOME/.editrc
	::el_source (m_edit_line, NULL);

	assert (m_history);
	::history (m_history, &m_history_event, H_SETSIZE, 800);
	::history (m_history, &m_history_event, H_SETUNIQUE, 1);
	// Load history
	HistorySaveLoad (false);

	// Set up mutex to make sure OutErr, OutWrite and RefreshPrompt do not interfere
	// with each other when writing.

	int error;
	::pthread_mutexattr_t attr;
	error = ::pthread_mutexattr_init (&attr);
	assert (error == 0);
	error = ::pthread_mutexattr_settype (&attr, PTHREAD_MUTEX_RECURSIVE);
	assert (error == 0);
	error = ::pthread_mutex_init (&m_output_mutex, &attr);
	assert (error == 0);
	error = ::pthread_mutexattr_destroy (&attr);
	assert (error == 0);

	// Initialize time that ::el_gets was last called.

	m_enter_elgets_time.tv_sec = 0;
	m_enter_elgets_time.tv_usec = 0;
	}

	IOChannel::~IOChannel ()
	{
	// Save history
	HistorySaveLoad (true);

	if (m_history != NULL)
	{
	::history_end (m_history);
	m_history = NULL;
	}

	if (m_edit_line != NULL)
	{
	::el_end (m_edit_line);
	m_edit_line = NULL;
	}

	::pthread_mutex_destroy (&m_output_mutex);
	}

	void
	IOChannel::HistorySaveLoad (bool save)
	{
	if (m_history != NULL)
	{
	char history_path[PATH_MAX];
	::snprintf (history_path, sizeof(history_path), "~/.%s-history", SBHostOS::GetProgramFileSpec().GetFilename());
	if ((size_t)SBFileSpec::ResolvePath (history_path, history_path, sizeof(history_path)) < sizeof(history_path) - 1)
	{
	const char *path_ptr = history_path;
	if (save)
	::history (m_history, &m_history_event, H_SAVE, path_ptr);
	else
	::history (m_history, &m_history_event, H_LOAD, path_ptr);
	}
	}
	}

	void
	IOChannel::LibeditOutputBytesReceived (void baton, const void src, size_t src_len)
	{
	// Make this a member variable.
	// static std::string prompt_str;
	IOChannel io_channel = (IOChannel ) baton;
	IOLocker locker (io_channel->m_output_mutex);
	const char bytes = (const char ) src;

	if (io_channel->IsGettingCommand() && io_channel->m_expecting_prompt)
	{
	io_channel->m_prompt_str.append (bytes, src_len);
	// Log this to make sure the prompt is really what you think it is.
	if (io_channel->m_prompt_str.find (el_prompt(io_channel->m_edit_line)) == 0)
	{
	io_channel->m_expecting_prompt = false;
	io_channel->m_refresh_request_pending = false;
	io_channel->OutWrite (io_channel->m_prompt_str.c_str(),
	io_channel->m_prompt_str.size(), NO_ASYNC);
	io_channel->m_prompt_str.clear();
	}
	}
	else
	{
	if (io_channel->m_prompt_str.size() > 0)
	io_channel->m_prompt_str.clear();
	std::string tmp_str (bytes, src_len);
	if (tmp_str.find (el_prompt (io_channel->m_edit_line)) == 0)
	io_channel->m_refresh_request_pending = false;
	io_channel->OutWrite (bytes, src_len, NO_ASYNC);
	}
	}

	IOChannel::LibeditGetInputResult
	IOChannel::LibeditGetInput (std::string &new_line)
	{
	IOChannel::LibeditGetInputResult retval = IOChannel::eLibeditGetInputResultUnknown;
	if (m_edit_line != NULL)
	{
	int line_len = 0;

	// Set boolean indicating whether or not el_gets is trying to get input (i.e. whether or not to attempt
	// to refresh the prompt after writing data).
	SetGettingCommand (true);
	m_expecting_prompt = true;

	// Call el_gets to prompt the user and read the user's input.
	const char *line = ::el_gets (m_edit_line, &line_len);

	// Re-set the boolean indicating whether or not el_gets is trying to get input.
	SetGettingCommand (false);

	if (line)
	{
	retval = IOChannel::eLibeditGetInputValid;
	// strip any newlines off the end of the string...
	while (line_len > 0 && (line[line_len - 1] == '\n' \|\| line[line_len - 1] == '\r'))
	--line_len;
	if (line_len > 0)
	{
	::history (m_history, &m_history_event, H_ENTER, line);
	new_line.assign (line, line_len); // Omit the newline
	}
	else
	{
	retval = IOChannel::eLibeditGetInputEmpty;
	// Someone just hit ENTER, return the empty string
	new_line.clear();
	}
	// Return true to indicate success even if a string is empty
	return retval;
	}
	else
	{
	retval = (line_len == 0 ? IOChannel::eLibeditGetInputEOF : IOChannel::eLibeditGetInputResultError);
	}
	}
	// Return false to indicate failure. This can happen when the file handle
	// is closed (EOF).
	new_line.clear();
	return retval;
	}

	void *
	IOChannel::IOReadThread (void *ptr)
	{
	IOChannel myself = static_cast<IOChannel > (ptr);
	myself->Run();
	return NULL;
	}

	void
	IOChannel::Run ()
	{
	SBListener listener("IOChannel::Run");
	std::string new_line;

	SBBroadcaster interpreter_broadcaster (m_driver->GetDebugger().GetCommandInterpreter().GetBroadcaster());
	listener.StartListeningForEvents (interpreter_broadcaster,
	SBCommandInterpreter::eBroadcastBitResetPrompt \|
	SBCommandInterpreter::eBroadcastBitThreadShouldExit \|
	SBCommandInterpreter::eBroadcastBitQuitCommandReceived);

	listener.StartListeningForEvents (*this,
	IOChannel::eBroadcastBitThreadShouldExit);

	listener.StartListeningForEvents (*m_driver,
	Driver::eBroadcastBitReadyForInput \|
	Driver::eBroadcastBitThreadShouldExit);

	// Let anyone know that the IO channel is up and listening and ready for events
	BroadcastEventByType (eBroadcastBitThreadDidStart);
	bool done = false;
	while (!done)
	{
	SBEvent event;

	listener.WaitForEvent (UINT32_MAX, event);
	if (!event.IsValid())
	continue;

	const uint32_t event_type = event.GetType();

	if (event.GetBroadcaster().IsValid())
	{
	if (event.BroadcasterMatchesPtr (m_driver))
	{
	if (event_type & Driver::eBroadcastBitReadyForInput)
	{
	std::string line;

	if (CommandQueueIsEmpty())
	{
	IOChannel::LibeditGetInputResult getline_result = LibeditGetInput(line);
	if (getline_result == IOChannel::eLibeditGetInputEOF)
	{
	// EOF occurred
	// pretend that a quit was typed so the user gets a potential
	// chance to confirm
	line.assign("quit");
	}
	else if (getline_result == IOChannel::eLibeditGetInputResultError \|\| getline_result == IOChannel::eLibeditGetInputResultUnknown)
	{
	// some random error occurred, exit and don't ask because the state might be corrupt
	done = true;
	continue;
	}
	}
	else
	{
	GetCommandFromQueue (line);
	}

	// TO BE DONE: FIGURE OUT WHICH COMMANDS SHOULD NOT BE REPEATED IF USER PRESSES PLAIN 'RETURN'
	// AND TAKE CARE OF THAT HERE.

	SBEvent line_event(IOChannel::eBroadcastBitHasUserInput,
	line.c_str(),
	line.size());
	BroadcastEvent (line_event);
	}
	else if (event_type & Driver::eBroadcastBitThreadShouldExit)
	{
	done = true;
	continue;
	}
	}
	else if (event.BroadcasterMatchesRef (interpreter_broadcaster))
	{
	switch (event_type)
	{
	case SBCommandInterpreter::eBroadcastBitResetPrompt:
	{
	const char *new_prompt = SBEvent::GetCStringFromEvent (event);
	if (new_prompt)
	g_prompt_map[m_edit_line] = new_prompt;
	}
	break;

	case SBCommandInterpreter::eBroadcastBitThreadShouldExit:
	case SBCommandInterpreter::eBroadcastBitQuitCommandReceived:
	done = true;
	break;
	}
	}
	else if (event.BroadcasterMatchesPtr (this))
	{
	if (event_type & IOChannel::eBroadcastBitThreadShouldExit)
	{
	done = true;
	continue;
	}
	}
	}
	}
	BroadcastEventByType (IOChannel::eBroadcastBitThreadDidExit);
	m_driver = NULL;
	m_read_thread = 0;
	}

	bool
	IOChannel::Start ()
	{
	if (IS_VALID_LLDB_HOST_THREAD(m_read_thread))
	return true;

	m_read_thread = SBHostOS::ThreadCreate ("<lldb.driver.commandline_io>", IOChannel::IOReadThread, this,
	NULL);

	return (IS_VALID_LLDB_HOST_THREAD(m_read_thread));
	}

	bool
	IOChannel::Stop ()
	{
	if (!IS_VALID_LLDB_HOST_THREAD(m_read_thread))
	return true;

	BroadcastEventByType (eBroadcastBitThreadShouldExit);

	// Don't call Host::ThreadCancel since el_gets won't respond to this
	// function call -- the thread will just die and all local variables in
	// IOChannel::Run() won't get destructed down which is bad since there is
	// a local listener holding onto broadcasters... To ensure proper shutdown,
	// a ^D (control-D) sequence (0x04) should be written to other end of the
	// the "in" file handle that was passed into the contructor as closing the
	// file handle doesn't seem to make el_gets() exit....
	return SBHostOS::ThreadJoin (m_read_thread, NULL, NULL);
	}

	void
	IOChannel::RefreshPrompt ()
	{
	// If we are not in the middle of getting input from the user, there is no need to
	// refresh the prompt.
	IOLocker locker (m_output_mutex);
	if (! IsGettingCommand())
	return;

	// If we haven't finished writing the prompt, there's no need to refresh it.
	if (m_expecting_prompt)
	return;

	if (m_refresh_request_pending)
	return;

	::el_set (m_edit_line, EL_REFRESH);
	m_refresh_request_pending = true;
	}

	void
	IOChannel::OutWrite (const char *buffer, size_t len, bool asynchronous)
	{
	if (len == 0 \|\| buffer == NULL)
	return;

	// We're in the process of exiting -- IOChannel::Run() has already completed
	// and set m_driver to NULL - it is time for us to leave now. We might not
	// print the final ^D to stdout in this case. We need to do some re-work on
	// how the I/O streams are managed at some point.
	if (m_driver == NULL)
	{
	return;
	}

	// Use the mutex to make sure OutWrite and ErrWrite do not interfere with each other's output.
	IOLocker locker (m_output_mutex);
	if (m_driver->EditlineReaderIsTop() && asynchronous)
	::fwrite (undo_prompt_string, 1, 4, m_out_file);
	::fwrite (buffer, 1, len, m_out_file);
	if (asynchronous)
	m_driver->GetDebugger().NotifyTopInputReader (eInputReaderAsynchronousOutputWritten);
	}

	void
	IOChannel::ErrWrite (const char *buffer, size_t len, bool asynchronous)
	{
	if (len == 0 \|\| buffer == NULL)
	return;

	// Use the mutex to make sure OutWrite and ErrWrite do not interfere with each other's output.
	IOLocker locker (m_output_mutex);
	if (asynchronous)
	::fwrite (undo_prompt_string, 1, 4, m_err_file);
	::fwrite (buffer, 1, len, m_err_file);
	if (asynchronous)
	m_driver->GetDebugger().NotifyTopInputReader (eInputReaderAsynchronousOutputWritten);
	}

	void
	IOChannel::AddCommandToQueue (const char *command)
	{
	m_command_queue.push (std::string(command));
	}

	bool
	IOChannel::GetCommandFromQueue (std::string &cmd)
	{
	if (m_command_queue.empty())
	return false;
	cmd.swap(m_command_queue.front());
	m_command_queue.pop ();
	return true;
	}

	int
	IOChannel::CommandQueueSize () const
	{
	return m_command_queue.size();
	}

	void
	IOChannel::ClearCommandQueue ()
	{
	while (!m_command_queue.empty())
	m_command_queue.pop();
	}

	bool
	IOChannel::CommandQueueIsEmpty () const
	{
	return m_command_queue.empty();
	}

	bool
	IOChannel::IsGettingCommand () const
	{
	return m_getting_command;
	}

	void
	IOChannel::SetGettingCommand (bool new_value)
	{
	m_getting_command = new_value;
	}

	IOLocker::IOLocker (pthread_mutex_t &mutex) :
	m_mutex_ptr (&mutex)
	{
	if (m_mutex_ptr)
	::pthread_mutex_lock (m_mutex_ptr);

	}

	IOLocker::~IOLocker ()
	{
	if (m_mutex_ptr)
	::pthread_mutex_unlock (m_mutex_ptr);
	}