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