size_t Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent(
const EventSP &event_sp) {
const BreakpointEventData *data = GetEventDataFromEvent(event_sp.get());
if (data)
return data->m_locations.GetSize();
return 0;
}
BreakpointEventType
Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent(
const EventSP &event_sp) {
const BreakpointEventData *data = GetEventDataFromEvent(event_sp.get());
if (data == nullptr)
return eBreakpointEventTypeInvalidType;
else
return data->GetBreakpointEventType();
}
BreakpointSP Breakpoint::BreakpointEventData::GetBreakpointFromEvent(
const EventSP &event_sp) {
BreakpointSP bp_sp;
const BreakpointEventData *data = GetEventDataFromEvent(event_sp.get());
if (data)
bp_sp = data->m_new_breakpoint_sp;
return bp_sp;
}
WatchpointSP Watchpoint::WatchpointEventData::GetWatchpointFromEvent(
const EventSP &event_sp) {
WatchpointSP wp_sp;
const WatchpointEventData *data = GetEventDataFromEvent(event_sp.get());
if (data)
wp_sp = data->m_new_watchpoint_sp;
return wp_sp;
}
WatchpointEventType
Watchpoint::WatchpointEventData::GetWatchpointEventTypeFromEvent (const EventSP &event_sp)
{
const WatchpointEventData *data = GetEventDataFromEvent (event_sp.get());
if (data == NULL)
return eWatchpointEventTypeInvalidType;
else
return data->GetWatchpointEventType();
}
bool Listener::FindNextEventInternal(
std::unique_lock<std::mutex> &lock,
Broadcaster *broadcaster, // nullptr for any broadcaster
const ConstString *broadcaster_names, // nullptr for any event
uint32_t num_broadcaster_names, uint32_t event_type_mask, EventSP &event_sp,
bool remove) {
// NOTE: callers of this function must lock m_events_mutex using a
// Mutex::Locker
// and pass the locker as the first argument. m_events_mutex is no longer
// recursive.
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
if (m_events.empty())
return false;
Listener::event_collection::iterator pos = m_events.end();
if (broadcaster == nullptr && broadcaster_names == nullptr &&
event_type_mask == 0) {
pos = m_events.begin();
} else {
pos = std::find_if(m_events.begin(), m_events.end(),
EventMatcher(broadcaster, broadcaster_names,
num_broadcaster_names, event_type_mask));
}
if (pos != m_events.end()) {
event_sp = *pos;
if (log != nullptr)
log->Printf("%p '%s' Listener::FindNextEventInternal(broadcaster=%p, "
"broadcaster_names=%p[%u], event_type_mask=0x%8.8x, "
"remove=%i) event %p",
static_cast<void *>(this), GetName(),
static_cast<void *>(broadcaster),
static_cast<const void *>(broadcaster_names),
num_broadcaster_names, event_type_mask, remove,
static_cast<void *>(event_sp.get()));
if (remove) {
m_events.erase(pos);
// Unlock the event queue here. We've removed this event and are about to
// return
// it so it should be okay to get the next event off the queue here - and
// it might
// be useful to do that in the "DoOnRemoval".
lock.unlock();
event_sp->DoOnRemoval();
}
return true;
}
event_sp.reset();
return false;
}
void Listener::AddEvent(EventSP &event_sp) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EVENTS));
if (log != nullptr)
log->Printf("%p Listener('%s')::AddEvent (event_sp = {%p})",
static_cast<void *>(this), m_name.c_str(),
static_cast<void *>(event_sp.get()));
std::lock_guard<std::mutex> guard(m_events_mutex);
m_events.push_back(event_sp);
m_events_condition.notify_all();
}
void
Listener::AddEvent (EventSP &event_sp)
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EVENTS));
if (log)
log->Printf ("%p Listener('%s')::AddEvent (event_sp = {%p})",
static_cast<void*>(this), m_name.c_str(),
static_cast<void*>(event_sp.get()));
// Scope for "locker"
{
Mutex::Locker locker(m_events_mutex);
m_events.push_back (event_sp);
}
m_cond_wait.SetValue (true, eBroadcastAlways);
}
SBEvent::SBEvent (EventSP &event_sp) :
m_event_sp (event_sp),
m_opaque_ptr (event_sp.get())
{
}
bool
Listener::FindNextEventInternal
(
Broadcaster *broadcaster, // NULL for any broadcaster
const ConstString *broadcaster_names, // NULL for any event
uint32_t num_broadcaster_names,
uint32_t event_type_mask,
EventSP &event_sp,
bool remove)
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EVENTS));
Mutex::Locker lock(m_events_mutex);
if (m_events.empty())
return false;
Listener::event_collection::iterator pos = m_events.end();
if (broadcaster == NULL && broadcaster_names == NULL && event_type_mask == 0)
{
pos = m_events.begin();
}
else
{
pos = std::find_if (m_events.begin(), m_events.end(), EventMatcher (broadcaster, broadcaster_names, num_broadcaster_names, event_type_mask));
}
if (pos != m_events.end())
{
event_sp = *pos;
if (log)
log->Printf ("%p '%s' Listener::FindNextEventInternal(broadcaster=%p, broadcaster_names=%p[%u], event_type_mask=0x%8.8x, remove=%i) event %p",
static_cast<void*>(this), GetName(),
static_cast<void*>(broadcaster),
static_cast<const void*>(broadcaster_names),
num_broadcaster_names, event_type_mask, remove,
static_cast<void*>(event_sp.get()));
if (remove)
{
m_events.erase(pos);
if (m_events.empty())
m_cond_wait.SetValue (false, eBroadcastNever);
}
// Unlock the event queue here. We've removed this event and are about to return
// it so it should be okay to get the next event off the queue here - and it might
// be useful to do that in the "DoOnRemoval".
lock.Unlock();
// Don't call DoOnRemoval if you aren't removing the event...
if (remove)
event_sp->DoOnRemoval();
return true;
}
event_sp.reset();
return false;
}
