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   register 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       /* These types need no prefix.  They are listed here so that
 288          gcc -Wall will reveal any types that haven't been handled.  */
 289       break;
 290     default:
 291       error ("type not handled in c_type_print_varspec_prefix()");
 292       break;
 293     }
 294 }
 295
 296 /* Print out "const" and "volatile" attributes.
 297    TYPE is a pointer to the type being printed out.
 298    STREAM is the output destination.
 299    NEED_SPACE = 1 indicates an initial white space is needed */
 300
 301 static void
 302 c_type_print_modifier (struct type *type, struct ui_file *stream,
 303                        int need_pre_space, int need_post_space)
 304 {
 305   int did_print_modifier = 0;
 306   const char *address_space_id;
 307
 308   /* We don't print `const' qualifiers for references --- since all
 309      operators affect the thing referenced, not the reference itself,
 310      every reference is `const'.  */
 311   if (TYPE_CONST (type)
 312       && TYPE_CODE (type) != TYPE_CODE_REF)
 313     {
 314       if (need_pre_space)
 315         fprintf_filtered (stream, " ");
 316       fprintf_filtered (stream, "const");
 317       did_print_modifier = 1;
 318     }
 319
 320   if (TYPE_VOLATILE (type))
 321     {
 322       if (did_print_modifier || need_pre_space)
 323         fprintf_filtered (stream, " ");
 324       fprintf_filtered (stream, "volatile");
 325       did_print_modifier = 1;
 326     }
 327
 328   address_space_id = address_space_int_to_name (TYPE_INSTANCE_FLAGS (type));
 329   if (address_space_id)
 330     {
 331       if (did_print_modifier || need_pre_space)
 332         fprintf_filtered (stream, " ");
 333       fprintf_filtered (stream, "@%s", address_space_id);
 334       did_print_modifier = 1;
 335     }
 336
 337   if (did_print_modifier && need_post_space)
 338     fprintf_filtered (stream, " ");
 339 }
 340
 341
 342
 343
 344 static void
 345 c_type_print_args (struct type *type, struct ui_file *stream)
 346 {
 347   int i;
 348   struct field *args;
 349
 350   fprintf_filtered (stream, "(");
 351   args = TYPE_FIELDS (type);
 352   if (args != NULL)
 353     {
 354       int i;
 355
 356       /* FIXME drow/2002-05-31: Always skips the first argument,
 357          should we be checking for static members?  */
 358
 359       for (i = 1; i < TYPE_NFIELDS (type); i++)
 360         {
 361           c_print_type (args[i].type, "", stream, -1, 0);
 362           if (i != TYPE_NFIELDS (type))
 363             {
 364               fprintf_filtered (stream, ",");
 365               wrap_here ("    ");
 366             }
 367         }
 368       if (TYPE_VARARGS (type))
 369         fprintf_filtered (stream, "...");
 370       else if (i == 1
 371                && (current_language->la_language == language_cplus))
 372         fprintf_filtered (stream, "void");
 373     }
 374   else if (current_language->la_language == language_cplus)
 375     {
 376       fprintf_filtered (stream, "void");
 377     }
 378
 379   fprintf_filtered (stream, ")");
 380 }
 381
 382
 383 /* Return true iff the j'th overloading of the i'th method of TYPE
 384    is a type conversion operator, like `operator int () { ... }'.
 385    When listing a class's methods, we don't print the return type of
 386    such operators.  */
 387 static int
 388 is_type_conversion_operator (struct type *type, int i, int j)
 389 {
 390   /* I think the whole idea of recognizing type conversion operators
 391      by their name is pretty terrible.  But I don't think our present
 392      data structure gives us any other way to tell.  If you know of
 393      some other way, feel free to rewrite this function.  */
 394   char *name = TYPE_FN_FIELDLIST_NAME (type, i);
 395
 396   if (strncmp (name, "operator", 8) != 0)
 397     return 0;
 398
 399   name += 8;
 400   if (! strchr (" \t\f\n\r", *name))
 401     return 0;
 402
 403   while (strchr (" \t\f\n\r", *name))
 404     name++;
 405
 406   if (!('a' <= *name && *name <= 'z')
 407       && !('A' <= *name && *name <= 'Z')
 408       && *name != '_')
 409     /* If this doesn't look like the start of an identifier, then it
 410        isn't a type conversion operator.  */
 411     return 0;
 412   else if (strncmp (name, "new", 3) == 0)
 413     name += 3;
 414   else if (strncmp (name, "delete", 6) == 0)
 415     name += 6;
 416   else
 417     /* If it doesn't look like new or delete, it's a type conversion
 418        operator.  */
 419     return 1;
 420
 421   /* Is that really the end of the name?  */
 422   if (('a' <= *name && *name <= 'z')
 423       || ('A' <= *name && *name <= 'Z')
 424       || ('0' <= *name && *name <= '9')
 425       || *name == '_')
 426     /* No, so the identifier following "operator" must be a type name,
 427        and this is a type conversion operator.  */
 428     return 1;
 429
 430   /* That was indeed the end of the name, so it was `operator new' or
 431      `operator delete', neither of which are type conversion operators.  */
 432   return 0;
 433 }
 434
 435
 436 /* Given a C++ qualified identifier QID, strip off the qualifiers,
 437    yielding the unqualified name.  The return value is a pointer into
 438    the original string.
 439
 440    It's a pity we don't have this information in some more structured
 441    form.  Even the author of this function feels that writing little
 442    parsers like this everywhere is stupid.  */
 443 static char *
 444 remove_qualifiers (char *qid)
 445 {
 446   int quoted = 0;               /* zero if we're not in quotes;
 447                                    '"' if we're in a double-quoted string;
 448                                    '\'' if we're in a single-quoted string.  */
 449   int depth = 0;                /* number of unclosed parens we've seen */
 450   char *parenstack = (char *) alloca (strlen (qid));
 451   char *scan;
 452   char *last = 0;               /* The character after the rightmost
 453                                    `::' token we've seen so far.  */
 454
 455   for (scan = qid; *scan; scan++)
 456     {
 457       if (quoted)
 458         {
 459           if (*scan == quoted)
 460             quoted = 0;
 461           else if (*scan == '\\' && *(scan + 1))
 462             scan++;
 463         }
 464       else if (scan[0] == ':' && scan[1] == ':')
 465         {
 466           /* If we're inside parenthesis (i.e., an argument list) or
 467              angle brackets (i.e., a list of template arguments), then
 468              we don't record the position of this :: token, since it's
 469              not relevant to the top-level structure we're trying
 470              to operate on.  */
 471           if (depth == 0)
 472             {
 473               last = scan + 2;
 474               scan++;
 475             }
 476         }
 477       else if (*scan == '"' || *scan == '\'')
 478         quoted = *scan;
 479       else if (*scan == '(')
 480         parenstack[depth++] = ')';
 481       else if (*scan == '[')
 482         parenstack[depth++] = ']';
 483       /* We're going to treat <> as a pair of matching characters,
 484          since we're more likely to see those in template id's than
 485          real less-than characters.  What a crock.  */
 486       else if (*scan == '<')
 487         parenstack[depth++] = '>';
 488       else if (*scan == ')' || *scan == ']' || *scan == '>')
 489         {
 490           if (depth > 0 && parenstack[depth - 1] == *scan)
 491             depth--;
 492           else
 493             {
 494               /* We're going to do a little error recovery here.  If we
 495                  don't find a match for *scan on the paren stack, but
 496                  there is something lower on the stack that does match, we
 497                  pop the stack to that point.  */
 498               int i;
 499
 500               for (i = depth - 1; i >= 0; i--)
 501                 if (parenstack[i] == *scan)
 502                   {
 503                     depth = i;
 504                     break;
 505                   }
 506             }
 507         }
 508     }
 509
 510   if (last)
 511     return last;
 512   else
 513     /* We didn't find any :: tokens at the top level, so declare the
 514        whole thing an unqualified identifier.  */
 515     return qid;
 516 }
 517
 518
 519 /* Print any array sizes, function arguments or close parentheses
 520    needed after the variable name (to describe its type).
 521    Args work like c_type_print_varspec_prefix.  */
 522
 523 void
 524 c_type_print_varspec_suffix (struct type *type, struct ui_file *stream,
 525                              int show, int passed_a_ptr, int demangled_args)
 526 {
 527   if (type == 0)
 528     return;
 529
 530   if (TYPE_NAME (type) && show <= 0)
 531     return;
 532
 533   QUIT;
 534
 535   switch (TYPE_CODE (type))
 536     {
 537     case TYPE_CODE_ARRAY:
 538       if (passed_a_ptr)
 539         fprintf_filtered (stream, ")");
 540
 541       fprintf_filtered (stream, "[");
 542       if (TYPE_LENGTH (type) >= 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
 543         && TYPE_ARRAY_UPPER_BOUND_TYPE (type) != BOUND_CANNOT_BE_DETERMINED)
 544         fprintf_filtered (stream, "%d",
 545                           (TYPE_LENGTH (type)
 546                            / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
 547       fprintf_filtered (stream, "]");
 548
 549       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 550                                    0, 0);
 551       break;
 552
 553     case TYPE_CODE_MEMBER:
 554       if (passed_a_ptr)
 555         fprintf_filtered (stream, ")");
 556       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 557                                    0, 0);
 558       break;
 559
 560     case TYPE_CODE_METHOD:
 561       if (passed_a_ptr)
 562         fprintf_filtered (stream, ")");
 563       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 564                                    0, 0);
 565       if (passed_a_ptr)
 566         {
 567           c_type_print_args (type, stream);
 568         }
 569       break;
 570
 571     case TYPE_CODE_PTR:
 572     case TYPE_CODE_REF:
 573       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 574                                    1, 0);
 575       break;
 576
 577     case TYPE_CODE_FUNC:
 578       if (passed_a_ptr)
 579         fprintf_filtered (stream, ")");
 580       if (!demangled_args)
 581         {
 582           int i, len = TYPE_NFIELDS (type);
 583           fprintf_filtered (stream, "(");
 584           if (len == 0
 585               && (TYPE_PROTOTYPED (type)
 586                   || current_language->la_language == language_cplus))
 587             {
 588               fprintf_filtered (stream, "void");
 589             }
 590           else
 591             for (i = 0; i < len; i++)
 592               {
 593                 if (i > 0)
 594                   {
 595                     fputs_filtered (", ", stream);
 596                     wrap_here ("    ");
 597                   }
 598                 c_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
 599               }
 600           fprintf_filtered (stream, ")");
 601         }
 602       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 603                                    passed_a_ptr, 0);
 604       break;
 605
 606     case TYPE_CODE_TYPEDEF:
 607       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 608                                    passed_a_ptr, 0);
 609       break;
 610
 611     case TYPE_CODE_UNDEF:
 612     case TYPE_CODE_STRUCT:
 613     case TYPE_CODE_UNION:
 614     case TYPE_CODE_ENUM:
 615     case TYPE_CODE_INT:
 616     case TYPE_CODE_FLT:
 617     case TYPE_CODE_VOID:
 618     case TYPE_CODE_ERROR:
 619     case TYPE_CODE_CHAR:
 620     case TYPE_CODE_BOOL:
 621     case TYPE_CODE_SET:
 622     case TYPE_CODE_RANGE:
 623     case TYPE_CODE_STRING:
 624     case TYPE_CODE_BITSTRING:
 625     case TYPE_CODE_COMPLEX:
 626     case TYPE_CODE_TEMPLATE:
 627       /* These types do not need a suffix.  They are listed so that
 628          gcc -Wall will report types that may not have been considered.  */
 629       break;
 630     default:
 631       error ("type not handled in c_type_print_varspec_suffix()");
 632       break;
 633     }
 634 }
 635
 636 /* Print the name of the type (or the ultimate pointer target,
 637    function value or array element), or the description of a
 638    structure or union.
 639
 640    SHOW positive means print details about the type (e.g. enum values),
 641    and print structure elements passing SHOW - 1 for show.
 642    SHOW negative means just print the type name or struct tag if there is one.
 643    If there is no name, print something sensible but concise like
 644    "struct {...}".
 645    SHOW zero means just print the type name or struct tag if there is one.
 646    If there is no name, print something sensible but not as concise like
 647    "struct {int x; int y;}".
 648
 649    LEVEL is the number of spaces to indent by.
 650    We increase it for some recursive calls.  */
 651
 652 void
 653 c_type_print_base (struct type *type, struct ui_file *stream, int show,
 654                    int level)
 655 {
 656   int i;
 657   int len, real_len;
 658   int lastval;
 659   char *mangled_name;
 660   char *demangled_name;
 661   char *demangled_no_static;
 662   enum
 663     {
 664       s_none, s_public, s_private, s_protected
 665     }
 666   section_type;
 667   int need_access_label = 0;
 668   int j, len2;
 669
 670   QUIT;
 671
 672   wrap_here ("    ");
 673   if (type == NULL)
 674     {
 675       fputs_filtered ("<type unknown>", stream);
 676       return;
 677     }
 678
 679   /* When SHOW is zero or less, and there is a valid type name, then always
 680      just print the type name directly from the type.  */
 681   /* If we have "typedef struct foo {. . .} bar;" do we want to print it
 682      as "struct foo" or as "bar"?  Pick the latter, because C++ folk tend
 683      to expect things like "class5 *foo" rather than "struct class5 *foo".  */
 684
 685   if (show <= 0
 686       && TYPE_NAME (type) != NULL)
 687     {
 688       c_type_print_modifier (type, stream, 0, 1);
 689       fputs_filtered (TYPE_NAME (type), stream);
 690       return;
 691     }
 692
 693   CHECK_TYPEDEF (type);
 694
 695   switch (TYPE_CODE (type))
 696     {
 697     case TYPE_CODE_TYPEDEF:
 698     case TYPE_CODE_ARRAY:
 699     case TYPE_CODE_PTR:
 700     case TYPE_CODE_MEMBER:
 701     case TYPE_CODE_REF:
 702     case TYPE_CODE_FUNC:
 703     case TYPE_CODE_METHOD:
 704       c_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
 705       break;
 706
 707     case TYPE_CODE_STRUCT:
 708       c_type_print_modifier (type, stream, 0, 1);
 709       /* Note TYPE_CODE_STRUCT and TYPE_CODE_CLASS have the same value,
 710        * so we use another means for distinguishing them.
 711        */
 712       if (HAVE_CPLUS_STRUCT (type))
 713         {
 714           switch (TYPE_DECLARED_TYPE (type))
 715             {
 716             case DECLARED_TYPE_CLASS:
 717               fprintf_filtered (stream, "class ");
 718               break;
 719             case DECLARED_TYPE_UNION:
 720               fprintf_filtered (stream, "union ");
 721               break;
 722             case DECLARED_TYPE_STRUCT:
 723               fprintf_filtered (stream, "struct ");
 724               break;
 725             default:
 726               /* If there is a CPLUS_STRUCT, assume class if not
 727                * otherwise specified in the declared_type field.
 728                */
 729               fprintf_filtered (stream, "class ");
 730               break;
 731             }                   /* switch */
 732         }
 733       else
 734         {
 735           /* If not CPLUS_STRUCT, then assume it's a C struct */
 736           fprintf_filtered (stream, "struct ");
 737         }
 738       goto struct_union;
 739
 740     case TYPE_CODE_UNION:
 741       c_type_print_modifier (type, stream, 0, 1);
 742       fprintf_filtered (stream, "union ");
 743
 744     struct_union:
 745
 746       /* Print the tag if it exists.
 747        * The HP aCC compiler emits
 748        * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
 749        * tag  for unnamed struct/union/enum's, which we don't
 750        * want to print.
 751        */
 752       if (TYPE_TAG_NAME (type) != NULL &&
 753           strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
 754         {
 755           fputs_filtered (TYPE_TAG_NAME (type), stream);
 756           if (show > 0)
 757             fputs_filtered (" ", stream);
 758         }
 759       wrap_here ("    ");
 760       if (show < 0)
 761         {
 762           /* If we just printed a tag name, no need to print anything else.  */
 763           if (TYPE_TAG_NAME (type) == NULL)
 764             fprintf_filtered (stream, "{...}");
 765         }
 766       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
 767         {
 768           cp_type_print_derivation_info (stream, type);
 769
 770           fprintf_filtered (stream, "{\n");
 771           if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
 772             {
 773               if (TYPE_STUB (type))
 774                 fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
 775               else
 776                 fprintfi_filtered (level + 4, stream, "<no data fields>\n");
 777             }
 778
 779           /* Start off with no specific section type, so we can print
 780              one for the first field we find, and use that section type
 781              thereafter until we find another type. */
 782
 783           section_type = s_none;
 784
 785           /* For a class, if all members are private, there's no need
 786              for a "private:" label; similarly, for a struct or union
 787              masquerading as a class, if all members are public, there's
 788              no need for a "public:" label. */
 789
 790           if ((TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_CLASS) ||
 791               (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_TEMPLATE))
 792             {
 793               QUIT;
 794               len = TYPE_NFIELDS (type);
 795               for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 796                 if (!TYPE_FIELD_PRIVATE (type, i))
 797                   {
 798                     need_access_label = 1;
 799                     break;
 800                   }
 801               QUIT;
 802               if (!need_access_label)
 803                 {
 804                   len2 = TYPE_NFN_FIELDS (type);
 805                   for (j = 0; j < len2; j++)
 806                     {
 807                       len = TYPE_FN_FIELDLIST_LENGTH (type, j);
 808                       for (i = 0; i < len; i++)
 809                         if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i))
 810                           {
 811                             need_access_label = 1;
 812                             break;
 813                           }
 814                       if (need_access_label)
 815                         break;
 816                     }
 817                 }
 818             }
 819           else if ((TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_STRUCT) ||
 820                    (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_UNION))
 821             {
 822               QUIT;
 823               len = TYPE_NFIELDS (type);
 824               for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 825                 if (TYPE_FIELD_PRIVATE (type, i) || TYPE_FIELD_PROTECTED (type, i))
 826                   {
 827                     need_access_label = 1;
 828                     break;
 829                   }
 830               QUIT;
 831               if (!need_access_label)
 832                 {
 833                   len2 = TYPE_NFN_FIELDS (type);
 834                   for (j = 0; j < len2; j++)
 835                     {
 836                       QUIT;
 837                       len = TYPE_FN_FIELDLIST_LENGTH (type, j);
 838                       for (i = 0; i < len; i++)
 839                         if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i) ||
 840                             TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type, j), i))
 841                           {
 842                             need_access_label = 1;
 843                             break;
 844                           }
 845                       if (need_access_label)
 846                         break;
 847                     }
 848                 }
 849             }
 850
 851           /* If there is a base class for this type,
 852              do not print the field that it occupies.  */
 853
 854           len = TYPE_NFIELDS (type);
 855           for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 856             {
 857               QUIT;
 858               /* Don't print out virtual function table.  */
 859               /* HP ANSI C++ case */
 860               if (TYPE_HAS_VTABLE (type) && (STREQN (TYPE_FIELD_NAME (type, i), "__vfp", 5)))
 861                 continue;
 862               /* Other compilers */
 863               if (STREQN (TYPE_FIELD_NAME (type, i), "_vptr", 5)
 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 && STREQ (method_name, name);
 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 (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     default:
1186       /* Handle types not explicitly handled by the other cases,
1187          such as fundamental types.  For these, just print whatever
1188          the type name is, as recorded in the type itself.  If there
1189          is no type name, then complain. */
1190       if (TYPE_NAME (type) != NULL)
1191         {
1192           c_type_print_modifier (type, stream, 0, 1);
1193           fputs_filtered (TYPE_NAME (type), stream);
1194         }
1195       else
1196         {
1197           /* At least for dump_symtab, it is important that this not be
1198              an error ().  */
1199           fprintf_filtered (stream, "<invalid type code %d>",
1200                             TYPE_CODE (type));
1201         }
1202       break;
1203     }
1204 }