[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 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 (CORE_ADDR address, struct ui_file *stream,
				int addressprint)
{
  CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (current_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 (address), stream);
      fputs_filtered (": ", stream);
    }
  print_address_demangle (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 (target == NULL)
    target = builtin_type_int32;

  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 (target == NULL)
		target = builtin_type_int32;
	    }
	}
      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 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 (addr, stream, options->addressprint);
      /* Return value is irrelevant except for string pointers.  */
      return 0;
    }

  if (options->addressprint && options->format != 's')
    fputs_filtered (paddress (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)
{
  CORE_ADDR addr = unpack_pointer (type, valaddr);
  struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));

  fprintf_filtered (stream, "[");
  fputs_filtered (paddress (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)
{
  unsigned int i = 0;	/* Number of characters printed */
  unsigned len;
  struct type *elttype;
  unsigned eltlen;
  int length_pos, length_size, string_pos;
  int char_size;
  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, 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 (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 (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,
0fb0cc75	4	2007, 2008, 2009 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
79a45b7d TT	49	print_function_pointer_address (CORE_ADDR address, struct ui_file *stream,
79a45b7d TT	50	int addressprint)
72019c9c GM	51	{
	52	CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
	53	address,
	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);
	61	fputs_filtered (paddress (address), stream);
	62	fputs_filtered (": ", stream);
	63	}
	64	print_address_demangle (func_addr, stream, demangle);
	65	}
	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);
	122	if (target == NULL)
6d84d3d8	123	target = builtin_type_int32;
72019c9c GM	124
	125	if (get_discrete_bounds (range, &field_low, &field_high) >= 0)
	126	{
	127	for (i = low_bound; i <= high_bound; i++)
	128	{
	129	bitval = value_bit_index (TYPE_FIELD_TYPE (type, field),
	130	(TYPE_FIELD_BITPOS (type, field) / 8) +
	131	valaddr + embedded_offset, i);
	132	if (bitval < 0)
	133	error (_("bit test is out of range"));
	134	else if (bitval > 0)
	135	{
	136	previous_high = i;
	137	if (! element_seen)
	138	{
	139	if (! empty_set)
	140	fprintf_filtered (stream, ", ");
	141	print_type_scalar (target, i, stream);
	142	empty_set = 0;
	143	element_seen = 1;
	144	previous_low = i;
	145	}
	146	}
	147	else
	148	{
	149	/* bit is not set */
	150	if (element_seen)
	151	{
	152	if (previous_low+1 < previous_high)
	153	fprintf_filtered (stream, "..");
	154	if (previous_low+1 < previous_high)
	155	print_type_scalar (target, previous_high, stream);
	156	element_seen = 0;
	157	}
	158	}
	159	if (i == field_high)
	160	{
	161	field++;
	162	if (field == len)
	163	break;
	164	range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field));
	165	if (get_discrete_bounds (range, &field_low, &field_high) < 0)
	166	break;
	167	target = TYPE_TARGET_TYPE (range);
	168	if (target == NULL)
6d84d3d8	169	target = builtin_type_int32;
72019c9c GM	170	}
	171	}
	172	if (element_seen)
	173	{
	174	if (previous_low+1 < previous_high)
	175	{
	176	fprintf_filtered (stream, "..");
	177	print_type_scalar (target, previous_high, stream);
	178	}
	179	element_seen = 0;
	180	}
	181	fprintf_filtered (stream, "}");
	182	}
	183	}
	184
844781a1 GM	185	static void
	186	m2_print_unbounded_array (struct type type, const gdb_byte valaddr,
	187	int embedded_offset, CORE_ADDR address,
79a45b7d TT	188	struct ui_file *stream, int recurse,
79a45b7d TT	189	const struct value_print_options *options)
844781a1 GM	190	{
	191	struct type *content_type;
	192	CORE_ADDR addr;
	193	LONGEST len;
	194	struct value *val;
	195
	196	CHECK_TYPEDEF (type);
	197	content_type = TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0));
	198
	199	addr = unpack_pointer (TYPE_FIELD_TYPE (type, 0),
	200	(TYPE_FIELD_BITPOS (type, 0) / 8) +
	201	valaddr + embedded_offset);
	202
	203	val = value_at_lazy (TYPE_TARGET_TYPE (TYPE_FIELD_TYPE (type, 0)),
	204	addr);
	205	len = unpack_field_as_long (type, valaddr + embedded_offset, 1);
	206
	207	fprintf_filtered (stream, "{");
	208	m2_print_array_contents (value_type (val), value_contents(val),
	209	value_embedded_offset (val), addr, stream,
79a45b7d	210	recurse, options, len);
844781a1 GM	211	fprintf_filtered (stream, ", HIGH = %d}", (int) len);
	212	}
	213
