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, 2010
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"
37 #include "gdb_string.h"
40 static void cp_type_print_method_args (struct type *mtype, char *prefix,
41 char *varstring, int staticp,
42 struct ui_file *stream);
44 static void cp_type_print_derivation_info (struct ui_file *, struct type *);
46 static void c_type_print_varspec_prefix (struct type *, struct ui_file *, int,
49 /* Print "const", "volatile", or address space modifiers. */
50 static void c_type_print_modifier (struct type *, struct ui_file *,
56 /* LEVEL is the depth to indent lines by. */
59 c_print_type (struct type *type, const char *varstring, struct ui_file *stream,
69 c_type_print_base (type, stream, show, level);
70 code = TYPE_CODE (type);
71 if ((varstring != NULL && *varstring != '\0')
72 /* Need a space if going to print stars or brackets;
73 but not if we will print just a type name. */
74 || ((show > 0 || TYPE_NAME (type) == 0)
75 && (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
76 || code == TYPE_CODE_METHOD
77 || code == TYPE_CODE_ARRAY
78 || code == TYPE_CODE_MEMBERPTR
79 || code == TYPE_CODE_METHODPTR
80 || code == TYPE_CODE_REF)))
81 fputs_filtered (" ", stream);
82 need_post_space = (varstring != NULL && strcmp (varstring, "") != 0);
83 c_type_print_varspec_prefix (type, stream, show, 0, need_post_space);
85 if (varstring != NULL)
87 fputs_filtered (varstring, stream);
89 /* For demangled function names, we have the arglist as part of the name,
90 so don't print an additional pair of ()'s */
92 demangled_args = strchr (varstring, '(') != NULL;
93 c_type_print_varspec_suffix (type, stream, show, 0, demangled_args);
97 /* Print a typedef using C syntax. TYPE is the underlying type.
98 NEW_SYMBOL is the symbol naming the type. STREAM is the stream on
102 c_print_typedef (struct type *type, struct symbol *new_symbol,
103 struct ui_file *stream)
105 CHECK_TYPEDEF (type);
106 fprintf_filtered (stream, "typedef ");
107 type_print (type, "", stream, 0);
108 if (TYPE_NAME ((SYMBOL_TYPE (new_symbol))) == 0
109 || strcmp (TYPE_NAME ((SYMBOL_TYPE (new_symbol))),
110 SYMBOL_LINKAGE_NAME (new_symbol)) != 0)
111 fprintf_filtered (stream, " %s", SYMBOL_PRINT_NAME (new_symbol));
112 fprintf_filtered (stream, ";\n");
115 /* If TYPE is a derived type, then print out derivation information.
116 Print only the actual base classes of this type, not the base classes
117 of the base classes. I.E. for the derivation hierarchy:
120 class B : public A {int b; };
121 class C : public B {int c; };
123 Print the type of class C as:
129 Not as the following (like gdb used to), which is not legal C++ syntax for
130 derived types and may be confused with the multiple inheritance form:
132 class C : public B : public A {
136 In general, gdb should try to print the types as closely as possible to
137 the form that they appear in the source code.
138 Note that in case of protected derivation gcc will not say 'protected'
139 but 'private'. The HP's aCC compiler emits specific information for
140 derivation via protected inheritance, so gdb can print it out */
143 cp_type_print_derivation_info (struct ui_file *stream, struct type *type)
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) ? "public"
153 : (TYPE_FIELD_PROTECTED (type, i) ? "protected" : "private"),
154 BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : "");
155 name = type_name_no_tag (TYPE_BASECLASS (type, i));
156 fprintf_filtered (stream, "%s", name ? name : "(null)");
160 fputs_filtered (" ", stream);
164 /* Print the C++ method arguments ARGS to the file STREAM. */
167 cp_type_print_method_args (struct type *mtype, char *prefix, char *varstring,
168 int staticp, struct ui_file *stream)
170 struct field *args = TYPE_FIELDS (mtype);
171 int nargs = TYPE_NFIELDS (mtype);
172 int varargs = TYPE_VARARGS (mtype);
175 fprintf_symbol_filtered (stream, prefix, language_cplus, DMGL_ANSI);
176 fprintf_symbol_filtered (stream, varstring, language_cplus, DMGL_ANSI);
177 fputs_filtered ("(", stream);
179 /* Skip the class variable. */
185 type_print (args[i++].type, "", stream, 0);
187 if (i == nargs && varargs)
188 fprintf_filtered (stream, ", ...");
190 fprintf_filtered (stream, ", ");
194 fprintf_filtered (stream, "...");
195 else if (current_language->la_language == language_cplus)
196 fprintf_filtered (stream, "void");
198 fprintf_filtered (stream, ")");
200 /* For non-static methods, read qualifiers from the type of
206 gdb_assert (nargs > 0);
207 gdb_assert (TYPE_CODE (args[0].type) == TYPE_CODE_PTR);
208 domain = TYPE_TARGET_TYPE (args[0].type);
210 if (TYPE_CONST (domain))
211 fprintf_filtered (stream, " const");
213 if (TYPE_VOLATILE (domain))
214 fprintf_filtered (stream, " volatile");
219 /* Print any asterisks or open-parentheses needed before the
220 variable name (to describe its type).
222 On outermost call, pass 0 for PASSED_A_PTR.
223 On outermost call, SHOW > 0 means should ignore
224 any typename for TYPE and show its details.
225 SHOW is always zero on recursive calls.
227 NEED_POST_SPACE is non-zero when a space will be be needed
228 between a trailing qualifier and a field, variable, or function
232 c_type_print_varspec_prefix (struct type *type, struct ui_file *stream,
233 int show, int passed_a_ptr, int need_post_space)
240 if (TYPE_NAME (type) && show <= 0)
245 switch (TYPE_CODE (type))
248 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 1, 1);
249 fprintf_filtered (stream, "*");
250 c_type_print_modifier (type, stream, 1, need_post_space);
253 case TYPE_CODE_MEMBERPTR:
254 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
255 name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
257 fputs_filtered (name, stream);
259 c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
260 fprintf_filtered (stream, "::*");
263 case TYPE_CODE_METHODPTR:
264 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
265 fprintf_filtered (stream, "(");
266 name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
268 fputs_filtered (name, stream);
270 c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
271 fprintf_filtered (stream, "::*");
275 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 1, 0);
276 fprintf_filtered (stream, "&");
277 c_type_print_modifier (type, stream, 1, need_post_space);
280 case TYPE_CODE_METHOD:
282 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
284 fprintf_filtered (stream, "(");
287 case TYPE_CODE_ARRAY:
288 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
290 fprintf_filtered (stream, "(");
293 case TYPE_CODE_TYPEDEF:
294 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
297 case TYPE_CODE_UNDEF:
298 case TYPE_CODE_STRUCT:
299 case TYPE_CODE_UNION:
304 case TYPE_CODE_ERROR:
308 case TYPE_CODE_RANGE:
309 case TYPE_CODE_STRING:
310 case TYPE_CODE_BITSTRING:
311 case TYPE_CODE_COMPLEX:
312 case TYPE_CODE_NAMESPACE:
313 case TYPE_CODE_DECFLOAT:
314 /* These types need no prefix. They are listed here so that
315 gcc -Wall will reveal any types that haven't been handled. */
318 error (_("type not handled in c_type_print_varspec_prefix()"));
323 /* Print out "const" and "volatile" attributes.
324 TYPE is a pointer to the type being printed out.
325 STREAM is the output destination.
326 NEED_SPACE = 1 indicates an initial white space is needed */
329 c_type_print_modifier (struct type *type, struct ui_file *stream,
330 int need_pre_space, int need_post_space)
332 int did_print_modifier = 0;
333 const char *address_space_id;
335 /* We don't print `const' qualifiers for references --- since all
336 operators affect the thing referenced, not the reference itself,
337 every reference is `const'. */
338 if (TYPE_CONST (type)
339 && TYPE_CODE (type) != TYPE_CODE_REF)
342 fprintf_filtered (stream, " ");
343 fprintf_filtered (stream, "const");
344 did_print_modifier = 1;
347 if (TYPE_VOLATILE (type))
349 if (did_print_modifier || need_pre_space)
350 fprintf_filtered (stream, " ");
351 fprintf_filtered (stream, "volatile");
352 did_print_modifier = 1;
355 address_space_id = address_space_int_to_name (get_type_arch (type),
356 TYPE_INSTANCE_FLAGS (type));
357 if (address_space_id)
359 if (did_print_modifier || need_pre_space)
360 fprintf_filtered (stream, " ");
361 fprintf_filtered (stream, "@%s", address_space_id);
362 did_print_modifier = 1;
365 if (did_print_modifier && need_post_space)
366 fprintf_filtered (stream, " ");
370 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
371 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
372 in non-static methods, are displayed if SHOW_ARTIFICIAL is
373 non-zero. LANGUAGE is the language in which TYPE was defined. This is
374 a necessary evil since this code is used by the C, C++, and Java
378 c_type_print_args (struct type *type, struct ui_file *stream,
379 int show_artificial, enum language language)
385 fprintf_filtered (stream, "(");
386 args = TYPE_FIELDS (type);
387 len = TYPE_NFIELDS (type);
389 for (i = 0; i < TYPE_NFIELDS (type); i++)
391 if (TYPE_FIELD_ARTIFICIAL (type, i) && !show_artificial)
396 fprintf_filtered (stream, ", ");
400 if (language == language_java)
401 java_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
403 c_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
407 if (printed_any && TYPE_VARARGS (type))
409 /* Print out a trailing ellipsis for varargs functions. Ignore
410 TYPE_VARARGS if the function has no named arguments; that
411 represents unprototyped (K&R style) C functions. */
412 if (printed_any && TYPE_VARARGS (type))
414 fprintf_filtered (stream, ", ");
416 fprintf_filtered (stream, "...");
419 else if (!printed_any
420 && ((TYPE_PROTOTYPED (type) && language != language_java)
421 || language == language_cplus))
422 fprintf_filtered (stream, "void");
424 fprintf_filtered (stream, ")");
428 /* Return true iff the j'th overloading of the i'th method of TYPE
429 is a type conversion operator, like `operator int () { ... }'.
430 When listing a class's methods, we don't print the return type of
433 is_type_conversion_operator (struct type *type, int i, int j)
435 /* I think the whole idea of recognizing type conversion operators
436 by their name is pretty terrible. But I don't think our present
437 data structure gives us any other way to tell. If you know of
438 some other way, feel free to rewrite this function. */
439 char *name = TYPE_FN_FIELDLIST_NAME (type, i);
441 if (strncmp (name, "operator", 8) != 0)
445 if (! strchr (" \t\f\n\r", *name))
448 while (strchr (" \t\f\n\r", *name))
451 if (!('a' <= *name && *name <= 'z')
452 && !('A' <= *name && *name <= 'Z')
454 /* If this doesn't look like the start of an identifier, then it
455 isn't a type conversion operator. */
457 else if (strncmp (name, "new", 3) == 0)
459 else if (strncmp (name, "delete", 6) == 0)
462 /* If it doesn't look like new or delete, it's a type conversion
466 /* Is that really the end of the name? */
467 if (('a' <= *name && *name <= 'z')
468 || ('A' <= *name && *name <= 'Z')
469 || ('0' <= *name && *name <= '9')
471 /* No, so the identifier following "operator" must be a type name,
472 and this is a type conversion operator. */
475 /* That was indeed the end of the name, so it was `operator new' or
476 `operator delete', neither of which are type conversion operators. */
481 /* Given a C++ qualified identifier QID, strip off the qualifiers,
482 yielding the unqualified name. The return value is a pointer into
485 It's a pity we don't have this information in some more structured
486 form. Even the author of this function feels that writing little
487 parsers like this everywhere is stupid. */
489 remove_qualifiers (char *qid)
491 int quoted = 0; /* zero if we're not in quotes;
492 '"' if we're in a double-quoted string;
493 '\'' if we're in a single-quoted string. */
494 int depth = 0; /* number of unclosed parens we've seen */
495 char *parenstack = (char *) alloca (strlen (qid));
497 char *last = 0; /* The character after the rightmost
498 `::' token we've seen so far. */
500 for (scan = qid; *scan; scan++)
506 else if (*scan == '\\' && *(scan + 1))
509 else if (scan[0] == ':' && scan[1] == ':')
511 /* If we're inside parenthesis (i.e., an argument list) or
512 angle brackets (i.e., a list of template arguments), then
513 we don't record the position of this :: token, since it's
514 not relevant to the top-level structure we're trying
522 else if (*scan == '"' || *scan == '\'')
524 else if (*scan == '(')
525 parenstack[depth++] = ')';
526 else if (*scan == '[')
527 parenstack[depth++] = ']';
528 /* We're going to treat <> as a pair of matching characters,
529 since we're more likely to see those in template id's than
530 real less-than characters. What a crock. */
531 else if (*scan == '<')
532 parenstack[depth++] = '>';
533 else if (*scan == ')' || *scan == ']' || *scan == '>')
535 if (depth > 0 && parenstack[depth - 1] == *scan)
539 /* We're going to do a little error recovery here. If we
540 don't find a match for *scan on the paren stack, but
541 there is something lower on the stack that does match, we
542 pop the stack to that point. */
545 for (i = depth - 1; i >= 0; i--)
546 if (parenstack[i] == *scan)
558 /* We didn't find any :: tokens at the top level, so declare the
559 whole thing an unqualified identifier. */
564 /* Print any array sizes, function arguments or close parentheses
565 needed after the variable name (to describe its type).
566 Args work like c_type_print_varspec_prefix. */
569 c_type_print_varspec_suffix (struct type *type, struct ui_file *stream,
570 int show, int passed_a_ptr, int demangled_args)
575 if (TYPE_NAME (type) && show <= 0)
580 switch (TYPE_CODE (type))
582 case TYPE_CODE_ARRAY:
584 fprintf_filtered (stream, ")");
586 fprintf_filtered (stream, "[");
587 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
588 && !TYPE_ARRAY_UPPER_BOUND_IS_UNDEFINED (type))
589 fprintf_filtered (stream, "%d",
591 / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
592 fprintf_filtered (stream, "]");
594 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
598 case TYPE_CODE_MEMBERPTR:
599 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
603 case TYPE_CODE_METHODPTR:
604 fprintf_filtered (stream, ")");
605 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
611 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
615 case TYPE_CODE_METHOD:
618 fprintf_filtered (stream, ")");
620 c_type_print_args (type, stream, 1, current_language->la_language);
621 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
625 case TYPE_CODE_TYPEDEF:
626 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
630 case TYPE_CODE_UNDEF:
631 case TYPE_CODE_STRUCT:
632 case TYPE_CODE_UNION:
637 case TYPE_CODE_ERROR:
641 case TYPE_CODE_RANGE:
642 case TYPE_CODE_STRING:
643 case TYPE_CODE_BITSTRING:
644 case TYPE_CODE_COMPLEX:
645 case TYPE_CODE_NAMESPACE:
646 case TYPE_CODE_DECFLOAT:
647 /* These types do not need a suffix. They are listed so that
648 gcc -Wall will report types that may not have been considered. */
651 error (_("type not handled in c_type_print_varspec_suffix()"));
656 /* Print the name of the type (or the ultimate pointer target,
657 function value or array element), or the description of a
660 SHOW positive means print details about the type (e.g. enum values),
661 and print structure elements passing SHOW - 1 for show.
662 SHOW negative means just print the type name or struct tag if there is one.
663 If there is no name, print something sensible but concise like
665 SHOW zero means just print the type name or struct tag if there is one.
666 If there is no name, print something sensible but not as concise like
667 "struct {int x; int y;}".
669 LEVEL is the number of spaces to indent by.
670 We increase it for some recursive calls. */
673 c_type_print_base (struct type *type, struct ui_file *stream, int show,
680 char *demangled_name;
681 char *demangled_no_static;
684 s_none, s_public, s_private, s_protected
687 int need_access_label = 0;
695 fputs_filtered (_("<type unknown>"), stream);
699 /* When SHOW is zero or less, and there is a valid type name, then always
700 just print the type name directly from the type. */
701 /* If we have "typedef struct foo {. . .} bar;" do we want to print it
702 as "struct foo" or as "bar"? Pick the latter, because C++ folk tend
703 to expect things like "class5 *foo" rather than "struct class5 *foo". */
706 && TYPE_NAME (type) != NULL)
708 c_type_print_modifier (type, stream, 0, 1);
709 fputs_filtered (TYPE_NAME (type), stream);
713 CHECK_TYPEDEF (type);
715 switch (TYPE_CODE (type))
717 case TYPE_CODE_TYPEDEF:
718 case TYPE_CODE_ARRAY:
720 case TYPE_CODE_MEMBERPTR:
723 case TYPE_CODE_METHOD:
724 case TYPE_CODE_METHODPTR:
725 c_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
728 case TYPE_CODE_STRUCT:
729 c_type_print_modifier (type, stream, 0, 1);
730 if (TYPE_DECLARED_CLASS (type))
731 fprintf_filtered (stream, "class ");
733 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 struct type *basetype;
767 cp_type_print_derivation_info (stream, type);
769 fprintf_filtered (stream, "{\n");
770 if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
772 if (TYPE_STUB (type))
773 fprintfi_filtered (level + 4, stream, _("<incomplete type>\n"));
775 fprintfi_filtered (level + 4, stream, _("<no data fields>\n"));
778 /* Start off with no specific section type, so we can print
779 one for the first field we find, and use that section type
780 thereafter until we find another type. */
782 section_type = s_none;
784 /* For a class, if all members are private, there's no need
785 for a "private:" label; similarly, for a struct or union
786 masquerading as a class, if all members are public, there's
787 no need for a "public:" label. */
789 if (TYPE_DECLARED_CLASS (type))
792 len = TYPE_NFIELDS (type);
793 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
794 if (!TYPE_FIELD_PRIVATE (type, i))
796 need_access_label = 1;
800 if (!need_access_label)
802 len2 = TYPE_NFN_FIELDS (type);
803 for (j = 0; j < len2; j++)
805 len = TYPE_FN_FIELDLIST_LENGTH (type, j);
806 for (i = 0; i < len; i++)
807 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i))
809 need_access_label = 1;
812 if (need_access_label)
820 len = TYPE_NFIELDS (type);
821 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
822 if (TYPE_FIELD_PRIVATE (type, i) || TYPE_FIELD_PROTECTED (type, i))
824 need_access_label = 1;
828 if (!need_access_label)
830 len2 = TYPE_NFN_FIELDS (type);
831 for (j = 0; j < len2; j++)
834 len = TYPE_FN_FIELDLIST_LENGTH (type, j);
835 for (i = 0; i < len; i++)
836 if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i)
837 || TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type, j), i))
839 need_access_label = 1;
842 if (need_access_label)
848 /* If there is a base class for this type,
849 do not print the field that it occupies. */
851 len = TYPE_NFIELDS (type);
852 vptr_fieldno = get_vptr_fieldno (type, &basetype);
853 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
857 /* If we have a virtual table pointer, omit it. Even if
858 virtual table pointers are not specifically marked in
859 the debug info, they should be artificial. */
860 if ((i == vptr_fieldno && type == basetype)
861 || TYPE_FIELD_ARTIFICIAL (type, i))
864 if (need_access_label)
866 if (TYPE_FIELD_PROTECTED (type, i))
868 if (section_type != s_protected)
870 section_type = s_protected;
871 fprintfi_filtered (level + 2, stream,
875 else if (TYPE_FIELD_PRIVATE (type, i))
877 if (section_type != s_private)
879 section_type = s_private;
880 fprintfi_filtered (level + 2, stream, "private:\n");
885 if (section_type != s_public)
887 section_type = s_public;
888 fprintfi_filtered (level + 2, stream, "public:\n");
893 print_spaces_filtered (level + 4, stream);
894 if (field_is_static (&TYPE_FIELD (type, i)))
895 fprintf_filtered (stream, "static ");
896 c_print_type (TYPE_FIELD_TYPE (type, i),
897 TYPE_FIELD_NAME (type, i),
898 stream, show - 1, level + 4);
899 if (!field_is_static (&TYPE_FIELD (type, i))
900 && TYPE_FIELD_PACKED (type, i))
902 /* It is a bitfield. This code does not attempt
903 to look at the bitpos and reconstruct filler,
904 unnamed fields. This would lead to misleading
905 results if the compiler does not put out fields
906 for such things (I don't know what it does). */
907 fprintf_filtered (stream, " : %d",
908 TYPE_FIELD_BITSIZE (type, i));
910 fprintf_filtered (stream, ";\n");
913 /* If there are both fields and methods, put a blank line
914 between them. Make sure to count only method that we will
915 display; artificial methods will be hidden. */
916 len = TYPE_NFN_FIELDS (type);
918 for (i = 0; i < len; i++)
920 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
921 int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
924 for (j = 0; j < len2; j++)
925 if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
928 if (real_len > 0 && section_type != s_none)
929 fprintf_filtered (stream, "\n");
931 /* C++: print out the methods */
932 for (i = 0; i < len; i++)
934 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
935 int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
936 char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
937 char *name = type_name_no_tag (type);
938 int is_constructor = name && strcmp (method_name, name) == 0;
940 for (j = 0; j < len2; j++)
942 char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
943 int is_full_physname_constructor =
944 is_constructor_name (physname)
945 || is_destructor_name (physname)
946 || method_name[0] == '~';
948 /* Do not print out artificial methods. */
949 if (TYPE_FN_FIELD_ARTIFICIAL (f, j))
953 if (TYPE_FN_FIELD_PROTECTED (f, j))
955 if (section_type != s_protected)
957 section_type = s_protected;
958 fprintfi_filtered (level + 2, stream,
962 else if (TYPE_FN_FIELD_PRIVATE (f, j))
964 if (section_type != s_private)
966 section_type = s_private;
967 fprintfi_filtered (level + 2, stream, "private:\n");
972 if (section_type != s_public)
974 section_type = s_public;
975 fprintfi_filtered (level + 2, stream, "public:\n");
979 print_spaces_filtered (level + 4, stream);
980 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
981 fprintf_filtered (stream, "virtual ");
982 else if (TYPE_FN_FIELD_STATIC_P (f, j))
983 fprintf_filtered (stream, "static ");
984 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
986 /* Keep GDB from crashing here. */
987 fprintf_filtered (stream, _("<undefined type> %s;\n"),
988 TYPE_FN_FIELD_PHYSNAME (f, j));
991 else if (!is_constructor /* constructors don't have declared types */
992 && !is_full_physname_constructor /* " " */
993 && !is_type_conversion_operator (type, i, j))
995 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
997 fputs_filtered (" ", stream);
999 if (TYPE_FN_FIELD_STUB (f, j))
1000 /* Build something we can demangle. */
1001 mangled_name = gdb_mangle_name (type, i, j);
1003 mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
1006 cplus_demangle (mangled_name,
1007 DMGL_ANSI | DMGL_PARAMS);
1008 if (demangled_name == NULL)
1010 /* in some cases (for instance with the HP demangling),
1011 if a function has more than 10 arguments,
1012 the demangling will fail.
1013 Let's try to reconstruct the function signature from
1014 the symbol information */
1015 if (!TYPE_FN_FIELD_STUB (f, j))
1017 int staticp = TYPE_FN_FIELD_STATIC_P (f, j);
1018 struct type *mtype = TYPE_FN_FIELD_TYPE (f, j);
1020 cp_type_print_method_args (mtype,
1027 fprintf_filtered (stream, _("<badly mangled name '%s'>"),
1033 char *demangled_no_class
1034 = remove_qualifiers (demangled_name);
1036 /* get rid of the `static' appended by the demangler */
1037 p = strstr (demangled_no_class, " static");
1040 int length = p - demangled_no_class;
1042 demangled_no_static = (char *) xmalloc (length + 1);
1043 strncpy (demangled_no_static, demangled_no_class, length);
1044 *(demangled_no_static + length) = '\0';
1045 fputs_filtered (demangled_no_static, stream);
1046 xfree (demangled_no_static);
1049 fputs_filtered (demangled_no_class, stream);
1050 xfree (demangled_name);
1053 if (TYPE_FN_FIELD_STUB (f, j))
1054 xfree (mangled_name);
1056 fprintf_filtered (stream, ";\n");
1060 fprintfi_filtered (level, stream, "}");
1062 if (TYPE_LOCALTYPE_PTR (type) && show >= 0)
1063 fprintfi_filtered (level, stream, _(" (Local at %s:%d)\n"),
1064 TYPE_LOCALTYPE_FILE (type),
1065 TYPE_LOCALTYPE_LINE (type));
1069 case TYPE_CODE_ENUM:
1070 c_type_print_modifier (type, stream, 0, 1);
1071 fprintf_filtered (stream, "enum ");
1072 /* Print the tag name if it exists.
1073 The aCC compiler emits a spurious
1074 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1075 tag for unnamed struct/union/enum's, which we don't
1077 if (TYPE_TAG_NAME (type) != NULL
1078 && strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
1080 fputs_filtered (TYPE_TAG_NAME (type), stream);
1082 fputs_filtered (" ", stream);
1088 /* If we just printed a tag name, no need to print anything else. */
1089 if (TYPE_TAG_NAME (type) == NULL)
1090 fprintf_filtered (stream, "{...}");
1092 else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1094 fprintf_filtered (stream, "{");
1095 len = TYPE_NFIELDS (type);
1097 for (i = 0; i < len; i++)
1101 fprintf_filtered (stream, ", ");
1103 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1104 if (lastval != TYPE_FIELD_BITPOS (type, i))
1106 fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
1107 lastval = TYPE_FIELD_BITPOS (type, i);
1111 fprintf_filtered (stream, "}");
1115 case TYPE_CODE_VOID:
1116 fprintf_filtered (stream, "void");
1119 case TYPE_CODE_UNDEF:
1120 fprintf_filtered (stream, _("struct <unknown>"));
1123 case TYPE_CODE_ERROR:
1124 fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
1127 case TYPE_CODE_RANGE:
1128 /* This should not occur */
1129 fprintf_filtered (stream, _("<range type>"));
1132 case TYPE_CODE_NAMESPACE:
1133 fputs_filtered ("namespace ", stream);
1134 fputs_filtered (TYPE_TAG_NAME (type), stream);
1138 /* Handle types not explicitly handled by the other cases,
1139 such as fundamental types. For these, just print whatever
1140 the type name is, as recorded in the type itself. If there
1141 is no type name, then complain. */
1142 if (TYPE_NAME (type) != NULL)
1144 c_type_print_modifier (type, stream, 0, 1);
1145 fputs_filtered (TYPE_NAME (type), stream);
1149 /* At least for dump_symtab, it is important that this not be
1151 fprintf_filtered (stream, _("<invalid type code %d>"),