[deliverable/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
   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)
{
  register 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_SOURCE_NAME (msymbol), stream);
		  fputs_filtered (">", stream);
		}
	      if (vt_address && vtblprint)
		{
		  struct value *vt_val;
		  struct symbol *wsym = (struct symbol *) NULL;
		  struct type *wtype;
		  struct symtab *s;
		  struct block *block = (struct block *) NULL;
		  int is_this_fld;

		  if (msymbol != NULL)
		    wsym = lookup_symbol (SYMBOL_NAME (msymbol), block,
					  VAR_NAMESPACE, &is_this_fld, &s);

		  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),
		    stream, format, 1, 0, pretty);
}
Commit	Line	Data
c906108c	1	/* Support for printing C values for GDB, the GNU debugger.
b6ba6518	2	Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 1996, 1997,
6943961c	3	1998, 1999, 2000, 2001
c5aa993b	4	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	{
c5aa993b	73	register 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);
	208	fputs_filtered (SYMBOL_SOURCE_NAME (msymbol), stream);
	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;
c906108c	216	struct symtab *s;
c5aa993b	217	struct block block = (struct block ) NULL;
c906108c SS	218	int is_this_fld;
	219
	220	if (msymbol != NULL)
c5aa993b JM	221	wsym = lookup_symbol (SYMBOL_NAME (msymbol), block,
	222	VAR_NAMESPACE, &is_this_fld, &s);
	223
c906108c SS	224	if (wsym)
c906108c SS	225	{
c5aa993b	226	wtype = SYMBOL_TYPE (wsym);
c906108c SS	227	}
	228	else
	229	{
c5aa993b	230	wtype = TYPE_TARGET_TYPE (type);
c906108c SS	231	}
	232	vt_val = value_at (wtype, vt_address, NULL);
	233	val_print (VALUE_TYPE (vt_val), VALUE_CONTENTS (vt_val), 0,
	234	VALUE_ADDRESS (vt_val), stream, format,
	235	deref_ref, recurse + 1, pretty);
	236	if (pretty)
	237	{
	238	fprintf_filtered (stream, "\n");
	239	print_spaces_filtered (2 + 2 * recurse, stream);
	240	}
c5aa993b JM	241	}
c5aa993b JM	242	}
c906108c SS	243
	244	/* Return number of characters printed, including the terminating
	245	'\0' if we reached the end. val_print_string takes care including
	246	the terminating '\0' if necessary. */
	247	return i;
	248	}
	249	break;
	250
	251	case TYPE_CODE_MEMBER:
	252	error ("not implemented: member type in c_val_print");
	253	break;
	254
	255	case TYPE_CODE_REF:
	256	elttype = check_typedef (TYPE_TARGET_TYPE (type));
	257	if (TYPE_CODE (elttype) == TYPE_CODE_MEMBER)
c5aa993b	258	{
c906108c SS	259	cp_print_class_member (valaddr + embedded_offset,
	260	TYPE_DOMAIN_TYPE (elttype),
	261	stream, "");
	262	break;
	263	}
	264	if (addressprint)
c5aa993b	265	{
4478b372 JB	266	CORE_ADDR addr
4478b372 JB	267	= extract_typed_address (valaddr + embedded_offset, type);
c906108c	268	fprintf_filtered (stream, "@");
4478b372	269	print_address_numeric (addr, 1, stream);
c906108c SS	270	if (deref_ref)
c906108c SS	271	fputs_filtered (": ", stream);
c5aa993b	272	}
c906108c SS	273	/* De-reference the reference. */
	274	if (deref_ref)
	275	{
	276	if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
	277	{
6943961c	278	struct value *deref_val =
c5aa993b JM	279	value_at
	280	(TYPE_TARGET_TYPE (type),
	281	unpack_pointer (lookup_pointer_type (builtin_type_void),
	282	valaddr + embedded_offset),
	283	NULL);
c906108c	284	val_print (VALUE_TYPE (deref_val),
c5aa993b JM	285	VALUE_CONTENTS (deref_val),
	286	0,
	287	VALUE_ADDRESS (deref_val),
	288	stream,
	289	format,
	290	deref_ref,
	291	recurse,
	292	pretty);
c906108c SS	293	}
	294	else
	295	fputs_filtered ("???", stream);
	296	}
	297	break;
	298
	299	case TYPE_CODE_UNION:
	300	if (recurse && !unionprint)
	301	{
	302	fprintf_filtered (stream, "{...}");
	303	break;
	304	}
	305	/* Fall through. */
	306	case TYPE_CODE_STRUCT:
