#ifndef lldb_Host_MonitoringProcessLauncher_h_
#define lldb_Host_MonitoringProcessLauncher_h_
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
#include "lldb/Host/ProcessLauncher.h"
namespace lldb_private
public:
explicit MonitoringProcessLauncher(std::unique_ptr<ProcessLauncher> delegate_launcher);
- virtual HostProcess LaunchProcess(const ProcessLaunchInfo &launch_info, Error &error);
+ HostProcess LaunchProcess(const ProcessLaunchInfo &launch_info, Error &error) override;
private:
std::unique_ptr<ProcessLauncher> m_delegate_launcher;
};
-}
-#endif
+} // namespace lldb_private
+
+#endif // lldb_Host_MonitoringProcessLauncher_h_
#ifndef lldb_Host_HostProcesPosix_h_
#define lldb_Host_HostProcesPosix_h_
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
#include "lldb/lldb-types.h"
#include "lldb/Core/Error.h"
#include "lldb/Host/HostNativeProcessBase.h"
public:
HostProcessPosix();
HostProcessPosix(lldb::process_t process);
- virtual ~HostProcessPosix();
+ ~HostProcessPosix() override;
virtual Error Signal(int signo) const;
static Error Signal(lldb::process_t process, int signo);
HostThread StartMonitoring(HostProcess::MonitorCallback callback, void *callback_baton, bool monitor_signals) override;
};
-}
-#endif
+} // namespace lldb_private
+
+#endif // lldb_Host_HostProcesPosix_h_
// so you can add custom enums starting from here in your Option class.
// Also if you & in this bit the base code will not process the option.
eCustomCompletion = (1u << 9)
-
} CommonCompletionTypes;
struct CommonCompletionElement
SearchFilter *searcher,
bool &word_complete,
StringList &matches);
+
static int
DiskDirectories (CommandInterpreter &interpreter,
const char *partial_file_name,
int max_return_elements,
StringList &matches);
- virtual ~Completer ();
+ ~Completer() override;
- virtual CallbackReturn
- SearchCallback (SearchFilter &filter,
- SymbolContext &context,
- Address *addr,
- bool complete) = 0;
+ CallbackReturn
+ SearchCallback(SearchFilter &filter,
+ SymbolContext &context,
+ Address *addr,
+ bool complete) override = 0;
- virtual Depth
- GetDepth () = 0;
+ Depth
+ GetDepth() override = 0;
virtual size_t
DoCompletion (SearchFilter *filter) = 0;
int m_match_start_point;
int m_max_return_elements;
StringList &m_matches;
+
private:
- DISALLOW_COPY_AND_ASSIGN (Completer);
+ DISALLOW_COPY_AND_ASSIGN(Completer);
};
//----------------------------------------------------------------------
class SourceFileCompleter : public Completer
{
public:
-
SourceFileCompleter (CommandInterpreter &interpreter,
bool include_support_files,
const char *completion_str,
int max_return_elements,
StringList &matches);
- virtual Searcher::Depth GetDepth ();
+ Searcher::Depth GetDepth() override;
- virtual Searcher::CallbackReturn
- SearchCallback (SearchFilter &filter,
- SymbolContext &context,
- Address *addr,
- bool complete);
+ Searcher::CallbackReturn
+ SearchCallback(SearchFilter &filter,
+ SymbolContext &context,
+ Address *addr,
+ bool complete) override;
size_t
- DoCompletion (SearchFilter *filter);
+ DoCompletion(SearchFilter *filter) override;
private:
bool m_include_support_files;
FileSpecList m_matching_files;
const char *m_file_name;
const char *m_dir_name;
- DISALLOW_COPY_AND_ASSIGN (SourceFileCompleter);
+ DISALLOW_COPY_AND_ASSIGN(SourceFileCompleter);
};
//----------------------------------------------------------------------
class ModuleCompleter : public Completer
{
public:
-
ModuleCompleter (CommandInterpreter &interpreter,
const char *completion_str,
int match_start_point,
int max_return_elements,
StringList &matches);
- virtual Searcher::Depth GetDepth ();
+ Searcher::Depth GetDepth() override;
- virtual Searcher::CallbackReturn
- SearchCallback (SearchFilter &filter,
- SymbolContext &context,
- Address *addr,
- bool complete);
+ Searcher::CallbackReturn
+ SearchCallback(SearchFilter &filter,
+ SymbolContext &context,
+ Address *addr,
+ bool complete) override;
size_t
- DoCompletion (SearchFilter *filter);
+ DoCompletion(SearchFilter *filter) override;
private:
const char *m_file_name;
const char *m_dir_name;
- DISALLOW_COPY_AND_ASSIGN (ModuleCompleter);
+ DISALLOW_COPY_AND_ASSIGN(ModuleCompleter);
};
//----------------------------------------------------------------------
class SymbolCompleter : public Completer
{
public:
-
SymbolCompleter (CommandInterpreter &interpreter,
const char *completion_str,
int match_start_point,
int max_return_elements,
StringList &matches);
- virtual Searcher::Depth GetDepth ();
+ Searcher::Depth GetDepth() override;
- virtual Searcher::CallbackReturn
- SearchCallback (SearchFilter &filter,
- SymbolContext &context,
- Address *addr,
- bool complete);
+ Searcher::CallbackReturn
+ SearchCallback(SearchFilter &filter,
+ SymbolContext &context,
+ Address *addr,
+ bool complete) override;
size_t
- DoCompletion (SearchFilter *filter);
+ DoCompletion(SearchFilter *filter) override;
private:
// struct NameCmp {
RegularExpression m_regex;
typedef std::set<ConstString> collection;
collection m_match_set;
- DISALLOW_COPY_AND_ASSIGN (SymbolCompleter);
+ DISALLOW_COPY_AND_ASSIGN(SymbolCompleter);
};
private:
static CommonCompletionElement g_common_completions[];
-
};
} // namespace lldb_private
-#endif // lldb_CommandCompletions_h_
+
+#endif // lldb_CommandCompletions_h_
// Other libraries and framework includes
// Project includes
-
#include "lldb/lldb-private.h"
#include "lldb/Core/Stream.h"
#include "lldb/Host/Mutex.h"
public IOHandlerDelegate
{
public:
-
-
typedef std::map<std::string, OptionArgVectorSP> OptionArgMap;
enum
eCommandTypesAllThem = 0xFFFF // all commands
};
+ CommandInterpreter(Debugger &debugger,
+ lldb::ScriptLanguage script_language,
+ bool synchronous_execution);
+
+ ~CommandInterpreter() override;
+
// These two functions fill out the Broadcaster interface:
static ConstString &GetStaticBroadcasterClass ();
- virtual ConstString &GetBroadcasterClass() const
+ ConstString &GetBroadcasterClass() const override
{
return GetStaticBroadcasterClass();
}
SourceInitFile (bool in_cwd,
CommandReturnObject &result);
- CommandInterpreter (Debugger &debugger,
- lldb::ScriptLanguage script_language,
- bool synchronous_execution);
-
- virtual
- ~CommandInterpreter ();
-
bool
AddCommand (const char *name,
const lldb::CommandObjectSP &cmd_sp,
OptionArgVectorSP
GetAliasOptions (const char *alias_name);
-
bool
ProcessAliasOptionsArgs (lldb::CommandObjectSP &cmd_obj_sp,
const char *options_args,
// Otherwise, returns the number of matches.
//
// FIXME: Only max_return_elements == -1 is supported at present.
-
int
HandleCompletion (const char *current_line,
const char *cursor,
// Help command can call it for the first argument.
// word_complete tells whether the completions are considered a "complete" response (so the
// completer should complete the quote & put a space after the word.
-
int
HandleCompletionMatches (Args &input,
int &cursor_index,
bool &word_complete,
StringList &matches);
-
int
GetCommandNamesMatchingPartialString (const char *cmd_cstr,
bool include_aliases,
void
SetScriptLanguage (lldb::ScriptLanguage lang);
-
bool
HasCommands ();
//------------------------------------------------------------------
// IOHandlerDelegate functions
//------------------------------------------------------------------
- virtual void
- IOHandlerInputComplete (IOHandler &io_handler,
- std::string &line);
+ void
+ IOHandlerInputComplete(IOHandler &io_handler,
+ std::string &line) override;
- virtual ConstString
- IOHandlerGetControlSequence (char ch)
+ ConstString
+ IOHandlerGetControlSequence(char ch) override
{
if (ch == 'd')
return ConstString("quit\n");
return ConstString();
}
- virtual bool
- IOHandlerInterrupt (IOHandler &io_handler);
+ bool
+ IOHandlerInterrupt(IOHandler &io_handler) override;
size_t
GetProcessOutput ();
lldb::CommandObjectSP
GetCommandSP (const char *cmd, bool include_aliases = true, bool exact = true, StringList *matches = NULL);
-
private:
-
Error
PreprocessCommand (std::string &command);
CommandObject *
ResolveCommandImpl(std::string &command_line, CommandReturnObject &result);
-
Debugger &m_debugger; // The debugger session that this interpreter is associated with
ExecutionContextRef m_exe_ctx_ref; // The current execution context to use when handling commands
bool m_synchronous_execution;
uint32_t m_num_errors;
bool m_quit_requested;
bool m_stopped_for_crash;
-
};
-
} // namespace lldb_private
-#endif // liblldb_CommandInterpreter_h_
+#endif // liblldb_CommandInterpreter_h_
#ifndef liblldb_CommandObject_h_
#define liblldb_CommandObject_h_
+// C Includes
+// C++ Includes
#include <map>
-#include <set>
#include <string>
#include <vector>
+// Other libraries and framework includes
+// Project includes
#include "lldb/lldb-private.h"
#include "lldb/Interpreter/Args.h"
#include "lldb/Interpreter/CommandCompletions.h"
class CommandObject
{
public:
-
typedef const char *(ArgumentHelpCallbackFunction) ();
struct ArgumentHelpCallback
{
return (help_callback != NULL);
}
-
};
struct ArgumentTableEntry // Entries in the main argument information table
virtual
~CommandObject ();
-
static const char *
GetArgumentTypeAsCString (const lldb::CommandArgumentType arg_type);
/// @return
/// The number of completions.
//------------------------------------------------------------------
-
virtual int
HandleArgumentCompletion (Args &input,
int &cursor_index,
// to the specified command argument entry.
static void
AddIDsArgumentData(CommandArgumentEntry &arg, lldb::CommandArgumentType ID, lldb::CommandArgumentType IDRange);
-
};
class CommandObjectParsed : public CommandObject
{
public:
-
CommandObjectParsed (CommandInterpreter &interpreter,
const char *name,
const char *help = NULL,
uint32_t flags = 0) :
CommandObject (interpreter, name, help, syntax, flags) {}
- virtual
- ~CommandObjectParsed () {}
+ ~CommandObjectParsed() override = default;
- virtual bool
- Execute (const char *args_string, CommandReturnObject &result);
+ bool
+ Execute(const char *args_string, CommandReturnObject &result) override;
protected:
virtual bool
DoExecute (Args& command,
CommandReturnObject &result) = 0;
- virtual bool
- WantsRawCommandString() { return false; }
+ bool
+ WantsRawCommandString() override
+ {
+ return false;
+ }
};
class CommandObjectRaw : public CommandObject
{
public:
-
CommandObjectRaw (CommandInterpreter &interpreter,
const char *name,
const char *help = NULL,
uint32_t flags = 0) :
CommandObject (interpreter, name, help, syntax, flags) {}
- virtual
- ~CommandObjectRaw () {}
+ ~CommandObjectRaw() override = default;
- virtual bool
- Execute (const char *args_string, CommandReturnObject &result);
+ bool
+ Execute(const char *args_string, CommandReturnObject &result) override;
protected:
virtual bool
DoExecute (const char *command, CommandReturnObject &result) = 0;
- virtual bool
- WantsRawCommandString() { return true; }
+ bool
+ WantsRawCommandString() override
+ {
+ return true;
+ }
};
-
} // namespace lldb_private
-
-#endif // liblldb_CommandObject_h_
+#endif // liblldb_CommandObject_h_
// C Includes
// C++ Includes
-#include <map>
-
// Other libraries and framework includes
// Project includes
#include "lldb/Interpreter/CommandObject.h"
const char *syntax = NULL,
uint32_t flags = 0);
- virtual
- ~CommandObjectMultiword ();
+ ~CommandObjectMultiword() override;
- virtual bool
- IsMultiwordObject () { return true; }
+ bool
+ IsMultiwordObject() override
+ {
+ return true;
+ }
- virtual bool
- LoadSubCommand (const char *cmd_name,
- const lldb::CommandObjectSP& command_obj);
+ bool
+ LoadSubCommand(const char *cmd_name,
+ const lldb::CommandObjectSP& command_obj) override;
- virtual void
- GenerateHelpText (Stream &output_stream);
+ void
+ GenerateHelpText(Stream &output_stream) override;
- virtual lldb::CommandObjectSP
- GetSubcommandSP (const char *sub_cmd, StringList *matches = NULL);
+ lldb::CommandObjectSP
+ GetSubcommandSP(const char *sub_cmd, StringList *matches = NULL) override;
- virtual CommandObject *
- GetSubcommandObject (const char *sub_cmd, StringList *matches = NULL);
-
- virtual void
- AproposAllSubCommands (const char *prefix,
- const char *search_word,
- StringList &commands_found,
- StringList &commands_help);
-
- virtual bool
- WantsRawCommandString() { return false; }
-
- virtual int
- HandleCompletion (Args &input,
- int &cursor_index,
- int &cursor_char_position,
- int match_start_point,
- int max_return_elements,
- bool &word_complete,
- StringList &matches);
-
- virtual const char *GetRepeatCommand (Args ¤t_command_args, uint32_t index);
-
- virtual bool
- Execute (const char *args_string,
- CommandReturnObject &result);
+ CommandObject *
+ GetSubcommandObject(const char *sub_cmd, StringList *matches = NULL) override;
+
+ void
+ AproposAllSubCommands(const char *prefix,
+ const char *search_word,
+ StringList &commands_found,
+ StringList &commands_help) override;
+
+ bool
+ WantsRawCommandString() override
+ {
+ return false;
+ }
+
+ int
+ HandleCompletion(Args &input,
+ int &cursor_index,
+ int &cursor_char_position,
+ int match_start_point,
+ int max_return_elements,
+ bool &word_complete,
+ StringList &matches) override;
+
+ const char *
+ GetRepeatCommand (Args ¤t_command_args, uint32_t index) override;
+
+ bool
+ Execute(const char *args_string,
+ CommandReturnObject &result) override;
- virtual bool
- IsRemovable() const { return m_can_be_removed; }
+ bool
+ IsRemovable() const override
+ {
+ return m_can_be_removed;
+ }
void
SetRemovable (bool removable)
CommandObject::CommandMap m_subcommand_dict;
bool m_can_be_removed;
};
-
class CommandObjectProxy : public CommandObject
{
const char *syntax = NULL,
uint32_t flags = 0);
- virtual
- ~CommandObjectProxy ();
+ ~CommandObjectProxy() override;
// Subclasses must provide a command object that will be transparently
// used for this object.
virtual CommandObject *
GetProxyCommandObject() = 0;
- virtual const char *
- GetHelpLong ();
+ const char *
+ GetHelpLong() override;
- virtual bool
- IsRemovable() const;
+ bool
+ IsRemovable() const override;
- virtual bool
- IsMultiwordObject ();
-
- virtual lldb::CommandObjectSP
- GetSubcommandSP (const char *sub_cmd, StringList *matches = NULL);
-
- virtual CommandObject *
- GetSubcommandObject (const char *sub_cmd, StringList *matches = NULL);
+ bool
+ IsMultiwordObject() override;
- virtual void
- AproposAllSubCommands (const char *prefix,
- const char *search_word,
- StringList &commands_found,
- StringList &commands_help);
-
- virtual bool
- LoadSubCommand (const char *cmd_name,
- const lldb::CommandObjectSP& command_obj);
+ lldb::CommandObjectSP
+ GetSubcommandSP(const char *sub_cmd, StringList *matches = NULL) override;
- virtual bool
- WantsRawCommandString();
+ CommandObject *
+ GetSubcommandObject(const char *sub_cmd, StringList *matches = NULL) override;
- virtual bool
- WantsCompletion();
-
- virtual Options *
- GetOptions ();
-
-
- virtual int
- HandleCompletion (Args &input,
- int &cursor_index,
- int &cursor_char_position,
- int match_start_point,
- int max_return_elements,
- bool &word_complete,
- StringList &matches);
-
- virtual int
- HandleArgumentCompletion (Args &input,
- int &cursor_index,
- int &cursor_char_position,
- OptionElementVector &opt_element_vector,
- int match_start_point,
- int max_return_elements,
- bool &word_complete,
- StringList &matches);
-
- virtual const char *
- GetRepeatCommand (Args ¤t_command_args,
- uint32_t index);
-
- virtual bool
- Execute (const char *args_string,
- CommandReturnObject &result);
+ void
+ AproposAllSubCommands(const char *prefix,
+ const char *search_word,
+ StringList &commands_found,
+ StringList &commands_help) override;
+
+ bool
+ LoadSubCommand(const char *cmd_name,
+ const lldb::CommandObjectSP& command_obj) override;
+
+ bool
+ WantsRawCommandString() override;
+
+ bool
+ WantsCompletion() override;
+
+ Options *
+ GetOptions() override;
+
+ int
+ HandleCompletion(Args &input,
+ int &cursor_index,
+ int &cursor_char_position,
+ int match_start_point,
+ int max_return_elements,
+ bool &word_complete,
+ StringList &matches) override;
+
+ int
+ HandleArgumentCompletion(Args &input,
+ int &cursor_index,
+ int &cursor_char_position,
+ OptionElementVector &opt_element_vector,
+ int match_start_point,
+ int max_return_elements,
+ bool &word_complete,
+ StringList &matches) override;
+
+ const char *
+ GetRepeatCommand(Args ¤t_command_args,
+ uint32_t index) override;
+
+ bool
+ Execute(const char *args_string,
+ CommandReturnObject &result) override;
protected:
-
// These two want to iterate over the subcommand dictionary.
friend class CommandInterpreter;
friend class CommandObjectSyntax;
-
};
} // namespace lldb_private
-#endif // liblldb_CommandObjectMultiword_h_
+#endif // liblldb_CommandObjectMultiword_h_
class CommandObjectRegexCommand : public CommandObjectRaw
{
public:
-
CommandObjectRegexCommand (CommandInterpreter &interpreter,
const char *name,
const char *help,
uint32_t completion_type_mask,
bool is_removable);
- virtual
- ~CommandObjectRegexCommand ();
+ ~CommandObjectRegexCommand() override;
bool
IsRemovable () const override { return m_is_removable; }
} // namespace lldb_private
-#endif // liblldb_CommandObjectRegexCommand_h_
+#endif // liblldb_CommandObjectRegexCommand_h_
#ifndef liblldb_CommandOptionValidators_h_
#define liblldb_CommandOptionValidators_h_
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
#include "lldb/lldb-private-types.h"
namespace lldb_private {
class PosixPlatformCommandOptionValidator : public OptionValidator
{
- virtual bool IsValid(Platform &platform, const ExecutionContext &target) const;
- virtual const char* ShortConditionString() const;
- virtual const char* LongConditionString() const;
+ bool IsValid(Platform &platform, const ExecutionContext &target) const override;
+ const char* ShortConditionString() const override;
+ const char* LongConditionString() const override;
};
} // namespace lldb_private
-
-#endif // liblldb_CommandOptionValidators_h_
+#endif // liblldb_CommandOptionValidators_h_
OptionGroupArchitecture ();
- virtual
- ~OptionGroupArchitecture ();
+ ~OptionGroupArchitecture() override;
+ uint32_t
+ GetNumDefinitions() override;
- virtual uint32_t
- GetNumDefinitions ();
+ const OptionDefinition*
+ GetDefinitions() override;
- virtual const OptionDefinition*
- GetDefinitions ();
+ Error
+ SetOptionValue(CommandInterpreter &interpreter,
+ uint32_t option_idx,
+ const char *option_value) override;
- virtual Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value);
-
- virtual void
- OptionParsingStarting (CommandInterpreter &interpreter);
+ void
+ OptionParsingStarting(CommandInterpreter &interpreter) override;
bool
GetArchitecture (Platform *platform, ArchSpec &arch);
{
return !m_arch_str.empty();
}
+
const char *
GetArchitectureName ()
{
} // namespace lldb_private
-#endif // liblldb_OptionGroupArchitecture_h_
+#endif // liblldb_OptionGroupArchitecture_h_
bool default_value,
bool no_argument_toggle_default);
- virtual
- ~OptionGroupBoolean ();
-
-
- virtual uint32_t
- GetNumDefinitions ()
+ ~OptionGroupBoolean() override;
+
+ uint32_t
+ GetNumDefinitions() override
{
return 1;
}
- virtual const OptionDefinition*
- GetDefinitions ()
+ const OptionDefinition*
+ GetDefinitions() override
{
return &m_option_definition;
}
- virtual Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value);
+ Error
+ SetOptionValue(CommandInterpreter &interpreter,
+ uint32_t option_idx,
+ const char *option_value) override;
- virtual void
- OptionParsingStarting (CommandInterpreter &interpreter);
+ void
+ OptionParsingStarting(CommandInterpreter &interpreter) override;
OptionValueBoolean &
GetOptionValue ()
protected:
OptionValueBoolean m_value;
OptionDefinition m_option_definition;
-
};
} // namespace lldb_private
-#endif // liblldb_OptionGroupBoolean_h_
+#endif // liblldb_OptionGroupBoolean_h_
-//===-- OptionGroupFile.h -------------------------------*- C++ -*-===//
+//===-- OptionGroupFile.h ---------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
class OptionGroupFile : public OptionGroup
{
public:
-
OptionGroupFile (uint32_t usage_mask,
bool required,
const char *long_option,
lldb::CommandArgumentType argument_type,
const char *usage_text);
- virtual
- ~OptionGroupFile ();
+ ~OptionGroupFile() override;
-
- virtual uint32_t
- GetNumDefinitions ()
+ uint32_t
+ GetNumDefinitions() override
{
return 1;
}
- virtual const OptionDefinition*
- GetDefinitions ()
+ const OptionDefinition*
+ GetDefinitions() override
{
return &m_option_definition;
}
- virtual Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value);
+ Error
+ SetOptionValue(CommandInterpreter &interpreter,
+ uint32_t option_idx,
+ const char *option_value) override;
- virtual void
- OptionParsingStarting (CommandInterpreter &interpreter);
+ void
+ OptionParsingStarting(CommandInterpreter &interpreter) override;
OptionValueFileSpec &
GetOptionValue ()
protected:
OptionValueFileSpec m_file;
OptionDefinition m_option_definition;
-
};
//-------------------------------------------------------------------------
lldb::CommandArgumentType argument_type,
const char *usage_text);
- virtual
- ~OptionGroupFileList ();
+ ~OptionGroupFileList() override;
-
- virtual uint32_t
- GetNumDefinitions ()
+ uint32_t
+ GetNumDefinitions() override
{
return 1;
}
- virtual const OptionDefinition*
- GetDefinitions ()
+ const OptionDefinition*
+ GetDefinitions() override
{
return &m_option_definition;
}
- virtual Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value);
-
- virtual void
- OptionParsingStarting (CommandInterpreter &interpreter);
+ Error
+ SetOptionValue(CommandInterpreter &interpreter,
+ uint32_t option_idx,
+ const char *option_value) override;
+ void
+ OptionParsingStarting(CommandInterpreter &interpreter) override;
OptionValueFileSpecList &
GetOptionValue ()
protected:
OptionValueFileSpecList m_file_list;
OptionDefinition m_option_definition;
-
};
} // namespace lldb_private
-#endif // liblldb_OptionGroupFile_h_
+#endif // liblldb_OptionGroupFile_h_
-//===-- OptionGroupFormat.h -------------------------------*- C++ -*-===//
+//===-- OptionGroupFormat.h -------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
uint64_t default_byte_size = UINT64_MAX, // Pass UINT64_MAX to disable the "--size" option
uint64_t default_count = UINT64_MAX); // Pass UINT64_MAX to disable the "--count" option
- virtual
- ~OptionGroupFormat ();
+ ~OptionGroupFormat() override;
+ uint32_t
+ GetNumDefinitions() override;
- virtual uint32_t
- GetNumDefinitions ();
+ const OptionDefinition*
+ GetDefinitions() override;
- virtual const OptionDefinition*
- GetDefinitions ();
+ Error
+ SetOptionValue(CommandInterpreter &interpreter,
+ uint32_t option_idx,
+ const char *option_value) override;
- virtual Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value);
-
- virtual void
- OptionParsingStarting (CommandInterpreter &interpreter);
+ void
+ OptionParsingStarting(CommandInterpreter &interpreter) override;
lldb::Format
GetFormat () const
}
protected:
-
bool
ParserGDBFormatLetter (CommandInterpreter &interpreter,
char format_letter,
OptionValueUInt64 m_count;
char m_prev_gdb_format;
char m_prev_gdb_size;
-
bool m_has_gdb_format;
};
} // namespace lldb_private
-#endif // liblldb_OptionGroupFormat_h_
+#endif // liblldb_OptionGroupFormat_h_
-//===-- OptionGroupOutputFile.h -------------------------------*- C++ -*-===//
+//===-- OptionGroupOutputFile.h ---------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
class OptionGroupOutputFile : public OptionGroup
{
public:
-
OptionGroupOutputFile ();
- virtual
- ~OptionGroupOutputFile ();
+ ~OptionGroupOutputFile() override;
+ uint32_t
+ GetNumDefinitions() override;
- virtual uint32_t
- GetNumDefinitions ();
-
- virtual const OptionDefinition*
- GetDefinitions ();
+ const OptionDefinition*
+ GetDefinitions() override;
- virtual Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value);
+ Error
+ SetOptionValue(CommandInterpreter &interpreter,
+ uint32_t option_idx,
+ const char *option_value) override;
- virtual void
- OptionParsingStarting (CommandInterpreter &interpreter);
+ void
+ OptionParsingStarting(CommandInterpreter &interpreter) override;
const OptionValueFileSpec &
GetFile ()
protected:
OptionValueFileSpec m_file;
OptionValueBoolean m_append;
-
};
} // namespace lldb_private
-#endif // liblldb_OptionGroupOutputFile_h_
+#endif // liblldb_OptionGroupOutputFile_h_
class OptionGroupPlatform : public OptionGroup
{
public:
-
OptionGroupPlatform (bool include_platform_option) :
OptionGroup(),
m_platform_name (),
{
}
- virtual
- ~OptionGroupPlatform ()
- {
- }
+ ~OptionGroupPlatform() override = default;
- virtual uint32_t
- GetNumDefinitions ();
+ uint32_t
+ GetNumDefinitions() override;
- virtual const OptionDefinition*
- GetDefinitions ();
+ const OptionDefinition*
+ GetDefinitions() override;
- virtual Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value);
+ Error
+ SetOptionValue(CommandInterpreter &interpreter,
+ uint32_t option_idx,
+ const char *option_value) override;
- virtual void
- OptionParsingStarting (CommandInterpreter &interpreter);
+ void
+ OptionParsingStarting(CommandInterpreter &interpreter) override;
lldb::PlatformSP
CreatePlatformWithOptions (CommandInterpreter &interpreter,
} // namespace lldb_private
-#endif // liblldb_OptionGroupPlatform_h_
+#endif // liblldb_OptionGroupPlatform_h_
-//===-- OptionGroupString.h ------------------------------------*- C++ -*-===//
+//===-- OptionGroupString.h -------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
class OptionGroupString : public OptionGroup
{
public:
-
OptionGroupString (uint32_t usage_mask,
bool required,
const char *long_option,
const char *usage_text,
const char *default_value);
- virtual
- ~OptionGroupString ();
-
-
- virtual uint32_t
- GetNumDefinitions ()
+ ~OptionGroupString() override;
+
+ uint32_t
+ GetNumDefinitions() override
{
return 1;
}
- virtual const OptionDefinition*
- GetDefinitions ()
+ const OptionDefinition*
+ GetDefinitions() override
{
return &m_option_definition;
}
- virtual Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value);
+ Error
+ SetOptionValue(CommandInterpreter &interpreter,
+ uint32_t option_idx,
+ const char *option_value) override;
- virtual void
- OptionParsingStarting (CommandInterpreter &interpreter);
+ void
+ OptionParsingStarting(CommandInterpreter &interpreter) override;
OptionValueString &
GetOptionValue ()
protected:
OptionValueString m_value;
OptionDefinition m_option_definition;
-
};
} // namespace lldb_private
-#endif // liblldb_OptionGroupString_h_
+#endif // liblldb_OptionGroupString_h_
-//===-- OptionGroupUInt64.h ------------------------------------*- C++ -*-===//
+//===-- OptionGroupUInt64.h -------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
#include "lldb/Interpreter/OptionValueUInt64.h"
namespace lldb_private {
+
//-------------------------------------------------------------------------
// OptionGroupUInt64
//-------------------------------------------------------------------------
class OptionGroupUInt64 : public OptionGroup
{
public:
-
OptionGroupUInt64 (uint32_t usage_mask,
bool required,
const char *long_option,
const char *usage_text,
uint64_t default_value);
- virtual
- ~OptionGroupUInt64 ();
-
-
- virtual uint32_t
- GetNumDefinitions ()
+ ~OptionGroupUInt64() override;
+
+ uint32_t
+ GetNumDefinitions() override
{
return 1;
}
- virtual const OptionDefinition*
- GetDefinitions ()
+ const OptionDefinition*
+ GetDefinitions() override
{
return &m_option_definition;
}
- virtual Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value);
+ Error
+ SetOptionValue(CommandInterpreter &interpreter,
+ uint32_t option_idx,
+ const char *option_value) override;
- virtual void
- OptionParsingStarting (CommandInterpreter &interpreter);
+ void
+ OptionParsingStarting(CommandInterpreter &interpreter) override;
OptionValueUInt64 &
GetOptionValue ()
protected:
OptionValueUInt64 m_value;
OptionDefinition m_option_definition;
-
};
} // namespace lldb_private
-#endif // liblldb_OptionGroupUInt64_h_
+#endif // liblldb_OptionGroupUInt64_h_
#include "lldb/Interpreter/OptionValueUUID.h"
namespace lldb_private {
+
//-------------------------------------------------------------------------
// OptionGroupUUID
//-------------------------------------------------------------------------
class OptionGroupUUID : public OptionGroup
{
public:
-
OptionGroupUUID ();
- virtual
- ~OptionGroupUUID ();
+ ~OptionGroupUUID() override;
+ uint32_t
+ GetNumDefinitions() override;
- virtual uint32_t
- GetNumDefinitions ();
-
- virtual const OptionDefinition*
- GetDefinitions ();
+ const OptionDefinition*
+ GetDefinitions() override;
- virtual Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value);
+ Error
+ SetOptionValue(CommandInterpreter &interpreter,
+ uint32_t option_idx,
+ const char *option_value) override;
- virtual void
- OptionParsingStarting (CommandInterpreter &interpreter);
+ void
+ OptionParsingStarting(CommandInterpreter &interpreter) override;
const OptionValueUUID &
GetOptionValue () const
} // namespace lldb_private
-#endif // liblldb_OptionGroupUUID_h_
+#endif // liblldb_OptionGroupUUID_h_
-//===-- OptionGroupValueObjectDisplay.h -------------------------------*- C++ -*-===//
+//===-- OptionGroupValueObjectDisplay.h -------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
class OptionGroupValueObjectDisplay : public OptionGroup
{
public:
-
OptionGroupValueObjectDisplay ();
- virtual
- ~OptionGroupValueObjectDisplay ();
+ ~OptionGroupValueObjectDisplay() override;
+ uint32_t
+ GetNumDefinitions() override;
- virtual uint32_t
- GetNumDefinitions ();
-
- virtual const OptionDefinition*
- GetDefinitions ();
+ const OptionDefinition*
+ GetDefinitions() override;
- virtual Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_value);
+ Error
+ SetOptionValue(CommandInterpreter &interpreter,
+ uint32_t option_idx,
+ const char *option_value) override;
- virtual void
- OptionParsingStarting (CommandInterpreter &interpreter);
+ void
+ OptionParsingStarting(CommandInterpreter &interpreter) override;
bool
AnyOptionWasSet () const
{
- return show_types == true ||
- no_summary_depth != 0 ||
- show_location == true ||
- flat_output == true ||
- use_objc == true ||
+ return show_types ||
+ no_summary_depth != 0 ||
+ show_location ||
+ flat_output ||
+ use_objc ||
max_depth != UINT32_MAX ||
ptr_depth != 0 ||
- use_synth == false ||
- be_raw == true ||
- ignore_cap == true ||
- run_validator == true;
+ !use_synth ||
+ be_raw ||
+ ignore_cap ||
+ run_validator;
}
DumpValueObjectOptions
} // namespace lldb_private
-#endif // liblldb_OptionGroupValueObjectDisplay_h_
+#endif // liblldb_OptionGroupValueObjectDisplay_h_
class OptionGroupVariable : public OptionGroup
{
public:
-
OptionGroupVariable (bool show_frame_options);
- virtual
- ~OptionGroupVariable ();
-
- virtual uint32_t
- GetNumDefinitions ();
+ ~OptionGroupVariable() override;
+
+ uint32_t
+ GetNumDefinitions() override;
- virtual const OptionDefinition*
- GetDefinitions ();
+ const OptionDefinition*
+ GetDefinitions() override;
- virtual Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg);
+ Error
+ SetOptionValue(CommandInterpreter &interpreter,
+ uint32_t option_idx,
+ const char *option_arg) override;
- virtual void
- OptionParsingStarting (CommandInterpreter &interpreter);
+ void
+ OptionParsingStarting(CommandInterpreter &interpreter) override;
bool include_frame_options:1,
show_args:1, // Frame option only (include_frame_options == true)
} // namespace lldb_private
-#endif // liblldb_OptionGroupVariable_h_
+#endif // liblldb_OptionGroupVariable_h_
class OptionGroupWatchpoint : public OptionGroup
{
public:
-
+ OptionGroupWatchpoint ();
+
+ ~OptionGroupWatchpoint() override;
+
static bool
IsWatchSizeSupported(uint32_t watch_size);
- OptionGroupWatchpoint ();
-
- virtual
- ~OptionGroupWatchpoint ();
-
- virtual uint32_t
- GetNumDefinitions ();
+ uint32_t
+ GetNumDefinitions() override;
- virtual const OptionDefinition*
- GetDefinitions ();
+ const OptionDefinition*
+ GetDefinitions() override;
- virtual Error
- SetOptionValue (CommandInterpreter &interpreter,
- uint32_t option_idx,
- const char *option_arg);
+ Error
+ SetOptionValue(CommandInterpreter &interpreter,
+ uint32_t option_idx,
+ const char *option_arg) override;
- virtual void
- OptionParsingStarting (CommandInterpreter &interpreter);
+ void
+ OptionParsingStarting(CommandInterpreter &interpreter) override;
// Note:
// eWatchRead == LLDB_WATCH_TYPE_READ; and
} // namespace lldb_private
-#endif // liblldb_OptionGroupWatchpoint_h_
+#endif // liblldb_OptionGroupWatchpoint_h_
#define liblldb_Options_h_
// C Includes
-
// C++ Includes
#include <set>
#include <vector>
return isprint(ch);
}
-
//----------------------------------------------------------------------
/// @class Options Options.h "lldb/Interpreter/Options.h"
/// @brief A command line option parsing protocol class.
class Options
{
public:
-
Options (CommandInterpreter &interpreter);
virtual
// Verify that the options given are in the options table and can
// be used together, but there may be some required options that are
// missing (used to verify options that get folded into command aliases).
-
bool
VerifyPartialOptions (CommandReturnObject &result);
class OptionGroup
{
public:
- OptionGroup ()
- {
- }
-
+ OptionGroup() = default;
+
virtual
- ~OptionGroup ()
- {
- }
-
+ ~OptionGroup() = default;
+
virtual uint32_t
GetNumDefinitions () = 0;
class OptionGroupOptions : public Options
{
public:
-
OptionGroupOptions (CommandInterpreter &interpreter) :
Options (interpreter),
m_option_defs (),
{
}
- virtual
- ~OptionGroupOptions ()
- {
- }
-
-
+ ~OptionGroupOptions() override = default;
+
//----------------------------------------------------------------------
/// Append options from a OptionGroup class.
///
return m_did_finalize;
}
- virtual Error
- SetOptionValue (uint32_t option_idx,
- const char *option_arg);
+ Error
+ SetOptionValue(uint32_t option_idx,
+ const char *option_arg) override;
- virtual void
- OptionParsingStarting ();
+ void
+ OptionParsingStarting() override;
- virtual Error
- OptionParsingFinished ();
+ Error
+ OptionParsingFinished() override;
const OptionDefinition*
- GetDefinitions ()
+ GetDefinitions() override
{
assert (m_did_finalize);
return &m_option_defs[0];
OptionInfos m_option_infos;
bool m_did_finalize;
};
-
} // namespace lldb_private
-#endif // liblldb_Options_h_
+#endif // liblldb_Options_h_
#ifndef liblldb_ScriptInterpreter_h_
#define liblldb_ScriptInterpreter_h_
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
#include "lldb/lldb-private.h"
#include "lldb/Core/Broadcaster.h"
#include "lldb/Utility/PseudoTerminal.h"
-
namespace lldb_private {
class ScriptInterpreterLocker
{
public:
- ScriptInterpreterLocker ()
- {
- }
+ ScriptInterpreterLocker() = default;
- virtual ~ScriptInterpreterLocker ()
- {
- }
+ virtual ~ScriptInterpreterLocker() = default;
+
private:
DISALLOW_COPY_AND_ASSIGN (ScriptInterpreterLocker);
};
class ScriptInterpreter : public PluginInterface
{
public:
-
typedef enum
{
eScriptReturnTypeCharPtr,
ScriptInterpreter (CommandInterpreter &interpreter, lldb::ScriptLanguage script_lang);
- virtual ~ScriptInterpreter ();
+ ~ScriptInterpreter() override;
struct ExecuteScriptOptions
{
SetBreakpointCommandCallbackFunction (BreakpointOptions *bp_options,
const char *function_name)
{
- return;
}
/// Set a one-liner as the callback for the watchpoint.
SetWatchpointCommandCallback (WatchpointOptions *wp_options,
const char *oneliner)
{
- return;
}
virtual bool
virtual bool
GetDocumentationForItem (const char* item, std::string& dest)
{
- dest.clear();
+ dest.clear();
return false;
}
int
GetMasterFileDescriptor ();
- CommandInterpreter &
- GetCommandInterpreter ();
+ CommandInterpreter &
+ GetCommandInterpreter();
static std::string
LanguageToString (lldb::ScriptLanguage language);
} // namespace lldb_private
-#endif // #ifndef liblldb_ScriptInterpreter_h_
+#endif // liblldb_ScriptInterpreter_h_