OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-7.2/] [gdb/] [tui/] [tui-stack.c] - Blame information for rev 330

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 330 jeremybenn
/* TUI display locator.
2
 
3
   Copyright (C) 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2006, 2007, 2008,
4
   2009, 2010 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_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
      /* 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 *) locator->content[0])->which_element.locator;
290
  element->file_name[0] = 0;
291
  strcat_to_buf (element->file_name, MAX_LOCATOR_ELEMENT_LEN, filename);
292
}
293
 
294
/* Update the locator, with the provided arguments.  */
295
static void
296
tui_set_locator_info (struct gdbarch *gdbarch,
297
                      const char *filename,
298
                      const char *procname,
299
                      int lineno,
300
                      CORE_ADDR addr)
301
{
302
  struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
303
  struct tui_locator_element *element;
304
 
305
  /* Allocate the locator content if necessary.  */
306
  if (locator->content_size <= 0)
307
    {
308
      locator->content = (void **) tui_alloc_content (1, locator->type);
309
      locator->content_size = 1;
310
    }
311
 
312
  element = &((struct tui_win_element *) locator->content[0])->which_element.locator;
313
  element->proc_name[0] = (char) 0;
314
  strcat_to_buf (element->proc_name, MAX_LOCATOR_ELEMENT_LEN, procname);
315
  element->line_no = lineno;
316
  element->addr = addr;
317
  element->gdbarch = gdbarch;
318
  tui_set_locator_filename (filename);
319
}
320
 
321
/* Update only the filename portion of the locator.  */
322
void
323
tui_update_locator_filename (const char *filename)
324
{
325
  tui_set_locator_filename (filename);
326
  tui_show_locator_content ();
327
}
328
 
329
/* Function to print the frame information for the TUI.  */
330
void
331
tui_show_frame_info (struct frame_info *fi)
332
{
333
  struct tui_win_info *win_info;
334
  int i;
335
 
336
  if (fi)
337
    {
338
      int start_line, i;
339
      CORE_ADDR low;
340
      struct tui_gen_win_info *locator = tui_locator_win_info_ptr ();
341
      int source_already_displayed;
342
      struct symtab_and_line sal;
343
 
344
      find_frame_sal (fi, &sal);
345
 
346
      source_already_displayed = sal.symtab != 0
347
        && tui_source_is_displayed (sal.symtab->filename);
348
      tui_set_locator_info (get_frame_arch (fi),
349
                            sal.symtab == 0 ? "??" : sal.symtab->filename,
350
                            tui_get_function_from_frame (fi),
351
                            sal.line,
352
                            get_frame_pc (fi));
353
      tui_show_locator_content ();
354
      start_line = 0;
355
      for (i = 0; i < (tui_source_windows ())->count; i++)
356
        {
357
          union tui_which_element *item;
358
 
359
          win_info = (tui_source_windows ())->list[i];
360
 
361
          item = &((struct tui_win_element *) locator->content[0])->which_element;
362
          if (win_info == TUI_SRC_WIN)
363
            {
364
              start_line = (item->locator.line_no -
365
                           (win_info->generic.viewport_height / 2)) + 1;
366
              if (start_line <= 0)
367
                start_line = 1;
368
            }
369
          else
370
            {
371
              if (find_pc_partial_function (get_frame_pc (fi), (char **) NULL,
372
                                            &low, (CORE_ADDR) 0) == 0)
373
                error (_("No function contains program counter for selected frame."));
374
              else
375
                low = tui_get_low_disassembly_address (get_frame_arch (fi),
376
                                                       low, get_frame_pc (fi));
377
            }
378
 
379
          if (win_info == TUI_SRC_WIN)
380
            {
381
              struct tui_line_or_address l;
382
 
383
              l.loa = LOA_LINE;
384
              l.u.line_no = start_line;
385
              if (!(source_already_displayed
386
                    && tui_line_is_displayed (item->locator.line_no, win_info, TRUE)))
387
                tui_update_source_window (win_info, get_frame_arch (fi),
388
                                          sal.symtab, l, TRUE);
389
              else
390
                {
391
                  l.u.line_no = item->locator.line_no;
392
                  tui_set_is_exec_point_at (l, win_info);
393
                }
394
            }
395
          else
396
            {
397
              if (win_info == TUI_DISASM_WIN)
398
                {
399
                  struct tui_line_or_address a;
400
 
401
                  a.loa = LOA_ADDRESS;
402
                  a.u.addr = low;
403
                  if (!tui_addr_is_displayed (item->locator.addr, win_info, TRUE))
404
                    tui_update_source_window (win_info, get_frame_arch (fi),
405
                                              sal.symtab, a, TRUE);
406
                  else
407
                    {
408
                      a.u.addr = item->locator.addr;
409
                      tui_set_is_exec_point_at (a, win_info);
410
                    }
411
                }
412
            }
413
          tui_update_exec_info (win_info);
414
        }
415
    }
416
  else
417
    {
418
      tui_set_locator_info (NULL, NULL, NULL, 0, (CORE_ADDR) 0);
419
      tui_show_locator_content ();
420
      for (i = 0; i < (tui_source_windows ())->count; i++)
421
        {
422
          win_info = (tui_source_windows ())->list[i];
423
          tui_clear_source_content (win_info, EMPTY_SOURCE_PROMPT);
424
          tui_update_exec_info (win_info);
425
        }
426
    }
427
}
428
 
429
/* Function to initialize gdb commands, for tui window stack
430
   manipulation.  */
431
 
432
/* Provide a prototype to silence -Wmissing-prototypes.  */
433
extern initialize_file_ftype _initialize_tui_stack;
434
 
435
void
436
_initialize_tui_stack (void)
437
{
438
  add_com ("update", class_tui, tui_update_command, _("\
439
Update the source window and locator to display the current execution point.\n"));
440
}
441
 
442
/* Command to update the display with the current execution point.  */
443
static void
444
tui_update_command (char *arg, int from_tty)
445
{
446
  char cmd[sizeof("frame 0")];
447
 
448
  strcpy (cmd, "frame 0");
449
  execute_command (cmd, from_tty);
450
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.