015a42b4	307	/FIXME: Abstract this away /
c5aa993b	308	if (vtblprint && cp_is_vtbl_ptr_type (type))
c906108c	309	{
c5aa993b	310	/* Print the unmangled name if desired. */
c906108c SS	311	/* Print vtable entry - we only get here if NOT using
c906108c SS	312	-fvtable_thunks. (Otherwise, look under TYPE_CODE_PTR.) */
4478b372 JB	313	int offset = (embedded_offset +
	314	TYPE_FIELD_BITPOS (type, VTBL_FNADDR_OFFSET) / 8);
	315	struct type *field_type = TYPE_FIELD_TYPE (type, VTBL_FNADDR_OFFSET);
	316	CORE_ADDR addr
	317	= extract_typed_address (valaddr + offset, field_type);
	318
6e778545	319	print_function_pointer_address (addr, stream);
c906108c SS	320	}
	321	else
	322	cp_print_value_fields (type, type, valaddr, embedded_offset, address, stream, format,
	323	recurse, pretty, NULL, 0);
	324	break;
	325
	326	case TYPE_CODE_ENUM:
	327	if (format)
	328	{
	329	print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	330	break;
	331	}
	332	len = TYPE_NFIELDS (type);
	333	val = unpack_long (type, valaddr + embedded_offset);
	334	for (i = 0; i < len; i++)
	335	{
	336	QUIT;
	337	if (val == TYPE_FIELD_BITPOS (type, i))
	338	{
	339	break;
	340	}
	341	}
	342	if (i < len)
	343	{
	344	fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
	345	}
	346	else
	347	{
	348	print_longest (stream, 'd', 0, val);
	349	}
	350	break;
	351
	352	case TYPE_CODE_FUNC:
	353	if (format)
	354	{
	355	print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	356	break;
	357	}
	358	/* FIXME, we should consider, at least for ANSI C language, eliminating
c5aa993b	359	the distinction made between FUNCs and POINTERs to FUNCs. */
c906108c SS	360	fprintf_filtered (stream, "{");
	361	type_print (type, "", stream, -1);
	362	fprintf_filtered (stream, "} ");
	363	/* Try to print what function it points to, and its address. */
	364	print_address_demangle (address, stream, demangle);
	365	break;
	366
	367	case TYPE_CODE_BOOL:
	368	format = format ? format : output_format;
	369	if (format)
	370	print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	371	else
	372	{
	373	val = unpack_long (type, valaddr + embedded_offset);
	374	if (val == 0)
	375	fputs_filtered ("false", stream);
	376	else if (val == 1)
	377	fputs_filtered ("true", stream);
	378	else
	379	print_longest (stream, 'd', 0, val);
	380	}
	381	break;
	382
	383	case TYPE_CODE_RANGE:
	384	/* FIXME: create_range_type does not set the unsigned bit in a
c5aa993b JM	385	range type (I think it probably should copy it from the target
	386	type), so we won't print values which are too large to
	387	fit in a signed integer correctly. */
