[deliverable/binutils-gdb.git] / gdb / cp-support.c

/* Helper routines for C++ support in GDB.
   Copyright 2002, 2003 Free Software Foundation, Inc.

   Contributed by MontaVista Software.

   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 <ctype.h>
#include "cp-support.h"
#include "gdb_string.h"
#include "demangle.h"
#include "gdb_assert.h"
#include "gdbcmd.h"

/* The list of "maint cplus" commands.  */

static struct cmd_list_element *maint_cplus_cmd_list = NULL;

/* The actual commands.  */

static void maint_cplus_command (char *arg, int from_tty);
static void first_component_command (char *arg, int from_tty);

/* Here are some random pieces of trivia to keep in mind while trying
   to take apart demangled names:

   - Names can contain function arguments or templates, so the process
     has to be, to some extent recursive: maybe keep track of your
     depth based on encountering <> and ().

   - Parentheses don't just have to happen at the end of a name: they
     can occur even if the name in question isn't a function, because
     a template argument might be a type that's a function.

   - Conversely, even if you're trying to deal with a function, its
     demangled name might not end with ')': it could be a const or
     volatile class method, in which case it ends with "const" or
     "volatile".

   - Parentheses are also used in anonymous namespaces: a variable
     'foo' in an anonymous namespace gets demangled as "(anonymous
     namespace)::foo".

   - And operator names can contain parentheses or angle brackets.  */

/* FIXME: carlton/2003-03-13: We have several functions here with
   overlapping functionality; can we combine them?  Also, do they
   handle all the above considerations correctly?  */

/* Find the last component of the demangled C++ name NAME.  NAME
   must be a method name including arguments, in order to correctly
   locate the last component.

   This function return a pointer to the first colon before the
   last component, or NULL if the name had only one component.  */

static const char *
find_last_component (const char *name)
{
  const char *p;
  int depth;

  /* Functions can have local classes, so we need to find the
     beginning of the last argument list, not the end of the first
     one.  */
  p = name + strlen (name) - 1;
  while (p > name && *p != ')')
    p--;

  if (p == name)
    return NULL;

  /* P now points at the `)' at the end of the argument list.  Walk
     back to the beginning.  */
  p--;
  depth = 1;
  while (p > name && depth > 0)
    {
      if (*p == '<' || *p == '(')
	depth--;
      else if (*p == '>' || *p == ')')
	depth++;
      p--;
    }

  if (p == name)
    return NULL;

  while (p > name && *p != ':')
    p--;

  if (p == name || p == name + 1 || p[-1] != ':')
    return NULL;

  return p - 1;
}

/* Return the name of the class containing method PHYSNAME.  */

char *
class_name_from_physname (const char *physname)
{
  char *ret = NULL;
  const char *end;
  int depth = 0;
  char *demangled_name = cplus_demangle (physname, DMGL_ANSI);

  if (demangled_name == NULL)
    return NULL;

  end = find_last_component (demangled_name);
  if (end != NULL)
    {
      ret = xmalloc (end - demangled_name + 1);
      memcpy (ret, demangled_name, end - demangled_name);
      ret[end - demangled_name] = '\0';
    }

  xfree (demangled_name);
  return ret;
}

/* Return the name of the method whose linkage name is PHYSNAME.  */

char *
method_name_from_physname (const char *physname)
{
  char *ret = NULL;
  const char *end;
  int depth = 0;
  char *demangled_name = cplus_demangle (physname, DMGL_ANSI);

  if (demangled_name == NULL)
    return NULL;

  end = find_last_component (demangled_name);
  if (end != NULL)
    {
      char *args;
      int len;

      /* Skip "::".  */
      end = end + 2;

      /* Find the argument list, if any.  */
      args = strchr (end, '(');
      if (args == NULL)
	len = strlen (end + 2);
      else
	{
	  args --;
	  while (*args == ' ')
	    args --;
	  len = args - end + 1;
	}
      ret = xmalloc (len + 1);
      memcpy (ret, end, len);
      ret[len] = 0;
    }

  xfree (demangled_name);
  return ret;
}

/* This returns the length of first component of NAME, which should be
   the demangled name of a C++ variable/function/method/etc.
   Specifically, it returns the index of the first colon forming the
   boundary of the first component: so, given 'A::foo' or 'A::B::foo'
   it returns the 1, and given 'foo', it returns 0.  */

