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

1 files changed, 520 insertions, 0 deletions

diff --git a/contrib/llvm/tools/lldb/source/Commands/CommandObjectMultiword.cpp b/contrib/llvm/tools/lldb/source/Commands/CommandObjectMultiword.cpp
new file mode 100644
index 0000000..f84b401
--- /dev/null
+++ b/contrib/llvm/tools/lldb/source/Commands/CommandObjectMultiword.cpp
@@ -0,0 +1,520 @@
+//===-- CommandObjectMultiword.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 "lldb/Interpreter/CommandObjectMultiword.h"
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/Core/Debugger.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Interpreter/Options.h"
+#include "lldb/Interpreter/CommandReturnObject.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+//-------------------------------------------------------------------------
+// CommandObjectMultiword
+//-------------------------------------------------------------------------
+
+CommandObjectMultiword::CommandObjectMultiword
+(
+    CommandInterpreter &interpreter,
+    const char *name,
+    const char *help,
+    const char *syntax,
+    uint32_t flags
+) :
+    CommandObject (interpreter, name, help, syntax, flags),
+    m_can_be_removed(false)
+{
+}
+
+CommandObjectMultiword::~CommandObjectMultiword ()
+{
+}
+
+CommandObjectSP
+CommandObjectMultiword::GetSubcommandSP (const char *sub_cmd, StringList *matches)
+{
+    CommandObjectSP return_cmd_sp;
+    CommandObject::CommandMap::iterator pos;
+
+    if (!m_subcommand_dict.empty())
+    {
+        pos = m_subcommand_dict.find (sub_cmd);
+        if (pos != m_subcommand_dict.end()) {
+            // An exact match; append the sub_cmd to the 'matches' string list.
+            if (matches)
+                matches->AppendString(sub_cmd);
+            return_cmd_sp = pos->second;
+        }
+        else
+        {
+
+            StringList local_matches;
+            if (matches == NULL)
+                matches = &local_matches;
+            int num_matches = CommandObject::AddNamesMatchingPartialString (m_subcommand_dict, sub_cmd, *matches);
+
+            if (num_matches == 1)
+            {
+                // Cleaner, but slightly less efficient would be to call back into this function, since I now
+                // know I have an exact match...
+
+                sub_cmd = matches->GetStringAtIndex(0);
+                pos = m_subcommand_dict.find(sub_cmd);
+                if (pos != m_subcommand_dict.end())
+                    return_cmd_sp = pos->second;
+            }
+        }
+    }
+    return return_cmd_sp;
+}
+
+CommandObject *
+CommandObjectMultiword::GetSubcommandObject (const char *sub_cmd, StringList *matches)
+{
+    return GetSubcommandSP(sub_cmd, matches).get();
+}
+
+bool
+CommandObjectMultiword::LoadSubCommand 
+(
+    const char *name,
+    const CommandObjectSP& cmd_obj
+)
+{
+    CommandMap::iterator pos;
+    bool success = true;
+
+    pos = m_subcommand_dict.find(name);
+    if (pos == m_subcommand_dict.end())
+    {
+        m_subcommand_dict[name] = cmd_obj;
+    }
+    else
+        success = false;
+
+    return success;
+}
+
+bool
+CommandObjectMultiword::Execute(const char *args_string, CommandReturnObject &result)
+{
+    Args args (args_string);
+    const size_t argc = args.GetArgumentCount();
+    if (argc == 0)
+    {
+        this->CommandObject::GenerateHelpText (result);
+    }
+    else
+    {
+        const char *sub_command = args.GetArgumentAtIndex (0);
+
+        if (sub_command)
+        {
+            if (::strcasecmp (sub_command, "help") == 0)
+            {
+                this->CommandObject::GenerateHelpText (result);
+            }
+            else if (!m_subcommand_dict.empty())
+            {
+                StringList matches;
+                CommandObject *sub_cmd_obj = GetSubcommandObject(sub_command, &matches);
+                if (sub_cmd_obj != NULL)
+                {
+                    // Now call CommandObject::Execute to process and options in 'rest_of_line'.  From there
+                    // the command-specific version of Execute will be called, with the processed arguments.
+
+                    args.Shift();
+
+                    sub_cmd_obj->Execute (args_string, result);
+                }
+                else
+                {
+                    std::string error_msg;
+                    const size_t num_subcmd_matches = matches.GetSize();
+                    if (num_subcmd_matches > 0)
+                        error_msg.assign ("ambiguous command ");
+                    else
+                        error_msg.assign ("invalid command ");
+
+                    error_msg.append ("'");
+                    error_msg.append (GetCommandName());
+                    error_msg.append (" ");
+                    error_msg.append (sub_command);
+                    error_msg.append ("'");
+
+                    if (num_subcmd_matches > 0)
+                    {
+                        error_msg.append (" Possible completions:");
+                        for (size_t i = 0; i < num_subcmd_matches; i++)
+                        {
+                            error_msg.append ("\n\t");
+                            error_msg.append (matches.GetStringAtIndex (i));
+                        }
+                    }
+                    error_msg.append ("\n");
+                    result.AppendRawError (error_msg.c_str());
+                    result.SetStatus (eReturnStatusFailed);
+                }
+            }
+            else
+            {
+                result.AppendErrorWithFormat ("'%s' does not have any subcommands.\n", GetCommandName());
+                result.SetStatus (eReturnStatusFailed);
+            }
+        }
+    }
+
+    return result.Succeeded();
+}
+
+void
+CommandObjectMultiword::GenerateHelpText (Stream &output_stream)
+{
+    // First time through here, generate the help text for the object and
+    // push it to the return result object as well
+
+    output_stream.PutCString ("The following subcommands are supported:\n\n");
+
+    CommandMap::iterator pos;
+    uint32_t max_len = m_interpreter.FindLongestCommandWord (m_subcommand_dict);
+
+    if (max_len)
+        max_len += 4; // Indent the output by 4 spaces.
+
+    for (pos = m_subcommand_dict.begin(); pos != m_subcommand_dict.end(); ++pos)
+    {
+        std::string indented_command ("    ");
+        indented_command.append (pos->first);
+        if (pos->second->WantsRawCommandString ())
+        {
+            std::string help_text (pos->second->GetHelp());
+            help_text.append ("  This command takes 'raw' input (no need to quote stuff).");
+            m_interpreter.OutputFormattedHelpText (output_stream,
+                                                   indented_command.c_str(),
+                                                   "--",
+                                                   help_text.c_str(),
+                                                   max_len);
+        }
+        else
+            m_interpreter.OutputFormattedHelpText (output_stream, 
+                                                   indented_command.c_str(),
+                                                   "--", 
+                                                   pos->second->GetHelp(), 
+                                                   max_len);
+    }
+
+    output_stream.PutCString ("\nFor more help on any particular subcommand, type 'help <command> <subcommand>'.\n");
+}
+
+int
+CommandObjectMultiword::HandleCompletion
+(
+    Args &input,
+    int &cursor_index,
+    int &cursor_char_position,
+    int match_start_point,
+    int max_return_elements,
+    bool &word_complete,
+    StringList &matches
+)
+{
+    // Any of the command matches will provide a complete word, otherwise the individual
+    // completers will override this.
+    word_complete = true;
+    
+    if (cursor_index == 0)
+    {
+        CommandObject::AddNamesMatchingPartialString (m_subcommand_dict, 
+                                                      input.GetArgumentAtIndex(0), 
+                                                      matches);
+
+        if (matches.GetSize() == 1
+            && matches.GetStringAtIndex(0) != NULL
+            && strcmp (input.GetArgumentAtIndex(0), matches.GetStringAtIndex(0)) == 0)
+        {
+            StringList temp_matches;
+            CommandObject *cmd_obj = GetSubcommandObject (input.GetArgumentAtIndex(0), 
+                                                          &temp_matches);
+            if (cmd_obj != NULL)
+            {
+                matches.DeleteStringAtIndex (0);
+                input.Shift();
+                cursor_char_position = 0;
+                input.AppendArgument ("");
+                return cmd_obj->HandleCompletion (input, 
+                                                  cursor_index, 
+                                                  cursor_char_position, 
+                                                  match_start_point,
+                                                  max_return_elements,
+                                                  word_complete, 
+                                                  matches);
+            }
+            else
+                return matches.GetSize();
+        }
+        else
+            return matches.GetSize();
+    }
+    else
+    {
+        CommandObject *sub_command_object = GetSubcommandObject (input.GetArgumentAtIndex(0), 
+                                                                 &matches);
+        if (sub_command_object == NULL)
+        {
+            return matches.GetSize();
+        }
+        else
+        {
+            // Remove the one match that we got from calling GetSubcommandObject.
+            matches.DeleteStringAtIndex(0);
+            input.Shift();
+            cursor_index--;
+            return sub_command_object->HandleCompletion (input, 
+                                                         cursor_index, 
+                                                         cursor_char_position, 
+                                                         match_start_point,
+                                                         max_return_elements,
+                                                         word_complete,
+                                                         matches);
+        }
+
+    }
+}
+
+const char *
+CommandObjectMultiword::GetRepeatCommand (Args &current_command_args, uint32_t index)
+{
+    index++;
+    if (current_command_args.GetArgumentCount() <= index)
+        return NULL;
+    CommandObject *sub_command_object = GetSubcommandObject (current_command_args.GetArgumentAtIndex(index));
+    if (sub_command_object == NULL)
+        return NULL;
+    return sub_command_object->GetRepeatCommand(current_command_args, index);
+}
+
+
+void
+CommandObjectMultiword::AproposAllSubCommands (const char *prefix,
+                                               const char *search_word,
+                                               StringList &commands_found,
+                                               StringList &commands_help)
+{
+    CommandObject::CommandMap::const_iterator pos;
+
+    for (pos = m_subcommand_dict.begin(); pos != m_subcommand_dict.end(); ++pos)
+    {
+        const char * command_name = pos->first.c_str();
+        CommandObject *sub_cmd_obj = pos->second.get();
+        StreamString complete_command_name;
+        
+        complete_command_name.Printf ("%s %s", prefix, command_name);
+        
+        if (sub_cmd_obj->HelpTextContainsWord (search_word))
+        {
+            commands_found.AppendString (complete_command_name.GetData());
+            commands_help.AppendString (sub_cmd_obj->GetHelp());
+        }
+        
+        if (sub_cmd_obj->IsMultiwordObject())
+            sub_cmd_obj->AproposAllSubCommands (complete_command_name.GetData(),
+                                                search_word,
+                                                commands_found,
+                                                commands_help);
+    }
+}
+
+
+
+CommandObjectProxy::CommandObjectProxy (CommandInterpreter &interpreter,
+                                        const char *name,
+                                        const char *help,
+                                        const char *syntax,
+                                        uint32_t flags) :
+    CommandObject (interpreter, name, help, syntax, flags)
+{
+}
+
+CommandObjectProxy::~CommandObjectProxy ()
+{
+}
+
+const char *
+CommandObjectProxy::GetHelpLong ()
+{
+    CommandObject *proxy_command = GetProxyCommandObject();
+    if (proxy_command)
+        return proxy_command->GetHelpLong();
+    return NULL;
+}
+
+bool
+CommandObjectProxy::IsRemovable() const
+{
+    const CommandObject *proxy_command = const_cast<CommandObjectProxy *>(this)->GetProxyCommandObject();
+    if (proxy_command)
+        return proxy_command->IsRemovable();
+    return false;
+}
+
+bool
+CommandObjectProxy::IsMultiwordObject ()
+{
+    CommandObject *proxy_command = GetProxyCommandObject();
+    if (proxy_command)
+        return proxy_command->IsMultiwordObject();
+    return false;
+}
+
+lldb::CommandObjectSP
+CommandObjectProxy::GetSubcommandSP (const char *sub_cmd, StringList *matches)
+{
+    CommandObject *proxy_command = GetProxyCommandObject();
+    if (proxy_command)
+        return proxy_command->GetSubcommandSP(sub_cmd, matches);
+    return lldb::CommandObjectSP();
+}
+
+CommandObject *
+CommandObjectProxy::GetSubcommandObject (const char *sub_cmd, StringList *matches)
+{
+    CommandObject *proxy_command = GetProxyCommandObject();
+    if (proxy_command)
+        return proxy_command->GetSubcommandObject(sub_cmd, matches);
+    return NULL;
+}
+
+void
+CommandObjectProxy::AproposAllSubCommands (const char *prefix,
+                                           const char *search_word,
+                                           StringList &commands_found,
+                                           StringList &commands_help)
+{
+    CommandObject *proxy_command = GetProxyCommandObject();
+    if (proxy_command)
+        return proxy_command->AproposAllSubCommands (prefix,
+                                                     search_word,
+                                                     commands_found,
+                                                     commands_help);
+}
+
+bool
+CommandObjectProxy::LoadSubCommand (const char *cmd_name,
+                                    const lldb::CommandObjectSP& command_sp)
+{
+    CommandObject *proxy_command = GetProxyCommandObject();
+    if (proxy_command)
+        return proxy_command->LoadSubCommand (cmd_name, command_sp);
+    return false;
+}
+
+bool
+CommandObjectProxy::WantsRawCommandString()
+{
+    CommandObject *proxy_command = GetProxyCommandObject();
+    if (proxy_command)
+        return proxy_command->WantsRawCommandString();
+    return false;
+}
+
+bool
+CommandObjectProxy::WantsCompletion()
+{
+    CommandObject *proxy_command = GetProxyCommandObject();
+    if (proxy_command)
+        return proxy_command->WantsCompletion();
+    return false;
+}
+
+
+Options *
+CommandObjectProxy::GetOptions ()
+{
+    CommandObject *proxy_command = GetProxyCommandObject();
+    if (proxy_command)
+        return proxy_command->GetOptions ();
+    return NULL;
+}
+
+
+int
+CommandObjectProxy::HandleCompletion (Args &input,
+                                      int &cursor_index,
+                                      int &cursor_char_position,
+                                      int match_start_point,
+                                      int max_return_elements,
+                                      bool &word_complete,
+                                      StringList &matches)
+{
+    CommandObject *proxy_command = GetProxyCommandObject();
+    if (proxy_command)
+        return proxy_command->HandleCompletion (input,
+                                                cursor_index,
+                                                cursor_char_position,
+                                                match_start_point,
+                                                max_return_elements,
+                                                word_complete,
+                                                matches);
+    matches.Clear();
+    return 0;
+}
+int
+CommandObjectProxy::HandleArgumentCompletion (Args &input,
+                                              int &cursor_index,
+                                              int &cursor_char_position,
+                                              OptionElementVector &opt_element_vector,
+                                              int match_start_point,
+                                              int max_return_elements,
+                                              bool &word_complete,
+                                              StringList &matches)
+{
+    CommandObject *proxy_command = GetProxyCommandObject();
+    if (proxy_command)
+        return proxy_command->HandleArgumentCompletion (input,
+                                                        cursor_index,
+                                                        cursor_char_position,
+                                                        opt_element_vector,
+                                                        match_start_point,
+                                                        max_return_elements,
+                                                        word_complete,
+                                                        matches);
+    matches.Clear();
+    return 0;
+}
+
+const char *
+CommandObjectProxy::GetRepeatCommand (Args &current_command_args,
+                                      uint32_t index)
+{
+    CommandObject *proxy_command = GetProxyCommandObject();
+    if (proxy_command)
+        return proxy_command->GetRepeatCommand (current_command_args, index);
+    return NULL;
+}
+
+bool
+CommandObjectProxy::Execute (const char *args_string,
+                             CommandReturnObject &result)
+{
+    CommandObject *proxy_command = GetProxyCommandObject();
+    if (proxy_command)
+        return proxy_command->Execute (args_string, result);
+    result.AppendError ("command is not implemented");
+    result.SetStatus (eReturnStatusFailed);
+    return false;
+}
+
+