gdb/c-typeprint.c

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