[deliverable/binutils-gdb.git] / gdb / ch-valprint.c

/* Support for printing Chill values for GDB, the GNU debugger.
   Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994
   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., 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include "defs.h"
#include "obstack.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "valprint.h"
#include "expression.h"
#include "value.h"
#include "language.h"
#include "demangle.h"
#include "c-lang.h" /* For c_val_print */

static void
chill_print_value_fields PARAMS ((struct type *, char *, GDB_FILE *, int, int,
				  enum val_prettyprint, struct type **));

\f
/* 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
chill_val_print (type, valaddr, address, stream, format, deref_ref, recurse,
		 pretty)
     struct type *type;
     char *valaddr;
     CORE_ADDR address;
     GDB_FILE *stream;
     int format;
     int deref_ref;
     int recurse;
     enum val_prettyprint pretty;
{
  LONGEST val;
  unsigned int i = 0;		/* Number of characters printed.  */
  struct type *elttype;
  CORE_ADDR addr;

  switch (TYPE_CODE (type))
    {
    case TYPE_CODE_ARRAY:
      if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
	{
	  if (prettyprint_arrays)
	    {
	      print_spaces_filtered (2 + 2 * recurse, stream);
	    }
	  fprintf_filtered (stream, "[");
	  val_print_array_elements (type, valaddr, address, stream, format,
				    deref_ref, recurse, pretty, 0);
	  fprintf_filtered (stream, "]");
	}
      else
	{
	  error ("unimplemented in chill_val_print; unspecified array length");
	}
      break;

    case TYPE_CODE_INT:
      format = format ? format : output_format;
      if (format)
	{
	  print_scalar_formatted (valaddr, type, format, 0, stream);
	}
      else
	{
	  val_print_type_code_int (type, valaddr, stream);
	}
      break;

    case TYPE_CODE_CHAR:
      format = format ? format : output_format;
      if (format)
	{
	  print_scalar_formatted (valaddr, type, format, 0, stream);
	}
      else
	{
	  LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr),
			 stream);
	}
      break;

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

    case TYPE_CODE_BOOL:
      format = format ? format : output_format;
      if (format)
	{
	  print_scalar_formatted (valaddr, type, format, 0, stream);
	}
      else
	{
	  val = unpack_long (builtin_type_chill_bool, valaddr);
	  fprintf_filtered (stream, val ? "TRUE" : "FALSE");
	}
      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_PTR:
      if (format && format != 's')
	{
	  print_scalar_formatted (valaddr, type, format, 0, stream);
	  break;
	}
      addr = unpack_pointer (type, valaddr);
      elttype = TYPE_TARGET_TYPE (type);
      
      if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
	{
	  /* Try to print what function it points to.  */
	  print_address_demangle (addr, stream, demangle);
	  /* Return value is irrelevant except for string pointers.  */
	  return (0);
	}
      if (addressprint && format != 's')
	{
	  print_address_numeric (addr, stream);
	}
      
      /* For a pointer to char or unsigned char, also print the string
	 pointed to, unless pointer is null.  */
      if (TYPE_LENGTH (elttype) == 1
	  && TYPE_CODE (elttype) == TYPE_CODE_CHAR
	  && (format == 0 || format == 's')
	  && addr != 0
	  && /* If print_max is UINT_MAX, the alloca below will fail.
		In that case don't try to print the string.  */
	  print_max < UINT_MAX)
	  {
	    i = val_print_string (addr, 0, stream);
	  }
      /* Return number of characters printed, plus one for the
	 terminating null if we have "reached the end".  */
      return (i + (print_max && i != print_max));
      break;

    case TYPE_CODE_STRING:
      if (format && format != 's')
	{
	  print_scalar_formatted (valaddr, type, format, 0, stream);
	  break;
	}
      i = TYPE_LENGTH (type);
      LA_PRINT_STRING (stream, valaddr, i, 0);
      /* Return number of characters printed, plus one for the terminating
	 null if we have "reached the end".  */
      return (i + (print_max && i != print_max));
      break;

    case TYPE_CODE_BITSTRING:
    case TYPE_CODE_SET:
      {
	struct type *range = TYPE_FIELD_TYPE (type, 0);
	int low_bound = TYPE_LOW_BOUND (range);
	int high_bound = TYPE_HIGH_BOUND (range);
	int i;
	int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
	int need_comma = 0;
	int in_range = 0;

	if (is_bitstring)
	  fputs_filtered ("B'", stream);
	else
	  fputs_filtered ("[", stream);
	for (i = low_bound; i <= high_bound; i++)
	  {
	    int element = value_bit_index (type, valaddr, i);
	    if (is_bitstring)
	      fprintf_filtered (stream, "%d", element);
	    else if (element)
	      {
		if (need_comma)
		  fputs_filtered (", ", stream);
		print_type_scalar (TYPE_TARGET_TYPE (range), i, stream);
		need_comma = 1;

		/* Look for a continuous range of true elements. */
		if (i+1 <= high_bound && value_bit_index (type, valaddr, ++i))
		  {
		    int j = i; /* j is the upper bound so far of the range */
		    fputs_filtered (":", stream);
		    while (i+1 <= high_bound
			   && value_bit_index (type, valaddr, ++i))
		      j = i;
		    print_type_scalar (TYPE_TARGET_TYPE (range), j, stream);
		  }
	      }
	  }
	if (is_bitstring)
	  fputs_filtered ("'", stream);
	else
	  fputs_filtered ("]", stream);
      }
      break;

    case TYPE_CODE_STRUCT:
      if (chill_is_varying_struct (type))
	{
	  struct type *inner = TYPE_FIELD_TYPE (type, 1);
	  long length = unpack_long (TYPE_FIELD_TYPE (type, 0), valaddr);
	  char *data_addr = valaddr + TYPE_FIELD_BITPOS (type, 1) / 8;
	  
	  switch (TYPE_CODE (inner))
	    {
	    case TYPE_CODE_STRING:
	      if (length > TYPE_LENGTH (type))
		{
		  fprintf_filtered (stream,
				    "<dynamic length %d > static length %d>",
				    length, TYPE_LENGTH (type));
		  length > TYPE_LENGTH (type);
		}
	      LA_PRINT_STRING (stream, data_addr, length, 0);
	      return length;
	    }
	}
      chill_print_value_fields (type, valaddr, stream, format, recurse, pretty,
				0);
      break;

    case TYPE_CODE_REF:
      if (addressprint)
        {
	  fprintf_filtered (stream, "LOC(");
	  print_address_numeric
	    (extract_address (valaddr, TARGET_PTR_BIT / HOST_CHAR_BIT),
	     stream);
	  fprintf_filtered (stream, ")");
	  if (deref_ref)
	    fputs_filtered (": ", stream);
        }
      /* De-reference the reference.  */
      if (deref_ref)
	{
	  if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_UNDEF)
	    {
	      value deref_val =
		value_at
		  (TYPE_TARGET_TYPE (type),
		   unpack_pointer (lookup_pointer_type (builtin_type_void),
				   valaddr));
	      val_print (VALUE_TYPE (deref_val),
			 VALUE_CONTENTS (deref_val),
			 VALUE_ADDRESS (deref_val), stream, format,
			 deref_ref, recurse + 1, pretty);
	    }
	  else
	    fputs_filtered ("???", stream);
	}
      break;

    case TYPE_CODE_ENUM:
      c_val_print (type, valaddr, address, stream, format,
		   deref_ref, recurse, pretty);
      break;

    case TYPE_CODE_RANGE:
      if (TYPE_TARGET_TYPE (type))
	chill_val_print (TYPE_TARGET_TYPE (type), valaddr, address, stream,
			 format, deref_ref, recurse, pretty);
      break;

    case TYPE_CODE_MEMBER:
    case TYPE_CODE_UNION:
    case TYPE_CODE_FUNC:
    case TYPE_CODE_VOID:
    case TYPE_CODE_ERROR:
    default:
      /* Let's defer printing to the C printer, rather than
	 print an error message.  FIXME! */
      c_val_print (type, valaddr, address, stream, format,
		   deref_ref, recurse, pretty);
    }
  gdb_flush (stream);
  return (0);
}

