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