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