[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 <string.h>
#include <errno.h>

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

void
chill_print_type (type, varstring, stream, show, level)
     struct type *type;
     char *varstring;
     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;
     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;
    }

  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_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_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
	  {
	    check_stub_type (type);
	    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++)
		  {
		    QUIT;
		    print_spaces_filtered (level + 4, stream);
		    chill_print_type (TYPE_FIELD_TYPE (type, i),
				      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_VOID:
      case TYPE_CODE_UNDEF:
      case TYPE_CODE_ERROR:
      case TYPE_CODE_RANGE:
      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"
	34
	35	#include <string.h>
	36	#include <errno.h>
	37
8fbdca53 FF	38	static void
8fbdca53 FF	39	chill_type_print_base PARAMS ((struct type , FILE , int, int));
a8a69e63 FF	40
	41	void
	42	chill_print_type (type, varstring, stream, show, level)
	43	struct type *type;
	44	char *varstring;
	45	FILE *stream;
	46	int show;
	47	int level;
	48	{
a8a69e63 FF	49	if (varstring != NULL && *varstring != '\0')
	50	{
	51	fputs_filtered (varstring, stream);
	52	fputs_filtered (" ", stream);
	53	}
8a177da6	54	chill_type_print_base (type, stream, show, level);
a8a69e63 FF	55	}
	56
	57	/* Print the name of the type (or the ultimate pointer target,
	58	function value or array element).
	59
	60	SHOW nonzero means don't print this type as just its name;
	61	show its real definition even if it has a name.
	62	SHOW zero means print just typename or tag if there is one
	63	SHOW negative means abbreviate structure elements.
	64	SHOW is decremented for printing of structure elements.
	65
	66	LEVEL is the depth to indent by.
	67	We increase it for some recursive calls. */
	68
8fbdca53 FF	69	static void
8fbdca53 FF	70	chill_type_print_base (type, stream, show, level)
a8a69e63 FF	71	struct type *type;
	72	FILE *stream;
	73	int show;
	74	int level;
	75	{
8fbdca53 FF	76	char *name;
	77	register int len;
	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
	102	switch (TYPE_CODE (type))
	103	{
a8a69e63	104	case TYPE_CODE_PTR:
8a177da6 PB	105	if (TYPE_CODE (TYPE_TARGET_TYPE (type)) == TYPE_CODE_VOID)
	106	{
	107	fprintf_filtered (stream, "PTR");
	108	break;
	109	}
	110	fprintf_filtered (stream, "REF ");
	111	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	112	break;
	113
	114	case TYPE_CODE_ARRAY:
	115	range_type = TYPE_FIELD_TYPE (type, 0);
	116	index_type = TYPE_TARGET_TYPE (range_type);
	117	low_bound = TYPE_FIELD_BITPOS (range_type, 0);
	118	high_bound = TYPE_FIELD_BITPOS (range_type, 1);
	119	fputs_filtered ("ARRAY (", stream);
	120	print_type_scalar (index_type, low_bound, stream);
	121	fputs_filtered (":", stream);
	122	print_type_scalar (index_type, high_bound, stream);
	123	fputs_filtered (") ", stream);
	124	chill_print_type (TYPE_TARGET_TYPE (type), "", stream, show, level);
	125	break;
	126
	127	case TYPE_CODE_STRING:
	128	range_type = TYPE_FIELD_TYPE (type, 0);
	129	index_type = TYPE_TARGET_TYPE (range_type);
	130	high_bound = TYPE_FIELD_BITPOS (range_type, 1);
	131	fputs_filtered ("CHAR (", stream);
	132	print_type_scalar (index_type, high_bound + 1, stream);
	133	fputs_filtered (")", stream);
	134	break;
	135
a8a69e63	136	case TYPE_CODE_MEMBER:
8a177da6 PB	137	fprintf_filtered (stream, "MEMBER ");
	138	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	139	break;
a8a69e63	140	case TYPE_CODE_REF:
8a177da6 PB	141	fprintf_filtered (stream, "/LOC/ ");
	142	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	143	break;
a8a69e63	144	case TYPE_CODE_FUNC:
8a177da6	145	fprintf_filtered (stream, "PROC (?)");
8fbdca53 FF	146	chill_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	147	break;
	148
	149	case TYPE_CODE_STRUCT:
	150	fprintf_filtered (stream, "STRUCT ");
	151	if ((name = type_name_no_tag (type)) != NULL)
	152	{
	153	fputs_filtered (name, stream);
	154	fputs_filtered (" ", stream);
	155	wrap_here (" ");
	156	}
	157	if (show < 0)
	158	{
	159	fprintf_filtered (stream, "(...)");
	160	}
	161	else
	162	{
	163	check_stub_type (type);
	164	fprintf_filtered (stream, "(\n");
	165	if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
	166	{
	167	if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
	168	{
	169	fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
	170	}
	171	else
	172	{
	173	fprintfi_filtered (level + 4, stream, "<no data fields>\n");
	174	}
	175	}
	176	else
	177	{
	178	len = TYPE_NFIELDS (type);
	179	for (i = TYPE_N_BASECLASSES (type); i < len; i++)
	180	{
	181	QUIT;
	182	print_spaces_filtered (level + 4, stream);
	183	chill_print_type (TYPE_FIELD_TYPE (type, i),
	184	TYPE_FIELD_NAME (type, i),
	185	stream, show - 1, level + 4);
	186	if (i < (len - 1))
	187	{
	188	fputs_filtered (",", stream);
	189	}
	190	fputs_filtered ("\n", stream);
	191	}
	192	}
	193	fprintfi_filtered (level, stream, ")");
	194	}
a8a69e63 FF	195	break;
	196
	197	case TYPE_CODE_VOID:
	198	case TYPE_CODE_UNDEF:
	199	case TYPE_CODE_ERROR:
	200	case TYPE_CODE_RANGE:
	201	case TYPE_CODE_ENUM:
	202	case TYPE_CODE_UNION:
a8a69e63	203	case TYPE_CODE_METHOD:
8fbdca53	204	error ("missing language support in chill_type_print_base");
a8a69e63 FF	205	break;
	206
	207	default:
	208
	209	/* Handle types not explicitly handled by the other cases,
	210	such as fundamental types. For these, just print whatever
	211	the type name is, as recorded in the type itself. If there
	212	is no type name, then complain. */
	213
	214	if (TYPE_NAME (type) != NULL)
	215	{
	216	fputs_filtered (TYPE_NAME (type), stream);
	217	}
	218	else
	219	{
	220	error ("Unrecognized type code (%d) in symbol table.",
	221	TYPE_CODE (type));
	222	}
	223	break;
	224	}
	225	}