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  <tom@tromey.com>

	* cp-namespace.c: Include <string>.
	(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 8c8b18a6786f39f8a4b62ade06ab49f671390025..410c386758baf8ab0d1926105a603b1e881ec3b1 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,10 @@
+2016-09-23  Tom Tromey  <tom@tromey.com>
+
+       * cp-namespace.c: Include <string>.
+       (cp_search_static_and_baseclasses)
+       (cp_lookup_symbol_imports_or_template, find_symbol_in_baseclass):
+       Use std::string.
+
 2016-09-23  Tom Tromey  <tom@tromey.com>
 
        * break-catch-sig.c: Include <string>.

diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c
index 0f1b452f6510fcd234ba8af44431906e9f62a8db..e19a6f394646e84229f94c7c99c1ea1014734f13 100644 (file)
--- a/gdb/cp-namespace.c
+++ b/gdb/cp-namespace.c
@@ -32,6 +32,7 @@
 #include "buildsym.h"
 #include "language.h"
 #include "namespace.h"
+#include <string>
 
 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;
 }