projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* cadillac.c (kernel_dispatch): Make return type void.
[deliverable/binutils-gdb.git] / gdb / valprint.c
1 /* Print values for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1991 Free Software Foundation, Inc.
3
4 This file is part of GDB.
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
19
20 #include "defs.h"
21 #include <string.h>
22 #include "symtab.h"
23 #include "gdbtypes.h"
24 #include "value.h"
25 #include "gdbcore.h"
26 #include "gdbcmd.h"
27 #include "target.h"
28 #include "obstack.h"
29 #include "language.h"
30 #include "demangle.h"
31
32 #include <errno.h>
33
34 /* Prototypes for local functions */
35
36 static void
37 print_string PARAMS ((FILE *, char *, unsigned int, int));
38
39 static void
40 show_print PARAMS ((char *, int));
41
42 static void
43 set_print PARAMS ((char *, int));
44
45 static void
46 set_radix PARAMS ((char *, int, struct cmd_list_element *));
47
48 static void
49 set_output_radix PARAMS ((char *, int, struct cmd_list_element *));
50
51 static void
52 type_print_base PARAMS ((struct type *, FILE *, int, int));
53
54 static void
55 type_print_varspec_suffix PARAMS ((struct type *, FILE *, int, int, int));
56
57 static void
58 type_print_varspec_prefix PARAMS ((struct type *, FILE *, int, int));
59
60 static void
61 type_print_derivation_info PARAMS ((FILE *, struct type *));
62
63 static void
64 type_print_method_args PARAMS ((struct type **, char *, char *, int, FILE *));
65
66 static void
67 cplus_val_print PARAMS ((struct type *, char *, FILE *, int, int,
68 enum val_prettyprint, struct type **));
69
70 static void
71 val_print_fields PARAMS ((struct type *, char *, FILE *, int, int,
72 enum val_prettyprint, struct type **));
73
74 static int
75 is_vtbl_member PARAMS ((struct type *));
76
77 static int
78 is_vtbl_ptr_type PARAMS ((struct type *));
79
80 static void
81 print_hex_chars PARAMS ((FILE *, unsigned char *, unsigned));
82
83 extern int demangle; /* whether to print C++ syms raw or source-form */
84
85 /* Maximum number of chars to print for a string pointer value
86 or vector contents, or UINT_MAX for no limit. */
87
88 static unsigned int print_max;
89
90 /* Default input and output radixes, and output format letter. */
91
92 unsigned input_radix = 10;
93 unsigned output_radix = 10;
94 int output_format = 0;
95
96 /* Print repeat counts if there are more than this
97 many repetitions of an element in an array. */
98 #define REPEAT_COUNT_THRESHOLD 10
99
100 /* Define a mess of print controls. */
101
102 int prettyprint; /* Controls pretty printing of structures */
103 int vtblprint; /* Controls printing of vtbl's */
104 int unionprint; /* Controls printing of nested unions. */
105 int arrayprint; /* Controls pretty printing of arrays. */
106 int addressprint; /* Controls pretty printing of addresses. */
107 int objectprint; /* Controls looking up an object's derived type
108 using what we find in its vtables. */
109
110 struct obstack dont_print_obstack;
111
112 \f
113 /* Print the character string STRING, printing at most LENGTH characters.
114 Printing stops early if the number hits print_max; repeat counts
115 are printed as appropriate. Print ellipses at the end if we
116 had to stop before printing LENGTH characters, or if FORCE_ELLIPSES. */
117
118 static void
119 print_string (stream, string, length, force_ellipses)
120 FILE *stream;
121 char *string;
122 unsigned int length;
123 int force_ellipses;
124 {
125 register unsigned int i;
126 unsigned int things_printed = 0;
127 int in_quotes = 0;
128 int need_comma = 0;
129 extern int inspect_it;
130
131 if (length == 0)
132 {
133 fputs_filtered ("\"\"", stdout);
134 return;
135 }
136
137 for (i = 0; i < length && things_printed < print_max; ++i)
138 {
139 /* Position of the character we are examining
140 to see whether it is repeated. */
141 unsigned int rep1;
142 /* Number of repetitions we have detected so far. */
143 unsigned int reps;
144
145 QUIT;
146
147 if (need_comma)
148 {
149 fputs_filtered (", ", stream);
150 need_comma = 0;
151 }
152
153 rep1 = i + 1;
154 reps = 1;
155 while (rep1 < length && string[rep1] == string[i])
156 {
157 ++rep1;
158 ++reps;
159 }
160
161 if (reps > REPEAT_COUNT_THRESHOLD)
162 {
163 if (in_quotes)
164 {
165 if (inspect_it)
166 fputs_filtered ("\\\", ", stream);
167 else
168 fputs_filtered ("\", ", stream);
169 in_quotes = 0;
170 }
171 fputs_filtered ("'", stream);
172 printchar (string[i], stream, '\'');
173 fprintf_filtered (stream, "' <repeats %u times>", reps);
174 i = rep1 - 1;
175 things_printed += REPEAT_COUNT_THRESHOLD;
176 need_comma = 1;
177 }
178 else
179 {
180 if (!in_quotes)
181 {
182 if (inspect_it)
183 fputs_filtered ("\\\"", stream);
184 else
185 fputs_filtered ("\"", stream);
186 in_quotes = 1;
187 }
188 printchar (string[i], stream, '"');
189 ++things_printed;
190 }
191 }
192
193 /* Terminate the quotes if necessary. */
194 if (in_quotes)
195 {
196 if (inspect_it)
197 fputs_filtered ("\\\"", stream);
198 else
199 fputs_filtered ("\"", stream);
200 }
201
202 if (force_ellipses || i < length)
203 fputs_filtered ("...", stream);
204 }
205
206 /* Print a floating point value of type TYPE, pointed to in GDB by VALADDR,
207 on STREAM. */
208
209 void
210 print_floating (valaddr, type, stream)
211 char *valaddr;
212 struct type *type;
213 FILE *stream;
214 {
215 double doub;
216 int inv;
217 unsigned len = TYPE_LENGTH (type);
218
219 #if defined (IEEE_FLOAT)
220
221 /* Check for NaN's. Note that this code does not depend on us being
222 on an IEEE conforming system. It only depends on the target
223 machine using IEEE representation. This means (a)
224 cross-debugging works right, and (2) IEEE_FLOAT can (and should)
225 be defined for systems like the 68881, which uses IEEE
226 representation, but is not IEEE conforming. */
227
228 {
229 long low, high;
230 /* Is the sign bit 0? */
231 int nonnegative;
232 /* Is it is a NaN (i.e. the exponent is all ones and
233 the fraction is nonzero)? */
234 int is_nan;
235
236 if (len == sizeof (float))
237 {
238 /* It's single precision. */
239 bcopy (valaddr, &low, sizeof (low));
240 /* target -> host. */
241 SWAP_TARGET_AND_HOST (&low, sizeof (float));
242 nonnegative = low >= 0;
243 is_nan = ((((low >> 23) & 0xFF) == 0xFF)
244 && 0 != (low & 0x7FFFFF));
245 low &= 0x7fffff;
246 high = 0;
247 }
248 else
249 {
250 /* It's double precision. Get the high and low words. */
251
252 #if TARGET_BYTE_ORDER == BIG_ENDIAN
253 bcopy (valaddr+4, &low, sizeof (low));
254 bcopy (valaddr+0, &high, sizeof (high));
255 #else
256 bcopy (valaddr+0, &low, sizeof (low));
257 bcopy (valaddr+4, &high, sizeof (high));
258 #endif
259 SWAP_TARGET_AND_HOST (&low, sizeof (low));
260 SWAP_TARGET_AND_HOST (&high, sizeof (high));
261 nonnegative = high >= 0;
262 is_nan = (((high >> 20) & 0x7ff) == 0x7ff
263 && ! ((((high & 0xfffff) == 0)) && (low == 0)));
264 high &= 0xfffff;
265 }
266
267 if (is_nan)
268 {
269 /* The meaning of the sign and fraction is not defined by IEEE.
270 But the user might know what they mean. For example, they
271 (in an implementation-defined manner) distinguish between
272 signaling and quiet NaN's. */
273 if (high)
274 fprintf_filtered (stream, "-NaN(0x%lx%.8lx)" + nonnegative,
275 high, low);
276 else
277 fprintf_filtered (stream, "-NaN(0x%lx)" + nonnegative, low);
278 return;
279 }
280 }
281 #endif /* IEEE_FLOAT. */
282
283 doub = unpack_double (type, valaddr, &inv);
284 if (inv)
285 fprintf_filtered (stream, "<invalid float value>");
286 else
287 fprintf_filtered (stream, len <= sizeof(float) ? "%.9g" : "%.17g", doub);
288 }
289
290 /* VALADDR points to an integer of LEN bytes. Print it in hex on stream. */
291 static void
292 print_hex_chars (stream, valaddr, len)
293 FILE *stream;
294 unsigned char *valaddr;
295 unsigned len;
296 {
297 unsigned char *p;
298
299 fprintf_filtered (stream, "0x");
300 #if TARGET_BYTE_ORDER == BIG_ENDIAN
301 for (p = valaddr;
302 p < valaddr + len;
303 p++)
304 #else /* Little endian. */
305 for (p = valaddr + len - 1;
306 p >= valaddr;
307 p--)
308 #endif
309 {
310 fprintf_filtered (stream, "%02x", *p);
311 }
312 }
313 \f
314 /* Print the value VAL in C-ish syntax on stream STREAM.
315 FORMAT is a format-letter, or 0 for print in natural format of data type.
316 If the object printed is a string pointer, returns
317 the number of string bytes printed. */
318
319 int
320 value_print (val, stream, format, pretty)
321 value val;
322 FILE *stream;
323 int format;
324 enum val_prettyprint pretty;
325 {
326 register unsigned int i, n, typelen;
327
328 if (val == 0)
329 {
330 printf_filtered ("<address of value unknown>");
331 return 0;
332 }
333 if (VALUE_OPTIMIZED_OUT (val))
334 {
335 printf_filtered ("<value optimized out>");
336 return 0;
337 }
338
339 /* A "repeated" value really contains several values in a row.
340 They are made by the @ operator.
341 Print such values as if they were arrays. */
342
343 else if (VALUE_REPEATED (val))
344 {
345 n = VALUE_REPETITIONS (val);
346 typelen = TYPE_LENGTH (VALUE_TYPE (val));
347 fprintf_filtered (stream, "{");
348 /* Print arrays of characters using string syntax. */
349 if (typelen == 1 && TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_INT
350 && format == 0)
351 print_string (stream, VALUE_CONTENTS (val), n, 0);
352 else
353 {
354 unsigned int things_printed = 0;
355
356 for (i = 0; i < n && things_printed < print_max; i++)
357 {
358 /* Position of the array element we are examining to see
359 whether it is repeated. */
360 unsigned int rep1;
361 /* Number of repetitions we have detected so far. */
362 unsigned int reps;
363
364 if (i != 0)
365 fprintf_filtered (stream, ", ");
366 wrap_here ("");
367
368 rep1 = i + 1;
369 reps = 1;
370 while (rep1 < n
371 && !bcmp (VALUE_CONTENTS (val) + typelen * i,
372 VALUE_CONTENTS (val) + typelen * rep1, typelen))
373 {
374 ++reps;
375 ++rep1;
376 }
377
378 if (reps > REPEAT_COUNT_THRESHOLD)
379 {
380 val_print (VALUE_TYPE (val),
381 VALUE_CONTENTS (val) + typelen * i,
382 VALUE_ADDRESS (val) + typelen * i,
383 stream, format, 1, 0, pretty);
384 fprintf (stream, " <repeats %u times>", reps);
385 i = rep1 - 1;
386 things_printed += REPEAT_COUNT_THRESHOLD;
387 }
388 else
389 {
390 val_print (VALUE_TYPE (val),
391 VALUE_CONTENTS (val) + typelen * i,
392 VALUE_ADDRESS (val) + typelen * i,
393 stream, format, 1, 0, pretty);
394 things_printed++;
395 }
396 }
397 if (i < n)
398 fprintf_filtered (stream, "...");
399 }
400 fprintf_filtered (stream, "}");
401 return n * typelen;
402 }
403 else
404 {
405 struct type *type = VALUE_TYPE (val);
406
407 /* If it is a pointer, indicate what it points to.
408
409 Print type also if it is a reference.
410
411 C++: if it is a member pointer, we will take care
412 of that when we print it. */
413 if (TYPE_CODE (type) == TYPE_CODE_PTR
414 || TYPE_CODE (type) == TYPE_CODE_REF)
415 {
416 /* Hack: remove (char *) for char strings. Their
417 type is indicated by the quoted string anyway. */
418 if (TYPE_CODE (type) == TYPE_CODE_PTR
419 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == sizeof(char)
420 && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_INT
421 && !TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
422 {
423 /* Print nothing */
424 }
425 else
426 {
427 fprintf_filtered (stream, "(");
428 type_print (type, "", stream, -1);
429 fprintf_filtered (stream, ") ");
430 }
431 }
432 return val_print (type, VALUE_CONTENTS (val),
433 VALUE_ADDRESS (val), stream, format, 1, 0, pretty);
434 }
435 }
436
437 /* Return truth value for assertion that TYPE is of the type
438 "pointer to virtual function". */
439 static int
440 is_vtbl_ptr_type(type)
441 struct type *type;
442 {
443 char *typename = type_name_no_tag (type);
444 static const char vtbl_ptr_name[] =
445 { CPLUS_MARKER,'v','t','b','l','_','p','t','r','_','t','y','p','e', 0 };
446
447 return (typename != NULL && !strcmp(typename, vtbl_ptr_name));
448 }
449
450 /* Return truth value for the assertion that TYPE is of the type
451 "pointer to virtual function table". */
452 static int
453 is_vtbl_member(type)
454 struct type *type;
455 {
456 if (TYPE_CODE (type) == TYPE_CODE_PTR)
457 type = TYPE_TARGET_TYPE (type);
458 else
459 return 0;
460
461 if (TYPE_CODE (type) == TYPE_CODE_ARRAY
462 && TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT)
463 /* Virtual functions tables are full of pointers to virtual functions. */
464 return is_vtbl_ptr_type (TYPE_TARGET_TYPE (type));
465 return 0;
466 }
467 \f
468 /* Mutually recursive subroutines of cplus_val_print and val_print to print out
469 a structure's fields: val_print_fields and cplus_val_print.
470
471 TYPE, VALADDR, STREAM, RECURSE, and PRETTY have the
472 same meanings as in cplus_val_print and val_print.
473
474 DONT_PRINT is an array of baseclass types that we
475 should not print, or zero if called from top level. */
476
477 static void
478 val_print_fields (type, valaddr, stream, format, recurse, pretty, dont_print)
479 struct type *type;
480 char *valaddr;
481 FILE *stream;
482 int format;
483 int recurse;
484 enum val_prettyprint pretty;
485 struct type **dont_print;
486 {
487 int i, len, n_baseclasses;
488
489 check_stub_type (type);
490
491 fprintf_filtered (stream, "{");
492 len = TYPE_NFIELDS (type);
493 n_baseclasses = TYPE_N_BASECLASSES (type);
494
495 /* Print out baseclasses such that we don't print
496 duplicates of virtual baseclasses. */
497 if (n_baseclasses > 0)
498 cplus_val_print (type, valaddr, stream, format, recurse+1, pretty, dont_print);
499
500 if (!len && n_baseclasses == 1)
501 fprintf_filtered (stream, "<No data fields>");
502 else
503 {
504 extern int inspect_it;
505 int fields_seen = 0;
506
507 for (i = n_baseclasses; i < len; i++)
508 {
509 /* Check if static field */
510 if (TYPE_FIELD_STATIC (type, i))
511 continue;
512 if (fields_seen)
513 fprintf_filtered (stream, ", ");
514 else if (n_baseclasses > 0)
515 {
516 if (pretty)
517 {
518 fprintf_filtered (stream, "\n");
519 print_spaces_filtered (2 + 2 * recurse, stream);
520 fputs_filtered ("members of ", stream);
521 fputs_filtered (type_name_no_tag (type), stream);
522 fputs_filtered (": ", stream);
523 }
524 }
525 fields_seen = 1;
526
527 if (pretty)
528 {
529 fprintf_filtered (stream, "\n");
530 print_spaces_filtered (2 + 2 * recurse, stream);
531 }
532 else
533 {
534 wrap_here (n_spaces (2 + 2 * recurse));
535 }
536 if (inspect_it)
537 {
538 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
539 fputs_filtered ("\"( ptr \"", stream);
540 else
541 fputs_filtered ("\"( nodef \"", stream);
542 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
543 fputs_filtered ("\" \"", stream);
544 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
545 fputs_filtered ("\") \"", stream);
546 }
547 else
548 {
549 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
550 fputs_filtered (" = ", stream);
551 }
552 if (TYPE_FIELD_PACKED (type, i))
553 {
554 value v;
555
556 /* Bitfields require special handling, especially due to byte
557 order problems. */
558 v = value_from_longest (TYPE_FIELD_TYPE (type, i),
559 unpack_field_as_long (type, valaddr, i));
560
561 val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0,
562 stream, format, 0, recurse + 1, pretty);
563 }
564 else
565 {
566 val_print (TYPE_FIELD_TYPE (type, i),
567 valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
568 0, stream, format, 0, recurse + 1, pretty);
569 }
570 }
571 if (pretty)
572 {
573 fprintf_filtered (stream, "\n");
574 print_spaces_filtered (2 * recurse, stream);
575 }
576 }
577 fprintf_filtered (stream, "}");
578 }
579
580 /* Special val_print routine to avoid printing multiple copies of virtual
581 baseclasses. */
582
583 static void
584 cplus_val_print (type, valaddr, stream, format, recurse, pretty, dont_print)
585 struct type *type;
586 char *valaddr;
587 FILE *stream;
588 int format;
589 int recurse;
590 enum val_prettyprint pretty;
591 struct type **dont_print;
592 {
593 struct obstack tmp_obstack;
594 struct type **last_dont_print
595 = (struct type **)obstack_next_free (&dont_print_obstack);
596 int i, n_baseclasses = TYPE_N_BASECLASSES (type);
597
598 if (dont_print == 0)
599 {
600 /* If we're at top level, carve out a completely fresh
601 chunk of the obstack and use that until this particular
602 invocation returns. */
603 tmp_obstack = dont_print_obstack;
604 /* Bump up the high-water mark. Now alpha is omega. */
605 obstack_finish (&dont_print_obstack);
606 }
607
608 for (i = 0; i < n_baseclasses; i++)
609 {
610 char *baddr;
611 int err;
612
613 if (BASETYPE_VIA_VIRTUAL (type, i))
614 {
615 struct type **first_dont_print
616 = (struct type **)obstack_base (&dont_print_obstack);
617
618 int j = (struct type **)obstack_next_free (&dont_print_obstack)
619 - first_dont_print;
620
621 while (--j >= 0)
622 if (TYPE_BASECLASS (type, i) == first_dont_print[j])
623 goto flush_it;
624
625 obstack_ptr_grow (&dont_print_obstack, TYPE_BASECLASS (type, i));
626 }
627
628 baddr = baseclass_addr (type, i, valaddr, 0, &err);
629 if (err == 0 && baddr == 0)
630 error ("could not find virtual baseclass `%s'\n",
631 type_name_no_tag (TYPE_BASECLASS (type, i)));
632
633 if (pretty)
634 {
635 fprintf_filtered (stream, "\n");
636 print_spaces_filtered (2 * recurse, stream);
637 }
638 fputs_filtered ("<", stream);
639 fputs_filtered (type_name_no_tag (TYPE_BASECLASS (type, i)), stream);
640 fputs_filtered ("> = ", stream);
641 if (err != 0)
642 fprintf_filtered (stream, "<invalid address 0x%x>", baddr);
643 else
644 val_print_fields (TYPE_BASECLASS (type, i), baddr, stream, format,
645 recurse, pretty,
646 (struct type **)obstack_base (&dont_print_obstack));
647 fputs_filtered (", ", stream);
648
649 flush_it:
650 ;
651 }
652
653 if (dont_print == 0)
654 {
655 /* Free the space used to deal with the printing
656 of this type from top level. */
657 obstack_free (&dont_print_obstack, last_dont_print);
658 /* Reset watermark so that we can continue protecting
659 ourselves from whatever we were protecting ourselves. */
660 dont_print_obstack = tmp_obstack;
661 }
662 }
663
664 static void
665 print_class_member (valaddr, domain, stream, prefix)
666 char *valaddr;
667 struct type *domain;
668 FILE *stream;
669 char *prefix;
670 {
671
672 /* VAL is a byte offset into the structure type DOMAIN.
673 Find the name of the field for that offset and
674 print it. */
675 int extra = 0;
676 int bits = 0;
677 register unsigned int i;
678 unsigned len = TYPE_NFIELDS (domain);
679 /* @@ Make VAL into bit offset */
680 LONGEST val = unpack_long (builtin_type_int, valaddr) << 3;
681 for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
682 {
683 int bitpos = TYPE_FIELD_BITPOS (domain, i);
684 QUIT;
685 if (val == bitpos)
686 break;
687 if (val < bitpos && i != 0)
688 {
689 /* Somehow pointing into a field. */
690 i -= 1;
691 extra = (val - TYPE_FIELD_BITPOS (domain, i));
692 if (extra & 0x7)
693 bits = 1;
694 else
695 extra >>= 3;
696 break;
697 }
698 }
699 if (i < len)
700 {
701 char *name;
702 fprintf_filtered (stream, prefix);
703 name = type_name_no_tag (domain);
704 if (name)
705 fputs_filtered (name, stream);
706 else
707 type_print_base (domain, stream, 0, 0);
708 fprintf_filtered (stream, "::");
709 fputs_filtered (TYPE_FIELD_NAME (domain, i), stream);
710 if (extra)
711 fprintf_filtered (stream, " + %d bytes", extra);
712 if (bits)
713 fprintf_filtered (stream, " (offset in bits)");
714 }
715 else
716 fprintf_filtered (stream, "%d", val >> 3);
717 }
718
719 /* Print data of type TYPE located at VALADDR (within GDB),
720 which came from the inferior at address ADDRESS,
721 onto stdio stream STREAM according to FORMAT
722 (a letter or 0 for natural format). The data at VALADDR
723 is in target byte order.
724
725 If the data are a string pointer, returns the number of
726 sting characters printed.
727
728 if DEREF_REF is nonzero, then dereference references,
729 otherwise just print them like pointers.
730
731 The PRETTY parameter controls prettyprinting. */
732
733 int
734 val_print (type, valaddr, address, stream, format, deref_ref, recurse, pretty)
735 struct type *type;
736 char *valaddr;
737 CORE_ADDR address;
738 FILE *stream;
739 int format;
740 int deref_ref;
741 int recurse;
742 enum val_prettyprint pretty;
743 {
744 register unsigned int i;
745 unsigned len;
746 struct type *elttype;
747 unsigned eltlen;
748 LONGEST val;
749 unsigned char c;
750
751 if (pretty == Val_pretty_default)
752 {
753 pretty = prettyprint ? Val_prettyprint : Val_no_prettyprint;
754 }
755
756 QUIT;
757
758 check_stub_type (type);
759
760 if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
761 {
762 fprintf_filtered (stream, "<unknown struct>");
763 fflush (stream);
764 return 0;
765 }
766
767 switch (TYPE_CODE (type))
768 {
769 case TYPE_CODE_ARRAY:
770 if (TYPE_LENGTH (type) > 0
771 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
772 {
773 elttype = TYPE_TARGET_TYPE (type);
774 eltlen = TYPE_LENGTH (elttype);
775 len = TYPE_LENGTH (type) / eltlen;
776 if (arrayprint)
777 print_spaces_filtered (2 + 2 * recurse, stream);
778 fprintf_filtered (stream, "{");
779 /* For an array of chars, print with string syntax. */
780 if (eltlen == 1 && TYPE_CODE (elttype) == TYPE_CODE_INT
781 && (format == 0 || format == 's') )
782 print_string (stream, valaddr, len, 0);
783 else
784 {
785 unsigned int things_printed = 0;
786
787 /* If this is a virtual function table, print the 0th
788 entry specially, and the rest of the members normally. */
789 if (is_vtbl_ptr_type (elttype))
790 {
791 fprintf_filtered (stream, "%d vtable entries", len-1);
792 i = 1;
793 }
794 else
795 i = 0;
796
797 for (; i < len && things_printed < print_max; i++)
798 {
799 /* Position of the array element we are examining to see
800 whether it is repeated. */
801 unsigned int rep1;
802 /* Number of repetitions we have detected so far. */
803 unsigned int reps;
804
805 if (i != 0)
806 if (arrayprint)
807 {
808 fprintf_filtered (stream, ",\n");
809 print_spaces_filtered (2 + 2 * recurse, stream);
810 }
811 else
812 fprintf_filtered (stream, ", ");
813 wrap_here (n_spaces (2 + 2 * recurse));
814
815 rep1 = i + 1;
816 reps = 1;
817 while (rep1 < len
818 && !bcmp (valaddr + i * eltlen,
819 valaddr + rep1 * eltlen, eltlen))
820 {
821 ++reps;
822 ++rep1;
823 }
824
825 if (reps > REPEAT_COUNT_THRESHOLD)
826 {
827 val_print (elttype, valaddr + i * eltlen,
828 0, stream, format, deref_ref,
829 recurse + 1, pretty);
830 fprintf_filtered (stream, " <repeats %u times>", reps);
831 i = rep1 - 1;
832 things_printed += REPEAT_COUNT_THRESHOLD;
833 }
834 else
835 {
836 val_print (elttype, valaddr + i * eltlen,
837 0, stream, format, deref_ref,
838 recurse + 1, pretty);
839 things_printed++;
840 }
841 }
842 if (i < len)
843 fprintf_filtered (stream, "...");
844 }
845 fprintf_filtered (stream, "}");
846 break;
847 }
848 /* Array of unspecified length: treat like pointer to first elt. */
849 valaddr = (char *) &address;
850
851 case TYPE_CODE_PTR:
852 if (format && format != 's')
853 {
854 print_scalar_formatted (valaddr, type, format, 0, stream);
855 break;
856 }
857 if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD)
858 {
859 struct type *domain = TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type));
860 struct fn_field *f;
861 int j, len2;
862 char *kind = "";
863 CORE_ADDR addr;
864
865 addr = unpack_pointer (lookup_pointer_type (builtin_type_void),
866 valaddr);
867 if (addr < 128) /* FIXME! What is this 128? */
868 {
869 len = TYPE_NFN_FIELDS (domain);
870 for (i = 0; i < len; i++)
871 {
872 f = TYPE_FN_FIELDLIST1 (domain, i);
873 len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
874
875 for (j = 0; j < len2; j++)
876 {
877 QUIT;
878 if (TYPE_FN_FIELD_VOFFSET (f, j) == addr)
879 {
880 kind = "virtual";
881 goto common;
882 }
883 }
884 }
885 }
886 else
887 {
888 struct symbol *sym = find_pc_function (addr);
889 if (sym == 0)
890 error ("invalid pointer to member function");
891 len = TYPE_NFN_FIELDS (domain);
892 for (i = 0; i < len; i++)
893 {
894 f = TYPE_FN_FIELDLIST1 (domain, i);
895 len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
896
897 for (j = 0; j < len2; j++)
898 {
899 QUIT;
900 if (!strcmp (SYMBOL_NAME (sym), TYPE_FN_FIELD_PHYSNAME (f, j)))
901 goto common;
902 }
903 }
904 }
905 common:
906 if (i < len)
907 {
908 fprintf_filtered (stream, "&");
909 type_print_varspec_prefix (TYPE_FN_FIELD_TYPE (f, j), stream, 0, 0);
910 fprintf (stream, kind);
911 if (TYPE_FN_FIELD_PHYSNAME (f, j)[0] == '_'
912 && TYPE_FN_FIELD_PHYSNAME (f, j)[1] == CPLUS_MARKER)
913 type_print_method_args
914 (TYPE_FN_FIELD_ARGS (f, j) + 1, "~",
915 TYPE_FN_FIELDLIST_NAME (domain, i), 0, stream);
916 else
917 type_print_method_args
918 (TYPE_FN_FIELD_ARGS (f, j), "",
919 TYPE_FN_FIELDLIST_NAME (domain, i), 0, stream);
920 break;
921 }
922 fprintf_filtered (stream, "(");
923 type_print (type, "", stream, -1);
924 fprintf_filtered (stream, ") %d", (int) addr >> 3);
925 }
926 else if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_MEMBER)
927 {
928 print_class_member (valaddr,
929 TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type)),
930 stream, "&");
931 }
932 else
933 {
934 CORE_ADDR addr = unpack_pointer (type, valaddr);
935 elttype = TYPE_TARGET_TYPE (type);
936
937 if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
938 {
939 /* Try to print what function it points to. */
940 print_address_demangle (addr, stream, demangle);
941 /* Return value is irrelevant except for string pointers. */
942 return 0;
943 }
944
945 if (addressprint && format != 's')
946 fprintf_filtered (stream, "0x%x", addr);
947
948 /* For a pointer to char or unsigned char,
949 also print the string pointed to, unless pointer is null. */
950 i = 0; /* Number of characters printed. */
951 if (TYPE_LENGTH (elttype) == 1
952 && TYPE_CODE (elttype) == TYPE_CODE_INT
953 && (format == 0 || format == 's')
954 && addr != 0
955 /* If print_max is UINT_MAX, the alloca below will fail.
956 In that case don't try to print the string. */
957 && print_max < UINT_MAX)
958 {
959 int first_addr_err = 0;
960 int errcode = 0;
961
962 /* Get first character. */
963 errcode = target_read_memory (addr, (char *)&c, 1);
964 if (errcode != 0)
965 {
966 /* First address out of bounds. */
967 first_addr_err = 1;
968 }
969 else
970 {
971 /* A real string. */
972 char *string = (char *) alloca (print_max);
973
974 /* If the loop ends by us hitting print_max characters,
975 we need to have elipses at the end. */
976 int force_ellipses = 1;
977
978 /* This loop always fetches print_max characters, even
979 though print_string might want to print more or fewer
980 (with repeated characters). This is so that
981 we don't spend forever fetching if we print
982 a long string consisting of the same character
983 repeated. Also so we can do it all in one memory
984 operation, which is faster. However, this will be
985 slower if print_max is set high, e.g. if you set
986 print_max to 1000, not only will it take a long
987 time to fetch short strings, but if you are near
988 the end of the address space, it might not work. */
989 QUIT;
990 errcode = target_read_memory (addr, string, print_max);
991 if (errcode != 0)
992 {
993 /* Try reading just one character. If that succeeds,
994 assume we hit the end of the address space, but
995 the initial part of the string is probably safe. */
996 char x[1];
997 errcode = target_read_memory (addr, x, 1);
998 }
999 if (errcode != 0)
1000 force_ellipses = 0;
1001 else
1002 for (i = 0; i < print_max; i++)
1003 if (string[i] == '\0')
1004 {
1005 force_ellipses = 0;
1006 break;
1007 }
1008 QUIT;
1009
1010 if (addressprint)
1011 fputs_filtered (" ", stream);
1012 print_string (stream, string, i, force_ellipses);
1013 }
1014
1015 if (errcode != 0)
1016 {
1017 if (errcode == EIO)
1018 {
1019 fprintf_filtered (stream,
1020 (" <Address 0x%x out of bounds>"
1021 + first_addr_err),
1022 addr + i);
1023 }
1024 else
1025 {
1026 error ("Error reading memory address 0x%x: %s.",
1027 addr + i, safe_strerror (errcode));
1028 }
1029 }
1030
1031 fflush (stream);
1032 }
1033 else /* print vtbl's nicely */
1034 if (is_vtbl_member(type))
1035 {
1036 CORE_ADDR vt_address = unpack_pointer (type, valaddr);
1037
1038 struct minimal_symbol *msymbol =
1039 lookup_minimal_symbol_by_pc (vt_address);
1040 if ((msymbol != NULL) && (vt_address == msymbol -> address))
1041 {
1042 fputs_filtered (" <", stream);
1043 fputs_demangled (msymbol -> name, stream,
1044 DMGL_ANSI | DMGL_PARAMS);
1045 fputs_filtered (">", stream);
1046 }
1047 if (vtblprint)
1048 {
1049 value vt_val;
1050
1051 vt_val = value_at (TYPE_TARGET_TYPE (type), vt_address);
1052 val_print (VALUE_TYPE (vt_val), VALUE_CONTENTS (vt_val),
1053 VALUE_ADDRESS (vt_val), stream, format,
1054 deref_ref, recurse + 1, pretty);
1055 if (pretty)
1056 {
1057 fprintf_filtered (stream, "\n");
1058 print_spaces_filtered (2 + 2 * recurse, stream);
1059 }
1060 }
1061 }
1062
1063 /* Return number of characters printed, plus one for the
1064 terminating null if we have "reached the end". */
1065 return i + (print_max && i != print_max);
1066 }
1067 break;
1068
1069 case TYPE_CODE_MEMBER:
1070 error ("not implemented: member type in val_print");
1071 break;
1072
1073 case TYPE_CODE_REF:
1074 if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_MEMBER)
1075 {
1076 print_class_member (valaddr,
1077 TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type)),
1078 stream, "");
1079 break;
1080 }
1081 if (addressprint)
1082 {
1083 fprintf_filtered (stream, "@0x%lx",
1084 unpack_long (builtin_type_int, valaddr));
1085 if (deref_ref)
1086 fputs_filtered (": ", stream);
1087 }
1088 /* De-reference the reference. */
1089 if (deref_ref)
1090 {
1091 if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_UNDEF)
1092 {
1093 value deref_val =
1094 value_at
1095 (TYPE_TARGET_TYPE (type),
1096 unpack_pointer (lookup_pointer_type (builtin_type_void),
1097 valaddr));
1098 val_print (VALUE_TYPE (deref_val), VALUE_CONTENTS (deref_val),
1099 VALUE_ADDRESS (deref_val), stream, format,
1100 deref_ref, recurse + 1, pretty);
1101 }
1102 else
1103 fputs_filtered ("???", stream);
1104 }
1105 break;
1106
1107 case TYPE_CODE_UNION:
1108 if (recurse && !unionprint)
1109 {
1110 fprintf_filtered (stream, "{...}");
1111 break;
1112 }
1113 /* Fall through. */
1114 case TYPE_CODE_STRUCT:
1115 if (vtblprint && is_vtbl_ptr_type(type))
1116 {
1117 /* Print the unmangled name if desired. */
1118 print_address_demangle(*((int *) (valaddr + /* FIXME bytesex */
1119 TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8)),
1120 stream, demangle);
1121 break;
1122 }
1123 val_print_fields (type, valaddr, stream, format, recurse, pretty, 0);
1124 break;
1125
1126 case TYPE_CODE_ENUM:
1127 if (format)
1128 {
1129 print_scalar_formatted (valaddr, type, format, 0, stream);
1130 break;
1131 }
1132 len = TYPE_NFIELDS (type);
1133 val = unpack_long (builtin_type_int, valaddr);
1134 for (i = 0; i < len; i++)
1135 {
1136 QUIT;
1137 if (val == TYPE_FIELD_BITPOS (type, i))
1138 break;
1139 }
1140 if (i < len)
1141 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1142 else
1143 #ifdef LONG_LONG
1144 fprintf_filtered (stream, "%lld", val);
1145 #else
1146 fprintf_filtered (stream, "%ld", val);
1147 #endif
1148 break;
1149
1150 case TYPE_CODE_FUNC:
1151 if (format)
1152 {
1153 print_scalar_formatted (valaddr, type, format, 0, stream);
1154 break;
1155 }
1156 /* FIXME, we should consider, at least for ANSI C language, eliminating
1157 the distinction made between FUNCs and POINTERs to FUNCs. */
1158 fprintf_filtered (stream, "{");
1159 type_print (type, "", stream, -1);
1160 fprintf_filtered (stream, "} ");
1161 /* Try to print what function it points to, and its address. */
1162 print_address_demangle (address, stream, demangle);
1163 break;
1164
1165 case TYPE_CODE_INT:
1166 if (format || output_format)
1167 {
1168 print_scalar_formatted (valaddr, type,
1169 format? format: output_format,
1170 0, stream);
1171 break;
1172 }
1173 if (TYPE_LENGTH (type) > sizeof (LONGEST))
1174 {
1175 if (TYPE_UNSIGNED (type))
1176 {
1177 /* First figure out whether the number in fact has zeros
1178 in all its bytes more significant than least significant
1179 sizeof (LONGEST) ones. */
1180 char *p;
1181 /* Pointer to first (i.e. lowest address) nonzero character. */
1182 char *first_addr;
1183 len = TYPE_LENGTH (type);
1184
1185 #if TARGET_BYTE_ORDER == BIG_ENDIAN
1186 for (p = valaddr;
1187 len > sizeof (LONGEST)
1188 && p < valaddr + TYPE_LENGTH (type);
1189 p++)
1190 #else /* Little endian. */
1191 first_addr = valaddr;
1192 for (p = valaddr + TYPE_LENGTH (type);
1193 len > sizeof (LONGEST) && p >= valaddr;
1194 p--)
1195 #endif /* Little endian. */
1196 {
1197 if (*p == 0)
1198 len--;
1199 else
1200 break;
1201 }
1202 #if TARGET_BYTE_ORDER == BIG_ENDIAN
1203 first_addr = p;
1204 #endif
1205
1206 if (len <= sizeof (LONGEST))
1207 {
1208 /* We can print it in decimal. */
1209 fprintf_filtered
1210 (stream,
1211 #if defined (LONG_LONG)
1212 "%llu",
1213 #else
1214 "%lu",
1215 #endif
1216 unpack_long (BUILTIN_TYPE_LONGEST, first_addr));
1217 }
1218 else
1219 {
1220 /* It is big, so print it in hex. */
1221 print_hex_chars (stream, (unsigned char *)first_addr, len);
1222 }
1223 }
1224 else
1225 {
1226 /* Signed. One could assume two's complement (a reasonable
1227 assumption, I think) and do better than this. */
1228 print_hex_chars (stream, (unsigned char *)valaddr,
1229 TYPE_LENGTH (type));
1230 }
1231 break;
1232 }
1233 #ifdef PRINT_TYPELESS_INTEGER
1234 PRINT_TYPELESS_INTEGER (stream, type, unpack_long (type, valaddr));
1235 #else
1236 #ifndef LONG_LONG
1237 fprintf_filtered (stream,
1238 TYPE_UNSIGNED (type) ? "%u" : "%d",
1239 unpack_long (type, valaddr));
1240 #else
1241 fprintf_filtered (stream,
1242 TYPE_UNSIGNED (type) ? "%llu" : "%lld",
1243 unpack_long (type, valaddr));
1244 #endif
1245 #endif
1246
1247 if (TYPE_LENGTH (type) == 1)
1248 {
1249 fprintf_filtered (stream, " '");
1250 printchar ((unsigned char) unpack_long (type, valaddr),
1251 stream, '\'');
1252 fprintf_filtered (stream, "'");
1253 }
1254 break;
1255
1256 case TYPE_CODE_FLT:
1257 if (format)
1258 print_scalar_formatted (valaddr, type, format, 0, stream);
1259 else
1260 print_floating (valaddr, type, stream);
1261 break;
1262
1263 case TYPE_CODE_VOID:
1264 fprintf_filtered (stream, "void");
1265 break;
1266
1267 case TYPE_CODE_UNDEF:
1268 /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
1269 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
1270 and no complete type for struct foo in that file. */
1271 fprintf_filtered (stream, "<unknown struct>");
1272 break;
1273
1274 case TYPE_CODE_ERROR:
1275 fprintf_filtered (stream, "?");
1276 break;
1277
1278 case TYPE_CODE_RANGE:
1279 /* FIXME, we should not ever have to print one of these yet. */
1280 fprintf_filtered (stream, "<range type>");
1281 break;
1282
1283 default:
1284 error ("Invalid type code in symbol table.");
1285 }
1286 fflush (stream);
1287 return 0;
1288 }
1289 \f
1290 /* Print a description of a type in the format of a
1291 typedef for the current language.
1292 NEW is the new name for a type TYPE. */
1293 void
1294 typedef_print (type, new, stream)
1295 struct type *type;
1296 struct symbol *new;
1297 FILE *stream;
1298 {
1299 switch (current_language->la_language)
1300 {
1301 #ifdef _LANG_c
1302 case language_c:
1303 case language_cplus:
1304 fprintf_filtered(stream, "typedef ");
1305 type_print(type,"",stream,0);
1306 if(TYPE_NAME ((SYMBOL_TYPE (new))) == 0
1307 || 0 != strcmp (TYPE_NAME ((SYMBOL_TYPE (new))),
1308 SYMBOL_NAME (new)))
1309 fprintf_filtered(stream, " %s", SYMBOL_NAME(new));
1310 break;
1311 #endif
1312 #ifdef _LANG_m2
1313 case language_m2:
1314 fprintf_filtered(stream, "TYPE ");
1315 if(!TYPE_NAME(SYMBOL_TYPE(new)) ||
1316 strcmp (TYPE_NAME(SYMBOL_TYPE(new)),
1317 SYMBOL_NAME(new)))
1318 fprintf_filtered(stream, "%s = ", SYMBOL_NAME(new));
1319 else
1320 fprintf_filtered(stream, "<builtin> = ");
1321 type_print(type,"",stream,0);
1322 break;
1323 #endif
1324 default:
1325 error("Language not supported.");
1326 }
1327 fprintf_filtered(stream, ";\n");
1328 }
1329
1330
1331 /* Print a description of a type TYPE
1332 in the form of a declaration of a variable named VARSTRING.
1333 (VARSTRING is demangled if necessary.)
1334 Output goes to STREAM (via stdio).
1335 If SHOW is positive, we show the contents of the outermost level
1336 of structure even if there is a type name that could be used instead.
1337 If SHOW is negative, we never show the details of elements' types. */
1338
1339 void
1340 type_print (type, varstring, stream, show)
1341 struct type *type;
1342 char *varstring;
1343 FILE *stream;
1344 int show;
1345 {
1346 type_print_1 (type, varstring, stream, show, 0);
1347 }
1348
1349 /* LEVEL is the depth to indent lines by. */
1350
1351 void
1352 type_print_1 (type, varstring, stream, show, level)
1353 struct type *type;
1354 char *varstring;
1355 FILE *stream;
1356 int show;
1357 int level;
1358 {
1359 register enum type_code code;
1360 char *demangled = NULL;
1361 int demangled_args;
1362
1363 type_print_base (type, stream, show, level);
1364 code = TYPE_CODE (type);
1365 if ((varstring && *varstring)
1366 ||
1367 /* Need a space if going to print stars or brackets;
1368 but not if we will print just a type name. */
1369 ((show > 0 || TYPE_NAME (type) == 0)
1370 &&
1371 (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
1372 || code == TYPE_CODE_METHOD
1373 || code == TYPE_CODE_ARRAY
1374 || code == TYPE_CODE_MEMBER
1375 || code == TYPE_CODE_REF)))
1376 fprintf_filtered (stream, " ");
1377 type_print_varspec_prefix (type, stream, show, 0);
1378
1379 /* See if the name has a C++ demangled equivalent, and if so, print that
1380 instead. */
1381
1382 if (demangle)
1383 {
1384 demangled = cplus_demangle (varstring, DMGL_ANSI | DMGL_PARAMS);
1385 }
1386 fputs_filtered ((demangled != NULL) ? demangled : varstring, stream);
1387
1388 /* For demangled function names, we have the arglist as part of the name,
1389 so don't print an additional pair of ()'s */
1390
1391 demangled_args = (demangled != NULL) && (code == TYPE_CODE_FUNC);
1392 type_print_varspec_suffix (type, stream, show, 0, demangled_args);
1393
1394 if (demangled)
1395 {
1396 free (demangled);
1397 }
1398 }
1399
1400 /* Print the method arguments ARGS to the file STREAM. */
1401 static void
1402 type_print_method_args (args, prefix, varstring, staticp, stream)
1403 struct type **args;
1404 char *prefix, *varstring;
1405 int staticp;
1406 FILE *stream;
1407 {
1408 int i;
1409
1410 fputs_demangled (prefix, stream, DMGL_ANSI | DMGL_PARAMS);
1411 fputs_demangled (varstring, stream, DMGL_ANSI | DMGL_PARAMS);
1412 fputs_filtered (" (", stream);
1413 if (args && args[!staticp] && args[!staticp]->code != TYPE_CODE_VOID)
1414 {
1415 i = !staticp; /* skip the class variable */
1416 while (1)
1417 {
1418 type_print (args[i++], "", stream, 0);
1419 if (!args[i])
1420 {
1421 fprintf_filtered (stream, " ...");
1422 break;
1423 }
1424 else if (args[i]->code != TYPE_CODE_VOID)
1425 {
1426 fprintf_filtered (stream, ", ");
1427 }
1428 else break;
1429 }
1430 }
1431 fprintf_filtered (stream, ")");
1432 }
1433
1434 /* If TYPE is a derived type, then print out derivation
1435 information. Print out all layers of the type heirarchy
1436 until we encounter one with multiple inheritance.
1437 At that point, print out that ply, and return. */
1438 static void
1439 type_print_derivation_info (stream, type)
1440 FILE *stream;
1441 struct type *type;
1442 {
1443 char *name;
1444 int i, n_baseclasses = TYPE_N_BASECLASSES (type);
1445 struct type *basetype = 0;
1446
1447 while (type && n_baseclasses > 0)
1448 {
1449 /* Not actually sure about this one -- Bryan. */
1450 check_stub_type (type);
1451
1452 fprintf_filtered (stream, ": ");
1453 for (i = 0; ;)
1454 {
1455 basetype = TYPE_BASECLASS (type, i);
1456 if (name = type_name_no_tag (basetype))
1457 {
1458 fprintf_filtered (stream, "%s%s ",
1459 BASETYPE_VIA_PUBLIC(type, i) ? "public" : "private",
1460 BASETYPE_VIA_VIRTUAL(type, i) ? " virtual" : "");
1461 fputs_filtered (name, stream);
1462 }
1463 i++;
1464 if (i >= n_baseclasses)
1465 break;
1466 fprintf_filtered (stream, ", ");
1467 }
1468
1469 fprintf_filtered (stream, " ");
1470 if (n_baseclasses != 1)
1471 break;
1472 n_baseclasses = TYPE_N_BASECLASSES (basetype);
1473 type = basetype;
1474 }
1475 }
1476
1477 /* Print any asterisks or open-parentheses needed before the
1478 variable name (to describe its type).
1479
1480 On outermost call, pass 0 for PASSED_A_PTR.
1481 On outermost call, SHOW > 0 means should ignore
1482 any typename for TYPE and show its details.
1483 SHOW is always zero on recursive calls. */
1484
1485 static void
1486 type_print_varspec_prefix (type, stream, show, passed_a_ptr)
1487 struct type *type;
1488 FILE *stream;
1489 int show;
1490 int passed_a_ptr;
1491 {
1492 char *name;
1493 if (type == 0)
1494 return;
1495
1496 if (TYPE_NAME (type) && show <= 0)
1497 return;
1498
1499 QUIT;
1500
1501 switch (TYPE_CODE (type))
1502 {
1503 case TYPE_CODE_PTR:
1504 type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1);
1505 fprintf_filtered (stream, "*");
1506 break;
1507
1508 case TYPE_CODE_MEMBER:
1509 if (passed_a_ptr)
1510 fprintf_filtered (stream, "(");
1511 type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0,
1512 0);
1513 fprintf_filtered (stream, " ");
1514 name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
1515 if (name)
1516 fputs_filtered (name, stream);
1517 else
1518 type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
1519 fprintf_filtered (stream, "::");
1520 break;
1521
1522 case TYPE_CODE_METHOD:
1523 if (passed_a_ptr)
1524 fprintf (stream, "(");
1525 type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0,
1526 0);
1527 if (passed_a_ptr)
1528 {
1529 fprintf_filtered (stream, " ");
1530 type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0,
1531 passed_a_ptr);
1532 fprintf_filtered (stream, "::");
1533 }
1534 break;
1535
1536 case TYPE_CODE_REF:
1537 type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1);
1538 fprintf_filtered (stream, "&");
1539 break;
1540
1541 case TYPE_CODE_FUNC:
1542 type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0,
1543 0);
1544 if (passed_a_ptr)
1545 fprintf_filtered (stream, "(");
1546 break;
1547
1548 case TYPE_CODE_ARRAY:
1549 type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0,
1550 0);
1551 if (passed_a_ptr)
1552 fprintf_filtered (stream, "(");
1553 break;
1554
1555 case TYPE_CODE_UNDEF:
1556 case TYPE_CODE_STRUCT:
1557 case TYPE_CODE_UNION:
1558 case TYPE_CODE_ENUM:
1559 case TYPE_CODE_INT:
1560 case TYPE_CODE_FLT:
1561 case TYPE_CODE_VOID:
1562 case TYPE_CODE_ERROR:
1563 case TYPE_CODE_CHAR:
1564 case TYPE_CODE_BOOL:
1565 /* These types need no prefix. They are listed here so that
1566 gcc -Wall will reveal any types that haven't been handled. */
1567 break;
1568 }
1569 }
1570
1571 /* Print any array sizes, function arguments or close parentheses
1572 needed after the variable name (to describe its type).
1573 Args work like type_print_varspec_prefix. */
1574
1575 static void
1576 type_print_varspec_suffix (type, stream, show, passed_a_ptr, demangled_args)
1577 struct type *type;
1578 FILE *stream;
1579 int show;
1580 int passed_a_ptr;
1581 int demangled_args;
1582 {
1583 if (type == 0)
1584 return;
1585
1586 if (TYPE_NAME (type) && show <= 0)
1587 return;
1588
1589 QUIT;
1590
1591 switch (TYPE_CODE (type))
1592 {
1593 case TYPE_CODE_ARRAY:
1594 if (passed_a_ptr)
1595 fprintf_filtered (stream, ")");
1596
1597 fprintf_filtered (stream, "[");
1598 if (TYPE_LENGTH (type) > 0
1599 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
1600 fprintf_filtered (stream, "%d",
1601 (TYPE_LENGTH (type)
1602 / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
1603 fprintf_filtered (stream, "]");
1604
1605 type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
1606 0, 0);
1607 break;
1608
1609 case TYPE_CODE_MEMBER:
1610 if (passed_a_ptr)
1611 fprintf_filtered (stream, ")");
1612 type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
1613 break;
1614
1615 case TYPE_CODE_METHOD:
1616 if (passed_a_ptr)
1617 fprintf_filtered (stream, ")");
1618 type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0, 0);
1619 if (passed_a_ptr)
1620 {
1621 int i;
1622 struct type **args = TYPE_ARG_TYPES (type);
1623
1624 fprintf_filtered (stream, "(");
1625 if (args[1] == 0)
1626 fprintf_filtered (stream, "...");
1627 else for (i = 1; args[i] != 0 && args[i]->code != TYPE_CODE_VOID; i++)
1628 {
1629 type_print_1 (args[i], "", stream, -1, 0);
1630 if (args[i+1] == 0)
1631 fprintf_filtered (stream, "...");
1632 else if (args[i+1]->code != TYPE_CODE_VOID) {
1633 fprintf_filtered (stream, ",");
1634 wrap_here (" ");
1635 }
1636 }
1637 fprintf_filtered (stream, ")");
1638 }
1639 break;
1640
1641 case TYPE_CODE_PTR:
1642 case TYPE_CODE_REF:
1643 type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 1, 0);
1644 break;
1645
1646 case TYPE_CODE_FUNC:
1647 type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
1648 passed_a_ptr, 0);
1649 if (passed_a_ptr)
1650 fprintf_filtered (stream, ")");
1651 if (!demangled_args)
1652 fprintf_filtered (stream, "()");
1653 break;
1654
1655 case TYPE_CODE_UNDEF:
1656 case TYPE_CODE_STRUCT:
1657 case TYPE_CODE_UNION:
1658 case TYPE_CODE_ENUM:
1659 case TYPE_CODE_INT:
1660 case TYPE_CODE_FLT:
1661 case TYPE_CODE_VOID:
1662 case TYPE_CODE_ERROR:
1663 case TYPE_CODE_CHAR:
1664 case TYPE_CODE_BOOL:
1665 /* These types do not need a suffix. They are listed so that
1666 gcc -Wall will report types that may not have been considered. */
1667 break;
1668 }
1669 }
1670
1671 /* Print the name of the type (or the ultimate pointer target,
1672 function value or array element), or the description of a
1673 structure or union.
1674
1675 SHOW nonzero means don't print this type as just its name;
1676 show its real definition even if it has a name.
1677 SHOW zero means print just typename or struct tag if there is one
1678 SHOW negative means abbreviate structure elements.
1679 SHOW is decremented for printing of structure elements.
1680
1681 LEVEL is the depth to indent by.
1682 We increase it for some recursive calls. */
1683
1684 static void
1685 type_print_base (type, stream, show, level)
1686 struct type *type;
1687 FILE *stream;
1688 int show;
1689 int level;
1690 {
1691 char *name;
1692 register int i;
1693 register int len;
1694 register int lastval;
1695 char *mangled_name;
1696 char *demangled_name;
1697
1698 QUIT;
1699
1700 wrap_here (" ");
1701 if (type == NULL)
1702 {
1703 fputs_filtered ("<type unknown>", stream);
1704 return;
1705 }
1706
1707 /* When SHOW is zero or less, and there is a valid type name, then always
1708 just print the type name directly from the type. */
1709
1710 if ((show <= 0) && (TYPE_NAME (type) != NULL))
1711 {
1712 fputs_filtered (TYPE_NAME (type), stream);
1713 return;
1714 }
1715
1716 switch (TYPE_CODE (type))
1717 {
1718 case TYPE_CODE_ARRAY:
1719 case TYPE_CODE_PTR:
1720 case TYPE_CODE_MEMBER:
1721 case TYPE_CODE_REF:
1722 case TYPE_CODE_FUNC:
1723 case TYPE_CODE_METHOD:
1724 type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
1725 break;
1726
1727 case TYPE_CODE_STRUCT:
1728 fprintf_filtered (stream, "struct ");
1729 goto struct_union;
1730
1731 case TYPE_CODE_UNION:
1732 fprintf_filtered (stream, "union ");
1733 struct_union:
1734 if (name = type_name_no_tag (type))
1735 {
1736 fputs_filtered (name, stream);
1737 fputs_filtered (" ", stream);
1738 wrap_here (" ");
1739 }
1740 if (show < 0)
1741 fprintf_filtered (stream, "{...}");
1742 else
1743 {
1744 check_stub_type (type);
1745
1746 type_print_derivation_info (stream, type);
1747
1748 fprintf_filtered (stream, "{");
1749 len = TYPE_NFIELDS (type);
1750 if (len)
1751 fprintf_filtered (stream, "\n");
1752 else
1753 {
1754 if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
1755 fprintf_filtered (stream, "<incomplete type>\n");
1756 else
1757 fprintf_filtered (stream, "<no data fields>\n");
1758 }
1759
1760 /* If there is a base class for this type,
1761 do not print the field that it occupies. */
1762 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
1763 {
1764 QUIT;
1765 /* Don't print out virtual function table. */
1766 if ((TYPE_FIELD_NAME (type, i))[5] == CPLUS_MARKER &&
1767 !strncmp (TYPE_FIELD_NAME (type, i), "_vptr", 5))
1768 continue;
1769
1770 print_spaces_filtered (level + 4, stream);
1771 if (TYPE_FIELD_STATIC (type, i))
1772 {
1773 fprintf_filtered (stream, "static ");
1774 }
1775 type_print_1 (TYPE_FIELD_TYPE (type, i),
1776 TYPE_FIELD_NAME (type, i),
1777 stream, show - 1, level + 4);
1778 if (!TYPE_FIELD_STATIC (type, i)
1779 && TYPE_FIELD_PACKED (type, i))
1780 {
1781 /* It is a bitfield. This code does not attempt
1782 to look at the bitpos and reconstruct filler,
1783 unnamed fields. This would lead to misleading
1784 results if the compiler does not put out fields
1785 for such things (I don't know what it does). */
1786 fprintf_filtered (stream, " : %d",
1787 TYPE_FIELD_BITSIZE (type, i));
1788 }
1789 fprintf_filtered (stream, ";\n");
1790 }
1791
1792 /* C++: print out the methods */
1793 len = TYPE_NFN_FIELDS (type);
1794 if (len) fprintf_filtered (stream, "\n");
1795 for (i = 0; i < len; i++)
1796 {
1797 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1798 int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
1799 char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
1800 int is_constructor = name && strcmp(method_name, name) == 0;
1801 for (j = 0; j < len2; j++)
1802 {
1803 QUIT;
1804 print_spaces_filtered (level + 4, stream);
1805 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1806 fprintf_filtered (stream, "virtual ");
1807 else if (TYPE_FN_FIELD_STATIC_P (f, j))
1808 fprintf_filtered (stream, "static ");
1809 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
1810 {
1811 /* Keep GDB from crashing here. */
1812 fprintf (stream, "<undefined type> %s;\n",
1813 TYPE_FN_FIELD_PHYSNAME (f, j));
1814 break;
1815 }
1816 else if (!is_constructor)
1817 {
1818 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
1819 "", stream, 0);
1820 fputs_filtered (" ", stream);
1821 }
1822 if (TYPE_FN_FIELD_STUB (f, j))
1823 {
1824 /* Build something we can demangle. */
1825 mangled_name = gdb_mangle_name (type, i, j);
1826 demangled_name =
1827 cplus_demangle (mangled_name,
1828 DMGL_ANSI | DMGL_PARAMS);
1829 if (demangled_name == NULL)
1830 fprintf_filtered (stream, "<badly mangled name %s>",
1831 mangled_name);
1832 else
1833 {
1834 fprintf_filtered (stream, "%s",
1835 strchr (demangled_name, ':') + 2);
1836 free (demangled_name);
1837 }
1838 free (mangled_name);
1839 }
1840 else if (TYPE_FN_FIELD_PHYSNAME (f, j)[0] == '_'
1841 && TYPE_FN_FIELD_PHYSNAME (f, j)[1] == CPLUS_MARKER)
1842 type_print_method_args
1843 (TYPE_FN_FIELD_ARGS (f, j) + 1, "~",
1844 method_name, 0, stream);
1845 else
1846 type_print_method_args
1847 (TYPE_FN_FIELD_ARGS (f, j), "",
1848 method_name,
1849 TYPE_FN_FIELD_STATIC_P (f, j), stream);
1850
1851 fprintf_filtered (stream, ";\n");
1852 }
1853 }
1854
1855 print_spaces_filtered (level, stream);
1856 fprintf_filtered (stream, "}");
1857 }
1858 break;
1859
1860 case TYPE_CODE_ENUM:
1861 fprintf_filtered (stream, "enum ");
1862 if (name = type_name_no_tag (type))
1863 {
1864 fputs_filtered (name, stream);
1865 fputs_filtered (" ", stream);
1866 }
1867 wrap_here (" ");
1868 if (show < 0)
1869 fprintf_filtered (stream, "{...}");
1870 else
1871 {
1872 fprintf_filtered (stream, "{");
1873 len = TYPE_NFIELDS (type);
1874 lastval = 0;
1875 for (i = 0; i < len; i++)
1876 {
1877 QUIT;
1878 if (i) fprintf_filtered (stream, ", ");
1879 wrap_here (" ");
1880 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1881 if (lastval != TYPE_FIELD_BITPOS (type, i))
1882 {
1883 fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
1884 lastval = TYPE_FIELD_BITPOS (type, i);
1885 }
1886 lastval++;
1887 }
1888 fprintf_filtered (stream, "}");
1889 }
1890 break;
1891
1892 case TYPE_CODE_VOID:
1893 fprintf_filtered (stream, "void");
1894 break;
1895
1896 case TYPE_CODE_UNDEF:
1897 fprintf_filtered (stream, "struct <unknown>");
1898 break;
1899
1900 case TYPE_CODE_ERROR:
1901 fprintf_filtered (stream, "<unknown type>");
1902 break;
1903
1904 case TYPE_CODE_RANGE:
1905 /* This should not occur */
1906 fprintf_filtered (stream, "<range type>");
1907 break;
1908
1909 default:
1910 /* Handle types not explicitly handled by the other cases,
1911 such as fundamental types. For these, just print whatever
1912 the type name is, as recorded in the type itself. If there
1913 is no type name, then complain. */
1914 if (TYPE_NAME (type) != NULL)
1915 {
1916 fputs_filtered (TYPE_NAME (type), stream);
1917 }
1918 else
1919 {
1920 error ("Invalid type code (%d) in symbol table.", TYPE_CODE (type));
1921 }
1922 break;
1923 }
1924 }
1925 \f
1926 #if 0
1927 /* Validate an input or output radix setting, and make sure the user
1928 knows what they really did here. Radix setting is confusing, e.g.
1929 setting the input radix to "10" never changes it! */
1930
1931 /* ARGSUSED */
1932 static void
1933 set_input_radix (args, from_tty, c)
1934 char *args;
1935 int from_tty;
1936 struct cmd_list_element *c;
1937 {
1938 unsigned radix = *(unsigned *)c->var;
1939
1940 if (from_tty)
1941 printf_filtered ("Input radix set to decimal %d, hex %x, octal %o\n",
1942 radix, radix, radix);
1943 }
1944 #endif
1945
1946 /* ARGSUSED */
1947 static void
1948 set_output_radix (args, from_tty, c)
1949 char *args;
1950 int from_tty;
1951 struct cmd_list_element *c;
1952 {
1953 unsigned radix = *(unsigned *)c->var;
1954
1955 if (from_tty)
1956 printf_filtered ("Output radix set to decimal %d, hex %x, octal %o\n",
1957 radix, radix, radix);
1958
1959 /* FIXME, we really should be able to validate the setting BEFORE
1960 it takes effect. */
1961 switch (radix)
1962 {
1963 case 16:
1964 output_format = 'x';
1965 break;
1966 case 10:
1967 output_format = 0;
1968 break;
1969 case 8:
1970 output_format = 'o'; /* octal */
1971 break;
1972 default:
1973 output_format = 0;
1974 error ("Unsupported radix ``decimal %d''; using decimal output",
1975 radix);
1976 }
1977 }
1978
1979 /* Both at once */
1980 static void
1981 set_radix (arg, from_tty, c)
1982 char *arg;
1983 int from_tty;
1984 struct cmd_list_element *c;
1985 {
1986 unsigned radix = *(unsigned *)c->var;
1987
1988 if (from_tty)
1989 printf_filtered ("Radix set to decimal %d, hex %x, octal %o\n",
1990 radix, radix, radix);
1991
1992 input_radix = radix;
1993 output_radix = radix;
1994
1995 set_output_radix (arg, 0, c);
1996 }
1997 \f
1998 struct cmd_list_element *setprintlist = NULL;
1999 struct cmd_list_element *showprintlist = NULL;
2000
2001 /*ARGSUSED*/
2002 static void
2003 set_print (arg, from_tty)
2004 char *arg;
2005 int from_tty;
2006 {
2007 printf (
2008 "\"set print\" must be followed by the name of a print subcommand.\n");
2009 help_list (setprintlist, "set print ", -1, stdout);
2010 }
2011
2012 /*ARGSUSED*/
2013 static void
2014 show_print (args, from_tty)
2015 char *args;
2016 int from_tty;
2017 {
2018 cmd_show_list (showprintlist, from_tty, "");
2019 }
2020 \f
2021 void
2022 _initialize_valprint ()
2023 {
2024 struct cmd_list_element *c;
2025
2026 add_prefix_cmd ("print", no_class, set_print,
2027 "Generic command for setting how things print.",
2028 &setprintlist, "set print ", 0, &setlist);
2029 add_alias_cmd ("p", "print", no_class, 1, &setlist);
2030 add_alias_cmd ("pr", "print", no_class, 1, &setlist); /* prefer set print
2031 to set prompt */
2032 add_prefix_cmd ("print", no_class, show_print,
2033 "Generic command for showing print settings.",
2034 &showprintlist, "show print ", 0, &showlist);
2035 add_alias_cmd ("p", "print", no_class, 1, &showlist);
2036 add_alias_cmd ("pr", "print", no_class, 1, &showlist);
2037
2038 add_show_from_set
2039 (add_set_cmd ("elements", no_class, var_uinteger, (char *)&print_max,
2040 "Set limit on string chars or array elements to print.\n\
2041 \"set print elements 0\" causes there to be no limit.",
2042 &setprintlist),
2043 &showprintlist);
2044
2045 add_show_from_set
2046 (add_set_cmd ("pretty", class_support, var_boolean, (char *)&prettyprint,
2047 "Set prettyprinting of structures.",
2048 &setprintlist),
2049 &showprintlist);
2050
2051 add_show_from_set
2052 (add_set_cmd ("union", class_support, var_boolean, (char *)&unionprint,
2053 "Set printing of unions interior to structures.",
2054 &setprintlist),
2055 &showprintlist);
2056
2057 add_show_from_set
2058 (add_set_cmd ("vtbl", class_support, var_boolean, (char *)&vtblprint,
2059 "Set printing of C++ virtual function tables.",
2060 &setprintlist),
2061 &showprintlist);
2062
2063 add_show_from_set
2064 (add_set_cmd ("array", class_support, var_boolean, (char *)&arrayprint,
2065 "Set prettyprinting of arrays.",
2066 &setprintlist),
2067 &showprintlist);
2068
2069 add_show_from_set
2070 (add_set_cmd ("object", class_support, var_boolean, (char *)&objectprint,
2071 "Set printing of object's derived type based on vtable info.",
2072 &setprintlist),
2073 &showprintlist);
2074
2075 add_show_from_set
2076 (add_set_cmd ("address", class_support, var_boolean, (char *)&addressprint,
2077 "Set printing of addresses.",
2078 &setprintlist),
2079 &showprintlist);
2080
2081 #if 0
2082 /* The "show radix" cmd isn't good enough to show two separate values.
2083 The rest of the code works, but the show part is confusing, so don't
2084 let them be set separately 'til we work out "show". */
2085 c = add_set_cmd ("input-radix", class_support, var_uinteger,
2086 (char *)&input_radix,
2087 "Set default input radix for entering numbers.",
2088 &setlist);
2089 add_show_from_set (c, &showlist);
2090 c->function = set_input_radix;
2091
2092 c = add_set_cmd ("output-radix", class_support, var_uinteger,
2093 (char *)&output_radix,
2094 "Set default output radix for printing of values.",
2095 &setlist);
2096 add_show_from_set (c, &showlist);
2097 c->function = set_output_radix;
2098 #endif
2099
2100 c = add_set_cmd ("radix", class_support, var_uinteger,
2101 (char *)&output_radix,
2102 "Set default input and output number radix.",
2103 &setlist);
2104 add_show_from_set (c, &showlist);
2105 c->function.sfunc = set_radix;
2106
2107 /* Give people the defaults which they are used to. */
2108 prettyprint = 0;
2109 unionprint = 1;
2110 vtblprint = 0;
2111 arrayprint = 0;
2112 addressprint = 1;
2113 objectprint = 0;
2114
2115 print_max = 200;
2116
2117 obstack_begin (&dont_print_obstack, 32 * sizeof (struct type *));
2118 }
GDB Binutils - Deliverables
This page took 0.074887 seconds and 4 git commands to generate.