#include "obstack.h"
#include "language.h"
#include "demangle.h"
+#include "annotate.h"
#include <errno.h>
static void
set_output_radix_1 PARAMS ((int, unsigned));
-static void
-value_print_array_elements PARAMS ((value, GDB_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"
/* 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)
int
value_print (val, stream, format, pretty)
- value val;
+ value_ptr val;
GDB_FILE *stream;
int format;
enum val_prettyprint pretty;
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)
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%lx%08lx", vtop, vbot);
return;
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;
+ value_ptr val;
GDB_FILE *stream;
int format;
enum val_prettyprint pretty;
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;
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 */
&& 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 ");
- print_address_numeric (addr, stream);
+ print_address_numeric (addr, 1, stream);
fprintf_filtered (stream, " out of bounds>");
}
else
{
- /* FIXME-32x64: assumes addr fits in a long. */
- error ("Error reading memory address 0x%lx: %s.",
- (unsigned long) addr,
- safe_strerror (errcode));
+ fprintf_filtered (stream, " <Error reading address ");
+ print_address_numeric (addr, 1, stream);
+ fprintf_filtered (stream, ": %s>", safe_strerror (errcode));
}
}
gdb_flush (stream);
projects / deliverable / binutils-gdb.git / blobdiff