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