lldb/source/API/SBEvent.cpp

   1 //===-- SBEvent.cpp ---------------------------------------------*- C++ -*-===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/API/SBEvent.h"
  10 #include "SBReproducerPrivate.h"
  11 #include "lldb/API/SBBroadcaster.h"
  12 #include "lldb/API/SBStream.h"
  13
  14 #include "lldb/Breakpoint/Breakpoint.h"
  15 #include "lldb/Core/StreamFile.h"
  16 #include "lldb/Interpreter/CommandInterpreter.h"
  17 #include "lldb/Target/Process.h"
  18 #include "lldb/Utility/ConstString.h"
  19 #include "lldb/Utility/Event.h"
  20 #include "lldb/Utility/Stream.h"
  21
  22 using namespace lldb;
  23 using namespace lldb_private;
  24
  25 SBEvent::SBEvent() : m_event_sp(), m_opaque_ptr(nullptr) {
  26   LLDB_RECORD_CONSTRUCTOR_NO_ARGS(SBEvent);
  27 }
  28
  29 SBEvent::SBEvent(uint32_t event_type, const char *cstr, uint32_t cstr_len)
  30     : m_event_sp(new Event(event_type, new EventDataBytes(cstr, cstr_len))),
  31       m_opaque_ptr(m_event_sp.get()) {
  32   LLDB_RECORD_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t),
  33                           event_type, cstr, cstr_len);
  34 }
  35
  36 SBEvent::SBEvent(EventSP &event_sp)
  37     : m_event_sp(event_sp), m_opaque_ptr(event_sp.get()) {
  38   LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb::EventSP &), event_sp);
  39 }
  40
  41 SBEvent::SBEvent(Event *event_ptr) : m_event_sp(), m_opaque_ptr(event_ptr) {
  42   LLDB_RECORD_CONSTRUCTOR(SBEvent, (lldb_private::Event *), event_ptr);
  43 }
  44
  45 SBEvent::SBEvent(const SBEvent &rhs)
  46     : m_event_sp(rhs.m_event_sp), m_opaque_ptr(rhs.m_opaque_ptr) {
  47   LLDB_RECORD_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &), rhs);
  48 }
  49
  50 const SBEvent &SBEvent::operator=(const SBEvent &rhs) {
  51   LLDB_RECORD_METHOD(const lldb::SBEvent &,
  52                      SBEvent, operator=,(const lldb::SBEvent &), rhs);
  53
  54   if (this != &rhs) {
  55     m_event_sp = rhs.m_event_sp;
  56     m_opaque_ptr = rhs.m_opaque_ptr;
  57   }
  58   return LLDB_RECORD_RESULT(*this);
  59 }
  60
  61 SBEvent::~SBEvent() {}
  62
  63 const char *SBEvent::GetDataFlavor() {
  64   LLDB_RECORD_METHOD_NO_ARGS(const char *, SBEvent, GetDataFlavor);
  65
  66   Event *lldb_event = get();
  67   if (lldb_event) {
  68     EventData *event_data = lldb_event->GetData();
  69     if (event_data)
  70       return lldb_event->GetData()->GetFlavor().AsCString();
  71   }
  72   return nullptr;
  73 }
  74
  75 uint32_t SBEvent::GetType() const {
  76   LLDB_RECORD_METHOD_CONST_NO_ARGS(uint32_t, SBEvent, GetType);
  77
  78
  79   const Event *lldb_event = get();
  80   uint32_t event_type = 0;
  81   if (lldb_event)
  82     event_type = lldb_event->GetType();
  83
  84
  85   return event_type;
  86 }
  87
  88 SBBroadcaster SBEvent::GetBroadcaster() const {
  89   LLDB_RECORD_METHOD_CONST_NO_ARGS(lldb::SBBroadcaster, SBEvent,
  90                                    GetBroadcaster);
  91
  92   SBBroadcaster broadcaster;
  93   const Event *lldb_event = get();
  94   if (lldb_event)
  95     broadcaster.reset(lldb_event->GetBroadcaster(), false);
  96   return LLDB_RECORD_RESULT(broadcaster);
  97 }
  98
  99 const char *SBEvent::GetBroadcasterClass() const {
 100   LLDB_RECORD_METHOD_CONST_NO_ARGS(const char *, SBEvent, GetBroadcasterClass);
 101
 102   const Event *lldb_event = get();
 103   if (lldb_event)
 104     return lldb_event->GetBroadcaster()->GetBroadcasterClass().AsCString();
 105   else
 106     return "unknown class";
 107 }
 108
 109 bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) {
 110   LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesPtr,
 111                      (const lldb::SBBroadcaster *), broadcaster);
 112
 113   if (broadcaster)
 114     return BroadcasterMatchesRef(*broadcaster);
 115   return false;
 116 }
 117
 118 bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) {
 119   LLDB_RECORD_METHOD(bool, SBEvent, BroadcasterMatchesRef,
 120                      (const lldb::SBBroadcaster &), broadcaster);
 121
 122   Event *lldb_event = get();
 123   bool success = false;
 124   if (lldb_event)
 125     success = lldb_event->BroadcasterIs(broadcaster.get());
 126
 127
 128   return success;
 129 }
 130
 131 void SBEvent::Clear() {
 132   LLDB_RECORD_METHOD_NO_ARGS(void, SBEvent, Clear);
 133
 134   Event *lldb_event = get();
 135   if (lldb_event)
 136     lldb_event->Clear();
 137 }
 138
 139 EventSP &SBEvent::GetSP() const { return m_event_sp; }
 140
 141 Event *SBEvent::get() const {
 142   // There is a dangerous accessor call GetSharedPtr which can be used, so if
 143   // we have anything valid in m_event_sp, we must use that since if it gets
 144   // used by a function that puts something in there, then it won't update
 145   // m_opaque_ptr...
 146   if (m_event_sp)
 147     m_opaque_ptr = m_event_sp.get();
 148
 149   return m_opaque_ptr;
 150 }
 151
 152 void SBEvent::reset(EventSP &event_sp) {
 153   m_event_sp = event_sp;
 154   m_opaque_ptr = m_event_sp.get();
 155 }
 156
 157 void SBEvent::reset(Event *event_ptr) {
 158   m_opaque_ptr = event_ptr;
 159   m_event_sp.reset();
 160 }
 161
 162 bool SBEvent::IsValid() const {
 163   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, IsValid);
 164   return this->operator bool();
 165 }
 166 SBEvent::operator bool() const {
 167   LLDB_RECORD_METHOD_CONST_NO_ARGS(bool, SBEvent, operator bool);
 168
 169   // Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor.
 170   // See comments in SBEvent::get()....
 171   return SBEvent::get() != nullptr;
 172 }
 173
 174 const char *SBEvent::GetCStringFromEvent(const SBEvent &event) {
 175   LLDB_RECORD_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,
 176                             (const lldb::SBEvent &), event);
 177
 178   return static_cast<const char *>(
 179       EventDataBytes::GetBytesFromEvent(event.get()));
 180 }
 181
 182 bool SBEvent::GetDescription(SBStream &description) {
 183   LLDB_RECORD_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &),
 184                      description);
 185
 186   Stream &strm = description.ref();
 187
 188   if (get()) {
 189     m_opaque_ptr->Dump(&strm);
 190   } else
 191     strm.PutCString("No value");
 192
 193   return true;
 194 }
 195
 196 bool SBEvent::GetDescription(SBStream &description) const {
 197   LLDB_RECORD_METHOD_CONST(bool, SBEvent, GetDescription, (lldb::SBStream &),
 198                            description);
 199
 200   Stream &strm = description.ref();
 201
 202   if (get()) {
 203     m_opaque_ptr->Dump(&strm);
 204   } else
 205     strm.PutCString("No value");
 206
 207   return true;
 208 }
 209
 210 namespace lldb_private {
 211 namespace repro {
 212
 213 template <>
 214 void RegisterMethods<SBEvent>(Registry &R) {
 215   LLDB_REGISTER_CONSTRUCTOR(SBEvent, ());
 216   LLDB_REGISTER_CONSTRUCTOR(SBEvent, (uint32_t, const char *, uint32_t));
 217   LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb::EventSP &));
 218   LLDB_REGISTER_CONSTRUCTOR(SBEvent, (lldb_private::Event *));
 219   LLDB_REGISTER_CONSTRUCTOR(SBEvent, (const lldb::SBEvent &));
 220   LLDB_REGISTER_METHOD(const lldb::SBEvent &,
 221                        SBEvent, operator=,(const lldb::SBEvent &));
 222   LLDB_REGISTER_METHOD(const char *, SBEvent, GetDataFlavor, ());
 223   LLDB_REGISTER_METHOD_CONST(uint32_t, SBEvent, GetType, ());
 224   LLDB_REGISTER_METHOD_CONST(lldb::SBBroadcaster, SBEvent, GetBroadcaster,
 225                              ());
 226   LLDB_REGISTER_METHOD_CONST(const char *, SBEvent, GetBroadcasterClass, ());
 227   LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesPtr,
 228                        (const lldb::SBBroadcaster *));
 229   LLDB_REGISTER_METHOD(bool, SBEvent, BroadcasterMatchesRef,
 230                        (const lldb::SBBroadcaster &));
 231   LLDB_REGISTER_METHOD(void, SBEvent, Clear, ());
 232   LLDB_REGISTER_METHOD_CONST(bool, SBEvent, IsValid, ());
 233   LLDB_REGISTER_METHOD_CONST(bool, SBEvent, operator bool, ());
 234   LLDB_REGISTER_STATIC_METHOD(const char *, SBEvent, GetCStringFromEvent,
 235                               (const lldb::SBEvent &));
 236   LLDB_REGISTER_METHOD(bool, SBEvent, GetDescription, (lldb::SBStream &));
 237   LLDB_REGISTER_METHOD_CONST(bool, SBEvent, GetDescription,
 238                              (lldb::SBStream &));
 239 }
 240
 241 }
 242 }