[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 (options, gdbarch, addr, stream);
      /* 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
c906108c	1	/* Support for printing Modula 2 values for GDB, the GNU debugger.
a8d6eb4a	2
0b302171 JB	3	Copyright (C) 1986, 1988-1989, 1991-1992, 1996, 1998, 2000, 2005-2012
0b302171 JB	4	Free Software Foundation, Inc.
c906108c	5
c5aa993b	6	This file is part of GDB.
c906108c	7
c5aa993b JM	8	This program is free software; you can redistribute it and/or modify
c5aa993b JM	9	it under the terms of the GNU General Public License as published by
a9762ec7	10	the Free Software Foundation; either version 3 of the License, or
c5aa993b	11	(at your option) any later version.
c906108c	12
c5aa993b JM	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.
c906108c	17
c5aa993b	18	You should have received a copy of the GNU General Public License
a9762ec7	19	along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c SS	20
c906108c SS	21	#include "defs.h"
c906108c SS	22	#include "symtab.h"
c906108c SS	23	#include "gdbtypes.h"
72019c9c GM	24	#include "expression.h"
	25	#include "value.h"
	26	#include "valprint.h"
	27	#include "language.h"
	28	#include "typeprint.h"
a8d6eb4a	29	#include "c-lang.h"
72019c9c GM	30	#include "m2-lang.h"
	31	#include "target.h"
	32
79a45b7d TT	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);
844781a1 GM	37	static void
	38	m2_print_array_contents (struct type type, const gdb_byte valaddr,
	39	int embedded_offset, CORE_ADDR address,
79a45b7d	40	struct ui_file *stream, int recurse,
0e03807e	41	const struct value *val,
79a45b7d TT	42	const struct value_print_options *options,
79a45b7d TT	43	int len);
72019c9c GM	44
72019c9c GM	45
844781a1 GM	46	/* get_long_set_bounds - assigns the bounds of the long set to low and
844781a1 GM	47	high. */
72019c9c GM	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,
79a45b7d	72	struct ui_file *stream)
72019c9c GM	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);
72019c9c GM	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);
72019c9c GM	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
844781a1 GM	160	static void
	161	m2_print_unbounded_array (struct type type, const gdb_byte valaddr,
	162	int embedded_offset, CORE_ADDR address,
79a45b7d TT	163	struct ui_file *stream, int recurse,
79a45b7d TT	164	const struct value_print_options *options)
844781a1 GM	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, "{");
66d61a4c PA	183	m2_print_array_contents (value_type (val),
66d61a4c PA	184	value_contents_for_printing (val),
844781a1	185	value_embedded_offset (val), addr, stream,
66d61a4c	186	recurse, val, options, len);
844781a1 GM	187	fprintf_filtered (stream, ", HIGH = %d}", (int) len);
	188	}
	189
79a45b7d	190	static int
72019c9c GM	191	print_unpacked_pointer (struct type *type,
72019c9c GM	192	CORE_ADDR address, CORE_ADDR addr,
79a45b7d TT	193	const struct value_print_options *options,
79a45b7d TT	194	struct ui_file *stream)
72019c9c	195	{
50810684	196	struct gdbarch *gdbarch = get_type_arch (type);
72019c9c GM	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. */
edf0c1b7	202	print_function_pointer_address (options, gdbarch, addr, stream);
72019c9c GM	203	/* Return value is irrelevant except for string pointers. */
	204	return 0;
	205	}
	206
79a45b7d	207	if (options->addressprint && options->format != 's')
5af949e3	208	fputs_filtered (paddress (gdbarch, address), stream);
72019c9c GM	209
	210	/* For a pointer to char or unsigned char, also print the string
	211	pointed to, unless pointer is null. */
	212
	213	if (TYPE_LENGTH (elttype) == 1
	214	&& TYPE_CODE (elttype) == TYPE_CODE_INT
79a45b7d	215	&& (options->format == 0 \|\| options->format == 's')
72019c9c	216	&& addr != 0)
09ca9e2e	217	return val_print_string (TYPE_TARGET_TYPE (type), NULL, addr, -1,
6c7a06a3	218	stream, options);
72019c9c GM	219
	220	return 0;
	221	}
	222
	223	static void
