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

/* Support for printing Java types for GDB, the GNU debugger.
   Copyright (C) 1997, 1998, 1999, 2000, 2007, 2008
   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 3 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, see <http://www.gnu.org/licenses/>.  */


#include "defs.h"
#include "symtab.h"
#include "gdbtypes.h"
#include "value.h"
#include "demangle.h"
#include "jv-lang.h"
#include "gdb_string.h"
#include "typeprint.h"
#include "c-lang.h"
#include "cp-abi.h"

/* Local functions */

static void java_type_print_base (struct type * type,
				  struct ui_file *stream, int show,
				  int level);

static void
java_type_print_derivation_info (struct ui_file *stream, struct type *type)
{
  char *name;
  int i;
  int n_bases;
  int prev;

  n_bases = TYPE_N_BASECLASSES (type);

  for (i = 0, prev = 0; i < n_bases; i++)
    {
      int kind;

      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.  */

static void
java_type_print_base (struct type *type, struct ui_file *stream, int show,
		      int level)
{
  int i;
  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_filtered (name, stream);
	  xfree (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_STUB (type))
		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 (strncmp (TYPE_FIELD_NAME (type, i), "_vptr", 5) == 0
		  && is_cplus_marker ((TYPE_FIELD_NAME (type, i))[5]))
		continue;

	      /* Don't print the dummy field "class". */
	      if (strncmp (TYPE_FIELD_NAME (type, i), "class", 5) == 0)
		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;
	      int j;
	      char *method_name;
	      char *name;
	      int is_constructor;
	      int n_overloads;

	      f = TYPE_FN_FIELDLIST1 (type, i);
	      n_overloads = TYPE_FN_FIELDLIST_LENGTH (type, i);
	      method_name = TYPE_FN_FIELDLIST_NAME (type, i);
	      name = type_name_no_tag (type);
	      is_constructor = name && strcmp (method_name, name) == 0;

	      for (j = 0; j < n_overloads; j++)
		{
		  char *physname;
		  int is_full_physname_constructor;

		  physname = TYPE_FN_FIELD_PHYSNAME (f, j);

		  is_full_physname_constructor
                    = (is_constructor_name (physname)
                       || is_destructor_name (physname));

		  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 if (TYPE_FN_FIELD_PUBLIC (f, j))
		    fprintf_filtered (stream, "public ");

		  if (TYPE_FN_FIELD_ABSTRACT (f, j))
		    fprintf_filtered (stream, "abstract ");
		  if (TYPE_FN_FIELD_STATIC (f, j))
		    fprintf_filtered (stream, "static ");
		  if (TYPE_FN_FIELD_FINAL (f, j))
		    fprintf_filtered (stream, "final ");
		  if (TYPE_FN_FIELD_SYNCHRONIZED (f, j))
		    fprintf_filtered (stream, "synchronized ");
		  if (TYPE_FN_FIELD_NATIVE (f, j))
		    fprintf_filtered (stream, "native ");

		  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)
		    demangled_name = xstrdup (mangled_name);

		  {
		    char *demangled_no_class;
		    char *ptr;

		    ptr = demangled_no_class = demangled_name;

		    while (1)
		      {
			char c;

			c = *ptr++;

			if (c == 0 || c == '(')
			  break;
			if (c == '.')
			  demangled_no_class = ptr;
		      }

		    fputs_filtered (demangled_no_class, stream);
		    xfree (demangled_name);
		  }

		  if (TYPE_FN_FIELD_STUB (f, j))
		    xfree (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.  */

extern void c_type_print_varspec_suffix (struct type *, struct ui_file *,
					 int, int, int);

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

  java_type_print_base (type, stream, show, level);

  if (varstring != NULL && *varstring != '\0')
    {
      fputs_filtered (" ", stream);
      fputs_filtered (varstring, stream);
    }

  /* For demangled function names, we have the arglist as part of the name,
     so don't print an additional pair of ()'s */

  demangled_args = varstring != NULL && strchr (varstring, '(') != NULL;
  c_type_print_varspec_suffix (type, stream, show, 0, demangled_args);
}
Commit	Line	Data
c906108c	1	/* Support for printing Java types for GDB, the GNU debugger.
9b254dd1 DJ	2	Copyright (C) 1997, 1998, 1999, 2000, 2007, 2008
9b254dd1 DJ	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
c5aa993b JM	8	it under the terms of the GNU General Public License as published by
a9762ec7	9	the Free Software Foundation; either version 3 of the License, or
c5aa993b	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	17	You should have received a copy of the GNU General Public License
a9762ec7	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
c906108c SS	19
	20
	21	#include "defs.h"
	22	#include "symtab.h"
	23	#include "gdbtypes.h"
	24	#include "value.h"
	25	#include "demangle.h"
	26	#include "jv-lang.h"
	27	#include "gdb_string.h"
	28	#include "typeprint.h"
7a292a7a	29	#include "c-lang.h"
015a42b4	30	#include "cp-abi.h"
c906108c	31
392a587b JM	32	/* Local functions */
392a587b JM	33
d9fcf2fb JM	34	static void java_type_print_base (struct type * type,
	35	struct ui_file *stream, int show,
	36	int level);
392a587b	37
c906108c	38	static void
fba45db2	39	java_type_print_derivation_info (struct ui_file stream, struct type type)
c906108c SS	40	{
	41	char *name;
	42	int i;
	43	int n_bases;
	44	int prev;
	45
	46	n_bases = TYPE_N_BASECLASSES (type);
	47
	48	for (i = 0, prev = 0; i < n_bases; i++)
	49	{
	50	int kind;
	51
c5aa993b	52	kind = BASETYPE_VIA_VIRTUAL (type, i) ? 'I' : 'E';
c906108c SS	53
	54	fputs_filtered (kind == prev ? ", "
	55	: kind == 'I' ? " implements "
	56	: " extends ",
	57	stream);
	58	prev = kind;
	59	name = type_name_no_tag (TYPE_BASECLASS (type, i));
	60
	61	fprintf_filtered (stream, "%s", name ? name : "(null)");
	62	}
	63
	64	if (i > 0)
	65	fputs_filtered (" ", stream);
	66	}
	67
	68	/* Print the name of the type (or the ultimate pointer target,
	69	function value or array element), or the description of a
	70	structure or union.
	71
	72	SHOW positive means print details about the type (e.g. enum values),
	73	and print structure elements passing SHOW - 1 for show.
	74	SHOW negative means just print the type name or struct tag if there is one.
	75	If there is no name, print something sensible but concise like
	76	"struct {...}".
	77	SHOW zero means just print the type name or struct tag if there is one.
	78	If there is no name, print something sensible but not as concise like
	79	"struct {int x; int y;}".
	80
	81	LEVEL is the number of spaces to indent by.
	82	We increase it for some recursive calls. */
	83
392a587b	84	static void
fba45db2 KB	85	java_type_print_base (struct type type, struct ui_file stream, int show,
fba45db2 KB	86	int level)
c906108c	87	{
52f0bd74 AC	88	int i;
52f0bd74 AC	89	int len;
c906108c SS	90	char *mangled_name;
	91	char *demangled_name;
	92	QUIT;
	93
	94	wrap_here (" ");
	95
	96	if (type == NULL)
	97	{
	98	fputs_filtered ("<type unknown>", stream);
	99	return;
	100	}
	101
	102	/* When SHOW is zero or less, and there is a valid type name, then always
	103	just print the type name directly from the type. */
	104
	105	if (show <= 0
	106	&& TYPE_NAME (type) != NULL)
	107	{
	108	fputs_filtered (TYPE_NAME (type), stream);
	109	return;
	110	}
	111
	112	CHECK_TYPEDEF (type);
	113
	114	switch (TYPE_CODE (type))
	115	{
	116	case TYPE_CODE_PTR:
	117	java_type_print_base (TYPE_TARGET_TYPE (type), stream, show, level);
	118	break;
	119
	120	case TYPE_CODE_STRUCT:
	121	if (TYPE_TAG_NAME (type) != NULL && TYPE_TAG_NAME (type)[0] == '[')
	122	{ /* array type */
	123	char *name = java_demangle_type_signature (TYPE_TAG_NAME (type));
	124	fputs_filtered (name, stream);
b8c9b27d	125	xfree (name);
c906108c SS	126	break;
	127	}
	128
	129	if (show >= 0)
	130	fprintf_filtered (stream, "class ");
	131
	132	if (TYPE_TAG_NAME (type) != NULL)
	133	{
	134	fputs_filtered (TYPE_TAG_NAME (type), stream);
	135	if (show > 0)
	136	fputs_filtered (" ", stream);
	137	}
	138
	139	wrap_here (" ");
	140
	141	if (show < 0)
	142	{
	143	/* If we just printed a tag name, no need to print anything else. */
	144	if (TYPE_TAG_NAME (type) == NULL)
	145	fprintf_filtered (stream, "{...}");
	146	}
	147	else if (show > 0 \|\| TYPE_TAG_NAME (type) == NULL)
	148	{
	149	java_type_print_derivation_info (stream, type);
c5aa993b	150
c906108c SS	151	fprintf_filtered (stream, "{\n");
c906108c SS	152	if ((TYPE_NFIELDS (type) == 0) && (TYPE_NFN_FIELDS (type) == 0))
7a292a7a	153	{
74a9bb82	154	if (TYPE_STUB (type))
7a292a7a SS	155	fprintfi_filtered (level + 4, stream, "<incomplete type>\n");
	156	else
	157	fprintfi_filtered (level + 4, stream, "<no data fields>\n");
	158	}
c906108c SS	159
	160	/* If there is a base class for this type,
	161	do not print the field that it occupies. */
	162
	163	len = TYPE_NFIELDS (type);
	164	for (i = TYPE_N_BASECLASSES (type); i < len; i++)
	165	{
	166	QUIT;
	167	/* Don't print out virtual function table. */
5cb316ef	168	if (strncmp (TYPE_FIELD_NAME (type, i), "_vptr", 5) == 0
c906108c SS	169	&& is_cplus_marker ((TYPE_FIELD_NAME (type, i))[5]))
	170	continue;
	171
	172	/* Don't print the dummy field "class". */
5cb316ef	173	if (strncmp (TYPE_FIELD_NAME (type, i), "class", 5) == 0)
c906108c SS	174	continue;
	175
	176	print_spaces_filtered (level + 4, stream);
	177
	178	if (HAVE_CPLUS_STRUCT (type))
7a292a7a SS	179	{
	180	if (TYPE_FIELD_PROTECTED (type, i))
	181	fprintf_filtered (stream, "protected ");
	182	else if (TYPE_FIELD_PRIVATE (type, i))
	183	fprintf_filtered (stream, "private ");
	184	else
	185	fprintf_filtered (stream, "public ");
	186	}
c906108c SS	187
	188	if (TYPE_FIELD_STATIC (type, i))
	189	fprintf_filtered (stream, "static ");
	190
	191	java_print_type (TYPE_FIELD_TYPE (type, i),
	192	TYPE_FIELD_NAME (type, i),
	193	stream, show - 1, level + 4);
	194
	195	fprintf_filtered (stream, ";\n");
	196	}
	197
	198	/* If there are both fields and methods, put a space between. */
	199	len = TYPE_NFN_FIELDS (type);
	200	if (len)
c5aa993b	201	fprintf_filtered (stream, "\n");
c906108c SS	202
	203	/* Print out the methods */
	204
	205	for (i = 0; i < len; i++)
	206	{
	207	struct fn_field *f;
	208	int j;
	209	char *method_name;
	210	char *name;
	211	int is_constructor;
	212	int n_overloads;
	213
	214	f = TYPE_FN_FIELDLIST1 (type, i);
	215	n_overloads = TYPE_FN_FIELDLIST_LENGTH (type, i);
	216	method_name = TYPE_FN_FIELDLIST_NAME (type, i);
	217	name = type_name_no_tag (type);
762f08a3	218	is_constructor = name && strcmp (method_name, name) == 0;
c906108c SS	219
	220	for (j = 0; j < n_overloads; j++)
	221	{
	222	char *physname;
	223	int is_full_physname_constructor;
	224
	225	physname = TYPE_FN_FIELD_PHYSNAME (f, j);
	226
015a42b4 JB	227	is_full_physname_constructor
	228	= (is_constructor_name (physname)
	229	\|\| is_destructor_name (physname));
c906108c SS	230
	231	QUIT;
	232
	233	print_spaces_filtered (level + 4, stream);
	234
	235	if (TYPE_FN_FIELD_PROTECTED (f, j))
	236	fprintf_filtered (stream, "protected ");
	237	else if (TYPE_FN_FIELD_PRIVATE (f, j))
	238	fprintf_filtered (stream, "private ");
	239	else if (TYPE_FN_FIELD_PUBLIC (f, j))
	240	fprintf_filtered (stream, "public ");
	241
	242	if (TYPE_FN_FIELD_ABSTRACT (f, j))
	243	fprintf_filtered (stream, "abstract ");
	244	if (TYPE_FN_FIELD_STATIC (f, j))
	245	fprintf_filtered (stream, "static ");
	246	if (TYPE_FN_FIELD_FINAL (f, j))
	247	fprintf_filtered (stream, "final ");
	248	if (TYPE_FN_FIELD_SYNCHRONIZED (f, j))
	249	fprintf_filtered (stream, "synchronized ");
	250	if (TYPE_FN_FIELD_NATIVE (f, j))
	251	fprintf_filtered (stream, "native ");
	252
	253	if (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)) == 0)
	254	{
	255	/* Keep GDB from crashing here. */
	256	fprintf_filtered (stream, "<undefined type> %s;\n",
c5aa993b	257	TYPE_FN_FIELD_PHYSNAME (f, j));
c906108c SS	258	break;
	259	}
	260	else if (!is_constructor && !is_full_physname_constructor)
	261	{
	262	type_print (TYPE_TARGET_TYPE (TYPE_FN_FIELD_TYPE (f, j)),
	263	"", stream, -1);
	264	fputs_filtered (" ", stream);
	265	}
	266
	267	if (TYPE_FN_FIELD_STUB (f, j))
	268	/* Build something we can demangle. */
	269	mangled_name = gdb_mangle_name (type, i, j);
	270	else
	271	mangled_name = TYPE_FN_FIELD_PHYSNAME (f, j);
	272
	273	demangled_name =
	274	cplus_demangle (mangled_name,
	275	DMGL_ANSI \| DMGL_PARAMS \| DMGL_JAVA);
	276
	277	if (demangled_name == NULL)
c2d11a7d	278	demangled_name = xstrdup (mangled_name);
c906108c SS	279
	280	{
	281	char *demangled_no_class;
	282	char *ptr;
	283
	284	ptr = demangled_no_class = demangled_name;
	285
	286	while (1)
	287	{
	288	char c;
	289
	290	c = *ptr++;
	291
	292	if (c == 0 \|\| c == '(')
	293	break;
	294	if (c == '.')
	295	demangled_no_class = ptr;
	296	}
	297
	298	fputs_filtered (demangled_no_class, stream);
b8c9b27d	299	xfree (demangled_name);
c906108c SS	300	}
	301
	302	if (TYPE_FN_FIELD_STUB (f, j))
b8c9b27d	303	xfree (mangled_name);
c906108c SS	304
	305	fprintf_filtered (stream, ";\n");
	306	}
	307	}
	308
	309	fprintfi_filtered (level, stream, "}");
	310	}
	311	break;
	312
c5aa993b JM	313	default:
c5aa993b JM	314	c_type_print_base (type, stream, show, level);
c906108c SS	315	}
	316	}
	317
	318	/* LEVEL is the depth to indent lines by. */
	319
d9fcf2fb JM	320	extern void c_type_print_varspec_suffix (struct type , struct ui_file ,
d9fcf2fb JM	321	int, int, int);
7a292a7a	322
c906108c	323	void
fba45db2 KB	324	java_print_type (struct type type, char varstring, struct ui_file *stream,
fba45db2 KB	325	int show, int level)
c906108c SS	326	{
	327	int demangled_args;
	328
	329	java_type_print_base (type, stream, show, level);
	330
	331	if (varstring != NULL && *varstring != '\0')
	332	{
	333	fputs_filtered (" ", stream);
	334	fputs_filtered (varstring, stream);
	335	}
	336
	337	/* For demangled function names, we have the arglist as part of the name,
	338	so don't print an additional pair of ()'s */
	339
dc5000e7	340	demangled_args = varstring != NULL && strchr (varstring, '(') != NULL;
c906108c SS	341	c_type_print_varspec_suffix (type, stream, show, 0, demangled_args);
c906108c SS	342	}