gdb/c-typeprint.c

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