gdb/c-typeprint.c

   1 /* Support for printing C and C++ types for GDB, the GNU debugger.
   2    Copyright 1986, 1988, 1989, 1991, 1993-1996, 1998-2000
   3    Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 59 Temple Place - Suite 330,
  20    Boston, MA 02111-1307, USA.  */
  21
  22 #include "defs.h"
  23 #include "obstack.h"
  24 #include "bfd.h"                /* Binary File Description */
  25 #include "symtab.h"
  26 #include "gdbtypes.h"
  27 #include "expression.h"
  28 #include "value.h"
  29 #include "gdbcore.h"
  30 #include "target.h"
  31 #include "command.h"
  32 #include "gdbcmd.h"
  33 #include "language.h"
  34 #include "demangle.h"
  35 #include "c-lang.h"
  36 #include "typeprint.h"
  37
  38 #include "gdb_string.h"
  39 #include <errno.h>
  40 #include <ctype.h>
  41
  42 /* Flag indicating target was compiled by HP compiler */
  43 extern int hp_som_som_object_present;
  44
  45 static void cp_type_print_method_args (struct type ** args, char *prefix,
  46                                        char *varstring, int staticp,
  47                                        struct ui_file *stream);
  48
  49 static void c_type_print_args (struct type *, struct ui_file *);
  50
  51 static void cp_type_print_derivation_info (struct ui_file *, struct type *);
  52
  53 void c_type_print_varspec_prefix (struct type *, struct ui_file *, int,
  54                                   int);
  55
  56 static void c_type_print_cv_qualifier (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_cv_qualifier (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_cv_qualifier (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_cv_qualifier (struct type *type, struct ui_file *stream,
 294                            int need_pre_space, int need_post_space)
 295 {
 296   int flag = 0;
 297
 298   if (TYPE_CONST (type))
 299     {
 300       if (need_pre_space)
 301         fprintf_filtered (stream, " ");
 302       fprintf_filtered (stream, "const");
 303       flag = 1;
 304     }
 305
 306   if (TYPE_VOLATILE (type))
 307     {
 308       if (flag || need_pre_space)
 309         fprintf_filtered (stream, " ");
 310       fprintf_filtered (stream, "volatile");
 311       flag = 1;
 312     }
 313
 314   if (flag && need_post_space)
 315     fprintf_filtered (stream, " ");
 316 }
 317
 318
 319
 320
 321 static void
 322 c_type_print_args (struct type *type, struct ui_file *stream)
 323 {
 324   int i;
 325   struct type **args;
 326
 327   fprintf_filtered (stream, "(");
 328   args = TYPE_ARG_TYPES (type);
 329   if (args != NULL)
 330     {
 331       if (args[1] == NULL)
 332         {
 333           fprintf_filtered (stream, "...");
 334         }
 335       else if ((args[1]->code == TYPE_CODE_VOID) &&
 336                (current_language->la_language == language_cplus))
 337         {
 338           fprintf_filtered (stream, "void");
 339         }
 340       else
 341         {
 342           for (i = 1;
 343                args[i] != NULL && args[i]->code != TYPE_CODE_VOID;
 344                i++)
 345             {
 346               c_print_type (args[i], "", stream, -1, 0);
 347               if (args[i + 1] == NULL)
 348                 {
 349                   fprintf_filtered (stream, "...");
 350                 }
 351               else if (args[i + 1]->code != TYPE_CODE_VOID)
 352                 {
 353                   fprintf_filtered (stream, ",");
 354                   wrap_here ("    ");
 355                 }
 356             }
 357         }
 358     }
 359   else if (current_language->la_language == language_cplus)
 360     {
 361       fprintf_filtered (stream, "void");
 362     }
 363
 364   fprintf_filtered (stream, ")");
 365 }
 366
 367
 368 /* Return true iff the j'th overloading of the i'th method of TYPE
 369    is a type conversion operator, like `operator int () { ... }'.
 370    When listing a class's methods, we don't print the return type of
 371    such operators.  */
 372 static int
 373 is_type_conversion_operator (struct type *type, int i, int j)
 374 {
 375   /* I think the whole idea of recognizing type conversion operators
 376      by their name is pretty terrible.  But I don't think our present
 377      data structure gives us any other way to tell.  If you know of
 378      some other way, feel free to rewrite this function.  */
 379   char *name = TYPE_FN_FIELDLIST_NAME (type, i);
 380
 381   if (strncmp (name, "operator", 8) != 0)
 382     return 0;
 383
 384   name += 8;
 385   if (! strchr (" \t\f\n\r", *name))
 386     return 0;
 387
 388   while (strchr (" \t\f\n\r", *name))
 389     name++;
 390
 391   if (strncmp (name, "new", 3) == 0)
 392     name += 3;
 393   else if (strncmp (name, "delete", 6) == 0)
 394     name += 6;
 395   else
 396     return 0;
 397
 398   /* Is that really the end of the name?  */
 399   if (('a' <= *name && *name <= 'z')
 400       || ('A' <= *name && *name <= 'Z')
 401       || ('0' <= *name && *name <= '9')
 402       || *name == '_')
 403     /* No, so the identifier following "operator" must be a type name,
 404        and this is a type conversion operator.  */
 405     return 1;
 406
 407   /* That was indeed the end of the name, so it was `operator new' or
 408      `operator delete', neither of which are type conversion operators.  */
 409   return 0;
 410 }
 411
 412
 413 /* Given a C++ qualified identifier QID, strip off the qualifiers,
 414    yielding the unqualified name.  The return value is a pointer into
 415    the original string.
 416
 417    It's a pity we don't have this information in some more structured
 418    form.  Even the author of this function feels that writing little
 419    parsers like this everywhere is stupid.  */
 420 static char *
 421 remove_qualifiers (char *qid)
 422 {
 423   int quoted = 0;               /* zero if we're not in quotes;
 424                                    '"' if we're in a double-quoted string;
 425                                    '\'' if we're in a single-quoted string.  */
 426   int depth = 0;                /* number of unclosed parens we've seen */
 427   char *parenstack = (char *) alloca (strlen (qid));
 428   char *scan;
 429   char *last = 0;               /* The character after the rightmost
 430                                    `::' token we've seen so far.  */
 431
 432   for (scan = qid; *scan; scan++)
 433     {
 434       if (quoted)
 435         {
 436           if (*scan == quoted)
 437             quoted = 0;
 438           else if (*scan == '\\' && *(scan + 1))
 439             scan++;
 440         }
 441       else if (scan[0] == ':' && scan[1] == ':')
 442         {
 443           /* If we're inside parenthesis (i.e., an argument list) or
 444              angle brackets (i.e., a list of template arguments), then
 445              we don't record the position of this :: token, since it's
 446              not relevant to the top-level structure we're trying
 447              to operate on.  */
 448           if (depth == 0)
 449             {
 450               last = scan + 2;
 451               scan++;
 452             }
 453         }
 454       else if (*scan == '"' || *scan == '\'')
 455         quoted = *scan;
 456       else if (*scan == '(')
 457         parenstack[depth++] = ')';
 458       else if (*scan == '[')
 459         parenstack[depth++] = ']';
 460       /* We're going to treat <> as a pair of matching characters,
 461          since we're more likely to see those in template id's than
 462          real less-than characters.  What a crock.  */
 463       else if (*scan == '<')
 464         parenstack[depth++] = '>';
 465       else if (*scan == ')' || *scan == ']' || *scan == '>')
 466         {
 467           if (depth > 0 && parenstack[depth - 1] == *scan)
 468             depth--;
 469           else
 470             {
 471               /* We're going to do a little error recovery here.  If we
 472                  don't find a match for *scan on the paren stack, but
 473                  there is something lower on the stack that does match, we
 474                  pop the stack to that point.  */
 475               int i;
 476
 477               for (i = depth - 1; i >= 0; i--)
 478                 if (parenstack[i] == *scan)
 479                   {
 480                     depth = i;
 481                     break;
 482                   }
 483             }
 484         }
 485     }
 486
 487   if (last)
 488     return last;
 489   else
 490     /* We didn't find any :: tokens at the top level, so declare the
 491        whole thing an unqualified identifier.  */
 492     return qid;
 493 }
 494
 495
 496 /* Print any array sizes, function arguments or close parentheses
 497    needed after the variable name (to describe its type).
 498    Args work like c_type_print_varspec_prefix.  */
 499
 500 void
 501 c_type_print_varspec_suffix (struct type *type, struct ui_file *stream,
 502                              int show, int passed_a_ptr, int demangled_args)
 503 {
 504   if (type == 0)
 505     return;
 506
 507   if (TYPE_NAME (type) && show <= 0)
 508     return;
 509
 510   QUIT;
 511
 512   switch (TYPE_CODE (type))
 513     {
 514     case TYPE_CODE_ARRAY:
 515       if (passed_a_ptr)
 516         fprintf_filtered (stream, ")");
 517
 518       fprintf_filtered (stream, "[");
 519       if (TYPE_LENGTH (type) >= 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
 520         && TYPE_ARRAY_UPPER_BOUND_TYPE (type) != BOUND_CANNOT_BE_DETERMINED)
 521         fprintf_filtered (stream, "%d",
 522                           (TYPE_LENGTH (type)
 523                            / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
 524       fprintf_filtered (stream, "]");
 525
 526       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
 527       break;
 528
 529     case TYPE_CODE_MEMBER:
 530       if (passed_a_ptr)
 531         fprintf_filtered (stream, ")");
 532       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
 533       break;
 534
 535     case TYPE_CODE_METHOD:
 536       if (passed_a_ptr)
 537         fprintf_filtered (stream, ")");
 538       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
 539       if (passed_a_ptr)
 540         {
 541           c_type_print_args (type, stream);
 542         }
 543       break;
 544
 545     case TYPE_CODE_PTR:
 546     case TYPE_CODE_REF:
 547       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 1, 0);
 548       break;
 549
 550     case TYPE_CODE_FUNC:
 551       if (passed_a_ptr)
 552         fprintf_filtered (stream, ")");
 553       if (!demangled_args)
 554         {
 555           int i, len = TYPE_NFIELDS (type);
 556           fprintf_filtered (stream, "(");
 557           if ((len == 0) && (current_language->la_language == language_cplus))
 558             {
 559               fprintf_filtered (stream, "void");
 560             }
 561           else
 562             for (i = 0; i < len; i++)
 563               {
 564                 if (i > 0)
 565                   {
 566                     fputs_filtered (", ", stream);
 567                     wrap_here ("    ");
 568                   }
 569                 c_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
 570               }
 571           fprintf_filtered (stream, ")");
 572         }
 573       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
 574                                    passed_a_ptr, 0);
 575       break;
 576
 577     case TYPE_CODE_UNDEF:
 578     case TYPE_CODE_STRUCT:
 579     case TYPE_CODE_UNION:
 580     case TYPE_CODE_ENUM:
 581     case TYPE_CODE_INT:
 582     case TYPE_CODE_FLT:
 583     case TYPE_CODE_VOID:
 584     case TYPE_CODE_ERROR:
 585     case TYPE_CODE_CHAR:
 586     case TYPE_CODE_BOOL:
 587     case TYPE_CODE_SET:
 588     case TYPE_CODE_RANGE:
 589     case TYPE_CODE_STRING:
 590     case TYPE_CODE_BITSTRING:
 591     case TYPE_CODE_COMPLEX:
 592     case TYPE_CODE_TYPEDEF:
 593     case TYPE_CODE_TEMPLATE:
 594       /* These types do not need a suffix.  They are listed so that
 595          gcc -Wall will report types that may not have been considered.  */
 596       break;
 597     default:
 598       error ("type not handled in c_type_print_varspec_suffix()");
 599       break;
 600     }
 601 }
 602
 603 /* Print the name of the type (or the ultimate pointer target,
 604    function value or array element), or the description of a
 605    structure or union.
 606
 607    SHOW positive means print details about the type (e.g. enum values),
 608    and print structure elements passing SHOW - 1 for show.
 609    SHOW negative means just print the type name or struct tag if there is one.
 610    If there is no name, print something sensible but concise like
 611    "struct {...}".
 612    SHOW zero means just print the type name or struct tag if there is one.
 613    If there is no name, print something sensible but not as concise like
 614    "struct {int x; int y;}".
 615
 616    LEVEL is the number of spaces to indent by.
 617    We increase it for some recursive calls.  */
 618
 619 void
 620 c_type_print_base (struct type *type, struct ui_file *stream, int show,
 621                    int level)
 622 {
 623   register int i;
 624   register int len;
 625   register int lastval;
 626   char *mangled_name;
 627   char *demangled_name;
 628   char *demangled_no_static;
 629   enum
 630     {
 631       s_none, s_public, s_private, s_protected
 632     }
 633   section_type;
 634   int need_access_label = 0;
 635   int j, len2;
 636
 637   QUIT;
 638
 639   wrap_here ("    ");
 640   if (type == NULL)
 641     {
 642       fputs_filtered ("<type unknown>", stream);
 643       return;
 644     }
 645
 646   /* When SHOW is zero or less, and there is a valid type name, then always
 647      just print the type name directly from the type.  */
 648   /* If we have "typedef struct foo {. . .} bar;" do we want to print it
 649      as "struct foo" or as "bar"?  Pick the latter, because C++ folk tend
 650      to expect things like "class5 *foo" rather than "struct class5 *foo".  */
 651
 652   if (show <= 0
 653       && TYPE_NAME (type) != NULL)
 654     {
 655       c_type_print_cv_qualifier (type, stream, 0, 1);
 656       fputs_filtered (TYPE_NAME (type), stream);
 657       return;
 658     }
 659
 660   CHECK_TYPEDEF (type);
 661
 662   switch (TYPE_CODE (type))
 663     {
 664     case TYPE_CODE_TYPEDEF:
 665     case TYPE_CODE_ARRAY:
 666     case TYPE_CODE_PTR:
 667     case TYPE_CODE_MEMBER:
 668     case TYPE_CODE_REF:
 669     case TYPE_CODE_FUNC:
 670     case TYPE_CODE_METHOD:
 671       c_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
 672       break;
 673
 674     case TYPE_CODE_STRUCT:
 675       c_type_print_cv_qualifier (type, stream, 0, 1);
 676       /* Note TYPE_CODE_STRUCT and TYPE_CODE_CLASS have the same value,
 677        * so we use another means for distinguishing them.
 678        */
 679       if (HAVE_CPLUS_STRUCT (type))
 680         {
 681           switch (TYPE_DECLARED_TYPE (type))
 682             {
 683             case DECLARED_TYPE_CLASS:
 684               fprintf_filtered (stream, "class ");
 685               break;
 686             case DECLARED_TYPE_UNION:
 687               fprintf_filtered (stream, "union ");
 688               break;
 689             case DECLARED_TYPE_STRUCT:
 690               fprintf_filtered (stream, "struct ");
 691               break;
 692             default:
 693               /* If there is a CPLUS_STRUCT, assume class if not
 694                * otherwise specified in the declared_type field.
 695                */
 696               fprintf_filtered (stream, "class ");
 697               break;
 698             }                   /* switch */
 699         }
 700       else
 701         {
 702           /* If not CPLUS_STRUCT, then assume it's a C struct */
 703           fprintf_filtered (stream, "struct ");
 704         }
 705       goto struct_union;
 706
 707     case TYPE_CODE_UNION:
 708       c_type_print_cv_qualifier (type, stream, 0, 1);
 709       fprintf_filtered (stream, "union ");
 710
 711     struct_union:
 712
 713       /* Print the tag if it exists.
 714        * The HP aCC compiler emits
 715        * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
 716        * tag  for unnamed struct/union/enum's, which we don't
 717        * want to print.
 718        */
 719       if (TYPE_TAG_NAME (type) != NULL &&
 720           strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
 721         {
 722           fputs_filtered (TYPE_TAG_NAME (type), stream);
 723           if (show > 0)
 724             fputs_filtered (" ", stream);
 725         }
 726       wrap_here ("    ");
 727       if (show < 0)
 728         {
 729           /* If we just printed a tag name, no need to print anything else.  */
 730           if (TYPE_TAG_NAME (type) == NULL)
 731             fprintf_filtered (stream, "{...}");
 732         }
 733       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
 734         {
 735           cp_type_print_derivation_info (stream, type);
 736
 737           fprintf_filtered (stream, "{\n");
 738           if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
 739             {
 740               if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
 741                 fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
 742               else
 743                 fprintfi_filtered (level + 4, stream, "<no data fields>\n");
 744             }
 745
 746           /* Start off with no specific section type, so we can print
 747              one for the first field we find, and use that section type
 748              thereafter until we find another type. */
 749
 750           section_type = s_none;
 751
 752           /* For a class, if all members are private, there's no need
 753              for a "private:" label; similarly, for a struct or union
 754              masquerading as a class, if all members are public, there's
 755              no need for a "public:" label. */
 756
 757           if ((TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_CLASS) ||
 758               (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_TEMPLATE))
 759             {
 760               QUIT;
 761               len = TYPE_NFIELDS (type);
 762               for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 763                 if (!TYPE_FIELD_PRIVATE (type, i))
 764                   {
 765                     need_access_label = 1;
 766                     break;
 767                   }
 768               QUIT;
 769               if (!need_access_label)
 770                 {
 771                   len2 = TYPE_NFN_FIELDS (type);
 772                   for (j = 0; j < len2; j++)
 773                     {
 774                       len = TYPE_FN_FIELDLIST_LENGTH (type, j);
 775                       for (i = 0; i < len; i++)
 776                         if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i))
 777                           {
 778                             need_access_label = 1;
 779                             break;
 780                           }
 781                       if (need_access_label)
 782                         break;
 783                     }
 784                 }
 785             }
 786           else if ((TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_STRUCT) ||
 787                    (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_UNION))
 788             {
 789               QUIT;
 790               len = TYPE_NFIELDS (type);
 791               for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 792                 if (TYPE_FIELD_PRIVATE (type, i) || TYPE_FIELD_PROTECTED (type, i))
 793                   {
 794                     need_access_label = 1;
 795                     break;
 796                   }
 797               QUIT;
 798               if (!need_access_label)
 799                 {
 800                   len2 = TYPE_NFN_FIELDS (type);
 801                   for (j = 0; j < len2; j++)
 802                     {
 803                       QUIT;
 804                       len = TYPE_FN_FIELDLIST_LENGTH (type, j);
 805                       for (i = 0; i < len; i++)
 806                         if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i) ||
 807                             TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type, j), i))
 808                           {
 809                             need_access_label = 1;
 810                             break;
 811                           }
 812                       if (need_access_label)
 813                         break;
 814                     }
 815                 }
 816             }
 817
 818           /* If there is a base class for this type,
 819              do not print the field that it occupies.  */
 820
 821           len = TYPE_NFIELDS (type);
 822           for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 823             {
 824               QUIT;
 825               /* Don't print out virtual function table.  */
 826               /* HP ANSI C++ case */
 827               if (TYPE_HAS_VTABLE (type) && (STREQN (TYPE_FIELD_NAME (type, i), "__vfp", 5)))
 828                 continue;
 829               /* Other compilers */
 830               if (STREQN (TYPE_FIELD_NAME (type, i), "_vptr", 5)
 831                   && is_cplus_marker ((TYPE_FIELD_NAME (type, i))[5]))
 832                 continue;
 833
 834               /* If this is a C++ class we can print the various C++ section
 835                  labels. */
 836
 837               if (HAVE_CPLUS_STRUCT (type) && need_access_label)
 838                 {
 839                   if (TYPE_FIELD_PROTECTED (type, i))
 840                     {
 841                       if (section_type != s_protected)
 842                         {
 843                           section_type = s_protected;
 844                           fprintfi_filtered (level + 2, stream,
 845                                              "protected:\n");
 846                         }
 847                     }
 848                   else if (TYPE_FIELD_PRIVATE (type, i))
 849                     {
 850                       if (section_type != s_private)
 851                         {
 852                           section_type = s_private;
 853                           fprintfi_filtered (level + 2, stream, "private:\n");
 854                         }
 855                     }
 856                   else
 857                     {
 858                       if (section_type != s_public)
 859                         {
 860                           section_type = s_public;
 861                           fprintfi_filtered (level + 2, stream, "public:\n");
 862                         }
 863                     }
 864                 }
 865
 866               print_spaces_filtered (level + 4, stream);
 867               if (TYPE_FIELD_STATIC (type, i))
 868                 {
 869                   fprintf_filtered (stream, "static ");
 870                 }
 871               c_print_type (TYPE_FIELD_TYPE (type, i),
 872                             TYPE_FIELD_NAME (type, i),
 873                             stream, show - 1, level + 4);
 874               if (!TYPE_FIELD_STATIC (type, i)
 875                   && TYPE_FIELD_PACKED (type, i))
 876                 {
 877                   /* It is a bitfield.  This code does not attempt
 878                      to look at the bitpos and reconstruct filler,
 879                      unnamed fields.  This would lead to misleading
 880                      results if the compiler does not put out fields
 881                      for such things (I don't know what it does).  */
 882                   fprintf_filtered (stream, " : %d",
 883                                     TYPE_FIELD_BITSIZE (type, i));
 884                 }
 885               fprintf_filtered (stream, ";\n");
 886             }
 887
 888           /* If there are both fields and methods, put a space between. */
 889           len = TYPE_NFN_FIELDS (type);
 890           if (len && section_type != s_none)
 891             fprintf_filtered (stream, "\n");
 892
 893           /* C++: print out the methods */
 894           for (i = 0; i < len; i++)
 895             {
 896               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 897               int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 898               char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
 899               char *name = type_name_no_tag (type);
 900               int is_constructor = name && STREQ (method_name, name);
 901               for (j = 0; j < len2; j++)
 902                 {
 903                   char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
 904                   int is_full_physname_constructor =
 905                   ((physname[0] == '_' && physname[1] == '_'
 906                     && strchr ("0123456789Qt", physname[2]))
 907                    || STREQN (physname, "__ct__", 6)
 908                    || DESTRUCTOR_PREFIX_P (physname)
 909                    || STREQN (physname, "__dt__", 6));
 910
 911                   QUIT;
 912                   if (TYPE_FN_FIELD_PROTECTED (f, j))
 913                     {
 914                       if (section_type != s_protected)
 915                         {
 916                           section_type = s_protected;
 917                           fprintfi_filtered (level + 2, stream,
 918                                              "protected:\n");
 919                         }
 920                     }
 921                   else if (TYPE_FN_FIELD_PRIVATE (f, j))
 922                     {
 923                       if (section_type != s_private)
 924                         {
 925                           section_type = s_private;
 926                           fprintfi_filtered (level + 2, stream, "private:\n");
 927                         }
 928                     }
 929                   else
 930                     {
 931                       if (section_type != s_public)
 932                         {
 933                           section_type = s_public;
 934                           fprintfi_filtered (level + 2, stream, "public:\n");
 935                         }
 936                     }
 937
 938                   print_spaces_filtered (level + 4, stream);
 939                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
 940                     fprintf_filtered (stream, "virtual ");
 941                   else if (TYPE_FN_FIELD_STATIC_P (f, j))
 942                     fprintf_filtered (stream, "static ");
 943                   if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
 944                     {
 945                       /* Keep GDB from crashing here.  */
 946                       fprintf_filtered (stream, "<undefined type> %s;\n",
 947                                         TYPE_FN_FIELD_PHYSNAME (f, j));
 948                       break;
 949                     }
 950                   else if (!is_constructor &&   /* constructors don't have declared types */
 951                            !is_full_physname_constructor &&     /*    " "  */
 952                            !is_type_conversion_operator (type, i, j))
 953                     {
 954                       type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
 955                                   "", stream, -1);
 956                       fputs_filtered (" ", stream);
 957                     }
 958                   if (TYPE_FN_FIELD_STUB (f, j))
 959                     /* Build something we can demangle.  */
 960                     mangled_name = gdb_mangle_name (type, i, j);
 961                   else
 962                     mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
 963
 964                   demangled_name =
 965                     cplus_demangle (mangled_name,
 966                                     DMGL_ANSI | DMGL_PARAMS);
 967                   if (demangled_name == NULL)
 968                     {
 969                       /* in some cases (for instance with the HP demangling),
 970                          if a function has more than 10 arguments,
 971                          the demangling will fail.
 972                          Let's try to reconstruct the function signature from
 973                          the symbol information */
 974                       if (!TYPE_FN_FIELD_STUB (f, j))
 975                         cp_type_print_method_args (TYPE_FN_FIELD_ARGS (f, j), "",
 976                                                    method_name,
 977                                               TYPE_FN_FIELD_STATIC_P (f, j),
 978                                                    stream);
 979                       else
 980                         fprintf_filtered (stream, "<badly mangled name '%s'>",
 981                                           mangled_name);
 982                     }
 983                   else
 984                     {
 985                       char *p;
 986                       char *demangled_no_class
 987                         = remove_qualifiers (demangled_name);
 988
 989                       /* get rid of the `static' appended by the demangler */
 990                       p = strstr (demangled_no_class, " static");
 991                       if (p != NULL)
 992                         {
 993                           int length = p - demangled_no_class;
 994                           demangled_no_static = (char *) xmalloc (length + 1);
 995                           strncpy (demangled_no_static, demangled_no_class, length);
 996                           *(demangled_no_static + length) = '\0';
 997                           fputs_filtered (demangled_no_static, stream);
 998                           free (demangled_no_static);
 999                         }
1000                       else
1001                         fputs_filtered (demangled_no_class, stream);
1002                       free (demangled_name);
1003                     }
1004
1005                   if (TYPE_FN_FIELD_STUB (f, j))
1006                     free (mangled_name);
1007
1008                   fprintf_filtered (stream, ";\n");
1009                 }
1010             }
1011
1012           fprintfi_filtered (level, stream, "}");
1013
1014           if (TYPE_LOCALTYPE_PTR (type) && show >= 0)
1015             fprintfi_filtered (level, stream, " (Local at %s:%d)\n",
1016                                TYPE_LOCALTYPE_FILE (type),
1017                                TYPE_LOCALTYPE_LINE (type));
1018         }
1019       if (TYPE_CODE (type) == TYPE_CODE_TEMPLATE)
1020         goto go_back;
1021       break;
1022
1023     case TYPE_CODE_ENUM:
1024       c_type_print_cv_qualifier (type, stream, 0, 1);
1025       /* HP C supports sized enums */
1026       if (hp_som_som_object_present)
1027         switch (TYPE_LENGTH (type))
1028           {
1029           case 1:
1030             fputs_filtered ("char ", stream);
1031             break;
1032           case 2:
1033             fputs_filtered ("short ", stream);
1034             break;
1035           default:
1036             break;
1037           }
1038       fprintf_filtered (stream, "enum ");
1039       /* Print the tag name if it exists.
1040          The aCC compiler emits a spurious
1041          "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1042          tag for unnamed struct/union/enum's, which we don't
1043          want to print. */
1044       if (TYPE_TAG_NAME (type) != NULL &&
1045           strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
1046         {
1047           fputs_filtered (TYPE_TAG_NAME (type), stream);
1048           if (show > 0)
1049             fputs_filtered (" ", stream);
1050         }
1051
1052       wrap_here ("    ");
1053       if (show < 0)
1054         {
1055           /* If we just printed a tag name, no need to print anything else.  */
1056           if (TYPE_TAG_NAME (type) == NULL)
1057             fprintf_filtered (stream, "{...}");
1058         }
1059       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1060         {
1061           fprintf_filtered (stream, "{");
1062           len = TYPE_NFIELDS (type);
1063           lastval = 0;
1064           for (i = 0; i < len; i++)
1065             {
1066               QUIT;
1067               if (i)
1068                 fprintf_filtered (stream, ", ");
1069               wrap_here ("    ");
1070               fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1071               if (lastval != TYPE_FIELD_BITPOS (type, i))
1072                 {
1073                   fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
1074                   lastval = TYPE_FIELD_BITPOS (type, i);
1075                 }
1076               lastval++;
1077             }
1078           fprintf_filtered (stream, "}");
1079         }
1080       break;
1081
1082     case TYPE_CODE_VOID:
1083       fprintf_filtered (stream, "void");
1084       break;
1085
1086     case TYPE_CODE_UNDEF:
1087       fprintf_filtered (stream, "struct <unknown>");
1088       break;
1089
1090     case TYPE_CODE_ERROR:
1091       fprintf_filtered (stream, "<unknown type>");
1092       break;
1093
1094     case TYPE_CODE_RANGE:
1095       /* This should not occur */
1096       fprintf_filtered (stream, "<range type>");
1097       break;
1098
1099     case TYPE_CODE_TEMPLATE:
1100       /* Called on "ptype t" where "t" is a template.
1101          Prints the template header (with args), e.g.:
1102          template <class T1, class T2> class "
1103          and then merges with the struct/union/class code to
1104          print the rest of the definition. */
1105       c_type_print_cv_qualifier (type, stream, 0, 1);
1106       fprintf_filtered (stream, "template <");
1107       for (i = 0; i < TYPE_NTEMPLATE_ARGS (type); i++)
1108         {
1109           struct template_arg templ_arg;
1110           templ_arg = TYPE_TEMPLATE_ARG (type, i);
1111           fprintf_filtered (stream, "class %s", templ_arg.name);
1112           if (i < TYPE_NTEMPLATE_ARGS (type) - 1)
1113             fprintf_filtered (stream, ", ");
1114         }
1115       fprintf_filtered (stream, "> class ");
1116       /* Yuck, factor this out to a subroutine so we can call
1117          it and return to the point marked with the "goback:" label... - RT */
1118       goto struct_union;
1119     go_back:
1120       if (TYPE_NINSTANTIATIONS (type) > 0)
1121         {
1122           fprintf_filtered (stream, "\ntemplate instantiations:\n");
1123           for (i = 0; i < TYPE_NINSTANTIATIONS (type); i++)
1124             {
1125               fprintf_filtered (stream, "  ");
1126               c_type_print_base (TYPE_INSTANTIATION (type, i), stream, 0, level);
1127               if (i < TYPE_NINSTANTIATIONS (type) - 1)
1128                 fprintf_filtered (stream, "\n");
1129             }
1130         }
1131       break;
1132
1133     default:
1134       /* Handle types not explicitly handled by the other cases,
1135          such as fundamental types.  For these, just print whatever
1136          the type name is, as recorded in the type itself.  If there
1137          is no type name, then complain. */
1138       if (TYPE_NAME (type) != NULL)
1139         {
1140           c_type_print_cv_qualifier (type, stream, 0, 1);
1141           fputs_filtered (TYPE_NAME (type), stream);
1142         }
1143       else
1144         {
1145           /* At least for dump_symtab, it is important that this not be
1146              an error ().  */
1147           fprintf_filtered (stream, "<invalid type code %d>",
1148                             TYPE_CODE (type));
1149         }
1150       break;
1151     }
1152 }