]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blame - gdb/valprint.c
import gdb-1999-07-07 post reformat
[thirdparty/binutils-gdb.git] / gdb / valprint.c
CommitLineData
c906108c
SS
1/* Print values for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1998
c5aa993b 3 Free Software Foundation, Inc.
c906108c 4
c5aa993b 5 This file is part of GDB.
c906108c 6
c5aa993b
JM
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.
c906108c 11
c5aa993b
JM
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.
c906108c 16
c5aa993b
JM
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,
20 Boston, MA 02111-1307, USA. */
c906108c
SS
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 "obstack.h"
31#include "language.h"
32#include "demangle.h"
33#include "annotate.h"
34#include "valprint.h"
35
36#include <errno.h>
37
38/* Prototypes for local functions */
39
c5aa993b
JM
40static void print_hex_chars PARAMS ((GDB_FILE *, unsigned char *,
41 unsigned int));
c906108c
SS
42
43static void show_print PARAMS ((char *, int));
44
45static void set_print PARAMS ((char *, int));
46
47static void set_radix PARAMS ((char *, int));
48
49static void show_radix PARAMS ((char *, int));
50
51static void set_input_radix PARAMS ((char *, int, struct cmd_list_element *));
52
53static void set_input_radix_1 PARAMS ((int, unsigned));
54
55static void set_output_radix PARAMS ((char *, int, struct cmd_list_element *));
56
57static void set_output_radix_1 PARAMS ((int, unsigned));
58
59void _initialize_valprint PARAMS ((void));
60
61/* Maximum number of chars to print for a string pointer value or vector
62 contents, or UINT_MAX for no limit. Note that "set print elements 0"
63 stores UINT_MAX in print_max, which displays in a show command as
64 "unlimited". */
65
66unsigned int print_max;
67#define PRINT_MAX_DEFAULT 200 /* Start print_max off at this value. */
68
69/* Default input and output radixes, and output format letter. */
70
71unsigned input_radix = 10;
72unsigned output_radix = 10;
73int output_format = 0;
74
75/* Print repeat counts if there are more than this many repetitions of an
76 element in an array. Referenced by the low level language dependent
77 print routines. */
78
79unsigned int repeat_count_threshold = 10;
80
81/* If nonzero, stops printing of char arrays at first null. */
82
83int stop_print_at_null;
84
85/* Controls pretty printing of structures. */
86
87int prettyprint_structs;
88
89/* Controls pretty printing of arrays. */
90
91int prettyprint_arrays;
92
93/* If nonzero, causes unions inside structures or other unions to be
94 printed. */
95
96int unionprint; /* Controls printing of nested unions. */
97
98/* If nonzero, causes machine addresses to be printed in certain contexts. */
99
100int addressprint; /* Controls printing of machine addresses */
c906108c 101\f
c5aa993b 102
c906108c
SS
103/* Print data of type TYPE located at VALADDR (within GDB), which came from
104 the inferior at address ADDRESS, onto stdio stream STREAM according to
105 FORMAT (a letter, or 0 for natural format using TYPE).
106
107 If DEREF_REF is nonzero, then dereference references, otherwise just print
108 them like pointers.
109
110 The PRETTY parameter controls prettyprinting.
111
112 If the data are a string pointer, returns the number of string characters
113 printed.
114
115 FIXME: The data at VALADDR is in target byte order. If gdb is ever
116 enhanced to be able to debug more than the single target it was compiled
117 for (specific CPU type and thus specific target byte ordering), then
118 either the print routines are going to have to take this into account,
119 or the data is going to have to be passed into here already converted
120 to the host byte ordering, whichever is more convenient. */
121
122
123int
124val_print (type, valaddr, embedded_offset, address,
c5aa993b 125 stream, format, deref_ref, recurse, pretty)
c906108c
SS
126 struct type *type;
127 char *valaddr;
128 int embedded_offset;
129 CORE_ADDR address;
130 GDB_FILE *stream;
131 int format;
132 int deref_ref;
133 int recurse;
134 enum val_prettyprint pretty;
135{
136 struct type *real_type = check_typedef (type);
137 if (pretty == Val_pretty_default)
138 {
139 pretty = prettyprint_structs ? Val_prettyprint : Val_no_prettyprint;
140 }
c5aa993b 141
c906108c
SS
142 QUIT;
143
144 /* Ensure that the type is complete and not just a stub. If the type is
145 only a stub and we can't find and substitute its complete type, then
146 print appropriate string and return. */
147
148 if (TYPE_FLAGS (real_type) & TYPE_FLAG_STUB)
149 {
150 fprintf_filtered (stream, "<incomplete type>");
151 gdb_flush (stream);
152 return (0);
153 }
c5aa993b 154
c906108c 155 return (LA_VAL_PRINT (type, valaddr, embedded_offset, address,
c5aa993b 156 stream, format, deref_ref, recurse, pretty));
c906108c
SS
157}
158
159/* Print the value VAL in C-ish syntax on stream STREAM.
160 FORMAT is a format-letter, or 0 for print in natural format of data type.
161 If the object printed is a string pointer, returns
162 the number of string bytes printed. */
163
164int
165value_print (val, stream, format, pretty)
166 value_ptr val;
167 GDB_FILE *stream;
168 int format;
169 enum val_prettyprint pretty;
170{
171 if (val == 0)
172 {
173 printf_filtered ("<address of value unknown>");
174 return 0;
175 }
176 if (VALUE_OPTIMIZED_OUT (val))
177 {
178 printf_filtered ("<value optimized out>");
179 return 0;
180 }
181 return LA_VALUE_PRINT (val, stream, format, pretty);
182}
183
184/* Called by various <lang>_val_print routines to print
185 TYPE_CODE_INT's. TYPE is the type. VALADDR is the address of the
186 value. STREAM is where to print the value. */
187
188void
189val_print_type_code_int (type, valaddr, stream)
190 struct type *type;
191 char *valaddr;
192 GDB_FILE *stream;
193{
194 if (TYPE_LENGTH (type) > sizeof (LONGEST))
195 {
196 LONGEST val;
197
198 if (TYPE_UNSIGNED (type)
199 && extract_long_unsigned_integer (valaddr, TYPE_LENGTH (type),
200 &val))
201 {
202 print_longest (stream, 'u', 0, val);
203 }
204 else
205 {
206 /* Signed, or we couldn't turn an unsigned value into a
207 LONGEST. For signed values, one could assume two's
208 complement (a reasonable assumption, I think) and do
209 better than this. */
210 print_hex_chars (stream, (unsigned char *) valaddr,
211 TYPE_LENGTH (type));
212 }
213 }
214 else
215 {
216#ifdef PRINT_TYPELESS_INTEGER
217 PRINT_TYPELESS_INTEGER (stream, type, unpack_long (type, valaddr));
218#else
219 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0,
220 unpack_long (type, valaddr));
221#endif
222 }
223}
224
225/* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
226 The raison d'etre of this function is to consolidate printing of
227 LONG_LONG's into this one function. Some platforms have long longs but
228 don't have a printf() that supports "ll" in the format string. We handle
229 these by seeing if the number is representable as either a signed or
230 unsigned long, depending upon what format is desired, and if not we just
231 bail out and print the number in hex.
232
233 The format chars b,h,w,g are from print_scalar_formatted(). If USE_LOCAL,
234 format it according to the current language (this should be used for most
235 integers which GDB prints, the exception is things like protocols where
236 the format of the integer is a protocol thing, not a user-visible thing).
c5aa993b 237 */
c906108c
SS
238
239#if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
c5aa993b 240static void print_decimal PARAMS ((GDB_FILE * stream, char *sign, int use_local, ULONGEST val_ulong));
c906108c
SS
241static void
242print_decimal (stream, sign, use_local, val_ulong)
243 GDB_FILE *stream;
244 char *sign;
245 int use_local;
246 ULONGEST val_ulong;
247{
248 unsigned long temp[3];
249 int i = 0;
250 do
251 {
252 temp[i] = val_ulong % (1000 * 1000 * 1000);
253 val_ulong /= (1000 * 1000 * 1000);
254 i++;
255 }
256 while (val_ulong != 0 && i < (sizeof (temp) / sizeof (temp[0])));
257 switch (i)
258 {
259 case 1:
260 fprintf_filtered (stream, "%s%lu",
261 sign, temp[0]);
262 break;
263 case 2:
264 fprintf_filtered (stream, "%s%lu%09lu",
265 sign, temp[1], temp[0]);
266 break;
267 case 3:
268 fprintf_filtered (stream, "%s%lu%09lu%09lu",
269 sign, temp[2], temp[1], temp[0]);
270 break;
271 default:
272 abort ();
273 }
274 return;
275}
276#endif
277
278void
279print_longest (stream, format, use_local, val_long)
280 GDB_FILE *stream;
281 int format;
282 int use_local;
283 LONGEST val_long;
284{
285#if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
286 if (sizeof (long) < sizeof (LONGEST))
287 {
288 switch (format)
289 {
290 case 'd':
291 {
292 /* Print a signed value, that doesn't fit in a long */
293 if ((long) val_long != val_long)
294 {
295 if (val_long < 0)
296 print_decimal (stream, "-", use_local, -val_long);
297 else
298 print_decimal (stream, "", use_local, val_long);
299 return;
300 }
301 break;
302 }
303 case 'u':
304 {
305 /* Print an unsigned value, that doesn't fit in a long */
306 if ((unsigned long) val_long != (ULONGEST) val_long)
307 {
308 print_decimal (stream, "", use_local, val_long);
309 return;
310 }
311 break;
312 }
313 case 'x':
314 case 'o':
315 case 'b':
316 case 'h':
317 case 'w':
318 case 'g':
319 /* Print as unsigned value, must fit completely in unsigned long */
320 {
321 unsigned long temp = val_long;
322 if (temp != val_long)
323 {
324 /* Urk, can't represent value in long so print in hex.
325 Do shift in two operations so that if sizeof (long)
326 == sizeof (LONGEST) we can avoid warnings from
327 picky compilers about shifts >= the size of the
328 shiftee in bits */
329 unsigned long vbot = (unsigned long) val_long;
330 LONGEST temp = (val_long >> (sizeof (long) * HOST_CHAR_BIT - 1));
331 unsigned long vtop = temp >> 1;
332 fprintf_filtered (stream, "0x%lx%08lx", vtop, vbot);
333 return;
334 }
335 break;
336 }
337 }
338 }
339#endif
340
341#if defined (CC_HAS_LONG_LONG) && defined (PRINTF_HAS_LONG_LONG)
342 switch (format)
343 {
344 case 'd':
345 fprintf_filtered (stream,
346 use_local ? local_decimal_format_custom ("ll")
c5aa993b 347 : "%lld",
c906108c
SS
348 val_long);
349 break;
350 case 'u':
351 fprintf_filtered (stream, "%llu", val_long);
352 break;
353 case 'x':
354 fprintf_filtered (stream,
355 use_local ? local_hex_format_custom ("ll")
c5aa993b 356 : "%llx",
c906108c
SS
357 val_long);
358 break;
359 case 'o':
360 fprintf_filtered (stream,
361 use_local ? local_octal_format_custom ("ll")
c5aa993b 362 : "%llo",
c906108c
SS
363 val_long);
364 break;
365 case 'b':
366 fprintf_filtered (stream, local_hex_format_custom ("02ll"), val_long);
367 break;
368 case 'h':
369 fprintf_filtered (stream, local_hex_format_custom ("04ll"), val_long);
370 break;
371 case 'w':
372 fprintf_filtered (stream, local_hex_format_custom ("08ll"), val_long);
373 break;
374 case 'g':
375 fprintf_filtered (stream, local_hex_format_custom ("016ll"), val_long);
376 break;
377 default:
378 abort ();
379 }
c5aa993b 380#else /* !CC_HAS_LONG_LONG || !PRINTF_HAS_LONG_LONG */
c906108c
SS
381 /* In the following it is important to coerce (val_long) to a long. It does
382 nothing if !LONG_LONG, but it will chop off the top half (which we know
383 we can ignore) if the host supports long longs. */
384
385 switch (format)
386 {
387 case 'd':
388 fprintf_filtered (stream,
389 use_local ? local_decimal_format_custom ("l")
c5aa993b 390 : "%ld",
c906108c
SS
391 (long) val_long);
392 break;
393 case 'u':
394 fprintf_filtered (stream, "%lu", (unsigned long) val_long);
395 break;
396 case 'x':
397 fprintf_filtered (stream,
398 use_local ? local_hex_format_custom ("l")
c5aa993b 399 : "%lx",
c906108c
SS
400 (unsigned long) val_long);
401 break;
402 case 'o':
403 fprintf_filtered (stream,
404 use_local ? local_octal_format_custom ("l")
c5aa993b 405 : "%lo",
c906108c
SS
406 (unsigned long) val_long);
407 break;
408 case 'b':
409 fprintf_filtered (stream, local_hex_format_custom ("02l"),
410 (unsigned long) val_long);
411 break;
412 case 'h':
413 fprintf_filtered (stream, local_hex_format_custom ("04l"),
414 (unsigned long) val_long);
415 break;
416 case 'w':
417 fprintf_filtered (stream, local_hex_format_custom ("08l"),
418 (unsigned long) val_long);
419 break;
420 case 'g':
421 fprintf_filtered (stream, local_hex_format_custom ("016l"),
422 (unsigned long) val_long);
423 break;
424 default:
425 abort ();
426 }
427#endif /* CC_HAS_LONG_LONG || PRINTF_HAS_LONG_LONG */
428}
429
7a292a7a 430#if 0
c906108c
SS
431void
432strcat_longest (format, use_local, val_long, buf, buflen)
433 int format;
434 int use_local;
435 LONGEST val_long;
436 char *buf;
437 int buflen; /* ignored, for now */
438{
439#if defined (CC_HAS_LONG_LONG) && !defined (PRINTF_HAS_LONG_LONG)
440 long vtop, vbot;
441
442 vtop = val_long >> (sizeof (long) * HOST_CHAR_BIT);
443 vbot = (long) val_long;
444
445 if ((format == 'd' && (val_long < INT_MIN || val_long > INT_MAX))
c5aa993b 446 || ((format == 'u' || format == 'x') && (unsigned long long) val_long > UINT_MAX))
c906108c
SS
447 {
448 sprintf (buf, "0x%lx%08lx", vtop, vbot);
449 return;
450 }
451#endif
452
453#ifdef PRINTF_HAS_LONG_LONG
454 switch (format)
455 {
456 case 'd':
457 sprintf (buf,
c5aa993b 458 (use_local ? local_decimal_format_custom ("ll") : "%lld"),
c906108c
SS
459 val_long);
460 break;
461 case 'u':
c5aa993b 462 sprintf (buf, "%llu", val_long);
c906108c
SS
463 break;
464 case 'x':
465 sprintf (buf,
c5aa993b
JM
466 (use_local ? local_hex_format_custom ("ll") : "%llx"),
467
c906108c
SS
468 val_long);
469 break;
470 case 'o':
471 sprintf (buf,
c5aa993b 472 (use_local ? local_octal_format_custom ("ll") : "%llo"),
c906108c
SS
473 val_long);
474 break;
475 case 'b':
c5aa993b 476 sprintf (buf, local_hex_format_custom ("02ll"), val_long);
c906108c
SS
477 break;
478 case 'h':
c5aa993b 479 sprintf (buf, local_hex_format_custom ("04ll"), val_long);
c906108c
SS
480 break;
481 case 'w':
c5aa993b 482 sprintf (buf, local_hex_format_custom ("08ll"), val_long);
c906108c
SS
483 break;
484 case 'g':
c5aa993b 485 sprintf (buf, local_hex_format_custom ("016ll"), val_long);
c906108c
SS
486 break;
487 default:
488 abort ();
489 }
490#else /* !PRINTF_HAS_LONG_LONG */
491 /* In the following it is important to coerce (val_long) to a long. It does
492 nothing if !LONG_LONG, but it will chop off the top half (which we know
493 we can ignore) if the host supports long longs. */
494
495 switch (format)
496 {
497 case 'd':
c5aa993b
JM
498 sprintf (buf, (use_local ? local_decimal_format_custom ("l") : "%ld"),
499 ((long) val_long));
c906108c
SS
500 break;
501 case 'u':
c5aa993b 502 sprintf (buf, "%lu", ((unsigned long) val_long));
c906108c
SS
503 break;
504 case 'x':
c5aa993b 505 sprintf (buf, (use_local ? local_hex_format_custom ("l") : "%lx"),
c906108c
SS
506 ((long) val_long));
507 break;
508 case 'o':
c5aa993b 509 sprintf (buf, (use_local ? local_octal_format_custom ("l") : "%lo"),
c906108c
SS
510 ((long) val_long));
511 break;
512 case 'b':
c5aa993b 513 sprintf (buf, local_hex_format_custom ("02l"),
c906108c
SS
514 ((long) val_long));
515 break;
516 case 'h':
c5aa993b 517 sprintf (buf, local_hex_format_custom ("04l"),
c906108c
SS
518 ((long) val_long));
519 break;
520 case 'w':
c5aa993b 521 sprintf (buf, local_hex_format_custom ("08l"),
c906108c
SS
522 ((long) val_long));
523 break;
524 case 'g':
525 sprintf (buf, local_hex_format_custom ("016l"),
526 ((long) val_long));
527 break;
528 default:
529 abort ();
530 }
c5aa993b 531
c906108c
SS
532#endif /* !PRINTF_HAS_LONG_LONG */
533}
7a292a7a 534#endif
c906108c
SS
535
536/* This used to be a macro, but I don't think it is called often enough
537 to merit such treatment. */
538/* Convert a LONGEST to an int. This is used in contexts (e.g. number of
539 arguments to a function, number in a value history, register number, etc.)
540 where the value must not be larger than can fit in an int. */
541
542int
543longest_to_int (arg)
544 LONGEST arg;
545{
546 /* Let the compiler do the work */
547 int rtnval = (int) arg;
548
549 /* Check for overflows or underflows */
550 if (sizeof (LONGEST) > sizeof (int))
551 {
552 if (rtnval != arg)
553 {
554 error ("Value out of range.");
555 }
556 }
557 return (rtnval);
558}
559
560/* Print a floating point value of type TYPE, pointed to in GDB by VALADDR,
561 on STREAM. */
562
563void
564print_floating (valaddr, type, stream)
565 char *valaddr;
566 struct type *type;
567 GDB_FILE *stream;
568{
569 DOUBLEST doub;
570 int inv;
571 unsigned len = TYPE_LENGTH (type);
c5aa993b 572
c906108c
SS
573#if defined (IEEE_FLOAT)
574
575 /* Check for NaN's. Note that this code does not depend on us being
576 on an IEEE conforming system. It only depends on the target
577 machine using IEEE representation. This means (a)
578 cross-debugging works right, and (2) IEEE_FLOAT can (and should)
579 be defined for systems like the 68881, which uses IEEE
580 representation, but is not IEEE conforming. */
581
582 {
583 unsigned long low, high;
584 /* Is the sign bit 0? */
585 int nonnegative;
586 /* Is it is a NaN (i.e. the exponent is all ones and
587 the fraction is nonzero)? */
588 int is_nan;
589
590 /* For lint, initialize these two variables to suppress warning: */
591 low = high = nonnegative = 0;
592 if (len == 4)
593 {
594 /* It's single precision. */
595 /* Assume that floating point byte order is the same as
596 integer byte order. */
597 low = extract_unsigned_integer (valaddr, 4);
598 nonnegative = ((low & 0x80000000) == 0);
c5aa993b 599 is_nan = ((((low >> 23) & 0xFF) == 0xFF)
c906108c
SS
600 && 0 != (low & 0x7FFFFF));
601 low &= 0x7fffff;
602 high = 0;
603 }
604 else if (len == 8)
605 {
606 /* It's double precision. Get the high and low words. */
607
608 /* Assume that floating point byte order is the same as
609 integer byte order. */
610 if (TARGET_BYTE_ORDER == BIG_ENDIAN)
611 {
612 low = extract_unsigned_integer (valaddr + 4, 4);
613 high = extract_unsigned_integer (valaddr, 4);
614 }
615 else
616 {
617 low = extract_unsigned_integer (valaddr, 4);
618 high = extract_unsigned_integer (valaddr + 4, 4);
619 }
620 nonnegative = ((high & 0x80000000) == 0);
621 is_nan = (((high >> 20) & 0x7ff) == 0x7ff
c5aa993b 622 && !((((high & 0xfffff) == 0)) && (low == 0)));
c906108c
SS
623 high &= 0xfffff;
624 }
625 else
626 /* Extended. We can't detect NaNs for extendeds yet. Also note
c5aa993b
JM
627 that currently extendeds get nuked to double in
628 REGISTER_CONVERTIBLE. */
c906108c
SS
629 is_nan = 0;
630
631 if (is_nan)
632 {
633 /* The meaning of the sign and fraction is not defined by IEEE.
634 But the user might know what they mean. For example, they
635 (in an implementation-defined manner) distinguish between
636 signaling and quiet NaN's. */
637 if (high)
638 fprintf_filtered (stream, "-NaN(0x%lx%.8lx)" + nonnegative,
639 high, low);
640 else
641 fprintf_filtered (stream, "-NaN(0x%lx)" + nonnegative, low);
642 return;
643 }
644 }
645#endif /* IEEE_FLOAT. */
646
647 doub = unpack_double (type, valaddr, &inv);
648 if (inv)
649 {
650 fprintf_filtered (stream, "<invalid float value>");
651 return;
652 }
653
654 if (len < sizeof (double))
c5aa993b 655 fprintf_filtered (stream, "%.9g", (double) doub);
c906108c 656 else if (len == sizeof (double))
c5aa993b 657 fprintf_filtered (stream, "%.17g", (double) doub);
c906108c
SS
658 else
659#ifdef PRINTF_HAS_LONG_DOUBLE
660 fprintf_filtered (stream, "%.35Lg", doub);
661#else
662 /* This at least wins with values that are representable as doubles */
663 fprintf_filtered (stream, "%.17g", (double) doub);
664#endif
665}
666
c5aa993b 667void
c906108c
SS
668print_binary_chars (stream, valaddr, len)
669 GDB_FILE *stream;
670 unsigned char *valaddr;
671 unsigned len;
672{
673
674#define BITS_IN_BYTES 8
675
676 unsigned char *p;
c5aa993b
JM
677 int i;
678 int b;
c906108c
SS
679
680 /* Declared "int" so it will be signed.
681 * This ensures that right shift will shift in zeros.
682 */
c5aa993b 683 const int mask = 0x080;
c906108c
SS
684
685 /* FIXME: We should be not printing leading zeroes in most cases. */
686
687 fprintf_filtered (stream, local_binary_format_prefix ());
688 if (TARGET_BYTE_ORDER == BIG_ENDIAN)
689 {
690 for (p = valaddr;
691 p < valaddr + len;
692 p++)
693 {
c5aa993b
JM
694 /* Every byte has 8 binary characters; peel off
695 * and print from the MSB end.
696 */
697 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
698 {
699 if (*p & (mask >> i))
700 b = 1;
701 else
702 b = 0;
703
704 fprintf_filtered (stream, "%1d", b);
705 }
c906108c
SS
706 }
707 }
708 else
709 {
710 for (p = valaddr + len - 1;
711 p >= valaddr;
712 p--)
713 {
c5aa993b
JM
714 for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
715 {
716 if (*p & (mask >> i))
717 b = 1;
718 else
719 b = 0;
720
721 fprintf_filtered (stream, "%1d", b);
722 }
c906108c
SS
723 }
724 }
725 fprintf_filtered (stream, local_binary_format_suffix ());
726}
727
728/* VALADDR points to an integer of LEN bytes.
729 * Print it in octal on stream or format it in buf.
730 */
731void
732print_octal_chars (stream, valaddr, len)
733 GDB_FILE *stream;
734 unsigned char *valaddr;
735 unsigned len;
736{
737 unsigned char *p;
738 unsigned char octa1, octa2, octa3, carry;
c5aa993b
JM
739 int cycle;
740
c906108c
SS
741 /* FIXME: We should be not printing leading zeroes in most cases. */
742
743
744 /* Octal is 3 bits, which doesn't fit. Yuk. So we have to track
745 * the extra bits, which cycle every three bytes:
746 *
747 * Byte side: 0 1 2 3
748 * | | | |
749 * bit number 123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
750 *
751 * Octal side: 0 1 carry 3 4 carry ...
752 *
753 * Cycle number: 0 1 2
754 *
755 * But of course we are printing from the high side, so we have to
756 * figure out where in the cycle we are so that we end up with no
757 * left over bits at the end.
758 */
759#define BITS_IN_OCTAL 3
760#define HIGH_ZERO 0340
761#define LOW_ZERO 0016
762#define CARRY_ZERO 0003
763#define HIGH_ONE 0200
764#define MID_ONE 0160
765#define LOW_ONE 0016
766#define CARRY_ONE 0001
767#define HIGH_TWO 0300
768#define MID_TWO 0070
769#define LOW_TWO 0007
770
771 /* For 32 we start in cycle 2, with two bits and one bit carry;
772 * for 64 in cycle in cycle 1, with one bit and a two bit carry.
773 */
774 cycle = (len * BITS_IN_BYTES) % BITS_IN_OCTAL;
775 carry = 0;
c5aa993b 776
c906108c
SS
777 fprintf_filtered (stream, local_octal_format_prefix ());
778 if (TARGET_BYTE_ORDER == BIG_ENDIAN)
779 {
780 for (p = valaddr;
781 p < valaddr + len;
782 p++)
783 {
c5aa993b
JM
784 switch (cycle)
785 {
786 case 0:
787 /* No carry in, carry out two bits.
788 */
789 octa1 = (HIGH_ZERO & *p) >> 5;
790 octa2 = (LOW_ZERO & *p) >> 2;
791 carry = (CARRY_ZERO & *p);
792 fprintf_filtered (stream, "%o", octa1);
793 fprintf_filtered (stream, "%o", octa2);
794 break;
795
796 case 1:
797 /* Carry in two bits, carry out one bit.
798 */
799 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
800 octa2 = (MID_ONE & *p) >> 4;
801 octa3 = (LOW_ONE & *p) >> 1;
802 carry = (CARRY_ONE & *p);
803 fprintf_filtered (stream, "%o", octa1);
804 fprintf_filtered (stream, "%o", octa2);
805 fprintf_filtered (stream, "%o", octa3);
806 break;
807
808 case 2:
809 /* Carry in one bit, no carry out.
810 */
811 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
812 octa2 = (MID_TWO & *p) >> 3;
813 octa3 = (LOW_TWO & *p);
814 carry = 0;
815 fprintf_filtered (stream, "%o", octa1);
816 fprintf_filtered (stream, "%o", octa2);
817 fprintf_filtered (stream, "%o", octa3);
818 break;
819
820 default:
821 error ("Internal error in octal conversion;");
822 }
823
824 cycle++;
825 cycle = cycle % BITS_IN_OCTAL;
c906108c
SS
826 }
827 }
828 else
829 {
830 for (p = valaddr + len - 1;
831 p >= valaddr;
832 p--)
833 {
c5aa993b
JM
834 switch (cycle)
835 {
836 case 0:
837 /* Carry out, no carry in */
838 octa1 = (HIGH_ZERO & *p) >> 5;
839 octa2 = (LOW_ZERO & *p) >> 2;
840 carry = (CARRY_ZERO & *p);
841 fprintf_filtered (stream, "%o", octa1);
842 fprintf_filtered (stream, "%o", octa2);
843 break;
844
845 case 1:
846 /* Carry in, carry out */
847 octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
848 octa2 = (MID_ONE & *p) >> 4;
849 octa3 = (LOW_ONE & *p) >> 1;
850 carry = (CARRY_ONE & *p);
851 fprintf_filtered (stream, "%o", octa1);
852 fprintf_filtered (stream, "%o", octa2);
853 fprintf_filtered (stream, "%o", octa3);
854 break;
855
856 case 2:
857 /* Carry in, no carry out */
858 octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
859 octa2 = (MID_TWO & *p) >> 3;
860 octa3 = (LOW_TWO & *p);
861 carry = 0;
862 fprintf_filtered (stream, "%o", octa1);
863 fprintf_filtered (stream, "%o", octa2);
864 fprintf_filtered (stream, "%o", octa3);
865 break;
866
867 default:
868 error ("Internal error in octal conversion;");
869 }
870
871 cycle++;
872 cycle = cycle % BITS_IN_OCTAL;
c906108c
SS
873 }
874 }
875
876 fprintf_filtered (stream, local_octal_format_suffix ());
877}
878
879/* VALADDR points to an integer of LEN bytes.
880 * Print it in decimal on stream or format it in buf.
881 */
882void
883print_decimal_chars (stream, valaddr, len)
884 GDB_FILE *stream;
885 unsigned char *valaddr;
886 unsigned len;
887{
888#define TEN 10
889#define TWO_TO_FOURTH 16
c5aa993b 890#define CARRY_OUT( x ) ((x) / TEN) /* extend char to int */
c906108c
SS
891#define CARRY_LEFT( x ) ((x) % TEN)
892#define SHIFT( x ) ((x) << 4)
893#define START_P \
894 ((TARGET_BYTE_ORDER == BIG_ENDIAN) ? valaddr : valaddr + len - 1)
895#define NOT_END_P \
896 ((TARGET_BYTE_ORDER == BIG_ENDIAN) ? (p < valaddr + len) : (p >= valaddr))
897#define NEXT_P \
898 ((TARGET_BYTE_ORDER == BIG_ENDIAN) ? p++ : p-- )
899#define LOW_NIBBLE( x ) ( (x) & 0x00F)
900#define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
901
902 unsigned char *p;
903 unsigned char *digits;
c5aa993b
JM
904 int carry;
905 int decimal_len;
906 int i, j, decimal_digits;
907 int dummy;
908 int flip;
909
c906108c
SS
910 /* Base-ten number is less than twice as many digits
911 * as the base 16 number, which is 2 digits per byte.
912 */
913 decimal_len = len * 2 * 2;
c5aa993b
JM
914 digits = (unsigned char *) malloc (decimal_len);
915 if (digits == NULL)
916 error ("Can't allocate memory for conversion to decimal.");
c906108c 917
c5aa993b
JM
918 for (i = 0; i < decimal_len; i++)
919 {
c906108c 920 digits[i] = 0;
c5aa993b 921 }
c906108c
SS
922
923 fprintf_filtered (stream, local_decimal_format_prefix ());
924
925 /* Ok, we have an unknown number of bytes of data to be printed in
926 * decimal.
927 *
928 * Given a hex number (in nibbles) as XYZ, we start by taking X and
929 * decemalizing it as "x1 x2" in two decimal nibbles. Then we multiply
930 * the nibbles by 16, add Y and re-decimalize. Repeat with Z.
931 *
932 * The trick is that "digits" holds a base-10 number, but sometimes
933 * the individual digits are > 10.
934 *
935 * Outer loop is per nibble (hex digit) of input, from MSD end to
936 * LSD end.
937 */
c5aa993b 938 decimal_digits = 0; /* Number of decimal digits so far */
c906108c
SS
939 p = START_P;
940 flip = 0;
c5aa993b
JM
941 while (NOT_END_P)
942 {
c906108c
SS
943 /*
944 * Multiply current base-ten number by 16 in place.
945 * Each digit was between 0 and 9, now is between
946 * 0 and 144.
947 */
c5aa993b
JM
948 for (j = 0; j < decimal_digits; j++)
949 {
950 digits[j] = SHIFT (digits[j]);
951 }
952
c906108c
SS
953 /* Take the next nibble off the input and add it to what
954 * we've got in the LSB position. Bottom 'digit' is now
955 * between 0 and 159.
956 *
957 * "flip" is used to run this loop twice for each byte.
958 */
c5aa993b
JM
959 if (flip == 0)
960 {
961 /* Take top nibble.
962 */
963 digits[0] += HIGH_NIBBLE (*p);
964 flip = 1;
965 }
966 else
967 {
968 /* Take low nibble and bump our pointer "p".
969 */
970 digits[0] += LOW_NIBBLE (*p);
971 NEXT_P;
972 flip = 0;
973 }
c906108c
SS
974
975 /* Re-decimalize. We have to do this often enough
976 * that we don't overflow, but once per nibble is
977 * overkill. Easier this way, though. Note that the
978 * carry is often larger than 10 (e.g. max initial
979 * carry out of lowest nibble is 15, could bubble all
980 * the way up greater than 10). So we have to do
981 * the carrying beyond the last current digit.
982 */
983 carry = 0;
c5aa993b
JM
984 for (j = 0; j < decimal_len - 1; j++)
985 {
986 digits[j] += carry;
987
988 /* "/" won't handle an unsigned char with
989 * a value that if signed would be negative.
990 * So extend to longword int via "dummy".
991 */
992 dummy = digits[j];
993 carry = CARRY_OUT (dummy);
994 digits[j] = CARRY_LEFT (dummy);
995
996 if (j >= decimal_digits && carry == 0)
997 {
998 /*
999 * All higher digits are 0 and we
1000 * no longer have a carry.
1001 *
1002 * Note: "j" is 0-based, "decimal_digits" is
1003 * 1-based.
1004 */
1005 decimal_digits = j + 1;
1006 break;
1007 }
1008 }
1009 }
c906108c
SS
1010
1011 /* Ok, now "digits" is the decimal representation, with
1012 * the "decimal_digits" actual digits. Print!
1013 */
c5aa993b
JM
1014 for (i = decimal_digits - 1; i >= 0; i--)
1015 {
1016 fprintf_filtered (stream, "%1d", digits[i]);
1017 }
1018 free (digits);
1019
c906108c
SS
1020 fprintf_filtered (stream, local_decimal_format_suffix ());
1021}
1022
1023/* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
1024
1025static void
1026print_hex_chars (stream, valaddr, len)
1027 GDB_FILE *stream;
1028 unsigned char *valaddr;
1029 unsigned len;
1030{
1031 unsigned char *p;
1032
1033 /* FIXME: We should be not printing leading zeroes in most cases. */
1034
1035 fprintf_filtered (stream, local_hex_format_prefix ());
1036 if (TARGET_BYTE_ORDER == BIG_ENDIAN)
1037 {
1038 for (p = valaddr;
1039 p < valaddr + len;
1040 p++)
1041 {
1042 fprintf_filtered (stream, "%02x", *p);
1043 }
1044 }
1045 else
1046 {
1047 for (p = valaddr + len - 1;
1048 p >= valaddr;
1049 p--)
1050 {
1051 fprintf_filtered (stream, "%02x", *p);
1052 }
1053 }
1054 fprintf_filtered (stream, local_hex_format_suffix ());
1055}
1056
1057/* Called by various <lang>_val_print routines to print elements of an
c5aa993b 1058 array in the form "<elem1>, <elem2>, <elem3>, ...".
c906108c 1059
c5aa993b
JM
1060 (FIXME?) Assumes array element separator is a comma, which is correct
1061 for all languages currently handled.
1062 (FIXME?) Some languages have a notation for repeated array elements,
1063 perhaps we should try to use that notation when appropriate.
1064 */
c906108c
SS
1065
1066void
1067val_print_array_elements (type, valaddr, address, stream, format, deref_ref,
1068 recurse, pretty, i)
1069 struct type *type;
1070 char *valaddr;
1071 CORE_ADDR address;
1072 GDB_FILE *stream;
1073 int format;
1074 int deref_ref;
1075 int recurse;
1076 enum val_prettyprint pretty;
1077 unsigned int i;
1078{
1079 unsigned int things_printed = 0;
1080 unsigned len;
1081 struct type *elttype;
1082 unsigned eltlen;
1083 /* Position of the array element we are examining to see
1084 whether it is repeated. */
1085 unsigned int rep1;
1086 /* Number of repetitions we have detected so far. */
1087 unsigned int reps;
c5aa993b 1088
c906108c
SS
1089 elttype = TYPE_TARGET_TYPE (type);
1090 eltlen = TYPE_LENGTH (check_typedef (elttype));
1091 len = TYPE_LENGTH (type) / eltlen;
1092
1093 annotate_array_section_begin (i, elttype);
1094
1095 for (; i < len && things_printed < print_max; i++)
1096 {
1097 if (i != 0)
1098 {
1099 if (prettyprint_arrays)
1100 {
1101 fprintf_filtered (stream, ",\n");
1102 print_spaces_filtered (2 + 2 * recurse, stream);
1103 }
1104 else
1105 {
1106 fprintf_filtered (stream, ", ");
1107 }
1108 }
1109 wrap_here (n_spaces (2 + 2 * recurse));
1110
1111 rep1 = i + 1;
1112 reps = 1;
c5aa993b 1113 while ((rep1 < len) &&
c906108c
SS
1114 !memcmp (valaddr + i * eltlen, valaddr + rep1 * eltlen, eltlen))
1115 {
1116 ++reps;
1117 ++rep1;
1118 }
1119
1120 if (reps > repeat_count_threshold)
1121 {
1122 val_print (elttype, valaddr + i * eltlen, 0, 0, stream, format,
1123 deref_ref, recurse + 1, pretty);
1124 annotate_elt_rep (reps);
1125 fprintf_filtered (stream, " <repeats %u times>", reps);
1126 annotate_elt_rep_end ();
1127
1128 i = rep1 - 1;
1129 things_printed += repeat_count_threshold;
1130 }
1131 else
1132 {
1133 val_print (elttype, valaddr + i * eltlen, 0, 0, stream, format,
1134 deref_ref, recurse + 1, pretty);
1135 annotate_elt ();
1136 things_printed++;
1137 }
1138 }
1139 annotate_array_section_end ();
1140 if (i < len)
1141 {
1142 fprintf_filtered (stream, "...");
1143 }
1144}
1145
1146/* Print a string from the inferior, starting at ADDR and printing up to LEN
c5aa993b
JM
1147 characters, of WIDTH bytes a piece, to STREAM. If LEN is -1, printing
1148 stops at the first null byte, otherwise printing proceeds (including null
1149 bytes) until either print_max or LEN characters have been printed,
1150 whichever is smaller. */
c906108c
SS
1151
1152/* FIXME: Use target_read_string. */
1153
1154int
1155val_print_string (addr, len, width, stream)
c5aa993b
JM
1156 CORE_ADDR addr;
1157 int len;
1158 int width;
1159 GDB_FILE *stream;
c906108c
SS
1160{
1161 int force_ellipsis = 0; /* Force ellipsis to be printed if nonzero. */
1162 int errcode; /* Errno returned from bad reads. */
1163 unsigned int fetchlimit; /* Maximum number of chars to print. */
1164 unsigned int nfetch; /* Chars to fetch / chars fetched. */
1165 unsigned int chunksize; /* Size of each fetch, in chars. */
1166 char *buffer = NULL; /* Dynamically growable fetch buffer. */
1167 char *bufptr; /* Pointer to next available byte in buffer. */
1168 char *limit; /* First location past end of fetch buffer. */
c5aa993b 1169 struct cleanup *old_chain = NULL; /* Top of the old cleanup chain. */
c906108c
SS
1170 int found_nul; /* Non-zero if we found the nul char */
1171
1172 /* First we need to figure out the limit on the number of characters we are
1173 going to attempt to fetch and print. This is actually pretty simple. If
1174 LEN >= zero, then the limit is the minimum of LEN and print_max. If
1175 LEN is -1, then the limit is print_max. This is true regardless of
1176 whether print_max is zero, UINT_MAX (unlimited), or something in between,
1177 because finding the null byte (or available memory) is what actually
1178 limits the fetch. */
1179
1180 fetchlimit = (len == -1 ? print_max : min (len, print_max));
1181
1182 /* Now decide how large of chunks to try to read in one operation. This
1183 is also pretty simple. If LEN >= zero, then we want fetchlimit chars,
1184 so we might as well read them all in one operation. If LEN is -1, we
1185 are looking for a null terminator to end the fetching, so we might as
1186 well read in blocks that are large enough to be efficient, but not so
1187 large as to be slow if fetchlimit happens to be large. So we choose the
1188 minimum of 8 and fetchlimit. We used to use 200 instead of 8 but
1189 200 is way too big for remote debugging over a serial line. */
1190
1191 chunksize = (len == -1 ? min (8, fetchlimit) : fetchlimit);
1192
1193 /* Loop until we either have all the characters to print, or we encounter
1194 some error, such as bumping into the end of the address space. */
1195
1196 found_nul = 0;
1197 old_chain = make_cleanup (null_cleanup, 0);
1198
1199 if (len > 0)
1200 {
1201 buffer = (char *) xmalloc (len * width);
1202 bufptr = buffer;
1203 old_chain = make_cleanup (free, buffer);
1204
1205 nfetch = target_read_memory_partial (addr, bufptr, len * width, &errcode)
1206 / width;
1207 addr += nfetch * width;
1208 bufptr += nfetch * width;
1209 }
1210 else if (len == -1)
1211 {
1212 unsigned long bufsize = 0;
1213 do
1214 {
1215 QUIT;
1216 nfetch = min (chunksize, fetchlimit - bufsize);
1217
1218 if (buffer == NULL)
1219 buffer = (char *) xmalloc (nfetch * width);
1220 else
1221 {
1222 discard_cleanups (old_chain);
1223 buffer = (char *) xrealloc (buffer, (nfetch + bufsize) * width);
1224 }
1225
1226 old_chain = make_cleanup (free, buffer);
1227 bufptr = buffer + bufsize * width;
1228 bufsize += nfetch;
1229
1230 /* Read as much as we can. */
1231 nfetch = target_read_memory_partial (addr, bufptr, nfetch * width, &errcode)
c5aa993b 1232 / width;
c906108c
SS
1233
1234 /* Scan this chunk for the null byte that terminates the string
1235 to print. If found, we don't need to fetch any more. Note
1236 that bufptr is explicitly left pointing at the next character
1237 after the null byte, or at the next character after the end of
1238 the buffer. */
1239
1240 limit = bufptr + nfetch * width;
1241 while (bufptr < limit)
1242 {
1243 unsigned long c;
1244
1245 c = extract_unsigned_integer (bufptr, width);
1246 addr += width;
1247 bufptr += width;
1248 if (c == 0)
1249 {
1250 /* We don't care about any error which happened after
1251 the NULL terminator. */
1252 errcode = 0;
1253 found_nul = 1;
1254 break;
1255 }
1256 }
1257 }
c5aa993b
JM
1258 while (errcode == 0 /* no error */
1259 && bufptr - buffer < fetchlimit * width /* no overrun */
1260 && !found_nul); /* haven't found nul yet */
c906108c
SS
1261 }
1262 else
1263 { /* length of string is really 0! */
1264 buffer = bufptr = NULL;
1265 errcode = 0;
1266 }
1267
1268 /* bufptr and addr now point immediately beyond the last byte which we
1269 consider part of the string (including a '\0' which ends the string). */
1270
1271 /* We now have either successfully filled the buffer to fetchlimit, or
1272 terminated early due to an error or finding a null char when LEN is -1. */
1273
1274 if (len == -1 && !found_nul)
1275 {
1276 char *peekbuf;
1277
1278 /* We didn't find a null terminator we were looking for. Attempt
c5aa993b
JM
1279 to peek at the next character. If not successful, or it is not
1280 a null byte, then force ellipsis to be printed. */
c906108c
SS
1281
1282 peekbuf = (char *) alloca (width);
1283
1284 if (target_read_memory (addr, peekbuf, width) == 0
1285 && extract_unsigned_integer (peekbuf, width) != 0)
1286 force_ellipsis = 1;
1287 }
c5aa993b 1288 else if ((len >= 0 && errcode != 0) || (len > (bufptr - buffer) / width))
c906108c
SS
1289 {
1290 /* Getting an error when we have a requested length, or fetching less
c5aa993b
JM
1291 than the number of characters actually requested, always make us
1292 print ellipsis. */
c906108c
SS
1293 force_ellipsis = 1;
1294 }
1295
1296 QUIT;
1297
1298 /* If we get an error before fetching anything, don't print a string.
1299 But if we fetch something and then get an error, print the string
1300 and then the error message. */
1301 if (errcode == 0 || bufptr > buffer)
1302 {
1303 if (addressprint)
1304 {
1305 fputs_filtered (" ", stream);
1306 }
c5aa993b 1307 LA_PRINT_STRING (stream, buffer, (bufptr - buffer) / width, width, force_ellipsis);
c906108c
SS
1308 }
1309
1310 if (errcode != 0)
1311 {
1312 if (errcode == EIO)
1313 {
1314 fprintf_filtered (stream, " <Address ");
1315 print_address_numeric (addr, 1, stream);
1316 fprintf_filtered (stream, " out of bounds>");
1317 }
1318 else
1319 {
1320 fprintf_filtered (stream, " <Error reading address ");
1321 print_address_numeric (addr, 1, stream);
1322 fprintf_filtered (stream, ": %s>", safe_strerror (errcode));
1323 }
1324 }
1325 gdb_flush (stream);
1326 do_cleanups (old_chain);
c5aa993b 1327 return ((bufptr - buffer) / width);
c906108c 1328}
c906108c 1329\f
c5aa993b 1330
c906108c
SS
1331/* Validate an input or output radix setting, and make sure the user
1332 knows what they really did here. Radix setting is confusing, e.g.
1333 setting the input radix to "10" never changes it! */
1334
1335/* ARGSUSED */
1336static void
1337set_input_radix (args, from_tty, c)
1338 char *args;
1339 int from_tty;
1340 struct cmd_list_element *c;
1341{
c5aa993b 1342 set_input_radix_1 (from_tty, *(unsigned *) c->var);
c906108c
SS
1343}
1344
1345/* ARGSUSED */
1346static void
1347set_input_radix_1 (from_tty, radix)
1348 int from_tty;
1349 unsigned radix;
1350{
1351 /* We don't currently disallow any input radix except 0 or 1, which don't
1352 make any mathematical sense. In theory, we can deal with any input
1353 radix greater than 1, even if we don't have unique digits for every
1354 value from 0 to radix-1, but in practice we lose on large radix values.
1355 We should either fix the lossage or restrict the radix range more.
1356 (FIXME). */
1357
1358 if (radix < 2)
1359 {
1360 error ("Nonsense input radix ``decimal %u''; input radix unchanged.",
1361 radix);
1362 }
1363 input_radix = radix;
1364 if (from_tty)
1365 {
1366 printf_filtered ("Input radix now set to decimal %u, hex %x, octal %o.\n",
1367 radix, radix, radix);
1368 }
1369}
1370
1371/* ARGSUSED */
1372static void
1373set_output_radix (args, from_tty, c)
1374 char *args;
1375 int from_tty;
1376 struct cmd_list_element *c;
1377{
c5aa993b 1378 set_output_radix_1 (from_tty, *(unsigned *) c->var);
c906108c
SS
1379}
1380
1381static void
1382set_output_radix_1 (from_tty, radix)
1383 int from_tty;
1384 unsigned radix;
1385{
1386 /* Validate the radix and disallow ones that we aren't prepared to
1387 handle correctly, leaving the radix unchanged. */
1388 switch (radix)
1389 {
1390 case 16:
c5aa993b 1391 output_format = 'x'; /* hex */
c906108c
SS
1392 break;
1393 case 10:
c5aa993b 1394 output_format = 0; /* decimal */
c906108c
SS
1395 break;
1396 case 8:
c5aa993b 1397 output_format = 'o'; /* octal */
c906108c
SS
1398 break;
1399 default:
1400 error ("Unsupported output radix ``decimal %u''; output radix unchanged.",
1401 radix);
1402 }
1403 output_radix = radix;
1404 if (from_tty)
1405 {
1406 printf_filtered ("Output radix now set to decimal %u, hex %x, octal %o.\n",
1407 radix, radix, radix);
1408 }
1409}
1410
1411/* Set both the input and output radix at once. Try to set the output radix
1412 first, since it has the most restrictive range. An radix that is valid as
1413 an output radix is also valid as an input radix.
1414
1415 It may be useful to have an unusual input radix. If the user wishes to
1416 set an input radix that is not valid as an output radix, he needs to use
1417 the 'set input-radix' command. */
1418
1419static void
1420set_radix (arg, from_tty)
1421 char *arg;
1422 int from_tty;
1423{
1424 unsigned radix;
1425
1426 radix = (arg == NULL) ? 10 : parse_and_eval_address (arg);
1427 set_output_radix_1 (0, radix);
1428 set_input_radix_1 (0, radix);
1429 if (from_tty)
1430 {
1431 printf_filtered ("Input and output radices now set to decimal %u, hex %x, octal %o.\n",
1432 radix, radix, radix);
1433 }
1434}
1435
1436/* Show both the input and output radices. */
1437
c5aa993b 1438/*ARGSUSED */
c906108c
SS
1439static void
1440show_radix (arg, from_tty)
1441 char *arg;
1442 int from_tty;
1443{
1444 if (from_tty)
1445 {
1446 if (input_radix == output_radix)
1447 {
1448 printf_filtered ("Input and output radices set to decimal %u, hex %x, octal %o.\n",
1449 input_radix, input_radix, input_radix);
1450 }
1451 else
1452 {
1453 printf_filtered ("Input radix set to decimal %u, hex %x, octal %o.\n",
1454 input_radix, input_radix, input_radix);
1455 printf_filtered ("Output radix set to decimal %u, hex %x, octal %o.\n",
1456 output_radix, output_radix, output_radix);
1457 }
1458 }
1459}
c906108c 1460\f
c5aa993b
JM
1461
1462/*ARGSUSED */
c906108c
SS
1463static void
1464set_print (arg, from_tty)
1465 char *arg;
1466 int from_tty;
1467{
1468 printf_unfiltered (
c5aa993b 1469 "\"set print\" must be followed by the name of a print subcommand.\n");
c906108c
SS
1470 help_list (setprintlist, "set print ", -1, gdb_stdout);
1471}
1472
c5aa993b 1473/*ARGSUSED */
c906108c
SS
1474static void
1475show_print (args, from_tty)
1476 char *args;
1477 int from_tty;
1478{
1479 cmd_show_list (showprintlist, from_tty, "");
1480}
1481\f
1482void
1483_initialize_valprint ()
1484{
1485 struct cmd_list_element *c;
1486
1487 add_prefix_cmd ("print", no_class, set_print,
1488 "Generic command for setting how things print.",
1489 &setprintlist, "set print ", 0, &setlist);
c5aa993b
JM
1490 add_alias_cmd ("p", "print", no_class, 1, &setlist);
1491 /* prefer set print to set prompt */
c906108c
SS
1492 add_alias_cmd ("pr", "print", no_class, 1, &setlist);
1493
1494 add_prefix_cmd ("print", no_class, show_print,
1495 "Generic command for showing print settings.",
1496 &showprintlist, "show print ", 0, &showlist);
c5aa993b
JM
1497 add_alias_cmd ("p", "print", no_class, 1, &showlist);
1498 add_alias_cmd ("pr", "print", no_class, 1, &showlist);
c906108c
SS
1499
1500 add_show_from_set
c5aa993b 1501 (add_set_cmd ("elements", no_class, var_uinteger, (char *) &print_max,
c906108c
SS
1502 "Set limit on string chars or array elements to print.\n\
1503\"set print elements 0\" causes there to be no limit.",
1504 &setprintlist),
1505 &showprintlist);
1506
1507 add_show_from_set
1508 (add_set_cmd ("null-stop", no_class, var_boolean,
c5aa993b 1509 (char *) &stop_print_at_null,
c906108c
SS
1510 "Set printing of char arrays to stop at first null char.",
1511 &setprintlist),
1512 &showprintlist);
1513
1514 add_show_from_set
1515 (add_set_cmd ("repeats", no_class, var_uinteger,
c5aa993b 1516 (char *) &repeat_count_threshold,
c906108c
SS
1517 "Set threshold for repeated print elements.\n\
1518\"set print repeats 0\" causes all elements to be individually printed.",
1519 &setprintlist),
1520 &showprintlist);
1521
1522 add_show_from_set
1523 (add_set_cmd ("pretty", class_support, var_boolean,
c5aa993b 1524 (char *) &prettyprint_structs,
c906108c
SS
1525 "Set prettyprinting of structures.",
1526 &setprintlist),
1527 &showprintlist);
1528
1529 add_show_from_set
c5aa993b 1530 (add_set_cmd ("union", class_support, var_boolean, (char *) &unionprint,
c906108c
SS
1531 "Set printing of unions interior to structures.",
1532 &setprintlist),
1533 &showprintlist);
c5aa993b 1534
c906108c
SS
1535 add_show_from_set
1536 (add_set_cmd ("array", class_support, var_boolean,
c5aa993b 1537 (char *) &prettyprint_arrays,
c906108c
SS
1538 "Set prettyprinting of arrays.",
1539 &setprintlist),
1540 &showprintlist);
1541
1542 add_show_from_set
c5aa993b 1543 (add_set_cmd ("address", class_support, var_boolean, (char *) &addressprint,
c906108c
SS
1544 "Set printing of addresses.",
1545 &setprintlist),
1546 &showprintlist);
1547
1548 c = add_set_cmd ("input-radix", class_support, var_uinteger,
c5aa993b
JM
1549 (char *) &input_radix,
1550 "Set default input radix for entering numbers.",
1551 &setlist);
c906108c
SS
1552 add_show_from_set (c, &showlist);
1553 c->function.sfunc = set_input_radix;
1554
1555 c = add_set_cmd ("output-radix", class_support, var_uinteger,
c5aa993b
JM
1556 (char *) &output_radix,
1557 "Set default output radix for printing of values.",
1558 &setlist);
c906108c
SS
1559 add_show_from_set (c, &showlist);
1560 c->function.sfunc = set_output_radix;
1561
1562 /* The "set radix" and "show radix" commands are special in that they are
1563 like normal set and show commands but allow two normally independent
1564 variables to be either set or shown with a single command. So the
1565 usual add_set_cmd() and add_show_from_set() commands aren't really
1566 appropriate. */
1567 add_cmd ("radix", class_support, set_radix,
1568 "Set default input and output number radices.\n\
1569Use 'set input-radix' or 'set output-radix' to independently set each.\n\
1570Without an argument, sets both radices back to the default value of 10.",
1571 &setlist);
1572 add_cmd ("radix", class_support, show_radix,
1573 "Show the default input and output number radices.\n\
1574Use 'show input-radix' or 'show output-radix' to independently show each.",
1575 &showlist);
1576
1577 /* Give people the defaults which they are used to. */
1578 prettyprint_structs = 0;
1579 prettyprint_arrays = 0;
1580 unionprint = 1;
1581 addressprint = 1;
1582 print_max = PRINT_MAX_DEFAULT;
1583}