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