844781a1 GM	224	print_variable_at_address (struct type *type,
844781a1 GM	225	const gdb_byte *valaddr,
79a45b7d TT	226	struct ui_file *stream,
	227	int recurse,
	228	const struct value_print_options *options)
72019c9c	229	{
5af949e3	230	struct gdbarch *gdbarch = get_type_arch (type);
72019c9c GM	231	CORE_ADDR addr = unpack_pointer (type, valaddr);
	232	struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
	233
	234	fprintf_filtered (stream, "[");
5af949e3	235	fputs_filtered (paddress (gdbarch, addr), stream);
72019c9c GM	236	fprintf_filtered (stream, "] : ");
	237
	238	if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
	239	{
	240	struct value *deref_val =
d8631d21	241	value_at (TYPE_TARGET_TYPE (type), unpack_pointer (type, valaddr));
b8d56208	242
79a45b7d	243	common_val_print (deref_val, stream, recurse, options, current_language);
72019c9c GM	244	}
	245	else
	246	fputs_filtered ("???", stream);
	247	}
	248
844781a1 GM	249
	250	/* m2_print_array_contents - prints out the contents of an
	251	array up to a max_print values.
	252	It prints arrays of char as a string
	253	and all other data types as comma
	254	separated values. */
	255
	256	static void
	257	m2_print_array_contents (struct type type, const gdb_byte valaddr,
	258	int embedded_offset, CORE_ADDR address,
79a45b7d	259	struct ui_file *stream, int recurse,
0e03807e	260	const struct value *val,
79a45b7d TT	261	const struct value_print_options *options,
79a45b7d TT	262	int len)
844781a1 GM	263	{
	264	int eltlen;
	265	CHECK_TYPEDEF (type);
	266
	267	if (TYPE_LENGTH (type) > 0)
	268	{
	269	eltlen = TYPE_LENGTH (type);
79a45b7d	270	if (options->prettyprint_arrays)
844781a1 GM	271	print_spaces_filtered (2 + 2 * recurse, stream);
	272	/* For an array of chars, print with string syntax. */
	273	if (eltlen == 1 &&
	274	((TYPE_CODE (type) == TYPE_CODE_INT)
	275	\|\| ((current_language->la_language == language_m2)
	276	&& (TYPE_CODE (type) == TYPE_CODE_CHAR)))
79a45b7d	277	&& (options->format == 0 \|\| options->format == 's'))
09ca9e2e	278	val_print_string (type, NULL, address, len+1, stream, options);
844781a1 GM	279	else
	280	{
	281	fprintf_filtered (stream, "{");
490f124f	282	val_print_array_elements (type, valaddr, embedded_offset,
0e03807e TT	283	address, stream, recurse, val,
0e03807e TT	284	options, 0);
844781a1 GM	285	fprintf_filtered (stream, "}");
	286	}
	287	}
	288	}
	289
e88acd96 TT	290	/* Decorations for Modula 2. */
	291
	292	static const struct generic_val_print_decorations m2_decorations =
	293	{
	294	"",
	295	" + ",
	296	" * I",
	297	"TRUE",
	298	"FALSE",
	299	"void"
	300	};
