1 //===-- CommandCompletions.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 // C Includes
11 #include <sys/stat.h>
12 #if defined(__APPLE__) || defined(__linux__)
13 #include <pwd.h>
14 #endif
15 
16 // C++ Includes
17 // Other libraries and framework includes
18 #include "llvm/ADT/SmallString.h"
19 
20 // Project includes
21 #include "lldb/Core/FileSpecList.h"
22 #include "lldb/Core/Module.h"
23 #include "lldb/Core/PluginManager.h"
24 #include "lldb/Host/FileSpec.h"
25 #include "lldb/Host/FileSystem.h"
26 #include "lldb/Interpreter/Args.h"
27 #include "lldb/Interpreter/CommandCompletions.h"
28 #include "lldb/Interpreter/CommandInterpreter.h"
29 #include "lldb/Interpreter/OptionValueProperties.h"
30 #include "lldb/Symbol/CompileUnit.h"
31 #include "lldb/Symbol/Variable.h"
32 #include "lldb/Target/Target.h"
33 #include "lldb/Utility/CleanUp.h"
34 
35 #include "llvm/ADT/SmallString.h"
36 
37 using namespace lldb_private;
38 
39 CommandCompletions::CommonCompletionElement
40     CommandCompletions::g_common_completions[] = {
41         {eCustomCompletion, nullptr},
42         {eSourceFileCompletion, CommandCompletions::SourceFiles},
43         {eDiskFileCompletion, CommandCompletions::DiskFiles},
44         {eDiskDirectoryCompletion, CommandCompletions::DiskDirectories},
45         {eSymbolCompletion, CommandCompletions::Symbols},
46         {eModuleCompletion, CommandCompletions::Modules},
47         {eSettingsNameCompletion, CommandCompletions::SettingsNames},
48         {ePlatformPluginCompletion, CommandCompletions::PlatformPluginNames},
49         {eArchitectureCompletion, CommandCompletions::ArchitectureNames},
50         {eVariablePathCompletion, CommandCompletions::VariablePath},
51         {eNoCompletion, nullptr} // This one has to be last in the list.
52 };
53 
54 bool CommandCompletions::InvokeCommonCompletionCallbacks(
55     CommandInterpreter &interpreter, uint32_t completion_mask,
56     llvm::StringRef completion_str, int match_start_point,
57     int max_return_elements, SearchFilter *searcher, bool &word_complete,
58     StringList &matches) {
59   bool handled = false;
60 
61   if (completion_mask & eCustomCompletion)
62     return false;
63 
64   for (int i = 0;; i++) {
65     if (g_common_completions[i].type == eNoCompletion)
66       break;
67     else if ((g_common_completions[i].type & completion_mask) ==
68                  g_common_completions[i].type &&
69              g_common_completions[i].callback != nullptr) {
70       handled = true;
71       g_common_completions[i].callback(interpreter, completion_str,
72                                        match_start_point, max_return_elements,
73                                        searcher, word_complete, matches);
74     }
75   }
76   return handled;
77 }
78 
79 int CommandCompletions::SourceFiles(CommandInterpreter &interpreter,
80                                     llvm::StringRef partial_file_name,
81                                     int match_start_point,
82                                     int max_return_elements,
83                                     SearchFilter *searcher, bool &word_complete,
84                                     StringList &matches) {
85   word_complete = true;
86   // Find some way to switch "include support files..."
87   SourceFileCompleter completer(interpreter, false, partial_file_name,
88                                 match_start_point, max_return_elements,
89                                 matches);
90 
91   if (searcher == nullptr) {
92     lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
93     SearchFilterForUnconstrainedSearches null_searcher(target_sp);
94     completer.DoCompletion(&null_searcher);
95   } else {
96     completer.DoCompletion(searcher);
97   }
98   return matches.GetSize();
99 }
100 
101 typedef struct DiskFilesOrDirectoriesBaton {
102   const char *remainder;
103   char *partial_name_copy;
104   bool only_directories;
105   bool *saw_directory;
106   StringList *matches;
107   char *end_ptr;
108   size_t baselen;
109 } DiskFilesOrDirectoriesBaton;
110 
111 FileSpec::EnumerateDirectoryResult
112 DiskFilesOrDirectoriesCallback(void *baton, FileSpec::FileType file_type,
113                                const FileSpec &spec) {
114   const char *name = spec.GetFilename().AsCString();
115 
116   const DiskFilesOrDirectoriesBaton *parameters =
117       (DiskFilesOrDirectoriesBaton *)baton;
118   char *end_ptr = parameters->end_ptr;
119   char *partial_name_copy = parameters->partial_name_copy;
120   const char *remainder = parameters->remainder;
121 
122   // Omit ".", ".." and any . files if the match string doesn't start with .
123   if (name[0] == '.') {
124     if (name[1] == '\0')
125       return FileSpec::eEnumerateDirectoryResultNext;
126     else if (name[1] == '.' && name[2] == '\0')
127       return FileSpec::eEnumerateDirectoryResultNext;
128     else if (remainder[0] != '.')
129       return FileSpec::eEnumerateDirectoryResultNext;
130   }
131 
132   // If we found a directory, we put a "/" at the end of the name.
133 
134   if (remainder[0] == '\0' || strstr(name, remainder) == name) {
135     if (strlen(name) + parameters->baselen >= PATH_MAX)
136       return FileSpec::eEnumerateDirectoryResultNext;
137 
138     strcpy(end_ptr, name);
139 
140     bool isa_directory = false;
141     if (file_type == FileSpec::eFileTypeDirectory)
142       isa_directory = true;
143     else if (file_type == FileSpec::eFileTypeSymbolicLink) {
144       if (FileSpec(partial_name_copy, false).IsDirectory())
145         isa_directory = true;
146     }
147 
148     if (isa_directory) {
149       *parameters->saw_directory = true;
150       size_t len = strlen(parameters->partial_name_copy);
151       partial_name_copy[len] = '/';
152       partial_name_copy[len + 1] = '\0';
153     }
154     if (parameters->only_directories && !isa_directory)
155       return FileSpec::eEnumerateDirectoryResultNext;
156     parameters->matches->AppendString(partial_name_copy);
157   }
158 
159   return FileSpec::eEnumerateDirectoryResultNext;
160 }
161 
162 static int DiskFilesOrDirectories(llvm::StringRef partial_file_name,
163                                   bool only_directories, bool &saw_directory,
164                                   StringList &matches) {
165   // I'm going to  use the "glob" function with GLOB_TILDE for user directory
166   // expansion.
167   // If it is not defined on your host system, you'll need to implement it
168   // yourself...
169 
170   size_t partial_name_len = partial_file_name.size();
171 
172   if (partial_name_len >= PATH_MAX)
173     return matches.GetSize();
174 
175   // This copy of the string will be cut up into the directory part, and the
176   // remainder.  end_ptr below will point to the place of the remainder in this
177   // string.  Then when we've resolved the containing directory, and opened it,
178   // we'll read the directory contents and overwrite the partial_name_copy
179   // starting from end_ptr with each of the matches.  Thus we will preserve the
180   // form the user originally typed.
181 
182   char partial_name_copy[PATH_MAX];
183   memcpy(partial_name_copy, partial_file_name.data(), partial_name_len);
184   partial_name_copy[partial_name_len] = '\0';
185 
186   // We'll need to save a copy of the remainder for comparison, which we do
187   // here.
188   char remainder[PATH_MAX];
189 
190   // end_ptr will point past the last / in partial_name_copy, or if there is no
191   // slash to the beginning of the string.
192   char *end_ptr;
193 
194   end_ptr = strrchr(partial_name_copy, '/');
195 
196   // This will store the resolved form of the containing directory
197   llvm::SmallString<64> containing_part;
198 
199   if (end_ptr == nullptr) {
200     // There's no directory.  If the thing begins with a "~" then this is a bare
201     // user name.
202     if (*partial_name_copy == '~') {
203       // Nothing here but the user name.  We could just put a slash on the end,
204       // but for completeness sake we'll resolve the user name and only put a
205       // slash
206       // on the end if it exists.
207       llvm::SmallString<64> resolved_username(partial_name_copy);
208       FileSpec::ResolveUsername(resolved_username);
209 
210       // Not sure how this would happen, a username longer than PATH_MAX?
211       // Still...
212       if (resolved_username.size() == 0) {
213         // The user name didn't resolve, let's look in the password database for
214         // matches.
215         // The user name database contains duplicates, and is not in
216         // alphabetical order, so
217         // we'll use a set to manage that for us.
218         FileSpec::ResolvePartialUsername(partial_name_copy, matches);
219         if (matches.GetSize() > 0)
220           saw_directory = true;
221         return matches.GetSize();
222       } else {
223         // The thing exists, put a '/' on the end, and return it...
224         // FIXME: complete user names here:
225         partial_name_copy[partial_name_len] = '/';
226         partial_name_copy[partial_name_len + 1] = '\0';
227         matches.AppendString(partial_name_copy);
228         saw_directory = true;
229         return matches.GetSize();
230       }
231     } else {
232       // The containing part is the CWD, and the whole string is the remainder.
233       containing_part = ".";
234       strcpy(remainder, partial_name_copy);
235       end_ptr = partial_name_copy;
236     }
237   } else {
238     if (end_ptr == partial_name_copy) {
239       // We're completing a file or directory in the root volume.
240       containing_part = "/";
241     } else {
242       containing_part.append(partial_name_copy, end_ptr);
243     }
244     // Push end_ptr past the final "/" and set remainder.
245     end_ptr++;
246     strcpy(remainder, end_ptr);
247   }
248 
249   // Look for a user name in the containing part, and if it's there, resolve it
250   // and stick the
251   // result back into the containing_part:
252 
253   if (*partial_name_copy == '~') {
254     FileSpec::ResolveUsername(containing_part);
255     // User name doesn't exist, we're not getting any further...
256     if (containing_part.empty())
257       return matches.GetSize();
258   }
259 
260   // Okay, containing_part is now the directory we want to open and look for
261   // files:
262 
263   size_t baselen = end_ptr - partial_name_copy;
264 
265   DiskFilesOrDirectoriesBaton parameters;
266   parameters.remainder = remainder;
267   parameters.partial_name_copy = partial_name_copy;
268   parameters.only_directories = only_directories;
269   parameters.saw_directory = &saw_directory;
270   parameters.matches = &matches;
271   parameters.end_ptr = end_ptr;
272   parameters.baselen = baselen;
273 
274   FileSpec::EnumerateDirectory(containing_part.c_str(), true, true, true,
275                                DiskFilesOrDirectoriesCallback, &parameters);
276 
277   return matches.GetSize();
278 }
279 
280 int CommandCompletions::DiskFiles(CommandInterpreter &interpreter,
281                                   llvm::StringRef partial_file_name,
282                                   int match_start_point,
283                                   int max_return_elements,
284                                   SearchFilter *searcher, bool &word_complete,
285                                   StringList &matches) {
286   int ret_val =
287       DiskFilesOrDirectories(partial_file_name, false, word_complete, matches);
288   word_complete = !word_complete;
289   return ret_val;
290 }
291 
292 int CommandCompletions::DiskDirectories(
293     CommandInterpreter &interpreter, llvm::StringRef partial_file_name,
294     int match_start_point, int max_return_elements, SearchFilter *searcher,
295     bool &word_complete, StringList &matches) {
296   int ret_val =
297       DiskFilesOrDirectories(partial_file_name, true, word_complete, matches);
298   word_complete = false;
299   return ret_val;
300 }
301 
302 int CommandCompletions::Modules(CommandInterpreter &interpreter,
303                                 llvm::StringRef partial_file_name,
304                                 int match_start_point, int max_return_elements,
305                                 SearchFilter *searcher, bool &word_complete,
306                                 StringList &matches) {
307   word_complete = true;
308   ModuleCompleter completer(interpreter, partial_file_name, match_start_point,
309                             max_return_elements, matches);
310 
311   if (searcher == nullptr) {
312     lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
313     SearchFilterForUnconstrainedSearches null_searcher(target_sp);
314     completer.DoCompletion(&null_searcher);
315   } else {
316     completer.DoCompletion(searcher);
317   }
318   return matches.GetSize();
319 }
320 
321 int CommandCompletions::Symbols(CommandInterpreter &interpreter,
322                                 llvm::StringRef partial_file_name,
323                                 int match_start_point, int max_return_elements,
324                                 SearchFilter *searcher, bool &word_complete,
325                                 StringList &matches) {
326   word_complete = true;
327   SymbolCompleter completer(interpreter, partial_file_name, match_start_point,
328                             max_return_elements, matches);
329 
330   if (searcher == nullptr) {
331     lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
332     SearchFilterForUnconstrainedSearches null_searcher(target_sp);
333     completer.DoCompletion(&null_searcher);
334   } else {
335     completer.DoCompletion(searcher);
336   }
337   return matches.GetSize();
338 }
339 
340 int CommandCompletions::SettingsNames(
341     CommandInterpreter &interpreter, llvm::StringRef partial_setting_name,
342     int match_start_point, int max_return_elements, SearchFilter *searcher,
343     bool &word_complete, StringList &matches) {
344   // Cache the full setting name list
345   static StringList g_property_names;
346   if (g_property_names.GetSize() == 0) {
347     // Generate the full setting name list on demand
348     lldb::OptionValuePropertiesSP properties_sp(
349         interpreter.GetDebugger().GetValueProperties());
350     if (properties_sp) {
351       StreamString strm;
352       properties_sp->DumpValue(nullptr, strm, OptionValue::eDumpOptionName);
353       const std::string &str = strm.GetString();
354       g_property_names.SplitIntoLines(str.c_str(), str.size());
355     }
356   }
357 
358   size_t exact_matches_idx = SIZE_MAX;
359   const size_t num_matches = g_property_names.AutoComplete(
360       partial_setting_name, matches, exact_matches_idx);
361   word_complete = exact_matches_idx != SIZE_MAX;
362   return num_matches;
363 }
364 
365 int CommandCompletions::PlatformPluginNames(
366     CommandInterpreter &interpreter, llvm::StringRef partial_name,
367     int match_start_point, int max_return_elements, SearchFilter *searcher,
368     bool &word_complete, lldb_private::StringList &matches) {
369   const uint32_t num_matches =
370       PluginManager::AutoCompletePlatformName(partial_name, matches);
371   word_complete = num_matches == 1;
372   return num_matches;
373 }
374 
375 int CommandCompletions::ArchitectureNames(
376     CommandInterpreter &interpreter, llvm::StringRef partial_name,
377     int match_start_point, int max_return_elements, SearchFilter *searcher,
378     bool &word_complete, lldb_private::StringList &matches) {
379   const uint32_t num_matches = ArchSpec::AutoComplete(partial_name, matches);
380   word_complete = num_matches == 1;
381   return num_matches;
382 }
383 
384 int CommandCompletions::VariablePath(
385     CommandInterpreter &interpreter, llvm::StringRef partial_name,
386     int match_start_point, int max_return_elements, SearchFilter *searcher,
387     bool &word_complete, lldb_private::StringList &matches) {
388   return Variable::AutoComplete(interpreter.GetExecutionContext(), partial_name,
389                                 matches, word_complete);
390 }
391 
392 CommandCompletions::Completer::Completer(CommandInterpreter &interpreter,
393                                          llvm::StringRef completion_str,
394                                          int match_start_point,
395                                          int max_return_elements,
396                                          StringList &matches)
397     : m_interpreter(interpreter), m_completion_str(completion_str),
398       m_match_start_point(match_start_point),
399       m_max_return_elements(max_return_elements), m_matches(matches) {}
400 
401 CommandCompletions::Completer::~Completer() = default;
402 
403 //----------------------------------------------------------------------
404 // SourceFileCompleter
405 //----------------------------------------------------------------------
406 
407 CommandCompletions::SourceFileCompleter::SourceFileCompleter(
408     CommandInterpreter &interpreter, bool include_support_files,
409     llvm::StringRef completion_str, int match_start_point,
410     int max_return_elements, StringList &matches)
411     : CommandCompletions::Completer(interpreter, completion_str,
412                                     match_start_point, max_return_elements,
413                                     matches),
414       m_include_support_files(include_support_files), m_matching_files() {
415   FileSpec partial_spec(m_completion_str, false);
416   m_file_name = partial_spec.GetFilename().GetCString();
417   m_dir_name = partial_spec.GetDirectory().GetCString();
418 }
419 
420 Searcher::Depth CommandCompletions::SourceFileCompleter::GetDepth() {
421   return eDepthCompUnit;
422 }
423 
424 Searcher::CallbackReturn
425 CommandCompletions::SourceFileCompleter::SearchCallback(SearchFilter &filter,
426                                                         SymbolContext &context,
427                                                         Address *addr,
428                                                         bool complete) {
429   if (context.comp_unit != nullptr) {
430     if (m_include_support_files) {
431       FileSpecList supporting_files = context.comp_unit->GetSupportFiles();
432       for (size_t sfiles = 0; sfiles < supporting_files.GetSize(); sfiles++) {
433         const FileSpec &sfile_spec =
434             supporting_files.GetFileSpecAtIndex(sfiles);
435         const char *sfile_file_name = sfile_spec.GetFilename().GetCString();
436         const char *sfile_dir_name = sfile_spec.GetFilename().GetCString();
437         bool match = false;
438         if (m_file_name && sfile_file_name &&
439             strstr(sfile_file_name, m_file_name) == sfile_file_name)
440           match = true;
441         if (match && m_dir_name && sfile_dir_name &&
442             strstr(sfile_dir_name, m_dir_name) != sfile_dir_name)
443           match = false;
444 
445         if (match) {
446           m_matching_files.AppendIfUnique(sfile_spec);
447         }
448       }
449     } else {
450       const char *cur_file_name = context.comp_unit->GetFilename().GetCString();
451       const char *cur_dir_name = context.comp_unit->GetDirectory().GetCString();
452 
453       bool match = false;
454       if (m_file_name && cur_file_name &&
455           strstr(cur_file_name, m_file_name) == cur_file_name)
456         match = true;
457 
458       if (match && m_dir_name && cur_dir_name &&
459           strstr(cur_dir_name, m_dir_name) != cur_dir_name)
460         match = false;
461 
462       if (match) {
463         m_matching_files.AppendIfUnique(context.comp_unit);
464       }
465     }
466   }
467   return Searcher::eCallbackReturnContinue;
468 }
469 
470 size_t
471 CommandCompletions::SourceFileCompleter::DoCompletion(SearchFilter *filter) {
472   filter->Search(*this);
473   // Now convert the filelist to completions:
474   for (size_t i = 0; i < m_matching_files.GetSize(); i++) {
475     m_matches.AppendString(
476         m_matching_files.GetFileSpecAtIndex(i).GetFilename().GetCString());
477   }
478   return m_matches.GetSize();
479 }
480 
481 //----------------------------------------------------------------------
482 // SymbolCompleter
483 //----------------------------------------------------------------------
484 
485 static bool regex_chars(const char comp) {
486   return (comp == '[' || comp == ']' || comp == '(' || comp == ')' ||
487           comp == '{' || comp == '}' || comp == '+' || comp == '.' ||
488           comp == '*' || comp == '|' || comp == '^' || comp == '$' ||
489           comp == '\\' || comp == '?');
490 }
491 
492 CommandCompletions::SymbolCompleter::SymbolCompleter(
493     CommandInterpreter &interpreter, llvm::StringRef completion_str,
494     int match_start_point, int max_return_elements, StringList &matches)
495     : CommandCompletions::Completer(interpreter, completion_str,
496                                     match_start_point, max_return_elements,
497                                     matches) {
498   std::string regex_str;
499   if (!completion_str.empty()) {
500     regex_str.append("^");
501     regex_str.append(completion_str);
502   } else {
503     // Match anything since the completion string is empty
504     regex_str.append(".");
505   }
506   std::string::iterator pos =
507       find_if(regex_str.begin() + 1, regex_str.end(), regex_chars);
508   while (pos < regex_str.end()) {
509     pos = regex_str.insert(pos, '\\');
510     pos = find_if(pos + 2, regex_str.end(), regex_chars);
511   }
512   m_regex.Compile(regex_str);
513 }
514 
515 Searcher::Depth CommandCompletions::SymbolCompleter::GetDepth() {
516   return eDepthModule;
517 }
518 
519 Searcher::CallbackReturn CommandCompletions::SymbolCompleter::SearchCallback(
520     SearchFilter &filter, SymbolContext &context, Address *addr,
521     bool complete) {
522   if (context.module_sp) {
523     SymbolContextList sc_list;
524     const bool include_symbols = true;
525     const bool include_inlines = true;
526     const bool append = true;
527     context.module_sp->FindFunctions(m_regex, include_symbols, include_inlines,
528                                      append, sc_list);
529 
530     SymbolContext sc;
531     // Now add the functions & symbols to the list - only add if unique:
532     for (uint32_t i = 0; i < sc_list.GetSize(); i++) {
533       if (sc_list.GetContextAtIndex(i, sc)) {
534         ConstString func_name = sc.GetFunctionName(Mangled::ePreferDemangled);
535         if (!func_name.IsEmpty())
536           m_match_set.insert(func_name);
537       }
538     }
539   }
540   return Searcher::eCallbackReturnContinue;
541 }
542 
543 size_t CommandCompletions::SymbolCompleter::DoCompletion(SearchFilter *filter) {
544   filter->Search(*this);
545   collection::iterator pos = m_match_set.begin(), end = m_match_set.end();
546   for (pos = m_match_set.begin(); pos != end; pos++)
547     m_matches.AppendString((*pos).GetCString());
548 
549   return m_matches.GetSize();
550 }
551 
552 //----------------------------------------------------------------------
553 // ModuleCompleter
554 //----------------------------------------------------------------------
555 CommandCompletions::ModuleCompleter::ModuleCompleter(
556     CommandInterpreter &interpreter, llvm::StringRef completion_str,
557     int match_start_point, int max_return_elements, StringList &matches)
558     : CommandCompletions::Completer(interpreter, completion_str,
559                                     match_start_point, max_return_elements,
560                                     matches) {
561   FileSpec partial_spec(m_completion_str, false);
562   m_file_name = partial_spec.GetFilename().GetCString();
563   m_dir_name = partial_spec.GetDirectory().GetCString();
564 }
565 
566 Searcher::Depth CommandCompletions::ModuleCompleter::GetDepth() {
567   return eDepthModule;
568 }
569 
570 Searcher::CallbackReturn CommandCompletions::ModuleCompleter::SearchCallback(
571     SearchFilter &filter, SymbolContext &context, Address *addr,
572     bool complete) {
573   if (context.module_sp) {
574     const char *cur_file_name =
575         context.module_sp->GetFileSpec().GetFilename().GetCString();
576     const char *cur_dir_name =
577         context.module_sp->GetFileSpec().GetDirectory().GetCString();
578 
579     bool match = false;
580     if (m_file_name && cur_file_name &&
581         strstr(cur_file_name, m_file_name) == cur_file_name)
582       match = true;
583 
584     if (match && m_dir_name && cur_dir_name &&
585         strstr(cur_dir_name, m_dir_name) != cur_dir_name)
586       match = false;
587 
588     if (match) {
589       m_matches.AppendString(cur_file_name);
590     }
591   }
592   return Searcher::eCallbackReturnContinue;
593 }
594 
595 size_t CommandCompletions::ModuleCompleter::DoCompletion(SearchFilter *filter) {
596   filter->Search(*this);
597   return m_matches.GetSize();
598 }
599