1 /* Support for printing C and C++ types for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1998,
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., 59 Temple Place - Suite 330,
21 Boston, MA 02111-1307, USA. */
25 #include "bfd.h" /* Binary File Description */
28 #include "expression.h"
37 #include "typeprint.h"
39 #include "gdb_string.h"
42 /* Flag indicating target was compiled by HP compiler */
43 extern int hp_som_som_object_present;
45 static void cp_type_print_method_args (struct type ** args, char *prefix,
46 char *varstring, int staticp,
47 struct ui_file *stream);
49 static void c_type_print_args (struct type *, struct ui_file *);
51 static void cp_type_print_derivation_info (struct ui_file *, struct type *);
53 void c_type_print_varspec_prefix (struct type *, struct ui_file *, int,
56 static void c_type_print_cv_qualifier (struct type *, struct ui_file *,
62 /* LEVEL is the depth to indent lines by. */
65 c_print_type (struct type *type, char *varstring, struct ui_file *stream,
68 register enum type_code code;
74 c_type_print_base (type, stream, show, level);
75 code = TYPE_CODE (type);
76 if ((varstring != NULL && *varstring != '\0')
78 /* Need a space if going to print stars or brackets;
79 but not if we will print just a type name. */
80 ((show > 0 || TYPE_NAME (type) == 0)
82 (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
83 || code == TYPE_CODE_METHOD
84 || code == TYPE_CODE_ARRAY
85 || code == TYPE_CODE_MEMBER
86 || code == TYPE_CODE_REF)))
87 fputs_filtered (" ", stream);
88 c_type_print_varspec_prefix (type, stream, show, 0);
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);
150 /* Print the C++ method arguments ARGS to the file STREAM. */
153 cp_type_print_method_args (struct type **args, char *prefix, char *varstring,
154 int staticp, struct ui_file *stream)
158 fprintf_symbol_filtered (stream, prefix, language_cplus, DMGL_ANSI);
159 fprintf_symbol_filtered (stream, varstring, language_cplus, DMGL_ANSI);
160 fputs_filtered ("(", stream);
161 if (args && args[!staticp] && args[!staticp]->code != TYPE_CODE_VOID)
163 i = !staticp; /* skip the class variable */
166 type_print (args[i++], "", stream, 0);
169 fprintf_filtered (stream, " ...");
172 else if (args[i]->code != TYPE_CODE_VOID)
174 fprintf_filtered (stream, ", ");
180 else if (current_language->la_language == language_cplus)
182 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. */
198 c_type_print_varspec_prefix (struct type *type, struct ui_file *stream,
199 int show, int passed_a_ptr)
205 if (TYPE_NAME (type) && show <= 0)
210 switch (TYPE_CODE (type))
213 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1);
214 fprintf_filtered (stream, "*");
215 c_type_print_cv_qualifier (type, stream, 1, 0);
218 case TYPE_CODE_MEMBER:
220 fprintf_filtered (stream, "(");
221 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
222 fprintf_filtered (stream, " ");
223 name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
225 fputs_filtered (name, stream);
227 c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
228 fprintf_filtered (stream, "::");
231 case TYPE_CODE_METHOD:
233 fprintf_filtered (stream, "(");
234 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
237 fprintf_filtered (stream, " ");
238 c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
239 fprintf_filtered (stream, "::");
244 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1);
245 fprintf_filtered (stream, "&");
246 c_type_print_cv_qualifier (type, stream, 1, 0);
250 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
252 fprintf_filtered (stream, "(");
255 case TYPE_CODE_ARRAY:
256 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 0);
258 fprintf_filtered (stream, "(");
261 case TYPE_CODE_UNDEF:
262 case TYPE_CODE_STRUCT:
263 case TYPE_CODE_UNION:
268 case TYPE_CODE_ERROR:
272 case TYPE_CODE_RANGE:
273 case TYPE_CODE_STRING:
274 case TYPE_CODE_BITSTRING:
275 case TYPE_CODE_COMPLEX:
276 case TYPE_CODE_TYPEDEF:
277 case TYPE_CODE_TEMPLATE:
278 /* These types need no prefix. They are listed here so that
279 gcc -Wall will reveal any types that haven't been handled. */
282 error ("type not handled in c_type_print_varspec_prefix()");
287 /* Print out "const" and "volatile" attributes.
288 TYPE is a pointer to the type being printed out.
289 STREAM is the output destination.
290 NEED_SPACE = 1 indicates an initial white space is needed */
293 c_type_print_cv_qualifier (struct type *type, struct ui_file *stream,
294 int need_pre_space, int need_post_space)
298 if (TYPE_CONST (type))
301 fprintf_filtered (stream, " ");
302 fprintf_filtered (stream, "const");
306 if (TYPE_VOLATILE (type))
308 if (flag || need_pre_space)
309 fprintf_filtered (stream, " ");
310 fprintf_filtered (stream, "volatile");
314 if (flag && need_post_space)
315 fprintf_filtered (stream, " ");
322 c_type_print_args (struct type *type, struct ui_file *stream)
327 fprintf_filtered (stream, "(");
328 args = TYPE_ARG_TYPES (type);
333 fprintf_filtered (stream, "...");
335 else if ((args[1]->code == TYPE_CODE_VOID) &&
336 (current_language->la_language == language_cplus))
338 fprintf_filtered (stream, "void");
343 args[i] != NULL && args[i]->code != TYPE_CODE_VOID;
346 c_print_type (args[i], "", stream, -1, 0);
347 if (args[i + 1] == NULL)
349 fprintf_filtered (stream, "...");
351 else if (args[i + 1]->code != TYPE_CODE_VOID)
353 fprintf_filtered (stream, ",");
359 else if (current_language->la_language == language_cplus)
361 fprintf_filtered (stream, "void");
364 fprintf_filtered (stream, ")");
368 /* Return true iff the j'th overloading of the i'th method of TYPE
369 is a type conversion operator, like `operator int () { ... }'.
370 When listing a class's methods, we don't print the return type of
373 is_type_conversion_operator (struct type *type, int i, int j)
375 /* I think the whole idea of recognizing type conversion operators
376 by their name is pretty terrible. But I don't think our present
377 data structure gives us any other way to tell. If you know of
378 some other way, feel free to rewrite this function. */
379 char *name = TYPE_FN_FIELDLIST_NAME (type, i);
381 if (strncmp (name, "operator", 8) != 0)
385 if (! strchr (" \t\f\n\r", *name))
388 while (strchr (" \t\f\n\r", *name))
391 if (strncmp (name, "new", 3) == 0)
393 else if (strncmp (name, "delete", 6) == 0)
398 /* Is that really the end of the name? */
399 if (('a' <= *name && *name <= 'z')
400 || ('A' <= *name && *name <= 'Z')
401 || ('0' <= *name && *name <= '9')
403 /* No, so the identifier following "operator" must be a type name,
404 and this is a type conversion operator. */
407 /* That was indeed the end of the name, so it was `operator new' or
408 `operator delete', neither of which are type conversion operators. */
413 /* Given a C++ qualified identifier QID, strip off the qualifiers,
414 yielding the unqualified name. The return value is a pointer into
417 It's a pity we don't have this information in some more structured
418 form. Even the author of this function feels that writing little
419 parsers like this everywhere is stupid. */
421 remove_qualifiers (char *qid)
423 int quoted = 0; /* zero if we're not in quotes;
424 '"' if we're in a double-quoted string;
425 '\'' if we're in a single-quoted string. */
426 int depth = 0; /* number of unclosed parens we've seen */
427 char *parenstack = (char *) alloca (strlen (qid));
429 char *last = 0; /* The character after the rightmost
430 `::' token we've seen so far. */
432 for (scan = qid; *scan; scan++)
438 else if (*scan == '\\' && *(scan + 1))
441 else if (scan[0] == ':' && scan[1] == ':')
443 /* If we're inside parenthesis (i.e., an argument list) or
444 angle brackets (i.e., a list of template arguments), then
445 we don't record the position of this :: token, since it's
446 not relevant to the top-level structure we're trying
454 else if (*scan == '"' || *scan == '\'')
456 else if (*scan == '(')
457 parenstack[depth++] = ')';
458 else if (*scan == '[')
459 parenstack[depth++] = ']';
460 /* We're going to treat <> as a pair of matching characters,
461 since we're more likely to see those in template id's than
462 real less-than characters. What a crock. */
463 else if (*scan == '<')
464 parenstack[depth++] = '>';
465 else if (*scan == ')' || *scan == ']' || *scan == '>')
467 if (depth > 0 && parenstack[depth - 1] == *scan)
471 /* We're going to do a little error recovery here. If we
472 don't find a match for *scan on the paren stack, but
473 there is something lower on the stack that does match, we
474 pop the stack to that point. */
477 for (i = depth - 1; i >= 0; i--)
478 if (parenstack[i] == *scan)
490 /* We didn't find any :: tokens at the top level, so declare the
491 whole thing an unqualified identifier. */
496 /* Print any array sizes, function arguments or close parentheses
497 needed after the variable name (to describe its type).
498 Args work like c_type_print_varspec_prefix. */
501 c_type_print_varspec_suffix (struct type *type, struct ui_file *stream,
502 int show, int passed_a_ptr, int demangled_args)
507 if (TYPE_NAME (type) && show <= 0)
512 switch (TYPE_CODE (type))
514 case TYPE_CODE_ARRAY:
516 fprintf_filtered (stream, ")");
518 fprintf_filtered (stream, "[");
519 if (TYPE_LENGTH (type) >= 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
520 && TYPE_ARRAY_UPPER_BOUND_TYPE (type) != BOUND_CANNOT_BE_DETERMINED)
521 fprintf_filtered (stream, "%d",
523 / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
524 fprintf_filtered (stream, "]");
526 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
529 case TYPE_CODE_MEMBER:
531 fprintf_filtered (stream, ")");
532 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
535 case TYPE_CODE_METHOD:
537 fprintf_filtered (stream, ")");
538 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
541 c_type_print_args (type, stream);
547 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 1, 0);
552 fprintf_filtered (stream, ")");
555 int i, len = TYPE_NFIELDS (type);
556 fprintf_filtered (stream, "(");
557 if ((len == 0) && (current_language->la_language == language_cplus))
559 fprintf_filtered (stream, "void");
562 for (i = 0; i < len; i++)
566 fputs_filtered (", ", stream);
569 c_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
571 fprintf_filtered (stream, ")");
573 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
577 case TYPE_CODE_UNDEF:
578 case TYPE_CODE_STRUCT:
579 case TYPE_CODE_UNION:
584 case TYPE_CODE_ERROR:
588 case TYPE_CODE_RANGE:
589 case TYPE_CODE_STRING:
590 case TYPE_CODE_BITSTRING:
591 case TYPE_CODE_COMPLEX:
592 case TYPE_CODE_TYPEDEF:
593 case TYPE_CODE_TEMPLATE:
594 /* These types do not need a suffix. They are listed so that
595 gcc -Wall will report types that may not have been considered. */
598 error ("type not handled in c_type_print_varspec_suffix()");
603 /* Print the name of the type (or the ultimate pointer target,
604 function value or array element), or the description of a
607 SHOW positive means print details about the type (e.g. enum values),
608 and print structure elements passing SHOW - 1 for show.
609 SHOW negative means just print the type name or struct tag if there is one.
610 If there is no name, print something sensible but concise like
612 SHOW zero means just print the type name or struct tag if there is one.
613 If there is no name, print something sensible but not as concise like
614 "struct {int x; int y;}".
616 LEVEL is the number of spaces to indent by.
617 We increase it for some recursive calls. */
620 c_type_print_base (struct type *type, struct ui_file *stream, int show,
625 register int lastval;
627 char *demangled_name;
628 char *demangled_no_static;
631 s_none, s_public, s_private, s_protected
634 int need_access_label = 0;
642 fputs_filtered ("<type unknown>", stream);
646 /* When SHOW is zero or less, and there is a valid type name, then always
647 just print the type name directly from the type. */
648 /* If we have "typedef struct foo {. . .} bar;" do we want to print it
649 as "struct foo" or as "bar"? Pick the latter, because C++ folk tend
650 to expect things like "class5 *foo" rather than "struct class5 *foo". */
653 && TYPE_NAME (type) != NULL)
655 c_type_print_cv_qualifier (type, stream, 0, 1);
656 fputs_filtered (TYPE_NAME (type), stream);
660 CHECK_TYPEDEF (type);
662 switch (TYPE_CODE (type))
664 case TYPE_CODE_TYPEDEF:
665 case TYPE_CODE_ARRAY:
667 case TYPE_CODE_MEMBER:
670 case TYPE_CODE_METHOD:
671 c_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
674 case TYPE_CODE_STRUCT:
675 c_type_print_cv_qualifier (type, stream, 0, 1);
676 /* Note TYPE_CODE_STRUCT and TYPE_CODE_CLASS have the same value,
677 * so we use another means for distinguishing them.
679 if (HAVE_CPLUS_STRUCT (type))
681 switch (TYPE_DECLARED_TYPE (type))
683 case DECLARED_TYPE_CLASS:
684 fprintf_filtered (stream, "class ");
686 case DECLARED_TYPE_UNION:
687 fprintf_filtered (stream, "union ");
689 case DECLARED_TYPE_STRUCT:
690 fprintf_filtered (stream, "struct ");
693 /* If there is a CPLUS_STRUCT, assume class if not
694 * otherwise specified in the declared_type field.
696 fprintf_filtered (stream, "class ");
702 /* If not CPLUS_STRUCT, then assume it's a C struct */
703 fprintf_filtered (stream, "struct ");
707 case TYPE_CODE_UNION:
708 c_type_print_cv_qualifier (type, stream, 0, 1);
709 fprintf_filtered (stream, "union ");
713 /* Print the tag if it exists.
714 * The HP aCC compiler emits
715 * a spurious "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
716 * tag for unnamed struct/union/enum's, which we don't
719 if (TYPE_TAG_NAME (type) != NULL &&
720 strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
722 fputs_filtered (TYPE_TAG_NAME (type), stream);
724 fputs_filtered (" ", stream);
729 /* If we just printed a tag name, no need to print anything else. */
730 if (TYPE_TAG_NAME (type) == NULL)
731 fprintf_filtered (stream, "{...}");
733 else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
735 cp_type_print_derivation_info (stream, type);
737 fprintf_filtered (stream, "{\n");
738 if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
740 if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
741 fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
743 fprintfi_filtered (level + 4, stream, "<no data fields>\n");
746 /* Start off with no specific section type, so we can print
747 one for the first field we find, and use that section type
748 thereafter until we find another type. */
750 section_type = s_none;
752 /* For a class, if all members are private, there's no need
753 for a "private:" label; similarly, for a struct or union
754 masquerading as a class, if all members are public, there's
755 no need for a "public:" label. */
757 if ((TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_CLASS) ||
758 (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_TEMPLATE))
761 len = TYPE_NFIELDS (type);
762 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
763 if (!TYPE_FIELD_PRIVATE (type, i))
765 need_access_label = 1;
769 if (!need_access_label)
771 len2 = TYPE_NFN_FIELDS (type);
772 for (j = 0; j < len2; j++)
774 len = TYPE_FN_FIELDLIST_LENGTH (type, j);
775 for (i = 0; i < len; i++)
776 if (!TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i))
778 need_access_label = 1;
781 if (need_access_label)
786 else if ((TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_STRUCT) ||
787 (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_UNION))
790 len = TYPE_NFIELDS (type);
791 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
792 if (TYPE_FIELD_PRIVATE (type, i) || TYPE_FIELD_PROTECTED (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++)
804 len = TYPE_FN_FIELDLIST_LENGTH (type, j);
805 for (i = 0; i < len; i++)
806 if (TYPE_FN_FIELD_PRIVATE (TYPE_FN_FIELDLIST1 (type, j), i) ||
807 TYPE_FN_FIELD_PROTECTED (TYPE_FN_FIELDLIST1 (type, j), i))
809 need_access_label = 1;
812 if (need_access_label)
818 /* If there is a base class for this type,
819 do not print the field that it occupies. */
821 len = TYPE_NFIELDS (type);
822 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
825 /* Don't print out virtual function table. */
826 /* HP ANSI C++ case */
827 if (TYPE_HAS_VTABLE (type) && (STREQN (TYPE_FIELD_NAME (type, i), "__vfp", 5)))
829 /* Other compilers */
830 if (STREQN (TYPE_FIELD_NAME (type, i), "_vptr", 5)
831 && is_cplus_marker ((TYPE_FIELD_NAME (type, i))[5]))
834 /* If this is a C++ class we can print the various C++ section
837 if (HAVE_CPLUS_STRUCT (type) && need_access_label)
839 if (TYPE_FIELD_PROTECTED (type, i))
841 if (section_type != s_protected)
843 section_type = s_protected;
844 fprintfi_filtered (level + 2, stream,
848 else if (TYPE_FIELD_PRIVATE (type, i))
850 if (section_type != s_private)
852 section_type = s_private;
853 fprintfi_filtered (level + 2, stream, "private:\n");
858 if (section_type != s_public)
860 section_type = s_public;
861 fprintfi_filtered (level + 2, stream, "public:\n");
866 print_spaces_filtered (level + 4, stream);
867 if (TYPE_FIELD_STATIC (type, i))
869 fprintf_filtered (stream, "static ");
871 c_print_type (TYPE_FIELD_TYPE (type, i),
872 TYPE_FIELD_NAME (type, i),
873 stream, show - 1, level + 4);
874 if (!TYPE_FIELD_STATIC (type, i)
875 && TYPE_FIELD_PACKED (type, i))
877 /* It is a bitfield. This code does not attempt
878 to look at the bitpos and reconstruct filler,
879 unnamed fields. This would lead to misleading
880 results if the compiler does not put out fields
881 for such things (I don't know what it does). */
882 fprintf_filtered (stream, " : %d",
883 TYPE_FIELD_BITSIZE (type, i));
885 fprintf_filtered (stream, ";\n");
888 /* If there are both fields and methods, put a space between. */
889 len = TYPE_NFN_FIELDS (type);
890 if (len && section_type != s_none)
891 fprintf_filtered (stream, "\n");
893 /* C++: print out the methods */
894 for (i = 0; i < len; i++)
896 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
897 int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
898 char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
899 char *name = type_name_no_tag (type);
900 int is_constructor = name && STREQ (method_name, name);
901 for (j = 0; j < len2; j++)
903 char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
904 int is_full_physname_constructor =
905 ((physname[0] == '_' && physname[1] == '_'
906 && strchr ("0123456789Qt", physname[2]))
907 || STREQN (physname, "__ct__", 6)
908 || DESTRUCTOR_PREFIX_P (physname)
909 || STREQN (physname, "__dt__", 6));
912 if (TYPE_FN_FIELD_PROTECTED (f, j))
914 if (section_type != s_protected)
916 section_type = s_protected;
917 fprintfi_filtered (level + 2, stream,
921 else if (TYPE_FN_FIELD_PRIVATE (f, j))
923 if (section_type != s_private)
925 section_type = s_private;
926 fprintfi_filtered (level + 2, stream, "private:\n");
931 if (section_type != s_public)
933 section_type = s_public;
934 fprintfi_filtered (level + 2, stream, "public:\n");
938 print_spaces_filtered (level + 4, stream);
939 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
940 fprintf_filtered (stream, "virtual ");
941 else if (TYPE_FN_FIELD_STATIC_P (f, j))
942 fprintf_filtered (stream, "static ");
943 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
945 /* Keep GDB from crashing here. */
946 fprintf_filtered (stream, "<undefined type> %s;\n",
947 TYPE_FN_FIELD_PHYSNAME (f, j));
950 else if (!is_constructor && /* constructors don't have declared types */
951 !is_full_physname_constructor && /* " " */
952 !is_type_conversion_operator (type, i, j))
954 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
956 fputs_filtered (" ", stream);
958 if (TYPE_FN_FIELD_STUB (f, j))
959 /* Build something we can demangle. */
960 mangled_name = gdb_mangle_name (type, i, j);
962 mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
965 cplus_demangle (mangled_name,
966 DMGL_ANSI | DMGL_PARAMS);
967 if (demangled_name == NULL)
969 /* in some cases (for instance with the HP demangling),
970 if a function has more than 10 arguments,
971 the demangling will fail.
972 Let's try to reconstruct the function signature from
973 the symbol information */
974 if (!TYPE_FN_FIELD_STUB (f, j))
975 cp_type_print_method_args (TYPE_FN_FIELD_ARGS (f, j), "",
977 TYPE_FN_FIELD_STATIC_P (f, j),
980 fprintf_filtered (stream, "<badly mangled name '%s'>",
986 char *demangled_no_class
987 = remove_qualifiers (demangled_name);
989 /* get rid of the `static' appended by the demangler */
990 p = strstr (demangled_no_class, " static");
993 int length = p - demangled_no_class;
994 demangled_no_static = (char *) xmalloc (length + 1);
995 strncpy (demangled_no_static, demangled_no_class, length);
996 *(demangled_no_static + length) = '\0';
997 fputs_filtered (demangled_no_static, stream);
998 xfree (demangled_no_static);
1001 fputs_filtered (demangled_no_class, stream);
1002 xfree (demangled_name);
1005 if (TYPE_FN_FIELD_STUB (f, j))
1006 xfree (mangled_name);
1008 fprintf_filtered (stream, ";\n");
1012 fprintfi_filtered (level, stream, "}");
1014 if (TYPE_LOCALTYPE_PTR (type) && show >= 0)
1015 fprintfi_filtered (level, stream, " (Local at %s:%d)\n",
1016 TYPE_LOCALTYPE_FILE (type),
1017 TYPE_LOCALTYPE_LINE (type));
1019 if (TYPE_CODE (type) == TYPE_CODE_TEMPLATE)
1023 case TYPE_CODE_ENUM:
1024 c_type_print_cv_qualifier (type, stream, 0, 1);
1025 /* HP C supports sized enums */
1026 if (hp_som_som_object_present)
1027 switch (TYPE_LENGTH (type))
1030 fputs_filtered ("char ", stream);
1033 fputs_filtered ("short ", stream);
1038 fprintf_filtered (stream, "enum ");
1039 /* Print the tag name if it exists.
1040 The aCC compiler emits a spurious
1041 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1042 tag for unnamed struct/union/enum's, which we don't
1044 if (TYPE_TAG_NAME (type) != NULL &&
1045 strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
1047 fputs_filtered (TYPE_TAG_NAME (type), stream);
1049 fputs_filtered (" ", stream);
1055 /* If we just printed a tag name, no need to print anything else. */
1056 if (TYPE_TAG_NAME (type) == NULL)
1057 fprintf_filtered (stream, "{...}");
1059 else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1061 fprintf_filtered (stream, "{");
1062 len = TYPE_NFIELDS (type);
1064 for (i = 0; i < len; i++)
1068 fprintf_filtered (stream, ", ");
1070 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1071 if (lastval != TYPE_FIELD_BITPOS (type, i))
1073 fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
1074 lastval = TYPE_FIELD_BITPOS (type, i);
1078 fprintf_filtered (stream, "}");
1082 case TYPE_CODE_VOID:
1083 fprintf_filtered (stream, "void");
1086 case TYPE_CODE_UNDEF:
1087 fprintf_filtered (stream, "struct <unknown>");
1090 case TYPE_CODE_ERROR:
1091 fprintf_filtered (stream, "<unknown type>");
1094 case TYPE_CODE_RANGE:
1095 /* This should not occur */
1096 fprintf_filtered (stream, "<range type>");
1099 case TYPE_CODE_TEMPLATE:
1100 /* Called on "ptype t" where "t" is a template.
1101 Prints the template header (with args), e.g.:
1102 template <class T1, class T2> class "
1103 and then merges with the struct/union/class code to
1104 print the rest of the definition. */
1105 c_type_print_cv_qualifier (type, stream, 0, 1);
1106 fprintf_filtered (stream, "template <");
1107 for (i = 0; i < TYPE_NTEMPLATE_ARGS (type); i++)
1109 struct template_arg templ_arg;
1110 templ_arg = TYPE_TEMPLATE_ARG (type, i);
1111 fprintf_filtered (stream, "class %s", templ_arg.name);
1112 if (i < TYPE_NTEMPLATE_ARGS (type) - 1)
1113 fprintf_filtered (stream, ", ");
1115 fprintf_filtered (stream, "> class ");
1116 /* Yuck, factor this out to a subroutine so we can call
1117 it and return to the point marked with the "goback:" label... - RT */
1120 if (TYPE_NINSTANTIATIONS (type) > 0)
1122 fprintf_filtered (stream, "\ntemplate instantiations:\n");
1123 for (i = 0; i < TYPE_NINSTANTIATIONS (type); i++)
1125 fprintf_filtered (stream, " ");
1126 c_type_print_base (TYPE_INSTANTIATION (type, i), stream, 0, level);
1127 if (i < TYPE_NINSTANTIATIONS (type) - 1)
1128 fprintf_filtered (stream, "\n");
1134 /* Handle types not explicitly handled by the other cases,
1135 such as fundamental types. For these, just print whatever
1136 the type name is, as recorded in the type itself. If there
1137 is no type name, then complain. */
1138 if (TYPE_NAME (type) != NULL)
1140 c_type_print_cv_qualifier (type, stream, 0, 1);
1141 fputs_filtered (TYPE_NAME (type), stream);
1145 /* At least for dump_symtab, it is important that this not be
1147 fprintf_filtered (stream, "<invalid type code %d>",