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