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

/* Support for printing Chill values for GDB, the GNU debugger.
   Copyright 1986, 1988, 1989, 1991-1994, 2000
   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 "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 */
#include "typeprint.h"
#include "ch-lang.h"
#include "annotate.h"

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

static void chill_print_type_scalar (struct type *, LONGEST,
				     struct ui_file *);

static void chill_val_print_array_elements (struct type *, char *,
					    CORE_ADDR, struct ui_file *,
					    int, int, int,
					    enum val_prettyprint);
\f

/* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
   Used to print data from type structures in a specified type.  For example,
   array bounds may be characters or booleans in some languages, and this
   allows the ranges to be printed in their "natural" form rather than as
   decimal integer values. */

static void
chill_print_type_scalar (type, val, stream)
     struct type *type;
     LONGEST val;
     struct ui_file *stream;
{
  switch (TYPE_CODE (type))
    {
    case TYPE_CODE_RANGE:
      if (TYPE_TARGET_TYPE (type))
	{
	  chill_print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
	  return;
	}
      break;
    case TYPE_CODE_UNDEF:
    case TYPE_CODE_PTR:
    case TYPE_CODE_ARRAY:
    case TYPE_CODE_STRUCT:
    case TYPE_CODE_UNION:
    case TYPE_CODE_ENUM:
    case TYPE_CODE_FUNC:
    case TYPE_CODE_INT:
    case TYPE_CODE_FLT:
    case TYPE_CODE_VOID:
    case TYPE_CODE_SET:
    case TYPE_CODE_STRING:
    case TYPE_CODE_BITSTRING:
    case TYPE_CODE_ERROR:
    case TYPE_CODE_MEMBER:
    case TYPE_CODE_METHOD:
    case TYPE_CODE_REF:
    case TYPE_CODE_CHAR:
    case TYPE_CODE_BOOL:
    case TYPE_CODE_COMPLEX:
    case TYPE_CODE_TYPEDEF:
    default:
      break;
    }
  print_type_scalar (type, val, stream);
}
\f
/* Print the elements of an array.
   Similar to val_print_array_elements, but prints
   element indexes (in Chill syntax). */

static void
chill_val_print_array_elements (type, valaddr, address, stream,
				format, deref_ref, recurse, pretty)
     struct type *type;
     char *valaddr;
     CORE_ADDR address;
     struct ui_file *stream;
     int format;
     int deref_ref;
     int recurse;
     enum val_prettyprint pretty;
{
  unsigned int i = 0;
  unsigned int things_printed = 0;
  unsigned len;
  struct type *elttype;
  struct type *range_type = TYPE_FIELD_TYPE (type, 0);
  struct type *index_type = TYPE_TARGET_TYPE (range_type);
  unsigned eltlen;
  /* Position of the array element we are examining to see
     whether it is repeated.  */
  unsigned int rep1;
  /* Number of repetitions we have detected so far.  */
  unsigned int reps;
  LONGEST low_bound = TYPE_FIELD_BITPOS (range_type, 0);

  elttype = check_typedef (TYPE_TARGET_TYPE (type));
  eltlen = TYPE_LENGTH (elttype);
  len = TYPE_LENGTH (type) / eltlen;

  annotate_array_section_begin (i, elttype);

  for (; i < len && things_printed < print_max; i++)
    {
      if (i != 0)
	{
	  if (prettyprint_arrays)
	    {
	      fprintf_filtered (stream, ",\n");
	      print_spaces_filtered (2 + 2 * recurse, stream);
	    }
	  else
	    {
	      fprintf_filtered (stream, ", ");
	    }
	}
      wrap_here (n_spaces (2 + 2 * recurse));

      rep1 = i + 1;
      reps = 1;
      while ((rep1 < len) &&
	     !memcmp (valaddr + i * eltlen, valaddr + rep1 * eltlen, eltlen))
	{
	  ++reps;
	  ++rep1;
	}

      fputs_filtered ("(", stream);
      chill_print_type_scalar (index_type, low_bound + i, stream);
      if (reps > 1)
	{
	  fputs_filtered (":", stream);
	  chill_print_type_scalar (index_type, low_bound + i + reps - 1,
				   stream);
	  fputs_filtered ("): ", stream);
	  val_print (elttype, valaddr + i * eltlen, 0, 0, stream, format,
		     deref_ref, recurse + 1, pretty);

	  i = rep1 - 1;
	  things_printed += 1;
	}
      else
	{
	  fputs_filtered ("): ", stream);
	  val_print (elttype, valaddr + i * eltlen, 0, 0, stream, format,
		     deref_ref, recurse + 1, pretty);
	  annotate_elt ();
	  things_printed++;
	}
    }
  annotate_array_section_end ();
  if (i < len)
    {
      fprintf_filtered (stream, "...");
    }
}

