1 /* TUI display locator. 2 3 Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006, 2007, 2008, 4 2009 Free Software Foundation, Inc. 5 6 Contributed by Hewlett-Packard Company. 7 8 This file is part of GDB. 9 10 This program is free software; you can redistribute it and/or modify 11 it under the terms of the GNU General Public License as published by 12 the Free Software Foundation; either version 3 of the License, or 13 (at your option) any later version. 14 15 This program is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU General Public License for more details. 19 20 You should have received a copy of the GNU General Public License 21 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 22 23 #include "defs.h" 24 #include "symtab.h" 25 #include "breakpoint.h" 26 #include "frame.h" 27 #include "command.h" 28 #include "inferior.h" 29 #include "target.h" 30 #include "top.h" 31 #include "gdb_string.h" 32 #include "tui/tui.h" 33 #include "tui/tui-data.h" 34 #include "tui/tui-stack.h" 35 #include "tui/tui-wingeneral.h" 36 #include "tui/tui-source.h" 37 #include "tui/tui-winsource.h" 38 #include "tui/tui-file.h" 39 40 #include "gdb_curses.h" 41 42 /* Get a printable name for the function at the address. 43 The symbol name is demangled if demangling is turned on. 44 Returns a pointer to a static area holding the result. */ 45 static char *tui_get_function_from_frame (struct frame_info *fi); 46 47 /* Set the filename portion of the locator. */ 48 static void tui_set_locator_filename (const char *filename); 49 50 /* Update the locator, with the provided arguments. */ 51 static void tui_set_locator_info (struct gdbarch *gdbarch, 52 const char *filename, 53 const char *procname, 54 int lineno, CORE_ADDR addr); 55 56 static void tui_update_command (char *, int); 57 58 59 /* Create the status line to display as much information as we can on 60 this single line: target name, process number, current function, 61 current line, current PC, SingleKey mode. */ 62 static char* 63 tui_make_status_line (struct tui_locator_element *loc) 64 { 65 char *string; 66 char line_buf[50], *pname; 67 char *buf; 68 int status_size; 69 int i, proc_width; 70 const char *pid_name; 71 const char *pc_buf; 72 int target_width; 73 int pid_width; 74 int line_width; 75 int pc_width; 76 struct ui_file *pc_out; 77 78 if (ptid_equal (inferior_ptid, null_ptid)) 79 pid_name = "No process"; 80 else 81 pid_name = target_pid_to_str (inferior_ptid); 82 83 target_width = strlen (target_shortname); 84 if (target_width > MAX_TARGET_WIDTH) 85 target_width = MAX_TARGET_WIDTH; 86 87 pid_width = strlen (pid_name); 88 if (pid_width > MAX_PID_WIDTH) 89 pid_width = MAX_PID_WIDTH; 90 91 status_size = tui_term_width (); 92 string = (char *) xmalloc (status_size + 1); 93 buf = (char*) alloca (status_size + 1); 94 95 /* Translate line number and obtain its size. */ 96 if (loc->line_no > 0) 97 sprintf (line_buf, "%d", loc->line_no); 98 else 99 strcpy (line_buf, "??"); 100 line_width = strlen (line_buf); 101 if (line_width < MIN_LINE_WIDTH) 102 line_width = MIN_LINE_WIDTH; 103 104 /* Translate PC address. */ 105 pc_out = tui_sfileopen (128); 106 fputs_filtered (loc->gdbarch? paddress (loc->gdbarch, loc->addr) : "??", 107 pc_out); 108 pc_buf = tui_file_get_strbuf (pc_out); 109 pc_width = strlen (pc_buf); 110 111 /* First determine the amount of proc name width we have available. 112 The +1 are for a space separator between fields. 113 The -1 are to take into account the \0 counted by sizeof. */ 114 proc_width = (status_size 115 - (target_width + 1) 116 - (pid_width + 1) 117 - (sizeof (PROC_PREFIX) - 1 + 1) 118 - (sizeof (LINE_PREFIX) - 1 + line_width + 1) 119 - (sizeof (PC_PREFIX) - 1 + pc_width + 1) 120 - (tui_current_key_mode == TUI_SINGLE_KEY_MODE 121 ? (sizeof (SINGLE_KEY) - 1 + 1) 122 : 0)); 123 124 /* If there is no room to print the function name, try by removing 125 some fields. */ 126 if (proc_width < MIN_PROC_WIDTH) 127 { 128 proc_width += target_width + 1; 129 target_width = 0; 130 if (proc_width < MIN_PROC_WIDTH) 131 { 132 proc_width += pid_width + 1; 133 pid_width = 0; 134 if (proc_width <= MIN_PROC_WIDTH) 135 { 136 proc_width += pc_width + sizeof (PC_PREFIX) - 1 + 1; 137 pc_width = 0; 138 if (proc_width < 0) 139 { 140 proc_width += line_width + sizeof (LINE_PREFIX) - 1 + 1; 141 line_width = 0; 142 if (proc_width < 0) 143 proc_width = 0; 144 } 145 } 146 } 147 } 148 149 /* Now convert elements to string form. */ 150 pname = loc->proc_name; 151 152 /* Now create the locator line from the string version of the 153 elements. We could use sprintf() here but that wouldn't ensure 154 that we don't overrun the size of the allocated buffer. 155 strcat_to_buf() will. */ 156 *string = (char) 0; 157 158 if (target_width > 0) 159 { 160 sprintf (buf, "%*.*s ", 161 -target_width, target_width, target_shortname); 162 strcat_to_buf (string, status_size, buf); 163 } 164 if (pid_width > 0) 165 { 166 sprintf (buf, "%*.*s ", 167 -pid_width, pid_width, pid_name); 168 strcat_to_buf (string, status_size, buf); 169 } 170 171 /* Show whether we are in SingleKey mode. */ 172 if (tui_current_key_mode == TUI_SINGLE_KEY_MODE) 173 { 174 strcat_to_buf (string, status_size, SINGLE_KEY); 175 strcat_to_buf (string, status_size, " "); 176 } 177 178 /* Procedure/class name. */ 179 if (proc_width > 0) 180 { 181 if (strlen (pname) > proc_width) 182 sprintf (buf, "%s%*.*s* ", PROC_PREFIX, 183 1 - proc_width, proc_width - 1, pname); 184 else 185 sprintf (buf, "%s%*.*s ", PROC_PREFIX, 186 -proc_width, proc_width, pname); 187 strcat_to_buf (string, status_size, buf); 188 } 189 190 if (line_width > 0) 191 { 192 sprintf (buf, "%s%*.*s ", LINE_PREFIX, 193 -line_width, line_width, line_buf); 194 strcat_to_buf (string, status_size, buf); 195 } 196 if (pc_width > 0) 197 { 198 strcat_to_buf (string, status_size, PC_PREFIX); 199 strcat_to_buf (string, status_size, pc_buf); 200 } 201 202 203 for (i = strlen (string); i < status_size; i++) 204 string[i] = ' '; 205 string[status_size] = (char) 0; 206 207 ui_file_delete (pc_out); 208 return string; 209 } 210 211 /* Get a printable name for the function at the address. The symbol 212 name is demangled if demangling is turned on. Returns a pointer to 213 a static area holding the result. */ 214 static char* 215 tui_get_function_from_frame (struct frame_info *fi) 216 { 217 static char name[256]; 218 struct ui_file *stream = tui_sfileopen (256); 219 char *p; 220 221 print_address_symbolic (get_frame_pc (fi), stream, demangle, ""); 222 p = tui_file_get_strbuf (stream); 223 224 /* Use simple heuristics to isolate the function name. The symbol 225 can be demangled and we can have function parameters. Remove 226 them because the status line is too short to display them. */ 227 if (*p == '<') 228 p++; 229 strncpy (name, p, sizeof (name)); 230 p = strchr (name, '('); 231 if (!p) 232 p = strchr (name, '>'); 233 if (p) 234 *p = 0; 235 p = strchr (name, '+'); 236 if (p) 237 *p = 0; 238 ui_file_delete (stream); 239 return name; 240 } 241 242 void 243 tui_show_locator_content (void) 244 { 245 char *string; 246 struct tui_gen_win_info *locator; 247 248 locator = tui_locator_win_info_ptr (); 249 250 if (locator != NULL && locator->handle != (WINDOW *) NULL) 251 { 252 struct tui_win_element *element; 253 254 element = (struct tui_win_element *) locator->content[0]; 255 256 string = tui_make_status_line (&element->which_element.locator); 257 wmove (locator->handle, 0, 0); 258 wstandout (locator->handle); 259 waddstr (locator->handle, string); 260 wclrtoeol (locator->handle); 261 wstandend (locator->handle); 262 tui_refresh_win (locator); 263 wmove (locator->handle, 0, 0); 264 xfree (string); 265 locator->content_in_use = TRUE; 266 } 267 } 268 269 270 /* Set the filename portion of the locator. */ 271 static void 272 tui_set_locator_filename (const char *filename) 273 { 274 struct tui_gen_win_info *locator = tui_locator_win_info_ptr (); 275 struct tui_locator_element *element; 276 277 if (locator->content[0] == NULL) 278 { 279 tui_set_locator_info (NULL, filename, NULL, 0, 0); 280 return; 281 } 282 283 element = &((struct tui_win_element *) locator->content[0])->which_element.locator; 284 element->file_name[0] = 0; 285 strcat_to_buf (element->file_name, MAX_LOCATOR_ELEMENT_LEN, filename); 286 } 287 288 /* Update the locator, with the provided arguments. */ 289 static void 290 tui_set_locator_info (struct gdbarch *gdbarch, 291 const char *filename, 292 const char *procname, 293 int lineno, 294 CORE_ADDR addr) 295 { 296 struct tui_gen_win_info *locator = tui_locator_win_info_ptr (); 297 struct tui_locator_element *element; 298 299 /* Allocate the locator content if necessary. */ 300 if (locator->content_size <= 0) 301 { 302 locator->content = (void **) tui_alloc_content (1, locator->type); 303 locator->content_size = 1; 304 } 305 306 element = &((struct tui_win_element *) locator->content[0])->which_element.locator; 307 element->proc_name[0] = (char) 0; 308 strcat_to_buf (element->proc_name, MAX_LOCATOR_ELEMENT_LEN, procname); 309 element->line_no = lineno; 310 element->addr = addr; 311 element->gdbarch = gdbarch; 312 tui_set_locator_filename (filename); 313 } 314 315 /* Update only the filename portion of the locator. */ 316 void 317 tui_update_locator_filename (const char *filename) 318 { 319 tui_set_locator_filename (filename); 320 tui_show_locator_content (); 321 } 322 323 /* Function to print the frame information for the TUI. */ 324 void 325 tui_show_frame_info (struct frame_info *fi) 326 { 327 struct tui_win_info *win_info; 328 int i; 329 330 if (fi) 331 { 332 int start_line, i; 333 CORE_ADDR low; 334 struct tui_gen_win_info *locator = tui_locator_win_info_ptr (); 335 int source_already_displayed; 336 struct symtab_and_line sal; 337 338 find_frame_sal (fi, &sal); 339 340 source_already_displayed = sal.symtab != 0 341 && tui_source_is_displayed (sal.symtab->filename); 342 tui_set_locator_info (get_frame_arch (fi), 343 sal.symtab == 0 ? "??" : sal.symtab->filename, 344 tui_get_function_from_frame (fi), 345 sal.line, 346 get_frame_pc (fi)); 347 tui_show_locator_content (); 348 start_line = 0; 349 for (i = 0; i < (tui_source_windows ())->count; i++) 350 { 351 union tui_which_element *item; 352 win_info = (tui_source_windows ())->list[i]; 353 354 item = &((struct tui_win_element *) locator->content[0])->which_element; 355 if (win_info == TUI_SRC_WIN) 356 { 357 start_line = (item->locator.line_no - 358 (win_info->generic.viewport_height / 2)) + 1; 359 if (start_line <= 0) 360 start_line = 1; 361 } 362 else 363 { 364 if (find_pc_partial_function (get_frame_pc (fi), (char **) NULL, 365 &low, (CORE_ADDR) 0) == 0) 366 error (_("No function contains program counter for selected frame.")); 367 else 368 low = tui_get_low_disassembly_address (get_frame_arch (fi), 369 low, get_frame_pc (fi)); 370 } 371 372 if (win_info == TUI_SRC_WIN) 373 { 374 struct tui_line_or_address l; 375 l.loa = LOA_LINE; 376 l.u.line_no = start_line; 377 if (!(source_already_displayed 378 && tui_line_is_displayed (item->locator.line_no, win_info, TRUE))) 379 tui_update_source_window (win_info, get_frame_arch (fi), 380 sal.symtab, l, TRUE); 381 else 382 { 383 l.u.line_no = item->locator.line_no; 384 tui_set_is_exec_point_at (l, win_info); 385 } 386 } 387 else 388 { 389 if (win_info == TUI_DISASM_WIN) 390 { 391 struct tui_line_or_address a; 392 a.loa = LOA_ADDRESS; 393 a.u.addr = low; 394 if (!tui_addr_is_displayed (item->locator.addr, win_info, TRUE)) 395 tui_update_source_window (win_info, get_frame_arch (fi), 396 sal.symtab, a, TRUE); 397 else 398 { 399 a.u.addr = item->locator.addr; 400 tui_set_is_exec_point_at (a, win_info); 401 } 402 } 403 } 404 tui_update_exec_info (win_info); 405 } 406 } 407 else 408 { 409 tui_set_locator_info (NULL, NULL, NULL, 0, (CORE_ADDR) 0); 410 tui_show_locator_content (); 411 for (i = 0; i < (tui_source_windows ())->count; i++) 412 { 413 win_info = (tui_source_windows ())->list[i]; 414 tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT); 415 tui_update_exec_info (win_info); 416 } 417 } 418 } 419 420 /* Function to initialize gdb commands, for tui window stack 421 manipulation. */ 422 423 /* Provide a prototype to silence -Wmissing-prototypes. */ 424 extern initialize_file_ftype _initialize_tui_stack; 425 426 void 427 _initialize_tui_stack (void) 428 { 429 add_com ("update", class_tui, tui_update_command, _("\ 430 Update the source window and locator to display the current execution point.\n")); 431 } 432 433 /* Command to update the display with the current execution point. */ 434 static void 435 tui_update_command (char *arg, int from_tty) 436 { 437 char cmd[sizeof("frame 0")]; 438 439 strcpy (cmd, "frame 0"); 440 execute_command (cmd, from_tty); 441 } 442