1 /* Support for printing C and C++ types for GDB, the GNU debugger.
2 Copyright (C) 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
3 1999, 2000, 2001, 2002, 2003, 2006, 2007, 2008, 2009
4 Free Software Foundation, Inc.
6 This file is part of GDB.
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 #include "gdb_obstack.h"
23 #include "bfd.h" /* Binary File Description */
26 #include "expression.h"
33 #include "typeprint.h"
36 #include "gdb_string.h"
39 static void cp_type_print_method_args (struct type
*mtype
, char *prefix
,
40 char *varstring
, int staticp
,
41 struct ui_file
*stream
);
43 static void c_type_print_args (struct type
*, struct ui_file
*);
45 static void cp_type_print_derivation_info (struct ui_file
*, struct type
*);
47 static void c_type_print_varspec_prefix (struct type
*, struct ui_file
*, int,
50 /* Print "const", "volatile", or address space modifiers. */
51 static void c_type_print_modifier (struct type
*, struct ui_file
*,
57 /* LEVEL is the depth to indent lines by. */
60 c_print_type (struct type
*type
, char *varstring
, struct ui_file
*stream
,
70 c_type_print_base (type
, stream
, show
, level
);
71 code
= TYPE_CODE (type
);
72 if ((varstring
!= NULL
&& *varstring
!= '\0')
73 /* Need a space if going to print stars or brackets;
74 but not if we will print just a type name. */
75 || ((show
> 0 || TYPE_NAME (type
) == 0)
76 && (code
== TYPE_CODE_PTR
|| code
== TYPE_CODE_FUNC
77 || code
== TYPE_CODE_METHOD
78 || code
== TYPE_CODE_ARRAY
79 || code
== TYPE_CODE_MEMBERPTR
80 || code
== TYPE_CODE_METHODPTR
81 || code
== TYPE_CODE_REF
)))
82 fputs_filtered (" ", stream
);
83 need_post_space
= (varstring
!= NULL
&& strcmp (varstring
, "") != 0);
84 c_type_print_varspec_prefix (type
, stream
, show
, 0, need_post_space
);
86 if (varstring
!= NULL
)
88 fputs_filtered (varstring
, stream
);
90 /* For demangled function names, we have the arglist as part of the name,
91 so don't print an additional pair of ()'s */
93 demangled_args
= strchr (varstring
, '(') != NULL
;
94 c_type_print_varspec_suffix (type
, stream
, show
, 0, demangled_args
);
98 /* Print a typedef using C syntax. TYPE is the underlying type.
99 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
103 c_print_typedef (struct type
*type
, struct symbol
*new_symbol
,
104 struct ui_file
*stream
)
106 CHECK_TYPEDEF (type
);
107 fprintf_filtered (stream
, "typedef ");
108 type_print (type
, "", stream
, 0);
109 if (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))) == 0
110 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol
))),
111 SYMBOL_LINKAGE_NAME (new_symbol
)) != 0)
112 fprintf_filtered (stream
, " %s", SYMBOL_PRINT_NAME (new_symbol
));
113 fprintf_filtered (stream
, ";\n");
116 /* If TYPE is a derived type, then print out derivation information.
117 Print only the actual base classes of this type, not the base classes
118 of the base classes. I.E. for the derivation hierarchy:
121 class B : public A {int b; };
122 class C : public B {int c; };
124 Print the type of class C as:
130 Not as the following (like gdb used to), which is not legal C++ syntax for
131 derived types and may be confused with the multiple inheritance form:
133 class C : public B : public A {
137 In general, gdb should try to print the types as closely as possible to
138 the form that they appear in the source code.
139 Note that in case of protected derivation gcc will not say 'protected'
140 but 'private'. The HP's aCC compiler emits specific information for
141 derivation via protected inheritance, so gdb can print it out */
144 cp_type_print_derivation_info (struct ui_file
*stream
, struct type
*type
)
149 for (i
= 0; i
< TYPE_N_BASECLASSES (type
); i
++)
151 fputs_filtered (i
== 0 ? ": " : ", ", stream
);
152 fprintf_filtered (stream
, "%s%s ",
153 BASETYPE_VIA_PUBLIC (type
, i
) ? "public"
154 : (TYPE_FIELD_PROTECTED (type
, i
) ? "protected" : "private"),
155 BASETYPE_VIA_VIRTUAL (type
, i
) ? " virtual" : "");
156 name
= type_name_no_tag (TYPE_BASECLASS (type
, i
));
157 fprintf_filtered (stream
, "%s", name
? name
: "(null)");
161 fputs_filtered (" ", stream
);
165 /* Print the C++ method arguments ARGS to the file STREAM. */
168 cp_type_print_method_args (struct type
*mtype
, char *prefix
, char *varstring
,
169 int staticp
, struct ui_file
*stream
)
171 struct field
*args
= TYPE_FIELDS (mtype
);
172 int nargs
= TYPE_NFIELDS (mtype
);
173 int varargs
= TYPE_VARARGS (mtype
);
176 fprintf_symbol_filtered (stream
, prefix
, language_cplus
, DMGL_ANSI
);
177 fprintf_symbol_filtered (stream
, varstring
, language_cplus
, DMGL_ANSI
);
178 fputs_filtered ("(", stream
);
180 /* Skip the class variable. */
186 type_print (args
[i
++].type
, "", stream
, 0);
188 if (i
== nargs
&& varargs
)
189 fprintf_filtered (stream
, ", ...");
191 fprintf_filtered (stream
, ", ");
195 fprintf_filtered (stream
, "...");
196 else if (current_language
->la_language
== language_cplus
)
197 fprintf_filtered (stream
, "void");
199 fprintf_filtered (stream
, ")");
203 /* Print any asterisks or open-parentheses needed before the
204 variable name (to describe its type).
206 On outermost call, pass 0 for PASSED_A_PTR.
207 On outermost call, SHOW > 0 means should ignore
208 any typename for TYPE and show its details.
209 SHOW is always zero on recursive calls.
211 NEED_POST_SPACE is non-zero when a space will be be needed
212 between a trailing qualifier and a field, variable, or function
216 c_type_print_varspec_prefix (struct type
*type
, struct ui_file
*stream
,
217 int show
, int passed_a_ptr
, int need_post_space
)
223 if (TYPE_NAME (type
) && show
<= 0)
228 switch (TYPE_CODE (type
))
231 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 1, 1);
232 fprintf_filtered (stream
, "*");
233 c_type_print_modifier (type
, stream
, 1, need_post_space
);
236 case TYPE_CODE_MEMBERPTR
:
237 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
238 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
240 fputs_filtered (name
, stream
);
242 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
243 fprintf_filtered (stream
, "::*");
246 case TYPE_CODE_METHODPTR
:
247 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
248 fprintf_filtered (stream
, "(");
249 name
= type_name_no_tag (TYPE_DOMAIN_TYPE (type
));
251 fputs_filtered (name
, stream
);
253 c_type_print_base (TYPE_DOMAIN_TYPE (type
), stream
, 0, passed_a_ptr
);
254 fprintf_filtered (stream
, "::*");
258 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 1, 0);
259 fprintf_filtered (stream
, "&");
260 c_type_print_modifier (type
, stream
, 1, need_post_space
);
263 case TYPE_CODE_METHOD
:
265 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
267 fprintf_filtered (stream
, "(");
270 case TYPE_CODE_ARRAY
:
271 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
273 fprintf_filtered (stream
, "(");
276 case TYPE_CODE_TYPEDEF
:
277 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type
), stream
, show
, 0, 0);
280 case TYPE_CODE_UNDEF
:
281 case TYPE_CODE_STRUCT
:
282 case TYPE_CODE_UNION
:
287 case TYPE_CODE_ERROR
:
291 case TYPE_CODE_RANGE
:
292 case TYPE_CODE_STRING
:
293 case TYPE_CODE_BITSTRING
:
294 case TYPE_CODE_COMPLEX
:
295 case TYPE_CODE_TEMPLATE
:
296 case TYPE_CODE_NAMESPACE
:
297 case TYPE_CODE_DECFLOAT
:
298 /* These types need no prefix. They are listed here so that
299 gcc -Wall will reveal any types that haven't been handled. */
302 error (_("type not handled in c_type_print_varspec_prefix()"));
307 /* Print out "const" and "volatile" attributes.
308 TYPE is a pointer to the type being printed out.
309 STREAM is the output destination.
310 NEED_SPACE = 1 indicates an initial white space is needed */
313 c_type_print_modifier (struct type
*type
, struct ui_file
*stream
,
314 int need_pre_space
, int need_post_space
)
316 int did_print_modifier
= 0;
317 const char *address_space_id
;
319 /* We don't print `const' qualifiers for references --- since all
320 operators affect the thing referenced, not the reference itself,
321 every reference is `const'. */
322 if (TYPE_CONST (type
)
323 && TYPE_CODE (type
) != TYPE_CODE_REF
)
326 fprintf_filtered (stream
, " ");
327 fprintf_filtered (stream
, "const");
328 did_print_modifier
= 1;
331 if (TYPE_VOLATILE (type
))
333 if (did_print_modifier
|| need_pre_space
)
334 fprintf_filtered (stream
, " ");
335 fprintf_filtered (stream
, "volatile");
336 did_print_modifier
= 1;
339 address_space_id
= address_space_int_to_name (get_type_arch (type
),
340 TYPE_INSTANCE_FLAGS (type
));
341 if (address_space_id
)
343 if (did_print_modifier
|| need_pre_space
)
344 fprintf_filtered (stream
, " ");
345 fprintf_filtered (stream
, "@%s", address_space_id
);
346 did_print_modifier
= 1;
349 if (did_print_modifier
&& need_post_space
)
350 fprintf_filtered (stream
, " ");
354 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
355 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
356 in non-static methods, are displayed. */
359 c_type_print_args (struct type
*type
, struct ui_file
*stream
)
365 fprintf_filtered (stream
, "(");
366 args
= TYPE_FIELDS (type
);
367 len
= TYPE_NFIELDS (type
);
369 for (i
= 0; i
< TYPE_NFIELDS (type
); i
++)
373 fprintf_filtered (stream
, ", ");
377 c_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
381 if (printed_any
&& TYPE_VARARGS (type
))
383 /* Print out a trailing ellipsis for varargs functions. Ignore
384 TYPE_VARARGS if the function has no named arguments; that
385 represents unprototyped (K&R style) C functions. */
386 if (printed_any
&& TYPE_VARARGS (type
))
388 fprintf_filtered (stream
, ", ");
390 fprintf_filtered (stream
, "...");
393 else if (!printed_any
394 && (TYPE_PROTOTYPED (type
)
395 || current_language
->la_language
== language_cplus
))
396 fprintf_filtered (stream
, "void");
398 fprintf_filtered (stream
, ")");
402 /* Return true iff the j'th overloading of the i'th method of TYPE
403 is a type conversion operator, like `operator int () { ... }'.
404 When listing a class's methods, we don't print the return type of
407 is_type_conversion_operator (struct type
*type
, int i
, int j
)
409 /* I think the whole idea of recognizing type conversion operators
410 by their name is pretty terrible. But I don't think our present
411 data structure gives us any other way to tell. If you know of
412 some other way, feel free to rewrite this function. */
413 char *name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
415 if (strncmp (name
, "operator", 8) != 0)
419 if (! strchr (" \t\f\n\r", *name
))
422 while (strchr (" \t\f\n\r", *name
))
425 if (!('a' <= *name
&& *name
<= 'z')
426 && !('A' <= *name
&& *name
<= 'Z')
428 /* If this doesn't look like the start of an identifier, then it
429 isn't a type conversion operator. */
431 else if (strncmp (name
, "new", 3) == 0)
433 else if (strncmp (name
, "delete", 6) == 0)
436 /* If it doesn't look like new or delete, it's a type conversion
440 /* Is that really the end of the name? */
441 if (('a' <= *name
&& *name
<= 'z')
442 || ('A' <= *name
&& *name
<= 'Z')
443 || ('0' <= *name
&& *name
<= '9')
445 /* No, so the identifier following "operator" must be a type name,
446 and this is a type conversion operator. */
449 /* That was indeed the end of the name, so it was `operator new' or
450 `operator delete', neither of which are type conversion operators. */
455 /* Given a C++ qualified identifier QID, strip off the qualifiers,
456 yielding the unqualified name. The return value is a pointer into
459 It's a pity we don't have this information in some more structured
460 form. Even the author of this function feels that writing little
461 parsers like this everywhere is stupid. */
463 remove_qualifiers (char *qid
)
465 int quoted
= 0; /* zero if we're not in quotes;
466 '"' if we're in a double-quoted string;
467 '\'' if we're in a single-quoted string. */
468 int depth
= 0; /* number of unclosed parens we've seen */
469 char *parenstack
= (char *) alloca (strlen (qid
));
471 char *last
= 0; /* The character after the rightmost
472 `::' token we've seen so far. */
474 for (scan
= qid
; *scan
; scan
++)
480 else if (*scan
== '\\' && *(scan
+ 1))
483 else if (scan
[0] == ':' && scan
[1] == ':')
485 /* If we're inside parenthesis (i.e., an argument list) or
486 angle brackets (i.e., a list of template arguments), then
487 we don't record the position of this :: token, since it's
488 not relevant to the top-level structure we're trying
496 else if (*scan
== '"' || *scan
== '\'')
498 else if (*scan
== '(')
499 parenstack
[depth
++] = ')';
500 else if (*scan
== '[')
501 parenstack
[depth
++] = ']';
502 /* We're going to treat <> as a pair of matching characters,
503 since we're more likely to see those in template id's than
504 real less-than characters. What a crock. */
505 else if (*scan
== '<')
506 parenstack
[depth
++] = '>';
507 else if (*scan
== ')' || *scan
== ']' || *scan
== '>')
509 if (depth
> 0 && parenstack
[depth
- 1] == *scan
)
513 /* We're going to do a little error recovery here. If we
514 don't find a match for *scan on the paren stack, but
515 there is something lower on the stack that does match, we
516 pop the stack to that point. */
519 for (i
= depth
- 1; i
>= 0; i
--)
520 if (parenstack
[i
] == *scan
)
532 /* We didn't find any :: tokens at the top level, so declare the
533 whole thing an unqualified identifier. */
538 /* Print any array sizes, function arguments or close parentheses
539 needed after the variable name (to describe its type).
540 Args work like c_type_print_varspec_prefix. */
543 c_type_print_varspec_suffix (struct type
*type
, struct ui_file
*stream
,
544 int show
, int passed_a_ptr
, int demangled_args
)
549 if (TYPE_NAME (type
) && show
<= 0)
554 switch (TYPE_CODE (type
))
556 case TYPE_CODE_ARRAY
:
558 fprintf_filtered (stream
, ")");
560 fprintf_filtered (stream
, "[");
561 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0
562 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type
))
563 fprintf_filtered (stream
, "%d",
565 / TYPE_LENGTH (TYPE_TARGET_TYPE (type
))));
566 fprintf_filtered (stream
, "]");
568 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
572 case TYPE_CODE_MEMBERPTR
:
573 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
577 case TYPE_CODE_METHODPTR
:
578 fprintf_filtered (stream
, ")");
579 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
585 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
589 case TYPE_CODE_METHOD
:
592 fprintf_filtered (stream
, ")");
594 c_type_print_args (type
, stream
);
595 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
599 case TYPE_CODE_TYPEDEF
:
600 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type
), stream
, show
,
604 case TYPE_CODE_UNDEF
:
605 case TYPE_CODE_STRUCT
:
606 case TYPE_CODE_UNION
:
611 case TYPE_CODE_ERROR
:
615 case TYPE_CODE_RANGE
:
616 case TYPE_CODE_STRING
:
617 case TYPE_CODE_BITSTRING
:
618 case TYPE_CODE_COMPLEX
:
619 case TYPE_CODE_TEMPLATE
:
620 case TYPE_CODE_NAMESPACE
:
621 case TYPE_CODE_DECFLOAT
:
622 /* These types do not need a suffix. They are listed so that
623 gcc -Wall will report types that may not have been considered. */
626 error (_("type not handled in c_type_print_varspec_suffix()"));
631 /* Print the name of the type (or the ultimate pointer target,
632 function value or array element), or the description of a
635 SHOW positive means print details about the type (e.g. enum values),
636 and print structure elements passing SHOW - 1 for show.
637 SHOW negative means just print the type name or struct tag if there is one.
638 If there is no name, print something sensible but concise like
640 SHOW zero means just print the type name or struct tag if there is one.
641 If there is no name, print something sensible but not as concise like
642 "struct {int x; int y;}".
644 LEVEL is the number of spaces to indent by.
645 We increase it for some recursive calls. */
648 c_type_print_base (struct type
*type
, struct ui_file
*stream
, int show
,
655 char *demangled_name
;
656 char *demangled_no_static
;
659 s_none
, s_public
, s_private
, s_protected
662 int need_access_label
= 0;
670 fputs_filtered (_("<type unknown>"), stream
);
674 /* When SHOW is zero or less, and there is a valid type name, then always
675 just print the type name directly from the type. */
676 /* If we have "typedef struct foo {. . .} bar;" do we want to print it
677 as "struct foo" or as "bar"? Pick the latter, because C++ folk tend
678 to expect things like "class5 *foo" rather than "struct class5 *foo". */
681 && TYPE_NAME (type
) != NULL
)
683 c_type_print_modifier (type
, stream
, 0, 1);
684 fputs_filtered (TYPE_NAME (type
), stream
);
688 CHECK_TYPEDEF (type
);
690 switch (TYPE_CODE (type
))
692 case TYPE_CODE_TYPEDEF
:
693 case TYPE_CODE_ARRAY
:
695 case TYPE_CODE_MEMBERPTR
:
698 case TYPE_CODE_METHOD
:
699 case TYPE_CODE_METHODPTR
:
700 c_type_print_base (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
703 case TYPE_CODE_STRUCT
:
704 c_type_print_modifier (type
, stream
, 0, 1);
705 /* Note TYPE_CODE_STRUCT and TYPE_CODE_CLASS have the same value,
706 * so we use another means for distinguishing them.
708 if (HAVE_CPLUS_STRUCT (type
))
710 switch (TYPE_DECLARED_TYPE (type
))
712 case DECLARED_TYPE_CLASS
:
713 fprintf_filtered (stream
, "class ");
715 case DECLARED_TYPE_UNION
:
716 fprintf_filtered (stream
, "union ");
718 case DECLARED_TYPE_STRUCT
:
719 fprintf_filtered (stream
, "struct ");
722 /* If there is a CPLUS_STRUCT, assume class if not
723 * otherwise specified in the declared_type field.
725 fprintf_filtered (stream
, "class ");
731 /* If not CPLUS_STRUCT, then assume it's a C struct */
732 fprintf_filtered (stream
, "struct ");
736 case TYPE_CODE_UNION
:
737 c_type_print_modifier (type
, stream
, 0, 1);
738 fprintf_filtered (stream
, "union ");
742 /* Print the tag if it exists.
743 * The HP aCC compiler emits
744 * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
745 * tag for unnamed struct/union/enum's, which we don't
748 if (TYPE_TAG_NAME (type
) != NULL
749 && strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
751 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
753 fputs_filtered (" ", stream
);
758 /* If we just printed a tag name, no need to print anything else. */
759 if (TYPE_TAG_NAME (type
) == NULL
)
760 fprintf_filtered (stream
, "{...}");
762 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
764 cp_type_print_derivation_info (stream
, type
);
766 fprintf_filtered (stream
, "{\n");
767 if ((TYPE_NFIELDS (type
) == 0) && (TYPE_NFN_FIELDS (type
) == 0))
769 if (TYPE_STUB (type
))
770 fprintfi_filtered (level
+ 4, stream
, _("<incomplete type>\n"));
772 fprintfi_filtered (level
+ 4, stream
, _("<no data fields>\n"));
775 /* Start off with no specific section type, so we can print
776 one for the first field we find, and use that section type
777 thereafter until we find another type. */
779 section_type
= s_none
;
781 /* For a class, if all members are private, there's no need
782 for a "private:" label; similarly, for a struct or union
783 masquerading as a class, if all members are public, there's
784 no need for a "public:" label. */
786 if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_CLASS
)
787 || (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_TEMPLATE
))
790 len
= TYPE_NFIELDS (type
);
791 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
792 if (!TYPE_FIELD_PRIVATE (type
, i
))
794 need_access_label
= 1;
798 if (!need_access_label
)
800 len2
= TYPE_NFN_FIELDS (type
);
801 for (j
= 0; j
< len2
; j
++)
803 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
804 for (i
= 0; i
< len
; i
++)
805 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
))
807 need_access_label
= 1;
810 if (need_access_label
)
815 else if ((TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_STRUCT
)
816 || (TYPE_DECLARED_TYPE (type
) == DECLARED_TYPE_UNION
))
819 len
= TYPE_NFIELDS (type
);
820 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
821 if (TYPE_FIELD_PRIVATE (type
, i
) || TYPE_FIELD_PROTECTED (type
, i
))
823 need_access_label
= 1;
827 if (!need_access_label
)
829 len2
= TYPE_NFN_FIELDS (type
);
830 for (j
= 0; j
< len2
; j
++)
833 len
= TYPE_FN_FIELDLIST_LENGTH (type
, j
);
834 for (i
= 0; i
< len
; i
++)
835 if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type
, j
), i
)
836 || TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type
, j
), i
))
838 need_access_label
= 1;
841 if (need_access_label
)
847 /* If there is a base class for this type,
848 do not print the field that it occupies. */
850 len
= TYPE_NFIELDS (type
);
851 for (i
= TYPE_N_BASECLASSES (type
); i
< len
; i
++)
854 /* Don't print out virtual function table. */
855 if (strncmp (TYPE_FIELD_NAME (type
, i
), "_vptr", 5) == 0
856 && is_cplus_marker ((TYPE_FIELD_NAME (type
, i
))[5]))
859 /* If this is a C++ class we can print the various C++ section
862 if (HAVE_CPLUS_STRUCT (type
) && need_access_label
)
864 if (TYPE_FIELD_PROTECTED (type
, i
))
866 if (section_type
!= s_protected
)
868 section_type
= s_protected
;
869 fprintfi_filtered (level
+ 2, stream
,
873 else if (TYPE_FIELD_PRIVATE (type
, i
))
875 if (section_type
!= s_private
)
877 section_type
= s_private
;
878 fprintfi_filtered (level
+ 2, stream
, "private:\n");
883 if (section_type
!= s_public
)
885 section_type
= s_public
;
886 fprintfi_filtered (level
+ 2, stream
, "public:\n");
891 print_spaces_filtered (level
+ 4, stream
);
892 if (field_is_static (&TYPE_FIELD (type
, i
)))
893 fprintf_filtered (stream
, "static ");
894 c_print_type (TYPE_FIELD_TYPE (type
, i
),
895 TYPE_FIELD_NAME (type
, i
),
896 stream
, show
- 1, level
+ 4);
897 if (!field_is_static (&TYPE_FIELD (type
, i
))
898 && TYPE_FIELD_PACKED (type
, i
))
900 /* It is a bitfield. This code does not attempt
901 to look at the bitpos and reconstruct filler,
902 unnamed fields. This would lead to misleading
903 results if the compiler does not put out fields
904 for such things (I don't know what it does). */
905 fprintf_filtered (stream
, " : %d",
906 TYPE_FIELD_BITSIZE (type
, i
));
908 fprintf_filtered (stream
, ";\n");
911 /* If there are both fields and methods, put a blank line
912 between them. Make sure to count only method that we will
913 display; artificial methods will be hidden. */
914 len
= TYPE_NFN_FIELDS (type
);
916 for (i
= 0; i
< len
; i
++)
918 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
919 int len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
921 for (j
= 0; j
< len2
; j
++)
922 if (!TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
925 if (real_len
> 0 && section_type
!= s_none
)
926 fprintf_filtered (stream
, "\n");
928 /* C++: print out the methods */
929 for (i
= 0; i
< len
; i
++)
931 struct fn_field
*f
= TYPE_FN_FIELDLIST1 (type
, i
);
932 int j
, len2
= TYPE_FN_FIELDLIST_LENGTH (type
, i
);
933 char *method_name
= TYPE_FN_FIELDLIST_NAME (type
, i
);
934 char *name
= type_name_no_tag (type
);
935 int is_constructor
= name
&& strcmp (method_name
, name
) == 0;
936 for (j
= 0; j
< len2
; j
++)
938 char *physname
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
939 int is_full_physname_constructor
=
940 is_constructor_name (physname
)
941 || is_destructor_name (physname
)
942 || method_name
[0] == '~';
944 /* Do not print out artificial methods. */
945 if (TYPE_FN_FIELD_ARTIFICIAL (f
, j
))
949 if (TYPE_FN_FIELD_PROTECTED (f
, j
))
951 if (section_type
!= s_protected
)
953 section_type
= s_protected
;
954 fprintfi_filtered (level
+ 2, stream
,
958 else if (TYPE_FN_FIELD_PRIVATE (f
, j
))
960 if (section_type
!= s_private
)
962 section_type
= s_private
;
963 fprintfi_filtered (level
+ 2, stream
, "private:\n");
968 if (section_type
!= s_public
)
970 section_type
= s_public
;
971 fprintfi_filtered (level
+ 2, stream
, "public:\n");
975 print_spaces_filtered (level
+ 4, stream
);
976 if (TYPE_FN_FIELD_VIRTUAL_P (f
, j
))
977 fprintf_filtered (stream
, "virtual ");
978 else if (TYPE_FN_FIELD_STATIC_P (f
, j
))
979 fprintf_filtered (stream
, "static ");
980 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)) == 0)
982 /* Keep GDB from crashing here. */
983 fprintf_filtered (stream
, _("<undefined type> %s;\n"),
984 TYPE_FN_FIELD_PHYSNAME (f
, j
));
987 else if (!is_constructor
/* constructors don't have declared types */
988 && !is_full_physname_constructor
/* " " */
989 && !is_type_conversion_operator (type
, i
, j
))
991 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f
, j
)),
993 fputs_filtered (" ", stream
);
995 if (TYPE_FN_FIELD_STUB (f
, j
))
996 /* Build something we can demangle. */
997 mangled_name
= gdb_mangle_name (type
, i
, j
);
999 mangled_name
= TYPE_FN_FIELD_PHYSNAME (f
, j
);
1002 cplus_demangle (mangled_name
,
1003 DMGL_ANSI
| DMGL_PARAMS
);
1004 if (demangled_name
== NULL
)
1006 /* in some cases (for instance with the HP demangling),
1007 if a function has more than 10 arguments,
1008 the demangling will fail.
1009 Let's try to reconstruct the function signature from
1010 the symbol information */
1011 if (!TYPE_FN_FIELD_STUB (f
, j
))
1013 int staticp
= TYPE_FN_FIELD_STATIC_P (f
, j
);
1014 struct type
*mtype
= TYPE_FN_FIELD_TYPE (f
, j
);
1015 cp_type_print_method_args (mtype
,
1022 fprintf_filtered (stream
, _("<badly mangled name '%s'>"),
1028 char *demangled_no_class
1029 = remove_qualifiers (demangled_name
);
1031 /* get rid of the `static' appended by the demangler */
1032 p
= strstr (demangled_no_class
, " static");
1035 int length
= p
- demangled_no_class
;
1036 demangled_no_static
= (char *) xmalloc (length
+ 1);
1037 strncpy (demangled_no_static
, demangled_no_class
, length
);
1038 *(demangled_no_static
+ length
) = '\0';
1039 fputs_filtered (demangled_no_static
, stream
);
1040 xfree (demangled_no_static
);
1043 fputs_filtered (demangled_no_class
, stream
);
1044 xfree (demangled_name
);
1047 if (TYPE_FN_FIELD_STUB (f
, j
))
1048 xfree (mangled_name
);
1050 fprintf_filtered (stream
, ";\n");
1054 fprintfi_filtered (level
, stream
, "}");
1056 if (TYPE_LOCALTYPE_PTR (type
) && show
>= 0)
1057 fprintfi_filtered (level
, stream
, _(" (Local at %s:%d)\n"),
1058 TYPE_LOCALTYPE_FILE (type
),
1059 TYPE_LOCALTYPE_LINE (type
));
1063 case TYPE_CODE_ENUM
:
1064 c_type_print_modifier (type
, stream
, 0, 1);
1065 fprintf_filtered (stream
, "enum ");
1066 /* Print the tag name if it exists.
1067 The aCC compiler emits a spurious
1068 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1069 tag for unnamed struct/union/enum's, which we don't
1071 if (TYPE_TAG_NAME (type
) != NULL
1072 && strncmp (TYPE_TAG_NAME (type
), "{unnamed", 8))
1074 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1076 fputs_filtered (" ", stream
);
1082 /* If we just printed a tag name, no need to print anything else. */
1083 if (TYPE_TAG_NAME (type
) == NULL
)
1084 fprintf_filtered (stream
, "{...}");
1086 else if (show
> 0 || TYPE_TAG_NAME (type
) == NULL
)
1088 fprintf_filtered (stream
, "{");
1089 len
= TYPE_NFIELDS (type
);
1091 for (i
= 0; i
< len
; i
++)
1095 fprintf_filtered (stream
, ", ");
1097 fputs_filtered (TYPE_FIELD_NAME (type
, i
), stream
);
1098 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
1100 fprintf_filtered (stream
, " = %d", TYPE_FIELD_BITPOS (type
, i
));
1101 lastval
= TYPE_FIELD_BITPOS (type
, i
);
1105 fprintf_filtered (stream
, "}");
1109 case TYPE_CODE_VOID
:
1110 fprintf_filtered (stream
, "void");
1113 case TYPE_CODE_UNDEF
:
1114 fprintf_filtered (stream
, _("struct <unknown>"));
1117 case TYPE_CODE_ERROR
:
1118 fprintf_filtered (stream
, _("<unknown type>"));
1121 case TYPE_CODE_RANGE
:
1122 /* This should not occur */
1123 fprintf_filtered (stream
, _("<range type>"));
1126 case TYPE_CODE_TEMPLATE
:
1127 /* Called on "ptype t" where "t" is a template.
1128 Prints the template header (with args), e.g.:
1129 template <class T1, class T2> class "
1130 and then merges with the struct/union/class code to
1131 print the rest of the definition. */
1132 c_type_print_modifier (type
, stream
, 0, 1);
1133 fprintf_filtered (stream
, "template <");
1134 for (i
= 0; i
< TYPE_NTEMPLATE_ARGS (type
); i
++)
1136 struct template_arg templ_arg
;
1137 templ_arg
= TYPE_TEMPLATE_ARG (type
, i
);
1138 fprintf_filtered (stream
, "class %s", templ_arg
.name
);
1139 if (i
< TYPE_NTEMPLATE_ARGS (type
) - 1)
1140 fprintf_filtered (stream
, ", ");
1142 fprintf_filtered (stream
, "> class ");
1145 case TYPE_CODE_NAMESPACE
:
1146 fputs_filtered ("namespace ", stream
);
1147 fputs_filtered (TYPE_TAG_NAME (type
), stream
);
1151 /* Handle types not explicitly handled by the other cases,
1152 such as fundamental types. For these, just print whatever
1153 the type name is, as recorded in the type itself. If there
1154 is no type name, then complain. */
1155 if (TYPE_NAME (type
) != NULL
)
1157 c_type_print_modifier (type
, stream
, 0, 1);
1158 fputs_filtered (TYPE_NAME (type
), stream
);
1162 /* At least for dump_symtab, it is important that this not be
1164 fprintf_filtered (stream
, _("<invalid type code %d>"),