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