gdb/top.h

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