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