gdb/cp-namespace.c

   1 /* Helper routines for C++ support in GDB.
   2    Copyright (C) 2003-2014 Free Software Foundation, Inc.
   3
   4    Contributed by David Carlton and by Kealia, Inc.
   5
   6    This file is part of GDB.
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  20
  21 #include "defs.h"
  22 #include "cp-support.h"
  23 #include "gdb_obstack.h"
  24 #include "symtab.h"
  25 #include "symfile.h"
  26 #include "block.h"
  27 #include "objfiles.h"
  28 #include "gdbtypes.h"
  29 #include "dictionary.h"
  30 #include "command.h"
  31 #include "frame.h"
  32 #include "buildsym.h"
  33 #include "language.h"
  34
  35 static struct symbol *
  36   cp_lookup_nested_symbol_1 (struct type *container_type,
  37                              const char *nested_name,
  38                              const char *concatenated_name,
  39                              const struct block *block,
  40                              int basic_lookup);
  41
  42 static struct type *cp_lookup_transparent_type_loop (const char *name,
  43                                                      const char *scope,
  44                                                      int scope_len);
  45
  46 /* Check to see if SYMBOL refers to an object contained within an
  47    anonymous namespace; if so, add an appropriate using directive.  */
  48
  49 void
  50 cp_scan_for_anonymous_namespaces (const struct symbol *const symbol,
  51                                   struct objfile *const objfile)
  52 {
  53   if (SYMBOL_DEMANGLED_NAME (symbol) != NULL)
  54     {
  55       const char *name = SYMBOL_DEMANGLED_NAME (symbol);
  56       unsigned int previous_component;
  57       unsigned int next_component;
  58
  59       /* Start with a quick-and-dirty check for mention of "(anonymous
  60          namespace)".  */
  61
  62       if (!cp_is_in_anonymous (name))
  63         return;
  64
  65       previous_component = 0;
  66       next_component = cp_find_first_component (name + previous_component);
  67
  68       while (name[next_component] == ':')
  69         {
  70           if (((next_component - previous_component)
  71                == CP_ANONYMOUS_NAMESPACE_LEN)
  72               && strncmp (name + previous_component,
  73                           CP_ANONYMOUS_NAMESPACE_STR,
  74                           CP_ANONYMOUS_NAMESPACE_LEN) == 0)
  75             {
  76               int dest_len = (previous_component == 0
  77                               ? 0 : previous_component - 2);
  78               int src_len = next_component;
  79
  80               char *dest = alloca (dest_len + 1);
  81               char *src = alloca (src_len + 1);
  82
  83               memcpy (dest, name, dest_len);
  84               memcpy (src, name, src_len);
  85
  86               dest[dest_len] = '\0';
  87               src[src_len] = '\0';
  88
  89               /* We've found a component of the name that's an
  90                  anonymous namespace.  So add symbols in it to the
  91                  namespace given by the previous component if there is
  92                  one, or to the global namespace if there isn't.  */
  93               cp_add_using_directive (dest, src, NULL, NULL, NULL, 1,
  94                                       &objfile->objfile_obstack);
  95             }
  96           /* The "+ 2" is for the "::".  */
  97           previous_component = next_component + 2;
  98           next_component = (previous_component
  99                             + cp_find_first_component (name
 100                                                        + previous_component));
 101         }
 102     }
 103 }
 104
 105 /* Add a using directive to using_directives.  If the using directive
 106    in question has already been added, don't add it twice.
 107
 108    Create a new struct using_direct which imports the namespace SRC
 109    into the scope DEST.  ALIAS is the name of the imported namespace
 110    in the current scope.  If ALIAS is NULL then the namespace is known
 111    by its original name.  DECLARATION is the name if the imported
 112    varable if this is a declaration import (Eg. using A::x), otherwise
 113    it is NULL.  EXCLUDES is a list of names not to import from an
 114    imported module or NULL.  If COPY_NAMES is non-zero, then the
 115    arguments are copied into newly allocated memory so they can be
 116    temporaries.  For EXCLUDES the VEC pointers are copied but the
 117    pointed to characters are not copied.  */
 118
 119 void
 120 cp_add_using_directive (const char *dest,
 121                         const char *src,
 122                         const char *alias,
 123                         const char *declaration,
 124                         VEC (const_char_ptr) *excludes,
 125                         int copy_names,
 126                         struct obstack *obstack)
 127 {
 128   struct using_direct *current;
 129   struct using_direct *new;
 130
 131   /* Has it already been added?  */
 132
 133   for (current = using_directives; current != NULL; current = current->next)
 134     {
 135       int ix;
 136       const char *param;
 137
 138       if (strcmp (current->import_src, src) != 0)
 139         continue;
 140       if (strcmp (current->import_dest, dest) != 0)
 141         continue;
 142       if ((alias == NULL && current->alias != NULL)
 143           || (alias != NULL && current->alias == NULL)
 144           || (alias != NULL && current->alias != NULL
 145               && strcmp (alias, current->alias) != 0))
 146         continue;
 147       if ((declaration == NULL && current->declaration != NULL)
 148           || (declaration != NULL && current->declaration == NULL)
 149           || (declaration != NULL && current->declaration != NULL
 150               && strcmp (declaration, current->declaration) != 0))
 151         continue;
 152
 153       /* Compare the contents of EXCLUDES.  */
 154       for (ix = 0; VEC_iterate (const_char_ptr, excludes, ix, param); ix++)
 155         if (current->excludes[ix] == NULL
 156             || strcmp (param, current->excludes[ix]) != 0)
 157           break;
 158       if (ix < VEC_length (const_char_ptr, excludes)
 159           || current->excludes[ix] != NULL)
 160         continue;
 161
 162       /* Parameters exactly match CURRENT.  */
 163       return;
 164     }
 165
 166   new = obstack_alloc (obstack, (sizeof (*new)
 167                                  + (VEC_length (const_char_ptr, excludes)
 168                                     * sizeof (*new->excludes))));
 169   memset (new, 0, sizeof (*new));
 170
 171   if (copy_names)
 172     {
 173       new->import_src = obstack_copy0 (obstack, src, strlen (src));
 174       new->import_dest = obstack_copy0 (obstack, dest, strlen (dest));
 175     }
 176   else
 177     {
 178       new->import_src = src;
 179       new->import_dest = dest;
 180     }
 181
 182   if (alias != NULL && copy_names)
 183     new->alias = obstack_copy0 (obstack, alias, strlen (alias));
 184   else
 185     new->alias = alias;
 186
 187   if (declaration != NULL && copy_names)
 188     new->declaration = obstack_copy0 (obstack,
 189                                       declaration, strlen (declaration));
 190   else
 191     new->declaration = declaration;
 192
 193   memcpy (new->excludes, VEC_address (const_char_ptr, excludes),
 194           VEC_length (const_char_ptr, excludes) * sizeof (*new->excludes));
 195   new->excludes[VEC_length (const_char_ptr, excludes)] = NULL;
 196
 197   new->next = using_directives;
 198   using_directives = new;
 199 }
 200
 201 /* Test whether or not NAMESPACE looks like it mentions an anonymous
 202    namespace; return nonzero if so.  */
 203
 204 int
 205 cp_is_in_anonymous (const char *symbol_name)
 206 {
 207   return (strstr (symbol_name, CP_ANONYMOUS_NAMESPACE_STR)
 208           != NULL);
 209 }
 210
 211 /* Look up NAME in DOMAIN in BLOCK's static block and in global blocks.
 212    If ANONYMOUS_NAMESPACE is nonzero, the symbol in question is located
 213    within an anonymous namespace.  */
 214
 215 static struct symbol *
 216 cp_basic_lookup_symbol (const char *name, const struct block *block,
 217                         const domain_enum domain, int anonymous_namespace)
 218 {
 219   struct symbol *sym;
 220
 221   sym = lookup_symbol_in_static_block (name, block, domain);
 222   if (sym != NULL)
 223     return sym;
 224
 225   if (anonymous_namespace)
 226     {
 227       /* Symbols defined in anonymous namespaces have external linkage
 228          but should be treated as local to a single file nonetheless.
 229          So we only search the current file's global block.  */
 230
 231       const struct block *global_block = block_global_block (block);
 232
 233       if (global_block != NULL)
 234         sym = lookup_symbol_in_block (name, global_block, domain);
 235     }
 236   else
 237     {
 238       sym = lookup_global_symbol (name, block, domain);
 239     }
 240
 241   return sym;
 242 }
 243
 244 /* Search bare symbol NAME in DOMAIN in BLOCK.
 245    NAME is guaranteed to not have any scope (no "::").
 246    If SEARCH is non-zero then see if we can determine "this" from BLOCK, and
 247    if so then also search for NAME in that class.  */
 248
 249 static struct symbol *
 250 cp_lookup_bare_symbol (const char *name, const struct block *block,
 251                        const domain_enum domain, int search)
 252 {
 253   struct symbol *sym;
 254
 255   /* Note: We can't do a simple assert for ':' not being in NAME because
 256      ':' may be in the args of a template spec.  This isn't intended to be
 257      a complete test, just cheap and documentary.  */
 258   if (strchr (name, '<') == NULL && strchr (name, '(') == NULL)
 259     gdb_assert (strchr (name, ':') == NULL);
 260
 261   sym = lookup_symbol_in_static_block (name, block, domain);
 262   if (sym != NULL)
 263     return sym;
 264
 265   sym = lookup_global_symbol (name, block, domain);
 266   if (sym != NULL)
 267     return sym;
 268
 269   if (search)
 270     {
 271       struct symbol *this;
 272       struct type *type;
 273
 274       this = lookup_language_this (language_def (language_cplus), block);
 275       if (this == NULL)
 276         return NULL;
 277
 278       type = check_typedef (TYPE_TARGET_TYPE (SYMBOL_TYPE (this)));
 279       /* If TYPE_NAME is NULL, abandon trying to find this symbol.
 280          This can happen for lambda functions compiled with clang++,
 281          which outputs no name for the container class.  */
 282       if (TYPE_NAME (type) == NULL)
 283         return NULL;
 284
 285       /* Look for a symbol named NESTED in this class.  */
 286       sym = cp_lookup_nested_symbol (type, name, block);
 287     }
 288
 289   return sym;
 290 }
 291
 292 /* Search NAME in DOMAIN in all static blocks, and then in all baseclasses.
 293    BLOCK specifies the context in which to perform the search.
 294    NAME is guaranteed to have scope (contain "::") and PREFIX_LEN specifies
 295    then length the entire scope of NAME (up to, but not including, the last
 296    "::".
 297
 298    Note: At least in the case of Fortran, which also uses this code, there
 299    may be no text after the last "::".  */
 300
 301 static struct symbol *
 302 cp_search_static_and_baseclasses (const char *name,
 303                                   const struct block *block,
 304                                   const domain_enum domain,
 305                                   unsigned int prefix_len)
 306 {
 307   struct symbol *sym;
 308   char *klass, *nested;
 309   struct cleanup *cleanup;
 310   struct symbol *klass_sym;
 311   struct type *klass_type;
 312
 313   /* The test here uses <= instead of < because Fortran also uses this,
 314      and the module.exp testcase will pass "modmany::" for NAME here.  */
 315   gdb_assert (prefix_len + 2 <= strlen (name));
 316   gdb_assert (name[prefix_len + 1] == ':');
 317
 318   /* Find the name of the class and the name of the method, variable, etc.  */
 319
 320   /* The class name is everything up to and including PREFIX_LEN.  */
 321   klass = savestring (name, prefix_len);
 322
 323   /* The rest of the name is everything else past the initial scope
 324      operator.  */
 325   nested = xstrdup (name + prefix_len + 2);
 326
 327   /* Add cleanups to free memory for these strings.  */
 328   cleanup = make_cleanup (xfree, klass);
 329   make_cleanup (xfree, nested);
 330
 331   /* Lookup a class named KLASS.  If none is found, there is nothing
 332      more that can be done.  */
 333   klass_sym = lookup_global_symbol (klass, block, domain);
 334   if (klass_sym == NULL)
 335     {
 336       do_cleanups (cleanup);
 337       return NULL;
 338     }
 339   klass_type = SYMBOL_TYPE (klass_sym);
 340
 341   /* Look for a symbol named NESTED in this class.
 342      The caller is assumed to have already have done a basic lookup of NAME.
 343      So we pass zero for BASIC_LOOKUP to cp_lookup_nested_symbol_1 here.  */
 344   sym = cp_lookup_nested_symbol_1 (klass_type, nested, name, block, 0);
 345
 346   do_cleanups (cleanup);
 347   return sym;
 348 }
 349
 350 /* Look up NAME in the C++ namespace NAMESPACE.  Other arguments are
 351    as in cp_lookup_symbol_nonlocal.  If SEARCH is non-zero, search
 352    through base classes for a matching symbol.
 353
 354    Note: Part of the complexity is because NAME may itself specify scope.
 355    Part of the complexity is also because this handles the case where
 356    there is no scoping in which case we also try looking in the class of
 357    "this" if we can compute it.  */
 358
 359 static struct symbol *
 360 cp_lookup_symbol_in_namespace (const char *namespace, const char *name,
 361                                const struct block *block,
 362                                const domain_enum domain, int search)
 363 {
 364   char *concatenated_name = NULL;
 365   int is_in_anonymous;
 366   unsigned int prefix_len;
 367   struct symbol *sym;
 368
 369   if (namespace[0] != '\0')
 370     {
 371       concatenated_name = alloca (strlen (namespace) + 2
 372                                   + strlen (name) + 1);
 373       strcpy (concatenated_name, namespace);
 374       strcat (concatenated_name, "::");
 375       strcat (concatenated_name, name);
 376       name = concatenated_name;
 377     }
 378
 379   prefix_len = cp_entire_prefix_len (name);
 380   if (prefix_len == 0)
 381     return cp_lookup_bare_symbol (name, block, domain, search);
 382
 383   /* This would be simpler if we just called cp_lookup_nested_symbol
 384      at this point.  But that would require first looking up the containing
 385      class/namespace.  Since we're only searching static and global blocks
 386      there's often no need to first do that lookup.  */
 387
 388   is_in_anonymous = namespace[0] != '\0' && cp_is_in_anonymous (namespace);
 389   sym = cp_basic_lookup_symbol (name, block, domain, is_in_anonymous);
 390   if (sym != NULL)
 391     return sym;
 392
 393   if (search)
 394     sym = cp_search_static_and_baseclasses (name, block, domain, prefix_len);
 395
 396   return sym;
 397 }
 398
 399 /* Used for cleanups to reset the "searched" flag incase
 400    of an error.  */
 401
 402 static void
 403 reset_directive_searched (void *data)
 404 {
 405   struct using_direct *direct = data;
 406   direct->searched = 0;
 407 }
 408
 409 /* Search for NAME by applying all import statements belonging to
 410    BLOCK which are applicable in SCOPE.  If DECLARATION_ONLY the
 411    search is restricted to using declarations.
 412    Example:
 413
 414      namespace A {
 415        int x;
 416      }
 417      using A::x;
 418
 419    If SEARCH_PARENTS the search will include imports which are
 420    applicable in parents of SCOPE.
 421    Example:
 422
 423      namespace A {
 424        using namespace X;
 425        namespace B {
 426          using namespace Y;
 427        }
 428      }
 429
 430    If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
 431    namespaces X and Y will be considered.  If SEARCH_PARENTS is false
 432    only the import of Y is considered.
 433
 434    SEARCH_SCOPE_FIRST is an internal implementation detail: Callers must
 435    pass 0 for it.  Internally we pass 1 when recursing.  */
 436
 437 static struct symbol *
 438 cp_lookup_symbol_via_imports (const char *scope,
 439                               const char *name,
 440                               const struct block *block,
 441                               const domain_enum domain,
 442                               const int search_scope_first,
 443                               const int declaration_only,
 444                               const int search_parents)
 445 {
 446   struct using_direct *current;
 447   struct symbol *sym = NULL;
 448   int len;
 449   int directive_match;
 450   struct cleanup *searched_cleanup;
 451
 452   /* First, try to find the symbol in the given namespace if requested.  */
 453   if (search_scope_first)
 454     sym = cp_lookup_symbol_in_namespace (scope, name,
 455                                          block, domain, 1);
 456
 457   if (sym != NULL)
 458     return sym;
 459
 460   /* Go through the using directives.  If any of them add new names to
 461      the namespace we're searching in, see if we can find a match by
 462      applying them.  */
 463
 464   for (current = block_using (block);
 465        current != NULL;
 466        current = current->next)
 467     {
 468       const char **excludep;
 469
 470       len = strlen (current->import_dest);
 471       directive_match = (search_parents
 472                          ? (strncmp (scope, current->import_dest,
 473                                      strlen (current->import_dest)) == 0
 474                             && (len == 0
 475                                 || scope[len] == ':'
 476                                 || scope[len] == '\0'))
 477                          : strcmp (scope, current->import_dest) == 0);
 478
 479       /* If the import destination is the current scope or one of its
 480          ancestors then it is applicable.  */
 481       if (directive_match && !current->searched)
 482         {
 483           /* Mark this import as searched so that the recursive call
 484              does not search it again.  */
 485           current->searched = 1;
 486           searched_cleanup = make_cleanup (reset_directive_searched,
 487                                            current);
 488
 489           /* If there is an import of a single declaration, compare the
 490              imported declaration (after optional renaming by its alias)
 491              with the sought out name.  If there is a match pass
 492              current->import_src as NAMESPACE to direct the search
 493              towards the imported namespace.  */
 494           if (current->declaration
 495               && strcmp (name, current->alias
 496                          ? current->alias : current->declaration) == 0)
 497             sym = cp_lookup_symbol_in_namespace (current->import_src,
 498                                                  current->declaration,
 499                                                  block, domain, 1);
 500
 501           /* If this is a DECLARATION_ONLY search or a symbol was found
 502              or this import statement was an import declaration, the
 503              search of this import is complete.  */
 504           if (declaration_only || sym != NULL || current->declaration)
 505             {
 506               current->searched = 0;
 507               discard_cleanups (searched_cleanup);
 508
 509               if (sym != NULL)
 510                 return sym;
 511
 512               continue;
 513             }
 514
 515           /* Do not follow CURRENT if NAME matches its EXCLUDES.  */
 516           for (excludep = current->excludes; *excludep; excludep++)
 517             if (strcmp (name, *excludep) == 0)
 518               break;
 519           if (*excludep)
 520             {
 521               discard_cleanups (searched_cleanup);
 522               continue;
 523             }
 524
 525           if (current->alias != NULL
 526               && strcmp (name, current->alias) == 0)
 527             /* If the import is creating an alias and the alias matches
 528                the sought name.  Pass current->import_src as the NAME to
 529                direct the search towards the aliased namespace.  */
 530             {
 531               sym = cp_lookup_symbol_in_namespace (scope,
 532                                                    current->import_src,
 533                                                    block, domain, 1);
 534             }
 535           else if (current->alias == NULL)
 536             {
 537               /* If this import statement creates no alias, pass
 538                  current->inner as NAMESPACE to direct the search
 539                  towards the imported namespace.  */
 540               sym = cp_lookup_symbol_via_imports (current->import_src,
 541                                                   name, block,
 542                                                   domain, 1, 0, 0);
 543             }
 544           current->searched = 0;
 545           discard_cleanups (searched_cleanup);
 546
 547           if (sym != NULL)
 548             return sym;
 549         }
 550     }
 551
 552   return NULL;
 553 }
 554
 555 /* Helper function that searches an array of symbols for one named
 556    NAME.  */
 557
 558 static struct symbol *
 559 search_symbol_list (const char *name, int num,
 560                     struct symbol **syms)
 561 {
 562   int i;
 563
 564   /* Maybe we should store a dictionary in here instead.  */
 565   for (i = 0; i < num; ++i)
 566     {
 567       if (strcmp (name, SYMBOL_NATURAL_NAME (syms[i])) == 0)
 568         return syms[i];
 569     }
 570   return NULL;
 571 }
 572
 573 /* Like cp_lookup_symbol_via_imports, but if BLOCK is a function, it
 574    searches through the template parameters of the function and the
 575    function's type.  */
 576
 577 struct symbol *
 578 cp_lookup_symbol_imports_or_template (const char *scope,
 579                                       const char *name,
 580                                       const struct block *block,
 581                                       const domain_enum domain)
 582 {
 583   struct symbol *function = BLOCK_FUNCTION (block);
 584   struct symbol *result;
 585
 586   if (symbol_lookup_debug)
 587     {
 588       fprintf_unfiltered (gdb_stdlog,
 589                           "cp_lookup_symbol_imports_or_template"
 590                           " (%s, %s, %s, %s)\n",
 591                           scope, name, host_address_to_string (block),
 592                           domain_name (domain));
 593     }
 594
 595   if (function != NULL && SYMBOL_LANGUAGE (function) == language_cplus)
 596     {
 597       /* Search the function's template parameters.  */
 598       if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function))
 599         {
 600           struct template_symbol *templ
 601             = (struct template_symbol *) function;
 602
 603           result = search_symbol_list (name,
 604                                        templ->n_template_arguments,
 605                                        templ->template_arguments);
 606           if (result != NULL)
 607             {
 608               if (symbol_lookup_debug)
 609                 {
 610                   fprintf_unfiltered (gdb_stdlog,
 611                                       "cp_lookup_symbol_imports_or_template"
 612                                       " (...) = %s\n",
 613                                       host_address_to_string (result));
 614                 }
 615               return result;
 616             }
 617         }
 618
 619       /* Search the template parameters of the function's defining
 620          context.  */
 621       if (SYMBOL_NATURAL_NAME (function))
 622         {
 623           struct type *context;
 624           char *name_copy = xstrdup (SYMBOL_NATURAL_NAME (function));
 625           struct cleanup *cleanups = make_cleanup (xfree, name_copy);
 626           const struct language_defn *lang = language_def (language_cplus);
 627           struct gdbarch *arch
 628             = get_objfile_arch (SYMBOL_OBJFILE (function));
 629           const struct block *parent = BLOCK_SUPERBLOCK (block);
 630
 631           while (1)
 632             {
 633               unsigned int prefix_len = cp_entire_prefix_len (name_copy);
 634
 635               if (prefix_len == 0)
 636                 context = NULL;
 637               else
 638                 {
 639                   name_copy[prefix_len] = '\0';
 640                   context = lookup_typename (lang, arch,
 641                                              name_copy,
 642                                              parent, 1);
 643                 }
 644
 645               if (context == NULL)
 646                 break;
 647
 648               result
 649                 = search_symbol_list (name,
 650                                       TYPE_N_TEMPLATE_ARGUMENTS (context),
 651                                       TYPE_TEMPLATE_ARGUMENTS (context));
 652               if (result != NULL)
 653                 {
 654                   do_cleanups (cleanups);
 655                   if (symbol_lookup_debug)
 656                     {
 657                       fprintf_unfiltered (gdb_stdlog,
 658                                           "cp_lookup_symbol_imports_or_template"
 659                                           " (...) = %s\n",
 660                                           host_address_to_string (result));
 661                     }
 662                   return result;
 663                 }
 664             }
 665
 666           do_cleanups (cleanups);
 667         }
 668     }
 669
 670   result = cp_lookup_symbol_via_imports (scope, name, block, domain, 0, 1, 1);
 671   if (symbol_lookup_debug)
 672     {
 673       fprintf_unfiltered (gdb_stdlog,
 674                           "cp_lookup_symbol_imports_or_template (...) = %s\n",
 675                           result != NULL
 676                           ? host_address_to_string (result) : "NULL");
 677     }
 678   return result;
 679 }
 680
 681 /* Search for NAME by applying relevant import statements belonging to BLOCK
 682    and its parents.  SCOPE is the namespace scope of the context in which the
 683    search is being evaluated.  */
 684
 685 static struct symbol *
 686 cp_lookup_symbol_via_all_imports (const char *scope, const char *name,
 687                                   const struct block *block,
 688                                   const domain_enum domain)
 689 {
 690   struct symbol *sym;
 691
 692   while (block != NULL)
 693     {
 694       sym = cp_lookup_symbol_via_imports (scope, name, block, domain, 0, 0, 1);
 695       if (sym)
 696         return sym;
 697
 698       block = BLOCK_SUPERBLOCK (block);
 699     }
 700
 701   return NULL;
 702 }
 703
 704 /* Searches for NAME in the current namespace, and by applying
 705    relevant import statements belonging to BLOCK and its parents.
 706    SCOPE is the namespace scope of the context in which the search is
 707    being evaluated.  */
 708
 709 struct symbol *
 710 cp_lookup_symbol_namespace (const char *scope,
 711                             const char *name,
 712                             const struct block *block,
 713                             const domain_enum domain)
 714 {
 715   struct symbol *sym;
 716
 717   if (symbol_lookup_debug)
 718     {
 719       fprintf_unfiltered (gdb_stdlog,
 720                           "cp_lookup_symbol_namespace (%s, %s, %s, %s)\n",
 721                           scope, name, host_address_to_string (block),
 722                           domain_name (domain));
 723     }
 724
 725   /* First, try to find the symbol in the given namespace.  */
 726   sym = cp_lookup_symbol_in_namespace (scope, name, block, domain, 1);
 727
 728   /* Search for name in namespaces imported to this and parent blocks.  */
 729   if (sym == NULL)
 730     sym = cp_lookup_symbol_via_all_imports (scope, name, block, domain);
 731
 732   if (symbol_lookup_debug)
 733     {
 734       fprintf_unfiltered (gdb_stdlog,
 735                           "cp_lookup_symbol_namespace (...) = %s\n",
 736                           sym != NULL ? host_address_to_string (sym) : "NULL");
 737     }
 738   return sym;
 739 }
 740
 741 /* Lookup NAME at namespace scope (or, in C terms, in static and
 742    global variables).  SCOPE is the namespace that the current
 743    function is defined within; only consider namespaces whose length
 744    is at least SCOPE_LEN.  Other arguments are as in
 745    cp_lookup_symbol_nonlocal.
 746
 747    For example, if we're within a function A::B::f and looking for a
 748    symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
 749    SCOPE_LEN = 0.  It then calls itself with NAME and SCOPE the same,
 750    but with SCOPE_LEN = 1.  And then it calls itself with NAME and
 751    SCOPE the same, but with SCOPE_LEN = 4.  This third call looks for
 752    "A::B::x"; if it doesn't find it, then the second call looks for
 753    "A::x", and if that call fails, then the first call looks for
 754    "x".  */
 755
 756 static struct symbol *
 757 lookup_namespace_scope (const char *name,
 758                         const struct block *block,
 759                         const domain_enum domain,
 760                         const char *scope,
 761                         int scope_len)
 762 {
 763   char *namespace;
 764
 765   if (scope[scope_len] != '\0')
 766     {
 767       /* Recursively search for names in child namespaces first.  */
 768
 769       struct symbol *sym;
 770       int new_scope_len = scope_len;
 771
 772       /* If the current scope is followed by "::", skip past that.  */
 773       if (new_scope_len != 0)
 774         {
 775           gdb_assert (scope[new_scope_len] == ':');
 776           new_scope_len += 2;
 777         }
 778       new_scope_len += cp_find_first_component (scope + new_scope_len);
 779       sym = lookup_namespace_scope (name, block, domain,
 780                                     scope, new_scope_len);
 781       if (sym != NULL)
 782         return sym;
 783     }
 784
 785   /* Okay, we didn't find a match in our children, so look for the
 786      name in the current namespace.  */
 787
 788   namespace = alloca (scope_len + 1);
 789   strncpy (namespace, scope, scope_len);
 790   namespace[scope_len] = '\0';
 791   return cp_lookup_symbol_in_namespace (namespace, name,
 792                                         block, domain, 1);
 793 }
 794
 795 /* The C++-specific version of name lookup for static and global
 796    names.  This makes sure that names get looked for in all namespaces
 797    that are in scope.  NAME is the natural name of the symbol that
 798    we're looking for, BLOCK is the block that we're searching within,
 799    DOMAIN says what kind of symbols we're looking for.  */
 800
 801 struct symbol *
 802 cp_lookup_symbol_nonlocal (const char *name,
 803                            const struct block *block,
 804                            const domain_enum domain)
 805 {
 806   struct symbol *sym;
 807   const char *scope = block_scope (block);
 808
 809   if (symbol_lookup_debug)
 810     {
 811       fprintf_unfiltered (gdb_stdlog,
 812                           "cp_lookup_symbol_non_local"
 813                           " (%s, %s (scope %s), %s)\n",
 814                           name, host_address_to_string (block), scope,
 815                           domain_name (domain));
 816     }
 817
 818   /* First, try to find the symbol in the given namespace, and all
 819      containing namespaces.  */
 820   sym = lookup_namespace_scope (name, block, domain, scope, 0);
 821
 822   /* Search for name in namespaces imported to this and parent blocks.  */
 823   if (sym == NULL)
 824     sym = cp_lookup_symbol_via_all_imports (scope, name, block, domain);
 825
 826   if (symbol_lookup_debug)
 827     {
 828       fprintf_unfiltered (gdb_stdlog,
 829                           "cp_lookup_symbol_nonlocal (...) = %s\n",
 830                           sym != NULL ? host_address_to_string (sym) : "NULL");
 831     }
 832   return sym;
 833 }
 834
 835 /* Search through the base classes of PARENT_TYPE for a base class
 836    named NAME and return its type.  If not found, return NULL.  */
 837
 838 struct type *
 839 cp_find_type_baseclass_by_name (struct type *parent_type, const char *name)
 840 {
 841   int i;
 842
 843   CHECK_TYPEDEF (parent_type);
 844   for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
 845     {
 846       struct type *type = check_typedef (TYPE_BASECLASS (parent_type, i));
 847       const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
 848
 849       if (base_name == NULL)
 850         continue;
 851
 852       if (streq (base_name, name))
 853         return type;
 854
 855       type = cp_find_type_baseclass_by_name (type, name);
 856       if (type != NULL)
 857         return type;
 858     }
 859
 860   return NULL;
 861 }
 862
 863 /* Search through the base classes of PARENT_TYPE for a symbol named
 864    NAME in block BLOCK.  */
 865
 866 static struct symbol *
 867 find_symbol_in_baseclass (struct type *parent_type, const char *name,
 868                            const struct block *block)
 869 {
 870   int i;
 871   struct symbol *sym;
 872   struct cleanup *cleanup;
 873   char *concatenated_name;
 874
 875   sym = NULL;
 876   concatenated_name = NULL;
 877   cleanup = make_cleanup (free_current_contents, &concatenated_name);
 878
 879   for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
 880     {
 881       size_t len;
 882       struct type *base_type = TYPE_BASECLASS (parent_type, i);
 883       const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
 884
 885       if (base_name == NULL)
 886         continue;
 887
 888       len = strlen (base_name) + 2 + strlen (name) + 1;
 889       concatenated_name = xrealloc (concatenated_name, len);
 890       xsnprintf (concatenated_name, len, "%s::%s", base_name, name);
 891
 892       sym = cp_lookup_nested_symbol_1 (base_type, name, concatenated_name,
 893                                        block, 1);
 894       if (sym != NULL)
 895         break;
 896     }
 897
 898   do_cleanups (cleanup);
 899   return sym;
 900 }
 901
 902 /* Helper function to look up NESTED_NAME in CONTAINER_TYPE within the
 903    context of BLOCK.
 904    CONTAINER_TYPE needn't have been "check_typedef'd" yet.
 905    CONCATENATED_NAME is the fully scoped spelling of NESTED_NAME, it is
 906    passed as an argument so that callers can control how space for it is
 907    allocated.
 908    If BASIC_LOOKUP is non-zero then perform a basic lookup of
 909    CONCATENATED_NAME.  See cp_basic_lookup_symbol for details.  */
 910
 911 static struct symbol *
 912 cp_lookup_nested_symbol_1 (struct type *container_type,
 913                            const char *nested_name,
 914                            const char *concatenated_name,
 915                            const struct block *block,
 916                            int basic_lookup)
 917 {
 918   int is_in_anonymous = cp_is_in_anonymous (concatenated_name);
 919   struct symbol *sym;
 920
 921   /* NOTE: carlton/2003-11-10: We don't treat C++ class members
 922      of classes like, say, data or function members.  Instead,
 923      they're just represented by symbols whose names are
 924      qualified by the name of the surrounding class.  This is
 925      just like members of namespaces; in particular,
 926      cp_basic_lookup_symbol works when looking them up.  */
 927
 928   if (basic_lookup)
 929     {
 930       sym = cp_basic_lookup_symbol (concatenated_name, block, VAR_DOMAIN,
 931                                     is_in_anonymous);
 932       if (sym != NULL)
 933         return sym;
 934     }
 935
 936   /* Now search all static file-level symbols.  We have to do this for things
 937      like typedefs in the class.  We do not try to guess any imported
 938      namespace as even the fully specified namespace search is already not
 939      C++ compliant and more assumptions could make it too magic.  */
 940
 941   /* First search in this symtab, what we want is possibly there.  */
 942   sym = lookup_symbol_in_static_block (concatenated_name, block, VAR_DOMAIN);
 943   if (sym != NULL)
 944     return sym;
 945
 946   /* Nope.  We now have to search all static blocks in all objfiles,
 947      even if block != NULL, because there's no guarantees as to which
 948      symtab the symbol we want is in.  */
 949   sym = lookup_static_symbol (concatenated_name, VAR_DOMAIN);
 950   if (sym != NULL)
 951     return sym;
 952
 953   /* If this is a class with baseclasses, search them next.  */
 954   CHECK_TYPEDEF (container_type);
 955   if (TYPE_N_BASECLASSES (container_type) > 0)
 956     {
 957       sym = find_symbol_in_baseclass (container_type, nested_name, block);
 958       if (sym != NULL)
 959         return sym;
 960     }
 961
 962   return NULL;
 963 }
 964
 965 /* Look up a symbol named NESTED_NAME that is nested inside the C++
 966    class or namespace given by PARENT_TYPE, from within the context
 967    given by BLOCK.  Return NULL if there is no such nested symbol.  */
 968
 969 struct symbol *
 970 cp_lookup_nested_symbol (struct type *parent_type,
 971                          const char *nested_name,
 972                          const struct block *block)
 973 {
 974   /* type_name_no_tag_or_error provides better error reporting using the
 975      original type.  */
 976   struct type *saved_parent_type = parent_type;
 977
 978   CHECK_TYPEDEF (parent_type);
 979
 980   if (symbol_lookup_debug)
 981     {
 982       const char *type_name = type_name_no_tag (saved_parent_type);
 983
 984       fprintf_unfiltered (gdb_stdlog,
 985                           "cp_lookup_nested_symbol (%s, %s, %s)\n",
 986                           type_name != NULL ? type_name : "unnamed",
 987                           nested_name, host_address_to_string (block));
 988     }
 989
 990   switch (TYPE_CODE (parent_type))
 991     {
 992     case TYPE_CODE_STRUCT:
 993     case TYPE_CODE_NAMESPACE:
 994     case TYPE_CODE_UNION:
 995     case TYPE_CODE_ENUM:
 996     /* NOTE: Handle modules here as well, because Fortran is re-using the C++
 997        specific code to lookup nested symbols in modules, by calling the
 998        function pointer la_lookup_symbol_nonlocal, which ends up here.  */
 999     case TYPE_CODE_MODULE:
1000       {
1001         int size;
1002         const char *parent_name = type_name_no_tag_or_error (saved_parent_type);
1003         struct symbol *sym;
1004         char *concatenated_name;
1005
1006         size = strlen (parent_name) + 2 + strlen (nested_name) + 1;
1007         concatenated_name = alloca (size);
1008         xsnprintf (concatenated_name, size, "%s::%s",
1009                    parent_name, nested_name);
1010
1011         sym = cp_lookup_nested_symbol_1 (parent_type, nested_name,
1012                                          concatenated_name, block, 1);
1013
1014         if (symbol_lookup_debug)
1015           {
1016             fprintf_unfiltered (gdb_stdlog,
1017                                 "cp_lookup_nested_symbol (...) = %s\n",
1018                                 sym != NULL
1019                                 ? host_address_to_string (sym) : "NULL");
1020           }
1021         return sym;
1022       }
1023
1024     case TYPE_CODE_FUNC:
1025     case TYPE_CODE_METHOD:
1026       if (symbol_lookup_debug)
1027         {
1028           fprintf_unfiltered (gdb_stdlog,
1029                               "cp_lookup_nested_symbol (...) = NULL"
1030                               " (func/method)\n");
1031         }
1032       return NULL;
1033
1034     default:
1035       internal_error (__FILE__, __LINE__,
1036                       _("cp_lookup_nested_symbol called "
1037                         "on a non-aggregate type."));
1038     }
1039 }
1040
1041 /* The C++-version of lookup_transparent_type.  */
1042
1043 /* FIXME: carlton/2004-01-16: The problem that this is trying to
1044    address is that, unfortunately, sometimes NAME is wrong: it may not
1045    include the name of namespaces enclosing the type in question.
1046    lookup_transparent_type gets called when the type in question
1047    is a declaration, and we're trying to find its definition; but, for
1048    declarations, our type name deduction mechanism doesn't work.
1049    There's nothing we can do to fix this in general, I think, in the
1050    absence of debug information about namespaces (I've filed PR
1051    gdb/1511 about this); until such debug information becomes more
1052    prevalent, one heuristic which sometimes looks is to search for the
1053    definition in namespaces containing the current namespace.
1054
1055    We should delete this functions once the appropriate debug
1056    information becomes more widespread.  (GCC 3.4 will be the first
1057    released version of GCC with such information.)  */
1058
1059 struct type *
1060 cp_lookup_transparent_type (const char *name)
1061 {
1062   /* First, try the honest way of looking up the definition.  */
1063   struct type *t = basic_lookup_transparent_type (name);
1064   const char *scope;
1065
1066   if (t != NULL)
1067     return t;
1068
1069   /* If that doesn't work and we're within a namespace, look there
1070      instead.  */
1071   scope = block_scope (get_selected_block (0));
1072
1073   if (scope[0] == '\0')
1074     return NULL;
1075
1076   return cp_lookup_transparent_type_loop (name, scope, 0);
1077 }
1078
1079 /* Lookup the type definition associated to NAME in namespaces/classes
1080    containing SCOPE whose name is strictly longer than LENGTH.  LENGTH
1081    must be the index of the start of a component of SCOPE.  */
1082
1083 static struct type *
1084 cp_lookup_transparent_type_loop (const char *name,
1085                                  const char *scope,
1086                                  int length)
1087 {
1088   int scope_length = length + cp_find_first_component (scope + length);
1089   char *full_name;
1090
1091   /* If the current scope is followed by "::", look in the next
1092      component.  */
1093   if (scope[scope_length] == ':')
1094     {
1095       struct type *retval
1096         = cp_lookup_transparent_type_loop (name, scope,
1097                                            scope_length + 2);
1098
1099       if (retval != NULL)
1100         return retval;
1101     }
1102
1103   full_name = alloca (scope_length + 2 + strlen (name) + 1);
1104   strncpy (full_name, scope, scope_length);
1105   strncpy (full_name + scope_length, "::", 2);
1106   strcpy (full_name + scope_length + 2, name);
1107
1108   return basic_lookup_transparent_type (full_name);
1109 }
1110
1111 /* This used to do something but was removed when it became
1112    obsolete.  */
1113
1114 static void
1115 maintenance_cplus_namespace (char *args, int from_tty)
1116 {
1117   printf_unfiltered (_("The `maint namespace' command was removed.\n"));
1118 }
1119
1120 /* Provide a prototype to silence -Wmissing-prototypes.  */
1121 extern initialize_file_ftype _initialize_cp_namespace;
1122
1123 void
1124 _initialize_cp_namespace (void)
1125 {
1126   struct cmd_list_element *cmd;
1127
1128   cmd = add_cmd ("namespace", class_maintenance,
1129                  maintenance_cplus_namespace,
1130                  _("Deprecated placeholder for removed functionality."),
1131                  &maint_cplus_cmd_list);
1132   deprecate_cmd (cmd, NULL);
1133 }