1 /* Support for printing C and C++ types for GDB, the GNU debugger.
2 Copyright (C) 1986-2019 Free Software Foundation, Inc.
4 This file is part of GDB.
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3 of the License, or
9 (at your option) any later version.
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 /* Local non-gdb includes. */
24 #include "cli/cli-style.h"
26 #include "cp-support.h"
28 #include "expression.h"
29 #include "gdb_obstack.h"
35 #include "typeprint.h"
38 /* A list of access specifiers used for printing. */
48 static void c_type_print_varspec_suffix (struct type
*, struct ui_file
*, int,
51 const struct type_print_options
*);
53 static void c_type_print_varspec_prefix (struct type
*,
57 const struct type_print_options
*,
58 struct print_offset_data
*);
60 /* Print "const", "volatile", or address space modifiers. */
61 static void c_type_print_modifier (struct type
*,
65 static void c_type_print_base_1 (struct type
*type
, struct ui_file
*stream
,
66 int show
, int level
, enum language language
,
67 const struct type_print_options
*flags
,
68 struct print_offset_data
*podata
);
71 /* A callback function for cp_canonicalize_string_full that uses
72 typedef_hash_table::find_typedef. */
75 find_typedef_for_canonicalize (struct type
*t
, void *data
)
77 return typedef_hash_table::find_typedef
78 ((const struct type_print_options
*) data
, t
);
81 /* Print NAME on STREAM. If the 'raw' field of FLAGS is not set,
82 canonicalize NAME using the local typedefs first. */
85 print_name_maybe_canonical (const char *name
,
86 const struct type_print_options
*flags
,
87 struct ui_file
*stream
)
92 s
= cp_canonicalize_string_full (name
,
93 find_typedef_for_canonicalize
,
96 fputs_filtered (!s
.empty () ? s
.c_str () : name
, stream
);
101 /* Helper function for c_print_type. */
104 c_print_type_1 (struct type
*type
,
105 const char *varstring
,
106 struct ui_file
*stream
,
108 enum language language
,
109 const struct type_print_options
*flags
,
110 struct print_offset_data
*podata
)
115 const char *local_name
;
118 type
= check_typedef (type
);
120 local_name
= typedef_hash_table::find_typedef (flags
, type
);
121 code
= TYPE_CODE (type
);
122 if (local_name
!= NULL
)
124 fputs_filtered (local_name
, stream
);
125 if (varstring
!= NULL
&& *varstring
!= '\0')
126 fputs_filtered (" ", stream
);
130 c_type_print_base_1 (type
, stream
, show
, level
, language
, flags
, podata
);
131 if ((varstring
!= NULL
&& *varstring
!= '\0')
132 /* Need a space if going to print stars or brackets;
133 but not if we will print just a type name. */
134 || ((show
> 0 || TYPE_NAME (type
) == 0)
135 && (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
136 || code
== TYPE_CODE_METHOD
137 || (code
== TYPE_CODE_ARRAY
138 && !TYPE_VECTOR (type
))
139 || code
== TYPE_CODE_MEMBERPTR
140 || code
== TYPE_CODE_METHODPTR
141 || TYPE_IS_REFERENCE (type
))))
142 fputs_filtered (" ", stream
);
143 need_post_space
= (varstring
!= NULL
&& strcmp (varstring
, "") != 0);
144 c_type_print_varspec_prefix (type
, stream
, show
, 0, need_post_space
,
145 language
, flags
, podata
);
148 if (varstring
!= NULL
)
150 if (code
== TYPE_CODE_FUNC
|| code
== TYPE_CODE_METHOD
)
151 fputs_styled (varstring
, function_name_style
.style (), stream
);
153 fputs_filtered (varstring
, stream
);
155 /* For demangled function names, we have the arglist as part of
156 the name, so don't print an additional pair of ()'s. */
157 if (local_name
== NULL
)
159 demangled_args
= strchr (varstring
, '(') != NULL
;
160 c_type_print_varspec_suffix (type
, stream
, show
,
167 /* LEVEL is the depth to indent lines by. */
170 c_print_type (struct type
*type
,
171 const char *varstring
,
172 struct ui_file
*stream
,
174 const struct type_print_options
*flags
)
176 struct print_offset_data podata
;
178 c_print_type_1 (type
, varstring
, stream
, show
, level
,
179 current_language
->la_language
, flags
, &podata
);
186 c_print_type (struct type
*type
,
187 const char *varstring
,
188 struct ui_file
*stream
,
190 enum language language
,
191 const struct type_print_options
*flags
)
193 struct print_offset_data podata
;
195 c_print_type_1 (type
, varstring
, stream
, show
, level
, language
, flags
,
199 /* Print a typedef using C syntax. TYPE is the underlying type.
200 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
204 c_print_typedef (struct type
*type
,
205 struct symbol
*new_symbol
,
206 struct ui_file
*stream
)
208 type
= check_typedef (type
);
209 fprintf_filtered (stream
, "typedef ");
210 type_print (type
, "", stream
, 0);
211 if (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))) == 0
212 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))),
213 SYMBOL_LINKAGE_NAME (new_symbol
)) != 0
214 || TYPE_CODE (SYMBOL_TYPE (new_symbol
)) == TYPE_CODE_TYPEDEF
)
215 fprintf_filtered (stream
, " %s", SYMBOL_PRINT_NAME (new_symbol
));
216 fprintf_filtered (stream
, ";\n");
219 /* If TYPE is a derived type, then print out derivation information.
220 Print only the actual base classes of this type, not the base
221 classes of the base classes. I.e. for the derivation hierarchy:
224 class B : public A {int b; };
225 class C : public B {int c; };
227 Print the type of class C as:
233 Not as the following (like gdb used to), which is not legal C++
234 syntax for derived types and may be confused with the multiple
237 class C : public B : public A {
241 In general, gdb should try to print the types as closely as
242 possible to the form that they appear in the source code. */
245 cp_type_print_derivation_info (struct ui_file
*stream
,
247 const struct type_print_options
*flags
)
252 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
255 fputs_filtered (i
== 0 ? ": " : ", ", stream
);
256 fprintf_filtered (stream
, "%s%s ",
257 BASETYPE_VIA_PUBLIC (type
, i
)
258 ? "public" : (TYPE_FIELD_PROTECTED (type
, i
)
259 ? "protected" : "private"),
260 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
261 name
= TYPE_NAME (TYPE_BASECLASS (type
, i
));
263 print_name_maybe_canonical (name
, flags
, stream
);
265 fprintf_filtered (stream
, "(null)");
269 fputs_filtered (" ", stream
);
273 /* Print the C++ method arguments ARGS to the file STREAM. */
276 cp_type_print_method_args (struct type
*mtype
, const char *prefix
,
277 const char *varstring
, int staticp
,
278 struct ui_file
*stream
,
279 enum language language
,
280 const struct type_print_options
*flags
)
282 struct field
*args
= TYPE_FIELDS (mtype
);
283 int nargs
= TYPE_NFIELDS (mtype
);
284 int varargs
= TYPE_VARARGS (mtype
);
287 fprintf_symbol_filtered (stream
, prefix
,
288 language_cplus
, DMGL_ANSI
);
289 fprintf_symbol_filtered (stream
, varstring
,
290 language_cplus
, DMGL_ANSI
);
291 fputs_filtered ("(", stream
);
293 /* Skip the class variable. We keep this here to accommodate older
294 compilers and debug formats which may not support artificial
301 struct field arg
= args
[i
++];
303 /* Skip any artificial arguments. */
304 if (FIELD_ARTIFICIAL (arg
))
307 c_print_type (arg
.type
, "", stream
, 0, 0, flags
);
309 if (i
== nargs
&& varargs
)
310 fprintf_filtered (stream
, ", ...");
313 fprintf_filtered (stream
, ", ");
319 fprintf_filtered (stream
, "...");
320 else if (language
== language_cplus
)
321 fprintf_filtered (stream
, "void");
323 fprintf_filtered (stream
, ")");
325 /* For non-static methods, read qualifiers from the type of
331 gdb_assert (nargs
> 0);
332 gdb_assert (TYPE_CODE (args
[0].type
) == TYPE_CODE_PTR
);
333 domain
= TYPE_TARGET_TYPE (args
[0].type
);
335 if (TYPE_CONST (domain
))
336 fprintf_filtered (stream
, " const");
338 if (TYPE_VOLATILE (domain
))
339 fprintf_filtered (stream
, " volatile");
341 if (TYPE_RESTRICT (domain
))
342 fprintf_filtered (stream
, " restrict");
344 if (TYPE_ATOMIC (domain
))
345 fprintf_filtered (stream
, " _Atomic");
350 /* Print any asterisks or open-parentheses needed before the
351 variable name (to describe its type).
353 On outermost call, pass 0 for PASSED_A_PTR.
354 On outermost call, SHOW > 0 means should ignore
355 any typename for TYPE and show its details.
356 SHOW is always zero on recursive calls.
358 NEED_POST_SPACE is non-zero when a space will be be needed
359 between a trailing qualifier and a field, variable, or function
363 c_type_print_varspec_prefix (struct type
*type
,
364 struct ui_file
*stream
,
365 int show
, int passed_a_ptr
,
367 enum language language
,
368 const struct type_print_options
*flags
,
369 struct print_offset_data
*podata
)
376 if (TYPE_NAME (type
) && show
<= 0)
381 switch (TYPE_CODE (type
))
384 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
385 stream
, show
, 1, 1, language
, flags
,
387 fprintf_filtered (stream
, "*");
388 c_type_print_modifier (type
, stream
, 1, need_post_space
);
391 case TYPE_CODE_MEMBERPTR
:
392 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
393 stream
, show
, 0, 0, language
, flags
, podata
);
394 name
= TYPE_NAME (TYPE_SELF_TYPE (type
));
396 print_name_maybe_canonical (name
, flags
, stream
);
398 c_type_print_base_1 (TYPE_SELF_TYPE (type
),
399 stream
, -1, passed_a_ptr
, language
, flags
,
401 fprintf_filtered (stream
, "::*");
404 case TYPE_CODE_METHODPTR
:
405 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
406 stream
, show
, 0, 0, language
, flags
,
408 fprintf_filtered (stream
, "(");
409 name
= TYPE_NAME (TYPE_SELF_TYPE (type
));
411 print_name_maybe_canonical (name
, flags
, stream
);
413 c_type_print_base_1 (TYPE_SELF_TYPE (type
),
414 stream
, -1, passed_a_ptr
, language
, flags
,
416 fprintf_filtered (stream
, "::*");
420 case TYPE_CODE_RVALUE_REF
:
421 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
422 stream
, show
, 1, 0, language
, flags
,
424 fprintf_filtered (stream
, TYPE_CODE(type
) == TYPE_CODE_REF
? "&" : "&&");
425 c_type_print_modifier (type
, stream
, 1, need_post_space
);
428 case TYPE_CODE_METHOD
:
430 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
431 stream
, show
, 0, 0, language
, flags
,
434 fprintf_filtered (stream
, "(");
437 case TYPE_CODE_ARRAY
:
438 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
439 stream
, show
, 0, 0, language
, flags
,
442 fprintf_filtered (stream
, "(");
445 case TYPE_CODE_TYPEDEF
:
446 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
447 stream
, show
, passed_a_ptr
, 0,
448 language
, flags
, podata
);
451 case TYPE_CODE_UNDEF
:
452 case TYPE_CODE_STRUCT
:
453 case TYPE_CODE_UNION
:
455 case TYPE_CODE_FLAGS
:
459 case TYPE_CODE_ERROR
:
463 case TYPE_CODE_RANGE
:
464 case TYPE_CODE_STRING
:
465 case TYPE_CODE_COMPLEX
:
466 case TYPE_CODE_NAMESPACE
:
467 case TYPE_CODE_DECFLOAT
:
468 /* These types need no prefix. They are listed here so that
469 gcc -Wall will reveal any types that haven't been handled. */
472 error (_("type not handled in c_type_print_varspec_prefix()"));
477 /* Print out "const" and "volatile" attributes,
478 and address space id if present.
479 TYPE is a pointer to the type being printed out.
480 STREAM is the output destination.
481 NEED_PRE_SPACE = 1 indicates an initial white space is needed.
482 NEED_POST_SPACE = 1 indicates a final white space is needed. */
485 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
486 int need_pre_space
, int need_post_space
)
488 int did_print_modifier
= 0;
489 const char *address_space_id
;
491 /* We don't print `const' qualifiers for references --- since all
492 operators affect the thing referenced, not the reference itself,
493 every reference is `const'. */
494 if (TYPE_CONST (type
) && !TYPE_IS_REFERENCE (type
))
497 fprintf_filtered (stream
, " ");
498 fprintf_filtered (stream
, "const");
499 did_print_modifier
= 1;
502 if (TYPE_VOLATILE (type
))
504 if (did_print_modifier
|| need_pre_space
)
505 fprintf_filtered (stream
, " ");
506 fprintf_filtered (stream
, "volatile");
507 did_print_modifier
= 1;
510 if (TYPE_RESTRICT (type
))
512 if (did_print_modifier
|| need_pre_space
)
513 fprintf_filtered (stream
, " ");
514 fprintf_filtered (stream
, "restrict");
515 did_print_modifier
= 1;
518 if (TYPE_ATOMIC (type
))
520 if (did_print_modifier
|| need_pre_space
)
521 fprintf_filtered (stream
, " ");
522 fprintf_filtered (stream
, "_Atomic");
523 did_print_modifier
= 1;
526 address_space_id
= address_space_int_to_name (get_type_arch (type
),
527 TYPE_INSTANCE_FLAGS (type
));
528 if (address_space_id
)
530 if (did_print_modifier
|| need_pre_space
)
531 fprintf_filtered (stream
, " ");
532 fprintf_filtered (stream
, "@%s", address_space_id
);
533 did_print_modifier
= 1;
536 if (did_print_modifier
&& need_post_space
)
537 fprintf_filtered (stream
, " ");
541 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
542 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
543 in non-static methods, are displayed if LINKAGE_NAME is zero. If
544 LINKAGE_NAME is non-zero and LANGUAGE is language_cplus the topmost
545 parameter types get removed their possible const and volatile qualifiers to
546 match demangled linkage name parameters part of such function type.
547 LANGUAGE is the language in which TYPE was defined. This is a necessary
548 evil since this code is used by the C and C++. */
551 c_type_print_args (struct type
*type
, struct ui_file
*stream
,
552 int linkage_name
, enum language language
,
553 const struct type_print_options
*flags
)
558 fprintf_filtered (stream
, "(");
560 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
562 struct type
*param_type
;
564 if (TYPE_FIELD_ARTIFICIAL (type
, i
) && linkage_name
)
569 fprintf_filtered (stream
, ", ");
573 param_type
= TYPE_FIELD_TYPE (type
, i
);
575 if (language
== language_cplus
&& linkage_name
)
577 /* C++ standard, 13.1 Overloadable declarations, point 3, item:
578 - Parameter declarations that differ only in the presence or
579 absence of const and/or volatile are equivalent.
581 And the const/volatile qualifiers are not present in the mangled
582 names as produced by GCC. */
584 param_type
= make_cv_type (0, 0, param_type
, NULL
);
587 c_print_type (param_type
, "", stream
, -1, 0, language
, flags
);
591 if (printed_any
&& TYPE_VARARGS (type
))
593 /* Print out a trailing ellipsis for varargs functions. Ignore
594 TYPE_VARARGS if the function has no named arguments; that
595 represents unprototyped (K&R style) C functions. */
596 if (printed_any
&& TYPE_VARARGS (type
))
598 fprintf_filtered (stream
, ", ");
600 fprintf_filtered (stream
, "...");
603 else if (!printed_any
604 && (TYPE_PROTOTYPED (type
) || language
== language_cplus
))
605 fprintf_filtered (stream
, "void");
607 fprintf_filtered (stream
, ")");
610 /* Return true iff the j'th overloading of the i'th method of TYPE
611 is a type conversion operator, like `operator int () { ... }'.
612 When listing a class's methods, we don't print the return type of
616 is_type_conversion_operator (struct type
*type
, int i
, int j
)
618 /* I think the whole idea of recognizing type conversion operators
619 by their name is pretty terrible. But I don't think our present
620 data structure gives us any other way to tell. If you know of
621 some other way, feel free to rewrite this function. */
622 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
624 if (!startswith (name
, CP_OPERATOR_STR
))
628 if (! strchr (" \t\f\n\r", *name
))
631 while (strchr (" \t\f\n\r", *name
))
634 if (!('a' <= *name
&& *name
<= 'z')
635 && !('A' <= *name
&& *name
<= 'Z')
637 /* If this doesn't look like the start of an identifier, then it
638 isn't a type conversion operator. */
640 else if (startswith (name
, "new"))
642 else if (startswith (name
, "delete"))
645 /* If it doesn't look like new or delete, it's a type conversion
649 /* Is that really the end of the name? */
650 if (('a' <= *name
&& *name
<= 'z')
651 || ('A' <= *name
&& *name
<= 'Z')
652 || ('0' <= *name
&& *name
<= '9')
654 /* No, so the identifier following "operator" must be a type name,
655 and this is a type conversion operator. */
658 /* That was indeed the end of the name, so it was `operator new' or
659 `operator delete', neither of which are type conversion
664 /* Given a C++ qualified identifier QID, strip off the qualifiers,
665 yielding the unqualified name. The return value is a pointer into
668 It's a pity we don't have this information in some more structured
669 form. Even the author of this function feels that writing little
670 parsers like this everywhere is stupid. */
673 remove_qualifiers (char *qid
)
675 int quoted
= 0; /* Zero if we're not in quotes;
676 '"' if we're in a double-quoted string;
677 '\'' if we're in a single-quoted string. */
678 int depth
= 0; /* Number of unclosed parens we've seen. */
679 char *parenstack
= (char *) alloca (strlen (qid
));
681 char *last
= 0; /* The character after the rightmost
682 `::' token we've seen so far. */
684 for (scan
= qid
; *scan
; scan
++)
690 else if (*scan
== '\\' && *(scan
+ 1))
693 else if (scan
[0] == ':' && scan
[1] == ':')
695 /* If we're inside parenthesis (i.e., an argument list) or
696 angle brackets (i.e., a list of template arguments), then
697 we don't record the position of this :: token, since it's
698 not relevant to the top-level structure we're trying to
706 else if (*scan
== '"' || *scan
== '\'')
708 else if (*scan
== '(')
709 parenstack
[depth
++] = ')';
710 else if (*scan
== '[')
711 parenstack
[depth
++] = ']';
712 /* We're going to treat <> as a pair of matching characters,
713 since we're more likely to see those in template id's than
714 real less-than characters. What a crock. */
715 else if (*scan
== '<')
716 parenstack
[depth
++] = '>';
717 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
719 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
723 /* We're going to do a little error recovery here. If
724 we don't find a match for *scan on the paren stack,
725 but there is something lower on the stack that does
726 match, we pop the stack to that point. */
729 for (i
= depth
- 1; i
>= 0; i
--)
730 if (parenstack
[i
] == *scan
)
742 /* We didn't find any :: tokens at the top level, so declare the
743 whole thing an unqualified identifier. */
747 /* Print any array sizes, function arguments or close parentheses
748 needed after the variable name (to describe its type).
749 Args work like c_type_print_varspec_prefix. */
752 c_type_print_varspec_suffix (struct type
*type
,
753 struct ui_file
*stream
,
754 int show
, int passed_a_ptr
,
756 enum language language
,
757 const struct type_print_options
*flags
)
762 if (TYPE_NAME (type
) && show
<= 0)
767 switch (TYPE_CODE (type
))
769 case TYPE_CODE_ARRAY
:
771 LONGEST low_bound
, high_bound
;
772 int is_vector
= TYPE_VECTOR (type
);
775 fprintf_filtered (stream
, ")");
777 fprintf_filtered (stream
, (is_vector
?
778 " __attribute__ ((vector_size(" : "["));
779 /* Bounds are not yet resolved, print a bounds placeholder instead. */
780 if (TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type
)) == PROP_LOCEXPR
781 || TYPE_HIGH_BOUND_KIND (TYPE_INDEX_TYPE (type
)) == PROP_LOCLIST
)
782 fprintf_filtered (stream
, "variable length");
783 else if (get_array_bounds (type
, &low_bound
, &high_bound
))
784 fprintf_filtered (stream
, "%s",
785 plongest (high_bound
- low_bound
+ 1));
786 fprintf_filtered (stream
, (is_vector
? ")))" : "]"));
788 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
789 show
, 0, 0, language
, flags
);
793 case TYPE_CODE_MEMBERPTR
:
794 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
795 show
, 0, 0, language
, flags
);
798 case TYPE_CODE_METHODPTR
:
799 fprintf_filtered (stream
, ")");
800 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
801 show
, 0, 0, language
, flags
);
806 case TYPE_CODE_RVALUE_REF
:
807 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
808 show
, 1, 0, language
, flags
);
811 case TYPE_CODE_METHOD
:
814 fprintf_filtered (stream
, ")");
816 c_type_print_args (type
, stream
, 0, language
, flags
);
817 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
818 show
, passed_a_ptr
, 0, language
, flags
);
821 case TYPE_CODE_TYPEDEF
:
822 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
823 show
, passed_a_ptr
, 0, language
, flags
);
826 case TYPE_CODE_UNDEF
:
827 case TYPE_CODE_STRUCT
:
828 case TYPE_CODE_UNION
:
829 case TYPE_CODE_FLAGS
:
834 case TYPE_CODE_ERROR
:
838 case TYPE_CODE_RANGE
:
839 case TYPE_CODE_STRING
:
840 case TYPE_CODE_COMPLEX
:
841 case TYPE_CODE_NAMESPACE
:
842 case TYPE_CODE_DECFLOAT
:
843 /* These types do not need a suffix. They are listed so that
844 gcc -Wall will report types that may not have been
848 error (_("type not handled in c_type_print_varspec_suffix()"));
853 /* A helper for c_type_print_base that displays template
854 parameters and their bindings, if needed.
856 TABLE is the local bindings table to use. If NULL, no printing is
857 done. Note that, at this point, TABLE won't have any useful
858 information in it -- but it is also used as a flag to
859 print_name_maybe_canonical to activate searching the global typedef
862 TYPE is the type whose template arguments are being displayed.
864 STREAM is the stream on which to print. */
867 c_type_print_template_args (const struct type_print_options
*flags
,
868 struct type
*type
, struct ui_file
*stream
)
875 for (i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
877 struct symbol
*sym
= TYPE_TEMPLATE_ARGUMENT (type
, i
);
879 if (SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
885 fprintf_filtered (stream
, _("[with %s = "),
886 SYMBOL_LINKAGE_NAME (sym
));
891 fputs_filtered (", ", stream
);
893 fprintf_filtered (stream
, "%s = ", SYMBOL_LINKAGE_NAME (sym
));
896 c_print_type (SYMBOL_TYPE (sym
), "", stream
, -1, 0, flags
);
900 fputs_filtered (_("] "), stream
);
903 /* Use 'print_spaces_filtered', but take into consideration the
904 type_print_options FLAGS in order to determine how many whitespaces
908 print_spaces_filtered_with_print_options
909 (int level
, struct ui_file
*stream
, const struct type_print_options
*flags
)
911 if (!flags
->print_offsets
)
912 print_spaces_filtered (level
, stream
);
914 print_spaces_filtered (level
+ print_offset_data::indentation
, stream
);
917 /* Output an access specifier to STREAM, if needed. LAST_ACCESS is the
918 last access specifier output (typically returned by this function). */
920 static enum access_specifier
921 output_access_specifier (struct ui_file
*stream
,
922 enum access_specifier last_access
,
923 int level
, bool is_protected
, bool is_private
,
924 const struct type_print_options
*flags
)
928 if (last_access
!= s_protected
)
930 last_access
= s_protected
;
931 print_spaces_filtered_with_print_options (level
+ 2, stream
, flags
);
932 fprintf_filtered (stream
, "protected:\n");
937 if (last_access
!= s_private
)
939 last_access
= s_private
;
940 print_spaces_filtered_with_print_options (level
+ 2, stream
, flags
);
941 fprintf_filtered (stream
, "private:\n");
946 if (last_access
!= s_public
)
948 last_access
= s_public
;
949 print_spaces_filtered_with_print_options (level
+ 2, stream
, flags
);
950 fprintf_filtered (stream
, "public:\n");
957 /* Return true if an access label (i.e., "public:", "private:",
958 "protected:") needs to be printed for TYPE. */
961 need_access_label_p (struct type
*type
)
963 if (TYPE_DECLARED_CLASS (type
))
966 for (int i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
967 if (!TYPE_FIELD_PRIVATE (type
, i
))
970 for (int j
= 0; j
< TYPE_NFN_FIELDS (type
); j
++)
971 for (int i
= 0; i
< TYPE_FN_FIELDLIST_LENGTH (type
, j
); i
++)
972 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
,
976 for (int i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (type
); ++i
)
977 if (!TYPE_TYPEDEF_FIELD_PRIVATE (type
, i
))
983 for (int i
= TYPE_N_BASECLASSES (type
); i
< TYPE_NFIELDS (type
); i
++)
984 if (TYPE_FIELD_PRIVATE (type
, i
) || TYPE_FIELD_PROTECTED (type
, i
))
987 for (int j
= 0; j
< TYPE_NFN_FIELDS (type
); j
++)
990 for (int i
= 0; i
< TYPE_FN_FIELDLIST_LENGTH (type
, j
); i
++)
991 if (TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
,
993 || TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
,
999 for (int i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (type
); ++i
)
1000 if (TYPE_TYPEDEF_FIELD_PROTECTED (type
, i
)
1001 || TYPE_TYPEDEF_FIELD_PRIVATE (type
, i
))
1008 /* Helper function that temporarily disables FLAGS->PRINT_OFFSETS,
1009 calls 'c_print_type_1', and then reenables FLAGS->PRINT_OFFSETS if
1013 c_print_type_no_offsets (struct type
*type
,
1014 const char *varstring
,
1015 struct ui_file
*stream
,
1016 int show
, int level
,
1017 enum language language
,
1018 struct type_print_options
*flags
,
1019 struct print_offset_data
*podata
)
1021 unsigned int old_po
= flags
->print_offsets
;
1023 /* Temporarily disable print_offsets, because it would mess with
1025 flags
->print_offsets
= 0;
1026 c_print_type_1 (type
, varstring
, stream
, show
, level
, language
, flags
,
1028 flags
->print_offsets
= old_po
;
1031 /* Helper for 'c_type_print_base' that handles structs and unions.
1032 For a description of the arguments, see 'c_type_print_base'. */
1035 c_type_print_base_struct_union (struct type
*type
, struct ui_file
*stream
,
1036 int show
, int level
,
1037 enum language language
,
1038 const struct type_print_options
*flags
,
1039 struct print_offset_data
*podata
)
1041 struct type_print_options local_flags
= *flags
;
1042 local_flags
.local_typedefs
= NULL
;
1044 std::unique_ptr
<typedef_hash_table
> hash_holder
;
1047 if (flags
->local_typedefs
)
1048 local_flags
.local_typedefs
1049 = new typedef_hash_table (*flags
->local_typedefs
);
1051 local_flags
.local_typedefs
= new typedef_hash_table ();
1053 hash_holder
.reset (local_flags
.local_typedefs
);
1056 c_type_print_modifier (type
, stream
, 0, 1);
1057 if (TYPE_CODE (type
) == TYPE_CODE_UNION
)
1058 fprintf_filtered (stream
, "union ");
1059 else if (TYPE_DECLARED_CLASS (type
))
1060 fprintf_filtered (stream
, "class ");
1062 fprintf_filtered (stream
, "struct ");
1064 /* Print the tag if it exists. The HP aCC compiler emits a
1065 spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
1066 enum}" tag for unnamed struct/union/enum's, which we don't
1068 if (TYPE_NAME (type
) != NULL
1069 && !startswith (TYPE_NAME (type
), "{unnamed"))
1071 /* When printing the tag name, we are still effectively
1072 printing in the outer context, hence the use of FLAGS
1074 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
1076 fputs_filtered (" ", stream
);
1081 /* If we just printed a tag name, no need to print anything
1083 if (TYPE_NAME (type
) == NULL
)
1084 fprintf_filtered (stream
, "{...}");
1086 else if (show
> 0 || TYPE_NAME (type
) == NULL
)
1088 struct type
*basetype
;
1091 c_type_print_template_args (&local_flags
, type
, stream
);
1093 /* Add in template parameters when printing derivation info. */
1094 if (local_flags
.local_typedefs
!= NULL
)
1095 local_flags
.local_typedefs
->add_template_parameters (type
);
1096 cp_type_print_derivation_info (stream
, type
, &local_flags
);
1098 /* This holds just the global typedefs and the template
1100 struct type_print_options semi_local_flags
= *flags
;
1101 semi_local_flags
.local_typedefs
= NULL
;
1103 std::unique_ptr
<typedef_hash_table
> semi_holder
;
1104 if (local_flags
.local_typedefs
!= nullptr)
1106 semi_local_flags
.local_typedefs
1107 = new typedef_hash_table (*local_flags
.local_typedefs
);
1108 semi_holder
.reset (semi_local_flags
.local_typedefs
);
1110 /* Now add in the local typedefs. */
1111 local_flags
.local_typedefs
->recursively_update (type
);
1114 fprintf_filtered (stream
, "{\n");
1116 if (TYPE_NFIELDS (type
) == 0 && TYPE_NFN_FIELDS (type
) == 0
1117 && TYPE_TYPEDEF_FIELD_COUNT (type
) == 0)
1119 if (TYPE_STUB (type
))
1120 fprintfi_filtered (level
+ 4, stream
,
1121 _("<incomplete type>\n"));
1123 fprintfi_filtered (level
+ 4, stream
,
1124 _("<no data fields>\n"));
1127 /* Start off with no specific section type, so we can print
1128 one for the first field we find, and use that section type
1129 thereafter until we find another type. */
1131 enum access_specifier section_type
= s_none
;
1133 /* For a class, if all members are private, there's no need
1134 for a "private:" label; similarly, for a struct or union
1135 masquerading as a class, if all members are public, there's
1136 no need for a "public:" label. */
1137 bool need_access_label
= need_access_label_p (type
);
1139 /* If there is a base class for this type,
1140 do not print the field that it occupies. */
1142 int len
= TYPE_NFIELDS (type
);
1143 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
1145 struct print_offset_data local_podata
;
1147 for (int i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
1151 /* If we have a virtual table pointer, omit it. Even if
1152 virtual table pointers are not specifically marked in
1153 the debug info, they should be artificial. */
1154 if ((i
== vptr_fieldno
&& type
== basetype
)
1155 || TYPE_FIELD_ARTIFICIAL (type
, i
))
1158 if (need_access_label
)
1160 section_type
= output_access_specifier
1161 (stream
, section_type
, level
,
1162 TYPE_FIELD_PROTECTED (type
, i
),
1163 TYPE_FIELD_PRIVATE (type
, i
), flags
);
1166 bool is_static
= field_is_static (&TYPE_FIELD (type
, i
));
1168 if (flags
->print_offsets
)
1169 podata
->update (type
, i
, stream
);
1171 print_spaces_filtered (level
+ 4, stream
);
1173 fprintf_filtered (stream
, "static ");
1175 int newshow
= show
- 1;
1177 if (!is_static
&& flags
->print_offsets
1178 && (TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_STRUCT
1179 || TYPE_CODE (TYPE_FIELD_TYPE (type
, i
)) == TYPE_CODE_UNION
))
1181 /* If we're printing offsets and this field's type is
1182 either a struct or an union, then we're interested in
1186 /* Make sure we carry our offset when we expand the
1188 local_podata
.offset_bitpos
1189 = podata
->offset_bitpos
+ TYPE_FIELD_BITPOS (type
, i
);
1190 /* We're entering a struct/union. Right now,
1191 PODATA->END_BITPOS points right *after* the
1192 struct/union. However, when printing the first field
1193 of this inner struct/union, the end_bitpos we're
1194 expecting is exactly at the beginning of the
1195 struct/union. Therefore, we subtract the length of
1196 the whole struct/union. */
1197 local_podata
.end_bitpos
1198 = podata
->end_bitpos
1199 - TYPE_LENGTH (TYPE_FIELD_TYPE (type
, i
)) * TARGET_CHAR_BIT
;
1202 c_print_type_1 (TYPE_FIELD_TYPE (type
, i
),
1203 TYPE_FIELD_NAME (type
, i
),
1204 stream
, newshow
, level
+ 4,
1205 language
, &local_flags
, &local_podata
);
1207 if (!is_static
&& TYPE_FIELD_PACKED (type
, i
))
1209 /* It is a bitfield. This code does not attempt
1210 to look at the bitpos and reconstruct filler,
1211 unnamed fields. This would lead to misleading
1212 results if the compiler does not put out fields
1213 for such things (I don't know what it does). */
1214 fprintf_filtered (stream
, " : %d",
1215 TYPE_FIELD_BITSIZE (type
, i
));
1217 fprintf_filtered (stream
, ";\n");
1220 /* If there are both fields and methods, put a blank line
1221 between them. Make sure to count only method that we
1222 will display; artificial methods will be hidden. */
1223 len
= TYPE_NFN_FIELDS (type
);
1224 if (!flags
->print_methods
)
1227 for (int i
= 0; i
< len
; i
++)
1229 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1230 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
1233 for (j
= 0; j
< len2
; j
++)
1234 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
1237 if (real_len
> 0 && section_type
!= s_none
)
1238 fprintf_filtered (stream
, "\n");
1240 /* C++: print out the methods. */
1241 for (int i
= 0; i
< len
; i
++)
1243 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1244 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
1245 const char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1246 const char *name
= TYPE_NAME (type
);
1247 int is_constructor
= name
&& strcmp (method_name
,
1250 for (j
= 0; j
< len2
; j
++)
1252 const char *mangled_name
;
1253 gdb::unique_xmalloc_ptr
<char> mangled_name_holder
;
1254 char *demangled_name
;
1255 const char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1256 int is_full_physname_constructor
=
1257 TYPE_FN_FIELD_CONSTRUCTOR (f
, j
)
1258 || is_constructor_name (physname
)
1259 || is_destructor_name (physname
)
1260 || method_name
[0] == '~';
1262 /* Do not print out artificial methods. */
1263 if (TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
1267 section_type
= output_access_specifier
1268 (stream
, section_type
, level
,
1269 TYPE_FN_FIELD_PROTECTED (f
, j
),
1270 TYPE_FN_FIELD_PRIVATE (f
, j
), flags
);
1272 print_spaces_filtered_with_print_options (level
+ 4, stream
,
1274 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1275 fprintf_filtered (stream
, "virtual ");
1276 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
1277 fprintf_filtered (stream
, "static ");
1278 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
1280 /* Keep GDB from crashing here. */
1281 fprintf_filtered (stream
,
1282 _("<undefined type> %s;\n"),
1283 TYPE_FN_FIELD_PHYSNAME (f
, j
));
1286 else if (!is_constructor
/* Constructors don't
1289 && !is_full_physname_constructor
/* " " */
1290 && !is_type_conversion_operator (type
, i
, j
))
1292 c_print_type_no_offsets
1293 (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
1294 "", stream
, -1, 0, language
, &local_flags
, podata
);
1296 fputs_filtered (" ", stream
);
1298 if (TYPE_FN_FIELD_STUB (f
, j
))
1300 /* Build something we can demangle. */
1301 mangled_name_holder
.reset (gdb_mangle_name (type
, i
, j
));
1302 mangled_name
= mangled_name_holder
.get ();
1305 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1308 gdb_demangle (mangled_name
,
1309 DMGL_ANSI
| DMGL_PARAMS
);
1310 if (demangled_name
== NULL
)
1312 /* In some cases (for instance with the HP
1313 demangling), if a function has more than 10
1314 arguments, the demangling will fail.
1315 Let's try to reconstruct the function
1316 signature from the symbol information. */
1317 if (!TYPE_FN_FIELD_STUB (f
, j
))
1319 int staticp
= TYPE_FN_FIELD_STATIC_P (f
, j
);
1320 struct type
*mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1322 cp_type_print_method_args (mtype
,
1330 fprintf_filtered (stream
,
1331 _("<badly mangled name '%s'>"),
1337 char *demangled_no_class
1338 = remove_qualifiers (demangled_name
);
1340 /* Get rid of the `static' appended by the
1342 p
= strstr (demangled_no_class
, " static");
1345 int length
= p
- demangled_no_class
;
1346 char *demangled_no_static
;
1349 = (char *) xmalloc (length
+ 1);
1350 strncpy (demangled_no_static
,
1351 demangled_no_class
, length
);
1352 *(demangled_no_static
+ length
) = '\0';
1353 fputs_filtered (demangled_no_static
, stream
);
1354 xfree (demangled_no_static
);
1357 fputs_filtered (demangled_no_class
, stream
);
1358 xfree (demangled_name
);
1361 fprintf_filtered (stream
, ";\n");
1365 /* Print out nested types. */
1366 if (TYPE_NESTED_TYPES_COUNT (type
) != 0
1367 && semi_local_flags
.print_nested_type_limit
!= 0)
1369 if (semi_local_flags
.print_nested_type_limit
> 0)
1370 --semi_local_flags
.print_nested_type_limit
;
1372 if (TYPE_NFIELDS (type
) != 0 || TYPE_NFN_FIELDS (type
) != 0)
1373 fprintf_filtered (stream
, "\n");
1375 for (int i
= 0; i
< TYPE_NESTED_TYPES_COUNT (type
); ++i
)
1377 print_spaces_filtered_with_print_options (level
+ 4, stream
,
1379 c_print_type_no_offsets (TYPE_NESTED_TYPES_FIELD_TYPE (type
, i
),
1380 "", stream
, show
, level
+ 4,
1381 language
, &semi_local_flags
, podata
);
1382 fprintf_filtered (stream
, ";\n");
1386 /* Print typedefs defined in this class. */
1388 if (TYPE_TYPEDEF_FIELD_COUNT (type
) != 0 && flags
->print_typedefs
)
1390 if (TYPE_NFIELDS (type
) != 0 || TYPE_NFN_FIELDS (type
) != 0
1391 || TYPE_NESTED_TYPES_COUNT (type
) != 0)
1392 fprintf_filtered (stream
, "\n");
1394 for (int i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (type
); i
++)
1396 struct type
*target
= TYPE_TYPEDEF_FIELD_TYPE (type
, i
);
1398 /* Dereference the typedef declaration itself. */
1399 gdb_assert (TYPE_CODE (target
) == TYPE_CODE_TYPEDEF
);
1400 target
= TYPE_TARGET_TYPE (target
);
1402 if (need_access_label
)
1404 section_type
= output_access_specifier
1405 (stream
, section_type
, level
,
1406 TYPE_TYPEDEF_FIELD_PROTECTED (type
, i
),
1407 TYPE_TYPEDEF_FIELD_PRIVATE (type
, i
), flags
);
1409 print_spaces_filtered_with_print_options (level
+ 4, stream
,
1411 fprintf_filtered (stream
, "typedef ");
1413 /* We want to print typedefs with substitutions
1414 from the template parameters or globally-known
1415 typedefs but not local typedefs. */
1416 c_print_type_no_offsets (target
,
1417 TYPE_TYPEDEF_FIELD_NAME (type
, i
),
1418 stream
, show
- 1, level
+ 4,
1419 language
, &semi_local_flags
, podata
);
1420 fprintf_filtered (stream
, ";\n");
1424 if (flags
->print_offsets
)
1427 podata
->finish (type
, level
, stream
);
1429 print_spaces_filtered (print_offset_data::indentation
, stream
);
1431 print_spaces_filtered (2, stream
);
1434 fprintfi_filtered (level
, stream
, "}");
1438 /* Print the name of the type (or the ultimate pointer target,
1439 function value or array element), or the description of a structure
1442 SHOW positive means print details about the type (e.g. enum
1443 values), and print structure elements passing SHOW - 1 for show.
1445 SHOW negative means just print the type name or struct tag if there
1446 is one. If there is no name, print something sensible but concise
1447 like "struct {...}".
1449 SHOW zero means just print the type name or struct tag if there is
1450 one. If there is no name, print something sensible but not as
1451 concise like "struct {int x; int y;}".
1453 LEVEL is the number of spaces to indent by.
1454 We increase it for some recursive calls. */
1457 c_type_print_base_1 (struct type
*type
, struct ui_file
*stream
,
1458 int show
, int level
,
1459 enum language language
,
1460 const struct type_print_options
*flags
,
1461 struct print_offset_data
*podata
)
1470 fputs_filtered (_("<type unknown>"), stream
);
1474 /* When SHOW is zero or less, and there is a valid type name, then
1475 always just print the type name directly from the type. */
1478 && TYPE_NAME (type
) != NULL
)
1480 c_type_print_modifier (type
, stream
, 0, 1);
1482 /* If we have "typedef struct foo {. . .} bar;" do we want to
1483 print it as "struct foo" or as "bar"? Pick the latter for
1484 C++, because C++ folk tend to expect things like "class5
1485 *foo" rather than "struct class5 *foo". We rather
1486 arbitrarily choose to make language_minimal work in a C-like
1488 if (language
== language_c
|| language
== language_minimal
)
1490 if (TYPE_CODE (type
) == TYPE_CODE_UNION
)
1491 fprintf_filtered (stream
, "union ");
1492 else if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
1494 if (TYPE_DECLARED_CLASS (type
))
1495 fprintf_filtered (stream
, "class ");
1497 fprintf_filtered (stream
, "struct ");
1499 else if (TYPE_CODE (type
) == TYPE_CODE_ENUM
)
1500 fprintf_filtered (stream
, "enum ");
1503 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
1507 type
= check_typedef (type
);
1509 switch (TYPE_CODE (type
))
1511 case TYPE_CODE_TYPEDEF
:
1512 /* If we get here, the typedef doesn't have a name, and we
1513 couldn't resolve TYPE_TARGET_TYPE. Not much we can do. */
1514 gdb_assert (TYPE_NAME (type
) == NULL
);
1515 gdb_assert (TYPE_TARGET_TYPE (type
) == NULL
);
1516 fprintf_filtered (stream
, _("<unnamed typedef>"));
1519 case TYPE_CODE_FUNC
:
1520 case TYPE_CODE_METHOD
:
1521 if (TYPE_TARGET_TYPE (type
) == NULL
)
1522 type_print_unknown_return_type (stream
);
1524 c_type_print_base_1 (TYPE_TARGET_TYPE (type
),
1525 stream
, show
, level
, language
, flags
, podata
);
1527 case TYPE_CODE_ARRAY
:
1529 case TYPE_CODE_MEMBERPTR
:
1531 case TYPE_CODE_RVALUE_REF
:
1532 case TYPE_CODE_METHODPTR
:
1533 c_type_print_base_1 (TYPE_TARGET_TYPE (type
),
1534 stream
, show
, level
, language
, flags
, podata
);
1537 case TYPE_CODE_STRUCT
:
1538 case TYPE_CODE_UNION
:
1539 c_type_print_base_struct_union (type
, stream
, show
, level
,
1540 language
, flags
, podata
);
1543 case TYPE_CODE_ENUM
:
1544 c_type_print_modifier (type
, stream
, 0, 1);
1545 fprintf_filtered (stream
, "enum ");
1546 if (TYPE_DECLARED_CLASS (type
))
1547 fprintf_filtered (stream
, "class ");
1548 /* Print the tag name if it exists.
1549 The aCC compiler emits a spurious
1550 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1551 tag for unnamed struct/union/enum's, which we don't
1553 if (TYPE_NAME (type
) != NULL
1554 && !startswith (TYPE_NAME (type
), "{unnamed"))
1556 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
1558 fputs_filtered (" ", stream
);
1564 /* If we just printed a tag name, no need to print anything
1566 if (TYPE_NAME (type
) == NULL
)
1567 fprintf_filtered (stream
, "{...}");
1569 else if (show
> 0 || TYPE_NAME (type
) == NULL
)
1571 LONGEST lastval
= 0;
1573 /* We can't handle this case perfectly, as DWARF does not
1574 tell us whether or not the underlying type was specified
1575 in the source (and other debug formats don't provide this
1576 at all). We choose to print the underlying type, if it
1577 has a name, when in C++ on the theory that it's better to
1578 print too much than too little; but conversely not to
1579 print something egregiously outside the current
1580 language's syntax. */
1581 if (language
== language_cplus
&& TYPE_TARGET_TYPE (type
) != NULL
)
1583 struct type
*underlying
= check_typedef (TYPE_TARGET_TYPE (type
));
1585 if (TYPE_NAME (underlying
) != NULL
)
1586 fprintf_filtered (stream
, ": %s ", TYPE_NAME (underlying
));
1589 fprintf_filtered (stream
, "{");
1590 len
= TYPE_NFIELDS (type
);
1591 for (i
= 0; i
< len
; i
++)
1595 fprintf_filtered (stream
, ", ");
1597 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1598 if (lastval
!= TYPE_FIELD_ENUMVAL (type
, i
))
1600 fprintf_filtered (stream
, " = %s",
1601 plongest (TYPE_FIELD_ENUMVAL (type
, i
)));
1602 lastval
= TYPE_FIELD_ENUMVAL (type
, i
);
1606 fprintf_filtered (stream
, "}");
1610 case TYPE_CODE_FLAGS
:
1612 struct type_print_options local_flags
= *flags
;
1614 local_flags
.local_typedefs
= NULL
;
1616 c_type_print_modifier (type
, stream
, 0, 1);
1617 fprintf_filtered (stream
, "flag ");
1618 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
1621 fputs_filtered (" ", stream
);
1622 fprintf_filtered (stream
, "{\n");
1623 if (TYPE_NFIELDS (type
) == 0)
1625 if (TYPE_STUB (type
))
1626 fprintfi_filtered (level
+ 4, stream
,
1627 _("<incomplete type>\n"));
1629 fprintfi_filtered (level
+ 4, stream
,
1630 _("<no data fields>\n"));
1632 len
= TYPE_NFIELDS (type
);
1633 for (i
= 0; i
< len
; i
++)
1636 print_spaces_filtered (level
+ 4, stream
);
1637 /* We pass "show" here and not "show - 1" to get enum types
1638 printed. There's no other way to see them. */
1639 c_print_type_1 (TYPE_FIELD_TYPE (type
, i
),
1640 TYPE_FIELD_NAME (type
, i
),
1641 stream
, show
, level
+ 4,
1642 language
, &local_flags
, podata
);
1643 fprintf_filtered (stream
, " @%s",
1644 plongest (TYPE_FIELD_BITPOS (type
, i
)));
1645 if (TYPE_FIELD_BITSIZE (type
, i
) > 1)
1647 fprintf_filtered (stream
, "-%s",
1648 plongest (TYPE_FIELD_BITPOS (type
, i
)
1649 + TYPE_FIELD_BITSIZE (type
, i
)
1652 fprintf_filtered (stream
, ";\n");
1654 fprintfi_filtered (level
, stream
, "}");
1659 case TYPE_CODE_VOID
:
1660 fprintf_filtered (stream
, "void");
1663 case TYPE_CODE_UNDEF
:
1664 fprintf_filtered (stream
, _("struct <unknown>"));
1667 case TYPE_CODE_ERROR
:
1668 fprintf_filtered (stream
, "%s", TYPE_ERROR_NAME (type
));
1671 case TYPE_CODE_RANGE
:
1672 /* This should not occur. */
1673 fprintf_filtered (stream
, _("<range type>"));
1676 case TYPE_CODE_NAMESPACE
:
1677 fputs_filtered ("namespace ", stream
);
1678 fputs_filtered (TYPE_NAME (type
), stream
);
1682 /* Handle types not explicitly handled by the other cases, such
1683 as fundamental types. For these, just print whatever the
1684 type name is, as recorded in the type itself. If there is no
1685 type name, then complain. */
1686 if (TYPE_NAME (type
) != NULL
)
1688 c_type_print_modifier (type
, stream
, 0, 1);
1689 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
1693 /* At least for dump_symtab, it is important that this not
1695 fprintf_filtered (stream
, _("<invalid type code %d>"),
1702 /* See c_type_print_base_1. */
1705 c_type_print_base (struct type
*type
, struct ui_file
*stream
,
1706 int show
, int level
,
1707 const struct type_print_options
*flags
)
1709 struct print_offset_data podata
;
1711 c_type_print_base_1 (type
, stream
, show
, level
,
1712 current_language
->la_language
, flags
, &podata
);