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

source code of lldb/source/API/SBEvent.cpp