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