1 /* Print values for GDB, the GNU debugger.
3 Copyright (C) 1986, 1988-2012 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "gdb_string.h"
31 #include "floatformat.h"
33 #include "exceptions.h"
35 #include "python/python.h"
37 #include "gdb_obstack.h"
43 /* Prototypes for local functions */
45 static int partial_memory_read (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
46 int len
, int *errnoptr
);
48 static void show_print (char *, int);
50 static void set_print (char *, int);
52 static void set_radix (char *, int);
54 static void show_radix (char *, int);
56 static void set_input_radix (char *, int, struct cmd_list_element
*);
58 static void set_input_radix_1 (int, unsigned);
60 static void set_output_radix (char *, int, struct cmd_list_element
*);
62 static void set_output_radix_1 (int, unsigned);
64 void _initialize_valprint (void);
66 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
68 struct value_print_options user_print_options
=
70 Val_pretty_default
, /* pretty */
71 0, /* prettyprint_arrays */
72 0, /* prettyprint_structs */
77 PRINT_MAX_DEFAULT
, /* print_max */
78 10, /* repeat_count_threshold */
79 0, /* output_format */
81 0, /* stop_print_at_null */
83 0, /* print_array_indexes */
85 1, /* static_field_print */
86 1, /* pascal_static_field_print */
91 /* Initialize *OPTS to be a copy of the user print options. */
93 get_user_print_options (struct value_print_options
*opts
)
95 *opts
= user_print_options
;
98 /* Initialize *OPTS to be a copy of the user print options, but with
99 pretty-printing disabled. */
101 get_raw_print_options (struct value_print_options
*opts
)
103 *opts
= user_print_options
;
104 opts
->pretty
= Val_no_prettyprint
;
107 /* Initialize *OPTS to be a copy of the user print options, but using
108 FORMAT as the formatting option. */
110 get_formatted_print_options (struct value_print_options
*opts
,
113 *opts
= user_print_options
;
114 opts
->format
= format
;
118 show_print_max (struct ui_file
*file
, int from_tty
,
119 struct cmd_list_element
*c
, const char *value
)
121 fprintf_filtered (file
,
122 _("Limit on string chars or array "
123 "elements to print is %s.\n"),
128 /* Default input and output radixes, and output format letter. */
130 unsigned input_radix
= 10;
132 show_input_radix (struct ui_file
*file
, int from_tty
,
133 struct cmd_list_element
*c
, const char *value
)
135 fprintf_filtered (file
,
136 _("Default input radix for entering numbers is %s.\n"),
140 unsigned output_radix
= 10;
142 show_output_radix (struct ui_file
*file
, int from_tty
,
143 struct cmd_list_element
*c
, const char *value
)
145 fprintf_filtered (file
,
146 _("Default output radix for printing of values is %s.\n"),
150 /* By default we print arrays without printing the index of each element in
151 the array. This behavior can be changed by setting PRINT_ARRAY_INDEXES. */
154 show_print_array_indexes (struct ui_file
*file
, int from_tty
,
155 struct cmd_list_element
*c
, const char *value
)
157 fprintf_filtered (file
, _("Printing of array indexes is %s.\n"), value
);
160 /* Print repeat counts if there are more than this many repetitions of an
161 element in an array. Referenced by the low level language dependent
165 show_repeat_count_threshold (struct ui_file
*file
, int from_tty
,
166 struct cmd_list_element
*c
, const char *value
)
168 fprintf_filtered (file
, _("Threshold for repeated print elements is %s.\n"),
172 /* If nonzero, stops printing of char arrays at first null. */
175 show_stop_print_at_null (struct ui_file
*file
, int from_tty
,
176 struct cmd_list_element
*c
, const char *value
)
178 fprintf_filtered (file
,
179 _("Printing of char arrays to stop "
180 "at first null char is %s.\n"),
184 /* Controls pretty printing of structures. */
187 show_prettyprint_structs (struct ui_file
*file
, int from_tty
,
188 struct cmd_list_element
*c
, const char *value
)
190 fprintf_filtered (file
, _("Prettyprinting of structures is %s.\n"), value
);
193 /* Controls pretty printing of arrays. */
196 show_prettyprint_arrays (struct ui_file
*file
, int from_tty
,
197 struct cmd_list_element
*c
, const char *value
)
199 fprintf_filtered (file
, _("Prettyprinting of arrays is %s.\n"), value
);
202 /* If nonzero, causes unions inside structures or other unions to be
206 show_unionprint (struct ui_file
*file
, int from_tty
,
207 struct cmd_list_element
*c
, const char *value
)
209 fprintf_filtered (file
,
210 _("Printing of unions interior to structures is %s.\n"),
214 /* If nonzero, causes machine addresses to be printed in certain contexts. */
217 show_addressprint (struct ui_file
*file
, int from_tty
,
218 struct cmd_list_element
*c
, const char *value
)
220 fprintf_filtered (file
, _("Printing of addresses is %s.\n"), value
);
224 /* A helper function for val_print. When printing in "summary" mode,
225 we want to print scalar arguments, but not aggregate arguments.
226 This function distinguishes between the two. */
229 scalar_type_p (struct type
*type
)
231 CHECK_TYPEDEF (type
);
232 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
234 type
= TYPE_TARGET_TYPE (type
);
235 CHECK_TYPEDEF (type
);
237 switch (TYPE_CODE (type
))
239 case TYPE_CODE_ARRAY
:
240 case TYPE_CODE_STRUCT
:
241 case TYPE_CODE_UNION
:
243 case TYPE_CODE_STRING
:
244 case TYPE_CODE_BITSTRING
:
251 /* See its definition in value.h. */
254 valprint_check_validity (struct ui_file
*stream
,
257 const struct value
*val
)
259 CHECK_TYPEDEF (type
);
261 if (TYPE_CODE (type
) != TYPE_CODE_UNION
262 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
263 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
265 if (!value_bits_valid (val
, TARGET_CHAR_BIT
* embedded_offset
,
266 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
268 val_print_optimized_out (stream
);
272 if (value_bits_synthetic_pointer (val
, TARGET_CHAR_BIT
* embedded_offset
,
273 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
275 fputs_filtered (_("<synthetic pointer>"), stream
);
279 if (!value_bytes_available (val
, embedded_offset
, TYPE_LENGTH (type
)))
281 val_print_unavailable (stream
);
290 val_print_optimized_out (struct ui_file
*stream
)
292 fprintf_filtered (stream
, _("<optimized out>"));
296 val_print_unavailable (struct ui_file
*stream
)
298 fprintf_filtered (stream
, _("<unavailable>"));
302 val_print_invalid_address (struct ui_file
*stream
)
304 fprintf_filtered (stream
, _("<invalid address>"));
307 /* A generic val_print that is suitable for use by language
308 implementations of the la_val_print method. This function can
309 handle most type codes, though not all, notably exception
310 TYPE_CODE_UNION and TYPE_CODE_STRUCT, which must be implemented by
313 Most arguments are as to val_print.
315 The additional DECORATIONS argument can be used to customize the
316 output in some small, language-specific ways. */
319 generic_val_print (struct type
*type
, const gdb_byte
*valaddr
,
320 int embedded_offset
, CORE_ADDR address
,
321 struct ui_file
*stream
, int recurse
,
322 const struct value
*original_value
,
323 const struct value_print_options
*options
,
324 const struct generic_val_print_decorations
*decorations
)
326 struct gdbarch
*gdbarch
= get_type_arch (type
);
327 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
328 unsigned int i
= 0; /* Number of characters printed. */
330 struct type
*elttype
, *unresolved_elttype
;
331 struct type
*unresolved_type
= type
;
336 CHECK_TYPEDEF (type
);
337 switch (TYPE_CODE (type
))
339 case TYPE_CODE_ARRAY
:
340 unresolved_elttype
= TYPE_TARGET_TYPE (type
);
341 elttype
= check_typedef (unresolved_elttype
);
342 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (unresolved_elttype
) > 0)
344 LONGEST low_bound
, high_bound
;
346 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
347 error (_("Could not determine the array high bound"));
349 if (options
->prettyprint_arrays
)
351 print_spaces_filtered (2 + 2 * recurse
, stream
);
354 fprintf_filtered (stream
, "{");
355 val_print_array_elements (type
, valaddr
, embedded_offset
,
357 recurse
, original_value
, options
, 0);
358 fprintf_filtered (stream
, "}");
361 /* Array of unspecified length: treat like pointer to first
363 addr
= address
+ embedded_offset
;
364 goto print_unpacked_pointer
;
366 case TYPE_CODE_MEMBERPTR
:
367 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
368 original_value
, options
, 0, stream
);
372 if (options
->format
&& options
->format
!= 's')
374 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
375 original_value
, options
, 0, stream
);
378 unresolved_elttype
= TYPE_TARGET_TYPE (type
);
379 elttype
= check_typedef (unresolved_elttype
);
381 addr
= unpack_pointer (type
, valaddr
+ embedded_offset
);
382 print_unpacked_pointer
:
384 if (TYPE_CODE (elttype
) == TYPE_CODE_FUNC
)
386 /* Try to print what function it points to. */
387 print_function_pointer_address (options
, gdbarch
, addr
, stream
);
391 if (options
->addressprint
)
392 fputs_filtered (paddress (gdbarch
, addr
), stream
);
397 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
398 if (options
->addressprint
)
401 = extract_typed_address (valaddr
+ embedded_offset
, type
);
403 fprintf_filtered (stream
, "@");
404 fputs_filtered (paddress (gdbarch
, addr
), stream
);
405 if (options
->deref_ref
)
406 fputs_filtered (": ", stream
);
408 /* De-reference the reference. */
409 if (options
->deref_ref
)
411 if (TYPE_CODE (elttype
) != TYPE_CODE_UNDEF
)
413 struct value
*deref_val
;
415 deref_val
= coerce_ref_if_computed (original_value
);
416 if (deref_val
!= NULL
)
418 /* More complicated computed references are not supported. */
419 gdb_assert (embedded_offset
== 0);
422 deref_val
= value_at (TYPE_TARGET_TYPE (type
),
423 unpack_pointer (type
,
425 + embedded_offset
)));
427 common_val_print (deref_val
, stream
, recurse
, options
,
431 fputs_filtered ("???", stream
);
438 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
439 original_value
, options
, 0, stream
);
442 len
= TYPE_NFIELDS (type
);
443 val
= unpack_long (type
, valaddr
+ embedded_offset
);
444 for (i
= 0; i
< len
; i
++)
447 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
454 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
456 else if (TYPE_FLAG_ENUM (type
))
460 /* We have a "flag" enum, so we try to decompose it into
461 pieces as appropriate. A flag enum has disjoint
462 constants by definition. */
463 fputs_filtered ("(", stream
);
464 for (i
= 0; i
< len
; ++i
)
468 if ((val
& TYPE_FIELD_ENUMVAL (type
, i
)) != 0)
471 fputs_filtered (" | ", stream
);
474 val
&= ~TYPE_FIELD_ENUMVAL (type
, i
);
475 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
479 if (first
|| val
!= 0)
482 fputs_filtered (" | ", stream
);
483 fputs_filtered ("unknown: ", stream
);
484 print_longest (stream
, 'd', 0, val
);
487 fputs_filtered (")", stream
);
490 print_longest (stream
, 'd', 0, val
);
493 case TYPE_CODE_FLAGS
:
495 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
496 original_value
, options
, 0, stream
);
498 val_print_type_code_flags (type
, valaddr
+ embedded_offset
,
503 case TYPE_CODE_METHOD
:
506 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
507 original_value
, options
, 0, stream
);
510 /* FIXME, we should consider, at least for ANSI C language,
511 eliminating the distinction made between FUNCs and POINTERs
513 fprintf_filtered (stream
, "{");
514 type_print (type
, "", stream
, -1);
515 fprintf_filtered (stream
, "} ");
516 /* Try to print what function it points to, and its address. */
517 print_address_demangle (options
, gdbarch
, address
, stream
, demangle
);
521 if (options
->format
|| options
->output_format
)
523 struct value_print_options opts
= *options
;
524 opts
.format
= (options
->format
? options
->format
525 : options
->output_format
);
526 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
527 original_value
, &opts
, 0, stream
);
531 val
= unpack_long (type
, valaddr
+ embedded_offset
);
533 fputs_filtered (decorations
->false_name
, stream
);
535 fputs_filtered (decorations
->true_name
, stream
);
537 print_longest (stream
, 'd', 0, val
);
541 case TYPE_CODE_RANGE
:
542 /* FIXME: create_range_type does not set the unsigned bit in a
543 range type (I think it probably should copy it from the
544 target type), so we won't print values which are too large to
545 fit in a signed integer correctly. */
546 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
547 print with the target type, though, because the size of our
548 type and the target type might differ). */
553 if (options
->format
|| options
->output_format
)
555 struct value_print_options opts
= *options
;
557 opts
.format
= (options
->format
? options
->format
558 : options
->output_format
);
559 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
560 original_value
, &opts
, 0, stream
);
563 val_print_type_code_int (type
, valaddr
+ embedded_offset
, stream
);
567 if (options
->format
|| options
->output_format
)
569 struct value_print_options opts
= *options
;
571 opts
.format
= (options
->format
? options
->format
572 : options
->output_format
);
573 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
574 original_value
, &opts
, 0, stream
);
578 val
= unpack_long (type
, valaddr
+ embedded_offset
);
579 if (TYPE_UNSIGNED (type
))
580 fprintf_filtered (stream
, "%u", (unsigned int) val
);
582 fprintf_filtered (stream
, "%d", (int) val
);
583 fputs_filtered (" ", stream
);
584 LA_PRINT_CHAR (val
, unresolved_type
, stream
);
591 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
592 original_value
, options
, 0, stream
);
596 print_floating (valaddr
+ embedded_offset
, type
, stream
);
600 case TYPE_CODE_DECFLOAT
:
602 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
603 original_value
, options
, 0, stream
);
605 print_decimal_floating (valaddr
+ embedded_offset
,
610 fputs_filtered (decorations
->void_name
, stream
);
613 case TYPE_CODE_ERROR
:
614 fprintf_filtered (stream
, "%s", TYPE_ERROR_NAME (type
));
617 case TYPE_CODE_UNDEF
:
618 /* This happens (without TYPE_FLAG_STUB set) on systems which
619 don't use dbx xrefs (NO_DBX_XREFS in gcc) if a file has a
620 "struct foo *bar" and no complete type for struct foo in that
622 fprintf_filtered (stream
, _("<incomplete type>"));
625 case TYPE_CODE_COMPLEX
:
626 fprintf_filtered (stream
, "%s", decorations
->complex_prefix
);
628 val_print_scalar_formatted (TYPE_TARGET_TYPE (type
),
629 valaddr
, embedded_offset
,
630 original_value
, options
, 0, stream
);
632 print_floating (valaddr
+ embedded_offset
,
633 TYPE_TARGET_TYPE (type
),
635 fprintf_filtered (stream
, "%s", decorations
->complex_infix
);
637 val_print_scalar_formatted (TYPE_TARGET_TYPE (type
),
640 + TYPE_LENGTH (TYPE_TARGET_TYPE (type
)),
644 print_floating (valaddr
+ embedded_offset
645 + TYPE_LENGTH (TYPE_TARGET_TYPE (type
)),
646 TYPE_TARGET_TYPE (type
),
648 fprintf_filtered (stream
, "%s", decorations
->complex_suffix
);
651 case TYPE_CODE_UNION
:
652 case TYPE_CODE_STRUCT
:
653 case TYPE_CODE_METHODPTR
:
655 error (_("Unhandled type code %d in symbol table."),
661 /* Print using the given LANGUAGE the data of type TYPE located at
662 VALADDR + EMBEDDED_OFFSET (within GDB), which came from the
663 inferior at address ADDRESS + EMBEDDED_OFFSET, onto stdio stream
664 STREAM according to OPTIONS. VAL is the whole object that came
665 from ADDRESS. VALADDR must point to the head of VAL's contents
668 The language printers will pass down an adjusted EMBEDDED_OFFSET to
669 further helper subroutines as subfields of TYPE are printed. In
670 such cases, VALADDR is passed down unadjusted, as well as VAL, so
671 that VAL can be queried for metadata about the contents data being
672 printed, using EMBEDDED_OFFSET as an offset into VAL's contents
673 buffer. For example: "has this field been optimized out", or "I'm
674 printing an object while inspecting a traceframe; has this
675 particular piece of data been collected?".
677 RECURSE indicates the amount of indentation to supply before
678 continuation lines; this amount is roughly twice the value of
682 val_print (struct type
*type
, const gdb_byte
*valaddr
, int embedded_offset
,
683 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
684 const struct value
*val
,
685 const struct value_print_options
*options
,
686 const struct language_defn
*language
)
688 volatile struct gdb_exception except
;
690 struct value_print_options local_opts
= *options
;
691 struct type
*real_type
= check_typedef (type
);
693 if (local_opts
.pretty
== Val_pretty_default
)
694 local_opts
.pretty
= (local_opts
.prettyprint_structs
695 ? Val_prettyprint
: Val_no_prettyprint
);
699 /* Ensure that the type is complete and not just a stub. If the type is
700 only a stub and we can't find and substitute its complete type, then
701 print appropriate string and return. */
703 if (TYPE_STUB (real_type
))
705 fprintf_filtered (stream
, _("<incomplete type>"));
710 if (!valprint_check_validity (stream
, real_type
, embedded_offset
, val
))
715 ret
= apply_val_pretty_printer (type
, valaddr
, embedded_offset
,
716 address
, stream
, recurse
,
717 val
, options
, language
);
722 /* Handle summary mode. If the value is a scalar, print it;
723 otherwise, print an ellipsis. */
724 if (options
->summary
&& !scalar_type_p (type
))
726 fprintf_filtered (stream
, "...");
730 TRY_CATCH (except
, RETURN_MASK_ERROR
)
732 language
->la_val_print (type
, valaddr
, embedded_offset
, address
,
733 stream
, recurse
, val
,
736 if (except
.reason
< 0)
737 fprintf_filtered (stream
, _("<error reading variable>"));
740 /* Check whether the value VAL is printable. Return 1 if it is;
741 return 0 and print an appropriate error message to STREAM according to
742 OPTIONS if it is not. */
745 value_check_printable (struct value
*val
, struct ui_file
*stream
,
746 const struct value_print_options
*options
)
750 fprintf_filtered (stream
, _("<address of value unknown>"));
754 if (value_entirely_optimized_out (val
))
756 if (options
->summary
&& !scalar_type_p (value_type (val
)))
757 fprintf_filtered (stream
, "...");
759 val_print_optimized_out (stream
);
763 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INTERNAL_FUNCTION
)
765 fprintf_filtered (stream
, _("<internal function %s>"),
766 value_internal_function_name (val
));
773 /* Print using the given LANGUAGE the value VAL onto stream STREAM according
776 This is a preferable interface to val_print, above, because it uses
777 GDB's value mechanism. */
780 common_val_print (struct value
*val
, struct ui_file
*stream
, int recurse
,
781 const struct value_print_options
*options
,
782 const struct language_defn
*language
)
784 if (!value_check_printable (val
, stream
, options
))
787 if (language
->la_language
== language_ada
)
788 /* The value might have a dynamic type, which would cause trouble
789 below when trying to extract the value contents (since the value
790 size is determined from the type size which is unknown). So
791 get a fixed representation of our value. */
792 val
= ada_to_fixed_value (val
);
794 val_print (value_type (val
), value_contents_for_printing (val
),
795 value_embedded_offset (val
), value_address (val
),
797 val
, options
, language
);
800 /* Print on stream STREAM the value VAL according to OPTIONS. The value
801 is printed using the current_language syntax. */
804 value_print (struct value
*val
, struct ui_file
*stream
,
805 const struct value_print_options
*options
)
807 if (!value_check_printable (val
, stream
, options
))
812 int r
= apply_val_pretty_printer (value_type (val
),
813 value_contents_for_printing (val
),
814 value_embedded_offset (val
),
817 val
, options
, current_language
);
823 LA_VALUE_PRINT (val
, stream
, options
);
826 /* Called by various <lang>_val_print routines to print
827 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
828 value. STREAM is where to print the value. */
831 val_print_type_code_int (struct type
*type
, const gdb_byte
*valaddr
,
832 struct ui_file
*stream
)
834 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
836 if (TYPE_LENGTH (type
) > sizeof (LONGEST
))
840 if (TYPE_UNSIGNED (type
)
841 && extract_long_unsigned_integer (valaddr
, TYPE_LENGTH (type
),
844 print_longest (stream
, 'u', 0, val
);
848 /* Signed, or we couldn't turn an unsigned value into a
849 LONGEST. For signed values, one could assume two's
850 complement (a reasonable assumption, I think) and do
852 print_hex_chars (stream
, (unsigned char *) valaddr
,
853 TYPE_LENGTH (type
), byte_order
);
858 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0,
859 unpack_long (type
, valaddr
));
864 val_print_type_code_flags (struct type
*type
, const gdb_byte
*valaddr
,
865 struct ui_file
*stream
)
867 ULONGEST val
= unpack_long (type
, valaddr
);
868 int bitpos
, nfields
= TYPE_NFIELDS (type
);
870 fputs_filtered ("[ ", stream
);
871 for (bitpos
= 0; bitpos
< nfields
; bitpos
++)
873 if (TYPE_FIELD_BITPOS (type
, bitpos
) != -1
874 && (val
& ((ULONGEST
)1 << bitpos
)))
876 if (TYPE_FIELD_NAME (type
, bitpos
))
877 fprintf_filtered (stream
, "%s ", TYPE_FIELD_NAME (type
, bitpos
));
879 fprintf_filtered (stream
, "#%d ", bitpos
);
882 fputs_filtered ("]", stream
);
885 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
886 according to OPTIONS and SIZE on STREAM. Format i is not supported
889 This is how the elements of an array or structure are printed
893 val_print_scalar_formatted (struct type
*type
,
894 const gdb_byte
*valaddr
, int embedded_offset
,
895 const struct value
*val
,
896 const struct value_print_options
*options
,
898 struct ui_file
*stream
)
900 gdb_assert (val
!= NULL
);
901 gdb_assert (valaddr
== value_contents_for_printing_const (val
));
903 /* If we get here with a string format, try again without it. Go
904 all the way back to the language printers, which may call us
906 if (options
->format
== 's')
908 struct value_print_options opts
= *options
;
911 val_print (type
, valaddr
, embedded_offset
, 0, stream
, 0, val
, &opts
,
916 /* A scalar object that does not have all bits available can't be
917 printed, because all bits contribute to its representation. */
918 if (!value_bits_valid (val
, TARGET_CHAR_BIT
* embedded_offset
,
919 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
920 val_print_optimized_out (stream
);
921 else if (!value_bytes_available (val
, embedded_offset
, TYPE_LENGTH (type
)))
922 val_print_unavailable (stream
);
924 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
925 options
, size
, stream
);
928 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
929 The raison d'etre of this function is to consolidate printing of
930 LONG_LONG's into this one function. The format chars b,h,w,g are
931 from print_scalar_formatted(). Numbers are printed using C
934 USE_C_FORMAT means to use C format in all cases. Without it,
935 'o' and 'x' format do not include the standard C radix prefix
938 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
939 and was intended to request formating according to the current
940 language and would be used for most integers that GDB prints. The
941 exceptional cases were things like protocols where the format of
942 the integer is a protocol thing, not a user-visible thing). The
943 parameter remains to preserve the information of what things might
944 be printed with language-specific format, should we ever resurrect
948 print_longest (struct ui_file
*stream
, int format
, int use_c_format
,
956 val
= int_string (val_long
, 10, 1, 0, 1); break;
958 val
= int_string (val_long
, 10, 0, 0, 1); break;
960 val
= int_string (val_long
, 16, 0, 0, use_c_format
); break;
962 val
= int_string (val_long
, 16, 0, 2, 1); break;
964 val
= int_string (val_long
, 16, 0, 4, 1); break;
966 val
= int_string (val_long
, 16, 0, 8, 1); break;
968 val
= int_string (val_long
, 16, 0, 16, 1); break;
971 val
= int_string (val_long
, 8, 0, 0, use_c_format
); break;
973 internal_error (__FILE__
, __LINE__
,
974 _("failed internal consistency check"));
976 fputs_filtered (val
, stream
);
979 /* This used to be a macro, but I don't think it is called often enough
980 to merit such treatment. */
981 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
982 arguments to a function, number in a value history, register number, etc.)
983 where the value must not be larger than can fit in an int. */
986 longest_to_int (LONGEST arg
)
988 /* Let the compiler do the work. */
989 int rtnval
= (int) arg
;
991 /* Check for overflows or underflows. */
992 if (sizeof (LONGEST
) > sizeof (int))
996 error (_("Value out of range."));
1002 /* Print a floating point value of type TYPE (not always a
1003 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
1006 print_floating (const gdb_byte
*valaddr
, struct type
*type
,
1007 struct ui_file
*stream
)
1011 const struct floatformat
*fmt
= NULL
;
1012 unsigned len
= TYPE_LENGTH (type
);
1013 enum float_kind kind
;
1015 /* If it is a floating-point, check for obvious problems. */
1016 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1017 fmt
= floatformat_from_type (type
);
1020 kind
= floatformat_classify (fmt
, valaddr
);
1021 if (kind
== float_nan
)
1023 if (floatformat_is_negative (fmt
, valaddr
))
1024 fprintf_filtered (stream
, "-");
1025 fprintf_filtered (stream
, "nan(");
1026 fputs_filtered ("0x", stream
);
1027 fputs_filtered (floatformat_mantissa (fmt
, valaddr
), stream
);
1028 fprintf_filtered (stream
, ")");
1031 else if (kind
== float_infinite
)
1033 if (floatformat_is_negative (fmt
, valaddr
))
1034 fputs_filtered ("-", stream
);
1035 fputs_filtered ("inf", stream
);
1040 /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
1041 isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double
1042 needs to be used as that takes care of any necessary type
1043 conversions. Such conversions are of course direct to DOUBLEST
1044 and disregard any possible target floating point limitations.
1045 For instance, a u64 would be converted and displayed exactly on a
1046 host with 80 bit DOUBLEST but with loss of information on a host
1047 with 64 bit DOUBLEST. */
1049 doub
= unpack_double (type
, valaddr
, &inv
);
1052 fprintf_filtered (stream
, "<invalid float value>");
1056 /* FIXME: kettenis/2001-01-20: The following code makes too much
1057 assumptions about the host and target floating point format. */
1059 /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
1060 not necessarily be a TYPE_CODE_FLT, the below ignores that and
1061 instead uses the type's length to determine the precision of the
1062 floating-point value being printed. */
1064 if (len
< sizeof (double))
1065 fprintf_filtered (stream
, "%.9g", (double) doub
);
1066 else if (len
== sizeof (double))
1067 fprintf_filtered (stream
, "%.17g", (double) doub
);
1069 #ifdef PRINTF_HAS_LONG_DOUBLE
1070 fprintf_filtered (stream
, "%.35Lg", doub
);
1072 /* This at least wins with values that are representable as
1074 fprintf_filtered (stream
, "%.17g", (double) doub
);
1079 print_decimal_floating (const gdb_byte
*valaddr
, struct type
*type
,
1080 struct ui_file
*stream
)
1082 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
1083 char decstr
[MAX_DECIMAL_STRING
];
1084 unsigned len
= TYPE_LENGTH (type
);
1086 decimal_to_string (valaddr
, len
, byte_order
, decstr
);
1087 fputs_filtered (decstr
, stream
);
1092 print_binary_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1093 unsigned len
, enum bfd_endian byte_order
)
1096 #define BITS_IN_BYTES 8
1102 /* Declared "int" so it will be signed.
1103 This ensures that right shift will shift in zeros. */
1105 const int mask
= 0x080;
1107 /* FIXME: We should be not printing leading zeroes in most cases. */
1109 if (byte_order
== BFD_ENDIAN_BIG
)
1115 /* Every byte has 8 binary characters; peel off
1116 and print from the MSB end. */
1118 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
1120 if (*p
& (mask
>> i
))
1125 fprintf_filtered (stream
, "%1d", b
);
1131 for (p
= valaddr
+ len
- 1;
1135 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
1137 if (*p
& (mask
>> i
))
1142 fprintf_filtered (stream
, "%1d", b
);
1148 /* VALADDR points to an integer of LEN bytes.
1149 Print it in octal on stream or format it in buf. */
1152 print_octal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1153 unsigned len
, enum bfd_endian byte_order
)
1156 unsigned char octa1
, octa2
, octa3
, carry
;
1159 /* FIXME: We should be not printing leading zeroes in most cases. */
1162 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
1163 * the extra bits, which cycle every three bytes:
1165 * Byte side: 0 1 2 3
1167 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
1169 * Octal side: 0 1 carry 3 4 carry ...
1171 * Cycle number: 0 1 2
1173 * But of course we are printing from the high side, so we have to
1174 * figure out where in the cycle we are so that we end up with no
1175 * left over bits at the end.
1177 #define BITS_IN_OCTAL 3
1178 #define HIGH_ZERO 0340
1179 #define LOW_ZERO 0016
1180 #define CARRY_ZERO 0003
1181 #define HIGH_ONE 0200
1182 #define MID_ONE 0160
1183 #define LOW_ONE 0016
1184 #define CARRY_ONE 0001
1185 #define HIGH_TWO 0300
1186 #define MID_TWO 0070
1187 #define LOW_TWO 0007
1189 /* For 32 we start in cycle 2, with two bits and one bit carry;
1190 for 64 in cycle in cycle 1, with one bit and a two bit carry. */
1192 cycle
= (len
* BITS_IN_BYTES
) % BITS_IN_OCTAL
;
1195 fputs_filtered ("0", stream
);
1196 if (byte_order
== BFD_ENDIAN_BIG
)
1205 /* No carry in, carry out two bits. */
1207 octa1
= (HIGH_ZERO
& *p
) >> 5;
1208 octa2
= (LOW_ZERO
& *p
) >> 2;
1209 carry
= (CARRY_ZERO
& *p
);
1210 fprintf_filtered (stream
, "%o", octa1
);
1211 fprintf_filtered (stream
, "%o", octa2
);
1215 /* Carry in two bits, carry out one bit. */
1217 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
1218 octa2
= (MID_ONE
& *p
) >> 4;
1219 octa3
= (LOW_ONE
& *p
) >> 1;
1220 carry
= (CARRY_ONE
& *p
);
1221 fprintf_filtered (stream
, "%o", octa1
);
1222 fprintf_filtered (stream
, "%o", octa2
);
1223 fprintf_filtered (stream
, "%o", octa3
);
1227 /* Carry in one bit, no carry out. */
1229 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
1230 octa2
= (MID_TWO
& *p
) >> 3;
1231 octa3
= (LOW_TWO
& *p
);
1233 fprintf_filtered (stream
, "%o", octa1
);
1234 fprintf_filtered (stream
, "%o", octa2
);
1235 fprintf_filtered (stream
, "%o", octa3
);
1239 error (_("Internal error in octal conversion;"));
1243 cycle
= cycle
% BITS_IN_OCTAL
;
1248 for (p
= valaddr
+ len
- 1;
1255 /* Carry out, no carry in */
1257 octa1
= (HIGH_ZERO
& *p
) >> 5;
1258 octa2
= (LOW_ZERO
& *p
) >> 2;
1259 carry
= (CARRY_ZERO
& *p
);
1260 fprintf_filtered (stream
, "%o", octa1
);
1261 fprintf_filtered (stream
, "%o", octa2
);
1265 /* Carry in, carry out */
1267 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
1268 octa2
= (MID_ONE
& *p
) >> 4;
1269 octa3
= (LOW_ONE
& *p
) >> 1;
1270 carry
= (CARRY_ONE
& *p
);
1271 fprintf_filtered (stream
, "%o", octa1
);
1272 fprintf_filtered (stream
, "%o", octa2
);
1273 fprintf_filtered (stream
, "%o", octa3
);
1277 /* Carry in, no carry out */
1279 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
1280 octa2
= (MID_TWO
& *p
) >> 3;
1281 octa3
= (LOW_TWO
& *p
);
1283 fprintf_filtered (stream
, "%o", octa1
);
1284 fprintf_filtered (stream
, "%o", octa2
);
1285 fprintf_filtered (stream
, "%o", octa3
);
1289 error (_("Internal error in octal conversion;"));
1293 cycle
= cycle
% BITS_IN_OCTAL
;
1299 /* VALADDR points to an integer of LEN bytes.
1300 Print it in decimal on stream or format it in buf. */
1303 print_decimal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1304 unsigned len
, enum bfd_endian byte_order
)
1307 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
1308 #define CARRY_LEFT( x ) ((x) % TEN)
1309 #define SHIFT( x ) ((x) << 4)
1310 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
1311 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
1314 unsigned char *digits
;
1317 int i
, j
, decimal_digits
;
1321 /* Base-ten number is less than twice as many digits
1322 as the base 16 number, which is 2 digits per byte. */
1324 decimal_len
= len
* 2 * 2;
1325 digits
= xmalloc (decimal_len
);
1327 for (i
= 0; i
< decimal_len
; i
++)
1332 /* Ok, we have an unknown number of bytes of data to be printed in
1335 * Given a hex number (in nibbles) as XYZ, we start by taking X and
1336 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
1337 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
1339 * The trick is that "digits" holds a base-10 number, but sometimes
1340 * the individual digits are > 10.
1342 * Outer loop is per nibble (hex digit) of input, from MSD end to
1345 decimal_digits
= 0; /* Number of decimal digits so far */
1346 p
= (byte_order
== BFD_ENDIAN_BIG
) ? valaddr
: valaddr
+ len
- 1;
1348 while ((byte_order
== BFD_ENDIAN_BIG
) ? (p
< valaddr
+ len
) : (p
>= valaddr
))
1351 * Multiply current base-ten number by 16 in place.
1352 * Each digit was between 0 and 9, now is between
1355 for (j
= 0; j
< decimal_digits
; j
++)
1357 digits
[j
] = SHIFT (digits
[j
]);
1360 /* Take the next nibble off the input and add it to what
1361 * we've got in the LSB position. Bottom 'digit' is now
1362 * between 0 and 159.
1364 * "flip" is used to run this loop twice for each byte.
1368 /* Take top nibble. */
1370 digits
[0] += HIGH_NIBBLE (*p
);
1375 /* Take low nibble and bump our pointer "p". */
1377 digits
[0] += LOW_NIBBLE (*p
);
1378 if (byte_order
== BFD_ENDIAN_BIG
)
1385 /* Re-decimalize. We have to do this often enough
1386 * that we don't overflow, but once per nibble is
1387 * overkill. Easier this way, though. Note that the
1388 * carry is often larger than 10 (e.g. max initial
1389 * carry out of lowest nibble is 15, could bubble all
1390 * the way up greater than 10). So we have to do
1391 * the carrying beyond the last current digit.
1394 for (j
= 0; j
< decimal_len
- 1; j
++)
1398 /* "/" won't handle an unsigned char with
1399 * a value that if signed would be negative.
1400 * So extend to longword int via "dummy".
1403 carry
= CARRY_OUT (dummy
);
1404 digits
[j
] = CARRY_LEFT (dummy
);
1406 if (j
>= decimal_digits
&& carry
== 0)
1409 * All higher digits are 0 and we
1410 * no longer have a carry.
1412 * Note: "j" is 0-based, "decimal_digits" is
1415 decimal_digits
= j
+ 1;
1421 /* Ok, now "digits" is the decimal representation, with
1422 the "decimal_digits" actual digits. Print! */
1424 for (i
= decimal_digits
- 1; i
>= 0; i
--)
1426 fprintf_filtered (stream
, "%1d", digits
[i
]);
1431 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
1434 print_hex_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1435 unsigned len
, enum bfd_endian byte_order
)
1439 /* FIXME: We should be not printing leading zeroes in most cases. */
1441 fputs_filtered ("0x", stream
);
1442 if (byte_order
== BFD_ENDIAN_BIG
)
1448 fprintf_filtered (stream
, "%02x", *p
);
1453 for (p
= valaddr
+ len
- 1;
1457 fprintf_filtered (stream
, "%02x", *p
);
1462 /* VALADDR points to a char integer of LEN bytes.
1463 Print it out in appropriate language form on stream.
1464 Omit any leading zero chars. */
1467 print_char_chars (struct ui_file
*stream
, struct type
*type
,
1468 const gdb_byte
*valaddr
,
1469 unsigned len
, enum bfd_endian byte_order
)
1473 if (byte_order
== BFD_ENDIAN_BIG
)
1476 while (p
< valaddr
+ len
- 1 && *p
== 0)
1479 while (p
< valaddr
+ len
)
1481 LA_EMIT_CHAR (*p
, type
, stream
, '\'');
1487 p
= valaddr
+ len
- 1;
1488 while (p
> valaddr
&& *p
== 0)
1491 while (p
>= valaddr
)
1493 LA_EMIT_CHAR (*p
, type
, stream
, '\'');
1499 /* Print function pointer with inferior address ADDRESS onto stdio
1503 print_function_pointer_address (const struct value_print_options
*options
,
1504 struct gdbarch
*gdbarch
,
1506 struct ui_file
*stream
)
1509 = gdbarch_convert_from_func_ptr_addr (gdbarch
, address
,
1512 /* If the function pointer is represented by a description, print
1513 the address of the description. */
1514 if (options
->addressprint
&& func_addr
!= address
)
1516 fputs_filtered ("@", stream
);
1517 fputs_filtered (paddress (gdbarch
, address
), stream
);
1518 fputs_filtered (": ", stream
);
1520 print_address_demangle (options
, gdbarch
, func_addr
, stream
, demangle
);
1524 /* Print on STREAM using the given OPTIONS the index for the element
1525 at INDEX of an array whose index type is INDEX_TYPE. */
1528 maybe_print_array_index (struct type
*index_type
, LONGEST index
,
1529 struct ui_file
*stream
,
1530 const struct value_print_options
*options
)
1532 struct value
*index_value
;
1534 if (!options
->print_array_indexes
)
1537 index_value
= value_from_longest (index_type
, index
);
1539 LA_PRINT_ARRAY_INDEX (index_value
, stream
, options
);
1542 /* Called by various <lang>_val_print routines to print elements of an
1543 array in the form "<elem1>, <elem2>, <elem3>, ...".
1545 (FIXME?) Assumes array element separator is a comma, which is correct
1546 for all languages currently handled.
1547 (FIXME?) Some languages have a notation for repeated array elements,
1548 perhaps we should try to use that notation when appropriate. */
1551 val_print_array_elements (struct type
*type
,
1552 const gdb_byte
*valaddr
, int embedded_offset
,
1553 CORE_ADDR address
, struct ui_file
*stream
,
1555 const struct value
*val
,
1556 const struct value_print_options
*options
,
1559 unsigned int things_printed
= 0;
1561 struct type
*elttype
, *index_type
;
1563 /* Position of the array element we are examining to see
1564 whether it is repeated. */
1566 /* Number of repetitions we have detected so far. */
1568 LONGEST low_bound
, high_bound
;
1570 elttype
= TYPE_TARGET_TYPE (type
);
1571 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
1572 index_type
= TYPE_INDEX_TYPE (type
);
1574 if (get_array_bounds (type
, &low_bound
, &high_bound
))
1576 /* The array length should normally be HIGH_BOUND - LOW_BOUND + 1.
1577 But we have to be a little extra careful, because some languages
1578 such as Ada allow LOW_BOUND to be greater than HIGH_BOUND for
1579 empty arrays. In that situation, the array length is just zero,
1581 if (low_bound
> high_bound
)
1584 len
= high_bound
- low_bound
+ 1;
1588 warning (_("unable to get bounds of array, assuming null array"));
1593 annotate_array_section_begin (i
, elttype
);
1595 for (; i
< len
&& things_printed
< options
->print_max
; i
++)
1599 if (options
->prettyprint_arrays
)
1601 fprintf_filtered (stream
, ",\n");
1602 print_spaces_filtered (2 + 2 * recurse
, stream
);
1606 fprintf_filtered (stream
, ", ");
1609 wrap_here (n_spaces (2 + 2 * recurse
));
1610 maybe_print_array_index (index_type
, i
+ low_bound
,
1615 /* Only check for reps if repeat_count_threshold is not set to
1616 UINT_MAX (unlimited). */
1617 if (options
->repeat_count_threshold
< UINT_MAX
)
1620 && value_available_contents_eq (val
,
1621 embedded_offset
+ i
* eltlen
,
1632 if (reps
> options
->repeat_count_threshold
)
1634 val_print (elttype
, valaddr
, embedded_offset
+ i
* eltlen
,
1635 address
, stream
, recurse
+ 1, val
, options
,
1637 annotate_elt_rep (reps
);
1638 fprintf_filtered (stream
, " <repeats %u times>", reps
);
1639 annotate_elt_rep_end ();
1642 things_printed
+= options
->repeat_count_threshold
;
1646 val_print (elttype
, valaddr
, embedded_offset
+ i
* eltlen
,
1648 stream
, recurse
+ 1, val
, options
, current_language
);
1653 annotate_array_section_end ();
1656 fprintf_filtered (stream
, "...");
1660 /* Read LEN bytes of target memory at address MEMADDR, placing the
1661 results in GDB's memory at MYADDR. Returns a count of the bytes
1662 actually read, and optionally an errno value in the location
1663 pointed to by ERRNOPTR if ERRNOPTR is non-null. */
1665 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
1666 function be eliminated. */
1669 partial_memory_read (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
1670 int len
, int *errnoptr
)
1672 int nread
; /* Number of bytes actually read. */
1673 int errcode
; /* Error from last read. */
1675 /* First try a complete read. */
1676 errcode
= target_read_memory (memaddr
, myaddr
, len
);
1684 /* Loop, reading one byte at a time until we get as much as we can. */
1685 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
1687 errcode
= target_read_memory (memaddr
++, myaddr
++, 1);
1689 /* If an error, the last read was unsuccessful, so adjust count. */
1695 if (errnoptr
!= NULL
)
1697 *errnoptr
= errcode
;
1702 /* Read a string from the inferior, at ADDR, with LEN characters of WIDTH bytes
1703 each. Fetch at most FETCHLIMIT characters. BUFFER will be set to a newly
1704 allocated buffer containing the string, which the caller is responsible to
1705 free, and BYTES_READ will be set to the number of bytes read. Returns 0 on
1706 success, or errno on failure.
1708 If LEN > 0, reads exactly LEN characters (including eventual NULs in
1709 the middle or end of the string). If LEN is -1, stops at the first
1710 null character (not necessarily the first null byte) up to a maximum
1711 of FETCHLIMIT characters. Set FETCHLIMIT to UINT_MAX to read as many
1712 characters as possible from the string.
1714 Unless an exception is thrown, BUFFER will always be allocated, even on
1715 failure. In this case, some characters might have been read before the
1716 failure happened. Check BYTES_READ to recognize this situation.
1718 Note: There was a FIXME asking to make this code use target_read_string,
1719 but this function is more general (can read past null characters, up to
1720 given LEN). Besides, it is used much more often than target_read_string
1721 so it is more tested. Perhaps callers of target_read_string should use
1722 this function instead? */
1725 read_string (CORE_ADDR addr
, int len
, int width
, unsigned int fetchlimit
,
1726 enum bfd_endian byte_order
, gdb_byte
**buffer
, int *bytes_read
)
1728 int found_nul
; /* Non-zero if we found the nul char. */
1729 int errcode
; /* Errno returned from bad reads. */
1730 unsigned int nfetch
; /* Chars to fetch / chars fetched. */
1731 unsigned int chunksize
; /* Size of each fetch, in chars. */
1732 gdb_byte
*bufptr
; /* Pointer to next available byte in
1734 gdb_byte
*limit
; /* First location past end of fetch buffer. */
1735 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
1737 /* Decide how large of chunks to try to read in one operation. This
1738 is also pretty simple. If LEN >= zero, then we want fetchlimit chars,
1739 so we might as well read them all in one operation. If LEN is -1, we
1740 are looking for a NUL terminator to end the fetching, so we might as
1741 well read in blocks that are large enough to be efficient, but not so
1742 large as to be slow if fetchlimit happens to be large. So we choose the
1743 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
1744 200 is way too big for remote debugging over a serial line. */
1746 chunksize
= (len
== -1 ? min (8, fetchlimit
) : fetchlimit
);
1748 /* Loop until we either have all the characters, or we encounter
1749 some error, such as bumping into the end of the address space. */
1754 old_chain
= make_cleanup (free_current_contents
, buffer
);
1758 *buffer
= (gdb_byte
*) xmalloc (len
* width
);
1761 nfetch
= partial_memory_read (addr
, bufptr
, len
* width
, &errcode
)
1763 addr
+= nfetch
* width
;
1764 bufptr
+= nfetch
* width
;
1768 unsigned long bufsize
= 0;
1773 nfetch
= min (chunksize
, fetchlimit
- bufsize
);
1775 if (*buffer
== NULL
)
1776 *buffer
= (gdb_byte
*) xmalloc (nfetch
* width
);
1778 *buffer
= (gdb_byte
*) xrealloc (*buffer
,
1779 (nfetch
+ bufsize
) * width
);
1781 bufptr
= *buffer
+ bufsize
* width
;
1784 /* Read as much as we can. */
1785 nfetch
= partial_memory_read (addr
, bufptr
, nfetch
* width
, &errcode
)
1788 /* Scan this chunk for the null character that terminates the string
1789 to print. If found, we don't need to fetch any more. Note
1790 that bufptr is explicitly left pointing at the next character
1791 after the null character, or at the next character after the end
1794 limit
= bufptr
+ nfetch
* width
;
1795 while (bufptr
< limit
)
1799 c
= extract_unsigned_integer (bufptr
, width
, byte_order
);
1804 /* We don't care about any error which happened after
1805 the NUL terminator. */
1812 while (errcode
== 0 /* no error */
1813 && bufptr
- *buffer
< fetchlimit
* width
/* no overrun */
1814 && !found_nul
); /* haven't found NUL yet */
1817 { /* Length of string is really 0! */
1818 /* We always allocate *buffer. */
1819 *buffer
= bufptr
= xmalloc (1);
1823 /* bufptr and addr now point immediately beyond the last byte which we
1824 consider part of the string (including a '\0' which ends the string). */
1825 *bytes_read
= bufptr
- *buffer
;
1829 discard_cleanups (old_chain
);
1834 /* Return true if print_wchar can display W without resorting to a
1835 numeric escape, false otherwise. */
1838 wchar_printable (gdb_wchar_t w
)
1840 return (gdb_iswprint (w
)
1841 || w
== LCST ('\a') || w
== LCST ('\b')
1842 || w
== LCST ('\f') || w
== LCST ('\n')
1843 || w
== LCST ('\r') || w
== LCST ('\t')
1844 || w
== LCST ('\v'));
1847 /* A helper function that converts the contents of STRING to wide
1848 characters and then appends them to OUTPUT. */
1851 append_string_as_wide (const char *string
,
1852 struct obstack
*output
)
1854 for (; *string
; ++string
)
1856 gdb_wchar_t w
= gdb_btowc (*string
);
1857 obstack_grow (output
, &w
, sizeof (gdb_wchar_t
));
1861 /* Print a wide character W to OUTPUT. ORIG is a pointer to the
1862 original (target) bytes representing the character, ORIG_LEN is the
1863 number of valid bytes. WIDTH is the number of bytes in a base
1864 characters of the type. OUTPUT is an obstack to which wide
1865 characters are emitted. QUOTER is a (narrow) character indicating
1866 the style of quotes surrounding the character to be printed.
1867 NEED_ESCAPE is an in/out flag which is used to track numeric
1868 escapes across calls. */
1871 print_wchar (gdb_wint_t w
, const gdb_byte
*orig
,
1872 int orig_len
, int width
,
1873 enum bfd_endian byte_order
,
1874 struct obstack
*output
,
1875 int quoter
, int *need_escapep
)
1877 int need_escape
= *need_escapep
;
1880 if (gdb_iswprint (w
) && (!need_escape
|| (!gdb_iswdigit (w
)
1882 && w
!= LCST ('9'))))
1884 gdb_wchar_t wchar
= w
;
1886 if (w
== gdb_btowc (quoter
) || w
== LCST ('\\'))
1887 obstack_grow_wstr (output
, LCST ("\\"));
1888 obstack_grow (output
, &wchar
, sizeof (gdb_wchar_t
));
1895 obstack_grow_wstr (output
, LCST ("\\a"));
1898 obstack_grow_wstr (output
, LCST ("\\b"));
1901 obstack_grow_wstr (output
, LCST ("\\f"));
1904 obstack_grow_wstr (output
, LCST ("\\n"));
1907 obstack_grow_wstr (output
, LCST ("\\r"));
1910 obstack_grow_wstr (output
, LCST ("\\t"));
1913 obstack_grow_wstr (output
, LCST ("\\v"));
1919 for (i
= 0; i
+ width
<= orig_len
; i
+= width
)
1924 value
= extract_unsigned_integer (&orig
[i
], width
,
1926 /* If the value fits in 3 octal digits, print it that
1927 way. Otherwise, print it as a hex escape. */
1929 sprintf (octal
, "\\%.3o", (int) (value
& 0777));
1931 sprintf (octal
, "\\x%lx", (long) value
);
1932 append_string_as_wide (octal
, output
);
1934 /* If we somehow have extra bytes, print them now. */
1935 while (i
< orig_len
)
1939 sprintf (octal
, "\\%.3o", orig
[i
] & 0xff);
1940 append_string_as_wide (octal
, output
);
1951 /* Print the character C on STREAM as part of the contents of a
1952 literal string whose delimiter is QUOTER. ENCODING names the
1956 generic_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
1957 int quoter
, const char *encoding
)
1959 enum bfd_endian byte_order
1960 = gdbarch_byte_order (get_type_arch (type
));
1961 struct obstack wchar_buf
, output
;
1962 struct cleanup
*cleanups
;
1964 struct wchar_iterator
*iter
;
1965 int need_escape
= 0;
1967 buf
= alloca (TYPE_LENGTH (type
));
1968 pack_long (buf
, type
, c
);
1970 iter
= make_wchar_iterator (buf
, TYPE_LENGTH (type
),
1971 encoding
, TYPE_LENGTH (type
));
1972 cleanups
= make_cleanup_wchar_iterator (iter
);
1974 /* This holds the printable form of the wchar_t data. */
1975 obstack_init (&wchar_buf
);
1976 make_cleanup_obstack_free (&wchar_buf
);
1982 const gdb_byte
*buf
;
1984 int print_escape
= 1;
1985 enum wchar_iterate_result result
;
1987 num_chars
= wchar_iterate (iter
, &result
, &chars
, &buf
, &buflen
);
1992 /* If all characters are printable, print them. Otherwise,
1993 we're going to have to print an escape sequence. We
1994 check all characters because we want to print the target
1995 bytes in the escape sequence, and we don't know character
1996 boundaries there. */
2000 for (i
= 0; i
< num_chars
; ++i
)
2001 if (!wchar_printable (chars
[i
]))
2009 for (i
= 0; i
< num_chars
; ++i
)
2010 print_wchar (chars
[i
], buf
, buflen
,
2011 TYPE_LENGTH (type
), byte_order
,
2012 &wchar_buf
, quoter
, &need_escape
);
2016 /* This handles the NUM_CHARS == 0 case as well. */
2018 print_wchar (gdb_WEOF
, buf
, buflen
, TYPE_LENGTH (type
),
2019 byte_order
, &wchar_buf
, quoter
, &need_escape
);
2022 /* The output in the host encoding. */
2023 obstack_init (&output
);
2024 make_cleanup_obstack_free (&output
);
2026 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
2027 obstack_base (&wchar_buf
),
2028 obstack_object_size (&wchar_buf
),
2029 1, &output
, translit_char
);
2030 obstack_1grow (&output
, '\0');
2032 fputs_filtered (obstack_base (&output
), stream
);
2034 do_cleanups (cleanups
);
2037 /* Print the character string STRING, printing at most LENGTH
2038 characters. LENGTH is -1 if the string is nul terminated. TYPE is
2039 the type of each character. OPTIONS holds the printing options;
2040 printing stops early if the number hits print_max; repeat counts
2041 are printed as appropriate. Print ellipses at the end if we had to
2042 stop before printing LENGTH characters, or if FORCE_ELLIPSES.
2043 QUOTE_CHAR is the character to print at each end of the string. If
2044 C_STYLE_TERMINATOR is true, and the last character is 0, then it is
2048 generic_printstr (struct ui_file
*stream
, struct type
*type
,
2049 const gdb_byte
*string
, unsigned int length
,
2050 const char *encoding
, int force_ellipses
,
2051 int quote_char
, int c_style_terminator
,
2052 const struct value_print_options
*options
)
2054 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
2056 unsigned int things_printed
= 0;
2059 int width
= TYPE_LENGTH (type
);
2060 struct obstack wchar_buf
, output
;
2061 struct cleanup
*cleanup
;
2062 struct wchar_iterator
*iter
;
2064 int need_escape
= 0;
2065 gdb_wchar_t wide_quote_char
= gdb_btowc (quote_char
);
2069 unsigned long current_char
= 1;
2071 for (i
= 0; current_char
; ++i
)
2074 current_char
= extract_unsigned_integer (string
+ i
* width
,
2080 /* If the string was not truncated due to `set print elements', and
2081 the last byte of it is a null, we don't print that, in
2082 traditional C style. */
2083 if (c_style_terminator
2086 && (extract_unsigned_integer (string
+ (length
- 1) * width
,
2087 width
, byte_order
) == 0))
2092 fputs_filtered ("\"\"", stream
);
2096 /* Arrange to iterate over the characters, in wchar_t form. */
2097 iter
= make_wchar_iterator (string
, length
* width
, encoding
, width
);
2098 cleanup
= make_cleanup_wchar_iterator (iter
);
2100 /* WCHAR_BUF is the obstack we use to represent the string in
2102 obstack_init (&wchar_buf
);
2103 make_cleanup_obstack_free (&wchar_buf
);
2105 while (!finished
&& things_printed
< options
->print_max
)
2108 enum wchar_iterate_result result
;
2110 const gdb_byte
*buf
;
2117 obstack_grow_wstr (&wchar_buf
, LCST (", "));
2121 num_chars
= wchar_iterate (iter
, &result
, &chars
, &buf
, &buflen
);
2122 /* We only look at repetitions when we were able to convert a
2123 single character in isolation. This makes the code simpler
2124 and probably does the sensible thing in the majority of
2126 while (num_chars
== 1 && things_printed
< options
->print_max
)
2128 /* Count the number of repetitions. */
2129 unsigned int reps
= 0;
2130 gdb_wchar_t current_char
= chars
[0];
2131 const gdb_byte
*orig_buf
= buf
;
2132 int orig_len
= buflen
;
2136 obstack_grow_wstr (&wchar_buf
, LCST (", "));
2140 while (num_chars
== 1 && current_char
== chars
[0])
2142 num_chars
= wchar_iterate (iter
, &result
, &chars
,
2147 /* Emit CURRENT_CHAR according to the repetition count and
2149 if (reps
> options
->repeat_count_threshold
)
2153 if (options
->inspect_it
)
2154 obstack_grow_wstr (&wchar_buf
, LCST ("\\"));
2155 obstack_grow (&wchar_buf
, &wide_quote_char
,
2156 sizeof (gdb_wchar_t
));
2157 obstack_grow_wstr (&wchar_buf
, LCST (", "));
2160 obstack_grow_wstr (&wchar_buf
, LCST ("'"));
2162 print_wchar (current_char
, orig_buf
, orig_len
, width
,
2163 byte_order
, &wchar_buf
, '\'', &need_escape
);
2164 obstack_grow_wstr (&wchar_buf
, LCST ("'"));
2166 /* Painful gyrations. */
2168 char *s
= xstrprintf (_(" <repeats %u times>"), reps
);
2170 for (j
= 0; s
[j
]; ++j
)
2172 gdb_wchar_t w
= gdb_btowc (s
[j
]);
2173 obstack_grow (&wchar_buf
, &w
, sizeof (gdb_wchar_t
));
2177 things_printed
+= options
->repeat_count_threshold
;
2182 /* Saw the character one or more times, but fewer than
2183 the repetition threshold. */
2186 if (options
->inspect_it
)
2187 obstack_grow_wstr (&wchar_buf
, LCST ("\\"));
2188 obstack_grow (&wchar_buf
, &wide_quote_char
,
2189 sizeof (gdb_wchar_t
));
2196 print_wchar (current_char
, orig_buf
,
2198 byte_order
, &wchar_buf
,
2199 quote_char
, &need_escape
);
2205 /* NUM_CHARS and the other outputs from wchar_iterate are valid
2206 here regardless of which branch was taken above. */
2216 case wchar_iterate_invalid
:
2219 if (options
->inspect_it
)
2220 obstack_grow_wstr (&wchar_buf
, LCST ("\\"));
2221 obstack_grow (&wchar_buf
, &wide_quote_char
,
2222 sizeof (gdb_wchar_t
));
2226 print_wchar (gdb_WEOF
, buf
, buflen
, width
, byte_order
,
2227 &wchar_buf
, quote_char
, &need_escape
);
2230 case wchar_iterate_incomplete
:
2233 if (options
->inspect_it
)
2234 obstack_grow_wstr (&wchar_buf
, LCST ("\\"));
2235 obstack_grow (&wchar_buf
, &wide_quote_char
,
2236 sizeof (gdb_wchar_t
));
2237 obstack_grow_wstr (&wchar_buf
, LCST (","));
2240 obstack_grow_wstr (&wchar_buf
,
2241 LCST (" <incomplete sequence "));
2242 print_wchar (gdb_WEOF
, buf
, buflen
, width
,
2243 byte_order
, &wchar_buf
,
2245 obstack_grow_wstr (&wchar_buf
, LCST (">"));
2251 /* Terminate the quotes if necessary. */
2254 if (options
->inspect_it
)
2255 obstack_grow_wstr (&wchar_buf
, LCST ("\\"));
2256 obstack_grow (&wchar_buf
, &wide_quote_char
,
2257 sizeof (gdb_wchar_t
));
2260 if (force_ellipses
|| !finished
)
2261 obstack_grow_wstr (&wchar_buf
, LCST ("..."));
2263 /* OUTPUT is where we collect `char's for printing. */
2264 obstack_init (&output
);
2265 make_cleanup_obstack_free (&output
);
2267 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
2268 obstack_base (&wchar_buf
),
2269 obstack_object_size (&wchar_buf
),
2270 1, &output
, translit_char
);
2271 obstack_1grow (&output
, '\0');
2273 fputs_filtered (obstack_base (&output
), stream
);
2275 do_cleanups (cleanup
);
2278 /* Print a string from the inferior, starting at ADDR and printing up to LEN
2279 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
2280 stops at the first null byte, otherwise printing proceeds (including null
2281 bytes) until either print_max or LEN characters have been printed,
2282 whichever is smaller. ENCODING is the name of the string's
2283 encoding. It can be NULL, in which case the target encoding is
2287 val_print_string (struct type
*elttype
, const char *encoding
,
2288 CORE_ADDR addr
, int len
,
2289 struct ui_file
*stream
,
2290 const struct value_print_options
*options
)
2292 int force_ellipsis
= 0; /* Force ellipsis to be printed if nonzero. */
2293 int errcode
; /* Errno returned from bad reads. */
2294 int found_nul
; /* Non-zero if we found the nul char. */
2295 unsigned int fetchlimit
; /* Maximum number of chars to print. */
2297 gdb_byte
*buffer
= NULL
; /* Dynamically growable fetch buffer. */
2298 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
2299 struct gdbarch
*gdbarch
= get_type_arch (elttype
);
2300 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2301 int width
= TYPE_LENGTH (elttype
);
2303 /* First we need to figure out the limit on the number of characters we are
2304 going to attempt to fetch and print. This is actually pretty simple. If
2305 LEN >= zero, then the limit is the minimum of LEN and print_max. If
2306 LEN is -1, then the limit is print_max. This is true regardless of
2307 whether print_max is zero, UINT_MAX (unlimited), or something in between,
2308 because finding the null byte (or available memory) is what actually
2309 limits the fetch. */
2311 fetchlimit
= (len
== -1 ? options
->print_max
: min (len
,
2312 options
->print_max
));
2314 errcode
= read_string (addr
, len
, width
, fetchlimit
, byte_order
,
2315 &buffer
, &bytes_read
);
2316 old_chain
= make_cleanup (xfree
, buffer
);
2320 /* We now have either successfully filled the buffer to fetchlimit,
2321 or terminated early due to an error or finding a null char when
2324 /* Determine found_nul by looking at the last character read. */
2325 found_nul
= extract_unsigned_integer (buffer
+ bytes_read
- width
, width
,
2327 if (len
== -1 && !found_nul
)
2331 /* We didn't find a NUL terminator we were looking for. Attempt
2332 to peek at the next character. If not successful, or it is not
2333 a null byte, then force ellipsis to be printed. */
2335 peekbuf
= (gdb_byte
*) alloca (width
);
2337 if (target_read_memory (addr
, peekbuf
, width
) == 0
2338 && extract_unsigned_integer (peekbuf
, width
, byte_order
) != 0)
2341 else if ((len
>= 0 && errcode
!= 0) || (len
> bytes_read
/ width
))
2343 /* Getting an error when we have a requested length, or fetching less
2344 than the number of characters actually requested, always make us
2349 /* If we get an error before fetching anything, don't print a string.
2350 But if we fetch something and then get an error, print the string
2351 and then the error message. */
2352 if (errcode
== 0 || bytes_read
> 0)
2354 LA_PRINT_STRING (stream
, elttype
, buffer
, bytes_read
/ width
,
2355 encoding
, force_ellipsis
, options
);
2362 fprintf_filtered (stream
, "<Address ");
2363 fputs_filtered (paddress (gdbarch
, addr
), stream
);
2364 fprintf_filtered (stream
, " out of bounds>");
2368 fprintf_filtered (stream
, "<Error reading address ");
2369 fputs_filtered (paddress (gdbarch
, addr
), stream
);
2370 fprintf_filtered (stream
, ": %s>", safe_strerror (errcode
));
2375 do_cleanups (old_chain
);
2377 return (bytes_read
/ width
);
2381 /* The 'set input-radix' command writes to this auxiliary variable.
2382 If the requested radix is valid, INPUT_RADIX is updated; otherwise,
2383 it is left unchanged. */
2385 static unsigned input_radix_1
= 10;
2387 /* Validate an input or output radix setting, and make sure the user
2388 knows what they really did here. Radix setting is confusing, e.g.
2389 setting the input radix to "10" never changes it! */
2392 set_input_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
2394 set_input_radix_1 (from_tty
, input_radix_1
);
2398 set_input_radix_1 (int from_tty
, unsigned radix
)
2400 /* We don't currently disallow any input radix except 0 or 1, which don't
2401 make any mathematical sense. In theory, we can deal with any input
2402 radix greater than 1, even if we don't have unique digits for every
2403 value from 0 to radix-1, but in practice we lose on large radix values.
2404 We should either fix the lossage or restrict the radix range more.
2409 input_radix_1
= input_radix
;
2410 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
2413 input_radix_1
= input_radix
= radix
;
2416 printf_filtered (_("Input radix now set to "
2417 "decimal %u, hex %x, octal %o.\n"),
2418 radix
, radix
, radix
);
2422 /* The 'set output-radix' command writes to this auxiliary variable.
2423 If the requested radix is valid, OUTPUT_RADIX is updated,
2424 otherwise, it is left unchanged. */
2426 static unsigned output_radix_1
= 10;
2429 set_output_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
2431 set_output_radix_1 (from_tty
, output_radix_1
);
2435 set_output_radix_1 (int from_tty
, unsigned radix
)
2437 /* Validate the radix and disallow ones that we aren't prepared to
2438 handle correctly, leaving the radix unchanged. */
2442 user_print_options
.output_format
= 'x'; /* hex */
2445 user_print_options
.output_format
= 0; /* decimal */
2448 user_print_options
.output_format
= 'o'; /* octal */
2451 output_radix_1
= output_radix
;
2452 error (_("Unsupported output radix ``decimal %u''; "
2453 "output radix unchanged."),
2456 output_radix_1
= output_radix
= radix
;
2459 printf_filtered (_("Output radix now set to "
2460 "decimal %u, hex %x, octal %o.\n"),
2461 radix
, radix
, radix
);
2465 /* Set both the input and output radix at once. Try to set the output radix
2466 first, since it has the most restrictive range. An radix that is valid as
2467 an output radix is also valid as an input radix.
2469 It may be useful to have an unusual input radix. If the user wishes to
2470 set an input radix that is not valid as an output radix, he needs to use
2471 the 'set input-radix' command. */
2474 set_radix (char *arg
, int from_tty
)
2478 radix
= (arg
== NULL
) ? 10 : parse_and_eval_long (arg
);
2479 set_output_radix_1 (0, radix
);
2480 set_input_radix_1 (0, radix
);
2483 printf_filtered (_("Input and output radices now set to "
2484 "decimal %u, hex %x, octal %o.\n"),
2485 radix
, radix
, radix
);
2489 /* Show both the input and output radices. */
2492 show_radix (char *arg
, int from_tty
)
2496 if (input_radix
== output_radix
)
2498 printf_filtered (_("Input and output radices set to "
2499 "decimal %u, hex %x, octal %o.\n"),
2500 input_radix
, input_radix
, input_radix
);
2504 printf_filtered (_("Input radix set to decimal "
2505 "%u, hex %x, octal %o.\n"),
2506 input_radix
, input_radix
, input_radix
);
2507 printf_filtered (_("Output radix set to decimal "
2508 "%u, hex %x, octal %o.\n"),
2509 output_radix
, output_radix
, output_radix
);
2516 set_print (char *arg
, int from_tty
)
2519 "\"set print\" must be followed by the name of a print subcommand.\n");
2520 help_list (setprintlist
, "set print ", -1, gdb_stdout
);
2524 show_print (char *args
, int from_tty
)
2526 cmd_show_list (showprintlist
, from_tty
, "");
2530 _initialize_valprint (void)
2532 add_prefix_cmd ("print", no_class
, set_print
,
2533 _("Generic command for setting how things print."),
2534 &setprintlist
, "set print ", 0, &setlist
);
2535 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
2536 /* Prefer set print to set prompt. */
2537 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
);
2539 add_prefix_cmd ("print", no_class
, show_print
,
2540 _("Generic command for showing print settings."),
2541 &showprintlist
, "show print ", 0, &showlist
);
2542 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
2543 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
2545 add_setshow_uinteger_cmd ("elements", no_class
,
2546 &user_print_options
.print_max
, _("\
2547 Set limit on string chars or array elements to print."), _("\
2548 Show limit on string chars or array elements to print."), _("\
2549 \"set print elements 0\" causes there to be no limit."),
2552 &setprintlist
, &showprintlist
);
2554 add_setshow_boolean_cmd ("null-stop", no_class
,
2555 &user_print_options
.stop_print_at_null
, _("\
2556 Set printing of char arrays to stop at first null char."), _("\
2557 Show printing of char arrays to stop at first null char."), NULL
,
2559 show_stop_print_at_null
,
2560 &setprintlist
, &showprintlist
);
2562 add_setshow_uinteger_cmd ("repeats", no_class
,
2563 &user_print_options
.repeat_count_threshold
, _("\
2564 Set threshold for repeated print elements."), _("\
2565 Show threshold for repeated print elements."), _("\
2566 \"set print repeats 0\" causes all elements to be individually printed."),
2568 show_repeat_count_threshold
,
2569 &setprintlist
, &showprintlist
);
2571 add_setshow_boolean_cmd ("pretty", class_support
,
2572 &user_print_options
.prettyprint_structs
, _("\
2573 Set prettyprinting of structures."), _("\
2574 Show prettyprinting of structures."), NULL
,
2576 show_prettyprint_structs
,
2577 &setprintlist
, &showprintlist
);
2579 add_setshow_boolean_cmd ("union", class_support
,
2580 &user_print_options
.unionprint
, _("\
2581 Set printing of unions interior to structures."), _("\
2582 Show printing of unions interior to structures."), NULL
,
2585 &setprintlist
, &showprintlist
);
2587 add_setshow_boolean_cmd ("array", class_support
,
2588 &user_print_options
.prettyprint_arrays
, _("\
2589 Set prettyprinting of arrays."), _("\
2590 Show prettyprinting of arrays."), NULL
,
2592 show_prettyprint_arrays
,
2593 &setprintlist
, &showprintlist
);
2595 add_setshow_boolean_cmd ("address", class_support
,
2596 &user_print_options
.addressprint
, _("\
2597 Set printing of addresses."), _("\
2598 Show printing of addresses."), NULL
,
2601 &setprintlist
, &showprintlist
);
2603 add_setshow_zuinteger_cmd ("input-radix", class_support
, &input_radix_1
,
2605 Set default input radix for entering numbers."), _("\
2606 Show default input radix for entering numbers."), NULL
,
2609 &setlist
, &showlist
);
2611 add_setshow_zuinteger_cmd ("output-radix", class_support
, &output_radix_1
,
2613 Set default output radix for printing of values."), _("\
2614 Show default output radix for printing of values."), NULL
,
2617 &setlist
, &showlist
);
2619 /* The "set radix" and "show radix" commands are special in that
2620 they are like normal set and show commands but allow two normally
2621 independent variables to be either set or shown with a single
2622 command. So the usual deprecated_add_set_cmd() and [deleted]
2623 add_show_from_set() commands aren't really appropriate. */
2624 /* FIXME: i18n: With the new add_setshow_integer command, that is no
2625 longer true - show can display anything. */
2626 add_cmd ("radix", class_support
, set_radix
, _("\
2627 Set default input and output number radices.\n\
2628 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
2629 Without an argument, sets both radices back to the default value of 10."),
2631 add_cmd ("radix", class_support
, show_radix
, _("\
2632 Show the default input and output number radices.\n\
2633 Use 'show input-radix' or 'show output-radix' to independently show each."),
2636 add_setshow_boolean_cmd ("array-indexes", class_support
,
2637 &user_print_options
.print_array_indexes
, _("\
2638 Set printing of array indexes."), _("\
2639 Show printing of array indexes"), NULL
, NULL
, show_print_array_indexes
,
2640 &setprintlist
, &showprintlist
);