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