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 /* These types need no prefix. They are listed here so that
342 gcc -Wall will reveal any types that haven't been handled. */
347 /* Print out "const" and "volatile" attributes.
348 TYPE is a pointer to the type being printed out.
349 STREAM is the output destination.
350 NEED_SPACE = 1 indicates an initial white space is needed */
353 c_type_print_cv_qualifier (type
, stream
, need_pre_space
, need_post_space
)
361 if (TYPE_CONST (type
))
364 fprintf_filtered (stream
, " ");
365 fprintf_filtered (stream
, "const");
369 if (TYPE_VOLATILE (type
))
371 if (flag
|| need_pre_space
)
372 fprintf_filtered (stream
, " ");
373 fprintf_filtered (stream
, "volatile");
377 if (flag
&& need_post_space
)
378 fprintf_filtered (stream
, " ");
385 c_type_print_args (type
, stream
)
392 fprintf_filtered (stream
, "(");
393 args
= TYPE_ARG_TYPES (type
);
398 fprintf_filtered (stream
, "...");
400 else if ((args
[1]->code
== TYPE_CODE_VOID
) &&
401 (current_language
->la_language
== language_cplus
))
403 fprintf_filtered (stream
, "void");
408 args
[i
] != NULL
&& args
[i
]->code
!= TYPE_CODE_VOID
;
411 c_print_type (args
[i
], "", stream
, -1, 0);
412 if (args
[i
+ 1] == NULL
)
414 fprintf_filtered (stream
, "...");
416 else if (args
[i
+ 1]->code
!= TYPE_CODE_VOID
)
418 fprintf_filtered (stream
, ",");
424 else if (current_language
->la_language
== language_cplus
)
426 fprintf_filtered (stream
, "void");
429 fprintf_filtered (stream
, ")");
432 /* Print any array sizes, function arguments or close parentheses
433 needed after the variable name (to describe its type).
434 Args work like c_type_print_varspec_prefix. */
437 c_type_print_varspec_suffix (type
, stream
, show
, passed_a_ptr
, demangled_args
)
447 if (TYPE_NAME (type
) && show
<= 0)
452 switch (TYPE_CODE (type
))
454 case TYPE_CODE_ARRAY
:
456 fprintf_filtered (stream
, ")");
458 fprintf_filtered (stream
, "[");
459 if (TYPE_LENGTH (type
) >= 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0
460 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
461 fprintf_filtered (stream
, "%d",
463 / TYPE_LENGTH (TYPE_TARGET_TYPE (type
))));
464 fprintf_filtered (stream
, "]");
466 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 0, 0);
469 case TYPE_CODE_MEMBER
:
471 fprintf_filtered (stream
, ")");
472 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 0, 0);
475 case TYPE_CODE_METHOD
:
477 fprintf_filtered (stream
, ")");
478 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 0, 0);
481 c_type_print_args (type
, stream
);
487 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 1, 0);
492 fprintf_filtered (stream
, ")");
495 int i
, len
= TYPE_NFIELDS (type
);
496 fprintf_filtered (stream
, "(");
497 if ((len
== 0) && (current_language
->la_language
== language_cplus
))
499 fprintf_filtered (stream
, "void");
502 for (i
= 0; i
< len
; i
++)
506 fputs_filtered (", ", stream
);
509 c_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
511 fprintf_filtered (stream
, ")");
513 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0,
517 case TYPE_CODE_UNDEF
:
518 case TYPE_CODE_STRUCT
:
519 case TYPE_CODE_UNION
:
524 case TYPE_CODE_ERROR
:
528 case TYPE_CODE_RANGE
:
529 case TYPE_CODE_STRING
:
530 case TYPE_CODE_BITSTRING
:
531 case TYPE_CODE_COMPLEX
:
532 case TYPE_CODE_TYPEDEF
:
533 /* These types do not need a suffix. They are listed so that
534 gcc -Wall will report types that may not have been considered. */
539 /* Print the name of the type (or the ultimate pointer target,
540 function value or array element), or the description of a
543 SHOW positive means print details about the type (e.g. enum values),
544 and print structure elements passing SHOW - 1 for show.
545 SHOW negative means just print the type name or struct tag if there is one.
546 If there is no name, print something sensible but concise like
548 SHOW zero means just print the type name or struct tag if there is one.
549 If there is no name, print something sensible but not as concise like
550 "struct {int x; int y;}".
552 LEVEL is the number of spaces to indent by.
553 We increase it for some recursive calls. */
556 c_type_print_base (type
, stream
, show
, level
)
564 register int lastval
;
566 char *demangled_name
;
567 char *demangled_no_static
;
570 s_none
, s_public
, s_private
, s_protected
573 int need_access_label
= 0;
581 fputs_filtered ("<type unknown>", stream
);
585 /* When SHOW is zero or less, and there is a valid type name, then always
586 just print the type name directly from the type. */
587 /* If we have "typedef struct foo {. . .} bar;" do we want to print it
588 as "struct foo" or as "bar"? Pick the latter, because C++ folk tend
589 to expect things like "class5 *foo" rather than "struct class5 *foo". */
592 && TYPE_NAME (type
) != NULL
)
594 c_type_print_cv_qualifier (type
, stream
, 0, 1);
595 fputs_filtered (TYPE_NAME (type
), stream
);
599 CHECK_TYPEDEF (type
);
601 switch (TYPE_CODE (type
))
603 case TYPE_CODE_TYPEDEF
:
604 case TYPE_CODE_ARRAY
:
606 case TYPE_CODE_MEMBER
:
609 case TYPE_CODE_METHOD
:
610 c_type_print_base (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
613 case TYPE_CODE_STRUCT
:
614 c_type_print_cv_qualifier (type
, stream
, 0, 1);
615 /* Note TYPE_CODE_STRUCT and TYPE_CODE_CLASS have the same value,
616 * so we use another means for distinguishing them.
618 if (HAVE_CPLUS_STRUCT (type
))
620 switch (TYPE_DECLARED_TYPE (type
))
622 case DECLARED_TYPE_CLASS
:
623 fprintf_filtered (stream
, "class ");
625 case DECLARED_TYPE_UNION
:
626 fprintf_filtered (stream
, "union ");
628 case DECLARED_TYPE_STRUCT
:
629 fprintf_filtered (stream
, "struct ");
632 /* If there is a CPLUS_STRUCT, assume class if not
633 * otherwise specified in the declared_type field.
635 fprintf_filtered (stream
, "class ");
641 /* If not CPLUS_STRUCT, then assume it's a C struct */
642 fprintf_filtered (stream
, "struct ");
646 case TYPE_CODE_UNION
:
647 c_type_print_cv_qualifier (type
, stream
, 0, 1);
648 fprintf_filtered (stream
, "union ");
652 /* Print the tag if it exists.
653 * The HP aCC compiler emits
654 * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
655 * tag for unnamed struct/union/enum's, which we don't
658 if (TYPE_TAG_NAME (type
) != NULL
&&
659 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
661 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
663 fputs_filtered (" ", stream
);
668 /* If we just printed a tag name, no need to print anything else. */
669 if (TYPE_TAG_NAME (type
) == NULL
)
670 fprintf_filtered (stream
, "{...}");
672 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
674 cp_type_print_derivation_info (stream
, type
);
676 fprintf_filtered (stream
, "{\n");
677 if ((TYPE_NFIELDS (type
) == 0) && (TYPE_NFN_FIELDS (type
) == 0))
679 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
680 fprintfi_filtered (level
+ 4, stream
, "<incomplete type>\n");
682 fprintfi_filtered (level
+ 4, stream
, "<no data fields>\n");
685 /* Start off with no specific section type, so we can print
686 one for the first field we find, and use that section type
687 thereafter until we find another type. */
689 section_type
= s_none
;
691 /* For a class, if all members are private, there's no need
692 for a "private:" label; similarly, for a struct or union
693 masquerading as a class, if all members are public, there's
694 no need for a "public:" label. */
696 if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_CLASS
) ||
697 (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_TEMPLATE
))
700 len
= TYPE_NFIELDS (type
);
701 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
702 if (!TYPE_FIELD_PRIVATE (type
, i
))
704 need_access_label
= 1;
708 if (!need_access_label
)
710 len2
= TYPE_NFN_FIELDS (type
);
711 for (j
= 0; j
< len2
; j
++)
713 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
714 for (i
= 0; i
< len
; i
++)
715 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
))
717 need_access_label
= 1;
720 if (need_access_label
)
725 else if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_STRUCT
) ||
726 (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_UNION
))
729 len
= TYPE_NFIELDS (type
);
730 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
731 if (TYPE_FIELD_PRIVATE (type
, i
) || TYPE_FIELD_PROTECTED (type
, i
))
733 need_access_label
= 1;
737 if (!need_access_label
)
739 len2
= TYPE_NFN_FIELDS (type
);
740 for (j
= 0; j
< len2
; j
++)
743 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
744 for (i
= 0; i
< len
; i
++)
745 if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
) ||
746 TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
, j
), i
))
748 need_access_label
= 1;
751 if (need_access_label
)
757 /* If there is a base class for this type,
758 do not print the field that it occupies. */
760 len
= TYPE_NFIELDS (type
);
761 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
764 /* Don't print out virtual function table. */
765 /* HP ANSI C++ case */
766 if (TYPE_HAS_VTABLE (type
) && (STREQN (TYPE_FIELD_NAME (type
, i
), "__vfp", 5)))
768 /* Other compilers */
769 /* pai:: FIXME : check for has_vtable < 0 */
770 if (STREQN (TYPE_FIELD_NAME (type
, i
), "_vptr", 5)
771 && is_cplus_marker ((TYPE_FIELD_NAME (type
, i
))[5]))
774 /* If this is a C++ class we can print the various C++ section
777 if (HAVE_CPLUS_STRUCT (type
) && need_access_label
)
779 if (TYPE_FIELD_PROTECTED (type
, i
))
781 if (section_type
!= s_protected
)
783 section_type
= s_protected
;
784 fprintfi_filtered (level
+ 2, stream
,
788 else if (TYPE_FIELD_PRIVATE (type
, i
))
790 if (section_type
!= s_private
)
792 section_type
= s_private
;
793 fprintfi_filtered (level
+ 2, stream
, "private:\n");
798 if (section_type
!= s_public
)
800 section_type
= s_public
;
801 fprintfi_filtered (level
+ 2, stream
, "public:\n");
806 print_spaces_filtered (level
+ 4, stream
);
807 if (TYPE_FIELD_STATIC (type
, i
))
809 fprintf_filtered (stream
, "static ");
811 c_print_type (TYPE_FIELD_TYPE (type
, i
),
812 TYPE_FIELD_NAME (type
, i
),
813 stream
, show
- 1, level
+ 4);
814 if (!TYPE_FIELD_STATIC (type
, i
)
815 && TYPE_FIELD_PACKED (type
, i
))
817 /* It is a bitfield. This code does not attempt
818 to look at the bitpos and reconstruct filler,
819 unnamed fields. This would lead to misleading
820 results if the compiler does not put out fields
821 for such things (I don't know what it does). */
822 fprintf_filtered (stream
, " : %d",
823 TYPE_FIELD_BITSIZE (type
, i
));
825 fprintf_filtered (stream
, ";\n");
828 /* If there are both fields and methods, put a space between. */
829 len
= TYPE_NFN_FIELDS (type
);
830 if (len
&& section_type
!= s_none
)
831 fprintf_filtered (stream
, "\n");
833 /* C++: print out the methods */
834 for (i
= 0; i
< len
; i
++)
836 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
837 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
838 char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
839 char *name
= type_name_no_tag (type
);
840 int is_constructor
= name
&& STREQ (method_name
, name
);
841 for (j
= 0; j
< len2
; j
++)
843 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
844 int is_full_physname_constructor
=
845 ((physname
[0] == '_' && physname
[1] == '_'
846 && strchr ("0123456789Qt", physname
[2]))
847 || STREQN (physname
, "__ct__", 6)
848 || DESTRUCTOR_PREFIX_P (physname
)
849 || STREQN (physname
, "__dt__", 6));
852 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
854 if (section_type
!= s_protected
)
856 section_type
= s_protected
;
857 fprintfi_filtered (level
+ 2, stream
,
861 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
863 if (section_type
!= s_private
)
865 section_type
= s_private
;
866 fprintfi_filtered (level
+ 2, stream
, "private:\n");
871 if (section_type
!= s_public
)
873 section_type
= s_public
;
874 fprintfi_filtered (level
+ 2, stream
, "public:\n");
878 print_spaces_filtered (level
+ 4, stream
);
879 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
880 fprintf_filtered (stream
, "virtual ");
881 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
882 fprintf_filtered (stream
, "static ");
883 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
885 /* Keep GDB from crashing here. */
886 fprintf_filtered (stream
, "<undefined type> %s;\n",
887 TYPE_FN_FIELD_PHYSNAME (f
, j
));
890 else if (!is_constructor
&& /* constructors don't have declared types */
891 !is_full_physname_constructor
&& /* " " */
892 !strstr (method_name
, "operator ")) /* Not a type conversion operator */
893 /* (note space -- other operators don't have it) */
895 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
897 fputs_filtered (" ", stream
);
899 if (TYPE_FN_FIELD_STUB (f
, j
))
900 /* Build something we can demangle. */
901 mangled_name
= gdb_mangle_name (type
, i
, j
);
903 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
906 cplus_demangle (mangled_name
,
907 DMGL_ANSI
| DMGL_PARAMS
);
908 if (demangled_name
== NULL
)
910 /* in some cases (for instance with the HP demangling),
911 if a function has more than 10 arguments,
912 the demangling will fail.
913 Let's try to reconstruct the function signature from
914 the symbol information */
915 if (!TYPE_FN_FIELD_STUB (f
, j
))
916 cp_type_print_method_args (TYPE_FN_FIELD_ARGS (f
, j
), "",
918 TYPE_FN_FIELD_STATIC_P (f
, j
),
921 fprintf_filtered (stream
, "<badly mangled name '%s'>",
927 char *demangled_no_class
= demangled_name
;
929 while ((p
= strchr (demangled_no_class
, ':')))
931 demangled_no_class
= p
;
932 if (*++demangled_no_class
== ':')
933 ++demangled_no_class
;
935 /* get rid of the static word appended by the demangler */
936 p
= strstr (demangled_no_class
, " static");
939 int length
= p
- demangled_no_class
;
940 demangled_no_static
= (char *) xmalloc (length
+ 1);
941 strncpy (demangled_no_static
, demangled_no_class
, length
);
942 *(demangled_no_static
+ length
) = '\0';
943 fputs_filtered (demangled_no_static
, stream
);
944 free (demangled_no_static
);
947 fputs_filtered (demangled_no_class
, stream
);
948 free (demangled_name
);
951 if (TYPE_FN_FIELD_STUB (f
, j
))
954 fprintf_filtered (stream
, ";\n");
958 if (TYPE_LOCALTYPE_PTR (type
) && show
>= 0)
959 fprintfi_filtered (level
, stream
, " (Local at %s:%d)\n",
960 TYPE_LOCALTYPE_FILE (type
),
961 TYPE_LOCALTYPE_LINE (type
));
963 fprintfi_filtered (level
, stream
, "}");
965 if (TYPE_CODE (type
) == TYPE_CODE_TEMPLATE
)
970 c_type_print_cv_qualifier (type
, stream
, 0, 1);
971 /* HP C supports sized enums */
972 if (hp_som_som_object_present
)
973 switch (TYPE_LENGTH (type
))
976 fputs_filtered ("char ", stream
);
979 fputs_filtered ("short ", stream
);
984 fprintf_filtered (stream
, "enum ");
985 /* Print the tag name if it exists.
986 The aCC compiler emits a spurious
987 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
988 tag for unnamed struct/union/enum's, which we don't
990 if (TYPE_TAG_NAME (type
) != NULL
&&
991 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
993 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
995 fputs_filtered (" ", stream
);
1001 /* If we just printed a tag name, no need to print anything else. */
1002 if (TYPE_TAG_NAME (type
) == NULL
)
1003 fprintf_filtered (stream
, "{...}");
1005 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1007 fprintf_filtered (stream
, "{");
1008 len
= TYPE_NFIELDS (type
);
1010 for (i
= 0; i
< len
; i
++)
1014 fprintf_filtered (stream
, ", ");
1016 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1017 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
1019 fprintf_filtered (stream
, " = %d", TYPE_FIELD_BITPOS (type
, i
));
1020 lastval
= TYPE_FIELD_BITPOS (type
, i
);
1024 fprintf_filtered (stream
, "}");
1028 case TYPE_CODE_VOID
:
1029 fprintf_filtered (stream
, "void");
1032 case TYPE_CODE_UNDEF
:
1033 fprintf_filtered (stream
, "struct <unknown>");
1036 case TYPE_CODE_ERROR
:
1037 fprintf_filtered (stream
, "<unknown type>");
1040 case TYPE_CODE_RANGE
:
1041 /* This should not occur */
1042 fprintf_filtered (stream
, "<range type>");
1045 case TYPE_CODE_TEMPLATE
:
1046 /* Called on "ptype t" where "t" is a template.
1047 Prints the template header (with args), e.g.:
1048 template <class T1, class T2> class "
1049 and then merges with the struct/union/class code to
1050 print the rest of the definition. */
1051 c_type_print_cv_qualifier (type
, stream
, 0, 1);
1052 fprintf_filtered (stream
, "template <");
1053 for (i
= 0; i
< TYPE_NTEMPLATE_ARGS (type
); i
++)
1055 struct template_arg templ_arg
;
1056 templ_arg
= TYPE_TEMPLATE_ARG (type
, i
);
1057 fprintf_filtered (stream
, "class %s", templ_arg
.name
);
1058 if (i
< TYPE_NTEMPLATE_ARGS (type
) - 1)
1059 fprintf_filtered (stream
, ", ");
1061 fprintf_filtered (stream
, "> class ");
1062 /* Yuck, factor this out to a subroutine so we can call
1063 it and return to the point marked with the "goback:" label... - RT */
1066 if (TYPE_NINSTANTIATIONS (type
) > 0)
1068 fprintf_filtered (stream
, "\ntemplate instantiations:\n");
1069 for (i
= 0; i
< TYPE_NINSTANTIATIONS (type
); i
++)
1071 fprintf_filtered (stream
, " ");
1072 c_type_print_base (TYPE_INSTANTIATION (type
, i
), stream
, 0, level
);
1073 if (i
< TYPE_NINSTANTIATIONS (type
) - 1)
1074 fprintf_filtered (stream
, "\n");
1080 /* Handle types not explicitly handled by the other cases,
1081 such as fundamental types. For these, just print whatever
1082 the type name is, as recorded in the type itself. If there
1083 is no type name, then complain. */
1084 if (TYPE_NAME (type
) != NULL
)
1086 c_type_print_cv_qualifier (type
, stream
, 0, 1);
1087 fputs_filtered (TYPE_NAME (type
), stream
);
1091 /* At least for dump_symtab, it is important that this not be
1093 fprintf_filtered (stream
, "<invalid type code %d>",