gdb/c-typeprint.c

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