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
SBEvent()24 SBEvent::SBEvent() { LLDB_INSTRUMENT_VA(this); }
25
SBEvent(uint32_t event_type,const char * cstr,uint32_t cstr_len)26 SBEvent::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
SBEvent(EventSP & event_sp)33 SBEvent::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
SBEvent(Event * event_ptr)38 SBEvent::SBEvent(Event *event_ptr) : m_opaque_ptr(event_ptr) {
39 LLDB_INSTRUMENT_VA(this, event_ptr);
40 }
41
SBEvent(const SBEvent & rhs)42 SBEvent::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
operator =(const SBEvent & rhs)47 const 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
57 SBEvent::~SBEvent() = default;
58
GetDataFlavor()59 const 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
GetType() const71 uint32_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
GetBroadcaster() const83 SBBroadcaster 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(lldb_event->GetBroadcaster(), false);
90 return broadcaster;
91 }
92
GetBroadcasterClass() const93 const char *SBEvent::GetBroadcasterClass() const {
94 LLDB_INSTRUMENT_VA(this);
95
96 const Event *lldb_event = get();
97 if (lldb_event)
98 return ConstString(lldb_event->GetBroadcaster()->GetBroadcasterClass())
99 .AsCString();
100 else
101 return "unknown class";
102 }
103
BroadcasterMatchesPtr(const SBBroadcaster * broadcaster)104 bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) {
105 LLDB_INSTRUMENT_VA(this, broadcaster);
106
107 if (broadcaster)
108 return BroadcasterMatchesRef(*broadcaster);
109 return false;
110 }
111
BroadcasterMatchesRef(const SBBroadcaster & broadcaster)112 bool SBEvent::BroadcasterMatchesRef(const SBBroadcaster &broadcaster) {
113 LLDB_INSTRUMENT_VA(this, broadcaster);
114
115 Event *lldb_event = get();
116 bool success = false;
117 if (lldb_event)
118 success = lldb_event->BroadcasterIs(broadcaster.get());
119
120
121 return success;
122 }
123
Clear()124 void SBEvent::Clear() {
125 LLDB_INSTRUMENT_VA(this);
126
127 Event *lldb_event = get();
128 if (lldb_event)
129 lldb_event->Clear();
130 }
131
GetSP() const132 EventSP &SBEvent::GetSP() const { return m_event_sp; }
133
get() const134 Event *SBEvent::get() const {
135 // There is a dangerous accessor call GetSharedPtr which can be used, so if
136 // we have anything valid in m_event_sp, we must use that since if it gets
137 // used by a function that puts something in there, then it won't update
138 // m_opaque_ptr...
139 if (m_event_sp)
140 m_opaque_ptr = m_event_sp.get();
141
142 return m_opaque_ptr;
143 }
144
reset(EventSP & event_sp)145 void SBEvent::reset(EventSP &event_sp) {
146 m_event_sp = event_sp;
147 m_opaque_ptr = m_event_sp.get();
148 }
149
reset(Event * event_ptr)150 void SBEvent::reset(Event *event_ptr) {
151 m_opaque_ptr = event_ptr;
152 m_event_sp.reset();
153 }
154
IsValid() const155 bool SBEvent::IsValid() const {
156 LLDB_INSTRUMENT_VA(this);
157 return this->operator bool();
158 }
operator bool() const159 SBEvent::operator bool() const {
160 LLDB_INSTRUMENT_VA(this);
161
162 // Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() accessor.
163 // See comments in SBEvent::get()....
164 return SBEvent::get() != nullptr;
165 }
166
GetCStringFromEvent(const SBEvent & event)167 const char *SBEvent::GetCStringFromEvent(const SBEvent &event) {
168 LLDB_INSTRUMENT_VA(event);
169
170 return ConstString(static_cast<const char *>(
171 EventDataBytes::GetBytesFromEvent(event.get())))
172 .GetCString();
173 }
174
GetDescription(SBStream & description)175 bool SBEvent::GetDescription(SBStream &description) {
176 LLDB_INSTRUMENT_VA(this, description);
177
178 Stream &strm = description.ref();
179
180 if (get()) {
181 m_opaque_ptr->Dump(&strm);
182 } else
183 strm.PutCString("No value");
184
185 return true;
186 }
187
GetDescription(SBStream & description) const188 bool SBEvent::GetDescription(SBStream &description) const {
189 LLDB_INSTRUMENT_VA(this, description);
190
191 Stream &strm = description.ref();
192
193 if (get()) {
194 m_opaque_ptr->Dump(&strm);
195 } else
196 strm.PutCString("No value");
197
198 return true;
199 }
200