/* Well, that's what it should do when called externally, but to make
   the recursion easier, it also stops if it reaches an unexpected ')'
   or '>'.  */

/* NOTE: carlton/2003-03-13: This function is currently only intended
   for internal use: it's probably not entirely safe when called on
   user-generated input, because some of the 'index += 2' lines might
   go past the end of malformed input.  */

/* Let's optimize away calls to strlen("operator").  */

#define LENGTH_OF_OPERATOR 8

unsigned int
cp_find_first_component (const char *name)
{
  unsigned int index = 0;
  /* Operator names can show up in unexpected places.  Since these can
     contain parentheses or angle brackets, they can screw up the
     recursion.  But not every string 'operator' is part of an
     operater name: e.g. you could have a variable 'cooperator'.  So
     this variable tells us whether or not we should treat the string
     'operator' as starting an operator.  */
  int operator_possible = 1;

  for (;; ++index)
    {
      switch (name[index])
	{
	case '<':
	  /* Template; eat it up.  The calls to cp_first_component
	     should only return (I hope!) when they reach the '>'
	     terminating the component or a '::' between two
	     components.  (Hence the '+ 2'.)  */
	  index += 1;
	  for (index += cp_find_first_component (name + index);
	       name[index] != '>';
	       index += cp_find_first_component (name + index))
	    {
	      gdb_assert (name[index] == ':');
	      index += 2;
	    }
	  operator_possible = 1;
	  break;
	case '(':
	  /* Similar comment as to '<'.  */
	  index += 1;
	  for (index += cp_find_first_component (name + index);
	       name[index] != ')';
	       index += cp_find_first_component (name + index))
	    {
	      gdb_assert (name[index] == ':');
	      index += 2;
	    }
	  operator_possible = 1;
	  break;
	case '>':
	case ')':
	case '\0':
	case ':':
	  return index;
	case 'o':
	  /* Operator names can screw up the recursion.  */
	  if (operator_possible
	      && strncmp (name + index, "operator", LENGTH_OF_OPERATOR) == 0)
	    {
	      index += LENGTH_OF_OPERATOR;
	      while (isspace(name[index]))
		++index;
	      switch (name[index])
		{
		  /* Skip over one less than the appropriate number of
		     characters: the for loop will skip over the last
		     one.  */
		case '<':
		  if (name[index + 1] == '<')
		    index += 1;
		  else
		    index += 0;
		  break;
		case '>':
		case '-':
		  if (name[index + 1] == '>')
		    index += 1;
		  else
		    index += 0;
		  break;
		case '(':
		  index += 1;
		  break;
		default:
		  index += 0;
		  break;
		}
	    }
	  operator_possible = 0;
	  break;
	case ' ':
	case ',':
	case '.':
	case '&':
	case '*':
	  /* NOTE: carlton/2003-04-18: I'm not sure what the precise
	     set of relevant characters are here: it's necessary to
	     include any character that can show up before 'operator'
	     in a demangled name, and it's safe to include any
	     character that can't be part of an identifier's name.  */
	  operator_possible = 1;
	  break;
	default:
	  operator_possible = 0;
	  break;
	}
    }
}

/* If NAME is the fully-qualified name of a C++
   function/variable/method/etc., this returns the length of its
   entire prefix: all of the namespaces and classes that make up its
   name.  Given 'A::foo', it returns 1, given 'A::B::foo', it returns
   4, given 'foo', it returns 0.  */

unsigned int
cp_entire_prefix_len (const char *name)
{
  unsigned int current_len = cp_find_first_component (name);
  unsigned int previous_len = 0;

  while (name[current_len] != '\0')
    {
      gdb_assert (name[current_len] == ':');
      previous_len = current_len;
      /* Skip the '::'.  */
      current_len += 2;
      current_len += cp_find_first_component (name + current_len);
    }

  return previous_len;
}

/* Don't allow just "maintenance cplus".  */

static  void
maint_cplus_command (char *arg, int from_tty)
{
  printf_unfiltered ("\"maintenance cplus\" must be followed by the name of a command.\n");
  help_list (maint_cplus_cmd_list, "maintenance cplus ", -1, gdb_stdout);
}

