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