gdb/typeprint.c

   1 /* Language independent support for printing types for GDB, the GNU debugger.
   2
   3    Copyright (C) 1986-2017 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   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.
  11
  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.
  16
  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/>.  */
  19
  20 #include "defs.h"
  21 #include "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
  40 const struct type_print_options type_print_raw_options =
  41 {
  42   1,                            /* raw */
  43   1,                            /* print_methods */
  44   1,                            /* print_typedefs */
  45   NULL,                         /* local_typedefs */
  46   NULL,                         /* global_table */
  47   NULL                          /* global_printers */
  48 };
  49
  50 /* The default flags for 'ptype' and 'whatis'.  */
  51
  52 static struct type_print_options default_ptype_flags =
  53 {
  54   0,                            /* raw */
  55   1,                            /* print_methods */
  56   1,                            /* print_typedefs */
  57   NULL,                         /* local_typedefs */
  58   NULL,                         /* global_table */
  59   NULL                          /* global_printers */
  60 };
  61
  62 \f
  63
  64 /* A hash table holding typedef_field objects.  This is more
  65    complicated than an ordinary hash because it must also track the
  66    lifetime of some -- but not all -- of the contained objects.  */
  67
  68 struct typedef_hash_table
  69 {
  70   /* The actual hash table.  */
  71   htab_t table;
  72
  73   /* Storage for typedef_field objects that must be synthesized.  */
  74   struct obstack storage;
  75 };
  76
  77 /* A hash function for a typedef_field.  */
  78
  79 static hashval_t
  80 hash_typedef_field (const void *p)
  81 {
  82   const struct typedef_field *tf = (const struct typedef_field *) p;
  83   struct type *t = check_typedef (tf->type);
  84
  85   return htab_hash_string (TYPE_SAFE_NAME (t));
  86 }
  87
  88 /* An equality function for a typedef field.  */
  89
  90 static int
  91 eq_typedef_field (const void *a, const void *b)
  92 {
  93   const struct typedef_field *tfa = (const struct typedef_field *) a;
  94   const struct typedef_field *tfb = (const struct typedef_field *) b;
  95
  96   return types_equal (tfa->type, tfb->type);
  97 }
  98
  99 /* Add typedefs from T to the hash table TABLE.  */
 100
 101 void
 102 recursively_update_typedef_hash (struct typedef_hash_table *table,
 103                                  struct type *t)
 104 {
 105   int i;
 106
 107   if (table == NULL)
 108     return;
 109
 110   for (i = 0; i < TYPE_TYPEDEF_FIELD_COUNT (t); ++i)
 111     {
 112       struct typedef_field *tdef = &TYPE_TYPEDEF_FIELD (t, i);
 113       void **slot;
 114
 115       slot = htab_find_slot (table->table, tdef, INSERT);
 116       /* Only add a given typedef name once.  Really this shouldn't
 117          happen; but it is safe enough to do the updates breadth-first
 118          and thus use the most specific typedef.  */
 119       if (*slot == NULL)
 120         *slot = tdef;
 121     }
 122
 123   /* Recurse into superclasses.  */
 124   for (i = 0; i < TYPE_N_BASECLASSES (t); ++i)
 125     recursively_update_typedef_hash (table, TYPE_BASECLASS (t, i));
 126 }
 127
 128 /* Add template parameters from T to the typedef hash TABLE.  */
 129
 130 void
 131 add_template_parameters (struct typedef_hash_table *table, struct type *t)
 132 {
 133   int i;
 134
 135   if (table == NULL)
 136     return;
 137
 138   for (i = 0; i < TYPE_N_TEMPLATE_ARGUMENTS (t); ++i)
 139     {
 140       struct typedef_field *tf;
 141       void **slot;
 142
 143       /* We only want type-valued template parameters in the hash.  */
 144       if (SYMBOL_CLASS (TYPE_TEMPLATE_ARGUMENT (t, i)) != LOC_TYPEDEF)
 145         continue;
 146
 147       tf = XOBNEW (&table->storage, struct typedef_field);
 148       tf->name = SYMBOL_LINKAGE_NAME (TYPE_TEMPLATE_ARGUMENT (t, i));
 149       tf->type = SYMBOL_TYPE (TYPE_TEMPLATE_ARGUMENT (t, i));
 150
 151       slot = htab_find_slot (table->table, tf, INSERT);
 152       if (*slot == NULL)
 153         *slot = tf;
 154     }
 155 }
 156
 157 /* Create a new typedef-lookup hash table.  */
 158
 159 struct typedef_hash_table *
 160 create_typedef_hash (void)
 161 {
 162   struct typedef_hash_table *result;
 163
 164   result = XNEW (struct typedef_hash_table);
 165   result->table = htab_create_alloc (10, hash_typedef_field, eq_typedef_field,
 166                                      NULL, xcalloc, xfree);
 167   obstack_init (&result->storage);
 168
 169   return result;
 170 }
 171
 172 /* Free a typedef field table.  */
 173
 174 void
 175 free_typedef_hash (struct typedef_hash_table *table)
 176 {
 177   if (table != NULL)
 178     {
 179       htab_delete (table->table);
 180       obstack_free (&table->storage, NULL);
 181       xfree (table);
 182     }
 183 }
 184
 185 /* A cleanup for freeing a typedef_hash_table.  */
 186
 187 static void
 188 do_free_typedef_hash (void *arg)
 189 {
 190   free_typedef_hash ((struct typedef_hash_table *) arg);
 191 }
 192
 193 /* Return a new cleanup that frees TABLE.  */
 194
 195 struct cleanup *
 196 make_cleanup_free_typedef_hash (struct typedef_hash_table *table)
 197 {
 198   return make_cleanup (do_free_typedef_hash, table);
 199 }
 200
 201 /* Helper function for copy_typedef_hash.  */
 202
 203 static int
 204 copy_typedef_hash_element (void **slot, void *nt)
 205 {
 206   htab_t new_table = (htab_t) nt;
 207   void **new_slot;
 208
 209   new_slot = htab_find_slot (new_table, *slot, INSERT);
 210   if (*new_slot == NULL)
 211     *new_slot = *slot;
 212
 213   return 1;
 214 }
 215
 216 /* Copy a typedef hash.  */
 217
 218 struct typedef_hash_table *
 219 copy_typedef_hash (struct typedef_hash_table *table)
 220 {
 221   struct typedef_hash_table *result;
 222
 223   if (table == NULL)
 224     return NULL;
 225
 226   result = create_typedef_hash ();
 227   htab_traverse_noresize (table->table, copy_typedef_hash_element,
 228                           result->table);
 229   return result;
 230 }
 231
 232 /* A cleanup to free the global typedef hash.  */
 233
 234 static void
 235 do_free_global_table (void *arg)
 236 {
 237   struct type_print_options *flags = (struct type_print_options *) arg;
 238
 239   free_typedef_hash (flags->global_typedefs);
 240   free_ext_lang_type_printers (flags->global_printers);
 241 }
 242
 243 /* Create the global typedef hash.  */
 244
 245 static struct cleanup *
 246 create_global_typedef_table (struct type_print_options *flags)
 247 {
 248   gdb_assert (flags->global_typedefs == NULL && flags->global_printers == NULL);
 249   flags->global_typedefs = create_typedef_hash ();
 250   flags->global_printers = start_ext_lang_type_printers ();
 251   return make_cleanup (do_free_global_table, flags);
 252 }
 253
 254 /* Look up the type T in the global typedef hash.  If it is found,
 255    return the typedef name.  If it is not found, apply the
 256    type-printers, if any, given by start_script_type_printers and return the
 257    result.  A NULL return means that the name was not found.  */
 258
 259 static const char *
 260 find_global_typedef (const struct type_print_options *flags,
 261                      struct type *t)
 262 {
 263   char *applied;
 264   void **slot;
 265   struct typedef_field tf, *new_tf;
 266
 267   if (flags->global_typedefs == NULL)
 268     return NULL;
 269
 270   tf.name = NULL;
 271   tf.type = t;
 272
 273   slot = htab_find_slot (flags->global_typedefs->table, &tf, INSERT);
 274   if (*slot != NULL)
 275     {
 276       new_tf = (struct typedef_field *) *slot;
 277       return new_tf->name;
 278     }
 279
 280   /* Put an entry into the hash table now, in case
 281      apply_ext_lang_type_printers recurses.  */
 282   new_tf = XOBNEW (&flags->global_typedefs->storage, struct typedef_field);
 283   new_tf->name = NULL;
 284   new_tf->type = t;
 285
 286   *slot = new_tf;
 287
 288   applied = apply_ext_lang_type_printers (flags->global_printers, t);
 289
 290   if (applied != NULL)
 291     {
 292       new_tf->name
 293         = (const char *) obstack_copy0 (&flags->global_typedefs->storage,
 294                                         applied, strlen (applied));
 295       xfree (applied);
 296     }
 297
 298   return new_tf->name;
 299 }
 300
 301 /* Look up the type T in the typedef hash table in with FLAGS.  If T
 302    is in the table, return its short (class-relative) typedef name.
 303    Otherwise return NULL.  If the table is NULL, this always returns
 304    NULL.  */
 305
 306 const char *
 307 find_typedef_in_hash (const struct type_print_options *flags, struct type *t)
 308 {
 309   if (flags->local_typedefs != NULL)
 310     {
 311       struct typedef_field tf, *found;
 312
 313       tf.name = NULL;
 314       tf.type = t;
 315       found = (struct typedef_field *) htab_find (flags->local_typedefs->table,
 316                                                   &tf);
 317
 318       if (found != NULL)
 319         return found->name;
 320     }
 321
 322   return find_global_typedef (flags, t);
 323 }
 324
 325 \f
 326
 327 /* Print a description of a type in the format of a
 328    typedef for the current language.
 329    NEW is the new name for a type TYPE.  */
 330
 331 void
 332 typedef_print (struct type *type, struct symbol *newobj, struct ui_file *stream)
 333 {
 334   LA_PRINT_TYPEDEF (type, newobj, stream);
 335 }
 336
 337 /* The default way to print a typedef.  */
 338
 339 void
 340 default_print_typedef (struct type *type, struct symbol *new_symbol,
 341                        struct ui_file *stream)
 342 {
 343   error (_("Language not supported."));
 344 }
 345
 346 /* Print a description of a type TYPE in the form of a declaration of a
 347    variable named VARSTRING.  (VARSTRING is demangled if necessary.)
 348    Output goes to STREAM (via stdio).
 349    If SHOW is positive, we show the contents of the outermost level
 350    of structure even if there is a type name that could be used instead.
 351    If SHOW is negative, we never show the details of elements' types.  */
 352
 353 void
 354 type_print (struct type *type, const char *varstring, struct ui_file *stream,
 355             int show)
 356 {
 357   LA_PRINT_TYPE (type, varstring, stream, show, 0, &default_ptype_flags);
 358 }
 359
 360 /* Print TYPE to a string, returning it.  The caller is responsible for
 361    freeing the string.  */
 362
 363 std::string
 364 type_to_string (struct type *type)
 365 {
 366   TRY
 367     {
 368       string_file stb;
 369
 370       type_print (type, "", &stb, -1);
 371       return std::move (stb.string ());
 372     }
 373   CATCH (except, RETURN_MASK_ALL)
 374     {
 375     }
 376   END_CATCH
 377
 378   return {};
 379 }
 380
 381 /* See typeprint.h.  */
 382
 383 void
 384 type_print_unknown_return_type (struct ui_file *stream)
 385 {
 386   fprintf_filtered (stream, _("<unknown return type>"));
 387 }
 388
 389 /* See typeprint.h.  */
 390
 391 void
 392 error_unknown_type (const char *sym_print_name)
 393 {
 394   error (_("'%s' has unknown type; cast it to its declared type"),
 395          sym_print_name);
 396 }
 397
 398 /* Print type of EXP, or last thing in value history if EXP == NULL.
 399    show is passed to type_print.  */
 400
 401 static void
 402 whatis_exp (const char *exp, int show)
 403 {
 404   struct value *val;
 405   struct cleanup *old_chain;
 406   struct type *real_type = NULL;
 407   struct type *type;
 408   int full = 0;
 409   LONGEST top = -1;
 410   int using_enc = 0;
 411   struct value_print_options opts;
 412   struct type_print_options flags = default_ptype_flags;
 413
 414   old_chain = make_cleanup (null_cleanup, NULL);
 415
 416   if (exp)
 417     {
 418       if (*exp == '/')
 419         {
 420           int seen_one = 0;
 421
 422           for (++exp; *exp && !isspace (*exp); ++exp)
 423             {
 424               switch (*exp)
 425                 {
 426                 case 'r':
 427                   flags.raw = 1;
 428                   break;
 429                 case 'm':
 430                   flags.print_methods = 0;
 431                   break;
 432                 case 'M':
 433                   flags.print_methods = 1;
 434                   break;
 435                 case 't':
 436                   flags.print_typedefs = 0;
 437                   break;
 438                 case 'T':
 439                   flags.print_typedefs = 1;
 440                   break;
 441                 default:
 442                   error (_("unrecognized flag '%c'"), *exp);
 443                 }
 444               seen_one = 1;
 445             }
 446
 447           if (!*exp && !seen_one)
 448             error (_("flag expected"));
 449           if (!isspace (*exp))
 450             error (_("expected space after format"));
 451           exp = skip_spaces (exp);
 452         }
 453
 454       expression_up expr = parse_expression (exp);
 455
 456       /* The behavior of "whatis" depends on whether the user
 457          expression names a type directly, or a language expression
 458          (including variable names).  If the former, then "whatis"
 459          strips one level of typedefs, only.  If an expression,
 460          "whatis" prints the type of the expression without stripping
 461          any typedef level.  "ptype" always strips all levels of
 462          typedefs.  */
 463       if (show == -1 && expr->elts[0].opcode == OP_TYPE)
 464         {
 465           /* The user expression names a type directly.  */
 466           type = expr->elts[1].type;
 467
 468           /* If this is a typedef, then find its immediate target.
 469              Use check_typedef to resolve stubs, but ignore its result
 470              because we do not want to dig past all typedefs.  */
 471           check_typedef (type);
 472           if (TYPE_CODE (type) == TYPE_CODE_TYPEDEF)
 473             type = TYPE_TARGET_TYPE (type);
 474         }
 475       else
 476         {
 477           /* The user expression names a type indirectly by naming an
 478              object or expression of that type.  Find that
 479              indirectly-named type.  */
 480           val = evaluate_type (expr.get ());
 481           type = value_type (val);
 482         }
 483     }
 484   else
 485     {
 486       val = access_value_history (0);
 487       type = value_type (val);
 488     }
 489
 490   get_user_print_options (&opts);
 491   if (opts.objectprint)
 492     {
 493       if (((TYPE_CODE (type) == TYPE_CODE_PTR) || TYPE_IS_REFERENCE (type))
 494           && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
 495         real_type = value_rtti_indirect_type (val, &full, &top, &using_enc);
 496       else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 497         real_type = value_rtti_type (val, &full, &top, &using_enc);
 498     }
 499
 500   printf_filtered ("type = ");
 501
 502   if (!flags.raw)
 503     create_global_typedef_table (&flags);
 504
 505   if (real_type)
 506     {
 507       printf_filtered ("/* real type = ");
 508       type_print (real_type, "", gdb_stdout, -1);
 509       if (! full)
 510         printf_filtered (" (incomplete object)");
 511       printf_filtered (" */\n");
 512     }
 513
 514   LA_PRINT_TYPE (type, "", gdb_stdout, show, 0, &flags);
 515   printf_filtered ("\n");
 516
 517   do_cleanups (old_chain);
 518 }
 519
 520 static void
 521 whatis_command (const char *exp, int from_tty)
 522 {
 523   /* Most of the time users do not want to see all the fields
 524      in a structure.  If they do they can use the "ptype" command.
 525      Hence the "-1" below.  */
 526   whatis_exp (exp, -1);
 527 }
 528
 529 /* TYPENAME is either the name of a type, or an expression.  */
 530
 531 static void
 532 ptype_command (const char *type_name, int from_tty)
 533 {
 534   whatis_exp (type_name, 1);
 535 }
 536
 537 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
 538    Used to print data from type structures in a specified type.  For example,
 539    array bounds may be characters or booleans in some languages, and this
 540    allows the ranges to be printed in their "natural" form rather than as
 541    decimal integer values.
 542
 543    FIXME:  This is here simply because only the type printing routines
 544    currently use it, and it wasn't clear if it really belonged somewhere
 545    else (like printcmd.c).  There are a lot of other gdb routines that do
 546    something similar, but they are generally concerned with printing values
 547    that come from the inferior in target byte order and target size.  */
 548
 549 void
 550 print_type_scalar (struct type *type, LONGEST val, struct ui_file *stream)
 551 {
 552   unsigned int i;
 553   unsigned len;
 554
 555   type = check_typedef (type);
 556
 557   switch (TYPE_CODE (type))
 558     {
 559
 560     case TYPE_CODE_ENUM:
 561       len = TYPE_NFIELDS (type);
 562       for (i = 0; i < len; i++)
 563         {
 564           if (TYPE_FIELD_ENUMVAL (type, i) == val)
 565             {
 566               break;
 567             }
 568         }
 569       if (i < len)
 570         {
 571           fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 572         }
 573       else
 574         {
 575           print_longest (stream, 'd', 0, val);
 576         }
 577       break;
 578
 579     case TYPE_CODE_INT:
 580       print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
 581       break;
 582
 583     case TYPE_CODE_CHAR:
 584       LA_PRINT_CHAR ((unsigned char) val, type, stream);
 585       break;
 586
 587     case TYPE_CODE_BOOL:
 588       fprintf_filtered (stream, val ? "TRUE" : "FALSE");
 589       break;
 590
 591     case TYPE_CODE_RANGE:
 592       print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
 593       return;
 594
 595     case TYPE_CODE_UNDEF:
 596     case TYPE_CODE_PTR:
 597     case TYPE_CODE_ARRAY:
 598     case TYPE_CODE_STRUCT:
 599     case TYPE_CODE_UNION:
 600     case TYPE_CODE_FUNC:
 601     case TYPE_CODE_FLT:
 602     case TYPE_CODE_VOID:
 603     case TYPE_CODE_SET:
 604     case TYPE_CODE_STRING:
 605     case TYPE_CODE_ERROR:
 606     case TYPE_CODE_MEMBERPTR:
 607     case TYPE_CODE_METHODPTR:
 608     case TYPE_CODE_METHOD:
 609     case TYPE_CODE_REF:
 610     case TYPE_CODE_RVALUE_REF:
 611     case TYPE_CODE_NAMESPACE:
 612       error (_("internal error: unhandled type in print_type_scalar"));
 613       break;
 614
 615     default:
 616       error (_("Invalid type code in symbol table."));
 617     }
 618   gdb_flush (stream);
 619 }
 620
 621 /* Dump details of a type specified either directly or indirectly.
 622    Uses the same sort of type lookup mechanism as ptype_command()
 623    and whatis_command().  */
 624
 625 void
 626 maintenance_print_type (const char *type_name, int from_tty)
 627 {
 628   struct value *val;
 629   struct type *type;
 630
 631   if (type_name != NULL)
 632     {
 633       expression_up expr = parse_expression (type_name);
 634       if (expr->elts[0].opcode == OP_TYPE)
 635         {
 636           /* The user expression names a type directly, just use that type.  */
 637           type = expr->elts[1].type;
 638         }
 639       else
 640         {
 641           /* The user expression may name a type indirectly by naming an
 642              object of that type.  Find that indirectly named type.  */
 643           val = evaluate_type (expr.get ());
 644           type = value_type (val);
 645         }
 646       if (type != NULL)
 647         {
 648           recursive_dump_type (type, 0);
 649         }
 650     }
 651 }
 652 \f
 653
 654 struct cmd_list_element *setprinttypelist;
 655
 656 struct cmd_list_element *showprinttypelist;
 657
 658 static void
 659 set_print_type (const char *arg, int from_tty)
 660 {
 661   printf_unfiltered (
 662      "\"set print type\" must be followed by the name of a subcommand.\n");
 663   help_list (setprintlist, "set print type ", all_commands, gdb_stdout);
 664 }
 665
 666 static void
 667 show_print_type (const char *args, int from_tty)
 668 {
 669   cmd_show_list (showprinttypelist, from_tty, "");
 670 }
 671
 672 static int print_methods = 1;
 673
 674 static void
 675 set_print_type_methods (const char *args,
 676                         int from_tty, struct cmd_list_element *c)
 677 {
 678   default_ptype_flags.print_methods = print_methods;
 679 }
 680
 681 static void
 682 show_print_type_methods (struct ui_file *file, int from_tty,
 683                          struct cmd_list_element *c, const char *value)
 684 {
 685   fprintf_filtered (file, _("Printing of methods defined in a class in %s\n"),
 686                     value);
 687 }
 688
 689 static int print_typedefs = 1;
 690
 691 static void
 692 set_print_type_typedefs (const char *args,
 693                          int from_tty, struct cmd_list_element *c)
 694 {
 695   default_ptype_flags.print_typedefs = print_typedefs;
 696 }
 697
 698 static void
 699 show_print_type_typedefs (struct ui_file *file, int from_tty,
 700                          struct cmd_list_element *c, const char *value)
 701 {
 702   fprintf_filtered (file, _("Printing of typedefs defined in a class in %s\n"),
 703                     value);
 704 }
 705
 706 void
 707 _initialize_typeprint (void)
 708 {
 709   struct cmd_list_element *c;
 710
 711   c = add_com ("ptype", class_vars, ptype_command, _("\
 712 Print definition of type TYPE.\n\
 713 Usage: ptype[/FLAGS] TYPE | EXPRESSION\n\
 714 Argument may be any type (for example a type name defined by typedef,\n\
 715 or \"struct STRUCT-TAG\" or \"class CLASS-NAME\" or \"union UNION-TAG\"\n\
 716 or \"enum ENUM-TAG\") or an expression.\n\
 717 The selected stack frame's lexical context is used to look up the name.\n\
 718 Contrary to \"whatis\", \"ptype\" always unrolls any typedefs.\n\
 719 \n\
 720 Available FLAGS are:\n\
 721   /r    print in \"raw\" form; do not substitute typedefs\n\
 722   /m    do not print methods defined in a class\n\
 723   /M    print methods defined in a class\n\
 724   /t    do not print typedefs defined in a class\n\
 725   /T    print typedefs defined in a class"));
 726   set_cmd_completer (c, expression_completer);
 727
 728   c = add_com ("whatis", class_vars, whatis_command,
 729                _("Print data type of expression EXP.\n\
 730 Only one level of typedefs is unrolled.  See also \"ptype\"."));
 731   set_cmd_completer (c, expression_completer);
 732
 733   add_prefix_cmd ("type", no_class, show_print_type,
 734                   _("Generic command for showing type-printing settings."),
 735                   &showprinttypelist, "show print type ", 0, &showprintlist);
 736   add_prefix_cmd ("type", no_class, set_print_type,
 737                   _("Generic command for setting how types print."),
 738                   &setprinttypelist, "show print type ", 0, &setprintlist);
 739
 740   add_setshow_boolean_cmd ("methods", no_class, &print_methods,
 741                            _("\
 742 Set printing of methods defined in classes."), _("\
 743 Show printing of methods defined in classes."), NULL,
 744                            set_print_type_methods,
 745                            show_print_type_methods,
 746                            &setprinttypelist, &showprinttypelist);
 747   add_setshow_boolean_cmd ("typedefs", no_class, &print_typedefs,
 748                            _("\
 749 Set printing of typedefs defined in classes."), _("\
 750 Show printing of typedefs defined in classes."), NULL,
 751                            set_print_type_typedefs,
 752                            show_print_type_typedefs,
 753                            &setprinttypelist, &showprinttypelist);
 754 }
 755
 756 /* Print <not allocated> status to stream STREAM.  */
 757
 758 void
 759 val_print_not_allocated (struct ui_file *stream)
 760 {
 761   fprintf_filtered (stream, _("<not allocated>"));
 762 }
 763
 764 /* Print <not associated> status to stream STREAM.  */
 765
 766 void
 767 val_print_not_associated (struct ui_file *stream)
 768 {
 769   fprintf_filtered (stream, _("<not associated>"));
 770 }