1 /* Support for printing C and C++ types for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
25 #include "bfd.h" /* Binary File Description */
28 #include "expression.h"
35 #include "typeprint.h"
38 #include "gdb_string.h"
41 /* Flag indicating target was compiled by HP compiler */
42 extern int hp_som_som_object_present
;
44 static void cp_type_print_method_args (struct type
** args
, char *prefix
,
45 char *varstring
, int staticp
,
46 struct ui_file
*stream
);
48 static void c_type_print_args (struct type
*, struct ui_file
*);
50 static void cp_type_print_derivation_info (struct ui_file
*, struct type
*);
52 void c_type_print_varspec_prefix (struct type
*, struct ui_file
*, int,
55 /* Print "const", "volatile", or address space modifiers. */
56 static void c_type_print_modifier (struct type
*, struct ui_file
*,
62 /* LEVEL is the depth to indent lines by. */
65 c_print_type (struct type
*type
, char *varstring
, struct ui_file
*stream
,
68 register enum type_code code
;
74 c_type_print_base (type
, stream
, show
, level
);
75 code
= TYPE_CODE (type
);
76 if ((varstring
!= NULL
&& *varstring
!= '\0')
78 /* Need a space if going to print stars or brackets;
79 but not if we will print just a type name. */
80 ((show
> 0 || TYPE_NAME (type
) == 0)
82 (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
83 || code
== TYPE_CODE_METHOD
84 || code
== TYPE_CODE_ARRAY
85 || code
== TYPE_CODE_MEMBER
86 || code
== TYPE_CODE_REF
)))
87 fputs_filtered (" ", stream
);
88 c_type_print_varspec_prefix (type
, stream
, show
, 0);
90 if (varstring
!= NULL
)
92 fputs_filtered (varstring
, stream
);
94 /* For demangled function names, we have the arglist as part of the name,
95 so don't print an additional pair of ()'s */
97 demangled_args
= strchr (varstring
, '(') != NULL
;
98 c_type_print_varspec_suffix (type
, stream
, show
, 0, demangled_args
);
102 /* If TYPE is a derived type, then print out derivation information.
103 Print only the actual base classes of this type, not the base classes
104 of the base classes. I.E. for the derivation hierarchy:
107 class B : public A {int b; };
108 class C : public B {int c; };
110 Print the type of class C as:
116 Not as the following (like gdb used to), which is not legal C++ syntax for
117 derived types and may be confused with the multiple inheritance form:
119 class C : public B : public A {
123 In general, gdb should try to print the types as closely as possible to
124 the form that they appear in the source code.
125 Note that in case of protected derivation gcc will not say 'protected'
126 but 'private'. The HP's aCC compiler emits specific information for
127 derivation via protected inheritance, so gdb can print it out */
130 cp_type_print_derivation_info (struct ui_file
*stream
, struct type
*type
)
135 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
137 fputs_filtered (i
== 0 ? ": " : ", ", stream
);
138 fprintf_filtered (stream
, "%s%s ",
139 BASETYPE_VIA_PUBLIC (type
, i
) ? "public"
140 : (TYPE_FIELD_PROTECTED (type
, i
) ? "protected" : "private"),
141 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
142 name
= type_name_no_tag (TYPE_BASECLASS (type
, i
));
143 fprintf_filtered (stream
, "%s", name
? name
: "(null)");
147 fputs_filtered (" ", stream
);
150 /* Print the C++ method arguments ARGS to the file STREAM. */
153 cp_type_print_method_args (struct type
**args
, char *prefix
, char *varstring
,
154 int staticp
, struct ui_file
*stream
)
158 fprintf_symbol_filtered (stream
, prefix
, language_cplus
, DMGL_ANSI
);
159 fprintf_symbol_filtered (stream
, varstring
, language_cplus
, DMGL_ANSI
);
160 fputs_filtered ("(", stream
);
161 if (args
&& args
[!staticp
] && TYPE_CODE (args
[!staticp
]) != TYPE_CODE_VOID
)
163 i
= !staticp
; /* skip the class variable */
166 type_print (args
[i
++], "", stream
, 0);
169 fprintf_filtered (stream
, " ...");
172 else if (TYPE_CODE (args
[i
]) != TYPE_CODE_VOID
)
174 fprintf_filtered (stream
, ", ");
180 else if (current_language
->la_language
== language_cplus
)
182 fprintf_filtered (stream
, "void");
185 fprintf_filtered (stream
, ")");
189 /* Print any asterisks or open-parentheses needed before the
190 variable name (to describe its type).
192 On outermost call, pass 0 for PASSED_A_PTR.
193 On outermost call, SHOW > 0 means should ignore
194 any typename for TYPE and show its details.
195 SHOW is always zero on recursive calls. */
198 c_type_print_varspec_prefix (struct type
*type
, struct ui_file
*stream
,
199 int show
, int passed_a_ptr
)
205 if (TYPE_NAME (type
) && show
<= 0)
210 switch (TYPE_CODE (type
))
213 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 1);
214 fprintf_filtered (stream
, "*");
215 c_type_print_modifier (type
, stream
, 1, 0);
218 case TYPE_CODE_MEMBER
:
220 fprintf_filtered (stream
, "(");
221 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 0);
222 fprintf_filtered (stream
, " ");
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_METHOD
:
233 fprintf_filtered (stream
, "(");
234 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 0);
237 fprintf_filtered (stream
, " ");
238 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
239 fprintf_filtered (stream
, "::");
244 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 1);
245 fprintf_filtered (stream
, "&");
246 c_type_print_modifier (type
, stream
, 1, 0);
250 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 0);
252 fprintf_filtered (stream
, "(");
255 case TYPE_CODE_ARRAY
:
256 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, 0, 0);
258 fprintf_filtered (stream
, "(");
261 case TYPE_CODE_UNDEF
:
262 case TYPE_CODE_STRUCT
:
263 case TYPE_CODE_UNION
:
268 case TYPE_CODE_ERROR
:
272 case TYPE_CODE_RANGE
:
273 case TYPE_CODE_STRING
:
274 case TYPE_CODE_BITSTRING
:
275 case TYPE_CODE_COMPLEX
:
276 case TYPE_CODE_TYPEDEF
:
277 case TYPE_CODE_TEMPLATE
:
278 /* These types need no prefix. They are listed here so that
279 gcc -Wall will reveal any types that haven't been handled. */
282 error ("type not handled in c_type_print_varspec_prefix()");
287 /* Print out "const" and "volatile" attributes.
288 TYPE is a pointer to the type being printed out.
289 STREAM is the output destination.
290 NEED_SPACE = 1 indicates an initial white space is needed */
293 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
294 int need_pre_space
, int need_post_space
)
296 int did_print_modifier
= 0;
297 char *address_space_id
;
299 /* We don't print `const' qualifiers for references --- since all
300 operators affect the thing referenced, not the reference itself,
301 every reference is `const'. */
302 if (TYPE_CONST (type
)
303 && TYPE_CODE (type
) != TYPE_CODE_REF
)
306 fprintf_filtered (stream
, " ");
307 fprintf_filtered (stream
, "const");
308 did_print_modifier
= 1;
311 if (TYPE_VOLATILE (type
))
313 if (did_print_modifier
|| need_pre_space
)
314 fprintf_filtered (stream
, " ");
315 fprintf_filtered (stream
, "volatile");
316 did_print_modifier
= 1;
319 address_space_id
= address_space_int_to_name (TYPE_FLAGS (type
));
320 if (address_space_id
)
322 if (did_print_modifier
|| need_pre_space
)
323 fprintf_filtered (stream
, " ");
324 fprintf_filtered (stream
, "@%s", address_space_id
);
325 did_print_modifier
= 1;
328 if (did_print_modifier
&& need_post_space
)
329 fprintf_filtered (stream
, " ");
336 c_type_print_args (struct type
*type
, struct ui_file
*stream
)
341 fprintf_filtered (stream
, "(");
342 args
= TYPE_ARG_TYPES (type
);
347 fprintf_filtered (stream
, "...");
349 else if ((TYPE_CODE (args
[1]) == TYPE_CODE_VOID
) &&
350 (current_language
->la_language
== language_cplus
))
352 fprintf_filtered (stream
, "void");
357 args
[i
] != NULL
&& TYPE_CODE (args
[i
]) != TYPE_CODE_VOID
;
360 c_print_type (args
[i
], "", stream
, -1, 0);
361 if (args
[i
+ 1] == NULL
)
363 fprintf_filtered (stream
, "...");
365 else if (TYPE_CODE (args
[i
+ 1]) != TYPE_CODE_VOID
)
367 fprintf_filtered (stream
, ",");
373 else if (current_language
->la_language
== language_cplus
)
375 fprintf_filtered (stream
, "void");
378 fprintf_filtered (stream
, ")");
382 /* Return true iff the j'th overloading of the i'th method of TYPE
383 is a type conversion operator, like `operator int () { ... }'.
384 When listing a class's methods, we don't print the return type of
387 is_type_conversion_operator (struct type
*type
, int i
, int j
)
389 /* I think the whole idea of recognizing type conversion operators
390 by their name is pretty terrible. But I don't think our present
391 data structure gives us any other way to tell. If you know of
392 some other way, feel free to rewrite this function. */
393 char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
395 if (strncmp (name
, "operator", 8) != 0)
399 if (! strchr (" \t\f\n\r", *name
))
402 while (strchr (" \t\f\n\r", *name
))
405 if (!('a' <= *name
&& *name
<= 'z')
406 && !('A' <= *name
&& *name
<= 'Z')
408 /* If this doesn't look like the start of an identifier, then it
409 isn't a type conversion operator. */
411 else if (strncmp (name
, "new", 3) == 0)
413 else if (strncmp (name
, "delete", 6) == 0)
416 /* If it doesn't look like new or delete, it's a type conversion
420 /* Is that really the end of the name? */
421 if (('a' <= *name
&& *name
<= 'z')
422 || ('A' <= *name
&& *name
<= 'Z')
423 || ('0' <= *name
&& *name
<= '9')
425 /* No, so the identifier following "operator" must be a type name,
426 and this is a type conversion operator. */
429 /* That was indeed the end of the name, so it was `operator new' or
430 `operator delete', neither of which are type conversion operators. */
435 /* Given a C++ qualified identifier QID, strip off the qualifiers,
436 yielding the unqualified name. The return value is a pointer into
439 It's a pity we don't have this information in some more structured
440 form. Even the author of this function feels that writing little
441 parsers like this everywhere is stupid. */
443 remove_qualifiers (char *qid
)
445 int quoted
= 0; /* zero if we're not in quotes;
446 '"' if we're in a double-quoted string;
447 '\'' if we're in a single-quoted string. */
448 int depth
= 0; /* number of unclosed parens we've seen */
449 char *parenstack
= (char *) alloca (strlen (qid
));
451 char *last
= 0; /* The character after the rightmost
452 `::' token we've seen so far. */
454 for (scan
= qid
; *scan
; scan
++)
460 else if (*scan
== '\\' && *(scan
+ 1))
463 else if (scan
[0] == ':' && scan
[1] == ':')
465 /* If we're inside parenthesis (i.e., an argument list) or
466 angle brackets (i.e., a list of template arguments), then
467 we don't record the position of this :: token, since it's
468 not relevant to the top-level structure we're trying
476 else if (*scan
== '"' || *scan
== '\'')
478 else if (*scan
== '(')
479 parenstack
[depth
++] = ')';
480 else if (*scan
== '[')
481 parenstack
[depth
++] = ']';
482 /* We're going to treat <> as a pair of matching characters,
483 since we're more likely to see those in template id's than
484 real less-than characters. What a crock. */
485 else if (*scan
== '<')
486 parenstack
[depth
++] = '>';
487 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
489 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
493 /* We're going to do a little error recovery here. If we
494 don't find a match for *scan on the paren stack, but
495 there is something lower on the stack that does match, we
496 pop the stack to that point. */
499 for (i
= depth
- 1; i
>= 0; i
--)
500 if (parenstack
[i
] == *scan
)
512 /* We didn't find any :: tokens at the top level, so declare the
513 whole thing an unqualified identifier. */
518 /* Print any array sizes, function arguments or close parentheses
519 needed after the variable name (to describe its type).
520 Args work like c_type_print_varspec_prefix. */
523 c_type_print_varspec_suffix (struct type
*type
, struct ui_file
*stream
,
524 int show
, int passed_a_ptr
, int demangled_args
)
529 if (TYPE_NAME (type
) && show
<= 0)
534 switch (TYPE_CODE (type
))
536 case TYPE_CODE_ARRAY
:
538 fprintf_filtered (stream
, ")");
540 fprintf_filtered (stream
, "[");
541 if (TYPE_LENGTH (type
) >= 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0
542 && TYPE_ARRAY_UPPER_BOUND_TYPE (type
) != BOUND_CANNOT_BE_DETERMINED
)
543 fprintf_filtered (stream
, "%d",
545 / TYPE_LENGTH (TYPE_TARGET_TYPE (type
))));
546 fprintf_filtered (stream
, "]");
548 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 0, 0);
551 case TYPE_CODE_MEMBER
:
553 fprintf_filtered (stream
, ")");
554 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 0, 0);
557 case TYPE_CODE_METHOD
:
559 fprintf_filtered (stream
, ")");
560 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 0, 0);
563 c_type_print_args (type
, stream
);
569 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0, 1, 0);
574 fprintf_filtered (stream
, ")");
577 int i
, len
= TYPE_NFIELDS (type
);
578 fprintf_filtered (stream
, "(");
580 && (TYPE_PROTOTYPED (type
)
581 || current_language
->la_language
== language_cplus
))
583 fprintf_filtered (stream
, "void");
586 for (i
= 0; i
< len
; i
++)
590 fputs_filtered (", ", stream
);
593 c_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
595 fprintf_filtered (stream
, ")");
597 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, 0,
601 case TYPE_CODE_UNDEF
:
602 case TYPE_CODE_STRUCT
:
603 case TYPE_CODE_UNION
:
608 case TYPE_CODE_ERROR
:
612 case TYPE_CODE_RANGE
:
613 case TYPE_CODE_STRING
:
614 case TYPE_CODE_BITSTRING
:
615 case TYPE_CODE_COMPLEX
:
616 case TYPE_CODE_TYPEDEF
:
617 case TYPE_CODE_TEMPLATE
:
618 /* These types do not need a suffix. They are listed so that
619 gcc -Wall will report types that may not have been considered. */
622 error ("type not handled in c_type_print_varspec_suffix()");
627 /* Print the name of the type (or the ultimate pointer target,
628 function value or array element), or the description of a
631 SHOW positive means print details about the type (e.g. enum values),
632 and print structure elements passing SHOW - 1 for show.
633 SHOW negative means just print the type name or struct tag if there is one.
634 If there is no name, print something sensible but concise like
636 SHOW zero means just print the type name or struct tag if there is one.
637 If there is no name, print something sensible but not as concise like
638 "struct {int x; int y;}".
640 LEVEL is the number of spaces to indent by.
641 We increase it for some recursive calls. */
644 c_type_print_base (struct type
*type
, struct ui_file
*stream
, int show
,
651 char *demangled_name
;
652 char *demangled_no_static
;
655 s_none
, s_public
, s_private
, s_protected
658 int need_access_label
= 0;
666 fputs_filtered ("<type unknown>", stream
);
670 /* When SHOW is zero or less, and there is a valid type name, then always
671 just print the type name directly from the type. */
672 /* If we have "typedef struct foo {. . .} bar;" do we want to print it
673 as "struct foo" or as "bar"? Pick the latter, because C++ folk tend
674 to expect things like "class5 *foo" rather than "struct class5 *foo". */
677 && TYPE_NAME (type
) != NULL
)
679 c_type_print_modifier (type
, stream
, 0, 1);
680 fputs_filtered (TYPE_NAME (type
), stream
);
684 CHECK_TYPEDEF (type
);
686 switch (TYPE_CODE (type
))
688 case TYPE_CODE_TYPEDEF
:
689 case TYPE_CODE_ARRAY
:
691 case TYPE_CODE_MEMBER
:
694 case TYPE_CODE_METHOD
:
695 c_type_print_base (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
698 case TYPE_CODE_STRUCT
:
699 c_type_print_modifier (type
, stream
, 0, 1);
700 /* Note TYPE_CODE_STRUCT and TYPE_CODE_CLASS have the same value,
701 * so we use another means for distinguishing them.
703 if (HAVE_CPLUS_STRUCT (type
))
705 switch (TYPE_DECLARED_TYPE (type
))
707 case DECLARED_TYPE_CLASS
:
708 fprintf_filtered (stream
, "class ");
710 case DECLARED_TYPE_UNION
:
711 fprintf_filtered (stream
, "union ");
713 case DECLARED_TYPE_STRUCT
:
714 fprintf_filtered (stream
, "struct ");
717 /* If there is a CPLUS_STRUCT, assume class if not
718 * otherwise specified in the declared_type field.
720 fprintf_filtered (stream
, "class ");
726 /* If not CPLUS_STRUCT, then assume it's a C struct */
727 fprintf_filtered (stream
, "struct ");
731 case TYPE_CODE_UNION
:
732 c_type_print_modifier (type
, stream
, 0, 1);
733 fprintf_filtered (stream
, "union ");
737 /* Print the tag if it exists.
738 * The HP aCC compiler emits
739 * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
740 * tag for unnamed struct/union/enum's, which we don't
743 if (TYPE_TAG_NAME (type
) != NULL
&&
744 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
746 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
748 fputs_filtered (" ", stream
);
753 /* If we just printed a tag name, no need to print anything else. */
754 if (TYPE_TAG_NAME (type
) == NULL
)
755 fprintf_filtered (stream
, "{...}");
757 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
759 cp_type_print_derivation_info (stream
, type
);
761 fprintf_filtered (stream
, "{\n");
762 if ((TYPE_NFIELDS (type
) == 0) && (TYPE_NFN_FIELDS (type
) == 0))
764 if (TYPE_STUB (type
))
765 fprintfi_filtered (level
+ 4, stream
, "<incomplete type>\n");
767 fprintfi_filtered (level
+ 4, stream
, "<no data fields>\n");
770 /* Start off with no specific section type, so we can print
771 one for the first field we find, and use that section type
772 thereafter until we find another type. */
774 section_type
= s_none
;
776 /* For a class, if all members are private, there's no need
777 for a "private:" label; similarly, for a struct or union
778 masquerading as a class, if all members are public, there's
779 no need for a "public:" label. */
781 if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_CLASS
) ||
782 (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_TEMPLATE
))
785 len
= TYPE_NFIELDS (type
);
786 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
787 if (!TYPE_FIELD_PRIVATE (type
, i
))
789 need_access_label
= 1;
793 if (!need_access_label
)
795 len2
= TYPE_NFN_FIELDS (type
);
796 for (j
= 0; j
< len2
; j
++)
798 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
799 for (i
= 0; i
< len
; i
++)
800 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
))
802 need_access_label
= 1;
805 if (need_access_label
)
810 else if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_STRUCT
) ||
811 (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_UNION
))
814 len
= TYPE_NFIELDS (type
);
815 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
816 if (TYPE_FIELD_PRIVATE (type
, i
) || TYPE_FIELD_PROTECTED (type
, i
))
818 need_access_label
= 1;
822 if (!need_access_label
)
824 len2
= TYPE_NFN_FIELDS (type
);
825 for (j
= 0; j
< len2
; j
++)
828 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
829 for (i
= 0; i
< len
; i
++)
830 if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
) ||
831 TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
, j
), i
))
833 need_access_label
= 1;
836 if (need_access_label
)
842 /* If there is a base class for this type,
843 do not print the field that it occupies. */
845 len
= TYPE_NFIELDS (type
);
846 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
849 /* Don't print out virtual function table. */
850 /* HP ANSI C++ case */
851 if (TYPE_HAS_VTABLE (type
) && (STREQN (TYPE_FIELD_NAME (type
, i
), "__vfp", 5)))
853 /* Other compilers */
854 if (STREQN (TYPE_FIELD_NAME (type
, i
), "_vptr", 5)
855 && is_cplus_marker ((TYPE_FIELD_NAME (type
, i
))[5]))
858 /* If this is a C++ class we can print the various C++ section
861 if (HAVE_CPLUS_STRUCT (type
) && need_access_label
)
863 if (TYPE_FIELD_PROTECTED (type
, i
))
865 if (section_type
!= s_protected
)
867 section_type
= s_protected
;
868 fprintfi_filtered (level
+ 2, stream
,
872 else if (TYPE_FIELD_PRIVATE (type
, i
))
874 if (section_type
!= s_private
)
876 section_type
= s_private
;
877 fprintfi_filtered (level
+ 2, stream
, "private:\n");
882 if (section_type
!= s_public
)
884 section_type
= s_public
;
885 fprintfi_filtered (level
+ 2, stream
, "public:\n");
890 print_spaces_filtered (level
+ 4, stream
);
891 if (TYPE_FIELD_STATIC (type
, i
))
893 fprintf_filtered (stream
, "static ");
895 c_print_type (TYPE_FIELD_TYPE (type
, i
),
896 TYPE_FIELD_NAME (type
, i
),
897 stream
, show
- 1, level
+ 4);
898 if (!TYPE_FIELD_STATIC (type
, i
)
899 && TYPE_FIELD_PACKED (type
, i
))
901 /* It is a bitfield. This code does not attempt
902 to look at the bitpos and reconstruct filler,
903 unnamed fields. This would lead to misleading
904 results if the compiler does not put out fields
905 for such things (I don't know what it does). */
906 fprintf_filtered (stream
, " : %d",
907 TYPE_FIELD_BITSIZE (type
, i
));
909 fprintf_filtered (stream
, ";\n");
912 /* If there are both fields and methods, put a blank line
913 between them. Make sure to count only method that we will
914 display; artificial methods will be hidden. */
915 len
= TYPE_NFN_FIELDS (type
);
917 for (i
= 0; i
< len
; i
++)
919 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
920 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
922 for (j
= 0; j
< len2
; j
++)
923 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
926 if (real_len
> 0 && section_type
!= s_none
)
927 fprintf_filtered (stream
, "\n");
929 /* C++: print out the methods */
930 for (i
= 0; i
< len
; i
++)
932 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
933 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
934 char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
935 char *name
= type_name_no_tag (type
);
936 int is_constructor
= name
&& STREQ (method_name
, name
);
937 for (j
= 0; j
< len2
; j
++)
939 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
940 int is_full_physname_constructor
=
941 is_constructor_name (physname
)
942 || is_destructor_name (physname
)
943 || method_name
[0] == '~';
945 /* Do not print out artificial methods. */
946 if (TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
950 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
952 if (section_type
!= s_protected
)
954 section_type
= s_protected
;
955 fprintfi_filtered (level
+ 2, stream
,
959 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
961 if (section_type
!= s_private
)
963 section_type
= s_private
;
964 fprintfi_filtered (level
+ 2, stream
, "private:\n");
969 if (section_type
!= s_public
)
971 section_type
= s_public
;
972 fprintfi_filtered (level
+ 2, stream
, "public:\n");
976 print_spaces_filtered (level
+ 4, stream
);
977 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
978 fprintf_filtered (stream
, "virtual ");
979 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
980 fprintf_filtered (stream
, "static ");
981 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
983 /* Keep GDB from crashing here. */
984 fprintf_filtered (stream
, "<undefined type> %s;\n",
985 TYPE_FN_FIELD_PHYSNAME (f
, j
));
988 else if (!is_constructor
&& /* constructors don't have declared types */
989 !is_full_physname_constructor
&& /* " " */
990 !is_type_conversion_operator (type
, i
, j
))
992 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
994 fputs_filtered (" ", stream
);
996 if (TYPE_FN_FIELD_STUB (f
, j
))
997 /* Build something we can demangle. */
998 mangled_name
= gdb_mangle_name (type
, i
, j
);
1000 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1003 cplus_demangle (mangled_name
,
1004 DMGL_ANSI
| DMGL_PARAMS
);
1005 if (demangled_name
== NULL
)
1007 /* in some cases (for instance with the HP demangling),
1008 if a function has more than 10 arguments,
1009 the demangling will fail.
1010 Let's try to reconstruct the function signature from
1011 the symbol information */
1012 if (!TYPE_FN_FIELD_STUB (f
, j
))
1013 cp_type_print_method_args (TYPE_FN_FIELD_ARGS (f
, j
), "",
1015 TYPE_FN_FIELD_STATIC_P (f
, j
),
1018 fprintf_filtered (stream
, "<badly mangled name '%s'>",
1024 char *demangled_no_class
1025 = remove_qualifiers (demangled_name
);
1027 /* get rid of the `static' appended by the demangler */
1028 p
= strstr (demangled_no_class
, " static");
1031 int length
= p
- demangled_no_class
;
1032 demangled_no_static
= (char *) xmalloc (length
+ 1);
1033 strncpy (demangled_no_static
, demangled_no_class
, length
);
1034 *(demangled_no_static
+ length
) = '\0';
1035 fputs_filtered (demangled_no_static
, stream
);
1036 xfree (demangled_no_static
);
1039 fputs_filtered (demangled_no_class
, stream
);
1040 xfree (demangled_name
);
1043 if (TYPE_FN_FIELD_STUB (f
, j
))
1044 xfree (mangled_name
);
1046 fprintf_filtered (stream
, ";\n");
1050 fprintfi_filtered (level
, stream
, "}");
1052 if (TYPE_LOCALTYPE_PTR (type
) && show
>= 0)
1053 fprintfi_filtered (level
, stream
, " (Local at %s:%d)\n",
1054 TYPE_LOCALTYPE_FILE (type
),
1055 TYPE_LOCALTYPE_LINE (type
));
1057 if (TYPE_CODE (type
) == TYPE_CODE_TEMPLATE
)
1061 case TYPE_CODE_ENUM
:
1062 c_type_print_modifier (type
, stream
, 0, 1);
1063 /* HP C supports sized enums */
1064 if (hp_som_som_object_present
)
1065 switch (TYPE_LENGTH (type
))
1068 fputs_filtered ("char ", stream
);
1071 fputs_filtered ("short ", stream
);
1076 fprintf_filtered (stream
, "enum ");
1077 /* Print the tag name if it exists.
1078 The aCC compiler emits a spurious
1079 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1080 tag for unnamed struct/union/enum's, which we don't
1082 if (TYPE_TAG_NAME (type
) != NULL
&&
1083 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
1085 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1087 fputs_filtered (" ", stream
);
1093 /* If we just printed a tag name, no need to print anything else. */
1094 if (TYPE_TAG_NAME (type
) == NULL
)
1095 fprintf_filtered (stream
, "{...}");
1097 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1099 fprintf_filtered (stream
, "{");
1100 len
= TYPE_NFIELDS (type
);
1102 for (i
= 0; i
< len
; i
++)
1106 fprintf_filtered (stream
, ", ");
1108 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1109 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
1111 fprintf_filtered (stream
, " = %d", TYPE_FIELD_BITPOS (type
, i
));
1112 lastval
= TYPE_FIELD_BITPOS (type
, i
);
1116 fprintf_filtered (stream
, "}");
1120 case TYPE_CODE_VOID
:
1121 fprintf_filtered (stream
, "void");
1124 case TYPE_CODE_UNDEF
:
1125 fprintf_filtered (stream
, "struct <unknown>");
1128 case TYPE_CODE_ERROR
:
1129 fprintf_filtered (stream
, "<unknown type>");
1132 case TYPE_CODE_RANGE
:
1133 /* This should not occur */
1134 fprintf_filtered (stream
, "<range type>");
1137 case TYPE_CODE_TEMPLATE
:
1138 /* Called on "ptype t" where "t" is a template.
1139 Prints the template header (with args), e.g.:
1140 template <class T1, class T2> class "
1141 and then merges with the struct/union/class code to
1142 print the rest of the definition. */
1143 c_type_print_modifier (type
, stream
, 0, 1);
1144 fprintf_filtered (stream
, "template <");
1145 for (i
= 0; i
< TYPE_NTEMPLATE_ARGS (type
); i
++)
1147 struct template_arg templ_arg
;
1148 templ_arg
= TYPE_TEMPLATE_ARG (type
, i
);
1149 fprintf_filtered (stream
, "class %s", templ_arg
.name
);
1150 if (i
< TYPE_NTEMPLATE_ARGS (type
) - 1)
1151 fprintf_filtered (stream
, ", ");
1153 fprintf_filtered (stream
, "> class ");
1154 /* Yuck, factor this out to a subroutine so we can call
1155 it and return to the point marked with the "goback:" label... - RT */
1158 if (TYPE_NINSTANTIATIONS (type
) > 0)
1160 fprintf_filtered (stream
, "\ntemplate instantiations:\n");
1161 for (i
= 0; i
< TYPE_NINSTANTIATIONS (type
); i
++)
1163 fprintf_filtered (stream
, " ");
1164 c_type_print_base (TYPE_INSTANTIATION (type
, i
), stream
, 0, level
);
1165 if (i
< TYPE_NINSTANTIATIONS (type
) - 1)
1166 fprintf_filtered (stream
, "\n");
1172 /* Handle types not explicitly handled by the other cases,
1173 such as fundamental types. For these, just print whatever
1174 the type name is, as recorded in the type itself. If there
1175 is no type name, then complain. */
1176 if (TYPE_NAME (type
) != NULL
)
1178 c_type_print_modifier (type
, stream
, 0, 1);
1179 fputs_filtered (TYPE_NAME (type
), stream
);
1183 /* At least for dump_symtab, it is important that this not be
1185 fprintf_filtered (stream
, "<invalid type code %d>",