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 c_type_print_varspec_prefix (struct type
*, struct ui_file
*, int,
42 /* Print "const", "volatile", or address space modifiers. */
43 static void c_type_print_modifier (struct type
*, struct ui_file
*,
46 /* LEVEL is the depth to indent lines by. */
49 c_print_type (struct type
*type
, const char *varstring
, struct ui_file
*stream
,
59 c_type_print_base (type
, stream
, show
, level
);
60 code
= TYPE_CODE (type
);
61 if ((varstring
!= NULL
&& *varstring
!= '\0')
62 /* Need a space if going to print stars or brackets;
63 but not if we will print just a type name. */
64 || ((show
> 0 || TYPE_NAME (type
) == 0)
65 && (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
66 || code
== TYPE_CODE_METHOD
67 || code
== TYPE_CODE_ARRAY
68 || code
== TYPE_CODE_MEMBERPTR
69 || code
== TYPE_CODE_METHODPTR
70 || code
== TYPE_CODE_REF
)))
71 fputs_filtered (" ", stream
);
72 need_post_space
= (varstring
!= NULL
&& strcmp (varstring
, "") != 0);
73 c_type_print_varspec_prefix (type
, stream
, show
, 0, need_post_space
);
75 if (varstring
!= NULL
)
77 fputs_filtered (varstring
, stream
);
79 /* For demangled function names, we have the arglist as part of the name,
80 so don't print an additional pair of ()'s */
82 demangled_args
= strchr (varstring
, '(') != NULL
;
83 c_type_print_varspec_suffix (type
, stream
, show
, 0, demangled_args
);
87 /* Print a typedef using C syntax. TYPE is the underlying type.
88 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
92 c_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
93 struct ui_file
*stream
)
96 fprintf_filtered (stream
, "typedef ");
97 type_print (type
, "", stream
, 0);
98 if (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))) == 0
99 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))),
100 SYMBOL_LINKAGE_NAME (new_symbol
)) != 0
101 || TYPE_CODE (SYMBOL_TYPE (new_symbol
)) == TYPE_CODE_TYPEDEF
)
102 fprintf_filtered (stream
, " %s", SYMBOL_PRINT_NAME (new_symbol
));
103 fprintf_filtered (stream
, ";\n");
106 /* If TYPE is a derived type, then print out derivation information.
107 Print only the actual base classes of this type, not the base classes
108 of the base classes. I.E. for the derivation hierarchy:
111 class B : public A {int b; };
112 class C : public B {int c; };
114 Print the type of class C as:
120 Not as the following (like gdb used to), which is not legal C++ syntax for
121 derived types and may be confused with the multiple inheritance form:
123 class C : public B : public A {
127 In general, gdb should try to print the types as closely as possible to
128 the form that they appear in the source code.
129 Note that in case of protected derivation gcc will not say 'protected'
130 but 'private'. The HP's aCC compiler emits specific information for
131 derivation via protected inheritance, so gdb can print it out */
134 cp_type_print_derivation_info (struct ui_file
*stream
, struct type
*type
)
139 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
141 fputs_filtered (i
== 0 ? ": " : ", ", stream
);
142 fprintf_filtered (stream
, "%s%s ",
143 BASETYPE_VIA_PUBLIC (type
, i
) ? "public"
144 : (TYPE_FIELD_PROTECTED (type
, i
) ? "protected" : "private"),
145 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
146 name
= type_name_no_tag (TYPE_BASECLASS (type
, i
));
147 fprintf_filtered (stream
, "%s", name
? name
: "(null)");
151 fputs_filtered (" ", stream
);
155 /* Print the C++ method arguments ARGS to the file STREAM. */
158 cp_type_print_method_args (struct type
*mtype
, char *prefix
, char *varstring
,
159 int staticp
, struct ui_file
*stream
)
161 struct field
*args
= TYPE_FIELDS (mtype
);
162 int nargs
= TYPE_NFIELDS (mtype
);
163 int varargs
= TYPE_VARARGS (mtype
);
166 fprintf_symbol_filtered (stream
, prefix
, language_cplus
, DMGL_ANSI
);
167 fprintf_symbol_filtered (stream
, varstring
, language_cplus
, DMGL_ANSI
);
168 fputs_filtered ("(", stream
);
170 /* Skip the class variable. */
176 type_print (args
[i
++].type
, "", stream
, 0);
178 if (i
== nargs
&& varargs
)
179 fprintf_filtered (stream
, ", ...");
181 fprintf_filtered (stream
, ", ");
185 fprintf_filtered (stream
, "...");
186 else if (current_language
->la_language
== language_cplus
)
187 fprintf_filtered (stream
, "void");
189 fprintf_filtered (stream
, ")");
191 /* For non-static methods, read qualifiers from the type of
197 gdb_assert (nargs
> 0);
198 gdb_assert (TYPE_CODE (args
[0].type
) == TYPE_CODE_PTR
);
199 domain
= TYPE_TARGET_TYPE (args
[0].type
);
201 if (TYPE_CONST (domain
))
202 fprintf_filtered (stream
, " const");
204 if (TYPE_VOLATILE (domain
))
205 fprintf_filtered (stream
, " volatile");
210 /* Print any asterisks or open-parentheses needed before the
211 variable name (to describe its type).
213 On outermost call, pass 0 for PASSED_A_PTR.
214 On outermost call, SHOW > 0 means should ignore
215 any typename for TYPE and show its details.
216 SHOW is always zero on recursive calls.
218 NEED_POST_SPACE is non-zero when a space will be be needed
219 between a trailing qualifier and a field, variable, or function
223 c_type_print_varspec_prefix (struct type
*type
, struct ui_file
*stream
,
224 int show
, int passed_a_ptr
, int need_post_space
)
231 if (TYPE_NAME (type
) && show
<= 0)
236 switch (TYPE_CODE (type
))
239 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 1, 1);
240 fprintf_filtered (stream
, "*");
241 c_type_print_modifier (type
, stream
, 1, need_post_space
);
244 case TYPE_CODE_MEMBERPTR
:
245 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
246 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
248 fputs_filtered (name
, stream
);
250 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
251 fprintf_filtered (stream
, "::*");
254 case TYPE_CODE_METHODPTR
:
255 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
256 fprintf_filtered (stream
, "(");
257 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
259 fputs_filtered (name
, stream
);
261 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
262 fprintf_filtered (stream
, "::*");
266 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 1, 0);
267 fprintf_filtered (stream
, "&");
268 c_type_print_modifier (type
, stream
, 1, need_post_space
);
271 case TYPE_CODE_METHOD
:
273 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
275 fprintf_filtered (stream
, "(");
278 case TYPE_CODE_ARRAY
:
279 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
281 fprintf_filtered (stream
, "(");
284 case TYPE_CODE_TYPEDEF
:
285 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
288 case TYPE_CODE_UNDEF
:
289 case TYPE_CODE_STRUCT
:
290 case TYPE_CODE_UNION
:
295 case TYPE_CODE_ERROR
:
299 case TYPE_CODE_RANGE
:
300 case TYPE_CODE_STRING
:
301 case TYPE_CODE_BITSTRING
:
302 case TYPE_CODE_COMPLEX
:
303 case TYPE_CODE_NAMESPACE
:
304 case TYPE_CODE_DECFLOAT
:
305 /* These types need no prefix. They are listed here so that
306 gcc -Wall will reveal any types that haven't been handled. */
309 error (_("type not handled in c_type_print_varspec_prefix()"));
314 /* Print out "const" and "volatile" attributes,
315 and address space id if present.
316 TYPE is a pointer to the type being printed out.
317 STREAM is the output destination.
318 NEED_PRE_SPACE = 1 indicates an initial white space is needed.
319 NEED_POST_SPACE = 1 indicates a final white space is needed. */
322 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
323 int need_pre_space
, int need_post_space
)
325 int did_print_modifier
= 0;
326 const char *address_space_id
;
328 /* We don't print `const' qualifiers for references --- since all
329 operators affect the thing referenced, not the reference itself,
330 every reference is `const'. */
331 if (TYPE_CONST (type
)
332 && TYPE_CODE (type
) != TYPE_CODE_REF
)
335 fprintf_filtered (stream
, " ");
336 fprintf_filtered (stream
, "const");
337 did_print_modifier
= 1;
340 if (TYPE_VOLATILE (type
))
342 if (did_print_modifier
|| need_pre_space
)
343 fprintf_filtered (stream
, " ");
344 fprintf_filtered (stream
, "volatile");
345 did_print_modifier
= 1;
348 address_space_id
= address_space_int_to_name (get_type_arch (type
),
349 TYPE_INSTANCE_FLAGS (type
));
350 if (address_space_id
)
352 if (did_print_modifier
|| need_pre_space
)
353 fprintf_filtered (stream
, " ");
354 fprintf_filtered (stream
, "@%s", address_space_id
);
355 did_print_modifier
= 1;
358 if (did_print_modifier
&& need_post_space
)
359 fprintf_filtered (stream
, " ");
363 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
364 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
365 in non-static methods, are displayed if SHOW_ARTIFICIAL is
366 non-zero. LANGUAGE is the language in which TYPE was defined. This is
367 a necessary evil since this code is used by the C, C++, and Java
371 c_type_print_args (struct type
*type
, struct ui_file
*stream
,
372 int show_artificial
, enum language language
)
378 fprintf_filtered (stream
, "(");
379 args
= TYPE_FIELDS (type
);
380 len
= TYPE_NFIELDS (type
);
382 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
384 if (TYPE_FIELD_ARTIFICIAL (type
, i
) && !show_artificial
)
389 fprintf_filtered (stream
, ", ");
393 if (language
== language_java
)
394 java_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
396 c_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
400 if (printed_any
&& TYPE_VARARGS (type
))
402 /* Print out a trailing ellipsis for varargs functions. Ignore
403 TYPE_VARARGS if the function has no named arguments; that
404 represents unprototyped (K&R style) C functions. */
405 if (printed_any
&& TYPE_VARARGS (type
))
407 fprintf_filtered (stream
, ", ");
409 fprintf_filtered (stream
, "...");
412 else if (!printed_any
413 && ((TYPE_PROTOTYPED (type
) && language
!= language_java
)
414 || language
== language_cplus
))
415 fprintf_filtered (stream
, "void");
417 fprintf_filtered (stream
, ")");
420 /* Return true iff the j'th overloading of the i'th method of TYPE
421 is a type conversion operator, like `operator int () { ... }'.
422 When listing a class's methods, we don't print the return type of
426 is_type_conversion_operator (struct type
*type
, int i
, int j
)
428 /* I think the whole idea of recognizing type conversion operators
429 by their name is pretty terrible. But I don't think our present
430 data structure gives us any other way to tell. If you know of
431 some other way, feel free to rewrite this function. */
432 char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
434 if (strncmp (name
, "operator", 8) != 0)
438 if (! strchr (" \t\f\n\r", *name
))
441 while (strchr (" \t\f\n\r", *name
))
444 if (!('a' <= *name
&& *name
<= 'z')
445 && !('A' <= *name
&& *name
<= 'Z')
447 /* If this doesn't look like the start of an identifier, then it
448 isn't a type conversion operator. */
450 else if (strncmp (name
, "new", 3) == 0)
452 else if (strncmp (name
, "delete", 6) == 0)
455 /* If it doesn't look like new or delete, it's a type conversion
459 /* Is that really the end of the name? */
460 if (('a' <= *name
&& *name
<= 'z')
461 || ('A' <= *name
&& *name
<= 'Z')
462 || ('0' <= *name
&& *name
<= '9')
464 /* No, so the identifier following "operator" must be a type name,
465 and this is a type conversion operator. */
468 /* That was indeed the end of the name, so it was `operator new' or
469 `operator delete', neither of which are type conversion operators. */
473 /* Given a C++ qualified identifier QID, strip off the qualifiers,
474 yielding the unqualified name. The return value is a pointer into
477 It's a pity we don't have this information in some more structured
478 form. Even the author of this function feels that writing little
479 parsers like this everywhere is stupid. */
482 remove_qualifiers (char *qid
)
484 int quoted
= 0; /* zero if we're not in quotes;
485 '"' if we're in a double-quoted string;
486 '\'' if we're in a single-quoted string. */
487 int depth
= 0; /* number of unclosed parens we've seen */
488 char *parenstack
= (char *) alloca (strlen (qid
));
490 char *last
= 0; /* The character after the rightmost
491 `::' token we've seen so far. */
493 for (scan
= qid
; *scan
; scan
++)
499 else if (*scan
== '\\' && *(scan
+ 1))
502 else if (scan
[0] == ':' && scan
[1] == ':')
504 /* If we're inside parenthesis (i.e., an argument list) or
505 angle brackets (i.e., a list of template arguments), then
506 we don't record the position of this :: token, since it's
507 not relevant to the top-level structure we're trying
515 else if (*scan
== '"' || *scan
== '\'')
517 else if (*scan
== '(')
518 parenstack
[depth
++] = ')';
519 else if (*scan
== '[')
520 parenstack
[depth
++] = ']';
521 /* We're going to treat <> as a pair of matching characters,
522 since we're more likely to see those in template id's than
523 real less-than characters. What a crock. */
524 else if (*scan
== '<')
525 parenstack
[depth
++] = '>';
526 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
528 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
532 /* We're going to do a little error recovery here. If we
533 don't find a match for *scan on the paren stack, but
534 there is something lower on the stack that does match, we
535 pop the stack to that point. */
538 for (i
= depth
- 1; i
>= 0; i
--)
539 if (parenstack
[i
] == *scan
)
551 /* We didn't find any :: tokens at the top level, so declare the
552 whole thing an unqualified identifier. */
556 /* Print any array sizes, function arguments or close parentheses
557 needed after the variable name (to describe its type).
558 Args work like c_type_print_varspec_prefix. */
561 c_type_print_varspec_suffix (struct type
*type
, struct ui_file
*stream
,
562 int show
, int passed_a_ptr
, int demangled_args
)
567 if (TYPE_NAME (type
) && show
<= 0)
572 switch (TYPE_CODE (type
))
574 case TYPE_CODE_ARRAY
:
576 LONGEST low_bound
, high_bound
;
579 fprintf_filtered (stream
, ")");
581 fprintf_filtered (stream
, "[");
582 if (get_array_bounds (type
, &low_bound
, &high_bound
))
583 fprintf_filtered (stream
, "%d", (int) (high_bound
- low_bound
+ 1));
584 fprintf_filtered (stream
, "]");
586 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
591 case TYPE_CODE_MEMBERPTR
:
592 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
596 case TYPE_CODE_METHODPTR
:
597 fprintf_filtered (stream
, ")");
598 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
604 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
608 case TYPE_CODE_METHOD
:
611 fprintf_filtered (stream
, ")");
613 c_type_print_args (type
, stream
, 1, current_language
->la_language
);
614 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
618 case TYPE_CODE_TYPEDEF
:
619 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
623 case TYPE_CODE_UNDEF
:
624 case TYPE_CODE_STRUCT
:
625 case TYPE_CODE_UNION
:
630 case TYPE_CODE_ERROR
:
634 case TYPE_CODE_RANGE
:
635 case TYPE_CODE_STRING
:
636 case TYPE_CODE_BITSTRING
:
637 case TYPE_CODE_COMPLEX
:
638 case TYPE_CODE_NAMESPACE
:
639 case TYPE_CODE_DECFLOAT
:
640 /* These types do not need a suffix. They are listed so that
641 gcc -Wall will report types that may not have been considered. */
644 error (_("type not handled in c_type_print_varspec_suffix()"));
649 /* Print the name of the type (or the ultimate pointer target,
650 function value or array element), or the description of a
653 SHOW positive means print details about the type (e.g. enum values),
654 and print structure elements passing SHOW - 1 for show.
655 SHOW negative means just print the type name or struct tag if there is one.
656 If there is no name, print something sensible but concise like
658 SHOW zero means just print the type name or struct tag if there is one.
659 If there is no name, print something sensible but not as concise like
660 "struct {int x; int y;}".
662 LEVEL is the number of spaces to indent by.
663 We increase it for some recursive calls. */
666 c_type_print_base (struct type
*type
, struct ui_file
*stream
, int show
,
673 char *demangled_name
;
674 char *demangled_no_static
;
677 s_none
, s_public
, s_private
, s_protected
680 int need_access_label
= 0;
688 fputs_filtered (_("<type unknown>"), stream
);
692 /* When SHOW is zero or less, and there is a valid type name, then always
693 just print the type name directly from the type. */
694 /* If we have "typedef struct foo {. . .} bar;" do we want to print it
695 as "struct foo" or as "bar"? Pick the latter, because C++ folk tend
696 to expect things like "class5 *foo" rather than "struct class5 *foo". */
699 && TYPE_NAME (type
) != NULL
)
701 c_type_print_modifier (type
, stream
, 0, 1);
702 fputs_filtered (TYPE_NAME (type
), stream
);
706 CHECK_TYPEDEF (type
);
708 switch (TYPE_CODE (type
))
710 case TYPE_CODE_TYPEDEF
:
711 /* If we get here, the typedef doesn't have a name, and we couldn't
712 resolve TYPE_TARGET_TYPE. Not much we can do. */
713 gdb_assert (TYPE_NAME (type
) == NULL
);
714 gdb_assert (TYPE_TARGET_TYPE (type
) == NULL
);
715 fprintf_filtered (stream
, _("<unnamed typedef>"));
718 case TYPE_CODE_ARRAY
:
720 case TYPE_CODE_MEMBERPTR
:
723 case TYPE_CODE_METHOD
:
724 case TYPE_CODE_METHODPTR
:
725 c_type_print_base (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
728 case TYPE_CODE_STRUCT
:
729 c_type_print_modifier (type
, stream
, 0, 1);
730 if (TYPE_DECLARED_CLASS (type
))
731 fprintf_filtered (stream
, "class ");
733 fprintf_filtered (stream
, "struct ");
736 case TYPE_CODE_UNION
:
737 c_type_print_modifier (type
, stream
, 0, 1);
738 fprintf_filtered (stream
, "union ");
742 /* Print the tag if it exists.
743 * The HP aCC compiler emits
744 * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
745 * tag for unnamed struct/union/enum's, which we don't
748 if (TYPE_TAG_NAME (type
) != NULL
749 && strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
751 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
753 fputs_filtered (" ", stream
);
758 /* If we just printed a tag name, no need to print anything else. */
759 if (TYPE_TAG_NAME (type
) == NULL
)
760 fprintf_filtered (stream
, "{...}");
762 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
764 struct type
*basetype
;
767 cp_type_print_derivation_info (stream
, type
);
769 fprintf_filtered (stream
, "{\n");
770 if (TYPE_NFIELDS (type
) == 0 && TYPE_NFN_FIELDS (type
) == 0
771 && TYPE_TYPEDEF_FIELD_COUNT (type
) == 0)
773 if (TYPE_STUB (type
))
774 fprintfi_filtered (level
+ 4, stream
, _("<incomplete type>\n"));
776 fprintfi_filtered (level
+ 4, stream
, _("<no data fields>\n"));
779 /* Start off with no specific section type, so we can print
780 one for the first field we find, and use that section type
781 thereafter until we find another type. */
783 section_type
= s_none
;
785 /* For a class, if all members are private, there's no need
786 for a "private:" label; similarly, for a struct or union
787 masquerading as a class, if all members are public, there's
788 no need for a "public:" label. */
790 if (TYPE_DECLARED_CLASS (type
))
793 len
= TYPE_NFIELDS (type
);
794 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
795 if (!TYPE_FIELD_PRIVATE (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
++)
806 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
807 for (i
= 0; i
< len
; i
++)
808 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
))
810 need_access_label
= 1;
813 if (need_access_label
)
821 len
= TYPE_NFIELDS (type
);
822 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
823 if (TYPE_FIELD_PRIVATE (type
, i
) || TYPE_FIELD_PROTECTED (type
, i
))
825 need_access_label
= 1;
829 if (!need_access_label
)
831 len2
= TYPE_NFN_FIELDS (type
);
832 for (j
= 0; j
< len2
; j
++)
835 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
836 for (i
= 0; i
< len
; i
++)
837 if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
)
838 || TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
, j
), i
))
840 need_access_label
= 1;
843 if (need_access_label
)
849 /* If there is a base class for this type,
850 do not print the field that it occupies. */
852 len
= TYPE_NFIELDS (type
);
853 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
854 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
858 /* If we have a virtual table pointer, omit it. Even if
859 virtual table pointers are not specifically marked in
860 the debug info, they should be artificial. */
861 if ((i
== vptr_fieldno
&& type
== basetype
)
862 || TYPE_FIELD_ARTIFICIAL (type
, i
))
865 if (need_access_label
)
867 if (TYPE_FIELD_PROTECTED (type
, i
))
869 if (section_type
!= s_protected
)
871 section_type
= s_protected
;
872 fprintfi_filtered (level
+ 2, stream
,
876 else if (TYPE_FIELD_PRIVATE (type
, i
))
878 if (section_type
!= s_private
)
880 section_type
= s_private
;
881 fprintfi_filtered (level
+ 2, stream
, "private:\n");
886 if (section_type
!= s_public
)
888 section_type
= s_public
;
889 fprintfi_filtered (level
+ 2, stream
, "public:\n");
894 print_spaces_filtered (level
+ 4, stream
);
895 if (field_is_static (&TYPE_FIELD (type
, i
)))
896 fprintf_filtered (stream
, "static ");
897 c_print_type (TYPE_FIELD_TYPE (type
, i
),
898 TYPE_FIELD_NAME (type
, i
),
899 stream
, show
- 1, level
+ 4);
900 if (!field_is_static (&TYPE_FIELD (type
, i
))
901 && TYPE_FIELD_PACKED (type
, i
))
903 /* It is a bitfield. This code does not attempt
904 to look at the bitpos and reconstruct filler,
905 unnamed fields. This would lead to misleading
906 results if the compiler does not put out fields
907 for such things (I don't know what it does). */
908 fprintf_filtered (stream
, " : %d",
909 TYPE_FIELD_BITSIZE (type
, i
));
911 fprintf_filtered (stream
, ";\n");
914 /* If there are both fields and methods, put a blank line
915 between them. Make sure to count only method that we will
916 display; artificial methods will be hidden. */
917 len
= TYPE_NFN_FIELDS (type
);
919 for (i
= 0; i
< len
; i
++)
921 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
922 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
925 for (j
= 0; j
< len2
; j
++)
926 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
929 if (real_len
> 0 && section_type
!= s_none
)
930 fprintf_filtered (stream
, "\n");
932 /* C++: print out the methods */
933 for (i
= 0; i
< len
; i
++)
935 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
936 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
937 char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
938 char *name
= type_name_no_tag (type
);
939 int is_constructor
= name
&& strcmp (method_name
, name
) == 0;
941 for (j
= 0; j
< len2
; j
++)
943 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
944 int is_full_physname_constructor
=
945 is_constructor_name (physname
)
946 || is_destructor_name (physname
)
947 || method_name
[0] == '~';
949 /* Do not print out artificial methods. */
950 if (TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
954 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
956 if (section_type
!= s_protected
)
958 section_type
= s_protected
;
959 fprintfi_filtered (level
+ 2, stream
,
963 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
965 if (section_type
!= s_private
)
967 section_type
= s_private
;
968 fprintfi_filtered (level
+ 2, stream
, "private:\n");
973 if (section_type
!= s_public
)
975 section_type
= s_public
;
976 fprintfi_filtered (level
+ 2, stream
, "public:\n");
980 print_spaces_filtered (level
+ 4, stream
);
981 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
982 fprintf_filtered (stream
, "virtual ");
983 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
984 fprintf_filtered (stream
, "static ");
985 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
987 /* Keep GDB from crashing here. */
988 fprintf_filtered (stream
, _("<undefined type> %s;\n"),
989 TYPE_FN_FIELD_PHYSNAME (f
, j
));
992 else if (!is_constructor
/* constructors don't have declared types */
993 && !is_full_physname_constructor
/* " " */
994 && !is_type_conversion_operator (type
, i
, j
))
996 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
998 fputs_filtered (" ", stream
);
1000 if (TYPE_FN_FIELD_STUB (f
, j
))
1001 /* Build something we can demangle. */
1002 mangled_name
= gdb_mangle_name (type
, i
, j
);
1004 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1007 cplus_demangle (mangled_name
,
1008 DMGL_ANSI
| DMGL_PARAMS
);
1009 if (demangled_name
== NULL
)
1011 /* in some cases (for instance with the HP demangling),
1012 if a function has more than 10 arguments,
1013 the demangling will fail.
1014 Let's try to reconstruct the function signature from
1015 the symbol information */
1016 if (!TYPE_FN_FIELD_STUB (f
, j
))
1018 int staticp
= TYPE_FN_FIELD_STATIC_P (f
, j
);
1019 struct type
*mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1021 cp_type_print_method_args (mtype
,
1028 fprintf_filtered (stream
, _("<badly mangled name '%s'>"),
1034 char *demangled_no_class
1035 = remove_qualifiers (demangled_name
);
1037 /* get rid of the `static' appended by the demangler */
1038 p
= strstr (demangled_no_class
, " static");
1041 int length
= p
- demangled_no_class
;
1043 demangled_no_static
= (char *) xmalloc (length
+ 1);
1044 strncpy (demangled_no_static
, demangled_no_class
, length
);
1045 *(demangled_no_static
+ length
) = '\0';
1046 fputs_filtered (demangled_no_static
, stream
);
1047 xfree (demangled_no_static
);
1050 fputs_filtered (demangled_no_class
, stream
);
1051 xfree (demangled_name
);
1054 if (TYPE_FN_FIELD_STUB (f
, j
))
1055 xfree (mangled_name
);
1057 fprintf_filtered (stream
, ";\n");
1061 /* Print typedefs defined in this class. */
1063 if (TYPE_TYPEDEF_FIELD_COUNT (type
) != 0)
1065 if (TYPE_NFIELDS (type
) != 0 || TYPE_NFN_FIELDS (type
) != 0)
1066 fprintf_filtered (stream
, "\n");
1068 for (i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (type
); i
++)
1070 struct type
*target
= TYPE_TYPEDEF_FIELD_TYPE (type
, i
);
1072 /* Dereference the typedef declaration itself. */
1073 gdb_assert (TYPE_CODE (target
) == TYPE_CODE_TYPEDEF
);
1074 target
= TYPE_TARGET_TYPE (target
);
1076 print_spaces_filtered (level
+ 4, stream
);
1077 fprintf_filtered (stream
, "typedef ");
1078 c_print_type (target
, TYPE_TYPEDEF_FIELD_NAME (type
, i
),
1079 stream
, show
- 1, level
+ 4);
1080 fprintf_filtered (stream
, ";\n");
1084 fprintfi_filtered (level
, stream
, "}");
1086 if (TYPE_LOCALTYPE_PTR (type
) && show
>= 0)
1087 fprintfi_filtered (level
, stream
, _(" (Local at %s:%d)\n"),
1088 TYPE_LOCALTYPE_FILE (type
),
1089 TYPE_LOCALTYPE_LINE (type
));
1093 case TYPE_CODE_ENUM
:
1094 c_type_print_modifier (type
, stream
, 0, 1);
1095 fprintf_filtered (stream
, "enum ");
1096 /* Print the tag name if it exists.
1097 The aCC compiler emits a spurious
1098 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1099 tag for unnamed struct/union/enum's, which we don't
1101 if (TYPE_TAG_NAME (type
) != NULL
1102 && strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
1104 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1106 fputs_filtered (" ", stream
);
1112 /* If we just printed a tag name, no need to print anything else. */
1113 if (TYPE_TAG_NAME (type
) == NULL
)
1114 fprintf_filtered (stream
, "{...}");
1116 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1118 fprintf_filtered (stream
, "{");
1119 len
= TYPE_NFIELDS (type
);
1121 for (i
= 0; i
< len
; i
++)
1125 fprintf_filtered (stream
, ", ");
1127 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1128 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
1130 fprintf_filtered (stream
, " = %d", TYPE_FIELD_BITPOS (type
, i
));
1131 lastval
= TYPE_FIELD_BITPOS (type
, i
);
1135 fprintf_filtered (stream
, "}");
1139 case TYPE_CODE_VOID
:
1140 fprintf_filtered (stream
, "void");
1143 case TYPE_CODE_UNDEF
:
1144 fprintf_filtered (stream
, _("struct <unknown>"));
1147 case TYPE_CODE_ERROR
:
1148 fprintf_filtered (stream
, "%s", TYPE_ERROR_NAME (type
));
1151 case TYPE_CODE_RANGE
:
1152 /* This should not occur */
1153 fprintf_filtered (stream
, _("<range type>"));
1156 case TYPE_CODE_NAMESPACE
:
1157 fputs_filtered ("namespace ", stream
);
1158 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1162 /* Handle types not explicitly handled by the other cases,
1163 such as fundamental types. For these, just print whatever
1164 the type name is, as recorded in the type itself. If there
1165 is no type name, then complain. */
1166 if (TYPE_NAME (type
) != NULL
)
1168 c_type_print_modifier (type
, stream
, 0, 1);
1169 fputs_filtered (TYPE_NAME (type
), stream
);
1173 /* At least for dump_symtab, it is important that this not be
1175 fprintf_filtered (stream
, _("<invalid type code %d>"),