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