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

/* Support for printing Modula 2 values for GDB, the GNU debugger.

   Copyright (C) 1986, 1988-1989, 1991-1992, 1996, 1998, 2000, 2005-2012
   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 3 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, see <http://www.gnu.org/licenses/>.  */

#include "defs.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "expression.h"
#include "value.h"
#include "valprint.h"
#include "language.h"
#include "typeprint.h"
#include "c-lang.h"
#include "m2-lang.h"
#include "target.h"

static int print_unpacked_pointer (struct type *type,
				   CORE_ADDR address, CORE_ADDR addr,
				   const struct value_print_options *options,
				   struct ui_file *stream);
static void
m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
			 int embedded_offset, CORE_ADDR address,
			 struct ui_file *stream, int recurse,
			 const struct value *val,
			 const struct value_print_options *options,
			 int len);


/* get_long_set_bounds - assigns the bounds of the long set to low and
                         high.  */

int
get_long_set_bounds (struct type *type, LONGEST *low, LONGEST *high)
{
  int len, i;

  if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
    {
      len = TYPE_NFIELDS (type);
      i = TYPE_N_BASECLASSES (type);
      if (len == 0)
	return 0;
      *low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i)));
      *high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type,
								 len-1)));
      return 1;
    }
  error (_("expecting long_set"));
  return 0;
}

static void
m2_print_long_set (struct type *type, const gdb_byte *valaddr,
		   int embedded_offset, CORE_ADDR address,
		   struct ui_file *stream)
{
  int empty_set        = 1;
  int element_seen     = 0;
  LONGEST previous_low = 0;
  LONGEST previous_high= 0;
  LONGEST i, low_bound, high_bound;
  LONGEST field_low, field_high;
  struct type *range;
  int len, field;
  struct type *target;
  int bitval;

  CHECK_TYPEDEF (type);

  fprintf_filtered (stream, "{");
  len = TYPE_NFIELDS (type);
  if (get_long_set_bounds (type, &low_bound, &high_bound))
    {
      field = TYPE_N_BASECLASSES (type);
      range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field));
    }
  else
    {
      fprintf_filtered (stream, " %s }", _("<unknown bounds of set>"));
      return;
    }

  target = TYPE_TARGET_TYPE (range);

  if (get_discrete_bounds (range, &field_low, &field_high) >= 0)
    {
      for (i = low_bound; i <= high_bound; i++)
	{
	  bitval = value_bit_index (TYPE_FIELD_TYPE (type, field),
				    (TYPE_FIELD_BITPOS (type, field) / 8) +
				    valaddr + embedded_offset, i);
	  if (bitval < 0)
	    error (_("bit test is out of range"));
	  else if (bitval > 0)
	    {
	      previous_high = i;
	      if (! element_seen)
		{
		  if (! empty_set)
		    fprintf_filtered (stream, ", ");
		  print_type_scalar (target, i, stream);
		  empty_set    = 0;
		  element_seen = 1;
		  previous_low = i;
		}
	    }
	  else
	    {
	      /* bit is not set */
	      if (element_seen)
		{
		  if (previous_low+1 < previous_high)
		    fprintf_filtered (stream, "..");
		  if (previous_low+1 < previous_high)
		    print_type_scalar (target, previous_high, stream);
		  element_seen = 0;
		}
	    }
	  if (i == field_high)
	    {
	      field++;
	      if (field == len)
		break;
	      range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field));
	      if (get_discrete_bounds (range, &field_low, &field_high) < 0)
		break;
	      target = TYPE_TARGET_TYPE (range);
	    }
	}
      if (element_seen)
	{
	  if (previous_low+1 < previous_high)
	    {
	      fprintf_filtered (stream, "..");
	      print_type_scalar (target, previous_high, stream);
	    }
	  element_seen = 0;
	}
      fprintf_filtered (stream, "}");
    }
}

static void
m2_print_unbounded_array (struct type *type, const gdb_byte *valaddr,
			  int embedded_offset, CORE_ADDR address,
			  struct ui_file *stream, int recurse,
			  const struct value_print_options *options)
{
  struct type *content_type;
  CORE_ADDR addr;
  LONGEST len;
  struct value *val;

  CHECK_TYPEDEF (type);
  content_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0));

  addr = unpack_pointer (TYPE_FIELD_TYPE (type, 0),
			 (TYPE_FIELD_BITPOS (type, 0) / 8) +
			 valaddr + embedded_offset);

  val = value_at_lazy (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0)),
		       addr);
  len = unpack_field_as_long (type, valaddr + embedded_offset, 1);

  fprintf_filtered (stream, "{");  
  m2_print_array_contents (value_type (val),
			   value_contents_for_printing (val),
			   value_embedded_offset (val), addr, stream,
			   recurse, val, options, len);
  fprintf_filtered (stream, ", HIGH = %d}", (int) len);
}

