[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, 2006,
                 2007, 2008, 2009, 2010 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);


/* Print function pointer with inferior address ADDRESS onto stdio
   stream STREAM.  */

static void
print_function_pointer_address (struct gdbarch *gdbarch, CORE_ADDR address,
				struct ui_file *stream, int addressprint)
{
  CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
							    &current_target);

  /* If the function pointer is represented by a description, print the
     address of the description.  */
  if (addressprint && func_addr != address)
    {
      fputs_filtered ("@", stream);
      fputs_filtered (paddress (gdbarch, address), stream);
      fputs_filtered (": ", stream);
    }
  print_address_demangle (gdbarch, func_addr, stream, demangle);
}

/* 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(val),
			   value_embedded_offset (val), addr, stream,
			   recurse, NULL, 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), 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, 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, "}");
	}
    }
}


/* Print data of type TYPE located at VALADDR (within GDB), which came from
   the inferior at address ADDRESS, onto stdio stream STREAM according to
   OPTIONS.  The data at VALADDR is in target byte order.

   If the data are a string pointer, returns the number of string characters
   printed.  */

int
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')
	print_scalar_formatted (valaddr + embedded_offset, type,
				options, 0, stream);
      else
	{
	  addr = unpack_pointer (type, valaddr + embedded_offset);
	  print_unpacked_pointer (type, addr, address, options, stream);
	}
      break;

    case TYPE_CODE_REF:
      elttype = check_typedef (TYPE_TARGET_TYPE (type));
      if (options->addressprint)
	{
	  CORE_ADDR addr
	    = extract_typed_address (valaddr + embedded_offset, type);

	  fprintf_filtered (stream, "@");
	  fputs_filtered (paddress (gdbarch, addr), stream);
	  if (options->deref_ref)
	    fputs_filtered (": ", stream);
	}
      /* De-reference the reference.  */
      if (options->deref_ref)
	{
	  if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
	    {
	      struct value *deref_val =
		value_at
		(TYPE_TARGET_TYPE (type),
		 unpack_pointer (type, valaddr + embedded_offset));

	      common_val_print (deref_val, stream, recurse, options,
				current_language);
	    }
	  else
	    fputs_filtered ("???", 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_ENUM:
      if (options->format)
	{
	  print_scalar_formatted (valaddr + embedded_offset, type,
				  options, 0, stream);
	  break;
	}
      len = TYPE_NFIELDS (type);
      val = unpack_long (type, valaddr + embedded_offset);
      for (i = 0; i < len; i++)
	{
	  QUIT;
	  if (val == TYPE_FIELD_BITPOS (type, i))
	    {
	      break;
	    }
	}
      if (i < len)
	{
	  fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
	}
      else
	{
	  print_longest (stream, 'd', 0, val);
	}
      break;

    case TYPE_CODE_FUNC:
      if (options->format)
	{
	  print_scalar_formatted (valaddr + embedded_offset, type,
				  options, 0, stream);
	  break;
	}
      /* FIXME, we should consider, at least for ANSI C language, eliminating
         the distinction made between FUNCs and POINTERs to FUNCs.  */
      fprintf_filtered (stream, "{");
      type_print (type, "", stream, -1);
      fprintf_filtered (stream, "} ");
      /* Try to print what function it points to, and its address.  */
      print_address_demangle (gdbarch, address, stream, demangle);
      break;

    case TYPE_CODE_BOOL:
      if (options->format || options->output_format)
	{
	  struct value_print_options opts = *options;

	  opts.format = (options->format ? options->format
			 : options->output_format);
	  print_scalar_formatted (valaddr + embedded_offset, type,
				  &opts, 0, stream);
	}
      else
	{
	  val = unpack_long (type, valaddr + embedded_offset);
	  if (val == 0)
	    fputs_filtered ("FALSE", stream);
	  else if (val == 1)
	    fputs_filtered ("TRUE", stream);
	  else
	    fprintf_filtered (stream, "%ld)", (long int) val);
	}
      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_INT:
      if (options->format || options->output_format)
	{
	  struct value_print_options opts = *options;

	  opts.format = (options->format ? options->format
			 : options->output_format);
	  print_scalar_formatted (valaddr + embedded_offset, type,
				  &opts, 0, stream);
	}
      else
	val_print_type_code_int (type, valaddr + embedded_offset, stream);
      break;

    case TYPE_CODE_CHAR:
      if (options->format || options->output_format)
	{
	  struct value_print_options opts = *options;

	  opts.format = (options->format ? options->format
			 : options->output_format);
	  print_scalar_formatted (valaddr + embedded_offset, type,
				  &opts, 0, stream);
	}
      else
	{
	  val = unpack_long (type, valaddr + embedded_offset);
	  if (TYPE_UNSIGNED (type))
	    fprintf_filtered (stream, "%u", (unsigned int) val);
	  else
	    fprintf_filtered (stream, "%d", (int) val);
	  fputs_filtered (" ", stream);
	  LA_PRINT_CHAR ((unsigned char) val, type, stream);
	}
      break;

    case TYPE_CODE_FLT:
      if (options->format)
	print_scalar_formatted (valaddr + embedded_offset, type,
				options, 0, stream);
      else
	print_floating (valaddr + embedded_offset, type, stream);
      break;

    case TYPE_CODE_METHOD:
      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_VOID:
      fprintf_filtered (stream, "void");
      break;

    case TYPE_CODE_ERROR:
      fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
      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;

    default:
      error (_("Invalid m2 type code %d in symbol table."), TYPE_CODE (type));
    }
  gdb_flush (stream);
  return (0);
}
Commit	Line	Data
c906108c	1	/* Support for printing Modula 2 values for GDB, the GNU debugger.
a8d6eb4a	2
6aba47ca	3	Copyright (C) 1986, 1988, 1989, 1991, 1992, 1996, 1998, 2000, 2005, 2006,
4c38e0a4	4	2007, 2008, 2009, 2010 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
	45
	46	/* Print function pointer with inferior address ADDRESS onto stdio
	47	stream STREAM. */
	48
	49	static void
