Initial import of binutils 2.22 on the new vendor branch
[dragonfly.git] / contrib / gdb-7 / 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, 2010, 2011 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) - 1);
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       /* We ignore the return value from wstandout and wstandend, casting
260          them to void in order to avoid a compiler warning.  The warning
261          itself was introduced by a patch to ncurses 5.7 dated 2009-08-29,
262          changing these macro to expand to code that causes the compiler
263          to generate an unused-value warning.  */
264       (void) wstandout (locator->handle);
265       waddstr (locator->handle, string);
266       wclrtoeol (locator->handle);
267       (void) wstandend (locator->handle);
268       tui_refresh_win (locator);
269       wmove (locator->handle, 0, 0);
270       xfree (string);
271       locator->content_in_use = TRUE;
272     }
273 }
274
275
276 /* Set the filename portion of the locator.  */
277 static void
278 tui_set_locator_filename (const char *filename)
279 {
280   struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
281   struct tui_locator_element *element;
282
283   if (locator->content[0] == NULL)
284     {
285       tui_set_locator_info (NULL, filename, NULL, 0, 0);
286       return;
287     }
288
289   element = &((struct tui_win_element *)
290               locator->content[0])->which_element.locator;
291   element->file_name[0] = 0;
292   strcat_to_buf (element->file_name, MAX_LOCATOR_ELEMENT_LEN, filename);
293 }
294
295 /* Update the locator, with the provided arguments.  */
296 static void
297 tui_set_locator_info (struct gdbarch *gdbarch,
298                       const char *filename,
299                       const char *procname, 
300                       int lineno,
301                       CORE_ADDR addr)
302 {
303   struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
304   struct tui_locator_element *element;
305
306   /* Allocate the locator content if necessary.  */
307   if (locator->content_size <= 0)
308     {
309       locator->content = (void **) tui_alloc_content (1, locator->type);
310       locator->content_size = 1;
311     }
312
313   element = &((struct tui_win_element *)
314               locator->content[0])->which_element.locator;
315   element->proc_name[0] = (char) 0;
316   strcat_to_buf (element->proc_name, MAX_LOCATOR_ELEMENT_LEN, procname);
317   element->line_no = lineno;
318   element->addr = addr;
319   element->gdbarch = gdbarch;
320   tui_set_locator_filename (filename);
321 }
322
323 /* Update only the filename portion of the locator.  */
324 void
325 tui_update_locator_filename (const char *filename)
326 {
327   tui_set_locator_filename (filename);
328   tui_show_locator_content ();
329 }
330
331 /* Function to print the frame information for the TUI.  */
332 void
333 tui_show_frame_info (struct frame_info *fi)
334 {
335   struct tui_win_info *win_info;
336   int i;
337
338   if (fi)
339     {
340       int start_line, i;
341       CORE_ADDR low;
342       struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
343       int source_already_displayed;
344       struct symtab_and_line sal;
345       CORE_ADDR pc;
346
347       find_frame_sal (fi, &sal);
348
349       source_already_displayed = sal.symtab != 0
350         && tui_source_is_displayed (sal.symtab->filename);
351
352       if (get_frame_pc_if_available (fi, &pc))
353         tui_set_locator_info (get_frame_arch (fi),
354                               sal.symtab == 0 ? "??" : sal.symtab->filename,
355                               tui_get_function_from_frame (fi),
356                               sal.line,
357                               pc);
358       else
359         tui_set_locator_info (get_frame_arch (fi),
360                               "??", _("<unavailable>"), sal.line, 0);
361
362       tui_show_locator_content ();
363       start_line = 0;
364       for (i = 0; i < (tui_source_windows ())->count; i++)
365         {
366           union tui_which_element *item;
367
368           win_info = (tui_source_windows ())->list[i];
369
370           item = &((struct tui_win_element *)
371                    locator->content[0])->which_element;
372           if (win_info == TUI_SRC_WIN)
373             {
374               start_line = (item->locator.line_no -
375                            (win_info->generic.viewport_height / 2)) + 1;
376               if (start_line <= 0)
377                 start_line = 1;
378             }
379           else
380             {
381               if (find_pc_partial_function (get_frame_pc (fi), (char **) NULL,
382                                             &low, (CORE_ADDR) 0) == 0)
383                 error (_("No function contains program "
384                          "counter for selected frame."));
385               else
386                 low = tui_get_low_disassembly_address (get_frame_arch (fi),
387                                                        low, get_frame_pc (fi));
388             }
389
390           if (win_info == TUI_SRC_WIN)
391             {
392               struct tui_line_or_address l;
393
394               l.loa = LOA_LINE;
395               l.u.line_no = start_line;
396               if (!(source_already_displayed
397                     && tui_line_is_displayed (item->locator.line_no,
398                                               win_info, TRUE)))
399                 tui_update_source_window (win_info, get_frame_arch (fi),
400                                           sal.symtab, l, TRUE);
401               else
402                 {
403                   l.u.line_no = item->locator.line_no;
404                   tui_set_is_exec_point_at (l, win_info);
405                 }
406             }
407           else
408             {
409               if (win_info == TUI_DISASM_WIN)
410                 {
411                   struct tui_line_or_address a;
412
413                   a.loa = LOA_ADDRESS;
414                   a.u.addr = low;
415                   if (!tui_addr_is_displayed (item->locator.addr,
416                                               win_info, TRUE))
417                     tui_update_source_window (win_info, get_frame_arch (fi),
418                                               sal.symtab, a, TRUE);
419                   else
420                     {
421                       a.u.addr = item->locator.addr;
422                       tui_set_is_exec_point_at (a, win_info);
423                     }
424                 }
425             }
426           tui_update_exec_info (win_info);
427         }
428     }
429   else
430     {
431       tui_set_locator_info (NULL, NULL, NULL, 0, (CORE_ADDR) 0);
432       tui_show_locator_content ();
433       for (i = 0; i < (tui_source_windows ())->count; i++)
434         {
435           win_info = (tui_source_windows ())->list[i];
436           tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
437           tui_update_exec_info (win_info);
438         }
439     }
440 }
441
442 /* Function to initialize gdb commands, for tui window stack
443    manipulation.  */
444
445 /* Provide a prototype to silence -Wmissing-prototypes.  */
446 extern initialize_file_ftype _initialize_tui_stack;
447
448 void
449 _initialize_tui_stack (void)
450 {
451   add_com ("update", class_tui, tui_update_command,
452            _("Update the source window and locator to "
453              "display the current execution point.\n"));
454 }
455
456 /* Command to update the display with the current execution point.  */
457 static void
458 tui_update_command (char *arg, int from_tty)
459 {
460   char cmd[sizeof("frame 0")];
461
462   strcpy (cmd, "frame 0");
463   execute_command (cmd, from_tty);
464 }