gdb/c-typeprint.c

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