[deliverable/binutils-gdb.git] / gdb / ch-typeprint.c

/* Support for printing Chill types for GDB, the GNU debugger.
   Copyright 1986, 1988, 1989, 1991 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., 675 Mass Ave, Cambridge, MA 02139, USA.  */

#include "defs.h"
#include "obstack.h"
#include "bfd.h"		/* Binary File Description */
#include "symtab.h"
#include "gdbtypes.h"
#include "expression.h"
#include "value.h"
#include "gdbcore.h"
#include "target.h"
#include "command.h"
#include "gdbcmd.h"
#include "language.h"
#include "demangle.h"
#include "ch-lang.h"
#include "typeprint.h"

#include <string.h>
#include <errno.h>

static void
chill_type_print_base PARAMS ((struct type *, GDB_FILE *, int, int));

void
chill_print_type (type, varstring, stream, show, level)
     struct type *type;
     char *varstring;
     GDB_FILE *stream;
     int show;
     int level;
{
  if (varstring != NULL && *varstring != '\0')
    {
      fputs_filtered (varstring, stream);
      fputs_filtered (" ", stream);
    }
  chill_type_print_base (type, stream, show, level);
}

/* Print the name of the type (or the ultimate pointer target,
   function value or array element).

   SHOW nonzero means don't print this type as just its name;
   show its real definition even if it has a name.
   SHOW zero means print just typename or tag if there is one
   SHOW negative means abbreviate structure elements.
   SHOW is decremented for printing of structure elements.

   LEVEL is the depth to indent by.
   We increase it for some recursive calls.  */

