[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,
			      TYPE_NAME (type) ? TYPE_NAME (type) : "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,
			  TYPE_NAME (type) ? TYPE_NAME (type) : "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_INDEX_TYPE (type), "", 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 (");
	len = TYPE_NFIELDS (type);
	for (i = 0; i < len; i++)
	  {
	    struct type *param_type = TYPE_FIELD_TYPE (type, i);
	    if (i > 0)
	      {
		fputs_filtered (", ", stream);
		wrap_here ("    ");
	      }
	    if (TYPE_CODE (param_type) == TYPE_CODE_REF)
	      {
		chill_type_print_base (TYPE_TARGET_TYPE (param_type),
				       stream, show, level);
		fputs_filtered (" LOC", stream);
	      }
	    else
	      chill_type_print_base (param_type, stream, show, level);
	  }
	fprintf_filtered (stream, ")");
	if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
	  {
	    fputs_filtered (" RETURNS (", stream);
	    chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	    fputs_filtered (")", stream);
	  }
	break;

      case TYPE_CODE_STRUCT:
	if (chill_varying_type (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)
8a177da6 PB	108	{
3bcf4181 PB	109	fprintf_filtered (stream,
3bcf4181 PB	110	TYPE_NAME (type) ? TYPE_NAME (type) : "PTR");
8a177da6 PB	111	break;
	112	}
	113	fprintf_filtered (stream, "REF ");
	114	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	115	break;
	116
11b959da	117	case TYPE_CODE_BOOL:
61932a8e JK	118	/* FIXME: we should probably just print the TYPE_NAME, in case
	119	anyone ever fixes the compiler to give us the real names
	120	in the presence of the chill equivalent of typedef (assuming
	121	there is one). */
3bcf4181 PB	122	fprintf_filtered (stream,
3bcf4181 PB	123	TYPE_NAME (type) ? TYPE_NAME (type) : "BOOL");
11b959da FF	124	break;
11b959da FF	125
8a177da6 PB	126	case TYPE_CODE_ARRAY:
	127	range_type = TYPE_FIELD_TYPE (type, 0);
	128	index_type = TYPE_TARGET_TYPE (range_type);
	129	low_bound = TYPE_FIELD_BITPOS (range_type, 0);
	130	high_bound = TYPE_FIELD_BITPOS (range_type, 1);
	131	fputs_filtered ("ARRAY (", stream);
	132	print_type_scalar (index_type, low_bound, stream);
	133	fputs_filtered (":", stream);
	134	print_type_scalar (index_type, high_bound, stream);
	135	fputs_filtered (") ", stream);
	136	chill_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
	137	break;
	138
cba00921 PB	139	case TYPE_CODE_BITSTRING:
	140	fprintf_filtered (stream, "BOOLS (%d)",
	141	TYPE_FIELD_BITPOS (TYPE_FIELD_TYPE(type,0), 1) + 1);
	142	break;
	143
e909f287 PB	144	case TYPE_CODE_SET:
e909f287 PB	145	fputs_filtered ("POWERSET ", stream);
6f52d064	146	chill_print_type (TYPE_INDEX_TYPE (type), "", stream,
cba00921	147	show - 1, level);
e909f287 PB	148	break;
e909f287 PB	149
8a177da6 PB	150	case TYPE_CODE_STRING:
	151	range_type = TYPE_FIELD_TYPE (type, 0);
	152	index_type = TYPE_TARGET_TYPE (range_type);
	153	high_bound = TYPE_FIELD_BITPOS (range_type, 1);
cba00921	154	fputs_filtered ("CHARS (", stream);
8a177da6 PB	155	print_type_scalar (index_type, high_bound + 1, stream);
	156	fputs_filtered (")", stream);
	157	break;
	158
a8a69e63	159	case TYPE_CODE_MEMBER:
8a177da6 PB	160	fprintf_filtered (stream, "MEMBER ");
	161	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	162	break;
a8a69e63	163	case TYPE_CODE_REF:
8a177da6 PB	164	fprintf_filtered (stream, "/LOC/ ");
	165	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	166	break;
a8a69e63	167	case TYPE_CODE_FUNC:
27202b6a PB	168	fprintf_filtered (stream, "PROC (");
	169	len = TYPE_NFIELDS (type);
	170	for (i = 0; i < len; i++)
	171	{
	172	struct type *param_type = TYPE_FIELD_TYPE (type, i);
	173	if (i > 0)
	174	{
	175	fputs_filtered (", ", stream);
	176	wrap_here (" ");
	177	}
	178	if (TYPE_CODE (param_type) == TYPE_CODE_REF)
	179	{
	180	chill_type_print_base (TYPE_TARGET_TYPE (param_type),
	181	stream, show, level);
	182	fputs_filtered (" LOC", stream);
	183	}
	184	else
	185	chill_type_print_base (param_type, stream, show, level);
	186	}
	187	fprintf_filtered (stream, ")");
6d34c236 PB	188	if (TYPE_CODE (TYPE_TARGET_TYPE (type)) != TYPE_CODE_VOID)
	189	{
	190	fputs_filtered (" RETURNS (", stream);
	191	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	192	fputs_filtered (")", stream);
	193	}
8fbdca53 FF	194	break;
	195
	196	case TYPE_CODE_STRUCT:
6073b8de	197	if (chill_varying_type (type))
8fbdca53	198	{
cba00921 PB	199	chill_type_print_base (TYPE_FIELD_TYPE (type, 1),
	200	stream, show, level);
	201	fputs_filtered (" VARYING", stream);
8fbdca53 FF	202	}
	203	else
	204	{
cba00921 PB	205	fprintf_filtered (stream, "STRUCT ");
cba00921 PB	206
8fbdca53 FF	207	fprintf_filtered (stream, "(\n");
	208	if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
	209	{
	210	if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
	211	{
	212	fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
	213	}
	214	else
	215	{
	216	fprintfi_filtered (level + 4, stream, "<no data fields>\n");
	217	}
	218	}
	219	else
	220	{
	221	len = TYPE_NFIELDS (type);
	222	for (i = TYPE_N_BASECLASSES (type); i < len; i++)
	223	{
11b959da	224	struct type *field_type = TYPE_FIELD_TYPE (type, i);
8fbdca53 FF	225	QUIT;
8fbdca53 FF	226	print_spaces_filtered (level + 4, stream);
11b959da FF	227	if (TYPE_CODE (field_type) == TYPE_CODE_UNION)
	228	{ int j; /* variant number */
	229	fputs_filtered ("CASE OF\n", stream);
	230	for (j = 0; j < TYPE_NFIELDS (field_type); j++)
	231	{ int k; /* variant field index */
	232	struct type *variant_type
	233	= TYPE_FIELD_TYPE (field_type, j);
	234	int var_len = TYPE_NFIELDS (variant_type);
	235	print_spaces_filtered (level + 4, stream);
	236	if (strcmp (TYPE_FIELD_NAME (field_type, j),
	237	"else") == 0)
	238	fputs_filtered ("ELSE\n", stream);
	239	else
	240	fputs_filtered (":\n", stream);
	241	if (TYPE_CODE (variant_type) != TYPE_CODE_STRUCT)
	242	error ("variant record confusion");
	243	for (k = 0; k < var_len; k++)
	244	{
	245	print_spaces_filtered (level + 8, stream);
	246	chill_print_type (TYPE_FIELD_TYPE (variant_type, k),
	247	TYPE_FIELD_NAME (variant_type, k),
	248	stream, show - 1, level + 8);
	249	if (k < (var_len - 1))
	250	fputs_filtered (",", stream);
	251	fputs_filtered ("\n", stream);
	252	}
	253	}
	254	fputs_filtered ("ESAC\n", stream);
	255	}
	256	else
	257	chill_print_type (field_type,
	258	TYPE_FIELD_NAME (type, i),
	259	stream, show - 1, level + 4);
8fbdca53 FF	260	if (i < (len - 1))
	261	{
	262	fputs_filtered (",", stream);
	263	}
	264	fputs_filtered ("\n", stream);
	265	}
	266	}
	267	fprintfi_filtered (level, stream, ")");
	268	}
a8a69e63 FF	269	break;
a8a69e63 FF	270
11b959da	271	case TYPE_CODE_RANGE:
42fca93e PB	272	if (TYPE_DUMMY_RANGE (type) > 0)
	273	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	274	else
11b959da	275	{
42fca93e PB	276	struct type *target = TYPE_TARGET_TYPE (type);
	277	if (target && TYPE_NAME (target))
	278	fputs_filtered (TYPE_NAME (target), stream);
	279	else
	280	fputs_filtered ("RANGE", stream);
	281	if (target == NULL)
	282	target = builtin_type_long;
11b959da	283	fputs_filtered (" (", stream);
42fca93e	284	print_type_scalar (target, TYPE_LOW_BOUND (type), stream);
11b959da	285	fputs_filtered (":", stream);
42fca93e	286	print_type_scalar (target, TYPE_HIGH_BOUND (type), stream);
11b959da FF	287	fputs_filtered (")", stream);
11b959da FF	288	}
11b959da FF	289	break;
11b959da FF	290
cba00921 PB	291	case TYPE_CODE_ENUM:
	292	{
	293	register int lastval = 0;
	294	fprintf_filtered (stream, "SET (");
	295	len = TYPE_NFIELDS (type);
	296	for (i = 0; i < len; i++)
	297	{
	298	QUIT;
	299	if (i) fprintf_filtered (stream, ", ");
	300	wrap_here (" ");
	301	fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
	302	if (lastval != TYPE_FIELD_BITPOS (type, i))
	303	{
	304	fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
	305	lastval = TYPE_FIELD_BITPOS (type, i);
	306	}
	307	lastval++;
	308	}
	309	fprintf_filtered (stream, ")");
	310	}
	311	break;
	312
a8a69e63 FF	313	case TYPE_CODE_VOID:
	314	case TYPE_CODE_UNDEF:
	315	case TYPE_CODE_ERROR:
a8a69e63	316	case TYPE_CODE_UNION:
a8a69e63	317	case TYPE_CODE_METHOD:
8fbdca53	318	error ("missing language support in chill_type_print_base");
a8a69e63 FF	319	break;
	320
	321	default:
	322
	323	/* Handle types not explicitly handled by the other cases,
	324	such as fundamental types. For these, just print whatever
	325	the type name is, as recorded in the type itself. If there
	326	is no type name, then complain. */
	327
	328	if (TYPE_NAME (type) != NULL)
	329	{
	330	fputs_filtered (TYPE_NAME (type), stream);
	331	}
	332	else
	333	{
	334	error ("Unrecognized type code (%d) in symbol table.",
	335	TYPE_CODE (type));
	336	}
	337	break;
	338	}
	339	}