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_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       else
 494         {
 495           /* The user expression names a type indirectly by naming an
 496              object or expression of that type.  Find that
 497              indirectly-named type.  */
 498           val = evaluate_type (expr.get ());
 499           type = value_type (val);
 500         }
 501     }
 502   else
 503     {
 504       val = access_value_history (0);
 505       type = value_type (val);
 506     }
 507
 508   get_user_print_options (&opts);
 509   if (opts.objectprint)
 510     {
 511       if (((TYPE_CODE (type) == TYPE_CODE_PTR) || TYPE_IS_REFERENCE (type))
 512           && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_STRUCT))
 513         real_type = value_rtti_indirect_type (val, &full, &top, &using_enc);
 514       else if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
 515         real_type = value_rtti_type (val, &full, &top, &using_enc);
 516     }
 517
 518   if (flags.print_offsets
 519       && (TYPE_CODE (type) == TYPE_CODE_STRUCT
 520           || TYPE_CODE (type) == TYPE_CODE_UNION))
 521     fprintf_filtered (gdb_stdout, "/* offset    |  size */  ");
 522
 523   printf_filtered ("type = ");
 524
 525   if (!flags.raw)
 526     create_global_typedef_table (&flags);
 527
 528   if (real_type)
 529     {
 530       printf_filtered ("/* real type = ");
 531       type_print (real_type, "", gdb_stdout, -1);
 532       if (! full)
 533         printf_filtered (" (incomplete object)");
 534       printf_filtered (" */\n");
 535     }
 536
 537   LA_PRINT_TYPE (type, "", gdb_stdout, show, 0, &flags);
 538   printf_filtered ("\n");
 539
 540   do_cleanups (old_chain);
 541 }
 542
 543 static void
 544 whatis_command (const char *exp, int from_tty)
 545 {
 546   /* Most of the time users do not want to see all the fields
 547      in a structure.  If they do they can use the "ptype" command.
 548      Hence the "-1" below.  */
 549   whatis_exp (exp, -1);
 550 }
 551
 552 /* TYPENAME is either the name of a type, or an expression.  */
 553
 554 static void
 555 ptype_command (const char *type_name, int from_tty)
 556 {
 557   whatis_exp (type_name, 1);
 558 }
 559
 560 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
 561    Used to print data from type structures in a specified type.  For example,
 562    array bounds may be characters or booleans in some languages, and this
 563    allows the ranges to be printed in their "natural" form rather than as
 564    decimal integer values.
 565
 566    FIXME:  This is here simply because only the type printing routines
 567    currently use it, and it wasn't clear if it really belonged somewhere
 568    else (like printcmd.c).  There are a lot of other gdb routines that do
 569    something similar, but they are generally concerned with printing values
 570    that come from the inferior in target byte order and target size.  */
 571
 572 void
 573 print_type_scalar (struct type *type, LONGEST val, struct ui_file *stream)
 574 {
 575   unsigned int i;
 576   unsigned len;
 577
 578   type = check_typedef (type);
 579
 580   switch (TYPE_CODE (type))
 581     {
 582
 583     case TYPE_CODE_ENUM:
 584       len = TYPE_NFIELDS (type);
 585       for (i = 0; i < len; i++)
 586         {
 587           if (TYPE_FIELD_ENUMVAL (type, i) == val)
 588             {
 589               break;
 590             }
 591         }
 592       if (i < len)
 593         {
 594           fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 595         }
 596       else
 597         {
 598           print_longest (stream, 'd', 0, val);
 599         }
 600       break;
 601
 602     case TYPE_CODE_INT:
 603       print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
 604       break;
 605
 606     case TYPE_CODE_CHAR:
 607       LA_PRINT_CHAR ((unsigned char) val, type, stream);
 608       break;
 609
 610     case TYPE_CODE_BOOL:
 611       fprintf_filtered (stream, val ? "TRUE" : "FALSE");
 612       break;
 613
 614     case TYPE_CODE_RANGE:
 615       print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
 616       return;
 617
 618     case TYPE_CODE_UNDEF:
 619     case TYPE_CODE_PTR:
 620     case TYPE_CODE_ARRAY:
 621     case TYPE_CODE_STRUCT:
 622     case TYPE_CODE_UNION:
 623     case TYPE_CODE_FUNC:
 624     case TYPE_CODE_FLT:
 625     case TYPE_CODE_VOID:
 626     case TYPE_CODE_SET:
 627     case TYPE_CODE_STRING:
 628     case TYPE_CODE_ERROR:
 629     case TYPE_CODE_MEMBERPTR:
 630     case TYPE_CODE_METHODPTR:
 631     case TYPE_CODE_METHOD:
 632     case TYPE_CODE_REF:
 633     case TYPE_CODE_RVALUE_REF:
 634     case TYPE_CODE_NAMESPACE:
 635       error (_("internal error: unhandled type in print_type_scalar"));
 636       break;
 637
 638     default:
 639       error (_("Invalid type code in symbol table."));
 640     }
 641   gdb_flush (stream);
 642 }
 643
 644 /* Dump details of a type specified either directly or indirectly.
 645    Uses the same sort of type lookup mechanism as ptype_command()
 646    and whatis_command().  */
 647
 648 void
 649 maintenance_print_type (const char *type_name, int from_tty)
 650 {
 651   struct value *val;
 652   struct type *type;
 653
 654   if (type_name != NULL)
 655     {
 656       expression_up expr = parse_expression (type_name);
 657       if (expr->elts[0].opcode == OP_TYPE)
 658         {
 659           /* The user expression names a type directly, just use that type.  */
 660           type = expr->elts[1].type;
 661         }
 662       else
 663         {
 664           /* The user expression may name a type indirectly by naming an
 665              object of that type.  Find that indirectly named type.  */
 666           val = evaluate_type (expr.get ());
 667           type = value_type (val);
 668         }
 669       if (type != NULL)
 670         {
 671           recursive_dump_type (type, 0);
 672         }
 673     }
 674 }
 675 \f
 676
 677 struct cmd_list_element *setprinttypelist;
 678
 679 struct cmd_list_element *showprinttypelist;
 680
 681 static void
 682 set_print_type (const char *arg, int from_tty)
 683 {
 684   printf_unfiltered (
 685      "\"set print type\" must be followed by the name of a subcommand.\n");
 686   help_list (setprintlist, "set print type ", all_commands, gdb_stdout);
 687 }
 688
 689 static void
 690 show_print_type (const char *args, int from_tty)
 691 {
 692   cmd_show_list (showprinttypelist, from_tty, "");
 693 }
 694
 695 static int print_methods = 1;
 696
 697 static void
 698 set_print_type_methods (const char *args,
 699                         int from_tty, struct cmd_list_element *c)
 700 {
 701   default_ptype_flags.print_methods = print_methods;
 702 }
 703
 704 static void
 705 show_print_type_methods (struct ui_file *file, int from_tty,
 706                          struct cmd_list_element *c, const char *value)
 707 {
 708   fprintf_filtered (file, _("Printing of methods defined in a class in %s\n"),
 709                     value);
 710 }
 711
 712 static int print_typedefs = 1;
 713
 714 static void
 715 set_print_type_typedefs (const char *args,
 716                          int from_tty, struct cmd_list_element *c)
 717 {
 718   default_ptype_flags.print_typedefs = print_typedefs;
 719 }
 720
 721 static void
 722 show_print_type_typedefs (struct ui_file *file, int from_tty,
 723                          struct cmd_list_element *c, const char *value)
 724 {
 725   fprintf_filtered (file, _("Printing of typedefs defined in a class in %s\n"),
 726                     value);
 727 }
 728
 729 /* Limit on the number of nested type definitions to print or -1 to print
 730    all nested type definitions in a class.  By default, we do not print
 731    nested definitions.  */
 732
 733 static int print_nested_type_limit = 0;
 734
 735 /* Set how many nested type definitions should be printed by the type
 736    printer.  */
 737
 738 static void
 739 set_print_type_nested_types (const char *args, int from_tty,
 740                              struct cmd_list_element *c)
 741 {
 742   default_ptype_flags.print_nested_type_limit = print_nested_type_limit;
 743 }
 744
 745 /* Show how many nested type definitions the type printer will print.  */
 746
 747 static void
 748 show_print_type_nested_types  (struct ui_file *file, int from_tty,
 749                                struct cmd_list_element *c, const char *value)
 750 {
 751   if (*value == '0')
 752     {
 753       fprintf_filtered (file,
 754                         _("Will not print nested types defined in a class\n"));
 755     }
 756   else
 757     {
 758       fprintf_filtered (file,
 759                         _("Will print %s nested types defined in a class\n"),
 760                         value);
 761     }
 762 }
 763
 764 void
 765 _initialize_typeprint (void)
 766 {
 767   struct cmd_list_element *c;
 768
 769   c = add_com ("ptype", class_vars, ptype_command, _("\
 770 Print definition of type TYPE.\n\
 771 Usage: ptype[/FLAGS] TYPE | EXPRESSION\n\
 772 Argument may be any type (for example a type name defined by typedef,\n\
 773 or \"struct STRUCT-TAG\" or \"class CLASS-NAME\" or \"union UNION-TAG\"\n\
 774 or \"enum ENUM-TAG\") or an expression.\n\
 775 The selected stack frame's lexical context is used to look up the name.\n\
 776 Contrary to \"whatis\", \"ptype\" always unrolls any typedefs.\n\
 777 \n\
 778 Available FLAGS are:\n\
 779   /r    print in \"raw\" form; do not substitute typedefs\n\
 780   /m    do not print methods defined in a class\n\
 781   /M    print methods defined in a class\n\
 782   /t    do not print typedefs defined in a class\n\
 783   /T    print typedefs defined in a class\n\
 784   /o    print offsets and sizes of fields in a struct (like pahole)\n"));
 785   set_cmd_completer (c, expression_completer);
 786
 787   c = add_com ("whatis", class_vars, whatis_command,
 788                _("Print data type of expression EXP.\n\
 789 Only one level of typedefs is unrolled.  See also \"ptype\"."));
 790   set_cmd_completer (c, expression_completer);
 791
 792   add_prefix_cmd ("type", no_class, show_print_type,
 793                   _("Generic command for showing type-printing settings."),
 794                   &showprinttypelist, "show print type ", 0, &showprintlist);
 795   add_prefix_cmd ("type", no_class, set_print_type,
 796                   _("Generic command for setting how types print."),
 797                   &setprinttypelist, "show print type ", 0, &setprintlist);
 798
 799   add_setshow_boolean_cmd ("methods", no_class, &print_methods,
 800                            _("\
 801 Set printing of methods defined in classes."), _("\
 802 Show printing of methods defined in classes."), NULL,
 803                            set_print_type_methods,
 804                            show_print_type_methods,
 805                            &setprinttypelist, &showprinttypelist);
 806   add_setshow_boolean_cmd ("typedefs", no_class, &print_typedefs,
 807                            _("\
 808 Set printing of typedefs defined in classes."), _("\
 809 Show printing of typedefs defined in classes."), NULL,
 810                            set_print_type_typedefs,
 811                            show_print_type_typedefs,
 812                            &setprinttypelist, &showprinttypelist);
 813
 814   add_setshow_zuinteger_unlimited_cmd ("nested-type-limit", no_class,
 815                                        &print_nested_type_limit,
 816                                        _("\
 817 Set the number of recursive nested type definitions to print \
 818 (\"unlimited\" or -1 to show all)."), _("\
 819 Show the number of recursive nested type definitions to print."), NULL,
 820                                        set_print_type_nested_types,
 821                                        show_print_type_nested_types,
 822                                        &setprinttypelist, &showprinttypelist);
 823 }
 824
 825 /* Print <not allocated> status to stream STREAM.  */
 826
 827 void
 828 val_print_not_allocated (struct ui_file *stream)
 829 {
 830   fprintf_filtered (stream, _("<not allocated>"));
 831 }
 832
 833 /* Print <not associated> status to stream STREAM.  */
 834
 835 void
 836 val_print_not_associated (struct ui_file *stream)
 837 {
 838   fprintf_filtered (stream, _("<not associated>"));
 839 }