[binutils.git] / gdb / typeprint.c

/* Language independent support for printing types for GDB, the GNU debugger.
   Copyright 1986, 1988, 1989, 1991-1993, 1998, 2000 Free Software Foundation, Inc.

   This file is part of GDB.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"
#include "obstack.h"
#include "bfd.h"		/* Binary File Description */
#include "symtab.h"
#include "gdbtypes.h"
#include "expression.h"
#include "value.h"
#include "gdbcore.h"
#include "command.h"
#include "gdbcmd.h"
#include "target.h"
#include "language.h"
#include "demangle.h"

#include "gdb_string.h"
#include <errno.h>

/* For real-type printing in whatis_exp() */
extern int objectprint;		/* Controls looking up an object's derived type
				   using what we find in its vtables.  */

extern void _initialize_typeprint PARAMS ((void));

static void
ptype_command PARAMS ((char *, int));

static struct type *
  ptype_eval PARAMS ((struct expression *));

static void
whatis_command PARAMS ((char *, int));

static void
whatis_exp PARAMS ((char *, int));

/* Print a description of a type TYPE in the form of a declaration of a
   variable named VARSTRING.  (VARSTRING is demangled if necessary.)
   Output goes to STREAM (via stdio).
   If SHOW is positive, we show the contents of the outermost level
   of structure even if there is a type name that could be used instead.
   If SHOW is negative, we never show the details of elements' types.  */

void
type_print (type, varstring, stream, show)
     struct type *type;
     char *varstring;
     struct ui_file *stream;
     int show;
{
  LA_PRINT_TYPE (type, varstring, stream, show, 0);
}

/* Print type of EXP, or last thing in value history if EXP == NULL.
   show is passed to type_print.  */

