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