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
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 2 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, write to the Free Software
20 Foundation, Inc., 51 Franklin Street, Fifth Floor,
21 Boston, MA 02110-1301, USA. */
24 #include "gdb_obstack.h"
25 #include "bfd.h" /* Binary File Description */
28 #include "expression.h"
35 #include "typeprint.h"
38 #include "gdb_string.h"
41 static void cp_type_print_method_args (struct type *mtype, char *prefix,
42 char *varstring, int staticp,
43 struct ui_file *stream);
45 static void c_type_print_args (struct type *, struct ui_file *);
47 static void cp_type_print_derivation_info (struct ui_file *, struct type *);
49 static void c_type_print_varspec_prefix (struct type *, struct ui_file *, int,
52 /* Print "const", "volatile", or address space modifiers. */
53 static void c_type_print_modifier (struct type *, struct ui_file *,
59 /* LEVEL is the depth to indent lines by. */
62 c_print_type (struct type *type, char *varstring, struct ui_file *stream,
72 c_type_print_base (type, stream, show, level);
73 code = TYPE_CODE (type);
74 if ((varstring != NULL && *varstring != '\0')
76 /* Need a space if going to print stars or brackets;
77 but not if we will print just a type name. */
78 ((show > 0 || TYPE_NAME (type) == 0)
80 (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
81 || code == TYPE_CODE_METHOD
82 || code == TYPE_CODE_ARRAY
83 || code == TYPE_CODE_MEMBERPTR
84 || code == TYPE_CODE_METHODPTR
85 || code == TYPE_CODE_REF)))
86 fputs_filtered (" ", stream);
87 need_post_space = (varstring != NULL && strcmp (varstring, "") != 0);
88 c_type_print_varspec_prefix (type, stream, show, 0, need_post_space);
90 if (varstring != NULL)
92 fputs_filtered (varstring, stream);
94 /* For demangled function names, we have the arglist as part of the name,
95 so don't print an additional pair of ()'s */
97 demangled_args = strchr (varstring, '(') != NULL;
98 c_type_print_varspec_suffix (type, stream, show, 0, demangled_args);
102 /* If TYPE is a derived type, then print out derivation information.
103 Print only the actual base classes of this type, not the base classes
104 of the base classes. I.E. for the derivation hierarchy:
107 class B : public A {int b; };
108 class C : public B {int c; };
110 Print the type of class C as:
116 Not as the following (like gdb used to), which is not legal C++ syntax for
117 derived types and may be confused with the multiple inheritance form:
119 class C : public B : public A {
123 In general, gdb should try to print the types as closely as possible to
124 the form that they appear in the source code.
125 Note that in case of protected derivation gcc will not say 'protected'
126 but 'private'. The HP's aCC compiler emits specific information for
127 derivation via protected inheritance, so gdb can print it out */
130 cp_type_print_derivation_info (struct ui_file *stream, struct type *type)
135 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
137 fputs_filtered (i == 0 ? ": " : ", ", stream);
138 fprintf_filtered (stream, "%s%s ",
139 BASETYPE_VIA_PUBLIC (type, i) ? "public"
140 : (TYPE_FIELD_PROTECTED (type, i) ? "protected" : "private"),
141 BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : "");
142 name = type_name_no_tag (TYPE_BASECLASS (type, i));
143 fprintf_filtered (stream, "%s", name ? name : "(null)");
147 fputs_filtered (" ", stream);
151 /* Print the C++ method arguments ARGS to the file STREAM. */
154 cp_type_print_method_args (struct type *mtype, char *prefix, char *varstring,
155 int staticp, struct ui_file *stream)
157 struct field *args = TYPE_FIELDS (mtype);
158 int nargs = TYPE_NFIELDS (mtype);
159 int varargs = TYPE_VARARGS (mtype);
162 fprintf_symbol_filtered (stream, prefix, language_cplus, DMGL_ANSI);
163 fprintf_symbol_filtered (stream, varstring, language_cplus, DMGL_ANSI);
164 fputs_filtered ("(", stream);
166 /* Skip the class variable. */
172 type_print (args[i++].type, "", stream, 0);
174 if (i == nargs && varargs)
175 fprintf_filtered (stream, ", ...");
177 fprintf_filtered (stream, ", ");
181 fprintf_filtered (stream, "...");
182 else if (current_language->la_language == language_cplus)
183 fprintf_filtered (stream, "void");
185 fprintf_filtered (stream, ")");
189 /* Print any asterisks or open-parentheses needed before the
190 variable name (to describe its type).
192 On outermost call, pass 0 for PASSED_A_PTR.
193 On outermost call, SHOW > 0 means should ignore
194 any typename for TYPE and show its details.
195 SHOW is always zero on recursive calls.
197 NEED_POST_SPACE is non-zero when a space will be be needed
198 between a trailing qualifier and a field, variable, or function
202 c_type_print_varspec_prefix (struct type *type, struct ui_file *stream,
203 int show, int passed_a_ptr, int need_post_space)
209 if (TYPE_NAME (type) && show <= 0)
214 switch (TYPE_CODE (type))
217 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 1, 1);
218 fprintf_filtered (stream, "*");
219 c_type_print_modifier (type, stream, 1, need_post_space);
222 case TYPE_CODE_MEMBERPTR:
223 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
224 name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
226 fputs_filtered (name, stream);
228 c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
229 fprintf_filtered (stream, "::*");
232 case TYPE_CODE_METHODPTR:
233 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
234 fprintf_filtered (stream, "(");
235 name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
237 fputs_filtered (name, stream);
239 c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
240 fprintf_filtered (stream, "::*");
244 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 1, 0);
245 fprintf_filtered (stream, "&");
246 c_type_print_modifier (type, stream, 1, need_post_space);
249 case TYPE_CODE_METHOD:
251 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
253 fprintf_filtered (stream, "(");
256 case TYPE_CODE_ARRAY:
257 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
259 fprintf_filtered (stream, "(");
262 case TYPE_CODE_TYPEDEF:
263 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
266 case TYPE_CODE_UNDEF:
267 case TYPE_CODE_STRUCT:
268 case TYPE_CODE_UNION:
273 case TYPE_CODE_ERROR:
277 case TYPE_CODE_RANGE:
278 case TYPE_CODE_STRING:
279 case TYPE_CODE_BITSTRING:
280 case TYPE_CODE_COMPLEX:
281 case TYPE_CODE_TEMPLATE:
282 case TYPE_CODE_NAMESPACE:
283 /* These types need no prefix. They are listed here so that
284 gcc -Wall will reveal any types that haven't been handled. */
287 error (_("type not handled in c_type_print_varspec_prefix()"));
292 /* Print out "const" and "volatile" attributes.
293 TYPE is a pointer to the type being printed out.
294 STREAM is the output destination.
295 NEED_SPACE = 1 indicates an initial white space is needed */
298 c_type_print_modifier (struct type *type, struct ui_file *stream,
299 int need_pre_space, int need_post_space)
301 int did_print_modifier = 0;
302 const char *address_space_id;
304 /* We don't print `const' qualifiers for references --- since all
305 operators affect the thing referenced, not the reference itself,
306 every reference is `const'. */
307 if (TYPE_CONST (type)
308 && TYPE_CODE (type) != TYPE_CODE_REF)
311 fprintf_filtered (stream, " ");
312 fprintf_filtered (stream, "const");
313 did_print_modifier = 1;
316 if (TYPE_VOLATILE (type))
318 if (did_print_modifier || need_pre_space)
319 fprintf_filtered (stream, " ");
320 fprintf_filtered (stream, "volatile");
321 did_print_modifier = 1;
324 address_space_id = address_space_int_to_name (TYPE_INSTANCE_FLAGS (type));
325 if (address_space_id)
327 if (did_print_modifier || need_pre_space)
328 fprintf_filtered (stream, " ");
329 fprintf_filtered (stream, "@%s", address_space_id);
330 did_print_modifier = 1;
333 if (did_print_modifier && need_post_space)
334 fprintf_filtered (stream, " ");
338 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
339 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
340 in non-static methods, are displayed. */
343 c_type_print_args (struct type *type, struct ui_file *stream)
349 fprintf_filtered (stream, "(");
350 args = TYPE_FIELDS (type);
351 len = TYPE_NFIELDS (type);
353 for (i = 0; i < TYPE_NFIELDS (type); i++)
357 fprintf_filtered (stream, ", ");
361 c_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
365 if (printed_any && TYPE_VARARGS (type))
367 /* Print out a trailing ellipsis for varargs functions. Ignore
368 TYPE_VARARGS if the function has no named arguments; that
369 represents unprototyped (K&R style) C functions. */
370 if (printed_any && TYPE_VARARGS (type))
372 fprintf_filtered (stream, ", ");
374 fprintf_filtered (stream, "...");
377 else if (!printed_any
378 && (TYPE_PROTOTYPED (type)
379 || current_language->la_language == language_cplus))
380 fprintf_filtered (stream, "void");
382 fprintf_filtered (stream, ")");
386 /* Return true iff the j'th overloading of the i'th method of TYPE
387 is a type conversion operator, like `operator int () { ... }'.
388 When listing a class's methods, we don't print the return type of
391 is_type_conversion_operator (struct type *type, int i, int j)
393 /* I think the whole idea of recognizing type conversion operators
394 by their name is pretty terrible. But I don't think our present
395 data structure gives us any other way to tell. If you know of
396 some other way, feel free to rewrite this function. */
397 char *name = TYPE_FN_FIELDLIST_NAME (type, i);
399 if (strncmp (name, "operator", 8) != 0)
403 if (! strchr (" \t\f\n\r", *name))
406 while (strchr (" \t\f\n\r", *name))
409 if (!('a' <= *name && *name <= 'z')
410 && !('A' <= *name && *name <= 'Z')
412 /* If this doesn't look like the start of an identifier, then it
413 isn't a type conversion operator. */
415 else if (strncmp (name, "new", 3) == 0)
417 else if (strncmp (name, "delete", 6) == 0)
420 /* If it doesn't look like new or delete, it's a type conversion
424 /* Is that really the end of the name? */
425 if (('a' <= *name && *name <= 'z')
426 || ('A' <= *name && *name <= 'Z')
427 || ('0' <= *name && *name <= '9')
429 /* No, so the identifier following "operator" must be a type name,
430 and this is a type conversion operator. */
433 /* That was indeed the end of the name, so it was `operator new' or
434 `operator delete', neither of which are type conversion operators. */
439 /* Given a C++ qualified identifier QID, strip off the qualifiers,
440 yielding the unqualified name. The return value is a pointer into
443 It's a pity we don't have this information in some more structured
444 form. Even the author of this function feels that writing little
445 parsers like this everywhere is stupid. */
447 remove_qualifiers (char *qid)
449 int quoted = 0; /* zero if we're not in quotes;
450 '"' if we're in a double-quoted string;
451 '\'' if we're in a single-quoted string. */
452 int depth = 0; /* number of unclosed parens we've seen */
453 char *parenstack = (char *) alloca (strlen (qid));
455 char *last = 0; /* The character after the rightmost
456 `::' token we've seen so far. */
458 for (scan = qid; *scan; scan++)
464 else if (*scan == '\\' && *(scan + 1))
467 else if (scan[0] == ':' && scan[1] == ':')
469 /* If we're inside parenthesis (i.e., an argument list) or
470 angle brackets (i.e., a list of template arguments), then
471 we don't record the position of this :: token, since it's
472 not relevant to the top-level structure we're trying
480 else if (*scan == '"' || *scan == '\'')
482 else if (*scan == '(')
483 parenstack[depth++] = ')';
484 else if (*scan == '[')
485 parenstack[depth++] = ']';
486 /* We're going to treat <> as a pair of matching characters,
487 since we're more likely to see those in template id's than
488 real less-than characters. What a crock. */
489 else if (*scan == '<')
490 parenstack[depth++] = '>';
491 else if (*scan == ')' || *scan == ']' || *scan == '>')
493 if (depth > 0 && parenstack[depth - 1] == *scan)
497 /* We're going to do a little error recovery here. If we
498 don't find a match for *scan on the paren stack, but
499 there is something lower on the stack that does match, we
500 pop the stack to that point. */
503 for (i = depth - 1; i >= 0; i--)
504 if (parenstack[i] == *scan)
516 /* We didn't find any :: tokens at the top level, so declare the
517 whole thing an unqualified identifier. */
522 /* Print any array sizes, function arguments or close parentheses
523 needed after the variable name (to describe its type).
524 Args work like c_type_print_varspec_prefix. */
527 c_type_print_varspec_suffix (struct type *type, struct ui_file *stream,
528 int show, int passed_a_ptr, int demangled_args)
533 if (TYPE_NAME (type) && show <= 0)
538 switch (TYPE_CODE (type))
540 case TYPE_CODE_ARRAY:
542 fprintf_filtered (stream, ")");
544 fprintf_filtered (stream, "[");
545 if (TYPE_LENGTH (type) >= 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
546 && TYPE_ARRAY_UPPER_BOUND_TYPE (type) != BOUND_CANNOT_BE_DETERMINED)
547 fprintf_filtered (stream, "%d",
549 / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
550 fprintf_filtered (stream, "]");
552 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
556 case TYPE_CODE_MEMBERPTR:
557 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
561 case TYPE_CODE_METHODPTR:
562 fprintf_filtered (stream, ")");
563 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
569 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
573 case TYPE_CODE_METHOD:
576 fprintf_filtered (stream, ")");
578 c_type_print_args (type, stream);
579 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
583 case TYPE_CODE_TYPEDEF:
584 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
588 case TYPE_CODE_UNDEF:
589 case TYPE_CODE_STRUCT:
590 case TYPE_CODE_UNION:
595 case TYPE_CODE_ERROR:
599 case TYPE_CODE_RANGE:
600 case TYPE_CODE_STRING:
601 case TYPE_CODE_BITSTRING:
602 case TYPE_CODE_COMPLEX:
603 case TYPE_CODE_TEMPLATE:
604 case TYPE_CODE_NAMESPACE:
605 /* These types do not need a suffix. They are listed so that
606 gcc -Wall will report types that may not have been considered. */
609 error (_("type not handled in c_type_print_varspec_suffix()"));
614 /* Print the name of the type (or the ultimate pointer target,
615 function value or array element), or the description of a
618 SHOW positive means print details about the type (e.g. enum values),
619 and print structure elements passing SHOW - 1 for show.
620 SHOW negative means just print the type name or struct tag if there is one.
621 If there is no name, print something sensible but concise like
623 SHOW zero means just print the type name or struct tag if there is one.
624 If there is no name, print something sensible but not as concise like
625 "struct {int x; int y;}".
627 LEVEL is the number of spaces to indent by.
628 We increase it for some recursive calls. */
631 c_type_print_base (struct type *type, struct ui_file *stream, int show,
638 char *demangled_name;
639 char *demangled_no_static;
642 s_none, s_public, s_private, s_protected
645 int need_access_label = 0;
653 fputs_filtered (_("<type unknown>"), stream);
657 /* When SHOW is zero or less, and there is a valid type name, then always
658 just print the type name directly from the type. */
659 /* If we have "typedef struct foo {. . .} bar;" do we want to print it
660 as "struct foo" or as "bar"? Pick the latter, because C++ folk tend
661 to expect things like "class5 *foo" rather than "struct class5 *foo". */
664 && TYPE_NAME (type) != NULL)
666 c_type_print_modifier (type, stream, 0, 1);
667 fputs_filtered (TYPE_NAME (type), stream);
671 CHECK_TYPEDEF (type);
673 switch (TYPE_CODE (type))
675 case TYPE_CODE_TYPEDEF:
676 case TYPE_CODE_ARRAY:
678 case TYPE_CODE_MEMBERPTR:
681 case TYPE_CODE_METHOD:
682 case TYPE_CODE_METHODPTR:
683 c_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
686 case TYPE_CODE_STRUCT:
687 c_type_print_modifier (type, stream, 0, 1);
688 /* Note TYPE_CODE_STRUCT and TYPE_CODE_CLASS have the same value,
689 * so we use another means for distinguishing them.
691 if (HAVE_CPLUS_STRUCT (type))
693 switch (TYPE_DECLARED_TYPE (type))
695 case DECLARED_TYPE_CLASS:
696 fprintf_filtered (stream, "class ");
698 case DECLARED_TYPE_UNION:
699 fprintf_filtered (stream, "union ");
701 case DECLARED_TYPE_STRUCT:
702 fprintf_filtered (stream, "struct ");
705 /* If there is a CPLUS_STRUCT, assume class if not
706 * otherwise specified in the declared_type field.
708 fprintf_filtered (stream, "class ");
714 /* If not CPLUS_STRUCT, then assume it's a C struct */
715 fprintf_filtered (stream, "struct ");
719 case TYPE_CODE_UNION:
720 c_type_print_modifier (type, stream, 0, 1);
721 fprintf_filtered (stream, "union ");
725 /* Print the tag if it exists.
726 * The HP aCC compiler emits
727 * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
728 * tag for unnamed struct/union/enum's, which we don't
731 if (TYPE_TAG_NAME (type) != NULL &&
732 strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
734 fputs_filtered (TYPE_TAG_NAME (type), stream);
736 fputs_filtered (" ", stream);
741 /* If we just printed a tag name, no need to print anything else. */
742 if (TYPE_TAG_NAME (type) == NULL)
743 fprintf_filtered (stream, "{...}");
745 else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
747 cp_type_print_derivation_info (stream, type);
749 fprintf_filtered (stream, "{\n");
750 if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
752 if (TYPE_STUB (type))
753 fprintfi_filtered (level + 4, stream, _("<incomplete type>\n"));
755 fprintfi_filtered (level + 4, stream, _("<no data fields>\n"));
758 /* Start off with no specific section type, so we can print
759 one for the first field we find, and use that section type
760 thereafter until we find another type. */
762 section_type = s_none;
764 /* For a class, if all members are private, there's no need
765 for a "private:" label; similarly, for a struct or union
766 masquerading as a class, if all members are public, there's
767 no need for a "public:" label. */
769 if ((TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_CLASS) ||
770 (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_TEMPLATE))
773 len = TYPE_NFIELDS (type);
774 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
775 if (!TYPE_FIELD_PRIVATE (type, i))
777 need_access_label = 1;
781 if (!need_access_label)
783 len2 = TYPE_NFN_FIELDS (type);
784 for (j = 0; j < len2; j++)
786 len = TYPE_FN_FIELDLIST_LENGTH (type, j);
787 for (i = 0; i < len; i++)
788 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i))
790 need_access_label = 1;
793 if (need_access_label)
798 else if ((TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_STRUCT) ||
799 (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_UNION))
802 len = TYPE_NFIELDS (type);
803 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
804 if (TYPE_FIELD_PRIVATE (type, i) || TYPE_FIELD_PROTECTED (type, i))
806 need_access_label = 1;
810 if (!need_access_label)
812 len2 = TYPE_NFN_FIELDS (type);
813 for (j = 0; j < len2; j++)
816 len = TYPE_FN_FIELDLIST_LENGTH (type, j);
817 for (i = 0; i < len; i++)
818 if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i) ||
819 TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type, j), i))
821 need_access_label = 1;
824 if (need_access_label)
830 /* If there is a base class for this type,
831 do not print the field that it occupies. */
833 len = TYPE_NFIELDS (type);
834 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
837 /* Don't print out virtual function table. */
838 /* HP ANSI C++ case */
839 if (TYPE_HAS_VTABLE (type)
840 && (strncmp (TYPE_FIELD_NAME (type, i), "__vfp", 5) == 0))
842 /* Other compilers */
843 if (strncmp (TYPE_FIELD_NAME (type, i), "_vptr", 5) == 0
844 && is_cplus_marker ((TYPE_FIELD_NAME (type, i))[5]))
847 /* If this is a C++ class we can print the various C++ section
850 if (HAVE_CPLUS_STRUCT (type) && need_access_label)
852 if (TYPE_FIELD_PROTECTED (type, i))
854 if (section_type != s_protected)
856 section_type = s_protected;
857 fprintfi_filtered (level + 2, stream,
861 else if (TYPE_FIELD_PRIVATE (type, i))
863 if (section_type != s_private)
865 section_type = s_private;
866 fprintfi_filtered (level + 2, stream, "private:\n");
871 if (section_type != s_public)
873 section_type = s_public;
874 fprintfi_filtered (level + 2, stream, "public:\n");
879 print_spaces_filtered (level + 4, stream);
880 if (TYPE_FIELD_STATIC (type, i))
882 fprintf_filtered (stream, "static ");
884 c_print_type (TYPE_FIELD_TYPE (type, i),
885 TYPE_FIELD_NAME (type, i),
886 stream, show - 1, level + 4);
887 if (!TYPE_FIELD_STATIC (type, i)
888 && TYPE_FIELD_PACKED (type, i))
890 /* It is a bitfield. This code does not attempt
891 to look at the bitpos and reconstruct filler,
892 unnamed fields. This would lead to misleading
893 results if the compiler does not put out fields
894 for such things (I don't know what it does). */
895 fprintf_filtered (stream, " : %d",
896 TYPE_FIELD_BITSIZE (type, i));
898 fprintf_filtered (stream, ";\n");
901 /* If there are both fields and methods, put a blank line
902 between them. Make sure to count only method that we will
903 display; artificial methods will be hidden. */
904 len = TYPE_NFN_FIELDS (type);
906 for (i = 0; i < len; i++)
908 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
909 int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
911 for (j = 0; j < len2; j++)
912 if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
915 if (real_len > 0 && section_type != s_none)
916 fprintf_filtered (stream, "\n");
918 /* C++: print out the methods */
919 for (i = 0; i < len; i++)
921 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
922 int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
923 char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
924 char *name = type_name_no_tag (type);
925 int is_constructor = name && strcmp (method_name, name) == 0;
926 for (j = 0; j < len2; j++)
928 char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
929 int is_full_physname_constructor =
930 is_constructor_name (physname)
931 || is_destructor_name (physname)
932 || method_name[0] == '~';
934 /* Do not print out artificial methods. */
935 if (TYPE_FN_FIELD_ARTIFICIAL (f, j))
939 if (TYPE_FN_FIELD_PROTECTED (f, j))
941 if (section_type != s_protected)
943 section_type = s_protected;
944 fprintfi_filtered (level + 2, stream,
948 else if (TYPE_FN_FIELD_PRIVATE (f, j))
950 if (section_type != s_private)
952 section_type = s_private;
953 fprintfi_filtered (level + 2, stream, "private:\n");
958 if (section_type != s_public)
960 section_type = s_public;
961 fprintfi_filtered (level + 2, stream, "public:\n");
965 print_spaces_filtered (level + 4, stream);
966 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
967 fprintf_filtered (stream, "virtual ");
968 else if (TYPE_FN_FIELD_STATIC_P (f, j))
969 fprintf_filtered (stream, "static ");
970 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
972 /* Keep GDB from crashing here. */
973 fprintf_filtered (stream, _("<undefined type> %s;\n"),
974 TYPE_FN_FIELD_PHYSNAME (f, j));
977 else if (!is_constructor && /* constructors don't have declared types */
978 !is_full_physname_constructor && /* " " */
979 !is_type_conversion_operator (type, i, j))
981 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
983 fputs_filtered (" ", stream);
985 if (TYPE_FN_FIELD_STUB (f, j))
986 /* Build something we can demangle. */
987 mangled_name = gdb_mangle_name (type, i, j);
989 mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
992 cplus_demangle (mangled_name,
993 DMGL_ANSI | DMGL_PARAMS);
994 if (demangled_name == NULL)
996 /* in some cases (for instance with the HP demangling),
997 if a function has more than 10 arguments,
998 the demangling will fail.
999 Let's try to reconstruct the function signature from
1000 the symbol information */
1001 if (!TYPE_FN_FIELD_STUB (f, j))
1003 int staticp = TYPE_FN_FIELD_STATIC_P (f, j);
1004 struct type *mtype = TYPE_FN_FIELD_TYPE (f, j);
1005 cp_type_print_method_args (mtype,
1012 fprintf_filtered (stream, _("<badly mangled name '%s'>"),
1018 char *demangled_no_class
1019 = remove_qualifiers (demangled_name);
1021 /* get rid of the `static' appended by the demangler */
1022 p = strstr (demangled_no_class, " static");
1025 int length = p - demangled_no_class;
1026 demangled_no_static = (char *) xmalloc (length + 1);
1027 strncpy (demangled_no_static, demangled_no_class, length);
1028 *(demangled_no_static + length) = '\0';
1029 fputs_filtered (demangled_no_static, stream);
1030 xfree (demangled_no_static);
1033 fputs_filtered (demangled_no_class, stream);
1034 xfree (demangled_name);
1037 if (TYPE_FN_FIELD_STUB (f, j))
1038 xfree (mangled_name);
1040 fprintf_filtered (stream, ";\n");
1044 fprintfi_filtered (level, stream, "}");
1046 if (TYPE_LOCALTYPE_PTR (type) && show >= 0)
1047 fprintfi_filtered (level, stream, _(" (Local at %s:%d)\n"),
1048 TYPE_LOCALTYPE_FILE (type),
1049 TYPE_LOCALTYPE_LINE (type));
1051 if (TYPE_CODE (type) == TYPE_CODE_TEMPLATE)
1055 case TYPE_CODE_ENUM:
1056 c_type_print_modifier (type, stream, 0, 1);
1057 /* HP C supports sized enums */
1058 if (deprecated_hp_som_som_object_present)
1059 switch (TYPE_LENGTH (type))
1062 fputs_filtered ("char ", stream);
1065 fputs_filtered ("short ", stream);
1070 fprintf_filtered (stream, "enum ");
1071 /* Print the tag name if it exists.
1072 The aCC compiler emits a spurious
1073 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1074 tag for unnamed struct/union/enum's, which we don't
1076 if (TYPE_TAG_NAME (type) != NULL &&
1077 strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
1079 fputs_filtered (TYPE_TAG_NAME (type), stream);
1081 fputs_filtered (" ", stream);
1087 /* If we just printed a tag name, no need to print anything else. */
1088 if (TYPE_TAG_NAME (type) == NULL)
1089 fprintf_filtered (stream, "{...}");
1091 else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1093 fprintf_filtered (stream, "{");
1094 len = TYPE_NFIELDS (type);
1096 for (i = 0; i < len; i++)
1100 fprintf_filtered (stream, ", ");
1102 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1103 if (lastval != TYPE_FIELD_BITPOS (type, i))
1105 fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
1106 lastval = TYPE_FIELD_BITPOS (type, i);
1110 fprintf_filtered (stream, "}");
1114 case TYPE_CODE_VOID:
1115 fprintf_filtered (stream, "void");
1118 case TYPE_CODE_UNDEF:
1119 fprintf_filtered (stream, _("struct <unknown>"));
1122 case TYPE_CODE_ERROR:
1123 fprintf_filtered (stream, _("<unknown type>"));
1126 case TYPE_CODE_RANGE:
1127 /* This should not occur */
1128 fprintf_filtered (stream, _("<range type>"));
1131 case TYPE_CODE_TEMPLATE:
1132 /* Called on "ptype t" where "t" is a template.
1133 Prints the template header (with args), e.g.:
1134 template <class T1, class T2> class "
1135 and then merges with the struct/union/class code to
1136 print the rest of the definition. */
1137 c_type_print_modifier (type, stream, 0, 1);
1138 fprintf_filtered (stream, "template <");
1139 for (i = 0; i < TYPE_NTEMPLATE_ARGS (type); i++)
1141 struct template_arg templ_arg;
1142 templ_arg = TYPE_TEMPLATE_ARG (type, i);
1143 fprintf_filtered (stream, "class %s", templ_arg.name);
1144 if (i < TYPE_NTEMPLATE_ARGS (type) - 1)
1145 fprintf_filtered (stream, ", ");
1147 fprintf_filtered (stream, "> class ");
1148 /* Yuck, factor this out to a subroutine so we can call
1149 it and return to the point marked with the "goback:" label... - RT */
1152 if (TYPE_NINSTANTIATIONS (type) > 0)
1154 fprintf_filtered (stream, _("\ntemplate instantiations:\n"));
1155 for (i = 0; i < TYPE_NINSTANTIATIONS (type); i++)
1157 fprintf_filtered (stream, " ");
1158 c_type_print_base (TYPE_INSTANTIATION (type, i), stream, 0, level);
1159 if (i < TYPE_NINSTANTIATIONS (type) - 1)
1160 fprintf_filtered (stream, "\n");
1165 case TYPE_CODE_NAMESPACE:
1166 fputs_filtered ("namespace ", stream);
1167 fputs_filtered (TYPE_TAG_NAME (type), stream);
1171 /* Handle types not explicitly handled by the other cases,
1172 such as fundamental types. For these, just print whatever
1173 the type name is, as recorded in the type itself. If there
1174 is no type name, then complain. */
1175 if (TYPE_NAME (type) != NULL)
1177 c_type_print_modifier (type, stream, 0, 1);
1178 fputs_filtered (TYPE_NAME (type), stream);
1182 /* At least for dump_symtab, it is important that this not be
1184 fprintf_filtered (stream, _("<invalid type code %d>"),