1 /* Support for printing Pascal values for GDB, the GNU debugger.
3 Copyright (C) 2000-2017 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 "common/byte-vector.h"
44 /* Decorations for Pascal. */
46 static const struct generic_val_print_decorations p_decorations
=
58 /* See val_print for a description of the various parameters of this
59 function; they are identical. */
62 pascal_val_print (struct type
*type
,
63 int embedded_offset
, CORE_ADDR address
,
64 struct ui_file
*stream
, int recurse
,
65 struct value
*original_value
,
66 const struct value_print_options
*options
)
68 struct gdbarch
*gdbarch
= get_type_arch (type
);
69 enum bfd_endian byte_order
= gdbarch_byte_order (gdbarch
);
70 unsigned int i
= 0; /* Number of characters printed */
72 LONGEST low_bound
, high_bound
;
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
))
85 if (get_array_bounds (type
, &low_bound
, &high_bound
))
87 len
= high_bound
- low_bound
+ 1;
88 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
89 eltlen
= TYPE_LENGTH (elttype
);
90 if (options
->prettyformat_arrays
)
92 print_spaces_filtered (2 + 2 * recurse
, stream
);
94 /* If 's' format is used, try to print out as string.
95 If no format is given, print as string if element type
96 is of TYPE_CODE_CHAR and element size is 1,2 or 4. */
97 if (options
->format
== 's'
98 || ((eltlen
== 1 || eltlen
== 2 || eltlen
== 4)
99 && TYPE_CODE (elttype
) == TYPE_CODE_CHAR
100 && options
->format
== 0))
102 /* If requested, look for the first null char and only print
103 elements up to it. */
104 if (options
->stop_print_at_null
)
106 unsigned int temp_len
;
108 /* Look for a NULL char. */
110 extract_unsigned_integer (valaddr
+ embedded_offset
+
111 temp_len
* eltlen
, eltlen
,
113 && temp_len
< len
&& temp_len
< options
->print_max
;
118 LA_PRINT_STRING (stream
, TYPE_TARGET_TYPE (type
),
119 valaddr
+ embedded_offset
, len
, NULL
, 0,
125 fprintf_filtered (stream
, "{");
126 /* If this is a virtual function table, print the 0th
127 entry specially, and the rest of the members normally. */
128 if (pascal_object_is_vtbl_ptr_type (elttype
))
131 fprintf_filtered (stream
, "%d vtable entries", len
- 1);
137 val_print_array_elements (type
, embedded_offset
,
138 address
, stream
, recurse
,
139 original_value
, options
, i
);
140 fprintf_filtered (stream
, "}");
144 /* Array of unspecified length: treat like pointer to first elt. */
145 addr
= address
+ embedded_offset
;
146 goto print_unpacked_pointer
;
149 if (options
->format
&& options
->format
!= 's')
151 val_print_scalar_formatted (type
, embedded_offset
,
152 original_value
, options
, 0, stream
);
155 if (options
->vtblprint
&& pascal_object_is_vtbl_ptr_type (type
))
157 /* Print the unmangled name if desired. */
158 /* Print vtable entry - we only get here if we ARE using
159 -fvtable_thunks. (Otherwise, look under TYPE_CODE_STRUCT.) */
160 /* Extract the address, assume that it is unsigned. */
161 addr
= extract_unsigned_integer (valaddr
+ embedded_offset
,
162 TYPE_LENGTH (type
), byte_order
);
163 print_address_demangle (options
, gdbarch
, addr
, stream
, demangle
);
166 check_typedef (TYPE_TARGET_TYPE (type
));
168 addr
= unpack_pointer (type
, valaddr
+ embedded_offset
);
169 print_unpacked_pointer
:
170 elttype
= check_typedef (TYPE_TARGET_TYPE (type
));
172 if (TYPE_CODE (elttype
) == TYPE_CODE_FUNC
)
174 /* Try to print what function it points to. */
175 print_address_demangle (options
, gdbarch
, addr
, stream
, demangle
);
179 if (options
->addressprint
&& options
->format
!= 's')
181 fputs_filtered (paddress (gdbarch
, addr
), stream
);
185 /* For a pointer to char or unsigned char, also print the string
186 pointed to, unless pointer is null. */
187 if (((TYPE_LENGTH (elttype
) == 1
188 && (TYPE_CODE (elttype
) == TYPE_CODE_INT
189 || TYPE_CODE (elttype
) == TYPE_CODE_CHAR
))
190 || ((TYPE_LENGTH (elttype
) == 2 || TYPE_LENGTH (elttype
) == 4)
191 && TYPE_CODE (elttype
) == TYPE_CODE_CHAR
))
192 && (options
->format
== 0 || options
->format
== 's')
196 fputs_filtered (" ", stream
);
197 /* No wide string yet. */
198 i
= val_print_string (elttype
, NULL
, addr
, -1, stream
, options
);
200 /* Also for pointers to pascal strings. */
201 /* Note: this is Free Pascal specific:
202 as GDB does not recognize stabs pascal strings
203 Pascal strings are mapped to records
204 with lowercase names PM. */
205 if (is_pascal_string_type (elttype
, &length_pos
, &length_size
,
206 &string_pos
, &char_type
, NULL
)
209 ULONGEST string_length
;
213 fputs_filtered (" ", stream
);
214 buffer
= (gdb_byte
*) xmalloc (length_size
);
215 read_memory (addr
+ length_pos
, buffer
, length_size
);
216 string_length
= extract_unsigned_integer (buffer
, length_size
,
219 i
= val_print_string (char_type
, NULL
,
220 addr
+ string_pos
, string_length
,
223 else if (pascal_object_is_vtbl_member (type
))
225 /* Print vtbl's nicely. */
226 CORE_ADDR vt_address
= unpack_pointer (type
,
227 valaddr
+ embedded_offset
);
228 struct bound_minimal_symbol msymbol
=
229 lookup_minimal_symbol_by_pc (vt_address
);
231 /* If 'symbol_print' is set, we did the work above. */
232 if (!options
->symbol_print
233 && (msymbol
.minsym
!= NULL
)
234 && (vt_address
== BMSYMBOL_VALUE_ADDRESS (msymbol
)))
237 fputs_filtered (" ", stream
);
238 fputs_filtered ("<", stream
);
239 fputs_filtered (MSYMBOL_PRINT_NAME (msymbol
.minsym
), stream
);
240 fputs_filtered (">", stream
);
243 if (vt_address
&& options
->vtblprint
)
245 struct value
*vt_val
;
246 struct symbol
*wsym
= NULL
;
248 struct block
*block
= NULL
;
249 struct field_of_this_result is_this_fld
;
252 fputs_filtered (" ", stream
);
254 if (msymbol
.minsym
!= NULL
)
255 wsym
= lookup_symbol (MSYMBOL_LINKAGE_NAME (msymbol
.minsym
),
257 VAR_DOMAIN
, &is_this_fld
).symbol
;
261 wtype
= SYMBOL_TYPE (wsym
);
265 wtype
= TYPE_TARGET_TYPE (type
);
267 vt_val
= value_at (wtype
, vt_address
);
268 common_val_print (vt_val
, stream
, recurse
+ 1, options
,
270 if (options
->prettyformat
)
272 fprintf_filtered (stream
, "\n");
273 print_spaces_filtered (2 + 2 * recurse
, stream
);
282 case TYPE_CODE_FLAGS
:
284 case TYPE_CODE_RANGE
:
288 case TYPE_CODE_ERROR
:
289 case TYPE_CODE_UNDEF
:
292 generic_val_print (type
, embedded_offset
, address
,
293 stream
, recurse
, original_value
, options
,
297 case TYPE_CODE_UNION
:
298 if (recurse
&& !options
->unionprint
)
300 fprintf_filtered (stream
, "{...}");
304 case TYPE_CODE_STRUCT
:
305 if (options
->vtblprint
&& pascal_object_is_vtbl_ptr_type (type
))
307 /* Print the unmangled name if desired. */
308 /* Print vtable entry - we only get here if NOT using
309 -fvtable_thunks. (Otherwise, look under TYPE_CODE_PTR.) */
310 /* Extract the address, assume that it is unsigned. */
311 print_address_demangle
313 extract_unsigned_integer (valaddr
+ embedded_offset
314 + TYPE_FIELD_BITPOS (type
,
315 VTBL_FNADDR_OFFSET
) / 8,
316 TYPE_LENGTH (TYPE_FIELD_TYPE (type
,
317 VTBL_FNADDR_OFFSET
)),
323 if (is_pascal_string_type (type
, &length_pos
, &length_size
,
324 &string_pos
, &char_type
, NULL
))
326 len
= extract_unsigned_integer (valaddr
+ embedded_offset
327 + length_pos
, length_size
,
329 LA_PRINT_STRING (stream
, char_type
,
330 valaddr
+ embedded_offset
+ string_pos
,
331 len
, NULL
, 0, options
);
334 pascal_object_print_value_fields (type
, valaddr
, embedded_offset
,
335 address
, stream
, recurse
,
336 original_value
, options
,
342 elttype
= TYPE_INDEX_TYPE (type
);
343 elttype
= check_typedef (elttype
);
344 if (TYPE_STUB (elttype
))
346 fprintf_filtered (stream
, "<incomplete type>");
352 struct type
*range
= elttype
;
353 LONGEST low_bound
, high_bound
;
357 fputs_filtered ("[", stream
);
359 i
= get_discrete_bounds (range
, &low_bound
, &high_bound
);
360 if (low_bound
== 0 && high_bound
== -1 && TYPE_LENGTH (type
) > 0)
362 /* If we know the size of the set type, we can figure out the
365 high_bound
= TYPE_LENGTH (type
) * TARGET_CHAR_BIT
- 1;
366 TYPE_HIGH_BOUND (range
) = high_bound
;
371 fputs_filtered ("<error value>", stream
);
375 for (i
= low_bound
; i
<= high_bound
; i
++)
377 int element
= value_bit_index (type
,
378 valaddr
+ embedded_offset
, i
);
383 goto maybe_bad_bstring
;
388 fputs_filtered (", ", stream
);
389 print_type_scalar (range
, i
, stream
);
392 if (i
+ 1 <= high_bound
393 && value_bit_index (type
,
394 valaddr
+ embedded_offset
, ++i
))
398 fputs_filtered ("..", stream
);
399 while (i
+ 1 <= high_bound
400 && value_bit_index (type
,
401 valaddr
+ embedded_offset
,
404 print_type_scalar (range
, j
, stream
);
409 fputs_filtered ("]", stream
);
414 error (_("Invalid pascal type code %d in symbol table."),
421 pascal_value_print (struct value
*val
, struct ui_file
*stream
,
422 const struct value_print_options
*options
)
424 struct type
*type
= value_type (val
);
425 struct value_print_options opts
= *options
;
429 /* If it is a pointer, indicate what it points to.
431 Print type also if it is a reference.
433 Object pascal: if it is a member pointer, we will take care
434 of that when we print it. */
435 if (TYPE_CODE (type
) == TYPE_CODE_PTR
436 || TYPE_CODE (type
) == TYPE_CODE_REF
)
438 /* Hack: remove (char *) for char strings. Their
439 type is indicated by the quoted string anyway. */
440 if (TYPE_CODE (type
) == TYPE_CODE_PTR
441 && TYPE_NAME (type
) == NULL
442 && TYPE_NAME (TYPE_TARGET_TYPE (type
)) != NULL
443 && strcmp (TYPE_NAME (TYPE_TARGET_TYPE (type
)), "char") == 0)
449 fprintf_filtered (stream
, "(");
450 type_print (type
, "", stream
, -1);
451 fprintf_filtered (stream
, ") ");
454 common_val_print (val
, stream
, 0, &opts
, current_language
);
459 show_pascal_static_field_print (struct ui_file
*file
, int from_tty
,
460 struct cmd_list_element
*c
, const char *value
)
462 fprintf_filtered (file
, _("Printing of pascal static members is %s.\n"),
466 static struct obstack dont_print_vb_obstack
;
467 static struct obstack dont_print_statmem_obstack
;
469 static void pascal_object_print_static_field (struct value
*,
470 struct ui_file
*, int,
471 const struct value_print_options
*);
473 static void pascal_object_print_value (struct type
*, const gdb_byte
*,
475 CORE_ADDR
, struct ui_file
*, int,
477 const struct value_print_options
*,
480 /* It was changed to this after 2.4.5. */
481 const char pascal_vtbl_ptr_name
[] =
482 {'_', '_', 'v', 't', 'b', 'l', '_', 'p', 't', 'r', '_', 't', 'y', 'p', 'e', 0};
484 /* Return truth value for assertion that TYPE is of the type
485 "pointer to virtual function". */
488 pascal_object_is_vtbl_ptr_type (struct type
*type
)
490 const char *type_name
= type_name_no_tag (type
);
492 return (type_name
!= NULL
493 && strcmp (type_name
, pascal_vtbl_ptr_name
) == 0);
496 /* Return truth value for the assertion that TYPE is of the type
497 "pointer to virtual function table". */
500 pascal_object_is_vtbl_member (struct type
*type
)
502 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
504 type
= TYPE_TARGET_TYPE (type
);
505 if (TYPE_CODE (type
) == TYPE_CODE_ARRAY
)
507 type
= TYPE_TARGET_TYPE (type
);
508 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
/* If not using
510 || TYPE_CODE (type
) == TYPE_CODE_PTR
) /* If using thunks. */
512 /* Virtual functions tables are full of pointers
513 to virtual functions. */
514 return pascal_object_is_vtbl_ptr_type (type
);
521 /* Mutually recursive subroutines of pascal_object_print_value and
522 c_val_print to print out a structure's fields:
523 pascal_object_print_value_fields and pascal_object_print_value.
525 TYPE, VALADDR, ADDRESS, STREAM, RECURSE, and OPTIONS have the
526 same meanings as in pascal_object_print_value and c_val_print.
528 DONT_PRINT is an array of baseclass types that we
529 should not print, or zero if called from top level. */
532 pascal_object_print_value_fields (struct type
*type
, const gdb_byte
*valaddr
,
534 CORE_ADDR address
, struct ui_file
*stream
,
537 const struct value_print_options
*options
,
538 struct type
**dont_print_vb
,
539 int dont_print_statmem
)
541 int i
, len
, n_baseclasses
;
542 char *last_dont_print
543 = (char *) obstack_next_free (&dont_print_statmem_obstack
);
545 type
= check_typedef (type
);
547 fprintf_filtered (stream
, "{");
548 len
= TYPE_NFIELDS (type
);
549 n_baseclasses
= TYPE_N_BASECLASSES (type
);
551 /* Print out baseclasses such that we don't print
552 duplicates of virtual baseclasses. */
553 if (n_baseclasses
> 0)
554 pascal_object_print_value (type
, valaddr
, offset
, address
,
555 stream
, recurse
+ 1, val
,
556 options
, dont_print_vb
);
558 if (!len
&& n_baseclasses
== 1)
559 fprintf_filtered (stream
, "<No data fields>");
562 struct obstack tmp_obstack
= dont_print_statmem_obstack
;
565 if (dont_print_statmem
== 0)
567 /* If we're at top level, carve out a completely fresh
568 chunk of the obstack and use that until this particular
569 invocation returns. */
570 obstack_finish (&dont_print_statmem_obstack
);
573 for (i
= n_baseclasses
; i
< len
; i
++)
575 /* If requested, skip printing of static fields. */
576 if (!options
->pascal_static_field_print
577 && field_is_static (&TYPE_FIELD (type
, i
)))
580 fprintf_filtered (stream
, ", ");
581 else if (n_baseclasses
> 0)
583 if (options
->prettyformat
)
585 fprintf_filtered (stream
, "\n");
586 print_spaces_filtered (2 + 2 * recurse
, stream
);
587 fputs_filtered ("members of ", stream
);
588 fputs_filtered (type_name_no_tag (type
), stream
);
589 fputs_filtered (": ", stream
);
594 if (options
->prettyformat
)
596 fprintf_filtered (stream
, "\n");
597 print_spaces_filtered (2 + 2 * recurse
, stream
);
601 wrap_here (n_spaces (2 + 2 * recurse
));
604 annotate_field_begin (TYPE_FIELD_TYPE (type
, i
));
606 if (field_is_static (&TYPE_FIELD (type
, i
)))
607 fputs_filtered ("static ", stream
);
608 fprintf_symbol_filtered (stream
, TYPE_FIELD_NAME (type
, i
),
610 DMGL_PARAMS
| DMGL_ANSI
);
611 annotate_field_name_end ();
612 fputs_filtered (" = ", stream
);
613 annotate_field_value ();
615 if (!field_is_static (&TYPE_FIELD (type
, i
))
616 && TYPE_FIELD_PACKED (type
, i
))
620 /* Bitfields require special handling, especially due to byte
622 if (TYPE_FIELD_IGNORE (type
, i
))
624 fputs_filtered ("<optimized out or zero length>", stream
);
626 else if (value_bits_synthetic_pointer (val
,
627 TYPE_FIELD_BITPOS (type
,
629 TYPE_FIELD_BITSIZE (type
,
632 fputs_filtered (_("<synthetic pointer>"), stream
);
636 struct value_print_options opts
= *options
;
638 v
= value_field_bitfield (type
, i
, valaddr
, offset
, val
);
641 common_val_print (v
, stream
, recurse
+ 1, &opts
,
647 if (TYPE_FIELD_IGNORE (type
, i
))
649 fputs_filtered ("<optimized out or zero length>", stream
);
651 else if (field_is_static (&TYPE_FIELD (type
, i
)))
653 /* struct value *v = value_static_field (type, i);
657 v
= value_field_bitfield (type
, i
, valaddr
, offset
, val
);
660 val_print_optimized_out (NULL
, stream
);
662 pascal_object_print_static_field (v
, stream
, recurse
+ 1,
667 struct value_print_options opts
= *options
;
670 /* val_print (TYPE_FIELD_TYPE (type, i),
671 valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
672 address + TYPE_FIELD_BITPOS (type, i) / 8, 0,
673 stream, format, 0, recurse + 1, pretty); */
674 val_print (TYPE_FIELD_TYPE (type
, i
),
675 offset
+ TYPE_FIELD_BITPOS (type
, i
) / 8,
676 address
, stream
, recurse
+ 1, val
, &opts
,
680 annotate_field_end ();
683 if (dont_print_statmem
== 0)
685 /* Free the space used to deal with the printing
686 of the members from top level. */
687 obstack_free (&dont_print_statmem_obstack
, last_dont_print
);
688 dont_print_statmem_obstack
= tmp_obstack
;
691 if (options
->prettyformat
)
693 fprintf_filtered (stream
, "\n");
694 print_spaces_filtered (2 * recurse
, stream
);
697 fprintf_filtered (stream
, "}");
700 /* Special val_print routine to avoid printing multiple copies of virtual
704 pascal_object_print_value (struct type
*type
, const gdb_byte
*valaddr
,
706 CORE_ADDR address
, struct ui_file
*stream
,
709 const struct value_print_options
*options
,
710 struct type
**dont_print_vb
)
712 struct type
**last_dont_print
713 = (struct type
**) obstack_next_free (&dont_print_vb_obstack
);
714 struct obstack tmp_obstack
= dont_print_vb_obstack
;
715 int i
, n_baseclasses
= TYPE_N_BASECLASSES (type
);
717 if (dont_print_vb
== 0)
719 /* If we're at top level, carve out a completely fresh
720 chunk of the obstack and use that until this particular
721 invocation returns. */
722 /* Bump up the high-water mark. Now alpha is omega. */
723 obstack_finish (&dont_print_vb_obstack
);
726 for (i
= 0; i
< n_baseclasses
; i
++)
729 struct type
*baseclass
= check_typedef (TYPE_BASECLASS (type
, i
));
730 const char *basename
= type_name_no_tag (baseclass
);
731 const gdb_byte
*base_valaddr
= NULL
;
734 gdb::byte_vector buf
;
736 if (BASETYPE_VIA_VIRTUAL (type
, i
))
738 struct type
**first_dont_print
739 = (struct type
**) obstack_base (&dont_print_vb_obstack
);
741 int j
= (struct type
**) obstack_next_free (&dont_print_vb_obstack
)
745 if (baseclass
== first_dont_print
[j
])
748 obstack_ptr_grow (&dont_print_vb_obstack
, baseclass
);
755 boffset
= baseclass_offset (type
, i
, valaddr
, offset
, address
, val
);
757 CATCH (ex
, RETURN_MASK_ERROR
)
759 if (ex
.error
== NOT_AVAILABLE_ERROR
)
768 /* The virtual base class pointer might have been clobbered by the
769 user program. Make sure that it still points to a valid memory
772 if (boffset
< 0 || boffset
>= TYPE_LENGTH (type
))
774 buf
.resize (TYPE_LENGTH (baseclass
));
776 base_valaddr
= buf
.data ();
777 if (target_read_memory (address
+ boffset
, buf
.data (),
778 TYPE_LENGTH (baseclass
)) != 0)
780 address
= address
+ boffset
;
785 base_valaddr
= valaddr
;
788 if (options
->prettyformat
)
790 fprintf_filtered (stream
, "\n");
791 print_spaces_filtered (2 * recurse
, stream
);
793 fputs_filtered ("<", stream
);
794 /* Not sure what the best notation is in the case where there is no
797 fputs_filtered (basename
? basename
: "", stream
);
798 fputs_filtered ("> = ", stream
);
801 val_print_unavailable (stream
);
803 val_print_invalid_address (stream
);
805 pascal_object_print_value_fields (baseclass
, base_valaddr
,
806 thisoffset
+ boffset
, address
,
807 stream
, recurse
, val
, options
,
808 (struct type
**) obstack_base (&dont_print_vb_obstack
),
810 fputs_filtered (", ", stream
);
816 if (dont_print_vb
== 0)
818 /* Free the space used to deal with the printing
819 of this type from top level. */
820 obstack_free (&dont_print_vb_obstack
, last_dont_print
);
821 /* Reset watermark so that we can continue protecting
822 ourselves from whatever we were protecting ourselves. */
823 dont_print_vb_obstack
= tmp_obstack
;
827 /* Print value of a static member.
828 To avoid infinite recursion when printing a class that contains
829 a static instance of the class, we keep the addresses of all printed
830 static member classes in an obstack and refuse to print them more
833 VAL contains the value to print, STREAM, RECURSE, and OPTIONS
834 have the same meanings as in c_val_print. */
837 pascal_object_print_static_field (struct value
*val
,
838 struct ui_file
*stream
,
840 const struct value_print_options
*options
)
842 struct type
*type
= value_type (val
);
843 struct value_print_options opts
;
845 if (value_entirely_optimized_out (val
))
847 val_print_optimized_out (val
, stream
);
851 if (TYPE_CODE (type
) == TYPE_CODE_STRUCT
)
853 CORE_ADDR
*first_dont_print
, addr
;
857 = (CORE_ADDR
*) obstack_base (&dont_print_statmem_obstack
);
858 i
= (CORE_ADDR
*) obstack_next_free (&dont_print_statmem_obstack
)
863 if (value_address (val
) == first_dont_print
[i
])
866 <same as static member of an already seen type>",
872 addr
= value_address (val
);
873 obstack_grow (&dont_print_statmem_obstack
, (char *) &addr
,
876 type
= check_typedef (type
);
877 pascal_object_print_value_fields (type
,
878 value_contents_for_printing (val
),
879 value_embedded_offset (val
),
882 val
, options
, NULL
, 1);
888 common_val_print (val
, stream
, recurse
, &opts
, current_language
);
892 _initialize_pascal_valprint (void)
894 add_setshow_boolean_cmd ("pascal_static-members", class_support
,
895 &user_print_options
.pascal_static_field_print
, _("\
896 Set printing of pascal static members."), _("\
897 Show printing of pascal static members."), NULL
,
899 show_pascal_static_field_print
,
900 &setprintlist
, &showprintlist
);