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 2 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, write to the Free Software
19 Foundation, Inc., 51 Franklin Street, Fifth Floor,
20 Boston, MA 02110-1301, USA. */
23 #include "gdb_obstack.h"
24 #include "bfd.h" /* Binary File Description */
27 #include "expression.h"
34 #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 c_type_print_args (struct type
*, struct ui_file
*);
46 static void cp_type_print_derivation_info (struct ui_file
*, struct type
*);
48 static void c_type_print_varspec_prefix (struct type
*, struct ui_file
*, int,
51 /* Print "const", "volatile", or address space modifiers. */
52 static void c_type_print_modifier (struct type
*, struct ui_file
*,
58 /* LEVEL is the depth to indent lines by. */
61 c_print_type (struct type
*type
, char *varstring
, struct ui_file
*stream
,
71 c_type_print_base (type
, stream
, show
, level
);
72 code
= TYPE_CODE (type
);
73 if ((varstring
!= NULL
&& *varstring
!= '\0')
75 /* Need a space if going to print stars or brackets;
76 but not if we will print just a type name. */
77 ((show
> 0 || TYPE_NAME (type
) == 0)
79 (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
80 || code
== TYPE_CODE_METHOD
81 || code
== TYPE_CODE_ARRAY
82 || code
== TYPE_CODE_MEMBERPTR
83 || code
== TYPE_CODE_METHODPTR
84 || code
== TYPE_CODE_REF
)))
85 fputs_filtered (" ", stream
);
86 need_post_space
= (varstring
!= NULL
&& strcmp (varstring
, "") != 0);
87 c_type_print_varspec_prefix (type
, stream
, show
, 0, need_post_space
);
89 if (varstring
!= NULL
)
91 fputs_filtered (varstring
, stream
);
93 /* For demangled function names, we have the arglist as part of the name,
94 so don't print an additional pair of ()'s */
96 demangled_args
= strchr (varstring
, '(') != NULL
;
97 c_type_print_varspec_suffix (type
, stream
, show
, 0, demangled_args
);
101 /* If TYPE is a derived type, then print out derivation information.
102 Print only the actual base classes of this type, not the base classes
103 of the base classes. I.E. for the derivation hierarchy:
106 class B : public A {int b; };
107 class C : public B {int c; };
109 Print the type of class C as:
115 Not as the following (like gdb used to), which is not legal C++ syntax for
116 derived types and may be confused with the multiple inheritance form:
118 class C : public B : public A {
122 In general, gdb should try to print the types as closely as possible to
123 the form that they appear in the source code.
124 Note that in case of protected derivation gcc will not say 'protected'
125 but 'private'. The HP's aCC compiler emits specific information for
126 derivation via protected inheritance, so gdb can print it out */
129 cp_type_print_derivation_info (struct ui_file
*stream
, struct type
*type
)
134 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
136 fputs_filtered (i
== 0 ? ": " : ", ", stream
);
137 fprintf_filtered (stream
, "%s%s ",
138 BASETYPE_VIA_PUBLIC (type
, i
) ? "public"
139 : (TYPE_FIELD_PROTECTED (type
, i
) ? "protected" : "private"),
140 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
141 name
= type_name_no_tag (TYPE_BASECLASS (type
, i
));
142 fprintf_filtered (stream
, "%s", name
? name
: "(null)");
146 fputs_filtered (" ", stream
);
150 /* Print the C++ method arguments ARGS to the file STREAM. */
153 cp_type_print_method_args (struct type
*mtype
, char *prefix
, char *varstring
,
154 int staticp
, struct ui_file
*stream
)
156 struct field
*args
= TYPE_FIELDS (mtype
);
157 int nargs
= TYPE_NFIELDS (mtype
);
158 int varargs
= TYPE_VARARGS (mtype
);
161 fprintf_symbol_filtered (stream
, prefix
, language_cplus
, DMGL_ANSI
);
162 fprintf_symbol_filtered (stream
, varstring
, language_cplus
, DMGL_ANSI
);
163 fputs_filtered ("(", stream
);
165 /* Skip the class variable. */
171 type_print (args
[i
++].type
, "", stream
, 0);
173 if (i
== nargs
&& varargs
)
174 fprintf_filtered (stream
, ", ...");
176 fprintf_filtered (stream
, ", ");
180 fprintf_filtered (stream
, "...");
181 else if (current_language
->la_language
== language_cplus
)
182 fprintf_filtered (stream
, "void");
184 fprintf_filtered (stream
, ")");
188 /* Print any asterisks or open-parentheses needed before the
189 variable name (to describe its type).
191 On outermost call, pass 0 for PASSED_A_PTR.
192 On outermost call, SHOW > 0 means should ignore
193 any typename for TYPE and show its details.
194 SHOW is always zero on recursive calls.
196 NEED_POST_SPACE is non-zero when a space will be be needed
197 between a trailing qualifier and a field, variable, or function
201 c_type_print_varspec_prefix (struct type
*type
, struct ui_file
*stream
,
202 int show
, int passed_a_ptr
, int need_post_space
)
208 if (TYPE_NAME (type
) && show
<= 0)
213 switch (TYPE_CODE (type
))
216 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 1, 1);
217 fprintf_filtered (stream
, "*");
218 c_type_print_modifier (type
, stream
, 1, need_post_space
);
221 case TYPE_CODE_MEMBERPTR
:
222 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
223 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
225 fputs_filtered (name
, stream
);
227 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
228 fprintf_filtered (stream
, "::*");
231 case TYPE_CODE_METHODPTR
:
232 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
233 fprintf_filtered (stream
, "(");
234 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
236 fputs_filtered (name
, stream
);
238 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
239 fprintf_filtered (stream
, "::*");
243 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 1, 0);
244 fprintf_filtered (stream
, "&");
245 c_type_print_modifier (type
, stream
, 1, need_post_space
);
248 case TYPE_CODE_METHOD
:
250 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
252 fprintf_filtered (stream
, "(");
255 case TYPE_CODE_ARRAY
:
256 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
258 fprintf_filtered (stream
, "(");
261 case TYPE_CODE_TYPEDEF
:
262 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
265 case TYPE_CODE_UNDEF
:
266 case TYPE_CODE_STRUCT
:
267 case TYPE_CODE_UNION
:
272 case TYPE_CODE_ERROR
:
276 case TYPE_CODE_RANGE
:
277 case TYPE_CODE_STRING
:
278 case TYPE_CODE_BITSTRING
:
279 case TYPE_CODE_COMPLEX
:
280 case TYPE_CODE_TEMPLATE
:
281 case TYPE_CODE_NAMESPACE
:
282 /* These types need no prefix. They are listed here so that
283 gcc -Wall will reveal any types that haven't been handled. */
286 error (_("type not handled in c_type_print_varspec_prefix()"));
291 /* Print out "const" and "volatile" attributes.
292 TYPE is a pointer to the type being printed out.
293 STREAM is the output destination.
294 NEED_SPACE = 1 indicates an initial white space is needed */
297 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
298 int need_pre_space
, int need_post_space
)
300 int did_print_modifier
= 0;
301 const char *address_space_id
;
303 /* We don't print `const' qualifiers for references --- since all
304 operators affect the thing referenced, not the reference itself,
305 every reference is `const'. */
306 if (TYPE_CONST (type
)
307 && TYPE_CODE (type
) != TYPE_CODE_REF
)
310 fprintf_filtered (stream
, " ");
311 fprintf_filtered (stream
, "const");
312 did_print_modifier
= 1;
315 if (TYPE_VOLATILE (type
))
317 if (did_print_modifier
|| need_pre_space
)
318 fprintf_filtered (stream
, " ");
319 fprintf_filtered (stream
, "volatile");
320 did_print_modifier
= 1;
323 address_space_id
= address_space_int_to_name (TYPE_INSTANCE_FLAGS (type
));
324 if (address_space_id
)
326 if (did_print_modifier
|| need_pre_space
)
327 fprintf_filtered (stream
, " ");
328 fprintf_filtered (stream
, "@%s", address_space_id
);
329 did_print_modifier
= 1;
332 if (did_print_modifier
&& need_post_space
)
333 fprintf_filtered (stream
, " ");
337 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
338 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
339 in non-static methods, are displayed. */
342 c_type_print_args (struct type
*type
, struct ui_file
*stream
)
348 fprintf_filtered (stream
, "(");
349 args
= TYPE_FIELDS (type
);
350 len
= TYPE_NFIELDS (type
);
352 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
356 fprintf_filtered (stream
, ", ");
360 c_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
364 if (printed_any
&& TYPE_VARARGS (type
))
366 /* Print out a trailing ellipsis for varargs functions. Ignore
367 TYPE_VARARGS if the function has no named arguments; that
368 represents unprototyped (K&R style) C functions. */
369 if (printed_any
&& TYPE_VARARGS (type
))
371 fprintf_filtered (stream
, ", ");
373 fprintf_filtered (stream
, "...");
376 else if (!printed_any
377 && (TYPE_PROTOTYPED (type
)
378 || current_language
->la_language
== language_cplus
))
379 fprintf_filtered (stream
, "void");
381 fprintf_filtered (stream
, ")");
385 /* Return true iff the j'th overloading of the i'th method of TYPE
386 is a type conversion operator, like `operator int () { ... }'.
387 When listing a class's methods, we don't print the return type of
390 is_type_conversion_operator (struct type
*type
, int i
, int j
)
392 /* I think the whole idea of recognizing type conversion operators
393 by their name is pretty terrible. But I don't think our present
394 data structure gives us any other way to tell. If you know of
395 some other way, feel free to rewrite this function. */
396 char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
398 if (strncmp (name
, "operator", 8) != 0)
402 if (! strchr (" \t\f\n\r", *name
))
405 while (strchr (" \t\f\n\r", *name
))
408 if (!('a' <= *name
&& *name
<= 'z')
409 && !('A' <= *name
&& *name
<= 'Z')
411 /* If this doesn't look like the start of an identifier, then it
412 isn't a type conversion operator. */
414 else if (strncmp (name
, "new", 3) == 0)
416 else if (strncmp (name
, "delete", 6) == 0)
419 /* If it doesn't look like new or delete, it's a type conversion
423 /* Is that really the end of the name? */
424 if (('a' <= *name
&& *name
<= 'z')
425 || ('A' <= *name
&& *name
<= 'Z')
426 || ('0' <= *name
&& *name
<= '9')
428 /* No, so the identifier following "operator" must be a type name,
429 and this is a type conversion operator. */
432 /* That was indeed the end of the name, so it was `operator new' or
433 `operator delete', neither of which are type conversion operators. */
438 /* Given a C++ qualified identifier QID, strip off the qualifiers,
439 yielding the unqualified name. The return value is a pointer into
442 It's a pity we don't have this information in some more structured
443 form. Even the author of this function feels that writing little
444 parsers like this everywhere is stupid. */
446 remove_qualifiers (char *qid
)
448 int quoted
= 0; /* zero if we're not in quotes;
449 '"' if we're in a double-quoted string;
450 '\'' if we're in a single-quoted string. */
451 int depth
= 0; /* number of unclosed parens we've seen */
452 char *parenstack
= (char *) alloca (strlen (qid
));
454 char *last
= 0; /* The character after the rightmost
455 `::' token we've seen so far. */
457 for (scan
= qid
; *scan
; scan
++)
463 else if (*scan
== '\\' && *(scan
+ 1))
466 else if (scan
[0] == ':' && scan
[1] == ':')
468 /* If we're inside parenthesis (i.e., an argument list) or
469 angle brackets (i.e., a list of template arguments), then
470 we don't record the position of this :: token, since it's
471 not relevant to the top-level structure we're trying
479 else if (*scan
== '"' || *scan
== '\'')
481 else if (*scan
== '(')
482 parenstack
[depth
++] = ')';
483 else if (*scan
== '[')
484 parenstack
[depth
++] = ']';
485 /* We're going to treat <> as a pair of matching characters,
486 since we're more likely to see those in template id's than
487 real less-than characters. What a crock. */
488 else if (*scan
== '<')
489 parenstack
[depth
++] = '>';
490 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
492 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
496 /* We're going to do a little error recovery here. If we
497 don't find a match for *scan on the paren stack, but
498 there is something lower on the stack that does match, we
499 pop the stack to that point. */
502 for (i
= depth
- 1; i
>= 0; i
--)
503 if (parenstack
[i
] == *scan
)
515 /* We didn't find any :: tokens at the top level, so declare the
516 whole thing an unqualified identifier. */
521 /* Print any array sizes, function arguments or close parentheses
522 needed after the variable name (to describe its type).
523 Args work like c_type_print_varspec_prefix. */
526 c_type_print_varspec_suffix (struct type
*type
, struct ui_file
*stream
,
527 int show
, int passed_a_ptr
, int demangled_args
)
532 if (TYPE_NAME (type
) && show
<= 0)
537 switch (TYPE_CODE (type
))
539 case TYPE_CODE_ARRAY
:
541 fprintf_filtered (stream
, ")");
543 fprintf_filtered (stream
, "[");
544 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0
545 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
546 fprintf_filtered (stream
, "%d",
548 / TYPE_LENGTH (TYPE_TARGET_TYPE (type
))));
549 fprintf_filtered (stream
, "]");
551 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
555 case TYPE_CODE_MEMBERPTR
:
556 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
560 case TYPE_CODE_METHODPTR
:
561 fprintf_filtered (stream
, ")");
562 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
568 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
572 case TYPE_CODE_METHOD
:
575 fprintf_filtered (stream
, ")");
577 c_type_print_args (type
, stream
);
578 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
582 case TYPE_CODE_TYPEDEF
:
583 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
587 case TYPE_CODE_UNDEF
:
588 case TYPE_CODE_STRUCT
:
589 case TYPE_CODE_UNION
:
594 case TYPE_CODE_ERROR
:
598 case TYPE_CODE_RANGE
:
599 case TYPE_CODE_STRING
:
600 case TYPE_CODE_BITSTRING
:
601 case TYPE_CODE_COMPLEX
:
602 case TYPE_CODE_TEMPLATE
:
603 case TYPE_CODE_NAMESPACE
:
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>"),