/* Print values for GNU debugger GDB.
Copyright 1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 1994,
- 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 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.
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 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);
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. */
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':
wrap_here (" ");
next_address = VALUE_ADDRESS (val)
+ gdb_print_insn (VALUE_ADDRESS (val), stream);
- next_section = VALUE_BFD_SECTION (val);
break;
default:
/* 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 (void *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) &&
+ (TYPE_CODE (type) == TYPE_CODE_INT
+ || TYPE_CODE (type) == TYPE_CODE_ENUM))
+ {
+ switch (format)
+ {
+ case 'o':
+ print_octal_chars (stream, valaddr, len);
+ return;
+ 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;
+ };
+ }
+
if (format != 'f')
val_long = unpack_long (type, valaddr);
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 ());
+ strcpy (buf, cp);
fputs_filtered (buf, stream);
}
break;
default:
- error ("Undefined output format \"%c\".", format);
+ error (_("Undefined output format \"%c\"."), format);
}
}
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)
{
char format = 0;
char size;
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);
}
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);
val = evaluate_expression (expr);
- annotate_value_begin (VALUE_TYPE (val));
+ annotate_value_begin (value_type (val));
print_formatted (val, format, fmt.size, gdb_stdout);
unsigned int offset;
if (!arg)
- error_no_arg ("address");
+ error_no_arg (_("address"));
addr = parse_and_eval_address (arg);
ALL_OBJSECTIONS (objfile, osect)
printf_filtered ("%s in ",
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);
}
static void
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_DOMAIN,
&is_a_field_of_this, (struct symtab **) NULL);
printf_filtered (".\n");
}
else
- error ("No symbol \"%s\" in current context.", exp);
+ error (_("No symbol \"%s\" in current context."), exp);
return;
}
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 ");
+ printf_filtered (_("a function at address "));
print_address_numeric (load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (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;
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_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
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;
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
{
d->enabled_p = 0;
return;
}
- printf_unfiltered ("No display number %d.\n", num);
+ printf_unfiltered (_("No display number %d.\n"), num);
}
void
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);
}
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')
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));
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;
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