gdb/typeprint.c

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