/// get processed start at the second argument. The first argument
/// is assumed to be the command and will not be touched.
///
+ /// param[in] platform_sp
+ /// The platform used for option validation. This is necessary
+ /// because an empty execution_context is not enough to get us
+ /// to a reasonable platform. If the platform isn't given,
+ /// we'll try to get it from the execution context. If we can't
+ /// get it from the execution context, we'll skip validation.
+ ///
+ /// param[in] require_validation
+ /// When true, it will fail option parsing if validation could
+ /// not occur due to not having a platform.
+ ///
/// @see class Options
//------------------------------------------------------------------
Error
- ParseOptions (Options &options);
+ ParseOptions (Options &options, ExecutionContext *execution_context,
+ lldb::PlatformSP platform_sp, bool require_validation);
size_t
FindArgumentIndexForOption (Option *long_options, int long_options_index);
GetDefinitions() override;
Error
- SetOptionValue(CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override;
+ SetOptionValue(uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting(CommandInterpreter &interpreter) override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
bool
GetArchitecture (Platform *platform, ArchSpec &arch);
}
Error
- SetOptionValue(CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override;
+ SetOptionValue(uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting(CommandInterpreter &interpreter) override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
OptionValueBoolean &
GetOptionValue ()
}
Error
- SetOptionValue(CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override;
+ SetOptionValue(uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting(CommandInterpreter &interpreter) override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
OptionValueFileSpec &
GetOptionValue ()
}
Error
- SetOptionValue(CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override;
+ SetOptionValue(uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting(CommandInterpreter &interpreter) override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
OptionValueFileSpecList &
GetOptionValue ()
GetDefinitions() override;
Error
- SetOptionValue(CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override;
+ SetOptionValue(uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting(CommandInterpreter &interpreter) override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
lldb::Format
GetFormat () const
protected:
bool
- ParserGDBFormatLetter (CommandInterpreter &interpreter,
+ ParserGDBFormatLetter (ExecutionContext *execution_context,
char format_letter,
lldb::Format &format,
uint32_t &byte_size);
GetDefinitions() override;
Error
- SetOptionValue(CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override;
+ SetOptionValue(uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting(CommandInterpreter &interpreter) override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
const OptionValueFileSpec &
GetFile ()
GetDefinitions() override;
Error
- SetOptionValue(CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override;
+ SetOptionValue(uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting(CommandInterpreter &interpreter) override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
lldb::PlatformSP
CreatePlatformWithOptions (CommandInterpreter &interpreter,
}
Error
- SetOptionValue(CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override;
+ SetOptionValue(uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting(CommandInterpreter &interpreter) override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
OptionValueString &
GetOptionValue ()
}
Error
- SetOptionValue(CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override;
+ SetOptionValue(uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting(CommandInterpreter &interpreter) override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
OptionValueUInt64 &
GetOptionValue ()
GetDefinitions() override;
Error
- SetOptionValue(CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override;
+ SetOptionValue(uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting(CommandInterpreter &interpreter) override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
const OptionValueUUID &
GetOptionValue () const
GetDefinitions() override;
Error
- SetOptionValue(CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override;
+ SetOptionValue(uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting(CommandInterpreter &interpreter) override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
bool
AnyOptionWasSet () const
GetDefinitions() override;
Error
- SetOptionValue(CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg) override;
+ SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting(CommandInterpreter &interpreter) override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
bool include_frame_options:1,
show_args:1, // Frame option only (include_frame_options == true)
GetDefinitions() override;
Error
- SetOptionValue(CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg) override;
+ SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting(CommandInterpreter &interpreter) override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
// Note:
// eWatchRead == LLDB_WATCH_TYPE_READ; and
class Options
{
public:
- Options (CommandInterpreter &interpreter);
+ Options ();
virtual
~Options ();
void
GenerateOptionUsage (Stream &strm,
- CommandObject *cmd);
+ CommandObject *cmd,
+ uint32_t screen_width);
bool
SupportsLongOption (const char *long_option);
// Option::OptionParsingStarting() like they did before. This was error
// prone and subclasses shouldn't have to do it.
void
- NotifyOptionParsingStarting ();
+ NotifyOptionParsingStarting (ExecutionContext *execution_context);
Error
- NotifyOptionParsingFinished ();
+ NotifyOptionParsingFinished (ExecutionContext *execution_context);
//------------------------------------------------------------------
/// Set the value of an option.
/// The argument value for the option that the user entered, or
/// nullptr if there is no argument for the current option.
///
+ /// @param[in] execution_context
+ /// The execution context to use for evaluating the option.
+ /// May be nullptr if the option is to be evaluated outside any
+ /// particular context.
///
/// @see Args::ParseOptions (Options&)
/// @see man getopt_long_only
//------------------------------------------------------------------
virtual Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) = 0;
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) = 0;
//------------------------------------------------------------------
/// Handles the generic bits of figuring out whether we are in an
int char_pos,
int match_start_point,
int max_return_elements,
+ CommandInterpreter &interpreter,
bool &word_complete,
lldb_private::StringList &matches);
/// See CommandObject::HandleCompletions for a description of
/// how these work.
///
+ /// @param[in] interpreter
+ /// The command interpreter in which we're doing completion.
+ ///
/// @param[out] word_complete
/// \btrue if this is a complete option value (a space will
/// be inserted after the completion.) \bfalse otherwise.
int opt_element_index,
int match_start_point,
int max_return_elements,
+ CommandInterpreter &interpreter,
bool &word_complete,
StringList &matches);
- CommandInterpreter&
- GetInterpreter()
- {
- return m_interpreter;
- }
-
protected:
// This is a set of options expressed as indexes into the options table for this Option.
typedef std::set<int> OptionSet;
typedef std::vector<OptionSet> OptionSetVector;
- CommandInterpreter &m_interpreter;
std::vector<Option> m_getopt_table;
OptionSet m_seen_options;
OptionSetVector m_required_options;
// option parse. Each subclass must override this function and revert
// all option settings to default values.
virtual void
- OptionParsingStarting () = 0;
+ OptionParsingStarting (ExecutionContext *execution_context) = 0;
virtual Error
- OptionParsingFinished ()
+ OptionParsingFinished (ExecutionContext *execution_context)
{
// If subclasses need to know when the options are done being parsed
// they can implement this function to do extra checking
GetDefinitions () = 0;
virtual Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) = 0;
+ SetOptionValue (uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) = 0;
virtual void
- OptionParsingStarting (CommandInterpreter &interpreter) = 0;
+ OptionParsingStarting(ExecutionContext *execution_context) = 0;
virtual Error
- OptionParsingFinished (CommandInterpreter &interpreter)
+ OptionParsingFinished(ExecutionContext *execution_context)
{
// If subclasses need to know when the options are done being parsed
// they can implement this function to do extra checking
class OptionGroupOptions : public Options
{
public:
- OptionGroupOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
+ OptionGroupOptions () :
+ Options (),
m_option_defs (),
m_option_infos (),
m_did_finalize (false)
Error
SetOptionValue(uint32_t option_idx,
- const char *option_arg) override;
+ const char *option_arg,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting() override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
Error
- OptionParsingFinished() override;
+ OptionParsingFinished(ExecutionContext *execution_context) override;
const OptionDefinition*
GetDefinitions() override
~OptionGroupPlatformRSync() override = default;
lldb_private::Error
- SetOptionValue(CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override;
+ SetOptionValue(uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting(CommandInterpreter &interpreter) override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
const lldb_private::OptionDefinition*
GetDefinitions() override;
~OptionGroupPlatformSSH() override = default;
lldb_private::Error
- SetOptionValue(CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override;
+ SetOptionValue(uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting(CommandInterpreter &interpreter) override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
uint32_t
GetNumDefinitions() override;
~OptionGroupPlatformCaching() override = default;
lldb_private::Error
- SetOptionValue(CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override;
+ SetOptionValue(uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting(CommandInterpreter &interpreter) override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
uint32_t
GetNumDefinitions() override;
class ProcessLaunchCommandOptions : public Options
{
public:
- ProcessLaunchCommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter)
+ ProcessLaunchCommandOptions () :
+ Options()
{
// Keep default values of all options in one place: OptionParsingStarting ()
- OptionParsingStarting ();
+ OptionParsingStarting (nullptr);
}
~ProcessLaunchCommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override;
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting() override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
launch_info.Clear();
disable_aslr = eLazyBoolCalculate;
//
CommandObjectArgs::CommandOptions::CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter)
+ Options()
{
// Keep only one place to reset the values to their defaults
- OptionParsingStarting();
+ OptionParsingStarting(nullptr);
}
CommandObjectArgs::CommandOptions::~CommandOptions() = default;
Error
-CommandObjectArgs::CommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
+CommandObjectArgs::CommandOptions::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error;
}
void
-CommandObjectArgs::CommandOptions::OptionParsingStarting ()
+CommandObjectArgs::CommandOptions::OptionParsingStarting(
+ ExecutionContext *execution_context)
{
}
~CommandOptions() override;
Error
- SetOptionValue(uint32_t option_idx, const char *option_arg) override;
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting() override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
const OptionDefinition*
GetDefinitions() override;
"breakpoint set",
"Sets a breakpoint or set of breakpoints in the executable.",
"breakpoint set <cmd-options>"),
- m_options (interpreter)
+ m_options ()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
+ CommandOptions () :
+ Options (),
m_condition (),
m_filenames (),
m_line_num (0),
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
{
case 'a':
{
- ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
- m_load_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+ m_load_addr =
+ Args::StringToAddress(execution_context, option_arg,
+ LLDB_INVALID_ADDRESS, &error);
}
break;
case 'R':
{
- ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
lldb::addr_t tmp_offset_addr;
- tmp_offset_addr = Args::StringToAddress(&exe_ctx, option_arg, 0, &error);
+ tmp_offset_addr =
+ Args::StringToAddress(execution_context, option_arg,
+ 0, &error);
if (error.Success())
m_offset_addr = tmp_offset_addr;
}
}
void
- OptionParsingStarting () override
+ OptionParsingStarting (ExecutionContext *execution_context) override
{
m_condition.clear();
m_filenames.Clear();
"If no breakpoint is specified, acts on the last created breakpoint. "
"With the exception of -e, -d and -i, passing an empty argument clears the modification.",
nullptr),
- m_options (interpreter)
+ m_options ()
{
CommandArgumentEntry arg;
CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID, eArgTypeBreakpointIDRange);
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
+ CommandOptions () :
+ Options (),
m_ignore_count (0),
m_thread_id(LLDB_INVALID_THREAD_ID),
m_thread_id_passed(false),
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting (ExecutionContext *execution_context) override
{
m_ignore_count = 0;
m_thread_id = LLDB_INVALID_THREAD_ID;
"breakpoint list",
"List some or all breakpoints at configurable levels of detail.",
nullptr),
- m_options (interpreter)
+ m_options ()
{
CommandArgumentEntry arg;
CommandArgumentData bp_id_arg;
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
+ CommandOptions () :
+ Options (),
m_level (lldb::eDescriptionLevelBrief),
m_use_dummy(false)
{
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting (ExecutionContext *execution_context) override
{
m_level = lldb::eDescriptionLevelFull;
m_internal = false;
: CommandObjectParsed(interpreter, "breakpoint clear",
"Delete or disable breakpoints matching the specified source file and line.",
"breakpoint clear <cmd-options>"),
- m_options(interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
+ CommandOptions () :
+ Options (),
m_filename (),
m_line_num (0)
{
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting (ExecutionContext *execution_context) override
{
m_filename.clear();
m_line_num = 0;
"breakpoint delete",
"Delete the specified breakpoint(s). If no breakpoints are specified, delete them all.",
nullptr),
- m_options (interpreter)
+ m_options()
{
CommandArgumentEntry arg;
CommandObject::AddIDsArgumentData(arg, eArgTypeBreakpointID, eArgTypeBreakpointIDRange);
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
+ CommandOptions () :
+ Options (),
m_use_dummy (false),
m_force (false)
{
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting (ExecutionContext *execution_context) override
{
m_use_dummy = false;
m_force = false;
}
Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override
+ SetOptionValue (uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = g_breakpoint_name_options[option_idx].short_option;
}
void
- OptionParsingStarting (CommandInterpreter &interpreter) override
+ OptionParsingStarting (ExecutionContext *execution_context) override
{
m_name.Clear();
m_breakpoint.Clear();
"Add a name to the breakpoints provided.",
"breakpoint name add <command-options> <breakpoint-id-list>"),
m_name_options(),
- m_option_group(interpreter)
+ m_option_group()
{
// Create the first variant for the first (and only) argument for this command.
CommandArgumentEntry arg1;
"Delete a name from the breakpoints provided.",
"breakpoint name delete <command-options> <breakpoint-id-list>"),
m_name_options(),
- m_option_group(interpreter)
+ m_option_group()
{
// Create the first variant for the first (and only) argument for this command.
CommandArgumentEntry arg1;
"List either the names for a breakpoint or the breakpoints for a given name.",
"breakpoint name list <command-options>"),
m_name_options(),
- m_option_group(interpreter)
+ m_option_group()
{
m_option_group.Append (&m_name_options);
m_option_group.Finalize();
" If no breakpoint is specified, adds the commands to the last created breakpoint.",
nullptr),
IOHandlerDelegateMultiline("DONE", IOHandlerDelegate::Completion::LLDBCommand),
- m_options(interpreter)
+ m_options()
{
SetHelpLong (
R"(
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
+ CommandOptions () :
+ Options (),
m_use_commands (false),
m_use_script_language (false),
m_script_language (eScriptLanguageNone),
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting (ExecutionContext *execution_context) override
{
m_use_commands = true;
m_use_script_language = false;
"delete",
"Delete the set of commands from a breakpoint.",
nullptr),
- m_options (interpreter)
+ m_options()
{
CommandArgumentEntry arg;
CommandArgumentData bp_id_arg;
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
- m_use_dummy (false)
+ CommandOptions() :
+ Options(),
+ m_use_dummy(false)
{
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting (ExecutionContext *execution_context) override
{
m_use_dummy = false;
}
"bugreport unwind",
"Create a bugreport for a bug in the stack unwinding code.",
nullptr),
- m_option_group(interpreter),
+ m_option_group(),
m_outfile_options()
{
m_option_group.Append (&m_outfile_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1 | LLDB_OPT_SET_2 | LLDB_OPT_SET_3);
"command history",
"Dump the history of commands in this session.",
nullptr),
- m_options (interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
+ CommandOptions() :
+ Options(),
m_start_idx(0),
m_stop_idx(0),
m_count(0),
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting (ExecutionContext *execution_context) override
{
m_start_idx.Clear();
m_stop_idx.Clear();
CommandObjectCommandsSource(CommandInterpreter &interpreter)
: CommandObjectParsed(interpreter, "command source", "Read and execute LLDB commands from the file <filename>.",
nullptr),
- m_options(interpreter)
+ m_options()
{
CommandArgumentEntry arg;
CommandArgumentData file_arg;
{
std::string completion_str (input.GetArgumentAtIndex(cursor_index));
completion_str.erase (cursor_char_position);
-
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eDiskFileCompletion,
completion_str.c_str(),
match_start_point,
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
+ 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, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting (ExecutionContext *execution_context) override
{
m_stop_on_error.Clear();
m_silent_run.Clear();
}
Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override
+ SetOptionValue (uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override
{
Error error;
}
void
- OptionParsingStarting (CommandInterpreter &interpreter) override
+ OptionParsingStarting (ExecutionContext *execution_context) override
{
m_help.Clear();
m_long_help.Clear();
CommandObjectCommandsAlias(CommandInterpreter &interpreter)
: CommandObjectRaw(interpreter, "command alias", "Define a custom command in terms of an existing command.",
nullptr),
- m_option_group(interpreter),
+ m_option_group(),
m_command_options()
{
m_option_group.Append(&m_command_options);
result.AppendError ("'command alias' requires at least two arguments");
return false;
}
-
- m_option_group.NotifyOptionParsingStarting();
+
+ ExecutionContext exe_ctx = GetCommandInterpreter().GetExecutionContext();
+ m_option_group.NotifyOptionParsingStarting(&exe_ctx);
const char * remainder = nullptr;
if (!ParseOptions (args, result))
return false;
- Error error (m_option_group.NotifyOptionParsingFinished());
+ Error error (m_option_group.NotifyOptionParsingFinished(&exe_ctx));
if (error.Fail())
{
result.AppendError (error.AsCString());
"Define a custom command in terms of existing commands by matching regular expressions.",
"command regex <cmd-name> [s/<regex>/<subst>/ ...]"),
IOHandlerDelegateMultiline("", IOHandlerDelegate::Completion::LLDBCommand),
- m_options(interpreter)
+ m_options()
{
SetHelpLong(R"(
)" "This command allows the user to create powerful regular expression commands \
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter)
+ CommandOptions() :
+ Options()
{
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting (ExecutionContext *execution_context) override
{
m_help.clear();
m_syntax.clear();
"command script import",
"Import a scripting module in LLDB.",
nullptr),
- m_options(interpreter)
+ m_options()
{
CommandArgumentEntry arg1;
CommandArgumentData cmd_arg;
{
std::string completion_str (input.GetArgumentAtIndex(cursor_index));
completion_str.erase (cursor_char_position);
-
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eDiskFileCompletion,
completion_str.c_str(),
match_start_point,
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter)
+ CommandOptions() :
+ Options()
{
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_allow_reload = true;
}
"Add a scripted function as an LLDB command.",
nullptr),
IOHandlerDelegateMultiline ("DONE"),
- m_options (interpreter)
+ m_options()
{
CommandArgumentEntry arg1;
CommandArgumentData cmd_arg;
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
+ CommandOptions() :
+ Options(),
m_class_name(),
m_funct_name(),
m_short_help(),
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_class_name.clear();
m_funct_name.clear();
using namespace lldb;
using namespace lldb_private;
-CommandObjectDisassemble::CommandOptions::CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter),
+CommandObjectDisassemble::CommandOptions::CommandOptions() :
+ Options(),
num_lines_context(0),
num_instructions (0),
func_name(),
some_location_specified (false),
symbol_containing_addr ()
{
- OptionParsingStarting();
+ OptionParsingStarting(nullptr);
}
CommandObjectDisassemble::CommandOptions::~CommandOptions() = default;
Error
-CommandObjectDisassemble::CommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
+CommandObjectDisassemble::CommandOptions::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error;
case 's':
{
- ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
- start_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+ start_addr = Args::StringToAddress(execution_context, option_arg,
+ LLDB_INVALID_ADDRESS, &error);
if (start_addr != LLDB_INVALID_ADDRESS)
some_location_specified = true;
}
break;
case 'e':
{
- ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
- end_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+ end_addr = Args::StringToAddress(execution_context, option_arg,
+ LLDB_INVALID_ADDRESS, &error);
if (end_addr != LLDB_INVALID_ADDRESS)
some_location_specified = true;
}
case 'F':
{
- Target *target = m_interpreter.GetExecutionContext().GetTargetPtr();
- if (target->GetArchitecture().GetTriple().getArch() == llvm::Triple::x86
- || target->GetArchitecture().GetTriple().getArch() == llvm::Triple::x86_64)
+ TargetSP target_sp = execution_context ?
+ execution_context->GetTargetSP() : TargetSP();
+ if (target_sp &&
+ (target_sp->GetArchitecture().GetTriple().getArch() == llvm::Triple::x86
+ || target_sp->GetArchitecture().GetTriple().getArch() == llvm::Triple::x86_64))
{
flavor_string.assign (option_arg);
}
break;
case 'A':
- if (!arch.SetTriple (option_arg, m_interpreter.GetPlatform (true).get()))
- arch.SetTriple (option_arg);
+ if (execution_context)
+ {
+ auto target_sp = execution_context ?
+ execution_context->GetTargetSP() : TargetSP();
+ auto platform_sp =
+ target_sp ? target_sp->GetPlatform() : PlatformSP();
+ if (!arch.SetTriple (option_arg, platform_sp.get()))
+ arch.SetTriple (option_arg);
+ }
break;
case 'a':
{
- ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
- symbol_containing_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+ symbol_containing_addr =
+ Args::StringToAddress(execution_context,option_arg,
+ LLDB_INVALID_ADDRESS, &error);
if (symbol_containing_addr != LLDB_INVALID_ADDRESS)
{
some_location_specified = true;
}
void
-CommandObjectDisassemble::CommandOptions::OptionParsingStarting ()
+CommandObjectDisassemble::CommandOptions::OptionParsingStarting(
+ ExecutionContext *execution_context)
{
show_mixed = false;
show_bytes = false;
raw = false;
plugin_name.clear();
- Target *target = m_interpreter.GetExecutionContext().GetTargetPtr();
+ Target *target =
+ execution_context ? execution_context->GetTargetPtr() : nullptr;
// This is a hack till we get the ability to specify features based on architecture. For now GetDisassemblyFlavor
// is really only valid for x86 (and for the llvm assembler plugin, but I'm papering over that since that is the
}
Error
-CommandObjectDisassemble::CommandOptions::OptionParsingFinished ()
+CommandObjectDisassemble::CommandOptions::OptionParsingFinished(
+ ExecutionContext *execution_context)
{
if (!some_location_specified)
current_function = true;
"Defaults to the current function for the current thread and "
"stack frame.",
"disassemble [<cmd-options>]"),
- m_options(interpreter)
+ m_options()
{
}
if (command.GetArgumentCount() != 0)
{
result.AppendErrorWithFormat ("\"disassemble\" arguments are specified as options.\n");
- GetOptions()->GenerateOptionUsage (result.GetErrorStream(), this);
+ const int terminal_width =
+ GetCommandInterpreter().GetDebugger().GetTerminalWidth();
+ GetOptions()->GenerateOptionUsage(result.GetErrorStream(), this,
+ terminal_width);
result.SetStatus (eReturnStatusFailed);
return false;
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter);
+ CommandOptions();
~CommandOptions() override;
Error
- SetOptionValue(uint32_t option_idx, const char *option_arg) override;
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting() override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
const OptionDefinition*
GetDefinitions() override;
}
Error
- OptionParsingFinished() override;
+ OptionParsingFinished(ExecutionContext *execution_context) override;
bool show_mixed; // Show mixed source/assembly
bool show_bytes;
}
Error
-CommandObjectExpression::CommandOptions::SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg)
+CommandObjectExpression::CommandOptions::SetOptionValue (uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error;
}
void
-CommandObjectExpression::CommandOptions::OptionParsingStarting (CommandInterpreter &interpreter)
+CommandObjectExpression::CommandOptions::OptionParsingStarting(
+ ExecutionContext *execution_context)
{
- Process *process = interpreter.GetExecutionContext().GetProcessPtr();
- if (process != nullptr)
+ auto process_sp =
+ execution_context ? execution_context->GetProcessSP() : ProcessSP();
+ if (process_sp)
{
- ignore_breakpoints = process->GetIgnoreBreakpointsInExpressions();
- unwind_on_error = process->GetUnwindOnErrorInExpressions();
+ ignore_breakpoints = process_sp->GetIgnoreBreakpointsInExpressions();
+ unwind_on_error = process_sp->GetUnwindOnErrorInExpressions();
}
else
{
"Evaluate an expression on the current thread. Displays any returned value with LLDB's default formatting.",
nullptr, eCommandProcessMustBePaused | eCommandTryTargetAPILock),
IOHandlerDelegate(IOHandlerDelegate::Completion::Expression),
- m_option_group(interpreter),
+ m_option_group(),
m_format_options(eFormatDefault),
m_repl_option(LLDB_OPT_SET_1, false, "repl", 'r', "Drop into REPL", false, true),
m_command_options(),
CommandReturnObject &result)
{
m_fixed_expression.clear();
- m_option_group.NotifyOptionParsingStarting();
+ auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
+ m_option_group.NotifyOptionParsingStarting(&exe_ctx);
const char * expr = nullptr;
if (!ParseOptions (args, result))
return false;
- Error error (m_option_group.NotifyOptionParsingFinished());
+ Error error (m_option_group.NotifyOptionParsingFinished(&exe_ctx));
if (error.Fail())
{
result.AppendError (error.AsCString());
GetDefinitions() override;
Error
- SetOptionValue(CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override;
+ SetOptionValue(uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting(CommandInterpreter &interpreter) override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
// Options table: Required for subclasses of Options.
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter)
+ CommandOptions() :
+ Options()
{
- OptionParsingStarting ();
+ OptionParsingStarting(nullptr);
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
bool success = false;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
relative_frame_offset = INT32_MIN;
}
"Select the current stack frame by index from within the current thread (see 'thread backtrace'.)",
nullptr, eCommandRequiresThread | eCommandTryTargetAPILock | eCommandProcessMustBeLaunched |
eCommandProcessMustBePaused),
- m_options(interpreter)
+ m_options()
{
CommandArgumentEntry arg;
CommandArgumentData index_arg;
{
result.AppendErrorWithFormat ("too many arguments; expected frame-index, saw '%s'.\n",
command.GetArgumentAtIndex(0));
- m_options.GenerateOptionUsage (result.GetErrorStream(), this);
+ m_options.GenerateOptionUsage(result.GetErrorStream(), this,
+ GetCommandInterpreter()
+ .GetDebugger()
+ .GetTerminalWidth());
return false;
}
}
"'var->child.x'.",
nullptr, eCommandRequiresFrame | eCommandTryTargetAPILock | eCommandProcessMustBeLaunched |
eCommandProcessMustBePaused | eCommandRequiresProcess),
- m_option_group(interpreter),
+ m_option_group(),
m_option_variable(true), // Include the frame specific options by passing "true"
m_option_format(eFormatDefault),
m_varobj_options()
// Arguments are the standard source file completer.
std::string completion_str (input.GetArgumentAtIndex(cursor_index));
completion_str.erase (cursor_char_position);
-
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eVariablePathCompletion,
completion_str.c_str(),
match_start_point,
: CommandObjectParsed(interpreter, "help",
"Show a list of all debugger commands, or give details about a specific command.",
"help [<cmd-name>]"),
- m_options(interpreter)
+ m_options()
{
CommandArgumentEntry arg;
CommandArgumentData command_arg;
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter)
+ CommandOptions() :
+ Options()
{
}
~CommandOptions() override {}
Error
- SetOptionValue(uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting() override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_show_aliases = true;
m_show_user_defined = true;
"log enable",
"Enable logging for a single log channel.",
nullptr),
- m_options (interpreter)
+ m_options()
{
CommandArgumentEntry arg1;
CommandArgumentEntry arg2;
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
- log_file (),
- log_options (0)
+ CommandOptions() :
+ Options(),
+ log_file(),
+ log_options(0)
{
}
~CommandOptions () override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
log_file.Clear();
log_options = 0;
}
Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg) override
+ SetOptionValue (uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = g_option_table[option_idx].short_option;
}
void
- OptionParsingStarting (CommandInterpreter &interpreter) override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_num_per_line.Clear();
m_output_as_binary = false;
CommandObjectMemoryRead(CommandInterpreter &interpreter)
: CommandObjectParsed(interpreter, "memory read", "Read from the memory of the current target process.",
nullptr, eCommandRequiresTarget | eCommandProcessMustBePaused),
- m_option_group(interpreter),
+ m_option_group(),
m_format_options(eFormatBytesWithASCII, 1, 8),
m_memory_options(),
m_outfile_options(),
}
Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg) override
+ SetOptionValue (uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = g_memory_find_option_table[option_idx].short_option;
}
void
- OptionParsingStarting (CommandInterpreter &interpreter) override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_expr.Clear();
m_string.Clear();
CommandObjectMemoryFind(CommandInterpreter &interpreter)
: CommandObjectParsed(interpreter, "memory find", "Find a value in the memory of the current target process.",
nullptr, eCommandRequiresProcess | eCommandProcessMustBeLaunched),
- m_option_group(interpreter),
+ m_option_group(),
m_memory_options()
{
CommandArgumentEntry arg1;
}
Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg) override
+ SetOptionValue (uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = g_memory_write_option_table[option_idx].short_option;
}
void
- OptionParsingStarting (CommandInterpreter &interpreter) override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_infile.Clear();
m_infile_offset = 0;
CommandObjectMemoryWrite(CommandInterpreter &interpreter)
: CommandObjectParsed(interpreter, "memory write", "Write to the memory of the current target process.",
nullptr, eCommandRequiresProcess | eCommandProcessMustBeLaunched),
- m_option_group(interpreter),
+ m_option_group(),
m_format_options(eFormatBytes, 1, UINT64_MAX),
m_memory_options()
{
~OptionPermissions() override = default;
lldb_private::Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg) override
+ SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
char short_option = (char) GetDefinitions()[option_idx].short_option;
}
void
- OptionParsingStarting (CommandInterpreter &interpreter) override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_permissions = 0;
}
"Create a platform if needed and select it as the current platform.",
"platform select <platform-name>",
0),
- m_option_group (interpreter),
+ m_option_group (),
m_platform_options (false) // Don't include the "--platform" option by passing false
{
m_option_group.Append (&m_platform_options, LLDB_OPT_SET_ALL, 1);
std::string completion_str (input.GetArgumentAtIndex(cursor_index));
completion_str.erase (cursor_char_position);
- CommandCompletions::PlatformPluginNames(m_interpreter,
+ CommandCompletions::PlatformPluginNames(GetCommandInterpreter(),
completion_str.c_str(),
match_start_point,
max_return_elements,
"Set settings for the current target's platform, or for a platform by name.",
"platform settings",
0),
- m_options (interpreter),
+ m_options(),
m_option_working_dir (LLDB_OPT_SET_1, false, "working-dir", 'w', 0, eArgTypePath, "The working directory for the platform.")
{
m_options.Append (&m_option_working_dir, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
"Make a new directory on the remote end.",
nullptr,
0),
- m_options(interpreter)
+ m_options()
{
}
"Open a file on the remote end.",
nullptr,
0),
- m_options(interpreter)
+ m_options()
{
}
"Read data from a file on the remote end.",
nullptr,
0),
- m_options (interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter)
+ CommandOptions() :
+ Options()
{
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
char short_option = (char) m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_offset = 0;
m_count = 1;
"Write data to a file on the remote end.",
nullptr,
0),
- m_options (interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter)
+ CommandOptions() :
+ Options()
{
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
char short_option = (char) m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_offset = 0;
m_data.clear();
"Launch a new process on a remote platform.",
"platform process launch program",
eCommandRequiresTarget | eCommandTryTargetAPILock),
- m_options (interpreter)
+ m_options()
{
}
"List processes on a remote platform by name, pid, or many other matching attributes.",
"platform process list",
0),
- m_options (interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions(CommandInterpreter &interpreter) :
- Options(interpreter),
+ CommandOptions() :
+ Options(),
match_info(),
show_args(false),
verbose(false)
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
break;
case 'a':
- match_info.GetProcessInfo().GetArchitecture().SetTriple (option_arg, m_interpreter.GetDebugger().GetPlatformList().GetSelectedPlatform().get());
+ {
+ TargetSP target_sp = execution_context ?
+ execution_context->GetTargetSP() : TargetSP();
+ DebuggerSP debugger_sp = target_sp ?
+ target_sp->GetDebugger().shared_from_this() :
+ DebuggerSP();
+ PlatformSP platform_sp = debugger_sp ?
+ debugger_sp->GetPlatformList().GetSelectedPlatform() :
+ PlatformSP();
+ match_info.GetProcessInfo().GetArchitecture().SetTriple(
+ option_arg, platform_sp.get());
+ }
break;
case 'n':
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
match_info.Clear();
show_args = false;
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter)
+ CommandOptions() :
+ Options()
{
// Keep default values of all options in one place: OptionParsingStarting ()
- OptionParsingStarting ();
+ OptionParsingStarting(nullptr);
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
char short_option = (char) m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
attach_info.Clear();
}
int opt_element_index,
int match_start_point,
int max_return_elements,
+ CommandInterpreter &interpreter,
bool &word_complete,
StringList &matches) override
{
const char *partial_name = nullptr;
partial_name = input.GetArgumentAtIndex(opt_arg_pos);
- PlatformSP platform_sp (m_interpreter.GetPlatform (true));
+ PlatformSP platform_sp(interpreter.GetPlatform(true));
if (platform_sp)
{
ProcessInstanceInfoList process_infos;
"platform process attach",
"Attach to a process.",
"platform process attach <cmd-options>"),
- m_options (interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter),
+ CommandOptions() :
+ Options(),
timeout(10)
{
}
Error
SetOptionValue (uint32_t option_idx,
- const char *option_value) override
+ const char *option_value,
+ ExecutionContext *execution_context) override
{
Error error;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
}
CommandObjectPlatformShell(CommandInterpreter &interpreter)
: CommandObjectRaw(interpreter, "platform shell", "Run a shell command on the current platform.",
"platform shell <shell-command>", 0),
- m_options(interpreter)
+ m_options()
{
}
bool
DoExecute (const char *raw_command_line, CommandReturnObject &result) override
{
- m_options.NotifyOptionParsingStarting();
+ ExecutionContext exe_ctx =
+ GetCommandInterpreter().GetExecutionContext();
+ m_options.NotifyOptionParsingStarting(&exe_ctx);
const char* expr = nullptr;
{
std::string completion_str (input.GetArgumentAtIndex(cursor_index));
completion_str.erase (cursor_char_position);
-
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eDiskFileCompletion,
completion_str.c_str(),
match_start_point,
nullptr,
eCommandRequiresTarget,
"restart"),
- m_options (interpreter)
+ m_options()
{
CommandArgumentEntry arg;
CommandArgumentData run_args_arg;
{
std::string completion_str (input.GetArgumentAtIndex(cursor_index));
completion_str.erase (cursor_char_position);
-
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eDiskFileCompletion,
completion_str.c_str(),
match_start_point,
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter)
+ CommandOptions() :
+ Options()
{
// Keep default values of all options in one place: OptionParsingStarting ()
- OptionParsingStarting ();
+ OptionParsingStarting(nullptr);
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
attach_info.Clear();
}
int opt_element_index,
int match_start_point,
int max_return_elements,
+ CommandInterpreter &interpreter,
bool &word_complete,
StringList &matches) override
{
const char *partial_name = nullptr;
partial_name = input.GetArgumentAtIndex(opt_arg_pos);
- PlatformSP platform_sp (m_interpreter.GetPlatform (true));
+ PlatformSP platform_sp(interpreter.GetPlatform(true));
if (platform_sp)
{
ProcessInstanceInfoList process_infos;
"process attach <cmd-options>",
0,
"attach"),
- m_options (interpreter)
+ m_options()
{
}
eCommandTryTargetAPILock |
eCommandProcessMustBeLaunched |
eCommandProcessMustBePaused ),
- m_options(interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter)
+ CommandOptions() :
+ Options()
{
// Keep default values of all options in one place: OptionParsingStarting ()
- OptionParsingStarting ();
+ OptionParsingStarting(nullptr);
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_ignore = 0;
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter)
+ CommandOptions() :
+ Options()
{
- OptionParsingStarting ();
+ OptionParsingStarting(nullptr);
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_keep_stopped = eLazyBoolCalculate;
}
: CommandObjectParsed(interpreter, "process detach", "Detach from the current target process.",
"process detach",
eCommandRequiresProcess | eCommandTryTargetAPILock | eCommandProcessMustBeLaunched),
- m_options(interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter)
+ CommandOptions() :
+ Options()
{
// Keep default values of all options in one place: OptionParsingStarting ()
- OptionParsingStarting ();
+ OptionParsingStarting(nullptr);
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
plugin_name.clear();
}
"Connect to a remote debug service.",
"process connect <remote-url>",
0),
- m_options (interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter)
+ CommandOptions() :
+ Options()
{
// Keep default values of all options in one place: OptionParsingStarting ()
- OptionParsingStarting ();
+ OptionParsingStarting(nullptr);
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
do_install = false;
install_path.Clear();
eCommandTryTargetAPILock |
eCommandProcessMustBeLaunched |
eCommandProcessMustBePaused ),
- m_options (interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter)
+ CommandOptions() :
+ Options()
{
- OptionParsingStarting ();
+ OptionParsingStarting(nullptr);
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
stop.clear();
notify.clear();
interpreter, "process handle",
"Manage LLDB handling of OS signals for the current target process. Defaults to showing current policy.",
nullptr),
- m_options(interpreter)
+ m_options()
{
SetHelpLong ("\nIf no signals are specified, update them all. If no update "
"option is specified, list the current values.");
eCommandRequiresRegContext |
eCommandProcessMustBeLaunched |
eCommandProcessMustBePaused ),
- m_option_group (interpreter),
+ m_option_group(),
m_format_options (eFormatDefault),
m_command_options ()
{
}
void
- OptionParsingStarting (CommandInterpreter &interpreter) override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
set_indexes.Clear();
dump_all_sets.Clear();
}
Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override
+ SetOptionValue (uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = g_option_table[option_idx].short_option;
public:
CommandObjectSettingsSet(CommandInterpreter &interpreter)
: CommandObjectRaw(interpreter, "settings set", "Set the value of the specified debugger setting.", nullptr),
- m_options(interpreter)
+ m_options()
{
CommandArgumentEntry arg1;
CommandArgumentEntry arg2;
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
- m_global (false)
+ CommandOptions() :
+ Options(),
+ m_global(false)
{
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_global = false;
}
if (cursor_index == setting_var_idx)
{
// Attempting to complete setting variable name
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eSettingsNameCompletion,
completion_str.c_str(),
match_start_point,
{
std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eSettingsNameCompletion,
completion_str.c_str(),
match_start_point,
{
std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eSettingsNameCompletion,
completion_str.c_str(),
match_start_point,
// Attempting to complete variable name
if (cursor_index < 2)
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eSettingsNameCompletion,
completion_str.c_str(),
match_start_point,
nullptr,
word_complete,
matches);
-
return matches.GetSize();
}
// Attempting to complete variable name
if (cursor_index < 2)
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eSettingsNameCompletion,
completion_str.c_str(),
match_start_point,
// Attempting to complete variable name
if (cursor_index < 2)
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eSettingsNameCompletion,
completion_str.c_str(),
match_start_point,
// Attempting to complete variable name
if (cursor_index < 2)
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eSettingsNameCompletion,
completion_str.c_str(),
match_start_point,
// Attempting to complete variable name
if (cursor_index < 2)
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eSettingsNameCompletion,
completion_str.c_str(),
match_start_point,
// Attempting to complete variable name
if (cursor_index < 2)
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eSettingsNameCompletion,
completion_str.c_str(),
match_start_point,
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) : Options(interpreter) {}
+ CommandOptions() : Options() {}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = g_option_table[option_idx].short_option;
case 'a':
{
- ExecutionContext exe_ctx(m_interpreter.GetExecutionContext());
- address = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+ address = Args::StringToAddress(execution_context,
+ option_arg,
+ LLDB_INVALID_ADDRESS,
+ &error);
}
break;
case 's':
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
file_spec.Clear();
file_name.clear();
"process. Defaults to instruction pointer in current stack "
"frame.",
nullptr, eCommandRequiresTarget),
- m_options(interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter)
+ CommandOptions() :
+ Options()
{
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = g_option_table[option_idx].short_option;
case 'a':
{
- ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
- address = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+ address = Args::StringToAddress(execution_context,
+ option_arg,
+ LLDB_INVALID_ADDRESS,
+ &error);
}
break;
case 's':
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
file_spec.Clear();
file_name.clear();
: CommandObjectParsed(interpreter, "source list",
"Display source code for the current target process as specified by options.", nullptr,
eCommandRequiresTarget),
- m_options(interpreter)
+ m_options()
{
}
"target create",
"Create a target using the argument as the main executable.",
nullptr),
- m_option_group (interpreter),
+ m_option_group (),
m_arch_option (),
m_core_file (LLDB_OPT_SET_1, false, "core", 'c', 0, eArgTypeFilename, "Fullpath to a core file to use for this target."),
m_platform_path (LLDB_OPT_SET_1, false, "platform-path", 'P', 0, eArgTypePath, "Path to the remote file to use for this target."),
std::string completion_str (input.GetArgumentAtIndex(cursor_index));
completion_str.erase (cursor_char_position);
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eDiskFileCompletion,
completion_str.c_str(),
match_start_point,
"target delete",
"Delete one or more targets by target index.",
nullptr),
- m_option_group(interpreter),
+ m_option_group(),
m_all_option(LLDB_OPT_SET_1, false, "all", 'a', "Delete all targets.", false, true),
m_cleanup_option(
LLDB_OPT_SET_1,
: CommandObjectParsed(interpreter, "target variable",
"Read global variables for the current target, before or while running a process.",
nullptr, eCommandRequiresTarget),
- m_option_group(interpreter),
+ m_option_group(),
m_option_variable(false), // Don't include frame options
m_option_format(eFormatDefault),
m_option_compile_units(LLDB_OPT_SET_1, false, "file", SHORT_OPTION_FILE, 0, eArgTypeFilename,
std::string completion_str (input.GetArgumentAtIndex(cursor_index));
completion_str.erase (cursor_char_position);
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eModuleCompletion,
completion_str.c_str(),
match_start_point,
std::string completion_str (input.GetArgumentAtIndex(cursor_index));
completion_str.erase (cursor_char_position);
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eSourceFileCompletion,
completion_str.c_str(),
match_start_point,
"target modules dump symtab",
"Dump the symbol table from one or more target modules.",
nullptr),
- m_options(interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter),
- m_sort_order (eSortOrderNone)
+ CommandOptions() :
+ Options(),
+ m_sort_order(eSortOrderNone)
{
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_sort_order = eSortOrderNone;
}
"target modules add",
"Add a new module to the current target's modules.",
"target modules add [<module>]"),
- m_option_group (interpreter),
+ m_option_group(),
m_symbol_file (LLDB_OPT_SET_1, false, "symfile", 's', 0, eArgTypeFilename, "Fullpath to a stand alone debug symbols file for when debug symbols are not in the executable.")
{
m_option_group.Append (&m_uuid_option_group, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1);
std::string completion_str (input.GetArgumentAtIndex(cursor_index));
completion_str.erase (cursor_char_position);
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eDiskFileCompletion,
completion_str.c_str(),
match_start_point,
"target modules load",
"Set the load addresses for one or more sections in a target module.",
"target modules load [--file <module> --uuid <uuid>] <sect-name> <address> [<sect-name> <address> ....]"),
- m_option_group (interpreter),
+ m_option_group(),
m_file_option (LLDB_OPT_SET_1, false, "file", 'f', 0, eArgTypeName, "Fullpath or basename for module to load.", ""),
m_slide_option(LLDB_OPT_SET_1, false, "slide", 's', 0, eArgTypeOffset, "Set the load address for all sections to be the virtual address in the file plus the offset.", 0)
{
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter),
+ CommandOptions() :
+ Options(),
m_format_array(),
m_use_global_module_list (false),
m_module_addr (LLDB_INVALID_ADDRESS)
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
}
else if (short_option == 'a')
{
- ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
- m_module_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+ m_module_addr = Args::StringToAddress(execution_context,
+ option_arg,
+ LLDB_INVALID_ADDRESS,
+ &error);
}
else
{
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_format_array.clear();
m_use_global_module_list = false;
"target modules list",
"List current executable and dependent shared library images.",
"target modules list [<cmd-options>]"),
- m_options (interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter),
+ CommandOptions() :
+ Options(),
m_type(eLookupTypeInvalid),
m_str(),
m_addr(LLDB_INVALID_ADDRESS)
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
{
case 'a':
{
- ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
m_str = option_arg;
m_type = eLookupTypeAddress;
- m_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+ m_addr = Args::StringToAddress(execution_context,
+ option_arg,
+ LLDB_INVALID_ADDRESS,
+ &error);
if (m_addr == LLDB_INVALID_ADDRESS)
error.SetErrorStringWithFormat ("invalid address string '%s'", option_arg);
break;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_type = eLookupTypeInvalid;
m_str.clear();
eCommandRequiresProcess |
eCommandProcessMustBeLaunched |
eCommandProcessMustBePaused ),
- m_options (interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter)
+ CommandOptions() :
+ Options()
{
- OptionParsingStarting();
+ OptionParsingStarting(nullptr);
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
case 'a':
{
m_type = eLookupTypeAddress;
- ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
- m_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+ m_addr = Args::StringToAddress(execution_context,
+ option_arg,
+ LLDB_INVALID_ADDRESS,
+ &error);
}
break;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_type = eLookupTypeInvalid;
m_str.clear();
"Look up information within executable and dependent shared library images.",
nullptr,
eCommandRequiresTarget),
- m_options (interpreter)
+ m_options()
{
CommandArgumentEntry arg;
CommandArgumentData file_arg;
break;
default:
- m_options.GenerateOptionUsage (result.GetErrorStream(), this);
+ m_options.GenerateOptionUsage(result.GetErrorStream(), this,
+ GetCommandInterpreter()
+ .GetDebugger()
+ .GetTerminalWidth());
syntax_error = true;
break;
}
"target symbols add",
"Add a debug symbol file to one of the target's current modules by specifying a path to a debug symbols file, or using the options to specify a module to download symbols for.",
"target symbols add [<symfile>]", eCommandRequiresTarget),
- m_option_group (interpreter),
+ m_option_group(),
m_file_option (LLDB_OPT_SET_1, false, "shlib", 's', CommandCompletions::eModuleCompletion, eArgTypeShlibName, "Fullpath or basename for module to find debug symbols for."),
m_current_frame_option (LLDB_OPT_SET_2, false, "frame", 'F', "Locate the debug symbols the currently selected frame.", false, true)
std::string completion_str (input.GetArgumentAtIndex(cursor_index));
completion_str.erase (cursor_char_position);
- CommandCompletions::InvokeCommonCompletionCallbacks(m_interpreter,
+ CommandCompletions::InvokeCommonCompletionCallbacks(GetCommandInterpreter(),
CommandCompletions::eDiskFileCompletion,
completion_str.c_str(),
match_start_point,
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter),
+ CommandOptions() :
+ Options(),
m_line_start(0),
m_line_end (UINT_MAX),
m_func_name_type_mask (eFunctionNameTypeAuto),
}
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_class_name.clear();
m_function_name.clear();
"Add a hook to be executed when the target stops.",
"target stop-hook add"),
IOHandlerDelegateMultiline ("DONE", IOHandlerDelegate::Completion::LLDBCommand),
- m_options (interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter)
+ CommandOptions() :
+ Options()
{
// Keep default values of all options in one place: OptionParsingStarting ()
- OptionParsingStarting ();
+ OptionParsingStarting(nullptr);
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_count = UINT32_MAX;
m_start = 0;
"to see all threads.",
nullptr, eCommandRequiresProcess | eCommandRequiresThread | eCommandTryTargetAPILock |
eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
- m_options(interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter)
+ CommandOptions() :
+ Options()
{
// Keep default values of all options in one place: OptionParsingStarting ()
- OptionParsingStarting ();
+ OptionParsingStarting(nullptr);
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_step_in_avoid_no_debug = eLazyBoolCalculate;
m_step_out_avoid_no_debug = eLazyBoolCalculate;
m_run_mode = eOnlyDuringStepping;
// Check if we are in Non-Stop mode
- lldb::TargetSP target_sp = m_interpreter.GetDebugger().GetSelectedTarget();
+ TargetSP target_sp =
+ execution_context ? execution_context->GetTargetSP() :
+ TargetSP();
if (target_sp && target_sp->GetNonStopModeEnabled())
m_run_mode = eOnlyThisThread;
eCommandProcessMustBePaused ),
m_step_type (step_type),
m_step_scope (step_scope),
- m_options (interpreter)
+ m_options()
{
CommandArgumentEntry arg;
CommandArgumentData thread_id_arg;
uint32_t m_thread_idx;
uint32_t m_frame_idx;
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
+ CommandOptions() :
+ Options(),
m_thread_idx(LLDB_INVALID_THREAD_ID),
m_frame_idx(LLDB_INVALID_FRAME_ID)
{
// Keep default values of all options in one place: OptionParsingStarting ()
- OptionParsingStarting ();
+ OptionParsingStarting(nullptr);
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
{
case 'a':
{
- ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
- lldb::addr_t tmp_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
+ lldb::addr_t tmp_addr =
+ Args::StringToAddress(execution_context, option_arg,
+ LLDB_INVALID_ADDRESS, &error);
if (error.Success())
m_until_addrs.push_back(tmp_addr);
}
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_thread_idx = LLDB_INVALID_THREAD_ID;
m_frame_idx = 0;
"the current function as a safety measure.",
nullptr, eCommandRequiresThread | eCommandTryTargetAPILock |
eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
- m_options(interpreter)
+ m_options()
{
CommandArgumentEntry arg;
CommandArgumentData line_num_arg;
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter)
+ CommandOptions() :
+ Options()
{
- OptionParsingStarting ();
+ OptionParsingStarting(nullptr);
}
~CommandOptions() override = default;
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_json_thread = false;
m_json_stopinfo = false;
}
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
const int short_option = m_getopt_table[option_idx].val;
Error error;
"Show an extended summary of one or more threads. Defaults to the current thread.", "thread info",
eCommandRequiresProcess | eCommandTryTargetAPILock | eCommandProcessMustBeLaunched |
eCommandProcessMustBePaused),
- m_options(interpreter)
+ m_options()
{
m_add_return = false;
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
- m_from_expression (false)
+ CommandOptions() :
+ Options(),
+ m_from_expression(false)
{
// Keep default values of all options in one place: OptionParsingStarting ()
- OptionParsingStarting ();
+ OptionParsingStarting(nullptr);
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_from_expression = false;
}
"frame.",
"thread return", eCommandRequiresFrame | eCommandTryTargetAPILock |
eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
- m_options(interpreter)
+ m_options()
{
CommandArgumentEntry arg;
CommandArgumentData expression_arg;
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter)
+ CommandOptions() :
+ Options()
{
- OptionParsingStarting ();
+ OptionParsingStarting(nullptr);
}
~CommandOptions() override = default;
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_filenames.Clear();
m_line_num = 0;
}
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
bool success;
const int short_option = m_getopt_table[option_idx].val;
return Error("invalid line offset: '%s'.", option_arg);
break;
case 'a':
- {
- ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
- m_load_addr = Args::StringToAddress(&exe_ctx, option_arg, LLDB_INVALID_ADDRESS, &error);
- }
+ m_load_addr = Args::StringToAddress(execution_context,
+ option_arg,
+ LLDB_INVALID_ADDRESS,
+ &error);
break;
case 'r':
m_force = true;
eCommandTryTargetAPILock |
eCommandProcessMustBeLaunched |
eCommandProcessMustBePaused ),
- m_options (interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter)
+ CommandOptions() :
+ Options()
{
// Keep default values of all options in one place: OptionParsingStarting ()
- OptionParsingStarting ();
+ OptionParsingStarting(nullptr);
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_verbose = false;
m_internal = false;
"current thread. Use the thread-index \"all\" to see all threads.",
nullptr, eCommandRequiresProcess | eCommandRequiresThread | eCommandTryTargetAPILock |
eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
- m_options(interpreter)
+ m_options()
{
}
{
public:
CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter)
+ Options()
{
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override;
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override;
void
- OptionParsingStarting () override;
+ OptionParsingStarting(ExecutionContext *execution_context) override;
const OptionDefinition*
GetDefinitions () override
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter)
+ CommandOptions() :
+ Options()
{
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_cascade = true;
m_class_name = "";
}
void
- OptionParsingStarting (CommandInterpreter &interpreter) override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_cascade = true;
m_skip_pointers = false;
}
Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override
+ SetOptionValue(uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = g_option_table[option_idx].short_option;
"type format add",
"Add a new formatting style for a type.",
nullptr),
- m_option_group (interpreter),
- m_format_options (eFormatInvalid),
- m_command_options ()
+ m_option_group(),
+ m_format_options(eFormatInvalid),
+ m_command_options()
{
CommandArgumentEntry type_arg;
CommandArgumentData type_style_arg;
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter)
+ CommandOptions() :
+ Options()
{
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_delete_all = false;
m_category = "default";
name,
help,
nullptr),
- m_options(interpreter),
+ m_options(),
m_formatter_kind_mask(formatter_kind_mask)
{
CommandArgumentEntry type_arg;
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter)
+ CommandOptions() :
+ Options()
{
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_delete_all = false;
}
name,
help,
nullptr),
- m_options(interpreter),
+ m_options(),
m_formatter_kind_mask(formatter_kind_mask)
{
}
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
+ CommandOptions() :
+ Options(),
m_category_regex("",""),
m_category_language(lldb::eLanguageTypeUnknown, lldb::eLanguageTypeUnknown)
{
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_category_regex.Clear();
m_category_language.Clear();
name,
help,
nullptr),
- m_options(interpreter)
+ m_options()
{
CommandArgumentEntry type_arg;
CommandArgumentData type_style_arg;
#endif // LLDB_DISABLE_PYTHON
Error
-CommandObjectTypeSummaryAdd::CommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
+CommandObjectTypeSummaryAdd::CommandOptions::SetOptionValue(uint32_t option_idx,
+ const char
+ *option_arg,
+ ExecutionContext
+ *execution_context)
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
-CommandObjectTypeSummaryAdd::CommandOptions::OptionParsingStarting ()
+CommandObjectTypeSummaryAdd::CommandOptions::OptionParsingStarting(
+ ExecutionContext *execution_context)
{
m_flags.Clear().SetCascades().SetDontShowChildren().SetDontShowValue(false);
m_flags.SetShowMembersOneLiner(false).SetSkipPointers(false).SetSkipReferences(false).SetHideItemNames(false);
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
+ CommandOptions() :
+ Options(),
m_define_enabled(false,false),
m_cate_language(eLanguageTypeUnknown,eLanguageTypeUnknown)
{
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_define_enabled.Clear();
m_cate_language.Clear();
"type category define",
"Define a new category as a source of formatters.",
nullptr),
- m_options(interpreter)
+ m_options()
{
CommandArgumentEntry type_arg;
CommandArgumentData type_style_arg;
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter)
+ CommandOptions() :
+ Options()
{
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_language = lldb::eLanguageTypeUnknown;
}
"type category enable",
"Enable a category as a source of formatters.",
nullptr),
- m_options(interpreter)
+ m_options()
{
CommandArgumentEntry type_arg;
CommandArgumentData type_style_arg;
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter)
+ CommandOptions() :
+ Options()
{
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue (uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_language = lldb::eLanguageTypeUnknown;
}
"type category disable",
"Disable a category as a source of formatters.",
nullptr),
- m_options(interpreter)
+ m_options()
{
CommandArgumentEntry type_arg;
CommandArgumentData type_style_arg;
"Add a new synthetic provider for a type.",
nullptr),
IOHandlerDelegateMultiline ("DONE"),
- m_options (interpreter)
+ m_options()
{
CommandArgumentEntry type_arg;
CommandArgumentData type_style_arg;
typedef std::vector<std::string> option_vector;
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter)
+ CommandOptions() :
+ Options()
{
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_cascade = true;
m_skip_pointers = false;
"type filter add",
"Add a new filter for a type.",
nullptr),
- m_options (interpreter)
+ m_options()
{
CommandArgumentEntry type_arg;
CommandArgumentData type_style_arg;
}
Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value) override
+ SetOptionValue (uint32_t option_idx,
+ const char *option_value,
+ ExecutionContext *execution_context) override
{
Error error;
}
void
- OptionParsingStarting (CommandInterpreter &interpreter) override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_show_help = false;
m_language = eLanguageTypeUnknown;
"Lookup types and declarations in the current target, following language-specific naming conventions.",
"type lookup <type-specifier>",
eCommandRequiresTarget),
- m_option_group(interpreter),
+ m_option_group(),
m_command_options()
{
m_option_group.Append(&m_command_options);
result.SetError("type lookup cannot be invoked without a type name as argument");
return false;
}
-
- m_option_group.NotifyOptionParsingStarting();
+
+ auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
+ m_option_group.NotifyOptionParsingStarting(&exe_ctx);
const char * name_of_type = nullptr;
if (!ParseOptions (args, result))
return false;
- Error error (m_option_group.NotifyOptionParsingFinished());
+ Error error(m_option_group.NotifyOptionParsingFinished(
+ &exe_ctx));
if (error.Fail())
{
result.AppendError (error.AsCString());
if (nullptr == name_of_type)
name_of_type = raw_command_line;
- TargetSP target_sp(GetCommandInterpreter().GetDebugger().GetSelectedTarget());
- const bool fill_all_in = true;
- ExecutionContext exe_ctx(target_sp.get(), fill_all_in);
+ // TargetSP target_sp(GetCommandInterpreter().GetDebugger().GetSelectedTarget());
+ // const bool fill_all_in = true;
+ // ExecutionContext exe_ctx(target_sp.get(), fill_all_in);
ExecutionContextScope *best_scope = exe_ctx.GetBestExecutionContextScope();
bool any_found = false;
"watchpoint list",
"List all watchpoints at configurable levels of detail.",
nullptr),
- m_options(interpreter)
+ m_options()
{
CommandArgumentEntry arg;
CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID, eArgTypeWatchpointIDRange);
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter),
+ CommandOptions() :
+ Options(),
m_level(lldb::eDescriptionLevelBrief) // Watchpoint List defaults to brief descriptions
{
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_level = lldb::eDescriptionLevelFull;
}
"watchpoint ignore",
"Set ignore count on the specified watchpoint(s). If no watchpoints are specified, set them all.",
nullptr),
- m_options (interpreter)
+ m_options()
{
CommandArgumentEntry arg;
CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID, eArgTypeWatchpointIDRange);
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
+ CommandOptions() :
+ Options(),
m_ignore_count (0)
{
}
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_ignore_count = 0;
}
"If no watchpoint is specified, act on the last created watchpoint. "
"Passing an empty argument clears the modification.",
nullptr),
- m_options (interpreter)
+ m_options()
{
CommandArgumentEntry arg;
CommandObject::AddIDsArgumentData(arg, eArgTypeWatchpointID, eArgTypeWatchpointIDRange);
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
+ CommandOptions() :
+ Options(),
m_condition (),
m_condition_passed (false)
{
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_condition.clear();
m_condition_passed = false;
eCommandTryTargetAPILock |
eCommandProcessMustBeLaunched |
eCommandProcessMustBePaused ),
- m_option_group (interpreter),
+ m_option_group(),
m_option_watchpoint ()
{
SetHelpLong(
eCommandTryTargetAPILock |
eCommandProcessMustBeLaunched |
eCommandProcessMustBePaused ),
- m_option_group (interpreter),
+ m_option_group(),
m_option_watchpoint ()
{
SetHelpLong(
bool
DoExecute (const char *raw_command, CommandReturnObject &result) override
{
- m_option_group.NotifyOptionParsingStarting(); // This is a raw command, so notify the option group
+ auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
+ m_option_group.NotifyOptionParsingStarting(&exe_ctx); // This is a raw command, so notify the option group
Target *target = m_interpreter.GetDebugger().GetSelectedTarget().get();
StackFrame *frame = m_exe_ctx.GetFramePtr();
if (!ParseOptions (args, result))
return false;
- Error error (m_option_group.NotifyOptionParsingFinished());
+ Error error(m_option_group.NotifyOptionParsingFinished(
+ &exe_ctx));
if (error.Fail())
{
result.AppendError (error.AsCString());
interpreter, "add",
"Add a set of LLDB commands to a watchpoint, to be executed whenever the watchpoint is hit.", nullptr),
IOHandlerDelegateMultiline("DONE", IOHandlerDelegate::Completion::LLDBCommand),
- m_options(interpreter)
+ m_options()
{
SetHelpLong (
R"(
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options (interpreter),
+ CommandOptions() :
+ Options(),
m_use_commands (false),
m_use_script_language (false),
m_script_language (eScriptLanguageNone),
~CommandOptions() override = default;
Error
- SetOptionValue (uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting () override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_use_commands = true;
m_use_script_language = false;
{
// Make sure all option values have sane defaults
Debugger &debugger = m_target.GetDebugger();
- CommandInterpreter &ci = debugger.GetCommandInterpreter();
- m_format_options.OptionParsingStarting(ci);
- m_varobj_options.OptionParsingStarting(ci);
- m_command_options.OptionParsingStarting(ci);
+ auto exe_ctx = debugger.GetCommandInterpreter().GetExecutionContext();
+ m_format_options.OptionParsingStarting(&exe_ctx);
+ m_varobj_options.OptionParsingStarting(&exe_ctx);
+ m_command_options.OptionParsingStarting(&exe_ctx);
// Default certain settings for REPL regardless of the global settings.
m_command_options.unwind_on_error = false;
Error
-Args::ParseOptions (Options &options)
+Args::ParseOptions (Options &options, ExecutionContext *execution_context,
+ PlatformSP platform_sp, bool require_validation)
{
StreamString sstr;
Error error;
if (long_options_index >= 0 && long_options[long_options_index].definition)
{
const OptionDefinition *def = long_options[long_options_index].definition;
- CommandInterpreter &interpreter = options.GetInterpreter();
+
+ if (!platform_sp)
+ {
+ // User did not pass in an explicit platform. Try to grab
+ // from the execution context.
+ TargetSP target_sp = execution_context ?
+ execution_context->GetTargetSP() : TargetSP();
+ platform_sp = target_sp ?
+ target_sp->GetPlatform() : PlatformSP();
+ }
OptionValidator *validator = def->validator;
- if (validator && !validator->IsValid(*interpreter.GetPlatform(true), interpreter.GetExecutionContext()))
+
+ if (!platform_sp && require_validation)
{
- error.SetErrorStringWithFormat("Option \"%s\" invalid. %s", def->long_option, def->validator->LongConditionString());
+ // Caller requires validation but we cannot validate as we
+ // don't have the mandatory platform against which to
+ // validate.
+ error.SetErrorString("cannot validate options: "
+ "no platform available");
+ return error;
}
- else
+
+ bool validation_failed = false;
+ if (platform_sp)
{
- error = options.SetOptionValue(long_options_index,
- (def->option_has_arg == OptionParser::eNoArgument) ? nullptr : OptionParser::GetOptionArgument());
+ // Ensure we have an execution context, empty or not.
+ ExecutionContext dummy_context;
+ ExecutionContext *exe_ctx_p =
+ execution_context ? execution_context : &dummy_context;
+ if (validator && !validator->IsValid(*platform_sp, *exe_ctx_p))
+ {
+ validation_failed = true;
+ error.SetErrorStringWithFormat("Option \"%s\" invalid. %s", def->long_option, def->validator->LongConditionString());
+ }
}
+
+ // As long as validation didn't fail, we set the option value.
+ if (!validation_failed)
+ error = options.SetOptionValue(long_options_index,
+ (def->option_has_arg == OptionParser::eNoArgument) ? nullptr : OptionParser::GetOptionArgument(),
+ execution_context);
}
else
{
#include "llvm/Support/ErrorHandling.h"
#include "lldb/Core/StreamString.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandObject.h"
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Interpreter/Options.h"
if (options)
{
// See if any options were specified as part of the alias; if so, handle them appropriately.
- options->NotifyOptionParsingStarting ();
+ ExecutionContext exe_ctx =
+ cmd_obj_sp->GetCommandInterpreter().GetExecutionContext();
+ options->NotifyOptionParsingStarting(&exe_ctx);
args.Unshift ("dummy_arg");
args.ParseAliasOptions (*options, result, option_arg_vector, options_string);
args.Shift ();
if (options != nullptr)
{
Error error;
- options->NotifyOptionParsingStarting();
+
+ auto exe_ctx = GetCommandInterpreter().GetExecutionContext();
+ options->NotifyOptionParsingStarting(&exe_ctx);
// ParseOptions calls getopt_long_only, which always skips the zero'th item in the array and starts at position 1,
// so we need to push a dummy value into position zero.
args.Unshift("dummy_string");
- error = args.ParseOptions (*options);
+ const bool require_validation = true;
+ error = args.ParseOptions(*options, &exe_ctx,
+ GetCommandInterpreter().GetPlatform(true),
+ require_validation);
// The "dummy_string" will have already been removed by ParseOptions,
// so no need to remove it.
if (error.Success())
- error = options->NotifyOptionParsingFinished();
+ error = options->NotifyOptionParsingFinished(&exe_ctx);
if (error.Success())
{
else
{
// No error string, output the usage information into result
- options->GenerateOptionUsage (result.GetErrorStream(), this);
+ options->GenerateOptionUsage(result.GetErrorStream(), this,
+ GetCommandInterpreter()
+ .GetDebugger()
+ .GetTerminalWidth());
}
}
result.SetStatus (eReturnStatusFailed);
cursor_char_position,
match_start_point,
max_return_elements,
+ GetCommandInterpreter(),
word_complete,
matches);
if (handled_by_options)
&& GetOptions() != nullptr)
{
StreamString usage_help;
- GetOptions()->GenerateOptionUsage (usage_help, this);
+ GetOptions()->GenerateOptionUsage(usage_help, this,
+ GetCommandInterpreter()
+ .GetDebugger().GetTerminalWidth());
if (usage_help.GetSize() > 0)
{
const char *usage_text = usage_help.GetData();
Options *options = GetOptions();
if (options != nullptr)
{
- options->GenerateOptionUsage(output_strm, this);
+ options->GenerateOptionUsage(output_strm, this,
+ GetCommandInterpreter()
+ .GetDebugger().GetTerminalWidth());
}
const char *long_help = GetHelpLong();
if ((long_help != nullptr) && (strlen(long_help) > 0))
if (m_completion_type_mask)
{
std::string completion_str (input.GetArgumentAtIndex (cursor_index), cursor_char_position);
- CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
+ CommandCompletions::InvokeCommonCompletionCallbacks (GetCommandInterpreter(),
m_completion_type_mask,
completion_str.c_str(),
match_start_point,
Error
-OptionGroupArchitecture::SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg)
+OptionGroupArchitecture::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error;
const int short_option = g_option_table[option_idx].short_option;
}
void
-OptionGroupArchitecture::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupArchitecture::OptionParsingStarting(
+ ExecutionContext *execution_context)
{
m_arch_str.clear();
}
}
Error
-OptionGroupBoolean::SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg)
+OptionGroupBoolean::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error;
if (m_option_definition.option_has_arg == OptionParser::eNoArgument)
}
void
-OptionGroupBoolean::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupBoolean::OptionParsingStarting(ExecutionContext *execution_context)
{
m_value.Clear();
}
}
Error
-OptionGroupFile::SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg)
+OptionGroupFile::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error (m_file.SetValueFromString (option_arg));
return error;
}
void
-OptionGroupFile::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupFile::OptionParsingStarting(ExecutionContext *execution_context)
{
m_file.Clear();
}
}
Error
-OptionGroupFileList::SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg)
+OptionGroupFileList::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error (m_file_list.SetValueFromString (option_arg));
return error;
}
void
-OptionGroupFileList::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupFileList::OptionParsingStarting(ExecutionContext *execution_context)
{
m_file_list.Clear();
}
}
Error
-OptionGroupFormat::SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg)
+OptionGroupFormat::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error;
const int short_option = g_option_table[option_idx].short_option;
Format format = eFormatDefault;
uint32_t byte_size = 0;
- while (ParserGDBFormatLetter (interpreter, gdb_format_cstr[0], format, byte_size))
+ while (ParserGDBFormatLetter (execution_context,
+ gdb_format_cstr[0], format,
+ byte_size))
{
++gdb_format_cstr;
}
// Anything that wasn't set correctly should be set to the
// previous default
if (format == eFormatInvalid)
- ParserGDBFormatLetter (interpreter, m_prev_gdb_format, format, byte_size);
+ ParserGDBFormatLetter (execution_context, m_prev_gdb_format,
+ format, byte_size);
const bool byte_size_enabled = m_byte_size.GetDefaultValue() < UINT64_MAX;
const bool count_enabled = m_count.GetDefaultValue() < UINT64_MAX;
{
// Byte size is enabled
if (byte_size == 0)
- ParserGDBFormatLetter (interpreter, m_prev_gdb_size, format, byte_size);
+ ParserGDBFormatLetter (execution_context, m_prev_gdb_size, format, byte_size);
}
else
{
}
bool
-OptionGroupFormat::ParserGDBFormatLetter (CommandInterpreter &interpreter, char format_letter, Format &format, uint32_t &byte_size)
+OptionGroupFormat::ParserGDBFormatLetter(ExecutionContext *execution_context,
+ char format_letter, Format &format,
+ uint32_t &byte_size)
{
m_has_gdb_format = true;
switch (format_letter)
case 'f': format = eFormatFloat; m_prev_gdb_format = format_letter; return true;
case 'a': format = eFormatAddressInfo;
{
- ExecutionContext exe_ctx(interpreter.GetExecutionContext());
- Target *target = exe_ctx.GetTargetPtr();
- if (target)
- byte_size = target->GetArchitecture().GetAddressByteSize();
+ TargetSP target_sp = execution_context ?
+ execution_context->GetTargetSP() : TargetSP();
+ if (target_sp)
+ byte_size = target_sp->GetArchitecture().GetAddressByteSize();
m_prev_gdb_format = format_letter;
return true;
}
}
void
-OptionGroupFormat::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupFormat::OptionParsingStarting(ExecutionContext *execution_context)
{
m_format.Clear();
m_byte_size.Clear();
}
Error
-OptionGroupOutputFile::SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg)
+OptionGroupOutputFile::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error;
const int short_option = g_option_table[option_idx].short_option;
}
void
-OptionGroupOutputFile::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupOutputFile::OptionParsingStarting(
+ ExecutionContext *execution_context)
{
m_file.Clear();
m_append.Clear();
}
void
-OptionGroupPlatform::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupPlatform::OptionParsingStarting(ExecutionContext *execution_context)
{
m_platform_name.clear();
m_sdk_sysroot.Clear();
Error
-OptionGroupPlatform::SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg)
+OptionGroupPlatform::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error;
if (!m_include_platform_option)
}
Error
-OptionGroupString::SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg)
+OptionGroupString::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error (m_value.SetValueFromString (option_arg));
return error;
}
void
-OptionGroupString::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupString::OptionParsingStarting(ExecutionContext *execution_context)
{
m_value.Clear();
}
}
Error
-OptionGroupUInt64::SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg)
+OptionGroupUInt64::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error (m_value.SetValueFromString (option_arg));
return error;
}
void
-OptionGroupUInt64::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupUInt64::OptionParsingStarting(ExecutionContext *execution_context)
{
m_value.Clear();
}
}
Error
-OptionGroupUUID::SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg)
+OptionGroupUUID::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error;
const int short_option = g_option_table[option_idx].short_option;
}
void
-OptionGroupUUID::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupUUID::OptionParsingStarting(ExecutionContext *execution_context)
{
m_uuid.Clear();
}
Error
-OptionGroupValueObjectDisplay::SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg)
+OptionGroupValueObjectDisplay::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext
+ *execution_context)
{
Error error;
const int short_option = g_option_table[option_idx].short_option;
}
void
-OptionGroupValueObjectDisplay::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupValueObjectDisplay::OptionParsingStarting(ExecutionContext
+ *execution_context)
{
// If these defaults change, be sure to modify AnyOptionWasSet().
show_types = false;
be_raw = false;
ignore_cap = false;
run_validator = false;
-
- Target *target = interpreter.GetExecutionContext().GetTargetPtr();
- if (target != nullptr)
- use_dynamic = target->GetPreferDynamicValue();
+
+ TargetSP target_sp =
+ execution_context ? execution_context->GetTargetSP() : TargetSP();
+ if (target_sp)
+ use_dynamic = target_sp->GetPreferDynamicValue();
else
{
// If we don't have any targets, then dynamic values won't do us much good.
}
Error
-OptionGroupVariable::SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg)
+OptionGroupVariable::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error;
if (!include_frame_options)
}
void
-OptionGroupVariable::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupVariable::OptionParsingStarting(ExecutionContext *execution_context)
{
show_args = true; // Frame option only
show_locals = true; // Frame option only
}
Error
-OptionGroupWatchpoint::SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg)
+OptionGroupWatchpoint::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error;
const int short_option = g_option_table[option_idx].short_option;
}
void
-OptionGroupWatchpoint::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupWatchpoint::OptionParsingStarting(ExecutionContext
+ *execution_context)
{
watch_type_specified = false;
watch_type = eWatchInvalid;
#include "lldb/DataFormatters/FormatManager.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandCompletions.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
using namespace lldb;
using namespace lldb_private;
#include "lldb/DataFormatters/FormatManager.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandCompletions.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
using namespace lldb;
using namespace lldb_private;
//-------------------------------------------------------------------------
// Options
//-------------------------------------------------------------------------
-Options::Options (CommandInterpreter &interpreter) :
- m_interpreter (interpreter),
+Options::Options () :
m_getopt_table ()
{
BuildValidOptionSets();
}
void
-Options::NotifyOptionParsingStarting ()
+Options::NotifyOptionParsingStarting(ExecutionContext *execution_context)
{
m_seen_options.clear();
// Let the subclass reset its option values
- OptionParsingStarting ();
+ OptionParsingStarting(execution_context);
}
Error
-Options::NotifyOptionParsingFinished ()
+Options::NotifyOptionParsingFinished(ExecutionContext *execution_context)
{
- return OptionParsingFinished ();
+ return OptionParsingFinished(execution_context);
}
void
Options::GenerateOptionUsage
(
Stream &strm,
- CommandObject *cmd
+ CommandObject *cmd,
+ uint32_t screen_width
)
{
const bool only_print_args = cmd->IsDashDashCommand();
- const uint32_t screen_width = m_interpreter.GetDebugger().GetTerminalWidth();
const OptionDefinition *opt_defs = GetDefinitions();
const uint32_t save_indent_level = strm.GetIndentLevel();
int char_pos,
int match_start_point,
int max_return_elements,
+ CommandInterpreter &interpreter,
bool &word_complete,
lldb_private::StringList &matches
)
i,
match_start_point,
max_return_elements,
+ interpreter,
word_complete,
matches);
return true;
int opt_element_index,
int match_start_point,
int max_return_elements,
+ CommandInterpreter &interpreter,
bool &word_complete,
lldb_private::StringList &matches
)
if (module_name)
{
FileSpec module_spec(module_name, false);
- lldb::TargetSP target_sp = m_interpreter.GetDebugger().GetSelectedTarget();
+ lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
// Search filters require a target...
if (target_sp)
filter_ap.reset (new SearchFilterByModule (target_sp, module_spec));
}
}
- return CommandCompletions::InvokeCommonCompletionCallbacks (m_interpreter,
+ return CommandCompletions::InvokeCommonCompletionCallbacks (interpreter,
completion_mask,
input.GetArgumentAtIndex (opt_arg_pos),
match_start_point,
Error
OptionGroupOptions::SetOptionValue (uint32_t option_idx,
- const char *option_value)
+ const char *option_value,
+ ExecutionContext *execution_context)
{
// After calling OptionGroupOptions::Append(...), you must finalize the groups
// by calling OptionGroupOptions::Finlize()
Error error;
if (option_idx < m_option_infos.size())
{
- error = m_option_infos[option_idx].option_group->SetOptionValue (m_interpreter,
- m_option_infos[option_idx].option_index,
- option_value);
+ error = m_option_infos[option_idx].option_group->SetOptionValue (m_option_infos[option_idx].option_index,
+ option_value,
+ execution_context);
}
else
}
void
-OptionGroupOptions::OptionParsingStarting ()
+OptionGroupOptions::OptionParsingStarting (ExecutionContext *execution_context)
{
std::set<OptionGroup*> group_set;
OptionInfos::iterator pos, end = m_option_infos.end();
OptionGroup* group = pos->option_group;
if (group_set.find(group) == group_set.end())
{
- group->OptionParsingStarting (m_interpreter);
+ group->OptionParsingStarting(execution_context);
group_set.insert(group);
}
}
}
Error
-OptionGroupOptions::OptionParsingFinished ()
+OptionGroupOptions::OptionParsingFinished (ExecutionContext *execution_context)
{
std::set<OptionGroup*> group_set;
Error error;
OptionGroup* group = pos->option_group;
if (group_set.find(group) == group_set.end())
{
- error = group->OptionParsingFinished (m_interpreter);
+ error = group->OptionParsingFinished (execution_context);
group_set.insert(group);
if (error.Fail())
return error;
class CommandOptions : public Options
{
public:
- CommandOptions (CommandInterpreter &interpreter) :
- Options(interpreter),
+ CommandOptions() :
+ Options(),
m_verbose(false,false)
{}
~CommandOptions() override = default;
Error
- SetOptionValue(uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting() override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_verbose.Clear();
}
eCommandRequiresProcess |
eCommandProcessMustBeLaunched |
eCommandProcessMustBePaused ),
- m_options(interpreter)
+ m_options()
{
CommandArgumentEntry arg;
CommandArgumentData index_arg;
"Sets a breakpoint on a renderscript kernel.",
"renderscript kernel breakpoint set <kernel_name> [-c x,y,z]",
eCommandRequiresProcess | eCommandProcessMustBeLaunched | eCommandProcessMustBePaused),
- m_options(interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions(CommandInterpreter &interpreter) : Options(interpreter) {}
+ CommandOptions() : Options() {}
~CommandOptions() override = default;
Error
- SetOptionValue(uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting() override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
// -1 means the -c option hasn't been set
m_coord[0] = -1;
: CommandObjectParsed(interpreter, "renderscript allocation dump",
"Displays the contents of a particular allocation", "renderscript allocation dump <ID>",
eCommandRequiresProcess | eCommandProcessMustBeLaunched),
- m_options(interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions(CommandInterpreter &interpreter) : Options(interpreter) {}
+ CommandOptions() : Options() {}
~CommandOptions() override = default;
Error
- SetOptionValue(uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting() override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_outfile.Clear();
}
: CommandObjectParsed(interpreter, "renderscript allocation list",
"List renderscript allocations and their information.", "renderscript allocation list",
eCommandRequiresProcess | eCommandProcessMustBeLaunched),
- m_options(interpreter)
+ m_options()
{
}
class CommandOptions : public Options
{
public:
- CommandOptions(CommandInterpreter &interpreter) : Options(interpreter), m_id(0) {}
+ CommandOptions() : Options(), m_id(0) {}
~CommandOptions() override = default;
Error
- SetOptionValue(uint32_t option_idx, const char *option_arg) override
+ SetOptionValue(uint32_t option_idx, const char *option_arg,
+ ExecutionContext *execution_context) override
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
}
void
- OptionParsingStarting() override
+ OptionParsingStarting(ExecutionContext *execution_context) override
{
m_id = 0;
}
auto iter = m_options.find(&interpreter), end = m_options.end();
if (iter == end)
{
- std::unique_ptr<lldb_private::OptionGroupOptions> options(new OptionGroupOptions(interpreter));
+ std::unique_ptr<lldb_private::OptionGroupOptions> options(new OptionGroupOptions());
options->Append(m_option_group_platform_rsync.get());
options->Append(m_option_group_platform_ssh.get());
options->Append(m_option_group_platform_caching.get());
"process plugin packet send",
"Send a custom packet through the KDP protocol by specifying the command byte and the packet payload data. A packet will be sent with a correct header and payload, and the raw result bytes will be displayed as a string value. ",
NULL),
- m_option_group (interpreter),
+ m_option_group(),
m_command_byte(LLDB_OPT_SET_1, true , "command", 'c', 0, eArgTypeNone, "Specify the command byte to use when sending the KDP request packet.", 0),
m_packet_data (LLDB_OPT_SET_1, false, "payload", 'p', 0, eArgTypeNone, "Specify packet payload bytes as a hex ASCII string with no spaces or hex prefixes.", NULL)
{
"process plugin packet speed-test",
"Tests packet speeds of various sizes to determine the performance characteristics of the GDB remote connection. ",
NULL),
- m_option_group (interpreter),
+ m_option_group (),
m_num_packets (LLDB_OPT_SET_1, false, "count", 'c', 0, eArgTypeCount, "The number of packets to send of each varying size (default is 1000).", 1000),
m_max_send (LLDB_OPT_SET_1, false, "max-send", 's', 0, eArgTypeCount, "The maximum number of bytes to send in a packet. Sizes increase in powers of 2 while the size is less than or equal to this option value. (default 1024).", 1024),
m_max_recv (LLDB_OPT_SET_1, false, "max-receive", 'r', 0, eArgTypeCount, "The maximum number of bytes to receive in a packet. Sizes increase in powers of 2 while the size is less than or equal to this option value. (default 1024).", 1024),
}
void
-OptionGroupPlatformRSync::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupPlatformRSync::OptionParsingStarting(ExecutionContext *execution_context)
{
m_rsync = false;
m_rsync_opts.clear();
}
lldb_private::Error
-OptionGroupPlatformRSync::SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg)
+OptionGroupPlatformRSync::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error;
char short_option = (char) GetDefinitions()[option_idx].short_option;
}
void
-OptionGroupPlatformSSH::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupPlatformSSH::OptionParsingStarting(ExecutionContext
+ *execution_context)
{
m_ssh = false;
m_ssh_opts.clear();
}
lldb_private::Error
-OptionGroupPlatformSSH::SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg)
+OptionGroupPlatformSSH::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error;
char short_option = (char) GetDefinitions()[option_idx].short_option;
}
void
-OptionGroupPlatformCaching::OptionParsingStarting (CommandInterpreter &interpreter)
+OptionGroupPlatformCaching::OptionParsingStarting(ExecutionContext
+ *execution_context)
{
m_cache_dir.clear();
}
lldb_private::Error
-OptionGroupPlatformCaching::SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg)
+OptionGroupPlatformCaching::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error;
char short_option = (char) GetDefinitions()[option_idx].short_option;
}
Error
-ProcessLaunchCommandOptions::SetOptionValue (uint32_t option_idx, const char *option_arg)
+ProcessLaunchCommandOptions::SetOptionValue(uint32_t option_idx,
+ const char *option_arg,
+ ExecutionContext *execution_context)
{
Error error;
const int short_option = m_getopt_table[option_idx].val;
break;
case 'a':
- if (!launch_info.GetArchitecture().SetTriple (option_arg, m_interpreter.GetPlatform(true).get()))
- launch_info.GetArchitecture().SetTriple (option_arg);
+ {
+ TargetSP target_sp = execution_context ?
+ execution_context->GetTargetSP() : TargetSP();
+ PlatformSP platform_sp = target_sp ?
+ target_sp->GetPlatform() : PlatformSP();
+ if (!launch_info.GetArchitecture().SetTriple (option_arg, platform_sp.get()))
+ launch_info.GetArchitecture().SetTriple (option_arg);
+ }
break;
case 'A': // Disable ASLR.