gdb/tui/tui-stack.c

   1 /* TUI display locator.
   2
   3    Copyright 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software
   4    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 2 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, write to the Free Software
  22    Foundation, Inc., 59 Temple Place - Suite 330,
  23    Boston, MA 02111-1307, USA.  */
  24
  25 #include "defs.h"
  26 #include "symtab.h"
  27 #include "breakpoint.h"
  28 #include "frame.h"
  29 #include "command.h"
  30 #include "inferior.h"
  31 #include "target.h"
  32 #include "top.h"
  33 #include "gdb_string.h"
  34 #include "tui/tui.h"
  35 #include "tui/tui-data.h"
  36 #include "tui/tui-stack.h"
  37 #include "tui/tui-wingeneral.h"
  38 #include "tui/tui-source.h"
  39 #include "tui/tui-winsource.h"
  40 #include "tui/tui-file.h"
  41
  42 #ifdef HAVE_NCURSES_H
  43 #include <ncurses.h>
  44 #else
  45 #ifdef HAVE_CURSES_H
  46 #include <curses.h>
  47 #endif
  48 #endif
  49
  50 /* Get a printable name for the function at the address.
  51    The symbol name is demangled if demangling is turned on.
  52    Returns a pointer to a static area holding the result.  */
  53 static char* tui_get_function_from_frame (struct frame_info *fi);
  54
  55 /* Set the filename portion of the locator.  */
  56 static void tui_set_locator_filename (const char *filename);
  57
  58 /* Update the locator, with the provided arguments.  */
  59 static void tui_set_locator_info (const char *filename, const char *procname,
  60                                   int lineno, CORE_ADDR addr);
  61
  62 static void tui_update_command (char *, int);
  63 \f
  64
  65 /* Create the status line to display as much information as we
  66    can on this single line: target name, process number, current
  67    function, current line, current PC, SingleKey mode.  */
  68 static char*
  69 tui_make_status_line (struct tui_locator_element* loc)
  70 {
  71   char* string;
  72   char line_buf[50], *pname;
  73   char* buf;
  74   int status_size;
  75   int i, proc_width;
  76   const char* pid_name;
  77   const char* pc_buf;
  78   int target_width;
  79   int pid_width;
  80   int line_width;
  81   int pc_width;
  82   struct ui_file *pc_out;
  83
  84   if (ptid_equal (inferior_ptid, null_ptid))
  85     pid_name = "No process";
  86   else
  87     pid_name = target_pid_to_str (inferior_ptid);
  88
  89   target_width = strlen (target_shortname);
  90   if (target_width > MAX_TARGET_WIDTH)
  91     target_width = MAX_TARGET_WIDTH;
  92
  93   pid_width = strlen (pid_name);
  94   if (pid_width > MAX_PID_WIDTH)
  95     pid_width = MAX_PID_WIDTH;
  96
  97   status_size = tui_term_width ();
  98   string = (char *) xmalloc (status_size + 1);
  99   buf = (char*) alloca (status_size + 1);
 100
 101   /* Translate line number and obtain its size.  */
 102   if (loc->line_no > 0)
 103     sprintf (line_buf, "%d", loc->line_no);
 104   else
 105     strcpy (line_buf, "??");
 106   line_width = strlen (line_buf);
 107   if (line_width < MIN_LINE_WIDTH)
 108     line_width = MIN_LINE_WIDTH;
 109
 110   /* Translate PC address.  */
 111   pc_out = tui_sfileopen (128);
 112   print_address_numeric (loc->addr, 1, pc_out);
 113   pc_buf = tui_file_get_strbuf (pc_out);
 114   pc_width = strlen (pc_buf);
 115
 116   /* First determine the amount of proc name width we have available.
 117      The +1 are for a space separator between fields.
 118      The -1 are to take into account the \0 counted by sizeof.  */
 119   proc_width = (status_size
 120                 - (target_width + 1)
 121                 - (pid_width + 1)
 122                 - (sizeof (PROC_PREFIX) - 1 + 1)
 123                 - (sizeof (LINE_PREFIX) - 1 + line_width + 1)
 124                 - (sizeof (PC_PREFIX) - 1 + pc_width + 1)
 125                 - (tui_current_key_mode == TUI_SINGLE_KEY_MODE
 126                    ? (sizeof (SINGLE_KEY) - 1 + 1)
 127                    : 0));
 128
 129   /* If there is no room to print the function name, try by removing
 130      some fields.  */
 131   if (proc_width < MIN_PROC_WIDTH)
 132     {
 133       proc_width += target_width + 1;
 134       target_width = 0;
 135       if (proc_width < MIN_PROC_WIDTH)
 136         {
 137           proc_width += pid_width + 1;
 138           pid_width = 0;
 139           if (proc_width <= MIN_PROC_WIDTH)
 140             {
 141               proc_width += pc_width + sizeof (PC_PREFIX) - 1 + 1;
 142               pc_width = 0;
 143               if (proc_width < 0)
 144                 {
 145                   proc_width += line_width + sizeof (LINE_PREFIX) - 1 + 1;
 146                   line_width = 0;
 147                   if (proc_width < 0)
 148                     proc_width = 0;
 149                 }
 150             }
 151         }
 152     }
 153
 154   /* Now convert elements to string form */
 155   pname = loc->proc_name;
 156
 157   /* Now create the locator line from the string version
 158      of the elements.  We could use sprintf() here but
 159      that wouldn't ensure that we don't overrun the size
 160      of the allocated buffer.  strcat_to_buf() will.  */
 161   *string = (char) 0;
 162
 163   if (target_width > 0)
 164     {
 165       sprintf (buf, "%*.*s ",
 166                -target_width, target_width, target_shortname);
 167       strcat_to_buf (string, status_size, buf);
 168     }
 169   if (pid_width > 0)
 170     {
 171       sprintf (buf, "%*.*s ",
 172                -pid_width, pid_width, pid_name);
 173       strcat_to_buf (string, status_size, buf);
 174     }
 175
 176   /* Show whether we are in SingleKey mode.  */
 177   if (tui_current_key_mode == TUI_SINGLE_KEY_MODE)
 178     {
 179       strcat_to_buf (string, status_size, SINGLE_KEY);
 180       strcat_to_buf (string, status_size, " ");
 181     }
 182
 183   /* procedure/class name */
 184   if (proc_width > 0)
 185     {
 186       if (strlen (pname) > proc_width)
 187         sprintf (buf, "%s%*.*s* ", PROC_PREFIX,
 188                  1 - proc_width, proc_width - 1, pname);
 189       else
 190         sprintf (buf, "%s%*.*s ", PROC_PREFIX,
 191                  -proc_width, proc_width, pname);
 192       strcat_to_buf (string, status_size, buf);
 193     }
 194
 195   if (line_width > 0)
 196     {
 197       sprintf (buf, "%s%*.*s ", LINE_PREFIX,
 198                -line_width, line_width, line_buf);
 199       strcat_to_buf (string, status_size, buf);
 200     }
 201   if (pc_width > 0)
 202     {
 203       strcat_to_buf (string, status_size, PC_PREFIX);
 204       strcat_to_buf (string, status_size, pc_buf);
 205     }
 206
 207
 208   for (i = strlen (string); i < status_size; i++)
 209     string[i] = ' ';
 210   string[status_size] = (char) 0;
 211
 212   ui_file_delete (pc_out);
 213   return string;
 214 }
 215
 216 /* Get a printable name for the function at the address.
 217    The symbol name is demangled if demangling is turned on.
 218    Returns a pointer to a static area holding the result.  */
 219 static char*
 220 tui_get_function_from_frame (struct frame_info *fi)
 221 {
 222   static char name[256];
 223   struct ui_file *stream = tui_sfileopen (256);
 224   char *p;
 225
 226   print_address_symbolic (get_frame_pc (fi), stream, demangle, "");
 227   p = tui_file_get_strbuf (stream);
 228
 229   /* Use simple heuristics to isolate the function name.  The symbol can
 230      be demangled and we can have function parameters.  Remove them because
 231      the status line is too short to display them.  */
 232   if (*p == '<')
 233     p++;
 234   strncpy (name, p, sizeof (name));
 235   p = strchr (name, '(');
 236   if (!p)
 237     p = strchr (name, '>');
 238   if (p)
 239     *p = 0;
 240   p = strchr (name, '+');
 241   if (p)
 242     *p = 0;
 243   ui_file_delete (stream);
 244   return name;
 245 }
 246
 247 void
 248 tui_show_locator_content (void)
 249 {
 250   char *string;
 251   struct tui_gen_win_info * locator;
 252
 253   locator = tui_locator_win_info_ptr ();
 254
 255   if (locator != NULL && locator->handle != (WINDOW *) NULL)
 256     {
 257       struct tui_win_element * element;
 258
 259       element = (struct tui_win_element *) locator->content[0];
 260
 261       string = tui_make_status_line (&element->which_element.locator);
 262       wmove (locator->handle, 0, 0);
 263       wstandout (locator->handle);
 264       waddstr (locator->handle, string);
 265       wclrtoeol (locator->handle);
 266       wstandend (locator->handle);
 267       tui_refresh_win (locator);
 268       wmove (locator->handle, 0, 0);
 269       xfree (string);
 270       locator->content_in_use = TRUE;
 271     }
 272 }
 273
 274
 275 /* Set the filename portion of the locator.  */
 276 static void
 277 tui_set_locator_filename (const char *filename)
 278 {
 279   struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
 280   struct tui_locator_element * element;
 281
 282   if (locator->content[0] == NULL)
 283     {
 284       tui_set_locator_info (filename, NULL, 0, 0);
 285       return;
 286     }
 287
 288   element = &((struct tui_win_element *) locator->content[0])->which_element.locator;
 289   element->file_name[0] = 0;
 290   strcat_to_buf (element->file_name, MAX_LOCATOR_ELEMENT_LEN, filename);
 291 }
 292
 293 /* Update the locator, with the provided arguments.  */
 294 static void
 295 tui_set_locator_info (const char *filename, const char *procname, int lineno,
 296                       CORE_ADDR addr)
 297 {
 298   struct tui_gen_win_info * locator = tui_locator_win_info_ptr ();
 299   struct tui_locator_element * element;
 300
 301   /* Allocate the locator content if necessary.  */
 302   if (locator->content_size <= 0)
 303     {
 304       locator->content = (void **) tui_alloc_content (1, locator->type);
 305       locator->content_size = 1;
 306     }
 307
 308   element = &((struct tui_win_element *) locator->content[0])->which_element.locator;
 309   element->proc_name[0] = (char) 0;
 310   strcat_to_buf (element->proc_name, MAX_LOCATOR_ELEMENT_LEN, procname);
 311   element->line_no = lineno;
 312   element->addr = addr;
 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 (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 = (struct tui_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) NULL) == 0)
 366                 error ("No function contains program counter for selected frame.\n");
 367               else
 368                 low = tui_get_low_disassembly_address (low, get_frame_pc (fi));
 369             }
 370
 371           if (win_info == TUI_SRC_WIN)
 372             {
 373               union tui_line_or_address l;
 374               l.line_no = start_line;
 375               if (!(source_already_displayed
 376                     && tui_line_is_displayed (item->locator.line_no, win_info, TRUE)))
 377                 tui_update_source_window (win_info, sal.symtab, l, TRUE);
 378               else
 379                 {
 380                   l.line_no = item->locator.line_no;
 381                   tui_set_is_exec_point_at (l, win_info);
 382                 }
 383             }
 384           else
 385             {
 386               if (win_info == TUI_DISASM_WIN)
 387                 {
 388                   union tui_line_or_address a;
 389                   a.addr = low;
 390                   if (!tui_addr_is_displayed (item->locator.addr, win_info, TRUE))
 391                     tui_update_source_window (win_info, sal.symtab, a, TRUE);
 392                   else
 393                     {
 394                       a.addr = item->locator.addr;
 395                       tui_set_is_exec_point_at (a, win_info);
 396                     }
 397                 }
 398             }
 399           tui_update_exec_info (win_info);
 400         }
 401     }
 402   else
 403     {
 404       tui_set_locator_info (NULL, NULL, 0, (CORE_ADDR) 0);
 405       tui_show_locator_content ();
 406       for (i = 0; i < (tui_source_windows ())->count; i++)
 407         {
 408           win_info = (struct tui_win_info *) (tui_source_windows ())->list[i];
 409           tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
 410           tui_update_exec_info (win_info);
 411         }
 412     }
 413 }
 414
 415 /* Function to initialize gdb commands, for tui window stack
 416    manipulation.  */
 417 void
 418 _initialize_tui_stack (void)
 419 {
 420   add_com ("update", class_tui, tui_update_command,
 421            "Update the source window and locator to display the current "
 422            "execution point.\n");
 423 }
 424
 425 /* Command to update the display with the current execution point.  */
 426 static void
 427 tui_update_command (char *arg, int from_tty)
 428 {
 429   char cmd[sizeof("frame 0")];
 430
 431   strcpy (cmd, "frame 0");
 432   execute_command (cmd, from_tty);
 433 }