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,
3 1999, 2000, 2001, 2002, 2003
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. */
24 #include "gdb_obstack.h"
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
*mtype
, 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 static 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
;
75 c_type_print_base (type
, stream
, show
, level
);
76 code
= TYPE_CODE (type
);
77 if ((varstring
!= NULL
&& *varstring
!= '\0')
79 /* Need a space if going to print stars or brackets;
80 but not if we will print just a type name. */
81 ((show
> 0 || TYPE_NAME (type
) == 0)
83 (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
84 || code
== TYPE_CODE_METHOD
85 || code
== TYPE_CODE_ARRAY
86 || code
== TYPE_CODE_MEMBER
87 || code
== TYPE_CODE_REF
)))
88 fputs_filtered (" ", stream
);
89 need_post_space
= (varstring
!= NULL
&& strcmp (varstring
, "") != 0);
90 c_type_print_varspec_prefix (type
, stream
, show
, 0, need_post_space
);
92 if (varstring
!= NULL
)
94 fputs_filtered (varstring
, stream
);
96 /* For demangled function names, we have the arglist as part of the name,
97 so don't print an additional pair of ()'s */
99 demangled_args
= strchr (varstring
, '(') != NULL
;
100 c_type_print_varspec_suffix (type
, stream
, show
, 0, demangled_args
);
104 /* If TYPE is a derived type, then print out derivation information.
105 Print only the actual base classes of this type, not the base classes
106 of the base classes. I.E. for the derivation hierarchy:
109 class B : public A {int b; };
110 class C : public B {int c; };
112 Print the type of class C as:
118 Not as the following (like gdb used to), which is not legal C++ syntax for
119 derived types and may be confused with the multiple inheritance form:
121 class C : public B : public A {
125 In general, gdb should try to print the types as closely as possible to
126 the form that they appear in the source code.
127 Note that in case of protected derivation gcc will not say 'protected'
128 but 'private'. The HP's aCC compiler emits specific information for
129 derivation via protected inheritance, so gdb can print it out */
132 cp_type_print_derivation_info (struct ui_file
*stream
, struct type
*type
)
137 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
139 fputs_filtered (i
== 0 ? ": " : ", ", stream
);
140 fprintf_filtered (stream
, "%s%s ",
141 BASETYPE_VIA_PUBLIC (type
, i
) ? "public"
142 : (TYPE_FIELD_PROTECTED (type
, i
) ? "protected" : "private"),
143 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
144 name
= type_name_no_tag (TYPE_BASECLASS (type
, i
));
145 fprintf_filtered (stream
, "%s", name
? name
: "(null)");
149 fputs_filtered (" ", stream
);
153 /* Print the C++ method arguments ARGS to the file STREAM. */
156 cp_type_print_method_args (struct type
*mtype
, char *prefix
, char *varstring
,
157 int staticp
, struct ui_file
*stream
)
159 struct field
*args
= TYPE_FIELDS (mtype
);
160 int nargs
= TYPE_NFIELDS (mtype
);
161 int varargs
= TYPE_VARARGS (mtype
);
164 fprintf_symbol_filtered (stream
, prefix
, language_cplus
, DMGL_ANSI
);
165 fprintf_symbol_filtered (stream
, varstring
, language_cplus
, DMGL_ANSI
);
166 fputs_filtered ("(", stream
);
168 /* Skip the class variable. */
174 type_print (args
[i
++].type
, "", stream
, 0);
176 if (i
== nargs
&& varargs
)
177 fprintf_filtered (stream
, ", ...");
179 fprintf_filtered (stream
, ", ");
183 fprintf_filtered (stream
, "...");
184 else if (current_language
->la_language
== language_cplus
)
185 fprintf_filtered (stream
, "void");
187 fprintf_filtered (stream
, ")");
191 /* Print any asterisks or open-parentheses needed before the
192 variable name (to describe its type).
194 On outermost call, pass 0 for PASSED_A_PTR.
195 On outermost call, SHOW > 0 means should ignore
196 any typename for TYPE and show its details.
197 SHOW is always zero on recursive calls.
199 NEED_POST_SPACE is non-zero when a space will be be needed
200 between a trailing qualifier and a field, variable, or function
204 c_type_print_varspec_prefix (struct type
*type
, struct ui_file
*stream
,
205 int show
, int passed_a_ptr
, int need_post_space
)
211 if (TYPE_NAME (type
) && show
<= 0)
216 switch (TYPE_CODE (type
))
219 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 1, 1);
220 fprintf_filtered (stream
, "*");
221 c_type_print_modifier (type
, stream
, 1, need_post_space
);
224 case TYPE_CODE_MEMBER
:
226 fprintf_filtered (stream
, "(");
227 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
228 fprintf_filtered (stream
, " ");
229 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
231 fputs_filtered (name
, stream
);
233 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
234 fprintf_filtered (stream
, "::");
237 case TYPE_CODE_METHOD
:
239 fprintf_filtered (stream
, "(");
240 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
243 fprintf_filtered (stream
, " ");
244 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
245 fprintf_filtered (stream
, "::");
250 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 1, 0);
251 fprintf_filtered (stream
, "&");
252 c_type_print_modifier (type
, stream
, 1, need_post_space
);
256 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
258 fprintf_filtered (stream
, "(");
261 case TYPE_CODE_ARRAY
:
262 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
264 fprintf_filtered (stream
, "(");
267 case TYPE_CODE_TYPEDEF
:
268 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
271 case TYPE_CODE_UNDEF
:
272 case TYPE_CODE_STRUCT
:
273 case TYPE_CODE_UNION
:
278 case TYPE_CODE_ERROR
:
282 case TYPE_CODE_RANGE
:
283 case TYPE_CODE_STRING
:
284 case TYPE_CODE_BITSTRING
:
285 case TYPE_CODE_COMPLEX
:
286 case TYPE_CODE_TEMPLATE
:
287 /* These types need no prefix. They are listed here so that
288 gcc -Wall will reveal any types that haven't been handled. */
291 error ("type not handled in c_type_print_varspec_prefix()");
296 /* Print out "const" and "volatile" attributes.
297 TYPE is a pointer to the type being printed out.
298 STREAM is the output destination.
299 NEED_SPACE = 1 indicates an initial white space is needed */
302 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
303 int need_pre_space
, int need_post_space
)
305 int did_print_modifier
= 0;
306 const char *address_space_id
;
308 /* We don't print `const' qualifiers for references --- since all
309 operators affect the thing referenced, not the reference itself,
310 every reference is `const'. */
311 if (TYPE_CONST (type
)
312 && TYPE_CODE (type
) != TYPE_CODE_REF
)
315 fprintf_filtered (stream
, " ");
316 fprintf_filtered (stream
, "const");
317 did_print_modifier
= 1;
320 if (TYPE_VOLATILE (type
))
322 if (did_print_modifier
|| need_pre_space
)
323 fprintf_filtered (stream
, " ");
324 fprintf_filtered (stream
, "volatile");
325 did_print_modifier
= 1;
328 address_space_id
= address_space_int_to_name (TYPE_INSTANCE_FLAGS (type
));
329 if (address_space_id
)
331 if (did_print_modifier
|| need_pre_space
)
332 fprintf_filtered (stream
, " ");
333 fprintf_filtered (stream
, "@%s", address_space_id
);
334 did_print_modifier
= 1;
337 if (did_print_modifier
&& need_post_space
)
338 fprintf_filtered (stream
, " ");
345 c_type_print_args (struct type
*type
, struct ui_file
*stream
)
350 fprintf_filtered (stream
, "(");
351 args
= TYPE_FIELDS (type
);
356 /* FIXME drow/2002-05-31: Always skips the first argument,
357 should we be checking for static members? */
359 for (i
= 1; i
< TYPE_NFIELDS (type
); i
++)
361 c_print_type (args
[i
].type
, "", stream
, -1, 0);
362 if (i
!= TYPE_NFIELDS (type
))
364 fprintf_filtered (stream
, ",");
368 if (TYPE_VARARGS (type
))
369 fprintf_filtered (stream
, "...");
371 && (current_language
->la_language
== language_cplus
))
372 fprintf_filtered (stream
, "void");
374 else if (current_language
->la_language
== language_cplus
)
376 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
) >= 0 && 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_MEMBER
:
555 fprintf_filtered (stream
, ")");
556 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
560 case TYPE_CODE_METHOD
:
562 fprintf_filtered (stream
, ")");
563 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
567 c_type_print_args (type
, stream
);
573 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
579 fprintf_filtered (stream
, ")");
582 int i
, len
= TYPE_NFIELDS (type
);
583 fprintf_filtered (stream
, "(");
585 && (TYPE_PROTOTYPED (type
)
586 || current_language
->la_language
== language_cplus
))
588 fprintf_filtered (stream
, "void");
591 for (i
= 0; i
< len
; i
++)
595 fputs_filtered (", ", stream
);
598 c_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
600 fprintf_filtered (stream
, ")");
602 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
606 case TYPE_CODE_TYPEDEF
:
607 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
611 case TYPE_CODE_UNDEF
:
612 case TYPE_CODE_STRUCT
:
613 case TYPE_CODE_UNION
:
618 case TYPE_CODE_ERROR
:
622 case TYPE_CODE_RANGE
:
623 case TYPE_CODE_STRING
:
624 case TYPE_CODE_BITSTRING
:
625 case TYPE_CODE_COMPLEX
:
626 case TYPE_CODE_TEMPLATE
:
627 /* These types do not need a suffix. They are listed so that
628 gcc -Wall will report types that may not have been considered. */
631 error ("type not handled in c_type_print_varspec_suffix()");
636 /* Print the name of the type (or the ultimate pointer target,
637 function value or array element), or the description of a
640 SHOW positive means print details about the type (e.g. enum values),
641 and print structure elements passing SHOW - 1 for show.
642 SHOW negative means just print the type name or struct tag if there is one.
643 If there is no name, print something sensible but concise like
645 SHOW zero means just print the type name or struct tag if there is one.
646 If there is no name, print something sensible but not as concise like
647 "struct {int x; int y;}".
649 LEVEL is the number of spaces to indent by.
650 We increase it for some recursive calls. */
653 c_type_print_base (struct type
*type
, struct ui_file
*stream
, int show
,
660 char *demangled_name
;
661 char *demangled_no_static
;
664 s_none
, s_public
, s_private
, s_protected
667 int need_access_label
= 0;
675 fputs_filtered ("<type unknown>", stream
);
679 /* When SHOW is zero or less, and there is a valid type name, then always
680 just print the type name directly from the type. */
681 /* If we have "typedef struct foo {. . .} bar;" do we want to print it
682 as "struct foo" or as "bar"? Pick the latter, because C++ folk tend
683 to expect things like "class5 *foo" rather than "struct class5 *foo". */
686 && TYPE_NAME (type
) != NULL
)
688 c_type_print_modifier (type
, stream
, 0, 1);
689 fputs_filtered (TYPE_NAME (type
), stream
);
693 CHECK_TYPEDEF (type
);
695 switch (TYPE_CODE (type
))
697 case TYPE_CODE_TYPEDEF
:
698 case TYPE_CODE_ARRAY
:
700 case TYPE_CODE_MEMBER
:
703 case TYPE_CODE_METHOD
:
704 c_type_print_base (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
707 case TYPE_CODE_STRUCT
:
708 c_type_print_modifier (type
, stream
, 0, 1);
709 /* Note TYPE_CODE_STRUCT and TYPE_CODE_CLASS have the same value,
710 * so we use another means for distinguishing them.
712 if (HAVE_CPLUS_STRUCT (type
))
714 switch (TYPE_DECLARED_TYPE (type
))
716 case DECLARED_TYPE_CLASS
:
717 fprintf_filtered (stream
, "class ");
719 case DECLARED_TYPE_UNION
:
720 fprintf_filtered (stream
, "union ");
722 case DECLARED_TYPE_STRUCT
:
723 fprintf_filtered (stream
, "struct ");
726 /* If there is a CPLUS_STRUCT, assume class if not
727 * otherwise specified in the declared_type field.
729 fprintf_filtered (stream
, "class ");
735 /* If not CPLUS_STRUCT, then assume it's a C struct */
736 fprintf_filtered (stream
, "struct ");
740 case TYPE_CODE_UNION
:
741 c_type_print_modifier (type
, stream
, 0, 1);
742 fprintf_filtered (stream
, "union ");
746 /* Print the tag if it exists.
747 * The HP aCC compiler emits
748 * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
749 * tag for unnamed struct/union/enum's, which we don't
752 if (TYPE_TAG_NAME (type
) != NULL
&&
753 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
755 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
757 fputs_filtered (" ", stream
);
762 /* If we just printed a tag name, no need to print anything else. */
763 if (TYPE_TAG_NAME (type
) == NULL
)
764 fprintf_filtered (stream
, "{...}");
766 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
768 cp_type_print_derivation_info (stream
, type
);
770 fprintf_filtered (stream
, "{\n");
771 if ((TYPE_NFIELDS (type
) == 0) && (TYPE_NFN_FIELDS (type
) == 0))
773 if (TYPE_STUB (type
))
774 fprintfi_filtered (level
+ 4, stream
, "<incomplete type>\n");
776 fprintfi_filtered (level
+ 4, stream
, "<no data fields>\n");
779 /* Start off with no specific section type, so we can print
780 one for the first field we find, and use that section type
781 thereafter until we find another type. */
783 section_type
= s_none
;
785 /* For a class, if all members are private, there's no need
786 for a "private:" label; similarly, for a struct or union
787 masquerading as a class, if all members are public, there's
788 no need for a "public:" label. */
790 if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_CLASS
) ||
791 (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_TEMPLATE
))
794 len
= TYPE_NFIELDS (type
);
795 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
796 if (!TYPE_FIELD_PRIVATE (type
, i
))
798 need_access_label
= 1;
802 if (!need_access_label
)
804 len2
= TYPE_NFN_FIELDS (type
);
805 for (j
= 0; j
< len2
; j
++)
807 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
808 for (i
= 0; i
< len
; i
++)
809 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
))
811 need_access_label
= 1;
814 if (need_access_label
)
819 else if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_STRUCT
) ||
820 (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_UNION
))
823 len
= TYPE_NFIELDS (type
);
824 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
825 if (TYPE_FIELD_PRIVATE (type
, i
) || TYPE_FIELD_PROTECTED (type
, i
))
827 need_access_label
= 1;
831 if (!need_access_label
)
833 len2
= TYPE_NFN_FIELDS (type
);
834 for (j
= 0; j
< len2
; j
++)
837 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
838 for (i
= 0; i
< len
; i
++)
839 if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
) ||
840 TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
, j
), i
))
842 need_access_label
= 1;
845 if (need_access_label
)
851 /* If there is a base class for this type,
852 do not print the field that it occupies. */
854 len
= TYPE_NFIELDS (type
);
855 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
858 /* Don't print out virtual function table. */
859 /* HP ANSI C++ case */
860 if (TYPE_HAS_VTABLE (type
) && (STREQN (TYPE_FIELD_NAME (type
, i
), "__vfp", 5)))
862 /* Other compilers */
863 if (STREQN (TYPE_FIELD_NAME (type
, i
), "_vptr", 5)
864 && is_cplus_marker ((TYPE_FIELD_NAME (type
, i
))[5]))
867 /* If this is a C++ class we can print the various C++ section
870 if (HAVE_CPLUS_STRUCT (type
) && need_access_label
)
872 if (TYPE_FIELD_PROTECTED (type
, i
))
874 if (section_type
!= s_protected
)
876 section_type
= s_protected
;
877 fprintfi_filtered (level
+ 2, stream
,
881 else if (TYPE_FIELD_PRIVATE (type
, i
))
883 if (section_type
!= s_private
)
885 section_type
= s_private
;
886 fprintfi_filtered (level
+ 2, stream
, "private:\n");
891 if (section_type
!= s_public
)
893 section_type
= s_public
;
894 fprintfi_filtered (level
+ 2, stream
, "public:\n");
899 print_spaces_filtered (level
+ 4, stream
);
900 if (TYPE_FIELD_STATIC (type
, i
))
902 fprintf_filtered (stream
, "static ");
904 c_print_type (TYPE_FIELD_TYPE (type
, i
),
905 TYPE_FIELD_NAME (type
, i
),
906 stream
, show
- 1, level
+ 4);
907 if (!TYPE_FIELD_STATIC (type
, i
)
908 && TYPE_FIELD_PACKED (type
, i
))
910 /* It is a bitfield. This code does not attempt
911 to look at the bitpos and reconstruct filler,
912 unnamed fields. This would lead to misleading
913 results if the compiler does not put out fields
914 for such things (I don't know what it does). */
915 fprintf_filtered (stream
, " : %d",
916 TYPE_FIELD_BITSIZE (type
, i
));
918 fprintf_filtered (stream
, ";\n");
921 /* If there are both fields and methods, put a blank line
922 between them. Make sure to count only method that we will
923 display; artificial methods will be hidden. */
924 len
= TYPE_NFN_FIELDS (type
);
926 for (i
= 0; i
< len
; i
++)
928 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
929 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
931 for (j
= 0; j
< len2
; j
++)
932 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
935 if (real_len
> 0 && section_type
!= s_none
)
936 fprintf_filtered (stream
, "\n");
938 /* C++: print out the methods */
939 for (i
= 0; i
< len
; i
++)
941 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
942 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
943 char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
944 char *name
= type_name_no_tag (type
);
945 int is_constructor
= name
&& STREQ (method_name
, name
);
946 for (j
= 0; j
< len2
; j
++)
948 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
949 int is_full_physname_constructor
=
950 is_constructor_name (physname
)
951 || is_destructor_name (physname
)
952 || method_name
[0] == '~';
954 /* Do not print out artificial methods. */
955 if (TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
959 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
961 if (section_type
!= s_protected
)
963 section_type
= s_protected
;
964 fprintfi_filtered (level
+ 2, stream
,
968 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
970 if (section_type
!= s_private
)
972 section_type
= s_private
;
973 fprintfi_filtered (level
+ 2, stream
, "private:\n");
978 if (section_type
!= s_public
)
980 section_type
= s_public
;
981 fprintfi_filtered (level
+ 2, stream
, "public:\n");
985 print_spaces_filtered (level
+ 4, stream
);
986 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
987 fprintf_filtered (stream
, "virtual ");
988 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
989 fprintf_filtered (stream
, "static ");
990 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
992 /* Keep GDB from crashing here. */
993 fprintf_filtered (stream
, "<undefined type> %s;\n",
994 TYPE_FN_FIELD_PHYSNAME (f
, j
));
997 else if (!is_constructor
&& /* constructors don't have declared types */
998 !is_full_physname_constructor
&& /* " " */
999 !is_type_conversion_operator (type
, i
, j
))
1001 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
1003 fputs_filtered (" ", stream
);
1005 if (TYPE_FN_FIELD_STUB (f
, j
))
1006 /* Build something we can demangle. */
1007 mangled_name
= gdb_mangle_name (type
, i
, j
);
1009 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1012 cplus_demangle (mangled_name
,
1013 DMGL_ANSI
| DMGL_PARAMS
);
1014 if (demangled_name
== NULL
)
1016 /* in some cases (for instance with the HP demangling),
1017 if a function has more than 10 arguments,
1018 the demangling will fail.
1019 Let's try to reconstruct the function signature from
1020 the symbol information */
1021 if (!TYPE_FN_FIELD_STUB (f
, j
))
1023 int staticp
= TYPE_FN_FIELD_STATIC_P (f
, j
);
1024 struct type
*mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1025 cp_type_print_method_args (mtype
,
1032 fprintf_filtered (stream
, "<badly mangled name '%s'>",
1038 char *demangled_no_class
1039 = remove_qualifiers (demangled_name
);
1041 /* get rid of the `static' appended by the demangler */
1042 p
= strstr (demangled_no_class
, " static");
1045 int length
= p
- demangled_no_class
;
1046 demangled_no_static
= (char *) xmalloc (length
+ 1);
1047 strncpy (demangled_no_static
, demangled_no_class
, length
);
1048 *(demangled_no_static
+ length
) = '\0';
1049 fputs_filtered (demangled_no_static
, stream
);
1050 xfree (demangled_no_static
);
1053 fputs_filtered (demangled_no_class
, stream
);
1054 xfree (demangled_name
);
1057 if (TYPE_FN_FIELD_STUB (f
, j
))
1058 xfree (mangled_name
);
1060 fprintf_filtered (stream
, ";\n");
1064 fprintfi_filtered (level
, stream
, "}");
1066 if (TYPE_LOCALTYPE_PTR (type
) && show
>= 0)
1067 fprintfi_filtered (level
, stream
, " (Local at %s:%d)\n",
1068 TYPE_LOCALTYPE_FILE (type
),
1069 TYPE_LOCALTYPE_LINE (type
));
1071 if (TYPE_CODE (type
) == TYPE_CODE_TEMPLATE
)
1075 case TYPE_CODE_ENUM
:
1076 c_type_print_modifier (type
, stream
, 0, 1);
1077 /* HP C supports sized enums */
1078 if (hp_som_som_object_present
)
1079 switch (TYPE_LENGTH (type
))
1082 fputs_filtered ("char ", stream
);
1085 fputs_filtered ("short ", stream
);
1090 fprintf_filtered (stream
, "enum ");
1091 /* Print the tag name if it exists.
1092 The aCC compiler emits a spurious
1093 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1094 tag for unnamed struct/union/enum's, which we don't
1096 if (TYPE_TAG_NAME (type
) != NULL
&&
1097 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
1099 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1101 fputs_filtered (" ", stream
);
1107 /* If we just printed a tag name, no need to print anything else. */
1108 if (TYPE_TAG_NAME (type
) == NULL
)
1109 fprintf_filtered (stream
, "{...}");
1111 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1113 fprintf_filtered (stream
, "{");
1114 len
= TYPE_NFIELDS (type
);
1116 for (i
= 0; i
< len
; i
++)
1120 fprintf_filtered (stream
, ", ");
1122 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1123 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
1125 fprintf_filtered (stream
, " = %d", TYPE_FIELD_BITPOS (type
, i
));
1126 lastval
= TYPE_FIELD_BITPOS (type
, i
);
1130 fprintf_filtered (stream
, "}");
1134 case TYPE_CODE_VOID
:
1135 fprintf_filtered (stream
, "void");
1138 case TYPE_CODE_UNDEF
:
1139 fprintf_filtered (stream
, "struct <unknown>");
1142 case TYPE_CODE_ERROR
:
1143 fprintf_filtered (stream
, "<unknown type>");
1146 case TYPE_CODE_RANGE
:
1147 /* This should not occur */
1148 fprintf_filtered (stream
, "<range type>");
1151 case TYPE_CODE_TEMPLATE
:
1152 /* Called on "ptype t" where "t" is a template.
1153 Prints the template header (with args), e.g.:
1154 template <class T1, class T2> class "
1155 and then merges with the struct/union/class code to
1156 print the rest of the definition. */
1157 c_type_print_modifier (type
, stream
, 0, 1);
1158 fprintf_filtered (stream
, "template <");
1159 for (i
= 0; i
< TYPE_NTEMPLATE_ARGS (type
); i
++)
1161 struct template_arg templ_arg
;
1162 templ_arg
= TYPE_TEMPLATE_ARG (type
, i
);
1163 fprintf_filtered (stream
, "class %s", templ_arg
.name
);
1164 if (i
< TYPE_NTEMPLATE_ARGS (type
) - 1)
1165 fprintf_filtered (stream
, ", ");
1167 fprintf_filtered (stream
, "> class ");
1168 /* Yuck, factor this out to a subroutine so we can call
1169 it and return to the point marked with the "goback:" label... - RT */
1172 if (TYPE_NINSTANTIATIONS (type
) > 0)
1174 fprintf_filtered (stream
, "\ntemplate instantiations:\n");
1175 for (i
= 0; i
< TYPE_NINSTANTIATIONS (type
); i
++)
1177 fprintf_filtered (stream
, " ");
1178 c_type_print_base (TYPE_INSTANTIATION (type
, i
), stream
, 0, level
);
1179 if (i
< TYPE_NINSTANTIATIONS (type
) - 1)
1180 fprintf_filtered (stream
, "\n");
1186 /* Handle types not explicitly handled by the other cases,
1187 such as fundamental types. For these, just print whatever
1188 the type name is, as recorded in the type itself. If there
1189 is no type name, then complain. */
1190 if (TYPE_NAME (type
) != NULL
)
1192 c_type_print_modifier (type
, stream
, 0, 1);
1193 fputs_filtered (TYPE_NAME (type
), stream
);
1197 /* At least for dump_symtab, it is important that this not be
1199 fprintf_filtered (stream
, "<invalid type code %d>",