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