/* Print values for GDB, the GNU debugger.
- Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1998
+ Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
+ 1997, 1998, 1999, 2000, 2001
Free Software Foundation, Inc.
This file is part of GDB.
#include "target.h"
#include "obstack.h"
#include "language.h"
-#include "demangle.h"
#include "annotate.h"
#include "valprint.h"
+#include "floatformat.h"
#include <errno.h>
/* Prototypes for local functions */
-static void print_hex_chars PARAMS ((GDB_FILE *, unsigned char *,
- unsigned int));
+static int partial_memory_read (CORE_ADDR memaddr, char *myaddr,
+ int len, int *errnoptr);
-static void show_print PARAMS ((char *, int));
+static void print_hex_chars (struct ui_file *, unsigned char *,
+ unsigned int);
-static void set_print PARAMS ((char *, int));
+static void show_print (char *, int);
-static void set_radix PARAMS ((char *, int));
+static void set_print (char *, int);
-static void show_radix PARAMS ((char *, int));
+static void set_radix (char *, int);
-static void set_input_radix PARAMS ((char *, int, struct cmd_list_element *));
+static void show_radix (char *, int);
-static void set_input_radix_1 PARAMS ((int, unsigned));
+static void set_input_radix (char *, int, struct cmd_list_element *);
-static void set_output_radix PARAMS ((char *, int, struct cmd_list_element *));
+static void set_input_radix_1 (int, unsigned);
-static void set_output_radix_1 PARAMS ((int, unsigned));
+static void set_output_radix (char *, int, struct cmd_list_element *);
-void _initialize_valprint PARAMS ((void));
+static void set_output_radix_1 (int, unsigned);
+
+void _initialize_valprint (void);
/* Maximum number of chars to print for a string pointer value or vector
contents, or UINT_MAX for no limit. Note that "set print elements 0"
int
-val_print (type, valaddr, embedded_offset, address,
- stream, format, deref_ref, recurse, pretty)
- struct type *type;
- char *valaddr;
- int embedded_offset;
- CORE_ADDR address;
- GDB_FILE *stream;
- int format;
- int deref_ref;
- int recurse;
- enum val_prettyprint pretty;
+val_print (struct type *type, char *valaddr, int embedded_offset,
+ CORE_ADDR address, struct ui_file *stream, int format, int deref_ref,
+ int recurse, enum val_prettyprint pretty)
{
struct type *real_type = check_typedef (type);
if (pretty == Val_pretty_default)
the number of string bytes printed. */
int
-value_print (val, stream, format, pretty)
- value_ptr val;
- GDB_FILE *stream;
- int format;
- enum val_prettyprint pretty;
+value_print (value_ptr val, struct ui_file *stream, int format,
+ enum val_prettyprint pretty)
{
if (val == 0)
{
value. STREAM is where to print the value. */
void
-val_print_type_code_int (type, valaddr, stream)
- struct type *type;
- char *valaddr;
- GDB_FILE *stream;
+val_print_type_code_int (struct type *type, char *valaddr,
+ struct ui_file *stream)
{
if (TYPE_LENGTH (type) > sizeof (LONGEST))
{
*/
#if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
-static void print_decimal PARAMS ((GDB_FILE * stream, char *sign, int use_local, ULONGEST val_ulong));
+static void print_decimal (struct ui_file * stream, char *sign,
+ int use_local, ULONGEST val_ulong);
static void
-print_decimal (stream, sign, use_local, val_ulong)
- GDB_FILE *stream;
- char *sign;
- int use_local;
- ULONGEST val_ulong;
+print_decimal (struct ui_file *stream, char *sign, int use_local,
+ ULONGEST val_ulong)
{
unsigned long temp[3];
int i = 0;
sign, temp[2], temp[1], temp[0]);
break;
default:
- abort ();
+ internal_error (__FILE__, __LINE__, "failed internal consistency check");
}
return;
}
#endif
void
-print_longest (stream, format, use_local, val_long)
- GDB_FILE *stream;
- int format;
- int use_local;
- LONGEST val_long;
+print_longest (struct ui_file *stream, int format, int use_local,
+ LONGEST val_long)
{
#if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
if (sizeof (long) < sizeof (LONGEST))
fprintf_filtered (stream, local_hex_format_custom ("016ll"), val_long);
break;
default:
- abort ();
+ internal_error (__FILE__, __LINE__, "failed internal consistency check");
}
#else /* !CC_HAS_LONG_LONG || !PRINTF_HAS_LONG_LONG */
/* In the following it is important to coerce (val_long) to a long. It does
(unsigned long) val_long);
break;
default:
- abort ();
+ internal_error (__FILE__, __LINE__, "failed internal consistency check");
}
#endif /* CC_HAS_LONG_LONG || PRINTF_HAS_LONG_LONG */
}
#if 0
void
-strcat_longest (format, use_local, val_long, buf, buflen)
- int format;
- int use_local;
- LONGEST val_long;
- char *buf;
- int buflen; /* ignored, for now */
+strcat_longest (int format, int use_local, LONGEST val_long, char *buf,
+ int buflen)
{
+/* FIXME: Use buflen to avoid buffer overflow. */
#if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
long vtop, vbot;
sprintf (buf, local_hex_format_custom ("016ll"), val_long);
break;
default:
- abort ();
+ internal_error (__FILE__, __LINE__, "failed internal consistency check");
}
#else /* !PRINTF_HAS_LONG_LONG */
/* In the following it is important to coerce (val_long) to a long. It does
((long) val_long));
break;
default:
- abort ();
+ internal_error (__FILE__, __LINE__, "failed internal consistency check");
}
#endif /* !PRINTF_HAS_LONG_LONG */
where the value must not be larger than can fit in an int. */
int
-longest_to_int (arg)
- LONGEST arg;
+longest_to_int (LONGEST arg)
{
/* Let the compiler do the work */
int rtnval = (int) arg;
return (rtnval);
}
-/* Print a floating point value of type TYPE, pointed to in GDB by VALADDR,
- on STREAM. */
+/* Print a floating point value of type TYPE, pointed to in GDB by
+ VALADDR, on STREAM. */
void
-print_floating (valaddr, type, stream)
- char *valaddr;
- struct type *type;
- GDB_FILE *stream;
+print_floating (char *valaddr, struct type *type, struct ui_file *stream)
{
DOUBLEST doub;
int inv;
+ const struct floatformat *fmt = &floatformat_unknown;
unsigned len = TYPE_LENGTH (type);
-#if defined (IEEE_FLOAT)
-
- /* Check for NaN's. Note that this code does not depend on us being
- on an IEEE conforming system. It only depends on the target
- machine using IEEE representation. This means (a)
- cross-debugging works right, and (2) IEEE_FLOAT can (and should)
- be defined for systems like the 68881, which uses IEEE
- representation, but is not IEEE conforming. */
-
- {
- unsigned long low, high;
- /* Is the sign bit 0? */
- int nonnegative;
- /* Is it is a NaN (i.e. the exponent is all ones and
- the fraction is nonzero)? */
- int is_nan;
-
- /* For lint, initialize these two variables to suppress warning: */
- low = high = nonnegative = 0;
- if (len == 4)
- {
- /* It's single precision. */
- /* Assume that floating point byte order is the same as
- integer byte order. */
- low = extract_unsigned_integer (valaddr, 4);
- nonnegative = ((low & 0x80000000) == 0);
- is_nan = ((((low >> 23) & 0xFF) == 0xFF)
- && 0 != (low & 0x7FFFFF));
- low &= 0x7fffff;
- high = 0;
- }
- else if (len == 8)
- {
- /* It's double precision. Get the high and low words. */
-
- /* Assume that floating point byte order is the same as
- integer byte order. */
- if (TARGET_BYTE_ORDER == BIG_ENDIAN)
- {
- low = extract_unsigned_integer (valaddr + 4, 4);
- high = extract_unsigned_integer (valaddr, 4);
- }
- else
- {
- low = extract_unsigned_integer (valaddr, 4);
- high = extract_unsigned_integer (valaddr + 4, 4);
- }
- nonnegative = ((high & 0x80000000) == 0);
- is_nan = (((high >> 20) & 0x7ff) == 0x7ff
- && !((((high & 0xfffff) == 0)) && (low == 0)));
- high &= 0xfffff;
- }
- else
- /* Extended. We can't detect NaNs for extendeds yet. Also note
- that currently extendeds get nuked to double in
- REGISTER_CONVERTIBLE. */
- is_nan = 0;
-
- if (is_nan)
- {
- /* The meaning of the sign and fraction is not defined by IEEE.
- But the user might know what they mean. For example, they
- (in an implementation-defined manner) distinguish between
- signaling and quiet NaN's. */
- if (high)
- fprintf_filtered (stream, "-NaN(0x%lx%.8lx)" + nonnegative,
- high, low);
- else
- fprintf_filtered (stream, "-NaN(0x%lx)" + nonnegative, low);
- return;
- }
- }
-#endif /* IEEE_FLOAT. */
+ /* FIXME: kettenis/2001-01-20: The check for IEEE_FLOAT is probably
+ still necessary since GDB by default assumes that the target uses
+ the IEEE 754 representation for its floats and doubles. Of
+ course this is all crock and should be cleaned up. */
+
+ if (len == TARGET_FLOAT_BIT / TARGET_CHAR_BIT && IEEE_FLOAT)
+ fmt = TARGET_FLOAT_FORMAT;
+ else if (len == TARGET_DOUBLE_BIT / TARGET_CHAR_BIT && IEEE_FLOAT)
+ fmt = TARGET_DOUBLE_FORMAT;
+ else if (len == TARGET_LONG_DOUBLE_BIT / TARGET_CHAR_BIT)
+ fmt = TARGET_LONG_DOUBLE_FORMAT;
+
+ if (floatformat_is_nan (fmt, valaddr))
+ {
+ if (floatformat_is_negative (fmt, valaddr))
+ fprintf_filtered (stream, "-");
+ fprintf_filtered (stream, "nan(");
+ fprintf_filtered (stream, local_hex_format_prefix ());
+ fprintf_filtered (stream, floatformat_mantissa (fmt, valaddr));
+ fprintf_filtered (stream, local_hex_format_suffix ());
+ fprintf_filtered (stream, ")");
+ return;
+ }
doub = unpack_double (type, valaddr, &inv);
if (inv)
return;
}
+ /* FIXME: kettenis/2001-01-20: The following code makes too much
+ assumptions about the host and target floating point format. */
+
if (len < sizeof (double))
fprintf_filtered (stream, "%.9g", (double) doub);
else if (len == sizeof (double))
#ifdef PRINTF_HAS_LONG_DOUBLE
fprintf_filtered (stream, "%.35Lg", doub);
#else
- /* This at least wins with values that are representable as doubles */
+ /* This at least wins with values that are representable as
+ doubles. */
fprintf_filtered (stream, "%.17g", (double) doub);
#endif
}
void
-print_binary_chars (stream, valaddr, len)
- GDB_FILE *stream;
- unsigned char *valaddr;
- unsigned len;
+print_binary_chars (struct ui_file *stream, unsigned char *valaddr,
+ unsigned len)
{
#define BITS_IN_BYTES 8
unsigned char *p;
- int i;
+ unsigned int i;
int b;
/* Declared "int" so it will be signed.
* Print it in octal on stream or format it in buf.
*/
void
-print_octal_chars (stream, valaddr, len)
- GDB_FILE *stream;
- unsigned char *valaddr;
- unsigned len;
+print_octal_chars (struct ui_file *stream, unsigned char *valaddr, unsigned len)
{
unsigned char *p;
unsigned char octa1, octa2, octa3, carry;
* Print it in decimal on stream or format it in buf.
*/
void
-print_decimal_chars (stream, valaddr, len)
- GDB_FILE *stream;
- unsigned char *valaddr;
- unsigned len;
+print_decimal_chars (struct ui_file *stream, unsigned char *valaddr,
+ unsigned len)
{
#define TEN 10
#define TWO_TO_FOURTH 16
* as the base 16 number, which is 2 digits per byte.
*/
decimal_len = len * 2 * 2;
- digits = (unsigned char *) malloc (decimal_len);
- if (digits == NULL)
- error ("Can't allocate memory for conversion to decimal.");
+ digits = xmalloc (decimal_len);
for (i = 0; i < decimal_len; i++)
{
{
fprintf_filtered (stream, "%1d", digits[i]);
}
- free (digits);
+ xfree (digits);
fprintf_filtered (stream, local_decimal_format_suffix ());
}
/* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
static void
-print_hex_chars (stream, valaddr, len)
- GDB_FILE *stream;
- unsigned char *valaddr;
- unsigned len;
+print_hex_chars (struct ui_file *stream, unsigned char *valaddr, unsigned len)
{
unsigned char *p;
*/
void
-val_print_array_elements (type, valaddr, address, stream, format, deref_ref,
- recurse, pretty, i)
- struct type *type;
- char *valaddr;
- CORE_ADDR address;
- GDB_FILE *stream;
- int format;
- int deref_ref;
- int recurse;
- enum val_prettyprint pretty;
- unsigned int i;
+val_print_array_elements (struct type *type, char *valaddr, CORE_ADDR address,
+ struct ui_file *stream, int format, int deref_ref,
+ int recurse, enum val_prettyprint pretty,
+ unsigned int i)
{
unsigned int things_printed = 0;
unsigned len;
}
}
+/* Read LEN bytes of target memory at address MEMADDR, placing the
+ results in GDB's memory at MYADDR. Returns a count of the bytes
+ actually read, and optionally an errno value in the location
+ pointed to by ERRNOPTR if ERRNOPTR is non-null. */
+
+/* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
+ function be eliminated. */
+
+static int
+partial_memory_read (CORE_ADDR memaddr, char *myaddr, int len, int *errnoptr)
+{
+ int nread; /* Number of bytes actually read. */
+ int errcode; /* Error from last read. */
+
+ /* First try a complete read. */
+ errcode = target_read_memory (memaddr, myaddr, len);
+ if (errcode == 0)
+ {
+ /* Got it all. */
+ nread = len;
+ }
+ else
+ {
+ /* Loop, reading one byte at a time until we get as much as we can. */
+ for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
+ {
+ errcode = target_read_memory (memaddr++, myaddr++, 1);
+ }
+ /* If an error, the last read was unsuccessful, so adjust count. */
+ if (errcode != 0)
+ {
+ nread--;
+ }
+ }
+ if (errnoptr != NULL)
+ {
+ *errnoptr = errcode;
+ }
+ return (nread);
+}
+
/* Print a string from the inferior, starting at ADDR and printing up to LEN
characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
stops at the first null byte, otherwise printing proceeds (including null
/* FIXME: Use target_read_string. */
int
-val_print_string (addr, len, width, stream)
- CORE_ADDR addr;
- int len;
- int width;
- GDB_FILE *stream;
+val_print_string (CORE_ADDR addr, int len, int width, struct ui_file *stream)
{
int force_ellipsis = 0; /* Force ellipsis to be printed if nonzero. */
int errcode; /* Errno returned from bad reads. */
{
buffer = (char *) xmalloc (len * width);
bufptr = buffer;
- old_chain = make_cleanup (free, buffer);
+ old_chain = make_cleanup (xfree, buffer);
- nfetch = target_read_memory_partial (addr, bufptr, len * width, &errcode)
+ nfetch = partial_memory_read (addr, bufptr, len * width, &errcode)
/ width;
addr += nfetch * width;
bufptr += nfetch * width;
buffer = (char *) xrealloc (buffer, (nfetch + bufsize) * width);
}
- old_chain = make_cleanup (free, buffer);
+ old_chain = make_cleanup (xfree, buffer);
bufptr = buffer + bufsize * width;
bufsize += nfetch;
/* Read as much as we can. */
- nfetch = target_read_memory_partial (addr, bufptr, nfetch * width, &errcode)
+ nfetch = partial_memory_read (addr, bufptr, nfetch * width, &errcode)
/ width;
/* Scan this chunk for the null byte that terminates the string
/* ARGSUSED */
static void
-set_input_radix (args, from_tty, c)
- char *args;
- int from_tty;
- struct cmd_list_element *c;
+set_input_radix (char *args, int from_tty, struct cmd_list_element *c)
{
set_input_radix_1 (from_tty, *(unsigned *) c->var);
}
/* ARGSUSED */
static void
-set_input_radix_1 (from_tty, radix)
- int from_tty;
- unsigned radix;
+set_input_radix_1 (int from_tty, unsigned radix)
{
/* We don't currently disallow any input radix except 0 or 1, which don't
make any mathematical sense. In theory, we can deal with any input
/* ARGSUSED */
static void
-set_output_radix (args, from_tty, c)
- char *args;
- int from_tty;
- struct cmd_list_element *c;
+set_output_radix (char *args, int from_tty, struct cmd_list_element *c)
{
set_output_radix_1 (from_tty, *(unsigned *) c->var);
}
static void
-set_output_radix_1 (from_tty, radix)
- int from_tty;
- unsigned radix;
+set_output_radix_1 (int from_tty, unsigned radix)
{
/* Validate the radix and disallow ones that we aren't prepared to
handle correctly, leaving the radix unchanged. */
the 'set input-radix' command. */
static void
-set_radix (arg, from_tty)
- char *arg;
- int from_tty;
+set_radix (char *arg, int from_tty)
{
unsigned radix;
- radix = (arg == NULL) ? 10 : parse_and_eval_address (arg);
+ radix = (arg == NULL) ? 10 : parse_and_eval_long (arg);
set_output_radix_1 (0, radix);
set_input_radix_1 (0, radix);
if (from_tty)
/*ARGSUSED */
static void
-show_radix (arg, from_tty)
- char *arg;
- int from_tty;
+show_radix (char *arg, int from_tty)
{
if (from_tty)
{
/*ARGSUSED */
static void
-set_print (arg, from_tty)
- char *arg;
- int from_tty;
+set_print (char *arg, int from_tty)
{
printf_unfiltered (
"\"set print\" must be followed by the name of a print subcommand.\n");
/*ARGSUSED */
static void
-show_print (args, from_tty)
- char *args;
- int from_tty;
+show_print (char *args, int from_tty)
{
cmd_show_list (showprintlist, from_tty, "");
}
\f
void
-_initialize_valprint ()
+_initialize_valprint (void)
{
struct cmd_list_element *c;
projects / deliverable / binutils-gdb.git / blobdiff