50810684 UW	50	print_function_pointer_address (struct gdbarch *gdbarch, CORE_ADDR address,
50810684 UW	51	struct ui_file *stream, int addressprint)
72019c9c	52	{
50810684	53	CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (gdbarch, address,
72019c9c GM	54	&current_target);
	55
	56	/* If the function pointer is represented by a description, print the
	57	address of the description. */
	58	if (addressprint && func_addr != address)
	59	{
	60	fputs_filtered ("@", stream);
5af949e3	61	fputs_filtered (paddress (gdbarch, address), stream);
72019c9c GM	62	fputs_filtered (": ", stream);
72019c9c GM	63	}
5af949e3	64	print_address_demangle (gdbarch, func_addr, stream, demangle);
72019c9c GM	65	}
72019c9c GM	66
844781a1 GM	67	/* get_long_set_bounds - assigns the bounds of the long set to low and
844781a1 GM	68	high. */
72019c9c GM	69
	70	int
	71	get_long_set_bounds (struct type type, LONGEST low, LONGEST *high)
	72	{
	73	int len, i;
	74
	75	if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
	76	{
	77	len = TYPE_NFIELDS (type);
	78	i = TYPE_N_BASECLASSES (type);
	79	if (len == 0)
	80	return 0;
	81	*low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i)));
	82	*high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type,
	83	len-1)));
	84	return 1;
	85	}
	86	error (_("expecting long_set"));
	87	return 0;
	88	}
	89
	90	static void
	91	m2_print_long_set (struct type type, const gdb_byte valaddr,
	92	int embedded_offset, CORE_ADDR address,
79a45b7d	93	struct ui_file *stream)
72019c9c GM	94	{
	95	int empty_set = 1;
	96	int element_seen = 0;
	97	LONGEST previous_low = 0;
	98	LONGEST previous_high= 0;
	99	LONGEST i, low_bound, high_bound;
	100	LONGEST field_low, field_high;
	101	struct type *range;
	102	int len, field;
	103	struct type *target;
	104	int bitval;
	105
	106	CHECK_TYPEDEF (type);
	107
	108	fprintf_filtered (stream, "{");
	109	len = TYPE_NFIELDS (type);
	110	if (get_long_set_bounds (type, &low_bound, &high_bound))
	111	{
	112	field = TYPE_N_BASECLASSES (type);
	113	range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field));
	114	}
	115	else
	116	{
	117	fprintf_filtered (stream, " %s }", _("<unknown bounds of set>"));
	118	return;
	119	}
	120
	121	target = TYPE_TARGET_TYPE (range);
