1 /* Support for printing Pascal values for GDB, the GNU debugger.
3 Copyright (C) 2000-2020 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 3 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, see <http://www.gnu.org/licenses/>. */
20 /* This file is derived from c-valprint.c */
23 #include "gdb_obstack.h"
26 #include "expression.h"
33 #include "typeprint.h"
39 #include "cp-support.h"
41 #include "gdbsupport/byte-vector.h"
42 #include "cli/cli-style.h"
45 static void pascal_object_print_value_fields (struct type
*, const gdb_byte
*,
47 CORE_ADDR
, struct ui_file
*,
50 const struct value_print_options
*,
53 /* Decorations for Pascal. */
55 static const struct generic_val_print_decorations p_decorations
=
67 /* See val_print for a description of the various parameters of this
68 function; they are identical. */
71 pascal_val_print (struct type
*type
,
72 int embedded_offset
, CORE_ADDR address
,
73 struct ui_file
*stream
, int recurse
,
74 struct value
*original_value
,
75 const struct value_print_options
*options
)
77 struct gdbarch
*gdbarch
= get_type_arch (type
);
78 enum bfd_endian byte_order
= type_byte_order (type
);
79 unsigned int i
= 0; /* Number of characters printed */
83 int length_pos
, length_size
, string_pos
;
84 struct type
*char_type
;
87 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
89 type
= check_typedef (type
);
90 switch (TYPE_CODE (type
))
94 LONGEST low_bound
, high_bound
;
96 if (get_array_bounds (type
, &low_bound
, &high_bound
))
98 len
= high_bound
- low_bound
+ 1;
99 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
100 eltlen
= TYPE_LENGTH (elttype
);
101 if (options
->prettyformat_arrays
)
103 print_spaces_filtered (2 + 2 * recurse
, stream
);
105 /* If 's' format is used, try to print out as string.
106 If no format is given, print as string if element type
107 is of TYPE_CODE_CHAR and element size is 1,2 or 4. */
108 if (options
->format
== 's'
109 || ((eltlen
== 1 || eltlen
== 2 || eltlen
== 4)
110 && TYPE_CODE (elttype
) == TYPE_CODE_CHAR
111 && options
->format
== 0))
113 /* If requested, look for the first null char and only print
114 elements up to it. */
115 if (options
->stop_print_at_null
)
117 unsigned int temp_len
;
119 /* Look for a NULL char. */
121 extract_unsigned_integer (valaddr
+ embedded_offset
+
122 temp_len
* eltlen
, eltlen
,
124 && temp_len
< len
&& temp_len
< options
->print_max
;
129 LA_PRINT_STRING (stream
, TYPE_TARGET_TYPE (type
),
130 valaddr
+ embedded_offset
, len
, NULL
, 0,
136 fprintf_filtered (stream
, "{");
137 /* If this is a virtual function table, print the 0th
138 entry specially, and the rest of the members normally. */
139 if (pascal_object_is_vtbl_ptr_type (elttype
))
142 fprintf_filtered (stream
, "%d vtable entries", len
- 1);
148 val_print_array_elements (type
, embedded_offset
,
149 address
, stream
, recurse
,
150 original_value
, options
, i
);
151 fprintf_filtered (stream
, "}");
155 /* Array of unspecified length: treat like pointer to first elt. */
156 addr
= address
+ embedded_offset
;
158 goto print_unpacked_pointer
;
161 if (options
->format
&& options
->format
!= 's')
163 val_print_scalar_formatted (type
, embedded_offset
,
164 original_value
, options
, 0, stream
);
167 if (options
->vtblprint
&& pascal_object_is_vtbl_ptr_type (type
))
169 /* Print the unmangled name if desired. */
170 /* Print vtable entry - we only get here if we ARE using
171 -fvtable_thunks. (Otherwise, look under TYPE_CODE_STRUCT.) */
172 /* Extract the address, assume that it is unsigned. */
173 addr
= extract_unsigned_integer (valaddr
+ embedded_offset
,
174 TYPE_LENGTH (type
), byte_order
);
175 print_address_demangle (options
, gdbarch
, addr
, stream
, demangle
);
178 check_typedef (TYPE_TARGET_TYPE (type
));
180 addr
= unpack_pointer (type
, valaddr
+ embedded_offset
);
181 print_unpacked_pointer
:
182 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
184 if (TYPE_CODE (elttype
) == TYPE_CODE_FUNC
)
186 /* Try to print what function it points to. */
187 print_address_demangle (options
, gdbarch
, addr
, stream
, demangle
);
191 if (options
->addressprint
&& options
->format
!= 's')
193 fputs_filtered (paddress (gdbarch
, addr
), stream
);
197 /* For a pointer to char or unsigned char, also print the string
198 pointed to, unless pointer is null. */
199 if (((TYPE_LENGTH (elttype
) == 1
200 && (TYPE_CODE (elttype
) == TYPE_CODE_INT
201 || TYPE_CODE (elttype
) == TYPE_CODE_CHAR
))
202 || ((TYPE_LENGTH (elttype
) == 2 || TYPE_LENGTH (elttype
) == 4)
203 && TYPE_CODE (elttype
) == TYPE_CODE_CHAR
))
204 && (options
->format
== 0 || options
->format
== 's')
208 fputs_filtered (" ", stream
);
209 /* No wide string yet. */
210 i
= val_print_string (elttype
, NULL
, addr
, -1, stream
, options
);
212 /* Also for pointers to pascal strings. */
213 /* Note: this is Free Pascal specific:
214 as GDB does not recognize stabs pascal strings
215 Pascal strings are mapped to records
216 with lowercase names PM. */
217 if (is_pascal_string_type (elttype
, &length_pos
, &length_size
,
218 &string_pos
, &char_type
, NULL
)
221 ULONGEST string_length
;
225 fputs_filtered (" ", stream
);
226 buffer
= (gdb_byte
*) xmalloc (length_size
);
227 read_memory (addr
+ length_pos
, buffer
, length_size
);
228 string_length
= extract_unsigned_integer (buffer
, length_size
,
231 i
= val_print_string (char_type
, NULL
,
232 addr
+ string_pos
, string_length
,
235 else if (pascal_object_is_vtbl_member (type
))
237 /* Print vtbl's nicely. */
238 CORE_ADDR vt_address
= unpack_pointer (type
,
239 valaddr
+ embedded_offset
);
240 struct bound_minimal_symbol msymbol
=
241 lookup_minimal_symbol_by_pc (vt_address
);
243 /* If 'symbol_print' is set, we did the work above. */
244 if (!options
->symbol_print
245 && (msymbol
.minsym
!= NULL
)
246 && (vt_address
== BMSYMBOL_VALUE_ADDRESS (msymbol
)))
249 fputs_filtered (" ", stream
);
250 fputs_filtered ("<", stream
);
251 fputs_filtered (msymbol
.minsym
->print_name (), stream
);
252 fputs_filtered (">", stream
);
255 if (vt_address
&& options
->vtblprint
)
257 struct value
*vt_val
;
258 struct symbol
*wsym
= NULL
;
262 fputs_filtered (" ", stream
);
264 if (msymbol
.minsym
!= NULL
)
266 const char *search_name
= msymbol
.minsym
->search_name ();
267 wsym
= lookup_symbol_search_name (search_name
, NULL
,
273 wtype
= SYMBOL_TYPE (wsym
);
277 wtype
= TYPE_TARGET_TYPE (type
);
279 vt_val
= value_at (wtype
, vt_address
);
280 common_val_print (vt_val
, stream
, recurse
+ 1, options
,
282 if (options
->prettyformat
)
284 fprintf_filtered (stream
, "\n");
285 print_spaces_filtered (2 + 2 * recurse
, stream
);
294 case TYPE_CODE_FLAGS
:
296 case TYPE_CODE_RANGE
:
300 case TYPE_CODE_ERROR
:
301 case TYPE_CODE_UNDEF
:
304 generic_val_print (type
, embedded_offset
, address
,
305 stream
, recurse
, original_value
, options
,
309 case TYPE_CODE_UNION
:
310 if (recurse
&& !options
->unionprint
)
312 fprintf_filtered (stream
, "{...}");
316 case TYPE_CODE_STRUCT
:
317 if (options
->vtblprint
&& pascal_object_is_vtbl_ptr_type (type
))
319 /* Print the unmangled name if desired. */
320 /* Print vtable entry - we only get here if NOT using
321 -fvtable_thunks. (Otherwise, look under TYPE_CODE_PTR.) */
322 /* Extract the address, assume that it is unsigned. */
323 print_address_demangle
325 extract_unsigned_integer (valaddr
+ embedded_offset
326 + TYPE_FIELD_BITPOS (type
,
327 VTBL_FNADDR_OFFSET
) / 8,
328 TYPE_LENGTH (TYPE_FIELD_TYPE (type
,
329 VTBL_FNADDR_OFFSET
)),
335 if (is_pascal_string_type (type
, &length_pos
, &length_size
,
336 &string_pos
, &char_type
, NULL
))
338 len
= extract_unsigned_integer (valaddr
+ embedded_offset
339 + length_pos
, length_size
,
341 LA_PRINT_STRING (stream
, char_type
,
342 valaddr
+ embedded_offset
+ string_pos
,
343 len
, NULL
, 0, options
);
346 pascal_object_print_value_fields (type
, valaddr
, embedded_offset
,
347 address
, stream
, recurse
,
348 original_value
, options
,
354 elttype
= TYPE_INDEX_TYPE (type
);
355 elttype
= check_typedef (elttype
);
356 if (TYPE_STUB (elttype
))
358 fprintf_styled (stream
, metadata_style
.style (), "<incomplete type>");
363 struct type
*range
= elttype
;
364 LONGEST low_bound
, high_bound
;
367 fputs_filtered ("[", stream
);
369 int bound_info
= get_discrete_bounds (range
, &low_bound
, &high_bound
);
370 if (low_bound
== 0 && high_bound
== -1 && TYPE_LENGTH (type
) > 0)
372 /* If we know the size of the set type, we can figure out the
375 high_bound
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1;
376 TYPE_HIGH_BOUND (range
) = high_bound
;
381 fputs_styled ("<error value>", metadata_style
.style (), stream
);
385 for (i
= low_bound
; i
<= high_bound
; i
++)
387 int element
= value_bit_index (type
,
388 valaddr
+ embedded_offset
, i
);
393 goto maybe_bad_bstring
;
398 fputs_filtered (", ", stream
);
399 print_type_scalar (range
, i
, stream
);
402 if (i
+ 1 <= high_bound
403 && value_bit_index (type
,
404 valaddr
+ embedded_offset
, ++i
))
408 fputs_filtered ("..", stream
);
409 while (i
+ 1 <= high_bound
410 && value_bit_index (type
,
411 valaddr
+ embedded_offset
,
414 print_type_scalar (range
, j
, stream
);
419 fputs_filtered ("]", stream
);
424 error (_("Invalid pascal type code %d in symbol table."),
430 pascal_value_print (struct value
*val
, struct ui_file
*stream
,
431 const struct value_print_options
*options
)
433 struct type
*type
= value_type (val
);
434 struct value_print_options opts
= *options
;
438 /* If it is a pointer, indicate what it points to.
440 Print type also if it is a reference.
442 Object pascal: if it is a member pointer, we will take care
443 of that when we print it. */
444 if (TYPE_CODE (type
) == TYPE_CODE_PTR
445 || TYPE_CODE (type
) == TYPE_CODE_REF
)
447 /* Hack: remove (char *) for char strings. Their
448 type is indicated by the quoted string anyway. */
449 if (TYPE_CODE (type
) == TYPE_CODE_PTR
450 && TYPE_NAME (type
) == NULL
451 && TYPE_NAME (TYPE_TARGET_TYPE (type
)) != NULL
452 && strcmp (TYPE_NAME (TYPE_TARGET_TYPE (type
)), "char") == 0)
458 fprintf_filtered (stream
, "(");
459 type_print (type
, "", stream
, -1);
460 fprintf_filtered (stream
, ") ");
463 common_val_print (val
, stream
, 0, &opts
, current_language
);
468 show_pascal_static_field_print (struct ui_file
*file
, int from_tty
,
469 struct cmd_list_element
*c
, const char *value
)
471 fprintf_filtered (file
, _("Printing of pascal static members is %s.\n"),
475 static struct obstack dont_print_vb_obstack
;
476 static struct obstack dont_print_statmem_obstack
;
478 static void pascal_object_print_static_field (struct value
*,
479 struct ui_file
*, int,
480 const struct value_print_options
*);
482 static void pascal_object_print_value (struct type
*, const gdb_byte
*,
484 CORE_ADDR
, struct ui_file
*, int,
486 const struct value_print_options
*,
489 /* It was changed to this after 2.4.5. */
490 const char pascal_vtbl_ptr_name
[] =
491 {'_', '_', 'v', 't', 'b', 'l', '_', 'p', 't', 'r', '_', 't', 'y', 'p', 'e', 0};
493 /* Return truth value for assertion that TYPE is of the type
494 "pointer to virtual function". */
497 pascal_object_is_vtbl_ptr_type (struct type
*type
)
499 const char *type_name
= TYPE_NAME (type
);
501 return (type_name
!= NULL
502 && strcmp (type_name
, pascal_vtbl_ptr_name
) == 0);
505 /* Return truth value for the assertion that TYPE is of the type
506 "pointer to virtual function table". */
509 pascal_object_is_vtbl_member (struct type
*type
)
511 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
513 type
= TYPE_TARGET_TYPE (type
);
514 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
516 type
= TYPE_TARGET_TYPE (type
);
517 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
/* If not using
519 || TYPE_CODE (type
) == TYPE_CODE_PTR
) /* If using thunks. */
521 /* Virtual functions tables are full of pointers
522 to virtual functions. */
523 return pascal_object_is_vtbl_ptr_type (type
);
530 /* Mutually recursive subroutines of pascal_object_print_value and
531 c_val_print to print out a structure's fields:
532 pascal_object_print_value_fields and pascal_object_print_value.
534 TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the
535 same meanings as in pascal_object_print_value and c_val_print.
537 DONT_PRINT is an array of baseclass types that we
538 should not print, or zero if called from top level. */
541 pascal_object_print_value_fields (struct type
*type
, const gdb_byte
*valaddr
,
543 CORE_ADDR address
, struct ui_file
*stream
,
546 const struct value_print_options
*options
,
547 struct type
**dont_print_vb
,
548 int dont_print_statmem
)
550 int i
, len
, n_baseclasses
;
551 char *last_dont_print
552 = (char *) obstack_next_free (&dont_print_statmem_obstack
);
554 type
= check_typedef (type
);
556 fprintf_filtered (stream
, "{");
557 len
= TYPE_NFIELDS (type
);
558 n_baseclasses
= TYPE_N_BASECLASSES (type
);
560 /* Print out baseclasses such that we don't print
561 duplicates of virtual baseclasses. */
562 if (n_baseclasses
> 0)
563 pascal_object_print_value (type
, valaddr
, offset
, address
,
564 stream
, recurse
+ 1, val
,
565 options
, dont_print_vb
);
567 if (!len
&& n_baseclasses
== 1)
568 fprintf_styled (stream
, metadata_style
.style (), "<No data fields>");
571 struct obstack tmp_obstack
= dont_print_statmem_obstack
;
574 if (dont_print_statmem
== 0)
576 /* If we're at top level, carve out a completely fresh
577 chunk of the obstack and use that until this particular
578 invocation returns. */
579 obstack_finish (&dont_print_statmem_obstack
);
582 for (i
= n_baseclasses
; i
< len
; i
++)
584 /* If requested, skip printing of static fields. */
585 if (!options
->pascal_static_field_print
586 && field_is_static (&TYPE_FIELD (type
, i
)))
589 fprintf_filtered (stream
, ", ");
590 else if (n_baseclasses
> 0)
592 if (options
->prettyformat
)
594 fprintf_filtered (stream
, "\n");
595 print_spaces_filtered (2 + 2 * recurse
, stream
);
596 fputs_filtered ("members of ", stream
);
597 fputs_filtered (TYPE_NAME (type
), stream
);
598 fputs_filtered (": ", stream
);
603 if (options
->prettyformat
)
605 fprintf_filtered (stream
, "\n");
606 print_spaces_filtered (2 + 2 * recurse
, stream
);
610 wrap_here (n_spaces (2 + 2 * recurse
));
613 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
615 if (field_is_static (&TYPE_FIELD (type
, i
)))
617 fputs_filtered ("static ", stream
);
618 fprintf_symbol_filtered (stream
,
619 TYPE_FIELD_NAME (type
, i
),
620 current_language
->la_language
,
621 DMGL_PARAMS
| DMGL_ANSI
);
624 fputs_styled (TYPE_FIELD_NAME (type
, i
),
625 variable_name_style
.style (), stream
);
626 annotate_field_name_end ();
627 fputs_filtered (" = ", stream
);
628 annotate_field_value ();
630 if (!field_is_static (&TYPE_FIELD (type
, i
))
631 && TYPE_FIELD_PACKED (type
, i
))
635 /* Bitfields require special handling, especially due to byte
637 if (TYPE_FIELD_IGNORE (type
, i
))
639 fputs_styled ("<optimized out or zero length>",
640 metadata_style
.style (), stream
);
642 else if (value_bits_synthetic_pointer (val
,
643 TYPE_FIELD_BITPOS (type
,
645 TYPE_FIELD_BITSIZE (type
,
648 fputs_styled (_("<synthetic pointer>"),
649 metadata_style
.style (), stream
);
653 struct value_print_options opts
= *options
;
655 v
= value_field_bitfield (type
, i
, valaddr
, offset
, val
);
658 common_val_print (v
, stream
, recurse
+ 1, &opts
,
664 if (TYPE_FIELD_IGNORE (type
, i
))
666 fputs_styled ("<optimized out or zero length>",
667 metadata_style
.style (), stream
);
669 else if (field_is_static (&TYPE_FIELD (type
, i
)))
671 /* struct value *v = value_static_field (type, i);
675 v
= value_field_bitfield (type
, i
, valaddr
, offset
, val
);
678 val_print_optimized_out (NULL
, stream
);
680 pascal_object_print_static_field (v
, stream
, recurse
+ 1,
685 struct value_print_options opts
= *options
;
688 /* val_print (TYPE_FIELD_TYPE (type, i),
689 valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
690 address + TYPE_FIELD_BITPOS (type, i) / 8, 0,
691 stream, format, 0, recurse + 1, pretty); */
692 val_print (TYPE_FIELD_TYPE (type
, i
),
693 offset
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
694 address
, stream
, recurse
+ 1, val
, &opts
,
698 annotate_field_end ();
701 if (dont_print_statmem
== 0)
703 /* Free the space used to deal with the printing
704 of the members from top level. */
705 obstack_free (&dont_print_statmem_obstack
, last_dont_print
);
706 dont_print_statmem_obstack
= tmp_obstack
;
709 if (options
->prettyformat
)
711 fprintf_filtered (stream
, "\n");
712 print_spaces_filtered (2 * recurse
, stream
);
715 fprintf_filtered (stream
, "}");
718 /* Special val_print routine to avoid printing multiple copies of virtual
722 pascal_object_print_value (struct type
*type
, const gdb_byte
*valaddr
,
724 CORE_ADDR address
, struct ui_file
*stream
,
727 const struct value_print_options
*options
,
728 struct type
**dont_print_vb
)
730 struct type
**last_dont_print
731 = (struct type
**) obstack_next_free (&dont_print_vb_obstack
);
732 struct obstack tmp_obstack
= dont_print_vb_obstack
;
733 int i
, n_baseclasses
= TYPE_N_BASECLASSES (type
);
735 if (dont_print_vb
== 0)
737 /* If we're at top level, carve out a completely fresh
738 chunk of the obstack and use that until this particular
739 invocation returns. */
740 /* Bump up the high-water mark. Now alpha is omega. */
741 obstack_finish (&dont_print_vb_obstack
);
744 for (i
= 0; i
< n_baseclasses
; i
++)
747 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
748 const char *basename
= TYPE_NAME (baseclass
);
749 const gdb_byte
*base_valaddr
= NULL
;
752 gdb::byte_vector buf
;
754 if (BASETYPE_VIA_VIRTUAL (type
, i
))
756 struct type
**first_dont_print
757 = (struct type
**) obstack_base (&dont_print_vb_obstack
);
759 int j
= (struct type
**) obstack_next_free (&dont_print_vb_obstack
)
763 if (baseclass
== first_dont_print
[j
])
766 obstack_ptr_grow (&dont_print_vb_obstack
, baseclass
);
773 boffset
= baseclass_offset (type
, i
, valaddr
, offset
, address
, val
);
775 catch (const gdb_exception_error
&ex
)
777 if (ex
.error
== NOT_AVAILABLE_ERROR
)
785 /* The virtual base class pointer might have been clobbered by the
786 user program. Make sure that it still points to a valid memory
789 if (boffset
< 0 || boffset
>= TYPE_LENGTH (type
))
791 buf
.resize (TYPE_LENGTH (baseclass
));
793 base_valaddr
= buf
.data ();
794 if (target_read_memory (address
+ boffset
, buf
.data (),
795 TYPE_LENGTH (baseclass
)) != 0)
797 address
= address
+ boffset
;
802 base_valaddr
= valaddr
;
805 if (options
->prettyformat
)
807 fprintf_filtered (stream
, "\n");
808 print_spaces_filtered (2 * recurse
, stream
);
810 fputs_filtered ("<", stream
);
811 /* Not sure what the best notation is in the case where there is no
814 fputs_filtered (basename
? basename
: "", stream
);
815 fputs_filtered ("> = ", stream
);
818 val_print_unavailable (stream
);
820 val_print_invalid_address (stream
);
822 pascal_object_print_value_fields (baseclass
, base_valaddr
,
823 thisoffset
+ boffset
, address
,
824 stream
, recurse
, val
, options
,
825 (struct type
**) obstack_base (&dont_print_vb_obstack
),
827 fputs_filtered (", ", stream
);
833 if (dont_print_vb
== 0)
835 /* Free the space used to deal with the printing
836 of this type from top level. */
837 obstack_free (&dont_print_vb_obstack
, last_dont_print
);
838 /* Reset watermark so that we can continue protecting
839 ourselves from whatever we were protecting ourselves. */
840 dont_print_vb_obstack
= tmp_obstack
;
844 /* Print value of a static member.
845 To avoid infinite recursion when printing a class that contains
846 a static instance of the class, we keep the addresses of all printed
847 static member classes in an obstack and refuse to print them more
850 VAL contains the value to print, STREAM, RECURSE, and OPTIONS
851 have the same meanings as in c_val_print. */
854 pascal_object_print_static_field (struct value
*val
,
855 struct ui_file
*stream
,
857 const struct value_print_options
*options
)
859 struct type
*type
= value_type (val
);
860 struct value_print_options opts
;
862 if (value_entirely_optimized_out (val
))
864 val_print_optimized_out (val
, stream
);
868 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
870 CORE_ADDR
*first_dont_print
, addr
;
874 = (CORE_ADDR
*) obstack_base (&dont_print_statmem_obstack
);
875 i
= (CORE_ADDR
*) obstack_next_free (&dont_print_statmem_obstack
)
880 if (value_address (val
) == first_dont_print
[i
])
883 <same as static member of an already seen type>"),
884 metadata_style
.style (), stream
);
889 addr
= value_address (val
);
890 obstack_grow (&dont_print_statmem_obstack
, (char *) &addr
,
893 type
= check_typedef (type
);
894 pascal_object_print_value_fields (type
,
895 value_contents_for_printing (val
),
896 value_embedded_offset (val
),
899 val
, options
, NULL
, 1);
905 common_val_print (val
, stream
, recurse
, &opts
, current_language
);
908 void _initialize_pascal_valprint ();
910 _initialize_pascal_valprint ()
912 add_setshow_boolean_cmd ("pascal_static-members", class_support
,
913 &user_print_options
.pascal_static_field_print
, _("\
914 Set printing of pascal static members."), _("\
915 Show printing of pascal static members."), NULL
,
917 show_pascal_static_field_print
,
918 &setprintlist
, &showprintlist
);