static void
whatis_exp (exp, show)
     char *exp;
     int show;
{
  struct expression *expr;
  register value_ptr val;
  register struct cleanup *old_chain = NULL;
  struct type *real_type = NULL;
  struct type *type;
  int full = 0;
  int top = -1;
  int using_enc = 0;

  if (exp)
    {
      expr = parse_expression (exp);
      old_chain = make_cleanup ((make_cleanup_func) free_current_contents,
				&expr);
      val = evaluate_type (expr);
    }
  else
    val = access_value_history (0);

  type = VALUE_TYPE (val);

  if (objectprint)
    {
      if (((TYPE_CODE (type) == TYPE_CODE_PTR) ||
           (TYPE_CODE (type) == TYPE_CODE_REF))
          &&
          (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
        {
          real_type = value_rtti_target_type (val, &full, &top, &using_enc);
          if (real_type)
            {
              if (TYPE_CODE (type) == TYPE_CODE_PTR)
                real_type = lookup_pointer_type (real_type);
              else
                real_type = lookup_reference_type (real_type);
            }
        }
      else if (TYPE_CODE (type) == TYPE_CODE_CLASS)
  real_type = value_rtti_type (val, &full, &top, &using_enc);
    }

  printf_filtered ("type = ");

  if (real_type)
    {
      printf_filtered ("/* real type = ");
      type_print (real_type, "", gdb_stdout, -1);
      if (! full)
        printf_filtered (" (incomplete object)");
      printf_filtered (" */\n");    
    }

  type_print (type, "", gdb_stdout, show);
  printf_filtered ("\n");

  if (exp)
    do_cleanups (old_chain);
}

/* ARGSUSED */
static void
whatis_command (exp, from_tty)
     char *exp;
     int from_tty;
{
  /* Most of the time users do not want to see all the fields
     in a structure.  If they do they can use the "ptype" command.
     Hence the "-1" below.  */
  whatis_exp (exp, -1);
}

/* Simple subroutine for ptype_command.  */

static struct type *
ptype_eval (exp)
     struct expression *exp;
{
  if (exp->elts[0].opcode == OP_TYPE)
    {
      return (exp->elts[1].type);
    }
  else
    {
      return (NULL);
    }
}

/* TYPENAME is either the name of a type, or an expression.  */

/* ARGSUSED */
static void
ptype_command (typename, from_tty)
     char *typename;
     int from_tty;
{
  register struct type *type;
  struct expression *expr;
  register struct cleanup *old_chain;

  if (typename == NULL)
    {
      /* Print type of last thing in value history. */
      whatis_exp (typename, 1);
    }
  else
    {
      expr = parse_expression (typename);
      old_chain = make_cleanup ((make_cleanup_func) free_current_contents,
				&expr);
      type = ptype_eval (expr);
      if (type != NULL)
	{
	  /* User did "ptype <typename>" */
	  printf_filtered ("type = ");
	  type_print (type, "", gdb_stdout, 1);
	  printf_filtered ("\n");
	  do_cleanups (old_chain);
	}
      else
	{
	  /* User did "ptype <symbolname>" */
	  do_cleanups (old_chain);
	  whatis_exp (typename, 1);
	}
    }
}

/* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
   Used to print data from type structures in a specified type.  For example,
   array bounds may be characters or booleans in some languages, and this
   allows the ranges to be printed in their "natural" form rather than as
   decimal integer values.

   FIXME:  This is here simply because only the type printing routines
   currently use it, and it wasn't clear if it really belonged somewhere
   else (like printcmd.c).  There are a lot of other gdb routines that do
   something similar, but they are generally concerned with printing values
   that come from the inferior in target byte order and target size. */

void
print_type_scalar (type, val, stream)
     struct type *type;
     LONGEST val;
     struct ui_file *stream;
{
  unsigned int i;
  unsigned len;

  CHECK_TYPEDEF (type);

  switch (TYPE_CODE (type))
    {

    case TYPE_CODE_ENUM:
      len = TYPE_NFIELDS (type);
      for (i = 0; i < len; i++)
	{
	  if (TYPE_FIELD_BITPOS (type, i) == val)
	    {
	      break;
	    }
	}
      if (i < len)
	{
	  fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
	}
      else
	{
	  print_longest (stream, 'd', 0, val);
	}
      break;

    case TYPE_CODE_INT:
      print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
      break;

    case TYPE_CODE_CHAR:
      LA_PRINT_CHAR ((unsigned char) val, stream);
      break;

    case TYPE_CODE_BOOL:
      fprintf_filtered (stream, val ? "TRUE" : "FALSE");
      break;

    case TYPE_CODE_RANGE:
      print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
      return;

    case TYPE_CODE_UNDEF:
    case TYPE_CODE_PTR:
    case TYPE_CODE_ARRAY:
    case TYPE_CODE_STRUCT:
    case TYPE_CODE_UNION:
    case TYPE_CODE_FUNC:
    case TYPE_CODE_FLT:
    case TYPE_CODE_VOID:
    case TYPE_CODE_SET:
    case TYPE_CODE_STRING:
    case TYPE_CODE_ERROR:
    case TYPE_CODE_MEMBER:
    case TYPE_CODE_METHOD:
    case TYPE_CODE_REF:
      error ("internal error: unhandled type in print_type_scalar");
      break;

    default:
      error ("Invalid type code in symbol table.");
    }
  gdb_flush (stream);
}

/* Dump details of a type specified either directly or indirectly.
   Uses the same sort of type lookup mechanism as ptype_command()
   and whatis_command(). */

void
maintenance_print_type (typename, from_tty)
     char *typename;
     int from_tty;
{
  register value_ptr val;
  register struct type *type;
  register struct cleanup *old_chain;
  struct expression *expr;

  if (typename != NULL)
    {
      expr = parse_expression (typename);
      old_chain = make_cleanup ((make_cleanup_func) free_current_contents, &expr);
      if (expr->elts[0].opcode == OP_TYPE)
	{
	  /* The user expression names a type directly, just use that type. */
	  type = expr->elts[1].type;
	}
      else
	{
	  /* The user expression may name a type indirectly by naming an
	     object of that type.  Find that indirectly named type. */
	  val = evaluate_type (expr);
	  type = VALUE_TYPE (val);
	}
      if (type != NULL)
	{
	  recursive_dump_type (type, 0);
	}
      do_cleanups (old_chain);
    }
}
\f

void
_initialize_typeprint ()
{

  add_com ("ptype", class_vars, ptype_command,
	   "Print definition of type TYPE.\n\
Argument may be a type name defined by typedef, or \"struct STRUCT-TAG\"\n\
or \"class CLASS-NAME\" or \"union UNION-TAG\" or \"enum ENUM-TAG\".\n\
The selected stack frame's lexical context is used to look up the name.");

  add_com ("whatis", class_vars, whatis_command,
	   "Print data type of expression EXP.");

}
Commit	Line	Data
c906108c	1	/* Language independent support for printing types for GDB, the GNU debugger.
d9fcf2fb	2	Copyright 1986, 1988, 1989, 1991-1993, 1998, 2000 Free Software Foundation, Inc.
c906108c	3
c5aa993b	4	This file is part of GDB.
c906108c	5
c5aa993b JM	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.
c906108c	10
c5aa993b JM	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.
c906108c	15
c5aa993b JM	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,
	19	Boston, MA 02111-1307, USA. */
c906108c SS	20
	21	#include "defs.h"
	22	#include "obstack.h"
	23	#include "bfd.h" /* Binary File Description */
	24	#include "symtab.h"
	25	#include "gdbtypes.h"
	26	#include "expression.h"
	27	#include "value.h"
	28	#include "gdbcore.h"
	29	#include "command.h"
	30	#include "gdbcmd.h"
	31	#include "target.h"
	32	#include "language.h"
	33	#include "demangle.h"
	34
	35	#include "gdb_string.h"
	36	#include <errno.h>
	37
	38	/* For real-type printing in whatis_exp() */
	39	extern int objectprint; /* Controls looking up an object's derived type
	40	using what we find in its vtables. */
	41
392a587b JM	42	extern void _initialize_typeprint PARAMS ((void));
392a587b JM	43
c906108c SS	44	static void
	45	ptype_command PARAMS ((char *, int));
	46
	47	static struct type *
c5aa993b	48	ptype_eval PARAMS ((struct expression *));
c906108c SS	49
	50	static void
	51	whatis_command PARAMS ((char *, int));
	52
	53	static void
	54	whatis_exp PARAMS ((char *, int));
	55
	56	/* Print a description of a type TYPE in the form of a declaration of a
	57	variable named VARSTRING. (VARSTRING is demangled if necessary.)
	58	Output goes to STREAM (via stdio).
	59	If SHOW is positive, we show the contents of the outermost level
	60	of structure even if there is a type name that could be used instead.
	61	If SHOW is negative, we never show the details of elements' types. */
	62
	63	void
	64	type_print (type, varstring, stream, show)
	65	struct type *type;
	66	char *varstring;
d9fcf2fb	67	struct ui_file *stream;
c906108c SS	68	int show;
	69	{
	70	LA_PRINT_TYPE (type, varstring, stream, show, 0);
	71	}
	72
	73	/* Print type of EXP, or last thing in value history if EXP == NULL.
	74	show is passed to type_print. */
	75
	76	static void
	77	whatis_exp (exp, show)
	78	char *exp;
	79	int show;
	80	{
	81	struct expression *expr;
	82	register value_ptr val;
	83	register struct cleanup *old_chain = NULL;
c5aa993b	84	struct type *real_type = NULL;
070ad9f0	85	struct type *type;
c906108c SS	86	int full = 0;
	87	int top = -1;
	88	int using_enc = 0;
	89
	90	if (exp)
	91	{
	92	expr = parse_expression (exp);
c5aa993b JM	93	old_chain = make_cleanup ((make_cleanup_func) free_current_contents,
c5aa993b JM	94	&expr);
c906108c SS	95	val = evaluate_type (expr);
	96	}
	97	else
	98	val = access_value_history (0);
	99
070ad9f0 DB	100	type = VALUE_TYPE (val);
	101
	102	if (objectprint)
	103	{
	104	if (((TYPE_CODE (type) == TYPE_CODE_PTR) \|\|
	105	(TYPE_CODE (type) == TYPE_CODE_REF))
	106	&&
	107	(TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
	108	{
	109	real_type = value_rtti_target_type (val, &full, &top, &using_enc);
	110	if (real_type)
	111	{
	112	if (TYPE_CODE (type) == TYPE_CODE_PTR)
	113	real_type = lookup_pointer_type (real_type);
	114	else
	115	real_type = lookup_reference_type (real_type);
	116	}
	117	}
	118	else if (TYPE_CODE (type) == TYPE_CODE_CLASS)
c906108c	119	real_type = value_rtti_type (val, &full, &top, &using_enc);
070ad9f0	120	}
c906108c SS	121
	122	printf_filtered ("type = ");
	123
070ad9f0 DB	124	if (real_type)
	125	{
	126	printf_filtered ("/* real type = ");
	127	type_print (real_type, "", gdb_stdout, -1);
	128	if (! full)
	129	printf_filtered (" (incomplete object)");
	130	printf_filtered (" */\n");
	131	}
c906108c	132
070ad9f0	133	type_print (type, "", gdb_stdout, show);
c906108c SS	134	printf_filtered ("\n");
	135
	136	if (exp)
	137	do_cleanups (old_chain);
	138	}
	139
	140	/* ARGSUSED */
	141	static void
	142	whatis_command (exp, from_tty)
	143	char *exp;
	144	int from_tty;
	145	{
	146	/* Most of the time users do not want to see all the fields
	147	in a structure. If they do they can use the "ptype" command.
	148	Hence the "-1" below. */
	149	whatis_exp (exp, -1);
	150	}
	151
	152	/* Simple subroutine for ptype_command. */
	153
	154	static struct type *
	155	ptype_eval (exp)
	156	struct expression *exp;
	157	{
	158	if (exp->elts[0].opcode == OP_TYPE)
	159	{
	160	return (exp->elts[1].type);
	161	}
	162	else
	163	{
	164	return (NULL);
	165	}
	166	}
	167
	168	/* TYPENAME is either the name of a type, or an expression. */
	169
	170	/* ARGSUSED */
	171	static void
	172	ptype_command (typename, from_tty)
	173	char *typename;
	174	int from_tty;
	175	{
	176	register struct type *type;
	177	struct expression *expr;
	178	register struct cleanup *old_chain;
	179
	180	if (typename == NULL)
	181	{
	182	/* Print type of last thing in value history. */
	183	whatis_exp (typename, 1);
	184	}
	185	else
	186	{
	187	expr = parse_expression (typename);
c5aa993b JM	188	old_chain = make_cleanup ((make_cleanup_func) free_current_contents,
c5aa993b JM	189	&expr);
c906108c SS	190	type = ptype_eval (expr);
	191	if (type != NULL)
	192	{
	193	/* User did "ptype <typename>" */
	194	printf_filtered ("type = ");
	195	type_print (type, "", gdb_stdout, 1);
	196	printf_filtered ("\n");
	197	do_cleanups (old_chain);
	198	}
	199	else
	200	{
	201	/* User did "ptype <symbolname>" */
	202	do_cleanups (old_chain);
	203	whatis_exp (typename, 1);
	204	}
	205	}
	206	}
	207
	208	/* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
	209	Used to print data from type structures in a specified type. For example,
	210	array bounds may be characters or booleans in some languages, and this
	211	allows the ranges to be printed in their "natural" form rather than as
	212	decimal integer values.
	213
	214	FIXME: This is here simply because only the type printing routines
	215	currently use it, and it wasn't clear if it really belonged somewhere
	216	else (like printcmd.c). There are a lot of other gdb routines that do
	217	something similar, but they are generally concerned with printing values
	218	that come from the inferior in target byte order and target size. */
	219
	220	void
	221	print_type_scalar (type, val, stream)
	222	struct type *type;
	223	LONGEST val;
d9fcf2fb	224	struct ui_file *stream;
c906108c SS	225	{
	226	unsigned int i;
	227	unsigned len;
	228
	229	CHECK_TYPEDEF (type);
	230
	231	switch (TYPE_CODE (type))
	232	{
	233
	234	case TYPE_CODE_ENUM:
	235	len = TYPE_NFIELDS (type);
	236	for (i = 0; i < len; i++)
	237	{
	238	if (TYPE_FIELD_BITPOS (type, i) == val)
	239	{
	240	break;
	241	}
	242	}
	243	if (i < len)
	244	{
	245	fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
	246	}
	247	else
	248	{
	249	print_longest (stream, 'd', 0, val);
	250	}
	251	break;
	252
	253	case TYPE_CODE_INT:
	254	print_longest (stream, TYPE_UNSIGNED (type) ? 'u' : 'd', 0, val);
	255	break;
	256
	257	case TYPE_CODE_CHAR:
	258	LA_PRINT_CHAR ((unsigned char) val, stream);
	259	break;
	260
	261	case TYPE_CODE_BOOL:
	262	fprintf_filtered (stream, val ? "TRUE" : "FALSE");
	263	break;
	264
	265	case TYPE_CODE_RANGE:
	266	print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
	267	return;
	268
	269	case TYPE_CODE_UNDEF:
	270	case TYPE_CODE_PTR:
	271	case TYPE_CODE_ARRAY:
	272	case TYPE_CODE_STRUCT:
	273	case TYPE_CODE_UNION:
	274	case TYPE_CODE_FUNC:
	275	case TYPE_CODE_FLT:
	276	case TYPE_CODE_VOID:
	277	case TYPE_CODE_SET:
	278	case TYPE_CODE_STRING:
	279	case TYPE_CODE_ERROR:
	280	case TYPE_CODE_MEMBER:
	281	case TYPE_CODE_METHOD:
	282	case TYPE_CODE_REF:
	283	error ("internal error: unhandled type in print_type_scalar");
	284	break;
	285
	286	default:
	287	error ("Invalid type code in symbol table.");
	288	}
289	gdb_flush (stream);
290	}
291
c906108c SS	292	/* Dump details of a type specified either directly or indirectly.
	293	Uses the same sort of type lookup mechanism as ptype_command()
	294	and whatis_command(). */
	295
	296	void
	297	maintenance_print_type (typename, from_tty)
	298	char *typename;
	299	int from_tty;
	300	{
	301	register value_ptr val;
	302	register struct type *type;
	303	register struct cleanup *old_chain;
	304	struct expression *expr;
	305
	306	if (typename != NULL)
c5aa993b JM	307	{
	308	expr = parse_expression (typename);
	309	old_chain = make_cleanup ((make_cleanup_func) free_current_contents, &expr);
	310	if (expr->elts[0].opcode == OP_TYPE)
	311	{
	312	/* The user expression names a type directly, just use that type. */
	313	type = expr->elts[1].type;
	314	}
	315	else
	316	{
	317	/* The user expression may name a type indirectly by naming an
	318	object of that type. Find that indirectly named type. */
	319	val = evaluate_type (expr);
	320	type = VALUE_TYPE (val);
	321	}
	322	if (type != NULL)
	323	{
	324	recursive_dump_type (type, 0);
	325	}
	326	do_cleanups (old_chain);
	327	}
c906108c	328	}
c906108c	329	\f
c5aa993b	330
c906108c SS	331	void
	332	_initialize_typeprint ()
	333	{
	334
	335	add_com ("ptype", class_vars, ptype_command,
	336	"Print definition of type TYPE.\n\
	337	Argument may be a type name defined by typedef, or \"struct STRUCT-TAG\"\n\
	338	or \"class CLASS-NAME\" or \"union UNION-TAG\" or \"enum ENUM-TAG\".\n\
	339	The selected stack frame's lexical context is used to look up the name.");
	340
	341	add_com ("whatis", class_vars, whatis_command,
	342	"Print data type of expression EXP.");
	343
	344	}