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