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,
4 Free Software Foundation, Inc.
6 This file is part of GDB.
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.
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.
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. */
25 #include "bfd.h" /* Binary File Description */
28 #include "expression.h"
35 #include "typeprint.h"
37 #include "gdb_string.h"
40 /* Flag indicating target was compiled by HP compiler */
41 extern int hp_som_som_object_present
;
43 static void cp_type_print_method_args (struct type
** args
, char *prefix
,
44 char *varstring
, int staticp
,
45 struct ui_file
*stream
);
47 static void c_type_print_args (struct type
*, struct ui_file
*);
49 static void cp_type_print_derivation_info (struct ui_file
*, struct type
*);
51 void c_type_print_varspec_prefix (struct type
*, struct ui_file
*, int,
54 static void c_type_print_cv_qualifier (struct type
*, struct ui_file
*,
60 /* LEVEL is the depth to indent lines by. */
63 c_print_type (struct type
*type
, char *varstring
, struct ui_file
*stream
,
66 register enum type_code code
;
72 c_type_print_base (type
, stream
, show
, level
);
73 code
= TYPE_CODE (type
);
74 if ((varstring
!= NULL
&& *varstring
!= '\0')
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)
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 c_type_print_varspec_prefix (type
, stream
, show
, 0);
88 if (varstring
!= NULL
)
90 fputs_filtered (varstring
, stream
);
92 /* For demangled function names, we have the arglist as part of the name,
93 so don't print an additional pair of ()'s */
95 demangled_args
= strchr (varstring
, '(') != NULL
;
96 c_type_print_varspec_suffix (type
, stream
, show
, 0, demangled_args
);
100 /* If TYPE is a derived type, then print out derivation information.
101 Print only the actual base classes of this type, not the base classes
102 of the base classes. I.E. for the derivation hierarchy:
105 class B : public A {int b; };
106 class C : public B {int c; };
108 Print the type of class C as:
114 Not as the following (like gdb used to), which is not legal C++ syntax for
115 derived types and may be confused with the multiple inheritance form:
117 class C : public B : public A {
121 In general, gdb should try to print the types as closely as possible to
122 the form that they appear in the source code.
123 Note that in case of protected derivation gcc will not say 'protected'
124 but 'private'. The HP's aCC compiler emits specific information for
125 derivation via protected inheritance, so gdb can print it out */
128 cp_type_print_derivation_info (struct ui_file
*stream
, struct type
*type
)
133 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
135 fputs_filtered (i
== 0 ? ": " : ", ", stream
);
136 fprintf_filtered (stream
, "%s%s ",
137 BASETYPE_VIA_PUBLIC (type
, i
) ? "public"
138 : (TYPE_FIELD_PROTECTED (type
, i
) ? "protected" : "private"),
139 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
140 name
= type_name_no_tag (TYPE_BASECLASS (type
, i
));
141 fprintf_filtered (stream
, "%s", name
? name
: "(null)");
145 fputs_filtered (" ", stream
);
148 /* Print the C++ method arguments ARGS to the file STREAM. */
151 cp_type_print_method_args (struct type
**args
, char *prefix
, char *varstring
,
152 int staticp
, struct ui_file
*stream
)
156 fprintf_symbol_filtered (stream
, prefix
, language_cplus
, DMGL_ANSI
);
157 fprintf_symbol_filtered (stream
, varstring
, language_cplus
, DMGL_ANSI
);
158 fputs_filtered ("(", stream
);
159 if (args
&& args
[!staticp
] && args
[!staticp
]->code
!= TYPE_CODE_VOID
)
161 i
= !staticp
; /* skip the class variable */
164 type_print (args
[i
++], "", stream
, 0);
167 fprintf_filtered (stream
, " ...");
170 else if (args
[i
]->code
!= TYPE_CODE_VOID
)
172 fprintf_filtered (stream
, ", ");
178 else if (current_language
->la_language
== language_cplus
)
180 fprintf_filtered (stream
, "void");
183 fprintf_filtered (stream
, ")");
187 /* Print any asterisks or open-parentheses needed before the
188 variable name (to describe its type).
190 On outermost call, pass 0 for PASSED_A_PTR.
191 On outermost call, SHOW > 0 means should ignore
192 any typename for TYPE and show its details.
193 SHOW is always zero on recursive calls. */
196 c_type_print_varspec_prefix (struct type
*type
, struct ui_file
*stream
,
197 int show
, int passed_a_ptr
)
203 if (TYPE_NAME (type
) && show
<= 0)
208 switch (TYPE_CODE (type
))
211 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 1);
212 fprintf_filtered (stream
, "*");
213 c_type_print_cv_qualifier (type
, stream
, 1, 0);
216 case TYPE_CODE_MEMBER
:
218 fprintf_filtered (stream
, "(");
219 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 0);
220 fprintf_filtered (stream
, " ");
221 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
223 fputs_filtered (name
, stream
);
225 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
226 fprintf_filtered (stream
, "::");
229 case TYPE_CODE_METHOD
:
231 fprintf_filtered (stream
, "(");
232 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 0);
235 fprintf_filtered (stream
, " ");
236 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
237 fprintf_filtered (stream
, "::");
242 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 1);
243 fprintf_filtered (stream
, "&");
244 c_type_print_cv_qualifier (type
, stream
, 1, 0);
248 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 0);
250 fprintf_filtered (stream
, "(");
253 case TYPE_CODE_ARRAY
:
254 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 0);
256 fprintf_filtered (stream
, "(");
259 case TYPE_CODE_UNDEF
:
260 case TYPE_CODE_STRUCT
:
261 case TYPE_CODE_UNION
:
266 case TYPE_CODE_ERROR
:
270 case TYPE_CODE_RANGE
:
271 case TYPE_CODE_STRING
:
272 case TYPE_CODE_BITSTRING
:
273 case TYPE_CODE_COMPLEX
:
274 case TYPE_CODE_TYPEDEF
:
275 case TYPE_CODE_TEMPLATE
:
276 /* These types need no prefix. They are listed here so that
277 gcc -Wall will reveal any types that haven't been handled. */
280 error ("type not handled in c_type_print_varspec_prefix()");
285 /* Print out "const" and "volatile" attributes.
286 TYPE is a pointer to the type being printed out.
287 STREAM is the output destination.
288 NEED_SPACE = 1 indicates an initial white space is needed */
291 c_type_print_cv_qualifier (struct type
*type
, struct ui_file
*stream
,
292 int need_pre_space
, int need_post_space
)
296 if (TYPE_CONST (type
))
299 fprintf_filtered (stream
, " ");
300 fprintf_filtered (stream
, "const");
304 if (TYPE_VOLATILE (type
))
306 if (flag
|| need_pre_space
)
307 fprintf_filtered (stream
, " ");
308 fprintf_filtered (stream
, "volatile");
312 if (flag
&& need_post_space
)
313 fprintf_filtered (stream
, " ");
320 c_type_print_args (struct type
*type
, struct ui_file
*stream
)
325 fprintf_filtered (stream
, "(");
326 args
= TYPE_ARG_TYPES (type
);
331 fprintf_filtered (stream
, "...");
333 else if ((args
[1]->code
== TYPE_CODE_VOID
) &&
334 (current_language
->la_language
== language_cplus
))
336 fprintf_filtered (stream
, "void");
341 args
[i
] != NULL
&& args
[i
]->code
!= TYPE_CODE_VOID
;
344 c_print_type (args
[i
], "", stream
, -1, 0);
345 if (args
[i
+ 1] == NULL
)
347 fprintf_filtered (stream
, "...");
349 else if (args
[i
+ 1]->code
!= TYPE_CODE_VOID
)
351 fprintf_filtered (stream
, ",");
357 else if (current_language
->la_language
== language_cplus
)
359 fprintf_filtered (stream
, "void");
362 fprintf_filtered (stream
, ")");
366 /* Return true iff the j'th overloading of the i'th method of TYPE
367 is a type conversion operator, like `operator int () { ... }'.
368 When listing a class's methods, we don't print the return type of
371 is_type_conversion_operator (struct type
*type
, int i
, int j
)
373 /* I think the whole idea of recognizing type conversion operators
374 by their name is pretty terrible. But I don't think our present
375 data structure gives us any other way to tell. If you know of
376 some other way, feel free to rewrite this function. */
377 char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
379 if (strncmp (name
, "operator", 8) != 0)
383 if (! strchr (" \t\f\n\r", *name
))
386 while (strchr (" \t\f\n\r", *name
))
389 if (strncmp (name
, "new", 3) == 0)
391 else if (strncmp (name
, "delete", 6) == 0)
396 /* Is that really the end of the name? */
397 if (('a' <= *name
&& *name
<= 'z')
398 || ('A' <= *name
&& *name
<= 'Z')
399 || ('0' <= *name
&& *name
<= '9')
401 /* No, so the identifier following "operator" must be a type name,
402 and this is a type conversion operator. */
405 /* That was indeed the end of the name, so it was `operator new' or
406 `operator delete', neither of which are type conversion operators. */
411 /* Given a C++ qualified identifier QID, strip off the qualifiers,
412 yielding the unqualified name. The return value is a pointer into
415 It's a pity we don't have this information in some more structured
416 form. Even the author of this function feels that writing little
417 parsers like this everywhere is stupid. */
419 remove_qualifiers (char *qid
)
421 int quoted
= 0; /* zero if we're not in quotes;
422 '"' if we're in a double-quoted string;
423 '\'' if we're in a single-quoted string. */
424 int depth
= 0; /* number of unclosed parens we've seen */
425 char *parenstack
= (char *) alloca (strlen (qid
));
427 char *last
= 0; /* The character after the rightmost
428 `::' token we've seen so far. */
430 for (scan
= qid
; *scan
; scan
++)
436 else if (*scan
== '\\' && *(scan
+ 1))
439 else if (scan
[0] == ':' && scan
[1] == ':')
441 /* If we're inside parenthesis (i.e., an argument list) or
442 angle brackets (i.e., a list of template arguments), then
443 we don't record the position of this :: token, since it's
444 not relevant to the top-level structure we're trying
452 else if (*scan
== '"' || *scan
== '\'')
454 else if (*scan
== '(')
455 parenstack
[depth
++] = ')';
456 else if (*scan
== '[')
457 parenstack
[depth
++] = ']';
458 /* We're going to treat <> as a pair of matching characters,
459 since we're more likely to see those in template id's than
460 real less-than characters. What a crock. */
461 else if (*scan
== '<')
462 parenstack
[depth
++] = '>';
463 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
465 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
469 /* We're going to do a little error recovery here. If we
470 don't find a match for *scan on the paren stack, but
471 there is something lower on the stack that does match, we
472 pop the stack to that point. */
475 for (i
= depth
- 1; i
>= 0; i
--)
476 if (parenstack
[i
] == *scan
)
488 /* We didn't find any :: tokens at the top level, so declare the
489 whole thing an unqualified identifier. */
494 /* Print any array sizes, function arguments or close parentheses
495 needed after the variable name (to describe its type).
496 Args work like c_type_print_varspec_prefix. */
499 c_type_print_varspec_suffix (struct type
*type
, struct ui_file
*stream
,
500 int show
, int passed_a_ptr
, int demangled_args
)
505 if (TYPE_NAME (type
) && show
<= 0)
510 switch (TYPE_CODE (type
))
512 case TYPE_CODE_ARRAY
:
514 fprintf_filtered (stream
, ")");
516 fprintf_filtered (stream
, "[");
517 if (TYPE_LENGTH (type
) >= 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0
518 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
519 fprintf_filtered (stream
, "%d",
521 / TYPE_LENGTH (TYPE_TARGET_TYPE (type
))));
522 fprintf_filtered (stream
, "]");
524 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 0, 0);
527 case TYPE_CODE_MEMBER
:
529 fprintf_filtered (stream
, ")");
530 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 0, 0);
533 case TYPE_CODE_METHOD
:
535 fprintf_filtered (stream
, ")");
536 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 0, 0);
539 c_type_print_args (type
, stream
);
545 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 1, 0);
550 fprintf_filtered (stream
, ")");
553 int i
, len
= TYPE_NFIELDS (type
);
554 fprintf_filtered (stream
, "(");
555 if ((len
== 0) && (current_language
->la_language
== language_cplus
))
557 fprintf_filtered (stream
, "void");
560 for (i
= 0; i
< len
; i
++)
564 fputs_filtered (", ", stream
);
567 c_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
569 fprintf_filtered (stream
, ")");
571 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0,
575 case TYPE_CODE_UNDEF
:
576 case TYPE_CODE_STRUCT
:
577 case TYPE_CODE_UNION
:
582 case TYPE_CODE_ERROR
:
586 case TYPE_CODE_RANGE
:
587 case TYPE_CODE_STRING
:
588 case TYPE_CODE_BITSTRING
:
589 case TYPE_CODE_COMPLEX
:
590 case TYPE_CODE_TYPEDEF
:
591 case TYPE_CODE_TEMPLATE
:
592 /* These types do not need a suffix. They are listed so that
593 gcc -Wall will report types that may not have been considered. */
596 error ("type not handled in c_type_print_varspec_suffix()");
601 /* Print the name of the type (or the ultimate pointer target,
602 function value or array element), or the description of a
605 SHOW positive means print details about the type (e.g. enum values),
606 and print structure elements passing SHOW - 1 for show.
607 SHOW negative means just print the type name or struct tag if there is one.
608 If there is no name, print something sensible but concise like
610 SHOW zero means just print the type name or struct tag if there is one.
611 If there is no name, print something sensible but not as concise like
612 "struct {int x; int y;}".
614 LEVEL is the number of spaces to indent by.
615 We increase it for some recursive calls. */
618 c_type_print_base (struct type
*type
, struct ui_file
*stream
, int show
,
623 register int lastval
;
625 char *demangled_name
;
626 char *demangled_no_static
;
629 s_none
, s_public
, s_private
, s_protected
632 int need_access_label
= 0;
640 fputs_filtered ("<type unknown>", stream
);
644 /* When SHOW is zero or less, and there is a valid type name, then always
645 just print the type name directly from the type. */
646 /* If we have "typedef struct foo {. . .} bar;" do we want to print it
647 as "struct foo" or as "bar"? Pick the latter, because C++ folk tend
648 to expect things like "class5 *foo" rather than "struct class5 *foo". */
651 && TYPE_NAME (type
) != NULL
)
653 c_type_print_cv_qualifier (type
, stream
, 0, 1);
654 fputs_filtered (TYPE_NAME (type
), stream
);
658 CHECK_TYPEDEF (type
);
660 switch (TYPE_CODE (type
))
662 case TYPE_CODE_TYPEDEF
:
663 case TYPE_CODE_ARRAY
:
665 case TYPE_CODE_MEMBER
:
668 case TYPE_CODE_METHOD
:
669 c_type_print_base (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
672 case TYPE_CODE_STRUCT
:
673 c_type_print_cv_qualifier (type
, stream
, 0, 1);
674 /* Note TYPE_CODE_STRUCT and TYPE_CODE_CLASS have the same value,
675 * so we use another means for distinguishing them.
677 if (HAVE_CPLUS_STRUCT (type
))
679 switch (TYPE_DECLARED_TYPE (type
))
681 case DECLARED_TYPE_CLASS
:
682 fprintf_filtered (stream
, "class ");
684 case DECLARED_TYPE_UNION
:
685 fprintf_filtered (stream
, "union ");
687 case DECLARED_TYPE_STRUCT
:
688 fprintf_filtered (stream
, "struct ");
691 /* If there is a CPLUS_STRUCT, assume class if not
692 * otherwise specified in the declared_type field.
694 fprintf_filtered (stream
, "class ");
700 /* If not CPLUS_STRUCT, then assume it's a C struct */
701 fprintf_filtered (stream
, "struct ");
705 case TYPE_CODE_UNION
:
706 c_type_print_cv_qualifier (type
, stream
, 0, 1);
707 fprintf_filtered (stream
, "union ");
711 /* Print the tag if it exists.
712 * The HP aCC compiler emits
713 * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
714 * tag for unnamed struct/union/enum's, which we don't
717 if (TYPE_TAG_NAME (type
) != NULL
&&
718 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
720 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
722 fputs_filtered (" ", stream
);
727 /* If we just printed a tag name, no need to print anything else. */
728 if (TYPE_TAG_NAME (type
) == NULL
)
729 fprintf_filtered (stream
, "{...}");
731 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
733 cp_type_print_derivation_info (stream
, type
);
735 fprintf_filtered (stream
, "{\n");
736 if ((TYPE_NFIELDS (type
) == 0) && (TYPE_NFN_FIELDS (type
) == 0))
738 if (TYPE_FLAGS (type
) & TYPE_FLAG_STUB
)
739 fprintfi_filtered (level
+ 4, stream
, "<incomplete type>\n");
741 fprintfi_filtered (level
+ 4, stream
, "<no data fields>\n");
744 /* Start off with no specific section type, so we can print
745 one for the first field we find, and use that section type
746 thereafter until we find another type. */
748 section_type
= s_none
;
750 /* For a class, if all members are private, there's no need
751 for a "private:" label; similarly, for a struct or union
752 masquerading as a class, if all members are public, there's
753 no need for a "public:" label. */
755 if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_CLASS
) ||
756 (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_TEMPLATE
))
759 len
= TYPE_NFIELDS (type
);
760 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
761 if (!TYPE_FIELD_PRIVATE (type
, i
))
763 need_access_label
= 1;
767 if (!need_access_label
)
769 len2
= TYPE_NFN_FIELDS (type
);
770 for (j
= 0; j
< len2
; j
++)
772 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
773 for (i
= 0; i
< len
; i
++)
774 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
))
776 need_access_label
= 1;
779 if (need_access_label
)
784 else if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_STRUCT
) ||
785 (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_UNION
))
788 len
= TYPE_NFIELDS (type
);
789 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
790 if (TYPE_FIELD_PRIVATE (type
, i
) || TYPE_FIELD_PROTECTED (type
, i
))
792 need_access_label
= 1;
796 if (!need_access_label
)
798 len2
= TYPE_NFN_FIELDS (type
);
799 for (j
= 0; j
< len2
; j
++)
802 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
803 for (i
= 0; i
< len
; i
++)
804 if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
) ||
805 TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
, j
), i
))
807 need_access_label
= 1;
810 if (need_access_label
)
816 /* If there is a base class for this type,
817 do not print the field that it occupies. */
819 len
= TYPE_NFIELDS (type
);
820 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
823 /* Don't print out virtual function table. */
824 /* HP ANSI C++ case */
825 if (TYPE_HAS_VTABLE (type
) && (STREQN (TYPE_FIELD_NAME (type
, i
), "__vfp", 5)))
827 /* Other compilers */
828 if (STREQN (TYPE_FIELD_NAME (type
, i
), "_vptr", 5)
829 && is_cplus_marker ((TYPE_FIELD_NAME (type
, i
))[5]))
832 /* If this is a C++ class we can print the various C++ section
835 if (HAVE_CPLUS_STRUCT (type
) && need_access_label
)
837 if (TYPE_FIELD_PROTECTED (type
, i
))
839 if (section_type
!= s_protected
)
841 section_type
= s_protected
;
842 fprintfi_filtered (level
+ 2, stream
,
846 else if (TYPE_FIELD_PRIVATE (type
, i
))
848 if (section_type
!= s_private
)
850 section_type
= s_private
;
851 fprintfi_filtered (level
+ 2, stream
, "private:\n");
856 if (section_type
!= s_public
)
858 section_type
= s_public
;
859 fprintfi_filtered (level
+ 2, stream
, "public:\n");
864 print_spaces_filtered (level
+ 4, stream
);
865 if (TYPE_FIELD_STATIC (type
, i
))
867 fprintf_filtered (stream
, "static ");
869 c_print_type (TYPE_FIELD_TYPE (type
, i
),
870 TYPE_FIELD_NAME (type
, i
),
871 stream
, show
- 1, level
+ 4);
872 if (!TYPE_FIELD_STATIC (type
, i
)
873 && TYPE_FIELD_PACKED (type
, i
))
875 /* It is a bitfield. This code does not attempt
876 to look at the bitpos and reconstruct filler,
877 unnamed fields. This would lead to misleading
878 results if the compiler does not put out fields
879 for such things (I don't know what it does). */
880 fprintf_filtered (stream
, " : %d",
881 TYPE_FIELD_BITSIZE (type
, i
));
883 fprintf_filtered (stream
, ";\n");
886 /* If there are both fields and methods, put a space between. */
887 len
= TYPE_NFN_FIELDS (type
);
888 if (len
&& section_type
!= s_none
)
889 fprintf_filtered (stream
, "\n");
891 /* C++: print out the methods */
892 for (i
= 0; i
< len
; i
++)
894 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
895 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
896 char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
897 char *name
= type_name_no_tag (type
);
898 int is_constructor
= name
&& STREQ (method_name
, name
);
899 for (j
= 0; j
< len2
; j
++)
901 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
902 int is_full_physname_constructor
=
903 ((physname
[0] == '_' && physname
[1] == '_'
904 && strchr ("0123456789Qt", physname
[2]))
905 || STREQN (physname
, "__ct__", 6)
906 || DESTRUCTOR_PREFIX_P (physname
)
907 || STREQN (physname
, "__dt__", 6));
910 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
912 if (section_type
!= s_protected
)
914 section_type
= s_protected
;
915 fprintfi_filtered (level
+ 2, stream
,
919 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
921 if (section_type
!= s_private
)
923 section_type
= s_private
;
924 fprintfi_filtered (level
+ 2, stream
, "private:\n");
929 if (section_type
!= s_public
)
931 section_type
= s_public
;
932 fprintfi_filtered (level
+ 2, stream
, "public:\n");
936 print_spaces_filtered (level
+ 4, stream
);
937 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
938 fprintf_filtered (stream
, "virtual ");
939 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
940 fprintf_filtered (stream
, "static ");
941 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
943 /* Keep GDB from crashing here. */
944 fprintf_filtered (stream
, "<undefined type> %s;\n",
945 TYPE_FN_FIELD_PHYSNAME (f
, j
));
948 else if (!is_constructor
&& /* constructors don't have declared types */
949 !is_full_physname_constructor
&& /* " " */
950 !is_type_conversion_operator (type
, i
, j
))
952 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
954 fputs_filtered (" ", stream
);
956 if (TYPE_FN_FIELD_STUB (f
, j
))
957 /* Build something we can demangle. */
958 mangled_name
= gdb_mangle_name (type
, i
, j
);
960 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
963 cplus_demangle (mangled_name
,
964 DMGL_ANSI
| DMGL_PARAMS
);
965 if (demangled_name
== NULL
)
967 /* in some cases (for instance with the HP demangling),
968 if a function has more than 10 arguments,
969 the demangling will fail.
970 Let's try to reconstruct the function signature from
971 the symbol information */
972 if (!TYPE_FN_FIELD_STUB (f
, j
))
973 cp_type_print_method_args (TYPE_FN_FIELD_ARGS (f
, j
), "",
975 TYPE_FN_FIELD_STATIC_P (f
, j
),
978 fprintf_filtered (stream
, "<badly mangled name '%s'>",
984 char *demangled_no_class
985 = remove_qualifiers (demangled_name
);
987 /* get rid of the `static' appended by the demangler */
988 p
= strstr (demangled_no_class
, " static");
991 int length
= p
- demangled_no_class
;
992 demangled_no_static
= (char *) xmalloc (length
+ 1);
993 strncpy (demangled_no_static
, demangled_no_class
, length
);
994 *(demangled_no_static
+ length
) = '\0';
995 fputs_filtered (demangled_no_static
, stream
);
996 xfree (demangled_no_static
);
999 fputs_filtered (demangled_no_class
, stream
);
1000 xfree (demangled_name
);
1003 if (TYPE_FN_FIELD_STUB (f
, j
))
1004 xfree (mangled_name
);
1006 fprintf_filtered (stream
, ";\n");
1010 fprintfi_filtered (level
, stream
, "}");
1012 if (TYPE_LOCALTYPE_PTR (type
) && show
>= 0)
1013 fprintfi_filtered (level
, stream
, " (Local at %s:%d)\n",
1014 TYPE_LOCALTYPE_FILE (type
),
1015 TYPE_LOCALTYPE_LINE (type
));
1017 if (TYPE_CODE (type
) == TYPE_CODE_TEMPLATE
)
1021 case TYPE_CODE_ENUM
:
1022 c_type_print_cv_qualifier (type
, stream
, 0, 1);
1023 /* HP C supports sized enums */
1024 if (hp_som_som_object_present
)
1025 switch (TYPE_LENGTH (type
))
1028 fputs_filtered ("char ", stream
);
1031 fputs_filtered ("short ", stream
);
1036 fprintf_filtered (stream
, "enum ");
1037 /* Print the tag name if it exists.
1038 The aCC compiler emits a spurious
1039 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1040 tag for unnamed struct/union/enum's, which we don't
1042 if (TYPE_TAG_NAME (type
) != NULL
&&
1043 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
1045 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1047 fputs_filtered (" ", stream
);
1053 /* If we just printed a tag name, no need to print anything else. */
1054 if (TYPE_TAG_NAME (type
) == NULL
)
1055 fprintf_filtered (stream
, "{...}");
1057 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1059 fprintf_filtered (stream
, "{");
1060 len
= TYPE_NFIELDS (type
);
1062 for (i
= 0; i
< len
; i
++)
1066 fprintf_filtered (stream
, ", ");
1068 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1069 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
1071 fprintf_filtered (stream
, " = %d", TYPE_FIELD_BITPOS (type
, i
));
1072 lastval
= TYPE_FIELD_BITPOS (type
, i
);
1076 fprintf_filtered (stream
, "}");
1080 case TYPE_CODE_VOID
:
1081 fprintf_filtered (stream
, "void");
1084 case TYPE_CODE_UNDEF
:
1085 fprintf_filtered (stream
, "struct <unknown>");
1088 case TYPE_CODE_ERROR
:
1089 fprintf_filtered (stream
, "<unknown type>");
1092 case TYPE_CODE_RANGE
:
1093 /* This should not occur */
1094 fprintf_filtered (stream
, "<range type>");
1097 case TYPE_CODE_TEMPLATE
:
1098 /* Called on "ptype t" where "t" is a template.
1099 Prints the template header (with args), e.g.:
1100 template <class T1, class T2> class "
1101 and then merges with the struct/union/class code to
1102 print the rest of the definition. */
1103 c_type_print_cv_qualifier (type
, stream
, 0, 1);
1104 fprintf_filtered (stream
, "template <");
1105 for (i
= 0; i
< TYPE_NTEMPLATE_ARGS (type
); i
++)
1107 struct template_arg templ_arg
;
1108 templ_arg
= TYPE_TEMPLATE_ARG (type
, i
);
1109 fprintf_filtered (stream
, "class %s", templ_arg
.name
);
1110 if (i
< TYPE_NTEMPLATE_ARGS (type
) - 1)
1111 fprintf_filtered (stream
, ", ");
1113 fprintf_filtered (stream
, "> class ");
1114 /* Yuck, factor this out to a subroutine so we can call
1115 it and return to the point marked with the "goback:" label... - RT */
1118 if (TYPE_NINSTANTIATIONS (type
) > 0)
1120 fprintf_filtered (stream
, "\ntemplate instantiations:\n");
1121 for (i
= 0; i
< TYPE_NINSTANTIATIONS (type
); i
++)
1123 fprintf_filtered (stream
, " ");
1124 c_type_print_base (TYPE_INSTANTIATION (type
, i
), stream
, 0, level
);
1125 if (i
< TYPE_NINSTANTIATIONS (type
) - 1)
1126 fprintf_filtered (stream
, "\n");
1132 /* Handle types not explicitly handled by the other cases,
1133 such as fundamental types. For these, just print whatever
1134 the type name is, as recorded in the type itself. If there
1135 is no type name, then complain. */
1136 if (TYPE_NAME (type
) != NULL
)
1138 c_type_print_cv_qualifier (type
, stream
, 0, 1);
1139 fputs_filtered (TYPE_NAME (type
), stream
);
1143 /* At least for dump_symtab, it is important that this not be
1145 fprintf_filtered (stream
, "<invalid type code %d>",