diff mbox

[RFA,2/5] Use std::string in cp-namespace.c

Message ID 1474566656-15389-3-git-send-email-tom@tromey.com
State New
Headers show

Commit Message

Tom Tromey Sept. 22, 2016, 5:50 p.m. UTC
This changes a few spots in cp-namespace.c to use std::string,
removing some cleanups.

2016-09-22  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.
---
 gdb/ChangeLog      |  7 +++++++
 gdb/cp-namespace.c | 51 +++++++++++++++++----------------------------------
 2 files changed, 24 insertions(+), 34 deletions(-)

Comments

Pedro Alves Sept. 22, 2016, 7:03 p.m. UTC | #1
On 09/22/2016 06:50 PM, Tom Tromey wrote:
> -		  name_copy[prefix_len] = '\0';
> +		  name_copy.erase (prefix_len, name_copy.size ());

Passing name_copy.size () here looks odd, since that parameter is
how many bytes to erase.  Just don't pass a second parameter,
which defaults to std::string::npos?

>  		  context = lookup_typename (lang, arch,
> -					     name_copy,
> +					     name_copy.c_str (),
>  					     parent, 1);
>  		}
>
Tom Tromey Sept. 22, 2016, 8:36 p.m. UTC | #2
>>>>> "Pedro" == Pedro Alves <palves@redhat.com> writes:

Pedro> On 09/22/2016 06:50 PM, Tom Tromey wrote:
>> -		  name_copy[prefix_len] = '\0';
>> +		  name_copy.erase (prefix_len, name_copy.size ());

Pedro> Passing name_copy.size () here looks odd, since that parameter is
Pedro> how many bytes to erase.  Just don't pass a second parameter,
Pedro> which defaults to std::string::npos?

For some reason I was under the impression that the 1-arg form just
removed a single character, but I see that's incorrect.  Thanks.

Tom
diff mbox

Patch

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index f9924e5..2029bcb 100644
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,5 +1,12 @@ 
 2016-09-22  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-22  Tom Tromey  <tom@tromey.com>
+
 	* break-catch-sig.c: Include <string>.
 	(signal_catchpoint_print_one): Use std::string.
 
diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c
index 0f1b452..1df59ae 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 <string>
 
 static struct block_symbol
   cp_lookup_nested_symbol_1 (struct type *container_type,
@@ -246,8 +247,7 @@  cp_search_static_and_baseclasses (const char *name,
 				  int is_in_anonymous)
 {
   struct block_symbol sym;
-  char *klass, *nested;
-  struct cleanup *cleanup;
+  std::string klass, nested;
   struct block_symbol klass_sym;
   struct type *klass_type;
 
@@ -258,36 +258,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);
+  klass = std::string (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);
+  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 +559,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 +567,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, name_copy.size ());
 		  context = lookup_typename (lang, arch,
-					     name_copy,
+					     name_copy.c_str (),
 					     parent, 1);
 		}
 
@@ -597,7 +589,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 +599,6 @@  cp_lookup_symbol_imports_or_template (const char *scope,
 		  return (struct block_symbol) {sym, parent};
 		}
 	    }
-
-	  do_cleanups (cleanups);
 	}
     }
 
@@ -832,34 +821,28 @@  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);
+      std::string concatenated_name;
 
       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);
+      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;
 }