[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 (addr, -1, TYPE_LENGTH (elttype), 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 (address, len+1, eltlen, 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, valaddr + embedded_offset, len, 1, 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, 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)
79a45b7d	240	return val_print_string (addr, -1, TYPE_LENGTH (elttype), stream, options);
72019c9c GM	241
	242	return 0;
	243	}
	244
	245	static void
844781a1 GM	246	print_variable_at_address (struct type *type,
844781a1 GM	247	const gdb_byte *valaddr,
79a45b7d TT	248	struct ui_file *stream,
	249	int recurse,
	250	const struct value_print_options *options)
72019c9c GM	251	{
	252	CORE_ADDR addr = unpack_pointer (type, valaddr);
	253	struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
	254
	255	fprintf_filtered (stream, "[");
	256	fputs_filtered (paddress (addr), stream);
	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));
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 TT	296	&& (options->format == 0 \|\| options->format == 's'))
79a45b7d TT	297	val_print_string (address, len+1, eltlen, 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	{
72019c9c GM	321	unsigned int i = 0; /* Number of characters printed */
	322	unsigned len;
	323	struct type *elttype;
	324	unsigned eltlen;
	325	int length_pos, length_size, string_pos;
	326	int char_size;
	327	LONGEST val;
	328	CORE_ADDR addr;
	329
	330	CHECK_TYPEDEF (type);
	331	switch (TYPE_CODE (type))
	332	{
	333	case TYPE_CODE_ARRAY:
	334	if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
	335	{
	336	elttype = check_typedef (TYPE_TARGET_TYPE (type));
	337	eltlen = TYPE_LENGTH (elttype);
	338	len = TYPE_LENGTH (type) / eltlen;
79a45b7d	339	if (options->prettyprint_arrays)
72019c9c GM	340	print_spaces_filtered (2 + 2 * recurse, stream);
	341	/* For an array of chars, print with string syntax. */
	342	if (eltlen == 1 &&
	343	((TYPE_CODE (elttype) == TYPE_CODE_INT)
	344	\|\| ((current_language->la_language == language_m2)
	345	&& (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
79a45b7d	346	&& (options->format == 0 \|\| options->format == 's'))
72019c9c GM	347	{
	348	/* If requested, look for the first null char and only print
	349	elements up to it. */
79a45b7d	350	if (options->stop_print_at_null)
72019c9c GM	351	{
	352	unsigned int temp_len;
	353
	354	/* Look for a NULL char. */
	355	for (temp_len = 0;
	356	(valaddr + embedded_offset)[temp_len]
79a45b7d	357	&& temp_len < len && temp_len < options->print_max;
72019c9c GM	358	temp_len++);
	359	len = temp_len;
	360	}
	361
79a45b7d TT	362	LA_PRINT_STRING (stream, valaddr + embedded_offset, len, 1, 0,
79a45b7d TT	363	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);
	399	fprintf_filtered (stream, "@");
	400	fputs_filtered (paddress (addr), stream);
79a45b7d	401	if (options->deref_ref)
72019c9c GM	402	fputs_filtered (": ", stream);
	403	}
	404	/* De-reference the reference. */
79a45b7d	405	if (options->deref_ref)
72019c9c GM	406	{
	407	if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
	408	{
	409	struct value *deref_val =
	410	value_at
	411	(TYPE_TARGET_TYPE (type),
d8631d21	412	unpack_pointer (type, valaddr + embedded_offset));
79a45b7d TT	413	common_val_print (deref_val, stream, recurse, options,
79a45b7d TT	414	current_language);
72019c9c GM	415	}
	416	else
	417	fputs_filtered ("???", stream);
	418	}
	419	break;
	420
	421	case TYPE_CODE_UNION:
79a45b7d	422	if (recurse && !options->unionprint)
72019c9c GM	423	{
	424	fprintf_filtered (stream, "{...}");
	425	break;
	426	}
	427	/* Fall through. */
	428	case TYPE_CODE_STRUCT:
	429	if (m2_is_long_set (type))
	430	m2_print_long_set (type, valaddr, embedded_offset, address,
79a45b7d	431	stream);
844781a1 GM	432	else if (m2_is_unbounded_array (type))
844781a1 GM	433	m2_print_unbounded_array (type, valaddr, embedded_offset,
79a45b7d	434	address, stream, recurse, options);
72019c9c GM	435	else
72019c9c GM	436	cp_print_value_fields (type, type, valaddr, embedded_offset,
79a45b7d	437	address, stream, recurse, options, NULL, 0);
72019c9c GM	438	break;
	439
	440	case TYPE_CODE_ENUM:
79a45b7d	441	if (options->format)
72019c9c GM	442	{
72019c9c GM	443	print_scalar_formatted (valaddr + embedded_offset, type,
79a45b7d	444	options, 0, stream);
72019c9c GM	445	break;
	446	}
	447	len = TYPE_NFIELDS (type);
	448	val = unpack_long (type, valaddr + embedded_offset);
	449	for (i = 0; i < len; i++)
	450	{
	451	QUIT;
	452	if (val == TYPE_FIELD_BITPOS (type, i))
	453	{
	454	break;
	455	}
	456	}
	457	if (i < len)
	458	{
	459	fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
	460	}
	461	else
	462	{
	463	print_longest (stream, 'd', 0, val);
	464	}
	465	break;
	466
	467	case TYPE_CODE_FUNC:
79a45b7d	468	if (options->format)
72019c9c GM	469	{
72019c9c GM	470	print_scalar_formatted (valaddr + embedded_offset, type,
79a45b7d	471	options, 0, stream);
72019c9c GM	472	break;
	473	}
	474	/* FIXME, we should consider, at least for ANSI C language, eliminating
	475	the distinction made between FUNCs and POINTERs to FUNCs. */
	476	fprintf_filtered (stream, "{");
	477	type_print (type, "", stream, -1);
	478	fprintf_filtered (stream, "} ");
	479	/* Try to print what function it points to, and its address. */
	480	print_address_demangle (address, stream, demangle);
	481	break;
	482
	483	case TYPE_CODE_BOOL:
79a45b7d TT	484	if (options->format \|\| options->output_format)
	485	{
	486	struct value_print_options opts = *options;
	487	opts.format = (options->format ? options->format
	488	: options->output_format);
	489	print_scalar_formatted (valaddr + embedded_offset, type,
	490	&opts, 0, stream);
	491	}
72019c9c GM	492	else
	493	{
	494	val = unpack_long (type, valaddr + embedded_offset);
	495	if (val == 0)
	496	fputs_filtered ("FALSE", stream);
	497	else if (val == 1)
	498	fputs_filtered ("TRUE", stream);
	499	else
	500	fprintf_filtered (stream, "%ld)", (long int) val);
	501	}
	502	break;
	503
	504	case TYPE_CODE_RANGE:
	505	if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
	506	{
	507	m2_val_print (TYPE_TARGET_TYPE (type), valaddr, embedded_offset,
79a45b7d	508	address, stream, recurse, options);
72019c9c GM	509	break;
	510	}
	511	/* FIXME: create_range_type does not set the unsigned bit in a
	512	range type (I think it probably should copy it from the target
	513	type), so we won't print values which are too large to
	514	fit in a signed integer correctly. */
	515	/* FIXME: Doesn't handle ranges of enums correctly. (Can't just
	516	print with the target type, though, because the size of our type
	517	and the target type might differ). */
	518	/* FALLTHROUGH */
	519
	520	case TYPE_CODE_INT:
79a45b7d TT	521	if (options->format \|\| options->output_format)
	522	{
	523	struct value_print_options opts = *options;
	524	opts.format = (options->format ? options->format
	525	: options->output_format);
	526	print_scalar_formatted (valaddr + embedded_offset, type,
	527	&opts, 0, stream);
	528	}
72019c9c GM	529	else
	530	val_print_type_code_int (type, valaddr + embedded_offset, stream);
	531	break;
	532
	533	case TYPE_CODE_CHAR:
79a45b7d TT	534	if (options->format \|\| options->output_format)
	535	{
	536	struct value_print_options opts = *options;
	537	opts.format = (options->format ? options->format
	538	: options->output_format);
	539	print_scalar_formatted (valaddr + embedded_offset, type,
	540	&opts, 0, stream);
	541	}
72019c9c GM	542	else
	543	{
	544	val = unpack_long (type, valaddr + embedded_offset);
	545	if (TYPE_UNSIGNED (type))
	546	fprintf_filtered (stream, "%u", (unsigned int) val);
	547	else
	548	fprintf_filtered (stream, "%d", (int) val);
	549	fputs_filtered (" ", stream);
	550	LA_PRINT_CHAR ((unsigned char) val, stream);
	551	}
	552	break;
	553
	554	case TYPE_CODE_FLT:
79a45b7d	555	if (options->format)
72019c9c	556	print_scalar_formatted (valaddr + embedded_offset, type,
79a45b7d	557	options, 0, stream);
72019c9c GM	558	else
	559	print_floating (valaddr + embedded_offset, type, stream);
	560	break;
	561
	562	case TYPE_CODE_METHOD:
	563	break;
	564
	565	case TYPE_CODE_BITSTRING:
	566	case TYPE_CODE_SET:
	567	elttype = TYPE_INDEX_TYPE (type);
	568	CHECK_TYPEDEF (elttype);
	569	if (TYPE_STUB (elttype))
	570	{
	571	fprintf_filtered (stream, _("<incomplete type>"));
	572	gdb_flush (stream);
	573	break;
	574	}
	575	else
	576	{
	577	struct type *range = elttype;
	578	LONGEST low_bound, high_bound;
	579	int i;
	580	int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
	581	int need_comma = 0;
	582
	583	if (is_bitstring)
	584	fputs_filtered ("B'", stream);
	585	else
	586	fputs_filtered ("{", stream);
	587
	588	i = get_discrete_bounds (range, &low_bound, &high_bound);
	589	maybe_bad_bstring:
	590	if (i < 0)
	591	{
	592	fputs_filtered (_("<error value>"), stream);
	593	goto done;
	594	}
	595
	596	for (i = low_bound; i <= high_bound; i++)
	597	{
	598	int element = value_bit_index (type, valaddr + embedded_offset,
	599	i);
	600	if (element < 0)
	601	{
	602	i = element;
	603	goto maybe_bad_bstring;
	604	}
	605	if (is_bitstring)
	606	fprintf_filtered (stream, "%d", element);
	607	else if (element)
	608	{
	609	if (need_comma)
	610	fputs_filtered (", ", stream);
	611	print_type_scalar (range, i, stream);
	612	need_comma = 1;
	613
	614	if (i + 1 <= high_bound
	615	&& value_bit_index (type, valaddr + embedded_offset,
	616	++i))
	617	{
	618	int j = i;
	619	fputs_filtered ("..", stream);
	620	while (i + 1 <= high_bound
	621	&& value_bit_index (type,
622	valaddr + embedded_offset,
623	++i))
624	j = i;
625	print_type_scalar (range, j, stream);
626	}
627	}
628	}
629	done:
630	if (is_bitstring)
631	fputs_filtered ("'", stream);
632	else
633	fputs_filtered ("}", stream);
634	}
635	break;
636
637	case TYPE_CODE_VOID:
638	fprintf_filtered (stream, "void");
639	break;
640
641	case TYPE_CODE_ERROR:
642	fprintf_filtered (stream, _("<error type>"));
643	break;
644
645	case TYPE_CODE_UNDEF:
646	/* This happens (without TYPE_FLAG_STUB set) on systems which don't use
647	dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
648	and no complete type for struct foo in that file. */
649	fprintf_filtered (stream, _("<incomplete type>"));
650	break;
651
652	default:
653	error (_("Invalid m2 type code %d in symbol table."), TYPE_CODE (type));
654	}
655	gdb_flush (stream);
656	return (0);
c906108c	657	}