gdb/top.h

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