1 /* Print values for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994
3 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
22 #include "gdb_string.h"
37 /* Prototypes for local functions */
40 print_hex_chars
PARAMS ((GDB_FILE
*, unsigned char *, unsigned int));
43 show_print
PARAMS ((char *, int));
46 set_print
PARAMS ((char *, int));
49 set_radix
PARAMS ((char *, int));
52 show_radix
PARAMS ((char *, int));
55 set_input_radix
PARAMS ((char *, int, struct cmd_list_element
*));
58 set_input_radix_1
PARAMS ((int, unsigned));
61 set_output_radix
PARAMS ((char *, int, struct cmd_list_element
*));
64 set_output_radix_1
PARAMS ((int, unsigned));
66 /* Maximum number of chars to print for a string pointer value or vector
67 contents, or UINT_MAX for no limit. Note that "set print elements 0"
68 stores UINT_MAX in print_max, which displays in a show command as
71 unsigned int print_max
;
72 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
74 /* Default input and output radixes, and output format letter. */
76 unsigned input_radix
= 10;
77 unsigned output_radix
= 10;
78 int output_format
= 0;
80 /* Print repeat counts if there are more than this many repetitions of an
81 element in an array. Referenced by the low level language dependent
84 unsigned int repeat_count_threshold
= 10;
86 /* If nonzero, stops printing of char arrays at first null. */
88 int stop_print_at_null
;
90 /* Controls pretty printing of structures. */
92 int prettyprint_structs
;
94 /* Controls pretty printing of arrays. */
96 int prettyprint_arrays
;
98 /* If nonzero, causes unions inside structures or other unions to be
101 int unionprint
; /* Controls printing of nested unions. */
103 /* If nonzero, causes machine addresses to be printed in certain contexts. */
105 int addressprint
; /* Controls printing of machine addresses */
108 /* Print data of type TYPE located at VALADDR (within GDB), which came from
109 the inferior at address ADDRESS, onto stdio stream STREAM according to
110 FORMAT (a letter, or 0 for natural format using TYPE).
112 If DEREF_REF is nonzero, then dereference references, otherwise just print
115 The PRETTY parameter controls prettyprinting.
117 If the data are a string pointer, returns the number of string characters
120 FIXME: The data at VALADDR is in target byte order. If gdb is ever
121 enhanced to be able to debug more than the single target it was compiled
122 for (specific CPU type and thus specific target byte ordering), then
123 either the print routines are going to have to take this into account,
124 or the data is going to have to be passed into here already converted
125 to the host byte ordering, whichever is more convenient. */
129 val_print (type
, valaddr
, address
, stream
, format
, deref_ref
, recurse
, pretty
)
137 enum val_prettyprint pretty
;
139 struct type
*real_type
= check_typedef (type
);
140 if (pretty
== Val_pretty_default
)
142 pretty
= prettyprint_structs
? Val_prettyprint
: Val_no_prettyprint
;
147 /* Ensure that the type is complete and not just a stub. If the type is
148 only a stub and we can't find and substitute its complete type, then
149 print appropriate string and return. */
151 if (TYPE_FLAGS (real_type
) & TYPE_FLAG_STUB
)
153 fprintf_filtered (stream
, "<incomplete type>");
158 return (LA_VAL_PRINT (type
, valaddr
, address
, stream
, format
, deref_ref
,
162 /* Print the value VAL in C-ish syntax on stream STREAM.
163 FORMAT is a format-letter, or 0 for print in natural format of data type.
164 If the object printed is a string pointer, returns
165 the number of string bytes printed. */
168 value_print (val
, stream
, format
, pretty
)
172 enum val_prettyprint pretty
;
176 printf_filtered ("<address of value unknown>");
179 if (VALUE_OPTIMIZED_OUT (val
))
181 printf_filtered ("<value optimized out>");
184 return LA_VALUE_PRINT (val
, stream
, format
, pretty
);
187 /* Called by various <lang>_val_print routines to print
188 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
189 value. STREAM is where to print the value. */
192 val_print_type_code_int (type
, valaddr
, stream
)
197 if (TYPE_LENGTH (type
) > sizeof (LONGEST
))
201 if (TYPE_UNSIGNED (type
)
202 && extract_long_unsigned_integer (valaddr
, TYPE_LENGTH (type
),
205 print_longest (stream
, 'u', 0, val
);
209 /* Signed, or we couldn't turn an unsigned value into a
210 LONGEST. For signed values, one could assume two's
211 complement (a reasonable assumption, I think) and do
213 print_hex_chars (stream
, (unsigned char *) valaddr
,
219 #ifdef PRINT_TYPELESS_INTEGER
220 PRINT_TYPELESS_INTEGER (stream
, type
, unpack_long (type
, valaddr
));
222 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0,
223 unpack_long (type
, valaddr
));
228 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
229 The raison d'etre of this function is to consolidate printing of LONG_LONG's
230 into this one function. Some platforms have long longs but don't have a
231 printf() that supports "ll" in the format string. We handle these by seeing
232 if the number is actually a long, and if not we just bail out and print the
233 number in hex. The format chars b,h,w,g are from
234 print_scalar_formatted(). If USE_LOCAL, format it according to the current
235 language (this should be used for most integers which GDB prints, the
236 exception is things like protocols where the format of the integer is
237 a protocol thing, not a user-visible thing). */
240 print_longest (stream
, format
, use_local
, val_long
)
246 #if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
248 unsigned int ui_max
= UINT_MAX
;
249 unsigned long long val_ulonglong
;
251 /* Do shift in two operations so that if sizeof (long) == sizeof (LONGEST)
252 we can avoid warnings from picky compilers about shifts >= the size of
253 the shiftee in bits */
254 vtop
= val_long
>> (sizeof (long) * HOST_CHAR_BIT
- 1);
256 vbot
= (long) val_long
;
257 val_ulonglong
= (unsigned long long) val_long
;
261 if (val_long
< INT_MIN
|| val_long
> INT_MAX
)
263 if (sizeof (long long) > sizeof (long))
265 fprintf_filtered (stream
, "0x%lx%08lx", vtop
, vbot
);
269 fprintf_filtered (stream
, "%d", vbot
);
275 if (val_ulonglong
> ui_max
)
277 if (sizeof (long long) > sizeof (long))
279 fprintf_filtered (stream
, "0x%lx%08lx", vtop
, vbot
);
283 fprintf_filtered (stream
, "0x%lx", vbot
);
289 if (val_ulonglong
> ui_max
)
291 if (sizeof (long long) > sizeof (long))
293 fprintf_filtered (stream
, "0x%lx%08lx", vtop
, vbot
);
297 fprintf_filtered (stream
, "%lu", (unsigned long) vbot
);
305 #ifdef PRINTF_HAS_LONG_LONG
309 fprintf_filtered (stream
,
310 use_local
? local_decimal_format_custom ("ll")
315 fprintf_filtered (stream
, "%llu", val_long
);
318 fprintf_filtered (stream
,
319 use_local
? local_hex_format_custom ("ll")
324 fprintf_filtered (stream
,
325 use_local
? local_octal_format_custom ("ll")
330 fprintf_filtered (stream
, local_hex_format_custom ("02ll"), val_long
);
333 fprintf_filtered (stream
, local_hex_format_custom ("04ll"), val_long
);
336 fprintf_filtered (stream
, local_hex_format_custom ("08ll"), val_long
);
339 fprintf_filtered (stream
, local_hex_format_custom ("016ll"), val_long
);
344 #else /* !PRINTF_HAS_LONG_LONG */
345 /* In the following it is important to coerce (val_long) to a long. It does
346 nothing if !LONG_LONG, but it will chop off the top half (which we know
347 we can ignore) if the host supports long longs. */
352 fprintf_filtered (stream
,
353 use_local
? local_decimal_format_custom ("l")
358 fprintf_filtered (stream
, "%lu", (unsigned long) val_long
);
361 fprintf_filtered (stream
,
362 use_local
? local_hex_format_custom ("l")
367 fprintf_filtered (stream
,
368 use_local
? local_octal_format_custom ("l")
373 fprintf_filtered (stream
, local_hex_format_custom ("02l"),
377 fprintf_filtered (stream
, local_hex_format_custom ("04l"),
381 fprintf_filtered (stream
, local_hex_format_custom ("08l"),
385 fprintf_filtered (stream
, local_hex_format_custom ("016l"),
391 #endif /* !PRINTF_HAS_LONG_LONG */
394 /* This used to be a macro, but I don't think it is called often enough
395 to merit such treatment. */
396 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
397 arguments to a function, number in a value history, register number, etc.)
398 where the value must not be larger than can fit in an int. */
405 /* This check is in case a system header has botched the
406 definition of INT_MIN, like on BSDI. */
407 if (sizeof (LONGEST
) <= sizeof (int))
411 error ("Value is larger than largest signed integer.");
413 error ("Value is smaller than smallest signed integer.");
418 /* Print a floating point value of type TYPE, pointed to in GDB by VALADDR,
422 print_floating (valaddr
, type
, stream
)
429 unsigned len
= TYPE_LENGTH (type
);
431 #if defined (IEEE_FLOAT)
433 /* Check for NaN's. Note that this code does not depend on us being
434 on an IEEE conforming system. It only depends on the target
435 machine using IEEE representation. This means (a)
436 cross-debugging works right, and (2) IEEE_FLOAT can (and should)
437 be defined for systems like the 68881, which uses IEEE
438 representation, but is not IEEE conforming. */
441 unsigned long low
, high
;
442 /* Is the sign bit 0? */
444 /* Is it is a NaN (i.e. the exponent is all ones and
445 the fraction is nonzero)? */
450 /* It's single precision. */
451 /* Assume that floating point byte order is the same as
452 integer byte order. */
453 low
= extract_unsigned_integer (valaddr
, 4);
454 nonnegative
= ((low
& 0x80000000) == 0);
455 is_nan
= ((((low
>> 23) & 0xFF) == 0xFF)
456 && 0 != (low
& 0x7FFFFF));
462 /* It's double precision. Get the high and low words. */
464 /* Assume that floating point byte order is the same as
465 integer byte order. */
466 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
468 low
= extract_unsigned_integer (valaddr
+ 4, 4);
469 high
= extract_unsigned_integer (valaddr
, 4);
473 low
= extract_unsigned_integer (valaddr
, 4);
474 high
= extract_unsigned_integer (valaddr
+ 4, 4);
476 nonnegative
= ((high
& 0x80000000) == 0);
477 is_nan
= (((high
>> 20) & 0x7ff) == 0x7ff
478 && ! ((((high
& 0xfffff) == 0)) && (low
== 0)));
482 /* Extended. We can't detect NaNs for extendeds yet. Also note
483 that currently extendeds get nuked to double in
484 REGISTER_CONVERTIBLE. */
489 /* The meaning of the sign and fraction is not defined by IEEE.
490 But the user might know what they mean. For example, they
491 (in an implementation-defined manner) distinguish between
492 signaling and quiet NaN's. */
494 fprintf_filtered (stream
, "-NaN(0x%lx%.8lx)" + nonnegative
,
497 fprintf_filtered (stream
, "-NaN(0x%lx)" + nonnegative
, low
);
501 #endif /* IEEE_FLOAT. */
503 doub
= unpack_double (type
, valaddr
, &inv
);
506 fprintf_filtered (stream
, "<invalid float value>");
510 if (len
< sizeof (double))
511 fprintf_filtered (stream
, "%.9g", (double) doub
);
512 else if (len
== sizeof (double))
513 fprintf_filtered (stream
, "%.17g", (double) doub
);
515 #ifdef PRINTF_HAS_LONG_DOUBLE
516 fprintf_filtered (stream
, "%.35Lg", doub
);
518 /* This at least wins with values that are representable as doubles */
519 fprintf_filtered (stream
, "%.17g", (double) doub
);
523 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
526 print_hex_chars (stream
, valaddr
, len
)
528 unsigned char *valaddr
;
533 /* FIXME: We should be not printing leading zeroes in most cases. */
535 fprintf_filtered (stream
, local_hex_format_prefix ());
536 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
542 fprintf_filtered (stream
, "%02x", *p
);
547 for (p
= valaddr
+ len
- 1;
551 fprintf_filtered (stream
, "%02x", *p
);
554 fprintf_filtered (stream
, local_hex_format_suffix ());
557 /* Called by various <lang>_val_print routines to print elements of an
558 array in the form "<elem1>, <elem2>, <elem3>, ...".
560 (FIXME?) Assumes array element separator is a comma, which is correct
561 for all languages currently handled.
562 (FIXME?) Some languages have a notation for repeated array elements,
563 perhaps we should try to use that notation when appropriate.
567 val_print_array_elements (type
, valaddr
, address
, stream
, format
, deref_ref
,
576 enum val_prettyprint pretty
;
579 unsigned int things_printed
= 0;
581 struct type
*elttype
;
583 /* Position of the array element we are examining to see
584 whether it is repeated. */
586 /* Number of repetitions we have detected so far. */
589 elttype
= TYPE_TARGET_TYPE (type
);
590 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
591 len
= TYPE_LENGTH (type
) / eltlen
;
593 annotate_array_section_begin (i
, elttype
);
595 for (; i
< len
&& things_printed
< print_max
; i
++)
599 if (prettyprint_arrays
)
601 fprintf_filtered (stream
, ",\n");
602 print_spaces_filtered (2 + 2 * recurse
, stream
);
606 fprintf_filtered (stream
, ", ");
609 wrap_here (n_spaces (2 + 2 * recurse
));
613 while ((rep1
< len
) &&
614 !memcmp (valaddr
+ i
* eltlen
, valaddr
+ rep1
* eltlen
, eltlen
))
620 if (reps
> repeat_count_threshold
)
622 val_print (elttype
, valaddr
+ i
* eltlen
, 0, stream
, format
,
623 deref_ref
, recurse
+ 1, pretty
);
624 annotate_elt_rep (reps
);
625 fprintf_filtered (stream
, " <repeats %u times>", reps
);
626 annotate_elt_rep_end ();
629 things_printed
+= repeat_count_threshold
;
633 val_print (elttype
, valaddr
+ i
* eltlen
, 0, stream
, format
,
634 deref_ref
, recurse
+ 1, pretty
);
639 annotate_array_section_end ();
642 fprintf_filtered (stream
, "...");
646 /* Print a string from the inferior, starting at ADDR and printing up to LEN
647 characters, to STREAM. If LEN is zero, printing stops at the first null
648 byte, otherwise printing proceeds (including null bytes) until either
649 print_max or LEN characters have been printed, whichever is smaller. */
651 /* FIXME: All callers supply LEN of zero. Supplying a non-zero LEN is
652 pointless, this routine just then becomes a convoluted version of
653 target_read_memory_partial. Removing all the LEN stuff would simplify
654 this routine enormously.
656 FIXME: Use target_read_string. */
659 val_print_string (addr
, len
, stream
)
664 int force_ellipsis
= 0; /* Force ellipsis to be printed if nonzero. */
665 int errcode
; /* Errno returned from bad reads. */
666 unsigned int fetchlimit
; /* Maximum number of bytes to fetch. */
667 unsigned int nfetch
; /* Bytes to fetch / bytes fetched. */
668 unsigned int chunksize
; /* Size of each fetch, in bytes. */
669 unsigned int bufsize
; /* Size of current fetch buffer. */
670 char *buffer
= NULL
; /* Dynamically growable fetch buffer. */
671 char *bufptr
; /* Pointer to next available byte in buffer. */
672 char *limit
; /* First location past end of fetch buffer. */
673 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
674 char peekchar
; /* Place into which we can read one char. */
676 /* First we need to figure out the limit on the number of characters we are
677 going to attempt to fetch and print. This is actually pretty simple. If
678 LEN is nonzero, then the limit is the minimum of LEN and print_max. If
679 LEN is zero, then the limit is print_max. This is true regardless of
680 whether print_max is zero, UINT_MAX (unlimited), or something in between,
681 because finding the null byte (or available memory) is what actually
684 fetchlimit
= (len
== 0 ? print_max
: min (len
, print_max
));
686 /* Now decide how large of chunks to try to read in one operation. This
687 is also pretty simple. If LEN is nonzero, then we want fetchlimit bytes,
688 so we might as well read them all in one operation. If LEN is zero, we
689 are looking for a null terminator to end the fetching, so we might as
690 well read in blocks that are large enough to be efficient, but not so
691 large as to be slow if fetchlimit happens to be large. So we choose the
692 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
693 200 is way too big for remote debugging over a serial line. */
695 chunksize
= (len
== 0 ? min (8, fetchlimit
) : fetchlimit
);
697 /* Loop until we either have all the characters to print, or we encounter
698 some error, such as bumping into the end of the address space. */
703 /* Figure out how much to fetch this time, and grow the buffer to fit. */
704 nfetch
= min (chunksize
, fetchlimit
- bufsize
);
708 buffer
= (char *) xmalloc (bufsize
);
713 discard_cleanups (old_chain
);
714 buffer
= (char *) xrealloc (buffer
, bufsize
);
715 bufptr
= buffer
+ bufsize
- nfetch
;
717 old_chain
= make_cleanup (free
, buffer
);
719 /* Read as much as we can. */
720 nfetch
= target_read_memory_partial (addr
, bufptr
, nfetch
, &errcode
);
728 /* Scan this chunk for the null byte that terminates the string
729 to print. If found, we don't need to fetch any more. Note
730 that bufptr is explicitly left pointing at the next character
731 after the null byte, or at the next character after the end of
733 limit
= bufptr
+ nfetch
;
734 while (bufptr
< limit
)
738 if (bufptr
[-1] == '\0')
740 /* We don't care about any error which happened after
741 the NULL terminator. */
747 } while (errcode
== 0 /* no error */
748 && bufsize
< fetchlimit
/* no overrun */
749 && !(len
== 0 && *(bufptr
- 1) == '\0')); /* no null term */
751 /* bufptr and addr now point immediately beyond the last byte which we
752 consider part of the string (including a '\0' which ends the string). */
754 /* We now have either successfully filled the buffer to fetchlimit, or
755 terminated early due to an error or finding a null byte when LEN is
758 if (len
== 0 && bufptr
> buffer
&& *(bufptr
- 1) != '\0')
760 /* We didn't find a null terminator we were looking for. Attempt
761 to peek at the next character. If not successful, or it is not
762 a null byte, then force ellipsis to be printed. */
763 if (target_read_memory (addr
, &peekchar
, 1) != 0 || peekchar
!= '\0')
768 else if ((len
!= 0 && errcode
!= 0) || (len
> bufptr
- buffer
))
770 /* Getting an error when we have a requested length, or fetching less
771 than the number of characters actually requested, always make us
778 /* If we get an error before fetching anything, don't print a string.
779 But if we fetch something and then get an error, print the string
780 and then the error message. */
781 if (errcode
== 0 || bufptr
> buffer
)
785 fputs_filtered (" ", stream
);
787 LA_PRINT_STRING (stream
, buffer
, bufptr
- buffer
, force_ellipsis
);
794 fprintf_filtered (stream
, " <Address ");
795 print_address_numeric (addr
, 1, stream
);
796 fprintf_filtered (stream
, " out of bounds>");
800 fprintf_filtered (stream
, " <Error reading address ");
801 print_address_numeric (addr
, 1, stream
);
802 fprintf_filtered (stream
, ": %s>", safe_strerror (errcode
));
806 do_cleanups (old_chain
);
807 return (bufptr
- buffer
);
811 /* Validate an input or output radix setting, and make sure the user
812 knows what they really did here. Radix setting is confusing, e.g.
813 setting the input radix to "10" never changes it! */
817 set_input_radix (args
, from_tty
, c
)
820 struct cmd_list_element
*c
;
822 set_input_radix_1 (from_tty
, *(unsigned *)c
->var
);
827 set_input_radix_1 (from_tty
, radix
)
831 /* We don't currently disallow any input radix except 0 or 1, which don't
832 make any mathematical sense. In theory, we can deal with any input
833 radix greater than 1, even if we don't have unique digits for every
834 value from 0 to radix-1, but in practice we lose on large radix values.
835 We should either fix the lossage or restrict the radix range more.
840 error ("Nonsense input radix ``decimal %u''; input radix unchanged.",
846 printf_filtered ("Input radix now set to decimal %u, hex %x, octal %o.\n",
847 radix
, radix
, radix
);
853 set_output_radix (args
, from_tty
, c
)
856 struct cmd_list_element
*c
;
858 set_output_radix_1 (from_tty
, *(unsigned *)c
->var
);
862 set_output_radix_1 (from_tty
, radix
)
866 /* Validate the radix and disallow ones that we aren't prepared to
867 handle correctly, leaving the radix unchanged. */
871 output_format
= 'x'; /* hex */
874 output_format
= 0; /* decimal */
877 output_format
= 'o'; /* octal */
880 error ("Unsupported output radix ``decimal %u''; output radix unchanged.",
883 output_radix
= radix
;
886 printf_filtered ("Output radix now set to decimal %u, hex %x, octal %o.\n",
887 radix
, radix
, radix
);
891 /* Set both the input and output radix at once. Try to set the output radix
892 first, since it has the most restrictive range. An radix that is valid as
893 an output radix is also valid as an input radix.
895 It may be useful to have an unusual input radix. If the user wishes to
896 set an input radix that is not valid as an output radix, he needs to use
897 the 'set input-radix' command. */
900 set_radix (arg
, from_tty
)
906 radix
= (arg
== NULL
) ? 10 : parse_and_eval_address (arg
);
907 set_output_radix_1 (0, radix
);
908 set_input_radix_1 (0, radix
);
911 printf_filtered ("Input and output radices now set to decimal %u, hex %x, octal %o.\n",
912 radix
, radix
, radix
);
916 /* Show both the input and output radices. */
920 show_radix (arg
, from_tty
)
926 if (input_radix
== output_radix
)
928 printf_filtered ("Input and output radices set to decimal %u, hex %x, octal %o.\n",
929 input_radix
, input_radix
, input_radix
);
933 printf_filtered ("Input radix set to decimal %u, hex %x, octal %o.\n",
934 input_radix
, input_radix
, input_radix
);
935 printf_filtered ("Output radix set to decimal %u, hex %x, octal %o.\n",
936 output_radix
, output_radix
, output_radix
);
944 set_print (arg
, from_tty
)
949 "\"set print\" must be followed by the name of a print subcommand.\n");
950 help_list (setprintlist
, "set print ", -1, gdb_stdout
);
955 show_print (args
, from_tty
)
959 cmd_show_list (showprintlist
, from_tty
, "");
963 _initialize_valprint ()
965 struct cmd_list_element
*c
;
967 add_prefix_cmd ("print", no_class
, set_print
,
968 "Generic command for setting how things print.",
969 &setprintlist
, "set print ", 0, &setlist
);
970 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
971 /* prefer set print to set prompt */
972 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
);
974 add_prefix_cmd ("print", no_class
, show_print
,
975 "Generic command for showing print settings.",
976 &showprintlist
, "show print ", 0, &showlist
);
977 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
978 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
981 (add_set_cmd ("elements", no_class
, var_uinteger
, (char *)&print_max
,
982 "Set limit on string chars or array elements to print.\n\
983 \"set print elements 0\" causes there to be no limit.",
988 (add_set_cmd ("null-stop", no_class
, var_boolean
,
989 (char *)&stop_print_at_null
,
990 "Set printing of char arrays to stop at first null char.",
995 (add_set_cmd ("repeats", no_class
, var_uinteger
,
996 (char *)&repeat_count_threshold
,
997 "Set threshold for repeated print elements.\n\
998 \"set print repeats 0\" causes all elements to be individually printed.",
1003 (add_set_cmd ("pretty", class_support
, var_boolean
,
1004 (char *)&prettyprint_structs
,
1005 "Set prettyprinting of structures.",
1010 (add_set_cmd ("union", class_support
, var_boolean
, (char *)&unionprint
,
1011 "Set printing of unions interior to structures.",
1016 (add_set_cmd ("array", class_support
, var_boolean
,
1017 (char *)&prettyprint_arrays
,
1018 "Set prettyprinting of arrays.",
1023 (add_set_cmd ("address", class_support
, var_boolean
, (char *)&addressprint
,
1024 "Set printing of addresses.",
1028 c
= add_set_cmd ("input-radix", class_support
, var_uinteger
,
1029 (char *)&input_radix
,
1030 "Set default input radix for entering numbers.",
1032 add_show_from_set (c
, &showlist
);
1033 c
->function
.sfunc
= set_input_radix
;
1035 c
= add_set_cmd ("output-radix", class_support
, var_uinteger
,
1036 (char *)&output_radix
,
1037 "Set default output radix for printing of values.",
1039 add_show_from_set (c
, &showlist
);
1040 c
->function
.sfunc
= set_output_radix
;
1042 /* The "set radix" and "show radix" commands are special in that they are
1043 like normal set and show commands but allow two normally independent
1044 variables to be either set or shown with a single command. So the
1045 usual add_set_cmd() and add_show_from_set() commands aren't really
1047 add_cmd ("radix", class_support
, set_radix
,
1048 "Set default input and output number radices.\n\
1049 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
1050 Without an argument, sets both radices back to the default value of 10.",
1052 add_cmd ("radix", class_support
, show_radix
,
1053 "Show the default input and output number radices.\n\
1054 Use 'show input-radix' or 'show output-radix' to independently show each.",
1057 /* Give people the defaults which they are used to. */
1058 prettyprint_structs
= 0;
1059 prettyprint_arrays
= 0;
1062 print_max
= PRINT_MAX_DEFAULT
;
This page took 0.060543 seconds and 4 git commands to generate.