/* Mutually recursive subroutines of cplus_print_value and c_val_print to
   print out a structure's fields: cp_print_value_fields and cplus_print_value.

   TYPE, VALADDR, STREAM, RECURSE, and PRETTY have the
   same meanings as in cplus_print_value and c_val_print.

   DONT_PRINT is an array of baseclass types that we
   should not print, or zero if called from top level.  */

static void
chill_print_value_fields (type, valaddr, stream, format, recurse, pretty,
			  dont_print)
     struct type *type;
     char *valaddr;
     GDB_FILE *stream;
     int format;
     int recurse;
     enum val_prettyprint pretty;
     struct type **dont_print;
{
  int i, len;
  int fields_seen = 0;

  check_stub_type (type);

  fprintf_filtered (stream, "[");
  len = TYPE_NFIELDS (type);
  if (len == 0)
    {
      fprintf_filtered (stream, "<No data fields>");
    }
  else
    {
      for (i = 0; i < len; i++)
	{
	  if (fields_seen)
	    {
	      fprintf_filtered (stream, ", ");
	    }
	  fields_seen = 1;
	  if (pretty)
	    {
	      fprintf_filtered (stream, "\n");
	      print_spaces_filtered (2 + 2 * recurse, stream);
	    }
	  else 
	    {
	      wrap_here (n_spaces (2 + 2 * recurse));
	    }
	  fputs_filtered (".", stream);
	  fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
				   language_chill, DMGL_NO_OPTS);
	  fputs_filtered (": ", stream);
	  if (TYPE_FIELD_PACKED (type, i))
	    {
	      value v;

	      /* Bitfields require special handling, especially due to byte
		 order problems.  */
	      v = value_from_longest (TYPE_FIELD_TYPE (type, i),
				      unpack_field_as_long (type, valaddr, i));

	      chill_val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0,
			       stream, format, 0, recurse + 1, pretty);
	    }
	  else
	    {
	      chill_val_print (TYPE_FIELD_TYPE (type, i), 
			       valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
			       0, stream, format, 0, recurse + 1, pretty);
	    }
	}
      if (pretty)
	{
	  fprintf_filtered (stream, "\n");
	  print_spaces_filtered (2 * recurse, stream);
	}
    }
  fprintf_filtered (stream, "]");
}
Commit	Line	Data
a8a69e63	1	/* Support for printing Chill values for GDB, the GNU debugger.
67e9b3b3 PS	2	Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994
67e9b3b3 PS	3	Free Software Foundation, Inc.
a8a69e63 FF	4
	5	This file is part of GDB.
	6
	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
	11
	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	20
	21	#include "defs.h"
	22	#include "obstack.h"
	23	#include "symtab.h"
	24	#include "gdbtypes.h"
	25	#include "valprint.h"
	26	#include "expression.h"
8fbdca53	27	#include "value.h"
a8a69e63	28	#include "language.h"
5e81259d	29	#include "demangle.h"
100f92e2	30	#include "c-lang.h" /* For c_val_print */
a8a69e63	31
8fbdca53	32	static void
199b2450	33	chill_print_value_fields PARAMS ((struct type , char , GDB_FILE *, int, int,
8fbdca53 FF	34	enum val_prettyprint, struct type **));
8fbdca53 FF	35
a8a69e63 FF	36	\f
	37	/* Print data of type TYPE located at VALADDR (within GDB), which came from
	38	the inferior at address ADDRESS, onto stdio stream STREAM according to
	39	FORMAT (a letter or 0 for natural format). The data at VALADDR is in
	40	target byte order.
	41
	42	If the data are a string pointer, returns the number of string characters
	43	printed.
	44
	45	If DEREF_REF is nonzero, then dereference references, otherwise just print
	46	them like pointers.
	47
	48	The PRETTY parameter controls prettyprinting. */
	49
	50	int
	51	chill_val_print (type, valaddr, address, stream, format, deref_ref, recurse,
	52	pretty)
	53	struct type *type;
	54	char *valaddr;
	55	CORE_ADDR address;