static void
chill_type_print_base (type, stream, show, level)
     struct type *type;
     GDB_FILE *stream;
     int show;
     int level;
{
  register int len;
  register int i;
  struct type *index_type;
  struct type *range_type;
  LONGEST low_bound;
  LONGEST high_bound;

  QUIT;

  wrap_here ("    ");
  if (type == NULL)
    {
      fputs_filtered ("<type unknown>", stream);
      return;
    }

  /* When SHOW is zero or less, and there is a valid type name, then always
     just print the type name directly from the type. */

  if ((show <= 0) && (TYPE_NAME (type) != NULL))
    {
      fputs_filtered (TYPE_NAME (type), stream);
      return;
    }

  check_stub_type (type);

  switch (TYPE_CODE (type))
    {
      case TYPE_CODE_PTR:
	if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
	  {
	    fprintf_filtered (stream, "PTR");
	    break;
	  }
	fprintf_filtered (stream, "REF ");
	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	break;

      case TYPE_CODE_BOOL:
	/* FIXME: we should probably just print the TYPE_NAME, in case
	   anyone ever fixes the compiler to give us the real names
	   in the presence of the chill equivalent of typedef (assuming
	   there is one).  */
	fprintf_filtered (stream, "BOOL");
	break;

      case TYPE_CODE_ARRAY:
	range_type = TYPE_FIELD_TYPE (type, 0);
	index_type = TYPE_TARGET_TYPE (range_type);
	low_bound = TYPE_FIELD_BITPOS (range_type, 0);
	high_bound = TYPE_FIELD_BITPOS (range_type, 1);
        fputs_filtered ("ARRAY (", stream);
	print_type_scalar (index_type, low_bound, stream);
	fputs_filtered (":", stream);
	print_type_scalar (index_type, high_bound, stream);
	fputs_filtered (") ", stream);
	chill_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
	break;

      case TYPE_CODE_BITSTRING:
        fprintf_filtered (stream, "BOOLS (%d)",
			  TYPE_FIELD_BITPOS (TYPE_FIELD_TYPE(type,0), 1) + 1);
	break;

      case TYPE_CODE_SET:
        fputs_filtered ("POWERSET ", stream);
	chill_print_type (TYPE_FIELD_TYPE (type, 0), "", stream,
			  show - 1, level);
	break;

      case TYPE_CODE_STRING:
	range_type = TYPE_FIELD_TYPE (type, 0);
	index_type = TYPE_TARGET_TYPE (range_type);
	high_bound = TYPE_FIELD_BITPOS (range_type, 1);
        fputs_filtered ("CHARS (", stream);
	print_type_scalar (index_type, high_bound + 1, stream);
	fputs_filtered (")", stream);
	break;

      case TYPE_CODE_MEMBER:
	fprintf_filtered (stream, "MEMBER ");
        chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	break;
      case TYPE_CODE_REF:
	fprintf_filtered (stream, "/*LOC*/ ");
        chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	break;
      case TYPE_CODE_FUNC:
	fprintf_filtered (stream, "PROC (?)");
        chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	break;

      case TYPE_CODE_STRUCT:
	if (chill_is_varying_struct (type))
	  {
	    chill_type_print_base (TYPE_FIELD_TYPE (type, 1),
				   stream, show, level);
	    fputs_filtered (" VARYING", stream);
	  }
	else
	  {
	    fprintf_filtered (stream, "STRUCT ");

	    fprintf_filtered (stream, "(\n");
	    if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
	      {
		if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
		  {
		    fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
		  }
		else
		  {
		    fprintfi_filtered (level + 4, stream, "<no data fields>\n");
		  }
	      }
	    else
	      {
		len = TYPE_NFIELDS (type);
		for (i = TYPE_N_BASECLASSES (type); i < len; i++)
		  {
		    struct type *field_type = TYPE_FIELD_TYPE (type, i);
		    QUIT;
		    print_spaces_filtered (level + 4, stream);
		    if (TYPE_CODE (field_type) == TYPE_CODE_UNION)
		      { int j; /* variant number */
			fputs_filtered ("CASE OF\n", stream);
			for (j = 0; j < TYPE_NFIELDS (field_type); j++)
			  { int k; /* variant field index */
			    struct type *variant_type
			      = TYPE_FIELD_TYPE (field_type, j);
			    int var_len = TYPE_NFIELDS (variant_type);
			    print_spaces_filtered (level + 4, stream);
			    if (strcmp (TYPE_FIELD_NAME (field_type, j),
					"else") == 0)
			      fputs_filtered ("ELSE\n", stream);
			    else
			      fputs_filtered (":\n", stream);
			    if (TYPE_CODE (variant_type) != TYPE_CODE_STRUCT)
			      error ("variant record confusion");
			    for (k = 0; k < var_len; k++)
			      {
				print_spaces_filtered (level + 8, stream);
				chill_print_type (TYPE_FIELD_TYPE (variant_type, k),
						  TYPE_FIELD_NAME (variant_type, k),
						  stream, show - 1, level + 8);
				if (k < (var_len - 1))
				  fputs_filtered (",", stream);
				fputs_filtered ("\n", stream);
			      }
			  }
			fputs_filtered ("ESAC\n", stream);
		      }
		    else
		      chill_print_type (field_type,
					TYPE_FIELD_NAME (type, i),
					stream, show - 1, level + 4);
		    if (i < (len - 1))
		      {
			fputs_filtered (",", stream);
		      }
		    fputs_filtered ("\n", stream);
		  }
	      }
	    fprintfi_filtered (level, stream, ")");
	  }
	break;

      case TYPE_CODE_RANGE:
	if (TYPE_DUMMY_RANGE (type) > 0)
	  chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	else
	  {
	    struct type *target = TYPE_TARGET_TYPE (type);
	    if (target && TYPE_NAME (target))
	      fputs_filtered (TYPE_NAME (target), stream);
	    else
	      fputs_filtered ("RANGE", stream);
	    if (target == NULL)
	      target = builtin_type_long;
	    fputs_filtered (" (", stream);
	    print_type_scalar (target, TYPE_LOW_BOUND (type), stream);
	    fputs_filtered (":", stream);
	    print_type_scalar (target, TYPE_HIGH_BOUND (type), stream);
	    fputs_filtered (")", stream);
	  }
	break;

      case TYPE_CODE_ENUM:
	{
	  register int lastval = 0;
	  fprintf_filtered (stream, "SET (");
	  len = TYPE_NFIELDS (type);
	  for (i = 0; i < len; i++)
	    {
	      QUIT;
	      if (i) fprintf_filtered (stream, ", ");
	      wrap_here ("    ");
	      fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
	      if (lastval != TYPE_FIELD_BITPOS (type, i))
		{
		  fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
		  lastval = TYPE_FIELD_BITPOS (type, i);
		}
	      lastval++;
	    }
	  fprintf_filtered (stream, ")");
	}
	break;

      case TYPE_CODE_VOID:
      case TYPE_CODE_UNDEF:
      case TYPE_CODE_ERROR:
      case TYPE_CODE_UNION:
      case TYPE_CODE_METHOD:
	error ("missing language support in chill_type_print_base");
	break;

      default:

	/* Handle types not explicitly handled by the other cases,
	   such as fundamental types.  For these, just print whatever
	   the type name is, as recorded in the type itself.  If there
	   is no type name, then complain. */

	if (TYPE_NAME (type) != NULL)
	  {
	    fputs_filtered (TYPE_NAME (type), stream);
	  }
	else
	  {
	    error ("Unrecognized type code (%d) in symbol table.",
		   TYPE_CODE (type));
	  }
	break;
      }
}
Commit	Line	Data
a8a69e63 FF	1	/* Support for printing Chill types for GDB, the GNU debugger.
	2	Copyright 1986, 1988, 1989, 1991 Free Software Foundation, Inc.
	3
	4	This file is part of GDB.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
	19
	20	#include "defs.h"
	21	#include "obstack.h"
	22	#include "bfd.h" /* Binary File Description */
	23	#include "symtab.h"
	24	#include "gdbtypes.h"
	25	#include "expression.h"
	26	#include "value.h"
	27	#include "gdbcore.h"
	28	#include "target.h"
	29	#include "command.h"
	30	#include "gdbcmd.h"
	31	#include "language.h"
	32	#include "demangle.h"
	33	#include "ch-lang.h"
