From: Tom Tromey Date: Thu, 22 Sep 2016 15:51:03 +0000 (-0600) Subject: Use std::string in cp-namespace.c X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=05d49c372d4689f8ca8baf4fdd32529ac40f297a;p=binutils-gdb.git Use std::string in cp-namespace.c This changes a few spots in cp-namespace.c to use std::string, removing some cleanups. 2016-09-23 Tom Tromey * cp-namespace.c: Include . (cp_search_static_and_baseclasses) (cp_lookup_symbol_imports_or_template, find_symbol_in_baseclass): Use std::string. --- diff --git a/gdb/ChangeLog b/gdb/ChangeLog index 8c8b18a6786..410c386758b 100644 --- a/gdb/ChangeLog +++ b/gdb/ChangeLog @@ -1,3 +1,10 @@ +2016-09-23 Tom Tromey + + * cp-namespace.c: Include . + (cp_search_static_and_baseclasses) + (cp_lookup_symbol_imports_or_template, find_symbol_in_baseclass): + Use std::string. + 2016-09-23 Tom Tromey * break-catch-sig.c: Include . diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c index 0f1b452f651..e19a6f39464 100644 --- a/gdb/cp-namespace.c +++ b/gdb/cp-namespace.c @@ -32,6 +32,7 @@ #include "buildsym.h" #include "language.h" #include "namespace.h" +#include static struct block_symbol cp_lookup_nested_symbol_1 (struct type *container_type, @@ -246,8 +247,6 @@ cp_search_static_and_baseclasses (const char *name, int is_in_anonymous) { struct block_symbol sym; - char *klass, *nested; - struct cleanup *cleanup; struct block_symbol klass_sym; struct type *klass_type; @@ -258,36 +257,28 @@ cp_search_static_and_baseclasses (const char *name, /* 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 null_block_symbol; - } + 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; } @@ -567,8 +558,7 @@ cp_lookup_symbol_imports_or_template (const char *scope, 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); @@ -576,15 +566,16 @@ cp_lookup_symbol_imports_or_template (const char *scope, 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); } @@ -597,7 +588,6 @@ cp_lookup_symbol_imports_or_template (const char *scope, TYPE_TEMPLATE_ARGUMENTS (context)); if (sym != NULL) { - do_cleanups (cleanups); if (symbol_lookup_debug) { fprintf_unfiltered @@ -608,8 +598,6 @@ cp_lookup_symbol_imports_or_template (const char *scope, return (struct block_symbol) {sym, parent}; } } - - do_cleanups (cleanups); } } @@ -832,34 +820,27 @@ find_symbol_in_baseclass (struct type *parent_type, const char *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 = (char *) 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; }