1 /* Support for printing C and C++ types for GDB, the GNU debugger.
2 Copyright (C) 1986, 1988-1989, 1991-1996, 1998-2003, 2006-2012 Free
3 Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "gdb_obstack.h"
22 #include "bfd.h" /* Binary File Description. */
25 #include "expression.h"
32 #include "typeprint.h"
35 #include "gdb_string.h"
38 static void c_type_print_varspec_prefix (struct type *,
42 /* Print "const", "volatile", or address space modifiers. */
43 static void c_type_print_modifier (struct type *,
47 /* LEVEL is the depth to indent lines by. */
50 c_print_type (struct type *type,
51 const char *varstring,
52 struct ui_file *stream,
62 c_type_print_base (type, stream, show, level);
63 code = TYPE_CODE (type);
64 if ((varstring != NULL && *varstring != '\0')
65 /* Need a space if going to print stars or brackets;
66 but not if we will print just a type name. */
67 || ((show > 0 || TYPE_NAME (type) == 0)
68 && (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
69 || code == TYPE_CODE_METHOD
70 || code == TYPE_CODE_ARRAY
71 || code == TYPE_CODE_MEMBERPTR
72 || code == TYPE_CODE_METHODPTR
73 || code == TYPE_CODE_REF)))
74 fputs_filtered (" ", stream);
75 need_post_space = (varstring != NULL && strcmp (varstring, "") != 0);
76 c_type_print_varspec_prefix (type, stream, show, 0, need_post_space);
78 if (varstring != NULL)
80 fputs_filtered (varstring, stream);
82 /* For demangled function names, we have the arglist as part of
83 the name, so don't print an additional pair of ()'s. */
85 demangled_args = strchr (varstring, '(') != NULL;
86 c_type_print_varspec_suffix (type, stream, show,
91 /* Print a typedef using C syntax. TYPE is the underlying type.
92 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
96 c_print_typedef (struct type *type,
97 struct symbol *new_symbol,
98 struct ui_file *stream)
100 CHECK_TYPEDEF (type);
101 fprintf_filtered (stream, "typedef ");
102 type_print (type, "", stream, 0);
103 if (TYPE_NAME ((SYMBOL_TYPE (new_symbol))) == 0
104 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol))),
105 SYMBOL_LINKAGE_NAME (new_symbol)) != 0
106 || TYPE_CODE (SYMBOL_TYPE (new_symbol)) == TYPE_CODE_TYPEDEF)
107 fprintf_filtered (stream, " %s", SYMBOL_PRINT_NAME (new_symbol));
108 fprintf_filtered (stream, ";\n");
111 /* If TYPE is a derived type, then print out derivation information.
112 Print only the actual base classes of this type, not the base
113 classes of the base classes. I.e. for the derivation hierarchy:
116 class B : public A {int b; };
117 class C : public B {int c; };
119 Print the type of class C as:
125 Not as the following (like gdb used to), which is not legal C++
126 syntax for derived types and may be confused with the multiple
129 class C : public B : public A {
133 In general, gdb should try to print the types as closely as
134 possible to the form that they appear in the source code.
136 Note that in case of protected derivation gcc will not say
137 'protected' but 'private'. The HP's aCC compiler emits specific
138 information for derivation via protected inheritance, so gdb can
142 cp_type_print_derivation_info (struct ui_file *stream,
148 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
150 fputs_filtered (i == 0 ? ": " : ", ", stream);
151 fprintf_filtered (stream, "%s%s ",
152 BASETYPE_VIA_PUBLIC (type, i)
153 ? "public" : (TYPE_FIELD_PROTECTED (type, i)
154 ? "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, const char *prefix,
169 const char *varstring, int staticp,
170 struct ui_file *stream)
172 struct field *args = TYPE_FIELDS (mtype);
173 int nargs = TYPE_NFIELDS (mtype);
174 int varargs = TYPE_VARARGS (mtype);
177 fprintf_symbol_filtered (stream, prefix,
178 language_cplus, DMGL_ANSI);
179 fprintf_symbol_filtered (stream, varstring,
180 language_cplus, DMGL_ANSI);
181 fputs_filtered ("(", stream);
183 /* Skip the class variable. */
189 type_print (args[i++].type, "", stream, 0);
191 if (i == nargs && varargs)
192 fprintf_filtered (stream, ", ...");
194 fprintf_filtered (stream, ", ");
198 fprintf_filtered (stream, "...");
199 else if (current_language->la_language == language_cplus)
200 fprintf_filtered (stream, "void");
202 fprintf_filtered (stream, ")");
204 /* For non-static methods, read qualifiers from the type of
210 gdb_assert (nargs > 0);
211 gdb_assert (TYPE_CODE (args[0].type) == TYPE_CODE_PTR);
212 domain = TYPE_TARGET_TYPE (args[0].type);
214 if (TYPE_CONST (domain))
215 fprintf_filtered (stream, " const");
217 if (TYPE_VOLATILE (domain))
218 fprintf_filtered (stream, " volatile");
223 /* Print any asterisks or open-parentheses needed before the
224 variable name (to describe its type).
226 On outermost call, pass 0 for PASSED_A_PTR.
227 On outermost call, SHOW > 0 means should ignore
228 any typename for TYPE and show its details.
229 SHOW is always zero on recursive calls.
231 NEED_POST_SPACE is non-zero when a space will be be needed
232 between a trailing qualifier and a field, variable, or function
236 c_type_print_varspec_prefix (struct type *type,
237 struct ui_file *stream,
238 int show, int passed_a_ptr,
246 if (TYPE_NAME (type) && show <= 0)
251 switch (TYPE_CODE (type))
254 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
256 fprintf_filtered (stream, "*");
257 c_type_print_modifier (type, stream, 1, need_post_space);
260 case TYPE_CODE_MEMBERPTR:
261 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
263 name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
265 fputs_filtered (name, stream);
267 c_type_print_base (TYPE_DOMAIN_TYPE (type),
268 stream, -1, passed_a_ptr);
269 fprintf_filtered (stream, "::*");
272 case TYPE_CODE_METHODPTR:
273 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
275 fprintf_filtered (stream, "(");
276 name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
278 fputs_filtered (name, stream);
280 c_type_print_base (TYPE_DOMAIN_TYPE (type),
281 stream, -1, passed_a_ptr);
282 fprintf_filtered (stream, "::*");
286 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
288 fprintf_filtered (stream, "&");
289 c_type_print_modifier (type, stream, 1, need_post_space);
292 case TYPE_CODE_METHOD:
294 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
297 fprintf_filtered (stream, "(");
300 case TYPE_CODE_ARRAY:
301 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
304 fprintf_filtered (stream, "(");
307 case TYPE_CODE_TYPEDEF:
308 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type),
312 case TYPE_CODE_UNDEF:
313 case TYPE_CODE_STRUCT:
314 case TYPE_CODE_UNION:
319 case TYPE_CODE_ERROR:
323 case TYPE_CODE_RANGE:
324 case TYPE_CODE_STRING:
325 case TYPE_CODE_COMPLEX:
326 case TYPE_CODE_NAMESPACE:
327 case TYPE_CODE_DECFLOAT:
328 /* These types need no prefix. They are listed here so that
329 gcc -Wall will reveal any types that haven't been handled. */
332 error (_("type not handled in c_type_print_varspec_prefix()"));
337 /* Print out "const" and "volatile" attributes,
338 and address space id if present.
339 TYPE is a pointer to the type being printed out.
340 STREAM is the output destination.
341 NEED_PRE_SPACE = 1 indicates an initial white space is needed.
342 NEED_POST_SPACE = 1 indicates a final white space is needed. */
345 c_type_print_modifier (struct type *type, struct ui_file *stream,
346 int need_pre_space, int need_post_space)
348 int did_print_modifier = 0;
349 const char *address_space_id;
351 /* We don't print `const' qualifiers for references --- since all
352 operators affect the thing referenced, not the reference itself,
353 every reference is `const'. */
354 if (TYPE_CONST (type)
355 && TYPE_CODE (type) != TYPE_CODE_REF)
358 fprintf_filtered (stream, " ");
359 fprintf_filtered (stream, "const");
360 did_print_modifier = 1;
363 if (TYPE_VOLATILE (type))
365 if (did_print_modifier || need_pre_space)
366 fprintf_filtered (stream, " ");
367 fprintf_filtered (stream, "volatile");
368 did_print_modifier = 1;
371 address_space_id = address_space_int_to_name (get_type_arch (type),
372 TYPE_INSTANCE_FLAGS (type));
373 if (address_space_id)
375 if (did_print_modifier || need_pre_space)
376 fprintf_filtered (stream, " ");
377 fprintf_filtered (stream, "@%s", address_space_id);
378 did_print_modifier = 1;
381 if (did_print_modifier && need_post_space)
382 fprintf_filtered (stream, " ");
386 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
387 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
388 in non-static methods, are displayed if LINKAGE_NAME is zero. If
389 LINKAGE_NAME is non-zero and LANGUAGE is language_cplus the topmost
390 parameter types get removed their possible const and volatile qualifiers to
391 match demangled linkage name parameters part of such function type.
392 LANGUAGE is the language in which TYPE was defined. This is a necessary
393 evil since this code is used by the C, C++, and Java backends. */
396 c_type_print_args (struct type *type, struct ui_file *stream,
397 int linkage_name, enum language language)
403 fprintf_filtered (stream, "(");
404 args = TYPE_FIELDS (type);
405 len = TYPE_NFIELDS (type);
407 for (i = 0; i < TYPE_NFIELDS (type); i++)
409 struct type *param_type;
411 if (TYPE_FIELD_ARTIFICIAL (type, i) && linkage_name)
416 fprintf_filtered (stream, ", ");
420 param_type = TYPE_FIELD_TYPE (type, i);
422 if (language == language_cplus && linkage_name)
424 /* C++ standard, 13.1 Overloadable declarations, point 3, item:
425 - Parameter declarations that differ only in the presence or
426 absence of const and/or volatile are equivalent.
428 And the const/volatile qualifiers are not present in the mangled
429 names as produced by GCC. */
431 param_type = make_cv_type (0, 0, param_type, NULL);
434 if (language == language_java)
435 java_print_type (param_type, "", stream, -1, 0);
437 c_print_type (param_type, "", stream, -1, 0);
441 if (printed_any && TYPE_VARARGS (type))
443 /* Print out a trailing ellipsis for varargs functions. Ignore
444 TYPE_VARARGS if the function has no named arguments; that
445 represents unprototyped (K&R style) C functions. */
446 if (printed_any && TYPE_VARARGS (type))
448 fprintf_filtered (stream, ", ");
450 fprintf_filtered (stream, "...");
453 else if (!printed_any
454 && ((TYPE_PROTOTYPED (type) && language != language_java)
455 || language == language_cplus))
456 fprintf_filtered (stream, "void");
458 fprintf_filtered (stream, ")");
461 /* Return true iff the j'th overloading of the i'th method of TYPE
462 is a type conversion operator, like `operator int () { ... }'.
463 When listing a class's methods, we don't print the return type of
467 is_type_conversion_operator (struct type *type, int i, int j)
469 /* I think the whole idea of recognizing type conversion operators
470 by their name is pretty terrible. But I don't think our present
471 data structure gives us any other way to tell. If you know of
472 some other way, feel free to rewrite this function. */
473 const char *name = TYPE_FN_FIELDLIST_NAME (type, i);
475 if (strncmp (name, "operator", 8) != 0)
479 if (! strchr (" \t\f\n\r", *name))
482 while (strchr (" \t\f\n\r", *name))
485 if (!('a' <= *name && *name <= 'z')
486 && !('A' <= *name && *name <= 'Z')
488 /* If this doesn't look like the start of an identifier, then it
489 isn't a type conversion operator. */
491 else if (strncmp (name, "new", 3) == 0)
493 else if (strncmp (name, "delete", 6) == 0)
496 /* If it doesn't look like new or delete, it's a type conversion
500 /* Is that really the end of the name? */
501 if (('a' <= *name && *name <= 'z')
502 || ('A' <= *name && *name <= 'Z')
503 || ('0' <= *name && *name <= '9')
505 /* No, so the identifier following "operator" must be a type name,
506 and this is a type conversion operator. */
509 /* That was indeed the end of the name, so it was `operator new' or
510 `operator delete', neither of which are type conversion
515 /* Given a C++ qualified identifier QID, strip off the qualifiers,
516 yielding the unqualified name. The return value is a pointer into
519 It's a pity we don't have this information in some more structured
520 form. Even the author of this function feels that writing little
521 parsers like this everywhere is stupid. */
524 remove_qualifiers (char *qid)
526 int quoted = 0; /* Zero if we're not in quotes;
527 '"' if we're in a double-quoted string;
528 '\'' if we're in a single-quoted string. */
529 int depth = 0; /* Number of unclosed parens we've seen. */
530 char *parenstack = (char *) alloca (strlen (qid));
532 char *last = 0; /* The character after the rightmost
533 `::' token we've seen so far. */
535 for (scan = qid; *scan; scan++)
541 else if (*scan == '\\' && *(scan + 1))
544 else if (scan[0] == ':' && scan[1] == ':')
546 /* If we're inside parenthesis (i.e., an argument list) or
547 angle brackets (i.e., a list of template arguments), then
548 we don't record the position of this :: token, since it's
549 not relevant to the top-level structure we're trying to
557 else if (*scan == '"' || *scan == '\'')
559 else if (*scan == '(')
560 parenstack[depth++] = ')';
561 else if (*scan == '[')
562 parenstack[depth++] = ']';
563 /* We're going to treat <> as a pair of matching characters,
564 since we're more likely to see those in template id's than
565 real less-than characters. What a crock. */
566 else if (*scan == '<')
567 parenstack[depth++] = '>';
568 else if (*scan == ')' || *scan == ']' || *scan == '>')
570 if (depth > 0 && parenstack[depth - 1] == *scan)
574 /* We're going to do a little error recovery here. If
575 we don't find a match for *scan on the paren stack,
576 but there is something lower on the stack that does
577 match, we pop the stack to that point. */
580 for (i = depth - 1; i >= 0; i--)
581 if (parenstack[i] == *scan)
593 /* We didn't find any :: tokens at the top level, so declare the
594 whole thing an unqualified identifier. */
598 /* Print any array sizes, function arguments or close parentheses
599 needed after the variable name (to describe its type).
600 Args work like c_type_print_varspec_prefix. */
603 c_type_print_varspec_suffix (struct type *type,
604 struct ui_file *stream,
605 int show, int passed_a_ptr,
611 if (TYPE_NAME (type) && show <= 0)
616 switch (TYPE_CODE (type))
618 case TYPE_CODE_ARRAY:
620 LONGEST low_bound, high_bound;
623 fprintf_filtered (stream, ")");
625 fprintf_filtered (stream, "[");
626 if (get_array_bounds (type, &low_bound, &high_bound))
627 fprintf_filtered (stream, "%d",
628 (int) (high_bound - low_bound + 1));
629 fprintf_filtered (stream, "]");
631 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
636 case TYPE_CODE_MEMBERPTR:
637 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
641 case TYPE_CODE_METHODPTR:
642 fprintf_filtered (stream, ")");
643 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
649 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
653 case TYPE_CODE_METHOD:
656 fprintf_filtered (stream, ")");
658 c_type_print_args (type, stream, 0, current_language->la_language);
659 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
660 show, passed_a_ptr, 0);
663 case TYPE_CODE_TYPEDEF:
664 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream,
665 show, passed_a_ptr, 0);
668 case TYPE_CODE_UNDEF:
669 case TYPE_CODE_STRUCT:
670 case TYPE_CODE_UNION:
675 case TYPE_CODE_ERROR:
679 case TYPE_CODE_RANGE:
680 case TYPE_CODE_STRING:
681 case TYPE_CODE_COMPLEX:
682 case TYPE_CODE_NAMESPACE:
683 case TYPE_CODE_DECFLOAT:
684 /* These types do not need a suffix. They are listed so that
685 gcc -Wall will report types that may not have been
689 error (_("type not handled in c_type_print_varspec_suffix()"));
694 /* Print the name of the type (or the ultimate pointer target,
695 function value or array element), or the description of a structure
698 SHOW positive means print details about the type (e.g. enum
699 values), and print structure elements passing SHOW - 1 for show.
701 SHOW negative means just print the type name or struct tag if there
702 is one. If there is no name, print something sensible but concise
705 SHOW zero means just print the type name or struct tag if there is
706 one. If there is no name, print something sensible but not as
707 concise like "struct {int x; int y;}".
709 LEVEL is the number of spaces to indent by.
710 We increase it for some recursive calls. */
713 c_type_print_base (struct type *type, struct ui_file *stream,
720 s_none, s_public, s_private, s_protected
723 int need_access_label = 0;
731 fputs_filtered (_("<type unknown>"), stream);
735 /* When SHOW is zero or less, and there is a valid type name, then
736 always just print the type name directly from the type. */
737 /* If we have "typedef struct foo {. . .} bar;" do we want to print
738 it as "struct foo" or as "bar"? Pick the latter, because C++
739 folk tend to expect things like "class5 *foo" rather than "struct
743 && TYPE_NAME (type) != NULL)
745 c_type_print_modifier (type, stream, 0, 1);
746 fputs_filtered (TYPE_NAME (type), stream);
750 CHECK_TYPEDEF (type);
752 switch (TYPE_CODE (type))
754 case TYPE_CODE_TYPEDEF:
755 /* If we get here, the typedef doesn't have a name, and we
756 couldn't resolve TYPE_TARGET_TYPE. Not much we can do. */
757 gdb_assert (TYPE_NAME (type) == NULL);
758 gdb_assert (TYPE_TARGET_TYPE (type) == NULL);
759 fprintf_filtered (stream, _("<unnamed typedef>"));
762 case TYPE_CODE_ARRAY:
764 case TYPE_CODE_MEMBERPTR:
767 case TYPE_CODE_METHOD:
768 case TYPE_CODE_METHODPTR:
769 c_type_print_base (TYPE_TARGET_TYPE (type),
770 stream, show, level);
773 case TYPE_CODE_STRUCT:
774 c_type_print_modifier (type, stream, 0, 1);
775 if (TYPE_DECLARED_CLASS (type))
776 fprintf_filtered (stream, "class ");
778 fprintf_filtered (stream, "struct ");
781 case TYPE_CODE_UNION:
782 c_type_print_modifier (type, stream, 0, 1);
783 fprintf_filtered (stream, "union ");
787 /* Print the tag if it exists. The HP aCC compiler emits a
788 spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed
789 enum}" tag for unnamed struct/union/enum's, which we don't
791 if (TYPE_TAG_NAME (type) != NULL
792 && strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
794 fputs_filtered (TYPE_TAG_NAME (type), stream);
796 fputs_filtered (" ", stream);
801 /* If we just printed a tag name, no need to print anything
803 if (TYPE_TAG_NAME (type) == NULL)
804 fprintf_filtered (stream, "{...}");
806 else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
808 struct type *basetype;
811 cp_type_print_derivation_info (stream, type);
813 fprintf_filtered (stream, "{\n");
814 if (TYPE_NFIELDS (type) == 0 && TYPE_NFN_FIELDS (type) == 0
815 && TYPE_TYPEDEF_FIELD_COUNT (type) == 0)
817 if (TYPE_STUB (type))
818 fprintfi_filtered (level + 4, stream,
819 _("<incomplete type>\n"));
821 fprintfi_filtered (level + 4, stream,
822 _("<no data fields>\n"));
825 /* Start off with no specific section type, so we can print
826 one for the first field we find, and use that section type
827 thereafter until we find another type. */
829 section_type = s_none;
831 /* For a class, if all members are private, there's no need
832 for a "private:" label; similarly, for a struct or union
833 masquerading as a class, if all members are public, there's
834 no need for a "public:" label. */
836 if (TYPE_DECLARED_CLASS (type))
839 len = TYPE_NFIELDS (type);
840 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
841 if (!TYPE_FIELD_PRIVATE (type, i))
843 need_access_label = 1;
847 if (!need_access_label)
849 len2 = TYPE_NFN_FIELDS (type);
850 for (j = 0; j < len2; j++)
852 len = TYPE_FN_FIELDLIST_LENGTH (type, j);
853 for (i = 0; i < len; i++)
854 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type,
857 need_access_label = 1;
860 if (need_access_label)
868 len = TYPE_NFIELDS (type);
869 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
870 if (TYPE_FIELD_PRIVATE (type, i)
871 || TYPE_FIELD_PROTECTED (type, i))
873 need_access_label = 1;
877 if (!need_access_label)
879 len2 = TYPE_NFN_FIELDS (type);
880 for (j = 0; j < len2; j++)
883 len = TYPE_FN_FIELDLIST_LENGTH (type, j);
884 for (i = 0; i < len; i++)
885 if (TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type,
887 || TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type,
891 need_access_label = 1;
894 if (need_access_label)
900 /* If there is a base class for this type,
901 do not print the field that it occupies. */
903 len = TYPE_NFIELDS (type);
904 vptr_fieldno = get_vptr_fieldno (type, &basetype);
905 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
909 /* If we have a virtual table pointer, omit it. Even if
910 virtual table pointers are not specifically marked in
911 the debug info, they should be artificial. */
912 if ((i == vptr_fieldno && type == basetype)
913 || TYPE_FIELD_ARTIFICIAL (type, i))
916 if (need_access_label)
918 if (TYPE_FIELD_PROTECTED (type, i))
920 if (section_type != s_protected)
922 section_type = s_protected;
923 fprintfi_filtered (level + 2, stream,
927 else if (TYPE_FIELD_PRIVATE (type, i))
929 if (section_type != s_private)
931 section_type = s_private;
932 fprintfi_filtered (level + 2, stream,
938 if (section_type != s_public)
940 section_type = s_public;
941 fprintfi_filtered (level + 2, stream,
947 print_spaces_filtered (level + 4, stream);
948 if (field_is_static (&TYPE_FIELD (type, i)))
949 fprintf_filtered (stream, "static ");
950 c_print_type (TYPE_FIELD_TYPE (type, i),
951 TYPE_FIELD_NAME (type, i),
952 stream, show - 1, level + 4);
953 if (!field_is_static (&TYPE_FIELD (type, i))
954 && TYPE_FIELD_PACKED (type, i))
956 /* It is a bitfield. This code does not attempt
957 to look at the bitpos and reconstruct filler,
958 unnamed fields. This would lead to misleading
959 results if the compiler does not put out fields
960 for such things (I don't know what it does). */
961 fprintf_filtered (stream, " : %d",
962 TYPE_FIELD_BITSIZE (type, i));
964 fprintf_filtered (stream, ";\n");
967 /* If there are both fields and methods, put a blank line
968 between them. Make sure to count only method that we
969 will display; artificial methods will be hidden. */
970 len = TYPE_NFN_FIELDS (type);
972 for (i = 0; i < len; i++)
974 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
975 int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
978 for (j = 0; j < len2; j++)
979 if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
982 if (real_len > 0 && section_type != s_none)
983 fprintf_filtered (stream, "\n");
985 /* C++: print out the methods. */
986 for (i = 0; i < len; i++)
988 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
989 int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
990 const char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
991 const char *name = type_name_no_tag (type);
992 int is_constructor = name && strcmp (method_name,
995 for (j = 0; j < len2; j++)
997 const char *mangled_name;
998 char *demangled_name;
999 struct cleanup *inner_cleanup;
1000 const char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
1001 int is_full_physname_constructor =
1002 is_constructor_name (physname)
1003 || is_destructor_name (physname)
1004 || method_name[0] == '~';
1006 /* Do not print out artificial methods. */
1007 if (TYPE_FN_FIELD_ARTIFICIAL (f, j))
1010 inner_cleanup = make_cleanup (null_cleanup, NULL);
1013 if (TYPE_FN_FIELD_PROTECTED (f, j))
1015 if (section_type != s_protected)
1017 section_type = s_protected;
1018 fprintfi_filtered (level + 2, stream,
1022 else if (TYPE_FN_FIELD_PRIVATE (f, j))
1024 if (section_type != s_private)
1026 section_type = s_private;
1027 fprintfi_filtered (level + 2, stream,
1033 if (section_type != s_public)
1035 section_type = s_public;
1036 fprintfi_filtered (level + 2, stream,
1041 print_spaces_filtered (level + 4, stream);
1042 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1043 fprintf_filtered (stream, "virtual ");
1044 else if (TYPE_FN_FIELD_STATIC_P (f, j))
1045 fprintf_filtered (stream, "static ");
1046 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
1048 /* Keep GDB from crashing here. */
1049 fprintf_filtered (stream,
1050 _("<undefined type> %s;\n"),
1051 TYPE_FN_FIELD_PHYSNAME (f, j));
1054 else if (!is_constructor /* Constructors don't
1057 && !is_full_physname_constructor /* " " */
1058 && !is_type_conversion_operator (type, i, j))
1060 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
1062 fputs_filtered (" ", stream);
1064 if (TYPE_FN_FIELD_STUB (f, j))
1068 /* Build something we can demangle. */
1069 tem = gdb_mangle_name (type, i, j);
1070 make_cleanup (xfree, tem);
1074 mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
1077 cplus_demangle (mangled_name,
1078 DMGL_ANSI | DMGL_PARAMS);
1079 if (demangled_name == NULL)
1081 /* In some cases (for instance with the HP
1082 demangling), if a function has more than 10
1083 arguments, the demangling will fail.
1084 Let's try to reconstruct the function
1085 signature from the symbol information. */
1086 if (!TYPE_FN_FIELD_STUB (f, j))
1088 int staticp = TYPE_FN_FIELD_STATIC_P (f, j);
1089 struct type *mtype = TYPE_FN_FIELD_TYPE (f, j);
1091 cp_type_print_method_args (mtype,
1098 fprintf_filtered (stream,
1099 _("<badly mangled name '%s'>"),
1105 char *demangled_no_class
1106 = remove_qualifiers (demangled_name);
1108 /* Get rid of the `static' appended by the
1110 p = strstr (demangled_no_class, " static");
1113 int length = p - demangled_no_class;
1114 char *demangled_no_static;
1117 = (char *) xmalloc (length + 1);
1118 strncpy (demangled_no_static,
1119 demangled_no_class, length);
1120 *(demangled_no_static + length) = '\0';
1121 fputs_filtered (demangled_no_static, stream);
1122 xfree (demangled_no_static);
1125 fputs_filtered (demangled_no_class, stream);
1126 xfree (demangled_name);
1129 do_cleanups (inner_cleanup);
1131 fprintf_filtered (stream, ";\n");
1135 /* Print typedefs defined in this class. */
1137 if (TYPE_TYPEDEF_FIELD_COUNT (type) != 0)
1139 if (TYPE_NFIELDS (type) != 0 || TYPE_NFN_FIELDS (type) != 0)
1140 fprintf_filtered (stream, "\n");
1142 for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (type); i++)
1144 struct type *target = TYPE_TYPEDEF_FIELD_TYPE (type, i);
1146 /* Dereference the typedef declaration itself. */
1147 gdb_assert (TYPE_CODE (target) == TYPE_CODE_TYPEDEF);
1148 target = TYPE_TARGET_TYPE (target);
1150 print_spaces_filtered (level + 4, stream);
1151 fprintf_filtered (stream, "typedef ");
1152 c_print_type (target, TYPE_TYPEDEF_FIELD_NAME (type, i),
1153 stream, show - 1, level + 4);
1154 fprintf_filtered (stream, ";\n");
1158 fprintfi_filtered (level, stream, "}");
1160 if (TYPE_LOCALTYPE_PTR (type) && show >= 0)
1161 fprintfi_filtered (level,
1162 stream, _(" (Local at %s:%d)\n"),
1163 TYPE_LOCALTYPE_FILE (type),
1164 TYPE_LOCALTYPE_LINE (type));
1168 case TYPE_CODE_ENUM:
1169 c_type_print_modifier (type, stream, 0, 1);
1170 fprintf_filtered (stream, "enum ");
1171 /* Print the tag name if it exists.
1172 The aCC compiler emits a spurious
1173 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1174 tag for unnamed struct/union/enum's, which we don't
1176 if (TYPE_TAG_NAME (type) != NULL
1177 && strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
1179 fputs_filtered (TYPE_TAG_NAME (type), stream);
1181 fputs_filtered (" ", stream);
1187 /* If we just printed a tag name, no need to print anything
1189 if (TYPE_TAG_NAME (type) == NULL)
1190 fprintf_filtered (stream, "{...}");
1192 else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1194 LONGEST lastval = 0;
1196 fprintf_filtered (stream, "{");
1197 len = TYPE_NFIELDS (type);
1198 for (i = 0; i < len; i++)
1202 fprintf_filtered (stream, ", ");
1204 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1205 if (lastval != TYPE_FIELD_ENUMVAL (type, i))
1207 fprintf_filtered (stream, " = %s",
1208 plongest (TYPE_FIELD_ENUMVAL (type, i)));
1209 lastval = TYPE_FIELD_ENUMVAL (type, i);
1213 fprintf_filtered (stream, "}");
1217 case TYPE_CODE_VOID:
1218 fprintf_filtered (stream, "void");
1221 case TYPE_CODE_UNDEF:
1222 fprintf_filtered (stream, _("struct <unknown>"));
1225 case TYPE_CODE_ERROR:
1226 fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
1229 case TYPE_CODE_RANGE:
1230 /* This should not occur. */
1231 fprintf_filtered (stream, _("<range type>"));
1234 case TYPE_CODE_NAMESPACE:
1235 fputs_filtered ("namespace ", stream);
1236 fputs_filtered (TYPE_TAG_NAME (type), stream);
1240 /* Handle types not explicitly handled by the other cases, such
1241 as fundamental types. For these, just print whatever the
1242 type name is, as recorded in the type itself. If there is no
1243 type name, then complain. */
1244 if (TYPE_NAME (type) != NULL)
1246 c_type_print_modifier (type, stream, 0, 1);
1247 fputs_filtered (TYPE_NAME (type), stream);
1251 /* At least for dump_symtab, it is important that this not
1253 fprintf_filtered (stream, _("<invalid type code %d>"),