1 files changed, 199 insertions, 0 deletions
diff --git a/contrib/llvm-project/lldb/source/API/SBEvent.cpp b/contrib/llvm-project/lldb/source/API/SBEvent.cpp
new file mode 100644
index 000000000000..aa9c0ff097d4
--- /dev/null
+++ b/contrib/llvm-project/lldb/source/API/SBEvent.cpp
@@ -0,0 +1,199 @@
+//===-- SBEvent.cpp -------------------------------------------------------===//
+//
+// 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 "lldb/API/SBBroadcaster.h"
+#include "lldb/API/SBStream.h"
+#include "lldb/Utility/Instrumentation.h"
+
+#include "lldb/Breakpoint/Breakpoint.h"
+#include "lldb/Interpreter/CommandInterpreter.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Utility/ConstString.h"
+#include "lldb/Utility/Event.h"
+#include "lldb/Utility/Stream.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+SBEvent::SBEvent() { LLDB_INSTRUMENT_VA(this); }
+
+SBEvent::SBEvent(uint32_t event_type, const char *cstr, uint32_t cstr_len)
+    : m_event_sp(new Event(
+          event_type, new EventDataBytes(llvm::StringRef(cstr, cstr_len)))),
+      m_opaque_ptr(m_event_sp.get()) {
+  LLDB_INSTRUMENT_VA(this, event_type, cstr, cstr_len);
+}
+
+SBEvent::SBEvent(EventSP &event_sp)
+    : m_event_sp(event_sp), m_opaque_ptr(event_sp.get()) {
+  LLDB_INSTRUMENT_VA(this, event_sp);
+}
+
+SBEvent::SBEvent(Event *event_ptr) : m_opaque_ptr(event_ptr) {
+  LLDB_INSTRUMENT_VA(this, event_ptr);
+}
+
+SBEvent::SBEvent(const SBEvent &rhs)
+    : m_event_sp(rhs.m_event_sp), m_opaque_ptr(rhs.m_opaque_ptr) {
+  LLDB_INSTRUMENT_VA(this, rhs);
+}
+
+const SBEvent &SBEvent::operator=(const SBEvent &rhs) {
+  LLDB_INSTRUMENT_VA(this, rhs);
+
+  if (this != &rhs) {
+    m_event_sp = rhs.m_event_sp;
+    m_opaque_ptr = rhs.m_opaque_ptr;
+  }
+  return *this;
+}
+
+SBEvent::~SBEvent() = default;
+
+const char *SBEvent::GetDataFlavor() {
+  LLDB_INSTRUMENT_VA(this);
+
+  Event *lldb_event = get();
+  if (lldb_event) {
+    EventData *event_data = lldb_event->GetData();
+    if (event_data)
+      return ConstString(lldb_event->GetData()->GetFlavor()).GetCString();
+  }
+  return nullptr;
+}
+
+uint32_t SBEvent::GetType() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  const Event *lldb_event = get();
+  uint32_t event_type = 0;
+  if (lldb_event)
+    event_type = lldb_event->GetType();
+
+
+  return event_type;
+}
+
+SBBroadcaster SBEvent::GetBroadcaster() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  SBBroadcaster broadcaster;
+  const Event *lldb_event = get();
+  if (lldb_event)
+    broadcaster.reset(lldb_event->GetBroadcaster(), false);
+  return broadcaster;
+}
+
+const char *SBEvent::GetBroadcasterClass() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  const Event *lldb_event = get();
+  if (lldb_event)
+    return ConstString(lldb_event->GetBroadcaster()->GetBroadcasterClass())
+        .AsCString();
+  else
+    return "unknown class";
+}
+
+bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) {
+  LLDB_INSTRUMENT_VA(this, broadcaster);
+
+  if (broadcaster)
+    return BroadcasterMatchesRef(*broadcaster);
+  return false;
+}
+
+bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) {
+  LLDB_INSTRUMENT_VA(this, broadcaster);
+
+  Event *lldb_event = get();
+  bool success = false;
+  if (lldb_event)
+    success = lldb_event->BroadcasterIs(broadcaster.get());
+
+
+  return success;
+}
+
+void SBEvent::Clear() {
+  LLDB_INSTRUMENT_VA(this);
+
+  Event *lldb_event = get();
+  if (lldb_event)
+    lldb_event->Clear();
+}
+
+EventSP &SBEvent::GetSP() const { return m_event_sp; }
+
+Event *SBEvent::get() const {
+  // There is a dangerous accessor call GetSharedPtr which can be used, so if
+  // we have anything valid in m_event_sp, we must use that since if it gets
+  // used by a function that puts something in there, then it won't update
+  // m_opaque_ptr...
+  if (m_event_sp)
+    m_opaque_ptr = m_event_sp.get();
+
+  return m_opaque_ptr;
+}
+
+void SBEvent::reset(EventSP &event_sp) {
+  m_event_sp = event_sp;
+  m_opaque_ptr = m_event_sp.get();
+}
+
+void SBEvent::reset(Event *event_ptr) {
+  m_opaque_ptr = event_ptr;
+  m_event_sp.reset();
+}
+
+bool SBEvent::IsValid() const {
+  LLDB_INSTRUMENT_VA(this);
+  return this->operator bool();
+}
+SBEvent::operator bool() const {
+  LLDB_INSTRUMENT_VA(this);
+
+  // Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor.
+  // See comments in SBEvent::get()....
+  return SBEvent::get() != nullptr;
+}
+
+const char *SBEvent::GetCStringFromEvent(const SBEvent &event) {
+  LLDB_INSTRUMENT_VA(event);
+
+  return ConstString(static_cast<const char *>(
+                         EventDataBytes::GetBytesFromEvent(event.get())))
+      .GetCString();
+}
+
+bool SBEvent::GetDescription(SBStream &description) {
+  LLDB_INSTRUMENT_VA(this, description);
+
+  Stream &strm = description.ref();
+
+  if (get()) {
+    m_opaque_ptr->Dump(&strm);
+  } else
+    strm.PutCString("No value");
+
+  return true;
+}
+
+bool SBEvent::GetDescription(SBStream &description) const {
+  LLDB_INSTRUMENT_VA(this, description);
+
+  Stream &strm = description.ref();
+
+  if (get()) {
+    m_opaque_ptr->Dump(&strm);
+  } else
+    strm.PutCString("No value");
+
+  return true;
+}