1 /* Print values for GDB, the GNU debugger.
3 Copyright (C) 1986-2013 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 /* Maximum number of wchars returned from wchar_iterate. */
46 /* A convenience macro to compute the size of a wchar_t buffer containing X
48 #define WCHAR_BUFLEN(X) ((X) * sizeof (gdb_wchar_t))
50 /* Character buffer size saved while iterating over wchars. */
51 #define WCHAR_BUFLEN_MAX WCHAR_BUFLEN (MAX_WCHARS)
53 /* A structure to encapsulate state information from iterated
54 character conversions. */
55 struct converted_character
57 /* The number of characters converted. */
60 /* The result of the conversion. See charset.h for more. */
61 enum wchar_iterate_result result
;
63 /* The (saved) converted character(s). */
64 gdb_wchar_t chars
[WCHAR_BUFLEN_MAX
];
66 /* The first converted target byte. */
69 /* The number of bytes converted. */
72 /* How many times this character(s) is repeated. */
76 typedef struct converted_character converted_character_d
;
77 DEF_VEC_O (converted_character_d
);
79 /* Command lists for set/show print raw. */
80 struct cmd_list_element
*setprintrawlist
;
81 struct cmd_list_element
*showprintrawlist
;
83 /* Prototypes for local functions */
85 static int partial_memory_read (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
86 int len
, int *errptr
);
88 static void show_print (char *, int);
90 static void set_print (char *, int);
92 static void set_radix (char *, int);
94 static void show_radix (char *, int);
96 static void set_input_radix (char *, int, struct cmd_list_element
*);
98 static void set_input_radix_1 (int, unsigned);
100 static void set_output_radix (char *, int, struct cmd_list_element
*);
102 static void set_output_radix_1 (int, unsigned);
104 void _initialize_valprint (void);
106 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
108 struct value_print_options user_print_options
=
110 Val_prettyformat_default
, /* prettyformat */
111 0, /* prettyformat_arrays */
112 0, /* prettyformat_structs */
115 1, /* addressprint */
117 PRINT_MAX_DEFAULT
, /* print_max */
118 10, /* repeat_count_threshold */
119 0, /* output_format */
121 0, /* stop_print_at_null */
122 0, /* print_array_indexes */
124 1, /* static_field_print */
125 1, /* pascal_static_field_print */
131 /* Initialize *OPTS to be a copy of the user print options. */
133 get_user_print_options (struct value_print_options
*opts
)
135 *opts
= user_print_options
;
138 /* Initialize *OPTS to be a copy of the user print options, but with
139 pretty-formatting disabled. */
141 get_no_prettyformat_print_options (struct value_print_options
*opts
)
143 *opts
= user_print_options
;
144 opts
->prettyformat
= Val_no_prettyformat
;
147 /* Initialize *OPTS to be a copy of the user print options, but using
148 FORMAT as the formatting option. */
150 get_formatted_print_options (struct value_print_options
*opts
,
153 *opts
= user_print_options
;
154 opts
->format
= format
;
158 show_print_max (struct ui_file
*file
, int from_tty
,
159 struct cmd_list_element
*c
, const char *value
)
161 fprintf_filtered (file
,
162 _("Limit on string chars or array "
163 "elements to print is %s.\n"),
168 /* Default input and output radixes, and output format letter. */
170 unsigned input_radix
= 10;
172 show_input_radix (struct ui_file
*file
, int from_tty
,
173 struct cmd_list_element
*c
, const char *value
)
175 fprintf_filtered (file
,
176 _("Default input radix for entering numbers is %s.\n"),
180 unsigned output_radix
= 10;
182 show_output_radix (struct ui_file
*file
, int from_tty
,
183 struct cmd_list_element
*c
, const char *value
)
185 fprintf_filtered (file
,
186 _("Default output radix for printing of values is %s.\n"),
190 /* By default we print arrays without printing the index of each element in
191 the array. This behavior can be changed by setting PRINT_ARRAY_INDEXES. */
194 show_print_array_indexes (struct ui_file
*file
, int from_tty
,
195 struct cmd_list_element
*c
, const char *value
)
197 fprintf_filtered (file
, _("Printing of array indexes is %s.\n"), value
);
200 /* Print repeat counts if there are more than this many repetitions of an
201 element in an array. Referenced by the low level language dependent
205 show_repeat_count_threshold (struct ui_file
*file
, int from_tty
,
206 struct cmd_list_element
*c
, const char *value
)
208 fprintf_filtered (file
, _("Threshold for repeated print elements is %s.\n"),
212 /* If nonzero, stops printing of char arrays at first null. */
215 show_stop_print_at_null (struct ui_file
*file
, int from_tty
,
216 struct cmd_list_element
*c
, const char *value
)
218 fprintf_filtered (file
,
219 _("Printing of char arrays to stop "
220 "at first null char is %s.\n"),
224 /* Controls pretty printing of structures. */
227 show_prettyformat_structs (struct ui_file
*file
, int from_tty
,
228 struct cmd_list_element
*c
, const char *value
)
230 fprintf_filtered (file
, _("Pretty formatting of structures is %s.\n"), value
);
233 /* Controls pretty printing of arrays. */
236 show_prettyformat_arrays (struct ui_file
*file
, int from_tty
,
237 struct cmd_list_element
*c
, const char *value
)
239 fprintf_filtered (file
, _("Pretty formatting of arrays is %s.\n"), value
);
242 /* If nonzero, causes unions inside structures or other unions to be
246 show_unionprint (struct ui_file
*file
, int from_tty
,
247 struct cmd_list_element
*c
, const char *value
)
249 fprintf_filtered (file
,
250 _("Printing of unions interior to structures is %s.\n"),
254 /* If nonzero, causes machine addresses to be printed in certain contexts. */
257 show_addressprint (struct ui_file
*file
, int from_tty
,
258 struct cmd_list_element
*c
, const char *value
)
260 fprintf_filtered (file
, _("Printing of addresses is %s.\n"), value
);
264 show_symbol_print (struct ui_file
*file
, int from_tty
,
265 struct cmd_list_element
*c
, const char *value
)
267 fprintf_filtered (file
,
268 _("Printing of symbols when printing pointers is %s.\n"),
274 /* A helper function for val_print. When printing in "summary" mode,
275 we want to print scalar arguments, but not aggregate arguments.
276 This function distinguishes between the two. */
279 val_print_scalar_type_p (struct type
*type
)
281 CHECK_TYPEDEF (type
);
282 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
284 type
= TYPE_TARGET_TYPE (type
);
285 CHECK_TYPEDEF (type
);
287 switch (TYPE_CODE (type
))
289 case TYPE_CODE_ARRAY
:
290 case TYPE_CODE_STRUCT
:
291 case TYPE_CODE_UNION
:
293 case TYPE_CODE_STRING
:
300 /* See its definition in value.h. */
303 valprint_check_validity (struct ui_file
*stream
,
306 const struct value
*val
)
308 CHECK_TYPEDEF (type
);
310 if (TYPE_CODE (type
) != TYPE_CODE_UNION
311 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
312 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
314 if (!value_bits_valid (val
, TARGET_CHAR_BIT
* embedded_offset
,
315 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
317 val_print_optimized_out (val
, stream
);
321 if (value_bits_synthetic_pointer (val
, TARGET_CHAR_BIT
* embedded_offset
,
322 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
324 fputs_filtered (_("<synthetic pointer>"), stream
);
328 if (!value_bytes_available (val
, embedded_offset
, TYPE_LENGTH (type
)))
330 val_print_unavailable (stream
);
339 val_print_optimized_out (const struct value
*val
, struct ui_file
*stream
)
341 if (val
!= NULL
&& value_lval_const (val
) == lval_register
)
342 fprintf_filtered (stream
, _("<not saved>"));
344 fprintf_filtered (stream
, _("<optimized out>"));
348 val_print_unavailable (struct ui_file
*stream
)
350 fprintf_filtered (stream
, _("<unavailable>"));
354 val_print_invalid_address (struct ui_file
*stream
)
356 fprintf_filtered (stream
, _("<invalid address>"));
359 /* A generic val_print that is suitable for use by language
360 implementations of the la_val_print method. This function can
361 handle most type codes, though not all, notably exception
362 TYPE_CODE_UNION and TYPE_CODE_STRUCT, which must be implemented by
365 Most arguments are as to val_print.
367 The additional DECORATIONS argument can be used to customize the
368 output in some small, language-specific ways. */
371 generic_val_print (struct type
*type
, const gdb_byte
*valaddr
,
372 int embedded_offset
, CORE_ADDR address
,
373 struct ui_file
*stream
, int recurse
,
374 const struct value
*original_value
,
375 const struct value_print_options
*options
,
376 const struct generic_val_print_decorations
*decorations
)
378 struct gdbarch
*gdbarch
= get_type_arch (type
);
379 unsigned int i
= 0; /* Number of characters printed. */
381 struct type
*elttype
, *unresolved_elttype
;
382 struct type
*unresolved_type
= type
;
386 CHECK_TYPEDEF (type
);
387 switch (TYPE_CODE (type
))
389 case TYPE_CODE_ARRAY
:
390 unresolved_elttype
= TYPE_TARGET_TYPE (type
);
391 elttype
= check_typedef (unresolved_elttype
);
392 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (unresolved_elttype
) > 0)
394 LONGEST low_bound
, high_bound
;
396 if (!get_array_bounds (type
, &low_bound
, &high_bound
))
397 error (_("Could not determine the array high bound"));
399 if (options
->prettyformat_arrays
)
401 print_spaces_filtered (2 + 2 * recurse
, stream
);
404 fprintf_filtered (stream
, "{");
405 val_print_array_elements (type
, valaddr
, embedded_offset
,
407 recurse
, original_value
, options
, 0);
408 fprintf_filtered (stream
, "}");
411 /* Array of unspecified length: treat like pointer to first
413 addr
= address
+ embedded_offset
;
414 goto print_unpacked_pointer
;
416 case TYPE_CODE_MEMBERPTR
:
417 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
418 original_value
, options
, 0, stream
);
422 if (options
->format
&& options
->format
!= 's')
424 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
425 original_value
, options
, 0, stream
);
428 unresolved_elttype
= TYPE_TARGET_TYPE (type
);
429 elttype
= check_typedef (unresolved_elttype
);
431 addr
= unpack_pointer (type
, valaddr
+ embedded_offset
);
432 print_unpacked_pointer
:
434 if (TYPE_CODE (elttype
) == TYPE_CODE_FUNC
)
436 /* Try to print what function it points to. */
437 print_function_pointer_address (options
, gdbarch
, addr
, stream
);
441 if (options
->symbol_print
)
442 print_address_demangle (options
, gdbarch
, addr
, stream
, demangle
);
443 else if (options
->addressprint
)
444 fputs_filtered (paddress (gdbarch
, addr
), stream
);
449 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
450 if (options
->addressprint
)
453 = extract_typed_address (valaddr
+ embedded_offset
, type
);
455 fprintf_filtered (stream
, "@");
456 fputs_filtered (paddress (gdbarch
, addr
), stream
);
457 if (options
->deref_ref
)
458 fputs_filtered (": ", stream
);
460 /* De-reference the reference. */
461 if (options
->deref_ref
)
463 if (TYPE_CODE (elttype
) != TYPE_CODE_UNDEF
)
465 struct value
*deref_val
;
467 deref_val
= coerce_ref_if_computed (original_value
);
468 if (deref_val
!= NULL
)
470 /* More complicated computed references are not supported. */
471 gdb_assert (embedded_offset
== 0);
474 deref_val
= value_at (TYPE_TARGET_TYPE (type
),
475 unpack_pointer (type
,
477 + embedded_offset
)));
479 common_val_print (deref_val
, stream
, recurse
, options
,
483 fputs_filtered ("???", stream
);
490 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
491 original_value
, options
, 0, stream
);
494 len
= TYPE_NFIELDS (type
);
495 val
= unpack_long (type
, valaddr
+ embedded_offset
);
496 for (i
= 0; i
< len
; i
++)
499 if (val
== TYPE_FIELD_ENUMVAL (type
, i
))
506 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
508 else if (TYPE_FLAG_ENUM (type
))
512 /* We have a "flag" enum, so we try to decompose it into
513 pieces as appropriate. A flag enum has disjoint
514 constants by definition. */
515 fputs_filtered ("(", stream
);
516 for (i
= 0; i
< len
; ++i
)
520 if ((val
& TYPE_FIELD_ENUMVAL (type
, i
)) != 0)
523 fputs_filtered (" | ", stream
);
526 val
&= ~TYPE_FIELD_ENUMVAL (type
, i
);
527 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
531 if (first
|| val
!= 0)
534 fputs_filtered (" | ", stream
);
535 fputs_filtered ("unknown: ", stream
);
536 print_longest (stream
, 'd', 0, val
);
539 fputs_filtered (")", stream
);
542 print_longest (stream
, 'd', 0, val
);
545 case TYPE_CODE_FLAGS
:
547 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
548 original_value
, options
, 0, stream
);
550 val_print_type_code_flags (type
, valaddr
+ embedded_offset
,
555 case TYPE_CODE_METHOD
:
558 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
559 original_value
, options
, 0, stream
);
562 /* FIXME, we should consider, at least for ANSI C language,
563 eliminating the distinction made between FUNCs and POINTERs
565 fprintf_filtered (stream
, "{");
566 type_print (type
, "", stream
, -1);
567 fprintf_filtered (stream
, "} ");
568 /* Try to print what function it points to, and its address. */
569 print_address_demangle (options
, gdbarch
, address
, stream
, demangle
);
573 if (options
->format
|| options
->output_format
)
575 struct value_print_options opts
= *options
;
576 opts
.format
= (options
->format
? options
->format
577 : options
->output_format
);
578 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
579 original_value
, &opts
, 0, stream
);
583 val
= unpack_long (type
, valaddr
+ embedded_offset
);
585 fputs_filtered (decorations
->false_name
, stream
);
587 fputs_filtered (decorations
->true_name
, stream
);
589 print_longest (stream
, 'd', 0, val
);
593 case TYPE_CODE_RANGE
:
594 /* FIXME: create_range_type does not set the unsigned bit in a
595 range type (I think it probably should copy it from the
596 target type), so we won't print values which are too large to
597 fit in a signed integer correctly. */
598 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
599 print with the target type, though, because the size of our
600 type and the target type might differ). */
605 if (options
->format
|| options
->output_format
)
607 struct value_print_options opts
= *options
;
609 opts
.format
= (options
->format
? options
->format
610 : options
->output_format
);
611 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
612 original_value
, &opts
, 0, stream
);
615 val_print_type_code_int (type
, valaddr
+ embedded_offset
, stream
);
619 if (options
->format
|| options
->output_format
)
621 struct value_print_options opts
= *options
;
623 opts
.format
= (options
->format
? options
->format
624 : options
->output_format
);
625 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
626 original_value
, &opts
, 0, stream
);
630 val
= unpack_long (type
, valaddr
+ embedded_offset
);
631 if (TYPE_UNSIGNED (type
))
632 fprintf_filtered (stream
, "%u", (unsigned int) val
);
634 fprintf_filtered (stream
, "%d", (int) val
);
635 fputs_filtered (" ", stream
);
636 LA_PRINT_CHAR (val
, unresolved_type
, stream
);
643 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
644 original_value
, options
, 0, stream
);
648 print_floating (valaddr
+ embedded_offset
, type
, stream
);
652 case TYPE_CODE_DECFLOAT
:
654 val_print_scalar_formatted (type
, valaddr
, embedded_offset
,
655 original_value
, options
, 0, stream
);
657 print_decimal_floating (valaddr
+ embedded_offset
,
662 fputs_filtered (decorations
->void_name
, stream
);
665 case TYPE_CODE_ERROR
:
666 fprintf_filtered (stream
, "%s", TYPE_ERROR_NAME (type
));
669 case TYPE_CODE_UNDEF
:
670 /* This happens (without TYPE_FLAG_STUB set) on systems which
671 don't use dbx xrefs (NO_DBX_XREFS in gcc) if a file has a
672 "struct foo *bar" and no complete type for struct foo in that
674 fprintf_filtered (stream
, _("<incomplete type>"));
677 case TYPE_CODE_COMPLEX
:
678 fprintf_filtered (stream
, "%s", decorations
->complex_prefix
);
680 val_print_scalar_formatted (TYPE_TARGET_TYPE (type
),
681 valaddr
, embedded_offset
,
682 original_value
, options
, 0, stream
);
684 print_floating (valaddr
+ embedded_offset
,
685 TYPE_TARGET_TYPE (type
),
687 fprintf_filtered (stream
, "%s", decorations
->complex_infix
);
689 val_print_scalar_formatted (TYPE_TARGET_TYPE (type
),
692 + TYPE_LENGTH (TYPE_TARGET_TYPE (type
)),
696 print_floating (valaddr
+ embedded_offset
697 + TYPE_LENGTH (TYPE_TARGET_TYPE (type
)),
698 TYPE_TARGET_TYPE (type
),
700 fprintf_filtered (stream
, "%s", decorations
->complex_suffix
);
703 case TYPE_CODE_UNION
:
704 case TYPE_CODE_STRUCT
:
705 case TYPE_CODE_METHODPTR
:
707 error (_("Unhandled type code %d in symbol table."),
713 /* Print using the given LANGUAGE the data of type TYPE located at
714 VALADDR + EMBEDDED_OFFSET (within GDB), which came from the
715 inferior at address ADDRESS + EMBEDDED_OFFSET, onto stdio stream
716 STREAM according to OPTIONS. VAL is the whole object that came
717 from ADDRESS. VALADDR must point to the head of VAL's contents
720 The language printers will pass down an adjusted EMBEDDED_OFFSET to
721 further helper subroutines as subfields of TYPE are printed. In
722 such cases, VALADDR is passed down unadjusted, as well as VAL, so
723 that VAL can be queried for metadata about the contents data being
724 printed, using EMBEDDED_OFFSET as an offset into VAL's contents
725 buffer. For example: "has this field been optimized out", or "I'm
726 printing an object while inspecting a traceframe; has this
727 particular piece of data been collected?".
729 RECURSE indicates the amount of indentation to supply before
730 continuation lines; this amount is roughly twice the value of
734 val_print (struct type
*type
, const gdb_byte
*valaddr
, int embedded_offset
,
735 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
736 const struct value
*val
,
737 const struct value_print_options
*options
,
738 const struct language_defn
*language
)
740 volatile struct gdb_exception except
;
742 struct value_print_options local_opts
= *options
;
743 struct type
*real_type
= check_typedef (type
);
745 if (local_opts
.prettyformat
== Val_prettyformat_default
)
746 local_opts
.prettyformat
= (local_opts
.prettyformat_structs
747 ? Val_prettyformat
: Val_no_prettyformat
);
751 /* Ensure that the type is complete and not just a stub. If the type is
752 only a stub and we can't find and substitute its complete type, then
753 print appropriate string and return. */
755 if (TYPE_STUB (real_type
))
757 fprintf_filtered (stream
, _("<incomplete type>"));
762 if (!valprint_check_validity (stream
, real_type
, embedded_offset
, val
))
767 ret
= apply_val_pretty_printer (type
, valaddr
, embedded_offset
,
768 address
, stream
, recurse
,
769 val
, options
, language
);
774 /* Handle summary mode. If the value is a scalar, print it;
775 otherwise, print an ellipsis. */
776 if (options
->summary
&& !val_print_scalar_type_p (type
))
778 fprintf_filtered (stream
, "...");
782 TRY_CATCH (except
, RETURN_MASK_ERROR
)
784 language
->la_val_print (type
, valaddr
, embedded_offset
, address
,
785 stream
, recurse
, val
,
788 if (except
.reason
< 0)
789 fprintf_filtered (stream
, _("<error reading variable>"));
792 /* Check whether the value VAL is printable. Return 1 if it is;
793 return 0 and print an appropriate error message to STREAM according to
794 OPTIONS if it is not. */
797 value_check_printable (struct value
*val
, struct ui_file
*stream
,
798 const struct value_print_options
*options
)
802 fprintf_filtered (stream
, _("<address of value unknown>"));
806 if (value_entirely_optimized_out (val
))
808 if (options
->summary
&& !val_print_scalar_type_p (value_type (val
)))
809 fprintf_filtered (stream
, "...");
811 val_print_optimized_out (val
, stream
);
815 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INTERNAL_FUNCTION
)
817 fprintf_filtered (stream
, _("<internal function %s>"),
818 value_internal_function_name (val
));
825 /* Print using the given LANGUAGE the value VAL onto stream STREAM according
828 This is a preferable interface to val_print, above, because it uses
829 GDB's value mechanism. */
832 common_val_print (struct value
*val
, struct ui_file
*stream
, int recurse
,
833 const struct value_print_options
*options
,
834 const struct language_defn
*language
)
836 if (!value_check_printable (val
, stream
, options
))
839 if (language
->la_language
== language_ada
)
840 /* The value might have a dynamic type, which would cause trouble
841 below when trying to extract the value contents (since the value
842 size is determined from the type size which is unknown). So
843 get a fixed representation of our value. */
844 val
= ada_to_fixed_value (val
);
846 val_print (value_type (val
), value_contents_for_printing (val
),
847 value_embedded_offset (val
), value_address (val
),
849 val
, options
, language
);
852 /* Print on stream STREAM the value VAL according to OPTIONS. The value
853 is printed using the current_language syntax. */
856 value_print (struct value
*val
, struct ui_file
*stream
,
857 const struct value_print_options
*options
)
859 if (!value_check_printable (val
, stream
, options
))
864 int r
= apply_val_pretty_printer (value_type (val
),
865 value_contents_for_printing (val
),
866 value_embedded_offset (val
),
869 val
, options
, current_language
);
875 LA_VALUE_PRINT (val
, stream
, options
);
878 /* Called by various <lang>_val_print routines to print
879 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
880 value. STREAM is where to print the value. */
883 val_print_type_code_int (struct type
*type
, const gdb_byte
*valaddr
,
884 struct ui_file
*stream
)
886 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
888 if (TYPE_LENGTH (type
) > sizeof (LONGEST
))
892 if (TYPE_UNSIGNED (type
)
893 && extract_long_unsigned_integer (valaddr
, TYPE_LENGTH (type
),
896 print_longest (stream
, 'u', 0, val
);
900 /* Signed, or we couldn't turn an unsigned value into a
901 LONGEST. For signed values, one could assume two's
902 complement (a reasonable assumption, I think) and do
904 print_hex_chars (stream
, (unsigned char *) valaddr
,
905 TYPE_LENGTH (type
), byte_order
);
910 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0,
911 unpack_long (type
, valaddr
));
916 val_print_type_code_flags (struct type
*type
, const gdb_byte
*valaddr
,
917 struct ui_file
*stream
)
919 ULONGEST val
= unpack_long (type
, valaddr
);
920 int bitpos
, nfields
= TYPE_NFIELDS (type
);
922 fputs_filtered ("[ ", stream
);
923 for (bitpos
= 0; bitpos
< nfields
; bitpos
++)
925 if (TYPE_FIELD_BITPOS (type
, bitpos
) != -1
926 && (val
& ((ULONGEST
)1 << bitpos
)))
928 if (TYPE_FIELD_NAME (type
, bitpos
))
929 fprintf_filtered (stream
, "%s ", TYPE_FIELD_NAME (type
, bitpos
));
931 fprintf_filtered (stream
, "#%d ", bitpos
);
934 fputs_filtered ("]", stream
);
937 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
938 according to OPTIONS and SIZE on STREAM. Format i is not supported
941 This is how the elements of an array or structure are printed
945 val_print_scalar_formatted (struct type
*type
,
946 const gdb_byte
*valaddr
, int embedded_offset
,
947 const struct value
*val
,
948 const struct value_print_options
*options
,
950 struct ui_file
*stream
)
952 gdb_assert (val
!= NULL
);
953 gdb_assert (valaddr
== value_contents_for_printing_const (val
));
955 /* If we get here with a string format, try again without it. Go
956 all the way back to the language printers, which may call us
958 if (options
->format
== 's')
960 struct value_print_options opts
= *options
;
963 val_print (type
, valaddr
, embedded_offset
, 0, stream
, 0, val
, &opts
,
968 /* A scalar object that does not have all bits available can't be
969 printed, because all bits contribute to its representation. */
970 if (!value_bits_valid (val
, TARGET_CHAR_BIT
* embedded_offset
,
971 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
972 val_print_optimized_out (val
, stream
);
973 else if (!value_bytes_available (val
, embedded_offset
, TYPE_LENGTH (type
)))
974 val_print_unavailable (stream
);
976 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
977 options
, size
, stream
);
980 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
981 The raison d'etre of this function is to consolidate printing of
982 LONG_LONG's into this one function. The format chars b,h,w,g are
983 from print_scalar_formatted(). Numbers are printed using C
986 USE_C_FORMAT means to use C format in all cases. Without it,
987 'o' and 'x' format do not include the standard C radix prefix
990 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
991 and was intended to request formating according to the current
992 language and would be used for most integers that GDB prints. The
993 exceptional cases were things like protocols where the format of
994 the integer is a protocol thing, not a user-visible thing). The
995 parameter remains to preserve the information of what things might
996 be printed with language-specific format, should we ever resurrect
1000 print_longest (struct ui_file
*stream
, int format
, int use_c_format
,
1008 val
= int_string (val_long
, 10, 1, 0, 1); break;
1010 val
= int_string (val_long
, 10, 0, 0, 1); break;
1012 val
= int_string (val_long
, 16, 0, 0, use_c_format
); break;
1014 val
= int_string (val_long
, 16, 0, 2, 1); break;
1016 val
= int_string (val_long
, 16, 0, 4, 1); break;
1018 val
= int_string (val_long
, 16, 0, 8, 1); break;
1020 val
= int_string (val_long
, 16, 0, 16, 1); break;
1023 val
= int_string (val_long
, 8, 0, 0, use_c_format
); break;
1025 internal_error (__FILE__
, __LINE__
,
1026 _("failed internal consistency check"));
1028 fputs_filtered (val
, stream
);
1031 /* This used to be a macro, but I don't think it is called often enough
1032 to merit such treatment. */
1033 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
1034 arguments to a function, number in a value history, register number, etc.)
1035 where the value must not be larger than can fit in an int. */
1038 longest_to_int (LONGEST arg
)
1040 /* Let the compiler do the work. */
1041 int rtnval
= (int) arg
;
1043 /* Check for overflows or underflows. */
1044 if (sizeof (LONGEST
) > sizeof (int))
1048 error (_("Value out of range."));
1054 /* Print a floating point value of type TYPE (not always a
1055 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
1058 print_floating (const gdb_byte
*valaddr
, struct type
*type
,
1059 struct ui_file
*stream
)
1063 const struct floatformat
*fmt
= NULL
;
1064 unsigned len
= TYPE_LENGTH (type
);
1065 enum float_kind kind
;
1067 /* If it is a floating-point, check for obvious problems. */
1068 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
1069 fmt
= floatformat_from_type (type
);
1072 kind
= floatformat_classify (fmt
, valaddr
);
1073 if (kind
== float_nan
)
1075 if (floatformat_is_negative (fmt
, valaddr
))
1076 fprintf_filtered (stream
, "-");
1077 fprintf_filtered (stream
, "nan(");
1078 fputs_filtered ("0x", stream
);
1079 fputs_filtered (floatformat_mantissa (fmt
, valaddr
), stream
);
1080 fprintf_filtered (stream
, ")");
1083 else if (kind
== float_infinite
)
1085 if (floatformat_is_negative (fmt
, valaddr
))
1086 fputs_filtered ("-", stream
);
1087 fputs_filtered ("inf", stream
);
1092 /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
1093 isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double
1094 needs to be used as that takes care of any necessary type
1095 conversions. Such conversions are of course direct to DOUBLEST
1096 and disregard any possible target floating point limitations.
1097 For instance, a u64 would be converted and displayed exactly on a
1098 host with 80 bit DOUBLEST but with loss of information on a host
1099 with 64 bit DOUBLEST. */
1101 doub
= unpack_double (type
, valaddr
, &inv
);
1104 fprintf_filtered (stream
, "<invalid float value>");
1108 /* FIXME: kettenis/2001-01-20: The following code makes too much
1109 assumptions about the host and target floating point format. */
1111 /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
1112 not necessarily be a TYPE_CODE_FLT, the below ignores that and
1113 instead uses the type's length to determine the precision of the
1114 floating-point value being printed. */
1116 if (len
< sizeof (double))
1117 fprintf_filtered (stream
, "%.9g", (double) doub
);
1118 else if (len
== sizeof (double))
1119 fprintf_filtered (stream
, "%.17g", (double) doub
);
1121 #ifdef PRINTF_HAS_LONG_DOUBLE
1122 fprintf_filtered (stream
, "%.35Lg", doub
);
1124 /* This at least wins with values that are representable as
1126 fprintf_filtered (stream
, "%.17g", (double) doub
);
1131 print_decimal_floating (const gdb_byte
*valaddr
, struct type
*type
,
1132 struct ui_file
*stream
)
1134 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
1135 char decstr
[MAX_DECIMAL_STRING
];
1136 unsigned len
= TYPE_LENGTH (type
);
1138 decimal_to_string (valaddr
, len
, byte_order
, decstr
);
1139 fputs_filtered (decstr
, stream
);
1144 print_binary_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1145 unsigned len
, enum bfd_endian byte_order
)
1148 #define BITS_IN_BYTES 8
1154 /* Declared "int" so it will be signed.
1155 This ensures that right shift will shift in zeros. */
1157 const int mask
= 0x080;
1159 /* FIXME: We should be not printing leading zeroes in most cases. */
1161 if (byte_order
== BFD_ENDIAN_BIG
)
1167 /* Every byte has 8 binary characters; peel off
1168 and print from the MSB end. */
1170 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
1172 if (*p
& (mask
>> i
))
1177 fprintf_filtered (stream
, "%1d", b
);
1183 for (p
= valaddr
+ len
- 1;
1187 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
1189 if (*p
& (mask
>> i
))
1194 fprintf_filtered (stream
, "%1d", b
);
1200 /* VALADDR points to an integer of LEN bytes.
1201 Print it in octal on stream or format it in buf. */
1204 print_octal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1205 unsigned len
, enum bfd_endian byte_order
)
1208 unsigned char octa1
, octa2
, octa3
, carry
;
1211 /* FIXME: We should be not printing leading zeroes in most cases. */
1214 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
1215 * the extra bits, which cycle every three bytes:
1217 * Byte side: 0 1 2 3
1219 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
1221 * Octal side: 0 1 carry 3 4 carry ...
1223 * Cycle number: 0 1 2
1225 * But of course we are printing from the high side, so we have to
1226 * figure out where in the cycle we are so that we end up with no
1227 * left over bits at the end.
1229 #define BITS_IN_OCTAL 3
1230 #define HIGH_ZERO 0340
1231 #define LOW_ZERO 0016
1232 #define CARRY_ZERO 0003
1233 #define HIGH_ONE 0200
1234 #define MID_ONE 0160
1235 #define LOW_ONE 0016
1236 #define CARRY_ONE 0001
1237 #define HIGH_TWO 0300
1238 #define MID_TWO 0070
1239 #define LOW_TWO 0007
1241 /* For 32 we start in cycle 2, with two bits and one bit carry;
1242 for 64 in cycle in cycle 1, with one bit and a two bit carry. */
1244 cycle
= (len
* BITS_IN_BYTES
) % BITS_IN_OCTAL
;
1247 fputs_filtered ("0", stream
);
1248 if (byte_order
== BFD_ENDIAN_BIG
)
1257 /* No carry in, carry out two bits. */
1259 octa1
= (HIGH_ZERO
& *p
) >> 5;
1260 octa2
= (LOW_ZERO
& *p
) >> 2;
1261 carry
= (CARRY_ZERO
& *p
);
1262 fprintf_filtered (stream
, "%o", octa1
);
1263 fprintf_filtered (stream
, "%o", octa2
);
1267 /* Carry in two bits, carry out one bit. */
1269 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
1270 octa2
= (MID_ONE
& *p
) >> 4;
1271 octa3
= (LOW_ONE
& *p
) >> 1;
1272 carry
= (CARRY_ONE
& *p
);
1273 fprintf_filtered (stream
, "%o", octa1
);
1274 fprintf_filtered (stream
, "%o", octa2
);
1275 fprintf_filtered (stream
, "%o", octa3
);
1279 /* Carry in one bit, no carry out. */
1281 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
1282 octa2
= (MID_TWO
& *p
) >> 3;
1283 octa3
= (LOW_TWO
& *p
);
1285 fprintf_filtered (stream
, "%o", octa1
);
1286 fprintf_filtered (stream
, "%o", octa2
);
1287 fprintf_filtered (stream
, "%o", octa3
);
1291 error (_("Internal error in octal conversion;"));
1295 cycle
= cycle
% BITS_IN_OCTAL
;
1300 for (p
= valaddr
+ len
- 1;
1307 /* Carry out, no carry in */
1309 octa1
= (HIGH_ZERO
& *p
) >> 5;
1310 octa2
= (LOW_ZERO
& *p
) >> 2;
1311 carry
= (CARRY_ZERO
& *p
);
1312 fprintf_filtered (stream
, "%o", octa1
);
1313 fprintf_filtered (stream
, "%o", octa2
);
1317 /* Carry in, carry out */
1319 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
1320 octa2
= (MID_ONE
& *p
) >> 4;
1321 octa3
= (LOW_ONE
& *p
) >> 1;
1322 carry
= (CARRY_ONE
& *p
);
1323 fprintf_filtered (stream
, "%o", octa1
);
1324 fprintf_filtered (stream
, "%o", octa2
);
1325 fprintf_filtered (stream
, "%o", octa3
);
1329 /* Carry in, no carry out */
1331 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
1332 octa2
= (MID_TWO
& *p
) >> 3;
1333 octa3
= (LOW_TWO
& *p
);
1335 fprintf_filtered (stream
, "%o", octa1
);
1336 fprintf_filtered (stream
, "%o", octa2
);
1337 fprintf_filtered (stream
, "%o", octa3
);
1341 error (_("Internal error in octal conversion;"));
1345 cycle
= cycle
% BITS_IN_OCTAL
;
1351 /* VALADDR points to an integer of LEN bytes.
1352 Print it in decimal on stream or format it in buf. */
1355 print_decimal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1356 unsigned len
, enum bfd_endian byte_order
)
1359 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
1360 #define CARRY_LEFT( x ) ((x) % TEN)
1361 #define SHIFT( x ) ((x) << 4)
1362 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
1363 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
1366 unsigned char *digits
;
1369 int i
, j
, decimal_digits
;
1373 /* Base-ten number is less than twice as many digits
1374 as the base 16 number, which is 2 digits per byte. */
1376 decimal_len
= len
* 2 * 2;
1377 digits
= xmalloc (decimal_len
);
1379 for (i
= 0; i
< decimal_len
; i
++)
1384 /* Ok, we have an unknown number of bytes of data to be printed in
1387 * Given a hex number (in nibbles) as XYZ, we start by taking X and
1388 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
1389 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
1391 * The trick is that "digits" holds a base-10 number, but sometimes
1392 * the individual digits are > 10.
1394 * Outer loop is per nibble (hex digit) of input, from MSD end to
1397 decimal_digits
= 0; /* Number of decimal digits so far */
1398 p
= (byte_order
== BFD_ENDIAN_BIG
) ? valaddr
: valaddr
+ len
- 1;
1400 while ((byte_order
== BFD_ENDIAN_BIG
) ? (p
< valaddr
+ len
) : (p
>= valaddr
))
1403 * Multiply current base-ten number by 16 in place.
1404 * Each digit was between 0 and 9, now is between
1407 for (j
= 0; j
< decimal_digits
; j
++)
1409 digits
[j
] = SHIFT (digits
[j
]);
1412 /* Take the next nibble off the input and add it to what
1413 * we've got in the LSB position. Bottom 'digit' is now
1414 * between 0 and 159.
1416 * "flip" is used to run this loop twice for each byte.
1420 /* Take top nibble. */
1422 digits
[0] += HIGH_NIBBLE (*p
);
1427 /* Take low nibble and bump our pointer "p". */
1429 digits
[0] += LOW_NIBBLE (*p
);
1430 if (byte_order
== BFD_ENDIAN_BIG
)
1437 /* Re-decimalize. We have to do this often enough
1438 * that we don't overflow, but once per nibble is
1439 * overkill. Easier this way, though. Note that the
1440 * carry is often larger than 10 (e.g. max initial
1441 * carry out of lowest nibble is 15, could bubble all
1442 * the way up greater than 10). So we have to do
1443 * the carrying beyond the last current digit.
1446 for (j
= 0; j
< decimal_len
- 1; j
++)
1450 /* "/" won't handle an unsigned char with
1451 * a value that if signed would be negative.
1452 * So extend to longword int via "dummy".
1455 carry
= CARRY_OUT (dummy
);
1456 digits
[j
] = CARRY_LEFT (dummy
);
1458 if (j
>= decimal_digits
&& carry
== 0)
1461 * All higher digits are 0 and we
1462 * no longer have a carry.
1464 * Note: "j" is 0-based, "decimal_digits" is
1467 decimal_digits
= j
+ 1;
1473 /* Ok, now "digits" is the decimal representation, with
1474 the "decimal_digits" actual digits. Print! */
1476 for (i
= decimal_digits
- 1; i
>= 0; i
--)
1478 fprintf_filtered (stream
, "%1d", digits
[i
]);
1483 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
1486 print_hex_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1487 unsigned len
, enum bfd_endian byte_order
)
1491 /* FIXME: We should be not printing leading zeroes in most cases. */
1493 fputs_filtered ("0x", stream
);
1494 if (byte_order
== BFD_ENDIAN_BIG
)
1500 fprintf_filtered (stream
, "%02x", *p
);
1505 for (p
= valaddr
+ len
- 1;
1509 fprintf_filtered (stream
, "%02x", *p
);
1514 /* VALADDR points to a char integer of LEN bytes.
1515 Print it out in appropriate language form on stream.
1516 Omit any leading zero chars. */
1519 print_char_chars (struct ui_file
*stream
, struct type
*type
,
1520 const gdb_byte
*valaddr
,
1521 unsigned len
, enum bfd_endian byte_order
)
1525 if (byte_order
== BFD_ENDIAN_BIG
)
1528 while (p
< valaddr
+ len
- 1 && *p
== 0)
1531 while (p
< valaddr
+ len
)
1533 LA_EMIT_CHAR (*p
, type
, stream
, '\'');
1539 p
= valaddr
+ len
- 1;
1540 while (p
> valaddr
&& *p
== 0)
1543 while (p
>= valaddr
)
1545 LA_EMIT_CHAR (*p
, type
, stream
, '\'');
1551 /* Print function pointer with inferior address ADDRESS onto stdio
1555 print_function_pointer_address (const struct value_print_options
*options
,
1556 struct gdbarch
*gdbarch
,
1558 struct ui_file
*stream
)
1561 = gdbarch_convert_from_func_ptr_addr (gdbarch
, address
,
1564 /* If the function pointer is represented by a description, print
1565 the address of the description. */
1566 if (options
->addressprint
&& func_addr
!= address
)
1568 fputs_filtered ("@", stream
);
1569 fputs_filtered (paddress (gdbarch
, address
), stream
);
1570 fputs_filtered (": ", stream
);
1572 print_address_demangle (options
, gdbarch
, func_addr
, stream
, demangle
);
1576 /* Print on STREAM using the given OPTIONS the index for the element
1577 at INDEX of an array whose index type is INDEX_TYPE. */
1580 maybe_print_array_index (struct type
*index_type
, LONGEST index
,
1581 struct ui_file
*stream
,
1582 const struct value_print_options
*options
)
1584 struct value
*index_value
;
1586 if (!options
->print_array_indexes
)
1589 index_value
= value_from_longest (index_type
, index
);
1591 LA_PRINT_ARRAY_INDEX (index_value
, stream
, options
);
1594 /* Called by various <lang>_val_print routines to print elements of an
1595 array in the form "<elem1>, <elem2>, <elem3>, ...".
1597 (FIXME?) Assumes array element separator is a comma, which is correct
1598 for all languages currently handled.
1599 (FIXME?) Some languages have a notation for repeated array elements,
1600 perhaps we should try to use that notation when appropriate. */
1603 val_print_array_elements (struct type
*type
,
1604 const gdb_byte
*valaddr
, int embedded_offset
,
1605 CORE_ADDR address
, struct ui_file
*stream
,
1607 const struct value
*val
,
1608 const struct value_print_options
*options
,
1611 unsigned int things_printed
= 0;
1613 struct type
*elttype
, *index_type
;
1615 /* Position of the array element we are examining to see
1616 whether it is repeated. */
1618 /* Number of repetitions we have detected so far. */
1620 LONGEST low_bound
, high_bound
;
1622 elttype
= TYPE_TARGET_TYPE (type
);
1623 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
1624 index_type
= TYPE_INDEX_TYPE (type
);
1626 if (get_array_bounds (type
, &low_bound
, &high_bound
))
1628 /* The array length should normally be HIGH_BOUND - LOW_BOUND + 1.
1629 But we have to be a little extra careful, because some languages
1630 such as Ada allow LOW_BOUND to be greater than HIGH_BOUND for
1631 empty arrays. In that situation, the array length is just zero,
1633 if (low_bound
> high_bound
)
1636 len
= high_bound
- low_bound
+ 1;
1640 warning (_("unable to get bounds of array, assuming null array"));
1645 annotate_array_section_begin (i
, elttype
);
1647 for (; i
< len
&& things_printed
< options
->print_max
; i
++)
1651 if (options
->prettyformat_arrays
)
1653 fprintf_filtered (stream
, ",\n");
1654 print_spaces_filtered (2 + 2 * recurse
, stream
);
1658 fprintf_filtered (stream
, ", ");
1661 wrap_here (n_spaces (2 + 2 * recurse
));
1662 maybe_print_array_index (index_type
, i
+ low_bound
,
1667 /* Only check for reps if repeat_count_threshold is not set to
1668 UINT_MAX (unlimited). */
1669 if (options
->repeat_count_threshold
< UINT_MAX
)
1672 && value_available_contents_eq (val
,
1673 embedded_offset
+ i
* eltlen
,
1684 if (reps
> options
->repeat_count_threshold
)
1686 val_print (elttype
, valaddr
, embedded_offset
+ i
* eltlen
,
1687 address
, stream
, recurse
+ 1, val
, options
,
1689 annotate_elt_rep (reps
);
1690 fprintf_filtered (stream
, " <repeats %u times>", reps
);
1691 annotate_elt_rep_end ();
1694 things_printed
+= options
->repeat_count_threshold
;
1698 val_print (elttype
, valaddr
, embedded_offset
+ i
* eltlen
,
1700 stream
, recurse
+ 1, val
, options
, current_language
);
1705 annotate_array_section_end ();
1708 fprintf_filtered (stream
, "...");
1712 /* Read LEN bytes of target memory at address MEMADDR, placing the
1713 results in GDB's memory at MYADDR. Returns a count of the bytes
1714 actually read, and optionally a target_xfer_error value in the
1715 location pointed to by ERRPTR if ERRPTR is non-null. */
1717 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
1718 function be eliminated. */
1721 partial_memory_read (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
1722 int len
, int *errptr
)
1724 int nread
; /* Number of bytes actually read. */
1725 int errcode
; /* Error from last read. */
1727 /* First try a complete read. */
1728 errcode
= target_read_memory (memaddr
, myaddr
, len
);
1736 /* Loop, reading one byte at a time until we get as much as we can. */
1737 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
1739 errcode
= target_read_memory (memaddr
++, myaddr
++, 1);
1741 /* If an error, the last read was unsuccessful, so adjust count. */
1754 /* Read a string from the inferior, at ADDR, with LEN characters of WIDTH bytes
1755 each. Fetch at most FETCHLIMIT characters. BUFFER will be set to a newly
1756 allocated buffer containing the string, which the caller is responsible to
1757 free, and BYTES_READ will be set to the number of bytes read. Returns 0 on
1758 success, or a target_xfer_error on failure.
1760 If LEN > 0, reads exactly LEN characters (including eventual NULs in
1761 the middle or end of the string). If LEN is -1, stops at the first
1762 null character (not necessarily the first null byte) up to a maximum
1763 of FETCHLIMIT characters. Set FETCHLIMIT to UINT_MAX to read as many
1764 characters as possible from the string.
1766 Unless an exception is thrown, BUFFER will always be allocated, even on
1767 failure. In this case, some characters might have been read before the
1768 failure happened. Check BYTES_READ to recognize this situation.
1770 Note: There was a FIXME asking to make this code use target_read_string,
1771 but this function is more general (can read past null characters, up to
1772 given LEN). Besides, it is used much more often than target_read_string
1773 so it is more tested. Perhaps callers of target_read_string should use
1774 this function instead? */
1777 read_string (CORE_ADDR addr
, int len
, int width
, unsigned int fetchlimit
,
1778 enum bfd_endian byte_order
, gdb_byte
**buffer
, int *bytes_read
)
1780 int found_nul
; /* Non-zero if we found the nul char. */
1781 int errcode
; /* Errno returned from bad reads. */
1782 unsigned int nfetch
; /* Chars to fetch / chars fetched. */
1783 unsigned int chunksize
; /* Size of each fetch, in chars. */
1784 gdb_byte
*bufptr
; /* Pointer to next available byte in
1786 gdb_byte
*limit
; /* First location past end of fetch buffer. */
1787 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
1789 /* Decide how large of chunks to try to read in one operation. This
1790 is also pretty simple. If LEN >= zero, then we want fetchlimit chars,
1791 so we might as well read them all in one operation. If LEN is -1, we
1792 are looking for a NUL terminator to end the fetching, so we might as
1793 well read in blocks that are large enough to be efficient, but not so
1794 large as to be slow if fetchlimit happens to be large. So we choose the
1795 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
1796 200 is way too big for remote debugging over a serial line. */
1798 chunksize
= (len
== -1 ? min (8, fetchlimit
) : fetchlimit
);
1800 /* Loop until we either have all the characters, or we encounter
1801 some error, such as bumping into the end of the address space. */
1806 old_chain
= make_cleanup (free_current_contents
, buffer
);
1810 *buffer
= (gdb_byte
*) xmalloc (len
* width
);
1813 nfetch
= partial_memory_read (addr
, bufptr
, len
* width
, &errcode
)
1815 addr
+= nfetch
* width
;
1816 bufptr
+= nfetch
* width
;
1820 unsigned long bufsize
= 0;
1825 nfetch
= min (chunksize
, fetchlimit
- bufsize
);
1827 if (*buffer
== NULL
)
1828 *buffer
= (gdb_byte
*) xmalloc (nfetch
* width
);
1830 *buffer
= (gdb_byte
*) xrealloc (*buffer
,
1831 (nfetch
+ bufsize
) * width
);
1833 bufptr
= *buffer
+ bufsize
* width
;
1836 /* Read as much as we can. */
1837 nfetch
= partial_memory_read (addr
, bufptr
, nfetch
* width
, &errcode
)
1840 /* Scan this chunk for the null character that terminates the string
1841 to print. If found, we don't need to fetch any more. Note
1842 that bufptr is explicitly left pointing at the next character
1843 after the null character, or at the next character after the end
1846 limit
= bufptr
+ nfetch
* width
;
1847 while (bufptr
< limit
)
1851 c
= extract_unsigned_integer (bufptr
, width
, byte_order
);
1856 /* We don't care about any error which happened after
1857 the NUL terminator. */
1864 while (errcode
== 0 /* no error */
1865 && bufptr
- *buffer
< fetchlimit
* width
/* no overrun */
1866 && !found_nul
); /* haven't found NUL yet */
1869 { /* Length of string is really 0! */
1870 /* We always allocate *buffer. */
1871 *buffer
= bufptr
= xmalloc (1);
1875 /* bufptr and addr now point immediately beyond the last byte which we
1876 consider part of the string (including a '\0' which ends the string). */
1877 *bytes_read
= bufptr
- *buffer
;
1881 discard_cleanups (old_chain
);
1886 /* Return true if print_wchar can display W without resorting to a
1887 numeric escape, false otherwise. */
1890 wchar_printable (gdb_wchar_t w
)
1892 return (gdb_iswprint (w
)
1893 || w
== LCST ('\a') || w
== LCST ('\b')
1894 || w
== LCST ('\f') || w
== LCST ('\n')
1895 || w
== LCST ('\r') || w
== LCST ('\t')
1896 || w
== LCST ('\v'));
1899 /* A helper function that converts the contents of STRING to wide
1900 characters and then appends them to OUTPUT. */
1903 append_string_as_wide (const char *string
,
1904 struct obstack
*output
)
1906 for (; *string
; ++string
)
1908 gdb_wchar_t w
= gdb_btowc (*string
);
1909 obstack_grow (output
, &w
, sizeof (gdb_wchar_t
));
1913 /* Print a wide character W to OUTPUT. ORIG is a pointer to the
1914 original (target) bytes representing the character, ORIG_LEN is the
1915 number of valid bytes. WIDTH is the number of bytes in a base
1916 characters of the type. OUTPUT is an obstack to which wide
1917 characters are emitted. QUOTER is a (narrow) character indicating
1918 the style of quotes surrounding the character to be printed.
1919 NEED_ESCAPE is an in/out flag which is used to track numeric
1920 escapes across calls. */
1923 print_wchar (gdb_wint_t w
, const gdb_byte
*orig
,
1924 int orig_len
, int width
,
1925 enum bfd_endian byte_order
,
1926 struct obstack
*output
,
1927 int quoter
, int *need_escapep
)
1929 int need_escape
= *need_escapep
;
1932 if (gdb_iswprint (w
) && (!need_escape
|| (!gdb_iswdigit (w
)
1934 && w
!= LCST ('9'))))
1936 gdb_wchar_t wchar
= w
;
1938 if (w
== gdb_btowc (quoter
) || w
== LCST ('\\'))
1939 obstack_grow_wstr (output
, LCST ("\\"));
1940 obstack_grow (output
, &wchar
, sizeof (gdb_wchar_t
));
1947 obstack_grow_wstr (output
, LCST ("\\a"));
1950 obstack_grow_wstr (output
, LCST ("\\b"));
1953 obstack_grow_wstr (output
, LCST ("\\f"));
1956 obstack_grow_wstr (output
, LCST ("\\n"));
1959 obstack_grow_wstr (output
, LCST ("\\r"));
1962 obstack_grow_wstr (output
, LCST ("\\t"));
1965 obstack_grow_wstr (output
, LCST ("\\v"));
1971 for (i
= 0; i
+ width
<= orig_len
; i
+= width
)
1976 value
= extract_unsigned_integer (&orig
[i
], width
,
1978 /* If the value fits in 3 octal digits, print it that
1979 way. Otherwise, print it as a hex escape. */
1981 xsnprintf (octal
, sizeof (octal
), "\\%.3o",
1982 (int) (value
& 0777));
1984 xsnprintf (octal
, sizeof (octal
), "\\x%lx", (long) value
);
1985 append_string_as_wide (octal
, output
);
1987 /* If we somehow have extra bytes, print them now. */
1988 while (i
< orig_len
)
1992 xsnprintf (octal
, sizeof (octal
), "\\%.3o", orig
[i
] & 0xff);
1993 append_string_as_wide (octal
, output
);
2004 /* Print the character C on STREAM as part of the contents of a
2005 literal string whose delimiter is QUOTER. ENCODING names the
2009 generic_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
2010 int quoter
, const char *encoding
)
2012 enum bfd_endian byte_order
2013 = gdbarch_byte_order (get_type_arch (type
));
2014 struct obstack wchar_buf
, output
;
2015 struct cleanup
*cleanups
;
2017 struct wchar_iterator
*iter
;
2018 int need_escape
= 0;
2020 buf
= alloca (TYPE_LENGTH (type
));
2021 pack_long (buf
, type
, c
);
2023 iter
= make_wchar_iterator (buf
, TYPE_LENGTH (type
),
2024 encoding
, TYPE_LENGTH (type
));
2025 cleanups
= make_cleanup_wchar_iterator (iter
);
2027 /* This holds the printable form of the wchar_t data. */
2028 obstack_init (&wchar_buf
);
2029 make_cleanup_obstack_free (&wchar_buf
);
2035 const gdb_byte
*buf
;
2037 int print_escape
= 1;
2038 enum wchar_iterate_result result
;
2040 num_chars
= wchar_iterate (iter
, &result
, &chars
, &buf
, &buflen
);
2045 /* If all characters are printable, print them. Otherwise,
2046 we're going to have to print an escape sequence. We
2047 check all characters because we want to print the target
2048 bytes in the escape sequence, and we don't know character
2049 boundaries there. */
2053 for (i
= 0; i
< num_chars
; ++i
)
2054 if (!wchar_printable (chars
[i
]))
2062 for (i
= 0; i
< num_chars
; ++i
)
2063 print_wchar (chars
[i
], buf
, buflen
,
2064 TYPE_LENGTH (type
), byte_order
,
2065 &wchar_buf
, quoter
, &need_escape
);
2069 /* This handles the NUM_CHARS == 0 case as well. */
2071 print_wchar (gdb_WEOF
, buf
, buflen
, TYPE_LENGTH (type
),
2072 byte_order
, &wchar_buf
, quoter
, &need_escape
);
2075 /* The output in the host encoding. */
2076 obstack_init (&output
);
2077 make_cleanup_obstack_free (&output
);
2079 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
2080 (gdb_byte
*) obstack_base (&wchar_buf
),
2081 obstack_object_size (&wchar_buf
),
2082 sizeof (gdb_wchar_t
), &output
, translit_char
);
2083 obstack_1grow (&output
, '\0');
2085 fputs_filtered (obstack_base (&output
), stream
);
2087 do_cleanups (cleanups
);
2090 /* Return the repeat count of the next character/byte in ITER,
2091 storing the result in VEC. */
2094 count_next_character (struct wchar_iterator
*iter
,
2095 VEC (converted_character_d
) **vec
)
2097 struct converted_character
*current
;
2099 if (VEC_empty (converted_character_d
, *vec
))
2101 struct converted_character tmp
;
2105 = wchar_iterate (iter
, &tmp
.result
, &chars
, &tmp
.buf
, &tmp
.buflen
);
2106 if (tmp
.num_chars
> 0)
2108 gdb_assert (tmp
.num_chars
< MAX_WCHARS
);
2109 memcpy (tmp
.chars
, chars
, tmp
.num_chars
* sizeof (gdb_wchar_t
));
2111 VEC_safe_push (converted_character_d
, *vec
, &tmp
);
2114 current
= VEC_last (converted_character_d
, *vec
);
2116 /* Count repeated characters or bytes. */
2117 current
->repeat_count
= 1;
2118 if (current
->num_chars
== -1)
2126 struct converted_character d
;
2133 /* Get the next character. */
2135 = wchar_iterate (iter
, &d
.result
, &chars
, &d
.buf
, &d
.buflen
);
2137 /* If a character was successfully converted, save the character
2138 into the converted character. */
2139 if (d
.num_chars
> 0)
2141 gdb_assert (d
.num_chars
< MAX_WCHARS
);
2142 memcpy (d
.chars
, chars
, WCHAR_BUFLEN (d
.num_chars
));
2145 /* Determine if the current character is the same as this
2147 if (d
.num_chars
== current
->num_chars
&& d
.result
== current
->result
)
2149 /* There are two cases to consider:
2151 1) Equality of converted character (num_chars > 0)
2152 2) Equality of non-converted character (num_chars == 0) */
2153 if ((current
->num_chars
> 0
2154 && memcmp (current
->chars
, d
.chars
,
2155 WCHAR_BUFLEN (current
->num_chars
)) == 0)
2156 || (current
->num_chars
== 0
2157 && current
->buflen
== d
.buflen
2158 && memcmp (current
->buf
, d
.buf
, current
->buflen
) == 0))
2159 ++current
->repeat_count
;
2167 /* Push this next converted character onto the result vector. */
2168 repeat
= current
->repeat_count
;
2169 VEC_safe_push (converted_character_d
, *vec
, &d
);
2174 /* Print the characters in CHARS to the OBSTACK. QUOTE_CHAR is the quote
2175 character to use with string output. WIDTH is the size of the output
2176 character type. BYTE_ORDER is the the target byte order. OPTIONS
2177 is the user's print options. */
2180 print_converted_chars_to_obstack (struct obstack
*obstack
,
2181 VEC (converted_character_d
) *chars
,
2182 int quote_char
, int width
,
2183 enum bfd_endian byte_order
,
2184 const struct value_print_options
*options
)
2187 struct converted_character
*elem
;
2188 enum {START
, SINGLE
, REPEAT
, INCOMPLETE
, FINISH
} state
, last
;
2189 gdb_wchar_t wide_quote_char
= gdb_btowc (quote_char
);
2190 int need_escape
= 0;
2192 /* Set the start state. */
2194 last
= state
= START
;
2202 /* Nothing to do. */
2209 /* We are outputting a single character
2210 (< options->repeat_count_threshold). */
2214 /* We were outputting some other type of content, so we
2215 must output and a comma and a quote. */
2217 obstack_grow_wstr (obstack
, LCST (", "));
2218 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2220 /* Output the character. */
2221 for (j
= 0; j
< elem
->repeat_count
; ++j
)
2223 if (elem
->result
== wchar_iterate_ok
)
2224 print_wchar (elem
->chars
[0], elem
->buf
, elem
->buflen
, width
,
2225 byte_order
, obstack
, quote_char
, &need_escape
);
2227 print_wchar (gdb_WEOF
, elem
->buf
, elem
->buflen
, width
,
2228 byte_order
, obstack
, quote_char
, &need_escape
);
2238 /* We are outputting a character with a repeat count
2239 greater than options->repeat_count_threshold. */
2243 /* We were outputting a single string. Terminate the
2245 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2248 obstack_grow_wstr (obstack
, LCST (", "));
2250 /* Output the character and repeat string. */
2251 obstack_grow_wstr (obstack
, LCST ("'"));
2252 if (elem
->result
== wchar_iterate_ok
)
2253 print_wchar (elem
->chars
[0], elem
->buf
, elem
->buflen
, width
,
2254 byte_order
, obstack
, quote_char
, &need_escape
);
2256 print_wchar (gdb_WEOF
, elem
->buf
, elem
->buflen
, width
,
2257 byte_order
, obstack
, quote_char
, &need_escape
);
2258 obstack_grow_wstr (obstack
, LCST ("'"));
2259 s
= xstrprintf (_(" <repeats %u times>"), elem
->repeat_count
);
2260 for (j
= 0; s
[j
]; ++j
)
2262 gdb_wchar_t w
= gdb_btowc (s
[j
]);
2263 obstack_grow (obstack
, &w
, sizeof (gdb_wchar_t
));
2270 /* We are outputting an incomplete sequence. */
2273 /* If we were outputting a string of SINGLE characters,
2274 terminate the quote. */
2275 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2278 obstack_grow_wstr (obstack
, LCST (", "));
2280 /* Output the incomplete sequence string. */
2281 obstack_grow_wstr (obstack
, LCST ("<incomplete sequence "));
2282 print_wchar (gdb_WEOF
, elem
->buf
, elem
->buflen
, width
, byte_order
,
2283 obstack
, 0, &need_escape
);
2284 obstack_grow_wstr (obstack
, LCST (">"));
2286 /* We do not attempt to outupt anything after this. */
2291 /* All done. If we were outputting a string of SINGLE
2292 characters, the string must be terminated. Otherwise,
2293 REPEAT and INCOMPLETE are always left properly terminated. */
2295 obstack_grow (obstack
, &wide_quote_char
, sizeof (gdb_wchar_t
));
2300 /* Get the next element and state. */
2302 if (state
!= FINISH
)
2304 elem
= VEC_index (converted_character_d
, chars
, idx
++);
2305 switch (elem
->result
)
2307 case wchar_iterate_ok
:
2308 case wchar_iterate_invalid
:
2309 if (elem
->repeat_count
> options
->repeat_count_threshold
)
2315 case wchar_iterate_incomplete
:
2319 case wchar_iterate_eof
:
2327 /* Print the character string STRING, printing at most LENGTH
2328 characters. LENGTH is -1 if the string is nul terminated. TYPE is
2329 the type of each character. OPTIONS holds the printing options;
2330 printing stops early if the number hits print_max; repeat counts
2331 are printed as appropriate. Print ellipses at the end if we had to
2332 stop before printing LENGTH characters, or if FORCE_ELLIPSES.
2333 QUOTE_CHAR is the character to print at each end of the string. If
2334 C_STYLE_TERMINATOR is true, and the last character is 0, then it is
2338 generic_printstr (struct ui_file
*stream
, struct type
*type
,
2339 const gdb_byte
*string
, unsigned int length
,
2340 const char *encoding
, int force_ellipses
,
2341 int quote_char
, int c_style_terminator
,
2342 const struct value_print_options
*options
)
2344 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
2346 int width
= TYPE_LENGTH (type
);
2347 struct obstack wchar_buf
, output
;
2348 struct cleanup
*cleanup
;
2349 struct wchar_iterator
*iter
;
2351 struct converted_character
*last
;
2352 VEC (converted_character_d
) *converted_chars
;
2356 unsigned long current_char
= 1;
2358 for (i
= 0; current_char
; ++i
)
2361 current_char
= extract_unsigned_integer (string
+ i
* width
,
2367 /* If the string was not truncated due to `set print elements', and
2368 the last byte of it is a null, we don't print that, in
2369 traditional C style. */
2370 if (c_style_terminator
2373 && (extract_unsigned_integer (string
+ (length
- 1) * width
,
2374 width
, byte_order
) == 0))
2379 fputs_filtered ("\"\"", stream
);
2383 /* Arrange to iterate over the characters, in wchar_t form. */
2384 iter
= make_wchar_iterator (string
, length
* width
, encoding
, width
);
2385 cleanup
= make_cleanup_wchar_iterator (iter
);
2386 converted_chars
= NULL
;
2387 make_cleanup (VEC_cleanup (converted_character_d
), &converted_chars
);
2389 /* Convert characters until the string is over or the maximum
2390 number of printed characters has been reached. */
2392 while (i
< options
->print_max
)
2398 /* Grab the next character and repeat count. */
2399 r
= count_next_character (iter
, &converted_chars
);
2401 /* If less than zero, the end of the input string was reached. */
2405 /* Otherwise, add the count to the total print count and get
2406 the next character. */
2410 /* Get the last element and determine if the entire string was
2412 last
= VEC_last (converted_character_d
, converted_chars
);
2413 finished
= (last
->result
== wchar_iterate_eof
);
2415 /* Ensure that CONVERTED_CHARS is terminated. */
2416 last
->result
= wchar_iterate_eof
;
2418 /* WCHAR_BUF is the obstack we use to represent the string in
2420 obstack_init (&wchar_buf
);
2421 make_cleanup_obstack_free (&wchar_buf
);
2423 /* Print the output string to the obstack. */
2424 print_converted_chars_to_obstack (&wchar_buf
, converted_chars
, quote_char
,
2425 width
, byte_order
, options
);
2427 if (force_ellipses
|| !finished
)
2428 obstack_grow_wstr (&wchar_buf
, LCST ("..."));
2430 /* OUTPUT is where we collect `char's for printing. */
2431 obstack_init (&output
);
2432 make_cleanup_obstack_free (&output
);
2434 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
2435 (gdb_byte
*) obstack_base (&wchar_buf
),
2436 obstack_object_size (&wchar_buf
),
2437 sizeof (gdb_wchar_t
), &output
, translit_char
);
2438 obstack_1grow (&output
, '\0');
2440 fputs_filtered (obstack_base (&output
), stream
);
2442 do_cleanups (cleanup
);
2445 /* Print a string from the inferior, starting at ADDR and printing up to LEN
2446 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
2447 stops at the first null byte, otherwise printing proceeds (including null
2448 bytes) until either print_max or LEN characters have been printed,
2449 whichever is smaller. ENCODING is the name of the string's
2450 encoding. It can be NULL, in which case the target encoding is
2454 val_print_string (struct type
*elttype
, const char *encoding
,
2455 CORE_ADDR addr
, int len
,
2456 struct ui_file
*stream
,
2457 const struct value_print_options
*options
)
2459 int force_ellipsis
= 0; /* Force ellipsis to be printed if nonzero. */
2460 int errcode
; /* Errno returned from bad reads. */
2461 int found_nul
; /* Non-zero if we found the nul char. */
2462 unsigned int fetchlimit
; /* Maximum number of chars to print. */
2464 gdb_byte
*buffer
= NULL
; /* Dynamically growable fetch buffer. */
2465 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
2466 struct gdbarch
*gdbarch
= get_type_arch (elttype
);
2467 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
2468 int width
= TYPE_LENGTH (elttype
);
2470 /* First we need to figure out the limit on the number of characters we are
2471 going to attempt to fetch and print. This is actually pretty simple. If
2472 LEN >= zero, then the limit is the minimum of LEN and print_max. If
2473 LEN is -1, then the limit is print_max. This is true regardless of
2474 whether print_max is zero, UINT_MAX (unlimited), or something in between,
2475 because finding the null byte (or available memory) is what actually
2476 limits the fetch. */
2478 fetchlimit
= (len
== -1 ? options
->print_max
: min (len
,
2479 options
->print_max
));
2481 errcode
= read_string (addr
, len
, width
, fetchlimit
, byte_order
,
2482 &buffer
, &bytes_read
);
2483 old_chain
= make_cleanup (xfree
, buffer
);
2487 /* We now have either successfully filled the buffer to fetchlimit,
2488 or terminated early due to an error or finding a null char when
2491 /* Determine found_nul by looking at the last character read. */
2492 found_nul
= extract_unsigned_integer (buffer
+ bytes_read
- width
, width
,
2494 if (len
== -1 && !found_nul
)
2498 /* We didn't find a NUL terminator we were looking for. Attempt
2499 to peek at the next character. If not successful, or it is not
2500 a null byte, then force ellipsis to be printed. */
2502 peekbuf
= (gdb_byte
*) alloca (width
);
2504 if (target_read_memory (addr
, peekbuf
, width
) == 0
2505 && extract_unsigned_integer (peekbuf
, width
, byte_order
) != 0)
2508 else if ((len
>= 0 && errcode
!= 0) || (len
> bytes_read
/ width
))
2510 /* Getting an error when we have a requested length, or fetching less
2511 than the number of characters actually requested, always make us
2516 /* If we get an error before fetching anything, don't print a string.
2517 But if we fetch something and then get an error, print the string
2518 and then the error message. */
2519 if (errcode
== 0 || bytes_read
> 0)
2521 LA_PRINT_STRING (stream
, elttype
, buffer
, bytes_read
/ width
,
2522 encoding
, force_ellipsis
, options
);
2529 str
= memory_error_message (errcode
, gdbarch
, addr
);
2530 make_cleanup (xfree
, str
);
2532 fprintf_filtered (stream
, "<error: ");
2533 fputs_filtered (str
, stream
);
2534 fprintf_filtered (stream
, ">");
2538 do_cleanups (old_chain
);
2540 return (bytes_read
/ width
);
2544 /* The 'set input-radix' command writes to this auxiliary variable.
2545 If the requested radix is valid, INPUT_RADIX is updated; otherwise,
2546 it is left unchanged. */
2548 static unsigned input_radix_1
= 10;
2550 /* Validate an input or output radix setting, and make sure the user
2551 knows what they really did here. Radix setting is confusing, e.g.
2552 setting the input radix to "10" never changes it! */
2555 set_input_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
2557 set_input_radix_1 (from_tty
, input_radix_1
);
2561 set_input_radix_1 (int from_tty
, unsigned radix
)
2563 /* We don't currently disallow any input radix except 0 or 1, which don't
2564 make any mathematical sense. In theory, we can deal with any input
2565 radix greater than 1, even if we don't have unique digits for every
2566 value from 0 to radix-1, but in practice we lose on large radix values.
2567 We should either fix the lossage or restrict the radix range more.
2572 input_radix_1
= input_radix
;
2573 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
2576 input_radix_1
= input_radix
= radix
;
2579 printf_filtered (_("Input radix now set to "
2580 "decimal %u, hex %x, octal %o.\n"),
2581 radix
, radix
, radix
);
2585 /* The 'set output-radix' command writes to this auxiliary variable.
2586 If the requested radix is valid, OUTPUT_RADIX is updated,
2587 otherwise, it is left unchanged. */
2589 static unsigned output_radix_1
= 10;
2592 set_output_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
2594 set_output_radix_1 (from_tty
, output_radix_1
);
2598 set_output_radix_1 (int from_tty
, unsigned radix
)
2600 /* Validate the radix and disallow ones that we aren't prepared to
2601 handle correctly, leaving the radix unchanged. */
2605 user_print_options
.output_format
= 'x'; /* hex */
2608 user_print_options
.output_format
= 0; /* decimal */
2611 user_print_options
.output_format
= 'o'; /* octal */
2614 output_radix_1
= output_radix
;
2615 error (_("Unsupported output radix ``decimal %u''; "
2616 "output radix unchanged."),
2619 output_radix_1
= output_radix
= radix
;
2622 printf_filtered (_("Output radix now set to "
2623 "decimal %u, hex %x, octal %o.\n"),
2624 radix
, radix
, radix
);
2628 /* Set both the input and output radix at once. Try to set the output radix
2629 first, since it has the most restrictive range. An radix that is valid as
2630 an output radix is also valid as an input radix.
2632 It may be useful to have an unusual input radix. If the user wishes to
2633 set an input radix that is not valid as an output radix, he needs to use
2634 the 'set input-radix' command. */
2637 set_radix (char *arg
, int from_tty
)
2641 radix
= (arg
== NULL
) ? 10 : parse_and_eval_long (arg
);
2642 set_output_radix_1 (0, radix
);
2643 set_input_radix_1 (0, radix
);
2646 printf_filtered (_("Input and output radices now set to "
2647 "decimal %u, hex %x, octal %o.\n"),
2648 radix
, radix
, radix
);
2652 /* Show both the input and output radices. */
2655 show_radix (char *arg
, int from_tty
)
2659 if (input_radix
== output_radix
)
2661 printf_filtered (_("Input and output radices set to "
2662 "decimal %u, hex %x, octal %o.\n"),
2663 input_radix
, input_radix
, input_radix
);
2667 printf_filtered (_("Input radix set to decimal "
2668 "%u, hex %x, octal %o.\n"),
2669 input_radix
, input_radix
, input_radix
);
2670 printf_filtered (_("Output radix set to decimal "
2671 "%u, hex %x, octal %o.\n"),
2672 output_radix
, output_radix
, output_radix
);
2679 set_print (char *arg
, int from_tty
)
2682 "\"set print\" must be followed by the name of a print subcommand.\n");
2683 help_list (setprintlist
, "set print ", -1, gdb_stdout
);
2687 show_print (char *args
, int from_tty
)
2689 cmd_show_list (showprintlist
, from_tty
, "");
2693 set_print_raw (char *arg
, int from_tty
)
2696 "\"set print raw\" must be followed by the name of a \"print raw\" subcommand.\n");
2697 help_list (setprintrawlist
, "set print raw ", -1, gdb_stdout
);
2701 show_print_raw (char *args
, int from_tty
)
2703 cmd_show_list (showprintrawlist
, from_tty
, "");
2708 _initialize_valprint (void)
2710 add_prefix_cmd ("print", no_class
, set_print
,
2711 _("Generic command for setting how things print."),
2712 &setprintlist
, "set print ", 0, &setlist
);
2713 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
2714 /* Prefer set print to set prompt. */
2715 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
);
2717 add_prefix_cmd ("print", no_class
, show_print
,
2718 _("Generic command for showing print settings."),
2719 &showprintlist
, "show print ", 0, &showlist
);
2720 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
2721 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
2723 add_prefix_cmd ("raw", no_class
, set_print_raw
,
2725 Generic command for setting what things to print in \"raw\" mode."),
2726 &setprintrawlist
, "set print raw ", 0, &setprintlist
);
2727 add_prefix_cmd ("raw", no_class
, show_print_raw
,
2728 _("Generic command for showing \"print raw\" settings."),
2729 &showprintrawlist
, "show print raw ", 0, &showprintlist
);
2731 add_setshow_uinteger_cmd ("elements", no_class
,
2732 &user_print_options
.print_max
, _("\
2733 Set limit on string chars or array elements to print."), _("\
2734 Show limit on string chars or array elements to print."), _("\
2735 \"set print elements unlimited\" causes there to be no limit."),
2738 &setprintlist
, &showprintlist
);
2740 add_setshow_boolean_cmd ("null-stop", no_class
,
2741 &user_print_options
.stop_print_at_null
, _("\
2742 Set printing of char arrays to stop at first null char."), _("\
2743 Show printing of char arrays to stop at first null char."), NULL
,
2745 show_stop_print_at_null
,
2746 &setprintlist
, &showprintlist
);
2748 add_setshow_uinteger_cmd ("repeats", no_class
,
2749 &user_print_options
.repeat_count_threshold
, _("\
2750 Set threshold for repeated print elements."), _("\
2751 Show threshold for repeated print elements."), _("\
2752 \"set print repeats unlimited\" causes all elements to be individually printed."),
2754 show_repeat_count_threshold
,
2755 &setprintlist
, &showprintlist
);
2757 add_setshow_boolean_cmd ("pretty", class_support
,
2758 &user_print_options
.prettyformat_structs
, _("\
2759 Set pretty formatting of structures."), _("\
2760 Show pretty formatting of structures."), NULL
,
2762 show_prettyformat_structs
,
2763 &setprintlist
, &showprintlist
);
2765 add_setshow_boolean_cmd ("union", class_support
,
2766 &user_print_options
.unionprint
, _("\
2767 Set printing of unions interior to structures."), _("\
2768 Show printing of unions interior to structures."), NULL
,
2771 &setprintlist
, &showprintlist
);
2773 add_setshow_boolean_cmd ("array", class_support
,
2774 &user_print_options
.prettyformat_arrays
, _("\
2775 Set pretty formatting of arrays."), _("\
2776 Show pretty formatting of arrays."), NULL
,
2778 show_prettyformat_arrays
,
2779 &setprintlist
, &showprintlist
);
2781 add_setshow_boolean_cmd ("address", class_support
,
2782 &user_print_options
.addressprint
, _("\
2783 Set printing of addresses."), _("\
2784 Show printing of addresses."), NULL
,
2787 &setprintlist
, &showprintlist
);
2789 add_setshow_boolean_cmd ("symbol", class_support
,
2790 &user_print_options
.symbol_print
, _("\
2791 Set printing of symbol names when printing pointers."), _("\
2792 Show printing of symbol names when printing pointers."),
2795 &setprintlist
, &showprintlist
);
2797 add_setshow_zuinteger_cmd ("input-radix", class_support
, &input_radix_1
,
2799 Set default input radix for entering numbers."), _("\
2800 Show default input radix for entering numbers."), NULL
,
2803 &setlist
, &showlist
);
2805 add_setshow_zuinteger_cmd ("output-radix", class_support
, &output_radix_1
,
2807 Set default output radix for printing of values."), _("\
2808 Show default output radix for printing of values."), NULL
,
2811 &setlist
, &showlist
);
2813 /* The "set radix" and "show radix" commands are special in that
2814 they are like normal set and show commands but allow two normally
2815 independent variables to be either set or shown with a single
2816 command. So the usual deprecated_add_set_cmd() and [deleted]
2817 add_show_from_set() commands aren't really appropriate. */
2818 /* FIXME: i18n: With the new add_setshow_integer command, that is no
2819 longer true - show can display anything. */
2820 add_cmd ("radix", class_support
, set_radix
, _("\
2821 Set default input and output number radices.\n\
2822 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
2823 Without an argument, sets both radices back to the default value of 10."),
2825 add_cmd ("radix", class_support
, show_radix
, _("\
2826 Show the default input and output number radices.\n\
2827 Use 'show input-radix' or 'show output-radix' to independently show each."),
2830 add_setshow_boolean_cmd ("array-indexes", class_support
,
2831 &user_print_options
.print_array_indexes
, _("\
2832 Set printing of array indexes."), _("\
2833 Show printing of array indexes"), NULL
, NULL
, show_print_array_indexes
,
2834 &setprintlist
, &showprintlist
);