72019c9c GM	122
	123	if (get_discrete_bounds (range, &field_low, &field_high) >= 0)
	124	{
	125	for (i = low_bound; i <= high_bound; i++)
	126	{
	127	bitval = value_bit_index (TYPE_FIELD_TYPE (type, field),
	128	(TYPE_FIELD_BITPOS (type, field) / 8) +
	129	valaddr + embedded_offset, i);
	130	if (bitval < 0)
	131	error (_("bit test is out of range"));
	132	else if (bitval > 0)
	133	{
	134	previous_high = i;
	135	if (! element_seen)
	136	{
	137	if (! empty_set)
	138	fprintf_filtered (stream, ", ");
	139	print_type_scalar (target, i, stream);
	140	empty_set = 0;
	141	element_seen = 1;
	142	previous_low = i;
	143	}
	144	}
	145	else
	146	{
	147	/* bit is not set */
	148	if (element_seen)
	149	{
	150	if (previous_low+1 < previous_high)
	151	fprintf_filtered (stream, "..");
	152	if (previous_low+1 < previous_high)
	153	print_type_scalar (target, previous_high, stream);
	154	element_seen = 0;
	155	}
	156	}
	157	if (i == field_high)
	158	{
	159	field++;
	160	if (field == len)
	161	break;
	162	range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field));
	163	if (get_discrete_bounds (range, &field_low, &field_high) < 0)
	164	break;
	165	target = TYPE_TARGET_TYPE (range);
72019c9c GM	166	}
	167	}
	168	if (element_seen)
	169	{
	170	if (previous_low+1 < previous_high)
	171	{
	172	fprintf_filtered (stream, "..");
	173	print_type_scalar (target, previous_high, stream);
	174	}
	175	element_seen = 0;
	176	}
	177	fprintf_filtered (stream, "}");
	178	}
	179	}
	180
844781a1 GM	181	static void
	182	m2_print_unbounded_array (struct type type, const gdb_byte valaddr,
	183	int embedded_offset, CORE_ADDR address,
79a45b7d TT	184	struct ui_file *stream, int recurse,
79a45b7d TT	185	const struct value_print_options *options)
844781a1 GM	186	{
	187	struct type *content_type;
	188	CORE_ADDR addr;
	189	LONGEST len;
	190	struct value *val;
	191
	192	CHECK_TYPEDEF (type);
	193	content_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0));
	194
	195	addr = unpack_pointer (TYPE_FIELD_TYPE (type, 0),
	196	(TYPE_FIELD_BITPOS (type, 0) / 8) +
	197	valaddr + embedded_offset);
	198
	199	val = value_at_lazy (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0)),
	200	addr);
	201	len = unpack_field_as_long (type, valaddr + embedded_offset, 1);
	202
	203	fprintf_filtered (stream, "{");
	204	m2_print_array_contents (value_type (val), value_contents(val),
	205	value_embedded_offset (val), addr, stream,
0e03807e	206	recurse, NULL, options, len);
844781a1 GM	207	fprintf_filtered (stream, ", HIGH = %d}", (int) len);
	208	}
	209
79a45b7d	210	static int
72019c9c GM	211	print_unpacked_pointer (struct type *type,
72019c9c GM	212	CORE_ADDR address, CORE_ADDR addr,
79a45b7d TT	213	const struct value_print_options *options,
79a45b7d TT	214	struct ui_file *stream)
72019c9c	215	{
50810684	216	struct gdbarch *gdbarch = get_type_arch (type);
72019c9c GM	217	struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
	218
	219	if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
	220	{
	221	/* Try to print what function it points to. */
50810684 UW	222	print_function_pointer_address (gdbarch, addr, stream,
50810684 UW	223	options->addressprint);
72019c9c GM	224	/* Return value is irrelevant except for string pointers. */
	225	return 0;
	226	}
	227
79a45b7d	228	if (options->addressprint && options->format != 's')
5af949e3	229	fputs_filtered (paddress (gdbarch, address), stream);
72019c9c GM	230
	231	/* For a pointer to char or unsigned char, also print the string
	232	pointed to, unless pointer is null. */
	233
	234	if (TYPE_LENGTH (elttype) == 1
	235	&& TYPE_CODE (elttype) == TYPE_CODE_INT
79a45b7d	236	&& (options->format == 0 \|\| options->format == 's')
72019c9c	237	&& addr != 0)
6c7a06a3 TT	238	return val_print_string (TYPE_TARGET_TYPE (type), addr, -1,
6c7a06a3 TT	239	stream, options);
72019c9c GM	240
	241	return 0;
	242	}
	243
	244	static void
