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., 675 Mass Ave, Cambridge, MA 02139, USA. */
26 #include "expression.h"
30 #include "c-lang.h" /* For c_val_print */
31 #include "typeprint.h"
35 chill_print_value_fields
PARAMS ((struct type
*, char *, GDB_FILE
*, int, int,
36 enum val_prettyprint
, struct type
**));
39 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
40 Used to print data from type structures in a specified type. For example,
41 array bounds may be characters or booleans in some languages, and this
42 allows the ranges to be printed in their "natural" form rather than as
43 decimal integer values. */
46 chill_print_type_scalar (type
, val
, stream
)
51 switch (TYPE_CODE (type
))
54 if (TYPE_TARGET_TYPE (type
))
56 chill_print_type_scalar (TYPE_TARGET_TYPE (type
), val
, stream
);
60 print_type_scalar (type
, val
, stream
);
63 /* Print the elements of an array.
64 Similar to val_print_array_elements, but prints
65 element indexes (in Chill syntax). */
68 chill_val_print_array_elements (type
, valaddr
, address
, stream
,
69 format
, deref_ref
, recurse
, pretty
)
77 enum val_prettyprint pretty
;
80 unsigned int things_printed
= 0;
83 struct type
*range_type
= TYPE_FIELD_TYPE (type
, 0);
84 struct type
*index_type
= TYPE_TARGET_TYPE (range_type
);
86 /* Position of the array element we are examining to see
87 whether it is repeated. */
89 /* Number of repetitions we have detected so far. */
91 LONGEST low_bound
= TYPE_FIELD_BITPOS (range_type
, 0);
92 LONGEST high_bound
= TYPE_FIELD_BITPOS (range_type
, 1);
94 elttype
= TYPE_TARGET_TYPE (type
);
95 eltlen
= TYPE_LENGTH (elttype
);
96 len
= TYPE_LENGTH (type
) / eltlen
;
98 annotate_array_section_begin (i
, elttype
);
100 for (; i
< len
&& things_printed
< print_max
; i
++)
104 if (prettyprint_arrays
)
106 fprintf_filtered (stream
, ",\n");
107 print_spaces_filtered (2 + 2 * recurse
, stream
);
111 fprintf_filtered (stream
, ", ");
114 wrap_here (n_spaces (2 + 2 * recurse
));
118 while ((rep1
< len
) &&
119 !memcmp (valaddr
+ i
* eltlen
, valaddr
+ rep1
* eltlen
, eltlen
))
125 fputs_filtered ("(", stream
);
126 chill_print_type_scalar (index_type
, low_bound
+ i
, stream
);
129 fputs_filtered (":", stream
);
130 chill_print_type_scalar (index_type
, low_bound
+ i
+ reps
- 1,
132 fputs_filtered ("): ", stream
);
133 val_print (elttype
, valaddr
+ i
* eltlen
, 0, stream
, format
,
134 deref_ref
, recurse
+ 1, pretty
);
141 fputs_filtered ("): ", stream
);
142 val_print (elttype
, valaddr
+ i
* eltlen
, 0, stream
, format
,
143 deref_ref
, recurse
+ 1, pretty
);
148 annotate_array_section_end ();
151 fprintf_filtered (stream
, "...");
155 /* Print data of type TYPE located at VALADDR (within GDB), which came from
156 the inferior at address ADDRESS, onto stdio stream STREAM according to
157 FORMAT (a letter or 0 for natural format). The data at VALADDR is in
160 If the data are a string pointer, returns the number of string characters
163 If DEREF_REF is nonzero, then dereference references, otherwise just print
166 The PRETTY parameter controls prettyprinting. */
169 chill_val_print (type
, valaddr
, address
, stream
, format
, deref_ref
, recurse
,
178 enum val_prettyprint pretty
;
181 unsigned int i
= 0; /* Number of characters printed. */
182 struct type
*elttype
;
185 switch (TYPE_CODE (type
))
187 case TYPE_CODE_ARRAY
:
188 if (TYPE_LENGTH (type
) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type
)) > 0)
190 if (prettyprint_arrays
)
192 print_spaces_filtered (2 + 2 * recurse
, stream
);
194 fprintf_filtered (stream
, "[");
195 chill_val_print_array_elements (type
, valaddr
, address
, stream
,
196 format
, deref_ref
, recurse
, pretty
);
197 fprintf_filtered (stream
, "]");
201 error ("unimplemented in chill_val_print; unspecified array length");
206 format
= format
? format
: output_format
;
209 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
213 val_print_type_code_int (type
, valaddr
, stream
);
218 format
= format
? format
: output_format
;
221 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
225 LA_PRINT_CHAR ((unsigned char) unpack_long (type
, valaddr
),
233 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
237 print_floating (valaddr
, type
, stream
);
242 format
= format
? format
: output_format
;
245 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
249 /* FIXME: Why is this using builtin_type_chill_bool not type? */
250 val
= unpack_long (builtin_type_chill_bool
, valaddr
);
251 fprintf_filtered (stream
, val
? "TRUE" : "FALSE");
255 case TYPE_CODE_UNDEF
:
256 /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
257 dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
258 and no complete type for struct foo in that file. */
259 fprintf_filtered (stream
, "<incomplete type>");
263 if (format
&& format
!= 's')
265 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
268 addr
= unpack_pointer (type
, valaddr
);
269 elttype
= TYPE_TARGET_TYPE (type
);
271 /* We assume a NULL pointer is all zeros ... */
274 fputs_filtered ("NULL", stream
);
278 if (TYPE_CODE (elttype
) == TYPE_CODE_FUNC
)
280 /* Try to print what function it points to. */
281 print_address_demangle (addr
, stream
, demangle
);
282 /* Return value is irrelevant except for string pointers. */
285 if (addressprint
&& format
!= 's')
287 print_address_numeric (addr
, 1, stream
);
290 /* For a pointer to char or unsigned char, also print the string
291 pointed to, unless pointer is null. */
292 if (TYPE_LENGTH (elttype
) == 1
293 && TYPE_CODE (elttype
) == TYPE_CODE_CHAR
294 && (format
== 0 || format
== 's')
296 && /* If print_max is UINT_MAX, the alloca below will fail.
297 In that case don't try to print the string. */
298 print_max
< UINT_MAX
)
300 i
= val_print_string (addr
, 0, stream
);
302 /* Return number of characters printed, plus one for the
303 terminating null if we have "reached the end". */
304 return (i
+ (print_max
&& i
!= print_max
));
307 case TYPE_CODE_STRING
:
308 if (format
&& format
!= 's')
310 print_scalar_formatted (valaddr
, type
, format
, 0, stream
);
313 i
= TYPE_LENGTH (type
);
314 LA_PRINT_STRING (stream
, valaddr
, i
, 0);
315 /* Return number of characters printed, plus one for the terminating
316 null if we have "reached the end". */
317 return (i
+ (print_max
&& i
!= print_max
));
320 case TYPE_CODE_BITSTRING
:
322 elttype
= TYPE_INDEX_TYPE (type
);
323 check_stub_type (elttype
);
324 if (TYPE_FLAGS (elttype
) & TYPE_FLAG_STUB
)
326 fprintf_filtered (stream
, "<incomplete type>");
331 struct type
*range
= elttype
;
332 int low_bound
= TYPE_LOW_BOUND (range
);
333 int high_bound
= TYPE_HIGH_BOUND (range
);
335 int is_bitstring
= TYPE_CODE (type
) == TYPE_CODE_BITSTRING
;
339 fputs_filtered ("B'", stream
);
341 fputs_filtered ("[", stream
);
342 for (i
= low_bound
; i
<= high_bound
; i
++)
344 int element
= value_bit_index (type
, valaddr
, i
);
346 fprintf_filtered (stream
, "%d", element
);
350 fputs_filtered (", ", stream
);
351 chill_print_type_scalar (range
, i
, stream
);
354 /* Look for a continuous range of true elements. */
355 if (i
+1 <= high_bound
&& value_bit_index (type
, valaddr
, ++i
))
357 int j
= i
; /* j is the upper bound so far of the range */
358 fputs_filtered (":", stream
);
359 while (i
+1 <= high_bound
360 && value_bit_index (type
, valaddr
, ++i
))
362 chill_print_type_scalar (range
, j
, stream
);
367 fputs_filtered ("'", stream
);
369 fputs_filtered ("]", stream
);
373 case TYPE_CODE_STRUCT
:
374 if (chill_is_varying_struct (type
))
376 struct type
*inner
= TYPE_FIELD_TYPE (type
, 1);
377 long length
= unpack_long (TYPE_FIELD_TYPE (type
, 0), valaddr
);
378 char *data_addr
= valaddr
+ TYPE_FIELD_BITPOS (type
, 1) / 8;
380 switch (TYPE_CODE (inner
))
382 case TYPE_CODE_STRING
:
383 if (length
> TYPE_LENGTH (type
))
385 fprintf_filtered (stream
,
386 "<dynamic length %d > static length %d>",
387 length
, TYPE_LENGTH (type
));
389 LA_PRINT_STRING (stream
, data_addr
, length
, 0);
395 chill_print_value_fields (type
, valaddr
, stream
, format
, recurse
, pretty
,
402 fprintf_filtered (stream
, "LOC(");
403 print_address_numeric
404 (extract_address (valaddr
, TARGET_PTR_BIT
/ HOST_CHAR_BIT
),
407 fprintf_filtered (stream
, ")");
409 fputs_filtered (": ", stream
);
411 /* De-reference the reference. */
414 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_UNDEF
)
416 value_ptr deref_val
=
418 (TYPE_TARGET_TYPE (type
),
419 unpack_pointer (lookup_pointer_type (builtin_type_void
),
421 val_print (VALUE_TYPE (deref_val
),
422 VALUE_CONTENTS (deref_val
),
423 VALUE_ADDRESS (deref_val
), stream
, format
,
424 deref_ref
, recurse
+ 1, pretty
);
427 fputs_filtered ("???", stream
);
432 c_val_print (type
, valaddr
, address
, stream
, format
,
433 deref_ref
, recurse
, pretty
);
436 case TYPE_CODE_RANGE
:
437 if (TYPE_TARGET_TYPE (type
))
438 chill_val_print (TYPE_TARGET_TYPE (type
), valaddr
, address
, stream
,
439 format
, deref_ref
, recurse
, pretty
);
442 case TYPE_CODE_MEMBER
:
443 case TYPE_CODE_UNION
:
446 case TYPE_CODE_ERROR
:
448 /* Let's defer printing to the C printer, rather than
449 print an error message. FIXME! */
450 c_val_print (type
, valaddr
, address
, stream
, format
,
451 deref_ref
, recurse
, pretty
);
457 /* Mutually recursive subroutines of cplus_print_value and c_val_print to
458 print out a structure's fields: cp_print_value_fields and cplus_print_value.
460 TYPE, VALADDR, STREAM, RECURSE, and PRETTY have the
461 same meanings as in cplus_print_value and c_val_print.
463 DONT_PRINT is an array of baseclass types that we
464 should not print, or zero if called from top level. */
467 chill_print_value_fields (type
, valaddr
, stream
, format
, recurse
, pretty
,
474 enum val_prettyprint pretty
;
475 struct type
**dont_print
;
480 check_stub_type (type
);
482 fprintf_filtered (stream
, "[");
483 len
= TYPE_NFIELDS (type
);
486 fprintf_filtered (stream
, "<No data fields>");
490 for (i
= 0; i
< len
; i
++)
494 fprintf_filtered (stream
, ", ");
499 fprintf_filtered (stream
, "\n");
500 print_spaces_filtered (2 + 2 * recurse
, stream
);
504 wrap_here (n_spaces (2 + 2 * recurse
));
506 fputs_filtered (".", stream
);
507 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
508 language_chill
, DMGL_NO_OPTS
);
509 fputs_filtered (": ", stream
);
510 if (TYPE_FIELD_PACKED (type
, i
))
514 /* Bitfields require special handling, especially due to byte
516 v
= value_from_longest (TYPE_FIELD_TYPE (type
, i
),
517 unpack_field_as_long (type
, valaddr
, i
));
519 chill_val_print (TYPE_FIELD_TYPE (type
, i
), VALUE_CONTENTS (v
), 0,
520 stream
, format
, 0, recurse
+ 1, pretty
);
524 chill_val_print (TYPE_FIELD_TYPE (type
, i
),
525 valaddr
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
526 0, stream
, format
, 0, recurse
+ 1, pretty
);
531 fprintf_filtered (stream
, "\n");
532 print_spaces_filtered (2 * recurse
, stream
);
535 fprintf_filtered (stream
, "]");
539 chill_value_print (val
, stream
, format
, pretty
)
543 enum val_prettyprint pretty
;
545 /* A "repeated" value really contains several values in a row.
546 They are made by the @ operator.
547 Print such values as if they were arrays. */
549 if (VALUE_REPEATED (val
))
551 register unsigned int n
= VALUE_REPETITIONS (val
);
552 register unsigned int typelen
= TYPE_LENGTH (VALUE_TYPE (val
));
553 fprintf_filtered (stream
, "[");
554 /* Print arrays of characters using string syntax. */
555 if (typelen
== 1 && TYPE_CODE (VALUE_TYPE (val
)) == TYPE_CODE_INT
557 LA_PRINT_STRING (stream
, VALUE_CONTENTS (val
), n
, 0);
560 value_print_array_elements (val
, stream
, format
, pretty
);
562 fprintf_filtered (stream
, "]");
563 return (n
* typelen
);
567 struct type
*type
= VALUE_TYPE (val
);
569 /* If it is a pointer, indicate what it points to.
571 Print type also if it is a reference.
573 C++: if it is a member pointer, we will take care
574 of that when we print it. */
575 if (TYPE_CODE (type
) == TYPE_CODE_PTR
||
576 TYPE_CODE (type
) == TYPE_CODE_REF
)
578 char *valaddr
= VALUE_CONTENTS (val
);
579 CORE_ADDR addr
= unpack_pointer (type
, valaddr
);
580 if (TYPE_CODE (type
) != TYPE_CODE_PTR
|| addr
!= 0)
583 char *name
= TYPE_NAME (type
);
585 fputs_filtered (name
, stream
);
586 else if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_VOID
)
587 fputs_filtered ("PTR", stream
);
590 fprintf_filtered (stream
, "(");
591 type_print (type
, "", stream
, -1);
592 fprintf_filtered (stream
, ")");
594 fprintf_filtered (stream
, "(");
595 i
= val_print (type
, valaddr
, VALUE_ADDRESS (val
),
596 stream
, format
, 1, 0, pretty
);
597 fprintf_filtered (stream
, ")");
601 return (val_print (type
, VALUE_CONTENTS (val
),
602 VALUE_ADDRESS (val
), stream
, format
, 1, 0, pretty
));
This page took 0.049748 seconds and 4 git commands to generate.