/* This is a front end for cp_find_first_component, for unit testing.
   Be careful when using it: see the NOTE above
   cp_find_first_component.  */

static void
first_component_command (char *arg, int from_tty)
{
  int len = cp_find_first_component (arg);
  char *prefix = alloca (len + 1);

  memcpy (prefix, arg, len);
  prefix[len] = '\0';

  printf_unfiltered ("%s\n", prefix);
}

extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */

void
_initialize_cp_support (void)
{
  add_prefix_cmd ("cplus", class_maintenance, maint_cplus_command,
		  "C++ maintenance commands.", &maint_cplus_cmd_list,
		  "maintenance cplus ", 0, &maintenancelist);
  add_alias_cmd ("cp", "cplus", class_maintenance, 1, &maintenancelist);

  add_cmd ("first_component", class_maintenance, first_component_command,
	   "Print the first class/namespace component of NAME.",
	   &maint_cplus_cmd_list);
		  
}
Commit	Line	Data
de17c821	1	/* Helper routines for C++ support in GDB.
9219021c	2	Copyright 2002, 2003 Free Software Foundation, Inc.
de17c821 DJ	3
	4	Contributed by MontaVista Software.
	5
	6	This file is part of GDB.
	7
	8	This program is free software; you can redistribute it and/or modify
	9	it under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	11	(at your option) any later version.
	12
	13	This program is distributed in the hope that it will be useful,
	14	but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	GNU General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	19	along with this program; if not, write to the Free Software
	20	Foundation, Inc., 59 Temple Place - Suite 330,
	21	Boston, MA 02111-1307, USA. */
	22
	23	#include "defs.h"
9219021c	24	#include <ctype.h>
de17c821 DJ	25	#include "cp-support.h"
	26	#include "gdb_string.h"
	27	#include "demangle.h"
9219021c DC	28	#include "gdb_assert.h"
	29	#include "gdbcmd.h"
	30
	31	/* The list of "maint cplus" commands. */
	32
	33	static struct cmd_list_element *maint_cplus_cmd_list = NULL;
	34
	35	/* The actual commands. */
	36
	37	static void maint_cplus_command (char *arg, int from_tty);
	38	static void first_component_command (char *arg, int from_tty);
	39
	40	/* Here are some random pieces of trivia to keep in mind while trying
	41	to take apart demangled names:
	42
	43	- Names can contain function arguments or templates, so the process
	44	has to be, to some extent recursive: maybe keep track of your
	45	depth based on encountering <> and ().
	46
	47	- Parentheses don't just have to happen at the end of a name: they
	48	can occur even if the name in question isn't a function, because
	49	a template argument might be a type that's a function.
	50
	51	- Conversely, even if you're trying to deal with a function, its
	52	demangled name might not end with ')': it could be a const or
	53	volatile class method, in which case it ends with "const" or
	54	"volatile".
	55
	56	- Parentheses are also used in anonymous namespaces: a variable
	57	'foo' in an anonymous namespace gets demangled as "(anonymous
	58	namespace)::foo".
	59
0f20eeea	60	- And operator names can contain parentheses or angle brackets. */
9219021c DC	61
	62	/* FIXME: carlton/2003-03-13: We have several functions here with
	63	overlapping functionality; can we combine them? Also, do they
	64	handle all the above considerations correctly? */
