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 /* HP ANSI C++ case */
838 if (TYPE_HAS_VTABLE (type
)
839 && (strncmp (TYPE_FIELD_NAME (type
, i
), "__vfp", 5) == 0))
841 /* Other compilers */
842 if (strncmp (TYPE_FIELD_NAME (type
, i
), "_vptr", 5) == 0
843 && is_cplus_marker ((TYPE_FIELD_NAME (type
, i
))[5]))
846 /* If this is a C++ class we can print the various C++ section
849 if (HAVE_CPLUS_STRUCT (type
) && need_access_label
)
851 if (TYPE_FIELD_PROTECTED (type
, i
))
853 if (section_type
!= s_protected
)
855 section_type
= s_protected
;
856 fprintfi_filtered (level
+ 2, stream
,
860 else if (TYPE_FIELD_PRIVATE (type
, i
))
862 if (section_type
!= s_private
)
864 section_type
= s_private
;
865 fprintfi_filtered (level
+ 2, stream
, "private:\n");
870 if (section_type
!= s_public
)
872 section_type
= s_public
;
873 fprintfi_filtered (level
+ 2, stream
, "public:\n");
878 print_spaces_filtered (level
+ 4, stream
);
879 if (TYPE_FIELD_STATIC (type
, i
))
881 fprintf_filtered (stream
, "static ");
883 c_print_type (TYPE_FIELD_TYPE (type
, i
),
884 TYPE_FIELD_NAME (type
, i
),
885 stream
, show
- 1, level
+ 4);
886 if (!TYPE_FIELD_STATIC (type
, i
)
887 && TYPE_FIELD_PACKED (type
, i
))
889 /* It is a bitfield. This code does not attempt
890 to look at the bitpos and reconstruct filler,
891 unnamed fields. This would lead to misleading
892 results if the compiler does not put out fields
893 for such things (I don't know what it does). */
894 fprintf_filtered (stream
, " : %d",
895 TYPE_FIELD_BITSIZE (type
, i
));
897 fprintf_filtered (stream
, ";\n");
900 /* If there are both fields and methods, put a blank line
901 between them. Make sure to count only method that we will
902 display; artificial methods will be hidden. */
903 len
= TYPE_NFN_FIELDS (type
);
905 for (i
= 0; i
< len
; i
++)
907 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
908 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
910 for (j
= 0; j
< len2
; j
++)
911 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
914 if (real_len
> 0 && section_type
!= s_none
)
915 fprintf_filtered (stream
, "\n");
917 /* C++: print out the methods */
918 for (i
= 0; i
< len
; i
++)
920 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
921 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
922 char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
923 char *name
= type_name_no_tag (type
);
924 int is_constructor
= name
&& strcmp (method_name
, name
) == 0;
925 for (j
= 0; j
< len2
; j
++)
927 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
928 int is_full_physname_constructor
=
929 is_constructor_name (physname
)
930 || is_destructor_name (physname
)
931 || method_name
[0] == '~';
933 /* Do not print out artificial methods. */
934 if (TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
938 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
940 if (section_type
!= s_protected
)
942 section_type
= s_protected
;
943 fprintfi_filtered (level
+ 2, stream
,
947 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
949 if (section_type
!= s_private
)
951 section_type
= s_private
;
952 fprintfi_filtered (level
+ 2, stream
, "private:\n");
957 if (section_type
!= s_public
)
959 section_type
= s_public
;
960 fprintfi_filtered (level
+ 2, stream
, "public:\n");
964 print_spaces_filtered (level
+ 4, stream
);
965 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
966 fprintf_filtered (stream
, "virtual ");
967 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
968 fprintf_filtered (stream
, "static ");
969 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
971 /* Keep GDB from crashing here. */
972 fprintf_filtered (stream
, _("<undefined type> %s;\n"),
973 TYPE_FN_FIELD_PHYSNAME (f
, j
));
976 else if (!is_constructor
&& /* constructors don't have declared types */
977 !is_full_physname_constructor
&& /* " " */
978 !is_type_conversion_operator (type
, i
, j
))
980 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
982 fputs_filtered (" ", stream
);
984 if (TYPE_FN_FIELD_STUB (f
, j
))
985 /* Build something we can demangle. */
986 mangled_name
= gdb_mangle_name (type
, i
, j
);
988 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
991 cplus_demangle (mangled_name
,
992 DMGL_ANSI
| DMGL_PARAMS
);
993 if (demangled_name
== NULL
)
995 /* in some cases (for instance with the HP demangling),
996 if a function has more than 10 arguments,
997 the demangling will fail.
998 Let's try to reconstruct the function signature from
999 the symbol information */
1000 if (!TYPE_FN_FIELD_STUB (f
, j
))
1002 int staticp
= TYPE_FN_FIELD_STATIC_P (f
, j
);
1003 struct type
*mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1004 cp_type_print_method_args (mtype
,
1011 fprintf_filtered (stream
, _("<badly mangled name '%s'>"),
1017 char *demangled_no_class
1018 = remove_qualifiers (demangled_name
);
1020 /* get rid of the `static' appended by the demangler */
1021 p
= strstr (demangled_no_class
, " static");
1024 int length
= p
- demangled_no_class
;
1025 demangled_no_static
= (char *) xmalloc (length
+ 1);
1026 strncpy (demangled_no_static
, demangled_no_class
, length
);
1027 *(demangled_no_static
+ length
) = '\0';
1028 fputs_filtered (demangled_no_static
, stream
);
1029 xfree (demangled_no_static
);
1032 fputs_filtered (demangled_no_class
, stream
);
1033 xfree (demangled_name
);
1036 if (TYPE_FN_FIELD_STUB (f
, j
))
1037 xfree (mangled_name
);
1039 fprintf_filtered (stream
, ";\n");
1043 fprintfi_filtered (level
, stream
, "}");
1045 if (TYPE_LOCALTYPE_PTR (type
) && show
>= 0)
1046 fprintfi_filtered (level
, stream
, _(" (Local at %s:%d)\n"),
1047 TYPE_LOCALTYPE_FILE (type
),
1048 TYPE_LOCALTYPE_LINE (type
));
1050 if (TYPE_CODE (type
) == TYPE_CODE_TEMPLATE
)
1054 case TYPE_CODE_ENUM
:
1055 c_type_print_modifier (type
, stream
, 0, 1);
1056 fprintf_filtered (stream
, "enum ");
1057 /* Print the tag name if it exists.
1058 The aCC compiler emits a spurious
1059 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1060 tag for unnamed struct/union/enum's, which we don't
1062 if (TYPE_TAG_NAME (type
) != NULL
&&
1063 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
1065 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1067 fputs_filtered (" ", stream
);
1073 /* If we just printed a tag name, no need to print anything else. */
1074 if (TYPE_TAG_NAME (type
) == NULL
)
1075 fprintf_filtered (stream
, "{...}");
1077 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1079 fprintf_filtered (stream
, "{");
1080 len
= TYPE_NFIELDS (type
);
1082 for (i
= 0; i
< len
; i
++)
1086 fprintf_filtered (stream
, ", ");
1088 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1089 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
1091 fprintf_filtered (stream
, " = %d", TYPE_FIELD_BITPOS (type
, i
));
1092 lastval
= TYPE_FIELD_BITPOS (type
, i
);
1096 fprintf_filtered (stream
, "}");
1100 case TYPE_CODE_VOID
:
1101 fprintf_filtered (stream
, "void");
1104 case TYPE_CODE_UNDEF
:
1105 fprintf_filtered (stream
, _("struct <unknown>"));
1108 case TYPE_CODE_ERROR
:
1109 fprintf_filtered (stream
, _("<unknown type>"));
1112 case TYPE_CODE_RANGE
:
1113 /* This should not occur */
1114 fprintf_filtered (stream
, _("<range type>"));
1117 case TYPE_CODE_TEMPLATE
:
1118 /* Called on "ptype t" where "t" is a template.
1119 Prints the template header (with args), e.g.:
1120 template <class T1, class T2> class "
1121 and then merges with the struct/union/class code to
1122 print the rest of the definition. */
1123 c_type_print_modifier (type
, stream
, 0, 1);
1124 fprintf_filtered (stream
, "template <");
1125 for (i
= 0; i
< TYPE_NTEMPLATE_ARGS (type
); i
++)
1127 struct template_arg templ_arg
;
1128 templ_arg
= TYPE_TEMPLATE_ARG (type
, i
);
1129 fprintf_filtered (stream
, "class %s", templ_arg
.name
);
1130 if (i
< TYPE_NTEMPLATE_ARGS (type
) - 1)
1131 fprintf_filtered (stream
, ", ");
1133 fprintf_filtered (stream
, "> class ");
1134 /* Yuck, factor this out to a subroutine so we can call
1135 it and return to the point marked with the "goback:" label... - RT */
1138 if (TYPE_NINSTANTIATIONS (type
) > 0)
1140 fprintf_filtered (stream
, _("\ntemplate instantiations:\n"));
1141 for (i
= 0; i
< TYPE_NINSTANTIATIONS (type
); i
++)
1143 fprintf_filtered (stream
, " ");
1144 c_type_print_base (TYPE_INSTANTIATION (type
, i
), stream
, 0, level
);
1145 if (i
< TYPE_NINSTANTIATIONS (type
) - 1)
1146 fprintf_filtered (stream
, "\n");
1151 case TYPE_CODE_NAMESPACE
:
1152 fputs_filtered ("namespace ", stream
);
1153 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1157 /* Handle types not explicitly handled by the other cases,
1158 such as fundamental types. For these, just print whatever
1159 the type name is, as recorded in the type itself. If there
1160 is no type name, then complain. */
1161 if (TYPE_NAME (type
) != NULL
)
1163 c_type_print_modifier (type
, stream
, 0, 1);
1164 fputs_filtered (TYPE_NAME (type
), stream
);
1168 /* At least for dump_symtab, it is important that this not be
1170 fprintf_filtered (stream
, _("<invalid type code %d>"),