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 #include <sys/stat.h>
11 #if defined(__APPLE__) || defined(__linux__)
12 #include <pwd.h>
13 #endif
14 
15 #include "llvm/ADT/SmallString.h"
16 #include "llvm/ADT/StringSet.h"
17 
18 #include "lldb/Core/FileSpecList.h"
19 #include "lldb/Core/Module.h"
20 #include "lldb/Core/PluginManager.h"
21 #include "lldb/Host/FileSystem.h"
22 #include "lldb/Interpreter/CommandCompletions.h"
23 #include "lldb/Interpreter/CommandInterpreter.h"
24 #include "lldb/Interpreter/OptionValueProperties.h"
25 #include "lldb/Symbol/CompileUnit.h"
26 #include "lldb/Symbol/Variable.h"
27 #include "lldb/Target/Target.h"
28 #include "lldb/Utility/Args.h"
29 #include "lldb/Utility/FileSpec.h"
30 #include "lldb/Utility/StreamString.h"
31 #include "lldb/Utility/TildeExpressionResolver.h"
32 
33 #include "llvm/ADT/SmallString.h"
34 #include "llvm/Support/FileSystem.h"
35 #include "llvm/Support/Path.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     CompletionRequest &request, SearchFilter *searcher) {
57   bool handled = false;
58 
59   if (completion_mask & eCustomCompletion)
60     return false;
61 
62   for (int i = 0;; i++) {
63     if (g_common_completions[i].type == eNoCompletion)
64       break;
65     else if ((g_common_completions[i].type & completion_mask) ==
66                  g_common_completions[i].type &&
67              g_common_completions[i].callback != nullptr) {
68       handled = true;
69       g_common_completions[i].callback(interpreter, request, searcher);
70     }
71   }
72   return handled;
73 }
74 
75 int CommandCompletions::SourceFiles(CommandInterpreter &interpreter,
76                                     CompletionRequest &request,
77                                     SearchFilter *searcher) {
78   request.SetWordComplete(true);
79   // Find some way to switch "include support files..."
80   SourceFileCompleter completer(interpreter, false, request);
81 
82   if (searcher == nullptr) {
83     lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
84     SearchFilterForUnconstrainedSearches null_searcher(target_sp);
85     completer.DoCompletion(&null_searcher);
86   } else {
87     completer.DoCompletion(searcher);
88   }
89   return request.GetNumberOfMatches();
90 }
91 
92 static int DiskFilesOrDirectories(const llvm::Twine &partial_name,
93                                   bool only_directories, StringList &matches,
94                                   TildeExpressionResolver &Resolver) {
95   matches.Clear();
96 
97   llvm::SmallString<256> CompletionBuffer;
98   llvm::SmallString<256> Storage;
99   partial_name.toVector(CompletionBuffer);
100 
101   if (CompletionBuffer.size() >= PATH_MAX)
102     return matches.GetSize();
103 
104   namespace path = llvm::sys::path;
105 
106   llvm::StringRef SearchDir;
107   llvm::StringRef PartialItem;
108 
109   if (CompletionBuffer.startswith("~")) {
110     llvm::StringRef Buffer(CompletionBuffer);
111     size_t FirstSep =
112         Buffer.find_if([](char c) { return path::is_separator(c); });
113 
114     llvm::StringRef Username = Buffer.take_front(FirstSep);
115     llvm::StringRef Remainder;
116     if (FirstSep != llvm::StringRef::npos)
117       Remainder = Buffer.drop_front(FirstSep + 1);
118 
119     llvm::SmallString<256> Resolved;
120     if (!Resolver.ResolveExact(Username, Resolved)) {
121       // We couldn't resolve it as a full username.  If there were no slashes
122       // then this might be a partial username.   We try to resolve it as such
123       // but after that, we're done regardless of any matches.
124       if (FirstSep == llvm::StringRef::npos) {
125         llvm::StringSet<> MatchSet;
126         Resolver.ResolvePartial(Username, MatchSet);
127         for (const auto &S : MatchSet) {
128           Resolved = S.getKey();
129           path::append(Resolved, path::get_separator());
130           matches.AppendString(Resolved);
131         }
132       }
133       return matches.GetSize();
134     }
135 
136     // If there was no trailing slash, then we're done as soon as we resolve
137     // the expression to the correct directory.  Otherwise we need to continue
138     // looking for matches within that directory.
139     if (FirstSep == llvm::StringRef::npos) {
140       // Make sure it ends with a separator.
141       path::append(CompletionBuffer, path::get_separator());
142       matches.AppendString(CompletionBuffer);
143       return matches.GetSize();
144     }
145 
146     // We want to keep the form the user typed, so we special case this to
147     // search in the fully resolved directory, but CompletionBuffer keeps the
148     // unmodified form that the user typed.
149     Storage = Resolved;
150     llvm::StringRef RemainderDir = path::parent_path(Remainder);
151     if (!RemainderDir.empty()) {
152       // Append the remaining path to the resolved directory.
153       Storage.append(path::get_separator());
154       Storage.append(RemainderDir);
155     }
156     SearchDir = Storage;
157   } else {
158     SearchDir = path::parent_path(CompletionBuffer);
159   }
160 
161   size_t FullPrefixLen = CompletionBuffer.size();
162 
163   PartialItem = path::filename(CompletionBuffer);
164 
165   // path::filename() will return "." when the passed path ends with a
166   // directory separator. We have to filter those out, but only when the
167   // "." doesn't come from the completion request itself.
168   if (PartialItem == "." && path::is_separator(CompletionBuffer.back()))
169     PartialItem = llvm::StringRef();
170 
171   if (SearchDir.empty()) {
172     llvm::sys::fs::current_path(Storage);
173     SearchDir = Storage;
174   }
175   assert(!PartialItem.contains(path::get_separator()));
176 
177   // SearchDir now contains the directory to search in, and Prefix contains the
178   // text we want to match against items in that directory.
179 
180   FileSystem &fs = FileSystem::Instance();
181   std::error_code EC;
182   llvm::vfs::directory_iterator Iter = fs.DirBegin(SearchDir, EC);
183   llvm::vfs::directory_iterator End;
184   for (; Iter != End && !EC; Iter.increment(EC)) {
185     auto &Entry = *Iter;
186     llvm::ErrorOr<llvm::vfs::Status> Status = fs.GetStatus(Entry.path());
187 
188     if (!Status)
189       continue;
190 
191     auto Name = path::filename(Entry.path());
192 
193     // Omit ".", ".."
194     if (Name == "." || Name == ".." || !Name.startswith(PartialItem))
195       continue;
196 
197     bool is_dir = Status->isDirectory();
198 
199     // If it's a symlink, then we treat it as a directory as long as the target
200     // is a directory.
201     if (Status->isSymlink()) {
202       FileSpec symlink_filespec(Entry.path());
203       FileSpec resolved_filespec;
204       auto error = fs.ResolveSymbolicLink(symlink_filespec, resolved_filespec);
205       if (error.Success())
206         is_dir = fs.IsDirectory(symlink_filespec);
207     }
208 
209     if (only_directories && !is_dir)
210       continue;
211 
212     // Shrink it back down so that it just has the original prefix the user
213     // typed and remove the part of the name which is common to the located
214     // item and what the user typed.
215     CompletionBuffer.resize(FullPrefixLen);
216     Name = Name.drop_front(PartialItem.size());
217     CompletionBuffer.append(Name);
218 
219     if (is_dir) {
220       path::append(CompletionBuffer, path::get_separator());
221     }
222 
223     matches.AppendString(CompletionBuffer);
224   }
225 
226   return matches.GetSize();
227 }
228 
229 static int DiskFilesOrDirectories(CompletionRequest &request,
230                                   bool only_directories) {
231   request.SetWordComplete(false);
232   StandardTildeExpressionResolver resolver;
233   StringList matches;
234   DiskFilesOrDirectories(request.GetCursorArgumentPrefix(), only_directories,
235                          matches, resolver);
236   request.AddCompletions(matches);
237   return request.GetNumberOfMatches();
238 }
239 
240 int CommandCompletions::DiskFiles(CommandInterpreter &interpreter,
241                                   CompletionRequest &request,
242                                   SearchFilter *searcher) {
243   return DiskFilesOrDirectories(request, /*only_dirs*/ false);
244 }
245 
246 int CommandCompletions::DiskFiles(const llvm::Twine &partial_file_name,
247                                   StringList &matches,
248                                   TildeExpressionResolver &Resolver) {
249   return DiskFilesOrDirectories(partial_file_name, false, matches, Resolver);
250 }
251 
252 int CommandCompletions::DiskDirectories(CommandInterpreter &interpreter,
253                                         CompletionRequest &request,
254                                         SearchFilter *searcher) {
255   return DiskFilesOrDirectories(request, /*only_dirs*/ true);
256 }
257 
258 int CommandCompletions::DiskDirectories(const llvm::Twine &partial_file_name,
259                                         StringList &matches,
260                                         TildeExpressionResolver &Resolver) {
261   return DiskFilesOrDirectories(partial_file_name, true, matches, Resolver);
262 }
263 
264 int CommandCompletions::Modules(CommandInterpreter &interpreter,
265                                 CompletionRequest &request,
266                                 SearchFilter *searcher) {
267   request.SetWordComplete(true);
268   ModuleCompleter completer(interpreter, request);
269 
270   if (searcher == nullptr) {
271     lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
272     SearchFilterForUnconstrainedSearches null_searcher(target_sp);
273     completer.DoCompletion(&null_searcher);
274   } else {
275     completer.DoCompletion(searcher);
276   }
277   return request.GetNumberOfMatches();
278 }
279 
280 int CommandCompletions::Symbols(CommandInterpreter &interpreter,
281                                 CompletionRequest &request,
282                                 SearchFilter *searcher) {
283   request.SetWordComplete(true);
284   SymbolCompleter completer(interpreter, request);
285 
286   if (searcher == nullptr) {
287     lldb::TargetSP target_sp = interpreter.GetDebugger().GetSelectedTarget();
288     SearchFilterForUnconstrainedSearches null_searcher(target_sp);
289     completer.DoCompletion(&null_searcher);
290   } else {
291     completer.DoCompletion(searcher);
292   }
293   return request.GetNumberOfMatches();
294 }
295 
296 int CommandCompletions::SettingsNames(CommandInterpreter &interpreter,
297                                       CompletionRequest &request,
298                                       SearchFilter *searcher) {
299   // Cache the full setting name list
300   static StringList g_property_names;
301   if (g_property_names.GetSize() == 0) {
302     // Generate the full setting name list on demand
303     lldb::OptionValuePropertiesSP properties_sp(
304         interpreter.GetDebugger().GetValueProperties());
305     if (properties_sp) {
306       StreamString strm;
307       properties_sp->DumpValue(nullptr, strm, OptionValue::eDumpOptionName);
308       const std::string &str = strm.GetString();
309       g_property_names.SplitIntoLines(str.c_str(), str.size());
310     }
311   }
312 
313   size_t exact_matches_idx = SIZE_MAX;
314   StringList matches;
315   g_property_names.AutoComplete(request.GetCursorArgumentPrefix(), matches,
316                                 exact_matches_idx);
317   request.SetWordComplete(exact_matches_idx != SIZE_MAX);
318   request.AddCompletions(matches);
319   return request.GetNumberOfMatches();
320 }
321 
322 int CommandCompletions::PlatformPluginNames(CommandInterpreter &interpreter,
323                                             CompletionRequest &request,
324                                             SearchFilter *searcher) {
325   StringList new_matches;
326   std::size_t num_matches = PluginManager::AutoCompletePlatformName(
327       request.GetCursorArgumentPrefix(), new_matches);
328   request.SetWordComplete(num_matches == 1);
329   request.AddCompletions(new_matches);
330   return request.GetNumberOfMatches();
331 }
332 
333 int CommandCompletions::ArchitectureNames(CommandInterpreter &interpreter,
334                                           CompletionRequest &request,
335                                           SearchFilter *searcher) {
336   const uint32_t num_matches = ArchSpec::AutoComplete(request);
337   request.SetWordComplete(num_matches == 1);
338   return num_matches;
339 }
340 
341 int CommandCompletions::VariablePath(CommandInterpreter &interpreter,
342                                      CompletionRequest &request,
343                                      SearchFilter *searcher) {
344   return Variable::AutoComplete(interpreter.GetExecutionContext(), request);
345 }
346 
347 CommandCompletions::Completer::Completer(CommandInterpreter &interpreter,
348                                          CompletionRequest &request)
349     : m_interpreter(interpreter), m_request(request) {}
350 
351 CommandCompletions::Completer::~Completer() = default;
352 
353 //----------------------------------------------------------------------
354 // SourceFileCompleter
355 //----------------------------------------------------------------------
356 
357 CommandCompletions::SourceFileCompleter::SourceFileCompleter(
358     CommandInterpreter &interpreter, bool include_support_files,
359     CompletionRequest &request)
360     : CommandCompletions::Completer(interpreter, request),
361       m_include_support_files(include_support_files), m_matching_files() {
362   FileSpec partial_spec(m_request.GetCursorArgumentPrefix());
363   m_file_name = partial_spec.GetFilename().GetCString();
364   m_dir_name = partial_spec.GetDirectory().GetCString();
365 }
366 
367 lldb::SearchDepth CommandCompletions::SourceFileCompleter::GetDepth() {
368   return lldb::eSearchDepthCompUnit;
369 }
370 
371 Searcher::CallbackReturn
372 CommandCompletions::SourceFileCompleter::SearchCallback(SearchFilter &filter,
373                                                         SymbolContext &context,
374                                                         Address *addr,
375                                                         bool complete) {
376   if (context.comp_unit != nullptr) {
377     if (m_include_support_files) {
378       FileSpecList supporting_files = context.comp_unit->GetSupportFiles();
379       for (size_t sfiles = 0; sfiles < supporting_files.GetSize(); sfiles++) {
380         const FileSpec &sfile_spec =
381             supporting_files.GetFileSpecAtIndex(sfiles);
382         const char *sfile_file_name = sfile_spec.GetFilename().GetCString();
383         const char *sfile_dir_name = sfile_spec.GetFilename().GetCString();
384         bool match = false;
385         if (m_file_name && sfile_file_name &&
386             strstr(sfile_file_name, m_file_name) == sfile_file_name)
387           match = true;
388         if (match && m_dir_name && sfile_dir_name &&
389             strstr(sfile_dir_name, m_dir_name) != sfile_dir_name)
390           match = false;
391 
392         if (match) {
393           m_matching_files.AppendIfUnique(sfile_spec);
394         }
395       }
396     } else {
397       const char *cur_file_name = context.comp_unit->GetFilename().GetCString();
398       const char *cur_dir_name = context.comp_unit->GetDirectory().GetCString();
399 
400       bool match = false;
401       if (m_file_name && cur_file_name &&
402           strstr(cur_file_name, m_file_name) == cur_file_name)
403         match = true;
404 
405       if (match && m_dir_name && cur_dir_name &&
406           strstr(cur_dir_name, m_dir_name) != cur_dir_name)
407         match = false;
408 
409       if (match) {
410         m_matching_files.AppendIfUnique(context.comp_unit);
411       }
412     }
413   }
414   return Searcher::eCallbackReturnContinue;
415 }
416 
417 size_t
418 CommandCompletions::SourceFileCompleter::DoCompletion(SearchFilter *filter) {
419   filter->Search(*this);
420   // Now convert the filelist to completions:
421   for (size_t i = 0; i < m_matching_files.GetSize(); i++) {
422     m_request.AddCompletion(
423         m_matching_files.GetFileSpecAtIndex(i).GetFilename().GetCString());
424   }
425   return m_request.GetNumberOfMatches();
426 }
427 
428 //----------------------------------------------------------------------
429 // SymbolCompleter
430 //----------------------------------------------------------------------
431 
432 static bool regex_chars(const char comp) {
433   return (comp == '[' || comp == ']' || comp == '(' || comp == ')' ||
434           comp == '{' || comp == '}' || comp == '+' || comp == '.' ||
435           comp == '*' || comp == '|' || comp == '^' || comp == '$' ||
436           comp == '\\' || comp == '?');
437 }
438 
439 CommandCompletions::SymbolCompleter::SymbolCompleter(
440     CommandInterpreter &interpreter, CompletionRequest &request)
441     : CommandCompletions::Completer(interpreter, request) {
442   std::string regex_str;
443   if (!m_request.GetCursorArgumentPrefix().empty()) {
444     regex_str.append("^");
445     regex_str.append(m_request.GetCursorArgumentPrefix());
446   } else {
447     // Match anything since the completion string is empty
448     regex_str.append(".");
449   }
450   std::string::iterator pos =
451       find_if(regex_str.begin() + 1, regex_str.end(), regex_chars);
452   while (pos < regex_str.end()) {
453     pos = regex_str.insert(pos, '\\');
454     pos = find_if(pos + 2, regex_str.end(), regex_chars);
455   }
456   m_regex.Compile(regex_str);
457 }
458 
459 lldb::SearchDepth CommandCompletions::SymbolCompleter::GetDepth() {
460   return lldb::eSearchDepthModule;
461 }
462 
463 Searcher::CallbackReturn CommandCompletions::SymbolCompleter::SearchCallback(
464     SearchFilter &filter, SymbolContext &context, Address *addr,
465     bool complete) {
466   if (context.module_sp) {
467     SymbolContextList sc_list;
468     const bool include_symbols = true;
469     const bool include_inlines = true;
470     const bool append = true;
471     context.module_sp->FindFunctions(m_regex, include_symbols, include_inlines,
472                                      append, sc_list);
473 
474     SymbolContext sc;
475     // Now add the functions & symbols to the list - only add if unique:
476     for (uint32_t i = 0; i < sc_list.GetSize(); i++) {
477       if (sc_list.GetContextAtIndex(i, sc)) {
478         ConstString func_name = sc.GetFunctionName(Mangled::ePreferDemangled);
479         if (!func_name.IsEmpty())
480           m_match_set.insert(func_name);
481       }
482     }
483   }
484   return Searcher::eCallbackReturnContinue;
485 }
486 
487 size_t CommandCompletions::SymbolCompleter::DoCompletion(SearchFilter *filter) {
488   filter->Search(*this);
489   collection::iterator pos = m_match_set.begin(), end = m_match_set.end();
490   for (pos = m_match_set.begin(); pos != end; pos++)
491     m_request.AddCompletion((*pos).GetCString());
492 
493   return m_request.GetNumberOfMatches();
494 }
495 
496 //----------------------------------------------------------------------
497 // ModuleCompleter
498 //----------------------------------------------------------------------
499 CommandCompletions::ModuleCompleter::ModuleCompleter(
500     CommandInterpreter &interpreter, CompletionRequest &request)
501     : CommandCompletions::Completer(interpreter, request) {
502   FileSpec partial_spec(m_request.GetCursorArgumentPrefix());
503   m_file_name = partial_spec.GetFilename().GetCString();
504   m_dir_name = partial_spec.GetDirectory().GetCString();
505 }
506 
507 lldb::SearchDepth CommandCompletions::ModuleCompleter::GetDepth() {
508   return lldb::eSearchDepthModule;
509 }
510 
511 Searcher::CallbackReturn CommandCompletions::ModuleCompleter::SearchCallback(
512     SearchFilter &filter, SymbolContext &context, Address *addr,
513     bool complete) {
514   if (context.module_sp) {
515     const char *cur_file_name =
516         context.module_sp->GetFileSpec().GetFilename().GetCString();
517     const char *cur_dir_name =
518         context.module_sp->GetFileSpec().GetDirectory().GetCString();
519 
520     bool match = false;
521     if (m_file_name && cur_file_name &&
522         strstr(cur_file_name, m_file_name) == cur_file_name)
523       match = true;
524 
525     if (match && m_dir_name && cur_dir_name &&
526         strstr(cur_dir_name, m_dir_name) != cur_dir_name)
527       match = false;
528 
529     if (match) {
530       m_request.AddCompletion(cur_file_name);
531     }
532   }
533   return Searcher::eCallbackReturnContinue;
534 }
535 
536 size_t CommandCompletions::ModuleCompleter::DoCompletion(SearchFilter *filter) {
537   filter->Search(*this);
538   return m_request.GetNumberOfMatches();
539 }
540