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 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "gdb_obstack.h"
22 #include "bfd.h" /* Binary File Description */
25 #include "expression.h"
32 #include "typeprint.h"
35 #include "gdb_string.h"
38 static void cp_type_print_method_args (struct type
*mtype
, char *prefix
,
39 char *varstring
, int staticp
,
40 struct ui_file
*stream
);
42 static void c_type_print_args (struct type
*, struct ui_file
*);
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')
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)
77 (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
78 || code
== TYPE_CODE_METHOD
79 || code
== TYPE_CODE_ARRAY
80 || code
== TYPE_CODE_MEMBERPTR
81 || code
== TYPE_CODE_METHODPTR
82 || code
== TYPE_CODE_REF
)))
83 fputs_filtered (" ", stream
);
84 need_post_space
= (varstring
!= NULL
&& strcmp (varstring
, "") != 0);
85 c_type_print_varspec_prefix (type
, stream
, show
, 0, need_post_space
);
87 if (varstring
!= NULL
)
89 fputs_filtered (varstring
, stream
);
91 /* For demangled function names, we have the arglist as part of the name,
92 so don't print an additional pair of ()'s */
94 demangled_args
= strchr (varstring
, '(') != NULL
;
95 c_type_print_varspec_suffix (type
, stream
, show
, 0, demangled_args
);
99 /* If TYPE is a derived type, then print out derivation information.
100 Print only the actual base classes of this type, not the base classes
101 of the base classes. I.E. for the derivation hierarchy:
104 class B : public A {int b; };
105 class C : public B {int c; };
107 Print the type of class C as:
113 Not as the following (like gdb used to), which is not legal C++ syntax for
114 derived types and may be confused with the multiple inheritance form:
116 class C : public B : public A {
120 In general, gdb should try to print the types as closely as possible to
121 the form that they appear in the source code.
122 Note that in case of protected derivation gcc will not say 'protected'
123 but 'private'. The HP's aCC compiler emits specific information for
124 derivation via protected inheritance, so gdb can print it out */
127 cp_type_print_derivation_info (struct ui_file
*stream
, struct type
*type
)
132 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
134 fputs_filtered (i
== 0 ? ": " : ", ", stream
);
135 fprintf_filtered (stream
, "%s%s ",
136 BASETYPE_VIA_PUBLIC (type
, i
) ? "public"
137 : (TYPE_FIELD_PROTECTED (type
, i
) ? "protected" : "private"),
138 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
139 name
= type_name_no_tag (TYPE_BASECLASS (type
, i
));
140 fprintf_filtered (stream
, "%s", name
? name
: "(null)");
144 fputs_filtered (" ", stream
);
148 /* Print the C++ method arguments ARGS to the file STREAM. */
151 cp_type_print_method_args (struct type
*mtype
, char *prefix
, char *varstring
,
152 int staticp
, struct ui_file
*stream
)
154 struct field
*args
= TYPE_FIELDS (mtype
);
155 int nargs
= TYPE_NFIELDS (mtype
);
156 int varargs
= TYPE_VARARGS (mtype
);
159 fprintf_symbol_filtered (stream
, prefix
, language_cplus
, DMGL_ANSI
);
160 fprintf_symbol_filtered (stream
, varstring
, language_cplus
, DMGL_ANSI
);
161 fputs_filtered ("(", stream
);
163 /* Skip the class variable. */
169 type_print (args
[i
++].type
, "", stream
, 0);
171 if (i
== nargs
&& varargs
)
172 fprintf_filtered (stream
, ", ...");
174 fprintf_filtered (stream
, ", ");
178 fprintf_filtered (stream
, "...");
179 else if (current_language
->la_language
== language_cplus
)
180 fprintf_filtered (stream
, "void");
182 fprintf_filtered (stream
, ")");
186 /* Print any asterisks or open-parentheses needed before the
187 variable name (to describe its type).
189 On outermost call, pass 0 for PASSED_A_PTR.
190 On outermost call, SHOW > 0 means should ignore
191 any typename for TYPE and show its details.
192 SHOW is always zero on recursive calls.
194 NEED_POST_SPACE is non-zero when a space will be be needed
195 between a trailing qualifier and a field, variable, or function
199 c_type_print_varspec_prefix (struct type
*type
, struct ui_file
*stream
,
200 int show
, int passed_a_ptr
, int need_post_space
)
206 if (TYPE_NAME (type
) && show
<= 0)
211 switch (TYPE_CODE (type
))
214 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 1, 1);
215 fprintf_filtered (stream
, "*");
216 c_type_print_modifier (type
, stream
, 1, need_post_space
);
219 case TYPE_CODE_MEMBERPTR
:
220 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
221 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
223 fputs_filtered (name
, stream
);
225 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
226 fprintf_filtered (stream
, "::*");
229 case TYPE_CODE_METHODPTR
:
230 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
231 fprintf_filtered (stream
, "(");
232 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
234 fputs_filtered (name
, stream
);
236 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
237 fprintf_filtered (stream
, "::*");
241 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 1, 0);
242 fprintf_filtered (stream
, "&");
243 c_type_print_modifier (type
, stream
, 1, need_post_space
);
246 case TYPE_CODE_METHOD
:
248 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
250 fprintf_filtered (stream
, "(");
253 case TYPE_CODE_ARRAY
:
254 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
256 fprintf_filtered (stream
, "(");
259 case TYPE_CODE_TYPEDEF
:
260 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
263 case TYPE_CODE_UNDEF
:
264 case TYPE_CODE_STRUCT
:
265 case TYPE_CODE_UNION
:
270 case TYPE_CODE_ERROR
:
274 case TYPE_CODE_RANGE
:
275 case TYPE_CODE_STRING
:
276 case TYPE_CODE_BITSTRING
:
277 case TYPE_CODE_COMPLEX
:
278 case TYPE_CODE_TEMPLATE
:
279 case TYPE_CODE_NAMESPACE
:
280 case TYPE_CODE_DECFLOAT
:
281 /* These types need no prefix. They are listed here so that
282 gcc -Wall will reveal any types that haven't been handled. */
285 error (_("type not handled in c_type_print_varspec_prefix()"));
290 /* Print out "const" and "volatile" attributes.
291 TYPE is a pointer to the type being printed out.
292 STREAM is the output destination.
293 NEED_SPACE = 1 indicates an initial white space is needed */
296 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
297 int need_pre_space
, int need_post_space
)
299 int did_print_modifier
= 0;
300 const char *address_space_id
;
302 /* We don't print `const' qualifiers for references --- since all
303 operators affect the thing referenced, not the reference itself,
304 every reference is `const'. */
305 if (TYPE_CONST (type
)
306 && TYPE_CODE (type
) != TYPE_CODE_REF
)
309 fprintf_filtered (stream
, " ");
310 fprintf_filtered (stream
, "const");
311 did_print_modifier
= 1;
314 if (TYPE_VOLATILE (type
))
316 if (did_print_modifier
|| need_pre_space
)
317 fprintf_filtered (stream
, " ");
318 fprintf_filtered (stream
, "volatile");
319 did_print_modifier
= 1;
322 address_space_id
= address_space_int_to_name (TYPE_INSTANCE_FLAGS (type
));
323 if (address_space_id
)
325 if (did_print_modifier
|| need_pre_space
)
326 fprintf_filtered (stream
, " ");
327 fprintf_filtered (stream
, "@%s", address_space_id
);
328 did_print_modifier
= 1;
331 if (did_print_modifier
&& need_post_space
)
332 fprintf_filtered (stream
, " ");
336 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
337 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
338 in non-static methods, are displayed. */
341 c_type_print_args (struct type
*type
, struct ui_file
*stream
)
347 fprintf_filtered (stream
, "(");
348 args
= TYPE_FIELDS (type
);
349 len
= TYPE_NFIELDS (type
);
351 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
355 fprintf_filtered (stream
, ", ");
359 c_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
363 if (printed_any
&& TYPE_VARARGS (type
))
365 /* Print out a trailing ellipsis for varargs functions. Ignore
366 TYPE_VARARGS if the function has no named arguments; that
367 represents unprototyped (K&R style) C functions. */
368 if (printed_any
&& TYPE_VARARGS (type
))
370 fprintf_filtered (stream
, ", ");
372 fprintf_filtered (stream
, "...");
375 else if (!printed_any
376 && (TYPE_PROTOTYPED (type
)
377 || current_language
->la_language
== language_cplus
))
378 fprintf_filtered (stream
, "void");
380 fprintf_filtered (stream
, ")");
384 /* Return true iff the j'th overloading of the i'th method of TYPE
385 is a type conversion operator, like `operator int () { ... }'.
386 When listing a class's methods, we don't print the return type of
389 is_type_conversion_operator (struct type
*type
, int i
, int j
)
391 /* I think the whole idea of recognizing type conversion operators
392 by their name is pretty terrible. But I don't think our present
393 data structure gives us any other way to tell. If you know of
394 some other way, feel free to rewrite this function. */
395 char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
397 if (strncmp (name
, "operator", 8) != 0)
401 if (! strchr (" \t\f\n\r", *name
))
404 while (strchr (" \t\f\n\r", *name
))
407 if (!('a' <= *name
&& *name
<= 'z')
408 && !('A' <= *name
&& *name
<= 'Z')
410 /* If this doesn't look like the start of an identifier, then it
411 isn't a type conversion operator. */
413 else if (strncmp (name
, "new", 3) == 0)
415 else if (strncmp (name
, "delete", 6) == 0)
418 /* If it doesn't look like new or delete, it's a type conversion
422 /* Is that really the end of the name? */
423 if (('a' <= *name
&& *name
<= 'z')
424 || ('A' <= *name
&& *name
<= 'Z')
425 || ('0' <= *name
&& *name
<= '9')
427 /* No, so the identifier following "operator" must be a type name,
428 and this is a type conversion operator. */
431 /* That was indeed the end of the name, so it was `operator new' or
432 `operator delete', neither of which are type conversion operators. */
437 /* Given a C++ qualified identifier QID, strip off the qualifiers,
438 yielding the unqualified name. The return value is a pointer into
441 It's a pity we don't have this information in some more structured
442 form. Even the author of this function feels that writing little
443 parsers like this everywhere is stupid. */
445 remove_qualifiers (char *qid
)
447 int quoted
= 0; /* zero if we're not in quotes;
448 '"' if we're in a double-quoted string;
449 '\'' if we're in a single-quoted string. */
450 int depth
= 0; /* number of unclosed parens we've seen */
451 char *parenstack
= (char *) alloca (strlen (qid
));
453 char *last
= 0; /* The character after the rightmost
454 `::' token we've seen so far. */
456 for (scan
= qid
; *scan
; scan
++)
462 else if (*scan
== '\\' && *(scan
+ 1))
465 else if (scan
[0] == ':' && scan
[1] == ':')
467 /* If we're inside parenthesis (i.e., an argument list) or
468 angle brackets (i.e., a list of template arguments), then
469 we don't record the position of this :: token, since it's
470 not relevant to the top-level structure we're trying
478 else if (*scan
== '"' || *scan
== '\'')
480 else if (*scan
== '(')
481 parenstack
[depth
++] = ')';
482 else if (*scan
== '[')
483 parenstack
[depth
++] = ']';
484 /* We're going to treat <> as a pair of matching characters,
485 since we're more likely to see those in template id's than
486 real less-than characters. What a crock. */
487 else if (*scan
== '<')
488 parenstack
[depth
++] = '>';
489 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
491 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
495 /* We're going to do a little error recovery here. If we
496 don't find a match for *scan on the paren stack, but
497 there is something lower on the stack that does match, we
498 pop the stack to that point. */
501 for (i
= depth
- 1; i
>= 0; i
--)
502 if (parenstack
[i
] == *scan
)
514 /* We didn't find any :: tokens at the top level, so declare the
515 whole thing an unqualified identifier. */
520 /* Print any array sizes, function arguments or close parentheses
521 needed after the variable name (to describe its type).
522 Args work like c_type_print_varspec_prefix. */
525 c_type_print_varspec_suffix (struct type
*type
, struct ui_file
*stream
,
526 int show
, int passed_a_ptr
, int demangled_args
)
531 if (TYPE_NAME (type
) && show
<= 0)
536 switch (TYPE_CODE (type
))
538 case TYPE_CODE_ARRAY
:
540 fprintf_filtered (stream
, ")");
542 fprintf_filtered (stream
, "[");
543 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0
544 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
545 fprintf_filtered (stream
, "%d",
547 / TYPE_LENGTH (TYPE_TARGET_TYPE (type
))));
548 fprintf_filtered (stream
, "]");
550 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
554 case TYPE_CODE_MEMBERPTR
:
555 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
559 case TYPE_CODE_METHODPTR
:
560 fprintf_filtered (stream
, ")");
561 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
567 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
571 case TYPE_CODE_METHOD
:
574 fprintf_filtered (stream
, ")");
576 c_type_print_args (type
, stream
);
577 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
581 case TYPE_CODE_TYPEDEF
:
582 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
586 case TYPE_CODE_UNDEF
:
587 case TYPE_CODE_STRUCT
:
588 case TYPE_CODE_UNION
:
593 case TYPE_CODE_ERROR
:
597 case TYPE_CODE_RANGE
:
598 case TYPE_CODE_STRING
:
599 case TYPE_CODE_BITSTRING
:
600 case TYPE_CODE_COMPLEX
:
601 case TYPE_CODE_TEMPLATE
:
602 case TYPE_CODE_NAMESPACE
:
603 case TYPE_CODE_DECFLOAT
:
604 /* These types do not need a suffix. They are listed so that
605 gcc -Wall will report types that may not have been considered. */
608 error (_("type not handled in c_type_print_varspec_suffix()"));
613 /* Print the name of the type (or the ultimate pointer target,
614 function value or array element), or the description of a
617 SHOW positive means print details about the type (e.g. enum values),
618 and print structure elements passing SHOW - 1 for show.
619 SHOW negative means just print the type name or struct tag if there is one.
620 If there is no name, print something sensible but concise like
622 SHOW zero means just print the type name or struct tag if there is one.
623 If there is no name, print something sensible but not as concise like
624 "struct {int x; int y;}".
626 LEVEL is the number of spaces to indent by.
627 We increase it for some recursive calls. */
630 c_type_print_base (struct type
*type
, struct ui_file
*stream
, int show
,
637 char *demangled_name
;
638 char *demangled_no_static
;
641 s_none
, s_public
, s_private
, s_protected
644 int need_access_label
= 0;
652 fputs_filtered (_("<type unknown>"), stream
);
656 /* When SHOW is zero or less, and there is a valid type name, then always
657 just print the type name directly from the type. */
658 /* If we have "typedef struct foo {. . .} bar;" do we want to print it
659 as "struct foo" or as "bar"? Pick the latter, because C++ folk tend
660 to expect things like "class5 *foo" rather than "struct class5 *foo". */
663 && TYPE_NAME (type
) != NULL
)
665 c_type_print_modifier (type
, stream
, 0, 1);
666 fputs_filtered (TYPE_NAME (type
), stream
);
670 CHECK_TYPEDEF (type
);
672 switch (TYPE_CODE (type
))
674 case TYPE_CODE_TYPEDEF
:
675 case TYPE_CODE_ARRAY
:
677 case TYPE_CODE_MEMBERPTR
:
680 case TYPE_CODE_METHOD
:
681 case TYPE_CODE_METHODPTR
:
682 c_type_print_base (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
685 case TYPE_CODE_STRUCT
:
686 c_type_print_modifier (type
, stream
, 0, 1);
687 /* Note TYPE_CODE_STRUCT and TYPE_CODE_CLASS have the same value,
688 * so we use another means for distinguishing them.
690 if (HAVE_CPLUS_STRUCT (type
))
692 switch (TYPE_DECLARED_TYPE (type
))
694 case DECLARED_TYPE_CLASS
:
695 fprintf_filtered (stream
, "class ");
697 case DECLARED_TYPE_UNION
:
698 fprintf_filtered (stream
, "union ");
700 case DECLARED_TYPE_STRUCT
:
701 fprintf_filtered (stream
, "struct ");
704 /* If there is a CPLUS_STRUCT, assume class if not
705 * otherwise specified in the declared_type field.
707 fprintf_filtered (stream
, "class ");
713 /* If not CPLUS_STRUCT, then assume it's a C struct */
714 fprintf_filtered (stream
, "struct ");
718 case TYPE_CODE_UNION
:
719 c_type_print_modifier (type
, stream
, 0, 1);
720 fprintf_filtered (stream
, "union ");
724 /* Print the tag if it exists.
725 * The HP aCC compiler emits
726 * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
727 * tag for unnamed struct/union/enum's, which we don't
730 if (TYPE_TAG_NAME (type
) != NULL
&&
731 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
733 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
735 fputs_filtered (" ", stream
);
740 /* If we just printed a tag name, no need to print anything else. */
741 if (TYPE_TAG_NAME (type
) == NULL
)
742 fprintf_filtered (stream
, "{...}");
744 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
746 cp_type_print_derivation_info (stream
, type
);
748 fprintf_filtered (stream
, "{\n");
749 if ((TYPE_NFIELDS (type
) == 0) && (TYPE_NFN_FIELDS (type
) == 0))
751 if (TYPE_STUB (type
))
752 fprintfi_filtered (level
+ 4, stream
, _("<incomplete type>\n"));
754 fprintfi_filtered (level
+ 4, stream
, _("<no data fields>\n"));
757 /* Start off with no specific section type, so we can print
758 one for the first field we find, and use that section type
759 thereafter until we find another type. */
761 section_type
= s_none
;
763 /* For a class, if all members are private, there's no need
764 for a "private:" label; similarly, for a struct or union
765 masquerading as a class, if all members are public, there's
766 no need for a "public:" label. */
768 if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_CLASS
) ||
769 (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_TEMPLATE
))
772 len
= TYPE_NFIELDS (type
);
773 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
774 if (!TYPE_FIELD_PRIVATE (type
, i
))
776 need_access_label
= 1;
780 if (!need_access_label
)
782 len2
= TYPE_NFN_FIELDS (type
);
783 for (j
= 0; j
< len2
; j
++)
785 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
786 for (i
= 0; i
< len
; i
++)
787 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
))
789 need_access_label
= 1;
792 if (need_access_label
)
797 else if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_STRUCT
) ||
798 (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_UNION
))
801 len
= TYPE_NFIELDS (type
);
802 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
803 if (TYPE_FIELD_PRIVATE (type
, i
) || TYPE_FIELD_PROTECTED (type
, i
))
805 need_access_label
= 1;
809 if (!need_access_label
)
811 len2
= TYPE_NFN_FIELDS (type
);
812 for (j
= 0; j
< len2
; j
++)
815 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
816 for (i
= 0; i
< len
; i
++)
817 if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
) ||
818 TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
, j
), i
))
820 need_access_label
= 1;
823 if (need_access_label
)
829 /* If there is a base class for this type,
830 do not print the field that it occupies. */
832 len
= TYPE_NFIELDS (type
);
833 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
836 /* Don't print out virtual function table. */
837 if (strncmp (TYPE_FIELD_NAME (type
, i
), "_vptr", 5) == 0
838 && is_cplus_marker ((TYPE_FIELD_NAME (type
, i
))[5]))
841 /* If this is a C++ class we can print the various C++ section
844 if (HAVE_CPLUS_STRUCT (type
) && need_access_label
)
846 if (TYPE_FIELD_PROTECTED (type
, i
))
848 if (section_type
!= s_protected
)
850 section_type
= s_protected
;
851 fprintfi_filtered (level
+ 2, stream
,
855 else if (TYPE_FIELD_PRIVATE (type
, i
))
857 if (section_type
!= s_private
)
859 section_type
= s_private
;
860 fprintfi_filtered (level
+ 2, stream
, "private:\n");
865 if (section_type
!= s_public
)
867 section_type
= s_public
;
868 fprintfi_filtered (level
+ 2, stream
, "public:\n");
873 print_spaces_filtered (level
+ 4, stream
);
874 if (TYPE_FIELD_STATIC (type
, i
))
876 fprintf_filtered (stream
, "static ");
878 c_print_type (TYPE_FIELD_TYPE (type
, i
),
879 TYPE_FIELD_NAME (type
, i
),
880 stream
, show
- 1, level
+ 4);
881 if (!TYPE_FIELD_STATIC (type
, i
)
882 && TYPE_FIELD_PACKED (type
, i
))
884 /* It is a bitfield. This code does not attempt
885 to look at the bitpos and reconstruct filler,
886 unnamed fields. This would lead to misleading
887 results if the compiler does not put out fields
888 for such things (I don't know what it does). */
889 fprintf_filtered (stream
, " : %d",
890 TYPE_FIELD_BITSIZE (type
, i
));
892 fprintf_filtered (stream
, ";\n");
895 /* If there are both fields and methods, put a blank line
896 between them. Make sure to count only method that we will
897 display; artificial methods will be hidden. */
898 len
= TYPE_NFN_FIELDS (type
);
900 for (i
= 0; i
< len
; i
++)
902 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
903 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
905 for (j
= 0; j
< len2
; j
++)
906 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
909 if (real_len
> 0 && section_type
!= s_none
)
910 fprintf_filtered (stream
, "\n");
912 /* C++: print out the methods */
913 for (i
= 0; i
< len
; i
++)
915 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
916 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
917 char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
918 char *name
= type_name_no_tag (type
);
919 int is_constructor
= name
&& strcmp (method_name
, name
) == 0;
920 for (j
= 0; j
< len2
; j
++)
922 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
923 int is_full_physname_constructor
=
924 is_constructor_name (physname
)
925 || is_destructor_name (physname
)
926 || method_name
[0] == '~';
928 /* Do not print out artificial methods. */
929 if (TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
933 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
935 if (section_type
!= s_protected
)
937 section_type
= s_protected
;
938 fprintfi_filtered (level
+ 2, stream
,
942 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
944 if (section_type
!= s_private
)
946 section_type
= s_private
;
947 fprintfi_filtered (level
+ 2, stream
, "private:\n");
952 if (section_type
!= s_public
)
954 section_type
= s_public
;
955 fprintfi_filtered (level
+ 2, stream
, "public:\n");
959 print_spaces_filtered (level
+ 4, stream
);
960 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
961 fprintf_filtered (stream
, "virtual ");
962 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
963 fprintf_filtered (stream
, "static ");
964 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
966 /* Keep GDB from crashing here. */
967 fprintf_filtered (stream
, _("<undefined type> %s;\n"),
968 TYPE_FN_FIELD_PHYSNAME (f
, j
));
971 else if (!is_constructor
&& /* constructors don't have declared types */
972 !is_full_physname_constructor
&& /* " " */
973 !is_type_conversion_operator (type
, i
, j
))
975 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
977 fputs_filtered (" ", stream
);
979 if (TYPE_FN_FIELD_STUB (f
, j
))
980 /* Build something we can demangle. */
981 mangled_name
= gdb_mangle_name (type
, i
, j
);
983 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
986 cplus_demangle (mangled_name
,
987 DMGL_ANSI
| DMGL_PARAMS
);
988 if (demangled_name
== NULL
)
990 /* in some cases (for instance with the HP demangling),
991 if a function has more than 10 arguments,
992 the demangling will fail.
993 Let's try to reconstruct the function signature from
994 the symbol information */
995 if (!TYPE_FN_FIELD_STUB (f
, j
))
997 int staticp
= TYPE_FN_FIELD_STATIC_P (f
, j
);
998 struct type
*mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
999 cp_type_print_method_args (mtype
,
1006 fprintf_filtered (stream
, _("<badly mangled name '%s'>"),
1012 char *demangled_no_class
1013 = remove_qualifiers (demangled_name
);
1015 /* get rid of the `static' appended by the demangler */
1016 p
= strstr (demangled_no_class
, " static");
1019 int length
= p
- demangled_no_class
;
1020 demangled_no_static
= (char *) xmalloc (length
+ 1);
1021 strncpy (demangled_no_static
, demangled_no_class
, length
);
1022 *(demangled_no_static
+ length
) = '\0';
1023 fputs_filtered (demangled_no_static
, stream
);
1024 xfree (demangled_no_static
);
1027 fputs_filtered (demangled_no_class
, stream
);
1028 xfree (demangled_name
);
1031 if (TYPE_FN_FIELD_STUB (f
, j
))
1032 xfree (mangled_name
);
1034 fprintf_filtered (stream
, ";\n");
1038 fprintfi_filtered (level
, stream
, "}");
1040 if (TYPE_LOCALTYPE_PTR (type
) && show
>= 0)
1041 fprintfi_filtered (level
, stream
, _(" (Local at %s:%d)\n"),
1042 TYPE_LOCALTYPE_FILE (type
),
1043 TYPE_LOCALTYPE_LINE (type
));
1045 if (TYPE_CODE (type
) == TYPE_CODE_TEMPLATE
)
1049 case TYPE_CODE_ENUM
:
1050 c_type_print_modifier (type
, stream
, 0, 1);
1051 fprintf_filtered (stream
, "enum ");
1052 /* Print the tag name if it exists.
1053 The aCC compiler emits a spurious
1054 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1055 tag for unnamed struct/union/enum's, which we don't
1057 if (TYPE_TAG_NAME (type
) != NULL
&&
1058 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
1060 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1062 fputs_filtered (" ", stream
);
1068 /* If we just printed a tag name, no need to print anything else. */
1069 if (TYPE_TAG_NAME (type
) == NULL
)
1070 fprintf_filtered (stream
, "{...}");
1072 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1074 fprintf_filtered (stream
, "{");
1075 len
= TYPE_NFIELDS (type
);
1077 for (i
= 0; i
< len
; i
++)
1081 fprintf_filtered (stream
, ", ");
1083 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1084 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
1086 fprintf_filtered (stream
, " = %d", TYPE_FIELD_BITPOS (type
, i
));
1087 lastval
= TYPE_FIELD_BITPOS (type
, i
);
1091 fprintf_filtered (stream
, "}");
1095 case TYPE_CODE_VOID
:
1096 fprintf_filtered (stream
, "void");
1099 case TYPE_CODE_UNDEF
:
1100 fprintf_filtered (stream
, _("struct <unknown>"));
1103 case TYPE_CODE_ERROR
:
1104 fprintf_filtered (stream
, _("<unknown type>"));
1107 case TYPE_CODE_RANGE
:
1108 /* This should not occur */
1109 fprintf_filtered (stream
, _("<range type>"));
1112 case TYPE_CODE_TEMPLATE
:
1113 /* Called on "ptype t" where "t" is a template.
1114 Prints the template header (with args), e.g.:
1115 template <class T1, class T2> class "
1116 and then merges with the struct/union/class code to
1117 print the rest of the definition. */
1118 c_type_print_modifier (type
, stream
, 0, 1);
1119 fprintf_filtered (stream
, "template <");
1120 for (i
= 0; i
< TYPE_NTEMPLATE_ARGS (type
); i
++)
1122 struct template_arg templ_arg
;
1123 templ_arg
= TYPE_TEMPLATE_ARG (type
, i
);
1124 fprintf_filtered (stream
, "class %s", templ_arg
.name
);
1125 if (i
< TYPE_NTEMPLATE_ARGS (type
) - 1)
1126 fprintf_filtered (stream
, ", ");
1128 fprintf_filtered (stream
, "> class ");
1129 /* Yuck, factor this out to a subroutine so we can call
1130 it and return to the point marked with the "goback:" label... - RT */
1133 if (TYPE_NINSTANTIATIONS (type
) > 0)
1135 fprintf_filtered (stream
, _("\ntemplate instantiations:\n"));
1136 for (i
= 0; i
< TYPE_NINSTANTIATIONS (type
); i
++)
1138 fprintf_filtered (stream
, " ");
1139 c_type_print_base (TYPE_INSTANTIATION (type
, i
), stream
, 0, level
);
1140 if (i
< TYPE_NINSTANTIATIONS (type
) - 1)
1141 fprintf_filtered (stream
, "\n");
1146 case TYPE_CODE_NAMESPACE
:
1147 fputs_filtered ("namespace ", stream
);
1148 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1152 /* Handle types not explicitly handled by the other cases,
1153 such as fundamental types. For these, just print whatever
1154 the type name is, as recorded in the type itself. If there
1155 is no type name, then complain. */
1156 if (TYPE_NAME (type
) != NULL
)
1158 c_type_print_modifier (type
, stream
, 0, 1);
1159 fputs_filtered (TYPE_NAME (type
), stream
);
1163 /* At least for dump_symtab, it is important that this not be
1165 fprintf_filtered (stream
, _("<invalid type code %d>"),