Merge lldb r188801 to contrib/llvm/tools/lldb/

1 files changed, 2882 insertions, 0 deletions

diff --git a/contrib/llvm/tools/lldb/source/Interpreter/CommandInterpreter.cpp b/contrib/llvm/tools/lldb/source/Interpreter/CommandInterpreter.cpp
new file mode 100644
index 0000000..db2f2fa
--- /dev/null
+++ b/contrib/llvm/tools/lldb/source/Interpreter/CommandInterpreter.cpp
@@ -0,0 +1,2882 @@
+//===-- CommandInterpreter.cpp ----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/lldb-python.h"
+
+#include <string>
+#include <vector>
+
+#include <getopt.h>
+#include <stdlib.h>
+
+#include "CommandObjectScript.h"
+#include "lldb/Interpreter/CommandObjectRegexCommand.h"
+
+#include "../Commands/CommandObjectApropos.h"
+#include "../Commands/CommandObjectArgs.h"
+#include "../Commands/CommandObjectBreakpoint.h"
+#include "../Commands/CommandObjectDisassemble.h"
+#include "../Commands/CommandObjectExpression.h"
+#include "../Commands/CommandObjectFrame.h"
+#include "../Commands/CommandObjectHelp.h"
+#include "../Commands/CommandObjectLog.h"
+#include "../Commands/CommandObjectMemory.h"
+#include "../Commands/CommandObjectPlatform.h"
+#include "../Commands/CommandObjectPlugin.h"
+#include "../Commands/CommandObjectProcess.h"
+#include "../Commands/CommandObjectQuit.h"
+#include "../Commands/CommandObjectRegister.h"
+#include "../Commands/CommandObjectSettings.h"
+#include "../Commands/CommandObjectSource.h"
+#include "../Commands/CommandObjectCommands.h"
+#include "../Commands/CommandObjectSyntax.h"
+#include "../Commands/CommandObjectTarget.h"
+#include "../Commands/CommandObjectThread.h"
+#include "../Commands/CommandObjectType.h"
+#include "../Commands/CommandObjectVersion.h"
+#include "../Commands/CommandObjectWatchpoint.h"
+
+
+#include "lldb/Core/Debugger.h"
+#include "lldb/Core/InputReader.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Core/Timer.h"
+
+#include "lldb/Host/Host.h"
+
+#include "lldb/Interpreter/Args.h"
+#include "lldb/Interpreter/CommandCompletions.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Interpreter/CommandReturnObject.h"
+#include "lldb/Interpreter/Options.h"
+#include "lldb/Interpreter/ScriptInterpreterNone.h"
+#include "lldb/Interpreter/ScriptInterpreterPython.h"
+
+
+#include "lldb/Target/Process.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Target/TargetList.h"
+
+#include "lldb/Utility/CleanUp.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+
+static PropertyDefinition
+g_properties[] =
+{
+    { "expand-regex-aliases", OptionValue::eTypeBoolean, true, false, NULL, NULL, "If true, regular expression alias commands will show the expanded command that will be executed. This can be used to debug new regular expression alias commands." },
+    { "prompt-on-quit", OptionValue::eTypeBoolean, true, true, NULL, NULL, "If true, LLDB will prompt you before quitting if there are any live processes being debugged. If false, LLDB will quit without asking in any case." },
+    { "stop-command-source-on-error", OptionValue::eTypeBoolean, true, true, NULL, NULL, "If true, LLDB will stop running a 'command source' script upon encountering an error." },
+    { NULL                  , OptionValue::eTypeInvalid, true, 0    , NULL, NULL, NULL }
+};
+
+enum
+{
+    ePropertyExpandRegexAliases = 0,
+    ePropertyPromptOnQuit = 1,
+    ePropertyStopCmdSourceOnError = 2
+};
+
+ConstString &
+CommandInterpreter::GetStaticBroadcasterClass ()
+{
+    static ConstString class_name ("lldb.commandInterpreter");
+    return class_name;
+}
+
+CommandInterpreter::CommandInterpreter
+(
+    Debugger &debugger,
+    ScriptLanguage script_language,
+    bool synchronous_execution
+) :
+    Broadcaster (&debugger, "lldb.command-interpreter"),
+    Properties(OptionValuePropertiesSP(new OptionValueProperties(ConstString("interpreter")))),
+    m_debugger (debugger),
+    m_synchronous_execution (synchronous_execution),
+    m_skip_lldbinit_files (false),
+    m_skip_app_init_files (false),
+    m_script_interpreter_ap (),
+    m_comment_char ('#'),
+    m_batch_command_mode (false),
+    m_truncation_warning(eNoTruncation),
+    m_command_source_depth (0)
+{
+    debugger.SetScriptLanguage (script_language);
+    SetEventName (eBroadcastBitThreadShouldExit, "thread-should-exit");
+    SetEventName (eBroadcastBitResetPrompt, "reset-prompt");
+    SetEventName (eBroadcastBitQuitCommandReceived, "quit");    
+    CheckInWithManager ();
+    m_collection_sp->Initialize (g_properties);
+}
+
+bool
+CommandInterpreter::GetExpandRegexAliases () const
+{
+    const uint32_t idx = ePropertyExpandRegexAliases;
+    return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
+}
+
+bool
+CommandInterpreter::GetPromptOnQuit () const
+{
+    const uint32_t idx = ePropertyPromptOnQuit;
+    return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
+}
+
+bool
+CommandInterpreter::GetStopCmdSourceOnError () const
+{
+    const uint32_t idx = ePropertyStopCmdSourceOnError;
+    return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
+}
+
+void
+CommandInterpreter::Initialize ()
+{
+    Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
+
+    CommandReturnObject result;
+
+    LoadCommandDictionary ();
+
+    // Set up some initial aliases.
+    CommandObjectSP cmd_obj_sp = GetCommandSPExact ("quit", false);
+    if (cmd_obj_sp)
+    {
+        AddAlias ("q", cmd_obj_sp);
+        AddAlias ("exit", cmd_obj_sp);
+    }
+    
+    cmd_obj_sp = GetCommandSPExact ("_regexp-attach",false);
+    if (cmd_obj_sp)
+    {
+        AddAlias ("attach", cmd_obj_sp);
+    }
+
+    cmd_obj_sp = GetCommandSPExact ("process detach",false);
+    if (cmd_obj_sp)
+    {
+        AddAlias ("detach", cmd_obj_sp);
+    }
+
+    cmd_obj_sp = GetCommandSPExact ("process continue", false);
+    if (cmd_obj_sp)
+    {
+        AddAlias ("c", cmd_obj_sp);
+        AddAlias ("continue", cmd_obj_sp);
+    }
+
+    cmd_obj_sp = GetCommandSPExact ("_regexp-break",false);
+    if (cmd_obj_sp)
+        AddAlias ("b", cmd_obj_sp);
+
+    cmd_obj_sp = GetCommandSPExact ("_regexp-tbreak",false);
+    if (cmd_obj_sp)
+        AddAlias ("tbreak", cmd_obj_sp);
+
+    cmd_obj_sp = GetCommandSPExact ("thread step-inst", false);
+    if (cmd_obj_sp)
+    {
+        AddAlias ("stepi", cmd_obj_sp);
+        AddAlias ("si", cmd_obj_sp);
+    }
+
+    cmd_obj_sp = GetCommandSPExact ("thread step-inst-over", false);
+    if (cmd_obj_sp)
+    {
+        AddAlias ("nexti", cmd_obj_sp);
+        AddAlias ("ni", cmd_obj_sp);
+    }
+
+    cmd_obj_sp = GetCommandSPExact ("thread step-in", false);
+    if (cmd_obj_sp)
+    {
+        AddAlias ("s", cmd_obj_sp);
+        AddAlias ("step", cmd_obj_sp);
+    }
+
+    cmd_obj_sp = GetCommandSPExact ("thread step-over", false);
+    if (cmd_obj_sp)
+    {
+        AddAlias ("n", cmd_obj_sp);
+        AddAlias ("next", cmd_obj_sp);
+    }
+
+    cmd_obj_sp = GetCommandSPExact ("thread step-out", false);
+    if (cmd_obj_sp)
+    {
+        AddAlias ("finish", cmd_obj_sp);
+    }
+
+    cmd_obj_sp = GetCommandSPExact ("frame select", false);
+    if (cmd_obj_sp)
+    {
+        AddAlias ("f", cmd_obj_sp);
+    }
+
+    cmd_obj_sp = GetCommandSPExact ("thread select", false);
+    if (cmd_obj_sp)
+    {
+        AddAlias ("t", cmd_obj_sp);
+    }
+
+    cmd_obj_sp = GetCommandSPExact ("_regexp-list", false);
+    if (cmd_obj_sp)
+    {
+        AddAlias ("l", cmd_obj_sp);
+        AddAlias ("list", cmd_obj_sp);
+    }
+
+    cmd_obj_sp = GetCommandSPExact ("_regexp-env", false);
+    if (cmd_obj_sp)
+    {
+        AddAlias ("env", cmd_obj_sp);
+    }
+
+    cmd_obj_sp = GetCommandSPExact ("memory read", false);
+    if (cmd_obj_sp)
+        AddAlias ("x", cmd_obj_sp);
+
+    cmd_obj_sp = GetCommandSPExact ("_regexp-up", false);
+    if (cmd_obj_sp)
+        AddAlias ("up", cmd_obj_sp);
+
+    cmd_obj_sp = GetCommandSPExact ("_regexp-down", false);
+    if (cmd_obj_sp)
+        AddAlias ("down", cmd_obj_sp);
+
+    cmd_obj_sp = GetCommandSPExact ("_regexp-display", false);
+    if (cmd_obj_sp)
+        AddAlias ("display", cmd_obj_sp);
+        
+    cmd_obj_sp = GetCommandSPExact ("disassemble", false);
+    if (cmd_obj_sp)
+        AddAlias ("dis", cmd_obj_sp);
+
+    cmd_obj_sp = GetCommandSPExact ("disassemble", false);
+    if (cmd_obj_sp)
+        AddAlias ("di", cmd_obj_sp);
+
+
+
+    cmd_obj_sp = GetCommandSPExact ("_regexp-undisplay", false);
+    if (cmd_obj_sp)
+        AddAlias ("undisplay", cmd_obj_sp);
+
+    cmd_obj_sp = GetCommandSPExact ("_regexp-bt", false);
+    if (cmd_obj_sp)
+        AddAlias ("bt", cmd_obj_sp);
+
+    cmd_obj_sp = GetCommandSPExact ("target create", false);
+    if (cmd_obj_sp)
+        AddAlias ("file", cmd_obj_sp);
+
+    cmd_obj_sp = GetCommandSPExact ("target modules", false);
+    if (cmd_obj_sp)
+        AddAlias ("image", cmd_obj_sp);
+
+
+    OptionArgVectorSP alias_arguments_vector_sp (new OptionArgVector);
+    
+    cmd_obj_sp = GetCommandSPExact ("expression", false);
+    if (cmd_obj_sp)
+    {        
+        ProcessAliasOptionsArgs (cmd_obj_sp, "--", alias_arguments_vector_sp);
+        AddAlias ("p", cmd_obj_sp);
+        AddAlias ("print", cmd_obj_sp);
+        AddAlias ("call", cmd_obj_sp);
+        AddOrReplaceAliasOptions ("p", alias_arguments_vector_sp);
+        AddOrReplaceAliasOptions ("print", alias_arguments_vector_sp);
+        AddOrReplaceAliasOptions ("call", alias_arguments_vector_sp);
+
+        alias_arguments_vector_sp.reset (new OptionArgVector);
+        ProcessAliasOptionsArgs (cmd_obj_sp, "-O -- ", alias_arguments_vector_sp);
+        AddAlias ("po", cmd_obj_sp);
+        AddOrReplaceAliasOptions ("po", alias_arguments_vector_sp);
+    }
+    
+    cmd_obj_sp = GetCommandSPExact ("process kill", false);
+    if (cmd_obj_sp)
+    {
+        AddAlias ("kill", cmd_obj_sp);
+    }
+    
+    cmd_obj_sp = GetCommandSPExact ("process launch", false);
+    if (cmd_obj_sp)
+    {
+        alias_arguments_vector_sp.reset (new OptionArgVector);
+#if defined (__arm__)
+        ProcessAliasOptionsArgs (cmd_obj_sp, "--", alias_arguments_vector_sp);
+#else
+        ProcessAliasOptionsArgs (cmd_obj_sp, "--shell=/bin/bash --", alias_arguments_vector_sp);
+#endif
+        AddAlias ("r", cmd_obj_sp);
+        AddAlias ("run", cmd_obj_sp);
+        AddOrReplaceAliasOptions ("r", alias_arguments_vector_sp);
+        AddOrReplaceAliasOptions ("run", alias_arguments_vector_sp);
+    }
+    
+    cmd_obj_sp = GetCommandSPExact ("target symbols add", false);
+    if (cmd_obj_sp)
+    {
+        AddAlias ("add-dsym", cmd_obj_sp);
+    }
+    
+    cmd_obj_sp = GetCommandSPExact ("breakpoint set", false);
+    if (cmd_obj_sp)
+    {
+        alias_arguments_vector_sp.reset (new OptionArgVector);
+        ProcessAliasOptionsArgs (cmd_obj_sp, "--func-regex %1", alias_arguments_vector_sp);
+        AddAlias ("rbreak", cmd_obj_sp);
+        AddOrReplaceAliasOptions("rbreak", alias_arguments_vector_sp);
+    }
+}
+
+const char *
+CommandInterpreter::ProcessEmbeddedScriptCommands (const char *arg)
+{
+    // This function has not yet been implemented.
+
+    // Look for any embedded script command
+    // If found,
+    //    get interpreter object from the command dictionary,
+    //    call execute_one_command on it,
+    //    get the results as a string,
+    //    substitute that string for current stuff.
+
+    return arg;
+}
+
+
+void
+CommandInterpreter::LoadCommandDictionary ()
+{
+    Timer scoped_timer (__PRETTY_FUNCTION__, __PRETTY_FUNCTION__);
+
+    lldb::ScriptLanguage script_language = m_debugger.GetScriptLanguage();
+    
+    m_command_dict["apropos"]   = CommandObjectSP (new CommandObjectApropos (*this));
+    m_command_dict["breakpoint"]= CommandObjectSP (new CommandObjectMultiwordBreakpoint (*this));
+    m_command_dict["command"]   = CommandObjectSP (new CommandObjectMultiwordCommands (*this));
+    m_command_dict["disassemble"] = CommandObjectSP (new CommandObjectDisassemble (*this));
+    m_command_dict["expression"]= CommandObjectSP (new CommandObjectExpression (*this));
+    m_command_dict["frame"]     = CommandObjectSP (new CommandObjectMultiwordFrame (*this));
+    m_command_dict["help"]      = CommandObjectSP (new CommandObjectHelp (*this));
+    m_command_dict["log"]       = CommandObjectSP (new CommandObjectLog (*this));
+    m_command_dict["memory"]    = CommandObjectSP (new CommandObjectMemory (*this));
+    m_command_dict["platform"]  = CommandObjectSP (new CommandObjectPlatform (*this));
+    m_command_dict["plugin"]    = CommandObjectSP (new CommandObjectPlugin (*this));
+    m_command_dict["process"]   = CommandObjectSP (new CommandObjectMultiwordProcess (*this));
+    m_command_dict["quit"]      = CommandObjectSP (new CommandObjectQuit (*this));
+    m_command_dict["register"]  = CommandObjectSP (new CommandObjectRegister (*this));
+    m_command_dict["script"]    = CommandObjectSP (new CommandObjectScript (*this, script_language));
+    m_command_dict["settings"]  = CommandObjectSP (new CommandObjectMultiwordSettings (*this));
+    m_command_dict["source"]    = CommandObjectSP (new CommandObjectMultiwordSource (*this));
+    m_command_dict["target"]    = CommandObjectSP (new CommandObjectMultiwordTarget (*this));
+    m_command_dict["thread"]    = CommandObjectSP (new CommandObjectMultiwordThread (*this));
+    m_command_dict["type"]      = CommandObjectSP (new CommandObjectType (*this));
+    m_command_dict["version"]   = CommandObjectSP (new CommandObjectVersion (*this));
+    m_command_dict["watchpoint"]= CommandObjectSP (new CommandObjectMultiwordWatchpoint (*this));
+
+    const char *break_regexes[][2] = {{"^(.*[^[:space:]])[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]]*$", "breakpoint set --file '%1' --line %2"},
+                                      {"^([[:digit:]]+)[[:space:]]*$", "breakpoint set --line %1"},
+                                      {"^\\*?(0x[[:xdigit:]]+)[[:space:]]*$", "breakpoint set --address %1"},
+                                      {"^[\"']?([-+]?\\[.*\\])[\"']?[[:space:]]*$", "breakpoint set --name '%1'"},
+                                      {"^(-.*)$", "breakpoint set %1"},
+                                      {"^(.*[^[:space:]])`(.*[^[:space:]])[[:space:]]*$", "breakpoint set --name '%2' --shlib '%1'"},
+                                      {"^\\&(.*[^[:space:]])[[:space:]]*$", "breakpoint set --name '%1' --skip-prologue=0"},
+                                      {"^(.*[^[:space:]])[[:space:]]*$", "breakpoint set --name '%1'"}};
+    
+    size_t num_regexes = sizeof break_regexes/sizeof(char *[2]);
+        
+    std::unique_ptr<CommandObjectRegexCommand>
+    break_regex_cmd_ap(new CommandObjectRegexCommand (*this,
+                                                      "_regexp-break",
+                                                      "Set a breakpoint using a regular expression to specify the location, where <linenum> is in decimal and <address> is in hex.",
+                                                      "_regexp-break [<filename>:<linenum>]\n_regexp-break [<linenum>]\n_regexp-break [<address>]\n_regexp-break <...>",
+                                                      2,
+                                                      CommandCompletions::eSymbolCompletion |
+                                                      CommandCompletions::eSourceFileCompletion));
+
+    if (break_regex_cmd_ap.get())
+    {
+        bool success = true;
+        for (size_t i = 0; i < num_regexes; i++)
+        {
+            success = break_regex_cmd_ap->AddRegexCommand (break_regexes[i][0], break_regexes[i][1]);
+            if (!success)
+                break;
+        }
+        success = break_regex_cmd_ap->AddRegexCommand("^$", "breakpoint list --full");
+
+        if (success)
+        {
+            CommandObjectSP break_regex_cmd_sp(break_regex_cmd_ap.release());
+            m_command_dict[break_regex_cmd_sp->GetCommandName ()] = break_regex_cmd_sp;
+        }
+    }
+
+    std::unique_ptr<CommandObjectRegexCommand>
+    tbreak_regex_cmd_ap(new CommandObjectRegexCommand (*this,
+                                                      "_regexp-tbreak",
+                                                      "Set a one shot breakpoint using a regular expression to specify the location, where <linenum> is in decimal and <address> is in hex.",
+                                                      "_regexp-tbreak [<filename>:<linenum>]\n_regexp-break [<linenum>]\n_regexp-break [<address>]\n_regexp-break <...>",
+                                                       2,
+                                                       CommandCompletions::eSymbolCompletion |
+                                                       CommandCompletions::eSourceFileCompletion));
+
+    if (tbreak_regex_cmd_ap.get())
+    {
+        bool success = true;
+        for (size_t i = 0; i < num_regexes; i++)
+        {
+            // If you add a resultant command string longer than 1024 characters be sure to increase the size of this buffer.
+            char buffer[1024];
+            int num_printed = snprintf(buffer, 1024, "%s %s", break_regexes[i][1], "-o");
+            assert (num_printed < 1024);
+            success = tbreak_regex_cmd_ap->AddRegexCommand (break_regexes[i][0], buffer);
+            if (!success)
+                break;
+        }
+        success = tbreak_regex_cmd_ap->AddRegexCommand("^$", "breakpoint list --full");
+
+        if (success)
+        {
+            CommandObjectSP tbreak_regex_cmd_sp(tbreak_regex_cmd_ap.release());
+            m_command_dict[tbreak_regex_cmd_sp->GetCommandName ()] = tbreak_regex_cmd_sp;
+        }
+    }
+
+    std::unique_ptr<CommandObjectRegexCommand>
+    attach_regex_cmd_ap(new CommandObjectRegexCommand (*this,
+                                                       "_regexp-attach",
+                                                       "Attach to a process id if in decimal, otherwise treat the argument as a process name to attach to.",
+                                                       "_regexp-attach [<pid>]\n_regexp-attach [<process-name>]",
+                                                       2));
+    if (attach_regex_cmd_ap.get())
+    {
+        if (attach_regex_cmd_ap->AddRegexCommand("^([0-9]+)[[:space:]]*$", "process attach --pid %1") &&
+            attach_regex_cmd_ap->AddRegexCommand("^(-.*|.* -.*)$", "process attach %1") && // Any options that are specified get passed to 'process attach'
+            attach_regex_cmd_ap->AddRegexCommand("^(.+)$", "process attach --name '%1'") &&
+            attach_regex_cmd_ap->AddRegexCommand("^$", "process attach"))
+        {
+            CommandObjectSP attach_regex_cmd_sp(attach_regex_cmd_ap.release());
+            m_command_dict[attach_regex_cmd_sp->GetCommandName ()] = attach_regex_cmd_sp;
+        }
+    }
+    
+    std::unique_ptr<CommandObjectRegexCommand>
+    down_regex_cmd_ap(new CommandObjectRegexCommand (*this,
+                                                     "_regexp-down",
+                                                     "Go down \"n\" frames in the stack (1 frame by default).",
+                                                     "_regexp-down [n]", 2));
+    if (down_regex_cmd_ap.get())
+    {
+        if (down_regex_cmd_ap->AddRegexCommand("^$", "frame select -r -1") &&
+            down_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", "frame select -r -%1"))
+        {
+            CommandObjectSP down_regex_cmd_sp(down_regex_cmd_ap.release());
+            m_command_dict[down_regex_cmd_sp->GetCommandName ()] = down_regex_cmd_sp;
+        }
+    }
+    
+    std::unique_ptr<CommandObjectRegexCommand>
+    up_regex_cmd_ap(new CommandObjectRegexCommand (*this,
+                                                   "_regexp-up",
+                                                   "Go up \"n\" frames in the stack (1 frame by default).",
+                                                   "_regexp-up [n]", 2));
+    if (up_regex_cmd_ap.get())
+    {
+        if (up_regex_cmd_ap->AddRegexCommand("^$", "frame select -r 1") &&
+            up_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", "frame select -r %1"))
+        {
+            CommandObjectSP up_regex_cmd_sp(up_regex_cmd_ap.release());
+            m_command_dict[up_regex_cmd_sp->GetCommandName ()] = up_regex_cmd_sp;
+        }
+    }
+
+    std::unique_ptr<CommandObjectRegexCommand>
+    display_regex_cmd_ap(new CommandObjectRegexCommand (*this,
+                                                        "_regexp-display",
+                                                        "Add an expression evaluation stop-hook.",
+                                                        "_regexp-display expression", 2));
+    if (display_regex_cmd_ap.get())
+    {
+        if (display_regex_cmd_ap->AddRegexCommand("^(.+)$", "target stop-hook add -o \"expr -- %1\""))
+        {
+            CommandObjectSP display_regex_cmd_sp(display_regex_cmd_ap.release());
+            m_command_dict[display_regex_cmd_sp->GetCommandName ()] = display_regex_cmd_sp;
+        }
+    }
+
+    std::unique_ptr<CommandObjectRegexCommand>
+    undisplay_regex_cmd_ap(new CommandObjectRegexCommand (*this,
+                                                          "_regexp-undisplay",
+                                                          "Remove an expression evaluation stop-hook.",
+                                                          "_regexp-undisplay stop-hook-number", 2));
+    if (undisplay_regex_cmd_ap.get())
+    {
+        if (undisplay_regex_cmd_ap->AddRegexCommand("^([0-9]+)$", "target stop-hook delete %1"))
+        {
+            CommandObjectSP undisplay_regex_cmd_sp(undisplay_regex_cmd_ap.release());
+            m_command_dict[undisplay_regex_cmd_sp->GetCommandName ()] = undisplay_regex_cmd_sp;
+        }
+    }
+
+    std::unique_ptr<CommandObjectRegexCommand>
+    connect_gdb_remote_cmd_ap(new CommandObjectRegexCommand (*this,
+                                                             "gdb-remote",
+                                                             "Connect to a remote GDB server.  If no hostname is provided, localhost is assumed.",
+                                                             "gdb-remote [<hostname>:]<portnum>", 2));
+    if (connect_gdb_remote_cmd_ap.get())
+    {
+        if (connect_gdb_remote_cmd_ap->AddRegexCommand("^([^:]+:[[:digit:]]+)$", "process connect --plugin gdb-remote connect://%1") &&
+            connect_gdb_remote_cmd_ap->AddRegexCommand("^([[:digit:]]+)$", "process connect --plugin gdb-remote connect://localhost:%1"))
+        {
+            CommandObjectSP command_sp(connect_gdb_remote_cmd_ap.release());
+            m_command_dict[command_sp->GetCommandName ()] = command_sp;
+        }
+    }
+
+    std::unique_ptr<CommandObjectRegexCommand>
+    connect_kdp_remote_cmd_ap(new CommandObjectRegexCommand (*this,
+                                                             "kdp-remote",
+                                                             "Connect to a remote KDP server.  udp port 41139 is the default port number.",
+                                                             "kdp-remote <hostname>[:<portnum>]", 2));
+    if (connect_kdp_remote_cmd_ap.get())
+    {
+        if (connect_kdp_remote_cmd_ap->AddRegexCommand("^([^:]+:[[:digit:]]+)$", "process connect --plugin kdp-remote udp://%1") &&
+            connect_kdp_remote_cmd_ap->AddRegexCommand("^(.+)$", "process connect --plugin kdp-remote udp://%1:41139"))
+        {
+            CommandObjectSP command_sp(connect_kdp_remote_cmd_ap.release());
+            m_command_dict[command_sp->GetCommandName ()] = command_sp;
+        }
+    }
+
+    std::unique_ptr<CommandObjectRegexCommand>
+    bt_regex_cmd_ap(new CommandObjectRegexCommand (*this,
+                                                     "_regexp-bt",
+                                                     "Show a backtrace.  An optional argument is accepted; if that argument is a number, it specifies the number of frames to display.  If that argument is 'all', full backtraces of all threads are displayed.",
+                                                     "bt [<digit>|all]", 2));
+    if (bt_regex_cmd_ap.get())
+    {
+        // accept but don't document "bt -c <number>" -- before bt was a regex command if you wanted to backtrace
+        // three frames you would do "bt -c 3" but the intention is to have this emulate the gdb "bt" command and
+        // so now "bt 3" is the preferred form, in line with gdb.
+        if (bt_regex_cmd_ap->AddRegexCommand("^([[:digit:]]+)$", "thread backtrace -c %1") &&
+            bt_regex_cmd_ap->AddRegexCommand("^-c ([[:digit:]]+)$", "thread backtrace -c %1") &&
+            bt_regex_cmd_ap->AddRegexCommand("^all$", "thread backtrace all") &&
+            bt_regex_cmd_ap->AddRegexCommand("^$", "thread backtrace"))
+        {
+            CommandObjectSP command_sp(bt_regex_cmd_ap.release());
+            m_command_dict[command_sp->GetCommandName ()] = command_sp;
+        }
+    }
+
+    std::unique_ptr<CommandObjectRegexCommand>
+    list_regex_cmd_ap(new CommandObjectRegexCommand (*this,
+                                                     "_regexp-list",
+                                                     "Implements the GDB 'list' command in all of its forms except FILE:FUNCTION and maps them to the appropriate 'source list' commands.",
+                                                     "_regexp-list [<line>]\n_regexp-attach [<file>:<line>]\n_regexp-attach [<file>:<line>]",
+                                                     2,
+                                                     CommandCompletions::eSourceFileCompletion));
+    if (list_regex_cmd_ap.get())
+    {
+        if (list_regex_cmd_ap->AddRegexCommand("^([0-9]+)[[:space:]]*$", "source list --line %1") &&
+            list_regex_cmd_ap->AddRegexCommand("^(.*[^[:space:]])[[:space:]]*:[[:space:]]*([[:digit:]]+)[[:space:]]*$", "source list --file '%1' --line %2") &&
+            list_regex_cmd_ap->AddRegexCommand("^\\*?(0x[[:xdigit:]]+)[[:space:]]*$", "source list --address %1") &&
+            list_regex_cmd_ap->AddRegexCommand("^-[[:space:]]*$", "source list --reverse") &&
+            list_regex_cmd_ap->AddRegexCommand("^-([[:digit:]]+)[[:space:]]*$", "source list --reverse --count %1") &&
+            list_regex_cmd_ap->AddRegexCommand("^(.+)$", "source list --name \"%1\"") &&
+            list_regex_cmd_ap->AddRegexCommand("^$", "source list"))
+        {
+            CommandObjectSP list_regex_cmd_sp(list_regex_cmd_ap.release());
+            m_command_dict[list_regex_cmd_sp->GetCommandName ()] = list_regex_cmd_sp;
+        }
+    }
+
+    std::unique_ptr<CommandObjectRegexCommand>
+    env_regex_cmd_ap(new CommandObjectRegexCommand (*this,
+                                                    "_regexp-env",
+                                                    "Implements a shortcut to viewing and setting environment variables.",
+                                                    "_regexp-env\n_regexp-env FOO=BAR", 2));
+    if (env_regex_cmd_ap.get())
+    {
+        if (env_regex_cmd_ap->AddRegexCommand("^$", "settings show target.env-vars") &&
+            env_regex_cmd_ap->AddRegexCommand("^([A-Za-z_][A-Za-z_0-9]*=.*)$", "settings set target.env-vars %1"))
+        {
+            CommandObjectSP env_regex_cmd_sp(env_regex_cmd_ap.release());
+            m_command_dict[env_regex_cmd_sp->GetCommandName ()] = env_regex_cmd_sp;
+        }
+    }
+
+}
+
+int
+CommandInterpreter::GetCommandNamesMatchingPartialString (const char *cmd_str, bool include_aliases,
+                                                          StringList &matches)
+{
+    CommandObject::AddNamesMatchingPartialString (m_command_dict, cmd_str, matches);
+
+    if (include_aliases)
+    {
+        CommandObject::AddNamesMatchingPartialString (m_alias_dict, cmd_str, matches);
+    }
+
+    return matches.GetSize();
+}
+
+CommandObjectSP
+CommandInterpreter::GetCommandSP (const char *cmd_cstr, bool include_aliases, bool exact, StringList *matches)
+{
+    CommandObject::CommandMap::iterator pos;
+    CommandObjectSP command_sp;
+
+    std::string cmd(cmd_cstr);
+
+    if (HasCommands())
+    {
+        pos = m_command_dict.find(cmd);
+        if (pos != m_command_dict.end())
+            command_sp = pos->second;
+    }
+
+    if (include_aliases && HasAliases())
+    {
+        pos = m_alias_dict.find(cmd);
+        if (pos != m_alias_dict.end())
+            command_sp = pos->second;
+    }
+
+    if (HasUserCommands())
+    {
+        pos = m_user_dict.find(cmd);
+        if (pos != m_user_dict.end())
+            command_sp = pos->second;
+    }
+
+    if (!exact && !command_sp)
+    {
+        // We will only get into here if we didn't find any exact matches.
+        
+        CommandObjectSP user_match_sp, alias_match_sp, real_match_sp;
+
+        StringList local_matches;
+        if (matches == NULL)
+            matches = &local_matches;
+
+        unsigned int num_cmd_matches = 0;
+        unsigned int num_alias_matches = 0;
+        unsigned int num_user_matches = 0;
+        
+        // Look through the command dictionaries one by one, and if we get only one match from any of
+        // them in toto, then return that, otherwise return an empty CommandObjectSP and the list of matches.
+        
+        if (HasCommands())
+        {
+            num_cmd_matches = CommandObject::AddNamesMatchingPartialString (m_command_dict, cmd_cstr, *matches);
+        }
+
+        if (num_cmd_matches == 1)
+        {
+            cmd.assign(matches->GetStringAtIndex(0));
+            pos = m_command_dict.find(cmd);
+            if (pos != m_command_dict.end())
+                real_match_sp = pos->second;
+        }
+
+        if (include_aliases && HasAliases())
+        {
+            num_alias_matches = CommandObject::AddNamesMatchingPartialString (m_alias_dict, cmd_cstr, *matches);
+
+        }
+
+        if (num_alias_matches == 1)
+        {
+            cmd.assign(matches->GetStringAtIndex (num_cmd_matches));
+            pos = m_alias_dict.find(cmd);
+            if (pos != m_alias_dict.end())
+                alias_match_sp = pos->second;
+        }
+
+        if (HasUserCommands())
+        {
+            num_user_matches = CommandObject::AddNamesMatchingPartialString (m_user_dict, cmd_cstr, *matches);
+        }
+
+        if (num_user_matches == 1)
+        {
+            cmd.assign (matches->GetStringAtIndex (num_cmd_matches + num_alias_matches));
+
+            pos = m_user_dict.find (cmd);
+            if (pos != m_user_dict.end())
+                user_match_sp = pos->second;
+        }
+        
+        // If we got exactly one match, return that, otherwise return the match list.
+        
+        if (num_user_matches + num_cmd_matches + num_alias_matches == 1)
+        {
+            if (num_cmd_matches)
+                return real_match_sp;
+            else if (num_alias_matches)
+                return alias_match_sp;
+            else
+                return user_match_sp;
+        }
+    }
+    else if (matches && command_sp)
+    {
+        matches->AppendString (cmd_cstr);
+    }
+
+
+    return command_sp;
+}
+
+bool
+CommandInterpreter::AddCommand (const char *name, const lldb::CommandObjectSP &cmd_sp, bool can_replace)
+{
+    if (name && name[0])
+    {
+        std::string name_sstr(name);
+        bool found = (m_command_dict.find (name_sstr) != m_command_dict.end());
+        if (found && !can_replace)
+            return false;
+        if (found && m_command_dict[name_sstr]->IsRemovable() == false)
+            return false;
+        m_command_dict[name_sstr] = cmd_sp;
+        return true;
+    }
+    return false;
+}
+
+bool
+CommandInterpreter::AddUserCommand (std::string name, 
+                                    const lldb::CommandObjectSP &cmd_sp,
+                                    bool can_replace)
+{
+    if (!name.empty())
+    {
+        
+        const char* name_cstr = name.c_str();
+        
+        // do not allow replacement of internal commands
+        if (CommandExists(name_cstr))
+        {
+            if (can_replace == false)
+                return false;
+            if (m_command_dict[name]->IsRemovable() == false)
+                return false;
+        }
+        
+        if (UserCommandExists(name_cstr))
+        {
+            if (can_replace == false)
+                return false;
+            if (m_user_dict[name]->IsRemovable() == false)
+                return false;
+        }
+        
+        m_user_dict[name] = cmd_sp;
+        return true;
+    }
+    return false;
+}
+
+CommandObjectSP
+CommandInterpreter::GetCommandSPExact (const char *cmd_cstr, bool include_aliases)
+{
+    Args cmd_words (cmd_cstr); // Break up the command string into words, in case it's a multi-word command.
+    CommandObjectSP ret_val;   // Possibly empty return value.
+    
+    if (cmd_cstr == NULL)
+        return ret_val;
+    
+    if (cmd_words.GetArgumentCount() == 1)
+        return GetCommandSP(cmd_cstr, include_aliases, true, NULL);
+    else
+    {
+        // We have a multi-word command (seemingly), so we need to do more work.
+        // First, get the cmd_obj_sp for the first word in the command.
+        CommandObjectSP cmd_obj_sp = GetCommandSP (cmd_words.GetArgumentAtIndex (0), include_aliases, true, NULL);
+        if (cmd_obj_sp.get() != NULL)
+        {
+            // Loop through the rest of the words in the command (everything passed in was supposed to be part of a 
+            // command name), and find the appropriate sub-command SP for each command word....
+            size_t end = cmd_words.GetArgumentCount();
+            for (size_t j= 1; j < end; ++j)
+            {
+                if (cmd_obj_sp->IsMultiwordObject())
+                {
+                    cmd_obj_sp = cmd_obj_sp->GetSubcommandSP (cmd_words.GetArgumentAtIndex (j));
+                    if (cmd_obj_sp.get() == NULL)
+                        // The sub-command name was invalid.  Fail and return the empty 'ret_val'.
+                        return ret_val;
+                }
+                else
+                    // We have more words in the command name, but we don't have a multiword object. Fail and return 
+                    // empty 'ret_val'.
+                    return ret_val;
+            }
+            // We successfully looped through all the command words and got valid command objects for them.  Assign the 
+            // last object retrieved to 'ret_val'.
+            ret_val = cmd_obj_sp;
+        }
+    }
+    return ret_val;
+}
+
+CommandObject *
+CommandInterpreter::GetCommandObjectExact (const char *cmd_cstr, bool include_aliases)
+{
+    return GetCommandSPExact (cmd_cstr, include_aliases).get();
+}
+
+CommandObject *
+CommandInterpreter::GetCommandObject (const char *cmd_cstr, StringList *matches)
+{
+    CommandObject *command_obj = GetCommandSP (cmd_cstr, false, true, matches).get();
+
+    // If we didn't find an exact match to the command string in the commands, look in
+    // the aliases.
+    
+    if (command_obj)
+        return command_obj;
+
+    command_obj = GetCommandSP (cmd_cstr, true, true, matches).get();
+
+    if (command_obj)
+        return command_obj;
+    
+    // If there wasn't an exact match then look for an inexact one in just the commands
+    command_obj = GetCommandSP(cmd_cstr, false, false, NULL).get();
+
+    // Finally, if there wasn't an inexact match among the commands, look for an inexact
+    // match in both the commands and aliases.
+    
+    if (command_obj)
+    {
+        if (matches)
+            matches->AppendString(command_obj->GetCommandName());
+        return command_obj;
+    }
+    
+    return GetCommandSP(cmd_cstr, true, false, matches).get();
+}
+
+bool
+CommandInterpreter::CommandExists (const char *cmd)
+{
+    return m_command_dict.find(cmd) != m_command_dict.end();
+}
+
+bool
+CommandInterpreter::ProcessAliasOptionsArgs (lldb::CommandObjectSP &cmd_obj_sp, 
+                                            const char *options_args, 
+                                            OptionArgVectorSP &option_arg_vector_sp)
+{
+    bool success = true;
+    OptionArgVector *option_arg_vector = option_arg_vector_sp.get();
+    
+    if (!options_args || (strlen (options_args) < 1))
+        return true;
+
+    std::string options_string (options_args);
+    Args args (options_args);
+    CommandReturnObject result;
+    // Check to see if the command being aliased can take any command options.
+    Options *options = cmd_obj_sp->GetOptions ();
+    if (options)
+    {
+        // See if any options were specified as part of the alias;  if so, handle them appropriately.
+        options->NotifyOptionParsingStarting ();
+        args.Unshift ("dummy_arg");
+        args.ParseAliasOptions (*options, result, option_arg_vector, options_string);
+        args.Shift ();
+        if (result.Succeeded())
+            options->VerifyPartialOptions (result);
+        if (!result.Succeeded() && result.GetStatus() != lldb::eReturnStatusStarted)
+        {
+            result.AppendError ("Unable to create requested alias.\n");
+            return false;
+        }
+    }
+    
+    if (!options_string.empty())
+    {
+        if (cmd_obj_sp->WantsRawCommandString ())
+            option_arg_vector->push_back (OptionArgPair ("<argument>",
+                                                          OptionArgValue (-1,
+                                                                          options_string)));
+        else
+        {
+            const size_t argc = args.GetArgumentCount();
+            for (size_t i = 0; i < argc; ++i)
+                if (strcmp (args.GetArgumentAtIndex (i), "") != 0)
+                    option_arg_vector->push_back 
+                                (OptionArgPair ("<argument>",
+                                                OptionArgValue (-1,
+                                                                std::string (args.GetArgumentAtIndex (i)))));
+        }
+    }
+        
+    return success;
+}
+
+bool
+CommandInterpreter::GetAliasFullName (const char *cmd, std::string &full_name)
+{
+    bool exact_match  = (m_alias_dict.find(cmd) != m_alias_dict.end());
+    if (exact_match)
+    {
+        full_name.assign(cmd);
+        return exact_match;
+    }
+    else
+    {
+        StringList matches;
+        size_t num_alias_matches;
+        num_alias_matches = CommandObject::AddNamesMatchingPartialString (m_alias_dict, cmd, matches);
+        if (num_alias_matches == 1)
+        {
+            // Make sure this isn't shadowing a command in the regular command space:
+            StringList regular_matches;
+            const bool include_aliases = false;
+            const bool exact = false;
+            CommandObjectSP cmd_obj_sp(GetCommandSP (cmd, include_aliases, exact, &regular_matches));
+            if (cmd_obj_sp || regular_matches.GetSize() > 0)
+                return false;
+            else
+            {
+                full_name.assign (matches.GetStringAtIndex(0));
+                return true;
+            }
+        }
+        else
+            return false;
+    }
+}
+
+bool
+CommandInterpreter::AliasExists (const char *cmd)
+{
+    return m_alias_dict.find(cmd) != m_alias_dict.end();
+}
+
+bool
+CommandInterpreter::UserCommandExists (const char *cmd)
+{
+    return m_user_dict.find(cmd) != m_user_dict.end();
+}
+
+void
+CommandInterpreter::AddAlias (const char *alias_name, CommandObjectSP& command_obj_sp)
+{
+    command_obj_sp->SetIsAlias (true);
+    m_alias_dict[alias_name] = command_obj_sp;
+}
+
+bool
+CommandInterpreter::RemoveAlias (const char *alias_name)
+{
+    CommandObject::CommandMap::iterator pos = m_alias_dict.find(alias_name);
+    if (pos != m_alias_dict.end())
+    {
+        m_alias_dict.erase(pos);
+        return true;
+    }
+    return false;
+}
+bool
+CommandInterpreter::RemoveUser (const char *alias_name)
+{
+    CommandObject::CommandMap::iterator pos = m_user_dict.find(alias_name);
+    if (pos != m_user_dict.end())
+    {
+        m_user_dict.erase(pos);
+        return true;
+    }
+    return false;
+}
+
+void
+CommandInterpreter::GetAliasHelp (const char *alias_name, const char *command_name, StreamString &help_string)
+{
+    help_string.Printf ("'%s", command_name);
+    OptionArgVectorSP option_arg_vector_sp = GetAliasOptions (alias_name);
+
+    if (option_arg_vector_sp)
+    {
+        OptionArgVector *options = option_arg_vector_sp.get();
+        for (size_t i = 0; i < options->size(); ++i)
+        {
+            OptionArgPair cur_option = (*options)[i];
+            std::string opt = cur_option.first;
+            OptionArgValue value_pair = cur_option.second;
+            std::string value = value_pair.second;
+            if (opt.compare("<argument>") == 0)
+            {
+                help_string.Printf (" %s", value.c_str());
+            }
+            else
+            {
+                help_string.Printf (" %s", opt.c_str());
+                if ((value.compare ("<no-argument>") != 0)
+                    && (value.compare ("<need-argument") != 0))
+                {
+                    help_string.Printf (" %s", value.c_str());
+                }
+            }
+        }
+    }
+
+    help_string.Printf ("'");
+}
+
+size_t
+CommandInterpreter::FindLongestCommandWord (CommandObject::CommandMap &dict)
+{
+    CommandObject::CommandMap::const_iterator pos;
+    CommandObject::CommandMap::const_iterator end = dict.end();
+    size_t max_len = 0;
+
+    for (pos = dict.begin(); pos != end; ++pos)
+    {
+        size_t len = pos->first.size();
+        if (max_len < len)
+            max_len = len;
+    }
+    return max_len;
+}
+
+void
+CommandInterpreter::GetHelp (CommandReturnObject &result,
+                             uint32_t cmd_types)
+{
+    CommandObject::CommandMap::const_iterator pos;
+    size_t max_len = FindLongestCommandWord (m_command_dict);
+    
+    if ( (cmd_types & eCommandTypesBuiltin) == eCommandTypesBuiltin )
+    {
+    
+        result.AppendMessage("The following is a list of built-in, permanent debugger commands:");
+        result.AppendMessage("");
+
+        for (pos = m_command_dict.begin(); pos != m_command_dict.end(); ++pos)
+        {
+            OutputFormattedHelpText (result.GetOutputStream(), pos->first.c_str(), "--", pos->second->GetHelp(),
+                                     max_len);
+        }
+        result.AppendMessage("");
+
+    }
+
+    if (!m_alias_dict.empty() && ( (cmd_types & eCommandTypesAliases) == eCommandTypesAliases ))
+    {
+        result.AppendMessage("The following is a list of your current command abbreviations "
+                             "(see 'help command alias' for more info):");
+        result.AppendMessage("");
+        max_len = FindLongestCommandWord (m_alias_dict);
+
+        for (pos = m_alias_dict.begin(); pos != m_alias_dict.end(); ++pos)
+        {
+            StreamString sstr;
+            StreamString translation_and_help;
+            std::string entry_name = pos->first;
+            std::string second_entry = pos->second.get()->GetCommandName();
+            GetAliasHelp (pos->first.c_str(), pos->second->GetCommandName(), sstr);
+            
+            translation_and_help.Printf ("(%s)  %s", sstr.GetData(), pos->second->GetHelp());
+            OutputFormattedHelpText (result.GetOutputStream(), pos->first.c_str(), "--", 
+                                     translation_and_help.GetData(), max_len);
+        }
+        result.AppendMessage("");
+    }
+
+    if (!m_user_dict.empty() && ( (cmd_types & eCommandTypesUserDef) == eCommandTypesUserDef ))
+    {
+        result.AppendMessage ("The following is a list of your current user-defined commands:");
+        result.AppendMessage("");
+        max_len = FindLongestCommandWord (m_user_dict);
+        for (pos = m_user_dict.begin(); pos != m_user_dict.end(); ++pos)
+        {
+            OutputFormattedHelpText (result.GetOutputStream(), pos->first.c_str(), "--", pos->second->GetHelp(),
+                                     max_len);
+        }
+        result.AppendMessage("");
+    }
+
+    result.AppendMessage("For more information on any particular command, try 'help <command-name>'.");
+}
+
+CommandObject *
+CommandInterpreter::GetCommandObjectForCommand (std::string &command_string)
+{
+    // This function finds the final, lowest-level, alias-resolved command object whose 'Execute' function will
+    // eventually be invoked by the given command line.
+    
+    CommandObject *cmd_obj = NULL;
+    std::string white_space (" \t\v");
+    size_t start = command_string.find_first_not_of (white_space);
+    size_t end = 0;
+    bool done = false;
+    while (!done)
+    {
+        if (start != std::string::npos)
+        {
+            // Get the next word from command_string.
+            end = command_string.find_first_of (white_space, start);
+            if (end == std::string::npos)
+                end = command_string.size();
+            std::string cmd_word = command_string.substr (start, end - start);
+            
+            if (cmd_obj == NULL)
+                // Since cmd_obj is NULL we are on our first time through this loop. Check to see if cmd_word is a valid 
+                // command or alias.
+                cmd_obj = GetCommandObject (cmd_word.c_str());
+            else if (cmd_obj->IsMultiwordObject ())
+            {
+                // Our current object is a multi-word object; see if the cmd_word is a valid sub-command for our object.
+                CommandObject *sub_cmd_obj = cmd_obj->GetSubcommandObject (cmd_word.c_str());
+                if (sub_cmd_obj)
+                    cmd_obj = sub_cmd_obj;
+                else // cmd_word was not a valid sub-command word, so we are donee
+                    done = true;
+            }
+            else  
+                // We have a cmd_obj and it is not a multi-word object, so we are done.
+                done = true;
+
+            // If we didn't find a valid command object, or our command object is not a multi-word object, or
+            // we are at the end of the command_string, then we are done.  Otherwise, find the start of the
+            // next word.
+            
+            if (!cmd_obj || !cmd_obj->IsMultiwordObject() || end >= command_string.size())
+                done = true;
+            else
+                start = command_string.find_first_not_of (white_space, end);
+        }
+        else
+            // Unable to find any more words.
+            done = true;
+    }
+    
+    if (end == command_string.size())
+        command_string.clear();
+    else
+        command_string = command_string.substr(end);
+    
+    return cmd_obj;
+}
+
+static const char *k_white_space = " \t\v";
+static const char *k_valid_command_chars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789-_";
+static void
+StripLeadingSpaces (std::string &s)
+{
+    if (!s.empty())
+    {
+        size_t pos = s.find_first_not_of (k_white_space);
+        if (pos == std::string::npos)
+            s.clear();
+        else if (pos == 0)
+            return;
+        s.erase (0, pos);
+    }
+}
+
+static size_t
+FindArgumentTerminator (const std::string &s)
+{
+    const size_t s_len = s.size();
+    size_t offset = 0;
+    while (offset < s_len)
+    {
+        size_t pos = s.find ("--", offset);
+        if (pos == std::string::npos)
+            break;
+        if (pos > 0)
+        {
+            if (isspace(s[pos-1]))
+            {
+                // Check if the string ends "\s--" (where \s is a space character)
+                // or if we have "\s--\s".
+                if ((pos + 2 >= s_len) || isspace(s[pos+2]))
+                {
+                    return pos;
+                }
+            }
+        }
+        offset = pos + 2;
+    }
+    return std::string::npos;
+}
+
+static bool
+ExtractCommand (std::string &command_string, std::string &command, std::string &suffix, char &quote_char)
+{
+    command.clear();
+    suffix.clear();
+    StripLeadingSpaces (command_string);
+
+    bool result = false;
+    quote_char = '\0';
+    
+    if (!command_string.empty())
+    {
+        const char first_char = command_string[0];
+        if (first_char == '\'' || first_char == '"')
+        {
+            quote_char = first_char;
+            const size_t end_quote_pos = command_string.find (quote_char, 1);
+            if (end_quote_pos == std::string::npos)
+            {
+                command.swap (command_string);
+                command_string.erase ();
+            }
+            else
+            {
+                command.assign (command_string, 1, end_quote_pos - 1);
+                if (end_quote_pos + 1 < command_string.size())
+                    command_string.erase (0, command_string.find_first_not_of (k_white_space, end_quote_pos + 1));
+                else
+                    command_string.erase ();
+            }
+        }
+        else
+        {
+            const size_t first_space_pos = command_string.find_first_of (k_white_space);
+            if (first_space_pos == std::string::npos)
+            {
+                command.swap (command_string);
+                command_string.erase();
+            }
+            else
+            {
+                command.assign (command_string, 0, first_space_pos);
+                command_string.erase(0, command_string.find_first_not_of (k_white_space, first_space_pos));
+            }
+        }
+        result = true;
+    }
+    
+    
+    if (!command.empty())
+    {
+        // actual commands can't start with '-' or '_'
+        if (command[0] != '-' && command[0] != '_')
+        {
+            size_t pos = command.find_first_not_of(k_valid_command_chars);
+            if (pos > 0 && pos != std::string::npos)
+            {
+                suffix.assign (command.begin() + pos, command.end());
+                command.erase (pos);
+            }
+        }
+    }
+
+    return result;
+}
+
+CommandObject *
+CommandInterpreter::BuildAliasResult (const char *alias_name, 
+                                      std::string &raw_input_string, 
+                                      std::string &alias_result,
+                                      CommandReturnObject &result)
+{
+    CommandObject *alias_cmd_obj = NULL;
+    Args cmd_args (raw_input_string.c_str());
+    alias_cmd_obj = GetCommandObject (alias_name);
+    StreamString result_str;
+    
+    if (alias_cmd_obj)
+    {
+        std::string alias_name_str = alias_name;
+        if ((cmd_args.GetArgumentCount() == 0)
+            || (alias_name_str.compare (cmd_args.GetArgumentAtIndex(0)) != 0))
+            cmd_args.Unshift (alias_name);
+            
+        result_str.Printf ("%s", alias_cmd_obj->GetCommandName ());
+        OptionArgVectorSP option_arg_vector_sp = GetAliasOptions (alias_name);
+
+        if (option_arg_vector_sp.get())
+        {
+            OptionArgVector *option_arg_vector = option_arg_vector_sp.get();
+
+            for (size_t i = 0; i < option_arg_vector->size(); ++i)
+            {
+                OptionArgPair option_pair = (*option_arg_vector)[i];
+                OptionArgValue value_pair = option_pair.second;
+                int value_type = value_pair.first;
+                std::string option = option_pair.first;
+                std::string value = value_pair.second;
+                if (option.compare ("<argument>") == 0)
+                    result_str.Printf (" %s", value.c_str());
+                else
+                {
+                    result_str.Printf (" %s", option.c_str());
+                    if (value_type != optional_argument)
+                        result_str.Printf (" ");
+                    if (value.compare ("<no_argument>") != 0)
+                    {
+                        int index = GetOptionArgumentPosition (value.c_str());
+                        if (index == 0)
+                            result_str.Printf ("%s", value.c_str());
+                        else if (index >= cmd_args.GetArgumentCount())
+                        {
+                            
+                            result.AppendErrorWithFormat
+                            ("Not enough arguments provided; you need at least %d arguments to use this alias.\n",
+                             index);
+                            result.SetStatus (eReturnStatusFailed);
+                            return alias_cmd_obj;
+                        }
+                        else
+                        {
+                            size_t strpos = raw_input_string.find (cmd_args.GetArgumentAtIndex (index));
+                            if (strpos != std::string::npos)
+                                raw_input_string = raw_input_string.erase (strpos, 
+                                                                          strlen (cmd_args.GetArgumentAtIndex (index)));
+                            result_str.Printf ("%s", cmd_args.GetArgumentAtIndex (index));
+                        }
+                    }
+                }
+            }
+        }
+        
+        alias_result = result_str.GetData();
+    }
+    return alias_cmd_obj;
+}
+
+Error
+CommandInterpreter::PreprocessCommand (std::string &command)
+{
+    // The command preprocessor needs to do things to the command 
+    // line before any parsing of arguments or anything else is done.
+    // The only current stuff that gets proprocessed is anyting enclosed
+    // in backtick ('`') characters is evaluated as an expression and
+    // the result of the expression must be a scalar that can be substituted
+    // into the command. An example would be:
+    // (lldb) memory read `$rsp + 20`
+    Error error; // Error for any expressions that might not evaluate
+    size_t start_backtick;
+    size_t pos = 0;
+    while ((start_backtick = command.find ('`', pos)) != std::string::npos)
+    {
+        if (start_backtick > 0 && command[start_backtick-1] == '\\')
+        {
+            // The backtick was preceeded by a '\' character, remove the slash
+            // and don't treat the backtick as the start of an expression
+            command.erase(start_backtick-1, 1);
+            // No need to add one to start_backtick since we just deleted a char
+            pos = start_backtick; 
+        }
+        else
+        {
+            const size_t expr_content_start = start_backtick + 1;
+            const size_t end_backtick = command.find ('`', expr_content_start);
+            if (end_backtick == std::string::npos)
+                return error;
+            else if (end_backtick == expr_content_start)
+            {
+                // Empty expression (two backticks in a row)
+                command.erase (start_backtick, 2);
+            }
+            else
+            {
+                std::string expr_str (command, expr_content_start, end_backtick - expr_content_start);
+                
+                ExecutionContext exe_ctx(GetExecutionContext());
+                Target *target = exe_ctx.GetTargetPtr();
+                // Get a dummy target to allow for calculator mode while processing backticks.
+                // This also helps break the infinite loop caused when target is null.
+                if (!target)
+                    target = Host::GetDummyTarget(GetDebugger()).get();
+                if (target)
+                {
+                    ValueObjectSP expr_result_valobj_sp;
+                    
+                    EvaluateExpressionOptions options;
+                    options.SetCoerceToId(false)
+                    .SetUnwindOnError(true)
+                    .SetIgnoreBreakpoints(true)
+                    .SetKeepInMemory(false)
+                    .SetRunOthers(true)
+                    .SetTimeoutUsec(0);
+                    
+                    ExecutionResults expr_result = target->EvaluateExpression (expr_str.c_str(), 
+                                                                               exe_ctx.GetFramePtr(),
+                                                                               expr_result_valobj_sp,
+                                                                               options);
+                    
+                    if (expr_result == eExecutionCompleted)
+                    {
+                        Scalar scalar;
+                        if (expr_result_valobj_sp->ResolveValue (scalar))
+                        {
+                            command.erase (start_backtick, end_backtick - start_backtick + 1);
+                            StreamString value_strm;
+                            const bool show_type = false;
+                            scalar.GetValue (&value_strm, show_type);
+                            size_t value_string_size = value_strm.GetSize();
+                            if (value_string_size)
+                            {
+                                command.insert (start_backtick, value_strm.GetData(), value_string_size);
+                                pos = start_backtick + value_string_size;
+                                continue;
+                            }
+                            else
+                            {
+                                error.SetErrorStringWithFormat("expression value didn't result in a scalar value for the expression '%s'", expr_str.c_str());
+                            }
+                        }
+                        else
+                        {
+                            error.SetErrorStringWithFormat("expression value didn't result in a scalar value for the expression '%s'", expr_str.c_str());
+                        }
+                    }
+                    else
+                    {
+                        if (expr_result_valobj_sp)
+                            error = expr_result_valobj_sp->GetError();
+                        if (error.Success())
+                        {
+
+                            switch (expr_result)
+                            {
+                                case eExecutionSetupError: 
+                                    error.SetErrorStringWithFormat("expression setup error for the expression '%s'", expr_str.c_str());
+                                    break;
+                                case eExecutionCompleted:
+                                    break;
+                                case eExecutionDiscarded:
+                                    error.SetErrorStringWithFormat("expression discarded for the expression '%s'", expr_str.c_str());
+                                    break;
+                                case eExecutionInterrupted:
+                                    error.SetErrorStringWithFormat("expression interrupted for the expression '%s'", expr_str.c_str());
+                                    break;
+                                case eExecutionHitBreakpoint:
+                                    error.SetErrorStringWithFormat("expression hit breakpoint for the expression '%s'", expr_str.c_str());
+                                    break;
+                                case eExecutionTimedOut:
+                                    error.SetErrorStringWithFormat("expression timed out for the expression '%s'", expr_str.c_str());
+                                    break;
+                            }
+                        }
+                    }
+                }
+            }
+            if (error.Fail())
+                break;
+        }
+    }
+    return error;
+}
+
+
+bool
+CommandInterpreter::HandleCommand (const char *command_line, 
+                                   LazyBool lazy_add_to_history,
+                                   CommandReturnObject &result,
+                                   ExecutionContext *override_context,
+                                   bool repeat_on_empty_command,
+                                   bool no_context_switching)
+
+{
+
+    bool done = false;
+    CommandObject *cmd_obj = NULL;
+    bool wants_raw_input = false;
+    std::string command_string (command_line);
+    std::string original_command_string (command_line);
+    
+    Log *log (lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_COMMANDS));
+    Host::SetCrashDescriptionWithFormat ("HandleCommand(command = \"%s\")", command_line);
+    
+    // Make a scoped cleanup object that will clear the crash description string 
+    // on exit of this function.
+    lldb_utility::CleanUp <const char *> crash_description_cleanup(NULL, Host::SetCrashDescription);
+
+    if (log)
+        log->Printf ("Processing command: %s", command_line);
+
+    Timer scoped_timer (__PRETTY_FUNCTION__, "Handling command: %s.", command_line);
+    
+    if (!no_context_switching)
+        UpdateExecutionContext (override_context);
+    
+    bool add_to_history;
+    if (lazy_add_to_history == eLazyBoolCalculate)
+        add_to_history = (m_command_source_depth == 0);
+    else
+        add_to_history = (lazy_add_to_history == eLazyBoolYes);
+    
+    bool empty_command = false;
+    bool comment_command = false;
+    if (command_string.empty())
+        empty_command = true;
+    else
+    {
+        const char *k_space_characters = "\t\n\v\f\r ";
+
+        size_t non_space = command_string.find_first_not_of (k_space_characters);
+        // Check for empty line or comment line (lines whose first
+        // non-space character is the comment character for this interpreter)
+        if (non_space == std::string::npos)
+            empty_command = true;
+        else if (command_string[non_space] == m_comment_char)
+             comment_command = true;
+        else if (command_string[non_space] == CommandHistory::g_repeat_char)
+        {
+            const char *history_string = m_command_history.FindString(command_string.c_str() + non_space);
+            if (history_string == NULL)
+            {
+                result.AppendErrorWithFormat ("Could not find entry: %s in history", command_string.c_str());
+                result.SetStatus(eReturnStatusFailed);
+                return false;
+            }
+            add_to_history = false;
+            command_string = history_string;
+            original_command_string = history_string;
+        }
+    }
+    
+    if (empty_command)
+    {
+        if (repeat_on_empty_command)
+        {
+            if (m_command_history.IsEmpty())
+            {
+                result.AppendError ("empty command");
+                result.SetStatus(eReturnStatusFailed);
+                return false;
+            }
+            else
+            {
+                command_line = m_repeat_command.c_str();
+                command_string = command_line;
+                original_command_string = command_line;
+                if (m_repeat_command.empty())
+                {
+                    result.AppendErrorWithFormat("No auto repeat.\n");
+                    result.SetStatus (eReturnStatusFailed);
+                    return false;
+                }
+            }
+            add_to_history = false;
+        }
+        else
+        {
+            result.SetStatus (eReturnStatusSuccessFinishNoResult);
+            return true;
+        }
+    }
+    else if (comment_command)
+    {
+        result.SetStatus (eReturnStatusSuccessFinishNoResult);
+        return true;
+    }
+    
+    
+    Error error (PreprocessCommand (command_string));
+    
+    if (error.Fail())
+    {
+        result.AppendError (error.AsCString());
+        result.SetStatus(eReturnStatusFailed);
+        return false;
+    }
+    // Phase 1.
+    
+    // Before we do ANY kind of argument processing, etc. we need to figure out what the real/final command object
+    // is for the specified command, and whether or not it wants raw input.  This gets complicated by the fact that
+    // the user could have specified an alias, and in translating the alias there may also be command options and/or
+    // even data (including raw text strings) that need to be found and inserted into the command line as part of
+    // the translation.  So this first step is plain look-up & replacement, resulting in three things:  1). the command
+    // object whose Execute method will actually be called; 2). a revised command string, with all substitutions &
+    // replacements taken care of; 3). whether or not the Execute function wants raw input or not.
+
+    StreamString revised_command_line;
+    size_t actual_cmd_name_len = 0;
+    std::string next_word;
+    StringList matches;
+    while (!done)
+    {
+        char quote_char = '\0';
+        std::string suffix;
+        ExtractCommand (command_string, next_word, suffix, quote_char);
+        if (cmd_obj == NULL)
+        {
+            std::string full_name;
+            if (GetAliasFullName(next_word.c_str(), full_name))
+            {
+                std::string alias_result;
+                cmd_obj = BuildAliasResult (full_name.c_str(), command_string, alias_result, result);
+                revised_command_line.Printf ("%s", alias_result.c_str());
+                if (cmd_obj)
+                {
+                    wants_raw_input = cmd_obj->WantsRawCommandString ();
+                    actual_cmd_name_len = strlen (cmd_obj->GetCommandName());
+                }
+            }
+            else
+            {
+                cmd_obj = GetCommandObject (next_word.c_str(), &matches);
+                if (cmd_obj)
+                {
+                    actual_cmd_name_len += next_word.length();
+                    revised_command_line.Printf ("%s", next_word.c_str());
+                    wants_raw_input = cmd_obj->WantsRawCommandString ();
+                }
+                else
+                {
+                    revised_command_line.Printf ("%s", next_word.c_str());
+                }
+            }
+        }
+        else
+        {
+            if (cmd_obj->IsMultiwordObject ())
+            {
+                CommandObject *sub_cmd_obj = cmd_obj->GetSubcommandObject (next_word.c_str());
+                if (sub_cmd_obj)
+                {
+                    actual_cmd_name_len += next_word.length() + 1;
+                    revised_command_line.Printf (" %s", next_word.c_str());
+                    cmd_obj = sub_cmd_obj;
+                    wants_raw_input = cmd_obj->WantsRawCommandString ();
+                }
+                else
+                {
+                    if (quote_char)
+                        revised_command_line.Printf (" %c%s%s%c", quote_char, next_word.c_str(), suffix.c_str(), quote_char);
+                    else
+                        revised_command_line.Printf (" %s%s", next_word.c_str(), suffix.c_str());
+                    done = true;
+                }
+            }
+            else
+            {
+                if (quote_char)
+                    revised_command_line.Printf (" %c%s%s%c", quote_char, next_word.c_str(), suffix.c_str(), quote_char);
+                else
+                    revised_command_line.Printf (" %s%s", next_word.c_str(), suffix.c_str());
+                done = true;
+            }
+        }
+
+        if (cmd_obj == NULL)
+        {
+            const size_t num_matches = matches.GetSize();
+            if (matches.GetSize() > 1) {
+                StreamString error_msg;
+                error_msg.Printf ("Ambiguous command '%s'. Possible matches:\n", next_word.c_str());
+
+                for (uint32_t i = 0; i < num_matches; ++i) {
+                    error_msg.Printf ("\t%s\n", matches.GetStringAtIndex(i));
+                }
+                result.AppendRawError (error_msg.GetString().c_str());
+            } else {
+                // We didn't have only one match, otherwise we wouldn't get here.
+                assert(num_matches == 0);
+                result.AppendErrorWithFormat ("'%s' is not a valid command.\n", next_word.c_str());
+            }
+            result.SetStatus (eReturnStatusFailed);
+            return false;
+        }
+
+        if (cmd_obj->IsMultiwordObject ())
+        {
+            if (!suffix.empty())
+            {
+
+                result.AppendErrorWithFormat ("command '%s' did not recognize '%s%s%s' as valid (subcommand might be invalid).\n",
+                                              cmd_obj->GetCommandName(),
+                                              next_word.empty() ? "" : next_word.c_str(),
+                                              next_word.empty() ? " -- " : " ",
+                                              suffix.c_str());
+                result.SetStatus (eReturnStatusFailed);
+                return false;
+            }
+        }
+        else
+        {
+            // If we found a normal command, we are done
+            done = true;
+            if (!suffix.empty())
+            {
+                switch (suffix[0])
+                {
+                case '/':
+                    // GDB format suffixes
+                    {
+                        Options *command_options = cmd_obj->GetOptions();
+                        if (command_options && command_options->SupportsLongOption("gdb-format"))
+                        {
+                            std::string gdb_format_option ("--gdb-format=");
+                            gdb_format_option += (suffix.c_str() + 1);
+    
+                            bool inserted = false;
+                            std::string &cmd = revised_command_line.GetString();
+                            size_t arg_terminator_idx = FindArgumentTerminator (cmd);
+                            if (arg_terminator_idx != std::string::npos)
+                            {
+                                // Insert the gdb format option before the "--" that terminates options
+                                gdb_format_option.append(1,' ');
+                                cmd.insert(arg_terminator_idx, gdb_format_option);
+                                inserted = true;
+                            }
+
+                            if (!inserted)
+                                revised_command_line.Printf (" %s", gdb_format_option.c_str());
+                        
+                            if (wants_raw_input && FindArgumentTerminator(cmd) == std::string::npos)
+                                revised_command_line.PutCString (" --");
+                        }
+                        else
+                        {
+                            result.AppendErrorWithFormat ("the '%s' command doesn't support the --gdb-format option\n", 
+                                                          cmd_obj->GetCommandName());
+                            result.SetStatus (eReturnStatusFailed);
+                            return false;
+                        }
+                    }
+                    break;
+
+                default:
+                    result.AppendErrorWithFormat ("unknown command shorthand suffix: '%s'\n", 
+                                                  suffix.c_str());
+                    result.SetStatus (eReturnStatusFailed);
+                    return false;
+        
+                }
+            }
+        }
+        if (command_string.length() == 0)
+            done = true;
+            
+    }
+
+    if (!command_string.empty())
+        revised_command_line.Printf (" %s", command_string.c_str());
+
+    // End of Phase 1.
+    // At this point cmd_obj should contain the CommandObject whose Execute method will be called, if the command
+    // specified was valid; revised_command_line contains the complete command line (including command name(s)),
+    // fully translated with all substitutions & translations taken care of (still in raw text format); and
+    // wants_raw_input specifies whether the Execute method expects raw input or not.
+
+ 
+    if (log)
+    {
+        log->Printf ("HandleCommand, cmd_obj : '%s'", cmd_obj ? cmd_obj->GetCommandName() : "<not found>");
+        log->Printf ("HandleCommand, revised_command_line: '%s'", revised_command_line.GetData());
+        log->Printf ("HandleCommand, wants_raw_input:'%s'", wants_raw_input ? "True" : "False");
+    }
+
+    // Phase 2.
+    // Take care of things like setting up the history command & calling the appropriate Execute method on the
+    // CommandObject, with the appropriate arguments.
+    
+    if (cmd_obj != NULL)
+    {
+        if (add_to_history)
+        {
+            Args command_args (revised_command_line.GetData());
+            const char *repeat_command = cmd_obj->GetRepeatCommand(command_args, 0);
+            if (repeat_command != NULL)
+                m_repeat_command.assign(repeat_command);
+            else
+                m_repeat_command.assign(original_command_string.c_str());
+            
+            m_command_history.AppendString (original_command_string);
+        }
+        
+        command_string = revised_command_line.GetData();
+        std::string command_name (cmd_obj->GetCommandName());
+        std::string remainder;
+        if (actual_cmd_name_len < command_string.length()) 
+            remainder = command_string.substr (actual_cmd_name_len);  // Note: 'actual_cmd_name_len' may be considerably shorter
+                                                           // than cmd_obj->GetCommandName(), because name completion
+                                                           // allows users to enter short versions of the names,
+                                                           // e.g. 'br s' for 'breakpoint set'.
+        
+        // Remove any initial spaces
+        std::string white_space (" \t\v");
+        size_t pos = remainder.find_first_not_of (white_space);
+        if (pos != 0 && pos != std::string::npos)
+            remainder.erase(0, pos);
+
+        if (log)
+            log->Printf ("HandleCommand, command line after removing command name(s): '%s'", remainder.c_str());
+    
+        cmd_obj->Execute (remainder.c_str(), result);
+    }
+    else
+    {
+        // We didn't find the first command object, so complete the first argument.
+        Args command_args (revised_command_line.GetData());
+        StringList matches;
+        int num_matches;
+        int cursor_index = 0;
+        int cursor_char_position = strlen (command_args.GetArgumentAtIndex(0));
+        bool word_complete;
+        num_matches = HandleCompletionMatches (command_args, 
+                                               cursor_index,
+                                               cursor_char_position,
+                                               0, 
+                                               -1, 
+                                               word_complete,
+                                               matches);
+        
+        if (num_matches > 0)
+        {
+            std::string error_msg;
+            error_msg.assign ("ambiguous command '");
+            error_msg.append(command_args.GetArgumentAtIndex(0));
+            error_msg.append ("'.");
+            
+            error_msg.append (" Possible completions:");
+            for (int i = 0; i < num_matches; i++)
+            {
+                error_msg.append ("\n\t");
+                error_msg.append (matches.GetStringAtIndex (i));
+            }
+            error_msg.append ("\n");
+            result.AppendRawError (error_msg.c_str());
+        }
+        else
+            result.AppendErrorWithFormat ("Unrecognized command '%s'.\n", command_args.GetArgumentAtIndex (0));
+        
+        result.SetStatus (eReturnStatusFailed);
+    }
+    
+    if (log)
+      log->Printf ("HandleCommand, command %s", (result.Succeeded() ? "succeeded" : "did not succeed"));
+
+    return result.Succeeded();
+}
+
+int
+CommandInterpreter::HandleCompletionMatches (Args &parsed_line,
+                                             int &cursor_index,
+                                             int &cursor_char_position,
+                                             int match_start_point,
+                                             int max_return_elements,
+                                             bool &word_complete,
+                                             StringList &matches)
+{
+    int num_command_matches = 0;
+    bool look_for_subcommand = false;
+    
+    // For any of the command completions a unique match will be a complete word.
+    word_complete = true;
+
+    if (cursor_index == -1)
+    {
+        // We got nothing on the command line, so return the list of commands
+        bool include_aliases = true;
+        num_command_matches = GetCommandNamesMatchingPartialString ("", include_aliases, matches);
+    }
+    else if (cursor_index == 0)
+    {
+        // The cursor is in the first argument, so just do a lookup in the dictionary.
+        CommandObject *cmd_obj = GetCommandObject (parsed_line.GetArgumentAtIndex(0), &matches);
+        num_command_matches = matches.GetSize();
+
+        if (num_command_matches == 1
+            && cmd_obj && cmd_obj->IsMultiwordObject()
+            && matches.GetStringAtIndex(0) != NULL
+            && strcmp (parsed_line.GetArgumentAtIndex(0), matches.GetStringAtIndex(0)) == 0)
+        {
+            look_for_subcommand = true;
+            num_command_matches = 0;
+            matches.DeleteStringAtIndex(0);
+            parsed_line.AppendArgument ("");
+            cursor_index++;
+            cursor_char_position = 0;
+        }
+    }
+
+    if (cursor_index > 0 || look_for_subcommand)
+    {
+        // We are completing further on into a commands arguments, so find the command and tell it
+        // to complete the command.
+        // First see if there is a matching initial command:
+        CommandObject *command_object = GetCommandObject (parsed_line.GetArgumentAtIndex(0));
+        if (command_object == NULL)
+        {
+            return 0;
+        }
+        else
+        {
+            parsed_line.Shift();
+            cursor_index--;
+            num_command_matches = command_object->HandleCompletion (parsed_line, 
+                                                                    cursor_index, 
+                                                                    cursor_char_position,
+                                                                    match_start_point, 
+                                                                    max_return_elements,
+                                                                    word_complete, 
+                                                                    matches);
+        }
+    }
+
+    return num_command_matches;
+
+}
+
+int
+CommandInterpreter::HandleCompletion (const char *current_line,
+                                      const char *cursor,
+                                      const char *last_char,
+                                      int match_start_point,
+                                      int max_return_elements,
+                                      StringList &matches)
+{
+    // We parse the argument up to the cursor, so the last argument in parsed_line is
+    // the one containing the cursor, and the cursor is after the last character.
+
+    Args parsed_line(current_line, last_char - current_line);
+    Args partial_parsed_line(current_line, cursor - current_line);
+
+    // Don't complete comments, and if the line we are completing is just the history repeat character, 
+    // substitute the appropriate history line.
+    const char *first_arg = parsed_line.GetArgumentAtIndex(0);
+    if (first_arg)
+    {
+        if (first_arg[0] == m_comment_char)
+            return 0;
+        else if (first_arg[0] == CommandHistory::g_repeat_char)
+        {
+            const char *history_string = m_command_history.FindString (first_arg);
+            if (history_string != NULL)
+            {
+                matches.Clear();
+                matches.InsertStringAtIndex(0, history_string);
+                return -2;
+            }
+            else
+                return 0;
+
+        }
+    }
+    
+    
+    int num_args = partial_parsed_line.GetArgumentCount();
+    int cursor_index = partial_parsed_line.GetArgumentCount() - 1;
+    int cursor_char_position;
+
+    if (cursor_index == -1)
+        cursor_char_position = 0;
+    else
+        cursor_char_position = strlen (partial_parsed_line.GetArgumentAtIndex(cursor_index));
+        
+    if (cursor > current_line && cursor[-1] == ' ')
+    {
+        // We are just after a space.  If we are in an argument, then we will continue
+        // parsing, but if we are between arguments, then we have to complete whatever the next
+        // element would be.
+        // We can distinguish the two cases because if we are in an argument (e.g. because the space is
+        // protected by a quote) then the space will also be in the parsed argument...
+        
+        const char *current_elem = partial_parsed_line.GetArgumentAtIndex(cursor_index);
+        if (cursor_char_position == 0 || current_elem[cursor_char_position - 1] != ' ')
+        {
+            parsed_line.InsertArgumentAtIndex(cursor_index + 1, "", '"');
+            cursor_index++;
+            cursor_char_position = 0;
+        }
+    }
+
+    int num_command_matches;
+
+    matches.Clear();
+
+    // Only max_return_elements == -1 is supported at present:
+    assert (max_return_elements == -1);
+    bool word_complete;
+    num_command_matches = HandleCompletionMatches (parsed_line, 
+                                                   cursor_index, 
+                                                   cursor_char_position, 
+                                                   match_start_point,
+                                                   max_return_elements,
+                                                   word_complete,
+                                                   matches);
+
+    if (num_command_matches <= 0)
+            return num_command_matches;
+
+    if (num_args == 0)
+    {
+        // If we got an empty string, insert nothing.
+        matches.InsertStringAtIndex(0, "");
+    }
+    else
+    {
+        // Now figure out if there is a common substring, and if so put that in element 0, otherwise
+        // put an empty string in element 0.
+        std::string command_partial_str;
+        if (cursor_index >= 0)
+            command_partial_str.assign(parsed_line.GetArgumentAtIndex(cursor_index), 
+                                       parsed_line.GetArgumentAtIndex(cursor_index) + cursor_char_position);
+
+        std::string common_prefix;
+        matches.LongestCommonPrefix (common_prefix);
+        const size_t partial_name_len = command_partial_str.size();
+
+        // If we matched a unique single command, add a space...
+        // Only do this if the completer told us this was a complete word, however...
+        if (num_command_matches == 1 && word_complete)
+        {
+            char quote_char = parsed_line.GetArgumentQuoteCharAtIndex(cursor_index);
+            if (quote_char != '\0')
+                common_prefix.push_back(quote_char);
+
+            common_prefix.push_back(' ');
+        }
+        common_prefix.erase (0, partial_name_len);
+        matches.InsertStringAtIndex(0, common_prefix.c_str());
+    }
+    return num_command_matches;
+}
+
+
+CommandInterpreter::~CommandInterpreter ()
+{
+}
+
+const char *
+CommandInterpreter::GetPrompt ()
+{
+    return m_debugger.GetPrompt();
+}
+
+void
+CommandInterpreter::SetPrompt (const char *new_prompt)
+{
+    m_debugger.SetPrompt (new_prompt);
+}
+
+size_t
+CommandInterpreter::GetConfirmationInputReaderCallback 
+(
+    void *baton,
+    InputReader &reader,
+    lldb::InputReaderAction action,
+    const char *bytes,
+    size_t bytes_len
+)
+{
+    File &out_file = reader.GetDebugger().GetOutputFile();
+    bool *response_ptr = (bool *) baton;
+    
+    switch (action)
+    {
+    case eInputReaderActivate:
+        if (out_file.IsValid())
+        {
+            if (reader.GetPrompt())
+            {
+                out_file.Printf ("%s", reader.GetPrompt());
+                out_file.Flush ();
+            }
+        }
+        break;
+
+    case eInputReaderDeactivate:
+        break;
+
+    case eInputReaderReactivate:
+        if (out_file.IsValid() && reader.GetPrompt())
+        {
+            out_file.Printf ("%s", reader.GetPrompt());
+            out_file.Flush ();
+        }
+        break;
+        
+    case eInputReaderAsynchronousOutputWritten:
+        break;
+        
+    case eInputReaderGotToken:
+        if (bytes_len == 0)
+        {
+            reader.SetIsDone(true);
+        }
+        else if (bytes[0] == 'y' || bytes[0] == 'Y')
+        {
+            *response_ptr = true;
+            reader.SetIsDone(true);
+        }
+        else if (bytes[0] == 'n' || bytes[0] == 'N')
+        {
+            *response_ptr = false;
+            reader.SetIsDone(true);
+        }
+        else
+        {
+            if (out_file.IsValid() && !reader.IsDone() && reader.GetPrompt())
+            {
+                out_file.Printf ("Please answer \"y\" or \"n\".\n%s", reader.GetPrompt());
+                out_file.Flush ();
+            }
+        }
+        break;
+        
+    case eInputReaderInterrupt:
+    case eInputReaderEndOfFile:
+        *response_ptr = false;  // Assume ^C or ^D means cancel the proposed action
+        reader.SetIsDone (true);
+        break;
+        
+    case eInputReaderDone:
+        break;
+    }
+
+    return bytes_len;
+
+}
+
+bool 
+CommandInterpreter::Confirm (const char *message, bool default_answer)
+{
+    // Check AutoConfirm first:
+    if (m_debugger.GetAutoConfirm())
+        return default_answer;
+        
+    InputReaderSP reader_sp (new InputReader(GetDebugger()));
+    bool response = default_answer;
+    if (reader_sp)
+    {
+        std::string prompt(message);
+        prompt.append(": [");
+        if (default_answer)
+            prompt.append ("Y/n] ");
+        else
+            prompt.append ("y/N] ");
+            
+        Error err (reader_sp->Initialize (CommandInterpreter::GetConfirmationInputReaderCallback,
+                                          &response,                    // baton
+                                          eInputReaderGranularityLine,  // token size, to pass to callback function
+                                          NULL,                         // end token
+                                          prompt.c_str(),               // prompt
+                                          true));                       // echo input
+        if (err.Success())
+        {
+            GetDebugger().PushInputReader (reader_sp);
+        }
+        reader_sp->WaitOnReaderIsDone();
+    }
+    return response;        
+}
+    
+OptionArgVectorSP
+CommandInterpreter::GetAliasOptions (const char *alias_name)
+{
+    OptionArgMap::iterator pos;
+    OptionArgVectorSP ret_val;
+
+    std::string alias (alias_name);
+
+    if (HasAliasOptions())
+    {
+        pos = m_alias_options.find (alias);
+        if (pos != m_alias_options.end())
+          ret_val = pos->second;
+    }
+
+    return ret_val;
+}
+
+void
+CommandInterpreter::RemoveAliasOptions (const char *alias_name)
+{
+    OptionArgMap::iterator pos = m_alias_options.find(alias_name);
+    if (pos != m_alias_options.end())
+    {
+        m_alias_options.erase (pos);
+    }
+}
+
+void
+CommandInterpreter::AddOrReplaceAliasOptions (const char *alias_name, OptionArgVectorSP &option_arg_vector_sp)
+{
+    m_alias_options[alias_name] = option_arg_vector_sp;
+}
+
+bool
+CommandInterpreter::HasCommands ()
+{
+    return (!m_command_dict.empty());
+}
+
+bool
+CommandInterpreter::HasAliases ()
+{
+    return (!m_alias_dict.empty());
+}
+
+bool
+CommandInterpreter::HasUserCommands ()
+{
+    return (!m_user_dict.empty());
+}
+
+bool
+CommandInterpreter::HasAliasOptions ()
+{
+    return (!m_alias_options.empty());
+}
+
+void
+CommandInterpreter::BuildAliasCommandArgs (CommandObject *alias_cmd_obj,
+                                           const char *alias_name,
+                                           Args &cmd_args,
+                                           std::string &raw_input_string,
+                                           CommandReturnObject &result)
+{
+    OptionArgVectorSP option_arg_vector_sp = GetAliasOptions (alias_name);
+    
+    bool wants_raw_input = alias_cmd_obj->WantsRawCommandString();
+
+    // Make sure that the alias name is the 0th element in cmd_args
+    std::string alias_name_str = alias_name;
+    if (alias_name_str.compare (cmd_args.GetArgumentAtIndex(0)) != 0)
+        cmd_args.Unshift (alias_name);
+    
+    Args new_args (alias_cmd_obj->GetCommandName());
+    if (new_args.GetArgumentCount() == 2)
+        new_args.Shift();
+    
+    if (option_arg_vector_sp.get())
+    {
+        if (wants_raw_input)
+        {
+            // We have a command that both has command options and takes raw input.  Make *sure* it has a
+            // " -- " in the right place in the raw_input_string.
+            size_t pos = raw_input_string.find(" -- ");
+            if (pos == std::string::npos)
+            {
+                // None found; assume it goes at the beginning of the raw input string
+                raw_input_string.insert (0, " -- ");
+            }
+        }
+
+        OptionArgVector *option_arg_vector = option_arg_vector_sp.get();
+        const size_t old_size = cmd_args.GetArgumentCount();
+        std::vector<bool> used (old_size + 1, false);
+        
+        used[0] = true;
+
+        for (size_t i = 0; i < option_arg_vector->size(); ++i)
+        {
+            OptionArgPair option_pair = (*option_arg_vector)[i];
+            OptionArgValue value_pair = option_pair.second;
+            int value_type = value_pair.first;
+            std::string option = option_pair.first;
+            std::string value = value_pair.second;
+            if (option.compare ("<argument>") == 0)
+            {
+                if (!wants_raw_input
+                    || (value.compare("--") != 0)) // Since we inserted this above, make sure we don't insert it twice
+                    new_args.AppendArgument (value.c_str());
+            }
+            else
+            {
+                if (value_type != optional_argument)
+                    new_args.AppendArgument (option.c_str());
+                if (value.compare ("<no-argument>") != 0)
+                {
+                    int index = GetOptionArgumentPosition (value.c_str());
+                    if (index == 0)
+                    {
+                        // value was NOT a positional argument; must be a real value
+                        if (value_type != optional_argument)
+                            new_args.AppendArgument (value.c_str());
+                        else
+                        {
+                            char buffer[255];
+                            ::snprintf (buffer, sizeof (buffer), "%s%s", option.c_str(), value.c_str());
+                            new_args.AppendArgument (buffer);
+                        }
+
+                    }
+                    else if (index >= cmd_args.GetArgumentCount())
+                    {
+                        result.AppendErrorWithFormat
+                                    ("Not enough arguments provided; you need at least %d arguments to use this alias.\n",
+                                     index);
+                        result.SetStatus (eReturnStatusFailed);
+                        return;
+                    }
+                    else
+                    {
+                        // Find and remove cmd_args.GetArgumentAtIndex(i) from raw_input_string
+                        size_t strpos = raw_input_string.find (cmd_args.GetArgumentAtIndex (index));
+                        if (strpos != std::string::npos)
+                        {
+                            raw_input_string = raw_input_string.erase (strpos, strlen (cmd_args.GetArgumentAtIndex (index)));
+                        }
+
+                        if (value_type != optional_argument)
+                            new_args.AppendArgument (cmd_args.GetArgumentAtIndex (index));
+                        else
+                        {
+                            char buffer[255];
+                            ::snprintf (buffer, sizeof(buffer), "%s%s", option.c_str(), 
+                                        cmd_args.GetArgumentAtIndex (index));
+                            new_args.AppendArgument (buffer);
+                        }
+                        used[index] = true;
+                    }
+                }
+            }
+        }
+
+        for (size_t j = 0; j < cmd_args.GetArgumentCount(); ++j)
+        {
+            if (!used[j] && !wants_raw_input)
+                new_args.AppendArgument (cmd_args.GetArgumentAtIndex (j));
+        }
+
+        cmd_args.Clear();
+        cmd_args.SetArguments (new_args.GetArgumentCount(), (const char **) new_args.GetArgumentVector());
+    }
+    else
+    {
+        result.SetStatus (eReturnStatusSuccessFinishNoResult);
+        // This alias was not created with any options; nothing further needs to be done, unless it is a command that
+        // wants raw input, in which case we need to clear the rest of the data from cmd_args, since its in the raw
+        // input string.
+        if (wants_raw_input)
+        {
+            cmd_args.Clear();
+            cmd_args.SetArguments (new_args.GetArgumentCount(), (const char **) new_args.GetArgumentVector());
+        }
+        return;
+    }
+
+    result.SetStatus (eReturnStatusSuccessFinishNoResult);
+    return;
+}
+
+
+int
+CommandInterpreter::GetOptionArgumentPosition (const char *in_string)
+{
+    int position = 0;   // Any string that isn't an argument position, i.e. '%' followed by an integer, gets a position
+                        // of zero.
+
+    char *cptr = (char *) in_string;
+
+    // Does it start with '%'
+    if (cptr[0] == '%')
+    {
+        ++cptr;
+
+        // Is the rest of it entirely digits?
+        if (isdigit (cptr[0]))
+        {
+            const char *start = cptr;
+            while (isdigit (cptr[0]))
+                ++cptr;
+
+            // We've gotten to the end of the digits; are we at the end of the string?
+            if (cptr[0] == '\0')
+                position = atoi (start);
+        }
+    }
+
+    return position;
+}
+
+void
+CommandInterpreter::SourceInitFile (bool in_cwd, CommandReturnObject &result)
+{
+    FileSpec init_file;
+    if (in_cwd)
+    {
+        // In the current working directory we don't load any program specific
+        // .lldbinit files, we only look for a "./.lldbinit" file.
+        if (m_skip_lldbinit_files)
+            return;
+
+        init_file.SetFile ("./.lldbinit", true);
+    }
+    else
+    {
+        // If we aren't looking in the current working directory we are looking
+        // in the home directory. We will first see if there is an application
+        // specific ".lldbinit" file whose name is "~/.lldbinit" followed by a 
+        // "-" and the name of the program. If this file doesn't exist, we fall
+        // back to just the "~/.lldbinit" file. We also obey any requests to not
+        // load the init files.
+        const char *init_file_path = "~/.lldbinit";
+
+        if (m_skip_app_init_files == false)
+        {
+            FileSpec program_file_spec (Host::GetProgramFileSpec());
+            const char *program_name = program_file_spec.GetFilename().AsCString();
+    
+            if (program_name)
+            {
+                char program_init_file_name[PATH_MAX];
+                ::snprintf (program_init_file_name, sizeof(program_init_file_name), "%s-%s", init_file_path, program_name);
+                init_file.SetFile (program_init_file_name, true);
+                if (!init_file.Exists())
+                    init_file.Clear();
+            }
+        }
+        
+        if (!init_file && !m_skip_lldbinit_files)
+			init_file.SetFile (init_file_path, true);
+    }
+
+    // If the file exists, tell HandleCommand to 'source' it; this will do the actual broadcasting
+    // of the commands back to any appropriate listener (see CommandObjectSource::Execute for more details).
+
+    if (init_file.Exists())
+    {
+        ExecutionContext *exe_ctx = NULL;  // We don't have any context yet.
+        bool stop_on_continue = true;
+        bool stop_on_error    = false;
+        bool echo_commands    = false;
+        bool print_results    = false;
+        
+        HandleCommandsFromFile (init_file, exe_ctx, stop_on_continue, stop_on_error, echo_commands, print_results, eLazyBoolNo, result);
+    }
+    else
+    {
+        // nothing to be done if the file doesn't exist
+        result.SetStatus(eReturnStatusSuccessFinishNoResult);
+    }
+}
+
+PlatformSP
+CommandInterpreter::GetPlatform (bool prefer_target_platform)
+{
+    PlatformSP platform_sp;
+    if (prefer_target_platform)
+    {
+        ExecutionContext exe_ctx(GetExecutionContext());
+        Target *target = exe_ctx.GetTargetPtr();
+        if (target)
+            platform_sp = target->GetPlatform();
+    }
+
+    if (!platform_sp)
+        platform_sp = m_debugger.GetPlatformList().GetSelectedPlatform();
+    return platform_sp;
+}
+
+void
+CommandInterpreter::HandleCommands (const StringList &commands, 
+                                    ExecutionContext *override_context, 
+                                    bool stop_on_continue,
+                                    bool stop_on_error,
+                                    bool echo_commands,
+                                    bool print_results,
+                                    LazyBool add_to_history,
+                                    CommandReturnObject &result)
+{
+    size_t num_lines = commands.GetSize();
+    
+    // If we are going to continue past a "continue" then we need to run the commands synchronously.
+    // Make sure you reset this value anywhere you return from the function.
+    
+    bool old_async_execution = m_debugger.GetAsyncExecution();
+    
+    // If we've been given an execution context, set it at the start, but don't keep resetting it or we will
+    // cause series of commands that change the context, then do an operation that relies on that context to fail.
+    
+    if (override_context != NULL)
+        UpdateExecutionContext (override_context);
+            
+    if (!stop_on_continue)
+    {
+        m_debugger.SetAsyncExecution (false);
+    }
+
+    for (size_t idx = 0; idx < num_lines; idx++)
+    {
+        const char *cmd = commands.GetStringAtIndex(idx);
+        if (cmd[0] == '\0')
+            continue;
+            
+        if (echo_commands)
+        {
+            result.AppendMessageWithFormat ("%s %s\n", 
+                                             GetPrompt(), 
+                                             cmd);
+        }
+
+        CommandReturnObject tmp_result;
+        // If override_context is not NULL, pass no_context_switching = true for
+        // HandleCommand() since we updated our context already.
+        
+        // We might call into a regex or alias command, in which case the add_to_history will get lost.  This
+        // m_command_source_depth dingus is the way we turn off adding to the history in that case, so set it up here.
+        if (!add_to_history)
+            m_command_source_depth++;
+        bool success = HandleCommand(cmd, add_to_history, tmp_result,
+                                     NULL, /* override_context */
+                                     true, /* repeat_on_empty_command */
+                                     override_context != NULL /* no_context_switching */);
+        if (!add_to_history)
+            m_command_source_depth--;
+        
+        if (print_results)
+        {
+            if (tmp_result.Succeeded())
+              result.AppendMessageWithFormat("%s", tmp_result.GetOutputData());
+        }
+                
+        if (!success || !tmp_result.Succeeded())
+        {
+            const char *error_msg = tmp_result.GetErrorData();
+            if (error_msg == NULL || error_msg[0] == '\0')
+                error_msg = "<unknown error>.\n";
+            if (stop_on_error)
+            {
+                result.AppendErrorWithFormat("Aborting reading of commands after command #%zu: '%s' failed with %s",
+                                         idx, cmd, error_msg);
+                result.SetStatus (eReturnStatusFailed);
+                m_debugger.SetAsyncExecution (old_async_execution);
+                return;
+            }
+            else if (print_results)
+            {
+                result.AppendMessageWithFormat ("Command #%zu '%s' failed with %s",
+                                                idx + 1, 
+                                                cmd, 
+                                                error_msg);
+            }
+        }
+        
+        if (result.GetImmediateOutputStream())
+            result.GetImmediateOutputStream()->Flush();
+        
+        if (result.GetImmediateErrorStream())
+            result.GetImmediateErrorStream()->Flush();
+        
+        // N.B. Can't depend on DidChangeProcessState, because the state coming into the command execution
+        // could be running (for instance in Breakpoint Commands.
+        // So we check the return value to see if it is has running in it.
+        if ((tmp_result.GetStatus() == eReturnStatusSuccessContinuingNoResult)
+                || (tmp_result.GetStatus() == eReturnStatusSuccessContinuingResult))
+        {
+            if (stop_on_continue)
+            {
+                // If we caused the target to proceed, and we're going to stop in that case, set the
+                // status in our real result before returning.  This is an error if the continue was not the
+                // last command in the set of commands to be run.
+                if (idx != num_lines - 1)
+                    result.AppendErrorWithFormat("Aborting reading of commands after command #%zu: '%s' continued the target.\n", 
+                                                 idx + 1, cmd);
+                else
+                    result.AppendMessageWithFormat ("Command #%zu '%s' continued the target.\n", idx + 1, cmd);
+                    
+                result.SetStatus(tmp_result.GetStatus());
+                m_debugger.SetAsyncExecution (old_async_execution);
+
+                return;
+            }
+        }
+        
+    }
+    
+    result.SetStatus (eReturnStatusSuccessFinishResult);
+    m_debugger.SetAsyncExecution (old_async_execution);
+
+    return;
+}
+
+void
+CommandInterpreter::HandleCommandsFromFile (FileSpec &cmd_file, 
+                                            ExecutionContext *context, 
+                                            bool stop_on_continue,
+                                            bool stop_on_error,
+                                            bool echo_command,
+                                            bool print_result,
+                                            LazyBool add_to_history,
+                                            CommandReturnObject &result)
+{
+    if (cmd_file.Exists())
+    {
+        bool success;
+        StringList commands;
+        success = commands.ReadFileLines(cmd_file);
+        if (!success)
+        {
+            result.AppendErrorWithFormat ("Error reading commands from file: %s.\n", cmd_file.GetFilename().AsCString());
+            result.SetStatus (eReturnStatusFailed);
+            return;
+        }
+        m_command_source_depth++;
+        HandleCommands (commands, context, stop_on_continue, stop_on_error, echo_command, print_result, add_to_history, result);
+        m_command_source_depth--;
+    }
+    else
+    {
+        result.AppendErrorWithFormat ("Error reading commands from file %s - file not found.\n", 
+                                      cmd_file.GetFilename().AsCString());
+        result.SetStatus (eReturnStatusFailed);
+        return;
+    }
+}
+
+ScriptInterpreter *
+CommandInterpreter::GetScriptInterpreter (bool can_create)
+{
+    if (m_script_interpreter_ap.get() != NULL)
+        return m_script_interpreter_ap.get();
+    
+    if (!can_create)
+        return NULL;
+ 
+    // <rdar://problem/11751427>
+    // we need to protect the initialization of the script interpreter
+    // otherwise we could end up with two threads both trying to create
+    // their instance of it, and for some languages (e.g. Python)
+    // this is a bulletproof recipe for disaster!
+    // this needs to be a function-level static because multiple Debugger instances living in the same process
+    // still need to be isolated and not try to initialize Python concurrently
+    static Mutex g_interpreter_mutex(Mutex::eMutexTypeRecursive);
+    Mutex::Locker interpreter_lock(g_interpreter_mutex);
+    
+    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
+    if (log)
+        log->Printf("Initializing the ScriptInterpreter now\n");
+    
+    lldb::ScriptLanguage script_lang = GetDebugger().GetScriptLanguage();
+    switch (script_lang)
+    {
+        case eScriptLanguagePython:
+#ifndef LLDB_DISABLE_PYTHON
+            m_script_interpreter_ap.reset (new ScriptInterpreterPython (*this));
+            break;
+#else
+            // Fall through to the None case when python is disabled
+#endif
+        case eScriptLanguageNone:
+            m_script_interpreter_ap.reset (new ScriptInterpreterNone (*this));
+            break;
+    };
+    
+    return m_script_interpreter_ap.get();
+}
+
+
+
+bool
+CommandInterpreter::GetSynchronous ()
+{
+    return m_synchronous_execution;
+}
+
+void
+CommandInterpreter::SetSynchronous (bool value)
+{
+    m_synchronous_execution  = value;
+}
+
+void
+CommandInterpreter::OutputFormattedHelpText (Stream &strm,
+                                             const char *word_text,
+                                             const char *separator,
+                                             const char *help_text,
+                                             size_t max_word_len)
+{
+    const uint32_t max_columns = m_debugger.GetTerminalWidth();
+
+    int indent_size = max_word_len + strlen (separator) + 2;
+
+    strm.IndentMore (indent_size);
+    
+    StreamString text_strm;
+    text_strm.Printf ("%-*s %s %s",  (int)max_word_len, word_text, separator, help_text);
+    
+    size_t len = text_strm.GetSize();
+    const char *text = text_strm.GetData();
+    if (text[len - 1] == '\n')
+    {
+        text_strm.EOL();
+        len = text_strm.GetSize();
+    }
+
+    if (len  < max_columns)
+    {
+        // Output it as a single line.
+        strm.Printf ("%s", text);
+    }
+    else
+    {
+        // We need to break it up into multiple lines.
+        bool first_line = true;
+        int text_width;
+        size_t start = 0;
+        size_t end = start;
+        const size_t final_end = strlen (text);
+        
+        while (end < final_end)
+        {
+            if (first_line)
+                text_width = max_columns - 1;
+            else
+                text_width = max_columns - indent_size - 1;
+
+            // Don't start the 'text' on a space, since we're already outputting the indentation.
+            if (!first_line)
+            {
+                while ((start < final_end) && (text[start] == ' '))
+                  start++;
+            }
+
+            end = start + text_width;
+            if (end > final_end)
+                end = final_end;
+            else
+            {
+                // If we're not at the end of the text, make sure we break the line on white space.
+                while (end > start
+                       && text[end] != ' ' && text[end] != '\t' && text[end] != '\n')
+                    end--;
+                assert (end > 0);
+            }
+
+            const size_t sub_len = end - start;
+            if (start != 0)
+              strm.EOL();
+            if (!first_line)
+                strm.Indent();
+            else
+                first_line = false;
+            assert (start <= final_end);
+            assert (start + sub_len <= final_end);
+            if (sub_len > 0)
+                strm.Write (text + start, sub_len);
+            start = end + 1;
+        }
+    }
+    strm.EOL();
+    strm.IndentLess(indent_size);
+}
+
+void
+CommandInterpreter::OutputHelpText (Stream &strm,
+                                    const char *word_text,
+                                    const char *separator,
+                                    const char *help_text,
+                                    uint32_t max_word_len)
+{
+    int indent_size = max_word_len + strlen (separator) + 2;
+    
+    strm.IndentMore (indent_size);
+    
+    StreamString text_strm;
+    text_strm.Printf ("%-*s %s %s",  max_word_len, word_text, separator, help_text);
+    
+    const uint32_t max_columns = m_debugger.GetTerminalWidth();
+    
+    size_t len = text_strm.GetSize();
+    const char *text = text_strm.GetData();
+        
+    uint32_t chars_left = max_columns;
+
+    for (uint32_t i = 0; i < len; i++)
+    {
+        if ((text[i] == ' ' && ::strchr((text+i+1), ' ') && chars_left < ::strchr((text+i+1), ' ')-(text+i)) || text[i] == '\n')
+        {
+            chars_left = max_columns - indent_size;
+            strm.EOL();
+            strm.Indent();
+        }
+        else
+        {
+            strm.PutChar(text[i]);
+            chars_left--;
+        }
+        
+    }
+    
+    strm.EOL();
+    strm.IndentLess(indent_size);
+}
+
+void
+CommandInterpreter::FindCommandsForApropos (const char *search_word, StringList &commands_found,
+                                            StringList &commands_help, bool search_builtin_commands, bool search_user_commands)
+{
+    CommandObject::CommandMap::const_iterator pos;
+
+    if (search_builtin_commands)
+    {
+        for (pos = m_command_dict.begin(); pos != m_command_dict.end(); ++pos)
+        {
+            const char *command_name = pos->first.c_str();
+            CommandObject *cmd_obj = pos->second.get();
+
+            if (cmd_obj->HelpTextContainsWord (search_word))
+            {
+                commands_found.AppendString (command_name);
+                commands_help.AppendString (cmd_obj->GetHelp());
+            }
+
+            if (cmd_obj->IsMultiwordObject())
+                cmd_obj->AproposAllSubCommands (command_name,
+                                                search_word,
+                                                commands_found,
+                                                commands_help);
+          
+        }
+    }
+    
+    if (search_user_commands)
+    {
+        for (pos = m_user_dict.begin(); pos != m_user_dict.end(); ++pos)
+        {
+            const char *command_name = pos->first.c_str();
+            CommandObject *cmd_obj = pos->second.get();
+
+            if (cmd_obj->HelpTextContainsWord (search_word))
+            {
+                commands_found.AppendString (command_name);
+                commands_help.AppendString (cmd_obj->GetHelp());
+            }
+
+            if (cmd_obj->IsMultiwordObject())
+                cmd_obj->AproposAllSubCommands (command_name,
+                                                search_word,
+                                                commands_found,
+                                                commands_help);
+          
+        }
+    }
+}
+
+
+void
+CommandInterpreter::UpdateExecutionContext (ExecutionContext *override_context)
+{
+    if (override_context != NULL)
+    {
+        m_exe_ctx_ref = *override_context;
+    }
+    else
+    {
+        const bool adopt_selected = true;
+        m_exe_ctx_ref.SetTargetPtr (m_debugger.GetSelectedTarget().get(), adopt_selected);
+    }
+}