199b2450	56	GDB_FILE *stream;
a8a69e63 FF	57	int format;
	58	int deref_ref;
	59	int recurse;
	60	enum val_prettyprint pretty;
	61	{
a8a69e63	62	LONGEST val;
ec16f701	63	unsigned int i = 0; /* Number of characters printed. */
c7da3ed3	64	struct type *elttype;
c7da3ed3	65	CORE_ADDR addr;
a8a69e63 FF	66
	67	switch (TYPE_CODE (type))
	68	{
	69	case TYPE_CODE_ARRAY:
	70	if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
	71	{
a8a69e63 FF	72	if (prettyprint_arrays)
	73	{
	74	print_spaces_filtered (2 + 2 * recurse, stream);
	75	}
	76	fprintf_filtered (stream, "[");
a9b37611 FF	77	val_print_array_elements (type, valaddr, address, stream, format,
a9b37611 FF	78	deref_ref, recurse, pretty, 0);
a8a69e63 FF	79	fprintf_filtered (stream, "]");
	80	}
	81	else
	82	{
	83	error ("unimplemented in chill_val_print; unspecified array length");
	84	}
	85	break;
	86
	87	case TYPE_CODE_INT:
	88	format = format ? format : output_format;
	89	if (format)
	90	{
	91	print_scalar_formatted (valaddr, type, format, 0, stream);
	92	}
	93	else
	94	{
	95	val_print_type_code_int (type, valaddr, stream);
	96	}
	97	break;
	98
	99	case TYPE_CODE_CHAR:
	100	format = format ? format : output_format;
	101	if (format)
	102	{
	103	print_scalar_formatted (valaddr, type, format, 0, stream);
	104	}
	105	else
	106	{
	107	LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr),
	108	stream);
	109	}
	110	break;
	111
	112	case TYPE_CODE_FLT:
	113	if (format)
	114	{
	115	print_scalar_formatted (valaddr, type, format, 0, stream);
	116	}
	117	else
	118	{
	119	print_floating (valaddr, type, stream);
	120	}
	121	break;
	122
	123	case TYPE_CODE_BOOL:
	124	format = format ? format : output_format;
	125	if (format)
	126	{
	127	print_scalar_formatted (valaddr, type, format, 0, stream);
	128	}
	129	else
	130	{
	131	val = unpack_long (builtin_type_chill_bool, valaddr);
	132	fprintf_filtered (stream, val ? "TRUE" : "FALSE");
	133	}
	134	break;
	135
	136	case TYPE_CODE_UNDEF:
	137	/* This happens (without TYPE_FLAG_STUB set) on systems which don't use
	138	dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
	139	and no complete type for struct foo in that file. */
	140	fprintf_filtered (stream, "<incomplete type>");
	141	break;
	142
