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"
37 #include "gdb_string.h"
40 static void cp_type_print_method_args (struct type
*mtype
, char *prefix
,
41 char *varstring
, int staticp
,
42 struct ui_file
*stream
);
44 static void cp_type_print_derivation_info (struct ui_file
*, struct type
*);
46 static void c_type_print_varspec_prefix (struct type
*, struct ui_file
*, int,
49 /* Print "const", "volatile", or address space modifiers. */
50 static void c_type_print_modifier (struct type
*, struct ui_file
*,
56 /* LEVEL is the depth to indent lines by. */
59 c_print_type (struct type
*type
, char *varstring
, struct ui_file
*stream
,
69 c_type_print_base (type
, stream
, show
, level
);
70 code
= TYPE_CODE (type
);
71 if ((varstring
!= NULL
&& *varstring
!= '\0')
72 /* Need a space if going to print stars or brackets;
73 but not if we will print just a type name. */
74 || ((show
> 0 || TYPE_NAME (type
) == 0)
75 && (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
76 || code
== TYPE_CODE_METHOD
77 || code
== TYPE_CODE_ARRAY
78 || code
== TYPE_CODE_MEMBERPTR
79 || code
== TYPE_CODE_METHODPTR
80 || code
== TYPE_CODE_REF
)))
81 fputs_filtered (" ", stream
);
82 need_post_space
= (varstring
!= NULL
&& strcmp (varstring
, "") != 0);
83 c_type_print_varspec_prefix (type
, stream
, show
, 0, need_post_space
);
85 if (varstring
!= NULL
)
87 fputs_filtered (varstring
, stream
);
89 /* For demangled function names, we have the arglist as part of the name,
90 so don't print an additional pair of ()'s */
92 demangled_args
= strchr (varstring
, '(') != NULL
;
93 c_type_print_varspec_suffix (type
, stream
, show
, 0, demangled_args
);
97 /* Print a typedef using C syntax. TYPE is the underlying type.
98 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
102 c_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
103 struct ui_file
*stream
)
105 CHECK_TYPEDEF (type
);
106 fprintf_filtered (stream
, "typedef ");
107 type_print (type
, "", stream
, 0);
108 if (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))) == 0
109 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))),
110 SYMBOL_LINKAGE_NAME (new_symbol
)) != 0)
111 fprintf_filtered (stream
, " %s", SYMBOL_PRINT_NAME (new_symbol
));
112 fprintf_filtered (stream
, ";\n");
115 /* If TYPE is a derived type, then print out derivation information.
116 Print only the actual base classes of this type, not the base classes
117 of the base classes. I.E. for the derivation hierarchy:
120 class B : public A {int b; };
121 class C : public B {int c; };
123 Print the type of class C as:
129 Not as the following (like gdb used to), which is not legal C++ syntax for
130 derived types and may be confused with the multiple inheritance form:
132 class C : public B : public A {
136 In general, gdb should try to print the types as closely as possible to
137 the form that they appear in the source code.
138 Note that in case of protected derivation gcc will not say 'protected'
139 but 'private'. The HP's aCC compiler emits specific information for
140 derivation via protected inheritance, so gdb can print it out */
143 cp_type_print_derivation_info (struct ui_file
*stream
, struct type
*type
)
148 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
150 fputs_filtered (i
== 0 ? ": " : ", ", stream
);
151 fprintf_filtered (stream
, "%s%s ",
152 BASETYPE_VIA_PUBLIC (type
, i
) ? "public"
153 : (TYPE_FIELD_PROTECTED (type
, i
) ? "protected" : "private"),
154 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
155 name
= type_name_no_tag (TYPE_BASECLASS (type
, i
));
156 fprintf_filtered (stream
, "%s", name
? name
: "(null)");
160 fputs_filtered (" ", stream
);
164 /* Print the C++ method arguments ARGS to the file STREAM. */
167 cp_type_print_method_args (struct type
*mtype
, char *prefix
, char *varstring
,
168 int staticp
, struct ui_file
*stream
)
170 struct field
*args
= TYPE_FIELDS (mtype
);
171 int nargs
= TYPE_NFIELDS (mtype
);
172 int varargs
= TYPE_VARARGS (mtype
);
175 fprintf_symbol_filtered (stream
, prefix
, language_cplus
, DMGL_ANSI
);
176 fprintf_symbol_filtered (stream
, varstring
, language_cplus
, DMGL_ANSI
);
177 fputs_filtered ("(", stream
);
179 /* Skip the class variable. */
185 type_print (args
[i
++].type
, "", stream
, 0);
187 if (i
== nargs
&& varargs
)
188 fprintf_filtered (stream
, ", ...");
190 fprintf_filtered (stream
, ", ");
194 fprintf_filtered (stream
, "...");
195 else if (current_language
->la_language
== language_cplus
)
196 fprintf_filtered (stream
, "void");
198 fprintf_filtered (stream
, ")");
200 /* For non-static methods, read qualifiers from the type of
206 gdb_assert (nargs
> 0);
207 gdb_assert (TYPE_CODE (args
[0].type
) == TYPE_CODE_PTR
);
208 domain
= TYPE_TARGET_TYPE (args
[0].type
);
210 if (TYPE_CONST (domain
))
211 fprintf_filtered (stream
, " const");
213 if (TYPE_VOLATILE (domain
))
214 fprintf_filtered (stream
, " volatile");
219 /* Print any asterisks or open-parentheses needed before the
220 variable name (to describe its type).
222 On outermost call, pass 0 for PASSED_A_PTR.
223 On outermost call, SHOW > 0 means should ignore
224 any typename for TYPE and show its details.
225 SHOW is always zero on recursive calls.
227 NEED_POST_SPACE is non-zero when a space will be be needed
228 between a trailing qualifier and a field, variable, or function
232 c_type_print_varspec_prefix (struct type
*type
, struct ui_file
*stream
,
233 int show
, int passed_a_ptr
, int need_post_space
)
239 if (TYPE_NAME (type
) && show
<= 0)
244 switch (TYPE_CODE (type
))
247 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 1, 1);
248 fprintf_filtered (stream
, "*");
249 c_type_print_modifier (type
, stream
, 1, need_post_space
);
252 case TYPE_CODE_MEMBERPTR
:
253 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
254 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
256 fputs_filtered (name
, stream
);
258 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
259 fprintf_filtered (stream
, "::*");
262 case TYPE_CODE_METHODPTR
:
263 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
264 fprintf_filtered (stream
, "(");
265 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
267 fputs_filtered (name
, stream
);
269 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
270 fprintf_filtered (stream
, "::*");
274 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 1, 0);
275 fprintf_filtered (stream
, "&");
276 c_type_print_modifier (type
, stream
, 1, need_post_space
);
279 case TYPE_CODE_METHOD
:
281 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
283 fprintf_filtered (stream
, "(");
286 case TYPE_CODE_ARRAY
:
287 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
289 fprintf_filtered (stream
, "(");
292 case TYPE_CODE_TYPEDEF
:
293 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
296 case TYPE_CODE_UNDEF
:
297 case TYPE_CODE_STRUCT
:
298 case TYPE_CODE_UNION
:
303 case TYPE_CODE_ERROR
:
307 case TYPE_CODE_RANGE
:
308 case TYPE_CODE_STRING
:
309 case TYPE_CODE_BITSTRING
:
310 case TYPE_CODE_COMPLEX
:
311 case TYPE_CODE_NAMESPACE
:
312 case TYPE_CODE_DECFLOAT
:
313 /* These types need no prefix. They are listed here so that
314 gcc -Wall will reveal any types that haven't been handled. */
317 error (_("type not handled in c_type_print_varspec_prefix()"));
322 /* Print out "const" and "volatile" attributes.
323 TYPE is a pointer to the type being printed out.
324 STREAM is the output destination.
325 NEED_SPACE = 1 indicates an initial white space is needed */
328 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
329 int need_pre_space
, int need_post_space
)
331 int did_print_modifier
= 0;
332 const char *address_space_id
;
334 /* We don't print `const' qualifiers for references --- since all
335 operators affect the thing referenced, not the reference itself,
336 every reference is `const'. */
337 if (TYPE_CONST (type
)
338 && TYPE_CODE (type
) != TYPE_CODE_REF
)
341 fprintf_filtered (stream
, " ");
342 fprintf_filtered (stream
, "const");
343 did_print_modifier
= 1;
346 if (TYPE_VOLATILE (type
))
348 if (did_print_modifier
|| need_pre_space
)
349 fprintf_filtered (stream
, " ");
350 fprintf_filtered (stream
, "volatile");
351 did_print_modifier
= 1;
354 address_space_id
= address_space_int_to_name (get_type_arch (type
),
355 TYPE_INSTANCE_FLAGS (type
));
356 if (address_space_id
)
358 if (did_print_modifier
|| need_pre_space
)
359 fprintf_filtered (stream
, " ");
360 fprintf_filtered (stream
, "@%s", address_space_id
);
361 did_print_modifier
= 1;
364 if (did_print_modifier
&& need_post_space
)
365 fprintf_filtered (stream
, " ");
369 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
370 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
371 in non-static methods, are displayed if SHOW_ARTIFICIAL is
372 non-zero. LANGUAGE is the language in which TYPE was defined. This is
373 a necessary evil since this code is used by the C, C++, and Java
377 c_type_print_args (struct type
*type
, struct ui_file
*stream
,
378 int show_artificial
, enum language language
)
384 fprintf_filtered (stream
, "(");
385 args
= TYPE_FIELDS (type
);
386 len
= TYPE_NFIELDS (type
);
388 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
390 if (TYPE_FIELD_ARTIFICIAL (type
, i
) && !show_artificial
)
395 fprintf_filtered (stream
, ", ");
399 if (language
== language_java
)
400 java_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
402 c_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
406 if (printed_any
&& TYPE_VARARGS (type
))
408 /* Print out a trailing ellipsis for varargs functions. Ignore
409 TYPE_VARARGS if the function has no named arguments; that
410 represents unprototyped (K&R style) C functions. */
411 if (printed_any
&& TYPE_VARARGS (type
))
413 fprintf_filtered (stream
, ", ");
415 fprintf_filtered (stream
, "...");
418 else if (!printed_any
419 && (TYPE_PROTOTYPED (type
)
420 || current_language
->la_language
== language_cplus
))
421 fprintf_filtered (stream
, "void");
423 fprintf_filtered (stream
, ")");
427 /* Return true iff the j'th overloading of the i'th method of TYPE
428 is a type conversion operator, like `operator int () { ... }'.
429 When listing a class's methods, we don't print the return type of
432 is_type_conversion_operator (struct type
*type
, int i
, int j
)
434 /* I think the whole idea of recognizing type conversion operators
435 by their name is pretty terrible. But I don't think our present
436 data structure gives us any other way to tell. If you know of
437 some other way, feel free to rewrite this function. */
438 char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
440 if (strncmp (name
, "operator", 8) != 0)
444 if (! strchr (" \t\f\n\r", *name
))
447 while (strchr (" \t\f\n\r", *name
))
450 if (!('a' <= *name
&& *name
<= 'z')
451 && !('A' <= *name
&& *name
<= 'Z')
453 /* If this doesn't look like the start of an identifier, then it
454 isn't a type conversion operator. */
456 else if (strncmp (name
, "new", 3) == 0)
458 else if (strncmp (name
, "delete", 6) == 0)
461 /* If it doesn't look like new or delete, it's a type conversion
465 /* Is that really the end of the name? */
466 if (('a' <= *name
&& *name
<= 'z')
467 || ('A' <= *name
&& *name
<= 'Z')
468 || ('0' <= *name
&& *name
<= '9')
470 /* No, so the identifier following "operator" must be a type name,
471 and this is a type conversion operator. */
474 /* That was indeed the end of the name, so it was `operator new' or
475 `operator delete', neither of which are type conversion operators. */
480 /* Given a C++ qualified identifier QID, strip off the qualifiers,
481 yielding the unqualified name. The return value is a pointer into
484 It's a pity we don't have this information in some more structured
485 form. Even the author of this function feels that writing little
486 parsers like this everywhere is stupid. */
488 remove_qualifiers (char *qid
)
490 int quoted
= 0; /* zero if we're not in quotes;
491 '"' if we're in a double-quoted string;
492 '\'' if we're in a single-quoted string. */
493 int depth
= 0; /* number of unclosed parens we've seen */
494 char *parenstack
= (char *) alloca (strlen (qid
));
496 char *last
= 0; /* The character after the rightmost
497 `::' token we've seen so far. */
499 for (scan
= qid
; *scan
; scan
++)
505 else if (*scan
== '\\' && *(scan
+ 1))
508 else if (scan
[0] == ':' && scan
[1] == ':')
510 /* If we're inside parenthesis (i.e., an argument list) or
511 angle brackets (i.e., a list of template arguments), then
512 we don't record the position of this :: token, since it's
513 not relevant to the top-level structure we're trying
521 else if (*scan
== '"' || *scan
== '\'')
523 else if (*scan
== '(')
524 parenstack
[depth
++] = ')';
525 else if (*scan
== '[')
526 parenstack
[depth
++] = ']';
527 /* We're going to treat <> as a pair of matching characters,
528 since we're more likely to see those in template id's than
529 real less-than characters. What a crock. */
530 else if (*scan
== '<')
531 parenstack
[depth
++] = '>';
532 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
534 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
538 /* We're going to do a little error recovery here. If we
539 don't find a match for *scan on the paren stack, but
540 there is something lower on the stack that does match, we
541 pop the stack to that point. */
544 for (i
= depth
- 1; i
>= 0; i
--)
545 if (parenstack
[i
] == *scan
)
557 /* We didn't find any :: tokens at the top level, so declare the
558 whole thing an unqualified identifier. */
563 /* Print any array sizes, function arguments or close parentheses
564 needed after the variable name (to describe its type).
565 Args work like c_type_print_varspec_prefix. */
568 c_type_print_varspec_suffix (struct type
*type
, struct ui_file
*stream
,
569 int show
, int passed_a_ptr
, int demangled_args
)
574 if (TYPE_NAME (type
) && show
<= 0)
579 switch (TYPE_CODE (type
))
581 case TYPE_CODE_ARRAY
:
583 fprintf_filtered (stream
, ")");
585 fprintf_filtered (stream
, "[");
586 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0
587 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))
588 fprintf_filtered (stream
, "%d",
590 / TYPE_LENGTH (TYPE_TARGET_TYPE (type
))));
591 fprintf_filtered (stream
, "]");
593 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
597 case TYPE_CODE_MEMBERPTR
:
598 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
602 case TYPE_CODE_METHODPTR
:
603 fprintf_filtered (stream
, ")");
604 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
610 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
614 case TYPE_CODE_METHOD
:
617 fprintf_filtered (stream
, ")");
619 c_type_print_args (type
, stream
, 1, language_c
);
620 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
624 case TYPE_CODE_TYPEDEF
:
625 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
629 case TYPE_CODE_UNDEF
:
630 case TYPE_CODE_STRUCT
:
631 case TYPE_CODE_UNION
:
636 case TYPE_CODE_ERROR
:
640 case TYPE_CODE_RANGE
:
641 case TYPE_CODE_STRING
:
642 case TYPE_CODE_BITSTRING
:
643 case TYPE_CODE_COMPLEX
:
644 case TYPE_CODE_NAMESPACE
:
645 case TYPE_CODE_DECFLOAT
:
646 /* These types do not need a suffix. They are listed so that
647 gcc -Wall will report types that may not have been considered. */
650 error (_("type not handled in c_type_print_varspec_suffix()"));
655 /* Print the name of the type (or the ultimate pointer target,
656 function value or array element), or the description of a
659 SHOW positive means print details about the type (e.g. enum values),
660 and print structure elements passing SHOW - 1 for show.
661 SHOW negative means just print the type name or struct tag if there is one.
662 If there is no name, print something sensible but concise like
664 SHOW zero means just print the type name or struct tag if there is one.
665 If there is no name, print something sensible but not as concise like
666 "struct {int x; int y;}".
668 LEVEL is the number of spaces to indent by.
669 We increase it for some recursive calls. */
672 c_type_print_base (struct type
*type
, struct ui_file
*stream
, int show
,
679 char *demangled_name
;
680 char *demangled_no_static
;
683 s_none
, s_public
, s_private
, s_protected
686 int need_access_label
= 0;
694 fputs_filtered (_("<type unknown>"), stream
);
698 /* When SHOW is zero or less, and there is a valid type name, then always
699 just print the type name directly from the type. */
700 /* If we have "typedef struct foo {. . .} bar;" do we want to print it
701 as "struct foo" or as "bar"? Pick the latter, because C++ folk tend
702 to expect things like "class5 *foo" rather than "struct class5 *foo". */
705 && TYPE_NAME (type
) != NULL
)
707 c_type_print_modifier (type
, stream
, 0, 1);
708 fputs_filtered (TYPE_NAME (type
), stream
);
712 CHECK_TYPEDEF (type
);
714 switch (TYPE_CODE (type
))
716 case TYPE_CODE_TYPEDEF
:
717 case TYPE_CODE_ARRAY
:
719 case TYPE_CODE_MEMBERPTR
:
722 case TYPE_CODE_METHOD
:
723 case TYPE_CODE_METHODPTR
:
724 c_type_print_base (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
727 case TYPE_CODE_STRUCT
:
728 c_type_print_modifier (type
, stream
, 0, 1);
729 if (TYPE_DECLARED_CLASS (type
))
730 fprintf_filtered (stream
, "class ");
732 fprintf_filtered (stream
, "struct ");
735 case TYPE_CODE_UNION
:
736 c_type_print_modifier (type
, stream
, 0, 1);
737 fprintf_filtered (stream
, "union ");
741 /* Print the tag if it exists.
742 * The HP aCC compiler emits
743 * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
744 * tag for unnamed struct/union/enum's, which we don't
747 if (TYPE_TAG_NAME (type
) != NULL
748 && strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
750 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
752 fputs_filtered (" ", stream
);
757 /* If we just printed a tag name, no need to print anything else. */
758 if (TYPE_TAG_NAME (type
) == NULL
)
759 fprintf_filtered (stream
, "{...}");
761 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
763 struct type
*basetype
;
766 cp_type_print_derivation_info (stream
, type
);
768 fprintf_filtered (stream
, "{\n");
769 if ((TYPE_NFIELDS (type
) == 0) && (TYPE_NFN_FIELDS (type
) == 0))
771 if (TYPE_STUB (type
))
772 fprintfi_filtered (level
+ 4, stream
, _("<incomplete type>\n"));
774 fprintfi_filtered (level
+ 4, stream
, _("<no data fields>\n"));
777 /* Start off with no specific section type, so we can print
778 one for the first field we find, and use that section type
779 thereafter until we find another type. */
781 section_type
= s_none
;
783 /* For a class, if all members are private, there's no need
784 for a "private:" label; similarly, for a struct or union
785 masquerading as a class, if all members are public, there's
786 no need for a "public:" label. */
788 if (TYPE_DECLARED_CLASS (type
))
791 len
= TYPE_NFIELDS (type
);
792 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
793 if (!TYPE_FIELD_PRIVATE (type
, i
))
795 need_access_label
= 1;
799 if (!need_access_label
)
801 len2
= TYPE_NFN_FIELDS (type
);
802 for (j
= 0; j
< len2
; j
++)
804 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
805 for (i
= 0; i
< len
; i
++)
806 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
))
808 need_access_label
= 1;
811 if (need_access_label
)
819 len
= TYPE_NFIELDS (type
);
820 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
821 if (TYPE_FIELD_PRIVATE (type
, i
) || TYPE_FIELD_PROTECTED (type
, i
))
823 need_access_label
= 1;
827 if (!need_access_label
)
829 len2
= TYPE_NFN_FIELDS (type
);
830 for (j
= 0; j
< len2
; j
++)
833 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
834 for (i
= 0; i
< len
; i
++)
835 if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
)
836 || TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
, j
), i
))
838 need_access_label
= 1;
841 if (need_access_label
)
847 /* If there is a base class for this type,
848 do not print the field that it occupies. */
850 len
= TYPE_NFIELDS (type
);
851 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
852 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
856 /* If we have a virtual table pointer, omit it. Even if
857 virtual table pointers are not specifically marked in
858 the debug info, they should be artificial. */
859 if ((i
== vptr_fieldno
&& type
== basetype
)
860 || TYPE_FIELD_ARTIFICIAL (type
, i
))
863 if (need_access_label
)
865 if (TYPE_FIELD_PROTECTED (type
, i
))
867 if (section_type
!= s_protected
)
869 section_type
= s_protected
;
870 fprintfi_filtered (level
+ 2, stream
,
874 else if (TYPE_FIELD_PRIVATE (type
, i
))
876 if (section_type
!= s_private
)
878 section_type
= s_private
;
879 fprintfi_filtered (level
+ 2, stream
, "private:\n");
884 if (section_type
!= s_public
)
886 section_type
= s_public
;
887 fprintfi_filtered (level
+ 2, stream
, "public:\n");
892 print_spaces_filtered (level
+ 4, stream
);
893 if (field_is_static (&TYPE_FIELD (type
, i
)))
894 fprintf_filtered (stream
, "static ");
895 c_print_type (TYPE_FIELD_TYPE (type
, i
),
896 TYPE_FIELD_NAME (type
, i
),
897 stream
, show
- 1, level
+ 4);
898 if (!field_is_static (&TYPE_FIELD (type
, i
))
899 && TYPE_FIELD_PACKED (type
, i
))
901 /* It is a bitfield. This code does not attempt
902 to look at the bitpos and reconstruct filler,
903 unnamed fields. This would lead to misleading
904 results if the compiler does not put out fields
905 for such things (I don't know what it does). */
906 fprintf_filtered (stream
, " : %d",
907 TYPE_FIELD_BITSIZE (type
, i
));
909 fprintf_filtered (stream
, ";\n");
912 /* If there are both fields and methods, put a blank line
913 between them. Make sure to count only method that we will
914 display; artificial methods will be hidden. */
915 len
= TYPE_NFN_FIELDS (type
);
917 for (i
= 0; i
< len
; i
++)
919 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
920 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
922 for (j
= 0; j
< len2
; j
++)
923 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
926 if (real_len
> 0 && section_type
!= s_none
)
927 fprintf_filtered (stream
, "\n");
929 /* C++: print out the methods */
930 for (i
= 0; i
< len
; i
++)
932 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
933 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
934 char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
935 char *name
= type_name_no_tag (type
);
936 int is_constructor
= name
&& strcmp (method_name
, name
) == 0;
937 for (j
= 0; j
< len2
; j
++)
939 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
940 int is_full_physname_constructor
=
941 is_constructor_name (physname
)
942 || is_destructor_name (physname
)
943 || method_name
[0] == '~';
945 /* Do not print out artificial methods. */
946 if (TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
950 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
952 if (section_type
!= s_protected
)
954 section_type
= s_protected
;
955 fprintfi_filtered (level
+ 2, stream
,
959 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
961 if (section_type
!= s_private
)
963 section_type
= s_private
;
964 fprintfi_filtered (level
+ 2, stream
, "private:\n");
969 if (section_type
!= s_public
)
971 section_type
= s_public
;
972 fprintfi_filtered (level
+ 2, stream
, "public:\n");
976 print_spaces_filtered (level
+ 4, stream
);
977 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
978 fprintf_filtered (stream
, "virtual ");
979 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
980 fprintf_filtered (stream
, "static ");
981 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
983 /* Keep GDB from crashing here. */
984 fprintf_filtered (stream
, _("<undefined type> %s;\n"),
985 TYPE_FN_FIELD_PHYSNAME (f
, j
));
988 else if (!is_constructor
/* constructors don't have declared types */
989 && !is_full_physname_constructor
/* " " */
990 && !is_type_conversion_operator (type
, i
, j
))
992 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
994 fputs_filtered (" ", stream
);
996 if (TYPE_FN_FIELD_STUB (f
, j
))
997 /* Build something we can demangle. */
998 mangled_name
= gdb_mangle_name (type
, i
, j
);
1000 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1003 cplus_demangle (mangled_name
,
1004 DMGL_ANSI
| DMGL_PARAMS
);
1005 if (demangled_name
== NULL
)
1007 /* in some cases (for instance with the HP demangling),
1008 if a function has more than 10 arguments,
1009 the demangling will fail.
1010 Let's try to reconstruct the function signature from
1011 the symbol information */
1012 if (!TYPE_FN_FIELD_STUB (f
, j
))
1014 int staticp
= TYPE_FN_FIELD_STATIC_P (f
, j
);
1015 struct type
*mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1016 cp_type_print_method_args (mtype
,
1023 fprintf_filtered (stream
, _("<badly mangled name '%s'>"),
1029 char *demangled_no_class
1030 = remove_qualifiers (demangled_name
);
1032 /* get rid of the `static' appended by the demangler */
1033 p
= strstr (demangled_no_class
, " static");
1036 int length
= p
- demangled_no_class
;
1037 demangled_no_static
= (char *) xmalloc (length
+ 1);
1038 strncpy (demangled_no_static
, demangled_no_class
, length
);
1039 *(demangled_no_static
+ length
) = '\0';
1040 fputs_filtered (demangled_no_static
, stream
);
1041 xfree (demangled_no_static
);
1044 fputs_filtered (demangled_no_class
, stream
);
1045 xfree (demangled_name
);
1048 if (TYPE_FN_FIELD_STUB (f
, j
))
1049 xfree (mangled_name
);
1051 fprintf_filtered (stream
, ";\n");
1055 fprintfi_filtered (level
, stream
, "}");
1057 if (TYPE_LOCALTYPE_PTR (type
) && show
>= 0)
1058 fprintfi_filtered (level
, stream
, _(" (Local at %s:%d)\n"),
1059 TYPE_LOCALTYPE_FILE (type
),
1060 TYPE_LOCALTYPE_LINE (type
));
1064 case TYPE_CODE_ENUM
:
1065 c_type_print_modifier (type
, stream
, 0, 1);
1066 fprintf_filtered (stream
, "enum ");
1067 /* Print the tag name if it exists.
1068 The aCC compiler emits a spurious
1069 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1070 tag for unnamed struct/union/enum's, which we don't
1072 if (TYPE_TAG_NAME (type
) != NULL
1073 && strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
1075 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1077 fputs_filtered (" ", stream
);
1083 /* If we just printed a tag name, no need to print anything else. */
1084 if (TYPE_TAG_NAME (type
) == NULL
)
1085 fprintf_filtered (stream
, "{...}");
1087 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1089 fprintf_filtered (stream
, "{");
1090 len
= TYPE_NFIELDS (type
);
1092 for (i
= 0; i
< len
; i
++)
1096 fprintf_filtered (stream
, ", ");
1098 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1099 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
1101 fprintf_filtered (stream
, " = %d", TYPE_FIELD_BITPOS (type
, i
));
1102 lastval
= TYPE_FIELD_BITPOS (type
, i
);
1106 fprintf_filtered (stream
, "}");
1110 case TYPE_CODE_VOID
:
1111 fprintf_filtered (stream
, "void");
1114 case TYPE_CODE_UNDEF
:
1115 fprintf_filtered (stream
, _("struct <unknown>"));
1118 case TYPE_CODE_ERROR
:
1119 fprintf_filtered (stream
, _("<unknown type>"));
1122 case TYPE_CODE_RANGE
:
1123 /* This should not occur */
1124 fprintf_filtered (stream
, _("<range type>"));
1127 case TYPE_CODE_NAMESPACE
:
1128 fputs_filtered ("namespace ", stream
);
1129 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1133 /* Handle types not explicitly handled by the other cases,
1134 such as fundamental types. For these, just print whatever
1135 the type name is, as recorded in the type itself. If there
1136 is no type name, then complain. */
1137 if (TYPE_NAME (type
) != NULL
)
1139 c_type_print_modifier (type
, stream
, 0, 1);
1140 fputs_filtered (TYPE_NAME (type
), stream
);
1144 /* At least for dump_symtab, it is important that this not be
1146 fprintf_filtered (stream
, _("<invalid type code %d>"),