[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 "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:
      cp_print_class_method (valaddr + embedded_offset, 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;

    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 &&
	  STREQ (TYPE_NAME (TYPE_TARGET_TYPE (type)), "char"))
	{
	  /* 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
	23	#include "defs.h"
	24	#include "symtab.h"
	25	#include "gdbtypes.h"
	26	#include "expression.h"
	27	#include "value.h"
c906108c SS	28	#include "valprint.h"
	29	#include "language.h"
	30	#include "c-lang.h"
015a42b4	31	#include "cp-abi.h"
c906108c	32	\f
c5aa993b	33
6e778545 PS	34	/* Print function pointer with inferior address ADDRESS onto stdio
	35	stream STREAM. */
	36
	37	static void
	38	print_function_pointer_address (CORE_ADDR address, struct ui_file *stream)
	39	{
	40	CORE_ADDR func_addr = CONVERT_FROM_FUNC_PTR_ADDR (address);
	41
	42	/* If the function pointer is represented by a description, print the
	43	address of the description. */
	44	if (addressprint && func_addr != address)
	45	{
	46	fputs_filtered ("@", stream);
	47	print_address_numeric (address, 1, stream);
	48	fputs_filtered (": ", stream);
	49	}
	50	print_address_demangle (func_addr, stream, demangle);
	51	}
	52
	53
c906108c SS	54	/* Print data of type TYPE located at VALADDR (within GDB), which came from
	55	the inferior at address ADDRESS, onto stdio stream STREAM according to
	56	FORMAT (a letter or 0 for natural format). The data at VALADDR is in
	57	target byte order.
	58
	59	If the data are a string pointer, returns the number of string characters
	60	printed.
	61
	62	If DEREF_REF is nonzero, then dereference references, otherwise just print
	63	them like pointers.
	64
	65	The PRETTY parameter controls prettyprinting. */
	66
	67	int
fba45db2 KB	68	c_val_print (struct type type, char valaddr, int embedded_offset,
	69	CORE_ADDR address, struct ui_file *stream, int format,
	70	int deref_ref, int recurse, enum val_prettyprint pretty)
c906108c	71	{
c5aa993b	72	register unsigned int i = 0; /* Number of characters printed */
c906108c SS	73	unsigned len;
	74	struct type *elttype;
	75	unsigned eltlen;
	76	LONGEST val;
	77	CORE_ADDR addr;
	78
	79	CHECK_TYPEDEF (type);
	80	switch (TYPE_CODE (type))
	81	{
	82	case TYPE_CODE_ARRAY:
	83	elttype = check_typedef (TYPE_TARGET_TYPE (type));
	84	if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
	85	{
	86	eltlen = TYPE_LENGTH (elttype);
	87	len = TYPE_LENGTH (type) / eltlen;
	88	if (prettyprint_arrays)
	89	{
	90	print_spaces_filtered (2 + 2 * recurse, stream);
	91	}
	92	/* For an array of chars, print with string syntax. */
	93	if (eltlen == 1 &&
	94	((TYPE_CODE (elttype) == TYPE_CODE_INT)
	95	\|\| ((current_language->la_language == language_m2)
	96	&& (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
	97	&& (format == 0 \|\| format == 's'))
	98	{
	99	/* If requested, look for the first null char and only print
c5aa993b	100	elements up to it. */
c906108c SS	101	if (stop_print_at_null)
c906108c SS	102	{
745b8ca0	103	unsigned int temp_len;
c5aa993b	104
c906108c SS	105	/* Look for a NULL char. */
	106	for (temp_len = 0;
	107	(valaddr + embedded_offset)[temp_len]
	108	&& temp_len < len && temp_len < print_max;
	109	temp_len++);
	110	len = temp_len;
	111	}
c5aa993b	112
c906108c SS	113	LA_PRINT_STRING (stream, valaddr + embedded_offset, len, eltlen, 0);
	114	i = len;
	115	}
	116	else
	117	{
	118	fprintf_filtered (stream, "{");
	119	/* If this is a virtual function table, print the 0th
c5aa993b	120	entry specially, and the rest of the members normally. */
c906108c SS	121	if (cp_is_vtbl_ptr_type (elttype))
	122	{
	123	i = 1;
	124	fprintf_filtered (stream, "%d vtable entries", len - 1);
	125	}
	126	else
	127	{
	128	i = 0;
	129	}
	130	val_print_array_elements (type, valaddr + embedded_offset, address, stream,
c5aa993b	131	format, deref_ref, recurse, pretty, i);
c906108c SS	132	fprintf_filtered (stream, "}");
	133	}
	134	break;
	135	}
	136	/* Array of unspecified length: treat like pointer to first elt. */
	137	addr = address;
	138	goto print_unpacked_pointer;
	139
	140	case TYPE_CODE_PTR:
	141	if (format && format != 's')
	142	{
	143	print_scalar_formatted (valaddr + embedded_offset, type, format, 0, stream);
	144	break;
	145	}
c5aa993b	146	if (vtblprint && cp_is_vtbl_ptr_type (type))
c906108c	147	{
c5aa993b	148	/* Print the unmangled name if desired. */
c906108c SS	149	/* Print vtable entry - we only get here if we ARE using
c906108c SS	150	-fvtable_thunks. (Otherwise, look under TYPE_CODE_STRUCT.) */
4478b372 JB	151	CORE_ADDR addr
4478b372 JB	152	= extract_typed_address (valaddr + embedded_offset, type);
6e778545	153	print_function_pointer_address (addr, stream);
c906108c SS	154	break;
	155	}
	156	elttype = check_typedef (TYPE_TARGET_TYPE (type));
	157	if (TYPE_CODE (elttype) == TYPE_CODE_METHOD)
	158	{
	159	cp_print_class_method (valaddr + embedded_offset, type, stream);
	160	}
	161	else if (TYPE_CODE (elttype) == TYPE_CODE_MEMBER)
	162	{
	163	cp_print_class_member (valaddr + embedded_offset,
	164	TYPE_DOMAIN_TYPE (TYPE_TARGET_TYPE (type)),
	165	stream, "&");
	166	}
	167	else
	168	{
	169	addr = unpack_pointer (type, valaddr + embedded_offset);
	170	print_unpacked_pointer:
c906108c SS	171
	172	if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
	173	{
	174	/* Try to print what function it points to. */
6e778545	175	print_function_pointer_address (addr, stream);
c906108c SS	176	/* Return value is irrelevant except for string pointers. */
	177	return (0);
	178	}
	179
	180	if (addressprint && format != 's')
	181	{
	182	print_address_numeric (addr, 1, stream);
	183	}
	184
	185	/* For a pointer to char or unsigned char, also print the string
	186	pointed to, unless pointer is null. */
	187	/* FIXME: need to handle wchar_t here... */
	188
	189	if (TYPE_LENGTH (elttype) == 1
	190	&& TYPE_CODE (elttype) == TYPE_CODE_INT
	191	&& (format == 0 \|\| format == 's')
	192	&& addr != 0)
	193	{
	194	i = val_print_string (addr, -1, TYPE_LENGTH (elttype), stream);
	195	}
c5aa993b JM	196	else if (cp_is_vtbl_member (type))
c5aa993b JM	197	{
c906108c SS	198	/* print vtbl's nicely */
	199	CORE_ADDR vt_address = unpack_pointer (type, valaddr + embedded_offset);
	200
	201	struct minimal_symbol *msymbol =
c5aa993b	202	lookup_minimal_symbol_by_pc (vt_address);
c906108c SS	203	if ((msymbol != NULL) &&
	204	(vt_address == SYMBOL_VALUE_ADDRESS (msymbol)))
	205	{
	206	fputs_filtered (" <", stream);
	207	fputs_filtered (SYMBOL_SOURCE_NAME (msymbol), stream);
	208	fputs_filtered (">", stream);
	209	}
	210	if (vt_address && vtblprint)
c5aa993b	211	{
6943961c	212	struct value *vt_val;
c5aa993b JM	213	struct symbol wsym = (struct symbol ) NULL;
c5aa993b JM	214	struct type *wtype;
c906108c	215	struct symtab *s;
c5aa993b	216	struct block block = (struct block ) NULL;
c906108c SS	217	int is_this_fld;
	218
	219	if (msymbol != NULL)
c5aa993b JM	220	wsym = lookup_symbol (SYMBOL_NAME (msymbol), block,
	221	VAR_NAMESPACE, &is_this_fld, &s);
	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:
	444	cp_print_class_method (valaddr + embedded_offset, lookup_pointer_type (type), stream);
	445	break;
	446
	447	case TYPE_CODE_VOID:
	448	fprintf_filtered (stream, "void");
	449	break;
	450
	451	case TYPE_CODE_ERROR:
	452	fprintf_filtered (stream, "<error type>");
	453	break;
	454
	455	case TYPE_CODE_UNDEF:
	456	/* This happens (without TYPE_FLAG_STUB set) on systems which don't use
c5aa993b JM	457	dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
c5aa993b JM	458	and no complete type for struct foo in that file. */
c906108c SS	459	fprintf_filtered (stream, "<incomplete type>");
	460	break;
	461
	462	default:
	463	error ("Invalid C/C++ type code %d in symbol table.", TYPE_CODE (type));
	464	}
	465	gdb_flush (stream);
	466	return (0);
	467	}
	468	\f
	469	int
6943961c	470	c_value_print (struct value val, struct ui_file stream, int format,
fba45db2	471	enum val_prettyprint pretty)
c906108c SS	472	{
c906108c SS	473	struct type *type = VALUE_TYPE (val);
c5aa993b	474	struct type *real_type;
c906108c	475	int full, top, using_enc;
c5aa993b	476
c906108c SS	477	/* If it is a pointer, indicate what it points to.
	478
	479	Print type also if it is a reference.
	480
	481	C++: if it is a member pointer, we will take care
	482	of that when we print it. */
	483	if (TYPE_CODE (type) == TYPE_CODE_PTR \|\|
	484	TYPE_CODE (type) == TYPE_CODE_REF)
	485	{
	486	/* Hack: remove (char *) for char strings. Their
c5aa993b	487	type is indicated by the quoted string anyway. */
c906108c SS	488	if (TYPE_CODE (type) == TYPE_CODE_PTR &&
	489	TYPE_NAME (type) == NULL &&
	490	TYPE_NAME (TYPE_TARGET_TYPE (type)) != NULL &&
	491	STREQ (TYPE_NAME (TYPE_TARGET_TYPE (type)), "char"))
	492	{
	493	/* Print nothing */
	494	}
	495	else if (objectprint && (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_CLASS))
c5aa993b	496	{
070ad9f0 DB	497
	498	if (TYPE_CODE(type) == TYPE_CODE_REF)
	499	{
	500	/* Copy value, change to pointer, so we don't get an
	501	* error about a non-pointer type in value_rtti_target_type
	502	*/
6943961c	503	struct value *temparg;
070ad9f0 DB	504	temparg=value_copy(val);
	505	VALUE_TYPE (temparg) = lookup_pointer_type(TYPE_TARGET_TYPE(type));
	506	val=temparg;
	507	}
c5aa993b	508	/* Pointer to class, check real type of object */
c906108c	509	fprintf_filtered (stream, "(");
c4093a6a JM	510	real_type = value_rtti_target_type (val, &full, &top, &using_enc);
c4093a6a JM	511	if (real_type)
c5aa993b JM	512	{
c5aa993b JM	513	/* RTTI entry found */
c4093a6a JM	514	if (TYPE_CODE (type) == TYPE_CODE_PTR)
	515	{
	516	/* create a pointer type pointing to the real type */
	517	type = lookup_pointer_type (real_type);
	518	}
	519	else
	520	{
	521	/* create a reference type referencing the real type */
	522	type = lookup_reference_type (real_type);
	523	}
070ad9f0 DB	524	/* JYG: Need to adjust pointer value. */
	525	val->aligner.contents[0] -= top;
	526
c4093a6a JM	527	/* Note: When we look up RTTI entries, we don't get any
	528	information on const or volatile attributes */
	529	}
	530	type_print (type, "", stream, -1);
c906108c	531	fprintf_filtered (stream, ") ");
c5aa993b	532	}
c906108c SS	533	else
c906108c SS	534	{
c5aa993b	535	/* normal case */
c906108c SS	536	fprintf_filtered (stream, "(");
	537	type_print (type, "", stream, -1);
	538	fprintf_filtered (stream, ") ");
	539	}
	540	}
	541	if (objectprint && (TYPE_CODE (VALUE_TYPE (val)) == TYPE_CODE_CLASS))
	542	{
	543	/* Attempt to determine real type of object */
	544	real_type = value_rtti_type (val, &full, &top, &using_enc);
c5aa993b JM	545	if (real_type)
	546	{
	547	/* We have RTTI information, so use it */
	548	val = value_full_object (val, real_type, full, top, using_enc);
	549	fprintf_filtered (stream, "(%s%s) ",
	550	TYPE_NAME (real_type),
	551	full ? "" : " [incomplete object]");
	552	/* Print out object: enclosing type is same as real_type if full */
	553	return val_print (VALUE_ENCLOSING_TYPE (val), VALUE_CONTENTS_ALL (val), 0,
	554	VALUE_ADDRESS (val), stream, format, 1, 0, pretty);
c4093a6a JM	555	/* Note: When we look up RTTI entries, we don't get any information on
c4093a6a JM	556	const or volatile attributes */
c5aa993b	557	}
c906108c	558	else if (type != VALUE_ENCLOSING_TYPE (val))
c5aa993b JM	559	{
	560	/* No RTTI information, so let's do our best */
	561	fprintf_filtered (stream, "(%s ?) ",
	562	TYPE_NAME (VALUE_ENCLOSING_TYPE (val)));
	563	return val_print (VALUE_ENCLOSING_TYPE (val), VALUE_CONTENTS_ALL (val), 0,
	564	VALUE_ADDRESS (val), stream, format, 1, 0, pretty);
	565	}
c906108c SS	566	/* Otherwise, we end up at the return outside this "if" */
c906108c SS	567	}
c5aa993b JM	568
c5aa993b JM	569	return val_print (type, VALUE_CONTENTS_ALL (val), VALUE_EMBEDDED_OFFSET (val),
c906108c SS	570	VALUE_ADDRESS (val),
	571	stream, format, 1, 0, pretty);
	572	}