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 /* Decorations for Pascal. */
47 static const struct generic_val_print_decorations p_decorations
=
59 /* See val_print for a description of the various parameters of this
60 function; they are identical. */
63 pascal_val_print (struct type
*type
,
64 int embedded_offset
, CORE_ADDR address
,
65 struct ui_file
*stream
, int recurse
,
66 struct value
*original_value
,
67 const struct value_print_options
*options
)
69 struct gdbarch
*gdbarch
= get_type_arch (type
);
70 enum bfd_endian byte_order
= type_byte_order (type
);
71 unsigned int i
= 0; /* Number of characters printed */
75 int length_pos
, length_size
, string_pos
;
76 struct type
*char_type
;
79 const gdb_byte
*valaddr
= value_contents_for_printing (original_value
);
81 type
= check_typedef (type
);
82 switch (TYPE_CODE (type
))
86 LONGEST low_bound
, high_bound
;
88 if (get_array_bounds (type
, &low_bound
, &high_bound
))
90 len
= high_bound
- low_bound
+ 1;
91 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
92 eltlen
= TYPE_LENGTH (elttype
);
93 if (options
->prettyformat_arrays
)
95 print_spaces_filtered (2 + 2 * recurse
, stream
);
97 /* If 's' format is used, try to print out as string.
98 If no format is given, print as string if element type
99 is of TYPE_CODE_CHAR and element size is 1,2 or 4. */
100 if (options
->format
== 's'
101 || ((eltlen
== 1 || eltlen
== 2 || eltlen
== 4)
102 && TYPE_CODE (elttype
) == TYPE_CODE_CHAR
103 && options
->format
== 0))
105 /* If requested, look for the first null char and only print
106 elements up to it. */
107 if (options
->stop_print_at_null
)
109 unsigned int temp_len
;
111 /* Look for a NULL char. */
113 extract_unsigned_integer (valaddr
+ embedded_offset
+
114 temp_len
* eltlen
, eltlen
,
116 && temp_len
< len
&& temp_len
< options
->print_max
;
121 LA_PRINT_STRING (stream
, TYPE_TARGET_TYPE (type
),
122 valaddr
+ embedded_offset
, len
, NULL
, 0,
128 fprintf_filtered (stream
, "{");
129 /* If this is a virtual function table, print the 0th
130 entry specially, and the rest of the members normally. */
131 if (pascal_object_is_vtbl_ptr_type (elttype
))
134 fprintf_filtered (stream
, "%d vtable entries", len
- 1);
140 val_print_array_elements (type
, embedded_offset
,
141 address
, stream
, recurse
,
142 original_value
, options
, i
);
143 fprintf_filtered (stream
, "}");
147 /* Array of unspecified length: treat like pointer to first elt. */
148 addr
= address
+ embedded_offset
;
150 goto print_unpacked_pointer
;
153 if (options
->format
&& options
->format
!= 's')
155 val_print_scalar_formatted (type
, embedded_offset
,
156 original_value
, options
, 0, stream
);
159 if (options
->vtblprint
&& pascal_object_is_vtbl_ptr_type (type
))
161 /* Print the unmangled name if desired. */
162 /* Print vtable entry - we only get here if we ARE using
163 -fvtable_thunks. (Otherwise, look under TYPE_CODE_STRUCT.) */
164 /* Extract the address, assume that it is unsigned. */
165 addr
= extract_unsigned_integer (valaddr
+ embedded_offset
,
166 TYPE_LENGTH (type
), byte_order
);
167 print_address_demangle (options
, gdbarch
, addr
, stream
, demangle
);
170 check_typedef (TYPE_TARGET_TYPE (type
));
172 addr
= unpack_pointer (type
, valaddr
+ embedded_offset
);
173 print_unpacked_pointer
:
174 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
176 if (TYPE_CODE (elttype
) == TYPE_CODE_FUNC
)
178 /* Try to print what function it points to. */
179 print_address_demangle (options
, gdbarch
, addr
, stream
, demangle
);
183 if (options
->addressprint
&& options
->format
!= 's')
185 fputs_filtered (paddress (gdbarch
, addr
), stream
);
189 /* For a pointer to char or unsigned char, also print the string
190 pointed to, unless pointer is null. */
191 if (((TYPE_LENGTH (elttype
) == 1
192 && (TYPE_CODE (elttype
) == TYPE_CODE_INT
193 || TYPE_CODE (elttype
) == TYPE_CODE_CHAR
))
194 || ((TYPE_LENGTH (elttype
) == 2 || TYPE_LENGTH (elttype
) == 4)
195 && TYPE_CODE (elttype
) == TYPE_CODE_CHAR
))
196 && (options
->format
== 0 || options
->format
== 's')
200 fputs_filtered (" ", stream
);
201 /* No wide string yet. */
202 i
= val_print_string (elttype
, NULL
, addr
, -1, stream
, options
);
204 /* Also for pointers to pascal strings. */
205 /* Note: this is Free Pascal specific:
206 as GDB does not recognize stabs pascal strings
207 Pascal strings are mapped to records
208 with lowercase names PM. */
209 if (is_pascal_string_type (elttype
, &length_pos
, &length_size
,
210 &string_pos
, &char_type
, NULL
)
213 ULONGEST string_length
;
217 fputs_filtered (" ", stream
);
218 buffer
= (gdb_byte
*) xmalloc (length_size
);
219 read_memory (addr
+ length_pos
, buffer
, length_size
);
220 string_length
= extract_unsigned_integer (buffer
, length_size
,
223 i
= val_print_string (char_type
, NULL
,
224 addr
+ string_pos
, string_length
,
227 else if (pascal_object_is_vtbl_member (type
))
229 /* Print vtbl's nicely. */
230 CORE_ADDR vt_address
= unpack_pointer (type
,
231 valaddr
+ embedded_offset
);
232 struct bound_minimal_symbol msymbol
=
233 lookup_minimal_symbol_by_pc (vt_address
);
235 /* If 'symbol_print' is set, we did the work above. */
236 if (!options
->symbol_print
237 && (msymbol
.minsym
!= NULL
)
238 && (vt_address
== BMSYMBOL_VALUE_ADDRESS (msymbol
)))
241 fputs_filtered (" ", stream
);
242 fputs_filtered ("<", stream
);
243 fputs_filtered (msymbol
.minsym
->print_name (), stream
);
244 fputs_filtered (">", stream
);
247 if (vt_address
&& options
->vtblprint
)
249 struct value
*vt_val
;
250 struct symbol
*wsym
= NULL
;
254 fputs_filtered (" ", stream
);
256 if (msymbol
.minsym
!= NULL
)
258 const char *search_name
= msymbol
.minsym
->search_name ();
259 wsym
= lookup_symbol_search_name (search_name
, NULL
,
265 wtype
= SYMBOL_TYPE (wsym
);
269 wtype
= TYPE_TARGET_TYPE (type
);
271 vt_val
= value_at (wtype
, vt_address
);
272 common_val_print (vt_val
, stream
, recurse
+ 1, options
,
274 if (options
->prettyformat
)
276 fprintf_filtered (stream
, "\n");
277 print_spaces_filtered (2 + 2 * recurse
, stream
);
286 case TYPE_CODE_FLAGS
:
288 case TYPE_CODE_RANGE
:
292 case TYPE_CODE_ERROR
:
293 case TYPE_CODE_UNDEF
:
296 generic_val_print (type
, embedded_offset
, address
,
297 stream
, recurse
, original_value
, options
,
301 case TYPE_CODE_UNION
:
302 if (recurse
&& !options
->unionprint
)
304 fprintf_filtered (stream
, "{...}");
308 case TYPE_CODE_STRUCT
:
309 if (options
->vtblprint
&& pascal_object_is_vtbl_ptr_type (type
))
311 /* Print the unmangled name if desired. */
312 /* Print vtable entry - we only get here if NOT using
313 -fvtable_thunks. (Otherwise, look under TYPE_CODE_PTR.) */
314 /* Extract the address, assume that it is unsigned. */
315 print_address_demangle
317 extract_unsigned_integer (valaddr
+ embedded_offset
318 + TYPE_FIELD_BITPOS (type
,
319 VTBL_FNADDR_OFFSET
) / 8,
320 TYPE_LENGTH (TYPE_FIELD_TYPE (type
,
321 VTBL_FNADDR_OFFSET
)),
327 if (is_pascal_string_type (type
, &length_pos
, &length_size
,
328 &string_pos
, &char_type
, NULL
))
330 len
= extract_unsigned_integer (valaddr
+ embedded_offset
331 + length_pos
, length_size
,
333 LA_PRINT_STRING (stream
, char_type
,
334 valaddr
+ embedded_offset
+ string_pos
,
335 len
, NULL
, 0, options
);
338 pascal_object_print_value_fields (type
, valaddr
, embedded_offset
,
339 address
, stream
, recurse
,
340 original_value
, options
,
346 elttype
= TYPE_INDEX_TYPE (type
);
347 elttype
= check_typedef (elttype
);
348 if (TYPE_STUB (elttype
))
350 fprintf_styled (stream
, metadata_style
.style (), "<incomplete type>");
355 struct type
*range
= elttype
;
356 LONGEST low_bound
, high_bound
;
359 fputs_filtered ("[", stream
);
361 int bound_info
= get_discrete_bounds (range
, &low_bound
, &high_bound
);
362 if (low_bound
== 0 && high_bound
== -1 && TYPE_LENGTH (type
) > 0)
364 /* If we know the size of the set type, we can figure out the
367 high_bound
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1;
368 TYPE_HIGH_BOUND (range
) = high_bound
;
373 fputs_styled ("<error value>", metadata_style
.style (), stream
);
377 for (i
= low_bound
; i
<= high_bound
; i
++)
379 int element
= value_bit_index (type
,
380 valaddr
+ embedded_offset
, i
);
385 goto maybe_bad_bstring
;
390 fputs_filtered (", ", stream
);
391 print_type_scalar (range
, i
, stream
);
394 if (i
+ 1 <= high_bound
395 && value_bit_index (type
,
396 valaddr
+ embedded_offset
, ++i
))
400 fputs_filtered ("..", stream
);
401 while (i
+ 1 <= high_bound
402 && value_bit_index (type
,
403 valaddr
+ embedded_offset
,
406 print_type_scalar (range
, j
, stream
);
411 fputs_filtered ("]", stream
);
416 error (_("Invalid pascal type code %d in symbol table."),
422 pascal_value_print (struct value
*val
, struct ui_file
*stream
,
423 const struct value_print_options
*options
)
425 struct type
*type
= value_type (val
);
426 struct value_print_options opts
= *options
;
430 /* If it is a pointer, indicate what it points to.
432 Print type also if it is a reference.
434 Object pascal: if it is a member pointer, we will take care
435 of that when we print it. */
436 if (TYPE_CODE (type
) == TYPE_CODE_PTR
437 || TYPE_CODE (type
) == TYPE_CODE_REF
)
439 /* Hack: remove (char *) for char strings. Their
440 type is indicated by the quoted string anyway. */
441 if (TYPE_CODE (type
) == TYPE_CODE_PTR
442 && TYPE_NAME (type
) == NULL
443 && TYPE_NAME (TYPE_TARGET_TYPE (type
)) != NULL
444 && strcmp (TYPE_NAME (TYPE_TARGET_TYPE (type
)), "char") == 0)
450 fprintf_filtered (stream
, "(");
451 type_print (type
, "", stream
, -1);
452 fprintf_filtered (stream
, ") ");
455 common_val_print (val
, stream
, 0, &opts
, current_language
);
460 show_pascal_static_field_print (struct ui_file
*file
, int from_tty
,
461 struct cmd_list_element
*c
, const char *value
)
463 fprintf_filtered (file
, _("Printing of pascal static members is %s.\n"),
467 static struct obstack dont_print_vb_obstack
;
468 static struct obstack dont_print_statmem_obstack
;
470 static void pascal_object_print_static_field (struct value
*,
471 struct ui_file
*, int,
472 const struct value_print_options
*);
474 static void pascal_object_print_value (struct type
*, const gdb_byte
*,
476 CORE_ADDR
, struct ui_file
*, int,
478 const struct value_print_options
*,
481 /* It was changed to this after 2.4.5. */
482 const char pascal_vtbl_ptr_name
[] =
483 {'_', '_', 'v', 't', 'b', 'l', '_', 'p', 't', 'r', '_', 't', 'y', 'p', 'e', 0};
485 /* Return truth value for assertion that TYPE is of the type
486 "pointer to virtual function". */
489 pascal_object_is_vtbl_ptr_type (struct type
*type
)
491 const char *type_name
= TYPE_NAME (type
);
493 return (type_name
!= NULL
494 && strcmp (type_name
, pascal_vtbl_ptr_name
) == 0);
497 /* Return truth value for the assertion that TYPE is of the type
498 "pointer to virtual function table". */
501 pascal_object_is_vtbl_member (struct type
*type
)
503 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
505 type
= TYPE_TARGET_TYPE (type
);
506 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
508 type
= TYPE_TARGET_TYPE (type
);
509 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
/* If not using
511 || TYPE_CODE (type
) == TYPE_CODE_PTR
) /* If using thunks. */
513 /* Virtual functions tables are full of pointers
514 to virtual functions. */
515 return pascal_object_is_vtbl_ptr_type (type
);
522 /* Mutually recursive subroutines of pascal_object_print_value and
523 c_val_print to print out a structure's fields:
524 pascal_object_print_value_fields and pascal_object_print_value.
526 TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the
527 same meanings as in pascal_object_print_value and c_val_print.
529 DONT_PRINT is an array of baseclass types that we
530 should not print, or zero if called from top level. */
533 pascal_object_print_value_fields (struct type
*type
, const gdb_byte
*valaddr
,
535 CORE_ADDR address
, struct ui_file
*stream
,
538 const struct value_print_options
*options
,
539 struct type
**dont_print_vb
,
540 int dont_print_statmem
)
542 int i
, len
, n_baseclasses
;
543 char *last_dont_print
544 = (char *) obstack_next_free (&dont_print_statmem_obstack
);
546 type
= check_typedef (type
);
548 fprintf_filtered (stream
, "{");
549 len
= TYPE_NFIELDS (type
);
550 n_baseclasses
= TYPE_N_BASECLASSES (type
);
552 /* Print out baseclasses such that we don't print
553 duplicates of virtual baseclasses. */
554 if (n_baseclasses
> 0)
555 pascal_object_print_value (type
, valaddr
, offset
, address
,
556 stream
, recurse
+ 1, val
,
557 options
, dont_print_vb
);
559 if (!len
&& n_baseclasses
== 1)
560 fprintf_styled (stream
, metadata_style
.style (), "<No data fields>");
563 struct obstack tmp_obstack
= dont_print_statmem_obstack
;
566 if (dont_print_statmem
== 0)
568 /* If we're at top level, carve out a completely fresh
569 chunk of the obstack and use that until this particular
570 invocation returns. */
571 obstack_finish (&dont_print_statmem_obstack
);
574 for (i
= n_baseclasses
; i
< len
; i
++)
576 /* If requested, skip printing of static fields. */
577 if (!options
->pascal_static_field_print
578 && field_is_static (&TYPE_FIELD (type
, i
)))
581 fprintf_filtered (stream
, ", ");
582 else if (n_baseclasses
> 0)
584 if (options
->prettyformat
)
586 fprintf_filtered (stream
, "\n");
587 print_spaces_filtered (2 + 2 * recurse
, stream
);
588 fputs_filtered ("members of ", stream
);
589 fputs_filtered (TYPE_NAME (type
), stream
);
590 fputs_filtered (": ", stream
);
595 if (options
->prettyformat
)
597 fprintf_filtered (stream
, "\n");
598 print_spaces_filtered (2 + 2 * recurse
, stream
);
602 wrap_here (n_spaces (2 + 2 * recurse
));
605 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
607 if (field_is_static (&TYPE_FIELD (type
, i
)))
609 fputs_filtered ("static ", stream
);
610 fprintf_symbol_filtered (stream
,
611 TYPE_FIELD_NAME (type
, i
),
612 current_language
->la_language
,
613 DMGL_PARAMS
| DMGL_ANSI
);
616 fputs_styled (TYPE_FIELD_NAME (type
, i
),
617 variable_name_style
.style (), stream
);
618 annotate_field_name_end ();
619 fputs_filtered (" = ", stream
);
620 annotate_field_value ();
622 if (!field_is_static (&TYPE_FIELD (type
, i
))
623 && TYPE_FIELD_PACKED (type
, i
))
627 /* Bitfields require special handling, especially due to byte
629 if (TYPE_FIELD_IGNORE (type
, i
))
631 fputs_styled ("<optimized out or zero length>",
632 metadata_style
.style (), stream
);
634 else if (value_bits_synthetic_pointer (val
,
635 TYPE_FIELD_BITPOS (type
,
637 TYPE_FIELD_BITSIZE (type
,
640 fputs_styled (_("<synthetic pointer>"),
641 metadata_style
.style (), stream
);
645 struct value_print_options opts
= *options
;
647 v
= value_field_bitfield (type
, i
, valaddr
, offset
, val
);
650 common_val_print (v
, stream
, recurse
+ 1, &opts
,
656 if (TYPE_FIELD_IGNORE (type
, i
))
658 fputs_styled ("<optimized out or zero length>",
659 metadata_style
.style (), stream
);
661 else if (field_is_static (&TYPE_FIELD (type
, i
)))
663 /* struct value *v = value_static_field (type, i);
667 v
= value_field_bitfield (type
, i
, valaddr
, offset
, val
);
670 val_print_optimized_out (NULL
, stream
);
672 pascal_object_print_static_field (v
, stream
, recurse
+ 1,
677 struct value_print_options opts
= *options
;
680 /* val_print (TYPE_FIELD_TYPE (type, i),
681 valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
682 address + TYPE_FIELD_BITPOS (type, i) / 8, 0,
683 stream, format, 0, recurse + 1, pretty); */
684 val_print (TYPE_FIELD_TYPE (type
, i
),
685 offset
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
686 address
, stream
, recurse
+ 1, val
, &opts
,
690 annotate_field_end ();
693 if (dont_print_statmem
== 0)
695 /* Free the space used to deal with the printing
696 of the members from top level. */
697 obstack_free (&dont_print_statmem_obstack
, last_dont_print
);
698 dont_print_statmem_obstack
= tmp_obstack
;
701 if (options
->prettyformat
)
703 fprintf_filtered (stream
, "\n");
704 print_spaces_filtered (2 * recurse
, stream
);
707 fprintf_filtered (stream
, "}");
710 /* Special val_print routine to avoid printing multiple copies of virtual
714 pascal_object_print_value (struct type
*type
, const gdb_byte
*valaddr
,
716 CORE_ADDR address
, struct ui_file
*stream
,
719 const struct value_print_options
*options
,
720 struct type
**dont_print_vb
)
722 struct type
**last_dont_print
723 = (struct type
**) obstack_next_free (&dont_print_vb_obstack
);
724 struct obstack tmp_obstack
= dont_print_vb_obstack
;
725 int i
, n_baseclasses
= TYPE_N_BASECLASSES (type
);
727 if (dont_print_vb
== 0)
729 /* If we're at top level, carve out a completely fresh
730 chunk of the obstack and use that until this particular
731 invocation returns. */
732 /* Bump up the high-water mark. Now alpha is omega. */
733 obstack_finish (&dont_print_vb_obstack
);
736 for (i
= 0; i
< n_baseclasses
; i
++)
739 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
740 const char *basename
= TYPE_NAME (baseclass
);
741 const gdb_byte
*base_valaddr
= NULL
;
744 gdb::byte_vector buf
;
746 if (BASETYPE_VIA_VIRTUAL (type
, i
))
748 struct type
**first_dont_print
749 = (struct type
**) obstack_base (&dont_print_vb_obstack
);
751 int j
= (struct type
**) obstack_next_free (&dont_print_vb_obstack
)
755 if (baseclass
== first_dont_print
[j
])
758 obstack_ptr_grow (&dont_print_vb_obstack
, baseclass
);
765 boffset
= baseclass_offset (type
, i
, valaddr
, offset
, address
, val
);
767 catch (const gdb_exception_error
&ex
)
769 if (ex
.error
== NOT_AVAILABLE_ERROR
)
777 /* The virtual base class pointer might have been clobbered by the
778 user program. Make sure that it still points to a valid memory
781 if (boffset
< 0 || boffset
>= TYPE_LENGTH (type
))
783 buf
.resize (TYPE_LENGTH (baseclass
));
785 base_valaddr
= buf
.data ();
786 if (target_read_memory (address
+ boffset
, buf
.data (),
787 TYPE_LENGTH (baseclass
)) != 0)
789 address
= address
+ boffset
;
794 base_valaddr
= valaddr
;
797 if (options
->prettyformat
)
799 fprintf_filtered (stream
, "\n");
800 print_spaces_filtered (2 * recurse
, stream
);
802 fputs_filtered ("<", stream
);
803 /* Not sure what the best notation is in the case where there is no
806 fputs_filtered (basename
? basename
: "", stream
);
807 fputs_filtered ("> = ", stream
);
810 val_print_unavailable (stream
);
812 val_print_invalid_address (stream
);
814 pascal_object_print_value_fields (baseclass
, base_valaddr
,
815 thisoffset
+ boffset
, address
,
816 stream
, recurse
, val
, options
,
817 (struct type
**) obstack_base (&dont_print_vb_obstack
),
819 fputs_filtered (", ", stream
);
825 if (dont_print_vb
== 0)
827 /* Free the space used to deal with the printing
828 of this type from top level. */
829 obstack_free (&dont_print_vb_obstack
, last_dont_print
);
830 /* Reset watermark so that we can continue protecting
831 ourselves from whatever we were protecting ourselves. */
832 dont_print_vb_obstack
= tmp_obstack
;
836 /* Print value of a static member.
837 To avoid infinite recursion when printing a class that contains
838 a static instance of the class, we keep the addresses of all printed
839 static member classes in an obstack and refuse to print them more
842 VAL contains the value to print, STREAM, RECURSE, and OPTIONS
843 have the same meanings as in c_val_print. */
846 pascal_object_print_static_field (struct value
*val
,
847 struct ui_file
*stream
,
849 const struct value_print_options
*options
)
851 struct type
*type
= value_type (val
);
852 struct value_print_options opts
;
854 if (value_entirely_optimized_out (val
))
856 val_print_optimized_out (val
, stream
);
860 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
862 CORE_ADDR
*first_dont_print
, addr
;
866 = (CORE_ADDR
*) obstack_base (&dont_print_statmem_obstack
);
867 i
= (CORE_ADDR
*) obstack_next_free (&dont_print_statmem_obstack
)
872 if (value_address (val
) == first_dont_print
[i
])
875 <same as static member of an already seen type>"),
876 metadata_style
.style (), stream
);
881 addr
= value_address (val
);
882 obstack_grow (&dont_print_statmem_obstack
, (char *) &addr
,
885 type
= check_typedef (type
);
886 pascal_object_print_value_fields (type
,
887 value_contents_for_printing (val
),
888 value_embedded_offset (val
),
891 val
, options
, NULL
, 1);
897 common_val_print (val
, stream
, recurse
, &opts
, current_language
);
900 void _initialize_pascal_valprint ();
902 _initialize_pascal_valprint ()
904 add_setshow_boolean_cmd ("pascal_static-members", class_support
,
905 &user_print_options
.pascal_static_field_print
, _("\
906 Set printing of pascal static members."), _("\
907 Show printing of pascal static members."), NULL
,
909 show_pascal_static_field_print
,
910 &setprintlist
, &showprintlist
);