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 #include "gdb_string.h"
  37 #include <errno.h>
  38
  39 static void c_type_print_varspec_prefix (struct type *, struct ui_file *, int,
  40                                          int, int);
  41
  42 /* Print "const", "volatile", or address space modifiers. */
  43 static void c_type_print_modifier (struct type *, struct ui_file *,
  44                                    int, int);
  45 \f
  46 /* LEVEL is the depth to indent lines by.  */
  47
  48 void
  49 c_print_type (struct type *type, const char *varstring, struct ui_file *stream,
  50               int show, int level)
  51 {
  52   enum type_code code;
  53   int demangled_args;
  54   int need_post_space;
  55
  56   if (show > 0)
  57     CHECK_TYPEDEF (type);
  58
  59   c_type_print_base (type, stream, show, level);
  60   code = TYPE_CODE (type);
  61   if ((varstring != NULL && *varstring != '\0')
  62   /* Need a space if going to print stars or brackets;
  63      but not if we will print just a type name.  */
  64       || ((show > 0 || TYPE_NAME (type) == 0)
  65           && (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
  66               || code == TYPE_CODE_METHOD
  67               || code == TYPE_CODE_ARRAY
  68               || code == TYPE_CODE_MEMBERPTR
  69               || code == TYPE_CODE_METHODPTR
  70               || code == TYPE_CODE_REF)))
  71     fputs_filtered (" ", stream);
  72   need_post_space = (varstring != NULL && strcmp (varstring, "") != 0);
  73   c_type_print_varspec_prefix (type, stream, show, 0, need_post_space);
  74
  75   if (varstring != NULL)
  76     {
  77       fputs_filtered (varstring, stream);
  78
  79       /* For demangled function names, we have the arglist as part of the name,
  80          so don't print an additional pair of ()'s */
  81
  82       demangled_args = strchr (varstring, '(') != NULL;
  83       c_type_print_varspec_suffix (type, stream, show, 0, demangled_args);
  84     }
  85 }
  86
  87 /* Print a typedef using C syntax.  TYPE is the underlying type.
  88    NEW_SYMBOL is the symbol naming the type.  STREAM is the stream on
  89    which to print.  */
  90
  91 void
  92 c_print_typedef (struct type *type, struct symbol *new_symbol,
  93                  struct ui_file *stream)
  94 {
  95   CHECK_TYPEDEF (type);
  96   fprintf_filtered (stream, "typedef ");
  97   type_print (type, "", stream, 0);
  98   if (TYPE_NAME ((SYMBOL_TYPE (new_symbol))) == 0
  99       || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol))),
 100                  SYMBOL_LINKAGE_NAME (new_symbol)) != 0
 101       || TYPE_CODE (SYMBOL_TYPE (new_symbol)) == TYPE_CODE_TYPEDEF)
 102     fprintf_filtered (stream, " %s", SYMBOL_PRINT_NAME (new_symbol));
 103   fprintf_filtered (stream, ";\n");
 104 }
 105
 106 /* If TYPE is a derived type, then print out derivation information.
 107    Print only the actual base classes of this type, not the base classes
 108    of the base classes.  I.E.  for the derivation hierarchy:
 109
 110    class A { int a; };
 111    class B : public A {int b; };
 112    class C : public B {int c; };
 113
 114    Print the type of class C as:
 115
 116    class C : public B {
 117    int c;
 118    }
 119
 120    Not as the following (like gdb used to), which is not legal C++ syntax for
 121    derived types and may be confused with the multiple inheritance form:
 122
 123    class C : public B : public A {
 124    int c;
 125    }
 126
 127    In general, gdb should try to print the types as closely as possible to
 128    the form that they appear in the source code.
 129    Note that in case of protected derivation gcc will not say 'protected'
 130    but 'private'. The HP's aCC compiler emits specific information for
 131    derivation via protected inheritance, so gdb can print it out */
 132
 133 static void
 134 cp_type_print_derivation_info (struct ui_file *stream, struct type *type)
 135 {
 136   char *name;
 137   int i;
 138
 139   for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
 140     {
 141       fputs_filtered (i == 0 ? ": " : ", ", stream);
 142       fprintf_filtered (stream, "%s%s ",
 143                         BASETYPE_VIA_PUBLIC (type, i) ? "public"
 144                : (TYPE_FIELD_PROTECTED (type, i) ? "protected" : "private"),
 145                         BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : "");
 146       name = type_name_no_tag (TYPE_BASECLASS (type, i));
 147       fprintf_filtered (stream, "%s", name ? name : "(null)");
 148     }
 149   if (i > 0)
 150     {
 151       fputs_filtered (" ", stream);
 152     }
 153 }
 154
 155 /* Print the C++ method arguments ARGS to the file STREAM.  */
 156
 157 static void
 158 cp_type_print_method_args (struct type *mtype, char *prefix, char *varstring,
 159                            int staticp, struct ui_file *stream)
 160 {
 161   struct field *args = TYPE_FIELDS (mtype);
 162   int nargs = TYPE_NFIELDS (mtype);
 163   int varargs = TYPE_VARARGS (mtype);
 164   int i;
 165
 166   fprintf_symbol_filtered (stream, prefix, language_cplus, DMGL_ANSI);
 167   fprintf_symbol_filtered (stream, varstring, language_cplus, DMGL_ANSI);
 168   fputs_filtered ("(", stream);
 169
 170   /* Skip the class variable.  */
 171   i = staticp ? 0 : 1;
 172   if (nargs > i)
 173     {
 174       while (i < nargs)
 175         {
 176           type_print (args[i++].type, "", stream, 0);
 177
 178           if (i == nargs && varargs)
 179             fprintf_filtered (stream, ", ...");
 180           else if (i < nargs)
 181             fprintf_filtered (stream, ", ");
 182         }
 183     }
 184   else if (varargs)
 185     fprintf_filtered (stream, "...");
 186   else if (current_language->la_language == language_cplus)
 187     fprintf_filtered (stream, "void");
 188
 189   fprintf_filtered (stream, ")");
 190
 191   /* For non-static methods, read qualifiers from the type of
 192      THIS.  */
 193   if (!staticp)
 194     {
 195       struct type *domain;
 196
 197       gdb_assert (nargs > 0);
 198       gdb_assert (TYPE_CODE (args[0].type) == TYPE_CODE_PTR);
 199       domain = TYPE_TARGET_TYPE (args[0].type);
 200
 201       if (TYPE_CONST (domain))
 202         fprintf_filtered (stream, " const");
 203
 204       if (TYPE_VOLATILE (domain))
 205         fprintf_filtered (stream, " volatile");
 206     }
 207 }
 208
 209
 210 /* Print any asterisks or open-parentheses needed before the
 211    variable name (to describe its type).
 212
 213    On outermost call, pass 0 for PASSED_A_PTR.
 214    On outermost call, SHOW > 0 means should ignore
 215    any typename for TYPE and show its details.
 216    SHOW is always zero on recursive calls.
 217
 218    NEED_POST_SPACE is non-zero when a space will be be needed
 219    between a trailing qualifier and a field, variable, or function
 220    name.  */
 221
 222 static void
 223 c_type_print_varspec_prefix (struct type *type, struct ui_file *stream,
 224                              int show, int passed_a_ptr, int need_post_space)
 225 {
 226   char *name;
 227
 228   if (type == 0)
 229     return;
 230
 231   if (TYPE_NAME (type) && show <= 0)
 232     return;
 233
 234   QUIT;
 235
 236   switch (TYPE_CODE (type))
 237     {
 238     case TYPE_CODE_PTR:
 239       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 1, 1);
 240       fprintf_filtered (stream, "*");
 241       c_type_print_modifier (type, stream, 1, need_post_space);
 242       break;
 243
 244     case TYPE_CODE_MEMBERPTR:
 245       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
 246       name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
 247       if (name)
 248         fputs_filtered (name, stream);
 249       else
 250         c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
 251       fprintf_filtered (stream, "::*");
 252       break;
 253
 254     case TYPE_CODE_METHODPTR:
 255       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
 256       fprintf_filtered (stream, "(");
 257       name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
 258       if (name)
 259         fputs_filtered (name, stream);
 260       else
 261         c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
 262       fprintf_filtered (stream, "::*");
 263       break;
 264
 265     case TYPE_CODE_REF:
 266       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 1, 0);
 267       fprintf_filtered (stream, "&");
 268       c_type_print_modifier (type, stream, 1, need_post_space);
 269       break;
 270
 271     case TYPE_CODE_METHOD:
 272     case TYPE_CODE_FUNC:
 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_ARRAY:
 279       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
 280       if (passed_a_ptr)
 281         fprintf_filtered (stream, "(");
 282       break;
 283
 284     case TYPE_CODE_TYPEDEF:
 285       c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
 286       break;
 287
 288     case TYPE_CODE_UNDEF:
 289     case TYPE_CODE_STRUCT:
 290     case TYPE_CODE_UNION:
 291     case TYPE_CODE_ENUM:
 292     case TYPE_CODE_INT:
 293     case TYPE_CODE_FLT:
 294     case TYPE_CODE_VOID:
 295     case TYPE_CODE_ERROR:
 296     case TYPE_CODE_CHAR:
 297     case TYPE_CODE_BOOL:
 298     case TYPE_CODE_SET:
 299     case TYPE_CODE_RANGE:
 300     case TYPE_CODE_STRING:
 301     case TYPE_CODE_BITSTRING:
 302     case TYPE_CODE_COMPLEX:
 303     case TYPE_CODE_NAMESPACE:
 304     case TYPE_CODE_DECFLOAT:
 305       /* These types need no prefix.  They are listed here so that
 306          gcc -Wall will reveal any types that haven't been handled.  */
 307       break;
 308     default:
 309       error (_("type not handled in c_type_print_varspec_prefix()"));
 310       break;
 311     }
 312 }
 313
 314 /* Print out "const" and "volatile" attributes,
 315    and address space id if present.
 316    TYPE is a pointer to the type being printed out.
 317    STREAM is the output destination.
 318    NEED_PRE_SPACE = 1 indicates an initial white space is needed.
 319    NEED_POST_SPACE = 1 indicates a final white space is needed.  */
 320
 321 static void
 322 c_type_print_modifier (struct type *type, struct ui_file *stream,
 323                        int need_pre_space, int need_post_space)
 324 {
 325   int did_print_modifier = 0;
 326   const char *address_space_id;
 327
 328   /* We don't print `const' qualifiers for references --- since all
 329      operators affect the thing referenced, not the reference itself,
 330      every reference is `const'.  */
 331   if (TYPE_CONST (type)
 332       && TYPE_CODE (type) != TYPE_CODE_REF)
 333     {
 334       if (need_pre_space)
 335         fprintf_filtered (stream, " ");
 336       fprintf_filtered (stream, "const");
 337       did_print_modifier = 1;
 338     }
 339
 340   if (TYPE_VOLATILE (type))
 341     {
 342       if (did_print_modifier || need_pre_space)
 343         fprintf_filtered (stream, " ");
 344       fprintf_filtered (stream, "volatile");
 345       did_print_modifier = 1;
 346     }
 347
 348   address_space_id = address_space_int_to_name (get_type_arch (type),
 349                                                 TYPE_INSTANCE_FLAGS (type));
 350   if (address_space_id)
 351     {
 352       if (did_print_modifier || need_pre_space)
 353         fprintf_filtered (stream, " ");
 354       fprintf_filtered (stream, "@%s", address_space_id);
 355       did_print_modifier = 1;
 356     }
 357
 358   if (did_print_modifier && need_post_space)
 359     fprintf_filtered (stream, " ");
 360 }
 361
 362
 363 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
 364    or TYPE_CODE_FUNC, to STREAM.  Artificial arguments, such as "this"
 365    in non-static methods, are displayed if SHOW_ARTIFICIAL is
 366    non-zero. LANGUAGE is the language in which TYPE was defined.  This is
 367    a necessary evil since this code is used by the C, C++, and Java
 368    backends. */
 369
 370 void
 371 c_type_print_args (struct type *type, struct ui_file *stream,
 372                    int show_artificial, enum language language)
 373 {
 374   int i, len;
 375   struct field *args;
 376   int printed_any = 0;
 377
 378   fprintf_filtered (stream, "(");
 379   args = TYPE_FIELDS (type);
 380   len = TYPE_NFIELDS (type);
 381
 382   for (i = 0; i < TYPE_NFIELDS (type); i++)
 383     {
 384       if (TYPE_FIELD_ARTIFICIAL (type, i) && !show_artificial)
 385         continue;
 386
 387       if (printed_any)
 388         {
 389           fprintf_filtered (stream, ", ");
 390           wrap_here ("    ");
 391         }
 392
 393       if (language == language_java)
 394         java_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
 395       else
 396         c_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
 397       printed_any = 1;
 398     }
 399
 400   if (printed_any && TYPE_VARARGS (type))
 401     {
 402       /* Print out a trailing ellipsis for varargs functions.  Ignore
 403          TYPE_VARARGS if the function has no named arguments; that
 404          represents unprototyped (K&R style) C functions.  */
 405       if (printed_any && TYPE_VARARGS (type))
 406         {
 407           fprintf_filtered (stream, ", ");
 408           wrap_here ("    ");
 409           fprintf_filtered (stream, "...");
 410         }
 411     }
 412   else if (!printed_any
 413            && ((TYPE_PROTOTYPED (type) && language != language_java)
 414                || language == language_cplus))
 415     fprintf_filtered (stream, "void");
 416
 417   fprintf_filtered (stream, ")");
 418 }
 419
 420 /* Return true iff the j'th overloading of the i'th method of TYPE
 421    is a type conversion operator, like `operator int () { ... }'.
 422    When listing a class's methods, we don't print the return type of
 423    such operators.  */
 424
 425 static int
 426 is_type_conversion_operator (struct type *type, int i, int j)
 427 {
 428   /* I think the whole idea of recognizing type conversion operators
 429      by their name is pretty terrible.  But I don't think our present
 430      data structure gives us any other way to tell.  If you know of
 431      some other way, feel free to rewrite this function.  */
 432   char *name = TYPE_FN_FIELDLIST_NAME (type, i);
 433
 434   if (strncmp (name, "operator", 8) != 0)
 435     return 0;
 436
 437   name += 8;
 438   if (! strchr (" \t\f\n\r", *name))
 439     return 0;
 440
 441   while (strchr (" \t\f\n\r", *name))
 442     name++;
 443
 444   if (!('a' <= *name && *name <= 'z')
 445       && !('A' <= *name && *name <= 'Z')
 446       && *name != '_')
 447     /* If this doesn't look like the start of an identifier, then it
 448        isn't a type conversion operator.  */
 449     return 0;
 450   else if (strncmp (name, "new", 3) == 0)
 451     name += 3;
 452   else if (strncmp (name, "delete", 6) == 0)
 453     name += 6;
 454   else
 455     /* If it doesn't look like new or delete, it's a type conversion
 456        operator.  */
 457     return 1;
 458
 459   /* Is that really the end of the name?  */
 460   if (('a' <= *name && *name <= 'z')
 461       || ('A' <= *name && *name <= 'Z')
 462       || ('0' <= *name && *name <= '9')
 463       || *name == '_')
 464     /* No, so the identifier following "operator" must be a type name,
 465        and this is a type conversion operator.  */
 466     return 1;
 467
 468   /* That was indeed the end of the name, so it was `operator new' or
 469      `operator delete', neither of which are type conversion operators.  */
 470   return 0;
 471 }
 472
 473 /* Given a C++ qualified identifier QID, strip off the qualifiers,
 474    yielding the unqualified name.  The return value is a pointer into
 475    the original string.
 476
 477    It's a pity we don't have this information in some more structured
 478    form.  Even the author of this function feels that writing little
 479    parsers like this everywhere is stupid.  */
 480
 481 static char *
 482 remove_qualifiers (char *qid)
 483 {
 484   int quoted = 0;               /* zero if we're not in quotes;
 485                                    '"' if we're in a double-quoted string;
 486                                    '\'' if we're in a single-quoted string.  */
 487   int depth = 0;                /* number of unclosed parens we've seen */
 488   char *parenstack = (char *) alloca (strlen (qid));
 489   char *scan;
 490   char *last = 0;               /* The character after the rightmost
 491                                    `::' token we've seen so far.  */
 492
 493   for (scan = qid; *scan; scan++)
 494     {
 495       if (quoted)
 496         {
 497           if (*scan == quoted)
 498             quoted = 0;
 499           else if (*scan == '\\' && *(scan + 1))
 500             scan++;
 501         }
 502       else if (scan[0] == ':' && scan[1] == ':')
 503         {
 504           /* If we're inside parenthesis (i.e., an argument list) or
 505              angle brackets (i.e., a list of template arguments), then
 506              we don't record the position of this :: token, since it's
 507              not relevant to the top-level structure we're trying
 508              to operate on.  */
 509           if (depth == 0)
 510             {
 511               last = scan + 2;
 512               scan++;
 513             }
 514         }
 515       else if (*scan == '"' || *scan == '\'')
 516         quoted = *scan;
 517       else if (*scan == '(')
 518         parenstack[depth++] = ')';
 519       else if (*scan == '[')
 520         parenstack[depth++] = ']';
 521       /* We're going to treat <> as a pair of matching characters,
 522          since we're more likely to see those in template id's than
 523          real less-than characters.  What a crock.  */
 524       else if (*scan == '<')
 525         parenstack[depth++] = '>';
 526       else if (*scan == ')' || *scan == ']' || *scan == '>')
 527         {
 528           if (depth > 0 && parenstack[depth - 1] == *scan)
 529             depth--;
 530           else
 531             {
 532               /* We're going to do a little error recovery here.  If we
 533                  don't find a match for *scan on the paren stack, but
 534                  there is something lower on the stack that does match, we
 535                  pop the stack to that point.  */
 536               int i;
 537
 538               for (i = depth - 1; i >= 0; i--)
 539                 if (parenstack[i] == *scan)
 540                   {
 541                     depth = i;
 542                     break;
 543                   }
 544             }
 545         }
 546     }
 547
 548   if (last)
 549     return last;
 550   else
 551     /* We didn't find any :: tokens at the top level, so declare the
 552        whole thing an unqualified identifier.  */
 553     return qid;
 554 }
 555
 556 /* Print any array sizes, function arguments or close parentheses
 557    needed after the variable name (to describe its type).
 558    Args work like c_type_print_varspec_prefix.  */
 559
 560 void
 561 c_type_print_varspec_suffix (struct type *type, struct ui_file *stream,
 562                              int show, int passed_a_ptr, int demangled_args)
 563 {
 564   if (type == 0)
 565     return;
 566
 567   if (TYPE_NAME (type) && show <= 0)
 568     return;
 569
 570   QUIT;
 571
 572   switch (TYPE_CODE (type))
 573     {
 574     case TYPE_CODE_ARRAY:
 575       if (passed_a_ptr)
 576         fprintf_filtered (stream, ")");
 577
 578       fprintf_filtered (stream, "[");
 579       if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
 580         && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
 581         fprintf_filtered (stream, "%d",
 582                           (TYPE_LENGTH (type)
 583                            / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
 584       fprintf_filtered (stream, "]");
 585
 586       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 587                                    0, 0);
 588       break;
 589
 590     case TYPE_CODE_MEMBERPTR:
 591       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 592                                    0, 0);
 593       break;
 594
 595     case TYPE_CODE_METHODPTR:
 596       fprintf_filtered (stream, ")");
 597       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 598                                    0, 0);
 599       break;
 600
 601     case TYPE_CODE_PTR:
 602     case TYPE_CODE_REF:
 603       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 604                                    1, 0);
 605       break;
 606
 607     case TYPE_CODE_METHOD:
 608     case TYPE_CODE_FUNC:
 609       if (passed_a_ptr)
 610         fprintf_filtered (stream, ")");
 611       if (!demangled_args)
 612         c_type_print_args (type, stream, 1, current_language->la_language);
 613       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 614                                    passed_a_ptr, 0);
 615       break;
 616
 617     case TYPE_CODE_TYPEDEF:
 618       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
 619                                    passed_a_ptr, 0);
 620       break;
 621
 622     case TYPE_CODE_UNDEF:
 623     case TYPE_CODE_STRUCT:
 624     case TYPE_CODE_UNION:
 625     case TYPE_CODE_ENUM:
 626     case TYPE_CODE_INT:
 627     case TYPE_CODE_FLT:
 628     case TYPE_CODE_VOID:
 629     case TYPE_CODE_ERROR:
 630     case TYPE_CODE_CHAR:
 631     case TYPE_CODE_BOOL:
 632     case TYPE_CODE_SET:
 633     case TYPE_CODE_RANGE:
 634     case TYPE_CODE_STRING:
 635     case TYPE_CODE_BITSTRING:
 636     case TYPE_CODE_COMPLEX:
 637     case TYPE_CODE_NAMESPACE:
 638     case TYPE_CODE_DECFLOAT:
 639       /* These types do not need a suffix.  They are listed so that
 640          gcc -Wall will report types that may not have been considered.  */
 641       break;
 642     default:
 643       error (_("type not handled in c_type_print_varspec_suffix()"));
 644       break;
 645     }
 646 }
 647
 648 /* Print the name of the type (or the ultimate pointer target,
 649    function value or array element), or the description of a
 650    structure or union.
 651
 652    SHOW positive means print details about the type (e.g. enum values),
 653    and print structure elements passing SHOW - 1 for show.
 654    SHOW negative means just print the type name or struct tag if there is one.
 655    If there is no name, print something sensible but concise like
 656    "struct {...}".
 657    SHOW zero means just print the type name or struct tag if there is one.
 658    If there is no name, print something sensible but not as concise like
 659    "struct {int x; int y;}".
 660
 661    LEVEL is the number of spaces to indent by.
 662    We increase it for some recursive calls.  */
 663
 664 void
 665 c_type_print_base (struct type *type, struct ui_file *stream, int show,
 666                    int level)
 667 {
 668   int i;
 669   int len, real_len;
 670   int lastval;
 671   char *mangled_name;
 672   char *demangled_name;
 673   char *demangled_no_static;
 674   enum
 675     {
 676       s_none, s_public, s_private, s_protected
 677     }
 678   section_type;
 679   int need_access_label = 0;
 680   int j, len2;
 681
 682   QUIT;
 683
 684   wrap_here ("    ");
 685   if (type == NULL)
 686     {
 687       fputs_filtered (_("<type unknown>"), stream);
 688       return;
 689     }
 690
 691   /* When SHOW is zero or less, and there is a valid type name, then always
 692      just print the type name directly from the type.  */
 693   /* If we have "typedef struct foo {. . .} bar;" do we want to print it
 694      as "struct foo" or as "bar"?  Pick the latter, because C++ folk tend
 695      to expect things like "class5 *foo" rather than "struct class5 *foo".  */
 696
 697   if (show <= 0
 698       && TYPE_NAME (type) != NULL)
 699     {
 700       c_type_print_modifier (type, stream, 0, 1);
 701       fputs_filtered (TYPE_NAME (type), stream);
 702       return;
 703     }
 704
 705   CHECK_TYPEDEF (type);
 706
 707   switch (TYPE_CODE (type))
 708     {
 709     case TYPE_CODE_TYPEDEF:
 710       /* If we get here, the typedef doesn't have a name, and we couldn't
 711          resolve TYPE_TARGET_TYPE.  Not much we can do.  */
 712       gdb_assert (TYPE_NAME (type) == NULL);
 713       gdb_assert (TYPE_TARGET_TYPE (type) == NULL);
 714       fprintf_filtered (stream, _("<unnamed typedef>"));
 715       break;
 716
 717     case TYPE_CODE_ARRAY:
 718     case TYPE_CODE_PTR:
 719     case TYPE_CODE_MEMBERPTR:
 720     case TYPE_CODE_REF:
 721     case TYPE_CODE_FUNC:
 722     case TYPE_CODE_METHOD:
 723     case TYPE_CODE_METHODPTR:
 724       c_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
 725       break;
 726
 727     case TYPE_CODE_STRUCT:
 728       c_type_print_modifier (type, stream, 0, 1);
 729       if (TYPE_DECLARED_CLASS (type))
 730         fprintf_filtered (stream, "class ");
 731       else
 732         fprintf_filtered (stream, "struct ");
 733       goto struct_union;
 734
 735     case TYPE_CODE_UNION:
 736       c_type_print_modifier (type, stream, 0, 1);
 737       fprintf_filtered (stream, "union ");
 738
 739     struct_union:
 740
 741       /* Print the tag if it exists.
 742        * The HP aCC compiler emits
 743        * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
 744        * tag  for unnamed struct/union/enum's, which we don't
 745        * want to print.
 746        */
 747       if (TYPE_TAG_NAME (type) != NULL
 748           && strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
 749         {
 750           fputs_filtered (TYPE_TAG_NAME (type), stream);
 751           if (show > 0)
 752             fputs_filtered (" ", stream);
 753         }
 754       wrap_here ("    ");
 755       if (show < 0)
 756         {
 757           /* If we just printed a tag name, no need to print anything else.  */
 758           if (TYPE_TAG_NAME (type) == NULL)
 759             fprintf_filtered (stream, "{...}");
 760         }
 761       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
 762         {
 763           struct type *basetype;
 764           int vptr_fieldno;
 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               && TYPE_TYPEDEF_FIELD_COUNT (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           /* Print typedefs defined in this class.  */
1061
1062           if (TYPE_TYPEDEF_FIELD_COUNT (type) != 0)
1063             {
1064               if (TYPE_NFIELDS (type) != 0 || TYPE_NFN_FIELDS (type) != 0)
1065                 fprintf_filtered (stream, "\n");
1066
1067               for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (type); i++)
1068                 {
1069                   struct type *target = TYPE_TYPEDEF_FIELD_TYPE (type, i);
1070
1071                   /* Dereference the typedef declaration itself.  */
1072                   gdb_assert (TYPE_CODE (target) == TYPE_CODE_TYPEDEF);
1073                   target = TYPE_TARGET_TYPE (target);
1074
1075                   print_spaces_filtered (level + 4, stream);
1076                   fprintf_filtered (stream, "typedef ");
1077                   c_print_type (target, TYPE_TYPEDEF_FIELD_NAME (type, i),
1078                                 stream, show - 1, level + 4);
1079                   fprintf_filtered (stream, ";\n");
1080                 }
1081             }
1082
1083           fprintfi_filtered (level, stream, "}");
1084
1085           if (TYPE_LOCALTYPE_PTR (type) && show >= 0)
1086             fprintfi_filtered (level, stream, _(" (Local at %s:%d)\n"),
1087                                TYPE_LOCALTYPE_FILE (type),
1088                                TYPE_LOCALTYPE_LINE (type));
1089         }
1090       break;
1091
1092     case TYPE_CODE_ENUM:
1093       c_type_print_modifier (type, stream, 0, 1);
1094       fprintf_filtered (stream, "enum ");
1095       /* Print the tag name if it exists.
1096          The aCC compiler emits a spurious
1097          "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1098          tag for unnamed struct/union/enum's, which we don't
1099          want to print. */
1100       if (TYPE_TAG_NAME (type) != NULL
1101           && strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
1102         {
1103           fputs_filtered (TYPE_TAG_NAME (type), stream);
1104           if (show > 0)
1105             fputs_filtered (" ", stream);
1106         }
1107
1108       wrap_here ("    ");
1109       if (show < 0)
1110         {
1111           /* If we just printed a tag name, no need to print anything else.  */
1112           if (TYPE_TAG_NAME (type) == NULL)
1113             fprintf_filtered (stream, "{...}");
1114         }
1115       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1116         {
1117           fprintf_filtered (stream, "{");
1118           len = TYPE_NFIELDS (type);
1119           lastval = 0;
1120           for (i = 0; i < len; i++)
1121             {
1122               QUIT;
1123               if (i)
1124                 fprintf_filtered (stream, ", ");
1125               wrap_here ("    ");
1126               fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1127               if (lastval != TYPE_FIELD_BITPOS (type, i))
1128                 {
1129                   fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
1130                   lastval = TYPE_FIELD_BITPOS (type, i);
1131                 }
1132               lastval++;
1133             }
1134           fprintf_filtered (stream, "}");
1135         }
1136       break;
1137
1138     case TYPE_CODE_VOID:
1139       fprintf_filtered (stream, "void");
1140       break;
1141
1142     case TYPE_CODE_UNDEF:
1143       fprintf_filtered (stream, _("struct <unknown>"));
1144       break;
1145
1146     case TYPE_CODE_ERROR:
1147       fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
1148       break;
1149
1150     case TYPE_CODE_RANGE:
1151       /* This should not occur */
1152       fprintf_filtered (stream, _("<range type>"));
1153       break;
1154
1155     case TYPE_CODE_NAMESPACE:
1156       fputs_filtered ("namespace ", stream);
1157       fputs_filtered (TYPE_TAG_NAME (type), stream);
1158       break;
1159
1160     default:
1161       /* Handle types not explicitly handled by the other cases,
1162          such as fundamental types.  For these, just print whatever
1163          the type name is, as recorded in the type itself.  If there
1164          is no type name, then complain. */
1165       if (TYPE_NAME (type) != NULL)
1166         {
1167           c_type_print_modifier (type, stream, 0, 1);
1168           fputs_filtered (TYPE_NAME (type), stream);
1169         }
1170       else
1171         {
1172           /* At least for dump_symtab, it is important that this not be
1173              an error ().  */
1174           fprintf_filtered (stream, _("<invalid type code %d>"),
1175                             TYPE_CODE (type));
1176         }
1177       break;
1178     }
1179 }