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"
36 /* Prototypes for local functions */
39 print_hex_chars
PARAMS ((GDB_FILE
*, unsigned char *, unsigned int));
42 show_print
PARAMS ((char *, int));
45 set_print
PARAMS ((char *, int));
48 set_radix
PARAMS ((char *, int));
51 show_radix
PARAMS ((char *, int));
54 set_input_radix
PARAMS ((char *, int, struct cmd_list_element
*));
57 set_input_radix_1
PARAMS ((int, unsigned));
60 set_output_radix
PARAMS ((char *, int, struct cmd_list_element
*));
63 set_output_radix_1
PARAMS ((int, unsigned));
65 /* Maximum number of chars to print for a string pointer value or vector
66 contents, or UINT_MAX for no limit. Note that "set print elements 0"
67 stores UINT_MAX in print_max, which displays in a show command as
70 unsigned int print_max
;
71 #define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
73 /* Default input and output radixes, and output format letter. */
75 unsigned input_radix
= 10;
76 unsigned output_radix
= 10;
77 int output_format
= 0;
79 /* Print repeat counts if there are more than this many repetitions of an
80 element in an array. Referenced by the low level language dependent
83 unsigned int repeat_count_threshold
= 10;
85 /* If nonzero, stops printing of char arrays at first null. */
87 int stop_print_at_null
;
89 /* Controls pretty printing of structures. */
91 int prettyprint_structs
;
93 /* Controls pretty printing of arrays. */
95 int prettyprint_arrays
;
97 /* If nonzero, causes unions inside structures or other unions to be
100 int unionprint
; /* Controls printing of nested unions. */
102 /* If nonzero, causes machine addresses to be printed in certain contexts. */
104 int addressprint
; /* Controls printing of machine addresses */
107 /* Print data of type TYPE located at VALADDR (within GDB), which came from
108 the inferior at address ADDRESS, onto stdio stream STREAM according to
109 FORMAT (a letter, or 0 for natural format using TYPE).
111 If DEREF_REF is nonzero, then dereference references, otherwise just print
114 The PRETTY parameter controls prettyprinting.
116 If the data are a string pointer, returns the number of string characters
119 FIXME: The data at VALADDR is in target byte order. If gdb is ever
120 enhanced to be able to debug more than the single target it was compiled
121 for (specific CPU type and thus specific target byte ordering), then
122 either the print routines are going to have to take this into account,
123 or the data is going to have to be passed into here already converted
124 to the host byte ordering, whichever is more convenient. */
128 val_print (type
, valaddr
, address
, stream
, format
, deref_ref
, recurse
, pretty
)
136 enum val_prettyprint pretty
;
138 struct type
*real_type
= check_typedef (type
);
139 if (pretty
== Val_pretty_default
)
141 pretty
= prettyprint_structs
? Val_prettyprint
: Val_no_prettyprint
;
146 /* Ensure that the type is complete and not just a stub. If the type is
147 only a stub and we can't find and substitute its complete type, then
148 print appropriate string and return. */
150 if (TYPE_FLAGS (real_type
) & TYPE_FLAG_STUB
151 || TYPE_LENGTH (real_type
) == 0)
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 TYPE_CODE_INT's */
190 val_print_type_code_int (type
, valaddr
, stream
)
196 /* Pointer to first (i.e. lowest address) nonzero character. */
200 if (TYPE_LENGTH (type
) > sizeof (LONGEST
))
202 if (TYPE_UNSIGNED (type
))
204 /* First figure out whether the number in fact has zeros
205 in all its bytes more significant than least significant
206 sizeof (LONGEST) ones. */
207 len
= TYPE_LENGTH (type
);
209 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
212 len
> sizeof (LONGEST
) && p
< valaddr
+ TYPE_LENGTH (type
);
228 first_addr
= valaddr
;
229 for (p
= valaddr
+ TYPE_LENGTH (type
) - 1;
230 len
> sizeof (LONGEST
) && p
>= valaddr
;
244 if (len
<= sizeof (LONGEST
))
246 /* The most significant bytes are zero, so we can just get
247 the least significant sizeof (LONGEST) bytes and print it
249 print_longest (stream
, 'u', 0,
250 extract_unsigned_integer (first_addr
,
255 /* It is big, so print it in hex. */
256 print_hex_chars (stream
, (unsigned char *) first_addr
, len
);
261 /* Signed. One could assume two's complement (a reasonable
262 assumption, I think) and do better than this. */
263 print_hex_chars (stream
, (unsigned char *) valaddr
,
269 #ifdef PRINT_TYPELESS_INTEGER
270 PRINT_TYPELESS_INTEGER (stream
, type
, unpack_long (type
, valaddr
));
272 print_longest (stream
, TYPE_UNSIGNED (type
) ? 'u' : 'd', 0,
273 unpack_long (type
, valaddr
));
278 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
279 The raison d'etre of this function is to consolidate printing of LONG_LONG's
280 into this one function. Some platforms have long longs but don't have a
281 printf() that supports "ll" in the format string. We handle these by seeing
282 if the number is actually a long, and if not we just bail out and print the
283 number in hex. The format chars b,h,w,g are from
284 print_scalar_formatted(). If USE_LOCAL, format it according to the current
285 language (this should be used for most integers which GDB prints, the
286 exception is things like protocols where the format of the integer is
287 a protocol thing, not a user-visible thing). */
290 print_longest (stream
, format
, use_local
, val_long
)
296 #if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
299 vtop
= val_long
>> (sizeof (long) * HOST_CHAR_BIT
);
300 vbot
= (long) val_long
;
302 if ((format
== 'd' && (val_long
< INT_MIN
|| val_long
> INT_MAX
))
303 || ((format
== 'u' || format
== 'x') && (unsigned long long)val_long
> UINT_MAX
))
305 fprintf_filtered (stream
, "0x%lx%08lx", vtop
, vbot
);
310 #ifdef PRINTF_HAS_LONG_LONG
314 fprintf_filtered (stream
,
315 use_local
? local_decimal_format_custom ("ll")
320 fprintf_filtered (stream
, "%llu", val_long
);
323 fprintf_filtered (stream
,
324 use_local
? local_hex_format_custom ("ll")
329 fprintf_filtered (stream
,
330 use_local
? local_octal_format_custom ("ll")
335 fprintf_filtered (stream
, local_hex_format_custom ("02ll"), val_long
);
338 fprintf_filtered (stream
, local_hex_format_custom ("04ll"), val_long
);
341 fprintf_filtered (stream
, local_hex_format_custom ("08ll"), val_long
);
344 fprintf_filtered (stream
, local_hex_format_custom ("016ll"), val_long
);
349 #else /* !PRINTF_HAS_LONG_LONG */
350 /* In the following it is important to coerce (val_long) to a long. It does
351 nothing if !LONG_LONG, but it will chop off the top half (which we know
352 we can ignore) if the host supports long longs. */
357 fprintf_filtered (stream
,
358 use_local
? local_decimal_format_custom ("l")
363 fprintf_filtered (stream
, "%lu", (unsigned long) val_long
);
366 fprintf_filtered (stream
,
367 use_local
? local_hex_format_custom ("l")
372 fprintf_filtered (stream
,
373 use_local
? local_octal_format_custom ("l")
378 fprintf_filtered (stream
, local_hex_format_custom ("02l"),
382 fprintf_filtered (stream
, local_hex_format_custom ("04l"),
386 fprintf_filtered (stream
, local_hex_format_custom ("08l"),
390 fprintf_filtered (stream
, local_hex_format_custom ("016l"),
396 #endif /* !PRINTF_HAS_LONG_LONG */
399 /* This used to be a macro, but I don't think it is called often enough
400 to merit such treatment. */
401 /* Convert a LONGEST to an int. This is used in contexts (e.g. number of
402 arguments to a function, number in a value history, register number, etc.)
403 where the value must not be larger than can fit in an int. */
410 /* This check is in case a system header has botched the
411 definition of INT_MIN, like on BSDI. */
412 if (sizeof (LONGEST
) <= sizeof (int))
415 if (arg
> INT_MAX
|| arg
< INT_MIN
)
416 error ("Value out of range.");
421 /* Print a floating point value of type TYPE, pointed to in GDB by VALADDR,
425 print_floating (valaddr
, type
, stream
)
432 unsigned len
= TYPE_LENGTH (type
);
434 #if defined (IEEE_FLOAT)
436 /* Check for NaN's. Note that this code does not depend on us being
437 on an IEEE conforming system. It only depends on the target
438 machine using IEEE representation. This means (a)
439 cross-debugging works right, and (2) IEEE_FLOAT can (and should)
440 be defined for systems like the 68881, which uses IEEE
441 representation, but is not IEEE conforming. */
444 unsigned long low
, high
;
445 /* Is the sign bit 0? */
447 /* Is it is a NaN (i.e. the exponent is all ones and
448 the fraction is nonzero)? */
453 /* It's single precision. */
454 /* Assume that floating point byte order is the same as
455 integer byte order. */
456 low
= extract_unsigned_integer (valaddr
, 4);
457 nonnegative
= ((low
& 0x80000000) == 0);
458 is_nan
= ((((low
>> 23) & 0xFF) == 0xFF)
459 && 0 != (low
& 0x7FFFFF));
465 /* It's double precision. Get the high and low words. */
467 /* Assume that floating point byte order is the same as
468 integer byte order. */
469 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
471 low
= extract_unsigned_integer (valaddr
+ 4, 4);
472 high
= extract_unsigned_integer (valaddr
, 4);
476 low
= extract_unsigned_integer (valaddr
, 4);
477 high
= extract_unsigned_integer (valaddr
+ 4, 4);
479 nonnegative
= ((high
& 0x80000000) == 0);
480 is_nan
= (((high
>> 20) & 0x7ff) == 0x7ff
481 && ! ((((high
& 0xfffff) == 0)) && (low
== 0)));
485 /* Extended. We can't detect NaNs for extendeds yet. Also note
486 that currently extendeds get nuked to double in
487 REGISTER_CONVERTIBLE. */
492 /* The meaning of the sign and fraction is not defined by IEEE.
493 But the user might know what they mean. For example, they
494 (in an implementation-defined manner) distinguish between
495 signaling and quiet NaN's. */
497 fprintf_filtered (stream
, "-NaN(0x%lx%.8lx)" + nonnegative
,
500 fprintf_filtered (stream
, "-NaN(0x%lx)" + nonnegative
, low
);
504 #endif /* IEEE_FLOAT. */
506 doub
= unpack_double (type
, valaddr
, &inv
);
508 fprintf_filtered (stream
, "<invalid float value>");
510 fprintf_filtered (stream
, len
<= sizeof(float) ? "%.9g" : "%.17g", doub
);
513 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
516 print_hex_chars (stream
, valaddr
, len
)
518 unsigned char *valaddr
;
523 /* FIXME: We should be not printing leading zeroes in most cases. */
525 fprintf_filtered (stream
, local_hex_format_prefix ());
526 if (TARGET_BYTE_ORDER
== BIG_ENDIAN
)
532 fprintf_filtered (stream
, "%02x", *p
);
537 for (p
= valaddr
+ len
- 1;
541 fprintf_filtered (stream
, "%02x", *p
);
544 fprintf_filtered (stream
, local_hex_format_suffix ());
547 /* Called by various <lang>_val_print routines to print elements of an
548 array in the form "<elem1>, <elem2>, <elem3>, ...".
550 (FIXME?) Assumes array element separator is a comma, which is correct
551 for all languages currently handled.
552 (FIXME?) Some languages have a notation for repeated array elements,
553 perhaps we should try to use that notation when appropriate.
557 val_print_array_elements (type
, valaddr
, address
, stream
, format
, deref_ref
,
566 enum val_prettyprint pretty
;
569 unsigned int things_printed
= 0;
571 struct type
*elttype
;
573 /* Position of the array element we are examining to see
574 whether it is repeated. */
576 /* Number of repetitions we have detected so far. */
579 elttype
= TYPE_TARGET_TYPE (type
);
580 eltlen
= TYPE_LENGTH (check_typedef (elttype
));
581 len
= TYPE_LENGTH (type
) / eltlen
;
583 annotate_array_section_begin (i
, elttype
);
585 for (; i
< len
&& things_printed
< print_max
; i
++)
589 if (prettyprint_arrays
)
591 fprintf_filtered (stream
, ",\n");
592 print_spaces_filtered (2 + 2 * recurse
, stream
);
596 fprintf_filtered (stream
, ", ");
599 wrap_here (n_spaces (2 + 2 * recurse
));
603 while ((rep1
< len
) &&
604 !memcmp (valaddr
+ i
* eltlen
, valaddr
+ rep1
* eltlen
, eltlen
))
610 if (reps
> repeat_count_threshold
)
612 val_print (elttype
, valaddr
+ i
* eltlen
, 0, stream
, format
,
613 deref_ref
, recurse
+ 1, pretty
);
614 annotate_elt_rep (reps
);
615 fprintf_filtered (stream
, " <repeats %u times>", reps
);
616 annotate_elt_rep_end ();
619 things_printed
+= repeat_count_threshold
;
623 val_print (elttype
, valaddr
+ i
* eltlen
, 0, stream
, format
,
624 deref_ref
, recurse
+ 1, pretty
);
629 annotate_array_section_end ();
632 fprintf_filtered (stream
, "...");
636 /* Print a string from the inferior, starting at ADDR and printing up to LEN
637 characters, to STREAM. If LEN is zero, printing stops at the first null
638 byte, otherwise printing proceeds (including null bytes) until either
639 print_max or LEN characters have been printed, whichever is smaller. */
641 /* FIXME: All callers supply LEN of zero. Supplying a non-zero LEN is
642 pointless, this routine just then becomes a convoluted version of
643 target_read_memory_partial. Removing all the LEN stuff would simplify
644 this routine enormously.
646 FIXME: Use target_read_string. */
649 val_print_string (addr
, len
, stream
)
654 int force_ellipsis
= 0; /* Force ellipsis to be printed if nonzero. */
655 int errcode
; /* Errno returned from bad reads. */
656 unsigned int fetchlimit
; /* Maximum number of bytes to fetch. */
657 unsigned int nfetch
; /* Bytes to fetch / bytes fetched. */
658 unsigned int chunksize
; /* Size of each fetch, in bytes. */
659 int bufsize
; /* Size of current fetch buffer. */
660 char *buffer
= NULL
; /* Dynamically growable fetch buffer. */
661 char *bufptr
; /* Pointer to next available byte in buffer. */
662 char *limit
; /* First location past end of fetch buffer. */
663 struct cleanup
*old_chain
= NULL
; /* Top of the old cleanup chain. */
664 char peekchar
; /* Place into which we can read one char. */
666 /* First we need to figure out the limit on the number of characters we are
667 going to attempt to fetch and print. This is actually pretty simple. If
668 LEN is nonzero, then the limit is the minimum of LEN and print_max. If
669 LEN is zero, then the limit is print_max. This is true regardless of
670 whether print_max is zero, UINT_MAX (unlimited), or something in between,
671 because finding the null byte (or available memory) is what actually
674 fetchlimit
= (len
== 0 ? print_max
: min (len
, print_max
));
676 /* Now decide how large of chunks to try to read in one operation. This
677 is also pretty simple. If LEN is nonzero, then we want fetchlimit bytes,
678 so we might as well read them all in one operation. If LEN is zero, we
679 are looking for a null terminator to end the fetching, so we might as
680 well read in blocks that are large enough to be efficient, but not so
681 large as to be slow if fetchlimit happens to be large. So we choose the
682 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
683 200 is way too big for remote debugging over a serial line. */
685 chunksize
= (len
== 0 ? min (8, fetchlimit
) : fetchlimit
);
687 /* Loop until we either have all the characters to print, or we encounter
688 some error, such as bumping into the end of the address space. */
693 /* Figure out how much to fetch this time, and grow the buffer to fit. */
694 nfetch
= min (chunksize
, fetchlimit
- bufsize
);
698 buffer
= (char *) xmalloc (bufsize
);
703 discard_cleanups (old_chain
);
704 buffer
= (char *) xrealloc (buffer
, bufsize
);
705 bufptr
= buffer
+ bufsize
- nfetch
;
707 old_chain
= make_cleanup (free
, buffer
);
709 /* Read as much as we can. */
710 nfetch
= target_read_memory_partial (addr
, bufptr
, nfetch
, &errcode
);
718 /* Scan this chunk for the null byte that terminates the string
719 to print. If found, we don't need to fetch any more. Note
720 that bufptr is explicitly left pointing at the next character
721 after the null byte, or at the next character after the end of
723 limit
= bufptr
+ nfetch
;
724 while (bufptr
< limit
)
728 if (bufptr
[-1] == '\0')
730 /* We don't care about any error which happened after
731 the NULL terminator. */
737 } while (errcode
== 0 /* no error */
738 && bufsize
< fetchlimit
/* no overrun */
739 && !(len
== 0 && *(bufptr
- 1) == '\0')); /* no null term */
741 /* bufptr and addr now point immediately beyond the last byte which we
742 consider part of the string (including a '\0' which ends the string). */
744 /* We now have either successfully filled the buffer to fetchlimit, or
745 terminated early due to an error or finding a null byte when LEN is
748 if (len
== 0 && bufptr
> buffer
&& *(bufptr
- 1) != '\0')
750 /* We didn't find a null terminator we were looking for. Attempt
751 to peek at the next character. If not successful, or it is not
752 a null byte, then force ellipsis to be printed. */
753 if (target_read_memory (addr
, &peekchar
, 1) != 0 || peekchar
!= '\0')
758 else if ((len
!= 0 && errcode
!= 0) || (len
> bufptr
- buffer
))
760 /* Getting an error when we have a requested length, or fetching less
761 than the number of characters actually requested, always make us
768 /* If we get an error before fetching anything, don't print a string.
769 But if we fetch something and then get an error, print the string
770 and then the error message. */
771 if (errcode
== 0 || bufptr
> buffer
)
775 fputs_filtered (" ", stream
);
777 LA_PRINT_STRING (stream
, buffer
, bufptr
- buffer
, force_ellipsis
);
784 fprintf_filtered (stream
, " <Address ");
785 print_address_numeric (addr
, 1, stream
);
786 fprintf_filtered (stream
, " out of bounds>");
790 fprintf_filtered (stream
, " <Error reading address ");
791 print_address_numeric (addr
, 1, stream
);
792 fprintf_filtered (stream
, ": %s>", safe_strerror (errcode
));
796 do_cleanups (old_chain
);
797 return (bufptr
- buffer
);
801 /* Validate an input or output radix setting, and make sure the user
802 knows what they really did here. Radix setting is confusing, e.g.
803 setting the input radix to "10" never changes it! */
807 set_input_radix (args
, from_tty
, c
)
810 struct cmd_list_element
*c
;
812 set_input_radix_1 (from_tty
, *(unsigned *)c
->var
);
817 set_input_radix_1 (from_tty
, radix
)
821 /* We don't currently disallow any input radix except 0 or 1, which don't
822 make any mathematical sense. In theory, we can deal with any input
823 radix greater than 1, even if we don't have unique digits for every
824 value from 0 to radix-1, but in practice we lose on large radix values.
825 We should either fix the lossage or restrict the radix range more.
830 error ("Nonsense input radix ``decimal %u''; input radix unchanged.",
836 printf_filtered ("Input radix now set to decimal %u, hex %x, octal %o.\n",
837 radix
, radix
, radix
);
843 set_output_radix (args
, from_tty
, c
)
846 struct cmd_list_element
*c
;
848 set_output_radix_1 (from_tty
, *(unsigned *)c
->var
);
852 set_output_radix_1 (from_tty
, radix
)
856 /* Validate the radix and disallow ones that we aren't prepared to
857 handle correctly, leaving the radix unchanged. */
861 output_format
= 'x'; /* hex */
864 output_format
= 0; /* decimal */
867 output_format
= 'o'; /* octal */
870 error ("Unsupported output radix ``decimal %u''; output radix unchanged.",
873 output_radix
= radix
;
876 printf_filtered ("Output radix now set to decimal %u, hex %x, octal %o.\n",
877 radix
, radix
, radix
);
881 /* Set both the input and output radix at once. Try to set the output radix
882 first, since it has the most restrictive range. An radix that is valid as
883 an output radix is also valid as an input radix.
885 It may be useful to have an unusual input radix. If the user wishes to
886 set an input radix that is not valid as an output radix, he needs to use
887 the 'set input-radix' command. */
890 set_radix (arg
, from_tty
)
896 radix
= (arg
== NULL
) ? 10 : parse_and_eval_address (arg
);
897 set_output_radix_1 (0, radix
);
898 set_input_radix_1 (0, radix
);
901 printf_filtered ("Input and output radices now set to decimal %u, hex %x, octal %o.\n",
902 radix
, radix
, radix
);
906 /* Show both the input and output radices. */
910 show_radix (arg
, from_tty
)
916 if (input_radix
== output_radix
)
918 printf_filtered ("Input and output radices set to decimal %u, hex %x, octal %o.\n",
919 input_radix
, input_radix
, input_radix
);
923 printf_filtered ("Input radix set to decimal %u, hex %x, octal %o.\n",
924 input_radix
, input_radix
, input_radix
);
925 printf_filtered ("Output radix set to decimal %u, hex %x, octal %o.\n",
926 output_radix
, output_radix
, output_radix
);
934 set_print (arg
, from_tty
)
939 "\"set print\" must be followed by the name of a print subcommand.\n");
940 help_list (setprintlist
, "set print ", -1, gdb_stdout
);
945 show_print (args
, from_tty
)
949 cmd_show_list (showprintlist
, from_tty
, "");
953 _initialize_valprint ()
955 struct cmd_list_element
*c
;
957 add_prefix_cmd ("print", no_class
, set_print
,
958 "Generic command for setting how things print.",
959 &setprintlist
, "set print ", 0, &setlist
);
960 add_alias_cmd ("p", "print", no_class
, 1, &setlist
);
961 /* prefer set print to set prompt */
962 add_alias_cmd ("pr", "print", no_class
, 1, &setlist
);
964 add_prefix_cmd ("print", no_class
, show_print
,
965 "Generic command for showing print settings.",
966 &showprintlist
, "show print ", 0, &showlist
);
967 add_alias_cmd ("p", "print", no_class
, 1, &showlist
);
968 add_alias_cmd ("pr", "print", no_class
, 1, &showlist
);
971 (add_set_cmd ("elements", no_class
, var_uinteger
, (char *)&print_max
,
972 "Set limit on string chars or array elements to print.\n\
973 \"set print elements 0\" causes there to be no limit.",
978 (add_set_cmd ("null-stop", no_class
, var_boolean
,
979 (char *)&stop_print_at_null
,
980 "Set printing of char arrays to stop at first null char.",
985 (add_set_cmd ("repeats", no_class
, var_uinteger
,
986 (char *)&repeat_count_threshold
,
987 "Set threshold for repeated print elements.\n\
988 \"set print repeats 0\" causes all elements to be individually printed.",
993 (add_set_cmd ("pretty", class_support
, var_boolean
,
994 (char *)&prettyprint_structs
,
995 "Set prettyprinting of structures.",
1000 (add_set_cmd ("union", class_support
, var_boolean
, (char *)&unionprint
,
1001 "Set printing of unions interior to structures.",
1006 (add_set_cmd ("array", class_support
, var_boolean
,
1007 (char *)&prettyprint_arrays
,
1008 "Set prettyprinting of arrays.",
1013 (add_set_cmd ("address", class_support
, var_boolean
, (char *)&addressprint
,
1014 "Set printing of addresses.",
1018 c
= add_set_cmd ("input-radix", class_support
, var_uinteger
,
1019 (char *)&input_radix
,
1020 "Set default input radix for entering numbers.",
1022 add_show_from_set (c
, &showlist
);
1023 c
->function
.sfunc
= set_input_radix
;
1025 c
= add_set_cmd ("output-radix", class_support
, var_uinteger
,
1026 (char *)&output_radix
,
1027 "Set default output radix for printing of values.",
1029 add_show_from_set (c
, &showlist
);
1030 c
->function
.sfunc
= set_output_radix
;
1032 /* The "set radix" and "show radix" commands are special in that they are
1033 like normal set and show commands but allow two normally independent
1034 variables to be either set or shown with a single command. So the
1035 usual add_set_cmd() and add_show_from_set() commands aren't really
1037 add_cmd ("radix", class_support
, set_radix
,
1038 "Set default input and output number radices.\n\
1039 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
1040 Without an argument, sets both radices back to the default value of 10.",
1042 add_cmd ("radix", class_support
, show_radix
,
1043 "Show the default input and output number radices.\n\
1044 Use 'show input-radix' or 'show output-radix' to independently show each.",
1047 /* Give people the defaults which they are used to. */
1048 prettyprint_structs
= 0;
1049 prettyprint_arrays
= 0;
1052 print_max
= PRINT_MAX_DEFAULT
;
This page took 0.05093 seconds and 4 git commands to generate.