1 /* Support for printing Chill values for GDB, the GNU debugger.
2 Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994
3 Free Software Foundation, Inc.
5 This file is part of GDB.
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.
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.
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
26 #include "expression.h"
30 #include "c-lang.h" /* For c_val_print */
31 #include "typeprint.h"
36 chill_print_value_fields
PARAMS ((struct type
*, char *, GDB_FILE
*, int, int,
37 enum val_prettyprint
, struct type
**));
40 chill_print_type_scalar
PARAMS ((struct type
*, LONGEST
, GDB_FILE
*));
43 chill_val_print_array_elements
PARAMS ((struct type
*, char *, CORE_ADDR
, GDB_FILE
*,
44 int, int, int, enum val_prettyprint
));
47 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
48 Used to print data from type structures in a specified type. For example,
49 array bounds may be characters or booleans in some languages, and this
50 allows the ranges to be printed in their "natural" form rather than as
51 decimal integer values. */
54 chill_print_type_scalar (type
, val
, stream
)
59 switch (TYPE_CODE (type
))
62 if (TYPE_TARGET_TYPE (type
))
64 chill_print_type_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
71 case TYPE_CODE_STRUCT
:
79 case TYPE_CODE_STRING
:
80 case TYPE_CODE_BITSTRING
:
82 case TYPE_CODE_MEMBER
:
83 case TYPE_CODE_METHOD
:
87 case TYPE_CODE_COMPLEX
:
88 case TYPE_CODE_TYPEDEF
:
92 print_type_scalar (type
, val
, stream
);
95 /* Print the elements of an array.
96 Similar to val_print_array_elements, but prints
97 element indexes (in Chill syntax). */
100 chill_val_print_array_elements (type
, valaddr
, address
, stream
,
101 format
, deref_ref
, recurse
, pretty
)
109 enum val_prettyprint pretty
;
112 unsigned int things_printed
= 0;
114 struct type
*elttype
;
115 struct type
*range_type
= TYPE_FIELD_TYPE (type
, 0);
116 struct type
*index_type
= TYPE_TARGET_TYPE (range_type
);
118 /* Position of the array element we are examining to see
119 whether it is repeated. */
121 /* Number of repetitions we have detected so far. */
123 LONGEST low_bound
= TYPE_FIELD_BITPOS (range_type
, 0);
125 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
126 eltlen
= TYPE_LENGTH (elttype
);
127 len
= TYPE_LENGTH (type
) / eltlen
;
129 annotate_array_section_begin (i
, elttype
);
131 for (; i
< len
&& things_printed
< print_max
; i
++)
135 if (prettyprint_arrays
)
137 fprintf_filtered (stream
, ",\n");
138 print_spaces_filtered (2 + 2 * recurse
, stream
);
142 fprintf_filtered (stream
, ", ");
145 wrap_here (n_spaces (2 + 2 * recurse
));
149 while ((rep1
< len
) &&
150 !memcmp (valaddr
+ i
* eltlen
, valaddr
+ rep1
* eltlen
, eltlen
))
156 fputs_filtered ("(", stream
);
157 chill_print_type_scalar (index_type
, low_bound
+ i
, stream
);
160 fputs_filtered (":", stream
);
161 chill_print_type_scalar (index_type
, low_bound
+ i
+ reps
- 1,
163 fputs_filtered ("): ", stream
);
164 val_print (elttype
, valaddr
+ i
* eltlen
, 0, 0, stream
, format
,
165 deref_ref
, recurse
+ 1, pretty
);
172 fputs_filtered ("): ", stream
);
173 val_print (elttype
, valaddr
+ i
* eltlen
, 0, 0, stream
, format
,
174 deref_ref
, recurse
+ 1, pretty
);
179 annotate_array_section_end ();
182 fprintf_filtered (stream
, "...");
186 /* Print data of type TYPE located at VALADDR (within GDB), which came from
187 the inferior at address ADDRESS, onto stdio stream STREAM according to
188 FORMAT (a letter or 0 for natural format). The data at VALADDR is in
191 If the data are a string pointer, returns the number of string characters
194 If DEREF_REF is nonzero, then dereference references, otherwise just print
197 The PRETTY parameter controls prettyprinting. */
200 chill_val_print (type
, valaddr
, embedded_offset
, address
,
201 stream
, format
, deref_ref
, recurse
, pretty
)
210 enum val_prettyprint pretty
;
213 unsigned int i
= 0; /* Number of characters printed. */
214 struct type
*elttype
;
217 CHECK_TYPEDEF (type
);
219 switch (TYPE_CODE (type
))
221 case TYPE_CODE_ARRAY
:
222 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0)
224 if (prettyprint_arrays
)
226 print_spaces_filtered (2 + 2 * recurse
, stream
);
228 fprintf_filtered (stream
, "[");
229 chill_val_print_array_elements (type
, valaddr
, address
, stream
,
230 format
, deref_ref
, recurse
, pretty
);
231 fprintf_filtered (stream
, "]");
235 error ("unimplemented in chill_val_print; unspecified array length");
240 format
= format
? format
: output_format
;
243 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
247 val_print_type_code_int (type
, valaddr
, stream
);
252 format
= format
? format
: output_format
;
255 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
259 LA_PRINT_CHAR ((unsigned char) unpack_long (type
, valaddr
),
267 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
271 print_floating (valaddr
, type
, stream
);
276 format
= format
? format
: output_format
;
279 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
283 /* FIXME: Why is this using builtin_type_chill_bool not type? */
284 val
= unpack_long (builtin_type_chill_bool
, valaddr
);
285 fprintf_filtered (stream
, val
? "TRUE" : "FALSE");
289 case TYPE_CODE_UNDEF
:
290 /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
291 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
292 and no complete type for struct foo in that file. */
293 fprintf_filtered (stream
, "<incomplete type>");
297 if (format
&& format
!= 's')
299 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
302 addr
= unpack_pointer (type
, valaddr
);
303 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
305 /* We assume a NULL pointer is all zeros ... */
308 fputs_filtered ("NULL", stream
);
312 if (TYPE_CODE (elttype
) == TYPE_CODE_FUNC
)
314 /* Try to print what function it points to. */
315 print_address_demangle (addr
, stream
, demangle
);
316 /* Return value is irrelevant except for string pointers. */
319 if (addressprint
&& format
!= 's')
321 print_address_numeric (addr
, 1, stream
);
324 /* For a pointer to char or unsigned char, also print the string
325 pointed to, unless pointer is null. */
326 if (TYPE_LENGTH (elttype
) == 1
327 && TYPE_CODE (elttype
) == TYPE_CODE_CHAR
328 && (format
== 0 || format
== 's')
330 && /* If print_max is UINT_MAX, the alloca below will fail.
331 In that case don't try to print the string. */
332 print_max
< UINT_MAX
)
333 i
= val_print_string (addr
, -1, TYPE_LENGTH (elttype
), stream
);
335 /* Return number of characters printed, plus one for the
336 terminating null if we have "reached the end". */
337 return (i
+ (print_max
&& i
!= print_max
));
340 case TYPE_CODE_STRING
:
341 i
= TYPE_LENGTH (type
);
342 LA_PRINT_STRING (stream
, valaddr
, i
, 1, 0);
343 /* Return number of characters printed, plus one for the terminating
344 null if we have "reached the end". */
345 return (i
+ (print_max
&& i
!= print_max
));
348 case TYPE_CODE_BITSTRING
:
350 elttype
= TYPE_INDEX_TYPE (type
);
351 CHECK_TYPEDEF (elttype
);
352 if (TYPE_FLAGS (elttype
) & TYPE_FLAG_STUB
)
354 fprintf_filtered (stream
, "<incomplete type>");
359 struct type
*range
= elttype
;
360 LONGEST low_bound
, high_bound
;
362 int is_bitstring
= TYPE_CODE (type
) == TYPE_CODE_BITSTRING
;
366 fputs_filtered ("B'", stream
);
368 fputs_filtered ("[", stream
);
370 i
= get_discrete_bounds (range
, &low_bound
, &high_bound
);
374 fputs_filtered ("<error value>", stream
);
378 for (i
= low_bound
; i
<= high_bound
; i
++)
380 int element
= value_bit_index (type
, valaddr
, i
);
384 goto maybe_bad_bstring
;
387 fprintf_filtered (stream
, "%d", element
);
391 fputs_filtered (", ", stream
);
392 chill_print_type_scalar (range
, (LONGEST
) i
, stream
);
395 /* Look for a continuous range of true elements. */
396 if (i
+1 <= high_bound
&& value_bit_index (type
, valaddr
, ++i
))
398 int j
= i
; /* j is the upper bound so far of the range */
399 fputs_filtered (":", stream
);
400 while (i
+1 <= high_bound
401 && value_bit_index (type
, valaddr
, ++i
))
403 chill_print_type_scalar (range
, (LONGEST
) j
, stream
);
409 fputs_filtered ("'", stream
);
411 fputs_filtered ("]", stream
);
415 case TYPE_CODE_STRUCT
:
416 if (chill_varying_type (type
))
418 struct type
*inner
= check_typedef (TYPE_FIELD_TYPE (type
, 1));
419 long length
= unpack_long (TYPE_FIELD_TYPE (type
, 0), valaddr
);
420 char *data_addr
= valaddr
+ TYPE_FIELD_BITPOS (type
, 1) / 8;
422 switch (TYPE_CODE (inner
))
424 case TYPE_CODE_STRING
:
425 if (length
> TYPE_LENGTH (type
) - 2)
427 fprintf_filtered (stream
,
428 "<dynamic length %ld > static length %d> *invalid*",
429 length
, TYPE_LENGTH (type
));
431 /* Don't print the string; doing so might produce a
435 LA_PRINT_STRING (stream
, data_addr
, length
, 1, 0);
441 chill_print_value_fields (type
, valaddr
, stream
, format
, recurse
, pretty
,
448 fprintf_filtered (stream
, "LOC(");
449 print_address_numeric
450 (extract_address (valaddr
, TARGET_PTR_BIT
/ HOST_CHAR_BIT
),
453 fprintf_filtered (stream
, ")");
455 fputs_filtered (": ", stream
);
457 /* De-reference the reference. */
460 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_UNDEF
)
462 value_ptr deref_val
=
464 (TYPE_TARGET_TYPE (type
),
465 unpack_pointer (lookup_pointer_type (builtin_type_void
),
468 val_print (VALUE_TYPE (deref_val
),
469 VALUE_CONTENTS (deref_val
),
471 VALUE_ADDRESS (deref_val
), stream
, format
,
472 deref_ref
, recurse
+ 1, pretty
);
475 fputs_filtered ("???", stream
);
480 c_val_print (type
, valaddr
, 0, address
, stream
, format
,
481 deref_ref
, recurse
, pretty
);
484 case TYPE_CODE_RANGE
:
485 if (TYPE_TARGET_TYPE (type
))
486 chill_val_print (TYPE_TARGET_TYPE (type
), valaddr
, 0, address
, stream
,
487 format
, deref_ref
, recurse
, pretty
);
490 case TYPE_CODE_MEMBER
:
491 case TYPE_CODE_UNION
:
494 case TYPE_CODE_ERROR
:
496 /* Let's defer printing to the C printer, rather than
497 print an error message. FIXME! */
498 c_val_print (type
, valaddr
, 0, address
, stream
, format
,
499 deref_ref
, recurse
, pretty
);
505 /* Mutually recursive subroutines of cplus_print_value and c_val_print to
506 print out a structure's fields: cp_print_value_fields and cplus_print_value.
508 TYPE, VALADDR, STREAM, RECURSE, and PRETTY have the
509 same meanings as in cplus_print_value and c_val_print.
511 DONT_PRINT is an array of baseclass types that we
512 should not print, or zero if called from top level. */
515 chill_print_value_fields (type
, valaddr
, stream
, format
, recurse
, pretty
,
522 enum val_prettyprint pretty
;
523 struct type
**dont_print
;
528 CHECK_TYPEDEF (type
);
530 fprintf_filtered (stream
, "[");
531 len
= TYPE_NFIELDS (type
);
534 fprintf_filtered (stream
, "<No data fields>");
538 for (i
= 0; i
< len
; i
++)
542 fprintf_filtered (stream
, ", ");
547 fprintf_filtered (stream
, "\n");
548 print_spaces_filtered (2 + 2 * recurse
, stream
);
552 wrap_here (n_spaces (2 + 2 * recurse
));
554 fputs_filtered (".", stream
);
555 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
556 language_chill
, DMGL_NO_OPTS
);
557 fputs_filtered (": ", stream
);
558 if (TYPE_FIELD_PACKED (type
, i
))
562 /* Bitfields require special handling, especially due to byte
564 v
= value_from_longest (TYPE_FIELD_TYPE (type
, i
),
565 unpack_field_as_long (type
, valaddr
, i
));
567 chill_val_print (TYPE_FIELD_TYPE (type
, i
), VALUE_CONTENTS (v
), 0, 0,
568 stream
, format
, 0, recurse
+ 1, pretty
);
572 chill_val_print (TYPE_FIELD_TYPE (type
, i
),
573 valaddr
+ TYPE_FIELD_BITPOS (type
, i
) / 8, 0,
574 0, stream
, format
, 0, recurse
+ 1, pretty
);
579 fprintf_filtered (stream
, "\n");
580 print_spaces_filtered (2 * recurse
, stream
);
583 fprintf_filtered (stream
, "]");
587 chill_value_print (val
, stream
, format
, pretty
)
591 enum val_prettyprint pretty
;
593 struct type
*type
= VALUE_TYPE (val
);
594 struct type
*real_type
= check_typedef (type
);
596 /* If it is a pointer, indicate what it points to.
598 Print type also if it is a reference. */
600 if (TYPE_CODE (real_type
) == TYPE_CODE_PTR
||
601 TYPE_CODE (real_type
) == TYPE_CODE_REF
)
603 char *valaddr
= VALUE_CONTENTS (val
);
604 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
605 if (TYPE_CODE (type
) != TYPE_CODE_PTR
|| addr
!= 0)
608 char *name
= TYPE_NAME (type
);
610 fputs_filtered (name
, stream
);
611 else if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_VOID
)
612 fputs_filtered ("PTR", stream
);
615 fprintf_filtered (stream
, "(");
616 type_print (type
, "", stream
, -1);
617 fprintf_filtered (stream
, ")");
619 fprintf_filtered (stream
, "(");
620 i
= val_print (type
, valaddr
, 0, VALUE_ADDRESS (val
),
621 stream
, format
, 1, 0, pretty
);
622 fprintf_filtered (stream
, ")");
626 return (val_print (type
, VALUE_CONTENTS (val
), 0,
627 VALUE_ADDRESS (val
), stream
, format
, 1, 0, pretty
));