contrib/llvm/tools/lldb/source/Commands/CommandCompletions.cpp

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