100f92e2	34	#include "typeprint.h"
a8a69e63 FF	35
	36	#include <string.h>
	37	#include <errno.h>
	38
8fbdca53	39	static void
199b2450	40	chill_type_print_base PARAMS ((struct type , GDB_FILE , int, int));
a8a69e63 FF	41
	42	void
	43	chill_print_type (type, varstring, stream, show, level)
	44	struct type *type;
	45	char *varstring;
199b2450	46	GDB_FILE *stream;
a8a69e63 FF	47	int show;
	48	int level;
	49	{
a8a69e63 FF	50	if (varstring != NULL && *varstring != '\0')
	51	{
	52	fputs_filtered (varstring, stream);
	53	fputs_filtered (" ", stream);
	54	}
8a177da6	55	chill_type_print_base (type, stream, show, level);
a8a69e63 FF	56	}
	57
	58	/* Print the name of the type (or the ultimate pointer target,
	59	function value or array element).
	60
	61	SHOW nonzero means don't print this type as just its name;
	62	show its real definition even if it has a name.
	63	SHOW zero means print just typename or tag if there is one
	64	SHOW negative means abbreviate structure elements.
	65	SHOW is decremented for printing of structure elements.
	66
	67	LEVEL is the depth to indent by.
	68	We increase it for some recursive calls. */
	69
