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