SBDebugger.cpp revision 263367
1254721Semaste//===-- SBDebugger.cpp ------------------------------------------*- C++ -*-===//
2254721Semaste//
3254721Semaste//                     The LLVM Compiler Infrastructure
4254721Semaste//
5254721Semaste// This file is distributed under the University of Illinois Open Source
6254721Semaste// License. See LICENSE.TXT for details.
7254721Semaste//
8254721Semaste//===----------------------------------------------------------------------===//
9254721Semaste
10254721Semaste#include "lldb/lldb-python.h"
11254721Semaste
12254721Semaste#include "lldb/API/SBDebugger.h"
13254721Semaste
14254721Semaste#include "lldb/lldb-private.h"
15254721Semaste
16254721Semaste#include "lldb/API/SBListener.h"
17254721Semaste#include "lldb/API/SBBroadcaster.h"
18254721Semaste#include "lldb/API/SBCommandInterpreter.h"
19254721Semaste#include "lldb/API/SBCommandReturnObject.h"
20254721Semaste#include "lldb/API/SBError.h"
21254721Semaste#include "lldb/API/SBEvent.h"
22254721Semaste#include "lldb/API/SBFrame.h"
23254721Semaste#include "lldb/API/SBInputReader.h"
24254721Semaste#include "lldb/API/SBProcess.h"
25254721Semaste#include "lldb/API/SBSourceManager.h"
26254721Semaste#include "lldb/API/SBStream.h"
27254721Semaste#include "lldb/API/SBStringList.h"
28254721Semaste#include "lldb/API/SBTarget.h"
29254721Semaste#include "lldb/API/SBThread.h"
30254721Semaste#include "lldb/API/SBTypeCategory.h"
31254721Semaste#include "lldb/API/SBTypeFormat.h"
32254721Semaste#include "lldb/API/SBTypeFilter.h"
33254721Semaste#include "lldb/API/SBTypeNameSpecifier.h"
34254721Semaste#include "lldb/API/SBTypeSummary.h"
35254721Semaste#include "lldb/API/SBTypeSynthetic.h"
36254721Semaste
37254721Semaste
38254721Semaste#include "lldb/Core/Debugger.h"
39254721Semaste#include "lldb/Core/State.h"
40254721Semaste#include "lldb/DataFormatters/DataVisualization.h"
41263367Semaste#include "lldb/Host/DynamicLibrary.h"
42254721Semaste#include "lldb/Interpreter/Args.h"
43254721Semaste#include "lldb/Interpreter/CommandInterpreter.h"
44254721Semaste#include "lldb/Interpreter/OptionGroupPlatform.h"
45254721Semaste#include "lldb/Target/Process.h"
46254721Semaste#include "lldb/Target/TargetList.h"
47254721Semaste
48254721Semasteusing namespace lldb;
49254721Semasteusing namespace lldb_private;
50254721Semaste
51263367Semaste
52263367Semastestatic lldb::DynamicLibrarySP
53263367SemasteLoadPlugin (const lldb::DebuggerSP &debugger_sp, const FileSpec& spec, Error& error)
54263367Semaste{
55263367Semaste    lldb::DynamicLibrarySP dynlib_sp(new lldb_private::DynamicLibrary(spec));
56263367Semaste    if (dynlib_sp && dynlib_sp->IsValid())
57263367Semaste    {
58263367Semaste        typedef bool (*LLDBCommandPluginInit) (lldb::SBDebugger& debugger);
59263367Semaste
60263367Semaste        lldb::SBDebugger debugger_sb(debugger_sp);
61263367Semaste        // This calls the bool lldb::PluginInitialize(lldb::SBDebugger debugger) function.
62263367Semaste        // TODO: mangle this differently for your system - on OSX, the first underscore needs to be removed and the second one stays
63263367Semaste        LLDBCommandPluginInit init_func = dynlib_sp->GetSymbol<LLDBCommandPluginInit>("_ZN4lldb16PluginInitializeENS_10SBDebuggerE");
64263367Semaste        if (init_func)
65263367Semaste        {
66263367Semaste            if (init_func(debugger_sb))
67263367Semaste                return dynlib_sp;
68263367Semaste            else
69263367Semaste                error.SetErrorString("plug-in refused to load (lldb::PluginInitialize(lldb::SBDebugger) returned false)");
70263367Semaste        }
71263367Semaste        else
72263367Semaste        {
73263367Semaste            error.SetErrorString("plug-in is missing the required initialization: lldb::PluginInitialize(lldb::SBDebugger)");
74263367Semaste        }
75263367Semaste    }
76263367Semaste    else
77263367Semaste    {
78263367Semaste        if (spec.Exists())
79263367Semaste            error.SetErrorString("this file does not represent a loadable dylib");
80263367Semaste        else
81263367Semaste            error.SetErrorString("no such file");
82263367Semaste    }
83263367Semaste    return lldb::DynamicLibrarySP();
84263367Semaste}
85263367Semaste
86254721Semastevoid
87254721SemasteSBDebugger::Initialize ()
88254721Semaste{
89254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
90254721Semaste
91254721Semaste    if (log)
92254721Semaste        log->Printf ("SBDebugger::Initialize ()");
93254721Semaste
94254721Semaste    SBCommandInterpreter::InitializeSWIG ();
95254721Semaste
96263367Semaste    Debugger::Initialize(LoadPlugin);
97254721Semaste}
98254721Semaste
99254721Semastevoid
100254721SemasteSBDebugger::Terminate ()
101254721Semaste{
102254721Semaste    Debugger::Terminate();
103254721Semaste}
104254721Semaste
105254721Semastevoid
106254721SemasteSBDebugger::Clear ()
107254721Semaste{
108254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
109254721Semaste
110254721Semaste    if (log)
111254721Semaste        log->Printf ("SBDebugger(%p)::Clear ()", m_opaque_sp.get());
112254721Semaste
113254721Semaste    if (m_opaque_sp)
114254721Semaste        m_opaque_sp->CleanUpInputReaders ();
115254721Semaste
116254721Semaste    m_opaque_sp.reset();
117254721Semaste}
118254721Semaste
119254721SemasteSBDebugger
120254721SemasteSBDebugger::Create()
121254721Semaste{
122254721Semaste    return SBDebugger::Create(false, NULL, NULL);
123254721Semaste}
124254721Semaste
125254721SemasteSBDebugger
126254721SemasteSBDebugger::Create(bool source_init_files)
127254721Semaste{
128254721Semaste    return SBDebugger::Create (source_init_files, NULL, NULL);
129254721Semaste}
130254721Semaste
131254721SemasteSBDebugger
132254721SemasteSBDebugger::Create(bool source_init_files, lldb::LogOutputCallback callback, void *baton)
133254721Semaste
134254721Semaste{
135254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
136254721Semaste
137254721Semaste    SBDebugger debugger;
138254721Semaste    debugger.reset(Debugger::CreateInstance(callback, baton));
139254721Semaste
140254721Semaste    if (log)
141254721Semaste    {
142254721Semaste        SBStream sstr;
143254721Semaste        debugger.GetDescription (sstr);
144254721Semaste        log->Printf ("SBDebugger::Create () => SBDebugger(%p): %s", debugger.m_opaque_sp.get(), sstr.GetData());
145254721Semaste    }
146254721Semaste
147254721Semaste    SBCommandInterpreter interp = debugger.GetCommandInterpreter();
148254721Semaste    if (source_init_files)
149254721Semaste    {
150254721Semaste        interp.get()->SkipLLDBInitFiles(false);
151254721Semaste        interp.get()->SkipAppInitFiles (false);
152254721Semaste        SBCommandReturnObject result;
153254721Semaste        interp.SourceInitFileInHomeDirectory(result);
154254721Semaste    }
155254721Semaste    else
156254721Semaste    {
157254721Semaste        interp.get()->SkipLLDBInitFiles(true);
158254721Semaste        interp.get()->SkipAppInitFiles (true);
159254721Semaste    }
160254721Semaste    return debugger;
161254721Semaste}
162254721Semaste
163254721Semastevoid
164254721SemasteSBDebugger::Destroy (SBDebugger &debugger)
165254721Semaste{
166254721Semaste    Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
167254721Semaste
168254721Semaste    if (log)
169254721Semaste    {
170254721Semaste        SBStream sstr;
171254721Semaste        debugger.GetDescription (sstr);
172254721Semaste        log->Printf ("SBDebugger::Destroy () => SBDebugger(%p): %s", debugger.m_opaque_sp.get(), sstr.GetData());
173254721Semaste    }
174254721Semaste
175254721Semaste    Debugger::Destroy (debugger.m_opaque_sp);
176254721Semaste
177254721Semaste    if (debugger.m_opaque_sp.get() != NULL)
178254721Semaste        debugger.m_opaque_sp.reset();
179254721Semaste}
180254721Semaste
181254721Semastevoid
182254721SemasteSBDebugger::MemoryPressureDetected ()
183254721Semaste{
184254721Semaste    // Since this function can be call asynchronously, we allow it to be
185254721Semaste    // non-mandatory. We have seen deadlocks with this function when called
186254721Semaste    // so we need to safeguard against this until we can determine what is
187254721Semaste    // causing the deadlocks.
188254721Semaste    Log *log (GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
189254721Semaste
190254721Semaste    const bool mandatory = false;
191254721Semaste    if (log)
192254721Semaste    {
193254721Semaste        log->Printf ("SBDebugger::MemoryPressureDetected (), mandatory = %d", mandatory);
194254721Semaste    }
195254721Semaste
196254721Semaste    ModuleList::RemoveOrphanSharedModules(mandatory);
197254721Semaste}
198254721Semaste
199254721SemasteSBDebugger::SBDebugger () :
200254721Semaste    m_opaque_sp ()
201254721Semaste{
202254721Semaste}
203254721Semaste
204254721SemasteSBDebugger::SBDebugger(const lldb::DebuggerSP &debugger_sp) :
205254721Semaste    m_opaque_sp(debugger_sp)
206254721Semaste{
207254721Semaste}
208254721Semaste
209254721SemasteSBDebugger::SBDebugger(const SBDebugger &rhs) :
210254721Semaste    m_opaque_sp (rhs.m_opaque_sp)
211254721Semaste{
212254721Semaste}
213254721Semaste
214254721SemasteSBDebugger &
215254721SemasteSBDebugger::operator = (const SBDebugger &rhs)
216254721Semaste{
217254721Semaste    if (this != &rhs)
218254721Semaste    {
219254721Semaste        m_opaque_sp = rhs.m_opaque_sp;
220254721Semaste    }
221254721Semaste    return *this;
222254721Semaste}
223254721Semaste
224254721SemasteSBDebugger::~SBDebugger ()
225254721Semaste{
226254721Semaste}
227254721Semaste
228254721Semastebool
229254721SemasteSBDebugger::IsValid() const
230254721Semaste{
231254721Semaste    return m_opaque_sp.get() != NULL;
232254721Semaste}
233254721Semaste
234254721Semaste
235254721Semastevoid
236254721SemasteSBDebugger::SetAsync (bool b)
237254721Semaste{
238254721Semaste    if (m_opaque_sp)
239254721Semaste        m_opaque_sp->SetAsyncExecution(b);
240254721Semaste}
241254721Semaste
242254721Semastebool
243254721SemasteSBDebugger::GetAsync ()
244254721Semaste{
245254721Semaste    if (m_opaque_sp)
246254721Semaste        return m_opaque_sp->GetAsyncExecution();
247254721Semaste    else
248254721Semaste        return false;
249254721Semaste}
250254721Semaste
251254721Semastevoid
252254721SemasteSBDebugger::SkipLLDBInitFiles (bool b)
253254721Semaste{
254254721Semaste    if (m_opaque_sp)
255254721Semaste        m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles (b);
256254721Semaste}
257254721Semaste
258254721Semastevoid
259254721SemasteSBDebugger::SkipAppInitFiles (bool b)
260254721Semaste{
261254721Semaste    if (m_opaque_sp)
262254721Semaste        m_opaque_sp->GetCommandInterpreter().SkipAppInitFiles (b);
263254721Semaste}
264254721Semaste
265254721Semaste// Shouldn't really be settable after initialization as this could cause lots of problems; don't want users
266254721Semaste// trying to switch modes in the middle of a debugging session.
267254721Semastevoid
268254721SemasteSBDebugger::SetInputFileHandle (FILE *fh, bool transfer_ownership)
269254721Semaste{
270254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
271254721Semaste
272254721Semaste    if (log)
273254721Semaste        log->Printf ("SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(),
274254721Semaste                     fh, transfer_ownership);
275254721Semaste
276254721Semaste    if (m_opaque_sp)
277254721Semaste        m_opaque_sp->SetInputFileHandle (fh, transfer_ownership);
278254721Semaste}
279254721Semaste
280254721Semastevoid
281254721SemasteSBDebugger::SetOutputFileHandle (FILE *fh, bool transfer_ownership)
282254721Semaste{
283254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
284254721Semaste
285254721Semaste
286254721Semaste    if (log)
287254721Semaste        log->Printf ("SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(),
288254721Semaste                     fh, transfer_ownership);
289254721Semaste
290254721Semaste    if (m_opaque_sp)
291254721Semaste        m_opaque_sp->SetOutputFileHandle (fh, transfer_ownership);
292254721Semaste}
293254721Semaste
294254721Semastevoid
295254721SemasteSBDebugger::SetErrorFileHandle (FILE *fh, bool transfer_ownership)
296254721Semaste{
297254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
298254721Semaste
299254721Semaste
300254721Semaste    if (log)
301254721Semaste        log->Printf ("SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(),
302254721Semaste                     fh, transfer_ownership);
303254721Semaste
304254721Semaste    if (m_opaque_sp)
305254721Semaste        m_opaque_sp->SetErrorFileHandle (fh, transfer_ownership);
306254721Semaste}
307254721Semaste
308254721SemasteFILE *
309254721SemasteSBDebugger::GetInputFileHandle ()
310254721Semaste{
311254721Semaste    if (m_opaque_sp)
312254721Semaste        return m_opaque_sp->GetInputFile().GetStream();
313254721Semaste    return NULL;
314254721Semaste}
315254721Semaste
316254721SemasteFILE *
317254721SemasteSBDebugger::GetOutputFileHandle ()
318254721Semaste{
319254721Semaste    if (m_opaque_sp)
320254721Semaste        return m_opaque_sp->GetOutputFile().GetStream();
321254721Semaste    return NULL;
322254721Semaste}
323254721Semaste
324254721SemasteFILE *
325254721SemasteSBDebugger::GetErrorFileHandle ()
326254721Semaste{
327254721Semaste    if (m_opaque_sp)
328254721Semaste        return m_opaque_sp->GetErrorFile().GetStream();
329254721Semaste    return NULL;
330254721Semaste}
331254721Semaste
332254721Semastevoid
333254721SemasteSBDebugger::SaveInputTerminalState()
334254721Semaste{
335254721Semaste    if (m_opaque_sp)
336254721Semaste        m_opaque_sp->SaveInputTerminalState();
337254721Semaste}
338254721Semaste
339254721Semastevoid
340254721SemasteSBDebugger::RestoreInputTerminalState()
341254721Semaste{
342254721Semaste    if (m_opaque_sp)
343254721Semaste        m_opaque_sp->RestoreInputTerminalState();
344254721Semaste
345254721Semaste}
346254721SemasteSBCommandInterpreter
347254721SemasteSBDebugger::GetCommandInterpreter ()
348254721Semaste{
349254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
350254721Semaste
351254721Semaste    SBCommandInterpreter sb_interpreter;
352254721Semaste    if (m_opaque_sp)
353254721Semaste        sb_interpreter.reset (&m_opaque_sp->GetCommandInterpreter());
354254721Semaste
355254721Semaste    if (log)
356254721Semaste        log->Printf ("SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)",
357254721Semaste                     m_opaque_sp.get(), sb_interpreter.get());
358254721Semaste
359254721Semaste    return sb_interpreter;
360254721Semaste}
361254721Semaste
362254721Semastevoid
363254721SemasteSBDebugger::HandleCommand (const char *command)
364254721Semaste{
365254721Semaste    if (m_opaque_sp)
366254721Semaste    {
367254721Semaste        TargetSP target_sp (m_opaque_sp->GetSelectedTarget());
368254721Semaste        Mutex::Locker api_locker;
369254721Semaste        if (target_sp)
370254721Semaste            api_locker.Lock(target_sp->GetAPIMutex());
371254721Semaste
372254721Semaste        SBCommandInterpreter sb_interpreter(GetCommandInterpreter ());
373254721Semaste        SBCommandReturnObject result;
374254721Semaste
375254721Semaste        sb_interpreter.HandleCommand (command, result, false);
376254721Semaste
377254721Semaste        if (GetErrorFileHandle() != NULL)
378254721Semaste            result.PutError (GetErrorFileHandle());
379254721Semaste        if (GetOutputFileHandle() != NULL)
380254721Semaste            result.PutOutput (GetOutputFileHandle());
381254721Semaste
382254721Semaste        if (m_opaque_sp->GetAsyncExecution() == false)
383254721Semaste        {
384254721Semaste            SBProcess process(GetCommandInterpreter().GetProcess ());
385254721Semaste            ProcessSP process_sp (process.GetSP());
386254721Semaste            if (process_sp)
387254721Semaste            {
388254721Semaste                EventSP event_sp;
389254721Semaste                Listener &lldb_listener = m_opaque_sp->GetListener();
390254721Semaste                while (lldb_listener.GetNextEventForBroadcaster (process_sp.get(), event_sp))
391254721Semaste                {
392254721Semaste                    SBEvent event(event_sp);
393254721Semaste                    HandleProcessEvent (process, event, GetOutputFileHandle(), GetErrorFileHandle());
394254721Semaste                }
395254721Semaste            }
396254721Semaste        }
397254721Semaste    }
398254721Semaste}
399254721Semaste
400254721SemasteSBListener
401254721SemasteSBDebugger::GetListener ()
402254721Semaste{
403254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
404254721Semaste
405254721Semaste    SBListener sb_listener;
406254721Semaste    if (m_opaque_sp)
407254721Semaste        sb_listener.reset(&m_opaque_sp->GetListener(), false);
408254721Semaste
409254721Semaste    if (log)
410254721Semaste        log->Printf ("SBDebugger(%p)::GetListener () => SBListener(%p)", m_opaque_sp.get(),
411254721Semaste                     sb_listener.get());
412254721Semaste
413254721Semaste    return sb_listener;
414254721Semaste}
415254721Semaste
416254721Semastevoid
417254721SemasteSBDebugger::HandleProcessEvent (const SBProcess &process, const SBEvent &event, FILE *out, FILE *err)
418254721Semaste{
419254721Semaste    if (!process.IsValid())
420254721Semaste        return;
421254721Semaste
422254721Semaste    TargetSP target_sp (process.GetTarget().GetSP());
423254721Semaste    if (!target_sp)
424254721Semaste        return;
425254721Semaste
426254721Semaste    const uint32_t event_type = event.GetType();
427254721Semaste    char stdio_buffer[1024];
428254721Semaste    size_t len;
429254721Semaste
430254721Semaste    Mutex::Locker api_locker (target_sp->GetAPIMutex());
431254721Semaste
432254721Semaste    if (event_type & (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged))
433254721Semaste    {
434254721Semaste        // Drain stdout when we stop just in case we have any bytes
435254721Semaste        while ((len = process.GetSTDOUT (stdio_buffer, sizeof (stdio_buffer))) > 0)
436254721Semaste            if (out != NULL)
437254721Semaste                ::fwrite (stdio_buffer, 1, len, out);
438254721Semaste    }
439254721Semaste
440254721Semaste    if (event_type & (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged))
441254721Semaste    {
442254721Semaste        // Drain stderr when we stop just in case we have any bytes
443254721Semaste        while ((len = process.GetSTDERR (stdio_buffer, sizeof (stdio_buffer))) > 0)
444254721Semaste            if (err != NULL)
445254721Semaste                ::fwrite (stdio_buffer, 1, len, err);
446254721Semaste    }
447254721Semaste
448254721Semaste    if (event_type & Process::eBroadcastBitStateChanged)
449254721Semaste    {
450254721Semaste        StateType event_state = SBProcess::GetStateFromEvent (event);
451254721Semaste
452254721Semaste        if (event_state == eStateInvalid)
453254721Semaste            return;
454254721Semaste
455254721Semaste        bool is_stopped = StateIsStoppedState (event_state);
456254721Semaste        if (!is_stopped)
457254721Semaste            process.ReportEventState (event, out);
458254721Semaste    }
459254721Semaste}
460254721Semaste
461254721SemasteSBSourceManager
462254721SemasteSBDebugger::GetSourceManager ()
463254721Semaste{
464254721Semaste    SBSourceManager sb_source_manager (*this);
465254721Semaste    return sb_source_manager;
466254721Semaste}
467254721Semaste
468254721Semaste
469254721Semastebool
470254721SemasteSBDebugger::GetDefaultArchitecture (char *arch_name, size_t arch_name_len)
471254721Semaste{
472254721Semaste    if (arch_name && arch_name_len)
473254721Semaste    {
474254721Semaste        ArchSpec default_arch = Target::GetDefaultArchitecture ();
475254721Semaste
476254721Semaste        if (default_arch.IsValid())
477254721Semaste        {
478254721Semaste            const std::string &triple_str = default_arch.GetTriple().str();
479254721Semaste            if (!triple_str.empty())
480254721Semaste                ::snprintf (arch_name, arch_name_len, "%s", triple_str.c_str());
481254721Semaste            else
482254721Semaste                ::snprintf (arch_name, arch_name_len, "%s", default_arch.GetArchitectureName());
483254721Semaste            return true;
484254721Semaste        }
485254721Semaste    }
486254721Semaste    if (arch_name && arch_name_len)
487254721Semaste        arch_name[0] = '\0';
488254721Semaste    return false;
489254721Semaste}
490254721Semaste
491254721Semaste
492254721Semastebool
493254721SemasteSBDebugger::SetDefaultArchitecture (const char *arch_name)
494254721Semaste{
495254721Semaste    if (arch_name)
496254721Semaste    {
497254721Semaste        ArchSpec arch (arch_name);
498254721Semaste        if (arch.IsValid())
499254721Semaste        {
500254721Semaste            Target::SetDefaultArchitecture (arch);
501254721Semaste            return true;
502254721Semaste        }
503254721Semaste    }
504254721Semaste    return false;
505254721Semaste}
506254721Semaste
507254721SemasteScriptLanguage
508254721SemasteSBDebugger::GetScriptingLanguage (const char *script_language_name)
509254721Semaste{
510254721Semaste
511254721Semaste    return Args::StringToScriptLanguage (script_language_name,
512254721Semaste                                         eScriptLanguageDefault,
513254721Semaste                                         NULL);
514254721Semaste}
515254721Semaste
516254721Semasteconst char *
517254721SemasteSBDebugger::GetVersionString ()
518254721Semaste{
519263363Semaste    return lldb_private::GetVersion();
520254721Semaste}
521254721Semaste
522254721Semasteconst char *
523254721SemasteSBDebugger::StateAsCString (StateType state)
524254721Semaste{
525254721Semaste    return lldb_private::StateAsCString (state);
526254721Semaste}
527254721Semaste
528254721Semastebool
529254721SemasteSBDebugger::StateIsRunningState (StateType state)
530254721Semaste{
531254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
532254721Semaste
533254721Semaste    const bool result = lldb_private::StateIsRunningState (state);
534254721Semaste    if (log)
535254721Semaste        log->Printf ("SBDebugger::StateIsRunningState (state=%s) => %i",
536254721Semaste                     StateAsCString (state), result);
537254721Semaste
538254721Semaste    return result;
539254721Semaste}
540254721Semaste
541254721Semastebool
542254721SemasteSBDebugger::StateIsStoppedState (StateType state)
543254721Semaste{
544254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
545254721Semaste
546254721Semaste    const bool result = lldb_private::StateIsStoppedState (state, false);
547254721Semaste    if (log)
548254721Semaste        log->Printf ("SBDebugger::StateIsStoppedState (state=%s) => %i",
549254721Semaste                     StateAsCString (state), result);
550254721Semaste
551254721Semaste    return result;
552254721Semaste}
553254721Semaste
554254721Semastelldb::SBTarget
555254721SemasteSBDebugger::CreateTarget (const char *filename,
556254721Semaste                          const char *target_triple,
557254721Semaste                          const char *platform_name,
558254721Semaste                          bool add_dependent_modules,
559254721Semaste                          lldb::SBError& sb_error)
560254721Semaste{
561254721Semaste    SBTarget sb_target;
562254721Semaste    TargetSP target_sp;
563254721Semaste    if (m_opaque_sp)
564254721Semaste    {
565254721Semaste        sb_error.Clear();
566254721Semaste        OptionGroupPlatform platform_options (false);
567254721Semaste        platform_options.SetPlatformName (platform_name);
568254721Semaste
569254721Semaste        sb_error.ref() = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp,
570254721Semaste                                                                    filename,
571254721Semaste                                                                    target_triple,
572254721Semaste                                                                    add_dependent_modules,
573254721Semaste                                                                    &platform_options,
574254721Semaste                                                                    target_sp);
575254721Semaste
576254721Semaste        if (sb_error.Success())
577254721Semaste            sb_target.SetSP (target_sp);
578254721Semaste    }
579254721Semaste    else
580254721Semaste    {
581254721Semaste        sb_error.SetErrorString("invalid target");
582254721Semaste    }
583254721Semaste
584254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
585254721Semaste    if (log)
586254721Semaste    {
587254721Semaste        log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\", triple=%s, platform_name=%s, add_dependent_modules=%u, error=%s) => SBTarget(%p)",
588254721Semaste                     m_opaque_sp.get(),
589254721Semaste                     filename,
590254721Semaste                     target_triple,
591254721Semaste                     platform_name,
592254721Semaste                     add_dependent_modules,
593254721Semaste                     sb_error.GetCString(),
594254721Semaste                     target_sp.get());
595254721Semaste    }
596254721Semaste
597254721Semaste    return sb_target;
598254721Semaste}
599254721Semaste
600254721SemasteSBTarget
601254721SemasteSBDebugger::CreateTargetWithFileAndTargetTriple (const char *filename,
602254721Semaste                                                 const char *target_triple)
603254721Semaste{
604254721Semaste    SBTarget sb_target;
605254721Semaste    TargetSP target_sp;
606254721Semaste    if (m_opaque_sp)
607254721Semaste    {
608254721Semaste        const bool add_dependent_modules = true;
609254721Semaste        Error error (m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp,
610254721Semaste                                                                filename,
611254721Semaste                                                                target_triple,
612254721Semaste                                                                add_dependent_modules,
613254721Semaste                                                                NULL,
614254721Semaste                                                                target_sp));
615254721Semaste        sb_target.SetSP (target_sp);
616254721Semaste    }
617254721Semaste
618254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
619254721Semaste    if (log)
620254721Semaste    {
621254721Semaste        log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple (filename=\"%s\", triple=%s) => SBTarget(%p)",
622254721Semaste                     m_opaque_sp.get(), filename, target_triple, target_sp.get());
623254721Semaste    }
624254721Semaste
625254721Semaste    return sb_target;
626254721Semaste}
627254721Semaste
628254721SemasteSBTarget
629254721SemasteSBDebugger::CreateTargetWithFileAndArch (const char *filename, const char *arch_cstr)
630254721Semaste{
631254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
632254721Semaste
633254721Semaste    SBTarget sb_target;
634254721Semaste    TargetSP target_sp;
635254721Semaste    if (m_opaque_sp)
636254721Semaste    {
637254721Semaste        Error error;
638254721Semaste        const bool add_dependent_modules = true;
639254721Semaste
640254721Semaste        error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp,
641254721Semaste                                                           filename,
642254721Semaste                                                           arch_cstr,
643254721Semaste                                                           add_dependent_modules,
644254721Semaste                                                           NULL,
645254721Semaste                                                           target_sp);
646254721Semaste
647254721Semaste        if (error.Success())
648254721Semaste        {
649254721Semaste            m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get());
650254721Semaste            sb_target.SetSP (target_sp);
651254721Semaste        }
652254721Semaste    }
653254721Semaste
654254721Semaste    if (log)
655254721Semaste    {
656254721Semaste        log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", arch=%s) => SBTarget(%p)",
657254721Semaste                     m_opaque_sp.get(), filename, arch_cstr, target_sp.get());
658254721Semaste    }
659254721Semaste
660254721Semaste    return sb_target;
661254721Semaste}
662254721Semaste
663254721SemasteSBTarget
664254721SemasteSBDebugger::CreateTarget (const char *filename)
665254721Semaste{
666254721Semaste    SBTarget sb_target;
667254721Semaste    TargetSP target_sp;
668254721Semaste    if (m_opaque_sp)
669254721Semaste    {
670254721Semaste        ArchSpec arch = Target::GetDefaultArchitecture ();
671254721Semaste        Error error;
672254721Semaste        const bool add_dependent_modules = true;
673254721Semaste
674254721Semaste        PlatformSP platform_sp(m_opaque_sp->GetPlatformList().GetSelectedPlatform());
675254721Semaste        error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp,
676254721Semaste                                                           filename,
677254721Semaste                                                           arch,
678254721Semaste                                                           add_dependent_modules,
679254721Semaste                                                           platform_sp,
680254721Semaste                                                           target_sp);
681254721Semaste
682254721Semaste        if (error.Success())
683254721Semaste        {
684254721Semaste            m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get());
685254721Semaste            sb_target.SetSP (target_sp);
686254721Semaste        }
687254721Semaste    }
688254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
689254721Semaste    if (log)
690254721Semaste    {
691254721Semaste        log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)",
692254721Semaste                     m_opaque_sp.get(), filename, target_sp.get());
693254721Semaste    }
694254721Semaste    return sb_target;
695254721Semaste}
696254721Semaste
697254721Semastebool
698254721SemasteSBDebugger::DeleteTarget (lldb::SBTarget &target)
699254721Semaste{
700254721Semaste    bool result = false;
701254721Semaste    if (m_opaque_sp)
702254721Semaste    {
703254721Semaste        TargetSP target_sp(target.GetSP());
704254721Semaste        if (target_sp)
705254721Semaste        {
706254721Semaste            // No need to lock, the target list is thread safe
707254721Semaste            result = m_opaque_sp->GetTargetList().DeleteTarget (target_sp);
708254721Semaste            target_sp->Destroy();
709254721Semaste            target.Clear();
710254721Semaste            const bool mandatory = true;
711254721Semaste            ModuleList::RemoveOrphanSharedModules(mandatory);
712254721Semaste        }
713254721Semaste    }
714254721Semaste
715254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
716254721Semaste    if (log)
717254721Semaste    {
718254721Semaste        log->Printf ("SBDebugger(%p)::DeleteTarget (SBTarget(%p)) => %i", m_opaque_sp.get(), target.m_opaque_sp.get(), result);
719254721Semaste    }
720254721Semaste
721254721Semaste    return result;
722254721Semaste}
723254721SemasteSBTarget
724254721SemasteSBDebugger::GetTargetAtIndex (uint32_t idx)
725254721Semaste{
726254721Semaste    SBTarget sb_target;
727254721Semaste    if (m_opaque_sp)
728254721Semaste    {
729254721Semaste        // No need to lock, the target list is thread safe
730254721Semaste        sb_target.SetSP (m_opaque_sp->GetTargetList().GetTargetAtIndex (idx));
731254721Semaste    }
732254721Semaste    return sb_target;
733254721Semaste}
734254721Semaste
735254721Semasteuint32_t
736254721SemasteSBDebugger::GetIndexOfTarget (lldb::SBTarget target)
737254721Semaste{
738254721Semaste
739254721Semaste    lldb::TargetSP target_sp = target.GetSP();
740254721Semaste    if (!target_sp)
741254721Semaste        return UINT32_MAX;
742254721Semaste
743254721Semaste    if (!m_opaque_sp)
744254721Semaste        return UINT32_MAX;
745254721Semaste
746254721Semaste    return m_opaque_sp->GetTargetList().GetIndexOfTarget (target.GetSP());
747254721Semaste}
748254721Semaste
749254721SemasteSBTarget
750263363SemasteSBDebugger::FindTargetWithProcessID (lldb::pid_t pid)
751254721Semaste{
752254721Semaste    SBTarget sb_target;
753254721Semaste    if (m_opaque_sp)
754254721Semaste    {
755254721Semaste        // No need to lock, the target list is thread safe
756254721Semaste        sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcessID (pid));
757254721Semaste    }
758254721Semaste    return sb_target;
759254721Semaste}
760254721Semaste
761254721SemasteSBTarget
762254721SemasteSBDebugger::FindTargetWithFileAndArch (const char *filename, const char *arch_name)
763254721Semaste{
764254721Semaste    SBTarget sb_target;
765254721Semaste    if (m_opaque_sp && filename && filename[0])
766254721Semaste    {
767254721Semaste        // No need to lock, the target list is thread safe
768254721Semaste        ArchSpec arch (arch_name, m_opaque_sp->GetPlatformList().GetSelectedPlatform().get());
769254721Semaste        TargetSP target_sp (m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture (FileSpec(filename, false), arch_name ? &arch : NULL));
770254721Semaste        sb_target.SetSP (target_sp);
771254721Semaste    }
772254721Semaste    return sb_target;
773254721Semaste}
774254721Semaste
775254721SemasteSBTarget
776254721SemasteSBDebugger::FindTargetWithLLDBProcess (const ProcessSP &process_sp)
777254721Semaste{
778254721Semaste    SBTarget sb_target;
779254721Semaste    if (m_opaque_sp)
780254721Semaste    {
781254721Semaste        // No need to lock, the target list is thread safe
782254721Semaste        sb_target.SetSP (m_opaque_sp->GetTargetList().FindTargetWithProcess (process_sp.get()));
783254721Semaste    }
784254721Semaste    return sb_target;
785254721Semaste}
786254721Semaste
787254721Semaste
788254721Semasteuint32_t
789254721SemasteSBDebugger::GetNumTargets ()
790254721Semaste{
791254721Semaste    if (m_opaque_sp)
792254721Semaste    {
793254721Semaste        // No need to lock, the target list is thread safe
794254721Semaste        return m_opaque_sp->GetTargetList().GetNumTargets ();
795254721Semaste    }
796254721Semaste    return 0;
797254721Semaste}
798254721Semaste
799254721SemasteSBTarget
800254721SemasteSBDebugger::GetSelectedTarget ()
801254721Semaste{
802254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
803254721Semaste
804254721Semaste    SBTarget sb_target;
805254721Semaste    TargetSP target_sp;
806254721Semaste    if (m_opaque_sp)
807254721Semaste    {
808254721Semaste        // No need to lock, the target list is thread safe
809254721Semaste        target_sp = m_opaque_sp->GetTargetList().GetSelectedTarget ();
810254721Semaste        sb_target.SetSP (target_sp);
811254721Semaste    }
812254721Semaste
813254721Semaste    if (log)
814254721Semaste    {
815254721Semaste        SBStream sstr;
816254721Semaste        sb_target.GetDescription (sstr, eDescriptionLevelBrief);
817254721Semaste        log->Printf ("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s", m_opaque_sp.get(),
818254721Semaste                     target_sp.get(), sstr.GetData());
819254721Semaste    }
820254721Semaste
821254721Semaste    return sb_target;
822254721Semaste}
823254721Semaste
824254721Semastevoid
825254721SemasteSBDebugger::SetSelectedTarget (SBTarget &sb_target)
826254721Semaste{
827254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
828254721Semaste
829254721Semaste    TargetSP target_sp (sb_target.GetSP());
830254721Semaste    if (m_opaque_sp)
831254721Semaste    {
832254721Semaste        m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get());
833254721Semaste    }
834254721Semaste    if (log)
835254721Semaste    {
836254721Semaste        SBStream sstr;
837254721Semaste        sb_target.GetDescription (sstr, eDescriptionLevelBrief);
838254721Semaste        log->Printf ("SBDebugger(%p)::SetSelectedTarget () => SBTarget(%p): %s", m_opaque_sp.get(),
839254721Semaste                     target_sp.get(), sstr.GetData());
840254721Semaste    }
841254721Semaste}
842254721Semaste
843263367SemasteSBPlatform
844263367SemasteSBDebugger::GetSelectedPlatform()
845263367Semaste{
846263367Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
847263367Semaste
848263367Semaste    SBPlatform sb_platform;
849263367Semaste    DebuggerSP debugger_sp(m_opaque_sp);
850263367Semaste    if (debugger_sp)
851263367Semaste    {
852263367Semaste        sb_platform.SetSP(debugger_sp->GetPlatformList().GetSelectedPlatform());
853263367Semaste    }
854263367Semaste    if (log)
855263367Semaste    {
856263367Semaste        log->Printf ("SBDebugger(%p)::GetSelectedPlatform () => SBPlatform(%p): %s", m_opaque_sp.get(),
857263367Semaste                     sb_platform.GetSP().get(), sb_platform.GetName());
858263367Semaste    }
859263367Semaste    return sb_platform;
860263367Semaste}
861263367Semaste
862254721Semastevoid
863263367SemasteSBDebugger::SetSelectedPlatform(SBPlatform &sb_platform)
864263367Semaste{
865263367Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
866263367Semaste
867263367Semaste    DebuggerSP debugger_sp(m_opaque_sp);
868263367Semaste    if (debugger_sp)
869263367Semaste    {
870263367Semaste        debugger_sp->GetPlatformList().SetSelectedPlatform(sb_platform.GetSP());
871263367Semaste    }
872263367Semaste    if (log)
873263367Semaste    {
874263367Semaste        log->Printf ("SBDebugger(%p)::SetSelectedPlatform (SBPlatform(%p) %s)", m_opaque_sp.get(),
875263367Semaste                     sb_platform.GetSP().get(), sb_platform.GetName());
876263367Semaste    }
877263367Semaste}
878263367Semaste
879263367Semastevoid
880254721SemasteSBDebugger::DispatchInput (void* baton, const void *data, size_t data_len)
881254721Semaste{
882254721Semaste    DispatchInput (data,data_len);
883254721Semaste}
884254721Semaste
885254721Semastevoid
886254721SemasteSBDebugger::DispatchInput (const void *data, size_t data_len)
887254721Semaste{
888254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
889254721Semaste
890254721Semaste    if (log)
891254721Semaste        log->Printf ("SBDebugger(%p)::DispatchInput (data=\"%.*s\", size_t=%" PRIu64 ")",
892254721Semaste                     m_opaque_sp.get(),
893254721Semaste                     (int) data_len,
894254721Semaste                     (const char *) data,
895254721Semaste                     (uint64_t)data_len);
896254721Semaste
897254721Semaste    if (m_opaque_sp)
898254721Semaste        m_opaque_sp->DispatchInput ((const char *) data, data_len);
899254721Semaste}
900254721Semaste
901254721Semastevoid
902254721SemasteSBDebugger::DispatchInputInterrupt ()
903254721Semaste{
904254721Semaste    if (m_opaque_sp)
905254721Semaste        m_opaque_sp->DispatchInputInterrupt ();
906254721Semaste}
907254721Semaste
908254721Semastevoid
909254721SemasteSBDebugger::DispatchInputEndOfFile ()
910254721Semaste{
911254721Semaste    if (m_opaque_sp)
912254721Semaste        m_opaque_sp->DispatchInputEndOfFile ();
913254721Semaste}
914254721Semaste
915254721Semastebool
916254721SemasteSBDebugger::InputReaderIsTopReader (const lldb::SBInputReader &reader)
917254721Semaste{
918254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
919254721Semaste
920254721Semaste    if (log)
921254721Semaste        log->Printf ("SBDebugger(%p)::InputReaderIsTopReader (SBInputReader(%p))", m_opaque_sp.get(), &reader);
922254721Semaste
923254721Semaste    if (m_opaque_sp && reader.IsValid())
924254721Semaste    {
925254721Semaste        InputReaderSP reader_sp (*reader);
926254721Semaste        return m_opaque_sp->InputReaderIsTopReader (reader_sp);
927254721Semaste    }
928254721Semaste
929254721Semaste    return false;
930254721Semaste}
931254721Semaste
932254721Semaste
933254721Semastevoid
934254721SemasteSBDebugger::PushInputReader (SBInputReader &reader)
935254721Semaste{
936254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
937254721Semaste
938254721Semaste    if (log)
939254721Semaste        log->Printf ("SBDebugger(%p)::PushInputReader (SBInputReader(%p))", m_opaque_sp.get(), &reader);
940254721Semaste
941254721Semaste    if (m_opaque_sp && reader.IsValid())
942254721Semaste    {
943254721Semaste        TargetSP target_sp (m_opaque_sp->GetSelectedTarget());
944254721Semaste        Mutex::Locker api_locker;
945254721Semaste        if (target_sp)
946254721Semaste            api_locker.Lock(target_sp->GetAPIMutex());
947254721Semaste        InputReaderSP reader_sp(*reader);
948254721Semaste        m_opaque_sp->PushInputReader (reader_sp);
949254721Semaste    }
950254721Semaste}
951254721Semaste
952254721Semastevoid
953254721SemasteSBDebugger::NotifyTopInputReader (InputReaderAction notification)
954254721Semaste{
955254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
956254721Semaste
957254721Semaste    if (log)
958254721Semaste        log->Printf ("SBDebugger(%p)::NotifyTopInputReader (%d)", m_opaque_sp.get(), notification);
959254721Semaste
960254721Semaste    if (m_opaque_sp)
961254721Semaste        m_opaque_sp->NotifyTopInputReader (notification);
962254721Semaste}
963254721Semaste
964254721Semastevoid
965254721SemasteSBDebugger::reset (const DebuggerSP &debugger_sp)
966254721Semaste{
967254721Semaste    m_opaque_sp = debugger_sp;
968254721Semaste}
969254721Semaste
970254721SemasteDebugger *
971254721SemasteSBDebugger::get () const
972254721Semaste{
973254721Semaste    return m_opaque_sp.get();
974254721Semaste}
975254721Semaste
976254721SemasteDebugger &
977254721SemasteSBDebugger::ref () const
978254721Semaste{
979254721Semaste    assert (m_opaque_sp.get());
980254721Semaste    return *m_opaque_sp;
981254721Semaste}
982254721Semaste
983254721Semasteconst lldb::DebuggerSP &
984254721SemasteSBDebugger::get_sp () const
985254721Semaste{
986254721Semaste    return m_opaque_sp;
987254721Semaste}
988254721Semaste
989254721SemasteSBDebugger
990254721SemasteSBDebugger::FindDebuggerWithID (int id)
991254721Semaste{
992254721Semaste    // No need to lock, the debugger list is thread safe
993254721Semaste    SBDebugger sb_debugger;
994254721Semaste    DebuggerSP debugger_sp = Debugger::FindDebuggerWithID (id);
995254721Semaste    if (debugger_sp)
996254721Semaste        sb_debugger.reset (debugger_sp);
997254721Semaste    return sb_debugger;
998254721Semaste}
999254721Semaste
1000254721Semasteconst char *
1001254721SemasteSBDebugger::GetInstanceName()
1002254721Semaste{
1003254721Semaste    if (m_opaque_sp)
1004254721Semaste        return m_opaque_sp->GetInstanceName().AsCString();
1005254721Semaste    else
1006254721Semaste        return NULL;
1007254721Semaste}
1008254721Semaste
1009254721SemasteSBError
1010254721SemasteSBDebugger::SetInternalVariable (const char *var_name, const char *value, const char *debugger_instance_name)
1011254721Semaste{
1012254721Semaste    SBError sb_error;
1013254721Semaste    DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name)));
1014254721Semaste    Error error;
1015254721Semaste    if (debugger_sp)
1016254721Semaste    {
1017254721Semaste        ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext());
1018254721Semaste        error = debugger_sp->SetPropertyValue (&exe_ctx,
1019254721Semaste                                               eVarSetOperationAssign,
1020254721Semaste                                               var_name,
1021254721Semaste                                               value);
1022254721Semaste    }
1023254721Semaste    else
1024254721Semaste    {
1025254721Semaste        error.SetErrorStringWithFormat ("invalid debugger instance name '%s'", debugger_instance_name);
1026254721Semaste    }
1027254721Semaste    if (error.Fail())
1028254721Semaste        sb_error.SetError(error);
1029254721Semaste    return sb_error;
1030254721Semaste}
1031254721Semaste
1032254721SemasteSBStringList
1033254721SemasteSBDebugger::GetInternalVariableValue (const char *var_name, const char *debugger_instance_name)
1034254721Semaste{
1035254721Semaste    SBStringList ret_value;
1036254721Semaste    DebuggerSP debugger_sp(Debugger::FindDebuggerWithInstanceName (ConstString(debugger_instance_name)));
1037254721Semaste    Error error;
1038254721Semaste    if (debugger_sp)
1039254721Semaste    {
1040254721Semaste        ExecutionContext exe_ctx (debugger_sp->GetCommandInterpreter().GetExecutionContext());
1041254721Semaste        lldb::OptionValueSP value_sp (debugger_sp->GetPropertyValue (&exe_ctx,
1042254721Semaste                                                                     var_name,
1043254721Semaste                                                                     false,
1044254721Semaste                                                                     error));
1045254721Semaste        if (value_sp)
1046254721Semaste        {
1047254721Semaste            StreamString value_strm;
1048254721Semaste            value_sp->DumpValue (&exe_ctx, value_strm, OptionValue::eDumpOptionValue);
1049254721Semaste            const std::string &value_str = value_strm.GetString();
1050254721Semaste            if (!value_str.empty())
1051254721Semaste            {
1052254721Semaste                StringList string_list;
1053254721Semaste                string_list.SplitIntoLines(value_str.c_str(), value_str.size());
1054254721Semaste                return SBStringList(&string_list);
1055254721Semaste            }
1056254721Semaste        }
1057254721Semaste    }
1058254721Semaste    return SBStringList();
1059254721Semaste}
1060254721Semaste
1061254721Semasteuint32_t
1062254721SemasteSBDebugger::GetTerminalWidth () const
1063254721Semaste{
1064254721Semaste    if (m_opaque_sp)
1065254721Semaste        return m_opaque_sp->GetTerminalWidth ();
1066254721Semaste    return 0;
1067254721Semaste}
1068254721Semaste
1069254721Semastevoid
1070254721SemasteSBDebugger::SetTerminalWidth (uint32_t term_width)
1071254721Semaste{
1072254721Semaste    if (m_opaque_sp)
1073254721Semaste        m_opaque_sp->SetTerminalWidth (term_width);
1074254721Semaste}
1075254721Semaste
1076254721Semasteconst char *
1077254721SemasteSBDebugger::GetPrompt() const
1078254721Semaste{
1079254721Semaste    Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
1080254721Semaste
1081254721Semaste    if (log)
1082254721Semaste        log->Printf ("SBDebugger(%p)::GetPrompt () => \"%s\"", m_opaque_sp.get(),
1083254721Semaste                     (m_opaque_sp ? m_opaque_sp->GetPrompt() : ""));
1084254721Semaste
1085254721Semaste    if (m_opaque_sp)
1086254721Semaste        return m_opaque_sp->GetPrompt ();
1087254721Semaste    return 0;
1088254721Semaste}
1089254721Semaste
1090254721Semastevoid
1091254721SemasteSBDebugger::SetPrompt (const char *prompt)
1092254721Semaste{
1093254721Semaste    if (m_opaque_sp)
1094254721Semaste        m_opaque_sp->SetPrompt (prompt);
1095254721Semaste}
1096254721Semaste
1097254721Semaste
1098254721SemasteScriptLanguage
1099254721SemasteSBDebugger::GetScriptLanguage() const
1100254721Semaste{
1101254721Semaste    if (m_opaque_sp)
1102254721Semaste        return m_opaque_sp->GetScriptLanguage ();
1103254721Semaste    return eScriptLanguageNone;
1104254721Semaste}
1105254721Semaste
1106254721Semastevoid
1107254721SemasteSBDebugger::SetScriptLanguage (ScriptLanguage script_lang)
1108254721Semaste{
1109254721Semaste    if (m_opaque_sp)
1110254721Semaste    {
1111254721Semaste        m_opaque_sp->SetScriptLanguage (script_lang);
1112254721Semaste    }
1113254721Semaste}
1114254721Semaste
1115254721Semastebool
1116254721SemasteSBDebugger::SetUseExternalEditor (bool value)
1117254721Semaste{
1118254721Semaste    if (m_opaque_sp)
1119254721Semaste        return m_opaque_sp->SetUseExternalEditor (value);
1120254721Semaste    return false;
1121254721Semaste}
1122254721Semaste
1123254721Semastebool
1124254721SemasteSBDebugger::GetUseExternalEditor ()
1125254721Semaste{
1126254721Semaste    if (m_opaque_sp)
1127254721Semaste        return m_opaque_sp->GetUseExternalEditor ();
1128254721Semaste    return false;
1129254721Semaste}
1130254721Semaste
1131254721Semastebool
1132254721SemasteSBDebugger::SetUseColor (bool value)
1133254721Semaste{
1134254721Semaste    if (m_opaque_sp)
1135254721Semaste        return m_opaque_sp->SetUseColor (value);
1136254721Semaste    return false;
1137254721Semaste}
1138254721Semaste
1139254721Semastebool
1140254721SemasteSBDebugger::GetUseColor () const
1141254721Semaste{
1142254721Semaste    if (m_opaque_sp)
1143254721Semaste        return m_opaque_sp->GetUseColor ();
1144254721Semaste    return false;
1145254721Semaste}
1146254721Semaste
1147254721Semastebool
1148254721SemasteSBDebugger::GetDescription (SBStream &description)
1149254721Semaste{
1150254721Semaste    Stream &strm = description.ref();
1151254721Semaste
1152254721Semaste    if (m_opaque_sp)
1153254721Semaste    {
1154254721Semaste        const char *name = m_opaque_sp->GetInstanceName().AsCString();
1155254721Semaste        user_id_t id = m_opaque_sp->GetID();
1156254721Semaste        strm.Printf ("Debugger (instance: \"%s\", id: %" PRIu64 ")", name, id);
1157254721Semaste    }
1158254721Semaste    else
1159254721Semaste        strm.PutCString ("No value");
1160254721Semaste
1161254721Semaste    return true;
1162254721Semaste}
1163254721Semaste
1164254721Semasteuser_id_t
1165254721SemasteSBDebugger::GetID()
1166254721Semaste{
1167254721Semaste    if (m_opaque_sp)
1168254721Semaste        return m_opaque_sp->GetID();
1169254721Semaste    return LLDB_INVALID_UID;
1170254721Semaste}
1171254721Semaste
1172254721Semaste
1173254721SemasteSBError
1174254721SemasteSBDebugger::SetCurrentPlatform (const char *platform_name)
1175254721Semaste{
1176254721Semaste    SBError sb_error;
1177254721Semaste    if (m_opaque_sp)
1178254721Semaste    {
1179254721Semaste        PlatformSP platform_sp (Platform::Create (platform_name, sb_error.ref()));
1180254721Semaste
1181254721Semaste        if (platform_sp)
1182254721Semaste        {
1183254721Semaste            bool make_selected = true;
1184254721Semaste            m_opaque_sp->GetPlatformList().Append (platform_sp, make_selected);
1185254721Semaste        }
1186254721Semaste    }
1187254721Semaste    return sb_error;
1188254721Semaste}
1189254721Semaste
1190254721Semastebool
1191254721SemasteSBDebugger::SetCurrentPlatformSDKRoot (const char *sysroot)
1192254721Semaste{
1193254721Semaste    if (m_opaque_sp)
1194254721Semaste    {
1195254721Semaste        PlatformSP platform_sp (m_opaque_sp->GetPlatformList().GetSelectedPlatform());
1196254721Semaste
1197254721Semaste        if (platform_sp)
1198254721Semaste        {
1199254721Semaste            platform_sp->SetSDKRootDirectory (ConstString (sysroot));
1200254721Semaste            return true;
1201254721Semaste        }
1202254721Semaste    }
1203254721Semaste    return false;
1204254721Semaste}
1205254721Semaste
1206254721Semastebool
1207254721SemasteSBDebugger::GetCloseInputOnEOF () const
1208254721Semaste{
1209254721Semaste    if (m_opaque_sp)
1210254721Semaste        return m_opaque_sp->GetCloseInputOnEOF ();
1211254721Semaste    return false;
1212254721Semaste}
1213254721Semaste
1214254721Semastevoid
1215254721SemasteSBDebugger::SetCloseInputOnEOF (bool b)
1216254721Semaste{
1217254721Semaste    if (m_opaque_sp)
1218254721Semaste        m_opaque_sp->SetCloseInputOnEOF (b);
1219254721Semaste}
1220254721Semaste
1221254721SemasteSBTypeCategory
1222254721SemasteSBDebugger::GetCategory (const char* category_name)
1223254721Semaste{
1224254721Semaste    if (!category_name || *category_name == 0)
1225254721Semaste        return SBTypeCategory();
1226254721Semaste
1227254721Semaste    TypeCategoryImplSP category_sp;
1228254721Semaste
1229254721Semaste    if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, false))
1230254721Semaste        return SBTypeCategory(category_sp);
1231254721Semaste    else
1232254721Semaste        return SBTypeCategory();
1233254721Semaste}
1234254721Semaste
1235254721SemasteSBTypeCategory
1236254721SemasteSBDebugger::CreateCategory (const char* category_name)
1237254721Semaste{
1238254721Semaste    if (!category_name || *category_name == 0)
1239254721Semaste        return SBTypeCategory();
1240254721Semaste
1241254721Semaste    TypeCategoryImplSP category_sp;
1242254721Semaste
1243254721Semaste    if (DataVisualization::Categories::GetCategory(ConstString(category_name), category_sp, true))
1244254721Semaste        return SBTypeCategory(category_sp);
1245254721Semaste    else
1246254721Semaste        return SBTypeCategory();
1247254721Semaste}
1248254721Semaste
1249254721Semastebool
1250254721SemasteSBDebugger::DeleteCategory (const char* category_name)
1251254721Semaste{
1252254721Semaste    if (!category_name || *category_name == 0)
1253254721Semaste        return false;
1254254721Semaste
1255254721Semaste    return DataVisualization::Categories::Delete(ConstString(category_name));
1256254721Semaste}
1257254721Semaste
1258254721Semasteuint32_t
1259254721SemasteSBDebugger::GetNumCategories()
1260254721Semaste{
1261254721Semaste    return DataVisualization::Categories::GetCount();
1262254721Semaste}
1263254721Semaste
1264254721SemasteSBTypeCategory
1265254721SemasteSBDebugger::GetCategoryAtIndex (uint32_t index)
1266254721Semaste{
1267254721Semaste    return SBTypeCategory(DataVisualization::Categories::GetCategoryAtIndex(index));
1268254721Semaste}
1269254721Semaste
1270254721SemasteSBTypeCategory
1271254721SemasteSBDebugger::GetDefaultCategory()
1272254721Semaste{
1273254721Semaste    return GetCategory("default");
1274254721Semaste}
1275254721Semaste
1276254721SemasteSBTypeFormat
1277254721SemasteSBDebugger::GetFormatForType (SBTypeNameSpecifier type_name)
1278254721Semaste{
1279254721Semaste    SBTypeCategory default_category_sb = GetDefaultCategory();
1280254721Semaste    if (default_category_sb.GetEnabled())
1281254721Semaste        return default_category_sb.GetFormatForType(type_name);
1282254721Semaste    return SBTypeFormat();
1283254721Semaste}
1284254721Semaste
1285254721Semaste#ifndef LLDB_DISABLE_PYTHON
1286254721SemasteSBTypeSummary
1287254721SemasteSBDebugger::GetSummaryForType (SBTypeNameSpecifier type_name)
1288254721Semaste{
1289254721Semaste    if (type_name.IsValid() == false)
1290254721Semaste        return SBTypeSummary();
1291254721Semaste    return SBTypeSummary(DataVisualization::GetSummaryForType(type_name.GetSP()));
1292254721Semaste}
1293254721Semaste#endif // LLDB_DISABLE_PYTHON
1294254721Semaste
1295254721SemasteSBTypeFilter
1296254721SemasteSBDebugger::GetFilterForType (SBTypeNameSpecifier type_name)
1297254721Semaste{
1298254721Semaste    if (type_name.IsValid() == false)
1299254721Semaste        return SBTypeFilter();
1300254721Semaste    return SBTypeFilter(DataVisualization::GetFilterForType(type_name.GetSP()));
1301254721Semaste}
1302254721Semaste
1303254721Semaste#ifndef LLDB_DISABLE_PYTHON
1304254721SemasteSBTypeSynthetic
1305254721SemasteSBDebugger::GetSyntheticForType (SBTypeNameSpecifier type_name)
1306254721Semaste{
1307254721Semaste    if (type_name.IsValid() == false)
1308254721Semaste        return SBTypeSynthetic();
1309254721Semaste    return SBTypeSynthetic(DataVisualization::GetSyntheticForType(type_name.GetSP()));
1310254721Semaste}
1311254721Semaste#endif // LLDB_DISABLE_PYTHON
1312254721Semaste
1313254721Semastebool
1314254721SemasteSBDebugger::EnableLog (const char *channel, const char **categories)
1315254721Semaste{
1316254721Semaste    if (m_opaque_sp)
1317254721Semaste    {
1318254721Semaste        uint32_t log_options = LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
1319254721Semaste        StreamString errors;
1320254721Semaste        return m_opaque_sp->EnableLog (channel, categories, NULL, log_options, errors);
1321254721Semaste
1322254721Semaste    }
1323254721Semaste    else
1324254721Semaste        return false;
1325254721Semaste}
1326254721Semaste
1327254721Semastevoid
1328254721SemasteSBDebugger::SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton)
1329254721Semaste{
1330254721Semaste    if (m_opaque_sp)
1331254721Semaste    {
1332254721Semaste        return m_opaque_sp->SetLoggingCallback (log_callback, baton);
1333254721Semaste    }
1334254721Semaste}
1335254721Semaste
1336254721Semaste
1337