projects / deliverable / binutils-gdb.git / blob
? search:


6492f1dc20a76322b51ae5cfff6f62f6d143e665
[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));
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 fprintf_filtered (stream, "\n");
517 print_spaces_filtered (2 + 2 * recurse, stream);
518 fputs_filtered ("members of ", stream);
519 fputs_filtered (type_name_no_tag (type), stream);
520 fputs_filtered (": ", stream);
521 }
522 fields_seen = 1;
523
524 if (pretty)
525 {
526 fprintf_filtered (stream, "\n");
527 print_spaces_filtered (2 + 2 * recurse, stream);
528 }
529 else
530 {
531 wrap_here (n_spaces (2 + 2 * recurse));
532 }
533 if (inspect_it)
534 {
535 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
536 fputs_filtered ("\"( ptr \"", stream);
537 else
538 fputs_filtered ("\"( nodef \"", stream);
539 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
540 fputs_filtered ("\" \"", stream);
541 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
542 fputs_filtered ("\") \"", stream);
543 }
544 else
545 {
546 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
547 fputs_filtered (" = ", stream);
548 }
549 if (TYPE_FIELD_PACKED (type, i))
550 {
551 value v;
552
553 /* Bitfields require special handling, especially due to byte
554 order problems. */
555 v = value_from_longest (TYPE_FIELD_TYPE (type, i),
556 unpack_field_as_long (type, valaddr, i));
557
558 val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0,
559 stream, format, 0, recurse + 1, pretty);
560 }
561 else
562 {
563 val_print (TYPE_FIELD_TYPE (type, i),
564 valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
565 0, stream, format, 0, recurse + 1, pretty);
566 }
567 }
568 if (pretty)
569 {
570 fprintf_filtered (stream, "\n");
571 print_spaces_filtered (2 * recurse, stream);
572 }
573 }
574 fprintf_filtered (stream, "}");
575 }
576
577 /* Special val_print routine to avoid printing multiple copies of virtual
578 baseclasses. */
579
580 static void
581 cplus_val_print (type, valaddr, stream, format, recurse, pretty, dont_print)
582 struct type *type;
583 char *valaddr;
584 FILE *stream;
585 int format;
586 int recurse;
587 enum val_prettyprint pretty;
588 struct type **dont_print;
589 {
590 struct obstack tmp_obstack;
591 struct type **last_dont_print
592 = (struct type **)obstack_next_free (&dont_print_obstack);
593 int i, n_baseclasses = TYPE_N_BASECLASSES (type);
594
595 if (dont_print == 0)
596 {
597 /* If we're at top level, carve out a completely fresh
598 chunk of the obstack and use that until this particular
599 invocation returns. */
600 tmp_obstack = dont_print_obstack;
601 /* Bump up the high-water mark. Now alpha is omega. */
602 obstack_finish (&dont_print_obstack);
603 }
604
605 for (i = 0; i < n_baseclasses; i++)
606 {
607 char *baddr;
608 int err;
609
610 if (BASETYPE_VIA_VIRTUAL (type, i))
611 {
612 struct type **first_dont_print
613 = (struct type **)obstack_base (&dont_print_obstack);
614
615 int j = (struct type **)obstack_next_free (&dont_print_obstack)
616 - first_dont_print;
617
618 while (--j >= 0)
619 if (TYPE_BASECLASS (type, i) == first_dont_print[j])
620 goto flush_it;
621
622 obstack_ptr_grow (&dont_print_obstack, TYPE_BASECLASS (type, i));
623 }
624
625 baddr = baseclass_addr (type, i, valaddr, 0, &err);
626 if (err == 0 && baddr == 0)
627 error ("could not find virtual baseclass `%s'\n",
628 type_name_no_tag (TYPE_BASECLASS (type, i)));
629
630 fprintf_filtered (stream, "\n");
631 if (pretty)
632 print_spaces_filtered (2 + 2 * recurse, stream);
633 fputs_filtered ("<", stream);
634 fputs_filtered (type_name_no_tag (TYPE_BASECLASS (type, i)), stream);
635 fputs_filtered ("> = ", stream);
636 if (err != 0)
637 fprintf_filtered (stream, "<invalid address 0x%x>", baddr);
638 else
639 val_print_fields (TYPE_BASECLASS (type, i), baddr, stream, format,
640 recurse, pretty,
641 (struct type **)obstack_base (&dont_print_obstack));
642 flush_it:
643 ;
644 }
645
646 if (dont_print == 0)
647 {
648 /* Free the space used to deal with the printing
649 of this type from top level. */
650 obstack_free (&dont_print_obstack, last_dont_print);
651 /* Reset watermark so that we can continue protecting
652 ourselves from whatever we were protecting ourselves. */
653 dont_print_obstack = tmp_obstack;
654 }
655 }
656
657 static void
658 print_class_member (valaddr, domain, stream, prefix)
659 char *valaddr;
660 struct type *domain;
661 FILE *stream;
662 char *prefix;
663 {
664
665 /* VAL is a byte offset into the structure type DOMAIN.
666 Find the name of the field for that offset and
667 print it. */
668 int extra = 0;
669 int bits = 0;
670 register unsigned int i;
671 unsigned len = TYPE_NFIELDS (domain);
672 /* @@ Make VAL into bit offset */
673 LONGEST val = unpack_long (builtin_type_int, valaddr) << 3;
674 for (i = TYPE_N_BASECLASSES (domain); i < len; i++)
675 {
676 int bitpos = TYPE_FIELD_BITPOS (domain, i);
677 QUIT;
678 if (val == bitpos)
679 break;
680 if (val < bitpos && i != 0)
681 {
682 /* Somehow pointing into a field. */
683 i -= 1;
684 extra = (val - TYPE_FIELD_BITPOS (domain, i));
685 if (extra & 0x7)
686 bits = 1;
687 else
688 extra >>= 3;
689 break;
690 }
691 }
692 if (i < len)
693 {
694 char *name;
695 fprintf_filtered (stream, prefix);
696 name = type_name_no_tag (domain);
697 if (name)
698 fputs_filtered (name, stream);
699 else
700 type_print_base (domain, stream, 0, 0);
701 fprintf_filtered (stream, "::");
702 fputs_filtered (TYPE_FIELD_NAME (domain, i), stream);
703 if (extra)
704 fprintf_filtered (stream, " + %d bytes", extra);
705 if (bits)
706 fprintf_filtered (stream, " (offset in bits)");
707 }
708 else
709 fprintf_filtered (stream, "%d", val >> 3);
710 }
711
712 /* Print data of type TYPE located at VALADDR (within GDB),
713 which came from the inferior at address ADDRESS,
714 onto stdio stream STREAM according to FORMAT
715 (a letter or 0 for natural format). The data at VALADDR
716 is in target byte order.
717
718 If the data are a string pointer, returns the number of
719 sting characters printed.
720
721 if DEREF_REF is nonzero, then dereference references,
722 otherwise just print them like pointers.
723
724 The PRETTY parameter controls prettyprinting. */
725
726 int
727 val_print (type, valaddr, address, stream, format, deref_ref, recurse, pretty)
728 struct type *type;
729 char *valaddr;
730 CORE_ADDR address;
731 FILE *stream;
732 int format;
733 int deref_ref;
734 int recurse;
735 enum val_prettyprint pretty;
736 {
737 register unsigned int i;
738 unsigned len;
739 struct type *elttype;
740 unsigned eltlen;
741 LONGEST val;
742 unsigned char c;
743
744 if (pretty == Val_pretty_default)
745 {
746 pretty = prettyprint ? Val_prettyprint : Val_no_prettyprint;
747 }
748
749 QUIT;
750
751 check_stub_type (type);
752
753 if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
754 {
755 fprintf_filtered (stream, "<unknown struct>");
756 fflush (stream);
757 return 0;
758 }
759
760 switch (TYPE_CODE (type))
761 {
762 case TYPE_CODE_ARRAY:
763 if (TYPE_LENGTH (type) > 0
764 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
765 {
766 elttype = TYPE_TARGET_TYPE (type);
767 eltlen = TYPE_LENGTH (elttype);
768 len = TYPE_LENGTH (type) / eltlen;
769 if (arrayprint)
770 print_spaces_filtered (2 + 2 * recurse, stream);
771 fprintf_filtered (stream, "{");
772 /* For an array of chars, print with string syntax. */
773 if (eltlen == 1 && TYPE_CODE (elttype) == TYPE_CODE_INT
774 && (format == 0 || format == 's') )
775 print_string (stream, valaddr, len, 0);
776 else
777 {
778 unsigned int things_printed = 0;
779
780 /* If this is a virtual function table, print the 0th
781 entry specially, and the rest of the members normally. */
782 if (is_vtbl_ptr_type (elttype))
783 {
784 fprintf_filtered (stream, "%d vtable entries", len-1);
785 i = 1;
786 }
787 else
788 i = 0;
789
790 for (; i < len && things_printed < print_max; i++)
791 {
792 /* Position of the array element we are examining to see
793 whether it is repeated. */
794 unsigned int rep1;
795 /* Number of repetitions we have detected so far. */
796 unsigned int reps;
797
798 if (i != 0)
799 if (arrayprint)
800 {
801 fprintf_filtered (stream, ",\n");
802 print_spaces_filtered (2 + 2 * recurse, stream);
803 }
804 else
805 fprintf_filtered (stream, ", ");
806 wrap_here (n_spaces (2 + 2 * recurse));
807
808 rep1 = i + 1;
809 reps = 1;
810 while (rep1 < len
811 && !bcmp (valaddr + i * eltlen,
812 valaddr + rep1 * eltlen, eltlen))
813 {
814 ++reps;
815 ++rep1;
816 }
817
818 if (reps > REPEAT_COUNT_THRESHOLD)
819 {
820 val_print (elttype, valaddr + i * eltlen,
821 0, stream, format, deref_ref,
822 recurse + 1, pretty);
823 fprintf_filtered (stream, " <repeats %u times>", reps);
824 i = rep1 - 1;
825 things_printed += REPEAT_COUNT_THRESHOLD;
826 }
827 else
828 {
829 val_print (elttype, valaddr + i * eltlen,
830 0, stream, format, deref_ref,
831 recurse + 1, pretty);
832 things_printed++;
833 }
834 }
835 if (i < len)
836 fprintf_filtered (stream, "...");
837 }
838 fprintf_filtered (stream, "}");
839 break;
840 }
841 /* Array of unspecified length: treat like pointer to first elt. */
842 valaddr = (char *) &address;
843
844 case TYPE_CODE_PTR:
845 if (format && format != 's')
846 {
847 print_scalar_formatted (valaddr, type, format, 0, stream);
848 break;
849 }
850 if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_METHOD)
851 {
852 struct type *domain = TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type));
853 struct fn_field *f;
854 int j, len2;
855 char *kind = "";
856 CORE_ADDR addr;
857
858 addr = unpack_pointer (lookup_pointer_type (builtin_type_void),
859 valaddr);
860 if (addr < 128) /* FIXME! What is this 128? */
861 {
862 len = TYPE_NFN_FIELDS (domain);
863 for (i = 0; i < len; i++)
864 {
865 f = TYPE_FN_FIELDLIST1 (domain, i);
866 len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
867
868 for (j = 0; j < len2; j++)
869 {
870 QUIT;
871 if (TYPE_FN_FIELD_VOFFSET (f, j) == addr)
872 {
873 kind = "virtual";
874 goto common;
875 }
876 }
877 }
878 }
879 else
880 {
881 struct symbol *sym = find_pc_function (addr);
882 if (sym == 0)
883 error ("invalid pointer to member function");
884 len = TYPE_NFN_FIELDS (domain);
885 for (i = 0; i < len; i++)
886 {
887 f = TYPE_FN_FIELDLIST1 (domain, i);
888 len2 = TYPE_FN_FIELDLIST_LENGTH (domain, i);
889
890 for (j = 0; j < len2; j++)
891 {
892 QUIT;
893 if (!strcmp (SYMBOL_NAME (sym), TYPE_FN_FIELD_PHYSNAME (f, j)))
894 goto common;
895 }
896 }
897 }
898 common:
899 if (i < len)
900 {
901 fprintf_filtered (stream, "&");
902 type_print_varspec_prefix (TYPE_FN_FIELD_TYPE (f, j), stream, 0, 0);
903 fprintf (stream, kind);
904 if (TYPE_FN_FIELD_PHYSNAME (f, j)[0] == '_'
905 && TYPE_FN_FIELD_PHYSNAME (f, j)[1] == CPLUS_MARKER)
906 type_print_method_args
907 (TYPE_FN_FIELD_ARGS (f, j) + 1, "~",
908 TYPE_FN_FIELDLIST_NAME (domain, i), 0, stream);
909 else
910 type_print_method_args
911 (TYPE_FN_FIELD_ARGS (f, j), "",
912 TYPE_FN_FIELDLIST_NAME (domain, i), 0, stream);
913 break;
914 }
915 fprintf_filtered (stream, "(");
916 type_print (type, "", stream, -1);
917 fprintf_filtered (stream, ") %d", (int) addr >> 3);
918 }
919 else if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_MEMBER)
920 {
921 print_class_member (valaddr,
922 TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type)),
923 stream, "&");
924 }
925 else
926 {
927 CORE_ADDR addr = unpack_pointer (type, valaddr);
928 elttype = TYPE_TARGET_TYPE (type);
929
930 if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
931 {
932 /* Try to print what function it points to. */
933 print_address_demangle (addr, stream, demangle);
934 /* Return value is irrelevant except for string pointers. */
935 return 0;
936 }
937
938 if (addressprint && format != 's')
939 fprintf_filtered (stream, "0x%x", addr);
940
941 /* For a pointer to char or unsigned char,
942 also print the string pointed to, unless pointer is null. */
943 i = 0; /* Number of characters printed. */
944 if (TYPE_LENGTH (elttype) == 1
945 && TYPE_CODE (elttype) == TYPE_CODE_INT
946 && (format == 0 || format == 's')
947 && addr != 0
948 /* If print_max is UINT_MAX, the alloca below will fail.
949 In that case don't try to print the string. */
950 && print_max < UINT_MAX)
951 {
952 int first_addr_err = 0;
953 int errcode = 0;
954
955 /* Get first character. */
956 errcode = target_read_memory (addr, (char *)&c, 1);
957 if (errcode != 0)
958 {
959 /* First address out of bounds. */
960 first_addr_err = 1;
961 }
962 else
963 {
964 /* A real string. */
965 char *string = (char *) alloca (print_max);
966
967 /* If the loop ends by us hitting print_max characters,
968 we need to have elipses at the end. */
969 int force_ellipses = 1;
970
971 /* This loop always fetches print_max characters, even
972 though print_string might want to print more or fewer
973 (with repeated characters). This is so that
974 we don't spend forever fetching if we print
975 a long string consisting of the same character
976 repeated. Also so we can do it all in one memory
977 operation, which is faster. However, this will be
978 slower if print_max is set high, e.g. if you set
979 print_max to 1000, not only will it take a long
980 time to fetch short strings, but if you are near
981 the end of the address space, it might not work. */
982 QUIT;
983 errcode = target_read_memory (addr, string, print_max);
984 if (errcode != 0)
985 {
986 /* Try reading just one character. If that succeeds,
987 assume we hit the end of the address space, but
988 the initial part of the string is probably safe. */
989 char x[1];
990 errcode = target_read_memory (addr, x, 1);
991 }
992 if (errcode != 0)
993 force_ellipses = 0;
994 else
995 for (i = 0; i < print_max; i++)
996 if (string[i] == '\0')
997 {
998 force_ellipses = 0;
999 break;
1000 }
1001 QUIT;
1002
1003 if (addressprint)
1004 fputs_filtered (" ", stream);
1005 print_string (stream, string, i, force_ellipses);
1006 }
1007
1008 if (errcode != 0)
1009 {
1010 if (errcode == EIO)
1011 {
1012 fprintf_filtered (stream,
1013 (" <Address 0x%x out of bounds>"
1014 + first_addr_err),
1015 addr + i);
1016 }
1017 else
1018 {
1019 error ("Error reading memory address 0x%x: %s.",
1020 addr + i, safe_strerror (errcode));
1021 }
1022 }
1023
1024 fflush (stream);
1025 }
1026 else /* print vtbl's nicely */
1027 if (is_vtbl_member(type))
1028 {
1029 CORE_ADDR vt_address = unpack_pointer (type, valaddr);
1030
1031 struct minimal_symbol *msymbol =
1032 lookup_minimal_symbol_by_pc (vt_address);
1033 if ((msymbol != NULL) && (vt_address == msymbol -> address))
1034 {
1035 fputs_filtered (" <", stream);
1036 fputs_demangled (msymbol -> name, stream,
1037 DMGL_ANSI | DMGL_PARAMS);
1038 fputs_filtered (">", stream);
1039 }
1040 if (vtblprint)
1041 {
1042 value vt_val;
1043
1044 vt_val = value_at (TYPE_TARGET_TYPE (type), vt_address);
1045 val_print (VALUE_TYPE (vt_val), VALUE_CONTENTS (vt_val),
1046 VALUE_ADDRESS (vt_val), stream, format,
1047 deref_ref, recurse + 1, pretty);
1048 if (pretty)
1049 {
1050 fprintf_filtered (stream, "\n");
1051 print_spaces_filtered (2 + 2 * recurse, stream);
1052 }
1053 }
1054 }
1055
1056 /* Return number of characters printed, plus one for the
1057 terminating null if we have "reached the end". */
1058 return i + (print_max && i != print_max);
1059 }
1060 break;
1061
1062 case TYPE_CODE_MEMBER:
1063 error ("not implemented: member type in val_print");
1064 break;
1065
1066 case TYPE_CODE_REF:
1067 if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_MEMBER)
1068 {
1069 print_class_member (valaddr,
1070 TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type)),
1071 stream, "");
1072 break;
1073 }
1074 if (addressprint)
1075 {
1076 fprintf_filtered (stream, "@0x%lx",
1077 unpack_long (builtin_type_int, valaddr));
1078 if (deref_ref)
1079 fputs_filtered (": ", stream);
1080 }
1081 /* De-reference the reference. */
1082 if (deref_ref)
1083 {
1084 if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_UNDEF)
1085 {
1086 value deref_val =
1087 value_at
1088 (TYPE_TARGET_TYPE (type),
1089 unpack_pointer (lookup_pointer_type (builtin_type_void),
1090 valaddr));
1091 val_print (VALUE_TYPE (deref_val), VALUE_CONTENTS (deref_val),
1092 VALUE_ADDRESS (deref_val), stream, format,
1093 deref_ref, recurse + 1, pretty);
1094 }
1095 else
1096 fputs_filtered ("???", stream);
1097 }
1098 break;
1099
1100 case TYPE_CODE_UNION:
1101 if (recurse && !unionprint)
1102 {
1103 fprintf_filtered (stream, "{...}");
1104 break;
1105 }
1106 /* Fall through. */
1107 case TYPE_CODE_STRUCT:
1108 if (vtblprint && is_vtbl_ptr_type(type))
1109 {
1110 /* Print the unmangled name if desired. */
1111 print_address_demangle(*((int *) (valaddr + /* FIXME bytesex */
1112 TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8)),
1113 stream, demangle);
1114 break;
1115 }
1116 val_print_fields (type, valaddr, stream, format, recurse, pretty, 0);
1117 break;
1118
1119 case TYPE_CODE_ENUM:
1120 if (format)
1121 {
1122 print_scalar_formatted (valaddr, type, format, 0, stream);
1123 break;
1124 }
1125 len = TYPE_NFIELDS (type);
1126 val = unpack_long (builtin_type_int, valaddr);
1127 for (i = 0; i < len; i++)
1128 {
1129 QUIT;
1130 if (val == TYPE_FIELD_BITPOS (type, i))
1131 break;
1132 }
1133 if (i < len)
1134 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1135 else
1136 #ifdef LONG_LONG
1137 fprintf_filtered (stream, "%lld", val);
1138 #else
1139 fprintf_filtered (stream, "%ld", val);
1140 #endif
1141 break;
1142
1143 case TYPE_CODE_FUNC:
1144 if (format)
1145 {
1146 print_scalar_formatted (valaddr, type, format, 0, stream);
1147 break;
1148 }
1149 /* FIXME, we should consider, at least for ANSI C language, eliminating
1150 the distinction made between FUNCs and POINTERs to FUNCs. */
1151 fprintf_filtered (stream, "{");
1152 type_print (type, "", stream, -1);
1153 fprintf_filtered (stream, "} ");
1154 /* Try to print what function it points to, and its address. */
1155 print_address_demangle (address, stream, demangle);
1156 break;
1157
1158 case TYPE_CODE_INT:
1159 if (format || output_format)
1160 {
1161 print_scalar_formatted (valaddr, type,
1162 format? format: output_format,
1163 0, stream);
1164 break;
1165 }
1166 if (TYPE_LENGTH (type) > sizeof (LONGEST))
1167 {
1168 if (TYPE_UNSIGNED (type))
1169 {
1170 /* First figure out whether the number in fact has zeros
1171 in all its bytes more significant than least significant
1172 sizeof (LONGEST) ones. */
1173 char *p;
1174 /* Pointer to first (i.e. lowest address) nonzero character. */
1175 char *first_addr;
1176 len = TYPE_LENGTH (type);
1177
1178 #if TARGET_BYTE_ORDER == BIG_ENDIAN
1179 for (p = valaddr;
1180 len > sizeof (LONGEST)
1181 && p < valaddr + TYPE_LENGTH (type);
1182 p++)
1183 #else /* Little endian. */
1184 first_addr = valaddr;
1185 for (p = valaddr + TYPE_LENGTH (type);
1186 len > sizeof (LONGEST) && p >= valaddr;
1187 p--)
1188 #endif /* Little endian. */
1189 {
1190 if (*p == 0)
1191 len--;
1192 else
1193 break;
1194 }
1195 #if TARGET_BYTE_ORDER == BIG_ENDIAN
1196 first_addr = p;
1197 #endif
1198
1199 if (len <= sizeof (LONGEST))
1200 {
1201 /* We can print it in decimal. */
1202 fprintf_filtered
1203 (stream,
1204 #if defined (LONG_LONG)
1205 "%llu",
1206 #else
1207 "%lu",
1208 #endif
1209 unpack_long (BUILTIN_TYPE_LONGEST, first_addr));
1210 }
1211 else
1212 {
1213 /* It is big, so print it in hex. */
1214 print_hex_chars (stream, (unsigned char *)first_addr, len);
1215 }
1216 }
1217 else
1218 {
1219 /* Signed. One could assume two's complement (a reasonable
1220 assumption, I think) and do better than this. */
1221 print_hex_chars (stream, (unsigned char *)valaddr,
1222 TYPE_LENGTH (type));
1223 }
1224 break;
1225 }
1226 #ifdef PRINT_TYPELESS_INTEGER
1227 PRINT_TYPELESS_INTEGER (stream, type, unpack_long (type, valaddr));
1228 #else
1229 #ifndef LONG_LONG
1230 fprintf_filtered (stream,
1231 TYPE_UNSIGNED (type) ? "%u" : "%d",
1232 unpack_long (type, valaddr));
1233 #else
1234 fprintf_filtered (stream,
1235 TYPE_UNSIGNED (type) ? "%llu" : "%lld",
1236 unpack_long (type, valaddr));
1237 #endif
1238 #endif
1239
1240 if (TYPE_LENGTH (type) == 1)
1241 {
1242 fprintf_filtered (stream, " '");
1243 printchar ((unsigned char) unpack_long (type, valaddr),
1244 stream, '\'');
1245 fprintf_filtered (stream, "'");
1246 }
1247 break;
1248
1249 case TYPE_CODE_FLT:
1250 if (format)
1251 print_scalar_formatted (valaddr, type, format, 0, stream);
1252 else
1253 print_floating (valaddr, type, stream);
1254 break;
1255
1256 case TYPE_CODE_VOID:
1257 fprintf_filtered (stream, "void");
1258 break;
1259
1260 case TYPE_CODE_UNDEF:
1261 /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
1262 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
1263 and no complete type for struct foo in that file. */
1264 fprintf_filtered (stream, "<unknown struct>");
1265 break;
1266
1267 case TYPE_CODE_ERROR:
1268 fprintf_filtered (stream, "?");
1269 break;
1270
1271 case TYPE_CODE_RANGE:
1272 /* FIXME, we should not ever have to print one of these yet. */
1273 fprintf_filtered (stream, "<range type>");
1274 break;
1275
1276 default:
1277 error ("Invalid type code in symbol table.");
1278 }
1279 fflush (stream);
1280 return 0;
1281 }
1282 \f
1283 /* Print a description of a type in the format of a
1284 typedef for the current language.
1285 NEW is the new name for a type TYPE. */
1286 void
1287 typedef_print (type, new, stream)
1288 struct type *type;
1289 struct symbol *new;
1290 FILE *stream;
1291 {
1292 switch (current_language->la_language)
1293 {
1294 #ifdef _LANG_c
1295 case language_c:
1296 case language_cplus:
1297 fprintf_filtered(stream, "typedef ");
1298 type_print(type,"",stream,0);
1299 if(TYPE_NAME ((SYMBOL_TYPE (new))) == 0
1300 || 0 != strcmp (TYPE_NAME ((SYMBOL_TYPE (new))),
1301 SYMBOL_NAME (new)))
1302 fprintf_filtered(stream, " %s", SYMBOL_NAME(new));
1303 break;
1304 #endif
1305 #ifdef _LANG_m2
1306 case language_m2:
1307 fprintf_filtered(stream, "TYPE ");
1308 if(!TYPE_NAME(SYMBOL_TYPE(new)) ||
1309 strcmp (TYPE_NAME(SYMBOL_TYPE(new)),
1310 SYMBOL_NAME(new)))
1311 fprintf_filtered(stream, "%s = ", SYMBOL_NAME(new));
1312 else
1313 fprintf_filtered(stream, "<builtin> = ");
1314 type_print(type,"",stream,0);
1315 break;
1316 #endif
1317 default:
1318 error("Language not supported.");
1319 }
1320 fprintf_filtered(stream, ";\n");
1321 }
1322
1323
1324 /* Print a description of a type TYPE
1325 in the form of a declaration of a variable named VARSTRING.
1326 (VARSTRING is demangled if necessary.)
1327 Output goes to STREAM (via stdio).
1328 If SHOW is positive, we show the contents of the outermost level
1329 of structure even if there is a type name that could be used instead.
1330 If SHOW is negative, we never show the details of elements' types. */
1331
1332 void
1333 type_print (type, varstring, stream, show)
1334 struct type *type;
1335 char *varstring;
1336 FILE *stream;
1337 int show;
1338 {
1339 type_print_1 (type, varstring, stream, show, 0);
1340 }
1341
1342 /* LEVEL is the depth to indent lines by. */
1343
1344 void
1345 type_print_1 (type, varstring, stream, show, level)
1346 struct type *type;
1347 char *varstring;
1348 FILE *stream;
1349 int show;
1350 int level;
1351 {
1352 register enum type_code code;
1353 type_print_base (type, stream, show, level);
1354 code = TYPE_CODE (type);
1355 if ((varstring && *varstring)
1356 ||
1357 /* Need a space if going to print stars or brackets;
1358 but not if we will print just a type name. */
1359 ((show > 0 || TYPE_NAME (type) == 0)
1360 &&
1361 (code == TYPE_CODE_PTR || code == TYPE_CODE_FUNC
1362 || code == TYPE_CODE_METHOD
1363 || code == TYPE_CODE_ARRAY
1364 || code == TYPE_CODE_MEMBER
1365 || code == TYPE_CODE_REF)))
1366 fprintf_filtered (stream, " ");
1367 type_print_varspec_prefix (type, stream, show, 0);
1368 /* FIXME: Previously this printed demangled names without function args,
1369 which is a lose since you can't distinguish between overloaded function
1370 names (try "info func" for example). This change is still not optimal,
1371 since you now get a superflous pair of parens for functions, but at
1372 least you can distinguish them. */
1373 fputs_demangled (varstring, stream, DMGL_PARAMS);
1374 type_print_varspec_suffix (type, stream, show, 0);
1375 }
1376
1377 /* Print the method arguments ARGS to the file STREAM. */
1378 static void
1379 type_print_method_args (args, prefix, varstring, staticp, stream)
1380 struct type **args;
1381 char *prefix, *varstring;
1382 int staticp;
1383 FILE *stream;
1384 {
1385 int i;
1386
1387 fputs_demangled (prefix, stream, DMGL_ANSI | DMGL_PARAMS);
1388 fputs_demangled (varstring, stream, DMGL_ANSI | DMGL_PARAMS);
1389 fputs_filtered (" (", stream);
1390 if (args && args[!staticp] && args[!staticp]->code != TYPE_CODE_VOID)
1391 {
1392 i = !staticp; /* skip the class variable */
1393 while (1)
1394 {
1395 type_print (args[i++], "", stream, 0);
1396 if (!args[i])
1397 {
1398 fprintf_filtered (stream, " ...");
1399 break;
1400 }
1401 else if (args[i]->code != TYPE_CODE_VOID)
1402 {
1403 fprintf_filtered (stream, ", ");
1404 }
1405 else break;
1406 }
1407 }
1408 fprintf_filtered (stream, ")");
1409 }
1410
1411 /* If TYPE is a derived type, then print out derivation
1412 information. Print out all layers of the type heirarchy
1413 until we encounter one with multiple inheritance.
1414 At that point, print out that ply, and return. */
1415 static void
1416 type_print_derivation_info (stream, type)
1417 FILE *stream;
1418 struct type *type;
1419 {
1420 char *name;
1421 int i, n_baseclasses = TYPE_N_BASECLASSES (type);
1422 struct type *basetype = 0;
1423
1424 while (type && n_baseclasses > 0)
1425 {
1426 /* Not actually sure about this one -- Bryan. */
1427 check_stub_type (type);
1428
1429 fprintf_filtered (stream, ": ");
1430 for (i = 0; ;)
1431 {
1432 basetype = TYPE_BASECLASS (type, i);
1433 if (name = type_name_no_tag (basetype))
1434 {
1435 fprintf_filtered (stream, "%s%s ",
1436 BASETYPE_VIA_PUBLIC(type, i) ? "public" : "private",
1437 BASETYPE_VIA_VIRTUAL(type, i) ? " virtual" : "");
1438 fputs_filtered (name, stream);
1439 }
1440 i++;
1441 if (i >= n_baseclasses)
1442 break;
1443 fprintf_filtered (stream, ", ");
1444 }
1445
1446 fprintf_filtered (stream, " ");
1447 if (n_baseclasses != 1)
1448 break;
1449 n_baseclasses = TYPE_N_BASECLASSES (basetype);
1450 type = basetype;
1451 }
1452 }
1453
1454 /* Print any asterisks or open-parentheses needed before the
1455 variable name (to describe its type).
1456
1457 On outermost call, pass 0 for PASSED_A_PTR.
1458 On outermost call, SHOW > 0 means should ignore
1459 any typename for TYPE and show its details.
1460 SHOW is always zero on recursive calls. */
1461
1462 static void
1463 type_print_varspec_prefix (type, stream, show, passed_a_ptr)
1464 struct type *type;
1465 FILE *stream;
1466 int show;
1467 int passed_a_ptr;
1468 {
1469 char *name;
1470 if (type == 0)
1471 return;
1472
1473 if (TYPE_NAME (type) && show <= 0)
1474 return;
1475
1476 QUIT;
1477
1478 switch (TYPE_CODE (type))
1479 {
1480 case TYPE_CODE_PTR:
1481 type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1);
1482 fprintf_filtered (stream, "*");
1483 break;
1484
1485 case TYPE_CODE_MEMBER:
1486 if (passed_a_ptr)
1487 fprintf_filtered (stream, "(");
1488 type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0,
1489 0);
1490 fprintf_filtered (stream, " ");
1491 name = type_name_no_tag (TYPE_DOMAIN_TYPE (type));
1492 if (name)
1493 fputs_filtered (name, stream);
1494 else
1495 type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0, passed_a_ptr);
1496 fprintf_filtered (stream, "::");
1497 break;
1498
1499 case TYPE_CODE_METHOD:
1500 if (passed_a_ptr)
1501 fprintf (stream, "(");
1502 type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0,
1503 0);
1504 if (passed_a_ptr)
1505 {
1506 fprintf_filtered (stream, " ");
1507 type_print_base (TYPE_DOMAIN_TYPE (type), stream, 0,
1508 passed_a_ptr);
1509 fprintf_filtered (stream, "::");
1510 }
1511 break;
1512
1513 case TYPE_CODE_REF:
1514 type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0, 1);
1515 fprintf_filtered (stream, "&");
1516 break;
1517
1518 case TYPE_CODE_FUNC:
1519 type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0,
1520 0);
1521 if (passed_a_ptr)
1522 fprintf_filtered (stream, "(");
1523 break;
1524
1525 case TYPE_CODE_ARRAY:
1526 type_print_varspec_prefix (TYPE_TARGET_TYPE (type), stream, 0,
1527 0);
1528 if (passed_a_ptr)
1529 fprintf_filtered (stream, "(");
1530 break;
1531
1532 case TYPE_CODE_UNDEF:
1533 case TYPE_CODE_STRUCT:
1534 case TYPE_CODE_UNION:
1535 case TYPE_CODE_ENUM:
1536 case TYPE_CODE_INT:
1537 case TYPE_CODE_FLT:
1538 case TYPE_CODE_VOID:
1539 case TYPE_CODE_ERROR:
1540 case TYPE_CODE_CHAR:
1541 case TYPE_CODE_BOOL:
1542 /* These types need no prefix. They are listed here so that
1543 gcc -Wall will reveal any types that haven't been handled. */
1544 break;
1545 }
1546 }
1547
1548 /* Print any array sizes, function arguments or close parentheses
1549 needed after the variable name (to describe its type).
1550 Args work like type_print_varspec_prefix. */
1551
1552 static void
1553 type_print_varspec_suffix (type, stream, show, passed_a_ptr)
1554 struct type *type;
1555 FILE *stream;
1556 int show;
1557 int passed_a_ptr;
1558 {
1559 if (type == 0)
1560 return;
1561
1562 if (TYPE_NAME (type) && show <= 0)
1563 return;
1564
1565 QUIT;
1566
1567 switch (TYPE_CODE (type))
1568 {
1569 case TYPE_CODE_ARRAY:
1570 if (passed_a_ptr)
1571 fprintf_filtered (stream, ")");
1572
1573 fprintf_filtered (stream, "[");
1574 if (TYPE_LENGTH (type) > 0
1575 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
1576 fprintf_filtered (stream, "%d",
1577 (TYPE_LENGTH (type)
1578 / TYPE_LENGTH (TYPE_TARGET_TYPE (type))));
1579 fprintf_filtered (stream, "]");
1580
1581 type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
1582 0);
1583 break;
1584
1585 case TYPE_CODE_MEMBER:
1586 if (passed_a_ptr)
1587 fprintf_filtered (stream, ")");
1588 type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0);
1589 break;
1590
1591 case TYPE_CODE_METHOD:
1592 if (passed_a_ptr)
1593 fprintf_filtered (stream, ")");
1594 type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 0);
1595 if (passed_a_ptr)
1596 {
1597 int i;
1598 struct type **args = TYPE_ARG_TYPES (type);
1599
1600 fprintf_filtered (stream, "(");
1601 if (args[1] == 0)
1602 fprintf_filtered (stream, "...");
1603 else for (i = 1; args[i] != 0 && args[i]->code != TYPE_CODE_VOID; i++)
1604 {
1605 type_print_1 (args[i], "", stream, -1, 0);
1606 if (args[i+1] == 0)
1607 fprintf_filtered (stream, "...");
1608 else if (args[i+1]->code != TYPE_CODE_VOID) {
1609 fprintf_filtered (stream, ",");
1610 wrap_here (" ");
1611 }
1612 }
1613 fprintf_filtered (stream, ")");
1614 }
1615 break;
1616
1617 case TYPE_CODE_PTR:
1618 case TYPE_CODE_REF:
1619 type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0, 1);
1620 break;
1621
1622 case TYPE_CODE_FUNC:
1623 type_print_varspec_suffix (TYPE_TARGET_TYPE (type), stream, 0,
1624 passed_a_ptr);
1625 if (passed_a_ptr)
1626 fprintf_filtered (stream, ")");
1627 fprintf_filtered (stream, "()");
1628 break;
1629
1630 case TYPE_CODE_UNDEF:
1631 case TYPE_CODE_STRUCT:
1632 case TYPE_CODE_UNION:
1633 case TYPE_CODE_ENUM:
1634 case TYPE_CODE_INT:
1635 case TYPE_CODE_FLT:
1636 case TYPE_CODE_VOID:
1637 case TYPE_CODE_ERROR:
1638 case TYPE_CODE_CHAR:
1639 case TYPE_CODE_BOOL:
1640 /* These types do not need a suffix. They are listed so that
1641 gcc -Wall will report types that may not have been considered. */
1642 break;
1643 }
1644 }
1645
1646 /* Print the name of the type (or the ultimate pointer target,
1647 function value or array element), or the description of a
1648 structure or union.
1649
1650 SHOW nonzero means don't print this type as just its name;
1651 show its real definition even if it has a name.
1652 SHOW zero means print just typename or struct tag if there is one
1653 SHOW negative means abbreviate structure elements.
1654 SHOW is decremented for printing of structure elements.
1655
1656 LEVEL is the depth to indent by.
1657 We increase it for some recursive calls. */
1658
1659 static void
1660 type_print_base (type, stream, show, level)
1661 struct type *type;
1662 FILE *stream;
1663 int show;
1664 int level;
1665 {
1666 char *name;
1667 register int i;
1668 register int len;
1669 register int lastval;
1670
1671 QUIT;
1672
1673 wrap_here (" ");
1674 if (type == NULL)
1675 {
1676 fputs_filtered ("<type unknown>", stream);
1677 return;
1678 }
1679
1680 /* When SHOW is zero or less, and there is a valid type name, then always
1681 just print the type name directly from the type. */
1682
1683 if ((show <= 0) && (TYPE_NAME (type) != NULL))
1684 {
1685 fputs_filtered (TYPE_NAME (type), stream);
1686 return;
1687 }
1688
1689 switch (TYPE_CODE (type))
1690 {
1691 case TYPE_CODE_ARRAY:
1692 case TYPE_CODE_PTR:
1693 case TYPE_CODE_MEMBER:
1694 case TYPE_CODE_REF:
1695 case TYPE_CODE_FUNC:
1696 case TYPE_CODE_METHOD:
1697 type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
1698 break;
1699
1700 case TYPE_CODE_STRUCT:
1701 fprintf_filtered (stream, "struct ");
1702 goto struct_union;
1703
1704 case TYPE_CODE_UNION:
1705 fprintf_filtered (stream, "union ");
1706 struct_union:
1707 if (name = type_name_no_tag (type))
1708 {
1709 fputs_filtered (name, stream);
1710 fputs_filtered (" ", stream);
1711 wrap_here (" ");
1712 }
1713 if (show < 0)
1714 fprintf_filtered (stream, "{...}");
1715 else
1716 {
1717 check_stub_type (type);
1718
1719 type_print_derivation_info (stream, type);
1720
1721 fprintf_filtered (stream, "{");
1722 len = TYPE_NFIELDS (type);
1723 if (len)
1724 fprintf_filtered (stream, "\n");
1725 else
1726 {
1727 if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
1728 fprintf_filtered (stream, "<incomplete type>\n");
1729 else
1730 fprintf_filtered (stream, "<no data fields>\n");
1731 }
1732
1733 /* If there is a base class for this type,
1734 do not print the field that it occupies. */
1735 for (i = TYPE_N_BASECLASSES (type); i < len; i++)
1736 {
1737 QUIT;
1738 /* Don't print out virtual function table. */
1739 if ((TYPE_FIELD_NAME (type, i))[5] == CPLUS_MARKER &&
1740 !strncmp (TYPE_FIELD_NAME (type, i), "_vptr", 5))
1741 continue;
1742
1743 print_spaces_filtered (level + 4, stream);
1744 if (TYPE_FIELD_STATIC (type, i))
1745 {
1746 fprintf_filtered (stream, "static ");
1747 }
1748 type_print_1 (TYPE_FIELD_TYPE (type, i),
1749 TYPE_FIELD_NAME (type, i),
1750 stream, show - 1, level + 4);
1751 if (!TYPE_FIELD_STATIC (type, i)
1752 && TYPE_FIELD_PACKED (type, i))
1753 {
1754 /* It is a bitfield. This code does not attempt
1755 to look at the bitpos and reconstruct filler,
1756 unnamed fields. This would lead to misleading
1757 results if the compiler does not put out fields
1758 for such things (I don't know what it does). */
1759 fprintf_filtered (stream, " : %d",
1760 TYPE_FIELD_BITSIZE (type, i));
1761 }
1762 fprintf_filtered (stream, ";\n");
1763 }
1764
1765 /* C++: print out the methods */
1766 len = TYPE_NFN_FIELDS (type);
1767 if (len) fprintf_filtered (stream, "\n");
1768 for (i = 0; i < len; i++)
1769 {
1770 struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
1771 int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
1772 char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
1773 int is_constructor = name && strcmp(method_name, name) == 0;
1774 for (j = 0; j < len2; j++)
1775 {
1776 QUIT;
1777 print_spaces_filtered (level + 4, stream);
1778 if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
1779 fprintf_filtered (stream, "virtual ");
1780 else if (TYPE_FN_FIELD_STATIC_P (f, j))
1781 fprintf_filtered (stream, "static ");
1782 if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
1783 {
1784 /* Keep GDB from crashing here. */
1785 fprintf (stream, "<undefined type> %s;\n",
1786 TYPE_FN_FIELD_PHYSNAME (f, j));
1787 break;
1788 }
1789 else if (!is_constructor)
1790 {
1791 type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
1792 "", stream, 0);
1793 fputs_filtered (" ", stream);
1794 }
1795 if (TYPE_FN_FIELD_STUB (f, j))
1796 {
1797 /* Build something we can demangle. */
1798 char *mangled_name = gdb_mangle_name (type, i, j);
1799 char *demangled_name =
1800 cplus_demangle (mangled_name,
1801 DMGL_ANSI | DMGL_PARAMS);
1802 if (demangled_name == 0)
1803 fprintf_filtered (stream, "<badly mangled name %s>",
1804 mangled_name);
1805 else
1806 {
1807 fprintf_filtered (stream, "%s",
1808 strchr (demangled_name, ':') + 2);
1809 free (demangled_name);
1810 }
1811 free (mangled_name);
1812 }
1813 else if (TYPE_FN_FIELD_PHYSNAME (f, j)[0] == '_'
1814 && TYPE_FN_FIELD_PHYSNAME (f, j)[1] == CPLUS_MARKER)
1815 type_print_method_args
1816 (TYPE_FN_FIELD_ARGS (f, j) + 1, "~",
1817 method_name, 0, stream);
1818 else
1819 type_print_method_args
1820 (TYPE_FN_FIELD_ARGS (f, j), "",
1821 method_name,
1822 TYPE_FN_FIELD_STATIC_P (f, j), stream);
1823
1824 fprintf_filtered (stream, ";\n");
1825 }
1826 }
1827
1828 print_spaces_filtered (level, stream);
1829 fprintf_filtered (stream, "}");
1830 }
1831 break;
1832
1833 case TYPE_CODE_ENUM:
1834 fprintf_filtered (stream, "enum ");
1835 if (name = type_name_no_tag (type))
1836 {
1837 fputs_filtered (name, stream);
1838 fputs_filtered (" ", stream);
1839 }
1840 wrap_here (" ");
1841 if (show < 0)
1842 fprintf_filtered (stream, "{...}");
1843 else
1844 {
1845 fprintf_filtered (stream, "{");
1846 len = TYPE_NFIELDS (type);
1847 lastval = 0;
1848 for (i = 0; i < len; i++)
1849 {
1850 QUIT;
1851 if (i) fprintf_filtered (stream, ", ");
1852 wrap_here (" ");
1853 fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
1854 if (lastval != TYPE_FIELD_BITPOS (type, i))
1855 {
1856 fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
1857 lastval = TYPE_FIELD_BITPOS (type, i);
1858 }
1859 lastval++;
1860 }
1861 fprintf_filtered (stream, "}");
1862 }
1863 break;
1864
1865 case TYPE_CODE_VOID:
1866 fprintf_filtered (stream, "void");
1867 break;
1868
1869 case TYPE_CODE_UNDEF:
1870 fprintf_filtered (stream, "struct <unknown>");
1871 break;
1872
1873 case TYPE_CODE_ERROR:
1874 fprintf_filtered (stream, "<unknown type>");
1875 break;
1876
1877 case TYPE_CODE_RANGE:
1878 /* This should not occur */
1879 fprintf_filtered (stream, "<range type>");
1880 break;
1881
1882 default:
1883 /* Handle types not explicitly handled by the other cases,
1884 such as fundamental types. For these, just print whatever
1885 the type name is, as recorded in the type itself. If there
1886 is no type name, then complain. */
1887 if (TYPE_NAME (type) != NULL)
1888 {
1889 fputs_filtered (TYPE_NAME (type), stream);
1890 }
1891 else
1892 {
1893 error ("Invalid type code (%d) in symbol table.", TYPE_CODE (type));
1894 }
1895 break;
1896 }
1897 }
1898 \f
1899 #if 0
1900 /* Validate an input or output radix setting, and make sure the user
1901 knows what they really did here. Radix setting is confusing, e.g.
1902 setting the input radix to "10" never changes it! */
1903
1904 /* ARGSUSED */
1905 static void
1906 set_input_radix (args, from_tty, c)
1907 char *args;
1908 int from_tty;
1909 struct cmd_list_element *c;
1910 {
1911 unsigned radix = *(unsigned *)c->var;
1912
1913 if (from_tty)
1914 printf_filtered ("Input radix set to decimal %d, hex %x, octal %o\n",
1915 radix, radix, radix);
1916 }
1917 #endif
1918
1919 /* ARGSUSED */
1920 static void
1921 set_output_radix (args, from_tty, c)
1922 char *args;
1923 int from_tty;
1924 struct cmd_list_element *c;
1925 {
1926 unsigned radix = *(unsigned *)c->var;
1927
1928 if (from_tty)
1929 printf_filtered ("Output radix set to decimal %d, hex %x, octal %o\n",
1930 radix, radix, radix);
1931
1932 /* FIXME, we really should be able to validate the setting BEFORE
1933 it takes effect. */
1934 switch (radix)
1935 {
1936 case 16:
1937 output_format = 'x';
1938 break;
1939 case 10:
1940 output_format = 0;
1941 break;
1942 case 8:
1943 output_format = 'o'; /* octal */
1944 break;
1945 default:
1946 output_format = 0;
1947 error ("Unsupported radix ``decimal %d''; using decimal output",
1948 radix);
1949 }
1950 }
1951
1952 /* Both at once */
1953 static void
1954 set_radix (arg, from_tty, c)
1955 char *arg;
1956 int from_tty;
1957 struct cmd_list_element *c;
1958 {
1959 unsigned radix = *(unsigned *)c->var;
1960
1961 if (from_tty)
1962 printf_filtered ("Radix set to decimal %d, hex %x, octal %o\n",
1963 radix, radix, radix);
1964
1965 input_radix = radix;
1966 output_radix = radix;
1967
1968 set_output_radix (arg, 0, c);
1969 }
1970 \f
1971 struct cmd_list_element *setprintlist = NULL;
1972 struct cmd_list_element *showprintlist = NULL;
1973
1974 /*ARGSUSED*/
1975 static void
1976 set_print (arg, from_tty)
1977 char *arg;
1978 int from_tty;
1979 {
1980 printf (
1981 "\"set print\" must be followed by the name of a print subcommand.\n");
1982 help_list (setprintlist, "set print ", -1, stdout);
1983 }
1984
1985 /*ARGSUSED*/
1986 static void
1987 show_print (args, from_tty)
1988 char *args;
1989 int from_tty;
1990 {
1991 cmd_show_list (showprintlist, from_tty, "");
1992 }
1993 \f
1994 void
1995 _initialize_valprint ()
1996 {
1997 struct cmd_list_element *c;
1998
1999 add_prefix_cmd ("print", no_class, set_print,
2000 "Generic command for setting how things print.",
2001 &setprintlist, "set print ", 0, &setlist);
2002 add_alias_cmd ("p", "print", no_class, 1, &setlist);
2003 add_alias_cmd ("pr", "print", no_class, 1, &setlist); /* prefer set print
2004 to set prompt */
2005 add_prefix_cmd ("print", no_class, show_print,
2006 "Generic command for showing print settings.",
2007 &showprintlist, "show print ", 0, &showlist);
2008 add_alias_cmd ("p", "print", no_class, 1, &showlist);
2009 add_alias_cmd ("pr", "print", no_class, 1, &showlist);
2010
2011 add_show_from_set
2012 (add_set_cmd ("elements", no_class, var_uinteger, (char *)&print_max,
2013 "Set limit on string chars or array elements to print.\n\
2014 \"set print elements 0\" causes there to be no limit.",
2015 &setprintlist),
2016 &showprintlist);
2017
2018 add_show_from_set
2019 (add_set_cmd ("pretty", class_support, var_boolean, (char *)&prettyprint,
2020 "Set prettyprinting of structures.",
2021 &setprintlist),
2022 &showprintlist);
2023
2024 add_show_from_set
2025 (add_set_cmd ("union", class_support, var_boolean, (char *)&unionprint,
2026 "Set printing of unions interior to structures.",
2027 &setprintlist),
2028 &showprintlist);
2029
2030 add_show_from_set
2031 (add_set_cmd ("vtbl", class_support, var_boolean, (char *)&vtblprint,
2032 "Set printing of C++ virtual function tables.",
2033 &setprintlist),
2034 &showprintlist);
2035
2036 add_show_from_set
2037 (add_set_cmd ("array", class_support, var_boolean, (char *)&arrayprint,
2038 "Set prettyprinting of arrays.",
2039 &setprintlist),
2040 &showprintlist);
2041
2042 add_show_from_set
2043 (add_set_cmd ("object", class_support, var_boolean, (char *)&objectprint,
2044 "Set printing of object's derived type based on vtable info.",
2045 &setprintlist),
2046 &showprintlist);
2047
2048 add_show_from_set
2049 (add_set_cmd ("address", class_support, var_boolean, (char *)&addressprint,
2050 "Set printing of addresses.",
2051 &setprintlist),
2052 &showprintlist);
2053
2054 #if 0
2055 /* The "show radix" cmd isn't good enough to show two separate values.
2056 The rest of the code works, but the show part is confusing, so don't
2057 let them be set separately 'til we work out "show". */
2058 c = add_set_cmd ("input-radix", class_support, var_uinteger,
2059 (char *)&input_radix,
2060 "Set default input radix for entering numbers.",
2061 &setlist);
2062 add_show_from_set (c, &showlist);
2063 c->function = set_input_radix;
2064
2065 c = add_set_cmd ("output-radix", class_support, var_uinteger,
2066 (char *)&output_radix,
2067 "Set default output radix for printing of values.",
2068 &setlist);
2069 add_show_from_set (c, &showlist);
2070 c->function = set_output_radix;
2071 #endif
2072
2073 c = add_set_cmd ("radix", class_support, var_uinteger,
2074 (char *)&output_radix,
2075 "Set default input and output number radix.",
2076 &setlist);
2077 add_show_from_set (c, &showlist);
2078 c->function.sfunc = set_radix;
2079
2080 /* Give people the defaults which they are used to. */
2081 prettyprint = 0;
2082 unionprint = 1;
2083 vtblprint = 0;
2084 arrayprint = 0;
2085 addressprint = 1;
2086 objectprint = 0;
2087
2088 print_max = 200;
2089
2090 obstack_begin (&dont_print_obstack, 32 * sizeof (struct type *));
2091 }
GDB Binutils - Deliverables
This page took 0.091193 seconds and 4 git commands to generate.