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