[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 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"
\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 = CONVERT_FROM_FUNC_PTR_ADDR (address);

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