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/SourceManager.h"
14 #include "lldb/Core/Listener.h"
15 #include "lldb/Interpreter/CommandInterpreter.h"
16 #include "lldb/Interpreter/CommandObjectMultiword.h"
17 #include "lldb/Interpreter/CommandReturnObject.h"
18 #include "lldb/Target/Target.h"
19 
20 #include "lldb/API/SBBroadcaster.h"
21 #include "lldb/API/SBCommandReturnObject.h"
22 #include "lldb/API/SBCommandInterpreter.h"
23 #include "lldb/API/SBEvent.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 CommandInterpreter::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::EventIsCommandInterpreterEvent (const lldb::SBEvent &event)
553 {
554     return event.GetBroadcasterClass() == SBCommandInterpreter::GetBroadcasterClass();
555 }
556 
557 bool
558 SBCommandInterpreter::SetCommandOverrideCallback (const char *command_name,
559                                                   lldb::CommandOverrideCallback callback,
560                                                   void *baton)
561 {
562     if (command_name && command_name[0] && m_opaque_ptr)
563     {
564         std::string command_name_str (command_name);
565         CommandObject *cmd_obj = m_opaque_ptr->GetCommandObjectForCommand(command_name_str);
566         if (cmd_obj)
567         {
568             assert(command_name_str.empty());
569             cmd_obj->SetOverrideCallback (callback, baton);
570             return true;
571         }
572     }
573     return false;
574 }
575 
576 #ifndef LLDB_DISABLE_PYTHON
577 
578 // Defined in the SWIG source file
579 extern "C" void
580 init_lldb(void);
581 
582 // these are the Pythonic implementations of the required callbacks
583 // these are scripting-language specific, which is why they belong here
584 // we still need to use function pointers to them instead of relying
585 // on linkage-time resolution because the SWIG stuff and this file
586 // get built at different times
587 extern "C" bool
588 LLDBSwigPythonBreakpointCallbackFunction (const char *python_function_name,
589                                           const char *session_dictionary_name,
590                                           const lldb::StackFrameSP& sb_frame,
591                                           const lldb::BreakpointLocationSP& sb_bp_loc);
592 
593 extern "C" bool
594 LLDBSwigPythonWatchpointCallbackFunction (const char *python_function_name,
595                                           const char *session_dictionary_name,
596                                           const lldb::StackFrameSP& sb_frame,
597                                           const lldb::WatchpointSP& sb_wp);
598 
599 extern "C" bool
600 LLDBSwigPythonCallTypeScript (const char *python_function_name,
601                               void *session_dictionary,
602                               const lldb::ValueObjectSP& valobj_sp,
603                               void** pyfunct_wrapper,
604                               const lldb::TypeSummaryOptionsSP& options_sp,
605                               std::string& retval);
606 
607 extern "C" void*
608 LLDBSwigPythonCreateSyntheticProvider (const char *python_class_name,
609                                        const char *session_dictionary_name,
610                                        const lldb::ValueObjectSP& valobj_sp);
611 
612 extern "C" void*
613 LLDBSwigPythonCreateCommandObject (const char *python_class_name,
614                                    const char *session_dictionary_name,
615                                    const lldb::DebuggerSP debugger_sp);
616 
617 extern "C" void*
618 LLDBSwigPythonCreateScriptedThreadPlan (const char *python_class_name,
619                                         const char *session_dictionary_name,
620                                         const lldb::ThreadPlanSP& thread_plan_sp);
621 
622 extern "C" bool
623 LLDBSWIGPythonCallThreadPlan (void *implementor,
624                               const char *method_name,
625                               Event *event_sp,
626                               bool &got_error);
627 
628 extern "C" size_t
629 LLDBSwigPython_CalculateNumChildren (void *implementor);
630 
631 extern "C" void *
632 LLDBSwigPython_GetChildAtIndex (void *implementor, uint32_t idx);
633 
634 extern "C" int
635 LLDBSwigPython_GetIndexOfChildWithName (void *implementor, const char* child_name);
636 
637 extern "C" void *
638 LLDBSWIGPython_CastPyObjectToSBValue (void* data);
639 
640 extern lldb::ValueObjectSP
641 LLDBSWIGPython_GetValueObjectSPFromSBValue (void* data);
642 
643 extern "C" bool
644 LLDBSwigPython_UpdateSynthProviderInstance (void* implementor);
645 
646 extern "C" bool
647 LLDBSwigPython_MightHaveChildrenSynthProviderInstance (void* implementor);
648 
649 extern "C" void *
650 LLDBSwigPython_GetValueSynthProviderInstance (void* implementor);
651 
652 extern "C" bool
653 LLDBSwigPythonCallCommand (const char *python_function_name,
654                            const char *session_dictionary_name,
655                            lldb::DebuggerSP& debugger,
656                            const char* args,
657                            lldb_private::CommandReturnObject &cmd_retobj,
658                            lldb::ExecutionContextRefSP exe_ctx_ref_sp);
659 
660 extern "C" bool
661 LLDBSwigPythonCallCommandObject (void *implementor,
662                                  lldb::DebuggerSP& debugger,
663                                  const char* args,
664                                  lldb_private::CommandReturnObject& cmd_retobj,
665                                  lldb::ExecutionContextRefSP exe_ctx_ref_sp);
666 
667 extern "C" bool
668 LLDBSwigPythonCallModuleInit (const char *python_module_name,
669                               const char *session_dictionary_name,
670                               lldb::DebuggerSP& debugger);
671 
672 extern "C" void*
673 LLDBSWIGPythonCreateOSPlugin (const char *python_class_name,
674                               const char *session_dictionary_name,
675                               const lldb::ProcessSP& process_sp);
676 
677 extern "C" bool
678 LLDBSWIGPythonRunScriptKeywordProcess (const char* python_function_name,
679                                        const char* session_dictionary_name,
680                                        lldb::ProcessSP& process,
681                                        std::string& output);
682 
683 extern "C" bool
684 LLDBSWIGPythonRunScriptKeywordThread (const char* python_function_name,
685                                       const char* session_dictionary_name,
686                                       lldb::ThreadSP& thread,
687                                       std::string& output);
688 
689 extern "C" bool
690 LLDBSWIGPythonRunScriptKeywordTarget (const char* python_function_name,
691                                       const char* session_dictionary_name,
692                                       lldb::TargetSP& target,
693                                       std::string& output);
694 
695 extern "C" bool
696 LLDBSWIGPythonRunScriptKeywordFrame (const char* python_function_name,
697                                      const char* session_dictionary_name,
698                                      lldb::StackFrameSP& frame,
699                                      std::string& output);
700 
701 extern "C" bool
702 LLDBSWIGPythonRunScriptKeywordValue (const char* python_function_name,
703                                      const char* session_dictionary_name,
704                                      lldb::ValueObjectSP& value,
705                                      std::string& output);
706 
707 extern "C" void*
708 LLDBSWIGPython_GetDynamicSetting (void* module,
709                                   const char* setting,
710                                   const lldb::TargetSP& target_sp);
711 
712 
713 #endif
714 
715 void
716 SBCommandInterpreter::InitializeSWIG ()
717 {
718     static bool g_initialized = false;
719     if (!g_initialized)
720     {
721         g_initialized = true;
722 #ifndef LLDB_DISABLE_PYTHON
723         ScriptInterpreter::InitializeInterpreter (init_lldb,
724                                                   LLDBSwigPythonBreakpointCallbackFunction,
725                                                   LLDBSwigPythonWatchpointCallbackFunction,
726                                                   LLDBSwigPythonCallTypeScript,
727                                                   LLDBSwigPythonCreateSyntheticProvider,
728                                                   LLDBSwigPythonCreateCommandObject,
729                                                   LLDBSwigPython_CalculateNumChildren,
730                                                   LLDBSwigPython_GetChildAtIndex,
731                                                   LLDBSwigPython_GetIndexOfChildWithName,
732                                                   LLDBSWIGPython_CastPyObjectToSBValue,
733                                                   LLDBSWIGPython_GetValueObjectSPFromSBValue,
734                                                   LLDBSwigPython_UpdateSynthProviderInstance,
735                                                   LLDBSwigPython_MightHaveChildrenSynthProviderInstance,
736                                                   LLDBSwigPython_GetValueSynthProviderInstance,
737                                                   LLDBSwigPythonCallCommand,
738                                                   LLDBSwigPythonCallCommandObject,
739                                                   LLDBSwigPythonCallModuleInit,
740                                                   LLDBSWIGPythonCreateOSPlugin,
741                                                   LLDBSWIGPythonRunScriptKeywordProcess,
742                                                   LLDBSWIGPythonRunScriptKeywordThread,
743                                                   LLDBSWIGPythonRunScriptKeywordTarget,
744                                                   LLDBSWIGPythonRunScriptKeywordFrame,
745                                                   LLDBSWIGPythonRunScriptKeywordValue,
746                                                   LLDBSWIGPython_GetDynamicSetting,
747                                                   LLDBSwigPythonCreateScriptedThreadPlan,
748                                                   LLDBSWIGPythonCallThreadPlan);
749 #endif
750     }
751 }
752 
753 lldb::SBCommand
754 SBCommandInterpreter::AddMultiwordCommand (const char* name, const char* help)
755 {
756     CommandObjectMultiword *new_command = new CommandObjectMultiword(*m_opaque_ptr,name,help);
757     new_command->SetRemovable (true);
758     lldb::CommandObjectSP new_command_sp(new_command);
759     if (new_command_sp && m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
760         return lldb::SBCommand(new_command_sp);
761     return lldb::SBCommand();
762 }
763 
764 lldb::SBCommand
765 SBCommandInterpreter::AddCommand (const char* name, lldb::SBCommandPluginInterface* impl, const char* help)
766 {
767     lldb::CommandObjectSP new_command_sp;
768     new_command_sp.reset(new CommandPluginInterfaceImplementation(*m_opaque_ptr,name,impl,help));
769 
770     if (new_command_sp && m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
771         return lldb::SBCommand(new_command_sp);
772     return lldb::SBCommand();
773 }
774 
775 SBCommand::SBCommand ()
776 {}
777 
778 SBCommand::SBCommand (lldb::CommandObjectSP cmd_sp) : m_opaque_sp (cmd_sp)
779 {}
780 
781 bool
782 SBCommand::IsValid ()
783 {
784     return (bool)m_opaque_sp;
785 }
786 
787 const char*
788 SBCommand::GetName ()
789 {
790     if (IsValid ())
791         return m_opaque_sp->GetCommandName ();
792     return NULL;
793 }
794 
795 const char*
796 SBCommand::GetHelp ()
797 {
798     if (IsValid ())
799         return m_opaque_sp->GetHelp ();
800     return NULL;
801 }
802 
803 const char*
804 SBCommand::GetHelpLong ()
805 {
806     if (IsValid ())
807         return m_opaque_sp->GetHelpLong ();
808     return NULL;
809 }
810 
811 void
812 SBCommand::SetHelp (const char* help)
813 {
814     if (IsValid())
815         m_opaque_sp->SetHelp(help);
816 }
817 
818 void
819 SBCommand::SetHelpLong (const char* help)
820 {
821     if (IsValid())
822         m_opaque_sp->SetHelpLong(help);
823 }
824 
825 lldb::SBCommand
826 SBCommand::AddMultiwordCommand (const char* name, const char* help)
827 {
828     if (!IsValid ())
829         return lldb::SBCommand();
830     if (m_opaque_sp->IsMultiwordObject() == false)
831         return lldb::SBCommand();
832     CommandObjectMultiword *new_command = new CommandObjectMultiword(m_opaque_sp->GetCommandInterpreter(),name,help);
833     new_command->SetRemovable (true);
834     lldb::CommandObjectSP new_command_sp(new_command);
835     if (new_command_sp && m_opaque_sp->LoadSubCommand(name,new_command_sp))
836         return lldb::SBCommand(new_command_sp);
837     return lldb::SBCommand();
838 }
839 
840 lldb::SBCommand
841 SBCommand::AddCommand (const char* name, lldb::SBCommandPluginInterface *impl, const char* help)
842 {
843     if (!IsValid ())
844         return lldb::SBCommand();
845     if (m_opaque_sp->IsMultiwordObject() == false)
846         return lldb::SBCommand();
847     lldb::CommandObjectSP new_command_sp;
848     new_command_sp.reset(new CommandPluginInterfaceImplementation(m_opaque_sp->GetCommandInterpreter(),name,impl,help));
849     if (new_command_sp && m_opaque_sp->LoadSubCommand(name,new_command_sp))
850         return lldb::SBCommand(new_command_sp);
851     return lldb::SBCommand();
852 }
853 
854