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