/* Helper routines for C++ support in GDB.
- Copyright (C) 2003-2015 Free Software Foundation, Inc.
+ Copyright (C) 2003-2016 Free Software Foundation, Inc.
Contributed by David Carlton and by Kealia, Inc.
#include "frame.h"
#include "buildsym.h"
#include "language.h"
+#include "namespace.h"
+#include <string>
static struct block_symbol
cp_lookup_nested_symbol_1 (struct type *container_type,
? 0 : previous_component - 2);
int src_len = next_component;
- char *dest = alloca (dest_len + 1);
- char *src = alloca (src_len + 1);
+ char *dest = (char *) alloca (dest_len + 1);
+ char *src = (char *) alloca (src_len + 1);
memcpy (dest, name, dest_len);
memcpy (src, name, src_len);
anonymous namespace. So add symbols in it to the
namespace given by the previous component if there is
one, or to the global namespace if there isn't. */
- cp_add_using_directive (dest, src, NULL, NULL, NULL, 1,
- &objfile->objfile_obstack);
+ add_using_directive (&local_using_directives,
+ dest, src, NULL, NULL, NULL, 1,
+ &objfile->objfile_obstack);
}
/* The "+ 2" is for the "::". */
previous_component = next_component + 2;
}
}
-/* Add a using directive to using_directives. If the using directive
- in question has already been added, don't add it twice.
-
- Create a new struct using_direct which imports the namespace SRC
- into the scope DEST. ALIAS is the name of the imported namespace
- in the current scope. If ALIAS is NULL then the namespace is known
- by its original name. DECLARATION is the name if the imported
- varable if this is a declaration import (Eg. using A::x), otherwise
- it is NULL. EXCLUDES is a list of names not to import from an
- imported module or NULL. If COPY_NAMES is non-zero, then the
- arguments are copied into newly allocated memory so they can be
- temporaries. For EXCLUDES the VEC pointers are copied but the
- pointed to characters are not copied. */
-
-void
-cp_add_using_directive (const char *dest,
- const char *src,
- const char *alias,
- const char *declaration,
- VEC (const_char_ptr) *excludes,
- int copy_names,
- struct obstack *obstack)
-{
- struct using_direct *current;
- struct using_direct *newobj;
-
- /* Has it already been added? */
-
- for (current = using_directives; current != NULL; current = current->next)
- {
- int ix;
- const char *param;
-
- if (strcmp (current->import_src, src) != 0)
- continue;
- if (strcmp (current->import_dest, dest) != 0)
- continue;
- if ((alias == NULL && current->alias != NULL)
- || (alias != NULL && current->alias == NULL)
- || (alias != NULL && current->alias != NULL
- && strcmp (alias, current->alias) != 0))
- continue;
- if ((declaration == NULL && current->declaration != NULL)
- || (declaration != NULL && current->declaration == NULL)
- || (declaration != NULL && current->declaration != NULL
- && strcmp (declaration, current->declaration) != 0))
- continue;
-
- /* Compare the contents of EXCLUDES. */
- for (ix = 0; VEC_iterate (const_char_ptr, excludes, ix, param); ix++)
- if (current->excludes[ix] == NULL
- || strcmp (param, current->excludes[ix]) != 0)
- break;
- if (ix < VEC_length (const_char_ptr, excludes)
- || current->excludes[ix] != NULL)
- continue;
-
- /* Parameters exactly match CURRENT. */
- return;
- }
-
- newobj = obstack_alloc (obstack, (sizeof (*newobj)
- + (VEC_length (const_char_ptr, excludes)
- * sizeof (*newobj->excludes))));
- memset (newobj, 0, sizeof (*newobj));
-
- if (copy_names)
- {
- newobj->import_src = obstack_copy0 (obstack, src, strlen (src));
- newobj->import_dest = obstack_copy0 (obstack, dest, strlen (dest));
- }
- else
- {
- newobj->import_src = src;
- newobj->import_dest = dest;
- }
-
- if (alias != NULL && copy_names)
- newobj->alias = obstack_copy0 (obstack, alias, strlen (alias));
- else
- newobj->alias = alias;
-
- if (declaration != NULL && copy_names)
- newobj->declaration = obstack_copy0 (obstack,
- declaration, strlen (declaration));
- else
- newobj->declaration = declaration;
-
- memcpy (newobj->excludes, VEC_address (const_char_ptr, excludes),
- VEC_length (const_char_ptr, excludes) * sizeof (*newobj->excludes));
- newobj->excludes[VEC_length (const_char_ptr, excludes)] = NULL;
-
- newobj->next = using_directives;
- using_directives = newobj;
-}
-
/* Test whether or not NAMESPACE looks like it mentions an anonymous
namespace; return nonzero if so. */
':' may be in the args of a template spec. This isn't intended to be
a complete test, just cheap and documentary. */
if (strchr (name, '<') == NULL && strchr (name, '(') == NULL)
- gdb_assert (strchr (name, ':') == NULL);
+ gdb_assert (strstr (name, "::") == NULL);
sym = lookup_symbol_in_static_block (name, block, domain);
if (sym.symbol != NULL)
struct block_symbol lang_this;
struct type *type;
- lang_this = lookup_language_this (language_def (language_cplus), block);
+ lang_this.symbol = NULL;
+
+ if (langdef != NULL)
+ lang_this = lookup_language_this (langdef, block);
+
if (lang_this.symbol == NULL)
- return (struct block_symbol) {NULL, NULL};
+ return null_block_symbol;
+
type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (lang_this.symbol)));
/* If TYPE_NAME is NULL, abandon trying to find this symbol.
This can happen for lambda functions compiled with clang++,
which outputs no name for the container class. */
if (TYPE_NAME (type) == NULL)
- return (struct block_symbol) {NULL, NULL};
+ return null_block_symbol;
/* Look for symbol NAME in this class. */
sym = cp_lookup_nested_symbol (type, name, block, domain);
int is_in_anonymous)
{
struct block_symbol sym;
- char *klass, *nested;
- struct cleanup *cleanup;
struct block_symbol klass_sym;
struct type *klass_type;
- /* The test here uses <= instead of < because Fortran also uses this,
- and the module.exp testcase will pass "modmany::" for NAME here. */
- gdb_assert (prefix_len + 2 <= strlen (name));
- gdb_assert (name[prefix_len + 1] == ':');
+ /* Check for malformed input. */
+ if (prefix_len + 2 > strlen (name) || name[prefix_len + 1] != ':')
+ return null_block_symbol;
/* Find the name of the class and the name of the method, variable, etc. */
/* The class name is everything up to and including PREFIX_LEN. */
- klass = savestring (name, prefix_len);
+ std::string klass (name, prefix_len);
/* The rest of the name is everything else past the initial scope
operator. */
- nested = xstrdup (name + prefix_len + 2);
-
- /* Add cleanups to free memory for these strings. */
- cleanup = make_cleanup (xfree, klass);
- make_cleanup (xfree, nested);
+ std::string nested (name + prefix_len + 2);
/* Lookup a class named KLASS. If none is found, there is nothing
more that can be done. KLASS could be a namespace, so always look
in VAR_DOMAIN. This works for classes too because of
symbol_matches_domain (which should be replaced with something else,
but it's what we have today). */
- klass_sym = lookup_global_symbol (klass, block, VAR_DOMAIN);
+ klass_sym = lookup_global_symbol (klass.c_str (), block, VAR_DOMAIN);
if (klass_sym.symbol == NULL)
- {
- do_cleanups (cleanup);
- return (struct block_symbol) {NULL, NULL};
- }
+ return null_block_symbol;
klass_type = SYMBOL_TYPE (klass_sym.symbol);
/* Look for a symbol named NESTED in this class.
The caller is assumed to have already have done a basic lookup of NAME.
So we pass zero for BASIC_LOOKUP to cp_lookup_nested_symbol_1 here. */
- sym = cp_lookup_nested_symbol_1 (klass_type, nested, name, block, domain,
- 0, is_in_anonymous);
+ sym = cp_lookup_nested_symbol_1 (klass_type, nested.c_str (), name,
+ block, domain, 0, is_in_anonymous);
- do_cleanups (cleanup);
return sym;
}
if (the_namespace[0] != '\0')
{
- concatenated_name = alloca (strlen (the_namespace) + 2
- + strlen (name) + 1);
+ concatenated_name
+ = (char *) alloca (strlen (the_namespace) + 2 + strlen (name) + 1);
strcpy (concatenated_name, the_namespace);
strcat (concatenated_name, "::");
strcat (concatenated_name, name);
static void
reset_directive_searched (void *data)
{
- struct using_direct *direct = data;
+ struct using_direct *direct = (struct using_direct *) data;
direct->searched = 0;
}
struct cleanup *searched_cleanup;
sym.symbol = NULL;
+ sym.block = NULL;
/* First, try to find the symbol in the given namespace if requested. */
if (search_scope_first)
}
}
- return (struct block_symbol) {NULL, NULL};
+ return null_block_symbol;
}
/* Helper function that searches an array of symbols for one named NAME. */
if (SYMBOL_NATURAL_NAME (function))
{
struct type *context;
- char *name_copy = xstrdup (SYMBOL_NATURAL_NAME (function));
- struct cleanup *cleanups = make_cleanup (xfree, name_copy);
+ std::string name_copy (SYMBOL_NATURAL_NAME (function));
const struct language_defn *lang = language_def (language_cplus);
struct gdbarch *arch = symbol_arch (function);
const struct block *parent = BLOCK_SUPERBLOCK (block);
while (1)
{
- unsigned int prefix_len = cp_entire_prefix_len (name_copy);
+ unsigned int prefix_len
+ = cp_entire_prefix_len (name_copy.c_str ());
if (prefix_len == 0)
context = NULL;
else
{
- name_copy[prefix_len] = '\0';
+ name_copy.erase (prefix_len);
context = lookup_typename (lang, arch,
- name_copy,
+ name_copy.c_str (),
parent, 1);
}
TYPE_TEMPLATE_ARGUMENTS (context));
if (sym != NULL)
{
- do_cleanups (cleanups);
if (symbol_lookup_debug)
{
fprintf_unfiltered
return (struct block_symbol) {sym, parent};
}
}
-
- do_cleanups (cleanups);
}
}
block = BLOCK_SUPERBLOCK (block);
}
- return (struct block_symbol) {NULL, NULL};
+ return null_block_symbol;
}
/* Searches for NAME in the current namespace, and by applying
if (scope_len == 0 && strchr (name, ':') == NULL)
return cp_lookup_bare_symbol (langdef, name, block, domain, 1);
- the_namespace = alloca (scope_len + 1);
+ the_namespace = (char *) alloca (scope_len + 1);
strncpy (the_namespace, scope, scope_len);
the_namespace[scope_len] = '\0';
return cp_lookup_symbol_in_namespace (the_namespace, name,
{
int i;
struct block_symbol sym;
- struct cleanup *cleanup;
- char *concatenated_name;
sym.symbol = NULL;
sym.block = NULL;
- concatenated_name = NULL;
- cleanup = make_cleanup (free_current_contents, &concatenated_name);
for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
{
- size_t len;
struct type *base_type = TYPE_BASECLASS (parent_type, i);
const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
if (base_name == NULL)
continue;
- len = strlen (base_name) + 2 + strlen (name) + 1;
- concatenated_name = xrealloc (concatenated_name, len);
- xsnprintf (concatenated_name, len, "%s::%s", base_name, name);
+ std::string concatenated_name = std::string (base_name) + "::" + name;
- sym = cp_lookup_nested_symbol_1 (base_type, name, concatenated_name,
+ sym = cp_lookup_nested_symbol_1 (base_type, name,
+ concatenated_name.c_str (),
block, domain, 1, is_in_anonymous);
if (sym.symbol != NULL)
break;
}
- do_cleanups (cleanup);
return sym;
}
return sym;
}
- return (struct block_symbol) {NULL, NULL};
+ return null_block_symbol;
}
/* Look up a symbol named NESTED_NAME that is nested inside the C++
int is_in_anonymous;
size = strlen (parent_name) + 2 + strlen (nested_name) + 1;
- concatenated_name = alloca (size);
+ concatenated_name = (char *) alloca (size);
xsnprintf (concatenated_name, size, "%s::%s",
parent_name, nested_name);
is_in_anonymous = cp_is_in_anonymous (concatenated_name);
"cp_lookup_nested_symbol (...) = NULL"
" (func/method)\n");
}
- return (struct block_symbol) {NULL, NULL};
+ return null_block_symbol;
default:
internal_error (__FILE__, __LINE__,
return retval;
}
- full_name = alloca (scope_length + 2 + strlen (name) + 1);
+ full_name = (char *) alloca (scope_length + 2 + strlen (name) + 1);
strncpy (full_name, scope, scope_length);
strncpy (full_name + scope_length, "::", 2);
strcpy (full_name + scope_length + 2, name);