summaryrefslogtreecommitdiff
path: root/source/API/SBEvent.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'source/API/SBEvent.cpp')
-rw-r--r--source/API/SBEvent.cpp127
1 files changed, 91 insertions, 36 deletions
diff --git a/source/API/SBEvent.cpp b/source/API/SBEvent.cpp
index 0556f50f6544..75ca2830df9f 100644
--- a/source/API/SBEvent.cpp
+++ b/source/API/SBEvent.cpp
@@ -1,13 +1,13 @@
//===-- SBEvent.cpp ---------------------------------------------*- C++ -*-===//
//
-// The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
#include "lldb/API/SBEvent.h"
+#include "SBReproducerPrivate.h"
#include "lldb/API/SBBroadcaster.h"
#include "lldb/API/SBStream.h"
@@ -22,71 +22,83 @@
using namespace lldb;
using namespace lldb_private;
-SBEvent::SBEvent() : m_event_sp(), m_opaque_ptr(NULL) {}
+SBEvent::SBEvent() : m_event_sp(), m_opaque_ptr(nullptr) {
+ LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBEvent);
+}
SBEvent::SBEvent(uint32_t event_type, const char *cstr, uint32_t cstr_len)
: m_event_sp(new Event(event_type, new EventDataBytes(cstr, cstr_len))),
- m_opaque_ptr(m_event_sp.get()) {}
+ m_opaque_ptr(m_event_sp.get()) {
+ LLDB_RECORD_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t),
+ event_type, cstr, cstr_len);
+}
SBEvent::SBEvent(EventSP &event_sp)
- : m_event_sp(event_sp), m_opaque_ptr(event_sp.get()) {}
+ : m_event_sp(event_sp), m_opaque_ptr(event_sp.get()) {
+ LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb::EventSP &), event_sp);
+}
-SBEvent::SBEvent(Event *event_ptr) : m_event_sp(), m_opaque_ptr(event_ptr) {}
+SBEvent::SBEvent(Event *event_ptr) : m_event_sp(), m_opaque_ptr(event_ptr) {
+ LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb_private::Event *), event_ptr);
+}
SBEvent::SBEvent(const SBEvent &rhs)
- : m_event_sp(rhs.m_event_sp), m_opaque_ptr(rhs.m_opaque_ptr) {}
+ : m_event_sp(rhs.m_event_sp), m_opaque_ptr(rhs.m_opaque_ptr) {
+ LLDB_RECORD_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &), rhs);
+}
const SBEvent &SBEvent::operator=(const SBEvent &rhs) {
+ LLDB_RECORD_METHOD(const lldb::SBEvent &,
+ SBEvent, operator=,(const lldb::SBEvent &), rhs);
+
if (this != &rhs) {
m_event_sp = rhs.m_event_sp;
m_opaque_ptr = rhs.m_opaque_ptr;
}
- return *this;
+ return LLDB_RECORD_RESULT(*this);
}
SBEvent::~SBEvent() {}
const char *SBEvent::GetDataFlavor() {
+ LLDB_RECORD_METHOD_NO_ARGS(const char *, SBEvent, GetDataFlavor);
+
Event *lldb_event = get();
if (lldb_event) {
EventData *event_data = lldb_event->GetData();
if (event_data)
return lldb_event->GetData()->GetFlavor().AsCString();
}
- return NULL;
+ return nullptr;
}
uint32_t SBEvent::GetType() const {
- Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBEvent, GetType);
+
const Event *lldb_event = get();
uint32_t event_type = 0;
if (lldb_event)
event_type = lldb_event->GetType();
- if (log) {
- StreamString sstr;
- if (lldb_event && lldb_event->GetBroadcaster() &&
- lldb_event->GetBroadcaster()->GetEventNames(sstr, event_type, true))
- log->Printf("SBEvent(%p)::GetType () => 0x%8.8x (%s)",
- static_cast<void *>(get()), event_type, sstr.GetData());
- else
- log->Printf("SBEvent(%p)::GetType () => 0x%8.8x",
- static_cast<void *>(get()), event_type);
- }
return event_type;
}
SBBroadcaster SBEvent::GetBroadcaster() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBEvent,
+ GetBroadcaster);
+
SBBroadcaster broadcaster;
const Event *lldb_event = get();
if (lldb_event)
broadcaster.reset(lldb_event->GetBroadcaster(), false);
- return broadcaster;
+ return LLDB_RECORD_RESULT(broadcaster);
}
const char *SBEvent::GetBroadcasterClass() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBEvent, GetBroadcasterClass);
+
const Event *lldb_event = get();
if (lldb_event)
return lldb_event->GetBroadcaster()->GetBroadcasterClass().AsCString();
@@ -95,28 +107,30 @@ const char *SBEvent::GetBroadcasterClass() const {
}
bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) {
+ LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesPtr,
+ (const lldb::SBBroadcaster *), broadcaster);
+
if (broadcaster)
return BroadcasterMatchesRef(*broadcaster);
return false;
}
bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) {
+ LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesRef,
+ (const lldb::SBBroadcaster &), broadcaster);
Event *lldb_event = get();
bool success = false;
if (lldb_event)
success = lldb_event->BroadcasterIs(broadcaster.get());
- // For logging, this gets a little chatty so only enable this when verbose
- // logging is on
- Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
- LLDB_LOGV(log, "({0}) (SBBroadcaster({1}): {2}) => {3}", get(),
- broadcaster.get(), broadcaster.GetName(), success);
return success;
}
void SBEvent::Clear() {
+ LLDB_RECORD_METHOD_NO_ARGS(void, SBEvent, Clear);
+
Event *lldb_event = get();
if (lldb_event)
lldb_event->Clear();
@@ -146,25 +160,29 @@ void SBEvent::reset(Event *event_ptr) {
}
bool SBEvent::IsValid() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, IsValid);
+ return this->operator bool();
+}
+SBEvent::operator bool() const {
+ LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, operator bool);
+
// Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor.
// See comments in SBEvent::get()....
- return SBEvent::get() != NULL;
+ return SBEvent::get() != nullptr;
}
const char *SBEvent::GetCStringFromEvent(const SBEvent &event) {
- Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
-
- if (log)
- log->Printf("SBEvent(%p)::GetCStringFromEvent () => \"%s\"",
- static_cast<void *>(event.get()),
- reinterpret_cast<const char *>(
- EventDataBytes::GetBytesFromEvent(event.get())));
+ LLDB_RECORD_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,
+ (const lldb::SBEvent &), event);
return reinterpret_cast<const char *>(
EventDataBytes::GetBytesFromEvent(event.get()));
}
bool SBEvent::GetDescription(SBStream &description) {
+ LLDB_RECORD_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &),
+ description);
+
Stream &strm = description.ref();
if (get()) {
@@ -176,6 +194,9 @@ bool SBEvent::GetDescription(SBStream &description) {
}
bool SBEvent::GetDescription(SBStream &description) const {
+ LLDB_RECORD_METHOD_CONST(bool, SBEvent, GetDescription, (lldb::SBStream &),
+ description);
+
Stream &strm = description.ref();
if (get()) {
@@ -185,3 +206,37 @@ bool SBEvent::GetDescription(SBStream &description) const {
return true;
}
+
+namespace lldb_private {
+namespace repro {
+
+template <>
+void RegisterMethods<SBEvent>(Registry &R) {
+ LLDB_REGISTER_CONSTRUCTOR(SBEvent, ());
+ LLDB_REGISTER_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t));
+ LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb::EventSP &));
+ LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb_private::Event *));
+ LLDB_REGISTER_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(const lldb::SBEvent &,
+ SBEvent, operator=,(const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(const char *, SBEvent, GetDataFlavor, ());
+ LLDB_REGISTER_METHOD_CONST(uint32_t, SBEvent, GetType, ());
+ LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBEvent, GetBroadcaster,
+ ());
+ LLDB_REGISTER_METHOD_CONST(const char *, SBEvent, GetBroadcasterClass, ());
+ LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesPtr,
+ (const lldb::SBBroadcaster *));
+ LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesRef,
+ (const lldb::SBBroadcaster &));
+ LLDB_REGISTER_METHOD(void, SBEvent, Clear, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBEvent, IsValid, ());
+ LLDB_REGISTER_METHOD_CONST(bool, SBEvent, operator bool, ());
+ LLDB_REGISTER_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,
+ (const lldb::SBEvent &));
+ LLDB_REGISTER_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &));
+ LLDB_REGISTER_METHOD_CONST(bool, SBEvent, GetDescription,
+ (lldb::SBStream &));
+}
+
+}
+}