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-types.h"
11 #include "lldb/Interpreter/Args.h"
12 #include "lldb/Core/SourceManager.h"
13 #include "lldb/Core/Listener.h"
14 #include "lldb/Interpreter/CommandInterpreter.h"
15 #include "lldb/Interpreter/CommandReturnObject.h"
16 #include "lldb/Target/Target.h"
17 
18 #include "lldb/API/SBBroadcaster.h"
19 #include "lldb/API/SBDebugger.h"
20 #include "lldb/API/SBCommandReturnObject.h"
21 #include "lldb/API/SBCommandInterpreter.h"
22 #include "lldb/API/SBProcess.h"
23 #include "lldb/API/SBTarget.h"
24 #include "lldb/API/SBListener.h"
25 #include "lldb/API/SBStream.h"
26 #include "lldb/API/SBStringList.h"
27 
28 using namespace lldb;
29 using namespace lldb_private;
30 
31 
32 SBCommandInterpreter::SBCommandInterpreter (CommandInterpreter *interpreter) :
33     m_opaque_ptr (interpreter)
34 {
35     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
36 
37     if (log)
38         log->Printf ("SBCommandInterpreter::SBCommandInterpreter (interpreter=%p)"
39                      " => SBCommandInterpreter(%p)", interpreter, m_opaque_ptr);
40 }
41 
42 SBCommandInterpreter::SBCommandInterpreter(const SBCommandInterpreter &rhs) :
43     m_opaque_ptr (rhs.m_opaque_ptr)
44 {
45 }
46 
47 const SBCommandInterpreter &
48 SBCommandInterpreter::operator = (const SBCommandInterpreter &rhs)
49 {
50     m_opaque_ptr = rhs.m_opaque_ptr;
51     return *this;
52 }
53 
54 SBCommandInterpreter::~SBCommandInterpreter ()
55 {
56 }
57 
58 bool
59 SBCommandInterpreter::IsValid() const
60 {
61     return m_opaque_ptr != NULL;
62 }
63 
64 
65 bool
66 SBCommandInterpreter::CommandExists (const char *cmd)
67 {
68     if (m_opaque_ptr)
69         return m_opaque_ptr->CommandExists (cmd);
70     return false;
71 }
72 
73 bool
74 SBCommandInterpreter::AliasExists (const char *cmd)
75 {
76     if (m_opaque_ptr)
77         return m_opaque_ptr->AliasExists (cmd);
78     return false;
79 }
80 
81 lldb::ReturnStatus
82 SBCommandInterpreter::HandleCommand (const char *command_line, SBCommandReturnObject &result, bool add_to_history)
83 {
84     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
85 
86     if (log)
87         log->Printf ("SBCommandInterpreter(%p)::HandleCommand (command=\"%s\", SBCommandReturnObject(%p), add_to_history=%i)",
88                      m_opaque_ptr, command_line, result.get(), add_to_history);
89 
90     result.Clear();
91     if (m_opaque_ptr)
92     {
93         TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
94         Mutex::Locker api_locker;
95         if (target_sp)
96             api_locker.Reset(target_sp->GetAPIMutex().GetMutex());
97         m_opaque_ptr->HandleCommand (command_line, add_to_history, result.ref());
98     }
99     else
100     {
101         result->AppendError ("SBCommandInterpreter is not valid");
102         result->SetStatus (eReturnStatusFailed);
103     }
104 
105     // We need to get the value again, in case the command disabled the log!
106     log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API);
107     if (log)
108     {
109         SBStream sstr;
110         result.GetDescription (sstr);
111         log->Printf ("SBCommandInterpreter(%p)::HandleCommand (command=\"%s\", SBCommandReturnObject(%p): %s, add_to_history=%i) => %i",
112                      m_opaque_ptr, command_line, result.get(), sstr.GetData(), add_to_history, result.GetStatus());
113     }
114 
115     return result.GetStatus();
116 }
117 
118 int
119 SBCommandInterpreter::HandleCompletion (const char *current_line,
120                                         const char *cursor,
121                                         const char *last_char,
122                                         int match_start_point,
123                                         int max_return_elements,
124                                         SBStringList &matches)
125 {
126     int num_completions = 0;
127     if (m_opaque_ptr)
128     {
129         lldb_private::StringList lldb_matches;
130         num_completions =  m_opaque_ptr->HandleCompletion (current_line, cursor, last_char, match_start_point,
131                                                            max_return_elements, lldb_matches);
132 
133         SBStringList temp_list (&lldb_matches);
134         matches.AppendList (temp_list);
135     }
136     return num_completions;
137 }
138 
139 int
140 SBCommandInterpreter::HandleCompletion (const char *current_line,
141                   uint32_t cursor_pos,
142                   int match_start_point,
143                   int max_return_elements,
144                   lldb::SBStringList &matches)
145 {
146     const char *cursor = current_line + cursor_pos;
147     const char *last_char = current_line + strlen (current_line);
148     return HandleCompletion (current_line, cursor, last_char, match_start_point, max_return_elements, matches);
149 }
150 
151 bool
152 SBCommandInterpreter::HasCommands ()
153 {
154     if (m_opaque_ptr)
155         return m_opaque_ptr->HasCommands();
156     return false;
157 }
158 
159 bool
160 SBCommandInterpreter::HasAliases ()
161 {
162     if (m_opaque_ptr)
163         return m_opaque_ptr->HasAliases();
164     return false;
165 }
166 
167 bool
168 SBCommandInterpreter::HasAliasOptions ()
169 {
170     if (m_opaque_ptr)
171         return m_opaque_ptr->HasAliasOptions ();
172     return false;
173 }
174 
175 SBProcess
176 SBCommandInterpreter::GetProcess ()
177 {
178     SBProcess process;
179     if (m_opaque_ptr)
180     {
181         TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
182         if (target_sp)
183         {
184             Mutex::Locker api_locker(target_sp->GetAPIMutex());
185             process.SetProcess(target_sp->GetProcessSP());
186         }
187     }
188     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
189 
190     if (log)
191         log->Printf ("SBCommandInterpreter(%p)::GetProcess () => SBProcess(%p)",
192                      m_opaque_ptr, process.get());
193 
194 
195     return process;
196 }
197 
198 ssize_t
199 SBCommandInterpreter::WriteToScriptInterpreter (const char *src)
200 {
201     return WriteToScriptInterpreter (src, strlen(src));
202 }
203 
204 ssize_t
205 SBCommandInterpreter::WriteToScriptInterpreter (const char *src, size_t src_len)
206 {
207     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
208 
209     ssize_t bytes_written = 0;
210     if (m_opaque_ptr && src && src[0])
211     {
212         ScriptInterpreter *script_interpreter = m_opaque_ptr->GetScriptInterpreter();
213         if (script_interpreter)
214             bytes_written = ::write (script_interpreter->GetMasterFileDescriptor(), src, src_len);
215     }
216     if (log)
217         log->Printf ("SBCommandInterpreter(%p)::WriteToScriptInterpreter (src=\"%s\", src_len=%zu) => %zi",
218                      m_opaque_ptr, src, src_len, bytes_written);
219 
220     return bytes_written;
221 }
222 
223 
224 CommandInterpreter *
225 SBCommandInterpreter::get ()
226 {
227     return m_opaque_ptr;
228 }
229 
230 CommandInterpreter &
231 SBCommandInterpreter::ref ()
232 {
233     assert (m_opaque_ptr);
234     return *m_opaque_ptr;
235 }
236 
237 void
238 SBCommandInterpreter::reset (lldb_private::CommandInterpreter *interpreter)
239 {
240     m_opaque_ptr = interpreter;
241 }
242 
243 void
244 SBCommandInterpreter::SourceInitFileInHomeDirectory (SBCommandReturnObject &result)
245 {
246     result.Clear();
247     if (m_opaque_ptr)
248     {
249         TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
250         Mutex::Locker api_locker;
251         if (target_sp)
252             api_locker.Reset(target_sp->GetAPIMutex().GetMutex());
253         m_opaque_ptr->SourceInitFile (false, result.ref());
254     }
255     else
256     {
257         result->AppendError ("SBCommandInterpreter is not valid");
258         result->SetStatus (eReturnStatusFailed);
259     }
260     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
261 
262     if (log)
263         log->Printf ("SBCommandInterpreter(%p)::SourceInitFileInHomeDirectory (&SBCommandReturnObject(%p))",
264                      m_opaque_ptr, result.get());
265 
266 }
267 
268 void
269 SBCommandInterpreter::SourceInitFileInCurrentWorkingDirectory (SBCommandReturnObject &result)
270 {
271     result.Clear();
272     if (m_opaque_ptr)
273     {
274         TargetSP target_sp(m_opaque_ptr->GetDebugger().GetSelectedTarget());
275         Mutex::Locker api_locker;
276         if (target_sp)
277             api_locker.Reset(target_sp->GetAPIMutex().GetMutex());
278         m_opaque_ptr->SourceInitFile (true, result.ref());
279     }
280     else
281     {
282         result->AppendError ("SBCommandInterpreter is not valid");
283         result->SetStatus (eReturnStatusFailed);
284     }
285     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
286 
287     if (log)
288         log->Printf ("SBCommandInterpreter(%p)::SourceInitFileInCurrentWorkingDirectory (&SBCommandReturnObject(%p))",
289                      m_opaque_ptr, result.get());
290 }
291 
292 SBBroadcaster
293 SBCommandInterpreter::GetBroadcaster ()
294 {
295     LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
296 
297     SBBroadcaster broadcaster (m_opaque_ptr, false);
298 
299     if (log)
300         log->Printf ("SBCommandInterpreter(%p)::GetBroadcaster() => SBBroadcaster(%p)",
301                      m_opaque_ptr, broadcaster.get());
302 
303     return broadcaster;
304 }
305 
306 const char *
307 SBCommandInterpreter::GetArgumentTypeAsCString (const lldb::CommandArgumentType arg_type)
308 {
309     return CommandObject::GetArgumentTypeAsCString (arg_type);
310 }
311 
312 const char *
313 SBCommandInterpreter::GetArgumentDescriptionAsCString (const lldb::CommandArgumentType arg_type)
314 {
315     return CommandObject::GetArgumentDescriptionAsCString (arg_type);
316 }
317 
318 
319 #ifndef LLDB_DISABLE_PYTHON
320 extern "C" bool
321 LLDBSwigPythonBreakpointCallbackFunction
322 (
323     const char *python_function_name,
324     const char *session_dictionary_name,
325     const lldb::StackFrameSP& sb_frame,
326     const lldb::BreakpointLocationSP& sb_bp_loc
327 );
328 
329 extern "C" std::string
330 LLDBSwigPythonCallTypeScript
331 (
332     const char *python_function_name,
333     const char *session_dictionary_name,
334     const lldb::ValueObjectSP& valobj_sp
335 );
336 
337 extern "C" void*
338 LLDBSwigPythonCreateSyntheticProvider
339 (
340     const std::string python_class_name,
341     const char *session_dictionary_name,
342     const lldb::ValueObjectSP& valobj_sp
343 );
344 
345 
346 extern "C" uint32_t       LLDBSwigPython_CalculateNumChildren        (void *implementor);
347 extern "C" void*          LLDBSwigPython_GetChildAtIndex             (void *implementor, uint32_t idx);
348 extern "C" int            LLDBSwigPython_GetIndexOfChildWithName     (void *implementor, const char* child_name);
349 extern "C" void*          LLDBSWIGPython_CastPyObjectToSBValue       (void* data);
350 extern "C" void           LLDBSwigPython_UpdateSynthProviderInstance (void* implementor);
351 
352 extern "C" bool           LLDBSwigPythonCallCommand
353 (
354     const char *python_function_name,
355     const char *session_dictionary_name,
356     lldb::DebuggerSP& debugger,
357     const char* args,
358     std::string& err_msg,
359     lldb_private::CommandReturnObject& cmd_retobj
360 );
361 
362 // Defined in the SWIG source file
363 extern "C" void
364 init_lldb(void);
365 
366 extern "C" bool           LLDBSwigPythonCallModuleInit
367 (
368     const std::string python_module_name,
369     const char *session_dictionary_name,
370     lldb::DebuggerSP& debugger
371 );
372 
373 #else
374 
375 extern "C" void init_lldb(void);
376 
377 // Usually defined in the SWIG source file, but we have sripting disabled
378 extern "C" void
379 init_lldb(void)
380 {
381 }
382 
383 #endif
384 
385 void
386 SBCommandInterpreter::InitializeSWIG ()
387 {
388     static bool g_initialized = false;
389     if (!g_initialized)
390     {
391         g_initialized = true;
392 #ifndef LLDB_DISABLE_PYTHON
393         ScriptInterpreter::InitializeInterpreter (init_lldb,
394                                                   LLDBSwigPythonBreakpointCallbackFunction,
395                                                   LLDBSwigPythonCallTypeScript,
396                                                   LLDBSwigPythonCreateSyntheticProvider,
397                                                   LLDBSwigPython_CalculateNumChildren,
398                                                   LLDBSwigPython_GetChildAtIndex,
399                                                   LLDBSwigPython_GetIndexOfChildWithName,
400                                                   LLDBSWIGPython_CastPyObjectToSBValue,
401                                                   LLDBSwigPython_UpdateSynthProviderInstance,
402                                                   LLDBSwigPythonCallCommand,
403                                                   LLDBSwigPythonCallModuleInit);
404 #endif
405     }
406 }
407