contrib/gdb-7/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               && TYPE_TYPEDEF_FIELD_COUNT (type) == 0)
 773             {
 774               if (TYPE_STUB (type))
 775                 fprintfi_filtered (level + 4, stream, _("<incomplete type>\n"));
 776               else
 777                 fprintfi_filtered (level + 4, stream, _("<no data fields>\n"));
 778             }
 779
 780           /* Start off with no specific section type, so we can print
 781              one for the first field we find, and use that section type
 782              thereafter until we find another type. */
 783
 784           section_type = s_none;
 785
 786           /* For a class, if all members are private, there's no need
 787              for a "private:" label; similarly, for a struct or union
 788              masquerading as a class, if all members are public, there's
 789              no need for a "public:" label. */
 790
 791           if (TYPE_DECLARED_CLASS (type))
 792             {
 793               QUIT;
 794               len = TYPE_NFIELDS (type);
 795               for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 796                 if (!TYPE_FIELD_PRIVATE (type, i))
 797                   {
 798                     need_access_label = 1;
 799                     break;
 800                   }
 801               QUIT;
 802               if (!need_access_label)
 803                 {
 804                   len2 = TYPE_NFN_FIELDS (type);
 805                   for (j = 0; j < len2; j++)
 806                     {
 807                       len = TYPE_FN_FIELDLIST_LENGTH (type, j);
 808                       for (i = 0; i < len; i++)
 809                         if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i))
 810                           {
 811                             need_access_label = 1;
 812                             break;
 813                           }
 814                       if (need_access_label)
 815                         break;
 816                     }
 817                 }
 818             }
 819           else
 820             {
 821               QUIT;
 822               len = TYPE_NFIELDS (type);
 823               for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 824                 if (TYPE_FIELD_PRIVATE (type, i) || TYPE_FIELD_PROTECTED (type, i))
 825                   {
 826                     need_access_label = 1;
 827                     break;
 828                   }
 829               QUIT;
 830               if (!need_access_label)
 831                 {
 832                   len2 = TYPE_NFN_FIELDS (type);
 833                   for (j = 0; j < len2; j++)
 834                     {
 835                       QUIT;
 836                       len = TYPE_FN_FIELDLIST_LENGTH (type, j);
 837                       for (i = 0; i < len; i++)
 838                         if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i)
 839                             || TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type, j), i))
 840                           {
 841                             need_access_label = 1;
 842                             break;
 843                           }
 844                       if (need_access_label)
 845                         break;
 846                     }
 847                 }
 848             }
 849
 850           /* If there is a base class for this type,
 851              do not print the field that it occupies.  */
 852
 853           len = TYPE_NFIELDS (type);
 854           vptr_fieldno = get_vptr_fieldno (type, &basetype);
 855           for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 856             {
 857               QUIT;
 858
 859               /* If we have a virtual table pointer, omit it.  Even if
 860                  virtual table pointers are not specifically marked in
 861                  the debug info, they should be artificial.  */
 862               if ((i == vptr_fieldno && type == basetype)
 863                   || TYPE_FIELD_ARTIFICIAL (type, i))
 864                 continue;
 865
 866               if (need_access_label)
 867                 {
 868                   if (TYPE_FIELD_PROTECTED (type, i))
 869                     {
 870                       if (section_type != s_protected)
 871                         {
 872                           section_type = s_protected;
 873                           fprintfi_filtered (level + 2, stream,
 874                                              "protected:\n");
 875                         }
 876                     }
 877                   else if (TYPE_FIELD_PRIVATE (type, i))
 878                     {
 879                       if (section_type != s_private)
 880                         {
 881                           section_type = s_private;
 882                           fprintfi_filtered (level + 2, stream, "private:\n");
 883                         }
 884                     }
 885                   else
 886                     {
 887                       if (section_type != s_public)
 888                         {
 889                           section_type = s_public;
 890                           fprintfi_filtered (level + 2, stream, "public:\n");
 891                         }
 892                     }
 893                 }
 894
 895               print_spaces_filtered (level + 4, stream);
 896               if (field_is_static (&TYPE_FIELD (type, i)))
 897                 fprintf_filtered (stream, "static ");
 898               c_print_type (TYPE_FIELD_TYPE (type, i),
 899                             TYPE_FIELD_NAME (type, i),
 900                             stream, show - 1, level + 4);
 901               if (!field_is_static (&TYPE_FIELD (type, i))
 902                   && TYPE_FIELD_PACKED (type, i))
 903                 {
 904                   /* It is a bitfield.  This code does not attempt
 905                      to look at the bitpos and reconstruct filler,
 906                      unnamed fields.  This would lead to misleading
 907                      results if the compiler does not put out fields
 908                      for such things (I don't know what it does).  */
 909                   fprintf_filtered (stream, " : %d",
 910                                     TYPE_FIELD_BITSIZE (type, i));
 911                 }
 912               fprintf_filtered (stream, ";\n");
 913             }
 914
 915           /* If there are both fields and methods, put a blank line
 916               between them.  Make sure to count only method that we will
 917               display; artificial methods will be hidden.  */
 918           len = TYPE_NFN_FIELDS (type);
 919           real_len = 0;
 920           for (i = 0; i < len; i++)
 921             {
 922               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 923               int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 924               int j;
 925
 926               for (j = 0; j < len2; j++)
 927                 if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
 928                   real_len++;
 929             }
 930           if (real_len > 0 && section_type != s_none)
 931             fprintf_filtered (stream, "\n");
 932
 933           /* C++: print out the methods */
 934           for (i = 0; i < len; i++)
 935             {
 936               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 937               int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 938               char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
 939               char *name = type_name_no_tag (type);
 940               int is_constructor = name && strcmp (method_name, name) == 0;
 941
 942               for (j = 0; j < len2; j++)
 943                 {
 944                   char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
 945                   int is_full_physname_constructor =
 946                     is_constructor_name (physname)
 947                     || is_destructor_name (physname)
 948                     || method_name[0] == '~';
 949
 950                   /* Do not print out artificial methods.  */
 951                   if (TYPE_FN_FIELD_ARTIFICIAL (f, j))
 952                     continue;
 953
 954                   QUIT;
 955                   if (TYPE_FN_FIELD_PROTECTED (f, j))
 956                     {
 957                       if (section_type != s_protected)
 958                         {
 959                           section_type = s_protected;
 960                           fprintfi_filtered (level + 2, stream,
 961                                              "protected:\n");
 962                         }
 963                     }
 964                   else if (TYPE_FN_FIELD_PRIVATE (f, j))
 965                     {
 966                       if (section_type != s_private)
 967                         {
 968                           section_type = s_private;
 969                           fprintfi_filtered (level + 2, stream, "private:\n");
 970                         }
 971                     }
 972                   else
 973                     {
 974                       if (section_type != s_public)
 975                         {
 976                           section_type = s_public;
 977                           fprintfi_filtered (level + 2, stream, "public:\n");
 978                         }
 979                     }
 980
 981                   print_spaces_filtered (level + 4, stream);
 982                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
 983                     fprintf_filtered (stream, "virtual ");
 984                   else if (TYPE_FN_FIELD_STATIC_P (f, j))
 985                     fprintf_filtered (stream, "static ");
 986                   if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
 987                     {
 988                       /* Keep GDB from crashing here.  */
 989                       fprintf_filtered (stream, _("<undefined type> %s;\n"),
 990                                         TYPE_FN_FIELD_PHYSNAME (f, j));
 991                       break;
 992                     }
 993                   else if (!is_constructor      /* constructors don't have declared types */
 994                            && !is_full_physname_constructor     /*    " "  */
 995                            && !is_type_conversion_operator (type, i, j))
 996                     {
 997                       type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
 998                                   "", stream, -1);
 999                       fputs_filtered (" ", stream);
1000                     }
1001                   if (TYPE_FN_FIELD_STUB (f, j))
1002                     /* Build something we can demangle.  */
1003                     mangled_name = gdb_mangle_name (type, i, j);
1004                   else
1005                     mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
1006
1007                   demangled_name =
1008                     cplus_demangle (mangled_name,
1009                                     DMGL_ANSI | DMGL_PARAMS);
1010                   if (demangled_name == NULL)
1011                     {
1012                       /* in some cases (for instance with the HP demangling),
1013                          if a function has more than 10 arguments,
1014                          the demangling will fail.
1015                          Let's try to reconstruct the function signature from
1016                          the symbol information */
1017                       if (!TYPE_FN_FIELD_STUB (f, j))
1018                         {
1019                           int staticp = TYPE_FN_FIELD_STATIC_P (f, j);
1020                           struct type *mtype = TYPE_FN_FIELD_TYPE (f, j);
1021
1022                           cp_type_print_method_args (mtype,
1023                                                      "",
1024                                                      method_name,
1025                                                      staticp,
1026                                                      stream);
1027                         }
1028                       else
1029                         fprintf_filtered (stream, _("<badly mangled name '%s'>"),
1030                                           mangled_name);
1031                     }
1032                   else
1033                     {
1034                       char *p;
1035                       char *demangled_no_class
1036                         = remove_qualifiers (demangled_name);
1037
1038                       /* get rid of the `static' appended by the demangler */
1039                       p = strstr (demangled_no_class, " static");
1040                       if (p != NULL)
1041                         {
1042                           int length = p - demangled_no_class;
1043
1044                           demangled_no_static = (char *) xmalloc (length + 1);
1045                           strncpy (demangled_no_static, demangled_no_class, length);
1046                           *(demangled_no_static + length) = '\0';
1047                           fputs_filtered (demangled_no_static, stream);
1048                           xfree (demangled_no_static);
1049                         }
1050                       else
1051                         fputs_filtered (demangled_no_class, stream);
1052                       xfree (demangled_name);
1053                     }
1054
1055                   if (TYPE_FN_FIELD_STUB (f, j))
1056                     xfree (mangled_name);
1057
1058                   fprintf_filtered (stream, ";\n");
1059                 }
1060             }
1061
1062           /* Print typedefs defined in this class.  */
1063
1064           if (TYPE_TYPEDEF_FIELD_COUNT (type) != 0)
1065             {
1066               if (TYPE_NFIELDS (type) != 0 || TYPE_NFN_FIELDS (type) != 0)
1067                 fprintf_filtered (stream, "\n");
1068
1069               for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (type); i++)
1070                 {
1071                   struct type *target = TYPE_TYPEDEF_FIELD_TYPE (type, i);
1072
1073                   /* Dereference the typedef declaration itself.  */
1074                   gdb_assert (TYPE_CODE (target) == TYPE_CODE_TYPEDEF);
1075                   target = TYPE_TARGET_TYPE (target);
1076
1077                   print_spaces_filtered (level + 4, stream);
1078                   fprintf_filtered (stream, "typedef ");
1079                   c_print_type (target, TYPE_TYPEDEF_FIELD_NAME (type, i),
1080                                 stream, show - 1, level + 4);
1081                   fprintf_filtered (stream, ";\n");
1082                 }
1083             }
1084
1085           fprintfi_filtered (level, stream, "}");
1086
1087           if (TYPE_LOCALTYPE_PTR (type) && show >= 0)
1088             fprintfi_filtered (level, stream, _(" (Local at %s:%d)\n"),
1089                                TYPE_LOCALTYPE_FILE (type),
1090                                TYPE_LOCALTYPE_LINE (type));
1091         }
1092       break;
1093
1094     case TYPE_CODE_ENUM:
1095       c_type_print_modifier (type, stream, 0, 1);
1096       fprintf_filtered (stream, "enum ");
1097       /* Print the tag name if it exists.
1098          The aCC compiler emits a spurious
1099          "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1100          tag for unnamed struct/union/enum's, which we don't
1101          want to print. */
1102       if (TYPE_TAG_NAME (type) != NULL
1103           && strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
1104         {
1105           fputs_filtered (TYPE_TAG_NAME (type), stream);
1106           if (show > 0)
1107             fputs_filtered (" ", stream);
1108         }
1109
1110       wrap_here ("    ");
1111       if (show < 0)
1112         {
1113           /* If we just printed a tag name, no need to print anything else.  */
1114           if (TYPE_TAG_NAME (type) == NULL)
1115             fprintf_filtered (stream, "{...}");
1116         }
1117       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1118         {
1119           fprintf_filtered (stream, "{");
1120           len = TYPE_NFIELDS (type);
1121           lastval = 0;
1122           for (i = 0; i < len; i++)
1123             {
1124               QUIT;
1125               if (i)
1126                 fprintf_filtered (stream, ", ");
1127               wrap_here ("    ");
1128               fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1129               if (lastval != TYPE_FIELD_BITPOS (type, i))
1130                 {
1131                   fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
1132                   lastval = TYPE_FIELD_BITPOS (type, i);
1133                 }
1134               lastval++;
1135             }
1136           fprintf_filtered (stream, "}");
1137         }
1138       break;
1139
1140     case TYPE_CODE_VOID:
1141       fprintf_filtered (stream, "void");
1142       break;
1143
1144     case TYPE_CODE_UNDEF:
1145       fprintf_filtered (stream, _("struct <unknown>"));
1146       break;
1147
1148     case TYPE_CODE_ERROR:
1149       fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
1150       break;
1151
1152     case TYPE_CODE_RANGE:
1153       /* This should not occur */
1154       fprintf_filtered (stream, _("<range type>"));
1155       break;
1156
1157     case TYPE_CODE_NAMESPACE:
1158       fputs_filtered ("namespace ", stream);
1159       fputs_filtered (TYPE_TAG_NAME (type), stream);
1160       break;
1161
1162     default:
1163       /* Handle types not explicitly handled by the other cases,
1164          such as fundamental types.  For these, just print whatever
1165          the type name is, as recorded in the type itself.  If there
1166          is no type name, then complain. */
1167       if (TYPE_NAME (type) != NULL)
1168         {
1169           c_type_print_modifier (type, stream, 0, 1);
1170           fputs_filtered (TYPE_NAME (type), stream);
1171         }
1172       else
1173         {
1174           /* At least for dump_symtab, it is important that this not be
1175              an error ().  */
1176           fprintf_filtered (stream, _("<invalid type code %d>"),
1177                             TYPE_CODE (type));
1178         }
1179       break;
1180     }
1181 }