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
21using namespace lldb;
22using namespace lldb_private;
23
24SBEvent::SBEvent() { LLDB_INSTRUMENT_VA(this); }
25
26SBEvent::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
32SBEvent::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
37SBEvent::SBEvent(Event *event_ptr) : m_opaque_ptr(event_ptr) {
38  LLDB_INSTRUMENT_VA(this, event_ptr);
39}
40
41SBEvent::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
46const 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
56SBEvent::~SBEvent() = default;
57
58const 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
70uint32_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
82SBBroadcaster 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
92const 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
102bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) {
103  LLDB_INSTRUMENT_VA(this, broadcaster);
104
105  if (broadcaster)
106    return BroadcasterMatchesRef(*broadcaster);
107  return false;
108}
109
110bool 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
122void SBEvent::Clear() {
123  LLDB_INSTRUMENT_VA(this);
124
125  Event *lldb_event = get();
126  if (lldb_event)
127    lldb_event->Clear();
128}
129
130EventSP &SBEvent::GetSP() const { return m_event_sp; }
131
132Event *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
143void SBEvent::reset(EventSP &event_sp) {
144  m_event_sp = event_sp;
145  m_opaque_ptr = m_event_sp.get();
146}
147
148void SBEvent::reset(Event *event_ptr) {
149  m_opaque_ptr = event_ptr;
150  m_event_sp.reset();
151}
152
153bool SBEvent::IsValid() const {
154  LLDB_INSTRUMENT_VA(this);
155  return this->operator bool();
156}
157SBEvent::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
165const 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
173bool 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
186bool 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}
198