/* 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, embedded_offset, address,
		 stream, format, deref_ref, recurse, pretty)
     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;
{
  LONGEST val;
  unsigned int i = 0;		/* Number of characters printed.  */
  struct type *elttype;
  CORE_ADDR addr;

  CHECK_TYPEDEF (type);

  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, "[");
	  chill_val_print_array_elements (type, valaddr, address, stream,
					format, deref_ref, recurse, pretty);
	  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 = check_typedef (TYPE_TARGET_TYPE (type));

      /* We assume a NULL pointer is all zeros ... */
      if (addr == 0)
	{
	  fputs_filtered ("NULL", stream);
	  return 0;
	}

      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, 1, 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, -1, TYPE_LENGTH (elttype), 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:
      i = TYPE_LENGTH (type);
      LA_PRINT_STRING (stream, valaddr, i, 1, 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:
      elttype = TYPE_INDEX_TYPE (type);
      CHECK_TYPEDEF (elttype);
      if (TYPE_FLAGS (elttype) & TYPE_FLAG_STUB)
	{
	  fprintf_filtered (stream, "<incomplete type>");
	  gdb_flush (stream);
	  break;
	}
      {
	struct type *range = elttype;
	LONGEST low_bound, high_bound;
	int i;
	int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
	int need_comma = 0;

	if (is_bitstring)
	  fputs_filtered ("B'", stream);
	else
	  fputs_filtered ("[", stream);

	i = get_discrete_bounds (range, &low_bound, &high_bound);
      maybe_bad_bstring:
	if (i < 0)
	  {
	    fputs_filtered ("<error value>", stream);
	    goto done;
	  }

	for (i = low_bound; i <= high_bound; i++)
	  {
	    int element = value_bit_index (type, valaddr, i);
	    if (element < 0)
	      {
		i = element;
		goto maybe_bad_bstring;
	      }
	    if (is_bitstring)
	      fprintf_filtered (stream, "%d", element);
	    else if (element)
	      {
		if (need_comma)
		  fputs_filtered (", ", stream);
		chill_print_type_scalar (range, (LONGEST) 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;
		    chill_print_type_scalar (range, (LONGEST) j, stream);
		  }
	      }
	  }
      done:
	if (is_bitstring)
	  fputs_filtered ("'", stream);
	else
	  fputs_filtered ("]", stream);
      }
      break;

    case TYPE_CODE_STRUCT:
      if (chill_varying_type (type))
	{
	  struct type *inner = check_typedef (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) - 2)
		{
		  fprintf_filtered (stream,
			"<dynamic length %ld > static length %d> *invalid*",
				    length, TYPE_LENGTH (type));

		  /* Don't print the string; doing so might produce a
		     segfault.  */
		  return length;
		}
	      LA_PRINT_STRING (stream, data_addr, length, 1, 0);
	      return length;
	    default:
	      break;
	    }
	}
      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),
	     1,
	     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),
	       NULL);
	      val_print (VALUE_TYPE (deref_val),
			 VALUE_CONTENTS (deref_val),
			 0,
			 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, 0, 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, 0, 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, 0, 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;
     struct ui_file *stream;
     int format;
     int recurse;
     enum val_prettyprint pretty;
     struct type **dont_print;
{
  int i, len;
  int fields_seen = 0;

  CHECK_TYPEDEF (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, 0,
			       stream, format, 0, recurse + 1, pretty);
	    }
	  else
	    {
	      chill_val_print (TYPE_FIELD_TYPE (type, i),
			       valaddr + TYPE_FIELD_BITPOS (type, i) / 8, 0,
			       0, stream, format, 0, recurse + 1, pretty);
	    }
	}
      if (pretty)
	{
	  fprintf_filtered (stream, "\n");
	  print_spaces_filtered (2 * recurse, stream);
	}
    }
  fprintf_filtered (stream, "]");
}
\f
int
chill_value_print (val, stream, format, pretty)
     value_ptr val;
     struct ui_file *stream;
     int format;
     enum val_prettyprint pretty;
{
  struct type *type = VALUE_TYPE (val);
  struct type *real_type = check_typedef (type);

