* linux-low.c (my_waitpid): Delete unnecessary prototype.

[deliverable/binutils-gdb.git] / gdb / cp-namespace.c

diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c
index f3b2194404136afb4fffaeebbe9ba1395567d95d..a7a387bad7e2b124e571646c21b87d125b90d798 100644 (file)
--- a/gdb/cp-namespace.c
+++ b/gdb/cp-namespace.c
@@ -103,14 +103,23 @@ cp_scan_for_anonymous_namespaces (const struct symbol *symbol)
                          "(anonymous namespace)",
                          ANONYMOUS_NAMESPACE_LEN) == 0)
            {
+             int dest_len = (previous_component == 0 ? 0 : previous_component - 2);
+             int src_len = next_component;
+
+             char *dest = alloca (dest_len + 1);
+             char *src = alloca (src_len + 1);
+
+             memcpy (dest, name, dest_len);
+             memcpy (src, name, src_len);
+
+             dest[dest_len] = '\0';
+             src[src_len] = '\0';
+
              /* We've found a component of the name that's an
                 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 (name,
-                                     previous_component == 0
-                                     ? 0 : previous_component - 2,
-                                     next_component);
+             cp_add_using_directive (dest, src);
            }
          /* The "+ 2" is for the "::".  */
          previous_component = next_component + 2;
@@ -121,16 +130,11 @@ cp_scan_for_anonymous_namespaces (const struct symbol *symbol)
     }
 }
 
-/* Add a using directive to using_list.  NAME is the start of a string
-   that should contain the namespaces we want to add as initial
-   substrings, OUTER_LENGTH is the end of the outer namespace, and
-   INNER_LENGTH is the end of the inner namespace.  If the using
-   directive in question has already been added, don't add it
-   twice.  */
+/* Add a using directive to using_list. If the using directive in question
+   has already been added, don't add it twice.  */
 
 void
-cp_add_using_directive (const char *name, unsigned int outer_length,
-                       unsigned int inner_length)
+cp_add_using_directive (const char *dest, const char *src)
 {
   struct using_direct *current;
   struct using_direct *new;
@@ -139,14 +143,13 @@ cp_add_using_directive (const char *name, unsigned int outer_length,
 
   for (current = using_directives; current != NULL; current = current->next)
     {
-      if ((strncmp (current->inner, name, inner_length) == 0)
-         && (strlen (current->inner) == inner_length)
-         && (strlen (current->outer) == outer_length))
+      if (strcmp (current->import_src, src) == 0
+          && strcmp (current->import_dest, dest) == 0)
        return;
     }
 
-  using_directives = cp_add_using (name, inner_length, outer_length,
-                                   using_directives);
+  using_directives = cp_add_using (dest, src, using_directives);
+
 }
 
 /* Record the namespace that the function defined by SYMBOL was
@@ -197,26 +200,22 @@ cp_is_anonymous (const char *namespace)
          != NULL);
 }
 
-/* Create a new struct using direct whose inner namespace is the
-   initial substring of NAME of leng INNER_LEN and whose outer
-   namespace is the initial substring of NAME of length OUTER_LENGTH.
+/* Create a new struct using direct which imports the namespace SRC
+   into the scope DEST.
    Set its next member in the linked list to NEXT; allocate all memory
    using xmalloc.  It copies the strings, so NAME can be a temporary
    string.  */
 
 struct using_direct *
-cp_add_using (const char *name,
-             unsigned int inner_len,
-             unsigned int outer_len,
+cp_add_using (const char *dest,
+              const char *src,
              struct using_direct *next)
 {
   struct using_direct *retval;
 
-  gdb_assert (outer_len < inner_len);
-
   retval = xmalloc (sizeof (struct using_direct));
-  retval->inner = savestring (name, inner_len);
-  retval->outer = savestring (name, outer_len);
+  retval->import_src = savestring (src, strlen(src));
+  retval->import_dest = savestring (dest, strlen(dest));
   retval->next = next;
 
   return retval;
@@ -238,14 +237,14 @@ cp_copy_usings (struct using_direct *using,
     {
       struct using_direct *retval
        = obstack_alloc (obstack, sizeof (struct using_direct));
-      retval->inner = obsavestring (using->inner, strlen (using->inner),
+      retval->import_src = obsavestring (using->import_src, strlen (using->import_src),
                                    obstack);
-      retval->outer = obsavestring (using->outer, strlen (using->outer),
+      retval->import_dest = obsavestring (using->import_dest, strlen (using->import_dest),
                                    obstack);
       retval->next = cp_copy_usings (using->next, obstack);
 
-      xfree (using->inner);
-      xfree (using->outer);
+      xfree (using->import_src);
+      xfree (using->import_dest);
       xfree (using);
 
       return retval;
@@ -347,9 +346,9 @@ cp_lookup_symbol_namespace (const char *namespace,
        current != NULL;
        current = current->next)
     {
-      if (strcmp (namespace, current->outer) == 0)
+      if (strcmp (namespace, current->import_dest) == 0)
        {
-         sym = cp_lookup_symbol_namespace (current->inner,
+         sym = cp_lookup_symbol_namespace (current->import_src,
                                            name,
                                            linkage_name,
                                            block,
@@ -715,7 +714,6 @@ check_one_possible_namespace_symbol (const char *name, int len,
   if (sym == NULL)
     {
       struct type *type;
-      name_copy = obsavestring (name, len, &objfile->objfile_obstack);
 
       type = init_type (TYPE_CODE_NAMESPACE, 0, 0, name_copy, objfile);
 
@@ -724,7 +722,9 @@ check_one_possible_namespace_symbol (const char *name, int len,
       sym = obstack_alloc (&objfile->objfile_obstack, sizeof (struct symbol));
       memset (sym, 0, sizeof (struct symbol));
       SYMBOL_LANGUAGE (sym) = language_cplus;
-      SYMBOL_SET_NAMES (sym, name_copy, len, objfile);
+      /* Note that init_type copied the name to the objfile's
+        obstack.  */
+      SYMBOL_SET_NAMES (sym, TYPE_NAME (type), len, 0, objfile);
       SYMBOL_CLASS (sym) = LOC_TYPEDEF;
       SYMBOL_TYPE (sym) = type;
       SYMBOL_DOMAIN (sym) = VAR_DOMAIN;