gdb/valprint.c

   1 /* Print values for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986, 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, 1996,
   4    1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008,
   5    2009, 2010 Free Software Foundation, Inc.
   6
   7    This file is part of GDB.
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  21
  22 #include "defs.h"
  23 #include "gdb_string.h"
  24 #include "symtab.h"
  25 #include "gdbtypes.h"
  26 #include "value.h"
  27 #include "gdbcore.h"
  28 #include "gdbcmd.h"
  29 #include "target.h"
  30 #include "language.h"
  31 #include "annotate.h"
  32 #include "valprint.h"
  33 #include "floatformat.h"
  34 #include "doublest.h"
  35 #include "exceptions.h"
  36 #include "dfp.h"
  37 #include "python/python.h"
  38
  39 #include <errno.h>
  40
  41 /* Prototypes for local functions */
  42
  43 static int partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr,
  44                                 int len, int *errnoptr);
  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 #define PRINT_MAX_DEFAULT 200   /* Start print_max off at this value. */
  65
  66 struct value_print_options user_print_options =
  67 {
  68   Val_pretty_default,           /* pretty */
  69   0,                            /* prettyprint_arrays */
  70   0,                            /* prettyprint_structs */
  71   0,                            /* vtblprint */
  72   1,                            /* unionprint */
  73   1,                            /* addressprint */
  74   0,                            /* objectprint */
  75   PRINT_MAX_DEFAULT,            /* print_max */
  76   10,                           /* repeat_count_threshold */
  77   0,                            /* output_format */
  78   0,                            /* format */
  79   0,                            /* stop_print_at_null */
  80   0,                            /* inspect_it */
  81   0,                            /* print_array_indexes */
  82   0,                            /* deref_ref */
  83   1,                            /* static_field_print */
  84   1,                            /* pascal_static_field_print */
  85   0,                            /* raw */
  86   0                             /* summary */
  87 };
  88
  89 /* Initialize *OPTS to be a copy of the user print options.  */
  90 void
  91 get_user_print_options (struct value_print_options *opts)
  92 {
  93   *opts = user_print_options;
  94 }
  95
  96 /* Initialize *OPTS to be a copy of the user print options, but with
  97    pretty-printing disabled.  */
  98 void
  99 get_raw_print_options (struct value_print_options *opts)
 100 {
 101   *opts = user_print_options;
 102   opts->pretty = Val_no_prettyprint;
 103 }
 104
 105 /* Initialize *OPTS to be a copy of the user print options, but using
 106    FORMAT as the formatting option.  */
 107 void
 108 get_formatted_print_options (struct value_print_options *opts,
 109                              char format)
 110 {
 111   *opts = user_print_options;
 112   opts->format = format;
 113 }
 114
 115 static void
 116 show_print_max (struct ui_file *file, int from_tty,
 117                 struct cmd_list_element *c, const char *value)
 118 {
 119   fprintf_filtered (file, _("\
 120 Limit on string chars or array elements to print is %s.\n"),
 121                     value);
 122 }
 123
 124
 125 /* Default input and output radixes, and output format letter.  */
 126
 127 unsigned input_radix = 10;
 128 static void
 129 show_input_radix (struct ui_file *file, int from_tty,
 130                   struct cmd_list_element *c, const char *value)
 131 {
 132   fprintf_filtered (file, _("\
 133 Default input radix for entering numbers is %s.\n"),
 134                     value);
 135 }
 136
 137 unsigned output_radix = 10;
 138 static void
 139 show_output_radix (struct ui_file *file, int from_tty,
 140                    struct cmd_list_element *c, const char *value)
 141 {
 142   fprintf_filtered (file, _("\
 143 Default output radix for printing of values is %s.\n"),
 144                     value);
 145 }
 146
 147 /* By default we print arrays without printing the index of each element in
 148    the array.  This behavior can be changed by setting PRINT_ARRAY_INDEXES.  */
 149
 150 static void
 151 show_print_array_indexes (struct ui_file *file, int from_tty,
 152                           struct cmd_list_element *c, const char *value)
 153 {
 154   fprintf_filtered (file, _("Printing of array indexes is %s.\n"), value);
 155 }
 156
 157 /* Print repeat counts if there are more than this many repetitions of an
 158    element in an array.  Referenced by the low level language dependent
 159    print routines. */
 160
 161 static void
 162 show_repeat_count_threshold (struct ui_file *file, int from_tty,
 163                              struct cmd_list_element *c, const char *value)
 164 {
 165   fprintf_filtered (file, _("Threshold for repeated print elements is %s.\n"),
 166                     value);
 167 }
 168
 169 /* If nonzero, stops printing of char arrays at first null. */
 170
 171 static void
 172 show_stop_print_at_null (struct ui_file *file, int from_tty,
 173                          struct cmd_list_element *c, const char *value)
 174 {
 175   fprintf_filtered (file, _("\
 176 Printing of char arrays to stop at first null char is %s.\n"),
 177                     value);
 178 }
 179
 180 /* Controls pretty printing of structures. */
 181
 182 static void
 183 show_prettyprint_structs (struct ui_file *file, int from_tty,
 184                           struct cmd_list_element *c, const char *value)
 185 {
 186   fprintf_filtered (file, _("Prettyprinting of structures is %s.\n"), value);
 187 }
 188
 189 /* Controls pretty printing of arrays.  */
 190
 191 static void
 192 show_prettyprint_arrays (struct ui_file *file, int from_tty,
 193                          struct cmd_list_element *c, const char *value)
 194 {
 195   fprintf_filtered (file, _("Prettyprinting of arrays is %s.\n"), value);
 196 }
 197
 198 /* If nonzero, causes unions inside structures or other unions to be
 199    printed. */
 200
 201 static void
 202 show_unionprint (struct ui_file *file, int from_tty,
 203                  struct cmd_list_element *c, const char *value)
 204 {
 205   fprintf_filtered (file, _("\
 206 Printing of unions interior to structures is %s.\n"),
 207                     value);
 208 }
 209
 210 /* If nonzero, causes machine addresses to be printed in certain contexts. */
 211
 212 static void
 213 show_addressprint (struct ui_file *file, int from_tty,
 214                    struct cmd_list_element *c, const char *value)
 215 {
 216   fprintf_filtered (file, _("Printing of addresses is %s.\n"), value);
 217 }
 218 \f
 219
 220 /* A helper function for val_print.  When printing in "summary" mode,
 221    we want to print scalar arguments, but not aggregate arguments.
 222    This function distinguishes between the two.  */
 223
 224 static int
 225 scalar_type_p (struct type *type)
 226 {
 227   CHECK_TYPEDEF (type);
 228   while (TYPE_CODE (type) == TYPE_CODE_REF)
 229     {
 230       type = TYPE_TARGET_TYPE (type);
 231       CHECK_TYPEDEF (type);
 232     }
 233   switch (TYPE_CODE (type))
 234     {
 235     case TYPE_CODE_ARRAY:
 236     case TYPE_CODE_STRUCT:
 237     case TYPE_CODE_UNION:
 238     case TYPE_CODE_SET:
 239     case TYPE_CODE_STRING:
 240     case TYPE_CODE_BITSTRING:
 241       return 0;
 242     default:
 243       return 1;
 244     }
 245 }
 246
 247 /* Print using the given LANGUAGE the data of type TYPE located at VALADDR
 248    (within GDB), which came from the inferior at address ADDRESS, onto
 249    stdio stream STREAM according to OPTIONS.
 250
 251    If the data are a string pointer, returns the number of string characters
 252    printed.
 253
 254    FIXME:  The data at VALADDR is in target byte order.  If gdb is ever
 255    enhanced to be able to debug more than the single target it was compiled
 256    for (specific CPU type and thus specific target byte ordering), then
 257    either the print routines are going to have to take this into account,
 258    or the data is going to have to be passed into here already converted
 259    to the host byte ordering, whichever is more convenient. */
 260
 261
 262 int
 263 val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
 264            CORE_ADDR address, struct ui_file *stream, int recurse,
 265            const struct value_print_options *options,
 266            const struct language_defn *language)
 267 {
 268   volatile struct gdb_exception except;
 269   int ret = 0;
 270   struct value_print_options local_opts = *options;
 271   struct type *real_type = check_typedef (type);
 272
 273   if (local_opts.pretty == Val_pretty_default)
 274     local_opts.pretty = (local_opts.prettyprint_structs
 275                          ? Val_prettyprint : Val_no_prettyprint);
 276
 277   QUIT;
 278
 279   /* Ensure that the type is complete and not just a stub.  If the type is
 280      only a stub and we can't find and substitute its complete type, then
 281      print appropriate string and return.  */
 282
 283   if (TYPE_STUB (real_type))
 284     {
 285       fprintf_filtered (stream, "<incomplete type>");
 286       gdb_flush (stream);
 287       return (0);
 288     }
 289
 290   if (!options->raw)
 291     {
 292       ret = apply_val_pretty_printer (type, valaddr, embedded_offset,
 293                                       address, stream, recurse, options,
 294                                       language);
 295       if (ret)
 296         return ret;
 297     }
 298
 299   /* Handle summary mode.  If the value is a scalar, print it;
 300      otherwise, print an ellipsis.  */
 301   if (options->summary && !scalar_type_p (type))
 302     {
 303       fprintf_filtered (stream, "...");
 304       return 0;
 305     }
 306
 307   TRY_CATCH (except, RETURN_MASK_ERROR)
 308     {
 309       ret = language->la_val_print (type, valaddr, embedded_offset, address,
 310                                     stream, recurse, &local_opts);
 311     }
 312   if (except.reason < 0)
 313     fprintf_filtered (stream, _("<error reading variable>"));
 314
 315   return ret;
 316 }
 317
 318 /* Check whether the value VAL is printable.  Return 1 if it is;
 319    return 0 and print an appropriate error message to STREAM if it
 320    is not.  */
 321
 322 static int
 323 value_check_printable (struct value *val, struct ui_file *stream)
 324 {
 325   if (val == 0)
 326     {
 327       fprintf_filtered (stream, _("<address of value unknown>"));
 328       return 0;
 329     }
 330
 331   if (value_optimized_out (val))
 332     {
 333       fprintf_filtered (stream, _("<value optimized out>"));
 334       return 0;
 335     }
 336
 337   if (TYPE_CODE (value_type (val)) == TYPE_CODE_INTERNAL_FUNCTION)
 338     {
 339       fprintf_filtered (stream, _("<internal function %s>"),
 340                         value_internal_function_name (val));
 341       return 0;
 342     }
 343
 344   return 1;
 345 }
 346
 347 /* Print using the given LANGUAGE the value VAL onto stream STREAM according
 348    to OPTIONS.
 349
 350    If the data are a string pointer, returns the number of string characters
 351    printed.
 352
 353    This is a preferable interface to val_print, above, because it uses
 354    GDB's value mechanism.  */
 355
 356 int
 357 common_val_print (struct value *val, struct ui_file *stream, int recurse,
 358                   const struct value_print_options *options,
 359                   const struct language_defn *language)
 360 {
 361   if (!value_check_printable (val, stream))
 362     return 0;
 363
 364   return val_print (value_type (val), value_contents_all (val),
 365                     value_embedded_offset (val), value_address (val),
 366                     stream, recurse, options, language);
 367 }
 368
 369 /* Print the value VAL in C-ish syntax on stream STREAM according to
 370    OPTIONS.
 371    If the object printed is a string pointer, returns
 372    the number of string bytes printed.  */
 373
 374 int
 375 value_print (struct value *val, struct ui_file *stream,
 376              const struct value_print_options *options)
 377 {
 378   if (!value_check_printable (val, stream))
 379     return 0;
 380
 381   if (!options->raw)
 382     {
 383       int r = apply_val_pretty_printer (value_type (val),
 384                                         value_contents_all (val),
 385                                         value_embedded_offset (val),
 386                                         value_address (val),
 387                                         stream, 0, options,
 388                                         current_language);
 389       if (r)
 390         return r;
 391     }
 392
 393   return LA_VALUE_PRINT (val, stream, options);
 394 }
 395
 396 /* Called by various <lang>_val_print routines to print
 397    TYPE_CODE_INT's.  TYPE is the type.  VALADDR is the address of the
 398    value.  STREAM is where to print the value.  */
 399
 400 void
 401 val_print_type_code_int (struct type *type, const gdb_byte *valaddr,
 402                          struct ui_file *stream)
 403 {
 404   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
 405
 406   if (TYPE_LENGTH (type) > sizeof (LONGEST))
 407     {
 408       LONGEST val;
 409
 410       if (TYPE_UNSIGNED (type)
 411           && extract_long_unsigned_integer (valaddr, TYPE_LENGTH (type),
 412                                             byte_order, &val))
 413         {
 414           print_longest (stream, 'u', 0, val);
 415         }
 416       else
 417         {
 418           /* Signed, or we couldn't turn an unsigned value into a
 419              LONGEST.  For signed values, one could assume two's
 420              complement (a reasonable assumption, I think) and do
 421              better than this.  */
 422           print_hex_chars (stream, (unsigned char *) valaddr,
 423                            TYPE_LENGTH (type), byte_order);
 424         }
 425     }
 426   else
 427     {
 428       print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0,
 429                      unpack_long (type, valaddr));
 430     }
 431 }
 432
 433 void
 434 val_print_type_code_flags (struct type *type, const gdb_byte *valaddr,
 435                            struct ui_file *stream)
 436 {
 437   ULONGEST val = unpack_long (type, valaddr);
 438   int bitpos, nfields = TYPE_NFIELDS (type);
 439
 440   fputs_filtered ("[ ", stream);
 441   for (bitpos = 0; bitpos < nfields; bitpos++)
 442     {
 443       if (TYPE_FIELD_BITPOS (type, bitpos) != -1
 444           && (val & ((ULONGEST)1 << bitpos)))
 445         {
 446           if (TYPE_FIELD_NAME (type, bitpos))
 447             fprintf_filtered (stream, "%s ", TYPE_FIELD_NAME (type, bitpos));
 448           else
 449             fprintf_filtered (stream, "#%d ", bitpos);
 450         }
 451     }
 452   fputs_filtered ("]", stream);
 453 }
 454
 455 /* Print a number according to FORMAT which is one of d,u,x,o,b,h,w,g.
 456    The raison d'etre of this function is to consolidate printing of
 457    LONG_LONG's into this one function. The format chars b,h,w,g are
 458    from print_scalar_formatted().  Numbers are printed using C
 459    format.
 460
 461    USE_C_FORMAT means to use C format in all cases.  Without it,
 462    'o' and 'x' format do not include the standard C radix prefix
 463    (leading 0 or 0x).
 464
 465    Hilfinger/2004-09-09: USE_C_FORMAT was originally called USE_LOCAL
 466    and was intended to request formating according to the current
 467    language and would be used for most integers that GDB prints.  The
 468    exceptional cases were things like protocols where the format of
 469    the integer is a protocol thing, not a user-visible thing).  The
 470    parameter remains to preserve the information of what things might
 471    be printed with language-specific format, should we ever resurrect
 472    that capability. */
 473
 474 void
 475 print_longest (struct ui_file *stream, int format, int use_c_format,
 476                LONGEST val_long)
 477 {
 478   const char *val;
 479
 480   switch (format)
 481     {
 482     case 'd':
 483       val = int_string (val_long, 10, 1, 0, 1); break;
 484     case 'u':
 485       val = int_string (val_long, 10, 0, 0, 1); break;
 486     case 'x':
 487       val = int_string (val_long, 16, 0, 0, use_c_format); break;
 488     case 'b':
 489       val = int_string (val_long, 16, 0, 2, 1); break;
 490     case 'h':
 491       val = int_string (val_long, 16, 0, 4, 1); break;
 492     case 'w':
 493       val = int_string (val_long, 16, 0, 8, 1); break;
 494     case 'g':
 495       val = int_string (val_long, 16, 0, 16, 1); break;
 496       break;
 497     case 'o':
 498       val = int_string (val_long, 8, 0, 0, use_c_format); break;
 499     default:
 500       internal_error (__FILE__, __LINE__, _("failed internal consistency check"));
 501     }
 502   fputs_filtered (val, stream);
 503 }
 504
 505 /* This used to be a macro, but I don't think it is called often enough
 506    to merit such treatment.  */
 507 /* Convert a LONGEST to an int.  This is used in contexts (e.g. number of
 508    arguments to a function, number in a value history, register number, etc.)
 509    where the value must not be larger than can fit in an int.  */
 510
 511 int
 512 longest_to_int (LONGEST arg)
 513 {
 514   /* Let the compiler do the work */
 515   int rtnval = (int) arg;
 516
 517   /* Check for overflows or underflows */
 518   if (sizeof (LONGEST) > sizeof (int))
 519     {
 520       if (rtnval != arg)
 521         {
 522           error (_("Value out of range."));
 523         }
 524     }
 525   return (rtnval);
 526 }
 527
 528 /* Print a floating point value of type TYPE (not always a
 529    TYPE_CODE_FLT), pointed to in GDB by VALADDR, on STREAM.  */
 530
 531 void
 532 print_floating (const gdb_byte *valaddr, struct type *type,
 533                 struct ui_file *stream)
 534 {
 535   DOUBLEST doub;
 536   int inv;
 537   const struct floatformat *fmt = NULL;
 538   unsigned len = TYPE_LENGTH (type);
 539   enum float_kind kind;
 540
 541   /* If it is a floating-point, check for obvious problems.  */
 542   if (TYPE_CODE (type) == TYPE_CODE_FLT)
 543     fmt = floatformat_from_type (type);
 544   if (fmt != NULL)
 545     {
 546       kind = floatformat_classify (fmt, valaddr);
 547       if (kind == float_nan)
 548         {
 549           if (floatformat_is_negative (fmt, valaddr))
 550             fprintf_filtered (stream, "-");
 551           fprintf_filtered (stream, "nan(");
 552           fputs_filtered ("0x", stream);
 553           fputs_filtered (floatformat_mantissa (fmt, valaddr), stream);
 554           fprintf_filtered (stream, ")");
 555           return;
 556         }
 557       else if (kind == float_infinite)
 558         {
 559           if (floatformat_is_negative (fmt, valaddr))
 560             fputs_filtered ("-", stream);
 561           fputs_filtered ("inf", stream);
 562           return;
 563         }
 564     }
 565
 566   /* NOTE: cagney/2002-01-15: The TYPE passed into print_floating()
 567      isn't necessarily a TYPE_CODE_FLT.  Consequently, unpack_double
 568      needs to be used as that takes care of any necessary type
 569      conversions.  Such conversions are of course direct to DOUBLEST
 570      and disregard any possible target floating point limitations.
 571      For instance, a u64 would be converted and displayed exactly on a
 572      host with 80 bit DOUBLEST but with loss of information on a host
 573      with 64 bit DOUBLEST.  */
 574
 575   doub = unpack_double (type, valaddr, &inv);
 576   if (inv)
 577     {
 578       fprintf_filtered (stream, "<invalid float value>");
 579       return;
 580     }
 581
 582   /* FIXME: kettenis/2001-01-20: The following code makes too much
 583      assumptions about the host and target floating point format.  */
 584
 585   /* NOTE: cagney/2002-02-03: Since the TYPE of what was passed in may
 586      not necessarily be a TYPE_CODE_FLT, the below ignores that and
 587      instead uses the type's length to determine the precision of the
 588      floating-point value being printed.  */
 589
 590   if (len < sizeof (double))
 591       fprintf_filtered (stream, "%.9g", (double) doub);
 592   else if (len == sizeof (double))
 593       fprintf_filtered (stream, "%.17g", (double) doub);
 594   else
 595 #ifdef PRINTF_HAS_LONG_DOUBLE
 596     fprintf_filtered (stream, "%.35Lg", doub);
 597 #else
 598     /* This at least wins with values that are representable as
 599        doubles.  */
 600     fprintf_filtered (stream, "%.17g", (double) doub);
 601 #endif
 602 }
 603
 604 void
 605 print_decimal_floating (const gdb_byte *valaddr, struct type *type,
 606                         struct ui_file *stream)
 607 {
 608   enum bfd_endian byte_order = gdbarch_byte_order (get_type_arch (type));
 609   char decstr[MAX_DECIMAL_STRING];
 610   unsigned len = TYPE_LENGTH (type);
 611
 612   decimal_to_string (valaddr, len, byte_order, decstr);
 613   fputs_filtered (decstr, stream);
 614   return;
 615 }
 616
 617 void
 618 print_binary_chars (struct ui_file *stream, const gdb_byte *valaddr,
 619                     unsigned len, enum bfd_endian byte_order)
 620 {
 621
 622 #define BITS_IN_BYTES 8
 623
 624   const gdb_byte *p;
 625   unsigned int i;
 626   int b;
 627
 628   /* Declared "int" so it will be signed.
 629    * This ensures that right shift will shift in zeros.
 630    */
 631   const int mask = 0x080;
 632
 633   /* FIXME: We should be not printing leading zeroes in most cases.  */
 634
 635   if (byte_order == BFD_ENDIAN_BIG)
 636     {
 637       for (p = valaddr;
 638            p < valaddr + len;
 639            p++)
 640         {
 641           /* Every byte has 8 binary characters; peel off
 642            * and print from the MSB end.
 643            */
 644           for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
 645             {
 646               if (*p & (mask >> i))
 647                 b = 1;
 648               else
 649                 b = 0;
 650
 651               fprintf_filtered (stream, "%1d", b);
 652             }
 653         }
 654     }
 655   else
 656     {
 657       for (p = valaddr + len - 1;
 658            p >= valaddr;
 659            p--)
 660         {
 661           for (i = 0; i < (BITS_IN_BYTES * sizeof (*p)); i++)
 662             {
 663               if (*p & (mask >> i))
 664                 b = 1;
 665               else
 666                 b = 0;
 667
 668               fprintf_filtered (stream, "%1d", b);
 669             }
 670         }
 671     }
 672 }
 673
 674 /* VALADDR points to an integer of LEN bytes.
 675  * Print it in octal on stream or format it in buf.
 676  */
 677 void
 678 print_octal_chars (struct ui_file *stream, const gdb_byte *valaddr,
 679                    unsigned len, enum bfd_endian byte_order)
 680 {
 681   const gdb_byte *p;
 682   unsigned char octa1, octa2, octa3, carry;
 683   int cycle;
 684
 685   /* FIXME: We should be not printing leading zeroes in most cases.  */
 686
 687
 688   /* Octal is 3 bits, which doesn't fit.  Yuk.  So we have to track
 689    * the extra bits, which cycle every three bytes:
 690    *
 691    * Byte side:       0            1             2          3
 692    *                         |             |            |            |
 693    * bit number   123 456 78 | 9 012 345 6 | 78 901 234 | 567 890 12 |
 694    *
 695    * Octal side:   0   1   carry  3   4  carry ...
 696    *
 697    * Cycle number:    0             1            2
 698    *
 699    * But of course we are printing from the high side, so we have to
 700    * figure out where in the cycle we are so that we end up with no
 701    * left over bits at the end.
 702    */
 703 #define BITS_IN_OCTAL 3
 704 #define HIGH_ZERO     0340
 705 #define LOW_ZERO      0016
 706 #define CARRY_ZERO    0003
 707 #define HIGH_ONE      0200
 708 #define MID_ONE       0160
 709 #define LOW_ONE       0016
 710 #define CARRY_ONE     0001
 711 #define HIGH_TWO      0300
 712 #define MID_TWO       0070
 713 #define LOW_TWO       0007
 714
 715   /* For 32 we start in cycle 2, with two bits and one bit carry;
 716    * for 64 in cycle in cycle 1, with one bit and a two bit carry.
 717    */
 718   cycle = (len * BITS_IN_BYTES) % BITS_IN_OCTAL;
 719   carry = 0;
 720
 721   fputs_filtered ("0", stream);
 722   if (byte_order == BFD_ENDIAN_BIG)
 723     {
 724       for (p = valaddr;
 725            p < valaddr + len;
 726            p++)
 727         {
 728           switch (cycle)
 729             {
 730             case 0:
 731               /* No carry in, carry out two bits.
 732                */
 733               octa1 = (HIGH_ZERO & *p) >> 5;
 734               octa2 = (LOW_ZERO & *p) >> 2;
 735               carry = (CARRY_ZERO & *p);
 736               fprintf_filtered (stream, "%o", octa1);
 737               fprintf_filtered (stream, "%o", octa2);
 738               break;
 739
 740             case 1:
 741               /* Carry in two bits, carry out one bit.
 742                */
 743               octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
 744               octa2 = (MID_ONE & *p) >> 4;
 745               octa3 = (LOW_ONE & *p) >> 1;
 746               carry = (CARRY_ONE & *p);
 747               fprintf_filtered (stream, "%o", octa1);
 748               fprintf_filtered (stream, "%o", octa2);
 749               fprintf_filtered (stream, "%o", octa3);
 750               break;
 751
 752             case 2:
 753               /* Carry in one bit, no carry out.
 754                */
 755               octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
 756               octa2 = (MID_TWO & *p) >> 3;
 757               octa3 = (LOW_TWO & *p);
 758               carry = 0;
 759               fprintf_filtered (stream, "%o", octa1);
 760               fprintf_filtered (stream, "%o", octa2);
 761               fprintf_filtered (stream, "%o", octa3);
 762               break;
 763
 764             default:
 765               error (_("Internal error in octal conversion;"));
 766             }
 767
 768           cycle++;
 769           cycle = cycle % BITS_IN_OCTAL;
 770         }
 771     }
 772   else
 773     {
 774       for (p = valaddr + len - 1;
 775            p >= valaddr;
 776            p--)
 777         {
 778           switch (cycle)
 779             {
 780             case 0:
 781               /* Carry out, no carry in */
 782               octa1 = (HIGH_ZERO & *p) >> 5;
 783               octa2 = (LOW_ZERO & *p) >> 2;
 784               carry = (CARRY_ZERO & *p);
 785               fprintf_filtered (stream, "%o", octa1);
 786               fprintf_filtered (stream, "%o", octa2);
 787               break;
 788
 789             case 1:
 790               /* Carry in, carry out */
 791               octa1 = (carry << 1) | ((HIGH_ONE & *p) >> 7);
 792               octa2 = (MID_ONE & *p) >> 4;
 793               octa3 = (LOW_ONE & *p) >> 1;
 794               carry = (CARRY_ONE & *p);
 795               fprintf_filtered (stream, "%o", octa1);
 796               fprintf_filtered (stream, "%o", octa2);
 797               fprintf_filtered (stream, "%o", octa3);
 798               break;
 799
 800             case 2:
 801               /* Carry in, no carry out */
 802               octa1 = (carry << 2) | ((HIGH_TWO & *p) >> 6);
 803               octa2 = (MID_TWO & *p) >> 3;
 804               octa3 = (LOW_TWO & *p);
 805               carry = 0;
 806               fprintf_filtered (stream, "%o", octa1);
 807               fprintf_filtered (stream, "%o", octa2);
 808               fprintf_filtered (stream, "%o", octa3);
 809               break;
 810
 811             default:
 812               error (_("Internal error in octal conversion;"));
 813             }
 814
 815           cycle++;
 816           cycle = cycle % BITS_IN_OCTAL;
 817         }
 818     }
 819
 820 }
 821
 822 /* VALADDR points to an integer of LEN bytes.
 823  * Print it in decimal on stream or format it in buf.
 824  */
 825 void
 826 print_decimal_chars (struct ui_file *stream, const gdb_byte *valaddr,
 827                      unsigned len, enum bfd_endian byte_order)
 828 {
 829 #define TEN             10
 830 #define CARRY_OUT(  x ) ((x) / TEN)     /* extend char to int */
 831 #define CARRY_LEFT( x ) ((x) % TEN)
 832 #define SHIFT( x )      ((x) << 4)
 833 #define LOW_NIBBLE(  x ) ( (x) & 0x00F)
 834 #define HIGH_NIBBLE( x ) (((x) & 0x0F0) >> 4)
 835
 836   const gdb_byte *p;
 837   unsigned char *digits;
 838   int carry;
 839   int decimal_len;
 840   int i, j, decimal_digits;
 841   int dummy;
 842   int flip;
 843
 844   /* Base-ten number is less than twice as many digits
 845    * as the base 16 number, which is 2 digits per byte.
 846    */
 847   decimal_len = len * 2 * 2;
 848   digits = xmalloc (decimal_len);
 849
 850   for (i = 0; i < decimal_len; i++)
 851     {
 852       digits[i] = 0;
 853     }
 854
 855   /* Ok, we have an unknown number of bytes of data to be printed in
 856    * decimal.
 857    *
 858    * Given a hex number (in nibbles) as XYZ, we start by taking X and
 859    * decemalizing it as "x1 x2" in two decimal nibbles.  Then we multiply
 860    * the nibbles by 16, add Y and re-decimalize.  Repeat with Z.
 861    *
 862    * The trick is that "digits" holds a base-10 number, but sometimes
 863    * the individual digits are > 10.
 864    *
 865    * Outer loop is per nibble (hex digit) of input, from MSD end to
 866    * LSD end.
 867    */
 868   decimal_digits = 0;           /* Number of decimal digits so far */
 869   p = (byte_order == BFD_ENDIAN_BIG) ? valaddr : valaddr + len - 1;
 870   flip = 0;
 871   while ((byte_order == BFD_ENDIAN_BIG) ? (p < valaddr + len) : (p >= valaddr))
 872     {
 873       /*
 874        * Multiply current base-ten number by 16 in place.
 875        * Each digit was between 0 and 9, now is between
 876        * 0 and 144.
 877        */
 878       for (j = 0; j < decimal_digits; j++)
 879         {
 880           digits[j] = SHIFT (digits[j]);
 881         }
 882
 883       /* Take the next nibble off the input and add it to what
 884        * we've got in the LSB position.  Bottom 'digit' is now
 885        * between 0 and 159.
 886        *
 887        * "flip" is used to run this loop twice for each byte.
 888        */
 889       if (flip == 0)
 890         {
 891           /* Take top nibble.
 892            */
 893           digits[0] += HIGH_NIBBLE (*p);
 894           flip = 1;
 895         }
 896       else
 897         {
 898           /* Take low nibble and bump our pointer "p".
 899            */
 900           digits[0] += LOW_NIBBLE (*p);
 901           if (byte_order == BFD_ENDIAN_BIG)
 902             p++;
 903           else
 904             p--;
 905           flip = 0;
 906         }
 907
 908       /* Re-decimalize.  We have to do this often enough
 909        * that we don't overflow, but once per nibble is
 910        * overkill.  Easier this way, though.  Note that the
 911        * carry is often larger than 10 (e.g. max initial
 912        * carry out of lowest nibble is 15, could bubble all
 913        * the way up greater than 10).  So we have to do
 914        * the carrying beyond the last current digit.
 915        */
 916       carry = 0;
 917       for (j = 0; j < decimal_len - 1; j++)
 918         {
 919           digits[j] += carry;
 920
 921           /* "/" won't handle an unsigned char with
 922            * a value that if signed would be negative.
 923            * So extend to longword int via "dummy".
 924            */
 925           dummy = digits[j];
 926           carry = CARRY_OUT (dummy);
 927           digits[j] = CARRY_LEFT (dummy);
 928
 929           if (j >= decimal_digits && carry == 0)
 930             {
 931               /*
 932                * All higher digits are 0 and we
 933                * no longer have a carry.
 934                *
 935                * Note: "j" is 0-based, "decimal_digits" is
 936                *       1-based.
 937                */
 938               decimal_digits = j + 1;
 939               break;
 940             }
 941         }
 942     }
 943
 944   /* Ok, now "digits" is the decimal representation, with
 945    * the "decimal_digits" actual digits.  Print!
 946    */
 947   for (i = decimal_digits - 1; i >= 0; i--)
 948     {
 949       fprintf_filtered (stream, "%1d", digits[i]);
 950     }
 951   xfree (digits);
 952 }
 953
 954 /* VALADDR points to an integer of LEN bytes.  Print it in hex on stream.  */
 955
 956 void
 957 print_hex_chars (struct ui_file *stream, const gdb_byte *valaddr,
 958                  unsigned len, enum bfd_endian byte_order)
 959 {
 960   const gdb_byte *p;
 961
 962   /* FIXME: We should be not printing leading zeroes in most cases.  */
 963
 964   fputs_filtered ("0x", stream);
 965   if (byte_order == BFD_ENDIAN_BIG)
 966     {
 967       for (p = valaddr;
 968            p < valaddr + len;
 969            p++)
 970         {
 971           fprintf_filtered (stream, "%02x", *p);
 972         }
 973     }
 974   else
 975     {
 976       for (p = valaddr + len - 1;
 977            p >= valaddr;
 978            p--)
 979         {
 980           fprintf_filtered (stream, "%02x", *p);
 981         }
 982     }
 983 }
 984
 985 /* VALADDR points to a char integer of LEN bytes.  Print it out in appropriate language form on stream.
 986    Omit any leading zero chars.  */
 987
 988 void
 989 print_char_chars (struct ui_file *stream, struct type *type,
 990                   const gdb_byte *valaddr,
 991                   unsigned len, enum bfd_endian byte_order)
 992 {
 993   const gdb_byte *p;
 994
 995   if (byte_order == BFD_ENDIAN_BIG)
 996     {
 997       p = valaddr;
 998       while (p < valaddr + len - 1 && *p == 0)
 999         ++p;
1000
1001       while (p < valaddr + len)
1002         {
1003           LA_EMIT_CHAR (*p, type, stream, '\'');
1004           ++p;
1005         }
1006     }
1007   else
1008     {
1009       p = valaddr + len - 1;
1010       while (p > valaddr && *p == 0)
1011         --p;
1012
1013       while (p >= valaddr)
1014         {
1015           LA_EMIT_CHAR (*p, type, stream, '\'');
1016           --p;
1017         }
1018     }
1019 }
1020
1021 /* Assuming TYPE is a simple, non-empty array type, compute its upper
1022    and lower bound.  Save the low bound into LOW_BOUND if not NULL.
1023    Save the high bound into HIGH_BOUND if not NULL.
1024
1025    Return 1 if the operation was successful. Return zero otherwise,
1026    in which case the values of LOW_BOUND and HIGH_BOUNDS are unmodified.
1027
1028    Computing the array upper and lower bounds is pretty easy, but this
1029    function does some additional verifications before returning them.
1030    If something incorrect is detected, it is better to return a status
1031    rather than throwing an error, making it easier for the caller to
1032    implement an error-recovery plan.  For instance, it may decide to
1033    warn the user that the bounds were not found and then use some
1034    default values instead.  */
1035
1036 int
1037 get_array_bounds (struct type *type, long *low_bound, long *high_bound)
1038 {
1039   struct type *index = TYPE_INDEX_TYPE (type);
1040   long low = 0;
1041   long high = 0;
1042
1043   if (index == NULL)
1044     return 0;
1045
1046   if (TYPE_CODE (index) == TYPE_CODE_RANGE)
1047     {
1048       low = TYPE_LOW_BOUND (index);
1049       high = TYPE_HIGH_BOUND (index);
1050     }
1051   else if (TYPE_CODE (index) == TYPE_CODE_ENUM)
1052     {
1053       const int n_enums = TYPE_NFIELDS (index);
1054
1055       low = TYPE_FIELD_BITPOS (index, 0);
1056       high = TYPE_FIELD_BITPOS (index, n_enums - 1);
1057     }
1058   else
1059     return 0;
1060
1061   /* Abort if the lower bound is greater than the higher bound, except
1062      when low = high + 1.  This is a very common idiom used in Ada when
1063      defining empty ranges (for instance "range 1 .. 0").  */
1064   if (low > high + 1)
1065     return 0;
1066
1067   if (low_bound)
1068     *low_bound = low;
1069
1070   if (high_bound)
1071     *high_bound = high;
1072
1073   return 1;
1074 }
1075
1076 /* Print on STREAM using the given OPTIONS the index for the element
1077    at INDEX of an array whose index type is INDEX_TYPE.  */
1078
1079 void
1080 maybe_print_array_index (struct type *index_type, LONGEST index,
1081                          struct ui_file *stream,
1082                          const struct value_print_options *options)
1083 {
1084   struct value *index_value;
1085
1086   if (!options->print_array_indexes)
1087     return;
1088
1089   index_value = value_from_longest (index_type, index);
1090
1091   LA_PRINT_ARRAY_INDEX (index_value, stream, options);
1092 }
1093
1094 /*  Called by various <lang>_val_print routines to print elements of an
1095    array in the form "<elem1>, <elem2>, <elem3>, ...".
1096
1097    (FIXME?)  Assumes array element separator is a comma, which is correct
1098    for all languages currently handled.
1099    (FIXME?)  Some languages have a notation for repeated array elements,
1100    perhaps we should try to use that notation when appropriate.
1101  */
1102
1103 void
1104 val_print_array_elements (struct type *type, const gdb_byte *valaddr,
1105                           CORE_ADDR address, struct ui_file *stream,
1106                           int recurse,
1107                           const struct value_print_options *options,
1108                           unsigned int i)
1109 {
1110   unsigned int things_printed = 0;
1111   unsigned len;
1112   struct type *elttype, *index_type;
1113   unsigned eltlen;
1114   /* Position of the array element we are examining to see
1115      whether it is repeated.  */
1116   unsigned int rep1;
1117   /* Number of repetitions we have detected so far.  */
1118   unsigned int reps;
1119   long low_bound_index = 0;
1120
1121   elttype = TYPE_TARGET_TYPE (type);
1122   eltlen = TYPE_LENGTH (check_typedef (elttype));
1123   index_type = TYPE_INDEX_TYPE (type);
1124
1125   /* Compute the number of elements in the array.  On most arrays,
1126      the size of its elements is not zero, and so the number of elements
1127      is simply the size of the array divided by the size of the elements.
1128      But for arrays of elements whose size is zero, we need to look at
1129      the bounds.  */
1130   if (eltlen != 0)
1131     len = TYPE_LENGTH (type) / eltlen;
1132   else
1133     {
1134       long low, hi;
1135       if (get_array_bounds (type, &low, &hi))
1136         len = hi - low + 1;
1137       else
1138         {
1139           warning (_("unable to get bounds of array, assuming null array"));
1140           len = 0;
1141         }
1142     }
1143
1144   /* Get the array low bound.  This only makes sense if the array
1145      has one or more element in it.  */
1146   if (len > 0 && !get_array_bounds (type, &low_bound_index, NULL))
1147     {
1148       warning (_("unable to get low bound of array, using zero as default"));
1149       low_bound_index = 0;
1150     }
1151
1152   annotate_array_section_begin (i, elttype);
1153
1154   for (; i < len && things_printed < options->print_max; i++)
1155     {
1156       if (i != 0)
1157         {
1158           if (options->prettyprint_arrays)
1159             {
1160               fprintf_filtered (stream, ",\n");
1161               print_spaces_filtered (2 + 2 * recurse, stream);
1162             }
1163           else
1164             {
1165               fprintf_filtered (stream, ", ");
1166             }
1167         }
1168       wrap_here (n_spaces (2 + 2 * recurse));
1169       maybe_print_array_index (index_type, i + low_bound_index,
1170                                stream, options);
1171
1172       rep1 = i + 1;
1173       reps = 1;
1174       while ((rep1 < len) &&
1175              !memcmp (valaddr + i * eltlen, valaddr + rep1 * eltlen, eltlen))
1176         {
1177           ++reps;
1178           ++rep1;
1179         }
1180
1181       if (reps > options->repeat_count_threshold)
1182         {
1183           val_print (elttype, valaddr + i * eltlen, 0, address + i * eltlen,
1184                      stream, recurse + 1, options, current_language);
1185           annotate_elt_rep (reps);
1186           fprintf_filtered (stream, " <repeats %u times>", reps);
1187           annotate_elt_rep_end ();
1188
1189           i = rep1 - 1;
1190           things_printed += options->repeat_count_threshold;
1191         }
1192       else
1193         {
1194           val_print (elttype, valaddr + i * eltlen, 0, address + i * eltlen,
1195                      stream, recurse + 1, options, current_language);
1196           annotate_elt ();
1197           things_printed++;
1198         }
1199     }
1200   annotate_array_section_end ();
1201   if (i < len)
1202     {
1203       fprintf_filtered (stream, "...");
1204     }
1205 }
1206
1207 /* Read LEN bytes of target memory at address MEMADDR, placing the
1208    results in GDB's memory at MYADDR.  Returns a count of the bytes
1209    actually read, and optionally an errno value in the location
1210    pointed to by ERRNOPTR if ERRNOPTR is non-null. */
1211
1212 /* FIXME: cagney/1999-10-14: Only used by val_print_string.  Can this
1213    function be eliminated.  */
1214
1215 static int
1216 partial_memory_read (CORE_ADDR memaddr, gdb_byte *myaddr, int len, int *errnoptr)
1217 {
1218   int nread;                    /* Number of bytes actually read. */
1219   int errcode;                  /* Error from last read. */
1220
1221   /* First try a complete read. */
1222   errcode = target_read_memory (memaddr, myaddr, len);
1223   if (errcode == 0)
1224     {
1225       /* Got it all. */
1226       nread = len;
1227     }
1228   else
1229     {
1230       /* Loop, reading one byte at a time until we get as much as we can. */
1231       for (errcode = 0, nread = 0; len > 0 && errcode == 0; nread++, len--)
1232         {
1233           errcode = target_read_memory (memaddr++, myaddr++, 1);
1234         }
1235       /* If an error, the last read was unsuccessful, so adjust count. */
1236       if (errcode != 0)
1237         {
1238           nread--;
1239         }
1240     }
1241   if (errnoptr != NULL)
1242     {
1243       *errnoptr = errcode;
1244     }
1245   return (nread);
1246 }
1247
1248 /* Read a string from the inferior, at ADDR, with LEN characters of WIDTH bytes
1249    each.  Fetch at most FETCHLIMIT characters.  BUFFER will be set to a newly
1250    allocated buffer containing the string, which the caller is responsible to
1251    free, and BYTES_READ will be set to the number of bytes read.  Returns 0 on
1252    success, or errno on failure.
1253
1254    If LEN > 0, reads exactly LEN characters (including eventual NULs in
1255    the middle or end of the string).  If LEN is -1, stops at the first
1256    null character (not necessarily the first null byte) up to a maximum
1257    of FETCHLIMIT characters.  Set FETCHLIMIT to UINT_MAX to read as many
1258    characters as possible from the string.
1259
1260    Unless an exception is thrown, BUFFER will always be allocated, even on
1261    failure.  In this case, some characters might have been read before the
1262    failure happened.  Check BYTES_READ to recognize this situation.
1263
1264    Note: There was a FIXME asking to make this code use target_read_string,
1265    but this function is more general (can read past null characters, up to
1266    given LEN). Besides, it is used much more often than target_read_string
1267    so it is more tested.  Perhaps callers of target_read_string should use
1268    this function instead?  */
1269
1270 int
1271 read_string (CORE_ADDR addr, int len, int width, unsigned int fetchlimit,
1272              enum bfd_endian byte_order, gdb_byte **buffer, int *bytes_read)
1273 {
1274   int found_nul;                /* Non-zero if we found the nul char.  */
1275   int errcode;                  /* Errno returned from bad reads.  */
1276   unsigned int nfetch;          /* Chars to fetch / chars fetched.  */
1277   unsigned int chunksize;       /* Size of each fetch, in chars.  */
1278   gdb_byte *bufptr;             /* Pointer to next available byte in buffer.  */
1279   gdb_byte *limit;              /* First location past end of fetch buffer.  */
1280   struct cleanup *old_chain = NULL;     /* Top of the old cleanup chain.  */
1281
1282   /* Decide how large of chunks to try to read in one operation.  This
1283      is also pretty simple.  If LEN >= zero, then we want fetchlimit chars,
1284      so we might as well read them all in one operation.  If LEN is -1, we
1285      are looking for a NUL terminator to end the fetching, so we might as
1286      well read in blocks that are large enough to be efficient, but not so
1287      large as to be slow if fetchlimit happens to be large.  So we choose the
1288      minimum of 8 and fetchlimit.  We used to use 200 instead of 8 but
1289      200 is way too big for remote debugging over a serial line.  */
1290
1291   chunksize = (len == -1 ? min (8, fetchlimit) : fetchlimit);
1292
1293   /* Loop until we either have all the characters, or we encounter
1294      some error, such as bumping into the end of the address space.  */
1295
1296   found_nul = 0;
1297   *buffer = NULL;
1298
1299   old_chain = make_cleanup (free_current_contents, buffer);
1300
1301   if (len > 0)
1302     {
1303       *buffer = (gdb_byte *) xmalloc (len * width);
1304       bufptr = *buffer;
1305
1306       nfetch = partial_memory_read (addr, bufptr, len * width, &errcode)
1307         / width;
1308       addr += nfetch * width;
1309       bufptr += nfetch * width;
1310     }
1311   else if (len == -1)
1312     {
1313       unsigned long bufsize = 0;
1314
1315       do
1316         {
1317           QUIT;
1318           nfetch = min (chunksize, fetchlimit - bufsize);
1319
1320           if (*buffer == NULL)
1321             *buffer = (gdb_byte *) xmalloc (nfetch * width);
1322           else
1323             *buffer = (gdb_byte *) xrealloc (*buffer,
1324                                              (nfetch + bufsize) * width);
1325
1326           bufptr = *buffer + bufsize * width;
1327           bufsize += nfetch;
1328
1329           /* Read as much as we can.  */
1330           nfetch = partial_memory_read (addr, bufptr, nfetch * width, &errcode)
1331                     / width;
1332
1333           /* Scan this chunk for the null character that terminates the string
1334              to print.  If found, we don't need to fetch any more.  Note
1335              that bufptr is explicitly left pointing at the next character
1336              after the null character, or at the next character after the end
1337              of the buffer.  */
1338
1339           limit = bufptr + nfetch * width;
1340           while (bufptr < limit)
1341             {
1342               unsigned long c;
1343
1344               c = extract_unsigned_integer (bufptr, width, byte_order);
1345               addr += width;
1346               bufptr += width;
1347               if (c == 0)
1348                 {
1349                   /* We don't care about any error which happened after
1350                      the NUL terminator.  */
1351                   errcode = 0;
1352                   found_nul = 1;
1353                   break;
1354                 }
1355             }
1356         }
1357       while (errcode == 0       /* no error */
1358              && bufptr - *buffer < fetchlimit * width   /* no overrun */
1359              && !found_nul);    /* haven't found NUL yet */
1360     }
1361   else
1362     {                           /* Length of string is really 0!  */
1363       /* We always allocate *buffer.  */
1364       *buffer = bufptr = xmalloc (1);
1365       errcode = 0;
1366     }
1367
1368   /* bufptr and addr now point immediately beyond the last byte which we
1369      consider part of the string (including a '\0' which ends the string).  */
1370   *bytes_read = bufptr - *buffer;
1371
1372   QUIT;
1373
1374   discard_cleanups (old_chain);
1375
1376   return errcode;
1377 }
1378
1379 /* Print a string from the inferior, starting at ADDR and printing up to LEN
1380    characters, of WIDTH bytes a piece, to STREAM.  If LEN is -1, printing
1381    stops at the first null byte, otherwise printing proceeds (including null
1382    bytes) until either print_max or LEN characters have been printed,
1383    whichever is smaller.  */
1384
1385 int
1386 val_print_string (struct type *elttype, CORE_ADDR addr, int len,
1387                   struct ui_file *stream,
1388                   const struct value_print_options *options)
1389 {
1390   int force_ellipsis = 0;       /* Force ellipsis to be printed if nonzero.  */
1391   int errcode;                  /* Errno returned from bad reads.  */
1392   int found_nul;                /* Non-zero if we found the nul char */
1393   unsigned int fetchlimit;      /* Maximum number of chars to print.  */
1394   int bytes_read;
1395   gdb_byte *buffer = NULL;      /* Dynamically growable fetch buffer.  */
1396   struct cleanup *old_chain = NULL;     /* Top of the old cleanup chain.  */
1397   struct gdbarch *gdbarch = get_type_arch (elttype);
1398   enum bfd_endian byte_order = gdbarch_byte_order (gdbarch);
1399   int width = TYPE_LENGTH (elttype);
1400
1401   /* First we need to figure out the limit on the number of characters we are
1402      going to attempt to fetch and print.  This is actually pretty simple.  If
1403      LEN >= zero, then the limit is the minimum of LEN and print_max.  If
1404      LEN is -1, then the limit is print_max.  This is true regardless of
1405      whether print_max is zero, UINT_MAX (unlimited), or something in between,
1406      because finding the null byte (or available memory) is what actually
1407      limits the fetch.  */
1408
1409   fetchlimit = (len == -1 ? options->print_max : min (len, options->print_max));
1410
1411   errcode = read_string (addr, len, width, fetchlimit, byte_order,
1412                          &buffer, &bytes_read);
1413   old_chain = make_cleanup (xfree, buffer);
1414
1415   addr += bytes_read;
1416
1417   /* We now have either successfully filled the buffer to fetchlimit, or
1418      terminated early due to an error or finding a null char when LEN is -1.  */
1419
1420   /* Determine found_nul by looking at the last character read.  */
1421   found_nul = extract_unsigned_integer (buffer + bytes_read - width, width,
1422                                         byte_order) == 0;
1423   if (len == -1 && !found_nul)
1424     {
1425       gdb_byte *peekbuf;
1426
1427       /* We didn't find a NUL terminator we were looking for.  Attempt
1428          to peek at the next character.  If not successful, or it is not
1429          a null byte, then force ellipsis to be printed.  */
1430
1431       peekbuf = (gdb_byte *) alloca (width);
1432
1433       if (target_read_memory (addr, peekbuf, width) == 0
1434           && extract_unsigned_integer (peekbuf, width, byte_order) != 0)
1435         force_ellipsis = 1;
1436     }
1437   else if ((len >= 0 && errcode != 0) || (len > bytes_read / width))
1438     {
1439       /* Getting an error when we have a requested length, or fetching less
1440          than the number of characters actually requested, always make us
1441          print ellipsis.  */
1442       force_ellipsis = 1;
1443     }
1444
1445   /* If we get an error before fetching anything, don't print a string.
1446      But if we fetch something and then get an error, print the string
1447      and then the error message.  */
1448   if (errcode == 0 || bytes_read > 0)
1449     {
1450       if (options->addressprint)
1451         {
1452           fputs_filtered (" ", stream);
1453         }
1454       LA_PRINT_STRING (stream, elttype, buffer, bytes_read / width, force_ellipsis, options);
1455     }
1456
1457   if (errcode != 0)
1458     {
1459       if (errcode == EIO)
1460         {
1461           fprintf_filtered (stream, " <Address ");
1462           fputs_filtered (paddress (gdbarch, addr), stream);
1463           fprintf_filtered (stream, " out of bounds>");
1464         }
1465       else
1466         {
1467           fprintf_filtered (stream, " <Error reading address ");
1468           fputs_filtered (paddress (gdbarch, addr), stream);
1469           fprintf_filtered (stream, ": %s>", safe_strerror (errcode));
1470         }
1471     }
1472
1473   gdb_flush (stream);
1474   do_cleanups (old_chain);
1475
1476   return (bytes_read / width);
1477 }
1478 \f
1479
1480 /* The 'set input-radix' command writes to this auxiliary variable.
1481    If the requested radix is valid, INPUT_RADIX is updated; otherwise,
1482    it is left unchanged.  */
1483
1484 static unsigned input_radix_1 = 10;
1485
1486 /* Validate an input or output radix setting, and make sure the user
1487    knows what they really did here.  Radix setting is confusing, e.g.
1488    setting the input radix to "10" never changes it!  */
1489
1490 static void
1491 set_input_radix (char *args, int from_tty, struct cmd_list_element *c)
1492 {
1493   set_input_radix_1 (from_tty, input_radix_1);
1494 }
1495
1496 static void
1497 set_input_radix_1 (int from_tty, unsigned radix)
1498 {
1499   /* We don't currently disallow any input radix except 0 or 1, which don't
1500      make any mathematical sense.  In theory, we can deal with any input
1501      radix greater than 1, even if we don't have unique digits for every
1502      value from 0 to radix-1, but in practice we lose on large radix values.
1503      We should either fix the lossage or restrict the radix range more.
1504      (FIXME). */
1505
1506   if (radix < 2)
1507     {
1508       input_radix_1 = input_radix;
1509       error (_("Nonsense input radix ``decimal %u''; input radix unchanged."),
1510              radix);
1511     }
1512   input_radix_1 = input_radix = radix;
1513   if (from_tty)
1514     {
1515       printf_filtered (_("Input radix now set to decimal %u, hex %x, octal %o.\n"),
1516                        radix, radix, radix);
1517     }
1518 }
1519
1520 /* The 'set output-radix' command writes to this auxiliary variable.
1521    If the requested radix is valid, OUTPUT_RADIX is updated,
1522    otherwise, it is left unchanged.  */
1523
1524 static unsigned output_radix_1 = 10;
1525
1526 static void
1527 set_output_radix (char *args, int from_tty, struct cmd_list_element *c)
1528 {
1529   set_output_radix_1 (from_tty, output_radix_1);
1530 }
1531
1532 static void
1533 set_output_radix_1 (int from_tty, unsigned radix)
1534 {
1535   /* Validate the radix and disallow ones that we aren't prepared to
1536      handle correctly, leaving the radix unchanged. */
1537   switch (radix)
1538     {
1539     case 16:
1540       user_print_options.output_format = 'x';   /* hex */
1541       break;
1542     case 10:
1543       user_print_options.output_format = 0;     /* decimal */
1544       break;
1545     case 8:
1546       user_print_options.output_format = 'o';   /* octal */
1547       break;
1548     default:
1549       output_radix_1 = output_radix;
1550       error (_("Unsupported output radix ``decimal %u''; output radix unchanged."),
1551              radix);
1552     }
1553   output_radix_1 = output_radix = radix;
1554   if (from_tty)
1555     {
1556       printf_filtered (_("Output radix now set to decimal %u, hex %x, octal %o.\n"),
1557                        radix, radix, radix);
1558     }
1559 }
1560
1561 /* Set both the input and output radix at once.  Try to set the output radix
1562    first, since it has the most restrictive range.  An radix that is valid as
1563    an output radix is also valid as an input radix.
1564
1565    It may be useful to have an unusual input radix.  If the user wishes to
1566    set an input radix that is not valid as an output radix, he needs to use
1567    the 'set input-radix' command. */
1568
1569 static void
1570 set_radix (char *arg, int from_tty)
1571 {
1572   unsigned radix;
1573
1574   radix = (arg == NULL) ? 10 : parse_and_eval_long (arg);
1575   set_output_radix_1 (0, radix);
1576   set_input_radix_1 (0, radix);
1577   if (from_tty)
1578     {
1579       printf_filtered (_("Input and output radices now set to decimal %u, hex %x, octal %o.\n"),
1580                        radix, radix, radix);
1581     }
1582 }
1583
1584 /* Show both the input and output radices. */
1585
1586 static void
1587 show_radix (char *arg, int from_tty)
1588 {
1589   if (from_tty)
1590     {
1591       if (input_radix == output_radix)
1592         {
1593           printf_filtered (_("Input and output radices set to decimal %u, hex %x, octal %o.\n"),
1594                            input_radix, input_radix, input_radix);
1595         }
1596       else
1597         {
1598           printf_filtered (_("Input radix set to decimal %u, hex %x, octal %o.\n"),
1599                            input_radix, input_radix, input_radix);
1600           printf_filtered (_("Output radix set to decimal %u, hex %x, octal %o.\n"),
1601                            output_radix, output_radix, output_radix);
1602         }
1603     }
1604 }
1605 \f
1606
1607 static void
1608 set_print (char *arg, int from_tty)
1609 {
1610   printf_unfiltered (
1611      "\"set print\" must be followed by the name of a print subcommand.\n");
1612   help_list (setprintlist, "set print ", -1, gdb_stdout);
1613 }
1614
1615 static void
1616 show_print (char *args, int from_tty)
1617 {
1618   cmd_show_list (showprintlist, from_tty, "");
1619 }
1620 \f
1621 void
1622 _initialize_valprint (void)
1623 {
1624   struct cmd_list_element *c;
1625
1626   add_prefix_cmd ("print", no_class, set_print,
1627                   _("Generic command for setting how things print."),
1628                   &setprintlist, "set print ", 0, &setlist);
1629   add_alias_cmd ("p", "print", no_class, 1, &setlist);
1630   /* prefer set print to set prompt */
1631   add_alias_cmd ("pr", "print", no_class, 1, &setlist);
1632
1633   add_prefix_cmd ("print", no_class, show_print,
1634                   _("Generic command for showing print settings."),
1635                   &showprintlist, "show print ", 0, &showlist);
1636   add_alias_cmd ("p", "print", no_class, 1, &showlist);
1637   add_alias_cmd ("pr", "print", no_class, 1, &showlist);
1638
1639   add_setshow_uinteger_cmd ("elements", no_class,
1640                             &user_print_options.print_max, _("\
1641 Set limit on string chars or array elements to print."), _("\
1642 Show limit on string chars or array elements to print."), _("\
1643 \"set print elements 0\" causes there to be no limit."),
1644                             NULL,
1645                             show_print_max,
1646                             &setprintlist, &showprintlist);
1647
1648   add_setshow_boolean_cmd ("null-stop", no_class,
1649                            &user_print_options.stop_print_at_null, _("\
1650 Set printing of char arrays to stop at first null char."), _("\
1651 Show printing of char arrays to stop at first null char."), NULL,
1652                            NULL,
1653                            show_stop_print_at_null,
1654                            &setprintlist, &showprintlist);
1655
1656   add_setshow_uinteger_cmd ("repeats", no_class,
1657                             &user_print_options.repeat_count_threshold, _("\
1658 Set threshold for repeated print elements."), _("\
1659 Show threshold for repeated print elements."), _("\
1660 \"set print repeats 0\" causes all elements to be individually printed."),
1661                             NULL,
1662                             show_repeat_count_threshold,
1663                             &setprintlist, &showprintlist);
1664
1665   add_setshow_boolean_cmd ("pretty", class_support,
1666                            &user_print_options.prettyprint_structs, _("\
1667 Set prettyprinting of structures."), _("\
1668 Show prettyprinting of structures."), NULL,
1669                            NULL,
1670                            show_prettyprint_structs,
1671                            &setprintlist, &showprintlist);
1672
1673   add_setshow_boolean_cmd ("union", class_support,
1674                            &user_print_options.unionprint, _("\
1675 Set printing of unions interior to structures."), _("\
1676 Show printing of unions interior to structures."), NULL,
1677                            NULL,
1678                            show_unionprint,
1679                            &setprintlist, &showprintlist);
1680
1681   add_setshow_boolean_cmd ("array", class_support,
1682                            &user_print_options.prettyprint_arrays, _("\
1683 Set prettyprinting of arrays."), _("\
1684 Show prettyprinting of arrays."), NULL,
1685                            NULL,
1686                            show_prettyprint_arrays,
1687                            &setprintlist, &showprintlist);
1688
1689   add_setshow_boolean_cmd ("address", class_support,
1690                            &user_print_options.addressprint, _("\
1691 Set printing of addresses."), _("\
1692 Show printing of addresses."), NULL,
1693                            NULL,
1694                            show_addressprint,
1695                            &setprintlist, &showprintlist);
1696
1697   add_setshow_zuinteger_cmd ("input-radix", class_support, &input_radix_1,
1698                              _("\
1699 Set default input radix for entering numbers."), _("\
1700 Show default input radix for entering numbers."), NULL,
1701                              set_input_radix,
1702                              show_input_radix,
1703                              &setlist, &showlist);
1704
1705   add_setshow_zuinteger_cmd ("output-radix", class_support, &output_radix_1,
1706                              _("\
1707 Set default output radix for printing of values."), _("\
1708 Show default output radix for printing of values."), NULL,
1709                              set_output_radix,
1710                              show_output_radix,
1711                              &setlist, &showlist);
1712
1713   /* The "set radix" and "show radix" commands are special in that
1714      they are like normal set and show commands but allow two normally
1715      independent variables to be either set or shown with a single
1716      command.  So the usual deprecated_add_set_cmd() and [deleted]
1717      add_show_from_set() commands aren't really appropriate. */
1718   /* FIXME: i18n: With the new add_setshow_integer command, that is no
1719      longer true - show can display anything.  */
1720   add_cmd ("radix", class_support, set_radix, _("\
1721 Set default input and output number radices.\n\
1722 Use 'set input-radix' or 'set output-radix' to independently set each.\n\
1723 Without an argument, sets both radices back to the default value of 10."),
1724            &setlist);
1725   add_cmd ("radix", class_support, show_radix, _("\
1726 Show the default input and output number radices.\n\
1727 Use 'show input-radix' or 'show output-radix' to independently show each."),
1728            &showlist);
1729
1730   add_setshow_boolean_cmd ("array-indexes", class_support,
1731                            &user_print_options.print_array_indexes, _("\
1732 Set printing of array indexes."), _("\
1733 Show printing of array indexes"), NULL, NULL, show_print_array_indexes,
1734                            &setprintlist, &showprintlist);
1735 }