1 /* TUI Interpreter definitions for GDB, the GNU debugger.
2
3 Copyright (C) 2003, 2007, 2008, 2009, 2010, 2011
4 Free Software Foundation, Inc.
5
6 This file is part of GDB.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
20
21 #include "defs.h"
22 #include "interps.h"
23 #include "top.h"
24 #include "event-top.h"
25 #include "event-loop.h"
26 #include "ui-out.h"
27 #include "cli-out.h"
28 #include "tui/tui-data.h"
29 #include "readline/readline.h"
30 #include "tui/tui-win.h"
31 #include "tui/tui.h"
32 #include "tui/tui-io.h"
33 #include "exceptions.h"
34
35 /* Set to 1 when the TUI mode must be activated when we first start
36 gdb. */
37 static int tui_start_enabled = 0;
38
39 /* Cleanup the tui before exiting. */
40
41 static void
tui_exit(void)42 tui_exit (void)
43 {
44 /* Disable the tui. Curses mode is left leaving the screen in a
45 clean state (see endwin()). */
46 tui_disable ();
47 }
48
49 /* True if TUI is the top-level interpreter. */
50 static int tui_is_toplevel = 0;
51
52 /* These implement the TUI interpreter. */
53
54 static void *
tui_init(int top_level)55 tui_init (int top_level)
56 {
57 tui_is_toplevel = top_level;
58
59 /* Install exit handler to leave the screen in a good shape. */
60 atexit (tui_exit);
61
62 tui_initialize_static_data ();
63
64 tui_initialize_io ();
65 tui_initialize_win ();
66 if (ui_file_isatty (gdb_stdout))
67 tui_initialize_readline ();
68
69 return NULL;
70 }
71
72 /* True if enabling the TUI is allowed. Example, if the top level
73 interpreter is MI, enabling curses will certainly lose. */
74
75 int
tui_allowed_p(void)76 tui_allowed_p (void)
77 {
78 /* Only if TUI is the top level interpreter. Also don't try to
79 setup curses (and print funny control characters) if we're not
80 outputting to a terminal. */
81 return tui_is_toplevel && ui_file_isatty (gdb_stdout);
82 }
83
84 static int
tui_resume(void * data)85 tui_resume (void *data)
86 {
87 struct ui_file *stream;
88
89 /* gdb_setup_readline will change gdb_stdout. If the TUI was
90 previously writing to gdb_stdout, then set it to the new
91 gdb_stdout afterwards. */
92
93 stream = cli_out_set_stream (tui_old_uiout, gdb_stdout);
94 if (stream != gdb_stdout)
95 {
96 cli_out_set_stream (tui_old_uiout, stream);
97 stream = NULL;
98 }
99
100 gdb_setup_readline ();
101
102 if (stream != NULL)
103 cli_out_set_stream (tui_old_uiout, gdb_stdout);
104
105 if (tui_start_enabled)
106 tui_enable ();
107 return 1;
108 }
109
110 static int
tui_suspend(void * data)111 tui_suspend (void *data)
112 {
113 tui_start_enabled = tui_active;
114 tui_disable ();
115 return 1;
116 }
117
118 /* Display the prompt if we are silent. */
119
120 static int
tui_display_prompt_p(void * data)121 tui_display_prompt_p (void *data)
122 {
123 if (interp_quiet_p (NULL))
124 return 0;
125 else
126 return 1;
127 }
128
129 static struct gdb_exception
tui_exec(void * data,const char * command_str)130 tui_exec (void *data, const char *command_str)
131 {
132 internal_error (__FILE__, __LINE__, _("tui_exec called"));
133 }
134
135
136 /* Initialize all the necessary variables, start the event loop,
137 register readline, and stdin, start the loop. */
138
139 static void
tui_command_loop(void * data)140 tui_command_loop (void *data)
141 {
142 /* If we are using readline, set things up and display the first
143 prompt, otherwise just print the prompt. */
144 if (async_command_editing_p)
145 {
146 int length;
147 char *a_prompt;
148 char *gdb_prompt = get_prompt ();
149
150 /* Tell readline what the prompt to display is and what function
151 it will need to call after a whole line is read. This also
152 displays the first prompt. */
153 length = strlen (PREFIX (0))
154 + strlen (gdb_prompt) + strlen (SUFFIX (0)) + 1;
155 a_prompt = (char *) alloca (length);
156 strcpy (a_prompt, PREFIX (0));
157 strcat (a_prompt, gdb_prompt);
158 strcat (a_prompt, SUFFIX (0));
159 rl_callback_handler_install (a_prompt, input_handler);
160 }
161 else
162 display_gdb_prompt (0);
163
164 /* Loop until there is nothing to do. This is the entry point to the
165 event loop engine. gdb_do_one_event, called via catch_errors()
166 will process one event for each invocation. It blocks waits for
167 an event and then processes it. >0 when an event is processed, 0
168 when catch_errors() caught an error and <0 when there are no
169 longer any event sources registered. */
170 while (1)
171 {
172 int result = catch_errors (gdb_do_one_event, 0, "", RETURN_MASK_ALL);
173
174 if (result < 0)
175 break;
176
177 /* Update gdb output according to TUI mode. Since catch_errors
178 preserves the uiout from changing, this must be done at top
179 level of event loop. */
180 if (tui_active)
181 uiout = tui_out;
182 else
183 uiout = tui_old_uiout;
184
185 if (result == 0)
186 {
187 /* If any exception escaped to here, we better enable
188 stdin. Otherwise, any command that calls async_disable_stdin,
189 and then throws, will leave stdin inoperable. */
190 async_enable_stdin ();
191 /* FIXME: this should really be a call to a hook that is
192 interface specific, because interfaces can display the
193 prompt in their own way. */
194 display_gdb_prompt (0);
195 /* This call looks bizarre, but it is required. If the user
196 entered a command that caused an error,
197 after_char_processing_hook won't be called from
198 rl_callback_read_char_wrapper. Using a cleanup there
199 won't work, since we want this function to be called
200 after a new prompt is printed. */
201 if (after_char_processing_hook)
202 (*after_char_processing_hook) ();
203 /* Maybe better to set a flag to be checked somewhere as to
204 whether display the prompt or not. */
205 }
206 }
207
208 /* We are done with the event loop. There are no more event sources
209 to listen to. So we exit GDB. */
210 return;
211 }
212
213 /* Provide a prototype to silence -Wmissing-prototypes. */
214 extern initialize_file_ftype _initialize_tui_interp;
215
216 void
_initialize_tui_interp(void)217 _initialize_tui_interp (void)
218 {
219 static const struct interp_procs procs = {
220 tui_init,
221 tui_resume,
222 tui_suspend,
223 tui_exec,
224 tui_display_prompt_p,
225 tui_command_loop,
226 };
227
228 /* Create a default uiout builder for the TUI. */
229 tui_out = tui_out_new (gdb_stdout);
230 interp_add (interp_new (INTERP_TUI, NULL, tui_out, &procs));
231 if (interpreter_p && strcmp (interpreter_p, INTERP_TUI) == 0)
232 tui_start_enabled = 1;
233
234 if (interpreter_p && strcmp (interpreter_p, INTERP_CONSOLE) == 0)
235 {
236 xfree (interpreter_p);
237 interpreter_p = xstrdup (INTERP_TUI);
238 }
239 }
240