/* Helper routines for C++ support in GDB.
|
/* Helper routines for C++ support in GDB.
|
Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
|
Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010
|
Free Software Foundation, Inc.
|
Free Software Foundation, Inc.
|
|
|
Contributed by MontaVista Software.
|
Contributed by MontaVista Software.
|
|
|
This file is part of GDB.
|
This file is part of GDB.
|
|
|
This program is free software; you can redistribute it and/or modify
|
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
|
it under the terms of the GNU General Public License as published by
|
the Free Software Foundation; either version 3 of the License, or
|
the Free Software Foundation; either version 3 of the License, or
|
(at your option) any later version.
|
(at your option) any later version.
|
|
|
This program is distributed in the hope that it will be useful,
|
This program is distributed in the hope that it will be useful,
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
GNU General Public License for more details.
|
GNU General Public License for more details.
|
|
|
You should have received a copy of the GNU General Public License
|
You should have received a copy of the GNU General Public License
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
along with this program. If not, see <http://www.gnu.org/licenses/>. */
|
|
|
#include "defs.h"
|
#include "defs.h"
|
#include "cp-support.h"
|
#include "cp-support.h"
|
#include "gdb_string.h"
|
#include "gdb_string.h"
|
#include "demangle.h"
|
#include "demangle.h"
|
#include "gdb_assert.h"
|
#include "gdb_assert.h"
|
#include "gdbcmd.h"
|
#include "gdbcmd.h"
|
#include "dictionary.h"
|
#include "dictionary.h"
|
#include "objfiles.h"
|
#include "objfiles.h"
|
#include "frame.h"
|
#include "frame.h"
|
#include "symtab.h"
|
#include "symtab.h"
|
#include "block.h"
|
#include "block.h"
|
#include "complaints.h"
|
#include "complaints.h"
|
#include "gdbtypes.h"
|
#include "gdbtypes.h"
|
#include "exceptions.h"
|
#include "exceptions.h"
|
#include "expression.h"
|
#include "expression.h"
|
#include "value.h"
|
#include "value.h"
|
|
|
#include "safe-ctype.h"
|
#include "safe-ctype.h"
|
|
|
#define d_left(dc) (dc)->u.s_binary.left
|
#define d_left(dc) (dc)->u.s_binary.left
|
#define d_right(dc) (dc)->u.s_binary.right
|
#define d_right(dc) (dc)->u.s_binary.right
|
|
|
/* Functions related to demangled name parsing. */
|
/* Functions related to demangled name parsing. */
|
|
|
static unsigned int cp_find_first_component_aux (const char *name,
|
static unsigned int cp_find_first_component_aux (const char *name,
|
int permissive);
|
int permissive);
|
|
|
static void demangled_name_complaint (const char *name);
|
static void demangled_name_complaint (const char *name);
|
|
|
/* Functions/variables related to overload resolution. */
|
/* Functions/variables related to overload resolution. */
|
|
|
static int sym_return_val_size;
|
static int sym_return_val_size;
|
static int sym_return_val_index;
|
static int sym_return_val_index;
|
static struct symbol **sym_return_val;
|
static struct symbol **sym_return_val;
|
|
|
static void overload_list_add_symbol (struct symbol *sym,
|
static void overload_list_add_symbol (struct symbol *sym,
|
const char *oload_name);
|
const char *oload_name);
|
|
|
static void make_symbol_overload_list_using (const char *func_name,
|
static void make_symbol_overload_list_using (const char *func_name,
|
const char *namespace);
|
const char *namespace);
|
|
|
static void make_symbol_overload_list_qualified (const char *func_name);
|
static void make_symbol_overload_list_qualified (const char *func_name);
|
|
|
static void read_in_psymtabs (const char *oload_name);
|
static void read_in_psymtabs (const char *oload_name);
|
|
|
/* The list of "maint cplus" commands. */
|
/* The list of "maint cplus" commands. */
|
|
|
struct cmd_list_element *maint_cplus_cmd_list = NULL;
|
struct cmd_list_element *maint_cplus_cmd_list = NULL;
|
|
|
/* The actual commands. */
|
/* The actual commands. */
|
|
|
static void maint_cplus_command (char *arg, int from_tty);
|
static void maint_cplus_command (char *arg, int from_tty);
|
static void first_component_command (char *arg, int from_tty);
|
static void first_component_command (char *arg, int from_tty);
|
|
|
/* Operator validation.
|
/* Operator validation.
|
NOTE: Multi-byte operators (usually the assignment variety operator)
|
NOTE: Multi-byte operators (usually the assignment variety operator)
|
must appear before the single byte version, i.e., "+=" before "+". */
|
must appear before the single byte version, i.e., "+=" before "+". */
|
static const char *operator_tokens[] =
|
static const char *operator_tokens[] =
|
{
|
{
|
"++", "+=", "+", "->*", "->", "--", "-=", "-", "*=", "*", "/=", "/",
|
"++", "+=", "+", "->*", "->", "--", "-=", "-", "*=", "*", "/=", "/",
|
"%=", "%", "!=", "==", "!", "&&", "<<=", "<<", ">>=", ">>",
|
"%=", "%", "!=", "==", "!", "&&", "<<=", "<<", ">>=", ">>",
|
"<=", "<", ">=", ">", "~", "&=", "&", "|=", "||", "|", "^=", "^",
|
"<=", "<", ">=", ">", "~", "&=", "&", "|=", "||", "|", "^=", "^",
|
"=", "()", "[]", ",", "new", "delete"
|
"=", "()", "[]", ",", "new", "delete"
|
/* new[] and delete[] require special whitespace handling */
|
/* new[] and delete[] require special whitespace handling */
|
};
|
};
|
|
|
/* Return 1 if STRING is clearly already in canonical form. This
|
/* Return 1 if STRING is clearly already in canonical form. This
|
function is conservative; things which it does not recognize are
|
function is conservative; things which it does not recognize are
|
assumed to be non-canonical, and the parser will sort them out
|
assumed to be non-canonical, and the parser will sort them out
|
afterwards. This speeds up the critical path for alphanumeric
|
afterwards. This speeds up the critical path for alphanumeric
|
identifiers. */
|
identifiers. */
|
|
|
static int
|
static int
|
cp_already_canonical (const char *string)
|
cp_already_canonical (const char *string)
|
{
|
{
|
/* Identifier start character [a-zA-Z_]. */
|
/* Identifier start character [a-zA-Z_]. */
|
if (!ISIDST (string[0]))
|
if (!ISIDST (string[0]))
|
return 0;
|
return 0;
|
|
|
/* These are the only two identifiers which canonicalize to other
|
/* These are the only two identifiers which canonicalize to other
|
than themselves or an error: unsigned -> unsigned int and
|
than themselves or an error: unsigned -> unsigned int and
|
signed -> int. */
|
signed -> int. */
|
if (string[0] == 'u' && strcmp (&string[1], "nsigned") == 0)
|
if (string[0] == 'u' && strcmp (&string[1], "nsigned") == 0)
|
return 0;
|
return 0;
|
else if (string[0] == 's' && strcmp (&string[1], "igned") == 0)
|
else if (string[0] == 's' && strcmp (&string[1], "igned") == 0)
|
return 0;
|
return 0;
|
|
|
/* Identifier character [a-zA-Z0-9_]. */
|
/* Identifier character [a-zA-Z0-9_]. */
|
while (ISIDNUM (string[1]))
|
while (ISIDNUM (string[1]))
|
string++;
|
string++;
|
|
|
if (string[1] == '\0')
|
if (string[1] == '\0')
|
return 1;
|
return 1;
|
else
|
else
|
return 0;
|
return 0;
|
}
|
}
|
|
|
/* Parse STRING and convert it to canonical form. If parsing fails,
|
/* Parse STRING and convert it to canonical form. If parsing fails,
|
or if STRING is already canonical, return NULL. Otherwise return
|
or if STRING is already canonical, return NULL. Otherwise return
|
the canonical form. The return value is allocated via xmalloc. */
|
the canonical form. The return value is allocated via xmalloc. */
|
|
|
char *
|
char *
|
cp_canonicalize_string (const char *string)
|
cp_canonicalize_string (const char *string)
|
{
|
{
|
struct demangle_component *ret_comp;
|
struct demangle_component *ret_comp;
|
unsigned int estimated_len;
|
unsigned int estimated_len;
|
char *ret;
|
char *ret;
|
|
|
if (cp_already_canonical (string))
|
if (cp_already_canonical (string))
|
return NULL;
|
return NULL;
|
|
|
ret_comp = cp_demangled_name_to_comp (string, NULL);
|
ret_comp = cp_demangled_name_to_comp (string, NULL);
|
if (ret_comp == NULL)
|
if (ret_comp == NULL)
|
return NULL;
|
return NULL;
|
|
|
estimated_len = strlen (string) * 2;
|
estimated_len = strlen (string) * 2;
|
ret = cp_comp_to_string (ret_comp, estimated_len);
|
ret = cp_comp_to_string (ret_comp, estimated_len);
|
|
|
if (strcmp (string, ret) == 0)
|
if (strcmp (string, ret) == 0)
|
{
|
{
|
xfree (ret);
|
xfree (ret);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Convert a mangled name to a demangle_component tree. *MEMORY is set to the
|
/* Convert a mangled name to a demangle_component tree. *MEMORY is set to the
|
block of used memory that should be freed when finished with the tree.
|
block of used memory that should be freed when finished with the tree.
|
DEMANGLED_P is set to the char * that should be freed when finished with
|
DEMANGLED_P is set to the char * that should be freed when finished with
|
the tree, or NULL if none was needed. OPTIONS will be passed to the
|
the tree, or NULL if none was needed. OPTIONS will be passed to the
|
demangler. */
|
demangler. */
|
|
|
static struct demangle_component *
|
static struct demangle_component *
|
mangled_name_to_comp (const char *mangled_name, int options,
|
mangled_name_to_comp (const char *mangled_name, int options,
|
void **memory, char **demangled_p)
|
void **memory, char **demangled_p)
|
{
|
{
|
struct demangle_component *ret;
|
struct demangle_component *ret;
|
char *demangled_name;
|
char *demangled_name;
|
int len;
|
int len;
|
|
|
/* If it looks like a v3 mangled name, then try to go directly
|
/* If it looks like a v3 mangled name, then try to go directly
|
to trees. */
|
to trees. */
|
if (mangled_name[0] == '_' && mangled_name[1] == 'Z')
|
if (mangled_name[0] == '_' && mangled_name[1] == 'Z')
|
{
|
{
|
ret = cplus_demangle_v3_components (mangled_name, options, memory);
|
ret = cplus_demangle_v3_components (mangled_name, options, memory);
|
if (ret)
|
if (ret)
|
{
|
{
|
*demangled_p = NULL;
|
*demangled_p = NULL;
|
return ret;
|
return ret;
|
}
|
}
|
}
|
}
|
|
|
/* If it doesn't, or if that failed, then try to demangle the name. */
|
/* If it doesn't, or if that failed, then try to demangle the name. */
|
demangled_name = cplus_demangle (mangled_name, options);
|
demangled_name = cplus_demangle (mangled_name, options);
|
if (demangled_name == NULL)
|
if (demangled_name == NULL)
|
return NULL;
|
return NULL;
|
|
|
/* If we could demangle the name, parse it to build the component tree. */
|
/* If we could demangle the name, parse it to build the component tree. */
|
ret = cp_demangled_name_to_comp (demangled_name, NULL);
|
ret = cp_demangled_name_to_comp (demangled_name, NULL);
|
|
|
if (ret == NULL)
|
if (ret == NULL)
|
{
|
{
|
xfree (demangled_name);
|
xfree (demangled_name);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
*demangled_p = demangled_name;
|
*demangled_p = demangled_name;
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Return the name of the class containing method PHYSNAME. */
|
/* Return the name of the class containing method PHYSNAME. */
|
|
|
char *
|
char *
|
cp_class_name_from_physname (const char *physname)
|
cp_class_name_from_physname (const char *physname)
|
{
|
{
|
void *storage = NULL;
|
void *storage = NULL;
|
char *demangled_name = NULL, *ret;
|
char *demangled_name = NULL, *ret;
|
struct demangle_component *ret_comp, *prev_comp, *cur_comp;
|
struct demangle_component *ret_comp, *prev_comp, *cur_comp;
|
int done;
|
int done;
|
|
|
ret_comp = mangled_name_to_comp (physname, DMGL_ANSI, &storage,
|
ret_comp = mangled_name_to_comp (physname, DMGL_ANSI, &storage,
|
&demangled_name);
|
&demangled_name);
|
if (ret_comp == NULL)
|
if (ret_comp == NULL)
|
return NULL;
|
return NULL;
|
|
|
done = 0;
|
done = 0;
|
|
|
/* First strip off any qualifiers, if we have a function or method. */
|
/* First strip off any qualifiers, if we have a function or method. */
|
while (!done)
|
while (!done)
|
switch (ret_comp->type)
|
switch (ret_comp->type)
|
{
|
{
|
case DEMANGLE_COMPONENT_CONST:
|
case DEMANGLE_COMPONENT_CONST:
|
case DEMANGLE_COMPONENT_RESTRICT:
|
case DEMANGLE_COMPONENT_RESTRICT:
|
case DEMANGLE_COMPONENT_VOLATILE:
|
case DEMANGLE_COMPONENT_VOLATILE:
|
case DEMANGLE_COMPONENT_CONST_THIS:
|
case DEMANGLE_COMPONENT_CONST_THIS:
|
case DEMANGLE_COMPONENT_RESTRICT_THIS:
|
case DEMANGLE_COMPONENT_RESTRICT_THIS:
|
case DEMANGLE_COMPONENT_VOLATILE_THIS:
|
case DEMANGLE_COMPONENT_VOLATILE_THIS:
|
case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
|
case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
|
ret_comp = d_left (ret_comp);
|
ret_comp = d_left (ret_comp);
|
break;
|
break;
|
default:
|
default:
|
done = 1;
|
done = 1;
|
break;
|
break;
|
}
|
}
|
|
|
/* If what we have now is a function, discard the argument list. */
|
/* If what we have now is a function, discard the argument list. */
|
if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
|
if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
|
ret_comp = d_left (ret_comp);
|
ret_comp = d_left (ret_comp);
|
|
|
/* If what we have now is a template, strip off the template
|
/* If what we have now is a template, strip off the template
|
arguments. The left subtree may be a qualified name. */
|
arguments. The left subtree may be a qualified name. */
|
if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE)
|
if (ret_comp->type == DEMANGLE_COMPONENT_TEMPLATE)
|
ret_comp = d_left (ret_comp);
|
ret_comp = d_left (ret_comp);
|
|
|
/* What we have now should be a name, possibly qualified. Additional
|
/* What we have now should be a name, possibly qualified. Additional
|
qualifiers could live in the left subtree or the right subtree. Find
|
qualifiers could live in the left subtree or the right subtree. Find
|
the last piece. */
|
the last piece. */
|
done = 0;
|
done = 0;
|
prev_comp = NULL;
|
prev_comp = NULL;
|
cur_comp = ret_comp;
|
cur_comp = ret_comp;
|
while (!done)
|
while (!done)
|
switch (cur_comp->type)
|
switch (cur_comp->type)
|
{
|
{
|
case DEMANGLE_COMPONENT_QUAL_NAME:
|
case DEMANGLE_COMPONENT_QUAL_NAME:
|
case DEMANGLE_COMPONENT_LOCAL_NAME:
|
case DEMANGLE_COMPONENT_LOCAL_NAME:
|
prev_comp = cur_comp;
|
prev_comp = cur_comp;
|
cur_comp = d_right (cur_comp);
|
cur_comp = d_right (cur_comp);
|
break;
|
break;
|
case DEMANGLE_COMPONENT_TEMPLATE:
|
case DEMANGLE_COMPONENT_TEMPLATE:
|
case DEMANGLE_COMPONENT_NAME:
|
case DEMANGLE_COMPONENT_NAME:
|
case DEMANGLE_COMPONENT_CTOR:
|
case DEMANGLE_COMPONENT_CTOR:
|
case DEMANGLE_COMPONENT_DTOR:
|
case DEMANGLE_COMPONENT_DTOR:
|
case DEMANGLE_COMPONENT_OPERATOR:
|
case DEMANGLE_COMPONENT_OPERATOR:
|
case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
|
case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
|
done = 1;
|
done = 1;
|
break;
|
break;
|
default:
|
default:
|
done = 1;
|
done = 1;
|
cur_comp = NULL;
|
cur_comp = NULL;
|
break;
|
break;
|
}
|
}
|
|
|
ret = NULL;
|
ret = NULL;
|
if (cur_comp != NULL && prev_comp != NULL)
|
if (cur_comp != NULL && prev_comp != NULL)
|
{
|
{
|
/* We want to discard the rightmost child of PREV_COMP. */
|
/* We want to discard the rightmost child of PREV_COMP. */
|
*prev_comp = *d_left (prev_comp);
|
*prev_comp = *d_left (prev_comp);
|
/* The ten is completely arbitrary; we don't have a good estimate. */
|
/* The ten is completely arbitrary; we don't have a good estimate. */
|
ret = cp_comp_to_string (ret_comp, 10);
|
ret = cp_comp_to_string (ret_comp, 10);
|
}
|
}
|
|
|
xfree (storage);
|
xfree (storage);
|
if (demangled_name)
|
if (demangled_name)
|
xfree (demangled_name);
|
xfree (demangled_name);
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Return the child of COMP which is the basename of a method, variable,
|
/* Return the child of COMP which is the basename of a method, variable,
|
et cetera. All scope qualifiers are discarded, but template arguments
|
et cetera. All scope qualifiers are discarded, but template arguments
|
will be included. The component tree may be modified. */
|
will be included. The component tree may be modified. */
|
|
|
static struct demangle_component *
|
static struct demangle_component *
|
unqualified_name_from_comp (struct demangle_component *comp)
|
unqualified_name_from_comp (struct demangle_component *comp)
|
{
|
{
|
struct demangle_component *ret_comp = comp, *last_template;
|
struct demangle_component *ret_comp = comp, *last_template;
|
int done;
|
int done;
|
|
|
done = 0;
|
done = 0;
|
last_template = NULL;
|
last_template = NULL;
|
while (!done)
|
while (!done)
|
switch (ret_comp->type)
|
switch (ret_comp->type)
|
{
|
{
|
case DEMANGLE_COMPONENT_QUAL_NAME:
|
case DEMANGLE_COMPONENT_QUAL_NAME:
|
case DEMANGLE_COMPONENT_LOCAL_NAME:
|
case DEMANGLE_COMPONENT_LOCAL_NAME:
|
ret_comp = d_right (ret_comp);
|
ret_comp = d_right (ret_comp);
|
break;
|
break;
|
case DEMANGLE_COMPONENT_TYPED_NAME:
|
case DEMANGLE_COMPONENT_TYPED_NAME:
|
ret_comp = d_left (ret_comp);
|
ret_comp = d_left (ret_comp);
|
break;
|
break;
|
case DEMANGLE_COMPONENT_TEMPLATE:
|
case DEMANGLE_COMPONENT_TEMPLATE:
|
gdb_assert (last_template == NULL);
|
gdb_assert (last_template == NULL);
|
last_template = ret_comp;
|
last_template = ret_comp;
|
ret_comp = d_left (ret_comp);
|
ret_comp = d_left (ret_comp);
|
break;
|
break;
|
case DEMANGLE_COMPONENT_CONST:
|
case DEMANGLE_COMPONENT_CONST:
|
case DEMANGLE_COMPONENT_RESTRICT:
|
case DEMANGLE_COMPONENT_RESTRICT:
|
case DEMANGLE_COMPONENT_VOLATILE:
|
case DEMANGLE_COMPONENT_VOLATILE:
|
case DEMANGLE_COMPONENT_CONST_THIS:
|
case DEMANGLE_COMPONENT_CONST_THIS:
|
case DEMANGLE_COMPONENT_RESTRICT_THIS:
|
case DEMANGLE_COMPONENT_RESTRICT_THIS:
|
case DEMANGLE_COMPONENT_VOLATILE_THIS:
|
case DEMANGLE_COMPONENT_VOLATILE_THIS:
|
case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
|
case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
|
ret_comp = d_left (ret_comp);
|
ret_comp = d_left (ret_comp);
|
break;
|
break;
|
case DEMANGLE_COMPONENT_NAME:
|
case DEMANGLE_COMPONENT_NAME:
|
case DEMANGLE_COMPONENT_CTOR:
|
case DEMANGLE_COMPONENT_CTOR:
|
case DEMANGLE_COMPONENT_DTOR:
|
case DEMANGLE_COMPONENT_DTOR:
|
case DEMANGLE_COMPONENT_OPERATOR:
|
case DEMANGLE_COMPONENT_OPERATOR:
|
case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
|
case DEMANGLE_COMPONENT_EXTENDED_OPERATOR:
|
done = 1;
|
done = 1;
|
break;
|
break;
|
default:
|
default:
|
return NULL;
|
return NULL;
|
break;
|
break;
|
}
|
}
|
|
|
if (last_template)
|
if (last_template)
|
{
|
{
|
d_left (last_template) = ret_comp;
|
d_left (last_template) = ret_comp;
|
return last_template;
|
return last_template;
|
}
|
}
|
|
|
return ret_comp;
|
return ret_comp;
|
}
|
}
|
|
|
/* Return the name of the method whose linkage name is PHYSNAME. */
|
/* Return the name of the method whose linkage name is PHYSNAME. */
|
|
|
char *
|
char *
|
method_name_from_physname (const char *physname)
|
method_name_from_physname (const char *physname)
|
{
|
{
|
void *storage = NULL;
|
void *storage = NULL;
|
char *demangled_name = NULL, *ret;
|
char *demangled_name = NULL, *ret;
|
struct demangle_component *ret_comp;
|
struct demangle_component *ret_comp;
|
int done;
|
int done;
|
|
|
ret_comp = mangled_name_to_comp (physname, DMGL_ANSI, &storage,
|
ret_comp = mangled_name_to_comp (physname, DMGL_ANSI, &storage,
|
&demangled_name);
|
&demangled_name);
|
if (ret_comp == NULL)
|
if (ret_comp == NULL)
|
return NULL;
|
return NULL;
|
|
|
ret_comp = unqualified_name_from_comp (ret_comp);
|
ret_comp = unqualified_name_from_comp (ret_comp);
|
|
|
ret = NULL;
|
ret = NULL;
|
if (ret_comp != NULL)
|
if (ret_comp != NULL)
|
/* The ten is completely arbitrary; we don't have a good estimate. */
|
/* The ten is completely arbitrary; we don't have a good estimate. */
|
ret = cp_comp_to_string (ret_comp, 10);
|
ret = cp_comp_to_string (ret_comp, 10);
|
|
|
xfree (storage);
|
xfree (storage);
|
if (demangled_name)
|
if (demangled_name)
|
xfree (demangled_name);
|
xfree (demangled_name);
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* If FULL_NAME is the demangled name of a C++ function (including an
|
/* If FULL_NAME is the demangled name of a C++ function (including an
|
arg list, possibly including namespace/class qualifications),
|
arg list, possibly including namespace/class qualifications),
|
return a new string containing only the function name (without the
|
return a new string containing only the function name (without the
|
arg list/class qualifications). Otherwise, return NULL. The
|
arg list/class qualifications). Otherwise, return NULL. The
|
caller is responsible for freeing the memory in question. */
|
caller is responsible for freeing the memory in question. */
|
|
|
char *
|
char *
|
cp_func_name (const char *full_name)
|
cp_func_name (const char *full_name)
|
{
|
{
|
char *ret;
|
char *ret;
|
struct demangle_component *ret_comp;
|
struct demangle_component *ret_comp;
|
int done;
|
int done;
|
|
|
ret_comp = cp_demangled_name_to_comp (full_name, NULL);
|
ret_comp = cp_demangled_name_to_comp (full_name, NULL);
|
if (!ret_comp)
|
if (!ret_comp)
|
return NULL;
|
return NULL;
|
|
|
ret_comp = unqualified_name_from_comp (ret_comp);
|
ret_comp = unqualified_name_from_comp (ret_comp);
|
|
|
ret = NULL;
|
ret = NULL;
|
if (ret_comp != NULL)
|
if (ret_comp != NULL)
|
ret = cp_comp_to_string (ret_comp, 10);
|
ret = cp_comp_to_string (ret_comp, 10);
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* DEMANGLED_NAME is the name of a function, including parameters and
|
/* DEMANGLED_NAME is the name of a function, including parameters and
|
(optionally) a return type. Return the name of the function without
|
(optionally) a return type. Return the name of the function without
|
parameters or return type, or NULL if we can not parse the name. */
|
parameters or return type, or NULL if we can not parse the name. */
|
|
|
char *
|
char *
|
cp_remove_params (const char *demangled_name)
|
cp_remove_params (const char *demangled_name)
|
{
|
{
|
int done = 0;
|
int done = 0;
|
struct demangle_component *ret_comp;
|
struct demangle_component *ret_comp;
|
char *ret = NULL;
|
char *ret = NULL;
|
|
|
if (demangled_name == NULL)
|
if (demangled_name == NULL)
|
return NULL;
|
return NULL;
|
|
|
ret_comp = cp_demangled_name_to_comp (demangled_name, NULL);
|
ret_comp = cp_demangled_name_to_comp (demangled_name, NULL);
|
if (ret_comp == NULL)
|
if (ret_comp == NULL)
|
return NULL;
|
return NULL;
|
|
|
/* First strip off any qualifiers, if we have a function or method. */
|
/* First strip off any qualifiers, if we have a function or method. */
|
while (!done)
|
while (!done)
|
switch (ret_comp->type)
|
switch (ret_comp->type)
|
{
|
{
|
case DEMANGLE_COMPONENT_CONST:
|
case DEMANGLE_COMPONENT_CONST:
|
case DEMANGLE_COMPONENT_RESTRICT:
|
case DEMANGLE_COMPONENT_RESTRICT:
|
case DEMANGLE_COMPONENT_VOLATILE:
|
case DEMANGLE_COMPONENT_VOLATILE:
|
case DEMANGLE_COMPONENT_CONST_THIS:
|
case DEMANGLE_COMPONENT_CONST_THIS:
|
case DEMANGLE_COMPONENT_RESTRICT_THIS:
|
case DEMANGLE_COMPONENT_RESTRICT_THIS:
|
case DEMANGLE_COMPONENT_VOLATILE_THIS:
|
case DEMANGLE_COMPONENT_VOLATILE_THIS:
|
case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
|
case DEMANGLE_COMPONENT_VENDOR_TYPE_QUAL:
|
ret_comp = d_left (ret_comp);
|
ret_comp = d_left (ret_comp);
|
break;
|
break;
|
default:
|
default:
|
done = 1;
|
done = 1;
|
break;
|
break;
|
}
|
}
|
|
|
/* What we have now should be a function. Return its name. */
|
/* What we have now should be a function. Return its name. */
|
if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
|
if (ret_comp->type == DEMANGLE_COMPONENT_TYPED_NAME)
|
ret = cp_comp_to_string (d_left (ret_comp), 10);
|
ret = cp_comp_to_string (d_left (ret_comp), 10);
|
|
|
return ret;
|
return ret;
|
}
|
}
|
|
|
/* Here are some random pieces of trivia to keep in mind while trying
|
/* Here are some random pieces of trivia to keep in mind while trying
|
to take apart demangled names:
|
to take apart demangled names:
|
|
|
- Names can contain function arguments or templates, so the process
|
- Names can contain function arguments or templates, so the process
|
has to be, to some extent recursive: maybe keep track of your
|
has to be, to some extent recursive: maybe keep track of your
|
depth based on encountering <> and ().
|
depth based on encountering <> and ().
|
|
|
- Parentheses don't just have to happen at the end of a name: they
|
- 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
|
can occur even if the name in question isn't a function, because
|
a template argument might be a type that's a function.
|
a template argument might be a type that's a function.
|
|
|
- Conversely, even if you're trying to deal with a function, its
|
- Conversely, even if you're trying to deal with a function, its
|
demangled name might not end with ')': it could be a const or
|
demangled name might not end with ')': it could be a const or
|
volatile class method, in which case it ends with "const" or
|
volatile class method, in which case it ends with "const" or
|
"volatile".
|
"volatile".
|
|
|
- Parentheses are also used in anonymous namespaces: a variable
|
- Parentheses are also used in anonymous namespaces: a variable
|
'foo' in an anonymous namespace gets demangled as "(anonymous
|
'foo' in an anonymous namespace gets demangled as "(anonymous
|
namespace)::foo".
|
namespace)::foo".
|
|
|
- And operator names can contain parentheses or angle brackets. */
|
- And operator names can contain parentheses or angle brackets. */
|
|
|
/* FIXME: carlton/2003-03-13: We have several functions here with
|
/* FIXME: carlton/2003-03-13: We have several functions here with
|
overlapping functionality; can we combine them? Also, do they
|
overlapping functionality; can we combine them? Also, do they
|
handle all the above considerations correctly? */
|
handle all the above considerations correctly? */
|
|
|
|
|
/* This returns the length of first component of NAME, which should be
|
/* This returns the length of first component of NAME, which should be
|
the demangled name of a C++ variable/function/method/etc.
|
the demangled name of a C++ variable/function/method/etc.
|
Specifically, it returns the index of the first colon forming the
|
Specifically, it returns the index of the first colon forming the
|
boundary of the first component: so, given 'A::foo' or 'A::B::foo'
|
boundary of the first component: so, given 'A::foo' or 'A::B::foo'
|
it returns the 1, and given 'foo', it returns 0. */
|
it returns the 1, and given 'foo', it returns 0. */
|
|
|
/* The character in NAME indexed by the return value is guaranteed to
|
/* The character in NAME indexed by the return value is guaranteed to
|
always be either ':' or '\0'. */
|
always be either ':' or '\0'. */
|
|
|
/* NOTE: carlton/2003-03-13: This function is currently only intended
|
/* NOTE: carlton/2003-03-13: This function is currently only intended
|
for internal use: it's probably not entirely safe when called on
|
for internal use: it's probably not entirely safe when called on
|
user-generated input, because some of the 'index += 2' lines in
|
user-generated input, because some of the 'index += 2' lines in
|
cp_find_first_component_aux might go past the end of malformed
|
cp_find_first_component_aux might go past the end of malformed
|
input. */
|
input. */
|
|
|
unsigned int
|
unsigned int
|
cp_find_first_component (const char *name)
|
cp_find_first_component (const char *name)
|
{
|
{
|
return cp_find_first_component_aux (name, 0);
|
return cp_find_first_component_aux (name, 0);
|
}
|
}
|
|
|
/* Helper function for cp_find_first_component. Like that function,
|
/* Helper function for cp_find_first_component. Like that function,
|
it returns the length of the first component of NAME, but to make
|
it returns the length of the first component of NAME, but to make
|
the recursion easier, it also stops if it reaches an unexpected ')'
|
the recursion easier, it also stops if it reaches an unexpected ')'
|
or '>' if the value of PERMISSIVE is nonzero. */
|
or '>' if the value of PERMISSIVE is nonzero. */
|
|
|
/* Let's optimize away calls to strlen("operator"). */
|
/* Let's optimize away calls to strlen("operator"). */
|
|
|
#define LENGTH_OF_OPERATOR 8
|
#define LENGTH_OF_OPERATOR 8
|
|
|
static unsigned int
|
static unsigned int
|
cp_find_first_component_aux (const char *name, int permissive)
|
cp_find_first_component_aux (const char *name, int permissive)
|
{
|
{
|
unsigned int index = 0;
|
unsigned int index = 0;
|
/* Operator names can show up in unexpected places. Since these can
|
/* Operator names can show up in unexpected places. Since these can
|
contain parentheses or angle brackets, they can screw up the
|
contain parentheses or angle brackets, they can screw up the
|
recursion. But not every string 'operator' is part of an
|
recursion. But not every string 'operator' is part of an
|
operater name: e.g. you could have a variable 'cooperator'. So
|
operater name: e.g. you could have a variable 'cooperator'. So
|
this variable tells us whether or not we should treat the string
|
this variable tells us whether or not we should treat the string
|
'operator' as starting an operator. */
|
'operator' as starting an operator. */
|
int operator_possible = 1;
|
int operator_possible = 1;
|
|
|
for (;; ++index)
|
for (;; ++index)
|
{
|
{
|
switch (name[index])
|
switch (name[index])
|
{
|
{
|
case '<':
|
case '<':
|
/* Template; eat it up. The calls to cp_first_component
|
/* Template; eat it up. The calls to cp_first_component
|
should only return (I hope!) when they reach the '>'
|
should only return (I hope!) when they reach the '>'
|
terminating the component or a '::' between two
|
terminating the component or a '::' between two
|
components. (Hence the '+ 2'.) */
|
components. (Hence the '+ 2'.) */
|
index += 1;
|
index += 1;
|
for (index += cp_find_first_component_aux (name + index, 1);
|
for (index += cp_find_first_component_aux (name + index, 1);
|
name[index] != '>';
|
name[index] != '>';
|
index += cp_find_first_component_aux (name + index, 1))
|
index += cp_find_first_component_aux (name + index, 1))
|
{
|
{
|
if (name[index] != ':')
|
if (name[index] != ':')
|
{
|
{
|
demangled_name_complaint (name);
|
demangled_name_complaint (name);
|
return strlen (name);
|
return strlen (name);
|
}
|
}
|
index += 2;
|
index += 2;
|
}
|
}
|
operator_possible = 1;
|
operator_possible = 1;
|
break;
|
break;
|
case '(':
|
case '(':
|
/* Similar comment as to '<'. */
|
/* Similar comment as to '<'. */
|
index += 1;
|
index += 1;
|
for (index += cp_find_first_component_aux (name + index, 1);
|
for (index += cp_find_first_component_aux (name + index, 1);
|
name[index] != ')';
|
name[index] != ')';
|
index += cp_find_first_component_aux (name + index, 1))
|
index += cp_find_first_component_aux (name + index, 1))
|
{
|
{
|
if (name[index] != ':')
|
if (name[index] != ':')
|
{
|
{
|
demangled_name_complaint (name);
|
demangled_name_complaint (name);
|
return strlen (name);
|
return strlen (name);
|
}
|
}
|
index += 2;
|
index += 2;
|
}
|
}
|
operator_possible = 1;
|
operator_possible = 1;
|
break;
|
break;
|
case '>':
|
case '>':
|
case ')':
|
case ')':
|
if (permissive)
|
if (permissive)
|
return index;
|
return index;
|
else
|
else
|
{
|
{
|
demangled_name_complaint (name);
|
demangled_name_complaint (name);
|
return strlen (name);
|
return strlen (name);
|
}
|
}
|
case '\0':
|
case '\0':
|
case ':':
|
case ':':
|
return index;
|
return index;
|
case 'o':
|
case 'o':
|
/* Operator names can screw up the recursion. */
|
/* Operator names can screw up the recursion. */
|
if (operator_possible
|
if (operator_possible
|
&& strncmp (name + index, "operator", LENGTH_OF_OPERATOR) == 0)
|
&& strncmp (name + index, "operator", LENGTH_OF_OPERATOR) == 0)
|
{
|
{
|
index += LENGTH_OF_OPERATOR;
|
index += LENGTH_OF_OPERATOR;
|
while (ISSPACE(name[index]))
|
while (ISSPACE(name[index]))
|
++index;
|
++index;
|
switch (name[index])
|
switch (name[index])
|
{
|
{
|
/* Skip over one less than the appropriate number of
|
/* Skip over one less than the appropriate number of
|
characters: the for loop will skip over the last
|
characters: the for loop will skip over the last
|
one. */
|
one. */
|
case '<':
|
case '<':
|
if (name[index + 1] == '<')
|
if (name[index + 1] == '<')
|
index += 1;
|
index += 1;
|
else
|
else
|
index += 0;
|
index += 0;
|
break;
|
break;
|
case '>':
|
case '>':
|
case '-':
|
case '-':
|
if (name[index + 1] == '>')
|
if (name[index + 1] == '>')
|
index += 1;
|
index += 1;
|
else
|
else
|
index += 0;
|
index += 0;
|
break;
|
break;
|
case '(':
|
case '(':
|
index += 1;
|
index += 1;
|
break;
|
break;
|
default:
|
default:
|
index += 0;
|
index += 0;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
operator_possible = 0;
|
operator_possible = 0;
|
break;
|
break;
|
case ' ':
|
case ' ':
|
case ',':
|
case ',':
|
case '.':
|
case '.':
|
case '&':
|
case '&':
|
case '*':
|
case '*':
|
/* NOTE: carlton/2003-04-18: I'm not sure what the precise
|
/* NOTE: carlton/2003-04-18: I'm not sure what the precise
|
set of relevant characters are here: it's necessary to
|
set of relevant characters are here: it's necessary to
|
include any character that can show up before 'operator'
|
include any character that can show up before 'operator'
|
in a demangled name, and it's safe to include any
|
in a demangled name, and it's safe to include any
|
character that can't be part of an identifier's name. */
|
character that can't be part of an identifier's name. */
|
operator_possible = 1;
|
operator_possible = 1;
|
break;
|
break;
|
default:
|
default:
|
operator_possible = 0;
|
operator_possible = 0;
|
break;
|
break;
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Complain about a demangled name that we don't know how to parse.
|
/* Complain about a demangled name that we don't know how to parse.
|
NAME is the demangled name in question. */
|
NAME is the demangled name in question. */
|
|
|
static void
|
static void
|
demangled_name_complaint (const char *name)
|
demangled_name_complaint (const char *name)
|
{
|
{
|
complaint (&symfile_complaints,
|
complaint (&symfile_complaints,
|
"unexpected demangled name '%s'", name);
|
"unexpected demangled name '%s'", name);
|
}
|
}
|
|
|
/* If NAME is the fully-qualified name of a C++
|
/* If NAME is the fully-qualified name of a C++
|
function/variable/method/etc., this returns the length of its
|
function/variable/method/etc., this returns the length of its
|
entire prefix: all of the namespaces and classes that make up 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
|
name. Given 'A::foo', it returns 1, given 'A::B::foo', it returns
|
4, given 'foo', it returns 0. */
|
4, given 'foo', it returns 0. */
|
|
|
unsigned int
|
unsigned int
|
cp_entire_prefix_len (const char *name)
|
cp_entire_prefix_len (const char *name)
|
{
|
{
|
unsigned int current_len = cp_find_first_component (name);
|
unsigned int current_len = cp_find_first_component (name);
|
unsigned int previous_len = 0;
|
unsigned int previous_len = 0;
|
|
|
while (name[current_len] != '\0')
|
while (name[current_len] != '\0')
|
{
|
{
|
gdb_assert (name[current_len] == ':');
|
gdb_assert (name[current_len] == ':');
|
previous_len = current_len;
|
previous_len = current_len;
|
/* Skip the '::'. */
|
/* Skip the '::'. */
|
current_len += 2;
|
current_len += 2;
|
current_len += cp_find_first_component (name + current_len);
|
current_len += cp_find_first_component (name + current_len);
|
}
|
}
|
|
|
return previous_len;
|
return previous_len;
|
}
|
}
|
|
|
/* Overload resolution functions. */
|
/* Overload resolution functions. */
|
|
|
/* Test to see if SYM is a symbol that we haven't seen corresponding
|
/* Test to see if SYM is a symbol that we haven't seen corresponding
|
to a function named OLOAD_NAME. If so, add it to the current
|
to a function named OLOAD_NAME. If so, add it to the current
|
completion list. */
|
completion list. */
|
|
|
static void
|
static void
|
overload_list_add_symbol (struct symbol *sym, const char *oload_name)
|
overload_list_add_symbol (struct symbol *sym, const char *oload_name)
|
{
|
{
|
int newsize;
|
int newsize;
|
int i;
|
int i;
|
char *sym_name;
|
char *sym_name;
|
|
|
/* If there is no type information, we can't do anything, so skip */
|
/* If there is no type information, we can't do anything, so skip */
|
if (SYMBOL_TYPE (sym) == NULL)
|
if (SYMBOL_TYPE (sym) == NULL)
|
return;
|
return;
|
|
|
/* skip any symbols that we've already considered. */
|
/* skip any symbols that we've already considered. */
|
for (i = 0; i < sym_return_val_index; ++i)
|
for (i = 0; i < sym_return_val_index; ++i)
|
if (strcmp (SYMBOL_LINKAGE_NAME (sym),
|
if (strcmp (SYMBOL_LINKAGE_NAME (sym),
|
SYMBOL_LINKAGE_NAME (sym_return_val[i])) == 0)
|
SYMBOL_LINKAGE_NAME (sym_return_val[i])) == 0)
|
return;
|
return;
|
|
|
/* Get the demangled name without parameters */
|
/* Get the demangled name without parameters */
|
sym_name = cp_remove_params (SYMBOL_NATURAL_NAME (sym));
|
sym_name = cp_remove_params (SYMBOL_NATURAL_NAME (sym));
|
if (!sym_name)
|
if (!sym_name)
|
return;
|
return;
|
|
|
/* skip symbols that cannot match */
|
/* skip symbols that cannot match */
|
if (strcmp (sym_name, oload_name) != 0)
|
if (strcmp (sym_name, oload_name) != 0)
|
{
|
{
|
xfree (sym_name);
|
xfree (sym_name);
|
return;
|
return;
|
}
|
}
|
|
|
xfree (sym_name);
|
xfree (sym_name);
|
|
|
/* We have a match for an overload instance, so add SYM to the current list
|
/* We have a match for an overload instance, so add SYM to the current list
|
* of overload instances */
|
* of overload instances */
|
if (sym_return_val_index + 3 > sym_return_val_size)
|
if (sym_return_val_index + 3 > sym_return_val_size)
|
{
|
{
|
newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *);
|
newsize = (sym_return_val_size *= 2) * sizeof (struct symbol *);
|
sym_return_val = (struct symbol **) xrealloc ((char *) sym_return_val, newsize);
|
sym_return_val = (struct symbol **) xrealloc ((char *) sym_return_val, newsize);
|
}
|
}
|
sym_return_val[sym_return_val_index++] = sym;
|
sym_return_val[sym_return_val_index++] = sym;
|
sym_return_val[sym_return_val_index] = NULL;
|
sym_return_val[sym_return_val_index] = NULL;
|
}
|
}
|
|
|
/* Return a null-terminated list of pointers to function symbols that
|
/* Return a null-terminated list of pointers to function symbols that
|
are named FUNC_NAME and are visible within NAMESPACE. */
|
are named FUNC_NAME and are visible within NAMESPACE. */
|
|
|
struct symbol **
|
struct symbol **
|
make_symbol_overload_list (const char *func_name,
|
make_symbol_overload_list (const char *func_name,
|
const char *namespace)
|
const char *namespace)
|
{
|
{
|
struct cleanup *old_cleanups;
|
struct cleanup *old_cleanups;
|
|
|
sym_return_val_size = 100;
|
sym_return_val_size = 100;
|
sym_return_val_index = 0;
|
sym_return_val_index = 0;
|
sym_return_val = xmalloc ((sym_return_val_size + 1) *
|
sym_return_val = xmalloc ((sym_return_val_size + 1) *
|
sizeof (struct symbol *));
|
sizeof (struct symbol *));
|
sym_return_val[0] = NULL;
|
sym_return_val[0] = NULL;
|
|
|
old_cleanups = make_cleanup (xfree, sym_return_val);
|
old_cleanups = make_cleanup (xfree, sym_return_val);
|
|
|
make_symbol_overload_list_using (func_name, namespace);
|
make_symbol_overload_list_using (func_name, namespace);
|
|
|
discard_cleanups (old_cleanups);
|
discard_cleanups (old_cleanups);
|
|
|
return sym_return_val;
|
return sym_return_val;
|
}
|
}
|
|
|
/* This applies the using directives to add namespaces to search in,
|
/* This applies the using directives to add namespaces to search in,
|
and then searches for overloads in all of those namespaces. It
|
and then searches for overloads in all of those namespaces. It
|
adds the symbols found to sym_return_val. Arguments are as in
|
adds the symbols found to sym_return_val. Arguments are as in
|
make_symbol_overload_list. */
|
make_symbol_overload_list. */
|
|
|
static void
|
static void
|
make_symbol_overload_list_using (const char *func_name,
|
make_symbol_overload_list_using (const char *func_name,
|
const char *namespace)
|
const char *namespace)
|
{
|
{
|
const struct using_direct *current;
|
const struct using_direct *current;
|
|
|
/* First, go through the using directives. If any of them apply,
|
/* First, go through the using directives. If any of them apply,
|
look in the appropriate namespaces for new functions to match
|
look in the appropriate namespaces for new functions to match
|
on. */
|
on. */
|
|
|
for (current = block_using (get_selected_block (0));
|
for (current = block_using (get_selected_block (0));
|
current != NULL;
|
current != NULL;
|
current = current->next)
|
current = current->next)
|
{
|
{
|
if (strcmp (namespace, current->import_dest) == 0)
|
if (strcmp (namespace, current->import_dest) == 0)
|
{
|
{
|
make_symbol_overload_list_using (func_name,
|
make_symbol_overload_list_using (func_name,
|
current->import_src);
|
current->import_src);
|
}
|
}
|
}
|
}
|
|
|
/* Now, add names for this namespace. */
|
/* Now, add names for this namespace. */
|
|
|
if (namespace[0] == '\0')
|
if (namespace[0] == '\0')
|
{
|
{
|
make_symbol_overload_list_qualified (func_name);
|
make_symbol_overload_list_qualified (func_name);
|
}
|
}
|
else
|
else
|
{
|
{
|
char *concatenated_name
|
char *concatenated_name
|
= alloca (strlen (namespace) + 2 + strlen (func_name) + 1);
|
= alloca (strlen (namespace) + 2 + strlen (func_name) + 1);
|
strcpy (concatenated_name, namespace);
|
strcpy (concatenated_name, namespace);
|
strcat (concatenated_name, "::");
|
strcat (concatenated_name, "::");
|
strcat (concatenated_name, func_name);
|
strcat (concatenated_name, func_name);
|
make_symbol_overload_list_qualified (concatenated_name);
|
make_symbol_overload_list_qualified (concatenated_name);
|
}
|
}
|
}
|
}
|
|
|
/* This does the bulk of the work of finding overloaded symbols.
|
/* This does the bulk of the work of finding overloaded symbols.
|
FUNC_NAME is the name of the overloaded function we're looking for
|
FUNC_NAME is the name of the overloaded function we're looking for
|
(possibly including namespace info). */
|
(possibly including namespace info). */
|
|
|
static void
|
static void
|
make_symbol_overload_list_qualified (const char *func_name)
|
make_symbol_overload_list_qualified (const char *func_name)
|
{
|
{
|
struct symbol *sym;
|
struct symbol *sym;
|
struct symtab *s;
|
struct symtab *s;
|
struct objfile *objfile;
|
struct objfile *objfile;
|
const struct block *b, *surrounding_static_block = 0;
|
const struct block *b, *surrounding_static_block = 0;
|
struct dict_iterator iter;
|
struct dict_iterator iter;
|
const struct dictionary *dict;
|
const struct dictionary *dict;
|
|
|
/* Look through the partial symtabs for all symbols which begin
|
/* Look through the partial symtabs for all symbols which begin
|
by matching FUNC_NAME. Make sure we read that symbol table in. */
|
by matching FUNC_NAME. Make sure we read that symbol table in. */
|
|
|
read_in_psymtabs (func_name);
|
read_in_psymtabs (func_name);
|
|
|
/* Search upwards from currently selected frame (so that we can
|
/* Search upwards from currently selected frame (so that we can
|
complete on local vars. */
|
complete on local vars. */
|
|
|
for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
|
for (b = get_selected_block (0); b != NULL; b = BLOCK_SUPERBLOCK (b))
|
{
|
{
|
dict = BLOCK_DICT (b);
|
dict = BLOCK_DICT (b);
|
|
|
for (sym = dict_iter_name_first (dict, func_name, &iter);
|
for (sym = dict_iter_name_first (dict, func_name, &iter);
|
sym;
|
sym;
|
sym = dict_iter_name_next (func_name, &iter))
|
sym = dict_iter_name_next (func_name, &iter))
|
{
|
{
|
overload_list_add_symbol (sym, func_name);
|
overload_list_add_symbol (sym, func_name);
|
}
|
}
|
}
|
}
|
|
|
surrounding_static_block = block_static_block (get_selected_block (0));
|
surrounding_static_block = block_static_block (get_selected_block (0));
|
|
|
/* Go through the symtabs and check the externs and statics for
|
/* Go through the symtabs and check the externs and statics for
|
symbols which match. */
|
symbols which match. */
|
|
|
ALL_PRIMARY_SYMTABS (objfile, s)
|
ALL_PRIMARY_SYMTABS (objfile, s)
|
{
|
{
|
QUIT;
|
QUIT;
|
b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
|
b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), GLOBAL_BLOCK);
|
dict = BLOCK_DICT (b);
|
dict = BLOCK_DICT (b);
|
|
|
for (sym = dict_iter_name_first (dict, func_name, &iter);
|
for (sym = dict_iter_name_first (dict, func_name, &iter);
|
sym;
|
sym;
|
sym = dict_iter_name_next (func_name, &iter))
|
sym = dict_iter_name_next (func_name, &iter))
|
{
|
{
|
overload_list_add_symbol (sym, func_name);
|
overload_list_add_symbol (sym, func_name);
|
}
|
}
|
}
|
}
|
|
|
ALL_PRIMARY_SYMTABS (objfile, s)
|
ALL_PRIMARY_SYMTABS (objfile, s)
|
{
|
{
|
QUIT;
|
QUIT;
|
b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
|
b = BLOCKVECTOR_BLOCK (BLOCKVECTOR (s), STATIC_BLOCK);
|
/* Don't do this block twice. */
|
/* Don't do this block twice. */
|
if (b == surrounding_static_block)
|
if (b == surrounding_static_block)
|
continue;
|
continue;
|
dict = BLOCK_DICT (b);
|
dict = BLOCK_DICT (b);
|
|
|
for (sym = dict_iter_name_first (dict, func_name, &iter);
|
for (sym = dict_iter_name_first (dict, func_name, &iter);
|
sym;
|
sym;
|
sym = dict_iter_name_next (func_name, &iter))
|
sym = dict_iter_name_next (func_name, &iter))
|
{
|
{
|
overload_list_add_symbol (sym, func_name);
|
overload_list_add_symbol (sym, func_name);
|
}
|
}
|
}
|
}
|
}
|
}
|
|
|
/* Look through the partial symtabs for all symbols which begin
|
/* Look through the partial symtabs for all symbols which begin
|
by matching FUNC_NAME. Make sure we read that symbol table in. */
|
by matching FUNC_NAME. Make sure we read that symbol table in. */
|
|
|
static void
|
static void
|
read_in_psymtabs (const char *func_name)
|
read_in_psymtabs (const char *func_name)
|
{
|
{
|
struct partial_symtab *ps;
|
struct partial_symtab *ps;
|
struct objfile *objfile;
|
struct objfile *objfile;
|
|
|
ALL_PSYMTABS (objfile, ps)
|
ALL_PSYMTABS (objfile, ps)
|
{
|
{
|
if (ps->readin)
|
if (ps->readin)
|
continue;
|
continue;
|
|
|
if ((lookup_partial_symbol (ps, func_name, NULL, 1, VAR_DOMAIN)
|
if ((lookup_partial_symbol (ps, func_name, NULL, 1, VAR_DOMAIN)
|
!= NULL)
|
!= NULL)
|
|| (lookup_partial_symbol (ps, func_name, NULL, 0, VAR_DOMAIN)
|
|| (lookup_partial_symbol (ps, func_name, NULL, 0, VAR_DOMAIN)
|
!= NULL))
|
!= NULL))
|
psymtab_to_symtab (ps);
|
psymtab_to_symtab (ps);
|
}
|
}
|
}
|
}
|
|
|
/* Lookup the rtti type for a class name. */
|
/* Lookup the rtti type for a class name. */
|
|
|
struct type *
|
struct type *
|
cp_lookup_rtti_type (const char *name, struct block *block)
|
cp_lookup_rtti_type (const char *name, struct block *block)
|
{
|
{
|
struct symbol * rtti_sym;
|
struct symbol * rtti_sym;
|
struct type * rtti_type;
|
struct type * rtti_type;
|
|
|
rtti_sym = lookup_symbol (name, block, STRUCT_DOMAIN, NULL);
|
rtti_sym = lookup_symbol (name, block, STRUCT_DOMAIN, NULL);
|
|
|
if (rtti_sym == NULL)
|
if (rtti_sym == NULL)
|
{
|
{
|
warning (_("RTTI symbol not found for class '%s'"), name);
|
warning (_("RTTI symbol not found for class '%s'"), name);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
|
if (SYMBOL_CLASS (rtti_sym) != LOC_TYPEDEF)
|
{
|
{
|
warning (_("RTTI symbol for class '%s' is not a type"), name);
|
warning (_("RTTI symbol for class '%s' is not a type"), name);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
rtti_type = SYMBOL_TYPE (rtti_sym);
|
rtti_type = SYMBOL_TYPE (rtti_sym);
|
|
|
switch (TYPE_CODE (rtti_type))
|
switch (TYPE_CODE (rtti_type))
|
{
|
{
|
case TYPE_CODE_CLASS:
|
case TYPE_CODE_CLASS:
|
break;
|
break;
|
case TYPE_CODE_NAMESPACE:
|
case TYPE_CODE_NAMESPACE:
|
/* chastain/2003-11-26: the symbol tables often contain fake
|
/* chastain/2003-11-26: the symbol tables often contain fake
|
symbols for namespaces with the same name as the struct.
|
symbols for namespaces with the same name as the struct.
|
This warning is an indication of a bug in the lookup order
|
This warning is an indication of a bug in the lookup order
|
or a bug in the way that the symbol tables are populated. */
|
or a bug in the way that the symbol tables are populated. */
|
warning (_("RTTI symbol for class '%s' is a namespace"), name);
|
warning (_("RTTI symbol for class '%s' is a namespace"), name);
|
return NULL;
|
return NULL;
|
default:
|
default:
|
warning (_("RTTI symbol for class '%s' has bad type"), name);
|
warning (_("RTTI symbol for class '%s' has bad type"), name);
|
return NULL;
|
return NULL;
|
}
|
}
|
|
|
return rtti_type;
|
return rtti_type;
|
}
|
}
|
|
|
/* Don't allow just "maintenance cplus". */
|
/* Don't allow just "maintenance cplus". */
|
|
|
static void
|
static void
|
maint_cplus_command (char *arg, int from_tty)
|
maint_cplus_command (char *arg, int from_tty)
|
{
|
{
|
printf_unfiltered (_("\"maintenance cplus\" must be followed by the name of a command.\n"));
|
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);
|
help_list (maint_cplus_cmd_list, "maintenance cplus ", -1, gdb_stdout);
|
}
|
}
|
|
|
/* This is a front end for cp_find_first_component, for unit testing.
|
/* This is a front end for cp_find_first_component, for unit testing.
|
Be careful when using it: see the NOTE above
|
Be careful when using it: see the NOTE above
|
cp_find_first_component. */
|
cp_find_first_component. */
|
|
|
static void
|
static void
|
first_component_command (char *arg, int from_tty)
|
first_component_command (char *arg, int from_tty)
|
{
|
{
|
int len;
|
int len;
|
char *prefix;
|
char *prefix;
|
|
|
if (!arg)
|
if (!arg)
|
return;
|
return;
|
|
|
len = cp_find_first_component (arg);
|
len = cp_find_first_component (arg);
|
prefix = alloca (len + 1);
|
prefix = alloca (len + 1);
|
|
|
memcpy (prefix, arg, len);
|
memcpy (prefix, arg, len);
|
prefix[len] = '\0';
|
prefix[len] = '\0';
|
|
|
printf_unfiltered ("%s\n", prefix);
|
printf_unfiltered ("%s\n", prefix);
|
}
|
}
|
|
|
extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */
|
extern initialize_file_ftype _initialize_cp_support; /* -Wmissing-prototypes */
|
|
|
#define SKIP_SPACE(P) \
|
#define SKIP_SPACE(P) \
|
do \
|
do \
|
{ \
|
{ \
|
while (*(P) == ' ' || *(P) == '\t') \
|
while (*(P) == ' ' || *(P) == '\t') \
|
++(P); \
|
++(P); \
|
} \
|
} \
|
while (0)
|
while (0)
|
|
|
/* Returns the length of the operator name or 0 if INPUT does not
|
/* Returns the length of the operator name or 0 if INPUT does not
|
point to a valid C++ operator. INPUT should start with "operator". */
|
point to a valid C++ operator. INPUT should start with "operator". */
|
int
|
int
|
cp_validate_operator (const char *input)
|
cp_validate_operator (const char *input)
|
{
|
{
|
int i;
|
int i;
|
char *copy;
|
char *copy;
|
const char *p;
|
const char *p;
|
struct expression *expr;
|
struct expression *expr;
|
struct value *val;
|
struct value *val;
|
struct gdb_exception except;
|
struct gdb_exception except;
|
struct cleanup *old_chain;
|
struct cleanup *old_chain;
|
|
|
p = input;
|
p = input;
|
|
|
if (strncmp (p, "operator", 8) == 0)
|
if (strncmp (p, "operator", 8) == 0)
|
{
|
{
|
int valid = 0;
|
int valid = 0;
|
p += 8;
|
p += 8;
|
|
|
SKIP_SPACE (p);
|
SKIP_SPACE (p);
|
for (i = 0; i < sizeof (operator_tokens) / sizeof (operator_tokens[0]);
|
for (i = 0; i < sizeof (operator_tokens) / sizeof (operator_tokens[0]);
|
++i)
|
++i)
|
{
|
{
|
int length = strlen (operator_tokens[i]);
|
int length = strlen (operator_tokens[i]);
|
/* By using strncmp here, we MUST have operator_tokens ordered!
|
/* By using strncmp here, we MUST have operator_tokens ordered!
|
See additional notes where operator_tokens is defined above. */
|
See additional notes where operator_tokens is defined above. */
|
if (strncmp (p, operator_tokens[i], length) == 0)
|
if (strncmp (p, operator_tokens[i], length) == 0)
|
{
|
{
|
const char *op = p;
|
const char *op = p;
|
valid = 1;
|
valid = 1;
|
p += length;
|
p += length;
|
|
|
if (strncmp (op, "new", 3) == 0
|
if (strncmp (op, "new", 3) == 0
|
|| strncmp (op, "delete", 6) == 0)
|
|| strncmp (op, "delete", 6) == 0)
|
{
|
{
|
|
|
/* Special case: new[] and delete[]. We must be careful
|
/* Special case: new[] and delete[]. We must be careful
|
to swallow whitespace before/in "[]". */
|
to swallow whitespace before/in "[]". */
|
SKIP_SPACE (p);
|
SKIP_SPACE (p);
|
|
|
if (*p == '[')
|
if (*p == '[')
|
{
|
{
|
++p;
|
++p;
|
SKIP_SPACE (p);
|
SKIP_SPACE (p);
|
if (*p == ']')
|
if (*p == ']')
|
++p;
|
++p;
|
else
|
else
|
valid = 0;
|
valid = 0;
|
}
|
}
|
}
|
}
|
|
|
if (valid)
|
if (valid)
|
return (p - input);
|
return (p - input);
|
}
|
}
|
}
|
}
|
|
|
/* Check input for a conversion operator. */
|
/* Check input for a conversion operator. */
|
|
|
/* Skip past base typename */
|
/* Skip past base typename */
|
while (*p != '*' && *p != '&' && *p != 0 && *p != ' ')
|
while (*p != '*' && *p != '&' && *p != 0 && *p != ' ')
|
++p;
|
++p;
|
SKIP_SPACE (p);
|
SKIP_SPACE (p);
|
|
|
/* Add modifiers '*'/'&' */
|
/* Add modifiers '*'/'&' */
|
while (*p == '*' || *p == '&')
|
while (*p == '*' || *p == '&')
|
{
|
{
|
++p;
|
++p;
|
SKIP_SPACE (p);
|
SKIP_SPACE (p);
|
}
|
}
|
|
|
/* Check for valid type. [Remember: input starts with
|
/* Check for valid type. [Remember: input starts with
|
"operator".] */
|
"operator".] */
|
copy = savestring (input + 8, p - input - 8);
|
copy = savestring (input + 8, p - input - 8);
|
expr = NULL;
|
expr = NULL;
|
val = NULL;
|
val = NULL;
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
TRY_CATCH (except, RETURN_MASK_ALL)
|
{
|
{
|
expr = parse_expression (copy);
|
expr = parse_expression (copy);
|
val = evaluate_type (expr);
|
val = evaluate_type (expr);
|
}
|
}
|
|
|
xfree (copy);
|
xfree (copy);
|
if (expr)
|
if (expr)
|
xfree (expr);
|
xfree (expr);
|
|
|
if (val != NULL && value_type (val) != NULL)
|
if (val != NULL && value_type (val) != NULL)
|
return (p - input);
|
return (p - input);
|
}
|
}
|
|
|
return 0;
|
return 0;
|
}
|
}
|
|
|
void
|
void
|
_initialize_cp_support (void)
|
_initialize_cp_support (void)
|
{
|
{
|
add_prefix_cmd ("cplus", class_maintenance, maint_cplus_command,
|
add_prefix_cmd ("cplus", class_maintenance, maint_cplus_command,
|
_("C++ maintenance commands."), &maint_cplus_cmd_list,
|
_("C++ maintenance commands."), &maint_cplus_cmd_list,
|
"maintenance cplus ", 0, &maintenancelist);
|
"maintenance cplus ", 0, &maintenancelist);
|
add_alias_cmd ("cp", "cplus", class_maintenance, 1, &maintenancelist);
|
add_alias_cmd ("cp", "cplus", class_maintenance, 1, &maintenancelist);
|
|
|
add_cmd ("first_component", class_maintenance, first_component_command,
|
add_cmd ("first_component", class_maintenance, first_component_command,
|
_("Print the first class/namespace component of NAME."),
|
_("Print the first class/namespace component of NAME."),
|
&maint_cplus_cmd_list);
|
&maint_cplus_cmd_list);
|
}
|
}
|
|
|
