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