//===-- 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/Interpreter/CommandInterpreter.h" #include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Interpreter/CommandCompletions.h" #include "lldb/Interpreter/OptionValueProperties.h" using namespace lldb; using namespace lldb_private; //------------------------------------------------------------------------- // CommandObjectSettingsSet //------------------------------------------------------------------------- class CommandObjectSettingsSet : public CommandObjectRaw { public: CommandObjectSettingsSet(CommandInterpreter &interpreter) : CommandObjectRaw(interpreter, "settings set", "Set the value of the specified debugger setting.", nullptr), m_options(interpreter) { 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 (CommandInterpreter &interpreter) : Options (interpreter), m_global (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 'g': m_global = true; break; default: error.SetErrorStringWithFormat ("unrecognized options '%c'", short_option); break; } return error; } void OptionParsingStarting () override { m_global = false; } 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_global; }; 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), cursor_char_position); const size_t argc = input.GetArgumentCount(); const char *arg = nullptr; int setting_var_idx; for (setting_var_idx = 1; setting_var_idx < static_cast(argc); ++setting_var_idx) { arg = input.GetArgumentAtIndex(setting_var_idx); if (arg && arg[0] != '-') break; // We found our setting variable name index } if (cursor_index == setting_var_idx) { // Attempting to complete setting variable name CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter, CommandCompletions::eSettingsNameCompletion, completion_str.c_str(), match_start_point, max_return_elements, nullptr, word_complete, matches); } else { arg = input.GetArgumentAtIndex(cursor_index); if (arg) { if (arg[0] == '-') { // Complete option name } else { // Complete setting value const char *setting_var_name = input.GetArgumentAtIndex(setting_var_idx); Error 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, completion_str.c_str(), match_start_point, max_return_elements, word_complete, matches); } } } } return matches.GetSize(); } protected: bool DoExecute (const char *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); Error 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; }; OptionDefinition CommandObjectSettingsSet::CommandOptions::g_option_table[] = { { LLDB_OPT_SET_2, false, "global", 'g', OptionParser::eNoArgument, nullptr, nullptr, 0, eArgTypeNone, "Apply the new value to the global default value." }, { 0, false, nullptr, 0, 0, nullptr, nullptr, 0, eArgTypeNone, nullptr } }; //------------------------------------------------------------------------- // 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 (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), cursor_char_position); CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter, CommandCompletions::eSettingsNameCompletion, completion_str.c_str(), match_start_point, max_return_elements, nullptr, word_complete, matches); return matches.GetSize(); } protected: bool DoExecute (Args& args, CommandReturnObject &result) override { result.SetStatus (eReturnStatusSuccessFinishResult); const size_t argc = args.GetArgumentCount (); if (argc > 0) { for (size_t i = 0; i < argc; ++i) { const char *property_path = args.GetArgumentAtIndex (i); Error error(m_interpreter.GetDebugger().DumpPropertyValue (&m_exe_ctx, result.GetOutputStream(), property_path, 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 (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), cursor_char_position); CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter, CommandCompletions::eSettingsNameCompletion, completion_str.c_str(), match_start_point, max_return_elements, nullptr, word_complete, matches); return matches.GetSize(); } 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; 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.", nullptr) { 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 (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), cursor_char_position); // Attempting to complete variable name if (cursor_index < 2) CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter, CommandCompletions::eSettingsNameCompletion, completion_str.c_str(), match_start_point, max_return_elements, nullptr, word_complete, matches); return matches.GetSize(); } protected: bool DoExecute (const char *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); Error 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.", nullptr) { 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 (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), cursor_char_position); // Attempting to complete variable name if (cursor_index < 2) CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter, CommandCompletions::eSettingsNameCompletion, completion_str.c_str(), match_start_point, max_return_elements, nullptr, word_complete, matches); return matches.GetSize(); } protected: bool DoExecute (const char *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); Error 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.", nullptr) { 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 (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), cursor_char_position); // Attempting to complete variable name if (cursor_index < 2) CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter, CommandCompletions::eSettingsNameCompletion, completion_str.c_str(), match_start_point, max_return_elements, nullptr, word_complete, matches); return matches.GetSize(); } protected: bool DoExecute (const char *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); Error 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.", nullptr) { 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 (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), cursor_char_position); // Attempting to complete variable name if (cursor_index < 2) CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter, CommandCompletions::eSettingsNameCompletion, completion_str.c_str(), match_start_point, max_return_elements, nullptr, word_complete, matches); return matches.GetSize(); } protected: bool DoExecute (const char *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); Error 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.", nullptr) { 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 (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), cursor_char_position); // Attempting to complete variable name if (cursor_index < 2) CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter, CommandCompletions::eSettingsNameCompletion, completion_str.c_str(), match_start_point, max_return_elements, nullptr, word_complete, matches); return matches.GetSize(); } protected: bool DoExecute (const char *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); Error 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 (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), cursor_char_position); // Attempting to complete variable name if (cursor_index < 2) CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter, CommandCompletions::eSettingsNameCompletion, completion_str.c_str(), match_start_point, max_return_elements, nullptr, word_complete, matches); return matches.GetSize(); } 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; } Error error(m_interpreter.GetDebugger().SetPropertyValue(&m_exe_ctx, eVarSetOperationClear, var_name, nullptr)); 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 []") { 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;