c906108c	388	/* FIXME: Doesn't handle ranges of enums correctly. (Can't just
c5aa993b JM	389	print with the target type, though, because the size of our type
c5aa993b JM	390	and the target type might differ). */
c906108c SS	391	/* FALLTHROUGH */
	392
	393	case TYPE_CODE_INT:
	394	format = format ? format : output_format;
	395	if (format)
	396	{
	397	print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	398	}
	399	else
	400	{
	401	val_print_type_code_int (type, valaddr + embedded_offset, stream);
	402	/* C and C++ has no single byte int type, char is used instead.
	403	Since we don't know whether the value is really intended to
	404	be used as an integer or a character, print the character
	405	equivalent as well. */
	406	if (TYPE_LENGTH (type) == 1)
	407	{
	408	fputs_filtered (" ", stream);
	409	LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr + embedded_offset),
	410	stream);
	411	}
	412	}
	413	break;
	414
	415	case TYPE_CODE_CHAR:
	416	format = format ? format : output_format;
	417	if (format)
	418	{
	419	print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	420	}
	421	else
	422	{
96baa820 JM	423	val = unpack_long (type, valaddr + embedded_offset);
	424	if (TYPE_UNSIGNED (type))
	425	fprintf_filtered (stream, "%u", (unsigned int) val);
	426	else
	427	fprintf_filtered (stream, "%d", (int) val);
c906108c	428	fputs_filtered (" ", stream);
96baa820	429	LA_PRINT_CHAR ((unsigned char) val, stream);
c906108c SS	430	}
	431	break;
	432
	433	case TYPE_CODE_FLT:
	434	if (format)
	435	{
	436	print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	437	}
	438	else
	439	{
	440	print_floating (valaddr + embedded_offset, type, stream);
	441	}
	442	break;
	443
	444	case TYPE_CODE_METHOD:
acf5ed49 DJ	445	{
	446	struct value *v = value_at (type, address, NULL);
	447	cp_print_class_method (VALUE_CONTENTS (value_addr (v)),
	448	lookup_pointer_type (type), stream);
	449	break;
	450	}
c906108c SS	451
	452	case TYPE_CODE_VOID:
	453	fprintf_filtered (stream, "void");
	454	break;
	455
	456	case TYPE_CODE_ERROR:
	457	fprintf_filtered (stream, "<error type>");
	458	break;
	459
	460	case TYPE_CODE_UNDEF:
	461	/* This happens (without TYPE_FLAG_STUB set) on systems which don't use
c5aa993b JM	462	dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
c5aa993b JM	463	and no complete type for struct foo in that file. */
c906108c SS	464	fprintf_filtered (stream, "<incomplete type>");
	465	break;
	466
fca9e603 DJ	467	case TYPE_CODE_COMPLEX:
	468	if (format)
	469	print_scalar_formatted (valaddr + embedded_offset,
	470	TYPE_TARGET_TYPE (type),
	471	format, 0, stream);
	472	else
	473	print_floating (valaddr + embedded_offset, TYPE_TARGET_TYPE (type),
	474	stream);
	475	fprintf_filtered (stream, " + ");
	476	if (format)
	477	print_scalar_formatted (valaddr + embedded_offset
	478	+ TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
	479	TYPE_TARGET_TYPE (type),
	480	format, 0, stream);
	481	else
	482	print_floating (valaddr + embedded_offset
	483	+ TYPE_LENGTH (TYPE_TARGET_TYPE (type)),
	484	TYPE_TARGET_TYPE (type),
	485	stream);
	486	fprintf_filtered (stream, " * I");
	487	break;
	488
c906108c SS	489	default:
	490	error ("Invalid C/C++ type code %d in symbol table.", TYPE_CODE (type));
	491	}
	492	gdb_flush (stream);
	493	return (0);
	494	}
	495	\f
	496	int
