gdb/typeprint.c

   1 /* Language independent support for printing types for GDB, the GNU debugger.
   2    Copyright 1986, 1988, 1989, 1991, 1992, 1993 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  19
  20 #include "defs.h"
  21 #include "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 "demangle.h"
  33
  34 #include "gdb_string.h"
  35 #include <errno.h>
  36
  37 static void
  38 ptype_command PARAMS ((char *, int));
  39
  40 static struct type *
  41 ptype_eval PARAMS ((struct expression *));
  42
  43 static void
  44 whatis_command PARAMS ((char *, int));
  45
  46 static void
  47 whatis_exp PARAMS ((char *, int));
  48
  49 /* Print a description of a type TYPE in the form of a declaration of a
  50    variable named VARSTRING.  (VARSTRING is demangled if necessary.)
  51    Output goes to STREAM (via stdio).
  52    If SHOW is positive, we show the contents of the outermost level
  53    of structure even if there is a type name that could be used instead.
  54    If SHOW is negative, we never show the details of elements' types.  */
  55
  56 void
  57 type_print (type, varstring, stream, show)
  58      struct type *type;
  59      char *varstring;
  60      GDB_FILE *stream;
  61      int show;
  62 {
  63   LA_PRINT_TYPE (type, varstring, stream, show, 0);
  64 }
  65
  66 /* Print type of EXP, or last thing in value history if EXP == NULL.
  67    show is passed to type_print.  */
  68
  69 static void
  70 whatis_exp (exp, show)
  71      char *exp;
  72      int show;
  73 {
  74   struct expression *expr;
  75   register value_ptr val;
  76   register struct cleanup *old_chain = NULL;
  77
  78   if (exp)
  79     {
  80       expr = parse_expression (exp);
  81       old_chain = make_cleanup (free_current_contents, &expr);
  82       val = evaluate_type (expr);
  83     }
  84   else
  85     val = access_value_history (0);
  86
  87   printf_filtered ("type = ");
  88   type_print (VALUE_TYPE (val), "", gdb_stdout, show);
  89   printf_filtered ("\n");
  90
  91   if (exp)
  92     do_cleanups (old_chain);
  93 }
  94
  95 /* ARGSUSED */
  96 static void
  97 whatis_command (exp, from_tty)
  98      char *exp;
  99      int from_tty;
 100 {
 101   /* Most of the time users do not want to see all the fields
 102      in a structure.  If they do they can use the "ptype" command.
 103      Hence the "-1" below.  */
 104   whatis_exp (exp, -1);
 105 }
 106
 107 /* Simple subroutine for ptype_command.  */
 108
 109 static struct type *
 110 ptype_eval (exp)
 111      struct expression *exp;
 112 {
 113   if (exp->elts[0].opcode == OP_TYPE)
 114     {
 115       return (exp->elts[1].type);
 116     }
 117   else
 118     {
 119       return (NULL);
 120     }
 121 }
 122
 123 /* TYPENAME is either the name of a type, or an expression.  */
 124
 125 /* ARGSUSED */
 126 static void
 127 ptype_command (typename, from_tty)
 128      char *typename;
 129      int from_tty;
 130 {
 131   register struct type *type;
 132   struct expression *expr;
 133   register struct cleanup *old_chain;
 134
 135   if (typename == NULL)
 136     {
 137       /* Print type of last thing in value history. */
 138       whatis_exp (typename, 1);
 139     }
 140   else
 141     {
 142       expr = parse_expression (typename);
 143       old_chain = make_cleanup (free_current_contents, &expr);
 144       type = ptype_eval (expr);
 145       if (type != NULL)
 146         {
 147           /* User did "ptype <typename>" */
 148           printf_filtered ("type = ");
 149           type_print (type, "", gdb_stdout, 1);
 150           printf_filtered ("\n");
 151           do_cleanups (old_chain);
 152         }
 153       else
 154         {
 155           /* User did "ptype <symbolname>" */
 156           do_cleanups (old_chain);
 157           whatis_exp (typename, 1);
 158         }
 159     }
 160 }
 161
 162 /* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
 163    Used to print data from type structures in a specified type.  For example,
 164    array bounds may be characters or booleans in some languages, and this
 165    allows the ranges to be printed in their "natural" form rather than as
 166    decimal integer values.
 167
 168    FIXME:  This is here simply because only the type printing routines
 169    currently use it, and it wasn't clear if it really belonged somewhere
 170    else (like printcmd.c).  There are a lot of other gdb routines that do
 171    something similar, but they are generally concerned with printing values
 172    that come from the inferior in target byte order and target size. */
 173
 174 void
 175 print_type_scalar (type, val, stream)
 176      struct type *type;
 177      LONGEST val;
 178      GDB_FILE *stream;
 179 {
 180   unsigned int i;
 181   unsigned len;
 182
 183   CHECK_TYPEDEF (type);
 184
 185   switch (TYPE_CODE (type))
 186     {
 187
 188     case TYPE_CODE_ENUM:
 189       len = TYPE_NFIELDS (type);
 190       for (i = 0; i < len; i++)
 191         {
 192           if (TYPE_FIELD_BITPOS (type, i) == val)
 193             {
 194               break;
 195             }
 196         }
 197       if (i < len)
 198         {
 199           fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
 200         }
 201       else
 202         {
 203           print_longest (stream, 'd', 0, val);
 204         }
 205       break;
 206
 207     case TYPE_CODE_INT:
 208       print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
 209       break;
 210
 211     case TYPE_CODE_CHAR:
 212       LA_PRINT_CHAR ((unsigned char) val, stream);
 213       break;
 214
 215     case TYPE_CODE_BOOL:
 216       fprintf_filtered (stream, val ? "TRUE" : "FALSE");
 217       break;
 218
 219     case TYPE_CODE_RANGE:
 220       print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
 221       return;
 222
 223     case TYPE_CODE_UNDEF:
 224     case TYPE_CODE_PTR:
 225     case TYPE_CODE_ARRAY:
 226     case TYPE_CODE_STRUCT:
 227     case TYPE_CODE_UNION:
 228     case TYPE_CODE_FUNC:
 229     case TYPE_CODE_FLT:
 230     case TYPE_CODE_VOID:
 231     case TYPE_CODE_SET:
 232     case TYPE_CODE_STRING:
 233     case TYPE_CODE_ERROR:
 234     case TYPE_CODE_MEMBER:
 235     case TYPE_CODE_METHOD:
 236     case TYPE_CODE_REF:
 237       error ("internal error: unhandled type in print_type_scalar");
 238       break;
 239
 240     default:
 241       error ("Invalid type code in symbol table.");
 242     }
 243   gdb_flush (stream);
 244 }
 245
 246 #if MAINTENANCE_CMDS
 247
 248 /* Dump details of a type specified either directly or indirectly.
 249    Uses the same sort of type lookup mechanism as ptype_command()
 250    and whatis_command(). */
 251
 252 void
 253 maintenance_print_type (typename, from_tty)
 254      char *typename;
 255      int from_tty;
 256 {
 257   register value_ptr val;
 258   register struct type *type;
 259   register struct cleanup *old_chain;
 260   struct expression *expr;
 261
 262   if (typename != NULL)
 263   {
 264     expr = parse_expression (typename);
 265     old_chain = make_cleanup (free_current_contents, &expr);
 266     if (expr -> elts[0].opcode == OP_TYPE)
 267       {
 268         /* The user expression names a type directly, just use that type. */
 269         type = expr -> elts[1].type;
 270       }
 271     else
 272       {
 273         /* The user expression may name a type indirectly by naming an
 274            object of that type.  Find that indirectly named type. */
 275         val = evaluate_type (expr);
 276         type = VALUE_TYPE (val);
 277       }
 278     if (type != NULL)
 279       {
 280         recursive_dump_type (type, 0);
 281       }
 282     do_cleanups (old_chain);
 283   }
 284 }
 285
 286 #endif  /* MAINTENANCE_CMDS */
 287
 288 \f
 289 void
 290 _initialize_typeprint ()
 291 {
 292
 293   add_com ("ptype", class_vars, ptype_command,
 294            "Print definition of type TYPE.\n\
 295 Argument may be a type name defined by typedef, or \"struct STRUCT-TAG\"\n\
 296 or \"class CLASS-NAME\" or \"union UNION-TAG\" or \"enum ENUM-TAG\".\n\
 297 The selected stack frame's lexical context is used to look up the name.");
 298
 299   add_com ("whatis", class_vars, whatis_command,
 300            "Print data type of expression EXP.");
 301
 302 }