2010-06-09 00:52:24 +08:00
|
|
|
//===-- 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/Interpreter/CommandObjectMultiword.h"
|
|
|
|
// C Includes
|
|
|
|
// C++ Includes
|
|
|
|
// Other libraries and framework includes
|
|
|
|
// Project includes
|
2010-06-23 09:19:29 +08:00
|
|
|
#include "lldb/Core/Debugger.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
#include "lldb/Interpreter/CommandInterpreter.h"
|
2010-06-16 03:49:27 +08:00
|
|
|
#include "lldb/Interpreter/Options.h"
|
2010-06-09 00:52:24 +08:00
|
|
|
#include "lldb/Interpreter/CommandReturnObject.h"
|
|
|
|
|
|
|
|
using namespace lldb;
|
|
|
|
using namespace lldb_private;
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
|
|
// CommandObjectMultiword
|
|
|
|
//-------------------------------------------------------------------------
|
|
|
|
|
|
|
|
CommandObjectMultiword::CommandObjectMultiword
|
|
|
|
(
|
2010-09-18 09:14:36 +08:00
|
|
|
CommandInterpreter &interpreter,
|
2010-06-09 00:52:24 +08:00
|
|
|
const char *name,
|
|
|
|
const char *help,
|
|
|
|
const char *syntax,
|
|
|
|
uint32_t flags
|
|
|
|
) :
|
2010-09-18 09:14:36 +08:00
|
|
|
CommandObject (interpreter, name, help, syntax, flags)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
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);
|
2010-12-01 09:04:22 +08:00
|
|
|
if (pos != m_subcommand_dict.end()) {
|
|
|
|
// An exact match; append the sub_cmd to the 'matches' string list.
|
|
|
|
if (matches)
|
|
|
|
matches->AppendString(sub_cmd);
|
2010-06-09 00:52:24 +08:00
|
|
|
return_cmd_sp = pos->second;
|
2010-12-01 09:04:22 +08:00
|
|
|
}
|
2010-06-09 00:52:24 +08:00
|
|
|
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
|
2010-06-23 09:19:29 +08:00
|
|
|
CommandObjectMultiword::LoadSubCommand
|
|
|
|
(
|
|
|
|
const char *name,
|
|
|
|
const CommandObjectSP& cmd_obj
|
|
|
|
)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
|
|
|
CommandMap::iterator pos;
|
|
|
|
bool success = true;
|
|
|
|
|
|
|
|
pos = m_subcommand_dict.find(name);
|
|
|
|
if (pos == m_subcommand_dict.end())
|
|
|
|
{
|
|
|
|
m_subcommand_dict[name] = cmd_obj;
|
2010-09-18 09:14:36 +08:00
|
|
|
m_interpreter.CrossRegisterCommand (name, GetCommandName());
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
success = false;
|
|
|
|
|
|
|
|
return success;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool
|
|
|
|
CommandObjectMultiword::Execute
|
|
|
|
(
|
|
|
|
Args& args,
|
|
|
|
CommandReturnObject &result
|
|
|
|
)
|
|
|
|
{
|
|
|
|
const size_t argc = args.GetArgumentCount();
|
|
|
|
if (argc == 0)
|
|
|
|
{
|
2010-09-18 09:14:36 +08:00
|
|
|
GenerateHelpText (result);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
const char *sub_command = args.GetArgumentAtIndex (0);
|
|
|
|
|
|
|
|
if (sub_command)
|
|
|
|
{
|
|
|
|
if (::strcasecmp (sub_command, "help") == 0)
|
|
|
|
{
|
2010-09-18 09:14:36 +08:00
|
|
|
GenerateHelpText (result);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
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();
|
|
|
|
|
2010-09-18 09:14:36 +08:00
|
|
|
sub_cmd_obj->ExecuteWithOptions (args, result);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
std::string error_msg;
|
|
|
|
int 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 (int 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(), error_msg.size());
|
|
|
|
result.SetStatus (eReturnStatusFailed);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
result.AppendErrorWithFormat ("'%s' does not have any subcommands.\n", GetCommandName());
|
|
|
|
result.SetStatus (eReturnStatusFailed);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return result.Succeeded();
|
|
|
|
}
|
|
|
|
|
|
|
|
void
|
2010-09-18 09:14:36 +08:00
|
|
|
CommandObjectMultiword::GenerateHelpText (CommandReturnObject &result)
|
2010-06-09 00:52:24 +08:00
|
|
|
{
|
|
|
|
// First time through here, generate the help text for the object and
|
|
|
|
// push it to the return result object as well
|
|
|
|
|
|
|
|
StreamString &output_stream = result.GetOutputStream();
|
|
|
|
output_stream.PutCString ("The following subcommands are supported:\n\n");
|
|
|
|
|
|
|
|
CommandMap::iterator pos;
|
2010-09-18 09:14:36 +08:00
|
|
|
uint32_t max_len = m_interpreter.FindLongestCommandWord (m_subcommand_dict);
|
2010-06-09 00:52:24 +08:00
|
|
|
|
2010-08-27 06:05:43 +08:00
|
|
|
if (max_len)
|
|
|
|
max_len += 4; // Indent the output by 4 spaces.
|
2010-06-09 00:52:24 +08:00
|
|
|
|
|
|
|
for (pos = m_subcommand_dict.begin(); pos != m_subcommand_dict.end(); ++pos)
|
|
|
|
{
|
|
|
|
std::string indented_command (" ");
|
|
|
|
indented_command.append (pos->first);
|
Add infrastructure for standardizing arguments for commands and
command options; makes it easier to ensure that the same type of
argument will have the same name everywhere, hooks up help for command
arguments, so that users can ask for help when they are confused about
what an argument should be; puts in the beginnings of the ability to
do tab-completion for certain types of arguments, allows automatic
syntax help generation for commands with arguments, and adds command
arguments into command options help correctly.
Currently only the breakpoint-id and breakpoint-id-range arguments, in
the breakpoint commands, have been hooked up to use the new mechanism.
The next steps will be to fix the command options arguments to use
this mechanism, and to fix the rest of the regular command arguments
to use this mechanism. Most of the help text is currently missing or
dummy text; this will need to be filled in, and the existing argument
help text will need to be cleaned up a bit (it was thrown in quickly,
mostly for testing purposes).
Help command now works for all argument types, although the help may not
be very helpful yet.
Those commands that take "raw" command strings now indicate it in their
help text.
llvm-svn: 115318
2010-10-02 01:46:38 +08:00
|
|
|
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 (result.GetOutputStream(),
|
|
|
|
indented_command.c_str(),
|
|
|
|
"--",
|
|
|
|
help_text.c_str(),
|
|
|
|
max_len);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
m_interpreter.OutputFormattedHelpText (result.GetOutputStream(),
|
|
|
|
indented_command.c_str(),
|
|
|
|
"--",
|
|
|
|
pos->second->GetHelp(),
|
|
|
|
max_len);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
output_stream.PutCString ("\nFor more help on any particular subcommand, type 'help <command> <subcommand>'.\n");
|
|
|
|
|
|
|
|
result.SetStatus (eReturnStatusSuccessFinishNoResult);
|
|
|
|
}
|
|
|
|
|
|
|
|
int
|
|
|
|
CommandObjectMultiword::HandleCompletion
|
|
|
|
(
|
|
|
|
Args &input,
|
|
|
|
int &cursor_index,
|
|
|
|
int &cursor_char_position,
|
|
|
|
int match_start_point,
|
|
|
|
int max_return_elements,
|
2010-06-30 13:02:46 +08:00
|
|
|
bool &word_complete,
|
2010-06-09 00:52:24 +08:00
|
|
|
StringList &matches
|
|
|
|
)
|
|
|
|
{
|
2010-06-30 13:02:46 +08:00
|
|
|
// Any of the command matches will provide a complete word, otherwise the individual
|
|
|
|
// completers will override this.
|
|
|
|
word_complete = true;
|
|
|
|
|
2010-06-09 00:52:24 +08:00
|
|
|
if (cursor_index == 0)
|
|
|
|
{
|
2010-06-23 09:19:29 +08:00
|
|
|
CommandObject::AddNamesMatchingPartialString (m_subcommand_dict,
|
|
|
|
input.GetArgumentAtIndex(0),
|
|
|
|
matches);
|
2010-06-09 00:52:24 +08:00
|
|
|
|
|
|
|
if (matches.GetSize() == 1
|
|
|
|
&& matches.GetStringAtIndex(0) != NULL
|
|
|
|
&& strcmp (input.GetArgumentAtIndex(0), matches.GetStringAtIndex(0)) == 0)
|
|
|
|
{
|
|
|
|
StringList temp_matches;
|
2010-06-23 09:19:29 +08:00
|
|
|
CommandObject *cmd_obj = GetSubcommandObject (input.GetArgumentAtIndex(0),
|
|
|
|
&temp_matches);
|
2010-06-09 00:52:24 +08:00
|
|
|
if (cmd_obj != NULL)
|
|
|
|
{
|
|
|
|
matches.DeleteStringAtIndex (0);
|
|
|
|
input.Shift();
|
|
|
|
cursor_char_position = 0;
|
|
|
|
input.AppendArgument ("");
|
2010-09-18 09:14:36 +08:00
|
|
|
return cmd_obj->HandleCompletion (input,
|
|
|
|
cursor_index,
|
2010-06-23 09:19:29 +08:00
|
|
|
cursor_char_position,
|
|
|
|
match_start_point,
|
2010-06-30 13:02:46 +08:00
|
|
|
max_return_elements,
|
|
|
|
word_complete,
|
2010-06-23 09:19:29 +08:00
|
|
|
matches);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
return matches.GetSize();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
return matches.GetSize();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2010-06-23 09:19:29 +08:00
|
|
|
CommandObject *sub_command_object = GetSubcommandObject (input.GetArgumentAtIndex(0),
|
|
|
|
&matches);
|
2010-06-09 00:52:24 +08:00
|
|
|
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--;
|
2010-09-18 09:14:36 +08:00
|
|
|
return sub_command_object->HandleCompletion (input,
|
2010-06-23 09:19:29 +08:00
|
|
|
cursor_index,
|
|
|
|
cursor_char_position,
|
|
|
|
match_start_point,
|
2010-06-30 13:02:46 +08:00
|
|
|
max_return_elements,
|
|
|
|
word_complete,
|
2010-06-23 09:19:29 +08:00
|
|
|
matches);
|
2010-06-09 00:52:24 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-07-07 11:36:20 +08:00
|
|
|
const char *
|
|
|
|
CommandObjectMultiword::GetRepeatCommand (Args ¤t_command_args, uint32_t index)
|
|
|
|
{
|
|
|
|
index++;
|
2010-07-21 06:54:09 +08:00
|
|
|
if (current_command_args.GetArgumentCount() <= index)
|
|
|
|
return NULL;
|
2010-07-07 11:36:20 +08:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|