CommandInterpreter.h revision a4fede31869663e889d67ace3d07dc5d3e4ea2b8
1//===-- CommandInterpreter.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_CommandInterpreter_h_ 11#define liblldb_CommandInterpreter_h_ 12 13// C Includes 14// C++ Includes 15// Other libraries and framework includes 16// Project includes 17#include "lldb/lldb-private.h" 18#include "lldb/Core/Broadcaster.h" 19#include "lldb/Core/Debugger.h" 20#include "lldb/Core/Log.h" 21#include "lldb/Interpreter/CommandObject.h" 22#include "lldb/Interpreter/ScriptInterpreter.h" 23#include "lldb/Core/Event.h" 24#include "lldb/Interpreter/Args.h" 25#include "lldb/Core/StringList.h" 26 27namespace lldb_private { 28 29class CommandInterpreter : public Broadcaster 30{ 31public: 32 typedef std::map<std::string, OptionArgVectorSP> OptionArgMap; 33 34 enum 35 { 36 eBroadcastBitThreadShouldExit = (1 << 0), 37 eBroadcastBitResetPrompt = (1 << 1), 38 eBroadcastBitQuitCommandReceived = (1 << 2) // User entered quit 39 }; 40 41 void 42 SourceInitFile (bool in_cwd, CommandReturnObject &result); 43 44 CommandInterpreter (Debugger &debugger, 45 lldb::ScriptLanguage script_language, 46 bool synchronous_execution); 47 48 virtual 49 ~CommandInterpreter (); 50 51 lldb::CommandObjectSP 52 GetCommandSPExact (const char *cmd, bool include_aliases); 53 54 CommandObject * 55 GetCommandObjectExact (const char *cmd_cstr, bool include_aliases); 56 57 CommandObject * 58 GetCommandObject (const char *cmd, StringList *matches = NULL); 59 60 bool 61 CommandExists (const char *cmd); 62 63 bool 64 AliasExists (const char *cmd); 65 66 bool 67 UserCommandExists (const char *cmd); 68 69 void 70 AddAlias (const char *alias_name, lldb::CommandObjectSP& command_obj_sp); 71 72 bool 73 RemoveAlias (const char *alias_name); 74 75 bool 76 RemoveUser (const char *alias_name); 77 78 OptionArgVectorSP 79 GetAliasOptions (const char *alias_name); 80 81 void 82 RemoveAliasOptions (const char *alias_name); 83 84 void 85 AddOrReplaceAliasOptions (const char *alias_name, OptionArgVectorSP &option_arg_vector_sp); 86 87 bool 88 StripFirstWord (std::string &command_string, std::string &next_word); 89 90 void 91 BuildAliasResult (const char *alias_name, std::string &raw_input_string, std::string &alias_result, 92 CommandObject *&alias_cmd_obj, CommandReturnObject &result); 93 94 bool 95 HandleCommand (const char *command_line, 96 bool add_to_history, 97 CommandReturnObject &result, 98 ExecutionContext *override_context = NULL, 99 bool repeat_on_empty_command = true); 100 101 //------------------------------------------------------------------ 102 /// Execute a list of commands in sequence. 103 /// 104 /// @param[in] commands 105 /// The list of commands to execute. 106 /// @param[in/out] context 107 /// The execution context in which to run the commands. Can be NULL in which case the default 108 /// context will be used. 109 /// @param[in] stop_on_continue 110 /// If \b true execution will end on the first command that causes the process in the 111 /// execution context to continue. If \false, we won't check the execution status. 112 /// @param[in] stop_on_error 113 /// If \b true execution will end on the first command that causes an error. 114 /// @param[in] echo_commands 115 /// If \b true echo the command before executing it. If \false, execute silently. 116 /// @param[in] print_results 117 /// If \b true print the results of the command after executing it. If \false, execute silently. 118 /// @param[out] result 119 /// This is marked as succeeding with no output if all commands execute safely, 120 /// and failed with some explanation if we aborted executing the commands at some point. 121 //------------------------------------------------------------------ 122 void 123 HandleCommands (const StringList &commands, 124 ExecutionContext *context, 125 bool stop_on_continue, 126 bool stop_on_error, 127 bool echo_commands, 128 bool print_results, 129 CommandReturnObject &result); 130 131 //------------------------------------------------------------------ 132 /// Execute a list of commands from a file. 133 /// 134 /// @param[in] file 135 /// The file from which to read in commands. 136 /// @param[in/out] context 137 /// The execution context in which to run the commands. Can be NULL in which case the default 138 /// context will be used. 139 /// @param[in] stop_on_continue 140 /// If \b true execution will end on the first command that causes the process in the 141 /// execution context to continue. If \false, we won't check the execution status. 142 /// @param[in] stop_on_error 143 /// If \b true execution will end on the first command that causes an error. 144 /// @param[in] echo_commands 145 /// If \b true echo the command before executing it. If \false, execute silently. 146 /// @param[in] print_results 147 /// If \b true print the results of the command after executing it. If \false, execute silently. 148 /// @param[out] result 149 /// This is marked as succeeding with no output if all commands execute safely, 150 /// and failed with some explanation if we aborted executing the commands at some point. 151 //------------------------------------------------------------------ 152 void 153 HandleCommandsFromFile (FileSpec &file, 154 ExecutionContext *context, 155 bool stop_on_continue, 156 bool stop_on_error, 157 bool echo_commands, 158 bool print_results, 159 CommandReturnObject &result); 160 161 CommandObject * 162 GetCommandObjectForCommand (std::string &command_line); 163 164 // This handles command line completion. You are given a pointer to the command string buffer, to the current cursor, 165 // and to the end of the string (in case it is not NULL terminated). 166 // You also passed in an Args object to fill with the returns. 167 // The first element of the array will be filled with the string that you would need to insert at 168 // the cursor point to complete the cursor point to the longest common matching prefix. 169 // If you want to limit the number of elements returned, set max_return_elements to the number of elements 170 // you want returned. Otherwise set max_return_elements to -1. 171 // If you want to start some way into the match list, then set match_start_point to the desired start 172 // point. 173 // Returns the total number of completions, or -1 if the completion character should be inserted, or 174 // INT_MAX if the number of matches is > max_return_elements, but it is expensive to compute. 175 // 176 // FIXME: Only max_return_elements == -1 is supported at present. 177 178 int 179 HandleCompletion (const char *current_line, 180 const char *cursor, 181 const char *last_char, 182 int match_start_point, 183 int max_return_elements, 184 StringList &matches); 185 186 // This version just returns matches, and doesn't compute the substring. It is here so the 187 // Help command can call it for the first argument. 188 // word_complete tells whether a the completions are considered a "complete" response (so the 189 // completer should complete the quote & put a space after the word. 190 191 int 192 HandleCompletionMatches (Args &input, 193 int &cursor_index, 194 int &cursor_char_position, 195 int match_start_point, 196 int max_return_elements, 197 bool &word_complete, 198 StringList &matches); 199 200 201 int 202 GetCommandNamesMatchingPartialString (const char *cmd_cstr, bool include_aliases, StringList &matches); 203 204 void 205 GetHelp (CommandReturnObject &result); 206 207 void 208 GetAliasHelp (const char *alias_name, const char *command_name, StreamString &help_string); 209 210 void 211 OutputFormattedHelpText (Stream &stream, 212 const char *command_word, 213 const char *separator, 214 const char *help_text, 215 uint32_t max_word_len); 216 217 Debugger & 218 GetDebugger () 219 { 220 return m_debugger; 221 } 222 223 const char * 224 ProcessEmbeddedScriptCommands (const char *arg); 225 226 const char * 227 GetPrompt (); 228 229 void 230 SetPrompt (const char *); 231 232 bool Confirm (const char *message, bool default_answer); 233 234 static size_t 235 GetConfirmationInputReaderCallback (void *baton, 236 InputReader &reader, 237 lldb::InputReaderAction action, 238 const char *bytes, 239 size_t bytes_len); 240 241 void 242 LoadCommandDictionary (); 243 244 void 245 Initialize (); 246 247 void 248 CrossRegisterCommand (const char * dest_cmd, const char * object_type); 249 250 void 251 SetScriptLanguage (lldb::ScriptLanguage lang); 252 253 254 bool 255 HasCommands (); 256 257 bool 258 HasAliases (); 259 260 bool 261 HasUserCommands (); 262 263 bool 264 HasAliasOptions (); 265 266 void 267 BuildAliasCommandArgs (CommandObject *alias_cmd_obj, const char *alias_name, Args &cmd_args, 268 std::string &raw_input_string, CommandReturnObject &result); 269 270 int 271 GetOptionArgumentPosition (const char *in_string); 272 273 ScriptInterpreter * 274 GetScriptInterpreter (); 275 276 void 277 SkipLLDBInitFiles (bool skip_lldbinit_files) 278 { 279 m_skip_lldbinit_files = skip_lldbinit_files; 280 } 281 282 bool 283 GetSynchronous (); 284 285#ifndef SWIG 286 void 287 AddLogChannel (const char *name, const Log::Callbacks &log_callbacks); 288 289 bool 290 GetLogChannelCallbacks (const char *channel, Log::Callbacks &log_callbacks); 291 292 bool 293 RemoveLogChannel (const char *name); 294#endif 295 296 size_t 297 FindLongestCommandWord (CommandObject::CommandMap &dict); 298 299 void 300 FindCommandsForApropos (const char *word, StringList &commands_found, StringList &commands_help); 301 302 void 303 AproposAllSubCommands (CommandObject *cmd_obj, const char *prefix, const char *search_word, 304 StringList &commands_found, StringList &commands_help); 305 306protected: 307 friend class Debugger; 308 309 void 310 SetSynchronous (bool value); 311 312 lldb::CommandObjectSP 313 GetCommandSP (const char *cmd, bool include_aliases = true, bool exact = true, StringList *matches = NULL); 314 315private: 316 317 Debugger &m_debugger; // The debugger session that this interpreter is associated with 318 bool m_synchronous_execution; 319 bool m_skip_lldbinit_files; 320 CommandObject::CommandMap m_command_dict; // Stores basic built-in commands (they cannot be deleted, removed or overwritten). 321 CommandObject::CommandMap m_alias_dict; // Stores user aliases/abbreviations for commands 322 CommandObject::CommandMap m_user_dict; // Stores user-defined commands 323 OptionArgMap m_alias_options; // Stores any options (with or without arguments) that go with any alias. 324 std::vector<std::string> m_command_history; 325 std::string m_repeat_command; // Stores the command that will be executed for an empty command string. 326 std::auto_ptr<ScriptInterpreter> m_script_interpreter_ap; 327 char m_comment_char; 328}; 329 330 331} // namespace lldb_private 332 333#endif // liblldb_CommandInterpreter_h_ 334