gdb/c-typeprint.c

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