Make out and error streams be per UI
[external/binutils.git] / 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   /* stdio stream that command input is being read from.  Set to stdin
72      normally.  Set by source_command to the file we are sourcing.
73      Set to NULL if we are executing a user-defined command or
74      interacting via a GUI.  */
75   FILE *instream;
76   /* Standard output stream.  */
77   FILE *outstream;
78   /* Standard error stream.  */
79   FILE *errstream;
80
81   /* The file descriptor for the input stream, so that we can register
82      it with the event loop.  */
83   int input_fd;
84
85   /* The fields below that start with "m_" are "private".  They're
86      meant to be accessed through wrapper macros that make them look
87      like globals.  */
88
89   /* The ui_file streams.  */
90   /* Normal results */
91   struct ui_file *m_gdb_stdout;
92   /* Input stream */
93   struct ui_file *m_gdb_stdin;
94   /* Serious error notifications */
95   struct ui_file *m_gdb_stderr;
96   /* Log/debug/trace messages that should bypass normal stdout/stderr
97      filtering.  For moment, always call this stream using
98      *_unfiltered.  In the very near future that restriction shall be
99      removed - either call shall be unfiltered.  (cagney 1999-06-13).  */
100   struct ui_file *m_gdb_stdlog;
101 };
102
103 /* The main UI.  This is the UI that is bound to stdin/stdout/stderr.
104    It always exists and is created automatically when GDB starts
105    up.  */
106 extern struct ui *main_ui;
107
108 /* The current UI.  */
109 extern struct ui *current_ui;
110
111 /* The list of all UIs.  */
112 extern struct ui *ui_list;
113
114 /* State for SWITCH_THRU_ALL_UIS.  Declared here because it is meant
115    to be created on the stack, but should be treated as opaque.  */
116 struct switch_thru_all_uis
117 {
118   struct ui *iter;
119   struct cleanup *old_chain;
120 };
121
122 /* Functions to drive SWITCH_THRU_ALL_UIS.  Though declared here by
123    necessity, these functions should not be used other than via the
124    SWITCH_THRU_ALL_UIS macro defined below.  */
125 extern void switch_thru_all_uis_init (struct switch_thru_all_uis *state);
126 extern int switch_thru_all_uis_cond (struct switch_thru_all_uis *state);
127 extern void switch_thru_all_uis_next (struct switch_thru_all_uis *state);
128
129   /* Traverse through all UI, and switch the current UI to the one
130      being iterated.  */
131 #define SWITCH_THRU_ALL_UIS(STATE)              \
132   for (switch_thru_all_uis_init (&STATE);               \
133        switch_thru_all_uis_cond (&STATE);               \
134        switch_thru_all_uis_next (&STATE))
135
136 /* From top.c.  */
137 extern char *saved_command_line;
138 extern int in_user_command;
139 extern int confirm;
140 extern char gdb_dirbuf[1024];
141 extern int inhibit_gdbinit;
142 extern const char gdbinit[];
143
144 extern void print_gdb_version (struct ui_file *);
145 extern void print_gdb_configuration (struct ui_file *);
146
147 extern void read_command_file (FILE *);
148 extern void init_history (void);
149 extern void command_loop (void);
150 extern int quit_confirm (void);
151 extern void quit_force (char *, int);
152 extern void quit_command (char *, int);
153 extern void quit_cover (void);
154 extern void execute_command (char *, int);
155
156 /* If the interpreter is in sync mode (we're running a user command's
157    list, running command hooks or similars), and we just ran a
158    synchronous command that started the target, wait for that command
159    to end.  WAS_SYNC indicates whether sync_execution was set before
160    the command was run.  */
161
162 extern void maybe_wait_sync_command_done (int was_sync);
163
164 /* Wait for a synchronous execution command to end.  */
165 extern void wait_sync_command_done (void);
166
167 extern void check_frame_language_change (void);
168
169 /* Prepare for execution of a command.
170    Call this before every command, CLI or MI.
171    Returns a cleanup to be run after the command is completed.  */
172 extern struct cleanup *prepare_execute_command (void);
173
174 /* This function returns a pointer to the string that is used
175    by gdb for its command prompt.  */
176 extern char *get_prompt (void);
177
178 /* This function returns a pointer to the string that is used
179    by gdb for its command prompt.  */
180 extern void set_prompt (const char *s);
181
182 /* Return 1 if the current input handler is a secondary prompt, 0 otherwise.  */
183
184 extern int gdb_in_secondary_prompt_p (void);
185
186 /* From random places.  */
187 extern int readnow_symbol_files;
188
189 /* Perform _initialize initialization.  */
190 extern void gdb_init (char *);
191
192 /* For use by event-top.c.  */
193 /* Variables from top.c.  */
194 extern int source_line_number;
195 extern const char *source_file_name;
196 extern int history_expansion_p;
197 extern int server_command;
198 extern char *lim_at_start;
199
200 extern void gdb_add_history (const char *);
201
202 extern void show_commands (char *args, int from_tty);
203
204 extern void set_history (char *, int);
205
206 extern void show_history (char *, int);
207
208 extern void set_verbose (char *, int, struct cmd_list_element *);
209
210 extern void do_restore_instream_cleanup (void *stream);
211
212 extern char *handle_line_of_input (struct buffer *cmd_line_buffer,
213                                    char *rl, int repeat,
214                                    char *annotation_suffix);
215
216 #endif