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

   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/IOHandler.h"
  21 #include "lldb/Core/Log.h"
  22 #include "lldb/Interpreter/CommandHistory.h"
  23 #include "lldb/Interpreter/CommandObject.h"
  24 #include "lldb/Interpreter/ScriptInterpreter.h"
  25 #include "lldb/Core/Event.h"
  26 #include "lldb/Interpreter/Args.h"
  27 #include "lldb/Core/StringList.h"
  28
  29 namespace lldb_private {
  30
  31 class CommandInterpreter :
  32     public Broadcaster,
  33     public Properties,
  34     public IOHandlerDelegate
  35 {
  36 public:
  37     typedef std::map<std::string, OptionArgVectorSP> OptionArgMap;
  38
  39     enum
  40     {
  41         eBroadcastBitThreadShouldExit       = (1 << 0),
  42         eBroadcastBitResetPrompt            = (1 << 1),
  43         eBroadcastBitQuitCommandReceived    = (1 << 2),   // User entered quit
  44         eBroadcastBitAsynchronousOutputData = (1 << 3),
  45         eBroadcastBitAsynchronousErrorData  = (1 << 4)
  46     };
  47
  48     enum ChildrenTruncatedWarningStatus // tristate boolean to manage children truncation warning
  49     {
  50         eNoTruncation = 0, // never truncated
  51         eUnwarnedTruncation = 1, // truncated but did not notify
  52         eWarnedTruncation = 2 // truncated and notified
  53     };
  54
  55     enum CommandTypes
  56     {
  57         eCommandTypesBuiltin = 0x0001,  // native commands such as "frame"
  58         eCommandTypesUserDef = 0x0002,  // scripted commands
  59         eCommandTypesAliases = 0x0004,  // aliases such as "po"
  60         eCommandTypesAllThem = 0xFFFF   // all commands
  61     };
  62
  63     // These two functions fill out the Broadcaster interface:
  64
  65     static ConstString &GetStaticBroadcasterClass ();
  66
  67     virtual ConstString &GetBroadcasterClass() const
  68     {
  69         return GetStaticBroadcasterClass();
  70     }
  71
  72     void
  73     SourceInitFile (bool in_cwd,
  74                     CommandReturnObject &result);
  75
  76     CommandInterpreter (Debugger &debugger,
  77                         lldb::ScriptLanguage script_language,
  78                         bool synchronous_execution);
  79
  80     virtual
  81     ~CommandInterpreter ();
  82
  83     bool
  84     AddCommand (const char *name,
  85                 const lldb::CommandObjectSP &cmd_sp,
  86                 bool can_replace);
  87
  88     bool
  89     AddUserCommand (std::string name,
  90                     const lldb::CommandObjectSP &cmd_sp,
  91                     bool can_replace);
  92
  93     lldb::CommandObjectSP
  94     GetCommandSPExact (const char *cmd,
  95                        bool include_aliases);
  96
  97     CommandObject *
  98     GetCommandObjectExact (const char *cmd_cstr,
  99                            bool include_aliases);
 100
 101     CommandObject *
 102     GetCommandObject (const char *cmd,
 103                       StringList *matches = NULL);
 104
 105     bool
 106     CommandExists (const char *cmd);
 107
 108     bool
 109     AliasExists (const char *cmd);
 110
 111     bool
 112     UserCommandExists (const char *cmd);
 113
 114     void
 115     AddAlias (const char *alias_name,
 116               lldb::CommandObjectSP& command_obj_sp);
 117
 118     bool
 119     RemoveAlias (const char *alias_name);
 120
 121     bool
 122     GetAliasFullName (const char *cmd, std::string &full_name);
 123
 124     bool
 125     RemoveUser (const char *alias_name);
 126
 127     void
 128     RemoveAllUser ()
 129     {
 130         m_user_dict.clear();
 131     }
 132
 133     OptionArgVectorSP
 134     GetAliasOptions (const char *alias_name);
 135
 136
 137     bool
 138     ProcessAliasOptionsArgs (lldb::CommandObjectSP &cmd_obj_sp,
 139                              const char *options_args,
 140                              OptionArgVectorSP &option_arg_vector_sp);
 141
 142     void
 143     RemoveAliasOptions (const char *alias_name);
 144
 145     void
 146     AddOrReplaceAliasOptions (const char *alias_name,
 147                               OptionArgVectorSP &option_arg_vector_sp);
 148
 149     CommandObject *
 150     BuildAliasResult (const char *alias_name,
 151                       std::string &raw_input_string,
 152                       std::string &alias_result,
 153                       CommandReturnObject &result);
 154
 155     bool
 156     HandleCommand (const char *command_line,
 157                    LazyBool add_to_history,
 158                    CommandReturnObject &result,
 159                    ExecutionContext *override_context = NULL,
 160                    bool repeat_on_empty_command = true,
 161                    bool no_context_switching = false);
 162
 163     //------------------------------------------------------------------
 164     /// Execute a list of commands in sequence.
 165     ///
 166     /// @param[in] commands
 167     ///    The list of commands to execute.
 168     /// @param[in/out] context
 169     ///    The execution context in which to run the commands.  Can be NULL in which case the default
 170     ///    context will be used.
 171     /// @param[in] stop_on_continue
 172     ///    If \b true execution will end on the first command that causes the process in the
 173     ///    execution context to continue.  If \false, we won't check the execution status.
 174     /// @param[in] stop_on_error
 175     ///    If \b true execution will end on the first command that causes an error.
 176     /// @param[in] echo_commands
 177     ///    If \b true echo the command before executing it.  If \false, execute silently.
 178     /// @param[in] print_results
 179     ///    If \b true print the results of the command after executing it.  If \false, execute silently.
 180     /// @param[out] result
 181     ///    This is marked as succeeding with no output if all commands execute safely,
 182     ///    and failed with some explanation if we aborted executing the commands at some point.
 183     //------------------------------------------------------------------
 184     void
 185     HandleCommands (const StringList &commands,
 186                     ExecutionContext *context,
 187                     bool stop_on_continue,
 188                     bool stop_on_error,
 189                     bool echo_commands,
 190                     bool print_results,
 191                     LazyBool add_to_history,
 192                     CommandReturnObject &result);
 193
 194     //------------------------------------------------------------------
 195     /// Execute a list of commands from a file.
 196     ///
 197     /// @param[in] file
 198     ///    The file from which to read in commands.
 199     /// @param[in/out] context
 200     ///    The execution context in which to run the commands.  Can be NULL in which case the default
 201     ///    context will be used.
 202     /// @param[in] stop_on_continue
 203     ///    If \b true execution will end on the first command that causes the process in the
 204     ///    execution context to continue.  If \false, we won't check the execution status.
 205     /// @param[in] stop_on_error
 206     ///    If \b true execution will end on the first command that causes an error.
 207     /// @param[in] echo_commands
 208     ///    If \b true echo the command before executing it.  If \false, execute silently.
 209     /// @param[in] print_results
 210     ///    If \b true print the results of the command after executing it.  If \false, execute silently.
 211     /// @param[out] result
 212     ///    This is marked as succeeding with no output if all commands execute safely,
 213     ///    and failed with some explanation if we aborted executing the commands at some point.
 214     //------------------------------------------------------------------
 215     void
 216     HandleCommandsFromFile (FileSpec &file,
 217                             ExecutionContext *context,
 218                             LazyBool stop_on_continue,
 219                             LazyBool stop_on_error,
 220                             LazyBool echo_commands,
 221                             LazyBool print_results,
 222                             LazyBool add_to_history,
 223                             CommandReturnObject &result);
 224
 225     CommandObject *
 226     GetCommandObjectForCommand (std::string &command_line);
 227
 228     // This handles command line completion.  You are given a pointer to the command string buffer, to the current cursor,
 229     // and to the end of the string (in case it is not NULL terminated).
 230     // You also passed in an StringList object to fill with the returns.
 231     // The first element of the array will be filled with the string that you would need to insert at
 232     // the cursor point to complete the cursor point to the longest common matching prefix.
 233     // If you want to limit the number of elements returned, set max_return_elements to the number of elements
 234     // you want returned.  Otherwise set max_return_elements to -1.
 235     // If you want to start some way into the match list, then set match_start_point to the desired start
 236     // point.
 237     // Returns:
 238     // -1 if the completion character should be inserted
 239     // -2 if the entire command line should be deleted and replaced with matches.GetStringAtIndex(0)
 240     // INT_MAX if the number of matches is > max_return_elements, but it is expensive to compute.
 241     // Otherwise, returns the number of matches.
 242     //
 243     // FIXME: Only max_return_elements == -1 is supported at present.
 244
 245     int
 246     HandleCompletion (const char *current_line,
 247                       const char *cursor,
 248                       const char *last_char,
 249                       int match_start_point,
 250                       int max_return_elements,
 251                       StringList &matches);
 252
 253     // This version just returns matches, and doesn't compute the substring.  It is here so the
 254     // Help command can call it for the first argument.
 255     // word_complete tells whether a the completions are considered a "complete" response (so the
 256     // completer should complete the quote & put a space after the word.
 257
 258     int
 259     HandleCompletionMatches (Args &input,
 260                              int &cursor_index,
 261                              int &cursor_char_position,
 262                              int match_start_point,
 263                              int max_return_elements,
 264                              bool &word_complete,
 265                              StringList &matches);
 266
 267
 268     int
 269     GetCommandNamesMatchingPartialString (const char *cmd_cstr,
 270                                           bool include_aliases,
 271                                           StringList &matches);
 272
 273     void
 274     GetHelp (CommandReturnObject &result,
 275              uint32_t types = eCommandTypesAllThem);
 276
 277     void
 278     GetAliasHelp (const char *alias_name,
 279                   const char *command_name,
 280                   StreamString &help_string);
 281
 282     void
 283     OutputFormattedHelpText (Stream &stream,
 284                              const char *command_word,
 285                              const char *separator,
 286                              const char *help_text,
 287                              size_t max_word_len);
 288
 289     // this mimics OutputFormattedHelpText but it does perform a much simpler
 290     // formatting, basically ensuring line alignment. This is only good if you have
 291     // some complicated layout for your help text and want as little help as reasonable
 292     // in properly displaying it. Most of the times, you simply want to type some text
 293     // and have it printed in a reasonable way on screen. If so, use OutputFormattedHelpText
 294     void
 295     OutputHelpText (Stream &stream,
 296                     const char *command_word,
 297                     const char *separator,
 298                     const char *help_text,
 299                     uint32_t max_word_len);
 300
 301     Debugger &
 302     GetDebugger ()
 303     {
 304         return m_debugger;
 305     }
 306
 307     ExecutionContext
 308     GetExecutionContext()
 309     {
 310         const bool thread_and_frame_only_if_stopped = true;
 311         return m_exe_ctx_ref.Lock(thread_and_frame_only_if_stopped);
 312     }
 313
 314     void
 315     UpdateExecutionContext (ExecutionContext *override_context);
 316
 317     lldb::PlatformSP
 318     GetPlatform (bool prefer_target_platform);
 319
 320     const char *
 321     ProcessEmbeddedScriptCommands (const char *arg);
 322
 323     void
 324     UpdatePrompt (const char *);
 325
 326     bool
 327     Confirm (const char *message,
 328              bool default_answer);
 329
 330     void
 331     LoadCommandDictionary ();
 332
 333     void
 334     Initialize ();
 335
 336     void
 337     SetScriptLanguage (lldb::ScriptLanguage lang);
 338
 339
 340     bool
 341     HasCommands ();
 342
 343     bool
 344     HasAliases ();
 345
 346     bool
 347     HasUserCommands ();
 348
 349     bool
 350     HasAliasOptions ();
 351
 352     void
 353     BuildAliasCommandArgs (CommandObject *alias_cmd_obj,
 354                            const char *alias_name,
 355                            Args &cmd_args,
 356                            std::string &raw_input_string,
 357                            CommandReturnObject &result);
 358
 359     int
 360     GetOptionArgumentPosition (const char *in_string);
 361
 362     ScriptInterpreter *
 363     GetScriptInterpreter (bool can_create = true);
 364
 365     void
 366     SkipLLDBInitFiles (bool skip_lldbinit_files)
 367     {
 368         m_skip_lldbinit_files = skip_lldbinit_files;
 369     }
 370
 371     void
 372     SkipAppInitFiles (bool skip_app_init_files)
 373     {
 374         m_skip_app_init_files = m_skip_lldbinit_files;
 375     }
 376
 377     bool
 378     GetSynchronous ();
 379
 380     size_t
 381     FindLongestCommandWord (CommandObject::CommandMap &dict);
 382
 383     void
 384     FindCommandsForApropos (const char *word,
 385                             StringList &commands_found,
 386                             StringList &commands_help,
 387                             bool search_builtin_commands,
 388                             bool search_user_commands);
 389
 390     bool
 391     GetBatchCommandMode () { return m_batch_command_mode; }
 392
 393     bool
 394     SetBatchCommandMode (bool value) {
 395         const bool old_value = m_batch_command_mode;
 396         m_batch_command_mode = value;
 397         return old_value;
 398     }
 399
 400     void
 401     ChildrenTruncated ()
 402     {
 403         if (m_truncation_warning == eNoTruncation)
 404             m_truncation_warning = eUnwarnedTruncation;
 405     }
 406
 407     bool
 408     TruncationWarningNecessary ()
 409     {
 410         return (m_truncation_warning == eUnwarnedTruncation);
 411     }
 412
 413     void
 414     TruncationWarningGiven ()
 415     {
 416         m_truncation_warning = eWarnedTruncation;
 417     }
 418
 419     const char *
 420     TruncationWarningText ()
 421     {
 422         return "*** Some of your variables have more members than the debugger will show by default. To show all of them, you can either use the --show-all-children option to %s or raise the limit by changing the target.max-children-count setting.\n";
 423     }
 424
 425     const CommandHistory&
 426     GetCommandHistory () const
 427     {
 428         return m_command_history;
 429     }
 430
 431     CommandHistory&
 432     GetCommandHistory ()
 433     {
 434         return m_command_history;
 435     }
 436
 437     bool
 438     IsActive ();
 439
 440     void
 441     RunCommandInterpreter (bool auto_handle_events,
 442                            bool spawn_thread);
 443
 444     void
 445     GetLLDBCommandsFromIOHandler (const char *prompt,
 446                                   IOHandlerDelegate &delegate,
 447                                   bool asynchronously,
 448                                   void *baton);
 449
 450     void
 451     GetPythonCommandsFromIOHandler (const char *prompt,
 452                                     IOHandlerDelegate &delegate,
 453                                     bool asynchronously,
 454                                     void *baton);
 455
 456     //------------------------------------------------------------------
 457     // Properties
 458     //------------------------------------------------------------------
 459     bool
 460     GetExpandRegexAliases () const;
 461
 462     bool
 463     GetPromptOnQuit () const;
 464
 465     bool
 466     GetStopCmdSourceOnError () const;
 467
 468 protected:
 469     friend class Debugger;
 470
 471     //------------------------------------------------------------------
 472     // IOHandlerDelegate functions
 473     //------------------------------------------------------------------
 474     virtual void
 475     IOHandlerInputComplete (IOHandler &io_handler,
 476                             std::string &line);
 477
 478     virtual ConstString
 479     GetControlSequence (char ch)
 480     {
 481         if (ch == 'd')
 482             return ConstString("quit\n");
 483         return ConstString();
 484     }
 485
 486     size_t
 487     GetProcessOutput ();
 488
 489     void
 490     SetSynchronous (bool value);
 491
 492     lldb::CommandObjectSP
 493     GetCommandSP (const char *cmd, bool include_aliases = true, bool exact = true, StringList *matches = NULL);
 494
 495
 496 private:
 497
 498     Error
 499     PreprocessCommand (std::string &command);
 500
 501     Debugger &m_debugger;                       // The debugger session that this interpreter is associated with
 502     ExecutionContextRef m_exe_ctx_ref;          // The current execution context to use when handling commands
 503     bool m_synchronous_execution;
 504     bool m_skip_lldbinit_files;
 505     bool m_skip_app_init_files;
 506     CommandObject::CommandMap m_command_dict;   // Stores basic built-in commands (they cannot be deleted, removed or overwritten).
 507     CommandObject::CommandMap m_alias_dict;     // Stores user aliases/abbreviations for commands
 508     CommandObject::CommandMap m_user_dict;      // Stores user-defined commands
 509     OptionArgMap m_alias_options;               // Stores any options (with or without arguments) that go with any alias.
 510     CommandHistory m_command_history;
 511     std::string m_repeat_command;               // Stores the command that will be executed for an empty command string.
 512     std::unique_ptr<ScriptInterpreter> m_script_interpreter_ap;
 513     lldb::IOHandlerSP m_command_io_handler_sp;
 514     char m_comment_char;
 515     bool m_batch_command_mode;
 516     ChildrenTruncatedWarningStatus m_truncation_warning;    // Whether we truncated children and whether the user has been told
 517     uint32_t m_command_source_depth;
 518     std::vector<uint32_t> m_command_source_flags;
 519
 520 };
 521
 522
 523 } // namespace lldb_private
 524
 525 #endif  // liblldb_CommandInterpreter_h_