gdb/c-typeprint.c

   1 /* Support for printing C and C++ types for GDB, the GNU debugger.
   2    Copyright 1986, 1988, 1989, 1991, 1993, 1994
   3    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., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 #include "defs.h"
  22 #include "obstack.h"
  23 #include "bfd.h"                /* Binary File Description */
  24 #include "symtab.h"
  25 #include "gdbtypes.h"
  26 #include "expression.h"
  27 #include "value.h"
  28 #include "gdbcore.h"
  29 #include "target.h"
  30 #include "command.h"
  31 #include "gdbcmd.h"
  32 #include "language.h"
  33 #include "demangle.h"
  34 #include "c-lang.h"
  35 #include "typeprint.h"
  36
  37 #include <string.h>
  38 #include <errno.h>
  39 #include <ctype.h>
  40
  41 static void
  42 c_type_print_args PARAMS ((struct type *, GDB_FILE *));
  43
  44 static void
  45 c_type_print_varspec_suffix PARAMS ((struct type *, GDB_FILE *, int, int, int));
  46
  47 static void
  48 cp_type_print_derivation_info PARAMS ((GDB_FILE *, struct type *));
  49
  50 void
  51 c_type_print_varspec_prefix PARAMS ((struct type *, GDB_FILE *, int, int));
  52
  53 void
  54 c_type_print_base PARAMS ((struct type *, GDB_FILE *, int, int));
  55
  56 \f
  57 /* Print a description of a type in the format of a
  58    typedef for the current language.
  59    NEW is the new name for a type TYPE. */
  60
  61 void
  62 c_typedef_print (type, new, stream)
  63    struct type *type;
  64    struct symbol *new;
  65    GDB_FILE *stream;
  66 {
  67    switch (current_language->la_language)
  68    {
  69 #ifdef _LANG_c
  70    case language_c:
  71    case language_cplus:
  72       fprintf_filtered(stream, "typedef ");
  73       type_print(type,"",stream,0);
  74       if(TYPE_NAME ((SYMBOL_TYPE (new))) == 0
  75          || !STREQ (TYPE_NAME ((SYMBOL_TYPE (new))), SYMBOL_NAME (new)))
  76         fprintf_filtered(stream,  " %s", SYMBOL_SOURCE_NAME(new));
  77       break;
  78 #endif
  79 #ifdef _LANG_m2
  80    case language_m2:
  81       fprintf_filtered(stream, "TYPE ");
  82       if(!TYPE_NAME(SYMBOL_TYPE(new)) ||
  83          !STREQ (TYPE_NAME(SYMBOL_TYPE(new)), SYMBOL_NAME(new)))
  84         fprintf_filtered(stream, "%s = ", SYMBOL_SOURCE_NAME(new));
  85       else
  86          fprintf_filtered(stream, "<builtin> = ");
  87       type_print(type,"",stream,0);
  88       break;
  89 #endif
  90 #ifdef _LANG_chill
  91    case language_chill:
  92       fprintf_filtered(stream, "SYNMODE ");
  93       if(!TYPE_NAME(SYMBOL_TYPE(new)) ||
  94          !STREQ (TYPE_NAME(SYMBOL_TYPE(new)), SYMBOL_NAME(new)))
  95         fprintf_filtered(stream, "%s = ", SYMBOL_SOURCE_NAME(new));
  96       else
  97          fprintf_filtered(stream, "<builtin> = ");
  98       type_print(type,"",stream,0);
  99       break;
 100 #endif
 101    default:
 102       error("Language not supported.");
 103    }
 104    fprintf_filtered(stream, ";\n");
 105 }
 106
 107
 108 /* LEVEL is the depth to indent lines by.  */
 109
 110 void
 111 c_print_type (type, varstring, stream, show, level)
 112      struct type *type;
 113      char *varstring;
 114      GDB_FILE *stream;
 115      int show;
 116      int level;
 117 {
 118   register enum type_code code;
 119   int demangled_args;
 120
 121   c_type_print_base (type, stream, show, level);
 122   code = TYPE_CODE (type);
 123   if ((varstring != NULL && *varstring != '\0')
 124       ||
 125       /* Need a space if going to print stars or brackets;
 126          but not if we will print just a type name.  */
 127       ((show > 0 || TYPE_NAME (type) == 0)
 128        &&
 129        (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
 130         || code == TYPE_CODE_METHOD
 131         || code == TYPE_CODE_ARRAY
 132         || code == TYPE_CODE_MEMBER
 133         || code == TYPE_CODE_REF)))
 134     fputs_filtered (" ", stream);
 135   c_type_print_varspec_prefix (type, stream, show, 0);
 136
 137   fputs_filtered (varstring, stream);
 138
 139   /* For demangled function names, we have the arglist as part of the name,
 140      so don't print an additional pair of ()'s */
 141
 142   demangled_args = strchr(varstring, '(') != NULL;
 143   c_type_print_varspec_suffix (type, stream, show, 0, demangled_args);
 144
 145 }
 146
 147 /* Print the C++ method arguments ARGS to the file STREAM.  */
 148
 149 void
 150 cp_type_print_method_args (args, prefix, varstring, staticp, stream)
 151      struct type **args;
 152      char *prefix;
 153      char *varstring;
 154      int staticp;
 155      GDB_FILE *stream;
 156 {
 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   if (args && args[!staticp] && args[!staticp]->code != TYPE_CODE_VOID)
 163     {
 164       i = !staticp;             /* skip the class variable */
 165       while (1)
 166         {
 167           type_print (args[i++], "", stream, 0);
 168           if (!args[i])
 169             {
 170               fprintf_filtered (stream, " ...");
 171               break;
 172             }
 173           else if (args[i]->code != TYPE_CODE_VOID)
 174             {
 175               fprintf_filtered (stream, ", ");
 176             }
 177           else break;
 178         }
 179     }
 180   fprintf_filtered (stream, ")");
 181 }
 182
 183 /* If TYPE is a derived type, then print out derivation information.
 184    Print only the actual base classes of this type, not the base classes
 185    of the base classes.  I.E.  for the derivation hierarchy:
 186
 187         class A { int a; };
 188         class B : public A {int b; };
 189         class C : public B {int c; };
 190
 191    Print the type of class C as:
 192
 193         class C : public B {
 194                 int c;
 195         }
 196
 197    Not as the following (like gdb used to), which is not legal C++ syntax for
 198    derived types and may be confused with the multiple inheritance form:
 199
 200         class C : public B : public A {
 201                 int c;
 202         }
 203
 204    In general, gdb should try to print the types as closely as possible to
 205    the form that they appear in the source code. */
 206
 207 static void
 208 cp_type_print_derivation_info (stream, type)
 209      GDB_FILE *stream;
 210      struct type *type;
 211 {
 212   char *name;
 213   int i;
 214
 215   for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
 216     {
 217       fputs_filtered (i == 0 ? ": " : ", ", stream);
 218       fprintf_filtered (stream, "%s%s ",
 219                         BASETYPE_VIA_PUBLIC (type, i) ? "public" : "private",
 220                         BASETYPE_VIA_VIRTUAL(type, i) ? " virtual" : "");
 221       name = type_name_no_tag (TYPE_BASECLASS (type, i));
 222       fprintf_filtered (stream, "%s", name ? name : "(null)");
 223     }
 224   if (i > 0)
 225     {
 226       fputs_filtered (" ", stream);
 227     }
 228 }
 229
 230 /* Print any asterisks or open-parentheses needed before the
 231    variable name (to describe its type).
 232
 233    On outermost call, pass 0 for PASSED_A_PTR.
 234    On outermost call, SHOW > 0 means should ignore
 235    any typename for TYPE and show its details.
 236    SHOW is always zero on recursive calls.  */
 237
 238 void
 239 c_type_print_varspec_prefix (type, stream, show, passed_a_ptr)
 240      struct type *type;
 241      GDB_FILE *stream;
 242      int show;
 243      int passed_a_ptr;
 244 {
 245   char *name;
 246   if (type == 0)
 247     return;
 248
 249   if (TYPE_NAME (type) && show <= 0)
 250     return;
 251
 252   QUIT;
 253
 254   switch (TYPE_CODE (type))
 255     {
 256     case TYPE_CODE_PTR:
 257       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1);
 258       fprintf_filtered (stream, "*");
 259       break;
 260
 261     case TYPE_CODE_MEMBER:
 262       if (passed_a_ptr)
 263         fprintf_filtered (stream, "(");
 264       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
 265       fprintf_filtered (stream, " ");
 266       name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
 267       if (name)
 268         fputs_filtered (name, stream);
 269       else
 270         c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
 271       fprintf_filtered (stream, "::");
 272       break;
 273
 274     case TYPE_CODE_METHOD:
 275       if (passed_a_ptr)
 276         fprintf_unfiltered (stream, "(");
 277       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
 278       if (passed_a_ptr)
 279         {
 280           fprintf_filtered (stream, " ");
 281           c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
 282           fprintf_filtered (stream, "::");
 283         }
 284       break;
 285
 286     case TYPE_CODE_REF:
 287       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1);
 288       fprintf_filtered (stream, "&");
 289       break;
 290
 291     case TYPE_CODE_FUNC:
 292       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
 293       if (passed_a_ptr)
 294         fprintf_filtered (stream, "(");
 295       break;
 296
 297     case TYPE_CODE_ARRAY:
 298       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
 299       if (passed_a_ptr)
 300         fprintf_filtered (stream, "(");
 301       break;
 302
 303     case TYPE_CODE_UNDEF:
 304     case TYPE_CODE_STRUCT:
 305     case TYPE_CODE_UNION:
 306     case TYPE_CODE_ENUM:
 307     case TYPE_CODE_INT:
 308     case TYPE_CODE_FLT:
 309     case TYPE_CODE_VOID:
 310     case TYPE_CODE_ERROR:
 311     case TYPE_CODE_CHAR:
 312     case TYPE_CODE_BOOL:
 313     case TYPE_CODE_SET:
 314     case TYPE_CODE_RANGE:
 315     case TYPE_CODE_STRING:
 316     case TYPE_CODE_BITSTRING:
 317     case TYPE_CODE_COMPLEX:
 318       /* These types need no prefix.  They are listed here so that
 319          gcc -Wall will reveal any types that haven't been handled.  */
 320       break;
 321     }
 322 }
 323
 324 static void
 325 c_type_print_args (type, stream)
 326      struct type *type;
 327      GDB_FILE *stream;
 328 {
 329   int i;
 330   struct type **args;
 331
 332   fprintf_filtered (stream, "(");
 333   args = TYPE_ARG_TYPES (type);
 334   if (args != NULL)
 335     {
 336       if (args[1] == NULL)
 337         {
 338           fprintf_filtered (stream, "...");
 339         }
 340       else
 341         {
 342           for (i = 1;
 343                args[i] != NULL && args[i]->code != TYPE_CODE_VOID;
 344                i++)
 345             {
 346               c_print_type (args[i], "", stream, -1, 0);
 347               if (args[i+1] == NULL)
 348                 {
 349                   fprintf_filtered (stream, "...");
 350                 }
 351               else if (args[i+1]->code != TYPE_CODE_VOID)
 352                 {
 353                   fprintf_filtered (stream, ",");
 354                   wrap_here ("    ");
 355                 }
 356             }
 357         }
 358     }
 359   fprintf_filtered (stream, ")");
 360 }
 361
 362 /* Print any array sizes, function arguments or close parentheses
 363    needed after the variable name (to describe its type).
 364    Args work like c_type_print_varspec_prefix.  */
 365
 366 static void
 367 c_type_print_varspec_suffix (type, stream, show, passed_a_ptr, demangled_args)
 368      struct type *type;
 369      GDB_FILE *stream;
 370      int show;
 371      int passed_a_ptr;
 372      int demangled_args;
 373 {
 374   if (type == 0)
 375     return;
 376
 377   if (TYPE_NAME (type) && show <= 0)
 378     return;
 379
 380   QUIT;
 381
 382   switch (TYPE_CODE (type))
 383     {
 384     case TYPE_CODE_ARRAY:
 385       if (passed_a_ptr)
 386         fprintf_filtered (stream, ")");
 387
 388       fprintf_filtered (stream, "[");
 389       if (TYPE_LENGTH (type) >= 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
 390           && TYPE_ARRAY_UPPER_BOUND_TYPE(type) != BOUND_CANNOT_BE_DETERMINED)
 391         fprintf_filtered (stream, "%d",
 392                           (TYPE_LENGTH (type)
 393                            / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
 394       fprintf_filtered (stream, "]");
 395
 396       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
 397       break;
 398
 399     case TYPE_CODE_MEMBER:
 400       if (passed_a_ptr)
 401         fprintf_filtered (stream, ")");
 402       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
 403       break;
 404
 405     case TYPE_CODE_METHOD:
 406       if (passed_a_ptr)
 407         fprintf_filtered (stream, ")");
 408       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
 409       if (passed_a_ptr)
 410         {
 411           c_type_print_args (type, stream);
 412         }
 413       break;
 414
 415     case TYPE_CODE_PTR:
 416     case TYPE_CODE_REF:
 417       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 1, 0);
 418       break;
 419
 420     case TYPE_CODE_FUNC:
 421       if (passed_a_ptr)
 422         fprintf_filtered (stream, ")");
 423       if (!demangled_args)
 424         { int i, len = TYPE_NFIELDS (type);
 425           fprintf_filtered (stream, "(");
 426           for (i = 0; i < len; i++)
 427             {
 428               if (i > 0)
 429                 {
 430                   fputs_filtered (", ", stream);
 431                   wrap_here ("    ");
 432                 }
 433               c_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
 434             }
 435           fprintf_filtered (stream, ")");
 436         }
 437       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
 438                                    passed_a_ptr, 0);
 439       break;
 440
 441     case TYPE_CODE_UNDEF:
 442     case TYPE_CODE_STRUCT:
 443     case TYPE_CODE_UNION:
 444     case TYPE_CODE_ENUM:
 445     case TYPE_CODE_INT:
 446     case TYPE_CODE_FLT:
 447     case TYPE_CODE_VOID:
 448     case TYPE_CODE_ERROR:
 449     case TYPE_CODE_CHAR:
 450     case TYPE_CODE_BOOL:
 451     case TYPE_CODE_SET:
 452     case TYPE_CODE_RANGE:
 453     case TYPE_CODE_STRING:
 454     case TYPE_CODE_BITSTRING:
 455     case TYPE_CODE_COMPLEX:
 456       /* These types do not need a suffix.  They are listed so that
 457          gcc -Wall will report types that may not have been considered.  */
 458       break;
 459     }
 460 }
 461
 462 /* Print the name of the type (or the ultimate pointer target,
 463    function value or array element), or the description of a
 464    structure or union.
 465
 466    SHOW positive means print details about the type (e.g. enum values),
 467    and print structure elements passing SHOW - 1 for show.
 468    SHOW negative means just print the type name or struct tag if there is one.
 469    If there is no name, print something sensible but concise like
 470    "struct {...}".
 471    SHOW zero means just print the type name or struct tag if there is one.
 472    If there is no name, print something sensible but not as concise like
 473    "struct {int x; int y;}".
 474
 475    LEVEL is the number of spaces to indent by.
 476    We increase it for some recursive calls.  */
 477
 478 void
 479 c_type_print_base (type, stream, show, level)
 480      struct type *type;
 481      GDB_FILE *stream;
 482      int show;
 483      int level;
 484 {
 485   register int i;
 486   register int len;
 487   register int lastval;
 488   char *mangled_name;
 489   char *demangled_name;
 490   enum {s_none, s_public, s_private, s_protected} section_type;
 491   QUIT;
 492
 493   wrap_here ("    ");
 494   if (type == NULL)
 495     {
 496       fputs_filtered ("<type unknown>", stream);
 497       return;
 498     }
 499
 500   /* When SHOW is zero or less, and there is a valid type name, then always
 501      just print the type name directly from the type.  */
 502   /* If we have "typedef struct foo {. . .} bar;" do we want to print it
 503      as "struct foo" or as "bar"?  Pick the latter, because C++ folk tend
 504      to expect things like "class5 *foo" rather than "struct class5 *foo".  */
 505
 506   if (show <= 0
 507       && TYPE_NAME (type) != NULL)
 508     {
 509       fputs_filtered (TYPE_NAME (type), stream);
 510       return;
 511     }
 512
 513   check_stub_type (type);
 514
 515   switch (TYPE_CODE (type))
 516     {
 517     case TYPE_CODE_ARRAY:
 518     case TYPE_CODE_PTR:
 519     case TYPE_CODE_MEMBER:
 520     case TYPE_CODE_REF:
 521     case TYPE_CODE_FUNC:
 522     case TYPE_CODE_METHOD:
 523       c_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
 524       break;
 525
 526     case TYPE_CODE_STRUCT:
 527       if (HAVE_CPLUS_STRUCT (type))
 528         {
 529           fprintf_filtered (stream, "class ");
 530         }
 531       else
 532         {
 533           fprintf_filtered (stream, "struct ");
 534         }
 535       goto struct_union;
 536
 537     case TYPE_CODE_UNION:
 538       fprintf_filtered (stream, "union ");
 539
 540     struct_union:
 541       if (TYPE_TAG_NAME (type) != NULL)
 542         {
 543           fputs_filtered (TYPE_TAG_NAME (type), stream);
 544           if (show > 0)
 545             fputs_filtered (" ", stream);
 546         }
 547       wrap_here ("    ");
 548       if (show < 0)
 549         {
 550           /* If we just printed a tag name, no need to print anything else.  */
 551           if (TYPE_TAG_NAME (type) == NULL)
 552             fprintf_filtered (stream, "{...}");
 553         }
 554       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
 555         {
 556           cp_type_print_derivation_info (stream, type);
 557
 558           fprintf_filtered (stream, "{\n");
 559           if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
 560             {
 561               if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
 562                 fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
 563               else
 564                 fprintfi_filtered (level + 4, stream, "<no data fields>\n");
 565             }
 566
 567           /* Start off with no specific section type, so we can print
 568              one for the first field we find, and use that section type
 569              thereafter until we find another type. */
 570
 571           section_type = s_none;
 572
 573           /* If there is a base class for this type,
 574              do not print the field that it occupies.  */
 575
 576           len = TYPE_NFIELDS (type);
 577           for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 578             {
 579               QUIT;
 580               /* Don't print out virtual function table.  */
 581               if ((TYPE_FIELD_NAME (type, i))[5] == CPLUS_MARKER &&
 582                   !strncmp (TYPE_FIELD_NAME (type, i), "_vptr", 5))
 583                 continue;
 584
 585               /* If this is a C++ class we can print the various C++ section
 586                  labels. */
 587
 588               if (HAVE_CPLUS_STRUCT (type))
 589                 {
 590                   if (TYPE_FIELD_PROTECTED (type, i))
 591                     {
 592                       if (section_type != s_protected)
 593                         {
 594                           section_type = s_protected;
 595                           fprintfi_filtered (level + 2, stream,
 596                                              "protected:\n");
 597                         }
 598                     }
 599                   else if (TYPE_FIELD_PRIVATE (type, i))
 600                     {
 601                       if (section_type != s_private)
 602                         {
 603                           section_type = s_private;
 604                           fprintfi_filtered (level + 2, stream, "private:\n");
 605                         }
 606                     }
 607                   else
 608                     {
 609                       if (section_type != s_public)
 610                         {
 611                           section_type = s_public;
 612                           fprintfi_filtered (level + 2, stream, "public:\n");
 613                         }
 614                     }
 615                 }
 616
 617               print_spaces_filtered (level + 4, stream);
 618               if (TYPE_FIELD_STATIC (type, i))
 619                 {
 620                   fprintf_filtered (stream, "static ");
 621                 }
 622               c_print_type (TYPE_FIELD_TYPE (type, i),
 623                             TYPE_FIELD_NAME (type, i),
 624                             stream, show - 1, level + 4);
 625               if (!TYPE_FIELD_STATIC (type, i)
 626                   && TYPE_FIELD_PACKED (type, i))
 627                 {
 628                   /* It is a bitfield.  This code does not attempt
 629                      to look at the bitpos and reconstruct filler,
 630                      unnamed fields.  This would lead to misleading
 631                      results if the compiler does not put out fields
 632                      for such things (I don't know what it does).  */
 633                   fprintf_filtered (stream, " : %d",
 634                                     TYPE_FIELD_BITSIZE (type, i));
 635                 }
 636               fprintf_filtered (stream, ";\n");
 637             }
 638
 639           /* If there are both fields and methods, put a space between. */
 640           len = TYPE_NFN_FIELDS (type);
 641           if (len && section_type != s_none)
 642              fprintf_filtered (stream, "\n");
 643
 644           /* C++: print out the methods */
 645
 646           for (i = 0; i < len; i++)
 647             {
 648               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 649               int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 650               char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
 651               char *name = type_name_no_tag (type);
 652               int is_constructor = name && STREQ(method_name, name);
 653               for (j = 0; j < len2; j++)
 654                 {
 655                   char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
 656                   int is_full_physname_constructor =
 657                     ((physname[0]=='_' && physname[1]=='_' &&
 658                       (isdigit(physname[2])
 659                        || physname[2]=='Q'
 660                        || physname[2]=='t'))
 661                      || (strncmp(physname, "__ct__", 6) == 0));
 662
 663                   QUIT;
 664                   if (TYPE_FN_FIELD_PROTECTED (f, j))
 665                     {
 666                       if (section_type != s_protected)
 667                         {
 668                           section_type = s_protected;
 669                           fprintfi_filtered (level + 2, stream,
 670                                              "protected:\n");
 671                         }
 672                     }
 673                   else if (TYPE_FN_FIELD_PRIVATE (f, j))
 674                     {
 675                       if (section_type != s_private)
 676                         {
 677                           section_type = s_private;
 678                           fprintfi_filtered (level + 2, stream, "private:\n");
 679                         }
 680                     }
 681                   else
 682                     {
 683                       if (section_type != s_public)
 684                         {
 685                           section_type = s_public;
 686                           fprintfi_filtered (level + 2, stream, "public:\n");
 687                         }
 688                     }
 689
 690                   print_spaces_filtered (level + 4, stream);
 691                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
 692                     fprintf_filtered (stream, "virtual ");
 693                   else if (TYPE_FN_FIELD_STATIC_P (f, j))
 694                     fprintf_filtered (stream, "static ");
 695                   if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
 696                     {
 697                       /* Keep GDB from crashing here.  */
 698                       fprintf_unfiltered (stream, "<undefined type> %s;\n",
 699                                TYPE_FN_FIELD_PHYSNAME (f, j));
 700                       break;
 701                     }
 702                   else if (!is_constructor && !is_full_physname_constructor)
 703                     {
 704                       type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
 705                                   "", stream, -1);
 706                       fputs_filtered (" ", stream);
 707                     }
 708                   if (TYPE_FN_FIELD_STUB (f, j))
 709                     {
 710                       /* Build something we can demangle.  */
 711                       mangled_name = gdb_mangle_name (type, i, j);
 712                       demangled_name =
 713                         cplus_demangle (mangled_name,
 714                                         DMGL_ANSI | DMGL_PARAMS);
 715                       if (demangled_name == NULL)
 716                         fprintf_filtered (stream, "<badly mangled name %s>",
 717                                           mangled_name);
 718                       else
 719                         {
 720                           char *demangled_no_class =
 721                             strchr (demangled_name, ':');
 722
 723                           if (demangled_no_class == NULL)
 724                             demangled_no_class = demangled_name;
 725                           else
 726                             {
 727                               if (*++demangled_no_class == ':')
 728                                 ++demangled_no_class;
 729                             }
 730                           fputs_filtered (demangled_no_class, stream);
 731                           free (demangled_name);
 732                         }
 733                       free (mangled_name);
 734                     }
 735                   else if (TYPE_FN_FIELD_PHYSNAME (f, j)[0] == '_'
 736                         && TYPE_FN_FIELD_PHYSNAME (f, j)[1] == CPLUS_MARKER)
 737                     cp_type_print_method_args (TYPE_FN_FIELD_ARGS (f, j) + 1,
 738                                                "~", method_name, 0, stream);
 739                   else
 740                     cp_type_print_method_args (TYPE_FN_FIELD_ARGS (f, j), "",
 741                                                method_name,
 742                                                TYPE_FN_FIELD_STATIC_P (f, j),
 743                                                stream);
 744
 745                   fprintf_filtered (stream, ";\n");
 746                 }
 747             }
 748
 749           fprintfi_filtered (level, stream, "}");
 750         }
 751       break;
 752
 753     case TYPE_CODE_ENUM:
 754       fprintf_filtered (stream, "enum ");
 755       if (TYPE_TAG_NAME (type) != NULL)
 756         {
 757           fputs_filtered (TYPE_TAG_NAME (type), stream);
 758           if (show > 0)
 759             fputs_filtered (" ", stream);
 760         }
 761
 762       wrap_here ("    ");
 763       if (show < 0)
 764         {
 765           /* If we just printed a tag name, no need to print anything else.  */
 766           if (TYPE_TAG_NAME (type) == NULL)
 767             fprintf_filtered (stream, "{...}");
 768         }
 769       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
 770         {
 771           fprintf_filtered (stream, "{");
 772           len = TYPE_NFIELDS (type);
 773           lastval = 0;
 774           for (i = 0; i < len; i++)
 775             {
 776               QUIT;
 777               if (i) fprintf_filtered (stream, ", ");
 778               wrap_here ("    ");
 779               fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 780               if (lastval != TYPE_FIELD_BITPOS (type, i))
 781                 {
 782                   fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
 783                   lastval = TYPE_FIELD_BITPOS (type, i);
 784                 }
 785               lastval++;
 786             }
 787           fprintf_filtered (stream, "}");
 788         }
 789       break;
 790
 791     case TYPE_CODE_VOID:
 792       fprintf_filtered (stream, "void");
 793       break;
 794
 795     case TYPE_CODE_UNDEF:
 796       fprintf_filtered (stream, "struct <unknown>");
 797       break;
 798
 799     case TYPE_CODE_ERROR:
 800       fprintf_filtered (stream, "<unknown type>");
 801       break;
 802
 803     case TYPE_CODE_RANGE:
 804       /* This should not occur */
 805       fprintf_filtered (stream, "<range type>");
 806       break;
 807
 808     default:
 809       /* Handle types not explicitly handled by the other cases,
 810          such as fundamental types.  For these, just print whatever
 811          the type name is, as recorded in the type itself.  If there
 812          is no type name, then complain. */
 813       if (TYPE_NAME (type) != NULL)
 814         {
 815           fputs_filtered (TYPE_NAME (type), stream);
 816         }
 817       else
 818         {
 819           /* At least for dump_symtab, it is important that this not be
 820              an error ().  */
 821           fprintf_filtered (stream, "<invalid type code %d>",
 822                             TYPE_CODE (type));
 823         }
 824       break;
 825     }
 826 }
 827