gdb/c-typeprint.c

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