| //===-- CommandObjectSettings.cpp -------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "CommandObjectSettings.h" |
| |
| // C Includes |
| // C++ Includes |
| // Other libraries and framework includes |
| #include "llvm/ADT/StringRef.h" |
| |
| // Project includes |
| #include "lldb/Host/OptionParser.h" |
| #include "lldb/Interpreter/CommandCompletions.h" |
| #include "lldb/Interpreter/CommandInterpreter.h" |
| #include "lldb/Interpreter/CommandReturnObject.h" |
| #include "lldb/Interpreter/OptionValueProperties.h" |
| |
| using namespace lldb; |
| using namespace lldb_private; |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectSettingsSet |
| //------------------------------------------------------------------------- |
| |
| static OptionDefinition g_settings_set_options[] = { |
| // clang-format off |
| { LLDB_OPT_SET_2, false, "global", 'g', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Apply the new value to the global default value." } |
| // clang-format on |
| }; |
| |
| class CommandObjectSettingsSet : public CommandObjectRaw { |
| public: |
| CommandObjectSettingsSet(CommandInterpreter &interpreter) |
| : CommandObjectRaw(interpreter, "settings set", |
| "Set the value of the specified debugger setting."), |
| m_options() { |
| CommandArgumentEntry arg1; |
| CommandArgumentEntry arg2; |
| CommandArgumentData var_name_arg; |
| CommandArgumentData value_arg; |
| |
| // Define the first (and only) variant of this arg. |
| var_name_arg.arg_type = eArgTypeSettingVariableName; |
| var_name_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg1.push_back(var_name_arg); |
| |
| // Define the first (and only) variant of this arg. |
| value_arg.arg_type = eArgTypeValue; |
| value_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg2.push_back(value_arg); |
| |
| // Push the data for the first argument into the m_arguments vector. |
| m_arguments.push_back(arg1); |
| m_arguments.push_back(arg2); |
| |
| SetHelpLong( |
| "\nWhen setting a dictionary or array variable, you can set multiple entries \ |
| at once by giving the values to the set command. For example:" |
| R"( |
| |
| (lldb) settings set target.run-args value1 value2 value3 |
| (lldb) settings set target.env-vars MYPATH=~/.:/usr/bin SOME_ENV_VAR=12345 |
| |
| (lldb) settings show target.run-args |
| [0]: 'value1' |
| [1]: 'value2' |
| [3]: 'value3' |
| (lldb) settings show target.env-vars |
| 'MYPATH=~/.:/usr/bin' |
| 'SOME_ENV_VAR=12345' |
| |
| )" |
| "Warning: The 'set' command re-sets the entire array or dictionary. If you \ |
| just want to add, remove or update individual values (or add something to \ |
| the end), use one of the other settings sub-commands: append, replace, \ |
| insert-before or insert-after."); |
| } |
| |
| ~CommandObjectSettingsSet() override = default; |
| |
| // Overrides base class's behavior where WantsCompletion = |
| // !WantsRawCommandString. |
| bool WantsCompletion() override { return true; } |
| |
| Options *GetOptions() override { return &m_options; } |
| |
| class CommandOptions : public Options { |
| public: |
| CommandOptions() : Options(), m_global(false) {} |
| |
| ~CommandOptions() override = default; |
| |
| Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, |
| ExecutionContext *execution_context) override { |
| Status error; |
| const int short_option = m_getopt_table[option_idx].val; |
| |
| switch (short_option) { |
| case 'g': |
| m_global = true; |
| break; |
| default: |
| error.SetErrorStringWithFormat("unrecognized options '%c'", |
| short_option); |
| break; |
| } |
| |
| return error; |
| } |
| |
| void OptionParsingStarting(ExecutionContext *execution_context) override { |
| m_global = false; |
| } |
| |
| llvm::ArrayRef<OptionDefinition> GetDefinitions() override { |
| return llvm::makeArrayRef(g_settings_set_options); |
| } |
| |
| // Instance variables to hold the values for command options. |
| |
| bool m_global; |
| }; |
| |
| int HandleArgumentCompletion( |
| CompletionRequest &request, |
| OptionElementVector &opt_element_vector) override { |
| |
| const size_t argc = request.GetParsedLine().GetArgumentCount(); |
| const char *arg = nullptr; |
| int setting_var_idx; |
| for (setting_var_idx = 0; setting_var_idx < static_cast<int>(argc); |
| ++setting_var_idx) { |
| arg = request.GetParsedLine().GetArgumentAtIndex(setting_var_idx); |
| if (arg && arg[0] != '-') |
| break; // We found our setting variable name index |
| } |
| if (request.GetCursorIndex() == setting_var_idx) { |
| // Attempting to complete setting variable name |
| CommandCompletions::InvokeCommonCompletionCallbacks( |
| GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion, |
| request, nullptr); |
| } else { |
| arg = |
| request.GetParsedLine().GetArgumentAtIndex(request.GetCursorIndex()); |
| |
| if (arg) { |
| if (arg[0] == '-') { |
| // Complete option name |
| } else { |
| // Complete setting value |
| const char *setting_var_name = |
| request.GetParsedLine().GetArgumentAtIndex(setting_var_idx); |
| Status error; |
| lldb::OptionValueSP value_sp( |
| m_interpreter.GetDebugger().GetPropertyValue( |
| &m_exe_ctx, setting_var_name, false, error)); |
| if (value_sp) { |
| value_sp->AutoComplete(m_interpreter, request); |
| } |
| } |
| } |
| } |
| return request.GetNumberOfMatches(); |
| } |
| |
| protected: |
| bool DoExecute(llvm::StringRef command, |
| CommandReturnObject &result) override { |
| Args cmd_args(command); |
| |
| // Process possible options. |
| if (!ParseOptions(cmd_args, result)) |
| return false; |
| |
| const size_t argc = cmd_args.GetArgumentCount(); |
| if ((argc < 2) && (!m_options.m_global)) { |
| result.AppendError("'settings set' takes more arguments"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| const char *var_name = cmd_args.GetArgumentAtIndex(0); |
| if ((var_name == nullptr) || (var_name[0] == '\0')) { |
| result.AppendError( |
| "'settings set' command requires a valid variable name"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| // Split the raw command into var_name and value pair. |
| llvm::StringRef raw_str(command); |
| std::string var_value_string = raw_str.split(var_name).second.str(); |
| const char *var_value_cstr = |
| Args::StripSpaces(var_value_string, true, false, false); |
| |
| Status error; |
| if (m_options.m_global) { |
| error = m_interpreter.GetDebugger().SetPropertyValue( |
| nullptr, eVarSetOperationAssign, var_name, var_value_cstr); |
| } |
| |
| if (error.Success()) { |
| // FIXME this is the same issue as the one in commands script import |
| // we could be setting target.load-script-from-symbol-file which would |
| // cause Python scripts to be loaded, which could run LLDB commands (e.g. |
| // settings set target.process.python-os-plugin-path) and cause a crash |
| // if we did not clear the command's exe_ctx first |
| ExecutionContext exe_ctx(m_exe_ctx); |
| m_exe_ctx.Clear(); |
| error = m_interpreter.GetDebugger().SetPropertyValue( |
| &exe_ctx, eVarSetOperationAssign, var_name, var_value_cstr); |
| } |
| |
| if (error.Fail()) { |
| result.AppendError(error.AsCString()); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } else { |
| result.SetStatus(eReturnStatusSuccessFinishResult); |
| } |
| |
| return result.Succeeded(); |
| } |
| |
| private: |
| CommandOptions m_options; |
| }; |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectSettingsShow -- Show current values |
| //------------------------------------------------------------------------- |
| |
| class CommandObjectSettingsShow : public CommandObjectParsed { |
| public: |
| CommandObjectSettingsShow(CommandInterpreter &interpreter) |
| : CommandObjectParsed(interpreter, "settings show", |
| "Show matching debugger settings and their current " |
| "values. Defaults to showing all settings.", |
| nullptr) { |
| CommandArgumentEntry arg1; |
| CommandArgumentData var_name_arg; |
| |
| // Define the first (and only) variant of this arg. |
| var_name_arg.arg_type = eArgTypeSettingVariableName; |
| var_name_arg.arg_repetition = eArgRepeatOptional; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg1.push_back(var_name_arg); |
| |
| // Push the data for the first argument into the m_arguments vector. |
| m_arguments.push_back(arg1); |
| } |
| |
| ~CommandObjectSettingsShow() override = default; |
| |
| int HandleArgumentCompletion( |
| CompletionRequest &request, |
| OptionElementVector &opt_element_vector) override { |
| CommandCompletions::InvokeCommonCompletionCallbacks( |
| GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion, |
| request, nullptr); |
| return request.GetNumberOfMatches(); |
| } |
| |
| protected: |
| bool DoExecute(Args &args, CommandReturnObject &result) override { |
| result.SetStatus(eReturnStatusSuccessFinishResult); |
| |
| if (!args.empty()) { |
| for (const auto &arg : args) { |
| Status error(m_interpreter.GetDebugger().DumpPropertyValue( |
| &m_exe_ctx, result.GetOutputStream(), arg.ref, |
| OptionValue::eDumpGroupValue)); |
| if (error.Success()) { |
| result.GetOutputStream().EOL(); |
| } else { |
| result.AppendError(error.AsCString()); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } |
| } else { |
| m_interpreter.GetDebugger().DumpAllPropertyValues( |
| &m_exe_ctx, result.GetOutputStream(), OptionValue::eDumpGroupValue); |
| } |
| |
| return result.Succeeded(); |
| } |
| }; |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectSettingsList -- List settable variables |
| //------------------------------------------------------------------------- |
| |
| class CommandObjectSettingsList : public CommandObjectParsed { |
| public: |
| CommandObjectSettingsList(CommandInterpreter &interpreter) |
| : CommandObjectParsed(interpreter, "settings list", |
| "List and describe matching debugger settings. " |
| "Defaults to all listing all settings.", |
| nullptr) { |
| CommandArgumentEntry arg; |
| CommandArgumentData var_name_arg; |
| CommandArgumentData prefix_name_arg; |
| |
| // Define the first variant of this arg. |
| var_name_arg.arg_type = eArgTypeSettingVariableName; |
| var_name_arg.arg_repetition = eArgRepeatOptional; |
| |
| // Define the second variant of this arg. |
| prefix_name_arg.arg_type = eArgTypeSettingPrefix; |
| prefix_name_arg.arg_repetition = eArgRepeatOptional; |
| |
| arg.push_back(var_name_arg); |
| arg.push_back(prefix_name_arg); |
| |
| // Push the data for the first argument into the m_arguments vector. |
| m_arguments.push_back(arg); |
| } |
| |
| ~CommandObjectSettingsList() override = default; |
| |
| int HandleArgumentCompletion( |
| CompletionRequest &request, |
| OptionElementVector &opt_element_vector) override { |
| CommandCompletions::InvokeCommonCompletionCallbacks( |
| GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion, |
| request, nullptr); |
| return request.GetNumberOfMatches(); |
| } |
| |
| protected: |
| bool DoExecute(Args &args, CommandReturnObject &result) override { |
| result.SetStatus(eReturnStatusSuccessFinishResult); |
| |
| const bool will_modify = false; |
| const size_t argc = args.GetArgumentCount(); |
| if (argc > 0) { |
| const bool dump_qualified_name = true; |
| |
| // TODO: Convert to StringRef based enumeration. Requires converting |
| // GetPropertyAtPath first. |
| for (size_t i = 0; i < argc; ++i) { |
| const char *property_path = args.GetArgumentAtIndex(i); |
| |
| const Property *property = |
| m_interpreter.GetDebugger().GetValueProperties()->GetPropertyAtPath( |
| &m_exe_ctx, will_modify, property_path); |
| |
| if (property) { |
| property->DumpDescription(m_interpreter, result.GetOutputStream(), 0, |
| dump_qualified_name); |
| } else { |
| result.AppendErrorWithFormat("invalid property path '%s'", |
| property_path); |
| result.SetStatus(eReturnStatusFailed); |
| } |
| } |
| } else { |
| m_interpreter.GetDebugger().DumpAllDescriptions(m_interpreter, |
| result.GetOutputStream()); |
| } |
| |
| return result.Succeeded(); |
| } |
| }; |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectSettingsRemove |
| //------------------------------------------------------------------------- |
| |
| class CommandObjectSettingsRemove : public CommandObjectRaw { |
| public: |
| CommandObjectSettingsRemove(CommandInterpreter &interpreter) |
| : CommandObjectRaw(interpreter, "settings remove", |
| "Remove a value from a setting, specified by array " |
| "index or dictionary key.") { |
| CommandArgumentEntry arg1; |
| CommandArgumentEntry arg2; |
| CommandArgumentData var_name_arg; |
| CommandArgumentData index_arg; |
| CommandArgumentData key_arg; |
| |
| // Define the first (and only) variant of this arg. |
| var_name_arg.arg_type = eArgTypeSettingVariableName; |
| var_name_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg1.push_back(var_name_arg); |
| |
| // Define the first variant of this arg. |
| index_arg.arg_type = eArgTypeSettingIndex; |
| index_arg.arg_repetition = eArgRepeatPlain; |
| |
| // Define the second variant of this arg. |
| key_arg.arg_type = eArgTypeSettingKey; |
| key_arg.arg_repetition = eArgRepeatPlain; |
| |
| // Push both variants into this arg |
| arg2.push_back(index_arg); |
| arg2.push_back(key_arg); |
| |
| // Push the data for the first argument into the m_arguments vector. |
| m_arguments.push_back(arg1); |
| m_arguments.push_back(arg2); |
| } |
| |
| ~CommandObjectSettingsRemove() override = default; |
| |
| int HandleArgumentCompletion( |
| CompletionRequest &request, |
| OptionElementVector &opt_element_vector) override { |
| if (request.GetCursorIndex() < 2) |
| CommandCompletions::InvokeCommonCompletionCallbacks( |
| GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion, |
| request, nullptr); |
| return request.GetNumberOfMatches(); |
| } |
| |
| protected: |
| bool DoExecute(llvm::StringRef command, |
| CommandReturnObject &result) override { |
| result.SetStatus(eReturnStatusSuccessFinishNoResult); |
| |
| Args cmd_args(command); |
| |
| // Process possible options. |
| if (!ParseOptions(cmd_args, result)) |
| return false; |
| |
| const size_t argc = cmd_args.GetArgumentCount(); |
| if (argc == 0) { |
| result.AppendError("'settings set' takes an array or dictionary item, or " |
| "an array followed by one or more indexes, or a " |
| "dictionary followed by one or more key names to " |
| "remove"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| const char *var_name = cmd_args.GetArgumentAtIndex(0); |
| if ((var_name == nullptr) || (var_name[0] == '\0')) { |
| result.AppendError( |
| "'settings set' command requires a valid variable name"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| // Split the raw command into var_name and value pair. |
| llvm::StringRef raw_str(command); |
| std::string var_value_string = raw_str.split(var_name).second.str(); |
| const char *var_value_cstr = |
| Args::StripSpaces(var_value_string, true, true, false); |
| |
| Status error(m_interpreter.GetDebugger().SetPropertyValue( |
| &m_exe_ctx, eVarSetOperationRemove, var_name, var_value_cstr)); |
| if (error.Fail()) { |
| result.AppendError(error.AsCString()); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| return result.Succeeded(); |
| } |
| }; |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectSettingsReplace |
| //------------------------------------------------------------------------- |
| |
| class CommandObjectSettingsReplace : public CommandObjectRaw { |
| public: |
| CommandObjectSettingsReplace(CommandInterpreter &interpreter) |
| : CommandObjectRaw(interpreter, "settings replace", |
| "Replace the debugger setting value specified by " |
| "array index or dictionary key.") { |
| CommandArgumentEntry arg1; |
| CommandArgumentEntry arg2; |
| CommandArgumentEntry arg3; |
| CommandArgumentData var_name_arg; |
| CommandArgumentData index_arg; |
| CommandArgumentData key_arg; |
| CommandArgumentData value_arg; |
| |
| // Define the first (and only) variant of this arg. |
| var_name_arg.arg_type = eArgTypeSettingVariableName; |
| var_name_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg1.push_back(var_name_arg); |
| |
| // Define the first (variant of this arg. |
| index_arg.arg_type = eArgTypeSettingIndex; |
| index_arg.arg_repetition = eArgRepeatPlain; |
| |
| // Define the second (variant of this arg. |
| key_arg.arg_type = eArgTypeSettingKey; |
| key_arg.arg_repetition = eArgRepeatPlain; |
| |
| // Put both variants into this arg |
| arg2.push_back(index_arg); |
| arg2.push_back(key_arg); |
| |
| // Define the first (and only) variant of this arg. |
| value_arg.arg_type = eArgTypeValue; |
| value_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg3.push_back(value_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); |
| } |
| |
| ~CommandObjectSettingsReplace() override = default; |
| |
| // Overrides base class's behavior where WantsCompletion = |
| // !WantsRawCommandString. |
| bool WantsCompletion() override { return true; } |
| |
| int HandleArgumentCompletion( |
| CompletionRequest &request, |
| OptionElementVector &opt_element_vector) override { |
| // Attempting to complete variable name |
| if (request.GetCursorIndex() < 2) |
| CommandCompletions::InvokeCommonCompletionCallbacks( |
| GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion, |
| request, nullptr); |
| |
| return request.GetNumberOfMatches(); |
| } |
| |
| protected: |
| bool DoExecute(llvm::StringRef command, |
| CommandReturnObject &result) override { |
| result.SetStatus(eReturnStatusSuccessFinishNoResult); |
| |
| Args cmd_args(command); |
| const char *var_name = cmd_args.GetArgumentAtIndex(0); |
| if ((var_name == nullptr) || (var_name[0] == '\0')) { |
| result.AppendError("'settings replace' command requires a valid variable " |
| "name; No value supplied"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| // Split the raw command into var_name, index_value, and value triple. |
| llvm::StringRef raw_str(command); |
| std::string var_value_string = raw_str.split(var_name).second.str(); |
| const char *var_value_cstr = |
| Args::StripSpaces(var_value_string, true, true, false); |
| |
| Status error(m_interpreter.GetDebugger().SetPropertyValue( |
| &m_exe_ctx, eVarSetOperationReplace, var_name, var_value_cstr)); |
| if (error.Fail()) { |
| result.AppendError(error.AsCString()); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } else { |
| result.SetStatus(eReturnStatusSuccessFinishNoResult); |
| } |
| |
| return result.Succeeded(); |
| } |
| }; |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectSettingsInsertBefore |
| //------------------------------------------------------------------------- |
| |
| class CommandObjectSettingsInsertBefore : public CommandObjectRaw { |
| public: |
| CommandObjectSettingsInsertBefore(CommandInterpreter &interpreter) |
| : CommandObjectRaw(interpreter, "settings insert-before", |
| "Insert one or more values into an debugger array " |
| "setting immediately before the specified element " |
| "index.") { |
| CommandArgumentEntry arg1; |
| CommandArgumentEntry arg2; |
| CommandArgumentEntry arg3; |
| CommandArgumentData var_name_arg; |
| CommandArgumentData index_arg; |
| CommandArgumentData value_arg; |
| |
| // Define the first (and only) variant of this arg. |
| var_name_arg.arg_type = eArgTypeSettingVariableName; |
| var_name_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg1.push_back(var_name_arg); |
| |
| // Define the first (variant of this arg. |
| index_arg.arg_type = eArgTypeSettingIndex; |
| index_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg2.push_back(index_arg); |
| |
| // Define the first (and only) variant of this arg. |
| value_arg.arg_type = eArgTypeValue; |
| value_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg3.push_back(value_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); |
| } |
| |
| ~CommandObjectSettingsInsertBefore() override = default; |
| |
| // Overrides base class's behavior where WantsCompletion = |
| // !WantsRawCommandString. |
| bool WantsCompletion() override { return true; } |
| |
| int HandleArgumentCompletion( |
| CompletionRequest &request, |
| OptionElementVector &opt_element_vector) override { |
| // Attempting to complete variable name |
| if (request.GetCursorIndex() < 2) |
| CommandCompletions::InvokeCommonCompletionCallbacks( |
| GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion, |
| request, nullptr); |
| |
| return request.GetNumberOfMatches(); |
| } |
| |
| protected: |
| bool DoExecute(llvm::StringRef command, |
| CommandReturnObject &result) override { |
| result.SetStatus(eReturnStatusSuccessFinishNoResult); |
| |
| Args cmd_args(command); |
| const size_t argc = cmd_args.GetArgumentCount(); |
| |
| if (argc < 3) { |
| result.AppendError("'settings insert-before' takes more arguments"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| const char *var_name = cmd_args.GetArgumentAtIndex(0); |
| if ((var_name == nullptr) || (var_name[0] == '\0')) { |
| result.AppendError("'settings insert-before' command requires a valid " |
| "variable name; No value supplied"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| // Split the raw command into var_name, index_value, and value triple. |
| llvm::StringRef raw_str(command); |
| std::string var_value_string = raw_str.split(var_name).second.str(); |
| const char *var_value_cstr = |
| Args::StripSpaces(var_value_string, true, true, false); |
| |
| Status error(m_interpreter.GetDebugger().SetPropertyValue( |
| &m_exe_ctx, eVarSetOperationInsertBefore, var_name, var_value_cstr)); |
| if (error.Fail()) { |
| result.AppendError(error.AsCString()); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| return result.Succeeded(); |
| } |
| }; |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectSettingInsertAfter |
| //------------------------------------------------------------------------- |
| |
| class CommandObjectSettingsInsertAfter : public CommandObjectRaw { |
| public: |
| CommandObjectSettingsInsertAfter(CommandInterpreter &interpreter) |
| : CommandObjectRaw(interpreter, "settings insert-after", |
| "Insert one or more values into a debugger array " |
| "settings after the specified element index.") { |
| CommandArgumentEntry arg1; |
| CommandArgumentEntry arg2; |
| CommandArgumentEntry arg3; |
| CommandArgumentData var_name_arg; |
| CommandArgumentData index_arg; |
| CommandArgumentData value_arg; |
| |
| // Define the first (and only) variant of this arg. |
| var_name_arg.arg_type = eArgTypeSettingVariableName; |
| var_name_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg1.push_back(var_name_arg); |
| |
| // Define the first (variant of this arg. |
| index_arg.arg_type = eArgTypeSettingIndex; |
| index_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg2.push_back(index_arg); |
| |
| // Define the first (and only) variant of this arg. |
| value_arg.arg_type = eArgTypeValue; |
| value_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg3.push_back(value_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); |
| } |
| |
| ~CommandObjectSettingsInsertAfter() override = default; |
| |
| // Overrides base class's behavior where WantsCompletion = |
| // !WantsRawCommandString. |
| bool WantsCompletion() override { return true; } |
| |
| int HandleArgumentCompletion( |
| CompletionRequest &request, |
| OptionElementVector &opt_element_vector) override { |
| // Attempting to complete variable name |
| if (request.GetCursorIndex() < 2) |
| CommandCompletions::InvokeCommonCompletionCallbacks( |
| GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion, |
| request, nullptr); |
| |
| return request.GetNumberOfMatches(); |
| } |
| |
| protected: |
| bool DoExecute(llvm::StringRef command, |
| CommandReturnObject &result) override { |
| result.SetStatus(eReturnStatusSuccessFinishNoResult); |
| |
| Args cmd_args(command); |
| const size_t argc = cmd_args.GetArgumentCount(); |
| |
| if (argc < 3) { |
| result.AppendError("'settings insert-after' takes more arguments"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| const char *var_name = cmd_args.GetArgumentAtIndex(0); |
| if ((var_name == nullptr) || (var_name[0] == '\0')) { |
| result.AppendError("'settings insert-after' command requires a valid " |
| "variable name; No value supplied"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| // Split the raw command into var_name, index_value, and value triple. |
| llvm::StringRef raw_str(command); |
| std::string var_value_string = raw_str.split(var_name).second.str(); |
| const char *var_value_cstr = |
| Args::StripSpaces(var_value_string, true, true, false); |
| |
| Status error(m_interpreter.GetDebugger().SetPropertyValue( |
| &m_exe_ctx, eVarSetOperationInsertAfter, var_name, var_value_cstr)); |
| if (error.Fail()) { |
| result.AppendError(error.AsCString()); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| return result.Succeeded(); |
| } |
| }; |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectSettingsAppend |
| //------------------------------------------------------------------------- |
| |
| class CommandObjectSettingsAppend : public CommandObjectRaw { |
| public: |
| CommandObjectSettingsAppend(CommandInterpreter &interpreter) |
| : CommandObjectRaw(interpreter, "settings append", |
| "Append one or more values to a debugger array, " |
| "dictionary, or string setting.") { |
| CommandArgumentEntry arg1; |
| CommandArgumentEntry arg2; |
| CommandArgumentData var_name_arg; |
| CommandArgumentData value_arg; |
| |
| // Define the first (and only) variant of this arg. |
| var_name_arg.arg_type = eArgTypeSettingVariableName; |
| var_name_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg1.push_back(var_name_arg); |
| |
| // Define the first (and only) variant of this arg. |
| value_arg.arg_type = eArgTypeValue; |
| value_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg2.push_back(value_arg); |
| |
| // Push the data for the first argument into the m_arguments vector. |
| m_arguments.push_back(arg1); |
| m_arguments.push_back(arg2); |
| } |
| |
| ~CommandObjectSettingsAppend() override = default; |
| |
| // Overrides base class's behavior where WantsCompletion = |
| // !WantsRawCommandString. |
| bool WantsCompletion() override { return true; } |
| |
| int HandleArgumentCompletion( |
| CompletionRequest &request, |
| OptionElementVector &opt_element_vector) override { |
| // Attempting to complete variable name |
| if (request.GetCursorIndex() < 2) |
| CommandCompletions::InvokeCommonCompletionCallbacks( |
| GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion, |
| request, nullptr); |
| |
| return request.GetNumberOfMatches(); |
| } |
| |
| protected: |
| bool DoExecute(llvm::StringRef command, |
| CommandReturnObject &result) override { |
| result.SetStatus(eReturnStatusSuccessFinishNoResult); |
| Args cmd_args(command); |
| const size_t argc = cmd_args.GetArgumentCount(); |
| |
| if (argc < 2) { |
| result.AppendError("'settings append' takes more arguments"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| const char *var_name = cmd_args.GetArgumentAtIndex(0); |
| if ((var_name == nullptr) || (var_name[0] == '\0')) { |
| result.AppendError("'settings append' command requires a valid variable " |
| "name; No value supplied"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| // Do not perform cmd_args.Shift() since StringRef is manipulating the raw |
| // character string later on. |
| |
| // Split the raw command into var_name and value pair. |
| llvm::StringRef raw_str(command); |
| std::string var_value_string = raw_str.split(var_name).second.str(); |
| const char *var_value_cstr = |
| Args::StripSpaces(var_value_string, true, true, false); |
| |
| Status error(m_interpreter.GetDebugger().SetPropertyValue( |
| &m_exe_ctx, eVarSetOperationAppend, var_name, var_value_cstr)); |
| if (error.Fail()) { |
| result.AppendError(error.AsCString()); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| return result.Succeeded(); |
| } |
| }; |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectSettingsClear |
| //------------------------------------------------------------------------- |
| |
| class CommandObjectSettingsClear : public CommandObjectParsed { |
| public: |
| CommandObjectSettingsClear(CommandInterpreter &interpreter) |
| : CommandObjectParsed( |
| interpreter, "settings clear", |
| "Clear a debugger setting array, dictionary, or string.", nullptr) { |
| CommandArgumentEntry arg; |
| CommandArgumentData var_name_arg; |
| |
| // Define the first (and only) variant of this arg. |
| var_name_arg.arg_type = eArgTypeSettingVariableName; |
| var_name_arg.arg_repetition = eArgRepeatPlain; |
| |
| // There is only one variant this argument could be; put it into the |
| // argument entry. |
| arg.push_back(var_name_arg); |
| |
| // Push the data for the first argument into the m_arguments vector. |
| m_arguments.push_back(arg); |
| } |
| |
| ~CommandObjectSettingsClear() override = default; |
| |
| int HandleArgumentCompletion( |
| CompletionRequest &request, |
| OptionElementVector &opt_element_vector) override { |
| // Attempting to complete variable name |
| if (request.GetCursorIndex() < 2) |
| CommandCompletions::InvokeCommonCompletionCallbacks( |
| GetCommandInterpreter(), CommandCompletions::eSettingsNameCompletion, |
| request, nullptr); |
| |
| return request.GetNumberOfMatches(); |
| } |
| |
| protected: |
| bool DoExecute(Args &command, CommandReturnObject &result) override { |
| result.SetStatus(eReturnStatusSuccessFinishNoResult); |
| const size_t argc = command.GetArgumentCount(); |
| |
| if (argc != 1) { |
| result.AppendError("'settings clear' takes exactly one argument"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| const char *var_name = command.GetArgumentAtIndex(0); |
| if ((var_name == nullptr) || (var_name[0] == '\0')) { |
| result.AppendError("'settings clear' command requires a valid variable " |
| "name; No value supplied"); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| Status error(m_interpreter.GetDebugger().SetPropertyValue( |
| &m_exe_ctx, eVarSetOperationClear, var_name, llvm::StringRef())); |
| if (error.Fail()) { |
| result.AppendError(error.AsCString()); |
| result.SetStatus(eReturnStatusFailed); |
| return false; |
| } |
| |
| return result.Succeeded(); |
| } |
| }; |
| |
| //------------------------------------------------------------------------- |
| // CommandObjectMultiwordSettings |
| //------------------------------------------------------------------------- |
| |
| CommandObjectMultiwordSettings::CommandObjectMultiwordSettings( |
| CommandInterpreter &interpreter) |
| : CommandObjectMultiword(interpreter, "settings", |
| "Commands for managing LLDB settings.", |
| "settings <subcommand> [<command-options>]") { |
| LoadSubCommand("set", |
| CommandObjectSP(new CommandObjectSettingsSet(interpreter))); |
| LoadSubCommand("show", |
| CommandObjectSP(new CommandObjectSettingsShow(interpreter))); |
| LoadSubCommand("list", |
| CommandObjectSP(new CommandObjectSettingsList(interpreter))); |
| LoadSubCommand("remove", |
| CommandObjectSP(new CommandObjectSettingsRemove(interpreter))); |
| LoadSubCommand("replace", CommandObjectSP( |
| new CommandObjectSettingsReplace(interpreter))); |
| LoadSubCommand( |
| "insert-before", |
| CommandObjectSP(new CommandObjectSettingsInsertBefore(interpreter))); |
| LoadSubCommand( |
| "insert-after", |
| CommandObjectSP(new CommandObjectSettingsInsertAfter(interpreter))); |
| LoadSubCommand("append", |
| CommandObjectSP(new CommandObjectSettingsAppend(interpreter))); |
| LoadSubCommand("clear", |
| CommandObjectSP(new CommandObjectSettingsClear(interpreter))); |
| } |
| |
| CommandObjectMultiwordSettings::~CommandObjectMultiwordSettings() = default; |
