gdb/ada-valprint.c

   1 /* Support for printing Ada values for GDB, the GNU debugger.
   2    Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1997, 2001
   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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 #include <ctype.h>
  22 #include "defs.h"
  23 #include "symtab.h"
  24 #include "gdbtypes.h"
  25 #include "expression.h"
  26 #include "value.h"
  27 #include "demangle.h"
  28 #include "valprint.h"
  29 #include "language.h"
  30 #include "annotate.h"
  31 #include "ada-lang.h"
  32 #include "c-lang.h"
  33 #include "infcall.h"
  34
  35 /* Encapsulates arguments to ada_val_print. */
  36 struct ada_val_print_args
  37 {
  38   struct type *type;
  39   char *valaddr0;
  40   int embedded_offset;
  41   CORE_ADDR address;
  42   struct ui_file *stream;
  43   int format;
  44   int deref_ref;
  45   int recurse;
  46   enum val_prettyprint pretty;
  47 };
  48
  49 static void print_record (struct type *, char *, struct ui_file *, int,
  50                           int, enum val_prettyprint);
  51
  52 static int print_field_values (struct type *, char *, struct ui_file *,
  53                                int, int, enum val_prettyprint,
  54                                int, struct type *, char *);
  55
  56 static int print_variant_part (struct type *, int, char *,
  57                                struct ui_file *, int, int,
  58                                enum val_prettyprint, int, struct type *,
  59                                char *);
  60
  61 static void val_print_packed_array_elements (struct type *, char *valaddr,
  62                                              int, struct ui_file *, int, int,
  63                                              enum val_prettyprint);
  64
  65 static void adjust_type_signedness (struct type *);
  66
  67 static int ada_val_print_stub (void *args0);
  68
  69 static int ada_val_print_1 (struct type *, char *, int, CORE_ADDR,
  70                             struct ui_file *, int, int, int,
  71                             enum val_prettyprint);
  72 \f
  73
  74 /* Make TYPE unsigned if its range of values includes no negatives. */
  75 static void
  76 adjust_type_signedness (struct type *type)
  77 {
  78   if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
  79       && TYPE_LOW_BOUND (type) >= 0)
  80     TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
  81 }
  82
  83 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
  84    if non-standard (i.e., other than 1 for numbers, other than lower bound
  85    of index type for enumerated type). Returns 1 if something printed,
  86    otherwise 0. */
  87
  88 static int
  89 print_optional_low_bound (struct ui_file *stream, struct type *type)
  90 {
  91   struct type *index_type;
  92   long low_bound;
  93
  94   index_type = TYPE_INDEX_TYPE (type);
  95   low_bound = 0;
  96
  97   if (index_type == NULL)
  98     return 0;
  99   if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
 100     {
 101       low_bound = TYPE_LOW_BOUND (index_type);
 102       index_type = TYPE_TARGET_TYPE (index_type);
 103     }
 104   else
 105     return 0;
 106
 107   switch (TYPE_CODE (index_type))
 108     {
 109     case TYPE_CODE_ENUM:
 110       if (low_bound == TYPE_FIELD_BITPOS (index_type, 0))
 111         return 0;
 112       break;
 113     case TYPE_CODE_UNDEF:
 114       index_type = builtin_type_long;
 115       /* FALL THROUGH */
 116     default:
 117       if (low_bound == 1)
 118         return 0;
 119       break;
 120     }
 121
 122   ada_print_scalar (index_type, (LONGEST) low_bound, stream);
 123   fprintf_filtered (stream, " => ");
 124   return 1;
 125 }
 126
 127 /*  Version of val_print_array_elements for GNAT-style packed arrays.
 128     Prints elements of packed array of type TYPE at bit offset
 129     BITOFFSET from VALADDR on STREAM.  Formats according to FORMAT and
 130     separates with commas. RECURSE is the recursion (nesting) level.
 131     If PRETTY, uses "prettier" format. TYPE must have been decoded (as
 132     by ada_coerce_to_simple_array).  */
 133
 134 static void
 135 val_print_packed_array_elements (struct type *type, char *valaddr,
 136                                  int bitoffset, struct ui_file *stream,
 137                                  int format, int recurse,
 138                                  enum val_prettyprint pretty)
 139 {
 140   unsigned int i;
 141   unsigned int things_printed = 0;
 142   unsigned len;
 143   struct type *elttype;
 144   unsigned eltlen;
 145   /* Position of the array element we are examining to see
 146      whether it is repeated.  */
 147   unsigned int rep1;
 148   /* Number of repetitions we have detected so far.  */
 149   unsigned int reps;
 150   unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
 151   struct value *mark = value_mark ();
 152
 153   elttype = TYPE_TARGET_TYPE (type);
 154   eltlen = TYPE_LENGTH (check_typedef (elttype));
 155
 156   {
 157     LONGEST low, high;
 158     if (get_discrete_bounds (TYPE_FIELD_TYPE (type, 0), &low, &high) < 0)
 159       len = 1;
 160     else
 161       len = high - low + 1;
 162   }
 163
 164   i = 0;
 165   annotate_array_section_begin (i, elttype);
 166
 167   while (i < len && things_printed < print_max)
 168     {
 169       struct value *v0, *v1;
 170       int i0;
 171
 172       if (i != 0)
 173         {
 174           if (prettyprint_arrays)
 175             {
 176               fprintf_filtered (stream, ",\n");
 177               print_spaces_filtered (2 + 2 * recurse, stream);
 178             }
 179           else
 180             {
 181               fprintf_filtered (stream, ", ");
 182             }
 183         }
 184       wrap_here (n_spaces (2 + 2 * recurse));
 185
 186       i0 = i;
 187       v0 = ada_value_primitive_packed_val (NULL, valaddr,
 188                                            (i0 * bitsize) / HOST_CHAR_BIT,
 189                                            (i0 * bitsize) % HOST_CHAR_BIT,
 190                                            bitsize, elttype);
 191       while (1)
 192         {
 193           i += 1;
 194           if (i >= len)
 195             break;
 196           v1 = ada_value_primitive_packed_val (NULL, valaddr,
 197                                                (i * bitsize) / HOST_CHAR_BIT,
 198                                                (i * bitsize) % HOST_CHAR_BIT,
 199                                                bitsize, elttype);
 200           if (memcmp (VALUE_CONTENTS (v0), VALUE_CONTENTS (v1), eltlen) != 0)
 201             break;
 202         }
 203
 204       if (i - i0 > repeat_count_threshold)
 205         {
 206           val_print (elttype, VALUE_CONTENTS (v0), 0, 0, stream, format,
 207                      0, recurse + 1, pretty);
 208           annotate_elt_rep (i - i0);
 209           fprintf_filtered (stream, " <repeats %u times>", i - i0);
 210           annotate_elt_rep_end ();
 211
 212         }
 213       else
 214         {
 215           int j;
 216           for (j = i0; j < i; j += 1)
 217             {
 218               if (j > i0)
 219                 {
 220                   if (prettyprint_arrays)
 221                     {
 222                       fprintf_filtered (stream, ",\n");
 223                       print_spaces_filtered (2 + 2 * recurse, stream);
 224                     }
 225                   else
 226                     {
 227                       fprintf_filtered (stream, ", ");
 228                     }
 229                   wrap_here (n_spaces (2 + 2 * recurse));
 230                 }
 231               val_print (elttype, VALUE_CONTENTS (v0), 0, 0, stream, format,
 232                          0, recurse + 1, pretty);
 233               annotate_elt ();
 234             }
 235         }
 236       things_printed += i - i0;
 237     }
 238   annotate_array_section_end ();
 239   if (i < len)
 240     {
 241       fprintf_filtered (stream, "...");
 242     }
 243
 244   value_free_to_mark (mark);
 245 }
 246
 247 static struct type *
 248 printable_val_type (struct type *type, char *valaddr)
 249 {
 250   return ada_to_fixed_type (ada_aligned_type (type), valaddr, 0, NULL);
 251 }
 252
 253 /* Print the character C on STREAM as part of the contents of a literal
 254    string whose delimiter is QUOTER.  TYPE_LEN is the length in bytes
 255    (1 or 2) of the character. */
 256
 257 void
 258 ada_emit_char (int c, struct ui_file *stream, int quoter, int type_len)
 259 {
 260   if (type_len != 2)
 261     type_len = 1;
 262
 263   c &= (1 << (type_len * TARGET_CHAR_BIT)) - 1;
 264
 265   if (isascii (c) && isprint (c))
 266     {
 267       if (c == quoter && c == '"')
 268         fprintf_filtered (stream, "[\"%c\"]", quoter);
 269       else
 270         fprintf_filtered (stream, "%c", c);
 271     }
 272   else
 273     fprintf_filtered (stream, "[\"%0*x\"]", type_len * 2, c);
 274 }
 275
 276 /* Character #I of STRING, given that TYPE_LEN is the size in bytes (1
 277    or 2) of a character. */
 278
 279 static int
 280 char_at (char *string, int i, int type_len)
 281 {
 282   if (type_len == 1)
 283     return string[i];
 284   else
 285     return (int) extract_unsigned_integer (string + 2 * i, 2);
 286 }
 287
 288 void
 289 ada_printchar (int c, struct ui_file *stream)
 290 {
 291   fputs_filtered ("'", stream);
 292   ada_emit_char (c, stream, '\'', 1);
 293   fputs_filtered ("'", stream);
 294 }
 295
 296 /* [From print_type_scalar in typeprint.c].   Print VAL on STREAM in a
 297    form appropriate for TYPE. */
 298
 299 void
 300 ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream)
 301 {
 302   unsigned int i;
 303   unsigned len;
 304
 305   CHECK_TYPEDEF (type);
 306
 307   switch (TYPE_CODE (type))
 308     {
 309
 310     case TYPE_CODE_ENUM:
 311       len = TYPE_NFIELDS (type);
 312       for (i = 0; i < len; i++)
 313         {
 314           if (TYPE_FIELD_BITPOS (type, i) == val)
 315             {
 316               break;
 317             }
 318         }
 319       if (i < len)
 320         {
 321           fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
 322         }
 323       else
 324         {
 325           print_longest (stream, 'd', 0, val);
 326         }
 327       break;
 328
 329     case TYPE_CODE_INT:
 330       print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
 331       break;
 332
 333     case TYPE_CODE_CHAR:
 334       LA_PRINT_CHAR ((unsigned char) val, stream);
 335       break;
 336
 337     case TYPE_CODE_BOOL:
 338       fprintf_filtered (stream, val ? "true" : "false");
 339       break;
 340
 341     case TYPE_CODE_RANGE:
 342       ada_print_scalar (TYPE_TARGET_TYPE (type), val, stream);
 343       return;
 344
 345     case TYPE_CODE_UNDEF:
 346     case TYPE_CODE_PTR:
 347     case TYPE_CODE_ARRAY:
 348     case TYPE_CODE_STRUCT:
 349     case TYPE_CODE_UNION:
 350     case TYPE_CODE_FUNC:
 351     case TYPE_CODE_FLT:
 352     case TYPE_CODE_VOID:
 353     case TYPE_CODE_SET:
 354     case TYPE_CODE_STRING:
 355     case TYPE_CODE_ERROR:
 356     case TYPE_CODE_MEMBER:
 357     case TYPE_CODE_METHOD:
 358     case TYPE_CODE_REF:
 359       warning ("internal error: unhandled type in ada_print_scalar");
 360       break;
 361
 362     default:
 363       error ("Invalid type code in symbol table.");
 364     }
 365   gdb_flush (stream);
 366 }
 367
 368 /* Print the character string STRING, printing at most LENGTH characters.
 369    Printing stops early if the number hits print_max; repeat counts
 370    are printed as appropriate.  Print ellipses at the end if we
 371    had to stop before printing LENGTH characters, or if
 372    FORCE_ELLIPSES.   TYPE_LEN is the length (1 or 2) of the character type.
 373  */
 374
 375 static void
 376 printstr (struct ui_file *stream, char *string, unsigned int length,
 377           int force_ellipses, int type_len)
 378 {
 379   unsigned int i;
 380   unsigned int things_printed = 0;
 381   int in_quotes = 0;
 382   int need_comma = 0;
 383
 384   if (length == 0)
 385     {
 386       fputs_filtered ("\"\"", stream);
 387       return;
 388     }
 389
 390   for (i = 0; i < length && things_printed < print_max; i += 1)
 391     {
 392       /* Position of the character we are examining
 393          to see whether it is repeated.  */
 394       unsigned int rep1;
 395       /* Number of repetitions we have detected so far.  */
 396       unsigned int reps;
 397
 398       QUIT;
 399
 400       if (need_comma)
 401         {
 402           fputs_filtered (", ", stream);
 403           need_comma = 0;
 404         }
 405
 406       rep1 = i + 1;
 407       reps = 1;
 408       while (rep1 < length &&
 409              char_at (string, rep1, type_len) == char_at (string, i,
 410                                                           type_len))
 411         {
 412           rep1 += 1;
 413           reps += 1;
 414         }
 415
 416       if (reps > repeat_count_threshold)
 417         {
 418           if (in_quotes)
 419             {
 420               if (inspect_it)
 421                 fputs_filtered ("\\\", ", stream);
 422               else
 423                 fputs_filtered ("\", ", stream);
 424               in_quotes = 0;
 425             }
 426           fputs_filtered ("'", stream);
 427           ada_emit_char (char_at (string, i, type_len), stream, '\'',
 428                          type_len);
 429           fputs_filtered ("'", stream);
 430           fprintf_filtered (stream, " <repeats %u times>", reps);
 431           i = rep1 - 1;
 432           things_printed += repeat_count_threshold;
 433           need_comma = 1;
 434         }
 435       else
 436         {
 437           if (!in_quotes)
 438             {
 439               if (inspect_it)
 440                 fputs_filtered ("\\\"", stream);
 441               else
 442                 fputs_filtered ("\"", stream);
 443               in_quotes = 1;
 444             }
 445           ada_emit_char (char_at (string, i, type_len), stream, '"',
 446                          type_len);
 447           things_printed += 1;
 448         }
 449     }
 450
 451   /* Terminate the quotes if necessary.  */
 452   if (in_quotes)
 453     {
 454       if (inspect_it)
 455         fputs_filtered ("\\\"", stream);
 456       else
 457         fputs_filtered ("\"", stream);
 458     }
 459
 460   if (force_ellipses || i < length)
 461     fputs_filtered ("...", stream);
 462 }
 463
 464 void
 465 ada_printstr (struct ui_file *stream, char *string, unsigned int length,
 466               int force_ellipses, int width)
 467 {
 468   printstr (stream, string, length, force_ellipses, width);
 469 }
 470
 471
 472 /* Print data of type TYPE located at VALADDR (within GDB), which came from
 473    the inferior at address ADDRESS, onto stdio stream STREAM according to
 474    FORMAT (a letter as for the printf % codes or 0 for natural format).
 475    The data at VALADDR is in target byte order.
 476
 477    If the data is printed as a string, returns the number of string characters
 478    printed.
 479
 480    If DEREF_REF is nonzero, then dereference references, otherwise just print
 481    them like pointers.
 482
 483    RECURSE indicates the amount of indentation to supply before
 484    continuation lines; this amount is roughly twice the value of RECURSE.
 485
 486    When PRETTY is non-zero, prints record fields on separate lines.
 487    (For some reason, the current version of gdb instead uses a global
 488    variable---prettyprint_arrays--- to causes a similar effect on
 489    arrays.)  */
 490
 491 int
 492 ada_val_print (struct type *type, char *valaddr0, int embedded_offset,
 493                CORE_ADDR address, struct ui_file *stream, int format,
 494                int deref_ref, int recurse, enum val_prettyprint pretty)
 495 {
 496   struct ada_val_print_args args;
 497   args.type = type;
 498   args.valaddr0 = valaddr0;
 499   args.embedded_offset = embedded_offset;
 500   args.address = address;
 501   args.stream = stream;
 502   args.format = format;
 503   args.deref_ref = deref_ref;
 504   args.recurse = recurse;
 505   args.pretty = pretty;
 506
 507   return catch_errors (ada_val_print_stub, &args, NULL, RETURN_MASK_ALL);
 508 }
 509
 510 /* Helper for ada_val_print; used as argument to catch_errors to
 511    unmarshal the arguments to ada_val_print_1, which does the work. */
 512 static int
 513 ada_val_print_stub (void * args0)
 514 {
 515   struct ada_val_print_args *argsp = (struct ada_val_print_args *) args0;
 516   return ada_val_print_1 (argsp->type, argsp->valaddr0,
 517                           argsp->embedded_offset, argsp->address,
 518                           argsp->stream, argsp->format, argsp->deref_ref,
 519                           argsp->recurse, argsp->pretty);
 520 }
 521
 522 /* See the comment on ada_val_print.  This function differs in that it
 523  * does not catch evaluation errors (leaving that to ada_val_print). */
 524
 525 static int
 526 ada_val_print_1 (struct type *type, char *valaddr0, int embedded_offset,
 527                  CORE_ADDR address, struct ui_file *stream, int format,
 528                  int deref_ref, int recurse, enum val_prettyprint pretty)
 529 {
 530   unsigned int len;
 531   int i;
 532   struct type *elttype;
 533   unsigned int eltlen;
 534   LONGEST val;
 535   CORE_ADDR addr;
 536   char *valaddr = valaddr0 + embedded_offset;
 537
 538   CHECK_TYPEDEF (type);
 539
 540   if (ada_is_array_descriptor (type) || ada_is_packed_array_type (type))
 541     {
 542       int retn;
 543       struct value *mark = value_mark ();
 544       struct value *val;
 545       val = value_from_contents_and_address (type, valaddr, address);
 546       val = ada_coerce_to_simple_array_ptr (val);
 547       if (val == NULL)
 548         {
 549           fprintf_filtered (stream, "(null)");
 550           retn = 0;
 551         }
 552       else
 553         retn = ada_val_print_1 (VALUE_TYPE (val), VALUE_CONTENTS (val), 0,
 554                                 VALUE_ADDRESS (val), stream, format,
 555                                 deref_ref, recurse, pretty);
 556       value_free_to_mark (mark);
 557       return retn;
 558     }
 559
 560   valaddr = ada_aligned_value_addr (type, valaddr);
 561   embedded_offset -= valaddr - valaddr0 - embedded_offset;
 562   type = printable_val_type (type, valaddr);
 563
 564   switch (TYPE_CODE (type))
 565     {
 566     default:
 567       return c_val_print (type, valaddr0, embedded_offset, address, stream,
 568                           format, deref_ref, recurse, pretty);
 569
 570     case TYPE_CODE_INT:
 571     case TYPE_CODE_RANGE:
 572       if (ada_is_fixed_point_type (type))
 573         {
 574           LONGEST v = unpack_long (type, valaddr);
 575           int len = TYPE_LENGTH (type);
 576
 577           fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g",
 578                             (double) ada_fixed_to_float (type, v));
 579           return 0;
 580         }
 581       else if (ada_is_vax_floating_type (type))
 582         {
 583           struct value *val =
 584             value_from_contents_and_address (type, valaddr, address);
 585           struct value *func = ada_vax_float_print_function (type);
 586           if (func != 0)
 587             {
 588               static struct type *parray_of_char = NULL;
 589               struct value *printable_val;
 590
 591               if (parray_of_char == NULL)
 592                 parray_of_char =
 593                   make_pointer_type
 594                   (create_array_type
 595                    (NULL, builtin_type_char,
 596                     create_range_type (NULL, builtin_type_int, 0, 32)), NULL);
 597
 598               printable_val =
 599                 value_ind (value_cast (parray_of_char,
 600                                        call_function_by_hand (func, 1,
 601                                                               &val)));
 602
 603               fprintf_filtered (stream, "%s", VALUE_CONTENTS (printable_val));
 604               return 0;
 605             }
 606           /* No special printing function.  Do as best we can. */
 607         }
 608       else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
 609         {
 610           struct type *target_type = TYPE_TARGET_TYPE (type);
 611           if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
 612             {
 613               /* Obscure case of range type that has different length from
 614                  its base type.  Perform a conversion, or we will get a
 615                  nonsense value.  Actually, we could use the same
 616                  code regardless of lengths; I'm just avoiding a cast. */
 617               struct value *v = value_cast (target_type,
 618                                             value_from_contents_and_address
 619                                             (type, valaddr, 0));
 620               return ada_val_print_1 (target_type, VALUE_CONTENTS (v), 0, 0,
 621                                       stream, format, 0, recurse + 1, pretty);
 622             }
 623           else
 624             return ada_val_print_1 (TYPE_TARGET_TYPE (type),
 625                                     valaddr0, embedded_offset,
 626                                     address, stream, format, deref_ref,
 627                                     recurse, pretty);
 628         }
 629       else
 630         {
 631           format = format ? format : output_format;
 632           if (format)
 633             {
 634               print_scalar_formatted (valaddr, type, format, 0, stream);
 635             }
 636           else
 637             {
 638               val_print_type_code_int (type, valaddr, stream);
 639               if (ada_is_character_type (type))
 640                 {
 641                   fputs_filtered (" ", stream);
 642                   ada_printchar ((unsigned char) unpack_long (type, valaddr),
 643                                  stream);
 644                 }
 645             }
 646           return 0;
 647         }
 648
 649     case TYPE_CODE_ENUM:
 650       if (format)
 651         {
 652           print_scalar_formatted (valaddr, type, format, 0, stream);
 653           break;
 654         }
 655       len = TYPE_NFIELDS (type);
 656       val = unpack_long (type, valaddr);
 657       for (i = 0; i < len; i++)
 658         {
 659           QUIT;
 660           if (val == TYPE_FIELD_BITPOS (type, i))
 661             {
 662               break;
 663             }
 664         }
 665       if (i < len)
 666         {
 667           const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
 668           if (name[0] == '\'')
 669             fprintf_filtered (stream, "%ld %s", (long) val, name);
 670           else
 671             fputs_filtered (name, stream);
 672         }
 673       else
 674         {
 675           print_longest (stream, 'd', 0, val);
 676         }
 677       break;
 678
 679     case TYPE_CODE_UNION:
 680     case TYPE_CODE_STRUCT:
 681       if (ada_is_bogus_array_descriptor (type))
 682         {
 683           fprintf_filtered (stream, "(...?)");
 684           return 0;
 685         }
 686       else
 687         {
 688           print_record (type, valaddr, stream, format, recurse, pretty);
 689           return 0;
 690         }
 691
 692     case TYPE_CODE_ARRAY:
 693       if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
 694         {
 695           elttype = TYPE_TARGET_TYPE (type);
 696           eltlen = TYPE_LENGTH (elttype);
 697           len = TYPE_LENGTH (type) / eltlen;
 698
 699           /* For an array of chars, print with string syntax.  */
 700           if (ada_is_string_type (type) && (format == 0 || format == 's'))
 701             {
 702               if (prettyprint_arrays)
 703                 {
 704                   print_spaces_filtered (2 + 2 * recurse, stream);
 705                 }
 706               /* If requested, look for the first null char and only print
 707                  elements up to it.  */
 708               if (stop_print_at_null)
 709                 {
 710                   int temp_len;
 711
 712                   /* Look for a NULL char. */
 713                   for (temp_len = 0;
 714                        temp_len < len && temp_len < print_max
 715                        && char_at (valaddr, temp_len, eltlen) != 0;
 716                        temp_len += 1);
 717                   len = temp_len;
 718                 }
 719
 720               printstr (stream, valaddr, len, 0, eltlen);
 721             }
 722           else
 723             {
 724               len = 0;
 725               fprintf_filtered (stream, "(");
 726               print_optional_low_bound (stream, type);
 727               if (TYPE_FIELD_BITSIZE (type, 0) > 0)
 728                 val_print_packed_array_elements (type, valaddr, 0, stream,
 729                                                  format, recurse, pretty);
 730               else
 731                 val_print_array_elements (type, valaddr, address, stream,
 732                                           format, deref_ref, recurse,
 733                                           pretty, 0);
 734               fprintf_filtered (stream, ")");
 735             }
 736           gdb_flush (stream);
 737           return len;
 738         }
 739
 740     case TYPE_CODE_REF:
 741       elttype = check_typedef (TYPE_TARGET_TYPE (type));
 742       if (addressprint)
 743         {
 744           fprintf_filtered (stream, "@");
 745           print_address_numeric
 746             (extract_address (valaddr,
 747                               TARGET_PTR_BIT / HOST_CHAR_BIT), 1, stream);
 748           if (deref_ref)
 749             fputs_filtered (": ", stream);
 750         }
 751       /* De-reference the reference */
 752       if (deref_ref)
 753         {
 754           if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
 755             {
 756               LONGEST deref_val_int = (LONGEST)
 757                 unpack_pointer (lookup_pointer_type (builtin_type_void),
 758                                 valaddr);
 759               if (deref_val_int != 0)
 760                 {
 761                   struct value *deref_val =
 762                     ada_value_ind (value_from_longest
 763                                    (lookup_pointer_type (elttype),
 764                                     deref_val_int));
 765                   val_print (VALUE_TYPE (deref_val),
 766                              VALUE_CONTENTS (deref_val), 0,
 767                              VALUE_ADDRESS (deref_val), stream, format,
 768                              deref_ref, recurse + 1, pretty);
 769                 }
 770               else
 771                 fputs_filtered ("(null)", stream);
 772             }
 773           else
 774             fputs_filtered ("???", stream);
 775         }
 776       break;
 777     }
 778   return 0;
 779 }
 780
 781 static int
 782 print_variant_part (struct type *type, int field_num, char *valaddr,
 783                     struct ui_file *stream, int format, int recurse,
 784                     enum val_prettyprint pretty, int comma_needed,
 785                     struct type *outer_type, char *outer_valaddr)
 786 {
 787   struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
 788   int which = ada_which_variant_applies (var_type, outer_type, outer_valaddr);
 789
 790   if (which < 0)
 791     return 0;
 792   else
 793     return print_field_values
 794       (TYPE_FIELD_TYPE (var_type, which),
 795        valaddr + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
 796        + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
 797        stream, format, recurse, pretty,
 798        comma_needed, outer_type, outer_valaddr);
 799 }
 800
 801 int
 802 ada_value_print (struct value *val0, struct ui_file *stream, int format,
 803                  enum val_prettyprint pretty)
 804 {
 805   char *valaddr = VALUE_CONTENTS (val0);
 806   CORE_ADDR address = VALUE_ADDRESS (val0) + VALUE_OFFSET (val0);
 807   struct type *type =
 808     ada_to_fixed_type (VALUE_TYPE (val0), valaddr, address, NULL);
 809   struct value *val =
 810     value_from_contents_and_address (type, valaddr, address);
 811
 812   /* If it is a pointer, indicate what it points to. */
 813   if (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_CODE (type) == TYPE_CODE_REF)
 814     {
 815       /* Hack:  remove (char *) for char strings.  Their
 816          type is indicated by the quoted string anyway. */
 817       if (TYPE_CODE (type) == TYPE_CODE_PTR &&
 818           TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == sizeof (char) &&
 819           TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_INT &&
 820           !TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
 821         {
 822           /* Print nothing */
 823         }
 824       else
 825         {
 826           fprintf_filtered (stream, "(");
 827           type_print (type, "", stream, -1);
 828           fprintf_filtered (stream, ") ");
 829         }
 830     }
 831   else if (ada_is_array_descriptor (type))
 832     {
 833       fprintf_filtered (stream, "(");
 834       type_print (type, "", stream, -1);
 835       fprintf_filtered (stream, ") ");
 836     }
 837   else if (ada_is_bogus_array_descriptor (type))
 838     {
 839       fprintf_filtered (stream, "(");
 840       type_print (type, "", stream, -1);
 841       fprintf_filtered (stream, ") (...?)");
 842       return 0;
 843     }
 844   return (val_print (type, VALUE_CONTENTS (val), 0, address,
 845                      stream, format, 1, 0, pretty));
 846 }
 847
 848 static void
 849 print_record (struct type *type, char *valaddr, struct ui_file *stream,
 850               int format, int recurse, enum val_prettyprint pretty)
 851 {
 852   CHECK_TYPEDEF (type);
 853
 854   fprintf_filtered (stream, "(");
 855
 856   if (print_field_values (type, valaddr, stream, format, recurse, pretty,
 857                           0, type, valaddr) != 0 && pretty)
 858     {
 859       fprintf_filtered (stream, "\n");
 860       print_spaces_filtered (2 * recurse, stream);
 861     }
 862
 863   fprintf_filtered (stream, ")");
 864 }
 865
 866 /* Print out fields of value at VALADDR having structure type TYPE.
 867
 868    TYPE, VALADDR, STREAM, FORMAT, RECURSE, and PRETTY have the
 869    same meanings as in ada_print_value and ada_val_print.
 870
 871    OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record
 872    (used to get discriminant values when printing variant parts).
 873
 874    COMMA_NEEDED is 1 if fields have been printed at the current recursion
 875    level, so that a comma is needed before any field printed by this
 876    call.
 877
 878    Returns 1 if COMMA_NEEDED or any fields were printed. */
 879
 880 static int
 881 print_field_values (struct type *type, char *valaddr, struct ui_file *stream,
 882                     int format, int recurse, enum val_prettyprint pretty,
 883                     int comma_needed, struct type *outer_type,
 884                     char *outer_valaddr)
 885 {
 886   int i, len;
 887
 888   len = TYPE_NFIELDS (type);
 889
 890   for (i = 0; i < len; i += 1)
 891     {
 892       if (ada_is_ignored_field (type, i))
 893         continue;
 894
 895       if (ada_is_wrapper_field (type, i))
 896         {
 897           comma_needed =
 898             print_field_values (TYPE_FIELD_TYPE (type, i),
 899                                 valaddr
 900                                 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
 901                                 stream, format, recurse, pretty,
 902                                 comma_needed, type, valaddr);
 903           continue;
 904         }
 905       else if (ada_is_variant_part (type, i))
 906         {
 907           comma_needed =
 908             print_variant_part (type, i, valaddr,
 909                                 stream, format, recurse, pretty, comma_needed,
 910                                 outer_type, outer_valaddr);
 911           continue;
 912         }
 913
 914       if (comma_needed)
 915         fprintf_filtered (stream, ", ");
 916       comma_needed = 1;
 917
 918       if (pretty)
 919         {
 920           fprintf_filtered (stream, "\n");
 921           print_spaces_filtered (2 + 2 * recurse, stream);
 922         }
 923       else
 924         {
 925           wrap_here (n_spaces (2 + 2 * recurse));
 926         }
 927       if (inspect_it)
 928         {
 929           if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
 930             fputs_filtered ("\"( ptr \"", stream);
 931           else
 932             fputs_filtered ("\"( nodef \"", stream);
 933           fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
 934                                    language_cplus, DMGL_NO_OPTS);
 935           fputs_filtered ("\" \"", stream);
 936           fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
 937                                    language_cplus, DMGL_NO_OPTS);
 938           fputs_filtered ("\") \"", stream);
 939         }
 940       else
 941         {
 942           annotate_field_begin (TYPE_FIELD_TYPE (type, i));
 943           fprintf_filtered (stream, "%.*s",
 944                             ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
 945                             TYPE_FIELD_NAME (type, i));
 946           annotate_field_name_end ();
 947           fputs_filtered (" => ", stream);
 948           annotate_field_value ();
 949         }
 950
 951       if (TYPE_FIELD_PACKED (type, i))
 952         {
 953           struct value *v;
 954
 955           /* Bitfields require special handling, especially due to byte
 956              order problems.  */
 957           if (TYPE_CPLUS_SPECIFIC (type) != NULL
 958               && TYPE_FIELD_IGNORE (type, i))
 959             {
 960               fputs_filtered ("<optimized out or zero length>", stream);
 961             }
 962           else
 963             {
 964               int bit_pos = TYPE_FIELD_BITPOS (type, i);
 965               int bit_size = TYPE_FIELD_BITSIZE (type, i);
 966
 967               adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
 968               v = ada_value_primitive_packed_val (NULL, valaddr,
 969                                                   bit_pos / HOST_CHAR_BIT,
 970                                                   bit_pos % HOST_CHAR_BIT,
 971                                                   bit_size,
 972                                                   TYPE_FIELD_TYPE (type, i));
 973               val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0, 0,
 974                          stream, format, 0, recurse + 1, pretty);
 975             }
 976         }
 977       else
 978         ada_val_print (TYPE_FIELD_TYPE (type, i),
 979                        valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
 980                        0, 0, stream, format, 0, recurse + 1, pretty);
 981       annotate_field_end ();
 982     }
 983
 984   return comma_needed;
 985 }