1 //===-- SBEvent.cpp ---------------------------------------------*- C++ -*-===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 10 #include "lldb/API/SBEvent.h" 11 #include "lldb/API/SBBroadcaster.h" 12 #include "lldb/API/SBStream.h" 13 14 #include "lldb/Core/Event.h" 15 #include "lldb/Core/Stream.h" 16 #include "lldb/Core/StreamFile.h" 17 #include "lldb/Core/ConstString.h" 18 #include "lldb/Target/Process.h" 19 #include "lldb/Breakpoint/Breakpoint.h" 20 #include "lldb/Interpreter/CommandInterpreter.h" 21 22 using namespace lldb; 23 using namespace lldb_private; 24 25 26 SBEvent::SBEvent () : 27 m_event_sp (), 28 m_opaque_ptr (NULL) 29 { 30 } 31 32 SBEvent::SBEvent (uint32_t event_type, const char *cstr, uint32_t cstr_len) : 33 m_event_sp (new Event (event_type, new EventDataBytes (cstr, cstr_len))), 34 m_opaque_ptr (m_event_sp.get()) 35 { 36 } 37 38 SBEvent::SBEvent (EventSP &event_sp) : 39 m_event_sp (event_sp), 40 m_opaque_ptr (event_sp.get()) 41 { 42 } 43 44 SBEvent::SBEvent (const SBEvent &rhs) : 45 m_event_sp (rhs.m_event_sp), 46 m_opaque_ptr (rhs.m_opaque_ptr) 47 { 48 49 } 50 51 const SBEvent & 52 SBEvent::operator = (const SBEvent &rhs) 53 { 54 if (this != &rhs) 55 { 56 m_event_sp = rhs.m_event_sp; 57 m_opaque_ptr = rhs.m_opaque_ptr; 58 } 59 return *this; 60 } 61 62 SBEvent::~SBEvent() 63 { 64 } 65 66 const char * 67 SBEvent::GetDataFlavor () 68 { 69 Event *lldb_event = get(); 70 if (lldb_event) 71 { 72 EventData *event_data = lldb_event->GetData(); 73 if (event_data) 74 return lldb_event->GetData()->GetFlavor().AsCString(); 75 } 76 return NULL; 77 } 78 79 uint32_t 80 SBEvent::GetType () const 81 { 82 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 83 84 const Event *lldb_event = get(); 85 uint32_t event_type = 0; 86 if (lldb_event) 87 event_type = lldb_event->GetType(); 88 89 if (log) 90 { 91 StreamString sstr; 92 if (lldb_event && lldb_event->GetBroadcaster() && lldb_event->GetBroadcaster()->GetEventNames(sstr, event_type, true)) 93 log->Printf ("SBEvent(%p)::GetType () => 0x%8.8x (%s)", get(), event_type, sstr.GetData()); 94 else 95 log->Printf ("SBEvent(%p)::GetType () => 0x%8.8x", get(), event_type); 96 97 } 98 99 return event_type; 100 } 101 102 SBBroadcaster 103 SBEvent::GetBroadcaster () const 104 { 105 SBBroadcaster broadcaster; 106 const Event *lldb_event = get(); 107 if (lldb_event) 108 broadcaster.reset (lldb_event->GetBroadcaster(), false); 109 return broadcaster; 110 } 111 112 const char * 113 SBEvent::GetBroadcasterClass () const 114 { 115 const Event *lldb_event = get(); 116 if (lldb_event) 117 return lldb_event->GetBroadcaster()->GetBroadcasterClass().AsCString(); 118 else 119 return "unknown class"; 120 } 121 122 bool 123 SBEvent::BroadcasterMatchesPtr (const SBBroadcaster *broadcaster) 124 { 125 if (broadcaster) 126 return BroadcasterMatchesRef (*broadcaster); 127 return false; 128 } 129 130 bool 131 SBEvent::BroadcasterMatchesRef (const SBBroadcaster &broadcaster) 132 { 133 134 Event *lldb_event = get(); 135 bool success = false; 136 if (lldb_event) 137 success = lldb_event->BroadcasterIs (broadcaster.get()); 138 139 // For logging, this gets a little chatty so only enable this when verbose logging is on 140 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API | LIBLLDB_LOG_VERBOSE)); 141 if (log) 142 log->Printf ("SBEvent(%p)::BroadcasterMatchesRef (SBBroadcaster(%p): %s) => %i", 143 get(), 144 broadcaster.get(), 145 broadcaster.GetName(), 146 success); 147 148 return success; 149 } 150 151 void 152 SBEvent::Clear() 153 { 154 Event *lldb_event = get(); 155 if (lldb_event) 156 lldb_event->Clear(); 157 } 158 159 EventSP & 160 SBEvent::GetSP () const 161 { 162 return m_event_sp; 163 } 164 165 Event * 166 SBEvent::get() const 167 { 168 // There is a dangerous accessor call GetSharedPtr which can be used, so if 169 // we have anything valid in m_event_sp, we must use that since if it gets 170 // used by a function that puts something in there, then it won't update 171 // m_opaque_ptr... 172 if (m_event_sp) 173 m_opaque_ptr = m_event_sp.get(); 174 175 return m_opaque_ptr; 176 } 177 178 void 179 SBEvent::reset (EventSP &event_sp) 180 { 181 m_event_sp = event_sp; 182 m_opaque_ptr = m_event_sp.get(); 183 } 184 185 void 186 SBEvent::reset (Event* event_ptr) 187 { 188 m_opaque_ptr = event_ptr; 189 m_event_sp.reset(); 190 } 191 192 bool 193 SBEvent::IsValid() const 194 { 195 // Do NOT use m_opaque_ptr directly!!! Must use the SBEvent::get() 196 // accessor. See comments in SBEvent::get().... 197 return SBEvent::get() != NULL; 198 199 } 200 201 const char * 202 SBEvent::GetCStringFromEvent (const SBEvent &event) 203 { 204 LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); 205 206 if (log) 207 log->Printf ("SBEvent(%p)::GetCStringFromEvent () => \"%s\"", 208 event.get(), 209 reinterpret_cast<const char *>(EventDataBytes::GetBytesFromEvent (event.get()))); 210 211 return reinterpret_cast<const char *>(EventDataBytes::GetBytesFromEvent (event.get())); 212 } 213 214 215 bool 216 SBEvent::GetDescription (SBStream &description) 217 { 218 Stream &strm = description.ref(); 219 220 if (get()) 221 { 222 m_opaque_ptr->Dump (&strm); 223 } 224 else 225 strm.PutCString ("No value"); 226 227 return true; 228 } 229 230 bool 231 SBEvent::GetDescription (SBStream &description) const 232 { 233 Stream &strm = description.ref(); 234 235 if (get()) 236 { 237 m_opaque_ptr->Dump (&strm); 238 } 239 else 240 strm.PutCString ("No value"); 241 242 return true; 243 } 244