1 /* Support for printing C and C++ types for GDB, the GNU debugger.
2 Copyright (C) 1986-2013 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/>. */
20 #include "gdb_obstack.h"
21 #include "bfd.h" /* Binary File Description. */
24 #include "expression.h"
31 #include "typeprint.h"
34 #include "gdb_string.h"
36 #include "cp-support.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
*,
49 /* A callback function for cp_canonicalize_string_full that uses
50 find_typedef_in_hash. */
53 find_typedef_for_canonicalize (struct type
*t
, void *data
)
55 return find_typedef_in_hash (data
, t
);
58 /* Print NAME on STREAM. If the 'raw' field of FLAGS is not set,
59 canonicalize NAME using the local typedefs first. */
62 print_name_maybe_canonical (const char *name
,
63 const struct type_print_options
*flags
,
64 struct ui_file
*stream
)
69 s
= cp_canonicalize_string_full (name
,
70 find_typedef_for_canonicalize
,
73 fputs_filtered (s
? s
: name
, stream
);
79 /* LEVEL is the depth to indent lines by. */
82 c_print_type (struct type
*type
,
83 const char *varstring
,
84 struct ui_file
*stream
,
86 const struct type_print_options
*flags
)
91 const char *local_name
;
96 local_name
= find_typedef_in_hash (flags
, type
);
97 if (local_name
!= NULL
)
99 fputs_filtered (local_name
, stream
);
100 if (varstring
!= NULL
&& *varstring
!= '\0')
101 fputs_filtered (" ", stream
);
105 c_type_print_base (type
, stream
, show
, level
, flags
);
106 code
= TYPE_CODE (type
);
107 if ((varstring
!= NULL
&& *varstring
!= '\0')
108 /* Need a space if going to print stars or brackets;
109 but not if we will print just a type name. */
110 || ((show
> 0 || TYPE_NAME (type
) == 0)
111 && (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
112 || code
== TYPE_CODE_METHOD
113 || (code
== TYPE_CODE_ARRAY
114 && !TYPE_VECTOR (type
))
115 || code
== TYPE_CODE_MEMBERPTR
116 || code
== TYPE_CODE_METHODPTR
117 || code
== TYPE_CODE_REF
)))
118 fputs_filtered (" ", stream
);
119 need_post_space
= (varstring
!= NULL
&& strcmp (varstring
, "") != 0);
120 c_type_print_varspec_prefix (type
, stream
, show
, 0, need_post_space
,
124 if (varstring
!= NULL
)
126 fputs_filtered (varstring
, stream
);
128 /* For demangled function names, we have the arglist as part of
129 the name, so don't print an additional pair of ()'s. */
130 if (local_name
== NULL
)
132 demangled_args
= strchr (varstring
, '(') != NULL
;
133 c_type_print_varspec_suffix (type
, stream
, show
,
140 /* Print a typedef using C syntax. TYPE is the underlying type.
141 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
145 c_print_typedef (struct type
*type
,
146 struct symbol
*new_symbol
,
147 struct ui_file
*stream
)
149 CHECK_TYPEDEF (type
);
150 fprintf_filtered (stream
, "typedef ");
151 type_print (type
, "", stream
, 0);
152 if (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))) == 0
153 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))),
154 SYMBOL_LINKAGE_NAME (new_symbol
)) != 0
155 || TYPE_CODE (SYMBOL_TYPE (new_symbol
)) == TYPE_CODE_TYPEDEF
)
156 fprintf_filtered (stream
, " %s", SYMBOL_PRINT_NAME (new_symbol
));
157 fprintf_filtered (stream
, ";\n");
160 /* If TYPE is a derived type, then print out derivation information.
161 Print only the actual base classes of this type, not the base
162 classes of the base classes. I.e. for the derivation hierarchy:
165 class B : public A {int b; };
166 class C : public B {int c; };
168 Print the type of class C as:
174 Not as the following (like gdb used to), which is not legal C++
175 syntax for derived types and may be confused with the multiple
178 class C : public B : public A {
182 In general, gdb should try to print the types as closely as
183 possible to the form that they appear in the source code. */
186 cp_type_print_derivation_info (struct ui_file
*stream
,
188 const struct type_print_options
*flags
)
193 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
196 fputs_filtered (i
== 0 ? ": " : ", ", stream
);
197 fprintf_filtered (stream
, "%s%s ",
198 BASETYPE_VIA_PUBLIC (type
, i
)
199 ? "public" : (TYPE_FIELD_PROTECTED (type
, i
)
200 ? "protected" : "private"),
201 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
202 name
= type_name_no_tag (TYPE_BASECLASS (type
, i
));
204 print_name_maybe_canonical (name
, flags
, stream
);
206 fprintf_filtered (stream
, "(null)");
210 fputs_filtered (" ", stream
);
214 /* Print the C++ method arguments ARGS to the file STREAM. */
217 cp_type_print_method_args (struct type
*mtype
, const char *prefix
,
218 const char *varstring
, int staticp
,
219 struct ui_file
*stream
,
220 const struct type_print_options
*flags
)
222 struct field
*args
= TYPE_FIELDS (mtype
);
223 int nargs
= TYPE_NFIELDS (mtype
);
224 int varargs
= TYPE_VARARGS (mtype
);
227 fprintf_symbol_filtered (stream
, prefix
,
228 language_cplus
, DMGL_ANSI
);
229 fprintf_symbol_filtered (stream
, varstring
,
230 language_cplus
, DMGL_ANSI
);
231 fputs_filtered ("(", stream
);
233 /* Skip the class variable. */
239 c_print_type (args
[i
++].type
, "", stream
, 0, 0, flags
);
241 if (i
== nargs
&& varargs
)
242 fprintf_filtered (stream
, ", ...");
245 fprintf_filtered (stream
, ", ");
251 fprintf_filtered (stream
, "...");
252 else if (current_language
->la_language
== language_cplus
)
253 fprintf_filtered (stream
, "void");
255 fprintf_filtered (stream
, ")");
257 /* For non-static methods, read qualifiers from the type of
263 gdb_assert (nargs
> 0);
264 gdb_assert (TYPE_CODE (args
[0].type
) == TYPE_CODE_PTR
);
265 domain
= TYPE_TARGET_TYPE (args
[0].type
);
267 if (TYPE_CONST (domain
))
268 fprintf_filtered (stream
, " const");
270 if (TYPE_VOLATILE (domain
))
271 fprintf_filtered (stream
, " volatile");
273 if (TYPE_RESTRICT (domain
))
274 fprintf_filtered (stream
, " restrict");
279 /* Print any asterisks or open-parentheses needed before the
280 variable name (to describe its type).
282 On outermost call, pass 0 for PASSED_A_PTR.
283 On outermost call, SHOW > 0 means should ignore
284 any typename for TYPE and show its details.
285 SHOW is always zero on recursive calls.
287 NEED_POST_SPACE is non-zero when a space will be be needed
288 between a trailing qualifier and a field, variable, or function
292 c_type_print_varspec_prefix (struct type
*type
,
293 struct ui_file
*stream
,
294 int show
, int passed_a_ptr
,
296 const struct type_print_options
*flags
)
303 if (TYPE_NAME (type
) && show
<= 0)
308 switch (TYPE_CODE (type
))
311 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
312 stream
, show
, 1, 1, flags
);
313 fprintf_filtered (stream
, "*");
314 c_type_print_modifier (type
, stream
, 1, need_post_space
);
317 case TYPE_CODE_MEMBERPTR
:
318 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
319 stream
, show
, 0, 0, flags
);
320 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
322 print_name_maybe_canonical (name
, flags
, stream
);
324 c_type_print_base (TYPE_DOMAIN_TYPE (type
),
325 stream
, -1, passed_a_ptr
, flags
);
326 fprintf_filtered (stream
, "::*");
329 case TYPE_CODE_METHODPTR
:
330 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
331 stream
, show
, 0, 0, flags
);
332 fprintf_filtered (stream
, "(");
333 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
335 print_name_maybe_canonical (name
, flags
, stream
);
337 c_type_print_base (TYPE_DOMAIN_TYPE (type
),
338 stream
, -1, passed_a_ptr
, flags
);
339 fprintf_filtered (stream
, "::*");
343 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
344 stream
, show
, 1, 0, flags
);
345 fprintf_filtered (stream
, "&");
346 c_type_print_modifier (type
, stream
, 1, need_post_space
);
349 case TYPE_CODE_METHOD
:
351 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
352 stream
, show
, 0, 0, flags
);
354 fprintf_filtered (stream
, "(");
357 case TYPE_CODE_ARRAY
:
358 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
359 stream
, show
, 0, 0, flags
);
361 fprintf_filtered (stream
, "(");
364 case TYPE_CODE_TYPEDEF
:
365 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
366 stream
, show
, passed_a_ptr
, 0, flags
);
369 case TYPE_CODE_UNDEF
:
370 case TYPE_CODE_STRUCT
:
371 case TYPE_CODE_UNION
:
376 case TYPE_CODE_ERROR
:
380 case TYPE_CODE_RANGE
:
381 case TYPE_CODE_STRING
:
382 case TYPE_CODE_COMPLEX
:
383 case TYPE_CODE_NAMESPACE
:
384 case TYPE_CODE_DECFLOAT
:
385 /* These types need no prefix. They are listed here so that
386 gcc -Wall will reveal any types that haven't been handled. */
389 error (_("type not handled in c_type_print_varspec_prefix()"));
394 /* Print out "const" and "volatile" attributes,
395 and address space id if present.
396 TYPE is a pointer to the type being printed out.
397 STREAM is the output destination.
398 NEED_PRE_SPACE = 1 indicates an initial white space is needed.
399 NEED_POST_SPACE = 1 indicates a final white space is needed. */
402 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
403 int need_pre_space
, int need_post_space
)
405 int did_print_modifier
= 0;
406 const char *address_space_id
;
408 /* We don't print `const' qualifiers for references --- since all
409 operators affect the thing referenced, not the reference itself,
410 every reference is `const'. */
411 if (TYPE_CONST (type
)
412 && TYPE_CODE (type
) != TYPE_CODE_REF
)
415 fprintf_filtered (stream
, " ");
416 fprintf_filtered (stream
, "const");
417 did_print_modifier
= 1;
420 if (TYPE_VOLATILE (type
))
422 if (did_print_modifier
|| need_pre_space
)
423 fprintf_filtered (stream
, " ");
424 fprintf_filtered (stream
, "volatile");
425 did_print_modifier
= 1;
428 if (TYPE_RESTRICT (type
))
430 if (did_print_modifier
|| need_pre_space
)
431 fprintf_filtered (stream
, " ");
432 fprintf_filtered (stream
, "restrict");
433 did_print_modifier
= 1;
436 address_space_id
= address_space_int_to_name (get_type_arch (type
),
437 TYPE_INSTANCE_FLAGS (type
));
438 if (address_space_id
)
440 if (did_print_modifier
|| need_pre_space
)
441 fprintf_filtered (stream
, " ");
442 fprintf_filtered (stream
, "@%s", address_space_id
);
443 did_print_modifier
= 1;
446 if (did_print_modifier
&& need_post_space
)
447 fprintf_filtered (stream
, " ");
451 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
452 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
453 in non-static methods, are displayed if LINKAGE_NAME is zero. If
454 LINKAGE_NAME is non-zero and LANGUAGE is language_cplus the topmost
455 parameter types get removed their possible const and volatile qualifiers to
456 match demangled linkage name parameters part of such function type.
457 LANGUAGE is the language in which TYPE was defined. This is a necessary
458 evil since this code is used by the C, C++, and Java backends. */
461 c_type_print_args (struct type
*type
, struct ui_file
*stream
,
462 int linkage_name
, enum language language
,
463 const struct type_print_options
*flags
)
469 fprintf_filtered (stream
, "(");
470 args
= TYPE_FIELDS (type
);
471 len
= TYPE_NFIELDS (type
);
473 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
475 struct type
*param_type
;
477 if (TYPE_FIELD_ARTIFICIAL (type
, i
) && linkage_name
)
482 fprintf_filtered (stream
, ", ");
486 param_type
= TYPE_FIELD_TYPE (type
, i
);
488 if (language
== language_cplus
&& linkage_name
)
490 /* C++ standard, 13.1 Overloadable declarations, point 3, item:
491 - Parameter declarations that differ only in the presence or
492 absence of const and/or volatile are equivalent.
494 And the const/volatile qualifiers are not present in the mangled
495 names as produced by GCC. */
497 param_type
= make_cv_type (0, 0, param_type
, NULL
);
500 if (language
== language_java
)
501 java_print_type (param_type
, "", stream
, -1, 0, flags
);
503 c_print_type (param_type
, "", stream
, -1, 0, flags
);
507 if (printed_any
&& TYPE_VARARGS (type
))
509 /* Print out a trailing ellipsis for varargs functions. Ignore
510 TYPE_VARARGS if the function has no named arguments; that
511 represents unprototyped (K&R style) C functions. */
512 if (printed_any
&& TYPE_VARARGS (type
))
514 fprintf_filtered (stream
, ", ");
516 fprintf_filtered (stream
, "...");
519 else if (!printed_any
520 && ((TYPE_PROTOTYPED (type
) && language
!= language_java
)
521 || language
== language_cplus
))
522 fprintf_filtered (stream
, "void");
524 fprintf_filtered (stream
, ")");
527 /* Return true iff the j'th overloading of the i'th method of TYPE
528 is a type conversion operator, like `operator int () { ... }'.
529 When listing a class's methods, we don't print the return type of
533 is_type_conversion_operator (struct type
*type
, int i
, int j
)
535 /* I think the whole idea of recognizing type conversion operators
536 by their name is pretty terrible. But I don't think our present
537 data structure gives us any other way to tell. If you know of
538 some other way, feel free to rewrite this function. */
539 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
541 if (strncmp (name
, "operator", 8) != 0)
545 if (! strchr (" \t\f\n\r", *name
))
548 while (strchr (" \t\f\n\r", *name
))
551 if (!('a' <= *name
&& *name
<= 'z')
552 && !('A' <= *name
&& *name
<= 'Z')
554 /* If this doesn't look like the start of an identifier, then it
555 isn't a type conversion operator. */
557 else if (strncmp (name
, "new", 3) == 0)
559 else if (strncmp (name
, "delete", 6) == 0)
562 /* If it doesn't look like new or delete, it's a type conversion
566 /* Is that really the end of the name? */
567 if (('a' <= *name
&& *name
<= 'z')
568 || ('A' <= *name
&& *name
<= 'Z')
569 || ('0' <= *name
&& *name
<= '9')
571 /* No, so the identifier following "operator" must be a type name,
572 and this is a type conversion operator. */
575 /* That was indeed the end of the name, so it was `operator new' or
576 `operator delete', neither of which are type conversion
581 /* Given a C++ qualified identifier QID, strip off the qualifiers,
582 yielding the unqualified name. The return value is a pointer into
585 It's a pity we don't have this information in some more structured
586 form. Even the author of this function feels that writing little
587 parsers like this everywhere is stupid. */
590 remove_qualifiers (char *qid
)
592 int quoted
= 0; /* Zero if we're not in quotes;
593 '"' if we're in a double-quoted string;
594 '\'' if we're in a single-quoted string. */
595 int depth
= 0; /* Number of unclosed parens we've seen. */
596 char *parenstack
= (char *) alloca (strlen (qid
));
598 char *last
= 0; /* The character after the rightmost
599 `::' token we've seen so far. */
601 for (scan
= qid
; *scan
; scan
++)
607 else if (*scan
== '\\' && *(scan
+ 1))
610 else if (scan
[0] == ':' && scan
[1] == ':')
612 /* If we're inside parenthesis (i.e., an argument list) or
613 angle brackets (i.e., a list of template arguments), then
614 we don't record the position of this :: token, since it's
615 not relevant to the top-level structure we're trying to
623 else if (*scan
== '"' || *scan
== '\'')
625 else if (*scan
== '(')
626 parenstack
[depth
++] = ')';
627 else if (*scan
== '[')
628 parenstack
[depth
++] = ']';
629 /* We're going to treat <> as a pair of matching characters,
630 since we're more likely to see those in template id's than
631 real less-than characters. What a crock. */
632 else if (*scan
== '<')
633 parenstack
[depth
++] = '>';
634 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
636 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
640 /* We're going to do a little error recovery here. If
641 we don't find a match for *scan on the paren stack,
642 but there is something lower on the stack that does
643 match, we pop the stack to that point. */
646 for (i
= depth
- 1; i
>= 0; i
--)
647 if (parenstack
[i
] == *scan
)
659 /* We didn't find any :: tokens at the top level, so declare the
660 whole thing an unqualified identifier. */
664 /* Print any array sizes, function arguments or close parentheses
665 needed after the variable name (to describe its type).
666 Args work like c_type_print_varspec_prefix. */
669 c_type_print_varspec_suffix (struct type
*type
,
670 struct ui_file
*stream
,
671 int show
, int passed_a_ptr
,
673 const struct type_print_options
*flags
)
678 if (TYPE_NAME (type
) && show
<= 0)
683 switch (TYPE_CODE (type
))
685 case TYPE_CODE_ARRAY
:
687 LONGEST low_bound
, high_bound
;
688 int is_vector
= TYPE_VECTOR (type
);
691 fprintf_filtered (stream
, ")");
693 fprintf_filtered (stream
, (is_vector
?
694 " __attribute__ ((vector_size(" : "["));
695 if (get_array_bounds (type
, &low_bound
, &high_bound
))
696 fprintf_filtered (stream
, "%s",
697 plongest (high_bound
- low_bound
+ 1));
698 fprintf_filtered (stream
, (is_vector
? ")))" : "]"));
700 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
705 case TYPE_CODE_MEMBERPTR
:
706 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
710 case TYPE_CODE_METHODPTR
:
711 fprintf_filtered (stream
, ")");
712 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
718 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
722 case TYPE_CODE_METHOD
:
725 fprintf_filtered (stream
, ")");
727 c_type_print_args (type
, stream
, 0, current_language
->la_language
,
729 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
730 show
, passed_a_ptr
, 0, flags
);
733 case TYPE_CODE_TYPEDEF
:
734 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
735 show
, passed_a_ptr
, 0, flags
);
738 case TYPE_CODE_UNDEF
:
739 case TYPE_CODE_STRUCT
:
740 case TYPE_CODE_UNION
:
745 case TYPE_CODE_ERROR
:
749 case TYPE_CODE_RANGE
:
750 case TYPE_CODE_STRING
:
751 case TYPE_CODE_COMPLEX
:
752 case TYPE_CODE_NAMESPACE
:
753 case TYPE_CODE_DECFLOAT
:
754 /* These types do not need a suffix. They are listed so that
755 gcc -Wall will report types that may not have been
759 error (_("type not handled in c_type_print_varspec_suffix()"));
764 /* A helper for c_type_print_base that displays template
765 parameters and their bindings, if needed.
767 TABLE is the local bindings table to use. If NULL, no printing is
768 done. Note that, at this point, TABLE won't have any useful
769 information in it -- but it is also used as a flag to
770 print_name_maybe_canonical to activate searching the global typedef
773 TYPE is the type whose template arguments are being displayed.
775 STREAM is the stream on which to print. */
778 c_type_print_template_args (const struct type_print_options
*flags
,
779 struct type
*type
, struct ui_file
*stream
)
786 for (i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
788 struct symbol
*sym
= TYPE_TEMPLATE_ARGUMENT (type
, i
);
790 if (SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
796 fprintf_filtered (stream
, _("[with %s = "),
797 SYMBOL_LINKAGE_NAME (sym
));
802 fputs_filtered (", ", stream
);
804 fprintf_filtered (stream
, "%s = ", SYMBOL_LINKAGE_NAME (sym
));
807 c_print_type (SYMBOL_TYPE (sym
), "", stream
, -1, 0, flags
);
811 fputs_filtered (_("] "), stream
);
814 /* Print the name of the type (or the ultimate pointer target,
815 function value or array element), or the description of a structure
818 SHOW positive means print details about the type (e.g. enum
819 values), and print structure elements passing SHOW - 1 for show.
821 SHOW negative means just print the type name or struct tag if there
822 is one. If there is no name, print something sensible but concise
825 SHOW zero means just print the type name or struct tag if there is
826 one. If there is no name, print something sensible but not as
827 concise like "struct {int x; int y;}".
829 LEVEL is the number of spaces to indent by.
830 We increase it for some recursive calls. */
833 c_type_print_base (struct type
*type
, struct ui_file
*stream
,
834 int show
, int level
, const struct type_print_options
*flags
)
840 s_none
, s_public
, s_private
, s_protected
843 int need_access_label
= 0;
850 fputs_filtered (_("<type unknown>"), stream
);
854 /* When SHOW is zero or less, and there is a valid type name, then
855 always just print the type name directly from the type. */
856 /* If we have "typedef struct foo {. . .} bar;" do we want to print
857 it as "struct foo" or as "bar"? Pick the latter, because C++
858 folk tend to expect things like "class5 *foo" rather than "struct
862 && TYPE_NAME (type
) != NULL
)
864 c_type_print_modifier (type
, stream
, 0, 1);
865 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
869 CHECK_TYPEDEF (type
);
871 switch (TYPE_CODE (type
))
873 case TYPE_CODE_TYPEDEF
:
874 /* If we get here, the typedef doesn't have a name, and we
875 couldn't resolve TYPE_TARGET_TYPE. Not much we can do. */
876 gdb_assert (TYPE_NAME (type
) == NULL
);
877 gdb_assert (TYPE_TARGET_TYPE (type
) == NULL
);
878 fprintf_filtered (stream
, _("<unnamed typedef>"));
881 case TYPE_CODE_ARRAY
:
883 case TYPE_CODE_MEMBERPTR
:
886 case TYPE_CODE_METHOD
:
887 case TYPE_CODE_METHODPTR
:
888 c_type_print_base (TYPE_TARGET_TYPE (type
),
889 stream
, show
, level
, flags
);
892 case TYPE_CODE_STRUCT
:
893 case TYPE_CODE_UNION
:
895 struct type_print_options local_flags
= *flags
;
896 struct type_print_options semi_local_flags
= *flags
;
897 struct cleanup
*local_cleanups
= make_cleanup (null_cleanup
, NULL
);
899 local_flags
.local_typedefs
= NULL
;
900 semi_local_flags
.local_typedefs
= NULL
;
904 if (flags
->local_typedefs
)
905 local_flags
.local_typedefs
906 = copy_typedef_hash (flags
->local_typedefs
);
908 local_flags
.local_typedefs
= create_typedef_hash ();
910 make_cleanup_free_typedef_hash (local_flags
.local_typedefs
);
913 c_type_print_modifier (type
, stream
, 0, 1);
914 if (TYPE_CODE (type
) == TYPE_CODE_UNION
)
915 fprintf_filtered (stream
, "union ");
916 else if (TYPE_DECLARED_CLASS (type
))
917 fprintf_filtered (stream
, "class ");
919 fprintf_filtered (stream
, "struct ");
921 /* Print the tag if it exists. The HP aCC compiler emits a
922 spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
923 enum}" tag for unnamed struct/union/enum's, which we don't
925 if (TYPE_TAG_NAME (type
) != NULL
926 && strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
928 /* When printing the tag name, we are still effectively
929 printing in the outer context, hence the use of FLAGS
931 print_name_maybe_canonical (TYPE_TAG_NAME (type
), flags
, stream
);
933 fputs_filtered (" ", stream
);
938 /* If we just printed a tag name, no need to print anything
940 if (TYPE_TAG_NAME (type
) == NULL
)
941 fprintf_filtered (stream
, "{...}");
943 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
945 struct type
*basetype
;
948 c_type_print_template_args (&local_flags
, type
, stream
);
950 /* Add in template parameters when printing derivation info. */
951 add_template_parameters (local_flags
.local_typedefs
, type
);
952 cp_type_print_derivation_info (stream
, type
, &local_flags
);
954 /* This holds just the global typedefs and the template
956 semi_local_flags
.local_typedefs
957 = copy_typedef_hash (local_flags
.local_typedefs
);
958 if (semi_local_flags
.local_typedefs
)
959 make_cleanup_free_typedef_hash (semi_local_flags
.local_typedefs
);
961 /* Now add in the local typedefs. */
962 recursively_update_typedef_hash (local_flags
.local_typedefs
, type
);
964 fprintf_filtered (stream
, "{\n");
965 if (TYPE_NFIELDS (type
) == 0 && TYPE_NFN_FIELDS (type
) == 0
966 && TYPE_TYPEDEF_FIELD_COUNT (type
) == 0)
968 if (TYPE_STUB (type
))
969 fprintfi_filtered (level
+ 4, stream
,
970 _("<incomplete type>\n"));
972 fprintfi_filtered (level
+ 4, stream
,
973 _("<no data fields>\n"));
976 /* Start off with no specific section type, so we can print
977 one for the first field we find, and use that section type
978 thereafter until we find another type. */
980 section_type
= s_none
;
982 /* For a class, if all members are private, there's no need
983 for a "private:" label; similarly, for a struct or union
984 masquerading as a class, if all members are public, there's
985 no need for a "public:" label. */
987 if (TYPE_DECLARED_CLASS (type
))
990 len
= TYPE_NFIELDS (type
);
991 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
992 if (!TYPE_FIELD_PRIVATE (type
, i
))
994 need_access_label
= 1;
998 if (!need_access_label
)
1000 len2
= TYPE_NFN_FIELDS (type
);
1001 for (j
= 0; j
< len2
; j
++)
1003 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
1004 for (i
= 0; i
< len
; i
++)
1005 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
,
1008 need_access_label
= 1;
1011 if (need_access_label
)
1019 len
= TYPE_NFIELDS (type
);
1020 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
1021 if (TYPE_FIELD_PRIVATE (type
, i
)
1022 || TYPE_FIELD_PROTECTED (type
, i
))
1024 need_access_label
= 1;
1028 if (!need_access_label
)
1030 len2
= TYPE_NFN_FIELDS (type
);
1031 for (j
= 0; j
< len2
; j
++)
1034 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
1035 for (i
= 0; i
< len
; i
++)
1036 if (TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
,
1038 || TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
,
1042 need_access_label
= 1;
1045 if (need_access_label
)
1051 /* If there is a base class for this type,
1052 do not print the field that it occupies. */
1054 len
= TYPE_NFIELDS (type
);
1055 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
1056 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
1060 /* If we have a virtual table pointer, omit it. Even if
1061 virtual table pointers are not specifically marked in
1062 the debug info, they should be artificial. */
1063 if ((i
== vptr_fieldno
&& type
== basetype
)
1064 || TYPE_FIELD_ARTIFICIAL (type
, i
))
1067 if (need_access_label
)
1069 if (TYPE_FIELD_PROTECTED (type
, i
))
1071 if (section_type
!= s_protected
)
1073 section_type
= s_protected
;
1074 fprintfi_filtered (level
+ 2, stream
,
1078 else if (TYPE_FIELD_PRIVATE (type
, i
))
1080 if (section_type
!= s_private
)
1082 section_type
= s_private
;
1083 fprintfi_filtered (level
+ 2, stream
,
1089 if (section_type
!= s_public
)
1091 section_type
= s_public
;
1092 fprintfi_filtered (level
+ 2, stream
,
1098 print_spaces_filtered (level
+ 4, stream
);
1099 if (field_is_static (&TYPE_FIELD (type
, i
)))
1100 fprintf_filtered (stream
, "static ");
1101 c_print_type (TYPE_FIELD_TYPE (type
, i
),
1102 TYPE_FIELD_NAME (type
, i
),
1103 stream
, show
- 1, level
+ 4,
1105 if (!field_is_static (&TYPE_FIELD (type
, i
))
1106 && TYPE_FIELD_PACKED (type
, i
))
1108 /* It is a bitfield. This code does not attempt
1109 to look at the bitpos and reconstruct filler,
1110 unnamed fields. This would lead to misleading
1111 results if the compiler does not put out fields
1112 for such things (I don't know what it does). */
1113 fprintf_filtered (stream
, " : %d",
1114 TYPE_FIELD_BITSIZE (type
, i
));
1116 fprintf_filtered (stream
, ";\n");
1119 /* If there are both fields and methods, put a blank line
1120 between them. Make sure to count only method that we
1121 will display; artificial methods will be hidden. */
1122 len
= TYPE_NFN_FIELDS (type
);
1123 if (!flags
->print_methods
)
1126 for (i
= 0; i
< len
; i
++)
1128 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1129 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
1132 for (j
= 0; j
< len2
; j
++)
1133 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
1136 if (real_len
> 0 && section_type
!= s_none
)
1137 fprintf_filtered (stream
, "\n");
1139 /* C++: print out the methods. */
1140 for (i
= 0; i
< len
; i
++)
1142 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1143 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
1144 const char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1145 const char *name
= type_name_no_tag (type
);
1146 int is_constructor
= name
&& strcmp (method_name
,
1149 for (j
= 0; j
< len2
; j
++)
1151 const char *mangled_name
;
1152 char *demangled_name
;
1153 struct cleanup
*inner_cleanup
;
1154 const char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1155 int is_full_physname_constructor
=
1156 TYPE_FN_FIELD_CONSTRUCTOR (f
, j
)
1157 || is_constructor_name (physname
)
1158 || is_destructor_name (physname
)
1159 || method_name
[0] == '~';
1161 /* Do not print out artificial methods. */
1162 if (TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
1165 inner_cleanup
= make_cleanup (null_cleanup
, NULL
);
1168 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
1170 if (section_type
!= s_protected
)
1172 section_type
= s_protected
;
1173 fprintfi_filtered (level
+ 2, stream
,
1177 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
1179 if (section_type
!= s_private
)
1181 section_type
= s_private
;
1182 fprintfi_filtered (level
+ 2, stream
,
1188 if (section_type
!= s_public
)
1190 section_type
= s_public
;
1191 fprintfi_filtered (level
+ 2, stream
,
1196 print_spaces_filtered (level
+ 4, stream
);
1197 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1198 fprintf_filtered (stream
, "virtual ");
1199 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
1200 fprintf_filtered (stream
, "static ");
1201 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
1203 /* Keep GDB from crashing here. */
1204 fprintf_filtered (stream
,
1205 _("<undefined type> %s;\n"),
1206 TYPE_FN_FIELD_PHYSNAME (f
, j
));
1209 else if (!is_constructor
/* Constructors don't
1212 && !is_full_physname_constructor
/* " " */
1213 && !is_type_conversion_operator (type
, i
, j
))
1215 c_print_type (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
1218 fputs_filtered (" ", stream
);
1220 if (TYPE_FN_FIELD_STUB (f
, j
))
1224 /* Build something we can demangle. */
1225 tem
= gdb_mangle_name (type
, i
, j
);
1226 make_cleanup (xfree
, tem
);
1230 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1233 cplus_demangle (mangled_name
,
1234 DMGL_ANSI
| DMGL_PARAMS
);
1235 if (demangled_name
== NULL
)
1237 /* In some cases (for instance with the HP
1238 demangling), if a function has more than 10
1239 arguments, the demangling will fail.
1240 Let's try to reconstruct the function
1241 signature from the symbol information. */
1242 if (!TYPE_FN_FIELD_STUB (f
, j
))
1244 int staticp
= TYPE_FN_FIELD_STATIC_P (f
, j
);
1245 struct type
*mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1247 cp_type_print_method_args (mtype
,
1251 stream
, &local_flags
);
1254 fprintf_filtered (stream
,
1255 _("<badly mangled name '%s'>"),
1261 char *demangled_no_class
1262 = remove_qualifiers (demangled_name
);
1264 /* Get rid of the `static' appended by the
1266 p
= strstr (demangled_no_class
, " static");
1269 int length
= p
- demangled_no_class
;
1270 char *demangled_no_static
;
1273 = (char *) xmalloc (length
+ 1);
1274 strncpy (demangled_no_static
,
1275 demangled_no_class
, length
);
1276 *(demangled_no_static
+ length
) = '\0';
1277 fputs_filtered (demangled_no_static
, stream
);
1278 xfree (demangled_no_static
);
1281 fputs_filtered (demangled_no_class
, stream
);
1282 xfree (demangled_name
);
1285 do_cleanups (inner_cleanup
);
1287 fprintf_filtered (stream
, ";\n");
1291 /* Print typedefs defined in this class. */
1293 if (TYPE_TYPEDEF_FIELD_COUNT (type
) != 0 && flags
->print_typedefs
)
1295 if (TYPE_NFIELDS (type
) != 0 || TYPE_NFN_FIELDS (type
) != 0)
1296 fprintf_filtered (stream
, "\n");
1298 for (i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (type
); i
++)
1300 struct type
*target
= TYPE_TYPEDEF_FIELD_TYPE (type
, i
);
1301 struct typedef_hash_table
*table2
;
1303 /* Dereference the typedef declaration itself. */
1304 gdb_assert (TYPE_CODE (target
) == TYPE_CODE_TYPEDEF
);
1305 target
= TYPE_TARGET_TYPE (target
);
1307 print_spaces_filtered (level
+ 4, stream
);
1308 fprintf_filtered (stream
, "typedef ");
1310 /* We want to print typedefs with substitutions
1311 from the template parameters or globally-known
1312 typedefs but not local typedefs. */
1313 c_print_type (target
,
1314 TYPE_TYPEDEF_FIELD_NAME (type
, i
),
1315 stream
, show
- 1, level
+ 4,
1317 fprintf_filtered (stream
, ";\n");
1321 fprintfi_filtered (level
, stream
, "}");
1324 do_cleanups (local_cleanups
);
1328 case TYPE_CODE_ENUM
:
1329 c_type_print_modifier (type
, stream
, 0, 1);
1330 fprintf_filtered (stream
, "enum ");
1331 /* Print the tag name if it exists.
1332 The aCC compiler emits a spurious
1333 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1334 tag for unnamed struct/union/enum's, which we don't
1336 if (TYPE_TAG_NAME (type
) != NULL
1337 && strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
1339 print_name_maybe_canonical (TYPE_TAG_NAME (type
), flags
, stream
);
1341 fputs_filtered (" ", stream
);
1347 /* If we just printed a tag name, no need to print anything
1349 if (TYPE_TAG_NAME (type
) == NULL
)
1350 fprintf_filtered (stream
, "{...}");
1352 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1354 LONGEST lastval
= 0;
1356 fprintf_filtered (stream
, "{");
1357 len
= TYPE_NFIELDS (type
);
1358 for (i
= 0; i
< len
; i
++)
1362 fprintf_filtered (stream
, ", ");
1364 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1365 if (lastval
!= TYPE_FIELD_ENUMVAL (type
, i
))
1367 fprintf_filtered (stream
, " = %s",
1368 plongest (TYPE_FIELD_ENUMVAL (type
, i
)));
1369 lastval
= TYPE_FIELD_ENUMVAL (type
, i
);
1373 fprintf_filtered (stream
, "}");
1377 case TYPE_CODE_VOID
:
1378 fprintf_filtered (stream
, "void");
1381 case TYPE_CODE_UNDEF
:
1382 fprintf_filtered (stream
, _("struct <unknown>"));
1385 case TYPE_CODE_ERROR
:
1386 fprintf_filtered (stream
, "%s", TYPE_ERROR_NAME (type
));
1389 case TYPE_CODE_RANGE
:
1390 /* This should not occur. */
1391 fprintf_filtered (stream
, _("<range type>"));
1394 case TYPE_CODE_NAMESPACE
:
1395 fputs_filtered ("namespace ", stream
);
1396 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1400 /* Handle types not explicitly handled by the other cases, such
1401 as fundamental types. For these, just print whatever the
1402 type name is, as recorded in the type itself. If there is no
1403 type name, then complain. */
1404 if (TYPE_NAME (type
) != NULL
)
1406 c_type_print_modifier (type
, stream
, 0, 1);
1407 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
1411 /* At least for dump_symtab, it is important that this not
1413 fprintf_filtered (stream
, _("<invalid type code %d>"),