gdb/c-typeprint.c

   1 /* Support for printing C and C++ types for GDB, the GNU debugger.
   2    Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
   3    1999, 2000, 2001, 2002
   4    Free Software Foundation, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 59 Temple Place - Suite 330,
  21    Boston, MA 02111-1307, USA.  */
  22
  23 #include "defs.h"
  24 #include "obstack.h"
  25 #include "bfd.h"                /* Binary File Description */
  26 #include "symtab.h"
  27 #include "gdbtypes.h"
  28 #include "expression.h"
  29 #include "value.h"
  30 #include "gdbcore.h"
  31 #include "target.h"
  32 #include "language.h"
  33 #include "demangle.h"
  34 #include "c-lang.h"
  35 #include "typeprint.h"
  36 #include "cp-abi.h"
  37
  38 #include "gdb_string.h"
  39 #include <errno.h>
  40
  41 /* Flag indicating target was compiled by HP compiler */
  42 extern int hp_som_som_object_present;
  43
  44 static void cp_type_print_method_args (struct type *mtype, char *prefix,
  45                                        char *varstring, int staticp,
  46                                        struct ui_file *stream);
  47
  48 static void c_type_print_args (struct type *, struct ui_file *);
  49
  50 static void cp_type_print_derivation_info (struct ui_file *, struct type *);
  51
  52 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
 151 /* Print the C++ method arguments ARGS to the file STREAM.  */
 152
 153 static void
 154 cp_type_print_method_args (struct type *mtype, char *prefix, char *varstring,
 155                            int staticp, struct ui_file *stream)
 156 {
 157   struct field *args = TYPE_FIELDS (mtype);
 158   int nargs = TYPE_NFIELDS (mtype);
 159   int varargs = TYPE_VARARGS (mtype);
 160   int i;
 161
 162   fprintf_symbol_filtered (stream, prefix, language_cplus, DMGL_ANSI);
 163   fprintf_symbol_filtered (stream, varstring, language_cplus, DMGL_ANSI);
 164   fputs_filtered ("(", stream);
 165
 166   /* Skip the class variable.  */
 167   i = staticp ? 0 : 1;
 168   if (nargs > i)
 169     {
 170       while (i < nargs)
 171         {
 172           type_print (args[i++].type, "", stream, 0);
 173
 174           if (i == nargs && varargs)
 175             fprintf_filtered (stream, ", ...");
 176           else if (i < nargs)
 177             fprintf_filtered (stream, ", ");
 178         }
 179     }
 180   else if (varargs)
 181     fprintf_filtered (stream, "...");
 182   else if (current_language->la_language == language_cplus)
 183     fprintf_filtered (stream, "void");
 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_INSTANCE_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 field *args;
 340
 341   fprintf_filtered (stream, "(");
 342   args = TYPE_FIELDS (type);
 343   if (args != NULL)
 344     {
 345       int i;
 346
 347       /* FIXME drow/2002-05-31: Always skips the first argument,
 348          should we be checking for static members?  */
 349
 350       for (i = 1; i < TYPE_NFIELDS (type); i++)
 351         {
 352           c_print_type (args[i].type, "", stream, -1, 0);
 353           if (i != TYPE_NFIELDS (type))
 354             {
 355               fprintf_filtered (stream, ",");
 356               wrap_here ("    ");
 357             }
 358         }
 359       if (TYPE_VARARGS (type))
 360         fprintf_filtered (stream, "...");
 361       else if (i == 1
 362                && (current_language->la_language == language_cplus))
 363         fprintf_filtered (stream, "void");
 364     }
 365   else if (current_language->la_language == language_cplus)
 366     {
 367       fprintf_filtered (stream, "void");
 368     }
 369
 370   fprintf_filtered (stream, ")");
 371 }
 372
 373
 374 /* Return true iff the j'th overloading of the i'th method of TYPE
 375    is a type conversion operator, like `operator int () { ... }'.
 376    When listing a class's methods, we don't print the return type of
 377    such operators.  */
 378 static int
 379 is_type_conversion_operator (struct type *type, int i, int j)
 380 {
 381   /* I think the whole idea of recognizing type conversion operators
 382      by their name is pretty terrible.  But I don't think our present
 383      data structure gives us any other way to tell.  If you know of
 384      some other way, feel free to rewrite this function.  */
 385   char *name = TYPE_FN_FIELDLIST_NAME (type, i);
 386
 387   if (strncmp (name, "operator", 8) != 0)
 388     return 0;
 389
 390   name += 8;
 391   if (! strchr (" \t\f\n\r", *name))
 392     return 0;
 393
 394   while (strchr (" \t\f\n\r", *name))
 395     name++;
 396
 397   if (!('a' <= *name && *name <= 'z')
 398       && !('A' <= *name && *name <= 'Z')
 399       && *name != '_')
 400     /* If this doesn't look like the start of an identifier, then it
 401        isn't a type conversion operator.  */
 402     return 0;
 403   else if (strncmp (name, "new", 3) == 0)
 404     name += 3;
 405   else if (strncmp (name, "delete", 6) == 0)
 406     name += 6;
 407   else
 408     /* If it doesn't look like new or delete, it's a type conversion
 409        operator.  */
 410     return 1;
 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
 572               && (TYPE_PROTOTYPED (type)
 573                   || current_language->la_language == language_cplus))
 574             {
 575               fprintf_filtered (stream, "void");
 576             }
 577           else
 578             for (i = 0; i < len; i++)
 579               {
 580                 if (i > 0)
 581                   {
 582                     fputs_filtered (", ", stream);
 583                     wrap_here ("    ");
 584                   }
 585                 c_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
 586               }
 587           fprintf_filtered (stream, ")");
 588         }
 589       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
 590                                    passed_a_ptr, 0);
 591       break;
 592
 593     case TYPE_CODE_UNDEF:
 594     case TYPE_CODE_STRUCT:
 595     case TYPE_CODE_UNION:
 596     case TYPE_CODE_ENUM:
 597     case TYPE_CODE_INT:
 598     case TYPE_CODE_FLT:
 599     case TYPE_CODE_VOID:
 600     case TYPE_CODE_ERROR:
 601     case TYPE_CODE_CHAR:
 602     case TYPE_CODE_BOOL:
 603     case TYPE_CODE_SET:
 604     case TYPE_CODE_RANGE:
 605     case TYPE_CODE_STRING:
 606     case TYPE_CODE_BITSTRING:
 607     case TYPE_CODE_COMPLEX:
 608     case TYPE_CODE_TYPEDEF:
 609     case TYPE_CODE_TEMPLATE:
 610       /* These types do not need a suffix.  They are listed so that
 611          gcc -Wall will report types that may not have been considered.  */
 612       break;
 613     default:
 614       error ("type not handled in c_type_print_varspec_suffix()");
 615       break;
 616     }
 617 }
 618
 619 /* Print the name of the type (or the ultimate pointer target,
 620    function value or array element), or the description of a
 621    structure or union.
 622
 623    SHOW positive means print details about the type (e.g. enum values),
 624    and print structure elements passing SHOW - 1 for show.
 625    SHOW negative means just print the type name or struct tag if there is one.
 626    If there is no name, print something sensible but concise like
 627    "struct {...}".
 628    SHOW zero means just print the type name or struct tag if there is one.
 629    If there is no name, print something sensible but not as concise like
 630    "struct {int x; int y;}".
 631
 632    LEVEL is the number of spaces to indent by.
 633    We increase it for some recursive calls.  */
 634
 635 void
 636 c_type_print_base (struct type *type, struct ui_file *stream, int show,
 637                    int level)
 638 {
 639   int i;
 640   int len, real_len;
 641   int lastval;
 642   char *mangled_name;
 643   char *demangled_name;
 644   char *demangled_no_static;
 645   enum
 646     {
 647       s_none, s_public, s_private, s_protected
 648     }
 649   section_type;
 650   int need_access_label = 0;
 651   int j, len2;
 652
 653   QUIT;
 654
 655   wrap_here ("    ");
 656   if (type == NULL)
 657     {
 658       fputs_filtered ("<type unknown>", stream);
 659       return;
 660     }
 661
 662   /* When SHOW is zero or less, and there is a valid type name, then always
 663      just print the type name directly from the type.  */
 664   /* If we have "typedef struct foo {. . .} bar;" do we want to print it
 665      as "struct foo" or as "bar"?  Pick the latter, because C++ folk tend
 666      to expect things like "class5 *foo" rather than "struct class5 *foo".  */
 667
 668   if (show <= 0
 669       && TYPE_NAME (type) != NULL)
 670     {
 671       c_type_print_modifier (type, stream, 0, 1);
 672       fputs_filtered (TYPE_NAME (type), stream);
 673       return;
 674     }
 675
 676   CHECK_TYPEDEF (type);
 677
 678   switch (TYPE_CODE (type))
 679     {
 680     case TYPE_CODE_TYPEDEF:
 681     case TYPE_CODE_ARRAY:
 682     case TYPE_CODE_PTR:
 683     case TYPE_CODE_MEMBER:
 684     case TYPE_CODE_REF:
 685     case TYPE_CODE_FUNC:
 686     case TYPE_CODE_METHOD:
 687       c_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
 688       break;
 689
 690     case TYPE_CODE_STRUCT:
 691       c_type_print_modifier (type, stream, 0, 1);
 692       /* Note TYPE_CODE_STRUCT and TYPE_CODE_CLASS have the same value,
 693        * so we use another means for distinguishing them.
 694        */
 695       if (HAVE_CPLUS_STRUCT (type))
 696         {
 697           switch (TYPE_DECLARED_TYPE (type))
 698             {
 699             case DECLARED_TYPE_CLASS:
 700               fprintf_filtered (stream, "class ");
 701               break;
 702             case DECLARED_TYPE_UNION:
 703               fprintf_filtered (stream, "union ");
 704               break;
 705             case DECLARED_TYPE_STRUCT:
 706               fprintf_filtered (stream, "struct ");
 707               break;
 708             default:
 709               /* If there is a CPLUS_STRUCT, assume class if not
 710                * otherwise specified in the declared_type field.
 711                */
 712               fprintf_filtered (stream, "class ");
 713               break;
 714             }                   /* switch */
 715         }
 716       else
 717         {
 718           /* If not CPLUS_STRUCT, then assume it's a C struct */
 719           fprintf_filtered (stream, "struct ");
 720         }
 721       goto struct_union;
 722
 723     case TYPE_CODE_UNION:
 724       c_type_print_modifier (type, stream, 0, 1);
 725       fprintf_filtered (stream, "union ");
 726
 727     struct_union:
 728
 729       /* Print the tag if it exists.
 730        * The HP aCC compiler emits
 731        * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
 732        * tag  for unnamed struct/union/enum's, which we don't
 733        * want to print.
 734        */
 735       if (TYPE_TAG_NAME (type) != NULL &&
 736           strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
 737         {
 738           fputs_filtered (TYPE_TAG_NAME (type), stream);
 739           if (show > 0)
 740             fputs_filtered (" ", stream);
 741         }
 742       wrap_here ("    ");
 743       if (show < 0)
 744         {
 745           /* If we just printed a tag name, no need to print anything else.  */
 746           if (TYPE_TAG_NAME (type) == NULL)
 747             fprintf_filtered (stream, "{...}");
 748         }
 749       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
 750         {
 751           cp_type_print_derivation_info (stream, type);
 752
 753           fprintf_filtered (stream, "{\n");
 754           if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
 755             {
 756               if (TYPE_STUB (type))
 757                 fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
 758               else
 759                 fprintfi_filtered (level + 4, stream, "<no data fields>\n");
 760             }
 761
 762           /* Start off with no specific section type, so we can print
 763              one for the first field we find, and use that section type
 764              thereafter until we find another type. */
 765
 766           section_type = s_none;
 767
 768           /* For a class, if all members are private, there's no need
 769              for a "private:" label; similarly, for a struct or union
 770              masquerading as a class, if all members are public, there's
 771              no need for a "public:" label. */
 772
 773           if ((TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_CLASS) ||
 774               (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_TEMPLATE))
 775             {
 776               QUIT;
 777               len = TYPE_NFIELDS (type);
 778               for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 779                 if (!TYPE_FIELD_PRIVATE (type, i))
 780                   {
 781                     need_access_label = 1;
 782                     break;
 783                   }
 784               QUIT;
 785               if (!need_access_label)
 786                 {
 787                   len2 = TYPE_NFN_FIELDS (type);
 788                   for (j = 0; j < len2; j++)
 789                     {
 790                       len = TYPE_FN_FIELDLIST_LENGTH (type, j);
 791                       for (i = 0; i < len; i++)
 792                         if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i))
 793                           {
 794                             need_access_label = 1;
 795                             break;
 796                           }
 797                       if (need_access_label)
 798                         break;
 799                     }
 800                 }
 801             }
 802           else if ((TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_STRUCT) ||
 803                    (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_UNION))
 804             {
 805               QUIT;
 806               len = TYPE_NFIELDS (type);
 807               for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 808                 if (TYPE_FIELD_PRIVATE (type, i) || TYPE_FIELD_PROTECTED (type, i))
 809                   {
 810                     need_access_label = 1;
 811                     break;
 812                   }
 813               QUIT;
 814               if (!need_access_label)
 815                 {
 816                   len2 = TYPE_NFN_FIELDS (type);
 817                   for (j = 0; j < len2; j++)
 818                     {
 819                       QUIT;
 820                       len = TYPE_FN_FIELDLIST_LENGTH (type, j);
 821                       for (i = 0; i < len; i++)
 822                         if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i) ||
 823                             TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type, j), i))
 824                           {
 825                             need_access_label = 1;
 826                             break;
 827                           }
 828                       if (need_access_label)
 829                         break;
 830                     }
 831                 }
 832             }
 833
 834           /* If there is a base class for this type,
 835              do not print the field that it occupies.  */
 836
 837           len = TYPE_NFIELDS (type);
 838           for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 839             {
 840               QUIT;
 841               /* Don't print out virtual function table.  */
 842               /* HP ANSI C++ case */
 843               if (TYPE_HAS_VTABLE (type) && (STREQN (TYPE_FIELD_NAME (type, i), "__vfp", 5)))
 844                 continue;
 845               /* Other compilers */
 846               if (STREQN (TYPE_FIELD_NAME (type, i), "_vptr", 5)
 847                   && is_cplus_marker ((TYPE_FIELD_NAME (type, i))[5]))
 848                 continue;
 849
 850               /* If this is a C++ class we can print the various C++ section
 851                  labels. */
 852
 853               if (HAVE_CPLUS_STRUCT (type) && need_access_label)
 854                 {
 855                   if (TYPE_FIELD_PROTECTED (type, i))
 856                     {
 857                       if (section_type != s_protected)
 858                         {
 859                           section_type = s_protected;
 860                           fprintfi_filtered (level + 2, stream,
 861                                              "protected:\n");
 862                         }
 863                     }
 864                   else if (TYPE_FIELD_PRIVATE (type, i))
 865                     {
 866                       if (section_type != s_private)
 867                         {
 868                           section_type = s_private;
 869                           fprintfi_filtered (level + 2, stream, "private:\n");
 870                         }
 871                     }
 872                   else
 873                     {
 874                       if (section_type != s_public)
 875                         {
 876                           section_type = s_public;
 877                           fprintfi_filtered (level + 2, stream, "public:\n");
 878                         }
 879                     }
 880                 }
 881
 882               print_spaces_filtered (level + 4, stream);
 883               if (TYPE_FIELD_STATIC (type, i))
 884                 {
 885                   fprintf_filtered (stream, "static ");
 886                 }
 887               c_print_type (TYPE_FIELD_TYPE (type, i),
 888                             TYPE_FIELD_NAME (type, i),
 889                             stream, show - 1, level + 4);
 890               if (!TYPE_FIELD_STATIC (type, i)
 891                   && TYPE_FIELD_PACKED (type, i))
 892                 {
 893                   /* It is a bitfield.  This code does not attempt
 894                      to look at the bitpos and reconstruct filler,
 895                      unnamed fields.  This would lead to misleading
 896                      results if the compiler does not put out fields
 897                      for such things (I don't know what it does).  */
 898                   fprintf_filtered (stream, " : %d",
 899                                     TYPE_FIELD_BITSIZE (type, i));
 900                 }
 901               fprintf_filtered (stream, ";\n");
 902             }
 903
 904           /* If there are both fields and methods, put a blank line
 905               between them.  Make sure to count only method that we will
 906               display; artificial methods will be hidden.  */
 907           len = TYPE_NFN_FIELDS (type);
 908           real_len = 0;
 909           for (i = 0; i < len; i++)
 910             {
 911               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 912               int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 913               int j;
 914               for (j = 0; j < len2; j++)
 915                 if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
 916                   real_len++;
 917             }
 918           if (real_len > 0 && section_type != s_none)
 919             fprintf_filtered (stream, "\n");
 920
 921           /* C++: print out the methods */
 922           for (i = 0; i < len; i++)
 923             {
 924               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 925               int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 926               char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
 927               char *name = type_name_no_tag (type);
 928               int is_constructor = name && STREQ (method_name, name);
 929               for (j = 0; j < len2; j++)
 930                 {
 931                   char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
 932                   int is_full_physname_constructor =
 933                    is_constructor_name (physname)
 934                    || is_destructor_name (physname)
 935                    || method_name[0] == '~';
 936
 937                   /* Do not print out artificial methods.  */
 938                   if (TYPE_FN_FIELD_ARTIFICIAL (f, j))
 939                     continue;
 940
 941                   QUIT;
 942                   if (TYPE_FN_FIELD_PROTECTED (f, j))
 943                     {
 944                       if (section_type != s_protected)
 945                         {
 946                           section_type = s_protected;
 947                           fprintfi_filtered (level + 2, stream,
 948                                              "protected:\n");
 949                         }
 950                     }
 951                   else if (TYPE_FN_FIELD_PRIVATE (f, j))
 952                     {
 953                       if (section_type != s_private)
 954                         {
 955                           section_type = s_private;
 956                           fprintfi_filtered (level + 2, stream, "private:\n");
 957                         }
 958                     }
 959                   else
 960                     {
 961                       if (section_type != s_public)
 962                         {
 963                           section_type = s_public;
 964                           fprintfi_filtered (level + 2, stream, "public:\n");
 965                         }
 966                     }
 967
 968                   print_spaces_filtered (level + 4, stream);
 969                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
 970                     fprintf_filtered (stream, "virtual ");
 971                   else if (TYPE_FN_FIELD_STATIC_P (f, j))
 972                     fprintf_filtered (stream, "static ");
 973                   if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
 974                     {
 975                       /* Keep GDB from crashing here.  */
 976                       fprintf_filtered (stream, "<undefined type> %s;\n",
 977                                         TYPE_FN_FIELD_PHYSNAME (f, j));
 978                       break;
 979                     }
 980                   else if (!is_constructor &&   /* constructors don't have declared types */
 981                            !is_full_physname_constructor &&     /*    " "  */
 982                            !is_type_conversion_operator (type, i, j))
 983                     {
 984                       type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
 985                                   "", stream, -1);
 986                       fputs_filtered (" ", stream);
 987                     }
 988                   if (TYPE_FN_FIELD_STUB (f, j))
 989                     /* Build something we can demangle.  */
 990                     mangled_name = gdb_mangle_name (type, i, j);
 991                   else
 992                     mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
 993
 994                   demangled_name =
 995                     cplus_demangle (mangled_name,
 996                                     DMGL_ANSI | DMGL_PARAMS);
 997                   if (demangled_name == NULL)
 998                     {
 999                       /* in some cases (for instance with the HP demangling),
1000                          if a function has more than 10 arguments,
1001                          the demangling will fail.
1002                          Let's try to reconstruct the function signature from
1003                          the symbol information */
1004                       if (!TYPE_FN_FIELD_STUB (f, j))
1005                         {
1006                           int staticp = TYPE_FN_FIELD_STATIC_P (f, j);
1007                           struct type *mtype = TYPE_FN_FIELD_TYPE (f, j);
1008                           cp_type_print_method_args (mtype,
1009                                                      "",
1010                                                      method_name,
1011                                                      staticp,
1012                                                      stream);
1013                         }
1014                       else
1015                         fprintf_filtered (stream, "<badly mangled name '%s'>",
1016                                           mangled_name);
1017                     }
1018                   else
1019                     {
1020                       char *p;
1021                       char *demangled_no_class
1022                         = remove_qualifiers (demangled_name);
1023
1024                       /* get rid of the `static' appended by the demangler */
1025                       p = strstr (demangled_no_class, " static");
1026                       if (p != NULL)
1027                         {
1028                           int length = p - demangled_no_class;
1029                           demangled_no_static = (char *) xmalloc (length + 1);
1030                           strncpy (demangled_no_static, demangled_no_class, length);
1031                           *(demangled_no_static + length) = '\0';
1032                           fputs_filtered (demangled_no_static, stream);
1033                           xfree (demangled_no_static);
1034                         }
1035                       else
1036                         fputs_filtered (demangled_no_class, stream);
1037                       xfree (demangled_name);
1038                     }
1039
1040                   if (TYPE_FN_FIELD_STUB (f, j))
1041                     xfree (mangled_name);
1042
1043                   fprintf_filtered (stream, ";\n");
1044                 }
1045             }
1046
1047           fprintfi_filtered (level, stream, "}");
1048
1049           if (TYPE_LOCALTYPE_PTR (type) && show >= 0)
1050             fprintfi_filtered (level, stream, " (Local at %s:%d)\n",
1051                                TYPE_LOCALTYPE_FILE (type),
1052                                TYPE_LOCALTYPE_LINE (type));
1053         }
1054       if (TYPE_CODE (type) == TYPE_CODE_TEMPLATE)
1055         goto go_back;
1056       break;
1057
1058     case TYPE_CODE_ENUM:
1059       c_type_print_modifier (type, stream, 0, 1);
1060       /* HP C supports sized enums */
1061       if (hp_som_som_object_present)
1062         switch (TYPE_LENGTH (type))
1063           {
1064           case 1:
1065             fputs_filtered ("char ", stream);
1066             break;
1067           case 2:
1068             fputs_filtered ("short ", stream);
1069             break;
1070           default:
1071             break;
1072           }
1073       fprintf_filtered (stream, "enum ");
1074       /* Print the tag name if it exists.
1075          The aCC compiler emits a spurious
1076          "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1077          tag for unnamed struct/union/enum's, which we don't
1078          want to print. */
1079       if (TYPE_TAG_NAME (type) != NULL &&
1080           strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
1081         {
1082           fputs_filtered (TYPE_TAG_NAME (type), stream);
1083           if (show > 0)
1084             fputs_filtered (" ", stream);
1085         }
1086
1087       wrap_here ("    ");
1088       if (show < 0)
1089         {
1090           /* If we just printed a tag name, no need to print anything else.  */
1091           if (TYPE_TAG_NAME (type) == NULL)
1092             fprintf_filtered (stream, "{...}");
1093         }
1094       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1095         {
1096           fprintf_filtered (stream, "{");
1097           len = TYPE_NFIELDS (type);
1098           lastval = 0;
1099           for (i = 0; i < len; i++)
1100             {
1101               QUIT;
1102               if (i)
1103                 fprintf_filtered (stream, ", ");
1104               wrap_here ("    ");
1105               fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1106               if (lastval != TYPE_FIELD_BITPOS (type, i))
1107                 {
1108                   fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
1109                   lastval = TYPE_FIELD_BITPOS (type, i);
1110                 }
1111               lastval++;
1112             }
1113           fprintf_filtered (stream, "}");
1114         }
1115       break;
1116
1117     case TYPE_CODE_VOID:
1118       fprintf_filtered (stream, "void");
1119       break;
1120
1121     case TYPE_CODE_UNDEF:
1122       fprintf_filtered (stream, "struct <unknown>");
1123       break;
1124
1125     case TYPE_CODE_ERROR:
1126       fprintf_filtered (stream, "<unknown type>");
1127       break;
1128
1129     case TYPE_CODE_RANGE:
1130       /* This should not occur */
1131       fprintf_filtered (stream, "<range type>");
1132       break;
1133
1134     case TYPE_CODE_TEMPLATE:
1135       /* Called on "ptype t" where "t" is a template.
1136          Prints the template header (with args), e.g.:
1137          template <class T1, class T2> class "
1138          and then merges with the struct/union/class code to
1139          print the rest of the definition. */
1140       c_type_print_modifier (type, stream, 0, 1);
1141       fprintf_filtered (stream, "template <");
1142       for (i = 0; i < TYPE_NTEMPLATE_ARGS (type); i++)
1143         {
1144           struct template_arg templ_arg;
1145           templ_arg = TYPE_TEMPLATE_ARG (type, i);
1146           fprintf_filtered (stream, "class %s", templ_arg.name);
1147           if (i < TYPE_NTEMPLATE_ARGS (type) - 1)
1148             fprintf_filtered (stream, ", ");
1149         }
1150       fprintf_filtered (stream, "> class ");
1151       /* Yuck, factor this out to a subroutine so we can call
1152          it and return to the point marked with the "goback:" label... - RT */
1153       goto struct_union;
1154     go_back:
1155       if (TYPE_NINSTANTIATIONS (type) > 0)
1156         {
1157           fprintf_filtered (stream, "\ntemplate instantiations:\n");
1158           for (i = 0; i < TYPE_NINSTANTIATIONS (type); i++)
1159             {
1160               fprintf_filtered (stream, "  ");
1161               c_type_print_base (TYPE_INSTANTIATION (type, i), stream, 0, level);
1162               if (i < TYPE_NINSTANTIATIONS (type) - 1)
1163                 fprintf_filtered (stream, "\n");
1164             }
1165         }
1166       break;
1167
1168     default:
1169       /* Handle types not explicitly handled by the other cases,
1170          such as fundamental types.  For these, just print whatever
1171          the type name is, as recorded in the type itself.  If there
1172          is no type name, then complain. */
1173       if (TYPE_NAME (type) != NULL)
1174         {
1175           c_type_print_modifier (type, stream, 0, 1);
1176           fputs_filtered (TYPE_NAME (type), stream);
1177         }
1178       else
1179         {
1180           /* At least for dump_symtab, it is important that this not be
1181              an error ().  */
1182           fprintf_filtered (stream, "<invalid type code %d>",
1183                             TYPE_CODE (type));
1184         }
1185       break;
1186     }
1187 }