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