1//===-- SBDebugger.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/SBDebugger.h"
13
14#include "lldb/lldb-private.h"
15
16#include "lldb/API/SBListener.h"
17#include "lldb/API/SBBroadcaster.h"
18#include "lldb/API/SBCommandInterpreter.h"
19#include "lldb/API/SBCommandReturnObject.h"
20#include "lldb/API/SBError.h"
21#include "lldb/API/SBEvent.h"
22#include "lldb/API/SBFrame.h"
23#include "lldb/API/SBInputReader.h"
24#include "lldb/API/SBProcess.h"
25#include "lldb/API/SBSourceManager.h"
26#include "lldb/API/SBStream.h"
27#include "lldb/API/SBStringList.h"
28#include "lldb/API/SBTarget.h"
29#include "lldb/API/SBThread.h"
30#include "lldb/API/SBTypeCategory.h"
31#include "lldb/API/SBTypeFormat.h"
32#include "lldb/API/SBTypeFilter.h"
33#include "lldb/API/SBTypeNameSpecifier.h"
34#include "lldb/API/SBTypeSummary.h"
35#include "lldb/API/SBTypeSynthetic.h"
36
37
38#include "lldb/Core/Debugger.h"
39#include "lldb/Core/State.h"
40#include "lldb/DataFormatters/DataVisualization.h"
41#include "lldb/Interpreter/Args.h"
42#include "lldb/Interpreter/CommandInterpreter.h"
43#include "lldb/Interpreter/OptionGroupPlatform.h"
44#include "lldb/Target/Process.h"
45#include "lldb/Target/TargetList.h"
46
47using namespace lldb;
48using namespace lldb_private;
49
50void
51SBDebugger::Initialize ()
52{
53    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
54
55    if (log)
56        log->Printf ("SBDebugger::Initialize ()");
57
58    SBCommandInterpreter::InitializeSWIG ();
59
60    Debugger::Initialize();
61}
62
63void
64SBDebugger::Terminate ()
65{
66    Debugger::Terminate();
67}
68
69void
70SBDebugger::Clear ()
71{
72    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
73
74    if (log)
75        log->Printf ("SBDebugger(%p)::Clear ()", m_opaque_sp.get());
76
77    if (m_opaque_sp)
78        m_opaque_sp->CleanUpInputReaders ();
79
80    m_opaque_sp.reset();
81}
82
83SBDebugger
84SBDebugger::Create()
85{
86    return SBDebugger::Create(false, NULL, NULL);
87}
88
89SBDebugger
90SBDebugger::Create(bool source_init_files)
91{
92    return SBDebugger::Create (source_init_files, NULL, NULL);
93}
94
95SBDebugger
96SBDebugger::Create(bool source_init_files, lldb::LogOutputCallback callback, void *baton)
97
98{
99    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
100
101    SBDebugger debugger;
102    debugger.reset(Debugger::CreateInstance(callback, baton));
103
104    if (log)
105    {
106        SBStream sstr;
107        debugger.GetDescription (sstr);
108        log->Printf ("SBDebugger::Create () => SBDebugger(%p): %s", debugger.m_opaque_sp.get(), sstr.GetData());
109    }
110
111    SBCommandInterpreter interp = debugger.GetCommandInterpreter();
112    if (source_init_files)
113    {
114        interp.get()->SkipLLDBInitFiles(false);
115        interp.get()->SkipAppInitFiles (false);
116        SBCommandReturnObject result;
117        interp.SourceInitFileInHomeDirectory(result);
118    }
119    else
120    {
121        interp.get()->SkipLLDBInitFiles(true);
122        interp.get()->SkipAppInitFiles (true);
123    }
124    return debugger;
125}
126
127void
128SBDebugger::Destroy (SBDebugger &debugger)
129{
130    Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
131
132    if (log)
133    {
134        SBStream sstr;
135        debugger.GetDescription (sstr);
136        log->Printf ("SBDebugger::Destroy () => SBDebugger(%p): %s", debugger.m_opaque_sp.get(), sstr.GetData());
137    }
138
139    Debugger::Destroy (debugger.m_opaque_sp);
140
141    if (debugger.m_opaque_sp.get() != NULL)
142        debugger.m_opaque_sp.reset();
143}
144
145void
146SBDebugger::MemoryPressureDetected ()
147{
148    // Since this function can be call asynchronously, we allow it to be
149    // non-mandatory. We have seen deadlocks with this function when called
150    // so we need to safeguard against this until we can determine what is
151    // causing the deadlocks.
152    Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
153
154    const bool mandatory = false;
155    if (log)
156    {
157        log->Printf ("SBDebugger::MemoryPressureDetected (), mandatory = %d", mandatory);
158    }
159
160    ModuleList::RemoveOrphanSharedModules(mandatory);
161}
162
163SBDebugger::SBDebugger () :
164    m_opaque_sp ()
165{
166}
167
168SBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp) :
169    m_opaque_sp(debugger_sp)
170{
171}
172
173SBDebugger::SBDebugger(const SBDebugger &rhs) :
174    m_opaque_sp (rhs.m_opaque_sp)
175{
176}
177
178SBDebugger &
179SBDebugger::operator = (const SBDebugger &rhs)
180{
181    if (this != &rhs)
182    {
183        m_opaque_sp = rhs.m_opaque_sp;
184    }
185    return *this;
186}
187
188SBDebugger::~SBDebugger ()
189{
190}
191
192bool
193SBDebugger::IsValid() const
194{
195    return m_opaque_sp.get() != NULL;
196}
197
198
199void
200SBDebugger::SetAsync (bool b)
201{
202    if (m_opaque_sp)
203        m_opaque_sp->SetAsyncExecution(b);
204}
205
206bool
207SBDebugger::GetAsync ()
208{
209    if (m_opaque_sp)
210        return m_opaque_sp->GetAsyncExecution();
211    else
212        return false;
213}
214
215void
216SBDebugger::SkipLLDBInitFiles (bool b)
217{
218    if (m_opaque_sp)
219        m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles (b);
220}
221
222void
223SBDebugger::SkipAppInitFiles (bool b)
224{
225    if (m_opaque_sp)
226        m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles (b);
227}
228
229// Shouldn't really be settable after initialization as this could cause lots of problems; don't want users
230// trying to switch modes in the middle of a debugging session.
231void
232SBDebugger::SetInputFileHandle (FILE *fh, bool transfer_ownership)
233{
234    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
235
236    if (log)
237        log->Printf ("SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(),
238                     fh, transfer_ownership);
239
240    if (m_opaque_sp)
241        m_opaque_sp->SetInputFileHandle (fh, transfer_ownership);
242}
243
244void
245SBDebugger::SetOutputFileHandle (FILE *fh, bool transfer_ownership)
246{
247    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
248
249
250    if (log)
251        log->Printf ("SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(),
252                     fh, transfer_ownership);
253
254    if (m_opaque_sp)
255        m_opaque_sp->SetOutputFileHandle (fh, transfer_ownership);
256}
257
258void
259SBDebugger::SetErrorFileHandle (FILE *fh, bool transfer_ownership)
260{
261    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
262
263
264    if (log)
265        log->Printf ("SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(),
266                     fh, transfer_ownership);
267
268    if (m_opaque_sp)
269        m_opaque_sp->SetErrorFileHandle (fh, transfer_ownership);
270}
271
272FILE *
273SBDebugger::GetInputFileHandle ()
274{
275    if (m_opaque_sp)
276        return m_opaque_sp->GetInputFile().GetStream();
277    return NULL;
278}
279
280FILE *
281SBDebugger::GetOutputFileHandle ()
282{
283    if (m_opaque_sp)
284        return m_opaque_sp->GetOutputFile().GetStream();
285    return NULL;
286}
287
288FILE *
289SBDebugger::GetErrorFileHandle ()
290{
291    if (m_opaque_sp)
292        return m_opaque_sp->GetErrorFile().GetStream();
293    return NULL;
294}
295
296void
297SBDebugger::SaveInputTerminalState()
298{
299    if (m_opaque_sp)
300        m_opaque_sp->SaveInputTerminalState();
301}
302
303void
304SBDebugger::RestoreInputTerminalState()
305{
306    if (m_opaque_sp)
307        m_opaque_sp->RestoreInputTerminalState();
308
309}
310SBCommandInterpreter
311SBDebugger::GetCommandInterpreter ()
312{
313    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
314
315    SBCommandInterpreter sb_interpreter;
316    if (m_opaque_sp)
317        sb_interpreter.reset (&m_opaque_sp->GetCommandInterpreter());
318
319    if (log)
320        log->Printf ("SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)",
321                     m_opaque_sp.get(), sb_interpreter.get());
322
323    return sb_interpreter;
324}
325
326void
327SBDebugger::HandleCommand (const char *command)
328{
329    if (m_opaque_sp)
330    {
331        TargetSP target_sp (m_opaque_sp->GetSelectedTarget());
332        Mutex::Locker api_locker;
333        if (target_sp)
334            api_locker.Lock(target_sp->GetAPIMutex());
335
336        SBCommandInterpreter sb_interpreter(GetCommandInterpreter ());
337        SBCommandReturnObject result;
338
339        sb_interpreter.HandleCommand (command, result, false);
340
341        if (GetErrorFileHandle() != NULL)
342            result.PutError (GetErrorFileHandle());
343        if (GetOutputFileHandle() != NULL)
344            result.PutOutput (GetOutputFileHandle());
345
346        if (m_opaque_sp->GetAsyncExecution() == false)
347        {
348            SBProcess process(GetCommandInterpreter().GetProcess ());
349            ProcessSP process_sp (process.GetSP());
350            if (process_sp)
351            {
352                EventSP event_sp;
353                Listener &lldb_listener = m_opaque_sp->GetListener();
354                while (lldb_listener.GetNextEventForBroadcaster (process_sp.get(), event_sp))
355                {
356                    SBEvent event(event_sp);
357                    HandleProcessEvent (process, event, GetOutputFileHandle(), GetErrorFileHandle());
358                }
359            }
360        }
361    }
362}
363
364SBListener
365SBDebugger::GetListener ()
366{
367    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
368
369    SBListener sb_listener;
370    if (m_opaque_sp)
371        sb_listener.reset(&m_opaque_sp->GetListener(), false);
372
373    if (log)
374        log->Printf ("SBDebugger(%p)::GetListener () => SBListener(%p)", m_opaque_sp.get(),
375                     sb_listener.get());
376
377    return sb_listener;
378}
379
380void
381SBDebugger::HandleProcessEvent (const SBProcess &process, const SBEvent &event, FILE *out, FILE *err)
382{
383    if (!process.IsValid())
384        return;
385
386    TargetSP target_sp (process.GetTarget().GetSP());
387    if (!target_sp)
388        return;
389
390    const uint32_t event_type = event.GetType();
391    char stdio_buffer[1024];
392    size_t len;
393
394    Mutex::Locker api_locker (target_sp->GetAPIMutex());
395
396    if (event_type & (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged))
397    {
398        // Drain stdout when we stop just in case we have any bytes
399        while ((len = process.GetSTDOUT (stdio_buffer, sizeof (stdio_buffer))) > 0)
400            if (out != NULL)
401                ::fwrite (stdio_buffer, 1, len, out);
402    }
403
404    if (event_type & (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged))
405    {
406        // Drain stderr when we stop just in case we have any bytes
407        while ((len = process.GetSTDERR (stdio_buffer, sizeof (stdio_buffer))) > 0)
408            if (err != NULL)
409                ::fwrite (stdio_buffer, 1, len, err);
410    }
411
412    if (event_type & Process::eBroadcastBitStateChanged)
413    {
414        StateType event_state = SBProcess::GetStateFromEvent (event);
415
416        if (event_state == eStateInvalid)
417            return;
418
419        bool is_stopped = StateIsStoppedState (event_state);
420        if (!is_stopped)
421            process.ReportEventState (event, out);
422    }
423}
424
425SBSourceManager
426SBDebugger::GetSourceManager ()
427{
428    SBSourceManager sb_source_manager (*this);
429    return sb_source_manager;
430}
431
432
433bool
434SBDebugger::GetDefaultArchitecture (char *arch_name, size_t arch_name_len)
435{
436    if (arch_name && arch_name_len)
437    {
438        ArchSpec default_arch = Target::GetDefaultArchitecture ();
439
440        if (default_arch.IsValid())
441        {
442            const std::string &triple_str = default_arch.GetTriple().str();
443            if (!triple_str.empty())
444                ::snprintf (arch_name, arch_name_len, "%s", triple_str.c_str());
445            else
446                ::snprintf (arch_name, arch_name_len, "%s", default_arch.GetArchitectureName());
447            return true;
448        }
449    }
450    if (arch_name && arch_name_len)
451        arch_name[0] = '\0';
452    return false;
453}
454
455
456bool
457SBDebugger::SetDefaultArchitecture (const char *arch_name)
458{
459    if (arch_name)
460    {
461        ArchSpec arch (arch_name);
462        if (arch.IsValid())
463        {
464            Target::SetDefaultArchitecture (arch);
465            return true;
466        }
467    }
468    return false;
469}
470
471ScriptLanguage
472SBDebugger::GetScriptingLanguage (const char *script_language_name)
473{
474
475    return Args::StringToScriptLanguage (script_language_name,
476                                         eScriptLanguageDefault,
477                                         NULL);
478}
479
480const char *
481SBDebugger::GetVersionString ()
482{
483    return GetVersion();
484}
485
486const char *
487SBDebugger::StateAsCString (StateType state)
488{
489    return lldb_private::StateAsCString (state);
490}
491
492bool
493SBDebugger::StateIsRunningState (StateType state)
494{
495    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
496
497    const bool result = lldb_private::StateIsRunningState (state);
498    if (log)
499        log->Printf ("SBDebugger::StateIsRunningState (state=%s) => %i",
500                     StateAsCString (state), result);
501
502    return result;
503}
504
505bool
506SBDebugger::StateIsStoppedState (StateType state)
507{
508    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
509
510    const bool result = lldb_private::StateIsStoppedState (state, false);
511    if (log)
512        log->Printf ("SBDebugger::StateIsStoppedState (state=%s) => %i",
513                     StateAsCString (state), result);
514
515    return result;
516}
517
518lldb::SBTarget
519SBDebugger::CreateTarget (const char *filename,
520                          const char *target_triple,
521                          const char *platform_name,
522                          bool add_dependent_modules,
523                          lldb::SBError& sb_error)
524{
525    SBTarget sb_target;
526    TargetSP target_sp;
527    if (m_opaque_sp)
528    {
529        sb_error.Clear();
530        OptionGroupPlatform platform_options (false);
531        platform_options.SetPlatformName (platform_name);
532
533        sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp,
534                                                                    filename,
535                                                                    target_triple,
536                                                                    add_dependent_modules,
537                                                                    &platform_options,
538                                                                    target_sp);
539
540        if (sb_error.Success())
541            sb_target.SetSP (target_sp);
542    }
543    else
544    {
545        sb_error.SetErrorString("invalid target");
546    }
547
548    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
549    if (log)
550    {
551        log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, platform_name=%s, add_dependent_modules=%u, error=%s) => SBTarget(%p)",
552                     m_opaque_sp.get(),
553                     filename,
554                     target_triple,
555                     platform_name,
556                     add_dependent_modules,
557                     sb_error.GetCString(),
558                     target_sp.get());
559    }
560
561    return sb_target;
562}
563
564SBTarget
565SBDebugger::CreateTargetWithFileAndTargetTriple (const char *filename,
566                                                 const char *target_triple)
567{
568    SBTarget sb_target;
569    TargetSP target_sp;
570    if (m_opaque_sp)
571    {
572        const bool add_dependent_modules = true;
573        Error error (m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp,
574                                                                filename,
575                                                                target_triple,
576                                                                add_dependent_modules,
577                                                                NULL,
578                                                                target_sp));
579        sb_target.SetSP (target_sp);
580    }
581
582    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
583    if (log)
584    {
585        log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple (filename=\"%s\", triple=%s) => SBTarget(%p)",
586                     m_opaque_sp.get(), filename, target_triple, target_sp.get());
587    }
588
589    return sb_target;
590}
591
592SBTarget
593SBDebugger::CreateTargetWithFileAndArch (const char *filename, const char *arch_cstr)
594{
595    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
596
597    SBTarget sb_target;
598    TargetSP target_sp;
599    if (m_opaque_sp)
600    {
601        Error error;
602        const bool add_dependent_modules = true;
603
604        error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp,
605                                                           filename,
606                                                           arch_cstr,
607                                                           add_dependent_modules,
608                                                           NULL,
609                                                           target_sp);
610
611        if (error.Success())
612        {
613            m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get());
614            sb_target.SetSP (target_sp);
615        }
616    }
617
618    if (log)
619    {
620        log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", arch=%s) => SBTarget(%p)",
621                     m_opaque_sp.get(), filename, arch_cstr, target_sp.get());
622    }
623
624    return sb_target;
625}
626
627SBTarget
628SBDebugger::CreateTarget (const char *filename)
629{
630    SBTarget sb_target;
631    TargetSP target_sp;
632    if (m_opaque_sp)
633    {
634        ArchSpec arch = Target::GetDefaultArchitecture ();
635        Error error;
636        const bool add_dependent_modules = true;
637
638        PlatformSP platform_sp(m_opaque_sp->GetPlatformList().GetSelectedPlatform());
639        error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp,
640                                                           filename,
641                                                           arch,
642                                                           add_dependent_modules,
643                                                           platform_sp,
644                                                           target_sp);
645
646        if (error.Success())
647        {
648            m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get());
649            sb_target.SetSP (target_sp);
650        }
651    }
652    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
653    if (log)
654    {
655        log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)",
656                     m_opaque_sp.get(), filename, target_sp.get());
657    }
658    return sb_target;
659}
660
661bool
662SBDebugger::DeleteTarget (lldb::SBTarget &target)
663{
664    bool result = false;
665    if (m_opaque_sp)
666    {
667        TargetSP target_sp(target.GetSP());
668        if (target_sp)
669        {
670            // No need to lock, the target list is thread safe
671            result = m_opaque_sp->GetTargetList().DeleteTarget (target_sp);
672            target_sp->Destroy();
673            target.Clear();
674            const bool mandatory = true;
675            ModuleList::RemoveOrphanSharedModules(mandatory);
676        }
677    }
678
679    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
680    if (log)
681    {
682        log->Printf ("SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i", m_opaque_sp.get(), target.m_opaque_sp.get(), result);
683    }
684
685    return result;
686}
687SBTarget
688SBDebugger::GetTargetAtIndex (uint32_t idx)
689{
690    SBTarget sb_target;
691    if (m_opaque_sp)
692    {
693        // No need to lock, the target list is thread safe
694        sb_target.SetSP (m_opaque_sp->GetTargetList().GetTargetAtIndex (idx));
695    }
696    return sb_target;
697}
698
699uint32_t
700SBDebugger::GetIndexOfTarget (lldb::SBTarget target)
701{
702
703    lldb::TargetSP target_sp = target.GetSP();
704    if (!target_sp)
705        return UINT32_MAX;
706
707    if (!m_opaque_sp)
708        return UINT32_MAX;
709
710    return m_opaque_sp->GetTargetList().GetIndexOfTarget (target.GetSP());
711}
712
713SBTarget
714SBDebugger::FindTargetWithProcessID (pid_t pid)
715{
716    SBTarget sb_target;
717    if (m_opaque_sp)
718    {
719        // No need to lock, the target list is thread safe
720        sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcessID (pid));
721    }
722    return sb_target;
723}
724
725SBTarget
726SBDebugger::FindTargetWithFileAndArch (const char *filename, const char *arch_name)
727{
728    SBTarget sb_target;
729    if (m_opaque_sp && filename && filename[0])
730    {
731        // No need to lock, the target list is thread safe
732        ArchSpec arch (arch_name, m_opaque_sp->GetPlatformList().GetSelectedPlatform().get());
733        TargetSP target_sp (m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture (FileSpec(filename, false), arch_name ? &arch : NULL));
734        sb_target.SetSP (target_sp);
735    }
736    return sb_target;
737}
738
739SBTarget
740SBDebugger::FindTargetWithLLDBProcess (const ProcessSP &process_sp)
741{
742    SBTarget sb_target;
743    if (m_opaque_sp)
744    {
745        // No need to lock, the target list is thread safe
746        sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcess (process_sp.get()));
747    }
748    return sb_target;
749}
750
751
752uint32_t
753SBDebugger::GetNumTargets ()
754{
755    if (m_opaque_sp)
756    {
757        // No need to lock, the target list is thread safe
758        return m_opaque_sp->GetTargetList().GetNumTargets ();
759    }
760    return 0;
761}
762
763SBTarget
764SBDebugger::GetSelectedTarget ()
765{
766    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
767
768    SBTarget sb_target;
769    TargetSP target_sp;
770    if (m_opaque_sp)
771    {
772        // No need to lock, the target list is thread safe
773        target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget ();
774        sb_target.SetSP (target_sp);
775    }
776
777    if (log)
778    {
779        SBStream sstr;
780        sb_target.GetDescription (sstr, eDescriptionLevelBrief);
781        log->Printf ("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s", m_opaque_sp.get(),
782                     target_sp.get(), sstr.GetData());
783    }
784
785    return sb_target;
786}
787
788void
789SBDebugger::SetSelectedTarget (SBTarget &sb_target)
790{
791    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
792
793    TargetSP target_sp (sb_target.GetSP());
794    if (m_opaque_sp)
795    {
796        m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get());
797    }
798    if (log)
799    {
800        SBStream sstr;
801        sb_target.GetDescription (sstr, eDescriptionLevelBrief);
802        log->Printf ("SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s", m_opaque_sp.get(),
803                     target_sp.get(), sstr.GetData());
804    }
805}
806
807void
808SBDebugger::DispatchInput (void* baton, const void *data, size_t data_len)
809{
810    DispatchInput (data,data_len);
811}
812
813void
814SBDebugger::DispatchInput (const void *data, size_t data_len)
815{
816    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
817
818    if (log)
819        log->Printf ("SBDebugger(%p)::DispatchInput (data=\"%.*s\", size_t=%" PRIu64 ")",
820                     m_opaque_sp.get(),
821                     (int) data_len,
822                     (const char *) data,
823                     (uint64_t)data_len);
824
825    if (m_opaque_sp)
826        m_opaque_sp->DispatchInput ((const char *) data, data_len);
827}
828
829void
830SBDebugger::DispatchInputInterrupt ()
831{
832    if (m_opaque_sp)
833        m_opaque_sp->DispatchInputInterrupt ();
834}
835
836void
837SBDebugger::DispatchInputEndOfFile ()
838{
839    if (m_opaque_sp)
840        m_opaque_sp->DispatchInputEndOfFile ();
841}
842
843bool
844SBDebugger::InputReaderIsTopReader (const lldb::SBInputReader &reader)
845{
846    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
847
848    if (log)
849        log->Printf ("SBDebugger(%p)::InputReaderIsTopReader (SBInputReader(%p))", m_opaque_sp.get(), &reader);
850
851    if (m_opaque_sp && reader.IsValid())
852    {
853        InputReaderSP reader_sp (*reader);
854        return m_opaque_sp->InputReaderIsTopReader (reader_sp);
855    }
856
857    return false;
858}
859
860
861void
862SBDebugger::PushInputReader (SBInputReader &reader)
863{
864    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
865
866    if (log)
867        log->Printf ("SBDebugger(%p)::PushInputReader (SBInputReader(%p))", m_opaque_sp.get(), &reader);
868
869    if (m_opaque_sp && reader.IsValid())
870    {
871        TargetSP target_sp (m_opaque_sp->GetSelectedTarget());
872        Mutex::Locker api_locker;
873        if (target_sp)
874            api_locker.Lock(target_sp->GetAPIMutex());
875        InputReaderSP reader_sp(*reader);
876        m_opaque_sp->PushInputReader (reader_sp);
877    }
878}
879
880void
881SBDebugger::NotifyTopInputReader (InputReaderAction notification)
882{
883    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
884
885    if (log)
886        log->Printf ("SBDebugger(%p)::NotifyTopInputReader (%d)", m_opaque_sp.get(), notification);
887
888    if (m_opaque_sp)
889        m_opaque_sp->NotifyTopInputReader (notification);
890}
891
892void
893SBDebugger::reset (const DebuggerSP &debugger_sp)
894{
895    m_opaque_sp = debugger_sp;
896}
897
898Debugger *
899SBDebugger::get () const
900{
901    return m_opaque_sp.get();
902}
903
904Debugger &
905SBDebugger::ref () const
906{
907    assert (m_opaque_sp.get());
908    return *m_opaque_sp;
909}
910
911const lldb::DebuggerSP &
912SBDebugger::get_sp () const
913{
914    return m_opaque_sp;
915}
916
917SBDebugger
918SBDebugger::FindDebuggerWithID (int id)
919{
920    // No need to lock, the debugger list is thread safe
921    SBDebugger sb_debugger;
922    DebuggerSP debugger_sp = Debugger::FindDebuggerWithID (id);
923    if (debugger_sp)
924        sb_debugger.reset (debugger_sp);
925    return sb_debugger;
926}
927
928const char *
929SBDebugger::GetInstanceName()
930{
931    if (m_opaque_sp)
932        return m_opaque_sp->GetInstanceName().AsCString();
933    else
934        return NULL;
935}
936
937SBError
938SBDebugger::SetInternalVariable (const char *var_name, const char *value, const char *debugger_instance_name)
939{
940    SBError sb_error;
941    DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name)));
942    Error error;
943    if (debugger_sp)
944    {
945        ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext());
946        error = debugger_sp->SetPropertyValue (&exe_ctx,
947                                               eVarSetOperationAssign,
948                                               var_name,
949                                               value);
950    }
951    else
952    {
953        error.SetErrorStringWithFormat ("invalid debugger instance name '%s'", debugger_instance_name);
954    }
955    if (error.Fail())
956        sb_error.SetError(error);
957    return sb_error;
958}
959
960SBStringList
961SBDebugger::GetInternalVariableValue (const char *var_name, const char *debugger_instance_name)
962{
963    SBStringList ret_value;
964    DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name)));
965    Error error;
966    if (debugger_sp)
967    {
968        ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext());
969        lldb::OptionValueSP value_sp (debugger_sp->GetPropertyValue (&exe_ctx,
970                                                                     var_name,
971                                                                     false,
972                                                                     error));
973        if (value_sp)
974        {
975            StreamString value_strm;
976            value_sp->DumpValue (&exe_ctx, value_strm, OptionValue::eDumpOptionValue);
977            const std::string &value_str = value_strm.GetString();
978            if (!value_str.empty())
979            {
980                StringList string_list;
981                string_list.SplitIntoLines(value_str.c_str(), value_str.size());
982                return SBStringList(&string_list);
983            }
984        }
985    }
986    return SBStringList();
987}
988
989uint32_t
990SBDebugger::GetTerminalWidth () const
991{
992    if (m_opaque_sp)
993        return m_opaque_sp->GetTerminalWidth ();
994    return 0;
995}
996
997void
998SBDebugger::SetTerminalWidth (uint32_t term_width)
999{
1000    if (m_opaque_sp)
1001        m_opaque_sp->SetTerminalWidth (term_width);
1002}
1003
1004const char *
1005SBDebugger::GetPrompt() const
1006{
1007    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1008
1009    if (log)
1010        log->Printf ("SBDebugger(%p)::GetPrompt () => \"%s\"", m_opaque_sp.get(),
1011                     (m_opaque_sp ? m_opaque_sp->GetPrompt() : ""));
1012
1013    if (m_opaque_sp)
1014        return m_opaque_sp->GetPrompt ();
1015    return 0;
1016}
1017
1018void
1019SBDebugger::SetPrompt (const char *prompt)
1020{
1021    if (m_opaque_sp)
1022        m_opaque_sp->SetPrompt (prompt);
1023}
1024
1025
1026ScriptLanguage
1027SBDebugger::GetScriptLanguage() const
1028{
1029    if (m_opaque_sp)
1030        return m_opaque_sp->GetScriptLanguage ();
1031    return eScriptLanguageNone;
1032}
1033
1034void
1035SBDebugger::SetScriptLanguage (ScriptLanguage script_lang)
1036{
1037    if (m_opaque_sp)
1038    {
1039        m_opaque_sp->SetScriptLanguage (script_lang);
1040    }
1041}
1042
1043bool
1044SBDebugger::SetUseExternalEditor (bool value)
1045{
1046    if (m_opaque_sp)
1047        return m_opaque_sp->SetUseExternalEditor (value);
1048    return false;
1049}
1050
1051bool
1052SBDebugger::GetUseExternalEditor ()
1053{
1054    if (m_opaque_sp)
1055        return m_opaque_sp->GetUseExternalEditor ();
1056    return false;
1057}
1058
1059bool
1060SBDebugger::SetUseColor (bool value)
1061{
1062    if (m_opaque_sp)
1063        return m_opaque_sp->SetUseColor (value);
1064    return false;
1065}
1066
1067bool
1068SBDebugger::GetUseColor () const
1069{
1070    if (m_opaque_sp)
1071        return m_opaque_sp->GetUseColor ();
1072    return false;
1073}
1074
1075bool
1076SBDebugger::GetDescription (SBStream &description)
1077{
1078    Stream &strm = description.ref();
1079
1080    if (m_opaque_sp)
1081    {
1082        const char *name = m_opaque_sp->GetInstanceName().AsCString();
1083        user_id_t id = m_opaque_sp->GetID();
1084        strm.Printf ("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id);
1085    }
1086    else
1087        strm.PutCString ("No value");
1088
1089    return true;
1090}
1091
1092user_id_t
1093SBDebugger::GetID()
1094{
1095    if (m_opaque_sp)
1096        return m_opaque_sp->GetID();
1097    return LLDB_INVALID_UID;
1098}
1099
1100
1101SBError
1102SBDebugger::SetCurrentPlatform (const char *platform_name)
1103{
1104    SBError sb_error;
1105    if (m_opaque_sp)
1106    {
1107        PlatformSP platform_sp (Platform::Create (platform_name, sb_error.ref()));
1108
1109        if (platform_sp)
1110        {
1111            bool make_selected = true;
1112            m_opaque_sp->GetPlatformList().Append (platform_sp, make_selected);
1113        }
1114    }
1115    return sb_error;
1116}
1117
1118bool
1119SBDebugger::SetCurrentPlatformSDKRoot (const char *sysroot)
1120{
1121    if (m_opaque_sp)
1122    {
1123        PlatformSP platform_sp (m_opaque_sp->GetPlatformList().GetSelectedPlatform());
1124
1125        if (platform_sp)
1126        {
1127            platform_sp->SetSDKRootDirectory (ConstString (sysroot));
1128            return true;
1129        }
1130    }
1131    return false;
1132}
1133
1134bool
1135SBDebugger::GetCloseInputOnEOF () const
1136{
1137    if (m_opaque_sp)
1138        return m_opaque_sp->GetCloseInputOnEOF ();
1139    return false;
1140}
1141
1142void
1143SBDebugger::SetCloseInputOnEOF (bool b)
1144{
1145    if (m_opaque_sp)
1146        m_opaque_sp->SetCloseInputOnEOF (b);
1147}
1148
1149SBTypeCategory
1150SBDebugger::GetCategory (const char* category_name)
1151{
1152    if (!category_name || *category_name == 0)
1153        return SBTypeCategory();
1154
1155    TypeCategoryImplSP category_sp;
1156
1157    if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, false))
1158        return SBTypeCategory(category_sp);
1159    else
1160        return SBTypeCategory();
1161}
1162
1163SBTypeCategory
1164SBDebugger::CreateCategory (const char* category_name)
1165{
1166    if (!category_name || *category_name == 0)
1167        return SBTypeCategory();
1168
1169    TypeCategoryImplSP category_sp;
1170
1171    if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, true))
1172        return SBTypeCategory(category_sp);
1173    else
1174        return SBTypeCategory();
1175}
1176
1177bool
1178SBDebugger::DeleteCategory (const char* category_name)
1179{
1180    if (!category_name || *category_name == 0)
1181        return false;
1182
1183    return DataVisualization::Categories::Delete(ConstString(category_name));
1184}
1185
1186uint32_t
1187SBDebugger::GetNumCategories()
1188{
1189    return DataVisualization::Categories::GetCount();
1190}
1191
1192SBTypeCategory
1193SBDebugger::GetCategoryAtIndex (uint32_t index)
1194{
1195    return SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index));
1196}
1197
1198SBTypeCategory
1199SBDebugger::GetDefaultCategory()
1200{
1201    return GetCategory("default");
1202}
1203
1204SBTypeFormat
1205SBDebugger::GetFormatForType (SBTypeNameSpecifier type_name)
1206{
1207    SBTypeCategory default_category_sb = GetDefaultCategory();
1208    if (default_category_sb.GetEnabled())
1209        return default_category_sb.GetFormatForType(type_name);
1210    return SBTypeFormat();
1211}
1212
1213#ifndef LLDB_DISABLE_PYTHON
1214SBTypeSummary
1215SBDebugger::GetSummaryForType (SBTypeNameSpecifier type_name)
1216{
1217    if (type_name.IsValid() == false)
1218        return SBTypeSummary();
1219    return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()));
1220}
1221#endif // LLDB_DISABLE_PYTHON
1222
1223SBTypeFilter
1224SBDebugger::GetFilterForType (SBTypeNameSpecifier type_name)
1225{
1226    if (type_name.IsValid() == false)
1227        return SBTypeFilter();
1228    return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()));
1229}
1230
1231#ifndef LLDB_DISABLE_PYTHON
1232SBTypeSynthetic
1233SBDebugger::GetSyntheticForType (SBTypeNameSpecifier type_name)
1234{
1235    if (type_name.IsValid() == false)
1236        return SBTypeSynthetic();
1237    return SBTypeSynthetic(DataVisualization::GetSyntheticForType(type_name.GetSP()));
1238}
1239#endif // LLDB_DISABLE_PYTHON
1240
1241bool
1242SBDebugger::EnableLog (const char *channel, const char **categories)
1243{
1244    if (m_opaque_sp)
1245    {
1246        uint32_t log_options = LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
1247        StreamString errors;
1248        return m_opaque_sp->EnableLog (channel, categories, NULL, log_options, errors);
1249
1250    }
1251    else
1252        return false;
1253}
1254
1255void
1256SBDebugger::SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton)
1257{
1258    if (m_opaque_sp)
1259    {
1260        return m_opaque_sp->SetLoggingCallback (log_callback, baton);
1261    }
1262}
1263
1264
1265