[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
   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 2 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, write to the Free Software
   Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.  */

#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"

int print_unpacked_pointer (struct type *type,
			    CORE_ADDR address, CORE_ADDR addr,
			    int format, struct ui_file *stream);


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

static void
print_function_pointer_address (CORE_ADDR address, struct ui_file *stream)
{
  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 format,
		   enum val_prettyprint pretty)
{
  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_int;

  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_int;
	    }
	}
      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, "}");
    }
}

int
print_unpacked_pointer (struct type *type,
			CORE_ADDR address, CORE_ADDR addr,
			int format, 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);
      /* Return value is irrelevant except for string pointers.  */
      return 0;
    }

  if (addressprint && 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
      && (format == 0 || format == 's')
      && addr != 0)
      return val_print_string (addr, -1, TYPE_LENGTH (elttype), stream);
  
  return 0;
}

static void
print_variable_at_address (struct type *type, const gdb_byte *valaddr,
			   struct ui_file *stream, int format,
			   int deref_ref, int recurse,
			   enum val_prettyprint pretty)
{
  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 (lookup_pointer_type (builtin_type_void),
			 valaddr));
      common_val_print (deref_val, stream, format, deref_ref,
			recurse, pretty);
    }
  else
    fputs_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
   FORMAT (a letter or 0 for natural format).  The data at VALADDR is in
   target byte order.

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

   If DEREF_REF is nonzero, then dereference references, otherwise just print
   them like pointers.

   The PRETTY parameter controls prettyprinting.  */