79a45b7d	214	static int
72019c9c GM	215	print_unpacked_pointer (struct type *type,
72019c9c GM	216	CORE_ADDR address, CORE_ADDR addr,
79a45b7d TT	217	const struct value_print_options *options,
79a45b7d TT	218	struct ui_file *stream)
72019c9c GM	219	{
	220	struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
	221
	222	if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
	223	{
	224	/* Try to print what function it points to. */
79a45b7d	225	print_function_pointer_address (addr, stream, options->addressprint);
72019c9c GM	226	/* Return value is irrelevant except for string pointers. */
	227	return 0;
	228	}
	229
79a45b7d	230	if (options->addressprint && options->format != 's')
72019c9c GM	231	fputs_filtered (paddress (address), stream);
	232
	233	/* For a pointer to char or unsigned char, also print the string
	234	pointed to, unless pointer is null. */
	235
	236	if (TYPE_LENGTH (elttype) == 1
	237	&& TYPE_CODE (elttype) == TYPE_CODE_INT
79a45b7d	238	&& (options->format == 0 \|\| options->format == 's')
72019c9c	239	&& addr != 0)
6c7a06a3 TT	240	return val_print_string (TYPE_TARGET_TYPE (type), addr, -1,
6c7a06a3 TT	241	stream, options);
72019c9c GM	242
	243	return 0;
	244	}
	245
	246	static void
844781a1 GM	247	print_variable_at_address (struct type *type,
844781a1 GM	248	const gdb_byte *valaddr,
79a45b7d TT	249	struct ui_file *stream,
	250	int recurse,
	251	const struct value_print_options *options)