  /* If it is a pointer, indicate what it points to.

     Print type also if it is a reference. */

  if (TYPE_CODE (real_type) == TYPE_CODE_PTR ||
      TYPE_CODE (real_type) == TYPE_CODE_REF)
    {
      char *valaddr = VALUE_CONTENTS (val);
      CORE_ADDR addr = unpack_pointer (type, valaddr);
      if (TYPE_CODE (type) != TYPE_CODE_PTR || addr != 0)
	{
	  int i;
	  char *name = TYPE_NAME (type);
	  if (name)
	    fputs_filtered (name, stream);
	  else if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
	    fputs_filtered ("PTR", stream);
	  else
	    {
	      fprintf_filtered (stream, "(");
	      type_print (type, "", stream, -1);
	      fprintf_filtered (stream, ")");
	    }
	  fprintf_filtered (stream, "(");
	  i = val_print (type, valaddr, 0, VALUE_ADDRESS (val),
			 stream, format, 1, 0, pretty);
	  fprintf_filtered (stream, ")");
	  return i;
	}
    }
  return (val_print (type, VALUE_CONTENTS (val), 0,
		     VALUE_ADDRESS (val), stream, format, 1, 0, pretty));
}
Commit	Line	Data
c906108c	1	/* Support for printing Chill values for GDB, the GNU debugger.
d9fcf2fb	2	Copyright 1986, 1988, 1989, 1991-1994, 2000
c906108c SS	3	Free Software Foundation, Inc.
c906108c SS	4
c5aa993b	5	This file is part of GDB.
c906108c	6
c5aa993b JM	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.
c906108c	11
c5aa993b JM	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.
c906108c	16
c5aa993b JM	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., 59 Temple Place - Suite 330,
	20	Boston, MA 02111-1307, USA. */
c906108c SS	21
	22	#include "defs.h"
	23	#include "obstack.h"
	24	#include "symtab.h"
	25	#include "gdbtypes.h"
	26	#include "valprint.h"
	27	#include "expression.h"
	28	#include "value.h"
	29	#include "language.h"
	30	#include "demangle.h"
c5aa993b	31	#include "c-lang.h" /* For c_val_print */
c906108c SS	32	#include "typeprint.h"
	33	#include "ch-lang.h"
	34	#include "annotate.h"
	35
d9fcf2fb JM	36	static void chill_print_value_fields (struct type , char ,
	37	struct ui_file *, int, int,
	38	enum val_prettyprint, struct type **);
c906108c	39
d9fcf2fb JM	40	static void chill_print_type_scalar (struct type *, LONGEST,
d9fcf2fb JM	41	struct ui_file *);
c906108c	42
d9fcf2fb JM	43	static void chill_val_print_array_elements (struct type , char ,
	44	CORE_ADDR, struct ui_file *,
	45	int, int, int,
	46	enum val_prettyprint);
c906108c	47	\f
c5aa993b	48
c906108c SS	49	/* Print integral scalar data VAL, of type TYPE, onto stdio stream STREAM.
	50	Used to print data from type structures in a specified type. For example,
	51	array bounds may be characters or booleans in some languages, and this
	52	allows the ranges to be printed in their "natural" form rather than as
	53	decimal integer values. */
	54
	55	static void
	56	chill_print_type_scalar (type, val, stream)
	57	struct type *type;
	58	LONGEST val;
