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