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, 2008, 2009
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 3 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, see <http://www.gnu.org/licenses/>. */
22 #include "gdb_obstack.h"
23 #include "bfd.h" /* Binary File Description */
26 #include "expression.h"
33 #include "typeprint.h"
36 #include "gdb_string.h"
39 static void cp_type_print_method_args (struct type
*mtype
, char *prefix
,
40 char *varstring
, int staticp
,
41 struct ui_file
*stream
);
43 static void c_type_print_args (struct type
*, struct ui_file
*);
45 static void cp_type_print_derivation_info (struct ui_file
*, struct type
*);
47 static void c_type_print_varspec_prefix (struct type
*, struct ui_file
*, int,
50 /* Print "const", "volatile", or address space modifiers. */
51 static void c_type_print_modifier (struct type
*, struct ui_file
*,
57 /* LEVEL is the depth to indent lines by. */
60 c_print_type (struct type
*type
, char *varstring
, struct ui_file
*stream
,
70 c_type_print_base (type
, stream
, show
, level
);
71 code
= TYPE_CODE (type
);
72 if ((varstring
!= NULL
&& *varstring
!= '\0')
74 /* Need a space if going to print stars or brackets;
75 but not if we will print just a type name. */
76 ((show
> 0 || TYPE_NAME (type
) == 0)
78 (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
79 || code
== TYPE_CODE_METHOD
80 || code
== TYPE_CODE_ARRAY
81 || code
== TYPE_CODE_MEMBERPTR
82 || code
== TYPE_CODE_METHODPTR
83 || code
== TYPE_CODE_REF
)))
84 fputs_filtered (" ", stream
);
85 need_post_space
= (varstring
!= NULL
&& strcmp (varstring
, "") != 0);
86 c_type_print_varspec_prefix (type
, stream
, show
, 0, need_post_space
);
88 if (varstring
!= NULL
)
90 fputs_filtered (varstring
, stream
);
92 /* For demangled function names, we have the arglist as part of the name,
93 so don't print an additional pair of ()'s */
95 demangled_args
= strchr (varstring
, '(') != NULL
;
96 c_type_print_varspec_suffix (type
, stream
, show
, 0, demangled_args
);
100 /* Print a typedef using C syntax. TYPE is the underlying type.
101 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
105 c_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
106 struct ui_file
*stream
)
108 CHECK_TYPEDEF (type
);
109 fprintf_filtered (stream
, "typedef ");
110 type_print (type
, "", stream
, 0);
111 if (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))) == 0
112 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))),
113 SYMBOL_LINKAGE_NAME (new_symbol
)) != 0)
114 fprintf_filtered (stream
, " %s", SYMBOL_PRINT_NAME (new_symbol
));
115 fprintf_filtered (stream
, ";\n");
118 /* If TYPE is a derived type, then print out derivation information.
119 Print only the actual base classes of this type, not the base classes
120 of the base classes. I.E. for the derivation hierarchy:
123 class B : public A {int b; };
124 class C : public B {int c; };
126 Print the type of class C as:
132 Not as the following (like gdb used to), which is not legal C++ syntax for
133 derived types and may be confused with the multiple inheritance form:
135 class C : public B : public A {
139 In general, gdb should try to print the types as closely as possible to
140 the form that they appear in the source code.
141 Note that in case of protected derivation gcc will not say 'protected'
142 but 'private'. The HP's aCC compiler emits specific information for
143 derivation via protected inheritance, so gdb can print it out */
146 cp_type_print_derivation_info (struct ui_file
*stream
, struct type
*type
)
151 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
153 fputs_filtered (i
== 0 ? ": " : ", ", stream
);
154 fprintf_filtered (stream
, "%s%s ",
155 BASETYPE_VIA_PUBLIC (type
, i
) ? "public"
156 : (TYPE_FIELD_PROTECTED (type
, i
) ? "protected" : "private"),
157 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
158 name
= type_name_no_tag (TYPE_BASECLASS (type
, i
));
159 fprintf_filtered (stream
, "%s", name
? name
: "(null)");
163 fputs_filtered (" ", stream
);
167 /* Print the C++ method arguments ARGS to the file STREAM. */
170 cp_type_print_method_args (struct type
*mtype
, char *prefix
, char *varstring
,
171 int staticp
, struct ui_file
*stream
)
173 struct field
*args
= TYPE_FIELDS (mtype
);
174 int nargs
= TYPE_NFIELDS (mtype
);
175 int varargs
= TYPE_VARARGS (mtype
);
178 fprintf_symbol_filtered (stream
, prefix
, language_cplus
, DMGL_ANSI
);
179 fprintf_symbol_filtered (stream
, varstring
, language_cplus
, DMGL_ANSI
);
180 fputs_filtered ("(", stream
);
182 /* Skip the class variable. */
188 type_print (args
[i
++].type
, "", stream
, 0);
190 if (i
== nargs
&& varargs
)
191 fprintf_filtered (stream
, ", ...");
193 fprintf_filtered (stream
, ", ");
197 fprintf_filtered (stream
, "...");
198 else if (current_language
->la_language
== language_cplus
)
199 fprintf_filtered (stream
, "void");
201 fprintf_filtered (stream
, ")");
205 /* Print any asterisks or open-parentheses needed before the
206 variable name (to describe its type).
208 On outermost call, pass 0 for PASSED_A_PTR.
209 On outermost call, SHOW > 0 means should ignore
210 any typename for TYPE and show its details.
211 SHOW is always zero on recursive calls.
213 NEED_POST_SPACE is non-zero when a space will be be needed
214 between a trailing qualifier and a field, variable, or function
218 c_type_print_varspec_prefix (struct type
*type
, struct ui_file
*stream
,
219 int show
, int passed_a_ptr
, int need_post_space
)
225 if (TYPE_NAME (type
) && show
<= 0)
230 switch (TYPE_CODE (type
))
233 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 1, 1);
234 fprintf_filtered (stream
, "*");
235 c_type_print_modifier (type
, stream
, 1, need_post_space
);
238 case TYPE_CODE_MEMBERPTR
:
239 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
240 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
242 fputs_filtered (name
, stream
);
244 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
245 fprintf_filtered (stream
, "::*");
248 case TYPE_CODE_METHODPTR
:
249 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
250 fprintf_filtered (stream
, "(");
251 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
253 fputs_filtered (name
, stream
);
255 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
256 fprintf_filtered (stream
, "::*");
260 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 1, 0);
261 fprintf_filtered (stream
, "&");
262 c_type_print_modifier (type
, stream
, 1, need_post_space
);
265 case TYPE_CODE_METHOD
:
267 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
269 fprintf_filtered (stream
, "(");
272 case TYPE_CODE_ARRAY
:
273 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
275 fprintf_filtered (stream
, "(");
278 case TYPE_CODE_TYPEDEF
:
279 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
282 case TYPE_CODE_UNDEF
:
283 case TYPE_CODE_STRUCT
:
284 case TYPE_CODE_UNION
:
289 case TYPE_CODE_ERROR
:
293 case TYPE_CODE_RANGE
:
294 case TYPE_CODE_STRING
:
295 case TYPE_CODE_BITSTRING
:
296 case TYPE_CODE_COMPLEX
:
297 case TYPE_CODE_TEMPLATE
:
298 case TYPE_CODE_NAMESPACE
:
299 case TYPE_CODE_DECFLOAT
:
300 /* These types need no prefix. They are listed here so that
301 gcc -Wall will reveal any types that haven't been handled. */
304 error (_("type not handled in c_type_print_varspec_prefix()"));
309 /* Print out "const" and "volatile" attributes.
310 TYPE is a pointer to the type being printed out.
311 STREAM is the output destination.
312 NEED_SPACE = 1 indicates an initial white space is needed */
315 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
316 int need_pre_space
, int need_post_space
)
318 int did_print_modifier
= 0;
319 const char *address_space_id
;
321 /* We don't print `const' qualifiers for references --- since all
322 operators affect the thing referenced, not the reference itself,
323 every reference is `const'. */
324 if (TYPE_CONST (type
)
325 && TYPE_CODE (type
) != TYPE_CODE_REF
)
328 fprintf_filtered (stream
, " ");
329 fprintf_filtered (stream
, "const");
330 did_print_modifier
= 1;
333 if (TYPE_VOLATILE (type
))
335 if (did_print_modifier
|| need_pre_space
)
336 fprintf_filtered (stream
, " ");
337 fprintf_filtered (stream
, "volatile");
338 did_print_modifier
= 1;
341 address_space_id
= address_space_int_to_name (TYPE_INSTANCE_FLAGS (type
));
342 if (address_space_id
)
344 if (did_print_modifier
|| need_pre_space
)
345 fprintf_filtered (stream
, " ");
346 fprintf_filtered (stream
, "@%s", address_space_id
);
347 did_print_modifier
= 1;
350 if (did_print_modifier
&& need_post_space
)
351 fprintf_filtered (stream
, " ");
355 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
356 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
357 in non-static methods, are displayed. */
360 c_type_print_args (struct type
*type
, struct ui_file
*stream
)
366 fprintf_filtered (stream
, "(");
367 args
= TYPE_FIELDS (type
);
368 len
= TYPE_NFIELDS (type
);
370 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
374 fprintf_filtered (stream
, ", ");
378 c_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
382 if (printed_any
&& TYPE_VARARGS (type
))
384 /* Print out a trailing ellipsis for varargs functions. Ignore
385 TYPE_VARARGS if the function has no named arguments; that
386 represents unprototyped (K&R style) C functions. */
387 if (printed_any
&& TYPE_VARARGS (type
))
389 fprintf_filtered (stream
, ", ");
391 fprintf_filtered (stream
, "...");
394 else if (!printed_any
395 && (TYPE_PROTOTYPED (type
)
396 || current_language
->la_language
== language_cplus
))
397 fprintf_filtered (stream
, "void");
399 fprintf_filtered (stream
, ")");
403 /* Return true iff the j'th overloading of the i'th method of TYPE
404 is a type conversion operator, like `operator int () { ... }'.
405 When listing a class's methods, we don't print the return type of
408 is_type_conversion_operator (struct type
*type
, int i
, int j
)
410 /* I think the whole idea of recognizing type conversion operators
411 by their name is pretty terrible. But I don't think our present
412 data structure gives us any other way to tell. If you know of
413 some other way, feel free to rewrite this function. */
414 char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
416 if (strncmp (name
, "operator", 8) != 0)
420 if (! strchr (" \t\f\n\r", *name
))
423 while (strchr (" \t\f\n\r", *name
))
426 if (!('a' <= *name
&& *name
<= 'z')
427 && !('A' <= *name
&& *name
<= 'Z')
429 /* If this doesn't look like the start of an identifier, then it
430 isn't a type conversion operator. */
432 else if (strncmp (name
, "new", 3) == 0)
434 else if (strncmp (name
, "delete", 6) == 0)
437 /* If it doesn't look like new or delete, it's a type conversion
441 /* Is that really the end of the name? */
442 if (('a' <= *name
&& *name
<= 'z')
443 || ('A' <= *name
&& *name
<= 'Z')
444 || ('0' <= *name
&& *name
<= '9')
446 /* No, so the identifier following "operator" must be a type name,
447 and this is a type conversion operator. */
450 /* That was indeed the end of the name, so it was `operator new' or
451 `operator delete', neither of which are type conversion operators. */
456 /* Given a C++ qualified identifier QID, strip off the qualifiers,
457 yielding the unqualified name. The return value is a pointer into
460 It's a pity we don't have this information in some more structured
461 form. Even the author of this function feels that writing little
462 parsers like this everywhere is stupid. */
464 remove_qualifiers (char *qid
)
466 int quoted
= 0; /* zero if we're not in quotes;
467 '"' if we're in a double-quoted string;
468 '\'' if we're in a single-quoted string. */
469 int depth
= 0; /* number of unclosed parens we've seen */
470 char *parenstack
= (char *) alloca (strlen (qid
));
472 char *last
= 0; /* The character after the rightmost
473 `::' token we've seen so far. */
475 for (scan
= qid
; *scan
; scan
++)
481 else if (*scan
== '\\' && *(scan
+ 1))
484 else if (scan
[0] == ':' && scan
[1] == ':')
486 /* If we're inside parenthesis (i.e., an argument list) or
487 angle brackets (i.e., a list of template arguments), then
488 we don't record the position of this :: token, since it's
489 not relevant to the top-level structure we're trying
497 else if (*scan
== '"' || *scan
== '\'')
499 else if (*scan
== '(')
500 parenstack
[depth
++] = ')';
501 else if (*scan
== '[')
502 parenstack
[depth
++] = ']';
503 /* We're going to treat <> as a pair of matching characters,
504 since we're more likely to see those in template id's than
505 real less-than characters. What a crock. */
506 else if (*scan
== '<')
507 parenstack
[depth
++] = '>';
508 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
510 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
514 /* We're going to do a little error recovery here. If we
515 don't find a match for *scan on the paren stack, but
516 there is something lower on the stack that does match, we
517 pop the stack to that point. */
520 for (i
= depth
- 1; i
>= 0; i
--)
521 if (parenstack
[i
] == *scan
)
533 /* We didn't find any :: tokens at the top level, so declare the
534 whole thing an unqualified identifier. */
539 /* Print any array sizes, function arguments or close parentheses
540 needed after the variable name (to describe its type).
541 Args work like c_type_print_varspec_prefix. */
544 c_type_print_varspec_suffix (struct type
*type
, struct ui_file
*stream
,
545 int show
, int passed_a_ptr
, int demangled_args
)
550 if (TYPE_NAME (type
) && show
<= 0)
555 switch (TYPE_CODE (type
))
557 case TYPE_CODE_ARRAY
:
559 fprintf_filtered (stream
, ")");
561 fprintf_filtered (stream
, "[");
562 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0
563 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))
564 fprintf_filtered (stream
, "%d",
566 / TYPE_LENGTH (TYPE_TARGET_TYPE (type
))));
567 fprintf_filtered (stream
, "]");
569 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
573 case TYPE_CODE_MEMBERPTR
:
574 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
578 case TYPE_CODE_METHODPTR
:
579 fprintf_filtered (stream
, ")");
580 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
586 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
590 case TYPE_CODE_METHOD
:
593 fprintf_filtered (stream
, ")");
595 c_type_print_args (type
, stream
);
596 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
600 case TYPE_CODE_TYPEDEF
:
601 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
605 case TYPE_CODE_UNDEF
:
606 case TYPE_CODE_STRUCT
:
607 case TYPE_CODE_UNION
:
612 case TYPE_CODE_ERROR
:
616 case TYPE_CODE_RANGE
:
617 case TYPE_CODE_STRING
:
618 case TYPE_CODE_BITSTRING
:
619 case TYPE_CODE_COMPLEX
:
620 case TYPE_CODE_TEMPLATE
:
621 case TYPE_CODE_NAMESPACE
:
622 case TYPE_CODE_DECFLOAT
:
623 /* These types do not need a suffix. They are listed so that
624 gcc -Wall will report types that may not have been considered. */
627 error (_("type not handled in c_type_print_varspec_suffix()"));
632 /* Print the name of the type (or the ultimate pointer target,
633 function value or array element), or the description of a
636 SHOW positive means print details about the type (e.g. enum values),
637 and print structure elements passing SHOW - 1 for show.
638 SHOW negative means just print the type name or struct tag if there is one.
639 If there is no name, print something sensible but concise like
641 SHOW zero means just print the type name or struct tag if there is one.
642 If there is no name, print something sensible but not as concise like
643 "struct {int x; int y;}".
645 LEVEL is the number of spaces to indent by.
646 We increase it for some recursive calls. */
649 c_type_print_base (struct type
*type
, struct ui_file
*stream
, int show
,
656 char *demangled_name
;
657 char *demangled_no_static
;
660 s_none
, s_public
, s_private
, s_protected
663 int need_access_label
= 0;
671 fputs_filtered (_("<type unknown>"), stream
);
675 /* When SHOW is zero or less, and there is a valid type name, then always
676 just print the type name directly from the type. */
677 /* If we have "typedef struct foo {. . .} bar;" do we want to print it
678 as "struct foo" or as "bar"? Pick the latter, because C++ folk tend
679 to expect things like "class5 *foo" rather than "struct class5 *foo". */
682 && TYPE_NAME (type
) != NULL
)
684 c_type_print_modifier (type
, stream
, 0, 1);
685 fputs_filtered (TYPE_NAME (type
), stream
);
689 CHECK_TYPEDEF (type
);
691 switch (TYPE_CODE (type
))
693 case TYPE_CODE_TYPEDEF
:
694 case TYPE_CODE_ARRAY
:
696 case TYPE_CODE_MEMBERPTR
:
699 case TYPE_CODE_METHOD
:
700 case TYPE_CODE_METHODPTR
:
701 c_type_print_base (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
704 case TYPE_CODE_STRUCT
:
705 c_type_print_modifier (type
, stream
, 0, 1);
706 /* Note TYPE_CODE_STRUCT and TYPE_CODE_CLASS have the same value,
707 * so we use another means for distinguishing them.
709 if (HAVE_CPLUS_STRUCT (type
))
711 switch (TYPE_DECLARED_TYPE (type
))
713 case DECLARED_TYPE_CLASS
:
714 fprintf_filtered (stream
, "class ");
716 case DECLARED_TYPE_UNION
:
717 fprintf_filtered (stream
, "union ");
719 case DECLARED_TYPE_STRUCT
:
720 fprintf_filtered (stream
, "struct ");
723 /* If there is a CPLUS_STRUCT, assume class if not
724 * otherwise specified in the declared_type field.
726 fprintf_filtered (stream
, "class ");
732 /* If not CPLUS_STRUCT, then assume it's a C struct */
733 fprintf_filtered (stream
, "struct ");
737 case TYPE_CODE_UNION
:
738 c_type_print_modifier (type
, stream
, 0, 1);
739 fprintf_filtered (stream
, "union ");
743 /* Print the tag if it exists.
744 * The HP aCC compiler emits
745 * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
746 * tag for unnamed struct/union/enum's, which we don't
749 if (TYPE_TAG_NAME (type
) != NULL
&&
750 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
752 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
754 fputs_filtered (" ", stream
);
759 /* If we just printed a tag name, no need to print anything else. */
760 if (TYPE_TAG_NAME (type
) == NULL
)
761 fprintf_filtered (stream
, "{...}");
763 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
765 cp_type_print_derivation_info (stream
, type
);
767 fprintf_filtered (stream
, "{\n");
768 if ((TYPE_NFIELDS (type
) == 0) && (TYPE_NFN_FIELDS (type
) == 0))
770 if (TYPE_STUB (type
))
771 fprintfi_filtered (level
+ 4, stream
, _("<incomplete type>\n"));
773 fprintfi_filtered (level
+ 4, stream
, _("<no data fields>\n"));
776 /* Start off with no specific section type, so we can print
777 one for the first field we find, and use that section type
778 thereafter until we find another type. */
780 section_type
= s_none
;
782 /* For a class, if all members are private, there's no need
783 for a "private:" label; similarly, for a struct or union
784 masquerading as a class, if all members are public, there's
785 no need for a "public:" label. */
787 if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_CLASS
) ||
788 (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_TEMPLATE
))
791 len
= TYPE_NFIELDS (type
);
792 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
793 if (!TYPE_FIELD_PRIVATE (type
, i
))
795 need_access_label
= 1;
799 if (!need_access_label
)
801 len2
= TYPE_NFN_FIELDS (type
);
802 for (j
= 0; j
< len2
; j
++)
804 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
805 for (i
= 0; i
< len
; i
++)
806 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
))
808 need_access_label
= 1;
811 if (need_access_label
)
816 else if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_STRUCT
) ||
817 (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_UNION
))
820 len
= TYPE_NFIELDS (type
);
821 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
822 if (TYPE_FIELD_PRIVATE (type
, i
) || TYPE_FIELD_PROTECTED (type
, i
))
824 need_access_label
= 1;
828 if (!need_access_label
)
830 len2
= TYPE_NFN_FIELDS (type
);
831 for (j
= 0; j
< len2
; j
++)
834 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
835 for (i
= 0; i
< len
; i
++)
836 if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
) ||
837 TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
, j
), i
))
839 need_access_label
= 1;
842 if (need_access_label
)
848 /* If there is a base class for this type,
849 do not print the field that it occupies. */
851 len
= TYPE_NFIELDS (type
);
852 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
855 /* Don't print out virtual function table. */
856 if (strncmp (TYPE_FIELD_NAME (type
, i
), "_vptr", 5) == 0
857 && is_cplus_marker ((TYPE_FIELD_NAME (type
, i
))[5]))
860 /* If this is a C++ class we can print the various C++ section
863 if (HAVE_CPLUS_STRUCT (type
) && need_access_label
)
865 if (TYPE_FIELD_PROTECTED (type
, i
))
867 if (section_type
!= s_protected
)
869 section_type
= s_protected
;
870 fprintfi_filtered (level
+ 2, stream
,
874 else if (TYPE_FIELD_PRIVATE (type
, i
))
876 if (section_type
!= s_private
)
878 section_type
= s_private
;
879 fprintfi_filtered (level
+ 2, stream
, "private:\n");
884 if (section_type
!= s_public
)
886 section_type
= s_public
;
887 fprintfi_filtered (level
+ 2, stream
, "public:\n");
892 print_spaces_filtered (level
+ 4, stream
);
893 if (field_is_static (&TYPE_FIELD (type
, i
)))
894 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 (!field_is_static (&TYPE_FIELD (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
&& strcmp (method_name
, name
) == 0;
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
))
1014 int staticp
= TYPE_FN_FIELD_STATIC_P (f
, j
);
1015 struct type
*mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1016 cp_type_print_method_args (mtype
,
1023 fprintf_filtered (stream
, _("<badly mangled name '%s'>"),
1029 char *demangled_no_class
1030 = remove_qualifiers (demangled_name
);
1032 /* get rid of the `static' appended by the demangler */
1033 p
= strstr (demangled_no_class
, " static");
1036 int length
= p
- demangled_no_class
;
1037 demangled_no_static
= (char *) xmalloc (length
+ 1);
1038 strncpy (demangled_no_static
, demangled_no_class
, length
);
1039 *(demangled_no_static
+ length
) = '\0';
1040 fputs_filtered (demangled_no_static
, stream
);
1041 xfree (demangled_no_static
);
1044 fputs_filtered (demangled_no_class
, stream
);
1045 xfree (demangled_name
);
1048 if (TYPE_FN_FIELD_STUB (f
, j
))
1049 xfree (mangled_name
);
1051 fprintf_filtered (stream
, ";\n");
1055 fprintfi_filtered (level
, stream
, "}");
1057 if (TYPE_LOCALTYPE_PTR (type
) && show
>= 0)
1058 fprintfi_filtered (level
, stream
, _(" (Local at %s:%d)\n"),
1059 TYPE_LOCALTYPE_FILE (type
),
1060 TYPE_LOCALTYPE_LINE (type
));
1064 case TYPE_CODE_ENUM
:
1065 c_type_print_modifier (type
, stream
, 0, 1);
1066 fprintf_filtered (stream
, "enum ");
1067 /* Print the tag name if it exists.
1068 The aCC compiler emits a spurious
1069 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1070 tag for unnamed struct/union/enum's, which we don't
1072 if (TYPE_TAG_NAME (type
) != NULL
&&
1073 strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
1075 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1077 fputs_filtered (" ", stream
);
1083 /* If we just printed a tag name, no need to print anything else. */
1084 if (TYPE_TAG_NAME (type
) == NULL
)
1085 fprintf_filtered (stream
, "{...}");
1087 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1089 fprintf_filtered (stream
, "{");
1090 len
= TYPE_NFIELDS (type
);
1092 for (i
= 0; i
< len
; i
++)
1096 fprintf_filtered (stream
, ", ");
1098 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1099 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
1101 fprintf_filtered (stream
, " = %d", TYPE_FIELD_BITPOS (type
, i
));
1102 lastval
= TYPE_FIELD_BITPOS (type
, i
);
1106 fprintf_filtered (stream
, "}");
1110 case TYPE_CODE_VOID
:
1111 fprintf_filtered (stream
, "void");
1114 case TYPE_CODE_UNDEF
:
1115 fprintf_filtered (stream
, _("struct <unknown>"));
1118 case TYPE_CODE_ERROR
:
1119 fprintf_filtered (stream
, _("<unknown type>"));
1122 case TYPE_CODE_RANGE
:
1123 /* This should not occur */
1124 fprintf_filtered (stream
, _("<range type>"));
1127 case TYPE_CODE_TEMPLATE
:
1128 /* Called on "ptype t" where "t" is a template.
1129 Prints the template header (with args), e.g.:
1130 template <class T1, class T2> class "
1131 and then merges with the struct/union/class code to
1132 print the rest of the definition. */
1133 c_type_print_modifier (type
, stream
, 0, 1);
1134 fprintf_filtered (stream
, "template <");
1135 for (i
= 0; i
< TYPE_NTEMPLATE_ARGS (type
); i
++)
1137 struct template_arg templ_arg
;
1138 templ_arg
= TYPE_TEMPLATE_ARG (type
, i
);
1139 fprintf_filtered (stream
, "class %s", templ_arg
.name
);
1140 if (i
< TYPE_NTEMPLATE_ARGS (type
) - 1)
1141 fprintf_filtered (stream
, ", ");
1143 fprintf_filtered (stream
, "> class ");
1146 case TYPE_CODE_NAMESPACE
:
1147 fputs_filtered ("namespace ", stream
);
1148 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1152 /* Handle types not explicitly handled by the other cases,
1153 such as fundamental types. For these, just print whatever
1154 the type name is, as recorded in the type itself. If there
1155 is no type name, then complain. */
1156 if (TYPE_NAME (type
) != NULL
)
1158 c_type_print_modifier (type
, stream
, 0, 1);
1159 fputs_filtered (TYPE_NAME (type
), stream
);
1163 /* At least for dump_symtab, it is important that this not be
1165 fprintf_filtered (stream
, _("<invalid type code %d>"),