d9fcf2fb	59	struct ui_file *stream;
c906108c SS	60	{
	61	switch (TYPE_CODE (type))
	62	{
	63	case TYPE_CODE_RANGE:
	64	if (TYPE_TARGET_TYPE (type))
	65	{
	66	chill_print_type_scalar (TYPE_TARGET_TYPE (type), val, stream);
	67	return;
	68	}
	69	break;
	70	case TYPE_CODE_UNDEF:
	71	case TYPE_CODE_PTR:
	72	case TYPE_CODE_ARRAY:
	73	case TYPE_CODE_STRUCT:
	74	case TYPE_CODE_UNION:
	75	case TYPE_CODE_ENUM:
	76	case TYPE_CODE_FUNC:
	77	case TYPE_CODE_INT:
	78	case TYPE_CODE_FLT:
	79	case TYPE_CODE_VOID:
	80	case TYPE_CODE_SET:
	81	case TYPE_CODE_STRING:
	82	case TYPE_CODE_BITSTRING:
	83	case TYPE_CODE_ERROR:
	84	case TYPE_CODE_MEMBER:
	85	case TYPE_CODE_METHOD:
	86	case TYPE_CODE_REF:
	87	case TYPE_CODE_CHAR:
	88	case TYPE_CODE_BOOL:
	89	case TYPE_CODE_COMPLEX:
	90	case TYPE_CODE_TYPEDEF:
	91	default:
	92	break;
	93	}
	94	print_type_scalar (type, val, stream);
	95	}
	96	\f
	97	/* Print the elements of an array.
	98	Similar to val_print_array_elements, but prints
	99	element indexes (in Chill syntax). */
	100
	101	static void
	102	chill_val_print_array_elements (type, valaddr, address, stream,
	103	format, deref_ref, recurse, pretty)
	104	struct type *type;
	105	char *valaddr;
	106	CORE_ADDR address;
d9fcf2fb	107	struct ui_file *stream;
c906108c SS	108	int format;
	109	int deref_ref;
	110	int recurse;
	111	enum val_prettyprint pretty;
	112	{
	113	unsigned int i = 0;
	114	unsigned int things_printed = 0;
	115	unsigned len;
	116	struct type *elttype;
	117	struct type *range_type = TYPE_FIELD_TYPE (type, 0);
	118	struct type *index_type = TYPE_TARGET_TYPE (range_type);
	119	unsigned eltlen;
	120	/* Position of the array element we are examining to see
	121	whether it is repeated. */
	122	unsigned int rep1;
	123	/* Number of repetitions we have detected so far. */
	124	unsigned int reps;
c5aa993b JM	125	LONGEST low_bound = TYPE_FIELD_BITPOS (range_type, 0);
c5aa993b JM	126
c906108c SS	127	elttype = check_typedef (TYPE_TARGET_TYPE (type));
	128	eltlen = TYPE_LENGTH (elttype);
	129	len = TYPE_LENGTH (type) / eltlen;
	130
	131	annotate_array_section_begin (i, elttype);
	132
	133	for (; i < len && things_printed < print_max; i++)
	134	{
	135	if (i != 0)
	136	{
	137	if (prettyprint_arrays)
	138	{
	139	fprintf_filtered (stream, ",\n");
	140	print_spaces_filtered (2 + 2 * recurse, stream);
	141	}
	142	else
	143	{
	144	fprintf_filtered (stream, ", ");
	145	}
	146	}
	147	wrap_here (n_spaces (2 + 2 * recurse));
	148
	149	rep1 = i + 1;
	150	reps = 1;
c5aa993b	151	while ((rep1 < len) &&
c906108c SS	152	!memcmp (valaddr + i * eltlen, valaddr + rep1 * eltlen, eltlen))
	153	{
	154	++reps;
	155	++rep1;
	156	}
	157
	158	fputs_filtered ("(", stream);
	159	chill_print_type_scalar (index_type, low_bound + i, stream);
	160	if (reps > 1)
	161	{
	162	fputs_filtered (":", stream);
	163	chill_print_type_scalar (index_type, low_bound + i + reps - 1,
	164	stream);
	165	fputs_filtered ("): ", stream);
	166	val_print (elttype, valaddr + i * eltlen, 0, 0, stream, format,
	167	deref_ref, recurse + 1, pretty);
	168
	169	i = rep1 - 1;
	170	things_printed += 1;
	171	}
	172	else
	173	{
	174	fputs_filtered ("): ", stream);
	175	val_print (elttype, valaddr + i * eltlen, 0, 0, stream, format,
	176	deref_ref, recurse + 1, pretty);
	177	annotate_elt ();
	178	things_printed++;
	179	}
	180	}
	181	annotate_array_section_end ();
	182	if (i < len)
	183	{
	184	fprintf_filtered (stream, "...");
	185	}
	186	}
	187
	188	/* Print data of type TYPE located at VALADDR (within GDB), which came from
	189	the inferior at address ADDRESS, onto stdio stream STREAM according to
	190	FORMAT (a letter or 0 for natural format). The data at VALADDR is in
	191	target byte order.
	192
	193	If the data are a string pointer, returns the number of string characters
	194	printed.
	195
	196	If DEREF_REF is nonzero, then dereference references, otherwise just print
	197	them like pointers.
	198
	199	The PRETTY parameter controls prettyprinting. */
	200
	201	int
	202	chill_val_print (type, valaddr, embedded_offset, address,
c5aa993b	203	stream, format, deref_ref, recurse, pretty)
c906108c SS	204	struct type *type;
	205	char *valaddr;
	206	int embedded_offset;
	207	CORE_ADDR address;
