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