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