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