SBListener.cpp revision 280031 
1//===-- SBListener.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/lldb-python.h"
11
12#include "lldb/API/SBListener.h"
13#include "lldb/API/SBBroadcaster.h"
14#include "lldb/API/SBDebugger.h"
15#include "lldb/API/SBEvent.h"
16#include "lldb/API/SBStream.h"
17#include "lldb/Core/Broadcaster.h"
18#include "lldb/Core/Debugger.h"
19#include "lldb/Core/Listener.h"
20#include "lldb/Core/Log.h"
21#include "lldb/Core/StreamString.h"
22#include "lldb/Host/TimeValue.h"
23
24
25using namespace lldb;
26using namespace lldb_private;
27
28
29SBListener::SBListener () :
30    m_opaque_sp (),
31    m_opaque_ptr (NULL)
32{
33}
34
35SBListener::SBListener (const char *name) :
36    m_opaque_sp (new Listener (name)),
37    m_opaque_ptr (NULL)
38{
39    m_opaque_ptr = m_opaque_sp.get();
40
41    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
42
43    if (log)
44        log->Printf ("SBListener::SBListener (name=\"%s\") => SBListener(%p)",
45                     name, static_cast<void*>(m_opaque_ptr));
46}
47
48
49SBListener::SBListener (const SBListener &rhs) :
50    m_opaque_sp (rhs.m_opaque_sp),
51    m_opaque_ptr (rhs.m_opaque_ptr)
52{
53}
54
55const lldb::SBListener &
56SBListener::operator = (const lldb::SBListener &rhs)
57{
58    if (this != &rhs)
59    {
60        m_opaque_sp = rhs.m_opaque_sp;
61        m_opaque_ptr = rhs.m_opaque_ptr;
62    }
63    return *this;
64}
65
66SBListener::SBListener (Listener &listener) :
67    m_opaque_sp (),
68    m_opaque_ptr (&listener)
69{
70}
71
72SBListener::SBListener (const lldb::ListenerSP &listener_sp) :
73    m_opaque_sp (listener_sp),
74    m_opaque_ptr (listener_sp.get())
75{
76}
77
78SBListener::~SBListener ()
79{
80}
81
82bool
83SBListener::IsValid() const
84{
85    return m_opaque_ptr != NULL;
86}
87
88void
89SBListener::AddEvent (const SBEvent &event)
90{
91    EventSP &event_sp = event.GetSP ();
92    if (event_sp)
93        m_opaque_ptr->AddEvent (event_sp);
94}
95
96void
97SBListener::Clear ()
98{
99    if (m_opaque_ptr)
100        m_opaque_ptr->Clear ();
101}
102
103uint32_t
104SBListener::StartListeningForEventClass (SBDebugger &debugger,
105                             const char *broadcaster_class,
106                             uint32_t event_mask)
107{
108    if (m_opaque_ptr)
109    {
110        Debugger *lldb_debugger = debugger.get();
111        if (!lldb_debugger)
112            return 0;
113        BroadcastEventSpec event_spec (ConstString (broadcaster_class), event_mask);
114        return m_opaque_ptr->StartListeningForEventSpec (*lldb_debugger, event_spec);
115    }
116    else
117        return 0;
118}
119
120bool
121SBListener::StopListeningForEventClass (SBDebugger &debugger,
122                            const char *broadcaster_class,
123                            uint32_t event_mask)
124{
125    if (m_opaque_ptr)
126    {
127        Debugger *lldb_debugger = debugger.get();
128        if (!lldb_debugger)
129            return false;
130        BroadcastEventSpec event_spec (ConstString (broadcaster_class), event_mask);
131        return m_opaque_ptr->StopListeningForEventSpec (*lldb_debugger, event_spec);
132    }
133    else
134        return false;
135}
136
137uint32_t
138SBListener::StartListeningForEvents (const SBBroadcaster& broadcaster, uint32_t event_mask)
139{
140    uint32_t acquired_event_mask = 0;
141    if (m_opaque_ptr && broadcaster.IsValid())
142    {
143        acquired_event_mask = m_opaque_ptr->StartListeningForEvents (broadcaster.get(), event_mask);
144    }
145
146    Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
147    if (log)
148    {
149        StreamString sstr_requested;
150        StreamString sstr_acquired;
151
152        Broadcaster *lldb_broadcaster = broadcaster.get();
153        if (lldb_broadcaster)
154        {
155            const bool got_requested_names = lldb_broadcaster->GetEventNames (sstr_requested, event_mask, false);
156            const bool got_acquired_names = lldb_broadcaster->GetEventNames (sstr_acquired, acquired_event_mask, false);
157            log->Printf ("SBListener(%p)::StartListeneingForEvents (SBBroadcaster(%p): %s, event_mask=0x%8.8x%s%s%s) => 0x%8.8x%s%s%s",
158                         static_cast<void*>(m_opaque_ptr),
159                         static_cast<void*>(lldb_broadcaster),
160                         lldb_broadcaster->GetBroadcasterName().GetCString(),
161                         event_mask,
162                         got_requested_names ? " (" : "",
163                         sstr_requested.GetData(),
164                         got_requested_names ? ")" : "",
165                         acquired_event_mask,
166                         got_acquired_names ? " (" : "",
167                         sstr_acquired.GetData(),
168                         got_acquired_names ? ")" : "");
169        }
170        else
171        {
172            log->Printf ("SBListener(%p)::StartListeneingForEvents (SBBroadcaster(%p), event_mask=0x%8.8x) => 0x%8.8x",
173                         static_cast<void*>(m_opaque_ptr),
174                         static_cast<void*>(lldb_broadcaster), event_mask,
175                         acquired_event_mask);
176        }
177    }
178
179    return acquired_event_mask;
180}
181
182bool
183SBListener::StopListeningForEvents (const SBBroadcaster& broadcaster, uint32_t event_mask)
184{
185    if (m_opaque_ptr && broadcaster.IsValid())
186    {
187        return m_opaque_ptr->StopListeningForEvents (broadcaster.get(), event_mask);
188    }
189    return false;
190}
191
192bool
193SBListener::WaitForEvent (uint32_t timeout_secs, SBEvent &event)
194{
195    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
196    if (log)
197    {
198        if (timeout_secs == UINT32_MAX)
199        {
200            log->Printf ("SBListener(%p)::WaitForEvent (timeout_secs=INFINITE, SBEvent(%p))...",
201                         static_cast<void*>(m_opaque_ptr),
202                         static_cast<void*>(event.get()));
203        }
204        else
205        {
206            log->Printf ("SBListener(%p)::WaitForEvent (timeout_secs=%d, SBEvent(%p))...",
207                         static_cast<void*>(m_opaque_ptr), timeout_secs,
208                         static_cast<void*>(event.get()));
209        }
210    }
211    bool success = false;
212
213    if (m_opaque_ptr)
214    {
215        TimeValue time_value;
216        if (timeout_secs != UINT32_MAX)
217        {
218            assert (timeout_secs != 0); // Take this out after all calls with timeout set to zero have been removed....
219            time_value = TimeValue::Now();
220            time_value.OffsetWithSeconds (timeout_secs);
221        }
222        EventSP event_sp;
223        if (m_opaque_ptr->WaitForEvent (time_value.IsValid() ? &time_value : NULL, event_sp))
224        {
225            event.reset (event_sp);
226            success = true;
227        }
228    }
229
230    if (log)
231    {
232        if (timeout_secs == UINT32_MAX)
233        {
234            log->Printf ("SBListener(%p)::WaitForEvent (timeout_secs=INFINITE, SBEvent(%p)) => %i",
235                         static_cast<void*>(m_opaque_ptr),
236                         static_cast<void*>(event.get()), success);
237        }
238        else
239        {
240            log->Printf ("SBListener(%p)::WaitForEvent (timeout_secs=%d, SBEvent(%p)) => %i",
241                         static_cast<void*>(m_opaque_ptr), timeout_secs,
242                         static_cast<void*>(event.get()), success);
243        }
244    }
245    if (!success)
246        event.reset (NULL);
247    return success;
248}
249
250bool
251SBListener::WaitForEventForBroadcaster
252(
253    uint32_t num_seconds,
254    const SBBroadcaster &broadcaster,
255    SBEvent &event
256)
257{
258    if (m_opaque_ptr && broadcaster.IsValid())
259    {
260        TimeValue time_value;
261        if (num_seconds != UINT32_MAX)
262        {
263            time_value = TimeValue::Now();
264            time_value.OffsetWithSeconds (num_seconds);
265        }
266        EventSP event_sp;
267        if (m_opaque_ptr->WaitForEventForBroadcaster (time_value.IsValid() ? &time_value : NULL,
268                                                         broadcaster.get(),
269                                                         event_sp))
270        {
271            event.reset (event_sp);
272            return true;
273        }
274
275    }
276    event.reset (NULL);
277    return false;
278}
279
280bool
281SBListener::WaitForEventForBroadcasterWithType
282(
283    uint32_t num_seconds,
284    const SBBroadcaster &broadcaster,
285    uint32_t event_type_mask,
286    SBEvent &event
287)
288{
289    if (m_opaque_ptr && broadcaster.IsValid())
290    {
291        TimeValue time_value;
292        if (num_seconds != UINT32_MAX)
293        {
294            time_value = TimeValue::Now();
295            time_value.OffsetWithSeconds (num_seconds);
296        }
297        EventSP event_sp;
298        if (m_opaque_ptr->WaitForEventForBroadcasterWithType (time_value.IsValid() ? &time_value : NULL,
299                                                              broadcaster.get(),
300                                                              event_type_mask,
301                                                              event_sp))
302        {
303            event.reset (event_sp);
304            return true;
305        }
306    }
307    event.reset (NULL);
308    return false;
309}
310
311bool
312SBListener::PeekAtNextEvent (SBEvent &event)
313{
314    if (m_opaque_ptr)
315    {
316        event.reset (m_opaque_ptr->PeekAtNextEvent ());
317        return event.IsValid();
318    }
319    event.reset (NULL);
320    return false;
321}
322
323bool
324SBListener::PeekAtNextEventForBroadcaster (const SBBroadcaster &broadcaster, SBEvent &event)
325{
326    if (m_opaque_ptr && broadcaster.IsValid())
327    {
328        event.reset (m_opaque_ptr->PeekAtNextEventForBroadcaster (broadcaster.get()));
329        return event.IsValid();
330    }
331    event.reset (NULL);
332    return false;
333}
334
335bool
336SBListener::PeekAtNextEventForBroadcasterWithType (const SBBroadcaster &broadcaster, uint32_t event_type_mask,
337                                                   SBEvent &event)
338{
339    if (m_opaque_ptr && broadcaster.IsValid())
340    {
341        event.reset(m_opaque_ptr->PeekAtNextEventForBroadcasterWithType (broadcaster.get(), event_type_mask));
342        return event.IsValid();
343    }
344    event.reset (NULL);
345    return false;
346}
347
348bool
349SBListener::GetNextEvent (SBEvent &event)
350{
351    if (m_opaque_ptr)
352    {
353        EventSP event_sp;
354        if (m_opaque_ptr->GetNextEvent (event_sp))
355        {
356            event.reset (event_sp);
357            return true;
358        }
359    }
360    event.reset (NULL);
361    return false;
362}
363
364bool
365SBListener::GetNextEventForBroadcaster (const SBBroadcaster &broadcaster, SBEvent &event)
366{
367    if (m_opaque_ptr && broadcaster.IsValid())
368    {
369        EventSP event_sp;
370        if (m_opaque_ptr->GetNextEventForBroadcaster (broadcaster.get(), event_sp))
371        {
372            event.reset (event_sp);
373            return true;
374        }
375    }
376    event.reset (NULL);
377    return false;
378}
379
380bool
381SBListener::GetNextEventForBroadcasterWithType
382(
383    const SBBroadcaster &broadcaster,
384    uint32_t event_type_mask,
385    SBEvent &event
386)
387{
388    if (m_opaque_ptr && broadcaster.IsValid())
389    {
390        EventSP event_sp;
391        if (m_opaque_ptr->GetNextEventForBroadcasterWithType (broadcaster.get(),
392                                                              event_type_mask,
393                                                              event_sp))
394        {
395            event.reset (event_sp);
396            return true;
397        }
398    }
399    event.reset (NULL);
400    return false;
401}
402
403bool
404SBListener::HandleBroadcastEvent (const SBEvent &event)
405{
406    if (m_opaque_ptr)
407        return m_opaque_ptr->HandleBroadcastEvent (event.GetSP());
408    return false;
409}
410
411Listener *
412SBListener::operator->() const
413{
414    return m_opaque_ptr;
415}
416
417Listener *
418SBListener::get() const
419{
420    return m_opaque_ptr;
421}
422
423void
424SBListener::reset(Listener *listener, bool owns)
425{
426    if (owns)
427        m_opaque_sp.reset (listener);
428    else
429        m_opaque_sp.reset ();
430    m_opaque_ptr = listener;
431}
432
433Listener &
434SBListener::ref() const
435{
436    return *m_opaque_ptr;
437}
438
439Listener &
440SBListener::operator *()
441{
442    return *m_opaque_ptr;
443}
444
445const Listener &
446SBListener::operator *() const
447{
448    return *m_opaque_ptr;
449}
450
451
452