gdb/c-typeprint.c

   1 /* Support for printing C and C++ types for GDB, the GNU debugger.
   2    Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2006, 2007, 2008
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "gdb_obstack.h"
  23 #include "bfd.h"                /* Binary File Description */
  24 #include "symtab.h"
  25 #include "gdbtypes.h"
  26 #include "expression.h"
  27 #include "value.h"
  28 #include "gdbcore.h"
  29 #include "target.h"
  30 #include "language.h"
  31 #include "demangle.h"
  32 #include "c-lang.h"
  33 #include "typeprint.h"
  34 #include "cp-abi.h"
  35
  36 #include "gdb_string.h"
  37 #include <errno.h>
  38
  39 static void cp_type_print_method_args (struct type *mtype, char *prefix,
  40                                        char *varstring, int staticp,
  41                                        struct ui_file *stream);
  42
  43 static void c_type_print_args (struct type *, struct ui_file *);
  44
  45 static void cp_type_print_derivation_info (struct ui_file *, struct type *);
  46
  47 static void c_type_print_varspec_prefix (struct type *, struct ui_file *, int,
  48                                          int, int);
  49
  50 /* Print "const", "volatile", or address space modifiers. */
  51 static void c_type_print_modifier (struct type *, struct ui_file *,
  52                                    int, int);
  53 \f
  54
  55
  56
  57 /* LEVEL is the depth to indent lines by.  */
  58
  59 void
  60 c_print_type (struct type *type, char *varstring, struct ui_file *stream,
  61               int show, int level)
  62 {
  63   enum type_code code;
  64   int demangled_args;
  65   int need_post_space;
  66
  67   if (show > 0)
  68     CHECK_TYPEDEF (type);
  69
  70   c_type_print_base (type, stream, show, level);
  71   code = TYPE_CODE (type);
  72   if ((varstring != NULL && *varstring != '\0')
  73       ||
  74   /* Need a space if going to print stars or brackets;
  75      but not if we will print just a type name.  */
  76       ((show > 0 || TYPE_NAME (type) == 0)
  77        &&
  78        (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
  79         || code == TYPE_CODE_METHOD
  80         || code == TYPE_CODE_ARRAY
  81         || code == TYPE_CODE_MEMBERPTR
  82         || code == TYPE_CODE_METHODPTR
  83         || code == TYPE_CODE_REF)))
  84     fputs_filtered (" ", stream);
  85   need_post_space = (varstring != NULL && strcmp (varstring, "") != 0);
  86   c_type_print_varspec_prefix (type, stream, show, 0, need_post_space);
  87
  88   if (varstring != NULL)
  89     {
  90       fputs_filtered (varstring, stream);
  91
  92       /* For demangled function names, we have the arglist as part of the name,
  93          so don't print an additional pair of ()'s */
  94
  95       demangled_args = strchr (varstring, '(') != NULL;
  96       c_type_print_varspec_suffix (type, stream, show, 0, demangled_args);
  97     }
  98 }
  99
 100 /* If TYPE is a derived type, then print out derivation information.
 101    Print only the actual base classes of this type, not the base classes
 102    of the base classes.  I.E.  for the derivation hierarchy:
 103
 104    class A { int a; };
 105    class B : public A {int b; };
 106    class C : public B {int c; };
 107
 108    Print the type of class C as:
 109
 110    class C : public B {
 111    int c;
 112    }
 113
 114    Not as the following (like gdb used to), which is not legal C++ syntax for
 115    derived types and may be confused with the multiple inheritance form:
 116
 117    class C : public B : public A {
 118    int c;
 119    }
 120
 121    In general, gdb should try to print the types as closely as possible to
 122    the form that they appear in the source code.
 123    Note that in case of protected derivation gcc will not say 'protected'
 124    but 'private'. The HP's aCC compiler emits specific information for
 125    derivation via protected inheritance, so gdb can print it out */
 126
 127 static void
 128 cp_type_print_derivation_info (struct ui_file *stream, struct type *type)
 129 {
 130   char *name;
 131   int i;
 132
 133   for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
 134     {
 135       fputs_filtered (i == 0 ? ": " : ", ", stream);
 136       fprintf_filtered (stream, "%s%s ",
 137                         BASETYPE_VIA_PUBLIC (type, i) ? "public"
 138                : (TYPE_FIELD_PROTECTED (type, i) ? "protected" : "private"),
 139                         BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : "");
 140       name = type_name_no_tag (TYPE_BASECLASS (type, i));
 141       fprintf_filtered (stream, "%s", name ? name : "(null)");
 142     }
 143   if (i > 0)
 144     {
 145       fputs_filtered (" ", stream);
 146     }
 147 }
 148
 149 /* Print the C++ method arguments ARGS to the file STREAM.  */
 150
 151 static void
 152 cp_type_print_method_args (struct type *mtype, char *prefix, char *varstring,
 153                            int staticp, struct ui_file *stream)
 154 {
 155   struct field *args = TYPE_FIELDS (mtype);
 156   int nargs = TYPE_NFIELDS (mtype);
 157   int varargs = TYPE_VARARGS (mtype);
 158   int i;
 159
 160   fprintf_symbol_filtered (stream, prefix, language_cplus, DMGL_ANSI);
 161   fprintf_symbol_filtered (stream, varstring, language_cplus, DMGL_ANSI);
 162   fputs_filtered ("(", stream);
 163
 164   /* Skip the class variable.  */
 165   i = staticp ? 0 : 1;
 166   if (nargs > i)
 167     {
 168       while (i < nargs)
 169         {
 170           type_print (args[i++].type, "", stream, 0);
 171
 172           if (i == nargs && varargs)
 173             fprintf_filtered (stream, ", ...");
 174           else if (i < nargs)
 175             fprintf_filtered (stream, ", ");
 176         }
 177     }
 178   else if (varargs)
 179     fprintf_filtered (stream, "...");
 180   else if (current_language->la_language == language_cplus)
 181     fprintf_filtered (stream, "void");
 182
 183   fprintf_filtered (stream, ")");
 184 }
 185
 186
 187 /* Print any asterisks or open-parentheses needed before the
 188    variable name (to describe its type).
 189
 190    On outermost call, pass 0 for PASSED_A_PTR.
 191    On outermost call, SHOW > 0 means should ignore
 192    any typename for TYPE and show its details.
 193    SHOW is always zero on recursive calls.
 194
 195    NEED_POST_SPACE is non-zero when a space will be be needed
 196    between a trailing qualifier and a field, variable, or function
 197    name.  */
 198
 199 void
 200 c_type_print_varspec_prefix (struct type *type, struct ui_file *stream,
 201                              int show, int passed_a_ptr, int need_post_space)
 202 {
 203   char *name;
 204   if (type == 0)
 205     return;
 206
 207   if (TYPE_NAME (type) && show <= 0)
 208     return;
 209
 210   QUIT;
 211
 212   switch (TYPE_CODE (type))
 213     {
 214     case TYPE_CODE_PTR:
 215       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 1, 1);
 216       fprintf_filtered (stream, "*");
 217       c_type_print_modifier (type, stream, 1, need_post_space);
 218       break;
 219
 220     case TYPE_CODE_MEMBERPTR:
 221       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
 222       name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
 223       if (name)
 224         fputs_filtered (name, stream);
 225       else
 226         c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
 227       fprintf_filtered (stream, "::*");
 228       break;
 229
 230     case TYPE_CODE_METHODPTR:
 231       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
 232       fprintf_filtered (stream, "(");
 233       name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
 234       if (name)
 235         fputs_filtered (name, stream);
 236       else
 237         c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
 238       fprintf_filtered (stream, "::*");
 239       break;
 240
 241     case TYPE_CODE_REF:
 242       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 1, 0);
 243       fprintf_filtered (stream, "&");
 244       c_type_print_modifier (type, stream, 1, need_post_space);
 245       break;
 246
 247     case TYPE_CODE_METHOD:
 248     case TYPE_CODE_FUNC:
 249       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
 250       if (passed_a_ptr)
 251         fprintf_filtered (stream, "(");
 252       break;
 253
 254     case TYPE_CODE_ARRAY:
 255       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
 256       if (passed_a_ptr)
 257         fprintf_filtered (stream, "(");
 258       break;
 259
 260     case TYPE_CODE_TYPEDEF:
 261       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
 262       break;
 263
 264     case TYPE_CODE_UNDEF:
 265     case TYPE_CODE_STRUCT:
 266     case TYPE_CODE_UNION:
 267     case TYPE_CODE_ENUM:
 268     case TYPE_CODE_INT:
 269     case TYPE_CODE_FLT:
 270     case TYPE_CODE_VOID:
 271     case TYPE_CODE_ERROR:
 272     case TYPE_CODE_CHAR:
 273     case TYPE_CODE_BOOL:
 274     case TYPE_CODE_SET:
 275     case TYPE_CODE_RANGE:
 276     case TYPE_CODE_STRING:
 277     case TYPE_CODE_BITSTRING:
 278     case TYPE_CODE_COMPLEX:
 279     case TYPE_CODE_TEMPLATE:
 280     case TYPE_CODE_NAMESPACE:
 281     case TYPE_CODE_DECFLOAT:
 282       /* These types need no prefix.  They are listed here so that
 283          gcc -Wall will reveal any types that haven't been handled.  */
 284       break;
 285     default:
 286       error (_("type not handled in c_type_print_varspec_prefix()"));
 287       break;
 288     }
 289 }
 290
 291 /* Print out "const" and "volatile" attributes.
 292    TYPE is a pointer to the type being printed out.
 293    STREAM is the output destination.
 294    NEED_SPACE = 1 indicates an initial white space is needed */
 295
 296 static void
 297 c_type_print_modifier (struct type *type, struct ui_file *stream,
 298                        int need_pre_space, int need_post_space)
 299 {
 300   int did_print_modifier = 0;
 301   const char *address_space_id;
 302
 303   /* We don't print `const' qualifiers for references --- since all
 304      operators affect the thing referenced, not the reference itself,
 305      every reference is `const'.  */
 306   if (TYPE_CONST (type)
 307       && TYPE_CODE (type) != TYPE_CODE_REF)
 308     {
 309       if (need_pre_space)
 310         fprintf_filtered (stream, " ");
 311       fprintf_filtered (stream, "const");
 312       did_print_modifier = 1;
 313     }
 314
 315   if (TYPE_VOLATILE (type))
 316     {
 317       if (did_print_modifier || need_pre_space)
 318         fprintf_filtered (stream, " ");
 319       fprintf_filtered (stream, "volatile");
 320       did_print_modifier = 1;
 321     }
 322
 323   address_space_id = address_space_int_to_name (TYPE_INSTANCE_FLAGS (type));
 324   if (address_space_id)
 325     {
 326       if (did_print_modifier || need_pre_space)
 327         fprintf_filtered (stream, " ");
 328       fprintf_filtered (stream, "@%s", address_space_id);
 329       did_print_modifier = 1;
 330     }
 331
 332   if (did_print_modifier && need_post_space)
 333     fprintf_filtered (stream, " ");
 334 }
 335
 336
 337 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
 338    or TYPE_CODE_FUNC, to STREAM.  Artificial arguments, such as "this"
 339    in non-static methods, are displayed.  */
 340
 341 static void
 342 c_type_print_args (struct type *type, struct ui_file *stream)
 343 {
 344   int i, len;
 345   struct field *args;
 346   int printed_any = 0;
 347
 348   fprintf_filtered (stream, "(");
 349   args = TYPE_FIELDS (type);
 350   len = TYPE_NFIELDS (type);
 351
 352   for (i = 0; i < TYPE_NFIELDS (type); i++)
 353     {
 354       if (printed_any)
 355         {
 356           fprintf_filtered (stream, ", ");
 357           wrap_here ("    ");
 358         }
 359
 360       c_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
 361       printed_any = 1;
 362     }
 363
 364   if (printed_any && TYPE_VARARGS (type))
 365     {
 366       /* Print out a trailing ellipsis for varargs functions.  Ignore
 367          TYPE_VARARGS if the function has no named arguments; that
 368          represents unprototyped (K&R style) C functions.  */
 369       if (printed_any && TYPE_VARARGS (type))
 370         {
 371           fprintf_filtered (stream, ", ");
 372           wrap_here ("    ");
 373           fprintf_filtered (stream, "...");
 374         }
 375     }
 376   else if (!printed_any
 377       && (TYPE_PROTOTYPED (type)
 378           || current_language->la_language == language_cplus))
 379     fprintf_filtered (stream, "void");
 380
 381   fprintf_filtered (stream, ")");
 382 }
 383
 384
 385 /* Return true iff the j'th overloading of the i'th method of TYPE
 386    is a type conversion operator, like `operator int () { ... }'.
 387    When listing a class's methods, we don't print the return type of
 388    such operators.  */
 389 static int
 390 is_type_conversion_operator (struct type *type, int i, int j)
 391 {
 392   /* I think the whole idea of recognizing type conversion operators
 393      by their name is pretty terrible.  But I don't think our present
 394      data structure gives us any other way to tell.  If you know of
 395      some other way, feel free to rewrite this function.  */
 396   char *name = TYPE_FN_FIELDLIST_NAME (type, i);
 397
 398   if (strncmp (name, "operator", 8) != 0)
 399     return 0;
 400
 401   name += 8;
 402   if (! strchr (" \t\f\n\r", *name))
 403     return 0;
 404
 405   while (strchr (" \t\f\n\r", *name))
 406     name++;
 407
 408   if (!('a' <= *name && *name <= 'z')
 409       && !('A' <= *name && *name <= 'Z')
 410       && *name != '_')
 411     /* If this doesn't look like the start of an identifier, then it
 412        isn't a type conversion operator.  */
 413     return 0;
 414   else if (strncmp (name, "new", 3) == 0)
 415     name += 3;
 416   else if (strncmp (name, "delete", 6) == 0)
 417     name += 6;
 418   else
 419     /* If it doesn't look like new or delete, it's a type conversion
 420        operator.  */
 421     return 1;
 422
 423   /* Is that really the end of the name?  */
 424   if (('a' <= *name && *name <= 'z')
 425       || ('A' <= *name && *name <= 'Z')
 426       || ('0' <= *name && *name <= '9')
 427       || *name == '_')
 428     /* No, so the identifier following "operator" must be a type name,
 429        and this is a type conversion operator.  */
 430     return 1;
 431
 432   /* That was indeed the end of the name, so it was `operator new' or
 433      `operator delete', neither of which are type conversion operators.  */
 434   return 0;
 435 }
 436
 437
 438 /* Given a C++ qualified identifier QID, strip off the qualifiers,
 439    yielding the unqualified name.  The return value is a pointer into
 440    the original string.
 441
 442    It's a pity we don't have this information in some more structured
 443    form.  Even the author of this function feels that writing little
 444    parsers like this everywhere is stupid.  */
 445 static char *
 446 remove_qualifiers (char *qid)
 447 {
 448   int quoted = 0;               /* zero if we're not in quotes;
 449                                    '"' if we're in a double-quoted string;
 450                                    '\'' if we're in a single-quoted string.  */
 451   int depth = 0;                /* number of unclosed parens we've seen */
 452   char *parenstack = (char *) alloca (strlen (qid));
 453   char *scan;
 454   char *last = 0;               /* The character after the rightmost
 455                                    `::' token we've seen so far.  */
 456
 457   for (scan = qid; *scan; scan++)
 458     {
 459       if (quoted)
 460         {
 461           if (*scan == quoted)
 462             quoted = 0;
 463           else if (*scan == '\\' && *(scan + 1))
 464             scan++;
 465         }
 466       else if (scan[0] == ':' && scan[1] == ':')
 467         {
 468           /* If we're inside parenthesis (i.e., an argument list) or
 469              angle brackets (i.e., a list of template arguments), then
 470              we don't record the position of this :: token, since it's
 471              not relevant to the top-level structure we're trying
 472              to operate on.  */
 473           if (depth == 0)
 474             {
 475               last = scan + 2;
 476               scan++;
 477             }
 478         }
 479       else if (*scan == '"' || *scan == '\'')
 480         quoted = *scan;
 481       else if (*scan == '(')
 482         parenstack[depth++] = ')';
 483       else if (*scan == '[')
 484         parenstack[depth++] = ']';
 485       /* We're going to treat <> as a pair of matching characters,
 486          since we're more likely to see those in template id's than
 487          real less-than characters.  What a crock.  */
 488       else if (*scan == '<')
 489         parenstack[depth++] = '>';
 490       else if (*scan == ')' || *scan == ']' || *scan == '>')
 491         {
 492           if (depth > 0 && parenstack[depth - 1] == *scan)
 493             depth--;
 494           else
 495             {
 496               /* We're going to do a little error recovery here.  If we
 497                  don't find a match for *scan on the paren stack, but
 498                  there is something lower on the stack that does match, we
 499                  pop the stack to that point.  */
 500               int i;
 501
 502               for (i = depth - 1; i >= 0; i--)
 503                 if (parenstack[i] == *scan)
 504                   {
 505                     depth = i;
 506                     break;
 507                   }
 508             }
 509         }
 510     }
 511
 512   if (last)
 513     return last;
 514   else
 515     /* We didn't find any :: tokens at the top level, so declare the
 516        whole thing an unqualified identifier.  */
 517     return qid;
 518 }
 519
 520
 521 /* Print any array sizes, function arguments or close parentheses
 522    needed after the variable name (to describe its type).
 523    Args work like c_type_print_varspec_prefix.  */
 524
 525 void
 526 c_type_print_varspec_suffix (struct type *type, struct ui_file *stream,
 527                              int show, int passed_a_ptr, int demangled_args)
 528 {
 529   if (type == 0)
 530     return;
 531
 532   if (TYPE_NAME (type) && show <= 0)
 533     return;
 534
 535   QUIT;
 536
 537   switch (TYPE_CODE (type))
 538     {
 539     case TYPE_CODE_ARRAY:
 540       if (passed_a_ptr)
 541         fprintf_filtered (stream, ")");
 542
 543       fprintf_filtered (stream, "[");
 544       if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
 545         && TYPE_ARRAY_UPPER_BOUND_TYPE (type) != BOUND_CANNOT_BE_DETERMINED)
 546         fprintf_filtered (stream, "%d",
 547                           (TYPE_LENGTH (type)
 548                            / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
 549       fprintf_filtered (stream, "]");
 550
 551       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 552                                    0, 0);
 553       break;
 554
 555     case TYPE_CODE_MEMBERPTR:
 556       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 557                                    0, 0);
 558       break;
 559
 560     case TYPE_CODE_METHODPTR:
 561       fprintf_filtered (stream, ")");
 562       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 563                                    0, 0);
 564       break;
 565
 566     case TYPE_CODE_PTR:
 567     case TYPE_CODE_REF:
 568       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 569                                    1, 0);
 570       break;
 571
 572     case TYPE_CODE_METHOD:
 573     case TYPE_CODE_FUNC:
 574       if (passed_a_ptr)
 575         fprintf_filtered (stream, ")");
 576       if (!demangled_args)
 577         c_type_print_args (type, stream);
 578       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 579                                    passed_a_ptr, 0);
 580       break;
 581
 582     case TYPE_CODE_TYPEDEF:
 583       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 584                                    passed_a_ptr, 0);
 585       break;
 586
 587     case TYPE_CODE_UNDEF:
 588     case TYPE_CODE_STRUCT:
 589     case TYPE_CODE_UNION:
 590     case TYPE_CODE_ENUM:
 591     case TYPE_CODE_INT:
 592     case TYPE_CODE_FLT:
 593     case TYPE_CODE_VOID:
 594     case TYPE_CODE_ERROR:
 595     case TYPE_CODE_CHAR:
 596     case TYPE_CODE_BOOL:
 597     case TYPE_CODE_SET:
 598     case TYPE_CODE_RANGE:
 599     case TYPE_CODE_STRING:
 600     case TYPE_CODE_BITSTRING:
 601     case TYPE_CODE_COMPLEX:
 602     case TYPE_CODE_TEMPLATE:
 603     case TYPE_CODE_NAMESPACE:
 604     case TYPE_CODE_DECFLOAT:
 605       /* These types do not need a suffix.  They are listed so that
 606          gcc -Wall will report types that may not have been considered.  */
 607       break;
 608     default:
 609       error (_("type not handled in c_type_print_varspec_suffix()"));
 610       break;
 611     }
 612 }
 613
 614 /* Print the name of the type (or the ultimate pointer target,
 615    function value or array element), or the description of a
 616    structure or union.
 617
 618    SHOW positive means print details about the type (e.g. enum values),
 619    and print structure elements passing SHOW - 1 for show.
 620    SHOW negative means just print the type name or struct tag if there is one.
 621    If there is no name, print something sensible but concise like
 622    "struct {...}".
 623    SHOW zero means just print the type name or struct tag if there is one.
 624    If there is no name, print something sensible but not as concise like
 625    "struct {int x; int y;}".
 626
 627    LEVEL is the number of spaces to indent by.
 628    We increase it for some recursive calls.  */
 629
 630 void
 631 c_type_print_base (struct type *type, struct ui_file *stream, int show,
 632                    int level)
 633 {
 634   int i;
 635   int len, real_len;
 636   int lastval;
 637   char *mangled_name;
 638   char *demangled_name;
 639   char *demangled_no_static;
 640   enum
 641     {
 642       s_none, s_public, s_private, s_protected
 643     }
 644   section_type;
 645   int need_access_label = 0;
 646   int j, len2;
 647
 648   QUIT;
 649
 650   wrap_here ("    ");
 651   if (type == NULL)
 652     {
 653       fputs_filtered (_("<type unknown>"), stream);
 654       return;
 655     }
 656
 657   /* When SHOW is zero or less, and there is a valid type name, then always
 658      just print the type name directly from the type.  */
 659   /* If we have "typedef struct foo {. . .} bar;" do we want to print it
 660      as "struct foo" or as "bar"?  Pick the latter, because C++ folk tend
 661      to expect things like "class5 *foo" rather than "struct class5 *foo".  */
 662
 663   if (show <= 0
 664       && TYPE_NAME (type) != NULL)
 665     {
 666       c_type_print_modifier (type, stream, 0, 1);
 667       fputs_filtered (TYPE_NAME (type), stream);
 668       return;
 669     }
 670
 671   CHECK_TYPEDEF (type);
 672
 673   switch (TYPE_CODE (type))
 674     {
 675     case TYPE_CODE_TYPEDEF:
 676     case TYPE_CODE_ARRAY:
 677     case TYPE_CODE_PTR:
 678     case TYPE_CODE_MEMBERPTR:
 679     case TYPE_CODE_REF:
 680     case TYPE_CODE_FUNC:
 681     case TYPE_CODE_METHOD:
 682     case TYPE_CODE_METHODPTR:
 683       c_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
 684       break;
 685
 686     case TYPE_CODE_STRUCT:
 687       c_type_print_modifier (type, stream, 0, 1);
 688       /* Note TYPE_CODE_STRUCT and TYPE_CODE_CLASS have the same value,
 689        * so we use another means for distinguishing them.
 690        */
 691       if (HAVE_CPLUS_STRUCT (type))
 692         {
 693           switch (TYPE_DECLARED_TYPE (type))
 694             {
 695             case DECLARED_TYPE_CLASS:
 696               fprintf_filtered (stream, "class ");
 697               break;
 698             case DECLARED_TYPE_UNION:
 699               fprintf_filtered (stream, "union ");
 700               break;
 701             case DECLARED_TYPE_STRUCT:
 702               fprintf_filtered (stream, "struct ");
 703               break;
 704             default:
 705               /* If there is a CPLUS_STRUCT, assume class if not
 706                * otherwise specified in the declared_type field.
 707                */
 708               fprintf_filtered (stream, "class ");
 709               break;
 710             }                   /* switch */
 711         }
 712       else
 713         {
 714           /* If not CPLUS_STRUCT, then assume it's a C struct */
 715           fprintf_filtered (stream, "struct ");
 716         }
 717       goto struct_union;
 718
 719     case TYPE_CODE_UNION:
 720       c_type_print_modifier (type, stream, 0, 1);
 721       fprintf_filtered (stream, "union ");
 722
 723     struct_union:
 724
 725       /* Print the tag if it exists.
 726        * The HP aCC compiler emits
 727        * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
 728        * tag  for unnamed struct/union/enum's, which we don't
 729        * want to print.
 730        */
 731       if (TYPE_TAG_NAME (type) != NULL &&
 732           strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
 733         {
 734           fputs_filtered (TYPE_TAG_NAME (type), stream);
 735           if (show > 0)
 736             fputs_filtered (" ", stream);
 737         }
 738       wrap_here ("    ");
 739       if (show < 0)
 740         {
 741           /* If we just printed a tag name, no need to print anything else.  */
 742           if (TYPE_TAG_NAME (type) == NULL)
 743             fprintf_filtered (stream, "{...}");
 744         }
 745       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
 746         {
 747           cp_type_print_derivation_info (stream, type);
 748
 749           fprintf_filtered (stream, "{\n");
 750           if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
 751             {
 752               if (TYPE_STUB (type))
 753                 fprintfi_filtered (level + 4, stream, _("<incomplete type>\n"));
 754               else
 755                 fprintfi_filtered (level + 4, stream, _("<no data fields>\n"));
 756             }
 757
 758           /* Start off with no specific section type, so we can print
 759              one for the first field we find, and use that section type
 760              thereafter until we find another type. */
 761
 762           section_type = s_none;
 763
 764           /* For a class, if all members are private, there's no need
 765              for a "private:" label; similarly, for a struct or union
 766              masquerading as a class, if all members are public, there's
 767              no need for a "public:" label. */
 768
 769           if ((TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_CLASS) ||
 770               (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_TEMPLATE))
 771             {
 772               QUIT;
 773               len = TYPE_NFIELDS (type);
 774               for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 775                 if (!TYPE_FIELD_PRIVATE (type, i))
 776                   {
 777                     need_access_label = 1;
 778                     break;
 779                   }
 780               QUIT;
 781               if (!need_access_label)
 782                 {
 783                   len2 = TYPE_NFN_FIELDS (type);
 784                   for (j = 0; j < len2; j++)
 785                     {
 786                       len = TYPE_FN_FIELDLIST_LENGTH (type, j);
 787                       for (i = 0; i < len; i++)
 788                         if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i))
 789                           {
 790                             need_access_label = 1;
 791                             break;
 792                           }
 793                       if (need_access_label)
 794                         break;
 795                     }
 796                 }
 797             }
 798           else if ((TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_STRUCT) ||
 799                    (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_UNION))
 800             {
 801               QUIT;
 802               len = TYPE_NFIELDS (type);
 803               for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 804                 if (TYPE_FIELD_PRIVATE (type, i) || TYPE_FIELD_PROTECTED (type, i))
 805                   {
 806                     need_access_label = 1;
 807                     break;
 808                   }
 809               QUIT;
 810               if (!need_access_label)
 811                 {
 812                   len2 = TYPE_NFN_FIELDS (type);
 813                   for (j = 0; j < len2; j++)
 814                     {
 815                       QUIT;
 816                       len = TYPE_FN_FIELDLIST_LENGTH (type, j);
 817                       for (i = 0; i < len; i++)
 818                         if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i) ||
 819                             TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type, j), i))
 820                           {
 821                             need_access_label = 1;
 822                             break;
 823                           }
 824                       if (need_access_label)
 825                         break;
 826                     }
 827                 }
 828             }
 829
 830           /* If there is a base class for this type,
 831              do not print the field that it occupies.  */
 832
 833           len = TYPE_NFIELDS (type);
 834           for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 835             {
 836               QUIT;
 837               /* Don't print out virtual function table.  */
 838               if (strncmp (TYPE_FIELD_NAME (type, i), "_vptr", 5) == 0
 839                   && is_cplus_marker ((TYPE_FIELD_NAME (type, i))[5]))
 840                 continue;
 841
 842               /* If this is a C++ class we can print the various C++ section
 843                  labels. */
 844
 845               if (HAVE_CPLUS_STRUCT (type) && need_access_label)
 846                 {
 847                   if (TYPE_FIELD_PROTECTED (type, i))
 848                     {
 849                       if (section_type != s_protected)
 850                         {
 851                           section_type = s_protected;
 852                           fprintfi_filtered (level + 2, stream,
 853                                              "protected:\n");
 854                         }
 855                     }
 856                   else if (TYPE_FIELD_PRIVATE (type, i))
 857                     {
 858                       if (section_type != s_private)
 859                         {
 860                           section_type = s_private;
 861                           fprintfi_filtered (level + 2, stream, "private:\n");
 862                         }
 863                     }
 864                   else
 865                     {
 866                       if (section_type != s_public)
 867                         {
 868                           section_type = s_public;
 869                           fprintfi_filtered (level + 2, stream, "public:\n");
 870                         }
 871                     }
 872                 }
 873
 874               print_spaces_filtered (level + 4, stream);
 875               if (TYPE_FIELD_STATIC (type, i))
 876                 {
 877                   fprintf_filtered (stream, "static ");
 878                 }
 879               c_print_type (TYPE_FIELD_TYPE (type, i),
 880                             TYPE_FIELD_NAME (type, i),
 881                             stream, show - 1, level + 4);
 882               if (!TYPE_FIELD_STATIC (type, i)
 883                   && TYPE_FIELD_PACKED (type, i))
 884                 {
 885                   /* It is a bitfield.  This code does not attempt
 886                      to look at the bitpos and reconstruct filler,
 887                      unnamed fields.  This would lead to misleading
 888                      results if the compiler does not put out fields
 889                      for such things (I don't know what it does).  */
 890                   fprintf_filtered (stream, " : %d",
 891                                     TYPE_FIELD_BITSIZE (type, i));
 892                 }
 893               fprintf_filtered (stream, ";\n");
 894             }
 895
 896           /* If there are both fields and methods, put a blank line
 897               between them.  Make sure to count only method that we will
 898               display; artificial methods will be hidden.  */
 899           len = TYPE_NFN_FIELDS (type);
 900           real_len = 0;
 901           for (i = 0; i < len; i++)
 902             {
 903               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 904               int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 905               int j;
 906               for (j = 0; j < len2; j++)
 907                 if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
 908                   real_len++;
 909             }
 910           if (real_len > 0 && section_type != s_none)
 911             fprintf_filtered (stream, "\n");
 912
 913           /* C++: print out the methods */
 914           for (i = 0; i < len; i++)
 915             {
 916               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 917               int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 918               char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
 919               char *name = type_name_no_tag (type);
 920               int is_constructor = name && strcmp (method_name, name) == 0;
 921               for (j = 0; j < len2; j++)
 922                 {
 923                   char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
 924                   int is_full_physname_constructor =
 925                    is_constructor_name (physname)
 926                    || is_destructor_name (physname)
 927                    || method_name[0] == '~';
 928
 929                   /* Do not print out artificial methods.  */
 930                   if (TYPE_FN_FIELD_ARTIFICIAL (f, j))
 931                     continue;
 932
 933                   QUIT;
 934                   if (TYPE_FN_FIELD_PROTECTED (f, j))
 935                     {
 936                       if (section_type != s_protected)
 937                         {
 938                           section_type = s_protected;
 939                           fprintfi_filtered (level + 2, stream,
 940                                              "protected:\n");
 941                         }
 942                     }
 943                   else if (TYPE_FN_FIELD_PRIVATE (f, j))
 944                     {
 945                       if (section_type != s_private)
 946                         {
 947                           section_type = s_private;
 948                           fprintfi_filtered (level + 2, stream, "private:\n");
 949                         }
 950                     }
 951                   else
 952                     {
 953                       if (section_type != s_public)
 954                         {
 955                           section_type = s_public;
 956                           fprintfi_filtered (level + 2, stream, "public:\n");
 957                         }
 958                     }
 959
 960                   print_spaces_filtered (level + 4, stream);
 961                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
 962                     fprintf_filtered (stream, "virtual ");
 963                   else if (TYPE_FN_FIELD_STATIC_P (f, j))
 964                     fprintf_filtered (stream, "static ");
 965                   if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
 966                     {
 967                       /* Keep GDB from crashing here.  */
 968                       fprintf_filtered (stream, _("<undefined type> %s;\n"),
 969                                         TYPE_FN_FIELD_PHYSNAME (f, j));
 970                       break;
 971                     }
 972                   else if (!is_constructor &&   /* constructors don't have declared types */
 973                            !is_full_physname_constructor &&     /*    " "  */
 974                            !is_type_conversion_operator (type, i, j))
 975                     {
 976                       type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
 977                                   "", stream, -1);
 978                       fputs_filtered (" ", stream);
 979                     }
 980                   if (TYPE_FN_FIELD_STUB (f, j))
 981                     /* Build something we can demangle.  */
 982                     mangled_name = gdb_mangle_name (type, i, j);
 983                   else
 984                     mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
 985
 986                   demangled_name =
 987                     cplus_demangle (mangled_name,
 988                                     DMGL_ANSI | DMGL_PARAMS);
 989                   if (demangled_name == NULL)
 990                     {
 991                       /* in some cases (for instance with the HP demangling),
 992                          if a function has more than 10 arguments,
 993                          the demangling will fail.
 994                          Let's try to reconstruct the function signature from
 995                          the symbol information */
 996                       if (!TYPE_FN_FIELD_STUB (f, j))
 997                         {
 998                           int staticp = TYPE_FN_FIELD_STATIC_P (f, j);
 999                           struct type *mtype = TYPE_FN_FIELD_TYPE (f, j);
1000                           cp_type_print_method_args (mtype,
1001                                                      "",
1002                                                      method_name,
1003                                                      staticp,
1004                                                      stream);
1005                         }
1006                       else
1007                         fprintf_filtered (stream, _("<badly mangled name '%s'>"),
1008                                           mangled_name);
1009                     }
1010                   else
1011                     {
1012                       char *p;
1013                       char *demangled_no_class
1014                         = remove_qualifiers (demangled_name);
1015
1016                       /* get rid of the `static' appended by the demangler */
1017                       p = strstr (demangled_no_class, " static");
1018                       if (p != NULL)
1019                         {
1020                           int length = p - demangled_no_class;
1021                           demangled_no_static = (char *) xmalloc (length + 1);
1022                           strncpy (demangled_no_static, demangled_no_class, length);
1023                           *(demangled_no_static + length) = '\0';
1024                           fputs_filtered (demangled_no_static, stream);
1025                           xfree (demangled_no_static);
1026                         }
1027                       else
1028                         fputs_filtered (demangled_no_class, stream);
1029                       xfree (demangled_name);
1030                     }
1031
1032                   if (TYPE_FN_FIELD_STUB (f, j))
1033                     xfree (mangled_name);
1034
1035                   fprintf_filtered (stream, ";\n");
1036                 }
1037             }
1038
1039           fprintfi_filtered (level, stream, "}");
1040
1041           if (TYPE_LOCALTYPE_PTR (type) && show >= 0)
1042             fprintfi_filtered (level, stream, _(" (Local at %s:%d)\n"),
1043                                TYPE_LOCALTYPE_FILE (type),
1044                                TYPE_LOCALTYPE_LINE (type));
1045         }
1046       if (TYPE_CODE (type) == TYPE_CODE_TEMPLATE)
1047         goto go_back;
1048       break;
1049
1050     case TYPE_CODE_ENUM:
1051       c_type_print_modifier (type, stream, 0, 1);
1052       fprintf_filtered (stream, "enum ");
1053       /* Print the tag name if it exists.
1054          The aCC compiler emits a spurious
1055          "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1056          tag for unnamed struct/union/enum's, which we don't
1057          want to print. */
1058       if (TYPE_TAG_NAME (type) != NULL &&
1059           strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
1060         {
1061           fputs_filtered (TYPE_TAG_NAME (type), stream);
1062           if (show > 0)
1063             fputs_filtered (" ", stream);
1064         }
1065
1066       wrap_here ("    ");
1067       if (show < 0)
1068         {
1069           /* If we just printed a tag name, no need to print anything else.  */
1070           if (TYPE_TAG_NAME (type) == NULL)
1071             fprintf_filtered (stream, "{...}");
1072         }
1073       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1074         {
1075           fprintf_filtered (stream, "{");
1076           len = TYPE_NFIELDS (type);
1077           lastval = 0;
1078           for (i = 0; i < len; i++)
1079             {
1080               QUIT;
1081               if (i)
1082                 fprintf_filtered (stream, ", ");
1083               wrap_here ("    ");
1084               fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1085               if (lastval != TYPE_FIELD_BITPOS (type, i))
1086                 {
1087                   fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
1088                   lastval = TYPE_FIELD_BITPOS (type, i);
1089                 }
1090               lastval++;
1091             }
1092           fprintf_filtered (stream, "}");
1093         }
1094       break;
1095
1096     case TYPE_CODE_VOID:
1097       fprintf_filtered (stream, "void");
1098       break;
1099
1100     case TYPE_CODE_UNDEF:
1101       fprintf_filtered (stream, _("struct <unknown>"));
1102       break;
1103
1104     case TYPE_CODE_ERROR:
1105       fprintf_filtered (stream, _("<unknown type>"));
1106       break;
1107
1108     case TYPE_CODE_RANGE:
1109       /* This should not occur */
1110       fprintf_filtered (stream, _("<range type>"));
1111       break;
1112
1113     case TYPE_CODE_TEMPLATE:
1114       /* Called on "ptype t" where "t" is a template.
1115          Prints the template header (with args), e.g.:
1116          template <class T1, class T2> class "
1117          and then merges with the struct/union/class code to
1118          print the rest of the definition. */
1119       c_type_print_modifier (type, stream, 0, 1);
1120       fprintf_filtered (stream, "template <");
1121       for (i = 0; i < TYPE_NTEMPLATE_ARGS (type); i++)
1122         {
1123           struct template_arg templ_arg;
1124           templ_arg = TYPE_TEMPLATE_ARG (type, i);
1125           fprintf_filtered (stream, "class %s", templ_arg.name);
1126           if (i < TYPE_NTEMPLATE_ARGS (type) - 1)
1127             fprintf_filtered (stream, ", ");
1128         }
1129       fprintf_filtered (stream, "> class ");
1130       /* Yuck, factor this out to a subroutine so we can call
1131          it and return to the point marked with the "goback:" label... - RT */
1132       goto struct_union;
1133     go_back:
1134       if (TYPE_NINSTANTIATIONS (type) > 0)
1135         {
1136           fprintf_filtered (stream, _("\ntemplate instantiations:\n"));
1137           for (i = 0; i < TYPE_NINSTANTIATIONS (type); i++)
1138             {
1139               fprintf_filtered (stream, "  ");
1140               c_type_print_base (TYPE_INSTANTIATION (type, i), stream, 0, level);
1141               if (i < TYPE_NINSTANTIATIONS (type) - 1)
1142                 fprintf_filtered (stream, "\n");
1143             }
1144         }
1145       break;
1146
1147     case TYPE_CODE_NAMESPACE:
1148       fputs_filtered ("namespace ", stream);
1149       fputs_filtered (TYPE_TAG_NAME (type), stream);
1150       break;
1151
1152     default:
1153       /* Handle types not explicitly handled by the other cases,
1154          such as fundamental types.  For these, just print whatever
1155          the type name is, as recorded in the type itself.  If there
1156          is no type name, then complain. */
1157       if (TYPE_NAME (type) != NULL)
1158         {
1159           c_type_print_modifier (type, stream, 0, 1);
1160           fputs_filtered (TYPE_NAME (type), stream);
1161         }
1162       else
1163         {
1164           /* At least for dump_symtab, it is important that this not be
1165              an error ().  */
1166           fprintf_filtered (stream, _("<invalid type code %d>"),
1167                             TYPE_CODE (type));
1168         }
1169       break;
1170     }
1171 }