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   char *name;
 459   register int i;
 460   register int len;
 461   register int lastval;
 462   char *mangled_name;
 463   char *demangled_name;
 464   enum {s_none, s_public, s_private, s_protected} section_type;
 465   QUIT;
 466
 467   wrap_here ("    ");
 468   if (type == NULL)
 469     {
 470       fputs_filtered ("<type unknown>", stream);
 471       return;
 472     }
 473
 474   /* When SHOW is zero or less, and there is a valid type name, then always
 475      just print the type name directly from the type. */
 476
 477   if ((show <= 0) && (TYPE_NAME (type) != NULL))
 478     {
 479       fputs_filtered (TYPE_NAME (type), stream);
 480       return;
 481     }
 482
 483   switch (TYPE_CODE (type))
 484     {
 485     case TYPE_CODE_ARRAY:
 486     case TYPE_CODE_PTR:
 487     case TYPE_CODE_MEMBER:
 488     case TYPE_CODE_REF:
 489     case TYPE_CODE_FUNC:
 490     case TYPE_CODE_METHOD:
 491       c_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
 492       break;
 493
 494     case TYPE_CODE_STRUCT:
 495       fprintf_filtered (stream,
 496                         HAVE_CPLUS_STRUCT (type) ? "class " : "struct ");
 497       goto struct_union;
 498
 499     case TYPE_CODE_UNION:
 500       fprintf_filtered (stream, "union ");
 501     struct_union:
 502       if ((name = type_name_no_tag (type)) != NULL)
 503         {
 504           fputs_filtered (name, stream);
 505           fputs_filtered (" ", stream);
 506           wrap_here ("    ");
 507         }
 508       if (show < 0)
 509         fprintf_filtered (stream, "{...}");
 510       else
 511         {
 512           check_stub_type (type);
 513
 514           cp_type_print_derivation_info (stream, type);
 515
 516           fprintf_filtered (stream, "{\n");
 517           if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
 518             {
 519               if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
 520                 fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
 521               else
 522                 fprintfi_filtered (level + 4, stream, "<no data fields>\n");
 523             }
 524
 525           /* Start off with no specific section type, so we can print
 526              one for the first field we find, and use that section type
 527              thereafter until we find another type. */
 528
 529           section_type = s_none;
 530
 531           /* If there is a base class for this type,
 532              do not print the field that it occupies.  */
 533
 534           len = TYPE_NFIELDS (type);
 535           for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 536             {
 537               QUIT;
 538               /* Don't print out virtual function table.  */
 539               if ((TYPE_FIELD_NAME (type, i))[5] == CPLUS_MARKER &&
 540                   !strncmp (TYPE_FIELD_NAME (type, i), "_vptr", 5))
 541                 continue;
 542
 543               /* If this is a C++ class we can print the various C++ section
 544                  labels. */
 545
 546               if (HAVE_CPLUS_STRUCT (type))
 547                 {
 548                   if (TYPE_FIELD_PROTECTED (type, i))
 549                     {
 550                       if (section_type != s_protected)
 551                         {
 552                           section_type = s_protected;
 553                           fprintfi_filtered (level + 2, stream,
 554                                              "protected:\n");
 555                         }
 556                     }
 557                   else if (TYPE_FIELD_PRIVATE (type, i))
 558                     {
 559                       if (section_type != s_private)
 560                         {
 561                           section_type = s_private;
 562                           fprintfi_filtered (level + 2, stream, "private:\n");
 563                         }
 564                     }
 565                   else
 566                     {
 567                       if (section_type != s_public)
 568                         {
 569                           section_type = s_public;
 570                           fprintfi_filtered (level + 2, stream, "public:\n");
 571                         }
 572                     }
 573                 }
 574
 575               print_spaces_filtered (level + 4, stream);
 576               if (TYPE_FIELD_STATIC (type, i))
 577                 {
 578                   fprintf_filtered (stream, "static ");
 579                 }
 580               c_print_type (TYPE_FIELD_TYPE (type, i),
 581                             TYPE_FIELD_NAME (type, i),
 582                             stream, show - 1, level + 4);
 583               if (!TYPE_FIELD_STATIC (type, i)
 584                   && TYPE_FIELD_PACKED (type, i))
 585                 {
 586                   /* It is a bitfield.  This code does not attempt
 587                      to look at the bitpos and reconstruct filler,
 588                      unnamed fields.  This would lead to misleading
 589                      results if the compiler does not put out fields
 590                      for such things (I don't know what it does).  */
 591                   fprintf_filtered (stream, " : %d",
 592                                     TYPE_FIELD_BITSIZE (type, i));
 593                 }
 594               fprintf_filtered (stream, ";\n");
 595             }
 596
 597           /* If there are both fields and methods, put a space between. */
 598           len = TYPE_NFN_FIELDS (type);
 599           if (len && section_type != s_none)
 600              fprintf_filtered (stream, "\n");
 601
 602           /* C++: print out the methods */
 603
 604           for (i = 0; i < len; i++)
 605             {
 606               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 607               int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 608               char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
 609               int is_constructor = name && STREQ(method_name, name);
 610               for (j = 0; j < len2; j++)
 611                 {
 612                   QUIT;
 613                   if (TYPE_FN_FIELD_PROTECTED (f, j))
 614                     {
 615                       if (section_type != s_protected)
 616                         {
 617                           section_type = s_protected;
 618                           fprintfi_filtered (level + 2, stream,
 619                                              "protected:\n");
 620                         }
 621                     }
 622                   else if (TYPE_FN_FIELD_PRIVATE (f, j))
 623                     {
 624                       if (section_type != s_private)
 625                         {
 626                           section_type = s_private;
 627                           fprintfi_filtered (level + 2, stream, "private:\n");
 628                         }
 629                     }
 630                   else
 631                     {
 632                       if (section_type != s_public)
 633                         {
 634                           section_type = s_public;
 635                           fprintfi_filtered (level + 2, stream, "public:\n");
 636                         }
 637                     }
 638
 639                   print_spaces_filtered (level + 4, stream);
 640                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
 641                     fprintf_filtered (stream, "virtual ");
 642                   else if (TYPE_FN_FIELD_STATIC_P (f, j))
 643                     fprintf_filtered (stream, "static ");
 644                   if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
 645                     {
 646                       /* Keep GDB from crashing here.  */
 647                       fprintf (stream, "<undefined type> %s;\n",
 648                                TYPE_FN_FIELD_PHYSNAME (f, j));
 649                       break;
 650                     }
 651                   else if (!is_constructor)
 652                     {
 653                       type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
 654                                   "", stream, 0);
 655                       fputs_filtered (" ", stream);
 656                     }
 657                   if (TYPE_FN_FIELD_STUB (f, j))
 658                     {
 659                       /* Build something we can demangle.  */
 660                       mangled_name = gdb_mangle_name (type, i, j);
 661                       demangled_name =
 662                           cplus_demangle (mangled_name,
 663                                           DMGL_ANSI | DMGL_PARAMS);
 664                       if (demangled_name == NULL)
 665                         fprintf_filtered (stream, "<badly mangled name %s>",
 666                             mangled_name);
 667                       else
 668                         {
 669                           fprintf_filtered (stream, "%s",
 670                               strchr (demangled_name, ':') + 2);
 671                           free (demangled_name);
 672                         }
 673                       free (mangled_name);
 674                     }
 675                   else if (TYPE_FN_FIELD_PHYSNAME (f, j)[0] == '_'
 676                         && TYPE_FN_FIELD_PHYSNAME (f, j)[1] == CPLUS_MARKER)
 677                     cp_type_print_method_args (TYPE_FN_FIELD_ARGS (f, j) + 1,
 678                                                "~", method_name, 0, stream);
 679                   else
 680                     cp_type_print_method_args (TYPE_FN_FIELD_ARGS (f, j), "",
 681                                                method_name,
 682                                                TYPE_FN_FIELD_STATIC_P (f, j),
 683                                                stream);
 684
 685                   fprintf_filtered (stream, ";\n");
 686                 }
 687             }
 688
 689           fprintfi_filtered (level, stream, "}");
 690         }
 691       break;
 692
 693     case TYPE_CODE_ENUM:
 694       fprintf_filtered (stream, "enum ");
 695       if ((name = type_name_no_tag (type)) != NULL)
 696         {
 697           fputs_filtered (name, stream);
 698           fputs_filtered (" ", stream);
 699         }
 700       wrap_here ("    ");
 701       if (show < 0)
 702         fprintf_filtered (stream, "{...}");
 703       else
 704         {
 705           fprintf_filtered (stream, "{");
 706           len = TYPE_NFIELDS (type);
 707           lastval = 0;
 708           for (i = 0; i < len; i++)
 709             {
 710               QUIT;
 711               if (i) fprintf_filtered (stream, ", ");
 712               wrap_here ("    ");
 713               fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 714               if (lastval != TYPE_FIELD_BITPOS (type, i))
 715                 {
 716                   fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
 717                   lastval = TYPE_FIELD_BITPOS (type, i);
 718                 }
 719               lastval++;
 720             }
 721           fprintf_filtered (stream, "}");
 722         }
 723       break;
 724
 725     case TYPE_CODE_VOID:
 726       fprintf_filtered (stream, "void");
 727       break;
 728
 729     case TYPE_CODE_UNDEF:
 730       fprintf_filtered (stream, "struct <unknown>");
 731       break;
 732
 733     case TYPE_CODE_ERROR:
 734       fprintf_filtered (stream, "<unknown type>");
 735       break;
 736
 737     case TYPE_CODE_RANGE:
 738       /* This should not occur */
 739       fprintf_filtered (stream, "<range type>");
 740       break;
 741
 742     default:
 743       /* Handle types not explicitly handled by the other cases,
 744          such as fundamental types.  For these, just print whatever
 745          the type name is, as recorded in the type itself.  If there
 746          is no type name, then complain. */
 747       if (TYPE_NAME (type) != NULL)
 748         {
 749           fputs_filtered (TYPE_NAME (type), stream);
 750         }
 751       else
 752         {
 753           error ("Invalid type code (%d) in symbol table.", TYPE_CODE (type));
 754         }
 755       break;
 756     }
 757 }
 758