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

/* Support for printing Chill types for GDB, the GNU debugger.
   Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 2000
   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., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, 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 "language.h"
#include "ch-lang.h"
#include "typeprint.h"

#include "gdb_string.h"
#include <errno.h>

static void chill_type_print_base (struct type *, struct ui_file *, int, int);

void
chill_print_type (struct type *type, char *varstring, struct ui_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 (struct type *type, struct ui_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;
    }

  if (TYPE_CODE (type) != TYPE_CODE_TYPEDEF)
    CHECK_TYPEDEF (type);

  switch (TYPE_CODE (type))
    {
    case TYPE_CODE_TYPEDEF:
      chill_type_print_base (TYPE_TARGET_TYPE (type), stream, 0, level);
      break;
    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, 0, 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:
      fputs_filtered ("ARRAY (", stream);
      range_type = TYPE_FIELD_TYPE (type, 0);
      if (TYPE_CODE (range_type) != TYPE_CODE_RANGE)
	chill_print_type (range_type, "", stream, 0, level);
      else
	{
	  index_type = TYPE_TARGET_TYPE (range_type);
	  low_bound = TYPE_FIELD_BITPOS (range_type, 0);
	  high_bound = TYPE_FIELD_BITPOS (range_type, 1);
	  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, 0, 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, 0, 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, 0, 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, 0, level);
	  fputs_filtered (")", stream);
	}
      break;

    case TYPE_CODE_STRUCT:
      if (chill_varying_type (type))
	{
	  chill_type_print_base (TYPE_FIELD_TYPE (type, 1),
				 stream, 0, 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_STUB (type))
		{
		  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);
			    }
			}
		      print_spaces_filtered (level + 4, stream);
		      fputs_filtered ("ESAC", 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:
      {
	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
c906108c	1	/* Support for printing Chill types for GDB, the GNU debugger.
b6ba6518 KB	2	Copyright 1986, 1988, 1989, 1991, 1992, 1993, 1994, 1995, 2000
b6ba6518 KB	3	Free Software Foundation, Inc.
c906108c	4
c5aa993b	5	This file is part of GDB.
c906108c	6
c5aa993b JM	7	This program is free software; you can redistribute it and/or modify
	8	it under the terms of the GNU General Public License as published by
	9	the Free Software Foundation; either version 2 of the License, or
	10	(at your option) any later version.
c906108c	11
c5aa993b JM	12	This program is distributed in the hope that it will be useful,
	13	but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	GNU General Public License for more details.
c906108c	16
c5aa993b JM	17	You should have received a copy of the GNU General Public License
	18	along with this program; if not, write to the Free Software
	19	Foundation, Inc., 59 Temple Place - Suite 330,
	20	Boston, MA 02111-1307, USA. */
c906108c SS	21
	22	#include "defs.h"
	23	#include "obstack.h"
	24	#include "bfd.h" /* Binary File Description */
	25	#include "symtab.h"
	26	#include "gdbtypes.h"
	27	#include "expression.h"
	28	#include "value.h"
	29	#include "gdbcore.h"
	30	#include "target.h"
c906108c	31	#include "language.h"
c906108c SS	32	#include "ch-lang.h"
	33	#include "typeprint.h"
	34
	35	#include "gdb_string.h"
	36	#include <errno.h>
	37
d9fcf2fb	38	static void chill_type_print_base (struct type , struct ui_file , int, int);
c906108c SS	39
c906108c SS	40	void
fba45db2 KB	41	chill_print_type (struct type type, char varstring, struct ui_file *stream,
fba45db2 KB	42	int show, int level)
c906108c SS	43	{
	44	if (varstring != NULL && *varstring != '\0')
	45	{
	46	fputs_filtered (varstring, stream);
	47	fputs_filtered (" ", stream);
	48	}
	49	chill_type_print_base (type, stream, show, level);
	50	}
	51
	52	/* Print the name of the type (or the ultimate pointer target,
	53	function value or array element).
	54
	55	SHOW nonzero means don't print this type as just its name;
	56	show its real definition even if it has a name.
	57	SHOW zero means print just typename or tag if there is one
	58	SHOW negative means abbreviate structure elements.
	59	SHOW is decremented for printing of structure elements.
	60
	61	LEVEL is the depth to indent by.
	62	We increase it for some recursive calls. */
	63
	64	static void
