contrib/gdb-7/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;
 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         if (get_array_bounds (type, &low_bound, &high_bound))
 693           fprintf_filtered (stream, "%s",
 694                             plongest (high_bound - low_bound + 1));
 695         fprintf_filtered (stream, (is_vector ? ")))" : "]"));
 696
 697         c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
 698                                      show, 0, 0, flags);
 699       }
 700       break;
 701
 702     case TYPE_CODE_MEMBERPTR:
 703       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
 704                                    show, 0, 0, flags);
 705       break;
 706
 707     case TYPE_CODE_METHODPTR:
 708       fprintf_filtered (stream, ")");
 709       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
 710                                    show, 0, 0, flags);
 711       break;
 712
 713     case TYPE_CODE_PTR:
 714     case TYPE_CODE_REF:
 715       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
 716                                    show, 1, 0, flags);
 717       break;
 718
 719     case TYPE_CODE_METHOD:
 720     case TYPE_CODE_FUNC:
 721       if (passed_a_ptr)
 722         fprintf_filtered (stream, ")");
 723       if (!demangled_args)
 724         c_type_print_args (type, stream, 0, current_language->la_language,
 725                            flags);
 726       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
 727                                    show, passed_a_ptr, 0, flags);
 728       break;
 729
 730     case TYPE_CODE_TYPEDEF:
 731       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
 732                                    show, passed_a_ptr, 0, flags);
 733       break;
 734
 735     case TYPE_CODE_UNDEF:
 736     case TYPE_CODE_STRUCT:
 737     case TYPE_CODE_UNION:
 738     case TYPE_CODE_ENUM:
 739     case TYPE_CODE_INT:
 740     case TYPE_CODE_FLT:
 741     case TYPE_CODE_VOID:
 742     case TYPE_CODE_ERROR:
 743     case TYPE_CODE_CHAR:
 744     case TYPE_CODE_BOOL:
 745     case TYPE_CODE_SET:
 746     case TYPE_CODE_RANGE:
 747     case TYPE_CODE_STRING:
 748     case TYPE_CODE_COMPLEX:
 749     case TYPE_CODE_NAMESPACE:
 750     case TYPE_CODE_DECFLOAT:
 751       /* These types do not need a suffix.  They are listed so that
 752          gcc -Wall will report types that may not have been
 753          considered.  */
 754       break;
 755     default:
 756       error (_("type not handled in c_type_print_varspec_suffix()"));
 757       break;
 758     }
 759 }
 760
 761 /* A helper for c_type_print_base that displays template
 762    parameters and their bindings, if needed.
 763
 764    TABLE is the local bindings table to use.  If NULL, no printing is
 765    done.  Note that, at this point, TABLE won't have any useful
 766    information in it -- but it is also used as a flag to
 767    print_name_maybe_canonical to activate searching the global typedef
 768    table.
 769
 770    TYPE is the type whose template arguments are being displayed.
 771
 772    STREAM is the stream on which to print.  */
 773
 774 static void
 775 c_type_print_template_args (const struct type_print_options *flags,
 776                             struct type *type, struct ui_file *stream)
 777 {
 778   int first = 1, i;
 779
 780   if (flags->raw)
 781     return;
 782
 783   for (i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (type); ++i)
 784     {
 785       struct symbol *sym = TYPE_TEMPLATE_ARGUMENT (type, i);
 786
 787       if (SYMBOL_CLASS (sym) != LOC_TYPEDEF)
 788         continue;
 789
 790       if (first)
 791         {
 792           wrap_here ("    ");
 793           fprintf_filtered (stream, _("[with %s = "),
 794                             SYMBOL_LINKAGE_NAME (sym));
 795           first = 0;
 796         }
 797       else
 798         {
 799           fputs_filtered (", ", stream);
 800           wrap_here ("         ");
 801           fprintf_filtered (stream, "%s = ", SYMBOL_LINKAGE_NAME (sym));
 802         }
 803
 804       c_print_type (SYMBOL_TYPE (sym), "", stream, -1, 0, flags);
 805     }
 806
 807   if (!first)
 808     fputs_filtered (_("] "), stream);
 809 }
 810
 811 /* Print the name of the type (or the ultimate pointer target,
 812    function value or array element), or the description of a structure
 813    or union.
 814
 815    SHOW positive means print details about the type (e.g. enum
 816    values), and print structure elements passing SHOW - 1 for show.
 817
 818    SHOW negative means just print the type name or struct tag if there
 819    is one.  If there is no name, print something sensible but concise
 820    like "struct {...}".
 821
 822    SHOW zero means just print the type name or struct tag if there is
 823    one.  If there is no name, print something sensible but not as
 824    concise like "struct {int x; int y;}".
 825
 826    LEVEL is the number of spaces to indent by.
 827    We increase it for some recursive calls.  */
 828
 829 void
 830 c_type_print_base (struct type *type, struct ui_file *stream,
 831                    int show, int level, const struct type_print_options *flags)
 832 {
 833   int i;
 834   int len, real_len;
 835   enum
 836     {
 837       s_none, s_public, s_private, s_protected
 838     }
 839   section_type;
 840   int need_access_label = 0;
 841   int j, len2;
 842
 843   QUIT;
 844
 845   if (type == NULL)
 846     {
 847       fputs_filtered (_("<type unknown>"), stream);
 848       return;
 849     }
 850
 851   /* When SHOW is zero or less, and there is a valid type name, then
 852      always just print the type name directly from the type.  */
 853   /* If we have "typedef struct foo {. . .} bar;" do we want to print
 854      it as "struct foo" or as "bar"?  Pick the latter, because C++
 855      folk tend to expect things like "class5 *foo" rather than "struct
 856      class5 *foo".  */
 857
 858   if (show <= 0
 859       && TYPE_NAME (type) != NULL)
 860     {
 861       c_type_print_modifier (type, stream, 0, 1);
 862       print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
 863       return;
 864     }
 865
 866   CHECK_TYPEDEF (type);
 867
 868   switch (TYPE_CODE (type))
 869     {
 870     case TYPE_CODE_TYPEDEF:
 871       /* If we get here, the typedef doesn't have a name, and we
 872          couldn't resolve TYPE_TARGET_TYPE.  Not much we can do.  */
 873       gdb_assert (TYPE_NAME (type) == NULL);
 874       gdb_assert (TYPE_TARGET_TYPE (type) == NULL);
 875       fprintf_filtered (stream, _("<unnamed typedef>"));
 876       break;
 877
 878     case TYPE_CODE_ARRAY:
 879     case TYPE_CODE_PTR:
 880     case TYPE_CODE_MEMBERPTR:
 881     case TYPE_CODE_REF:
 882     case TYPE_CODE_FUNC:
 883     case TYPE_CODE_METHOD:
 884     case TYPE_CODE_METHODPTR:
 885       c_type_print_base (TYPE_TARGET_TYPE (type),
 886                          stream, show, level, flags);
 887       break;
 888
 889     case TYPE_CODE_STRUCT:
 890     case TYPE_CODE_UNION:
 891       {
 892         struct type_print_options local_flags = *flags;
 893         struct type_print_options semi_local_flags = *flags;
 894         struct cleanup *local_cleanups = make_cleanup (null_cleanup, NULL);
 895
 896         local_flags.local_typedefs = NULL;
 897         semi_local_flags.local_typedefs = NULL;
 898
 899         if (!flags->raw)
 900           {
 901             if (flags->local_typedefs)
 902               local_flags.local_typedefs
 903                 = copy_typedef_hash (flags->local_typedefs);
 904             else
 905               local_flags.local_typedefs = create_typedef_hash ();
 906
 907             make_cleanup_free_typedef_hash (local_flags.local_typedefs);
 908           }
 909
 910         c_type_print_modifier (type, stream, 0, 1);
 911         if (TYPE_CODE (type) == TYPE_CODE_UNION)
 912           fprintf_filtered (stream, "union ");
 913         else if (TYPE_DECLARED_CLASS (type))
 914           fprintf_filtered (stream, "class ");
 915         else
 916           fprintf_filtered (stream, "struct ");
 917
 918         /* Print the tag if it exists.  The HP aCC compiler emits a
 919            spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
 920            enum}" tag for unnamed struct/union/enum's, which we don't
 921            want to print.  */
 922         if (TYPE_TAG_NAME (type) != NULL
 923             && strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
 924           {
 925             /* When printing the tag name, we are still effectively
 926                printing in the outer context, hence the use of FLAGS
 927                here.  */
 928             print_name_maybe_canonical (TYPE_TAG_NAME (type), flags, stream);
 929             if (show > 0)
 930               fputs_filtered (" ", stream);
 931           }
 932
 933         if (show < 0)
 934           {
 935             /* If we just printed a tag name, no need to print anything
 936                else.  */
 937             if (TYPE_TAG_NAME (type) == NULL)
 938               fprintf_filtered (stream, "{...}");
 939           }
 940         else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
 941           {
 942             struct type *basetype;
 943             int vptr_fieldno;
 944
 945             c_type_print_template_args (&local_flags, type, stream);
 946
 947             /* Add in template parameters when printing derivation info.  */
 948             add_template_parameters (local_flags.local_typedefs, type);
 949             cp_type_print_derivation_info (stream, type, &local_flags);
 950
 951             /* This holds just the global typedefs and the template
 952                parameters.  */
 953             semi_local_flags.local_typedefs
 954               = copy_typedef_hash (local_flags.local_typedefs);
 955             if (semi_local_flags.local_typedefs)
 956               make_cleanup_free_typedef_hash (semi_local_flags.local_typedefs);
 957
 958             /* Now add in the local typedefs.  */
 959             recursively_update_typedef_hash (local_flags.local_typedefs, type);
 960
 961             fprintf_filtered (stream, "{\n");
 962             if (TYPE_NFIELDS (type) == 0 && TYPE_NFN_FIELDS (type) == 0
 963                 && TYPE_TYPEDEF_FIELD_COUNT (type) == 0)
 964               {
 965                 if (TYPE_STUB (type))
 966                   fprintfi_filtered (level + 4, stream,
 967                                      _("<incomplete type>\n"));
 968                 else
 969                   fprintfi_filtered (level + 4, stream,
 970                                      _("<no data fields>\n"));
 971               }
 972
 973             /* Start off with no specific section type, so we can print
 974                one for the first field we find, and use that section type
 975                thereafter until we find another type.  */
 976
 977             section_type = s_none;
 978
 979             /* For a class, if all members are private, there's no need
 980                for a "private:" label; similarly, for a struct or union
 981                masquerading as a class, if all members are public, there's
 982                no need for a "public:" label.  */
 983
 984             if (TYPE_DECLARED_CLASS (type))
 985               {
 986                 QUIT;
 987                 len = TYPE_NFIELDS (type);
 988                 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 989                   if (!TYPE_FIELD_PRIVATE (type, i))
 990                     {
 991                       need_access_label = 1;
 992                       break;
 993                     }
 994                 QUIT;
 995                 if (!need_access_label)
 996                   {
 997                     len2 = TYPE_NFN_FIELDS (type);
 998                     for (j = 0; j < len2; j++)
 999                       {
1000                         len = TYPE_FN_FIELDLIST_LENGTH (type, j);
1001                         for (i = 0; i < len; i++)
1002                           if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type,
1003                                                                           j), i))
1004                             {
1005                               need_access_label = 1;
1006                               break;
1007                             }
1008                         if (need_access_label)
1009                           break;
1010                       }
1011                   }
1012               }
1013             else
1014               {
1015                 QUIT;
1016                 len = TYPE_NFIELDS (type);
1017                 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
1018                   if (TYPE_FIELD_PRIVATE (type, i)
1019                       || TYPE_FIELD_PROTECTED (type, i))
1020                     {
1021                       need_access_label = 1;
1022                       break;
1023                     }
1024                 QUIT;
1025                 if (!need_access_label)
1026                   {
1027                     len2 = TYPE_NFN_FIELDS (type);
1028                     for (j = 0; j < len2; j++)
1029                       {
1030                         QUIT;
1031                         len = TYPE_FN_FIELDLIST_LENGTH (type, j);
1032                         for (i = 0; i < len; i++)
1033                           if (TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type,
1034                                                                            j), i)
1035                               || TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type,
1036                                                                             j),
1037                                                         i))
1038                             {
1039                               need_access_label = 1;
1040                               break;
1041                             }
1042                         if (need_access_label)
1043                           break;
1044                       }
1045                   }
1046               }
1047
1048             /* If there is a base class for this type,
1049                do not print the field that it occupies.  */
1050
1051             len = TYPE_NFIELDS (type);
1052             vptr_fieldno = get_vptr_fieldno (type, &basetype);
1053             for (i = TYPE_N_BASECLASSES (type); i < len; i++)
1054               {
1055                 QUIT;
1056
1057                 /* If we have a virtual table pointer, omit it.  Even if
1058                    virtual table pointers are not specifically marked in
1059                    the debug info, they should be artificial.  */
1060                 if ((i == vptr_fieldno && type == basetype)
1061                     || TYPE_FIELD_ARTIFICIAL (type, i))
1062                   continue;
1063
1064                 if (need_access_label)
1065                   {
1066                     if (TYPE_FIELD_PROTECTED (type, i))
1067                       {
1068                         if (section_type != s_protected)
1069                           {
1070                             section_type = s_protected;
1071                             fprintfi_filtered (level + 2, stream,
1072                                                "protected:\n");
1073                           }
1074                       }
1075                     else if (TYPE_FIELD_PRIVATE (type, i))
1076                       {
1077                         if (section_type != s_private)
1078                           {
1079                             section_type = s_private;
1080                             fprintfi_filtered (level + 2, stream,
1081                                                "private:\n");
1082                           }
1083                       }
1084                     else
1085                       {
1086                         if (section_type != s_public)
1087                           {
1088                             section_type = s_public;
1089                             fprintfi_filtered (level + 2, stream,
1090                                                "public:\n");
1091                           }
1092                       }
1093                   }
1094
1095                 print_spaces_filtered (level + 4, stream);
1096                 if (field_is_static (&TYPE_FIELD (type, i)))
1097                   fprintf_filtered (stream, "static ");
1098                 c_print_type (TYPE_FIELD_TYPE (type, i),
1099                               TYPE_FIELD_NAME (type, i),
1100                               stream, show - 1, level + 4,
1101                               &local_flags);
1102                 if (!field_is_static (&TYPE_FIELD (type, i))
1103                     && TYPE_FIELD_PACKED (type, i))
1104                   {
1105                     /* It is a bitfield.  This code does not attempt
1106                        to look at the bitpos and reconstruct filler,
1107                        unnamed fields.  This would lead to misleading
1108                        results if the compiler does not put out fields
1109                        for such things (I don't know what it does).  */
1110                     fprintf_filtered (stream, " : %d",
1111                                       TYPE_FIELD_BITSIZE (type, i));
1112                   }
1113                 fprintf_filtered (stream, ";\n");
1114               }
1115
1116           /* If there are both fields and methods, put a blank line
1117              between them.  Make sure to count only method that we
1118              will display; artificial methods will be hidden.  */
1119           len = TYPE_NFN_FIELDS (type);
1120           if (!flags->print_methods)
1121             len = 0;
1122           real_len = 0;
1123           for (i = 0; i < len; i++)
1124             {
1125               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1126               int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
1127               int j;
1128
1129               for (j = 0; j < len2; j++)
1130                 if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
1131                   real_len++;
1132             }
1133           if (real_len > 0 && section_type != s_none)
1134             fprintf_filtered (stream, "\n");
1135
1136           /* C++: print out the methods.  */
1137           for (i = 0; i < len; i++)
1138             {
1139               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1140               int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
1141               const char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
1142               const char *name = type_name_no_tag (type);
1143               int is_constructor = name && strcmp (method_name,
1144                                                    name) == 0;
1145
1146               for (j = 0; j < len2; j++)
1147                 {
1148                   const char *mangled_name;
1149                   char *demangled_name;
1150                   struct cleanup *inner_cleanup;
1151                   const char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
1152                   int is_full_physname_constructor =
1153                     TYPE_FN_FIELD_CONSTRUCTOR (f, j)
1154                     || is_constructor_name (physname)
1155                     || is_destructor_name (physname)
1156                     || method_name[0] == '~';
1157
1158                   /* Do not print out artificial methods.  */
1159                   if (TYPE_FN_FIELD_ARTIFICIAL (f, j))
1160                     continue;
1161
1162                   inner_cleanup = make_cleanup (null_cleanup, NULL);
1163
1164                   QUIT;
1165                   if (TYPE_FN_FIELD_PROTECTED (f, j))
1166                     {
1167                       if (section_type != s_protected)
1168                         {
1169                           section_type = s_protected;
1170                           fprintfi_filtered (level + 2, stream,
1171                                              "protected:\n");
1172                         }
1173                     }
1174                   else if (TYPE_FN_FIELD_PRIVATE (f, j))
1175                     {
1176                       if (section_type != s_private)
1177                         {
1178                           section_type = s_private;
1179                           fprintfi_filtered (level + 2, stream,
1180                                              "private:\n");
1181                         }
1182                     }
1183                   else
1184                     {
1185                       if (section_type != s_public)
1186                         {
1187                           section_type = s_public;
1188                           fprintfi_filtered (level + 2, stream,
1189                                              "public:\n");
1190                         }
1191                     }
1192
1193                   print_spaces_filtered (level + 4, stream);
1194                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1195                     fprintf_filtered (stream, "virtual ");
1196                   else if (TYPE_FN_FIELD_STATIC_P (f, j))
1197                     fprintf_filtered (stream, "static ");
1198                   if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
1199                     {
1200                       /* Keep GDB from crashing here.  */
1201                       fprintf_filtered (stream,
1202                                         _("<undefined type> %s;\n"),
1203                                         TYPE_FN_FIELD_PHYSNAME (f, j));
1204                       break;
1205                     }
1206                   else if (!is_constructor      /* Constructors don't
1207                                                    have declared
1208                                                    types.  */
1209                            && !is_full_physname_constructor  /* " " */
1210                            && !is_type_conversion_operator (type, i, j))
1211                     {
1212                       c_print_type (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
1213                                     "", stream, -1, 0,
1214                                     &local_flags);
1215                       fputs_filtered (" ", stream);
1216                     }
1217                   if (TYPE_FN_FIELD_STUB (f, j))
1218                     {
1219                       char *tem;
1220
1221                       /* Build something we can demangle.  */
1222                       tem = gdb_mangle_name (type, i, j);
1223                       make_cleanup (xfree, tem);
1224                       mangled_name = tem;
1225                     }
1226                   else
1227                     mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
1228
1229                   demangled_name =
1230                     cplus_demangle (mangled_name,
1231                                     DMGL_ANSI | DMGL_PARAMS);
1232                   if (demangled_name == NULL)
1233                     {
1234                       /* In some cases (for instance with the HP
1235                          demangling), if a function has more than 10
1236                          arguments, the demangling will fail.
1237                          Let's try to reconstruct the function
1238                          signature from the symbol information.  */
1239                       if (!TYPE_FN_FIELD_STUB (f, j))
1240                         {
1241                           int staticp = TYPE_FN_FIELD_STATIC_P (f, j);
1242                           struct type *mtype = TYPE_FN_FIELD_TYPE (f, j);
1243
1244                           cp_type_print_method_args (mtype,
1245                                                      "",
1246                                                      method_name,
1247                                                      staticp,
1248                                                      stream, &local_flags);
1249                         }
1250                       else
1251                         fprintf_filtered (stream,
1252                                           _("<badly mangled name '%s'>"),
1253                                           mangled_name);
1254                     }
1255                   else
1256                     {
1257                       char *p;
1258                       char *demangled_no_class
1259                         = remove_qualifiers (demangled_name);
1260
1261                       /* Get rid of the `static' appended by the
1262                          demangler.  */
1263                       p = strstr (demangled_no_class, " static");
1264                       if (p != NULL)
1265                         {
1266                           int length = p - demangled_no_class;
1267                           char *demangled_no_static;
1268
1269                           demangled_no_static
1270                             = (char *) xmalloc (length + 1);
1271                           strncpy (demangled_no_static,
1272                                    demangled_no_class, length);
1273                           *(demangled_no_static + length) = '\0';
1274                           fputs_filtered (demangled_no_static, stream);
1275                           xfree (demangled_no_static);
1276                         }
1277                       else
1278                         fputs_filtered (demangled_no_class, stream);
1279                       xfree (demangled_name);
1280                     }
1281
1282                   do_cleanups (inner_cleanup);
1283
1284                   fprintf_filtered (stream, ";\n");
1285                 }
1286             }
1287
1288           /* Print typedefs defined in this class.  */
1289
1290           if (TYPE_TYPEDEF_FIELD_COUNT (type) != 0 && flags->print_typedefs)
1291             {
1292               if (TYPE_NFIELDS (type) != 0 || TYPE_NFN_FIELDS (type) != 0)
1293                 fprintf_filtered (stream, "\n");
1294
1295                 for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (type); i++)
1296                   {
1297                     struct type *target = TYPE_TYPEDEF_FIELD_TYPE (type, i);
1298
1299                     /* Dereference the typedef declaration itself.  */
1300                     gdb_assert (TYPE_CODE (target) == TYPE_CODE_TYPEDEF);
1301                     target = TYPE_TARGET_TYPE (target);
1302
1303                     print_spaces_filtered (level + 4, stream);
1304                     fprintf_filtered (stream, "typedef ");
1305
1306                     /* We want to print typedefs with substitutions
1307                        from the template parameters or globally-known
1308                        typedefs but not local typedefs.  */
1309                     c_print_type (target,
1310                                   TYPE_TYPEDEF_FIELD_NAME (type, i),
1311                                   stream, show - 1, level + 4,
1312                                   &semi_local_flags);
1313                     fprintf_filtered (stream, ";\n");
1314                   }
1315               }
1316
1317             fprintfi_filtered (level, stream, "}");
1318           }
1319
1320         do_cleanups (local_cleanups);
1321       }
1322       break;
1323
1324     case TYPE_CODE_ENUM:
1325       c_type_print_modifier (type, stream, 0, 1);
1326       fprintf_filtered (stream, "enum ");
1327       /* Print the tag name if it exists.
1328          The aCC compiler emits a spurious
1329          "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1330          tag for unnamed struct/union/enum's, which we don't
1331          want to print.  */
1332       if (TYPE_TAG_NAME (type) != NULL
1333           && strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
1334         {
1335           print_name_maybe_canonical (TYPE_TAG_NAME (type), flags, stream);
1336           if (show > 0)
1337             fputs_filtered (" ", stream);
1338         }
1339
1340       wrap_here ("    ");
1341       if (show < 0)
1342         {
1343           /* If we just printed a tag name, no need to print anything
1344              else.  */
1345           if (TYPE_TAG_NAME (type) == NULL)
1346             fprintf_filtered (stream, "{...}");
1347         }
1348       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1349         {
1350           LONGEST lastval = 0;
1351
1352           fprintf_filtered (stream, "{");
1353           len = TYPE_NFIELDS (type);
1354           for (i = 0; i < len; i++)
1355             {
1356               QUIT;
1357               if (i)
1358                 fprintf_filtered (stream, ", ");
1359               wrap_here ("    ");
1360               fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1361               if (lastval != TYPE_FIELD_ENUMVAL (type, i))
1362                 {
1363                   fprintf_filtered (stream, " = %s",
1364                                     plongest (TYPE_FIELD_ENUMVAL (type, i)));
1365                   lastval = TYPE_FIELD_ENUMVAL (type, i);
1366                 }
1367               lastval++;
1368             }
1369           fprintf_filtered (stream, "}");
1370         }
1371       break;
1372
1373     case TYPE_CODE_VOID:
1374       fprintf_filtered (stream, "void");
1375       break;
1376
1377     case TYPE_CODE_UNDEF:
1378       fprintf_filtered (stream, _("struct <unknown>"));
1379       break;
1380
1381     case TYPE_CODE_ERROR:
1382       fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
1383       break;
1384
1385     case TYPE_CODE_RANGE:
1386       /* This should not occur.  */
1387       fprintf_filtered (stream, _("<range type>"));
1388       break;
1389
1390     case TYPE_CODE_NAMESPACE:
1391       fputs_filtered ("namespace ", stream);
1392       fputs_filtered (TYPE_TAG_NAME (type), stream);
1393       break;
1394
1395     default:
1396       /* Handle types not explicitly handled by the other cases, such
1397          as fundamental types.  For these, just print whatever the
1398          type name is, as recorded in the type itself.  If there is no
1399          type name, then complain.  */
1400       if (TYPE_NAME (type) != NULL)
1401         {
1402           c_type_print_modifier (type, stream, 0, 1);
1403           print_name_maybe_canonical (TYPE_NAME (type), flags, stream);
1404         }
1405       else
1406         {
1407           /* At least for dump_symtab, it is important that this not
1408              be an error ().  */
1409           fprintf_filtered (stream, _("<invalid type code %d>"),
1410                             TYPE_CODE (type));
1411         }
1412       break;
1413     }
1414 }