72019c9c GM	252	{
	253	CORE_ADDR addr = unpack_pointer (type, valaddr);
	254	struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
	255
	256	fprintf_filtered (stream, "[");
	257	fputs_filtered (paddress (addr), stream);
	258	fprintf_filtered (stream, "] : ");
	259
	260	if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
	261	{
	262	struct value *deref_val =
d8631d21	263	value_at (TYPE_TARGET_TYPE (type), unpack_pointer (type, valaddr));
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 TT	280	struct ui_file *stream, int recurse,
	281	const struct value_print_options *options,
	282	int len)
844781a1 GM	283	{
	284	int eltlen;
	285	CHECK_TYPEDEF (type);
	286
	287	if (TYPE_LENGTH (type) > 0)
	288	{
	289	eltlen = TYPE_LENGTH (type);
79a45b7d	290	if (options->prettyprint_arrays)
844781a1 GM	291	print_spaces_filtered (2 + 2 * recurse, stream);
	292	/* For an array of chars, print with string syntax. */
	293	if (eltlen == 1 &&
	294	((TYPE_CODE (type) == TYPE_CODE_INT)
	295	\|\| ((current_language->la_language == language_m2)
	296	&& (TYPE_CODE (type) == TYPE_CODE_CHAR)))
79a45b7d	297	&& (options->format == 0 \|\| options->format == 's'))
6c7a06a3	298	val_print_string (type, address, len+1, stream, options);
844781a1 GM	299	else
	300	{
	301	fprintf_filtered (stream, "{");
	302	val_print_array_elements (type, valaddr + embedded_offset,
79a45b7d	303	address, stream, recurse, options, 0);
844781a1 GM	304	fprintf_filtered (stream, "}");
	305	}
	306	}
	307	}
	308
	309
72019c9c GM	310	/* Print data of type TYPE located at VALADDR (within GDB), which came from
72019c9c GM	311	the inferior at address ADDRESS, onto stdio stream STREAM according to
79a45b7d	312	OPTIONS. The data at VALADDR is in target byte order.
72019c9c GM	313
72019c9c GM	314	If the data are a string pointer, returns the number of string characters
79a45b7d	315	printed. */
c906108c SS	316
c906108c SS	317	int
fc1a4b47	318	m2_val_print (struct type type, const gdb_byte valaddr, int embedded_offset,
79a45b7d TT	319	CORE_ADDR address, struct ui_file *stream, int recurse,
79a45b7d TT	320	const struct value_print_options *options)
c906108c	321	{
72019c9c GM	322	unsigned int i = 0; /* Number of characters printed */
	323	unsigned len;
	324	struct type *elttype;
	325	unsigned eltlen;
	326	int length_pos, length_size, string_pos;
	327	int char_size;
	328	LONGEST val;
	329	CORE_ADDR addr;
	330
	331	CHECK_TYPEDEF (type);
	332	switch (TYPE_CODE (type))
	333	{
	334	case TYPE_CODE_ARRAY:
	335	if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
	336	{
	337	elttype = check_typedef (TYPE_TARGET_TYPE (type));
	338	eltlen = TYPE_LENGTH (elttype);
	339	len = TYPE_LENGTH (type) / eltlen;
79a45b7d	340	if (options->prettyprint_arrays)
72019c9c GM	341	print_spaces_filtered (2 + 2 * recurse, stream);
	342	/* For an array of chars, print with string syntax. */
	343	if (eltlen == 1 &&
	344	((TYPE_CODE (elttype) == TYPE_CODE_INT)
	345	\|\| ((current_language->la_language == language_m2)
	346	&& (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
79a45b7d	347	&& (options->format == 0 \|\| options->format == 's'))
72019c9c GM	348	{
	349	/* If requested, look for the first null char and only print
	350	elements up to it. */
79a45b7d	351	if (options->stop_print_at_null)
72019c9c GM	352	{
	353	unsigned int temp_len;
	354
	355	/* Look for a NULL char. */
	356	for (temp_len = 0;
	357	(valaddr + embedded_offset)[temp_len]
79a45b7d	358	&& temp_len < len && temp_len < options->print_max;
72019c9c GM	359	temp_len++);
	360	len = temp_len;
	361	}
	362
6c7a06a3 TT	363	LA_PRINT_STRING (stream, TYPE_TARGET_TYPE (type),
6c7a06a3 TT	364	valaddr + embedded_offset, len, 0,
79a45b7d	365	options);
72019c9c GM	366	i = len;
	367	}
	368	else
	369	{
	370	fprintf_filtered (stream, "{");
	371	val_print_array_elements (type, valaddr + embedded_offset,
79a45b7d	372	address, stream, recurse, options, 0);
72019c9c GM	373	fprintf_filtered (stream, "}");
	374	}
	375	break;
	376	}
	377	/* Array of unspecified length: treat like pointer to first elt. */
79a45b7d	378	print_unpacked_pointer (type, address, address, options, stream);
72019c9c GM	379	break;
	380
	381	case TYPE_CODE_PTR:
	382	if (TYPE_CONST (type))
	383	print_variable_at_address (type, valaddr + embedded_offset,
79a45b7d TT	384	stream, recurse, options);
	385	else if (options->format && options->format != 's')
	386	print_scalar_formatted (valaddr + embedded_offset, type,
	387	options, 0, stream);
72019c9c GM	388	else
	389	{
	390	addr = unpack_pointer (type, valaddr + embedded_offset);
79a45b7d	391	print_unpacked_pointer (type, addr, address, options, stream);
72019c9c GM	392	}
	393	break;
	394
72019c9c GM	395	case TYPE_CODE_REF:
72019c9c GM	396	elttype = check_typedef (TYPE_TARGET_TYPE (type));
79a45b7d	397	if (options->addressprint)
72019c9c GM	398	{
	399	CORE_ADDR addr
	400	= extract_typed_address (valaddr + embedded_offset, type);
	401	fprintf_filtered (stream, "@");
	402	fputs_filtered (paddress (addr), stream);
79a45b7d	403	if (options->deref_ref)
72019c9c GM	404	fputs_filtered (": ", stream);
	405	}
	406	/* De-reference the reference. */
79a45b7d	407	if (options->deref_ref)
72019c9c GM	408	{
	409	if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
	410	{
	411	struct value *deref_val =
	412	value_at
	413	(TYPE_TARGET_TYPE (type),
d8631d21	414	unpack_pointer (type, valaddr + embedded_offset));
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. */
	482	print_address_demangle (address, stream, demangle);
	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;
	489	opts.format = (options->format ? options->format
	490	: options->output_format);
	491	print_scalar_formatted (valaddr + embedded_offset, type,
	492	&opts, 0, stream);
	493	}
72019c9c GM	494	else
	495	{
	496	val = unpack_long (type, valaddr + embedded_offset);
	497	if (val == 0)
	498	fputs_filtered ("FALSE", stream);
	499	else if (val == 1)
	500	fputs_filtered ("TRUE", stream);
	501	else
	502	fprintf_filtered (stream, "%ld)", (long int) val);
	503	}
	504	break;
	505
	506	case TYPE_CODE_RANGE:
	507	if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
	508	{
	509	m2_val_print (TYPE_TARGET_TYPE (type), valaddr, embedded_offset,
79a45b7d	510	address, stream, recurse, options);
72019c9c GM	511	break;
	512	}
	513	/* FIXME: create_range_type does not set the unsigned bit in a
	514	range type (I think it probably should copy it from the target
	515	type), so we won't print values which are too large to
	516	fit in a signed integer correctly. */
	517	/* FIXME: Doesn't handle ranges of enums correctly. (Can't just
	518	print with the target type, though, because the size of our type
	519	and the target type might differ). */
	520	/* FALLTHROUGH */
	521
	522	case TYPE_CODE_INT:
79a45b7d TT	523	if (options->format \|\| options->output_format)
	524	{
	525	struct value_print_options opts = *options;
	526	opts.format = (options->format ? options->format
	527	: options->output_format);
	528	print_scalar_formatted (valaddr + embedded_offset, type,
	529	&opts, 0, stream);
	530	}
72019c9c GM	531	else
	532	val_print_type_code_int (type, valaddr + embedded_offset, stream);
	533	break;
	534
	535	case TYPE_CODE_CHAR:
79a45b7d TT	536	if (options->format \|\| options->output_format)
	537	{
	538	struct value_print_options opts = *options;
	539	opts.format = (options->format ? options->format
	540	: options->output_format);
	541	print_scalar_formatted (valaddr + embedded_offset, type,
	542	&opts, 0, stream);
	543	}
72019c9c GM	544	else
	545	{
	546	val = unpack_long (type, valaddr + embedded_offset);
	547	if (TYPE_UNSIGNED (type))
	548	fprintf_filtered (stream, "%u", (unsigned int) val);
	549	else
	550	fprintf_filtered (stream, "%d", (int) val);
	551	fputs_filtered (" ", stream);
6c7a06a3	552	LA_PRINT_CHAR ((unsigned char) val, type, stream);
72019c9c GM	553	}
	554	break;
	555
	556	case TYPE_CODE_FLT:
79a45b7d	557	if (options->format)
72019c9c	558	print_scalar_formatted (valaddr + embedded_offset, type,
79a45b7d	559	options, 0, stream);
72019c9c GM	560	else
	561	print_floating (valaddr + embedded_offset, type, stream);
	562	break;
	563
	564	case TYPE_CODE_METHOD:
	565	break;
	566
	567	case TYPE_CODE_BITSTRING:
	568	case TYPE_CODE_SET:
	569	elttype = TYPE_INDEX_TYPE (type);
	570	CHECK_TYPEDEF (elttype);
	571	if (TYPE_STUB (elttype))
	572	{
	573	fprintf_filtered (stream, _("<incomplete type>"));
	574	gdb_flush (stream);
	575	break;
	576	}
	577	else
	578	{
	579	struct type *range = elttype;
	580	LONGEST low_bound, high_bound;
	581	int i;
	582	int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
	583	int need_comma = 0;
	584
	585	if (is_bitstring)
	586	fputs_filtered ("B'", stream);
	587	else
	588	fputs_filtered ("{", stream);
	589
	590	i = get_discrete_bounds (range, &low_bound, &high_bound);
	591	maybe_bad_bstring:
	592	if (i < 0)
	593	{
	594	fputs_filtered (_("<error value>"), stream);
	595	goto done;
	596	}
	597
	598	for (i = low_bound; i <= high_bound; i++)
	599	{
	600	int element = value_bit_index (type, valaddr + embedded_offset,
	601	i);
	602	if (element < 0)
	603	{
	604	i = element;
	605	goto maybe_bad_bstring;
	606	}
	607	if (is_bitstring)
	608	fprintf_filtered (stream, "%d", element);
	609	else if (element)
	610	{
	611	if (need_comma)
	612	fputs_filtered (", ", stream);
	613	print_type_scalar (range, i, stream);
	614	need_comma = 1;
	615
	616	if (i + 1 <= high_bound
	617	&& value_bit_index (type, valaddr + embedded_offset,
	618	++i))
	619	{
	620	int j = i;
	621	fputs_filtered ("..", stream);
	622	while (i + 1 <= high_bound
	623	&& value_bit_index (type,
624	valaddr + embedded_offset,
625	++i))
626	j = i;
627	print_type_scalar (range, j, stream);
628	}
629	}
630	}
631	done:
632	if (is_bitstring)
633	fputs_filtered ("'", stream);
634	else
635	fputs_filtered ("}", stream);
636	}
637	break;
638
639	case TYPE_CODE_VOID:
640	fprintf_filtered (stream, "void");
641	break;
642
643	case TYPE_CODE_ERROR:
644	fprintf_filtered (stream, _("<error type>"));
645	break;
646
647	case TYPE_CODE_UNDEF:
648	/* This happens (without TYPE_FLAG_STUB set) on systems which don't use
649	dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
650	and no complete type for struct foo in that file. */
651	fprintf_filtered (stream, _("<incomplete type>"));
652	break;
653
654	default:
655	error (_("Invalid m2 type code %d in symbol table."), TYPE_CODE (type));
656	}
657	gdb_flush (stream);
658	return (0);
c906108c	659	}