1 /* Support for printing Ada values for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1997, 2001
3 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
20
21 #include <ctype.h>
22 #include "defs.h"
23 #include "symtab.h"
24 #include "gdbtypes.h"
25 #include "expression.h"
26 #include "value.h"
27 #include "demangle.h"
28 #include "valprint.h"
29 #include "language.h"
30 #include "annotate.h"
31 #include "ada-lang.h"
32 #include "c-lang.h"
33 #include "infcall.h"
34
35 /* Encapsulates arguments to ada_val_print. */
36 struct ada_val_print_args
37 {
38 struct type *type;
39 char *valaddr0;
40 int embedded_offset;
41 CORE_ADDR address;
42 struct ui_file *stream;
43 int format;
44 int deref_ref;
45 int recurse;
46 enum val_prettyprint pretty;
47 };
48
49 static void print_record (struct type *, char *, struct ui_file *, int,
50 int, enum val_prettyprint);
51
52 static int print_field_values (struct type *, char *, struct ui_file *,
53 int, int, enum val_prettyprint,
54 int, struct type *, char *);
55
56 static int print_variant_part (struct type *, int, char *,
57 struct ui_file *, int, int,
58 enum val_prettyprint, int, struct type *,
59 char *);
60
61 static void val_print_packed_array_elements (struct type *, char *valaddr,
62 int, struct ui_file *, int, int,
63 enum val_prettyprint);
64
65 static void adjust_type_signedness (struct type *);
66
67 static int ada_val_print_stub (void *args0);
68
69 static int ada_val_print_1 (struct type *, char *, int, CORE_ADDR,
70 struct ui_file *, int, int, int,
71 enum val_prettyprint);
72
73
74 /* Make TYPE unsigned if its range of values includes no negatives. */
75 static void
adjust_type_signedness(struct type * type)76 adjust_type_signedness (struct type *type)
77 {
78 if (type != NULL && TYPE_CODE (type) == TYPE_CODE_RANGE
79 && TYPE_LOW_BOUND (type) >= 0)
80 TYPE_FLAGS (type) |= TYPE_FLAG_UNSIGNED;
81 }
82
83 /* Assuming TYPE is a simple array type, prints its lower bound on STREAM,
84 if non-standard (i.e., other than 1 for numbers, other than lower bound
85 of index type for enumerated type). Returns 1 if something printed,
86 otherwise 0. */
87
88 static int
print_optional_low_bound(struct ui_file * stream,struct type * type)89 print_optional_low_bound (struct ui_file *stream, struct type *type)
90 {
91 struct type *index_type;
92 long low_bound;
93
94 index_type = TYPE_INDEX_TYPE (type);
95 low_bound = 0;
96
97 if (index_type == NULL)
98 return 0;
99 if (TYPE_CODE (index_type) == TYPE_CODE_RANGE)
100 {
101 low_bound = TYPE_LOW_BOUND (index_type);
102 index_type = TYPE_TARGET_TYPE (index_type);
103 }
104 else
105 return 0;
106
107 switch (TYPE_CODE (index_type))
108 {
109 case TYPE_CODE_ENUM:
110 if (low_bound == TYPE_FIELD_BITPOS (index_type, 0))
111 return 0;
112 break;
113 case TYPE_CODE_UNDEF:
114 index_type = builtin_type_long;
115 /* FALL THROUGH */
116 default:
117 if (low_bound == 1)
118 return 0;
119 break;
120 }
121
122 ada_print_scalar (index_type, (LONGEST) low_bound, stream);
123 fprintf_filtered (stream, " => ");
124 return 1;
125 }
126
127 /* Version of val_print_array_elements for GNAT-style packed arrays.
128 Prints elements of packed array of type TYPE at bit offset
129 BITOFFSET from VALADDR on STREAM. Formats according to FORMAT and
130 separates with commas. RECURSE is the recursion (nesting) level.
131 If PRETTY, uses "prettier" format. TYPE must have been decoded (as
132 by ada_coerce_to_simple_array). */
133
134 static void
val_print_packed_array_elements(struct type * type,char * valaddr,int bitoffset,struct ui_file * stream,int format,int recurse,enum val_prettyprint pretty)135 val_print_packed_array_elements (struct type *type, char *valaddr,
136 int bitoffset, struct ui_file *stream,
137 int format, int recurse,
138 enum val_prettyprint pretty)
139 {
140 unsigned int i;
141 unsigned int things_printed = 0;
142 unsigned len;
143 struct type *elttype;
144 unsigned eltlen;
145 /* Position of the array element we are examining to see
146 whether it is repeated. */
147 unsigned int rep1;
148 /* Number of repetitions we have detected so far. */
149 unsigned int reps;
150 unsigned long bitsize = TYPE_FIELD_BITSIZE (type, 0);
151 struct value *mark = value_mark ();
152
153 elttype = TYPE_TARGET_TYPE (type);
154 eltlen = TYPE_LENGTH (check_typedef (elttype));
155
156 {
157 LONGEST low, high;
158 if (get_discrete_bounds (TYPE_FIELD_TYPE (type, 0), &low, &high) < 0)
159 len = 1;
160 else
161 len = high - low + 1;
162 }
163
164 i = 0;
165 annotate_array_section_begin (i, elttype);
166
167 while (i < len && things_printed < print_max)
168 {
169 struct value *v0, *v1;
170 int i0;
171
172 if (i != 0)
173 {
174 if (prettyprint_arrays)
175 {
176 fprintf_filtered (stream, ",\n");
177 print_spaces_filtered (2 + 2 * recurse, stream);
178 }
179 else
180 {
181 fprintf_filtered (stream, ", ");
182 }
183 }
184 wrap_here (n_spaces (2 + 2 * recurse));
185
186 i0 = i;
187 v0 = ada_value_primitive_packed_val (NULL, valaddr,
188 (i0 * bitsize) / HOST_CHAR_BIT,
189 (i0 * bitsize) % HOST_CHAR_BIT,
190 bitsize, elttype);
191 while (1)
192 {
193 i += 1;
194 if (i >= len)
195 break;
196 v1 = ada_value_primitive_packed_val (NULL, valaddr,
197 (i * bitsize) / HOST_CHAR_BIT,
198 (i * bitsize) % HOST_CHAR_BIT,
199 bitsize, elttype);
200 if (memcmp (VALUE_CONTENTS (v0), VALUE_CONTENTS (v1), eltlen) != 0)
201 break;
202 }
203
204 if (i - i0 > repeat_count_threshold)
205 {
206 val_print (elttype, VALUE_CONTENTS (v0), 0, 0, stream, format,
207 0, recurse + 1, pretty);
208 annotate_elt_rep (i - i0);
209 fprintf_filtered (stream, " <repeats %u times>", i - i0);
210 annotate_elt_rep_end ();
211
212 }
213 else
214 {
215 int j;
216 for (j = i0; j < i; j += 1)
217 {
218 if (j > i0)
219 {
220 if (prettyprint_arrays)
221 {
222 fprintf_filtered (stream, ",\n");
223 print_spaces_filtered (2 + 2 * recurse, stream);
224 }
225 else
226 {
227 fprintf_filtered (stream, ", ");
228 }
229 wrap_here (n_spaces (2 + 2 * recurse));
230 }
231 val_print (elttype, VALUE_CONTENTS (v0), 0, 0, stream, format,
232 0, recurse + 1, pretty);
233 annotate_elt ();
234 }
235 }
236 things_printed += i - i0;
237 }
238 annotate_array_section_end ();
239 if (i < len)
240 {
241 fprintf_filtered (stream, "...");
242 }
243
244 value_free_to_mark (mark);
245 }
246
247 static struct type *
printable_val_type(struct type * type,char * valaddr)248 printable_val_type (struct type *type, char *valaddr)
249 {
250 return ada_to_fixed_type (ada_aligned_type (type), valaddr, 0, NULL);
251 }
252
253 /* Print the character C on STREAM as part of the contents of a literal
254 string whose delimiter is QUOTER. TYPE_LEN is the length in bytes
255 (1 or 2) of the character. */
256
257 void
ada_emit_char(int c,struct ui_file * stream,int quoter,int type_len)258 ada_emit_char (int c, struct ui_file *stream, int quoter, int type_len)
259 {
260 if (type_len != 2)
261 type_len = 1;
262
263 c &= (1 << (type_len * TARGET_CHAR_BIT)) - 1;
264
265 if (isascii (c) && isprint (c))
266 {
267 if (c == quoter && c == '"')
268 fprintf_filtered (stream, "[\"%c\"]", quoter);
269 else
270 fprintf_filtered (stream, "%c", c);
271 }
272 else
273 fprintf_filtered (stream, "[\"%0*x\"]", type_len * 2, c);
274 }
275
276 /* Character #I of STRING, given that TYPE_LEN is the size in bytes (1
277 or 2) of a character. */
278
279 static int
char_at(char * string,int i,int type_len)280 char_at (char *string, int i, int type_len)
281 {
282 if (type_len == 1)
283 return string[i];
284 else
285 return (int) extract_unsigned_integer (string + 2 * i, 2);
286 }
287
288 void
ada_printchar(int c,struct ui_file * stream)289 ada_printchar (int c, struct ui_file *stream)
290 {
291 fputs_filtered ("'", stream);
292 ada_emit_char (c, stream, '\'', 1);
293 fputs_filtered ("'", stream);
294 }
295
296 /* [From print_type_scalar in typeprint.c]. Print VAL on STREAM in a
297 form appropriate for TYPE. */
298
299 void
ada_print_scalar(struct type * type,LONGEST val,struct ui_file * stream)300 ada_print_scalar (struct type *type, LONGEST val, struct ui_file *stream)
301 {
302 unsigned int i;
303 unsigned len;
304
305 CHECK_TYPEDEF (type);
306
307 switch (TYPE_CODE (type))
308 {
309
310 case TYPE_CODE_ENUM:
311 len = TYPE_NFIELDS (type);
312 for (i = 0; i < len; i++)
313 {
314 if (TYPE_FIELD_BITPOS (type, i) == val)
315 {
316 break;
317 }
318 }
319 if (i < len)
320 {
321 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type, i)), stream);
322 }
323 else
324 {
325 print_longest (stream, 'd', 0, val);
326 }
327 break;
328
329 case TYPE_CODE_INT:
330 print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
331 break;
332
333 case TYPE_CODE_CHAR:
334 LA_PRINT_CHAR ((unsigned char) val, stream);
335 break;
336
337 case TYPE_CODE_BOOL:
338 fprintf_filtered (stream, val ? "true" : "false");
339 break;
340
341 case TYPE_CODE_RANGE:
342 ada_print_scalar (TYPE_TARGET_TYPE (type), val, stream);
343 return;
344
345 case TYPE_CODE_UNDEF:
346 case TYPE_CODE_PTR:
347 case TYPE_CODE_ARRAY:
348 case TYPE_CODE_STRUCT:
349 case TYPE_CODE_UNION:
350 case TYPE_CODE_FUNC:
351 case TYPE_CODE_FLT:
352 case TYPE_CODE_VOID:
353 case TYPE_CODE_SET:
354 case TYPE_CODE_STRING:
355 case TYPE_CODE_ERROR:
356 case TYPE_CODE_MEMBER:
357 case TYPE_CODE_METHOD:
358 case TYPE_CODE_REF:
359 warning ("internal error: unhandled type in ada_print_scalar");
360 break;
361
362 default:
363 error ("Invalid type code in symbol table.");
364 }
365 gdb_flush (stream);
366 }
367
368 /* Print the character string STRING, printing at most LENGTH characters.
369 Printing stops early if the number hits print_max; repeat counts
370 are printed as appropriate. Print ellipses at the end if we
371 had to stop before printing LENGTH characters, or if
372 FORCE_ELLIPSES. TYPE_LEN is the length (1 or 2) of the character type.
373 */
374
375 static void
printstr(struct ui_file * stream,char * string,unsigned int length,int force_ellipses,int type_len)376 printstr (struct ui_file *stream, char *string, unsigned int length,
377 int force_ellipses, int type_len)
378 {
379 unsigned int i;
380 unsigned int things_printed = 0;
381 int in_quotes = 0;
382 int need_comma = 0;
383
384 if (length == 0)
385 {
386 fputs_filtered ("\"\"", stream);
387 return;
388 }
389
390 for (i = 0; i < length && things_printed < print_max; i += 1)
391 {
392 /* Position of the character we are examining
393 to see whether it is repeated. */
394 unsigned int rep1;
395 /* Number of repetitions we have detected so far. */
396 unsigned int reps;
397
398 QUIT;
399
400 if (need_comma)
401 {
402 fputs_filtered (", ", stream);
403 need_comma = 0;
404 }
405
406 rep1 = i + 1;
407 reps = 1;
408 while (rep1 < length &&
409 char_at (string, rep1, type_len) == char_at (string, i,
410 type_len))
411 {
412 rep1 += 1;
413 reps += 1;
414 }
415
416 if (reps > repeat_count_threshold)
417 {
418 if (in_quotes)
419 {
420 if (inspect_it)
421 fputs_filtered ("\\\", ", stream);
422 else
423 fputs_filtered ("\", ", stream);
424 in_quotes = 0;
425 }
426 fputs_filtered ("'", stream);
427 ada_emit_char (char_at (string, i, type_len), stream, '\'',
428 type_len);
429 fputs_filtered ("'", stream);
430 fprintf_filtered (stream, " <repeats %u times>", reps);
431 i = rep1 - 1;
432 things_printed += repeat_count_threshold;
433 need_comma = 1;
434 }
435 else
436 {
437 if (!in_quotes)
438 {
439 if (inspect_it)
440 fputs_filtered ("\\\"", stream);
441 else
442 fputs_filtered ("\"", stream);
443 in_quotes = 1;
444 }
445 ada_emit_char (char_at (string, i, type_len), stream, '"',
446 type_len);
447 things_printed += 1;
448 }
449 }
450
451 /* Terminate the quotes if necessary. */
452 if (in_quotes)
453 {
454 if (inspect_it)
455 fputs_filtered ("\\\"", stream);
456 else
457 fputs_filtered ("\"", stream);
458 }
459
460 if (force_ellipses || i < length)
461 fputs_filtered ("...", stream);
462 }
463
464 void
ada_printstr(struct ui_file * stream,char * string,unsigned int length,int force_ellipses,int width)465 ada_printstr (struct ui_file *stream, char *string, unsigned int length,
466 int force_ellipses, int width)
467 {
468 printstr (stream, string, length, force_ellipses, width);
469 }
470
471
472 /* Print data of type TYPE located at VALADDR (within GDB), which came from
473 the inferior at address ADDRESS, onto stdio stream STREAM according to
474 FORMAT (a letter as for the printf % codes or 0 for natural format).
475 The data at VALADDR is in target byte order.
476
477 If the data is printed as a string, returns the number of string characters
478 printed.
479
480 If DEREF_REF is nonzero, then dereference references, otherwise just print
481 them like pointers.
482
483 RECURSE indicates the amount of indentation to supply before
484 continuation lines; this amount is roughly twice the value of RECURSE.
485
486 When PRETTY is non-zero, prints record fields on separate lines.
487 (For some reason, the current version of gdb instead uses a global
488 variable---prettyprint_arrays--- to causes a similar effect on
489 arrays.) */
490
491 int
ada_val_print(struct type * type,char * valaddr0,int embedded_offset,CORE_ADDR address,struct ui_file * stream,int format,int deref_ref,int recurse,enum val_prettyprint pretty)492 ada_val_print (struct type *type, char *valaddr0, int embedded_offset,
493 CORE_ADDR address, struct ui_file *stream, int format,
494 int deref_ref, int recurse, enum val_prettyprint pretty)
495 {
496 struct ada_val_print_args args;
497 args.type = type;
498 args.valaddr0 = valaddr0;
499 args.embedded_offset = embedded_offset;
500 args.address = address;
501 args.stream = stream;
502 args.format = format;
503 args.deref_ref = deref_ref;
504 args.recurse = recurse;
505 args.pretty = pretty;
506
507 return catch_errors (ada_val_print_stub, &args, NULL, RETURN_MASK_ALL);
508 }
509
510 /* Helper for ada_val_print; used as argument to catch_errors to
511 unmarshal the arguments to ada_val_print_1, which does the work. */
512 static int
ada_val_print_stub(void * args0)513 ada_val_print_stub (void * args0)
514 {
515 struct ada_val_print_args *argsp = (struct ada_val_print_args *) args0;
516 return ada_val_print_1 (argsp->type, argsp->valaddr0,
517 argsp->embedded_offset, argsp->address,
518 argsp->stream, argsp->format, argsp->deref_ref,
519 argsp->recurse, argsp->pretty);
520 }
521
522 /* See the comment on ada_val_print. This function differs in that it
523 * does not catch evaluation errors (leaving that to ada_val_print). */
524
525 static int
ada_val_print_1(struct type * type,char * valaddr0,int embedded_offset,CORE_ADDR address,struct ui_file * stream,int format,int deref_ref,int recurse,enum val_prettyprint pretty)526 ada_val_print_1 (struct type *type, char *valaddr0, int embedded_offset,
527 CORE_ADDR address, struct ui_file *stream, int format,
528 int deref_ref, int recurse, enum val_prettyprint pretty)
529 {
530 unsigned int len;
531 int i;
532 struct type *elttype;
533 unsigned int eltlen;
534 LONGEST val;
535 CORE_ADDR addr;
536 char *valaddr = valaddr0 + embedded_offset;
537
538 CHECK_TYPEDEF (type);
539
540 if (ada_is_array_descriptor (type) || ada_is_packed_array_type (type))
541 {
542 int retn;
543 struct value *mark = value_mark ();
544 struct value *val;
545 val = value_from_contents_and_address (type, valaddr, address);
546 val = ada_coerce_to_simple_array_ptr (val);
547 if (val == NULL)
548 {
549 fprintf_filtered (stream, "(null)");
550 retn = 0;
551 }
552 else
553 retn = ada_val_print_1 (VALUE_TYPE (val), VALUE_CONTENTS (val), 0,
554 VALUE_ADDRESS (val), stream, format,
555 deref_ref, recurse, pretty);
556 value_free_to_mark (mark);
557 return retn;
558 }
559
560 valaddr = ada_aligned_value_addr (type, valaddr);
561 embedded_offset -= valaddr - valaddr0 - embedded_offset;
562 type = printable_val_type (type, valaddr);
563
564 switch (TYPE_CODE (type))
565 {
566 default:
567 return c_val_print (type, valaddr0, embedded_offset, address, stream,
568 format, deref_ref, recurse, pretty);
569
570 case TYPE_CODE_INT:
571 case TYPE_CODE_RANGE:
572 if (ada_is_fixed_point_type (type))
573 {
574 LONGEST v = unpack_long (type, valaddr);
575 int len = TYPE_LENGTH (type);
576
577 fprintf_filtered (stream, len < 4 ? "%.11g" : "%.17g",
578 (double) ada_fixed_to_float (type, v));
579 return 0;
580 }
581 else if (ada_is_vax_floating_type (type))
582 {
583 struct value *val =
584 value_from_contents_and_address (type, valaddr, address);
585 struct value *func = ada_vax_float_print_function (type);
586 if (func != 0)
587 {
588 static struct type *parray_of_char = NULL;
589 struct value *printable_val;
590
591 if (parray_of_char == NULL)
592 parray_of_char =
593 make_pointer_type
594 (create_array_type
595 (NULL, builtin_type_char,
596 create_range_type (NULL, builtin_type_int, 0, 32)), NULL);
597
598 printable_val =
599 value_ind (value_cast (parray_of_char,
600 call_function_by_hand (func, 1,
601 &val)));
602
603 fprintf_filtered (stream, "%s", VALUE_CONTENTS (printable_val));
604 return 0;
605 }
606 /* No special printing function. Do as best we can. */
607 }
608 else if (TYPE_CODE (type) == TYPE_CODE_RANGE)
609 {
610 struct type *target_type = TYPE_TARGET_TYPE (type);
611 if (TYPE_LENGTH (type) != TYPE_LENGTH (target_type))
612 {
613 /* Obscure case of range type that has different length from
614 its base type. Perform a conversion, or we will get a
615 nonsense value. Actually, we could use the same
616 code regardless of lengths; I'm just avoiding a cast. */
617 struct value *v = value_cast (target_type,
618 value_from_contents_and_address
619 (type, valaddr, 0));
620 return ada_val_print_1 (target_type, VALUE_CONTENTS (v), 0, 0,
621 stream, format, 0, recurse + 1, pretty);
622 }
623 else
624 return ada_val_print_1 (TYPE_TARGET_TYPE (type),
625 valaddr0, embedded_offset,
626 address, stream, format, deref_ref,
627 recurse, pretty);
628 }
629 else
630 {
631 format = format ? format : output_format;
632 if (format)
633 {
634 print_scalar_formatted (valaddr, type, format, 0, stream);
635 }
636 else
637 {
638 val_print_type_code_int (type, valaddr, stream);
639 if (ada_is_character_type (type))
640 {
641 fputs_filtered (" ", stream);
642 ada_printchar ((unsigned char) unpack_long (type, valaddr),
643 stream);
644 }
645 }
646 return 0;
647 }
648
649 case TYPE_CODE_ENUM:
650 if (format)
651 {
652 print_scalar_formatted (valaddr, type, format, 0, stream);
653 break;
654 }
655 len = TYPE_NFIELDS (type);
656 val = unpack_long (type, valaddr);
657 for (i = 0; i < len; i++)
658 {
659 QUIT;
660 if (val == TYPE_FIELD_BITPOS (type, i))
661 {
662 break;
663 }
664 }
665 if (i < len)
666 {
667 const char *name = ada_enum_name (TYPE_FIELD_NAME (type, i));
668 if (name[0] == '\'')
669 fprintf_filtered (stream, "%ld %s", (long) val, name);
670 else
671 fputs_filtered (name, stream);
672 }
673 else
674 {
675 print_longest (stream, 'd', 0, val);
676 }
677 break;
678
679 case TYPE_CODE_UNION:
680 case TYPE_CODE_STRUCT:
681 if (ada_is_bogus_array_descriptor (type))
682 {
683 fprintf_filtered (stream, "(...?)");
684 return 0;
685 }
686 else
687 {
688 print_record (type, valaddr, stream, format, recurse, pretty);
689 return 0;
690 }
691
692 case TYPE_CODE_ARRAY:
693 if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
694 {
695 elttype = TYPE_TARGET_TYPE (type);
696 eltlen = TYPE_LENGTH (elttype);
697 len = TYPE_LENGTH (type) / eltlen;
698
699 /* For an array of chars, print with string syntax. */
700 if (ada_is_string_type (type) && (format == 0 || format == 's'))
701 {
702 if (prettyprint_arrays)
703 {
704 print_spaces_filtered (2 + 2 * recurse, stream);
705 }
706 /* If requested, look for the first null char and only print
707 elements up to it. */
708 if (stop_print_at_null)
709 {
710 int temp_len;
711
712 /* Look for a NULL char. */
713 for (temp_len = 0;
714 temp_len < len && temp_len < print_max
715 && char_at (valaddr, temp_len, eltlen) != 0;
716 temp_len += 1);
717 len = temp_len;
718 }
719
720 printstr (stream, valaddr, len, 0, eltlen);
721 }
722 else
723 {
724 len = 0;
725 fprintf_filtered (stream, "(");
726 print_optional_low_bound (stream, type);
727 if (TYPE_FIELD_BITSIZE (type, 0) > 0)
728 val_print_packed_array_elements (type, valaddr, 0, stream,
729 format, recurse, pretty);
730 else
731 val_print_array_elements (type, valaddr, address, stream,
732 format, deref_ref, recurse,
733 pretty, 0);
734 fprintf_filtered (stream, ")");
735 }
736 gdb_flush (stream);
737 return len;
738 }
739
740 case TYPE_CODE_REF:
741 elttype = check_typedef (TYPE_TARGET_TYPE (type));
742 if (addressprint)
743 {
744 fprintf_filtered (stream, "@");
745 /* Extract an address, assume that the address is unsigned. */
746 print_address_numeric
747 (extract_unsigned_integer (valaddr,
748 TARGET_PTR_BIT / HOST_CHAR_BIT),
749 1, stream);
750 if (deref_ref)
751 fputs_filtered (": ", stream);
752 }
753 /* De-reference the reference */
754 if (deref_ref)
755 {
756 if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
757 {
758 LONGEST deref_val_int = (LONGEST)
759 unpack_pointer (lookup_pointer_type (builtin_type_void),
760 valaddr);
761 if (deref_val_int != 0)
762 {
763 struct value *deref_val =
764 ada_value_ind (value_from_longest
765 (lookup_pointer_type (elttype),
766 deref_val_int));
767 val_print (VALUE_TYPE (deref_val),
768 VALUE_CONTENTS (deref_val), 0,
769 VALUE_ADDRESS (deref_val), stream, format,
770 deref_ref, recurse + 1, pretty);
771 }
772 else
773 fputs_filtered ("(null)", stream);
774 }
775 else
776 fputs_filtered ("???", stream);
777 }
778 break;
779 }
780 return 0;
781 }
782
783 static int
print_variant_part(struct type * type,int field_num,char * valaddr,struct ui_file * stream,int format,int recurse,enum val_prettyprint pretty,int comma_needed,struct type * outer_type,char * outer_valaddr)784 print_variant_part (struct type *type, int field_num, char *valaddr,
785 struct ui_file *stream, int format, int recurse,
786 enum val_prettyprint pretty, int comma_needed,
787 struct type *outer_type, char *outer_valaddr)
788 {
789 struct type *var_type = TYPE_FIELD_TYPE (type, field_num);
790 int which = ada_which_variant_applies (var_type, outer_type, outer_valaddr);
791
792 if (which < 0)
793 return 0;
794 else
795 return print_field_values
796 (TYPE_FIELD_TYPE (var_type, which),
797 valaddr + TYPE_FIELD_BITPOS (type, field_num) / HOST_CHAR_BIT
798 + TYPE_FIELD_BITPOS (var_type, which) / HOST_CHAR_BIT,
799 stream, format, recurse, pretty,
800 comma_needed, outer_type, outer_valaddr);
801 }
802
803 int
ada_value_print(struct value * val0,struct ui_file * stream,int format,enum val_prettyprint pretty)804 ada_value_print (struct value *val0, struct ui_file *stream, int format,
805 enum val_prettyprint pretty)
806 {
807 char *valaddr = VALUE_CONTENTS (val0);
808 CORE_ADDR address = VALUE_ADDRESS (val0) + VALUE_OFFSET (val0);
809 struct type *type =
810 ada_to_fixed_type (VALUE_TYPE (val0), valaddr, address, NULL);
811 struct value *val =
812 value_from_contents_and_address (type, valaddr, address);
813
814 /* If it is a pointer, indicate what it points to. */
815 if (TYPE_CODE (type) == TYPE_CODE_PTR || TYPE_CODE (type) == TYPE_CODE_REF)
816 {
817 /* Hack: remove (char *) for char strings. Their
818 type is indicated by the quoted string anyway. */
819 if (TYPE_CODE (type) == TYPE_CODE_PTR &&
820 TYPE_LENGTH (TYPE_TARGET_TYPE (type)) == sizeof (char) &&
821 TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_INT &&
822 !TYPE_UNSIGNED (TYPE_TARGET_TYPE (type)))
823 {
824 /* Print nothing */
825 }
826 else
827 {
828 fprintf_filtered (stream, "(");
829 type_print (type, "", stream, -1);
830 fprintf_filtered (stream, ") ");
831 }
832 }
833 else if (ada_is_array_descriptor (type))
834 {
835 fprintf_filtered (stream, "(");
836 type_print (type, "", stream, -1);
837 fprintf_filtered (stream, ") ");
838 }
839 else if (ada_is_bogus_array_descriptor (type))
840 {
841 fprintf_filtered (stream, "(");
842 type_print (type, "", stream, -1);
843 fprintf_filtered (stream, ") (...?)");
844 return 0;
845 }
846 return (val_print (type, VALUE_CONTENTS (val), 0, address,
847 stream, format, 1, 0, pretty));
848 }
849
850 static void
print_record(struct type * type,char * valaddr,struct ui_file * stream,int format,int recurse,enum val_prettyprint pretty)851 print_record (struct type *type, char *valaddr, struct ui_file *stream,
852 int format, int recurse, enum val_prettyprint pretty)
853 {
854 CHECK_TYPEDEF (type);
855
856 fprintf_filtered (stream, "(");
857
858 if (print_field_values (type, valaddr, stream, format, recurse, pretty,
859 0, type, valaddr) != 0 && pretty)
860 {
861 fprintf_filtered (stream, "\n");
862 print_spaces_filtered (2 * recurse, stream);
863 }
864
865 fprintf_filtered (stream, ")");
866 }
867
868 /* Print out fields of value at VALADDR having structure type TYPE.
869
870 TYPE, VALADDR, STREAM, FORMAT, RECURSE, and PRETTY have the
871 same meanings as in ada_print_value and ada_val_print.
872
873 OUTER_TYPE and OUTER_VALADDR give type and address of enclosing record
874 (used to get discriminant values when printing variant parts).
875
876 COMMA_NEEDED is 1 if fields have been printed at the current recursion
877 level, so that a comma is needed before any field printed by this
878 call.
879
880 Returns 1 if COMMA_NEEDED or any fields were printed. */
881
882 static int
print_field_values(struct type * type,char * valaddr,struct ui_file * stream,int format,int recurse,enum val_prettyprint pretty,int comma_needed,struct type * outer_type,char * outer_valaddr)883 print_field_values (struct type *type, char *valaddr, struct ui_file *stream,
884 int format, int recurse, enum val_prettyprint pretty,
885 int comma_needed, struct type *outer_type,
886 char *outer_valaddr)
887 {
888 int i, len;
889
890 len = TYPE_NFIELDS (type);
891
892 for (i = 0; i < len; i += 1)
893 {
894 if (ada_is_ignored_field (type, i))
895 continue;
896
897 if (ada_is_wrapper_field (type, i))
898 {
899 comma_needed =
900 print_field_values (TYPE_FIELD_TYPE (type, i),
901 valaddr
902 + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
903 stream, format, recurse, pretty,
904 comma_needed, type, valaddr);
905 continue;
906 }
907 else if (ada_is_variant_part (type, i))
908 {
909 comma_needed =
910 print_variant_part (type, i, valaddr,
911 stream, format, recurse, pretty, comma_needed,
912 outer_type, outer_valaddr);
913 continue;
914 }
915
916 if (comma_needed)
917 fprintf_filtered (stream, ", ");
918 comma_needed = 1;
919
920 if (pretty)
921 {
922 fprintf_filtered (stream, "\n");
923 print_spaces_filtered (2 + 2 * recurse, stream);
924 }
925 else
926 {
927 wrap_here (n_spaces (2 + 2 * recurse));
928 }
929 if (inspect_it)
930 {
931 if (TYPE_CODE (TYPE_FIELD_TYPE (type, i)) == TYPE_CODE_PTR)
932 fputs_filtered ("\"( ptr \"", stream);
933 else
934 fputs_filtered ("\"( nodef \"", stream);
935 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
936 language_cplus, DMGL_NO_OPTS);
937 fputs_filtered ("\" \"", stream);
938 fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
939 language_cplus, DMGL_NO_OPTS);
940 fputs_filtered ("\") \"", stream);
941 }
942 else
943 {
944 annotate_field_begin (TYPE_FIELD_TYPE (type, i));
945 fprintf_filtered (stream, "%.*s",
946 ada_name_prefix_len (TYPE_FIELD_NAME (type, i)),
947 TYPE_FIELD_NAME (type, i));
948 annotate_field_name_end ();
949 fputs_filtered (" => ", stream);
950 annotate_field_value ();
951 }
952
953 if (TYPE_FIELD_PACKED (type, i))
954 {
955 struct value *v;
956
957 /* Bitfields require special handling, especially due to byte
958 order problems. */
959 if (TYPE_CPLUS_SPECIFIC (type) != NULL
960 && TYPE_FIELD_IGNORE (type, i))
961 {
962 fputs_filtered ("<optimized out or zero length>", stream);
963 }
964 else
965 {
966 int bit_pos = TYPE_FIELD_BITPOS (type, i);
967 int bit_size = TYPE_FIELD_BITSIZE (type, i);
968
969 adjust_type_signedness (TYPE_FIELD_TYPE (type, i));
970 v = ada_value_primitive_packed_val (NULL, valaddr,
971 bit_pos / HOST_CHAR_BIT,
972 bit_pos % HOST_CHAR_BIT,
973 bit_size,
974 TYPE_FIELD_TYPE (type, i));
975 val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0, 0,
976 stream, format, 0, recurse + 1, pretty);
977 }
978 }
979 else
980 ada_val_print (TYPE_FIELD_TYPE (type, i),
981 valaddr + TYPE_FIELD_BITPOS (type, i) / HOST_CHAR_BIT,
982 0, 0, stream, format, 0, recurse + 1, pretty);
983 annotate_field_end ();
984 }
985
986 return comma_needed;
987 }
988