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/>. */
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 (value_entirely_unavailable (val))
817 if (options->summary && !val_print_scalar_type_p (value_type (val)))
818 fprintf_filtered (stream, "...");
820 val_print_unavailable (stream);
824 if (TYPE_CODE (value_type (val)) == TYPE_CODE_INTERNAL_FUNCTION)
826 fprintf_filtered (stream, _("<internal function %s>"),
827 value_internal_function_name (val));
834 /* Print using the given LANGUAGE the value VAL onto stream STREAM according
837 This is a preferable interface to val_print, above, because it uses
838 GDB's value mechanism. */
841 common_val_print (struct value *val, struct ui_file *stream, int recurse,
842 const struct value_print_options *options,
843 const struct language_defn *language)
845 if (!value_check_printable (val, stream, options))
848 if (language->la_language == language_ada)
849 /* The value might have a dynamic type, which would cause trouble
850 below when trying to extract the value contents (since the value
851 size is determined from the type size which is unknown). So
852 get a fixed representation of our value. */
853 val = ada_to_fixed_value (val);
855 val_print (value_type (val), value_contents_for_printing (val),
856 value_embedded_offset (val), value_address (val),
858 val, options, language);
861 /* Print on stream STREAM the value VAL according to OPTIONS. The value
862 is printed using the current_language syntax. */
865 value_print (struct value *val, struct ui_file *stream,
866 const struct value_print_options *options)
868 if (!value_check_printable (val, stream, options))
873 int r = apply_val_pretty_printer (value_type (val),
874 value_contents_for_printing (val),
875 value_embedded_offset (val),
878 val, options, current_language);
884 LA_VALUE_PRINT (val, stream, options);
887 /* Called by various <lang>_val_print routines to print
888 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
889 value. STREAM is where to print the value. */
892 val_print_type_code_int (struct type *type, const gdb_byte *valaddr,
893 struct ui_file *stream)
895 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
897 if (TYPE_LENGTH (type) > sizeof (LONGEST))
901 if (TYPE_UNSIGNED (type)
902 && extract_long_unsigned_integer (valaddr, TYPE_LENGTH (type),
905 print_longest (stream, 'u', 0, val);
909 /* Signed, or we couldn't turn an unsigned value into a
910 LONGEST. For signed values, one could assume two's
911 complement (a reasonable assumption, I think) and do
913 print_hex_chars (stream, (unsigned char *) valaddr,
914 TYPE_LENGTH (type), byte_order);
919 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0,
920 unpack_long (type, valaddr));
925 val_print_type_code_flags (struct type *type, const gdb_byte *valaddr,
926 struct ui_file *stream)
928 ULONGEST val = unpack_long (type, valaddr);
929 int bitpos, nfields = TYPE_NFIELDS (type);
931 fputs_filtered ("[ ", stream);
932 for (bitpos = 0; bitpos < nfields; bitpos++)
934 if (TYPE_FIELD_BITPOS (type, bitpos) != -1
935 && (val & ((ULONGEST)1 << bitpos)))
937 if (TYPE_FIELD_NAME (type, bitpos))
938 fprintf_filtered (stream, "%s ", TYPE_FIELD_NAME (type, bitpos));
940 fprintf_filtered (stream, "#%d ", bitpos);
943 fputs_filtered ("]", stream);
946 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
947 according to OPTIONS and SIZE on STREAM. Format i is not supported
950 This is how the elements of an array or structure are printed
954 val_print_scalar_formatted (struct type *type,
955 const gdb_byte *valaddr, int embedded_offset,
956 const struct value *val,
957 const struct value_print_options *options,
959 struct ui_file *stream)
961 gdb_assert (val != NULL);
962 gdb_assert (valaddr == value_contents_for_printing_const (val));
964 /* If we get here with a string format, try again without it. Go
965 all the way back to the language printers, which may call us
967 if (options->format == 's')
969 struct value_print_options opts = *options;
972 val_print (type, valaddr, embedded_offset, 0, stream, 0, val, &opts,
977 /* A scalar object that does not have all bits available can't be
978 printed, because all bits contribute to its representation. */
979 if (!value_bits_valid (val, TARGET_CHAR_BIT * embedded_offset,
980 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
981 val_print_optimized_out (val, stream);
982 else if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
983 val_print_unavailable (stream);
985 print_scalar_formatted (valaddr + embedded_offset, type,
986 options, size, stream);
989 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
990 The raison d'etre of this function is to consolidate printing of
991 LONG_LONG's into this one function. The format chars b,h,w,g are
992 from print_scalar_formatted(). Numbers are printed using C
995 USE_C_FORMAT means to use C format in all cases. Without it,
996 'o' and 'x' format do not include the standard C radix prefix
999 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
1000 and was intended to request formating according to the current
1001 language and would be used for most integers that GDB prints. The
1002 exceptional cases were things like protocols where the format of
1003 the integer is a protocol thing, not a user-visible thing). The
1004 parameter remains to preserve the information of what things might
1005 be printed with language-specific format, should we ever resurrect
1009 print_longest (struct ui_file *stream, int format, int use_c_format,
1017 val = int_string (val_long, 10, 1, 0, 1); break;
1019 val = int_string (val_long, 10, 0, 0, 1); break;
1021 val = int_string (val_long, 16, 0, 0, use_c_format); break;
1023 val = int_string (val_long, 16, 0, 2, 1); break;
1025 val = int_string (val_long, 16, 0, 4, 1); break;
1027 val = int_string (val_long, 16, 0, 8, 1); break;
1029 val = int_string (val_long, 16, 0, 16, 1); break;
1032 val = int_string (val_long, 8, 0, 0, use_c_format); break;
1034 internal_error (__FILE__, __LINE__,
1035 _("failed internal consistency check"));
1037 fputs_filtered (val, stream);
1040 /* This used to be a macro, but I don't think it is called often enough
1041 to merit such treatment. */
1042 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
1043 arguments to a function, number in a value history, register number, etc.)
1044 where the value must not be larger than can fit in an int. */
1047 longest_to_int (LONGEST arg)
1049 /* Let the compiler do the work. */
1050 int rtnval = (int) arg;
1052 /* Check for overflows or underflows. */
1053 if (sizeof (LONGEST) > sizeof (int))
1057 error (_("Value out of range."));
1063 /* Print a floating point value of type TYPE (not always a
1064 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
1067 print_floating (const gdb_byte *valaddr, struct type *type,
1068 struct ui_file *stream)
1072 const struct floatformat *fmt = NULL;
1073 unsigned len = TYPE_LENGTH (type);
1074 enum float_kind kind;
1076 /* If it is a floating-point, check for obvious problems. */
1077 if (TYPE_CODE (type) == TYPE_CODE_FLT)
1078 fmt = floatformat_from_type (type);
1081 kind = floatformat_classify (fmt, valaddr);
1082 if (kind == float_nan)
1084 if (floatformat_is_negative (fmt, valaddr))
1085 fprintf_filtered (stream, "-");
1086 fprintf_filtered (stream, "nan(");
1087 fputs_filtered ("0x", stream);
1088 fputs_filtered (floatformat_mantissa (fmt, valaddr), stream);
1089 fprintf_filtered (stream, ")");
1092 else if (kind == float_infinite)
1094 if (floatformat_is_negative (fmt, valaddr))
1095 fputs_filtered ("-", stream);
1096 fputs_filtered ("inf", stream);
1101 /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
1102 isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double
1103 needs to be used as that takes care of any necessary type
1104 conversions. Such conversions are of course direct to DOUBLEST
1105 and disregard any possible target floating point limitations.
1106 For instance, a u64 would be converted and displayed exactly on a
1107 host with 80 bit DOUBLEST but with loss of information on a host
1108 with 64 bit DOUBLEST. */
1110 doub = unpack_double (type, valaddr, &inv);
1113 fprintf_filtered (stream, "<invalid float value>");
1117 /* FIXME: kettenis/2001-01-20: The following code makes too much
1118 assumptions about the host and target floating point format. */
1120 /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
1121 not necessarily be a TYPE_CODE_FLT, the below ignores that and
1122 instead uses the type's length to determine the precision of the
1123 floating-point value being printed. */
1125 if (len < sizeof (double))
1126 fprintf_filtered (stream, "%.9g", (double) doub);
1127 else if (len == sizeof (double))
1128 fprintf_filtered (stream, "%.17g", (double) doub);
1130 #ifdef PRINTF_HAS_LONG_DOUBLE
1131 fprintf_filtered (stream, "%.35Lg", doub);
1133 /* This at least wins with values that are representable as
1135 fprintf_filtered (stream, "%.17g", (double) doub);
1140 print_decimal_floating (const gdb_byte *valaddr, struct type *type,
1141 struct ui_file *stream)
1143 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
1144 char decstr[MAX_DECIMAL_STRING];
1145 unsigned len = TYPE_LENGTH (type);
1147 decimal_to_string (valaddr, len, byte_order, decstr);
1148 fputs_filtered (decstr, stream);
1153 print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr,
1154 unsigned len, enum bfd_endian byte_order)
1157 #define BITS_IN_BYTES 8
1163 /* Declared "int" so it will be signed.
1164 This ensures that right shift will shift in zeros. */
1166 const int mask = 0x080;
1168 /* FIXME: We should be not printing leading zeroes in most cases. */
1170 if (byte_order == BFD_ENDIAN_BIG)
1176 /* Every byte has 8 binary characters; peel off
1177 and print from the MSB end. */
1179 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
1181 if (*p & (mask >> i))
1186 fprintf_filtered (stream, "%1d", b);
1192 for (p = valaddr + len - 1;
1196 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
1198 if (*p & (mask >> i))
1203 fprintf_filtered (stream, "%1d", b);
1209 /* VALADDR points to an integer of LEN bytes.
1210 Print it in octal on stream or format it in buf. */
1213 print_octal_chars (struct ui_file *stream, const gdb_byte *valaddr,
1214 unsigned len, enum bfd_endian byte_order)
1217 unsigned char octa1, octa2, octa3, carry;
1220 /* FIXME: We should be not printing leading zeroes in most cases. */
1223 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
1224 * the extra bits, which cycle every three bytes:
1226 * Byte side: 0 1 2 3
1228 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
1230 * Octal side: 0 1 carry 3 4 carry ...
1232 * Cycle number: 0 1 2
1234 * But of course we are printing from the high side, so we have to
1235 * figure out where in the cycle we are so that we end up with no
1236 * left over bits at the end.
1238 #define BITS_IN_OCTAL 3
1239 #define HIGH_ZERO 0340
1240 #define LOW_ZERO 0016
1241 #define CARRY_ZERO 0003
1242 #define HIGH_ONE 0200
1243 #define MID_ONE 0160
1244 #define LOW_ONE 0016
1245 #define CARRY_ONE 0001
1246 #define HIGH_TWO 0300
1247 #define MID_TWO 0070
1248 #define LOW_TWO 0007
1250 /* For 32 we start in cycle 2, with two bits and one bit carry;
1251 for 64 in cycle in cycle 1, with one bit and a two bit carry. */
1253 cycle = (len * BITS_IN_BYTES) % BITS_IN_OCTAL;
1256 fputs_filtered ("0", stream);
1257 if (byte_order == BFD_ENDIAN_BIG)
1266 /* No carry in, carry out two bits. */
1268 octa1 = (HIGH_ZERO & *p) >> 5;
1269 octa2 = (LOW_ZERO & *p) >> 2;
1270 carry = (CARRY_ZERO & *p);
1271 fprintf_filtered (stream, "%o", octa1);
1272 fprintf_filtered (stream, "%o", octa2);
1276 /* Carry in two bits, carry out one bit. */
1278 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
1279 octa2 = (MID_ONE & *p) >> 4;
1280 octa3 = (LOW_ONE & *p) >> 1;
1281 carry = (CARRY_ONE & *p);
1282 fprintf_filtered (stream, "%o", octa1);
1283 fprintf_filtered (stream, "%o", octa2);
1284 fprintf_filtered (stream, "%o", octa3);
1288 /* Carry in one bit, no carry out. */
1290 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
1291 octa2 = (MID_TWO & *p) >> 3;
1292 octa3 = (LOW_TWO & *p);
1294 fprintf_filtered (stream, "%o", octa1);
1295 fprintf_filtered (stream, "%o", octa2);
1296 fprintf_filtered (stream, "%o", octa3);
1300 error (_("Internal error in octal conversion;"));
1304 cycle = cycle % BITS_IN_OCTAL;
1309 for (p = valaddr + len - 1;
1316 /* Carry out, no carry in */
1318 octa1 = (HIGH_ZERO & *p) >> 5;
1319 octa2 = (LOW_ZERO & *p) >> 2;
1320 carry = (CARRY_ZERO & *p);
1321 fprintf_filtered (stream, "%o", octa1);
1322 fprintf_filtered (stream, "%o", octa2);
1326 /* Carry in, carry out */
1328 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
1329 octa2 = (MID_ONE & *p) >> 4;
1330 octa3 = (LOW_ONE & *p) >> 1;
1331 carry = (CARRY_ONE & *p);
1332 fprintf_filtered (stream, "%o", octa1);
1333 fprintf_filtered (stream, "%o", octa2);
1334 fprintf_filtered (stream, "%o", octa3);
1338 /* Carry in, no carry out */
1340 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
1341 octa2 = (MID_TWO & *p) >> 3;
1342 octa3 = (LOW_TWO & *p);
1344 fprintf_filtered (stream, "%o", octa1);
1345 fprintf_filtered (stream, "%o", octa2);
1346 fprintf_filtered (stream, "%o", octa3);
1350 error (_("Internal error in octal conversion;"));
1354 cycle = cycle % BITS_IN_OCTAL;
1360 /* VALADDR points to an integer of LEN bytes.
1361 Print it in decimal on stream or format it in buf. */
1364 print_decimal_chars (struct ui_file *stream, const gdb_byte *valaddr,
1365 unsigned len, enum bfd_endian byte_order)
1368 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
1369 #define CARRY_LEFT( x ) ((x) % TEN)
1370 #define SHIFT( x ) ((x) << 4)
1371 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
1372 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
1375 unsigned char *digits;
1378 int i, j, decimal_digits;
1382 /* Base-ten number is less than twice as many digits
1383 as the base 16 number, which is 2 digits per byte. */
1385 decimal_len = len * 2 * 2;
1386 digits = xmalloc (decimal_len);
1388 for (i = 0; i < decimal_len; i++)
1393 /* Ok, we have an unknown number of bytes of data to be printed in
1396 * Given a hex number (in nibbles) as XYZ, we start by taking X and
1397 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
1398 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
1400 * The trick is that "digits" holds a base-10 number, but sometimes
1401 * the individual digits are > 10.
1403 * Outer loop is per nibble (hex digit) of input, from MSD end to
1406 decimal_digits = 0; /* Number of decimal digits so far */
1407 p = (byte_order == BFD_ENDIAN_BIG) ? valaddr : valaddr + len - 1;
1409 while ((byte_order == BFD_ENDIAN_BIG) ? (p < valaddr + len) : (p >= valaddr))
1412 * Multiply current base-ten number by 16 in place.
1413 * Each digit was between 0 and 9, now is between
1416 for (j = 0; j < decimal_digits; j++)
1418 digits[j] = SHIFT (digits[j]);
1421 /* Take the next nibble off the input and add it to what
1422 * we've got in the LSB position. Bottom 'digit' is now
1423 * between 0 and 159.
1425 * "flip" is used to run this loop twice for each byte.
1429 /* Take top nibble. */
1431 digits[0] += HIGH_NIBBLE (*p);
1436 /* Take low nibble and bump our pointer "p". */
1438 digits[0] += LOW_NIBBLE (*p);
1439 if (byte_order == BFD_ENDIAN_BIG)
1446 /* Re-decimalize. We have to do this often enough
1447 * that we don't overflow, but once per nibble is
1448 * overkill. Easier this way, though. Note that the
1449 * carry is often larger than 10 (e.g. max initial
1450 * carry out of lowest nibble is 15, could bubble all
1451 * the way up greater than 10). So we have to do
1452 * the carrying beyond the last current digit.
1455 for (j = 0; j < decimal_len - 1; j++)
1459 /* "/" won't handle an unsigned char with
1460 * a value that if signed would be negative.
1461 * So extend to longword int via "dummy".
1464 carry = CARRY_OUT (dummy);
1465 digits[j] = CARRY_LEFT (dummy);
1467 if (j >= decimal_digits && carry == 0)
1470 * All higher digits are 0 and we
1471 * no longer have a carry.
1473 * Note: "j" is 0-based, "decimal_digits" is
1476 decimal_digits = j + 1;
1482 /* Ok, now "digits" is the decimal representation, with
1483 the "decimal_digits" actual digits. Print! */
1485 for (i = decimal_digits - 1; i >= 0; i--)
1487 fprintf_filtered (stream, "%1d", digits[i]);
1492 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
1495 print_hex_chars (struct ui_file *stream, const gdb_byte *valaddr,
1496 unsigned len, enum bfd_endian byte_order)
1500 /* FIXME: We should be not printing leading zeroes in most cases. */
1502 fputs_filtered ("0x", stream);
1503 if (byte_order == BFD_ENDIAN_BIG)
1509 fprintf_filtered (stream, "%02x", *p);
1514 for (p = valaddr + len - 1;
1518 fprintf_filtered (stream, "%02x", *p);
1523 /* VALADDR points to a char integer of LEN bytes.
1524 Print it out in appropriate language form on stream.
1525 Omit any leading zero chars. */
1528 print_char_chars (struct ui_file *stream, struct type *type,
1529 const gdb_byte *valaddr,
1530 unsigned len, enum bfd_endian byte_order)
1534 if (byte_order == BFD_ENDIAN_BIG)
1537 while (p < valaddr + len - 1 && *p == 0)
1540 while (p < valaddr + len)
1542 LA_EMIT_CHAR (*p, type, stream, '\'');
1548 p = valaddr + len - 1;
1549 while (p > valaddr && *p == 0)
1552 while (p >= valaddr)
1554 LA_EMIT_CHAR (*p, type, stream, '\'');
1560 /* Print function pointer with inferior address ADDRESS onto stdio
1564 print_function_pointer_address (const struct value_print_options *options,
1565 struct gdbarch *gdbarch,
1567 struct ui_file *stream)
1570 = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
1573 /* If the function pointer is represented by a description, print
1574 the address of the description. */
1575 if (options->addressprint && func_addr != address)
1577 fputs_filtered ("@", stream);
1578 fputs_filtered (paddress (gdbarch, address), stream);
1579 fputs_filtered (": ", stream);
1581 print_address_demangle (options, gdbarch, func_addr, stream, demangle);
1585 /* Print on STREAM using the given OPTIONS the index for the element
1586 at INDEX of an array whose index type is INDEX_TYPE. */
1589 maybe_print_array_index (struct type *index_type, LONGEST index,
1590 struct ui_file *stream,
1591 const struct value_print_options *options)
1593 struct value *index_value;
1595 if (!options->print_array_indexes)
1598 index_value = value_from_longest (index_type, index);
1600 LA_PRINT_ARRAY_INDEX (index_value, stream, options);
1603 /* Called by various <lang>_val_print routines to print elements of an
1604 array in the form "<elem1>, <elem2>, <elem3>, ...".
1606 (FIXME?) Assumes array element separator is a comma, which is correct
1607 for all languages currently handled.
1608 (FIXME?) Some languages have a notation for repeated array elements,
1609 perhaps we should try to use that notation when appropriate. */
1612 val_print_array_elements (struct type *type,
1613 const gdb_byte *valaddr, int embedded_offset,
1614 CORE_ADDR address, struct ui_file *stream,
1616 const struct value *val,
1617 const struct value_print_options *options,
1620 unsigned int things_printed = 0;
1622 struct type *elttype, *index_type;
1624 /* Position of the array element we are examining to see
1625 whether it is repeated. */
1627 /* Number of repetitions we have detected so far. */
1629 LONGEST low_bound, high_bound;
1631 elttype = TYPE_TARGET_TYPE (type);
1632 eltlen = TYPE_LENGTH (check_typedef (elttype));
1633 index_type = TYPE_INDEX_TYPE (type);
1635 if (get_array_bounds (type, &low_bound, &high_bound))
1637 /* The array length should normally be HIGH_BOUND - LOW_BOUND + 1.
1638 But we have to be a little extra careful, because some languages
1639 such as Ada allow LOW_BOUND to be greater than HIGH_BOUND for
1640 empty arrays. In that situation, the array length is just zero,
1642 if (low_bound > high_bound)
1645 len = high_bound - low_bound + 1;
1649 warning (_("unable to get bounds of array, assuming null array"));
1654 annotate_array_section_begin (i, elttype);
1656 for (; i < len && things_printed < options->print_max; i++)
1660 if (options->prettyformat_arrays)
1662 fprintf_filtered (stream, ",\n");
1663 print_spaces_filtered (2 + 2 * recurse, stream);
1667 fprintf_filtered (stream, ", ");
1670 wrap_here (n_spaces (2 + 2 * recurse));
1671 maybe_print_array_index (index_type, i + low_bound,
1676 /* Only check for reps if repeat_count_threshold is not set to
1677 UINT_MAX (unlimited). */
1678 if (options->repeat_count_threshold < UINT_MAX)
1681 && value_available_contents_eq (val,
1682 embedded_offset + i * eltlen,
1693 if (reps > options->repeat_count_threshold)
1695 val_print (elttype, valaddr, embedded_offset + i * eltlen,
1696 address, stream, recurse + 1, val, options,
1698 annotate_elt_rep (reps);
1699 fprintf_filtered (stream, " <repeats %u times>", reps);
1700 annotate_elt_rep_end ();
1703 things_printed += options->repeat_count_threshold;
1707 val_print (elttype, valaddr, embedded_offset + i * eltlen,
1709 stream, recurse + 1, val, options, current_language);
1714 annotate_array_section_end ();
1717 fprintf_filtered (stream, "...");
1721 /* Read LEN bytes of target memory at address MEMADDR, placing the
1722 results in GDB's memory at MYADDR. Returns a count of the bytes
1723 actually read, and optionally a target_xfer_error value in the
1724 location pointed to by ERRPTR if ERRPTR is non-null. */
1726 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
1727 function be eliminated. */
1730 partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
1731 int len, int *errptr)
1733 int nread; /* Number of bytes actually read. */
1734 int errcode; /* Error from last read. */
1736 /* First try a complete read. */
1737 errcode = target_read_memory (memaddr, myaddr, len);
1745 /* Loop, reading one byte at a time until we get as much as we can. */
1746 for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
1748 errcode = target_read_memory (memaddr++, myaddr++, 1);
1750 /* If an error, the last read was unsuccessful, so adjust count. */
1763 /* Read a string from the inferior, at ADDR, with LEN characters of WIDTH bytes
1764 each. Fetch at most FETCHLIMIT characters. BUFFER will be set to a newly
1765 allocated buffer containing the string, which the caller is responsible to
1766 free, and BYTES_READ will be set to the number of bytes read. Returns 0 on
1767 success, or a target_xfer_error on failure.
1769 If LEN > 0, reads the lesser of LEN or FETCHLIMIT characters
1770 (including eventual NULs in the middle or end of the string).
1772 If LEN is -1, stops at the first null character (not necessarily
1773 the first null byte) up to a maximum of FETCHLIMIT characters. Set
1774 FETCHLIMIT to UINT_MAX to read as many characters as possible from
1777 Unless an exception is thrown, BUFFER will always be allocated, even on
1778 failure. In this case, some characters might have been read before the
1779 failure happened. Check BYTES_READ to recognize this situation.
1781 Note: There was a FIXME asking to make this code use target_read_string,
1782 but this function is more general (can read past null characters, up to
1783 given LEN). Besides, it is used much more often than target_read_string
1784 so it is more tested. Perhaps callers of target_read_string should use
1785 this function instead? */
1788 read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
1789 enum bfd_endian byte_order, gdb_byte **buffer, int *bytes_read)
1791 int found_nul; /* Non-zero if we found the nul char. */
1792 int errcode; /* Errno returned from bad reads. */
1793 unsigned int nfetch; /* Chars to fetch / chars fetched. */
1794 unsigned int chunksize; /* Size of each fetch, in chars. */
1795 gdb_byte *bufptr; /* Pointer to next available byte in
1797 gdb_byte *limit; /* First location past end of fetch buffer. */
1798 struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
1800 /* Decide how large of chunks to try to read in one operation. This
1801 is also pretty simple. If LEN >= zero, then we want fetchlimit chars,
1802 so we might as well read them all in one operation. If LEN is -1, we
1803 are looking for a NUL terminator to end the fetching, so we might as
1804 well read in blocks that are large enough to be efficient, but not so
1805 large as to be slow if fetchlimit happens to be large. So we choose the
1806 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
1807 200 is way too big for remote debugging over a serial line. */
1809 chunksize = (len == -1 ? min (8, fetchlimit) : fetchlimit);
1811 /* Loop until we either have all the characters, or we encounter
1812 some error, such as bumping into the end of the address space. */
1817 old_chain = make_cleanup (free_current_contents, buffer);
1821 unsigned int fetchlen = min (len, fetchlimit);
1823 *buffer = (gdb_byte *) xmalloc (fetchlen * width);
1826 nfetch = partial_memory_read (addr, bufptr, fetchlen * width, &errcode)
1828 addr += nfetch * width;
1829 bufptr += nfetch * width;
1833 unsigned long bufsize = 0;
1838 nfetch = min (chunksize, fetchlimit - bufsize);
1840 if (*buffer == NULL)
1841 *buffer = (gdb_byte *) xmalloc (nfetch * width);
1843 *buffer = (gdb_byte *) xrealloc (*buffer,
1844 (nfetch + bufsize) * width);
1846 bufptr = *buffer + bufsize * width;
1849 /* Read as much as we can. */
1850 nfetch = partial_memory_read (addr, bufptr, nfetch * width, &errcode)
1853 /* Scan this chunk for the null character that terminates the string
1854 to print. If found, we don't need to fetch any more. Note
1855 that bufptr is explicitly left pointing at the next character
1856 after the null character, or at the next character after the end
1859 limit = bufptr + nfetch * width;
1860 while (bufptr < limit)
1864 c = extract_unsigned_integer (bufptr, width, byte_order);
1869 /* We don't care about any error which happened after
1870 the NUL terminator. */
1877 while (errcode == 0 /* no error */
1878 && bufptr - *buffer < fetchlimit * width /* no overrun */
1879 && !found_nul); /* haven't found NUL yet */
1882 { /* Length of string is really 0! */
1883 /* We always allocate *buffer. */
1884 *buffer = bufptr = xmalloc (1);
1888 /* bufptr and addr now point immediately beyond the last byte which we
1889 consider part of the string (including a '\0' which ends the string). */
1890 *bytes_read = bufptr - *buffer;
1894 discard_cleanups (old_chain);
1899 /* Return true if print_wchar can display W without resorting to a
1900 numeric escape, false otherwise. */
1903 wchar_printable (gdb_wchar_t w)
1905 return (gdb_iswprint (w)
1906 || w == LCST ('\a') || w == LCST ('\b')
1907 || w == LCST ('\f') || w == LCST ('\n')
1908 || w == LCST ('\r') || w == LCST ('\t')
1909 || w == LCST ('\v'));
1912 /* A helper function that converts the contents of STRING to wide
1913 characters and then appends them to OUTPUT. */
1916 append_string_as_wide (const char *string,
1917 struct obstack *output)
1919 for (; *string; ++string)
1921 gdb_wchar_t w = gdb_btowc (*string);
1922 obstack_grow (output, &w, sizeof (gdb_wchar_t));
1926 /* Print a wide character W to OUTPUT. ORIG is a pointer to the
1927 original (target) bytes representing the character, ORIG_LEN is the
1928 number of valid bytes. WIDTH is the number of bytes in a base
1929 characters of the type. OUTPUT is an obstack to which wide
1930 characters are emitted. QUOTER is a (narrow) character indicating
1931 the style of quotes surrounding the character to be printed.
1932 NEED_ESCAPE is an in/out flag which is used to track numeric
1933 escapes across calls. */
1936 print_wchar (gdb_wint_t w, const gdb_byte *orig,
1937 int orig_len, int width,
1938 enum bfd_endian byte_order,
1939 struct obstack *output,
1940 int quoter, int *need_escapep)
1942 int need_escape = *need_escapep;
1945 if (gdb_iswprint (w) && (!need_escape || (!gdb_iswdigit (w)
1947 && w != LCST ('9'))))
1949 gdb_wchar_t wchar = w;
1951 if (w == gdb_btowc (quoter) || w == LCST ('\\'))
1952 obstack_grow_wstr (output, LCST ("\\"));
1953 obstack_grow (output, &wchar, sizeof (gdb_wchar_t));
1960 obstack_grow_wstr (output, LCST ("\\a"));
1963 obstack_grow_wstr (output, LCST ("\\b"));
1966 obstack_grow_wstr (output, LCST ("\\f"));
1969 obstack_grow_wstr (output, LCST ("\\n"));
1972 obstack_grow_wstr (output, LCST ("\\r"));
1975 obstack_grow_wstr (output, LCST ("\\t"));
1978 obstack_grow_wstr (output, LCST ("\\v"));
1984 for (i = 0; i + width <= orig_len; i += width)
1989 value = extract_unsigned_integer (&orig[i], width,
1991 /* If the value fits in 3 octal digits, print it that
1992 way. Otherwise, print it as a hex escape. */
1994 xsnprintf (octal, sizeof (octal), "\\%.3o",
1995 (int) (value & 0777));
1997 xsnprintf (octal, sizeof (octal), "\\x%lx", (long) value);
1998 append_string_as_wide (octal, output);
2000 /* If we somehow have extra bytes, print them now. */
2001 while (i < orig_len)
2005 xsnprintf (octal, sizeof (octal), "\\%.3o", orig[i] & 0xff);
2006 append_string_as_wide (octal, output);
2017 /* Print the character C on STREAM as part of the contents of a
2018 literal string whose delimiter is QUOTER. ENCODING names the
2022 generic_emit_char (int c, struct type *type, struct ui_file *stream,
2023 int quoter, const char *encoding)
2025 enum bfd_endian byte_order
2026 = gdbarch_byte_order (get_type_arch (type));
2027 struct obstack wchar_buf, output;
2028 struct cleanup *cleanups;
2030 struct wchar_iterator *iter;
2031 int need_escape = 0;
2033 buf = alloca (TYPE_LENGTH (type));
2034 pack_long (buf, type, c);
2036 iter = make_wchar_iterator (buf, TYPE_LENGTH (type),
2037 encoding, TYPE_LENGTH (type));
2038 cleanups = make_cleanup_wchar_iterator (iter);
2040 /* This holds the printable form of the wchar_t data. */
2041 obstack_init (&wchar_buf);
2042 make_cleanup_obstack_free (&wchar_buf);
2048 const gdb_byte *buf;
2050 int print_escape = 1;
2051 enum wchar_iterate_result result;
2053 num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
2058 /* If all characters are printable, print them. Otherwise,
2059 we're going to have to print an escape sequence. We
2060 check all characters because we want to print the target
2061 bytes in the escape sequence, and we don't know character
2062 boundaries there. */
2066 for (i = 0; i < num_chars; ++i)
2067 if (!wchar_printable (chars[i]))
2075 for (i = 0; i < num_chars; ++i)
2076 print_wchar (chars[i], buf, buflen,
2077 TYPE_LENGTH (type), byte_order,
2078 &wchar_buf, quoter, &need_escape);
2082 /* This handles the NUM_CHARS == 0 case as well. */
2084 print_wchar (gdb_WEOF, buf, buflen, TYPE_LENGTH (type),
2085 byte_order, &wchar_buf, quoter, &need_escape);
2088 /* The output in the host encoding. */
2089 obstack_init (&output);
2090 make_cleanup_obstack_free (&output);
2092 convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (),
2093 (gdb_byte *) obstack_base (&wchar_buf),
2094 obstack_object_size (&wchar_buf),
2095 sizeof (gdb_wchar_t), &output, translit_char);
2096 obstack_1grow (&output, '\0');
2098 fputs_filtered (obstack_base (&output), stream);
2100 do_cleanups (cleanups);
2103 /* Return the repeat count of the next character/byte in ITER,
2104 storing the result in VEC. */
2107 count_next_character (struct wchar_iterator *iter,
2108 VEC (converted_character_d) **vec)
2110 struct converted_character *current;
2112 if (VEC_empty (converted_character_d, *vec))
2114 struct converted_character tmp;
2118 = wchar_iterate (iter, &tmp.result, &chars, &tmp.buf, &tmp.buflen);
2119 if (tmp.num_chars > 0)
2121 gdb_assert (tmp.num_chars < MAX_WCHARS);
2122 memcpy (tmp.chars, chars, tmp.num_chars * sizeof (gdb_wchar_t));
2124 VEC_safe_push (converted_character_d, *vec, &tmp);
2127 current = VEC_last (converted_character_d, *vec);
2129 /* Count repeated characters or bytes. */
2130 current->repeat_count = 1;
2131 if (current->num_chars == -1)
2139 struct converted_character d;
2146 /* Get the next character. */
2148 = wchar_iterate (iter, &d.result, &chars, &d.buf, &d.buflen);
2150 /* If a character was successfully converted, save the character
2151 into the converted character. */
2152 if (d.num_chars > 0)
2154 gdb_assert (d.num_chars < MAX_WCHARS);
2155 memcpy (d.chars, chars, WCHAR_BUFLEN (d.num_chars));
2158 /* Determine if the current character is the same as this
2160 if (d.num_chars == current->num_chars && d.result == current->result)
2162 /* There are two cases to consider:
2164 1) Equality of converted character (num_chars > 0)
2165 2) Equality of non-converted character (num_chars == 0) */
2166 if ((current->num_chars > 0
2167 && memcmp (current->chars, d.chars,
2168 WCHAR_BUFLEN (current->num_chars)) == 0)
2169 || (current->num_chars == 0
2170 && current->buflen == d.buflen
2171 && memcmp (current->buf, d.buf, current->buflen) == 0))
2172 ++current->repeat_count;
2180 /* Push this next converted character onto the result vector. */
2181 repeat = current->repeat_count;
2182 VEC_safe_push (converted_character_d, *vec, &d);
2187 /* Print the characters in CHARS to the OBSTACK. QUOTE_CHAR is the quote
2188 character to use with string output. WIDTH is the size of the output
2189 character type. BYTE_ORDER is the the target byte order. OPTIONS
2190 is the user's print options. */
2193 print_converted_chars_to_obstack (struct obstack *obstack,
2194 VEC (converted_character_d) *chars,
2195 int quote_char, int width,
2196 enum bfd_endian byte_order,
2197 const struct value_print_options *options)
2200 struct converted_character *elem;
2201 enum {START, SINGLE, REPEAT, INCOMPLETE, FINISH} state, last;
2202 gdb_wchar_t wide_quote_char = gdb_btowc (quote_char);
2203 int need_escape = 0;
2205 /* Set the start state. */
2207 last = state = START;
2215 /* Nothing to do. */
2222 /* We are outputting a single character
2223 (< options->repeat_count_threshold). */
2227 /* We were outputting some other type of content, so we
2228 must output and a comma and a quote. */
2230 obstack_grow_wstr (obstack, LCST (", "));
2231 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t));
2233 /* Output the character. */
2234 for (j = 0; j < elem->repeat_count; ++j)
2236 if (elem->result == wchar_iterate_ok)
2237 print_wchar (elem->chars[0], elem->buf, elem->buflen, width,
2238 byte_order, obstack, quote_char, &need_escape);
2240 print_wchar (gdb_WEOF, elem->buf, elem->buflen, width,
2241 byte_order, obstack, quote_char, &need_escape);
2251 /* We are outputting a character with a repeat count
2252 greater than options->repeat_count_threshold. */
2256 /* We were outputting a single string. Terminate the
2258 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t));
2261 obstack_grow_wstr (obstack, LCST (", "));
2263 /* Output the character and repeat string. */
2264 obstack_grow_wstr (obstack, LCST ("'"));
2265 if (elem->result == wchar_iterate_ok)
2266 print_wchar (elem->chars[0], elem->buf, elem->buflen, width,
2267 byte_order, obstack, quote_char, &need_escape);
2269 print_wchar (gdb_WEOF, elem->buf, elem->buflen, width,
2270 byte_order, obstack, quote_char, &need_escape);
2271 obstack_grow_wstr (obstack, LCST ("'"));
2272 s = xstrprintf (_(" <repeats %u times>"), elem->repeat_count);
2273 for (j = 0; s[j]; ++j)
2275 gdb_wchar_t w = gdb_btowc (s[j]);
2276 obstack_grow (obstack, &w, sizeof (gdb_wchar_t));
2283 /* We are outputting an incomplete sequence. */
2286 /* If we were outputting a string of SINGLE characters,
2287 terminate the quote. */
2288 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t));
2291 obstack_grow_wstr (obstack, LCST (", "));
2293 /* Output the incomplete sequence string. */
2294 obstack_grow_wstr (obstack, LCST ("<incomplete sequence "));
2295 print_wchar (gdb_WEOF, elem->buf, elem->buflen, width, byte_order,
2296 obstack, 0, &need_escape);
2297 obstack_grow_wstr (obstack, LCST (">"));
2299 /* We do not attempt to outupt anything after this. */
2304 /* All done. If we were outputting a string of SINGLE
2305 characters, the string must be terminated. Otherwise,
2306 REPEAT and INCOMPLETE are always left properly terminated. */
2308 obstack_grow (obstack, &wide_quote_char, sizeof (gdb_wchar_t));
2313 /* Get the next element and state. */
2315 if (state != FINISH)
2317 elem = VEC_index (converted_character_d, chars, idx++);
2318 switch (elem->result)
2320 case wchar_iterate_ok:
2321 case wchar_iterate_invalid:
2322 if (elem->repeat_count > options->repeat_count_threshold)
2328 case wchar_iterate_incomplete:
2332 case wchar_iterate_eof:
2340 /* Print the character string STRING, printing at most LENGTH
2341 characters. LENGTH is -1 if the string is nul terminated. TYPE is
2342 the type of each character. OPTIONS holds the printing options;
2343 printing stops early if the number hits print_max; repeat counts
2344 are printed as appropriate. Print ellipses at the end if we had to
2345 stop before printing LENGTH characters, or if FORCE_ELLIPSES.
2346 QUOTE_CHAR is the character to print at each end of the string. If
2347 C_STYLE_TERMINATOR is true, and the last character is 0, then it is
2351 generic_printstr (struct ui_file *stream, struct type *type,
2352 const gdb_byte *string, unsigned int length,
2353 const char *encoding, int force_ellipses,
2354 int quote_char, int c_style_terminator,
2355 const struct value_print_options *options)
2357 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
2359 int width = TYPE_LENGTH (type);
2360 struct obstack wchar_buf, output;
2361 struct cleanup *cleanup;
2362 struct wchar_iterator *iter;
2364 struct converted_character *last;
2365 VEC (converted_character_d) *converted_chars;
2369 unsigned long current_char = 1;
2371 for (i = 0; current_char; ++i)
2374 current_char = extract_unsigned_integer (string + i * width,
2380 /* If the string was not truncated due to `set print elements', and
2381 the last byte of it is a null, we don't print that, in
2382 traditional C style. */
2383 if (c_style_terminator
2386 && (extract_unsigned_integer (string + (length - 1) * width,
2387 width, byte_order) == 0))
2392 fputs_filtered ("\"\"", stream);
2396 /* Arrange to iterate over the characters, in wchar_t form. */
2397 iter = make_wchar_iterator (string, length * width, encoding, width);
2398 cleanup = make_cleanup_wchar_iterator (iter);
2399 converted_chars = NULL;
2400 make_cleanup (VEC_cleanup (converted_character_d), &converted_chars);
2402 /* Convert characters until the string is over or the maximum
2403 number of printed characters has been reached. */
2405 while (i < options->print_max)
2411 /* Grab the next character and repeat count. */
2412 r = count_next_character (iter, &converted_chars);
2414 /* If less than zero, the end of the input string was reached. */
2418 /* Otherwise, add the count to the total print count and get
2419 the next character. */
2423 /* Get the last element and determine if the entire string was
2425 last = VEC_last (converted_character_d, converted_chars);
2426 finished = (last->result == wchar_iterate_eof);
2428 /* Ensure that CONVERTED_CHARS is terminated. */
2429 last->result = wchar_iterate_eof;
2431 /* WCHAR_BUF is the obstack we use to represent the string in
2433 obstack_init (&wchar_buf);
2434 make_cleanup_obstack_free (&wchar_buf);
2436 /* Print the output string to the obstack. */
2437 print_converted_chars_to_obstack (&wchar_buf, converted_chars, quote_char,
2438 width, byte_order, options);
2440 if (force_ellipses || !finished)
2441 obstack_grow_wstr (&wchar_buf, LCST ("..."));
2443 /* OUTPUT is where we collect `char's for printing. */
2444 obstack_init (&output);
2445 make_cleanup_obstack_free (&output);
2447 convert_between_encodings (INTERMEDIATE_ENCODING, host_charset (),
2448 (gdb_byte *) obstack_base (&wchar_buf),
2449 obstack_object_size (&wchar_buf),
2450 sizeof (gdb_wchar_t), &output, translit_char);
2451 obstack_1grow (&output, '\0');
2453 fputs_filtered (obstack_base (&output), stream);
2455 do_cleanups (cleanup);
2458 /* Print a string from the inferior, starting at ADDR and printing up to LEN
2459 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
2460 stops at the first null byte, otherwise printing proceeds (including null
2461 bytes) until either print_max or LEN characters have been printed,
2462 whichever is smaller. ENCODING is the name of the string's
2463 encoding. It can be NULL, in which case the target encoding is
2467 val_print_string (struct type *elttype, const char *encoding,
2468 CORE_ADDR addr, int len,
2469 struct ui_file *stream,
2470 const struct value_print_options *options)
2472 int force_ellipsis = 0; /* Force ellipsis to be printed if nonzero. */
2473 int errcode; /* Errno returned from bad reads. */
2474 int found_nul; /* Non-zero if we found the nul char. */
2475 unsigned int fetchlimit; /* Maximum number of chars to print. */
2477 gdb_byte *buffer = NULL; /* Dynamically growable fetch buffer. */
2478 struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
2479 struct gdbarch *gdbarch = get_type_arch (elttype);
2480 enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
2481 int width = TYPE_LENGTH (elttype);
2483 /* First we need to figure out the limit on the number of characters we are
2484 going to attempt to fetch and print. This is actually pretty simple. If
2485 LEN >= zero, then the limit is the minimum of LEN and print_max. If
2486 LEN is -1, then the limit is print_max. This is true regardless of
2487 whether print_max is zero, UINT_MAX (unlimited), or something in between,
2488 because finding the null byte (or available memory) is what actually
2489 limits the fetch. */
2491 fetchlimit = (len == -1 ? options->print_max : min (len,
2492 options->print_max));
2494 errcode = read_string (addr, len, width, fetchlimit, byte_order,
2495 &buffer, &bytes_read);
2496 old_chain = make_cleanup (xfree, buffer);
2500 /* We now have either successfully filled the buffer to fetchlimit,
2501 or terminated early due to an error or finding a null char when
2504 /* Determine found_nul by looking at the last character read. */
2505 found_nul = extract_unsigned_integer (buffer + bytes_read - width, width,
2507 if (len == -1 && !found_nul)
2511 /* We didn't find a NUL terminator we were looking for. Attempt
2512 to peek at the next character. If not successful, or it is not
2513 a null byte, then force ellipsis to be printed. */
2515 peekbuf = (gdb_byte *) alloca (width);
2517 if (target_read_memory (addr, peekbuf, width) == 0
2518 && extract_unsigned_integer (peekbuf, width, byte_order) != 0)
2521 else if ((len >= 0 && errcode != 0) || (len > bytes_read / width))
2523 /* Getting an error when we have a requested length, or fetching less
2524 than the number of characters actually requested, always make us
2529 /* If we get an error before fetching anything, don't print a string.
2530 But if we fetch something and then get an error, print the string
2531 and then the error message. */
2532 if (errcode == 0 || bytes_read > 0)
2534 LA_PRINT_STRING (stream, elttype, buffer, bytes_read / width,
2535 encoding, force_ellipsis, options);
2542 str = memory_error_message (errcode, gdbarch, addr);
2543 make_cleanup (xfree, str);
2545 fprintf_filtered (stream, "<error: ");
2546 fputs_filtered (str, stream);
2547 fprintf_filtered (stream, ">");
2551 do_cleanups (old_chain);
2553 return (bytes_read / width);
2557 /* The 'set input-radix' command writes to this auxiliary variable.
2558 If the requested radix is valid, INPUT_RADIX is updated; otherwise,
2559 it is left unchanged. */
2561 static unsigned input_radix_1 = 10;
2563 /* Validate an input or output radix setting, and make sure the user
2564 knows what they really did here. Radix setting is confusing, e.g.
2565 setting the input radix to "10" never changes it! */
2568 set_input_radix (char *args, int from_tty, struct cmd_list_element *c)
2570 set_input_radix_1 (from_tty, input_radix_1);
2574 set_input_radix_1 (int from_tty, unsigned radix)
2576 /* We don't currently disallow any input radix except 0 or 1, which don't
2577 make any mathematical sense. In theory, we can deal with any input
2578 radix greater than 1, even if we don't have unique digits for every
2579 value from 0 to radix-1, but in practice we lose on large radix values.
2580 We should either fix the lossage or restrict the radix range more.
2585 input_radix_1 = input_radix;
2586 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
2589 input_radix_1 = input_radix = radix;
2592 printf_filtered (_("Input radix now set to "
2593 "decimal %u, hex %x, octal %o.\n"),
2594 radix, radix, radix);
2598 /* The 'set output-radix' command writes to this auxiliary variable.
2599 If the requested radix is valid, OUTPUT_RADIX is updated,
2600 otherwise, it is left unchanged. */
2602 static unsigned output_radix_1 = 10;
2605 set_output_radix (char *args, int from_tty, struct cmd_list_element *c)
2607 set_output_radix_1 (from_tty, output_radix_1);
2611 set_output_radix_1 (int from_tty, unsigned radix)
2613 /* Validate the radix and disallow ones that we aren't prepared to
2614 handle correctly, leaving the radix unchanged. */
2618 user_print_options.output_format = 'x'; /* hex */
2621 user_print_options.output_format = 0; /* decimal */
2624 user_print_options.output_format = 'o'; /* octal */
2627 output_radix_1 = output_radix;
2628 error (_("Unsupported output radix ``decimal %u''; "
2629 "output radix unchanged."),
2632 output_radix_1 = output_radix = radix;
2635 printf_filtered (_("Output radix now set to "
2636 "decimal %u, hex %x, octal %o.\n"),
2637 radix, radix, radix);
2641 /* Set both the input and output radix at once. Try to set the output radix
2642 first, since it has the most restrictive range. An radix that is valid as
2643 an output radix is also valid as an input radix.
2645 It may be useful to have an unusual input radix. If the user wishes to
2646 set an input radix that is not valid as an output radix, he needs to use
2647 the 'set input-radix' command. */
2650 set_radix (char *arg, int from_tty)
2654 radix = (arg == NULL) ? 10 : parse_and_eval_long (arg);
2655 set_output_radix_1 (0, radix);
2656 set_input_radix_1 (0, radix);
2659 printf_filtered (_("Input and output radices now set to "
2660 "decimal %u, hex %x, octal %o.\n"),
2661 radix, radix, radix);
2665 /* Show both the input and output radices. */
2668 show_radix (char *arg, int from_tty)
2672 if (input_radix == output_radix)
2674 printf_filtered (_("Input and output radices set to "
2675 "decimal %u, hex %x, octal %o.\n"),
2676 input_radix, input_radix, input_radix);
2680 printf_filtered (_("Input radix set to decimal "
2681 "%u, hex %x, octal %o.\n"),
2682 input_radix, input_radix, input_radix);
2683 printf_filtered (_("Output radix set to decimal "
2684 "%u, hex %x, octal %o.\n"),
2685 output_radix, output_radix, output_radix);
2692 set_print (char *arg, int from_tty)
2695 "\"set print\" must be followed by the name of a print subcommand.\n");
2696 help_list (setprintlist, "set print ", -1, gdb_stdout);
2700 show_print (char *args, int from_tty)
2702 cmd_show_list (showprintlist, from_tty, "");
2706 set_print_raw (char *arg, int from_tty)
2709 "\"set print raw\" must be followed by the name of a \"print raw\" subcommand.\n");
2710 help_list (setprintrawlist, "set print raw ", -1, gdb_stdout);
2714 show_print_raw (char *args, int from_tty)
2716 cmd_show_list (showprintrawlist, from_tty, "");
2721 _initialize_valprint (void)
2723 add_prefix_cmd ("print", no_class, set_print,
2724 _("Generic command for setting how things print."),
2725 &setprintlist, "set print ", 0, &setlist);
2726 add_alias_cmd ("p", "print", no_class, 1, &setlist);
2727 /* Prefer set print to set prompt. */
2728 add_alias_cmd ("pr", "print", no_class, 1, &setlist);
2730 add_prefix_cmd ("print", no_class, show_print,
2731 _("Generic command for showing print settings."),
2732 &showprintlist, "show print ", 0, &showlist);
2733 add_alias_cmd ("p", "print", no_class, 1, &showlist);
2734 add_alias_cmd ("pr", "print", no_class, 1, &showlist);
2736 add_prefix_cmd ("raw", no_class, set_print_raw,
2738 Generic command for setting what things to print in \"raw\" mode."),
2739 &setprintrawlist, "set print raw ", 0, &setprintlist);
2740 add_prefix_cmd ("raw", no_class, show_print_raw,
2741 _("Generic command for showing \"print raw\" settings."),
2742 &showprintrawlist, "show print raw ", 0, &showprintlist);
2744 add_setshow_uinteger_cmd ("elements", no_class,
2745 &user_print_options.print_max, _("\
2746 Set limit on string chars or array elements to print."), _("\
2747 Show limit on string chars or array elements to print."), _("\
2748 \"set print elements unlimited\" causes there to be no limit."),
2751 &setprintlist, &showprintlist);
2753 add_setshow_boolean_cmd ("null-stop", no_class,
2754 &user_print_options.stop_print_at_null, _("\
2755 Set printing of char arrays to stop at first null char."), _("\
2756 Show printing of char arrays to stop at first null char."), NULL,
2758 show_stop_print_at_null,
2759 &setprintlist, &showprintlist);
2761 add_setshow_uinteger_cmd ("repeats", no_class,
2762 &user_print_options.repeat_count_threshold, _("\
2763 Set threshold for repeated print elements."), _("\
2764 Show threshold for repeated print elements."), _("\
2765 \"set print repeats unlimited\" causes all elements to be individually printed."),
2767 show_repeat_count_threshold,
2768 &setprintlist, &showprintlist);
2770 add_setshow_boolean_cmd ("pretty", class_support,
2771 &user_print_options.prettyformat_structs, _("\
2772 Set pretty formatting of structures."), _("\
2773 Show pretty formatting of structures."), NULL,
2775 show_prettyformat_structs,
2776 &setprintlist, &showprintlist);
2778 add_setshow_boolean_cmd ("union", class_support,
2779 &user_print_options.unionprint, _("\
2780 Set printing of unions interior to structures."), _("\
2781 Show printing of unions interior to structures."), NULL,
2784 &setprintlist, &showprintlist);
2786 add_setshow_boolean_cmd ("array", class_support,
2787 &user_print_options.prettyformat_arrays, _("\
2788 Set pretty formatting of arrays."), _("\
2789 Show pretty formatting of arrays."), NULL,
2791 show_prettyformat_arrays,
2792 &setprintlist, &showprintlist);
2794 add_setshow_boolean_cmd ("address", class_support,
2795 &user_print_options.addressprint, _("\
2796 Set printing of addresses."), _("\
2797 Show printing of addresses."), NULL,
2800 &setprintlist, &showprintlist);
2802 add_setshow_boolean_cmd ("symbol", class_support,
2803 &user_print_options.symbol_print, _("\
2804 Set printing of symbol names when printing pointers."), _("\
2805 Show printing of symbol names when printing pointers."),
2808 &setprintlist, &showprintlist);
2810 add_setshow_zuinteger_cmd ("input-radix", class_support, &input_radix_1,
2812 Set default input radix for entering numbers."), _("\
2813 Show default input radix for entering numbers."), NULL,
2816 &setlist, &showlist);
2818 add_setshow_zuinteger_cmd ("output-radix", class_support, &output_radix_1,
2820 Set default output radix for printing of values."), _("\
2821 Show default output radix for printing of values."), NULL,
2824 &setlist, &showlist);
2826 /* The "set radix" and "show radix" commands are special in that
2827 they are like normal set and show commands but allow two normally
2828 independent variables to be either set or shown with a single
2829 command. So the usual deprecated_add_set_cmd() and [deleted]
2830 add_show_from_set() commands aren't really appropriate. */
2831 /* FIXME: i18n: With the new add_setshow_integer command, that is no
2832 longer true - show can display anything. */
2833 add_cmd ("radix", class_support, set_radix, _("\
2834 Set default input and output number radices.\n\
2835 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
2836 Without an argument, sets both radices back to the default value of 10."),
2838 add_cmd ("radix", class_support, show_radix, _("\
2839 Show the default input and output number radices.\n\
2840 Use 'show input-radix' or 'show output-radix' to independently show each."),
2843 add_setshow_boolean_cmd ("array-indexes", class_support,
2844 &user_print_options.print_array_indexes, _("\
2845 Set printing of array indexes."), _("\
2846 Show printing of array indexes"), NULL, NULL, show_print_array_indexes,
2847 &setprintlist, &showprintlist);