d9fcf2fb	208	struct ui_file *stream;
c906108c SS	209	int format;
	210	int deref_ref;
	211	int recurse;
	212	enum val_prettyprint pretty;
	213	{
	214	LONGEST val;
	215	unsigned int i = 0; /* Number of characters printed. */
	216	struct type *elttype;
	217	CORE_ADDR addr;
	218
	219	CHECK_TYPEDEF (type);
	220
	221	switch (TYPE_CODE (type))
	222	{
	223	case TYPE_CODE_ARRAY:
	224	if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
	225	{
	226	if (prettyprint_arrays)
	227	{
	228	print_spaces_filtered (2 + 2 * recurse, stream);
	229	}
	230	fprintf_filtered (stream, "[");
	231	chill_val_print_array_elements (type, valaddr, address, stream,
c5aa993b	232	format, deref_ref, recurse, pretty);
c906108c SS	233	fprintf_filtered (stream, "]");
	234	}
	235	else
	236	{
	237	error ("unimplemented in chill_val_print; unspecified array length");
	238	}
	239	break;
	240
	241	case TYPE_CODE_INT:
	242	format = format ? format : output_format;
	243	if (format)
	244	{
	245	print_scalar_formatted (valaddr, type, format, 0, stream);
	246	}
	247	else
	248	{
	249	val_print_type_code_int (type, valaddr, stream);
	250	}
	251	break;
	252
	253	case TYPE_CODE_CHAR:
	254	format = format ? format : output_format;
	255	if (format)
	256	{
	257	print_scalar_formatted (valaddr, type, format, 0, stream);
	258	}
	259	else
	260	{
	261	LA_PRINT_CHAR ((unsigned char) unpack_long (type, valaddr),
	262	stream);
	263	}
	264	break;
	265
	266	case TYPE_CODE_FLT:
	267	if (format)
	268	{
	269	print_scalar_formatted (valaddr, type, format, 0, stream);
	270	}
	271	else
	272	{
	273	print_floating (valaddr, type, stream);
	274	}
	275	break;
	276
	277	case TYPE_CODE_BOOL:
	278	format = format ? format : output_format;
	279	if (format)
	280	{
	281	print_scalar_formatted (valaddr, type, format, 0, stream);
	282	}
	283	else
	284	{
	285	/* FIXME: Why is this using builtin_type_chill_bool not type? */
	286	val = unpack_long (builtin_type_chill_bool, valaddr);
	287	fprintf_filtered (stream, val ? "TRUE" : "FALSE");
	288	}
	289	break;
	290
	291	case TYPE_CODE_UNDEF:
	292	/* This happens (without TYPE_FLAG_STUB set) on systems which don't use
c5aa993b JM	293	dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
c5aa993b JM	294	and no complete type for struct foo in that file. */
c906108c SS	295	fprintf_filtered (stream, "<incomplete type>");
	296	break;
	297
	298	case TYPE_CODE_PTR:
	299	if (format && format != 's')
	300	{
	301	print_scalar_formatted (valaddr, type, format, 0, stream);
	302	break;
	303	}
	304	addr = unpack_pointer (type, valaddr);
	305	elttype = check_typedef (TYPE_TARGET_TYPE (type));
	306
	307	/* We assume a NULL pointer is all zeros ... */
	308	if (addr == 0)
	309	{
	310	fputs_filtered ("NULL", stream);
	311	return 0;
	312	}
c5aa993b	313
c906108c SS	314	if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
	315	{
	316	/* Try to print what function it points to. */
	317	print_address_demangle (addr, stream, demangle);
	318	/* Return value is irrelevant except for string pointers. */
	319	return (0);
	320	}
	321	if (addressprint && format != 's')
	322	{
	323	print_address_numeric (addr, 1, stream);
	324	}
c5aa993b	325
c906108c	326	/* For a pointer to char or unsigned char, also print the string
c5aa993b	327	pointed to, unless pointer is null. */
c906108c SS	328	if (TYPE_LENGTH (elttype) == 1
	329	&& TYPE_CODE (elttype) == TYPE_CODE_CHAR
	330	&& (format == 0 \|\| format == 's')
	331	&& addr != 0
c5aa993b JM	332	&& /* If print_max is UINT_MAX, the alloca below will fail.
c5aa993b JM	333	In that case don't try to print the string. */
c906108c SS	334	print_max < UINT_MAX)
	335	i = val_print_string (addr, -1, TYPE_LENGTH (elttype), stream);
	336
	337	/* Return number of characters printed, plus one for the
c5aa993b	338	terminating null if we have "reached the end". */
c906108c SS	339	return (i + (print_max && i != print_max));
	340	break;
	341
	342	case TYPE_CODE_STRING:
	343	i = TYPE_LENGTH (type);
	344	LA_PRINT_STRING (stream, valaddr, i, 1, 0);
	345	/* Return number of characters printed, plus one for the terminating
c5aa993b	346	null if we have "reached the end". */
c906108c SS	347	return (i + (print_max && i != print_max));
	348	break;
	349
	350	case TYPE_CODE_BITSTRING:
	351	case TYPE_CODE_SET:
	352	elttype = TYPE_INDEX_TYPE (type);
	353	CHECK_TYPEDEF (elttype);
	354	if (TYPE_FLAGS (elttype) & TYPE_FLAG_STUB)
	355	{
	356	fprintf_filtered (stream, "<incomplete type>");
	357	gdb_flush (stream);
	358	break;
	359	}
	360	{
	361	struct type *range = elttype;
	362	LONGEST low_bound, high_bound;
	363	int i;
	364	int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
	365	int need_comma = 0;
	366
	367	if (is_bitstring)
	368	fputs_filtered ("B'", stream);
	369	else
	370	fputs_filtered ("[", stream);
	371
	372	i = get_discrete_bounds (range, &low_bound, &high_bound);
	373	maybe_bad_bstring:
	374	if (i < 0)
	375	{
	376	fputs_filtered ("<error value>", stream);
	377	goto done;
	378	}
	379
	380	for (i = low_bound; i <= high_bound; i++)
	381	{
	382	int element = value_bit_index (type, valaddr, i);
	383	if (element < 0)
	384	{
	385	i = element;
	386	goto maybe_bad_bstring;
	387	}
	388	if (is_bitstring)
	389	fprintf_filtered (stream, "%d", element);
	390	else if (element)
	391	{
	392	if (need_comma)
	393	fputs_filtered (", ", stream);
	394	chill_print_type_scalar (range, (LONGEST) i, stream);
	395	need_comma = 1;
	396
	397	/* Look for a continuous range of true elements. */
c5aa993b	398	if (i + 1 <= high_bound && value_bit_index (type, valaddr, ++i))
c906108c	399	{
c5aa993b	400	int j = i; /* j is the upper bound so far of the range */
c906108c	401	fputs_filtered (":", stream);
c5aa993b	402	while (i + 1 <= high_bound
c906108c SS	403	&& value_bit_index (type, valaddr, ++i))
	404	j = i;
	405	chill_print_type_scalar (range, (LONGEST) j, stream);
	406	}
	407	}
	408	}
	409	done:
	410	if (is_bitstring)
	411	fputs_filtered ("'", stream);
	412	else
	413	fputs_filtered ("]", stream);
	414	}
	415	break;
	416
	417	case TYPE_CODE_STRUCT:
	418	if (chill_varying_type (type))
	419	{
	420	struct type *inner = check_typedef (TYPE_FIELD_TYPE (type, 1));
	421	long length = unpack_long (TYPE_FIELD_TYPE (type, 0), valaddr);
	422	char *data_addr = valaddr + TYPE_FIELD_BITPOS (type, 1) / 8;
c5aa993b	423
c906108c SS	424	switch (TYPE_CODE (inner))
	425	{
	426	case TYPE_CODE_STRING:
	427	if (length > TYPE_LENGTH (type) - 2)
	428	{
	429	fprintf_filtered (stream,
c5aa993b	430	"<dynamic length %ld > static length %d> invalid",
c906108c SS	431	length, TYPE_LENGTH (type));
	432
	433	/* Don't print the string; doing so might produce a
	434	segfault. */
	435	return length;
	436	}
	437	LA_PRINT_STRING (stream, data_addr, length, 1, 0);
	438	return length;
	439	default:
	440	break;
	441	}
	442	}
	443	chill_print_value_fields (type, valaddr, stream, format, recurse, pretty,
	444	0);
	445	break;
	446
	447	case TYPE_CODE_REF:
	448	if (addressprint)
c5aa993b	449	{
c906108c SS	450	fprintf_filtered (stream, "LOC(");
	451	print_address_numeric
	452	(extract_address (valaddr, TARGET_PTR_BIT / HOST_CHAR_BIT),
	453	1,
	454	stream);
	455	fprintf_filtered (stream, ")");
	456	if (deref_ref)
	457	fputs_filtered (": ", stream);
c5aa993b	458	}
c906108c SS	459	/* De-reference the reference. */
	460	if (deref_ref)
	461	{
	462	if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_UNDEF)
	463	{
	464	value_ptr deref_val =
c5aa993b JM	465	value_at
	466	(TYPE_TARGET_TYPE (type),
	467	unpack_pointer (lookup_pointer_type (builtin_type_void),
	468	valaddr),
	469	NULL);
c906108c SS	470	val_print (VALUE_TYPE (deref_val),
c906108c SS	471	VALUE_CONTENTS (deref_val),
c5aa993b	472	0,
c906108c SS	473	VALUE_ADDRESS (deref_val), stream, format,
	474	deref_ref, recurse + 1, pretty);
	475	}
	476	else
	477	fputs_filtered ("???", stream);
	478	}
	479	break;
	480
	481	case TYPE_CODE_ENUM:
	482	c_val_print (type, valaddr, 0, address, stream, format,
	483	deref_ref, recurse, pretty);
	484	break;
	485
	486	case TYPE_CODE_RANGE:
	487	if (TYPE_TARGET_TYPE (type))
	488	chill_val_print (TYPE_TARGET_TYPE (type), valaddr, 0, address, stream,
	489	format, deref_ref, recurse, pretty);
	490	break;
	491
	492	case TYPE_CODE_MEMBER:
	493	case TYPE_CODE_UNION:
	494	case TYPE_CODE_FUNC:
	495	case TYPE_CODE_VOID:
	496	case TYPE_CODE_ERROR:
	497	default:
	498	/* Let's defer printing to the C printer, rather than
c5aa993b	499	print an error message. FIXME! */
c906108c SS	500	c_val_print (type, valaddr, 0, address, stream, format,
	501	deref_ref, recurse, pretty);
	502	}
	503	gdb_flush (stream);
	504	return (0);
	505	}
	506
	507	/* Mutually recursive subroutines of cplus_print_value and c_val_print to
	508	print out a structure's fields: cp_print_value_fields and cplus_print_value.
	509
	510	TYPE, VALADDR, STREAM, RECURSE, and PRETTY have the
	511	same meanings as in cplus_print_value and c_val_print.
	512
	513	DONT_PRINT is an array of baseclass types that we
	514	should not print, or zero if called from top level. */
	515
	516	static void
	517	chill_print_value_fields (type, valaddr, stream, format, recurse, pretty,
	518	dont_print)
	519	struct type *type;
	520	char *valaddr;