143	case TYPE_CODE_PTR:
c7da3ed3 FF	144	if (format && format != 's')
	145	{
	146	print_scalar_formatted (valaddr, type, format, 0, stream);
	147	break;
	148	}
	149	addr = unpack_pointer (type, valaddr);
	150	elttype = TYPE_TARGET_TYPE (type);
	151
	152	if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
	153	{
	154	/* Try to print what function it points to. */
	155	print_address_demangle (addr, stream, demangle);
	156	/* Return value is irrelevant except for string pointers. */
	157	return (0);
	158	}
	159	if (addressprint && format != 's')
	160	{
833e0d94	161	print_address_numeric (addr, stream);
c7da3ed3 FF	162	}
	163
	164	/* For a pointer to char or unsigned char, also print the string
	165	pointed to, unless pointer is null. */
c7da3ed3 FF	166	if (TYPE_LENGTH (elttype) == 1
	167	&& TYPE_CODE (elttype) == TYPE_CODE_CHAR
	168	&& (format == 0 \|\| format == 's')
	169	&& addr != 0
	170	&& /* If print_max is UINT_MAX, the alloca below will fail.
	171	In that case don't try to print the string. */
	172	print_max < UINT_MAX)
	173	{
8fbdca53	174	i = val_print_string (addr, 0, stream);
c7da3ed3 FF	175	}
	176	/* Return number of characters printed, plus one for the
	177	terminating null if we have "reached the end". */
	178	return (i + (print_max && i != print_max));
	179	break;
	180
c4413e2c FF	181	case TYPE_CODE_STRING:
	182	if (format && format != 's')
	183	{
	184	print_scalar_formatted (valaddr, type, format, 0, stream);
	185	break;
	186	}
