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, 2009, 2010
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')
73 /* Need a space if going to print stars or brackets;
74 but not if we will print just a type name. */
75 || ((show
> 0 || TYPE_NAME (type
) == 0)
76 && (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
77 || code
== TYPE_CODE_METHOD
78 || code
== TYPE_CODE_ARRAY
79 || code
== TYPE_CODE_MEMBERPTR
80 || code
== TYPE_CODE_METHODPTR
81 || code
== TYPE_CODE_REF
)))
82 fputs_filtered (" ", stream
);
83 need_post_space
= (varstring
!= NULL
&& strcmp (varstring
, "") != 0);
84 c_type_print_varspec_prefix (type
, stream
, show
, 0, need_post_space
);
86 if (varstring
!= NULL
)
88 fputs_filtered (varstring
, stream
);
90 /* For demangled function names, we have the arglist as part of the name,
91 so don't print an additional pair of ()'s */
93 demangled_args
= strchr (varstring
, '(') != NULL
;
94 c_type_print_varspec_suffix (type
, stream
, show
, 0, demangled_args
);
98 /* Print a typedef using C syntax. TYPE is the underlying type.
99 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
103 c_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
104 struct ui_file
*stream
)
106 CHECK_TYPEDEF (type
);
107 fprintf_filtered (stream
, "typedef ");
108 type_print (type
, "", stream
, 0);
109 if (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))) == 0
110 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))),
111 SYMBOL_LINKAGE_NAME (new_symbol
)) != 0)
112 fprintf_filtered (stream
, " %s", SYMBOL_PRINT_NAME (new_symbol
));
113 fprintf_filtered (stream
, ";\n");
116 /* If TYPE is a derived type, then print out derivation information.
117 Print only the actual base classes of this type, not the base classes
118 of the base classes. I.E. for the derivation hierarchy:
121 class B : public A {int b; };
122 class C : public B {int c; };
124 Print the type of class C as:
130 Not as the following (like gdb used to), which is not legal C++ syntax for
131 derived types and may be confused with the multiple inheritance form:
133 class C : public B : public A {
137 In general, gdb should try to print the types as closely as possible to
138 the form that they appear in the source code.
139 Note that in case of protected derivation gcc will not say 'protected'
140 but 'private'. The HP's aCC compiler emits specific information for
141 derivation via protected inheritance, so gdb can print it out */
144 cp_type_print_derivation_info (struct ui_file
*stream
, struct type
*type
)
149 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
151 fputs_filtered (i
== 0 ? ": " : ", ", stream
);
152 fprintf_filtered (stream
, "%s%s ",
153 BASETYPE_VIA_PUBLIC (type
, i
) ? "public"
154 : (TYPE_FIELD_PROTECTED (type
, i
) ? "protected" : "private"),
155 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
156 name
= type_name_no_tag (TYPE_BASECLASS (type
, i
));
157 fprintf_filtered (stream
, "%s", name
? name
: "(null)");
161 fputs_filtered (" ", stream
);
165 /* Print the C++ method arguments ARGS to the file STREAM. */
168 cp_type_print_method_args (struct type
*mtype
, char *prefix
, char *varstring
,
169 int staticp
, struct ui_file
*stream
)
171 struct field
*args
= TYPE_FIELDS (mtype
);
172 int nargs
= TYPE_NFIELDS (mtype
);
173 int varargs
= TYPE_VARARGS (mtype
);
176 fprintf_symbol_filtered (stream
, prefix
, language_cplus
, DMGL_ANSI
);
177 fprintf_symbol_filtered (stream
, varstring
, language_cplus
, DMGL_ANSI
);
178 fputs_filtered ("(", stream
);
180 /* Skip the class variable. */
186 type_print (args
[i
++].type
, "", stream
, 0);
188 if (i
== nargs
&& varargs
)
189 fprintf_filtered (stream
, ", ...");
191 fprintf_filtered (stream
, ", ");
195 fprintf_filtered (stream
, "...");
196 else if (current_language
->la_language
== language_cplus
)
197 fprintf_filtered (stream
, "void");
199 fprintf_filtered (stream
, ")");
203 /* Print any asterisks or open-parentheses needed before the
204 variable name (to describe its type).
206 On outermost call, pass 0 for PASSED_A_PTR.
207 On outermost call, SHOW > 0 means should ignore
208 any typename for TYPE and show its details.
209 SHOW is always zero on recursive calls.
211 NEED_POST_SPACE is non-zero when a space will be be needed
212 between a trailing qualifier and a field, variable, or function
216 c_type_print_varspec_prefix (struct type
*type
, struct ui_file
*stream
,
217 int show
, int passed_a_ptr
, int need_post_space
)
223 if (TYPE_NAME (type
) && show
<= 0)
228 switch (TYPE_CODE (type
))
231 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 1, 1);
232 fprintf_filtered (stream
, "*");
233 c_type_print_modifier (type
, stream
, 1, need_post_space
);
236 case TYPE_CODE_MEMBERPTR
:
237 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
238 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
240 fputs_filtered (name
, stream
);
242 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
243 fprintf_filtered (stream
, "::*");
246 case TYPE_CODE_METHODPTR
:
247 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
248 fprintf_filtered (stream
, "(");
249 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
251 fputs_filtered (name
, stream
);
253 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
254 fprintf_filtered (stream
, "::*");
258 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 1, 0);
259 fprintf_filtered (stream
, "&");
260 c_type_print_modifier (type
, stream
, 1, need_post_space
);
263 case TYPE_CODE_METHOD
:
265 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
267 fprintf_filtered (stream
, "(");
270 case TYPE_CODE_ARRAY
:
271 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
273 fprintf_filtered (stream
, "(");
276 case TYPE_CODE_TYPEDEF
:
277 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
280 case TYPE_CODE_UNDEF
:
281 case TYPE_CODE_STRUCT
:
282 case TYPE_CODE_UNION
:
287 case TYPE_CODE_ERROR
:
291 case TYPE_CODE_RANGE
:
292 case TYPE_CODE_STRING
:
293 case TYPE_CODE_BITSTRING
:
294 case TYPE_CODE_COMPLEX
:
295 case TYPE_CODE_NAMESPACE
:
296 case TYPE_CODE_DECFLOAT
:
297 /* These types need no prefix. They are listed here so that
298 gcc -Wall will reveal any types that haven't been handled. */
301 error (_("type not handled in c_type_print_varspec_prefix()"));
306 /* Print out "const" and "volatile" attributes.
307 TYPE is a pointer to the type being printed out.
308 STREAM is the output destination.
309 NEED_SPACE = 1 indicates an initial white space is needed */
312 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
313 int need_pre_space
, int need_post_space
)
315 int did_print_modifier
= 0;
316 const char *address_space_id
;
318 /* We don't print `const' qualifiers for references --- since all
319 operators affect the thing referenced, not the reference itself,
320 every reference is `const'. */
321 if (TYPE_CONST (type
)
322 && TYPE_CODE (type
) != TYPE_CODE_REF
)
325 fprintf_filtered (stream
, " ");
326 fprintf_filtered (stream
, "const");
327 did_print_modifier
= 1;
330 if (TYPE_VOLATILE (type
))
332 if (did_print_modifier
|| need_pre_space
)
333 fprintf_filtered (stream
, " ");
334 fprintf_filtered (stream
, "volatile");
335 did_print_modifier
= 1;
338 address_space_id
= address_space_int_to_name (get_type_arch (type
),
339 TYPE_INSTANCE_FLAGS (type
));
340 if (address_space_id
)
342 if (did_print_modifier
|| need_pre_space
)
343 fprintf_filtered (stream
, " ");
344 fprintf_filtered (stream
, "@%s", address_space_id
);
345 did_print_modifier
= 1;
348 if (did_print_modifier
&& need_post_space
)
349 fprintf_filtered (stream
, " ");
353 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
354 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
355 in non-static methods, are displayed. */
358 c_type_print_args (struct type
*type
, struct ui_file
*stream
)
364 fprintf_filtered (stream
, "(");
365 args
= TYPE_FIELDS (type
);
366 len
= TYPE_NFIELDS (type
);
368 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
372 fprintf_filtered (stream
, ", ");
376 c_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
380 if (printed_any
&& TYPE_VARARGS (type
))
382 /* Print out a trailing ellipsis for varargs functions. Ignore
383 TYPE_VARARGS if the function has no named arguments; that
384 represents unprototyped (K&R style) C functions. */
385 if (printed_any
&& TYPE_VARARGS (type
))
387 fprintf_filtered (stream
, ", ");
389 fprintf_filtered (stream
, "...");
392 else if (!printed_any
393 && (TYPE_PROTOTYPED (type
)
394 || current_language
->la_language
== language_cplus
))
395 fprintf_filtered (stream
, "void");
397 fprintf_filtered (stream
, ")");
401 /* Return true iff the j'th overloading of the i'th method of TYPE
402 is a type conversion operator, like `operator int () { ... }'.
403 When listing a class's methods, we don't print the return type of
406 is_type_conversion_operator (struct type
*type
, int i
, int j
)
408 /* I think the whole idea of recognizing type conversion operators
409 by their name is pretty terrible. But I don't think our present
410 data structure gives us any other way to tell. If you know of
411 some other way, feel free to rewrite this function. */
412 char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
414 if (strncmp (name
, "operator", 8) != 0)
418 if (! strchr (" \t\f\n\r", *name
))
421 while (strchr (" \t\f\n\r", *name
))
424 if (!('a' <= *name
&& *name
<= 'z')
425 && !('A' <= *name
&& *name
<= 'Z')
427 /* If this doesn't look like the start of an identifier, then it
428 isn't a type conversion operator. */
430 else if (strncmp (name
, "new", 3) == 0)
432 else if (strncmp (name
, "delete", 6) == 0)
435 /* If it doesn't look like new or delete, it's a type conversion
439 /* Is that really the end of the name? */
440 if (('a' <= *name
&& *name
<= 'z')
441 || ('A' <= *name
&& *name
<= 'Z')
442 || ('0' <= *name
&& *name
<= '9')
444 /* No, so the identifier following "operator" must be a type name,
445 and this is a type conversion operator. */
448 /* That was indeed the end of the name, so it was `operator new' or
449 `operator delete', neither of which are type conversion operators. */
454 /* Given a C++ qualified identifier QID, strip off the qualifiers,
455 yielding the unqualified name. The return value is a pointer into
458 It's a pity we don't have this information in some more structured
459 form. Even the author of this function feels that writing little
460 parsers like this everywhere is stupid. */
462 remove_qualifiers (char *qid
)
464 int quoted
= 0; /* zero if we're not in quotes;
465 '"' if we're in a double-quoted string;
466 '\'' if we're in a single-quoted string. */
467 int depth
= 0; /* number of unclosed parens we've seen */
468 char *parenstack
= (char *) alloca (strlen (qid
));
470 char *last
= 0; /* The character after the rightmost
471 `::' token we've seen so far. */
473 for (scan
= qid
; *scan
; scan
++)
479 else if (*scan
== '\\' && *(scan
+ 1))
482 else if (scan
[0] == ':' && scan
[1] == ':')
484 /* If we're inside parenthesis (i.e., an argument list) or
485 angle brackets (i.e., a list of template arguments), then
486 we don't record the position of this :: token, since it's
487 not relevant to the top-level structure we're trying
495 else if (*scan
== '"' || *scan
== '\'')
497 else if (*scan
== '(')
498 parenstack
[depth
++] = ')';
499 else if (*scan
== '[')
500 parenstack
[depth
++] = ']';
501 /* We're going to treat <> as a pair of matching characters,
502 since we're more likely to see those in template id's than
503 real less-than characters. What a crock. */
504 else if (*scan
== '<')
505 parenstack
[depth
++] = '>';
506 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
508 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
512 /* We're going to do a little error recovery here. If we
513 don't find a match for *scan on the paren stack, but
514 there is something lower on the stack that does match, we
515 pop the stack to that point. */
518 for (i
= depth
- 1; i
>= 0; i
--)
519 if (parenstack
[i
] == *scan
)
531 /* We didn't find any :: tokens at the top level, so declare the
532 whole thing an unqualified identifier. */
537 /* Print any array sizes, function arguments or close parentheses
538 needed after the variable name (to describe its type).
539 Args work like c_type_print_varspec_prefix. */
542 c_type_print_varspec_suffix (struct type
*type
, struct ui_file
*stream
,
543 int show
, int passed_a_ptr
, int demangled_args
)
548 if (TYPE_NAME (type
) && show
<= 0)
553 switch (TYPE_CODE (type
))
555 case TYPE_CODE_ARRAY
:
557 fprintf_filtered (stream
, ")");
559 fprintf_filtered (stream
, "[");
560 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0
561 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))
562 fprintf_filtered (stream
, "%d",
564 / TYPE_LENGTH (TYPE_TARGET_TYPE (type
))));
565 fprintf_filtered (stream
, "]");
567 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
571 case TYPE_CODE_MEMBERPTR
:
572 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
576 case TYPE_CODE_METHODPTR
:
577 fprintf_filtered (stream
, ")");
578 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
584 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
588 case TYPE_CODE_METHOD
:
591 fprintf_filtered (stream
, ")");
593 c_type_print_args (type
, stream
);
594 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
598 case TYPE_CODE_TYPEDEF
:
599 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
603 case TYPE_CODE_UNDEF
:
604 case TYPE_CODE_STRUCT
:
605 case TYPE_CODE_UNION
:
610 case TYPE_CODE_ERROR
:
614 case TYPE_CODE_RANGE
:
615 case TYPE_CODE_STRING
:
616 case TYPE_CODE_BITSTRING
:
617 case TYPE_CODE_COMPLEX
:
618 case TYPE_CODE_NAMESPACE
:
619 case TYPE_CODE_DECFLOAT
:
620 /* These types do not need a suffix. They are listed so that
621 gcc -Wall will report types that may not have been considered. */
624 error (_("type not handled in c_type_print_varspec_suffix()"));
629 /* Print the name of the type (or the ultimate pointer target,
630 function value or array element), or the description of a
633 SHOW positive means print details about the type (e.g. enum values),
634 and print structure elements passing SHOW - 1 for show.
635 SHOW negative means just print the type name or struct tag if there is one.
636 If there is no name, print something sensible but concise like
638 SHOW zero means just print the type name or struct tag if there is one.
639 If there is no name, print something sensible but not as concise like
640 "struct {int x; int y;}".
642 LEVEL is the number of spaces to indent by.
643 We increase it for some recursive calls. */
646 c_type_print_base (struct type
*type
, struct ui_file
*stream
, int show
,
653 char *demangled_name
;
654 char *demangled_no_static
;
657 s_none
, s_public
, s_private
, s_protected
660 int need_access_label
= 0;
668 fputs_filtered (_("<type unknown>"), stream
);
672 /* When SHOW is zero or less, and there is a valid type name, then always
673 just print the type name directly from the type. */
674 /* If we have "typedef struct foo {. . .} bar;" do we want to print it
675 as "struct foo" or as "bar"? Pick the latter, because C++ folk tend
676 to expect things like "class5 *foo" rather than "struct class5 *foo". */
679 && TYPE_NAME (type
) != NULL
)
681 c_type_print_modifier (type
, stream
, 0, 1);
682 fputs_filtered (TYPE_NAME (type
), stream
);
686 CHECK_TYPEDEF (type
);
688 switch (TYPE_CODE (type
))
690 case TYPE_CODE_TYPEDEF
:
691 case TYPE_CODE_ARRAY
:
693 case TYPE_CODE_MEMBERPTR
:
696 case TYPE_CODE_METHOD
:
697 case TYPE_CODE_METHODPTR
:
698 c_type_print_base (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
701 case TYPE_CODE_STRUCT
:
702 c_type_print_modifier (type
, stream
, 0, 1);
703 if (TYPE_DECLARED_CLASS (type
))
704 fprintf_filtered (stream
, "class ");
706 fprintf_filtered (stream
, "struct ");
709 case TYPE_CODE_UNION
:
710 c_type_print_modifier (type
, stream
, 0, 1);
711 fprintf_filtered (stream
, "union ");
715 /* Print the tag if it exists.
716 * The HP aCC compiler emits
717 * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
718 * tag for unnamed struct/union/enum's, which we don't
721 if (TYPE_TAG_NAME (type
) != NULL
722 && strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
724 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
726 fputs_filtered (" ", stream
);
731 /* If we just printed a tag name, no need to print anything else. */
732 if (TYPE_TAG_NAME (type
) == NULL
)
733 fprintf_filtered (stream
, "{...}");
735 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
737 struct type
*basetype
;
740 cp_type_print_derivation_info (stream
, type
);
742 fprintf_filtered (stream
, "{\n");
743 if ((TYPE_NFIELDS (type
) == 0) && (TYPE_NFN_FIELDS (type
) == 0))
745 if (TYPE_STUB (type
))
746 fprintfi_filtered (level
+ 4, stream
, _("<incomplete type>\n"));
748 fprintfi_filtered (level
+ 4, stream
, _("<no data fields>\n"));
751 /* Start off with no specific section type, so we can print
752 one for the first field we find, and use that section type
753 thereafter until we find another type. */
755 section_type
= s_none
;
757 /* For a class, if all members are private, there's no need
758 for a "private:" label; similarly, for a struct or union
759 masquerading as a class, if all members are public, there's
760 no need for a "public:" label. */
762 if (TYPE_DECLARED_CLASS (type
))
765 len
= TYPE_NFIELDS (type
);
766 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
767 if (!TYPE_FIELD_PRIVATE (type
, i
))
769 need_access_label
= 1;
773 if (!need_access_label
)
775 len2
= TYPE_NFN_FIELDS (type
);
776 for (j
= 0; j
< len2
; j
++)
778 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
779 for (i
= 0; i
< len
; i
++)
780 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
))
782 need_access_label
= 1;
785 if (need_access_label
)
793 len
= TYPE_NFIELDS (type
);
794 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
795 if (TYPE_FIELD_PRIVATE (type
, i
) || TYPE_FIELD_PROTECTED (type
, i
))
797 need_access_label
= 1;
801 if (!need_access_label
)
803 len2
= TYPE_NFN_FIELDS (type
);
804 for (j
= 0; j
< len2
; j
++)
807 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
808 for (i
= 0; i
< len
; i
++)
809 if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
)
810 || TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
, j
), i
))
812 need_access_label
= 1;
815 if (need_access_label
)
821 /* If there is a base class for this type,
822 do not print the field that it occupies. */
824 len
= TYPE_NFIELDS (type
);
825 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
826 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
830 /* If we have a virtual table pointer, omit it. Even if
831 virtual table pointers are not specifically marked in
832 the debug info, they should be artificial. */
833 if ((i
== vptr_fieldno
&& type
== basetype
)
834 || TYPE_FIELD_ARTIFICIAL (type
, i
))
837 if (need_access_label
)
839 if (TYPE_FIELD_PROTECTED (type
, i
))
841 if (section_type
!= s_protected
)
843 section_type
= s_protected
;
844 fprintfi_filtered (level
+ 2, stream
,
848 else if (TYPE_FIELD_PRIVATE (type
, i
))
850 if (section_type
!= s_private
)
852 section_type
= s_private
;
853 fprintfi_filtered (level
+ 2, stream
, "private:\n");
858 if (section_type
!= s_public
)
860 section_type
= s_public
;
861 fprintfi_filtered (level
+ 2, stream
, "public:\n");
866 print_spaces_filtered (level
+ 4, stream
);
867 if (field_is_static (&TYPE_FIELD (type
, i
)))
868 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 (!field_is_static (&TYPE_FIELD (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 blank line
887 between them. Make sure to count only method that we will
888 display; artificial methods will be hidden. */
889 len
= TYPE_NFN_FIELDS (type
);
891 for (i
= 0; i
< len
; i
++)
893 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
894 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
896 for (j
= 0; j
< len2
; j
++)
897 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
900 if (real_len
> 0 && section_type
!= s_none
)
901 fprintf_filtered (stream
, "\n");
903 /* C++: print out the methods */
904 for (i
= 0; i
< len
; i
++)
906 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
907 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
908 char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
909 char *name
= type_name_no_tag (type
);
910 int is_constructor
= name
&& strcmp (method_name
, name
) == 0;
911 for (j
= 0; j
< len2
; j
++)
913 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
914 int is_full_physname_constructor
=
915 is_constructor_name (physname
)
916 || is_destructor_name (physname
)
917 || method_name
[0] == '~';
919 /* Do not print out artificial methods. */
920 if (TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
924 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
926 if (section_type
!= s_protected
)
928 section_type
= s_protected
;
929 fprintfi_filtered (level
+ 2, stream
,
933 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
935 if (section_type
!= s_private
)
937 section_type
= s_private
;
938 fprintfi_filtered (level
+ 2, stream
, "private:\n");
943 if (section_type
!= s_public
)
945 section_type
= s_public
;
946 fprintfi_filtered (level
+ 2, stream
, "public:\n");
950 print_spaces_filtered (level
+ 4, stream
);
951 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
952 fprintf_filtered (stream
, "virtual ");
953 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
954 fprintf_filtered (stream
, "static ");
955 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
957 /* Keep GDB from crashing here. */
958 fprintf_filtered (stream
, _("<undefined type> %s;\n"),
959 TYPE_FN_FIELD_PHYSNAME (f
, j
));
962 else if (!is_constructor
/* constructors don't have declared types */
963 && !is_full_physname_constructor
/* " " */
964 && !is_type_conversion_operator (type
, i
, j
))
966 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
968 fputs_filtered (" ", stream
);
970 if (TYPE_FN_FIELD_STUB (f
, j
))
971 /* Build something we can demangle. */
972 mangled_name
= gdb_mangle_name (type
, i
, j
);
974 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
977 cplus_demangle (mangled_name
,
978 DMGL_ANSI
| DMGL_PARAMS
);
979 if (demangled_name
== NULL
)
981 /* in some cases (for instance with the HP demangling),
982 if a function has more than 10 arguments,
983 the demangling will fail.
984 Let's try to reconstruct the function signature from
985 the symbol information */
986 if (!TYPE_FN_FIELD_STUB (f
, j
))
988 int staticp
= TYPE_FN_FIELD_STATIC_P (f
, j
);
989 struct type
*mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
990 cp_type_print_method_args (mtype
,
997 fprintf_filtered (stream
, _("<badly mangled name '%s'>"),
1003 char *demangled_no_class
1004 = remove_qualifiers (demangled_name
);
1006 /* get rid of the `static' appended by the demangler */
1007 p
= strstr (demangled_no_class
, " static");
1010 int length
= p
- demangled_no_class
;
1011 demangled_no_static
= (char *) xmalloc (length
+ 1);
1012 strncpy (demangled_no_static
, demangled_no_class
, length
);
1013 *(demangled_no_static
+ length
) = '\0';
1014 fputs_filtered (demangled_no_static
, stream
);
1015 xfree (demangled_no_static
);
1018 fputs_filtered (demangled_no_class
, stream
);
1019 xfree (demangled_name
);
1022 if (TYPE_FN_FIELD_STUB (f
, j
))
1023 xfree (mangled_name
);
1025 fprintf_filtered (stream
, ";\n");
1029 fprintfi_filtered (level
, stream
, "}");
1031 if (TYPE_LOCALTYPE_PTR (type
) && show
>= 0)
1032 fprintfi_filtered (level
, stream
, _(" (Local at %s:%d)\n"),
1033 TYPE_LOCALTYPE_FILE (type
),
1034 TYPE_LOCALTYPE_LINE (type
));
1038 case TYPE_CODE_ENUM
:
1039 c_type_print_modifier (type
, stream
, 0, 1);
1040 fprintf_filtered (stream
, "enum ");
1041 /* Print the tag name if it exists.
1042 The aCC compiler emits a spurious
1043 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1044 tag for unnamed struct/union/enum's, which we don't
1046 if (TYPE_TAG_NAME (type
) != NULL
1047 && strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
1049 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1051 fputs_filtered (" ", stream
);
1057 /* If we just printed a tag name, no need to print anything else. */
1058 if (TYPE_TAG_NAME (type
) == NULL
)
1059 fprintf_filtered (stream
, "{...}");
1061 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1063 fprintf_filtered (stream
, "{");
1064 len
= TYPE_NFIELDS (type
);
1066 for (i
= 0; i
< len
; i
++)
1070 fprintf_filtered (stream
, ", ");
1072 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1073 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
1075 fprintf_filtered (stream
, " = %d", TYPE_FIELD_BITPOS (type
, i
));
1076 lastval
= TYPE_FIELD_BITPOS (type
, i
);
1080 fprintf_filtered (stream
, "}");
1084 case TYPE_CODE_VOID
:
1085 fprintf_filtered (stream
, "void");
1088 case TYPE_CODE_UNDEF
:
1089 fprintf_filtered (stream
, _("struct <unknown>"));
1092 case TYPE_CODE_ERROR
:
1093 fprintf_filtered (stream
, _("<unknown type>"));
1096 case TYPE_CODE_RANGE
:
1097 /* This should not occur */
1098 fprintf_filtered (stream
, _("<range type>"));
1101 case TYPE_CODE_NAMESPACE
:
1102 fputs_filtered ("namespace ", stream
);
1103 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1107 /* Handle types not explicitly handled by the other cases,
1108 such as fundamental types. For these, just print whatever
1109 the type name is, as recorded in the type itself. If there
1110 is no type name, then complain. */
1111 if (TYPE_NAME (type
) != NULL
)
1113 c_type_print_modifier (type
, stream
, 0, 1);
1114 fputs_filtered (TYPE_NAME (type
), stream
);
1118 /* At least for dump_symtab, it is important that this not be
1120 fprintf_filtered (stream
, _("<invalid type code %d>"),