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