[binutils.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
	{
	  /* FIXME: Why is this using builtin_type_chill_bool not type?  */
	  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_ptr 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_ptr 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	{
61932a8e	131	/* FIXME: Why is this using builtin_type_chill_bool not type? */
a8a69e63 FF	132	val = unpack_long (builtin_type_chill_bool, valaddr);
	133	fprintf_filtered (stream, val ? "TRUE" : "FALSE");
	134	}
	135	break;
	136
	137	case TYPE_CODE_UNDEF:
	138	/* This happens (without TYPE_FLAG_STUB set) on systems which don't use
	139	dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
	140	and no complete type for struct foo in that file. */
	141	fprintf_filtered (stream, "<incomplete type>");
	142	break;
	143
	144	case TYPE_CODE_PTR:
c7da3ed3 FF	145	if (format && format != 's')
	146	{
	147	print_scalar_formatted (valaddr, type, format, 0, stream);
	148	break;
	149	}
	150	addr = unpack_pointer (type, valaddr);
	151	elttype = TYPE_TARGET_TYPE (type);
	152
	153	if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
	154	{
	155	/* Try to print what function it points to. */
	156	print_address_demangle (addr, stream, demangle);
	157	/* Return value is irrelevant except for string pointers. */
	158	return (0);
	159	}
	160	if (addressprint && format != 's')
	161	{
833e0d94	162	print_address_numeric (addr, stream);
c7da3ed3 FF	163	}
	164
	165	/* For a pointer to char or unsigned char, also print the string
	166	pointed to, unless pointer is null. */
c7da3ed3 FF	167	if (TYPE_LENGTH (elttype) == 1
	168	&& TYPE_CODE (elttype) == TYPE_CODE_CHAR
	169	&& (format == 0 \|\| format == 's')
	170	&& addr != 0
	171	&& /* If print_max is UINT_MAX, the alloca below will fail.
	172	In that case don't try to print the string. */
	173	print_max < UINT_MAX)
	174	{
8fbdca53	175	i = val_print_string (addr, 0, stream);
c7da3ed3 FF	176	}
	177	/* Return number of characters printed, plus one for the
	178	terminating null if we have "reached the end". */
	179	return (i + (print_max && i != print_max));
	180	break;
	181
c4413e2c FF	182	case TYPE_CODE_STRING:
	183	if (format && format != 's')
	184	{
	185	print_scalar_formatted (valaddr, type, format, 0, stream);
	186	break;
	187	}
ec16f701 FF	188	i = TYPE_LENGTH (type);
ec16f701 FF	189	LA_PRINT_STRING (stream, valaddr, i, 0);
c4413e2c FF	190	/* Return number of characters printed, plus one for the terminating
	191	null if we have "reached the end". */
	192	return (i + (print_max && i != print_max));
	193	break;
	194
cba00921	195	case TYPE_CODE_BITSTRING:
e909f287 PB	196	case TYPE_CODE_SET:
	197	{
	198	struct type *range = TYPE_FIELD_TYPE (type, 0);
cba00921 PB	199	int low_bound = TYPE_LOW_BOUND (range);
cba00921 PB	200	int high_bound = TYPE_HIGH_BOUND (range);
e909f287	201	int i;
cba00921	202	int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
e909f287 PB	203	int need_comma = 0;
	204	int in_range = 0;
	205
	206	if (is_bitstring)
	207	fputs_filtered ("B'", stream);
	208	else
	209	fputs_filtered ("[", stream);
	210	for (i = low_bound; i <= high_bound; i++)
	211	{
	212	int element = value_bit_index (type, valaddr, i);
	213	if (is_bitstring)
	214	fprintf_filtered (stream, "%d", element);
	215	else if (element)
	216	{
	217	if (need_comma)
	218	fputs_filtered (", ", stream);
	219	print_type_scalar (TYPE_TARGET_TYPE (range), i, stream);
	220	need_comma = 1;
	221
	222	/* Look for a continuous range of true elements. */
	223	if (i+1 <= high_bound && value_bit_index (type, valaddr, ++i))
	224	{
	225	int j = i; /* j is the upper bound so far of the range */
	226	fputs_filtered (":", stream);
	227	while (i+1 <= high_bound
	228	&& value_bit_index (type, valaddr, ++i))
	229	j = i;
	230	print_type_scalar (TYPE_TARGET_TYPE (range), j, stream);
	231	}
	232	}
	233	}
	234	if (is_bitstring)
	235	fputs_filtered ("'", stream);
	236	else
	237	fputs_filtered ("]", stream);
	238	}
	239	break;
	240
8fbdca53	241	case TYPE_CODE_STRUCT:
cba00921 PB	242	if (chill_is_varying_struct (type))
	243	{
	244	struct type *inner = TYPE_FIELD_TYPE (type, 1);
	245	long length = unpack_long (TYPE_FIELD_TYPE (type, 0), valaddr);
	246	char *data_addr = valaddr + TYPE_FIELD_BITPOS (type, 1) / 8;
	247
	248	switch (TYPE_CODE (inner))
	249	{
	250	case TYPE_CODE_STRING:
	251	if (length > TYPE_LENGTH (type))
	252	{
	253	fprintf_filtered (stream,
	254	"<dynamic length %d > static length %d>",
	255	length, TYPE_LENGTH (type));
	256	length > TYPE_LENGTH (type);
	257	}
	258	LA_PRINT_STRING (stream, data_addr, length, 0);
	259	return length;
	260	}
	261	}
8fbdca53 FF	262	chill_print_value_fields (type, valaddr, stream, format, recurse, pretty,
	263	0);
	264	break;
	265
a8a69e63	266	case TYPE_CODE_REF:
8a177da6 PB	267	if (addressprint)
8a177da6 PB	268	{
833e0d94 JK	269	fprintf_filtered (stream, "LOC(");
	270	print_address_numeric
	271	(extract_address (valaddr, TARGET_PTR_BIT / HOST_CHAR_BIT),
	272	stream);
	273	fprintf_filtered (stream, ")");
8a177da6 PB	274	if (deref_ref)
	275	fputs_filtered (": ", stream);
	276	}
	277	/* De-reference the reference. */
	278	if (deref_ref)
	279	{
	280	if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_UNDEF)
	281	{
82a2edfb	282	value_ptr deref_val =
8a177da6 PB	283	value_at
	284	(TYPE_TARGET_TYPE (type),
	285	unpack_pointer (lookup_pointer_type (builtin_type_void),
	286	valaddr));
	287	val_print (VALUE_TYPE (deref_val),
	288	VALUE_CONTENTS (deref_val),
	289	VALUE_ADDRESS (deref_val), stream, format,
	290	deref_ref, recurse + 1, pretty);
	291	}
	292	else
	293	fputs_filtered ("???", stream);
	294	}
	295	break;
	296
a8a69e63	297	case TYPE_CODE_ENUM:
8a177da6 PB	298	c_val_print (type, valaddr, address, stream, format,
	299	deref_ref, recurse, pretty);
	300	break;
	301
11b959da FF	302	case TYPE_CODE_RANGE:
	303	if (TYPE_TARGET_TYPE (type))
	304	chill_val_print (TYPE_TARGET_TYPE (type), valaddr, address, stream,
	305	format, deref_ref, recurse, pretty);
	306	break;
	307
8a177da6 PB	308	case TYPE_CODE_MEMBER:
8a177da6 PB	309	case TYPE_CODE_UNION:
a8a69e63 FF	310	case TYPE_CODE_FUNC:
	311	case TYPE_CODE_VOID:
	312	case TYPE_CODE_ERROR:
a8a69e63	313	default:
11b959da	314	/* Let's defer printing to the C printer, rather than
8a177da6 PB	315	print an error message. FIXME! */
	316	c_val_print (type, valaddr, address, stream, format,
	317	deref_ref, recurse, pretty);
a8a69e63	318	}
199b2450	319	gdb_flush (stream);
a8a69e63 FF	320	return (0);
a8a69e63 FF	321	}
8fbdca53 FF	322
	323	/* Mutually recursive subroutines of cplus_print_value and c_val_print to
	324	print out a structure's fields: cp_print_value_fields and cplus_print_value.
	325
	326	TYPE, VALADDR, STREAM, RECURSE, and PRETTY have the
	327	same meanings as in cplus_print_value and c_val_print.
	328
	329	DONT_PRINT is an array of baseclass types that we
	330	should not print, or zero if called from top level. */
	331
	332	static void
	333	chill_print_value_fields (type, valaddr, stream, format, recurse, pretty,
	334	dont_print)
	335	struct type *type;
	336	char *valaddr;