844781a1 GM	245	print_variable_at_address (struct type *type,
844781a1 GM	246	const gdb_byte *valaddr,
79a45b7d TT	247	struct ui_file *stream,
	248	int recurse,
	249	const struct value_print_options *options)
72019c9c	250	{
5af949e3	251	struct gdbarch *gdbarch = get_type_arch (type);
72019c9c GM	252	CORE_ADDR addr = unpack_pointer (type, valaddr);
	253	struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
	254
	255	fprintf_filtered (stream, "[");
5af949e3	256	fputs_filtered (paddress (gdbarch, addr), stream);
72019c9c GM	257	fprintf_filtered (stream, "] : ");
	258
	259	if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
	260	{
	261	struct value *deref_val =
d8631d21	262	value_at (TYPE_TARGET_TYPE (type), unpack_pointer (type, valaddr));
b8d56208	263
79a45b7d	264	common_val_print (deref_val, stream, recurse, options, current_language);
72019c9c GM	265	}
	266	else
	267	fputs_filtered ("???", stream);
	268	}
	269
844781a1 GM	270
	271	/* m2_print_array_contents - prints out the contents of an
	272	array up to a max_print values.
	273	It prints arrays of char as a string
	274	and all other data types as comma
	275	separated values. */
	276
	277	static void
	278	m2_print_array_contents (struct type type, const gdb_byte valaddr,
	279	int embedded_offset, CORE_ADDR address,
79a45b7d	280	struct ui_file *stream, int recurse,
0e03807e	281	const struct value *val,
79a45b7d TT	282	const struct value_print_options *options,
79a45b7d TT	283	int len)
844781a1 GM	284	{
	285	int eltlen;
	286	CHECK_TYPEDEF (type);
	287
	288	if (TYPE_LENGTH (type) > 0)
	289	{
	290	eltlen = TYPE_LENGTH (type);
79a45b7d	291	if (options->prettyprint_arrays)
844781a1 GM	292	print_spaces_filtered (2 + 2 * recurse, stream);
	293	/* For an array of chars, print with string syntax. */
	294	if (eltlen == 1 &&
	295	((TYPE_CODE (type) == TYPE_CODE_INT)
	296	\|\| ((current_language->la_language == language_m2)
	297	&& (TYPE_CODE (type) == TYPE_CODE_CHAR)))
79a45b7d	298	&& (options->format == 0 \|\| options->format == 's'))
6c7a06a3	299	val_print_string (type, address, len+1, stream, options);
844781a1 GM	300	else
	301	{
	302	fprintf_filtered (stream, "{");
	303	val_print_array_elements (type, valaddr + embedded_offset,
0e03807e TT	304	address, stream, recurse, val,
0e03807e TT	305	options, 0);
844781a1 GM	306	fprintf_filtered (stream, "}");
	307	}
	308	}
	309	}
	310
	311
