gdb/valprint.c

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