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
   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 2 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, write to the Free Software
  20    Foundation, Inc., 51 Franklin Street, Fifth Floor,
  21    Boston, MA 02110-1301, USA.  */
  22
  23 #include "defs.h"
  24 #include "gdb_obstack.h"
  25 #include "bfd.h"                /* Binary File Description */
  26 #include "symtab.h"
  27 #include "gdbtypes.h"
  28 #include "expression.h"
  29 #include "value.h"
  30 #include "gdbcore.h"
  31 #include "target.h"
  32 #include "language.h"
  33 #include "demangle.h"
  34 #include "c-lang.h"
  35 #include "typeprint.h"
  36 #include "cp-abi.h"
  37
  38 #include "gdb_string.h"
  39 #include <errno.h>
  40
  41 static void cp_type_print_method_args (struct type *mtype, char *prefix,
  42                                        char *varstring, int staticp,
  43                                        struct ui_file *stream);
  44
  45 static void c_type_print_args (struct type *, struct ui_file *);
  46
  47 static void cp_type_print_derivation_info (struct ui_file *, struct type *);
  48
  49 static void c_type_print_varspec_prefix (struct type *, struct ui_file *, int,
  50                                          int, int);
  51
  52 /* Print "const", "volatile", or address space modifiers. */
  53 static void c_type_print_modifier (struct type *, struct ui_file *,
  54                                    int, int);
  55 \f
  56
  57
  58
  59 /* LEVEL is the depth to indent lines by.  */
  60
  61 void
  62 c_print_type (struct type *type, char *varstring, struct ui_file *stream,
  63               int show, int level)
  64 {
  65   enum type_code code;
  66   int demangled_args;
  67   int need_post_space;
  68
  69   if (show > 0)
  70     CHECK_TYPEDEF (type);
  71
  72   c_type_print_base (type, stream, show, level);
  73   code = TYPE_CODE (type);
  74   if ((varstring != NULL && *varstring != '\0')
  75       ||
  76   /* Need a space if going to print stars or brackets;
  77      but not if we will print just a type name.  */
  78       ((show > 0 || TYPE_NAME (type) == 0)
  79        &&
  80        (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
  81         || code == TYPE_CODE_METHOD
  82         || code == TYPE_CODE_ARRAY
  83         || code == TYPE_CODE_MEMBERPTR
  84         || code == TYPE_CODE_METHODPTR
  85         || code == TYPE_CODE_REF)))
  86     fputs_filtered (" ", stream);
  87   need_post_space = (varstring != NULL && strcmp (varstring, "") != 0);
  88   c_type_print_varspec_prefix (type, stream, show, 0, need_post_space);
  89
  90   if (varstring != NULL)
  91     {
  92       fputs_filtered (varstring, stream);
  93
  94       /* For demangled function names, we have the arglist as part of the name,
  95          so don't print an additional pair of ()'s */
  96
  97       demangled_args = strchr (varstring, '(') != NULL;
  98       c_type_print_varspec_suffix (type, stream, show, 0, demangled_args);
  99     }
 100 }
 101
 102 /* If TYPE is a derived type, then print out derivation information.
 103    Print only the actual base classes of this type, not the base classes
 104    of the base classes.  I.E.  for the derivation hierarchy:
 105
 106    class A { int a; };
 107    class B : public A {int b; };
 108    class C : public B {int c; };
 109
 110    Print the type of class C as:
 111
 112    class C : public B {
 113    int c;
 114    }
 115
 116    Not as the following (like gdb used to), which is not legal C++ syntax for
 117    derived types and may be confused with the multiple inheritance form:
 118
 119    class C : public B : public A {
 120    int c;
 121    }
 122
 123    In general, gdb should try to print the types as closely as possible to
 124    the form that they appear in the source code.
 125    Note that in case of protected derivation gcc will not say 'protected'
 126    but 'private'. The HP's aCC compiler emits specific information for
 127    derivation via protected inheritance, so gdb can print it out */
 128
 129 static void
 130 cp_type_print_derivation_info (struct ui_file *stream, struct type *type)
 131 {
 132   char *name;
 133   int i;
 134
 135   for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
 136     {
 137       fputs_filtered (i == 0 ? ": " : ", ", stream);
 138       fprintf_filtered (stream, "%s%s ",
 139                         BASETYPE_VIA_PUBLIC (type, i) ? "public"
 140                : (TYPE_FIELD_PROTECTED (type, i) ? "protected" : "private"),
 141                         BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : "");
 142       name = type_name_no_tag (TYPE_BASECLASS (type, i));
 143       fprintf_filtered (stream, "%s", name ? name : "(null)");
 144     }
 145   if (i > 0)
 146     {
 147       fputs_filtered (" ", stream);
 148     }
 149 }
 150
 151 /* Print the C++ method arguments ARGS to the file STREAM.  */
 152
 153 static void
 154 cp_type_print_method_args (struct type *mtype, char *prefix, char *varstring,
 155                            int staticp, struct ui_file *stream)
 156 {
 157   struct field *args = TYPE_FIELDS (mtype);
 158   int nargs = TYPE_NFIELDS (mtype);
 159   int varargs = TYPE_VARARGS (mtype);
 160   int i;
 161
 162   fprintf_symbol_filtered (stream, prefix, language_cplus, DMGL_ANSI);
 163   fprintf_symbol_filtered (stream, varstring, language_cplus, DMGL_ANSI);
 164   fputs_filtered ("(", stream);
 165
 166   /* Skip the class variable.  */
 167   i = staticp ? 0 : 1;
 168   if (nargs > i)
 169     {
 170       while (i < nargs)
 171         {
 172           type_print (args[i++].type, "", stream, 0);
 173
 174           if (i == nargs && varargs)
 175             fprintf_filtered (stream, ", ...");
 176           else if (i < nargs)
 177             fprintf_filtered (stream, ", ");
 178         }
 179     }
 180   else if (varargs)
 181     fprintf_filtered (stream, "...");
 182   else if (current_language->la_language == language_cplus)
 183     fprintf_filtered (stream, "void");
 184
 185   fprintf_filtered (stream, ")");
 186 }
 187
 188
 189 /* Print any asterisks or open-parentheses needed before the
 190    variable name (to describe its type).
 191
 192    On outermost call, pass 0 for PASSED_A_PTR.
 193    On outermost call, SHOW > 0 means should ignore
 194    any typename for TYPE and show its details.
 195    SHOW is always zero on recursive calls.
 196
 197    NEED_POST_SPACE is non-zero when a space will be be needed
 198    between a trailing qualifier and a field, variable, or function
 199    name.  */
 200
 201 void
 202 c_type_print_varspec_prefix (struct type *type, struct ui_file *stream,
 203                              int show, int passed_a_ptr, int need_post_space)
 204 {
 205   char *name;
 206   if (type == 0)
 207     return;
 208
 209   if (TYPE_NAME (type) && show <= 0)
 210     return;
 211
 212   QUIT;
 213
 214   switch (TYPE_CODE (type))
 215     {
 216     case TYPE_CODE_PTR:
 217       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 1, 1);
 218       fprintf_filtered (stream, "*");
 219       c_type_print_modifier (type, stream, 1, need_post_space);
 220       break;
 221
 222     case TYPE_CODE_MEMBERPTR:
 223       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
 224       name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
 225       if (name)
 226         fputs_filtered (name, stream);
 227       else
 228         c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
 229       fprintf_filtered (stream, "::*");
 230       break;
 231
 232     case TYPE_CODE_METHODPTR:
 233       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
 234       fprintf_filtered (stream, "(");
 235       name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
 236       if (name)
 237         fputs_filtered (name, stream);
 238       else
 239         c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
 240       fprintf_filtered (stream, "::*");
 241       break;
 242
 243     case TYPE_CODE_REF:
 244       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 1, 0);
 245       fprintf_filtered (stream, "&");
 246       c_type_print_modifier (type, stream, 1, need_post_space);
 247       break;
 248
 249     case TYPE_CODE_METHOD:
 250     case TYPE_CODE_FUNC:
 251       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
 252       if (passed_a_ptr)
 253         fprintf_filtered (stream, "(");
 254       break;
 255
 256     case TYPE_CODE_ARRAY:
 257       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
 258       if (passed_a_ptr)
 259         fprintf_filtered (stream, "(");
 260       break;
 261
 262     case TYPE_CODE_TYPEDEF:
 263       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
 264       break;
 265
 266     case TYPE_CODE_UNDEF:
 267     case TYPE_CODE_STRUCT:
 268     case TYPE_CODE_UNION:
 269     case TYPE_CODE_ENUM:
 270     case TYPE_CODE_INT:
 271     case TYPE_CODE_FLT:
 272     case TYPE_CODE_VOID:
 273     case TYPE_CODE_ERROR:
 274     case TYPE_CODE_CHAR:
 275     case TYPE_CODE_BOOL:
 276     case TYPE_CODE_SET:
 277     case TYPE_CODE_RANGE:
 278     case TYPE_CODE_STRING:
 279     case TYPE_CODE_BITSTRING:
 280     case TYPE_CODE_COMPLEX:
 281     case TYPE_CODE_TEMPLATE:
 282     case TYPE_CODE_NAMESPACE:
 283       /* These types need no prefix.  They are listed here so that
 284          gcc -Wall will reveal any types that haven't been handled.  */
 285       break;
 286     default:
 287       error (_("type not handled in c_type_print_varspec_prefix()"));
 288       break;
 289     }
 290 }
 291
 292 /* Print out "const" and "volatile" attributes.
 293    TYPE is a pointer to the type being printed out.
 294    STREAM is the output destination.
 295    NEED_SPACE = 1 indicates an initial white space is needed */
 296
 297 static void
 298 c_type_print_modifier (struct type *type, struct ui_file *stream,
 299                        int need_pre_space, int need_post_space)
 300 {
 301   int did_print_modifier = 0;
 302   const char *address_space_id;
 303
 304   /* We don't print `const' qualifiers for references --- since all
 305      operators affect the thing referenced, not the reference itself,
 306      every reference is `const'.  */
 307   if (TYPE_CONST (type)
 308       && TYPE_CODE (type) != TYPE_CODE_REF)
 309     {
 310       if (need_pre_space)
 311         fprintf_filtered (stream, " ");
 312       fprintf_filtered (stream, "const");
 313       did_print_modifier = 1;
 314     }
 315
 316   if (TYPE_VOLATILE (type))
 317     {
 318       if (did_print_modifier || need_pre_space)
 319         fprintf_filtered (stream, " ");
 320       fprintf_filtered (stream, "volatile");
 321       did_print_modifier = 1;
 322     }
 323
 324   address_space_id = address_space_int_to_name (TYPE_INSTANCE_FLAGS (type));
 325   if (address_space_id)
 326     {
 327       if (did_print_modifier || need_pre_space)
 328         fprintf_filtered (stream, " ");
 329       fprintf_filtered (stream, "@%s", address_space_id);
 330       did_print_modifier = 1;
 331     }
 332
 333   if (did_print_modifier && need_post_space)
 334     fprintf_filtered (stream, " ");
 335 }
 336
 337
 338 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
 339    or TYPE_CODE_FUNC, to STREAM.  Artificial arguments, such as "this"
 340    in non-static methods, are displayed.  */
 341
 342 static void
 343 c_type_print_args (struct type *type, struct ui_file *stream)
 344 {
 345   int i, len;
 346   struct field *args;
 347   int printed_any = 0;
 348
 349   fprintf_filtered (stream, "(");
 350   args = TYPE_FIELDS (type);
 351   len = TYPE_NFIELDS (type);
 352
 353   for (i = 0; i < TYPE_NFIELDS (type); i++)
 354     {
 355       if (printed_any)
 356         {
 357           fprintf_filtered (stream, ", ");
 358           wrap_here ("    ");
 359         }
 360
 361       c_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
 362       printed_any = 1;
 363     }
 364
 365   if (printed_any && TYPE_VARARGS (type))
 366     {
 367       /* Print out a trailing ellipsis for varargs functions.  Ignore
 368          TYPE_VARARGS if the function has no named arguments; that
 369          represents unprototyped (K&R style) C functions.  */
 370       if (printed_any && TYPE_VARARGS (type))
 371         {
 372           fprintf_filtered (stream, ", ");
 373           wrap_here ("    ");
 374           fprintf_filtered (stream, "...");
 375         }
 376     }
 377   else if (!printed_any
 378       && (TYPE_PROTOTYPED (type)
 379           || current_language->la_language == language_cplus))
 380     fprintf_filtered (stream, "void");
 381
 382   fprintf_filtered (stream, ")");
 383 }
 384
 385
 386 /* Return true iff the j'th overloading of the i'th method of TYPE
 387    is a type conversion operator, like `operator int () { ... }'.
 388    When listing a class's methods, we don't print the return type of
 389    such operators.  */
 390 static int
 391 is_type_conversion_operator (struct type *type, int i, int j)
 392 {
 393   /* I think the whole idea of recognizing type conversion operators
 394      by their name is pretty terrible.  But I don't think our present
 395      data structure gives us any other way to tell.  If you know of
 396      some other way, feel free to rewrite this function.  */
 397   char *name = TYPE_FN_FIELDLIST_NAME (type, i);
 398
 399   if (strncmp (name, "operator", 8) != 0)
 400     return 0;
 401
 402   name += 8;
 403   if (! strchr (" \t\f\n\r", *name))
 404     return 0;
 405
 406   while (strchr (" \t\f\n\r", *name))
 407     name++;
 408
 409   if (!('a' <= *name && *name <= 'z')
 410       && !('A' <= *name && *name <= 'Z')
 411       && *name != '_')
 412     /* If this doesn't look like the start of an identifier, then it
 413        isn't a type conversion operator.  */
 414     return 0;
 415   else if (strncmp (name, "new", 3) == 0)
 416     name += 3;
 417   else if (strncmp (name, "delete", 6) == 0)
 418     name += 6;
 419   else
 420     /* If it doesn't look like new or delete, it's a type conversion
 421        operator.  */
 422     return 1;
 423
 424   /* Is that really the end of the name?  */
 425   if (('a' <= *name && *name <= 'z')
 426       || ('A' <= *name && *name <= 'Z')
 427       || ('0' <= *name && *name <= '9')
 428       || *name == '_')
 429     /* No, so the identifier following "operator" must be a type name,
 430        and this is a type conversion operator.  */
 431     return 1;
 432
 433   /* That was indeed the end of the name, so it was `operator new' or
 434      `operator delete', neither of which are type conversion operators.  */
 435   return 0;
 436 }
 437
 438
 439 /* Given a C++ qualified identifier QID, strip off the qualifiers,
 440    yielding the unqualified name.  The return value is a pointer into
 441    the original string.
 442
 443    It's a pity we don't have this information in some more structured
 444    form.  Even the author of this function feels that writing little
 445    parsers like this everywhere is stupid.  */
 446 static char *
 447 remove_qualifiers (char *qid)
 448 {
 449   int quoted = 0;               /* zero if we're not in quotes;
 450                                    '"' if we're in a double-quoted string;
 451                                    '\'' if we're in a single-quoted string.  */
 452   int depth = 0;                /* number of unclosed parens we've seen */
 453   char *parenstack = (char *) alloca (strlen (qid));
 454   char *scan;
 455   char *last = 0;               /* The character after the rightmost
 456                                    `::' token we've seen so far.  */
 457
 458   for (scan = qid; *scan; scan++)
 459     {
 460       if (quoted)
 461         {
 462           if (*scan == quoted)
 463             quoted = 0;
 464           else if (*scan == '\\' && *(scan + 1))
 465             scan++;
 466         }
 467       else if (scan[0] == ':' && scan[1] == ':')
 468         {
 469           /* If we're inside parenthesis (i.e., an argument list) or
 470              angle brackets (i.e., a list of template arguments), then
 471              we don't record the position of this :: token, since it's
 472              not relevant to the top-level structure we're trying
 473              to operate on.  */
 474           if (depth == 0)
 475             {
 476               last = scan + 2;
 477               scan++;
 478             }
 479         }
 480       else if (*scan == '"' || *scan == '\'')
 481         quoted = *scan;
 482       else if (*scan == '(')
 483         parenstack[depth++] = ')';
 484       else if (*scan == '[')
 485         parenstack[depth++] = ']';
 486       /* We're going to treat <> as a pair of matching characters,
 487          since we're more likely to see those in template id's than
 488          real less-than characters.  What a crock.  */
 489       else if (*scan == '<')
 490         parenstack[depth++] = '>';
 491       else if (*scan == ')' || *scan == ']' || *scan == '>')
 492         {
 493           if (depth > 0 && parenstack[depth - 1] == *scan)
 494             depth--;
 495           else
 496             {
 497               /* We're going to do a little error recovery here.  If we
 498                  don't find a match for *scan on the paren stack, but
 499                  there is something lower on the stack that does match, we
 500                  pop the stack to that point.  */
 501               int i;
 502
 503               for (i = depth - 1; i >= 0; i--)
 504                 if (parenstack[i] == *scan)
 505                   {
 506                     depth = i;
 507                     break;
 508                   }
 509             }
 510         }
 511     }
 512
 513   if (last)
 514     return last;
 515   else
 516     /* We didn't find any :: tokens at the top level, so declare the
 517        whole thing an unqualified identifier.  */
 518     return qid;
 519 }
 520
 521
 522 /* Print any array sizes, function arguments or close parentheses
 523    needed after the variable name (to describe its type).
 524    Args work like c_type_print_varspec_prefix.  */
 525
 526 void
 527 c_type_print_varspec_suffix (struct type *type, struct ui_file *stream,
 528                              int show, int passed_a_ptr, int demangled_args)
 529 {
 530   if (type == 0)
 531     return;
 532
 533   if (TYPE_NAME (type) && show <= 0)
 534     return;
 535
 536   QUIT;
 537
 538   switch (TYPE_CODE (type))
 539     {
 540     case TYPE_CODE_ARRAY:
 541       if (passed_a_ptr)
 542         fprintf_filtered (stream, ")");
 543
 544       fprintf_filtered (stream, "[");
 545       if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
 546         && TYPE_ARRAY_UPPER_BOUND_TYPE (type) != BOUND_CANNOT_BE_DETERMINED)
 547         fprintf_filtered (stream, "%d",
 548                           (TYPE_LENGTH (type)
 549                            / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
 550       fprintf_filtered (stream, "]");
 551
 552       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 553                                    0, 0);
 554       break;
 555
 556     case TYPE_CODE_MEMBERPTR:
 557       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 558                                    0, 0);
 559       break;
 560
 561     case TYPE_CODE_METHODPTR:
 562       fprintf_filtered (stream, ")");
 563       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 564                                    0, 0);
 565       break;
 566
 567     case TYPE_CODE_PTR:
 568     case TYPE_CODE_REF:
 569       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 570                                    1, 0);
 571       break;
 572
 573     case TYPE_CODE_METHOD:
 574     case TYPE_CODE_FUNC:
 575       if (passed_a_ptr)
 576         fprintf_filtered (stream, ")");
 577       if (!demangled_args)
 578         c_type_print_args (type, stream);
 579       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 580                                    passed_a_ptr, 0);
 581       break;
 582
 583     case TYPE_CODE_TYPEDEF:
 584       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 585                                    passed_a_ptr, 0);
 586       break;
 587
 588     case TYPE_CODE_UNDEF:
 589     case TYPE_CODE_STRUCT:
 590     case TYPE_CODE_UNION:
 591     case TYPE_CODE_ENUM:
 592     case TYPE_CODE_INT:
 593     case TYPE_CODE_FLT:
 594     case TYPE_CODE_VOID:
 595     case TYPE_CODE_ERROR:
 596     case TYPE_CODE_CHAR:
 597     case TYPE_CODE_BOOL:
 598     case TYPE_CODE_SET:
 599     case TYPE_CODE_RANGE:
 600     case TYPE_CODE_STRING:
 601     case TYPE_CODE_BITSTRING:
 602     case TYPE_CODE_COMPLEX:
 603     case TYPE_CODE_TEMPLATE:
 604     case TYPE_CODE_NAMESPACE:
 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               /* HP ANSI C++ case */
 839               if (TYPE_HAS_VTABLE (type)
 840                   && (strncmp (TYPE_FIELD_NAME (type, i), "__vfp", 5) == 0))
 841                 continue;
 842               /* Other compilers */
 843               if (strncmp (TYPE_FIELD_NAME (type, i), "_vptr", 5) == 0
 844                   && is_cplus_marker ((TYPE_FIELD_NAME (type, i))[5]))
 845                 continue;
 846
 847               /* If this is a C++ class we can print the various C++ section
 848                  labels. */
 849
 850               if (HAVE_CPLUS_STRUCT (type) && need_access_label)
 851                 {
 852                   if (TYPE_FIELD_PROTECTED (type, i))
 853                     {
 854                       if (section_type != s_protected)
 855                         {
 856                           section_type = s_protected;
 857                           fprintfi_filtered (level + 2, stream,
 858                                              "protected:\n");
 859                         }
 860                     }
 861                   else if (TYPE_FIELD_PRIVATE (type, i))
 862                     {
 863                       if (section_type != s_private)
 864                         {
 865                           section_type = s_private;
 866                           fprintfi_filtered (level + 2, stream, "private:\n");
 867                         }
 868                     }
 869                   else
 870                     {
 871                       if (section_type != s_public)
 872                         {
 873                           section_type = s_public;
 874                           fprintfi_filtered (level + 2, stream, "public:\n");
 875                         }
 876                     }
 877                 }
 878
 879               print_spaces_filtered (level + 4, stream);
 880               if (TYPE_FIELD_STATIC (type, i))
 881                 {
 882                   fprintf_filtered (stream, "static ");
 883                 }
 884               c_print_type (TYPE_FIELD_TYPE (type, i),
 885                             TYPE_FIELD_NAME (type, i),
 886                             stream, show - 1, level + 4);
 887               if (!TYPE_FIELD_STATIC (type, i)
 888                   && TYPE_FIELD_PACKED (type, i))
 889                 {
 890                   /* It is a bitfield.  This code does not attempt
 891                      to look at the bitpos and reconstruct filler,
 892                      unnamed fields.  This would lead to misleading
 893                      results if the compiler does not put out fields
 894                      for such things (I don't know what it does).  */
 895                   fprintf_filtered (stream, " : %d",
 896                                     TYPE_FIELD_BITSIZE (type, i));
 897                 }
 898               fprintf_filtered (stream, ";\n");
 899             }
 900
 901           /* If there are both fields and methods, put a blank line
 902               between them.  Make sure to count only method that we will
 903               display; artificial methods will be hidden.  */
 904           len = TYPE_NFN_FIELDS (type);
 905           real_len = 0;
 906           for (i = 0; i < len; i++)
 907             {
 908               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 909               int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 910               int j;
 911               for (j = 0; j < len2; j++)
 912                 if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
 913                   real_len++;
 914             }
 915           if (real_len > 0 && section_type != s_none)
 916             fprintf_filtered (stream, "\n");
 917
 918           /* C++: print out the methods */
 919           for (i = 0; i < len; i++)
 920             {
 921               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 922               int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 923               char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
 924               char *name = type_name_no_tag (type);
 925               int is_constructor = name && strcmp (method_name, name) == 0;
 926               for (j = 0; j < len2; j++)
 927                 {
 928                   char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
 929                   int is_full_physname_constructor =
 930                    is_constructor_name (physname)
 931                    || is_destructor_name (physname)
 932                    || method_name[0] == '~';
 933
 934                   /* Do not print out artificial methods.  */
 935                   if (TYPE_FN_FIELD_ARTIFICIAL (f, j))
 936                     continue;
 937
 938                   QUIT;
 939                   if (TYPE_FN_FIELD_PROTECTED (f, j))
 940                     {
 941                       if (section_type != s_protected)
 942                         {
 943                           section_type = s_protected;
 944                           fprintfi_filtered (level + 2, stream,
 945                                              "protected:\n");
 946                         }
 947                     }
 948                   else if (TYPE_FN_FIELD_PRIVATE (f, j))
 949                     {
 950                       if (section_type != s_private)
 951                         {
 952                           section_type = s_private;
 953                           fprintfi_filtered (level + 2, stream, "private:\n");
 954                         }
 955                     }
 956                   else
 957                     {
 958                       if (section_type != s_public)
 959                         {
 960                           section_type = s_public;
 961                           fprintfi_filtered (level + 2, stream, "public:\n");
 962                         }
 963                     }
 964
 965                   print_spaces_filtered (level + 4, stream);
 966                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
 967                     fprintf_filtered (stream, "virtual ");
 968                   else if (TYPE_FN_FIELD_STATIC_P (f, j))
 969                     fprintf_filtered (stream, "static ");
 970                   if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
 971                     {
 972                       /* Keep GDB from crashing here.  */
 973                       fprintf_filtered (stream, _("<undefined type> %s;\n"),
 974                                         TYPE_FN_FIELD_PHYSNAME (f, j));
 975                       break;
 976                     }
 977                   else if (!is_constructor &&   /* constructors don't have declared types */
 978                            !is_full_physname_constructor &&     /*    " "  */
 979                            !is_type_conversion_operator (type, i, j))
 980                     {
 981                       type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
 982                                   "", stream, -1);
 983                       fputs_filtered (" ", stream);
 984                     }
 985                   if (TYPE_FN_FIELD_STUB (f, j))
 986                     /* Build something we can demangle.  */
 987                     mangled_name = gdb_mangle_name (type, i, j);
 988                   else
 989                     mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
 990
 991                   demangled_name =
 992                     cplus_demangle (mangled_name,
 993                                     DMGL_ANSI | DMGL_PARAMS);
 994                   if (demangled_name == NULL)
 995                     {
 996                       /* in some cases (for instance with the HP demangling),
 997                          if a function has more than 10 arguments,
 998                          the demangling will fail.
 999                          Let's try to reconstruct the function signature from
1000                          the symbol information */
1001                       if (!TYPE_FN_FIELD_STUB (f, j))
1002                         {
1003                           int staticp = TYPE_FN_FIELD_STATIC_P (f, j);
1004                           struct type *mtype = TYPE_FN_FIELD_TYPE (f, j);
1005                           cp_type_print_method_args (mtype,
1006                                                      "",
1007                                                      method_name,
1008                                                      staticp,
1009                                                      stream);
1010                         }
1011                       else
1012                         fprintf_filtered (stream, _("<badly mangled name '%s'>"),
1013                                           mangled_name);
1014                     }
1015                   else
1016                     {
1017                       char *p;
1018                       char *demangled_no_class
1019                         = remove_qualifiers (demangled_name);
1020
1021                       /* get rid of the `static' appended by the demangler */
1022                       p = strstr (demangled_no_class, " static");
1023                       if (p != NULL)
1024                         {
1025                           int length = p - demangled_no_class;
1026                           demangled_no_static = (char *) xmalloc (length + 1);
1027                           strncpy (demangled_no_static, demangled_no_class, length);
1028                           *(demangled_no_static + length) = '\0';
1029                           fputs_filtered (demangled_no_static, stream);
1030                           xfree (demangled_no_static);
1031                         }
1032                       else
1033                         fputs_filtered (demangled_no_class, stream);
1034                       xfree (demangled_name);
1035                     }
1036
1037                   if (TYPE_FN_FIELD_STUB (f, j))
1038                     xfree (mangled_name);
1039
1040                   fprintf_filtered (stream, ";\n");
1041                 }
1042             }
1043
1044           fprintfi_filtered (level, stream, "}");
1045
1046           if (TYPE_LOCALTYPE_PTR (type) && show >= 0)
1047             fprintfi_filtered (level, stream, _(" (Local at %s:%d)\n"),
1048                                TYPE_LOCALTYPE_FILE (type),
1049                                TYPE_LOCALTYPE_LINE (type));
1050         }
1051       if (TYPE_CODE (type) == TYPE_CODE_TEMPLATE)
1052         goto go_back;
1053       break;
1054
1055     case TYPE_CODE_ENUM:
1056       c_type_print_modifier (type, stream, 0, 1);
1057       /* HP C supports sized enums */
1058       if (deprecated_hp_som_som_object_present)
1059         switch (TYPE_LENGTH (type))
1060           {
1061           case 1:
1062             fputs_filtered ("char ", stream);
1063             break;
1064           case 2:
1065             fputs_filtered ("short ", stream);
1066             break;
1067           default:
1068             break;
1069           }
1070       fprintf_filtered (stream, "enum ");
1071       /* Print the tag name if it exists.
1072          The aCC compiler emits a spurious
1073          "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1074          tag for unnamed struct/union/enum's, which we don't
1075          want to print. */
1076       if (TYPE_TAG_NAME (type) != NULL &&
1077           strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
1078         {
1079           fputs_filtered (TYPE_TAG_NAME (type), stream);
1080           if (show > 0)
1081             fputs_filtered (" ", stream);
1082         }
1083
1084       wrap_here ("    ");
1085       if (show < 0)
1086         {
1087           /* If we just printed a tag name, no need to print anything else.  */
1088           if (TYPE_TAG_NAME (type) == NULL)
1089             fprintf_filtered (stream, "{...}");
1090         }
1091       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1092         {
1093           fprintf_filtered (stream, "{");
1094           len = TYPE_NFIELDS (type);
1095           lastval = 0;
1096           for (i = 0; i < len; i++)
1097             {
1098               QUIT;
1099               if (i)
1100                 fprintf_filtered (stream, ", ");
1101               wrap_here ("    ");
1102               fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1103               if (lastval != TYPE_FIELD_BITPOS (type, i))
1104                 {
1105                   fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
1106                   lastval = TYPE_FIELD_BITPOS (type, i);
1107                 }
1108               lastval++;
1109             }
1110           fprintf_filtered (stream, "}");
1111         }
1112       break;
1113
1114     case TYPE_CODE_VOID:
1115       fprintf_filtered (stream, "void");
1116       break;
1117
1118     case TYPE_CODE_UNDEF:
1119       fprintf_filtered (stream, _("struct <unknown>"));
1120       break;
1121
1122     case TYPE_CODE_ERROR:
1123       fprintf_filtered (stream, _("<unknown type>"));
1124       break;
1125
1126     case TYPE_CODE_RANGE:
1127       /* This should not occur */
1128       fprintf_filtered (stream, _("<range type>"));
1129       break;
1130
1131     case TYPE_CODE_TEMPLATE:
1132       /* Called on "ptype t" where "t" is a template.
1133          Prints the template header (with args), e.g.:
1134          template <class T1, class T2> class "
1135          and then merges with the struct/union/class code to
1136          print the rest of the definition. */
1137       c_type_print_modifier (type, stream, 0, 1);
1138       fprintf_filtered (stream, "template <");
1139       for (i = 0; i < TYPE_NTEMPLATE_ARGS (type); i++)
1140         {
1141           struct template_arg templ_arg;
1142           templ_arg = TYPE_TEMPLATE_ARG (type, i);
1143           fprintf_filtered (stream, "class %s", templ_arg.name);
1144           if (i < TYPE_NTEMPLATE_ARGS (type) - 1)
1145             fprintf_filtered (stream, ", ");
1146         }
1147       fprintf_filtered (stream, "> class ");
1148       /* Yuck, factor this out to a subroutine so we can call
1149          it and return to the point marked with the "goback:" label... - RT */
1150       goto struct_union;
1151     go_back:
1152       if (TYPE_NINSTANTIATIONS (type) > 0)
1153         {
1154           fprintf_filtered (stream, _("\ntemplate instantiations:\n"));
1155           for (i = 0; i < TYPE_NINSTANTIATIONS (type); i++)
1156             {
1157               fprintf_filtered (stream, "  ");
1158               c_type_print_base (TYPE_INSTANTIATION (type, i), stream, 0, level);
1159               if (i < TYPE_NINSTANTIATIONS (type) - 1)
1160                 fprintf_filtered (stream, "\n");
1161             }
1162         }
1163       break;
1164
1165     case TYPE_CODE_NAMESPACE:
1166       fputs_filtered ("namespace ", stream);
1167       fputs_filtered (TYPE_TAG_NAME (type), stream);
1168       break;
1169
1170     default:
1171       /* Handle types not explicitly handled by the other cases,
1172          such as fundamental types.  For these, just print whatever
1173          the type name is, as recorded in the type itself.  If there
1174          is no type name, then complain. */
1175       if (TYPE_NAME (type) != NULL)
1176         {
1177           c_type_print_modifier (type, stream, 0, 1);
1178           fputs_filtered (TYPE_NAME (type), stream);
1179         }
1180       else
1181         {
1182           /* At least for dump_symtab, it is important that this not be
1183              an error ().  */
1184           fprintf_filtered (stream, _("<invalid type code %d>"),
1185                             TYPE_CODE (type));
1186         }
1187       break;
1188     }
1189 }