[binutils.git] / gdb / jv-typeprint.c

/* Support for printing Java types for GDB, the GNU debugger.
   Copyright 1997 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 "symtab.h"
#include "gdbtypes.h"
#include "value.h"
#include "demangle.h"
#include "jv-lang.h"
#include "gdb_string.h"

static void
java_type_print_derivation_info (stream, type)
     GDB_FILE *stream;
     struct type *type;
{
  char *name;
  int i = 0;
  int n_bases = TYPE_N_BASECLASSES (type);
  int prev = 0;

  for (i = 0; i < n_bases; i++)
    {
      int kind = BASETYPE_VIA_VIRTUAL(type, i) ? 'I' : 'E';
      fputs_filtered (kind == prev ? ", "
		      : kind == 'I' ? " implements "
		      : " extends ",
		      stream);
      prev = kind;
      name = type_name_no_tag (TYPE_BASECLASS (type, i));
      fprintf_filtered (stream, "%s", name ? name : "(null)");
    }
  if (i > 0)
    {
      fputs_filtered (" ", stream);
    }
}

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

   SHOW positive means print details about the type (e.g. enum values),
   and print structure elements passing SHOW - 1 for show.
   SHOW negative means just print the type name or struct tag if there is one.
   If there is no name, print something sensible but concise like
   "struct {...}".
   SHOW zero means just print the type name or struct tag if there is one.
   If there is no name, print something sensible but not as concise like
   "struct {int x; int y;}".

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

void
java_type_print_base (type, stream, show, level)
     struct type *type;
     GDB_FILE *stream;
     int show;
     int level;
{
  register int i;
  register int len;
  char *mangled_name;
  char *demangled_name;
  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_TYPEDEF (type);

  switch (TYPE_CODE (type))
    {
    case TYPE_CODE_PTR:
      java_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
      break;

    case TYPE_CODE_STRUCT:
      if (TYPE_TAG_NAME (type) != NULL && TYPE_TAG_NAME (type)[0] == '[')
	{ /* array type */
	  char *name = java_demangle_type_signature (TYPE_TAG_NAME (type));
	  fputs (name, stream);
	  free (name);
	  break;
	}
      if (show >= 0)
	fprintf_filtered (stream, "class ");
      if (TYPE_TAG_NAME (type) != NULL)
	{
	  fputs_filtered (TYPE_TAG_NAME (type), stream);
	  if (show > 0)
	    fputs_filtered (" ", stream);
	}
      wrap_here ("    ");
      if (show < 0)
	{
	  /* If we just printed a tag name, no need to print anything else.  */
	  if (TYPE_TAG_NAME (type) == NULL)
	    fprintf_filtered (stream, "{...}");
	}
      else if (show > 0 || TYPE_TAG_NAME (type) == NULL)
	{
	  java_type_print_derivation_info (stream, 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");
	    }

	  /* If there is a base class for this type,
	     do not print the field that it occupies.  */

	  len = TYPE_NFIELDS (type);
	  for (i = TYPE_N_BASECLASSES (type); i < len; i++)
	    {
	      QUIT;
	      /* Don't print out virtual function table.  */
	      if (STREQN (TYPE_FIELD_NAME (type, i), "_vptr", 5)
		  && is_cplus_marker ((TYPE_FIELD_NAME (type, i))[5]))
		continue;

	      /* Don't print the dummy field "class". */
	      if (STREQN (TYPE_FIELD_NAME (type, i), "class", 5))
		continue;

	      print_spaces_filtered (level + 4, stream);
	      if (HAVE_CPLUS_STRUCT (type))
		{
		  if (TYPE_FIELD_PROTECTED (type, i))
		    fprintf_filtered (stream, "protected ");
		  else if (TYPE_FIELD_PRIVATE (type, i))
		    fprintf_filtered (stream, "private ");
		  else
		    fprintf_filtered (stream, "public ");
		}

	      if (TYPE_FIELD_STATIC (type, i))
		{
		  fprintf_filtered (stream, "static ");
		}
	      java_print_type (TYPE_FIELD_TYPE (type, i),
			    TYPE_FIELD_NAME (type, i),
			    stream, show - 1, level + 4);
	      fprintf_filtered (stream, ";\n");
	    }

	  /* If there are both fields and methods, put a space between. */
	  len = TYPE_NFN_FIELDS (type);
	  if (len)
	     fprintf_filtered (stream, "\n");

	  /* Print out the methods */

	  for (i = 0; i < len; i++)
	    {
	      struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
	      int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
	      char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
	      char *name = type_name_no_tag (type);
	      int is_constructor = name && STREQ(method_name, name);
	      for (j = 0; j < len2; j++)
		{
		  char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
		  int is_full_physname_constructor = 
		    ((physname[0] == '_' && physname[1] == '_'
		      && strchr ("0123456789Qt", physname[2]))
		     || STREQN (physname, "__ct__", 6)
		     || DESTRUCTOR_PREFIX_P (physname)
		     || STREQN (physname, "__dt__", 6));

		  QUIT;
		  print_spaces_filtered (level + 4, stream);
		  if (TYPE_FN_FIELD_PROTECTED (f, j))
		    fprintf_filtered (stream, "protected ");
		  else if (TYPE_FN_FIELD_PRIVATE (f, j))
		    fprintf_filtered (stream, "private ");
		  else
		    fprintf_filtered (stream, "public ");

		  if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
		    fprintf_filtered (stream, "virtual ");
		  else if (TYPE_FN_FIELD_STATIC_P (f, j))
		    fprintf_filtered (stream, "static ");
		  if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
		    {
		      /* Keep GDB from crashing here.  */
		      fprintf_filtered (stream, "<undefined type> %s;\n",
			       TYPE_FN_FIELD_PHYSNAME (f, j));
		      break;
		    }
		  else if (!is_constructor && !is_full_physname_constructor)
		    {
		      type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
				  "", stream, -1);
		      fputs_filtered (" ", stream);
		    }
		  if (TYPE_FN_FIELD_STUB (f, j))
		    /* Build something we can demangle.  */
		    mangled_name = gdb_mangle_name (type, i, j);
		  else
		    mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);

		  demangled_name =
		    cplus_demangle (mangled_name,
				    DMGL_ANSI | DMGL_PARAMS | DMGL_JAVA);
		  if (demangled_name == NULL)
		    fprintf_filtered (stream, "<badly mangled name '%s'>",
				      mangled_name);
		  else
		    {
		      char *demangled_no_class = demangled_name;
		      char *ptr = demangled_name;
		      for ( ; ; )
			{
			  char c = *ptr++;
			  if (c == 0 || c == '(')
			    break;
			  if (c == '.')
			    demangled_no_class = ptr;
			}
		      fputs_filtered (demangled_no_class, stream);
		      free (demangled_name);
		    }

		  if (TYPE_FN_FIELD_STUB (f, j))
		    free (mangled_name);

		  fprintf_filtered (stream, ";\n");
		}
	    }

	  fprintfi_filtered (level, stream, "}");
	}
      break;

      default:
	c_type_print_base (type, stream, show, level);
    }
}