static int
print_unpacked_pointer (struct type *type,
			CORE_ADDR address, CORE_ADDR addr,
			const struct value_print_options *options,
			struct ui_file *stream)
{
  struct gdbarch *gdbarch = get_type_arch (type);
  struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));

  if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
    {
      /* Try to print what function it points to.  */
      print_function_pointer_address (gdbarch, addr, stream,
				      options->addressprint);
      /* Return value is irrelevant except for string pointers.  */
      return 0;
    }

  if (options->addressprint && options->format != 's')
    fputs_filtered (paddress (gdbarch, address), 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_INT
      && (options->format == 0 || options->format == 's')
      && addr != 0)
    return val_print_string (TYPE_TARGET_TYPE (type), NULL, addr, -1,
			     stream, options);
  
  return 0;
}

static void
print_variable_at_address (struct type *type,
			   const gdb_byte *valaddr,
			   struct ui_file *stream,
			   int recurse,
			   const struct value_print_options *options)
{
  struct gdbarch *gdbarch = get_type_arch (type);
  CORE_ADDR addr = unpack_pointer (type, valaddr);
  struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));

  fprintf_filtered (stream, "[");
  fputs_filtered (paddress (gdbarch, addr), stream);
  fprintf_filtered (stream, "] : ");
  
  if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
    {
      struct value *deref_val =
	value_at (TYPE_TARGET_TYPE (type), unpack_pointer (type, valaddr));

      common_val_print (deref_val, stream, recurse, options, current_language);
    }
  else
    fputs_filtered ("???", stream);
}


/* m2_print_array_contents - prints out the contents of an
                             array up to a max_print values.
                             It prints arrays of char as a string
                             and all other data types as comma
                             separated values.  */

static void
m2_print_array_contents (struct type *type, const gdb_byte *valaddr,
			 int embedded_offset, CORE_ADDR address,
			 struct ui_file *stream, int recurse,
			 const struct value *val,
			 const struct value_print_options *options,
			 int len)
{
  int eltlen;
  CHECK_TYPEDEF (type);

  if (TYPE_LENGTH (type) > 0)
    {
      eltlen = TYPE_LENGTH (type);
      if (options->prettyprint_arrays)
	print_spaces_filtered (2 + 2 * recurse, stream);
      /* For an array of chars, print with string syntax.  */
      if (eltlen == 1 &&
	  ((TYPE_CODE (type) == TYPE_CODE_INT)
	   || ((current_language->la_language == language_m2)
	       && (TYPE_CODE (type) == TYPE_CODE_CHAR)))
	  && (options->format == 0 || options->format == 's'))
	val_print_string (type, NULL, address, len+1, stream, options);
      else
	{
	  fprintf_filtered (stream, "{");
	  val_print_array_elements (type, valaddr, embedded_offset,
				    address, stream, recurse, val,
				    options, 0);
	  fprintf_filtered (stream, "}");
	}
    }
}

/* Decorations for Modula 2.  */

static const struct generic_val_print_decorations m2_decorations =
{
  "",
  " + ",
  " * I",
  "TRUE",
  "FALSE",
  "void"
};

/* See val_print for a description of the various parameters of this
   function; they are identical.  */

