lldb/source/Commands/CommandCompletions.cpp

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