intel/llvm
1
0
Fork 0
mirror of https://github.com/intel/llvm.git synced 2026-01-26 03:56:16 +08:00
Code Issues Packages Projects Releases Wiki Activity

[lldb/API] Move SBCommandInterpreterRunOption in its own header. (NFC)

Browse Source 
Currently, `SBCommandInterpreterRunOptions` is defined in
`SBCommandInterpreter.h`. Given that the options are always passed by
reference, a forward declaration is sufficient.

That's not the case for `SBCommandInterpreterRunResults`, which we need
for a new overload for `RunCommandInterpreter` and that returns this new
class by value. We can't include `SBCommandInterpreter.h` because
`SBCommandInterpreter::GetDebugger()` returns SBDebugger by value and
therefore needs a full definition.

This patch moves the definition of `SBCommandInterpreterRunOptions` into
a new header. In a later patch,  `SBCommandInterpreterRunResults` will
be defined in there as well, solving the aforementioned problem.

Differential revision: https://reviews.llvm.org/D79115
This commit is contained in:
Jonas Devlieghere
2020-04-30 13:28:42 -07:00
parent b5be1c5419
commit 4b35403942
15 changed files with 727 additions and 303 deletions
Download Patch File Download Diff File Expand all files Collapse all files

187
lldb/source/API/SBCommandInterpreter.cpp
View File

@@ -17,6 +17,7 @@
#include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBCommandInterpreter.h"
#include "lldb/API/SBCommandInterpreterRunOptions.h"
#include "lldb/API/SBCommandReturnObject.h"
#include "lldb/API/SBEvent.h"
#include "lldb/API/SBExecutionContext.h"
@@ -31,151 +32,6 @@
using namespace lldb;
using namespace lldb_private;
SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions() {
LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBCommandInterpreterRunOptions);
m_opaque_up.reset(new CommandInterpreterRunOptions());
}
SBCommandInterpreterRunOptions::~SBCommandInterpreterRunOptions() = default;
bool SBCommandInterpreterRunOptions::GetStopOnContinue() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetStopOnContinue);
return m_opaque_up->GetStopOnContinue();
}
void SBCommandInterpreterRunOptions::SetStopOnContinue(bool stop_on_continue) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnContinue,
(bool), stop_on_continue);
m_opaque_up->SetStopOnContinue(stop_on_continue);
}
bool SBCommandInterpreterRunOptions::GetStopOnError() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetStopOnError);
return m_opaque_up->GetStopOnError();
}
void SBCommandInterpreterRunOptions::SetStopOnError(bool stop_on_error) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
(bool), stop_on_error);
m_opaque_up->SetStopOnError(stop_on_error);
}
bool SBCommandInterpreterRunOptions::GetStopOnCrash() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetStopOnCrash);
return m_opaque_up->GetStopOnCrash();
}
void SBCommandInterpreterRunOptions::SetStopOnCrash(bool stop_on_crash) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
(bool), stop_on_crash);
m_opaque_up->SetStopOnCrash(stop_on_crash);
}
bool SBCommandInterpreterRunOptions::GetEchoCommands() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetEchoCommands);
return m_opaque_up->GetEchoCommands();
}
void SBCommandInterpreterRunOptions::SetEchoCommands(bool echo_commands) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
(bool), echo_commands);
m_opaque_up->SetEchoCommands(echo_commands);
}
bool SBCommandInterpreterRunOptions::GetEchoCommentCommands() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetEchoCommentCommands);
return m_opaque_up->GetEchoCommentCommands();
}
void SBCommandInterpreterRunOptions::SetEchoCommentCommands(bool echo) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions,
SetEchoCommentCommands, (bool), echo);
m_opaque_up->SetEchoCommentCommands(echo);
}
bool SBCommandInterpreterRunOptions::GetPrintResults() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetPrintResults);
return m_opaque_up->GetPrintResults();
}
void SBCommandInterpreterRunOptions::SetPrintResults(bool print_results) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
(bool), print_results);
m_opaque_up->SetPrintResults(print_results);
}
bool SBCommandInterpreterRunOptions::GetAddToHistory() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetAddToHistory);
return m_opaque_up->GetAddToHistory();
}
void SBCommandInterpreterRunOptions::SetAddToHistory(bool add_to_history) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
(bool), add_to_history);
m_opaque_up->SetAddToHistory(add_to_history);
}
bool SBCommandInterpreterRunOptions::GetAutoHandleEvents() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetAutoHandleEvents);
return m_opaque_up->GetAutoHandleEvents();
}
void SBCommandInterpreterRunOptions::SetAutoHandleEvents(
bool auto_handle_events) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetAutoHandleEvents,
(bool), auto_handle_events);
m_opaque_up->SetAutoHandleEvents(auto_handle_events);
}
bool SBCommandInterpreterRunOptions::GetSpawnThread() const {
LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBCommandInterpreterRunOptions,
GetSpawnThread);
return m_opaque_up->GetSpawnThread();
}
void SBCommandInterpreterRunOptions::SetSpawnThread(bool spawn_thread) {
LLDB_RECORD_METHOD(void, SBCommandInterpreterRunOptions, SetSpawnThread,
(bool), spawn_thread);
m_opaque_up->SetSpawnThread(spawn_thread);
}
lldb_private::CommandInterpreterRunOptions *
SBCommandInterpreterRunOptions::get() const {
return m_opaque_up.get();
}
lldb_private::CommandInterpreterRunOptions &
SBCommandInterpreterRunOptions::ref() const {
return *m_opaque_up;
}
class CommandPluginInterfaceImplementation : public CommandObjectParsed {
public:
CommandPluginInterfaceImplementation(CommandInterpreter &interpreter,
@@ -890,45 +746,7 @@ void SBCommand::SetFlags(uint32_t flags) {
namespace lldb_private {
namespace repro {
template <>
void RegisterMethods<SBCommandInterpreterRunOptions>(Registry &R) {
LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreterRunOptions, ());
LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
GetStopOnContinue, ());
LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
SetStopOnContinue, (bool));
LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
GetStopOnError, ());
LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnError,
(bool));
LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
GetStopOnCrash, ());
LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetStopOnCrash,
(bool));
LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
GetEchoCommands, ());
LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetEchoCommands,
(bool));
LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
GetEchoCommentCommands, ());
LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
SetEchoCommentCommands, (bool));
LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
GetPrintResults, ());
LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetPrintResults,
(bool));
LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
GetAddToHistory, ());
LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetAddToHistory,
(bool));
LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
GetAutoHandleEvents, ());
LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions,
SetAutoHandleEvents, (bool));
LLDB_REGISTER_METHOD_CONST(bool, SBCommandInterpreterRunOptions,
GetSpawnThread, ());
LLDB_REGISTER_METHOD(void, SBCommandInterpreterRunOptions, SetSpawnThread,
(bool));
template <> void RegisterMethods<SBCommandInterpreter>(Registry &R) {
LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
(lldb_private::CommandInterpreter *));
LLDB_REGISTER_CONSTRUCTOR(SBCommandInterpreter,
@@ -1037,6 +855,5 @@ void RegisterMethods<SBCommandInterpreterRunOptions>(Registry &R) {
LLDB_REGISTER_METHOD(uint32_t, SBCommand, GetFlags, ());
LLDB_REGISTER_METHOD(void, SBCommand, SetFlags, (uint32_t));
}
}
}