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/SBProcess.h"
24 #include "lldb/API/SBTarget.h"
25 #include "lldb/API/SBListener.h"
26 #include "lldb/API/SBStream.h"
27 #include "lldb/API/SBStringList.h"
28 
29 using namespace lldb;
30 using namespace lldb_private;
31 
32 class CommandPluginInterfaceImplementation : public CommandObjectParsed
33 {
34 public:
35     CommandPluginInterfaceImplementation (CommandInterpreter &interpreter,
36                                           const char *name,
37                                           lldb::SBCommandPluginInterface* backend,
38                                           const char *help = NULL,
39                                           const char *syntax = NULL,
40                                           uint32_t flags = 0) :
41     CommandObjectParsed (interpreter, name, help, syntax, flags),
42     m_backend(backend) {}
43 
44     virtual bool
45     IsRemovable() const { return true; }
46 
47 protected:
48     virtual bool
49     DoExecute (Args& command, CommandReturnObject &result)
50     {
51         SBCommandReturnObject sb_return(&result);
52         SBCommandInterpreter sb_interpreter(&m_interpreter);
53         SBDebugger debugger_sb(m_interpreter.GetDebugger().shared_from_this());
54         bool ret = m_backend->DoExecute (debugger_sb,(char**)command.GetArgumentVector(), sb_return);
55         sb_return.Release();
56         return ret;
57     }
58     lldb::SBCommandPluginInterface* m_backend;
59 };
60 
61 SBCommandInterpreter::SBCommandInterpreter (CommandInterpreter *interpreter) :
62     m_opaque_ptr (interpreter)
63 {
64     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
65 
66     if (log)
67         log->Printf ("SBCommandInterpreter::SBCommandInterpreter (interpreter=%p)"
68                      " => SBCommandInterpreter(%p)",
69                      static_cast<void*>(interpreter),
70                      static_cast<void*>(m_opaque_ptr));
71 }
72 
73 SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs) :
74     m_opaque_ptr (rhs.m_opaque_ptr)
75 {
76 }
77 
78 const SBCommandInterpreter &
79 SBCommandInterpreter::operator = (const SBCommandInterpreter &rhs)
80 {
81     m_opaque_ptr = rhs.m_opaque_ptr;
82     return *this;
83 }
84 
85 SBCommandInterpreter::~SBCommandInterpreter ()
86 {
87 }
88 
89 bool
90 SBCommandInterpreter::IsValid() const
91 {
92     return m_opaque_ptr != NULL;
93 }
94 
95 
96 bool
97 SBCommandInterpreter::CommandExists (const char *cmd)
98 {
99     if (cmd && m_opaque_ptr)
100         return m_opaque_ptr->CommandExists (cmd);
101     return false;
102 }
103 
104 bool
105 SBCommandInterpreter::AliasExists (const char *cmd)
106 {
107     if (cmd && m_opaque_ptr)
108         return m_opaque_ptr->AliasExists (cmd);
109     return false;
110 }
111 
112 bool
113 SBCommandInterpreter::IsActive ()
114 {
115     if (m_opaque_ptr)
116         return m_opaque_ptr->IsActive ();
117     return false;
118 }
119 
120 const char *
121 SBCommandInterpreter::GetIOHandlerControlSequence(char ch)
122 {
123     if (m_opaque_ptr)
124         return m_opaque_ptr->GetDebugger().GetTopIOHandlerControlSequence (ch).GetCString();
125     return NULL;
126 }
127 
128 lldb::ReturnStatus
129 SBCommandInterpreter::HandleCommand (const char *command_line, SBCommandReturnObject &result, bool add_to_history)
130 {
131     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
132 
133     if (log)
134         log->Printf ("SBCommandInterpreter(%p)::HandleCommand (command=\"%s\", SBCommandReturnObject(%p), add_to_history=%i)",
135                      static_cast<void*>(m_opaque_ptr), command_line,
136                      static_cast<void*>(result.get()), add_to_history);
137 
138     result.Clear();
139     if (command_line && m_opaque_ptr)
140     {
141         result.ref().SetInteractive(false);
142         m_opaque_ptr->HandleCommand (command_line, add_to_history ? eLazyBoolYes : eLazyBoolNo, result.ref());
143     }
144     else
145     {
146         result->AppendError ("SBCommandInterpreter or the command line is not valid");
147         result->SetStatus (eReturnStatusFailed);
148     }
149 
150     // We need to get the value again, in case the command disabled the log!
151     log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
152     if (log)
153     {
154         SBStream sstr;
155         result.GetDescription (sstr);
156         log->Printf ("SBCommandInterpreter(%p)::HandleCommand (command=\"%s\", SBCommandReturnObject(%p): %s, add_to_history=%i) => %i",
157                      static_cast<void*>(m_opaque_ptr), command_line,
158                      static_cast<void*>(result.get()), sstr.GetData(),
159                      add_to_history, result.GetStatus());
160     }
161 
162     return result.GetStatus();
163 }
164 
165 int
166 SBCommandInterpreter::HandleCompletion (const char *current_line,
167                                         const char *cursor,
168                                         const char *last_char,
169                                         int match_start_point,
170                                         int max_return_elements,
171                                         SBStringList &matches)
172 {
173     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
174     int num_completions = 0;
175 
176     // Sanity check the arguments that are passed in:
177     // cursor & last_char have to be within the current_line.
178     if (current_line == NULL || cursor == NULL || last_char == NULL)
179         return 0;
180 
181     if (cursor < current_line || last_char < current_line)
182         return 0;
183 
184     size_t current_line_size = strlen (current_line);
185     if (cursor - current_line > static_cast<ptrdiff_t>(current_line_size) ||
186         last_char - current_line > static_cast<ptrdiff_t>(current_line_size))
187         return 0;
188 
189     if (log)
190         log->Printf ("SBCommandInterpreter(%p)::HandleCompletion (current_line=\"%s\", cursor at: %" PRId64 ", last char at: %" PRId64 ", match_start_point: %d, max_return_elements: %d)",
191                      static_cast<void*>(m_opaque_ptr), current_line,
192                      static_cast<uint64_t>(cursor - current_line),
193                      static_cast<uint64_t>(last_char - current_line),
194                      match_start_point, max_return_elements);
195 
196     if (m_opaque_ptr)
197     {
198         lldb_private::StringList lldb_matches;
199         num_completions =  m_opaque_ptr->HandleCompletion (current_line, cursor, last_char, match_start_point,
200                                                            max_return_elements, lldb_matches);
201 
202         SBStringList temp_list (&lldb_matches);
203         matches.AppendList (temp_list);
204     }
205     if (log)
206         log->Printf ("SBCommandInterpreter(%p)::HandleCompletion - Found %d completions.",
207                      static_cast<void*>(m_opaque_ptr), num_completions);
208 
209     return num_completions;
210 }
211 
212 int
213 SBCommandInterpreter::HandleCompletion (const char *current_line,
214                   uint32_t cursor_pos,
215                   int match_start_point,
216                   int max_return_elements,
217                   lldb::SBStringList &matches)
218 {
219     const char *cursor = current_line + cursor_pos;
220     const char *last_char = current_line + strlen (current_line);
221     return HandleCompletion (current_line, cursor, last_char, match_start_point, max_return_elements, matches);
222 }
223 
224 bool
225 SBCommandInterpreter::HasCommands ()
226 {
227     if (m_opaque_ptr)
228         return m_opaque_ptr->HasCommands();
229     return false;
230 }
231 
232 bool
233 SBCommandInterpreter::HasAliases ()
234 {
235     if (m_opaque_ptr)
236         return m_opaque_ptr->HasAliases();
237     return false;
238 }
239 
240 bool
241 SBCommandInterpreter::HasAliasOptions ()
242 {
243     if (m_opaque_ptr)
244         return m_opaque_ptr->HasAliasOptions ();
245     return false;
246 }
247 
248 SBProcess
249 SBCommandInterpreter::GetProcess ()
250 {
251     SBProcess sb_process;
252     ProcessSP process_sp;
253     if (m_opaque_ptr)
254     {
255         TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
256         if (target_sp)
257         {
258             Mutex::Locker api_locker(target_sp->GetAPIMutex());
259             process_sp = target_sp->GetProcessSP();
260             sb_process.SetSP(process_sp);
261         }
262     }
263     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
264 
265     if (log)
266         log->Printf ("SBCommandInterpreter(%p)::GetProcess () => SBProcess(%p)",
267                      static_cast<void*>(m_opaque_ptr),
268                      static_cast<void*>(process_sp.get()));
269 
270     return sb_process;
271 }
272 
273 SBDebugger
274 SBCommandInterpreter::GetDebugger ()
275 {
276     SBDebugger sb_debugger;
277     if (m_opaque_ptr)
278         sb_debugger.reset(m_opaque_ptr->GetDebugger().shared_from_this());
279     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
280 
281     if (log)
282         log->Printf ("SBCommandInterpreter(%p)::GetDebugger () => SBDebugger(%p)",
283                      static_cast<void*>(m_opaque_ptr),
284                      static_cast<void*>(sb_debugger.get()));
285 
286     return sb_debugger;
287 }
288 
289 CommandInterpreter *
290 SBCommandInterpreter::get ()
291 {
292     return m_opaque_ptr;
293 }
294 
295 CommandInterpreter &
296 SBCommandInterpreter::ref ()
297 {
298     assert (m_opaque_ptr);
299     return *m_opaque_ptr;
300 }
301 
302 void
303 SBCommandInterpreter::reset (lldb_private::CommandInterpreter *interpreter)
304 {
305     m_opaque_ptr = interpreter;
306 }
307 
308 void
309 SBCommandInterpreter::SourceInitFileInHomeDirectory (SBCommandReturnObject &result)
310 {
311     result.Clear();
312     if (m_opaque_ptr)
313     {
314         TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
315         Mutex::Locker api_locker;
316         if (target_sp)
317             api_locker.Lock(target_sp->GetAPIMutex());
318         m_opaque_ptr->SourceInitFile (false, result.ref());
319     }
320     else
321     {
322         result->AppendError ("SBCommandInterpreter is not valid");
323         result->SetStatus (eReturnStatusFailed);
324     }
325     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
326 
327     if (log)
328         log->Printf ("SBCommandInterpreter(%p)::SourceInitFileInHomeDirectory (&SBCommandReturnObject(%p))",
329                      static_cast<void*>(m_opaque_ptr),
330                      static_cast<void*>(result.get()));
331 }
332 
333 void
334 SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory (SBCommandReturnObject &result)
335 {
336     result.Clear();
337     if (m_opaque_ptr)
338     {
339         TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
340         Mutex::Locker api_locker;
341         if (target_sp)
342             api_locker.Lock(target_sp->GetAPIMutex());
343         m_opaque_ptr->SourceInitFile (true, result.ref());
344     }
345     else
346     {
347         result->AppendError ("SBCommandInterpreter is not valid");
348         result->SetStatus (eReturnStatusFailed);
349     }
350     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
351 
352     if (log)
353         log->Printf ("SBCommandInterpreter(%p)::SourceInitFileInCurrentWorkingDirectory (&SBCommandReturnObject(%p))",
354                      static_cast<void*>(m_opaque_ptr),
355                      static_cast<void*>(result.get()));
356 }
357 
358 SBBroadcaster
359 SBCommandInterpreter::GetBroadcaster ()
360 {
361     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
362 
363     SBBroadcaster broadcaster (m_opaque_ptr, false);
364 
365     if (log)
366         log->Printf ("SBCommandInterpreter(%p)::GetBroadcaster() => SBBroadcaster(%p)",
367                      static_cast<void*>(m_opaque_ptr), static_cast<void*>(broadcaster.get()));
368 
369     return broadcaster;
370 }
371 
372 const char *
373 SBCommandInterpreter::GetBroadcasterClass ()
374 {
375     return Communication::GetStaticBroadcasterClass().AsCString();
376 }
377 
378 const char *
379 SBCommandInterpreter::GetArgumentTypeAsCString (const lldb::CommandArgumentType arg_type)
380 {
381     return CommandObject::GetArgumentTypeAsCString (arg_type);
382 }
383 
384 const char *
385 SBCommandInterpreter::GetArgumentDescriptionAsCString (const lldb::CommandArgumentType arg_type)
386 {
387     return CommandObject::GetArgumentDescriptionAsCString (arg_type);
388 }
389 
390 bool
391 SBCommandInterpreter::SetCommandOverrideCallback (const char *command_name,
392                                                   lldb::CommandOverrideCallback callback,
393                                                   void *baton)
394 {
395     if (command_name && command_name[0] && m_opaque_ptr)
396     {
397         std::string command_name_str (command_name);
398         CommandObject *cmd_obj = m_opaque_ptr->GetCommandObjectForCommand(command_name_str);
399         if (cmd_obj)
400         {
401             assert(command_name_str.empty());
402             cmd_obj->SetOverrideCallback (callback, baton);
403             return true;
404         }
405     }
406     return false;
407 }
408 
409 #ifndef LLDB_DISABLE_PYTHON
410 
411 // Defined in the SWIG source file
412 extern "C" void
413 init_lldb(void);
414 
415 // these are the Pythonic implementations of the required callbacks
416 // these are scripting-language specific, which is why they belong here
417 // we still need to use function pointers to them instead of relying
418 // on linkage-time resolution because the SWIG stuff and this file
419 // get built at different times
420 extern "C" bool
421 LLDBSwigPythonBreakpointCallbackFunction (const char *python_function_name,
422                                           const char *session_dictionary_name,
423                                           const lldb::StackFrameSP& sb_frame,
424                                           const lldb::BreakpointLocationSP& sb_bp_loc);
425 
426 extern "C" bool
427 LLDBSwigPythonWatchpointCallbackFunction (const char *python_function_name,
428                                           const char *session_dictionary_name,
429                                           const lldb::StackFrameSP& sb_frame,
430                                           const lldb::WatchpointSP& sb_wp);
431 
432 extern "C" bool
433 LLDBSwigPythonCallTypeScript (const char *python_function_name,
434                               void *session_dictionary,
435                               const lldb::ValueObjectSP& valobj_sp,
436                               void** pyfunct_wrapper,
437                               std::string& retval);
438 
439 extern "C" void*
440 LLDBSwigPythonCreateSyntheticProvider (const char *python_class_name,
441                                        const char *session_dictionary_name,
442                                        const lldb::ValueObjectSP& valobj_sp);
443 
444 
445 extern "C" uint32_t
446 LLDBSwigPython_CalculateNumChildren (void *implementor);
447 
448 extern "C" void *
449 LLDBSwigPython_GetChildAtIndex (void *implementor, uint32_t idx);
450 
451 extern "C" int
452 LLDBSwigPython_GetIndexOfChildWithName (void *implementor, const char* child_name);
453 
454 extern "C" void *
455 LLDBSWIGPython_CastPyObjectToSBValue (void* data);
456 
457 extern lldb::ValueObjectSP
458 LLDBSWIGPython_GetValueObjectSPFromSBValue (void* data);
459 
460 extern "C" bool
461 LLDBSwigPython_UpdateSynthProviderInstance (void* implementor);
462 
463 extern "C" bool
464 LLDBSwigPython_MightHaveChildrenSynthProviderInstance (void* implementor);
465 
466 extern "C" bool
467 LLDBSwigPythonCallCommand (const char *python_function_name,
468                            const char *session_dictionary_name,
469                            lldb::DebuggerSP& debugger,
470                            const char* args,
471                            lldb_private::CommandReturnObject &cmd_retobj);
472 
473 extern "C" bool
474 LLDBSwigPythonCallModuleInit (const char *python_module_name,
475                               const char *session_dictionary_name,
476                               lldb::DebuggerSP& debugger);
477 
478 extern "C" void*
479 LLDBSWIGPythonCreateOSPlugin (const char *python_class_name,
480                               const char *session_dictionary_name,
481                               const lldb::ProcessSP& process_sp);
482 
483 extern "C" bool
484 LLDBSWIGPythonRunScriptKeywordProcess (const char* python_function_name,
485                                        const char* session_dictionary_name,
486                                        lldb::ProcessSP& process,
487                                        std::string& output);
488 
489 extern "C" bool
490 LLDBSWIGPythonRunScriptKeywordThread (const char* python_function_name,
491                                       const char* session_dictionary_name,
492                                       lldb::ThreadSP& thread,
493                                       std::string& output);
494 
495 extern "C" bool
496 LLDBSWIGPythonRunScriptKeywordTarget (const char* python_function_name,
497                                       const char* session_dictionary_name,
498                                       lldb::TargetSP& target,
499                                       std::string& output);
500 
501 extern "C" bool
502 LLDBSWIGPythonRunScriptKeywordFrame (const char* python_function_name,
503                                      const char* session_dictionary_name,
504                                      lldb::StackFrameSP& frame,
505                                      std::string& output);
506 
507 extern "C" void*
508 LLDBSWIGPython_GetDynamicSetting (void* module,
509                                   const char* setting,
510                                   const lldb::TargetSP& target_sp);
511 
512 
513 #endif
514 
515 void
516 SBCommandInterpreter::InitializeSWIG ()
517 {
518     static bool g_initialized = false;
519     if (!g_initialized)
520     {
521         g_initialized = true;
522 #ifndef LLDB_DISABLE_PYTHON
523         ScriptInterpreter::InitializeInterpreter (init_lldb,
524                                                   LLDBSwigPythonBreakpointCallbackFunction,
525                                                   LLDBSwigPythonWatchpointCallbackFunction,
526                                                   LLDBSwigPythonCallTypeScript,
527                                                   LLDBSwigPythonCreateSyntheticProvider,
528                                                   LLDBSwigPython_CalculateNumChildren,
529                                                   LLDBSwigPython_GetChildAtIndex,
530                                                   LLDBSwigPython_GetIndexOfChildWithName,
531                                                   LLDBSWIGPython_CastPyObjectToSBValue,
532                                                   LLDBSWIGPython_GetValueObjectSPFromSBValue,
533                                                   LLDBSwigPython_UpdateSynthProviderInstance,
534                                                   LLDBSwigPython_MightHaveChildrenSynthProviderInstance,
535                                                   LLDBSwigPythonCallCommand,
536                                                   LLDBSwigPythonCallModuleInit,
537                                                   LLDBSWIGPythonCreateOSPlugin,
538                                                   LLDBSWIGPythonRunScriptKeywordProcess,
539                                                   LLDBSWIGPythonRunScriptKeywordThread,
540                                                   LLDBSWIGPythonRunScriptKeywordTarget,
541                                                   LLDBSWIGPythonRunScriptKeywordFrame,
542                                                   LLDBSWIGPython_GetDynamicSetting);
543 #endif
544     }
545 }
546 
547 lldb::SBCommand
548 SBCommandInterpreter::AddMultiwordCommand (const char* name, const char* help)
549 {
550     CommandObjectMultiword *new_command = new CommandObjectMultiword(*m_opaque_ptr,name,help);
551     new_command->SetRemovable (true);
552     lldb::CommandObjectSP new_command_sp(new_command);
553     if (new_command_sp && m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
554         return lldb::SBCommand(new_command_sp);
555     return lldb::SBCommand();
556 }
557 
558 lldb::SBCommand
559 SBCommandInterpreter::AddCommand (const char* name, lldb::SBCommandPluginInterface* impl, const char* help)
560 {
561     lldb::CommandObjectSP new_command_sp;
562     new_command_sp.reset(new CommandPluginInterfaceImplementation(*m_opaque_ptr,name,impl,help));
563 
564     if (new_command_sp && m_opaque_ptr->AddUserCommand(name, new_command_sp, true))
565         return lldb::SBCommand(new_command_sp);
566     return lldb::SBCommand();
567 }
568 
569 SBCommand::SBCommand ()
570 {}
571 
572 SBCommand::SBCommand (lldb::CommandObjectSP cmd_sp) : m_opaque_sp (cmd_sp)
573 {}
574 
575 bool
576 SBCommand::IsValid ()
577 {
578     return (bool)m_opaque_sp;
579 }
580 
581 const char*
582 SBCommand::GetName ()
583 {
584     if (IsValid ())
585         return m_opaque_sp->GetCommandName ();
586     return NULL;
587 }
588 
589 const char*
590 SBCommand::GetHelp ()
591 {
592     if (IsValid ())
593         return m_opaque_sp->GetHelp ();
594     return NULL;
595 }
596 
597 lldb::SBCommand
598 SBCommand::AddMultiwordCommand (const char* name, const char* help)
599 {
600     if (!IsValid ())
601         return lldb::SBCommand();
602     if (m_opaque_sp->IsMultiwordObject() == false)
603         return lldb::SBCommand();
604     CommandObjectMultiword *new_command = new CommandObjectMultiword(m_opaque_sp->GetCommandInterpreter(),name,help);
605     new_command->SetRemovable (true);
606     lldb::CommandObjectSP new_command_sp(new_command);
607     if (new_command_sp && m_opaque_sp->LoadSubCommand(name,new_command_sp))
608         return lldb::SBCommand(new_command_sp);
609     return lldb::SBCommand();
610 }
611 
612 lldb::SBCommand
613 SBCommand::AddCommand (const char* name, lldb::SBCommandPluginInterface *impl, const char* help)
614 {
615     if (!IsValid ())
616         return lldb::SBCommand();
617     if (m_opaque_sp->IsMultiwordObject() == false)
618         return lldb::SBCommand();
619     lldb::CommandObjectSP new_command_sp;
620     new_command_sp.reset(new CommandPluginInterfaceImplementation(m_opaque_sp->GetCommandInterpreter(),name,impl,help));
621     if (new_command_sp && m_opaque_sp->LoadSubCommand(name,new_command_sp))
622         return lldb::SBCommand(new_command_sp);
623     return lldb::SBCommand();
624 }
625 
626