1 /* Print values for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1991 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
34 /* Prototypes for local functions */
37 print_hex_chars
PARAMS ((GDB_FILE
*, unsigned char *, unsigned int));
40 show_print
PARAMS ((char *, int));
43 set_print
PARAMS ((char *, int));
46 set_radix
PARAMS ((char *, int));
49 show_radix
PARAMS ((char *, int));
52 set_input_radix
PARAMS ((char *, int, struct cmd_list_element
*));
55 set_input_radix_1
PARAMS ((int, unsigned));
58 set_output_radix
PARAMS ((char *, int, struct cmd_list_element
*));
61 set_output_radix_1
PARAMS ((int, unsigned));
63 static void value_print_array_elements
PARAMS ((value_ptr
, GDB_FILE
*, int,
64 enum val_prettyprint
));
66 /* Maximum number of chars to print for a string pointer value or vector
67 contents, or UINT_MAX for no limit. Note that "set print elements 0"
68 stores UINT_MAX in print_max, which displays in a show command as
71 unsigned int print_max
;
72 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
74 /* Default input and output radixes, and output format letter. */
76 unsigned input_radix
= 10;
77 unsigned output_radix
= 10;
78 int output_format
= 0;
80 /* Print repeat counts if there are more than this many repetitions of an
81 element in an array. Referenced by the low level language dependent
84 unsigned int repeat_count_threshold
= 10;
86 int prettyprint_structs
; /* Controls pretty printing of structures */
87 int prettyprint_arrays
; /* Controls pretty printing of arrays. */
89 /* If nonzero, causes unions inside structures or other unions to be
92 int unionprint
; /* Controls printing of nested unions. */
94 /* If nonzero, causes machine addresses to be printed in certain contexts. */
96 int addressprint
; /* Controls printing of machine addresses */
99 /* Print data of type TYPE located at VALADDR (within GDB), which came from
100 the inferior at address ADDRESS, onto stdio stream STREAM according to
101 FORMAT (a letter, or 0 for natural format using TYPE).
103 If DEREF_REF is nonzero, then dereference references, otherwise just print
106 The PRETTY parameter controls prettyprinting.
108 If the data are a string pointer, returns the number of string characters
111 FIXME: The data at VALADDR is in target byte order. If gdb is ever
112 enhanced to be able to debug more than the single target it was compiled
113 for (specific CPU type and thus specific target byte ordering), then
114 either the print routines are going to have to take this into account,
115 or the data is going to have to be passed into here already converted
116 to the host byte ordering, whichever is more convenient. */
120 val_print (type
, valaddr
, address
, stream
, format
, deref_ref
, recurse
, pretty
)
128 enum val_prettyprint pretty
;
130 if (pretty
== Val_pretty_default
)
132 pretty
= prettyprint_structs
? Val_prettyprint
: Val_no_prettyprint
;
137 /* Ensure that the type is complete and not just a stub. If the type is
138 only a stub and we can't find and substitute its complete type, then
139 print appropriate string and return. */
141 check_stub_type (type
);
142 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
144 fprintf_filtered (stream
, "<incomplete type>");
149 return (LA_VAL_PRINT (type
, valaddr
, address
, stream
, format
, deref_ref
,
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 (val
, stream
, format
, pretty
)
163 enum val_prettyprint pretty
;
165 register unsigned int n
, typelen
;
169 printf_filtered ("<address of value unknown>");
172 if (VALUE_OPTIMIZED_OUT (val
))
174 printf_filtered ("<value optimized out>");
178 /* A "repeated" value really contains several values in a row.
179 They are made by the @ operator.
180 Print such values as if they were arrays. */
182 if (VALUE_REPEATED (val
))
184 n
= VALUE_REPETITIONS (val
);
185 typelen
= TYPE_LENGTH (VALUE_TYPE (val
));
186 fprintf_filtered (stream
, "{");
187 /* Print arrays of characters using string syntax. */
188 if (typelen
== 1 && TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_INT
190 LA_PRINT_STRING (stream
, VALUE_CONTENTS (val
), n
, 0);
193 value_print_array_elements (val
, stream
, format
, pretty
);
195 fprintf_filtered (stream
, "}");
196 return (n
* typelen
);
200 struct type
*type
= VALUE_TYPE (val
);
202 /* If it is a pointer, indicate what it points to.
204 Print type also if it is a reference.
206 C++: if it is a member pointer, we will take care
207 of that when we print it. */
208 if (TYPE_CODE (type
) == TYPE_CODE_PTR
||
209 TYPE_CODE (type
) == TYPE_CODE_REF
)
211 /* Hack: remove (char *) for char strings. Their
212 type is indicated by the quoted string anyway. */
213 if (TYPE_CODE (type
) == TYPE_CODE_PTR
&&
214 TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) == sizeof(char) &&
215 TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_INT
&&
216 !TYPE_UNSIGNED (TYPE_TARGET_TYPE (type
)))
222 fprintf_filtered (stream
, "(");
223 type_print (type
, "", stream
, -1);
224 fprintf_filtered (stream
, ") ");
227 return (val_print (type
, VALUE_CONTENTS (val
),
228 VALUE_ADDRESS (val
), stream
, format
, 1, 0, pretty
));
232 /* Called by various <lang>_val_print routines to print TYPE_CODE_INT's */
235 val_print_type_code_int (type
, valaddr
, stream
)
241 /* Pointer to first (i.e. lowest address) nonzero character. */
245 if (TYPE_LENGTH (type
) > sizeof (LONGEST
))
247 if (TYPE_UNSIGNED (type
))
249 /* First figure out whether the number in fact has zeros
250 in all its bytes more significant than least significant
251 sizeof (LONGEST) ones. */
252 len
= TYPE_LENGTH (type
);
254 #if TARGET_BYTE_ORDER == BIG_ENDIAN
256 len
> sizeof (LONGEST
) && p
< valaddr
+ TYPE_LENGTH (type
);
258 #else /* Little endian. */
259 first_addr
= valaddr
;
260 for (p
= valaddr
+ TYPE_LENGTH (type
) - 1;
261 len
> sizeof (LONGEST
) && p
>= valaddr
;
263 #endif /* Little endian. */
274 #if TARGET_BYTE_ORDER == BIG_ENDIAN
277 if (len
<= sizeof (LONGEST
))
279 /* The most significant bytes are zero, so we can just get
280 the least significant sizeof (LONGEST) bytes and print it
282 print_longest (stream
, 'u', 0,
283 extract_unsigned_integer (first_addr
,
288 /* It is big, so print it in hex. */
289 print_hex_chars (stream
, (unsigned char *) first_addr
, len
);
294 /* Signed. One could assume two's complement (a reasonable
295 assumption, I think) and do better than this. */
296 print_hex_chars (stream
, (unsigned char *) valaddr
,
302 #ifdef PRINT_TYPELESS_INTEGER
303 PRINT_TYPELESS_INTEGER (stream
, type
, unpack_long (type
, valaddr
));
305 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0,
306 unpack_long (type
, valaddr
));
311 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
312 The raison d'etre of this function is to consolidate printing of LONG_LONG's
313 into this one function. Some platforms have long longs but don't have a
314 printf() that supports "ll" in the format string. We handle these by seeing
315 if the number is actually a long, and if not we just bail out and print the
316 number in hex. The format chars b,h,w,g are from
317 print_scalar_formatted(). USE_LOCAL says whether or not to call the
318 local formatting routine to get the format. */
321 print_longest (stream
, format
, use_local
, val_long
)
327 #if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
330 vtop
= val_long
>> (sizeof (long) * HOST_CHAR_BIT
);
331 vbot
= (long) val_long
;
333 if ((format
== 'd' && (val_long
< INT_MIN
|| val_long
> INT_MAX
))
334 || ((format
== 'u' || format
== 'x') && (unsigned long long)val_long
> UINT_MAX
))
336 fprintf_filtered (stream
, "0x%lx%08lx", vtop
, vbot
);
341 #ifdef PRINTF_HAS_LONG_LONG
345 fprintf_filtered (stream
,
346 use_local
? local_decimal_format_custom ("ll")
351 fprintf_filtered (stream
, "%llu", val_long
);
354 fprintf_filtered (stream
,
355 use_local
? local_hex_format_custom ("ll")
360 fprintf_filtered (stream
,
361 use_local
? local_octal_format_custom ("ll")
365 fprintf_filtered (stream
, local_hex_format_custom ("02ll"), val_long
);
368 fprintf_filtered (stream
, local_hex_format_custom ("04ll"), val_long
);
371 fprintf_filtered (stream
, local_hex_format_custom ("08ll"), val_long
);
374 fprintf_filtered (stream
, local_hex_format_custom ("016ll"), val_long
);
379 #else /* !PRINTF_HAS_LONG_LONG */
380 /* In the following it is important to coerce (val_long) to a long. It does
381 nothing if !LONG_LONG, but it will chop off the top half (which we know
382 we can ignore) if the host supports long longs. */
387 fprintf_filtered (stream
,
388 use_local
? local_decimal_format_custom ("l")
393 fprintf_filtered (stream
, "%lu", (unsigned long) val_long
);
396 fprintf_filtered (stream
,
397 use_local
? local_hex_format_custom ("l")
402 fprintf_filtered (stream
,
403 use_local
? local_octal_format_custom ("l")
408 fprintf_filtered (stream
, local_hex_format_custom ("02l"),
412 fprintf_filtered (stream
, local_hex_format_custom ("04l"),
416 fprintf_filtered (stream
, local_hex_format_custom ("08l"),
420 fprintf_filtered (stream
, local_hex_format_custom ("016l"),
426 #endif /* !PRINTF_HAS_LONG_LONG */
429 /* This used to be a macro, but I don't think it is called often enough
430 to merit such treatment. */
431 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
432 arguments to a function, number in a value history, register number, etc.)
433 where the value must not be larger than can fit in an int. */
440 /* This check is in case a system header has botched the
441 definition of INT_MIN, like on BSDI. */
442 if (sizeof (LONGEST
) <= sizeof (int))
445 if (arg
> INT_MAX
|| arg
< INT_MIN
)
446 error ("Value out of range.");
451 /* Print a floating point value of type TYPE, pointed to in GDB by VALADDR,
455 print_floating (valaddr
, type
, stream
)
462 unsigned len
= TYPE_LENGTH (type
);
464 #if defined (IEEE_FLOAT)
466 /* Check for NaN's. Note that this code does not depend on us being
467 on an IEEE conforming system. It only depends on the target
468 machine using IEEE representation. This means (a)
469 cross-debugging works right, and (2) IEEE_FLOAT can (and should)
470 be defined for systems like the 68881, which uses IEEE
471 representation, but is not IEEE conforming. */
474 unsigned long low
, high
;
475 /* Is the sign bit 0? */
477 /* Is it is a NaN (i.e. the exponent is all ones and
478 the fraction is nonzero)? */
483 /* It's single precision. */
484 /* Assume that floating point byte order is the same as
485 integer byte order. */
486 low
= extract_unsigned_integer (valaddr
, 4);
487 nonnegative
= ((low
& 0x80000000) == 0);
488 is_nan
= ((((low
>> 23) & 0xFF) == 0xFF)
489 && 0 != (low
& 0x7FFFFF));
495 /* It's double precision. Get the high and low words. */
497 /* Assume that floating point byte order is the same as
498 integer byte order. */
499 #if TARGET_BYTE_ORDER == BIG_ENDIAN
500 low
= extract_unsigned_integer (valaddr
+ 4, 4);
501 high
= extract_unsigned_integer (valaddr
, 4);
503 low
= extract_unsigned_integer (valaddr
, 4);
504 high
= extract_unsigned_integer (valaddr
+ 4, 4);
506 nonnegative
= ((high
& 0x80000000) == 0);
507 is_nan
= (((high
>> 20) & 0x7ff) == 0x7ff
508 && ! ((((high
& 0xfffff) == 0)) && (low
== 0)));
512 /* Extended. We can't detect NaNs for extendeds yet. Also note
513 that currently extendeds get nuked to double in
514 REGISTER_CONVERTIBLE. */
519 /* The meaning of the sign and fraction is not defined by IEEE.
520 But the user might know what they mean. For example, they
521 (in an implementation-defined manner) distinguish between
522 signaling and quiet NaN's. */
524 fprintf_filtered (stream
, "-NaN(0x%lx%.8lx)" + nonnegative
,
527 fprintf_filtered (stream
, "-NaN(0x%lx)" + nonnegative
, low
);
531 #endif /* IEEE_FLOAT. */
533 doub
= unpack_double (type
, valaddr
, &inv
);
535 fprintf_filtered (stream
, "<invalid float value>");
537 fprintf_filtered (stream
, len
<= sizeof(float) ? "%.9g" : "%.17g", doub
);
540 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
543 print_hex_chars (stream
, valaddr
, len
)
545 unsigned char *valaddr
;
550 /* FIXME: We should be not printing leading zeroes in most cases. */
552 fprintf_filtered (stream
, local_hex_format_prefix ());
553 #if TARGET_BYTE_ORDER == BIG_ENDIAN
557 #else /* Little endian. */
558 for (p
= valaddr
+ len
- 1;
563 fprintf_filtered (stream
, "%02x", *p
);
565 fprintf_filtered (stream
, local_hex_format_suffix ());
568 /* Called by various <lang>_val_print routines to print elements of an
569 array in the form "<elem1>, <elem2>, <elem3>, ...".
571 (FIXME?) Assumes array element separator is a comma, which is correct
572 for all languages currently handled.
573 (FIXME?) Some languages have a notation for repeated array elements,
574 perhaps we should try to use that notation when appropriate.
578 val_print_array_elements (type
, valaddr
, address
, stream
, format
, deref_ref
,
587 enum val_prettyprint pretty
;
590 unsigned int things_printed
= 0;
592 struct type
*elttype
;
594 /* Position of the array element we are examining to see
595 whether it is repeated. */
597 /* Number of repetitions we have detected so far. */
600 elttype
= TYPE_TARGET_TYPE (type
);
601 eltlen
= TYPE_LENGTH (elttype
);
602 len
= TYPE_LENGTH (type
) / eltlen
;
604 for (; i
< len
&& things_printed
< print_max
; i
++)
608 if (prettyprint_arrays
)
610 fprintf_filtered (stream
, ",\n");
611 print_spaces_filtered (2 + 2 * recurse
, stream
);
615 fprintf_filtered (stream
, ", ");
618 wrap_here (n_spaces (2 + 2 * recurse
));
622 while ((rep1
< len
) &&
623 !memcmp (valaddr
+ i
* eltlen
, valaddr
+ rep1
* eltlen
, eltlen
))
629 if (annotation_level
> 1)
631 printf_filtered ("\n\032\032array-element-begin %d ", i
);
632 print_value_flags (elttype
);
633 printf_filtered ("\n");
636 if (reps
> repeat_count_threshold
)
638 val_print (elttype
, valaddr
+ i
* eltlen
, 0, stream
, format
,
639 deref_ref
, recurse
+ 1, pretty
);
640 fprintf_filtered (stream
, " <repeats %u times>", reps
);
642 things_printed
+= repeat_count_threshold
;
646 val_print (elttype
, valaddr
+ i
* eltlen
, 0, stream
, format
,
647 deref_ref
, recurse
+ 1, pretty
);
650 if (annotation_level
> 1)
651 printf_filtered ("\n\032\032array-element-end\n");
655 fprintf_filtered (stream
, "...");
660 value_print_array_elements (val
, stream
, format
, pretty
)
664 enum val_prettyprint pretty
;
666 unsigned int things_printed
= 0;
667 register unsigned int i
, n
, typelen
;
668 /* Position of the array elem we are examining to see if it is repeated. */
670 /* Number of repetitions we have detected so far. */
673 n
= VALUE_REPETITIONS (val
);
674 typelen
= TYPE_LENGTH (VALUE_TYPE (val
));
675 for (i
= 0; i
< n
&& things_printed
< print_max
; i
++)
679 fprintf_filtered (stream
, ", ");
685 while (rep1
< n
&& !memcmp (VALUE_CONTENTS (val
) + typelen
* i
,
686 VALUE_CONTENTS (val
) + typelen
* rep1
,
693 if (reps
> repeat_count_threshold
)
695 val_print (VALUE_TYPE (val
), VALUE_CONTENTS (val
) + typelen
* i
,
696 VALUE_ADDRESS (val
) + typelen
* i
, stream
, format
, 1,
698 fprintf_unfiltered (stream
, " <repeats %u times>", reps
);
700 things_printed
+= repeat_count_threshold
;
704 val_print (VALUE_TYPE (val
), VALUE_CONTENTS (val
) + typelen
* i
,
705 VALUE_ADDRESS (val
) + typelen
* i
, stream
, format
, 1,
712 fprintf_filtered (stream
, "...");
716 /* Print a string from the inferior, starting at ADDR and printing up to LEN
717 characters, to STREAM. If LEN is zero, printing stops at the first null
718 byte, otherwise printing proceeds (including null bytes) until either
719 print_max or LEN characters have been printed, whichever is smaller. */
721 /* FIXME: All callers supply LEN of zero. Supplying a non-zero LEN is
722 pointless, this routine just then becomes a convoluted version of
723 target_read_memory_partial. Removing all the LEN stuff would simplify
724 this routine enormously.
726 FIXME: Use target_read_string. */
729 val_print_string (addr
, len
, stream
)
734 int force_ellipsis
= 0; /* Force ellipsis to be printed if nonzero. */
735 int errcode
; /* Errno returned from bad reads. */
736 unsigned int fetchlimit
; /* Maximum number of bytes to fetch. */
737 unsigned int nfetch
; /* Bytes to fetch / bytes fetched. */
738 unsigned int chunksize
; /* Size of each fetch, in bytes. */
739 int bufsize
; /* Size of current fetch buffer. */
740 char *buffer
= NULL
; /* Dynamically growable fetch buffer. */
741 char *bufptr
; /* Pointer to next available byte in buffer. */
742 char *limit
; /* First location past end of fetch buffer. */
743 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
744 char peekchar
; /* Place into which we can read one char. */
746 /* First we need to figure out the limit on the number of characters we are
747 going to attempt to fetch and print. This is actually pretty simple. If
748 LEN is nonzero, then the limit is the minimum of LEN and print_max. If
749 LEN is zero, then the limit is print_max. This is true regardless of
750 whether print_max is zero, UINT_MAX (unlimited), or something in between,
751 because finding the null byte (or available memory) is what actually
754 fetchlimit
= (len
== 0 ? print_max
: min (len
, print_max
));
756 /* Now decide how large of chunks to try to read in one operation. This
757 is also pretty simple. If LEN is nonzero, then we want fetchlimit bytes,
758 so we might as well read them all in one operation. If LEN is zero, we
759 are looking for a null terminator to end the fetching, so we might as
760 well read in blocks that are large enough to be efficient, but not so
761 large as to be slow if fetchlimit happens to be large. So we choose the
762 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
763 200 is way too big for remote debugging over a serial line. */
765 chunksize
= (len
== 0 ? min (8, fetchlimit
) : fetchlimit
);
767 /* Loop until we either have all the characters to print, or we encounter
768 some error, such as bumping into the end of the address space. */
773 /* Figure out how much to fetch this time, and grow the buffer to fit. */
774 nfetch
= min (chunksize
, fetchlimit
- bufsize
);
778 buffer
= (char *) xmalloc (bufsize
);
783 discard_cleanups (old_chain
);
784 buffer
= (char *) xrealloc (buffer
, bufsize
);
785 bufptr
= buffer
+ bufsize
- nfetch
;
787 old_chain
= make_cleanup (free
, buffer
);
789 /* Read as much as we can. */
790 nfetch
= target_read_memory_partial (addr
, bufptr
, nfetch
, &errcode
);
798 /* Scan this chunk for the null byte that terminates the string
799 to print. If found, we don't need to fetch any more. Note
800 that bufptr is explicitly left pointing at the next character
801 after the null byte, or at the next character after the end of
803 limit
= bufptr
+ nfetch
;
804 while (bufptr
< limit
)
808 if (bufptr
[-1] == '\0')
810 /* We don't care about any error which happened after
811 the NULL terminator. */
817 } while (errcode
== 0 /* no error */
818 && bufsize
< fetchlimit
/* no overrun */
819 && !(len
== 0 && *(bufptr
- 1) == '\0')); /* no null term */
821 /* bufptr and addr now point immediately beyond the last byte which we
822 consider part of the string (including a '\0' which ends the string). */
824 /* We now have either successfully filled the buffer to fetchlimit, or
825 terminated early due to an error or finding a null byte when LEN is
828 if (len
== 0 && bufptr
> buffer
&& *(bufptr
- 1) != '\0')
830 /* We didn't find a null terminator we were looking for. Attempt
831 to peek at the next character. If not successful, or it is not
832 a null byte, then force ellipsis to be printed. */
833 if (target_read_memory (addr
, &peekchar
, 1) != 0 || peekchar
!= '\0')
838 else if ((len
!= 0 && errcode
!= 0) || (len
> bufptr
- buffer
))
840 /* Getting an error when we have a requested length, or fetching less
841 than the number of characters actually requested, always make us
848 /* If we get an error before fetching anything, don't print a string.
849 But if we fetch something and then get an error, print the string
850 and then the error message. */
851 if (errcode
== 0 || bufptr
> buffer
)
855 fputs_filtered (" ", stream
);
857 LA_PRINT_STRING (stream
, buffer
, bufptr
- buffer
, force_ellipsis
);
864 fprintf_filtered (stream
, " <Address ");
865 print_address_numeric (addr
, stream
);
866 fprintf_filtered (stream
, " out of bounds>");
870 fprintf_filtered (stream
, " <Error reading address ");
871 print_address_numeric (addr
, stream
);
872 fprintf_filtered (stream
, ": %s>", safe_strerror (errcode
));
876 do_cleanups (old_chain
);
877 return (bufptr
- buffer
);
881 /* Validate an input or output radix setting, and make sure the user
882 knows what they really did here. Radix setting is confusing, e.g.
883 setting the input radix to "10" never changes it! */
887 set_input_radix (args
, from_tty
, c
)
890 struct cmd_list_element
*c
;
892 set_input_radix_1 (from_tty
, *(unsigned *)c
->var
);
897 set_input_radix_1 (from_tty
, radix
)
901 /* We don't currently disallow any input radix except 0 or 1, which don't
902 make any mathematical sense. In theory, we can deal with any input
903 radix greater than 1, even if we don't have unique digits for every
904 value from 0 to radix-1, but in practice we lose on large radix values.
905 We should either fix the lossage or restrict the radix range more.
910 error ("Nonsense input radix ``decimal %u''; input radix unchanged.",
916 printf_filtered ("Input radix now set to decimal %u, hex %x, octal %o.\n",
917 radix
, radix
, radix
);
923 set_output_radix (args
, from_tty
, c
)
926 struct cmd_list_element
*c
;
928 set_output_radix_1 (from_tty
, *(unsigned *)c
->var
);
932 set_output_radix_1 (from_tty
, radix
)
936 /* Validate the radix and disallow ones that we aren't prepared to
937 handle correctly, leaving the radix unchanged. */
941 output_format
= 'x'; /* hex */
944 output_format
= 0; /* decimal */
947 output_format
= 'o'; /* octal */
950 error ("Unsupported output radix ``decimal %u''; output radix unchanged.",
953 output_radix
= radix
;
956 printf_filtered ("Output radix now set to decimal %u, hex %x, octal %o.\n",
957 radix
, radix
, radix
);
961 /* Set both the input and output radix at once. Try to set the output radix
962 first, since it has the most restrictive range. An radix that is valid as
963 an output radix is also valid as an input radix.
965 It may be useful to have an unusual input radix. If the user wishes to
966 set an input radix that is not valid as an output radix, he needs to use
967 the 'set input-radix' command. */
970 set_radix (arg
, from_tty
)
976 radix
= (arg
== NULL
) ? 10 : parse_and_eval_address (arg
);
977 set_output_radix_1 (0, radix
);
978 set_input_radix_1 (0, radix
);
981 printf_filtered ("Input and output radices now set to decimal %u, hex %x, octal %o.\n",
982 radix
, radix
, radix
);
986 /* Show both the input and output radices. */
990 show_radix (arg
, from_tty
)
996 if (input_radix
== output_radix
)
998 printf_filtered ("Input and output radices set to decimal %u, hex %x, octal %o.\n",
999 input_radix
, input_radix
, input_radix
);
1003 printf_filtered ("Input radix set to decimal %u, hex %x, octal %o.\n",
1004 input_radix
, input_radix
, input_radix
);
1005 printf_filtered ("Output radix set to decimal %u, hex %x, octal %o.\n",
1006 output_radix
, output_radix
, output_radix
);
1014 set_print (arg
, from_tty
)
1019 "\"set print\" must be followed by the name of a print subcommand.\n");
1020 help_list (setprintlist
, "set print ", -1, gdb_stdout
);
1025 show_print (args
, from_tty
)
1029 cmd_show_list (showprintlist
, from_tty
, "");
1033 _initialize_valprint ()
1035 struct cmd_list_element
*c
;
1037 add_prefix_cmd ("print", no_class
, set_print
,
1038 "Generic command for setting how things print.",
1039 &setprintlist
, "set print ", 0, &setlist
);
1040 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
1041 /* prefer set print to set prompt */
1042 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
);
1044 add_prefix_cmd ("print", no_class
, show_print
,
1045 "Generic command for showing print settings.",
1046 &showprintlist
, "show print ", 0, &showlist
);
1047 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
1048 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
1051 (add_set_cmd ("elements", no_class
, var_uinteger
, (char *)&print_max
,
1052 "Set limit on string chars or array elements to print.\n\
1053 \"set print elements 0\" causes there to be no limit.",
1058 (add_set_cmd ("repeats", no_class
, var_uinteger
,
1059 (char *)&repeat_count_threshold
,
1060 "Set threshold for repeated print elements.\n\
1061 \"set print repeats 0\" causes all elements to be individually printed.",
1066 (add_set_cmd ("pretty", class_support
, var_boolean
,
1067 (char *)&prettyprint_structs
,
1068 "Set prettyprinting of structures.",
1073 (add_set_cmd ("union", class_support
, var_boolean
, (char *)&unionprint
,
1074 "Set printing of unions interior to structures.",
1079 (add_set_cmd ("array", class_support
, var_boolean
,
1080 (char *)&prettyprint_arrays
,
1081 "Set prettyprinting of arrays.",
1086 (add_set_cmd ("address", class_support
, var_boolean
, (char *)&addressprint
,
1087 "Set printing of addresses.",
1091 c
= add_set_cmd ("input-radix", class_support
, var_uinteger
,
1092 (char *)&input_radix
,
1093 "Set default input radix for entering numbers.",
1095 add_show_from_set (c
, &showlist
);
1096 c
->function
.sfunc
= set_input_radix
;
1098 c
= add_set_cmd ("output-radix", class_support
, var_uinteger
,
1099 (char *)&output_radix
,
1100 "Set default output radix for printing of values.",
1102 add_show_from_set (c
, &showlist
);
1103 c
->function
.sfunc
= set_output_radix
;
1105 /* The "set radix" and "show radix" commands are special in that they are
1106 like normal set and show commands but allow two normally independent
1107 variables to be either set or shown with a single command. So the
1108 usual add_set_cmd() and add_show_from_set() commands aren't really
1110 add_cmd ("radix", class_support
, set_radix
,
1111 "Set default input and output number radices.\n\
1112 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
1113 Without an argument, sets both radices back to the default value of 10.",
1115 add_cmd ("radix", class_support
, show_radix
,
1116 "Show the default input and output number radices.\n\
1117 Use 'show input-radix' or 'show output-radix' to independently show each.",
1120 /* Give people the defaults which they are used to. */
1121 prettyprint_structs
= 0;
1122 prettyprint_arrays
= 0;
1125 print_max
= PRINT_MAX_DEFAULT
;