gdb/ada-typeprint.c

   1 /* Support for printing Ada types for GDB, the GNU debugger.
   2    Copyright (C) 1986, 1988, 1989, 1991, 1997, 1998, 1999, 2000, 2001, 2002,
   3    2003, 2004, 2007, 2008, 2009, 2010 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 3 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, see <http://www.gnu.org/licenses/>.  */
  19
  20 #include "defs.h"
  21 #include "gdb_obstack.h"
  22 #include "bfd.h"                /* Binary File Description */
  23 #include "symtab.h"
  24 #include "gdbtypes.h"
  25 #include "expression.h"
  26 #include "value.h"
  27 #include "gdbcore.h"
  28 #include "target.h"
  29 #include "command.h"
  30 #include "gdbcmd.h"
  31 #include "language.h"
  32 #include "demangle.h"
  33 #include "c-lang.h"
  34 #include "typeprint.h"
  35 #include "ada-lang.h"
  36
  37 #include <ctype.h>
  38 #include "gdb_string.h"
  39 #include <errno.h>
  40
  41 static int print_record_field_types (struct type *, struct type *,
  42                                      struct ui_file *, int, int);
  43
  44 static void print_array_type (struct type *, struct ui_file *, int, int);
  45
  46 static void print_choices (struct type *, int, struct ui_file *,
  47                            struct type *);
  48
  49 static void print_range (struct type *, struct ui_file *);
  50
  51 static void print_range_bound (struct type *, char *, int *,
  52                                struct ui_file *);
  53
  54 static void
  55 print_dynamic_range_bound (struct type *, const char *, int,
  56                            const char *, struct ui_file *);
  57
  58 static void print_range_type_named (char *, struct type *, struct ui_file *);
  59 \f
  60
  61
  62 static char *name_buffer;
  63 static int name_buffer_len;
  64
  65 /* The (decoded) Ada name of TYPE.  This value persists until the
  66    next call.  */
  67
  68 static char *
  69 decoded_type_name (struct type *type)
  70 {
  71   if (ada_type_name (type) == NULL)
  72     return NULL;
  73   else
  74     {
  75       char *raw_name = ada_type_name (type);
  76       char *s, *q;
  77
  78       if (name_buffer == NULL || name_buffer_len <= strlen (raw_name))
  79         {
  80           name_buffer_len = 16 + 2 * strlen (raw_name);
  81           name_buffer = xrealloc (name_buffer, name_buffer_len);
  82         }
  83       strcpy (name_buffer, raw_name);
  84
  85       s = (char *) strstr (name_buffer, "___");
  86       if (s != NULL)
  87         *s = '\0';
  88
  89       s = name_buffer + strlen (name_buffer) - 1;
  90       while (s > name_buffer && (s[0] != '_' || s[-1] != '_'))
  91         s -= 1;
  92
  93       if (s == name_buffer)
  94         return name_buffer;
  95
  96       if (!islower (s[1]))
  97         return NULL;
  98
  99       for (s = q = name_buffer; *s != '\0'; q += 1)
 100         {
 101           if (s[0] == '_' && s[1] == '_')
 102             {
 103               *q = '.';
 104               s += 2;
 105             }
 106           else
 107             {
 108               *q = *s;
 109               s += 1;
 110             }
 111         }
 112       *q = '\0';
 113       return name_buffer;
 114     }
 115 }
 116
 117 /* Print TYPE on STREAM, preferably as a range.  */
 118
 119 static void
 120 print_range (struct type *type, struct ui_file *stream)
 121 {
 122   switch (TYPE_CODE (type))
 123     {
 124     case TYPE_CODE_RANGE:
 125     case TYPE_CODE_ENUM:
 126       {
 127         struct type *target_type;
 128         target_type = TYPE_TARGET_TYPE (type);
 129         if (target_type == NULL)
 130           target_type = type;
 131         ada_print_scalar (target_type, ada_discrete_type_low_bound (type),
 132                           stream);
 133         fprintf_filtered (stream, " .. ");
 134         ada_print_scalar (target_type, ada_discrete_type_high_bound (type),
 135                           stream);
 136       }
 137       break;
 138     default:
 139       fprintf_filtered (stream, "%.*s",
 140                         ada_name_prefix_len (TYPE_NAME (type)),
 141                         TYPE_NAME (type));
 142       break;
 143     }
 144 }
 145
 146 /* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
 147    set *N past the bound and its delimiter, if any.  */
 148
 149 static void
 150 print_range_bound (struct type *type, char *bounds, int *n,
 151                    struct ui_file *stream)
 152 {
 153   LONGEST B;
 154   if (ada_scan_number (bounds, *n, &B, n))
 155     {
 156       /* STABS decodes all range types which bounds are 0 .. -1 as
 157          unsigned integers (ie. the type code is TYPE_CODE_INT, not
 158          TYPE_CODE_RANGE).  Unfortunately, ada_print_scalar() relies
 159          on the unsigned flag to determine whether the bound should
 160          be printed as a signed or an unsigned value.  This causes
 161          the upper bound of the 0 .. -1 range types to be printed as
 162          a very large unsigned number instead of -1.
 163          To workaround this stabs deficiency, we replace the TYPE by NULL
 164          to indicate default output when we detect that the bound is negative,
 165          and the type is a TYPE_CODE_INT.  The bound is negative when
 166          'm' is the last character of the number scanned in BOUNDS.  */
 167       if (bounds[*n - 1] == 'm' && TYPE_CODE (type) == TYPE_CODE_INT)
 168         type = NULL;
 169       ada_print_scalar (type, B, stream);
 170       if (bounds[*n] == '_')
 171         *n += 2;
 172     }
 173   else
 174     {
 175       int bound_len;
 176       char *bound = bounds + *n;
 177       char *pend;
 178
 179       pend = strstr (bound, "__");
 180       if (pend == NULL)
 181         *n += bound_len = strlen (bound);
 182       else
 183         {
 184           bound_len = pend - bound;
 185           *n += bound_len + 2;
 186         }
 187       fprintf_filtered (stream, "%.*s", bound_len, bound);
 188     }
 189 }
 190
 191 /* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
 192    the value (if found) of the bound indicated by SUFFIX ("___L" or
 193    "___U") according to the ___XD conventions.  */
 194
 195 static void
 196 print_dynamic_range_bound (struct type *type, const char *name, int name_len,
 197                            const char *suffix, struct ui_file *stream)
 198 {
 199   static char *name_buf = NULL;
 200   static size_t name_buf_len = 0;
 201   LONGEST B;
 202   int OK;
 203
 204   GROW_VECT (name_buf, name_buf_len, name_len + strlen (suffix) + 1);
 205   strncpy (name_buf, name, name_len);
 206   strcpy (name_buf + name_len, suffix);
 207
 208   B = get_int_var_value (name_buf, &OK);
 209   if (OK)
 210     ada_print_scalar (type, B, stream);
 211   else
 212     fprintf_filtered (stream, "?");
 213 }
 214
 215 /* Print the range type named NAME.  If symbol lookup fails, fall back
 216    to ORIG_TYPE as base type.  */
 217
 218 static void
 219 print_range_type_named (char *name, struct type *orig_type,
 220                         struct ui_file *stream)
 221 {
 222   struct type *raw_type = ada_find_any_type (name);
 223   struct type *base_type;
 224   char *subtype_info;
 225
 226   if (raw_type == NULL)
 227     raw_type = orig_type;
 228
 229   if (TYPE_CODE (raw_type) == TYPE_CODE_RANGE)
 230     base_type = TYPE_TARGET_TYPE (raw_type);
 231   else
 232     base_type = raw_type;
 233
 234   subtype_info = strstr (name, "___XD");
 235   if (subtype_info == NULL)
 236     print_range (raw_type, stream);
 237   else
 238     {
 239       int prefix_len = subtype_info - name;
 240       char *bounds_str;
 241       int n;
 242
 243       subtype_info += 5;
 244       bounds_str = strchr (subtype_info, '_');
 245       n = 1;
 246
 247       if (*subtype_info == 'L')
 248         {
 249           print_range_bound (base_type, bounds_str, &n, stream);
 250           subtype_info += 1;
 251         }
 252       else
 253         print_dynamic_range_bound (base_type, name, prefix_len, "___L",
 254                                    stream);
 255
 256       fprintf_filtered (stream, " .. ");
 257
 258       if (*subtype_info == 'U')
 259         print_range_bound (base_type, bounds_str, &n, stream);
 260       else
 261         print_dynamic_range_bound (base_type, name, prefix_len, "___U",
 262                                    stream);
 263     }
 264 }
 265
 266 /* Print enumerated type TYPE on STREAM.  */
 267
 268 static void
 269 print_enum_type (struct type *type, struct ui_file *stream)
 270 {
 271   int len = TYPE_NFIELDS (type);
 272   int i, lastval;
 273
 274   fprintf_filtered (stream, "(");
 275   wrap_here (" ");
 276
 277   lastval = 0;
 278   for (i = 0; i < len; i++)
 279     {
 280       QUIT;
 281       if (i)
 282         fprintf_filtered (stream, ", ");
 283       wrap_here ("    ");
 284       fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
 285       if (lastval != TYPE_FIELD_BITPOS (type, i))
 286         {
 287           fprintf_filtered (stream, " => %d", TYPE_FIELD_BITPOS (type, i));
 288           lastval = TYPE_FIELD_BITPOS (type, i);
 289         }
 290       lastval += 1;
 291     }
 292   fprintf_filtered (stream, ")");
 293 }
 294
 295 /* Print representation of Ada fixed-point type TYPE on STREAM.  */
 296
 297 static void
 298 print_fixed_point_type (struct type *type, struct ui_file *stream)
 299 {
 300   DOUBLEST delta = ada_delta (type);
 301   DOUBLEST small = ada_fixed_to_float (type, 1.0);
 302
 303   if (delta < 0.0)
 304     fprintf_filtered (stream, "delta ??");
 305   else
 306     {
 307       fprintf_filtered (stream, "delta %g", (double) delta);
 308       if (delta != small)
 309         fprintf_filtered (stream, " <'small = %g>", (double) small);
 310     }
 311 }
 312
 313 /* Print representation of special VAX floating-point type TYPE on STREAM.  */
 314
 315 static void
 316 print_vax_floating_point_type (struct type *type, struct ui_file *stream)
 317 {
 318   fprintf_filtered (stream, "<float format %c>",
 319                     ada_vax_float_type_suffix (type));
 320 }
 321
 322 /* Print simple (constrained) array type TYPE on STREAM.  LEVEL is the
 323    recursion (indentation) level, in case the element type itself has
 324    nested structure, and SHOW is the number of levels of internal
 325    structure to show (see ada_print_type).  */
 326
 327 static void
 328 print_array_type (struct type *type, struct ui_file *stream, int show,
 329                   int level)
 330 {
 331   int bitsize;
 332   int n_indices;
 333
 334   if (ada_is_constrained_packed_array_type (type))
 335     type = ada_coerce_to_simple_array_type (type);
 336
 337   bitsize = 0;
 338   fprintf_filtered (stream, "array (");
 339
 340   if (type == NULL)
 341     {
 342       fprintf_filtered (stream, _("<undecipherable array type>"));
 343       return;
 344     }
 345
 346   n_indices = -1;
 347   if (show < 0)
 348     fprintf_filtered (stream, "...");
 349   else
 350     {
 351       if (ada_is_simple_array_type (type))
 352         {
 353           struct type *range_desc_type =
 354             ada_find_parallel_type (type, "___XA");
 355           struct type *arr_type;
 356
 357           bitsize = 0;
 358           if (range_desc_type == NULL)
 359             {
 360               for (arr_type = type; TYPE_CODE (arr_type) == TYPE_CODE_ARRAY;
 361                    arr_type = TYPE_TARGET_TYPE (arr_type))
 362                 {
 363                   if (arr_type != type)
 364                     fprintf_filtered (stream, ", ");
 365                   print_range (TYPE_INDEX_TYPE (arr_type), stream);
 366                   if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
 367                     bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
 368                 }
 369             }
 370           else
 371             {
 372               int k;
 373               n_indices = TYPE_NFIELDS (range_desc_type);
 374               for (k = 0, arr_type = type;
 375                    k < n_indices;
 376                    k += 1, arr_type = TYPE_TARGET_TYPE (arr_type))
 377                 {
 378                   if (k > 0)
 379                     fprintf_filtered (stream, ", ");
 380                   print_range_type_named (TYPE_FIELD_NAME
 381                                           (range_desc_type, k),
 382                                           TYPE_INDEX_TYPE (arr_type), stream);
 383                   if (TYPE_FIELD_BITSIZE (arr_type, 0) > 0)
 384                     bitsize = TYPE_FIELD_BITSIZE (arr_type, 0);
 385                 }
 386             }
 387         }
 388       else
 389         {
 390           int i, i0;
 391           for (i = i0 = ada_array_arity (type); i > 0; i -= 1)
 392             fprintf_filtered (stream, "%s<>", i == i0 ? "" : ", ");
 393         }
 394     }
 395
 396   fprintf_filtered (stream, ") of ");
 397   wrap_here ("");
 398   ada_print_type (ada_array_element_type (type, n_indices), "", stream,
 399                   show == 0 ? 0 : show - 1, level + 1);
 400   if (bitsize > 0)
 401     fprintf_filtered (stream, " <packed: %d-bit elements>", bitsize);
 402 }
 403
 404 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
 405    STREAM, assuming that VAL_TYPE (if non-NULL) is the type of the values.  */
 406
 407 static void
 408 print_choices (struct type *type, int field_num, struct ui_file *stream,
 409                struct type *val_type)
 410 {
 411   int have_output;
 412   int p;
 413   const char *name = TYPE_FIELD_NAME (type, field_num);
 414
 415   have_output = 0;
 416
 417   /* Skip over leading 'V': NOTE soon to be obsolete.  */
 418   if (name[0] == 'V')
 419     {
 420       if (!ada_scan_number (name, 1, NULL, &p))
 421         goto Huh;
 422     }
 423   else
 424     p = 0;
 425
 426   while (1)
 427     {
 428       switch (name[p])
 429         {
 430         default:
 431           return;
 432         case 'S':
 433         case 'R':
 434         case 'O':
 435           if (have_output)
 436             fprintf_filtered (stream, " | ");
 437           have_output = 1;
 438           break;
 439         }
 440
 441       switch (name[p])
 442         {
 443         case 'S':
 444           {
 445             LONGEST W;
 446             if (!ada_scan_number (name, p + 1, &W, &p))
 447               goto Huh;
 448             ada_print_scalar (val_type, W, stream);
 449             break;
 450           }
 451         case 'R':
 452           {
 453             LONGEST L, U;
 454             if (!ada_scan_number (name, p + 1, &L, &p)
 455                 || name[p] != 'T' || !ada_scan_number (name, p + 1, &U, &p))
 456               goto Huh;
 457             ada_print_scalar (val_type, L, stream);
 458             fprintf_filtered (stream, " .. ");
 459             ada_print_scalar (val_type, U, stream);
 460             break;
 461           }
 462         case 'O':
 463           fprintf_filtered (stream, "others");
 464           p += 1;
 465           break;
 466         }
 467     }
 468
 469 Huh:
 470   fprintf_filtered (stream, "??");
 471
 472 }
 473
 474 /* Assuming that field FIELD_NUM of TYPE is a VARIANTS field whose
 475    discriminant is contained in OUTER_TYPE, print its variants on STREAM.
 476    LEVEL is the recursion
 477    (indentation) level, in case any of the fields themselves have
 478    nested structure, and SHOW is the number of levels of internal structure
 479    to show (see ada_print_type).  For this purpose, fields nested in a
 480    variant part are taken to be at the same level as the fields
 481    immediately outside the variant part.  */
 482
 483 static void
 484 print_variant_clauses (struct type *type, int field_num,
 485                        struct type *outer_type, struct ui_file *stream,
 486                        int show, int level)
 487 {
 488   int i;
 489   struct type *var_type, *par_type;
 490   struct type *discr_type;
 491
 492   var_type = TYPE_FIELD_TYPE (type, field_num);
 493   discr_type = ada_variant_discrim_type (var_type, outer_type);
 494
 495   if (TYPE_CODE (var_type) == TYPE_CODE_PTR)
 496     {
 497       var_type = TYPE_TARGET_TYPE (var_type);
 498       if (var_type == NULL || TYPE_CODE (var_type) != TYPE_CODE_UNION)
 499         return;
 500     }
 501
 502   par_type = ada_find_parallel_type (var_type, "___XVU");
 503   if (par_type != NULL)
 504     var_type = par_type;
 505
 506   for (i = 0; i < TYPE_NFIELDS (var_type); i += 1)
 507     {
 508       fprintf_filtered (stream, "\n%*swhen ", level + 4, "");
 509       print_choices (var_type, i, stream, discr_type);
 510       fprintf_filtered (stream, " =>");
 511       if (print_record_field_types (TYPE_FIELD_TYPE (var_type, i),
 512                                     outer_type, stream, show, level + 4) <= 0)
 513         fprintf_filtered (stream, " null;");
 514     }
 515 }
 516
 517 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
 518    discriminants are contained in OUTER_TYPE, print a description of it
 519    on STREAM.  LEVEL is the recursion (indentation) level, in case any of
 520    the fields themselves have nested structure, and SHOW is the number of
 521    levels of internal structure to show (see ada_print_type).  For this
 522    purpose, fields nested in a variant part are taken to be at the same
 523    level as the fields immediately outside the variant part.  */
 524
 525 static void
 526 print_variant_part (struct type *type, int field_num, struct type *outer_type,
 527                     struct ui_file *stream, int show, int level)
 528 {
 529   fprintf_filtered (stream, "\n%*scase %s is", level + 4, "",
 530                     ada_variant_discrim_name
 531                     (TYPE_FIELD_TYPE (type, field_num)));
 532   print_variant_clauses (type, field_num, outer_type, stream, show,
 533                          level + 4);
 534   fprintf_filtered (stream, "\n%*send case;", level + 4, "");
 535 }
 536
 537 /* Print a description on STREAM of the fields in record type TYPE, whose
 538    discriminants are in OUTER_TYPE.  LEVEL is the recursion (indentation)
 539    level, in case any of the fields themselves have nested structure,
 540    and SHOW is the number of levels of internal structure to show
 541    (see ada_print_type).  Does not print parent type information of TYPE.
 542    Returns 0 if no fields printed, -1 for an incomplete type, else > 0.
 543    Prints each field beginning on a new line, but does not put a new line at
 544    end.  */
 545
 546 static int
 547 print_record_field_types (struct type *type, struct type *outer_type,
 548                           struct ui_file *stream, int show, int level)
 549 {
 550   int len, i, flds;
 551
 552   flds = 0;
 553   len = TYPE_NFIELDS (type);
 554
 555   if (len == 0 && TYPE_STUB (type))
 556     return -1;
 557
 558   for (i = 0; i < len; i += 1)
 559     {
 560       QUIT;
 561
 562       if (ada_is_parent_field (type, i) || ada_is_ignored_field (type, i))
 563         ;
 564       else if (ada_is_wrapper_field (type, i))
 565         flds += print_record_field_types (TYPE_FIELD_TYPE (type, i), type,
 566                                           stream, show, level);
 567       else if (ada_is_variant_part (type, i))
 568         {
 569           print_variant_part (type, i, outer_type, stream, show, level);
 570           flds = 1;
 571         }
 572       else
 573         {
 574           flds += 1;
 575           fprintf_filtered (stream, "\n%*s", level + 4, "");
 576           ada_print_type (TYPE_FIELD_TYPE (type, i),
 577                           TYPE_FIELD_NAME (type, i),
 578                           stream, show - 1, level + 4);
 579           fprintf_filtered (stream, ";");
 580         }
 581     }
 582
 583   return flds;
 584 }
 585
 586 /* Print record type TYPE on STREAM.  LEVEL is the recursion (indentation)
 587    level, in case the element type itself has nested structure, and SHOW is
 588    the number of levels of internal structure to show (see ada_print_type).  */
 589
 590 static void
 591 print_record_type (struct type *type0, struct ui_file *stream, int show,
 592                    int level)
 593 {
 594   struct type *parent_type;
 595   struct type *type;
 596
 597   type = ada_find_parallel_type (type0, "___XVE");
 598   if (type == NULL)
 599     type = type0;
 600
 601   parent_type = ada_parent_type (type);
 602   if (ada_type_name (parent_type) != NULL)
 603     fprintf_filtered (stream, "new %s with record",
 604                       decoded_type_name (parent_type));
 605   else if (parent_type == NULL && ada_is_tagged_type (type, 0))
 606     fprintf_filtered (stream, "tagged record");
 607   else
 608     fprintf_filtered (stream, "record");
 609
 610   if (show < 0)
 611     fprintf_filtered (stream, " ... end record");
 612   else
 613     {
 614       int flds;
 615
 616       flds = 0;
 617       if (parent_type != NULL && ada_type_name (parent_type) == NULL)
 618         flds += print_record_field_types (parent_type, parent_type,
 619                                           stream, show, level);
 620       flds += print_record_field_types (type, type, stream, show, level);
 621
 622       if (flds > 0)
 623         fprintf_filtered (stream, "\n%*send record", level, "");
 624       else if (flds < 0)
 625         fprintf_filtered (stream, _(" <incomplete type> end record"));
 626       else
 627         fprintf_filtered (stream, " null; end record");
 628     }
 629 }
 630
 631 /* Print the unchecked union type TYPE in something resembling Ada
 632    format on STREAM.  LEVEL is the recursion (indentation) level
 633    in case the element type itself has nested structure, and SHOW is the
 634    number of levels of internal structure to show (see ada_print_type).  */
 635 static void
 636 print_unchecked_union_type (struct type *type, struct ui_file *stream,
 637                             int show, int level)
 638 {
 639   if (show < 0)
 640     fprintf_filtered (stream, "record (?) is ... end record");
 641   else if (TYPE_NFIELDS (type) == 0)
 642     fprintf_filtered (stream, "record (?) is null; end record");
 643   else
 644     {
 645       int i;
 646
 647       fprintf_filtered (stream, "record (?) is\n%*scase ? is", level + 4, "");
 648
 649       for (i = 0; i < TYPE_NFIELDS (type); i += 1)
 650         {
 651           fprintf_filtered (stream, "\n%*swhen ? =>\n%*s", level + 8, "",
 652                             level + 12, "");
 653           ada_print_type (TYPE_FIELD_TYPE (type, i),
 654                           TYPE_FIELD_NAME (type, i),
 655                           stream, show - 1, level + 12);
 656           fprintf_filtered (stream, ";");
 657         }
 658
 659       fprintf_filtered (stream, "\n%*send case;\n%*send record",
 660                         level + 4, "", level, "");
 661     }
 662 }
 663
 664
 665
 666 /* Print function or procedure type TYPE on STREAM.  Make it a header
 667    for function or procedure NAME if NAME is not null.  */
 668
 669 static void
 670 print_func_type (struct type *type, struct ui_file *stream, char *name)
 671 {
 672   int i, len = TYPE_NFIELDS (type);
 673
 674   if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
 675     fprintf_filtered (stream, "procedure");
 676   else
 677     fprintf_filtered (stream, "function");
 678
 679   if (name != NULL && name[0] != '\0')
 680     fprintf_filtered (stream, " %s", name);
 681
 682   if (len > 0)
 683     {
 684       fprintf_filtered (stream, " (");
 685       for (i = 0; i < len; i += 1)
 686         {
 687           if (i > 0)
 688             {
 689               fputs_filtered ("; ", stream);
 690               wrap_here ("    ");
 691             }
 692           fprintf_filtered (stream, "a%d: ", i + 1);
 693           ada_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
 694         }
 695       fprintf_filtered (stream, ")");
 696     }
 697
 698   if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
 699     {
 700       fprintf_filtered (stream, " return ");
 701       ada_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, 0);
 702     }
 703 }
 704
 705
 706 /* Print a description of a type TYPE0.
 707    Output goes to STREAM (via stdio).
 708    If VARSTRING is a non-empty string, print as an Ada variable/field
 709        declaration.
 710    SHOW+1 is the maximum number of levels of internal type structure
 711       to show (this applies to record types, enumerated types, and
 712       array types).
 713    SHOW is the number of levels of internal type structure to show
 714       when there is a type name for the SHOWth deepest level (0th is
 715       outer level).
 716    When SHOW<0, no inner structure is shown.
 717    LEVEL indicates level of recursion (for nested definitions).  */
 718
 719 void
 720 ada_print_type (struct type *type0, char *varstring, struct ui_file *stream,
 721                 int show, int level)
 722 {
 723   struct type *type = ada_check_typedef (ada_get_base_type (type0));
 724   char *type_name = decoded_type_name (type0);
 725   int is_var_decl = (varstring != NULL && varstring[0] != '\0');
 726
 727   if (type == NULL)
 728     {
 729       if (is_var_decl)
 730         fprintf_filtered (stream, "%.*s: ",
 731                           ada_name_prefix_len (varstring), varstring);
 732       fprintf_filtered (stream, "<null type?>");
 733       return;
 734     }
 735
 736   if (show > 0)
 737     type = ada_check_typedef (type);
 738
 739   if (is_var_decl && TYPE_CODE (type) != TYPE_CODE_FUNC)
 740     fprintf_filtered (stream, "%.*s: ",
 741                       ada_name_prefix_len (varstring), varstring);
 742
 743   if (type_name != NULL && show <= 0)
 744     {
 745       fprintf_filtered (stream, "%.*s",
 746                         ada_name_prefix_len (type_name), type_name);
 747       return;
 748     }
 749
 750   if (ada_is_aligner_type (type))
 751     ada_print_type (ada_aligned_type (type), "", stream, show, level);
 752   else if (ada_is_constrained_packed_array_type (type))
 753     {
 754       if (TYPE_CODE (type) == TYPE_CODE_PTR)
 755         {
 756           fprintf_filtered (stream, "access ");
 757           print_array_type (TYPE_TARGET_TYPE (type), stream, show, level);
 758         }
 759       else
 760         {
 761           print_array_type (type, stream, show, level);
 762         }
 763     }
 764   else
 765     switch (TYPE_CODE (type))
 766       {
 767       default:
 768         fprintf_filtered (stream, "<");
 769         c_print_type (type, "", stream, show, level);
 770         fprintf_filtered (stream, ">");
 771         break;
 772       case TYPE_CODE_PTR:
 773         fprintf_filtered (stream, "access ");
 774         ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
 775         break;
 776       case TYPE_CODE_REF:
 777         fprintf_filtered (stream, "<ref> ");
 778         ada_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
 779         break;
 780       case TYPE_CODE_ARRAY:
 781         print_array_type (type, stream, show, level);
 782         break;
 783       case TYPE_CODE_BOOL:
 784         fprintf_filtered (stream, "(false, true)");
 785         break;
 786       case TYPE_CODE_INT:
 787         if (ada_is_fixed_point_type (type))
 788           print_fixed_point_type (type, stream);
 789         else if (ada_is_vax_floating_type (type))
 790           print_vax_floating_point_type (type, stream);
 791         else
 792           {
 793             char *name = ada_type_name (type);
 794             if (!ada_is_range_type_name (name))
 795               fprintf_filtered (stream, _("<%d-byte integer>"),
 796                                 TYPE_LENGTH (type));
 797             else
 798               {
 799                 fprintf_filtered (stream, "range ");
 800                 print_range_type_named (name, type, stream);
 801               }
 802           }
 803         break;
 804       case TYPE_CODE_RANGE:
 805         if (ada_is_fixed_point_type (type))
 806           print_fixed_point_type (type, stream);
 807         else if (ada_is_vax_floating_type (type))
 808           print_vax_floating_point_type (type, stream);
 809         else if (ada_is_modular_type (type))
 810           fprintf_filtered (stream, "mod %s",
 811                             int_string (ada_modulus (type), 10, 0, 0, 1));
 812         else
 813           {
 814             fprintf_filtered (stream, "range ");
 815             print_range (type, stream);
 816           }
 817         break;
 818       case TYPE_CODE_FLT:
 819         fprintf_filtered (stream, _("<%d-byte float>"), TYPE_LENGTH (type));
 820         break;
 821       case TYPE_CODE_ENUM:
 822         if (show < 0)
 823           fprintf_filtered (stream, "(...)");
 824         else
 825           print_enum_type (type, stream);
 826         break;
 827       case TYPE_CODE_STRUCT:
 828         if (ada_is_array_descriptor_type (type))
 829           print_array_type (type, stream, show, level);
 830         else if (ada_is_bogus_array_descriptor (type))
 831           fprintf_filtered (stream,
 832                             _("array (?) of ? (<mal-formed descriptor>)"));
 833         else
 834           print_record_type (type, stream, show, level);
 835         break;
 836       case TYPE_CODE_UNION:
 837         print_unchecked_union_type (type, stream, show, level);
 838         break;
 839       case TYPE_CODE_FUNC:
 840         print_func_type (type, stream, varstring);
 841         break;
 842       }
 843 }