gdb/c-typeprint.c

   1 /* Support for printing C and C++ types for GDB, the GNU debugger.
   2    Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
   3    1999, 2000, 2001, 2002
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "obstack.h"
  25 #include "bfd.h"                /* Binary File Description */
  26 #include "symtab.h"
  27 #include "gdbtypes.h"
  28 #include "expression.h"
  29 #include "value.h"
  30 #include "gdbcore.h"
  31 #include "target.h"
  32 #include "language.h"
  33 #include "demangle.h"
  34 #include "c-lang.h"
  35 #include "typeprint.h"
  36 #include "cp-abi.h"
  37
  38 #include "gdb_string.h"
  39 #include <errno.h>
  40
  41 /* Flag indicating target was compiled by HP compiler */
  42 extern int hp_som_som_object_present;
  43
  44 static void cp_type_print_method_args (struct type ** args, char *prefix,
  45                                        char *varstring, int staticp,
  46                                        struct ui_file *stream);
  47
  48 static void c_type_print_args (struct type *, struct ui_file *);
  49
  50 static void cp_type_print_derivation_info (struct ui_file *, struct type *);
  51
  52 void c_type_print_varspec_prefix (struct type *, struct ui_file *, int,
  53                                   int);
  54
  55 /* Print "const", "volatile", or address space modifiers. */
  56 static void c_type_print_modifier (struct type *, struct ui_file *,
  57                                    int, int);
  58 \f
  59
  60
  61
  62 /* LEVEL is the depth to indent lines by.  */
  63
  64 void
  65 c_print_type (struct type *type, char *varstring, struct ui_file *stream,
  66               int show, int level)
  67 {
  68   register enum type_code code;
  69   int demangled_args;
  70
  71   if (show > 0)
  72     CHECK_TYPEDEF (type);
  73
  74   c_type_print_base (type, stream, show, level);
  75   code = TYPE_CODE (type);
  76   if ((varstring != NULL && *varstring != '\0')
  77       ||
  78   /* Need a space if going to print stars or brackets;
  79      but not if we will print just a type name.  */
  80       ((show > 0 || TYPE_NAME (type) == 0)
  81        &&
  82        (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
  83         || code == TYPE_CODE_METHOD
  84         || code == TYPE_CODE_ARRAY
  85         || code == TYPE_CODE_MEMBER
  86         || code == TYPE_CODE_REF)))
  87     fputs_filtered (" ", stream);
  88   c_type_print_varspec_prefix (type, stream, show, 0);
  89
  90   if (varstring != NULL)
  91     {
  92       fputs_filtered (varstring, stream);
  93
  94       /* For demangled function names, we have the arglist as part of the name,
  95          so don't print an additional pair of ()'s */
  96
  97       demangled_args = strchr (varstring, '(') != NULL;
  98       c_type_print_varspec_suffix (type, stream, show, 0, demangled_args);
  99     }
 100 }
 101
 102 /* If TYPE is a derived type, then print out derivation information.
 103    Print only the actual base classes of this type, not the base classes
 104    of the base classes.  I.E.  for the derivation hierarchy:
 105
 106    class A { int a; };
 107    class B : public A {int b; };
 108    class C : public B {int c; };
 109
 110    Print the type of class C as:
 111
 112    class C : public B {
 113    int c;
 114    }
 115
 116    Not as the following (like gdb used to), which is not legal C++ syntax for
 117    derived types and may be confused with the multiple inheritance form:
 118
 119    class C : public B : public A {
 120    int c;
 121    }
 122
 123    In general, gdb should try to print the types as closely as possible to
 124    the form that they appear in the source code.
 125    Note that in case of protected derivation gcc will not say 'protected'
 126    but 'private'. The HP's aCC compiler emits specific information for
 127    derivation via protected inheritance, so gdb can print it out */
 128
 129 static void
 130 cp_type_print_derivation_info (struct ui_file *stream, struct type *type)
 131 {
 132   char *name;
 133   int i;
 134
 135   for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
 136     {
 137       fputs_filtered (i == 0 ? ": " : ", ", stream);
 138       fprintf_filtered (stream, "%s%s ",
 139                         BASETYPE_VIA_PUBLIC (type, i) ? "public"
 140                : (TYPE_FIELD_PROTECTED (type, i) ? "protected" : "private"),
 141                         BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : "");
 142       name = type_name_no_tag (TYPE_BASECLASS (type, i));
 143       fprintf_filtered (stream, "%s", name ? name : "(null)");
 144     }
 145   if (i > 0)
 146     {
 147       fputs_filtered (" ", stream);
 148     }
 149 }
 150 /* Print the C++ method arguments ARGS to the file STREAM.  */
 151
 152 static void
 153 cp_type_print_method_args (struct type **args, char *prefix, char *varstring,
 154                            int staticp, struct ui_file *stream)
 155 {
 156   int i;
 157
 158   fprintf_symbol_filtered (stream, prefix, language_cplus, DMGL_ANSI);
 159   fprintf_symbol_filtered (stream, varstring, language_cplus, DMGL_ANSI);
 160   fputs_filtered ("(", stream);
 161   if (args && args[!staticp] && TYPE_CODE (args[!staticp]) != TYPE_CODE_VOID)
 162     {
 163       i = !staticp;             /* skip the class variable */
 164       while (1)
 165         {
 166           type_print (args[i++], "", stream, 0);
 167           if (!args[i])
 168             {
 169               fprintf_filtered (stream, " ...");
 170               break;
 171             }
 172           else if (TYPE_CODE (args[i]) != TYPE_CODE_VOID)
 173             {
 174               fprintf_filtered (stream, ", ");
 175             }
 176           else
 177             break;
 178         }
 179     }
 180   else if (current_language->la_language == language_cplus)
 181     {
 182       fprintf_filtered (stream, "void");
 183     }
 184
 185   fprintf_filtered (stream, ")");
 186 }
 187
 188
 189 /* Print any asterisks or open-parentheses needed before the
 190    variable name (to describe its type).
 191
 192    On outermost call, pass 0 for PASSED_A_PTR.
 193    On outermost call, SHOW > 0 means should ignore
 194    any typename for TYPE and show its details.
 195    SHOW is always zero on recursive calls.  */
 196
 197 void
 198 c_type_print_varspec_prefix (struct type *type, struct ui_file *stream,
 199                              int show, int passed_a_ptr)
 200 {
 201   char *name;
 202   if (type == 0)
 203     return;
 204
 205   if (TYPE_NAME (type) && show <= 0)
 206     return;
 207
 208   QUIT;
 209
 210   switch (TYPE_CODE (type))
 211     {
 212     case TYPE_CODE_PTR:
 213       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1);
 214       fprintf_filtered (stream, "*");
 215       c_type_print_modifier (type, stream, 1, 0);
 216       break;
 217
 218     case TYPE_CODE_MEMBER:
 219       if (passed_a_ptr)
 220         fprintf_filtered (stream, "(");
 221       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
 222       fprintf_filtered (stream, " ");
 223       name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
 224       if (name)
 225         fputs_filtered (name, stream);
 226       else
 227         c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
 228       fprintf_filtered (stream, "::");
 229       break;
 230
 231     case TYPE_CODE_METHOD:
 232       if (passed_a_ptr)
 233         fprintf_filtered (stream, "(");
 234       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
 235       if (passed_a_ptr)
 236         {
 237           fprintf_filtered (stream, " ");
 238           c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
 239           fprintf_filtered (stream, "::");
 240         }
 241       break;
 242
 243     case TYPE_CODE_REF:
 244       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1);
 245       fprintf_filtered (stream, "&");
 246       c_type_print_modifier (type, stream, 1, 0);
 247       break;
 248
 249     case TYPE_CODE_FUNC:
 250       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
 251       if (passed_a_ptr)
 252         fprintf_filtered (stream, "(");
 253       break;
 254
 255     case TYPE_CODE_ARRAY:
 256       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
 257       if (passed_a_ptr)
 258         fprintf_filtered (stream, "(");
 259       break;
 260
 261     case TYPE_CODE_UNDEF:
 262     case TYPE_CODE_STRUCT:
 263     case TYPE_CODE_UNION:
 264     case TYPE_CODE_ENUM:
 265     case TYPE_CODE_INT:
 266     case TYPE_CODE_FLT:
 267     case TYPE_CODE_VOID:
 268     case TYPE_CODE_ERROR:
 269     case TYPE_CODE_CHAR:
 270     case TYPE_CODE_BOOL:
 271     case TYPE_CODE_SET:
 272     case TYPE_CODE_RANGE:
 273     case TYPE_CODE_STRING:
 274     case TYPE_CODE_BITSTRING:
 275     case TYPE_CODE_COMPLEX:
 276     case TYPE_CODE_TYPEDEF:
 277     case TYPE_CODE_TEMPLATE:
 278       /* These types need no prefix.  They are listed here so that
 279          gcc -Wall will reveal any types that haven't been handled.  */
 280       break;
 281     default:
 282       error ("type not handled in c_type_print_varspec_prefix()");
 283       break;
 284     }
 285 }
 286
 287 /* Print out "const" and "volatile" attributes.
 288    TYPE is a pointer to the type being printed out.
 289    STREAM is the output destination.
 290    NEED_SPACE = 1 indicates an initial white space is needed */
 291
 292 static void
 293 c_type_print_modifier (struct type *type, struct ui_file *stream,
 294                        int need_pre_space, int need_post_space)
 295 {
 296   int did_print_modifier = 0;
 297   char *address_space_id;
 298
 299   /* We don't print `const' qualifiers for references --- since all
 300      operators affect the thing referenced, not the reference itself,
 301      every reference is `const'.  */
 302   if (TYPE_CONST (type)
 303       && TYPE_CODE (type) != TYPE_CODE_REF)
 304     {
 305       if (need_pre_space)
 306         fprintf_filtered (stream, " ");
 307       fprintf_filtered (stream, "const");
 308       did_print_modifier = 1;
 309     }
 310
 311   if (TYPE_VOLATILE (type))
 312     {
 313       if (did_print_modifier || need_pre_space)
 314         fprintf_filtered (stream, " ");
 315       fprintf_filtered (stream, "volatile");
 316       did_print_modifier = 1;
 317     }
 318
 319   address_space_id = address_space_int_to_name (TYPE_INSTANCE_FLAGS (type));
 320   if (address_space_id)
 321     {
 322       if (did_print_modifier || need_pre_space)
 323         fprintf_filtered (stream, " ");
 324       fprintf_filtered (stream, "@%s", address_space_id);
 325       did_print_modifier = 1;
 326     }
 327
 328   if (did_print_modifier && need_post_space)
 329     fprintf_filtered (stream, " ");
 330 }
 331
 332
 333
 334
 335 static void
 336 c_type_print_args (struct type *type, struct ui_file *stream)
 337 {
 338   int i;
 339   struct type **args;
 340
 341   fprintf_filtered (stream, "(");
 342   args = TYPE_ARG_TYPES (type);
 343   if (args != NULL)
 344     {
 345       if (args[1] == NULL)
 346         {
 347           fprintf_filtered (stream, "...");
 348         }
 349       else if ((TYPE_CODE (args[1]) == TYPE_CODE_VOID) &&
 350                (current_language->la_language == language_cplus))
 351         {
 352           fprintf_filtered (stream, "void");
 353         }
 354       else
 355         {
 356           for (i = 1;
 357                args[i] != NULL && TYPE_CODE (args[i]) != TYPE_CODE_VOID;
 358                i++)
 359             {
 360               c_print_type (args[i], "", stream, -1, 0);
 361               if (args[i + 1] == NULL)
 362                 {
 363                   fprintf_filtered (stream, "...");
 364                 }
 365               else if (TYPE_CODE (args[i + 1]) != TYPE_CODE_VOID)
 366                 {
 367                   fprintf_filtered (stream, ",");
 368                   wrap_here ("    ");
 369                 }
 370             }
 371         }
 372     }
 373   else if (current_language->la_language == language_cplus)
 374     {
 375       fprintf_filtered (stream, "void");
 376     }
 377
 378   fprintf_filtered (stream, ")");
 379 }
 380
 381
 382 /* Return true iff the j'th overloading of the i'th method of TYPE
 383    is a type conversion operator, like `operator int () { ... }'.
 384    When listing a class's methods, we don't print the return type of
 385    such operators.  */
 386 static int
 387 is_type_conversion_operator (struct type *type, int i, int j)
 388 {
 389   /* I think the whole idea of recognizing type conversion operators
 390      by their name is pretty terrible.  But I don't think our present
 391      data structure gives us any other way to tell.  If you know of
 392      some other way, feel free to rewrite this function.  */
 393   char *name = TYPE_FN_FIELDLIST_NAME (type, i);
 394
 395   if (strncmp (name, "operator", 8) != 0)
 396     return 0;
 397
 398   name += 8;
 399   if (! strchr (" \t\f\n\r", *name))
 400     return 0;
 401
 402   while (strchr (" \t\f\n\r", *name))
 403     name++;
 404
 405   if (!('a' <= *name && *name <= 'z')
 406       && !('A' <= *name && *name <= 'Z')
 407       && *name != '_')
 408     /* If this doesn't look like the start of an identifier, then it
 409        isn't a type conversion operator.  */
 410     return 0;
 411   else if (strncmp (name, "new", 3) == 0)
 412     name += 3;
 413   else if (strncmp (name, "delete", 6) == 0)
 414     name += 6;
 415   else
 416     /* If it doesn't look like new or delete, it's a type conversion
 417        operator.  */
 418     return 1;
 419
 420   /* Is that really the end of the name?  */
 421   if (('a' <= *name && *name <= 'z')
 422       || ('A' <= *name && *name <= 'Z')
 423       || ('0' <= *name && *name <= '9')
 424       || *name == '_')
 425     /* No, so the identifier following "operator" must be a type name,
 426        and this is a type conversion operator.  */
 427     return 1;
 428
 429   /* That was indeed the end of the name, so it was `operator new' or
 430      `operator delete', neither of which are type conversion operators.  */
 431   return 0;
 432 }
 433
 434
 435 /* Given a C++ qualified identifier QID, strip off the qualifiers,
 436    yielding the unqualified name.  The return value is a pointer into
 437    the original string.
 438
 439    It's a pity we don't have this information in some more structured
 440    form.  Even the author of this function feels that writing little
 441    parsers like this everywhere is stupid.  */
 442 static char *
 443 remove_qualifiers (char *qid)
 444 {
 445   int quoted = 0;               /* zero if we're not in quotes;
 446                                    '"' if we're in a double-quoted string;
 447                                    '\'' if we're in a single-quoted string.  */
 448   int depth = 0;                /* number of unclosed parens we've seen */
 449   char *parenstack = (char *) alloca (strlen (qid));
 450   char *scan;
 451   char *last = 0;               /* The character after the rightmost
 452                                    `::' token we've seen so far.  */
 453
 454   for (scan = qid; *scan; scan++)
 455     {
 456       if (quoted)
 457         {
 458           if (*scan == quoted)
 459             quoted = 0;
 460           else if (*scan == '\\' && *(scan + 1))
 461             scan++;
 462         }
 463       else if (scan[0] == ':' && scan[1] == ':')
 464         {
 465           /* If we're inside parenthesis (i.e., an argument list) or
 466              angle brackets (i.e., a list of template arguments), then
 467              we don't record the position of this :: token, since it's
 468              not relevant to the top-level structure we're trying
 469              to operate on.  */
 470           if (depth == 0)
 471             {
 472               last = scan + 2;
 473               scan++;
 474             }
 475         }
 476       else if (*scan == '"' || *scan == '\'')
 477         quoted = *scan;
 478       else if (*scan == '(')
 479         parenstack[depth++] = ')';
 480       else if (*scan == '[')
 481         parenstack[depth++] = ']';
 482       /* We're going to treat <> as a pair of matching characters,
 483          since we're more likely to see those in template id's than
 484          real less-than characters.  What a crock.  */
 485       else if (*scan == '<')
 486         parenstack[depth++] = '>';
 487       else if (*scan == ')' || *scan == ']' || *scan == '>')
 488         {
 489           if (depth > 0 && parenstack[depth - 1] == *scan)
 490             depth--;
 491           else
 492             {
 493               /* We're going to do a little error recovery here.  If we
 494                  don't find a match for *scan on the paren stack, but
 495                  there is something lower on the stack that does match, we
 496                  pop the stack to that point.  */
 497               int i;
 498
 499               for (i = depth - 1; i >= 0; i--)
 500                 if (parenstack[i] == *scan)
 501                   {
 502                     depth = i;
 503                     break;
 504                   }
 505             }
 506         }
 507     }
 508
 509   if (last)
 510     return last;
 511   else
 512     /* We didn't find any :: tokens at the top level, so declare the
 513        whole thing an unqualified identifier.  */
 514     return qid;
 515 }
 516
 517
 518 /* Print any array sizes, function arguments or close parentheses
 519    needed after the variable name (to describe its type).
 520    Args work like c_type_print_varspec_prefix.  */
 521
 522 void
 523 c_type_print_varspec_suffix (struct type *type, struct ui_file *stream,
 524                              int show, int passed_a_ptr, int demangled_args)
 525 {
 526   if (type == 0)
 527     return;
 528
 529   if (TYPE_NAME (type) && show <= 0)
 530     return;
 531
 532   QUIT;
 533
 534   switch (TYPE_CODE (type))
 535     {
 536     case TYPE_CODE_ARRAY:
 537       if (passed_a_ptr)
 538         fprintf_filtered (stream, ")");
 539
 540       fprintf_filtered (stream, "[");
 541       if (TYPE_LENGTH (type) >= 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
 542         && TYPE_ARRAY_UPPER_BOUND_TYPE (type) != BOUND_CANNOT_BE_DETERMINED)
 543         fprintf_filtered (stream, "%d",
 544                           (TYPE_LENGTH (type)
 545                            / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
 546       fprintf_filtered (stream, "]");
 547
 548       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
 549       break;
 550
 551     case TYPE_CODE_MEMBER:
 552       if (passed_a_ptr)
 553         fprintf_filtered (stream, ")");
 554       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
 555       break;
 556
 557     case TYPE_CODE_METHOD:
 558       if (passed_a_ptr)
 559         fprintf_filtered (stream, ")");
 560       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
 561       if (passed_a_ptr)
 562         {
 563           c_type_print_args (type, stream);
 564         }
 565       break;
 566
 567     case TYPE_CODE_PTR:
 568     case TYPE_CODE_REF:
 569       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 1, 0);
 570       break;
 571
 572     case TYPE_CODE_FUNC:
 573       if (passed_a_ptr)
 574         fprintf_filtered (stream, ")");
 575       if (!demangled_args)
 576         {
 577           int i, len = TYPE_NFIELDS (type);
 578           fprintf_filtered (stream, "(");
 579           if (len == 0
 580               && (TYPE_PROTOTYPED (type)
 581                   || current_language->la_language == language_cplus))
 582             {
 583               fprintf_filtered (stream, "void");
 584             }
 585           else
 586             for (i = 0; i < len; i++)
 587               {
 588                 if (i > 0)
 589                   {
 590                     fputs_filtered (", ", stream);
 591                     wrap_here ("    ");
 592                   }
 593                 c_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
 594               }
 595           fprintf_filtered (stream, ")");
 596         }
 597       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
 598                                    passed_a_ptr, 0);
 599       break;
 600
 601     case TYPE_CODE_UNDEF:
 602     case TYPE_CODE_STRUCT:
 603     case TYPE_CODE_UNION:
 604     case TYPE_CODE_ENUM:
 605     case TYPE_CODE_INT:
 606     case TYPE_CODE_FLT:
 607     case TYPE_CODE_VOID:
 608     case TYPE_CODE_ERROR:
 609     case TYPE_CODE_CHAR:
 610     case TYPE_CODE_BOOL:
 611     case TYPE_CODE_SET:
 612     case TYPE_CODE_RANGE:
 613     case TYPE_CODE_STRING:
 614     case TYPE_CODE_BITSTRING:
 615     case TYPE_CODE_COMPLEX:
 616     case TYPE_CODE_TYPEDEF:
 617     case TYPE_CODE_TEMPLATE:
 618       /* These types do not need a suffix.  They are listed so that
 619          gcc -Wall will report types that may not have been considered.  */
 620       break;
 621     default:
 622       error ("type not handled in c_type_print_varspec_suffix()");
 623       break;
 624     }
 625 }
 626
 627 /* Print the name of the type (or the ultimate pointer target,
 628    function value or array element), or the description of a
 629    structure or union.
 630
 631    SHOW positive means print details about the type (e.g. enum values),
 632    and print structure elements passing SHOW - 1 for show.
 633    SHOW negative means just print the type name or struct tag if there is one.
 634    If there is no name, print something sensible but concise like
 635    "struct {...}".
 636    SHOW zero means just print the type name or struct tag if there is one.
 637    If there is no name, print something sensible but not as concise like
 638    "struct {int x; int y;}".
 639
 640    LEVEL is the number of spaces to indent by.
 641    We increase it for some recursive calls.  */
 642
 643 void
 644 c_type_print_base (struct type *type, struct ui_file *stream, int show,
 645                    int level)
 646 {
 647   int i;
 648   int len, real_len;
 649   int lastval;
 650   char *mangled_name;
 651   char *demangled_name;
 652   char *demangled_no_static;
 653   enum
 654     {
 655       s_none, s_public, s_private, s_protected
 656     }
 657   section_type;
 658   int need_access_label = 0;
 659   int j, len2;
 660
 661   QUIT;
 662
 663   wrap_here ("    ");
 664   if (type == NULL)
 665     {
 666       fputs_filtered ("<type unknown>", stream);
 667       return;
 668     }
 669
 670   /* When SHOW is zero or less, and there is a valid type name, then always
 671      just print the type name directly from the type.  */
 672   /* If we have "typedef struct foo {. . .} bar;" do we want to print it
 673      as "struct foo" or as "bar"?  Pick the latter, because C++ folk tend
 674      to expect things like "class5 *foo" rather than "struct class5 *foo".  */
 675
 676   if (show <= 0
 677       && TYPE_NAME (type) != NULL)
 678     {
 679       c_type_print_modifier (type, stream, 0, 1);
 680       fputs_filtered (TYPE_NAME (type), stream);
 681       return;
 682     }
 683
 684   CHECK_TYPEDEF (type);
 685
 686   switch (TYPE_CODE (type))
 687     {
 688     case TYPE_CODE_TYPEDEF:
 689     case TYPE_CODE_ARRAY:
 690     case TYPE_CODE_PTR:
 691     case TYPE_CODE_MEMBER:
 692     case TYPE_CODE_REF:
 693     case TYPE_CODE_FUNC:
 694     case TYPE_CODE_METHOD:
 695       c_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
 696       break;
 697
 698     case TYPE_CODE_STRUCT:
 699       c_type_print_modifier (type, stream, 0, 1);
 700       /* Note TYPE_CODE_STRUCT and TYPE_CODE_CLASS have the same value,
 701        * so we use another means for distinguishing them.
 702        */
 703       if (HAVE_CPLUS_STRUCT (type))
 704         {
 705           switch (TYPE_DECLARED_TYPE (type))
 706             {
 707             case DECLARED_TYPE_CLASS:
 708               fprintf_filtered (stream, "class ");
 709               break;
 710             case DECLARED_TYPE_UNION:
 711               fprintf_filtered (stream, "union ");
 712               break;
 713             case DECLARED_TYPE_STRUCT:
 714               fprintf_filtered (stream, "struct ");
 715               break;
 716             default:
 717               /* If there is a CPLUS_STRUCT, assume class if not
 718                * otherwise specified in the declared_type field.
 719                */
 720               fprintf_filtered (stream, "class ");
 721               break;
 722             }                   /* switch */
 723         }
 724       else
 725         {
 726           /* If not CPLUS_STRUCT, then assume it's a C struct */
 727           fprintf_filtered (stream, "struct ");
 728         }
 729       goto struct_union;
 730
 731     case TYPE_CODE_UNION:
 732       c_type_print_modifier (type, stream, 0, 1);
 733       fprintf_filtered (stream, "union ");
 734
 735     struct_union:
 736
 737       /* Print the tag if it exists.
 738        * The HP aCC compiler emits
 739        * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
 740        * tag  for unnamed struct/union/enum's, which we don't
 741        * want to print.
 742        */
 743       if (TYPE_TAG_NAME (type) != NULL &&
 744           strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
 745         {
 746           fputs_filtered (TYPE_TAG_NAME (type), stream);
 747           if (show > 0)
 748             fputs_filtered (" ", stream);
 749         }
 750       wrap_here ("    ");
 751       if (show < 0)
 752         {
 753           /* If we just printed a tag name, no need to print anything else.  */
 754           if (TYPE_TAG_NAME (type) == NULL)
 755             fprintf_filtered (stream, "{...}");
 756         }
 757       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
 758         {
 759           cp_type_print_derivation_info (stream, type);
 760
 761           fprintf_filtered (stream, "{\n");
 762           if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
 763             {
 764               if (TYPE_STUB (type))
 765                 fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
 766               else
 767                 fprintfi_filtered (level + 4, stream, "<no data fields>\n");
 768             }
 769
 770           /* Start off with no specific section type, so we can print
 771              one for the first field we find, and use that section type
 772              thereafter until we find another type. */
 773
 774           section_type = s_none;
 775
 776           /* For a class, if all members are private, there's no need
 777              for a "private:" label; similarly, for a struct or union
 778              masquerading as a class, if all members are public, there's
 779              no need for a "public:" label. */
 780
 781           if ((TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_CLASS) ||
 782               (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_TEMPLATE))
 783             {
 784               QUIT;
 785               len = TYPE_NFIELDS (type);
 786               for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 787                 if (!TYPE_FIELD_PRIVATE (type, i))
 788                   {
 789                     need_access_label = 1;
 790                     break;
 791                   }
 792               QUIT;
 793               if (!need_access_label)
 794                 {
 795                   len2 = TYPE_NFN_FIELDS (type);
 796                   for (j = 0; j < len2; j++)
 797                     {
 798                       len = TYPE_FN_FIELDLIST_LENGTH (type, j);
 799                       for (i = 0; i < len; i++)
 800                         if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i))
 801                           {
 802                             need_access_label = 1;
 803                             break;
 804                           }
 805                       if (need_access_label)
 806                         break;
 807                     }
 808                 }
 809             }
 810           else if ((TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_STRUCT) ||
 811                    (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_UNION))
 812             {
 813               QUIT;
 814               len = TYPE_NFIELDS (type);
 815               for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 816                 if (TYPE_FIELD_PRIVATE (type, i) || TYPE_FIELD_PROTECTED (type, i))
 817                   {
 818                     need_access_label = 1;
 819                     break;
 820                   }
 821               QUIT;
 822               if (!need_access_label)
 823                 {
 824                   len2 = TYPE_NFN_FIELDS (type);
 825                   for (j = 0; j < len2; j++)
 826                     {
 827                       QUIT;
 828                       len = TYPE_FN_FIELDLIST_LENGTH (type, j);
 829                       for (i = 0; i < len; i++)
 830                         if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i) ||
 831                             TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type, j), i))
 832                           {
 833                             need_access_label = 1;
 834                             break;
 835                           }
 836                       if (need_access_label)
 837                         break;
 838                     }
 839                 }
 840             }
 841
 842           /* If there is a base class for this type,
 843              do not print the field that it occupies.  */
 844
 845           len = TYPE_NFIELDS (type);
 846           for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 847             {
 848               QUIT;
 849               /* Don't print out virtual function table.  */
 850               /* HP ANSI C++ case */
 851               if (TYPE_HAS_VTABLE (type) && (STREQN (TYPE_FIELD_NAME (type, i), "__vfp", 5)))
 852                 continue;
 853               /* Other compilers */
 854               if (STREQN (TYPE_FIELD_NAME (type, i), "_vptr", 5)
 855                   && is_cplus_marker ((TYPE_FIELD_NAME (type, i))[5]))
 856                 continue;
 857
 858               /* If this is a C++ class we can print the various C++ section
 859                  labels. */
 860
 861               if (HAVE_CPLUS_STRUCT (type) && need_access_label)
 862                 {
 863                   if (TYPE_FIELD_PROTECTED (type, i))
 864                     {
 865                       if (section_type != s_protected)
 866                         {
 867                           section_type = s_protected;
 868                           fprintfi_filtered (level + 2, stream,
 869                                              "protected:\n");
 870                         }
 871                     }
 872                   else if (TYPE_FIELD_PRIVATE (type, i))
 873                     {
 874                       if (section_type != s_private)
 875                         {
 876                           section_type = s_private;
 877                           fprintfi_filtered (level + 2, stream, "private:\n");
 878                         }
 879                     }
 880                   else
 881                     {
 882                       if (section_type != s_public)
 883                         {
 884                           section_type = s_public;
 885                           fprintfi_filtered (level + 2, stream, "public:\n");
 886                         }
 887                     }
 888                 }
 889
 890               print_spaces_filtered (level + 4, stream);
 891               if (TYPE_FIELD_STATIC (type, i))
 892                 {
 893                   fprintf_filtered (stream, "static ");
 894                 }
 895               c_print_type (TYPE_FIELD_TYPE (type, i),
 896                             TYPE_FIELD_NAME (type, i),
 897                             stream, show - 1, level + 4);
 898               if (!TYPE_FIELD_STATIC (type, i)
 899                   && TYPE_FIELD_PACKED (type, i))
 900                 {
 901                   /* It is a bitfield.  This code does not attempt
 902                      to look at the bitpos and reconstruct filler,
 903                      unnamed fields.  This would lead to misleading
 904                      results if the compiler does not put out fields
 905                      for such things (I don't know what it does).  */
 906                   fprintf_filtered (stream, " : %d",
 907                                     TYPE_FIELD_BITSIZE (type, i));
 908                 }
 909               fprintf_filtered (stream, ";\n");
 910             }
 911
 912           /* If there are both fields and methods, put a blank line
 913               between them.  Make sure to count only method that we will
 914               display; artificial methods will be hidden.  */
 915           len = TYPE_NFN_FIELDS (type);
 916           real_len = 0;
 917           for (i = 0; i < len; i++)
 918             {
 919               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 920               int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 921               int j;
 922               for (j = 0; j < len2; j++)
 923                 if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
 924                   real_len++;
 925             }
 926           if (real_len > 0 && section_type != s_none)
 927             fprintf_filtered (stream, "\n");
 928
 929           /* C++: print out the methods */
 930           for (i = 0; i < len; i++)
 931             {
 932               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 933               int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 934               char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
 935               char *name = type_name_no_tag (type);
 936               int is_constructor = name && STREQ (method_name, name);
 937               for (j = 0; j < len2; j++)
 938                 {
 939                   char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
 940                   int is_full_physname_constructor =
 941                    is_constructor_name (physname)
 942                    || is_destructor_name (physname)
 943                    || method_name[0] == '~';
 944
 945                   /* Do not print out artificial methods.  */
 946                   if (TYPE_FN_FIELD_ARTIFICIAL (f, j))
 947                     continue;
 948
 949                   QUIT;
 950                   if (TYPE_FN_FIELD_PROTECTED (f, j))
 951                     {
 952                       if (section_type != s_protected)
 953                         {
 954                           section_type = s_protected;
 955                           fprintfi_filtered (level + 2, stream,
 956                                              "protected:\n");
 957                         }
 958                     }
 959                   else if (TYPE_FN_FIELD_PRIVATE (f, j))
 960                     {
 961                       if (section_type != s_private)
 962                         {
 963                           section_type = s_private;
 964                           fprintfi_filtered (level + 2, stream, "private:\n");
 965                         }
 966                     }
 967                   else
 968                     {
 969                       if (section_type != s_public)
 970                         {
 971                           section_type = s_public;
 972                           fprintfi_filtered (level + 2, stream, "public:\n");
 973                         }
 974                     }
 975
 976                   print_spaces_filtered (level + 4, stream);
 977                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
 978                     fprintf_filtered (stream, "virtual ");
 979                   else if (TYPE_FN_FIELD_STATIC_P (f, j))
 980                     fprintf_filtered (stream, "static ");
 981                   if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
 982                     {
 983                       /* Keep GDB from crashing here.  */
 984                       fprintf_filtered (stream, "<undefined type> %s;\n",
 985                                         TYPE_FN_FIELD_PHYSNAME (f, j));
 986                       break;
 987                     }
 988                   else if (!is_constructor &&   /* constructors don't have declared types */
 989                            !is_full_physname_constructor &&     /*    " "  */
 990                            !is_type_conversion_operator (type, i, j))
 991                     {
 992                       type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
 993                                   "", stream, -1);
 994                       fputs_filtered (" ", stream);
 995                     }
 996                   if (TYPE_FN_FIELD_STUB (f, j))
 997                     /* Build something we can demangle.  */
 998                     mangled_name = gdb_mangle_name (type, i, j);
 999                   else
1000                     mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
1001
1002                   demangled_name =
1003                     cplus_demangle (mangled_name,
1004                                     DMGL_ANSI | DMGL_PARAMS);
1005                   if (demangled_name == NULL)
1006                     {
1007                       /* in some cases (for instance with the HP demangling),
1008                          if a function has more than 10 arguments,
1009                          the demangling will fail.
1010                          Let's try to reconstruct the function signature from
1011                          the symbol information */
1012                       if (!TYPE_FN_FIELD_STUB (f, j))
1013                         cp_type_print_method_args (TYPE_FN_FIELD_ARGS (f, j), "",
1014                                                    method_name,
1015                                               TYPE_FN_FIELD_STATIC_P (f, j),
1016                                                    stream);
1017                       else
1018                         fprintf_filtered (stream, "<badly mangled name '%s'>",
1019                                           mangled_name);
1020                     }
1021                   else
1022                     {
1023                       char *p;
1024                       char *demangled_no_class
1025                         = remove_qualifiers (demangled_name);
1026
1027                       /* get rid of the `static' appended by the demangler */
1028                       p = strstr (demangled_no_class, " static");
1029                       if (p != NULL)
1030                         {
1031                           int length = p - demangled_no_class;
1032                           demangled_no_static = (char *) xmalloc (length + 1);
1033                           strncpy (demangled_no_static, demangled_no_class, length);
1034                           *(demangled_no_static + length) = '\0';
1035                           fputs_filtered (demangled_no_static, stream);
1036                           xfree (demangled_no_static);
1037                         }
1038                       else
1039                         fputs_filtered (demangled_no_class, stream);
1040                       xfree (demangled_name);
1041                     }
1042
1043                   if (TYPE_FN_FIELD_STUB (f, j))
1044                     xfree (mangled_name);
1045
1046                   fprintf_filtered (stream, ";\n");
1047                 }
1048             }
1049
1050           fprintfi_filtered (level, stream, "}");
1051
1052           if (TYPE_LOCALTYPE_PTR (type) && show >= 0)
1053             fprintfi_filtered (level, stream, " (Local at %s:%d)\n",
1054                                TYPE_LOCALTYPE_FILE (type),
1055                                TYPE_LOCALTYPE_LINE (type));
1056         }
1057       if (TYPE_CODE (type) == TYPE_CODE_TEMPLATE)
1058         goto go_back;
1059       break;
1060
1061     case TYPE_CODE_ENUM:
1062       c_type_print_modifier (type, stream, 0, 1);
1063       /* HP C supports sized enums */
1064       if (hp_som_som_object_present)
1065         switch (TYPE_LENGTH (type))
1066           {
1067           case 1:
1068             fputs_filtered ("char ", stream);
1069             break;
1070           case 2:
1071             fputs_filtered ("short ", stream);
1072             break;
1073           default:
1074             break;
1075           }
1076       fprintf_filtered (stream, "enum ");
1077       /* Print the tag name if it exists.
1078          The aCC compiler emits a spurious
1079          "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1080          tag for unnamed struct/union/enum's, which we don't
1081          want to print. */
1082       if (TYPE_TAG_NAME (type) != NULL &&
1083           strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
1084         {
1085           fputs_filtered (TYPE_TAG_NAME (type), stream);
1086           if (show > 0)
1087             fputs_filtered (" ", stream);
1088         }
1089
1090       wrap_here ("    ");
1091       if (show < 0)
1092         {
1093           /* If we just printed a tag name, no need to print anything else.  */
1094           if (TYPE_TAG_NAME (type) == NULL)
1095             fprintf_filtered (stream, "{...}");
1096         }
1097       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1098         {
1099           fprintf_filtered (stream, "{");
1100           len = TYPE_NFIELDS (type);
1101           lastval = 0;
1102           for (i = 0; i < len; i++)
1103             {
1104               QUIT;
1105               if (i)
1106                 fprintf_filtered (stream, ", ");
1107               wrap_here ("    ");
1108               fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1109               if (lastval != TYPE_FIELD_BITPOS (type, i))
1110                 {
1111                   fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
1112                   lastval = TYPE_FIELD_BITPOS (type, i);
1113                 }
1114               lastval++;
1115             }
1116           fprintf_filtered (stream, "}");
1117         }
1118       break;
1119
1120     case TYPE_CODE_VOID:
1121       fprintf_filtered (stream, "void");
1122       break;
1123
1124     case TYPE_CODE_UNDEF:
1125       fprintf_filtered (stream, "struct <unknown>");
1126       break;
1127
1128     case TYPE_CODE_ERROR:
1129       fprintf_filtered (stream, "<unknown type>");
1130       break;
1131
1132     case TYPE_CODE_RANGE:
1133       /* This should not occur */
1134       fprintf_filtered (stream, "<range type>");
1135       break;
1136
1137     case TYPE_CODE_TEMPLATE:
1138       /* Called on "ptype t" where "t" is a template.
1139          Prints the template header (with args), e.g.:
1140          template <class T1, class T2> class "
1141          and then merges with the struct/union/class code to
1142          print the rest of the definition. */
1143       c_type_print_modifier (type, stream, 0, 1);
1144       fprintf_filtered (stream, "template <");
1145       for (i = 0; i < TYPE_NTEMPLATE_ARGS (type); i++)
1146         {
1147           struct template_arg templ_arg;
1148           templ_arg = TYPE_TEMPLATE_ARG (type, i);
1149           fprintf_filtered (stream, "class %s", templ_arg.name);
1150           if (i < TYPE_NTEMPLATE_ARGS (type) - 1)
1151             fprintf_filtered (stream, ", ");
1152         }
1153       fprintf_filtered (stream, "> class ");
1154       /* Yuck, factor this out to a subroutine so we can call
1155          it and return to the point marked with the "goback:" label... - RT */
1156       goto struct_union;
1157     go_back:
1158       if (TYPE_NINSTANTIATIONS (type) > 0)
1159         {
1160           fprintf_filtered (stream, "\ntemplate instantiations:\n");
1161           for (i = 0; i < TYPE_NINSTANTIATIONS (type); i++)
1162             {
1163               fprintf_filtered (stream, "  ");
1164               c_type_print_base (TYPE_INSTANTIATION (type, i), stream, 0, level);
1165               if (i < TYPE_NINSTANTIATIONS (type) - 1)
1166                 fprintf_filtered (stream, "\n");
1167             }
1168         }
1169       break;
1170
1171     default:
1172       /* Handle types not explicitly handled by the other cases,
1173          such as fundamental types.  For these, just print whatever
1174          the type name is, as recorded in the type itself.  If there
1175          is no type name, then complain. */
1176       if (TYPE_NAME (type) != NULL)
1177         {
1178           c_type_print_modifier (type, stream, 0, 1);
1179           fputs_filtered (TYPE_NAME (type), stream);
1180         }
1181       else
1182         {
1183           /* At least for dump_symtab, it is important that this not be
1184              an error ().  */
1185           fprintf_filtered (stream, "<invalid type code %d>",
1186                             TYPE_CODE (type));
1187         }
1188       break;
1189     }
1190 }