1 /* Print values for GDB, the GNU debugger.
3 Copyright (C) 1986-2015 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/>. */
30 #include "floatformat.h"
33 #include "extension.h"
35 #include "gdb_obstack.h"
39 /* Maximum number of wchars returned from wchar_iterate. */
42 /* A convenience macro to compute the size of a wchar_t buffer containing X
44 #define WCHAR_BUFLEN(X) ((X) * sizeof (gdb_wchar_t))
46 /* Character buffer size saved while iterating over wchars. */
47 #define WCHAR_BUFLEN_MAX WCHAR_BUFLEN (MAX_WCHARS)
49 /* A structure to encapsulate state information from iterated
50 character conversions. */
51 struct converted_character
53 /* The number of characters converted. */
56 /* The result of the conversion. See charset.h for more. */
57 enum wchar_iterate_result result;
59 /* The (saved) converted character(s). */
60 gdb_wchar_t chars[WCHAR_BUFLEN_MAX];
62 /* The first converted target byte. */
65 /* The number of bytes converted. */
68 /* How many times this character(s) is repeated. */
72 typedef struct converted_character converted_character_d;
73 DEF_VEC_O (converted_character_d);
75 /* Command lists for set/show print raw. */
76 struct cmd_list_element *setprintrawlist;
77 struct cmd_list_element *showprintrawlist;
79 /* Prototypes for local functions */
81 static int partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
82 int len, int *errptr);
84 static void show_print (char *, int);
86 static void set_print (char *, int);
88 static void set_radix (char *, int);
90 static void show_radix (char *, int);
92 static void set_input_radix (char *, int, struct cmd_list_element *);
94 static void set_input_radix_1 (int, unsigned);
96 static void set_output_radix (char *, int, struct cmd_list_element *);
98 static void set_output_radix_1 (int, unsigned);
100 void _initialize_valprint (void);
102 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
104 struct value_print_options user_print_options =
106 Val_prettyformat_default, /* prettyformat */
107 0, /* prettyformat_arrays */
108 0, /* prettyformat_structs */
111 1, /* addressprint */
113 PRINT_MAX_DEFAULT, /* print_max */
114 10, /* repeat_count_threshold */
115 0, /* output_format */
117 0, /* stop_print_at_null */
118 0, /* print_array_indexes */
120 1, /* static_field_print */
121 1, /* pascal_static_field_print */
127 /* Initialize *OPTS to be a copy of the user print options. */
129 get_user_print_options (struct value_print_options *opts)
131 *opts = user_print_options;
134 /* Initialize *OPTS to be a copy of the user print options, but with
135 pretty-formatting disabled. */
137 get_no_prettyformat_print_options (struct value_print_options *opts)
139 *opts = user_print_options;
140 opts->prettyformat = Val_no_prettyformat;
143 /* Initialize *OPTS to be a copy of the user print options, but using
144 FORMAT as the formatting option. */
146 get_formatted_print_options (struct value_print_options *opts,
149 *opts = user_print_options;
150 opts->format = format;
154 show_print_max (struct ui_file *file, int from_tty,
155 struct cmd_list_element *c, const char *value)
157 fprintf_filtered (file,
158 _("Limit on string chars or array "
159 "elements to print is %s.\n"),
164 /* Default input and output radixes, and output format letter. */
166 unsigned input_radix = 10;
168 show_input_radix (struct ui_file *file, int from_tty,
169 struct cmd_list_element *c, const char *value)
171 fprintf_filtered (file,
172 _("Default input radix for entering numbers is %s.\n"),
176 unsigned output_radix = 10;
178 show_output_radix (struct ui_file *file, int from_tty,
179 struct cmd_list_element *c, const char *value)
181 fprintf_filtered (file,
182 _("Default output radix for printing of values is %s.\n"),
186 /* By default we print arrays without printing the index of each element in
187 the array. This behavior can be changed by setting PRINT_ARRAY_INDEXES. */
190 show_print_array_indexes (struct ui_file *file, int from_tty,
191 struct cmd_list_element *c, const char *value)
193 fprintf_filtered (file, _("Printing of array indexes is %s.\n"), value);
196 /* Print repeat counts if there are more than this many repetitions of an
197 element in an array. Referenced by the low level language dependent
201 show_repeat_count_threshold (struct ui_file *file, int from_tty,
202 struct cmd_list_element *c, const char *value)
204 fprintf_filtered (file, _("Threshold for repeated print elements is %s.\n"),
208 /* If nonzero, stops printing of char arrays at first null. */
211 show_stop_print_at_null (struct ui_file *file, int from_tty,
212 struct cmd_list_element *c, const char *value)
214 fprintf_filtered (file,
215 _("Printing of char arrays to stop "
216 "at first null char is %s.\n"),
220 /* Controls pretty printing of structures. */
223 show_prettyformat_structs (struct ui_file *file, int from_tty,
224 struct cmd_list_element *c, const char *value)
226 fprintf_filtered (file, _("Pretty formatting of structures is %s.\n"), value);
229 /* Controls pretty printing of arrays. */
232 show_prettyformat_arrays (struct ui_file *file, int from_tty,
233 struct cmd_list_element *c, const char *value)
235 fprintf_filtered (file, _("Pretty formatting of arrays is %s.\n"), value);
238 /* If nonzero, causes unions inside structures or other unions to be
242 show_unionprint (struct ui_file *file, int from_tty,
243 struct cmd_list_element *c, const char *value)
245 fprintf_filtered (file,
246 _("Printing of unions interior to structures is %s.\n"),
250 /* If nonzero, causes machine addresses to be printed in certain contexts. */
253 show_addressprint (struct ui_file *file, int from_tty,
254 struct cmd_list_element *c, const char *value)
256 fprintf_filtered (file, _("Printing of addresses is %s.\n"), value);
260 show_symbol_print (struct ui_file *file, int from_tty,
261 struct cmd_list_element *c, const char *value)
263 fprintf_filtered (file,
264 _("Printing of symbols when printing pointers is %s.\n"),
270 /* A helper function for val_print. When printing in "summary" mode,
271 we want to print scalar arguments, but not aggregate arguments.
272 This function distinguishes between the two. */
275 val_print_scalar_type_p (struct type *type)
277 type = check_typedef (type);
278 while (TYPE_CODE (type) == TYPE_CODE_REF)
280 type = TYPE_TARGET_TYPE (type);
281 type = check_typedef (type);
283 switch (TYPE_CODE (type))
285 case TYPE_CODE_ARRAY:
286 case TYPE_CODE_STRUCT:
287 case TYPE_CODE_UNION:
289 case TYPE_CODE_STRING:
296 /* See its definition in value.h. */
299 valprint_check_validity (struct ui_file *stream,
302 const struct value *val)
304 type = check_typedef (type);
306 if (TYPE_CODE (type) != TYPE_CODE_UNION
307 && TYPE_CODE (type) != TYPE_CODE_STRUCT
308 && TYPE_CODE (type) != TYPE_CODE_ARRAY)
310 if (value_bits_any_optimized_out (val,
311 TARGET_CHAR_BIT * embedded_offset,
312 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
314 val_print_optimized_out (val, stream);
318 if (value_bits_synthetic_pointer (val, TARGET_CHAR_BIT * embedded_offset,
319 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
321 fputs_filtered (_("<synthetic pointer>"), stream);
325 if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
327 val_print_unavailable (stream);
336 val_print_optimized_out (const struct value *val, struct ui_file *stream)
338 if (val != NULL && value_lval_const (val) == lval_register)
339 val_print_not_saved (stream);
341 fprintf_filtered (stream, _("<optimized out>"));
345 val_print_not_saved (struct ui_file *stream)
347 fprintf_filtered (stream, _("<not saved>"));
351 val_print_unavailable (struct ui_file *stream)
353 fprintf_filtered (stream, _("<unavailable>"));
357 val_print_invalid_address (struct ui_file *stream)
359 fprintf_filtered (stream, _("<invalid address>"));
362 /* Print a pointer based on the type of its target.
364 Arguments to this functions are roughly the same as those in
365 generic_val_print. A difference is that ADDRESS is the address to print,
366 with embedded_offset already added. ELTTYPE represents
367 the pointed type after check_typedef. */
370 print_unpacked_pointer (struct type *type, struct type *elttype,
371 CORE_ADDR address, struct ui_file *stream,
372 const struct value_print_options *options)
374 struct gdbarch *gdbarch = get_type_arch (type);
376 if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
378 /* Try to print what function it points to. */
379 print_function_pointer_address (options, gdbarch, address, stream);
383 if (options->symbol_print)
384 print_address_demangle (options, gdbarch, address, stream, demangle);
385 else if (options->addressprint)
386 fputs_filtered (paddress (gdbarch, address), stream);
389 /* generic_val_print helper for TYPE_CODE_ARRAY. */
392 generic_val_print_array (struct type *type, const gdb_byte *valaddr,
393 int embedded_offset, CORE_ADDR address,
394 struct ui_file *stream, int recurse,
395 const struct value *original_value,
396 const struct value_print_options *options)
398 struct type *unresolved_elttype = TYPE_TARGET_TYPE (type);
399 struct type *elttype = check_typedef (unresolved_elttype);
401 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (unresolved_elttype) > 0)
403 LONGEST low_bound, high_bound;
405 if (!get_array_bounds (type, &low_bound, &high_bound))
406 error (_("Could not determine the array high bound"));
408 if (options->prettyformat_arrays)
410 print_spaces_filtered (2 + 2 * recurse, stream);
413 fprintf_filtered (stream, "{");
414 val_print_array_elements (type, valaddr, embedded_offset,
416 recurse, original_value, options, 0);
417 fprintf_filtered (stream, "}");
421 /* Array of unspecified length: treat like pointer to first elt. */
422 print_unpacked_pointer (type, elttype, address + embedded_offset, stream,
428 /* A generic val_print that is suitable for use by language
429 implementations of the la_val_print method. This function can
430 handle most type codes, though not all, notably exception
431 TYPE_CODE_UNION and TYPE_CODE_STRUCT, which must be implemented by
434 Most arguments are as to val_print.
436 The additional DECORATIONS argument can be used to customize the
437 output in some small, language-specific ways. */
440 generic_val_print (struct type *type, const gdb_byte *valaddr,
441 int embedded_offset, CORE_ADDR address,
442 struct ui_file *stream, int recurse,
443 const struct value *original_value,
444 const struct value_print_options *options,
445 const struct generic_val_print_decorations *decorations)
447 struct gdbarch *gdbarch = get_type_arch (type);
448 unsigned int i = 0; /* Number of characters printed. */
450 struct type *elttype, *unresolved_elttype;
451 struct type *unresolved_type = type;
455 type = check_typedef (type);
456 switch (TYPE_CODE (type))
458 case TYPE_CODE_ARRAY:
459 generic_val_print_array (type, valaddr, embedded_offset, address, stream,
460 recurse, original_value, options);
463 case TYPE_CODE_MEMBERPTR:
464 val_print_scalar_formatted (type, valaddr, embedded_offset,
465 original_value, options, 0, stream);
469 if (options->format && options->format != 's')
471 val_print_scalar_formatted (type, valaddr, embedded_offset,
472 original_value, options, 0, stream);
475 unresolved_elttype = TYPE_TARGET_TYPE (type);
476 elttype = check_typedef (unresolved_elttype);
477 addr = unpack_pointer (type, valaddr + embedded_offset);
478 print_unpacked_pointer (type, elttype, addr, stream, options);
482 elttype = check_typedef (TYPE_TARGET_TYPE (type));
483 if (options->addressprint)
486 = extract_typed_address (valaddr + embedded_offset, type);
488 fprintf_filtered (stream, "@");
489 fputs_filtered (paddress (gdbarch, addr), stream);
490 if (options->deref_ref)
491 fputs_filtered (": ", stream);
493 /* De-reference the reference. */
494 if (options->deref_ref)
496 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
498 struct value *deref_val;
500 deref_val = coerce_ref_if_computed (original_value);
501 if (deref_val != NULL)
503 /* More complicated computed references are not supported. */
504 gdb_assert (embedded_offset == 0);
507 deref_val = value_at (TYPE_TARGET_TYPE (type),
508 unpack_pointer (type,
510 + embedded_offset)));
512 common_val_print (deref_val, stream, recurse, options,
516 fputs_filtered ("???", stream);
523 val_print_scalar_formatted (type, valaddr, embedded_offset,
524 original_value, options, 0, stream);
527 len = TYPE_NFIELDS (type);
528 val = unpack_long (type, valaddr + embedded_offset);
529 for (i = 0; i < len; i++)
532 if (val == TYPE_FIELD_ENUMVAL (type, i))
539 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
541 else if (TYPE_FLAG_ENUM (type))
545 /* We have a "flag" enum, so we try to decompose it into
546 pieces as appropriate. A flag enum has disjoint
547 constants by definition. */
548 fputs_filtered ("(", stream);
549 for (i = 0; i < len; ++i)
553 if ((val & TYPE_FIELD_ENUMVAL (type, i)) != 0)
556 fputs_filtered (" | ", stream);
559 val &= ~TYPE_FIELD_ENUMVAL (type, i);
560 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
564 if (first || val != 0)
567 fputs_filtered (" | ", stream);
568 fputs_filtered ("unknown: ", stream);
569 print_longest (stream, 'd', 0, val);
572 fputs_filtered (")", stream);
575 print_longest (stream, 'd', 0, val);
578 case TYPE_CODE_FLAGS:
580 val_print_scalar_formatted (type, valaddr, embedded_offset,
581 original_value, options, 0, stream);
583 val_print_type_code_flags (type, valaddr + embedded_offset,
588 case TYPE_CODE_METHOD:
591 val_print_scalar_formatted (type, valaddr, embedded_offset,
592 original_value, options, 0, stream);
595 /* FIXME, we should consider, at least for ANSI C language,
596 eliminating the distinction made between FUNCs and POINTERs
598 fprintf_filtered (stream, "{");
599 type_print (type, "", stream, -1);
600 fprintf_filtered (stream, "} ");
601 /* Try to print what function it points to, and its address. */
602 print_address_demangle (options, gdbarch, address, stream, demangle);
606 if (options->format || options->output_format)
608 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);
616 val = unpack_long (type, valaddr + embedded_offset);
618 fputs_filtered (decorations->false_name, stream);
620 fputs_filtered (decorations->true_name, stream);
622 print_longest (stream, 'd', 0, val);
626 case TYPE_CODE_RANGE:
627 /* FIXME: create_static_range_type does not set the unsigned bit in a
628 range type (I think it probably should copy it from the
629 target type), so we won't print values which are too large to
630 fit in a signed integer correctly. */
631 /* FIXME: Doesn't handle ranges of enums correctly. (Can't just
632 print with the target type, though, because the size of our
633 type and the target type might differ). */
638 if (options->format || options->output_format)
640 struct value_print_options opts = *options;
642 opts.format = (options->format ? options->format
643 : options->output_format);
644 val_print_scalar_formatted (type, valaddr, embedded_offset,
645 original_value, &opts, 0, stream);
648 val_print_type_code_int (type, valaddr + embedded_offset, stream);
652 if (options->format || options->output_format)
654 struct value_print_options opts = *options;
656 opts.format = (options->format ? options->format
657 : options->output_format);
658 val_print_scalar_formatted (type, valaddr, embedded_offset,
659 original_value, &opts, 0, stream);
663 val = unpack_long (type, valaddr + embedded_offset);
664 if (TYPE_UNSIGNED (type))
665 fprintf_filtered (stream, "%u", (unsigned int) val);
667 fprintf_filtered (stream, "%d", (int) val);
668 fputs_filtered (" ", stream);
669 LA_PRINT_CHAR (val, unresolved_type, stream);
676 val_print_scalar_formatted (type, valaddr, embedded_offset,
677 original_value, options, 0, stream);
681 print_floating (valaddr + embedded_offset, type, stream);
685 case TYPE_CODE_DECFLOAT:
687 val_print_scalar_formatted (type, valaddr, embedded_offset,
688 original_value, options, 0, stream);
690 print_decimal_floating (valaddr + embedded_offset,
695 fputs_filtered (decorations->void_name, stream);
698 case TYPE_CODE_ERROR:
699 fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
702 case TYPE_CODE_UNDEF:
703 /* This happens (without TYPE_FLAG_STUB set) on systems which
704 don't use dbx xrefs (NO_DBX_XREFS in gcc) if a file has a
705 "struct foo *bar" and no complete type for struct foo in that
707 fprintf_filtered (stream, _("<incomplete type>"));
710 case TYPE_CODE_COMPLEX:
711 fprintf_filtered (stream, "%s", decorations->complex_prefix);
713 val_print_scalar_formatted (TYPE_TARGET_TYPE (type),
714 valaddr, embedded_offset,
715 original_value, options, 0, stream);
717 print_floating (valaddr + embedded_offset,
718 TYPE_TARGET_TYPE (type),
720 fprintf_filtered (stream, "%s", decorations->complex_infix);
722 val_print_scalar_formatted (TYPE_TARGET_TYPE (type),
725 + TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
729 print_floating (valaddr + embedded_offset
730 + TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
731 TYPE_TARGET_TYPE (type),
733 fprintf_filtered (stream, "%s", decorations->complex_suffix);
736 case TYPE_CODE_UNION:
737 case TYPE_CODE_STRUCT:
738 case TYPE_CODE_METHODPTR:
740 error (_("Unhandled type code %d in symbol table."),
746 /* Print using the given LANGUAGE the data of type TYPE located at
747 VALADDR + EMBEDDED_OFFSET (within GDB), which came from the
748 inferior at address ADDRESS + EMBEDDED_OFFSET, onto stdio stream
749 STREAM according to OPTIONS. VAL is the whole object that came
750 from ADDRESS. VALADDR must point to the head of VAL's contents
753 The language printers will pass down an adjusted EMBEDDED_OFFSET to
754 further helper subroutines as subfields of TYPE are printed. In
755 such cases, VALADDR is passed down unadjusted, as well as VAL, so
756 that VAL can be queried for metadata about the contents data being
757 printed, using EMBEDDED_OFFSET as an offset into VAL's contents
758 buffer. For example: "has this field been optimized out", or "I'm
759 printing an object while inspecting a traceframe; has this
760 particular piece of data been collected?".
762 RECURSE indicates the amount of indentation to supply before
763 continuation lines; this amount is roughly twice the value of
767 val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
768 CORE_ADDR address, struct ui_file *stream, int recurse,
769 const struct value *val,
770 const struct value_print_options *options,
771 const struct language_defn *language)
774 struct value_print_options local_opts = *options;
775 struct type *real_type = check_typedef (type);
777 if (local_opts.prettyformat == Val_prettyformat_default)
778 local_opts.prettyformat = (local_opts.prettyformat_structs
779 ? Val_prettyformat : Val_no_prettyformat);
783 /* Ensure that the type is complete and not just a stub. If the type is
784 only a stub and we can't find and substitute its complete type, then
785 print appropriate string and return. */
787 if (TYPE_STUB (real_type))
789 fprintf_filtered (stream, _("<incomplete type>"));
794 if (!valprint_check_validity (stream, real_type, embedded_offset, val))
799 ret = apply_ext_lang_val_pretty_printer (type, valaddr, embedded_offset,
800 address, stream, recurse,
801 val, options, language);
806 /* Handle summary mode. If the value is a scalar, print it;
807 otherwise, print an ellipsis. */
808 if (options->summary && !val_print_scalar_type_p (type))
810 fprintf_filtered (stream, "...");
816 language->la_val_print (type, valaddr, embedded_offset, address,
817 stream, recurse, val,
820 CATCH (except, RETURN_MASK_ERROR)
822 fprintf_filtered (stream, _("<error reading variable>"));
827 /* Check whether the value VAL is printable. Return 1 if it is;
828 return 0 and print an appropriate error message to STREAM according to
829 OPTIONS if it is not. */
832 value_check_printable (struct value *val, struct ui_file *stream,
833 const struct value_print_options *options)
837 fprintf_filtered (stream, _("<address of value unknown>"));
841 if (value_entirely_optimized_out (val))
843 if (options->summary && !val_print_scalar_type_p (value_type (val)))
844 fprintf_filtered (stream, "...");
846 val_print_optimized_out (val, stream);
850 if (value_entirely_unavailable (val))
852 if (options->summary && !val_print_scalar_type_p (value_type (val)))
853 fprintf_filtered (stream, "...");
855 val_print_unavailable (stream);
859 if (TYPE_CODE (value_type (val)) == TYPE_CODE_INTERNAL_FUNCTION)
861 fprintf_filtered (stream, _("<internal function %s>"),
862 value_internal_function_name (val));
869 /* Print using the given LANGUAGE the value VAL onto stream STREAM according
872 This is a preferable interface to val_print, above, because it uses
873 GDB's value mechanism. */
876 common_val_print (struct value *val, struct ui_file *stream, int recurse,
877 const struct value_print_options *options,
878 const struct language_defn *language)
880 if (!value_check_printable (val, stream, options))
883 if (language->la_language == language_ada)
884 /* The value might have a dynamic type, which would cause trouble
885 below when trying to extract the value contents (since the value
886 size is determined from the type size which is unknown). So
887 get a fixed representation of our value. */
888 val = ada_to_fixed_value (val);
890 val_print (value_type (val), value_contents_for_printing (val),
891 value_embedded_offset (val), value_address (val),
893 val, options, language);
896 /* Print on stream STREAM the value VAL according to OPTIONS. The value
897 is printed using the current_language syntax. */
900 value_print (struct value *val, struct ui_file *stream,
901 const struct value_print_options *options)
903 if (!value_check_printable (val, stream, options))
909 = apply_ext_lang_val_pretty_printer (value_type (val),
910 value_contents_for_printing (val),
911 value_embedded_offset (val),
914 val, options, current_language);
920 LA_VALUE_PRINT (val, stream, options);
923 /* Called by various <lang>_val_print routines to print
924 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
925 value. STREAM is where to print the value. */
928 val_print_type_code_int (struct type *type, const gdb_byte *valaddr,
929 struct ui_file *stream)
931 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
933 if (TYPE_LENGTH (type) > sizeof (LONGEST))
937 if (TYPE_UNSIGNED (type)
938 && extract_long_unsigned_integer (valaddr, TYPE_LENGTH (type),
941 print_longest (stream, 'u', 0, val);
945 /* Signed, or we couldn't turn an unsigned value into a
946 LONGEST. For signed values, one could assume two's
947 complement (a reasonable assumption, I think) and do
949 print_hex_chars (stream, (unsigned char *) valaddr,
950 TYPE_LENGTH (type), byte_order);
955 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0,
956 unpack_long (type, valaddr));
961 val_print_type_code_flags (struct type *type, const gdb_byte *valaddr,
962 struct ui_file *stream)
964 ULONGEST val = unpack_long (type, valaddr);
965 int bitpos, nfields = TYPE_NFIELDS (type);
967 fputs_filtered ("[ ", stream);
968 for (bitpos = 0; bitpos < nfields; bitpos++)
970 if (TYPE_FIELD_BITPOS (type, bitpos) != -1
971 && (val & ((ULONGEST)1 << bitpos)))
973 if (TYPE_FIELD_NAME (type, bitpos))
974 fprintf_filtered (stream, "%s ", TYPE_FIELD_NAME (type, bitpos));
976 fprintf_filtered (stream, "#%d ", bitpos);
979 fputs_filtered ("]", stream);
982 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
983 according to OPTIONS and SIZE on STREAM. Format i is not supported
986 This is how the elements of an array or structure are printed
990 val_print_scalar_formatted (struct type *type,
991 const gdb_byte *valaddr, int embedded_offset,
992 const struct value *val,
993 const struct value_print_options *options,
995 struct ui_file *stream)
997 gdb_assert (val != NULL);
998 gdb_assert (valaddr == value_contents_for_printing_const (val));
1000 /* If we get here with a string format, try again without it. Go
1001 all the way back to the language printers, which may call us
1003 if (options->format == 's')
1005 struct value_print_options opts = *options;
1008 val_print (type, valaddr, embedded_offset, 0, stream, 0, val, &opts,
1013 /* A scalar object that does not have all bits available can't be
1014 printed, because all bits contribute to its representation. */
1015 if (value_bits_any_optimized_out (val,
1016 TARGET_CHAR_BIT * embedded_offset,
1017 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
1018 val_print_optimized_out (val, stream);
1019 else if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
1020 val_print_unavailable (stream);
1022 print_scalar_formatted (valaddr + embedded_offset, type,
1023 options, size, stream);
1026 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
1027 The raison d'etre of this function is to consolidate printing of
1028 LONG_LONG's into this one function. The format chars b,h,w,g are
1029 from print_scalar_formatted(). Numbers are printed using C
1032 USE_C_FORMAT means to use C format in all cases. Without it,
1033 'o' and 'x' format do not include the standard C radix prefix
1036 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
1037 and was intended to request formating according to the current
1038 language and would be used for most integers that GDB prints. The
1039 exceptional cases were things like protocols where the format of
1040 the integer is a protocol thing, not a user-visible thing). The
1041 parameter remains to preserve the information of what things might
1042 be printed with language-specific format, should we ever resurrect
1046 print_longest (struct ui_file *stream, int format, int use_c_format,
1054 val = int_string (val_long, 10, 1, 0, 1); break;
1056 val = int_string (val_long, 10, 0, 0, 1); break;
1058 val = int_string (val_long, 16, 0, 0, use_c_format); break;
1060 val = int_string (val_long, 16, 0, 2, 1); break;
1062 val = int_string (val_long, 16, 0, 4, 1); break;
1064 val = int_string (val_long, 16, 0, 8, 1); break;
1066 val = int_string (val_long, 16, 0, 16, 1); break;
1069 val = int_string (val_long, 8, 0, 0, use_c_format); break;
1071 internal_error (__FILE__, __LINE__,
1072 _("failed internal consistency check"));
1074 fputs_filtered (val, stream);
1077 /* This used to be a macro, but I don't think it is called often enough
1078 to merit such treatment. */
1079 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
1080 arguments to a function, number in a value history, register number, etc.)
1081 where the value must not be larger than can fit in an int. */
1084 longest_to_int (LONGEST arg)
1086 /* Let the compiler do the work. */
1087 int rtnval = (int) arg;
1089 /* Check for overflows or underflows. */
1090 if (sizeof (LONGEST) > sizeof (int))
1094 error (_("Value out of range."));
1100 /* Print a floating point value of type TYPE (not always a
1101 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
1104 print_floating (const gdb_byte *valaddr, struct type *type,
1105 struct ui_file *stream)
1109 const struct floatformat *fmt = NULL;
1110 unsigned len = TYPE_LENGTH (type);
1111 enum float_kind kind;
1113 /* If it is a floating-point, check for obvious problems. */
1114 if (TYPE_CODE (type) == TYPE_CODE_FLT)
1115 fmt = floatformat_from_type (type);
1118 kind = floatformat_classify (fmt, valaddr);
1119 if (kind == float_nan)
1121 if (floatformat_is_negative (fmt, valaddr))
1122 fprintf_filtered (stream, "-");
1123 fprintf_filtered (stream, "nan(");
1124 fputs_filtered ("0x", stream);
1125 fputs_filtered (floatformat_mantissa (fmt, valaddr), stream);
1126 fprintf_filtered (stream, ")");
1129 else if (kind == float_infinite)
1131 if (floatformat_is_negative (fmt, valaddr))
1132 fputs_filtered ("-", stream);
1133 fputs_filtered ("inf", stream);
1138 /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
1139 isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double
1140 needs to be used as that takes care of any necessary type
1141 conversions. Such conversions are of course direct to DOUBLEST
1142 and disregard any possible target floating point limitations.
1143 For instance, a u64 would be converted and displayed exactly on a
1144 host with 80 bit DOUBLEST but with loss of information on a host
1145 with 64 bit DOUBLEST. */
1147 doub = unpack_double (type, valaddr, &inv);
1150 fprintf_filtered (stream, "<invalid float value>");
1154 /* FIXME: kettenis/2001-01-20: The following code makes too much
1155 assumptions about the host and target floating point format. */
1157 /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
1158 not necessarily be a TYPE_CODE_FLT, the below ignores that and
1159 instead uses the type's length to determine the precision of the
1160 floating-point value being printed. */
1162 if (len < sizeof (double))
1163 fprintf_filtered (stream, "%.9g", (double) doub);
1164 else if (len == sizeof (double))
1165 fprintf_filtered (stream, "%.17g", (double) doub);
1167 #ifdef PRINTF_HAS_LONG_DOUBLE
1168 fprintf_filtered (stream, "%.35Lg", doub);
1170 /* This at least wins with values that are representable as
1172 fprintf_filtered (stream, "%.17g", (double) doub);
1177 print_decimal_floating (const gdb_byte *valaddr, struct type *type,
1178 struct ui_file *stream)
1180 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
1181 char decstr[MAX_DECIMAL_STRING];
1182 unsigned len = TYPE_LENGTH (type);
1184 decimal_to_string (valaddr, len, byte_order, decstr);
1185 fputs_filtered (decstr, stream);
1190 print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr,
1191 unsigned len, enum bfd_endian byte_order)
1194 #define BITS_IN_BYTES 8
1200 /* Declared "int" so it will be signed.
1201 This ensures that right shift will shift in zeros. */
1203 const int mask = 0x080;
1205 /* FIXME: We should be not printing leading zeroes in most cases. */
1207 if (byte_order == BFD_ENDIAN_BIG)
1213 /* Every byte has 8 binary characters; peel off
1214 and print from the MSB end. */
1216 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
1218 if (*p & (mask >> i))
1223 fprintf_filtered (stream, "%1d", b);
1229 for (p = valaddr + len - 1;
1233 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
1235 if (*p & (mask >> i))
1240 fprintf_filtered (stream, "%1d", b);
1246 /* VALADDR points to an integer of LEN bytes.
1247 Print it in octal on stream or format it in buf. */
1250 print_octal_chars (struct ui_file *stream, const gdb_byte *valaddr,
1251 unsigned len, enum bfd_endian byte_order)
1254 unsigned char octa1, octa2, octa3, carry;
1257 /* FIXME: We should be not printing leading zeroes in most cases. */
1260 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
1261 * the extra bits, which cycle every three bytes:
1263 * Byte side: 0 1 2 3
1265 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
1267 * Octal side: 0 1 carry 3 4 carry ...
1269 * Cycle number: 0 1 2
1271 * But of course we are printing from the high side, so we have to
1272 * figure out where in the cycle we are so that we end up with no
1273 * left over bits at the end.
1275 #define BITS_IN_OCTAL 3
1276 #define HIGH_ZERO 0340
1277 #define LOW_ZERO 0016
1278 #define CARRY_ZERO 0003
1279 #define HIGH_ONE 0200
1280 #define MID_ONE 0160
1281 #define LOW_ONE 0016
1282 #define CARRY_ONE 0001
1283 #define HIGH_TWO 0300
1284 #define MID_TWO 0070
1285 #define LOW_TWO 0007
1287 /* For 32 we start in cycle 2, with two bits and one bit carry;
1288 for 64 in cycle in cycle 1, with one bit and a two bit carry. */
1290 cycle = (len * BITS_IN_BYTES) % BITS_IN_OCTAL;
1293 fputs_filtered ("0", stream);
1294 if (byte_order == BFD_ENDIAN_BIG)
1303 /* No carry in, carry out two bits. */
1305 octa1 = (HIGH_ZERO & *p) >> 5;
1306 octa2 = (LOW_ZERO & *p) >> 2;
1307 carry = (CARRY_ZERO & *p);
1308 fprintf_filtered (stream, "%o", octa1);
1309 fprintf_filtered (stream, "%o", octa2);
1313 /* Carry in two bits, carry out one bit. */
1315 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
1316 octa2 = (MID_ONE & *p) >> 4;
1317 octa3 = (LOW_ONE & *p) >> 1;
1318 carry = (CARRY_ONE & *p);
1319 fprintf_filtered (stream, "%o", octa1);
1320 fprintf_filtered (stream, "%o", octa2);
1321 fprintf_filtered (stream, "%o", octa3);
1325 /* Carry in one bit, no carry out. */
1327 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
1328 octa2 = (MID_TWO & *p) >> 3;
1329 octa3 = (LOW_TWO & *p);
1331 fprintf_filtered (stream, "%o", octa1);
1332 fprintf_filtered (stream, "%o", octa2);
1333 fprintf_filtered (stream, "%o", octa3);
1337 error (_("Internal error in octal conversion;"));
1341 cycle = cycle % BITS_IN_OCTAL;
1346 for (p = valaddr + len - 1;
1353 /* Carry out, no carry in */
1355 octa1 = (HIGH_ZERO & *p) >> 5;
1356 octa2 = (LOW_ZERO & *p) >> 2;
1357 carry = (CARRY_ZERO & *p);
1358 fprintf_filtered (stream, "%o", octa1);
1359 fprintf_filtered (stream, "%o", octa2);
1363 /* Carry in, carry out */
1365 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
1366 octa2 = (MID_ONE & *p) >> 4;
1367 octa3 = (LOW_ONE & *p) >> 1;
1368 carry = (CARRY_ONE & *p);
1369 fprintf_filtered (stream, "%o", octa1);
1370 fprintf_filtered (stream, "%o", octa2);
1371 fprintf_filtered (stream, "%o", octa3);
1375 /* Carry in, no carry out */
1377 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
1378 octa2 = (MID_TWO & *p) >> 3;
1379 octa3 = (LOW_TWO & *p);
1381 fprintf_filtered (stream, "%o", octa1);
1382 fprintf_filtered (stream, "%o", octa2);
1383 fprintf_filtered (stream, "%o", octa3);
1387 error (_("Internal error in octal conversion;"));
1391 cycle = cycle % BITS_IN_OCTAL;
1397 /* VALADDR points to an integer of LEN bytes.
1398 Print it in decimal on stream or format it in buf. */
1401 print_decimal_chars (struct ui_file *stream, const gdb_byte *valaddr,
1402 unsigned len, enum bfd_endian byte_order)
1405 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
1406 #define CARRY_LEFT( x ) ((x) % TEN)
1407 #define SHIFT( x ) ((x) << 4)
1408 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
1409 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
1412 unsigned char *digits;
1415 int i, j, decimal_digits;
1419 /* Base-ten number is less than twice as many digits
1420 as the base 16 number, which is 2 digits per byte. */
1422 decimal_len = len * 2 * 2;
1423 digits = xmalloc (decimal_len);
1425 for (i = 0; i < decimal_len; i++)
1430 /* Ok, we have an unknown number of bytes of data to be printed in
1433 * Given a hex number (in nibbles) as XYZ, we start by taking X and
1434 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
1435 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
1437 * The trick is that "digits" holds a base-10 number, but sometimes
1438 * the individual digits are > 10.
1440 * Outer loop is per nibble (hex digit) of input, from MSD end to
1443 decimal_digits = 0; /* Number of decimal digits so far */
1444 p = (byte_order == BFD_ENDIAN_BIG) ? valaddr : valaddr + len - 1;
1446 while ((byte_order == BFD_ENDIAN_BIG) ? (p < valaddr + len) : (p >= valaddr))
1449 * Multiply current base-ten number by 16 in place.
1450 * Each digit was between 0 and 9, now is between
1453 for (j = 0; j < decimal_digits; j++)
1455 digits[j] = SHIFT (digits[j]);
1458 /* Take the next nibble off the input and add it to what
1459 * we've got in the LSB position. Bottom 'digit' is now
1460 * between 0 and 159.
1462 * "flip" is used to run this loop twice for each byte.
1466 /* Take top nibble. */
1468 digits[0] += HIGH_NIBBLE (*p);
1473 /* Take low nibble and bump our pointer "p". */
1475 digits[0] += LOW_NIBBLE (*p);
1476 if (byte_order == BFD_ENDIAN_BIG)
1483 /* Re-decimalize. We have to do this often enough
1484 * that we don't overflow, but once per nibble is
1485 * overkill. Easier this way, though. Note that the
1486 * carry is often larger than 10 (e.g. max initial
1487 * carry out of lowest nibble is 15, could bubble all
1488 * the way up greater than 10). So we have to do
1489 * the carrying beyond the last current digit.
1492 for (j = 0; j < decimal_len - 1; j++)
1496 /* "/" won't handle an unsigned char with
1497 * a value that if signed would be negative.
1498 * So extend to longword int via "dummy".
1501 carry = CARRY_OUT (dummy);
1502 digits[j] = CARRY_LEFT (dummy);
1504 if (j >= decimal_digits && carry == 0)
1507 * All higher digits are 0 and we
1508 * no longer have a carry.
1510 * Note: "j" is 0-based, "decimal_digits" is
1513 decimal_digits = j + 1;
1519 /* Ok, now "digits" is the decimal representation, with
1520 the "decimal_digits" actual digits. Print! */
1522 for (i = decimal_digits - 1; i >= 0; i--)
1524 fprintf_filtered (stream, "%1d", digits[i]);
1529 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
1532 print_hex_chars (struct ui_file *stream, const gdb_byte *valaddr,
1533 unsigned len, enum bfd_endian byte_order)
1537 /* FIXME: We should be not printing leading zeroes in most cases. */
1539 fputs_filtered ("0x", stream);
1540 if (byte_order == BFD_ENDIAN_BIG)
1546 fprintf_filtered (stream, "%02x", *p);
1551 for (p = valaddr + len - 1;
1555 fprintf_filtered (stream, "%02x", *p);
1560 /* VALADDR points to a char integer of LEN bytes.
1561 Print it out in appropriate language form on stream.
1562 Omit any leading zero chars. */
1565 print_char_chars (struct ui_file *stream, struct type *type,
1566 const gdb_byte *valaddr,
1567 unsigned len, enum bfd_endian byte_order)
1571 if (byte_order == BFD_ENDIAN_BIG)
1574 while (p < valaddr + len - 1 && *p == 0)
1577 while (p < valaddr + len)
1579 LA_EMIT_CHAR (*p, type, stream, '\'');
1585 p = valaddr + len - 1;
1586 while (p > valaddr && *p == 0)
1589 while (p >= valaddr)
1591 LA_EMIT_CHAR (*p, type, stream, '\'');
1597 /* Print function pointer with inferior address ADDRESS onto stdio
1601 print_function_pointer_address (const struct value_print_options *options,
1602 struct gdbarch *gdbarch,
1604 struct ui_file *stream)
1607 = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
1610 /* If the function pointer is represented by a description, print
1611 the address of the description. */
1612 if (options->addressprint && func_addr != address)
1614 fputs_filtered ("@", stream);
1615 fputs_filtered (paddress (gdbarch, address), stream);
1616 fputs_filtered (": ", stream);
1618 print_address_demangle (options, gdbarch, func_addr, stream, demangle);
1622 /* Print on STREAM using the given OPTIONS the index for the element
1623 at INDEX of an array whose index type is INDEX_TYPE. */
1626 maybe_print_array_index (struct type *index_type, LONGEST index,
1627 struct ui_file *stream,
1628 const struct value_print_options *options)
1630 struct value *index_value;
1632 if (!options->print_array_indexes)
1635 index_value = value_from_longest (index_type, index);
1637 LA_PRINT_ARRAY_INDEX (index_value, stream, options);
1640 /* Called by various <lang>_val_print routines to print elements of an
1641 array in the form "<elem1>, <elem2>, <elem3>, ...".
1643 (FIXME?) Assumes array element separator is a comma, which is correct
1644 for all languages currently handled.
1645 (FIXME?) Some languages have a notation for repeated array elements,
1646 perhaps we should try to use that notation when appropriate. */
1649 val_print_array_elements (struct type *type,
1650 const gdb_byte *valaddr, int embedded_offset,
1651 CORE_ADDR address, struct ui_file *stream,
1653 const struct value *val,
1654 const struct value_print_options *options,
1657 unsigned int things_printed = 0;
1659 struct type *elttype, *index_type, *base_index_type;
1661 /* Position of the array element we are examining to see
1662 whether it is repeated. */
1664 /* Number of repetitions we have detected so far. */
1666 LONGEST low_bound, high_bound;
1667 LONGEST low_pos, high_pos;
1669 elttype = TYPE_TARGET_TYPE (type);
1670 eltlen = TYPE_LENGTH (check_typedef (elttype));
1671 index_type = TYPE_INDEX_TYPE (type);
1673 if (get_array_bounds (type, &low_bound, &high_bound))
1675 if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
1676 base_index_type = TYPE_TARGET_TYPE (index_type);
1678 base_index_type = index_type;
1680 /* Non-contiguous enumerations types can by used as index types
1681 in some languages (e.g. Ada). In this case, the array length
1682 shall be computed from the positions of the first and last
1683 literal in the enumeration type, and not from the values
1684 of these literals. */
1685 if (!discrete_position (base_index_type, low_bound, &low_pos)
1686 || !discrete_position (base_index_type, high_bound, &high_pos))
1688 warning (_("unable to get positions in array, use bounds instead"));
1689 low_pos = low_bound;
1690 high_pos = high_bound;
1693 /* The array length should normally be HIGH_POS - LOW_POS + 1.
1694 But we have to be a little extra careful, because some languages
1695 such as Ada allow LOW_POS to be greater than HIGH_POS for
1696 empty arrays. In that situation, the array length is just zero,
1698 if (low_pos > high_pos)
1701 len = high_pos - low_pos + 1;
1705 warning (_("unable to get bounds of array, assuming null array"));
1710 annotate_array_section_begin (i, elttype);
1712 for (; i < len && things_printed < options->print_max; i++)
1716 if (options->prettyformat_arrays)
1718 fprintf_filtered (stream, ",\n");
1719 print_spaces_filtered (2 + 2 * recurse, stream);
1723 fprintf_filtered (stream, ", ");
1726 wrap_here (n_spaces (2 + 2 * recurse));
1727 maybe_print_array_index (index_type, i + low_bound,
1732 /* Only check for reps if repeat_count_threshold is not set to
1733 UINT_MAX (unlimited). */
1734 if (options->repeat_count_threshold < UINT_MAX)
1737 && value_contents_eq (val,
1738 embedded_offset + i * eltlen,
1749 if (reps > options->repeat_count_threshold)
1751 val_print (elttype, valaddr, embedded_offset + i * eltlen,
1752 address, stream, recurse + 1, val, options,
1754 annotate_elt_rep (reps);
1755 fprintf_filtered (stream, " <repeats %u times>", reps);
1756 annotate_elt_rep_end ();
1759 things_printed += options->repeat_count_threshold;
1763 val_print (elttype, valaddr, embedded_offset + i * eltlen,
1765 stream, recurse + 1, val, options, current_language);
1770 annotate_array_section_end ();
1773 fprintf_filtered (stream, "...");
1777 /* Read LEN bytes of target memory at address MEMADDR, placing the
1778 results in GDB's memory at MYADDR. Returns a count of the bytes
1779 actually read, and optionally a target_xfer_status value in the
1780 location pointed to by ERRPTR if ERRPTR is non-null. */
1782 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
1783 function be eliminated. */
1786 partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
1787 int len, int *errptr)
1789 int nread; /* Number of bytes actually read. */
1790 int errcode; /* Error from last read. */
1792 /* First try a complete read. */
1793 errcode = target_read_memory (memaddr, myaddr, len);
1801 /* Loop, reading one byte at a time until we get as much as we can. */
1802 for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
1804 errcode = target_read_memory (memaddr++, myaddr++, 1);
1806 /* If an error, the last read was unsuccessful, so adjust count. */
1819 /* Read a string from the inferior, at ADDR, with LEN characters of WIDTH bytes
1820 each. Fetch at most FETCHLIMIT characters. BUFFER will be set to a newly
1821 allocated buffer containing the string, which the caller is responsible to
1822 free, and BYTES_READ will be set to the number of bytes read. Returns 0 on
1823 success, or a target_xfer_status on failure.
1825 If LEN > 0, reads the lesser of LEN or FETCHLIMIT characters
1826 (including eventual NULs in the middle or end of the string).
1828 If LEN is -1, stops at the first null character (not necessarily
1829 the first null byte) up to a maximum of FETCHLIMIT characters. Set
1830 FETCHLIMIT to UINT_MAX to read as many characters as possible from
1833 Unless an exception is thrown, BUFFER will always be allocated, even on
1834 failure. In this case, some characters might have been read before the
1835 failure happened. Check BYTES_READ to recognize this situation.
1837 Note: There was a FIXME asking to make this code use target_read_string,
1838 but this function is more general (can read past null characters, up to
1839 given LEN). Besides, it is used much more often than target_read_string
1840 so it is more tested. Perhaps callers of target_read_string should use
1841 this function instead? */
1844 read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
1845 enum bfd_endian byte_order, gdb_byte **buffer, int *bytes_read)
1847 int errcode; /* Errno returned from bad reads. */
1848 unsigned int nfetch; /* Chars to fetch / chars fetched. */
1849 gdb_byte *bufptr; /* Pointer to next available byte in
1851 struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
1853 /* Loop until we either have all the characters, or we encounter
1854 some error, such as bumping into the end of the address space. */
1858 old_chain = make_cleanup (free_current_contents, buffer);
1862 /* We want fetchlimit chars, so we might as well read them all in
1864 unsigned int fetchlen = min (len, fetchlimit);
1866 *buffer = (gdb_byte *) xmalloc (fetchlen * width);
1869 nfetch = partial_memory_read (addr, bufptr, fetchlen * width, &errcode)
1871 addr += nfetch * width;
1872 bufptr += nfetch * width;
1876 unsigned long bufsize = 0;
1877 unsigned int chunksize; /* Size of each fetch, in chars. */
1878 int found_nul; /* Non-zero if we found the nul char. */
1879 gdb_byte *limit; /* First location past end of fetch buffer. */
1882 /* We are looking for a NUL terminator to end the fetching, so we
1883 might as well read in blocks that are large enough to be efficient,
1884 but not so large as to be slow if fetchlimit happens to be large.
1885 So we choose the minimum of 8 and fetchlimit. We used to use 200
1886 instead of 8 but 200 is way too big for remote debugging over a
1888 chunksize = min (8, fetchlimit);
1893 nfetch = min (chunksize, fetchlimit - bufsize);
1895 if (*buffer == NULL)
1896 *buffer = (gdb_byte *) xmalloc (nfetch * width);
1898 *buffer = (gdb_byte *) xrealloc (*buffer,
1899 (nfetch + bufsize) * width);
1901 bufptr = *buffer + bufsize * width;
1904 /* Read as much as we can. */
1905 nfetch = partial_memory_read (addr, bufptr, nfetch * width, &errcode)
1908 /* Scan this chunk for the null character that terminates the string
1909 to print. If found, we don't need to fetch any more. Note
1910 that bufptr is explicitly left pointing at the next character
1911 after the null character, or at the next character after the end
1914 limit = bufptr + nfetch * width;
1915 while (bufptr < limit)
1919 c = extract_unsigned_integer (bufptr, width, byte_order);
1924 /* We don't care about any error which happened after
1925 the NUL terminator. */
1932 while (errcode == 0 /* no error */
1933 && bufptr - *buffer < fetchlimit * width /* no overrun */
1934 && !found_nul); /* haven't found NUL yet */
1937 { /* Length of string is really 0! */
1938 /* We always allocate *buffer. */
1939 *buffer = bufptr = xmalloc (1);
1943 /* bufptr and addr now point immediately beyond the last byte which we
1944 consider part of the string (including a '\0' which ends the string). */
1945 *bytes_read = bufptr - *buffer;
1949 discard_cleanups (old_chain);
1954 /* Return true if print_wchar can display W without resorting to a
1955 numeric escape, false otherwise. */
1958 wchar_printable (gdb_wchar_t w)
1960 return (gdb_iswprint (w)
1961 || w == LCST ('\a') || w == LCST ('\b')
1962 || w == LCST ('\f') || w == LCST ('\n')
1963 || w == LCST ('\r') || w == LCST ('\t')
1964 || w == LCST ('\v'));
1967 /* A helper function that converts the contents of STRING to wide
1968 characters and then appends them to OUTPUT. */
1971 append_string_as_wide (const char *string,
1972 struct obstack *output)
1974 for (; *string; ++string)
1976 gdb_wchar_t w = gdb_btowc (*string);
1977 obstack_grow (output, &w, sizeof (gdb_wchar_t));
1981 /* Print a wide character W to OUTPUT. ORIG is a pointer to the
1982 original (target) bytes representing the character, ORIG_LEN is the
1983 number of valid bytes. WIDTH is the number of bytes in a base
1984 characters of the type. OUTPUT is an obstack to which wide
1985 characters are emitted. QUOTER is a (narrow) character indicating
1986 the style of quotes surrounding the character to be printed.
1987 NEED_ESCAPE is an in/out flag which is used to track numeric
1988 escapes across calls. */
1991 print_wchar (gdb_wint_t w, const gdb_byte *orig,
1992 int orig_len, int width,
1993 enum bfd_endian byte_order,
1994 struct obstack *output,
1995 int quoter, int *need_escapep)
1997 int need_escape = *need_escapep;
2001 /* iswprint implementation on Windows returns 1 for tab character.
2002 In order to avoid different printout on this host, we explicitly
2003 use wchar_printable function. */
2007 obstack_grow_wstr (output, LCST ("\\a"));
2010 obstack_grow_wstr (output, LCST ("\\b"));
2013 obstack_grow_wstr (output, LCST ("\\f"));
2016 obstack_grow_wstr (output, LCST ("\\n"));
2019 obstack_grow_wstr (output, LCST ("\\r"));
2022 obstack_grow_wstr (output, LCST ("\\t"));
2025 obstack_grow_wstr (output, LCST ("\\v"));
2029 if (wchar_printable (w) && (!need_escape || (!gdb_iswdigit (w)
2031 && w != LCST ('9'))))
2033 gdb_wchar_t wchar = w;
2035 if (w == gdb_btowc (quoter) || w == LCST ('\\'))
2036 obstack_grow_wstr (output, LCST ("\\"));
2037 obstack_grow (output, &wchar, sizeof (gdb_wchar_t));
2043 for (i = 0; i + width <= orig_len; i += width)
2048 value = extract_unsigned_integer (&orig[i], width,
2050 /* If the value fits in 3 octal digits, print it that
2051 way. Otherwise, print it as a hex escape. */
2053 xsnprintf (octal, sizeof (octal), "\\%.3o",
2054 (int) (value & 0777));
2056 xsnprintf (octal, sizeof (octal), "\\x%lx", (long) value);
2057 append_string_as_wide (octal, output);
2059 /* If we somehow have extra bytes, print them now. */
2060 while (i < orig_len)
2064 xsnprintf (octal, sizeof (octal), "\\%.3o", orig[i] & 0xff);
2065 append_string_as_wide (octal, output);
2076 /* Print the character C on STREAM as part of the contents of a
2077 literal string whose delimiter is QUOTER. ENCODING names the
2081 generic_emit_char (int c, struct type *type, struct ui_file *stream,
2082 int quoter, const char *encoding)
2084 enum bfd_endian byte_order
2085 = gdbarch_byte_order (get_type_arch (type));
2086 struct obstack wchar_buf, output;
2087 struct cleanup *cleanups;
2089 struct wchar_iterator *iter;
2090 int need_escape = 0;
2092 buf = alloca (TYPE_LENGTH (type));
2093 pack_long (buf, type, c);
2095 iter = make_wchar_iterator (buf, TYPE_LENGTH (type),
2096 encoding, TYPE_LENGTH (type));
2097 cleanups = make_cleanup_wchar_iterator (iter);
2099 /* This holds the printable form of the wchar_t data. */
2100 obstack_init (&wchar_buf);
2101 make_cleanup_obstack_free (&wchar_buf);
2107 const gdb_byte *buf;
2109 int print_escape = 1;
2110 enum wchar_iterate_result result;
2112 num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
2117 /* If all characters are printable, print them. Otherwise,
2118 we're going to have to print an escape sequence. We
2119 check all characters because we want to print the target
2120 bytes in the escape sequence, and we don't know character
2121 boundaries there. */
2125 for (i = 0; i < num_chars; ++i)
2126 if (!wchar_printable (chars[i]))
2134 for (i = 0; i < num_chars; ++i)
2135 print_wchar (chars[i], buf, buflen,
2136 TYPE_LENGTH (type), byte_order,
2137 &wchar_buf, quoter, &need_escape);
2141 /* This handles the NUM_CHARS == 0 case as well. */
2143 print_wchar (gdb_WEOF, buf, buflen, TYPE_LENGTH (type),
2144 byte_order, &wchar_buf, quoter, &need_escape);
2147 /* The output in the host encoding. */
2148 obstack_init (&output);
2149 make_cleanup_obstack_free (&output);
2151 convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (),
2152 (gdb_byte *) obstack_base (&wchar_buf),
2153 obstack_object_size (&wchar_buf),
2154 sizeof (gdb_wchar_t), &output, translit_char);
2155 obstack_1grow (&output, '\0');
2157 fputs_filtered (obstack_base (&output), stream);
2159 do_cleanups (cleanups);
2162 /* Return the repeat count of the next character/byte in ITER,
2163 storing the result in VEC. */
2166 count_next_character (struct wchar_iterator *iter,
2167 VEC (converted_character_d) **vec)
2169 struct converted_character *current;
2171 if (VEC_empty (converted_character_d, *vec))
2173 struct converted_character tmp;
2177 = wchar_iterate (iter, &tmp.result, &chars, &tmp.buf, &tmp.buflen);
2178 if (tmp.num_chars > 0)
2180 gdb_assert (tmp.num_chars < MAX_WCHARS);
2181 memcpy (tmp.chars, chars, tmp.num_chars * sizeof (gdb_wchar_t));
2183 VEC_safe_push (converted_character_d, *vec, &tmp);
2186 current = VEC_last (converted_character_d, *vec);
2188 /* Count repeated characters or bytes. */
2189 current->repeat_count = 1;
2190 if (current->num_chars == -1)
2198 struct converted_character d;
2205 /* Get the next character. */
2207 = wchar_iterate (iter, &d.result, &chars, &d.buf, &d.buflen);
2209 /* If a character was successfully converted, save the character
2210 into the converted character. */
2211 if (d.num_chars > 0)
2213 gdb_assert (d.num_chars < MAX_WCHARS);
2214 memcpy (d.chars, chars, WCHAR_BUFLEN (d.num_chars));
2217 /* Determine if the current character is the same as this
2219 if (d.num_chars == current->num_chars && d.result == current->result)
2221 /* There are two cases to consider:
2223 1) Equality of converted character (num_chars > 0)
2224 2) Equality of non-converted character (num_chars == 0) */
2225 if ((current->num_chars > 0
2226 && memcmp (current->chars, d.chars,
2227 WCHAR_BUFLEN (current->num_chars)) == 0)
2228 || (current->num_chars == 0
2229 && current->buflen == d.buflen
2230 && memcmp (current->buf, d.buf, current->buflen) == 0))
2231 ++current->repeat_count;
2239 /* Push this next converted character onto the result vector. */
2240 repeat = current->repeat_count;
2241 VEC_safe_push (converted_character_d, *vec, &d);
2246 /* Print the characters in CHARS to the OBSTACK. QUOTE_CHAR is the quote
2247 character to use with string output. WIDTH is the size of the output
2248 character type. BYTE_ORDER is the the target byte order. OPTIONS
2249 is the user's print options. */
2252 print_converted_chars_to_obstack (struct obstack *obstack,
2253 VEC (converted_character_d) *chars,
2254 int quote_char, int width,
2255 enum bfd_endian byte_order,
2256 const struct value_print_options *options)
2259 struct converted_character *elem;
2260 enum {START, SINGLE, REPEAT, INCOMPLETE, FINISH} state, last;
2261 gdb_wchar_t wide_quote_char = gdb_btowc (quote_char);
2262 int need_escape = 0;
2264 /* Set the start state. */
2266 last = state = START;
2274 /* Nothing to do. */
2281 /* We are outputting a single character
2282 (< options->repeat_count_threshold). */
2286 /* We were outputting some other type of content, so we
2287 must output and a comma and a quote. */
2289 obstack_grow_wstr (obstack, LCST (", "));
2290 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t));
2292 /* Output the character. */
2293 for (j = 0; j < elem->repeat_count; ++j)
2295 if (elem->result == wchar_iterate_ok)
2296 print_wchar (elem->chars[0], elem->buf, elem->buflen, width,
2297 byte_order, obstack, quote_char, &need_escape);
2299 print_wchar (gdb_WEOF, elem->buf, elem->buflen, width,
2300 byte_order, obstack, quote_char, &need_escape);
2310 /* We are outputting a character with a repeat count
2311 greater than options->repeat_count_threshold. */
2315 /* We were outputting a single string. Terminate the
2317 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t));
2320 obstack_grow_wstr (obstack, LCST (", "));
2322 /* Output the character and repeat string. */
2323 obstack_grow_wstr (obstack, LCST ("'"));
2324 if (elem->result == wchar_iterate_ok)
2325 print_wchar (elem->chars[0], elem->buf, elem->buflen, width,
2326 byte_order, obstack, quote_char, &need_escape);
2328 print_wchar (gdb_WEOF, elem->buf, elem->buflen, width,
2329 byte_order, obstack, quote_char, &need_escape);
2330 obstack_grow_wstr (obstack, LCST ("'"));
2331 s = xstrprintf (_(" <repeats %u times>"), elem->repeat_count);
2332 for (j = 0; s[j]; ++j)
2334 gdb_wchar_t w = gdb_btowc (s[j]);
2335 obstack_grow (obstack, &w, sizeof (gdb_wchar_t));
2342 /* We are outputting an incomplete sequence. */
2345 /* If we were outputting a string of SINGLE characters,
2346 terminate the quote. */
2347 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t));
2350 obstack_grow_wstr (obstack, LCST (", "));
2352 /* Output the incomplete sequence string. */
2353 obstack_grow_wstr (obstack, LCST ("<incomplete sequence "));
2354 print_wchar (gdb_WEOF, elem->buf, elem->buflen, width, byte_order,
2355 obstack, 0, &need_escape);
2356 obstack_grow_wstr (obstack, LCST (">"));
2358 /* We do not attempt to outupt anything after this. */
2363 /* All done. If we were outputting a string of SINGLE
2364 characters, the string must be terminated. Otherwise,
2365 REPEAT and INCOMPLETE are always left properly terminated. */
2367 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t));
2372 /* Get the next element and state. */
2374 if (state != FINISH)
2376 elem = VEC_index (converted_character_d, chars, idx++);
2377 switch (elem->result)
2379 case wchar_iterate_ok:
2380 case wchar_iterate_invalid:
2381 if (elem->repeat_count > options->repeat_count_threshold)
2387 case wchar_iterate_incomplete:
2391 case wchar_iterate_eof:
2399 /* Print the character string STRING, printing at most LENGTH
2400 characters. LENGTH is -1 if the string is nul terminated. TYPE is
2401 the type of each character. OPTIONS holds the printing options;
2402 printing stops early if the number hits print_max; repeat counts
2403 are printed as appropriate. Print ellipses at the end if we had to
2404 stop before printing LENGTH characters, or if FORCE_ELLIPSES.
2405 QUOTE_CHAR is the character to print at each end of the string. If
2406 C_STYLE_TERMINATOR is true, and the last character is 0, then it is
2410 generic_printstr (struct ui_file *stream, struct type *type,
2411 const gdb_byte *string, unsigned int length,
2412 const char *encoding, int force_ellipses,
2413 int quote_char, int c_style_terminator,
2414 const struct value_print_options *options)
2416 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
2418 int width = TYPE_LENGTH (type);
2419 struct obstack wchar_buf, output;
2420 struct cleanup *cleanup;
2421 struct wchar_iterator *iter;
2423 struct converted_character *last;
2424 VEC (converted_character_d) *converted_chars;
2428 unsigned long current_char = 1;
2430 for (i = 0; current_char; ++i)
2433 current_char = extract_unsigned_integer (string + i * width,
2439 /* If the string was not truncated due to `set print elements', and
2440 the last byte of it is a null, we don't print that, in
2441 traditional C style. */
2442 if (c_style_terminator
2445 && (extract_unsigned_integer (string + (length - 1) * width,
2446 width, byte_order) == 0))
2451 fputs_filtered ("\"\"", stream);
2455 /* Arrange to iterate over the characters, in wchar_t form. */
2456 iter = make_wchar_iterator (string, length * width, encoding, width);
2457 cleanup = make_cleanup_wchar_iterator (iter);
2458 converted_chars = NULL;
2459 make_cleanup (VEC_cleanup (converted_character_d), &converted_chars);
2461 /* Convert characters until the string is over or the maximum
2462 number of printed characters has been reached. */
2464 while (i < options->print_max)
2470 /* Grab the next character and repeat count. */
2471 r = count_next_character (iter, &converted_chars);
2473 /* If less than zero, the end of the input string was reached. */
2477 /* Otherwise, add the count to the total print count and get
2478 the next character. */
2482 /* Get the last element and determine if the entire string was
2484 last = VEC_last (converted_character_d, converted_chars);
2485 finished = (last->result == wchar_iterate_eof);
2487 /* Ensure that CONVERTED_CHARS is terminated. */
2488 last->result = wchar_iterate_eof;
2490 /* WCHAR_BUF is the obstack we use to represent the string in
2492 obstack_init (&wchar_buf);
2493 make_cleanup_obstack_free (&wchar_buf);
2495 /* Print the output string to the obstack. */
2496 print_converted_chars_to_obstack (&wchar_buf, converted_chars, quote_char,
2497 width, byte_order, options);
2499 if (force_ellipses || !finished)
2500 obstack_grow_wstr (&wchar_buf, LCST ("..."));
2502 /* OUTPUT is where we collect `char's for printing. */
2503 obstack_init (&output);
2504 make_cleanup_obstack_free (&output);
2506 convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (),
2507 (gdb_byte *) obstack_base (&wchar_buf),
2508 obstack_object_size (&wchar_buf),
2509 sizeof (gdb_wchar_t), &output, translit_char);
2510 obstack_1grow (&output, '\0');
2512 fputs_filtered (obstack_base (&output), stream);
2514 do_cleanups (cleanup);
2517 /* Print a string from the inferior, starting at ADDR and printing up to LEN
2518 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
2519 stops at the first null byte, otherwise printing proceeds (including null
2520 bytes) until either print_max or LEN characters have been printed,
2521 whichever is smaller. ENCODING is the name of the string's
2522 encoding. It can be NULL, in which case the target encoding is
2526 val_print_string (struct type *elttype, const char *encoding,
2527 CORE_ADDR addr, int len,
2528 struct ui_file *stream,
2529 const struct value_print_options *options)
2531 int force_ellipsis = 0; /* Force ellipsis to be printed if nonzero. */
2532 int errcode; /* Errno returned from bad reads. */
2533 int found_nul; /* Non-zero if we found the nul char. */
2534 unsigned int fetchlimit; /* Maximum number of chars to print. */
2536 gdb_byte *buffer = NULL; /* Dynamically growable fetch buffer. */
2537 struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
2538 struct gdbarch *gdbarch = get_type_arch (elttype);
2539 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2540 int width = TYPE_LENGTH (elttype);
2542 /* First we need to figure out the limit on the number of characters we are
2543 going to attempt to fetch and print. This is actually pretty simple. If
2544 LEN >= zero, then the limit is the minimum of LEN and print_max. If
2545 LEN is -1, then the limit is print_max. This is true regardless of
2546 whether print_max is zero, UINT_MAX (unlimited), or something in between,
2547 because finding the null byte (or available memory) is what actually
2548 limits the fetch. */
2550 fetchlimit = (len == -1 ? options->print_max : min (len,
2551 options->print_max));
2553 errcode = read_string (addr, len, width, fetchlimit, byte_order,
2554 &buffer, &bytes_read);
2555 old_chain = make_cleanup (xfree, buffer);
2559 /* We now have either successfully filled the buffer to fetchlimit,
2560 or terminated early due to an error or finding a null char when
2563 /* Determine found_nul by looking at the last character read. */
2565 if (bytes_read >= width)
2566 found_nul = extract_unsigned_integer (buffer + bytes_read - width, width,
2568 if (len == -1 && !found_nul)
2572 /* We didn't find a NUL terminator we were looking for. Attempt
2573 to peek at the next character. If not successful, or it is not
2574 a null byte, then force ellipsis to be printed. */
2576 peekbuf = (gdb_byte *) alloca (width);
2578 if (target_read_memory (addr, peekbuf, width) == 0
2579 && extract_unsigned_integer (peekbuf, width, byte_order) != 0)
2582 else if ((len >= 0 && errcode != 0) || (len > bytes_read / width))
2584 /* Getting an error when we have a requested length, or fetching less
2585 than the number of characters actually requested, always make us
2590 /* If we get an error before fetching anything, don't print a string.
2591 But if we fetch something and then get an error, print the string
2592 and then the error message. */
2593 if (errcode == 0 || bytes_read > 0)
2595 LA_PRINT_STRING (stream, elttype, buffer, bytes_read / width,
2596 encoding, force_ellipsis, options);
2603 str = memory_error_message (errcode, gdbarch, addr);
2604 make_cleanup (xfree, str);
2606 fprintf_filtered (stream, "<error: ");
2607 fputs_filtered (str, stream);
2608 fprintf_filtered (stream, ">");
2612 do_cleanups (old_chain);
2614 return (bytes_read / width);
2618 /* The 'set input-radix' command writes to this auxiliary variable.
2619 If the requested radix is valid, INPUT_RADIX is updated; otherwise,
2620 it is left unchanged. */
2622 static unsigned input_radix_1 = 10;
2624 /* Validate an input or output radix setting, and make sure the user
2625 knows what they really did here. Radix setting is confusing, e.g.
2626 setting the input radix to "10" never changes it! */
2629 set_input_radix (char *args, int from_tty, struct cmd_list_element *c)
2631 set_input_radix_1 (from_tty, input_radix_1);
2635 set_input_radix_1 (int from_tty, unsigned radix)
2637 /* We don't currently disallow any input radix except 0 or 1, which don't
2638 make any mathematical sense. In theory, we can deal with any input
2639 radix greater than 1, even if we don't have unique digits for every
2640 value from 0 to radix-1, but in practice we lose on large radix values.
2641 We should either fix the lossage or restrict the radix range more.
2646 input_radix_1 = input_radix;
2647 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
2650 input_radix_1 = input_radix = radix;
2653 printf_filtered (_("Input radix now set to "
2654 "decimal %u, hex %x, octal %o.\n"),
2655 radix, radix, radix);
2659 /* The 'set output-radix' command writes to this auxiliary variable.
2660 If the requested radix is valid, OUTPUT_RADIX is updated,
2661 otherwise, it is left unchanged. */
2663 static unsigned output_radix_1 = 10;
2666 set_output_radix (char *args, int from_tty, struct cmd_list_element *c)
2668 set_output_radix_1 (from_tty, output_radix_1);
2672 set_output_radix_1 (int from_tty, unsigned radix)
2674 /* Validate the radix and disallow ones that we aren't prepared to
2675 handle correctly, leaving the radix unchanged. */
2679 user_print_options.output_format = 'x'; /* hex */
2682 user_print_options.output_format = 0; /* decimal */
2685 user_print_options.output_format = 'o'; /* octal */
2688 output_radix_1 = output_radix;
2689 error (_("Unsupported output radix ``decimal %u''; "
2690 "output radix unchanged."),
2693 output_radix_1 = output_radix = radix;
2696 printf_filtered (_("Output radix now set to "
2697 "decimal %u, hex %x, octal %o.\n"),
2698 radix, radix, radix);
2702 /* Set both the input and output radix at once. Try to set the output radix
2703 first, since it has the most restrictive range. An radix that is valid as
2704 an output radix is also valid as an input radix.
2706 It may be useful to have an unusual input radix. If the user wishes to
2707 set an input radix that is not valid as an output radix, he needs to use
2708 the 'set input-radix' command. */
2711 set_radix (char *arg, int from_tty)
2715 radix = (arg == NULL) ? 10 : parse_and_eval_long (arg);
2716 set_output_radix_1 (0, radix);
2717 set_input_radix_1 (0, radix);
2720 printf_filtered (_("Input and output radices now set to "
2721 "decimal %u, hex %x, octal %o.\n"),
2722 radix, radix, radix);
2726 /* Show both the input and output radices. */
2729 show_radix (char *arg, int from_tty)
2733 if (input_radix == output_radix)
2735 printf_filtered (_("Input and output radices set to "
2736 "decimal %u, hex %x, octal %o.\n"),
2737 input_radix, input_radix, input_radix);
2741 printf_filtered (_("Input radix set to decimal "
2742 "%u, hex %x, octal %o.\n"),
2743 input_radix, input_radix, input_radix);
2744 printf_filtered (_("Output radix set to decimal "
2745 "%u, hex %x, octal %o.\n"),
2746 output_radix, output_radix, output_radix);
2753 set_print (char *arg, int from_tty)
2756 "\"set print\" must be followed by the name of a print subcommand.\n");
2757 help_list (setprintlist, "set print ", all_commands, gdb_stdout);
2761 show_print (char *args, int from_tty)
2763 cmd_show_list (showprintlist, from_tty, "");
2767 set_print_raw (char *arg, int from_tty)
2770 "\"set print raw\" must be followed by the name of a \"print raw\" subcommand.\n");
2771 help_list (setprintrawlist, "set print raw ", all_commands, gdb_stdout);
2775 show_print_raw (char *args, int from_tty)
2777 cmd_show_list (showprintrawlist, from_tty, "");
2782 _initialize_valprint (void)
2784 add_prefix_cmd ("print", no_class, set_print,
2785 _("Generic command for setting how things print."),
2786 &setprintlist, "set print ", 0, &setlist);
2787 add_alias_cmd ("p", "print", no_class, 1, &setlist);
2788 /* Prefer set print to set prompt. */
2789 add_alias_cmd ("pr", "print", no_class, 1, &setlist);
2791 add_prefix_cmd ("print", no_class, show_print,
2792 _("Generic command for showing print settings."),
2793 &showprintlist, "show print ", 0, &showlist);
2794 add_alias_cmd ("p", "print", no_class, 1, &showlist);
2795 add_alias_cmd ("pr", "print", no_class, 1, &showlist);
2797 add_prefix_cmd ("raw", no_class, set_print_raw,
2799 Generic command for setting what things to print in \"raw\" mode."),
2800 &setprintrawlist, "set print raw ", 0, &setprintlist);
2801 add_prefix_cmd ("raw", no_class, show_print_raw,
2802 _("Generic command for showing \"print raw\" settings."),
2803 &showprintrawlist, "show print raw ", 0, &showprintlist);
2805 add_setshow_uinteger_cmd ("elements", no_class,
2806 &user_print_options.print_max, _("\
2807 Set limit on string chars or array elements to print."), _("\
2808 Show limit on string chars or array elements to print."), _("\
2809 \"set print elements unlimited\" causes there to be no limit."),
2812 &setprintlist, &showprintlist);
2814 add_setshow_boolean_cmd ("null-stop", no_class,
2815 &user_print_options.stop_print_at_null, _("\
2816 Set printing of char arrays to stop at first null char."), _("\
2817 Show printing of char arrays to stop at first null char."), NULL,
2819 show_stop_print_at_null,
2820 &setprintlist, &showprintlist);
2822 add_setshow_uinteger_cmd ("repeats", no_class,
2823 &user_print_options.repeat_count_threshold, _("\
2824 Set threshold for repeated print elements."), _("\
2825 Show threshold for repeated print elements."), _("\
2826 \"set print repeats unlimited\" causes all elements to be individually printed."),
2828 show_repeat_count_threshold,
2829 &setprintlist, &showprintlist);
2831 add_setshow_boolean_cmd ("pretty", class_support,
2832 &user_print_options.prettyformat_structs, _("\
2833 Set pretty formatting of structures."), _("\
2834 Show pretty formatting of structures."), NULL,
2836 show_prettyformat_structs,
2837 &setprintlist, &showprintlist);
2839 add_setshow_boolean_cmd ("union", class_support,
2840 &user_print_options.unionprint, _("\
2841 Set printing of unions interior to structures."), _("\
2842 Show printing of unions interior to structures."), NULL,
2845 &setprintlist, &showprintlist);
2847 add_setshow_boolean_cmd ("array", class_support,
2848 &user_print_options.prettyformat_arrays, _("\
2849 Set pretty formatting of arrays."), _("\
2850 Show pretty formatting of arrays."), NULL,
2852 show_prettyformat_arrays,
2853 &setprintlist, &showprintlist);
2855 add_setshow_boolean_cmd ("address", class_support,
2856 &user_print_options.addressprint, _("\
2857 Set printing of addresses."), _("\
2858 Show printing of addresses."), NULL,
2861 &setprintlist, &showprintlist);
2863 add_setshow_boolean_cmd ("symbol", class_support,
2864 &user_print_options.symbol_print, _("\
2865 Set printing of symbol names when printing pointers."), _("\
2866 Show printing of symbol names when printing pointers."),
2869 &setprintlist, &showprintlist);
2871 add_setshow_zuinteger_cmd ("input-radix", class_support, &input_radix_1,
2873 Set default input radix for entering numbers."), _("\
2874 Show default input radix for entering numbers."), NULL,
2877 &setlist, &showlist);
2879 add_setshow_zuinteger_cmd ("output-radix", class_support, &output_radix_1,
2881 Set default output radix for printing of values."), _("\
2882 Show default output radix for printing of values."), NULL,
2885 &setlist, &showlist);
2887 /* The "set radix" and "show radix" commands are special in that
2888 they are like normal set and show commands but allow two normally
2889 independent variables to be either set or shown with a single
2890 command. So the usual deprecated_add_set_cmd() and [deleted]
2891 add_show_from_set() commands aren't really appropriate. */
2892 /* FIXME: i18n: With the new add_setshow_integer command, that is no
2893 longer true - show can display anything. */
2894 add_cmd ("radix", class_support, set_radix, _("\
2895 Set default input and output number radices.\n\
2896 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
2897 Without an argument, sets both radices back to the default value of 10."),
2899 add_cmd ("radix", class_support, show_radix, _("\
2900 Show the default input and output number radices.\n\
2901 Use 'show input-radix' or 'show output-radix' to independently show each."),
2904 add_setshow_boolean_cmd ("array-indexes", class_support,
2905 &user_print_options.print_array_indexes, _("\
2906 Set printing of array indexes."), _("\
2907 Show printing of array indexes"), NULL, NULL, show_print_array_indexes,
2908 &setprintlist, &showprintlist);