Automatic date update in version.in
[binutils-gdb.git] / gdb / typeprint.c
blob3356bdde2e782bcf1551a39762b23625b1dcbbbd
1 /* Language independent support for printing types for GDB, the GNU debugger.
3 Copyright (C) 1986-2022 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 (TYPE_LENGTH (ftype), 4) :
142 pulongest (TYPE_LENGTH (ftype))));
143 return;
146 unsigned int bitpos = type->field (field_idx).loc_bitpos ();
147 unsigned int fieldsize_byte = TYPE_LENGTH (ftype);
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 (type) * 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 (type)));
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->la_language == language_c
482 || current_language->la_language == language_cplus
483 || current_language->la_language == language_rust))
485 flags.print_offsets = 1;
486 flags.print_typedefs = 0;
487 flags.print_methods = 0;
489 break;
491 case 'x':
492 flags.print_in_hex = 1;
493 break;
494 case 'd':
495 flags.print_in_hex = 0;
496 break;
497 default:
498 error (_("unrecognized flag '%c'"), *exp);
500 seen_one = 1;
503 if (!*exp && !seen_one)
504 error (_("flag expected"));
505 if (!isspace (*exp))
506 error (_("expected space after format"));
507 exp = skip_spaces (exp);
510 expression_up expr = parse_expression (exp);
512 /* The behavior of "whatis" depends on whether the user
513 expression names a type directly, or a language expression
514 (including variable names). If the former, then "whatis"
515 strips one level of typedefs, only. If an expression,
516 "whatis" prints the type of the expression without stripping
517 any typedef level. "ptype" always strips all levels of
518 typedefs. */
519 val = evaluate_type (expr.get ());
520 type = value_type (val);
522 if (show == -1 && expr->first_opcode () == OP_TYPE)
524 /* The user expression names a type directly. */
526 /* If this is a typedef, then find its immediate target.
527 Use check_typedef to resolve stubs, but ignore its result
528 because we do not want to dig past all typedefs. */
529 check_typedef (type);
530 if (type->code () == TYPE_CODE_TYPEDEF)
531 type = TYPE_TARGET_TYPE (type);
533 /* If the expression is actually a type, then there's no
534 value to fetch the dynamic type from. */
535 val = NULL;
538 else
540 val = access_value_history (0);
541 type = value_type (val);
544 get_user_print_options (&opts);
545 if (val != NULL && opts.objectprint)
547 if (type->is_pointer_or_reference ()
548 && (TYPE_TARGET_TYPE (type)->code () == TYPE_CODE_STRUCT))
549 real_type = value_rtti_indirect_type (val, &full, &top, &using_enc);
550 else if (type->code () == TYPE_CODE_STRUCT)
551 real_type = value_rtti_type (val, &full, &top, &using_enc);
554 if (flags.print_offsets
555 && (type->code () == TYPE_CODE_STRUCT
556 || type->code () == TYPE_CODE_UNION))
557 gdb_printf ("/* offset | size */ ");
559 gdb_printf ("type = ");
561 std::unique_ptr<typedef_hash_table> table_holder;
562 std::unique_ptr<ext_lang_type_printers> printer_holder;
563 if (!flags.raw)
565 table_holder.reset (new typedef_hash_table);
566 flags.global_typedefs = table_holder.get ();
568 printer_holder.reset (new ext_lang_type_printers);
569 flags.global_printers = printer_holder.get ();
572 if (real_type)
574 gdb_printf ("/* real type = ");
575 type_print (real_type, "", gdb_stdout, -1);
576 if (! full)
577 gdb_printf (" (incomplete object)");
578 gdb_printf (" */\n");
581 current_language->print_type (type, "", gdb_stdout, show, 0, &flags);
582 gdb_printf ("\n");
585 static void
586 whatis_command (const char *exp, int from_tty)
588 /* Most of the time users do not want to see all the fields
589 in a structure. If they do they can use the "ptype" command.
590 Hence the "-1" below. */
591 whatis_exp (exp, -1);
594 /* TYPENAME is either the name of a type, or an expression. */
596 static void
597 ptype_command (const char *type_name, int from_tty)
599 whatis_exp (type_name, 1);
602 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
603 Used to print data from type structures in a specified type. For example,
604 array bounds may be characters or booleans in some languages, and this
605 allows the ranges to be printed in their "natural" form rather than as
606 decimal integer values.
608 FIXME: This is here simply because only the type printing routines
609 currently use it, and it wasn't clear if it really belonged somewhere
610 else (like printcmd.c). There are a lot of other gdb routines that do
611 something similar, but they are generally concerned with printing values
612 that come from the inferior in target byte order and target size. */
614 void
615 print_type_scalar (struct type *type, LONGEST val, struct ui_file *stream)
617 unsigned int i;
618 unsigned len;
620 type = check_typedef (type);
622 switch (type->code ())
625 case TYPE_CODE_ENUM:
626 len = type->num_fields ();
627 for (i = 0; i < len; i++)
629 if (type->field (i).loc_enumval () == val)
631 break;
634 if (i < len)
636 gdb_puts (type->field (i).name (), stream);
638 else
640 print_longest (stream, 'd', 0, val);
642 break;
644 case TYPE_CODE_INT:
645 print_longest (stream, type->is_unsigned () ? 'u' : 'd', 0, val);
646 break;
648 case TYPE_CODE_CHAR:
649 current_language->printchar ((unsigned char) val, type, stream);
650 break;
652 case TYPE_CODE_BOOL:
653 gdb_printf (stream, val ? "TRUE" : "FALSE");
654 break;
656 case TYPE_CODE_RANGE:
657 print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
658 return;
660 case TYPE_CODE_FIXED_POINT:
661 print_type_fixed_point (type, stream);
662 break;
664 case TYPE_CODE_UNDEF:
665 case TYPE_CODE_PTR:
666 case TYPE_CODE_ARRAY:
667 case TYPE_CODE_STRUCT:
668 case TYPE_CODE_UNION:
669 case TYPE_CODE_FUNC:
670 case TYPE_CODE_FLT:
671 case TYPE_CODE_VOID:
672 case TYPE_CODE_SET:
673 case TYPE_CODE_STRING:
674 case TYPE_CODE_ERROR:
675 case TYPE_CODE_MEMBERPTR:
676 case TYPE_CODE_METHODPTR:
677 case TYPE_CODE_METHOD:
678 case TYPE_CODE_REF:
679 case TYPE_CODE_RVALUE_REF:
680 case TYPE_CODE_NAMESPACE:
681 error (_("internal error: unhandled type in print_type_scalar"));
682 break;
684 default:
685 error (_("Invalid type code in symbol table."));
689 /* See typeprint.h. */
691 void
692 print_type_fixed_point (struct type *type, struct ui_file *stream)
694 std::string small_img = type->fixed_point_scaling_factor ().str ();
696 gdb_printf (stream, "%s-byte fixed point (small = %s)",
697 pulongest (TYPE_LENGTH (type)), small_img.c_str ());
700 /* Dump details of a type specified either directly or indirectly.
701 Uses the same sort of type lookup mechanism as ptype_command()
702 and whatis_command(). */
704 void
705 maintenance_print_type (const char *type_name, int from_tty)
707 if (type_name != NULL)
709 expression_up expr = parse_expression (type_name);
710 struct value *val = evaluate_type (expr.get ());
711 struct type *type = value_type (val);
713 if (type != nullptr)
714 recursive_dump_type (type, 0);
719 struct cmd_list_element *setprinttypelist;
721 struct cmd_list_element *showprinttypelist;
723 static bool print_methods = true;
725 static void
726 set_print_type_methods (const char *args,
727 int from_tty, struct cmd_list_element *c)
729 default_ptype_flags.print_methods = print_methods;
732 static void
733 show_print_type_methods (struct ui_file *file, int from_tty,
734 struct cmd_list_element *c, const char *value)
736 gdb_printf (file, _("Printing of methods defined in a class in %s\n"),
737 value);
740 static bool print_typedefs = true;
742 static void
743 set_print_type_typedefs (const char *args,
744 int from_tty, struct cmd_list_element *c)
746 default_ptype_flags.print_typedefs = print_typedefs;
749 static void
750 show_print_type_typedefs (struct ui_file *file, int from_tty,
751 struct cmd_list_element *c, const char *value)
753 gdb_printf (file, _("Printing of typedefs defined in a class in %s\n"),
754 value);
757 /* Limit on the number of nested type definitions to print or -1 to print
758 all nested type definitions in a class. By default, we do not print
759 nested definitions. */
761 static int print_nested_type_limit = 0;
763 /* Set how many nested type definitions should be printed by the type
764 printer. */
766 static void
767 set_print_type_nested_types (const char *args, int from_tty,
768 struct cmd_list_element *c)
770 default_ptype_flags.print_nested_type_limit = print_nested_type_limit;
773 /* Show how many nested type definitions the type printer will print. */
775 static void
776 show_print_type_nested_types (struct ui_file *file, int from_tty,
777 struct cmd_list_element *c, const char *value)
779 if (*value == '0')
781 gdb_printf (file,
782 _("Will not print nested types defined in a class\n"));
784 else
786 gdb_printf (file,
787 _("Will print %s nested types defined in a class\n"),
788 value);
792 /* When printing structs, offsets and sizes of members can be displayed using
793 decimal notation or hexadecimal notation. By default, Decimal notation is
794 used. */
796 static bool print_offsets_and_sizes_in_hex = false;
798 /* Set the flags that instructs if sizes and offsets of struct members are
799 displayed in hexadecimal or decimal notation. */
801 static void
802 set_print_offsets_and_sizes_in_hex (const char *args,
803 int from_tty, struct cmd_list_element *c)
805 default_ptype_flags.print_in_hex = print_offsets_and_sizes_in_hex;
808 /* Display whether struct members sizes and offsets are printed
809 using decimal or hexadecimal notation. */
811 static void
812 show_print_offsets_and_sizes_in_hex (struct ui_file *file, int from_tty,
813 struct cmd_list_element *c,
814 const char *value)
816 gdb_printf (file, _("\
817 Display of struct members offsets and sizes in hexadecimal is %s\n"),
818 value);
821 void _initialize_typeprint ();
822 void
823 _initialize_typeprint ()
825 struct cmd_list_element *c;
827 c = add_com ("ptype", class_vars, ptype_command, _("\
828 Print definition of type TYPE.\n\
829 Usage: ptype[/FLAGS] TYPE | EXPRESSION\n\
830 Argument may be any type (for example a type name defined by typedef,\n\
831 or \"struct STRUCT-TAG\" or \"class CLASS-NAME\" or \"union UNION-TAG\"\n\
832 or \"enum ENUM-TAG\") or an expression.\n\
833 The selected stack frame's lexical context is used to look up the name.\n\
834 Contrary to \"whatis\", \"ptype\" always unrolls any typedefs.\n\
836 Available FLAGS are:\n\
837 /r print in \"raw\" form; do not substitute typedefs\n\
838 /m do not print methods defined in a class\n\
839 /M print methods defined in a class\n\
840 /t do not print typedefs defined in a class\n\
841 /T print typedefs defined in a class\n\
842 /o print offsets and sizes of fields in a struct (like pahole)\n\
843 /x use hexadecimal notation when displaying sizes and offsets\n\
844 of struct members\n\
845 /d use decimal notation when displaying sizes and offsets\n\
846 of struct members "));
847 set_cmd_completer (c, expression_completer);
849 c = add_com ("whatis", class_vars, whatis_command,
850 _("Print data type of expression EXP.\n\
851 Only one level of typedefs is unrolled. See also \"ptype\"."));
852 set_cmd_completer (c, expression_completer);
854 add_setshow_prefix_cmd ("type", no_class,
855 _("Generic command for showing type-printing settings."),
856 _("Generic command for setting how types print."),
857 &setprinttypelist, &showprinttypelist,
858 &setprintlist, &showprintlist);
860 add_setshow_boolean_cmd ("methods", no_class, &print_methods,
861 _("\
862 Set printing of methods defined in classes."), _("\
863 Show printing of methods defined in classes."), NULL,
864 set_print_type_methods,
865 show_print_type_methods,
866 &setprinttypelist, &showprinttypelist);
867 add_setshow_boolean_cmd ("typedefs", no_class, &print_typedefs,
868 _("\
869 Set printing of typedefs defined in classes."), _("\
870 Show printing of typedefs defined in classes."), NULL,
871 set_print_type_typedefs,
872 show_print_type_typedefs,
873 &setprinttypelist, &showprinttypelist);
875 add_setshow_zuinteger_unlimited_cmd ("nested-type-limit", no_class,
876 &print_nested_type_limit,
877 _("\
878 Set the number of recursive nested type definitions to print \
879 (\"unlimited\" or -1 to show all)."), _("\
880 Show the number of recursive nested type definitions to print."), NULL,
881 set_print_type_nested_types,
882 show_print_type_nested_types,
883 &setprinttypelist, &showprinttypelist);
885 add_setshow_boolean_cmd ("hex", no_class, &print_offsets_and_sizes_in_hex,
886 _("\
887 Set printing of struct members sizes and offsets using hex notation."), _("\
888 Show whether sizes and offsets of struct members are printed using hex \
889 notation."), nullptr, set_print_offsets_and_sizes_in_hex,
890 show_print_offsets_and_sizes_in_hex,
891 &setprinttypelist, &showprinttypelist);
894 /* Print <not allocated> status to stream STREAM. */
896 void
897 val_print_not_allocated (struct ui_file *stream)
899 fprintf_styled (stream, metadata_style.style (), _("<not allocated>"));
902 /* Print <not associated> status to stream STREAM. */
904 void
905 val_print_not_associated (struct ui_file *stream)
907 fprintf_styled (stream, metadata_style.style (), _("<not associated>"));