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/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() { LLDB_INSTRUMENT_VA(this); }
26 
27 SBEvent::SBEvent(uint32_t event_type, const char *cstr, uint32_t cstr_len)
28     : m_event_sp(new Event(event_type, new EventDataBytes(cstr, cstr_len))),
29       m_opaque_ptr(m_event_sp.get()) {
30   LLDB_INSTRUMENT_VA(this, event_type, cstr, cstr_len);
31 }
32 
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 
38 SBEvent::SBEvent(Event *event_ptr) : m_opaque_ptr(event_ptr) {
39   LLDB_INSTRUMENT_VA(this, event_ptr);
40 }
41 
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 
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 
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 
71 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 
83 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 
93 const 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 
103 bool SBEvent::BroadcasterMatchesPtr(const SBBroadcaster *broadcaster) {
104   LLDB_INSTRUMENT_VA(this, broadcaster);
105 
106   if (broadcaster)
107     return BroadcasterMatchesRef(*broadcaster);
108   return false;
109 }
110 
111 bool 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.get());
118 
119 
120   return success;
121 }
122 
123 void SBEvent::Clear() {
124   LLDB_INSTRUMENT_VA(this);
125 
126   Event *lldb_event = get();
127   if (lldb_event)
128     lldb_event->Clear();
129 }
130 
131 EventSP &SBEvent::GetSP() const { return m_event_sp; }
132 
133 Event *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 
144 void SBEvent::reset(EventSP &event_sp) {
145   m_event_sp = event_sp;
146   m_opaque_ptr = m_event_sp.get();
147 }
148 
149 void SBEvent::reset(Event *event_ptr) {
150   m_opaque_ptr = event_ptr;
151   m_event_sp.reset();
152 }
153 
154 bool SBEvent::IsValid() const {
155   LLDB_INSTRUMENT_VA(this);
156   return this->operator bool();
157 }
158 SBEvent::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 
166 const char *SBEvent::GetCStringFromEvent(const SBEvent &event) {
167   LLDB_INSTRUMENT_VA(event);
168 
169   return ConstString(static_cast<const char *>(
170                          EventDataBytes::GetBytesFromEvent(event.get())))
171       .GetCString();
172 }
173 
174 bool 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(&strm);
181   } else
182     strm.PutCString("No value");
183 
184   return true;
185 }
186 
187 bool 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(&strm);
194   } else
195     strm.PutCString("No value");
196 
197   return true;
198 }
199