gdb/tui/tuiStack.c

   1 /* TUI display locator.
   2
   3    Copyright 1998, 1999, 2000, 2001, 2002 Free Software Foundation,
   4    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 /* FIXME: cagney/2002-02-28: The GDB coding standard indicates that
  26    "defs.h" should be included first.  Unfortunatly some systems
  27    (currently Debian GNU/Linux) include the <stdbool.h> via <curses.h>
  28    and they clash with "bfd.h"'s definiton of true/false.  The correct
  29    fix is to remove true/false from "bfd.h", however, until that
  30    happens, hack around it by including "config.h" and <curses.h>
  31    first.  */
  32
  33 #include "config.h"
  34 #ifdef HAVE_NCURSES_H
  35 #include <ncurses.h>
  36 #else
  37 #ifdef HAVE_CURSES_H
  38 #include <curses.h>
  39 #endif
  40 #endif
  41
  42 #include "defs.h"
  43 #include "symtab.h"
  44 #include "breakpoint.h"
  45 #include "frame.h"
  46 #include "command.h"
  47 #include "inferior.h"
  48 #include "target.h"
  49 #include "top.h"
  50
  51 #include "tui.h"
  52 #include "tuiData.h"
  53 #include "tuiStack.h"
  54 #include "tuiGeneralWin.h"
  55 #include "tuiSource.h"
  56 #include "tuiSourceWin.h"
  57 #include "tui-file.h"
  58
  59
  60 /* Get a printable name for the function at the address.
  61    The symbol name is demangled if demangling is turned on.
  62    Returns a pointer to a static area holding the result.  */
  63 static char* tui_get_function_from_frame (struct frame_info *fi);
  64
  65 /* Set the filename portion of the locator.  */
  66 static void tui_set_locator_filename (const char *filename);
  67
  68 /* Update the locator, with the provided arguments.  */
  69 static void tui_set_locator_info (const char *filename, const char *procname,
  70                                   int lineno, CORE_ADDR addr);
  71
  72 static void tui_update_command (char *, int);
  73 \f
  74
  75 /* Create the status line to display as much information as we
  76    can on this single line: target name, process number, current
  77    function, current line, current PC, SingleKey mode.  */
  78 static char*
  79 tui_make_status_line (TuiLocatorElement* loc)
  80 {
  81   char* string;
  82   char line_buf[50], buf[50], *pname;
  83   int status_size = termWidth ();
  84   int i, proc_width;
  85   const char* pid_name;
  86   const char* pc_buf;
  87   int target_width;
  88   int pid_width;
  89   int line_width;
  90   int pc_width;
  91   struct ui_file *pc_out;
  92
  93   if (ptid_equal (inferior_ptid, null_ptid))
  94     pid_name = "No process";
  95   else
  96     pid_name = target_pid_to_str (inferior_ptid);
  97
  98   target_width = strlen (target_shortname);
  99   if (target_width > MAX_TARGET_WIDTH)
 100     target_width = MAX_TARGET_WIDTH;
 101
 102   pid_width = strlen (pid_name);
 103   if (pid_width > MAX_PID_WIDTH)
 104     pid_width = MAX_PID_WIDTH;
 105
 106   string = (char *) xmalloc (status_size + 1);
 107
 108   /* Translate line number and obtain its size.  */
 109   if (loc->lineNo > 0)
 110     sprintf (line_buf, "%d", loc->lineNo);
 111   else
 112     strcpy (line_buf, "??");
 113   line_width = strlen (line_buf);
 114   if (line_width < MIN_LINE_WIDTH)
 115     line_width = MIN_LINE_WIDTH;
 116
 117   /* Translate PC address.  */
 118   pc_out = tui_sfileopen (128);
 119   print_address_numeric (loc->addr, 1, pc_out);
 120   pc_buf = tui_file_get_strbuf (pc_out);
 121   pc_width = strlen (pc_buf);
 122
 123   /* First determine the amount of proc name width we have available.
 124      The +1 are for a space separator between fields.
 125      The -1 are to take into account the \0 counted by sizeof.  */
 126   proc_width = (status_size
 127                 - (target_width + 1)
 128                 - (pid_width + 1)
 129                 - (sizeof (PROC_PREFIX) - 1 + 1)
 130                 - (sizeof (LINE_PREFIX) - 1 + line_width + 1)
 131                 - (sizeof (PC_PREFIX) - 1 + pc_width + 1)
 132                 - (tui_current_key_mode == tui_single_key_mode
 133                    ? (sizeof (SINGLE_KEY) - 1 + 1)
 134                    : 0));
 135
 136   /* If there is no room to print the function name, try by removing
 137      some fields.  */
 138   if (proc_width < MIN_PROC_WIDTH)
 139     {
 140       proc_width += target_width + 1;
 141       target_width = 0;
 142       if (proc_width < MIN_PROC_WIDTH)
 143         {
 144           proc_width += pid_width + 1;
 145           pid_width = 0;
 146           if (proc_width <= MIN_PROC_WIDTH)
 147             {
 148               proc_width += pc_width + sizeof (PC_PREFIX) - 1 + 1;
 149               pc_width = 0;
 150               if (proc_width < 0)
 151                 {
 152                   proc_width += line_width + sizeof (LINE_PREFIX) - 1 + 1;
 153                   line_width = 0;
 154                   if (proc_width < 0)
 155                     proc_width = 0;
 156                 }
 157             }
 158         }
 159     }
 160
 161   /* Now convert elements to string form */
 162   pname = loc->procName;
 163
 164   /* Now create the locator line from the string version
 165      of the elements.  We could use sprintf() here but
 166      that wouldn't ensure that we don't overrun the size
 167      of the allocated buffer.  strcat_to_buf() will.  */
 168   *string = (char) 0;
 169
 170   if (target_width > 0)
 171     {
 172       sprintf (buf, "%*.*s ",
 173                -target_width, target_width, target_shortname);
 174       strcat_to_buf (string, status_size, buf);
 175     }
 176   if (pid_width > 0)
 177     {
 178       sprintf (buf, "%*.*s ",
 179                -pid_width, pid_width, pid_name);
 180       strcat_to_buf (string, status_size, buf);
 181     }
 182
 183   /* Show whether we are in SingleKey mode.  */
 184   if (tui_current_key_mode == tui_single_key_mode)
 185     {
 186       strcat_to_buf (string, status_size, SINGLE_KEY);
 187       strcat_to_buf (string, status_size, " ");
 188     }
 189
 190   /* procedure/class name */
 191   if (proc_width > 0)
 192     {
 193       if (strlen (pname) > proc_width)
 194         sprintf (buf, "%s%*.*s* ", PROC_PREFIX,
 195                  1 - proc_width, proc_width - 1, pname);
 196       else
 197         sprintf (buf, "%s%*.*s ", PROC_PREFIX,
 198                  -proc_width, proc_width, pname);
 199       strcat_to_buf (string, status_size, buf);
 200     }
 201
 202   if (line_width > 0)
 203     {
 204       sprintf (buf, "%s%*.*s ", LINE_PREFIX,
 205                -line_width, line_width, line_buf);
 206       strcat_to_buf (string, status_size, buf);
 207     }
 208   if (pc_width > 0)
 209     {
 210       strcat_to_buf (string, status_size, PC_PREFIX);
 211       strcat_to_buf (string, status_size, pc_buf);
 212     }
 213
 214
 215   for (i = strlen (string); i < status_size; i++)
 216     string[i] = ' ';
 217   string[status_size] = (char) 0;
 218
 219   ui_file_delete (pc_out);
 220   return string;
 221 }
 222
 223 /* Get a printable name for the function at the address.
 224    The symbol name is demangled if demangling is turned on.
 225    Returns a pointer to a static area holding the result.  */
 226 static char*
 227 tui_get_function_from_frame (struct frame_info *fi)
 228 {
 229   static char name[256];
 230   struct ui_file *stream = tui_sfileopen (256);
 231   char *p;
 232
 233   print_address_symbolic (fi->pc, stream, demangle, "");
 234   p = tui_file_get_strbuf (stream);
 235
 236   /* Use simple heuristics to isolate the function name.  The symbol can
 237      be demangled and we can have function parameters.  Remove them because
 238      the status line is too short to display them.  */
 239   if (*p == '<')
 240     p++;
 241   strncpy (name, p, sizeof (name));
 242   p = strchr (name, '(');
 243   if (!p)
 244     p = strchr (name, '>');
 245   if (p)
 246     *p = 0;
 247   p = strchr (name, '+');
 248   if (p)
 249     *p = 0;
 250   ui_file_delete (stream);
 251   return name;
 252 }
 253
 254 /*
 255    ** tuiShowLocatorContent()
 256  */
 257 void
 258 tuiShowLocatorContent (void)
 259 {
 260   char *string;
 261   TuiGenWinInfoPtr locator;
 262
 263   locator = locatorWinInfoPtr ();
 264
 265   if (m_genWinPtrNotNull (locator) && locator->handle != (WINDOW *) NULL)
 266     {
 267       TuiWinElementPtr element;
 268
 269       element = (TuiWinElementPtr) locator->content[0];
 270
 271       string = tui_make_status_line (&element->whichElement.locator);
 272       wmove (locator->handle, 0, 0);
 273       wstandout (locator->handle);
 274       waddstr (locator->handle, string);
 275       wclrtoeol (locator->handle);
 276       wstandend (locator->handle);
 277       tuiRefreshWin (locator);
 278       wmove (locator->handle, 0, 0);
 279       xfree (string);
 280       locator->contentInUse = TRUE;
 281     }
 282 }
 283
 284
 285 /* Set the filename portion of the locator.  */
 286 static void
 287 tui_set_locator_filename (const char *filename)
 288 {
 289   TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
 290   TuiLocatorElementPtr element;
 291
 292   if (locator->content[0] == (Opaque) NULL)
 293     {
 294       tui_set_locator_info (filename, NULL, 0, 0);
 295       return;
 296     }
 297
 298   element = &((TuiWinElementPtr) locator->content[0])->whichElement.locator;
 299   element->fileName[0] = 0;
 300   strcat_to_buf (element->fileName, MAX_LOCATOR_ELEMENT_LEN, filename);
 301 }
 302
 303 /* Update the locator, with the provided arguments.  */
 304 static void
 305 tui_set_locator_info (const char *filename, const char *procname, int lineno,
 306                       CORE_ADDR addr)
 307 {
 308   TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
 309   TuiLocatorElementPtr element;
 310
 311   /* Allocate the locator content if necessary.  */
 312   if (locator->contentSize <= 0)
 313     {
 314       locator->content = (OpaquePtr) allocContent (1, locator->type);
 315       locator->contentSize = 1;
 316     }
 317
 318   element = &((TuiWinElementPtr) locator->content[0])->whichElement.locator;
 319   element->procName[0] = (char) 0;
 320   strcat_to_buf (element->procName, MAX_LOCATOR_ELEMENT_LEN, procname);
 321   element->lineNo = lineno;
 322   element->addr = addr;
 323   tui_set_locator_filename (filename);
 324 }
 325
 326 /* Update only the filename portion of the locator.  */
 327 void
 328 tuiUpdateLocatorFilename (const char *filename)
 329 {
 330   tui_set_locator_filename (filename);
 331   tuiShowLocatorContent ();
 332 }
 333
 334 /* Function to print the frame information for the TUI.  */
 335 void
 336 tuiShowFrameInfo (struct frame_info *fi)
 337 {
 338   TuiWinInfoPtr winInfo;
 339   register int i;
 340
 341   if (fi)
 342     {
 343       register int startLine, i;
 344       CORE_ADDR low;
 345       TuiGenWinInfoPtr locator = locatorWinInfoPtr ();
 346       int sourceAlreadyDisplayed;
 347       struct symtab_and_line sal;
 348
 349       sal = find_pc_line (fi->pc,
 350                           (fi->next != (struct frame_info *) NULL &&
 351                            !fi->next->signal_handler_caller &&
 352                            !frame_in_dummy (fi->next)));
 353
 354       sourceAlreadyDisplayed = sal.symtab != 0
 355         && tuiSourceIsDisplayed (sal.symtab->filename);
 356       tui_set_locator_info (sal.symtab == 0 ? "??" : sal.symtab->filename,
 357                             tui_get_function_from_frame (fi),
 358                             sal.line,
 359                             fi->pc);
 360       tuiShowLocatorContent ();
 361       startLine = 0;
 362       for (i = 0; i < (sourceWindows ())->count; i++)
 363         {
 364           TuiWhichElement *item;
 365           winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[i];
 366
 367           item = &((TuiWinElementPtr) locator->content[0])->whichElement;
 368           if (winInfo == srcWin)
 369             {
 370               startLine = (item->locator.lineNo -
 371                            (winInfo->generic.viewportHeight / 2)) + 1;
 372               if (startLine <= 0)
 373                 startLine = 1;
 374             }
 375           else
 376             {
 377               if (find_pc_partial_function (fi->pc, (char **) NULL, &low, (CORE_ADDR) NULL) == 0)
 378                 error ("No function contains program counter for selected frame.\n");
 379               else
 380                 low = tuiGetLowDisassemblyAddress (low, fi->pc);
 381             }
 382
 383           if (winInfo == srcWin)
 384             {
 385               TuiLineOrAddress l;
 386               l.lineNo = startLine;
 387               if (!(sourceAlreadyDisplayed
 388                     && tuiLineIsDisplayed (item->locator.lineNo, winInfo, TRUE)))
 389                 tuiUpdateSourceWindow (winInfo, sal.symtab, l, TRUE);
 390               else
 391                 {
 392                   l.lineNo = item->locator.lineNo;
 393                   tuiSetIsExecPointAt (l, winInfo);
 394                 }
 395             }
 396           else
 397             {
 398               if (winInfo == disassemWin)
 399                 {
 400                   TuiLineOrAddress a;
 401                   a.addr = low;
 402                   if (!tuiAddrIsDisplayed (item->locator.addr, winInfo, TRUE))
 403                     tuiUpdateSourceWindow (winInfo, sal.symtab, a, TRUE);
 404                   else
 405                     {
 406                       a.addr = item->locator.addr;
 407                       tuiSetIsExecPointAt (a, winInfo);
 408                     }
 409                 }
 410             }
 411           tuiUpdateExecInfo (winInfo);
 412         }
 413     }
 414   else
 415     {
 416       tui_set_locator_info (NULL, NULL, 0, (CORE_ADDR) 0);
 417       tuiShowLocatorContent ();
 418       for (i = 0; i < (sourceWindows ())->count; i++)
 419         {
 420           winInfo = (TuiWinInfoPtr) (sourceWindows ())->list[i];
 421           tuiClearSourceContent (winInfo, EMPTY_SOURCE_PROMPT);
 422           tuiUpdateExecInfo (winInfo);
 423         }
 424     }
 425 }
 426
 427 /* Function to initialize gdb commands, for tui window stack manipulation.  */
 428 void
 429 _initialize_tuiStack (void)
 430 {
 431   add_com ("update", class_tui, tui_update_command,
 432            "Update the source window and locator to display the current "
 433            "execution point.\n");
 434 }
 435
 436 /* Command to update the display with the current execution point.  */
 437 static void
 438 tui_update_command (char *arg, int from_tty)
 439 {
 440   char cmd[sizeof("frame 0")];
 441
 442   strcpy (cmd, "frame 0");
 443   execute_command (cmd, from_tty);
 444 }