*** empty log message ***

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

diff --git a/gdb/cp-namespace.c b/gdb/cp-namespace.c
index b9cc794e35305cffce0898adb36b520ec4e2ae7c..9c7ea599a96e32cf5712ed75471c90beda2fc376 100644 (file)
--- a/gdb/cp-namespace.c
+++ b/gdb/cp-namespace.c
@@ -1,5 +1,5 @@
 /* Helper routines for C++ support in GDB.
 /* Helper routines for C++ support in GDB.

-   Copyright 2003, 2004 Free Software Foundation, Inc.
+   Copyright (C) 2003, 2004, 2007, 2008 Free Software Foundation, Inc.

 
    Contributed by David Carlton and by Kealia, Inc.
 
 
    Contributed by David Carlton and by Kealia, Inc.
 


@@ -7,7 +7,7 @@
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by

-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or

    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,
    (at your option) any later version.
 
    This program is distributed in the hope that it will be useful,


@@ -16,9 +16,7 @@
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License
    GNU General Public License for more details.
 
    You should have received a copy of the GNU General Public License

-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 59 Temple Place - Suite 330,
-   Boston, MA 02111-1307, USA.  */
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

 
 #include "defs.h"
 #include "cp-support.h"
 
 #include "defs.h"
 #include "cp-support.h"


@@ -75,7 +73,6 @@ static struct symbol *lookup_namespace_scope (const char *name,
                                              const char *linkage_name,
                                              const struct block *block,
                                              const domain_enum domain,
                                              const char *linkage_name,
                                              const struct block *block,
                                              const domain_enum domain,

-                                             struct symtab **symtab,

                                              const char *scope,
                                              int scope_len);
 
                                              const char *scope,
                                              int scope_len);
 


@@ -83,7 +80,6 @@ static struct symbol *lookup_symbol_file (const char *name,
                                          const char *linkage_name,
                                          const struct block *block,
                                          const domain_enum domain,
                                          const char *linkage_name,
                                          const struct block *block,
                                          const domain_enum domain,

-                                         struct symtab **symtab,

                                          int anonymous_namespace);
 
 static struct type *cp_lookup_transparent_type_loop (const char *name,
                                          int anonymous_namespace);
 
 static struct type *cp_lookup_transparent_type_loop (const char *name,


@@ -104,9 +100,7 @@ static int check_one_possible_namespace_symbol (const char *name,
                                                int len,
                                                struct objfile *objfile);
 
                                                int len,
                                                struct objfile *objfile);
 

-static
-struct symbol *lookup_possible_namespace_symbol (const char *name,
-                                                struct symtab **symtab);
+static struct symbol *lookup_possible_namespace_symbol (const char *name);

 
 static void maintenance_cplus_namespace (char *args, int from_tty);
 
 
 static void maintenance_cplus_namespace (char *args, int from_tty);
 


