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"
37 #include "cp-support.h"
39 static void c_type_print_varspec_prefix (struct type
*,
42 const struct type_print_options
*);
44 /* Print "const", "volatile", or address space modifiers. */
45 static void c_type_print_modifier (struct type
*,
50 /* A callback function for cp_canonicalize_string_full that uses
51 find_typedef_in_hash. */
54 find_typedef_for_canonicalize (struct type
*t
, void *data
)
56 return find_typedef_in_hash (data
, t
);
59 /* Print NAME on STREAM. If the 'raw' field of FLAGS is not set,
60 canonicalize NAME using the local typedefs first. */
63 print_name_maybe_canonical (const char *name
,
64 const struct type_print_options
*flags
,
65 struct ui_file
*stream
)
70 s
= cp_canonicalize_string_full (name
,
71 find_typedef_for_canonicalize
,
74 fputs_filtered (s
? s
: name
, stream
);
80 /* LEVEL is the depth to indent lines by. */
83 c_print_type (struct type
*type
,
84 const char *varstring
,
85 struct ui_file
*stream
,
87 const struct type_print_options
*flags
)
92 const char *local_name
;
97 local_name
= find_typedef_in_hash (flags
, type
);
98 if (local_name
!= NULL
)
100 fputs_filtered (local_name
, stream
);
101 if (varstring
!= NULL
&& *varstring
!= '\0')
102 fputs_filtered (" ", stream
);
106 c_type_print_base (type
, stream
, show
, level
, flags
);
107 code
= TYPE_CODE (type
);
108 if ((varstring
!= NULL
&& *varstring
!= '\0')
109 /* Need a space if going to print stars or brackets;
110 but not if we will print just a type name. */
111 || ((show
> 0 || TYPE_NAME (type
) == 0)
112 && (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
113 || code
== TYPE_CODE_METHOD
114 || (code
== TYPE_CODE_ARRAY
115 && !TYPE_VECTOR (type
))
116 || code
== TYPE_CODE_MEMBERPTR
117 || code
== TYPE_CODE_METHODPTR
118 || code
== TYPE_CODE_REF
)))
119 fputs_filtered (" ", stream
);
120 need_post_space
= (varstring
!= NULL
&& strcmp (varstring
, "") != 0);
121 c_type_print_varspec_prefix (type
, stream
, show
, 0, need_post_space
,
125 if (varstring
!= NULL
)
127 fputs_filtered (varstring
, stream
);
129 /* For demangled function names, we have the arglist as part of
130 the name, so don't print an additional pair of ()'s. */
131 if (local_name
== NULL
)
133 demangled_args
= strchr (varstring
, '(') != NULL
;
134 c_type_print_varspec_suffix (type
, stream
, show
,
141 /* Print a typedef using C syntax. TYPE is the underlying type.
142 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
146 c_print_typedef (struct type
*type
,
147 struct symbol
*new_symbol
,
148 struct ui_file
*stream
)
150 CHECK_TYPEDEF (type
);
151 fprintf_filtered (stream
, "typedef ");
152 type_print (type
, "", stream
, 0);
153 if (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))) == 0
154 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))),
155 SYMBOL_LINKAGE_NAME (new_symbol
)) != 0
156 || TYPE_CODE (SYMBOL_TYPE (new_symbol
)) == TYPE_CODE_TYPEDEF
)
157 fprintf_filtered (stream
, " %s", SYMBOL_PRINT_NAME (new_symbol
));
158 fprintf_filtered (stream
, ";\n");
161 /* If TYPE is a derived type, then print out derivation information.
162 Print only the actual base classes of this type, not the base
163 classes of the base classes. I.e. for the derivation hierarchy:
166 class B : public A {int b; };
167 class C : public B {int c; };
169 Print the type of class C as:
175 Not as the following (like gdb used to), which is not legal C++
176 syntax for derived types and may be confused with the multiple
179 class C : public B : public A {
183 In general, gdb should try to print the types as closely as
184 possible to the form that they appear in the source code. */
187 cp_type_print_derivation_info (struct ui_file
*stream
,
189 const struct type_print_options
*flags
)
194 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
197 fputs_filtered (i
== 0 ? ": " : ", ", stream
);
198 fprintf_filtered (stream
, "%s%s ",
199 BASETYPE_VIA_PUBLIC (type
, i
)
200 ? "public" : (TYPE_FIELD_PROTECTED (type
, i
)
201 ? "protected" : "private"),
202 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
203 name
= type_name_no_tag (TYPE_BASECLASS (type
, i
));
205 print_name_maybe_canonical (name
, flags
, stream
);
207 fprintf_filtered (stream
, "(null)");
211 fputs_filtered (" ", stream
);
215 /* Print the C++ method arguments ARGS to the file STREAM. */
218 cp_type_print_method_args (struct type
*mtype
, const char *prefix
,
219 const char *varstring
, int staticp
,
220 struct ui_file
*stream
,
221 const struct type_print_options
*flags
)
223 struct field
*args
= TYPE_FIELDS (mtype
);
224 int nargs
= TYPE_NFIELDS (mtype
);
225 int varargs
= TYPE_VARARGS (mtype
);
228 fprintf_symbol_filtered (stream
, prefix
,
229 language_cplus
, DMGL_ANSI
);
230 fprintf_symbol_filtered (stream
, varstring
,
231 language_cplus
, DMGL_ANSI
);
232 fputs_filtered ("(", stream
);
234 /* Skip the class variable. */
240 c_print_type (args
[i
++].type
, "", stream
, 0, 0, flags
);
242 if (i
== nargs
&& varargs
)
243 fprintf_filtered (stream
, ", ...");
246 fprintf_filtered (stream
, ", ");
252 fprintf_filtered (stream
, "...");
253 else if (current_language
->la_language
== language_cplus
)
254 fprintf_filtered (stream
, "void");
256 fprintf_filtered (stream
, ")");
258 /* For non-static methods, read qualifiers from the type of
264 gdb_assert (nargs
> 0);
265 gdb_assert (TYPE_CODE (args
[0].type
) == TYPE_CODE_PTR
);
266 domain
= TYPE_TARGET_TYPE (args
[0].type
);
268 if (TYPE_CONST (domain
))
269 fprintf_filtered (stream
, " const");
271 if (TYPE_VOLATILE (domain
))
272 fprintf_filtered (stream
, " volatile");
277 /* Print any asterisks or open-parentheses needed before the
278 variable name (to describe its type).
280 On outermost call, pass 0 for PASSED_A_PTR.
281 On outermost call, SHOW > 0 means should ignore
282 any typename for TYPE and show its details.
283 SHOW is always zero on recursive calls.
285 NEED_POST_SPACE is non-zero when a space will be be needed
286 between a trailing qualifier and a field, variable, or function
290 c_type_print_varspec_prefix (struct type
*type
,
291 struct ui_file
*stream
,
292 int show
, int passed_a_ptr
,
294 const struct type_print_options
*flags
)
301 if (TYPE_NAME (type
) && show
<= 0)
306 switch (TYPE_CODE (type
))
309 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
310 stream
, show
, 1, 1, flags
);
311 fprintf_filtered (stream
, "*");
312 c_type_print_modifier (type
, stream
, 1, need_post_space
);
315 case TYPE_CODE_MEMBERPTR
:
316 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
317 stream
, show
, 0, 0, flags
);
318 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
320 print_name_maybe_canonical (name
, flags
, stream
);
322 c_type_print_base (TYPE_DOMAIN_TYPE (type
),
323 stream
, -1, passed_a_ptr
, flags
);
324 fprintf_filtered (stream
, "::*");
327 case TYPE_CODE_METHODPTR
:
328 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
329 stream
, show
, 0, 0, flags
);
330 fprintf_filtered (stream
, "(");
331 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
333 print_name_maybe_canonical (name
, flags
, stream
);
335 c_type_print_base (TYPE_DOMAIN_TYPE (type
),
336 stream
, -1, passed_a_ptr
, flags
);
337 fprintf_filtered (stream
, "::*");
341 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
342 stream
, show
, 1, 0, flags
);
343 fprintf_filtered (stream
, "&");
344 c_type_print_modifier (type
, stream
, 1, need_post_space
);
347 case TYPE_CODE_METHOD
:
349 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
350 stream
, show
, 0, 0, flags
);
352 fprintf_filtered (stream
, "(");
355 case TYPE_CODE_ARRAY
:
356 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
357 stream
, show
, 0, 0, flags
);
359 fprintf_filtered (stream
, "(");
362 case TYPE_CODE_TYPEDEF
:
363 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
),
364 stream
, show
, passed_a_ptr
, 0, flags
);
367 case TYPE_CODE_UNDEF
:
368 case TYPE_CODE_STRUCT
:
369 case TYPE_CODE_UNION
:
374 case TYPE_CODE_ERROR
:
378 case TYPE_CODE_RANGE
:
379 case TYPE_CODE_STRING
:
380 case TYPE_CODE_COMPLEX
:
381 case TYPE_CODE_NAMESPACE
:
382 case TYPE_CODE_DECFLOAT
:
383 /* These types need no prefix. They are listed here so that
384 gcc -Wall will reveal any types that haven't been handled. */
387 error (_("type not handled in c_type_print_varspec_prefix()"));
392 /* Print out "const" and "volatile" attributes,
393 and address space id if present.
394 TYPE is a pointer to the type being printed out.
395 STREAM is the output destination.
396 NEED_PRE_SPACE = 1 indicates an initial white space is needed.
397 NEED_POST_SPACE = 1 indicates a final white space is needed. */
400 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
401 int need_pre_space
, int need_post_space
)
403 int did_print_modifier
= 0;
404 const char *address_space_id
;
406 /* We don't print `const' qualifiers for references --- since all
407 operators affect the thing referenced, not the reference itself,
408 every reference is `const'. */
409 if (TYPE_CONST (type
)
410 && TYPE_CODE (type
) != TYPE_CODE_REF
)
413 fprintf_filtered (stream
, " ");
414 fprintf_filtered (stream
, "const");
415 did_print_modifier
= 1;
418 if (TYPE_VOLATILE (type
))
420 if (did_print_modifier
|| need_pre_space
)
421 fprintf_filtered (stream
, " ");
422 fprintf_filtered (stream
, "volatile");
423 did_print_modifier
= 1;
426 address_space_id
= address_space_int_to_name (get_type_arch (type
),
427 TYPE_INSTANCE_FLAGS (type
));
428 if (address_space_id
)
430 if (did_print_modifier
|| need_pre_space
)
431 fprintf_filtered (stream
, " ");
432 fprintf_filtered (stream
, "@%s", address_space_id
);
433 did_print_modifier
= 1;
436 if (did_print_modifier
&& need_post_space
)
437 fprintf_filtered (stream
, " ");
441 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
442 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
443 in non-static methods, are displayed if LINKAGE_NAME is zero. If
444 LINKAGE_NAME is non-zero and LANGUAGE is language_cplus the topmost
445 parameter types get removed their possible const and volatile qualifiers to
446 match demangled linkage name parameters part of such function type.
447 LANGUAGE is the language in which TYPE was defined. This is a necessary
448 evil since this code is used by the C, C++, and Java backends. */
451 c_type_print_args (struct type
*type
, struct ui_file
*stream
,
452 int linkage_name
, enum language language
,
453 const struct type_print_options
*flags
)
459 fprintf_filtered (stream
, "(");
460 args
= TYPE_FIELDS (type
);
461 len
= TYPE_NFIELDS (type
);
463 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
465 struct type
*param_type
;
467 if (TYPE_FIELD_ARTIFICIAL (type
, i
) && linkage_name
)
472 fprintf_filtered (stream
, ", ");
476 param_type
= TYPE_FIELD_TYPE (type
, i
);
478 if (language
== language_cplus
&& linkage_name
)
480 /* C++ standard, 13.1 Overloadable declarations, point 3, item:
481 - Parameter declarations that differ only in the presence or
482 absence of const and/or volatile are equivalent.
484 And the const/volatile qualifiers are not present in the mangled
485 names as produced by GCC. */
487 param_type
= make_cv_type (0, 0, param_type
, NULL
);
490 if (language
== language_java
)
491 java_print_type (param_type
, "", stream
, -1, 0, flags
);
493 c_print_type (param_type
, "", stream
, -1, 0, flags
);
497 if (printed_any
&& TYPE_VARARGS (type
))
499 /* Print out a trailing ellipsis for varargs functions. Ignore
500 TYPE_VARARGS if the function has no named arguments; that
501 represents unprototyped (K&R style) C functions. */
502 if (printed_any
&& TYPE_VARARGS (type
))
504 fprintf_filtered (stream
, ", ");
506 fprintf_filtered (stream
, "...");
509 else if (!printed_any
510 && ((TYPE_PROTOTYPED (type
) && language
!= language_java
)
511 || language
== language_cplus
))
512 fprintf_filtered (stream
, "void");
514 fprintf_filtered (stream
, ")");
517 /* Return true iff the j'th overloading of the i'th method of TYPE
518 is a type conversion operator, like `operator int () { ... }'.
519 When listing a class's methods, we don't print the return type of
523 is_type_conversion_operator (struct type
*type
, int i
, int j
)
525 /* I think the whole idea of recognizing type conversion operators
526 by their name is pretty terrible. But I don't think our present
527 data structure gives us any other way to tell. If you know of
528 some other way, feel free to rewrite this function. */
529 const char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
531 if (strncmp (name
, "operator", 8) != 0)
535 if (! strchr (" \t\f\n\r", *name
))
538 while (strchr (" \t\f\n\r", *name
))
541 if (!('a' <= *name
&& *name
<= 'z')
542 && !('A' <= *name
&& *name
<= 'Z')
544 /* If this doesn't look like the start of an identifier, then it
545 isn't a type conversion operator. */
547 else if (strncmp (name
, "new", 3) == 0)
549 else if (strncmp (name
, "delete", 6) == 0)
552 /* If it doesn't look like new or delete, it's a type conversion
556 /* Is that really the end of the name? */
557 if (('a' <= *name
&& *name
<= 'z')
558 || ('A' <= *name
&& *name
<= 'Z')
559 || ('0' <= *name
&& *name
<= '9')
561 /* No, so the identifier following "operator" must be a type name,
562 and this is a type conversion operator. */
565 /* That was indeed the end of the name, so it was `operator new' or
566 `operator delete', neither of which are type conversion
571 /* Given a C++ qualified identifier QID, strip off the qualifiers,
572 yielding the unqualified name. The return value is a pointer into
575 It's a pity we don't have this information in some more structured
576 form. Even the author of this function feels that writing little
577 parsers like this everywhere is stupid. */
580 remove_qualifiers (char *qid
)
582 int quoted
= 0; /* Zero if we're not in quotes;
583 '"' if we're in a double-quoted string;
584 '\'' if we're in a single-quoted string. */
585 int depth
= 0; /* Number of unclosed parens we've seen. */
586 char *parenstack
= (char *) alloca (strlen (qid
));
588 char *last
= 0; /* The character after the rightmost
589 `::' token we've seen so far. */
591 for (scan
= qid
; *scan
; scan
++)
597 else if (*scan
== '\\' && *(scan
+ 1))
600 else if (scan
[0] == ':' && scan
[1] == ':')
602 /* If we're inside parenthesis (i.e., an argument list) or
603 angle brackets (i.e., a list of template arguments), then
604 we don't record the position of this :: token, since it's
605 not relevant to the top-level structure we're trying to
613 else if (*scan
== '"' || *scan
== '\'')
615 else if (*scan
== '(')
616 parenstack
[depth
++] = ')';
617 else if (*scan
== '[')
618 parenstack
[depth
++] = ']';
619 /* We're going to treat <> as a pair of matching characters,
620 since we're more likely to see those in template id's than
621 real less-than characters. What a crock. */
622 else if (*scan
== '<')
623 parenstack
[depth
++] = '>';
624 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
626 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
630 /* We're going to do a little error recovery here. If
631 we don't find a match for *scan on the paren stack,
632 but there is something lower on the stack that does
633 match, we pop the stack to that point. */
636 for (i
= depth
- 1; i
>= 0; i
--)
637 if (parenstack
[i
] == *scan
)
649 /* We didn't find any :: tokens at the top level, so declare the
650 whole thing an unqualified identifier. */
654 /* Print any array sizes, function arguments or close parentheses
655 needed after the variable name (to describe its type).
656 Args work like c_type_print_varspec_prefix. */
659 c_type_print_varspec_suffix (struct type
*type
,
660 struct ui_file
*stream
,
661 int show
, int passed_a_ptr
,
663 const struct type_print_options
*flags
)
668 if (TYPE_NAME (type
) && show
<= 0)
673 switch (TYPE_CODE (type
))
675 case TYPE_CODE_ARRAY
:
677 LONGEST low_bound
, high_bound
;
678 int is_vector
= TYPE_VECTOR (type
);
681 fprintf_filtered (stream
, ")");
683 fprintf_filtered (stream
, (is_vector
?
684 " __attribute__ ((vector_size(" : "["));
685 if (get_array_bounds (type
, &low_bound
, &high_bound
))
686 fprintf_filtered (stream
, "%s",
687 plongest (high_bound
- low_bound
+ 1));
688 fprintf_filtered (stream
, (is_vector
? ")))" : "]"));
690 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
695 case TYPE_CODE_MEMBERPTR
:
696 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
700 case TYPE_CODE_METHODPTR
:
701 fprintf_filtered (stream
, ")");
702 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
708 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
712 case TYPE_CODE_METHOD
:
715 fprintf_filtered (stream
, ")");
717 c_type_print_args (type
, stream
, 0, current_language
->la_language
,
719 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
720 show
, passed_a_ptr
, 0, flags
);
723 case TYPE_CODE_TYPEDEF
:
724 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
,
725 show
, passed_a_ptr
, 0, flags
);
728 case TYPE_CODE_UNDEF
:
729 case TYPE_CODE_STRUCT
:
730 case TYPE_CODE_UNION
:
735 case TYPE_CODE_ERROR
:
739 case TYPE_CODE_RANGE
:
740 case TYPE_CODE_STRING
:
741 case TYPE_CODE_COMPLEX
:
742 case TYPE_CODE_NAMESPACE
:
743 case TYPE_CODE_DECFLOAT
:
744 /* These types do not need a suffix. They are listed so that
745 gcc -Wall will report types that may not have been
749 error (_("type not handled in c_type_print_varspec_suffix()"));
754 /* A helper for c_type_print_base that displays template
755 parameters and their bindings, if needed.
757 TABLE is the local bindings table to use. If NULL, no printing is
758 done. Note that, at this point, TABLE won't have any useful
759 information in it -- but it is also used as a flag to
760 print_name_maybe_canonical to activate searching the global typedef
763 TYPE is the type whose template arguments are being displayed.
765 STREAM is the stream on which to print. */
768 c_type_print_template_args (const struct type_print_options
*flags
,
769 struct type
*type
, struct ui_file
*stream
)
776 for (i
= 0; i
< TYPE_N_TEMPLATE_ARGUMENTS (type
); ++i
)
778 struct symbol
*sym
= TYPE_TEMPLATE_ARGUMENT (type
, i
);
780 if (SYMBOL_CLASS (sym
) != LOC_TYPEDEF
)
786 fprintf_filtered (stream
, _("[with %s = "),
787 SYMBOL_LINKAGE_NAME (sym
));
792 fputs_filtered (", ", stream
);
794 fprintf_filtered (stream
, "%s = ", SYMBOL_LINKAGE_NAME (sym
));
797 c_print_type (SYMBOL_TYPE (sym
), "", stream
, -1, 0, flags
);
801 fputs_filtered (_("] "), stream
);
804 /* Print the name of the type (or the ultimate pointer target,
805 function value or array element), or the description of a structure
808 SHOW positive means print details about the type (e.g. enum
809 values), and print structure elements passing SHOW - 1 for show.
811 SHOW negative means just print the type name or struct tag if there
812 is one. If there is no name, print something sensible but concise
815 SHOW zero means just print the type name or struct tag if there is
816 one. If there is no name, print something sensible but not as
817 concise like "struct {int x; int y;}".
819 LEVEL is the number of spaces to indent by.
820 We increase it for some recursive calls. */
823 c_type_print_base (struct type
*type
, struct ui_file
*stream
,
824 int show
, int level
, const struct type_print_options
*flags
)
830 s_none
, s_public
, s_private
, s_protected
833 int need_access_label
= 0;
840 fputs_filtered (_("<type unknown>"), stream
);
844 /* When SHOW is zero or less, and there is a valid type name, then
845 always just print the type name directly from the type. */
846 /* If we have "typedef struct foo {. . .} bar;" do we want to print
847 it as "struct foo" or as "bar"? Pick the latter, because C++
848 folk tend to expect things like "class5 *foo" rather than "struct
852 && TYPE_NAME (type
) != NULL
)
854 c_type_print_modifier (type
, stream
, 0, 1);
855 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
859 CHECK_TYPEDEF (type
);
861 switch (TYPE_CODE (type
))
863 case TYPE_CODE_TYPEDEF
:
864 /* If we get here, the typedef doesn't have a name, and we
865 couldn't resolve TYPE_TARGET_TYPE. Not much we can do. */
866 gdb_assert (TYPE_NAME (type
) == NULL
);
867 gdb_assert (TYPE_TARGET_TYPE (type
) == NULL
);
868 fprintf_filtered (stream
, _("<unnamed typedef>"));
871 case TYPE_CODE_ARRAY
:
873 case TYPE_CODE_MEMBERPTR
:
876 case TYPE_CODE_METHOD
:
877 case TYPE_CODE_METHODPTR
:
878 c_type_print_base (TYPE_TARGET_TYPE (type
),
879 stream
, show
, level
, flags
);
882 case TYPE_CODE_STRUCT
:
883 case TYPE_CODE_UNION
:
885 struct type_print_options local_flags
= *flags
;
886 struct type_print_options semi_local_flags
= *flags
;
887 struct cleanup
*local_cleanups
= make_cleanup (null_cleanup
, NULL
);
889 local_flags
.local_typedefs
= NULL
;
890 semi_local_flags
.local_typedefs
= NULL
;
894 if (flags
->local_typedefs
)
895 local_flags
.local_typedefs
896 = copy_typedef_hash (flags
->local_typedefs
);
898 local_flags
.local_typedefs
= create_typedef_hash ();
900 make_cleanup_free_typedef_hash (local_flags
.local_typedefs
);
903 c_type_print_modifier (type
, stream
, 0, 1);
904 if (TYPE_CODE (type
) == TYPE_CODE_UNION
)
905 fprintf_filtered (stream
, "union ");
906 else if (TYPE_DECLARED_CLASS (type
))
907 fprintf_filtered (stream
, "class ");
909 fprintf_filtered (stream
, "struct ");
911 /* Print the tag if it exists. The HP aCC compiler emits a
912 spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
913 enum}" tag for unnamed struct/union/enum's, which we don't
915 if (TYPE_TAG_NAME (type
) != NULL
916 && strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
918 /* When printing the tag name, we are still effectively
919 printing in the outer context, hence the use of FLAGS
921 print_name_maybe_canonical (TYPE_TAG_NAME (type
), flags
, stream
);
923 fputs_filtered (" ", stream
);
928 /* If we just printed a tag name, no need to print anything
930 if (TYPE_TAG_NAME (type
) == NULL
)
931 fprintf_filtered (stream
, "{...}");
933 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
935 struct type
*basetype
;
938 c_type_print_template_args (&local_flags
, type
, stream
);
940 /* Add in template parameters when printing derivation info. */
941 add_template_parameters (local_flags
.local_typedefs
, type
);
942 cp_type_print_derivation_info (stream
, type
, &local_flags
);
944 /* This holds just the global typedefs and the template
946 semi_local_flags
.local_typedefs
947 = copy_typedef_hash (local_flags
.local_typedefs
);
948 if (semi_local_flags
.local_typedefs
)
949 make_cleanup_free_typedef_hash (semi_local_flags
.local_typedefs
);
951 /* Now add in the local typedefs. */
952 recursively_update_typedef_hash (local_flags
.local_typedefs
, type
);
954 fprintf_filtered (stream
, "{\n");
955 if (TYPE_NFIELDS (type
) == 0 && TYPE_NFN_FIELDS (type
) == 0
956 && TYPE_TYPEDEF_FIELD_COUNT (type
) == 0)
958 if (TYPE_STUB (type
))
959 fprintfi_filtered (level
+ 4, stream
,
960 _("<incomplete type>\n"));
962 fprintfi_filtered (level
+ 4, stream
,
963 _("<no data fields>\n"));
966 /* Start off with no specific section type, so we can print
967 one for the first field we find, and use that section type
968 thereafter until we find another type. */
970 section_type
= s_none
;
972 /* For a class, if all members are private, there's no need
973 for a "private:" label; similarly, for a struct or union
974 masquerading as a class, if all members are public, there's
975 no need for a "public:" label. */
977 if (TYPE_DECLARED_CLASS (type
))
980 len
= TYPE_NFIELDS (type
);
981 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
982 if (!TYPE_FIELD_PRIVATE (type
, i
))
984 need_access_label
= 1;
988 if (!need_access_label
)
990 len2
= TYPE_NFN_FIELDS (type
);
991 for (j
= 0; j
< len2
; j
++)
993 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
994 for (i
= 0; i
< len
; i
++)
995 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
,
998 need_access_label
= 1;
1001 if (need_access_label
)
1009 len
= TYPE_NFIELDS (type
);
1010 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
1011 if (TYPE_FIELD_PRIVATE (type
, i
)
1012 || TYPE_FIELD_PROTECTED (type
, i
))
1014 need_access_label
= 1;
1018 if (!need_access_label
)
1020 len2
= TYPE_NFN_FIELDS (type
);
1021 for (j
= 0; j
< len2
; j
++)
1024 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
1025 for (i
= 0; i
< len
; i
++)
1026 if (TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
,
1028 || TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
,
1032 need_access_label
= 1;
1035 if (need_access_label
)
1041 /* If there is a base class for this type,
1042 do not print the field that it occupies. */
1044 len
= TYPE_NFIELDS (type
);
1045 vptr_fieldno
= get_vptr_fieldno (type
, &basetype
);
1046 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
1050 /* If we have a virtual table pointer, omit it. Even if
1051 virtual table pointers are not specifically marked in
1052 the debug info, they should be artificial. */
1053 if ((i
== vptr_fieldno
&& type
== basetype
)
1054 || TYPE_FIELD_ARTIFICIAL (type
, i
))
1057 if (need_access_label
)
1059 if (TYPE_FIELD_PROTECTED (type
, i
))
1061 if (section_type
!= s_protected
)
1063 section_type
= s_protected
;
1064 fprintfi_filtered (level
+ 2, stream
,
1068 else if (TYPE_FIELD_PRIVATE (type
, i
))
1070 if (section_type
!= s_private
)
1072 section_type
= s_private
;
1073 fprintfi_filtered (level
+ 2, stream
,
1079 if (section_type
!= s_public
)
1081 section_type
= s_public
;
1082 fprintfi_filtered (level
+ 2, stream
,
1088 print_spaces_filtered (level
+ 4, stream
);
1089 if (field_is_static (&TYPE_FIELD (type
, i
)))
1090 fprintf_filtered (stream
, "static ");
1091 c_print_type (TYPE_FIELD_TYPE (type
, i
),
1092 TYPE_FIELD_NAME (type
, i
),
1093 stream
, show
- 1, level
+ 4,
1095 if (!field_is_static (&TYPE_FIELD (type
, i
))
1096 && TYPE_FIELD_PACKED (type
, i
))
1098 /* It is a bitfield. This code does not attempt
1099 to look at the bitpos and reconstruct filler,
1100 unnamed fields. This would lead to misleading
1101 results if the compiler does not put out fields
1102 for such things (I don't know what it does). */
1103 fprintf_filtered (stream
, " : %d",
1104 TYPE_FIELD_BITSIZE (type
, i
));
1106 fprintf_filtered (stream
, ";\n");
1109 /* If there are both fields and methods, put a blank line
1110 between them. Make sure to count only method that we
1111 will display; artificial methods will be hidden. */
1112 len
= TYPE_NFN_FIELDS (type
);
1113 if (!flags
->print_methods
)
1116 for (i
= 0; i
< len
; i
++)
1118 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1119 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
1122 for (j
= 0; j
< len2
; j
++)
1123 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
1126 if (real_len
> 0 && section_type
!= s_none
)
1127 fprintf_filtered (stream
, "\n");
1129 /* C++: print out the methods. */
1130 for (i
= 0; i
< len
; i
++)
1132 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
1133 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
1134 const char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
1135 const char *name
= type_name_no_tag (type
);
1136 int is_constructor
= name
&& strcmp (method_name
,
1139 for (j
= 0; j
< len2
; j
++)
1141 const char *mangled_name
;
1142 char *demangled_name
;
1143 struct cleanup
*inner_cleanup
;
1144 const char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1145 int is_full_physname_constructor
=
1146 is_constructor_name (physname
)
1147 || is_destructor_name (physname
)
1148 || method_name
[0] == '~';
1150 /* Do not print out artificial methods. */
1151 if (TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
1154 inner_cleanup
= make_cleanup (null_cleanup
, NULL
);
1157 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
1159 if (section_type
!= s_protected
)
1161 section_type
= s_protected
;
1162 fprintfi_filtered (level
+ 2, stream
,
1166 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
1168 if (section_type
!= s_private
)
1170 section_type
= s_private
;
1171 fprintfi_filtered (level
+ 2, stream
,
1177 if (section_type
!= s_public
)
1179 section_type
= s_public
;
1180 fprintfi_filtered (level
+ 2, stream
,
1185 print_spaces_filtered (level
+ 4, stream
);
1186 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
1187 fprintf_filtered (stream
, "virtual ");
1188 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
1189 fprintf_filtered (stream
, "static ");
1190 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
1192 /* Keep GDB from crashing here. */
1193 fprintf_filtered (stream
,
1194 _("<undefined type> %s;\n"),
1195 TYPE_FN_FIELD_PHYSNAME (f
, j
));
1198 else if (!is_constructor
/* Constructors don't
1201 && !is_full_physname_constructor
/* " " */
1202 && !is_type_conversion_operator (type
, i
, j
))
1204 c_print_type (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
1207 fputs_filtered (" ", stream
);
1209 if (TYPE_FN_FIELD_STUB (f
, j
))
1213 /* Build something we can demangle. */
1214 tem
= gdb_mangle_name (type
, i
, j
);
1215 make_cleanup (xfree
, tem
);
1219 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1222 cplus_demangle (mangled_name
,
1223 DMGL_ANSI
| DMGL_PARAMS
);
1224 if (demangled_name
== NULL
)
1226 /* In some cases (for instance with the HP
1227 demangling), if a function has more than 10
1228 arguments, the demangling will fail.
1229 Let's try to reconstruct the function
1230 signature from the symbol information. */
1231 if (!TYPE_FN_FIELD_STUB (f
, j
))
1233 int staticp
= TYPE_FN_FIELD_STATIC_P (f
, j
);
1234 struct type
*mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1236 cp_type_print_method_args (mtype
,
1240 stream
, &local_flags
);
1243 fprintf_filtered (stream
,
1244 _("<badly mangled name '%s'>"),
1250 char *demangled_no_class
1251 = remove_qualifiers (demangled_name
);
1253 /* Get rid of the `static' appended by the
1255 p
= strstr (demangled_no_class
, " static");
1258 int length
= p
- demangled_no_class
;
1259 char *demangled_no_static
;
1262 = (char *) xmalloc (length
+ 1);
1263 strncpy (demangled_no_static
,
1264 demangled_no_class
, length
);
1265 *(demangled_no_static
+ length
) = '\0';
1266 fputs_filtered (demangled_no_static
, stream
);
1267 xfree (demangled_no_static
);
1270 fputs_filtered (demangled_no_class
, stream
);
1271 xfree (demangled_name
);
1274 do_cleanups (inner_cleanup
);
1276 fprintf_filtered (stream
, ";\n");
1280 /* Print typedefs defined in this class. */
1282 if (TYPE_TYPEDEF_FIELD_COUNT (type
) != 0 && flags
->print_typedefs
)
1284 if (TYPE_NFIELDS (type
) != 0 || TYPE_NFN_FIELDS (type
) != 0)
1285 fprintf_filtered (stream
, "\n");
1287 for (i
= 0; i
< TYPE_TYPEDEF_FIELD_COUNT (type
); i
++)
1289 struct type
*target
= TYPE_TYPEDEF_FIELD_TYPE (type
, i
);
1290 struct typedef_hash_table
*table2
;
1292 /* Dereference the typedef declaration itself. */
1293 gdb_assert (TYPE_CODE (target
) == TYPE_CODE_TYPEDEF
);
1294 target
= TYPE_TARGET_TYPE (target
);
1296 print_spaces_filtered (level
+ 4, stream
);
1297 fprintf_filtered (stream
, "typedef ");
1299 /* We want to print typedefs with substitutions
1300 from the template parameters or globally-known
1301 typedefs but not local typedefs. */
1302 c_print_type (target
,
1303 TYPE_TYPEDEF_FIELD_NAME (type
, i
),
1304 stream
, show
- 1, level
+ 4,
1306 fprintf_filtered (stream
, ";\n");
1310 fprintfi_filtered (level
, stream
, "}");
1312 if (TYPE_LOCALTYPE_PTR (type
) && show
>= 0)
1313 fprintfi_filtered (level
,
1314 stream
, _(" (Local at %s:%d)\n"),
1315 TYPE_LOCALTYPE_FILE (type
),
1316 TYPE_LOCALTYPE_LINE (type
));
1319 do_cleanups (local_cleanups
);
1323 case TYPE_CODE_ENUM
:
1324 c_type_print_modifier (type
, stream
, 0, 1);
1325 fprintf_filtered (stream
, "enum ");
1326 /* Print the tag name if it exists.
1327 The aCC compiler emits a spurious
1328 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1329 tag for unnamed struct/union/enum's, which we don't
1331 if (TYPE_TAG_NAME (type
) != NULL
1332 && strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
1334 print_name_maybe_canonical (TYPE_TAG_NAME (type
), flags
, stream
);
1336 fputs_filtered (" ", stream
);
1342 /* If we just printed a tag name, no need to print anything
1344 if (TYPE_TAG_NAME (type
) == NULL
)
1345 fprintf_filtered (stream
, "{...}");
1347 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1349 LONGEST lastval
= 0;
1351 fprintf_filtered (stream
, "{");
1352 len
= TYPE_NFIELDS (type
);
1353 for (i
= 0; i
< len
; i
++)
1357 fprintf_filtered (stream
, ", ");
1359 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1360 if (lastval
!= TYPE_FIELD_ENUMVAL (type
, i
))
1362 fprintf_filtered (stream
, " = %s",
1363 plongest (TYPE_FIELD_ENUMVAL (type
, i
)));
1364 lastval
= TYPE_FIELD_ENUMVAL (type
, i
);
1368 fprintf_filtered (stream
, "}");
1372 case TYPE_CODE_VOID
:
1373 fprintf_filtered (stream
, "void");
1376 case TYPE_CODE_UNDEF
:
1377 fprintf_filtered (stream
, _("struct <unknown>"));
1380 case TYPE_CODE_ERROR
:
1381 fprintf_filtered (stream
, "%s", TYPE_ERROR_NAME (type
));
1384 case TYPE_CODE_RANGE
:
1385 /* This should not occur. */
1386 fprintf_filtered (stream
, _("<range type>"));
1389 case TYPE_CODE_NAMESPACE
:
1390 fputs_filtered ("namespace ", stream
);
1391 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1395 /* Handle types not explicitly handled by the other cases, such
1396 as fundamental types. For these, just print whatever the
1397 type name is, as recorded in the type itself. If there is no
1398 type name, then complain. */
1399 if (TYPE_NAME (type
) != NULL
)
1401 c_type_print_modifier (type
, stream
, 0, 1);
1402 print_name_maybe_canonical (TYPE_NAME (type
), flags
, stream
);
1406 /* At least for dump_symtab, it is important that this not
1408 fprintf_filtered (stream
, _("<invalid type code %d>"),