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