6943961c	497	c_value_print (struct value val, struct ui_file stream, int format,
fba45db2	498	enum val_prettyprint pretty)
c906108c SS	499	{
c906108c SS	500	struct type *type = VALUE_TYPE (val);
c5aa993b	501	struct type *real_type;
c906108c	502	int full, top, using_enc;
c5aa993b	503
c906108c SS	504	/* If it is a pointer, indicate what it points to.
	505
	506	Print type also if it is a reference.
	507
	508	C++: if it is a member pointer, we will take care
	509	of that when we print it. */
	510	if (TYPE_CODE (type) == TYPE_CODE_PTR \|\|
	511	TYPE_CODE (type) == TYPE_CODE_REF)
	512	{
	513	/* Hack: remove (char *) for char strings. Their
c5aa993b	514	type is indicated by the quoted string anyway. */
c906108c SS	515	if (TYPE_CODE (type) == TYPE_CODE_PTR &&
	516	TYPE_NAME (type) == NULL &&
	517	TYPE_NAME (TYPE_TARGET_TYPE (type)) != NULL &&
bde58177	518	strcmp (TYPE_NAME (TYPE_TARGET_TYPE (type)), "char") == 0)
c906108c SS	519	{
	520	/* Print nothing */
	521	}
	522	else if (objectprint && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
c5aa993b	523	{
070ad9f0 DB	524
	525	if (TYPE_CODE(type) == TYPE_CODE_REF)
	526	{
	527	/* Copy value, change to pointer, so we don't get an
	528	* error about a non-pointer type in value_rtti_target_type
	529	*/
6943961c	530	struct value *temparg;
070ad9f0 DB	531	temparg=value_copy(val);
	532	VALUE_TYPE (temparg) = lookup_pointer_type(TYPE_TARGET_TYPE(type));
	533	val=temparg;
	534	}
c5aa993b	535	/* Pointer to class, check real type of object */
c906108c	536	fprintf_filtered (stream, "(");
c4093a6a JM	537	real_type = value_rtti_target_type (val, &full, &top, &using_enc);
c4093a6a JM	538	if (real_type)
c5aa993b JM	539	{
c5aa993b JM	540	/* RTTI entry found */
c4093a6a JM	541	if (TYPE_CODE (type) == TYPE_CODE_PTR)
	542	{
	543	/* create a pointer type pointing to the real type */
	544	type = lookup_pointer_type (real_type);
	545	}
	546	else
	547	{
	548	/* create a reference type referencing the real type */
	549	type = lookup_reference_type (real_type);
	550	}
070ad9f0 DB	551	/* JYG: Need to adjust pointer value. */
	552	val->aligner.contents[0] -= top;
	553
c4093a6a JM	554	/* Note: When we look up RTTI entries, we don't get any
	555	information on const or volatile attributes */
	556	}
	557	type_print (type, "", stream, -1);
c906108c	558	fprintf_filtered (stream, ") ");
c5aa993b	559	}
c906108c SS	560	else
c906108c SS	561	{
c5aa993b	562	/* normal case */
c906108c SS	563	fprintf_filtered (stream, "(");
	564	type_print (type, "", stream, -1);
	565	fprintf_filtered (stream, ") ");
	566	}
	567	}
	568	if (objectprint && (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_CLASS))
	569	{
	570	/* Attempt to determine real type of object */
	571	real_type = value_rtti_type (val, &full, &top, &using_enc);
c5aa993b JM	572	if (real_type)
	573	{
	574	/* We have RTTI information, so use it */
	575	val = value_full_object (val, real_type, full, top, using_enc);
	576	fprintf_filtered (stream, "(%s%s) ",
	577	TYPE_NAME (real_type),
	578	full ? "" : " [incomplete object]");
	579	/* Print out object: enclosing type is same as real_type if full */
	580	return val_print (VALUE_ENCLOSING_TYPE (val), VALUE_CONTENTS_ALL (val), 0,
	581	VALUE_ADDRESS (val), stream, format, 1, 0, pretty);
c4093a6a JM	582	/* Note: When we look up RTTI entries, we don't get any information on
c4093a6a JM	583	const or volatile attributes */
c5aa993b	584	}
c906108c	585	else if (type != VALUE_ENCLOSING_TYPE (val))
c5aa993b JM	586	{
	587	/* No RTTI information, so let's do our best */
	588	fprintf_filtered (stream, "(%s ?) ",
	589	TYPE_NAME (VALUE_ENCLOSING_TYPE (val)));
	590	return val_print (VALUE_ENCLOSING_TYPE (val), VALUE_CONTENTS_ALL (val), 0,
	591	VALUE_ADDRESS (val), stream, format, 1, 0, pretty);
	592	}
c906108c SS	593	/* Otherwise, we end up at the return outside this "if" */
c906108c SS	594	}
c5aa993b JM	595
c5aa993b JM	596	return val_print (type, VALUE_CONTENTS_ALL (val), VALUE_EMBEDDED_OFFSET (val),
c906108c SS	597	VALUE_ADDRESS (val),
	598	stream, format, 1, 0, pretty);
	599	}