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     case TYPE_CODE_LITERAL_COMPLEX:
 319     case TYPE_CODE_LITERAL_STRING:
 320       /* These types need no prefix.  They are listed here so that
 321          gcc -Wall will reveal any types that haven't been handled.  */
 322       break;
 323     }
 324 }
 325
 326 static void
 327 c_type_print_args (type, stream)
 328      struct type *type;
 329      GDB_FILE *stream;
 330 {
 331   int i;
 332   struct type **args;
 333
 334   fprintf_filtered (stream, "(");
 335   args = TYPE_ARG_TYPES (type);
 336   if (args != NULL)
 337     {
 338       if (args[1] == NULL)
 339         {
 340           fprintf_filtered (stream, "...");
 341         }
 342       else
 343         {
 344           for (i = 1;
 345                args[i] != NULL && args[i]->code != TYPE_CODE_VOID;
 346                i++)
 347             {
 348               c_print_type (args[i], "", stream, -1, 0);
 349               if (args[i+1] == NULL)
 350                 {
 351                   fprintf_filtered (stream, "...");
 352                 }
 353               else if (args[i+1]->code != TYPE_CODE_VOID)
 354                 {
 355                   fprintf_filtered (stream, ",");
 356                   wrap_here ("    ");
 357                 }
 358             }
 359         }
 360     }
 361   fprintf_filtered (stream, ")");
 362 }
 363
 364 /* Print any array sizes, function arguments or close parentheses
 365    needed after the variable name (to describe its type).
 366    Args work like c_type_print_varspec_prefix.  */
 367
 368 static void
 369 c_type_print_varspec_suffix (type, stream, show, passed_a_ptr, demangled_args)
 370      struct type *type;
 371      GDB_FILE *stream;
 372      int show;
 373      int passed_a_ptr;
 374      int demangled_args;
 375 {
 376   if (type == 0)
 377     return;
 378
 379   if (TYPE_NAME (type) && show <= 0)
 380     return;
 381
 382   QUIT;
 383
 384   switch (TYPE_CODE (type))
 385     {
 386     case TYPE_CODE_ARRAY:
 387       if (passed_a_ptr)
 388         fprintf_filtered (stream, ")");
 389
 390       fprintf_filtered (stream, "[");
 391       if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
 392         fprintf_filtered (stream, "%d",
 393                           (TYPE_LENGTH (type)
 394                            / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
 395       fprintf_filtered (stream, "]");
 396
 397       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
 398       break;
 399
 400     case TYPE_CODE_MEMBER:
 401       if (passed_a_ptr)
 402         fprintf_filtered (stream, ")");
 403       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
 404       break;
 405
 406     case TYPE_CODE_METHOD:
 407       if (passed_a_ptr)
 408         fprintf_filtered (stream, ")");
 409       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
 410       if (passed_a_ptr)
 411         {
 412           c_type_print_args (type, stream);
 413         }
 414       break;
 415
 416     case TYPE_CODE_PTR:
 417     case TYPE_CODE_REF:
 418       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 1, 0);
 419       break;
 420
 421     case TYPE_CODE_FUNC:
 422       if (passed_a_ptr)
 423         fprintf_filtered (stream, ")");
 424       if (!demangled_args)
 425         fprintf_filtered (stream, "()");
 426       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
 427                                    passed_a_ptr, 0);
 428       break;
 429
 430     case TYPE_CODE_UNDEF:
 431     case TYPE_CODE_STRUCT:
 432     case TYPE_CODE_UNION:
 433     case TYPE_CODE_ENUM:
 434     case TYPE_CODE_INT:
 435     case TYPE_CODE_FLT:
 436     case TYPE_CODE_VOID:
 437     case TYPE_CODE_ERROR:
 438     case TYPE_CODE_CHAR:
 439     case TYPE_CODE_BOOL:
 440     case TYPE_CODE_SET:
 441     case TYPE_CODE_RANGE:
 442     case TYPE_CODE_STRING:
 443     case TYPE_CODE_BITSTRING:
 444     case TYPE_CODE_COMPLEX:
 445     case TYPE_CODE_LITERAL_COMPLEX:
 446     case TYPE_CODE_LITERAL_STRING:
 447       /* These types do not need a suffix.  They are listed so that
 448          gcc -Wall will report types that may not have been considered.  */
 449       break;
 450     }
 451 }
 452
 453 /* Print the name of the type (or the ultimate pointer target,
 454    function value or array element), or the description of a
 455    structure or union.
 456
 457    SHOW positive means print details about the type (e.g. enum values),
 458    and print structure elements passing SHOW - 1 for show.
 459    SHOW negative means just print the type name or struct tag if there is one.
 460    If there is no name, print something sensible but concise like
 461    "struct {...}".
 462    SHOW zero means just print the type name or struct tag if there is one.
 463    If there is no name, print something sensible but not as concise like
 464    "struct {int x; int y;}".
 465
 466    LEVEL is the number of spaces to indent by.
 467    We increase it for some recursive calls.  */
 468
 469 void
 470 c_type_print_base (type, stream, show, level)
 471      struct type *type;
 472      GDB_FILE *stream;
 473      int show;
 474      int level;
 475 {
 476   register int i;
 477   register int len;
 478   register int lastval;
 479   char *mangled_name;
 480   char *demangled_name;
 481   enum {s_none, s_public, s_private, s_protected} section_type;
 482   QUIT;
 483
 484   wrap_here ("    ");
 485   if (type == NULL)
 486     {
 487       fputs_filtered ("<type unknown>", stream);
 488       return;
 489     }
 490
 491   /* When SHOW is zero or less, and there is a valid type name, then always
 492      just print the type name directly from the type.  */
 493   /* If we have "typedef struct foo {. . .} bar;" do we want to print it
 494      as "struct foo" or as "bar"?  Pick the latter, because C++ folk tend
 495      to expect things like "class5 *foo" rather than "struct class5 *foo".  */
 496
 497   if (show <= 0
 498       && TYPE_NAME (type) != NULL)
 499     {
 500       fputs_filtered (TYPE_NAME (type), stream);
 501       return;
 502     }
 503
 504   check_stub_type (type);
 505
 506   switch (TYPE_CODE (type))
 507     {
 508     case TYPE_CODE_ARRAY:
 509     case TYPE_CODE_PTR:
 510     case TYPE_CODE_MEMBER:
 511     case TYPE_CODE_REF:
 512     case TYPE_CODE_FUNC:
 513     case TYPE_CODE_METHOD:
 514       c_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
 515       break;
 516
 517     case TYPE_CODE_STRUCT:
 518       if (HAVE_CPLUS_STRUCT (type))
 519         {
 520           fprintf_filtered (stream, "class ");
 521         }
 522       else
 523         {
 524           fprintf_filtered (stream, "struct ");
 525         }
 526       goto struct_union;
 527
 528     case TYPE_CODE_UNION:
 529       fprintf_filtered (stream, "union ");
 530
 531     struct_union:
 532       if (TYPE_TAG_NAME (type) != NULL)
 533         {
 534           fputs_filtered (TYPE_TAG_NAME (type), stream);
 535           if (show > 0)
 536             fputs_filtered (" ", stream);
 537         }
 538       wrap_here ("    ");
 539       if (show < 0)
 540         {
 541           /* If we just printed a tag name, no need to print anything else.  */
 542           if (TYPE_TAG_NAME (type) == NULL)
 543             fprintf_filtered (stream, "{...}");
 544         }
 545       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
 546         {
 547           cp_type_print_derivation_info (stream, type);
 548
 549           fprintf_filtered (stream, "{\n");
 550           if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
 551             {
 552               if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
 553                 fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
 554               else
 555                 fprintfi_filtered (level + 4, stream, "<no data fields>\n");
 556             }
 557
 558           /* Start off with no specific section type, so we can print
 559              one for the first field we find, and use that section type
 560              thereafter until we find another type. */
 561
 562           section_type = s_none;
 563
 564           /* If there is a base class for this type,
 565              do not print the field that it occupies.  */
 566
 567           len = TYPE_NFIELDS (type);
 568           for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 569             {
 570               QUIT;
 571               /* Don't print out virtual function table.  */
 572               if ((TYPE_FIELD_NAME (type, i))[5] == CPLUS_MARKER &&
 573                   !strncmp (TYPE_FIELD_NAME (type, i), "_vptr", 5))
 574                 continue;
 575
 576               /* If this is a C++ class we can print the various C++ section
 577                  labels. */
 578
 579               if (HAVE_CPLUS_STRUCT (type))
 580                 {
 581                   if (TYPE_FIELD_PROTECTED (type, i))
 582                     {
 583                       if (section_type != s_protected)
 584                         {
 585                           section_type = s_protected;
 586                           fprintfi_filtered (level + 2, stream,
 587                                              "protected:\n");
 588                         }
 589                     }
 590                   else if (TYPE_FIELD_PRIVATE (type, i))
 591                     {
 592                       if (section_type != s_private)
 593                         {
 594                           section_type = s_private;
 595                           fprintfi_filtered (level + 2, stream, "private:\n");
 596                         }
 597                     }
 598                   else
 599                     {
 600                       if (section_type != s_public)
 601                         {
 602                           section_type = s_public;
 603                           fprintfi_filtered (level + 2, stream, "public:\n");
 604                         }
 605                     }
 606                 }
 607
 608               print_spaces_filtered (level + 4, stream);
 609               if (TYPE_FIELD_STATIC (type, i))
 610                 {
 611                   fprintf_filtered (stream, "static ");
 612                 }
 613               c_print_type (TYPE_FIELD_TYPE (type, i),
 614                             TYPE_FIELD_NAME (type, i),
 615                             stream, show - 1, level + 4);
 616               if (!TYPE_FIELD_STATIC (type, i)
 617                   && TYPE_FIELD_PACKED (type, i))
 618                 {
 619                   /* It is a bitfield.  This code does not attempt
 620                      to look at the bitpos and reconstruct filler,
 621                      unnamed fields.  This would lead to misleading
 622                      results if the compiler does not put out fields
 623                      for such things (I don't know what it does).  */
 624                   fprintf_filtered (stream, " : %d",
 625                                     TYPE_FIELD_BITSIZE (type, i));
 626                 }
 627               fprintf_filtered (stream, ";\n");
 628             }
 629
 630           /* If there are both fields and methods, put a space between. */
 631           len = TYPE_NFN_FIELDS (type);
 632           if (len && section_type != s_none)
 633              fprintf_filtered (stream, "\n");
 634
 635           /* C++: print out the methods */
 636
 637           for (i = 0; i < len; i++)
 638             {
 639               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 640               int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 641               char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
 642               char *name = type_name_no_tag (type);
 643               int is_constructor = name && STREQ(method_name, name);
 644               for (j = 0; j < len2; j++)
 645                 {
 646                   char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
 647                   int is_full_physname_constructor =
 648                     ((physname[0]=='_' && physname[1]=='_' &&
 649                       (isdigit(physname[2])
 650                        || physname[2]=='Q'
 651                        || physname[2]=='t'))
 652                      || (strncmp(physname, "__ct__", 6) == 0));
 653
 654                   QUIT;
 655                   if (TYPE_FN_FIELD_PROTECTED (f, j))
 656                     {
 657                       if (section_type != s_protected)
 658                         {
 659                           section_type = s_protected;
 660                           fprintfi_filtered (level + 2, stream,
 661                                              "protected:\n");
 662                         }
 663                     }
 664                   else if (TYPE_FN_FIELD_PRIVATE (f, j))
 665                     {
 666                       if (section_type != s_private)
 667                         {
 668                           section_type = s_private;
 669                           fprintfi_filtered (level + 2, stream, "private:\n");
 670                         }
 671                     }
 672                   else
 673                     {
 674                       if (section_type != s_public)
 675                         {
 676                           section_type = s_public;
 677                           fprintfi_filtered (level + 2, stream, "public:\n");
 678                         }
 679                     }
 680
 681                   print_spaces_filtered (level + 4, stream);
 682                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
 683                     fprintf_filtered (stream, "virtual ");
 684                   else if (TYPE_FN_FIELD_STATIC_P (f, j))
 685                     fprintf_filtered (stream, "static ");
 686                   if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
 687                     {
 688                       /* Keep GDB from crashing here.  */
 689                       fprintf_unfiltered (stream, "<undefined type> %s;\n",
 690                                TYPE_FN_FIELD_PHYSNAME (f, j));
 691                       break;
 692                     }
 693                   else if (!is_constructor && !is_full_physname_constructor)
 694                     {
 695                       type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
 696                                   "", stream, -1);
 697                       fputs_filtered (" ", stream);
 698                     }
 699                   if (TYPE_FN_FIELD_STUB (f, j))
 700                     {
 701                       /* Build something we can demangle.  */
 702                       mangled_name = gdb_mangle_name (type, i, j);
 703                       demangled_name =
 704                         cplus_demangle (mangled_name,
 705                                         DMGL_ANSI | DMGL_PARAMS);
 706                       if (demangled_name == NULL)
 707                         fprintf_filtered (stream, "<badly mangled name %s>",
 708                                           mangled_name);
 709                       else
 710                         {
 711                           char *demangled_no_class =
 712                             strchr (demangled_name, ':');
 713
 714                           if (demangled_no_class == NULL)
 715                             demangled_no_class = demangled_name;
 716                           else
 717                             {
 718                               if (*++demangled_no_class == ':')
 719                                 ++demangled_no_class;
 720                             }
 721                           fputs_filtered (demangled_no_class, stream);
 722                           free (demangled_name);
 723                         }
 724                       free (mangled_name);
 725                     }
 726                   else if (TYPE_FN_FIELD_PHYSNAME (f, j)[0] == '_'
 727                         && TYPE_FN_FIELD_PHYSNAME (f, j)[1] == CPLUS_MARKER)
 728                     cp_type_print_method_args (TYPE_FN_FIELD_ARGS (f, j) + 1,
 729                                                "~", method_name, 0, stream);
 730                   else
 731                     cp_type_print_method_args (TYPE_FN_FIELD_ARGS (f, j), "",
 732                                                method_name,
 733                                                TYPE_FN_FIELD_STATIC_P (f, j),
 734                                                stream);
 735
 736                   fprintf_filtered (stream, ";\n");
 737                 }
 738             }
 739
 740           fprintfi_filtered (level, stream, "}");
 741         }
 742       break;
 743
 744     case TYPE_CODE_ENUM:
 745       fprintf_filtered (stream, "enum ");
 746       if (TYPE_TAG_NAME (type) != NULL)
 747         {
 748           fputs_filtered (TYPE_TAG_NAME (type), stream);
 749           if (show > 0)
 750             fputs_filtered (" ", stream);
 751         }
 752
 753       wrap_here ("    ");
 754       if (show < 0)
 755         {
 756           /* If we just printed a tag name, no need to print anything else.  */
 757           if (TYPE_TAG_NAME (type) == NULL)
 758             fprintf_filtered (stream, "{...}");
 759         }
 760       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
 761         {
 762           fprintf_filtered (stream, "{");
 763           len = TYPE_NFIELDS (type);
 764           lastval = 0;
 765           for (i = 0; i < len; i++)
 766             {
 767               QUIT;
 768               if (i) fprintf_filtered (stream, ", ");
 769               wrap_here ("    ");
 770               fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 771               if (lastval != TYPE_FIELD_BITPOS (type, i))
 772                 {
 773                   fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
 774                   lastval = TYPE_FIELD_BITPOS (type, i);
 775                 }
 776               lastval++;
 777             }
 778           fprintf_filtered (stream, "}");
 779         }
 780       break;
 781
 782     case TYPE_CODE_VOID:
 783       fprintf_filtered (stream, "void");
 784       break;
 785
 786     case TYPE_CODE_UNDEF:
 787       fprintf_filtered (stream, "struct <unknown>");
 788       break;
 789
 790     case TYPE_CODE_ERROR:
 791       fprintf_filtered (stream, "<unknown type>");
 792       break;
 793
 794     case TYPE_CODE_RANGE:
 795       /* This should not occur */
 796       fprintf_filtered (stream, "<range type>");
 797       break;
 798
 799     default:
 800       /* Handle types not explicitly handled by the other cases,
 801          such as fundamental types.  For these, just print whatever
 802          the type name is, as recorded in the type itself.  If there
 803          is no type name, then complain. */
 804       if (TYPE_NAME (type) != NULL)
 805         {
 806           fputs_filtered (TYPE_NAME (type), stream);
 807         }
 808       else
 809         {
 810           /* At least for dump_symtab, it is important that this not be
 811              an error ().  */
 812           fprintf_filtered (stream, "<invalid type code %d>",
 813                             TYPE_CODE (type));
 814         }
 815       break;
 816     }
 817 }
 818