/* LEVEL is the depth to indent lines by.  */

void
java_print_type (type, varstring, stream, show, level)
     struct type *type;
     char *varstring;
     GDB_FILE *stream;
     int show;
     int level;
{
  java_type_print_base (type, stream, show, level);

  if (varstring != NULL && *varstring != '\0')
    {
      fputs_filtered (" ", stream);
      fputs_filtered (varstring, stream);
    }
#if 0
  /* For demangled function names, we have the arglist as part of the name,
     so don't print an additional pair of ()'s */

  demangled_args = strchr(varstring, '(') != NULL;
  c_type_print_varspec_suffix (type, stream, show, 0, demangled_args);
#endif
}
Commit	Line	Data
166606b7 PB	1	/* Support for printing Java types for GDB, the GNU debugger.
	2	Copyright 1997 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
	19
	20
	21	#include "defs.h"
	22	#include "symtab.h"
	23	#include "gdbtypes.h"
d2e131a1 PB	24	#include "value.h"
	25	#include "demangle.h"
	26	#include "jv-lang.h"
	27	#include "gdb_string.h"
	28
	29	static void
	30	java_type_print_derivation_info (stream, type)
	31	GDB_FILE *stream;
	32	struct type *type;
	33	{
	34	char *name;
	35	int i = 0;
	36	int n_bases = TYPE_N_BASECLASSES (type);
	37	int prev = 0;
	38
	39	for (i = 0; i < n_bases; i++)
	40	{
	41	int kind = BASETYPE_VIA_VIRTUAL(type, i) ? 'I' : 'E';
	42	fputs_filtered (kind == prev ? ", "
	43	: kind == 'I' ? " implements "
	44	: " extends ",
	45	stream);
	46	prev = kind;
	47	name = type_name_no_tag (TYPE_BASECLASS (type, i));
	48	fprintf_filtered (stream, "%s", name ? name : "(null)");
	49	}
	50	if (i > 0)
	51	{
	52	fputs_filtered (" ", stream);
	53	}
	54	}
	55
	56	/* Print the name of the type (or the ultimate pointer target,
	57	function value or array element), or the description of a
	58	structure or union.
	59
	60	SHOW positive means print details about the type (e.g. enum values),
	61	and print structure elements passing SHOW - 1 for show.
	62	SHOW negative means just print the type name or struct tag if there is one.
	63	If there is no name, print something sensible but concise like
	64	"struct {...}".
	65	SHOW zero means just print the type name or struct tag if there is one.
	66	If there is no name, print something sensible but not as concise like
	67	"struct {int x; int y;}".
	68
	69	LEVEL is the number of spaces to indent by.
	70	We increase it for some recursive calls. */
	71
	72	void
	73	java_type_print_base (type, stream, show, level)
	74	struct type *type;
	75	GDB_FILE *stream;
	76	int show;
	77	int level;
	78	{
	79	register int i;
	80	register int len;
	81	char *mangled_name;
	82	char *demangled_name;
	83	QUIT;
	84
	85	wrap_here (" ");
	86	if (type == NULL)
	87	{
88	fputs_filtered ("<type unknown>", stream);
89	return;
90	}
91
92	/* When SHOW is zero or less, and there is a valid type name, then always
93	just print the type name directly from the type. */
94
95	if (show <= 0
96	&& TYPE_NAME (type) != NULL)
97	{
98	fputs_filtered (TYPE_NAME (type), stream);
99	return;
100	}
101
102	CHECK_TYPEDEF (type);
103
104	switch (TYPE_CODE (type))
105	{
fc655dc2 PB	106	case TYPE_CODE_PTR:
	107	java_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	108	break;
	109
d2e131a1	110	case TYPE_CODE_STRUCT:
fc655dc2 PB	111	if (TYPE_TAG_NAME (type) != NULL && TYPE_TAG_NAME (type)[0] == '[')
	112	{ /* array type */
	113	char *name = java_demangle_type_signature (TYPE_TAG_NAME (type));
	114	fputs (name, stream);
	115	free (name);
	116	break;
	117	}
	118	if (show >= 0)
	119	fprintf_filtered (stream, "class ");
d2e131a1 PB	120	if (TYPE_TAG_NAME (type) != NULL)
	121	{
	122	fputs_filtered (TYPE_TAG_NAME (type), stream);
	123	if (show > 0)
	124	fputs_filtered (" ", stream);
	125	}
	126	wrap_here (" ");
	127	if (show < 0)
	128	{
	129	/* If we just printed a tag name, no need to print anything else. */
	130	if (TYPE_TAG_NAME (type) == NULL)
	131	fprintf_filtered (stream, "{...}");
	132	}
	133	else if (show > 0 \|\| TYPE_TAG_NAME (type) == NULL)
	134	{
	135	java_type_print_derivation_info (stream, type);
	136
	137	fprintf_filtered (stream, "{\n");
	138	if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
	139	{
	140	if (TYPE_FLAGS (type) & TYPE_FLAG_STUB)
	141	fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
	142	else
	143	fprintfi_filtered (level + 4, stream, "<no data fields>\n");
	144	}
	145
	146	/* If there is a base class for this type,
	147	do not print the field that it occupies. */
	148
	149	len = TYPE_NFIELDS (type);
	150	for (i = TYPE_N_BASECLASSES (type); i < len; i++)
	151	{
	152	QUIT;
	153	/* Don't print out virtual function table. */
	154	if (STREQN (TYPE_FIELD_NAME (type, i), "_vptr", 5)
	155	&& is_cplus_marker ((TYPE_FIELD_NAME (type, i))[5]))
	156	continue;
	157
fc655dc2 PB	158	/* Don't print the dummy field "class". */
	159	if (STREQN (TYPE_FIELD_NAME (type, i), "class", 5))
	160	continue;
d2e131a1 PB	161
	162	print_spaces_filtered (level + 4, stream);
	163	if (HAVE_CPLUS_STRUCT (type))
	164	{
	165	if (TYPE_FIELD_PROTECTED (type, i))
	166	fprintf_filtered (stream, "protected ");
	167	else if (TYPE_FIELD_PRIVATE (type, i))
	168	fprintf_filtered (stream, "private ");
	169	else
	170	fprintf_filtered (stream, "public ");
	171	}
	172
	173	if (TYPE_FIELD_STATIC (type, i))
	174	{
	175	fprintf_filtered (stream, "static ");
	176	}
	177	java_print_type (TYPE_FIELD_TYPE (type, i),
	178	TYPE_FIELD_NAME (type, i),
	179	stream, show - 1, level + 4);
	180	fprintf_filtered (stream, ";\n");
	181	}
	182
	183	/* If there are both fields and methods, put a space between. */
	184	len = TYPE_NFN_FIELDS (type);
	185	if (len)
	186	fprintf_filtered (stream, "\n");
	187
	188	/* Print out the methods */
	189
	190	for (i = 0; i < len; i++)
	191	{
	192	struct fn_field *f = TYPE_FN_FIELDLIST1 (type, i);
	193	int j, len2 = TYPE_FN_FIELDLIST_LENGTH (type, i);
	194	char *method_name = TYPE_FN_FIELDLIST_NAME (type, i);
	195	char *name = type_name_no_tag (type);
	196	int is_constructor = name && STREQ(method_name, name);
	197	for (j = 0; j < len2; j++)
	198	{
	199	char *physname = TYPE_FN_FIELD_PHYSNAME (f, j);
	200	int is_full_physname_constructor =
	201	((physname[0] == '_' && physname[1] == '_'
	202	&& strchr ("0123456789Qt", physname[2]))
	203	\|\| STREQN (physname, "__ct__", 6)
	204	\|\| DESTRUCTOR_PREFIX_P (physname)
	205	\|\| STREQN (physname, "__dt__", 6));
	206
	207	QUIT;
	208	print_spaces_filtered (level + 4, stream);
	209	if (TYPE_FN_FIELD_PROTECTED (f, j))
	210	fprintf_filtered (stream, "protected ");
	211	else if (TYPE_FN_FIELD_PRIVATE (f, j))
	212	fprintf_filtered (stream, "private ");
	213	else
	214	fprintf_filtered (stream, "public ");
	215
	216	if (TYPE_FN_FIELD_VIRTUAL_P (f, j))
	217	fprintf_filtered (stream, "virtual ");
	218	else if (TYPE_FN_FIELD_STATIC_P (f, j))
	219	fprintf_filtered (stream, "static ");
	220	if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
	221	{
	222	/* Keep GDB from crashing here. */
	223	fprintf_filtered (stream, "<undefined type> %s;\n",
	224	TYPE_FN_FIELD_PHYSNAME (f, j));
225	break;
226	}
227	else if (!is_constructor && !is_full_physname_constructor)
228	{
229	type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
230	"", stream, -1);
231	fputs_filtered (" ", stream);
232	}
233	if (TYPE_FN_FIELD_STUB (f, j))
234	/* Build something we can demangle. */
235	mangled_name = gdb_mangle_name (type, i, j);
236	else
237	mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
238
239	demangled_name =
240	cplus_demangle (mangled_name,
241	DMGL_ANSI \| DMGL_PARAMS \| DMGL_JAVA);
242	if (demangled_name == NULL)
243	fprintf_filtered (stream, "<badly mangled name '%s'>",
244	mangled_name);
245	else
246	{
247	char *demangled_no_class = demangled_name;
248	char *ptr = demangled_name;
249	for ( ; ; )
250	{
251	char c = *ptr++;
252	if (c == 0 \|\| c == '(')
253	break;
254	if (c == '.')
255	demangled_no_class = ptr;
256	}
257	fputs_filtered (demangled_no_class, stream);
258	free (demangled_name);
259	}
260
261	if (TYPE_FN_FIELD_STUB (f, j))
262	free (mangled_name);
263
264	fprintf_filtered (stream, ";\n");
265	}
266	}
267
268	fprintfi_filtered (level, stream, "}");
269	}
270	break;
271
272	default:
273	c_type_print_base (type, stream, show, level);
274	}
275	}
166606b7 PB	276
	277	/* LEVEL is the depth to indent lines by. */
	278
	279	void
	280	java_print_type (type, varstring, stream, show, level)
	281	struct type *type;
	282	char *varstring;
	283	GDB_FILE *stream;
	284	int show;
	285	int level;
	286	{
d2e131a1 PB	287	java_type_print_base (type, stream, show, level);
	288
	289	if (varstring != NULL && *varstring != '\0')
	290	{
	291	fputs_filtered (" ", stream);
	292	fputs_filtered (varstring, stream);
	293	}
	294	#if 0
	295	/* For demangled function names, we have the arglist as part of the name,
	296	so don't print an additional pair of ()'s */
	297
	298	demangled_args = strchr(varstring, '(') != NULL;
	299	c_type_print_varspec_suffix (type, stream, show, 0, demangled_args);
	300	#endif
166606b7	301	}