gdb/c-typeprint.c

   1 /* Support for printing C and C++ types for GDB, the GNU debugger.
   2    Copyright (C) 1986-2013 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 3 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, see <http://www.gnu.org/licenses/>.  */
  18
  19 #include "defs.h"
  20 #include "gdb_obstack.h"
  21 #include "bfd.h"                /* Binary File Description.  */
  22 #include "symtab.h"
  23 #include "gdbtypes.h"
  24 #include "expression.h"
  25 #include "value.h"
  26 #include "gdbcore.h"
  27 #include "target.h"
  28 #include "language.h"
  29 #include "demangle.h"
  30 #include "c-lang.h"
  31 #include "typeprint.h"
  32 #include "cp-abi.h"
  33 #include "jv-lang.h"
  34 #include "gdb_string.h"
  35 #include <errno.h>
  36 #include "cp-support.h"
  37
  38 static void c_type_print_varspec_prefix (struct type *,
  39                                          struct ui_file *,
  40                                          int, int, int,
  41                                          const struct type_print_options *);
  42
  43 /* Print "const", "volatile", or address space modifiers.  */
  44 static void c_type_print_modifier (struct type *,
  45                                    struct ui_file *,
  46                                    int, int);
  47 \f
  48
  49 /* A callback function for cp_canonicalize_string_full that uses
  50    find_typedef_in_hash.  */
  51
  52 static const char *
  53 find_typedef_for_canonicalize (struct type *t, void *data)
  54 {
  55   return find_typedef_in_hash (data, t);
  56 }
  57
  58 /* Print NAME on STREAM.  If the 'raw' field of FLAGS is not set,
  59    canonicalize NAME using the local typedefs first.  */
  60
  61 static void
  62 print_name_maybe_canonical (const char *name,
  63                             const struct type_print_options *flags,
  64                             struct ui_file *stream)
  65 {
  66   char *s = NULL;
  67
  68   if (!flags->raw)
  69     s = cp_canonicalize_string_full (name,
  70                                      find_typedef_for_canonicalize,
  71                                      (void *) flags);
  72
  73   fputs_filtered (s ? s : name, stream);
  74   xfree (s);
  75 }
  76
  77 \f
  78
  79 /* LEVEL is the depth to indent lines by.  */
  80
  81 void
  82 c_print_type (struct type *type,
  83               const char *varstring,
  84               struct ui_file *stream,
  85               int show, int level,
  86               const struct type_print_options *flags)
  87 {
  88   enum type_code code;
  89   int demangled_args;
  90   int need_post_space;
  91   const char *local_name;
  92
  93   if (show > 0)
  94     CHECK_TYPEDEF (type);
  95
  96   local_name = find_typedef_in_hash (flags, type);
  97   if (local_name != NULL)
  98     {
  99       fputs_filtered (local_name, stream);
 100       if (varstring != NULL && *varstring != '\0')
 101         fputs_filtered (" ", stream);
 102     }
 103   else
 104     {
 105       c_type_print_base (type, stream, show, level, flags);
 106       code = TYPE_CODE (type);
 107       if ((varstring != NULL && *varstring != '\0')
 108           /* Need a space if going to print stars or brackets;
 109              but not if we will print just a type name.  */
 110           || ((show > 0 || TYPE_NAME (type) == 0)
 111               && (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
 112                   || code == TYPE_CODE_METHOD
 113                   || (code == TYPE_CODE_ARRAY
 114                       && !TYPE_VECTOR (type))
 115                   || code == TYPE_CODE_MEMBERPTR
 116                   || code == TYPE_CODE_METHODPTR
 117                   || code == TYPE_CODE_REF)))
 118         fputs_filtered (" ", stream);
 119       need_post_space = (varstring != NULL && strcmp (varstring, "") != 0);
 120       c_type_print_varspec_prefix (type, stream, show, 0, need_post_space,
 121                                    flags);
 122     }
 123
 124   if (varstring != NULL)
 125     {
 126       fputs_filtered (varstring, stream);
 127
 128       /* For demangled function names, we have the arglist as part of
 129          the name, so don't print an additional pair of ()'s.  */
 130       if (local_name == NULL)
 131         {
 132           demangled_args = strchr (varstring, '(') != NULL;
 133           c_type_print_varspec_suffix (type, stream, show,
 134                                        0, demangled_args,
 135                                        flags);
 136         }
 137     }
 138 }
 139
 140 /* Print a typedef using C syntax.  TYPE is the underlying type.
 141    NEW_SYMBOL is the symbol naming the type.  STREAM is the stream on
 142    which to print.  */
 143
 144 void
 145 c_print_typedef (struct type *type,
 146                  struct symbol *new_symbol,
 147                  struct ui_file *stream)
 148 {
 149   CHECK_TYPEDEF (type);
 150   fprintf_filtered (stream, "typedef ");
 151   type_print (type, "", stream, 0);
 152   if (TYPE_NAME ((SYMBOL_TYPE (new_symbol))) == 0
 153       || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol))),
 154                  SYMBOL_LINKAGE_NAME (new_symbol)) != 0
 155       || TYPE_CODE (SYMBOL_TYPE (new_symbol)) == TYPE_CODE_TYPEDEF)
 156     fprintf_filtered (stream, " %s", SYMBOL_PRINT_NAME (new_symbol));
 157   fprintf_filtered (stream, ";\n");
 158 }
 159
 160 /* If TYPE is a derived type, then print out derivation information.
 161    Print only the actual base classes of this type, not the base
 162    classes of the base classes.  I.e. for the derivation hierarchy:
 163
 164    class A { int a; };
 165    class B : public A {int b; };
 166    class C : public B {int c; };
 167
 168    Print the type of class C as:
 169
 170    class C : public B {
 171    int c;
 172    }
 173
 174    Not as the following (like gdb used to), which is not legal C++
 175    syntax for derived types and may be confused with the multiple
 176    inheritance form:
 177
 178    class C : public B : public A {
 179    int c;
 180    }
 181
 182    In general, gdb should try to print the types as closely as
 183    possible to the form that they appear in the source code.  */
 184
 185 static void
 186 cp_type_print_derivation_info (struct ui_file *stream,
 187                                struct type *type,
 188                                const struct type_print_options *flags)
 189 {
 190   const char *name;
 191   int i;
 192
 193   for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
 194     {
 195       wrap_here ("        ");
 196       fputs_filtered (i == 0 ? ": " : ", ", stream);
 197       fprintf_filtered (stream, "%s%s ",
 198                         BASETYPE_VIA_PUBLIC (type, i)
 199                         ? "public" : (TYPE_FIELD_PROTECTED (type, i)
 200                                       ? "protected" : "private"),
 201                         BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : "");
 202       name = type_name_no_tag (TYPE_BASECLASS (type, i));
 203       if (name)
 204         print_name_maybe_canonical (name, flags, stream);
 205       else
 206         fprintf_filtered (stream, "(null)");
 207     }
 208   if (i > 0)
 209     {
 210       fputs_filtered (" ", stream);
 211     }
 212 }
 213
 214 /* Print the C++ method arguments ARGS to the file STREAM.  */
 215
 216 static void
 217 cp_type_print_method_args (struct type *mtype, const char *prefix,
 218                            const char *varstring, int staticp,
 219                            struct ui_file *stream,
 220                            const struct type_print_options *flags)
 221 {
 222   struct field *args = TYPE_FIELDS (mtype);
 223   int nargs = TYPE_NFIELDS (mtype);
 224   int varargs = TYPE_VARARGS (mtype);
 225   int i;
 226
 227   fprintf_symbol_filtered (stream, prefix,
 228                            language_cplus, DMGL_ANSI);
 229   fprintf_symbol_filtered (stream, varstring,
 230                            language_cplus, DMGL_ANSI);
 231   fputs_filtered ("(", stream);
 232
 233   /* Skip the class variable.  */
 234   i = staticp ? 0 : 1;
 235   if (nargs > i)
 236     {
 237       while (i < nargs)
 238         {
 239           c_print_type (args[i++].type, "", stream, 0, 0, flags);
 240
 241           if (i == nargs && varargs)
 242             fprintf_filtered (stream, ", ...");
 243           else if (i < nargs)
 244             {
 245               fprintf_filtered (stream, ", ");
 246               wrap_here ("        ");
 247             }
 248         }
 249     }
 250   else if (varargs)
 251     fprintf_filtered (stream, "...");
 252   else if (current_language->la_language == language_cplus)
 253     fprintf_filtered (stream, "void");
 254
 255   fprintf_filtered (stream, ")");
 256
 257   /* For non-static methods, read qualifiers from the type of
 258      THIS.  */
 259   if (!staticp)
 260     {
 261       struct type *domain;
 262
 263       gdb_assert (nargs > 0);
 264       gdb_assert (TYPE_CODE (args[0].type) == TYPE_CODE_PTR);
 265       domain = TYPE_TARGET_TYPE (args[0].type);
 266
 267       if (TYPE_CONST (domain))
 268         fprintf_filtered (stream, " const");
 269
 270       if (TYPE_VOLATILE (domain))
 271         fprintf_filtered (stream, " volatile");
 272     }
 273 }
 274
 275
 276 /* Print any asterisks or open-parentheses needed before the
 277    variable name (to describe its type).
 278
 279    On outermost call, pass 0 for PASSED_A_PTR.
 280    On outermost call, SHOW > 0 means should ignore
 281    any typename for TYPE and show its details.
 282    SHOW is always zero on recursive calls.
 283
 284    NEED_POST_SPACE is non-zero when a space will be be needed
 285    between a trailing qualifier and a field, variable, or function
 286    name.  */
 287
 288 static void
 289 c_type_print_varspec_prefix (struct type *type,
 290                              struct ui_file *stream,
 291                              int show, int passed_a_ptr,
 292                              int need_post_space,
 293                              const struct type_print_options *flags)
 294 {
 295   const char *name;
 296
 297   if (type == 0)
 298     return;
 299
 300   if (TYPE_NAME (type) && show <= 0)
 301     return;
 302
 303   QUIT;
 304
 305   switch (TYPE_CODE (type))
 306     {
 307     case TYPE_CODE_PTR:
 308       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
 309                                    stream, show, 1, 1, flags);
 310       fprintf_filtered (stream, "*");
 311       c_type_print_modifier (type, stream, 1, need_post_space);
 312       break;
 313
 314     case TYPE_CODE_MEMBERPTR:
 315       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
 316                                    stream, show, 0, 0, flags);
 317       name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
 318       if (name)
 319         print_name_maybe_canonical (name, flags, stream);
 320       else
 321         c_type_print_base (TYPE_DOMAIN_TYPE (type),
 322                            stream, -1, passed_a_ptr, flags);
 323       fprintf_filtered (stream, "::*");
 324       break;
 325
 326     case TYPE_CODE_METHODPTR:
 327       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
 328                                    stream, show, 0, 0, flags);
 329       fprintf_filtered (stream, "(");
 330       name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
 331       if (name)
 332         print_name_maybe_canonical (name, flags, stream);
 333       else
 334         c_type_print_base (TYPE_DOMAIN_TYPE (type),
 335                            stream, -1, passed_a_ptr, flags);
 336       fprintf_filtered (stream, "::*");
 337       break;
 338
 339     case TYPE_CODE_REF:
 340       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
 341                                    stream, show, 1, 0, flags);
 342       fprintf_filtered (stream, "&");
 343       c_type_print_modifier (type, stream, 1, need_post_space);
 344       break;
 345
 346     case TYPE_CODE_METHOD:
 347     case TYPE_CODE_FUNC:
 348       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
 349                                    stream, show, 0, 0, flags);
 350       if (passed_a_ptr)
 351         fprintf_filtered (stream, "(");
 352       break;
 353
 354     case TYPE_CODE_ARRAY:
 355       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
 356                                    stream, show, 0, 0, flags);
 357       if (passed_a_ptr)
 358         fprintf_filtered (stream, "(");
 359       break;
 360
 361     case TYPE_CODE_TYPEDEF:
 362       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
 363                                    stream, show, passed_a_ptr, 0, flags);
 364       break;
 365
 366     case TYPE_CODE_UNDEF:
 367     case TYPE_CODE_STRUCT:
 368     case TYPE_CODE_UNION:
 369     case TYPE_CODE_ENUM:
 370     case TYPE_CODE_INT:
 371     case TYPE_CODE_FLT:
 372     case TYPE_CODE_VOID:
 373     case TYPE_CODE_ERROR:
 374     case TYPE_CODE_CHAR:
 375     case TYPE_CODE_BOOL:
 376     case TYPE_CODE_SET:
 377     case TYPE_CODE_RANGE:
 378     case TYPE_CODE_STRING:
 379     case TYPE_CODE_COMPLEX:
 380     case TYPE_CODE_NAMESPACE:
 381     case TYPE_CODE_DECFLOAT:
 382       /* These types need no prefix.  They are listed here so that
 383          gcc -Wall will reveal any types that haven't been handled.  */
 384       break;
 385     default:
 386       error (_("type not handled in c_type_print_varspec_prefix()"));
 387       break;
 388     }
 389 }
 390
 391 /* Print out "const" and "volatile" attributes,
 392    and address space id if present.
 393    TYPE is a pointer to the type being printed out.
 394    STREAM is the output destination.
 395    NEED_PRE_SPACE = 1 indicates an initial white space is needed.
 396    NEED_POST_SPACE = 1 indicates a final white space is needed.  */
 397
 398 static void
 399 c_type_print_modifier (struct type *type, struct ui_file *stream,
 400                        int need_pre_space, int need_post_space)
 401 {
 402   int did_print_modifier = 0;
 403   const char *address_space_id;
 404
 405   /* We don't print `const' qualifiers for references --- since all
 406      operators affect the thing referenced, not the reference itself,
 407      every reference is `const'.  */
 408   if (TYPE_CONST (type)
 409       && TYPE_CODE (type) != TYPE_CODE_REF)
 410     {
 411       if (need_pre_space)
 412         fprintf_filtered (stream, " ");
 413       fprintf_filtered (stream, "const");
 414       did_print_modifier = 1;
 415     }
 416
 417   if (TYPE_VOLATILE (type))
 418     {
 419       if (did_print_modifier || need_pre_space)
 420         fprintf_filtered (stream, " ");
 421       fprintf_filtered (stream, "volatile");
 422       did_print_modifier = 1;
 423     }
 424
 425   address_space_id = address_space_int_to_name (get_type_arch (type),
 426                                                 TYPE_INSTANCE_FLAGS (type));
 427   if (address_space_id)
 428     {
 429       if (did_print_modifier || need_pre_space)
 430         fprintf_filtered (stream, " ");
 431       fprintf_filtered (stream, "@%s", address_space_id);
 432       did_print_modifier = 1;
 433     }
 434
 435   if (did_print_modifier && need_post_space)
 436     fprintf_filtered (stream, " ");
 437 }
 438
 439
 440 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
 441    or TYPE_CODE_FUNC, to STREAM.  Artificial arguments, such as "this"
 442    in non-static methods, are displayed if LINKAGE_NAME is zero.  If
 443    LINKAGE_NAME is non-zero and LANGUAGE is language_cplus the topmost
 444    parameter types get removed their possible const and volatile qualifiers to
 445    match demangled linkage name parameters part of such function type.
 446    LANGUAGE is the language in which TYPE was defined.  This is a necessary
 447    evil since this code is used by the C, C++, and Java backends.  */
 448
 449 void
 450 c_type_print_args (struct type *type, struct ui_file *stream,
 451                    int linkage_name, enum language language,
 452                    const struct type_print_options *flags)
 453 {
 454   int i, len;
 455   struct field *args;
 456   int printed_any = 0;
 457
 458   fprintf_filtered (stream, "(");
 459   args = TYPE_FIELDS (type);
 460   len = TYPE_NFIELDS (type);
 461
 462   for (i = 0; i < TYPE_NFIELDS (type); i++)
 463     {
 464       struct type *param_type;
 465
 466       if (TYPE_FIELD_ARTIFICIAL (type, i) && linkage_name)
 467         continue;
 468
 469       if (printed_any)
 470         {
 471           fprintf_filtered (stream, ", ");
 472           wrap_here ("    ");
 473         }
 474
 475       param_type = TYPE_FIELD_TYPE (type, i);
 476
 477       if (language == language_cplus && linkage_name)
 478         {
 479           /* C++ standard, 13.1 Overloadable declarations, point 3, item:
 480              - Parameter declarations that differ only in the presence or
 481                absence of const and/or volatile are equivalent.
 482
 483              And the const/volatile qualifiers are not present in the mangled
 484              names as produced by GCC.  */
 485
 486           param_type = make_cv_type (0, 0, param_type, NULL);
 487         }
 488
 489       if (language == language_java)
 490         java_print_type (param_type, "", stream, -1, 0, flags);
 491       else
 492         c_print_type (param_type, "", stream, -1, 0, flags);
 493       printed_any = 1;
 494     }
 495
 496   if (printed_any && TYPE_VARARGS (type))
 497     {
 498       /* Print out a trailing ellipsis for varargs functions.  Ignore
 499          TYPE_VARARGS if the function has no named arguments; that
 500          represents unprototyped (K&R style) C functions.  */
 501       if (printed_any && TYPE_VARARGS (type))
 502         {
 503           fprintf_filtered (stream, ", ");
 504           wrap_here ("    ");
 505           fprintf_filtered (stream, "...");
 506         }
 507     }
 508   else if (!printed_any
 509            && ((TYPE_PROTOTYPED (type) && language != language_java)
 510                || language == language_cplus))
 511     fprintf_filtered (stream, "void");
 512
 513   fprintf_filtered (stream, ")");
 514 }
 515
 516 /* Return true iff the j'th overloading of the i'th method of TYPE
 517    is a type conversion operator, like `operator int () { ... }'.
 518    When listing a class's methods, we don't print the return type of
 519    such operators.  */
 520
 521 static int
 522 is_type_conversion_operator (struct type *type, int i, int j)
 523 {
 524   /* I think the whole idea of recognizing type conversion operators
 525      by their name is pretty terrible.  But I don't think our present
 526      data structure gives us any other way to tell.  If you know of
 527      some other way, feel free to rewrite this function.  */
 528   const char *name = TYPE_FN_FIELDLIST_NAME (type, i);
 529
 530   if (strncmp (name, "operator", 8) != 0)
 531     return 0;
 532
 533   name += 8;
 534   if (! strchr (" \t\f\n\r", *name))
 535     return 0;
 536
 537   while (strchr (" \t\f\n\r", *name))
 538     name++;
 539
 540   if (!('a' <= *name && *name <= 'z')
 541       && !('A' <= *name && *name <= 'Z')
 542       && *name != '_')
 543     /* If this doesn't look like the start of an identifier, then it
 544        isn't a type conversion operator.  */
 545     return 0;
 546   else if (strncmp (name, "new", 3) == 0)
 547     name += 3;
 548   else if (strncmp (name, "delete", 6) == 0)
 549     name += 6;
 550   else
 551     /* If it doesn't look like new or delete, it's a type conversion
 552        operator.  */
 553     return 1;
 554
 555   /* Is that really the end of the name?  */
 556   if (('a' <= *name && *name <= 'z')
 557       || ('A' <= *name && *name <= 'Z')
 558       || ('0' <= *name && *name <= '9')
 559       || *name == '_')
 560     /* No, so the identifier following "operator" must be a type name,
 561        and this is a type conversion operator.  */
 562     return 1;
 563
 564   /* That was indeed the end of the name, so it was `operator new' or
 565      `operator delete', neither of which are type conversion
 566      operators.  */
 567   return 0;
 568 }
 569
 570 /* Given a C++ qualified identifier QID, strip off the qualifiers,
 571    yielding the unqualified name.  The return value is a pointer into
 572    the original string.
 573
 574    It's a pity we don't have this information in some more structured
 575    form.  Even the author of this function feels that writing little
 576    parsers like this everywhere is stupid.  */
 577
 578 static char *
 579 remove_qualifiers (char *qid)
 580 {
 581   int quoted = 0;       /* Zero if we're not in quotes;
 582                            '"' if we're in a double-quoted string;
 583                            '\'' if we're in a single-quoted string.  */
 584   int depth = 0;        /* Number of unclosed parens we've seen.  */
 585   char *parenstack = (char *) alloca (strlen (qid));
 586   char *scan;
 587   char *last = 0;       /* The character after the rightmost
 588                            `::' token we've seen so far.  */
 589
 590   for (scan = qid; *scan; scan++)
 591     {
 592       if (quoted)
 593         {
 594           if (*scan == quoted)
 595             quoted = 0;
 596           else if (*scan == '\\' && *(scan + 1))
 597             scan++;
 598         }
 599       else if (scan[0] == ':' && scan[1] == ':')
 600         {
 601           /* If we're inside parenthesis (i.e., an argument list) or
 602              angle brackets (i.e., a list of template arguments), then
 603              we don't record the position of this :: token, since it's
 604              not relevant to the top-level structure we're trying to
 605              operate on.  */
 606           if (depth == 0)
 607             {
 608               last = scan + 2;
 609               scan++;
 610             }
 611         }
 612       else if (*scan == '"' || *scan == '\'')
 613         quoted = *scan;
 614       else if (*scan == '(')
 615         parenstack[depth++] = ')';
 616       else if (*scan == '[')
 617         parenstack[depth++] = ']';
 618       /* We're going to treat <> as a pair of matching characters,
 619          since we're more likely to see those in template id's than
 620          real less-than characters.  What a crock.  */
 621       else if (*scan == '<')
 622         parenstack[depth++] = '>';
 623       else if (*scan == ')' || *scan == ']' || *scan == '>')
 624         {
 625           if (depth > 0 && parenstack[depth - 1] == *scan)
 626             depth--;
 627           else
 628             {
 629               /* We're going to do a little error recovery here.  If
 630                  we don't find a match for *scan on the paren stack,
 631                  but there is something lower on the stack that does
 632                  match, we pop the stack to that point.  */
 633               int i;
 634
 635               for (i = depth - 1; i >= 0; i--)
 636                 if (parenstack[i] == *scan)
 637                   {
 638                     depth = i;
 639                     break;
 640                   }
 641             }
 642         }
 643     }
 644
 645   if (last)
 646     return last;
 647   else
 648     /* We didn't find any :: tokens at the top level, so declare the
 649        whole thing an unqualified identifier.  */
 650     return qid;
 651 }
 652
 653 /* Print any array sizes, function arguments or close parentheses
 654    needed after the variable name (to describe its type).
 655    Args work like c_type_print_varspec_prefix.  */
 656
 657 void
 658 c_type_print_varspec_suffix (struct type *type,
 659                              struct ui_file *stream,
 660                              int show, int passed_a_ptr,
 661                              int demangled_args,
 662                              const struct type_print_options *flags)
 663 {
 664   if (type == 0)
 665     return;
 666
 667   if (TYPE_NAME (type) && show <= 0)
 668     return;
 669
 670   QUIT;
 671
 672   switch (TYPE_CODE (type))
 673     {
 674     case TYPE_CODE_ARRAY:
 675       {
 676         LONGEST low_bound, high_bound;
 677         int is_vector = TYPE_VECTOR (type);
 678
 679         if (passed_a_ptr)
 680           fprintf_filtered (stream, ")");
 681
 682         fprintf_filtered (stream, (is_vector ?
 683                                    " __attribute__ ((vector_size(" : "["));
 684         if (get_array_bounds (type, &low_bound, &high_bound))
 685           fprintf_filtered (stream, "%s",
 686                             plongest (high_bound - low_bound + 1));
 687         fprintf_filtered (stream, (is_vector ? ")))" : "]"));
 688
 689         c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
 690                                      show, 0, 0, flags);
 691       }
 692       break;
 693
 694     case TYPE_CODE_MEMBERPTR:
 695       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
 696                                    show, 0, 0, flags);
 697       break;
 698
 699     case TYPE_CODE_METHODPTR:
 700       fprintf_filtered (stream, ")");
 701       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
 702                                    show, 0, 0, flags);
 703       break;
 704
 705     case TYPE_CODE_PTR:
 706     case TYPE_CODE_REF:
 707       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
 708                                    show, 1, 0, flags);
 709       break;
 710
 711     case TYPE_CODE_METHOD:
 712     case TYPE_CODE_FUNC:
 713       if (passed_a_ptr)
 714         fprintf_filtered (stream, ")");
 715       if (!demangled_args)
 716         c_type_print_args (type, stream, 0, current_language->la_language,
 717                            flags);
 718       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
 719                                    show, passed_a_ptr, 0, flags);
 720       break;
 721
 722     case TYPE_CODE_TYPEDEF:
 723       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
 724                                    show, passed_a_ptr, 0, flags);
 725       break;
 726
 727     case TYPE_CODE_UNDEF:
 728     case TYPE_CODE_STRUCT:
 729     case TYPE_CODE_UNION:
 730     case TYPE_CODE_ENUM:
 731     case TYPE_CODE_INT:
 732     case TYPE_CODE_FLT:
 733     case TYPE_CODE_VOID:
 734     case TYPE_CODE_ERROR:
 735     case TYPE_CODE_CHAR:
 736     case TYPE_CODE_BOOL:
 737     case TYPE_CODE_SET:
 738     case TYPE_CODE_RANGE:
 739     case TYPE_CODE_STRING:
 740     case TYPE_CODE_COMPLEX:
 741     case TYPE_CODE_NAMESPACE:
 742     case TYPE_CODE_DECFLOAT:
 743       /* These types do not need a suffix.  They are listed so that
 744          gcc -Wall will report types that may not have been
 745          considered.  */
 746       break;
 747     default:
 748       error (_("type not handled in c_type_print_varspec_suffix()"));
 749       break;
 750     }
 751 }
 752
 753 /* A helper for c_type_print_base that displays template
 754    parameters and their bindings, if needed.
 755
 756    TABLE is the local bindings table to use.  If NULL, no printing is
 757    done.  Note that, at this point, TABLE won't have any useful
 758    information in it -- but it is also used as a flag to
 759    print_name_maybe_canonical to activate searching the global typedef
 760    table.
 761
 762    TYPE is the type whose template arguments are being displayed.
 763
 764    STREAM is the stream on which to print.  */
 765
 766 static void
 767 c_type_print_template_args (const struct type_print_options *flags,
 768                             struct type *type, struct ui_file *stream)
 769 {
 770   int first = 1, i;
 771
 772   if (flags->raw)
 773     return;
 774
 775   for (i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (type); ++i)
 776     {
 777       struct symbol *sym = TYPE_TEMPLATE_ARGUMENT (type, i);
 778
 779       if (SYMBOL_CLASS (sym) != LOC_TYPEDEF)
 780         continue;
 781
 782       if (first)
 783         {
 784           wrap_here ("    ");
 785           fprintf_filtered (stream, _("[with %s = "),
 786                             SYMBOL_LINKAGE_NAME (sym));
 787           first = 0;
 788         }
 789       else
 790         {
 791           fputs_filtered (", ", stream);
 792           wrap_here ("         ");
 793           fprintf_filtered (stream, "%s = ", SYMBOL_LINKAGE_NAME (sym));
 794         }
 795
 796       c_print_type (SYMBOL_TYPE (sym), "", stream, -1, 0, flags);
 797     }
 798
 799   if (!first)
 800     fputs_filtered (_("] "), stream);
 801 }
 802
 803 /* Print the name of the type (or the ultimate pointer target,
 804    function value or array element), or the description of a structure
 805    or union.
 806
 807    SHOW positive means print details about the type (e.g. enum
 808    values), and print structure elements passing SHOW - 1 for show.
 809
 810    SHOW negative means just print the type name or struct tag if there
 811    is one.  If there is no name, print something sensible but concise
 812    like "struct {...}".
 813
 814    SHOW zero means just print the type name or struct tag if there is
 815    one.  If there is no name, print something sensible but not as
 816    concise like "struct {int x; int y;}".
 817
 818    LEVEL is the number of spaces to indent by.
 819    We increase it for some recursive calls.  */
 820
 821 void
 822 c_type_print_base (struct type *type, struct ui_file *stream,
 823                    int show, int level, const struct type_print_options *flags)
 824 {
 825   int i;
 826   int len, real_len;
 827   enum
 828     {
 829       s_none, s_public, s_private, s_protected
 830     }
 831   section_type;
 832   int need_access_label = 0;
 833   int j, len2;
 834
 835   QUIT;
 836
 837   if (type == NULL)
 838     {
 839       fputs_filtered (_("<type unknown>"), stream);
 840       return;
 841     }
 842
 843   /* When SHOW is zero or less, and there is a valid type name, then
 844      always just print the type name directly from the type.  */
 845   /* If we have "typedef struct foo {. . .} bar;" do we want to print
 846      it as "struct foo" or as "bar"?  Pick the latter, because C++
 847      folk tend to expect things like "class5 *foo" rather than "struct
 848      class5 *foo".  */
 849
 850   if (show <= 0
 851       && TYPE_NAME (type) != NULL)
 852     {
 853       c_type_print_modifier (type, stream, 0, 1);
 854       print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
 855       return;
 856     }
 857
 858   CHECK_TYPEDEF (type);
 859
 860   switch (TYPE_CODE (type))
 861     {
 862     case TYPE_CODE_TYPEDEF:
 863       /* If we get here, the typedef doesn't have a name, and we
 864          couldn't resolve TYPE_TARGET_TYPE.  Not much we can do.  */
 865       gdb_assert (TYPE_NAME (type) == NULL);
 866       gdb_assert (TYPE_TARGET_TYPE (type) == NULL);
 867       fprintf_filtered (stream, _("<unnamed typedef>"));
 868       break;
 869
 870     case TYPE_CODE_ARRAY:
 871     case TYPE_CODE_PTR:
 872     case TYPE_CODE_MEMBERPTR:
 873     case TYPE_CODE_REF:
 874     case TYPE_CODE_FUNC:
 875     case TYPE_CODE_METHOD:
 876     case TYPE_CODE_METHODPTR:
 877       c_type_print_base (TYPE_TARGET_TYPE (type),
 878                          stream, show, level, flags);
 879       break;
 880
 881     case TYPE_CODE_STRUCT:
 882     case TYPE_CODE_UNION:
 883       {
 884         struct type_print_options local_flags = *flags;
 885         struct type_print_options semi_local_flags = *flags;
 886         struct cleanup *local_cleanups = make_cleanup (null_cleanup, NULL);
 887
 888         local_flags.local_typedefs = NULL;
 889         semi_local_flags.local_typedefs = NULL;
 890
 891         if (!flags->raw)
 892           {
 893             if (flags->local_typedefs)
 894               local_flags.local_typedefs
 895                 = copy_typedef_hash (flags->local_typedefs);
 896             else
 897               local_flags.local_typedefs = create_typedef_hash ();
 898
 899             make_cleanup_free_typedef_hash (local_flags.local_typedefs);
 900           }
 901
 902         c_type_print_modifier (type, stream, 0, 1);
 903         if (TYPE_CODE (type) == TYPE_CODE_UNION)
 904           fprintf_filtered (stream, "union ");
 905         else if (TYPE_DECLARED_CLASS (type))
 906           fprintf_filtered (stream, "class ");
 907         else
 908           fprintf_filtered (stream, "struct ");
 909
 910         /* Print the tag if it exists.  The HP aCC compiler emits a
 911            spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
 912            enum}" tag for unnamed struct/union/enum's, which we don't
 913            want to print.  */
 914         if (TYPE_TAG_NAME (type) != NULL
 915             && strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
 916           {
 917             /* When printing the tag name, we are still effectively
 918                printing in the outer context, hence the use of FLAGS
 919                here.  */
 920             print_name_maybe_canonical (TYPE_TAG_NAME (type), flags, stream);
 921             if (show > 0)
 922               fputs_filtered (" ", stream);
 923           }
 924
 925         if (show < 0)
 926           {
 927             /* If we just printed a tag name, no need to print anything
 928                else.  */
 929             if (TYPE_TAG_NAME (type) == NULL)
 930               fprintf_filtered (stream, "{...}");
 931           }
 932         else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
 933           {
 934             struct type *basetype;
 935             int vptr_fieldno;
 936
 937             c_type_print_template_args (&local_flags, type, stream);
 938
 939             /* Add in template parameters when printing derivation info.  */
 940             add_template_parameters (local_flags.local_typedefs, type);
 941             cp_type_print_derivation_info (stream, type, &local_flags);
 942
 943             /* This holds just the global typedefs and the template
 944                parameters.  */
 945             semi_local_flags.local_typedefs
 946               = copy_typedef_hash (local_flags.local_typedefs);
 947             if (semi_local_flags.local_typedefs)
 948               make_cleanup_free_typedef_hash (semi_local_flags.local_typedefs);
 949
 950             /* Now add in the local typedefs.  */
 951             recursively_update_typedef_hash (local_flags.local_typedefs, type);
 952
 953             fprintf_filtered (stream, "{\n");
 954             if (TYPE_NFIELDS (type) == 0 && TYPE_NFN_FIELDS (type) == 0
 955                 && TYPE_TYPEDEF_FIELD_COUNT (type) == 0)
 956               {
 957                 if (TYPE_STUB (type))
 958                   fprintfi_filtered (level + 4, stream,
 959                                      _("<incomplete type>\n"));
 960                 else
 961                   fprintfi_filtered (level + 4, stream,
 962                                      _("<no data fields>\n"));
 963               }
 964
 965             /* Start off with no specific section type, so we can print
 966                one for the first field we find, and use that section type
 967                thereafter until we find another type.  */
 968
 969             section_type = s_none;
 970
 971             /* For a class, if all members are private, there's no need
 972                for a "private:" label; similarly, for a struct or union
 973                masquerading as a class, if all members are public, there's
 974                no need for a "public:" label.  */
 975
 976             if (TYPE_DECLARED_CLASS (type))
 977               {
 978                 QUIT;
 979                 len = TYPE_NFIELDS (type);
 980                 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 981                   if (!TYPE_FIELD_PRIVATE (type, i))
 982                     {
 983                       need_access_label = 1;
 984                       break;
 985                     }
 986                 QUIT;
 987                 if (!need_access_label)
 988                   {
 989                     len2 = TYPE_NFN_FIELDS (type);
 990                     for (j = 0; j < len2; j++)
 991                       {
 992                         len = TYPE_FN_FIELDLIST_LENGTH (type, j);
 993                         for (i = 0; i < len; i++)
 994                           if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type,
 995                                                                           j), i))
 996                             {
 997                               need_access_label = 1;
 998                               break;
 999                             }
1000                         if (need_access_label)
1001                           break;
1002                       }
1003                   }
1004               }
1005             else
1006               {
1007                 QUIT;
1008                 len = TYPE_NFIELDS (type);
1009                 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
1010                   if (TYPE_FIELD_PRIVATE (type, i)
1011                       || TYPE_FIELD_PROTECTED (type, i))
1012                     {
1013                       need_access_label = 1;
1014                       break;
1015                     }
1016                 QUIT;
1017                 if (!need_access_label)
1018                   {
1019                     len2 = TYPE_NFN_FIELDS (type);
1020                     for (j = 0; j < len2; j++)
1021                       {
1022                         QUIT;
1023                         len = TYPE_FN_FIELDLIST_LENGTH (type, j);
1024                         for (i = 0; i < len; i++)
1025                           if (TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type,
1026                                                                            j), i)
1027                               || TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type,
1028                                                                             j),
1029                                                         i))
1030                             {
1031                               need_access_label = 1;
1032                               break;
1033                             }
1034                         if (need_access_label)
1035                           break;
1036                       }
1037                   }
1038               }
1039
1040             /* If there is a base class for this type,
1041                do not print the field that it occupies.  */
1042
1043             len = TYPE_NFIELDS (type);
1044             vptr_fieldno = get_vptr_fieldno (type, &basetype);
1045             for (i = TYPE_N_BASECLASSES (type); i < len; i++)
1046               {
1047                 QUIT;
1048
1049                 /* If we have a virtual table pointer, omit it.  Even if
1050                    virtual table pointers are not specifically marked in
1051                    the debug info, they should be artificial.  */
1052                 if ((i == vptr_fieldno && type == basetype)
1053                     || TYPE_FIELD_ARTIFICIAL (type, i))
1054                   continue;
1055
1056                 if (need_access_label)
1057                   {
1058                     if (TYPE_FIELD_PROTECTED (type, i))
1059                       {
1060                         if (section_type != s_protected)
1061                           {
1062                             section_type = s_protected;
1063                             fprintfi_filtered (level + 2, stream,
1064                                                "protected:\n");
1065                           }
1066                       }
1067                     else if (TYPE_FIELD_PRIVATE (type, i))
1068                       {
1069                         if (section_type != s_private)
1070                           {
1071                             section_type = s_private;
1072                             fprintfi_filtered (level + 2, stream,
1073                                                "private:\n");
1074                           }
1075                       }
1076                     else
1077                       {
1078                         if (section_type != s_public)
1079                           {
1080                             section_type = s_public;
1081                             fprintfi_filtered (level + 2, stream,
1082                                                "public:\n");
1083                           }
1084                       }
1085                   }
1086
1087                 print_spaces_filtered (level + 4, stream);
1088                 if (field_is_static (&TYPE_FIELD (type, i)))
1089                   fprintf_filtered (stream, "static ");
1090                 c_print_type (TYPE_FIELD_TYPE (type, i),
1091                               TYPE_FIELD_NAME (type, i),
1092                               stream, show - 1, level + 4,
1093                               &local_flags);
1094                 if (!field_is_static (&TYPE_FIELD (type, i))
1095                     && TYPE_FIELD_PACKED (type, i))
1096                   {
1097                     /* It is a bitfield.  This code does not attempt
1098                        to look at the bitpos and reconstruct filler,
1099                        unnamed fields.  This would lead to misleading
1100                        results if the compiler does not put out fields
1101                        for such things (I don't know what it does).  */
1102                     fprintf_filtered (stream, " : %d",
1103                                       TYPE_FIELD_BITSIZE (type, i));
1104                   }
1105                 fprintf_filtered (stream, ";\n");
1106               }
1107
1108           /* If there are both fields and methods, put a blank line
1109              between them.  Make sure to count only method that we
1110              will display; artificial methods will be hidden.  */
1111           len = TYPE_NFN_FIELDS (type);
1112           if (!flags->print_methods)
1113             len = 0;
1114           real_len = 0;
1115           for (i = 0; i < len; i++)
1116             {
1117               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1118               int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
1119               int j;
1120
1121               for (j = 0; j < len2; j++)
1122                 if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
1123                   real_len++;
1124             }
1125           if (real_len > 0 && section_type != s_none)
1126             fprintf_filtered (stream, "\n");
1127
1128           /* C++: print out the methods.  */
1129           for (i = 0; i < len; i++)
1130             {
1131               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1132               int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
1133               const char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
1134               const char *name = type_name_no_tag (type);
1135               int is_constructor = name && strcmp (method_name,
1136                                                    name) == 0;
1137
1138               for (j = 0; j < len2; j++)
1139                 {
1140                   const char *mangled_name;
1141                   char *demangled_name;
1142                   struct cleanup *inner_cleanup;
1143                   const char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
1144                   int is_full_physname_constructor =
1145                     TYPE_FN_FIELD_CONSTRUCTOR (f, j)
1146                     || is_constructor_name (physname)
1147                     || is_destructor_name (physname)
1148                     || method_name[0] == '~';
1149
1150                   /* Do not print out artificial methods.  */
1151                   if (TYPE_FN_FIELD_ARTIFICIAL (f, j))
1152                     continue;
1153
1154                   inner_cleanup = make_cleanup (null_cleanup, NULL);
1155
1156                   QUIT;
1157                   if (TYPE_FN_FIELD_PROTECTED (f, j))
1158                     {
1159                       if (section_type != s_protected)
1160                         {
1161                           section_type = s_protected;
1162                           fprintfi_filtered (level + 2, stream,
1163                                              "protected:\n");
1164                         }
1165                     }
1166                   else if (TYPE_FN_FIELD_PRIVATE (f, j))
1167                     {
1168                       if (section_type != s_private)
1169                         {
1170                           section_type = s_private;
1171                           fprintfi_filtered (level + 2, stream,
1172                                              "private:\n");
1173                         }
1174                     }
1175                   else
1176                     {
1177                       if (section_type != s_public)
1178                         {
1179                           section_type = s_public;
1180                           fprintfi_filtered (level + 2, stream,
1181                                              "public:\n");
1182                         }
1183                     }
1184
1185                   print_spaces_filtered (level + 4, stream);
1186                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1187                     fprintf_filtered (stream, "virtual ");
1188                   else if (TYPE_FN_FIELD_STATIC_P (f, j))
1189                     fprintf_filtered (stream, "static ");
1190                   if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
1191                     {
1192                       /* Keep GDB from crashing here.  */
1193                       fprintf_filtered (stream,
1194                                         _("<undefined type> %s;\n"),
1195                                         TYPE_FN_FIELD_PHYSNAME (f, j));
1196                       break;
1197                     }
1198                   else if (!is_constructor      /* Constructors don't
1199                                                    have declared
1200                                                    types.  */
1201                            && !is_full_physname_constructor  /* " " */
1202                            && !is_type_conversion_operator (type, i, j))
1203                     {
1204                       c_print_type (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
1205                                     "", stream, -1, 0,
1206                                     &local_flags);
1207                       fputs_filtered (" ", stream);
1208                     }
1209                   if (TYPE_FN_FIELD_STUB (f, j))
1210                     {
1211                       char *tem;
1212
1213                       /* Build something we can demangle.  */
1214                       tem = gdb_mangle_name (type, i, j);
1215                       make_cleanup (xfree, tem);
1216                       mangled_name = tem;
1217                     }
1218                   else
1219                     mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
1220
1221                   demangled_name =
1222                     cplus_demangle (mangled_name,
1223                                     DMGL_ANSI | DMGL_PARAMS);
1224                   if (demangled_name == NULL)
1225                     {
1226                       /* In some cases (for instance with the HP
1227                          demangling), if a function has more than 10
1228                          arguments, the demangling will fail.
1229                          Let's try to reconstruct the function
1230                          signature from the symbol information.  */
1231                       if (!TYPE_FN_FIELD_STUB (f, j))
1232                         {
1233                           int staticp = TYPE_FN_FIELD_STATIC_P (f, j);
1234                           struct type *mtype = TYPE_FN_FIELD_TYPE (f, j);
1235
1236                           cp_type_print_method_args (mtype,
1237                                                      "",
1238                                                      method_name,
1239                                                      staticp,
1240                                                      stream, &local_flags);
1241                         }
1242                       else
1243                         fprintf_filtered (stream,
1244                                           _("<badly mangled name '%s'>"),
1245                                           mangled_name);
1246                     }
1247                   else
1248                     {
1249                       char *p;
1250                       char *demangled_no_class
1251                         = remove_qualifiers (demangled_name);
1252
1253                       /* Get rid of the `static' appended by the
1254                          demangler.  */
1255                       p = strstr (demangled_no_class, " static");
1256                       if (p != NULL)
1257                         {
1258                           int length = p - demangled_no_class;
1259                           char *demangled_no_static;
1260
1261                           demangled_no_static
1262                             = (char *) xmalloc (length + 1);
1263                           strncpy (demangled_no_static,
1264                                    demangled_no_class, length);
1265                           *(demangled_no_static + length) = '\0';
1266                           fputs_filtered (demangled_no_static, stream);
1267                           xfree (demangled_no_static);
1268                         }
1269                       else
1270                         fputs_filtered (demangled_no_class, stream);
1271                       xfree (demangled_name);
1272                     }
1273
1274                   do_cleanups (inner_cleanup);
1275
1276                   fprintf_filtered (stream, ";\n");
1277                 }
1278             }
1279
1280           /* Print typedefs defined in this class.  */
1281
1282           if (TYPE_TYPEDEF_FIELD_COUNT (type) != 0 && flags->print_typedefs)
1283             {
1284               if (TYPE_NFIELDS (type) != 0 || TYPE_NFN_FIELDS (type) != 0)
1285                 fprintf_filtered (stream, "\n");
1286
1287                 for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (type); i++)
1288                   {
1289                     struct type *target = TYPE_TYPEDEF_FIELD_TYPE (type, i);
1290                     struct typedef_hash_table *table2;
1291
1292                     /* Dereference the typedef declaration itself.  */
1293                     gdb_assert (TYPE_CODE (target) == TYPE_CODE_TYPEDEF);
1294                     target = TYPE_TARGET_TYPE (target);
1295
1296                     print_spaces_filtered (level + 4, stream);
1297                     fprintf_filtered (stream, "typedef ");
1298
1299                     /* We want to print typedefs with substitutions
1300                        from the template parameters or globally-known
1301                        typedefs but not local typedefs.  */
1302                     c_print_type (target,
1303                                   TYPE_TYPEDEF_FIELD_NAME (type, i),
1304                                   stream, show - 1, level + 4,
1305                                   &semi_local_flags);
1306                     fprintf_filtered (stream, ";\n");
1307                   }
1308               }
1309
1310             fprintfi_filtered (level, stream, "}");
1311           }
1312
1313         do_cleanups (local_cleanups);
1314       }
1315       break;
1316
1317     case TYPE_CODE_ENUM:
1318       c_type_print_modifier (type, stream, 0, 1);
1319       fprintf_filtered (stream, "enum ");
1320       /* Print the tag name if it exists.
1321          The aCC compiler emits a spurious
1322          "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1323          tag for unnamed struct/union/enum's, which we don't
1324          want to print.  */
1325       if (TYPE_TAG_NAME (type) != NULL
1326           && strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
1327         {
1328           print_name_maybe_canonical (TYPE_TAG_NAME (type), flags, stream);
1329           if (show > 0)
1330             fputs_filtered (" ", stream);
1331         }
1332
1333       wrap_here ("    ");
1334       if (show < 0)
1335         {
1336           /* If we just printed a tag name, no need to print anything
1337              else.  */
1338           if (TYPE_TAG_NAME (type) == NULL)
1339             fprintf_filtered (stream, "{...}");
1340         }
1341       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1342         {
1343           LONGEST lastval = 0;
1344
1345           fprintf_filtered (stream, "{");
1346           len = TYPE_NFIELDS (type);
1347           for (i = 0; i < len; i++)
1348             {
1349               QUIT;
1350               if (i)
1351                 fprintf_filtered (stream, ", ");
1352               wrap_here ("    ");
1353               fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1354               if (lastval != TYPE_FIELD_ENUMVAL (type, i))
1355                 {
1356                   fprintf_filtered (stream, " = %s",
1357                                     plongest (TYPE_FIELD_ENUMVAL (type, i)));
1358                   lastval = TYPE_FIELD_ENUMVAL (type, i);
1359                 }
1360               lastval++;
1361             }
1362           fprintf_filtered (stream, "}");
1363         }
1364       break;
1365
1366     case TYPE_CODE_VOID:
1367       fprintf_filtered (stream, "void");
1368       break;
1369
1370     case TYPE_CODE_UNDEF:
1371       fprintf_filtered (stream, _("struct <unknown>"));
1372       break;
1373
1374     case TYPE_CODE_ERROR:
1375       fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
1376       break;
1377
1378     case TYPE_CODE_RANGE:
1379       /* This should not occur.  */
1380       fprintf_filtered (stream, _("<range type>"));
1381       break;
1382
1383     case TYPE_CODE_NAMESPACE:
1384       fputs_filtered ("namespace ", stream);
1385       fputs_filtered (TYPE_TAG_NAME (type), stream);
1386       break;
1387
1388     default:
1389       /* Handle types not explicitly handled by the other cases, such
1390          as fundamental types.  For these, just print whatever the
1391          type name is, as recorded in the type itself.  If there is no
1392          type name, then complain.  */
1393       if (TYPE_NAME (type) != NULL)
1394         {
1395           c_type_print_modifier (type, stream, 0, 1);
1396           print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
1397         }
1398       else
1399         {
1400           /* At least for dump_symtab, it is important that this not
1401              be an error ().  */
1402           fprintf_filtered (stream, _("<invalid type code %d>"),
1403                             TYPE_CODE (type));
1404         }
1405       break;
1406     }
1407 }