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