gdb/ada-valprint.c

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