fba45db2 KB	65	chill_type_print_base (struct type type, struct ui_file stream, int show,
fba45db2 KB	66	int level)
c906108c SS	67	{
	68	register int len;
	69	register int i;
	70	struct type *index_type;
	71	struct type *range_type;
	72	LONGEST low_bound;
	73	LONGEST high_bound;
	74
	75	QUIT;
	76
	77	wrap_here (" ");
	78	if (type == NULL)
	79	{
	80	fputs_filtered ("<type unknown>", stream);
	81	return;
	82	}
	83
	84	/* When SHOW is zero or less, and there is a valid type name, then always
	85	just print the type name directly from the type. */
	86
	87	if ((show <= 0) && (TYPE_NAME (type) != NULL))
	88	{
	89	fputs_filtered (TYPE_NAME (type), stream);
	90	return;
	91	}
	92
	93	if (TYPE_CODE (type) != TYPE_CODE_TYPEDEF)
	94	CHECK_TYPEDEF (type);
	95
	96	switch (TYPE_CODE (type))
	97	{
c5aa993b JM	98	case TYPE_CODE_TYPEDEF:
	99	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, 0, level);
	100	break;
	101	case TYPE_CODE_PTR:
	102	if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
	103	{
	104	fprintf_filtered (stream,
	105	TYPE_NAME (type) ? TYPE_NAME (type) : "PTR");
	106	break;
	107	}
	108	fprintf_filtered (stream, "REF ");
	109	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, 0, level);
	110	break;
	111
	112	case TYPE_CODE_BOOL:
	113	/* FIXME: we should probably just print the TYPE_NAME, in case
	114	anyone ever fixes the compiler to give us the real names
	115	in the presence of the chill equivalent of typedef (assuming
	116	there is one). */
	117	fprintf_filtered (stream,
	118	TYPE_NAME (type) ? TYPE_NAME (type) : "BOOL");
	119	break;
	120
	121	case TYPE_CODE_ARRAY:
	122	fputs_filtered ("ARRAY (", stream);
	123	range_type = TYPE_FIELD_TYPE (type, 0);
	124	if (TYPE_CODE (range_type) != TYPE_CODE_RANGE)
	125	chill_print_type (range_type, "", stream, 0, level);
	126	else
	127	{
	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	print_type_scalar (index_type, low_bound, stream);
	132	fputs_filtered (":", stream);
	133	print_type_scalar (index_type, high_bound, stream);
	134	}
	135	fputs_filtered (") ", stream);
	136	chill_print_type (TYPE_TARGET_TYPE (type), "", stream, 0, level);
	137	break;
	138
	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
	144	case TYPE_CODE_SET:
	145	fputs_filtered ("POWERSET ", stream);
	146	chill_print_type (TYPE_INDEX_TYPE (type), "", stream,
	147	show - 1, level);
	148	break;
	149
	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);
	154	fputs_filtered ("CHARS (", stream);
	155	print_type_scalar (index_type, high_bound + 1, stream);
	156	fputs_filtered (")", stream);
	157	break;
	158
	159	case TYPE_CODE_MEMBER:
	160	fprintf_filtered (stream, "MEMBER ");
	161	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, 0, level);
