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