From 60b571e49a90d38697b3aca23020d9da42fc7d7f Mon Sep 17 00:00:00 2001 From: dim Date: Sun, 2 Apr 2017 17:24:58 +0000 Subject: Update clang, llvm, lld, lldb, compiler-rt and libc++ to 4.0.0 release: MFC r309142 (by emaste): Add WITH_LLD_AS_LD build knob If set it installs LLD as /usr/bin/ld. LLD (as of version 3.9) is not capable of linking the world and kernel, but can self-host and link many substantial applications. GNU ld continues to be used for the world and kernel build, regardless of how this knob is set. It is on by default for arm64, and off for all other CPU architectures. Sponsored by: The FreeBSD Foundation MFC r310840: Reapply 310775, now it also builds correctly if lldb is disabled: Move llvm-objdump from CLANG_EXTRAS to installed by default We currently install three tools from binutils 2.17.50: as, ld, and objdump. Work is underway to migrate to a permissively-licensed tool-chain, with one goal being the retirement of binutils 2.17.50. LLVM's llvm-objdump is intended to be compatible with GNU objdump although it is currently missing some options and may have formatting differences. Enable it by default for testing and further investigation. It may later be changed to install as /usr/bin/objdump, it becomes a fully viable replacement. Reviewed by: emaste Differential Revision: https://reviews.freebsd.org/D8879 MFC r312855 (by emaste): Rename LLD_AS_LD to LLD_IS_LD, for consistency with CLANG_IS_CC Reported by: Dan McGregor MFC r313559 | glebius | 2017-02-10 18:34:48 +0100 (Fri, 10 Feb 2017) | 5 lines Don't check struct rtentry on FreeBSD, it is an internal kernel structure. On other systems it may be API structure for SIOCADDRT/SIOCDELRT. Reviewed by: emaste, dim MFC r314152 (by jkim): Remove an assembler flag, which is redundant since r309124. The upstream took care of it by introducing a macro NO_EXEC_STACK_DIRECTIVE. http://llvm.org/viewvc/llvm-project?rev=273500&view=rev Reviewed by: dim MFC r314564: Upgrade our copies of clang, llvm, lld, lldb, compiler-rt and libc++ to 4.0.0 (branches/release_40 296509). The release will follow soon. Please note that from 3.5.0 onwards, clang, llvm and lldb require C++11 support to build; see UPDATING for more information. Also note that as of 4.0.0, lld should be able to link the base system on amd64 and aarch64. See the WITH_LLD_IS_LLD setting in src.conf(5). Though please be aware that this is work in progress. Release notes for llvm, clang and lld will be available here: Thanks to Ed Maste, Jan Beich, Antoine Brodin and Eric Fiselier for their help. Relnotes: yes Exp-run: antoine PR: 215969, 216008 MFC r314708: For now, revert r287232 from upstream llvm trunk (by Daniil Fukalov): [SCEV] limit recursion depth of CompareSCEVComplexity Summary: CompareSCEVComplexity goes too deep (50+ on a quite a big unrolled loop) and runs almost infinite time. Added cache of "equal" SCEV pairs to earlier cutoff of further estimation. Recursion depth limit was also introduced as a parameter. Reviewers: sanjoy Subscribers: mzolotukhin, tstellarAMD, llvm-commits Differential Revision: https://reviews.llvm.org/D26389 This commit is the cause of excessive compile times on skein_block.c (and possibly other files) during kernel builds on amd64. We never saw the problematic behavior described in this upstream commit, so for now it is better to revert it. An upstream bug has been filed here: https://bugs.llvm.org/show_bug.cgi?id=32142 Reported by: mjg MFC r314795: Reapply r287232 from upstream llvm trunk (by Daniil Fukalov): [SCEV] limit recursion depth of CompareSCEVComplexity Summary: CompareSCEVComplexity goes too deep (50+ on a quite a big unrolled loop) and runs almost infinite time. Added cache of "equal" SCEV pairs to earlier cutoff of further estimation. Recursion depth limit was also introduced as a parameter. Reviewers: sanjoy Subscribers: mzolotukhin, tstellarAMD, llvm-commits Differential Revision: https://reviews.llvm.org/D26389 Pull in r296992 from upstream llvm trunk (by Sanjoy Das): [SCEV] Decrease the recursion threshold for CompareValueComplexity Fixes PR32142. r287232 accidentally increased the recursion threshold for CompareValueComplexity from 2 to 32. This change reverses that change by introducing a separate flag for CompareValueComplexity's threshold. The latter revision fixes the excessive compile times for skein_block.c. MFC r314907 | mmel | 2017-03-08 12:40:27 +0100 (Wed, 08 Mar 2017) | 7 lines Unbreak ARMv6 world. The new compiler_rt library imported with clang 4.0.0 have several fatal issues (non-functional __udivsi3 for example) with ARM specific instrict functions. As temporary workaround, until upstream solve these problems, disable all thumb[1][2] related feature. MFC r315016: Update clang, llvm, lld, lldb, compiler-rt and libc++ to 4.0.0 release. We were already very close to the last release candidate, so this is a pretty minor update. Relnotes: yes MFC r316005: Revert r314907, and pull in r298713 from upstream compiler-rt trunk (by Weiming Zhao): builtins: Select correct code fragments when compiling for Thumb1/Thum2/ARM ISA. Summary: Value of __ARM_ARCH_ISA_THUMB isn't based on the actual compilation mode (-mthumb, -marm), it reflect's capability of given CPU. Due to this: - use __tbumb__ and __thumb2__ insteand of __ARM_ARCH_ISA_THUMB - use '.thumb' directive consistently in all affected files - decorate all thumb functions using DEFINE_COMPILERRT_THUMB_FUNCTION() --------- Note: This patch doesn't fix broken Thumb1 variant of __udivsi3 ! Reviewers: weimingz, rengolin, compnerd Subscribers: aemerson, dim Differential Revision: https://reviews.llvm.org/D30938 Discussed with: mmel --- .../lldb/source/Commands/CommandObjectCommands.cpp | 3631 +++++++++----------- 1 file changed, 1646 insertions(+), 1985 deletions(-) (limited to 'contrib/llvm/tools/lldb/source/Commands/CommandObjectCommands.cpp') diff --git a/contrib/llvm/tools/lldb/source/Commands/CommandObjectCommands.cpp b/contrib/llvm/tools/lldb/source/Commands/CommandObjectCommands.cpp index dd2fd9a..aa07c10 100644 --- a/contrib/llvm/tools/lldb/source/Commands/CommandObjectCommands.cpp +++ b/contrib/llvm/tools/lldb/source/Commands/CommandObjectCommands.cpp @@ -1,4 +1,4 @@ -//===-- CommandObjectSource.cpp ---------------------------------*- C++ -*-===// +//===-- CommandObjectCommands.cpp -------------------------------*- C++ -*-===// // // The LLVM Compiler Infrastructure // @@ -36,386 +36,305 @@ using namespace lldb_private; // CommandObjectCommandsSource //------------------------------------------------------------------------- -class CommandObjectCommandsHistory : public CommandObjectParsed -{ +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", + CommandObjectCommandsHistory(CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "command history", "Dump the history of commands in this session.", nullptr), - m_options (interpreter) - { - } + m_options() {} - ~CommandObjectCommandsHistory() override = default; + ~CommandObjectCommandsHistory() override = default; - Options * - GetOptions () override - { - return &m_options; - } + Options *GetOptions() override { return &m_options; } protected: - class CommandOptions : public Options - { - public: - CommandOptions (CommandInterpreter &interpreter) : - Options (interpreter), - m_start_idx(0), - m_stop_idx(0), - m_count(0), - m_clear(false) - { - } + class CommandOptions : public Options { + public: + CommandOptions() + : Options(), m_start_idx(0), m_stop_idx(0), m_count(0), m_clear(false) { + } - ~CommandOptions() override = default; - - Error - SetOptionValue (uint32_t option_idx, const char *option_arg) override - { - Error 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 && strcmp("end", option_arg) == 0) - { - 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; - } + ~CommandOptions() override = default; + + Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, + ExecutionContext *execution_context) override { + Error 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 () override - { - m_start_idx.Clear(); - m_stop_idx.Clear(); - m_count.Clear(); - m_clear.Clear(); - } + void OptionParsingStarting(ExecutionContext *execution_context) override { + m_start_idx.Clear(); + m_stop_idx.Clear(); + m_count.Clear(); + m_clear.Clear(); + } - const OptionDefinition* - GetDefinitions () override - { - return g_option_table; - } + llvm::ArrayRef GetDefinitions() override { + return llvm::makeArrayRef(g_history_options); + } - // Options table: Required for subclasses of Options. - - static OptionDefinition g_option_table[]; - - // 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); + // 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 start_idx( + m_options.m_start_idx.OptionWasSet(), + m_options.m_start_idx.GetCurrentValue()); + std::pair stop_idx( + m_options.m_stop_idx.OptionWasSet(), + m_options.m_stop_idx.GetCurrentValue()); + std::pair 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 - { - std::pair start_idx(m_options.m_start_idx.OptionWasSet(),m_options.m_start_idx.GetCurrentValue()); - std::pair stop_idx(m_options.m_stop_idx.OptionWasSet(),m_options.m_stop_idx.GetCurrentValue()); - std::pair 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); + } 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; } - } - return result.Succeeded(); - + } 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; -}; - -OptionDefinition -CommandObjectCommandsHistory::CommandOptions::g_option_table[] = -{ -{ 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."}, -{ 0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr } + CommandOptions m_options; }; //------------------------------------------------------------------------- // CommandObjectCommandsSource //------------------------------------------------------------------------- -class CommandObjectCommandsSource : public CommandObjectParsed -{ +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 .", - nullptr), - m_options(interpreter) - { - 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 - { - std::string completion_str (input.GetArgumentAtIndex(cursor_index)); - completion_str.erase (cursor_char_position); - - CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter, - CommandCompletions::eDiskFileCompletion, - completion_str.c_str(), - match_start_point, - max_return_elements, - nullptr, - word_complete, - matches); - return matches.GetSize(); - } - - Options * - GetOptions () override - { - return &m_options; - } + CommandObjectCommandsSource(CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "command source", + "Read and execute LLDB commands from the file .", + 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 (CommandInterpreter &interpreter) : - Options (interpreter), - m_stop_on_error (true), - m_silent_run (false), - m_stop_on_continue (true) - { - } + class CommandOptions : public Options { + public: + CommandOptions() + : Options(), m_stop_on_error(true), m_silent_run(false), + m_stop_on_continue(true) {} + + ~CommandOptions() override = default; + + Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, + ExecutionContext *execution_context) override { + Error 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; + } - ~CommandOptions() override = default; - - Error - SetOptionValue (uint32_t option_idx, const char *option_arg) override - { - Error 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(); + } - void - OptionParsingStarting () override - { - m_stop_on_error.Clear(); - m_silent_run.Clear(); - m_stop_on_continue.Clear(); - } + llvm::ArrayRef GetDefinitions() override { + return llvm::makeArrayRef(g_source_options); + } - const OptionDefinition* - GetDefinitions () override - { - return g_option_table; - } + // Instance variables to hold the values for command options. - // Options table: Required for subclasses of Options. - - static OptionDefinition g_option_table[]; - - // 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 - { - const size_t argc = command.GetArgumentCount(); - if (argc == 1) - { - const char *filename = command.GetArgumentAtIndex(0); - - FileSpec cmd_file (filename, 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); - } - } - else - { - result.AppendErrorWithFormat("'%s' takes exactly one executable filename argument.\n", GetCommandName()); - result.SetStatus (eReturnStatusFailed); - } - return result.Succeeded(); + 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; } - CommandOptions m_options; -}; + 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(); + } -OptionDefinition -CommandObjectCommandsSource::CommandOptions::g_option_table[] = -{ -{ 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."}, -{ 0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr } + CommandOptions m_options; }; #pragma mark CommandObjectCommandsAlias @@ -423,102 +342,85 @@ CommandObjectCommandsSource::CommandOptions::g_option_table[] = // CommandObjectCommandsAlias //------------------------------------------------------------------------- -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"; +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 -{ +class CommandObjectCommandsAlias : public CommandObjectRaw { protected: - class CommandOptions : public OptionGroup - { - public: - CommandOptions () : - OptionGroup(), - m_help(), - m_long_help() - {} - - ~CommandOptions() override = default; - - uint32_t - GetNumDefinitions () override - { - return 3; - } - - const OptionDefinition* - GetDefinitions () override - { - return g_option_table; - } - - Error - SetOptionValue (CommandInterpreter &interpreter, - uint32_t option_idx, - const char *option_value) override - { - Error error; - - const int short_option = g_option_table[option_idx].short_option; - - switch (short_option) - { - case 'h': - m_help.SetCurrentValue(option_value); - m_help.SetOptionWasSet(); - break; - - case 'H': - m_long_help.SetCurrentValue(option_value); - m_long_help.SetOptionWasSet(); - break; - - default: - error.SetErrorStringWithFormat("invalid short option character '%c'", short_option); - break; - } - - return error; - } - - void - OptionParsingStarting (CommandInterpreter &interpreter) override - { - m_help.Clear(); - m_long_help.Clear(); - } - - // Options table: Required for subclasses of Options. - - static OptionDefinition g_option_table[]; - OptionValueString m_help; - OptionValueString m_long_help; - }; - - OptionGroupOptions m_option_group; - CommandOptions m_command_options; - + class CommandOptions : public OptionGroup { + public: + CommandOptions() : OptionGroup(), m_help(), m_long_help() {} + + ~CommandOptions() override = default; + + llvm::ArrayRef GetDefinitions() override { + return llvm::makeArrayRef(g_alias_options); + } + + Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_value, + ExecutionContext *execution_context) override { + Error 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.", - nullptr), - m_option_group(interpreter), - 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 \ + 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"( +Below are some simple examples of how one might use the 'alias' command:" + R"( (lldb) command alias sc script @@ -526,22 +428,27 @@ Below are some simple examples of how one might use the 'alias' command:" R"( (lldb) command alias bp breakpoint -)" " Creates the abbreviation 'bp' for the 'breakpoint' command. Since \ +)" + " 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"( +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 \ +)" + "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"( +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 \ +)" + " 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 \ @@ -551,18 +458,23 @@ 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"( +launch' example below)." + R"( -)" "Note: the positional arguments must substitute as whole words in the resultant \ +)" + "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"( +\".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 \ +)" + "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"( +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 @@ -576,340 +488,310 @@ Another example: 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 \ +)" + "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"( +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; + 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; - } - - m_option_group.NotifyOptionParsingStarting(); - - 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; - - Error error (m_option_group.NotifyOptionParsingFinished()); - if (error.Fail()) - { - result.AppendError (error.AsCString()); - result.SetStatus (eReturnStatusFailed); - return false; - } - } - } - if (nullptr == remainder) - remainder = raw_command_line; - - std::string raw_command_string (remainder); - Args args (raw_command_string.c_str()); - - size_t argc = args.GetArgumentCount(); - - if (argc < 2) - { - result.AppendError ("'command alias' requires at least two arguments"); - result.SetStatus (eReturnStatusFailed); - return false; - } - - // Get the alias command. - - const std::string alias_command = args.GetArgumentAtIndex (0); - if (alias_command.size() > 1 && - alias_command[0] == '-') - { - 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.c_str())) - { - result.AppendErrorWithFormat ("'%s' is a permanent debugger command and cannot be redefined.\n", - alias_command.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. - std::string 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.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 (const std::string &alias_command, std::string &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.c_str()) - || m_interpreter.UserCommandExists (alias_command.c_str())) - { - result.AppendWarningWithFormat ("Overwriting existing definition for '%s'.\n", - alias_command.c_str()); - } - if (CommandAlias *alias = m_interpreter.AddAlias (alias_command.c_str(), cmd_obj_sp, raw_command_string.c_str())) - { - 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); - } + 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; + } - } - else - { - result.AppendError ("Unable to create requested alias.\n"); - result.SetStatus (eReturnStatusFailed); - } + 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; + + Error 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; - return result.Succeeded (); + 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; } - - 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; - } + // 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; + } - const std::string alias_command = args.GetArgumentAtIndex(0); - const std::string actual_command = args.GetArgumentAtIndex(1); + // 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; + } - 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. + 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); + } - // Verify that the command is alias'able, and get the appropriate command object. + return result.Succeeded(); + } - if (m_interpreter.CommandExists (alias_command.c_str())) - { - result.AppendErrorWithFormat ("'%s' is a permanent debugger command and cannot be redefined.\n", - alias_command.c_str()); - result.SetStatus (eReturnStatusFailed); - } - else - { - CommandObjectSP command_obj_sp(m_interpreter.GetCommandSPExact (actual_command.c_str(), true)); - CommandObjectSP subcommand_obj_sp; - bool use_subcommand = false; - if (command_obj_sp) - { - 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.GetArgumentCount() > 0) - { - if (argc >= 3) - { - const std::string sub_command = args.GetArgumentAtIndex(0); - assert (sub_command.length() != 0); - subcommand_obj_sp = cmd_obj->GetSubcommandSP (sub_command.c_str()); - if (subcommand_obj_sp) - { - 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; - } - else - { - result.AppendErrorWithFormat("'%s' is not a valid sub-command of '%s'. " - "Unable to create alias.\n", - sub_command.c_str(), actual_command.c_str()); - result.SetStatus (eReturnStatusFailed); - return false; - } - } - } - - // Verify & handle any options/arguments passed to the alias command - - std::string args_string; - - if (args.GetArgumentCount () > 0) - { - 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.c_str()) - || m_interpreter.UserCommandExists (alias_command.c_str())) - { - result.AppendWarningWithFormat ("Overwriting existing definition for '%s'.\n", - alias_command.c_str()); - } - - if (CommandAlias *alias = m_interpreter.AddAlias(alias_command.c_str(), - use_subcommand ? subcommand_obj_sp : command_obj_sp, - args_string.c_str())) - { - 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; - } - } - else - { - result.AppendErrorWithFormat ("'%s' is not an existing command.\n", actual_command.c_str()); - result.SetStatus (eReturnStatusFailed); - return false; - } - } + bool HandleAliasingNormalCommand(Args &args, CommandReturnObject &result) { + size_t argc = args.GetArgumentCount(); - return result.Succeeded(); + if (argc < 2) { + result.AppendError("'command alias' requires at least two arguments"); + result.SetStatus(eReturnStatusFailed); + return false; } -}; -OptionDefinition -CommandObjectCommandsAlias::CommandOptions::g_option_table[] = -{ - { 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"}, - { 0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr } + // 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 @@ -917,87 +799,82 @@ CommandObjectCommandsAlias::CommandOptions::g_option_table[] = // CommandObjectCommandsUnalias //------------------------------------------------------------------------- -class CommandObjectCommandsUnalias : public CommandObjectParsed -{ +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; + 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.GetArgumentCount() != 0) - { - const char *command_name = args.GetArgumentAtIndex(0); - cmd_obj = m_interpreter.GetCommandObject(command_name); - if (cmd_obj) - { - 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", - command_name); - } - else - { - result.AppendErrorWithFormat ("'%s' is a permanent debugger command and cannot be removed.\n", - command_name); - } - result.SetStatus (eReturnStatusFailed); - } - else - { - if (!m_interpreter.RemoveAlias(command_name)) - { - if (m_interpreter.AliasExists (command_name)) - result.AppendErrorWithFormat ("Error occurred while attempting to unalias '%s'.\n", - command_name); - else - result.AppendErrorWithFormat ("'%s' is not an existing alias.\n", command_name); - result.SetStatus (eReturnStatusFailed); - } - else - result.SetStatus (eReturnStatusSuccessFinishNoResult); - } - } - else - { - result.AppendErrorWithFormat ("'%s' is not a known command.\nTry 'help' to see a " - "current list of commands.\n", - command_name); - result.SetStatus (eReturnStatusFailed); - } - } - else - { - result.AppendError ("must call 'unalias' with a valid alias"); - result.SetStatus (eReturnStatusFailed); - } + 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; + } - return result.Succeeded(); + 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 @@ -1005,1249 +882,1016 @@ protected: // CommandObjectCommandsDelete //------------------------------------------------------------------------- -class CommandObjectCommandsDelete : public CommandObjectParsed -{ +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; + 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; + // 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); + // 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); - } + // Push the data for the first argument into the m_arguments vector. + m_arguments.push_back(arg); + } - ~CommandObjectCommandsDelete() override = default; + ~CommandObjectCommandsDelete() override = default; protected: - bool - DoExecute (Args& args, CommandReturnObject &result) override - { - CommandObject::CommandMap::iterator pos; - - if (args.GetArgumentCount() != 0) - { - const char *command_name = args.GetArgumentAtIndex(0); - if (m_interpreter.CommandExists (command_name)) - { - if (m_interpreter.RemoveCommand (command_name)) - { - result.SetStatus (eReturnStatusSuccessFinishNoResult); - } - else - { - result.AppendErrorWithFormat ("'%s' is a permanent debugger command and cannot be removed.\n", - command_name); - result.SetStatus (eReturnStatusFailed); - } - } - else - { - StreamString error_msg_stream; - const bool generate_apropos = true; - const bool generate_type_lookup = false; - CommandObjectHelp::GenerateAdditionalHelpAvenuesMessage(&error_msg_stream, - command_name, - nullptr, - nullptr, - generate_apropos, - generate_type_lookup); - result.AppendErrorWithFormat ("%s", error_msg_stream.GetData()); - result.SetStatus (eReturnStatusFailed); - } - } - else - { - result.AppendErrorWithFormat( - "must call '%s' with one or more valid user defined regular expression command names", - GetCommandName()); - result.SetStatus (eReturnStatusFailed); - } + 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); + } - return result.Succeeded(); + 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 -{ +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 [s/// ...]"), - IOHandlerDelegateMultiline("", IOHandlerDelegate::Completion::LLDBCommand), - m_options(interpreter) - { - SetHelpLong(R"( -)" "This command allows the user to create powerful regular expression commands \ + CommandObjectCommandsAddRegex(CommandInterpreter &interpreter) + : CommandObjectParsed( + interpreter, "command regex", "Define a custom command in terms of " + "existing commands by matching " + "regular expressions.", + "command regex [s/// ...]"), + 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"( +using the regular expression substitution format of:" + R"( s/// -)" " is a regular expression that can use parenthesis to capture regular \ +)" + " 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"( +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 \ +)" + "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"( +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 \ +)" + "The following example will define a regular expression command named 'f' that \ will call 'finish' if there are no arguments, or 'frame select ' if \ -a number follows 'f':" R"( +a number follows 'f':" + R"( - (lldb) command regex f s/^$/finish/ 's/([0-9]+)/frame select %1/')" - ); - } + (lldb) command regex f s/^$/finish/ 's/([0-9]+)/frame select %1/')"); + } - ~CommandObjectCommandsAddRegex() override = default; + ~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///'.\nTerminate the substitution list with an empty line.\n"); - output_sp->Flush(); - } + 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///'.\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; iPrintf("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); + } + + 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]); + Error 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 " + "[s/// s/// ...]'\n"); + result.SetStatus(eReturnStatusFailed); + return false; } - bool - DoExecute (Args& command, CommandReturnObject &result) override - { - const size_t argc = command.GetArgumentCount(); - if (argc == 0) - { - result.AppendError ("usage: 'command regex [s/// s/// ...]'\n"); - result.SetStatus (eReturnStatusFailed); - } - else - { - Error error; - const char *name = command.GetArgumentAtIndex(0); - m_regex_cmd_ap.reset (new 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 - "> ", // Prompt - nullptr, // 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 (size_t arg_idx = 1; arg_idx < argc; ++arg_idx) - { - llvm::StringRef arg_strref (command.GetArgumentAtIndex(arg_idx)); - bool check_only = false; - error = AppendRegexSubstitution (arg_strref, check_only); - if (error.Fail()) - break; - } - - if (error.Success()) - { - AddRegexCommandToInterpreter(); - } - } - if (error.Fail()) - { - result.AppendError (error.AsCString()); - result.SetStatus (eReturnStatusFailed); - } - } + Error error; + auto name = command[0].ref; + m_regex_cmd_ap = llvm::make_unique( + 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(); - } - - Error - AppendRegexSubstitution (const llvm::StringRef ®ex_sed, bool check_only) - { - Error 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; - } + return result.Succeeded(); + } - 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///" or "s|||" - 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; - } + Error AppendRegexSubstitution(const llvm::StringRef ®ex_sed, + bool check_only) { + Error 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 (!m_regex_cmd_ap) { + error.SetErrorStringWithFormat( + "invalid regular expression command object for: '%.*s'", + (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(" can't be empty in 's%c%c%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(" can't be empty in 's%c%c%c' string: '%.*s'", - separator_char, - separator_char, - separator_char, - (int)regex_sed.size(), - regex_sed.data()); - return error; - } + size_t regex_sed_size = regex_sed.size(); - 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; + if (regex_sed_size <= 1) { + error.SetErrorStringWithFormat( + "regular expression substitution string is too short: '%.*s'", + (int)regex_sed.size(), regex_sed.data()); + 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); - } - } + + 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///" or "s|||" + 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; } -private: - std::unique_ptr m_regex_cmd_ap; - - class CommandOptions : public Options - { - public: - CommandOptions (CommandInterpreter &interpreter) : - Options (interpreter) - { - } - - ~CommandOptions() override = default; - - Error - SetOptionValue (uint32_t option_idx, const char *option_arg) override - { - Error 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 () override - { - m_help.clear(); - m_syntax.clear(); - } - - const OptionDefinition* - GetDefinitions () override - { - return g_option_table; - } - - // Options table: Required for subclasses of Options. - - static OptionDefinition g_option_table[]; - - 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; -}; + 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; + } -OptionDefinition -CommandObjectCommandsAddRegex::CommandOptions::g_option_table[] = -{ -{ 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."}, -{ 0 , false, nullptr , 0 , 0 , nullptr, nullptr, 0, eArgTypeNone, nullptr } -}; + 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( + " can't be empty in 's%c%c%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( + " can't be empty in 's%c%c%c' string: '%.*s'", + separator_char, separator_char, separator_char, (int)regex_sed.size(), + regex_sed.data()); + return error; + } -class CommandObjectPythonFunction : public CommandObjectRaw -{ -public: - CommandObjectPythonFunction (CommandInterpreter &interpreter, - std::string name, - std::string funct, - std::string help, - ScriptedCommandSynchronicity synch) : - CommandObjectRaw(interpreter, - name.c_str(), - nullptr, - nullptr), - m_function_name(funct), - m_synchro(synch), - m_fetched_help_long(false) - { - if (!help.empty()) - SetHelp(help.c_str()); - else - { - StreamString stream; - stream.Printf("For more information run 'help %s'",name.c_str()); - SetHelp(stream.GetData()); - } + 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); + } } + } - ~CommandObjectPythonFunction() override = default; +private: + std::unique_ptr m_regex_cmd_ap; + + class CommandOptions : public Options { + public: + CommandOptions() : Options() {} + + ~CommandOptions() override = default; + + Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, + ExecutionContext *execution_context) override { + Error 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; + } - bool - IsRemovable () const override - { - return true; + void OptionParsingStarting(ExecutionContext *execution_context) override { + m_help.clear(); + m_syntax.clear(); } - const std::string& - GetFunctionName () - { - return m_function_name; + llvm::ArrayRef GetDefinitions() override { + return llvm::makeArrayRef(g_regex_options); } - ScriptedCommandSynchronicity - GetSynchronicity () - { - return m_synchro; + // TODO: Convert these functions to return StringRefs. + const char *GetHelp() { + return (m_help.empty() ? nullptr : m_help.c_str()); } - - const char * - GetHelpLong () override - { - if (!m_fetched_help_long) - { - ScriptInterpreter* scripter = m_interpreter.GetScriptInterpreter(); - if (scripter) - { - std::string docstring; - m_fetched_help_long = scripter->GetDocumentationForItem(m_function_name.c_str(),docstring); - if (!docstring.empty()) - SetHelpLong(docstring.c_str()); - } - } - return CommandObjectRaw::GetHelpLong(); + + 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(); - - Error 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); - } + bool DoExecute(const char *raw_command_line, + CommandReturnObject &result) override { + ScriptInterpreter *scripter = m_interpreter.GetScriptInterpreter(); + + Error 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 - { - // Don't change the status if the command already set it... - if (result.GetStatus() == eReturnStatusInvalid) - { - if (result.GetOutputData() == nullptr || result.GetOutputData()[0] == '\0') - result.SetStatus(eReturnStatusSuccessFinishNoResult); - else - result.SetStatus(eReturnStatusSuccessFinishResult); - } - } - - return result.Succeeded(); + result.SetStatus(eReturnStatusSuccessFinishResult); + } } + return result.Succeeded(); + } + private: - std::string m_function_name; - ScriptedCommandSynchronicity m_synchro; - bool m_fetched_help_long; + std::string m_function_name; + ScriptedCommandSynchronicity m_synchro; + bool m_fetched_help_long; }; -class CommandObjectScriptingObject : public CommandObjectRaw -{ +class CommandObjectScriptingObject : public CommandObjectRaw { public: - CommandObjectScriptingObject (CommandInterpreter &interpreter, - std::string name, - StructuredData::GenericSP cmd_obj_sp, - ScriptedCommandSynchronicity synch) : - CommandObjectRaw(interpreter, - name.c_str(), - nullptr, - nullptr), - 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.GetData()); - 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; - } - - const char * - GetHelp () override - { - if (!m_fetched_help_short) - { - ScriptInterpreter* scripter = m_interpreter.GetScriptInterpreter(); - if (scripter) - { - std::string docstring; - m_fetched_help_short = scripter->GetShortHelpForCommandObject(m_cmd_obj_sp,docstring); - if (!docstring.empty()) - SetHelp(docstring.c_str()); - } - } - return CommandObjectRaw::GetHelp(); - } - - const char * - GetHelpLong () override - { - if (!m_fetched_help_long) - { - ScriptInterpreter* scripter = m_interpreter.GetScriptInterpreter(); - if (scripter) - { - std::string docstring; - m_fetched_help_long = scripter->GetLongHelpForCommandObject(m_cmd_obj_sp,docstring); - if (!docstring.empty()) - SetHelpLong(docstring.c_str()); - } - } - return CommandObjectRaw::GetHelpLong(); - } - + 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(); - - Error 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); - } + bool DoExecute(const char *raw_command_line, + CommandReturnObject &result) override { + ScriptInterpreter *scripter = m_interpreter.GetScriptInterpreter(); + + Error 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 - { - // Don't change the status if the command already set it... - if (result.GetStatus() == eReturnStatusInvalid) - { - if (result.GetOutputData() == nullptr || result.GetOutputData()[0] == '\0') - result.SetStatus(eReturnStatusSuccessFinishNoResult); - else - result.SetStatus(eReturnStatusSuccessFinishResult); - } - } - - return result.Succeeded(); + 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; + StructuredData::GenericSP m_cmd_obj_sp; + ScriptedCommandSynchronicity m_synchro; + bool m_fetched_help_short : 1; + bool m_fetched_help_long : 1; }; //------------------------------------------------------------------------- // CommandObjectCommandsScriptImport //------------------------------------------------------------------------- -class CommandObjectCommandsScriptImport : public CommandObjectParsed -{ +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(interpreter) - { - 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 - { - std::string completion_str (input.GetArgumentAtIndex(cursor_index)); - completion_str.erase (cursor_char_position); - - CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter, - CommandCompletions::eDiskFileCompletion, - completion_str.c_str(), - match_start_point, - max_return_elements, - nullptr, - word_complete, - matches); - return matches.GetSize(); - } - - Options * - GetOptions () override - { - return &m_options; - } + 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 (CommandInterpreter &interpreter) : - Options (interpreter) - { - } + class CommandOptions : public Options { + public: + CommandOptions() : Options() {} + + ~CommandOptions() override = default; + + Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, + ExecutionContext *execution_context) override { + Error 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; + } - ~CommandOptions() override = default; - - Error - SetOptionValue (uint32_t option_idx, const char *option_arg) override - { - Error 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 () override - { - m_allow_reload = true; - } - - const OptionDefinition* - GetDefinitions () override - { - return g_option_table; - } - - // Options table: Required for subclasses of Options. - - static OptionDefinition g_option_table[]; - - // 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; - } - - size_t argc = command.GetArgumentCount(); - if (0 == argc) - { - result.AppendError("command script import needs one or more arguments"); - result.SetStatus (eReturnStatusFailed); - return false; - } - - for (size_t i = 0; - i < argc; - i++) - { - std::string path = command.GetArgumentAtIndex(i); - Error 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(path.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(); + void OptionParsingStarting(ExecutionContext *execution_context) override { + m_allow_reload = true; } - - CommandOptions m_options; -}; -OptionDefinition -CommandObjectCommandsScriptImport::CommandOptions::g_option_table[] = -{ - { 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."}, - { 0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr } + llvm::ArrayRef 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()) { + Error 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 //------------------------------------------------------------------------- -class CommandObjectCommandsScriptAdd : - public CommandObjectParsed, - public IOHandlerDelegateMultiline -{ +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", + CommandObjectCommandsScriptAdd(CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "command script add", "Add a scripted function as an LLDB command.", nullptr), - IOHandlerDelegateMultiline ("DONE"), - m_options (interpreter) - { - 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; - } - + 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 (CommandInterpreter &interpreter) : - Options (interpreter), - m_class_name(), - m_funct_name(), - m_short_help(), - m_synchronicity(eScriptedCommandSynchronicitySynchronous) - { - } + class CommandOptions : public Options { + public: + CommandOptions() + : Options(), m_class_name(), m_funct_name(), m_short_help(), + m_synchronicity(eScriptedCommandSynchronicitySynchronous) {} + + ~CommandOptions() override = default; + + Error SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, + ExecutionContext *execution_context) override { + Error 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; + } - ~CommandOptions() override = default; - - Error - SetOptionValue (uint32_t option_idx, const char *option_arg) override - { - Error error; - const int short_option = m_getopt_table[option_idx].val; - - switch (short_option) - { - case 'f': - if (option_arg) - m_funct_name.assign(option_arg); - break; - case 'c': - if (option_arg) - m_class_name.assign(option_arg); - break; - case 'h': - if (option_arg) - m_short_help.assign(option_arg); - break; - case 's': - m_synchronicity = (ScriptedCommandSynchronicity) Args::StringToOptionEnum(option_arg, g_option_table[option_idx].enum_values, 0, error); - if (!error.Success()) - error.SetErrorStringWithFormat ("unrecognized value for synchronicity '%s'", option_arg); - break; - default: - error.SetErrorStringWithFormat ("unrecognized option '%c'", short_option); - break; - } - - return error; - } - - void - OptionParsingStarting () override - { - m_class_name.clear(); - m_funct_name.clear(); - m_short_help.clear(); - m_synchronicity = eScriptedCommandSynchronicitySynchronous; - } - - const OptionDefinition* - GetDefinitions () override - { - return g_option_table; - } - - // Options table: Required for subclasses of Options. - - static OptionDefinition g_option_table[]; - - // 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 OptionParsingStarting(ExecutionContext *execution_context) override { + m_class_name.clear(); + m_funct_name.clear(); + m_short_help.clear(); + m_synchronicity = eScriptedCommandSynchronicitySynchronous; } - - - 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.c_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); + llvm::ArrayRef GetDefinitions() override { + return llvm::makeArrayRef(g_script_add_options); } -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; - } - - size_t argc = command.GetArgumentCount(); - - if (argc != 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.GetArgumentAtIndex(0); - 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); - } - } + // Instance variables to hold the values for command options. - return result.Succeeded(); - } - - CommandOptions m_options; - std::string m_cmd_name; + std::string m_class_name; + std::string m_funct_name; std::string m_short_help; ScriptedCommandSynchronicity m_synchronicity; -}; + }; -static OptionEnumValueElement g_script_synchro_type[] = -{ - { eScriptedCommandSynchronicitySynchronous, "synchronous", "Run synchronous"}, - { eScriptedCommandSynchronicityAsynchronous, "asynchronous", "Run asynchronous"}, - { eScriptedCommandSynchronicityCurrentValue, "current", "Do not alter current setting"}, - { 0, nullptr, nullptr } -}; + 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(); + } -OptionDefinition -CommandObjectCommandsScriptAdd::CommandOptions::g_option_table[] = -{ - { 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."}, - { 0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr } + CommandOptions m_options; + std::string m_cmd_name; + std::string m_short_help; + ScriptedCommandSynchronicity m_synchronicity; }; //------------------------------------------------------------------------- // CommandObjectCommandsScriptList //------------------------------------------------------------------------- -class CommandObjectCommandsScriptList : public CommandObjectParsed -{ +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; - } + 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 -{ +class CommandObjectCommandsScriptClear : public CommandObjectParsed { public: - CommandObjectCommandsScriptClear(CommandInterpreter &interpreter) : - CommandObjectParsed(interpreter, - "command script clear", - "Delete all scripted commands.", - nullptr) - { - } + CommandObjectCommandsScriptClear(CommandInterpreter &interpreter) + : CommandObjectParsed(interpreter, "command script clear", + "Delete all scripted commands.", nullptr) {} - ~CommandObjectCommandsScriptClear() override = default; + ~CommandObjectCommandsScriptClear() override = default; protected: - bool - DoExecute (Args& command, CommandReturnObject &result) override - { - m_interpreter.RemoveAllUser(); - - result.SetStatus (eReturnStatusSuccessFinishResult); - - return true; - } + bool DoExecute(Args &command, CommandReturnObject &result) override { + m_interpreter.RemoveAllUser(); + + result.SetStatus(eReturnStatusSuccessFinishResult); + + return true; + } }; //------------------------------------------------------------------------- // CommandObjectCommandsScriptDelete //------------------------------------------------------------------------- -class CommandObjectCommandsScriptDelete : public CommandObjectParsed -{ +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; + 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 - { - - size_t argc = command.GetArgumentCount(); - - if (argc != 1) - { - result.AppendError ("'command script delete' requires one argument"); - result.SetStatus (eReturnStatusFailed); - return false; - } - - const char* cmd_name = command.GetArgumentAtIndex(0); - - if (cmd_name && *cmd_name && m_interpreter.HasUserCommands() && m_interpreter.UserCommandExists(cmd_name)) - { - m_interpreter.RemoveUser(cmd_name); - result.SetStatus (eReturnStatusSuccessFinishResult); - } - else - { - result.AppendErrorWithFormat ("command %s not found", cmd_name); - result.SetStatus (eReturnStatusFailed); - } - - return result.Succeeded(); + 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 @@ -2256,22 +1900,30 @@ protected: // CommandObjectMultiwordCommandsScript //------------------------------------------------------------------------- -class CommandObjectMultiwordCommandsScript : public CommandObjectMultiword -{ +class CommandObjectMultiwordCommandsScript : public CommandObjectMultiword { public: - CommandObjectMultiwordCommandsScript(CommandInterpreter &interpreter) - : CommandObjectMultiword(interpreter, "command script", - "Commands for managing custom commands implemented by interpreter scripts.", - "command script []") - { - 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; + CommandObjectMultiwordCommandsScript(CommandInterpreter &interpreter) + : CommandObjectMultiword( + interpreter, "command script", "Commands for managing custom " + "commands implemented by " + "interpreter scripts.", + "command script []") { + 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 @@ -2280,17 +1932,26 @@ public: // CommandObjectMultiwordCommands //------------------------------------------------------------------------- -CommandObjectMultiwordCommands::CommandObjectMultiwordCommands(CommandInterpreter &interpreter) - : CommandObjectMultiword(interpreter, "command", "Commands for managing custom LLDB commands.", - "command []") -{ - 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( + CommandInterpreter &interpreter) + : CommandObjectMultiword(interpreter, "command", + "Commands for managing custom LLDB commands.", + "command []") { + 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; -- cgit v1.1