1 //===-- SBCommandInterpreter.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/lldb-types.h"
13 #include "lldb/Core/Communication.h"
14 #include "lldb/Core/SourceManager.h"
15 #include "lldb/Core/Listener.h"
16 #include "lldb/Interpreter/CommandInterpreter.h"
17 #include "lldb/Interpreter/CommandObjectMultiword.h"
18 #include "lldb/Interpreter/CommandReturnObject.h"
19 #include "lldb/Target/Target.h"
20 
21 #include "lldb/API/SBBroadcaster.h"
22 #include "lldb/API/SBCommandReturnObject.h"
23 #include "lldb/API/SBCommandInterpreter.h"
24 #include "lldb/API/SBExecutionContext.h"
25 #include "lldb/API/SBProcess.h"
26 #include "lldb/API/SBTarget.h"
27 #include "lldb/API/SBListener.h"
28 #include "lldb/API/SBStream.h"
29 #include "lldb/API/SBStringList.h"
30 
31 using namespace lldb;
32 using namespace lldb_private;
33 
34 SBCommandInterpreterRunOptions::SBCommandInterpreterRunOptions()
35 {
36     m_opaque_up.reset(new CommandInterpreterRunOptions());
37 }
38 
39 SBCommandInterpreterRunOptions::~SBCommandInterpreterRunOptions()
40 {
41 
42 }
43 
44 bool
45 SBCommandInterpreterRunOptions::GetStopOnContinue () const
46 {
47     return m_opaque_up->GetStopOnContinue();
48 }
49 
50 void
51 SBCommandInterpreterRunOptions::SetStopOnContinue (bool stop_on_continue)
52 {
53     m_opaque_up->SetStopOnContinue(stop_on_continue);
54 }
55 
56 bool
57 SBCommandInterpreterRunOptions::GetStopOnError () const
58 {
59     return m_opaque_up->GetStopOnError();
60 }
61 
62 void
63 SBCommandInterpreterRunOptions::SetStopOnError (bool stop_on_error)
64 {
65     m_opaque_up->SetStopOnError(stop_on_error);
66 }
67 
68 bool
69 SBCommandInterpreterRunOptions::GetStopOnCrash () const
70 {
71     return m_opaque_up->GetStopOnCrash();
72 }
73 
74 void
75 SBCommandInterpreterRunOptions::SetStopOnCrash (bool stop_on_crash)
76 {
77     m_opaque_up->SetStopOnCrash(stop_on_crash);
78 }
79 
80 bool
81 SBCommandInterpreterRunOptions::GetEchoCommands () const
82 {
83     return m_opaque_up->GetEchoCommands();
84 }
85 
86 void
87 SBCommandInterpreterRunOptions::SetEchoCommands (bool echo_commands)
88 {
89     m_opaque_up->SetEchoCommands(echo_commands);
90 }
91 
92 bool
93 SBCommandInterpreterRunOptions::GetPrintResults () const
94 {
95     return m_opaque_up->GetPrintResults();
96 }
97 
98 void
99 SBCommandInterpreterRunOptions::SetPrintResults (bool print_results)
100 {
101     m_opaque_up->SetPrintResults(print_results);
102 }
103 
104 bool
105 SBCommandInterpreterRunOptions::GetAddToHistory () const
106 {
107     return m_opaque_up->GetAddToHistory();
108 }
109 
110 void
111 SBCommandInterpreterRunOptions::SetAddToHistory (bool add_to_history)
112 {
113     m_opaque_up->SetAddToHistory(add_to_history);
114 }
115 
116 lldb_private::CommandInterpreterRunOptions *
117 SBCommandInterpreterRunOptions::get () const
118 {
119     return m_opaque_up.get();
120 }
121 
122 lldb_private::CommandInterpreterRunOptions &
123 SBCommandInterpreterRunOptions::ref () const
124 {
125     return *m_opaque_up.get();
126 }
127 
128 class CommandPluginInterfaceImplementation : public CommandObjectParsed
129 {
130 public:
131     CommandPluginInterfaceImplementation (CommandInterpreter &interpreter,
132                                           const char *name,
133                                           lldb::SBCommandPluginInterface* backend,
134                                           const char *help = NULL,
135                                           const char *syntax = NULL,
136                                           uint32_t flags = 0) :
137     CommandObjectParsed (interpreter, name, help, syntax, flags),
138     m_backend(backend) {}
139 
140     virtual bool
141     IsRemovable() const { return true; }
142 
143 protected:
144     virtual bool
145     DoExecute (Args& command, CommandReturnObject &result)
146     {
147         SBCommandReturnObject sb_return(&result);
148         SBCommandInterpreter sb_interpreter(&m_interpreter);
149         SBDebugger debugger_sb(m_interpreter.GetDebugger().shared_from_this());
150         bool ret = m_backend->DoExecute (debugger_sb,(char**)command.GetArgumentVector(), sb_return);
151         sb_return.Release();
152         return ret;
153     }
154     lldb::SBCommandPluginInterface* m_backend;
155 };
156 
157 SBCommandInterpreter::SBCommandInterpreter (CommandInterpreter *interpreter) :
158     m_opaque_ptr (interpreter)
159 {
160     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
161 
162     if (log)
163         log->Printf ("SBCommandInterpreter::SBCommandInterpreter (interpreter=%p)"
164                      " => SBCommandInterpreter(%p)",
165                      static_cast<void*>(interpreter),
166                      static_cast<void*>(m_opaque_ptr));
167 }
168 
169 SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs) :
170     m_opaque_ptr (rhs.m_opaque_ptr)
171 {
172 }
173 
174 const SBCommandInterpreter &
175 SBCommandInterpreter::operator = (const SBCommandInterpreter &rhs)
176 {
177     m_opaque_ptr = rhs.m_opaque_ptr;
178     return *this;
179 }
180 
181 SBCommandInterpreter::~SBCommandInterpreter ()
182 {
183 }
184 
185 bool
186 SBCommandInterpreter::IsValid() const
187 {
188     return m_opaque_ptr != NULL;
189 }
190 
191 
192 bool
193 SBCommandInterpreter::CommandExists (const char *cmd)
194 {
195     if (cmd && m_opaque_ptr)
196         return m_opaque_ptr->CommandExists (cmd);
197     return false;
198 }
199 
200 bool
201 SBCommandInterpreter::AliasExists (const char *cmd)
202 {
203     if (cmd && m_opaque_ptr)
204         return m_opaque_ptr->AliasExists (cmd);
205     return false;
206 }
207 
208 bool
209 SBCommandInterpreter::IsActive ()
210 {
211     if (m_opaque_ptr)
212         return m_opaque_ptr->IsActive ();
213     return false;
214 }
215 
216 const char *
217 SBCommandInterpreter::GetIOHandlerControlSequence(char ch)
218 {
219     if (m_opaque_ptr)
220         return m_opaque_ptr->GetDebugger().GetTopIOHandlerControlSequence (ch).GetCString();
221     return NULL;
222 }
223 
224 lldb::ReturnStatus
225 SBCommandInterpreter::HandleCommand (const char *command_line, SBCommandReturnObject &result, bool add_to_history)
226 {
227     SBExecutionContext sb_exe_ctx;
228     return HandleCommand (command_line, sb_exe_ctx, result, add_to_history);
229 }
230 
231 lldb::ReturnStatus
232 SBCommandInterpreter::HandleCommand (const char *command_line, SBExecutionContext &override_context, SBCommandReturnObject &result, bool add_to_history)
233 {
234     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
235 
236     if (log)
237         log->Printf ("SBCommandInterpreter(%p)::HandleCommand (command=\"%s\", SBCommandReturnObject(%p), add_to_history=%i)",
238                      static_cast<void*>(m_opaque_ptr), command_line,
239                      static_cast<void*>(result.get()), add_to_history);
240 
241     ExecutionContext ctx, *ctx_ptr;
242     if (override_context.get())
243     {
244         ctx = override_context.get()->Lock(true);
245         ctx_ptr = &ctx;
246     }
247     else
248        ctx_ptr = nullptr;
249 
250 
251     result.Clear();
252     if (command_line && m_opaque_ptr)
253     {
254         result.ref().SetInteractive(false);
255         m_opaque_ptr->HandleCommand (command_line, add_to_history ? eLazyBoolYes : eLazyBoolNo, result.ref(), ctx_ptr);
256     }
257     else
258     {
259         result->AppendError ("SBCommandInterpreter or the command line is not valid");
260         result->SetStatus (eReturnStatusFailed);
261     }
262 
263     // We need to get the value again, in case the command disabled the log!
264     log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
265     if (log)
266     {
267         SBStream sstr;
268         result.GetDescription (sstr);
269         log->Printf ("SBCommandInterpreter(%p)::HandleCommand (command=\"%s\", SBCommandReturnObject(%p): %s, add_to_history=%i) => %i",
270                      static_cast<void*>(m_opaque_ptr), command_line,
271                      static_cast<void*>(result.get()), sstr.GetData(),
272                      add_to_history, result.GetStatus());
273     }
274 
275     return result.GetStatus();
276 }
277 
278 void
279 SBCommandInterpreter::HandleCommandsFromFile (lldb::SBFileSpec &file,
280                                               lldb::SBExecutionContext &override_context,
281                                               lldb::SBCommandInterpreterRunOptions &options,
282                                               lldb::SBCommandReturnObject result)
283 {
284     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
285 
286     if (log)
287     {
288         SBStream s;
289         file.GetDescription (s);
290         log->Printf ("SBCommandInterpreter(%p)::HandleCommandsFromFile (file=\"%s\", SBCommandReturnObject(%p))",
291                      static_cast<void*>(m_opaque_ptr), s.GetData(),
292                      static_cast<void*>(result.get()));
293     }
294 
295     if (!m_opaque_ptr)
296     {
297         result->AppendError ("SBCommandInterpreter is not valid.");
298         result->SetStatus (eReturnStatusFailed);
299         return;
300     }
301 
302     if (!file.IsValid())
303     {
304         SBStream s;
305         file.GetDescription (s);
306         result->AppendErrorWithFormat ("File is not valid: %s.", s.GetData());
307         result->SetStatus (eReturnStatusFailed);
308     }
309 
310     FileSpec tmp_spec = file.ref();
311     ExecutionContext ctx, *ctx_ptr;
312     if (override_context.get())
313     {
314         ctx = override_context.get()->Lock(true);
315         ctx_ptr = &ctx;
316     }
317     else
318        ctx_ptr = nullptr;
319 
320 
321     m_opaque_ptr->HandleCommandsFromFile (tmp_spec, ctx_ptr, options.ref(), result.ref());
322 
323 }
324 
325 
326 int
327 SBCommandInterpreter::HandleCompletion (const char *current_line,
328                                         const char *cursor,
329                                         const char *last_char,
330                                         int match_start_point,
331                                         int max_return_elements,
332                                         SBStringList &matches)
333 {
334     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
335     int num_completions = 0;
336 
337     // Sanity check the arguments that are passed in:
338     // cursor & last_char have to be within the current_line.
339     if (current_line == NULL || cursor == NULL || last_char == NULL)
340         return 0;
341 
342     if (cursor < current_line || last_char < current_line)
343         return 0;
344 
345     size_t current_line_size = strlen (current_line);
346     if (cursor - current_line > static_cast<ptrdiff_t>(current_line_size) ||
347         last_char - current_line > static_cast<ptrdiff_t>(current_line_size))
348         return 0;
349 
350     if (log)
351         log->Printf ("SBCommandInterpreter(%p)::HandleCompletion (current_line=\"%s\", cursor at: %" PRId64 ", last char at: %" PRId64 ", match_start_point: %d, max_return_elements: %d)",
352                      static_cast<void*>(m_opaque_ptr), current_line,
353                      static_cast<uint64_t>(cursor - current_line),
354                      static_cast<uint64_t>(last_char - current_line),
355                      match_start_point, max_return_elements);
356 
357     if (m_opaque_ptr)
358     {
359         lldb_private::StringList lldb_matches;
360         num_completions =  m_opaque_ptr->HandleCompletion (current_line, cursor, last_char, match_start_point,
361                                                            max_return_elements, lldb_matches);
362 
363         SBStringList temp_list (&lldb_matches);
364         matches.AppendList (temp_list);
365     }
366     if (log)
367         log->Printf ("SBCommandInterpreter(%p)::HandleCompletion - Found %d completions.",
368                      static_cast<void*>(m_opaque_ptr), num_completions);
369 
370     return num_completions;
371 }
372 
373 int
374 SBCommandInterpreter::HandleCompletion (const char *current_line,
375                   uint32_t cursor_pos,
376                   int match_start_point,
377                   int max_return_elements,
378                   lldb::SBStringList &matches)
379 {
380     const char *cursor = current_line + cursor_pos;
381     const char *last_char = current_line + strlen (current_line);
382     return HandleCompletion (current_line, cursor, last_char, match_start_point, max_return_elements, matches);
383 }
384 
385 bool
386 SBCommandInterpreter::HasCommands ()
387 {
388     if (m_opaque_ptr)
389         return m_opaque_ptr->HasCommands();
390     return false;
391 }
392 
393 bool
394 SBCommandInterpreter::HasAliases ()
395 {
396     if (m_opaque_ptr)
397         return m_opaque_ptr->HasAliases();
398     return false;
399 }
400 
401 bool
402 SBCommandInterpreter::HasAliasOptions ()
403 {
404     if (m_opaque_ptr)
405         return m_opaque_ptr->HasAliasOptions ();
406     return false;
407 }
408 
409 SBProcess
410 SBCommandInterpreter::GetProcess ()
411 {
412     SBProcess sb_process;
413     ProcessSP process_sp;
414     if (m_opaque_ptr)
415     {
416         TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
417         if (target_sp)
418         {
419             Mutex::Locker api_locker(target_sp->GetAPIMutex());
420             process_sp = target_sp->GetProcessSP();
421             sb_process.SetSP(process_sp);
422         }
423     }
424     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
425 
426     if (log)
427         log->Printf ("SBCommandInterpreter(%p)::GetProcess () => SBProcess(%p)",
428                      static_cast<void*>(m_opaque_ptr),
429                      static_cast<void*>(process_sp.get()));
430 
431     return sb_process;
432 }
433 
434 SBDebugger
435 SBCommandInterpreter::GetDebugger ()
436 {
437     SBDebugger sb_debugger;
438     if (m_opaque_ptr)
439         sb_debugger.reset(m_opaque_ptr->GetDebugger().shared_from_this());
440     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
441 
442     if (log)
443         log->Printf ("SBCommandInterpreter(%p)::GetDebugger () => SBDebugger(%p)",
444                      static_cast<void*>(m_opaque_ptr),
445                      static_cast<void*>(sb_debugger.get()));
446 
447     return sb_debugger;
448 }
449 
450 CommandInterpreter *
451 SBCommandInterpreter::get ()
452 {
453     return m_opaque_ptr;
454 }
455 
456 CommandInterpreter &
457 SBCommandInterpreter::ref ()
458 {
459     assert (m_opaque_ptr);
460     return *m_opaque_ptr;
461 }
462 
463 void
464 SBCommandInterpreter::reset (lldb_private::CommandInterpreter *interpreter)
465 {
466     m_opaque_ptr = interpreter;
467 }
468 
469 void
470 SBCommandInterpreter::SourceInitFileInHomeDirectory (SBCommandReturnObject &result)
471 {
472     result.Clear();
473     if (m_opaque_ptr)
474     {
475         TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
476         Mutex::Locker api_locker;
477         if (target_sp)
478             api_locker.Lock(target_sp->GetAPIMutex());
479         m_opaque_ptr->SourceInitFile (false, result.ref());
480     }
481     else
482     {
483         result->AppendError ("SBCommandInterpreter is not valid");
484         result->SetStatus (eReturnStatusFailed);
485     }
486     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
487 
488     if (log)
489         log->Printf ("SBCommandInterpreter(%p)::SourceInitFileInHomeDirectory (&SBCommandReturnObject(%p))",
490                      static_cast<void*>(m_opaque_ptr),
491                      static_cast<void*>(result.get()));
492 }
493 
494 void
495 SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory (SBCommandReturnObject &result)
496 {
497     result.Clear();
498     if (m_opaque_ptr)
499     {
500         TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
501         Mutex::Locker api_locker;
502         if (target_sp)
503             api_locker.Lock(target_sp->GetAPIMutex());
504         m_opaque_ptr->SourceInitFile (true, result.ref());
505     }
506     else
507     {
508         result->AppendError ("SBCommandInterpreter is not valid");
509         result->SetStatus (eReturnStatusFailed);
510     }
511     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
512 
513     if (log)
514         log->Printf ("SBCommandInterpreter(%p)::SourceInitFileInCurrentWorkingDirectory (&SBCommandReturnObject(%p))",
515                      static_cast<void*>(m_opaque_ptr),
516                      static_cast<void*>(result.get()));
517 }
518 
519 SBBroadcaster
520 SBCommandInterpreter::GetBroadcaster ()
521 {
522     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
523 
524     SBBroadcaster broadcaster (m_opaque_ptr, false);
525 
526     if (log)
527         log->Printf ("SBCommandInterpreter(%p)::GetBroadcaster() => SBBroadcaster(%p)",
528                      static_cast<void*>(m_opaque_ptr), static_cast<void*>(broadcaster.get()));
529 
530     return broadcaster;
531 }
532 
533 const char *
534 SBCommandInterpreter::GetBroadcasterClass ()
535 {
536     return Communication::GetStaticBroadcasterClass().AsCString();
537 }
538 
539 const char *
540 SBCommandInterpreter::GetArgumentTypeAsCString (const lldb::CommandArgumentType arg_type)
541 {
542     return CommandObject::GetArgumentTypeAsCString (arg_type);
543 }
544 
545 const char *
546 SBCommandInterpreter::GetArgumentDescriptionAsCString (const lldb::CommandArgumentType arg_type)
547 {
548     return CommandObject::GetArgumentDescriptionAsCString (arg_type);
549 }
550 
551 bool
552 SBCommandInterpreter::SetCommandOverrideCallback (const char *command_name,
553                                                   lldb::CommandOverrideCallback callback,
554                                                   void *baton)
555 {
556     if (command_name && command_name[0] && m_opaque_ptr)
557     {
558         std::string command_name_str (command_name);
559         CommandObject *cmd_obj = m_opaque_ptr->GetCommandObjectForCommand(command_name_str);
560         if (cmd_obj)
561         {
562             assert(command_name_str.empty());
563             cmd_obj->SetOverrideCallback (callback, baton);
564             return true;
565         }
566     }
567     return false;
568 }
569 
570 #ifndef LLDB_DISABLE_PYTHON
571 
572 // Defined in the SWIG source file
573 extern "C" void
574 init_lldb(void);
575 
576 // these are the Pythonic implementations of the required callbacks
577 // these are scripting-language specific, which is why they belong here
578 // we still need to use function pointers to them instead of relying
579 // on linkage-time resolution because the SWIG stuff and this file
580 // get built at different times
581 extern "C" bool
582 LLDBSwigPythonBreakpointCallbackFunction (const char *python_function_name,
583                                           const char *session_dictionary_name,
584                                           const lldb::StackFrameSP& sb_frame,
585                                           const lldb::BreakpointLocationSP& sb_bp_loc);
586 
587 extern "C" bool
588 LLDBSwigPythonWatchpointCallbackFunction (const char *python_function_name,
589                                           const char *session_dictionary_name,
590                                           const lldb::StackFrameSP& sb_frame,
591                                           const lldb::WatchpointSP& sb_wp);
592 
593 extern "C" bool
594 LLDBSwigPythonCallTypeScript (const char *python_function_name,
595                               void *session_dictionary,
596                               const lldb::ValueObjectSP& valobj_sp,
597                               void** pyfunct_wrapper,
598                               const lldb::TypeSummaryOptionsSP& options_sp,
599                               std::string& retval);
600 
601 extern "C" void*
602 LLDBSwigPythonCreateSyntheticProvider (const char *python_class_name,
603                                        const char *session_dictionary_name,
604                                        const lldb::ValueObjectSP& valobj_sp);
605 
606 
607 extern "C" void*
608 LLDBSwigPythonCreateScriptedThreadPlan (const char *python_class_name,
609                                         const char *session_dictionary_name,
610                                         const lldb::ThreadPlanSP& thread_plan_sp);
611 
612 extern "C" bool
613 LLDBSWIGPythonCallThreadPlan (void *implementor,
614                               const char *method_name,
615                               Event *event_sp,
616                               bool &got_error);
617 
618 extern "C" uint32_t
619 LLDBSwigPython_CalculateNumChildren (void *implementor);
620 
621 extern "C" void *
622 LLDBSwigPython_GetChildAtIndex (void *implementor, uint32_t idx);
623 
624 extern "C" int
625 LLDBSwigPython_GetIndexOfChildWithName (void *implementor, const char* child_name);
626 
627 extern "C" void *
628 LLDBSWIGPython_CastPyObjectToSBValue (void* data);
629 
630 extern lldb::ValueObjectSP
631 LLDBSWIGPython_GetValueObjectSPFromSBValue (void* data);
632 
633 extern "C" bool
634 LLDBSwigPython_UpdateSynthProviderInstance (void* implementor);
635 
636 extern "C" bool
637 LLDBSwigPython_MightHaveChildrenSynthProviderInstance (void* implementor);
638 
639 extern "C" void *
640 LLDBSwigPython_GetValueSynthProviderInstance (void* implementor);
641 
642 extern "C" bool
643 LLDBSwigPythonCallCommand (const char *python_function_name,
644                            const char *session_dictionary_name,
645                            lldb::DebuggerSP& debugger,
646                            const char* args,
647                            lldb_private::CommandReturnObject &cmd_retobj,
648                            lldb::ExecutionContextRefSP exe_ctx_ref_sp);
649 
650 extern "C" bool
651 LLDBSwigPythonCallModuleInit (const char *python_module_name,
652                               const char *session_dictionary_name,
653                               lldb::DebuggerSP& debugger);
654 
655 extern "C" void*
656 LLDBSWIGPythonCreateOSPlugin (const char *python_class_name,
657                               const char *session_dictionary_name,
658                               const lldb::ProcessSP& process_sp);
659 
660 extern "C" bool
661 LLDBSWIGPythonRunScriptKeywordProcess (const char* python_function_name,
662                                        const char* session_dictionary_name,
663                                        lldb::ProcessSP& process,
664                                        std::string& output);
665 
666 extern "C" bool
667 LLDBSWIGPythonRunScriptKeywordThread (const char* python_function_name,
668                                       const char* session_dictionary_name,
669                                       lldb::ThreadSP& thread,
670                                       std::string& output);
671 
672 extern "C" bool
673 LLDBSWIGPythonRunScriptKeywordTarget (const char* python_function_name,
674                                       const char* session_dictionary_name,
675                                       lldb::TargetSP& target,
676                                       std::string& output);
677 
678 extern "C" bool
679 LLDBSWIGPythonRunScriptKeywordFrame (const char* python_function_name,
680                                      const char* session_dictionary_name,
681                                      lldb::StackFrameSP& frame,
682                                      std::string& output);
683 
684 extern "C" bool
685 LLDBSWIGPythonRunScriptKeywordValue (const char* python_function_name,
686                                      const char* session_dictionary_name,
687                                      lldb::ValueObjectSP& value,
688                                      std::string& output);
689 
690 extern "C" void*
691 LLDBSWIGPython_GetDynamicSetting (void* module,
692                                   const char* setting,
693                                   const lldb::TargetSP& target_sp);
694 
695 
696 #endif
697 
698 void
699 SBCommandInterpreter::InitializeSWIG ()
700 {
701     static bool g_initialized = false;
702     if (!g_initialized)
703     {
704         g_initialized = true;
705 #ifndef LLDB_DISABLE_PYTHON
706         ScriptInterpreter::InitializeInterpreter (init_lldb,
707                                                   LLDBSwigPythonBreakpointCallbackFunction,
708                                                   LLDBSwigPythonWatchpointCallbackFunction,
709                                                   LLDBSwigPythonCallTypeScript,
710                                                   LLDBSwigPythonCreateSyntheticProvider,
711                                                   LLDBSwigPython_CalculateNumChildren,
712                                                   LLDBSwigPython_GetChildAtIndex,
713                                                   LLDBSwigPython_GetIndexOfChildWithName,
714                                                   LLDBSWIGPython_CastPyObjectToSBValue,
715                                                   LLDBSWIGPython_GetValueObjectSPFromSBValue,
716                                                   LLDBSwigPython_UpdateSynthProviderInstance,
717                                                   LLDBSwigPython_MightHaveChildrenSynthProviderInstance,
718                                                   LLDBSwigPython_GetValueSynthProviderInstance,
719                                                   LLDBSwigPythonCallCommand,
720                                                   LLDBSwigPythonCallModuleInit,
721                                                   LLDBSWIGPythonCreateOSPlugin,
722                                                   LLDBSWIGPythonRunScriptKeywordProcess,
723                                                   LLDBSWIGPythonRunScriptKeywordThread,
724                                                   LLDBSWIGPythonRunScriptKeywordTarget,
725                                                   LLDBSWIGPythonRunScriptKeywordFrame,
726                                                   LLDBSWIGPythonRunScriptKeywordValue,
727                                                   LLDBSWIGPython_GetDynamicSetting,
728                                                   LLDBSwigPythonCreateScriptedThreadPlan,
729                                                   LLDBSWIGPythonCallThreadPlan);
730 #endif
731     }
732 }
733 
734 lldb::SBCommand
735 SBCommandInterpreter::AddMultiwordCommand (const char* name, const char* help)
736 {
737     CommandObjectMultiword *new_command = new CommandObjectMultiword(*m_opaque_ptr,name,help);
738     new_command->SetRemovable (true);
739     lldb::CommandObjectSP new_command_sp(new_command);
740     if (new_command_sp && m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
741         return lldb::SBCommand(new_command_sp);
742     return lldb::SBCommand();
743 }
744 
745 lldb::SBCommand
746 SBCommandInterpreter::AddCommand (const char* name, lldb::SBCommandPluginInterface* impl, const char* help)
747 {
748     lldb::CommandObjectSP new_command_sp;
749     new_command_sp.reset(new CommandPluginInterfaceImplementation(*m_opaque_ptr,name,impl,help));
750 
751     if (new_command_sp && m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
752         return lldb::SBCommand(new_command_sp);
753     return lldb::SBCommand();
754 }
755 
756 SBCommand::SBCommand ()
757 {}
758 
759 SBCommand::SBCommand (lldb::CommandObjectSP cmd_sp) : m_opaque_sp (cmd_sp)
760 {}
761 
762 bool
763 SBCommand::IsValid ()
764 {
765     return (bool)m_opaque_sp;
766 }
767 
768 const char*
769 SBCommand::GetName ()
770 {
771     if (IsValid ())
772         return m_opaque_sp->GetCommandName ();
773     return NULL;
774 }
775 
776 const char*
777 SBCommand::GetHelp ()
778 {
779     if (IsValid ())
780         return m_opaque_sp->GetHelp ();
781     return NULL;
782 }
783 
784 lldb::SBCommand
785 SBCommand::AddMultiwordCommand (const char* name, const char* help)
786 {
787     if (!IsValid ())
788         return lldb::SBCommand();
789     if (m_opaque_sp->IsMultiwordObject() == false)
790         return lldb::SBCommand();
791     CommandObjectMultiword *new_command = new CommandObjectMultiword(m_opaque_sp->GetCommandInterpreter(),name,help);
792     new_command->SetRemovable (true);
793     lldb::CommandObjectSP new_command_sp(new_command);
794     if (new_command_sp && m_opaque_sp->LoadSubCommand(name,new_command_sp))
795         return lldb::SBCommand(new_command_sp);
796     return lldb::SBCommand();
797 }
798 
799 lldb::SBCommand
800 SBCommand::AddCommand (const char* name, lldb::SBCommandPluginInterface *impl, const char* help)
801 {
802     if (!IsValid ())
803         return lldb::SBCommand();
804     if (m_opaque_sp->IsMultiwordObject() == false)
805         return lldb::SBCommand();
806     lldb::CommandObjectSP new_command_sp;
807     new_command_sp.reset(new CommandPluginInterfaceImplementation(m_opaque_sp->GetCommandInterpreter(),name,impl,help));
808     if (new_command_sp && m_opaque_sp->LoadSubCommand(name,new_command_sp))
809         return lldb::SBCommand(new_command_sp);
810     return lldb::SBCommand();
811 }
812 
813