gdb/ada-typeprint.c

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