/* Print values for GNU debugger GDB.
Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
- 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 Free Software
- Foundation, Inc.
+ 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
+ Free Software Foundation, Inc.
This file is part of GDB.
#include "completer.h" /* for completion functions */
#include "ui-out.h"
#include "gdb_assert.h"
+#include "block.h"
+#include "disasm.h"
+
+#ifdef TUI
+#include "tui/tui.h" /* For tui_active et.al. */
+#endif
extern int asm_demangle; /* Whether to demangle syms in asm printouts */
extern int addressprint; /* Whether to print hex addresses in HLL " */
static CORE_ADDR next_address;
-/* Default section to examine next. */
-
-static asection *next_section;
-
/* Last address examined. */
static CORE_ADDR last_examine_address;
static void disable_display_command (char *, int);
-static void disassemble_command (char *, int);
-
static void printf_command (char *, int);
-static void print_frame_nameless_args (struct frame_info *, long,
- int, int, struct ui_file *);
-
static void display_info (char *, int);
static void do_one_display (struct display *);
static void validate_format (struct format_data, char *);
-static void do_examine (struct format_data, CORE_ADDR addr,
- asection * section);
-
static void print_formatted (struct value *, int, int, struct ui_file *);
static struct format_data decode_format (char **, int, int);
-static int print_insn (CORE_ADDR, struct ui_file *);
-
static void sym_info (char *, int);
\f
decode_format (char **string_ptr, int oformat, int osize)
{
struct format_data val;
- register char *p = *string_ptr;
+ char *p = *string_ptr;
val.format = '?';
val.size = '?';
val.size = osize ? 'h' : osize;
else
/* Bad value for TARGET_PTR_BIT */
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
break;
case 'f':
/* Floating point has to be word or giantword. */
This is used to pad hex numbers so they line up. */
static void
-print_formatted (struct value *val, register int format, int size,
+print_formatted (struct value *val, int format, int size,
struct ui_file *stream)
{
- struct type *type = check_typedef (VALUE_TYPE (val));
+ struct type *type = check_typedef (value_type (val));
int len = TYPE_LENGTH (type);
if (VALUE_LVAL (val) == lval_memory)
{
next_address = VALUE_ADDRESS (val) + len;
- next_section = VALUE_BFD_SECTION (val);
}
switch (format)
/* FIXME: Need to handle wchar_t's here... */
next_address = VALUE_ADDRESS (val)
+ val_print_string (VALUE_ADDRESS (val), -1, 1, stream);
- next_section = VALUE_BFD_SECTION (val);
break;
case 'i':
/* We often wrap here if there are long symbolic names. */
wrap_here (" ");
next_address = VALUE_ADDRESS (val)
- + print_insn (VALUE_ADDRESS (val), stream);
- next_section = VALUE_BFD_SECTION (val);
+ + gdb_print_insn (VALUE_ADDRESS (val), stream);
break;
default:
|| TYPE_CODE (type) == TYPE_CODE_ARRAY
|| TYPE_CODE (type) == TYPE_CODE_STRING
|| TYPE_CODE (type) == TYPE_CODE_STRUCT
- || TYPE_CODE (type) == TYPE_CODE_UNION)
+ || TYPE_CODE (type) == TYPE_CODE_UNION
+ || TYPE_CODE (type) == TYPE_CODE_NAMESPACE)
/* If format is 0, use the 'natural' format for
* that type of value. If the type is non-scalar,
* we have to use language rules to print it as
/* User specified format, so don't look to the
* the type to tell us what to do.
*/
- print_scalar_formatted (VALUE_CONTENTS (val), type,
+ print_scalar_formatted (value_contents (val), type,
format, size, stream);
}
}
with a format. */
void
-print_scalar_formatted (char *valaddr, struct type *type, int format, int size,
- struct ui_file *stream)
+print_scalar_formatted (const void *valaddr, struct type *type,
+ int format, int size, struct ui_file *stream)
{
- LONGEST val_long;
+ LONGEST val_long = 0;
unsigned int len = TYPE_LENGTH (type);
- if (len > sizeof (LONGEST)
- && (format == 't'
- || format == 'c'
- || format == 'o'
- || format == 'u'
- || format == 'd'
- || format == 'x'))
+ if (len > sizeof(LONGEST) &&
+ (TYPE_CODE (type) == TYPE_CODE_INT
+ || TYPE_CODE (type) == TYPE_CODE_ENUM))
{
- if (!TYPE_UNSIGNED (type)
- || !extract_long_unsigned_integer (valaddr, len, &val_long))
+ switch (format)
{
- /* We can't print it normally, but we can print it in hex.
- Printing it in the wrong radix is more useful than saying
- "use /x, you dummy". */
- /* FIXME: we could also do octal or binary if that was the
- desired format. */
- /* FIXME: we should be using the size field to give us a
- minimum field width to print. */
-
- if (format == 'o')
- print_octal_chars (stream, valaddr, len);
- else if (format == 'd')
- print_decimal_chars (stream, valaddr, len);
- else if (format == 't')
- print_binary_chars (stream, valaddr, len);
- else
- /* replace with call to print_hex_chars? Looks
- like val_print_type_code_int is redoing
- work. - edie */
-
- val_print_type_code_int (type, valaddr, stream);
-
+ case 'o':
+ print_octal_chars (stream, valaddr, len);
return;
- }
-
- /* If we get here, extract_long_unsigned_integer set val_long. */
+ case 'u':
+ case 'd':
+ print_decimal_chars (stream, valaddr, len);
+ return;
+ case 't':
+ print_binary_chars (stream, valaddr, len);
+ return;
+ case 'x':
+ print_hex_chars (stream, valaddr, len);
+ return;
+ case 'c':
+ print_char_chars (stream, valaddr, len);
+ return;
+ default:
+ break;
+ };
}
- else if (format != 'f')
+
+ if (format != 'f')
val_long = unpack_long (type, valaddr);
/* If the value is a pointer, and pointers and addresses are not the
- same, then at this point, the value's length is TARGET_ADDR_BIT, not
- TYPE_LENGTH (type). */
+ same, then at this point, the value's length (in target bytes) is
+ TARGET_ADDR_BIT/TARGET_CHAR_BIT, not TYPE_LENGTH (type). */
if (TYPE_CODE (type) == TYPE_CODE_PTR)
- len = TARGET_ADDR_BIT;
+ len = TARGET_ADDR_BIT / TARGET_CHAR_BIT;
/* If we are printing it as unsigned, truncate it in case it is actually
a negative signed value (e.g. "print/u (short)-1" should print 65535
print_longest (stream, size, 1, val_long);
break;
default:
- error ("Undefined output size \"%c\".", size);
+ error (_("Undefined output size \"%c\"."), size);
}
break;
break;
case 0:
- internal_error (__FILE__, __LINE__, "failed internal consistency check");
+ internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
case 't':
/* Binary; 't' stands for "two". */
width = 64;
break;
default:
- error ("Undefined output size \"%c\".", size);
+ error (_("Undefined output size \"%c\"."), size);
}
bits[width] = '\0';
if (*cp == '\0')
cp--;
}
- strcpy (buf, local_binary_format_prefix ());
- strcat (buf, cp);
- strcat (buf, local_binary_format_suffix ());
- fprintf_filtered (stream, buf);
+ strcpy (buf, cp);
+ fputs_filtered (buf, stream);
}
break;
default:
- error ("Undefined output format \"%c\".", format);
+ error (_("Undefined output format \"%c\"."), format);
}
}
}
}
- /* On some targets, add in extra "flag" bits to PC for
- disassembly. This should ensure that "rounding errors" in
- symbol addresses that are masked for disassembly favour the
- the correct symbol. */
-
-#ifdef GDB_TARGET_UNMASK_DISAS_PC
- addr = GDB_TARGET_UNMASK_DISAS_PC (addr);
-#endif
-
/* First try to find the address in the symbol table, then
in the minsyms. Take the closest one. */
if (symbol)
{
name_location = BLOCK_START (SYMBOL_BLOCK_VALUE (symbol));
- if (do_demangle)
- name_temp = SYMBOL_SOURCE_NAME (symbol);
+ if (do_demangle || asm_demangle)
+ name_temp = SYMBOL_PRINT_NAME (symbol);
else
- name_temp = SYMBOL_LINKAGE_NAME (symbol);
+ name_temp = DEPRECATED_SYMBOL_NAME (symbol);
}
if (msymbol != NULL)
symbol = 0;
symtab = 0;
name_location = SYMBOL_VALUE_ADDRESS (msymbol);
- if (do_demangle)
- name_temp = SYMBOL_SOURCE_NAME (msymbol);
+ if (do_demangle || asm_demangle)
+ name_temp = SYMBOL_PRINT_NAME (msymbol);
else
- name_temp = SYMBOL_LINKAGE_NAME (msymbol);
+ name_temp = DEPRECATED_SYMBOL_NAME (msymbol);
}
}
if (symbol == NULL && msymbol == NULL)
return 1;
- /* On some targets, mask out extra "flag" bits from PC for handsome
- disassembly. */
-
-#ifdef GDB_TARGET_MASK_DISAS_PC
- name_location = GDB_TARGET_MASK_DISAS_PC (name_location);
- addr = GDB_TARGET_MASK_DISAS_PC (addr);
-#endif
-
/* If the nearest symbol is too far away, don't print anything symbolic. */
/* For when CORE_ADDR is larger than unsigned int, we do math in
Fetch it from memory and print on gdb_stdout. */
static void
-do_examine (struct format_data fmt, CORE_ADDR addr, asection *sect)
+do_examine (struct format_data fmt, CORE_ADDR addr)
{
- register char format = 0;
- register char size;
- register int count = 1;
+ char format = 0;
+ char size;
+ int count = 1;
struct type *val_type = NULL;
- register int i;
- register int maxelts;
+ int i;
+ int maxelts;
format = fmt.format;
size = fmt.size;
count = fmt.count;
next_address = addr;
- next_section = sect;
/* String or instruction format implies fetch single bytes
regardless of the specified size. */
the disassembler be modified so that LAST_EXAMINE_VALUE
is left with the byte sequence from the last complete
instruction fetched from memory? */
- last_examine_value = value_at_lazy (val_type, next_address, sect);
+ last_examine_value = value_at_lazy (val_type, next_address);
if (last_examine_value)
release_value (last_examine_value);
validate_format (struct format_data fmt, char *cmdname)
{
if (fmt.size != 0)
- error ("Size letters are meaningless in \"%s\" command.", cmdname);
+ error (_("Size letters are meaningless in \"%s\" command."), cmdname);
if (fmt.count != 1)
- error ("Item count other than 1 is meaningless in \"%s\" command.",
+ error (_("Item count other than 1 is meaningless in \"%s\" command."),
cmdname);
if (fmt.format == 'i' || fmt.format == 's')
- error ("Format letter \"%c\" is meaningless in \"%s\" command.",
+ error (_("Format letter \"%c\" is meaningless in \"%s\" command."),
fmt.format, cmdname);
}
print_command_1 (char *exp, int inspect, int voidprint)
{
struct expression *expr;
- register struct cleanup *old_chain = 0;
- register char format = 0;
+ struct cleanup *old_chain = 0;
+ char format = 0;
struct value *val;
struct format_data fmt;
int cleanup = 0;
else
val = access_value_history (0);
- if (voidprint || (val && VALUE_TYPE (val) &&
- TYPE_CODE (VALUE_TYPE (val)) != TYPE_CODE_VOID))
+ if (voidprint || (val && value_type (val) &&
+ TYPE_CODE (value_type (val)) != TYPE_CODE_VOID))
{
int histindex = record_latest_value (val);
if (histindex >= 0)
- annotate_value_history_begin (histindex, VALUE_TYPE (val));
+ annotate_value_history_begin (histindex, value_type (val));
else
- annotate_value_begin (VALUE_TYPE (val));
+ annotate_value_begin (value_type (val));
if (inspect)
printf_unfiltered ("\031(gdb-makebuffer \"%s\" %d '(\"", exp, histindex);
inspect_it = 0; /* Reset print routines to normal */
}
-/* ARGSUSED */
static void
print_command (char *exp, int from_tty)
{
}
/* Same as print, except in epoch, it gets its own window */
-/* ARGSUSED */
static void
inspect_command (char *exp, int from_tty)
{
}
/* Same as print, except it doesn't print void results. */
-/* ARGSUSED */
static void
call_command (char *exp, int from_tty)
{
print_command_1 (exp, 0, 0);
}
-/* ARGSUSED */
void
output_command (char *exp, int from_tty)
{
struct expression *expr;
- register struct cleanup *old_chain;
- register char format = 0;
+ struct cleanup *old_chain;
+ char format = 0;
struct value *val;
struct format_data fmt;
val = evaluate_expression (expr);
- annotate_value_begin (VALUE_TYPE (val));
+ annotate_value_begin (value_type (val));
print_formatted (val, format, fmt.size, gdb_stdout);
do_cleanups (old_chain);
}
-/* ARGSUSED */
static void
set_command (char *exp, int from_tty)
{
struct expression *expr = parse_expression (exp);
- register struct cleanup *old_chain =
+ struct cleanup *old_chain =
make_cleanup (free_current_contents, &expr);
evaluate_expression (expr);
do_cleanups (old_chain);
}
-/* ARGSUSED */
static void
sym_info (char *arg, int from_tty)
{
unsigned int offset;
if (!arg)
- error_no_arg ("address");
+ error_no_arg (_("address"));
addr = parse_and_eval_address (arg);
ALL_OBJSECTIONS (objfile, osect)
offset = sect_addr - SYMBOL_VALUE_ADDRESS (msymbol);
if (offset)
printf_filtered ("%s + %u in ",
- SYMBOL_SOURCE_NAME (msymbol), offset);
+ SYMBOL_PRINT_NAME (msymbol), offset);
else
printf_filtered ("%s in ",
- SYMBOL_SOURCE_NAME (msymbol));
+ SYMBOL_PRINT_NAME (msymbol));
if (pc_in_unmapped_range (addr, sect))
- printf_filtered ("load address range of ");
+ printf_filtered (_("load address range of "));
if (section_is_overlay (sect))
- printf_filtered ("%s overlay ",
+ printf_filtered (_("%s overlay "),
section_is_mapped (sect) ? "mapped" : "unmapped");
- printf_filtered ("section %s", sect->name);
+ printf_filtered (_("section %s"), sect->name);
printf_filtered ("\n");
}
}
if (matches == 0)
- printf_filtered ("No symbol matches %s.\n", arg);
+ printf_filtered (_("No symbol matches %s.\n"), arg);
}
-/* ARGSUSED */
static void
address_info (char *exp, int from_tty)
{
- register struct symbol *sym;
- register struct minimal_symbol *msymbol;
- register long val;
- register long basereg;
+ struct symbol *sym;
+ struct minimal_symbol *msymbol;
+ long val;
+ long basereg;
asection *section;
CORE_ADDR load_addr;
int is_a_field_of_this; /* C++: lookup_symbol sets this to nonzero
if exp is a field of `this'. */
if (exp == 0)
- error ("Argument required.");
+ error (_("Argument required."));
- sym = lookup_symbol (exp, get_selected_block (0), VAR_NAMESPACE,
+ sym = lookup_symbol (exp, get_selected_block (0), VAR_DOMAIN,
&is_a_field_of_this, (struct symtab **) NULL);
if (sym == NULL)
{
printf_filtered ("Symbol \"");
fprintf_symbol_filtered (gdb_stdout, exp,
current_language->la_language, DMGL_ANSI);
- printf_filtered ("\" is a field of the local class variable `this'\n");
+ printf_filtered ("\" is a field of the local class variable ");
+ if (current_language->la_language == language_objc)
+ printf_filtered ("`self'\n"); /* ObjC equivalent of "this" */
+ else
+ printf_filtered ("`this'\n");
return;
}
printf_filtered (".\n");
}
else
- error ("No symbol \"%s\" in current context.", exp);
+ error (_("No symbol \"%s\" in current context."), exp);
return;
}
printf_filtered ("Symbol \"");
- fprintf_symbol_filtered (gdb_stdout, SYMBOL_NAME (sym),
+ fprintf_symbol_filtered (gdb_stdout, DEPRECATED_SYMBOL_NAME (sym),
current_language->la_language, DMGL_ANSI);
printf_filtered ("\" is ");
val = SYMBOL_VALUE (sym);
}
break;
+ case LOC_COMPUTED:
+ case LOC_COMPUTED_ARG:
+ /* FIXME: cagney/2004-01-26: It should be possible to
+ unconditionally call the SYMBOL_OPS method when available.
+ Unfortunately DWARF 2 stores the frame-base (instead of the
+ function) location in a function's symbol. Oops! For the
+ moment enable this when/where applicable. */
+ SYMBOL_OPS (sym)->describe_location (sym, gdb_stdout);
+ break;
+
case LOC_REGISTER:
- printf_filtered ("a variable in register %s", REGISTER_NAME (val));
+ printf_filtered (_("a variable in register %s"), REGISTER_NAME (val));
break;
case LOC_STATIC:
- printf_filtered ("static storage at address ");
+ printf_filtered (_("static storage at address "));
print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym),
1, gdb_stdout);
if (section_is_overlay (section))
{
load_addr = overlay_unmapped_address (load_addr, section);
- printf_filtered (",\n -- loaded at ");
+ printf_filtered (_(",\n -- loaded at "));
print_address_numeric (load_addr, 1, gdb_stdout);
- printf_filtered (" in overlay section %s", section->name);
+ printf_filtered (_(" in overlay section %s"), section->name);
}
break;
case LOC_INDIRECT:
- printf_filtered ("external global (indirect addressing), at address *(");
+ printf_filtered (_("external global (indirect addressing), at address *("));
print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym),
1, gdb_stdout);
printf_filtered (")");
if (section_is_overlay (section))
{
load_addr = overlay_unmapped_address (load_addr, section);
- printf_filtered (",\n -- loaded at ");
+ printf_filtered (_(",\n -- loaded at "));
print_address_numeric (load_addr, 1, gdb_stdout);
- printf_filtered (" in overlay section %s", section->name);
+ printf_filtered (_(" in overlay section %s"), section->name);
}
break;
case LOC_REGPARM:
- printf_filtered ("an argument in register %s", REGISTER_NAME (val));
+ printf_filtered (_("an argument in register %s"), REGISTER_NAME (val));
break;
case LOC_REGPARM_ADDR:
- printf_filtered ("address of an argument in register %s", REGISTER_NAME (val));
+ printf_filtered (_("address of an argument in register %s"), REGISTER_NAME (val));
break;
case LOC_ARG:
- printf_filtered ("an argument at offset %ld", val);
+ printf_filtered (_("an argument at offset %ld"), val);
break;
case LOC_LOCAL_ARG:
- printf_filtered ("an argument at frame offset %ld", val);
+ printf_filtered (_("an argument at frame offset %ld"), val);
break;
case LOC_LOCAL:
- printf_filtered ("a local variable at frame offset %ld", val);
+ printf_filtered (_("a local variable at frame offset %ld"), val);
break;
case LOC_REF_ARG:
- printf_filtered ("a reference argument at offset %ld", val);
+ printf_filtered (_("a reference argument at offset %ld"), val);
break;
case LOC_BASEREG:
- printf_filtered ("a variable at offset %ld from register %s",
+ printf_filtered (_("a variable at offset %ld from register %s"),
val, REGISTER_NAME (basereg));
break;
case LOC_BASEREG_ARG:
- printf_filtered ("an argument at offset %ld from register %s",
+ printf_filtered (_("an argument at offset %ld from register %s"),
val, REGISTER_NAME (basereg));
break;
case LOC_TYPEDEF:
- printf_filtered ("a typedef");
+ printf_filtered (_("a typedef"));
break;
case LOC_BLOCK:
- printf_filtered ("a function at address ");
-#ifdef GDB_TARGET_MASK_DISAS_PC
- print_address_numeric
- (load_addr = GDB_TARGET_MASK_DISAS_PC (BLOCK_START (SYMBOL_BLOCK_VALUE (sym))),
- 1, gdb_stdout);
-#else
+ printf_filtered (_("a function at address "));
print_address_numeric (load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym)),
1, gdb_stdout);
-#endif
if (section_is_overlay (section))
{
load_addr = overlay_unmapped_address (load_addr, section);
- printf_filtered (",\n -- loaded at ");
+ printf_filtered (_(",\n -- loaded at "));
print_address_numeric (load_addr, 1, gdb_stdout);
- printf_filtered (" in overlay section %s", section->name);
+ printf_filtered (_(" in overlay section %s"), section->name);
}
break;
{
struct minimal_symbol *msym;
- msym = lookup_minimal_symbol (SYMBOL_NAME (sym), NULL, NULL);
+ msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym), NULL, NULL);
if (msym == NULL)
printf_filtered ("unresolved");
else
{
section = SYMBOL_BFD_SECTION (msym);
- printf_filtered ("static storage at address ");
+ printf_filtered (_("static storage at address "));
print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (msym),
1, gdb_stdout);
if (section_is_overlay (section))
{
load_addr = overlay_unmapped_address (load_addr, section);
- printf_filtered (",\n -- loaded at ");
+ printf_filtered (_(",\n -- loaded at "));
print_address_numeric (load_addr, 1, gdb_stdout);
- printf_filtered (" in overlay section %s", section->name);
+ printf_filtered (_(" in overlay section %s"), section->name);
}
}
}
break;
- case LOC_THREAD_LOCAL_STATIC:
+ case LOC_HP_THREAD_LOCAL_STATIC:
printf_filtered (
"a thread-local variable at offset %ld from the thread base register %s",
val, REGISTER_NAME (basereg));
break;
case LOC_OPTIMIZED_OUT:
- printf_filtered ("optimized out");
+ printf_filtered (_("optimized out"));
break;
default:
- printf_filtered ("of unknown (botched) type");
+ printf_filtered (_("of unknown (botched) type"));
break;
}
printf_filtered (".\n");
*exp = 0;
old_chain = make_cleanup (free_current_contents, &expr);
val = evaluate_expression (expr);
- if (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_REF)
+ if (TYPE_CODE (value_type (val)) == TYPE_CODE_REF)
val = value_ind (val);
/* In rvalue contexts, such as this, functions are coerced into
pointers to functions. This makes "x/i main" work. */
if (/* last_format == 'i' && */
- TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_FUNC
+ TYPE_CODE (value_type (val)) == TYPE_CODE_FUNC
&& VALUE_LVAL (val) == lval_memory)
next_address = VALUE_ADDRESS (val);
else
next_address = value_as_address (val);
- if (VALUE_BFD_SECTION (val))
- next_section = VALUE_BFD_SECTION (val);
do_cleanups (old_chain);
}
- do_examine (fmt, next_address, next_section);
+ do_examine (fmt, next_address);
/* If the examine succeeds, we remember its size and format for next time. */
last_size = fmt.size;
/* Make last address examined available to the user as $_. Use
the correct pointer type. */
struct type *pointer_type
- = lookup_pointer_type (VALUE_TYPE (last_examine_value));
+ = lookup_pointer_type (value_type (last_examine_value));
set_internalvar (lookup_internalvar ("_"),
value_from_pointer (pointer_type,
last_examine_address));
/* Make contents of last address examined available to the user as $__. */
/* If the last value has not been fetched from memory then don't
fetch it now - instead mark it by voiding the $__ variable. */
- if (VALUE_LAZY (last_examine_value))
+ if (value_lazy (last_examine_value))
set_internalvar (lookup_internalvar ("__"),
allocate_value (builtin_type_void));
else
display_command (char *exp, int from_tty)
{
struct format_data fmt;
- register struct expression *expr;
- register struct display *new;
+ struct expression *expr;
+ struct display *new;
int display_it = 1;
#if defined(TUI)
- if (tui_version && *exp == '$')
- display_it = (tui_set_layout (exp) == TUI_FAILURE);
+ /* NOTE: cagney/2003-02-13 The `tui_active' was previously
+ `tui_version'. */
+ if (tui_active && exp != NULL && *exp == '$')
+ display_it = (tui_set_layout_for_display_command (exp) == TUI_FAILURE);
#endif
if (display_it)
void
clear_displays (void)
{
- register struct display *d;
+ struct display *d;
while ((d = display_chain) != NULL)
{
static void
delete_display (int num)
{
- register struct display *d1, *d;
+ struct display *d1, *d;
if (!display_chain)
- error ("No display number %d.", num);
+ error (_("No display number %d."), num);
if (display_chain->number == num)
{
for (d = display_chain;; d = d->next)
{
if (d->next == 0)
- error ("No display number %d.", num);
+ error (_("No display number %d."), num);
if (d->next->number == num)
{
d1 = d->next;
static void
undisplay_command (char *args, int from_tty)
{
- register char *p = args;
- register char *p1;
- register int num;
+ char *p = args;
+ char *p1;
+ int num;
if (args == 0)
{
while (*p1 >= '0' && *p1 <= '9')
p1++;
if (*p1 && *p1 != ' ' && *p1 != '\t')
- error ("Arguments must be display numbers.");
+ error (_("Arguments must be display numbers."));
num = atoi (p);
annotate_display_value ();
- do_examine (d->format, addr, VALUE_BFD_SECTION (val));
+ do_examine (d->format, addr);
}
else
{
void
do_displays (void)
{
- register struct display *d;
+ struct display *d;
for (d = display_chain; d; d = d->next)
do_one_display (d);
void
disable_display (int num)
{
- register struct display *d;
+ struct display *d;
for (d = display_chain; d; d = d->next)
if (d->number == num)
d->enabled_p = 0;
return;
}
- printf_unfiltered ("No display number %d.\n", num);
+ printf_unfiltered (_("No display number %d.\n"), num);
}
void
static void
display_info (char *ignore, int from_tty)
{
- register struct display *d;
+ struct display *d;
if (!display_chain)
- printf_unfiltered ("There are no auto-display expressions now.\n");
+ printf_unfiltered (_("There are no auto-display expressions now.\n"));
else
- printf_filtered ("Auto-display expressions now in effect:\n\
-Num Enb Expression\n");
+ printf_filtered (_("Auto-display expressions now in effect:\n\
+Num Enb Expression\n"));
for (d = display_chain; d; d = d->next)
{
printf_filtered ("/%c ", d->format.format);
print_expression (d->exp, gdb_stdout);
if (d->block && !contained_in (get_selected_block (0), d->block))
- printf_filtered (" (cannot be evaluated in the current context)");
+ printf_filtered (_(" (cannot be evaluated in the current context)"));
printf_filtered ("\n");
gdb_flush (gdb_stdout);
}
static void
enable_display (char *args, int from_tty)
{
- register char *p = args;
- register char *p1;
- register int num;
- register struct display *d;
+ char *p = args;
+ char *p1;
+ int num;
+ struct display *d;
if (p == 0)
{
while (*p1 >= '0' && *p1 <= '9')
p1++;
if (*p1 && *p1 != ' ' && *p1 != '\t')
- error ("Arguments must be display numbers.");
+ error (_("Arguments must be display numbers."));
num = atoi (p);
d->enabled_p = 1;
goto win;
}
- printf_unfiltered ("No display number %d.\n", num);
+ printf_unfiltered (_("No display number %d.\n"), num);
win:
p = p1;
while (*p == ' ' || *p == '\t')
}
}
-/* ARGSUSED */
static void
disable_display_command (char *args, int from_tty)
{
- register char *p = args;
- register char *p1;
- register struct display *d;
+ char *p = args;
+ char *p1;
+ struct display *d;
if (p == 0)
{
while (*p1 >= '0' && *p1 <= '9')
p1++;
if (*p1 && *p1 != ' ' && *p1 != '\t')
- error ("Arguments must be display numbers.");
+ error (_("Arguments must be display numbers."));
disable_display (atoi (p));
value_print (val, stream, 0, Val_pretty_default);
}
-/* Print the arguments of a stack frame, given the function FUNC
- running in that frame (as a symbol), the info on the frame,
- and the number of args according to the stack frame (or -1 if unknown). */
-
-/* References here and elsewhere to "number of args according to the
- stack frame" appear in all cases to refer to "number of ints of args
- according to the stack frame". At least for VAX, i386, isi. */
-
-void
-print_frame_args (struct symbol *func, struct frame_info *fi, int num,
- struct ui_file *stream)
-{
- struct block *b = NULL;
- int first = 1;
- register int i;
- register struct symbol *sym;
- struct value *val;
- /* Offset of next stack argument beyond the one we have seen that is
- at the highest offset.
- -1 if we haven't come to a stack argument yet. */
- long highest_offset = -1;
- int arg_size;
- /* Number of ints of arguments that we have printed so far. */
- int args_printed = 0;
- struct cleanup *old_chain, *list_chain;
- struct ui_stream *stb;
-
- stb = ui_out_stream_new (uiout);
- old_chain = make_cleanup_ui_out_stream_delete (stb);
-
- if (func)
- {
- b = SYMBOL_BLOCK_VALUE (func);
- /* Function blocks are order sensitive, and thus should not be
- hashed. */
- gdb_assert (BLOCK_HASHTABLE (b) == 0);
-
- ALL_BLOCK_SYMBOLS (b, i, sym)
- {
- QUIT;
-
- /* Keep track of the highest stack argument offset seen, and
- skip over any kinds of symbols we don't care about. */
-
- switch (SYMBOL_CLASS (sym))
- {
- case LOC_ARG:
- case LOC_REF_ARG:
- {
- long current_offset = SYMBOL_VALUE (sym);
- arg_size = TYPE_LENGTH (SYMBOL_TYPE (sym));
-
- /* Compute address of next argument by adding the size of
- this argument and rounding to an int boundary. */
- current_offset =
- ((current_offset + arg_size + sizeof (int) - 1)
- & ~(sizeof (int) - 1));
-
- /* If this is the highest offset seen yet, set highest_offset. */
- if (highest_offset == -1
- || (current_offset > highest_offset))
- highest_offset = current_offset;
-
- /* Add the number of ints we're about to print to args_printed. */
- args_printed += (arg_size + sizeof (int) - 1) / sizeof (int);
- }
-
- /* We care about types of symbols, but don't need to keep track of
- stack offsets in them. */
- case LOC_REGPARM:
- case LOC_REGPARM_ADDR:
- case LOC_LOCAL_ARG:
- case LOC_BASEREG_ARG:
- break;
-
- /* Other types of symbols we just skip over. */
- default:
- continue;
- }
-
- /* We have to look up the symbol because arguments can have
- two entries (one a parameter, one a local) and the one we
- want is the local, which lookup_symbol will find for us.
- This includes gcc1 (not gcc2) on the sparc when passing a
- small structure and gcc2 when the argument type is float
- and it is passed as a double and converted to float by
- the prologue (in the latter case the type of the LOC_ARG
- symbol is double and the type of the LOC_LOCAL symbol is
- float). */
- /* But if the parameter name is null, don't try it.
- Null parameter names occur on the RS/6000, for traceback tables.
- FIXME, should we even print them? */
-
- if (*SYMBOL_NAME (sym))
- {
- struct symbol *nsym;
- nsym = lookup_symbol
- (SYMBOL_NAME (sym),
- b, VAR_NAMESPACE, (int *) NULL, (struct symtab **) NULL);
- if (SYMBOL_CLASS (nsym) == LOC_REGISTER)
- {
- /* There is a LOC_ARG/LOC_REGISTER pair. This means that
- it was passed on the stack and loaded into a register,
- or passed in a register and stored in a stack slot.
- GDB 3.x used the LOC_ARG; GDB 4.0-4.11 used the LOC_REGISTER.
-
- Reasons for using the LOC_ARG:
- (1) because find_saved_registers may be slow for remote
- debugging,
- (2) because registers are often re-used and stack slots
- rarely (never?) are. Therefore using the stack slot is
- much less likely to print garbage.
-
- Reasons why we might want to use the LOC_REGISTER:
- (1) So that the backtrace prints the same value as
- "print foo". I see no compelling reason why this needs
- to be the case; having the backtrace print the value which
- was passed in, and "print foo" print the value as modified
- within the called function, makes perfect sense to me.
-
- Additional note: It might be nice if "info args" displayed
- both values.
- One more note: There is a case with sparc structure passing
- where we need to use the LOC_REGISTER, but this is dealt with
- by creating a single LOC_REGPARM in symbol reading. */
-
- /* Leave sym (the LOC_ARG) alone. */
- ;
- }
- else
- sym = nsym;
- }
-
- /* Print the current arg. */
- if (!first)
- ui_out_text (uiout, ", ");
- ui_out_wrap_hint (uiout, " ");
-
- annotate_arg_begin ();
-
- list_chain = make_cleanup_ui_out_tuple_begin_end (uiout, NULL);
- fprintf_symbol_filtered (stb->stream, SYMBOL_SOURCE_NAME (sym),
- SYMBOL_LANGUAGE (sym), DMGL_PARAMS | DMGL_ANSI);
- ui_out_field_stream (uiout, "name", stb);
- annotate_arg_name_end ();
- ui_out_text (uiout, "=");
-
- /* Avoid value_print because it will deref ref parameters. We just
- want to print their addresses. Print ??? for args whose address
- we do not know. We pass 2 as "recurse" to val_print because our
- standard indentation here is 4 spaces, and val_print indents
- 2 for each recurse. */
- val = read_var_value (sym, fi);
-
- annotate_arg_value (val == NULL ? NULL : VALUE_TYPE (val));
-
- if (val)
- {
- val_print (VALUE_TYPE (val), VALUE_CONTENTS (val), 0,
- VALUE_ADDRESS (val),
- stb->stream, 0, 0, 2, Val_no_prettyprint);
- ui_out_field_stream (uiout, "value", stb);
- }
- else
- ui_out_text (uiout, "???");
-
- /* Invoke ui_out_tuple_end. */
- do_cleanups (list_chain);
-
- annotate_arg_end ();
-
- first = 0;
- }
- }
-
- /* Don't print nameless args in situations where we don't know
- enough about the stack to find them. */
- if (num != -1)
- {
- long start;
-
- if (highest_offset == -1)
- start = FRAME_ARGS_SKIP;
- else
- start = highest_offset;
-
- print_frame_nameless_args (fi, start, num - args_printed,
- first, stream);
- }
- do_cleanups (old_chain);
-}
-
-/* Print nameless args on STREAM.
- FI is the frameinfo for this frame, START is the offset
- of the first nameless arg, and NUM is the number of nameless args to
- print. FIRST is nonzero if this is the first argument (not just
- the first nameless arg). */
-
-static void
-print_frame_nameless_args (struct frame_info *fi, long start, int num,
- int first, struct ui_file *stream)
-{
- int i;
- CORE_ADDR argsaddr;
- long arg_value;
-
- for (i = 0; i < num; i++)
- {
- QUIT;
-#ifdef NAMELESS_ARG_VALUE
- NAMELESS_ARG_VALUE (fi, start, &arg_value);
-#else
- argsaddr = FRAME_ARGS_ADDRESS (fi);
- if (!argsaddr)
- return;
-
- arg_value = read_memory_integer (argsaddr + start, sizeof (int));
-#endif
-
- if (!first)
- fprintf_filtered (stream, ", ");
-
-#ifdef PRINT_NAMELESS_INTEGER
- PRINT_NAMELESS_INTEGER (stream, arg_value);
-#else
-#ifdef PRINT_TYPELESS_INTEGER
- PRINT_TYPELESS_INTEGER (stream, builtin_type_int, (LONGEST) arg_value);
-#else
- fprintf_filtered (stream, "%ld", arg_value);
-#endif /* PRINT_TYPELESS_INTEGER */
-#endif /* PRINT_NAMELESS_INTEGER */
- first = 0;
- start += sizeof (int);
- }
-}
-\f
-/* ARGSUSED */
static void
printf_command (char *arg, int from_tty)
{
- register char *f = NULL;
- register char *s = arg;
+ char *f = NULL;
+ char *s = arg;
char *string = NULL;
struct value **val_args;
char *substrings;
old_cleanups = make_cleanup (free_current_contents, &val_args);
if (s == 0)
- error_no_arg ("format-control string and values to print");
+ error_no_arg (_("format-control string and values to print"));
/* Skip white space before format string */
while (*s == ' ' || *s == '\t')
/* A format string should follow, enveloped in double quotes */
if (*s++ != '"')
- error ("Bad format string, missing '\"'.");
+ error (_("Bad format string, missing '\"'."));
/* Parse the format-control string and copy it into the string STRING,
processing some kinds of escape sequence. */
switch (c)
{
case '\0':
- error ("Bad format string, non-terminated '\"'.");
+ error (_("Bad format string, non-terminated '\"'."));
case '\\':
switch (c = *s++)
break;
default:
/* ??? TODO: handle other escape sequences */
- error ("Unrecognized escape character \\%c in format string.",
+ error (_("Unrecognized escape character \\%c in format string."),
c);
}
break;
s++;
if (*s != ',' && *s != 0)
- error ("Invalid argument syntax");
+ error (_("Invalid argument syntax"));
if (*s == ',')
s++;
break;
case '*':
- error ("`*' not supported for precision or width in printf");
+ error (_("`*' not supported for precision or width in printf"));
case 'n':
- error ("Format specifier `n' not supported in printf");
+ error (_("Format specifier `n' not supported in printf"));
case '%':
this_argclass = no_arg;
if (argclass[nargs] == double_arg)
{
- struct type *type = VALUE_TYPE (val_args[nargs]);
+ struct type *type = value_type (val_args[nargs]);
if (TYPE_LENGTH (type) == sizeof (float))
- VALUE_TYPE (val_args[nargs]) = builtin_type_float;
+ deprecated_set_value_type (val_args[nargs], builtin_type_float);
if (TYPE_LENGTH (type) == sizeof (double))
- VALUE_TYPE (val_args[nargs]) = builtin_type_double;
+ deprecated_set_value_type (val_args[nargs], builtin_type_double);
}
nargs++;
s = s1;
}
if (nargs != nargs_wanted)
- error ("Wrong number of arguments for specified format-string");
+ error (_("Wrong number of arguments for specified format-string"));
/* Now actually print them. */
current_substring = substrings;
break;
}
#else
- error ("long long not supported in printf");
+ error (_("long long not supported in printf"));
#endif
case int_arg:
{
break;
}
default: /* purecov: deadcode */
- error ("internal error in printf_command"); /* purecov: deadcode */
+ error (_("internal error in printf_command")); /* purecov: deadcode */
}
/* Skip to the next substring. */
current_substring += strlen (current_substring) + 1;
}
/* Print the portion of the format string after the last argument. */
- printf_filtered (last_arg);
+ puts_filtered (last_arg);
}
do_cleanups (old_cleanups);
}
-\f
-/* Dump a specified section of assembly code. With no command line
- arguments, this command will dump the assembly code for the
- function surrounding the pc value in the selected frame. With one
- argument, it will dump the assembly code surrounding that pc value.
- Two arguments are interpeted as bounds within which to dump
- assembly. */
-
-/* ARGSUSED */
-static void
-disassemble_command (char *arg, int from_tty)
-{
- CORE_ADDR low, high;
- char *name;
- CORE_ADDR pc, pc_masked;
- char *space_index;
-#if 0
- asection *section;
-#endif
-
- name = NULL;
- if (!arg)
- {
- if (!selected_frame)
- error ("No frame selected.\n");
-
- pc = get_frame_pc (selected_frame);
- if (find_pc_partial_function (pc, &name, &low, &high) == 0)
- error ("No function contains program counter for selected frame.\n");
-#if defined(TUI)
- else if (tui_version)
- low = tuiGetLowDisassemblyAddress (low, pc);
-#endif
- low += FUNCTION_START_OFFSET;
- }
- else if (!(space_index = (char *) strchr (arg, ' ')))
- {
- /* One argument. */
- pc = parse_and_eval_address (arg);
- if (find_pc_partial_function (pc, &name, &low, &high) == 0)
- error ("No function contains specified address.\n");
-#if defined(TUI)
- else if (tui_version)
- low = tuiGetLowDisassemblyAddress (low, pc);
-#endif
- low += FUNCTION_START_OFFSET;
- }
- else
- {
- /* Two arguments. */
- *space_index = '\0';
- low = parse_and_eval_address (arg);
- high = parse_and_eval_address (space_index + 1);
- }
-
-#if defined(TUI)
- if (!tui_is_window_visible (DISASSEM_WIN))
-#endif
- {
- printf_filtered ("Dump of assembler code ");
- if (name != NULL)
- {
- printf_filtered ("for function %s:\n", name);
- }
- else
- {
- printf_filtered ("from ");
- print_address_numeric (low, 1, gdb_stdout);
- printf_filtered (" to ");
- print_address_numeric (high, 1, gdb_stdout);
- printf_filtered (":\n");
- }
-
- /* Dump the specified range. */
- pc = low;
-
-#ifdef GDB_TARGET_MASK_DISAS_PC
- pc_masked = GDB_TARGET_MASK_DISAS_PC (pc);
-#else
- pc_masked = pc;
-#endif
-
- while (pc_masked < high)
- {
- QUIT;
- print_address (pc_masked, gdb_stdout);
- printf_filtered (":\t");
- /* We often wrap here if there are long symbolic names. */
- wrap_here (" ");
- pc += print_insn (pc, gdb_stdout);
- printf_filtered ("\n");
-
-#ifdef GDB_TARGET_MASK_DISAS_PC
- pc_masked = GDB_TARGET_MASK_DISAS_PC (pc);
-#else
- pc_masked = pc;
-#endif
- }
- printf_filtered ("End of assembler dump.\n");
- gdb_flush (gdb_stdout);
- }
-#if defined(TUI)
- else
- {
- tui_show_assembly (low);
- }
-#endif
-}
-
-/* Print the instruction at address MEMADDR in debugged memory,
- on STREAM. Returns length of the instruction, in bytes. */
-
-static int
-print_insn (CORE_ADDR memaddr, struct ui_file *stream)
-{
- if (TARGET_BYTE_ORDER == BFD_ENDIAN_BIG)
- TARGET_PRINT_INSN_INFO->endian = BFD_ENDIAN_BIG;
- else
- TARGET_PRINT_INSN_INFO->endian = BFD_ENDIAN_LITTLE;
-
- if (TARGET_ARCHITECTURE != NULL)
- TARGET_PRINT_INSN_INFO->mach = TARGET_ARCHITECTURE->mach;
- /* else: should set .mach=0 but some disassemblers don't grok this */
-
- TARGET_PRINT_INSN_INFO->stream = stream;
-
- return TARGET_PRINT_INSN (memaddr, TARGET_PRINT_INSN_INFO);
-}
-\f
void
_initialize_printcmd (void)
Default count is 1. Default address is following last thing printed\n\
with this command or \"print\".", NULL));
- c = add_com ("disassemble", class_vars, disassemble_command,
- "Disassemble a specified section of memory.\n\
-Default is the function surrounding the pc of the selected frame.\n\
-With a single argument, the function surrounding that address is dumped.\n\
-Two arguments are taken as a range of memory to dump.");
- set_cmd_completer (c, location_completer);
- if (xdb_commands)
- add_com_alias ("va", "disassemble", class_xdb, 0);
-
#if 0
add_com ("whereis", class_vars, whereis_command,
"Print line number and file of definition of variable.");
environment, the value is printed in its own window.");
set_cmd_completer (c, location_completer);
- add_show_from_set (
- add_set_cmd ("max-symbolic-offset", no_class, var_uinteger,
- (char *) &max_symbolic_offset,
+ deprecated_add_show_from_set
+ (add_set_cmd ("max-symbolic-offset", no_class, var_uinteger,
+ (char *) &max_symbolic_offset,
"Set the largest offset that will be printed in <symbol+1234> form.",
- &setprintlist),
- &showprintlist);
- add_show_from_set (
- add_set_cmd ("symbol-filename", no_class, var_boolean,
- (char *) &print_symbol_filename,
- "Set printing of source filename and line number with <symbol>.",
- &setprintlist),
- &showprintlist);
+ &setprintlist),
+ &showprintlist);
+ deprecated_add_show_from_set
+ (add_set_cmd ("symbol-filename", no_class, var_boolean,
+ (char *) &print_symbol_filename, "\
+Set printing of source filename and line number with <symbol>.",
+ &setprintlist),
+ &showprintlist);
/* For examine/instruction a single byte quantity is specified as
the data. This avoids problems with value_at_lazy() requiring a