2009-07-07 Sami Wagiaalla <swagiaal@redhat.com>

	* cp-support.h (struct using_direct): Rename members inner and
	outer to import_src, and import_dest respectively.
	* cp-namespace.c (cp_add_using_directive): Update.
	(cp_add_using): Update.
	(cp_copy_usings): Update.
	(cp_lookup_symbol_namespace): Update.
	(cp_scan_for_anonymous_namespaces): Update.
	* cp-support.c (make_symbol_overload_list_using): Update.
	* cp-support.h (cp_add_using_directive, cp_add_using): Rename
	arguments from inner and outer to src and dest respectively.
	* cp-namespace.c (cp_add_using_directive): Ditto.
	(cp_add_using): Ditto.

diff --git a/gdb/ChangeLog b/gdb/ChangeLog
index a5aa4b9790c62aa2dfc88b210dbf99a87b8cbf13..56480f10298cea9792cae758eee742054af798d3 100644 (file)
--- a/gdb/ChangeLog
+++ b/gdb/ChangeLog
@@ -1,3 +1,18 @@
+2009-07-07  Sami Wagiaalla  <swagiaal@redhat.com>
+
+       * cp-support.h (struct using_direct): Rename members inner and
+       outer to import_src, and import_dest respectively.
+       * cp-namespace.c (cp_add_using_directive): Update.
+       (cp_add_using): Update.
+       (cp_copy_usings): Update.
+       (cp_lookup_symbol_namespace): Update.
+       (cp_scan_for_anonymous_namespaces): Update.
+       * cp-support.c (make_symbol_overload_list_using): Update.
+       * cp-support.h (cp_add_using_directive, cp_add_using): Rename
+       arguments from inner and outer to src and dest respectively.
+       * cp-namespace.c (cp_add_using_directive): Ditto.
+       (cp_add_using): Ditto.
+
 2009-07-07  Jan Kratochvil  <jan.kratochvil@redhat.com>
 
        * mi/mi-cmd-var.c (mi_cmd_var_update): Replace a while loop by for loop.

diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c
index ef526caa5d14bf3cdfa6dcfe8afbef1a5c3f38a4..d2d8f2eb88e011349f9d391c08667c70ac19c1aa 100644 (file)
--- a/gdb/cp-namespace.c
+++ b/gdb/cp-namespace.c
@@ -103,23 +103,23 @@ cp_scan_for_anonymous_namespaces (const struct symbol *symbol)
                          "(anonymous namespace)",
                          ANONYMOUS_NAMESPACE_LEN) == 0)
            {
-             int outer_len = (previous_component == 0 ? 0 : previous_component - 2);
-             int inner_len = next_component;
+             int dest_len = (previous_component == 0 ? 0 : previous_component - 2);
+             int src_len = next_component;
 
-             char *outer = alloca (outer_len + 1);
-             char *inner = alloca (inner_len + 1);
+             char *dest = alloca (dest_len + 1);
+             char *src = alloca (src_len + 1);
 
-             memcpy (outer, name, outer_len);
-             memcpy (inner, name, inner_len);
+             memcpy (dest, name, dest_len);
+             memcpy (src, name, src_len);
 
-             outer[outer_len] = '\0';
-             inner[inner_len] = '\0';
+             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 (outer, inner);
+             cp_add_using_directive (dest, src);
            }
          /* The "+ 2" is for the "::".  */
          previous_component = next_component + 2;
@@ -134,7 +134,7 @@ cp_scan_for_anonymous_namespaces (const struct symbol *symbol)
    has already been added, don't add it twice.  */
 
 void
-cp_add_using_directive (const char *outer, const char *inner)
+cp_add_using_directive (const char *dest, const char *src)
 {
   struct using_direct *current;
   struct using_direct *new;
@@ -143,12 +143,12 @@ cp_add_using_directive (const char *outer, const char *inner)
 
   for (current = using_directives; current != NULL; current = current->next)
     {
-      if (strcmp (current->inner, inner) == 0
-          && strcmp (current->outer, outer) == 0)
+      if (strcmp (current->import_src, src) == 0
+          && strcmp (current->import_dest, dest) == 0)
        return;
     }
 
-  using_directives = cp_add_using (outer, inner, using_directives);
+  using_directives = cp_add_using (dest, src, using_directives);
 
 }
 
@@ -200,22 +200,22 @@ cp_is_anonymous (const char *namespace)
          != NULL);
 }
 
-/* Create a new struct using direct whose inner namespace is INNER
-   and whose outer namespace is OUTER.
+/* 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 *outer,
-              const char *inner,
+cp_add_using (const char *dest,
+              const char *src,
              struct using_direct *next)
 {
   struct using_direct *retval;
 
   retval = xmalloc (sizeof (struct using_direct));
-  retval->inner = savestring (inner, strlen(inner));
-  retval->outer = savestring (outer, strlen(outer));
+  retval->import_src = savestring (src, strlen(src));
+  retval->import_dest = savestring (dest, strlen(dest));
   retval->next = next;
 
   return retval;
@@ -237,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;
@@ -346,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,

diff --git a/gdb/cp-support.c b/gdb/cp-support.c
index bf42636539fb98580b04509cb195f5e90c04b2fa..f12d785f13265d770d494d7d5ac09d54fa0ff7a7 100644 (file)
--- a/gdb/cp-support.c
+++ b/gdb/cp-support.c
@@ -716,10 +716,10 @@ make_symbol_overload_list_using (const char *func_name,
        current != NULL;
        current = current->next)
     {
-      if (strcmp (namespace, current->outer) == 0)
+      if (strcmp (namespace, current->import_dest) == 0)
        {
          make_symbol_overload_list_using (func_name,
-                                          current->inner);
+                                          current->import_src);
        }
     }
 

diff --git a/gdb/cp-support.h b/gdb/cp-support.h
index ea366080b85796f9aa51cc3e80b1abcba412410f..b5a5c5fca7f8b461973d21b4ba2ea7b14a11242c 100644 (file)
--- a/gdb/cp-support.h
+++ b/gdb/cp-support.h
@@ -37,15 +37,15 @@ struct type;
 struct demangle_component;
 
 /* This struct is designed to store data from using directives.  It
-   says that names from namespace INNER should be visible within
-   namespace OUTER.  OUTER should always be a strict initial substring
-   of INNER.  These form a linked list; NEXT is the next element of
-   the list.  */
+   says that names from namespace IMPORT_SRC should be visible within
+   namespace IMPORT_DEST. IMPORT_DEST should always be a strict initial
+   substring of IMPORT_SRC. These form a linked list; NEXT is the next element
+   of the list.  */
 
 struct using_direct
 {
-  char *inner;
-  char *outer;
+  char *import_src;
+  char *import_dest;
   struct using_direct *next;
 };
 
@@ -76,11 +76,11 @@ extern struct type *cp_lookup_rtti_type (const char *name,
 
 extern int cp_is_anonymous (const char *namespace);
 
-extern void cp_add_using_directive (const char *outer,
-                                    const char *inner);
+extern void cp_add_using_directive (const char *dest,
+                                    const char *src);
 
-extern struct using_direct *cp_add_using (const char *outer,
-                                          const char *inner,
+extern struct using_direct *cp_add_using (const char *dest,
+                                          const char *src,
                                          struct using_direct *next);
 
 extern void cp_initialize_namespace (void);