1 /* Support for printing C and C++ types for GDB, the GNU debugger.
2 Copyright (C) 1986, 1988-1989, 1991-1996, 1998-2003, 2006-2012 Free
3 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 c_type_print_varspec_prefix (struct type
*,
41 const struct type_print_options
*);
43 /* Print "const", "volatile", or address space modifiers. */
44 static void c_type_print_modifier (struct type
*,
48 /* LEVEL is the depth to indent lines by. */
51 c_print_type (struct type
*type
,
52 const char *varstring
,
53 struct ui_file
*stream
,
55 const struct type_print_options
*flags
)
64 c_type_print_base (type
, stream
, show
, level
, flags
);
65 code
= TYPE_CODE (type
);
66 if ((varstring
!= NULL
&& *varstring
!= '\0')
67 /* Need a space if going to print stars or brackets;
68 but not if we will print just a type name. */
69 || ((show
> 0 || TYPE_NAME (type
) == 0)
70 && (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
71 || code
== TYPE_CODE_METHOD
72 || (code
== TYPE_CODE_ARRAY
73 && !TYPE_VECTOR (type
))
74 || code
== TYPE_CODE_MEMBERPTR
75 || code
== TYPE_CODE_METHODPTR
76 || code
== TYPE_CODE_REF
)))
77 fputs_filtered (" ", stream
);
78 need_post_space
= (varstring
!= NULL
&& strcmp (varstring
, "") != 0);
79 c_type_print_varspec_prefix (type
, stream
, show
, 0, need_post_space
,
82 if (varstring
!= NULL
)
84 fputs_filtered (varstring
, stream
);
86 /* For demangled function names, we have the arglist as part of
87 the name, so don't print an additional pair of ()'s. */
89 demangled_args
= strchr (varstring
, '(') != NULL
;
90 c_type_print_varspec_suffix (type
, stream
, show
,
91 0, demangled_args
, flags
);
95 /* Print a typedef using C syntax. TYPE is the underlying type.
96 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
100 c_print_typedef (struct type
*type
,
101 struct symbol
*new_symbol
,
102 struct ui_file
*stream
)
104 CHECK_TYPEDEF (type
);
105 fprintf_filtered (stream
, "typedef ");
106 type_print (type
, "", stream
, 0);
107 if (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))) == 0
108 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))),
109 SYMBOL_LINKAGE_NAME (new_symbol
)) != 0
110 || TYPE_CODE (SYMBOL_TYPE (new_symbol
)) == TYPE_CODE_TYPEDEF
)
111 fprintf_filtered (stream
, " %s", SYMBOL_PRINT_NAME (new_symbol
));
112 fprintf_filtered (stream
, ";\n");
115 /* If TYPE is a derived type, then print out derivation information.
116 Print only the actual base classes of this type, not the base
117 classes of the base classes. I.e. for the derivation hierarchy:
120 class B : public A {int b; };
121 class C : public B {int c; };
123 Print the type of class C as:
129 Not as the following (like gdb used to), which is not legal C++
130 syntax for derived types and may be confused with the multiple
133 class C : public B : public A {
137 In general, gdb should try to print the types as closely as
138 possible to the form that they appear in the source code. */
141 cp_type_print_derivation_info (struct ui_file
*stream
,
147 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
149 fputs_filtered (i
== 0 ? ": " : ", ", stream
);
150 fprintf_filtered (stream
, "%s%s ",
151 BASETYPE_VIA_PUBLIC (type
, i
)
152 ? "public" : (TYPE_FIELD_PROTECTED (type
, i
)
153 ? "protected" : "private"),
154 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
155 name
= type_name_no_tag (TYPE_BASECLASS (type
, i
));
156 fprintf_filtered (stream
, "%s", name
? name
: "(null)");
160 fputs_filtered (" ", stream
);
164 /* Print the C++ method arguments ARGS to the file STREAM. */
167 cp_type_print_method_args (struct type
*mtype
, const char *prefix
,
168 const char *varstring
, int staticp
,
169 struct ui_file
*stream
)
171 struct field
*args
= TYPE_FIELDS (mtype
);
172 int nargs
= TYPE_NFIELDS (mtype
);
173 int varargs
= TYPE_VARARGS (mtype
);
176 fprintf_symbol_filtered (stream
, prefix
,
177 language_cplus
, DMGL_ANSI
);
178 fprintf_symbol_filtered (stream
, varstring
,
179 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
, ")");
203 /* For non-static methods, read qualifiers from the type of
209 gdb_assert (nargs
> 0);
210 gdb_assert (TYPE_CODE (args
[0].type
) == TYPE_CODE_PTR
);
211 domain
= TYPE_TARGET_TYPE (args
[0].type
);
213 if (TYPE_CONST (domain
))
214 fprintf_filtered (stream
, " const");
216 if (TYPE_VOLATILE (domain
))
217 fprintf_filtered (stream
, " volatile");
222 /* Print any asterisks or open-parentheses needed before the
223 variable name (to describe its type).
225 On outermost call, pass 0 for PASSED_A_PTR.
226 On outermost call, SHOW > 0 means should ignore
227 any typename for TYPE and show its details.
228 SHOW is always zero on recursive calls.
230 NEED_POST_SPACE is non-zero when a space will be be needed
231 between a trailing qualifier and a field, variable, or function
235 c_type_print_varspec_prefix (struct type
*type
,
236 struct ui_file
*stream
,
237 int show
, int passed_a_ptr
,
239 const struct type_print_options
*flags
)
246 if (TYPE_NAME (type
) && show
<= 0)
251 switch (TYPE_CODE (type
))
254 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
255 stream
, show
, 1, 1, flags
);
256 fprintf_filtered (stream
, "*");
257 c_type_print_modifier (type
, stream
, 1, need_post_space
);
260 case TYPE_CODE_MEMBERPTR
:
261 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
262 stream
, show
, 0, 0, flags
);
263 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
265 fputs_filtered (name
, stream
);
267 c_type_print_base (TYPE_DOMAIN_TYPE (type
),
268 stream
, -1, passed_a_ptr
, flags
);
269 fprintf_filtered (stream
, "::*");
272 case TYPE_CODE_METHODPTR
:
273 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
274 stream
, show
, 0, 0, flags
);
275 fprintf_filtered (stream
, "(");
276 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
278 fputs_filtered (name
, stream
);
280 c_type_print_base (TYPE_DOMAIN_TYPE (type
),
281 stream
, -1, passed_a_ptr
, flags
);
282 fprintf_filtered (stream
, "::*");
286 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
287 stream
, show
, 1, 0, flags
);
288 fprintf_filtered (stream
, "&");
289 c_type_print_modifier (type
, stream
, 1, need_post_space
);
292 case TYPE_CODE_METHOD
:
294 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
295 stream
, show
, 0, 0, flags
);
297 fprintf_filtered (stream
, "(");
300 case TYPE_CODE_ARRAY
:
301 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
302 stream
, show
, 0, 0, flags
);
304 fprintf_filtered (stream
, "(");
307 case TYPE_CODE_TYPEDEF
:
308 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
309 stream
, show
, passed_a_ptr
, 0, flags
);
312 case TYPE_CODE_UNDEF
:
313 case TYPE_CODE_STRUCT
:
314 case TYPE_CODE_UNION
:
319 case TYPE_CODE_ERROR
:
323 case TYPE_CODE_RANGE
:
324 case TYPE_CODE_STRING
:
325 case TYPE_CODE_COMPLEX
:
326 case TYPE_CODE_NAMESPACE
:
327 case TYPE_CODE_DECFLOAT
:
328 /* These types need no prefix. They are listed here so that
329 gcc -Wall will reveal any types that haven't been handled. */
332 error (_("type not handled in c_type_print_varspec_prefix()"));
337 /* Print out "const" and "volatile" attributes,
338 and address space id if present.
339 TYPE is a pointer to the type being printed out.
340 STREAM is the output destination.
341 NEED_PRE_SPACE = 1 indicates an initial white space is needed.
342 NEED_POST_SPACE = 1 indicates a final white space is needed. */
345 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
346 int need_pre_space
, int need_post_space
)
348 int did_print_modifier
= 0;
349 const char *address_space_id
;
351 /* We don't print `const' qualifiers for references --- since all
352 operators affect the thing referenced, not the reference itself,
353 every reference is `const'. */
354 if (TYPE_CONST (type
)
355 && TYPE_CODE (type
) != TYPE_CODE_REF
)
358 fprintf_filtered (stream
, " ");
359 fprintf_filtered (stream
, "const");
360 did_print_modifier
= 1;
363 if (TYPE_VOLATILE (type
))
365 if (did_print_modifier
|| need_pre_space
)
366 fprintf_filtered (stream
, " ");
367 fprintf_filtered (stream
, "volatile");
368 did_print_modifier
= 1;
371 address_space_id
= address_space_int_to_name (get_type_arch (type
),
372 TYPE_INSTANCE_FLAGS (type
));
373 if (address_space_id
)
375 if (did_print_modifier
|| need_pre_space
)
376 fprintf_filtered (stream
, " ");
377 fprintf_filtered (stream
, "@%s", address_space_id
);
378 did_print_modifier
= 1;
381 if (did_print_modifier
&& need_post_space
)
382 fprintf_filtered (stream
, " ");
386 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
387 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
388 in non-static methods, are displayed if LINKAGE_NAME is zero. If
389 LINKAGE_NAME is non-zero and LANGUAGE is language_cplus the topmost
390 parameter types get removed their possible const and volatile qualifiers to
391 match demangled linkage name parameters part of such function type.
392 LANGUAGE is the language in which TYPE was defined. This is a necessary
393 evil since this code is used by the C, C++, and Java backends. */
396 c_type_print_args (struct type
*type
, struct ui_file
*stream
,
397 int linkage_name
, enum language language
,
398 const struct type_print_options
*flags
)
404 fprintf_filtered (stream
, "(");
405 args
= TYPE_FIELDS (type
);
406 len
= TYPE_NFIELDS (type
);
408 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
410 struct type
*param_type
;
412 if (TYPE_FIELD_ARTIFICIAL (type
, i
) && linkage_name
)
417 fprintf_filtered (stream
, ", ");
421 param_type
= TYPE_FIELD_TYPE (type
, i
);
423 if (language
== language_cplus
&& linkage_name
)
425 /* C++ standard, 13.1 Overloadable declarations, point 3, item:
426 - Parameter declarations that differ only in the presence or
427 absence of const and/or volatile are equivalent.
429 And the const/volatile qualifiers are not present in the mangled
430 names as produced by GCC. */
432 param_type
= make_cv_type (0, 0, param_type
, NULL
);
435 if (language
== language_java
)
436 java_print_type (param_type
, "", stream
, -1, 0, flags
);
438 c_print_type (param_type
, "", stream
, -1, 0, flags
);
442 if (printed_any
&& TYPE_VARARGS (type
))
444 /* Print out a trailing ellipsis for varargs functions. Ignore
445 TYPE_VARARGS if the function has no named arguments; that
446 represents unprototyped (K&R style) C functions. */
447 if (printed_any
&& TYPE_VARARGS (type
))
449 fprintf_filtered (stream
, ", ");
451 fprintf_filtered (stream
, "...");
454 else if (!printed_any
455 && ((TYPE_PROTOTYPED (type
) && language
!= language_java
)
456 || language
== language_cplus
))
457 fprintf_filtered (stream
, "void");
459 fprintf_filtered (stream
, ")");
462 /* Return true iff the j'th overloading of the i'th method of TYPE
463 is a type conversion operator, like `operator int () { ... }'.
464 When listing a class's methods, we don't print the return type of
468 is_type_conversion_operator (struct type
*type
, int i
, int j
)
470 /* I think the whole idea of recognizing type conversion operators
471 by their name is pretty terrible. But I don't think our present
472 data structure gives us any other way to tell. If you know of
473 some other way, feel free to rewrite this function. */
474 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
476 if (strncmp (name
, "operator", 8) != 0)
480 if (! strchr (" \t\f\n\r", *name
))
483 while (strchr (" \t\f\n\r", *name
))
486 if (!('a' <= *name
&& *name
<= 'z')
487 && !('A' <= *name
&& *name
<= 'Z')
489 /* If this doesn't look like the start of an identifier, then it
490 isn't a type conversion operator. */
492 else if (strncmp (name
, "new", 3) == 0)
494 else if (strncmp (name
, "delete", 6) == 0)
497 /* If it doesn't look like new or delete, it's a type conversion
501 /* Is that really the end of the name? */
502 if (('a' <= *name
&& *name
<= 'z')
503 || ('A' <= *name
&& *name
<= 'Z')
504 || ('0' <= *name
&& *name
<= '9')
506 /* No, so the identifier following "operator" must be a type name,
507 and this is a type conversion operator. */
510 /* That was indeed the end of the name, so it was `operator new' or
511 `operator delete', neither of which are type conversion
516 /* Given a C++ qualified identifier QID, strip off the qualifiers,
517 yielding the unqualified name. The return value is a pointer into
520 It's a pity we don't have this information in some more structured
521 form. Even the author of this function feels that writing little
522 parsers like this everywhere is stupid. */
525 remove_qualifiers (char *qid
)
527 int quoted
= 0; /* Zero if we're not in quotes;
528 '"' if we're in a double-quoted string;
529 '\'' if we're in a single-quoted string. */
530 int depth
= 0; /* Number of unclosed parens we've seen. */
531 char *parenstack
= (char *) alloca (strlen (qid
));
533 char *last
= 0; /* The character after the rightmost
534 `::' token we've seen so far. */
536 for (scan
= qid
; *scan
; scan
++)
542 else if (*scan
== '\\' && *(scan
+ 1))
545 else if (scan
[0] == ':' && scan
[1] == ':')
547 /* If we're inside parenthesis (i.e., an argument list) or
548 angle brackets (i.e., a list of template arguments), then
549 we don't record the position of this :: token, since it's
550 not relevant to the top-level structure we're trying to
558 else if (*scan
== '"' || *scan
== '\'')
560 else if (*scan
== '(')
561 parenstack
[depth
++] = ')';
562 else if (*scan
== '[')
563 parenstack
[depth
++] = ']';
564 /* We're going to treat <> as a pair of matching characters,
565 since we're more likely to see those in template id's than
566 real less-than characters. What a crock. */
567 else if (*scan
== '<')
568 parenstack
[depth
++] = '>';
569 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
571 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
575 /* We're going to do a little error recovery here. If
576 we don't find a match for *scan on the paren stack,
577 but there is something lower on the stack that does
578 match, we pop the stack to that point. */
581 for (i
= depth
- 1; i
>= 0; i
--)
582 if (parenstack
[i
] == *scan
)
594 /* We didn't find any :: tokens at the top level, so declare the
595 whole thing an unqualified identifier. */
599 /* Print any array sizes, function arguments or close parentheses
600 needed after the variable name (to describe its type).
601 Args work like c_type_print_varspec_prefix. */
604 c_type_print_varspec_suffix (struct type
*type
,
605 struct ui_file
*stream
,
606 int show
, int passed_a_ptr
,
608 const struct type_print_options
*flags
)
613 if (TYPE_NAME (type
) && show
<= 0)
618 switch (TYPE_CODE (type
))
620 case TYPE_CODE_ARRAY
:
622 LONGEST low_bound
, high_bound
;
623 int is_vector
= TYPE_VECTOR (type
);
626 fprintf_filtered (stream
, ")");
628 fprintf_filtered (stream
, (is_vector
?
629 " __attribute__ ((vector_size(" : "["));
630 if (get_array_bounds (type
, &low_bound
, &high_bound
))
631 fprintf_filtered (stream
, "%s",
632 plongest (high_bound
- low_bound
+ 1));
633 fprintf_filtered (stream
, (is_vector
? ")))" : "]"));
635 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
640 case TYPE_CODE_MEMBERPTR
:
641 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
645 case TYPE_CODE_METHODPTR
:
646 fprintf_filtered (stream
, ")");
647 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
653 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
657 case TYPE_CODE_METHOD
:
660 fprintf_filtered (stream
, ")");
662 c_type_print_args (type
, stream
, 0, current_language
->la_language
,
664 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
665 show
, passed_a_ptr
, 0, flags
);
668 case TYPE_CODE_TYPEDEF
:
669 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
670 show
, passed_a_ptr
, 0, flags
);
673 case TYPE_CODE_UNDEF
:
674 case TYPE_CODE_STRUCT
:
675 case TYPE_CODE_UNION
:
680 case TYPE_CODE_ERROR
:
684 case TYPE_CODE_RANGE
:
685 case TYPE_CODE_STRING
:
686 case TYPE_CODE_COMPLEX
:
687 case TYPE_CODE_NAMESPACE
:
688 case TYPE_CODE_DECFLOAT
:
689 /* These types do not need a suffix. They are listed so that
690 gcc -Wall will report types that may not have been
694 error (_("type not handled in c_type_print_varspec_suffix()"));
699 /* Print the name of the type (or the ultimate pointer target,
700 function value or array element), or the description of a structure
703 SHOW positive means print details about the type (e.g. enum
704 values), and print structure elements passing SHOW - 1 for show.
706 SHOW negative means just print the type name or struct tag if there
707 is one. If there is no name, print something sensible but concise
710 SHOW zero means just print the type name or struct tag if there is
711 one. If there is no name, print something sensible but not as
712 concise like "struct {int x; int y;}".
714 LEVEL is the number of spaces to indent by.
715 We increase it for some recursive calls. */
718 c_type_print_base (struct type
*type
, struct ui_file
*stream
,
719 int show
, int level
, const struct type_print_options
*flags
)
725 s_none
, s_public
, s_private
, s_protected
728 int need_access_label
= 0;
736 fputs_filtered (_("<type unknown>"), stream
);
740 /* When SHOW is zero or less, and there is a valid type name, then
741 always just print the type name directly from the type. */
742 /* If we have "typedef struct foo {. . .} bar;" do we want to print
743 it as "struct foo" or as "bar"? Pick the latter, because C++
744 folk tend to expect things like "class5 *foo" rather than "struct
748 && TYPE_NAME (type
) != NULL
)
750 c_type_print_modifier (type
, stream
, 0, 1);
751 fputs_filtered (TYPE_NAME (type
), stream
);
755 CHECK_TYPEDEF (type
);
757 switch (TYPE_CODE (type
))
759 case TYPE_CODE_TYPEDEF
:
760 /* If we get here, the typedef doesn't have a name, and we
761 couldn't resolve TYPE_TARGET_TYPE. Not much we can do. */
762 gdb_assert (TYPE_NAME (type
) == NULL
);
763 gdb_assert (TYPE_TARGET_TYPE (type
) == NULL
);
764 fprintf_filtered (stream
, _("<unnamed typedef>"));
767 case TYPE_CODE_ARRAY
:
769 case TYPE_CODE_MEMBERPTR
:
772 case TYPE_CODE_METHOD
:
773 case TYPE_CODE_METHODPTR
:
774 c_type_print_base (TYPE_TARGET_TYPE (type
),
775 stream
, show
, level
, flags
);
778 case TYPE_CODE_STRUCT
:
779 case TYPE_CODE_UNION
:
780 c_type_print_modifier (type
, stream
, 0, 1);
781 if (TYPE_CODE (type
) == TYPE_CODE_UNION
)
782 fprintf_filtered (stream
, "union ");
783 else if (TYPE_DECLARED_CLASS (type
))
784 fprintf_filtered (stream
, "class ");
786 fprintf_filtered (stream
, "struct ");
788 /* Print the tag if it exists. The HP aCC compiler emits a
789 spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
790 enum}" tag for unnamed struct/union/enum's, which we don't
792 if (TYPE_TAG_NAME (type
) != NULL
793 && strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
795 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
797 fputs_filtered (" ", stream
);
802 /* If we just printed a tag name, no need to print anything
804 if (TYPE_TAG_NAME (type
) == NULL
)
805 fprintf_filtered (stream
, "{...}");
807 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
809 struct type
*basetype
;
812 cp_type_print_derivation_info (stream
, type
);
814 fprintf_filtered (stream
, "{\n");
815 if (TYPE_NFIELDS (type
) == 0 && TYPE_NFN_FIELDS (type
) == 0
816 && TYPE_TYPEDEF_FIELD_COUNT (type
) == 0)
818 if (TYPE_STUB (type
))
819 fprintfi_filtered (level
+ 4, stream
,
820 _("<incomplete type>\n"));
822 fprintfi_filtered (level
+ 4, stream
,
823 _("<no data fields>\n"));
826 /* Start off with no specific section type, so we can print
827 one for the first field we find, and use that section type
828 thereafter until we find another type. */
830 section_type
= s_none
;
832 /* For a class, if all members are private, there's no need
833 for a "private:" label; similarly, for a struct or union
834 masquerading as a class, if all members are public, there's
835 no need for a "public:" label. */
837 if (TYPE_DECLARED_CLASS (type
))
840 len
= TYPE_NFIELDS (type
);
841 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
842 if (!TYPE_FIELD_PRIVATE (type
, i
))
844 need_access_label
= 1;
848 if (!need_access_label
)
850 len2
= TYPE_NFN_FIELDS (type
);
851 for (j
= 0; j
< len2
; j
++)
853 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
854 for (i
= 0; i
< len
; i
++)
855 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
,
858 need_access_label
= 1;
861 if (need_access_label
)
869 len
= TYPE_NFIELDS (type
);
870 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
871 if (TYPE_FIELD_PRIVATE (type
, i
)
872 || TYPE_FIELD_PROTECTED (type
, i
))
874 need_access_label
= 1;
878 if (!need_access_label
)
880 len2
= TYPE_NFN_FIELDS (type
);
881 for (j
= 0; j
< len2
; j
++)
884 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
885 for (i
= 0; i
< len
; i
++)
886 if (TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
,
888 || TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
,
892 need_access_label
= 1;
895 if (need_access_label
)
901 /* If there is a base class for this type,
902 do not print the field that it occupies. */
904 len
= TYPE_NFIELDS (type
);
905 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
906 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
910 /* If we have a virtual table pointer, omit it. Even if
911 virtual table pointers are not specifically marked in
912 the debug info, they should be artificial. */
913 if ((i
== vptr_fieldno
&& type
== basetype
)
914 || TYPE_FIELD_ARTIFICIAL (type
, i
))
917 if (need_access_label
)
919 if (TYPE_FIELD_PROTECTED (type
, i
))
921 if (section_type
!= s_protected
)
923 section_type
= s_protected
;
924 fprintfi_filtered (level
+ 2, stream
,
928 else if (TYPE_FIELD_PRIVATE (type
, i
))
930 if (section_type
!= s_private
)
932 section_type
= s_private
;
933 fprintfi_filtered (level
+ 2, stream
,
939 if (section_type
!= s_public
)
941 section_type
= s_public
;
942 fprintfi_filtered (level
+ 2, stream
,
948 print_spaces_filtered (level
+ 4, stream
);
949 if (field_is_static (&TYPE_FIELD (type
, i
)))
950 fprintf_filtered (stream
, "static ");
951 c_print_type (TYPE_FIELD_TYPE (type
, i
),
952 TYPE_FIELD_NAME (type
, i
),
953 stream
, show
- 1, level
+ 4, flags
);
954 if (!field_is_static (&TYPE_FIELD (type
, i
))
955 && TYPE_FIELD_PACKED (type
, i
))
957 /* It is a bitfield. This code does not attempt
958 to look at the bitpos and reconstruct filler,
959 unnamed fields. This would lead to misleading
960 results if the compiler does not put out fields
961 for such things (I don't know what it does). */
962 fprintf_filtered (stream
, " : %d",
963 TYPE_FIELD_BITSIZE (type
, i
));
965 fprintf_filtered (stream
, ";\n");
968 /* If there are both fields and methods, put a blank line
969 between them. Make sure to count only method that we
970 will display; artificial methods will be hidden. */
971 len
= TYPE_NFN_FIELDS (type
);
973 for (i
= 0; i
< len
; i
++)
975 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
976 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
979 for (j
= 0; j
< len2
; j
++)
980 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
983 if (real_len
> 0 && section_type
!= s_none
)
984 fprintf_filtered (stream
, "\n");
986 /* C++: print out the methods. */
987 for (i
= 0; i
< len
; i
++)
989 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
990 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
991 const char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
992 const char *name
= type_name_no_tag (type
);
993 int is_constructor
= name
&& strcmp (method_name
,
996 for (j
= 0; j
< len2
; j
++)
998 const char *mangled_name
;
999 char *demangled_name
;
1000 struct cleanup
*inner_cleanup
;
1001 const char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1002 int is_full_physname_constructor
=
1003 is_constructor_name (physname
)
1004 || is_destructor_name (physname
)
1005 || method_name
[0] == '~';
1007 /* Do not print out artificial methods. */
1008 if (TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
1011 inner_cleanup
= make_cleanup (null_cleanup
, NULL
);
1014 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
1016 if (section_type
!= s_protected
)
1018 section_type
= s_protected
;
1019 fprintfi_filtered (level
+ 2, stream
,
1023 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
1025 if (section_type
!= s_private
)
1027 section_type
= s_private
;
1028 fprintfi_filtered (level
+ 2, stream
,
1034 if (section_type
!= s_public
)
1036 section_type
= s_public
;
1037 fprintfi_filtered (level
+ 2, stream
,
1042 print_spaces_filtered (level
+ 4, stream
);
1043 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1044 fprintf_filtered (stream
, "virtual ");
1045 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
1046 fprintf_filtered (stream
, "static ");
1047 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
1049 /* Keep GDB from crashing here. */
1050 fprintf_filtered (stream
,
1051 _("<undefined type> %s;\n"),
1052 TYPE_FN_FIELD_PHYSNAME (f
, j
));
1055 else if (!is_constructor
/* Constructors don't
1058 && !is_full_physname_constructor
/* " " */
1059 && !is_type_conversion_operator (type
, i
, j
))
1061 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
1063 fputs_filtered (" ", stream
);
1065 if (TYPE_FN_FIELD_STUB (f
, j
))
1069 /* Build something we can demangle. */
1070 tem
= gdb_mangle_name (type
, i
, j
);
1071 make_cleanup (xfree
, tem
);
1075 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1078 cplus_demangle (mangled_name
,
1079 DMGL_ANSI
| DMGL_PARAMS
);
1080 if (demangled_name
== NULL
)
1082 /* In some cases (for instance with the HP
1083 demangling), if a function has more than 10
1084 arguments, the demangling will fail.
1085 Let's try to reconstruct the function
1086 signature from the symbol information. */
1087 if (!TYPE_FN_FIELD_STUB (f
, j
))
1089 int staticp
= TYPE_FN_FIELD_STATIC_P (f
, j
);
1090 struct type
*mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1092 cp_type_print_method_args (mtype
,
1099 fprintf_filtered (stream
,
1100 _("<badly mangled name '%s'>"),
1106 char *demangled_no_class
1107 = remove_qualifiers (demangled_name
);
1109 /* Get rid of the `static' appended by the
1111 p
= strstr (demangled_no_class
, " static");
1114 int length
= p
- demangled_no_class
;
1115 char *demangled_no_static
;
1118 = (char *) xmalloc (length
+ 1);
1119 strncpy (demangled_no_static
,
1120 demangled_no_class
, length
);
1121 *(demangled_no_static
+ length
) = '\0';
1122 fputs_filtered (demangled_no_static
, stream
);
1123 xfree (demangled_no_static
);
1126 fputs_filtered (demangled_no_class
, stream
);
1127 xfree (demangled_name
);
1130 do_cleanups (inner_cleanup
);
1132 fprintf_filtered (stream
, ";\n");
1136 /* Print typedefs defined in this class. */
1138 if (TYPE_TYPEDEF_FIELD_COUNT (type
) != 0)
1140 if (TYPE_NFIELDS (type
) != 0 || TYPE_NFN_FIELDS (type
) != 0)
1141 fprintf_filtered (stream
, "\n");
1143 for (i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (type
); i
++)
1145 struct type
*target
= TYPE_TYPEDEF_FIELD_TYPE (type
, i
);
1147 /* Dereference the typedef declaration itself. */
1148 gdb_assert (TYPE_CODE (target
) == TYPE_CODE_TYPEDEF
);
1149 target
= TYPE_TARGET_TYPE (target
);
1151 print_spaces_filtered (level
+ 4, stream
);
1152 fprintf_filtered (stream
, "typedef ");
1153 c_print_type (target
, TYPE_TYPEDEF_FIELD_NAME (type
, i
),
1154 stream
, show
- 1, level
+ 4, flags
);
1155 fprintf_filtered (stream
, ";\n");
1159 fprintfi_filtered (level
, stream
, "}");
1161 if (TYPE_LOCALTYPE_PTR (type
) && show
>= 0)
1162 fprintfi_filtered (level
,
1163 stream
, _(" (Local at %s:%d)\n"),
1164 TYPE_LOCALTYPE_FILE (type
),
1165 TYPE_LOCALTYPE_LINE (type
));
1169 case TYPE_CODE_ENUM
:
1170 c_type_print_modifier (type
, stream
, 0, 1);
1171 fprintf_filtered (stream
, "enum ");
1172 /* Print the tag name if it exists.
1173 The aCC compiler emits a spurious
1174 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1175 tag for unnamed struct/union/enum's, which we don't
1177 if (TYPE_TAG_NAME (type
) != NULL
1178 && strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
1180 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1182 fputs_filtered (" ", stream
);
1188 /* If we just printed a tag name, no need to print anything
1190 if (TYPE_TAG_NAME (type
) == NULL
)
1191 fprintf_filtered (stream
, "{...}");
1193 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1195 LONGEST lastval
= 0;
1197 fprintf_filtered (stream
, "{");
1198 len
= TYPE_NFIELDS (type
);
1199 for (i
= 0; i
< len
; i
++)
1203 fprintf_filtered (stream
, ", ");
1205 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1206 if (lastval
!= TYPE_FIELD_ENUMVAL (type
, i
))
1208 fprintf_filtered (stream
, " = %s",
1209 plongest (TYPE_FIELD_ENUMVAL (type
, i
)));
1210 lastval
= TYPE_FIELD_ENUMVAL (type
, i
);
1214 fprintf_filtered (stream
, "}");
1218 case TYPE_CODE_VOID
:
1219 fprintf_filtered (stream
, "void");
1222 case TYPE_CODE_UNDEF
:
1223 fprintf_filtered (stream
, _("struct <unknown>"));
1226 case TYPE_CODE_ERROR
:
1227 fprintf_filtered (stream
, "%s", TYPE_ERROR_NAME (type
));
1230 case TYPE_CODE_RANGE
:
1231 /* This should not occur. */
1232 fprintf_filtered (stream
, _("<range type>"));
1235 case TYPE_CODE_NAMESPACE
:
1236 fputs_filtered ("namespace ", stream
);
1237 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1241 /* Handle types not explicitly handled by the other cases, such
1242 as fundamental types. For these, just print whatever the
1243 type name is, as recorded in the type itself. If there is no
1244 type name, then complain. */
1245 if (TYPE_NAME (type
) != NULL
)
1247 c_type_print_modifier (type
, stream
, 0, 1);
1248 fputs_filtered (TYPE_NAME (type
), stream
);
1252 /* At least for dump_symtab, it is important that this not
1254 fprintf_filtered (stream
, _("<invalid type code %d>"),