gdb
[deliverable/binutils-gdb.git] / gdb / valprint.c
1 /* Print values for GDB, the GNU debugger.
2
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.
6
7 This file is part of GDB.
8
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.
13
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.
18
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/>. */
21
22 #include "defs.h"
23 #include "gdb_string.h"
24 #include "symtab.h"
25 #include "gdbtypes.h"
26 #include "value.h"
27 #include "gdbcore.h"
28 #include "gdbcmd.h"
29 #include "target.h"
30 #include "language.h"
31 #include "annotate.h"
32 #include "valprint.h"
33 #include "floatformat.h"
34 #include "doublest.h"
35 #include "exceptions.h"
36 #include "dfp.h"
37 #include "python/python.h"
38 #include "ada-lang.h"
39 #include "gdb_obstack.h"
40 #include "charset.h"
41 #include <ctype.h>
42
43 #include <errno.h>
44
45 /* Prototypes for local functions */
46
47 static int partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
48 int len, int *errnoptr);
49
50 static void show_print (char *, int);
51
52 static void set_print (char *, int);
53
54 static void set_radix (char *, int);
55
56 static void show_radix (char *, int);
57
58 static void set_input_radix (char *, int, struct cmd_list_element *);
59
60 static void set_input_radix_1 (int, unsigned);
61
62 static void set_output_radix (char *, int, struct cmd_list_element *);
63
64 static void set_output_radix_1 (int, unsigned);
65
66 void _initialize_valprint (void);
67
68 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
69
70 struct value_print_options user_print_options =
71 {
72 Val_pretty_default, /* pretty */
73 0, /* prettyprint_arrays */
74 0, /* prettyprint_structs */
75 0, /* vtblprint */
76 1, /* unionprint */
77 1, /* addressprint */
78 0, /* objectprint */
79 PRINT_MAX_DEFAULT, /* print_max */
80 10, /* repeat_count_threshold */
81 0, /* output_format */
82 0, /* format */
83 0, /* stop_print_at_null */
84 0, /* inspect_it */
85 0, /* print_array_indexes */
86 0, /* deref_ref */
87 1, /* static_field_print */
88 1, /* pascal_static_field_print */
89 0, /* raw */
90 0 /* summary */
91 };
92
93 /* Initialize *OPTS to be a copy of the user print options. */
94 void
95 get_user_print_options (struct value_print_options *opts)
96 {
97 *opts = user_print_options;
98 }
99
100 /* Initialize *OPTS to be a copy of the user print options, but with
101 pretty-printing disabled. */
102 void
103 get_raw_print_options (struct value_print_options *opts)
104 {
105 *opts = user_print_options;
106 opts->pretty = Val_no_prettyprint;
107 }
108
109 /* Initialize *OPTS to be a copy of the user print options, but using
110 FORMAT as the formatting option. */
111 void
112 get_formatted_print_options (struct value_print_options *opts,
113 char format)
114 {
115 *opts = user_print_options;
116 opts->format = format;
117 }
118
119 static void
120 show_print_max (struct ui_file *file, int from_tty,
121 struct cmd_list_element *c, const char *value)
122 {
123 fprintf_filtered (file,
124 _("Limit on string chars or array "
125 "elements to print is %s.\n"),
126 value);
127 }
128
129
130 /* Default input and output radixes, and output format letter. */
131
132 unsigned input_radix = 10;
133 static void
134 show_input_radix (struct ui_file *file, int from_tty,
135 struct cmd_list_element *c, const char *value)
136 {
137 fprintf_filtered (file,
138 _("Default input radix for entering numbers is %s.\n"),
139 value);
140 }
141
142 unsigned output_radix = 10;
143 static void
144 show_output_radix (struct ui_file *file, int from_tty,
145 struct cmd_list_element *c, const char *value)
146 {
147 fprintf_filtered (file,
148 _("Default output radix for printing of values is %s.\n"),
149 value);
150 }
151
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. */
154
155 static void
156 show_print_array_indexes (struct ui_file *file, int from_tty,
157 struct cmd_list_element *c, const char *value)
158 {
159 fprintf_filtered (file, _("Printing of array indexes is %s.\n"), value);
160 }
161
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
164 print routines. */
165
166 static void
167 show_repeat_count_threshold (struct ui_file *file, int from_tty,
168 struct cmd_list_element *c, const char *value)
169 {
170 fprintf_filtered (file, _("Threshold for repeated print elements is %s.\n"),
171 value);
172 }
173
174 /* If nonzero, stops printing of char arrays at first null. */
175
176 static void
177 show_stop_print_at_null (struct ui_file *file, int from_tty,
178 struct cmd_list_element *c, const char *value)
179 {
180 fprintf_filtered (file,
181 _("Printing of char arrays to stop "
182 "at first null char is %s.\n"),
183 value);
184 }
185
186 /* Controls pretty printing of structures. */
187
188 static void
189 show_prettyprint_structs (struct ui_file *file, int from_tty,
190 struct cmd_list_element *c, const char *value)
191 {
192 fprintf_filtered (file, _("Prettyprinting of structures is %s.\n"), value);
193 }
194
195 /* Controls pretty printing of arrays. */
196
197 static void
198 show_prettyprint_arrays (struct ui_file *file, int from_tty,
199 struct cmd_list_element *c, const char *value)
200 {
201 fprintf_filtered (file, _("Prettyprinting of arrays is %s.\n"), value);
202 }
203
204 /* If nonzero, causes unions inside structures or other unions to be
205 printed. */
206
207 static void
208 show_unionprint (struct ui_file *file, int from_tty,
209 struct cmd_list_element *c, const char *value)
210 {
211 fprintf_filtered (file,
212 _("Printing of unions interior to structures is %s.\n"),
213 value);
214 }
215
216 /* If nonzero, causes machine addresses to be printed in certain contexts. */
217
218 static void
219 show_addressprint (struct ui_file *file, int from_tty,
220 struct cmd_list_element *c, const char *value)
221 {
222 fprintf_filtered (file, _("Printing of addresses is %s.\n"), value);
223 }
224 \f
225
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. */
229
230 static int
231 scalar_type_p (struct type *type)
232 {
233 CHECK_TYPEDEF (type);
234 while (TYPE_CODE (type) == TYPE_CODE_REF)
235 {
236 type = TYPE_TARGET_TYPE (type);
237 CHECK_TYPEDEF (type);
238 }
239 switch (TYPE_CODE (type))
240 {
241 case TYPE_CODE_ARRAY:
242 case TYPE_CODE_STRUCT:
243 case TYPE_CODE_UNION:
244 case TYPE_CODE_SET:
245 case TYPE_CODE_STRING:
246 case TYPE_CODE_BITSTRING:
247 return 0;
248 default:
249 return 1;
250 }
251 }
252
253 /* Helper function to check the validity of some bits of a value.
254
255 If TYPE represents some aggregate type (e.g., a structure), return 1.
256
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.
260
261 Otherwise, return 1. */
262
263 static int
264 valprint_check_validity (struct ui_file *stream,
265 struct type *type,
266 int embedded_offset,
267 const struct value *val)
268 {
269 CHECK_TYPEDEF (type);
270
271 if (TYPE_CODE (type) != TYPE_CODE_UNION
272 && TYPE_CODE (type) != TYPE_CODE_STRUCT
273 && TYPE_CODE (type) != TYPE_CODE_ARRAY)
274 {
275 if (!value_bits_valid (val, TARGET_CHAR_BIT * embedded_offset,
276 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
277 {
278 val_print_optimized_out (stream);
279 return 0;
280 }
281
282 if (value_bits_synthetic_pointer (val, TARGET_CHAR_BIT * embedded_offset,
283 TARGET_CHAR_BIT * TYPE_LENGTH (type)))
284 {
285 fputs_filtered (_("<synthetic pointer>"), stream);
286 return 0;
287 }
288
289 if (!value_bytes_available (val, embedded_offset, TYPE_LENGTH (type)))
290 {
291 val_print_unavailable (stream);
292 return 0;
293 }
294 }
295
296 return 1;
297 }
298
299 void
300 val_print_optimized_out (struct ui_file *stream)
301 {
302 fprintf_filtered (stream, _("<optimized out>"));
303 }
304
305 void
306 val_print_unavailable (struct ui_file *stream)
307 {
308 fprintf_filtered (stream, _("<unavailable>"));
309 }
310
311 void
312 val_print_invalid_address (struct ui_file *stream)
313 {
314 fprintf_filtered (stream, _("<invalid address>"));
315 }
316
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
322 buffer.
323
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?".
332
333 RECURSE indicates the amount of indentation to supply before
334 continuation lines; this amount is roughly twice the value of
335 RECURSE.
336
337 If the data is printed as a string, returns the number of string
338 characters printed. */
339
340 int
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)
346 {
347 volatile struct gdb_exception except;
348 int ret = 0;
349 struct value_print_options local_opts = *options;
350 struct type *real_type = check_typedef (type);
351
352 if (local_opts.pretty == Val_pretty_default)
353 local_opts.pretty = (local_opts.prettyprint_structs
354 ? Val_prettyprint : Val_no_prettyprint);
355
356 QUIT;
357
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. */
361
362 if (TYPE_STUB (real_type))
363 {
364 fprintf_filtered (stream, _("<incomplete type>"));
365 gdb_flush (stream);
366 return (0);
367 }
368
369 if (!valprint_check_validity (stream, real_type, embedded_offset, val))
370 return 0;
371
372 if (!options->raw)
373 {
374 ret = apply_val_pretty_printer (type, valaddr, embedded_offset,
375 address, stream, recurse,
376 val, options, language);
377 if (ret)
378 return ret;
379 }
380
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))
384 {
385 fprintf_filtered (stream, "...");
386 return 0;
387 }
388
389 TRY_CATCH (except, RETURN_MASK_ERROR)
390 {
391 ret = language->la_val_print (type, valaddr, embedded_offset, address,
392 stream, recurse, val,
393 &local_opts);
394 }
395 if (except.reason < 0)
396 fprintf_filtered (stream, _("<error reading variable>"));
397
398 return ret;
399 }
400
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
403 is not. */
404
405 static int
406 value_check_printable (struct value *val, struct ui_file *stream)
407 {
408 if (val == 0)
409 {
410 fprintf_filtered (stream, _("<address of value unknown>"));
411 return 0;
412 }
413
414 if (value_entirely_optimized_out (val))
415 {
416 val_print_optimized_out (stream);
417 return 0;
418 }
419
420 if (TYPE_CODE (value_type (val)) == TYPE_CODE_INTERNAL_FUNCTION)
421 {
422 fprintf_filtered (stream, _("<internal function %s>"),
423 value_internal_function_name (val));
424 return 0;
425 }
426
427 return 1;
428 }
429
430 /* Print using the given LANGUAGE the value VAL onto stream STREAM according
431 to OPTIONS.
432
433 If the data are a string pointer, returns the number of string characters
434 printed.
435
436 This is a preferable interface to val_print, above, because it uses
437 GDB's value mechanism. */
438
439 int
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)
443 {
444 if (!value_check_printable (val, stream))
445 return 0;
446
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);
453
454 return val_print (value_type (val), value_contents_for_printing (val),
455 value_embedded_offset (val), value_address (val),
456 stream, recurse,
457 val, options, language);
458 }
459
460 /* Print on stream STREAM the value VAL according to OPTIONS. The value
461 is printed using the current_language syntax.
462
463 If the object printed is a string pointer, return the number of string
464 bytes printed. */
465
466 int
467 value_print (struct value *val, struct ui_file *stream,
468 const struct value_print_options *options)
469 {
470 if (!value_check_printable (val, stream))
471 return 0;
472
473 if (!options->raw)
474 {
475 int r = apply_val_pretty_printer (value_type (val),
476 value_contents_for_printing (val),
477 value_embedded_offset (val),
478 value_address (val),
479 stream, 0,
480 val, options, current_language);
481
482 if (r)
483 return r;
484 }
485
486 return LA_VALUE_PRINT (val, stream, options);
487 }
488
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. */
492
493 void
494 val_print_type_code_int (struct type *type, const gdb_byte *valaddr,
495 struct ui_file *stream)
496 {
497 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
498
499 if (TYPE_LENGTH (type) > sizeof (LONGEST))
500 {
501 LONGEST val;
502
503 if (TYPE_UNSIGNED (type)
504 && extract_long_unsigned_integer (valaddr, TYPE_LENGTH (type),
505 byte_order, &val))
506 {
507 print_longest (stream, 'u', 0, val);
508 }
509 else
510 {
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
514 better than this. */
515 print_hex_chars (stream, (unsigned char *) valaddr,
516 TYPE_LENGTH (type), byte_order);
517 }
518 }
519 else
520 {
521 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0,
522 unpack_long (type, valaddr));
523 }
524 }
525
526 void
527 val_print_type_code_flags (struct type *type, const gdb_byte *valaddr,
528 struct ui_file *stream)
529 {
530 ULONGEST val = unpack_long (type, valaddr);
531 int bitpos, nfields = TYPE_NFIELDS (type);
532
533 fputs_filtered ("[ ", stream);
534 for (bitpos = 0; bitpos < nfields; bitpos++)
535 {
536 if (TYPE_FIELD_BITPOS (type, bitpos) != -1
537 && (val & ((ULONGEST)1 << bitpos)))
538 {
539 if (TYPE_FIELD_NAME (type, bitpos))
540 fprintf_filtered (stream, "%s ", TYPE_FIELD_NAME (type, bitpos));
541 else
542 fprintf_filtered (stream, "#%d ", bitpos);
543 }
544 }
545 fputs_filtered ("]", stream);
546
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
549 at this level.
550
551 This is how the elements of an array or structure are printed
552 with a format. */
553 }
554
555 void
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,
560 int size,
561 struct ui_file *stream)
562 {
563 gdb_assert (val != NULL);
564 gdb_assert (valaddr == value_contents_for_printing_const (val));
565
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
568 again. */
569 if (options->format == 's')
570 {
571 struct value_print_options opts = *options;
572 opts.format = 0;
573 opts.deref_ref = 0;
574 val_print (type, valaddr, embedded_offset, 0, stream, 0, val, &opts,
575 current_language);
576 return;
577 }
578
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);
586 else
587 print_scalar_formatted (valaddr + embedded_offset, type,
588 options, size, stream);
589 }
590
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
595 format.
596
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
599 (leading 0 or 0x).
600
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
608 that capability. */
609
610 void
611 print_longest (struct ui_file *stream, int format, int use_c_format,
612 LONGEST val_long)
613 {
614 const char *val;
615
616 switch (format)
617 {
618 case 'd':
619 val = int_string (val_long, 10, 1, 0, 1); break;
620 case 'u':
621 val = int_string (val_long, 10, 0, 0, 1); break;
622 case 'x':
623 val = int_string (val_long, 16, 0, 0, use_c_format); break;
624 case 'b':
625 val = int_string (val_long, 16, 0, 2, 1); break;
626 case 'h':
627 val = int_string (val_long, 16, 0, 4, 1); break;
628 case 'w':
629 val = int_string (val_long, 16, 0, 8, 1); break;
630 case 'g':
631 val = int_string (val_long, 16, 0, 16, 1); break;
632 break;
633 case 'o':
634 val = int_string (val_long, 8, 0, 0, use_c_format); break;
635 default:
636 internal_error (__FILE__, __LINE__,
637 _("failed internal consistency check"));
638 }
639 fputs_filtered (val, stream);
640 }
641
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. */
647
648 int
649 longest_to_int (LONGEST arg)
650 {
651 /* Let the compiler do the work. */
652 int rtnval = (int) arg;
653
654 /* Check for overflows or underflows. */
655 if (sizeof (LONGEST) > sizeof (int))
656 {
657 if (rtnval != arg)
658 {
659 error (_("Value out of range."));
660 }
661 }
662 return (rtnval);
663 }
664
665 /* Print a floating point value of type TYPE (not always a
666 TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM. */
667
668 void
669 print_floating (const gdb_byte *valaddr, struct type *type,
670 struct ui_file *stream)
671 {
672 DOUBLEST doub;
673 int inv;
674 const struct floatformat *fmt = NULL;
675 unsigned len = TYPE_LENGTH (type);
676 enum float_kind kind;
677
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);
681 if (fmt != NULL)
682 {
683 kind = floatformat_classify (fmt, valaddr);
684 if (kind == float_nan)
685 {
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, ")");
692 return;
693 }
694 else if (kind == float_infinite)
695 {
696 if (floatformat_is_negative (fmt, valaddr))
697 fputs_filtered ("-", stream);
698 fputs_filtered ("inf", stream);
699 return;
700 }
701 }
702
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. */
711
712 doub = unpack_double (type, valaddr, &inv);
713 if (inv)
714 {
715 fprintf_filtered (stream, "<invalid float value>");
716 return;
717 }
718
719 /* FIXME: kettenis/2001-01-20: The following code makes too much
720 assumptions about the host and target floating point format. */
721
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. */
726
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);
731 else
732 #ifdef PRINTF_HAS_LONG_DOUBLE
733 fprintf_filtered (stream, "%.35Lg", doub);
734 #else
735 /* This at least wins with values that are representable as
736 doubles. */
737 fprintf_filtered (stream, "%.17g", (double) doub);
738 #endif
739 }
740
741 void
742 print_decimal_floating (const gdb_byte *valaddr, struct type *type,
743 struct ui_file *stream)
744 {
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);
748
749 decimal_to_string (valaddr, len, byte_order, decstr);
750 fputs_filtered (decstr, stream);
751 return;
752 }
753
754 void
755 print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr,
756 unsigned len, enum bfd_endian byte_order)
757 {
758
759 #define BITS_IN_BYTES 8
760
761 const gdb_byte *p;
762 unsigned int i;
763 int b;
764
765 /* Declared "int" so it will be signed.
766 This ensures that right shift will shift in zeros. */
767
768 const int mask = 0x080;
769
770 /* FIXME: We should be not printing leading zeroes in most cases. */
771
772 if (byte_order == BFD_ENDIAN_BIG)
773 {
774 for (p = valaddr;
775 p < valaddr + len;
776 p++)
777 {
778 /* Every byte has 8 binary characters; peel off
779 and print from the MSB end. */
780
781 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
782 {
783 if (*p & (mask >> i))
784 b = 1;
785 else
786 b = 0;
787
788 fprintf_filtered (stream, "%1d", b);
789 }
790 }
791 }
792 else
793 {
794 for (p = valaddr + len - 1;
795 p >= valaddr;
796 p--)
797 {
798 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
799 {
800 if (*p & (mask >> i))
801 b = 1;
802 else
803 b = 0;
804
805 fprintf_filtered (stream, "%1d", b);
806 }
807 }
808 }
809 }
810
811 /* VALADDR points to an integer of LEN bytes.
812 Print it in octal on stream or format it in buf. */
813
814 void
815 print_octal_chars (struct ui_file *stream, const gdb_byte *valaddr,
816 unsigned len, enum bfd_endian byte_order)
817 {
818 const gdb_byte *p;
819 unsigned char octa1, octa2, octa3, carry;
820 int cycle;
821
822 /* FIXME: We should be not printing leading zeroes in most cases. */
823
824
825 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
826 * the extra bits, which cycle every three bytes:
827 *
828 * Byte side: 0 1 2 3
829 * | | | |
830 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
831 *
832 * Octal side: 0 1 carry 3 4 carry ...
833 *
834 * Cycle number: 0 1 2
835 *
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.
839 */
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
845 #define MID_ONE 0160
846 #define LOW_ONE 0016
847 #define CARRY_ONE 0001
848 #define HIGH_TWO 0300
849 #define MID_TWO 0070
850 #define LOW_TWO 0007
851
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. */
854
855 cycle = (len * BITS_IN_BYTES) % BITS_IN_OCTAL;
856 carry = 0;
857
858 fputs_filtered ("0", stream);
859 if (byte_order == BFD_ENDIAN_BIG)
860 {
861 for (p = valaddr;
862 p < valaddr + len;
863 p++)
864 {
865 switch (cycle)
866 {
867 case 0:
868 /* No carry in, carry out two bits. */
869
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);
875 break;
876
877 case 1:
878 /* Carry in two bits, carry out one bit. */
879
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);
887 break;
888
889 case 2:
890 /* Carry in one bit, no carry out. */
891
892 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
893 octa2 = (MID_TWO & *p) >> 3;
894 octa3 = (LOW_TWO & *p);
895 carry = 0;
896 fprintf_filtered (stream, "%o", octa1);
897 fprintf_filtered (stream, "%o", octa2);
898 fprintf_filtered (stream, "%o", octa3);
899 break;
900
901 default:
902 error (_("Internal error in octal conversion;"));
903 }
904
905 cycle++;
906 cycle = cycle % BITS_IN_OCTAL;
907 }
908 }
909 else
910 {
911 for (p = valaddr + len - 1;
912 p >= valaddr;
913 p--)
914 {
915 switch (cycle)
916 {
917 case 0:
918 /* Carry out, no carry in */
919
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);
925 break;
926
927 case 1:
928 /* Carry in, carry out */
929
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);
937 break;
938
939 case 2:
940 /* Carry in, no carry out */
941
942 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
943 octa2 = (MID_TWO & *p) >> 3;
944 octa3 = (LOW_TWO & *p);
945 carry = 0;
946 fprintf_filtered (stream, "%o", octa1);
947 fprintf_filtered (stream, "%o", octa2);
948 fprintf_filtered (stream, "%o", octa3);
949 break;
950
951 default:
952 error (_("Internal error in octal conversion;"));
953 }
954
955 cycle++;
956 cycle = cycle % BITS_IN_OCTAL;
957 }
958 }
959
960 }
961
962 /* VALADDR points to an integer of LEN bytes.
963 Print it in decimal on stream or format it in buf. */
964
965 void
966 print_decimal_chars (struct ui_file *stream, const gdb_byte *valaddr,
967 unsigned len, enum bfd_endian byte_order)
968 {
969 #define TEN 10
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)
975
976 const gdb_byte *p;
977 unsigned char *digits;
978 int carry;
979 int decimal_len;
980 int i, j, decimal_digits;
981 int dummy;
982 int flip;
983
984 /* Base-ten number is less than twice as many digits
985 as the base 16 number, which is 2 digits per byte. */
986
987 decimal_len = len * 2 * 2;
988 digits = xmalloc (decimal_len);
989
990 for (i = 0; i < decimal_len; i++)
991 {
992 digits[i] = 0;
993 }
994
995 /* Ok, we have an unknown number of bytes of data to be printed in
996 * decimal.
997 *
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.
1001 *
1002 * The trick is that "digits" holds a base-10 number, but sometimes
1003 * the individual digits are > 10.
1004 *
1005 * Outer loop is per nibble (hex digit) of input, from MSD end to
1006 * LSD end.
1007 */
1008 decimal_digits = 0; /* Number of decimal digits so far */
1009 p = (byte_order == BFD_ENDIAN_BIG) ? valaddr : valaddr + len - 1;
1010 flip = 0;
1011 while ((byte_order == BFD_ENDIAN_BIG) ? (p < valaddr + len) : (p >= valaddr))
1012 {
1013 /*
1014 * Multiply current base-ten number by 16 in place.
1015 * Each digit was between 0 and 9, now is between
1016 * 0 and 144.
1017 */
1018 for (j = 0; j < decimal_digits; j++)
1019 {
1020 digits[j] = SHIFT (digits[j]);
1021 }
1022
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.
1026 *
1027 * "flip" is used to run this loop twice for each byte.
1028 */
1029 if (flip == 0)
1030 {
1031 /* Take top nibble. */
1032
1033 digits[0] += HIGH_NIBBLE (*p);
1034 flip = 1;
1035 }
1036 else
1037 {
1038 /* Take low nibble and bump our pointer "p". */
1039
1040 digits[0] += LOW_NIBBLE (*p);
1041 if (byte_order == BFD_ENDIAN_BIG)
1042 p++;
1043 else
1044 p--;
1045 flip = 0;
1046 }
1047
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.
1055 */
1056 carry = 0;
1057 for (j = 0; j < decimal_len - 1; j++)
1058 {
1059 digits[j] += carry;
1060
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".
1064 */
1065 dummy = digits[j];
1066 carry = CARRY_OUT (dummy);
1067 digits[j] = CARRY_LEFT (dummy);
1068
1069 if (j >= decimal_digits && carry == 0)
1070 {
1071 /*
1072 * All higher digits are 0 and we
1073 * no longer have a carry.
1074 *
1075 * Note: "j" is 0-based, "decimal_digits" is
1076 * 1-based.
1077 */
1078 decimal_digits = j + 1;
1079 break;
1080 }
1081 }
1082 }
1083
1084 /* Ok, now "digits" is the decimal representation, with
1085 the "decimal_digits" actual digits. Print! */
1086
1087 for (i = decimal_digits - 1; i >= 0; i--)
1088 {
1089 fprintf_filtered (stream, "%1d", digits[i]);
1090 }
1091 xfree (digits);
1092 }
1093
1094 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
1095
1096 void
1097 print_hex_chars (struct ui_file *stream, const gdb_byte *valaddr,
1098 unsigned len, enum bfd_endian byte_order)
1099 {
1100 const gdb_byte *p;
1101
1102 /* FIXME: We should be not printing leading zeroes in most cases. */
1103
1104 fputs_filtered ("0x", stream);
1105 if (byte_order == BFD_ENDIAN_BIG)
1106 {
1107 for (p = valaddr;
1108 p < valaddr + len;
1109 p++)
1110 {
1111 fprintf_filtered (stream, "%02x", *p);
1112 }
1113 }
1114 else
1115 {
1116 for (p = valaddr + len - 1;
1117 p >= valaddr;
1118 p--)
1119 {
1120 fprintf_filtered (stream, "%02x", *p);
1121 }
1122 }
1123 }
1124
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. */
1128
1129 void
1130 print_char_chars (struct ui_file *stream, struct type *type,
1131 const gdb_byte *valaddr,
1132 unsigned len, enum bfd_endian byte_order)
1133 {
1134 const gdb_byte *p;
1135
1136 if (byte_order == BFD_ENDIAN_BIG)
1137 {
1138 p = valaddr;
1139 while (p < valaddr + len - 1 && *p == 0)
1140 ++p;
1141
1142 while (p < valaddr + len)
1143 {
1144 LA_EMIT_CHAR (*p, type, stream, '\'');
1145 ++p;
1146 }
1147 }
1148 else
1149 {
1150 p = valaddr + len - 1;
1151 while (p > valaddr && *p == 0)
1152 --p;
1153
1154 while (p >= valaddr)
1155 {
1156 LA_EMIT_CHAR (*p, type, stream, '\'');
1157 --p;
1158 }
1159 }
1160 }
1161
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. */
1164
1165 void
1166 maybe_print_array_index (struct type *index_type, LONGEST index,
1167 struct ui_file *stream,
1168 const struct value_print_options *options)
1169 {
1170 struct value *index_value;
1171
1172 if (!options->print_array_indexes)
1173 return;
1174
1175 index_value = value_from_longest (index_type, index);
1176
1177 LA_PRINT_ARRAY_INDEX (index_value, stream, options);
1178 }
1179
1180 /* Called by various <lang>_val_print routines to print elements of an
1181 array in the form "<elem1>, <elem2>, <elem3>, ...".
1182
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. */
1187
1188 void
1189 val_print_array_elements (struct type *type,
1190 const gdb_byte *valaddr, int embedded_offset,
1191 CORE_ADDR address, struct ui_file *stream,
1192 int recurse,
1193 const struct value *val,
1194 const struct value_print_options *options,
1195 unsigned int i)
1196 {
1197 unsigned int things_printed = 0;
1198 unsigned len;
1199 struct type *elttype, *index_type;
1200 unsigned eltlen;
1201 /* Position of the array element we are examining to see
1202 whether it is repeated. */
1203 unsigned int rep1;
1204 /* Number of repetitions we have detected so far. */
1205 unsigned int reps;
1206 LONGEST low_bound, high_bound;
1207
1208 elttype = TYPE_TARGET_TYPE (type);
1209 eltlen = TYPE_LENGTH (check_typedef (elttype));
1210 index_type = TYPE_INDEX_TYPE (type);
1211
1212 if (get_array_bounds (type, &low_bound, &high_bound))
1213 {
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,
1218 not negative! */
1219 if (low_bound > high_bound)
1220 len = 0;
1221 else
1222 len = high_bound - low_bound + 1;
1223 }
1224 else
1225 {
1226 warning (_("unable to get bounds of array, assuming null array"));
1227 low_bound = 0;
1228 len = 0;
1229 }
1230
1231 annotate_array_section_begin (i, elttype);
1232
1233 for (; i < len && things_printed < options->print_max; i++)
1234 {
1235 if (i != 0)
1236 {
1237 if (options->prettyprint_arrays)
1238 {
1239 fprintf_filtered (stream, ",\n");
1240 print_spaces_filtered (2 + 2 * recurse, stream);
1241 }
1242 else
1243 {
1244 fprintf_filtered (stream, ", ");
1245 }
1246 }
1247 wrap_here (n_spaces (2 + 2 * recurse));
1248 maybe_print_array_index (index_type, i + low_bound,
1249 stream, options);
1250
1251 rep1 = i + 1;
1252 reps = 1;
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)
1256 {
1257 while (rep1 < len
1258 && value_available_contents_eq (val,
1259 embedded_offset + i * eltlen,
1260 val,
1261 (embedded_offset
1262 + rep1 * eltlen),
1263 eltlen))
1264 {
1265 ++reps;
1266 ++rep1;
1267 }
1268 }
1269
1270 if (reps > options->repeat_count_threshold)
1271 {
1272 val_print (elttype, valaddr, embedded_offset + i * eltlen,
1273 address, stream, recurse + 1, val, options,
1274 current_language);
1275 annotate_elt_rep (reps);
1276 fprintf_filtered (stream, " <repeats %u times>", reps);
1277 annotate_elt_rep_end ();
1278
1279 i = rep1 - 1;
1280 things_printed += options->repeat_count_threshold;
1281 }
1282 else
1283 {
1284 val_print (elttype, valaddr, embedded_offset + i * eltlen,
1285 address,
1286 stream, recurse + 1, val, options, current_language);
1287 annotate_elt ();
1288 things_printed++;
1289 }
1290 }
1291 annotate_array_section_end ();
1292 if (i < len)
1293 {
1294 fprintf_filtered (stream, "...");
1295 }
1296 }
1297
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. */
1302
1303 /* FIXME: cagney/1999-10-14: Only used by val_print_string. Can this
1304 function be eliminated. */
1305
1306 static int
1307 partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
1308 int len, int *errnoptr)
1309 {
1310 int nread; /* Number of bytes actually read. */
1311 int errcode; /* Error from last read. */
1312
1313 /* First try a complete read. */
1314 errcode = target_read_memory (memaddr, myaddr, len);
1315 if (errcode == 0)
1316 {
1317 /* Got it all. */
1318 nread = len;
1319 }
1320 else
1321 {
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--)
1324 {
1325 errcode = target_read_memory (memaddr++, myaddr++, 1);
1326 }
1327 /* If an error, the last read was unsuccessful, so adjust count. */
1328 if (errcode != 0)
1329 {
1330 nread--;
1331 }
1332 }
1333 if (errnoptr != NULL)
1334 {
1335 *errnoptr = errcode;
1336 }
1337 return (nread);
1338 }
1339
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.
1345
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.
1351
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.
1355
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? */
1361
1362 int
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)
1365 {
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
1371 buffer. */
1372 gdb_byte *limit; /* First location past end of fetch buffer. */
1373 struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
1374
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. */
1383
1384 chunksize = (len == -1 ? min (8, fetchlimit) : fetchlimit);
1385
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. */
1388
1389 found_nul = 0;
1390 *buffer = NULL;
1391
1392 old_chain = make_cleanup (free_current_contents, buffer);
1393
1394 if (len > 0)
1395 {
1396 *buffer = (gdb_byte *) xmalloc (len * width);
1397 bufptr = *buffer;
1398
1399 nfetch = partial_memory_read (addr, bufptr, len * width, &errcode)
1400 / width;
1401 addr += nfetch * width;
1402 bufptr += nfetch * width;
1403 }
1404 else if (len == -1)
1405 {
1406 unsigned long bufsize = 0;
1407
1408 do
1409 {
1410 QUIT;
1411 nfetch = min (chunksize, fetchlimit - bufsize);
1412
1413 if (*buffer == NULL)
1414 *buffer = (gdb_byte *) xmalloc (nfetch * width);
1415 else
1416 *buffer = (gdb_byte *) xrealloc (*buffer,
1417 (nfetch + bufsize) * width);
1418
1419 bufptr = *buffer + bufsize * width;
1420 bufsize += nfetch;
1421
1422 /* Read as much as we can. */
1423 nfetch = partial_memory_read (addr, bufptr, nfetch * width, &errcode)
1424 / width;
1425
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
1430 of the buffer. */
1431
1432 limit = bufptr + nfetch * width;
1433 while (bufptr < limit)
1434 {
1435 unsigned long c;
1436
1437 c = extract_unsigned_integer (bufptr, width, byte_order);
1438 addr += width;
1439 bufptr += width;
1440 if (c == 0)
1441 {
1442 /* We don't care about any error which happened after
1443 the NUL terminator. */
1444 errcode = 0;
1445 found_nul = 1;
1446 break;
1447 }
1448 }
1449 }
1450 while (errcode == 0 /* no error */
1451 && bufptr - *buffer < fetchlimit * width /* no overrun */
1452 && !found_nul); /* haven't found NUL yet */
1453 }
1454 else
1455 { /* Length of string is really 0! */
1456 /* We always allocate *buffer. */
1457 *buffer = bufptr = xmalloc (1);
1458 errcode = 0;
1459 }
1460
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;
1464
1465 QUIT;
1466
1467 discard_cleanups (old_chain);
1468
1469 return errcode;
1470 }
1471
1472 /* Return true if print_wchar can display W without resorting to a
1473 numeric escape, false otherwise. */
1474
1475 static int
1476 wchar_printable (gdb_wchar_t w)
1477 {
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'));
1483 }
1484
1485 /* A helper function that converts the contents of STRING to wide
1486 characters and then appends them to OUTPUT. */
1487
1488 static void
1489 append_string_as_wide (const char *string,
1490 struct obstack *output)
1491 {
1492 for (; *string; ++string)
1493 {
1494 gdb_wchar_t w = gdb_btowc (*string);
1495 obstack_grow (output, &w, sizeof (gdb_wchar_t));
1496 }
1497 }
1498
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. */
1507
1508 static void
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)
1514 {
1515 int need_escape = *need_escapep;
1516
1517 *need_escapep = 0;
1518 if (gdb_iswprint (w) && (!need_escape || (!gdb_iswdigit (w)
1519 && w != LCST ('8')
1520 && w != LCST ('9'))))
1521 {
1522 gdb_wchar_t wchar = w;
1523
1524 if (w == gdb_btowc (quoter) || w == LCST ('\\'))
1525 obstack_grow_wstr (output, LCST ("\\"));
1526 obstack_grow (output, &wchar, sizeof (gdb_wchar_t));
1527 }
1528 else
1529 {
1530 switch (w)
1531 {
1532 case LCST ('\a'):
1533 obstack_grow_wstr (output, LCST ("\\a"));
1534 break;
1535 case LCST ('\b'):
1536 obstack_grow_wstr (output, LCST ("\\b"));
1537 break;
1538 case LCST ('\f'):
1539 obstack_grow_wstr (output, LCST ("\\f"));
1540 break;
1541 case LCST ('\n'):
1542 obstack_grow_wstr (output, LCST ("\\n"));
1543 break;
1544 case LCST ('\r'):
1545 obstack_grow_wstr (output, LCST ("\\r"));
1546 break;
1547 case LCST ('\t'):
1548 obstack_grow_wstr (output, LCST ("\\t"));
1549 break;
1550 case LCST ('\v'):
1551 obstack_grow_wstr (output, LCST ("\\v"));
1552 break;
1553 default:
1554 {
1555 int i;
1556
1557 for (i = 0; i + width <= orig_len; i += width)
1558 {
1559 char octal[30];
1560 ULONGEST value;
1561
1562 value = extract_unsigned_integer (&orig[i], width,
1563 byte_order);
1564 /* If the value fits in 3 octal digits, print it that
1565 way. Otherwise, print it as a hex escape. */
1566 if (value <= 0777)
1567 sprintf (octal, "\\%.3o", (int) (value & 0777));
1568 else
1569 sprintf (octal, "\\x%lx", (long) value);
1570 append_string_as_wide (octal, output);
1571 }
1572 /* If we somehow have extra bytes, print them now. */
1573 while (i < orig_len)
1574 {
1575 char octal[5];
1576
1577 sprintf (octal, "\\%.3o", orig[i] & 0xff);
1578 append_string_as_wide (octal, output);
1579 ++i;
1580 }
1581
1582 *need_escapep = 1;
1583 }
1584 break;
1585 }
1586 }
1587 }
1588
1589 /* Print the character C on STREAM as part of the contents of a
1590 literal string whose delimiter is QUOTER. ENCODING names the
1591 encoding of C. */
1592
1593 void
1594 generic_emit_char (int c, struct type *type, struct ui_file *stream,
1595 int quoter, const char *encoding)
1596 {
1597 enum bfd_endian byte_order
1598 = gdbarch_byte_order (get_type_arch (type));
1599 struct obstack wchar_buf, output;
1600 struct cleanup *cleanups;
1601 gdb_byte *buf;
1602 struct wchar_iterator *iter;
1603 int need_escape = 0;
1604
1605 buf = alloca (TYPE_LENGTH (type));
1606 pack_long (buf, type, c);
1607
1608 iter = make_wchar_iterator (buf, TYPE_LENGTH (type),
1609 encoding, TYPE_LENGTH (type));
1610 cleanups = make_cleanup_wchar_iterator (iter);
1611
1612 /* This holds the printable form of the wchar_t data. */
1613 obstack_init (&wchar_buf);
1614 make_cleanup_obstack_free (&wchar_buf);
1615
1616 while (1)
1617 {
1618 int num_chars;
1619 gdb_wchar_t *chars;
1620 const gdb_byte *buf;
1621 size_t buflen;
1622 int print_escape = 1;
1623 enum wchar_iterate_result result;
1624
1625 num_chars = wchar_iterate (iter, &result, &chars, &buf, &buflen);
1626 if (num_chars < 0)
1627 break;
1628 if (num_chars > 0)
1629 {
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. */
1635 int i;
1636
1637 print_escape = 0;
1638 for (i = 0; i < num_chars; ++i)
1639 if (!wchar_printable (chars[i]))
1640 {
1641 print_escape = 1;
1642 break;
1643 }
1644
1645 if (!print_escape)
1646 {
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);
1651 }
1652 }
1653
1654 /* This handles the NUM_CHARS == 0 case as well. */
1655 if (print_escape)
1656 print_wchar (gdb_WEOF, buf, buflen, TYPE_LENGTH (type),
1657 byte_order, &wchar_buf, quoter, &need_escape);
1658 }
1659
1660 /* The output in the host encoding. */
1661 obstack_init (&output);
1662 make_cleanup_obstack_free (&output);
1663
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');
1669
1670 fputs_filtered (obstack_base (&output), stream);
1671
1672 do_cleanups (cleanups);
1673 }
1674
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
1683 omitted. */
1684
1685 void
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)
1691 {
1692 enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
1693 unsigned int i;
1694 unsigned int things_printed = 0;
1695 int in_quotes = 0;
1696 int need_comma = 0;
1697 int width = TYPE_LENGTH (type);
1698 struct obstack wchar_buf, output;
1699 struct cleanup *cleanup;
1700 struct wchar_iterator *iter;
1701 int finished = 0;
1702 int need_escape = 0;
1703 gdb_wchar_t wide_quote_char = gdb_btowc (quote_char);
1704
1705 if (length == -1)
1706 {
1707 unsigned long current_char = 1;
1708
1709 for (i = 0; current_char; ++i)
1710 {
1711 QUIT;
1712 current_char = extract_unsigned_integer (string + i * width,
1713 width, byte_order);
1714 }
1715 length = i;
1716 }
1717
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
1722 && !force_ellipses
1723 && length > 0
1724 && (extract_unsigned_integer (string + (length - 1) * width,
1725 width, byte_order) == 0))
1726 length--;
1727
1728 if (length == 0)
1729 {
1730 fputs_filtered ("\"\"", stream);
1731 return;
1732 }
1733
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);
1737
1738 /* WCHAR_BUF is the obstack we use to represent the string in
1739 wchar_t form. */
1740 obstack_init (&wchar_buf);
1741 make_cleanup_obstack_free (&wchar_buf);
1742
1743 while (!finished && things_printed < options->print_max)
1744 {
1745 int num_chars;
1746 enum wchar_iterate_result result;
1747 gdb_wchar_t *chars;
1748 const gdb_byte *buf;
1749 size_t buflen;
1750
1751 QUIT;
1752
1753 if (need_comma)
1754 {
1755 obstack_grow_wstr (&wchar_buf, LCST (", "));
1756 need_comma = 0;
1757 }
1758
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
1763 cases. */
1764 while (num_chars == 1 && things_printed < options->print_max)
1765 {
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;
1771
1772 if (need_comma)
1773 {
1774 obstack_grow_wstr (&wchar_buf, LCST (", "));
1775 need_comma = 0;
1776 }
1777
1778 while (num_chars == 1 && current_char == chars[0])
1779 {
1780 num_chars = wchar_iterate (iter, &result, &chars,
1781 &buf, &buflen);
1782 ++reps;
1783 }
1784
1785 /* Emit CURRENT_CHAR according to the repetition count and
1786 options. */
1787 if (reps > options->repeat_count_threshold)
1788 {
1789 if (in_quotes)
1790 {
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 (", "));
1796 in_quotes = 0;
1797 }
1798 obstack_grow_wstr (&wchar_buf, LCST ("'"));
1799 need_escape = 0;
1800 print_wchar (current_char, orig_buf, orig_len, width,
1801 byte_order, &wchar_buf, '\'', &need_escape);
1802 obstack_grow_wstr (&wchar_buf, LCST ("'"));
1803 {
1804 /* Painful gyrations. */
1805 int j;
1806 char *s = xstrprintf (_(" <repeats %u times>"), reps);
1807
1808 for (j = 0; s[j]; ++j)
1809 {
1810 gdb_wchar_t w = gdb_btowc (s[j]);
1811 obstack_grow (&wchar_buf, &w, sizeof (gdb_wchar_t));
1812 }
1813 xfree (s);
1814 }
1815 things_printed += options->repeat_count_threshold;
1816 need_comma = 1;
1817 }
1818 else
1819 {
1820 /* Saw the character one or more times, but fewer than
1821 the repetition threshold. */
1822 if (!in_quotes)
1823 {
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));
1828 in_quotes = 1;
1829 need_escape = 0;
1830 }
1831
1832 while (reps-- > 0)
1833 {
1834 print_wchar (current_char, orig_buf,
1835 orig_len, width,
1836 byte_order, &wchar_buf,
1837 quote_char, &need_escape);
1838 ++things_printed;
1839 }
1840 }
1841 }
1842
1843 /* NUM_CHARS and the other outputs from wchar_iterate are valid
1844 here regardless of which branch was taken above. */
1845 if (num_chars < 0)
1846 {
1847 /* Hit EOF. */
1848 finished = 1;
1849 break;
1850 }
1851
1852 switch (result)
1853 {
1854 case wchar_iterate_invalid:
1855 if (!in_quotes)
1856 {
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));
1861 in_quotes = 1;
1862 }
1863 need_escape = 0;
1864 print_wchar (gdb_WEOF, buf, buflen, width, byte_order,
1865 &wchar_buf, quote_char, &need_escape);
1866 break;
1867
1868 case wchar_iterate_incomplete:
1869 if (in_quotes)
1870 {
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 (","));
1876 in_quotes = 0;
1877 }
1878 obstack_grow_wstr (&wchar_buf,
1879 LCST (" <incomplete sequence "));
1880 print_wchar (gdb_WEOF, buf, buflen, width,
1881 byte_order, &wchar_buf,
1882 0, &need_escape);
1883 obstack_grow_wstr (&wchar_buf, LCST (">"));
1884 finished = 1;
1885 break;
1886 }
1887 }
1888
1889 /* Terminate the quotes if necessary. */
1890 if (in_quotes)
1891 {
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));
1896 }
1897
1898 if (force_ellipses || !finished)
1899 obstack_grow_wstr (&wchar_buf, LCST ("..."));
1900
1901 /* OUTPUT is where we collect `char's for printing. */
1902 obstack_init (&output);
1903 make_cleanup_obstack_free (&output);
1904
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');
1910
1911 fputs_filtered (obstack_base (&output), stream);
1912
1913 do_cleanups (cleanup);
1914 }
1915
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
1922 assumed. */
1923
1924 int
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)
1929 {
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. */
1934 int bytes_read;
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);
1940
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. */
1948
1949 fetchlimit = (len == -1 ? options->print_max : min (len,
1950 options->print_max));
1951
1952 errcode = read_string (addr, len, width, fetchlimit, byte_order,
1953 &buffer, &bytes_read);
1954 old_chain = make_cleanup (xfree, buffer);
1955
1956 addr += bytes_read;
1957
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
1960 LEN is -1. */
1961
1962 /* Determine found_nul by looking at the last character read. */
1963 found_nul = extract_unsigned_integer (buffer + bytes_read - width, width,
1964 byte_order) == 0;
1965 if (len == -1 && !found_nul)
1966 {
1967 gdb_byte *peekbuf;
1968
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. */
1972
1973 peekbuf = (gdb_byte *) alloca (width);
1974
1975 if (target_read_memory (addr, peekbuf, width) == 0
1976 && extract_unsigned_integer (peekbuf, width, byte_order) != 0)
1977 force_ellipsis = 1;
1978 }
1979 else if ((len >= 0 && errcode != 0) || (len > bytes_read / width))
1980 {
1981 /* Getting an error when we have a requested length, or fetching less
1982 than the number of characters actually requested, always make us
1983 print ellipsis. */
1984 force_ellipsis = 1;
1985 }
1986
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)
1991 {
1992 if (options->addressprint)
1993 {
1994 fputs_filtered (" ", stream);
1995 }
1996 LA_PRINT_STRING (stream, elttype, buffer, bytes_read / width,
1997 encoding, force_ellipsis, options);
1998 }
1999
2000 if (errcode != 0)
2001 {
2002 if (errcode == EIO)
2003 {
2004 fprintf_filtered (stream, " <Address ");
2005 fputs_filtered (paddress (gdbarch, addr), stream);
2006 fprintf_filtered (stream, " out of bounds>");
2007 }
2008 else
2009 {
2010 fprintf_filtered (stream, " <Error reading address ");
2011 fputs_filtered (paddress (gdbarch, addr), stream);
2012 fprintf_filtered (stream, ": %s>", safe_strerror (errcode));
2013 }
2014 }
2015
2016 gdb_flush (stream);
2017 do_cleanups (old_chain);
2018
2019 return (bytes_read / width);
2020 }
2021 \f
2022
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. */
2026
2027 static unsigned input_radix_1 = 10;
2028
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! */
2032
2033 static void
2034 set_input_radix (char *args, int from_tty, struct cmd_list_element *c)
2035 {
2036 set_input_radix_1 (from_tty, input_radix_1);
2037 }
2038
2039 static void
2040 set_input_radix_1 (int from_tty, unsigned radix)
2041 {
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.
2047 (FIXME). */
2048
2049 if (radix < 2)
2050 {
2051 input_radix_1 = input_radix;
2052 error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
2053 radix);
2054 }
2055 input_radix_1 = input_radix = radix;
2056 if (from_tty)
2057 {
2058 printf_filtered (_("Input radix now set to "
2059 "decimal %u, hex %x, octal %o.\n"),
2060 radix, radix, radix);
2061 }
2062 }
2063
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. */
2067
2068 static unsigned output_radix_1 = 10;
2069
2070 static void
2071 set_output_radix (char *args, int from_tty, struct cmd_list_element *c)
2072 {
2073 set_output_radix_1 (from_tty, output_radix_1);
2074 }
2075
2076 static void
2077 set_output_radix_1 (int from_tty, unsigned radix)
2078 {
2079 /* Validate the radix and disallow ones that we aren't prepared to
2080 handle correctly, leaving the radix unchanged. */
2081 switch (radix)
2082 {
2083 case 16:
2084 user_print_options.output_format = 'x'; /* hex */
2085 break;
2086 case 10:
2087 user_print_options.output_format = 0; /* decimal */
2088 break;
2089 case 8:
2090 user_print_options.output_format = 'o'; /* octal */
2091 break;
2092 default:
2093 output_radix_1 = output_radix;
2094 error (_("Unsupported output radix ``decimal %u''; "
2095 "output radix unchanged."),
2096 radix);
2097 }
2098 output_radix_1 = output_radix = radix;
2099 if (from_tty)
2100 {
2101 printf_filtered (_("Output radix now set to "
2102 "decimal %u, hex %x, octal %o.\n"),
2103 radix, radix, radix);
2104 }
2105 }
2106
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.
2110
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. */
2114
2115 static void
2116 set_radix (char *arg, int from_tty)
2117 {
2118 unsigned radix;
2119
2120 radix = (arg == NULL) ? 10 : parse_and_eval_long (arg);
2121 set_output_radix_1 (0, radix);
2122 set_input_radix_1 (0, radix);
2123 if (from_tty)
2124 {
2125 printf_filtered (_("Input and output radices now set to "
2126 "decimal %u, hex %x, octal %o.\n"),
2127 radix, radix, radix);
2128 }
2129 }
2130
2131 /* Show both the input and output radices. */
2132
2133 static void
2134 show_radix (char *arg, int from_tty)
2135 {
2136 if (from_tty)
2137 {
2138 if (input_radix == output_radix)
2139 {
2140 printf_filtered (_("Input and output radices set to "
2141 "decimal %u, hex %x, octal %o.\n"),
2142 input_radix, input_radix, input_radix);
2143 }
2144 else
2145 {
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);
2152 }
2153 }
2154 }
2155 \f
2156
2157 static void
2158 set_print (char *arg, int from_tty)
2159 {
2160 printf_unfiltered (
2161 "\"set print\" must be followed by the name of a print subcommand.\n");
2162 help_list (setprintlist, "set print ", -1, gdb_stdout);
2163 }
2164
2165 static void
2166 show_print (char *args, int from_tty)
2167 {
2168 cmd_show_list (showprintlist, from_tty, "");
2169 }
2170 \f
2171 void
2172 _initialize_valprint (void)
2173 {
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);
2180
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);
2186
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."),
2192 NULL,
2193 show_print_max,
2194 &setprintlist, &showprintlist);
2195
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,
2200 NULL,
2201 show_stop_print_at_null,
2202 &setprintlist, &showprintlist);
2203
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."),
2209 NULL,
2210 show_repeat_count_threshold,
2211 &setprintlist, &showprintlist);
2212
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,
2217 NULL,
2218 show_prettyprint_structs,
2219 &setprintlist, &showprintlist);
2220
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,
2225 NULL,
2226 show_unionprint,
2227 &setprintlist, &showprintlist);
2228
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,
2233 NULL,
2234 show_prettyprint_arrays,
2235 &setprintlist, &showprintlist);
2236
2237 add_setshow_boolean_cmd ("address", class_support,
2238 &user_print_options.addressprint, _("\
2239 Set printing of addresses."), _("\
2240 Show printing of addresses."), NULL,
2241 NULL,
2242 show_addressprint,
2243 &setprintlist, &showprintlist);
2244
2245 add_setshow_zuinteger_cmd ("input-radix", class_support, &input_radix_1,
2246 _("\
2247 Set default input radix for entering numbers."), _("\
2248 Show default input radix for entering numbers."), NULL,
2249 set_input_radix,
2250 show_input_radix,
2251 &setlist, &showlist);
2252
2253 add_setshow_zuinteger_cmd ("output-radix", class_support, &output_radix_1,
2254 _("\
2255 Set default output radix for printing of values."), _("\
2256 Show default output radix for printing of values."), NULL,
2257 set_output_radix,
2258 show_output_radix,
2259 &setlist, &showlist);
2260
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."),
2272 &setlist);
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."),
2276 &showlist);
2277
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);
2283 }
This page took 0.153026 seconds and 5 git commands to generate.