gdb/tui/tui-stack.c

   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 \f
  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_arch (fi), get_frame_pc (fi),
 222                           stream, demangle, "");
 223   p = tui_file_get_strbuf (stream);
 224
 225   /* Use simple heuristics to isolate the function name.  The symbol
 226      can be demangled and we can have function parameters.  Remove
 227      them because the status line is too short to display them.  */
 228   if (*p == '<')
 229     p++;
 230   strncpy (name, p, sizeof (name));
 231   p = strchr (name, '(');
 232   if (!p)
 233     p = strchr (name, '>');
 234   if (p)
 235     *p = 0;
 236   p = strchr (name, '+');
 237   if (p)
 238     *p = 0;
 239   ui_file_delete (stream);
 240   return name;
 241 }
 242
 243 void
 244 tui_show_locator_content (void)
 245 {
 246   char *string;
 247   struct tui_gen_win_info *locator;
 248
 249   locator = tui_locator_win_info_ptr ();
 250
 251   if (locator != NULL && locator->handle != (WINDOW *) NULL)
 252     {
 253       struct tui_win_element *element;
 254
 255       element = (struct tui_win_element *) locator->content[0];
 256
 257       string = tui_make_status_line (&element->which_element.locator);
 258       wmove (locator->handle, 0, 0);
 259       wstandout (locator->handle);
 260       waddstr (locator->handle, string);
 261       wclrtoeol (locator->handle);
 262       wstandend (locator->handle);
 263       tui_refresh_win (locator);
 264       wmove (locator->handle, 0, 0);
 265       xfree (string);
 266       locator->content_in_use = TRUE;
 267     }
 268 }
 269
 270
 271 /* Set the filename portion of the locator.  */
 272 static void
 273 tui_set_locator_filename (const char *filename)
 274 {
 275   struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
 276   struct tui_locator_element *element;
 277
 278   if (locator->content[0] == NULL)
 279     {
 280       tui_set_locator_info (NULL, filename, NULL, 0, 0);
 281       return;
 282     }
 283
 284   element = &((struct tui_win_element *) locator->content[0])->which_element.locator;
 285   element->file_name[0] = 0;
 286   strcat_to_buf (element->file_name, MAX_LOCATOR_ELEMENT_LEN, filename);
 287 }
 288
 289 /* Update the locator, with the provided arguments.  */
 290 static void
 291 tui_set_locator_info (struct gdbarch *gdbarch,
 292                       const char *filename,
 293                       const char *procname,
 294                       int lineno,
 295                       CORE_ADDR addr)
 296 {
 297   struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
 298   struct tui_locator_element *element;
 299
 300   /* Allocate the locator content if necessary.  */
 301   if (locator->content_size <= 0)
 302     {
 303       locator->content = (void **) tui_alloc_content (1, locator->type);
 304       locator->content_size = 1;
 305     }
 306
 307   element = &((struct tui_win_element *) locator->content[0])->which_element.locator;
 308   element->proc_name[0] = (char) 0;
 309   strcat_to_buf (element->proc_name, MAX_LOCATOR_ELEMENT_LEN, procname);
 310   element->line_no = lineno;
 311   element->addr = addr;
 312   element->gdbarch = gdbarch;
 313   tui_set_locator_filename (filename);
 314 }
 315
 316 /* Update only the filename portion of the locator.  */
 317 void
 318 tui_update_locator_filename (const char *filename)
 319 {
 320   tui_set_locator_filename (filename);
 321   tui_show_locator_content ();
 322 }
 323
 324 /* Function to print the frame information for the TUI.  */
 325 void
 326 tui_show_frame_info (struct frame_info *fi)
 327 {
 328   struct tui_win_info *win_info;
 329   int i;
 330
 331   if (fi)
 332     {
 333       int start_line, i;
 334       CORE_ADDR low;
 335       struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
 336       int source_already_displayed;
 337       struct symtab_and_line sal;
 338
 339       find_frame_sal (fi, &sal);
 340
 341       source_already_displayed = sal.symtab != 0
 342         && tui_source_is_displayed (sal.symtab->filename);
 343       tui_set_locator_info (get_frame_arch (fi),
 344                             sal.symtab == 0 ? "??" : sal.symtab->filename,
 345                             tui_get_function_from_frame (fi),
 346                             sal.line,
 347                             get_frame_pc (fi));
 348       tui_show_locator_content ();
 349       start_line = 0;
 350       for (i = 0; i < (tui_source_windows ())->count; i++)
 351         {
 352           union tui_which_element *item;
 353           win_info = (tui_source_windows ())->list[i];
 354
 355           item = &((struct tui_win_element *) locator->content[0])->which_element;
 356           if (win_info == TUI_SRC_WIN)
 357             {
 358               start_line = (item->locator.line_no -
 359                            (win_info->generic.viewport_height / 2)) + 1;
 360               if (start_line <= 0)
 361                 start_line = 1;
 362             }
 363           else
 364             {
 365               if (find_pc_partial_function (get_frame_pc (fi), (char **) NULL,
 366                                             &low, (CORE_ADDR) 0) == 0)
 367                 error (_("No function contains program counter for selected frame."));
 368               else
 369                 low = tui_get_low_disassembly_address (get_frame_arch (fi),
 370                                                        low, get_frame_pc (fi));
 371             }
 372
 373           if (win_info == TUI_SRC_WIN)
 374             {
 375               struct tui_line_or_address l;
 376               l.loa = LOA_LINE;
 377               l.u.line_no = start_line;
 378               if (!(source_already_displayed
 379                     && tui_line_is_displayed (item->locator.line_no, win_info, TRUE)))
 380                 tui_update_source_window (win_info, get_frame_arch (fi),
 381                                           sal.symtab, l, TRUE);
 382               else
 383                 {
 384                   l.u.line_no = item->locator.line_no;
 385                   tui_set_is_exec_point_at (l, win_info);
 386                 }
 387             }
 388           else
 389             {
 390               if (win_info == TUI_DISASM_WIN)
 391                 {
 392                   struct tui_line_or_address a;
 393                   a.loa = LOA_ADDRESS;
 394                   a.u.addr = low;
 395                   if (!tui_addr_is_displayed (item->locator.addr, win_info, TRUE))
 396                     tui_update_source_window (win_info, get_frame_arch (fi),
 397                                               sal.symtab, a, TRUE);
 398                   else
 399                     {
 400                       a.u.addr = item->locator.addr;
 401                       tui_set_is_exec_point_at (a, win_info);
 402                     }
 403                 }
 404             }
 405           tui_update_exec_info (win_info);
 406         }
 407     }
 408   else
 409     {
 410       tui_set_locator_info (NULL, NULL, NULL, 0, (CORE_ADDR) 0);
 411       tui_show_locator_content ();
 412       for (i = 0; i < (tui_source_windows ())->count; i++)
 413         {
 414           win_info = (tui_source_windows ())->list[i];
 415           tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
 416           tui_update_exec_info (win_info);
 417         }
 418     }
 419 }
 420
 421 /* Function to initialize gdb commands, for tui window stack
 422    manipulation.  */
 423
 424 /* Provide a prototype to silence -Wmissing-prototypes.  */
 425 extern initialize_file_ftype _initialize_tui_stack;
 426
 427 void
 428 _initialize_tui_stack (void)
 429 {
 430   add_com ("update", class_tui, tui_update_command, _("\
 431 Update the source window and locator to display the current execution point.\n"));
 432 }
 433
 434 /* Command to update the display with the current execution point.  */
 435 static void
 436 tui_update_command (char *arg, int from_tty)
 437 {
 438   char cmd[sizeof("frame 0")];
 439
 440   strcpy (cmd, "frame 0");
 441   execute_command (cmd, from_tty);
 442 }