de17c821 DJ	65
	66	/* Find the last component of the demangled C++ name NAME. NAME
	67	must be a method name including arguments, in order to correctly
	68	locate the last component.
	69
	70	This function return a pointer to the first colon before the
	71	last component, or NULL if the name had only one component. */
	72
	73	static const char *
	74	find_last_component (const char *name)
	75	{
	76	const char *p;
	77	int depth;
	78
	79	/* Functions can have local classes, so we need to find the
	80	beginning of the last argument list, not the end of the first
	81	one. */
	82	p = name + strlen (name) - 1;
	83	while (p > name && *p != ')')
	84	p--;
	85
	86	if (p == name)
	87	return NULL;
	88
	89	/* P now points at the `)' at the end of the argument list. Walk
	90	back to the beginning. */
	91	p--;
	92	depth = 1;
	93	while (p > name && depth > 0)
	94	{
	95	if (p == '<' \|\| p == '(')
	96	depth--;
	97	else if (p == '>' \|\| p == ')')
	98	depth++;
	99	p--;
	100	}
	101
	102	if (p == name)
	103	return NULL;
	104
	105	while (p > name && *p != ':')
	106	p--;
	107
	108	if (p == name \|\| p == name + 1 \|\| p[-1] != ':')
	109	return NULL;
	110
	111	return p - 1;
	112	}
	113
	114	/* Return the name of the class containing method PHYSNAME. */
	115
	116	char *
	117	class_name_from_physname (const char *physname)
	118	{
	119	char *ret = NULL;
	120	const char *end;
	121	int depth = 0;
	122	char *demangled_name = cplus_demangle (physname, DMGL_ANSI);
	123
	124	if (demangled_name == NULL)
	125	return NULL;
	126
	127	end = find_last_component (demangled_name);
	128	if (end != NULL)
129	{
130	ret = xmalloc (end - demangled_name + 1);
131	memcpy (ret, demangled_name, end - demangled_name);
132	ret[end - demangled_name] = '\0';
133	}
134
135	xfree (demangled_name);
136	return ret;
137	}
138
139	/* Return the name of the method whose linkage name is PHYSNAME. */
140
141	char *
142	method_name_from_physname (const char *physname)
143	{
144	char *ret = NULL;
145	const char *end;
146	int depth = 0;
147	char *demangled_name = cplus_demangle (physname, DMGL_ANSI);
148
149	if (demangled_name == NULL)
150	return NULL;
151
152	end = find_last_component (demangled_name);
153	if (end != NULL)
154	{
155	char *args;
156	int len;
157
158	/* Skip "::". */
159	end = end + 2;
160
161	/* Find the argument list, if any. */
162	args = strchr (end, '(');
163	if (args == NULL)
164	len = strlen (end + 2);
165	else
166	{
167	args --;
168	while (*args == ' ')
169	args --;
170	len = args - end + 1;
171	}
172	ret = xmalloc (len + 1);
173	memcpy (ret, end, len);
174	ret[len] = 0;
175	}
176
177	xfree (demangled_name);
178	return ret;
179	}
9219021c DC	180
	181	/* This returns the length of first component of NAME, which should be
	182	the demangled name of a C++ variable/function/method/etc.
	183	Specifically, it returns the index of the first colon forming the
	184	boundary of the first component: so, given 'A::foo' or 'A::B::foo'
	185	it returns the 1, and given 'foo', it returns 0. */
	186
	187	/* Well, that's what it should do when called externally, but to make
	188	the recursion easier, it also stops if it reaches an unexpected ')'
	189	or '>'. */
	190
	191	/* NOTE: carlton/2003-03-13: This function is currently only intended
	192	for internal use: it's probably not entirely safe when called on
	193	user-generated input, because some of the 'index += 2' lines might
	194	go past the end of malformed input. */
	195
	196	/* Let's optimize away calls to strlen("operator"). */
	197
	198	#define LENGTH_OF_OPERATOR 8
	199
	200	unsigned int
	201	cp_find_first_component (const char *name)
	202	{
9219021c	203	unsigned int index = 0;
0f20eeea DC	204	/* Operator names can show up in unexpected places. Since these can
	205	contain parentheses or angle brackets, they can screw up the
	206	recursion. But not every string 'operator' is part of an
	207	operater name: e.g. you could have a variable 'cooperator'. So
	208	this variable tells us whether or not we should treat the string
	209	'operator' as starting an operator. */
	210	int operator_possible = 1;
9219021c DC	211
	212	for (;; ++index)
	213	{
	214	switch (name[index])
	215	{
	216	case '<':
	217	/* Template; eat it up. The calls to cp_first_component
	218	should only return (I hope!) when they reach the '>'
	219	terminating the component or a '::' between two
	220	components. (Hence the '+ 2'.) */
	221	index += 1;
	222	for (index += cp_find_first_component (name + index);
	223	name[index] != '>';
	224	index += cp_find_first_component (name + index))
	225	{
	226	gdb_assert (name[index] == ':');
	227	index += 2;
	228	}
0f20eeea	229	operator_possible = 1;
9219021c DC	230	break;
	231	case '(':
	232	/* Similar comment as to '<'. */
	233	index += 1;
	234	for (index += cp_find_first_component (name + index);
	235	name[index] != ')';
	236	index += cp_find_first_component (name + index))
	237	{
	238	gdb_assert (name[index] == ':');
	239	index += 2;
	240	}
0f20eeea	241	operator_possible = 1;
9219021c DC	242	break;
	243	case '>':
	244	case ')':
	245	case '\0':
	246	case ':':
	247	return index;
0f20eeea DC	248	case 'o':
	249	/* Operator names can screw up the recursion. */
	250	if (operator_possible
	251	&& strncmp (name + index, "operator", LENGTH_OF_OPERATOR) == 0)
	252	{
	253	index += LENGTH_OF_OPERATOR;
	254	while (isspace(name[index]))
	255	++index;
	256	switch (name[index])
	257	{
	258	/* Skip over one less than the appropriate number of
	259	characters: the for loop will skip over the last
	260	one. */
	261	case '<':
	262	if (name[index + 1] == '<')
	263	index += 1;
	264	else
	265	index += 0;
	266	break;
	267	case '>':
	268	case '-':
	269	if (name[index + 1] == '>')
	270	index += 1;
	271	else
	272	index += 0;
	273	break;
	274	case '(':
	275	index += 1;
	276	break;
	277	default:
	278	index += 0;
	279	break;
	280	}
	281	}
	282	operator_possible = 0;
	283	break;
	284	case ' ':
	285	case ',':
	286	case '.':
	287	case '&':
	288	case '*':
	289	/* NOTE: carlton/2003-04-18: I'm not sure what the precise
	290	set of relevant characters are here: it's necessary to
	291	include any character that can show up before 'operator'
	292	in a demangled name, and it's safe to include any
	293	character that can't be part of an identifier's name. */
	294	operator_possible = 1;
	295	break;
9219021c	296	default:
0f20eeea	297	operator_possible = 0;
9219021c DC	298	break;
	299	}
	300	}
	301	}
	302
	303	/* If NAME is the fully-qualified name of a C++
	304	function/variable/method/etc., this returns the length of its
	305	entire prefix: all of the namespaces and classes that make up its
	306	name. Given 'A::foo', it returns 1, given 'A::B::foo', it returns
	307	4, given 'foo', it returns 0. */
	308
	309	unsigned int
	310	cp_entire_prefix_len (const char *name)
	311	{
	312	unsigned int current_len = cp_find_first_component (name);
	313	unsigned int previous_len = 0;
	314
	315	while (name[current_len] != '\0')
	316	{
	317	gdb_assert (name[current_len] == ':');
	318	previous_len = current_len;
	319	/* Skip the '::'. */
	320	current_len += 2;
	321	current_len += cp_find_first_component (name + current_len);
	322	}
	323
	324	return previous_len;
	325	}
	326
	327	/* Don't allow just "maintenance cplus". */
	328
	329	static void
	330	maint_cplus_command (char *arg, int from_tty)
	331	{
	332	printf_unfiltered ("\"maintenance cplus\" must be followed by the name of a command.\n");
	333	help_list (maint_cplus_cmd_list, "maintenance cplus ", -1, gdb_stdout);
	334	}
	335
	336	/* This is a front end for cp_find_first_component, for unit testing.
	337	Be careful when using it: see the NOTE above
	338	cp_find_first_component. */
	339
	340	static void
	341	first_component_command (char *arg, int from_tty)
	342	{
	343	int len = cp_find_first_component (arg);
	344	char *prefix = alloca (len + 1);
	345
	346	memcpy (prefix, arg, len);
	347	prefix[len] = '\0';
	348
	349	printf_unfiltered ("%s\n", prefix);
	350	}
	351
b9362cc7 AC	352	extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */
b9362cc7 AC	353
9219021c DC	354	void
	355	_initialize_cp_support (void)
	356	{
	357	add_prefix_cmd ("cplus", class_maintenance, maint_cplus_command,
	358	"C++ maintenance commands.", &maint_cplus_cmd_list,
	359	"maintenance cplus ", 0, &maintenancelist);
	360	add_alias_cmd ("cp", "cplus", class_maintenance, 1, &maintenancelist);
	361
	362	add_cmd ("first_component", class_maintenance, first_component_command,
	363	"Print the first class/namespace component of NAME.",
	364	&maint_cplus_cmd_list);
	365
	366	}