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