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 LINKAGE_NAME is zero.  If
 391    LINKAGE_NAME is non-zero and LANGUAGE is language_cplus the topmost
 392    parameter types get removed their possible const and volatile qualifiers to
 393    match demangled linkage name parameters part of such function type.
 394    LANGUAGE is the language in which TYPE was defined.  This is a necessary
 395    evil since this code is used by the C, C++, and Java backends.  */
 396
 397 void
 398 c_type_print_args (struct type *type, struct ui_file *stream,
 399                    int linkage_name, enum language language)
 400 {
 401   int i, len;
 402   struct field *args;
 403   int printed_any = 0;
 404
 405   fprintf_filtered (stream, "(");
 406   args = TYPE_FIELDS (type);
 407   len = TYPE_NFIELDS (type);
 408
 409   for (i = 0; i < TYPE_NFIELDS (type); i++)
 410     {
 411       struct type *param_type;
 412
 413       if (TYPE_FIELD_ARTIFICIAL (type, i) && linkage_name)
 414         continue;
 415
 416       if (printed_any)
 417         {
 418           fprintf_filtered (stream, ", ");
 419           wrap_here ("    ");
 420         }
 421
 422       param_type = TYPE_FIELD_TYPE (type, i);
 423
 424       if (language == language_cplus && linkage_name)
 425         {
 426           /* C++ standard, 13.1 Overloadable declarations, point 3, item:
 427              - Parameter declarations that differ only in the presence or
 428                absence of const and/or volatile are equivalent.
 429
 430              And the const/volatile qualifiers are not present in the mangled
 431              names as produced by GCC.  */
 432
 433           param_type = make_cv_type (0, 0, param_type, NULL);
 434         }
 435
 436       if (language == language_java)
 437         java_print_type (param_type, "", stream, -1, 0);
 438       else
 439         c_print_type (param_type, "", stream, -1, 0);
 440       printed_any = 1;
 441     }
 442
 443   if (printed_any && TYPE_VARARGS (type))
 444     {
 445       /* Print out a trailing ellipsis for varargs functions.  Ignore
 446          TYPE_VARARGS if the function has no named arguments; that
 447          represents unprototyped (K&R style) C functions.  */
 448       if (printed_any && TYPE_VARARGS (type))
 449         {
 450           fprintf_filtered (stream, ", ");
 451           wrap_here ("    ");
 452           fprintf_filtered (stream, "...");
 453         }
 454     }
 455   else if (!printed_any
 456            && ((TYPE_PROTOTYPED (type) && language != language_java)
 457                || language == language_cplus))
 458     fprintf_filtered (stream, "void");
 459
 460   fprintf_filtered (stream, ")");
 461 }
 462
 463 /* Return true iff the j'th overloading of the i'th method of TYPE
 464    is a type conversion operator, like `operator int () { ... }'.
 465    When listing a class's methods, we don't print the return type of
 466    such operators.  */
 467
 468 static int
 469 is_type_conversion_operator (struct type *type, int i, int j)
 470 {
 471   /* I think the whole idea of recognizing type conversion operators
 472      by their name is pretty terrible.  But I don't think our present
 473      data structure gives us any other way to tell.  If you know of
 474      some other way, feel free to rewrite this function.  */
 475   char *name = TYPE_FN_FIELDLIST_NAME (type, i);
 476
 477   if (strncmp (name, "operator", 8) != 0)
 478     return 0;
 479
 480   name += 8;
 481   if (! strchr (" \t\f\n\r", *name))
 482     return 0;
 483
 484   while (strchr (" \t\f\n\r", *name))
 485     name++;
 486
 487   if (!('a' <= *name && *name <= 'z')
 488       && !('A' <= *name && *name <= 'Z')
 489       && *name != '_')
 490     /* If this doesn't look like the start of an identifier, then it
 491        isn't a type conversion operator.  */
 492     return 0;
 493   else if (strncmp (name, "new", 3) == 0)
 494     name += 3;
 495   else if (strncmp (name, "delete", 6) == 0)
 496     name += 6;
 497   else
 498     /* If it doesn't look like new or delete, it's a type conversion
 499        operator.  */
 500     return 1;
 501
 502   /* Is that really the end of the name?  */
 503   if (('a' <= *name && *name <= 'z')
 504       || ('A' <= *name && *name <= 'Z')
 505       || ('0' <= *name && *name <= '9')
 506       || *name == '_')
 507     /* No, so the identifier following "operator" must be a type name,
 508        and this is a type conversion operator.  */
 509     return 1;
 510
 511   /* That was indeed the end of the name, so it was `operator new' or
 512      `operator delete', neither of which are type conversion
 513      operators.  */
 514   return 0;
 515 }
 516
 517 /* Given a C++ qualified identifier QID, strip off the qualifiers,
 518    yielding the unqualified name.  The return value is a pointer into
 519    the original string.
 520
 521    It's a pity we don't have this information in some more structured
 522    form.  Even the author of this function feels that writing little
 523    parsers like this everywhere is stupid.  */
 524
 525 static char *
 526 remove_qualifiers (char *qid)
 527 {
 528   int quoted = 0;       /* Zero if we're not in quotes;
 529                            '"' if we're in a double-quoted string;
 530                            '\'' if we're in a single-quoted string.  */
 531   int depth = 0;        /* Number of unclosed parens we've seen.  */
 532   char *parenstack = (char *) alloca (strlen (qid));
 533   char *scan;
 534   char *last = 0;       /* The character after the rightmost
 535                            `::' token we've seen so far.  */
 536
 537   for (scan = qid; *scan; scan++)
 538     {
 539       if (quoted)
 540         {
 541           if (*scan == quoted)
 542             quoted = 0;
 543           else if (*scan == '\\' && *(scan + 1))
 544             scan++;
 545         }
 546       else if (scan[0] == ':' && scan[1] == ':')
 547         {
 548           /* If we're inside parenthesis (i.e., an argument list) or
 549              angle brackets (i.e., a list of template arguments), then
 550              we don't record the position of this :: token, since it's
 551              not relevant to the top-level structure we're trying to
 552              operate on.  */
 553           if (depth == 0)
 554             {
 555               last = scan + 2;
 556               scan++;
 557             }
 558         }
 559       else if (*scan == '"' || *scan == '\'')
 560         quoted = *scan;
 561       else if (*scan == '(')
 562         parenstack[depth++] = ')';
 563       else if (*scan == '[')
 564         parenstack[depth++] = ']';
 565       /* We're going to treat <> as a pair of matching characters,
 566          since we're more likely to see those in template id's than
 567          real less-than characters.  What a crock.  */
 568       else if (*scan == '<')
 569         parenstack[depth++] = '>';
 570       else if (*scan == ')' || *scan == ']' || *scan == '>')
 571         {
 572           if (depth > 0 && parenstack[depth - 1] == *scan)
 573             depth--;
 574           else
 575             {
 576               /* We're going to do a little error recovery here.  If
 577                  we don't find a match for *scan on the paren stack,
 578                  but there is something lower on the stack that does
 579                  match, we pop the stack to that point.  */
 580               int i;
 581
 582               for (i = depth - 1; i >= 0; i--)
 583                 if (parenstack[i] == *scan)
 584                   {
 585                     depth = i;
 586                     break;
 587                   }
 588             }
 589         }
 590     }
 591
 592   if (last)
 593     return last;
 594   else
 595     /* We didn't find any :: tokens at the top level, so declare the
 596        whole thing an unqualified identifier.  */
 597     return qid;
 598 }
 599
 600 /* Print any array sizes, function arguments or close parentheses
 601    needed after the variable name (to describe its type).
 602    Args work like c_type_print_varspec_prefix.  */
 603
 604 void
 605 c_type_print_varspec_suffix (struct type *type,
 606                              struct ui_file *stream,
 607                              int show, int passed_a_ptr,
 608                              int demangled_args)
 609 {
 610   if (type == 0)
 611     return;
 612
 613   if (TYPE_NAME (type) && show <= 0)
 614     return;
 615
 616   QUIT;
 617
 618   switch (TYPE_CODE (type))
 619     {
 620     case TYPE_CODE_ARRAY:
 621       {
 622         LONGEST low_bound, high_bound;
 623
 624         if (passed_a_ptr)
 625           fprintf_filtered (stream, ")");
 626
 627         fprintf_filtered (stream, "[");
 628         if (get_array_bounds (type, &low_bound, &high_bound))
 629           fprintf_filtered (stream, "%d",
 630                             (int) (high_bound - low_bound + 1));
 631         fprintf_filtered (stream, "]");
 632
 633         c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
 634                                      show, 0, 0);
 635       }
 636       break;
 637
 638     case TYPE_CODE_MEMBERPTR:
 639       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
 640                                    show, 0, 0);
 641       break;
 642
 643     case TYPE_CODE_METHODPTR:
 644       fprintf_filtered (stream, ")");
 645       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
 646                                    show, 0, 0);
 647       break;
 648
 649     case TYPE_CODE_PTR:
 650     case TYPE_CODE_REF:
 651       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
 652                                    show, 1, 0);
 653       break;
 654
 655     case TYPE_CODE_METHOD:
 656     case TYPE_CODE_FUNC:
 657       if (passed_a_ptr)
 658         fprintf_filtered (stream, ")");
 659       if (!demangled_args)
 660         c_type_print_args (type, stream, 0, current_language->la_language);
 661       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
 662                                    show, passed_a_ptr, 0);
 663       break;
 664
 665     case TYPE_CODE_TYPEDEF:
 666       c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
 667                                    show, passed_a_ptr, 0);
 668       break;
 669
 670     case TYPE_CODE_UNDEF:
 671     case TYPE_CODE_STRUCT:
 672     case TYPE_CODE_UNION:
 673     case TYPE_CODE_ENUM:
 674     case TYPE_CODE_INT:
 675     case TYPE_CODE_FLT:
 676     case TYPE_CODE_VOID:
 677     case TYPE_CODE_ERROR:
 678     case TYPE_CODE_CHAR:
 679     case TYPE_CODE_BOOL:
 680     case TYPE_CODE_SET:
 681     case TYPE_CODE_RANGE:
 682     case TYPE_CODE_STRING:
 683     case TYPE_CODE_BITSTRING:
 684     case TYPE_CODE_COMPLEX:
 685     case TYPE_CODE_NAMESPACE:
 686     case TYPE_CODE_DECFLOAT:
 687       /* These types do not need a suffix.  They are listed so that
 688          gcc -Wall will report types that may not have been
 689          considered.  */
 690       break;
 691     default:
 692       error (_("type not handled in c_type_print_varspec_suffix()"));
 693       break;
 694     }
 695 }
 696
 697 /* Print the name of the type (or the ultimate pointer target,
 698    function value or array element), or the description of a structure
 699    or union.
 700
 701    SHOW positive means print details about the type (e.g. enum
 702    values), and print structure elements passing SHOW - 1 for show.
 703
 704    SHOW negative means just print the type name or struct tag if there
 705    is one.  If there is no name, print something sensible but concise
 706    like "struct {...}".
 707
 708    SHOW zero means just print the type name or struct tag if there is
 709    one.  If there is no name, print something sensible but not as
 710    concise like "struct {int x; int y;}".
 711
 712    LEVEL is the number of spaces to indent by.
 713    We increase it for some recursive calls.  */
 714
 715 void
 716 c_type_print_base (struct type *type, struct ui_file *stream,
 717                    int show, int level)
 718 {
 719   int i;
 720   int len, real_len;
 721   int lastval;
 722   enum
 723     {
 724       s_none, s_public, s_private, s_protected
 725     }
 726   section_type;
 727   int need_access_label = 0;
 728   int j, len2;
 729
 730   QUIT;
 731
 732   wrap_here ("    ");
 733   if (type == NULL)
 734     {
 735       fputs_filtered (_("<type unknown>"), stream);
 736       return;
 737     }
 738
 739   /* When SHOW is zero or less, and there is a valid type name, then
 740      always just print the type name directly from the type.  */
 741   /* If we have "typedef struct foo {. . .} bar;" do we want to print
 742      it as "struct foo" or as "bar"?  Pick the latter, because C++
 743      folk tend to expect things like "class5 *foo" rather than "struct
 744      class5 *foo".  */
 745
 746   if (show <= 0
 747       && TYPE_NAME (type) != NULL)
 748     {
 749       c_type_print_modifier (type, stream, 0, 1);
 750       fputs_filtered (TYPE_NAME (type), stream);
 751       return;
 752     }
 753
 754   CHECK_TYPEDEF (type);
 755
 756   switch (TYPE_CODE (type))
 757     {
 758     case TYPE_CODE_TYPEDEF:
 759       /* If we get here, the typedef doesn't have a name, and we
 760          couldn't resolve TYPE_TARGET_TYPE.  Not much we can do.  */
 761       gdb_assert (TYPE_NAME (type) == NULL);
 762       gdb_assert (TYPE_TARGET_TYPE (type) == NULL);
 763       fprintf_filtered (stream, _("<unnamed typedef>"));
 764       break;
 765
 766     case TYPE_CODE_ARRAY:
 767     case TYPE_CODE_PTR:
 768     case TYPE_CODE_MEMBERPTR:
 769     case TYPE_CODE_REF:
 770     case TYPE_CODE_FUNC:
 771     case TYPE_CODE_METHOD:
 772     case TYPE_CODE_METHODPTR:
 773       c_type_print_base (TYPE_TARGET_TYPE (type),
 774                          stream, show, level);
 775       break;
 776
 777     case TYPE_CODE_STRUCT:
 778       c_type_print_modifier (type, stream, 0, 1);
 779       if (TYPE_DECLARED_CLASS (type))
 780         fprintf_filtered (stream, "class ");
 781       else
 782         fprintf_filtered (stream, "struct ");
 783       goto struct_union;
 784
 785     case TYPE_CODE_UNION:
 786       c_type_print_modifier (type, stream, 0, 1);
 787       fprintf_filtered (stream, "union ");
 788
 789     struct_union:
 790
 791       /* Print the tag if it exists.  The HP aCC compiler emits a
 792          spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
 793          enum}" tag for unnamed struct/union/enum's, which we don't
 794          want to print.  */
 795       if (TYPE_TAG_NAME (type) != NULL
 796           && strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
 797         {
 798           fputs_filtered (TYPE_TAG_NAME (type), stream);
 799           if (show > 0)
 800             fputs_filtered (" ", stream);
 801         }
 802       wrap_here ("    ");
 803       if (show < 0)
 804         {
 805           /* If we just printed a tag name, no need to print anything
 806              else.  */
 807           if (TYPE_TAG_NAME (type) == NULL)
 808             fprintf_filtered (stream, "{...}");
 809         }
 810       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
 811         {
 812           struct type *basetype;
 813           int vptr_fieldno;
 814
 815           cp_type_print_derivation_info (stream, type);
 816
 817           fprintf_filtered (stream, "{\n");
 818           if (TYPE_NFIELDS (type) == 0 && TYPE_NFN_FIELDS (type) == 0
 819               && TYPE_TYPEDEF_FIELD_COUNT (type) == 0)
 820             {
 821               if (TYPE_STUB (type))
 822                 fprintfi_filtered (level + 4, stream,
 823                                    _("<incomplete type>\n"));
 824               else
 825                 fprintfi_filtered (level + 4, stream,
 826                                    _("<no data fields>\n"));
 827             }
 828
 829           /* Start off with no specific section type, so we can print
 830              one for the first field we find, and use that section type
 831              thereafter until we find another type.  */
 832
 833           section_type = s_none;
 834
 835           /* For a class, if all members are private, there's no need
 836              for a "private:" label; similarly, for a struct or union
 837              masquerading as a class, if all members are public, there's
 838              no need for a "public:" label.  */
 839
 840           if (TYPE_DECLARED_CLASS (type))
 841             {
 842               QUIT;
 843               len = TYPE_NFIELDS (type);
 844               for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 845                 if (!TYPE_FIELD_PRIVATE (type, i))
 846                   {
 847                     need_access_label = 1;
 848                     break;
 849                   }
 850               QUIT;
 851               if (!need_access_label)
 852                 {
 853                   len2 = TYPE_NFN_FIELDS (type);
 854                   for (j = 0; j < len2; j++)
 855                     {
 856                       len = TYPE_FN_FIELDLIST_LENGTH (type, j);
 857                       for (i = 0; i < len; i++)
 858                         if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type,
 859                                                                         j), i))
 860                           {
 861                             need_access_label = 1;
 862                             break;
 863                           }
 864                       if (need_access_label)
 865                         break;
 866                     }
 867                 }
 868             }
 869           else
 870             {
 871               QUIT;
 872               len = TYPE_NFIELDS (type);
 873               for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 874                 if (TYPE_FIELD_PRIVATE (type, i)
 875                     || TYPE_FIELD_PROTECTED (type, i))
 876                   {
 877                     need_access_label = 1;
 878                     break;
 879                   }
 880               QUIT;
 881               if (!need_access_label)
 882                 {
 883                   len2 = TYPE_NFN_FIELDS (type);
 884                   for (j = 0; j < len2; j++)
 885                     {
 886                       QUIT;
 887                       len = TYPE_FN_FIELDLIST_LENGTH (type, j);
 888                       for (i = 0; i < len; i++)
 889                         if (TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type,
 890                                                                          j), i)
 891                             || TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type,
 892                                                                           j),
 893                                                       i))
 894                           {
 895                             need_access_label = 1;
 896                             break;
 897                           }
 898                       if (need_access_label)
 899                         break;
 900                     }
 901                 }
 902             }
 903
 904           /* If there is a base class for this type,
 905              do not print the field that it occupies.  */
 906
 907           len = TYPE_NFIELDS (type);
 908           vptr_fieldno = get_vptr_fieldno (type, &basetype);
 909           for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 910             {
 911               QUIT;
 912
 913               /* If we have a virtual table pointer, omit it.  Even if
 914                  virtual table pointers are not specifically marked in
 915                  the debug info, they should be artificial.  */
 916               if ((i == vptr_fieldno && type == basetype)
 917                   || TYPE_FIELD_ARTIFICIAL (type, i))
 918                 continue;
 919
 920               if (need_access_label)
 921                 {
 922                   if (TYPE_FIELD_PROTECTED (type, i))
 923                     {
 924                       if (section_type != s_protected)
 925                         {
 926                           section_type = s_protected;
 927                           fprintfi_filtered (level + 2, stream,
 928                                              "protected:\n");
 929                         }
 930                     }
 931                   else if (TYPE_FIELD_PRIVATE (type, i))
 932                     {
 933                       if (section_type != s_private)
 934                         {
 935                           section_type = s_private;
 936                           fprintfi_filtered (level + 2, stream,
 937                                              "private:\n");
 938                         }
 939                     }
 940                   else
 941                     {
 942                       if (section_type != s_public)
 943                         {
 944                           section_type = s_public;
 945                           fprintfi_filtered (level + 2, stream,
 946                                              "public:\n");
 947                         }
 948                     }
 949                 }
 950
 951               print_spaces_filtered (level + 4, stream);
 952               if (field_is_static (&TYPE_FIELD (type, i)))
 953                 fprintf_filtered (stream, "static ");
 954               c_print_type (TYPE_FIELD_TYPE (type, i),
 955                             TYPE_FIELD_NAME (type, i),
 956                             stream, show - 1, level + 4);
 957               if (!field_is_static (&TYPE_FIELD (type, i))
 958                   && TYPE_FIELD_PACKED (type, i))
 959                 {
 960                   /* It is a bitfield.  This code does not attempt
 961                      to look at the bitpos and reconstruct filler,
 962                      unnamed fields.  This would lead to misleading
 963                      results if the compiler does not put out fields
 964                      for such things (I don't know what it does).  */
 965                   fprintf_filtered (stream, " : %d",
 966                                     TYPE_FIELD_BITSIZE (type, i));
 967                 }
 968               fprintf_filtered (stream, ";\n");
 969             }
 970
 971           /* If there are both fields and methods, put a blank line
 972              between them.  Make sure to count only method that we
 973              will display; artificial methods will be hidden.  */
 974           len = TYPE_NFN_FIELDS (type);
 975           real_len = 0;
 976           for (i = 0; i < len; i++)
 977             {
 978               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 979               int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 980               int j;
 981
 982               for (j = 0; j < len2; j++)
 983                 if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
 984                   real_len++;
 985             }
 986           if (real_len > 0 && section_type != s_none)
 987             fprintf_filtered (stream, "\n");
 988
 989           /* C++: print out the methods.  */
 990           for (i = 0; i < len; i++)
 991             {
 992               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 993               int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 994               char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
 995               char *name = type_name_no_tag (type);
 996               int is_constructor = name && strcmp (method_name,
 997                                                    name) == 0;
 998
 999               for (j = 0; j < len2; j++)
1000                 {
1001                   const char *mangled_name;
1002                   char *demangled_name;
1003                   struct cleanup *inner_cleanup;
1004                   const char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
1005                   int is_full_physname_constructor =
1006                     is_constructor_name (physname)
1007                     || is_destructor_name (physname)
1008                     || method_name[0] == '~';
1009
1010                   /* Do not print out artificial methods.  */
1011                   if (TYPE_FN_FIELD_ARTIFICIAL (f, j))
1012                     continue;
1013
1014                   inner_cleanup = make_cleanup (null_cleanup, NULL);
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                     {
1070                       char *tem;
1071
1072                       /* Build something we can demangle.  */
1073                       tem = gdb_mangle_name (type, i, j);
1074                       make_cleanup (xfree, tem);
1075                       mangled_name = tem;
1076                     }
1077                   else
1078                     mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
1079
1080                   demangled_name =
1081                     cplus_demangle (mangled_name,
1082                                     DMGL_ANSI | DMGL_PARAMS);
1083                   if (demangled_name == NULL)
1084                     {
1085                       /* In some cases (for instance with the HP
1086                          demangling), if a function has more than 10
1087                          arguments, the demangling will fail.
1088                          Let's try to reconstruct the function
1089                          signature from the symbol information.  */
1090                       if (!TYPE_FN_FIELD_STUB (f, j))
1091                         {
1092                           int staticp = TYPE_FN_FIELD_STATIC_P (f, j);
1093                           struct type *mtype = TYPE_FN_FIELD_TYPE (f, j);
1094
1095                           cp_type_print_method_args (mtype,
1096                                                      "",
1097                                                      method_name,
1098                                                      staticp,
1099                                                      stream);
1100                         }
1101                       else
1102                         fprintf_filtered (stream,
1103                                           _("<badly mangled name '%s'>"),
1104                                           mangled_name);
1105                     }
1106                   else
1107                     {
1108                       char *p;
1109                       char *demangled_no_class
1110                         = remove_qualifiers (demangled_name);
1111
1112                       /* Get rid of the `static' appended by the
1113                          demangler.  */
1114                       p = strstr (demangled_no_class, " static");
1115                       if (p != NULL)
1116                         {
1117                           int length = p - demangled_no_class;
1118                           char *demangled_no_static;
1119
1120                           demangled_no_static
1121                             = (char *) xmalloc (length + 1);
1122                           strncpy (demangled_no_static,
1123                                    demangled_no_class, length);
1124                           *(demangled_no_static + length) = '\0';
1125                           fputs_filtered (demangled_no_static, stream);
1126                           xfree (demangled_no_static);
1127                         }
1128                       else
1129                         fputs_filtered (demangled_no_class, stream);
1130                       xfree (demangled_name);
1131                     }
1132
1133                   do_cleanups (inner_cleanup);
1134
1135                   fprintf_filtered (stream, ";\n");
1136                 }
1137             }
1138
1139           /* Print typedefs defined in this class.  */
1140
1141           if (TYPE_TYPEDEF_FIELD_COUNT (type) != 0)
1142             {
1143               if (TYPE_NFIELDS (type) != 0 || TYPE_NFN_FIELDS (type) != 0)
1144                 fprintf_filtered (stream, "\n");
1145
1146               for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (type); i++)
1147                 {
1148                   struct type *target = TYPE_TYPEDEF_FIELD_TYPE (type, i);
1149
1150                   /* Dereference the typedef declaration itself.  */
1151                   gdb_assert (TYPE_CODE (target) == TYPE_CODE_TYPEDEF);
1152                   target = TYPE_TARGET_TYPE (target);
1153
1154                   print_spaces_filtered (level + 4, stream);
1155                   fprintf_filtered (stream, "typedef ");
1156                   c_print_type (target, TYPE_TYPEDEF_FIELD_NAME (type, i),
1157                                 stream, show - 1, level + 4);
1158                   fprintf_filtered (stream, ";\n");
1159                 }
1160             }
1161
1162           fprintfi_filtered (level, stream, "}");
1163
1164           if (TYPE_LOCALTYPE_PTR (type) && show >= 0)
1165             fprintfi_filtered (level,
1166                                stream, _(" (Local at %s:%d)\n"),
1167                                TYPE_LOCALTYPE_FILE (type),
1168                                TYPE_LOCALTYPE_LINE (type));
1169         }
1170       break;
1171
1172     case TYPE_CODE_ENUM:
1173       c_type_print_modifier (type, stream, 0, 1);
1174       fprintf_filtered (stream, "enum ");
1175       /* Print the tag name if it exists.
1176          The aCC compiler emits a spurious
1177          "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1178          tag for unnamed struct/union/enum's, which we don't
1179          want to print.  */
1180       if (TYPE_TAG_NAME (type) != NULL
1181           && strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
1182         {
1183           fputs_filtered (TYPE_TAG_NAME (type), stream);
1184           if (show > 0)
1185             fputs_filtered (" ", stream);
1186         }
1187
1188       wrap_here ("    ");
1189       if (show < 0)
1190         {
1191           /* If we just printed a tag name, no need to print anything
1192              else.  */
1193           if (TYPE_TAG_NAME (type) == NULL)
1194             fprintf_filtered (stream, "{...}");
1195         }
1196       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1197         {
1198           fprintf_filtered (stream, "{");
1199           len = TYPE_NFIELDS (type);
1200           lastval = 0;
1201           for (i = 0; i < len; i++)
1202             {
1203               QUIT;
1204               if (i)
1205                 fprintf_filtered (stream, ", ");
1206               wrap_here ("    ");
1207               fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1208               if (lastval != TYPE_FIELD_BITPOS (type, i))
1209                 {
1210                   fprintf_filtered (stream, " = %d",
1211                                     TYPE_FIELD_BITPOS (type, i));
1212                   lastval = TYPE_FIELD_BITPOS (type, i);
1213                 }
1214               lastval++;
1215             }
1216           fprintf_filtered (stream, "}");
1217         }
1218       break;
1219
1220     case TYPE_CODE_VOID:
1221       fprintf_filtered (stream, "void");
1222       break;
1223
1224     case TYPE_CODE_UNDEF:
1225       fprintf_filtered (stream, _("struct <unknown>"));
1226       break;
1227
1228     case TYPE_CODE_ERROR:
1229       fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
1230       break;
1231
1232     case TYPE_CODE_RANGE:
1233       /* This should not occur.  */
1234       fprintf_filtered (stream, _("<range type>"));
1235       break;
1236
1237     case TYPE_CODE_NAMESPACE:
1238       fputs_filtered ("namespace ", stream);
1239       fputs_filtered (TYPE_TAG_NAME (type), stream);
1240       break;
1241
1242     default:
1243       /* Handle types not explicitly handled by the other cases, such
1244          as fundamental types.  For these, just print whatever the
1245          type name is, as recorded in the type itself.  If there is no
1246          type name, then complain.  */
1247       if (TYPE_NAME (type) != NULL)
1248         {
1249           c_type_print_modifier (type, stream, 0, 1);
1250           fputs_filtered (TYPE_NAME (type), stream);
1251         }
1252       else
1253         {
1254           /* At least for dump_symtab, it is important that this not
1255              be an error ().  */
1256           fprintf_filtered (stream, _("<invalid type code %d>"),
1257                             TYPE_CODE (type));
1258         }
1259       break;
1260     }
1261 }