CommandObject.h revision d40f8a68b49a43264ff41a0f0ef51bef6372e8b3
1//===-- CommandObject.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 liblldb_CommandObject_h_ 11#define liblldb_CommandObject_h_ 12 13#include <map> 14#include <set> 15#include <string> 16#include <vector> 17 18#include "lldb/lldb-private.h" 19#include "lldb/Interpreter/Args.h" 20#include "lldb/Core/StringList.h" 21#include "lldb/Core/Flags.h" 22 23namespace lldb_private { 24 25class CommandObject 26{ 27public: 28 typedef std::map<std::string, lldb::CommandObjectSP> CommandMap; 29 30 31 CommandObject (const char *name, 32 const char *help = NULL, 33 const char *syntax = NULL, 34 uint32_t flags = 0); 35 36 virtual 37 ~CommandObject (); 38 39 const char * 40 GetHelp (); 41 42 const char * 43 GetHelpLong (); 44 45 const char * 46 GetSyntax (); 47 48 const char * 49 Translate (); 50 51 const char * 52 GetCommandName (); 53 54 void 55 SetHelp (const char * str); 56 57 void 58 SetHelpLong (const char * str); 59 60 void 61 SetSyntax (const char *str); 62 63 virtual void 64 AddObject (const char *obj_name) {} 65 66 virtual bool 67 IsCrossRefObject () { return false; } 68 69 bool 70 IsAlias () { return m_is_alias; } 71 72 void 73 SetIsAlias (bool value) { m_is_alias = value; } 74 75 virtual bool 76 IsMultiwordObject () { return false; } 77 78 virtual bool 79 WantsRawCommandString() { return false; } 80 81 virtual Options * 82 GetOptions (); 83 84 enum 85 { 86 eFlagProcessMustBeLaunched = (1 << 0), 87 eFlagProcessMustBePaused = (1 << 1) 88 }; 89 90 // Do not override this 91 bool 92 ExecuteCommandString (CommandInterpreter &interpreter, 93 const char *command, 94 CommandReturnObject &result); 95 96 bool 97 ParseOptions (CommandInterpreter &interpreter, 98 Args& args, 99 CommandReturnObject &result); 100 101 bool 102 ExecuteWithOptions (CommandInterpreter &interpreter, 103 Args& command, 104 CommandReturnObject &result); 105 106 virtual bool 107 ExecuteRawCommandString (CommandInterpreter &interpreter, 108 const char *command, 109 CommandReturnObject &result) 110 { 111 return false; 112 } 113 114 115 virtual bool 116 Execute (CommandInterpreter &interpreter, 117 Args& command, 118 CommandReturnObject &result) = 0; 119 120 void 121 SetCommandName (const char *name); 122 123 // This function really deals with CommandObjectLists, but we didn't make a 124 // CommandObjectList class, so I'm sticking it here. But we really should have 125 // such a class. Anyway, it looks up the commands in the map that match the partial 126 // string cmd_str, inserts the matches into matches, and returns the number added. 127 128 static int 129 AddNamesMatchingPartialString (CommandMap &in_map, const char *cmd_str, StringList &matches); 130 131 //------------------------------------------------------------------ 132 /// The input array contains a parsed version of the line. The insertion 133 /// point is given by cursor_index (the index in input of the word containing 134 /// the cursor) and cursor_char_position (the position of the cursor in that word.) 135 /// This default version handles calling option argument completions and then calls 136 /// HandleArgumentCompletion if the cursor is on an argument, not an option. 137 /// Don't override this method, override HandleArgumentCompletion instead unless 138 /// you have special reasons. 139 /// 140 /// @param[in] interpreter 141 /// The command interpreter doing the completion. 142 /// 143 /// @param[in] input 144 /// The command line parsed into words 145 /// 146 /// @param[in] cursor_index 147 /// The index in \ainput of the word in which the cursor lies. 148 /// 149 /// @param[in] cursor_char_pos 150 /// The character position of the cursor in its argument word. 151 /// 152 /// @param[in] match_start_point 153 /// @param[in] match_return_elements 154 /// FIXME: Not yet implemented... If there is a match that is expensive to compute, these are 155 /// here to allow you to compute the completions in batches. Start the completion from \amatch_start_point, 156 /// and return \amatch_return_elements elements. 157 /// 158 /// @param[out] word_complete 159 /// \btrue if this is a complete option value (a space will be inserted after the 160 /// completion.) \bfalse otherwise. 161 /// 162 /// @param[out] matches 163 /// The array of matches returned. 164 /// 165 /// FIXME: This is the wrong return value, since we also need to make a distinction between 166 /// total number of matches, and the window the user wants returned. 167 /// 168 /// @return 169 /// \btrue if we were in an option, \bfalse otherwise. 170 //------------------------------------------------------------------ 171 virtual int 172 HandleCompletion (CommandInterpreter &interpreter, 173 Args &input, 174 int &cursor_index, 175 int &cursor_char_position, 176 int match_start_point, 177 int max_return_elements, 178 bool &word_complete, 179 StringList &matches); 180 181 //------------------------------------------------------------------ 182 /// The input array contains a parsed version of the line. The insertion 183 /// point is given by cursor_index (the index in input of the word containing 184 /// the cursor) and cursor_char_position (the position of the cursor in that word.) 185 /// We've constructed the map of options and their arguments as well if that is 186 /// helpful for the completion. 187 /// 188 /// @param[in] interpreter 189 /// The command interpreter doing the completion. 190 /// 191 /// @param[in] input 192 /// The command line parsed into words 193 /// 194 /// @param[in] cursor_index 195 /// The index in \ainput of the word in which the cursor lies. 196 /// 197 /// @param[in] cursor_char_pos 198 /// The character position of the cursor in its argument word. 199 /// 200 /// @param[in] opt_element_vector 201 /// The results of the options parse of \a input. 202 /// 203 /// @param[in] match_start_point 204 /// @param[in] match_return_elements 205 /// See CommandObject::HandleCompletions for a description of how these work. 206 /// 207 /// @param[out] word_complete 208 /// \btrue if this is a complete option value (a space will be inserted after the 209 /// completion.) \bfalse otherwise. 210 /// 211 /// @param[out] matches 212 /// The array of matches returned. 213 /// 214 /// FIXME: This is the wrong return value, since we also need to make a distinction between 215 /// total number of matches, and the window the user wants returned. 216 /// 217 /// @return 218 /// \btrue if we were in an option, \bfalse otherwise. 219 //------------------------------------------------------------------ 220 221 virtual int 222 HandleArgumentCompletion (CommandInterpreter &interpreter, 223 Args &input, 224 int &cursor_index, 225 int &cursor_char_position, 226 OptionElementVector &opt_element_vector, 227 int match_start_point, 228 int max_return_elements, 229 bool &word_complete, 230 StringList &matches) 231 { 232 return 0; 233 } 234 235 bool 236 HelpTextContainsWord (const char *search_word); 237 238 //------------------------------------------------------------------ 239 /// The flags accessor. 240 /// 241 /// @return 242 /// A reference to the Flags member variable. 243 //------------------------------------------------------------------ 244 Flags& 245 GetFlags(); 246 247 //------------------------------------------------------------------ 248 /// The flags const accessor. 249 /// 250 /// @return 251 /// A const reference to the Flags member variable. 252 //------------------------------------------------------------------ 253 const Flags& 254 GetFlags() const; 255 256protected: 257 std::string m_cmd_name; 258 std::string m_cmd_help_short; 259 std::string m_cmd_help_long; 260 std::string m_cmd_syntax; 261 bool m_is_alias; 262 Flags m_flags; 263}; 264 265} // namespace lldb_private 266 267 268#endif // liblldb_CommandObject_h_ 269