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