gdb/top.h

   1 /* Top level stuff for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2020 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef TOP_H
  21 #define TOP_H
  22
  23 #include "gdbsupport/buffer.h"
  24 #include "gdbsupport/event-loop.h"
  25 #include "gdbsupport/next-iterator.h"
  26 #include "value.h"
  27
  28 struct tl_interp_info;
  29
  30 /* Prompt state.  */
  31
  32 enum prompt_state
  33 {
  34   /* The command line is blocked simulating synchronous execution.
  35      This is used to implement the foreground execution commands
  36      ('run', 'continue', etc.).  We won't display the prompt and
  37      accept further commands until the execution is actually over.  */
  38   PROMPT_BLOCKED,
  39
  40   /* The command finished; display the prompt before returning back to
  41      the top level.  */
  42   PROMPT_NEEDED,
  43
  44   /* We've displayed the prompt already, ready for input.  */
  45   PROMPTED,
  46 };
  47
  48 /* All about a user interface instance.  Each user interface has its
  49    own I/O files/streams, readline state, its own top level
  50    interpreter (for the main UI, this is the interpreter specified
  51    with -i on the command line) and secondary interpreters (for
  52    interpreter-exec ...), etc.  There's always one UI associated with
  53    stdin/stdout/stderr, but the user can create secondary UIs, for
  54    example, to create a separate MI channel on its own stdio
  55    streams.  */
  56
  57 struct ui
  58 {
  59   /* Create a new UI.  */
  60   ui (FILE *instream, FILE *outstream, FILE *errstream);
  61   ~ui ();
  62
  63   DISABLE_COPY_AND_ASSIGN (ui);
  64
  65   /* Pointer to next in singly-linked list.  */
  66   struct ui *next;
  67
  68   /* Convenient handle (UI number).  Unique across all UIs.  */
  69   int num;
  70
  71   /* The UI's command line buffer.  This is to used to accumulate
  72      input until we have a whole command line.  */
  73   struct buffer line_buffer;
  74
  75   /* The callback used by the event loop whenever an event is detected
  76      on the UI's input file descriptor.  This function incrementally
  77      builds a buffer where it accumulates the line read up to the
  78      point of invocation.  In the special case in which the character
  79      read is newline, the function invokes the INPUT_HANDLER callback
  80      (see below).  */
  81   void (*call_readline) (gdb_client_data);
  82
  83   /* The function to invoke when a complete line of input is ready for
  84      processing.  */
  85   void (*input_handler) (gdb::unique_xmalloc_ptr<char> &&);
  86
  87   /* True if this UI is using the readline library for command
  88      editing; false if using GDB's own simple readline emulation, with
  89      no editing support.  */
  90   int command_editing;
  91
  92   /* Each UI has its own independent set of interpreters.  */
  93   struct ui_interp_info *interp_info;
  94
  95   /* True if the UI is in async mode, false if in sync mode.  If in
  96      sync mode, a synchronous execution command (e.g, "next") does not
  97      return until the command is finished.  If in async mode, then
  98      running a synchronous command returns right after resuming the
  99      target.  Waiting for the command's completion is later done on
 100      the top event loop.  For the main UI, this starts out disabled,
 101      until all the explicit command line arguments (e.g., `gdb -ex
 102      "start" -ex "next"') are processed.  */
 103   int async;
 104
 105   /* The number of nested readline secondary prompts that are
 106      currently active.  */
 107   int secondary_prompt_depth;
 108
 109   /* The UI's stdin.  Set to stdin for the main UI.  */
 110   FILE *stdin_stream;
 111
 112   /* stdio stream that command input is being read from.  Set to stdin
 113      normally.  Set by source_command to the file we are sourcing.
 114      Set to NULL if we are executing a user-defined command or
 115      interacting via a GUI.  */
 116   FILE *instream;
 117   /* Standard output stream.  */
 118   FILE *outstream;
 119   /* Standard error stream.  */
 120   FILE *errstream;
 121
 122   /* The file descriptor for the input stream, so that we can register
 123      it with the event loop.  */
 124   int input_fd;
 125
 126   /* Whether ISATTY returns true on input_fd.  Cached here because
 127      quit_force needs to know this _after_ input_fd might be
 128      closed.  */
 129   int input_interactive_p;
 130
 131   /* See enum prompt_state's description.  */
 132   enum prompt_state prompt_state;
 133
 134   /* The fields below that start with "m_" are "private".  They're
 135      meant to be accessed through wrapper macros that make them look
 136      like globals.  */
 137
 138   /* The ui_file streams.  */
 139   /* Normal results */
 140   struct ui_file *m_gdb_stdout;
 141   /* Input stream */
 142   struct ui_file *m_gdb_stdin;
 143   /* Serious error notifications */
 144   struct ui_file *m_gdb_stderr;
 145   /* Log/debug/trace messages that should bypass normal stdout/stderr
 146      filtering.  For moment, always call this stream using
 147      *_unfiltered.  In the very near future that restriction shall be
 148      removed - either call shall be unfiltered.  (cagney 1999-06-13).  */
 149   struct ui_file *m_gdb_stdlog;
 150
 151   /* The current ui_out.  */
 152   struct ui_out *m_current_uiout;
 153 };
 154
 155 /* The main UI.  This is the UI that is bound to stdin/stdout/stderr.
 156    It always exists and is created automatically when GDB starts
 157    up.  */
 158 extern struct ui *main_ui;
 159
 160 /* The current UI.  */
 161 extern struct ui *current_ui;
 162
 163 /* The list of all UIs.  */
 164 extern struct ui *ui_list;
 165
 166 /* State for SWITCH_THRU_ALL_UIS.  */
 167 class switch_thru_all_uis
 168 {
 169 public:
 170
 171   switch_thru_all_uis () : m_iter (ui_list), m_save_ui (&current_ui)
 172   {
 173     current_ui = ui_list;
 174   }
 175
 176   /* If done iterating, return true; otherwise return false.  */
 177   bool done () const
 178   {
 179     return m_iter == NULL;
 180   }
 181
 182   /* Move to the next UI, setting current_ui if iteration is not yet
 183      complete.  */
 184   void next ()
 185   {
 186     m_iter = m_iter->next;
 187     if (m_iter != NULL)
 188       current_ui = m_iter;
 189   }
 190
 191  private:
 192
 193   /* No need for these.  They are intentionally not defined
 194      anywhere.  */
 195   switch_thru_all_uis &operator= (const switch_thru_all_uis &);
 196   switch_thru_all_uis (const switch_thru_all_uis &);
 197
 198   /* Used to iterate through the UIs.  */
 199   struct ui *m_iter;
 200
 201   /* Save and restore current_ui.  */
 202   scoped_restore_tmpl<struct ui *> m_save_ui;
 203 };
 204
 205   /* Traverse through all UI, and switch the current UI to the one
 206      being iterated.  */
 207 #define SWITCH_THRU_ALL_UIS()           \
 208   for (switch_thru_all_uis stau_state; !stau_state.done (); stau_state.next ())
 209
 210 /* An adapter that can be used to traverse over all UIs.  */
 211 static inline
 212 next_adapter<ui> all_uis ()
 213 {
 214   return next_adapter<ui> (ui_list);
 215 }
 216
 217 /* Register the UI's input file descriptor in the event loop.  */
 218 extern void ui_register_input_event_handler (struct ui *ui);
 219
 220 /* Unregister the UI's input file descriptor from the event loop.  */
 221 extern void ui_unregister_input_event_handler (struct ui *ui);
 222
 223 /* From top.c.  */
 224 extern bool confirm;
 225 extern int inhibit_gdbinit;
 226
 227 /* Print the GDB version banner to STREAM.  If INTERACTIVE is false,
 228    then information referring to commands (e.g., "show configuration")
 229    is omitted; this mode is used for the --version command line
 230    option.  If INTERACTIVE is true, then interactive commands are
 231    mentioned.  */
 232 extern void print_gdb_version (struct ui_file *stream, bool interactive);
 233
 234 extern void print_gdb_configuration (struct ui_file *);
 235
 236 extern void read_command_file (FILE *);
 237 extern void init_history (void);
 238 extern void command_loop (void);
 239 extern int quit_confirm (void);
 240 extern void quit_force (int *, int);
 241 extern void quit_command (const char *, int);
 242 extern void quit_cover (void);
 243 extern void execute_command (const char *, int);
 244
 245 /* If the interpreter is in sync mode (we're running a user command's
 246    list, running command hooks or similars), and we just ran a
 247    synchronous command that started the target, wait for that command
 248    to end.  WAS_SYNC indicates whether sync_execution was set before
 249    the command was run.  */
 250
 251 extern void maybe_wait_sync_command_done (int was_sync);
 252
 253 /* Wait for a synchronous execution command to end.  */
 254 extern void wait_sync_command_done (void);
 255
 256 extern void check_frame_language_change (void);
 257
 258 /* Prepare for execution of a command.
 259    Call this before every command, CLI or MI.
 260    Returns a cleanup to be run after the command is completed.  */
 261 extern scoped_value_mark prepare_execute_command (void);
 262
 263 /* This function returns a pointer to the string that is used
 264    by gdb for its command prompt.  */
 265 extern char *get_prompt (void);
 266
 267 /* This function returns a pointer to the string that is used
 268    by gdb for its command prompt.  */
 269 extern void set_prompt (const char *s);
 270
 271 /* Return 1 if UI's current input handler is a secondary prompt, 0
 272    otherwise.  */
 273
 274 extern int gdb_in_secondary_prompt_p (struct ui *ui);
 275
 276 /* From random places.  */
 277 extern int readnow_symbol_files;
 278 extern int readnever_symbol_files;
 279
 280 /* Perform _initialize initialization.  */
 281 extern void gdb_init (char *);
 282
 283 /* For use by event-top.c.  */
 284 /* Variables from top.c.  */
 285 extern int source_line_number;
 286 extern std::string source_file_name;
 287 extern bool history_expansion_p;
 288 extern bool server_command;
 289 extern char *lim_at_start;
 290
 291 extern void gdb_add_history (const char *);
 292
 293 extern void show_commands (const char *args, int from_tty);
 294
 295 extern void set_verbose (const char *, int, struct cmd_list_element *);
 296
 297 extern char *handle_line_of_input (struct buffer *cmd_line_buffer,
 298                                    const char *rl, int repeat,
 299                                    const char *annotation_suffix);
 300
 301 #endif