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

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