d9fcf2fb	521	struct ui_file *stream;
c906108c SS	522	int format;
	523	int recurse;
	524	enum val_prettyprint pretty;
	525	struct type **dont_print;
	526	{
	527	int i, len;
	528	int fields_seen = 0;
	529
	530	CHECK_TYPEDEF (type);
	531
	532	fprintf_filtered (stream, "[");
	533	len = TYPE_NFIELDS (type);
	534	if (len == 0)
	535	{
	536	fprintf_filtered (stream, "<No data fields>");
	537	}
	538	else
	539	{
	540	for (i = 0; i < len; i++)
	541	{
	542	if (fields_seen)
	543	{
	544	fprintf_filtered (stream, ", ");
	545	}
	546	fields_seen = 1;
	547	if (pretty)
	548	{
	549	fprintf_filtered (stream, "\n");
	550	print_spaces_filtered (2 + 2 * recurse, stream);
	551	}
c5aa993b	552	else
c906108c SS	553	{
	554	wrap_here (n_spaces (2 + 2 * recurse));
	555	}
	556	fputs_filtered (".", stream);
	557	fprintf_symbol_filtered (stream, TYPE_FIELD_NAME (type, i),
	558	language_chill, DMGL_NO_OPTS);
	559	fputs_filtered (": ", stream);
	560	if (TYPE_FIELD_PACKED (type, i))
	561	{
	562	value_ptr v;
	563
	564	/* Bitfields require special handling, especially due to byte
c5aa993b	565	order problems. */
c906108c	566	v = value_from_longest (TYPE_FIELD_TYPE (type, i),
c5aa993b	567	unpack_field_as_long (type, valaddr, i));
c906108c SS	568
	569	chill_val_print (TYPE_FIELD_TYPE (type, i), VALUE_CONTENTS (v), 0, 0,
	570	stream, format, 0, recurse + 1, pretty);
	571	}
	572	else
	573	{
c5aa993b	574	chill_val_print (TYPE_FIELD_TYPE (type, i),
c906108c SS	575	valaddr + TYPE_FIELD_BITPOS (type, i) / 8, 0,
	576	0, stream, format, 0, recurse + 1, pretty);
	577	}
	578	}
	579	if (pretty)
	580	{
	581	fprintf_filtered (stream, "\n");
	582	print_spaces_filtered (2 * recurse, stream);
	583	}
	584	}
	585	fprintf_filtered (stream, "]");
	586	}
	587	\f
	588	int
	589	chill_value_print (val, stream, format, pretty)
	590	value_ptr val;