844781a1	301
32b72a42	302	/* See val_print for a description of the various parameters of this
d3eab38a	303	function; they are identical. */
c906108c	304
d3eab38a	305	void
fc1a4b47	306	m2_val_print (struct type type, const gdb_byte valaddr, int embedded_offset,
79a45b7d	307	CORE_ADDR address, struct ui_file *stream, int recurse,
0e03807e	308	const struct value *original_value,
79a45b7d	309	const struct value_print_options *options)
c906108c	310	{
5af949e3	311	struct gdbarch *gdbarch = get_type_arch (type);
025bb325	312	unsigned int i = 0; /* Number of characters printed. */
72019c9c GM	313	unsigned len;
	314	struct type *elttype;
	315	unsigned eltlen;
72019c9c GM	316	LONGEST val;
	317	CORE_ADDR addr;
	318
	319	CHECK_TYPEDEF (type);
	320	switch (TYPE_CODE (type))
	321	{
	322	case TYPE_CODE_ARRAY:
	323	if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
	324	{
	325	elttype = check_typedef (TYPE_TARGET_TYPE (type));
	326	eltlen = TYPE_LENGTH (elttype);
	327	len = TYPE_LENGTH (type) / eltlen;
79a45b7d	328	if (options->prettyprint_arrays)
72019c9c GM	329	print_spaces_filtered (2 + 2 * recurse, stream);
	330	/* For an array of chars, print with string syntax. */
	331	if (eltlen == 1 &&
	332	((TYPE_CODE (elttype) == TYPE_CODE_INT)
	333	\|\| ((current_language->la_language == language_m2)
	334	&& (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
79a45b7d	335	&& (options->format == 0 \|\| options->format == 's'))
72019c9c GM	336	{
	337	/* If requested, look for the first null char and only print
	338	elements up to it. */
79a45b7d	339	if (options->stop_print_at_null)
72019c9c GM	340	{
	341	unsigned int temp_len;
	342
025bb325	343	/* Look for a NULL char. */
72019c9c GM	344	for (temp_len = 0;
72019c9c GM	345	(valaddr + embedded_offset)[temp_len]
79a45b7d	346	&& temp_len < len && temp_len < options->print_max;
72019c9c GM	347	temp_len++);
	348	len = temp_len;
	349	}
	350
6c7a06a3	351	LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type),
be759fcf PM	352	valaddr + embedded_offset, len, NULL,
be759fcf PM	353	0, options);
72019c9c GM	354	i = len;
	355	}
	356	else
	357	{
	358	fprintf_filtered (stream, "{");
490f124f	359	val_print_array_elements (type, valaddr, embedded_offset,
025bb325 MS	360	address, stream,
025bb325 MS	361	recurse, original_value,
0e03807e	362	options, 0);
72019c9c GM	363	fprintf_filtered (stream, "}");
	364	}
	365	break;
	366	}
	367	/* Array of unspecified length: treat like pointer to first elt. */
79a45b7d	368	print_unpacked_pointer (type, address, address, options, stream);
72019c9c GM	369	break;
	370
	371	case TYPE_CODE_PTR:
	372	if (TYPE_CONST (type))
	373	print_variable_at_address (type, valaddr + embedded_offset,
79a45b7d TT	374	stream, recurse, options);
79a45b7d TT	375	else if (options->format && options->format != 's')
ab2188aa PA	376	val_print_scalar_formatted (type, valaddr, embedded_offset,
ab2188aa PA	377	original_value, options, 0, stream);
72019c9c GM	378	else
	379	{
	380	addr = unpack_pointer (type, valaddr + embedded_offset);
79a45b7d	381	print_unpacked_pointer (type, addr, address, options, stream);
72019c9c GM	382	}
	383	break;
	384
72019c9c	385	case TYPE_CODE_UNION:
79a45b7d	386	if (recurse && !options->unionprint)
72019c9c GM	387	{
	388	fprintf_filtered (stream, "{...}");
	389	break;
	390	}
	391	/* Fall through. */
	392	case TYPE_CODE_STRUCT:
	393	if (m2_is_long_set (type))
	394	m2_print_long_set (type, valaddr, embedded_offset, address,
79a45b7d	395	stream);
844781a1 GM	396	else if (m2_is_unbounded_array (type))
844781a1 GM	397	m2_print_unbounded_array (type, valaddr, embedded_offset,
79a45b7d	398	address, stream, recurse, options);
72019c9c GM	399	else
72019c9c GM	400	cp_print_value_fields (type, type, valaddr, embedded_offset,
0e03807e TT	401	address, stream, recurse, original_value,
0e03807e TT	402	options, NULL, 0);
72019c9c GM	403	break;
72019c9c GM	404
72019c9c GM	405	case TYPE_CODE_BITSTRING:
	406	case TYPE_CODE_SET:
	407	elttype = TYPE_INDEX_TYPE (type);
	408	CHECK_TYPEDEF (elttype);
	409	if (TYPE_STUB (elttype))
	410	{
	411	fprintf_filtered (stream, _("<incomplete type>"));
	412	gdb_flush (stream);
	413	break;
	414	}
	415	else
	416	{
	417	struct type *range = elttype;
	418	LONGEST low_bound, high_bound;
	419	int i;
	420	int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
	421	int need_comma = 0;
	422
	423	if (is_bitstring)
	424	fputs_filtered ("B'", stream);
	425	else
	426	fputs_filtered ("{", stream);
	427
	428	i = get_discrete_bounds (range, &low_bound, &high_bound);
	429	maybe_bad_bstring:
	430	if (i < 0)
	431	{
	432	fputs_filtered (_("<error value>"), stream);
	433	goto done;
	434	}
	435
	436	for (i = low_bound; i <= high_bound; i++)
	437	{
	438	int element = value_bit_index (type, valaddr + embedded_offset,
	439	i);
b8d56208	440
72019c9c GM	441	if (element < 0)
	442	{
	443	i = element;
	444	goto maybe_bad_bstring;
	445	}
	446	if (is_bitstring)
	447	fprintf_filtered (stream, "%d", element);
	448	else if (element)
	449	{
	450	if (need_comma)
	451	fputs_filtered (", ", stream);
	452	print_type_scalar (range, i, stream);
	453	need_comma = 1;
	454
	455	if (i + 1 <= high_bound
	456	&& value_bit_index (type, valaddr + embedded_offset,
	457	++i))
	458	{
	459	int j = i;
b8d56208	460
72019c9c GM	461	fputs_filtered ("..", stream);
	462	while (i + 1 <= high_bound
	463	&& value_bit_index (type,
	464	valaddr + embedded_offset,
	465	++i))
	466	j = i;
	467	print_type_scalar (range, j, stream);
	468	}
	469	}
	470	}
	471	done:
	472	if (is_bitstring)
	473	fputs_filtered ("'", stream);
	474	else
	475	fputs_filtered ("}", stream);
	476	}
	477	break;
	478
e88acd96 TT	479	case TYPE_CODE_RANGE:
	480	if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
	481	{
	482	m2_val_print (TYPE_TARGET_TYPE (type), valaddr, embedded_offset,
	483	address, stream, recurse, original_value, options);
	484	break;
	485	}
	486	/* FIXME: create_range_type does not set the unsigned bit in a
	487	range type (I think it probably should copy it from the target
	488	type), so we won't print values which are too large to
	489	fit in a signed integer correctly. */
	490	/* FIXME: Doesn't handle ranges of enums correctly. (Can't just
	491	print with the target type, though, because the size of our type
	492	and the target type might differ). */
	493	/* FALLTHROUGH */
72019c9c	494
e88acd96 TT	495	case TYPE_CODE_REF:
	496	case TYPE_CODE_ENUM:
	497	case TYPE_CODE_FUNC:
	498	case TYPE_CODE_INT:
	499	case TYPE_CODE_FLT:
	500	case TYPE_CODE_METHOD:
	501	case TYPE_CODE_VOID:
72019c9c	502	case TYPE_CODE_ERROR:
72019c9c	503	case TYPE_CODE_UNDEF:
e88acd96 TT	504	case TYPE_CODE_BOOL:
e88acd96 TT	505	case TYPE_CODE_CHAR:
72019c9c	506	default:
e88acd96 TT	507	generic_val_print (type, valaddr, embedded_offset, address,
	508	stream, recurse, original_value, options,
	509	&m2_decorations);
	510	break;
72019c9c GM	511	}
72019c9c GM	512	gdb_flush (stream);
c906108c	513	}