contrib/llvm/tools/lldb/include/lldb/Interpreter/CommandCompletions.h

   1 //===-- CommandCompletions.h ------------------------------------*- 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 #ifndef lldb_CommandCompletions_h_
  11 #define lldb_CommandCompletions_h_
  12
  13 // C Includes
  14 // C++ Includes
  15 #include <set>
  16
  17 // Other libraries and framework includes
  18 // Project includes
  19 #include "lldb/lldb-private.h"
  20 #include "lldb/Core/SearchFilter.h"
  21 #include "lldb/Core/FileSpecList.h"
  22 #include "lldb/Core/RegularExpression.h"
  23
  24 namespace lldb_private
  25 {
  26 class CommandCompletions
  27 {
  28 public:
  29
  30     //----------------------------------------------------------------------
  31     // This is the command completion callback that is used to complete the argument of the option
  32     // it is bound to (in the OptionDefinition table below).  Return the total number of matches.
  33     //----------------------------------------------------------------------
  34     typedef int (*CompletionCallback) (CommandInterpreter &interpreter,
  35                                        const char *completion_str,          // This is the argument we are completing
  36                                        int match_start_point,               // This is the point in the list of matches that you should start returning elements
  37                                        int max_return_elements,             // This is the number of matches requested.
  38                                        lldb_private::SearchFilter *searcher,// A search filter to limit the search...
  39                                        bool &word_complete,
  40                                        lldb_private::StringList &matches);  // The array of matches we return.
  41     typedef enum
  42     {
  43         eNoCompletion             = 0u,
  44         eSourceFileCompletion     = (1u << 0),
  45         eDiskFileCompletion       = (1u << 1),
  46         eDiskDirectoryCompletion  = (1u << 2),
  47         eSymbolCompletion         = (1u << 3),
  48         eModuleCompletion         = (1u << 4),
  49         eSettingsNameCompletion   = (1u << 5),
  50         ePlatformPluginCompletion = (1u << 6),
  51         eArchitectureCompletion   = (1u << 7),
  52         eVariablePathCompletion   = (1u << 8),
  53         // This item serves two purposes.  It is the last element in the enum,
  54         // so you can add custom enums starting from here in your Option class.
  55         // Also if you & in this bit the base code will not process the option.
  56         eCustomCompletion         = (1u << 9)
  57
  58     } CommonCompletionTypes;
  59
  60     struct CommonCompletionElement
  61     {
  62         uint32_t type;
  63         CompletionCallback callback;
  64     };
  65
  66     static bool InvokeCommonCompletionCallbacks (CommandInterpreter &interpreter,
  67                                                  uint32_t completion_mask,
  68                                                  const char *completion_str,
  69                                                  int match_start_point,
  70                                                  int max_return_elements,
  71                                                  SearchFilter *searcher,
  72                                                  bool &word_complete,
  73                                                  StringList &matches);
  74
  75     //----------------------------------------------------------------------
  76     // These are the generic completer functions:
  77     //----------------------------------------------------------------------
  78     static int
  79     DiskFiles (CommandInterpreter &interpreter,
  80                const char *partial_file_name,
  81                int match_start_point,
  82                int max_return_elements,
  83                SearchFilter *searcher,
  84                bool &word_complete,
  85                StringList &matches);
  86     static int
  87     DiskDirectories (CommandInterpreter &interpreter,
  88                      const char *partial_file_name,
  89                      int match_start_point,
  90                      int max_return_elements,
  91                      SearchFilter *searcher,
  92                      bool &word_complete,
  93                      StringList &matches);
  94
  95     static int
  96     SourceFiles (CommandInterpreter &interpreter,
  97                  const char *partial_file_name,
  98                  int match_start_point,
  99                  int max_return_elements,
 100                  SearchFilter *searcher,
 101                  bool &word_complete,
 102                  StringList &matches);
 103
 104     static int
 105     Modules (CommandInterpreter &interpreter,
 106              const char *partial_file_name,
 107              int match_start_point,
 108              int max_return_elements,
 109              SearchFilter *searcher,
 110              bool &word_complete,
 111              lldb_private::StringList &matches);
 112
 113     static int
 114     Symbols (CommandInterpreter &interpreter,
 115              const char *partial_file_name,
 116              int match_start_point,
 117              int max_return_elements,
 118              SearchFilter *searcher,
 119              bool &word_complete,
 120              lldb_private::StringList &matches);
 121
 122     static int
 123     SettingsNames (CommandInterpreter &interpreter,
 124                    const char *partial_file_name,
 125                    int match_start_point,
 126                    int max_return_elements,
 127                    SearchFilter *searcher,
 128                    bool &word_complete,
 129                    lldb_private::StringList &matches);
 130
 131     static int
 132     PlatformPluginNames (CommandInterpreter &interpreter,
 133                          const char *partial_file_name,
 134                          int match_start_point,
 135                          int max_return_elements,
 136                          SearchFilter *searcher,
 137                          bool &word_complete,
 138                          lldb_private::StringList &matches);
 139
 140
 141     static int
 142     ArchitectureNames (CommandInterpreter &interpreter,
 143                        const char *partial_file_name,
 144                        int match_start_point,
 145                        int max_return_elements,
 146                        SearchFilter *searcher,
 147                        bool &word_complete,
 148                        lldb_private::StringList &matches);
 149
 150     static int
 151     VariablePath (CommandInterpreter &interpreter,
 152                   const char *partial_file_name,
 153                   int match_start_point,
 154                   int max_return_elements,
 155                   SearchFilter *searcher,
 156                   bool &word_complete,
 157                   lldb_private::StringList &matches);
 158
 159     //----------------------------------------------------------------------
 160     // The Completer class is a convenient base class for building searchers
 161     // that go along with the SearchFilter passed to the standard Completer
 162     // functions.
 163     //----------------------------------------------------------------------
 164     class Completer : public Searcher
 165     {
 166     public:
 167         Completer (CommandInterpreter &interpreter,
 168                    const char *completion_str,
 169                    int match_start_point,
 170                    int max_return_elements,
 171                    StringList &matches);
 172
 173         virtual ~Completer ();
 174
 175         virtual CallbackReturn
 176         SearchCallback (SearchFilter &filter,
 177                         SymbolContext &context,
 178                         Address *addr,
 179                         bool complete) = 0;
 180
 181         virtual Depth
 182         GetDepth () = 0;
 183
 184         virtual size_t
 185         DoCompletion (SearchFilter *filter) = 0;
 186
 187         protected:
 188             CommandInterpreter &m_interpreter;
 189             std::string m_completion_str;
 190             int m_match_start_point;
 191             int m_max_return_elements;
 192             StringList &m_matches;
 193         private:
 194             DISALLOW_COPY_AND_ASSIGN (Completer);
 195     };
 196
 197     //----------------------------------------------------------------------
 198     // SouceFileCompleter implements the source file completer
 199     //----------------------------------------------------------------------
 200     class SourceFileCompleter : public Completer
 201     {
 202     public:
 203
 204         SourceFileCompleter (CommandInterpreter &interpreter,
 205                              bool include_support_files,
 206                              const char *completion_str,
 207                              int match_start_point,
 208                              int max_return_elements,
 209                              StringList &matches);
 210
 211         virtual Searcher::Depth GetDepth ();
 212
 213         virtual Searcher::CallbackReturn
 214         SearchCallback (SearchFilter &filter,
 215                         SymbolContext &context,
 216                         Address *addr,
 217                         bool complete);
 218
 219         size_t
 220         DoCompletion (SearchFilter *filter);
 221
 222     private:
 223         bool m_include_support_files;
 224         FileSpecList m_matching_files;
 225         const char *m_file_name;
 226         const char *m_dir_name;
 227         DISALLOW_COPY_AND_ASSIGN (SourceFileCompleter);
 228
 229     };
 230
 231     //----------------------------------------------------------------------
 232     // ModuleCompleter implements the module completer
 233     //----------------------------------------------------------------------
 234     class ModuleCompleter : public Completer
 235     {
 236     public:
 237
 238         ModuleCompleter (CommandInterpreter &interpreter,
 239                          const char *completion_str,
 240                          int match_start_point,
 241                          int max_return_elements,
 242                          StringList &matches);
 243
 244         virtual Searcher::Depth GetDepth ();
 245
 246         virtual Searcher::CallbackReturn
 247         SearchCallback (SearchFilter &filter,
 248                         SymbolContext &context,
 249                         Address *addr,
 250                         bool complete);
 251
 252         size_t
 253         DoCompletion (SearchFilter *filter);
 254
 255     private:
 256         const char *m_file_name;
 257         const char *m_dir_name;
 258         DISALLOW_COPY_AND_ASSIGN (ModuleCompleter);
 259
 260     };
 261
 262     //----------------------------------------------------------------------
 263     // SymbolCompleter implements the symbol completer
 264     //----------------------------------------------------------------------
 265     class SymbolCompleter : public Completer
 266     {
 267     public:
 268
 269         SymbolCompleter (CommandInterpreter &interpreter,
 270                          const char *completion_str,
 271                          int match_start_point,
 272                          int max_return_elements,
 273                          StringList &matches);
 274
 275         virtual Searcher::Depth GetDepth ();
 276
 277         virtual Searcher::CallbackReturn
 278         SearchCallback (SearchFilter &filter,
 279                         SymbolContext &context,
 280                         Address *addr,
 281                         bool complete);
 282
 283         size_t
 284         DoCompletion (SearchFilter *filter);
 285
 286     private:
 287 //        struct NameCmp {
 288 //            bool operator() (const ConstString& lhs, const ConstString& rhs) const
 289 //            {
 290 //                return lhs < rhs;
 291 //            }
 292 //        };
 293
 294         RegularExpression m_regex;
 295         typedef std::set<ConstString> collection;
 296         collection m_match_set;
 297         DISALLOW_COPY_AND_ASSIGN (SymbolCompleter);
 298
 299     };
 300
 301 private:
 302     static CommonCompletionElement g_common_completions[];
 303
 304 };
 305
 306 } // namespace lldb_private
 307 #endif  // lldb_CommandCompletions_h_