1 /* Print values for GDB, the GNU debugger.
3 Copyright 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995,
4 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2005 Free Software
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 2 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program; if not, write to the Free Software
21 Foundation, Inc., 59 Temple Place - Suite 330,
22 Boston, MA 02111-1307, USA. */
25 #include "gdb_string.h"
35 #include "floatformat.h"
40 /* Prototypes for local functions */
42 static int partial_memory_read (CORE_ADDR memaddr
, char *myaddr
,
43 int len
, int *errnoptr
);
45 static void show_print (char *, int);
47 static void set_print (char *, int);
49 static void set_radix (char *, int);
51 static void show_radix (char *, int);
53 static void set_input_radix (char *, int, struct cmd_list_element
*);
55 static void set_input_radix_1 (int, unsigned);
57 static void set_output_radix (char *, int, struct cmd_list_element
*);
59 static void set_output_radix_1 (int, unsigned);
61 void _initialize_valprint (void);
63 /* Maximum number of chars to print for a string pointer value or vector
64 contents, or UINT_MAX for no limit. Note that "set print elements 0"
65 stores UINT_MAX in print_max, which displays in a show command as
68 unsigned int print_max
;
69 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
71 /* Default input and output radixes, and output format letter. */
73 unsigned input_radix
= 10;
74 unsigned output_radix
= 10;
75 int output_format
= 0;
77 /* Print repeat counts if there are more than this many repetitions of an
78 element in an array. Referenced by the low level language dependent
81 unsigned int repeat_count_threshold
= 10;
83 /* If nonzero, stops printing of char arrays at first null. */
85 int stop_print_at_null
;
87 /* Controls pretty printing of structures. */
89 int prettyprint_structs
;
91 /* Controls pretty printing of arrays. */
93 int prettyprint_arrays
;
95 /* If nonzero, causes unions inside structures or other unions to be
98 int unionprint
; /* Controls printing of nested unions. */
100 /* If nonzero, causes machine addresses to be printed in certain contexts. */
102 int addressprint
; /* Controls printing of machine addresses */
105 /* Print data of type TYPE located at VALADDR (within GDB), which came from
106 the inferior at address ADDRESS, onto stdio stream STREAM according to
107 FORMAT (a letter, or 0 for natural format using TYPE).
109 If DEREF_REF is nonzero, then dereference references, otherwise just print
112 The PRETTY parameter controls prettyprinting.
114 If the data are a string pointer, returns the number of string characters
117 FIXME: The data at VALADDR is in target byte order. If gdb is ever
118 enhanced to be able to debug more than the single target it was compiled
119 for (specific CPU type and thus specific target byte ordering), then
120 either the print routines are going to have to take this into account,
121 or the data is going to have to be passed into here already converted
122 to the host byte ordering, whichever is more convenient. */
126 val_print (struct type
*type
, char *valaddr
, int embedded_offset
,
127 CORE_ADDR address
, struct ui_file
*stream
, int format
, int deref_ref
,
128 int recurse
, enum val_prettyprint pretty
)
130 struct type
*real_type
= check_typedef (type
);
131 if (pretty
== Val_pretty_default
)
133 pretty
= prettyprint_structs
? Val_prettyprint
: Val_no_prettyprint
;
138 /* Ensure that the type is complete and not just a stub. If the type is
139 only a stub and we can't find and substitute its complete type, then
140 print appropriate string and return. */
142 if (TYPE_STUB (real_type
))
144 fprintf_filtered (stream
, "<incomplete type>");
149 return (LA_VAL_PRINT (type
, valaddr
, embedded_offset
, address
,
150 stream
, format
, deref_ref
, recurse
, pretty
));
153 /* Print the value VAL in C-ish syntax on stream STREAM.
154 FORMAT is a format-letter, or 0 for print in natural format of data type.
155 If the object printed is a string pointer, returns
156 the number of string bytes printed. */
159 value_print (struct value
*val
, struct ui_file
*stream
, int format
,
160 enum val_prettyprint pretty
)
164 printf_filtered ("<address of value unknown>");
167 if (VALUE_OPTIMIZED_OUT (val
))
169 printf_filtered ("<value optimized out>");
172 return LA_VALUE_PRINT (val
, stream
, format
, pretty
);
175 /* Called by various <lang>_val_print routines to print
176 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
177 value. STREAM is where to print the value. */
180 val_print_type_code_int (struct type
*type
, const bfd_byte
*valaddr
,
181 struct ui_file
*stream
)
183 if (TYPE_LENGTH (type
) > sizeof (LONGEST
))
187 if (TYPE_UNSIGNED (type
)
188 && extract_long_unsigned_integer (valaddr
, TYPE_LENGTH (type
),
191 print_longest (stream
, 'u', 0, val
);
195 /* Signed, or we couldn't turn an unsigned value into a
196 LONGEST. For signed values, one could assume two's
197 complement (a reasonable assumption, I think) and do
199 print_hex_chars (stream
, (unsigned char *) valaddr
,
205 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0,
206 unpack_long (type
, valaddr
));
210 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
211 The raison d'etre of this function is to consolidate printing of
212 LONG_LONG's into this one function. The format chars b,h,w,g are
213 from print_scalar_formatted(). Numbers are printed using C
216 USE_C_FORMAT means to use C format in all cases. Without it,
217 'o' and 'x' format do not include the standard C radix prefix
220 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
221 and was intended to request formating according to the current
222 language and would be used for most integers that GDB prints. The
223 exceptional cases were things like protocols where the format of
224 the integer is a protocol thing, not a user-visible thing). The
225 parameter remains to preserve the information of what things might
226 be printed with language-specific format, should we ever resurrect
230 print_longest (struct ui_file
*stream
, int format
, int use_c_format
,
238 val
= int_string (val_long
, 10, 1, 0, 1); break;
240 val
= int_string (val_long
, 10, 0, 0, 1); break;
242 val
= int_string (val_long
, 16, 0, 0, use_c_format
); break;
244 val
= int_string (val_long
, 16, 0, 2, 1); break;
246 val
= int_string (val_long
, 16, 0, 4, 1); break;
248 val
= int_string (val_long
, 16, 0, 8, 1); break;
250 val
= int_string (val_long
, 16, 0, 16, 1); break;
253 val
= int_string (val_long
, 8, 0, 0, use_c_format
); break;
255 internal_error (__FILE__
, __LINE__
, "failed internal consistency check");
257 fputs_filtered (val
, stream
);
260 /* This used to be a macro, but I don't think it is called often enough
261 to merit such treatment. */
262 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
263 arguments to a function, number in a value history, register number, etc.)
264 where the value must not be larger than can fit in an int. */
267 longest_to_int (LONGEST arg
)
269 /* Let the compiler do the work */
270 int rtnval
= (int) arg
;
272 /* Check for overflows or underflows */
273 if (sizeof (LONGEST
) > sizeof (int))
277 error ("Value out of range.");
283 /* Print a floating point value of type TYPE (not always a
284 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
287 print_floating (const bfd_byte
*valaddr
, struct type
*type
,
288 struct ui_file
*stream
)
292 const struct floatformat
*fmt
= NULL
;
293 unsigned len
= TYPE_LENGTH (type
);
295 /* If it is a floating-point, check for obvious problems. */
296 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
297 fmt
= floatformat_from_type (type
);
298 if (fmt
!= NULL
&& floatformat_is_nan (fmt
, valaddr
))
300 if (floatformat_is_negative (fmt
, valaddr
))
301 fprintf_filtered (stream
, "-");
302 fprintf_filtered (stream
, "nan(");
303 fputs_filtered ("0x", stream
);
304 fputs_filtered (floatformat_mantissa (fmt
, valaddr
), stream
);
305 fprintf_filtered (stream
, ")");
309 /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
310 isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double
311 needs to be used as that takes care of any necessary type
312 conversions. Such conversions are of course direct to DOUBLEST
313 and disregard any possible target floating point limitations.
314 For instance, a u64 would be converted and displayed exactly on a
315 host with 80 bit DOUBLEST but with loss of information on a host
316 with 64 bit DOUBLEST. */
318 doub
= unpack_double (type
, valaddr
, &inv
);
321 fprintf_filtered (stream
, "<invalid float value>");
325 /* FIXME: kettenis/2001-01-20: The following code makes too much
326 assumptions about the host and target floating point format. */
328 /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
329 not necessarially be a TYPE_CODE_FLT, the below ignores that and
330 instead uses the type's length to determine the precision of the
331 floating-point value being printed. */
333 if (len
< sizeof (double))
334 fprintf_filtered (stream
, "%.9g", (double) doub
);
335 else if (len
== sizeof (double))
336 fprintf_filtered (stream
, "%.17g", (double) doub
);
338 #ifdef PRINTF_HAS_LONG_DOUBLE
339 fprintf_filtered (stream
, "%.35Lg", doub
);
341 /* This at least wins with values that are representable as
343 fprintf_filtered (stream
, "%.17g", (double) doub
);
348 print_binary_chars (struct ui_file
*stream
, const bfd_byte
*valaddr
,
352 #define BITS_IN_BYTES 8
358 /* Declared "int" so it will be signed.
359 * This ensures that right shift will shift in zeros.
361 const int mask
= 0x080;
363 /* FIXME: We should be not printing leading zeroes in most cases. */
365 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
371 /* Every byte has 8 binary characters; peel off
372 * and print from the MSB end.
374 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
376 if (*p
& (mask
>> i
))
381 fprintf_filtered (stream
, "%1d", b
);
387 for (p
= valaddr
+ len
- 1;
391 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
393 if (*p
& (mask
>> i
))
398 fprintf_filtered (stream
, "%1d", b
);
404 /* VALADDR points to an integer of LEN bytes.
405 * Print it in octal on stream or format it in buf.
408 print_octal_chars (struct ui_file
*stream
, const bfd_byte
*valaddr
,
412 unsigned char octa1
, octa2
, octa3
, carry
;
415 /* FIXME: We should be not printing leading zeroes in most cases. */
418 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
419 * the extra bits, which cycle every three bytes:
423 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
425 * Octal side: 0 1 carry 3 4 carry ...
427 * Cycle number: 0 1 2
429 * But of course we are printing from the high side, so we have to
430 * figure out where in the cycle we are so that we end up with no
431 * left over bits at the end.
433 #define BITS_IN_OCTAL 3
434 #define HIGH_ZERO 0340
435 #define LOW_ZERO 0016
436 #define CARRY_ZERO 0003
437 #define HIGH_ONE 0200
440 #define CARRY_ONE 0001
441 #define HIGH_TWO 0300
445 /* For 32 we start in cycle 2, with two bits and one bit carry;
446 * for 64 in cycle in cycle 1, with one bit and a two bit carry.
448 cycle
= (len
* BITS_IN_BYTES
) % BITS_IN_OCTAL
;
451 fputs_filtered ("0", stream
);
452 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
461 /* No carry in, carry out two bits.
463 octa1
= (HIGH_ZERO
& *p
) >> 5;
464 octa2
= (LOW_ZERO
& *p
) >> 2;
465 carry
= (CARRY_ZERO
& *p
);
466 fprintf_filtered (stream
, "%o", octa1
);
467 fprintf_filtered (stream
, "%o", octa2
);
471 /* Carry in two bits, carry out one bit.
473 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
474 octa2
= (MID_ONE
& *p
) >> 4;
475 octa3
= (LOW_ONE
& *p
) >> 1;
476 carry
= (CARRY_ONE
& *p
);
477 fprintf_filtered (stream
, "%o", octa1
);
478 fprintf_filtered (stream
, "%o", octa2
);
479 fprintf_filtered (stream
, "%o", octa3
);
483 /* Carry in one bit, no carry out.
485 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
486 octa2
= (MID_TWO
& *p
) >> 3;
487 octa3
= (LOW_TWO
& *p
);
489 fprintf_filtered (stream
, "%o", octa1
);
490 fprintf_filtered (stream
, "%o", octa2
);
491 fprintf_filtered (stream
, "%o", octa3
);
495 error ("Internal error in octal conversion;");
499 cycle
= cycle
% BITS_IN_OCTAL
;
504 for (p
= valaddr
+ len
- 1;
511 /* Carry out, no carry in */
512 octa1
= (HIGH_ZERO
& *p
) >> 5;
513 octa2
= (LOW_ZERO
& *p
) >> 2;
514 carry
= (CARRY_ZERO
& *p
);
515 fprintf_filtered (stream
, "%o", octa1
);
516 fprintf_filtered (stream
, "%o", octa2
);
520 /* Carry in, carry out */
521 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
522 octa2
= (MID_ONE
& *p
) >> 4;
523 octa3
= (LOW_ONE
& *p
) >> 1;
524 carry
= (CARRY_ONE
& *p
);
525 fprintf_filtered (stream
, "%o", octa1
);
526 fprintf_filtered (stream
, "%o", octa2
);
527 fprintf_filtered (stream
, "%o", octa3
);
531 /* Carry in, no carry out */
532 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
533 octa2
= (MID_TWO
& *p
) >> 3;
534 octa3
= (LOW_TWO
& *p
);
536 fprintf_filtered (stream
, "%o", octa1
);
537 fprintf_filtered (stream
, "%o", octa2
);
538 fprintf_filtered (stream
, "%o", octa3
);
542 error ("Internal error in octal conversion;");
546 cycle
= cycle
% BITS_IN_OCTAL
;
552 /* VALADDR points to an integer of LEN bytes.
553 * Print it in decimal on stream or format it in buf.
556 print_decimal_chars (struct ui_file
*stream
, const bfd_byte
*valaddr
,
560 #define TWO_TO_FOURTH 16
561 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
562 #define CARRY_LEFT( x ) ((x) % TEN)
563 #define SHIFT( x ) ((x) << 4)
565 ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) ? valaddr : valaddr + len - 1)
567 ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) ? (p < valaddr + len) : (p >= valaddr))
569 ((TARGET_BYTE_ORDER == BFD_ENDIAN_BIG) ? p++ : p-- )
570 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
571 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
574 unsigned char *digits
;
577 int i
, j
, decimal_digits
;
581 /* Base-ten number is less than twice as many digits
582 * as the base 16 number, which is 2 digits per byte.
584 decimal_len
= len
* 2 * 2;
585 digits
= xmalloc (decimal_len
);
587 for (i
= 0; i
< decimal_len
; i
++)
592 /* Ok, we have an unknown number of bytes of data to be printed in
595 * Given a hex number (in nibbles) as XYZ, we start by taking X and
596 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
597 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
599 * The trick is that "digits" holds a base-10 number, but sometimes
600 * the individual digits are > 10.
602 * Outer loop is per nibble (hex digit) of input, from MSD end to
605 decimal_digits
= 0; /* Number of decimal digits so far */
611 * Multiply current base-ten number by 16 in place.
612 * Each digit was between 0 and 9, now is between
615 for (j
= 0; j
< decimal_digits
; j
++)
617 digits
[j
] = SHIFT (digits
[j
]);
620 /* Take the next nibble off the input and add it to what
621 * we've got in the LSB position. Bottom 'digit' is now
624 * "flip" is used to run this loop twice for each byte.
630 digits
[0] += HIGH_NIBBLE (*p
);
635 /* Take low nibble and bump our pointer "p".
637 digits
[0] += LOW_NIBBLE (*p
);
642 /* Re-decimalize. We have to do this often enough
643 * that we don't overflow, but once per nibble is
644 * overkill. Easier this way, though. Note that the
645 * carry is often larger than 10 (e.g. max initial
646 * carry out of lowest nibble is 15, could bubble all
647 * the way up greater than 10). So we have to do
648 * the carrying beyond the last current digit.
651 for (j
= 0; j
< decimal_len
- 1; j
++)
655 /* "/" won't handle an unsigned char with
656 * a value that if signed would be negative.
657 * So extend to longword int via "dummy".
660 carry
= CARRY_OUT (dummy
);
661 digits
[j
] = CARRY_LEFT (dummy
);
663 if (j
>= decimal_digits
&& carry
== 0)
666 * All higher digits are 0 and we
667 * no longer have a carry.
669 * Note: "j" is 0-based, "decimal_digits" is
672 decimal_digits
= j
+ 1;
678 /* Ok, now "digits" is the decimal representation, with
679 * the "decimal_digits" actual digits. Print!
681 for (i
= decimal_digits
- 1; i
>= 0; i
--)
683 fprintf_filtered (stream
, "%1d", digits
[i
]);
688 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
691 print_hex_chars (struct ui_file
*stream
, const bfd_byte
*valaddr
,
696 /* FIXME: We should be not printing leading zeroes in most cases. */
698 fputs_filtered ("0x", stream
);
699 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
705 fprintf_filtered (stream
, "%02x", *p
);
710 for (p
= valaddr
+ len
- 1;
714 fprintf_filtered (stream
, "%02x", *p
);
719 /* VALADDR points to a char integer of LEN bytes. Print it out in appropriate language form on stream.
720 Omit any leading zero chars. */
723 print_char_chars (struct ui_file
*stream
, const bfd_byte
*valaddr
,
728 if (TARGET_BYTE_ORDER
== BFD_ENDIAN_BIG
)
731 while (p
< valaddr
+ len
- 1 && *p
== 0)
734 while (p
< valaddr
+ len
)
736 LA_EMIT_CHAR (*p
, stream
, '\'');
742 p
= valaddr
+ len
- 1;
743 while (p
> valaddr
&& *p
== 0)
748 LA_EMIT_CHAR (*p
, stream
, '\'');
754 /* Called by various <lang>_val_print routines to print elements of an
755 array in the form "<elem1>, <elem2>, <elem3>, ...".
757 (FIXME?) Assumes array element separator is a comma, which is correct
758 for all languages currently handled.
759 (FIXME?) Some languages have a notation for repeated array elements,
760 perhaps we should try to use that notation when appropriate.
764 val_print_array_elements (struct type
*type
, char *valaddr
, CORE_ADDR address
,
765 struct ui_file
*stream
, int format
, int deref_ref
,
766 int recurse
, enum val_prettyprint pretty
,
769 unsigned int things_printed
= 0;
771 struct type
*elttype
;
773 /* Position of the array element we are examining to see
774 whether it is repeated. */
776 /* Number of repetitions we have detected so far. */
779 elttype
= TYPE_TARGET_TYPE (type
);
780 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
781 len
= TYPE_LENGTH (type
) / eltlen
;
783 annotate_array_section_begin (i
, elttype
);
785 for (; i
< len
&& things_printed
< print_max
; i
++)
789 if (prettyprint_arrays
)
791 fprintf_filtered (stream
, ",\n");
792 print_spaces_filtered (2 + 2 * recurse
, stream
);
796 fprintf_filtered (stream
, ", ");
799 wrap_here (n_spaces (2 + 2 * recurse
));
803 while ((rep1
< len
) &&
804 !memcmp (valaddr
+ i
* eltlen
, valaddr
+ rep1
* eltlen
, eltlen
))
810 if (reps
> repeat_count_threshold
)
812 val_print (elttype
, valaddr
+ i
* eltlen
, 0, 0, stream
, format
,
813 deref_ref
, recurse
+ 1, pretty
);
814 annotate_elt_rep (reps
);
815 fprintf_filtered (stream
, " <repeats %u times>", reps
);
816 annotate_elt_rep_end ();
819 things_printed
+= repeat_count_threshold
;
823 val_print (elttype
, valaddr
+ i
* eltlen
, 0, 0, stream
, format
,
824 deref_ref
, recurse
+ 1, pretty
);
829 annotate_array_section_end ();
832 fprintf_filtered (stream
, "...");
836 /* Read LEN bytes of target memory at address MEMADDR, placing the
837 results in GDB's memory at MYADDR. Returns a count of the bytes
838 actually read, and optionally an errno value in the location
839 pointed to by ERRNOPTR if ERRNOPTR is non-null. */
841 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
842 function be eliminated. */
845 partial_memory_read (CORE_ADDR memaddr
, char *myaddr
, int len
, int *errnoptr
)
847 int nread
; /* Number of bytes actually read. */
848 int errcode
; /* Error from last read. */
850 /* First try a complete read. */
851 errcode
= target_read_memory (memaddr
, myaddr
, len
);
859 /* Loop, reading one byte at a time until we get as much as we can. */
860 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
862 errcode
= target_read_memory (memaddr
++, myaddr
++, 1);
864 /* If an error, the last read was unsuccessful, so adjust count. */
870 if (errnoptr
!= NULL
)
877 /* Print a string from the inferior, starting at ADDR and printing up to LEN
878 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
879 stops at the first null byte, otherwise printing proceeds (including null
880 bytes) until either print_max or LEN characters have been printed,
881 whichever is smaller. */
883 /* FIXME: Use target_read_string. */
886 val_print_string (CORE_ADDR addr
, int len
, int width
, struct ui_file
*stream
)
888 int force_ellipsis
= 0; /* Force ellipsis to be printed if nonzero. */
889 int errcode
; /* Errno returned from bad reads. */
890 unsigned int fetchlimit
; /* Maximum number of chars to print. */
891 unsigned int nfetch
; /* Chars to fetch / chars fetched. */
892 unsigned int chunksize
; /* Size of each fetch, in chars. */
893 char *buffer
= NULL
; /* Dynamically growable fetch buffer. */
894 char *bufptr
; /* Pointer to next available byte in buffer. */
895 char *limit
; /* First location past end of fetch buffer. */
896 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
897 int found_nul
; /* Non-zero if we found the nul char */
899 /* First we need to figure out the limit on the number of characters we are
900 going to attempt to fetch and print. This is actually pretty simple. If
901 LEN >= zero, then the limit is the minimum of LEN and print_max. If
902 LEN is -1, then the limit is print_max. This is true regardless of
903 whether print_max is zero, UINT_MAX (unlimited), or something in between,
904 because finding the null byte (or available memory) is what actually
907 fetchlimit
= (len
== -1 ? print_max
: min (len
, print_max
));
909 /* Now decide how large of chunks to try to read in one operation. This
910 is also pretty simple. If LEN >= zero, then we want fetchlimit chars,
911 so we might as well read them all in one operation. If LEN is -1, we
912 are looking for a null terminator to end the fetching, so we might as
913 well read in blocks that are large enough to be efficient, but not so
914 large as to be slow if fetchlimit happens to be large. So we choose the
915 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
916 200 is way too big for remote debugging over a serial line. */
918 chunksize
= (len
== -1 ? min (8, fetchlimit
) : fetchlimit
);
920 /* Loop until we either have all the characters to print, or we encounter
921 some error, such as bumping into the end of the address space. */
924 old_chain
= make_cleanup (null_cleanup
, 0);
928 buffer
= (char *) xmalloc (len
* width
);
930 old_chain
= make_cleanup (xfree
, buffer
);
932 nfetch
= partial_memory_read (addr
, bufptr
, len
* width
, &errcode
)
934 addr
+= nfetch
* width
;
935 bufptr
+= nfetch
* width
;
939 unsigned long bufsize
= 0;
943 nfetch
= min (chunksize
, fetchlimit
- bufsize
);
946 buffer
= (char *) xmalloc (nfetch
* width
);
949 discard_cleanups (old_chain
);
950 buffer
= (char *) xrealloc (buffer
, (nfetch
+ bufsize
) * width
);
953 old_chain
= make_cleanup (xfree
, buffer
);
954 bufptr
= buffer
+ bufsize
* width
;
957 /* Read as much as we can. */
958 nfetch
= partial_memory_read (addr
, bufptr
, nfetch
* width
, &errcode
)
961 /* Scan this chunk for the null byte that terminates the string
962 to print. If found, we don't need to fetch any more. Note
963 that bufptr is explicitly left pointing at the next character
964 after the null byte, or at the next character after the end of
967 limit
= bufptr
+ nfetch
* width
;
968 while (bufptr
< limit
)
972 c
= extract_unsigned_integer (bufptr
, width
);
977 /* We don't care about any error which happened after
978 the NULL terminator. */
985 while (errcode
== 0 /* no error */
986 && bufptr
- buffer
< fetchlimit
* width
/* no overrun */
987 && !found_nul
); /* haven't found nul yet */
990 { /* length of string is really 0! */
991 buffer
= bufptr
= NULL
;
995 /* bufptr and addr now point immediately beyond the last byte which we
996 consider part of the string (including a '\0' which ends the string). */
998 /* We now have either successfully filled the buffer to fetchlimit, or
999 terminated early due to an error or finding a null char when LEN is -1. */
1001 if (len
== -1 && !found_nul
)
1005 /* We didn't find a null terminator we were looking for. Attempt
1006 to peek at the next character. If not successful, or it is not
1007 a null byte, then force ellipsis to be printed. */
1009 peekbuf
= (char *) alloca (width
);
1011 if (target_read_memory (addr
, peekbuf
, width
) == 0
1012 && extract_unsigned_integer (peekbuf
, width
) != 0)
1015 else if ((len
>= 0 && errcode
!= 0) || (len
> (bufptr
- buffer
) / width
))
1017 /* Getting an error when we have a requested length, or fetching less
1018 than the number of characters actually requested, always make us
1025 /* If we get an error before fetching anything, don't print a string.
1026 But if we fetch something and then get an error, print the string
1027 and then the error message. */
1028 if (errcode
== 0 || bufptr
> buffer
)
1032 fputs_filtered (" ", stream
);
1034 LA_PRINT_STRING (stream
, buffer
, (bufptr
- buffer
) / width
, width
, force_ellipsis
);
1041 fprintf_filtered (stream
, " <Address ");
1042 print_address_numeric (addr
, 1, stream
);
1043 fprintf_filtered (stream
, " out of bounds>");
1047 fprintf_filtered (stream
, " <Error reading address ");
1048 print_address_numeric (addr
, 1, stream
);
1049 fprintf_filtered (stream
, ": %s>", safe_strerror (errcode
));
1053 do_cleanups (old_chain
);
1054 return ((bufptr
- buffer
) / width
);
1058 /* Validate an input or output radix setting, and make sure the user
1059 knows what they really did here. Radix setting is confusing, e.g.
1060 setting the input radix to "10" never changes it! */
1063 set_input_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
1065 set_input_radix_1 (from_tty
, input_radix
);
1069 set_input_radix_1 (int from_tty
, unsigned radix
)
1071 /* We don't currently disallow any input radix except 0 or 1, which don't
1072 make any mathematical sense. In theory, we can deal with any input
1073 radix greater than 1, even if we don't have unique digits for every
1074 value from 0 to radix-1, but in practice we lose on large radix values.
1075 We should either fix the lossage or restrict the radix range more.
1080 /* FIXME: cagney/2002-03-17: This needs to revert the bad radix
1082 error ("Nonsense input radix ``decimal %u''; input radix unchanged.",
1085 input_radix
= radix
;
1088 printf_filtered ("Input radix now set to decimal %u, hex %x, octal %o.\n",
1089 radix
, radix
, radix
);
1094 set_output_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
1096 set_output_radix_1 (from_tty
, output_radix
);
1100 set_output_radix_1 (int from_tty
, unsigned radix
)
1102 /* Validate the radix and disallow ones that we aren't prepared to
1103 handle correctly, leaving the radix unchanged. */
1107 output_format
= 'x'; /* hex */
1110 output_format
= 0; /* decimal */
1113 output_format
= 'o'; /* octal */
1116 /* FIXME: cagney/2002-03-17: This needs to revert the bad radix
1118 error ("Unsupported output radix ``decimal %u''; output radix unchanged.",
1121 output_radix
= radix
;
1124 printf_filtered ("Output radix now set to decimal %u, hex %x, octal %o.\n",
1125 radix
, radix
, radix
);
1129 /* Set both the input and output radix at once. Try to set the output radix
1130 first, since it has the most restrictive range. An radix that is valid as
1131 an output radix is also valid as an input radix.
1133 It may be useful to have an unusual input radix. If the user wishes to
1134 set an input radix that is not valid as an output radix, he needs to use
1135 the 'set input-radix' command. */
1138 set_radix (char *arg
, int from_tty
)
1142 radix
= (arg
== NULL
) ? 10 : parse_and_eval_long (arg
);
1143 set_output_radix_1 (0, radix
);
1144 set_input_radix_1 (0, radix
);
1147 printf_filtered ("Input and output radices now set to decimal %u, hex %x, octal %o.\n",
1148 radix
, radix
, radix
);
1152 /* Show both the input and output radices. */
1155 show_radix (char *arg
, int from_tty
)
1159 if (input_radix
== output_radix
)
1161 printf_filtered ("Input and output radices set to decimal %u, hex %x, octal %o.\n",
1162 input_radix
, input_radix
, input_radix
);
1166 printf_filtered ("Input radix set to decimal %u, hex %x, octal %o.\n",
1167 input_radix
, input_radix
, input_radix
);
1168 printf_filtered ("Output radix set to decimal %u, hex %x, octal %o.\n",
1169 output_radix
, output_radix
, output_radix
);
1176 set_print (char *arg
, int from_tty
)
1179 "\"set print\" must be followed by the name of a print subcommand.\n");
1180 help_list (setprintlist
, "set print ", -1, gdb_stdout
);
1184 show_print (char *args
, int from_tty
)
1186 cmd_show_list (showprintlist
, from_tty
, "");
1190 _initialize_valprint (void)
1192 struct cmd_list_element
*c
;
1194 add_prefix_cmd ("print", no_class
, set_print
,
1195 "Generic command for setting how things print.",
1196 &setprintlist
, "set print ", 0, &setlist
);
1197 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
1198 /* prefer set print to set prompt */
1199 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
);
1201 add_prefix_cmd ("print", no_class
, show_print
,
1202 "Generic command for showing print settings.",
1203 &showprintlist
, "show print ", 0, &showlist
);
1204 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
1205 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
1207 deprecated_add_show_from_set
1208 (add_set_cmd ("elements", no_class
, var_uinteger
, (char *) &print_max
,
1209 "Set limit on string chars or array elements to print.\n\
1210 \"set print elements 0\" causes there to be no limit.",
1214 deprecated_add_show_from_set
1215 (add_set_cmd ("null-stop", no_class
, var_boolean
,
1216 (char *) &stop_print_at_null
,
1217 "Set printing of char arrays to stop at first null char.",
1221 deprecated_add_show_from_set
1222 (add_set_cmd ("repeats", no_class
, var_uinteger
,
1223 (char *) &repeat_count_threshold
,
1224 "Set threshold for repeated print elements.\n\
1225 \"set print repeats 0\" causes all elements to be individually printed.",
1229 deprecated_add_show_from_set
1230 (add_set_cmd ("pretty", class_support
, var_boolean
,
1231 (char *) &prettyprint_structs
,
1232 "Set prettyprinting of structures.",
1236 deprecated_add_show_from_set
1237 (add_set_cmd ("union", class_support
, var_boolean
, (char *) &unionprint
,
1238 "Set printing of unions interior to structures.",
1242 deprecated_add_show_from_set
1243 (add_set_cmd ("array", class_support
, var_boolean
,
1244 (char *) &prettyprint_arrays
,
1245 "Set prettyprinting of arrays.",
1249 deprecated_add_show_from_set
1250 (add_set_cmd ("address", class_support
, var_boolean
, (char *) &addressprint
,
1251 "Set printing of addresses.",
1255 c
= add_set_cmd ("input-radix", class_support
, var_uinteger
,
1256 (char *) &input_radix
,
1257 "Set default input radix for entering numbers.",
1259 deprecated_add_show_from_set (c
, &showlist
);
1260 set_cmd_sfunc (c
, set_input_radix
);
1262 c
= add_set_cmd ("output-radix", class_support
, var_uinteger
,
1263 (char *) &output_radix
,
1264 "Set default output radix for printing of values.",
1266 deprecated_add_show_from_set (c
, &showlist
);
1267 set_cmd_sfunc (c
, set_output_radix
);
1269 /* The "set radix" and "show radix" commands are special in that
1270 they are like normal set and show commands but allow two normally
1271 independent variables to be either set or shown with a single
1272 command. So the usual deprecated_add_set_cmd() and
1273 add_show_from_set() commands aren't really appropriate. */
1274 add_cmd ("radix", class_support
, set_radix
,
1275 "Set default input and output number radices.\n\
1276 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
1277 Without an argument, sets both radices back to the default value of 10.",
1279 add_cmd ("radix", class_support
, show_radix
,
1280 "Show the default input and output number radices.\n\
1281 Use 'show input-radix' or 'show output-radix' to independently show each.",
1284 /* Give people the defaults which they are used to. */
1285 prettyprint_structs
= 0;
1286 prettyprint_arrays
= 0;
1289 print_max
= PRINT_MAX_DEFAULT
;