@@ -335,11 +329,10 @@ struct symbol *
 cp_lookup_symbol_nonlocal (const char *name,
                           const char *linkage_name,
                           const struct block *block,
 cp_lookup_symbol_nonlocal (const char *name,
                           const char *linkage_name,
                           const struct block *block,

-                          const domain_enum domain,
-                          struct symtab **symtab)
+                          const domain_enum domain)

 {
   return lookup_namespace_scope (name, linkage_name, block, domain,
 {
   return lookup_namespace_scope (name, linkage_name, block, domain,

-                                symtab, block_scope (block), 0);
+                                block_scope (block), 0);

 }
 
 /* Lookup NAME at namespace scope (or, in C terms, in static and
 }
 
 /* Lookup NAME at namespace scope (or, in C terms, in static and


@@ -362,7 +355,6 @@ lookup_namespace_scope (const char *name,
                        const char *linkage_name,
                        const struct block *block,
                        const domain_enum domain,
                        const char *linkage_name,
                        const struct block *block,
                        const domain_enum domain,

-                       struct symtab **symtab,

                        const char *scope,
                        int scope_len)
 {
                        const char *scope,
                        int scope_len)
 {


@@ -383,8 +375,7 @@ lookup_namespace_scope (const char *name,
        }
       new_scope_len += cp_find_first_component (scope + new_scope_len);
       sym = lookup_namespace_scope (name, linkage_name, block,
        }
       new_scope_len += cp_find_first_component (scope + new_scope_len);
       sym = lookup_namespace_scope (name, linkage_name, block,

-                                   domain, symtab,
-                                   scope, new_scope_len);
+                                   domain, scope, new_scope_len);

       if (sym != NULL)
        return sym;
     }
       if (sym != NULL)
        return sym;
     }


@@ -396,7 +387,7 @@ lookup_namespace_scope (const char *name,
   strncpy (namespace, scope, scope_len);
   namespace[scope_len] = '\0';
   return cp_lookup_symbol_namespace (namespace, name, linkage_name,
   strncpy (namespace, scope, scope_len);
   namespace[scope_len] = '\0';
   return cp_lookup_symbol_namespace (namespace, name, linkage_name,

-                                    block, domain, symtab);
+                                    block, domain);

 }
 
 /* Look up NAME in the C++ namespace NAMESPACE, applying the using
 }
 
 /* Look up NAME in the C++ namespace NAMESPACE, applying the using


@@ -408,8 +399,7 @@ cp_lookup_symbol_namespace (const char *namespace,
                            const char *name,
                            const char *linkage_name,
                            const struct block *block,
                            const char *name,
                            const char *linkage_name,
                            const struct block *block,

-                           const domain_enum domain,
-                           struct symtab **symtab)
+                           const domain_enum domain)

 {
   const struct using_direct *current;
   struct symbol *sym;
 {
   const struct using_direct *current;
   struct symbol *sym;


@@ -428,8 +418,7 @@ cp_lookup_symbol_namespace (const char *namespace,
                                            name,
                                            linkage_name,
                                            block,
                                            name,
                                            linkage_name,
                                            block,

-                                           domain,
-                                           symtab);
+                                           domain);

          if (sym != NULL)
            return sym;
        }
          if (sym != NULL)
            return sym;
        }


@@ -442,7 +431,7 @@ cp_lookup_symbol_namespace (const char *namespace,
   if (namespace[0] == '\0')
     {
       return lookup_symbol_file (name, linkage_name, block,
   if (namespace[0] == '\0')
     {
       return lookup_symbol_file (name, linkage_name, block,

-                                domain, symtab, 0);
+                                domain, 0);

     }
   else
     {
     }
   else
     {


@@ -452,7 +441,7 @@ cp_lookup_symbol_namespace (const char *namespace,
       strcat (concatenated_name, "::");
       strcat (concatenated_name, name);
       sym = lookup_symbol_file (concatenated_name, linkage_name,
       strcat (concatenated_name, "::");
       strcat (concatenated_name, name);
       sym = lookup_symbol_file (concatenated_name, linkage_name,

-                               block, domain, symtab,
+                               block, domain, 

                                cp_is_anonymous (namespace));
       return sym;
     }
                                cp_is_anonymous (namespace));
       return sym;
     }


@@ -468,12 +457,11 @@ lookup_symbol_file (const char *name,
                    const char *linkage_name,
                    const struct block *block,
                    const domain_enum domain,
                    const char *linkage_name,
                    const struct block *block,
                    const domain_enum domain,

-                   struct symtab **symtab,

                    int anonymous_namespace)
 {
   struct symbol *sym = NULL;
 
                    int anonymous_namespace)
 {
   struct symbol *sym = NULL;
 

-  sym = lookup_symbol_static (name, linkage_name, block, domain, symtab);
+  sym = lookup_symbol_static (name, linkage_name, block, domain);

   if (sym != NULL)
     return sym;
 
   if (sym != NULL)
     return sym;
 


@@ -487,11 +475,11 @@ lookup_symbol_file (const char *name,
       
       if (global_block != NULL)
        sym = lookup_symbol_aux_block (name, linkage_name, global_block,
       
       if (global_block != NULL)
        sym = lookup_symbol_aux_block (name, linkage_name, global_block,

-                                      domain, symtab);
+                                      domain);

     }
   else
     {
     }
   else
     {

-      sym = lookup_symbol_global (name, linkage_name, domain, symtab);
+      sym = lookup_symbol_global (name, linkage_name, block, domain);

     }
 
   if (sym != NULL)
     }
 
   if (sym != NULL)


@@ -509,7 +497,7 @@ lookup_symbol_file (const char *name,
 
   if (domain == VAR_DOMAIN)
     {
 
   if (domain == VAR_DOMAIN)
     {

-      sym = lookup_possible_namespace_symbol (name, symtab);
+      sym = lookup_possible_namespace_symbol (name);

       if (sym != NULL)
        return sym;
     }
       if (sym != NULL)
        return sym;
     }


@@ -543,8 +531,7 @@ cp_lookup_nested_type (struct type *parent_type,
                                                         nested_name,
                                                         NULL,
                                                         block,
                                                         nested_name,
                                                         NULL,
                                                         block,

-                                                        VAR_DOMAIN,
-                                                        NULL);
+                                                        VAR_DOMAIN);

        if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
          return NULL;
        else
        if (sym == NULL || SYMBOL_CLASS (sym) != LOC_TYPEDEF)
          return NULL;
        else


@@ -552,7 +539,7 @@ cp_lookup_nested_type (struct type *parent_type,
       }
     default:
       internal_error (__FILE__, __LINE__,
       }
     default:
       internal_error (__FILE__, __LINE__,

-                     "cp_lookup_nested_type called on a non-aggregate type.");
+                     _("cp_lookup_nested_type called on a non-aggregate type."));

     }
 }
 
     }
 }
 


@@ -603,7 +590,7 @@ static struct type *
 cp_lookup_transparent_type_loop (const char *name, const char *scope,
                                 int length)
 {
 cp_lookup_transparent_type_loop (const char *name, const char *scope,
                                 int length)
 {

-  int scope_length = cp_find_first_component (scope + length);
+  int scope_length = length + cp_find_first_component (scope + length);

   char *full_name;
 
   /* If the current scope is followed by "::", look in the next
   char *full_name;
 
   /* If the current scope is followed by "::", look in the next


@@ -655,7 +642,7 @@ initialize_namespace_symtab (struct objfile *objfile)
   namespace_symtab->free_code = free_nothing;
   namespace_symtab->dirname = NULL;
 
   namespace_symtab->free_code = free_nothing;
   namespace_symtab->dirname = NULL;
 

-  bv = obstack_alloc (&objfile->symbol_obstack,
+  bv = obstack_alloc (&objfile->objfile_obstack,

                      sizeof (struct blockvector)
                      + FIRST_LOCAL_BLOCK * sizeof (struct block *));
   BLOCKVECTOR_NBLOCKS (bv) = FIRST_LOCAL_BLOCK + 1;
                      sizeof (struct blockvector)
                      + FIRST_LOCAL_BLOCK * sizeof (struct block *));
   BLOCKVECTOR_NBLOCKS (bv) = FIRST_LOCAL_BLOCK + 1;


@@ -663,12 +650,12 @@ initialize_namespace_symtab (struct objfile *objfile)
   
   /* Allocate empty GLOBAL_BLOCK and STATIC_BLOCK. */
 
   
   /* Allocate empty GLOBAL_BLOCK and STATIC_BLOCK. */
 

-  bl = allocate_block (&objfile->symbol_obstack);
-  BLOCK_DICT (bl) = dict_create_linear (&objfile->symbol_obstack,
+  bl = allocate_block (&objfile->objfile_obstack);
+  BLOCK_DICT (bl) = dict_create_linear (&objfile->objfile_obstack,

                                        NULL);
   BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl;
                                        NULL);
   BLOCKVECTOR_BLOCK (bv, GLOBAL_BLOCK) = bl;

-  bl = allocate_block (&objfile->symbol_obstack);
-  BLOCK_DICT (bl) = dict_create_linear (&objfile->symbol_obstack,
+  bl = allocate_block (&objfile->objfile_obstack);
+  BLOCK_DICT (bl) = dict_create_linear (&objfile->objfile_obstack,

                                        NULL);
   BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = bl;
 
                                        NULL);
   BLOCKVECTOR_BLOCK (bv, STATIC_BLOCK) = bl;
 


@@ -686,7 +673,7 @@ initialize_namespace_symtab (struct objfile *objfile)
      having a symtab/block for this purpose seems like the best
      solution for now.  */
 
      having a symtab/block for this purpose seems like the best
      solution for now.  */
 

-  bl = allocate_block (&objfile->symbol_obstack);
+  bl = allocate_block (&objfile->objfile_obstack);

   BLOCK_DICT (bl) = dict_create_hashed_expandable ();
   BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK) = bl;
 
   BLOCK_DICT (bl) = dict_create_hashed_expandable ();
   BLOCKVECTOR_BLOCK (bv, FIRST_LOCAL_BLOCK) = bl;
 