d9fcf2fb	591	struct ui_file *stream;
c906108c SS	592	int format;
	593	enum val_prettyprint pretty;
	594	{
	595	struct type *type = VALUE_TYPE (val);
c5aa993b	596	struct type *real_type = check_typedef (type);
c906108c SS	597
	598	/* If it is a pointer, indicate what it points to.
	599
	600	Print type also if it is a reference. */
	601
	602	if (TYPE_CODE (real_type) == TYPE_CODE_PTR \|\|
	603	TYPE_CODE (real_type) == TYPE_CODE_REF)
	604	{
	605	char *valaddr = VALUE_CONTENTS (val);
	606	CORE_ADDR addr = unpack_pointer (type, valaddr);
	607	if (TYPE_CODE (type) != TYPE_CODE_PTR \|\| addr != 0)
	608	{
	609	int i;
	610	char *name = TYPE_NAME (type);
	611	if (name)
	612	fputs_filtered (name, stream);
	613	else if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
	614	fputs_filtered ("PTR", stream);
	615	else
	616	{
	617	fprintf_filtered (stream, "(");
	618	type_print (type, "", stream, -1);
	619	fprintf_filtered (stream, ")");
	620	}
	621	fprintf_filtered (stream, "(");
	622	i = val_print (type, valaddr, 0, VALUE_ADDRESS (val),
	623	stream, format, 1, 0, pretty);
	624	fprintf_filtered (stream, ")");
	625	return i;
	626	}
	627	}
	628	return (val_print (type, VALUE_CONTENTS (val), 0,
	629	VALUE_ADDRESS (val), stream, format, 1, 0, pretty));
	630	}