contrib/gdb-7/gdb/c-typeprint.c

   1 /* Support for printing C and C++ types for GDB, the GNU debugger.
   2    Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
   3    1999, 2000, 2001, 2002, 2003, 2006, 2007, 2008, 2009, 2010, 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   char *mangled_name;
 723   char *demangled_name;
 724   char *demangled_no_static;
 725   enum
 726     {
 727       s_none, s_public, s_private, s_protected
 728     }
 729   section_type;
 730   int need_access_label = 0;
 731   int j, len2;
 732
 733   QUIT;
 734
 735   wrap_here ("    ");
 736   if (type == NULL)
 737     {
 738       fputs_filtered (_("<type unknown>"), stream);
 739       return;
 740     }
 741
 742   /* When SHOW is zero or less, and there is a valid type name, then
 743      always just print the type name directly from the type.  */
 744   /* If we have "typedef struct foo {. . .} bar;" do we want to print
 745      it as "struct foo" or as "bar"?  Pick the latter, because C++
 746      folk tend to expect things like "class5 *foo" rather than "struct
 747      class5 *foo".  */
 748
 749   if (show <= 0
 750       && TYPE_NAME (type) != NULL)
 751     {
 752       c_type_print_modifier (type, stream, 0, 1);
 753       fputs_filtered (TYPE_NAME (type), stream);
 754       return;
 755     }
 756
 757   CHECK_TYPEDEF (type);
 758
 759   switch (TYPE_CODE (type))
 760     {
 761     case TYPE_CODE_TYPEDEF:
 762       /* If we get here, the typedef doesn't have a name, and we
 763          couldn't resolve TYPE_TARGET_TYPE.  Not much we can do.  */
 764       gdb_assert (TYPE_NAME (type) == NULL);
 765       gdb_assert (TYPE_TARGET_TYPE (type) == NULL);
 766       fprintf_filtered (stream, _("<unnamed typedef>"));
 767       break;
 768
 769     case TYPE_CODE_ARRAY:
 770     case TYPE_CODE_PTR:
 771     case TYPE_CODE_MEMBERPTR:
 772     case TYPE_CODE_REF:
 773     case TYPE_CODE_FUNC:
 774     case TYPE_CODE_METHOD:
 775     case TYPE_CODE_METHODPTR:
 776       c_type_print_base (TYPE_TARGET_TYPE (type),
 777                          stream, show, level);
 778       break;
 779
 780     case TYPE_CODE_STRUCT:
 781       c_type_print_modifier (type, stream, 0, 1);
 782       if (TYPE_DECLARED_CLASS (type))
 783         fprintf_filtered (stream, "class ");
 784       else
 785         fprintf_filtered (stream, "struct ");
 786       goto struct_union;
 787
 788     case TYPE_CODE_UNION:
 789       c_type_print_modifier (type, stream, 0, 1);
 790       fprintf_filtered (stream, "union ");
 791
 792     struct_union:
 793
 794       /* Print the tag if it exists.  The HP aCC compiler emits a
 795          spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
 796          enum}" tag for unnamed struct/union/enum's, which we don't
 797          want to print.  */
 798       if (TYPE_TAG_NAME (type) != NULL
 799           && strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
 800         {
 801           fputs_filtered (TYPE_TAG_NAME (type), stream);
 802           if (show > 0)
 803             fputs_filtered (" ", stream);
 804         }
 805       wrap_here ("    ");
 806       if (show < 0)
 807         {
 808           /* If we just printed a tag name, no need to print anything
 809              else.  */
 810           if (TYPE_TAG_NAME (type) == NULL)
 811             fprintf_filtered (stream, "{...}");
 812         }
 813       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
 814         {
 815           struct type *basetype;
 816           int vptr_fieldno;
 817
 818           cp_type_print_derivation_info (stream, type);
 819
 820           fprintf_filtered (stream, "{\n");
 821           if (TYPE_NFIELDS (type) == 0 && TYPE_NFN_FIELDS (type) == 0
 822               && TYPE_TYPEDEF_FIELD_COUNT (type) == 0)
 823             {
 824               if (TYPE_STUB (type))
 825                 fprintfi_filtered (level + 4, stream,
 826                                    _("<incomplete type>\n"));
 827               else
 828                 fprintfi_filtered (level + 4, stream,
 829                                    _("<no data fields>\n"));
 830             }
 831
 832           /* Start off with no specific section type, so we can print
 833              one for the first field we find, and use that section type
 834              thereafter until we find another type.  */
 835
 836           section_type = s_none;
 837
 838           /* For a class, if all members are private, there's no need
 839              for a "private:" label; similarly, for a struct or union
 840              masquerading as a class, if all members are public, there's
 841              no need for a "public:" label.  */
 842
 843           if (TYPE_DECLARED_CLASS (type))
 844             {
 845               QUIT;
 846               len = TYPE_NFIELDS (type);
 847               for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 848                 if (!TYPE_FIELD_PRIVATE (type, i))
 849                   {
 850                     need_access_label = 1;
 851                     break;
 852                   }
 853               QUIT;
 854               if (!need_access_label)
 855                 {
 856                   len2 = TYPE_NFN_FIELDS (type);
 857                   for (j = 0; j < len2; j++)
 858                     {
 859                       len = TYPE_FN_FIELDLIST_LENGTH (type, j);
 860                       for (i = 0; i < len; i++)
 861                         if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type,
 862                                                                         j), i))
 863                           {
 864                             need_access_label = 1;
 865                             break;
 866                           }
 867                       if (need_access_label)
 868                         break;
 869                     }
 870                 }
 871             }
 872           else
 873             {
 874               QUIT;
 875               len = TYPE_NFIELDS (type);
 876               for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 877                 if (TYPE_FIELD_PRIVATE (type, i)
 878                     || TYPE_FIELD_PROTECTED (type, i))
 879                   {
 880                     need_access_label = 1;
 881                     break;
 882                   }
 883               QUIT;
 884               if (!need_access_label)
 885                 {
 886                   len2 = TYPE_NFN_FIELDS (type);
 887                   for (j = 0; j < len2; j++)
 888                     {
 889                       QUIT;
 890                       len = TYPE_FN_FIELDLIST_LENGTH (type, j);
 891                       for (i = 0; i < len; i++)
 892                         if (TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type,
 893                                                                          j), i)
 894                             || TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type,
 895                                                                           j),
 896                                                       i))
 897                           {
 898                             need_access_label = 1;
 899                             break;
 900                           }
 901                       if (need_access_label)
 902                         break;
 903                     }
 904                 }
 905             }
 906
 907           /* If there is a base class for this type,
 908              do not print the field that it occupies.  */
 909
 910           len = TYPE_NFIELDS (type);
 911           vptr_fieldno = get_vptr_fieldno (type, &basetype);
 912           for (i = TYPE_N_BASECLASSES (type); i < len; i++)
 913             {
 914               QUIT;
 915
 916               /* If we have a virtual table pointer, omit it.  Even if
 917                  virtual table pointers are not specifically marked in
 918                  the debug info, they should be artificial.  */
 919               if ((i == vptr_fieldno && type == basetype)
 920                   || TYPE_FIELD_ARTIFICIAL (type, i))
 921                 continue;
 922
 923               if (need_access_label)
 924                 {
 925                   if (TYPE_FIELD_PROTECTED (type, i))
 926                     {
 927                       if (section_type != s_protected)
 928                         {
 929                           section_type = s_protected;
 930                           fprintfi_filtered (level + 2, stream,
 931                                              "protected:\n");
 932                         }
 933                     }
 934                   else if (TYPE_FIELD_PRIVATE (type, i))
 935                     {
 936                       if (section_type != s_private)
 937                         {
 938                           section_type = s_private;
 939                           fprintfi_filtered (level + 2, stream,
 940                                              "private:\n");
 941                         }
 942                     }
 943                   else
 944                     {
 945                       if (section_type != s_public)
 946                         {
 947                           section_type = s_public;
 948                           fprintfi_filtered (level + 2, stream,
 949                                              "public:\n");
 950                         }
 951                     }
 952                 }
 953
 954               print_spaces_filtered (level + 4, stream);
 955               if (field_is_static (&TYPE_FIELD (type, i)))
 956                 fprintf_filtered (stream, "static ");
 957               c_print_type (TYPE_FIELD_TYPE (type, i),
 958                             TYPE_FIELD_NAME (type, i),
 959                             stream, show - 1, level + 4);
 960               if (!field_is_static (&TYPE_FIELD (type, i))
 961                   && TYPE_FIELD_PACKED (type, i))
 962                 {
 963                   /* It is a bitfield.  This code does not attempt
 964                      to look at the bitpos and reconstruct filler,
 965                      unnamed fields.  This would lead to misleading
 966                      results if the compiler does not put out fields
 967                      for such things (I don't know what it does).  */
 968                   fprintf_filtered (stream, " : %d",
 969                                     TYPE_FIELD_BITSIZE (type, i));
 970                 }
 971               fprintf_filtered (stream, ";\n");
 972             }
 973
 974           /* If there are both fields and methods, put a blank line
 975              between them.  Make sure to count only method that we
 976              will display; artificial methods will be hidden.  */
 977           len = TYPE_NFN_FIELDS (type);
 978           real_len = 0;
 979           for (i = 0; i < len; i++)
 980             {
 981               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 982               int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 983               int j;
 984
 985               for (j = 0; j < len2; j++)
 986                 if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
 987                   real_len++;
 988             }
 989           if (real_len > 0 && section_type != s_none)
 990             fprintf_filtered (stream, "\n");
 991
 992           /* C++: print out the methods.  */
 993           for (i = 0; i < len; i++)
 994             {
 995               struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
 996               int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
 997               char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
 998               char *name = type_name_no_tag (type);
 999               int is_constructor = name && strcmp (method_name,
1000                                                    name) == 0;
1001
1002               for (j = 0; j < len2; j++)
1003                 {
1004                   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                   QUIT;
1015                   if (TYPE_FN_FIELD_PROTECTED (f, j))
1016                     {
1017                       if (section_type != s_protected)
1018                         {
1019                           section_type = s_protected;
1020                           fprintfi_filtered (level + 2, stream,
1021                                              "protected:\n");
1022                         }
1023                     }
1024                   else if (TYPE_FN_FIELD_PRIVATE (f, j))
1025                     {
1026                       if (section_type != s_private)
1027                         {
1028                           section_type = s_private;
1029                           fprintfi_filtered (level + 2, stream,
1030                                              "private:\n");
1031                         }
1032                     }
1033                   else
1034                     {
1035                       if (section_type != s_public)
1036                         {
1037                           section_type = s_public;
1038                           fprintfi_filtered (level + 2, stream,
1039                                              "public:\n");
1040                         }
1041                     }
1042
1043                   print_spaces_filtered (level + 4, stream);
1044                   if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1045                     fprintf_filtered (stream, "virtual ");
1046                   else if (TYPE_FN_FIELD_STATIC_P (f, j))
1047                     fprintf_filtered (stream, "static ");
1048                   if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
1049                     {
1050                       /* Keep GDB from crashing here.  */
1051                       fprintf_filtered (stream,
1052                                         _("<undefined type> %s;\n"),
1053                                         TYPE_FN_FIELD_PHYSNAME (f, j));
1054                       break;
1055                     }
1056                   else if (!is_constructor      /* Constructors don't
1057                                                    have declared
1058                                                    types.  */
1059                            && !is_full_physname_constructor  /* " " */
1060                            && !is_type_conversion_operator (type, i, j))
1061                     {
1062                       type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
1063                                   "", stream, -1);
1064                       fputs_filtered (" ", stream);
1065                     }
1066                   if (TYPE_FN_FIELD_STUB (f, j))
1067                     /* Build something we can demangle.  */
1068                     mangled_name = gdb_mangle_name (type, i, j);
1069                   else
1070                     mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
1071
1072                   demangled_name =
1073                     cplus_demangle (mangled_name,
1074                                     DMGL_ANSI | DMGL_PARAMS);
1075                   if (demangled_name == NULL)
1076                     {
1077                       /* In some cases (for instance with the HP
1078                          demangling), if a function has more than 10
1079                          arguments, the demangling will fail.
1080                          Let's try to reconstruct the function
1081                          signature from the symbol information.  */
1082                       if (!TYPE_FN_FIELD_STUB (f, j))
1083                         {
1084                           int staticp = TYPE_FN_FIELD_STATIC_P (f, j);
1085                           struct type *mtype = TYPE_FN_FIELD_TYPE (f, j);
1086
1087                           cp_type_print_method_args (mtype,
1088                                                      "",
1089                                                      method_name,
1090                                                      staticp,
1091                                                      stream);
1092                         }
1093                       else
1094                         fprintf_filtered (stream,
1095                                           _("<badly mangled name '%s'>"),
1096                                           mangled_name);
1097                     }
1098                   else
1099                     {
1100                       char *p;
1101                       char *demangled_no_class
1102                         = remove_qualifiers (demangled_name);
1103
1104                       /* Get rid of the `static' appended by the
1105                          demangler.  */
1106                       p = strstr (demangled_no_class, " static");
1107                       if (p != NULL)
1108                         {
1109                           int length = p - demangled_no_class;
1110
1111                           demangled_no_static
1112                             = (char *) xmalloc (length + 1);
1113                           strncpy (demangled_no_static,
1114                                    demangled_no_class, length);
1115                           *(demangled_no_static + length) = '\0';
1116                           fputs_filtered (demangled_no_static, stream);
1117                           xfree (demangled_no_static);
1118                         }
1119                       else
1120                         fputs_filtered (demangled_no_class, stream);
1121                       xfree (demangled_name);
1122                     }
1123
1124                   if (TYPE_FN_FIELD_STUB (f, j))
1125                     xfree (mangled_name);
1126
1127                   fprintf_filtered (stream, ";\n");
1128                 }
1129             }
1130
1131           /* Print typedefs defined in this class.  */
1132
1133           if (TYPE_TYPEDEF_FIELD_COUNT (type) != 0)
1134             {
1135               if (TYPE_NFIELDS (type) != 0 || TYPE_NFN_FIELDS (type) != 0)
1136                 fprintf_filtered (stream, "\n");
1137
1138               for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (type); i++)
1139                 {
1140                   struct type *target = TYPE_TYPEDEF_FIELD_TYPE (type, i);
1141
1142                   /* Dereference the typedef declaration itself.  */
1143                   gdb_assert (TYPE_CODE (target) == TYPE_CODE_TYPEDEF);
1144                   target = TYPE_TARGET_TYPE (target);
1145
1146                   print_spaces_filtered (level + 4, stream);
1147                   fprintf_filtered (stream, "typedef ");
1148                   c_print_type (target, TYPE_TYPEDEF_FIELD_NAME (type, i),
1149                                 stream, show - 1, level + 4);
1150                   fprintf_filtered (stream, ";\n");
1151                 }
1152             }
1153
1154           fprintfi_filtered (level, stream, "}");
1155
1156           if (TYPE_LOCALTYPE_PTR (type) && show >= 0)
1157             fprintfi_filtered (level,
1158                                stream, _(" (Local at %s:%d)\n"),
1159                                TYPE_LOCALTYPE_FILE (type),
1160                                TYPE_LOCALTYPE_LINE (type));
1161         }
1162       break;
1163
1164     case TYPE_CODE_ENUM:
1165       c_type_print_modifier (type, stream, 0, 1);
1166       fprintf_filtered (stream, "enum ");
1167       /* Print the tag name if it exists.
1168          The aCC compiler emits a spurious
1169          "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1170          tag for unnamed struct/union/enum's, which we don't
1171          want to print.  */
1172       if (TYPE_TAG_NAME (type) != NULL
1173           && strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
1174         {
1175           fputs_filtered (TYPE_TAG_NAME (type), stream);
1176           if (show > 0)
1177             fputs_filtered (" ", stream);
1178         }
1179
1180       wrap_here ("    ");
1181       if (show < 0)
1182         {
1183           /* If we just printed a tag name, no need to print anything
1184              else.  */
1185           if (TYPE_TAG_NAME (type) == NULL)
1186             fprintf_filtered (stream, "{...}");
1187         }
1188       else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1189         {
1190           fprintf_filtered (stream, "{");
1191           len = TYPE_NFIELDS (type);
1192           lastval = 0;
1193           for (i = 0; i < len; i++)
1194             {
1195               QUIT;
1196               if (i)
1197                 fprintf_filtered (stream, ", ");
1198               wrap_here ("    ");
1199               fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1200               if (lastval != TYPE_FIELD_BITPOS (type, i))
1201                 {
1202                   fprintf_filtered (stream, " = %d",
1203                                     TYPE_FIELD_BITPOS (type, i));
1204                   lastval = TYPE_FIELD_BITPOS (type, i);
1205                 }
1206               lastval++;
1207             }
1208           fprintf_filtered (stream, "}");
1209         }
1210       break;
1211
1212     case TYPE_CODE_VOID:
1213       fprintf_filtered (stream, "void");
1214       break;
1215
1216     case TYPE_CODE_UNDEF:
1217       fprintf_filtered (stream, _("struct <unknown>"));
1218       break;
1219
1220     case TYPE_CODE_ERROR:
1221       fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
1222       break;
1223
1224     case TYPE_CODE_RANGE:
1225       /* This should not occur.  */
1226       fprintf_filtered (stream, _("<range type>"));
1227       break;
1228
1229     case TYPE_CODE_NAMESPACE:
1230       fputs_filtered ("namespace ", stream);
1231       fputs_filtered (TYPE_TAG_NAME (type), stream);
1232       break;
1233
1234     default:
1235       /* Handle types not explicitly handled by the other cases, such
1236          as fundamental types.  For these, just print whatever the
1237          type name is, as recorded in the type itself.  If there is no
1238          type name, then complain.  */
1239       if (TYPE_NAME (type) != NULL)
1240         {
1241           c_type_print_modifier (type, stream, 0, 1);
1242           fputs_filtered (TYPE_NAME (type), stream);
1243         }
1244       else
1245         {
1246           /* At least for dump_symtab, it is important that this not
1247              be an error ().  */
1248           fprintf_filtered (stream, _("<invalid type code %d>"),
1249                             TYPE_CODE (type));
1250         }
1251       break;
1252     }
1253 }