199b2450	337	GDB_FILE *stream;
8fbdca53 FF	338	int format;
	339	int recurse;
	340	enum val_prettyprint pretty;
	341	struct type **dont_print;
	342	{
	343	int i, len;
	344	int fields_seen = 0;
	345
	346	check_stub_type (type);
	347
8a177da6	348	fprintf_filtered (stream, "[");
8fbdca53 FF	349	len = TYPE_NFIELDS (type);
	350	if (len == 0)
	351	{
	352	fprintf_filtered (stream, "<No data fields>");
	353	}
	354	else
	355	{
	356	for (i = 0; i < len; i++)
	357	{
	358	if (fields_seen)
	359	{
	360	fprintf_filtered (stream, ", ");
	361	}
	362	fields_seen = 1;
	363	if (pretty)
	364	{
	365	fprintf_filtered (stream, "\n");
	366	print_spaces_filtered (2 + 2 * recurse, stream);
	367	}
	368	else
	369	{
	370	wrap_here (n_spaces (2 + 2 * recurse));
	371	}
8a177da6	372	fputs_filtered (".", stream);
5e81259d FF	373	fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
5e81259d FF	374	language_chill, DMGL_NO_OPTS);
8a177da6	375	fputs_filtered (": ", stream);
8fbdca53 FF	376	if (TYPE_FIELD_PACKED (type, i))
8fbdca53 FF	377	{
82a2edfb	378	value_ptr v;
8fbdca53 FF	379
	380	/* Bitfields require special handling, especially due to byte
	381	order problems. */
	382	v = value_from_longest (TYPE_FIELD_TYPE (type, i),
	383	unpack_field_as_long (type, valaddr, i));
	384
	385	chill_val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0,
	386	stream, format, 0, recurse + 1, pretty);
	387	}
	388	else
	389	{
	390	chill_val_print (TYPE_FIELD_TYPE (type, i),
	391	valaddr + TYPE_FIELD_BITPOS (type, i) / 8,
	392	0, stream, format, 0, recurse + 1, pretty);
	393	}
	394	}
	395	if (pretty)
	396	{
	397	fprintf_filtered (stream, "\n");
	398	print_spaces_filtered (2 * recurse, stream);
	399	}
	400	}
8a177da6	401	fprintf_filtered (stream, "]");
8fbdca53	402	}