[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;
{
  char *name;
  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:
	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_SET:
        fputs_filtered ("POWERSET ", stream);
	chill_print_type (TYPE_FIELD_TYPE (type, 0), "", stream, show, 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 ("CHAR (", 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:
	fprintf_filtered (stream, "STRUCT ");
	if ((name = type_name_no_tag (type)) != NULL)
	  {
	    fputs_filtered (name, stream);
	    fputs_filtered (" ", stream);
	    wrap_here ("    ");
	  }
	if (show < 0)
	  {
	    fprintf_filtered (stream, "(...)");
	  }
	else
	  {
	    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_TARGET_TYPE (type))
	  {
	    chill_type_print_base (TYPE_TARGET_TYPE (type),
				   stream, show, level);
	    fputs_filtered (" (", stream);
	    print_type_scalar (TYPE_TARGET_TYPE (type),
			       TYPE_FIELD_BITPOS (type, 0), stream);
	    fputs_filtered (":", stream);
	    print_type_scalar (TYPE_TARGET_TYPE (type),
			       TYPE_FIELD_BITPOS (type, 1), stream);
	    fputs_filtered (")", stream);
	  }
	else
	  fprintf_filtered (stream, "RANGE? (%s : %d)",
			    TYPE_FIELD_BITPOS (type, 0),
			    TYPE_FIELD_BITPOS (type, 1));
	break;

      case TYPE_CODE_VOID:
      case TYPE_CODE_UNDEF:
      case TYPE_CODE_ERROR:
      case TYPE_CODE_ENUM:
      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	char *name;
	78	register int len;
	79	register int i;
8a177da6 PB	80	struct type *index_type;
	81	struct type *range_type;
	82	LONGEST low_bound;
	83	LONGEST high_bound;
8fbdca53	84
a8a69e63 FF	85	QUIT;
	86
	87	wrap_here (" ");
	88	if (type == NULL)
	89	{
	90	fputs_filtered ("<type unknown>", stream);
	91	return;
	92	}
	93
	94	/* When SHOW is zero or less, and there is a valid type name, then always
	95	just print the type name directly from the type. */
	96
	97	if ((show <= 0) && (TYPE_NAME (type) != NULL))
	98	{
	99	fputs_filtered (TYPE_NAME (type), stream);
	100	return;
	101	}
	102
dda398c3 JK	103	check_stub_type (type);
dda398c3 JK	104
a8a69e63 FF	105	switch (TYPE_CODE (type))
a8a69e63 FF	106	{
a8a69e63	107	case TYPE_CODE_PTR:
8a177da6 PB	108	if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
	109	{
	110	fprintf_filtered (stream, "PTR");
	111	break;
	112	}
	113	fprintf_filtered (stream, "REF ");
	114	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	115	break;
	116
11b959da FF	117	case TYPE_CODE_BOOL:
	118	fprintf_filtered (stream, "BOOL");
	119	break;
	120
8a177da6 PB	121	case TYPE_CODE_ARRAY:
	122	range_type = TYPE_FIELD_TYPE (type, 0);
	123	index_type = TYPE_TARGET_TYPE (range_type);
	124	low_bound = TYPE_FIELD_BITPOS (range_type, 0);
	125	high_bound = TYPE_FIELD_BITPOS (range_type, 1);
	126	fputs_filtered ("ARRAY (", stream);
	127	print_type_scalar (index_type, low_bound, stream);
	128	fputs_filtered (":", stream);
	129	print_type_scalar (index_type, high_bound, stream);
	130	fputs_filtered (") ", stream);
	131	chill_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
	132	break;
	133
e909f287 PB	134	case TYPE_CODE_SET:
	135	fputs_filtered ("POWERSET ", stream);
	136	chill_print_type (TYPE_FIELD_TYPE (type, 0), "", stream, show, level);
	137	break;
	138
8a177da6 PB	139	case TYPE_CODE_STRING:
	140	range_type = TYPE_FIELD_TYPE (type, 0);
	141	index_type = TYPE_TARGET_TYPE (range_type);
	142	high_bound = TYPE_FIELD_BITPOS (range_type, 1);
	143	fputs_filtered ("CHAR (", stream);
	144	print_type_scalar (index_type, high_bound + 1, stream);
	145	fputs_filtered (")", stream);
	146	break;
	147
a8a69e63	148	case TYPE_CODE_MEMBER:
8a177da6 PB	149	fprintf_filtered (stream, "MEMBER ");
	150	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	151	break;
a8a69e63	152	case TYPE_CODE_REF:
8a177da6 PB	153	fprintf_filtered (stream, "/LOC/ ");
	154	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	155	break;
a8a69e63	156	case TYPE_CODE_FUNC:
8a177da6	157	fprintf_filtered (stream, "PROC (?)");
8fbdca53 FF	158	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	159	break;
	160
	161	case TYPE_CODE_STRUCT:
	162	fprintf_filtered (stream, "STRUCT ");
	163	if ((name = type_name_no_tag (type)) != NULL)
	164	{
	165	fputs_filtered (name, stream);
	166	fputs_filtered (" ", stream);
	167	wrap_here (" ");
	168	}
	169	if (show < 0)
	170	{
	171	fprintf_filtered (stream, "(...)");
	172	}
	173	else
	174	{
8fbdca53 FF	175	fprintf_filtered (stream, "(\n");
	176	if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
	177	{
	178	if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
	179	{
	180	fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
	181	}
	182	else
	183	{
	184	fprintfi_filtered (level + 4, stream, "<no data fields>\n");
	185	}
	186	}
	187	else
	188	{
	189	len = TYPE_NFIELDS (type);
	190	for (i = TYPE_N_BASECLASSES (type); i < len; i++)
	191	{
11b959da	192	struct type *field_type = TYPE_FIELD_TYPE (type, i);
8fbdca53 FF	193	QUIT;
8fbdca53 FF	194	print_spaces_filtered (level + 4, stream);
11b959da FF	195	if (TYPE_CODE (field_type) == TYPE_CODE_UNION)
	196	{ int j; /* variant number */
	197	fputs_filtered ("CASE OF\n", stream);
	198	for (j = 0; j < TYPE_NFIELDS (field_type); j++)
	199	{ int k; /* variant field index */
	200	struct type *variant_type
	201	= TYPE_FIELD_TYPE (field_type, j);
	202	int var_len = TYPE_NFIELDS (variant_type);
	203	print_spaces_filtered (level + 4, stream);
	204	if (strcmp (TYPE_FIELD_NAME (field_type, j),
	205	"else") == 0)
	206	fputs_filtered ("ELSE\n", stream);
	207	else
	208	fputs_filtered (":\n", stream);
	209	if (TYPE_CODE (variant_type) != TYPE_CODE_STRUCT)
	210	error ("variant record confusion");
	211	for (k = 0; k < var_len; k++)
	212	{
	213	print_spaces_filtered (level + 8, stream);
	214	chill_print_type (TYPE_FIELD_TYPE (variant_type, k),
	215	TYPE_FIELD_NAME (variant_type, k),
	216	stream, show - 1, level + 8);
	217	if (k < (var_len - 1))
	218	fputs_filtered (",", stream);
	219	fputs_filtered ("\n", stream);
	220	}
	221	}
	222	fputs_filtered ("ESAC\n", stream);
	223	}
	224	else
	225	chill_print_type (field_type,
	226	TYPE_FIELD_NAME (type, i),
	227	stream, show - 1, level + 4);
8fbdca53 FF	228	if (i < (len - 1))
	229	{
	230	fputs_filtered (",", stream);
	231	}
	232	fputs_filtered ("\n", stream);
	233	}
	234	}
	235	fprintfi_filtered (level, stream, ")");
	236	}
a8a69e63 FF	237	break;
a8a69e63 FF	238
11b959da FF	239	case TYPE_CODE_RANGE:
	240	if (TYPE_TARGET_TYPE (type))
	241	{
	242	chill_type_print_base (TYPE_TARGET_TYPE (type),
	243	stream, show, level);
	244	fputs_filtered (" (", stream);
	245	print_type_scalar (TYPE_TARGET_TYPE (type),
	246	TYPE_FIELD_BITPOS (type, 0), stream);
	247	fputs_filtered (":", stream);
	248	print_type_scalar (TYPE_TARGET_TYPE (type),
	249	TYPE_FIELD_BITPOS (type, 1), stream);
	250	fputs_filtered (")", stream);
	251	}
	252	else
	253	fprintf_filtered (stream, "RANGE? (%s : %d)",
	254	TYPE_FIELD_BITPOS (type, 0),
	255	TYPE_FIELD_BITPOS (type, 1));
	256	break;
	257
a8a69e63 FF	258	case TYPE_CODE_VOID:
	259	case TYPE_CODE_UNDEF:
	260	case TYPE_CODE_ERROR:
a8a69e63 FF	261	case TYPE_CODE_ENUM:
a8a69e63 FF	262	case TYPE_CODE_UNION:
a8a69e63	263	case TYPE_CODE_METHOD:
8fbdca53	264	error ("missing language support in chill_type_print_base");
a8a69e63 FF	265	break;
	266
	267	default:
	268
	269	/* Handle types not explicitly handled by the other cases,
	270	such as fundamental types. For these, just print whatever
	271	the type name is, as recorded in the type itself. If there
	272	is no type name, then complain. */
	273
	274	if (TYPE_NAME (type) != NULL)
	275	{
	276	fputs_filtered (TYPE_NAME (type), stream);
	277	}
	278	else
	279	{
	280	error ("Unrecognized type code (%d) in symbol table.",
	281	TYPE_CODE (type));
	282	}
	283	break;
	284	}
	285	}