#include "block.h"
#include "disasm.h"
#include "dfp.h"
+#include "valprint.h"
#ifdef TUI
#include "tui/tui.h" /* For tui_active et.al. */
#endif
+#if defined(__MINGW32__)
+# define USE_PRINTF_I64 1
+# define PRINTF_HAS_LONG_LONG
+#else
+# define USE_PRINTF_I64 0
+#endif
+
extern int asm_demangle; /* Whether to demangle syms in asm printouts */
-extern int addressprint; /* Whether to print hex addresses in HLL " */
struct format_data
{
int current_display_number;
-/* Flag to low-level print routines that this value is being printed
- in an epoch window. We'd like to pass this as a parameter, but
- every routine would need to take it. Perhaps we can encapsulate
- this in the I/O stream once we have GNU stdio. */
-
-int inspect_it = 0;
-
struct display
{
/* Chain link to next auto-display item. */
return val;
}
\f
-/* Print value VAL on stream according to FORMAT, a letter or 0.
+/* Print value VAL on stream according to OPTIONS.
Do not end with a newline.
- 0 means print VAL according to its own type.
SIZE is the letter for the size of datum being printed.
This is used to pad hex numbers so they line up. SIZE is 0
for print / output and set for examine. */
static void
-print_formatted (struct value *val, int format, int size,
+print_formatted (struct value *val, int size,
+ const struct value_print_options *options,
struct ui_file *stream)
{
struct type *type = check_typedef (value_type (val));
if (size)
{
- switch (format)
+ switch (options->format)
{
case 's':
/* FIXME: Need to handle wchar_t's here... */
next_address = VALUE_ADDRESS (val)
- + val_print_string (VALUE_ADDRESS (val), -1, 1, stream);
+ + val_print_string (VALUE_ADDRESS (val), -1, 1, stream,
+ options);
return;
case 'i':
}
}
- if (format == 0 || format == 's'
+ if (options->format == 0 || options->format == 's'
+ || TYPE_CODE (type) == TYPE_CODE_REF
|| 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_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 a series of scalars. */
- value_print (val, stream, format, Val_pretty_default);
+ value_print (val, stream, options);
else
/* User specified format, so don't look to the the type to
tell us what to do. */
print_scalar_formatted (value_contents (val), type,
- format, size, stream);
+ options, size, stream);
+}
+
+/* Return builtin floating point type of same length as TYPE.
+ If no such type is found, return TYPE itself. */
+static struct type *
+float_type_from_length (struct gdbarch *gdbarch, struct type *type)
+{
+ const struct builtin_type *builtin = builtin_type (gdbarch);
+ unsigned int len = TYPE_LENGTH (type);
+
+ if (len == TYPE_LENGTH (builtin->builtin_float))
+ type = builtin->builtin_float;
+ else if (len == TYPE_LENGTH (builtin->builtin_double))
+ type = builtin->builtin_double;
+ else if (len == TYPE_LENGTH (builtin->builtin_long_double))
+ type = builtin->builtin_long_double;
+
+ return type;
}
/* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
- according to letters FORMAT and SIZE on STREAM.
- FORMAT may not be zero. Formats s and i are not supported at this level.
+ according to OPTIONS and SIZE on STREAM.
+ Formats s and i are not supported at this level.
This is how the elements of an array or structure are printed
with a format. */
void
print_scalar_formatted (const void *valaddr, struct type *type,
- int format, int size, struct ui_file *stream)
+ const struct value_print_options *options,
+ int size, struct ui_file *stream)
{
LONGEST val_long = 0;
unsigned int len = TYPE_LENGTH (type);
+ enum bfd_endian byte_order = gdbarch_byte_order (current_gdbarch);
/* If we get here with a string format, try again without it. Go
all the way back to the language printers, which may call us
again. */
- if (format == 's')
+ if (options->format == 's')
{
- val_print (type, valaddr, 0, 0, stream, 0, 0, 0, Val_pretty_default);
+ struct value_print_options opts = *options;
+ opts.format = 0;
+ opts.deref_ref = 0;
+ val_print (type, valaddr, 0, 0, stream, 0, &opts,
+ current_language);
return;
}
(TYPE_CODE (type) == TYPE_CODE_INT
|| TYPE_CODE (type) == TYPE_CODE_ENUM))
{
- switch (format)
+ switch (options->format)
{
case 'o':
- print_octal_chars (stream, valaddr, len);
+ print_octal_chars (stream, valaddr, len, byte_order);
return;
case 'u':
case 'd':
- print_decimal_chars (stream, valaddr, len);
+ print_decimal_chars (stream, valaddr, len, byte_order);
return;
case 't':
- print_binary_chars (stream, valaddr, len);
+ print_binary_chars (stream, valaddr, len, byte_order);
return;
case 'x':
- print_hex_chars (stream, valaddr, len);
+ print_hex_chars (stream, valaddr, len, byte_order);
return;
case 'c':
- print_char_chars (stream, valaddr, len);
+ print_char_chars (stream, valaddr, len, byte_order);
return;
default:
break;
};
}
- if (format != 'f')
+ if (options->format != 'f')
val_long = unpack_long (type, valaddr);
/* If the value is a pointer, and pointers and addresses are not the
/* 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
(if shorts are 16 bits) instead of 4294967295). */
- if (format != 'd')
+ if (options->format != 'd')
{
if (len < sizeof (LONGEST))
val_long &= ((LONGEST) 1 << HOST_CHAR_BIT * len) - 1;
}
- switch (format)
+ switch (options->format)
{
case 'x':
if (!size)
break;
case 'c':
- if (TYPE_UNSIGNED (type))
- {
- struct type *utype;
-
- utype = builtin_type (current_gdbarch)->builtin_true_unsigned_char;
- value_print (value_from_longest (utype, val_long),
- stream, 0, Val_pretty_default);
- }
- else
- value_print (value_from_longest (builtin_type_true_char, val_long),
- stream, 0, Val_pretty_default);
+ {
+ struct value_print_options opts = *options;
+ opts.format = 0;
+ if (TYPE_UNSIGNED (type))
+ value_print (value_from_longest (builtin_type_true_unsigned_char,
+ val_long),
+ stream, &opts);
+ else
+ value_print (value_from_longest (builtin_type_true_char, val_long),
+ stream, &opts);
+ }
break;
case 'f':
- if (len == TYPE_LENGTH (builtin_type_float))
- type = builtin_type_float;
- else if (len == TYPE_LENGTH (builtin_type_double))
- type = builtin_type_double;
- else if (len == TYPE_LENGTH (builtin_type_long_double))
- type = builtin_type_long_double;
+ type = float_type_from_length (current_gdbarch, type);
print_floating (valaddr, type, stream);
break;
break;
default:
- error (_("Undefined output format \"%c\"."), format);
+ error (_("Undefined output format \"%c\"."), options->format);
}
}
The `info lines' command uses this. */
void
-set_next_address (CORE_ADDR addr)
+set_next_address (struct gdbarch *gdbarch, CORE_ADDR addr)
{
+ struct type *ptr_type = builtin_type (gdbarch)->builtin_data_ptr;
+
next_address = addr;
/* Make address available to the user as $_. */
set_internalvar (lookup_internalvar ("_"),
- value_from_pointer (lookup_pointer_type (builtin_type_void),
- addr));
+ value_from_pointer (ptr_type, addr));
}
/* Optionally print address ADDR symbolically as <SYMBOL+OFFSET> on STREAM,
struct minimal_symbol *msymbol;
struct symbol *symbol;
CORE_ADDR name_location = 0;
- asection *section = 0;
+ struct obj_section *section = NULL;
char *name_temp = "";
/* Let's say it is unmapped. */
if (do_demangle || asm_demangle)
name_temp = SYMBOL_PRINT_NAME (symbol);
else
- name_temp = DEPRECATED_SYMBOL_NAME (symbol);
+ name_temp = SYMBOL_LINKAGE_NAME (symbol);
}
if (msymbol != NULL)
if (do_demangle || asm_demangle)
name_temp = SYMBOL_PRINT_NAME (msymbol);
else
- name_temp = DEPRECATED_SYMBOL_NAME (msymbol);
+ name_temp = SYMBOL_LINKAGE_NAME (msymbol);
}
}
if (symbol == NULL && msymbol == NULL)
return 0;
}
-/* Print address ADDR on STREAM. USE_LOCAL means the same thing as for
- print_longest. */
-void
-deprecated_print_address_numeric (CORE_ADDR addr, int use_local,
- struct ui_file *stream)
-{
- if (use_local)
- fputs_filtered (paddress (addr), stream);
- else
- {
- int addr_bit = gdbarch_addr_bit (current_gdbarch);
-
- if (addr_bit < (sizeof (CORE_ADDR) * HOST_CHAR_BIT))
- addr &= ((CORE_ADDR) 1 << addr_bit) - 1;
- print_longest (stream, 'x', 0, (ULONGEST) addr);
- }
-}
/* Print address ADDR symbolically on STREAM.
First print it as a number. Then perhaps print
void
print_address (CORE_ADDR addr, struct ui_file *stream)
{
- deprecated_print_address_numeric (addr, 1, stream);
+ fputs_filtered (paddress (addr), stream);
print_address_symbolic (addr, stream, asm_demangle, " ");
}
print_address_demangle (CORE_ADDR addr, struct ui_file *stream,
int do_demangle)
{
+ struct value_print_options opts;
+ get_user_print_options (&opts);
if (addr == 0)
{
fprintf_filtered (stream, "0");
}
- else if (addressprint)
+ else if (opts.addressprint)
{
- deprecated_print_address_numeric (addr, 1, stream);
+ fputs_filtered (paddress (addr), stream);
print_address_symbolic (addr, stream, do_demangle, " ");
}
else
struct type *val_type = NULL;
int i;
int maxelts;
+ struct value_print_options opts;
format = fmt.format;
size = fmt.size;
if (format == 's' || format == 'i')
maxelts = 1;
+ get_formatted_print_options (&opts, format);
+
/* Print as many objects as specified in COUNT, at most maxelts per line,
with the address of the next one at the start of each line. */
if (last_examine_value)
release_value (last_examine_value);
- print_formatted (last_examine_value, format, size, gdb_stdout);
+ print_formatted (last_examine_value, size, &opts, gdb_stdout);
/* Display any branch delay slots following the final insn. */
if (format == 'i' && count == 1)
struct format_data fmt;
int cleanup = 0;
- /* Pass inspect flag to the rest of the print routines in a global
- (sigh). */
- inspect_it = inspect;
-
if (exp && *exp == '/')
{
exp++;
if (voidprint || (val && value_type (val) &&
TYPE_CODE (value_type (val)) != TYPE_CODE_VOID))
{
+ struct value_print_options opts;
int histindex = record_latest_value (val);
if (histindex >= 0)
if (histindex >= 0)
annotate_value_history_value ();
- print_formatted (val, format, fmt.size, gdb_stdout);
+ get_formatted_print_options (&opts, format);
+ opts.inspect_it = inspect;
+
+ print_formatted (val, fmt.size, &opts, gdb_stdout);
printf_filtered ("\n");
if (histindex >= 0)
if (cleanup)
do_cleanups (old_chain);
- inspect_it = 0; /* Reset print routines to normal. */
}
static void
char format = 0;
struct value *val;
struct format_data fmt;
+ struct value_print_options opts;
fmt.size = 0;
annotate_value_begin (value_type (val));
- print_formatted (val, format, fmt.size, gdb_stdout);
+ get_formatted_print_options (&opts, format);
+ print_formatted (val, fmt.size, &opts, gdb_stdout);
annotate_value_end ();
struct minimal_symbol *msymbol;
struct objfile *objfile;
struct obj_section *osect;
- asection *sect;
CORE_ADDR addr, sect_addr;
int matches = 0;
unsigned int offset;
if (objfile->separate_debug_objfile_backlink)
continue;
- sect = osect->the_bfd_section;
- sect_addr = overlay_mapped_address (addr, sect);
+ sect_addr = overlay_mapped_address (addr, osect);
- if (osect->addr <= sect_addr && sect_addr < osect->endaddr &&
- (msymbol = lookup_minimal_symbol_by_pc_section (sect_addr, sect)))
+ if (obj_section_addr (osect) <= sect_addr
+ && sect_addr < obj_section_endaddr (osect)
+ && (msymbol = lookup_minimal_symbol_by_pc_section (sect_addr, osect)))
{
matches = 1;
offset = sect_addr - SYMBOL_VALUE_ADDRESS (msymbol);
else
printf_filtered ("%s in ",
SYMBOL_PRINT_NAME (msymbol));
- if (pc_in_unmapped_range (addr, sect))
+ if (pc_in_unmapped_range (addr, osect))
printf_filtered (_("load address range of "));
- if (section_is_overlay (sect))
+ if (section_is_overlay (osect))
printf_filtered (_("%s overlay "),
- section_is_mapped (sect) ? "mapped" : "unmapped");
- printf_filtered (_("section %s"), sect->name);
+ section_is_mapped (osect) ? "mapped" : "unmapped");
+ printf_filtered (_("section %s"), osect->the_bfd_section->name);
printf_filtered ("\n");
}
}
struct symbol *sym;
struct minimal_symbol *msymbol;
long val;
- long basereg;
- asection *section;
+ struct obj_section *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'. */
error (_("Argument required."));
sym = lookup_symbol (exp, get_selected_block (0), VAR_DOMAIN,
- &is_a_field_of_this, (struct symtab **) NULL);
+ &is_a_field_of_this);
if (sym == NULL)
{
if (is_a_field_of_this)
fprintf_symbol_filtered (gdb_stdout, exp,
current_language->la_language, DMGL_ANSI);
printf_filtered ("\" is at ");
- deprecated_print_address_numeric (load_addr, 1, gdb_stdout);
+ fputs_filtered (paddress (load_addr), gdb_stdout);
printf_filtered (" in a file compiled without debugging");
- section = SYMBOL_BFD_SECTION (msymbol);
+ section = SYMBOL_OBJ_SECTION (msymbol);
if (section_is_overlay (section))
{
load_addr = overlay_unmapped_address (load_addr, section);
printf_filtered (",\n -- loaded at ");
- deprecated_print_address_numeric (load_addr, 1, gdb_stdout);
- printf_filtered (" in overlay section %s", section->name);
+ fputs_filtered (paddress (load_addr), gdb_stdout);
+ printf_filtered (" in overlay section %s",
+ section->the_bfd_section->name);
}
printf_filtered (".\n");
}
}
printf_filtered ("Symbol \"");
- fprintf_symbol_filtered (gdb_stdout, DEPRECATED_SYMBOL_NAME (sym),
+ fprintf_symbol_filtered (gdb_stdout, SYMBOL_PRINT_NAME (sym),
current_language->la_language, DMGL_ANSI);
printf_filtered ("\" is ");
val = SYMBOL_VALUE (sym);
- basereg = SYMBOL_BASEREG (sym);
- section = SYMBOL_BFD_SECTION (sym);
+ section = SYMBOL_OBJ_SECTION (sym);
switch (SYMBOL_CLASS (sym))
{
case LOC_LABEL:
printf_filtered ("a label at address ");
- deprecated_print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym),
- 1, gdb_stdout);
+ fputs_filtered (paddress (load_addr = SYMBOL_VALUE_ADDRESS (sym)),
+ gdb_stdout);
if (section_is_overlay (section))
{
load_addr = overlay_unmapped_address (load_addr, section);
printf_filtered (",\n -- loaded at ");
- deprecated_print_address_numeric (load_addr, 1, gdb_stdout);
- printf_filtered (" in overlay section %s", section->name);
+ fputs_filtered (paddress (load_addr), gdb_stdout);
+ printf_filtered (" in overlay section %s",
+ section->the_bfd_section->name);
}
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
break;
case LOC_REGISTER:
- printf_filtered (_("a variable in register %s"),
+ if (SYMBOL_IS_ARGUMENT (sym))
+ printf_filtered (_("an argument in register %s"),
+ gdbarch_register_name (current_gdbarch, val));
+ else
+ printf_filtered (_("a variable in register %s"),
gdbarch_register_name (current_gdbarch, val));
break;
case LOC_STATIC:
printf_filtered (_("static storage at address "));
- deprecated_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 "));
- deprecated_print_address_numeric (load_addr, 1, gdb_stdout);
- printf_filtered (_(" in overlay section %s"), section->name);
- }
- break;
-
- case LOC_INDIRECT:
- printf_filtered (_("external global (indirect addressing), at address *("));
- deprecated_print_address_numeric (load_addr = SYMBOL_VALUE_ADDRESS (sym),
- 1, gdb_stdout);
- printf_filtered (")");
+ fputs_filtered (paddress (load_addr = SYMBOL_VALUE_ADDRESS (sym)),
+ gdb_stdout);
if (section_is_overlay (section))
{
load_addr = overlay_unmapped_address (load_addr, section);
printf_filtered (_(",\n -- loaded at "));
- deprecated_print_address_numeric (load_addr, 1, gdb_stdout);
- printf_filtered (_(" in overlay section %s"), section->name);
+ fputs_filtered (paddress (load_addr), gdb_stdout);
+ printf_filtered (_(" in overlay section %s"),
+ section->the_bfd_section->name);
}
break;
- case LOC_REGPARM:
- printf_filtered (_("an argument in register %s"),
- gdbarch_register_name (current_gdbarch, val));
- break;
-
case LOC_REGPARM_ADDR:
printf_filtered (_("address of an argument in register %s"),
gdbarch_register_name (current_gdbarch, val));
printf_filtered (_("an argument at offset %ld"), val);
break;
- case LOC_LOCAL_ARG:
- printf_filtered (_("an argument at frame offset %ld"), val);
- break;
-
case LOC_LOCAL:
printf_filtered (_("a local variable at frame offset %ld"), val);
break;
printf_filtered (_("a reference argument at offset %ld"), val);
break;
- case LOC_BASEREG:
- printf_filtered (_("a variable at offset %ld from register %s"),
- val, gdbarch_register_name (current_gdbarch, basereg));
- break;
-
- case LOC_BASEREG_ARG:
- printf_filtered (_("an argument at offset %ld from register %s"),
- val, gdbarch_register_name (current_gdbarch, basereg));
- break;
-
case LOC_TYPEDEF:
printf_filtered (_("a typedef"));
break;
case LOC_BLOCK:
printf_filtered (_("a function at address "));
load_addr = BLOCK_START (SYMBOL_BLOCK_VALUE (sym));
- deprecated_print_address_numeric (load_addr, 1, gdb_stdout);
+ fputs_filtered (paddress (load_addr), gdb_stdout);
if (section_is_overlay (section))
{
load_addr = overlay_unmapped_address (load_addr, section);
printf_filtered (_(",\n -- loaded at "));
- deprecated_print_address_numeric (load_addr, 1, gdb_stdout);
- printf_filtered (_(" in overlay section %s"), section->name);
+ fputs_filtered (paddress (load_addr), gdb_stdout);
+ printf_filtered (_(" in overlay section %s"),
+ section->the_bfd_section->name);
}
break;
{
struct minimal_symbol *msym;
- msym = lookup_minimal_symbol (DEPRECATED_SYMBOL_NAME (sym), NULL, NULL);
+ msym = lookup_minimal_symbol (SYMBOL_LINKAGE_NAME (sym), NULL, NULL);
if (msym == NULL)
printf_filtered ("unresolved");
else
{
- section = SYMBOL_BFD_SECTION (msym);
+ section = SYMBOL_OBJ_SECTION (msym);
printf_filtered (_("static storage at address "));
load_addr = SYMBOL_VALUE_ADDRESS (msym);
- deprecated_print_address_numeric (load_addr, 1, gdb_stdout);
+ fputs_filtered (paddress (load_addr), gdb_stdout);
if (section_is_overlay (section))
{
load_addr = overlay_unmapped_address (load_addr, section);
printf_filtered (_(",\n -- loaded at "));
- deprecated_print_address_numeric (load_addr, 1, gdb_stdout);
- printf_filtered (_(" in overlay section %s"), section->name);
+ fputs_filtered (paddress (load_addr), gdb_stdout);
+ printf_filtered (_(" in overlay section %s"),
+ section->the_bfd_section->name);
}
}
}
break;
- case LOC_HP_THREAD_LOCAL_STATIC:
- printf_filtered (_("\
-a thread-local variable at offset %ld from the thread base register %s"),
- val, gdbarch_register_name (current_gdbarch, basereg));
- break;
-
case LOC_OPTIMIZED_OUT:
printf_filtered (_("optimized out"));
break;
}
else
{
+ struct value_print_options opts;
+
annotate_display_format ();
if (d->format.format)
annotate_display_expression ();
+ get_formatted_print_options (&opts, d->format.format);
print_formatted (evaluate_expression (d->exp),
- d->format.format, d->format.size, gdb_stdout);
+ d->format.size, &opts, gdb_stdout);
printf_filtered ("\n");
}
struct ui_file *stream)
{
struct value *val = read_var_value (var, frame);
+ struct value_print_options opts;
- value_print (val, stream, 0, Val_pretty_default);
+ get_user_print_options (&opts);
+ value_print (val, stream, &opts);
}
static void
{
int seen_hash = 0, seen_zero = 0, lcount = 0, seen_prec = 0;
int seen_space = 0, seen_plus = 0;
- int seen_big_l = 0, seen_h = 0;
+ int seen_big_l = 0, seen_h = 0, seen_big_h = 0;
+ int seen_big_d = 0, seen_double_big_d = 0;
int bad = 0;
/* Check the validity of the format specifier, and work
seen_big_l = 1;
f++;
}
+ /* Decimal32 modifier. */
+ else if (*f == 'H')
+ {
+ seen_big_h = 1;
+ f++;
+ }
+ /* Decimal64 and Decimal128 modifiers. */
+ else if (*f == 'D')
+ {
+ f++;
+
+ /* Check for a Decimal128. */
+ if (*f == 'D')
+ {
+ f++;
+ seen_double_big_d = 1;
+ }
+ else
+ seen_big_d = 1;
+ }
switch (*f)
{
bad = 1;
break;
- /* DFP Decimal32 types. */
- case 'H':
- this_argclass = decfloat_arg;
-
-#ifndef PRINTF_HAS_DECFLOAT
- if (lcount || seen_h || seen_big_l)
- bad = 1;
- if (seen_prec || seen_zero || seen_space || seen_plus)
- bad = 1;
-#endif
- break;
-
- /* DFP Decimal64 and Decimal128 types. */
- case 'D':
- this_argclass = decfloat_arg;
-
-#ifndef PRINTF_HAS_DECFLOAT
- if (lcount || seen_h || seen_big_l)
- bad = 1;
- if (seen_prec || seen_zero || seen_space || seen_plus)
- bad = 1;
-#endif
- /* Check for a Decimal128. */
- if (*(f + 1) == 'D')
- f++;
-
- break;
-
case 'c':
this_argclass = int_arg;
if (lcount || seen_h || seen_big_l)
case 'g':
case 'E':
case 'G':
- if (seen_big_l)
+ if (seen_big_h || seen_big_d || seen_double_big_d)
+ this_argclass = decfloat_arg;
+ else if (seen_big_l)
this_argclass = long_double_arg;
else
this_argclass = double_arg;
*f);
f++;
- strncpy (current_substring, last_arg, f - last_arg);
- current_substring += f - last_arg;
+
+ if (lcount > 1 && USE_PRINTF_I64)
+ {
+ /* Windows' printf does support long long, but not the usual way.
+ Convert %lld to %I64d. */
+ int length_before_ll = f - last_arg - 1 - lcount;
+ strncpy (current_substring, last_arg, length_before_ll);
+ strcpy (current_substring + length_before_ll, "I64");
+ current_substring[length_before_ll + 3] =
+ last_arg[length_before_ll + lcount];
+ current_substring += length_before_ll + 4;
+ }
+ else
+ {
+ strncpy (current_substring, last_arg, f - last_arg);
+ current_substring += f - last_arg;
+ }
*current_substring++ = '\0';
last_arg = f;
argclass[nargs_wanted++] = this_argclass;
s1 = s;
val_args[nargs] = parse_to_comma_and_eval (&s1);
- /* If format string wants a float, unchecked-convert the value to
- floating point of the same size */
-
- if (argclass[nargs] == double_arg)
- {
- struct type *type = value_type (val_args[nargs]);
- if (TYPE_LENGTH (type) == sizeof (float))
- deprecated_set_value_type (val_args[nargs], builtin_type_float);
- if (TYPE_LENGTH (type) == sizeof (double))
- deprecated_set_value_type (val_args[nargs], builtin_type_double);
- }
nargs++;
s = s1;
if (*s == ',')
break;
case double_arg:
{
- double val = value_as_double (val_args[i]);
- printf_filtered (current_substring, val);
+ struct type *type = value_type (val_args[i]);
+ DOUBLEST val;
+ int inv;
+
+ /* If format string wants a float, unchecked-convert the value
+ to floating point of the same size. */
+ type = float_type_from_length (current_gdbarch, type);
+ val = unpack_double (type, value_contents (val_args[i]), &inv);
+ if (inv)
+ error (_("Invalid floating value found in program."));
+
+ printf_filtered (current_substring, (double) val);
break;
}
case long_double_arg:
#ifdef HAVE_LONG_DOUBLE
{
- long double val = value_as_double (val_args[i]);
- printf_filtered (current_substring, val);
+ struct type *type = value_type (val_args[i]);
+ DOUBLEST val;
+ int inv;
+
+ /* If format string wants a float, unchecked-convert the value
+ to floating point of the same size. */
+ type = float_type_from_length (current_gdbarch, type);
+ val = unpack_double (type, value_contents (val_args[i]), &inv);
+ if (inv)
+ error (_("Invalid floating value found in program."));
+
+ printf_filtered (current_substring, (long double) val);
break;
}
#else
break;
}
- /* Handles decimal floating point values. */
- case decfloat_arg:
+ /* Handles decimal floating values. */
+ case decfloat_arg:
{
- char *eos;
- char decstr[MAX_DECIMAL_STRING];
- unsigned int dfp_len = TYPE_LENGTH (value_type (val_args[i]));
- unsigned char *dfp_value_ptr = (unsigned char *) value_contents_all (val_args[i])
- + value_offset (val_args[i]);
-
+ const gdb_byte *param_ptr = value_contents (val_args[i]);
#if defined (PRINTF_HAS_DECFLOAT)
- printf_filtered (current_substring, dfp_value_ptr);
+ /* If we have native support for Decimal floating
+ printing, handle it here. */
+ printf_filtered (current_substring, param_ptr);
#else
- if (TYPE_CODE (value_type (val_args[i])) != TYPE_CODE_DECFLOAT)
- error (_("Cannot convert parameter to decfloat."));
/* As a workaround until vasprintf has native support for DFP
- we convert the DFP values to string and print them using
- the %s format specifier. */
- decimal_to_string (dfp_value_ptr, dfp_len, decstr);
+ we convert the DFP values to string and print them using
+ the %s format specifier. */
+
+ char *eos, *sos;
+ int nnull_chars = 0;
+
+ /* Parameter data. */
+ struct type *param_type = value_type (val_args[i]);
+ unsigned int param_len = TYPE_LENGTH (param_type);
+
+ /* DFP output data. */
+ struct value *dfp_value = NULL;
+ gdb_byte *dfp_ptr;
+ int dfp_len = 16;
+ gdb_byte dec[16];
+ struct type *dfp_type = NULL;
+ char decstr[MAX_DECIMAL_STRING];
/* Points to the end of the string so that we can go back
- and check for DFP format specifiers. */
+ and check for DFP length modifiers. */
eos = current_substring + strlen (current_substring);
- /* Replace %H, %D and %DD with %s's. */
- while (*--eos != '%')
- if (*eos == 'D' && *(eos - 1) == 'D')
- {
- *(eos - 1) = 's';
-
- /* If we've found a %DD format specifier we need to go
- through the whole string pulling back one character
- since this format specifier has two chars. */
- while (eos < last_arg)
- {
- *eos = *(eos + 1);
- eos++;
- }
- }
- else if (*eos == 'D' || *eos == 'H')
- *eos = 's';
+ /* Look for the float/double format specifier. */
+ while (*eos != 'f' && *eos != 'e' && *eos != 'E'
+ && *eos != 'g' && *eos != 'G')
+ eos--;
+
+ sos = eos;
+
+ /* Search for the '%' char and extract the size and type of
+ the output decimal value based on its modifiers
+ (%Hf, %Df, %DDf). */
+ while (*--sos != '%')
+ {
+ if (*sos == 'H')
+ {
+ dfp_len = 4;
+ dfp_type = builtin_type (current_gdbarch)->builtin_decfloat;
+ }
+ else if (*sos == 'D' && *(sos - 1) == 'D')
+ {
+ dfp_len = 16;
+ dfp_type = builtin_type (current_gdbarch)->builtin_declong;
+ sos--;
+ }
+ else
+ {
+ dfp_len = 8;
+ dfp_type = builtin_type (current_gdbarch)->builtin_decdouble;
+ }
+ }
+
+ /* Replace %Hf, %Df and %DDf with %s's. */
+ *++sos = 's';
+
+ /* Go through the whole format string and pull the correct
+ number of chars back to compensate for the change in the
+ format specifier. */
+ while (nnull_chars < nargs - i)
+ {
+ if (*eos == '\0')
+ nnull_chars++;
+
+ *++sos = *++eos;
+ }
+
+ /* Conversion between different DFP types. */
+ if (TYPE_CODE (param_type) == TYPE_CODE_DECFLOAT)
+ decimal_convert (param_ptr, param_len, dec, dfp_len);
+ else
+ /* If this is a non-trivial conversion, just output 0.
+ A correct converted value can be displayed by explicitly
+ casting to a DFP type. */
+ decimal_from_string (dec, dfp_len, "0");
+
+ dfp_value = value_from_decfloat (dfp_type, dec);
+
+ dfp_ptr = (gdb_byte *) value_contents (dfp_value);
+
+ decimal_to_string (dfp_ptr, dfp_len, decstr);
/* Print the DFP value. */
printf_filtered (current_substring, decstr);
+
break;
#endif
}
The argument is the function name and arguments, in the notation of the\n\
current working language. The result is printed and saved in the value\n\
history, if it is not void."));
- set_cmd_completer (c, location_completer);
+ set_cmd_completer (c, expression_completer);
add_cmd ("variable", class_vars, set_command, _("\
Evaluate expression EXP and assign result to variable VAR, using assignment\n\
\n\
EXP may be preceded with /FMT, where FMT is a format letter\n\
but no count or size letter (see \"x\" command)."));
- set_cmd_completer (c, location_completer);
+ set_cmd_completer (c, expression_completer);
add_com_alias ("p", "print", class_vars, 1);
c = add_com ("inspect", class_vars, inspect_command, _("\
Same as \"print\" command, except that if you are running in the epoch\n\
environment, the value is printed in its own window."));
- set_cmd_completer (c, location_completer);
+ set_cmd_completer (c, expression_completer);
add_setshow_uinteger_cmd ("max-symbolic-offset", no_class,
&max_symbolic_offset, _("\
projects / thirdparty / binutils-gdb.git / blobdiff