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