[thirdparty/binutils-gdb.git] / gdb / c-valprint.c

/* Support for printing C values for GDB, the GNU debugger.

   Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996,
   1997, 1998, 1999, 2000, 2001, 2003, 2005 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 "gdb_string.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "expression.h"
#include "value.h"
#include "valprint.h"
#include "language.h"
#include "c-lang.h"
#include "cp-abi.h"
#include "target.h"
\f

/* Print function pointer with inferior address ADDRESS onto stdio
   stream STREAM.  */

static void
print_function_pointer_address (CORE_ADDR address, struct ui_file *stream)
{
  CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
							    address,
							    &current_target);

  /* If the function pointer is represented by a description, print the
     address of the description.  */
  if (addressprint && func_addr != address)
    {
      fputs_filtered ("@", stream);
      deprecated_print_address_numeric (address, 1, stream);
      fputs_filtered (": ", stream);
    }
  print_address_demangle (func_addr, stream, demangle);
}


/* Print data of type TYPE located at VALADDR (within GDB), which came from
   the inferior at address ADDRESS, onto stdio stream STREAM according to
   FORMAT (a letter or 0 for natural format).  The data at VALADDR is in
   target byte order.

   If the data are a string pointer, returns the number of string characters
   printed.

   If DEREF_REF is nonzero, then dereference references, otherwise just print
   them like pointers.

   The PRETTY parameter controls prettyprinting.  */

