forked from OSchip/llvm-project
1963 lines
70 KiB
C++
1963 lines
70 KiB
C++
//===-- CommandObjectCommands.cpp -------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
// C Includes
|
|
// C++ Includes
|
|
// Other libraries and framework includes
|
|
#include "llvm/ADT/StringRef.h"
|
|
|
|
// Project includes
|
|
#include "CommandObjectCommands.h"
|
|
#include "CommandObjectHelp.h"
|
|
#include "lldb/Core/Debugger.h"
|
|
#include "lldb/Core/IOHandler.h"
|
|
#include "lldb/Host/OptionParser.h"
|
|
#include "lldb/Interpreter/Args.h"
|
|
#include "lldb/Interpreter/CommandHistory.h"
|
|
#include "lldb/Interpreter/CommandInterpreter.h"
|
|
#include "lldb/Interpreter/CommandObjectRegexCommand.h"
|
|
#include "lldb/Interpreter/CommandReturnObject.h"
|
|
#include "lldb/Interpreter/OptionValueBoolean.h"
|
|
#include "lldb/Interpreter/OptionValueString.h"
|
|
#include "lldb/Interpreter/OptionValueUInt64.h"
|
|
#include "lldb/Interpreter/Options.h"
|
|
#include "lldb/Interpreter/ScriptInterpreter.h"
|
|
#include "lldb/Utility/StringList.h"
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
//-------------------------------------------------------------------------
|
|
// CommandObjectCommandsSource
|
|
//-------------------------------------------------------------------------
|
|
|
|
static OptionDefinition g_history_options[] = {
|
|
// clang-format off
|
|
{ LLDB_OPT_SET_1, false, "count", 'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger, "How many history commands to print." },
|
|
{ LLDB_OPT_SET_1, false, "start-index", 's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger, "Index at which to start printing history commands (or end to mean tail mode)." },
|
|
{ LLDB_OPT_SET_1, false, "end-index", 'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeUnsignedInteger, "Index at which to stop printing history commands." },
|
|
{ LLDB_OPT_SET_2, false, "clear", 'C', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeBoolean, "Clears the current command history." },
|
|
// clang-format on
|
|
};
|
|
|
|
class CommandObjectCommandsHistory : public CommandObjectParsed {
|
|
public:
|
|
CommandObjectCommandsHistory(CommandInterpreter &interpreter)
|
|
: CommandObjectParsed(interpreter, "command history",
|
|
"Dump the history of commands in this session.\n"
|
|
"Commands in the history list can be run again "
|
|
"using \"!<INDEX>\". \"!-<OFFSET>\" will re-run "
|
|
"the command that is <OFFSET> commands from the end"
|
|
" of the list (counting the current command).",
|
|
nullptr),
|
|
m_options() {}
|
|
|
|
~CommandObjectCommandsHistory() override = default;
|
|
|
|
Options *GetOptions() override { return &m_options; }
|
|
|
|
protected:
|
|
class CommandOptions : public Options {
|
|
public:
|
|
CommandOptions()
|
|
: Options(), m_start_idx(0), m_stop_idx(0), m_count(0), m_clear(false) {
|
|
}
|
|
|
|
~CommandOptions() override = default;
|
|
|
|
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
|
|
ExecutionContext *execution_context) override {
|
|
Status error;
|
|
const int short_option = m_getopt_table[option_idx].val;
|
|
|
|
switch (short_option) {
|
|
case 'c':
|
|
error = m_count.SetValueFromString(option_arg, eVarSetOperationAssign);
|
|
break;
|
|
case 's':
|
|
if (option_arg == "end") {
|
|
m_start_idx.SetCurrentValue(UINT64_MAX);
|
|
m_start_idx.SetOptionWasSet();
|
|
} else
|
|
error = m_start_idx.SetValueFromString(option_arg,
|
|
eVarSetOperationAssign);
|
|
break;
|
|
case 'e':
|
|
error =
|
|
m_stop_idx.SetValueFromString(option_arg, eVarSetOperationAssign);
|
|
break;
|
|
case 'C':
|
|
m_clear.SetCurrentValue(true);
|
|
m_clear.SetOptionWasSet();
|
|
break;
|
|
default:
|
|
error.SetErrorStringWithFormat("unrecognized option '%c'",
|
|
short_option);
|
|
break;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
void OptionParsingStarting(ExecutionContext *execution_context) override {
|
|
m_start_idx.Clear();
|
|
m_stop_idx.Clear();
|
|
m_count.Clear();
|
|
m_clear.Clear();
|
|
}
|
|
|
|
llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
|
|
return llvm::makeArrayRef(g_history_options);
|
|
}
|
|
|
|
// Instance variables to hold the values for command options.
|
|
|
|
OptionValueUInt64 m_start_idx;
|
|
OptionValueUInt64 m_stop_idx;
|
|
OptionValueUInt64 m_count;
|
|
OptionValueBoolean m_clear;
|
|
};
|
|
|
|
bool DoExecute(Args &command, CommandReturnObject &result) override {
|
|
if (m_options.m_clear.GetCurrentValue() &&
|
|
m_options.m_clear.OptionWasSet()) {
|
|
m_interpreter.GetCommandHistory().Clear();
|
|
result.SetStatus(lldb::eReturnStatusSuccessFinishNoResult);
|
|
} else {
|
|
if (m_options.m_start_idx.OptionWasSet() &&
|
|
m_options.m_stop_idx.OptionWasSet() &&
|
|
m_options.m_count.OptionWasSet()) {
|
|
result.AppendError("--count, --start-index and --end-index cannot be "
|
|
"all specified in the same invocation");
|
|
result.SetStatus(lldb::eReturnStatusFailed);
|
|
} else {
|
|
std::pair<bool, uint64_t> start_idx(
|
|
m_options.m_start_idx.OptionWasSet(),
|
|
m_options.m_start_idx.GetCurrentValue());
|
|
std::pair<bool, uint64_t> stop_idx(
|
|
m_options.m_stop_idx.OptionWasSet(),
|
|
m_options.m_stop_idx.GetCurrentValue());
|
|
std::pair<bool, uint64_t> count(m_options.m_count.OptionWasSet(),
|
|
m_options.m_count.GetCurrentValue());
|
|
|
|
const CommandHistory &history(m_interpreter.GetCommandHistory());
|
|
|
|
if (start_idx.first && start_idx.second == UINT64_MAX) {
|
|
if (count.first) {
|
|
start_idx.second = history.GetSize() - count.second;
|
|
stop_idx.second = history.GetSize() - 1;
|
|
} else if (stop_idx.first) {
|
|
start_idx.second = stop_idx.second;
|
|
stop_idx.second = history.GetSize() - 1;
|
|
} else {
|
|
start_idx.second = 0;
|
|
stop_idx.second = history.GetSize() - 1;
|
|
}
|
|
} else {
|
|
if (!start_idx.first && !stop_idx.first && !count.first) {
|
|
start_idx.second = 0;
|
|
stop_idx.second = history.GetSize() - 1;
|
|
} else if (start_idx.first) {
|
|
if (count.first) {
|
|
stop_idx.second = start_idx.second + count.second - 1;
|
|
} else if (!stop_idx.first) {
|
|
stop_idx.second = history.GetSize() - 1;
|
|
}
|
|
} else if (stop_idx.first) {
|
|
if (count.first) {
|
|
if (stop_idx.second >= count.second)
|
|
start_idx.second = stop_idx.second - count.second + 1;
|
|
else
|
|
start_idx.second = 0;
|
|
}
|
|
} else /* if (count.first) */
|
|
{
|
|
start_idx.second = 0;
|
|
stop_idx.second = count.second - 1;
|
|
}
|
|
}
|
|
history.Dump(result.GetOutputStream(), start_idx.second,
|
|
stop_idx.second);
|
|
}
|
|
}
|
|
return result.Succeeded();
|
|
}
|
|
|
|
CommandOptions m_options;
|
|
};
|
|
|
|
//-------------------------------------------------------------------------
|
|
// CommandObjectCommandsSource
|
|
//-------------------------------------------------------------------------
|
|
|
|
static OptionDefinition g_source_options[] = {
|
|
// clang-format off
|
|
{ LLDB_OPT_SET_ALL, false, "stop-on-error", 'e', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "If true, stop executing commands on error." },
|
|
{ LLDB_OPT_SET_ALL, false, "stop-on-continue", 'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "If true, stop executing commands on continue." },
|
|
{ LLDB_OPT_SET_ALL, false, "silent-run", 's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeBoolean, "If true don't echo commands while executing." },
|
|
// clang-format on
|
|
};
|
|
|
|
class CommandObjectCommandsSource : public CommandObjectParsed {
|
|
public:
|
|
CommandObjectCommandsSource(CommandInterpreter &interpreter)
|
|
: CommandObjectParsed(
|
|
interpreter, "command source",
|
|
"Read and execute LLDB commands from the file <filename>.",
|
|
nullptr),
|
|
m_options() {
|
|
CommandArgumentEntry arg;
|
|
CommandArgumentData file_arg;
|
|
|
|
// Define the first (and only) variant of this arg.
|
|
file_arg.arg_type = eArgTypeFilename;
|
|
file_arg.arg_repetition = eArgRepeatPlain;
|
|
|
|
// There is only one variant this argument could be; put it into the
|
|
// argument entry.
|
|
arg.push_back(file_arg);
|
|
|
|
// Push the data for the first argument into the m_arguments vector.
|
|
m_arguments.push_back(arg);
|
|
}
|
|
|
|
~CommandObjectCommandsSource() override = default;
|
|
|
|
const char *GetRepeatCommand(Args ¤t_command_args,
|
|
uint32_t index) override {
|
|
return "";
|
|
}
|
|
|
|
int 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) override {
|
|
auto completion_str = input[cursor_index].ref;
|
|
completion_str = completion_str.take_front(cursor_char_position);
|
|
|
|
CommandCompletions::InvokeCommonCompletionCallbacks(
|
|
GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
|
|
completion_str, match_start_point, max_return_elements, nullptr,
|
|
word_complete, matches);
|
|
return matches.GetSize();
|
|
}
|
|
|
|
Options *GetOptions() override { return &m_options; }
|
|
|
|
protected:
|
|
class CommandOptions : public Options {
|
|
public:
|
|
CommandOptions()
|
|
: Options(), m_stop_on_error(true), m_silent_run(false),
|
|
m_stop_on_continue(true) {}
|
|
|
|
~CommandOptions() override = default;
|
|
|
|
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
|
|
ExecutionContext *execution_context) override {
|
|
Status error;
|
|
const int short_option = m_getopt_table[option_idx].val;
|
|
|
|
switch (short_option) {
|
|
case 'e':
|
|
error = m_stop_on_error.SetValueFromString(option_arg);
|
|
break;
|
|
|
|
case 'c':
|
|
error = m_stop_on_continue.SetValueFromString(option_arg);
|
|
break;
|
|
|
|
case 's':
|
|
error = m_silent_run.SetValueFromString(option_arg);
|
|
break;
|
|
|
|
default:
|
|
error.SetErrorStringWithFormat("unrecognized option '%c'",
|
|
short_option);
|
|
break;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
void OptionParsingStarting(ExecutionContext *execution_context) override {
|
|
m_stop_on_error.Clear();
|
|
m_silent_run.Clear();
|
|
m_stop_on_continue.Clear();
|
|
}
|
|
|
|
llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
|
|
return llvm::makeArrayRef(g_source_options);
|
|
}
|
|
|
|
// Instance variables to hold the values for command options.
|
|
|
|
OptionValueBoolean m_stop_on_error;
|
|
OptionValueBoolean m_silent_run;
|
|
OptionValueBoolean m_stop_on_continue;
|
|
};
|
|
|
|
bool DoExecute(Args &command, CommandReturnObject &result) override {
|
|
if (command.GetArgumentCount() != 1) {
|
|
result.AppendErrorWithFormat(
|
|
"'%s' takes exactly one executable filename argument.\n",
|
|
GetCommandName().str().c_str());
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
FileSpec cmd_file(command[0].ref, true);
|
|
ExecutionContext *exe_ctx = nullptr; // Just use the default context.
|
|
|
|
// If any options were set, then use them
|
|
if (m_options.m_stop_on_error.OptionWasSet() ||
|
|
m_options.m_silent_run.OptionWasSet() ||
|
|
m_options.m_stop_on_continue.OptionWasSet()) {
|
|
// Use user set settings
|
|
CommandInterpreterRunOptions options;
|
|
options.SetStopOnContinue(m_options.m_stop_on_continue.GetCurrentValue());
|
|
options.SetStopOnError(m_options.m_stop_on_error.GetCurrentValue());
|
|
options.SetEchoCommands(!m_options.m_silent_run.GetCurrentValue());
|
|
options.SetPrintResults(!m_options.m_silent_run.GetCurrentValue());
|
|
|
|
m_interpreter.HandleCommandsFromFile(cmd_file, exe_ctx, options, result);
|
|
} else {
|
|
// No options were set, inherit any settings from nested "command
|
|
// source" commands,
|
|
// or set to sane default settings...
|
|
CommandInterpreterRunOptions options;
|
|
m_interpreter.HandleCommandsFromFile(cmd_file, exe_ctx, options, result);
|
|
}
|
|
return result.Succeeded();
|
|
}
|
|
|
|
CommandOptions m_options;
|
|
};
|
|
|
|
#pragma mark CommandObjectCommandsAlias
|
|
//-------------------------------------------------------------------------
|
|
// CommandObjectCommandsAlias
|
|
//-------------------------------------------------------------------------
|
|
|
|
static OptionDefinition g_alias_options[] = {
|
|
// clang-format off
|
|
{ LLDB_OPT_SET_ALL, false, "help", 'h', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeHelpText, "Help text for this command" },
|
|
{ LLDB_OPT_SET_ALL, false, "long-help", 'H', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeHelpText, "Long help text for this command" },
|
|
// clang-format on
|
|
};
|
|
|
|
static const char *g_python_command_instructions =
|
|
"Enter your Python command(s). Type 'DONE' to end.\n"
|
|
"You must define a Python function with this signature:\n"
|
|
"def my_command_impl(debugger, args, result, internal_dict):\n";
|
|
|
|
class CommandObjectCommandsAlias : public CommandObjectRaw {
|
|
protected:
|
|
class CommandOptions : public OptionGroup {
|
|
public:
|
|
CommandOptions() : OptionGroup(), m_help(), m_long_help() {}
|
|
|
|
~CommandOptions() override = default;
|
|
|
|
llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
|
|
return llvm::makeArrayRef(g_alias_options);
|
|
}
|
|
|
|
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_value,
|
|
ExecutionContext *execution_context) override {
|
|
Status error;
|
|
|
|
const int short_option = GetDefinitions()[option_idx].short_option;
|
|
std::string option_str(option_value);
|
|
|
|
switch (short_option) {
|
|
case 'h':
|
|
m_help.SetCurrentValue(option_str);
|
|
m_help.SetOptionWasSet();
|
|
break;
|
|
|
|
case 'H':
|
|
m_long_help.SetCurrentValue(option_str);
|
|
m_long_help.SetOptionWasSet();
|
|
break;
|
|
|
|
default:
|
|
error.SetErrorStringWithFormat("invalid short option character '%c'",
|
|
short_option);
|
|
break;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
void OptionParsingStarting(ExecutionContext *execution_context) override {
|
|
m_help.Clear();
|
|
m_long_help.Clear();
|
|
}
|
|
|
|
OptionValueString m_help;
|
|
OptionValueString m_long_help;
|
|
};
|
|
|
|
OptionGroupOptions m_option_group;
|
|
CommandOptions m_command_options;
|
|
|
|
public:
|
|
Options *GetOptions() override { return &m_option_group; }
|
|
|
|
CommandObjectCommandsAlias(CommandInterpreter &interpreter)
|
|
: CommandObjectRaw(
|
|
interpreter, "command alias",
|
|
"Define a custom command in terms of an existing command."),
|
|
m_option_group(), m_command_options() {
|
|
m_option_group.Append(&m_command_options);
|
|
m_option_group.Finalize();
|
|
|
|
SetHelpLong(
|
|
"'alias' allows the user to create a short-cut or abbreviation for long \
|
|
commands, multi-word commands, and commands that take particular options. \
|
|
Below are some simple examples of how one might use the 'alias' command:"
|
|
R"(
|
|
|
|
(lldb) command alias sc script
|
|
|
|
Creates the abbreviation 'sc' for the 'script' command.
|
|
|
|
(lldb) command alias bp breakpoint
|
|
|
|
)"
|
|
" Creates the abbreviation 'bp' for the 'breakpoint' command. Since \
|
|
breakpoint commands are two-word commands, the user would still need to \
|
|
enter the second word after 'bp', e.g. 'bp enable' or 'bp delete'."
|
|
R"(
|
|
|
|
(lldb) command alias bpl breakpoint list
|
|
|
|
Creates the abbreviation 'bpl' for the two-word command 'breakpoint list'.
|
|
|
|
)"
|
|
"An alias can include some options for the command, with the values either \
|
|
filled in at the time the alias is created, or specified as positional \
|
|
arguments, to be filled in when the alias is invoked. The following example \
|
|
shows how to create aliases with options:"
|
|
R"(
|
|
|
|
(lldb) command alias bfl breakpoint set -f %1 -l %2
|
|
|
|
)"
|
|
" Creates the abbreviation 'bfl' (for break-file-line), with the -f and -l \
|
|
options already part of the alias. So if the user wants to set a breakpoint \
|
|
by file and line without explicitly having to use the -f and -l options, the \
|
|
user can now use 'bfl' instead. The '%1' and '%2' are positional placeholders \
|
|
for the actual arguments that will be passed when the alias command is used. \
|
|
The number in the placeholder refers to the position/order the actual value \
|
|
occupies when the alias is used. All the occurrences of '%1' in the alias \
|
|
will be replaced with the first argument, all the occurrences of '%2' in the \
|
|
alias will be replaced with the second argument, and so on. This also allows \
|
|
actual arguments to be used multiple times within an alias (see 'process \
|
|
launch' example below)."
|
|
R"(
|
|
|
|
)"
|
|
"Note: the positional arguments must substitute as whole words in the resultant \
|
|
command, so you can't at present do something like this to append the file extension \
|
|
\".cpp\":"
|
|
R"(
|
|
|
|
(lldb) command alias bcppfl breakpoint set -f %1.cpp -l %2
|
|
|
|
)"
|
|
"For more complex aliasing, use the \"command regex\" command instead. In the \
|
|
'bfl' case above, the actual file value will be filled in with the first argument \
|
|
following 'bfl' and the actual line number value will be filled in with the second \
|
|
argument. The user would use this alias as follows:"
|
|
R"(
|
|
|
|
(lldb) command alias bfl breakpoint set -f %1 -l %2
|
|
(lldb) bfl my-file.c 137
|
|
|
|
This would be the same as if the user had entered 'breakpoint set -f my-file.c -l 137'.
|
|
|
|
Another example:
|
|
|
|
(lldb) command alias pltty process launch -s -o %1 -e %1
|
|
(lldb) pltty /dev/tty0
|
|
|
|
Interpreted as 'process launch -s -o /dev/tty0 -e /dev/tty0'
|
|
|
|
)"
|
|
"If the user always wanted to pass the same value to a particular option, the \
|
|
alias could be defined with that value directly in the alias as a constant, \
|
|
rather than using a positional placeholder:"
|
|
R"(
|
|
|
|
(lldb) command alias bl3 breakpoint set -f %1 -l 3
|
|
|
|
Always sets a breakpoint on line 3 of whatever file is indicated.)");
|
|
|
|
CommandArgumentEntry arg1;
|
|
CommandArgumentEntry arg2;
|
|
CommandArgumentEntry arg3;
|
|
CommandArgumentData alias_arg;
|
|
CommandArgumentData cmd_arg;
|
|
CommandArgumentData options_arg;
|
|
|
|
// Define the first (and only) variant of this arg.
|
|
alias_arg.arg_type = eArgTypeAliasName;
|
|
alias_arg.arg_repetition = eArgRepeatPlain;
|
|
|
|
// There is only one variant this argument could be; put it into the
|
|
// argument entry.
|
|
arg1.push_back(alias_arg);
|
|
|
|
// Define the first (and only) variant of this arg.
|
|
cmd_arg.arg_type = eArgTypeCommandName;
|
|
cmd_arg.arg_repetition = eArgRepeatPlain;
|
|
|
|
// There is only one variant this argument could be; put it into the
|
|
// argument entry.
|
|
arg2.push_back(cmd_arg);
|
|
|
|
// Define the first (and only) variant of this arg.
|
|
options_arg.arg_type = eArgTypeAliasOptions;
|
|
options_arg.arg_repetition = eArgRepeatOptional;
|
|
|
|
// There is only one variant this argument could be; put it into the
|
|
// argument entry.
|
|
arg3.push_back(options_arg);
|
|
|
|
// Push the data for the first argument into the m_arguments vector.
|
|
m_arguments.push_back(arg1);
|
|
m_arguments.push_back(arg2);
|
|
m_arguments.push_back(arg3);
|
|
}
|
|
|
|
~CommandObjectCommandsAlias() override = default;
|
|
|
|
protected:
|
|
bool DoExecute(const char *raw_command_line,
|
|
CommandReturnObject &result) override {
|
|
if (!raw_command_line || !raw_command_line[0]) {
|
|
result.AppendError("'command alias' requires at least two arguments");
|
|
return false;
|
|
}
|
|
|
|
ExecutionContext exe_ctx = GetCommandInterpreter().GetExecutionContext();
|
|
m_option_group.NotifyOptionParsingStarting(&exe_ctx);
|
|
|
|
const char *remainder = nullptr;
|
|
|
|
if (raw_command_line[0] == '-') {
|
|
// We have some options and these options MUST end with --.
|
|
const char *end_options = nullptr;
|
|
const char *s = raw_command_line;
|
|
while (s && s[0]) {
|
|
end_options = ::strstr(s, "--");
|
|
if (end_options) {
|
|
end_options += 2; // Get past the "--"
|
|
if (::isspace(end_options[0])) {
|
|
remainder = end_options;
|
|
while (::isspace(*remainder))
|
|
++remainder;
|
|
break;
|
|
}
|
|
}
|
|
s = end_options;
|
|
}
|
|
|
|
if (end_options) {
|
|
Args args(
|
|
llvm::StringRef(raw_command_line, end_options - raw_command_line));
|
|
if (!ParseOptions(args, result))
|
|
return false;
|
|
|
|
Status error(m_option_group.NotifyOptionParsingFinished(&exe_ctx));
|
|
if (error.Fail()) {
|
|
result.AppendError(error.AsCString());
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
if (nullptr == remainder)
|
|
remainder = raw_command_line;
|
|
|
|
llvm::StringRef raw_command_string(remainder);
|
|
Args args(raw_command_string);
|
|
|
|
if (args.GetArgumentCount() < 2) {
|
|
result.AppendError("'command alias' requires at least two arguments");
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
// Get the alias command.
|
|
|
|
auto alias_command = args[0].ref;
|
|
if (alias_command.startswith("-")) {
|
|
result.AppendError("aliases starting with a dash are not supported");
|
|
if (alias_command == "--help" || alias_command == "--long-help") {
|
|
result.AppendWarning("if trying to pass options to 'command alias' add "
|
|
"a -- at the end of the options");
|
|
}
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
// Strip the new alias name off 'raw_command_string' (leave it on args,
|
|
// which gets passed to 'Execute', which
|
|
// does the stripping itself.
|
|
size_t pos = raw_command_string.find(alias_command);
|
|
if (pos == 0) {
|
|
raw_command_string = raw_command_string.substr(alias_command.size());
|
|
pos = raw_command_string.find_first_not_of(' ');
|
|
if ((pos != std::string::npos) && (pos > 0))
|
|
raw_command_string = raw_command_string.substr(pos);
|
|
} else {
|
|
result.AppendError("Error parsing command string. No alias created.");
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
// Verify that the command is alias-able.
|
|
if (m_interpreter.CommandExists(alias_command)) {
|
|
result.AppendErrorWithFormat(
|
|
"'%s' is a permanent debugger command and cannot be redefined.\n",
|
|
args[0].c_str());
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
// Get CommandObject that is being aliased. The command name is read from
|
|
// the front of raw_command_string. raw_command_string is returned with the
|
|
// name of the command object stripped off the front.
|
|
llvm::StringRef original_raw_command_string = raw_command_string;
|
|
CommandObject *cmd_obj =
|
|
m_interpreter.GetCommandObjectForCommand(raw_command_string);
|
|
|
|
if (!cmd_obj) {
|
|
result.AppendErrorWithFormat("invalid command given to 'command alias'. "
|
|
"'%s' does not begin with a valid command."
|
|
" No alias created.",
|
|
original_raw_command_string.str().c_str());
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
} else if (!cmd_obj->WantsRawCommandString()) {
|
|
// Note that args was initialized with the original command, and has not
|
|
// been updated to this point.
|
|
// Therefore can we pass it to the version of Execute that does not
|
|
// need/expect raw input in the alias.
|
|
return HandleAliasingNormalCommand(args, result);
|
|
} else {
|
|
return HandleAliasingRawCommand(alias_command, raw_command_string,
|
|
*cmd_obj, result);
|
|
}
|
|
return result.Succeeded();
|
|
}
|
|
|
|
bool HandleAliasingRawCommand(llvm::StringRef alias_command,
|
|
llvm::StringRef raw_command_string,
|
|
CommandObject &cmd_obj,
|
|
CommandReturnObject &result) {
|
|
// Verify & handle any options/arguments passed to the alias command
|
|
|
|
OptionArgVectorSP option_arg_vector_sp =
|
|
OptionArgVectorSP(new OptionArgVector);
|
|
|
|
if (CommandObjectSP cmd_obj_sp =
|
|
m_interpreter.GetCommandSPExact(cmd_obj.GetCommandName(), false)) {
|
|
if (m_interpreter.AliasExists(alias_command) ||
|
|
m_interpreter.UserCommandExists(alias_command)) {
|
|
result.AppendWarningWithFormat(
|
|
"Overwriting existing definition for '%s'.\n",
|
|
alias_command.str().c_str());
|
|
}
|
|
if (CommandAlias *alias = m_interpreter.AddAlias(
|
|
alias_command, cmd_obj_sp, raw_command_string)) {
|
|
if (m_command_options.m_help.OptionWasSet())
|
|
alias->SetHelp(m_command_options.m_help.GetCurrentValue());
|
|
if (m_command_options.m_long_help.OptionWasSet())
|
|
alias->SetHelpLong(m_command_options.m_long_help.GetCurrentValue());
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
} else {
|
|
result.AppendError("Unable to create requested alias.\n");
|
|
result.SetStatus(eReturnStatusFailed);
|
|
}
|
|
|
|
} else {
|
|
result.AppendError("Unable to create requested alias.\n");
|
|
result.SetStatus(eReturnStatusFailed);
|
|
}
|
|
|
|
return result.Succeeded();
|
|
}
|
|
|
|
bool HandleAliasingNormalCommand(Args &args, CommandReturnObject &result) {
|
|
size_t argc = args.GetArgumentCount();
|
|
|
|
if (argc < 2) {
|
|
result.AppendError("'command alias' requires at least two arguments");
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
// Save these in std::strings since we're going to shift them off.
|
|
const std::string alias_command(args[0].ref);
|
|
const std::string actual_command(args[1].ref);
|
|
|
|
args.Shift(); // Shift the alias command word off the argument vector.
|
|
args.Shift(); // Shift the old command word off the argument vector.
|
|
|
|
// Verify that the command is alias'able, and get the appropriate command
|
|
// object.
|
|
|
|
if (m_interpreter.CommandExists(alias_command)) {
|
|
result.AppendErrorWithFormat(
|
|
"'%s' is a permanent debugger command and cannot be redefined.\n",
|
|
alias_command.c_str());
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
CommandObjectSP command_obj_sp(
|
|
m_interpreter.GetCommandSPExact(actual_command, true));
|
|
CommandObjectSP subcommand_obj_sp;
|
|
bool use_subcommand = false;
|
|
if (!command_obj_sp) {
|
|
result.AppendErrorWithFormat("'%s' is not an existing command.\n",
|
|
actual_command.c_str());
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
CommandObject *cmd_obj = command_obj_sp.get();
|
|
CommandObject *sub_cmd_obj = nullptr;
|
|
OptionArgVectorSP option_arg_vector_sp =
|
|
OptionArgVectorSP(new OptionArgVector);
|
|
|
|
while (cmd_obj->IsMultiwordObject() && !args.empty()) {
|
|
auto sub_command = args[0].ref;
|
|
assert(!sub_command.empty());
|
|
subcommand_obj_sp = cmd_obj->GetSubcommandSP(sub_command);
|
|
if (!subcommand_obj_sp) {
|
|
result.AppendErrorWithFormat(
|
|
"'%s' is not a valid sub-command of '%s'. "
|
|
"Unable to create alias.\n",
|
|
args[0].c_str(), actual_command.c_str());
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
sub_cmd_obj = subcommand_obj_sp.get();
|
|
use_subcommand = true;
|
|
args.Shift(); // Shift the sub_command word off the argument vector.
|
|
cmd_obj = sub_cmd_obj;
|
|
}
|
|
|
|
// Verify & handle any options/arguments passed to the alias command
|
|
|
|
std::string args_string;
|
|
|
|
if (!args.empty()) {
|
|
CommandObjectSP tmp_sp =
|
|
m_interpreter.GetCommandSPExact(cmd_obj->GetCommandName(), false);
|
|
if (use_subcommand)
|
|
tmp_sp = m_interpreter.GetCommandSPExact(sub_cmd_obj->GetCommandName(),
|
|
false);
|
|
|
|
args.GetCommandString(args_string);
|
|
}
|
|
|
|
if (m_interpreter.AliasExists(alias_command) ||
|
|
m_interpreter.UserCommandExists(alias_command)) {
|
|
result.AppendWarningWithFormat(
|
|
"Overwriting existing definition for '%s'.\n", alias_command.c_str());
|
|
}
|
|
|
|
if (CommandAlias *alias = m_interpreter.AddAlias(
|
|
alias_command, use_subcommand ? subcommand_obj_sp : command_obj_sp,
|
|
args_string)) {
|
|
if (m_command_options.m_help.OptionWasSet())
|
|
alias->SetHelp(m_command_options.m_help.GetCurrentValue());
|
|
if (m_command_options.m_long_help.OptionWasSet())
|
|
alias->SetHelpLong(m_command_options.m_long_help.GetCurrentValue());
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
} else {
|
|
result.AppendError("Unable to create requested alias.\n");
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
return result.Succeeded();
|
|
}
|
|
};
|
|
|
|
#pragma mark CommandObjectCommandsUnalias
|
|
//-------------------------------------------------------------------------
|
|
// CommandObjectCommandsUnalias
|
|
//-------------------------------------------------------------------------
|
|
|
|
class CommandObjectCommandsUnalias : public CommandObjectParsed {
|
|
public:
|
|
CommandObjectCommandsUnalias(CommandInterpreter &interpreter)
|
|
: CommandObjectParsed(
|
|
interpreter, "command unalias",
|
|
"Delete one or more custom commands defined by 'command alias'.",
|
|
nullptr) {
|
|
CommandArgumentEntry arg;
|
|
CommandArgumentData alias_arg;
|
|
|
|
// Define the first (and only) variant of this arg.
|
|
alias_arg.arg_type = eArgTypeAliasName;
|
|
alias_arg.arg_repetition = eArgRepeatPlain;
|
|
|
|
// There is only one variant this argument could be; put it into the
|
|
// argument entry.
|
|
arg.push_back(alias_arg);
|
|
|
|
// Push the data for the first argument into the m_arguments vector.
|
|
m_arguments.push_back(arg);
|
|
}
|
|
|
|
~CommandObjectCommandsUnalias() override = default;
|
|
|
|
protected:
|
|
bool DoExecute(Args &args, CommandReturnObject &result) override {
|
|
CommandObject::CommandMap::iterator pos;
|
|
CommandObject *cmd_obj;
|
|
|
|
if (args.empty()) {
|
|
result.AppendError("must call 'unalias' with a valid alias");
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
auto command_name = args[0].ref;
|
|
cmd_obj = m_interpreter.GetCommandObject(command_name);
|
|
if (!cmd_obj) {
|
|
result.AppendErrorWithFormat(
|
|
"'%s' is not a known command.\nTry 'help' to see a "
|
|
"current list of commands.\n",
|
|
args[0].c_str());
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
if (m_interpreter.CommandExists(command_name)) {
|
|
if (cmd_obj->IsRemovable()) {
|
|
result.AppendErrorWithFormat(
|
|
"'%s' is not an alias, it is a debugger command which can be "
|
|
"removed using the 'command delete' command.\n",
|
|
args[0].c_str());
|
|
} else {
|
|
result.AppendErrorWithFormat(
|
|
"'%s' is a permanent debugger command and cannot be removed.\n",
|
|
args[0].c_str());
|
|
}
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
if (!m_interpreter.RemoveAlias(command_name)) {
|
|
if (m_interpreter.AliasExists(command_name))
|
|
result.AppendErrorWithFormat(
|
|
"Error occurred while attempting to unalias '%s'.\n",
|
|
args[0].c_str());
|
|
else
|
|
result.AppendErrorWithFormat("'%s' is not an existing alias.\n",
|
|
args[0].c_str());
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
return result.Succeeded();
|
|
}
|
|
};
|
|
|
|
#pragma mark CommandObjectCommandsDelete
|
|
//-------------------------------------------------------------------------
|
|
// CommandObjectCommandsDelete
|
|
//-------------------------------------------------------------------------
|
|
|
|
class CommandObjectCommandsDelete : public CommandObjectParsed {
|
|
public:
|
|
CommandObjectCommandsDelete(CommandInterpreter &interpreter)
|
|
: CommandObjectParsed(
|
|
interpreter, "command delete",
|
|
"Delete one or more custom commands defined by 'command regex'.",
|
|
nullptr) {
|
|
CommandArgumentEntry arg;
|
|
CommandArgumentData alias_arg;
|
|
|
|
// Define the first (and only) variant of this arg.
|
|
alias_arg.arg_type = eArgTypeCommandName;
|
|
alias_arg.arg_repetition = eArgRepeatPlain;
|
|
|
|
// There is only one variant this argument could be; put it into the
|
|
// argument entry.
|
|
arg.push_back(alias_arg);
|
|
|
|
// Push the data for the first argument into the m_arguments vector.
|
|
m_arguments.push_back(arg);
|
|
}
|
|
|
|
~CommandObjectCommandsDelete() override = default;
|
|
|
|
protected:
|
|
bool DoExecute(Args &args, CommandReturnObject &result) override {
|
|
CommandObject::CommandMap::iterator pos;
|
|
|
|
if (args.empty()) {
|
|
result.AppendErrorWithFormat("must call '%s' with one or more valid user "
|
|
"defined regular expression command names",
|
|
GetCommandName().str().c_str());
|
|
result.SetStatus(eReturnStatusFailed);
|
|
}
|
|
|
|
auto command_name = args[0].ref;
|
|
if (!m_interpreter.CommandExists(command_name)) {
|
|
StreamString error_msg_stream;
|
|
const bool generate_apropos = true;
|
|
const bool generate_type_lookup = false;
|
|
CommandObjectHelp::GenerateAdditionalHelpAvenuesMessage(
|
|
&error_msg_stream, command_name, llvm::StringRef(), llvm::StringRef(),
|
|
generate_apropos, generate_type_lookup);
|
|
result.AppendError(error_msg_stream.GetString());
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
if (!m_interpreter.RemoveCommand(command_name)) {
|
|
result.AppendErrorWithFormat(
|
|
"'%s' is a permanent debugger command and cannot be removed.\n",
|
|
args[0].c_str());
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
//-------------------------------------------------------------------------
|
|
// CommandObjectCommandsAddRegex
|
|
//-------------------------------------------------------------------------
|
|
|
|
static OptionDefinition g_regex_options[] = {
|
|
// clang-format off
|
|
{ LLDB_OPT_SET_1, false, "help" , 'h', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeNone, "The help text to display for this command." },
|
|
{ LLDB_OPT_SET_1, false, "syntax", 's', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeNone, "A syntax string showing the typical usage syntax." },
|
|
// clang-format on
|
|
};
|
|
|
|
#pragma mark CommandObjectCommandsAddRegex
|
|
|
|
class CommandObjectCommandsAddRegex : public CommandObjectParsed,
|
|
public IOHandlerDelegateMultiline {
|
|
public:
|
|
CommandObjectCommandsAddRegex(CommandInterpreter &interpreter)
|
|
: CommandObjectParsed(
|
|
interpreter, "command regex", "Define a custom command in terms of "
|
|
"existing commands by matching "
|
|
"regular expressions.",
|
|
"command regex <cmd-name> [s/<regex>/<subst>/ ...]"),
|
|
IOHandlerDelegateMultiline("",
|
|
IOHandlerDelegate::Completion::LLDBCommand),
|
|
m_options() {
|
|
SetHelpLong(
|
|
R"(
|
|
)"
|
|
"This command allows the user to create powerful regular expression commands \
|
|
with substitutions. The regular expressions and substitutions are specified \
|
|
using the regular expression substitution format of:"
|
|
R"(
|
|
|
|
s/<regex>/<subst>/
|
|
|
|
)"
|
|
"<regex> is a regular expression that can use parenthesis to capture regular \
|
|
expression input and substitute the captured matches in the output using %1 \
|
|
for the first match, %2 for the second, and so on."
|
|
R"(
|
|
|
|
)"
|
|
"The regular expressions can all be specified on the command line if more than \
|
|
one argument is provided. If just the command name is provided on the command \
|
|
line, then the regular expressions and substitutions can be entered on separate \
|
|
lines, followed by an empty line to terminate the command definition."
|
|
R"(
|
|
|
|
EXAMPLES
|
|
|
|
)"
|
|
"The following example will define a regular expression command named 'f' that \
|
|
will call 'finish' if there are no arguments, or 'frame select <frame-idx>' if \
|
|
a number follows 'f':"
|
|
R"(
|
|
|
|
(lldb) command regex f s/^$/finish/ 's/([0-9]+)/frame select %1/')");
|
|
}
|
|
|
|
~CommandObjectCommandsAddRegex() override = default;
|
|
|
|
protected:
|
|
void IOHandlerActivated(IOHandler &io_handler) override {
|
|
StreamFileSP output_sp(io_handler.GetOutputStreamFile());
|
|
if (output_sp) {
|
|
output_sp->PutCString("Enter one of more sed substitution commands in "
|
|
"the form: 's/<regex>/<subst>/'.\nTerminate the "
|
|
"substitution list with an empty line.\n");
|
|
output_sp->Flush();
|
|
}
|
|
}
|
|
|
|
void IOHandlerInputComplete(IOHandler &io_handler,
|
|
std::string &data) override {
|
|
io_handler.SetIsDone(true);
|
|
if (m_regex_cmd_ap) {
|
|
StringList lines;
|
|
if (lines.SplitIntoLines(data)) {
|
|
const size_t num_lines = lines.GetSize();
|
|
bool check_only = false;
|
|
for (size_t i = 0; i < num_lines; ++i) {
|
|
llvm::StringRef bytes_strref(lines[i]);
|
|
Status error = AppendRegexSubstitution(bytes_strref, check_only);
|
|
if (error.Fail()) {
|
|
if (!m_interpreter.GetDebugger()
|
|
.GetCommandInterpreter()
|
|
.GetBatchCommandMode()) {
|
|
StreamSP out_stream =
|
|
m_interpreter.GetDebugger().GetAsyncOutputStream();
|
|
out_stream->Printf("error: %s\n", error.AsCString());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (m_regex_cmd_ap->HasRegexEntries()) {
|
|
CommandObjectSP cmd_sp(m_regex_cmd_ap.release());
|
|
m_interpreter.AddCommand(cmd_sp->GetCommandName(), cmd_sp, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
bool DoExecute(Args &command, CommandReturnObject &result) override {
|
|
const size_t argc = command.GetArgumentCount();
|
|
if (argc == 0) {
|
|
result.AppendError("usage: 'command regex <command-name> "
|
|
"[s/<regex1>/<subst1>/ s/<regex2>/<subst2>/ ...]'\n");
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
Status error;
|
|
auto name = command[0].ref;
|
|
m_regex_cmd_ap = llvm::make_unique<CommandObjectRegexCommand>(
|
|
m_interpreter, name, m_options.GetHelp(), m_options.GetSyntax(), 10, 0,
|
|
true);
|
|
|
|
if (argc == 1) {
|
|
Debugger &debugger = m_interpreter.GetDebugger();
|
|
bool color_prompt = debugger.GetUseColor();
|
|
const bool multiple_lines = true; // Get multiple lines
|
|
IOHandlerSP io_handler_sp(new IOHandlerEditline(
|
|
debugger, IOHandler::Type::Other,
|
|
"lldb-regex", // Name of input reader for history
|
|
llvm::StringRef("> "), // Prompt
|
|
llvm::StringRef(), // Continuation prompt
|
|
multiple_lines, color_prompt,
|
|
0, // Don't show line numbers
|
|
*this));
|
|
|
|
if (io_handler_sp) {
|
|
debugger.PushIOHandler(io_handler_sp);
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
}
|
|
} else {
|
|
for (auto &entry : command.entries().drop_front()) {
|
|
bool check_only = false;
|
|
error = AppendRegexSubstitution(entry.ref, check_only);
|
|
if (error.Fail())
|
|
break;
|
|
}
|
|
|
|
if (error.Success()) {
|
|
AddRegexCommandToInterpreter();
|
|
}
|
|
}
|
|
if (error.Fail()) {
|
|
result.AppendError(error.AsCString());
|
|
result.SetStatus(eReturnStatusFailed);
|
|
}
|
|
|
|
return result.Succeeded();
|
|
}
|
|
|
|
Status AppendRegexSubstitution(const llvm::StringRef ®ex_sed,
|
|
bool check_only) {
|
|
Status error;
|
|
|
|
if (!m_regex_cmd_ap) {
|
|
error.SetErrorStringWithFormat(
|
|
"invalid regular expression command object for: '%.*s'",
|
|
(int)regex_sed.size(), regex_sed.data());
|
|
return error;
|
|
}
|
|
|
|
size_t regex_sed_size = regex_sed.size();
|
|
|
|
if (regex_sed_size <= 1) {
|
|
error.SetErrorStringWithFormat(
|
|
"regular expression substitution string is too short: '%.*s'",
|
|
(int)regex_sed.size(), regex_sed.data());
|
|
return error;
|
|
}
|
|
|
|
if (regex_sed[0] != 's') {
|
|
error.SetErrorStringWithFormat("regular expression substitution string "
|
|
"doesn't start with 's': '%.*s'",
|
|
(int)regex_sed.size(), regex_sed.data());
|
|
return error;
|
|
}
|
|
const size_t first_separator_char_pos = 1;
|
|
// use the char that follows 's' as the regex separator character
|
|
// so we can have "s/<regex>/<subst>/" or "s|<regex>|<subst>|"
|
|
const char separator_char = regex_sed[first_separator_char_pos];
|
|
const size_t second_separator_char_pos =
|
|
regex_sed.find(separator_char, first_separator_char_pos + 1);
|
|
|
|
if (second_separator_char_pos == std::string::npos) {
|
|
error.SetErrorStringWithFormat(
|
|
"missing second '%c' separator char after '%.*s' in '%.*s'",
|
|
separator_char,
|
|
(int)(regex_sed.size() - first_separator_char_pos - 1),
|
|
regex_sed.data() + (first_separator_char_pos + 1),
|
|
(int)regex_sed.size(), regex_sed.data());
|
|
return error;
|
|
}
|
|
|
|
const size_t third_separator_char_pos =
|
|
regex_sed.find(separator_char, second_separator_char_pos + 1);
|
|
|
|
if (third_separator_char_pos == std::string::npos) {
|
|
error.SetErrorStringWithFormat(
|
|
"missing third '%c' separator char after '%.*s' in '%.*s'",
|
|
separator_char,
|
|
(int)(regex_sed.size() - second_separator_char_pos - 1),
|
|
regex_sed.data() + (second_separator_char_pos + 1),
|
|
(int)regex_sed.size(), regex_sed.data());
|
|
return error;
|
|
}
|
|
|
|
if (third_separator_char_pos != regex_sed_size - 1) {
|
|
// Make sure that everything that follows the last regex
|
|
// separator char
|
|
if (regex_sed.find_first_not_of("\t\n\v\f\r ",
|
|
third_separator_char_pos + 1) !=
|
|
std::string::npos) {
|
|
error.SetErrorStringWithFormat(
|
|
"extra data found after the '%.*s' regular expression substitution "
|
|
"string: '%.*s'",
|
|
(int)third_separator_char_pos + 1, regex_sed.data(),
|
|
(int)(regex_sed.size() - third_separator_char_pos - 1),
|
|
regex_sed.data() + (third_separator_char_pos + 1));
|
|
return error;
|
|
}
|
|
} else if (first_separator_char_pos + 1 == second_separator_char_pos) {
|
|
error.SetErrorStringWithFormat(
|
|
"<regex> can't be empty in 's%c<regex>%c<subst>%c' string: '%.*s'",
|
|
separator_char, separator_char, separator_char, (int)regex_sed.size(),
|
|
regex_sed.data());
|
|
return error;
|
|
} else if (second_separator_char_pos + 1 == third_separator_char_pos) {
|
|
error.SetErrorStringWithFormat(
|
|
"<subst> can't be empty in 's%c<regex>%c<subst>%c' string: '%.*s'",
|
|
separator_char, separator_char, separator_char, (int)regex_sed.size(),
|
|
regex_sed.data());
|
|
return error;
|
|
}
|
|
|
|
if (!check_only) {
|
|
std::string regex(regex_sed.substr(first_separator_char_pos + 1,
|
|
second_separator_char_pos -
|
|
first_separator_char_pos - 1));
|
|
std::string subst(regex_sed.substr(second_separator_char_pos + 1,
|
|
third_separator_char_pos -
|
|
second_separator_char_pos - 1));
|
|
m_regex_cmd_ap->AddRegexCommand(regex.c_str(), subst.c_str());
|
|
}
|
|
return error;
|
|
}
|
|
|
|
void AddRegexCommandToInterpreter() {
|
|
if (m_regex_cmd_ap) {
|
|
if (m_regex_cmd_ap->HasRegexEntries()) {
|
|
CommandObjectSP cmd_sp(m_regex_cmd_ap.release());
|
|
m_interpreter.AddCommand(cmd_sp->GetCommandName(), cmd_sp, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
private:
|
|
std::unique_ptr<CommandObjectRegexCommand> m_regex_cmd_ap;
|
|
|
|
class CommandOptions : public Options {
|
|
public:
|
|
CommandOptions() : Options() {}
|
|
|
|
~CommandOptions() override = default;
|
|
|
|
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
|
|
ExecutionContext *execution_context) override {
|
|
Status error;
|
|
const int short_option = m_getopt_table[option_idx].val;
|
|
|
|
switch (short_option) {
|
|
case 'h':
|
|
m_help.assign(option_arg);
|
|
break;
|
|
case 's':
|
|
m_syntax.assign(option_arg);
|
|
break;
|
|
default:
|
|
error.SetErrorStringWithFormat("unrecognized option '%c'",
|
|
short_option);
|
|
break;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
void OptionParsingStarting(ExecutionContext *execution_context) override {
|
|
m_help.clear();
|
|
m_syntax.clear();
|
|
}
|
|
|
|
llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
|
|
return llvm::makeArrayRef(g_regex_options);
|
|
}
|
|
|
|
// TODO: Convert these functions to return StringRefs.
|
|
const char *GetHelp() {
|
|
return (m_help.empty() ? nullptr : m_help.c_str());
|
|
}
|
|
|
|
const char *GetSyntax() {
|
|
return (m_syntax.empty() ? nullptr : m_syntax.c_str());
|
|
}
|
|
|
|
protected:
|
|
// Instance variables to hold the values for command options.
|
|
|
|
std::string m_help;
|
|
std::string m_syntax;
|
|
};
|
|
|
|
Options *GetOptions() override { return &m_options; }
|
|
|
|
CommandOptions m_options;
|
|
};
|
|
|
|
class CommandObjectPythonFunction : public CommandObjectRaw {
|
|
public:
|
|
CommandObjectPythonFunction(CommandInterpreter &interpreter, std::string name,
|
|
std::string funct, std::string help,
|
|
ScriptedCommandSynchronicity synch)
|
|
: CommandObjectRaw(interpreter, name),
|
|
m_function_name(funct), m_synchro(synch), m_fetched_help_long(false) {
|
|
if (!help.empty())
|
|
SetHelp(help);
|
|
else {
|
|
StreamString stream;
|
|
stream.Printf("For more information run 'help %s'", name.c_str());
|
|
SetHelp(stream.GetString());
|
|
}
|
|
}
|
|
|
|
~CommandObjectPythonFunction() override = default;
|
|
|
|
bool IsRemovable() const override { return true; }
|
|
|
|
const std::string &GetFunctionName() { return m_function_name; }
|
|
|
|
ScriptedCommandSynchronicity GetSynchronicity() { return m_synchro; }
|
|
|
|
llvm::StringRef GetHelpLong() override {
|
|
if (m_fetched_help_long)
|
|
return CommandObjectRaw::GetHelpLong();
|
|
|
|
ScriptInterpreter *scripter = m_interpreter.GetScriptInterpreter();
|
|
if (!scripter)
|
|
return CommandObjectRaw::GetHelpLong();
|
|
|
|
std::string docstring;
|
|
m_fetched_help_long =
|
|
scripter->GetDocumentationForItem(m_function_name.c_str(), docstring);
|
|
if (!docstring.empty())
|
|
SetHelpLong(docstring);
|
|
return CommandObjectRaw::GetHelpLong();
|
|
}
|
|
|
|
protected:
|
|
bool DoExecute(const char *raw_command_line,
|
|
CommandReturnObject &result) override {
|
|
ScriptInterpreter *scripter = m_interpreter.GetScriptInterpreter();
|
|
|
|
Status error;
|
|
|
|
result.SetStatus(eReturnStatusInvalid);
|
|
|
|
if (!scripter ||
|
|
!scripter->RunScriptBasedCommand(m_function_name.c_str(),
|
|
raw_command_line, m_synchro, result,
|
|
error, m_exe_ctx)) {
|
|
result.AppendError(error.AsCString());
|
|
result.SetStatus(eReturnStatusFailed);
|
|
} else {
|
|
// Don't change the status if the command already set it...
|
|
if (result.GetStatus() == eReturnStatusInvalid) {
|
|
if (result.GetOutputData().empty())
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
else
|
|
result.SetStatus(eReturnStatusSuccessFinishResult);
|
|
}
|
|
}
|
|
|
|
return result.Succeeded();
|
|
}
|
|
|
|
private:
|
|
std::string m_function_name;
|
|
ScriptedCommandSynchronicity m_synchro;
|
|
bool m_fetched_help_long;
|
|
};
|
|
|
|
class CommandObjectScriptingObject : public CommandObjectRaw {
|
|
public:
|
|
CommandObjectScriptingObject(CommandInterpreter &interpreter,
|
|
std::string name,
|
|
StructuredData::GenericSP cmd_obj_sp,
|
|
ScriptedCommandSynchronicity synch)
|
|
: CommandObjectRaw(interpreter, name),
|
|
m_cmd_obj_sp(cmd_obj_sp), m_synchro(synch), m_fetched_help_short(false),
|
|
m_fetched_help_long(false) {
|
|
StreamString stream;
|
|
stream.Printf("For more information run 'help %s'", name.c_str());
|
|
SetHelp(stream.GetString());
|
|
if (ScriptInterpreter *scripter = m_interpreter.GetScriptInterpreter())
|
|
GetFlags().Set(scripter->GetFlagsForCommandObject(cmd_obj_sp));
|
|
}
|
|
|
|
~CommandObjectScriptingObject() override = default;
|
|
|
|
bool IsRemovable() const override { return true; }
|
|
|
|
StructuredData::GenericSP GetImplementingObject() { return m_cmd_obj_sp; }
|
|
|
|
ScriptedCommandSynchronicity GetSynchronicity() { return m_synchro; }
|
|
|
|
llvm::StringRef GetHelp() override {
|
|
if (m_fetched_help_short)
|
|
return CommandObjectRaw::GetHelp();
|
|
ScriptInterpreter *scripter = m_interpreter.GetScriptInterpreter();
|
|
if (!scripter)
|
|
return CommandObjectRaw::GetHelp();
|
|
std::string docstring;
|
|
m_fetched_help_short =
|
|
scripter->GetShortHelpForCommandObject(m_cmd_obj_sp, docstring);
|
|
if (!docstring.empty())
|
|
SetHelp(docstring);
|
|
|
|
return CommandObjectRaw::GetHelp();
|
|
}
|
|
|
|
llvm::StringRef GetHelpLong() override {
|
|
if (m_fetched_help_long)
|
|
return CommandObjectRaw::GetHelpLong();
|
|
|
|
ScriptInterpreter *scripter = m_interpreter.GetScriptInterpreter();
|
|
if (!scripter)
|
|
return CommandObjectRaw::GetHelpLong();
|
|
|
|
std::string docstring;
|
|
m_fetched_help_long =
|
|
scripter->GetLongHelpForCommandObject(m_cmd_obj_sp, docstring);
|
|
if (!docstring.empty())
|
|
SetHelpLong(docstring);
|
|
return CommandObjectRaw::GetHelpLong();
|
|
}
|
|
|
|
protected:
|
|
bool DoExecute(const char *raw_command_line,
|
|
CommandReturnObject &result) override {
|
|
ScriptInterpreter *scripter = m_interpreter.GetScriptInterpreter();
|
|
|
|
Status error;
|
|
|
|
result.SetStatus(eReturnStatusInvalid);
|
|
|
|
if (!scripter ||
|
|
!scripter->RunScriptBasedCommand(m_cmd_obj_sp, raw_command_line,
|
|
m_synchro, result, error, m_exe_ctx)) {
|
|
result.AppendError(error.AsCString());
|
|
result.SetStatus(eReturnStatusFailed);
|
|
} else {
|
|
// Don't change the status if the command already set it...
|
|
if (result.GetStatus() == eReturnStatusInvalid) {
|
|
if (result.GetOutputData().empty())
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
else
|
|
result.SetStatus(eReturnStatusSuccessFinishResult);
|
|
}
|
|
}
|
|
|
|
return result.Succeeded();
|
|
}
|
|
|
|
private:
|
|
StructuredData::GenericSP m_cmd_obj_sp;
|
|
ScriptedCommandSynchronicity m_synchro;
|
|
bool m_fetched_help_short : 1;
|
|
bool m_fetched_help_long : 1;
|
|
};
|
|
|
|
//-------------------------------------------------------------------------
|
|
// CommandObjectCommandsScriptImport
|
|
//-------------------------------------------------------------------------
|
|
|
|
OptionDefinition g_script_import_options[] = {
|
|
// clang-format off
|
|
{ LLDB_OPT_SET_1, false, "allow-reload", 'r', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Allow the script to be loaded even if it was already loaded before. This argument exists for backwards compatibility, but reloading is always allowed, whether you specify it or not." },
|
|
// clang-format on
|
|
};
|
|
|
|
class CommandObjectCommandsScriptImport : public CommandObjectParsed {
|
|
public:
|
|
CommandObjectCommandsScriptImport(CommandInterpreter &interpreter)
|
|
: CommandObjectParsed(interpreter, "command script import",
|
|
"Import a scripting module in LLDB.", nullptr),
|
|
m_options() {
|
|
CommandArgumentEntry arg1;
|
|
CommandArgumentData cmd_arg;
|
|
|
|
// Define the first (and only) variant of this arg.
|
|
cmd_arg.arg_type = eArgTypeFilename;
|
|
cmd_arg.arg_repetition = eArgRepeatPlus;
|
|
|
|
// There is only one variant this argument could be; put it into the
|
|
// argument entry.
|
|
arg1.push_back(cmd_arg);
|
|
|
|
// Push the data for the first argument into the m_arguments vector.
|
|
m_arguments.push_back(arg1);
|
|
}
|
|
|
|
~CommandObjectCommandsScriptImport() override = default;
|
|
|
|
int 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) override {
|
|
llvm::StringRef completion_str = input[cursor_index].ref;
|
|
completion_str = completion_str.take_front(cursor_char_position);
|
|
|
|
CommandCompletions::InvokeCommonCompletionCallbacks(
|
|
GetCommandInterpreter(), CommandCompletions::eDiskFileCompletion,
|
|
completion_str, match_start_point, max_return_elements, nullptr,
|
|
word_complete, matches);
|
|
return matches.GetSize();
|
|
}
|
|
|
|
Options *GetOptions() override { return &m_options; }
|
|
|
|
protected:
|
|
class CommandOptions : public Options {
|
|
public:
|
|
CommandOptions() : Options() {}
|
|
|
|
~CommandOptions() override = default;
|
|
|
|
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
|
|
ExecutionContext *execution_context) override {
|
|
Status error;
|
|
const int short_option = m_getopt_table[option_idx].val;
|
|
|
|
switch (short_option) {
|
|
case 'r':
|
|
m_allow_reload = true;
|
|
break;
|
|
default:
|
|
error.SetErrorStringWithFormat("unrecognized option '%c'",
|
|
short_option);
|
|
break;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
void OptionParsingStarting(ExecutionContext *execution_context) override {
|
|
m_allow_reload = true;
|
|
}
|
|
|
|
llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
|
|
return llvm::makeArrayRef(g_script_import_options);
|
|
}
|
|
|
|
// Instance variables to hold the values for command options.
|
|
|
|
bool m_allow_reload;
|
|
};
|
|
|
|
bool DoExecute(Args &command, CommandReturnObject &result) override {
|
|
if (m_interpreter.GetDebugger().GetScriptLanguage() !=
|
|
lldb::eScriptLanguagePython) {
|
|
result.AppendError("only scripting language supported for module "
|
|
"importing is currently Python");
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
if (command.empty()) {
|
|
result.AppendError("command script import needs one or more arguments");
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
for (auto &entry : command.entries()) {
|
|
Status error;
|
|
|
|
const bool init_session = true;
|
|
// FIXME: this is necessary because CommandObject::CheckRequirements()
|
|
// assumes that commands won't ever be recursively invoked, but it's
|
|
// actually possible to craft a Python script that does other "command
|
|
// script imports" in __lldb_init_module the real fix is to have recursive
|
|
// commands possible with a CommandInvocation object separate from the
|
|
// CommandObject itself, so that recursive command invocations won't stomp
|
|
// on each other (wrt to execution contents, options, and more)
|
|
m_exe_ctx.Clear();
|
|
if (m_interpreter.GetScriptInterpreter()->LoadScriptingModule(
|
|
entry.c_str(), m_options.m_allow_reload, init_session, error)) {
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
} else {
|
|
result.AppendErrorWithFormat("module importing failed: %s",
|
|
error.AsCString());
|
|
result.SetStatus(eReturnStatusFailed);
|
|
}
|
|
}
|
|
|
|
return result.Succeeded();
|
|
}
|
|
|
|
CommandOptions m_options;
|
|
};
|
|
|
|
//-------------------------------------------------------------------------
|
|
// CommandObjectCommandsScriptAdd
|
|
//-------------------------------------------------------------------------
|
|
|
|
static OptionEnumValueElement g_script_synchro_type[] = {
|
|
{eScriptedCommandSynchronicitySynchronous, "synchronous",
|
|
"Run synchronous"},
|
|
{eScriptedCommandSynchronicityAsynchronous, "asynchronous",
|
|
"Run asynchronous"},
|
|
{eScriptedCommandSynchronicityCurrentValue, "current",
|
|
"Do not alter current setting"},
|
|
{0, nullptr, nullptr}};
|
|
|
|
static OptionDefinition g_script_add_options[] = {
|
|
// clang-format off
|
|
{ LLDB_OPT_SET_1, false, "function", 'f', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePythonFunction, "Name of the Python function to bind to this command name." },
|
|
{ LLDB_OPT_SET_2, false, "class", 'c', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypePythonClass, "Name of the Python class to bind to this command name." },
|
|
{ LLDB_OPT_SET_1, false, "help" , 'h', OptionParser::eRequiredArgument, nullptr, nullptr, 0, eArgTypeHelpText, "The help text to display for this command." },
|
|
{ LLDB_OPT_SET_ALL, false, "synchronicity", 's', OptionParser::eRequiredArgument, nullptr, g_script_synchro_type, 0, eArgTypeScriptedCommandSynchronicity, "Set the synchronicity of this command's executions with regard to LLDB event system." },
|
|
// clang-format on
|
|
};
|
|
|
|
class CommandObjectCommandsScriptAdd : public CommandObjectParsed,
|
|
public IOHandlerDelegateMultiline {
|
|
public:
|
|
CommandObjectCommandsScriptAdd(CommandInterpreter &interpreter)
|
|
: CommandObjectParsed(interpreter, "command script add",
|
|
"Add a scripted function as an LLDB command.",
|
|
nullptr),
|
|
IOHandlerDelegateMultiline("DONE"), m_options() {
|
|
CommandArgumentEntry arg1;
|
|
CommandArgumentData cmd_arg;
|
|
|
|
// Define the first (and only) variant of this arg.
|
|
cmd_arg.arg_type = eArgTypeCommandName;
|
|
cmd_arg.arg_repetition = eArgRepeatPlain;
|
|
|
|
// There is only one variant this argument could be; put it into the
|
|
// argument entry.
|
|
arg1.push_back(cmd_arg);
|
|
|
|
// Push the data for the first argument into the m_arguments vector.
|
|
m_arguments.push_back(arg1);
|
|
}
|
|
|
|
~CommandObjectCommandsScriptAdd() override = default;
|
|
|
|
Options *GetOptions() override { return &m_options; }
|
|
|
|
protected:
|
|
class CommandOptions : public Options {
|
|
public:
|
|
CommandOptions()
|
|
: Options(), m_class_name(), m_funct_name(), m_short_help(),
|
|
m_synchronicity(eScriptedCommandSynchronicitySynchronous) {}
|
|
|
|
~CommandOptions() override = default;
|
|
|
|
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
|
|
ExecutionContext *execution_context) override {
|
|
Status error;
|
|
const int short_option = m_getopt_table[option_idx].val;
|
|
|
|
switch (short_option) {
|
|
case 'f':
|
|
if (!option_arg.empty())
|
|
m_funct_name = option_arg;
|
|
break;
|
|
case 'c':
|
|
if (!option_arg.empty())
|
|
m_class_name = option_arg;
|
|
break;
|
|
case 'h':
|
|
if (!option_arg.empty())
|
|
m_short_help = option_arg;
|
|
break;
|
|
case 's':
|
|
m_synchronicity =
|
|
(ScriptedCommandSynchronicity)Args::StringToOptionEnum(
|
|
option_arg, GetDefinitions()[option_idx].enum_values, 0, error);
|
|
if (!error.Success())
|
|
error.SetErrorStringWithFormat(
|
|
"unrecognized value for synchronicity '%s'",
|
|
option_arg.str().c_str());
|
|
break;
|
|
default:
|
|
error.SetErrorStringWithFormat("unrecognized option '%c'",
|
|
short_option);
|
|
break;
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
void OptionParsingStarting(ExecutionContext *execution_context) override {
|
|
m_class_name.clear();
|
|
m_funct_name.clear();
|
|
m_short_help.clear();
|
|
m_synchronicity = eScriptedCommandSynchronicitySynchronous;
|
|
}
|
|
|
|
llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
|
|
return llvm::makeArrayRef(g_script_add_options);
|
|
}
|
|
|
|
// Instance variables to hold the values for command options.
|
|
|
|
std::string m_class_name;
|
|
std::string m_funct_name;
|
|
std::string m_short_help;
|
|
ScriptedCommandSynchronicity m_synchronicity;
|
|
};
|
|
|
|
void IOHandlerActivated(IOHandler &io_handler) override {
|
|
StreamFileSP output_sp(io_handler.GetOutputStreamFile());
|
|
if (output_sp) {
|
|
output_sp->PutCString(g_python_command_instructions);
|
|
output_sp->Flush();
|
|
}
|
|
}
|
|
|
|
void IOHandlerInputComplete(IOHandler &io_handler,
|
|
std::string &data) override {
|
|
StreamFileSP error_sp = io_handler.GetErrorStreamFile();
|
|
|
|
ScriptInterpreter *interpreter = m_interpreter.GetScriptInterpreter();
|
|
if (interpreter) {
|
|
|
|
StringList lines;
|
|
lines.SplitIntoLines(data);
|
|
if (lines.GetSize() > 0) {
|
|
std::string funct_name_str;
|
|
if (interpreter->GenerateScriptAliasFunction(lines, funct_name_str)) {
|
|
if (funct_name_str.empty()) {
|
|
error_sp->Printf("error: unable to obtain a function name, didn't "
|
|
"add python command.\n");
|
|
error_sp->Flush();
|
|
} else {
|
|
// everything should be fine now, let's add this alias
|
|
|
|
CommandObjectSP command_obj_sp(new CommandObjectPythonFunction(
|
|
m_interpreter, m_cmd_name, funct_name_str, m_short_help,
|
|
m_synchronicity));
|
|
|
|
if (!m_interpreter.AddUserCommand(m_cmd_name, command_obj_sp,
|
|
true)) {
|
|
error_sp->Printf("error: unable to add selected command, didn't "
|
|
"add python command.\n");
|
|
error_sp->Flush();
|
|
}
|
|
}
|
|
} else {
|
|
error_sp->Printf(
|
|
"error: unable to create function, didn't add python command.\n");
|
|
error_sp->Flush();
|
|
}
|
|
} else {
|
|
error_sp->Printf("error: empty function, didn't add python command.\n");
|
|
error_sp->Flush();
|
|
}
|
|
} else {
|
|
error_sp->Printf(
|
|
"error: script interpreter missing, didn't add python command.\n");
|
|
error_sp->Flush();
|
|
}
|
|
|
|
io_handler.SetIsDone(true);
|
|
}
|
|
|
|
protected:
|
|
bool DoExecute(Args &command, CommandReturnObject &result) override {
|
|
if (m_interpreter.GetDebugger().GetScriptLanguage() !=
|
|
lldb::eScriptLanguagePython) {
|
|
result.AppendError("only scripting language supported for scripted "
|
|
"commands is currently Python");
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
if (command.GetArgumentCount() != 1) {
|
|
result.AppendError("'command script add' requires one argument");
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
// Store the options in case we get multi-line input
|
|
m_cmd_name = command[0].ref;
|
|
m_short_help.assign(m_options.m_short_help);
|
|
m_synchronicity = m_options.m_synchronicity;
|
|
|
|
if (m_options.m_class_name.empty()) {
|
|
if (m_options.m_funct_name.empty()) {
|
|
m_interpreter.GetPythonCommandsFromIOHandler(
|
|
" ", // Prompt
|
|
*this, // IOHandlerDelegate
|
|
true, // Run IOHandler in async mode
|
|
nullptr); // Baton for the "io_handler" that will be passed back
|
|
// into our IOHandlerDelegate functions
|
|
} else {
|
|
CommandObjectSP new_cmd(new CommandObjectPythonFunction(
|
|
m_interpreter, m_cmd_name, m_options.m_funct_name,
|
|
m_options.m_short_help, m_synchronicity));
|
|
if (m_interpreter.AddUserCommand(m_cmd_name, new_cmd, true)) {
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
} else {
|
|
result.AppendError("cannot add command");
|
|
result.SetStatus(eReturnStatusFailed);
|
|
}
|
|
}
|
|
} else {
|
|
ScriptInterpreter *interpreter =
|
|
GetCommandInterpreter().GetScriptInterpreter();
|
|
if (!interpreter) {
|
|
result.AppendError("cannot find ScriptInterpreter");
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
auto cmd_obj_sp = interpreter->CreateScriptCommandObject(
|
|
m_options.m_class_name.c_str());
|
|
if (!cmd_obj_sp) {
|
|
result.AppendError("cannot create helper object");
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
CommandObjectSP new_cmd(new CommandObjectScriptingObject(
|
|
m_interpreter, m_cmd_name, cmd_obj_sp, m_synchronicity));
|
|
if (m_interpreter.AddUserCommand(m_cmd_name, new_cmd, true)) {
|
|
result.SetStatus(eReturnStatusSuccessFinishNoResult);
|
|
} else {
|
|
result.AppendError("cannot add command");
|
|
result.SetStatus(eReturnStatusFailed);
|
|
}
|
|
}
|
|
|
|
return result.Succeeded();
|
|
}
|
|
|
|
CommandOptions m_options;
|
|
std::string m_cmd_name;
|
|
std::string m_short_help;
|
|
ScriptedCommandSynchronicity m_synchronicity;
|
|
};
|
|
|
|
//-------------------------------------------------------------------------
|
|
// CommandObjectCommandsScriptList
|
|
//-------------------------------------------------------------------------
|
|
|
|
class CommandObjectCommandsScriptList : public CommandObjectParsed {
|
|
public:
|
|
CommandObjectCommandsScriptList(CommandInterpreter &interpreter)
|
|
: CommandObjectParsed(interpreter, "command script list",
|
|
"List defined scripted commands.", nullptr) {}
|
|
|
|
~CommandObjectCommandsScriptList() override = default;
|
|
|
|
bool DoExecute(Args &command, CommandReturnObject &result) override {
|
|
m_interpreter.GetHelp(result, CommandInterpreter::eCommandTypesUserDef);
|
|
|
|
result.SetStatus(eReturnStatusSuccessFinishResult);
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
//-------------------------------------------------------------------------
|
|
// CommandObjectCommandsScriptClear
|
|
//-------------------------------------------------------------------------
|
|
|
|
class CommandObjectCommandsScriptClear : public CommandObjectParsed {
|
|
public:
|
|
CommandObjectCommandsScriptClear(CommandInterpreter &interpreter)
|
|
: CommandObjectParsed(interpreter, "command script clear",
|
|
"Delete all scripted commands.", nullptr) {}
|
|
|
|
~CommandObjectCommandsScriptClear() override = default;
|
|
|
|
protected:
|
|
bool DoExecute(Args &command, CommandReturnObject &result) override {
|
|
m_interpreter.RemoveAllUser();
|
|
|
|
result.SetStatus(eReturnStatusSuccessFinishResult);
|
|
|
|
return true;
|
|
}
|
|
};
|
|
|
|
//-------------------------------------------------------------------------
|
|
// CommandObjectCommandsScriptDelete
|
|
//-------------------------------------------------------------------------
|
|
|
|
class CommandObjectCommandsScriptDelete : public CommandObjectParsed {
|
|
public:
|
|
CommandObjectCommandsScriptDelete(CommandInterpreter &interpreter)
|
|
: CommandObjectParsed(interpreter, "command script delete",
|
|
"Delete a scripted command.", nullptr) {
|
|
CommandArgumentEntry arg1;
|
|
CommandArgumentData cmd_arg;
|
|
|
|
// Define the first (and only) variant of this arg.
|
|
cmd_arg.arg_type = eArgTypeCommandName;
|
|
cmd_arg.arg_repetition = eArgRepeatPlain;
|
|
|
|
// There is only one variant this argument could be; put it into the
|
|
// argument entry.
|
|
arg1.push_back(cmd_arg);
|
|
|
|
// Push the data for the first argument into the m_arguments vector.
|
|
m_arguments.push_back(arg1);
|
|
}
|
|
|
|
~CommandObjectCommandsScriptDelete() override = default;
|
|
|
|
protected:
|
|
bool DoExecute(Args &command, CommandReturnObject &result) override {
|
|
|
|
if (command.GetArgumentCount() != 1) {
|
|
result.AppendError("'command script delete' requires one argument");
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
auto cmd_name = command[0].ref;
|
|
|
|
if (cmd_name.empty() || !m_interpreter.HasUserCommands() ||
|
|
!m_interpreter.UserCommandExists(cmd_name)) {
|
|
result.AppendErrorWithFormat("command %s not found", command[0].c_str());
|
|
result.SetStatus(eReturnStatusFailed);
|
|
return false;
|
|
}
|
|
|
|
m_interpreter.RemoveUser(cmd_name);
|
|
result.SetStatus(eReturnStatusSuccessFinishResult);
|
|
return true;
|
|
}
|
|
};
|
|
|
|
#pragma mark CommandObjectMultiwordCommandsScript
|
|
|
|
//-------------------------------------------------------------------------
|
|
// CommandObjectMultiwordCommandsScript
|
|
//-------------------------------------------------------------------------
|
|
|
|
class CommandObjectMultiwordCommandsScript : public CommandObjectMultiword {
|
|
public:
|
|
CommandObjectMultiwordCommandsScript(CommandInterpreter &interpreter)
|
|
: CommandObjectMultiword(
|
|
interpreter, "command script", "Commands for managing custom "
|
|
"commands implemented by "
|
|
"interpreter scripts.",
|
|
"command script <subcommand> [<subcommand-options>]") {
|
|
LoadSubCommand("add", CommandObjectSP(
|
|
new CommandObjectCommandsScriptAdd(interpreter)));
|
|
LoadSubCommand(
|
|
"delete",
|
|
CommandObjectSP(new CommandObjectCommandsScriptDelete(interpreter)));
|
|
LoadSubCommand(
|
|
"clear",
|
|
CommandObjectSP(new CommandObjectCommandsScriptClear(interpreter)));
|
|
LoadSubCommand("list", CommandObjectSP(new CommandObjectCommandsScriptList(
|
|
interpreter)));
|
|
LoadSubCommand(
|
|
"import",
|
|
CommandObjectSP(new CommandObjectCommandsScriptImport(interpreter)));
|
|
}
|
|
|
|
~CommandObjectMultiwordCommandsScript() override = default;
|
|
};
|
|
|
|
#pragma mark CommandObjectMultiwordCommands
|
|
|
|
//-------------------------------------------------------------------------
|
|
// CommandObjectMultiwordCommands
|
|
//-------------------------------------------------------------------------
|
|
|
|
CommandObjectMultiwordCommands::CommandObjectMultiwordCommands(
|
|
CommandInterpreter &interpreter)
|
|
: CommandObjectMultiword(interpreter, "command",
|
|
"Commands for managing custom LLDB commands.",
|
|
"command <subcommand> [<subcommand-options>]") {
|
|
LoadSubCommand("source",
|
|
CommandObjectSP(new CommandObjectCommandsSource(interpreter)));
|
|
LoadSubCommand("alias",
|
|
CommandObjectSP(new CommandObjectCommandsAlias(interpreter)));
|
|
LoadSubCommand("unalias", CommandObjectSP(
|
|
new CommandObjectCommandsUnalias(interpreter)));
|
|
LoadSubCommand("delete",
|
|
CommandObjectSP(new CommandObjectCommandsDelete(interpreter)));
|
|
LoadSubCommand(
|
|
"regex", CommandObjectSP(new CommandObjectCommandsAddRegex(interpreter)));
|
|
LoadSubCommand("history", CommandObjectSP(
|
|
new CommandObjectCommandsHistory(interpreter)));
|
|
LoadSubCommand(
|
|
"script",
|
|
CommandObjectSP(new CommandObjectMultiwordCommandsScript(interpreter)));
|
|
}
|
|
|
|
CommandObjectMultiwordCommands::~CommandObjectMultiwordCommands() = default;
|