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

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