int
m2_val_print (struct type *type, const gdb_byte *valaddr, int embedded_offset,
	      CORE_ADDR address, struct ui_file *stream, int format,
	      int deref_ref, int recurse, enum val_prettyprint pretty)
{
  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 (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)))
	      && (format == 0 || format == 's'))
	    {
	      /* If requested, look for the first null char and only print
	         elements up to it.  */
	      if (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 < print_max;
		       temp_len++);
		  len = temp_len;
		}

	      LA_PRINT_STRING (stream, valaddr + embedded_offset, len, 1, 0);
	      i = len;
	    }
	  else
	    {
	      fprintf_filtered (stream, "{");
	      val_print_array_elements (type, valaddr + embedded_offset,
					address, stream, format, deref_ref,
					recurse, pretty, 0);
	      fprintf_filtered (stream, "}");
	    }
	  break;
	}
      /* Array of unspecified length: treat like pointer to first elt.  */
      print_unpacked_pointer (type, address, address, format, stream);
      break;

    case TYPE_CODE_PTR:
      if (TYPE_CONST (type))
	print_variable_at_address (type, valaddr + embedded_offset,
				   stream, format, deref_ref, recurse,
				   pretty);
      else if (format && format != 's')
	print_scalar_formatted (valaddr + embedded_offset, type, format,
				0, stream);
      else
	{
	  addr = unpack_pointer (type, valaddr + embedded_offset);
	  print_unpacked_pointer (type, addr, address, format, stream);
	}
      break;

    case TYPE_CODE_REF:
      elttype = check_typedef (TYPE_TARGET_TYPE (type));
      if (addressprint)
	{
	  CORE_ADDR addr
	    = extract_typed_address (valaddr + embedded_offset, type);
	  fprintf_filtered (stream, "@");
	  fputs_filtered (paddress (addr), stream);
	  if (deref_ref)
	    fputs_filtered (": ", stream);
	}
      /* De-reference the reference.  */
      if (deref_ref)
	{
	  if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
	    {
	      struct value *deref_val =
		value_at
		(TYPE_TARGET_TYPE (type),
		 unpack_pointer (lookup_pointer_type (builtin_type_void),
				 valaddr + embedded_offset));
	      common_val_print (deref_val, stream, format, deref_ref,
				recurse, pretty);
	    }
	  else
	    fputs_filtered ("???", stream);
	}
      break;

    case TYPE_CODE_UNION:
      if (recurse && !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, format, pretty);
      else
	cp_print_value_fields (type, type, valaddr, embedded_offset,
			       address, stream, format,
			       recurse, pretty, NULL, 0);
      break;

    case TYPE_CODE_ENUM:
      if (format)
	{
	  print_scalar_formatted (valaddr + embedded_offset, type,
				  format, 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 (format)
	{
	  print_scalar_formatted (valaddr + embedded_offset, type,
				  format, 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:
      format = format ? format : output_format;
      if (format)
	print_scalar_formatted (valaddr + embedded_offset, type,
				format, 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, format, deref_ref, recurse, pretty);
	  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:
      format = format ? format : output_format;
      if (format)
	print_scalar_formatted (valaddr + embedded_offset, type, format,
				0, stream);
      else
	val_print_type_code_int (type, valaddr + embedded_offset, stream);
      break;

    case TYPE_CODE_CHAR:
      format = format ? format : output_format;
      if (format)
	print_scalar_formatted (valaddr + embedded_offset, type,
				format, 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 (format)
	print_scalar_formatted (valaddr + embedded_offset, type,
				format, 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
72019c9c GM	3	Copyright (C) 1986, 1988, 1989, 1991, 1992, 1996, 1998,
	4	2000, 2005, 2006
	5	Free Software Foundation, Inc.
c906108c	6
c5aa993b	7	This file is part of GDB.
c906108c	8
c5aa993b JM	9	This program is free software; you can redistribute it and/or modify
	10	it under the terms of the GNU General Public License as published by
	11	the Free Software Foundation; either version 2 of the License, or
	12	(at your option) any later version.
c906108c	13
c5aa993b JM	14	This program is distributed in the hope that it will be useful,
	15	but WITHOUT ANY WARRANTY; without even the implied warranty of
	16	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	17	GNU General Public License for more details.
c906108c	18
c5aa993b JM	19	You should have received a copy of the GNU General Public License
c5aa993b JM	20	along with this program; if not, write to the Free Software
197e01b6 EZ	21	Foundation, Inc., 51 Franklin Street, Fifth Floor,
197e01b6 EZ	22	Boston, MA 02110-1301, USA. */
c906108c SS	23
c906108c SS	24	#include "defs.h"
c906108c SS	25	#include "symtab.h"
c906108c SS	26	#include "gdbtypes.h"
72019c9c GM	27	#include "expression.h"
	28	#include "value.h"
	29	#include "valprint.h"
	30	#include "language.h"
	31	#include "typeprint.h"
a8d6eb4a	32	#include "c-lang.h"
72019c9c GM	33	#include "m2-lang.h"
	34	#include "target.h"
	35
	36	int print_unpacked_pointer (struct type *type,
	37	CORE_ADDR address, CORE_ADDR addr,
	38	int format, struct ui_file *stream);
	39
	40
	41	/* Print function pointer with inferior address ADDRESS onto stdio
	42	stream STREAM. */
	43
	44	static void
	45	print_function_pointer_address (CORE_ADDR address, struct ui_file *stream)
	46	{
	47	CORE_ADDR func_addr = gdbarch_convert_from_func_ptr_addr (current_gdbarch,
	48	address,
	49	&current_target);
	50
	51	/* If the function pointer is represented by a description, print the
	52	address of the description. */
	53	if (addressprint && func_addr != address)
	54	{
	55	fputs_filtered ("@", stream);
	56	fputs_filtered (paddress (address), stream);
	57	fputs_filtered (": ", stream);
	58	}
	59	print_address_demangle (func_addr, stream, demangle);
	60	}
	61
	62	/*
	63	* get_long_set_bounds - assigns the bounds of the long set to low and high.
	64	*/
	65
	66	int
	67	get_long_set_bounds (struct type type, LONGEST low, LONGEST *high)
	68	{
	69	int len, i;
	70
	71	if (TYPE_CODE (type) == TYPE_CODE_STRUCT)
	72	{
	73	len = TYPE_NFIELDS (type);
	74	i = TYPE_N_BASECLASSES (type);
	75	if (len == 0)
	76	return 0;
	77	*low = TYPE_LOW_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, i)));
	78	*high = TYPE_HIGH_BOUND (TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type,
	79	len-1)));
	80	return 1;
	81	}
	82	error (_("expecting long_set"));
	83	return 0;
	84	}
	85
	86	static void
	87	m2_print_long_set (struct type type, const gdb_byte valaddr,
	88	int embedded_offset, CORE_ADDR address,
	89	struct ui_file *stream, int format,
	90	enum val_prettyprint pretty)
	91	{
	92	int empty_set = 1;
	93	int element_seen = 0;
	94	LONGEST previous_low = 0;
	95	LONGEST previous_high= 0;
	96	LONGEST i, low_bound, high_bound;
97	LONGEST field_low, field_high;
98	struct type *range;
99	int len, field;
100	struct type *target;
101	int bitval;
102
103	CHECK_TYPEDEF (type);
104
105	fprintf_filtered (stream, "{");
106	len = TYPE_NFIELDS (type);
107	if (get_long_set_bounds (type, &low_bound, &high_bound))
108	{
109	field = TYPE_N_BASECLASSES (type);
110	range = TYPE_INDEX_TYPE (TYPE_FIELD_TYPE (type, field));
111	}
112	else
113	{
114	fprintf_filtered (stream, " %s }", _("<unknown bounds of set>"));
115	return;
116	}
117
118	target = TYPE_TARGET_TYPE (range);
119	if (target == NULL)
120	target = builtin_type_int;
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);
165	if (target == NULL)
166	target = builtin_type_int;
167	}
168	}
169	if (element_seen)
170	{
171	if (previous_low+1 < previous_high)
172	{
173	fprintf_filtered (stream, "..");
174	print_type_scalar (target, previous_high, stream);
175	}
176	element_seen = 0;
177	}
178	fprintf_filtered (stream, "}");
179	}
180	}
181
182	int
183	print_unpacked_pointer (struct type *type,
184	CORE_ADDR address, CORE_ADDR addr,
185	int format, struct ui_file *stream)
186	{
187	struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
188
189	if (TYPE_CODE (elttype) == TYPE_CODE_FUNC)
190	{
191	/* Try to print what function it points to. */
192	print_function_pointer_address (addr, stream);
193	/* Return value is irrelevant except for string pointers. */
194	return 0;
195	}
196
197	if (addressprint && format != 's')
198	fputs_filtered (paddress (address), stream);
199
200	/* For a pointer to char or unsigned char, also print the string
201	pointed to, unless pointer is null. */
202
203	if (TYPE_LENGTH (elttype) == 1
204	&& TYPE_CODE (elttype) == TYPE_CODE_INT
205	&& (format == 0 \|\| format == 's')
206	&& addr != 0)
207	return val_print_string (addr, -1, TYPE_LENGTH (elttype), stream);
208
209	return 0;
210	}
211
212	static void
213	print_variable_at_address (struct type type, const gdb_byte valaddr,
214	struct ui_file *stream, int format,
215	int deref_ref, int recurse,
216	enum val_prettyprint pretty)
217	{
218	CORE_ADDR addr = unpack_pointer (type, valaddr);
219	struct type *elttype = check_typedef (TYPE_TARGET_TYPE (type));
220
221	fprintf_filtered (stream, "[");
222	fputs_filtered (paddress (addr), stream);
223	fprintf_filtered (stream, "] : ");
224
225	if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
226	{
227	struct value *deref_val =
228	value_at
229	(TYPE_TARGET_TYPE (type),
230	unpack_pointer (lookup_pointer_type (builtin_type_void),
231	valaddr));
232	common_val_print (deref_val, stream, format, deref_ref,
233	recurse, pretty);
234	}
235	else
236	fputs_filtered ("???", stream);
237	}
238
239	/* Print data of type TYPE located at VALADDR (within GDB), which came from
240	the inferior at address ADDRESS, onto stdio stream STREAM according to
241	FORMAT (a letter or 0 for natural format). The data at VALADDR is in
242	target byte order.
243
244	If the data are a string pointer, returns the number of string characters
245	printed.
246
247	If DEREF_REF is nonzero, then dereference references, otherwise just print
248	them like pointers.
249
250	The PRETTY parameter controls prettyprinting. */
c906108c SS	251
c906108c SS	252	int
fc1a4b47	253	m2_val_print (struct type type, const gdb_byte valaddr, int embedded_offset,
fba45db2 KB	254	CORE_ADDR address, struct ui_file *stream, int format,
fba45db2 KB	255	int deref_ref, int recurse, enum val_prettyprint pretty)
c906108c	256	{
72019c9c GM	257	unsigned int i = 0; /* Number of characters printed */
	258	unsigned len;
	259	struct type *elttype;
	260	unsigned eltlen;
	261	int length_pos, length_size, string_pos;
	262	int char_size;
	263	LONGEST val;
	264	CORE_ADDR addr;
	265
	266	CHECK_TYPEDEF (type);
	267	switch (TYPE_CODE (type))
	268	{
	269	case TYPE_CODE_ARRAY:
	270	if (TYPE_LENGTH (type) > 0 && TYPE_LENGTH (TYPE_TARGET_TYPE (type)) > 0)
	271	{
	272	elttype = check_typedef (TYPE_TARGET_TYPE (type));
	273	eltlen = TYPE_LENGTH (elttype);
	274	len = TYPE_LENGTH (type) / eltlen;
	275	if (prettyprint_arrays)
	276	print_spaces_filtered (2 + 2 * recurse, stream);
	277	/* For an array of chars, print with string syntax. */
	278	if (eltlen == 1 &&
	279	((TYPE_CODE (elttype) == TYPE_CODE_INT)
	280	\|\| ((current_language->la_language == language_m2)
	281	&& (TYPE_CODE (elttype) == TYPE_CODE_CHAR)))
	282	&& (format == 0 \|\| format == 's'))
	283	{
	284	/* If requested, look for the first null char and only print
	285	elements up to it. */
	286	if (stop_print_at_null)
	287	{
	288	unsigned int temp_len;
	289
	290	/* Look for a NULL char. */
	291	for (temp_len = 0;
	292	(valaddr + embedded_offset)[temp_len]
	293	&& temp_len < len && temp_len < print_max;
	294	temp_len++);
	295	len = temp_len;
	296	}
	297
	298	LA_PRINT_STRING (stream, valaddr + embedded_offset, len, 1, 0);
	299	i = len;
	300	}
	301	else
	302	{
	303	fprintf_filtered (stream, "{");
	304	val_print_array_elements (type, valaddr + embedded_offset,
	305	address, stream, format, deref_ref,
	306	recurse, pretty, 0);
	307	fprintf_filtered (stream, "}");
	308	}
	309	break;
	310	}
	311	/* Array of unspecified length: treat like pointer to first elt. */
	312	print_unpacked_pointer (type, address, address, format, stream);
	313	break;
	314
	315	case TYPE_CODE_PTR:
	316	if (TYPE_CONST (type))
	317	print_variable_at_address (type, valaddr + embedded_offset,
	318	stream, format, deref_ref, recurse,
	319	pretty);
	320	else if (format && format != 's')
321	print_scalar_formatted (valaddr + embedded_offset, type, format,
322	0, stream);
323	else
324	{
325	addr = unpack_pointer (type, valaddr + embedded_offset);
326	print_unpacked_pointer (type, addr, address, format, stream);
327	}
328	break;
329
72019c9c GM	330	case TYPE_CODE_REF:
	331	elttype = check_typedef (TYPE_TARGET_TYPE (type));
	332	if (addressprint)
	333	{
	334	CORE_ADDR addr
	335	= extract_typed_address (valaddr + embedded_offset, type);
	336	fprintf_filtered (stream, "@");
	337	fputs_filtered (paddress (addr), stream);
	338	if (deref_ref)
	339	fputs_filtered (": ", stream);
	340	}
	341	/* De-reference the reference. */
	342	if (deref_ref)
	343	{
	344	if (TYPE_CODE (elttype) != TYPE_CODE_UNDEF)
	345	{
	346	struct value *deref_val =
	347	value_at
	348	(TYPE_TARGET_TYPE (type),
	349	unpack_pointer (lookup_pointer_type (builtin_type_void),
	350	valaddr + embedded_offset));
	351	common_val_print (deref_val, stream, format, deref_ref,
	352	recurse, pretty);
	353	}
	354	else
	355	fputs_filtered ("???", stream);
	356	}
	357	break;
	358
	359	case TYPE_CODE_UNION:
	360	if (recurse && !unionprint)
	361	{
	362	fprintf_filtered (stream, "{...}");
	363	break;
	364	}
	365	/* Fall through. */
	366	case TYPE_CODE_STRUCT:
	367	if (m2_is_long_set (type))
	368	m2_print_long_set (type, valaddr, embedded_offset, address,
	369	stream, format, pretty);
	370	else
	371	cp_print_value_fields (type, type, valaddr, embedded_offset,
	372	address, stream, format,
	373	recurse, pretty, NULL, 0);
	374	break;
	375
	376	case TYPE_CODE_ENUM:
	377	if (format)
	378	{
	379	print_scalar_formatted (valaddr + embedded_offset, type,
	380	format, 0, stream);
	381	break;
	382	}
	383	len = TYPE_NFIELDS (type);
	384	val = unpack_long (type, valaddr + embedded_offset);
	385	for (i = 0; i < len; i++)
	386	{
	387	QUIT;
	388	if (val == TYPE_FIELD_BITPOS (type, i))
	389	{
	390	break;
	391	}
	392	}
	393	if (i < len)
394	{
395	fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
396	}
397	else
398	{
399	print_longest (stream, 'd', 0, val);
400	}
401	break;
402
403	case TYPE_CODE_FUNC:
404	if (format)
405	{
406	print_scalar_formatted (valaddr + embedded_offset, type,
407	format, 0, stream);
408	break;
409	}
410	/* FIXME, we should consider, at least for ANSI C language, eliminating
411	the distinction made between FUNCs and POINTERs to FUNCs. */
412	fprintf_filtered (stream, "{");
413	type_print (type, "", stream, -1);
414	fprintf_filtered (stream, "} ");
415	/* Try to print what function it points to, and its address. */
416	print_address_demangle (address, stream, demangle);
417	break;
418
419	case TYPE_CODE_BOOL:
420	format = format ? format : output_format;
421	if (format)
422	print_scalar_formatted (valaddr + embedded_offset, type,
423	format, 0, stream);
424	else
425	{
426	val = unpack_long (type, valaddr + embedded_offset);
427	if (val == 0)
428	fputs_filtered ("FALSE", stream);
429	else if (val == 1)
430	fputs_filtered ("TRUE", stream);
431	else
432	fprintf_filtered (stream, "%ld)", (long int) val);
433	}
434	break;
435
436	case TYPE_CODE_RANGE:
437	if (TYPE_LENGTH (type) == TYPE_LENGTH (TYPE_TARGET_TYPE (type)))
438	{
439	m2_val_print (TYPE_TARGET_TYPE (type), valaddr, embedded_offset,
440	address, stream, format, deref_ref, recurse, pretty);
441	break;
442	}
443	/* FIXME: create_range_type does not set the unsigned bit in a
444	range type (I think it probably should copy it from the target
445	type), so we won't print values which are too large to
446	fit in a signed integer correctly. */
447	/* FIXME: Doesn't handle ranges of enums correctly. (Can't just
448	print with the target type, though, because the size of our type
449	and the target type might differ). */
450	/* FALLTHROUGH */
451
452	case TYPE_CODE_INT:
453	format = format ? format : output_format;
454	if (format)
455	print_scalar_formatted (valaddr + embedded_offset, type, format,
456	0, stream);
457	else
458	val_print_type_code_int (type, valaddr + embedded_offset, stream);
459	break;
460
461	case TYPE_CODE_CHAR:
462	format = format ? format : output_format;
463	if (format)
464	print_scalar_formatted (valaddr + embedded_offset, type,
465	format, 0, stream);
466	else
467	{
468	val = unpack_long (type, valaddr + embedded_offset);
469	if (TYPE_UNSIGNED (type))
470	fprintf_filtered (stream, "%u", (unsigned int) val);
471	else
472	fprintf_filtered (stream, "%d", (int) val);
473	fputs_filtered (" ", stream);
474	LA_PRINT_CHAR ((unsigned char) val, stream);
475	}
476	break;
477
478	case TYPE_CODE_FLT:
479	if (format)
480	print_scalar_formatted (valaddr + embedded_offset, type,
481	format, 0, stream);
482	else
483	print_floating (valaddr + embedded_offset, type, stream);
484	break;
485
486	case TYPE_CODE_METHOD:
487	break;
488
489	case TYPE_CODE_BITSTRING:
490	case TYPE_CODE_SET:
491	elttype = TYPE_INDEX_TYPE (type);
492	CHECK_TYPEDEF (elttype);
493	if (TYPE_STUB (elttype))
494	{
495	fprintf_filtered (stream, _("<incomplete type>"));
496	gdb_flush (stream);
497	break;
498	}
499	else
500	{
501	struct type *range = elttype;
502	LONGEST low_bound, high_bound;
503	int i;
504	int is_bitstring = TYPE_CODE (type) == TYPE_CODE_BITSTRING;
505	int need_comma = 0;
506
507	if (is_bitstring)
508	fputs_filtered ("B'", stream);
509	else
510	fputs_filtered ("{", stream);
511
512	i = get_discrete_bounds (range, &low_bound, &high_bound);
513	maybe_bad_bstring:
514	if (i < 0)
515	{
516	fputs_filtered (_("<error value>"), stream);
517	goto done;
518	}
519
520	for (i = low_bound; i <= high_bound; i++)
521	{
522	int element = value_bit_index (type, valaddr + embedded_offset,
523	i);
524	if (element < 0)
525	{
526	i = element;
527	goto maybe_bad_bstring;
528	}
529	if (is_bitstring)
530	fprintf_filtered (stream, "%d", element);
531	else if (element)
532	{
533	if (need_comma)
534	fputs_filtered (", ", stream);
535	print_type_scalar (range, i, stream);
536	need_comma = 1;
537
538	if (i + 1 <= high_bound
539	&& value_bit_index (type, valaddr + embedded_offset,
540	++i))
541	{
542	int j = i;
543	fputs_filtered ("..", stream);
544	while (i + 1 <= high_bound
545	&& value_bit_index (type,
546	valaddr + embedded_offset,
547	++i))
548	j = i;
549	print_type_scalar (range, j, stream);
550	}
551	}
552	}
553	done:
554	if (is_bitstring)
555	fputs_filtered ("'", stream);
556	else
557	fputs_filtered ("}", stream);
558	}
559	break;
560
561	case TYPE_CODE_VOID:
562	fprintf_filtered (stream, "void");
563	break;
564
565	case TYPE_CODE_ERROR:
566	fprintf_filtered (stream, _("<error type>"));
567	break;
568
569	case TYPE_CODE_UNDEF:
570	/* This happens (without TYPE_FLAG_STUB set) on systems which don't use
571	dbx xrefs (NO_DBX_XREFS in gcc) if a file has a "struct foo *bar"
572	and no complete type for struct foo in that file. */
573	fprintf_filtered (stream, _("<incomplete type>"));
574	break;
575
576	default:
577	error (_("Invalid m2 type code %d in symbol table."), TYPE_CODE (type));
578	}
579	gdb_flush (stream);
580	return (0);
c906108c	581	}