72019c9c GM	312	/* Print data of type TYPE located at VALADDR (within GDB), which came from
72019c9c GM	313	the inferior at address ADDRESS, onto stdio stream STREAM according to
79a45b7d	314	OPTIONS. The data at VALADDR is in target byte order.
72019c9c GM	315
72019c9c GM	316	If the data are a string pointer, returns the number of string characters
79a45b7d	317	printed. */
c906108c SS	318
c906108c SS	319	int
fc1a4b47	320	m2_val_print (struct type type, const gdb_byte valaddr, int embedded_offset,
79a45b7d	321	CORE_ADDR address, struct ui_file *stream, int recurse,
0e03807e	322	const struct value *original_value,
79a45b7d	323	const struct value_print_options *options)
c906108c	324	{
5af949e3	325	struct gdbarch *gdbarch = get_type_arch (type);
72019c9c GM	326	unsigned int i = 0; /* Number of characters printed */
	327	unsigned len;
	328	struct type *elttype;
	329	unsigned eltlen;
72019c9c GM	330	LONGEST val;
	331	CORE_ADDR addr;
	332
	333	CHECK_TYPEDEF (type);
	334	switch (TYPE_CODE (type))
	335	{
	336	case TYPE_CODE_ARRAY:
	337	if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
	338	{
	339	elttype = check_typedef (TYPE_TARGET_TYPE (type));
	340	eltlen = TYPE_LENGTH (elttype);
	341	len = TYPE_LENGTH (type) / eltlen;
79a45b7d	342	if (options->prettyprint_arrays)
72019c9c GM	343	print_spaces_filtered (2 + 2 * recurse, stream);
	344	/* For an array of chars, print with string syntax. */
	345	if (eltlen == 1 &&
	346	((TYPE_CODE (elttype) == TYPE_CODE_INT)
	347	\|\| ((current_language->la_language == language_m2)
	348	&& (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
79a45b7d	349	&& (options->format == 0 \|\| options->format == 's'))
72019c9c GM	350	{
	351	/* If requested, look for the first null char and only print
	352	elements up to it. */
79a45b7d	353	if (options->stop_print_at_null)
72019c9c GM	354	{
	355	unsigned int temp_len;
	356
	357	/* Look for a NULL char. */
	358	for (temp_len = 0;
	359	(valaddr + embedded_offset)[temp_len]
79a45b7d	360	&& temp_len < len && temp_len < options->print_max;
72019c9c GM	361	temp_len++);
	362	len = temp_len;
	363	}
	364
6c7a06a3	365	LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type),
be759fcf PM	366	valaddr + embedded_offset, len, NULL,
be759fcf PM	367	0, options);
72019c9c GM	368	i = len;
	369	}
	370	else
	371	{
	372	fprintf_filtered (stream, "{");
	373	val_print_array_elements (type, valaddr + embedded_offset,
0e03807e TT	374	address, stream, recurse, original_value,
0e03807e TT	375	options, 0);
72019c9c GM	376	fprintf_filtered (stream, "}");
	377	}
	378	break;
	379	}
	380	/* Array of unspecified length: treat like pointer to first elt. */
79a45b7d	381	print_unpacked_pointer (type, address, address, options, stream);
72019c9c GM	382	break;
	383
	384	case TYPE_CODE_PTR:
	385	if (TYPE_CONST (type))
	386	print_variable_at_address (type, valaddr + embedded_offset,
79a45b7d TT	387	stream, recurse, options);
	388	else if (options->format && options->format != 's')
	389	print_scalar_formatted (valaddr + embedded_offset, type,
	390	options, 0, stream);
72019c9c GM	391	else
	392	{
	393	addr = unpack_pointer (type, valaddr + embedded_offset);
79a45b7d	394	print_unpacked_pointer (type, addr, address, options, stream);
72019c9c GM	395	}
	396	break;
	397
72019c9c GM	398	case TYPE_CODE_REF:
72019c9c GM	399	elttype = check_typedef (TYPE_TARGET_TYPE (type));
79a45b7d	400	if (options->addressprint)
72019c9c GM	401	{
	402	CORE_ADDR addr
	403	= extract_typed_address (valaddr + embedded_offset, type);
b8d56208	404
72019c9c	405	fprintf_filtered (stream, "@");
5af949e3	406	fputs_filtered (paddress (gdbarch, addr), stream);
79a45b7d	407	if (options->deref_ref)
72019c9c GM	408	fputs_filtered (": ", stream);
	409	}
	410	/* De-reference the reference. */
79a45b7d	411	if (options->deref_ref)
72019c9c GM	412	{
	413	if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
	414	{
	415	struct value *deref_val =
	416	value_at
	417	(TYPE_TARGET_TYPE (type),
d8631d21	418	unpack_pointer (type, valaddr + embedded_offset));
b8d56208	419
79a45b7d TT	420	common_val_print (deref_val, stream, recurse, options,
79a45b7d TT	421	current_language);
72019c9c GM	422	}
	423	else
	424	fputs_filtered ("???", stream);
	425	}
	426	break;
	427
	428	case TYPE_CODE_UNION:
79a45b7d	429	if (recurse && !options->unionprint)
72019c9c GM	430	{
	431	fprintf_filtered (stream, "{...}");
	432	break;
	433	}
	434	/* Fall through. */
	435	case TYPE_CODE_STRUCT:
	436	if (m2_is_long_set (type))
	437	m2_print_long_set (type, valaddr, embedded_offset, address,
79a45b7d	438	stream);
844781a1 GM	439	else if (m2_is_unbounded_array (type))
844781a1 GM	440	m2_print_unbounded_array (type, valaddr, embedded_offset,
79a45b7d	441	address, stream, recurse, options);
72019c9c GM	442	else
72019c9c GM	443	cp_print_value_fields (type, type, valaddr, embedded_offset,
0e03807e TT	444	address, stream, recurse, original_value,
0e03807e TT	445	options, NULL, 0);
72019c9c GM	446	break;
	447
	448	case TYPE_CODE_ENUM:
79a45b7d	449	if (options->format)
72019c9c GM	450	{
72019c9c GM	451	print_scalar_formatted (valaddr + embedded_offset, type,
79a45b7d	452	options, 0, stream);
72019c9c GM	453	break;
	454	}
	455	len = TYPE_NFIELDS (type);
	456	val = unpack_long (type, valaddr + embedded_offset);
	457	for (i = 0; i < len; i++)
	458	{
	459	QUIT;
	460	if (val == TYPE_FIELD_BITPOS (type, i))
	461	{
	462	break;
	463	}
	464	}
	465	if (i < len)
	466	{
	467	fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
	468	}
	469	else
	470	{
	471	print_longest (stream, 'd', 0, val);
	472	}
	473	break;
	474
	475	case TYPE_CODE_FUNC:
79a45b7d	476	if (options->format)
72019c9c GM	477	{
72019c9c GM	478	print_scalar_formatted (valaddr + embedded_offset, type,
79a45b7d	479	options, 0, stream);
72019c9c GM	480	break;
	481	}
	482	/* FIXME, we should consider, at least for ANSI C language, eliminating
	483	the distinction made between FUNCs and POINTERs to FUNCs. */
	484	fprintf_filtered (stream, "{");
	485	type_print (type, "", stream, -1);
	486	fprintf_filtered (stream, "} ");
	487	/* Try to print what function it points to, and its address. */
5af949e3	488	print_address_demangle (gdbarch, address, stream, demangle);
72019c9c GM	489	break;
	490
	491	case TYPE_CODE_BOOL:
79a45b7d TT	492	if (options->format \|\| options->output_format)
	493	{
	494	struct value_print_options opts = *options;
b8d56208	495
79a45b7d TT	496	opts.format = (options->format ? options->format
	497	: options->output_format);
	498	print_scalar_formatted (valaddr + embedded_offset, type,
	499	&opts, 0, stream);
	500	}
72019c9c GM	501	else
	502	{
	503	val = unpack_long (type, valaddr + embedded_offset);
	504	if (val == 0)
	505	fputs_filtered ("FALSE", stream);
	506	else if (val == 1)
	507	fputs_filtered ("TRUE", stream);
	508	else
	509	fprintf_filtered (stream, "%ld)", (long int) val);
	510	}
	511	break;
	512
	513	case TYPE_CODE_RANGE:
	514	if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
	515	{
	516	m2_val_print (TYPE_TARGET_TYPE (type), valaddr, embedded_offset,
0e03807e	517	address, stream, recurse, original_value, options);
72019c9c GM	518	break;
	519	}
	520	/* FIXME: create_range_type does not set the unsigned bit in a
	521	range type (I think it probably should copy it from the target
	522	type), so we won't print values which are too large to
	523	fit in a signed integer correctly. */
	524	/* FIXME: Doesn't handle ranges of enums correctly. (Can't just
	525	print with the target type, though, because the size of our type
	526	and the target type might differ). */
	527	/* FALLTHROUGH */
	528
	529	case TYPE_CODE_INT:
79a45b7d TT	530	if (options->format \|\| options->output_format)
	531	{
	532	struct value_print_options opts = *options;
b8d56208	533
79a45b7d TT	534	opts.format = (options->format ? options->format
	535	: options->output_format);
	536	print_scalar_formatted (valaddr + embedded_offset, type,
	537	&opts, 0, stream);
	538	}
72019c9c GM	539	else
	540	val_print_type_code_int (type, valaddr + embedded_offset, stream);
	541	break;
	542
	543	case TYPE_CODE_CHAR:
79a45b7d TT	544	if (options->format \|\| options->output_format)
	545	{
	546	struct value_print_options opts = *options;
b8d56208	547
79a45b7d TT	548	opts.format = (options->format ? options->format
	549	: options->output_format);
	550	print_scalar_formatted (valaddr + embedded_offset, type,
	551	&opts, 0, stream);
	552	}
72019c9c GM	553	else
	554	{
	555	val = unpack_long (type, valaddr + embedded_offset);
	556	if (TYPE_UNSIGNED (type))
	557	fprintf_filtered (stream, "%u", (unsigned int) val);
	558	else
	559	fprintf_filtered (stream, "%d", (int) val);
	560	fputs_filtered (" ", stream);
6c7a06a3	561	LA_PRINT_CHAR ((unsigned char) val, type, stream);
72019c9c GM	562	}
	563	break;
	564
	565	case TYPE_CODE_FLT:
79a45b7d	566	if (options->format)
72019c9c	567	print_scalar_formatted (valaddr + embedded_offset, type,
79a45b7d	568	options, 0, stream);
72019c9c GM	569	else
	570	print_floating (valaddr + embedded_offset, type, stream);
	571	break;
	572
	573	case TYPE_CODE_METHOD:
	574	break;
	575
	576	case TYPE_CODE_BITSTRING:
	577	case TYPE_CODE_SET:
	578	elttype = TYPE_INDEX_TYPE (type);
	579	CHECK_TYPEDEF (elttype);
	580	if (TYPE_STUB (elttype))
	581	{
	582	fprintf_filtered (stream, _("<incomplete type>"));
	583	gdb_flush (stream);
	584	break;
	585	}
	586	else
	587	{
	588	struct type *range = elttype;
	589	LONGEST low_bound, high_bound;
	590	int i;
	591	int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
	592	int need_comma = 0;
	593
	594	if (is_bitstring)
	595	fputs_filtered ("B'", stream);
	596	else
	597	fputs_filtered ("{", stream);
	598
	599	i = get_discrete_bounds (range, &low_bound, &high_bound);
	600	maybe_bad_bstring:
	601	if (i < 0)
	602	{
	603	fputs_filtered (_("<error value>"), stream);
	604	goto done;
	605	}
	606
	607	for (i = low_bound; i <= high_bound; i++)
	608	{
	609	int element = value_bit_index (type, valaddr + embedded_offset,
	610	i);
b8d56208	611
72019c9c GM	612	if (element < 0)
	613	{
	614	i = element;
	615	goto maybe_bad_bstring;
	616	}
	617	if (is_bitstring)
	618	fprintf_filtered (stream, "%d", element);
	619	else if (element)
	620	{
	621	if (need_comma)
	622	fputs_filtered (", ", stream);
	623	print_type_scalar (range, i, stream);
	624	need_comma = 1;
	625
	626	if (i + 1 <= high_bound
	627	&& value_bit_index (type, valaddr + embedded_offset,
	628	++i))
	629	{
	630	int j = i;
b8d56208	631
72019c9c GM	632	fputs_filtered ("..", stream);
	633	while (i + 1 <= high_bound
	634	&& value_bit_index (type,
	635	valaddr + embedded_offset,
	636	++i))
	637	j = i;
	638	print_type_scalar (range, j, stream);
	639	}
	640	}
	641	}
	642	done:
	643	if (is_bitstring)
	644	fputs_filtered ("'", stream);
	645	else
	646	fputs_filtered ("}", stream);
	647	}
	648	break;
	649
	650	case TYPE_CODE_VOID:
	651	fprintf_filtered (stream, "void");
	652	break;
	653
	654	case TYPE_CODE_ERROR:
b00fdb78	655	fprintf_filtered (stream, "%s", TYPE_ERROR_NAME (type));
72019c9c GM	656	break;
	657
	658	case TYPE_CODE_UNDEF:
	659	/* This happens (without TYPE_FLAG_STUB set) on systems which don't use
	660	dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
	661	and no complete type for struct foo in that file. */
	662	fprintf_filtered (stream, _("<incomplete type>"));
	663	break;
	664
	665	default:
	666	error (_("Invalid m2 type code %d in symbol table."), TYPE_CODE (type));
	667	}
	668	gdb_flush (stream);
	669	return (0);
c906108c	670	}