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