1 /* TUI Interpreter definitions for GDB, the GNU debugger. 2 3 Copyright 2003 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 2 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, write to the Free Software 19 Foundation, Inc., 59 Temple Place - Suite 330, 20 Boston, MA 02111-1307, USA. */ 21 22 #include "defs.h" 23 #include "interps.h" 24 #include "top.h" 25 #include "event-top.h" 26 #include "event-loop.h" 27 #include "ui-out.h" 28 #include "cli-out.h" 29 #include "tui/tui-data.h" 30 #include "readline/readline.h" 31 #include "tui/tui-win.h" 32 #include "tui/tui.h" 33 #include "tui/tui-io.h" 34 35 /* Set to 1 when the TUI mode must be activated when we first start 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 44 in a clean state (see endwin()). */ 45 tui_disable (); 46 } 47 48 /* These implement the TUI interpreter. */ 49 50 static void * 51 tui_init (void) 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_readline (); 60 61 return NULL; 62 } 63 64 static int 65 tui_resume (void *data) 66 { 67 struct ui_file *stream; 68 69 /* gdb_setup_readline will change gdb_stdout. If the TUI was previously 70 writing to gdb_stdout, then set it to the new gdb_stdout afterwards. */ 71 72 stream = cli_out_set_stream (tui_old_uiout, gdb_stdout); 73 if (stream != gdb_stdout) 74 { 75 cli_out_set_stream (tui_old_uiout, stream); 76 stream = NULL; 77 } 78 79 gdb_setup_readline (); 80 81 if (stream != NULL) 82 cli_out_set_stream (tui_old_uiout, gdb_stdout); 83 84 if (tui_start_enabled) 85 tui_enable (); 86 return 1; 87 } 88 89 static int 90 tui_suspend (void *data) 91 { 92 tui_start_enabled = tui_active; 93 tui_disable (); 94 return 1; 95 } 96 97 /* Display the prompt if we are silent. */ 98 99 static int 100 tui_display_prompt_p (void *data) 101 { 102 if (interp_quiet_p (NULL)) 103 return 0; 104 else 105 return 1; 106 } 107 108 static int 109 tui_exec (void *data, const char *command_str) 110 { 111 internal_error (__FILE__, __LINE__, "tui_exec called"); 112 } 113 114 115 /* Initialize all the necessary variables, start the event loop, 116 register readline, and stdin, start the loop. */ 117 118 static void 119 tui_command_loop (void *data) 120 { 121 int length; 122 char *a_prompt; 123 char *gdb_prompt = get_prompt (); 124 125 /* If we are using readline, set things up and display the first 126 prompt, otherwise just print the prompt. */ 127 if (async_command_editing_p) 128 { 129 /* Tell readline what the prompt to display is and what function 130 it will need to call after a whole line is read. This also 131 displays the first prompt. */ 132 length = strlen (PREFIX (0)) + strlen (gdb_prompt) + strlen (SUFFIX (0)) + 1; 133 a_prompt = (char *) xmalloc (length); 134 strcpy (a_prompt, PREFIX (0)); 135 strcat (a_prompt, gdb_prompt); 136 strcat (a_prompt, SUFFIX (0)); 137 rl_callback_handler_install (a_prompt, input_handler); 138 } 139 else 140 display_gdb_prompt (0); 141 142 /* Loop until there is nothing to do. This is the entry point to the 143 event loop engine. gdb_do_one_event, called via catch_errors() 144 will process one event for each invocation. It blocks waits for 145 an event and then processes it. >0 when an event is processed, 0 146 when catch_errors() caught an error and <0 when there are no 147 longer any event sources registered. */ 148 while (1) 149 { 150 int result = catch_errors (gdb_do_one_event, 0, "", RETURN_MASK_ALL); 151 if (result < 0) 152 break; 153 154 /* Update gdb output according to TUI mode. Since catch_errors 155 preserves the uiout from changing, this must be done at top 156 level of event loop. */ 157 if (tui_active) 158 uiout = tui_out; 159 else 160 uiout = tui_old_uiout; 161 162 if (result == 0) 163 { 164 /* FIXME: this should really be a call to a hook that is 165 interface specific, because interfaces can display the 166 prompt in their own way. */ 167 display_gdb_prompt (0); 168 /* This call looks bizarre, but it is required. If the user 169 entered a command that caused an error, 170 after_char_processing_hook won't be called from 171 rl_callback_read_char_wrapper. Using a cleanup there 172 won't work, since we want this function to be called 173 after a new prompt is printed. */ 174 if (after_char_processing_hook) 175 (*after_char_processing_hook) (); 176 /* Maybe better to set a flag to be checked somewhere as to 177 whether display the prompt or not. */ 178 } 179 } 180 181 /* We are done with the event loop. There are no more event sources 182 to listen to. So we exit GDB. */ 183 return; 184 } 185 186 void 187 _initialize_tui_interp (void) 188 { 189 static const struct interp_procs procs = { 190 tui_init, 191 tui_resume, 192 tui_suspend, 193 tui_exec, 194 tui_display_prompt_p, 195 tui_command_loop, 196 }; 197 struct interp *tui_interp; 198 199 /* Create a default uiout builder for the TUI. */ 200 tui_out = tui_out_new (gdb_stdout); 201 interp_add (interp_new ("tui", NULL, tui_out, &procs)); 202 if (interpreter_p && strcmp (interpreter_p, "tui") == 0) 203 tui_start_enabled = 1; 204 205 if (interpreter_p && strcmp (interpreter_p, INTERP_CONSOLE) == 0) 206 { 207 xfree (interpreter_p); 208 interpreter_p = xstrdup ("tui"); 209 } 210 } 211