ec16f701 FF	187	i = TYPE_LENGTH (type);
ec16f701 FF	188	LA_PRINT_STRING (stream, valaddr, i, 0);
c4413e2c FF	189	/* Return number of characters printed, plus one for the terminating
	190	null if we have "reached the end". */
	191	return (i + (print_max && i != print_max));
	192	break;
	193
cba00921	194	case TYPE_CODE_BITSTRING:
e909f287 PB	195	case TYPE_CODE_SET:
	196	{
	197	struct type *range = TYPE_FIELD_TYPE (type, 0);
cba00921 PB	198	int low_bound = TYPE_LOW_BOUND (range);
cba00921 PB	199	int high_bound = TYPE_HIGH_BOUND (range);
e909f287	200	int i;
cba00921	201	int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
e909f287 PB	202	int need_comma = 0;
	203	int in_range = 0;
	204
	205	if (is_bitstring)
	206	fputs_filtered ("B'", stream);
	207	else
	208	fputs_filtered ("[", stream);
	209	for (i = low_bound; i <= high_bound; i++)
	210	{
	211	int element = value_bit_index (type, valaddr, i);
	212	if (is_bitstring)
	213	fprintf_filtered (stream, "%d", element);
	214	else if (element)
	215	{
	216	if (need_comma)
	217	fputs_filtered (", ", stream);
	218	print_type_scalar (TYPE_TARGET_TYPE (range), i, stream);
	219	need_comma = 1;
	220
	221	/* Look for a continuous range of true elements. */
	222	if (i+1 <= high_bound && value_bit_index (type, valaddr, ++i))
	223	{
	224	int j = i; /* j is the upper bound so far of the range */
	225	fputs_filtered (":", stream);
	226	while (i+1 <= high_bound
	227	&& value_bit_index (type, valaddr, ++i))
	228	j = i;
	229	print_type_scalar (TYPE_TARGET_TYPE (range), j, stream);
	230	}
	231	}
	232	}
	233	if (is_bitstring)
	234	fputs_filtered ("'", stream);
	235	else
	236	fputs_filtered ("]", stream);
	237	}
	238	break;
	239
8fbdca53	240	case TYPE_CODE_STRUCT:
cba00921 PB	241	if (chill_is_varying_struct (type))
	242	{
	243	struct type *inner = TYPE_FIELD_TYPE (type, 1);
	244	long length = unpack_long (TYPE_FIELD_TYPE (type, 0), valaddr);
	245	char *data_addr = valaddr + TYPE_FIELD_BITPOS (type, 1) / 8;
	246
	247	switch (TYPE_CODE (inner))
	248	{
	249	case TYPE_CODE_STRING:
	250	if (length > TYPE_LENGTH (type))
	251	{
	252	fprintf_filtered (stream,
	253	"<dynamic length %d > static length %d>",
	254	length, TYPE_LENGTH (type));
	255	length > TYPE_LENGTH (type);
	256	}
	257	LA_PRINT_STRING (stream, data_addr, length, 0);
	258	return length;
	259	}
	260	}
8fbdca53 FF	261	chill_print_value_fields (type, valaddr, stream, format, recurse, pretty,
	262	0);
	263	break;
	264
a8a69e63	265	case TYPE_CODE_REF:
8a177da6 PB	266	if (addressprint)
8a177da6 PB	267	{
833e0d94 JK	268	fprintf_filtered (stream, "LOC(");
	269	print_address_numeric
	270	(extract_address (valaddr, TARGET_PTR_BIT / HOST_CHAR_BIT),
	271	stream);
	272	fprintf_filtered (stream, ")");
8a177da6 PB	273	if (deref_ref)
	274	fputs_filtered (": ", stream);
	275	}
	276	/* De-reference the reference. */
	277	if (deref_ref)
	278	{
	279	if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_UNDEF)
	280	{
	281	value deref_val =
	282	value_at
	283	(TYPE_TARGET_TYPE (type),
	284	unpack_pointer (lookup_pointer_type (builtin_type_void),
	285	valaddr));
	286	val_print (VALUE_TYPE (deref_val),
	287	VALUE_CONTENTS (deref_val),
	288	VALUE_ADDRESS (deref_val), stream, format,
	289	deref_ref, recurse + 1, pretty);
	290	}
	291	else
	292	fputs_filtered ("???", stream);
	293	}
	294	break;
	295
