gdb/top.h

   1 /* Top level stuff for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2016 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 /* All about a user interface instance.  Each user interface has its
  29    own I/O files/streams, readline state, its own top level
  30    interpreter (for the main UI, this is the interpreter specified
  31    with -i on the command line) and secondary interpreters (for
  32    interpreter-exec ...), etc.  There's always one UI associated with
  33    stdin/stdout/stderr, but the user can create secondary UIs, for
  34    example, to create a separate MI channel on its own stdio
  35    streams.  */
  36
  37 struct ui
  38 {
  39   /* Pointer to next in singly-linked list.  */
  40   struct ui *next;
  41
  42   /* The UI's command line buffer.  This is to used to accumulate
  43      input until we have a whole command line.  */
  44   struct buffer line_buffer;
  45
  46   /* The callback used by the event loop whenever an event is detected
  47      on the UI's input file descriptor.  This function incrementally
  48      builds a buffer where it accumulates the line read up to the
  49      point of invocation.  In the special case in which the character
  50      read is newline, the function invokes the INPUT_HANDLER callback
  51      (see below).  */
  52   void (*call_readline) (gdb_client_data);
  53
  54   /* The function to invoke when a complete line of input is ready for
  55      processing.  */
  56   void (*input_handler) (char *);
  57
  58   /* Each UI has its own independent set of interpreters.  */
  59   struct ui_interp_info *interp_info;
  60
  61   /* True if the UI is in async mode, false if in sync mode.  If in
  62      sync mode, a synchronous execution command (e.g, "next") does not
  63      return until the command is finished.  If in async mode, then
  64      running a synchronous command returns right after resuming the
  65      target.  Waiting for the command's completion is later done on
  66      the top event loop.  For the main UI, this starts out disabled,
  67      until all the explicit command line arguments (e.g., `gdb -ex
  68      "start" -ex "next"') are processed.  */
  69   int async;
  70
  71   /* The fields below that start with "m_" are "private".  They're
  72      meant to be accessed through wrapper macros that make them look
  73      like globals.  */
  74
  75   /* The ui_file streams.  */
  76   /* Normal results */
  77   struct ui_file *m_gdb_stdout;
  78   /* Input stream */
  79   struct ui_file *m_gdb_stdin;
  80   /* Serious error notifications */
  81   struct ui_file *m_gdb_stderr;
  82   /* Log/debug/trace messages that should bypass normal stdout/stderr
  83      filtering.  For moment, always call this stream using
  84      *_unfiltered.  In the very near future that restriction shall be
  85      removed - either call shall be unfiltered.  (cagney 1999-06-13).  */
  86   struct ui_file *m_gdb_stdlog;
  87 };
  88
  89 /* The current UI.  */
  90 extern struct ui *current_ui;
  91
  92 /* The list of all UIs.  */
  93 extern struct ui *ui_list;
  94
  95 /* State for SWITCH_THRU_ALL_UIS.  Declared here because it is meant
  96    to be created on the stack, but should be treated as opaque.  */
  97 struct switch_thru_all_uis
  98 {
  99   struct ui *iter;
 100   struct cleanup *old_chain;
 101 };
 102
 103 /* Functions to drive SWITCH_THRU_ALL_UIS.  Though declared here by
 104    necessity, these functions should not be used other than via the
 105    SWITCH_THRU_ALL_UIS macro defined below.  */
 106 extern void switch_thru_all_uis_init (struct switch_thru_all_uis *state);
 107 extern int switch_thru_all_uis_cond (struct switch_thru_all_uis *state);
 108 extern void switch_thru_all_uis_next (struct switch_thru_all_uis *state);
 109
 110   /* Traverse through all UI, and switch the current UI to the one
 111      being iterated.  */
 112 #define SWITCH_THRU_ALL_UIS(STATE)              \
 113   for (switch_thru_all_uis_init (&STATE);               \
 114        switch_thru_all_uis_cond (&STATE);               \
 115        switch_thru_all_uis_next (&STATE))
 116
 117 /* From top.c.  */
 118 extern char *saved_command_line;
 119 extern FILE *instream;
 120 extern int in_user_command;
 121 extern int confirm;
 122 extern char gdb_dirbuf[1024];
 123 extern int inhibit_gdbinit;
 124 extern const char gdbinit[];
 125
 126 extern void print_gdb_version (struct ui_file *);
 127 extern void print_gdb_configuration (struct ui_file *);
 128
 129 extern void read_command_file (FILE *);
 130 extern void init_history (void);
 131 extern void command_loop (void);
 132 extern int quit_confirm (void);
 133 extern void quit_force (char *, int);
 134 extern void quit_command (char *, int);
 135 extern void quit_cover (void);
 136 extern void execute_command (char *, int);
 137
 138 /* If the interpreter is in sync mode (we're running a user command's
 139    list, running command hooks or similars), and we just ran a
 140    synchronous command that started the target, wait for that command
 141    to end.  WAS_SYNC indicates whether sync_execution was set before
 142    the command was run.  */
 143
 144 extern void maybe_wait_sync_command_done (int was_sync);
 145
 146 /* Wait for a synchronous execution command to end.  */
 147 extern void wait_sync_command_done (void);
 148
 149 extern void check_frame_language_change (void);
 150
 151 /* Prepare for execution of a command.
 152    Call this before every command, CLI or MI.
 153    Returns a cleanup to be run after the command is completed.  */
 154 extern struct cleanup *prepare_execute_command (void);
 155
 156 /* This function returns a pointer to the string that is used
 157    by gdb for its command prompt.  */
 158 extern char *get_prompt (void);
 159
 160 /* This function returns a pointer to the string that is used
 161    by gdb for its command prompt.  */
 162 extern void set_prompt (const char *s);
 163
 164 /* Return 1 if the current input handler is a secondary prompt, 0 otherwise.  */
 165
 166 extern int gdb_in_secondary_prompt_p (void);
 167
 168 /* From random places.  */
 169 extern int readnow_symbol_files;
 170
 171 /* Perform _initialize initialization.  */
 172 extern void gdb_init (char *);
 173
 174 /* For use by event-top.c.  */
 175 /* Variables from top.c.  */
 176 extern int source_line_number;
 177 extern const char *source_file_name;
 178 extern int history_expansion_p;
 179 extern int server_command;
 180 extern char *lim_at_start;
 181
 182 extern void gdb_add_history (const char *);
 183
 184 extern void show_commands (char *args, int from_tty);
 185
 186 extern void set_history (char *, int);
 187
 188 extern void show_history (char *, int);
 189
 190 extern void set_verbose (char *, int, struct cmd_list_element *);
 191
 192 extern void do_restore_instream_cleanup (void *stream);
 193
 194 extern char *handle_line_of_input (struct buffer *cmd_line_buffer,
 195                                    char *rl, int repeat,
 196                                    char *annotation_suffix);
 197
 198 #endif