#include "obstack.h"
#include "language.h"
#include "demangle.h"
+#include "annotate.h"
#include <errno.h>
/* Prototypes for local functions */
static void
-print_hex_chars PARAMS ((FILE *, unsigned char *, unsigned int));
+print_hex_chars PARAMS ((GDB_FILE *, unsigned char *, unsigned int));
static void
show_print PARAMS ((char *, int));
static void
set_output_radix_1 PARAMS ((int, unsigned));
-static void
-value_print_array_elements PARAMS ((value, FILE *, int, enum val_prettyprint));
+static void value_print_array_elements PARAMS ((value_ptr, GDB_FILE *, int,
+ enum val_prettyprint));
/* 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"
struct type *type;
char *valaddr;
CORE_ADDR address;
- FILE *stream;
+ GDB_FILE *stream;
int format;
int deref_ref;
int recurse;
/* Ensure that the type is complete and not just a stub. If the type is
only a stub and we can't find and substitute its complete type, then
- print appropriate string and return. Typical types that my be stubs
- are structs, unions, and C++ methods. */
+ print appropriate string and return. */
check_stub_type (type);
if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
{
fprintf_filtered (stream, "<incomplete type>");
- fflush (stream);
+ gdb_flush (stream);
return (0);
}
int
value_print (val, stream, format, pretty)
- value val;
- FILE *stream;
+ value_ptr val;
+ GDB_FILE *stream;
int format;
enum val_prettyprint pretty;
{
val_print_type_code_int (type, valaddr, stream)
struct type *type;
char *valaddr;
- FILE *stream;
+ GDB_FILE *stream;
{
char *p;
/* Pointer to first (i.e. lowest address) nonzero character. */
p++)
#else /* Little endian. */
first_addr = valaddr;
- for (p = valaddr + TYPE_LENGTH (type);
+ for (p = valaddr + TYPE_LENGTH (type) - 1;
len > sizeof (LONGEST) && p >= valaddr;
p--)
#endif /* Little endian. */
#endif
if (len <= sizeof (LONGEST))
{
- /* We can print it in decimal. */
+ /* The most significant bytes are zero, so we can just get
+ the least significant sizeof (LONGEST) bytes and print it
+ in decimal. */
print_longest (stream, 'u', 0,
- unpack_long (BUILTIN_TYPE_LONGEST, first_addr));
+ extract_unsigned_integer (first_addr,
+ sizeof (LONGEST)));
}
else
{
unpack_long (type, valaddr));
#endif
}
-}
+}
/* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
The raison d'etre of this function is to consolidate printing of LONG_LONG's
printf() that supports "ll" in the format string. We handle these by seeing
if the number is actually a long, and if not we just bail out and print the
number in hex. The format chars b,h,w,g are from
- print_scalar_formatted(). USE_LOCAL says whether or not to call the
- local formatting routine to get the format. */
+ print_scalar_formatted(). If USE_LOCAL, format it according to the current
+ language (this should be used for most integers which GDB prints, the
+ exception is things like protocols where the format of the integer is
+ a protocol thing, not a user-visible thing). */
void
print_longest (stream, format, use_local, val_long)
- FILE *stream;
+ GDB_FILE *stream;
int format;
int use_local;
LONGEST val_long;
vbot = (long) val_long;
if ((format == 'd' && (val_long < INT_MIN || val_long > INT_MAX))
- || ((format == 'u' || format == 'x') && val_long > UINT_MAX))
+ || ((format == 'u' || format == 'x') && (unsigned long long)val_long > UINT_MAX))
{
- fprintf_filtered (stream, "0x%x%08x", vtop, vbot);
+ fprintf_filtered (stream, "0x%lx%08lx", vtop, vbot);
return;
}
#endif
#endif /* !PRINTF_HAS_LONG_LONG */
}
+/* This used to be a macro, but I don't think it is called often enough
+ to merit such treatment. */
+/* Convert a LONGEST to an int. This is used in contexts (e.g. number of
+ arguments to a function, number in a value history, register number, etc.)
+ where the value must not be larger than can fit in an int. */
+
+int
+longest_to_int (arg)
+ LONGEST arg;
+{
+
+ /* This check is in case a system header has botched the
+ definition of INT_MIN, like on BSDI. */
+ if (sizeof (LONGEST) <= sizeof (int))
+ return arg;
+
+ if (arg > INT_MAX || arg < INT_MIN)
+ error ("Value out of range.");
+
+ return arg;
+}
+
/* Print a floating point value of type TYPE, pointed to in GDB by VALADDR,
on STREAM. */
print_floating (valaddr, type, stream)
char *valaddr;
struct type *type;
- FILE *stream;
+ GDB_FILE *stream;
{
double doub;
int inv;
representation, but is not IEEE conforming. */
{
- long low, high;
+ 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;
- if (len == sizeof (float))
+ if (len == 4)
{
- /* It's single precision. */
- memcpy ((char *) &low, valaddr, sizeof (low));
- /* target -> host. */
- SWAP_TARGET_AND_HOST (&low, sizeof (float));
- nonnegative = low >= 0;
+ /* 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
+ 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
- memcpy (&low, valaddr+4, sizeof (low));
- memcpy (&high, valaddr+0, sizeof (high));
+ low = extract_unsigned_integer (valaddr + 4, 4);
+ high = extract_unsigned_integer (valaddr, 4);
#else
- memcpy (&low, valaddr+0, sizeof (low));
- memcpy (&high, valaddr+4, sizeof (high));
+ low = extract_unsigned_integer (valaddr, 4);
+ high = extract_unsigned_integer (valaddr + 4, 4);
#endif
- SWAP_TARGET_AND_HOST (&low, sizeof (low));
- SWAP_TARGET_AND_HOST (&high, sizeof (high));
- nonnegative = high >= 0;
+ 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)
{
static void
print_hex_chars (stream, valaddr, len)
- FILE *stream;
+ GDB_FILE *stream;
unsigned char *valaddr;
unsigned len;
{
unsigned char *p;
-
- fprintf_filtered (stream, "0x");
+
+ /* FIXME: We should be not printing leading zeroes in most cases. */
+
+ fprintf_filtered (stream, local_hex_format_prefix ());
#if TARGET_BYTE_ORDER == BIG_ENDIAN
for (p = valaddr;
p < valaddr + len;
{
fprintf_filtered (stream, "%02x", *p);
}
+ fprintf_filtered (stream, local_hex_format_suffix ());
}
/* Called by various <lang>_val_print routines to print elements of an
struct type *type;
char *valaddr;
CORE_ADDR address;
- FILE *stream;
+ GDB_FILE *stream;
int format;
int deref_ref;
int recurse;
elttype = TYPE_TARGET_TYPE (type);
eltlen = TYPE_LENGTH (elttype);
len = TYPE_LENGTH (type) / eltlen;
-
+
+ annotate_array_section_begin (i, elttype);
+
for (; i < len && things_printed < print_max; i++)
{
if (i != 0)
}
}
wrap_here (n_spaces (2 + 2 * recurse));
-
+
rep1 = i + 1;
reps = 1;
while ((rep1 < len) &&
++reps;
++rep1;
}
-
+
if (reps > repeat_count_threshold)
{
val_print (elttype, valaddr + i * eltlen, 0, stream, format,
deref_ref, recurse + 1, pretty);
+ annotate_elt_rep (reps);
fprintf_filtered (stream, " <repeats %u times>", reps);
+ annotate_elt_rep_end ();
+
i = rep1 - 1;
things_printed += repeat_count_threshold;
}
{
val_print (elttype, valaddr + i * eltlen, 0, stream, format,
deref_ref, recurse + 1, pretty);
+ annotate_elt ();
things_printed++;
}
}
+ annotate_array_section_end ();
if (i < len)
{
fprintf_filtered (stream, "...");
static void
value_print_array_elements (val, stream, format, pretty)
- value val;
- FILE *stream;
+ value_ptr val;
+ GDB_FILE *stream;
int format;
enum val_prettyprint pretty;
{
val_print (VALUE_TYPE (val), VALUE_CONTENTS (val) + typelen * i,
VALUE_ADDRESS (val) + typelen * i, stream, format, 1,
0, pretty);
- fprintf (stream, " <repeats %u times>", reps);
+ fprintf_unfiltered (stream, " <repeats %u times>", reps);
i = rep1 - 1;
things_printed += repeat_count_threshold;
}
byte, otherwise printing proceeds (including null bytes) until either
print_max or LEN characters have been printed, whichever is smaller. */
+/* FIXME: All callers supply LEN of zero. Supplying a non-zero LEN is
+ pointless, this routine just then becomes a convoluted version of
+ target_read_memory_partial. Removing all the LEN stuff would simplify
+ this routine enormously.
+
+ FIXME: Use target_read_string. */
+
int
val_print_string (addr, len, stream)
CORE_ADDR addr;
unsigned int len;
- FILE *stream;
+ GDB_FILE *stream;
{
- int first_addr_err = 0; /* Nonzero if first address out of bounds. */
int force_ellipsis = 0; /* Force ellipsis to be printed if nonzero. */
int errcode; /* Errno returned from bad reads. */
unsigned int fetchlimit; /* Maximum number of bytes to fetch. */
char *buffer = NULL; /* Dynamically growable fetch buffer. */
char *bufptr; /* Pointer to next available byte in buffer. */
char *limit; /* First location past end of fetch buffer. */
- struct cleanup *old_chain; /* Top of the old cleanup chain. */
+ struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
char peekchar; /* Place into which we can read one char. */
/* First we need to figure out the limit on the number of characters we are
are looking for a null terminator to end the fetching, so we might as
well read in blocks that are large enough to be efficient, but not so
large as to be slow if fetchlimit happens to be large. So we choose the
- minimum of DEFAULT_PRINT_MAX and fetchlimit. */
+ minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
+ 200 is way too big for remote debugging over a serial line. */
- chunksize = (len == 0 ? min (PRINT_MAX_DEFAULT, fetchlimit) : fetchlimit);
+ chunksize = (len == 0 ? min (8, fetchlimit) : fetchlimit);
/* Loop until we either have all the characters to print, or we encounter
some error, such as bumping into the end of the address space. */
after the null byte, or at the next character after the end of
the buffer. */
limit = bufptr + nfetch;
- do {
- addr++;
- bufptr++;
- } while (bufptr < limit && *(bufptr - 1) != '\0');
+ while (bufptr < limit)
+ {
+ ++addr;
+ ++bufptr;
+ if (bufptr[-1] == '\0')
+ {
+ /* We don't care about any error which happened after
+ the NULL terminator. */
+ errcode = 0;
+ break;
+ }
+ }
}
} while (errcode == 0 /* no error */
- && bufptr < buffer + fetchlimit /* no overrun */
+ && bufsize < fetchlimit /* no overrun */
&& !(len == 0 && *(bufptr - 1) == '\0')); /* no null term */
+ /* bufptr and addr now point immediately beyond the last byte which we
+ consider part of the string (including a '\0' which ends the string). */
+
/* We now have either successfully filled the buffer to fetchlimit, or
terminated early due to an error or finding a null byte when LEN is
- zero. */
+ zero. */
- if (len == 0 && *(bufptr - 1) != '\0')
+ if (len == 0 && bufptr > buffer && *(bufptr - 1) != '\0')
{
/* We didn't find a null terminator we were looking for. Attempt
to peek at the next character. If not successful, or it is not
- a null byte, then force ellipsis to be printed. */
+ a null byte, then force ellipsis to be printed. */
if (target_read_memory (addr, &peekchar, 1) != 0 || peekchar != '\0')
{
force_ellipsis = 1;
}
QUIT;
-
- if (addressprint)
+
+ /* If we get an error before fetching anything, don't print a string.
+ But if we fetch something and then get an error, print the string
+ and then the error message. */
+ if (errcode == 0 || bufptr > buffer)
{
- fputs_filtered (" ", stream);
+ if (addressprint)
+ {
+ fputs_filtered (" ", stream);
+ }
+ LA_PRINT_STRING (stream, buffer, bufptr - buffer, force_ellipsis);
}
- LA_PRINT_STRING (stream, buffer, bufptr - buffer, force_ellipsis);
-
- if (errcode != 0 && force_ellipsis)
+
+ if (errcode != 0)
{
if (errcode == EIO)
{
- fprintf_filtered (stream, " <Address 0x%x out of bounds>", addr);
+ fprintf_filtered (stream, " <Address ");
+ print_address_numeric (addr, 1, stream);
+ fprintf_filtered (stream, " out of bounds>");
}
else
{
- error ("Error reading memory address 0x%x: %s.", addr,
- safe_strerror (errcode));
+ fprintf_filtered (stream, " <Error reading address ");
+ print_address_numeric (addr, 1, stream);
+ fprintf_filtered (stream, ": %s>", safe_strerror (errcode));
}
}
- fflush (stream);
+ gdb_flush (stream);
do_cleanups (old_chain);
return (bufptr - buffer);
}
char *arg;
int from_tty;
{
- printf (
+ printf_unfiltered (
"\"set print\" must be followed by the name of a print subcommand.\n");
- help_list (setprintlist, "set print ", -1, stdout);
+ help_list (setprintlist, "set print ", -1, gdb_stdout);
}
/*ARGSUSED*/
"Generic command for setting how things print.",
&setprintlist, "set print ", 0, &setlist);
add_alias_cmd ("p", "print", no_class, 1, &setlist);
- add_alias_cmd ("pr", "print", no_class, 1, &setlist); /* prefer set print
- to set prompt */
+ /* prefer set print to set prompt */
+ add_alias_cmd ("pr", "print", no_class, 1, &setlist);
+
add_prefix_cmd ("print", no_class, show_print,
"Generic command for showing print settings.",
&showprintlist, "show print ", 0, &showlist);
"Set default input radix for entering numbers.",
&setlist);
add_show_from_set (c, &showlist);
- c->function = set_input_radix;
+ c->function.sfunc = set_input_radix;
c = add_set_cmd ("output-radix", class_support, var_uinteger,
(char *)&output_radix,
"Set default output radix for printing of values.",
&setlist);
add_show_from_set (c, &showlist);
- c->function = set_output_radix;
+ c->function.sfunc = set_output_radix;
/* The "set radix" and "show radix" commands are special in that they are
like normal set and show commands but allow two normally independent
projects / deliverable / binutils-gdb.git / blobdiff