@@ -783,17 +770,23 @@ check_one_possible_namespace_symbol (const char *name, int len,
                                     struct objfile *objfile)
 {
   struct block *block = get_possible_namespace_block (objfile);
                                     struct objfile *objfile)
 {
   struct block *block = get_possible_namespace_block (objfile);

-  char *name_copy = obsavestring (name, len, &objfile->symbol_obstack);
-  struct symbol *sym = lookup_block_symbol (block, name_copy, NULL,
-                                           VAR_DOMAIN);
+  char *name_copy = alloca (len + 1);
+  struct symbol *sym;
+
+  memcpy (name_copy, name, len);
+  name_copy[len] = '\0';
+  sym = lookup_block_symbol (block, name_copy, NULL, VAR_DOMAIN);

 
   if (sym == NULL)
     {
 
   if (sym == NULL)
     {

-      struct type *type = init_type (TYPE_CODE_NAMESPACE, 0, 0,
-                                    name_copy, objfile);
+      struct type *type;
+      name_copy = obsavestring (name, len, &objfile->objfile_obstack);
+
+      type = init_type (TYPE_CODE_NAMESPACE, 0, 0, name_copy, objfile);
+

       TYPE_TAG_NAME (type) = TYPE_NAME (type);
 
       TYPE_TAG_NAME (type) = TYPE_NAME (type);
 

-      sym = obstack_alloc (&objfile->symbol_obstack, sizeof (struct symbol));
+      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);
       memset (sym, 0, sizeof (struct symbol));
       SYMBOL_LANGUAGE (sym) = language_cplus;
       SYMBOL_SET_NAMES (sym, name_copy, len, objfile);


@@ -806,19 +799,14 @@ check_one_possible_namespace_symbol (const char *name, int len,
       return 0;
     }
   else
       return 0;
     }
   else

-    {
-      obstack_free (&objfile->symbol_obstack, name_copy);
-
-      return 1;
-    }
+    return 1;

 }
 
 /* Look for a symbol named NAME in all the possible namespace blocks.
 }
 
 /* Look for a symbol named NAME in all the possible namespace blocks.

-   If one is found, return it; if SYMTAB is non-NULL, set *SYMTAB to
-   equal the symtab where it was found.  */
+   If one is found, return it.  */

 
 static struct symbol *
 
 static struct symbol *

