1 /* Support for printing C and C++ types for GDB, the GNU debugger.
2 Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
3 1999, 2000, 2001, 2002, 2003, 2006, 2007, 2008
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 3 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, see <http://www.gnu.org/licenses/>. */
22 #include "gdb_obstack.h"
23 #include "bfd.h" /* Binary File Description */
26 #include "expression.h"
33 #include "typeprint.h"
36 #include "gdb_string.h"
39 static void cp_type_print_method_args (struct type
*mtype
, char *prefix
,
40 char *varstring
, int staticp
,
41 struct ui_file
*stream
);
43 static void c_type_print_args (struct type
*, struct ui_file
*);
45 static void cp_type_print_derivation_info (struct ui_file
*, struct type
*);
47 static void c_type_print_varspec_prefix (struct type
*, struct ui_file
*, int,
50 /* Print "const", "volatile", or address space modifiers. */
51 static void c_type_print_modifier (struct type
*, struct ui_file
*,
57 /* LEVEL is the depth to indent lines by. */
60 c_print_type (struct type
*type
, char *varstring
, struct ui_file
*stream
,
70 c_type_print_base (type
, stream
, show
, level
);
71 code
= TYPE_CODE (type
);
72 if ((varstring
!= NULL
&& *varstring
!= '\0')
74 /* Need a space if going to print stars or brackets;
75 but not if we will print just a type name. */
76 ((show
> 0 || TYPE_NAME (type
) == 0)
78 (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
79 || code
== TYPE_CODE_METHOD
80 || code
== TYPE_CODE_ARRAY
81 || code
== TYPE_CODE_MEMBERPTR
82 || code
== TYPE_CODE_METHODPTR
83 || code
== TYPE_CODE_REF
)))
84 fputs_filtered (" ", stream
);
85 need_post_space
= (varstring
!= NULL
&& strcmp (varstring
, "") != 0);
86 c_type_print_varspec_prefix (type
, stream
, show
, 0, need_post_space
);
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
);
149 /* Print the C++ method arguments ARGS to the file STREAM. */
152 cp_type_print_method_args (struct type
*mtype
, char *prefix
, char *varstring
,
153 int staticp
, struct ui_file
*stream
)
155 struct field
*args
= TYPE_FIELDS (mtype
);
156 int nargs
= TYPE_NFIELDS (mtype
);
157 int varargs
= TYPE_VARARGS (mtype
);
160 fprintf_symbol_filtered (stream
, prefix
, language_cplus
, DMGL_ANSI
);
161 fprintf_symbol_filtered (stream
, varstring
, language_cplus
, DMGL_ANSI
);
162 fputs_filtered ("(", stream
);
164 /* Skip the class variable. */
170 type_print (args
[i
++].type
, "", stream
, 0);
172 if (i
== nargs
&& varargs
)
173 fprintf_filtered (stream
, ", ...");
175 fprintf_filtered (stream
, ", ");
179 fprintf_filtered (stream
, "...");
180 else if (current_language
->la_language
== language_cplus
)
181 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.
195 NEED_POST_SPACE is non-zero when a space will be be needed
196 between a trailing qualifier and a field, variable, or function
200 c_type_print_varspec_prefix (struct type
*type
, struct ui_file
*stream
,
201 int show
, int passed_a_ptr
, int need_post_space
)
207 if (TYPE_NAME (type
) && show
<= 0)
212 switch (TYPE_CODE (type
))
215 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 1, 1);
216 fprintf_filtered (stream
, "*");
217 c_type_print_modifier (type
, stream
, 1, need_post_space
);
220 case TYPE_CODE_MEMBERPTR
:
221 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
222 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
224 fputs_filtered (name
, stream
);
226 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
227 fprintf_filtered (stream
, "::*");
230 case TYPE_CODE_METHODPTR
:
231 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
232 fprintf_filtered (stream
, "(");
233 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
235 fputs_filtered (name
, stream
);
237 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
238 fprintf_filtered (stream
, "::*");
242 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 1, 0);
243 fprintf_filtered (stream
, "&");
244 c_type_print_modifier (type
, stream
, 1, need_post_space
);
247 case TYPE_CODE_METHOD
:
249 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
251 fprintf_filtered (stream
, "(");
254 case TYPE_CODE_ARRAY
:
255 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
257 fprintf_filtered (stream
, "(");
260 case TYPE_CODE_TYPEDEF
:
261 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
264 case TYPE_CODE_UNDEF
:
265 case TYPE_CODE_STRUCT
:
266 case TYPE_CODE_UNION
:
271 case TYPE_CODE_ERROR
:
275 case TYPE_CODE_RANGE
:
276 case TYPE_CODE_STRING
:
277 case TYPE_CODE_BITSTRING
:
278 case TYPE_CODE_COMPLEX
:
279 case TYPE_CODE_TEMPLATE
:
280 case TYPE_CODE_NAMESPACE
:
281 case TYPE_CODE_DECFLOAT
:
282 /* These types need no prefix. They are listed here so that
283 gcc -Wall will reveal any types that haven't been handled. */
286 error (_("type not handled in c_type_print_varspec_prefix()"));
291 /* Print out "const" and "volatile" attributes.
292 TYPE is a pointer to the type being printed out.
293 STREAM is the output destination.
294 NEED_SPACE = 1 indicates an initial white space is needed */
297 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
298 int need_pre_space
, int need_post_space
)
300 int did_print_modifier
= 0;
301 const char *address_space_id
;
303 /* We don't print `const' qualifiers for references --- since all
304 operators affect the thing referenced, not the reference itself,
305 every reference is `const'. */
306 if (TYPE_CONST (type
)
307 && TYPE_CODE (type
) != TYPE_CODE_REF
)
310 fprintf_filtered (stream
, " ");
311 fprintf_filtered (stream
, "const");
312 did_print_modifier
= 1;
315 if (TYPE_VOLATILE (type
))
317 if (did_print_modifier
|| need_pre_space
)
318 fprintf_filtered (stream
, " ");
319 fprintf_filtered (stream
, "volatile");
320 did_print_modifier
= 1;
323 address_space_id
= address_space_int_to_name (TYPE_INSTANCE_FLAGS (type
));
324 if (address_space_id
)
326 if (did_print_modifier
|| need_pre_space
)
327 fprintf_filtered (stream
, " ");
328 fprintf_filtered (stream
, "@%s", address_space_id
);
329 did_print_modifier
= 1;
332 if (did_print_modifier
&& need_post_space
)
333 fprintf_filtered (stream
, " ");
337 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
338 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
339 in non-static methods, are displayed. */
342 c_type_print_args (struct type
*type
, struct ui_file
*stream
)
348 fprintf_filtered (stream
, "(");
349 args
= TYPE_FIELDS (type
);
350 len
= TYPE_NFIELDS (type
);
352 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
356 fprintf_filtered (stream
, ", ");
360 c_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
364 if (printed_any
&& TYPE_VARARGS (type
))
366 /* Print out a trailing ellipsis for varargs functions. Ignore
367 TYPE_VARARGS if the function has no named arguments; that
368 represents unprototyped (K&R style) C functions. */
369 if (printed_any
&& TYPE_VARARGS (type
))
371 fprintf_filtered (stream
, ", ");
373 fprintf_filtered (stream
, "...");
376 else if (!printed_any
377 && (TYPE_PROTOTYPED (type
)
378 || current_language
->la_language
== language_cplus
))
379 fprintf_filtered (stream
, "void");
381 fprintf_filtered (stream
, ")");
385 /* Return true iff the j'th overloading of the i'th method of TYPE
386 is a type conversion operator, like `operator int () { ... }'.
387 When listing a class's methods, we don't print the return type of
390 is_type_conversion_operator (struct type
*type
, int i
, int j
)
392 /* I think the whole idea of recognizing type conversion operators
393 by their name is pretty terrible. But I don't think our present
394 data structure gives us any other way to tell. If you know of
395 some other way, feel free to rewrite this function. */
396 char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
398 if (strncmp (name
, "operator", 8) != 0)
402 if (! strchr (" \t\f\n\r", *name
))
405 while (strchr (" \t\f\n\r", *name
))
408 if (!('a' <= *name
&& *name
<= 'z')
409 && !('A' <= *name
&& *name
<= 'Z')
411 /* If this doesn't look like the start of an identifier, then it
412 isn't a type conversion operator. */
414 else if (strncmp (name
, "new", 3) == 0)
416 else if (strncmp (name
, "delete", 6) == 0)
419 /* If it doesn't look like new or delete, it's a type conversion
423 /* Is that really the end of the name? */
424 if (('a' <= *name
&& *name
<= 'z')
425 || ('A' <= *name
&& *name
<= 'Z')
426 || ('0' <= *name
&& *name
<= '9')
428 /* No, so the identifier following "operator" must be a type name,
429 and this is a type conversion operator. */
432 /* That was indeed the end of the name, so it was `operator new' or
433 `operator delete', neither of which are type conversion operators. */
438 /* Given a C++ qualified identifier QID, strip off the qualifiers,
439 yielding the unqualified name. The return value is a pointer into
442 It's a pity we don't have this information in some more structured
443 form. Even the author of this function feels that writing little
444 parsers like this everywhere is stupid. */
446 remove_qualifiers (char *qid
)
448 int quoted
= 0; /* zero if we're not in quotes;
449 '"' if we're in a double-quoted string;
450 '\'' if we're in a single-quoted string. */
451 int depth
= 0; /* number of unclosed parens we've seen */
452 char *parenstack
= (char *) alloca (strlen (qid
));
454 char *last
= 0; /* The character after the rightmost
455 `::' token we've seen so far. */
457 for (scan
= qid
; *scan
; scan
++)
463 else if (*scan
== '\\' && *(scan
+ 1))
466 else if (scan
[0] == ':' && scan
[1] == ':')
468 /* If we're inside parenthesis (i.e., an argument list) or
469 angle brackets (i.e., a list of template arguments), then
470 we don't record the position of this :: token, since it's
471 not relevant to the top-level structure we're trying
479 else if (*scan
== '"' || *scan
== '\'')
481 else if (*scan
== '(')
482 parenstack
[depth
++] = ')';
483 else if (*scan
== '[')
484 parenstack
[depth
++] = ']';
485 /* We're going to treat <> as a pair of matching characters,
486 since we're more likely to see those in template id's than
487 real less-than characters. What a crock. */
488 else if (*scan
== '<')
489 parenstack
[depth
++] = '>';
490 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
492 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
496 /* We're going to do a little error recovery here. If we
497 don't find a match for *scan on the paren stack, but
498 there is something lower on the stack that does match, we
499 pop the stack to that point. */
502 for (i
= depth
- 1; i
>= 0; i
--)
503 if (parenstack
[i
] == *scan
)
515 /* We didn't find any :: tokens at the top level, so declare the
516 whole thing an unqualified identifier. */
521 /* Print any array sizes, function arguments or close parentheses
522 needed after the variable name (to describe its type).
523 Args work like c_type_print_varspec_prefix. */
526 c_type_print_varspec_suffix (struct type
*type
, struct ui_file
*stream
,
527 int show
, int passed_a_ptr
, int demangled_args
)
532 if (TYPE_NAME (type
) && show
<= 0)
537 switch (TYPE_CODE (type
))
539 case TYPE_CODE_ARRAY
:
541 fprintf_filtered (stream
, ")");
543 fprintf_filtered (stream
, "[");
544 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0
545 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
546 fprintf_filtered (stream
, "%d",
548 / TYPE_LENGTH (TYPE_TARGET_TYPE (type
))));
549 fprintf_filtered (stream
, "]");
551 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
555 case TYPE_CODE_MEMBERPTR
:
556 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
560 case TYPE_CODE_METHODPTR
:
561 fprintf_filtered (stream
, ")");
562 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
568 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
572 case TYPE_CODE_METHOD
:
575 fprintf_filtered (stream
, ")");
577 c_type_print_args (type
, stream
);
578 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
582 case TYPE_CODE_TYPEDEF
:
583 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
587 case TYPE_CODE_UNDEF
:
588 case TYPE_CODE_STRUCT
:
589 case TYPE_CODE_UNION
:
594 case TYPE_CODE_ERROR
:
598 case TYPE_CODE_RANGE
:
599 case TYPE_CODE_STRING
:
600 case TYPE_CODE_BITSTRING
:
601 case TYPE_CODE_COMPLEX
:
602 case TYPE_CODE_TEMPLATE
:
603 case TYPE_CODE_NAMESPACE
:
604 case TYPE_CODE_DECFLOAT
:
605 /* These types do not need a suffix. They are listed so that
606 gcc -Wall will report types that may not have been considered. */
609 error (_("type not handled in c_type_print_varspec_suffix()"));
614 /* Print the name of the type (or the ultimate pointer target,
615 function value or array element), or the description of a
618 SHOW positive means print details about the type (e.g. enum values),
619 and print structure elements passing SHOW - 1 for show.
620 SHOW negative means just print the type name or struct tag if there is one.
621 If there is no name, print something sensible but concise like
623 SHOW zero means just print the type name or struct tag if there is one.
624 If there is no name, print something sensible but not as concise like
625 "struct {int x; int y;}".
627 LEVEL is the number of spaces to indent by.
628 We increase it for some recursive calls. */
631 c_type_print_base (struct type
*type
, struct ui_file
*stream
, int show
,
638 char *demangled_name
;
639 char *demangled_no_static
;
642 s_none
, s_public
, s_private
, s_protected
645 int need_access_label
= 0;
653 fputs_filtered (_("<type unknown>"), stream
);
657 /* When SHOW is zero or less, and there is a valid type name, then always
658 just print the type name directly from the type. */
659 /* If we have "typedef struct foo {. . .} bar;" do we want to print it
660 as "struct foo" or as "bar"? Pick the latter, because C++ folk tend
661 to expect things like "class5 *foo" rather than "struct class5 *foo". */
664 && TYPE_NAME (type
) != NULL
)
666 c_type_print_modifier (type
, stream
, 0, 1);
667 fputs_filtered (TYPE_NAME (type
), stream
);
671 CHECK_TYPEDEF (type
);
673 switch (TYPE_CODE (type
))
675 case TYPE_CODE_TYPEDEF
:
676 case TYPE_CODE_ARRAY
:
678 case TYPE_CODE_MEMBERPTR
:
681 case TYPE_CODE_METHOD
:
682 case TYPE_CODE_METHODPTR
:
683 c_type_print_base (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
686 case TYPE_CODE_STRUCT
:
687 c_type_print_modifier (type
, stream
, 0, 1);
688 /* Note TYPE_CODE_STRUCT and TYPE_CODE_CLASS have the same value,
689 * so we use another means for distinguishing them.
691 if (HAVE_CPLUS_STRUCT (type
))
693 switch (TYPE_DECLARED_TYPE (type
))
695 case DECLARED_TYPE_CLASS
:
696 fprintf_filtered (stream
, "class ");
698 case DECLARED_TYPE_UNION
:
699 fprintf_filtered (stream
, "union ");
701 case DECLARED_TYPE_STRUCT
:
702 fprintf_filtered (stream
, "struct ");
705 /* If there is a CPLUS_STRUCT, assume class if not
706 * otherwise specified in the declared_type field.
708 fprintf_filtered (stream
, "class ");
714 /* If not CPLUS_STRUCT, then assume it's a C struct */
715 fprintf_filtered (stream
, "struct ");
719 case TYPE_CODE_UNION
:
720 c_type_print_modifier (type
, stream
, 0, 1);
721 fprintf_filtered (stream
, "union ");
725 /* Print the tag if it exists.
726 * The HP aCC compiler emits
727 * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
728 * tag for unnamed struct/union/enum's, which we don't
731 if (TYPE_TAG_NAME (type
) != NULL
&&
732 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
734 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
736 fputs_filtered (" ", stream
);
741 /* If we just printed a tag name, no need to print anything else. */
742 if (TYPE_TAG_NAME (type
) == NULL
)
743 fprintf_filtered (stream
, "{...}");
745 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
747 cp_type_print_derivation_info (stream
, type
);
749 fprintf_filtered (stream
, "{\n");
750 if ((TYPE_NFIELDS (type
) == 0) && (TYPE_NFN_FIELDS (type
) == 0))
752 if (TYPE_STUB (type
))
753 fprintfi_filtered (level
+ 4, stream
, _("<incomplete type>\n"));
755 fprintfi_filtered (level
+ 4, stream
, _("<no data fields>\n"));
758 /* Start off with no specific section type, so we can print
759 one for the first field we find, and use that section type
760 thereafter until we find another type. */
762 section_type
= s_none
;
764 /* For a class, if all members are private, there's no need
765 for a "private:" label; similarly, for a struct or union
766 masquerading as a class, if all members are public, there's
767 no need for a "public:" label. */
769 if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_CLASS
) ||
770 (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_TEMPLATE
))
773 len
= TYPE_NFIELDS (type
);
774 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
775 if (!TYPE_FIELD_PRIVATE (type
, i
))
777 need_access_label
= 1;
781 if (!need_access_label
)
783 len2
= TYPE_NFN_FIELDS (type
);
784 for (j
= 0; j
< len2
; j
++)
786 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
787 for (i
= 0; i
< len
; i
++)
788 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
))
790 need_access_label
= 1;
793 if (need_access_label
)
798 else if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_STRUCT
) ||
799 (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_UNION
))
802 len
= TYPE_NFIELDS (type
);
803 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
804 if (TYPE_FIELD_PRIVATE (type
, i
) || TYPE_FIELD_PROTECTED (type
, i
))
806 need_access_label
= 1;
810 if (!need_access_label
)
812 len2
= TYPE_NFN_FIELDS (type
);
813 for (j
= 0; j
< len2
; j
++)
816 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
817 for (i
= 0; i
< len
; i
++)
818 if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
) ||
819 TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
, j
), i
))
821 need_access_label
= 1;
824 if (need_access_label
)
830 /* If there is a base class for this type,
831 do not print the field that it occupies. */
833 len
= TYPE_NFIELDS (type
);
834 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
837 /* Don't print out virtual function table. */
838 if (strncmp (TYPE_FIELD_NAME (type
, i
), "_vptr", 5) == 0
839 && is_cplus_marker ((TYPE_FIELD_NAME (type
, i
))[5]))
842 /* If this is a C++ class we can print the various C++ section
845 if (HAVE_CPLUS_STRUCT (type
) && need_access_label
)
847 if (TYPE_FIELD_PROTECTED (type
, i
))
849 if (section_type
!= s_protected
)
851 section_type
= s_protected
;
852 fprintfi_filtered (level
+ 2, stream
,
856 else if (TYPE_FIELD_PRIVATE (type
, i
))
858 if (section_type
!= s_private
)
860 section_type
= s_private
;
861 fprintfi_filtered (level
+ 2, stream
, "private:\n");
866 if (section_type
!= s_public
)
868 section_type
= s_public
;
869 fprintfi_filtered (level
+ 2, stream
, "public:\n");
874 print_spaces_filtered (level
+ 4, stream
);
875 if (TYPE_FIELD_STATIC (type
, i
))
877 fprintf_filtered (stream
, "static ");
879 c_print_type (TYPE_FIELD_TYPE (type
, i
),
880 TYPE_FIELD_NAME (type
, i
),
881 stream
, show
- 1, level
+ 4);
882 if (!TYPE_FIELD_STATIC (type
, i
)
883 && TYPE_FIELD_PACKED (type
, i
))
885 /* It is a bitfield. This code does not attempt
886 to look at the bitpos and reconstruct filler,
887 unnamed fields. This would lead to misleading
888 results if the compiler does not put out fields
889 for such things (I don't know what it does). */
890 fprintf_filtered (stream
, " : %d",
891 TYPE_FIELD_BITSIZE (type
, i
));
893 fprintf_filtered (stream
, ";\n");
896 /* If there are both fields and methods, put a blank line
897 between them. Make sure to count only method that we will
898 display; artificial methods will be hidden. */
899 len
= TYPE_NFN_FIELDS (type
);
901 for (i
= 0; i
< len
; i
++)
903 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
904 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
906 for (j
= 0; j
< len2
; j
++)
907 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
910 if (real_len
> 0 && section_type
!= s_none
)
911 fprintf_filtered (stream
, "\n");
913 /* C++: print out the methods */
914 for (i
= 0; i
< len
; i
++)
916 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
917 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
918 char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
919 char *name
= type_name_no_tag (type
);
920 int is_constructor
= name
&& strcmp (method_name
, name
) == 0;
921 for (j
= 0; j
< len2
; j
++)
923 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
924 int is_full_physname_constructor
=
925 is_constructor_name (physname
)
926 || is_destructor_name (physname
)
927 || method_name
[0] == '~';
929 /* Do not print out artificial methods. */
930 if (TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
934 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
936 if (section_type
!= s_protected
)
938 section_type
= s_protected
;
939 fprintfi_filtered (level
+ 2, stream
,
943 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
945 if (section_type
!= s_private
)
947 section_type
= s_private
;
948 fprintfi_filtered (level
+ 2, stream
, "private:\n");
953 if (section_type
!= s_public
)
955 section_type
= s_public
;
956 fprintfi_filtered (level
+ 2, stream
, "public:\n");
960 print_spaces_filtered (level
+ 4, stream
);
961 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
962 fprintf_filtered (stream
, "virtual ");
963 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
964 fprintf_filtered (stream
, "static ");
965 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
967 /* Keep GDB from crashing here. */
968 fprintf_filtered (stream
, _("<undefined type> %s;\n"),
969 TYPE_FN_FIELD_PHYSNAME (f
, j
));
972 else if (!is_constructor
&& /* constructors don't have declared types */
973 !is_full_physname_constructor
&& /* " " */
974 !is_type_conversion_operator (type
, i
, j
))
976 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
978 fputs_filtered (" ", stream
);
980 if (TYPE_FN_FIELD_STUB (f
, j
))
981 /* Build something we can demangle. */
982 mangled_name
= gdb_mangle_name (type
, i
, j
);
984 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
987 cplus_demangle (mangled_name
,
988 DMGL_ANSI
| DMGL_PARAMS
);
989 if (demangled_name
== NULL
)
991 /* in some cases (for instance with the HP demangling),
992 if a function has more than 10 arguments,
993 the demangling will fail.
994 Let's try to reconstruct the function signature from
995 the symbol information */
996 if (!TYPE_FN_FIELD_STUB (f
, j
))
998 int staticp
= TYPE_FN_FIELD_STATIC_P (f
, j
);
999 struct type
*mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1000 cp_type_print_method_args (mtype
,
1007 fprintf_filtered (stream
, _("<badly mangled name '%s'>"),
1013 char *demangled_no_class
1014 = remove_qualifiers (demangled_name
);
1016 /* get rid of the `static' appended by the demangler */
1017 p
= strstr (demangled_no_class
, " static");
1020 int length
= p
- demangled_no_class
;
1021 demangled_no_static
= (char *) xmalloc (length
+ 1);
1022 strncpy (demangled_no_static
, demangled_no_class
, length
);
1023 *(demangled_no_static
+ length
) = '\0';
1024 fputs_filtered (demangled_no_static
, stream
);
1025 xfree (demangled_no_static
);
1028 fputs_filtered (demangled_no_class
, stream
);
1029 xfree (demangled_name
);
1032 if (TYPE_FN_FIELD_STUB (f
, j
))
1033 xfree (mangled_name
);
1035 fprintf_filtered (stream
, ";\n");
1039 fprintfi_filtered (level
, stream
, "}");
1041 if (TYPE_LOCALTYPE_PTR (type
) && show
>= 0)
1042 fprintfi_filtered (level
, stream
, _(" (Local at %s:%d)\n"),
1043 TYPE_LOCALTYPE_FILE (type
),
1044 TYPE_LOCALTYPE_LINE (type
));
1046 if (TYPE_CODE (type
) == TYPE_CODE_TEMPLATE
)
1050 case TYPE_CODE_ENUM
:
1051 c_type_print_modifier (type
, stream
, 0, 1);
1052 fprintf_filtered (stream
, "enum ");
1053 /* Print the tag name if it exists.
1054 The aCC compiler emits a spurious
1055 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1056 tag for unnamed struct/union/enum's, which we don't
1058 if (TYPE_TAG_NAME (type
) != NULL
&&
1059 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
1061 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1063 fputs_filtered (" ", stream
);
1069 /* If we just printed a tag name, no need to print anything else. */
1070 if (TYPE_TAG_NAME (type
) == NULL
)
1071 fprintf_filtered (stream
, "{...}");
1073 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1075 fprintf_filtered (stream
, "{");
1076 len
= TYPE_NFIELDS (type
);
1078 for (i
= 0; i
< len
; i
++)
1082 fprintf_filtered (stream
, ", ");
1084 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1085 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
1087 fprintf_filtered (stream
, " = %d", TYPE_FIELD_BITPOS (type
, i
));
1088 lastval
= TYPE_FIELD_BITPOS (type
, i
);
1092 fprintf_filtered (stream
, "}");
1096 case TYPE_CODE_VOID
:
1097 fprintf_filtered (stream
, "void");
1100 case TYPE_CODE_UNDEF
:
1101 fprintf_filtered (stream
, _("struct <unknown>"));
1104 case TYPE_CODE_ERROR
:
1105 fprintf_filtered (stream
, _("<unknown type>"));
1108 case TYPE_CODE_RANGE
:
1109 /* This should not occur */
1110 fprintf_filtered (stream
, _("<range type>"));
1113 case TYPE_CODE_TEMPLATE
:
1114 /* Called on "ptype t" where "t" is a template.
1115 Prints the template header (with args), e.g.:
1116 template <class T1, class T2> class "
1117 and then merges with the struct/union/class code to
1118 print the rest of the definition. */
1119 c_type_print_modifier (type
, stream
, 0, 1);
1120 fprintf_filtered (stream
, "template <");
1121 for (i
= 0; i
< TYPE_NTEMPLATE_ARGS (type
); i
++)
1123 struct template_arg templ_arg
;
1124 templ_arg
= TYPE_TEMPLATE_ARG (type
, i
);
1125 fprintf_filtered (stream
, "class %s", templ_arg
.name
);
1126 if (i
< TYPE_NTEMPLATE_ARGS (type
) - 1)
1127 fprintf_filtered (stream
, ", ");
1129 fprintf_filtered (stream
, "> class ");
1130 /* Yuck, factor this out to a subroutine so we can call
1131 it and return to the point marked with the "goback:" label... - RT */
1134 if (TYPE_NINSTANTIATIONS (type
) > 0)
1136 fprintf_filtered (stream
, _("\ntemplate instantiations:\n"));
1137 for (i
= 0; i
< TYPE_NINSTANTIATIONS (type
); i
++)
1139 fprintf_filtered (stream
, " ");
1140 c_type_print_base (TYPE_INSTANTIATION (type
, i
), stream
, 0, level
);
1141 if (i
< TYPE_NINSTANTIATIONS (type
) - 1)
1142 fprintf_filtered (stream
, "\n");
1147 case TYPE_CODE_NAMESPACE
:
1148 fputs_filtered ("namespace ", stream
);
1149 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1153 /* Handle types not explicitly handled by the other cases,
1154 such as fundamental types. For these, just print whatever
1155 the type name is, as recorded in the type itself. If there
1156 is no type name, then complain. */
1157 if (TYPE_NAME (type
) != NULL
)
1159 c_type_print_modifier (type
, stream
, 0, 1);
1160 fputs_filtered (TYPE_NAME (type
), stream
);
1164 /* At least for dump_symtab, it is important that this not be
1166 fprintf_filtered (stream
, _("<invalid type code %d>"),