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 /* These types need no prefix. They are listed here so that
281 gcc -Wall will reveal any types that haven't been handled. */
284 error (_("type not handled in c_type_print_varspec_prefix()"));
289 /* Print out "const" and "volatile" attributes.
290 TYPE is a pointer to the type being printed out.
291 STREAM is the output destination.
292 NEED_SPACE = 1 indicates an initial white space is needed */
295 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
296 int need_pre_space
, int need_post_space
)
298 int did_print_modifier
= 0;
299 const char *address_space_id
;
301 /* We don't print `const' qualifiers for references --- since all
302 operators affect the thing referenced, not the reference itself,
303 every reference is `const'. */
304 if (TYPE_CONST (type
)
305 && TYPE_CODE (type
) != TYPE_CODE_REF
)
308 fprintf_filtered (stream
, " ");
309 fprintf_filtered (stream
, "const");
310 did_print_modifier
= 1;
313 if (TYPE_VOLATILE (type
))
315 if (did_print_modifier
|| need_pre_space
)
316 fprintf_filtered (stream
, " ");
317 fprintf_filtered (stream
, "volatile");
318 did_print_modifier
= 1;
321 address_space_id
= address_space_int_to_name (TYPE_INSTANCE_FLAGS (type
));
322 if (address_space_id
)
324 if (did_print_modifier
|| need_pre_space
)
325 fprintf_filtered (stream
, " ");
326 fprintf_filtered (stream
, "@%s", address_space_id
);
327 did_print_modifier
= 1;
330 if (did_print_modifier
&& need_post_space
)
331 fprintf_filtered (stream
, " ");
335 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
336 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
337 in non-static methods, are displayed. */
340 c_type_print_args (struct type
*type
, struct ui_file
*stream
)
346 fprintf_filtered (stream
, "(");
347 args
= TYPE_FIELDS (type
);
348 len
= TYPE_NFIELDS (type
);
350 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
354 fprintf_filtered (stream
, ", ");
358 c_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
362 if (printed_any
&& TYPE_VARARGS (type
))
364 /* Print out a trailing ellipsis for varargs functions. Ignore
365 TYPE_VARARGS if the function has no named arguments; that
366 represents unprototyped (K&R style) C functions. */
367 if (printed_any
&& TYPE_VARARGS (type
))
369 fprintf_filtered (stream
, ", ");
371 fprintf_filtered (stream
, "...");
374 else if (!printed_any
375 && (TYPE_PROTOTYPED (type
)
376 || current_language
->la_language
== language_cplus
))
377 fprintf_filtered (stream
, "void");
379 fprintf_filtered (stream
, ")");
383 /* Return true iff the j'th overloading of the i'th method of TYPE
384 is a type conversion operator, like `operator int () { ... }'.
385 When listing a class's methods, we don't print the return type of
388 is_type_conversion_operator (struct type
*type
, int i
, int j
)
390 /* I think the whole idea of recognizing type conversion operators
391 by their name is pretty terrible. But I don't think our present
392 data structure gives us any other way to tell. If you know of
393 some other way, feel free to rewrite this function. */
394 char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
396 if (strncmp (name
, "operator", 8) != 0)
400 if (! strchr (" \t\f\n\r", *name
))
403 while (strchr (" \t\f\n\r", *name
))
406 if (!('a' <= *name
&& *name
<= 'z')
407 && !('A' <= *name
&& *name
<= 'Z')
409 /* If this doesn't look like the start of an identifier, then it
410 isn't a type conversion operator. */
412 else if (strncmp (name
, "new", 3) == 0)
414 else if (strncmp (name
, "delete", 6) == 0)
417 /* If it doesn't look like new or delete, it's a type conversion
421 /* Is that really the end of the name? */
422 if (('a' <= *name
&& *name
<= 'z')
423 || ('A' <= *name
&& *name
<= 'Z')
424 || ('0' <= *name
&& *name
<= '9')
426 /* No, so the identifier following "operator" must be a type name,
427 and this is a type conversion operator. */
430 /* That was indeed the end of the name, so it was `operator new' or
431 `operator delete', neither of which are type conversion operators. */
436 /* Given a C++ qualified identifier QID, strip off the qualifiers,
437 yielding the unqualified name. The return value is a pointer into
440 It's a pity we don't have this information in some more structured
441 form. Even the author of this function feels that writing little
442 parsers like this everywhere is stupid. */
444 remove_qualifiers (char *qid
)
446 int quoted
= 0; /* zero if we're not in quotes;
447 '"' if we're in a double-quoted string;
448 '\'' if we're in a single-quoted string. */
449 int depth
= 0; /* number of unclosed parens we've seen */
450 char *parenstack
= (char *) alloca (strlen (qid
));
452 char *last
= 0; /* The character after the rightmost
453 `::' token we've seen so far. */
455 for (scan
= qid
; *scan
; scan
++)
461 else if (*scan
== '\\' && *(scan
+ 1))
464 else if (scan
[0] == ':' && scan
[1] == ':')
466 /* If we're inside parenthesis (i.e., an argument list) or
467 angle brackets (i.e., a list of template arguments), then
468 we don't record the position of this :: token, since it's
469 not relevant to the top-level structure we're trying
477 else if (*scan
== '"' || *scan
== '\'')
479 else if (*scan
== '(')
480 parenstack
[depth
++] = ')';
481 else if (*scan
== '[')
482 parenstack
[depth
++] = ']';
483 /* We're going to treat <> as a pair of matching characters,
484 since we're more likely to see those in template id's than
485 real less-than characters. What a crock. */
486 else if (*scan
== '<')
487 parenstack
[depth
++] = '>';
488 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
490 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
494 /* We're going to do a little error recovery here. If we
495 don't find a match for *scan on the paren stack, but
496 there is something lower on the stack that does match, we
497 pop the stack to that point. */
500 for (i
= depth
- 1; i
>= 0; i
--)
501 if (parenstack
[i
] == *scan
)
513 /* We didn't find any :: tokens at the top level, so declare the
514 whole thing an unqualified identifier. */
519 /* Print any array sizes, function arguments or close parentheses
520 needed after the variable name (to describe its type).
521 Args work like c_type_print_varspec_prefix. */
524 c_type_print_varspec_suffix (struct type
*type
, struct ui_file
*stream
,
525 int show
, int passed_a_ptr
, int demangled_args
)
530 if (TYPE_NAME (type
) && show
<= 0)
535 switch (TYPE_CODE (type
))
537 case TYPE_CODE_ARRAY
:
539 fprintf_filtered (stream
, ")");
541 fprintf_filtered (stream
, "[");
542 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0
543 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
544 fprintf_filtered (stream
, "%d",
546 / TYPE_LENGTH (TYPE_TARGET_TYPE (type
))));
547 fprintf_filtered (stream
, "]");
549 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
553 case TYPE_CODE_MEMBERPTR
:
554 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
558 case TYPE_CODE_METHODPTR
:
559 fprintf_filtered (stream
, ")");
560 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
566 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
570 case TYPE_CODE_METHOD
:
573 fprintf_filtered (stream
, ")");
575 c_type_print_args (type
, stream
);
576 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
580 case TYPE_CODE_TYPEDEF
:
581 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
585 case TYPE_CODE_UNDEF
:
586 case TYPE_CODE_STRUCT
:
587 case TYPE_CODE_UNION
:
592 case TYPE_CODE_ERROR
:
596 case TYPE_CODE_RANGE
:
597 case TYPE_CODE_STRING
:
598 case TYPE_CODE_BITSTRING
:
599 case TYPE_CODE_COMPLEX
:
600 case TYPE_CODE_TEMPLATE
:
601 case TYPE_CODE_NAMESPACE
:
602 /* These types do not need a suffix. They are listed so that
603 gcc -Wall will report types that may not have been considered. */
606 error (_("type not handled in c_type_print_varspec_suffix()"));
611 /* Print the name of the type (or the ultimate pointer target,
612 function value or array element), or the description of a
615 SHOW positive means print details about the type (e.g. enum values),
616 and print structure elements passing SHOW - 1 for show.
617 SHOW negative means just print the type name or struct tag if there is one.
618 If there is no name, print something sensible but concise like
620 SHOW zero means just print the type name or struct tag if there is one.
621 If there is no name, print something sensible but not as concise like
622 "struct {int x; int y;}".
624 LEVEL is the number of spaces to indent by.
625 We increase it for some recursive calls. */
628 c_type_print_base (struct type
*type
, struct ui_file
*stream
, int show
,
635 char *demangled_name
;
636 char *demangled_no_static
;
639 s_none
, s_public
, s_private
, s_protected
642 int need_access_label
= 0;
650 fputs_filtered (_("<type unknown>"), stream
);
654 /* When SHOW is zero or less, and there is a valid type name, then always
655 just print the type name directly from the type. */
656 /* If we have "typedef struct foo {. . .} bar;" do we want to print it
657 as "struct foo" or as "bar"? Pick the latter, because C++ folk tend
658 to expect things like "class5 *foo" rather than "struct class5 *foo". */
661 && TYPE_NAME (type
) != NULL
)
663 c_type_print_modifier (type
, stream
, 0, 1);
664 fputs_filtered (TYPE_NAME (type
), stream
);
668 CHECK_TYPEDEF (type
);
670 switch (TYPE_CODE (type
))
672 case TYPE_CODE_TYPEDEF
:
673 case TYPE_CODE_ARRAY
:
675 case TYPE_CODE_MEMBERPTR
:
678 case TYPE_CODE_METHOD
:
679 case TYPE_CODE_METHODPTR
:
680 c_type_print_base (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
683 case TYPE_CODE_STRUCT
:
684 c_type_print_modifier (type
, stream
, 0, 1);
685 /* Note TYPE_CODE_STRUCT and TYPE_CODE_CLASS have the same value,
686 * so we use another means for distinguishing them.
688 if (HAVE_CPLUS_STRUCT (type
))
690 switch (TYPE_DECLARED_TYPE (type
))
692 case DECLARED_TYPE_CLASS
:
693 fprintf_filtered (stream
, "class ");
695 case DECLARED_TYPE_UNION
:
696 fprintf_filtered (stream
, "union ");
698 case DECLARED_TYPE_STRUCT
:
699 fprintf_filtered (stream
, "struct ");
702 /* If there is a CPLUS_STRUCT, assume class if not
703 * otherwise specified in the declared_type field.
705 fprintf_filtered (stream
, "class ");
711 /* If not CPLUS_STRUCT, then assume it's a C struct */
712 fprintf_filtered (stream
, "struct ");
716 case TYPE_CODE_UNION
:
717 c_type_print_modifier (type
, stream
, 0, 1);
718 fprintf_filtered (stream
, "union ");
722 /* Print the tag if it exists.
723 * The HP aCC compiler emits
724 * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
725 * tag for unnamed struct/union/enum's, which we don't
728 if (TYPE_TAG_NAME (type
) != NULL
&&
729 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
731 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
733 fputs_filtered (" ", stream
);
738 /* If we just printed a tag name, no need to print anything else. */
739 if (TYPE_TAG_NAME (type
) == NULL
)
740 fprintf_filtered (stream
, "{...}");
742 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
744 cp_type_print_derivation_info (stream
, type
);
746 fprintf_filtered (stream
, "{\n");
747 if ((TYPE_NFIELDS (type
) == 0) && (TYPE_NFN_FIELDS (type
) == 0))
749 if (TYPE_STUB (type
))
750 fprintfi_filtered (level
+ 4, stream
, _("<incomplete type>\n"));
752 fprintfi_filtered (level
+ 4, stream
, _("<no data fields>\n"));
755 /* Start off with no specific section type, so we can print
756 one for the first field we find, and use that section type
757 thereafter until we find another type. */
759 section_type
= s_none
;
761 /* For a class, if all members are private, there's no need
762 for a "private:" label; similarly, for a struct or union
763 masquerading as a class, if all members are public, there's
764 no need for a "public:" label. */
766 if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_CLASS
) ||
767 (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_TEMPLATE
))
770 len
= TYPE_NFIELDS (type
);
771 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
772 if (!TYPE_FIELD_PRIVATE (type
, i
))
774 need_access_label
= 1;
778 if (!need_access_label
)
780 len2
= TYPE_NFN_FIELDS (type
);
781 for (j
= 0; j
< len2
; j
++)
783 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
784 for (i
= 0; i
< len
; i
++)
785 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
))
787 need_access_label
= 1;
790 if (need_access_label
)
795 else if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_STRUCT
) ||
796 (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_UNION
))
799 len
= TYPE_NFIELDS (type
);
800 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
801 if (TYPE_FIELD_PRIVATE (type
, i
) || TYPE_FIELD_PROTECTED (type
, i
))
803 need_access_label
= 1;
807 if (!need_access_label
)
809 len2
= TYPE_NFN_FIELDS (type
);
810 for (j
= 0; j
< len2
; j
++)
813 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
814 for (i
= 0; i
< len
; i
++)
815 if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
) ||
816 TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
, j
), i
))
818 need_access_label
= 1;
821 if (need_access_label
)
827 /* If there is a base class for this type,
828 do not print the field that it occupies. */
830 len
= TYPE_NFIELDS (type
);
831 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
834 /* Don't print out virtual function table. */
835 /* HP ANSI C++ case */
836 if (TYPE_HAS_VTABLE (type
)
837 && (strncmp (TYPE_FIELD_NAME (type
, i
), "__vfp", 5) == 0))
839 /* Other compilers */
840 if (strncmp (TYPE_FIELD_NAME (type
, i
), "_vptr", 5) == 0
841 && is_cplus_marker ((TYPE_FIELD_NAME (type
, i
))[5]))
844 /* If this is a C++ class we can print the various C++ section
847 if (HAVE_CPLUS_STRUCT (type
) && need_access_label
)
849 if (TYPE_FIELD_PROTECTED (type
, i
))
851 if (section_type
!= s_protected
)
853 section_type
= s_protected
;
854 fprintfi_filtered (level
+ 2, stream
,
858 else if (TYPE_FIELD_PRIVATE (type
, i
))
860 if (section_type
!= s_private
)
862 section_type
= s_private
;
863 fprintfi_filtered (level
+ 2, stream
, "private:\n");
868 if (section_type
!= s_public
)
870 section_type
= s_public
;
871 fprintfi_filtered (level
+ 2, stream
, "public:\n");
876 print_spaces_filtered (level
+ 4, stream
);
877 if (TYPE_FIELD_STATIC (type
, i
))
879 fprintf_filtered (stream
, "static ");
881 c_print_type (TYPE_FIELD_TYPE (type
, i
),
882 TYPE_FIELD_NAME (type
, i
),
883 stream
, show
- 1, level
+ 4);
884 if (!TYPE_FIELD_STATIC (type
, i
)
885 && TYPE_FIELD_PACKED (type
, i
))
887 /* It is a bitfield. This code does not attempt
888 to look at the bitpos and reconstruct filler,
889 unnamed fields. This would lead to misleading
890 results if the compiler does not put out fields
891 for such things (I don't know what it does). */
892 fprintf_filtered (stream
, " : %d",
893 TYPE_FIELD_BITSIZE (type
, i
));
895 fprintf_filtered (stream
, ";\n");
898 /* If there are both fields and methods, put a blank line
899 between them. Make sure to count only method that we will
900 display; artificial methods will be hidden. */
901 len
= TYPE_NFN_FIELDS (type
);
903 for (i
= 0; i
< len
; i
++)
905 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
906 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
908 for (j
= 0; j
< len2
; j
++)
909 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
912 if (real_len
> 0 && section_type
!= s_none
)
913 fprintf_filtered (stream
, "\n");
915 /* C++: print out the methods */
916 for (i
= 0; i
< len
; i
++)
918 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
919 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
920 char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
921 char *name
= type_name_no_tag (type
);
922 int is_constructor
= name
&& strcmp (method_name
, name
) == 0;
923 for (j
= 0; j
< len2
; j
++)
925 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
926 int is_full_physname_constructor
=
927 is_constructor_name (physname
)
928 || is_destructor_name (physname
)
929 || method_name
[0] == '~';
931 /* Do not print out artificial methods. */
932 if (TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
936 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
938 if (section_type
!= s_protected
)
940 section_type
= s_protected
;
941 fprintfi_filtered (level
+ 2, stream
,
945 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
947 if (section_type
!= s_private
)
949 section_type
= s_private
;
950 fprintfi_filtered (level
+ 2, stream
, "private:\n");
955 if (section_type
!= s_public
)
957 section_type
= s_public
;
958 fprintfi_filtered (level
+ 2, stream
, "public:\n");
962 print_spaces_filtered (level
+ 4, stream
);
963 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
964 fprintf_filtered (stream
, "virtual ");
965 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
966 fprintf_filtered (stream
, "static ");
967 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
969 /* Keep GDB from crashing here. */
970 fprintf_filtered (stream
, _("<undefined type> %s;\n"),
971 TYPE_FN_FIELD_PHYSNAME (f
, j
));
974 else if (!is_constructor
&& /* constructors don't have declared types */
975 !is_full_physname_constructor
&& /* " " */
976 !is_type_conversion_operator (type
, i
, j
))
978 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
980 fputs_filtered (" ", stream
);
982 if (TYPE_FN_FIELD_STUB (f
, j
))
983 /* Build something we can demangle. */
984 mangled_name
= gdb_mangle_name (type
, i
, j
);
986 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
989 cplus_demangle (mangled_name
,
990 DMGL_ANSI
| DMGL_PARAMS
);
991 if (demangled_name
== NULL
)
993 /* in some cases (for instance with the HP demangling),
994 if a function has more than 10 arguments,
995 the demangling will fail.
996 Let's try to reconstruct the function signature from
997 the symbol information */
998 if (!TYPE_FN_FIELD_STUB (f
, j
))
1000 int staticp
= TYPE_FN_FIELD_STATIC_P (f
, j
);
1001 struct type
*mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1002 cp_type_print_method_args (mtype
,
1009 fprintf_filtered (stream
, _("<badly mangled name '%s'>"),
1015 char *demangled_no_class
1016 = remove_qualifiers (demangled_name
);
1018 /* get rid of the `static' appended by the demangler */
1019 p
= strstr (demangled_no_class
, " static");
1022 int length
= p
- demangled_no_class
;
1023 demangled_no_static
= (char *) xmalloc (length
+ 1);
1024 strncpy (demangled_no_static
, demangled_no_class
, length
);
1025 *(demangled_no_static
+ length
) = '\0';
1026 fputs_filtered (demangled_no_static
, stream
);
1027 xfree (demangled_no_static
);
1030 fputs_filtered (demangled_no_class
, stream
);
1031 xfree (demangled_name
);
1034 if (TYPE_FN_FIELD_STUB (f
, j
))
1035 xfree (mangled_name
);
1037 fprintf_filtered (stream
, ";\n");
1041 fprintfi_filtered (level
, stream
, "}");
1043 if (TYPE_LOCALTYPE_PTR (type
) && show
>= 0)
1044 fprintfi_filtered (level
, stream
, _(" (Local at %s:%d)\n"),
1045 TYPE_LOCALTYPE_FILE (type
),
1046 TYPE_LOCALTYPE_LINE (type
));
1048 if (TYPE_CODE (type
) == TYPE_CODE_TEMPLATE
)
1052 case TYPE_CODE_ENUM
:
1053 c_type_print_modifier (type
, stream
, 0, 1);
1054 fprintf_filtered (stream
, "enum ");
1055 /* Print the tag name if it exists.
1056 The aCC compiler emits a spurious
1057 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1058 tag for unnamed struct/union/enum's, which we don't
1060 if (TYPE_TAG_NAME (type
) != NULL
&&
1061 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
1063 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1065 fputs_filtered (" ", stream
);
1071 /* If we just printed a tag name, no need to print anything else. */
1072 if (TYPE_TAG_NAME (type
) == NULL
)
1073 fprintf_filtered (stream
, "{...}");
1075 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1077 fprintf_filtered (stream
, "{");
1078 len
= TYPE_NFIELDS (type
);
1080 for (i
= 0; i
< len
; i
++)
1084 fprintf_filtered (stream
, ", ");
1086 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1087 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
1089 fprintf_filtered (stream
, " = %d", TYPE_FIELD_BITPOS (type
, i
));
1090 lastval
= TYPE_FIELD_BITPOS (type
, i
);
1094 fprintf_filtered (stream
, "}");
1098 case TYPE_CODE_VOID
:
1099 fprintf_filtered (stream
, "void");
1102 case TYPE_CODE_UNDEF
:
1103 fprintf_filtered (stream
, _("struct <unknown>"));
1106 case TYPE_CODE_ERROR
:
1107 fprintf_filtered (stream
, _("<unknown type>"));
1110 case TYPE_CODE_RANGE
:
1111 /* This should not occur */
1112 fprintf_filtered (stream
, _("<range type>"));
1115 case TYPE_CODE_TEMPLATE
:
1116 /* Called on "ptype t" where "t" is a template.
1117 Prints the template header (with args), e.g.:
1118 template <class T1, class T2> class "
1119 and then merges with the struct/union/class code to
1120 print the rest of the definition. */
1121 c_type_print_modifier (type
, stream
, 0, 1);
1122 fprintf_filtered (stream
, "template <");
1123 for (i
= 0; i
< TYPE_NTEMPLATE_ARGS (type
); i
++)
1125 struct template_arg templ_arg
;
1126 templ_arg
= TYPE_TEMPLATE_ARG (type
, i
);
1127 fprintf_filtered (stream
, "class %s", templ_arg
.name
);
1128 if (i
< TYPE_NTEMPLATE_ARGS (type
) - 1)
1129 fprintf_filtered (stream
, ", ");
1131 fprintf_filtered (stream
, "> class ");
1132 /* Yuck, factor this out to a subroutine so we can call
1133 it and return to the point marked with the "goback:" label... - RT */
1136 if (TYPE_NINSTANTIATIONS (type
) > 0)
1138 fprintf_filtered (stream
, _("\ntemplate instantiations:\n"));
1139 for (i
= 0; i
< TYPE_NINSTANTIATIONS (type
); i
++)
1141 fprintf_filtered (stream
, " ");
1142 c_type_print_base (TYPE_INSTANTIATION (type
, i
), stream
, 0, level
);
1143 if (i
< TYPE_NINSTANTIATIONS (type
) - 1)
1144 fprintf_filtered (stream
, "\n");
1149 case TYPE_CODE_NAMESPACE
:
1150 fputs_filtered ("namespace ", stream
);
1151 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1155 /* Handle types not explicitly handled by the other cases,
1156 such as fundamental types. For these, just print whatever
1157 the type name is, as recorded in the type itself. If there
1158 is no type name, then complain. */
1159 if (TYPE_NAME (type
) != NULL
)
1161 c_type_print_modifier (type
, stream
, 0, 1);
1162 fputs_filtered (TYPE_NAME (type
), stream
);
1166 /* At least for dump_symtab, it is important that this not be
1168 fprintf_filtered (stream
, _("<invalid type code %d>"),