gdb/cp-namespace.c

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