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,
   4    2002, 2003, 2004, 2005 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, "[\"%c\"]", quoter);
 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_MEMBER:
 424     case TYPE_CODE_METHOD:
 425     case TYPE_CODE_REF:
 426       warning (_("internal error: unhandled type in ada_print_scalar"));
 427       break;
 428
 429     default:
 430       error (_("Invalid type code in symbol table."));
 431     }
 432   gdb_flush (stream);
 433 }
 434
 435 /* Print the character string STRING, printing at most LENGTH characters.
 436    Printing stops early if the number hits print_max; repeat counts
 437    are printed as appropriate.  Print ellipses at the end if we
 438    had to stop before printing LENGTH characters, or if
 439    FORCE_ELLIPSES.   TYPE_LEN is the length (1 or 2) of the character type.
 440  */
 441
 442 static void
 443 printstr (struct ui_file *stream, const gdb_byte *string,
 444           unsigned int length, int force_ellipses, int type_len)
 445 {
 446   unsigned int i;
 447   unsigned int things_printed = 0;
 448   int in_quotes = 0;
 449   int need_comma = 0;
 450
 451   if (length == 0)
 452     {
 453       fputs_filtered ("\"\"", stream);
 454       return;
 455     }
 456
 457   for (i = 0; i < length && things_printed < print_max; i += 1)
 458     {
 459       /* Position of the character we are examining
 460          to see whether it is repeated.  */
 461       unsigned int rep1;
 462       /* Number of repetitions we have detected so far.  */
 463       unsigned int reps;
 464
 465       QUIT;
 466
 467       if (need_comma)
 468         {
 469           fputs_filtered (", ", stream);
 470           need_comma = 0;
 471         }
 472
 473       rep1 = i + 1;
 474       reps = 1;
 475       while (rep1 < length
 476              && char_at (string, rep1, type_len) == char_at (string, i,
 477                                                              type_len))
 478         {
 479           rep1 += 1;
 480           reps += 1;
 481         }
 482
 483       if (reps > repeat_count_threshold)
 484         {
 485           if (in_quotes)
 486             {
 487               if (inspect_it)
 488                 fputs_filtered ("\\\", ", stream);
 489               else
 490                 fputs_filtered ("\", ", stream);
 491               in_quotes = 0;
 492             }
 493           fputs_filtered ("'", stream);
 494           ada_emit_char (char_at (string, i, type_len), stream, '\'',
 495                          type_len);
 496           fputs_filtered ("'", stream);
 497           fprintf_filtered (stream, _(" <repeats %u times>"), reps);
 498           i = rep1 - 1;
 499           things_printed += repeat_count_threshold;
 500           need_comma = 1;
 501         }
 502       else
 503         {
 504           if (!in_quotes)
 505             {
 506               if (inspect_it)
 507                 fputs_filtered ("\\\"", stream);
 508               else
 509                 fputs_filtered ("\"", stream);
 510               in_quotes = 1;
 511             }
 512           ada_emit_char (char_at (string, i, type_len), stream, '"',
 513                          type_len);
 514           things_printed += 1;
 515         }
 516     }
 517
 518   /* Terminate the quotes if necessary.  */
 519   if (in_quotes)
 520     {
 521       if (inspect_it)
 522         fputs_filtered ("\\\"", stream);
 523       else
 524         fputs_filtered ("\"", stream);
 525     }
 526
 527   if (force_ellipses || i < length)
 528     fputs_filtered ("...", stream);
 529 }
 530
 531 void
 532 ada_printstr (struct ui_file *stream, const gdb_byte *string,
 533               unsigned int length, int width, int force_ellipses)
 534 {
 535   printstr (stream, string, length, force_ellipses, width);
 536 }
 537
 538
 539 /* Print data of type TYPE located at VALADDR (within GDB), which came from
 540    the inferior at address ADDRESS, onto stdio stream STREAM according to
 541    FORMAT (a letter as for the printf % codes or 0 for natural format).
 542    The data at VALADDR is in target byte order.
 543
 544    If the data is printed as a string, returns the number of string characters
 545    printed.
 546
 547    If DEREF_REF is nonzero, then dereference references, otherwise just print
 548    them like pointers.
 549
 550    RECURSE indicates the amount of indentation to supply before
 551    continuation lines; this amount is roughly twice the value of RECURSE.
 552
 553    When PRETTY is non-zero, prints record fields on separate lines.
 554    (For some reason, the current version of gdb instead uses a global
 555    variable---prettyprint_arrays--- to causes a similar effect on
 556    arrays.)  */
 557
 558 int
 559 ada_val_print (struct type *type, const gdb_byte *valaddr0,
 560                int embedded_offset, CORE_ADDR address,
 561                struct ui_file *stream, int format, int deref_ref,
 562                int recurse, enum val_prettyprint pretty)
 563 {
 564   struct ada_val_print_args args;
 565   args.type = type;
 566   args.valaddr0 = valaddr0;
 567   args.embedded_offset = embedded_offset;
 568   args.address = address;
 569   args.stream = stream;
 570   args.format = format;
 571   args.deref_ref = deref_ref;
 572   args.recurse = recurse;
 573   args.pretty = pretty;
 574
 575   return catch_errors (ada_val_print_stub, &args, NULL, RETURN_MASK_ALL);
 576 }
 577
 578 /* Helper for ada_val_print; used as argument to catch_errors to
 579    unmarshal the arguments to ada_val_print_1, which does the work.  */
 580 static int
 581 ada_val_print_stub (void *args0)
 582 {
 583   struct ada_val_print_args *argsp = (struct ada_val_print_args *) args0;
 584   return ada_val_print_1 (argsp->type, argsp->valaddr0,
 585                           argsp->embedded_offset, argsp->address,
 586                           argsp->stream, argsp->format, argsp->deref_ref,
 587                           argsp->recurse, argsp->pretty);
 588 }
 589
 590 /* See the comment on ada_val_print.  This function differs in that it
 591  * does not catch evaluation errors (leaving that to ada_val_print).  */
 592
 593 static int
 594 ada_val_print_1 (struct type *type, const gdb_byte *valaddr0,
 595                  int embedded_offset, CORE_ADDR address,
 596                  struct ui_file *stream, int format,
 597                  int deref_ref, int recurse, enum val_prettyprint pretty)
 598 {
 599   unsigned int len;
 600   int i;
 601   struct type *elttype;
 602   unsigned int eltlen;
 603   LONGEST val;
 604   const gdb_byte *valaddr = valaddr0 + embedded_offset;
 605
 606   type = ada_check_typedef (type);
 607
 608   if (ada_is_array_descriptor_type (type) || ada_is_packed_array_type (type))
 609     {
 610       int retn;
 611       struct value *mark = value_mark ();
 612       struct value *val;
 613       val = value_from_contents_and_address (type, valaddr, address);
 614       val = ada_coerce_to_simple_array_ptr (val);
 615       if (val == NULL)
 616         {
 617           fprintf_filtered (stream, "(null)");
 618           retn = 0;
 619         }
 620       else
 621         retn = ada_val_print_1 (value_type (val), value_contents (val), 0,
 622                                 VALUE_ADDRESS (val), stream, format,
 623                                 deref_ref, recurse, pretty);
 624       value_free_to_mark (mark);
 625       return retn;
 626     }
 627
 628   valaddr = ada_aligned_value_addr (type, valaddr);
 629   embedded_offset -= valaddr - valaddr0 - embedded_offset;
 630   type = printable_val_type (type, valaddr);
 631
 632   switch (TYPE_CODE (type))
 633     {
 634     default:
 635       return c_val_print (type, valaddr0, embedded_offset, address, stream,
 636                           format, deref_ref, recurse, pretty);
 637
 638     case TYPE_CODE_PTR:
 639       {
 640         int ret = c_val_print (type, valaddr0, embedded_offset, address,
 641                                stream, format, deref_ref, recurse, pretty);
 642         if (ada_is_tag_type (type))
 643           {
 644             struct value *val =
 645               value_from_contents_and_address (type, valaddr, address);
 646             const char *name = ada_tag_name (val);
 647             if (name != NULL)
 648               fprintf_filtered (stream, " (%s)", name);
 649             return 0;
 650         }
 651         return ret;
 652       }
 653
 654     case TYPE_CODE_INT:
 655     case TYPE_CODE_RANGE:
 656       if (ada_is_fixed_point_type (type))
 657         {
 658           LONGEST v = unpack_long (type, valaddr);
 659           int len = TYPE_LENGTH (type);
 660
 661           fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g",
 662                             (double) ada_fixed_to_float (type, v));
 663           return 0;
 664         }
 665       else if (ada_is_vax_floating_type (type))
 666         {
 667           struct value *val =
 668             value_from_contents_and_address (type, valaddr, address);
 669           struct value *func = ada_vax_float_print_function (type);
 670           if (func != 0)
 671             {
 672               static struct type *parray_of_char = NULL;
 673               struct value *printable_val;
 674
 675               if (parray_of_char == NULL)
 676                 parray_of_char =
 677                   make_pointer_type
 678                   (create_array_type
 679                    (NULL, builtin_type_char,
 680                     create_range_type (NULL, builtin_type_int, 0, 32)), NULL);
 681
 682               printable_val =
 683                 value_ind (value_cast (parray_of_char,
 684                                        call_function_by_hand (func, 1,
 685                                                               &val)));
 686
 687               fprintf_filtered (stream, "%s", value_contents (printable_val));
 688               return 0;
 689             }
 690           /* No special printing function.  Do as best we can.  */
 691         }
 692       else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
 693         {
 694           struct type *target_type = TYPE_TARGET_TYPE (type);
 695           if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
 696             {
 697               /* Obscure case of range type that has different length from
 698                  its base type.  Perform a conversion, or we will get a
 699                  nonsense value.  Actually, we could use the same
 700                  code regardless of lengths; I'm just avoiding a cast.  */
 701               struct value *v = value_cast (target_type,
 702                                             value_from_contents_and_address
 703                                             (type, valaddr, 0));
 704               return ada_val_print_1 (target_type, value_contents (v), 0, 0,
 705                                       stream, format, 0, recurse + 1, pretty);
 706             }
 707           else
 708             return ada_val_print_1 (TYPE_TARGET_TYPE (type),
 709                                     valaddr0, embedded_offset,
 710                                     address, stream, format, deref_ref,
 711                                     recurse, pretty);
 712         }
 713       else
 714         {
 715           format = format ? format : output_format;
 716           if (format)
 717             {
 718               print_scalar_formatted (valaddr, type, format, 0, stream);
 719             }
 720           else if (ada_is_system_address_type (type))
 721             {
 722               /* FIXME: We want to print System.Address variables using
 723                  the same format as for any access type.  But for some
 724                  reason GNAT encodes the System.Address type as an int,
 725                  so we have to work-around this deficiency by handling
 726                  System.Address values as a special case.  */
 727               fprintf_filtered (stream, "(");
 728               type_print (type, "", stream, -1);
 729               fprintf_filtered (stream, ") ");
 730               deprecated_print_address_numeric
 731                 (extract_typed_address (valaddr, builtin_type_void_data_ptr),
 732                  1, stream);
 733             }
 734           else
 735             {
 736               val_print_type_code_int (type, valaddr, stream);
 737               if (ada_is_character_type (type))
 738                 {
 739                   fputs_filtered (" ", stream);
 740                   ada_printchar ((unsigned char) unpack_long (type, valaddr),
 741                                  stream);
 742                 }
 743             }
 744           return 0;
 745         }
 746
 747     case TYPE_CODE_ENUM:
 748       if (format)
 749         {
 750           print_scalar_formatted (valaddr, type, format, 0, stream);
 751           break;
 752         }
 753       len = TYPE_NFIELDS (type);
 754       val = unpack_long (type, valaddr);
 755       for (i = 0; i < len; i++)
 756         {
 757           QUIT;
 758           if (val == TYPE_FIELD_BITPOS (type, i))
 759             {
 760               break;
 761             }
 762         }
 763       if (i < len)
 764         {
 765           const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
 766           if (name[0] == '\'')
 767             fprintf_filtered (stream, "%ld %s", (long) val, name);
 768           else
 769             fputs_filtered (name, stream);
 770         }
 771       else
 772         {
 773           print_longest (stream, 'd', 0, val);
 774         }
 775       break;
 776
 777     case TYPE_CODE_FLT:
 778       if (format)
 779         return c_val_print (type, valaddr0, embedded_offset, address, stream,
 780                             format, deref_ref, recurse, pretty);
 781       else
 782         ada_print_floating (valaddr0 + embedded_offset, type, stream);
 783       break;
 784
 785     case TYPE_CODE_UNION:
 786     case TYPE_CODE_STRUCT:
 787       if (ada_is_bogus_array_descriptor (type))
 788         {
 789           fprintf_filtered (stream, "(...?)");
 790           return 0;
 791         }
 792       else
 793         {
 794           print_record (type, valaddr, stream, format, recurse, pretty);
 795           return 0;
 796         }
 797
 798     case TYPE_CODE_ARRAY:
 799       elttype = TYPE_TARGET_TYPE (type);
 800       if (elttype == NULL)
 801         eltlen = 0;
 802       else
 803         eltlen = TYPE_LENGTH (elttype);
 804       /* FIXME: This doesn't deal with non-empty arrays of
 805          0-length items (not a typical case!) */
 806       if (eltlen == 0)
 807         len = 0;
 808       else
 809         len = TYPE_LENGTH (type) / eltlen;
 810
 811           /* For an array of chars, print with string syntax.  */
 812       if (ada_is_string_type (type) && (format == 0 || format == 's'))
 813         {
 814           if (prettyprint_arrays)
 815             {
 816               print_spaces_filtered (2 + 2 * recurse, stream);
 817             }
 818           /* If requested, look for the first null char and only print
 819              elements up to it.  */
 820           if (stop_print_at_null)
 821             {
 822               int temp_len;
 823
 824               /* Look for a NULL char.  */
 825               for (temp_len = 0;
 826                    temp_len < len && temp_len < print_max
 827                      && char_at (valaddr, temp_len, eltlen) != 0;
 828                    temp_len += 1);
 829               len = temp_len;
 830             }
 831
 832           printstr (stream, valaddr, len, 0, eltlen);
 833         }
 834       else
 835         {
 836           len = 0;
 837           fprintf_filtered (stream, "(");
 838           print_optional_low_bound (stream, type);
 839           if (TYPE_FIELD_BITSIZE (type, 0) > 0)
 840             val_print_packed_array_elements (type, valaddr, 0, stream,
 841                                              format, recurse, pretty);
 842           else
 843             val_print_array_elements (type, valaddr, address, stream,
 844                                       format, deref_ref, recurse,
 845                                       pretty, 0);
 846           fprintf_filtered (stream, ")");
 847         }
 848       gdb_flush (stream);
 849       return len;
 850
 851     case TYPE_CODE_REF:
 852       elttype = check_typedef (TYPE_TARGET_TYPE (type));
 853       /* De-reference the reference */
 854       if (deref_ref)
 855         {
 856           if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
 857             {
 858               LONGEST deref_val_int = (LONGEST)
 859                 unpack_pointer (lookup_pointer_type (builtin_type_void),
 860                                 valaddr);
 861               if (deref_val_int != 0)
 862                 {
 863                   struct value *deref_val =
 864                     ada_value_ind (value_from_longest
 865                                    (lookup_pointer_type (elttype),
 866                                     deref_val_int));
 867                   val_print (value_type (deref_val),
 868                              value_contents (deref_val), 0,
 869                              VALUE_ADDRESS (deref_val), stream, format,
 870                              deref_ref, recurse + 1, pretty);
 871                 }
 872               else
 873                 fputs_filtered ("(null)", stream);
 874             }
 875           else
 876             fputs_filtered ("???", stream);
 877         }
 878       break;
 879     }
 880   gdb_flush (stream);
 881   return 0;
 882 }
 883
 884 static int
 885 print_variant_part (struct type *type, int field_num, const gdb_byte *valaddr,
 886                     struct ui_file *stream, int format, int recurse,
 887                     enum val_prettyprint pretty, int comma_needed,
 888                     struct type *outer_type, const gdb_byte *outer_valaddr)
 889 {
 890   struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
 891   int which = ada_which_variant_applies (var_type, outer_type, outer_valaddr);
 892
 893   if (which < 0)
 894     return 0;
 895   else
 896     return print_field_values
 897       (TYPE_FIELD_TYPE (var_type, which),
 898        valaddr + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
 899        + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
 900        stream, format, recurse, pretty,
 901        comma_needed, outer_type, outer_valaddr);
 902 }
 903
 904 int
 905 ada_value_print (struct value *val0, struct ui_file *stream, int format,
 906                  enum val_prettyprint pretty)
 907 {
 908   const gdb_byte *valaddr = value_contents (val0);
 909   CORE_ADDR address = VALUE_ADDRESS (val0) + value_offset (val0);
 910   struct type *type =
 911     ada_to_fixed_type (value_type (val0), valaddr, address, NULL);
 912   struct value *val =
 913     value_from_contents_and_address (type, valaddr, address);
 914
 915   /* If it is a pointer, indicate what it points to.  */
 916   if (TYPE_CODE (type) == TYPE_CODE_PTR)
 917     {
 918       /* Hack:  don't print (char *) for char strings.  Their
 919          type is indicated by the quoted string anyway.  */
 920       if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) != sizeof (char)
 921           || TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_INT
 922           || TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
 923         {
 924           fprintf_filtered (stream, "(");
 925           type_print (type, "", stream, -1);
 926           fprintf_filtered (stream, ") ");
 927         }
 928     }
 929   else if (ada_is_array_descriptor_type (type))
 930     {
 931       fprintf_filtered (stream, "(");
 932       type_print (type, "", stream, -1);
 933       fprintf_filtered (stream, ") ");
 934     }
 935   else if (ada_is_bogus_array_descriptor (type))
 936     {
 937       fprintf_filtered (stream, "(");
 938       type_print (type, "", stream, -1);
 939       fprintf_filtered (stream, ") (...?)");
 940       return 0;
 941     }
 942
 943   if (TYPE_CODE (type) == TYPE_CODE_ARRAY
 944       && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == 0
 945       && TYPE_CODE (TYPE_INDEX_TYPE (type)) == TYPE_CODE_RANGE)
 946     {
 947       /* This is an array of zero-length elements, that is an array
 948          of null records.  This array needs to be printed by hand,
 949          as the standard routine to print arrays relies on the size of
 950          the array elements to be nonzero.  This is because it computes
 951          the number of elements in the array by dividing the array size
 952          by the array element size.  */
 953       fprintf_filtered (stream, "(%d .. %d => ())",
 954                         TYPE_LOW_BOUND (TYPE_INDEX_TYPE (type)),
 955                         TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (type)));
 956       return 0;
 957     }
 958
 959   return (val_print (type, value_contents (val), 0, address,
 960                      stream, format, 1, 0, pretty));
 961 }
 962
 963 static void
 964 print_record (struct type *type, const gdb_byte *valaddr,
 965               struct ui_file *stream, int format, int recurse,
 966               enum val_prettyprint pretty)
 967 {
 968   type = ada_check_typedef (type);
 969
 970   fprintf_filtered (stream, "(");
 971
 972   if (print_field_values (type, valaddr, stream, format, recurse, pretty,
 973                           0, type, valaddr) != 0 && pretty)
 974     {
 975       fprintf_filtered (stream, "\n");
 976       print_spaces_filtered (2 * recurse, stream);
 977     }
 978
 979   fprintf_filtered (stream, ")");
 980 }
 981
 982 /* Print out fields of value at VALADDR having structure type TYPE.
 983
 984    TYPE, VALADDR, STREAM, FORMAT, RECURSE, and PRETTY have the
 985    same meanings as in ada_print_value and ada_val_print.
 986
 987    OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record
 988    (used to get discriminant values when printing variant parts).
 989
 990    COMMA_NEEDED is 1 if fields have been printed at the current recursion
 991    level, so that a comma is needed before any field printed by this
 992    call.
 993
 994    Returns 1 if COMMA_NEEDED or any fields were printed.  */
 995
 996 static int
 997 print_field_values (struct type *type, const gdb_byte *valaddr,
 998                     struct ui_file *stream, int format, int recurse,
 999                     enum val_prettyprint pretty, int comma_needed,
1000                     struct type *outer_type, const gdb_byte *outer_valaddr)
1001 {
1002   int i, len;
1003
1004   len = TYPE_NFIELDS (type);
1005
1006   for (i = 0; i < len; i += 1)
1007     {
1008       if (ada_is_ignored_field (type, i))
1009         continue;
1010
1011       if (ada_is_wrapper_field (type, i))
1012         {
1013           comma_needed =
1014             print_field_values (TYPE_FIELD_TYPE (type, i),
1015                                 valaddr
1016                                 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
1017                                 stream, format, recurse, pretty,
1018                                 comma_needed, type, valaddr);
1019           continue;
1020         }
1021       else if (ada_is_variant_part (type, i))
1022         {
1023           comma_needed =
1024             print_variant_part (type, i, valaddr,
1025                                 stream, format, recurse, pretty, comma_needed,
1026                                 outer_type, outer_valaddr);
1027           continue;
1028         }
1029
1030       if (comma_needed)
1031         fprintf_filtered (stream, ", ");
1032       comma_needed = 1;
1033
1034       if (pretty)
1035         {
1036           fprintf_filtered (stream, "\n");
1037           print_spaces_filtered (2 + 2 * recurse, stream);
1038         }
1039       else
1040         {
1041           wrap_here (n_spaces (2 + 2 * recurse));
1042         }
1043       if (inspect_it)
1044         {
1045           if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
1046             fputs_filtered ("\"( ptr \"", stream);
1047           else
1048             fputs_filtered ("\"( nodef \"", stream);
1049           fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1050                                    language_cplus, DMGL_NO_OPTS);
1051           fputs_filtered ("\" \"", stream);
1052           fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
1053                                    language_cplus, DMGL_NO_OPTS);
1054           fputs_filtered ("\") \"", stream);
1055         }
1056       else
1057         {
1058           annotate_field_begin (TYPE_FIELD_TYPE (type, i));
1059           fprintf_filtered (stream, "%.*s",
1060                             ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
1061                             TYPE_FIELD_NAME (type, i));
1062           annotate_field_name_end ();
1063           fputs_filtered (" => ", stream);
1064           annotate_field_value ();
1065         }
1066
1067       if (TYPE_FIELD_PACKED (type, i))
1068         {
1069           struct value *v;
1070
1071           /* Bitfields require special handling, especially due to byte
1072              order problems.  */
1073           if (TYPE_CPLUS_SPECIFIC (type) != NULL
1074               && TYPE_FIELD_IGNORE (type, i))
1075             {
1076               fputs_filtered (_("<optimized out or zero length>"), stream);
1077             }
1078           else
1079             {
1080               int bit_pos = TYPE_FIELD_BITPOS (type, i);
1081               int bit_size = TYPE_FIELD_BITSIZE (type, i);
1082
1083               adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
1084               v = ada_value_primitive_packed_val (NULL, valaddr,
1085                                                   bit_pos / HOST_CHAR_BIT,
1086                                                   bit_pos % HOST_CHAR_BIT,
1087                                                   bit_size,
1088                                                   TYPE_FIELD_TYPE (type, i));
1089               val_print (TYPE_FIELD_TYPE (type, i), value_contents (v), 0, 0,
1090                          stream, format, 0, recurse + 1, pretty);
1091             }
1092         }
1093       else
1094         ada_val_print (TYPE_FIELD_TYPE (type, i),
1095                        valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
1096                        0, 0, stream, format, 0, recurse + 1, pretty);
1097       annotate_field_end ();
1098     }
1099
1100   return comma_needed;
1101 }