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