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, 2011
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 c_type_print_varspec_prefix (struct type
*,
43 /* Print "const", "volatile", or address space modifiers. */
44 static void c_type_print_modifier (struct type
*,
48 /* LEVEL is the depth to indent lines by. */
51 c_print_type (struct type
*type
,
52 const char *varstring
,
53 struct ui_file
*stream
,
63 c_type_print_base (type
, stream
, show
, level
);
64 code
= TYPE_CODE (type
);
65 if ((varstring
!= NULL
&& *varstring
!= '\0')
66 /* Need a space if going to print stars or brackets;
67 but not if we will print just a type name. */
68 || ((show
> 0 || TYPE_NAME (type
) == 0)
69 && (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
70 || code
== TYPE_CODE_METHOD
71 || code
== TYPE_CODE_ARRAY
72 || code
== TYPE_CODE_MEMBERPTR
73 || code
== TYPE_CODE_METHODPTR
74 || code
== TYPE_CODE_REF
)))
75 fputs_filtered (" ", stream
);
76 need_post_space
= (varstring
!= NULL
&& strcmp (varstring
, "") != 0);
77 c_type_print_varspec_prefix (type
, stream
, show
, 0, need_post_space
);
79 if (varstring
!= NULL
)
81 fputs_filtered (varstring
, stream
);
83 /* For demangled function names, we have the arglist as part of
84 the name, so don't print an additional pair of ()'s. */
86 demangled_args
= strchr (varstring
, '(') != NULL
;
87 c_type_print_varspec_suffix (type
, stream
, show
,
92 /* Print a typedef using C syntax. TYPE is the underlying type.
93 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
97 c_print_typedef (struct type
*type
,
98 struct symbol
*new_symbol
,
99 struct ui_file
*stream
)
101 CHECK_TYPEDEF (type
);
102 fprintf_filtered (stream
, "typedef ");
103 type_print (type
, "", stream
, 0);
104 if (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))) == 0
105 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))),
106 SYMBOL_LINKAGE_NAME (new_symbol
)) != 0
107 || TYPE_CODE (SYMBOL_TYPE (new_symbol
)) == TYPE_CODE_TYPEDEF
)
108 fprintf_filtered (stream
, " %s", SYMBOL_PRINT_NAME (new_symbol
));
109 fprintf_filtered (stream
, ";\n");
112 /* If TYPE is a derived type, then print out derivation information.
113 Print only the actual base classes of this type, not the base
114 classes of the base classes. I.e. for the derivation hierarchy:
117 class B : public A {int b; };
118 class C : public B {int c; };
120 Print the type of class C as:
126 Not as the following (like gdb used to), which is not legal C++
127 syntax for derived types and may be confused with the multiple
130 class C : public B : public A {
134 In general, gdb should try to print the types as closely as
135 possible to the form that they appear in the source code.
137 Note that in case of protected derivation gcc will not say
138 'protected' but 'private'. The HP's aCC compiler emits specific
139 information for derivation via protected inheritance, so gdb can
143 cp_type_print_derivation_info (struct ui_file
*stream
,
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
)
154 ? "public" : (TYPE_FIELD_PROTECTED (type
, i
)
155 ? "protected" : "private"),
156 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
157 name
= type_name_no_tag (TYPE_BASECLASS (type
, i
));
158 fprintf_filtered (stream
, "%s", name
? name
: "(null)");
162 fputs_filtered (" ", stream
);
166 /* Print the C++ method arguments ARGS to the file STREAM. */
169 cp_type_print_method_args (struct type
*mtype
, char *prefix
,
170 char *varstring
, int staticp
,
171 struct ui_file
*stream
)
173 struct field
*args
= TYPE_FIELDS (mtype
);
174 int nargs
= TYPE_NFIELDS (mtype
);
175 int varargs
= TYPE_VARARGS (mtype
);
178 fprintf_symbol_filtered (stream
, prefix
,
179 language_cplus
, DMGL_ANSI
);
180 fprintf_symbol_filtered (stream
, varstring
,
181 language_cplus
, DMGL_ANSI
);
182 fputs_filtered ("(", stream
);
184 /* Skip the class variable. */
190 type_print (args
[i
++].type
, "", stream
, 0);
192 if (i
== nargs
&& varargs
)
193 fprintf_filtered (stream
, ", ...");
195 fprintf_filtered (stream
, ", ");
199 fprintf_filtered (stream
, "...");
200 else if (current_language
->la_language
== language_cplus
)
201 fprintf_filtered (stream
, "void");
203 fprintf_filtered (stream
, ")");
205 /* For non-static methods, read qualifiers from the type of
211 gdb_assert (nargs
> 0);
212 gdb_assert (TYPE_CODE (args
[0].type
) == TYPE_CODE_PTR
);
213 domain
= TYPE_TARGET_TYPE (args
[0].type
);
215 if (TYPE_CONST (domain
))
216 fprintf_filtered (stream
, " const");
218 if (TYPE_VOLATILE (domain
))
219 fprintf_filtered (stream
, " volatile");
224 /* Print any asterisks or open-parentheses needed before the
225 variable name (to describe its type).
227 On outermost call, pass 0 for PASSED_A_PTR.
228 On outermost call, SHOW > 0 means should ignore
229 any typename for TYPE and show its details.
230 SHOW is always zero on recursive calls.
232 NEED_POST_SPACE is non-zero when a space will be be needed
233 between a trailing qualifier and a field, variable, or function
237 c_type_print_varspec_prefix (struct type
*type
,
238 struct ui_file
*stream
,
239 int show
, int passed_a_ptr
,
247 if (TYPE_NAME (type
) && show
<= 0)
252 switch (TYPE_CODE (type
))
255 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
257 fprintf_filtered (stream
, "*");
258 c_type_print_modifier (type
, stream
, 1, need_post_space
);
261 case TYPE_CODE_MEMBERPTR
:
262 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
264 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
266 fputs_filtered (name
, stream
);
268 c_type_print_base (TYPE_DOMAIN_TYPE (type
),
269 stream
, 0, passed_a_ptr
);
270 fprintf_filtered (stream
, "::*");
273 case TYPE_CODE_METHODPTR
:
274 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
276 fprintf_filtered (stream
, "(");
277 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
279 fputs_filtered (name
, stream
);
281 c_type_print_base (TYPE_DOMAIN_TYPE (type
),
282 stream
, 0, passed_a_ptr
);
283 fprintf_filtered (stream
, "::*");
287 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
289 fprintf_filtered (stream
, "&");
290 c_type_print_modifier (type
, stream
, 1, need_post_space
);
293 case TYPE_CODE_METHOD
:
295 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
298 fprintf_filtered (stream
, "(");
301 case TYPE_CODE_ARRAY
:
302 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
305 fprintf_filtered (stream
, "(");
308 case TYPE_CODE_TYPEDEF
:
309 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
313 case TYPE_CODE_UNDEF
:
314 case TYPE_CODE_STRUCT
:
315 case TYPE_CODE_UNION
:
320 case TYPE_CODE_ERROR
:
324 case TYPE_CODE_RANGE
:
325 case TYPE_CODE_STRING
:
326 case TYPE_CODE_BITSTRING
:
327 case TYPE_CODE_COMPLEX
:
328 case TYPE_CODE_NAMESPACE
:
329 case TYPE_CODE_DECFLOAT
:
330 /* These types need no prefix. They are listed here so that
331 gcc -Wall will reveal any types that haven't been handled. */
334 error (_("type not handled in c_type_print_varspec_prefix()"));
339 /* Print out "const" and "volatile" attributes,
340 and address space id if present.
341 TYPE is a pointer to the type being printed out.
342 STREAM is the output destination.
343 NEED_PRE_SPACE = 1 indicates an initial white space is needed.
344 NEED_POST_SPACE = 1 indicates a final white space is needed. */
347 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
348 int need_pre_space
, int need_post_space
)
350 int did_print_modifier
= 0;
351 const char *address_space_id
;
353 /* We don't print `const' qualifiers for references --- since all
354 operators affect the thing referenced, not the reference itself,
355 every reference is `const'. */
356 if (TYPE_CONST (type
)
357 && TYPE_CODE (type
) != TYPE_CODE_REF
)
360 fprintf_filtered (stream
, " ");
361 fprintf_filtered (stream
, "const");
362 did_print_modifier
= 1;
365 if (TYPE_VOLATILE (type
))
367 if (did_print_modifier
|| need_pre_space
)
368 fprintf_filtered (stream
, " ");
369 fprintf_filtered (stream
, "volatile");
370 did_print_modifier
= 1;
373 address_space_id
= address_space_int_to_name (get_type_arch (type
),
374 TYPE_INSTANCE_FLAGS (type
));
375 if (address_space_id
)
377 if (did_print_modifier
|| need_pre_space
)
378 fprintf_filtered (stream
, " ");
379 fprintf_filtered (stream
, "@%s", address_space_id
);
380 did_print_modifier
= 1;
383 if (did_print_modifier
&& need_post_space
)
384 fprintf_filtered (stream
, " ");
388 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
389 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
390 in non-static methods, are displayed if SHOW_ARTIFICIAL is
391 non-zero. LANGUAGE is the language in which TYPE was defined.
392 This is a necessary evil since this code is used by the C, C++, and
396 c_type_print_args (struct type
*type
, struct ui_file
*stream
,
397 int show_artificial
, enum language language
)
403 fprintf_filtered (stream
, "(");
404 args
= TYPE_FIELDS (type
);
405 len
= TYPE_NFIELDS (type
);
407 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
409 if (TYPE_FIELD_ARTIFICIAL (type
, i
) && !show_artificial
)
414 fprintf_filtered (stream
, ", ");
418 if (language
== language_java
)
419 java_print_type (TYPE_FIELD_TYPE (type
, i
),
422 c_print_type (TYPE_FIELD_TYPE (type
, i
),
427 if (printed_any
&& TYPE_VARARGS (type
))
429 /* Print out a trailing ellipsis for varargs functions. Ignore
430 TYPE_VARARGS if the function has no named arguments; that
431 represents unprototyped (K&R style) C functions. */
432 if (printed_any
&& TYPE_VARARGS (type
))
434 fprintf_filtered (stream
, ", ");
436 fprintf_filtered (stream
, "...");
439 else if (!printed_any
440 && ((TYPE_PROTOTYPED (type
) && language
!= language_java
)
441 || language
== language_cplus
))
442 fprintf_filtered (stream
, "void");
444 fprintf_filtered (stream
, ")");
447 /* Return true iff the j'th overloading of the i'th method of TYPE
448 is a type conversion operator, like `operator int () { ... }'.
449 When listing a class's methods, we don't print the return type of
453 is_type_conversion_operator (struct type
*type
, int i
, int j
)
455 /* I think the whole idea of recognizing type conversion operators
456 by their name is pretty terrible. But I don't think our present
457 data structure gives us any other way to tell. If you know of
458 some other way, feel free to rewrite this function. */
459 char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
461 if (strncmp (name
, "operator", 8) != 0)
465 if (! strchr (" \t\f\n\r", *name
))
468 while (strchr (" \t\f\n\r", *name
))
471 if (!('a' <= *name
&& *name
<= 'z')
472 && !('A' <= *name
&& *name
<= 'Z')
474 /* If this doesn't look like the start of an identifier, then it
475 isn't a type conversion operator. */
477 else if (strncmp (name
, "new", 3) == 0)
479 else if (strncmp (name
, "delete", 6) == 0)
482 /* If it doesn't look like new or delete, it's a type conversion
486 /* Is that really the end of the name? */
487 if (('a' <= *name
&& *name
<= 'z')
488 || ('A' <= *name
&& *name
<= 'Z')
489 || ('0' <= *name
&& *name
<= '9')
491 /* No, so the identifier following "operator" must be a type name,
492 and this is a type conversion operator. */
495 /* That was indeed the end of the name, so it was `operator new' or
496 `operator delete', neither of which are type conversion
501 /* Given a C++ qualified identifier QID, strip off the qualifiers,
502 yielding the unqualified name. The return value is a pointer into
505 It's a pity we don't have this information in some more structured
506 form. Even the author of this function feels that writing little
507 parsers like this everywhere is stupid. */
510 remove_qualifiers (char *qid
)
512 int quoted
= 0; /* Zero if we're not in quotes;
513 '"' if we're in a double-quoted string;
514 '\'' if we're in a single-quoted string. */
515 int depth
= 0; /* Number of unclosed parens we've seen. */
516 char *parenstack
= (char *) alloca (strlen (qid
));
518 char *last
= 0; /* The character after the rightmost
519 `::' token we've seen so far. */
521 for (scan
= qid
; *scan
; scan
++)
527 else if (*scan
== '\\' && *(scan
+ 1))
530 else if (scan
[0] == ':' && scan
[1] == ':')
532 /* If we're inside parenthesis (i.e., an argument list) or
533 angle brackets (i.e., a list of template arguments), then
534 we don't record the position of this :: token, since it's
535 not relevant to the top-level structure we're trying to
543 else if (*scan
== '"' || *scan
== '\'')
545 else if (*scan
== '(')
546 parenstack
[depth
++] = ')';
547 else if (*scan
== '[')
548 parenstack
[depth
++] = ']';
549 /* We're going to treat <> as a pair of matching characters,
550 since we're more likely to see those in template id's than
551 real less-than characters. What a crock. */
552 else if (*scan
== '<')
553 parenstack
[depth
++] = '>';
554 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
556 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
560 /* We're going to do a little error recovery here. If
561 we don't find a match for *scan on the paren stack,
562 but there is something lower on the stack that does
563 match, we pop the stack to that point. */
566 for (i
= depth
- 1; i
>= 0; i
--)
567 if (parenstack
[i
] == *scan
)
579 /* We didn't find any :: tokens at the top level, so declare the
580 whole thing an unqualified identifier. */
584 /* Print any array sizes, function arguments or close parentheses
585 needed after the variable name (to describe its type).
586 Args work like c_type_print_varspec_prefix. */
589 c_type_print_varspec_suffix (struct type
*type
,
590 struct ui_file
*stream
,
591 int show
, int passed_a_ptr
,
597 if (TYPE_NAME (type
) && show
<= 0)
602 switch (TYPE_CODE (type
))
604 case TYPE_CODE_ARRAY
:
606 LONGEST low_bound
, high_bound
;
609 fprintf_filtered (stream
, ")");
611 fprintf_filtered (stream
, "[");
612 if (get_array_bounds (type
, &low_bound
, &high_bound
))
613 fprintf_filtered (stream
, "%d",
614 (int) (high_bound
- low_bound
+ 1));
615 fprintf_filtered (stream
, "]");
617 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
622 case TYPE_CODE_MEMBERPTR
:
623 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
627 case TYPE_CODE_METHODPTR
:
628 fprintf_filtered (stream
, ")");
629 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
635 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
639 case TYPE_CODE_METHOD
:
642 fprintf_filtered (stream
, ")");
644 c_type_print_args (type
, stream
, 1,
645 current_language
->la_language
);
646 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
647 show
, passed_a_ptr
, 0);
650 case TYPE_CODE_TYPEDEF
:
651 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
652 show
, passed_a_ptr
, 0);
655 case TYPE_CODE_UNDEF
:
656 case TYPE_CODE_STRUCT
:
657 case TYPE_CODE_UNION
:
662 case TYPE_CODE_ERROR
:
666 case TYPE_CODE_RANGE
:
667 case TYPE_CODE_STRING
:
668 case TYPE_CODE_BITSTRING
:
669 case TYPE_CODE_COMPLEX
:
670 case TYPE_CODE_NAMESPACE
:
671 case TYPE_CODE_DECFLOAT
:
672 /* These types do not need a suffix. They are listed so that
673 gcc -Wall will report types that may not have been
677 error (_("type not handled in c_type_print_varspec_suffix()"));
682 /* Print the name of the type (or the ultimate pointer target,
683 function value or array element), or the description of a structure
686 SHOW positive means print details about the type (e.g. enum
687 values), and print structure elements passing SHOW - 1 for show.
689 SHOW negative means just print the type name or struct tag if there
690 is one. If there is no name, print something sensible but concise
693 SHOW zero means just print the type name or struct tag if there is
694 one. If there is no name, print something sensible but not as
695 concise like "struct {int x; int y;}".
697 LEVEL is the number of spaces to indent by.
698 We increase it for some recursive calls. */
701 c_type_print_base (struct type
*type
, struct ui_file
*stream
,
708 char *demangled_name
;
709 char *demangled_no_static
;
712 s_none
, s_public
, s_private
, s_protected
715 int need_access_label
= 0;
723 fputs_filtered (_("<type unknown>"), stream
);
727 /* When SHOW is zero or less, and there is a valid type name, then
728 always just print the type name directly from the type. */
729 /* If we have "typedef struct foo {. . .} bar;" do we want to print
730 it as "struct foo" or as "bar"? Pick the latter, because C++
731 folk tend to expect things like "class5 *foo" rather than "struct
735 && TYPE_NAME (type
) != NULL
)
737 c_type_print_modifier (type
, stream
, 0, 1);
738 fputs_filtered (TYPE_NAME (type
), stream
);
742 CHECK_TYPEDEF (type
);
744 switch (TYPE_CODE (type
))
746 case TYPE_CODE_TYPEDEF
:
747 /* If we get here, the typedef doesn't have a name, and we
748 couldn't resolve TYPE_TARGET_TYPE. Not much we can do. */
749 gdb_assert (TYPE_NAME (type
) == NULL
);
750 gdb_assert (TYPE_TARGET_TYPE (type
) == NULL
);
751 fprintf_filtered (stream
, _("<unnamed typedef>"));
754 case TYPE_CODE_ARRAY
:
756 case TYPE_CODE_MEMBERPTR
:
759 case TYPE_CODE_METHOD
:
760 case TYPE_CODE_METHODPTR
:
761 c_type_print_base (TYPE_TARGET_TYPE (type
),
762 stream
, show
, level
);
765 case TYPE_CODE_STRUCT
:
766 c_type_print_modifier (type
, stream
, 0, 1);
767 if (TYPE_DECLARED_CLASS (type
))
768 fprintf_filtered (stream
, "class ");
770 fprintf_filtered (stream
, "struct ");
773 case TYPE_CODE_UNION
:
774 c_type_print_modifier (type
, stream
, 0, 1);
775 fprintf_filtered (stream
, "union ");
779 /* Print the tag if it exists. The HP aCC compiler emits a
780 spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
781 enum}" tag for unnamed struct/union/enum's, which we don't
783 if (TYPE_TAG_NAME (type
) != NULL
784 && strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
786 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
788 fputs_filtered (" ", stream
);
793 /* If we just printed a tag name, no need to print anything
795 if (TYPE_TAG_NAME (type
) == NULL
)
796 fprintf_filtered (stream
, "{...}");
798 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
800 struct type
*basetype
;
803 cp_type_print_derivation_info (stream
, type
);
805 fprintf_filtered (stream
, "{\n");
806 if (TYPE_NFIELDS (type
) == 0 && TYPE_NFN_FIELDS (type
) == 0
807 && TYPE_TYPEDEF_FIELD_COUNT (type
) == 0)
809 if (TYPE_STUB (type
))
810 fprintfi_filtered (level
+ 4, stream
,
811 _("<incomplete type>\n"));
813 fprintfi_filtered (level
+ 4, stream
,
814 _("<no data fields>\n"));
817 /* Start off with no specific section type, so we can print
818 one for the first field we find, and use that section type
819 thereafter until we find another type. */
821 section_type
= s_none
;
823 /* For a class, if all members are private, there's no need
824 for a "private:" label; similarly, for a struct or union
825 masquerading as a class, if all members are public, there's
826 no need for a "public:" label. */
828 if (TYPE_DECLARED_CLASS (type
))
831 len
= TYPE_NFIELDS (type
);
832 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
833 if (!TYPE_FIELD_PRIVATE (type
, i
))
835 need_access_label
= 1;
839 if (!need_access_label
)
841 len2
= TYPE_NFN_FIELDS (type
);
842 for (j
= 0; j
< len2
; j
++)
844 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
845 for (i
= 0; i
< len
; i
++)
846 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
,
849 need_access_label
= 1;
852 if (need_access_label
)
860 len
= TYPE_NFIELDS (type
);
861 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
862 if (TYPE_FIELD_PRIVATE (type
, i
)
863 || TYPE_FIELD_PROTECTED (type
, i
))
865 need_access_label
= 1;
869 if (!need_access_label
)
871 len2
= TYPE_NFN_FIELDS (type
);
872 for (j
= 0; j
< len2
; j
++)
875 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
876 for (i
= 0; i
< len
; i
++)
877 if (TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
,
879 || TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
,
883 need_access_label
= 1;
886 if (need_access_label
)
892 /* If there is a base class for this type,
893 do not print the field that it occupies. */
895 len
= TYPE_NFIELDS (type
);
896 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
897 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
901 /* If we have a virtual table pointer, omit it. Even if
902 virtual table pointers are not specifically marked in
903 the debug info, they should be artificial. */
904 if ((i
== vptr_fieldno
&& type
== basetype
)
905 || TYPE_FIELD_ARTIFICIAL (type
, i
))
908 if (need_access_label
)
910 if (TYPE_FIELD_PROTECTED (type
, i
))
912 if (section_type
!= s_protected
)
914 section_type
= s_protected
;
915 fprintfi_filtered (level
+ 2, stream
,
919 else if (TYPE_FIELD_PRIVATE (type
, i
))
921 if (section_type
!= s_private
)
923 section_type
= s_private
;
924 fprintfi_filtered (level
+ 2, stream
,
930 if (section_type
!= s_public
)
932 section_type
= s_public
;
933 fprintfi_filtered (level
+ 2, stream
,
939 print_spaces_filtered (level
+ 4, stream
);
940 if (field_is_static (&TYPE_FIELD (type
, i
)))
941 fprintf_filtered (stream
, "static ");
942 c_print_type (TYPE_FIELD_TYPE (type
, i
),
943 TYPE_FIELD_NAME (type
, i
),
944 stream
, show
- 1, level
+ 4);
945 if (!field_is_static (&TYPE_FIELD (type
, i
))
946 && TYPE_FIELD_PACKED (type
, i
))
948 /* It is a bitfield. This code does not attempt
949 to look at the bitpos and reconstruct filler,
950 unnamed fields. This would lead to misleading
951 results if the compiler does not put out fields
952 for such things (I don't know what it does). */
953 fprintf_filtered (stream
, " : %d",
954 TYPE_FIELD_BITSIZE (type
, i
));
956 fprintf_filtered (stream
, ";\n");
959 /* If there are both fields and methods, put a blank line
960 between them. Make sure to count only method that we
961 will display; artificial methods will be hidden. */
962 len
= TYPE_NFN_FIELDS (type
);
964 for (i
= 0; i
< len
; i
++)
966 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
967 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
970 for (j
= 0; j
< len2
; j
++)
971 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
974 if (real_len
> 0 && section_type
!= s_none
)
975 fprintf_filtered (stream
, "\n");
977 /* C++: print out the methods. */
978 for (i
= 0; i
< len
; i
++)
980 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
981 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
982 char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
983 char *name
= type_name_no_tag (type
);
984 int is_constructor
= name
&& strcmp (method_name
,
987 for (j
= 0; j
< len2
; j
++)
989 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
990 int is_full_physname_constructor
=
991 is_constructor_name (physname
)
992 || is_destructor_name (physname
)
993 || method_name
[0] == '~';
995 /* Do not print out artificial methods. */
996 if (TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
1000 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
1002 if (section_type
!= s_protected
)
1004 section_type
= s_protected
;
1005 fprintfi_filtered (level
+ 2, stream
,
1009 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
1011 if (section_type
!= s_private
)
1013 section_type
= s_private
;
1014 fprintfi_filtered (level
+ 2, stream
,
1020 if (section_type
!= s_public
)
1022 section_type
= s_public
;
1023 fprintfi_filtered (level
+ 2, stream
,
1028 print_spaces_filtered (level
+ 4, stream
);
1029 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1030 fprintf_filtered (stream
, "virtual ");
1031 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
1032 fprintf_filtered (stream
, "static ");
1033 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
1035 /* Keep GDB from crashing here. */
1036 fprintf_filtered (stream
,
1037 _("<undefined type> %s;\n"),
1038 TYPE_FN_FIELD_PHYSNAME (f
, j
));
1041 else if (!is_constructor
/* Constructors don't
1044 && !is_full_physname_constructor
/* " " */
1045 && !is_type_conversion_operator (type
, i
, j
))
1047 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
1049 fputs_filtered (" ", stream
);
1051 if (TYPE_FN_FIELD_STUB (f
, j
))
1052 /* Build something we can demangle. */
1053 mangled_name
= gdb_mangle_name (type
, i
, j
);
1055 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1058 cplus_demangle (mangled_name
,
1059 DMGL_ANSI
| DMGL_PARAMS
);
1060 if (demangled_name
== NULL
)
1062 /* In some cases (for instance with the HP
1063 demangling), if a function has more than 10
1064 arguments, the demangling will fail.
1065 Let's try to reconstruct the function
1066 signature from the symbol information. */
1067 if (!TYPE_FN_FIELD_STUB (f
, j
))
1069 int staticp
= TYPE_FN_FIELD_STATIC_P (f
, j
);
1070 struct type
*mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1072 cp_type_print_method_args (mtype
,
1079 fprintf_filtered (stream
,
1080 _("<badly mangled name '%s'>"),
1086 char *demangled_no_class
1087 = remove_qualifiers (demangled_name
);
1089 /* Get rid of the `static' appended by the
1091 p
= strstr (demangled_no_class
, " static");
1094 int length
= p
- demangled_no_class
;
1097 = (char *) xmalloc (length
+ 1);
1098 strncpy (demangled_no_static
,
1099 demangled_no_class
, length
);
1100 *(demangled_no_static
+ length
) = '\0';
1101 fputs_filtered (demangled_no_static
, stream
);
1102 xfree (demangled_no_static
);
1105 fputs_filtered (demangled_no_class
, stream
);
1106 xfree (demangled_name
);
1109 if (TYPE_FN_FIELD_STUB (f
, j
))
1110 xfree (mangled_name
);
1112 fprintf_filtered (stream
, ";\n");
1116 /* Print typedefs defined in this class. */
1118 if (TYPE_TYPEDEF_FIELD_COUNT (type
) != 0)
1120 if (TYPE_NFIELDS (type
) != 0 || TYPE_NFN_FIELDS (type
) != 0)
1121 fprintf_filtered (stream
, "\n");
1123 for (i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (type
); i
++)
1125 struct type
*target
= TYPE_TYPEDEF_FIELD_TYPE (type
, i
);
1127 /* Dereference the typedef declaration itself. */
1128 gdb_assert (TYPE_CODE (target
) == TYPE_CODE_TYPEDEF
);
1129 target
= TYPE_TARGET_TYPE (target
);
1131 print_spaces_filtered (level
+ 4, stream
);
1132 fprintf_filtered (stream
, "typedef ");
1133 c_print_type (target
, TYPE_TYPEDEF_FIELD_NAME (type
, i
),
1134 stream
, show
- 1, level
+ 4);
1135 fprintf_filtered (stream
, ";\n");
1139 fprintfi_filtered (level
, stream
, "}");
1141 if (TYPE_LOCALTYPE_PTR (type
) && show
>= 0)
1142 fprintfi_filtered (level
,
1143 stream
, _(" (Local at %s:%d)\n"),
1144 TYPE_LOCALTYPE_FILE (type
),
1145 TYPE_LOCALTYPE_LINE (type
));
1149 case TYPE_CODE_ENUM
:
1150 c_type_print_modifier (type
, stream
, 0, 1);
1151 fprintf_filtered (stream
, "enum ");
1152 /* Print the tag name if it exists.
1153 The aCC compiler emits a spurious
1154 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1155 tag for unnamed struct/union/enum's, which we don't
1157 if (TYPE_TAG_NAME (type
) != NULL
1158 && strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
1160 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1162 fputs_filtered (" ", stream
);
1168 /* If we just printed a tag name, no need to print anything
1170 if (TYPE_TAG_NAME (type
) == NULL
)
1171 fprintf_filtered (stream
, "{...}");
1173 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1175 fprintf_filtered (stream
, "{");
1176 len
= TYPE_NFIELDS (type
);
1178 for (i
= 0; i
< len
; i
++)
1182 fprintf_filtered (stream
, ", ");
1184 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1185 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
1187 fprintf_filtered (stream
, " = %d",
1188 TYPE_FIELD_BITPOS (type
, i
));
1189 lastval
= TYPE_FIELD_BITPOS (type
, i
);
1193 fprintf_filtered (stream
, "}");
1197 case TYPE_CODE_VOID
:
1198 fprintf_filtered (stream
, "void");
1201 case TYPE_CODE_UNDEF
:
1202 fprintf_filtered (stream
, _("struct <unknown>"));
1205 case TYPE_CODE_ERROR
:
1206 fprintf_filtered (stream
, "%s", TYPE_ERROR_NAME (type
));
1209 case TYPE_CODE_RANGE
:
1210 /* This should not occur. */
1211 fprintf_filtered (stream
, _("<range type>"));
1214 case TYPE_CODE_NAMESPACE
:
1215 fputs_filtered ("namespace ", stream
);
1216 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1220 /* Handle types not explicitly handled by the other cases, such
1221 as fundamental types. For these, just print whatever the
1222 type name is, as recorded in the type itself. If there is no
1223 type name, then complain. */
1224 if (TYPE_NAME (type
) != NULL
)
1226 c_type_print_modifier (type
, stream
, 0, 1);
1227 fputs_filtered (TYPE_NAME (type
), stream
);
1231 /* At least for dump_symtab, it is important that this not
1233 fprintf_filtered (stream
, _("<invalid type code %d>"),