a8a69e63	296	case TYPE_CODE_ENUM:
8a177da6 PB	297	c_val_print (type, valaddr, address, stream, format,
	298	deref_ref, recurse, pretty);
	299	break;
	300
11b959da FF	301	case TYPE_CODE_RANGE:
	302	if (TYPE_TARGET_TYPE (type))
	303	chill_val_print (TYPE_TARGET_TYPE (type), valaddr, address, stream,
	304	format, deref_ref, recurse, pretty);
	305	break;
	306
8a177da6 PB	307	case TYPE_CODE_MEMBER:
8a177da6 PB	308	case TYPE_CODE_UNION:
a8a69e63 FF	309	case TYPE_CODE_FUNC:
	310	case TYPE_CODE_VOID:
	311	case TYPE_CODE_ERROR:
a8a69e63	312	default:
11b959da	313	/* Let's defer printing to the C printer, rather than
8a177da6 PB	314	print an error message. FIXME! */
	315	c_val_print (type, valaddr, address, stream, format,
	316	deref_ref, recurse, pretty);
a8a69e63	317	}
199b2450	318	gdb_flush (stream);
a8a69e63 FF	319	return (0);
a8a69e63 FF	320	}
8fbdca53 FF	321
	322	/* Mutually recursive subroutines of cplus_print_value and c_val_print to
	323	print out a structure's fields: cp_print_value_fields and cplus_print_value.
	324
	325	TYPE, VALADDR, STREAM, RECURSE, and PRETTY have the
	326	same meanings as in cplus_print_value and c_val_print.
	327
	328	DONT_PRINT is an array of baseclass types that we
	329	should not print, or zero if called from top level. */
	330
	331	static void
	332	chill_print_value_fields (type, valaddr, stream, format, recurse, pretty,
	333	dont_print)
	334	struct type *type;
	335	char *valaddr;
199b2450	336	GDB_FILE *stream;
8fbdca53 FF	337	int format;
	338	int recurse;
	339	enum val_prettyprint pretty;
	340	struct type **dont_print;
	341	{
	342	int i, len;
	343	int fields_seen = 0;
	344
	345	check_stub_type (type);
	346
8a177da6	347	fprintf_filtered (stream, "[");
8fbdca53 FF	348	len = TYPE_NFIELDS (type);
	349	if (len == 0)
	350	{
	351	fprintf_filtered (stream, "<No data fields>");
	352	}
	353	else
	354	{
	355	for (i = 0; i < len; i++)
	356	{
	357	if (fields_seen)
	358	{
	359	fprintf_filtered (stream, ", ");
	360	}
	361	fields_seen = 1;
	362	if (pretty)
	363	{
	364	fprintf_filtered (stream, "\n");
	365	print_spaces_filtered (2 + 2 * recurse, stream);
	366	}
	367	else
	368	{
	369	wrap_here (n_spaces (2 + 2 * recurse));
	370	}
8a177da6	371	fputs_filtered (".", stream);
5e81259d FF	372	fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
5e81259d FF	373	language_chill, DMGL_NO_OPTS);
8a177da6	374	fputs_filtered (": ", stream);
8fbdca53 FF	375	if (TYPE_FIELD_PACKED (type, i))
	376	{
	377	value v;
	378
	379	/* Bitfields require special handling, especially due to byte
	380	order problems. */
	381	v = value_from_longest (TYPE_FIELD_TYPE (type, i),
	382	unpack_field_as_long (type, valaddr, i));
	383
	384	chill_val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0,
	385	stream, format, 0, recurse + 1, pretty);
	386	}
	387	else
	388	{
	389	chill_val_print (TYPE_FIELD_TYPE (type, i),
	390	valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
	391	0, stream, format, 0, recurse + 1, pretty);
	392	}
	393	}
	394	if (pretty)
	395	{
	396	fprintf_filtered (stream, "\n");
	397	print_spaces_filtered (2 * recurse, stream);
	398	}
	399	}
8a177da6	400	fprintf_filtered (stream, "]");
8fbdca53	401	}