lldb/source/API/SBEvent.cpp

   1 //===-- SBEvent.cpp -------------------------------------------------------===//
   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 "lldb/API/SBBroadcaster.h"
  11 #include "lldb/API/SBStream.h"
  12 #include "lldb/Utility/Instrumentation.h"
  13
  14 #include "lldb/Breakpoint/Breakpoint.h"
  15 #include "lldb/Interpreter/CommandInterpreter.h"
  16 #include "lldb/Target/Process.h"
  17 #include "lldb/Utility/ConstString.h"
  18 #include "lldb/Utility/Event.h"
  19 #include "lldb/Utility/Stream.h"
  20
  21 using namespace lldb;
  22 using namespace lldb_private;
  23
  24 SBEvent::SBEvent() { LLDB_INSTRUMENT_VA(this); }
  25
  26 SBEvent::SBEvent(uint32_t event_type, const char *cstr, uint32_t cstr_len)
  27     : m_event_sp(new Event(event_type, new EventDataBytes(cstr, cstr_len))),
  28       m_opaque_ptr(m_event_sp.get()) {
  29   LLDB_INSTRUMENT_VA(this, event_type, cstr, cstr_len);
  30 }
  31
  32 SBEvent::SBEvent(EventSP &event_sp)
  33     : m_event_sp(event_sp), m_opaque_ptr(event_sp.get()) {
  34   LLDB_INSTRUMENT_VA(this, event_sp);
  35 }
  36
  37 SBEvent::SBEvent(Event *event_ptr) : m_opaque_ptr(event_ptr) {
  38   LLDB_INSTRUMENT_VA(this, event_ptr);
  39 }
  40
  41 SBEvent::SBEvent(const SBEvent &rhs)
  42     : m_event_sp(rhs.m_event_sp), m_opaque_ptr(rhs.m_opaque_ptr) {
  43   LLDB_INSTRUMENT_VA(this, rhs);
  44 }
  45
  46 const SBEvent &SBEvent::operator=(const SBEvent &rhs) {
  47   LLDB_INSTRUMENT_VA(this, rhs);
  48
  49   if (this != &rhs) {
  50     m_event_sp = rhs.m_event_sp;
  51     m_opaque_ptr = rhs.m_opaque_ptr;
  52   }
  53   return *this;
  54 }
  55
  56 SBEvent::~SBEvent() = default;
  57
  58 const char *SBEvent::GetDataFlavor() {
  59   LLDB_INSTRUMENT_VA(this);
  60
  61   Event *lldb_event = get();
  62   if (lldb_event) {
  63     EventData *event_data = lldb_event->GetData();
  64     if (event_data)
  65       return ConstString(lldb_event->GetData()->GetFlavor()).GetCString();
  66   }
  67   return nullptr;
  68 }
  69
  70 uint32_t SBEvent::GetType() const {
  71   LLDB_INSTRUMENT_VA(this);
  72
  73   const Event *lldb_event = get();
  74   uint32_t event_type = 0;
  75   if (lldb_event)
  76     event_type = lldb_event->GetType();
  77
  78
  79   return event_type;
  80 }
  81
  82 SBBroadcaster SBEvent::GetBroadcaster() const {
  83   LLDB_INSTRUMENT_VA(this);
  84
  85   SBBroadcaster broadcaster;
  86   const Event *lldb_event = get();
  87   if (lldb_event)
  88     broadcaster.reset(lldb_event->GetBroadcaster(), false);
  89   return broadcaster;
  90 }
  91
  92 const char *SBEvent::GetBroadcasterClass() const {
  93   LLDB_INSTRUMENT_VA(this);
  94
  95   const Event *lldb_event = get();
  96   if (lldb_event)
  97     return lldb_event->GetBroadcaster()->GetBroadcasterClass().AsCString();
  98   else
  99     return "unknown class";
 100 }
 101
 102 bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) {
 103   LLDB_INSTRUMENT_VA(this, broadcaster);
 104
 105   if (broadcaster)
 106     return BroadcasterMatchesRef(*broadcaster);
 107   return false;
 108 }
 109
 110 bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) {
 111   LLDB_INSTRUMENT_VA(this, broadcaster);
 112
 113   Event *lldb_event = get();
 114   bool success = false;
 115   if (lldb_event)
 116     success = lldb_event->BroadcasterIs(broadcaster.get());
 117
 118
 119   return success;
 120 }
 121
 122 void SBEvent::Clear() {
 123   LLDB_INSTRUMENT_VA(this);
 124
 125   Event *lldb_event = get();
 126   if (lldb_event)
 127     lldb_event->Clear();
 128 }
 129
 130 EventSP &SBEvent::GetSP() const { return m_event_sp; }
 131
 132 Event *SBEvent::get() const {
 133   // There is a dangerous accessor call GetSharedPtr which can be used, so if
 134   // we have anything valid in m_event_sp, we must use that since if it gets
 135   // used by a function that puts something in there, then it won't update
 136   // m_opaque_ptr...
 137   if (m_event_sp)
 138     m_opaque_ptr = m_event_sp.get();
 139
 140   return m_opaque_ptr;
 141 }
 142
 143 void SBEvent::reset(EventSP &event_sp) {
 144   m_event_sp = event_sp;
 145   m_opaque_ptr = m_event_sp.get();
 146 }
 147
 148 void SBEvent::reset(Event *event_ptr) {
 149   m_opaque_ptr = event_ptr;
 150   m_event_sp.reset();
 151 }
 152
 153 bool SBEvent::IsValid() const {
 154   LLDB_INSTRUMENT_VA(this);
 155   return this->operator bool();
 156 }
 157 SBEvent::operator bool() const {
 158   LLDB_INSTRUMENT_VA(this);
 159
 160   // Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor.
 161   // See comments in SBEvent::get()....
 162   return SBEvent::get() != nullptr;
 163 }
 164
 165 const char *SBEvent::GetCStringFromEvent(const SBEvent &event) {
 166   LLDB_INSTRUMENT_VA(event);
 167
 168   return ConstString(static_cast<const char *>(
 169                          EventDataBytes::GetBytesFromEvent(event.get())))
 170       .GetCString();
 171 }
 172
 173 bool SBEvent::GetDescription(SBStream &description) {
 174   LLDB_INSTRUMENT_VA(this, description);
 175
 176   Stream &strm = description.ref();
 177
 178   if (get()) {
 179     m_opaque_ptr->Dump(&strm);
 180   } else
 181     strm.PutCString("No value");
 182
 183   return true;
 184 }
 185
 186 bool SBEvent::GetDescription(SBStream &description) const {
 187   LLDB_INSTRUMENT_VA(this, description);
 188
 189   Stream &strm = description.ref();
 190
 191   if (get()) {
 192     m_opaque_ptr->Dump(&strm);
 193   } else
 194     strm.PutCString("No value");
 195
 196   return true;
 197 }