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.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
24 #include "bfd.h" /* Binary File Description */
27 #include "expression.h"
36 #include "typeprint.h"
38 #include "gdb_string.h"
42 /* Flag indicating target was compiled by HP compiler */
43 extern int hp_som_som_object_present
;
45 static void cp_type_print_method_args
PARAMS ((struct type
** args
, char *prefix
, char *varstring
, int staticp
, GDB_FILE
* stream
));
48 c_type_print_args
PARAMS ((struct type
*, GDB_FILE
*));
51 cp_type_print_derivation_info
PARAMS ((GDB_FILE
*, struct type
*));
54 c_type_print_varspec_prefix
PARAMS ((struct type
*, GDB_FILE
*, int, int));
57 c_type_print_cv_qualifier
PARAMS ((struct type
*, GDB_FILE
*, int, int));
61 /* Print a description of a type in the format of a
62 typedef for the current language.
63 NEW is the new name for a type TYPE. */
66 c_typedef_print (type
, new, stream
)
72 switch (current_language
->la_language
)
77 fprintf_filtered (stream
, "typedef ");
78 type_print (type
, "", stream
, 0);
79 if (TYPE_NAME ((SYMBOL_TYPE (new))) == 0
80 || !STREQ (TYPE_NAME ((SYMBOL_TYPE (new))), SYMBOL_NAME (new)))
81 fprintf_filtered (stream
, " %s", SYMBOL_SOURCE_NAME (new));
86 fprintf_filtered (stream
, "TYPE ");
87 if (!TYPE_NAME (SYMBOL_TYPE (new)) ||
88 !STREQ (TYPE_NAME (SYMBOL_TYPE (new)), SYMBOL_NAME (new)))
89 fprintf_filtered (stream
, "%s = ", SYMBOL_SOURCE_NAME (new));
91 fprintf_filtered (stream
, "<builtin> = ");
92 type_print (type
, "", stream
, 0);
97 fprintf_filtered (stream
, "SYNMODE ");
98 if (!TYPE_NAME (SYMBOL_TYPE (new)) ||
99 !STREQ (TYPE_NAME (SYMBOL_TYPE (new)), SYMBOL_NAME (new)))
100 fprintf_filtered (stream
, "%s = ", SYMBOL_SOURCE_NAME (new));
102 fprintf_filtered (stream
, "<builtin> = ");
103 type_print (type
, "", stream
, 0);
107 error ("Language not supported.");
109 fprintf_filtered (stream
, ";\n");
113 /* LEVEL is the depth to indent lines by. */
116 c_print_type (type
, varstring
, stream
, show
, level
)
123 register enum type_code code
;
127 CHECK_TYPEDEF (type
);
129 c_type_print_base (type
, stream
, show
, level
);
130 code
= TYPE_CODE (type
);
131 if ((varstring
!= NULL
&& *varstring
!= '\0')
133 /* Need a space if going to print stars or brackets;
134 but not if we will print just a type name. */
135 ((show
> 0 || TYPE_NAME (type
) == 0)
137 (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
138 || code
== TYPE_CODE_METHOD
139 || code
== TYPE_CODE_ARRAY
140 || code
== TYPE_CODE_MEMBER
141 || code
== TYPE_CODE_REF
)))
142 fputs_filtered (" ", stream
);
143 c_type_print_varspec_prefix (type
, stream
, show
, 0);
145 if (varstring
!= NULL
)
147 fputs_filtered (varstring
, stream
);
149 /* For demangled function names, we have the arglist as part of the name,
150 so don't print an additional pair of ()'s */
152 demangled_args
= strchr (varstring
, '(') != NULL
;
153 c_type_print_varspec_suffix (type
, stream
, show
, 0, demangled_args
);
157 /* If TYPE is a derived type, then print out derivation information.
158 Print only the actual base classes of this type, not the base classes
159 of the base classes. I.E. for the derivation hierarchy:
162 class B : public A {int b; };
163 class C : public B {int c; };
165 Print the type of class C as:
171 Not as the following (like gdb used to), which is not legal C++ syntax for
172 derived types and may be confused with the multiple inheritance form:
174 class C : public B : public A {
178 In general, gdb should try to print the types as closely as possible to
179 the form that they appear in the source code.
180 Note that in case of protected derivation gcc will not say 'protected'
181 but 'private'. The HP's aCC compiler emits specific information for
182 derivation via protected inheritance, so gdb can print it out */
185 cp_type_print_derivation_info (stream
, type
)
192 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
194 fputs_filtered (i
== 0 ? ": " : ", ", stream
);
195 fprintf_filtered (stream
, "%s%s ",
196 BASETYPE_VIA_PUBLIC (type
, i
) ? "public"
197 : (TYPE_FIELD_PROTECTED (type
, i
) ? "protected" : "private"),
198 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
199 name
= type_name_no_tag (TYPE_BASECLASS (type
, i
));
200 fprintf_filtered (stream
, "%s", name
? name
: "(null)");
204 fputs_filtered (" ", stream
);
207 /* Print the C++ method arguments ARGS to the file STREAM. */
210 cp_type_print_method_args (args
, prefix
, varstring
, staticp
, stream
)
219 fprintf_symbol_filtered (stream
, prefix
, language_cplus
, DMGL_ANSI
);
220 fprintf_symbol_filtered (stream
, varstring
, language_cplus
, DMGL_ANSI
);
221 fputs_filtered ("(", stream
);
222 if (args
&& args
[!staticp
] && args
[!staticp
]->code
!= TYPE_CODE_VOID
)
224 i
= !staticp
; /* skip the class variable */
227 type_print (args
[i
++], "", stream
, 0);
230 fprintf_filtered (stream
, " ...");
233 else if (args
[i
]->code
!= TYPE_CODE_VOID
)
235 fprintf_filtered (stream
, ", ");
241 else if (current_language
->la_language
== language_cplus
)
243 fprintf_filtered (stream
, "void");
246 fprintf_filtered (stream
, ")");
250 /* Print any asterisks or open-parentheses needed before the
251 variable name (to describe its type).
253 On outermost call, pass 0 for PASSED_A_PTR.
254 On outermost call, SHOW > 0 means should ignore
255 any typename for TYPE and show its details.
256 SHOW is always zero on recursive calls. */
259 c_type_print_varspec_prefix (type
, stream
, show
, passed_a_ptr
)
269 if (TYPE_NAME (type
) && show
<= 0)
274 switch (TYPE_CODE (type
))
277 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 1);
278 fprintf_filtered (stream
, "*");
279 c_type_print_cv_qualifier (type
, stream
, 1, 0);
282 case TYPE_CODE_MEMBER
:
284 fprintf_filtered (stream
, "(");
285 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 0);
286 fprintf_filtered (stream
, " ");
287 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
289 fputs_filtered (name
, stream
);
291 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
292 fprintf_filtered (stream
, "::");
295 case TYPE_CODE_METHOD
:
297 fprintf_filtered (stream
, "(");
298 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 0);
301 fprintf_filtered (stream
, " ");
302 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
303 fprintf_filtered (stream
, "::");
308 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 1);
309 fprintf_filtered (stream
, "&");
310 c_type_print_cv_qualifier (type
, stream
, 1, 0);
314 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 0);
316 fprintf_filtered (stream
, "(");
319 case TYPE_CODE_ARRAY
:
320 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 0);
322 fprintf_filtered (stream
, "(");
325 case TYPE_CODE_UNDEF
:
326 case TYPE_CODE_STRUCT
:
327 case TYPE_CODE_UNION
:
332 case TYPE_CODE_ERROR
:
336 case TYPE_CODE_RANGE
:
337 case TYPE_CODE_STRING
:
338 case TYPE_CODE_BITSTRING
:
339 case TYPE_CODE_COMPLEX
:
340 case TYPE_CODE_TYPEDEF
:
341 case TYPE_CODE_TEMPLATE
:
342 /* These types need no prefix. They are listed here so that
343 gcc -Wall will reveal any types that haven't been handled. */
346 error ("type not handled in c_type_print_varspec_prefix()");
351 /* Print out "const" and "volatile" attributes.
352 TYPE is a pointer to the type being printed out.
353 STREAM is the output destination.
354 NEED_SPACE = 1 indicates an initial white space is needed */
357 c_type_print_cv_qualifier (type
, stream
, need_pre_space
, need_post_space
)
365 if (TYPE_CONST (type
))
368 fprintf_filtered (stream
, " ");
369 fprintf_filtered (stream
, "const");
373 if (TYPE_VOLATILE (type
))
375 if (flag
|| need_pre_space
)
376 fprintf_filtered (stream
, " ");
377 fprintf_filtered (stream
, "volatile");
381 if (flag
&& need_post_space
)
382 fprintf_filtered (stream
, " ");
389 c_type_print_args (type
, stream
)
396 fprintf_filtered (stream
, "(");
397 args
= TYPE_ARG_TYPES (type
);
402 fprintf_filtered (stream
, "...");
404 else if ((args
[1]->code
== TYPE_CODE_VOID
) &&
405 (current_language
->la_language
== language_cplus
))
407 fprintf_filtered (stream
, "void");
412 args
[i
] != NULL
&& args
[i
]->code
!= TYPE_CODE_VOID
;
415 c_print_type (args
[i
], "", stream
, -1, 0);
416 if (args
[i
+ 1] == NULL
)
418 fprintf_filtered (stream
, "...");
420 else if (args
[i
+ 1]->code
!= TYPE_CODE_VOID
)
422 fprintf_filtered (stream
, ",");
428 else if (current_language
->la_language
== language_cplus
)
430 fprintf_filtered (stream
, "void");
433 fprintf_filtered (stream
, ")");
436 /* Print any array sizes, function arguments or close parentheses
437 needed after the variable name (to describe its type).
438 Args work like c_type_print_varspec_prefix. */
441 c_type_print_varspec_suffix (type
, stream
, show
, passed_a_ptr
, demangled_args
)
451 if (TYPE_NAME (type
) && show
<= 0)
456 switch (TYPE_CODE (type
))
458 case TYPE_CODE_ARRAY
:
460 fprintf_filtered (stream
, ")");
462 fprintf_filtered (stream
, "[");
463 if (TYPE_LENGTH (type
) >= 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0
464 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
465 fprintf_filtered (stream
, "%d",
467 / TYPE_LENGTH (TYPE_TARGET_TYPE (type
))));
468 fprintf_filtered (stream
, "]");
470 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 0, 0);
473 case TYPE_CODE_MEMBER
:
475 fprintf_filtered (stream
, ")");
476 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 0, 0);
479 case TYPE_CODE_METHOD
:
481 fprintf_filtered (stream
, ")");
482 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 0, 0);
485 c_type_print_args (type
, stream
);
491 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 1, 0);
496 fprintf_filtered (stream
, ")");
499 int i
, len
= TYPE_NFIELDS (type
);
500 fprintf_filtered (stream
, "(");
501 if ((len
== 0) && (current_language
->la_language
== language_cplus
))
503 fprintf_filtered (stream
, "void");
506 for (i
= 0; i
< len
; i
++)
510 fputs_filtered (", ", stream
);
513 c_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
515 fprintf_filtered (stream
, ")");
517 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0,
521 case TYPE_CODE_UNDEF
:
522 case TYPE_CODE_STRUCT
:
523 case TYPE_CODE_UNION
:
528 case TYPE_CODE_ERROR
:
532 case TYPE_CODE_RANGE
:
533 case TYPE_CODE_STRING
:
534 case TYPE_CODE_BITSTRING
:
535 case TYPE_CODE_COMPLEX
:
536 case TYPE_CODE_TYPEDEF
:
537 case TYPE_CODE_TEMPLATE
:
538 /* These types do not need a suffix. They are listed so that
539 gcc -Wall will report types that may not have been considered. */
542 error ("type not handled in c_type_print_varspec_suffix()");
547 /* Print the name of the type (or the ultimate pointer target,
548 function value or array element), or the description of a
551 SHOW positive means print details about the type (e.g. enum values),
552 and print structure elements passing SHOW - 1 for show.
553 SHOW negative means just print the type name or struct tag if there is one.
554 If there is no name, print something sensible but concise like
556 SHOW zero means just print the type name or struct tag if there is one.
557 If there is no name, print something sensible but not as concise like
558 "struct {int x; int y;}".
560 LEVEL is the number of spaces to indent by.
561 We increase it for some recursive calls. */
564 c_type_print_base (type
, stream
, show
, level
)
572 register int lastval
;
574 char *demangled_name
;
575 char *demangled_no_static
;
578 s_none
, s_public
, s_private
, s_protected
581 int need_access_label
= 0;
589 fputs_filtered ("<type unknown>", stream
);
593 /* When SHOW is zero or less, and there is a valid type name, then always
594 just print the type name directly from the type. */
595 /* If we have "typedef struct foo {. . .} bar;" do we want to print it
596 as "struct foo" or as "bar"? Pick the latter, because C++ folk tend
597 to expect things like "class5 *foo" rather than "struct class5 *foo". */
600 && TYPE_NAME (type
) != NULL
)
602 c_type_print_cv_qualifier (type
, stream
, 0, 1);
603 fputs_filtered (TYPE_NAME (type
), stream
);
607 CHECK_TYPEDEF (type
);
609 switch (TYPE_CODE (type
))
611 case TYPE_CODE_TYPEDEF
:
612 case TYPE_CODE_ARRAY
:
614 case TYPE_CODE_MEMBER
:
617 case TYPE_CODE_METHOD
:
618 c_type_print_base (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
621 case TYPE_CODE_STRUCT
:
622 c_type_print_cv_qualifier (type
, stream
, 0, 1);
623 /* Note TYPE_CODE_STRUCT and TYPE_CODE_CLASS have the same value,
624 * so we use another means for distinguishing them.
626 if (HAVE_CPLUS_STRUCT (type
))
628 switch (TYPE_DECLARED_TYPE (type
))
630 case DECLARED_TYPE_CLASS
:
631 fprintf_filtered (stream
, "class ");
633 case DECLARED_TYPE_UNION
:
634 fprintf_filtered (stream
, "union ");
636 case DECLARED_TYPE_STRUCT
:
637 fprintf_filtered (stream
, "struct ");
640 /* If there is a CPLUS_STRUCT, assume class if not
641 * otherwise specified in the declared_type field.
643 fprintf_filtered (stream
, "class ");
649 /* If not CPLUS_STRUCT, then assume it's a C struct */
650 fprintf_filtered (stream
, "struct ");
654 case TYPE_CODE_UNION
:
655 c_type_print_cv_qualifier (type
, stream
, 0, 1);
656 fprintf_filtered (stream
, "union ");
660 /* Print the tag if it exists.
661 * The HP aCC compiler emits
662 * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
663 * tag for unnamed struct/union/enum's, which we don't
666 if (TYPE_TAG_NAME (type
) != NULL
&&
667 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
669 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
671 fputs_filtered (" ", stream
);
676 /* If we just printed a tag name, no need to print anything else. */
677 if (TYPE_TAG_NAME (type
) == NULL
)
678 fprintf_filtered (stream
, "{...}");
680 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
682 cp_type_print_derivation_info (stream
, type
);
684 fprintf_filtered (stream
, "{\n");
685 if ((TYPE_NFIELDS (type
) == 0) && (TYPE_NFN_FIELDS (type
) == 0))
687 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
688 fprintfi_filtered (level
+ 4, stream
, "<incomplete type>\n");
690 fprintfi_filtered (level
+ 4, stream
, "<no data fields>\n");
693 /* Start off with no specific section type, so we can print
694 one for the first field we find, and use that section type
695 thereafter until we find another type. */
697 section_type
= s_none
;
699 /* For a class, if all members are private, there's no need
700 for a "private:" label; similarly, for a struct or union
701 masquerading as a class, if all members are public, there's
702 no need for a "public:" label. */
704 if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_CLASS
) ||
705 (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_TEMPLATE
))
708 len
= TYPE_NFIELDS (type
);
709 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
710 if (!TYPE_FIELD_PRIVATE (type
, i
))
712 need_access_label
= 1;
716 if (!need_access_label
)
718 len2
= TYPE_NFN_FIELDS (type
);
719 for (j
= 0; j
< len2
; j
++)
721 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
722 for (i
= 0; i
< len
; i
++)
723 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
))
725 need_access_label
= 1;
728 if (need_access_label
)
733 else if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_STRUCT
) ||
734 (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_UNION
))
737 len
= TYPE_NFIELDS (type
);
738 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
739 if (TYPE_FIELD_PRIVATE (type
, i
) || TYPE_FIELD_PROTECTED (type
, i
))
741 need_access_label
= 1;
745 if (!need_access_label
)
747 len2
= TYPE_NFN_FIELDS (type
);
748 for (j
= 0; j
< len2
; j
++)
751 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
752 for (i
= 0; i
< len
; i
++)
753 if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
) ||
754 TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
, j
), i
))
756 need_access_label
= 1;
759 if (need_access_label
)
765 /* If there is a base class for this type,
766 do not print the field that it occupies. */
768 len
= TYPE_NFIELDS (type
);
769 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
772 /* Don't print out virtual function table. */
773 /* HP ANSI C++ case */
774 if (TYPE_HAS_VTABLE (type
) && (STREQN (TYPE_FIELD_NAME (type
, i
), "__vfp", 5)))
776 /* Other compilers */
777 if (STREQN (TYPE_FIELD_NAME (type
, i
), "_vptr", 5)
778 && is_cplus_marker ((TYPE_FIELD_NAME (type
, i
))[5]))
781 /* If this is a C++ class we can print the various C++ section
784 if (HAVE_CPLUS_STRUCT (type
) && need_access_label
)
786 if (TYPE_FIELD_PROTECTED (type
, i
))
788 if (section_type
!= s_protected
)
790 section_type
= s_protected
;
791 fprintfi_filtered (level
+ 2, stream
,
795 else if (TYPE_FIELD_PRIVATE (type
, i
))
797 if (section_type
!= s_private
)
799 section_type
= s_private
;
800 fprintfi_filtered (level
+ 2, stream
, "private:\n");
805 if (section_type
!= s_public
)
807 section_type
= s_public
;
808 fprintfi_filtered (level
+ 2, stream
, "public:\n");
813 print_spaces_filtered (level
+ 4, stream
);
814 if (TYPE_FIELD_STATIC (type
, i
))
816 fprintf_filtered (stream
, "static ");
818 c_print_type (TYPE_FIELD_TYPE (type
, i
),
819 TYPE_FIELD_NAME (type
, i
),
820 stream
, show
- 1, level
+ 4);
821 if (!TYPE_FIELD_STATIC (type
, i
)
822 && TYPE_FIELD_PACKED (type
, i
))
824 /* It is a bitfield. This code does not attempt
825 to look at the bitpos and reconstruct filler,
826 unnamed fields. This would lead to misleading
827 results if the compiler does not put out fields
828 for such things (I don't know what it does). */
829 fprintf_filtered (stream
, " : %d",
830 TYPE_FIELD_BITSIZE (type
, i
));
832 fprintf_filtered (stream
, ";\n");
835 /* If there are both fields and methods, put a space between. */
836 len
= TYPE_NFN_FIELDS (type
);
837 if (len
&& section_type
!= s_none
)
838 fprintf_filtered (stream
, "\n");
840 /* C++: print out the methods */
841 for (i
= 0; i
< len
; i
++)
843 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
844 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
845 char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
846 char *name
= type_name_no_tag (type
);
847 int is_constructor
= name
&& STREQ (method_name
, name
);
848 for (j
= 0; j
< len2
; j
++)
850 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
851 int is_full_physname_constructor
=
852 ((physname
[0] == '_' && physname
[1] == '_'
853 && strchr ("0123456789Qt", physname
[2]))
854 || STREQN (physname
, "__ct__", 6)
855 || DESTRUCTOR_PREFIX_P (physname
)
856 || STREQN (physname
, "__dt__", 6));
859 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
861 if (section_type
!= s_protected
)
863 section_type
= s_protected
;
864 fprintfi_filtered (level
+ 2, stream
,
868 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
870 if (section_type
!= s_private
)
872 section_type
= s_private
;
873 fprintfi_filtered (level
+ 2, stream
, "private:\n");
878 if (section_type
!= s_public
)
880 section_type
= s_public
;
881 fprintfi_filtered (level
+ 2, stream
, "public:\n");
885 print_spaces_filtered (level
+ 4, stream
);
886 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
887 fprintf_filtered (stream
, "virtual ");
888 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
889 fprintf_filtered (stream
, "static ");
890 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
892 /* Keep GDB from crashing here. */
893 fprintf_filtered (stream
, "<undefined type> %s;\n",
894 TYPE_FN_FIELD_PHYSNAME (f
, j
));
897 else if (!is_constructor
&& /* constructors don't have declared types */
898 !is_full_physname_constructor
&& /* " " */
899 !strstr (method_name
, "operator ")) /* Not a type conversion operator */
900 /* (note space -- other operators don't have it) */
902 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
904 fputs_filtered (" ", stream
);
906 if (TYPE_FN_FIELD_STUB (f
, j
))
907 /* Build something we can demangle. */
908 mangled_name
= gdb_mangle_name (type
, i
, j
);
910 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
913 cplus_demangle (mangled_name
,
914 DMGL_ANSI
| DMGL_PARAMS
);
915 if (demangled_name
== NULL
)
917 /* in some cases (for instance with the HP demangling),
918 if a function has more than 10 arguments,
919 the demangling will fail.
920 Let's try to reconstruct the function signature from
921 the symbol information */
922 if (!TYPE_FN_FIELD_STUB (f
, j
))
923 cp_type_print_method_args (TYPE_FN_FIELD_ARGS (f
, j
), "",
925 TYPE_FN_FIELD_STATIC_P (f
, j
),
928 fprintf_filtered (stream
, "<badly mangled name '%s'>",
934 char *demangled_no_class
= strrchr (demangled_name
, ':');
936 if (demangled_no_class
== NULL
)
937 demangled_no_class
= demangled_name
;
940 ++demangled_no_class
; /* skip over last ':' */
942 /* get rid of the static word appended by the demangler */
943 p
= strstr (demangled_no_class
, " static");
946 int length
= p
- demangled_no_class
;
947 demangled_no_static
= (char *) xmalloc (length
+ 1);
948 strncpy (demangled_no_static
, demangled_no_class
, length
);
949 *(demangled_no_static
+ length
) = '\0';
950 fputs_filtered (demangled_no_static
, stream
);
951 free (demangled_no_static
);
954 fputs_filtered (demangled_no_class
, stream
);
955 free (demangled_name
);
958 if (TYPE_FN_FIELD_STUB (f
, j
))
961 fprintf_filtered (stream
, ";\n");
965 fprintfi_filtered (level
, stream
, "}");
967 if (TYPE_LOCALTYPE_PTR (type
) && show
>= 0)
968 fprintfi_filtered (level
, stream
, " (Local at %s:%d)\n",
969 TYPE_LOCALTYPE_FILE (type
),
970 TYPE_LOCALTYPE_LINE (type
));
972 if (TYPE_CODE (type
) == TYPE_CODE_TEMPLATE
)
977 c_type_print_cv_qualifier (type
, stream
, 0, 1);
978 /* HP C supports sized enums */
979 if (hp_som_som_object_present
)
980 switch (TYPE_LENGTH (type
))
983 fputs_filtered ("char ", stream
);
986 fputs_filtered ("short ", stream
);
991 fprintf_filtered (stream
, "enum ");
992 /* Print the tag name if it exists.
993 The aCC compiler emits a spurious
994 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
995 tag for unnamed struct/union/enum's, which we don't
997 if (TYPE_TAG_NAME (type
) != NULL
&&
998 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
1000 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1002 fputs_filtered (" ", stream
);
1008 /* If we just printed a tag name, no need to print anything else. */
1009 if (TYPE_TAG_NAME (type
) == NULL
)
1010 fprintf_filtered (stream
, "{...}");
1012 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1014 fprintf_filtered (stream
, "{");
1015 len
= TYPE_NFIELDS (type
);
1017 for (i
= 0; i
< len
; i
++)
1021 fprintf_filtered (stream
, ", ");
1023 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1024 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
1026 fprintf_filtered (stream
, " = %d", TYPE_FIELD_BITPOS (type
, i
));
1027 lastval
= TYPE_FIELD_BITPOS (type
, i
);
1031 fprintf_filtered (stream
, "}");
1035 case TYPE_CODE_VOID
:
1036 fprintf_filtered (stream
, "void");
1039 case TYPE_CODE_UNDEF
:
1040 fprintf_filtered (stream
, "struct <unknown>");
1043 case TYPE_CODE_ERROR
:
1044 fprintf_filtered (stream
, "<unknown type>");
1047 case TYPE_CODE_RANGE
:
1048 /* This should not occur */
1049 fprintf_filtered (stream
, "<range type>");
1052 case TYPE_CODE_TEMPLATE
:
1053 /* Called on "ptype t" where "t" is a template.
1054 Prints the template header (with args), e.g.:
1055 template <class T1, class T2> class "
1056 and then merges with the struct/union/class code to
1057 print the rest of the definition. */
1058 c_type_print_cv_qualifier (type
, stream
, 0, 1);
1059 fprintf_filtered (stream
, "template <");
1060 for (i
= 0; i
< TYPE_NTEMPLATE_ARGS (type
); i
++)
1062 struct template_arg templ_arg
;
1063 templ_arg
= TYPE_TEMPLATE_ARG (type
, i
);
1064 fprintf_filtered (stream
, "class %s", templ_arg
.name
);
1065 if (i
< TYPE_NTEMPLATE_ARGS (type
) - 1)
1066 fprintf_filtered (stream
, ", ");
1068 fprintf_filtered (stream
, "> class ");
1069 /* Yuck, factor this out to a subroutine so we can call
1070 it and return to the point marked with the "goback:" label... - RT */
1073 if (TYPE_NINSTANTIATIONS (type
) > 0)
1075 fprintf_filtered (stream
, "\ntemplate instantiations:\n");
1076 for (i
= 0; i
< TYPE_NINSTANTIATIONS (type
); i
++)
1078 fprintf_filtered (stream
, " ");
1079 c_type_print_base (TYPE_INSTANTIATION (type
, i
), stream
, 0, level
);
1080 if (i
< TYPE_NINSTANTIATIONS (type
) - 1)
1081 fprintf_filtered (stream
, "\n");
1087 /* Handle types not explicitly handled by the other cases,
1088 such as fundamental types. For these, just print whatever
1089 the type name is, as recorded in the type itself. If there
1090 is no type name, then complain. */
1091 if (TYPE_NAME (type
) != NULL
)
1093 c_type_print_cv_qualifier (type
, stream
, 0, 1);
1094 fputs_filtered (TYPE_NAME (type
), stream
);
1098 /* At least for dump_symtab, it is important that this not be
1100 fprintf_filtered (stream
, "<invalid type code %d>",