1 /* Print values for GDB, the GNU debugger.
3 Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
4 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
5 2009, 2010, 2011 Free Software Foundation, Inc.
7 This file is part of GDB.
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>. */
23 #include "gdb_string.h"
33 #include "floatformat.h"
35 #include "exceptions.h"
37 #include "python/python.h"
39 #include "gdb_obstack.h"
45 /* Prototypes for local functions */
47 static int partial_memory_read (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
48 int len
, int *errnoptr
);
50 static void show_print (char *, int);
52 static void set_print (char *, int);
54 static void set_radix (char *, int);
56 static void show_radix (char *, int);
58 static void set_input_radix (char *, int, struct cmd_list_element
*);
60 static void set_input_radix_1 (int, unsigned);
62 static void set_output_radix (char *, int, struct cmd_list_element
*);
64 static void set_output_radix_1 (int, unsigned);
66 void _initialize_valprint (void);
68 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
70 struct value_print_options user_print_options
=
72 Val_pretty_default
, /* pretty */
73 0, /* prettyprint_arrays */
74 0, /* prettyprint_structs */
79 PRINT_MAX_DEFAULT
, /* print_max */
80 10, /* repeat_count_threshold */
81 0, /* output_format */
83 0, /* stop_print_at_null */
85 0, /* print_array_indexes */
87 1, /* static_field_print */
88 1, /* pascal_static_field_print */
93 /* Initialize *OPTS to be a copy of the user print options. */
95 get_user_print_options (struct value_print_options
*opts
)
97 *opts
= user_print_options
;
100 /* Initialize *OPTS to be a copy of the user print options, but with
101 pretty-printing disabled. */
103 get_raw_print_options (struct value_print_options
*opts
)
105 *opts
= user_print_options
;
106 opts
->pretty
= Val_no_prettyprint
;
109 /* Initialize *OPTS to be a copy of the user print options, but using
110 FORMAT as the formatting option. */
112 get_formatted_print_options (struct value_print_options
*opts
,
115 *opts
= user_print_options
;
116 opts
->format
= format
;
120 show_print_max (struct ui_file
*file
, int from_tty
,
121 struct cmd_list_element
*c
, const char *value
)
123 fprintf_filtered (file
,
124 _("Limit on string chars or array "
125 "elements to print is %s.\n"),
130 /* Default input and output radixes, and output format letter. */
132 unsigned input_radix
= 10;
134 show_input_radix (struct ui_file
*file
, int from_tty
,
135 struct cmd_list_element
*c
, const char *value
)
137 fprintf_filtered (file
,
138 _("Default input radix for entering numbers is %s.\n"),
142 unsigned output_radix
= 10;
144 show_output_radix (struct ui_file
*file
, int from_tty
,
145 struct cmd_list_element
*c
, const char *value
)
147 fprintf_filtered (file
,
148 _("Default output radix for printing of values is %s.\n"),
152 /* By default we print arrays without printing the index of each element in
153 the array. This behavior can be changed by setting PRINT_ARRAY_INDEXES. */
156 show_print_array_indexes (struct ui_file
*file
, int from_tty
,
157 struct cmd_list_element
*c
, const char *value
)
159 fprintf_filtered (file
, _("Printing of array indexes is %s.\n"), value
);
162 /* Print repeat counts if there are more than this many repetitions of an
163 element in an array. Referenced by the low level language dependent
167 show_repeat_count_threshold (struct ui_file
*file
, int from_tty
,
168 struct cmd_list_element
*c
, const char *value
)
170 fprintf_filtered (file
, _("Threshold for repeated print elements is %s.\n"),
174 /* If nonzero, stops printing of char arrays at first null. */
177 show_stop_print_at_null (struct ui_file
*file
, int from_tty
,
178 struct cmd_list_element
*c
, const char *value
)
180 fprintf_filtered (file
,
181 _("Printing of char arrays to stop "
182 "at first null char is %s.\n"),
186 /* Controls pretty printing of structures. */
189 show_prettyprint_structs (struct ui_file
*file
, int from_tty
,
190 struct cmd_list_element
*c
, const char *value
)
192 fprintf_filtered (file
, _("Prettyprinting of structures is %s.\n"), value
);
195 /* Controls pretty printing of arrays. */
198 show_prettyprint_arrays (struct ui_file
*file
, int from_tty
,
199 struct cmd_list_element
*c
, const char *value
)
201 fprintf_filtered (file
, _("Prettyprinting of arrays is %s.\n"), value
);
204 /* If nonzero, causes unions inside structures or other unions to be
208 show_unionprint (struct ui_file
*file
, int from_tty
,
209 struct cmd_list_element
*c
, const char *value
)
211 fprintf_filtered (file
,
212 _("Printing of unions interior to structures is %s.\n"),
216 /* If nonzero, causes machine addresses to be printed in certain contexts. */
219 show_addressprint (struct ui_file
*file
, int from_tty
,
220 struct cmd_list_element
*c
, const char *value
)
222 fprintf_filtered (file
, _("Printing of addresses is %s.\n"), value
);
226 /* A helper function for val_print. When printing in "summary" mode,
227 we want to print scalar arguments, but not aggregate arguments.
228 This function distinguishes between the two. */
231 scalar_type_p (struct type
*type
)
233 CHECK_TYPEDEF (type
);
234 while (TYPE_CODE (type
) == TYPE_CODE_REF
)
236 type
= TYPE_TARGET_TYPE (type
);
237 CHECK_TYPEDEF (type
);
239 switch (TYPE_CODE (type
))
241 case TYPE_CODE_ARRAY
:
242 case TYPE_CODE_STRUCT
:
243 case TYPE_CODE_UNION
:
245 case TYPE_CODE_STRING
:
246 case TYPE_CODE_BITSTRING
:
253 /* Helper function to check the validity of some bits of a value.
255 If TYPE represents some aggregate type (e.g., a structure), return 1.
257 Otherwise, any of the bytes starting at OFFSET and extending for
258 TYPE_LENGTH(TYPE) bytes are invalid, print a message to STREAM and
259 return 0. The checking is done using FUNCS.
261 Otherwise, return 1. */
264 valprint_check_validity (struct ui_file
*stream
,
267 const struct value
*val
)
269 CHECK_TYPEDEF (type
);
271 if (TYPE_CODE (type
) != TYPE_CODE_UNION
272 && TYPE_CODE (type
) != TYPE_CODE_STRUCT
273 && TYPE_CODE (type
) != TYPE_CODE_ARRAY
)
275 if (!value_bits_valid (val
, TARGET_CHAR_BIT
* embedded_offset
,
276 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
278 val_print_optimized_out (stream
);
282 if (value_bits_synthetic_pointer (val
, TARGET_CHAR_BIT
* embedded_offset
,
283 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
285 fputs_filtered (_("<synthetic pointer>"), stream
);
289 if (!value_bytes_available (val
, embedded_offset
, TYPE_LENGTH (type
)))
291 val_print_unavailable (stream
);
300 val_print_optimized_out (struct ui_file
*stream
)
302 fprintf_filtered (stream
, _("<optimized out>"));
306 val_print_unavailable (struct ui_file
*stream
)
308 fprintf_filtered (stream
, _("<unavailable>"));
312 val_print_invalid_address (struct ui_file
*stream
)
314 fprintf_filtered (stream
, _("<invalid address>"));
317 /* Print using the given LANGUAGE the data of type TYPE located at
318 VALADDR + EMBEDDED_OFFSET (within GDB), which came from the
319 inferior at address ADDRESS + EMBEDDED_OFFSET, onto stdio stream
320 STREAM according to OPTIONS. VAL is the whole object that came
321 from ADDRESS. VALADDR must point to the head of VAL's contents
324 The language printers will pass down an adjusted EMBEDDED_OFFSET to
325 further helper subroutines as subfields of TYPE are printed. In
326 such cases, VALADDR is passed down unadjusted, as well as VAL, so
327 that VAL can be queried for metadata about the contents data being
328 printed, using EMBEDDED_OFFSET as an offset into VAL's contents
329 buffer. For example: "has this field been optimized out", or "I'm
330 printing an object while inspecting a traceframe; has this
331 particular piece of data been collected?".
333 RECURSE indicates the amount of indentation to supply before
334 continuation lines; this amount is roughly twice the value of
337 If the data is printed as a string, returns the number of string
338 characters printed. */
341 val_print (struct type
*type
, const gdb_byte
*valaddr
, int embedded_offset
,
342 CORE_ADDR address
, struct ui_file
*stream
, int recurse
,
343 const struct value
*val
,
344 const struct value_print_options
*options
,
345 const struct language_defn
*language
)
347 volatile struct gdb_exception except
;
349 struct value_print_options local_opts
= *options
;
350 struct type
*real_type
= check_typedef (type
);
352 if (local_opts
.pretty
== Val_pretty_default
)
353 local_opts
.pretty
= (local_opts
.prettyprint_structs
354 ? Val_prettyprint
: Val_no_prettyprint
);
358 /* Ensure that the type is complete and not just a stub. If the type is
359 only a stub and we can't find and substitute its complete type, then
360 print appropriate string and return. */
362 if (TYPE_STUB (real_type
))
364 fprintf_filtered (stream
, _("<incomplete type>"));
369 if (!valprint_check_validity (stream
, real_type
, embedded_offset
, val
))
374 ret
= apply_val_pretty_printer (type
, valaddr
, embedded_offset
,
375 address
, stream
, recurse
,
376 val
, options
, language
);
381 /* Handle summary mode. If the value is a scalar, print it;
382 otherwise, print an ellipsis. */
383 if (options
->summary
&& !scalar_type_p (type
))
385 fprintf_filtered (stream
, "...");
389 TRY_CATCH (except
, RETURN_MASK_ERROR
)
391 ret
= language
->la_val_print (type
, valaddr
, embedded_offset
, address
,
392 stream
, recurse
, val
,
395 if (except
.reason
< 0)
396 fprintf_filtered (stream
, _("<error reading variable>"));
401 /* Check whether the value VAL is printable. Return 1 if it is;
402 return 0 and print an appropriate error message to STREAM if it
406 value_check_printable (struct value
*val
, struct ui_file
*stream
)
410 fprintf_filtered (stream
, _("<address of value unknown>"));
414 if (value_entirely_optimized_out (val
))
416 val_print_optimized_out (stream
);
420 if (TYPE_CODE (value_type (val
)) == TYPE_CODE_INTERNAL_FUNCTION
)
422 fprintf_filtered (stream
, _("<internal function %s>"),
423 value_internal_function_name (val
));
430 /* Print using the given LANGUAGE the value VAL onto stream STREAM according
433 If the data are a string pointer, returns the number of string characters
436 This is a preferable interface to val_print, above, because it uses
437 GDB's value mechanism. */
440 common_val_print (struct value
*val
, struct ui_file
*stream
, int recurse
,
441 const struct value_print_options
*options
,
442 const struct language_defn
*language
)
444 if (!value_check_printable (val
, stream
))
447 if (language
->la_language
== language_ada
)
448 /* The value might have a dynamic type, which would cause trouble
449 below when trying to extract the value contents (since the value
450 size is determined from the type size which is unknown). So
451 get a fixed representation of our value. */
452 val
= ada_to_fixed_value (val
);
454 return val_print (value_type (val
), value_contents_for_printing (val
),
455 value_embedded_offset (val
), value_address (val
),
457 val
, options
, language
);
460 /* Print on stream STREAM the value VAL according to OPTIONS. The value
461 is printed using the current_language syntax.
463 If the object printed is a string pointer, return the number of string
467 value_print (struct value
*val
, struct ui_file
*stream
,
468 const struct value_print_options
*options
)
470 if (!value_check_printable (val
, stream
))
475 int r
= apply_val_pretty_printer (value_type (val
),
476 value_contents_for_printing (val
),
477 value_embedded_offset (val
),
480 val
, options
, current_language
);
486 return LA_VALUE_PRINT (val
, stream
, options
);
489 /* Called by various <lang>_val_print routines to print
490 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
491 value. STREAM is where to print the value. */
494 val_print_type_code_int (struct type
*type
, const gdb_byte
*valaddr
,
495 struct ui_file
*stream
)
497 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
499 if (TYPE_LENGTH (type
) > sizeof (LONGEST
))
503 if (TYPE_UNSIGNED (type
)
504 && extract_long_unsigned_integer (valaddr
, TYPE_LENGTH (type
),
507 print_longest (stream
, 'u', 0, val
);
511 /* Signed, or we couldn't turn an unsigned value into a
512 LONGEST. For signed values, one could assume two's
513 complement (a reasonable assumption, I think) and do
515 print_hex_chars (stream
, (unsigned char *) valaddr
,
516 TYPE_LENGTH (type
), byte_order
);
521 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0,
522 unpack_long (type
, valaddr
));
527 val_print_type_code_flags (struct type
*type
, const gdb_byte
*valaddr
,
528 struct ui_file
*stream
)
530 ULONGEST val
= unpack_long (type
, valaddr
);
531 int bitpos
, nfields
= TYPE_NFIELDS (type
);
533 fputs_filtered ("[ ", stream
);
534 for (bitpos
= 0; bitpos
< nfields
; bitpos
++)
536 if (TYPE_FIELD_BITPOS (type
, bitpos
) != -1
537 && (val
& ((ULONGEST
)1 << bitpos
)))
539 if (TYPE_FIELD_NAME (type
, bitpos
))
540 fprintf_filtered (stream
, "%s ", TYPE_FIELD_NAME (type
, bitpos
));
542 fprintf_filtered (stream
, "#%d ", bitpos
);
545 fputs_filtered ("]", stream
);
547 /* Print a scalar of data of type TYPE, pointed to in GDB by VALADDR,
548 according to OPTIONS and SIZE on STREAM. Format i is not supported
551 This is how the elements of an array or structure are printed
556 val_print_scalar_formatted (struct type
*type
,
557 const gdb_byte
*valaddr
, int embedded_offset
,
558 const struct value
*val
,
559 const struct value_print_options
*options
,
561 struct ui_file
*stream
)
563 gdb_assert (val
!= NULL
);
564 gdb_assert (valaddr
== value_contents_for_printing_const (val
));
566 /* If we get here with a string format, try again without it. Go
567 all the way back to the language printers, which may call us
569 if (options
->format
== 's')
571 struct value_print_options opts
= *options
;
574 val_print (type
, valaddr
, embedded_offset
, 0, stream
, 0, val
, &opts
,
579 /* A scalar object that does not have all bits available can't be
580 printed, because all bits contribute to its representation. */
581 if (!value_bits_valid (val
, TARGET_CHAR_BIT
* embedded_offset
,
582 TARGET_CHAR_BIT
* TYPE_LENGTH (type
)))
583 val_print_optimized_out (stream
);
584 else if (!value_bytes_available (val
, embedded_offset
, TYPE_LENGTH (type
)))
585 val_print_unavailable (stream
);
587 print_scalar_formatted (valaddr
+ embedded_offset
, type
,
588 options
, size
, stream
);
591 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
592 The raison d'etre of this function is to consolidate printing of
593 LONG_LONG's into this one function. The format chars b,h,w,g are
594 from print_scalar_formatted(). Numbers are printed using C
597 USE_C_FORMAT means to use C format in all cases. Without it,
598 'o' and 'x' format do not include the standard C radix prefix
601 Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
602 and was intended to request formating according to the current
603 language and would be used for most integers that GDB prints. The
604 exceptional cases were things like protocols where the format of
605 the integer is a protocol thing, not a user-visible thing). The
606 parameter remains to preserve the information of what things might
607 be printed with language-specific format, should we ever resurrect
611 print_longest (struct ui_file
*stream
, int format
, int use_c_format
,
619 val
= int_string (val_long
, 10, 1, 0, 1); break;
621 val
= int_string (val_long
, 10, 0, 0, 1); break;
623 val
= int_string (val_long
, 16, 0, 0, use_c_format
); break;
625 val
= int_string (val_long
, 16, 0, 2, 1); break;
627 val
= int_string (val_long
, 16, 0, 4, 1); break;
629 val
= int_string (val_long
, 16, 0, 8, 1); break;
631 val
= int_string (val_long
, 16, 0, 16, 1); break;
634 val
= int_string (val_long
, 8, 0, 0, use_c_format
); break;
636 internal_error (__FILE__
, __LINE__
,
637 _("failed internal consistency check"));
639 fputs_filtered (val
, stream
);
642 /* This used to be a macro, but I don't think it is called often enough
643 to merit such treatment. */
644 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
645 arguments to a function, number in a value history, register number, etc.)
646 where the value must not be larger than can fit in an int. */
649 longest_to_int (LONGEST arg
)
651 /* Let the compiler do the work. */
652 int rtnval
= (int) arg
;
654 /* Check for overflows or underflows. */
655 if (sizeof (LONGEST
) > sizeof (int))
659 error (_("Value out of range."));
665 /* Print a floating point value of type TYPE (not always a
666 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
669 print_floating (const gdb_byte
*valaddr
, struct type
*type
,
670 struct ui_file
*stream
)
674 const struct floatformat
*fmt
= NULL
;
675 unsigned len
= TYPE_LENGTH (type
);
676 enum float_kind kind
;
678 /* If it is a floating-point, check for obvious problems. */
679 if (TYPE_CODE (type
) == TYPE_CODE_FLT
)
680 fmt
= floatformat_from_type (type
);
683 kind
= floatformat_classify (fmt
, valaddr
);
684 if (kind
== float_nan
)
686 if (floatformat_is_negative (fmt
, valaddr
))
687 fprintf_filtered (stream
, "-");
688 fprintf_filtered (stream
, "nan(");
689 fputs_filtered ("0x", stream
);
690 fputs_filtered (floatformat_mantissa (fmt
, valaddr
), stream
);
691 fprintf_filtered (stream
, ")");
694 else if (kind
== float_infinite
)
696 if (floatformat_is_negative (fmt
, valaddr
))
697 fputs_filtered ("-", stream
);
698 fputs_filtered ("inf", stream
);
703 /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
704 isn't necessarily a TYPE_CODE_FLT. Consequently, unpack_double
705 needs to be used as that takes care of any necessary type
706 conversions. Such conversions are of course direct to DOUBLEST
707 and disregard any possible target floating point limitations.
708 For instance, a u64 would be converted and displayed exactly on a
709 host with 80 bit DOUBLEST but with loss of information on a host
710 with 64 bit DOUBLEST. */
712 doub
= unpack_double (type
, valaddr
, &inv
);
715 fprintf_filtered (stream
, "<invalid float value>");
719 /* FIXME: kettenis/2001-01-20: The following code makes too much
720 assumptions about the host and target floating point format. */
722 /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
723 not necessarily be a TYPE_CODE_FLT, the below ignores that and
724 instead uses the type's length to determine the precision of the
725 floating-point value being printed. */
727 if (len
< sizeof (double))
728 fprintf_filtered (stream
, "%.9g", (double) doub
);
729 else if (len
== sizeof (double))
730 fprintf_filtered (stream
, "%.17g", (double) doub
);
732 #ifdef PRINTF_HAS_LONG_DOUBLE
733 fprintf_filtered (stream
, "%.35Lg", doub
);
735 /* This at least wins with values that are representable as
737 fprintf_filtered (stream
, "%.17g", (double) doub
);
742 print_decimal_floating (const gdb_byte
*valaddr
, struct type
*type
,
743 struct ui_file
*stream
)
745 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
746 char decstr
[MAX_DECIMAL_STRING
];
747 unsigned len
= TYPE_LENGTH (type
);
749 decimal_to_string (valaddr
, len
, byte_order
, decstr
);
750 fputs_filtered (decstr
, stream
);
755 print_binary_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
756 unsigned len
, enum bfd_endian byte_order
)
759 #define BITS_IN_BYTES 8
765 /* Declared "int" so it will be signed.
766 This ensures that right shift will shift in zeros. */
768 const int mask
= 0x080;
770 /* FIXME: We should be not printing leading zeroes in most cases. */
772 if (byte_order
== BFD_ENDIAN_BIG
)
778 /* Every byte has 8 binary characters; peel off
779 and print from the MSB end. */
781 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
783 if (*p
& (mask
>> i
))
788 fprintf_filtered (stream
, "%1d", b
);
794 for (p
= valaddr
+ len
- 1;
798 for (i
= 0; i
< (BITS_IN_BYTES
* sizeof (*p
)); i
++)
800 if (*p
& (mask
>> i
))
805 fprintf_filtered (stream
, "%1d", b
);
811 /* VALADDR points to an integer of LEN bytes.
812 Print it in octal on stream or format it in buf. */
815 print_octal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
816 unsigned len
, enum bfd_endian byte_order
)
819 unsigned char octa1
, octa2
, octa3
, carry
;
822 /* FIXME: We should be not printing leading zeroes in most cases. */
825 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
826 * the extra bits, which cycle every three bytes:
830 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
832 * Octal side: 0 1 carry 3 4 carry ...
834 * Cycle number: 0 1 2
836 * But of course we are printing from the high side, so we have to
837 * figure out where in the cycle we are so that we end up with no
838 * left over bits at the end.
840 #define BITS_IN_OCTAL 3
841 #define HIGH_ZERO 0340
842 #define LOW_ZERO 0016
843 #define CARRY_ZERO 0003
844 #define HIGH_ONE 0200
847 #define CARRY_ONE 0001
848 #define HIGH_TWO 0300
852 /* For 32 we start in cycle 2, with two bits and one bit carry;
853 for 64 in cycle in cycle 1, with one bit and a two bit carry. */
855 cycle
= (len
* BITS_IN_BYTES
) % BITS_IN_OCTAL
;
858 fputs_filtered ("0", stream
);
859 if (byte_order
== BFD_ENDIAN_BIG
)
868 /* No carry in, carry out two bits. */
870 octa1
= (HIGH_ZERO
& *p
) >> 5;
871 octa2
= (LOW_ZERO
& *p
) >> 2;
872 carry
= (CARRY_ZERO
& *p
);
873 fprintf_filtered (stream
, "%o", octa1
);
874 fprintf_filtered (stream
, "%o", octa2
);
878 /* Carry in two bits, carry out one bit. */
880 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
881 octa2
= (MID_ONE
& *p
) >> 4;
882 octa3
= (LOW_ONE
& *p
) >> 1;
883 carry
= (CARRY_ONE
& *p
);
884 fprintf_filtered (stream
, "%o", octa1
);
885 fprintf_filtered (stream
, "%o", octa2
);
886 fprintf_filtered (stream
, "%o", octa3
);
890 /* Carry in one bit, no carry out. */
892 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
893 octa2
= (MID_TWO
& *p
) >> 3;
894 octa3
= (LOW_TWO
& *p
);
896 fprintf_filtered (stream
, "%o", octa1
);
897 fprintf_filtered (stream
, "%o", octa2
);
898 fprintf_filtered (stream
, "%o", octa3
);
902 error (_("Internal error in octal conversion;"));
906 cycle
= cycle
% BITS_IN_OCTAL
;
911 for (p
= valaddr
+ len
- 1;
918 /* Carry out, no carry in */
920 octa1
= (HIGH_ZERO
& *p
) >> 5;
921 octa2
= (LOW_ZERO
& *p
) >> 2;
922 carry
= (CARRY_ZERO
& *p
);
923 fprintf_filtered (stream
, "%o", octa1
);
924 fprintf_filtered (stream
, "%o", octa2
);
928 /* Carry in, carry out */
930 octa1
= (carry
<< 1) | ((HIGH_ONE
& *p
) >> 7);
931 octa2
= (MID_ONE
& *p
) >> 4;
932 octa3
= (LOW_ONE
& *p
) >> 1;
933 carry
= (CARRY_ONE
& *p
);
934 fprintf_filtered (stream
, "%o", octa1
);
935 fprintf_filtered (stream
, "%o", octa2
);
936 fprintf_filtered (stream
, "%o", octa3
);
940 /* Carry in, no carry out */
942 octa1
= (carry
<< 2) | ((HIGH_TWO
& *p
) >> 6);
943 octa2
= (MID_TWO
& *p
) >> 3;
944 octa3
= (LOW_TWO
& *p
);
946 fprintf_filtered (stream
, "%o", octa1
);
947 fprintf_filtered (stream
, "%o", octa2
);
948 fprintf_filtered (stream
, "%o", octa3
);
952 error (_("Internal error in octal conversion;"));
956 cycle
= cycle
% BITS_IN_OCTAL
;
962 /* VALADDR points to an integer of LEN bytes.
963 Print it in decimal on stream or format it in buf. */
966 print_decimal_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
967 unsigned len
, enum bfd_endian byte_order
)
970 #define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
971 #define CARRY_LEFT( x ) ((x) % TEN)
972 #define SHIFT( x ) ((x) << 4)
973 #define LOW_NIBBLE( x ) ( (x) & 0x00F)
974 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
977 unsigned char *digits
;
980 int i
, j
, decimal_digits
;
984 /* Base-ten number is less than twice as many digits
985 as the base 16 number, which is 2 digits per byte. */
987 decimal_len
= len
* 2 * 2;
988 digits
= xmalloc (decimal_len
);
990 for (i
= 0; i
< decimal_len
; i
++)
995 /* Ok, we have an unknown number of bytes of data to be printed in
998 * Given a hex number (in nibbles) as XYZ, we start by taking X and
999 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
1000 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
1002 * The trick is that "digits" holds a base-10 number, but sometimes
1003 * the individual digits are > 10.
1005 * Outer loop is per nibble (hex digit) of input, from MSD end to
1008 decimal_digits
= 0; /* Number of decimal digits so far */
1009 p
= (byte_order
== BFD_ENDIAN_BIG
) ? valaddr
: valaddr
+ len
- 1;
1011 while ((byte_order
== BFD_ENDIAN_BIG
) ? (p
< valaddr
+ len
) : (p
>= valaddr
))
1014 * Multiply current base-ten number by 16 in place.
1015 * Each digit was between 0 and 9, now is between
1018 for (j
= 0; j
< decimal_digits
; j
++)
1020 digits
[j
] = SHIFT (digits
[j
]);
1023 /* Take the next nibble off the input and add it to what
1024 * we've got in the LSB position. Bottom 'digit' is now
1025 * between 0 and 159.
1027 * "flip" is used to run this loop twice for each byte.
1031 /* Take top nibble. */
1033 digits
[0] += HIGH_NIBBLE (*p
);
1038 /* Take low nibble and bump our pointer "p". */
1040 digits
[0] += LOW_NIBBLE (*p
);
1041 if (byte_order
== BFD_ENDIAN_BIG
)
1048 /* Re-decimalize. We have to do this often enough
1049 * that we don't overflow, but once per nibble is
1050 * overkill. Easier this way, though. Note that the
1051 * carry is often larger than 10 (e.g. max initial
1052 * carry out of lowest nibble is 15, could bubble all
1053 * the way up greater than 10). So we have to do
1054 * the carrying beyond the last current digit.
1057 for (j
= 0; j
< decimal_len
- 1; j
++)
1061 /* "/" won't handle an unsigned char with
1062 * a value that if signed would be negative.
1063 * So extend to longword int via "dummy".
1066 carry
= CARRY_OUT (dummy
);
1067 digits
[j
] = CARRY_LEFT (dummy
);
1069 if (j
>= decimal_digits
&& carry
== 0)
1072 * All higher digits are 0 and we
1073 * no longer have a carry.
1075 * Note: "j" is 0-based, "decimal_digits" is
1078 decimal_digits
= j
+ 1;
1084 /* Ok, now "digits" is the decimal representation, with
1085 the "decimal_digits" actual digits. Print! */
1087 for (i
= decimal_digits
- 1; i
>= 0; i
--)
1089 fprintf_filtered (stream
, "%1d", digits
[i
]);
1094 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
1097 print_hex_chars (struct ui_file
*stream
, const gdb_byte
*valaddr
,
1098 unsigned len
, enum bfd_endian byte_order
)
1102 /* FIXME: We should be not printing leading zeroes in most cases. */
1104 fputs_filtered ("0x", stream
);
1105 if (byte_order
== BFD_ENDIAN_BIG
)
1111 fprintf_filtered (stream
, "%02x", *p
);
1116 for (p
= valaddr
+ len
- 1;
1120 fprintf_filtered (stream
, "%02x", *p
);
1125 /* VALADDR points to a char integer of LEN bytes.
1126 Print it out in appropriate language form on stream.
1127 Omit any leading zero chars. */
1130 print_char_chars (struct ui_file
*stream
, struct type
*type
,
1131 const gdb_byte
*valaddr
,
1132 unsigned len
, enum bfd_endian byte_order
)
1136 if (byte_order
== BFD_ENDIAN_BIG
)
1139 while (p
< valaddr
+ len
- 1 && *p
== 0)
1142 while (p
< valaddr
+ len
)
1144 LA_EMIT_CHAR (*p
, type
, stream
, '\'');
1150 p
= valaddr
+ len
- 1;
1151 while (p
> valaddr
&& *p
== 0)
1154 while (p
>= valaddr
)
1156 LA_EMIT_CHAR (*p
, type
, stream
, '\'');
1162 /* Print on STREAM using the given OPTIONS the index for the element
1163 at INDEX of an array whose index type is INDEX_TYPE. */
1166 maybe_print_array_index (struct type
*index_type
, LONGEST index
,
1167 struct ui_file
*stream
,
1168 const struct value_print_options
*options
)
1170 struct value
*index_value
;
1172 if (!options
->print_array_indexes
)
1175 index_value
= value_from_longest (index_type
, index
);
1177 LA_PRINT_ARRAY_INDEX (index_value
, stream
, options
);
1180 /* Called by various <lang>_val_print routines to print elements of an
1181 array in the form "<elem1>, <elem2>, <elem3>, ...".
1183 (FIXME?) Assumes array element separator is a comma, which is correct
1184 for all languages currently handled.
1185 (FIXME?) Some languages have a notation for repeated array elements,
1186 perhaps we should try to use that notation when appropriate. */
1189 val_print_array_elements (struct type
*type
,
1190 const gdb_byte
*valaddr
, int embedded_offset
,
1191 CORE_ADDR address
, struct ui_file
*stream
,
1193 const struct value
*val
,
1194 const struct value_print_options
*options
,
1197 unsigned int things_printed
= 0;
1199 struct type
*elttype
, *index_type
;
1201 /* Position of the array element we are examining to see
1202 whether it is repeated. */
1204 /* Number of repetitions we have detected so far. */
1206 LONGEST low_bound
, high_bound
;
1208 elttype
= TYPE_TARGET_TYPE (type
);
1209 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
1210 index_type
= TYPE_INDEX_TYPE (type
);
1212 if (get_array_bounds (type
, &low_bound
, &high_bound
))
1214 /* The array length should normally be HIGH_BOUND - LOW_BOUND + 1.
1215 But we have to be a little extra careful, because some languages
1216 such as Ada allow LOW_BOUND to be greater than HIGH_BOUND for
1217 empty arrays. In that situation, the array length is just zero,
1219 if (low_bound
> high_bound
)
1222 len
= high_bound
- low_bound
+ 1;
1226 warning (_("unable to get bounds of array, assuming null array"));
1231 annotate_array_section_begin (i
, elttype
);
1233 for (; i
< len
&& things_printed
< options
->print_max
; i
++)
1237 if (options
->prettyprint_arrays
)
1239 fprintf_filtered (stream
, ",\n");
1240 print_spaces_filtered (2 + 2 * recurse
, stream
);
1244 fprintf_filtered (stream
, ", ");
1247 wrap_here (n_spaces (2 + 2 * recurse
));
1248 maybe_print_array_index (index_type
, i
+ low_bound
,
1253 /* Only check for reps if repeat_count_threshold is not set to
1254 UINT_MAX (unlimited). */
1255 if (options
->repeat_count_threshold
< UINT_MAX
)
1258 && value_available_contents_eq (val
,
1259 embedded_offset
+ i
* eltlen
,
1270 if (reps
> options
->repeat_count_threshold
)
1272 val_print (elttype
, valaddr
, embedded_offset
+ i
* eltlen
,
1273 address
, stream
, recurse
+ 1, val
, options
,
1275 annotate_elt_rep (reps
);
1276 fprintf_filtered (stream
, " <repeats %u times>", reps
);
1277 annotate_elt_rep_end ();
1280 things_printed
+= options
->repeat_count_threshold
;
1284 val_print (elttype
, valaddr
, embedded_offset
+ i
* eltlen
,
1286 stream
, recurse
+ 1, val
, options
, current_language
);
1291 annotate_array_section_end ();
1294 fprintf_filtered (stream
, "...");
1298 /* Read LEN bytes of target memory at address MEMADDR, placing the
1299 results in GDB's memory at MYADDR. Returns a count of the bytes
1300 actually read, and optionally an errno value in the location
1301 pointed to by ERRNOPTR if ERRNOPTR is non-null. */
1303 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
1304 function be eliminated. */
1307 partial_memory_read (CORE_ADDR memaddr
, gdb_byte
*myaddr
,
1308 int len
, int *errnoptr
)
1310 int nread
; /* Number of bytes actually read. */
1311 int errcode
; /* Error from last read. */
1313 /* First try a complete read. */
1314 errcode
= target_read_memory (memaddr
, myaddr
, len
);
1322 /* Loop, reading one byte at a time until we get as much as we can. */
1323 for (errcode
= 0, nread
= 0; len
> 0 && errcode
== 0; nread
++, len
--)
1325 errcode
= target_read_memory (memaddr
++, myaddr
++, 1);
1327 /* If an error, the last read was unsuccessful, so adjust count. */
1333 if (errnoptr
!= NULL
)
1335 *errnoptr
= errcode
;
1340 /* Read a string from the inferior, at ADDR, with LEN characters of WIDTH bytes
1341 each. Fetch at most FETCHLIMIT characters. BUFFER will be set to a newly
1342 allocated buffer containing the string, which the caller is responsible to
1343 free, and BYTES_READ will be set to the number of bytes read. Returns 0 on
1344 success, or errno on failure.
1346 If LEN > 0, reads exactly LEN characters (including eventual NULs in
1347 the middle or end of the string). If LEN is -1, stops at the first
1348 null character (not necessarily the first null byte) up to a maximum
1349 of FETCHLIMIT characters. Set FETCHLIMIT to UINT_MAX to read as many
1350 characters as possible from the string.
1352 Unless an exception is thrown, BUFFER will always be allocated, even on
1353 failure. In this case, some characters might have been read before the
1354 failure happened. Check BYTES_READ to recognize this situation.
1356 Note: There was a FIXME asking to make this code use target_read_string,
1357 but this function is more general (can read past null characters, up to
1358 given LEN). Besides, it is used much more often than target_read_string
1359 so it is more tested. Perhaps callers of target_read_string should use
1360 this function instead? */
1363 read_string (CORE_ADDR addr
, int len
, int width
, unsigned int fetchlimit
,
1364 enum bfd_endian byte_order
, gdb_byte
**buffer
, int *bytes_read
)
1366 int found_nul
; /* Non-zero if we found the nul char. */
1367 int errcode
; /* Errno returned from bad reads. */
1368 unsigned int nfetch
; /* Chars to fetch / chars fetched. */
1369 unsigned int chunksize
; /* Size of each fetch, in chars. */
1370 gdb_byte
*bufptr
; /* Pointer to next available byte in
1372 gdb_byte
*limit
; /* First location past end of fetch buffer. */
1373 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
1375 /* Decide how large of chunks to try to read in one operation. This
1376 is also pretty simple. If LEN >= zero, then we want fetchlimit chars,
1377 so we might as well read them all in one operation. If LEN is -1, we
1378 are looking for a NUL terminator to end the fetching, so we might as
1379 well read in blocks that are large enough to be efficient, but not so
1380 large as to be slow if fetchlimit happens to be large. So we choose the
1381 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
1382 200 is way too big for remote debugging over a serial line. */
1384 chunksize
= (len
== -1 ? min (8, fetchlimit
) : fetchlimit
);
1386 /* Loop until we either have all the characters, or we encounter
1387 some error, such as bumping into the end of the address space. */
1392 old_chain
= make_cleanup (free_current_contents
, buffer
);
1396 *buffer
= (gdb_byte
*) xmalloc (len
* width
);
1399 nfetch
= partial_memory_read (addr
, bufptr
, len
* width
, &errcode
)
1401 addr
+= nfetch
* width
;
1402 bufptr
+= nfetch
* width
;
1406 unsigned long bufsize
= 0;
1411 nfetch
= min (chunksize
, fetchlimit
- bufsize
);
1413 if (*buffer
== NULL
)
1414 *buffer
= (gdb_byte
*) xmalloc (nfetch
* width
);
1416 *buffer
= (gdb_byte
*) xrealloc (*buffer
,
1417 (nfetch
+ bufsize
) * width
);
1419 bufptr
= *buffer
+ bufsize
* width
;
1422 /* Read as much as we can. */
1423 nfetch
= partial_memory_read (addr
, bufptr
, nfetch
* width
, &errcode
)
1426 /* Scan this chunk for the null character that terminates the string
1427 to print. If found, we don't need to fetch any more. Note
1428 that bufptr is explicitly left pointing at the next character
1429 after the null character, or at the next character after the end
1432 limit
= bufptr
+ nfetch
* width
;
1433 while (bufptr
< limit
)
1437 c
= extract_unsigned_integer (bufptr
, width
, byte_order
);
1442 /* We don't care about any error which happened after
1443 the NUL terminator. */
1450 while (errcode
== 0 /* no error */
1451 && bufptr
- *buffer
< fetchlimit
* width
/* no overrun */
1452 && !found_nul
); /* haven't found NUL yet */
1455 { /* Length of string is really 0! */
1456 /* We always allocate *buffer. */
1457 *buffer
= bufptr
= xmalloc (1);
1461 /* bufptr and addr now point immediately beyond the last byte which we
1462 consider part of the string (including a '\0' which ends the string). */
1463 *bytes_read
= bufptr
- *buffer
;
1467 discard_cleanups (old_chain
);
1472 /* Return true if print_wchar can display W without resorting to a
1473 numeric escape, false otherwise. */
1476 wchar_printable (gdb_wchar_t w
)
1478 return (gdb_iswprint (w
)
1479 || w
== LCST ('\a') || w
== LCST ('\b')
1480 || w
== LCST ('\f') || w
== LCST ('\n')
1481 || w
== LCST ('\r') || w
== LCST ('\t')
1482 || w
== LCST ('\v'));
1485 /* A helper function that converts the contents of STRING to wide
1486 characters and then appends them to OUTPUT. */
1489 append_string_as_wide (const char *string
,
1490 struct obstack
*output
)
1492 for (; *string
; ++string
)
1494 gdb_wchar_t w
= gdb_btowc (*string
);
1495 obstack_grow (output
, &w
, sizeof (gdb_wchar_t
));
1499 /* Print a wide character W to OUTPUT. ORIG is a pointer to the
1500 original (target) bytes representing the character, ORIG_LEN is the
1501 number of valid bytes. WIDTH is the number of bytes in a base
1502 characters of the type. OUTPUT is an obstack to which wide
1503 characters are emitted. QUOTER is a (narrow) character indicating
1504 the style of quotes surrounding the character to be printed.
1505 NEED_ESCAPE is an in/out flag which is used to track numeric
1506 escapes across calls. */
1509 print_wchar (gdb_wint_t w
, const gdb_byte
*orig
,
1510 int orig_len
, int width
,
1511 enum bfd_endian byte_order
,
1512 struct obstack
*output
,
1513 int quoter
, int *need_escapep
)
1515 int need_escape
= *need_escapep
;
1518 if (gdb_iswprint (w
) && (!need_escape
|| (!gdb_iswdigit (w
)
1520 && w
!= LCST ('9'))))
1522 gdb_wchar_t wchar
= w
;
1524 if (w
== gdb_btowc (quoter
) || w
== LCST ('\\'))
1525 obstack_grow_wstr (output
, LCST ("\\"));
1526 obstack_grow (output
, &wchar
, sizeof (gdb_wchar_t
));
1533 obstack_grow_wstr (output
, LCST ("\\a"));
1536 obstack_grow_wstr (output
, LCST ("\\b"));
1539 obstack_grow_wstr (output
, LCST ("\\f"));
1542 obstack_grow_wstr (output
, LCST ("\\n"));
1545 obstack_grow_wstr (output
, LCST ("\\r"));
1548 obstack_grow_wstr (output
, LCST ("\\t"));
1551 obstack_grow_wstr (output
, LCST ("\\v"));
1557 for (i
= 0; i
+ width
<= orig_len
; i
+= width
)
1562 value
= extract_unsigned_integer (&orig
[i
], width
,
1564 /* If the value fits in 3 octal digits, print it that
1565 way. Otherwise, print it as a hex escape. */
1567 sprintf (octal
, "\\%.3o", (int) (value
& 0777));
1569 sprintf (octal
, "\\x%lx", (long) value
);
1570 append_string_as_wide (octal
, output
);
1572 /* If we somehow have extra bytes, print them now. */
1573 while (i
< orig_len
)
1577 sprintf (octal
, "\\%.3o", orig
[i
] & 0xff);
1578 append_string_as_wide (octal
, output
);
1589 /* Print the character C on STREAM as part of the contents of a
1590 literal string whose delimiter is QUOTER. ENCODING names the
1594 generic_emit_char (int c
, struct type
*type
, struct ui_file
*stream
,
1595 int quoter
, const char *encoding
)
1597 enum bfd_endian byte_order
1598 = gdbarch_byte_order (get_type_arch (type
));
1599 struct obstack wchar_buf
, output
;
1600 struct cleanup
*cleanups
;
1602 struct wchar_iterator
*iter
;
1603 int need_escape
= 0;
1605 buf
= alloca (TYPE_LENGTH (type
));
1606 pack_long (buf
, type
, c
);
1608 iter
= make_wchar_iterator (buf
, TYPE_LENGTH (type
),
1609 encoding
, TYPE_LENGTH (type
));
1610 cleanups
= make_cleanup_wchar_iterator (iter
);
1612 /* This holds the printable form of the wchar_t data. */
1613 obstack_init (&wchar_buf
);
1614 make_cleanup_obstack_free (&wchar_buf
);
1620 const gdb_byte
*buf
;
1622 int print_escape
= 1;
1623 enum wchar_iterate_result result
;
1625 num_chars
= wchar_iterate (iter
, &result
, &chars
, &buf
, &buflen
);
1630 /* If all characters are printable, print them. Otherwise,
1631 we're going to have to print an escape sequence. We
1632 check all characters because we want to print the target
1633 bytes in the escape sequence, and we don't know character
1634 boundaries there. */
1638 for (i
= 0; i
< num_chars
; ++i
)
1639 if (!wchar_printable (chars
[i
]))
1647 for (i
= 0; i
< num_chars
; ++i
)
1648 print_wchar (chars
[i
], buf
, buflen
,
1649 TYPE_LENGTH (type
), byte_order
,
1650 &wchar_buf
, quoter
, &need_escape
);
1654 /* This handles the NUM_CHARS == 0 case as well. */
1656 print_wchar (gdb_WEOF
, buf
, buflen
, TYPE_LENGTH (type
),
1657 byte_order
, &wchar_buf
, quoter
, &need_escape
);
1660 /* The output in the host encoding. */
1661 obstack_init (&output
);
1662 make_cleanup_obstack_free (&output
);
1664 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
1665 obstack_base (&wchar_buf
),
1666 obstack_object_size (&wchar_buf
),
1667 1, &output
, translit_char
);
1668 obstack_1grow (&output
, '\0');
1670 fputs_filtered (obstack_base (&output
), stream
);
1672 do_cleanups (cleanups
);
1675 /* Print the character string STRING, printing at most LENGTH
1676 characters. LENGTH is -1 if the string is nul terminated. TYPE is
1677 the type of each character. OPTIONS holds the printing options;
1678 printing stops early if the number hits print_max; repeat counts
1679 are printed as appropriate. Print ellipses at the end if we had to
1680 stop before printing LENGTH characters, or if FORCE_ELLIPSES.
1681 QUOTE_CHAR is the character to print at each end of the string. If
1682 C_STYLE_TERMINATOR is true, and the last character is 0, then it is
1686 generic_printstr (struct ui_file
*stream
, struct type
*type
,
1687 const gdb_byte
*string
, unsigned int length
,
1688 const char *encoding
, int force_ellipses
,
1689 int quote_char
, int c_style_terminator
,
1690 const struct value_print_options
*options
)
1692 enum bfd_endian byte_order
= gdbarch_byte_order (get_type_arch (type
));
1694 unsigned int things_printed
= 0;
1697 int width
= TYPE_LENGTH (type
);
1698 struct obstack wchar_buf
, output
;
1699 struct cleanup
*cleanup
;
1700 struct wchar_iterator
*iter
;
1702 int need_escape
= 0;
1703 gdb_wchar_t wide_quote_char
= gdb_btowc (quote_char
);
1707 unsigned long current_char
= 1;
1709 for (i
= 0; current_char
; ++i
)
1712 current_char
= extract_unsigned_integer (string
+ i
* width
,
1718 /* If the string was not truncated due to `set print elements', and
1719 the last byte of it is a null, we don't print that, in
1720 traditional C style. */
1721 if (c_style_terminator
1724 && (extract_unsigned_integer (string
+ (length
- 1) * width
,
1725 width
, byte_order
) == 0))
1730 fputs_filtered ("\"\"", stream
);
1734 /* Arrange to iterate over the characters, in wchar_t form. */
1735 iter
= make_wchar_iterator (string
, length
* width
, encoding
, width
);
1736 cleanup
= make_cleanup_wchar_iterator (iter
);
1738 /* WCHAR_BUF is the obstack we use to represent the string in
1740 obstack_init (&wchar_buf
);
1741 make_cleanup_obstack_free (&wchar_buf
);
1743 while (!finished
&& things_printed
< options
->print_max
)
1746 enum wchar_iterate_result result
;
1748 const gdb_byte
*buf
;
1755 obstack_grow_wstr (&wchar_buf
, LCST (", "));
1759 num_chars
= wchar_iterate (iter
, &result
, &chars
, &buf
, &buflen
);
1760 /* We only look at repetitions when we were able to convert a
1761 single character in isolation. This makes the code simpler
1762 and probably does the sensible thing in the majority of
1764 while (num_chars
== 1 && things_printed
< options
->print_max
)
1766 /* Count the number of repetitions. */
1767 unsigned int reps
= 0;
1768 gdb_wchar_t current_char
= chars
[0];
1769 const gdb_byte
*orig_buf
= buf
;
1770 int orig_len
= buflen
;
1774 obstack_grow_wstr (&wchar_buf
, LCST (", "));
1778 while (num_chars
== 1 && current_char
== chars
[0])
1780 num_chars
= wchar_iterate (iter
, &result
, &chars
,
1785 /* Emit CURRENT_CHAR according to the repetition count and
1787 if (reps
> options
->repeat_count_threshold
)
1791 if (options
->inspect_it
)
1792 obstack_grow_wstr (&wchar_buf
, LCST ("\\"));
1793 obstack_grow (&wchar_buf
, &wide_quote_char
,
1794 sizeof (gdb_wchar_t
));
1795 obstack_grow_wstr (&wchar_buf
, LCST (", "));
1798 obstack_grow_wstr (&wchar_buf
, LCST ("'"));
1800 print_wchar (current_char
, orig_buf
, orig_len
, width
,
1801 byte_order
, &wchar_buf
, '\'', &need_escape
);
1802 obstack_grow_wstr (&wchar_buf
, LCST ("'"));
1804 /* Painful gyrations. */
1806 char *s
= xstrprintf (_(" <repeats %u times>"), reps
);
1808 for (j
= 0; s
[j
]; ++j
)
1810 gdb_wchar_t w
= gdb_btowc (s
[j
]);
1811 obstack_grow (&wchar_buf
, &w
, sizeof (gdb_wchar_t
));
1815 things_printed
+= options
->repeat_count_threshold
;
1820 /* Saw the character one or more times, but fewer than
1821 the repetition threshold. */
1824 if (options
->inspect_it
)
1825 obstack_grow_wstr (&wchar_buf
, LCST ("\\"));
1826 obstack_grow (&wchar_buf
, &wide_quote_char
,
1827 sizeof (gdb_wchar_t
));
1834 print_wchar (current_char
, orig_buf
,
1836 byte_order
, &wchar_buf
,
1837 quote_char
, &need_escape
);
1843 /* NUM_CHARS and the other outputs from wchar_iterate are valid
1844 here regardless of which branch was taken above. */
1854 case wchar_iterate_invalid
:
1857 if (options
->inspect_it
)
1858 obstack_grow_wstr (&wchar_buf
, LCST ("\\"));
1859 obstack_grow (&wchar_buf
, &wide_quote_char
,
1860 sizeof (gdb_wchar_t
));
1864 print_wchar (gdb_WEOF
, buf
, buflen
, width
, byte_order
,
1865 &wchar_buf
, quote_char
, &need_escape
);
1868 case wchar_iterate_incomplete
:
1871 if (options
->inspect_it
)
1872 obstack_grow_wstr (&wchar_buf
, LCST ("\\"));
1873 obstack_grow (&wchar_buf
, &wide_quote_char
,
1874 sizeof (gdb_wchar_t
));
1875 obstack_grow_wstr (&wchar_buf
, LCST (","));
1878 obstack_grow_wstr (&wchar_buf
,
1879 LCST (" <incomplete sequence "));
1880 print_wchar (gdb_WEOF
, buf
, buflen
, width
,
1881 byte_order
, &wchar_buf
,
1883 obstack_grow_wstr (&wchar_buf
, LCST (">"));
1889 /* Terminate the quotes if necessary. */
1892 if (options
->inspect_it
)
1893 obstack_grow_wstr (&wchar_buf
, LCST ("\\"));
1894 obstack_grow (&wchar_buf
, &wide_quote_char
,
1895 sizeof (gdb_wchar_t
));
1898 if (force_ellipses
|| !finished
)
1899 obstack_grow_wstr (&wchar_buf
, LCST ("..."));
1901 /* OUTPUT is where we collect `char's for printing. */
1902 obstack_init (&output
);
1903 make_cleanup_obstack_free (&output
);
1905 convert_between_encodings (INTERMEDIATE_ENCODING
, host_charset (),
1906 obstack_base (&wchar_buf
),
1907 obstack_object_size (&wchar_buf
),
1908 1, &output
, translit_char
);
1909 obstack_1grow (&output
, '\0');
1911 fputs_filtered (obstack_base (&output
), stream
);
1913 do_cleanups (cleanup
);
1916 /* Print a string from the inferior, starting at ADDR and printing up to LEN
1917 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
1918 stops at the first null byte, otherwise printing proceeds (including null
1919 bytes) until either print_max or LEN characters have been printed,
1920 whichever is smaller. ENCODING is the name of the string's
1921 encoding. It can be NULL, in which case the target encoding is
1925 val_print_string (struct type
*elttype
, const char *encoding
,
1926 CORE_ADDR addr
, int len
,
1927 struct ui_file
*stream
,
1928 const struct value_print_options
*options
)
1930 int force_ellipsis
= 0; /* Force ellipsis to be printed if nonzero. */
1931 int errcode
; /* Errno returned from bad reads. */
1932 int found_nul
; /* Non-zero if we found the nul char. */
1933 unsigned int fetchlimit
; /* Maximum number of chars to print. */
1935 gdb_byte
*buffer
= NULL
; /* Dynamically growable fetch buffer. */
1936 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
1937 struct gdbarch
*gdbarch
= get_type_arch (elttype
);
1938 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
1939 int width
= TYPE_LENGTH (elttype
);
1941 /* First we need to figure out the limit on the number of characters we are
1942 going to attempt to fetch and print. This is actually pretty simple. If
1943 LEN >= zero, then the limit is the minimum of LEN and print_max. If
1944 LEN is -1, then the limit is print_max. This is true regardless of
1945 whether print_max is zero, UINT_MAX (unlimited), or something in between,
1946 because finding the null byte (or available memory) is what actually
1947 limits the fetch. */
1949 fetchlimit
= (len
== -1 ? options
->print_max
: min (len
,
1950 options
->print_max
));
1952 errcode
= read_string (addr
, len
, width
, fetchlimit
, byte_order
,
1953 &buffer
, &bytes_read
);
1954 old_chain
= make_cleanup (xfree
, buffer
);
1958 /* We now have either successfully filled the buffer to fetchlimit,
1959 or terminated early due to an error or finding a null char when
1962 /* Determine found_nul by looking at the last character read. */
1963 found_nul
= extract_unsigned_integer (buffer
+ bytes_read
- width
, width
,
1965 if (len
== -1 && !found_nul
)
1969 /* We didn't find a NUL terminator we were looking for. Attempt
1970 to peek at the next character. If not successful, or it is not
1971 a null byte, then force ellipsis to be printed. */
1973 peekbuf
= (gdb_byte
*) alloca (width
);
1975 if (target_read_memory (addr
, peekbuf
, width
) == 0
1976 && extract_unsigned_integer (peekbuf
, width
, byte_order
) != 0)
1979 else if ((len
>= 0 && errcode
!= 0) || (len
> bytes_read
/ width
))
1981 /* Getting an error when we have a requested length, or fetching less
1982 than the number of characters actually requested, always make us
1987 /* If we get an error before fetching anything, don't print a string.
1988 But if we fetch something and then get an error, print the string
1989 and then the error message. */
1990 if (errcode
== 0 || bytes_read
> 0)
1992 if (options
->addressprint
)
1994 fputs_filtered (" ", stream
);
1996 LA_PRINT_STRING (stream
, elttype
, buffer
, bytes_read
/ width
,
1997 encoding
, force_ellipsis
, options
);
2004 fprintf_filtered (stream
, " <Address ");
2005 fputs_filtered (paddress (gdbarch
, addr
), stream
);
2006 fprintf_filtered (stream
, " out of bounds>");
2010 fprintf_filtered (stream
, " <Error reading address ");
2011 fputs_filtered (paddress (gdbarch
, addr
), stream
);
2012 fprintf_filtered (stream
, ": %s>", safe_strerror (errcode
));
2017 do_cleanups (old_chain
);
2019 return (bytes_read
/ width
);
2023 /* The 'set input-radix' command writes to this auxiliary variable.
2024 If the requested radix is valid, INPUT_RADIX is updated; otherwise,
2025 it is left unchanged. */
2027 static unsigned input_radix_1
= 10;
2029 /* Validate an input or output radix setting, and make sure the user
2030 knows what they really did here. Radix setting is confusing, e.g.
2031 setting the input radix to "10" never changes it! */
2034 set_input_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
2036 set_input_radix_1 (from_tty
, input_radix_1
);
2040 set_input_radix_1 (int from_tty
, unsigned radix
)
2042 /* We don't currently disallow any input radix except 0 or 1, which don't
2043 make any mathematical sense. In theory, we can deal with any input
2044 radix greater than 1, even if we don't have unique digits for every
2045 value from 0 to radix-1, but in practice we lose on large radix values.
2046 We should either fix the lossage or restrict the radix range more.
2051 input_radix_1
= input_radix
;
2052 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
2055 input_radix_1
= input_radix
= radix
;
2058 printf_filtered (_("Input radix now set to "
2059 "decimal %u, hex %x, octal %o.\n"),
2060 radix
, radix
, radix
);
2064 /* The 'set output-radix' command writes to this auxiliary variable.
2065 If the requested radix is valid, OUTPUT_RADIX is updated,
2066 otherwise, it is left unchanged. */
2068 static unsigned output_radix_1
= 10;
2071 set_output_radix (char *args
, int from_tty
, struct cmd_list_element
*c
)
2073 set_output_radix_1 (from_tty
, output_radix_1
);
2077 set_output_radix_1 (int from_tty
, unsigned radix
)
2079 /* Validate the radix and disallow ones that we aren't prepared to
2080 handle correctly, leaving the radix unchanged. */
2084 user_print_options
.output_format
= 'x'; /* hex */
2087 user_print_options
.output_format
= 0; /* decimal */
2090 user_print_options
.output_format
= 'o'; /* octal */
2093 output_radix_1
= output_radix
;
2094 error (_("Unsupported output radix ``decimal %u''; "
2095 "output radix unchanged."),
2098 output_radix_1
= output_radix
= radix
;
2101 printf_filtered (_("Output radix now set to "
2102 "decimal %u, hex %x, octal %o.\n"),
2103 radix
, radix
, radix
);
2107 /* Set both the input and output radix at once. Try to set the output radix
2108 first, since it has the most restrictive range. An radix that is valid as
2109 an output radix is also valid as an input radix.
2111 It may be useful to have an unusual input radix. If the user wishes to
2112 set an input radix that is not valid as an output radix, he needs to use
2113 the 'set input-radix' command. */
2116 set_radix (char *arg
, int from_tty
)
2120 radix
= (arg
== NULL
) ? 10 : parse_and_eval_long (arg
);
2121 set_output_radix_1 (0, radix
);
2122 set_input_radix_1 (0, radix
);
2125 printf_filtered (_("Input and output radices now set to "
2126 "decimal %u, hex %x, octal %o.\n"),
2127 radix
, radix
, radix
);
2131 /* Show both the input and output radices. */
2134 show_radix (char *arg
, int from_tty
)
2138 if (input_radix
== output_radix
)
2140 printf_filtered (_("Input and output radices set to "
2141 "decimal %u, hex %x, octal %o.\n"),
2142 input_radix
, input_radix
, input_radix
);
2146 printf_filtered (_("Input radix set to decimal "
2147 "%u, hex %x, octal %o.\n"),
2148 input_radix
, input_radix
, input_radix
);
2149 printf_filtered (_("Output radix set to decimal "
2150 "%u, hex %x, octal %o.\n"),
2151 output_radix
, output_radix
, output_radix
);
2158 set_print (char *arg
, int from_tty
)
2161 "\"set print\" must be followed by the name of a print subcommand.\n");
2162 help_list (setprintlist
, "set print ", -1, gdb_stdout
);
2166 show_print (char *args
, int from_tty
)
2168 cmd_show_list (showprintlist
, from_tty
, "");
2172 _initialize_valprint (void)
2174 add_prefix_cmd ("print", no_class
, set_print
,
2175 _("Generic command for setting how things print."),
2176 &setprintlist
, "set print ", 0, &setlist
);
2177 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
2178 /* Prefer set print to set prompt. */
2179 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
);
2181 add_prefix_cmd ("print", no_class
, show_print
,
2182 _("Generic command for showing print settings."),
2183 &showprintlist
, "show print ", 0, &showlist
);
2184 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
2185 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
2187 add_setshow_uinteger_cmd ("elements", no_class
,
2188 &user_print_options
.print_max
, _("\
2189 Set limit on string chars or array elements to print."), _("\
2190 Show limit on string chars or array elements to print."), _("\
2191 \"set print elements 0\" causes there to be no limit."),
2194 &setprintlist
, &showprintlist
);
2196 add_setshow_boolean_cmd ("null-stop", no_class
,
2197 &user_print_options
.stop_print_at_null
, _("\
2198 Set printing of char arrays to stop at first null char."), _("\
2199 Show printing of char arrays to stop at first null char."), NULL
,
2201 show_stop_print_at_null
,
2202 &setprintlist
, &showprintlist
);
2204 add_setshow_uinteger_cmd ("repeats", no_class
,
2205 &user_print_options
.repeat_count_threshold
, _("\
2206 Set threshold for repeated print elements."), _("\
2207 Show threshold for repeated print elements."), _("\
2208 \"set print repeats 0\" causes all elements to be individually printed."),
2210 show_repeat_count_threshold
,
2211 &setprintlist
, &showprintlist
);
2213 add_setshow_boolean_cmd ("pretty", class_support
,
2214 &user_print_options
.prettyprint_structs
, _("\
2215 Set prettyprinting of structures."), _("\
2216 Show prettyprinting of structures."), NULL
,
2218 show_prettyprint_structs
,
2219 &setprintlist
, &showprintlist
);
2221 add_setshow_boolean_cmd ("union", class_support
,
2222 &user_print_options
.unionprint
, _("\
2223 Set printing of unions interior to structures."), _("\
2224 Show printing of unions interior to structures."), NULL
,
2227 &setprintlist
, &showprintlist
);
2229 add_setshow_boolean_cmd ("array", class_support
,
2230 &user_print_options
.prettyprint_arrays
, _("\
2231 Set prettyprinting of arrays."), _("\
2232 Show prettyprinting of arrays."), NULL
,
2234 show_prettyprint_arrays
,
2235 &setprintlist
, &showprintlist
);
2237 add_setshow_boolean_cmd ("address", class_support
,
2238 &user_print_options
.addressprint
, _("\
2239 Set printing of addresses."), _("\
2240 Show printing of addresses."), NULL
,
2243 &setprintlist
, &showprintlist
);
2245 add_setshow_zuinteger_cmd ("input-radix", class_support
, &input_radix_1
,
2247 Set default input radix for entering numbers."), _("\
2248 Show default input radix for entering numbers."), NULL
,
2251 &setlist
, &showlist
);
2253 add_setshow_zuinteger_cmd ("output-radix", class_support
, &output_radix_1
,
2255 Set default output radix for printing of values."), _("\
2256 Show default output radix for printing of values."), NULL
,
2259 &setlist
, &showlist
);
2261 /* The "set radix" and "show radix" commands are special in that
2262 they are like normal set and show commands but allow two normally
2263 independent variables to be either set or shown with a single
2264 command. So the usual deprecated_add_set_cmd() and [deleted]
2265 add_show_from_set() commands aren't really appropriate. */
2266 /* FIXME: i18n: With the new add_setshow_integer command, that is no
2267 longer true - show can display anything. */
2268 add_cmd ("radix", class_support
, set_radix
, _("\
2269 Set default input and output number radices.\n\
2270 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
2271 Without an argument, sets both radices back to the default value of 10."),
2273 add_cmd ("radix", class_support
, show_radix
, _("\
2274 Show the default input and output number radices.\n\
2275 Use 'show input-radix' or 'show output-radix' to independently show each."),
2278 add_setshow_boolean_cmd ("array-indexes", class_support
,
2279 &user_print_options
.print_array_indexes
, _("\
2280 Set printing of array indexes."), _("\
2281 Show printing of array indexes"), NULL
, NULL
, show_print_array_indexes
,
2282 &setprintlist
, &showprintlist
);