-lookup_possible_namespace_symbol (const char *name, struct symtab **symtab)
+lookup_possible_namespace_symbol (const char *name)

 {
   struct objfile *objfile;
 
 {
   struct objfile *objfile;
 


@@ -830,12 +818,7 @@ lookup_possible_namespace_symbol (const char *name, struct symtab **symtab)
                                 name, NULL, VAR_DOMAIN);
 
       if (sym != NULL)
                                 name, NULL, VAR_DOMAIN);
 
       if (sym != NULL)

-       {
-         if (symtab != NULL)
-           *symtab = objfile->cp_namespace_symtab;
-
-         return sym;
-       }
+       return sym;

     }
 
   return NULL;
     }
 
   return NULL;


@@ -847,7 +830,7 @@ static void
 maintenance_cplus_namespace (char *args, int from_tty)
 {
   struct objfile *objfile;
 maintenance_cplus_namespace (char *args, int from_tty)
 {
   struct objfile *objfile;

-  printf_unfiltered ("Possible namespaces:\n");
+  printf_unfiltered (_("Possible namespaces:\n"));

   ALL_OBJFILES (objfile)
     {
       struct dict_iterator iter;
   ALL_OBJFILES (objfile)
     {
       struct dict_iterator iter;


@@ -864,6 +847,6 @@ void
 _initialize_cp_namespace (void)
 {
   add_cmd ("namespace", class_maintenance, maintenance_cplus_namespace,
 _initialize_cp_namespace (void)
 {
   add_cmd ("namespace", class_maintenance, maintenance_cplus_namespace,

-          "Print the list of possible C++ namespaces.",
+          _("Print the list of possible C++ namespaces."),

           &maint_cplus_cmd_list);
 }
           &maint_cplus_cmd_list);
 }