8fbdca53 FF	70	static void
8fbdca53 FF	71	chill_type_print_base (type, stream, show, level)
a8a69e63	72	struct type *type;
199b2450	73	GDB_FILE *stream;
a8a69e63 FF	74	int show;
	75	int level;
	76	{
8fbdca53 FF	77	register int len;
8fbdca53 FF	78	register int i;
8a177da6 PB	79	struct type *index_type;
	80	struct type *range_type;
	81	LONGEST low_bound;
	82	LONGEST high_bound;
8fbdca53	83
a8a69e63 FF	84	QUIT;
	85
	86	wrap_here (" ");
	87	if (type == NULL)
	88	{
	89	fputs_filtered ("<type unknown>", stream);
	90	return;
	91	}
	92
	93	/* When SHOW is zero or less, and there is a valid type name, then always
	94	just print the type name directly from the type. */
	95
	96	if ((show <= 0) && (TYPE_NAME (type) != NULL))
	97	{
	98	fputs_filtered (TYPE_NAME (type), stream);
	99	return;
	100	}
	101
dda398c3 JK	102	check_stub_type (type);
dda398c3 JK	103
a8a69e63 FF	104	switch (TYPE_CODE (type))
a8a69e63 FF	105	{
a8a69e63	106	case TYPE_CODE_PTR:
8a177da6 PB	107	if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
	108	{
	109	fprintf_filtered (stream, "PTR");
	110	break;
	111	}
	112	fprintf_filtered (stream, "REF ");
	113	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	114	break;
	115
11b959da	116	case TYPE_CODE_BOOL:
61932a8e JK	117	/* FIXME: we should probably just print the TYPE_NAME, in case
	118	anyone ever fixes the compiler to give us the real names
	119	in the presence of the chill equivalent of typedef (assuming
	120	there is one). */
11b959da FF	121	fprintf_filtered (stream, "BOOL");
	122	break;
	123
8a177da6 PB	124	case TYPE_CODE_ARRAY:
	125	range_type = TYPE_FIELD_TYPE (type, 0);
	126	index_type = TYPE_TARGET_TYPE (range_type);
	127	low_bound = TYPE_FIELD_BITPOS (range_type, 0);
	128	high_bound = TYPE_FIELD_BITPOS (range_type, 1);
	129	fputs_filtered ("ARRAY (", stream);
	130	print_type_scalar (index_type, low_bound, stream);
	131	fputs_filtered (":", stream);
	132	print_type_scalar (index_type, high_bound, stream);
	133	fputs_filtered (") ", stream);
	134	chill_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
	135	break;
	136
cba00921 PB	137	case TYPE_CODE_BITSTRING:
	138	fprintf_filtered (stream, "BOOLS (%d)",
	139	TYPE_FIELD_BITPOS (TYPE_FIELD_TYPE(type,0), 1) + 1);
	140	break;
	141
e909f287 PB	142	case TYPE_CODE_SET:
e909f287 PB	143	fputs_filtered ("POWERSET ", stream);
cba00921 PB	144	chill_print_type (TYPE_FIELD_TYPE (type, 0), "", stream,
cba00921 PB	145	show - 1, level);
e909f287 PB	146	break;
e909f287 PB	147
8a177da6 PB	148	case TYPE_CODE_STRING:
	149	range_type = TYPE_FIELD_TYPE (type, 0);
	150	index_type = TYPE_TARGET_TYPE (range_type);
	151	high_bound = TYPE_FIELD_BITPOS (range_type, 1);
cba00921	152	fputs_filtered ("CHARS (", stream);
8a177da6 PB	153	print_type_scalar (index_type, high_bound + 1, stream);
	154	fputs_filtered (")", stream);
	155	break;
	156
a8a69e63	157	case TYPE_CODE_MEMBER:
8a177da6 PB	158	fprintf_filtered (stream, "MEMBER ");
	159	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	160	break;
a8a69e63	161	case TYPE_CODE_REF:
8a177da6 PB	162	fprintf_filtered (stream, "/LOC/ ");
	163	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	164	break;
a8a69e63	165	case TYPE_CODE_FUNC:
8a177da6	166	fprintf_filtered (stream, "PROC (?)");
8fbdca53 FF	167	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	168	break;
	169
	170	case TYPE_CODE_STRUCT:
cba00921	171	if (chill_is_varying_struct (type))
8fbdca53	172	{
cba00921 PB	173	chill_type_print_base (TYPE_FIELD_TYPE (type, 1),
	174	stream, show, level);
	175	fputs_filtered (" VARYING", stream);
8fbdca53 FF	176	}
	177	else
	178	{
cba00921 PB	179	fprintf_filtered (stream, "STRUCT ");
cba00921 PB	180
8fbdca53 FF	181	fprintf_filtered (stream, "(\n");
	182	if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
	183	{
	184	if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
	185	{
	186	fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
	187	}
	188	else
	189	{
	190	fprintfi_filtered (level + 4, stream, "<no data fields>\n");
	191	}
	192	}
	193	else
	194	{
	195	len = TYPE_NFIELDS (type);
	196	for (i = TYPE_N_BASECLASSES (type); i < len; i++)
	197	{
11b959da	198	struct type *field_type = TYPE_FIELD_TYPE (type, i);
8fbdca53 FF	199	QUIT;
8fbdca53 FF	200	print_spaces_filtered (level + 4, stream);
11b959da FF	201	if (TYPE_CODE (field_type) == TYPE_CODE_UNION)
	202	{ int j; /* variant number */
	203	fputs_filtered ("CASE OF\n", stream);
	204	for (j = 0; j < TYPE_NFIELDS (field_type); j++)
	205	{ int k; /* variant field index */
	206	struct type *variant_type
	207	= TYPE_FIELD_TYPE (field_type, j);
	208	int var_len = TYPE_NFIELDS (variant_type);
	209	print_spaces_filtered (level + 4, stream);
	210	if (strcmp (TYPE_FIELD_NAME (field_type, j),
	211	"else") == 0)
	212	fputs_filtered ("ELSE\n", stream);
	213	else
	214	fputs_filtered (":\n", stream);
	215	if (TYPE_CODE (variant_type) != TYPE_CODE_STRUCT)
	216	error ("variant record confusion");
	217	for (k = 0; k < var_len; k++)
	218	{
	219	print_spaces_filtered (level + 8, stream);
	220	chill_print_type (TYPE_FIELD_TYPE (variant_type, k),
	221	TYPE_FIELD_NAME (variant_type, k),
	222	stream, show - 1, level + 8);
	223	if (k < (var_len - 1))
	224	fputs_filtered (",", stream);
	225	fputs_filtered ("\n", stream);
	226	}
	227	}
	228	fputs_filtered ("ESAC\n", stream);
	229	}
	230	else
	231	chill_print_type (field_type,
	232	TYPE_FIELD_NAME (type, i),
	233	stream, show - 1, level + 4);
8fbdca53 FF	234	if (i < (len - 1))
	235	{
	236	fputs_filtered (",", stream);
	237	}
	238	fputs_filtered ("\n", stream);
	239	}
	240	}
	241	fprintfi_filtered (level, stream, ")");
	242	}
a8a69e63 FF	243	break;
a8a69e63 FF	244
11b959da	245	case TYPE_CODE_RANGE:
42fca93e PB	246	if (TYPE_DUMMY_RANGE (type) > 0)
	247	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	248	else
11b959da	249	{
42fca93e PB	250	struct type *target = TYPE_TARGET_TYPE (type);
	251	if (target && TYPE_NAME (target))
	252	fputs_filtered (TYPE_NAME (target), stream);
	253	else
	254	fputs_filtered ("RANGE", stream);
	255	if (target == NULL)
	256	target = builtin_type_long;
11b959da	257	fputs_filtered (" (", stream);
42fca93e	258	print_type_scalar (target, TYPE_LOW_BOUND (type), stream);
11b959da	259	fputs_filtered (":", stream);
42fca93e	260	print_type_scalar (target, TYPE_HIGH_BOUND (type), stream);
11b959da FF	261	fputs_filtered (")", stream);
11b959da FF	262	}
11b959da FF	263	break;
11b959da FF	264
cba00921 PB	265	case TYPE_CODE_ENUM:
	266	{
	267	register int lastval = 0;
	268	fprintf_filtered (stream, "SET (");
	269	len = TYPE_NFIELDS (type);
	270	for (i = 0; i < len; i++)
	271	{
	272	QUIT;
	273	if (i) fprintf_filtered (stream, ", ");
	274	wrap_here (" ");
	275	fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
	276	if (lastval != TYPE_FIELD_BITPOS (type, i))
	277	{
	278	fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
	279	lastval = TYPE_FIELD_BITPOS (type, i);
	280	}
	281	lastval++;
	282	}
	283	fprintf_filtered (stream, ")");
	284	}
	285	break;
	286
a8a69e63 FF	287	case TYPE_CODE_VOID:
	288	case TYPE_CODE_UNDEF:
	289	case TYPE_CODE_ERROR:
a8a69e63	290	case TYPE_CODE_UNION:
a8a69e63	291	case TYPE_CODE_METHOD:
8fbdca53	292	error ("missing language support in chill_type_print_base");
a8a69e63 FF	293	break;
	294
	295	default:
	296
	297	/* Handle types not explicitly handled by the other cases,
	298	such as fundamental types. For these, just print whatever
	299	the type name is, as recorded in the type itself. If there
	300	is no type name, then complain. */
	301
	302	if (TYPE_NAME (type) != NULL)
	303	{
	304	fputs_filtered (TYPE_NAME (type), stream);
	305	}
	306	else
	307	{
	308	error ("Unrecognized type code (%d) in symbol table.",
	309	TYPE_CODE (type));
	310	}
	311	break;
	312	}
	313	}