int
c_val_print (struct type *type, const bfd_byte *valaddr, int embedded_offset,
	     CORE_ADDR address, struct ui_file *stream, int format,
	     int deref_ref, int recurse, enum val_prettyprint pretty)
{
  unsigned int i = 0;	/* Number of characters printed */
  unsigned len;
  struct type *elttype;
  unsigned eltlen;
  LONGEST val;
  CORE_ADDR addr;

  CHECK_TYPEDEF (type);
  switch (TYPE_CODE (type))
    {
    case TYPE_CODE_ARRAY:
      elttype = check_typedef (TYPE_TARGET_TYPE (type));
      if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
	{
	  eltlen = TYPE_LENGTH (elttype);
	  len = TYPE_LENGTH (type) / eltlen;
	  if (prettyprint_arrays)
	    {
	      print_spaces_filtered (2 + 2 * recurse, stream);
	    }
	  /* For an array of chars, print with string syntax.  */
	  if (eltlen == 1 &&
	      ((TYPE_CODE (elttype) == TYPE_CODE_INT)
	       || ((current_language->la_language == language_m2)
		   && (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
	      && (format == 0 || format == 's'))
	    {
	      /* If requested, look for the first null char and only print
	         elements up to it.  */
	      if (stop_print_at_null)
		{
		  unsigned int temp_len;

		  /* Look for a NULL char. */
		  for (temp_len = 0;
		       (valaddr + embedded_offset)[temp_len]
		       && temp_len < len && temp_len < print_max;
		       temp_len++);
		  len = temp_len;
		}

	      LA_PRINT_STRING (stream, valaddr + embedded_offset, len, eltlen, 0);
	      i = len;
	    }
	  else
	    {
	      fprintf_filtered (stream, "{");
	      /* If this is a virtual function table, print the 0th
	         entry specially, and the rest of the members normally.  */
	      if (cp_is_vtbl_ptr_type (elttype))
		{
		  i = 1;
		  fprintf_filtered (stream, _("%d vtable entries"), len - 1);
		}
	      else
		{
		  i = 0;
		}
	      val_print_array_elements (type, valaddr + embedded_offset, address, stream,
				     format, deref_ref, recurse, pretty, i);
	      fprintf_filtered (stream, "}");
	    }
	  break;
	}
      /* Array of unspecified length: treat like pointer to first elt.  */
      addr = address;
      goto print_unpacked_pointer;

    case TYPE_CODE_PTR:
      if (format && format != 's')
	{
	  print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	  break;
	}
      if (vtblprint && cp_is_vtbl_ptr_type (type))
	{
	  /* Print the unmangled name if desired.  */
	  /* Print vtable entry - we only get here if we ARE using
	     -fvtable_thunks.  (Otherwise, look under TYPE_CODE_STRUCT.) */
	  CORE_ADDR addr
	    = extract_typed_address (valaddr + embedded_offset, type);
	  print_function_pointer_address (addr, stream);
	  break;
	}
      elttype = check_typedef (TYPE_TARGET_TYPE (type));
      if (TYPE_CODE (elttype) == TYPE_CODE_METHOD)
	{
	  cp_print_class_method (valaddr + embedded_offset, type, stream);
	}
      else if (TYPE_CODE (elttype) == TYPE_CODE_MEMBER)
	{
	  cp_print_class_member (valaddr + embedded_offset,
				 TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type)),
				 stream, "&");
	}
      else
	{
	  addr = unpack_pointer (type, valaddr + embedded_offset);
	print_unpacked_pointer:

	  if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
	    {
	      /* Try to print what function it points to.  */
	      print_function_pointer_address (addr, stream);
	      /* Return value is irrelevant except for string pointers.  */
	      return (0);
	    }

	  if (addressprint && format != 's')
	    {
	      deprecated_print_address_numeric (addr, 1, stream);
	    }

	  /* For a pointer to char or unsigned char, also print the string
	     pointed to, unless pointer is null.  */
	  /* FIXME: need to handle wchar_t here... */

	  if (TYPE_LENGTH (elttype) == 1
	      && TYPE_CODE (elttype) == TYPE_CODE_INT
	      && (format == 0 || format == 's')
	      && addr != 0)
	    {
	      i = val_print_string (addr, -1, TYPE_LENGTH (elttype), stream);
	    }
	  else if (cp_is_vtbl_member (type))
	    {
	      /* print vtbl's nicely */
	      CORE_ADDR vt_address = unpack_pointer (type, valaddr + embedded_offset);

	      struct minimal_symbol *msymbol =
	      lookup_minimal_symbol_by_pc (vt_address);
	      if ((msymbol != NULL) &&
		  (vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
		{
		  fputs_filtered (" <", stream);
		  fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
		  fputs_filtered (">", stream);
		}
	      if (vt_address && vtblprint)
		{
		  struct value *vt_val;
		  struct symbol *wsym = (struct symbol *) NULL;
		  struct type *wtype;
		  struct block *block = (struct block *) NULL;
		  int is_this_fld;

		  if (msymbol != NULL)
		    wsym = lookup_symbol (DEPRECATED_SYMBOL_NAME (msymbol), block,
					  VAR_DOMAIN, &is_this_fld, NULL);

		  if (wsym)
		    {
		      wtype = SYMBOL_TYPE (wsym);
		    }
		  else
		    {
		      wtype = TYPE_TARGET_TYPE (type);
		    }
		  vt_val = value_at (wtype, vt_address);
		  common_val_print (vt_val, stream, format,
				    deref_ref, recurse + 1, pretty);
		  if (pretty)
		    {
		      fprintf_filtered (stream, "\n");
		      print_spaces_filtered (2 + 2 * recurse, stream);
		    }
		}
	    }

	  /* Return number of characters printed, including the terminating
	     '\0' if we reached the end.  val_print_string takes care including
	     the terminating '\0' if necessary.  */
	  return i;
	}
      break;

    case TYPE_CODE_MEMBER:
      error (_("not implemented: member type in c_val_print"));
      break;

    case TYPE_CODE_REF:
      elttype = check_typedef (TYPE_TARGET_TYPE (type));
      if (TYPE_CODE (elttype) == TYPE_CODE_MEMBER)
	{
	  cp_print_class_member (valaddr + embedded_offset,
				 TYPE_DOMAIN_TYPE (elttype),
				 stream, "");
	  break;
	}
      if (addressprint)
	{
	  CORE_ADDR addr
	    = extract_typed_address (valaddr + embedded_offset, type);
	  fprintf_filtered (stream, "@");
	  deprecated_print_address_numeric (addr, 1, stream);
	  if (deref_ref)
	    fputs_filtered (": ", stream);
	}
      /* De-reference the reference.  */
      if (deref_ref)
	{
	  if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
	    {
	      struct value *deref_val =
	      value_at
	      (TYPE_TARGET_TYPE (type),
	       unpack_pointer (lookup_pointer_type (builtin_type_void),
			       valaddr + embedded_offset));
	      common_val_print (deref_val, stream, format, deref_ref,
				recurse, pretty);
	    }
	  else
	    fputs_filtered ("???", stream);
	}
      break;

    case TYPE_CODE_UNION:
      if (recurse && !unionprint)
	{
	  fprintf_filtered (stream, "{...}");
	  break;
	}
      /* Fall through.  */
    case TYPE_CODE_STRUCT:
      /*FIXME: Abstract this away */
      if (vtblprint && cp_is_vtbl_ptr_type (type))
	{
	  /* Print the unmangled name if desired.  */
	  /* Print vtable entry - we only get here if NOT using
	     -fvtable_thunks.  (Otherwise, look under TYPE_CODE_PTR.) */
	  int offset = (embedded_offset +
			TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8);
	  struct type *field_type = TYPE_FIELD_TYPE (type, VTBL_FNADDR_OFFSET);
	  CORE_ADDR addr
	    = extract_typed_address (valaddr + offset, field_type);

	  print_function_pointer_address (addr, stream);
	}
      else
	cp_print_value_fields (type, type, valaddr, embedded_offset, address, stream, format,
			       recurse, pretty, NULL, 0);
      break;

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

    case TYPE_CODE_FUNC:
      if (format)
	{
	  print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	  break;
	}
      /* FIXME, we should consider, at least for ANSI C language, eliminating
         the distinction made between FUNCs and POINTERs to FUNCs.  */
      fprintf_filtered (stream, "{");
      type_print (type, "", stream, -1);
      fprintf_filtered (stream, "} ");
      /* Try to print what function it points to, and its address.  */
      print_address_demangle (address, stream, demangle);
      break;

    case TYPE_CODE_BOOL:
      format = format ? format : output_format;
      if (format)
	print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
      else
	{
	  val = unpack_long (type, valaddr + embedded_offset);
	  if (val == 0)
	    fputs_filtered ("false", stream);
	  else if (val == 1)
	    fputs_filtered ("true", stream);
	  else
	    print_longest (stream, 'd', 0, val);
	}
      break;

    case TYPE_CODE_RANGE:
      /* FIXME: create_range_type does not set the unsigned bit in a
         range type (I think it probably should copy it from the target
         type), so we won't print values which are too large to
         fit in a signed integer correctly.  */
      /* FIXME: Doesn't handle ranges of enums correctly.  (Can't just
         print with the target type, though, because the size of our type
         and the target type might differ).  */
      /* FALLTHROUGH */

    case TYPE_CODE_INT:
      format = format ? format : output_format;
      if (format)
	{
	  print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	}
      else
	{
	  val_print_type_code_int (type, valaddr + embedded_offset, stream);
	  /* C and C++ has no single byte int type, char is used instead.
	     Since we don't know whether the value is really intended to
	     be used as an integer or a character, print the character
	     equivalent as well. */
	  if (TYPE_LENGTH (type) == 1)
	    {
	      fputs_filtered (" ", stream);
	      LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr + embedded_offset),
			     stream);
	    }
	}
      break;

    case TYPE_CODE_CHAR:
      format = format ? format : output_format;
      if (format)
	{
	  print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	}
      else
	{
	  val = unpack_long (type, valaddr + embedded_offset);
	  if (TYPE_UNSIGNED (type))
	    fprintf_filtered (stream, "%u", (unsigned int) val);
	  else
	    fprintf_filtered (stream, "%d", (int) val);
	  fputs_filtered (" ", stream);
	  LA_PRINT_CHAR ((unsigned char) val, stream);
	}
      break;

    case TYPE_CODE_FLT:
      if (format)
	{
	  print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	}
      else
	{
	  print_floating (valaddr + embedded_offset, type, stream);
	}
      break;

    case TYPE_CODE_METHOD:
      {
	struct value *v = value_at (type, address);
	cp_print_class_method (value_contents (value_addr (v)),
			       lookup_pointer_type (type), stream);
	break;
      }

    case TYPE_CODE_VOID:
      fprintf_filtered (stream, "void");
      break;

    case TYPE_CODE_ERROR:
      fprintf_filtered (stream, _("<error type>"));
      break;

    case TYPE_CODE_UNDEF:
      /* This happens (without TYPE_FLAG_STUB set) on systems which don't use
         dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
         and no complete type for struct foo in that file.  */
      fprintf_filtered (stream, _("<incomplete type>"));
      break;

    case TYPE_CODE_COMPLEX:
      if (format)
	print_scalar_formatted (valaddr + embedded_offset,
				TYPE_TARGET_TYPE (type),
				format, 0, stream);
      else
	print_floating (valaddr + embedded_offset, TYPE_TARGET_TYPE (type),
			stream);
      fprintf_filtered (stream, " + ");
      if (format)
	print_scalar_formatted (valaddr + embedded_offset
				+ TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
				TYPE_TARGET_TYPE (type),
				format, 0, stream);
      else
	print_floating (valaddr + embedded_offset
			+ TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
			TYPE_TARGET_TYPE (type),
			stream);
      fprintf_filtered (stream, " * I");
      break;

    default:
      error (_("Invalid C/C++ type code %d in symbol table."), TYPE_CODE (type));
    }
  gdb_flush (stream);
  return (0);
}
\f
int
c_value_print (struct value *val, struct ui_file *stream, int format,
	       enum val_prettyprint pretty)
{
  struct type *type, *real_type;
  int full, top, using_enc;

  /* If it is a pointer, indicate what it points to.

     Print type also if it is a reference.

     C++: if it is a member pointer, we will take care
     of that when we print it.  */

  type = check_typedef (value_type (val));

  if (TYPE_CODE (type) == TYPE_CODE_PTR
      || TYPE_CODE (type) == TYPE_CODE_REF)
    {
      /* Hack:  remove (char *) for char strings.  Their
         type is indicated by the quoted string anyway. */
      if (TYPE_CODE (type) == TYPE_CODE_PTR
	  && TYPE_NAME (type) == NULL
	  && TYPE_NAME (TYPE_TARGET_TYPE (type)) != NULL
	  && strcmp (TYPE_NAME (TYPE_TARGET_TYPE (type)), "char") == 0)
	{
	  /* Print nothing */
	}
      else if (objectprint && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
	{

	  if (TYPE_CODE(type) == TYPE_CODE_REF)
	    {
	      /* Copy value, change to pointer, so we don't get an
	       * error about a non-pointer type in value_rtti_target_type
	       */
	      struct value *temparg;
	      temparg=value_copy(val);
	      deprecated_set_value_type (temparg, lookup_pointer_type (TYPE_TARGET_TYPE(type)));
	      val=temparg;
	    }
	  /* Pointer to class, check real type of object */
	  fprintf_filtered (stream, "(");
          real_type = value_rtti_target_type (val, &full, &top, &using_enc);
          if (real_type)
	    {
	      /* RTTI entry found */
              if (TYPE_CODE (type) == TYPE_CODE_PTR)
                {
                  /* create a pointer type pointing to the real type */
                  type = lookup_pointer_type (real_type);
                }
              else
                {
                  /* create a reference type referencing the real type */
                  type = lookup_reference_type (real_type);
                }
	      /* JYG: Need to adjust pointer value. */
	      /* NOTE: cagney/2005-01-02: THIS IS BOGUS.  */
              value_contents_writeable (val)[0] -= top;

              /* Note: When we look up RTTI entries, we don't get any 
                 information on const or volatile attributes */
            }
          type_print (type, "", stream, -1);
	  fprintf_filtered (stream, ") ");
	}
      else
	{
	  /* normal case */
	  fprintf_filtered (stream, "(");
	  type_print (value_type (val), "", stream, -1);
	  fprintf_filtered (stream, ") ");
	}
    }

  if (objectprint && (TYPE_CODE (type) == TYPE_CODE_CLASS))
    {
      /* Attempt to determine real type of object */
      real_type = value_rtti_type (val, &full, &top, &using_enc);
      if (real_type)
	{
	  /* We have RTTI information, so use it */
	  val = value_full_object (val, real_type, full, top, using_enc);
	  fprintf_filtered (stream, "(%s%s) ",
			    TYPE_NAME (real_type),
			    full ? "" : _(" [incomplete object]"));
	  /* Print out object: enclosing type is same as real_type if full */
	  return val_print (value_enclosing_type (val),
			    value_contents_all (val), 0,
			    VALUE_ADDRESS (val), stream, format, 1, 0, pretty);
          /* Note: When we look up RTTI entries, we don't get any information on
             const or volatile attributes */
	}
      else if (type != check_typedef (value_enclosing_type (val)))
	{
	  /* No RTTI information, so let's do our best */
	  fprintf_filtered (stream, "(%s ?) ",
			    TYPE_NAME (value_enclosing_type (val)));
	  return val_print (value_enclosing_type (val),
			    value_contents_all (val), 0,
			    VALUE_ADDRESS (val), stream, format, 1, 0, pretty);
	}
      /* Otherwise, we end up at the return outside this "if" */
    }

  return val_print (type, value_contents_all (val),
		    value_embedded_offset (val),
		    VALUE_ADDRESS (val) + value_offset (val),
		    stream, format, 1, 0, pretty);
}
Commit	Line	Data
c906108c	1	/* Support for printing C values for GDB, the GNU debugger.
1bac305b AC	2
1bac305b AC	3	Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996,
4754a64e AC	4	1997, 1998, 1999, 2000, 2001, 2003, 2005 Free Software Foundation,
4754a64e AC	5	Inc.
c906108c	6
c5aa993b	7	This file is part of GDB.
c906108c	8
c5aa993b JM	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 2 of the License, or
	12	(at your option) any later version.
c906108c	13
c5aa993b JM	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
c906108c	18
c5aa993b JM	19	You should have received a copy of the GNU General Public License
	20	along with this program; if not, write to the Free Software
	21	Foundation, Inc., 59 Temple Place - Suite 330,
	22	Boston, MA 02111-1307, USA. */
c906108c SS	23
c906108c SS	24	#include "defs.h"
309367d4	25	#include "gdb_string.h"
c906108c SS	26	#include "symtab.h"
	27	#include "gdbtypes.h"
	28	#include "expression.h"
	29	#include "value.h"
c906108c SS	30	#include "valprint.h"
	31	#include "language.h"
	32	#include "c-lang.h"
015a42b4	33	#include "cp-abi.h"
e2d0e7eb	34	#include "target.h"
c906108c	35	\f
c5aa993b	36
6e778545 PS	37	/* Print function pointer with inferior address ADDRESS onto stdio
	38	stream STREAM. */
	39
	40	static void
	41	print_function_pointer_address (CORE_ADDR address, struct ui_file *stream)
	42	{
e2d0e7eb AC	43	CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
	44	address,
	45	&current_target);
6e778545 PS	46
	47	/* If the function pointer is represented by a description, print the
	48	address of the description. */
	49	if (addressprint && func_addr != address)
	50	{
	51	fputs_filtered ("@", stream);
66bf4b3a	52	deprecated_print_address_numeric (address, 1, stream);
6e778545 PS	53	fputs_filtered (": ", stream);
	54	}
	55	print_address_demangle (func_addr, stream, demangle);
	56	}
	57
	58
c906108c SS	59	/* Print data of type TYPE located at VALADDR (within GDB), which came from
	60	the inferior at address ADDRESS, onto stdio stream STREAM according to
	61	FORMAT (a letter or 0 for natural format). The data at VALADDR is in
	62	target byte order.
	63
	64	If the data are a string pointer, returns the number of string characters
	65	printed.
	66
	67	If DEREF_REF is nonzero, then dereference references, otherwise just print
	68	them like pointers.
	69
	70	The PRETTY parameter controls prettyprinting. */
	71
	72	int
a2bd3dcd	73	c_val_print (struct type type, const bfd_byte valaddr, int embedded_offset,
fba45db2 KB	74	CORE_ADDR address, struct ui_file *stream, int format,
fba45db2 KB	75	int deref_ref, int recurse, enum val_prettyprint pretty)
c906108c	76	{
52f0bd74	77	unsigned int i = 0; /* Number of characters printed */
c906108c SS	78	unsigned len;
	79	struct type *elttype;
	80	unsigned eltlen;
	81	LONGEST val;
	82	CORE_ADDR addr;
	83
	84	CHECK_TYPEDEF (type);
	85	switch (TYPE_CODE (type))
	86	{
	87	case TYPE_CODE_ARRAY:
	88	elttype = check_typedef (TYPE_TARGET_TYPE (type));
	89	if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
	90	{
	91	eltlen = TYPE_LENGTH (elttype);
	92	len = TYPE_LENGTH (type) / eltlen;
	93	if (prettyprint_arrays)
	94	{
	95	print_spaces_filtered (2 + 2 * recurse, stream);
	96	}
	97	/* For an array of chars, print with string syntax. */
	98	if (eltlen == 1 &&
	99	((TYPE_CODE (elttype) == TYPE_CODE_INT)
	100	\|\| ((current_language->la_language == language_m2)
	101	&& (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
	102	&& (format == 0 \|\| format == 's'))
	103	{
	104	/* If requested, look for the first null char and only print
c5aa993b	105	elements up to it. */
c906108c SS	106	if (stop_print_at_null)
c906108c SS	107	{
745b8ca0	108	unsigned int temp_len;
c5aa993b	109
c906108c SS	110	/* Look for a NULL char. */
	111	for (temp_len = 0;
	112	(valaddr + embedded_offset)[temp_len]
	113	&& temp_len < len && temp_len < print_max;
	114	temp_len++);
	115	len = temp_len;
	116	}
c5aa993b	117
c906108c SS	118	LA_PRINT_STRING (stream, valaddr + embedded_offset, len, eltlen, 0);
	119	i = len;
	120	}
	121	else
	122	{
	123	fprintf_filtered (stream, "{");
	124	/* If this is a virtual function table, print the 0th
c5aa993b	125	entry specially, and the rest of the members normally. */
c906108c SS	126	if (cp_is_vtbl_ptr_type (elttype))
	127	{
	128	i = 1;
3d263c1d	129	fprintf_filtered (stream, _("%d vtable entries"), len - 1);
c906108c SS	130	}
	131	else
	132	{
	133	i = 0;
	134	}
	135	val_print_array_elements (type, valaddr + embedded_offset, address, stream,
c5aa993b	136	format, deref_ref, recurse, pretty, i);
c906108c SS	137	fprintf_filtered (stream, "}");
	138	}
	139	break;
	140	}
	141	/* Array of unspecified length: treat like pointer to first elt. */
	142	addr = address;
	143	goto print_unpacked_pointer;
	144
	145	case TYPE_CODE_PTR:
	146	if (format && format != 's')
	147	{
	148	print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	149	break;
	150	}
c5aa993b	151	if (vtblprint && cp_is_vtbl_ptr_type (type))
c906108c	152	{
c5aa993b	153	/* Print the unmangled name if desired. */
c906108c SS	154	/* Print vtable entry - we only get here if we ARE using
c906108c SS	155	-fvtable_thunks. (Otherwise, look under TYPE_CODE_STRUCT.) */
4478b372 JB	156	CORE_ADDR addr
4478b372 JB	157	= extract_typed_address (valaddr + embedded_offset, type);
6e778545	158	print_function_pointer_address (addr, stream);
c906108c SS	159	break;
	160	}
	161	elttype = check_typedef (TYPE_TARGET_TYPE (type));
	162	if (TYPE_CODE (elttype) == TYPE_CODE_METHOD)
	163	{
	164	cp_print_class_method (valaddr + embedded_offset, type, stream);
	165	}
	166	else if (TYPE_CODE (elttype) == TYPE_CODE_MEMBER)
	167	{
	168	cp_print_class_member (valaddr + embedded_offset,
	169	TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type)),
	170	stream, "&");
	171	}
	172	else
	173	{
	174	addr = unpack_pointer (type, valaddr + embedded_offset);
	175	print_unpacked_pointer:
c906108c SS	176
	177	if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
	178	{
	179	/* Try to print what function it points to. */
6e778545	180	print_function_pointer_address (addr, stream);
c906108c SS	181	/* Return value is irrelevant except for string pointers. */
	182	return (0);
	183	}
	184
	185	if (addressprint && format != 's')
	186	{
66bf4b3a	187	deprecated_print_address_numeric (addr, 1, stream);
c906108c SS	188	}
	189
	190	/* For a pointer to char or unsigned char, also print the string
	191	pointed to, unless pointer is null. */
	192	/* FIXME: need to handle wchar_t here... */
	193
	194	if (TYPE_LENGTH (elttype) == 1
	195	&& TYPE_CODE (elttype) == TYPE_CODE_INT
	196	&& (format == 0 \|\| format == 's')
	197	&& addr != 0)
	198	{
	199	i = val_print_string (addr, -1, TYPE_LENGTH (elttype), stream);
	200	}
c5aa993b JM	201	else if (cp_is_vtbl_member (type))
c5aa993b JM	202	{
c906108c SS	203	/* print vtbl's nicely */
	204	CORE_ADDR vt_address = unpack_pointer (type, valaddr + embedded_offset);
	205
	206	struct minimal_symbol *msymbol =
c5aa993b	207	lookup_minimal_symbol_by_pc (vt_address);
c906108c SS	208	if ((msymbol != NULL) &&
	209	(vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
	210	{
	211	fputs_filtered (" <", stream);
de5ad195	212	fputs_filtered (SYMBOL_PRINT_NAME (msymbol), stream);
c906108c SS	213	fputs_filtered (">", stream);
	214	}
	215	if (vt_address && vtblprint)
c5aa993b	216	{
6943961c	217	struct value *vt_val;
c5aa993b JM	218	struct symbol wsym = (struct symbol ) NULL;
c5aa993b JM	219	struct type *wtype;
c5aa993b	220	struct block block = (struct block ) NULL;
c906108c SS	221	int is_this_fld;
	222
	223	if (msymbol != NULL)
22abf04a	224	wsym = lookup_symbol (DEPRECATED_SYMBOL_NAME (msymbol), block,
cdef89d0	225	VAR_DOMAIN, &is_this_fld, NULL);
c5aa993b	226
c906108c SS	227	if (wsym)
c906108c SS	228	{
c5aa993b	229	wtype = SYMBOL_TYPE (wsym);
c906108c SS	230	}
	231	else
	232	{
c5aa993b	233	wtype = TYPE_TARGET_TYPE (type);
c906108c	234	}
00a4c844	235	vt_val = value_at (wtype, vt_address);
806048c6 DJ	236	common_val_print (vt_val, stream, format,
806048c6 DJ	237	deref_ref, recurse + 1, pretty);
c906108c SS	238	if (pretty)
	239	{
	240	fprintf_filtered (stream, "\n");
	241	print_spaces_filtered (2 + 2 * recurse, stream);
	242	}
c5aa993b JM	243	}
c5aa993b JM	244	}
c906108c SS	245
	246	/* Return number of characters printed, including the terminating
	247	'\0' if we reached the end. val_print_string takes care including
	248	the terminating '\0' if necessary. */
	249	return i;
	250	}
	251	break;
	252
	253	case TYPE_CODE_MEMBER:
3d263c1d	254	error (_("not implemented: member type in c_val_print"));
c906108c SS	255	break;
	256
	257	case TYPE_CODE_REF:
	258	elttype = check_typedef (TYPE_TARGET_TYPE (type));
	259	if (TYPE_CODE (elttype) == TYPE_CODE_MEMBER)
c5aa993b	260	{
c906108c SS	261	cp_print_class_member (valaddr + embedded_offset,
	262	TYPE_DOMAIN_TYPE (elttype),
	263	stream, "");
	264	break;
	265	}
	266	if (addressprint)
c5aa993b	267	{
4478b372 JB	268	CORE_ADDR addr
4478b372 JB	269	= extract_typed_address (valaddr + embedded_offset, type);
c906108c	270	fprintf_filtered (stream, "@");
66bf4b3a	271	deprecated_print_address_numeric (addr, 1, stream);
c906108c SS	272	if (deref_ref)
c906108c SS	273	fputs_filtered (": ", stream);
c5aa993b	274	}
c906108c SS	275	/* De-reference the reference. */
	276	if (deref_ref)
	277	{
	278	if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
	279	{
6943961c	280	struct value *deref_val =
c5aa993b JM	281	value_at
	282	(TYPE_TARGET_TYPE (type),
	283	unpack_pointer (lookup_pointer_type (builtin_type_void),
00a4c844	284	valaddr + embedded_offset));
806048c6 DJ	285	common_val_print (deref_val, stream, format, deref_ref,
806048c6 DJ	286	recurse, pretty);
c906108c SS	287	}
	288	else
	289	fputs_filtered ("???", stream);
	290	}
	291	break;
	292
	293	case TYPE_CODE_UNION:
	294	if (recurse && !unionprint)
	295	{
	296	fprintf_filtered (stream, "{...}");
	297	break;
	298	}
	299	/* Fall through. */
	300	case TYPE_CODE_STRUCT:
015a42b4	301	/FIXME: Abstract this away /
c5aa993b	302	if (vtblprint && cp_is_vtbl_ptr_type (type))
c906108c	303	{
c5aa993b	304	/* Print the unmangled name if desired. */
c906108c SS	305	/* Print vtable entry - we only get here if NOT using
c906108c SS	306	-fvtable_thunks. (Otherwise, look under TYPE_CODE_PTR.) */
4478b372 JB	307	int offset = (embedded_offset +
	308	TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8);
	309	struct type *field_type = TYPE_FIELD_TYPE (type, VTBL_FNADDR_OFFSET);
	310	CORE_ADDR addr
	311	= extract_typed_address (valaddr + offset, field_type);
	312
6e778545	313	print_function_pointer_address (addr, stream);
c906108c SS	314	}
	315	else
	316	cp_print_value_fields (type, type, valaddr, embedded_offset, address, stream, format,
	317	recurse, pretty, NULL, 0);
	318	break;
	319
	320	case TYPE_CODE_ENUM:
	321	if (format)
	322	{
	323	print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	324	break;
	325	}
	326	len = TYPE_NFIELDS (type);
	327	val = unpack_long (type, valaddr + embedded_offset);
	328	for (i = 0; i < len; i++)
	329	{
	330	QUIT;
	331	if (val == TYPE_FIELD_BITPOS (type, i))
	332	{
	333	break;
	334	}
	335	}
	336	if (i < len)
	337	{
	338	fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
	339	}
	340	else
	341	{
	342	print_longest (stream, 'd', 0, val);
	343	}
	344	break;
	345
	346	case TYPE_CODE_FUNC:
	347	if (format)
	348	{
	349	print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	350	break;
	351	}
	352	/* FIXME, we should consider, at least for ANSI C language, eliminating
c5aa993b	353	the distinction made between FUNCs and POINTERs to FUNCs. */
c906108c SS	354	fprintf_filtered (stream, "{");
	355	type_print (type, "", stream, -1);
	356	fprintf_filtered (stream, "} ");
	357	/* Try to print what function it points to, and its address. */
	358	print_address_demangle (address, stream, demangle);
	359	break;
	360
	361	case TYPE_CODE_BOOL:
	362	format = format ? format : output_format;
	363	if (format)
	364	print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	365	else
	366	{
	367	val = unpack_long (type, valaddr + embedded_offset);
	368	if (val == 0)
	369	fputs_filtered ("false", stream);
	370	else if (val == 1)
	371	fputs_filtered ("true", stream);
	372	else
	373	print_longest (stream, 'd', 0, val);
	374	}
	375	break;
	376
	377	case TYPE_CODE_RANGE:
	378	/* FIXME: create_range_type does not set the unsigned bit in a
c5aa993b JM	379	range type (I think it probably should copy it from the target
	380	type), so we won't print values which are too large to
	381	fit in a signed integer correctly. */
c906108c	382	/* FIXME: Doesn't handle ranges of enums correctly. (Can't just
c5aa993b JM	383	print with the target type, though, because the size of our type
c5aa993b JM	384	and the target type might differ). */
c906108c SS	385	/* FALLTHROUGH */
	386
	387	case TYPE_CODE_INT:
	388	format = format ? format : output_format;
	389	if (format)
	390	{
	391	print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	392	}
	393	else
	394	{
	395	val_print_type_code_int (type, valaddr + embedded_offset, stream);
	396	/* C and C++ has no single byte int type, char is used instead.
	397	Since we don't know whether the value is really intended to
	398	be used as an integer or a character, print the character
	399	equivalent as well. */
	400	if (TYPE_LENGTH (type) == 1)
	401	{
	402	fputs_filtered (" ", stream);
	403	LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr + embedded_offset),
	404	stream);
	405	}
	406	}
	407	break;
	408
	409	case TYPE_CODE_CHAR:
	410	format = format ? format : output_format;
	411	if (format)
	412	{
	413	print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	414	}
	415	else
	416	{
96baa820 JM	417	val = unpack_long (type, valaddr + embedded_offset);
	418	if (TYPE_UNSIGNED (type))
	419	fprintf_filtered (stream, "%u", (unsigned int) val);
	420	else
	421	fprintf_filtered (stream, "%d", (int) val);
c906108c	422	fputs_filtered (" ", stream);
96baa820	423	LA_PRINT_CHAR ((unsigned char) val, stream);
c906108c SS	424	}
	425	break;
	426
	427	case TYPE_CODE_FLT:
	428	if (format)
	429	{
	430	print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	431	}
	432	else
	433	{
	434	print_floating (valaddr + embedded_offset, type, stream);
	435	}
	436	break;
	437
	438	case TYPE_CODE_METHOD:
acf5ed49	439	{
00a4c844	440	struct value *v = value_at (type, address);
0fd88904	441	cp_print_class_method (value_contents (value_addr (v)),
acf5ed49 DJ	442	lookup_pointer_type (type), stream);
	443	break;
	444	}
c906108c SS	445
	446	case TYPE_CODE_VOID:
	447	fprintf_filtered (stream, "void");
	448	break;
	449
	450	case TYPE_CODE_ERROR:
3d263c1d	451	fprintf_filtered (stream, _("<error type>"));
c906108c SS	452	break;
	453
	454	case TYPE_CODE_UNDEF:
	455	/* This happens (without TYPE_FLAG_STUB set) on systems which don't use
c5aa993b JM	456	dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
c5aa993b JM	457	and no complete type for struct foo in that file. */
3d263c1d	458	fprintf_filtered (stream, _("<incomplete type>"));
c906108c SS	459	break;
c906108c SS	460
fca9e603 DJ	461	case TYPE_CODE_COMPLEX:
	462	if (format)
	463	print_scalar_formatted (valaddr + embedded_offset,
	464	TYPE_TARGET_TYPE (type),
	465	format, 0, stream);
	466	else
	467	print_floating (valaddr + embedded_offset, TYPE_TARGET_TYPE (type),
	468	stream);
	469	fprintf_filtered (stream, " + ");
	470	if (format)
	471	print_scalar_formatted (valaddr + embedded_offset
	472	+ TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
	473	TYPE_TARGET_TYPE (type),
	474	format, 0, stream);
	475	else
	476	print_floating (valaddr + embedded_offset
	477	+ TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
	478	TYPE_TARGET_TYPE (type),
	479	stream);
	480	fprintf_filtered (stream, " * I");
	481	break;
	482
c906108c	483	default:
3d263c1d	484	error (_("Invalid C/C++ type code %d in symbol table."), TYPE_CODE (type));
c906108c SS	485	}
	486	gdb_flush (stream);
	487	return (0);
	488	}
	489	\f
	490	int
6943961c	491	c_value_print (struct value val, struct ui_file stream, int format,
fba45db2	492	enum val_prettyprint pretty)
c906108c	493	{
88750304	494	struct type type, real_type;
c906108c	495	int full, top, using_enc;
c5aa993b	496
c906108c SS	497	/* If it is a pointer, indicate what it points to.
	498
	499	Print type also if it is a reference.
	500
	501	C++: if it is a member pointer, we will take care
	502	of that when we print it. */
88750304 DJ	503
	504	type = check_typedef (value_type (val));
	505
	506	if (TYPE_CODE (type) == TYPE_CODE_PTR
	507	\|\| TYPE_CODE (type) == TYPE_CODE_REF)
c906108c SS	508	{
c906108c SS	509	/* Hack: remove (char *) for char strings. Their
c5aa993b	510	type is indicated by the quoted string anyway. */
88750304 DJ	511	if (TYPE_CODE (type) == TYPE_CODE_PTR
	512	&& TYPE_NAME (type) == NULL
	513	&& TYPE_NAME (TYPE_TARGET_TYPE (type)) != NULL
	514	&& strcmp (TYPE_NAME (TYPE_TARGET_TYPE (type)), "char") == 0)
c906108c SS	515	{
	516	/* Print nothing */
	517	}
	518	else if (objectprint && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
c5aa993b	519	{
070ad9f0 DB	520
	521	if (TYPE_CODE(type) == TYPE_CODE_REF)
	522	{
	523	/* Copy value, change to pointer, so we don't get an
	524	* error about a non-pointer type in value_rtti_target_type
	525	*/
6943961c	526	struct value *temparg;
070ad9f0	527	temparg=value_copy(val);
04624583	528	deprecated_set_value_type (temparg, lookup_pointer_type (TYPE_TARGET_TYPE(type)));
070ad9f0 DB	529	val=temparg;
070ad9f0 DB	530	}
c5aa993b	531	/* Pointer to class, check real type of object */
c906108c	532	fprintf_filtered (stream, "(");
c4093a6a JM	533	real_type = value_rtti_target_type (val, &full, &top, &using_enc);
c4093a6a JM	534	if (real_type)
c5aa993b JM	535	{
c5aa993b JM	536	/* RTTI entry found */
c4093a6a JM	537	if (TYPE_CODE (type) == TYPE_CODE_PTR)
	538	{
	539	/* create a pointer type pointing to the real type */
	540	type = lookup_pointer_type (real_type);
	541	}
	542	else
	543	{
	544	/* create a reference type referencing the real type */
	545	type = lookup_reference_type (real_type);
	546	}
070ad9f0	547	/* JYG: Need to adjust pointer value. */
5086187c AC	548	/* NOTE: cagney/2005-01-02: THIS IS BOGUS. */
5086187c AC	549	value_contents_writeable (val)[0] -= top;
070ad9f0	550
c4093a6a JM	551	/* Note: When we look up RTTI entries, we don't get any
	552	information on const or volatile attributes */
	553	}
	554	type_print (type, "", stream, -1);
c906108c	555	fprintf_filtered (stream, ") ");
c5aa993b	556	}
c906108c SS	557	else
c906108c SS	558	{
c5aa993b	559	/* normal case */
c906108c	560	fprintf_filtered (stream, "(");
88750304	561	type_print (value_type (val), "", stream, -1);
c906108c SS	562	fprintf_filtered (stream, ") ");
	563	}
	564	}
88750304 DJ	565
88750304 DJ	566	if (objectprint && (TYPE_CODE (type) == TYPE_CODE_CLASS))
c906108c SS	567	{
	568	/* Attempt to determine real type of object */
	569	real_type = value_rtti_type (val, &full, &top, &using_enc);
c5aa993b JM	570	if (real_type)
	571	{
	572	/* We have RTTI information, so use it */
	573	val = value_full_object (val, real_type, full, top, using_enc);
	574	fprintf_filtered (stream, "(%s%s) ",
	575	TYPE_NAME (real_type),
3d263c1d	576	full ? "" : _(" [incomplete object]"));
c5aa993b	577	/* Print out object: enclosing type is same as real_type if full */
46615f07 AC	578	return val_print (value_enclosing_type (val),
	579	value_contents_all (val), 0,
	580	VALUE_ADDRESS (val), stream, format, 1, 0, pretty);
c4093a6a JM	581	/* Note: When we look up RTTI entries, we don't get any information on
c4093a6a JM	582	const or volatile attributes */
c5aa993b	583	}
88750304	584	else if (type != check_typedef (value_enclosing_type (val)))
c5aa993b JM	585	{
	586	/* No RTTI information, so let's do our best */
	587	fprintf_filtered (stream, "(%s ?) ",
4754a64e	588	TYPE_NAME (value_enclosing_type (val)));
46615f07 AC	589	return val_print (value_enclosing_type (val),
	590	value_contents_all (val), 0,
	591	VALUE_ADDRESS (val), stream, format, 1, 0, pretty);
c5aa993b	592	}
c906108c SS	593	/* Otherwise, we end up at the return outside this "if" */
c906108c SS	594	}
c5aa993b	595
46615f07	596	return val_print (type, value_contents_all (val),
13c3b5f5	597	value_embedded_offset (val),
df407dfe	598	VALUE_ADDRESS (val) + value_offset (val),
c906108c SS	599	stream, format, 1, 0, pretty);
c906108c SS	600	}