Use ptid_t.tid to store thread ids instead of ptid_t.pid.
[deliverable/binutils-gdb.git] / gdb / c-typeprint.c
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
4 Free Software Foundation, Inc.
5
6 This file is part of GDB.
7
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.
12
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.
17
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/>. */
20
21 #include "defs.h"
22 #include "gdb_obstack.h"
23 #include "bfd.h" /* Binary File Description */
24 #include "symtab.h"
25 #include "gdbtypes.h"
26 #include "expression.h"
27 #include "value.h"
28 #include "gdbcore.h"
29 #include "target.h"
30 #include "language.h"
31 #include "demangle.h"
32 #include "c-lang.h"
33 #include "typeprint.h"
34 #include "cp-abi.h"
35
36 #include "gdb_string.h"
37 #include <errno.h>
38
39 static void cp_type_print_method_args (struct type *mtype, char *prefix,
40 char *varstring, int staticp,
41 struct ui_file *stream);
42
43 static void c_type_print_args (struct type *, struct ui_file *);
44
45 static void cp_type_print_derivation_info (struct ui_file *, struct type *);
46
47 static void c_type_print_varspec_prefix (struct type *, struct ui_file *, int,
48 int, int);
49
50 /* Print "const", "volatile", or address space modifiers. */
51 static void c_type_print_modifier (struct type *, struct ui_file *,
52 int, int);
53 \f
54
55
56
57 /* LEVEL is the depth to indent lines by. */
58
59 void
60 c_print_type (struct type *type, char *varstring, struct ui_file *stream,
61 int show, int level)
62 {
63 enum type_code code;
64 int demangled_args;
65 int need_post_space;
66
67 if (show > 0)
68 CHECK_TYPEDEF (type);
69
70 c_type_print_base (type, stream, show, level);
71 code = TYPE_CODE (type);
72 if ((varstring != NULL && *varstring != '\0')
73 ||
74 /* Need a space if going to print stars or brackets;
75 but not if we will print just a type name. */
76 ((show > 0 || TYPE_NAME (type) == 0)
77 &&
78 (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
79 || code == TYPE_CODE_METHOD
80 || code == TYPE_CODE_ARRAY
81 || code == TYPE_CODE_MEMBERPTR
82 || code == TYPE_CODE_METHODPTR
83 || code == TYPE_CODE_REF)))
84 fputs_filtered (" ", stream);
85 need_post_space = (varstring != NULL && strcmp (varstring, "") != 0);
86 c_type_print_varspec_prefix (type, stream, show, 0, need_post_space);
87
88 if (varstring != NULL)
89 {
90 fputs_filtered (varstring, stream);
91
92 /* For demangled function names, we have the arglist as part of the name,
93 so don't print an additional pair of ()'s */
94
95 demangled_args = strchr (varstring, '(') != NULL;
96 c_type_print_varspec_suffix (type, stream, show, 0, demangled_args);
97 }
98 }
99
100 /* If TYPE is a derived type, then print out derivation information.
101 Print only the actual base classes of this type, not the base classes
102 of the base classes. I.E. for the derivation hierarchy:
103
104 class A { int a; };
105 class B : public A {int b; };
106 class C : public B {int c; };
107
108 Print the type of class C as:
109
110 class C : public B {
111 int c;
112 }
113
114 Not as the following (like gdb used to), which is not legal C++ syntax for
115 derived types and may be confused with the multiple inheritance form:
116
117 class C : public B : public A {
118 int c;
119 }
120
121 In general, gdb should try to print the types as closely as possible to
122 the form that they appear in the source code.
123 Note that in case of protected derivation gcc will not say 'protected'
124 but 'private'. The HP's aCC compiler emits specific information for
125 derivation via protected inheritance, so gdb can print it out */
126
127 static void
128 cp_type_print_derivation_info (struct ui_file *stream, struct type *type)
129 {
130 char *name;
131 int i;
132
133 for (i = 0; i < TYPE_N_BASECLASSES (type); i++)
134 {
135 fputs_filtered (i == 0 ? ": " : ", ", stream);
136 fprintf_filtered (stream, "%s%s ",
137 BASETYPE_VIA_PUBLIC (type, i) ? "public"
138 : (TYPE_FIELD_PROTECTED (type, i) ? "protected" : "private"),
139 BASETYPE_VIA_VIRTUAL (type, i) ? " virtual" : "");
140 name = type_name_no_tag (TYPE_BASECLASS (type, i));
141 fprintf_filtered (stream, "%s", name ? name : "(null)");
142 }
143 if (i > 0)
144 {
145 fputs_filtered (" ", stream);
146 }
147 }
148
149 /* Print the C++ method arguments ARGS to the file STREAM. */
150
151 static void
152 cp_type_print_method_args (struct type *mtype, char *prefix, char *varstring,
153 int staticp, struct ui_file *stream)
154 {
155 struct field *args = TYPE_FIELDS (mtype);
156 int nargs = TYPE_NFIELDS (mtype);
157 int varargs = TYPE_VARARGS (mtype);
158 int i;
159
160 fprintf_symbol_filtered (stream, prefix, language_cplus, DMGL_ANSI);
161 fprintf_symbol_filtered (stream, varstring, language_cplus, DMGL_ANSI);
162 fputs_filtered ("(", stream);
163
164 /* Skip the class variable. */
165 i = staticp ? 0 : 1;
166 if (nargs > i)
167 {
168 while (i < nargs)
169 {
170 type_print (args[i++].type, "", stream, 0);
171
172 if (i == nargs && varargs)
173 fprintf_filtered (stream, ", ...");
174 else if (i < nargs)
175 fprintf_filtered (stream, ", ");
176 }
177 }
178 else if (varargs)
179 fprintf_filtered (stream, "...");
180 else if (current_language->la_language == language_cplus)
181 fprintf_filtered (stream, "void");
182
183 fprintf_filtered (stream, ")");
184 }
185
186
187 /* Print any asterisks or open-parentheses needed before the
188 variable name (to describe its type).
189
190 On outermost call, pass 0 for PASSED_A_PTR.
191 On outermost call, SHOW > 0 means should ignore
192 any typename for TYPE and show its details.
193 SHOW is always zero on recursive calls.
194
195 NEED_POST_SPACE is non-zero when a space will be be needed
196 between a trailing qualifier and a field, variable, or function
197 name. */
198
199 void
200 c_type_print_varspec_prefix (struct type *type, struct ui_file *stream,
201 int show, int passed_a_ptr, int need_post_space)
202 {
203 char *name;
204 if (type == 0)
205 return;
206
207 if (TYPE_NAME (type) && show <= 0)
208 return;
209
210 QUIT;
211
212 switch (TYPE_CODE (type))
213 {
214 case TYPE_CODE_PTR:
215 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 1, 1);
216 fprintf_filtered (stream, "*");
217 c_type_print_modifier (type, stream, 1, need_post_space);
218 break;
219
220 case TYPE_CODE_MEMBERPTR:
221 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
222 name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
223 if (name)
224 fputs_filtered (name, stream);
225 else
226 c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
227 fprintf_filtered (stream, "::*");
228 break;
229
230 case TYPE_CODE_METHODPTR:
231 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
232 fprintf_filtered (stream, "(");
233 name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
234 if (name)
235 fputs_filtered (name, stream);
236 else
237 c_type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
238 fprintf_filtered (stream, "::*");
239 break;
240
241 case TYPE_CODE_REF:
242 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 1, 0);
243 fprintf_filtered (stream, "&");
244 c_type_print_modifier (type, stream, 1, need_post_space);
245 break;
246
247 case TYPE_CODE_METHOD:
248 case TYPE_CODE_FUNC:
249 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
250 if (passed_a_ptr)
251 fprintf_filtered (stream, "(");
252 break;
253
254 case TYPE_CODE_ARRAY:
255 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
256 if (passed_a_ptr)
257 fprintf_filtered (stream, "(");
258 break;
259
260 case TYPE_CODE_TYPEDEF:
261 c_type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, show, 0, 0);
262 break;
263
264 case TYPE_CODE_UNDEF:
265 case TYPE_CODE_STRUCT:
266 case TYPE_CODE_UNION:
267 case TYPE_CODE_ENUM:
268 case TYPE_CODE_INT:
269 case TYPE_CODE_FLT:
270 case TYPE_CODE_VOID:
271 case TYPE_CODE_ERROR:
272 case TYPE_CODE_CHAR:
273 case TYPE_CODE_BOOL:
274 case TYPE_CODE_SET:
275 case TYPE_CODE_RANGE:
276 case TYPE_CODE_STRING:
277 case TYPE_CODE_BITSTRING:
278 case TYPE_CODE_COMPLEX:
279 case TYPE_CODE_TEMPLATE:
280 case TYPE_CODE_NAMESPACE:
281 case TYPE_CODE_DECFLOAT:
282 /* These types need no prefix. They are listed here so that
283 gcc -Wall will reveal any types that haven't been handled. */
284 break;
285 default:
286 error (_("type not handled in c_type_print_varspec_prefix()"));
287 break;
288 }
289 }
290
291 /* Print out "const" and "volatile" attributes.
292 TYPE is a pointer to the type being printed out.
293 STREAM is the output destination.
294 NEED_SPACE = 1 indicates an initial white space is needed */
295
296 static void
297 c_type_print_modifier (struct type *type, struct ui_file *stream,
298 int need_pre_space, int need_post_space)
299 {
300 int did_print_modifier = 0;
301 const char *address_space_id;
302
303 /* We don't print `const' qualifiers for references --- since all
304 operators affect the thing referenced, not the reference itself,
305 every reference is `const'. */
306 if (TYPE_CONST (type)
307 && TYPE_CODE (type) != TYPE_CODE_REF)
308 {
309 if (need_pre_space)
310 fprintf_filtered (stream, " ");
311 fprintf_filtered (stream, "const");
312 did_print_modifier = 1;
313 }
314
315 if (TYPE_VOLATILE (type))
316 {
317 if (did_print_modifier || need_pre_space)
318 fprintf_filtered (stream, " ");
319 fprintf_filtered (stream, "volatile");
320 did_print_modifier = 1;
321 }
322
323 address_space_id = address_space_int_to_name (TYPE_INSTANCE_FLAGS (type));
324 if (address_space_id)
325 {
326 if (did_print_modifier || need_pre_space)
327 fprintf_filtered (stream, " ");
328 fprintf_filtered (stream, "@%s", address_space_id);
329 did_print_modifier = 1;
330 }
331
332 if (did_print_modifier && need_post_space)
333 fprintf_filtered (stream, " ");
334 }
335
336
337 /* Print out the arguments of TYPE, which should have TYPE_CODE_METHOD
338 or TYPE_CODE_FUNC, to STREAM. Artificial arguments, such as "this"
339 in non-static methods, are displayed. */
340
341 static void
342 c_type_print_args (struct type *type, struct ui_file *stream)
343 {
344 int i, len;
345 struct field *args;
346 int printed_any = 0;
347
348 fprintf_filtered (stream, "(");
349 args = TYPE_FIELDS (type);
350 len = TYPE_NFIELDS (type);
351
352 for (i = 0; i < TYPE_NFIELDS (type); i++)
353 {
354 if (printed_any)
355 {
356 fprintf_filtered (stream, ", ");
357 wrap_here (" ");
358 }
359
360 c_print_type (TYPE_FIELD_TYPE (type, i), "", stream, -1, 0);
361 printed_any = 1;
362 }
363
364 if (printed_any && TYPE_VARARGS (type))
365 {
366 /* Print out a trailing ellipsis for varargs functions. Ignore
367 TYPE_VARARGS if the function has no named arguments; that
368 represents unprototyped (K&R style) C functions. */
369 if (printed_any && TYPE_VARARGS (type))
370 {
371 fprintf_filtered (stream, ", ");
372 wrap_here (" ");
373 fprintf_filtered (stream, "...");
374 }
375 }
376 else if (!printed_any
377 && (TYPE_PROTOTYPED (type)
378 || current_language->la_language == language_cplus))
379 fprintf_filtered (stream, "void");
380
381 fprintf_filtered (stream, ")");
382 }
383
384
385 /* Return true iff the j'th overloading of the i'th method of TYPE
386 is a type conversion operator, like `operator int () { ... }'.
387 When listing a class's methods, we don't print the return type of
388 such operators. */
389 static int
390 is_type_conversion_operator (struct type *type, int i, int j)
391 {
392 /* I think the whole idea of recognizing type conversion operators
393 by their name is pretty terrible. But I don't think our present
394 data structure gives us any other way to tell. If you know of
395 some other way, feel free to rewrite this function. */
396 char *name = TYPE_FN_FIELDLIST_NAME (type, i);
397
398 if (strncmp (name, "operator", 8) != 0)
399 return 0;
400
401 name += 8;
402 if (! strchr (" \t\f\n\r", *name))
403 return 0;
404
405 while (strchr (" \t\f\n\r", *name))
406 name++;
407
408 if (!('a' <= *name && *name <= 'z')
409 && !('A' <= *name && *name <= 'Z')
410 && *name != '_')
411 /* If this doesn't look like the start of an identifier, then it
412 isn't a type conversion operator. */
413 return 0;
414 else if (strncmp (name, "new", 3) == 0)
415 name += 3;
416 else if (strncmp (name, "delete", 6) == 0)
417 name += 6;
418 else
419 /* If it doesn't look like new or delete, it's a type conversion
420 operator. */
421 return 1;
422
423 /* Is that really the end of the name? */
424 if (('a' <= *name && *name <= 'z')
425 || ('A' <= *name && *name <= 'Z')
426 || ('0' <= *name && *name <= '9')
427 || *name == '_')
428 /* No, so the identifier following "operator" must be a type name,
429 and this is a type conversion operator. */
430 return 1;
431
432 /* That was indeed the end of the name, so it was `operator new' or
433 `operator delete', neither of which are type conversion operators. */
434 return 0;
435 }
436
437
438 /* Given a C++ qualified identifier QID, strip off the qualifiers,
439 yielding the unqualified name. The return value is a pointer into
440 the original string.
441
442 It's a pity we don't have this information in some more structured
443 form. Even the author of this function feels that writing little
444 parsers like this everywhere is stupid. */
445 static char *
446 remove_qualifiers (char *qid)
447 {
448 int quoted = 0; /* zero if we're not in quotes;
449 '"' if we're in a double-quoted string;
450 '\'' if we're in a single-quoted string. */
451 int depth = 0; /* number of unclosed parens we've seen */
452 char *parenstack = (char *) alloca (strlen (qid));
453 char *scan;
454 char *last = 0; /* The character after the rightmost
455 `::' token we've seen so far. */
456
457 for (scan = qid; *scan; scan++)
458 {
459 if (quoted)
460 {
461 if (*scan == quoted)
462 quoted = 0;
463 else if (*scan == '\\' && *(scan + 1))
464 scan++;
465 }
466 else if (scan[0] == ':' && scan[1] == ':')
467 {
468 /* If we're inside parenthesis (i.e., an argument list) or
469 angle brackets (i.e., a list of template arguments), then
470 we don't record the position of this :: token, since it's
471 not relevant to the top-level structure we're trying
472 to operate on. */
473 if (depth == 0)
474 {
475 last = scan + 2;
476 scan++;
477 }
478 }
479 else if (*scan == '"' || *scan == '\'')
480 quoted = *scan;
481 else if (*scan == '(')
482 parenstack[depth++] = ')';
483 else if (*scan == '[')
484 parenstack[depth++] = ']';
485 /* We're going to treat <> as a pair of matching characters,
486 since we're more likely to see those in template id's than
487 real less-than characters. What a crock. */
488 else if (*scan == '<')
489 parenstack[depth++] = '>';
490 else if (*scan == ')' || *scan == ']' || *scan == '>')
491 {
492 if (depth > 0 && parenstack[depth - 1] == *scan)
493 depth--;
494 else
495 {
496 /* We're going to do a little error recovery here. If we
497 don't find a match for *scan on the paren stack, but
498 there is something lower on the stack that does match, we
499 pop the stack to that point. */
500 int i;
501
502 for (i = depth - 1; i >= 0; i--)
503 if (parenstack[i] == *scan)
504 {
505 depth = i;
506 break;
507 }
508 }
509 }
510 }
511
512 if (last)
513 return last;
514 else
515 /* We didn't find any :: tokens at the top level, so declare the
516 whole thing an unqualified identifier. */
517 return qid;
518 }
519
520
521 /* Print any array sizes, function arguments or close parentheses
522 needed after the variable name (to describe its type).
523 Args work like c_type_print_varspec_prefix. */
524
525 void
526 c_type_print_varspec_suffix (struct type *type, struct ui_file *stream,
527 int show, int passed_a_ptr, int demangled_args)
528 {
529 if (type == 0)
530 return;
531
532 if (TYPE_NAME (type) && show <= 0)
533 return;
534
535 QUIT;
536
537 switch (TYPE_CODE (type))
538 {
539 case TYPE_CODE_ARRAY:
540 if (passed_a_ptr)
541 fprintf_filtered (stream, ")");
542
543 fprintf_filtered (stream, "[");
544 if (TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0
545 && TYPE_ARRAY_UPPER_BOUND_TYPE (type) != BOUND_CANNOT_BE_DETERMINED)
546 fprintf_filtered (stream, "%d",
547 (TYPE_LENGTH (type)
548 / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
549 fprintf_filtered (stream, "]");
550
551 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
552 0, 0);
553 break;
554
555 case TYPE_CODE_MEMBERPTR:
556 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
557 0, 0);
558 break;
559
560 case TYPE_CODE_METHODPTR:
561 fprintf_filtered (stream, ")");
562 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
563 0, 0);
564 break;
565
566 case TYPE_CODE_PTR:
567 case TYPE_CODE_REF:
568 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
569 1, 0);
570 break;
571
572 case TYPE_CODE_METHOD:
573 case TYPE_CODE_FUNC:
574 if (passed_a_ptr)
575 fprintf_filtered (stream, ")");
576 if (!demangled_args)
577 c_type_print_args (type, stream);
578 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
579 passed_a_ptr, 0);
580 break;
581
582 case TYPE_CODE_TYPEDEF:
583 c_type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, show,
584 passed_a_ptr, 0);
585 break;
586
587 case TYPE_CODE_UNDEF:
588 case TYPE_CODE_STRUCT:
589 case TYPE_CODE_UNION:
590 case TYPE_CODE_ENUM:
591 case TYPE_CODE_INT:
592 case TYPE_CODE_FLT:
593 case TYPE_CODE_VOID:
594 case TYPE_CODE_ERROR:
595 case TYPE_CODE_CHAR:
596 case TYPE_CODE_BOOL:
597 case TYPE_CODE_SET:
598 case TYPE_CODE_RANGE:
599 case TYPE_CODE_STRING:
600 case TYPE_CODE_BITSTRING:
601 case TYPE_CODE_COMPLEX:
602 case TYPE_CODE_TEMPLATE:
603 case TYPE_CODE_NAMESPACE:
604 case TYPE_CODE_DECFLOAT:
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. */
607 break;
608 default:
609 error (_("type not handled in c_type_print_varspec_suffix()"));
610 break;
611 }
612 }
613
614 /* Print the name of the type (or the ultimate pointer target,
615 function value or array element), or the description of a
616 structure or union.
617
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
622 "struct {...}".
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;}".
626
627 LEVEL is the number of spaces to indent by.
628 We increase it for some recursive calls. */
629
630 void
631 c_type_print_base (struct type *type, struct ui_file *stream, int show,
632 int level)
633 {
634 int i;
635 int len, real_len;
636 int lastval;
637 char *mangled_name;
638 char *demangled_name;
639 char *demangled_no_static;
640 enum
641 {
642 s_none, s_public, s_private, s_protected
643 }
644 section_type;
645 int need_access_label = 0;
646 int j, len2;
647
648 QUIT;
649
650 wrap_here (" ");
651 if (type == NULL)
652 {
653 fputs_filtered (_("<type unknown>"), stream);
654 return;
655 }
656
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". */
662
663 if (show <= 0
664 && TYPE_NAME (type) != NULL)
665 {
666 c_type_print_modifier (type, stream, 0, 1);
667 fputs_filtered (TYPE_NAME (type), stream);
668 return;
669 }
670
671 CHECK_TYPEDEF (type);
672
673 switch (TYPE_CODE (type))
674 {
675 case TYPE_CODE_TYPEDEF:
676 case TYPE_CODE_ARRAY:
677 case TYPE_CODE_PTR:
678 case TYPE_CODE_MEMBERPTR:
679 case TYPE_CODE_REF:
680 case TYPE_CODE_FUNC:
681 case TYPE_CODE_METHOD:
682 case TYPE_CODE_METHODPTR:
683 c_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
684 break;
685
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.
690 */
691 if (HAVE_CPLUS_STRUCT (type))
692 {
693 switch (TYPE_DECLARED_TYPE (type))
694 {
695 case DECLARED_TYPE_CLASS:
696 fprintf_filtered (stream, "class ");
697 break;
698 case DECLARED_TYPE_UNION:
699 fprintf_filtered (stream, "union ");
700 break;
701 case DECLARED_TYPE_STRUCT:
702 fprintf_filtered (stream, "struct ");
703 break;
704 default:
705 /* If there is a CPLUS_STRUCT, assume class if not
706 * otherwise specified in the declared_type field.
707 */
708 fprintf_filtered (stream, "class ");
709 break;
710 } /* switch */
711 }
712 else
713 {
714 /* If not CPLUS_STRUCT, then assume it's a C struct */
715 fprintf_filtered (stream, "struct ");
716 }
717 goto struct_union;
718
719 case TYPE_CODE_UNION:
720 c_type_print_modifier (type, stream, 0, 1);
721 fprintf_filtered (stream, "union ");
722
723 struct_union:
724
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
729 * want to print.
730 */
731 if (TYPE_TAG_NAME (type) != NULL &&
732 strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
733 {
734 fputs_filtered (TYPE_TAG_NAME (type), stream);
735 if (show > 0)
736 fputs_filtered (" ", stream);
737 }
738 wrap_here (" ");
739 if (show < 0)
740 {
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, "{...}");
744 }
745 else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
746 {
747 cp_type_print_derivation_info (stream, type);
748
749 fprintf_filtered (stream, "{\n");
750 if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
751 {
752 if (TYPE_STUB (type))
753 fprintfi_filtered (level + 4, stream, _("<incomplete type>\n"));
754 else
755 fprintfi_filtered (level + 4, stream, _("<no data fields>\n"));
756 }
757
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. */
761
762 section_type = s_none;
763
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. */
768
769 if ((TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_CLASS) ||
770 (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_TEMPLATE))
771 {
772 QUIT;
773 len = TYPE_NFIELDS (type);
774 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
775 if (!TYPE_FIELD_PRIVATE (type, i))
776 {
777 need_access_label = 1;
778 break;
779 }
780 QUIT;
781 if (!need_access_label)
782 {
783 len2 = TYPE_NFN_FIELDS (type);
784 for (j = 0; j < len2; j++)
785 {
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))
789 {
790 need_access_label = 1;
791 break;
792 }
793 if (need_access_label)
794 break;
795 }
796 }
797 }
798 else if ((TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_STRUCT) ||
799 (TYPE_DECLARED_TYPE (type) == DECLARED_TYPE_UNION))
800 {
801 QUIT;
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))
805 {
806 need_access_label = 1;
807 break;
808 }
809 QUIT;
810 if (!need_access_label)
811 {
812 len2 = TYPE_NFN_FIELDS (type);
813 for (j = 0; j < len2; j++)
814 {
815 QUIT;
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))
820 {
821 need_access_label = 1;
822 break;
823 }
824 if (need_access_label)
825 break;
826 }
827 }
828 }
829
830 /* If there is a base class for this type,
831 do not print the field that it occupies. */
832
833 len = TYPE_NFIELDS (type);
834 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
835 {
836 QUIT;
837 /* Don't print out virtual function table. */
838 if (strncmp (TYPE_FIELD_NAME (type, i), "_vptr", 5) == 0
839 && is_cplus_marker ((TYPE_FIELD_NAME (type, i))[5]))
840 continue;
841
842 /* If this is a C++ class we can print the various C++ section
843 labels. */
844
845 if (HAVE_CPLUS_STRUCT (type) && need_access_label)
846 {
847 if (TYPE_FIELD_PROTECTED (type, i))
848 {
849 if (section_type != s_protected)
850 {
851 section_type = s_protected;
852 fprintfi_filtered (level + 2, stream,
853 "protected:\n");
854 }
855 }
856 else if (TYPE_FIELD_PRIVATE (type, i))
857 {
858 if (section_type != s_private)
859 {
860 section_type = s_private;
861 fprintfi_filtered (level + 2, stream, "private:\n");
862 }
863 }
864 else
865 {
866 if (section_type != s_public)
867 {
868 section_type = s_public;
869 fprintfi_filtered (level + 2, stream, "public:\n");
870 }
871 }
872 }
873
874 print_spaces_filtered (level + 4, stream);
875 if (TYPE_FIELD_STATIC (type, i))
876 {
877 fprintf_filtered (stream, "static ");
878 }
879 c_print_type (TYPE_FIELD_TYPE (type, i),
880 TYPE_FIELD_NAME (type, i),
881 stream, show - 1, level + 4);
882 if (!TYPE_FIELD_STATIC (type, i)
883 && TYPE_FIELD_PACKED (type, i))
884 {
885 /* It is a bitfield. This code does not attempt
886 to look at the bitpos and reconstruct filler,
887 unnamed fields. This would lead to misleading
888 results if the compiler does not put out fields
889 for such things (I don't know what it does). */
890 fprintf_filtered (stream, " : %d",
891 TYPE_FIELD_BITSIZE (type, i));
892 }
893 fprintf_filtered (stream, ";\n");
894 }
895
896 /* If there are both fields and methods, put a blank line
897 between them. Make sure to count only method that we will
898 display; artificial methods will be hidden. */
899 len = TYPE_NFN_FIELDS (type);
900 real_len = 0;
901 for (i = 0; i < len; i++)
902 {
903 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
904 int len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
905 int j;
906 for (j = 0; j < len2; j++)
907 if (!TYPE_FN_FIELD_ARTIFICIAL (f, j))
908 real_len++;
909 }
910 if (real_len > 0 && section_type != s_none)
911 fprintf_filtered (stream, "\n");
912
913 /* C++: print out the methods */
914 for (i = 0; i < len; i++)
915 {
916 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
917 int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
918 char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
919 char *name = type_name_no_tag (type);
920 int is_constructor = name && strcmp (method_name, name) == 0;
921 for (j = 0; j < len2; j++)
922 {
923 char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
924 int is_full_physname_constructor =
925 is_constructor_name (physname)
926 || is_destructor_name (physname)
927 || method_name[0] == '~';
928
929 /* Do not print out artificial methods. */
930 if (TYPE_FN_FIELD_ARTIFICIAL (f, j))
931 continue;
932
933 QUIT;
934 if (TYPE_FN_FIELD_PROTECTED (f, j))
935 {
936 if (section_type != s_protected)
937 {
938 section_type = s_protected;
939 fprintfi_filtered (level + 2, stream,
940 "protected:\n");
941 }
942 }
943 else if (TYPE_FN_FIELD_PRIVATE (f, j))
944 {
945 if (section_type != s_private)
946 {
947 section_type = s_private;
948 fprintfi_filtered (level + 2, stream, "private:\n");
949 }
950 }
951 else
952 {
953 if (section_type != s_public)
954 {
955 section_type = s_public;
956 fprintfi_filtered (level + 2, stream, "public:\n");
957 }
958 }
959
960 print_spaces_filtered (level + 4, stream);
961 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
962 fprintf_filtered (stream, "virtual ");
963 else if (TYPE_FN_FIELD_STATIC_P (f, j))
964 fprintf_filtered (stream, "static ");
965 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
966 {
967 /* Keep GDB from crashing here. */
968 fprintf_filtered (stream, _("<undefined type> %s;\n"),
969 TYPE_FN_FIELD_PHYSNAME (f, j));
970 break;
971 }
972 else if (!is_constructor && /* constructors don't have declared types */
973 !is_full_physname_constructor && /* " " */
974 !is_type_conversion_operator (type, i, j))
975 {
976 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
977 "", stream, -1);
978 fputs_filtered (" ", stream);
979 }
980 if (TYPE_FN_FIELD_STUB (f, j))
981 /* Build something we can demangle. */
982 mangled_name = gdb_mangle_name (type, i, j);
983 else
984 mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
985
986 demangled_name =
987 cplus_demangle (mangled_name,
988 DMGL_ANSI | DMGL_PARAMS);
989 if (demangled_name == NULL)
990 {
991 /* in some cases (for instance with the HP demangling),
992 if a function has more than 10 arguments,
993 the demangling will fail.
994 Let's try to reconstruct the function signature from
995 the symbol information */
996 if (!TYPE_FN_FIELD_STUB (f, j))
997 {
998 int staticp = TYPE_FN_FIELD_STATIC_P (f, j);
999 struct type *mtype = TYPE_FN_FIELD_TYPE (f, j);
1000 cp_type_print_method_args (mtype,
1001 "",
1002 method_name,
1003 staticp,
1004 stream);
1005 }
1006 else
1007 fprintf_filtered (stream, _("<badly mangled name '%s'>"),
1008 mangled_name);
1009 }
1010 else
1011 {
1012 char *p;
1013 char *demangled_no_class
1014 = remove_qualifiers (demangled_name);
1015
1016 /* get rid of the `static' appended by the demangler */
1017 p = strstr (demangled_no_class, " static");
1018 if (p != NULL)
1019 {
1020 int length = p - demangled_no_class;
1021 demangled_no_static = (char *) xmalloc (length + 1);
1022 strncpy (demangled_no_static, demangled_no_class, length);
1023 *(demangled_no_static + length) = '\0';
1024 fputs_filtered (demangled_no_static, stream);
1025 xfree (demangled_no_static);
1026 }
1027 else
1028 fputs_filtered (demangled_no_class, stream);
1029 xfree (demangled_name);
1030 }
1031
1032 if (TYPE_FN_FIELD_STUB (f, j))
1033 xfree (mangled_name);
1034
1035 fprintf_filtered (stream, ";\n");
1036 }
1037 }
1038
1039 fprintfi_filtered (level, stream, "}");
1040
1041 if (TYPE_LOCALTYPE_PTR (type) && show >= 0)
1042 fprintfi_filtered (level, stream, _(" (Local at %s:%d)\n"),
1043 TYPE_LOCALTYPE_FILE (type),
1044 TYPE_LOCALTYPE_LINE (type));
1045 }
1046 break;
1047
1048 case TYPE_CODE_ENUM:
1049 c_type_print_modifier (type, stream, 0, 1);
1050 fprintf_filtered (stream, "enum ");
1051 /* Print the tag name if it exists.
1052 The aCC compiler emits a spurious
1053 "{unnamed struct}"/"{unnamed union}"/"{unnamed enum}"
1054 tag for unnamed struct/union/enum's, which we don't
1055 want to print. */
1056 if (TYPE_TAG_NAME (type) != NULL &&
1057 strncmp (TYPE_TAG_NAME (type), "{unnamed", 8))
1058 {
1059 fputs_filtered (TYPE_TAG_NAME (type), stream);
1060 if (show > 0)
1061 fputs_filtered (" ", stream);
1062 }
1063
1064 wrap_here (" ");
1065 if (show < 0)
1066 {
1067 /* If we just printed a tag name, no need to print anything else. */
1068 if (TYPE_TAG_NAME (type) == NULL)
1069 fprintf_filtered (stream, "{...}");
1070 }
1071 else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
1072 {
1073 fprintf_filtered (stream, "{");
1074 len = TYPE_NFIELDS (type);
1075 lastval = 0;
1076 for (i = 0; i < len; i++)
1077 {
1078 QUIT;
1079 if (i)
1080 fprintf_filtered (stream, ", ");
1081 wrap_here (" ");
1082 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1083 if (lastval != TYPE_FIELD_BITPOS (type, i))
1084 {
1085 fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
1086 lastval = TYPE_FIELD_BITPOS (type, i);
1087 }
1088 lastval++;
1089 }
1090 fprintf_filtered (stream, "}");
1091 }
1092 break;
1093
1094 case TYPE_CODE_VOID:
1095 fprintf_filtered (stream, "void");
1096 break;
1097
1098 case TYPE_CODE_UNDEF:
1099 fprintf_filtered (stream, _("struct <unknown>"));
1100 break;
1101
1102 case TYPE_CODE_ERROR:
1103 fprintf_filtered (stream, _("<unknown type>"));
1104 break;
1105
1106 case TYPE_CODE_RANGE:
1107 /* This should not occur */
1108 fprintf_filtered (stream, _("<range type>"));
1109 break;
1110
1111 case TYPE_CODE_TEMPLATE:
1112 /* Called on "ptype t" where "t" is a template.
1113 Prints the template header (with args), e.g.:
1114 template <class T1, class T2> class "
1115 and then merges with the struct/union/class code to
1116 print the rest of the definition. */
1117 c_type_print_modifier (type, stream, 0, 1);
1118 fprintf_filtered (stream, "template <");
1119 for (i = 0; i < TYPE_NTEMPLATE_ARGS (type); i++)
1120 {
1121 struct template_arg templ_arg;
1122 templ_arg = TYPE_TEMPLATE_ARG (type, i);
1123 fprintf_filtered (stream, "class %s", templ_arg.name);
1124 if (i < TYPE_NTEMPLATE_ARGS (type) - 1)
1125 fprintf_filtered (stream, ", ");
1126 }
1127 fprintf_filtered (stream, "> class ");
1128 goto struct_union;
1129
1130 case TYPE_CODE_NAMESPACE:
1131 fputs_filtered ("namespace ", stream);
1132 fputs_filtered (TYPE_TAG_NAME (type), stream);
1133 break;
1134
1135 default:
1136 /* Handle types not explicitly handled by the other cases,
1137 such as fundamental types. For these, just print whatever
1138 the type name is, as recorded in the type itself. If there
1139 is no type name, then complain. */
1140 if (TYPE_NAME (type) != NULL)
1141 {
1142 c_type_print_modifier (type, stream, 0, 1);
1143 fputs_filtered (TYPE_NAME (type), stream);
1144 }
1145 else
1146 {
1147 /* At least for dump_symtab, it is important that this not be
1148 an error (). */
1149 fprintf_filtered (stream, _("<invalid type code %d>"),
1150 TYPE_CODE (type));
1151 }
1152 break;
1153 }
1154 }
This page took 0.061915 seconds and 4 git commands to generate.