void
m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
	      CORE_ADDR address, struct ui_file *stream, int recurse,
	      const struct value *original_value,
	      const struct value_print_options *options)
{
  struct gdbarch *gdbarch = get_type_arch (type);
  unsigned int i = 0;	/* Number of characters printed.  */
  unsigned len;
  struct type *elttype;
  unsigned eltlen;
  LONGEST val;
  CORE_ADDR addr;

  CHECK_TYPEDEF (type);
  switch (TYPE_CODE (type))
    {
    case TYPE_CODE_ARRAY:
      if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
	{
	  elttype = check_typedef (TYPE_TARGET_TYPE (type));
	  eltlen = TYPE_LENGTH (elttype);
	  len = TYPE_LENGTH (type) / eltlen;
	  if (options->prettyprint_arrays)
	    print_spaces_filtered (2 + 2 * recurse, stream);
	  /* For an array of chars, print with string syntax.  */
	  if (eltlen == 1 &&
	      ((TYPE_CODE (elttype) == TYPE_CODE_INT)
	       || ((current_language->la_language == language_m2)
		   && (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
	      && (options->format == 0 || options->format == 's'))
	    {
	      /* If requested, look for the first null char and only print
	         elements up to it.  */
	      if (options->stop_print_at_null)
		{
		  unsigned int temp_len;

		  /* Look for a NULL char.  */
		  for (temp_len = 0;
		       (valaddr + embedded_offset)[temp_len]
			 && temp_len < len && temp_len < options->print_max;
		       temp_len++);
		  len = temp_len;
		}

	      LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type),
			       valaddr + embedded_offset, len, NULL,
			       0, options);
	      i = len;
	    }
	  else
	    {
	      fprintf_filtered (stream, "{");
	      val_print_array_elements (type, valaddr, embedded_offset,
					address, stream,
					recurse, original_value,
					options, 0);
	      fprintf_filtered (stream, "}");
	    }
	  break;
	}
      /* Array of unspecified length: treat like pointer to first elt.  */
      print_unpacked_pointer (type, address, address, options, stream);
      break;

    case TYPE_CODE_PTR:
      if (TYPE_CONST (type))
	print_variable_at_address (type, valaddr + embedded_offset,
				   stream, recurse, options);
      else if (options->format && options->format != 's')
	val_print_scalar_formatted (type, valaddr, embedded_offset,
				    original_value, options, 0, stream);
      else
	{
	  addr = unpack_pointer (type, valaddr + embedded_offset);
	  print_unpacked_pointer (type, addr, address, options, stream);
	}
      break;

    case TYPE_CODE_UNION:
      if (recurse && !options->unionprint)
	{
	  fprintf_filtered (stream, "{...}");
	  break;
	}
      /* Fall through.  */
    case TYPE_CODE_STRUCT:
      if (m2_is_long_set (type))
	m2_print_long_set (type, valaddr, embedded_offset, address,
			   stream);
      else if (m2_is_unbounded_array (type))
	m2_print_unbounded_array (type, valaddr, embedded_offset,
				  address, stream, recurse, options);
      else
	cp_print_value_fields (type, type, valaddr, embedded_offset,
			       address, stream, recurse, original_value,
			       options, NULL, 0);
      break;

    case TYPE_CODE_BITSTRING:
    case TYPE_CODE_SET:
      elttype = TYPE_INDEX_TYPE (type);
      CHECK_TYPEDEF (elttype);
      if (TYPE_STUB (elttype))
	{
	  fprintf_filtered (stream, _("<incomplete type>"));
	  gdb_flush (stream);
	  break;
	}
      else
	{
	  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 + embedded_offset,
					     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);
		  print_type_scalar (range, i, stream);
		  need_comma = 1;

		  if (i + 1 <= high_bound
		      && value_bit_index (type, valaddr + embedded_offset,
					  ++i))
		    {
		      int j = i;

		      fputs_filtered ("..", stream);
		      while (i + 1 <= high_bound
			     && value_bit_index (type,
						 valaddr + embedded_offset,
						 ++i))
			j = i;
		      print_type_scalar (range, j, stream);
		    }
		}
	    }
	done:
	  if (is_bitstring)
	    fputs_filtered ("'", stream);
	  else
	    fputs_filtered ("}", stream);
	}
      break;

    case TYPE_CODE_RANGE:
      if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
	{
	  m2_val_print (TYPE_TARGET_TYPE (type), valaddr, embedded_offset,
			address, stream, recurse, original_value, options);
	  break;
	}
      /* FIXME: create_range_type does not set the unsigned bit in a
         range type (I think it probably should copy it from the target
         type), so we won't print values which are too large to
         fit in a signed integer correctly.  */
      /* FIXME: Doesn't handle ranges of enums correctly.  (Can't just
         print with the target type, though, because the size of our type
         and the target type might differ).  */
      /* FALLTHROUGH */

    case TYPE_CODE_REF:
    case TYPE_CODE_ENUM:
    case TYPE_CODE_FUNC:
    case TYPE_CODE_INT:
    case TYPE_CODE_FLT:
    case TYPE_CODE_METHOD:
    case TYPE_CODE_VOID:
    case TYPE_CODE_ERROR:
    case TYPE_CODE_UNDEF:
    case TYPE_CODE_BOOL:
    case TYPE_CODE_CHAR:
    default:
      generic_val_print (type, valaddr, embedded_offset, address,
			 stream, recurse, original_value, options,
			 &m2_decorations);
      break;
    }
  gdb_flush (stream);
}
Commit	Line	Data
	1	/* Support for printing Modula 2 values for GDB, the GNU debugger.
	2
	3	Copyright (C) 1986, 1988-1989, 1991-1992, 1996, 1998, 2000, 2005-2012
	4	Free Software Foundation, Inc.
	5
	6	This file is part of GDB.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 3 of the License, or
	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
	20
	21	#include "defs.h"
	22	#include "symtab.h"
	23	#include "gdbtypes.h"
	24	#include "expression.h"
	25	#include "value.h"
	26	#include "valprint.h"
	27	#include "language.h"
	28	#include "typeprint.h"
	29	#include "c-lang.h"
	30	#include "m2-lang.h"
	31	#include "target.h"
	32
	33	static int print_unpacked_pointer (struct type *type,
	34	CORE_ADDR address, CORE_ADDR addr,
	35	const struct value_print_options *options,
	36	struct ui_file *stream);
	37	static void
	38	m2_print_array_contents (struct type type, const gdb_byte valaddr,
	39	int embedded_offset, CORE_ADDR address,
	40	struct ui_file *stream, int recurse,
	41	const struct value *val,
	42	const struct value_print_options *options,
	43	int len);
	44
	45
	46	/* get_long_set_bounds - assigns the bounds of the long set to low and
	47	high. */
	48
	49	int
	50	get_long_set_bounds (struct type type, LONGEST low, LONGEST *high)
	51	{
	52	int len, i;
	53
	54	if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
	55	{
	56	len = TYPE_NFIELDS (type);
	57	i = TYPE_N_BASECLASSES (type);
	58	if (len == 0)
	59	return 0;
	60	*low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i)));
	61	*high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type,
	62	len-1)));
	63	return 1;
	64	}
	65	error (_("expecting long_set"));
	66	return 0;
	67	}
	68
	69	static void
	70	m2_print_long_set (struct type type, const gdb_byte valaddr,
	71	int embedded_offset, CORE_ADDR address,
	72	struct ui_file *stream)
	73	{
	74	int empty_set = 1;
	75	int element_seen = 0;
	76	LONGEST previous_low = 0;
	77	LONGEST previous_high= 0;
	78	LONGEST i, low_bound, high_bound;
	79	LONGEST field_low, field_high;
	80	struct type *range;
	81	int len, field;
	82	struct type *target;
	83	int bitval;
	84
	85	CHECK_TYPEDEF (type);
	86
	87	fprintf_filtered (stream, "{");
	88	len = TYPE_NFIELDS (type);
	89	if (get_long_set_bounds (type, &low_bound, &high_bound))
	90	{
	91	field = TYPE_N_BASECLASSES (type);
	92	range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field));
	93	}
	94	else
	95	{
	96	fprintf_filtered (stream, " %s }", _("<unknown bounds of set>"));
	97	return;
	98	}
	99
	100	target = TYPE_TARGET_TYPE (range);
	101
	102	if (get_discrete_bounds (range, &field_low, &field_high) >= 0)
	103	{
	104	for (i = low_bound; i <= high_bound; i++)
	105	{
	106	bitval = value_bit_index (TYPE_FIELD_TYPE (type, field),
	107	(TYPE_FIELD_BITPOS (type, field) / 8) +
	108	valaddr + embedded_offset, i);
	109	if (bitval < 0)
	110	error (_("bit test is out of range"));
	111	else if (bitval > 0)
	112	{
	113	previous_high = i;
	114	if (! element_seen)
	115	{
	116	if (! empty_set)
	117	fprintf_filtered (stream, ", ");
	118	print_type_scalar (target, i, stream);
	119	empty_set = 0;
	120	element_seen = 1;
	121	previous_low = i;
	122	}
	123	}
	124	else
	125	{
	126	/* bit is not set */
	127	if (element_seen)
	128	{
	129	if (previous_low+1 < previous_high)
	130	fprintf_filtered (stream, "..");
	131	if (previous_low+1 < previous_high)
	132	print_type_scalar (target, previous_high, stream);
	133	element_seen = 0;
	134	}
	135	}
	136	if (i == field_high)
	137	{
	138	field++;
	139	if (field == len)
	140	break;
	141	range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field));
	142	if (get_discrete_bounds (range, &field_low, &field_high) < 0)
	143	break;
	144	target = TYPE_TARGET_TYPE (range);
	145	}
	146	}
	147	if (element_seen)
	148	{
	149	if (previous_low+1 < previous_high)
	150	{
	151	fprintf_filtered (stream, "..");
	152	print_type_scalar (target, previous_high, stream);
	153	}
	154	element_seen = 0;
	155	}
	156	fprintf_filtered (stream, "}");
	157	}
	158	}
	159
	160	static void
	161	m2_print_unbounded_array (struct type type, const gdb_byte valaddr,
	162	int embedded_offset, CORE_ADDR address,
	163	struct ui_file *stream, int recurse,
	164	const struct value_print_options *options)
	165	{
	166	struct type *content_type;
	167	CORE_ADDR addr;
	168	LONGEST len;
	169	struct value *val;
	170
	171	CHECK_TYPEDEF (type);
	172	content_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0));
	173
	174	addr = unpack_pointer (TYPE_FIELD_TYPE (type, 0),
	175	(TYPE_FIELD_BITPOS (type, 0) / 8) +
	176	valaddr + embedded_offset);
	177
	178	val = value_at_lazy (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0)),
	179	addr);
	180	len = unpack_field_as_long (type, valaddr + embedded_offset, 1);
	181
	182	fprintf_filtered (stream, "{");
	183	m2_print_array_contents (value_type (val),
	184	value_contents_for_printing (val),
	185	value_embedded_offset (val), addr, stream,
	186	recurse, val, options, len);
	187	fprintf_filtered (stream, ", HIGH = %d}", (int) len);
	188	}
	189
	190	static int
	191	print_unpacked_pointer (struct type *type,
	192	CORE_ADDR address, CORE_ADDR addr,
	193	const struct value_print_options *options,
	194	struct ui_file *stream)
	195	{
	196	struct gdbarch *gdbarch = get_type_arch (type);
	197	struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
	198
	199	if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
	200	{
	201	/* Try to print what function it points to. */
	202	print_function_pointer_address (gdbarch, addr, stream,
	203	options->addressprint);
	204	/* Return value is irrelevant except for string pointers. */
	205	return 0;
	206	}
	207
	208	if (options->addressprint && options->format != 's')
	209	fputs_filtered (paddress (gdbarch, address), stream);
	210
	211	/* For a pointer to char or unsigned char, also print the string
	212	pointed to, unless pointer is null. */
	213
	214	if (TYPE_LENGTH (elttype) == 1
	215	&& TYPE_CODE (elttype) == TYPE_CODE_INT
	216	&& (options->format == 0 \|\| options->format == 's')
	217	&& addr != 0)
	218	return val_print_string (TYPE_TARGET_TYPE (type), NULL, addr, -1,
	219	stream, options);
	220
	221	return 0;
	222	}
	223
	224	static void
	225	print_variable_at_address (struct type *type,
	226	const gdb_byte *valaddr,
	227	struct ui_file *stream,
	228	int recurse,
	229	const struct value_print_options *options)
	230	{
	231	struct gdbarch *gdbarch = get_type_arch (type);
	232	CORE_ADDR addr = unpack_pointer (type, valaddr);
	233	struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
	234
	235	fprintf_filtered (stream, "[");
	236	fputs_filtered (paddress (gdbarch, addr), stream);
	237	fprintf_filtered (stream, "] : ");
	238
	239	if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
	240	{
	241	struct value *deref_val =
	242	value_at (TYPE_TARGET_TYPE (type), unpack_pointer (type, valaddr));
	243
	244	common_val_print (deref_val, stream, recurse, options, current_language);
	245	}
	246	else
	247	fputs_filtered ("???", stream);
	248	}
	249
	250
	251	/* m2_print_array_contents - prints out the contents of an
	252	array up to a max_print values.
	253	It prints arrays of char as a string
	254	and all other data types as comma
	255	separated values. */
	256
	257	static void
	258	m2_print_array_contents (struct type type, const gdb_byte valaddr,
	259	int embedded_offset, CORE_ADDR address,
	260	struct ui_file *stream, int recurse,
	261	const struct value *val,
	262	const struct value_print_options *options,
	263	int len)
	264	{
	265	int eltlen;
	266	CHECK_TYPEDEF (type);
	267
	268	if (TYPE_LENGTH (type) > 0)
	269	{
	270	eltlen = TYPE_LENGTH (type);
	271	if (options->prettyprint_arrays)
	272	print_spaces_filtered (2 + 2 * recurse, stream);
	273	/* For an array of chars, print with string syntax. */
	274	if (eltlen == 1 &&
	275	((TYPE_CODE (type) == TYPE_CODE_INT)
	276	\|\| ((current_language->la_language == language_m2)
	277	&& (TYPE_CODE (type) == TYPE_CODE_CHAR)))
	278	&& (options->format == 0 \|\| options->format == 's'))
	279	val_print_string (type, NULL, address, len+1, stream, options);
	280	else
	281	{
	282	fprintf_filtered (stream, "{");
	283	val_print_array_elements (type, valaddr, embedded_offset,
	284	address, stream, recurse, val,
	285	options, 0);
	286	fprintf_filtered (stream, "}");
	287	}
	288	}
	289	}
	290
	291	/* Decorations for Modula 2. */
	292
	293	static const struct generic_val_print_decorations m2_decorations =
	294	{
	295	"",
	296	" + ",
	297	" * I",
	298	"TRUE",
	299	"FALSE",
	300	"void"
	301	};
	302
	303	/* See val_print for a description of the various parameters of this
	304	function; they are identical. */
	305
	306	void
	307	m2_val_print (struct type type, const gdb_byte valaddr, int embedded_offset,
	308	CORE_ADDR address, struct ui_file *stream, int recurse,
	309	const struct value *original_value,
	310	const struct value_print_options *options)
	311	{
	312	struct gdbarch *gdbarch = get_type_arch (type);
	313	unsigned int i = 0; /* Number of characters printed. */
	314	unsigned len;
	315	struct type *elttype;
	316	unsigned eltlen;
	317	LONGEST val;
	318	CORE_ADDR addr;
	319
	320	CHECK_TYPEDEF (type);
	321	switch (TYPE_CODE (type))
	322	{
	323	case TYPE_CODE_ARRAY:
	324	if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
	325	{
	326	elttype = check_typedef (TYPE_TARGET_TYPE (type));
	327	eltlen = TYPE_LENGTH (elttype);
	328	len = TYPE_LENGTH (type) / eltlen;
	329	if (options->prettyprint_arrays)
	330	print_spaces_filtered (2 + 2 * recurse, stream);
	331	/* For an array of chars, print with string syntax. */
	332	if (eltlen == 1 &&
	333	((TYPE_CODE (elttype) == TYPE_CODE_INT)
	334	\|\| ((current_language->la_language == language_m2)
	335	&& (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
	336	&& (options->format == 0 \|\| options->format == 's'))
	337	{
	338	/* If requested, look for the first null char and only print
	339	elements up to it. */
	340	if (options->stop_print_at_null)
	341	{
	342	unsigned int temp_len;
	343
	344	/* Look for a NULL char. */
	345	for (temp_len = 0;
	346	(valaddr + embedded_offset)[temp_len]
	347	&& temp_len < len && temp_len < options->print_max;
	348	temp_len++);
	349	len = temp_len;
	350	}
	351
	352	LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type),
	353	valaddr + embedded_offset, len, NULL,
	354	0, options);
	355	i = len;
	356	}
	357	else
	358	{
	359	fprintf_filtered (stream, "{");
	360	val_print_array_elements (type, valaddr, embedded_offset,
	361	address, stream,
	362	recurse, original_value,
	363	options, 0);
	364	fprintf_filtered (stream, "}");
	365	}
	366	break;
	367	}
	368	/* Array of unspecified length: treat like pointer to first elt. */
	369	print_unpacked_pointer (type, address, address, options, stream);
	370	break;
	371
	372	case TYPE_CODE_PTR:
	373	if (TYPE_CONST (type))
	374	print_variable_at_address (type, valaddr + embedded_offset,
	375	stream, recurse, options);
	376	else if (options->format && options->format != 's')
	377	val_print_scalar_formatted (type, valaddr, embedded_offset,
	378	original_value, options, 0, stream);
	379	else
	380	{
	381	addr = unpack_pointer (type, valaddr + embedded_offset);
	382	print_unpacked_pointer (type, addr, address, options, stream);
	383	}
	384	break;
	385
	386	case TYPE_CODE_UNION:
	387	if (recurse && !options->unionprint)
	388	{
	389	fprintf_filtered (stream, "{...}");
	390	break;
	391	}
	392	/* Fall through. */
	393	case TYPE_CODE_STRUCT:
	394	if (m2_is_long_set (type))
	395	m2_print_long_set (type, valaddr, embedded_offset, address,
	396	stream);
	397	else if (m2_is_unbounded_array (type))
	398	m2_print_unbounded_array (type, valaddr, embedded_offset,
	399	address, stream, recurse, options);
	400	else
	401	cp_print_value_fields (type, type, valaddr, embedded_offset,
	402	address, stream, recurse, original_value,
	403	options, NULL, 0);
	404	break;
	405
	406	case TYPE_CODE_BITSTRING:
	407	case TYPE_CODE_SET:
	408	elttype = TYPE_INDEX_TYPE (type);
	409	CHECK_TYPEDEF (elttype);
	410	if (TYPE_STUB (elttype))
	411	{
	412	fprintf_filtered (stream, _("<incomplete type>"));
	413	gdb_flush (stream);
	414	break;
	415	}
	416	else
	417	{
	418	struct type *range = elttype;
	419	LONGEST low_bound, high_bound;
	420	int i;
	421	int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
	422	int need_comma = 0;
	423
	424	if (is_bitstring)
	425	fputs_filtered ("B'", stream);
	426	else
	427	fputs_filtered ("{", stream);
	428
	429	i = get_discrete_bounds (range, &low_bound, &high_bound);
	430	maybe_bad_bstring:
	431	if (i < 0)
	432	{
	433	fputs_filtered (_("<error value>"), stream);
	434	goto done;
	435	}
	436
	437	for (i = low_bound; i <= high_bound; i++)
	438	{
	439	int element = value_bit_index (type, valaddr + embedded_offset,
	440	i);
	441
	442	if (element < 0)
	443	{
	444	i = element;
	445	goto maybe_bad_bstring;
	446	}
	447	if (is_bitstring)
	448	fprintf_filtered (stream, "%d", element);
	449	else if (element)
	450	{
	451	if (need_comma)
	452	fputs_filtered (", ", stream);
	453	print_type_scalar (range, i, stream);
	454	need_comma = 1;
	455
	456	if (i + 1 <= high_bound
	457	&& value_bit_index (type, valaddr + embedded_offset,
	458	++i))
	459	{
	460	int j = i;
	461
	462	fputs_filtered ("..", stream);
	463	while (i + 1 <= high_bound
	464	&& value_bit_index (type,
	465	valaddr + embedded_offset,
	466	++i))
	467	j = i;
	468	print_type_scalar (range, j, stream);
	469	}
	470	}
	471	}
	472	done:
	473	if (is_bitstring)
	474	fputs_filtered ("'", stream);
	475	else
	476	fputs_filtered ("}", stream);
	477	}
	478	break;
	479
	480	case TYPE_CODE_RANGE:
	481	if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
	482	{
	483	m2_val_print (TYPE_TARGET_TYPE (type), valaddr, embedded_offset,
	484	address, stream, recurse, original_value, options);
	485	break;
	486	}
	487	/* FIXME: create_range_type does not set the unsigned bit in a
	488	range type (I think it probably should copy it from the target
	489	type), so we won't print values which are too large to
	490	fit in a signed integer correctly. */
	491	/* FIXME: Doesn't handle ranges of enums correctly. (Can't just
	492	print with the target type, though, because the size of our type
	493	and the target type might differ). */
	494	/* FALLTHROUGH */
	495
	496	case TYPE_CODE_REF:
	497	case TYPE_CODE_ENUM:
	498	case TYPE_CODE_FUNC:
	499	case TYPE_CODE_INT:
	500	case TYPE_CODE_FLT:
	501	case TYPE_CODE_METHOD:
	502	case TYPE_CODE_VOID:
	503	case TYPE_CODE_ERROR:
	504	case TYPE_CODE_UNDEF:
	505	case TYPE_CODE_BOOL:
	506	case TYPE_CODE_CHAR:
	507	default:
	508	generic_val_print (type, valaddr, embedded_offset, address,
	509	stream, recurse, original_value, options,
	510	&m2_decorations);
	511	break;
	512	}
	513	gdb_flush (stream);
	514	}