manual copyright year range of various GDB files to add 2023
[binutils-gdb.git] / gdb / typeprint.c
blob87df7f2ad35c7956c0289c2ae1afbff8682fda5b
1 /* Language independent support for printing types for GDB, the GNU debugger.
3 Copyright (C) 1986-2023 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 #include "defs.h"
21 #include "gdbsupport/gdb_obstack.h"
22 #include "bfd.h" /* Binary File Description */
23 #include "symtab.h"
24 #include "gdbtypes.h"
25 #include "expression.h"
26 #include "value.h"
27 #include "gdbcore.h"
28 #include "command.h"
29 #include "gdbcmd.h"
30 #include "target.h"
31 #include "language.h"
32 #include "cp-abi.h"
33 #include "typeprint.h"
34 #include "valprint.h"
35 #include <ctype.h>
36 #include "cli/cli-utils.h"
37 #include "extension.h"
38 #include "completer.h"
39 #include "cli/cli-style.h"
41 const struct type_print_options type_print_raw_options =
43 1, /* raw */
44 1, /* print_methods */
45 1, /* print_typedefs */
46 0, /* print_offsets */
47 0, /* print_in_hex */
48 0, /* print_nested_type_limit */
49 NULL, /* local_typedefs */
50 NULL, /* global_table */
51 NULL /* global_printers */
54 /* The default flags for 'ptype' and 'whatis'. */
56 static struct type_print_options default_ptype_flags =
58 0, /* raw */
59 1, /* print_methods */
60 1, /* print_typedefs */
61 0, /* print_offsets */
62 0, /* print_in_hex */
63 0, /* print_nested_type_limit */
64 NULL, /* local_typedefs */
65 NULL, /* global_table */
66 NULL /* global_printers */
71 /* See typeprint.h. */
73 const int print_offset_data::indentation = 27;
75 /* See typeprint.h. */
77 print_offset_data::print_offset_data (const struct type_print_options *flags)
79 if (flags != nullptr)
80 print_in_hex = flags->print_in_hex;
83 /* See typeprint.h. */
85 void
86 print_offset_data::maybe_print_hole (struct ui_file *stream,
87 unsigned int bitpos,
88 const char *for_what)
90 /* We check for END_BITPOS > 0 because there is a specific
91 scenario when END_BITPOS can be zero and BITPOS can be >
92 0: when we are dealing with a struct/class with a virtual method.
93 Because of the vtable, the first field of the struct/class will
94 have an offset of sizeof (void *) (the size of the vtable). If
95 we do not check for END_BITPOS > 0 here, GDB will report
96 a hole before the first field, which is not accurate. */
97 if (end_bitpos > 0 && end_bitpos < bitpos)
99 /* If END_BITPOS is smaller than the current type's
100 bitpos, it means there's a hole in the struct, so we report
101 it here. */
102 unsigned int hole = bitpos - end_bitpos;
103 unsigned int hole_byte = hole / TARGET_CHAR_BIT;
104 unsigned int hole_bit = hole % TARGET_CHAR_BIT;
106 if (hole_bit > 0)
108 fprintf_styled (stream, highlight_style.style (),
109 "/* XXX %2u-bit %-7s */", hole_bit, for_what);
110 gdb_puts ("\n", stream);
113 if (hole_byte > 0)
115 fprintf_styled (stream, highlight_style.style (),
116 "/* XXX %2u-byte %-7s */", hole_byte, for_what);
117 gdb_puts ("\n", stream);
122 /* See typeprint.h. */
124 void
125 print_offset_data::update (struct type *type, unsigned int field_idx,
126 struct ui_file *stream)
128 if (field_is_static (&type->field (field_idx)))
130 print_spaces (indentation, stream);
131 return;
134 struct type *ftype = check_typedef (type->field (field_idx).type ());
135 if (type->code () == TYPE_CODE_UNION)
137 /* Since union fields don't have the concept of offsets, we just
138 print their sizes. */
139 gdb_printf (stream, "/* %6s */",
140 (print_in_hex ?
141 hex_string_custom (ftype->length (), 4) :
142 pulongest (ftype->length ())));
143 return;
146 unsigned int bitpos = type->field (field_idx).loc_bitpos ();
147 unsigned int fieldsize_byte = ftype->length ();
148 unsigned int fieldsize_bit = fieldsize_byte * TARGET_CHAR_BIT;
150 maybe_print_hole (stream, bitpos, "hole");
152 if (TYPE_FIELD_PACKED (type, field_idx)
153 || offset_bitpos % TARGET_CHAR_BIT != 0)
155 /* We're dealing with a bitfield. Print the bit offset. */
156 fieldsize_bit = TYPE_FIELD_BITSIZE (type, field_idx);
158 unsigned real_bitpos = bitpos + offset_bitpos;
160 gdb_printf (stream,
161 (print_in_hex ? "/* 0x%04x: 0x%x" : "/* %6u:%2u "),
162 real_bitpos / TARGET_CHAR_BIT,
163 real_bitpos % TARGET_CHAR_BIT);
165 else
167 /* The position of the field, relative to the beginning of the
168 struct. */
169 gdb_printf (stream, (print_in_hex ? "/* 0x%04x" : "/* %6u"),
170 (bitpos + offset_bitpos) / TARGET_CHAR_BIT);
172 gdb_printf (stream, " ");
175 gdb_printf (stream, (print_in_hex ? " | 0x%04x */" : " | %6u */"),
176 fieldsize_byte);
178 end_bitpos = bitpos + fieldsize_bit;
181 /* See typeprint.h. */
183 void
184 print_offset_data::finish (struct type *type, int level,
185 struct ui_file *stream)
187 unsigned int bitpos = type->length () * TARGET_CHAR_BIT;
188 maybe_print_hole (stream, bitpos, "padding");
190 gdb_puts ("\n", stream);
191 print_spaces (level + 4 + print_offset_data::indentation, stream);
192 gdb_printf (stream, "/* total size (bytes): %4s */\n",
193 pulongest (type->length ()));
198 /* A hash function for a typedef_field. */
200 static hashval_t
201 hash_typedef_field (const void *p)
203 const struct decl_field *tf = (const struct decl_field *) p;
205 return htab_hash_string (TYPE_SAFE_NAME (tf->type));
208 /* An equality function for a typedef field. */
210 static int
211 eq_typedef_field (const void *a, const void *b)
213 const struct decl_field *tfa = (const struct decl_field *) a;
214 const struct decl_field *tfb = (const struct decl_field *) b;
216 return types_equal (tfa->type, tfb->type);
219 /* See typeprint.h. */
221 void
222 typedef_hash_table::recursively_update (struct type *t)
224 int i;
226 for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (t); ++i)
228 struct decl_field *tdef = &TYPE_TYPEDEF_FIELD (t, i);
229 void **slot;
231 slot = htab_find_slot (m_table.get (), tdef, INSERT);
232 /* Only add a given typedef name once. Really this shouldn't
233 happen; but it is safe enough to do the updates breadth-first
234 and thus use the most specific typedef. */
235 if (*slot == NULL)
236 *slot = tdef;
239 /* Recurse into superclasses. */
240 for (i = 0; i < TYPE_N_BASECLASSES (t); ++i)
241 recursively_update (TYPE_BASECLASS (t, i));
244 /* See typeprint.h. */
246 void
247 typedef_hash_table::add_template_parameters (struct type *t)
249 int i;
251 for (i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (t); ++i)
253 struct decl_field *tf;
254 void **slot;
256 /* We only want type-valued template parameters in the hash. */
257 if (TYPE_TEMPLATE_ARGUMENT (t, i)->aclass () != LOC_TYPEDEF)
258 continue;
260 tf = XOBNEW (&m_storage, struct decl_field);
261 tf->name = TYPE_TEMPLATE_ARGUMENT (t, i)->linkage_name ();
262 tf->type = TYPE_TEMPLATE_ARGUMENT (t, i)->type ();
264 slot = htab_find_slot (m_table.get (), tf, INSERT);
265 if (*slot == NULL)
266 *slot = tf;
270 /* See typeprint.h. */
272 typedef_hash_table::typedef_hash_table ()
273 : m_table (htab_create_alloc (10, hash_typedef_field, eq_typedef_field,
274 NULL, xcalloc, xfree))
278 /* Helper function for typedef_hash_table::copy. */
280 static int
281 copy_typedef_hash_element (void **slot, void *nt)
283 htab_t new_table = (htab_t) nt;
284 void **new_slot;
286 new_slot = htab_find_slot (new_table, *slot, INSERT);
287 if (*new_slot == NULL)
288 *new_slot = *slot;
290 return 1;
293 /* See typeprint.h. */
295 typedef_hash_table::typedef_hash_table (const typedef_hash_table &table)
297 m_table.reset (htab_create_alloc (10, hash_typedef_field, eq_typedef_field,
298 NULL, xcalloc, xfree));
299 htab_traverse_noresize (table.m_table.get (), copy_typedef_hash_element,
300 m_table.get ());
303 /* Look up the type T in the global typedef hash. If it is found,
304 return the typedef name. If it is not found, apply the
305 type-printers, if any, given by start_script_type_printers and return the
306 result. A NULL return means that the name was not found. */
308 const char *
309 typedef_hash_table::find_global_typedef (const struct type_print_options *flags,
310 struct type *t)
312 char *applied;
313 void **slot;
314 struct decl_field tf, *new_tf;
316 if (flags->global_typedefs == NULL)
317 return NULL;
319 tf.name = NULL;
320 tf.type = t;
322 slot = htab_find_slot (flags->global_typedefs->m_table.get (), &tf, INSERT);
323 if (*slot != NULL)
325 new_tf = (struct decl_field *) *slot;
326 return new_tf->name;
329 /* Put an entry into the hash table now, in case
330 apply_ext_lang_type_printers recurses. */
331 new_tf = XOBNEW (&flags->global_typedefs->m_storage, struct decl_field);
332 new_tf->name = NULL;
333 new_tf->type = t;
335 *slot = new_tf;
337 applied = apply_ext_lang_type_printers (flags->global_printers, t);
339 if (applied != NULL)
341 new_tf->name = obstack_strdup (&flags->global_typedefs->m_storage,
342 applied);
343 xfree (applied);
346 return new_tf->name;
349 /* See typeprint.h. */
351 const char *
352 typedef_hash_table::find_typedef (const struct type_print_options *flags,
353 struct type *t)
355 if (flags->local_typedefs != NULL)
357 struct decl_field tf, *found;
359 tf.name = NULL;
360 tf.type = t;
361 htab_t table = flags->local_typedefs->m_table.get ();
362 found = (struct decl_field *) htab_find (table, &tf);
364 if (found != NULL)
365 return found->name;
368 return find_global_typedef (flags, t);
373 /* Print a description of a type in the format of a
374 typedef for the current language.
375 NEW is the new name for a type TYPE. */
377 void
378 typedef_print (struct type *type, struct symbol *newobj, struct ui_file *stream)
380 current_language->print_typedef (type, newobj, stream);
383 /* Print a description of a type TYPE in the form of a declaration of a
384 variable named VARSTRING. (VARSTRING is demangled if necessary.)
385 Output goes to STREAM (via stdio).
386 If SHOW is positive, we show the contents of the outermost level
387 of structure even if there is a type name that could be used instead.
388 If SHOW is negative, we never show the details of elements' types. */
390 void
391 type_print (struct type *type, const char *varstring, struct ui_file *stream,
392 int show)
394 current_language->print_type (type, varstring, stream, show, 0,
395 &default_ptype_flags);
398 /* Print TYPE to a string, returning it. The caller is responsible for
399 freeing the string. */
401 std::string
402 type_to_string (struct type *type)
406 string_file stb;
408 type_print (type, "", &stb, -1);
409 return stb.release ();
411 catch (const gdb_exception &except)
415 return {};
418 /* See typeprint.h. */
420 void
421 type_print_unknown_return_type (struct ui_file *stream)
423 fprintf_styled (stream, metadata_style.style (),
424 _("<unknown return type>"));
427 /* See typeprint.h. */
429 void
430 error_unknown_type (const char *sym_print_name)
432 error (_("'%s' has unknown type; cast it to its declared type"),
433 sym_print_name);
436 /* Print type of EXP, or last thing in value history if EXP == NULL.
437 show is passed to type_print. */
439 static void
440 whatis_exp (const char *exp, int show)
442 struct value *val;
443 struct type *real_type = NULL;
444 struct type *type;
445 int full = 0;
446 LONGEST top = -1;
447 int using_enc = 0;
448 struct value_print_options opts;
449 struct type_print_options flags = default_ptype_flags;
451 if (exp)
453 if (*exp == '/')
455 int seen_one = 0;
457 for (++exp; *exp && !isspace (*exp); ++exp)
459 switch (*exp)
461 case 'r':
462 flags.raw = 1;
463 break;
464 case 'm':
465 flags.print_methods = 0;
466 break;
467 case 'M':
468 flags.print_methods = 1;
469 break;
470 case 't':
471 flags.print_typedefs = 0;
472 break;
473 case 'T':
474 flags.print_typedefs = 1;
475 break;
476 case 'o':
478 /* Filter out languages which don't implement the
479 feature. */
480 if (show > 0
481 && current_language->can_print_type_offsets ())
483 flags.print_offsets = 1;
484 flags.print_typedefs = 0;
485 flags.print_methods = 0;
487 break;
489 case 'x':
490 flags.print_in_hex = 1;
491 break;
492 case 'd':
493 flags.print_in_hex = 0;
494 break;
495 default:
496 error (_("unrecognized flag '%c'"), *exp);
498 seen_one = 1;
501 if (!*exp && !seen_one)
502 error (_("flag expected"));
503 if (!isspace (*exp))
504 error (_("expected space after format"));
505 exp = skip_spaces (exp);
508 expression_up expr = parse_expression (exp);
510 /* The behavior of "whatis" depends on whether the user
511 expression names a type directly, or a language expression
512 (including variable names). If the former, then "whatis"
513 strips one level of typedefs, only. If an expression,
514 "whatis" prints the type of the expression without stripping
515 any typedef level. "ptype" always strips all levels of
516 typedefs. */
517 val = evaluate_type (expr.get ());
518 type = value_type (val);
520 if (show == -1 && expr->first_opcode () == OP_TYPE)
522 /* The user expression names a type directly. */
524 /* If this is a typedef, then find its immediate target.
525 Use check_typedef to resolve stubs, but ignore its result
526 because we do not want to dig past all typedefs. */
527 check_typedef (type);
528 if (type->code () == TYPE_CODE_TYPEDEF)
529 type = type->target_type ();
531 /* If the expression is actually a type, then there's no
532 value to fetch the dynamic type from. */
533 val = NULL;
536 else
538 val = access_value_history (0);
539 type = value_type (val);
542 get_user_print_options (&opts);
543 if (val != NULL && opts.objectprint)
545 if (type->is_pointer_or_reference ()
546 && (type->target_type ()->code () == TYPE_CODE_STRUCT))
547 real_type = value_rtti_indirect_type (val, &full, &top, &using_enc);
548 else if (type->code () == TYPE_CODE_STRUCT)
549 real_type = value_rtti_type (val, &full, &top, &using_enc);
552 if (flags.print_offsets
553 && (type->code () == TYPE_CODE_STRUCT
554 || type->code () == TYPE_CODE_UNION))
555 gdb_printf ("/* offset | size */ ");
557 gdb_printf ("type = ");
559 std::unique_ptr<typedef_hash_table> table_holder;
560 std::unique_ptr<ext_lang_type_printers> printer_holder;
561 if (!flags.raw)
563 table_holder.reset (new typedef_hash_table);
564 flags.global_typedefs = table_holder.get ();
566 printer_holder.reset (new ext_lang_type_printers);
567 flags.global_printers = printer_holder.get ();
570 if (real_type)
572 gdb_printf ("/* real type = ");
573 type_print (real_type, "", gdb_stdout, -1);
574 if (! full)
575 gdb_printf (" (incomplete object)");
576 gdb_printf (" */\n");
579 current_language->print_type (type, "", gdb_stdout, show, 0, &flags);
580 gdb_printf ("\n");
583 static void
584 whatis_command (const char *exp, int from_tty)
586 /* Most of the time users do not want to see all the fields
587 in a structure. If they do they can use the "ptype" command.
588 Hence the "-1" below. */
589 whatis_exp (exp, -1);
592 /* TYPENAME is either the name of a type, or an expression. */
594 static void
595 ptype_command (const char *type_name, int from_tty)
597 whatis_exp (type_name, 1);
600 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
601 Used to print data from type structures in a specified type. For example,
602 array bounds may be characters or booleans in some languages, and this
603 allows the ranges to be printed in their "natural" form rather than as
604 decimal integer values.
606 FIXME: This is here simply because only the type printing routines
607 currently use it, and it wasn't clear if it really belonged somewhere
608 else (like printcmd.c). There are a lot of other gdb routines that do
609 something similar, but they are generally concerned with printing values
610 that come from the inferior in target byte order and target size. */
612 void
613 print_type_scalar (struct type *type, LONGEST val, struct ui_file *stream)
615 unsigned int i;
616 unsigned len;
618 type = check_typedef (type);
620 switch (type->code ())
623 case TYPE_CODE_ENUM:
624 len = type->num_fields ();
625 for (i = 0; i < len; i++)
627 if (type->field (i).loc_enumval () == val)
629 break;
632 if (i < len)
634 gdb_puts (type->field (i).name (), stream);
636 else
638 print_longest (stream, 'd', 0, val);
640 break;
642 case TYPE_CODE_INT:
643 print_longest (stream, type->is_unsigned () ? 'u' : 'd', 0, val);
644 break;
646 case TYPE_CODE_CHAR:
647 current_language->printchar ((unsigned char) val, type, stream);
648 break;
650 case TYPE_CODE_BOOL:
651 gdb_printf (stream, val ? "TRUE" : "FALSE");
652 break;
654 case TYPE_CODE_RANGE:
655 print_type_scalar (type->target_type (), val, stream);
656 return;
658 case TYPE_CODE_FIXED_POINT:
659 print_type_fixed_point (type, stream);
660 break;
662 case TYPE_CODE_UNDEF:
663 case TYPE_CODE_PTR:
664 case TYPE_CODE_ARRAY:
665 case TYPE_CODE_STRUCT:
666 case TYPE_CODE_UNION:
667 case TYPE_CODE_FUNC:
668 case TYPE_CODE_FLT:
669 case TYPE_CODE_VOID:
670 case TYPE_CODE_SET:
671 case TYPE_CODE_STRING:
672 case TYPE_CODE_ERROR:
673 case TYPE_CODE_MEMBERPTR:
674 case TYPE_CODE_METHODPTR:
675 case TYPE_CODE_METHOD:
676 case TYPE_CODE_REF:
677 case TYPE_CODE_RVALUE_REF:
678 case TYPE_CODE_NAMESPACE:
679 error (_("internal error: unhandled type in print_type_scalar"));
680 break;
682 default:
683 error (_("Invalid type code in symbol table."));
687 /* See typeprint.h. */
689 void
690 print_type_fixed_point (struct type *type, struct ui_file *stream)
692 std::string small_img = type->fixed_point_scaling_factor ().str ();
694 gdb_printf (stream, "%s-byte fixed point (small = %s)",
695 pulongest (type->length ()), small_img.c_str ());
698 /* Dump details of a type specified either directly or indirectly.
699 Uses the same sort of type lookup mechanism as ptype_command()
700 and whatis_command(). */
702 void
703 maintenance_print_type (const char *type_name, int from_tty)
705 if (type_name != NULL)
707 expression_up expr = parse_expression (type_name);
708 struct value *val = evaluate_type (expr.get ());
709 struct type *type = value_type (val);
711 if (type != nullptr)
712 recursive_dump_type (type, 0);
717 struct cmd_list_element *setprinttypelist;
719 struct cmd_list_element *showprinttypelist;
721 static bool print_methods = true;
723 static void
724 set_print_type_methods (const char *args,
725 int from_tty, struct cmd_list_element *c)
727 default_ptype_flags.print_methods = print_methods;
730 static void
731 show_print_type_methods (struct ui_file *file, int from_tty,
732 struct cmd_list_element *c, const char *value)
734 gdb_printf (file, _("Printing of methods defined in a class in %s\n"),
735 value);
738 static bool print_typedefs = true;
740 static void
741 set_print_type_typedefs (const char *args,
742 int from_tty, struct cmd_list_element *c)
744 default_ptype_flags.print_typedefs = print_typedefs;
747 static void
748 show_print_type_typedefs (struct ui_file *file, int from_tty,
749 struct cmd_list_element *c, const char *value)
751 gdb_printf (file, _("Printing of typedefs defined in a class in %s\n"),
752 value);
755 /* Limit on the number of nested type definitions to print or -1 to print
756 all nested type definitions in a class. By default, we do not print
757 nested definitions. */
759 static int print_nested_type_limit = 0;
761 /* Set how many nested type definitions should be printed by the type
762 printer. */
764 static void
765 set_print_type_nested_types (const char *args, int from_tty,
766 struct cmd_list_element *c)
768 default_ptype_flags.print_nested_type_limit = print_nested_type_limit;
771 /* Show how many nested type definitions the type printer will print. */
773 static void
774 show_print_type_nested_types (struct ui_file *file, int from_tty,
775 struct cmd_list_element *c, const char *value)
777 if (*value == '0')
779 gdb_printf (file,
780 _("Will not print nested types defined in a class\n"));
782 else
784 gdb_printf (file,
785 _("Will print %s nested types defined in a class\n"),
786 value);
790 /* When printing structs, offsets and sizes of members can be displayed using
791 decimal notation or hexadecimal notation. By default, Decimal notation is
792 used. */
794 static bool print_offsets_and_sizes_in_hex = false;
796 /* Set the flags that instructs if sizes and offsets of struct members are
797 displayed in hexadecimal or decimal notation. */
799 static void
800 set_print_offsets_and_sizes_in_hex (const char *args,
801 int from_tty, struct cmd_list_element *c)
803 default_ptype_flags.print_in_hex = print_offsets_and_sizes_in_hex;
806 /* Display whether struct members sizes and offsets are printed
807 using decimal or hexadecimal notation. */
809 static void
810 show_print_offsets_and_sizes_in_hex (struct ui_file *file, int from_tty,
811 struct cmd_list_element *c,
812 const char *value)
814 gdb_printf (file, _("\
815 Display of struct members offsets and sizes in hexadecimal is %s\n"),
816 value);
819 void _initialize_typeprint ();
820 void
821 _initialize_typeprint ()
823 struct cmd_list_element *c;
825 c = add_com ("ptype", class_vars, ptype_command, _("\
826 Print definition of type TYPE.\n\
827 Usage: ptype[/FLAGS] TYPE | EXPRESSION\n\
828 Argument may be any type (for example a type name defined by typedef,\n\
829 or \"struct STRUCT-TAG\" or \"class CLASS-NAME\" or \"union UNION-TAG\"\n\
830 or \"enum ENUM-TAG\") or an expression.\n\
831 The selected stack frame's lexical context is used to look up the name.\n\
832 Contrary to \"whatis\", \"ptype\" always unrolls any typedefs.\n\
834 Available FLAGS are:\n\
835 /r print in \"raw\" form; do not substitute typedefs\n\
836 /m do not print methods defined in a class\n\
837 /M print methods defined in a class\n\
838 /t do not print typedefs defined in a class\n\
839 /T print typedefs defined in a class\n\
840 /o print offsets and sizes of fields in a struct (like pahole)\n\
841 /x use hexadecimal notation when displaying sizes and offsets\n\
842 of struct members\n\
843 /d use decimal notation when displaying sizes and offsets\n\
844 of struct members "));
845 set_cmd_completer (c, expression_completer);
847 c = add_com ("whatis", class_vars, whatis_command,
848 _("Print data type of expression EXP.\n\
849 Only one level of typedefs is unrolled. See also \"ptype\"."));
850 set_cmd_completer (c, expression_completer);
852 add_setshow_prefix_cmd ("type", no_class,
853 _("Generic command for showing type-printing settings."),
854 _("Generic command for setting how types print."),
855 &setprinttypelist, &showprinttypelist,
856 &setprintlist, &showprintlist);
858 add_setshow_boolean_cmd ("methods", no_class, &print_methods,
859 _("\
860 Set printing of methods defined in classes."), _("\
861 Show printing of methods defined in classes."), NULL,
862 set_print_type_methods,
863 show_print_type_methods,
864 &setprinttypelist, &showprinttypelist);
865 add_setshow_boolean_cmd ("typedefs", no_class, &print_typedefs,
866 _("\
867 Set printing of typedefs defined in classes."), _("\
868 Show printing of typedefs defined in classes."), NULL,
869 set_print_type_typedefs,
870 show_print_type_typedefs,
871 &setprinttypelist, &showprinttypelist);
873 add_setshow_zuinteger_unlimited_cmd ("nested-type-limit", no_class,
874 &print_nested_type_limit,
875 _("\
876 Set the number of recursive nested type definitions to print \
877 (\"unlimited\" or -1 to show all)."), _("\
878 Show the number of recursive nested type definitions to print."), NULL,
879 set_print_type_nested_types,
880 show_print_type_nested_types,
881 &setprinttypelist, &showprinttypelist);
883 add_setshow_boolean_cmd ("hex", no_class, &print_offsets_and_sizes_in_hex,
884 _("\
885 Set printing of struct members sizes and offsets using hex notation."), _("\
886 Show whether sizes and offsets of struct members are printed using hex \
887 notation."), nullptr, set_print_offsets_and_sizes_in_hex,
888 show_print_offsets_and_sizes_in_hex,
889 &setprinttypelist, &showprinttypelist);
892 /* Print <not allocated> status to stream STREAM. */
894 void
895 val_print_not_allocated (struct ui_file *stream)
897 fprintf_styled (stream, metadata_style.style (), _("<not allocated>"));
900 /* Print <not associated> status to stream STREAM. */
902 void
903 val_print_not_associated (struct ui_file *stream)
905 fprintf_styled (stream, metadata_style.style (), _("<not associated>"));