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