162	break;
163	case TYPE_CODE_REF:
164	fprintf_filtered (stream, "/LOC/ ");
165	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
166	break;
167	case TYPE_CODE_FUNC:
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, 0, level);
182	fputs_filtered (" LOC", stream);
183	}
184	else
185	chill_type_print_base (param_type, stream, show, level);
186	}
187	fprintf_filtered (stream, ")");
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, 0, level);
192	fputs_filtered (")", stream);
193	}
194	break;
195
196	case TYPE_CODE_STRUCT:
197	if (chill_varying_type (type))
198	{
199	chill_type_print_base (TYPE_FIELD_TYPE (type, 1),
200	stream, 0, level);
201	fputs_filtered (" VARYING", stream);
202	}
203	else
204	{
205	fprintf_filtered (stream, "STRUCT ");
206
207	fprintf_filtered (stream, "(\n");
208	if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
209	{
74a9bb82	210	if (TYPE_STUB (type))
c5aa993b JM	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	{
	224	struct type *field_type = TYPE_FIELD_TYPE (type, i);
	225	QUIT;
	226	print_spaces_filtered (level + 4, stream);
	227	if (TYPE_CODE (field_type) == TYPE_CODE_UNION)
	228	{
	229	int j; /* variant number */
	230	fputs_filtered ("CASE OF\n", stream);
	231	for (j = 0; j < TYPE_NFIELDS (field_type); j++)
	232	{
	233	int k; /* variant field index */
	234	struct type *variant_type
	235	= TYPE_FIELD_TYPE (field_type, j);
	236	int var_len = TYPE_NFIELDS (variant_type);
	237	print_spaces_filtered (level + 4, stream);
	238	if (strcmp (TYPE_FIELD_NAME (field_type, j),
	239	"else") == 0)
	240	fputs_filtered ("ELSE\n", stream);
	241	else
	242	fputs_filtered (":\n", stream);
	243	if (TYPE_CODE (variant_type) != TYPE_CODE_STRUCT)
	244	error ("variant record confusion");
	245	for (k = 0; k < var_len; k++)
	246	{
	247	print_spaces_filtered (level + 8, stream);
	248	chill_print_type (TYPE_FIELD_TYPE (variant_type, k),
	249	TYPE_FIELD_NAME (variant_type, k),
	250	stream, show - 1, level + 8);
	251	if (k < (var_len - 1))
	252	fputs_filtered (",", stream);
	253	fputs_filtered ("\n", stream);
	254	}
	255	}
	256	print_spaces_filtered (level + 4, stream);
	257	fputs_filtered ("ESAC", stream);
	258	}
	259	else
	260	chill_print_type (field_type,
	261	TYPE_FIELD_NAME (type, i),
	262	stream, show - 1, level + 4);
	263	if (i < (len - 1))
	264	{
	265	fputs_filtered (",", stream);
	266	}
	267	fputs_filtered ("\n", stream);
	268	}
	269	}
	270	fprintfi_filtered (level, stream, ")");
	271	}
	272	break;
	273
	274	case TYPE_CODE_RANGE:
275	{
276	struct type *target = TYPE_TARGET_TYPE (type);
277	if (target && TYPE_NAME (target))
278	fputs_filtered (TYPE_NAME (target), stream);
c906108c	279	else
c5aa993b JM	280	fputs_filtered ("RANGE", stream);
	281	if (target == NULL)
	282	target = builtin_type_long;
	283	fputs_filtered (" (", stream);
	284	print_type_scalar (target, TYPE_LOW_BOUND (type), stream);
	285	fputs_filtered (":", stream);
	286	print_type_scalar (target, TYPE_HIGH_BOUND (type), stream);
c906108c	287	fputs_filtered (")", stream);
c5aa993b JM	288	}
	289	break;
	290
	291	case TYPE_CODE_ENUM:
	292	{
	293	register int lastval = 0;
	294	fprintf_filtered (stream, "SET (");
c906108c SS	295	len = TYPE_NFIELDS (type);
	296	for (i = 0; i < len; i++)
	297	{
c5aa993b JM	298	QUIT;
	299	if (i)
	300	fprintf_filtered (stream, ", ");
	301	wrap_here (" ");
	302	fputs_filtered (TYPE_FIELD_NAME (type, i), stream);
	303	if (lastval != TYPE_FIELD_BITPOS (type, i))
c906108c	304	{
c5aa993b JM	305	fprintf_filtered (stream, " = %d", TYPE_FIELD_BITPOS (type, i));
c5aa993b JM	306	lastval = TYPE_FIELD_BITPOS (type, i);
c906108c	307	}
c5aa993b	308	lastval++;
c906108c SS	309	}
c906108c SS	310	fprintf_filtered (stream, ")");
c5aa993b JM	311	}
c5aa993b JM	312	break;
c906108c	313
c5aa993b JM	314	case TYPE_CODE_VOID:
	315	case TYPE_CODE_UNDEF:
	316	case TYPE_CODE_ERROR:
	317	case TYPE_CODE_UNION:
	318	case TYPE_CODE_METHOD:
	319	error ("missing language support in chill_type_print_base");
	320	break;
c906108c	321
c5aa993b	322	default:
c906108c	323
c5aa993b JM	324	/* Handle types not explicitly handled by the other cases,
	325	such as fundamental types. For these, just print whatever
	326	the type name is, as recorded in the type itself. If there
	327	is no type name, then complain. */
c906108c	328
c5aa993b	329	if (TYPE_NAME (type) != NULL)
c906108c	330	{
c5aa993b	331	fputs_filtered (TYPE_NAME (type), stream);
c906108c	332	}
c5aa993b JM	333	else
	334	{
	335	error ("Unrecognized type code (%d) in symbol table.",
	336	TYPE_CODE (type));
	337	}
	338	break;
	339	}
c906108c	340	}