gdb/c-typeprint.c

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