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 /* Used for cleanups to reset the "searched" flag in case of an error.  */
 342
 343 static void
 344 reset_directive_searched (void *data)
 345 {
 346   struct using_direct *direct = (struct using_direct *) data;
 347   direct->searched = 0;
 348 }
 349
 350 /* Search for NAME by applying all import statements belonging to
 351    BLOCK which are applicable in SCOPE.  If DECLARATION_ONLY the
 352    search is restricted to using declarations.
 353    Example:
 354
 355      namespace A {
 356        int x;
 357      }
 358      using A::x;
 359
 360    If SEARCH_PARENTS the search will include imports which are
 361    applicable in parents of SCOPE.
 362    Example:
 363
 364      namespace A {
 365        using namespace X;
 366        namespace B {
 367          using namespace Y;
 368        }
 369      }
 370
 371    If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
 372    namespaces X and Y will be considered.  If SEARCH_PARENTS is false
 373    only the import of Y is considered.
 374
 375    SEARCH_SCOPE_FIRST is an internal implementation detail: Callers must
 376    pass 0 for it.  Internally we pass 1 when recursing.  */
 377
 378 static struct block_symbol
 379 cp_lookup_symbol_via_imports (const char *scope,
 380                               const char *name,
 381                               const struct block *block,
 382                               const domain_enum domain,
 383                               const int search_scope_first,
 384                               const int declaration_only,
 385                               const int search_parents)
 386 {
 387   struct using_direct *current;
 388   struct block_symbol sym;
 389   int len;
 390   int directive_match;
 391   struct cleanup *searched_cleanup;
 392
 393   sym.symbol = NULL;
 394   sym.block = NULL;
 395
 396   /* First, try to find the symbol in the given namespace if requested.  */
 397   if (search_scope_first)
 398     sym = cp_lookup_symbol_in_namespace (scope, name,
 399                                          block, domain, 1);
 400
 401   if (sym.symbol != NULL)
 402     return sym;
 403
 404   /* Go through the using directives.  If any of them add new names to
 405      the namespace we're searching in, see if we can find a match by
 406      applying them.  */
 407
 408   for (current = block_using (block);
 409        current != NULL;
 410        current = current->next)
 411     {
 412       const char **excludep;
 413
 414       len = strlen (current->import_dest);
 415       directive_match = (search_parents
 416                          ? (startswith (scope, current->import_dest)
 417                             && (len == 0
 418                                 || scope[len] == ':'
 419                                 || scope[len] == '\0'))
 420                          : strcmp (scope, current->import_dest) == 0);
 421
 422       /* If the import destination is the current scope or one of its
 423          ancestors then it is applicable.  */
 424       if (directive_match && !current->searched)
 425         {
 426           /* Mark this import as searched so that the recursive call
 427              does not search it again.  */
 428           current->searched = 1;
 429           searched_cleanup = make_cleanup (reset_directive_searched,
 430                                            current);
 431
 432           /* If there is an import of a single declaration, compare the
 433              imported declaration (after optional renaming by its alias)
 434              with the sought out name.  If there is a match pass
 435              current->import_src as NAMESPACE to direct the search
 436              towards the imported namespace.  */
 437           if (current->declaration
 438               && strcmp (name, current->alias
 439                          ? current->alias : current->declaration) == 0)
 440             sym = cp_lookup_symbol_in_namespace (current->import_src,
 441                                                  current->declaration,
 442                                                  block, domain, 1);
 443
 444           /* If this is a DECLARATION_ONLY search or a symbol was found
 445              or this import statement was an import declaration, the
 446              search of this import is complete.  */
 447           if (declaration_only || sym.symbol != NULL || current->declaration)
 448             {
 449               current->searched = 0;
 450               discard_cleanups (searched_cleanup);
 451
 452               if (sym.symbol != NULL)
 453                 return sym;
 454
 455               continue;
 456             }
 457
 458           /* Do not follow CURRENT if NAME matches its EXCLUDES.  */
 459           for (excludep = current->excludes; *excludep; excludep++)
 460             if (strcmp (name, *excludep) == 0)
 461               break;
 462           if (*excludep)
 463             {
 464               discard_cleanups (searched_cleanup);
 465               continue;
 466             }
 467
 468           if (current->alias != NULL
 469               && strcmp (name, current->alias) == 0)
 470             /* If the import is creating an alias and the alias matches
 471                the sought name.  Pass current->import_src as the NAME to
 472                direct the search towards the aliased namespace.  */
 473             {
 474               sym = cp_lookup_symbol_in_namespace (scope,
 475                                                    current->import_src,
 476                                                    block, domain, 1);
 477             }
 478           else if (current->alias == NULL)
 479             {
 480               /* If this import statement creates no alias, pass
 481                  current->inner as NAMESPACE to direct the search
 482                  towards the imported namespace.  */
 483               sym = cp_lookup_symbol_via_imports (current->import_src,
 484                                                   name, block,
 485                                                   domain, 1, 0, 0);
 486             }
 487           current->searched = 0;
 488           discard_cleanups (searched_cleanup);
 489
 490           if (sym.symbol != NULL)
 491             return sym;
 492         }
 493     }
 494
 495   return null_block_symbol;
 496 }
 497
 498 /* Helper function that searches an array of symbols for one named NAME.  */
 499
 500 static struct symbol *
 501 search_symbol_list (const char *name, int num,
 502                     struct symbol **syms)
 503 {
 504   int i;
 505
 506   /* Maybe we should store a dictionary in here instead.  */
 507   for (i = 0; i < num; ++i)
 508     {
 509       if (strcmp (name, SYMBOL_NATURAL_NAME (syms[i])) == 0)
 510         return syms[i];
 511     }
 512   return NULL;
 513 }
 514
 515 /* Like cp_lookup_symbol_via_imports, but if BLOCK is a function, it
 516    searches through the template parameters of the function and the
 517    function's type.  */
 518
 519 struct block_symbol
 520 cp_lookup_symbol_imports_or_template (const char *scope,
 521                                       const char *name,
 522                                       const struct block *block,
 523                                       const domain_enum domain)
 524 {
 525   struct symbol *function = BLOCK_FUNCTION (block);
 526   struct block_symbol result;
 527
 528   if (symbol_lookup_debug)
 529     {
 530       fprintf_unfiltered (gdb_stdlog,
 531                           "cp_lookup_symbol_imports_or_template"
 532                           " (%s, %s, %s, %s)\n",
 533                           scope, name, host_address_to_string (block),
 534                           domain_name (domain));
 535     }
 536
 537   if (function != NULL && SYMBOL_LANGUAGE (function) == language_cplus)
 538     {
 539       /* Search the function's template parameters.  */
 540       if (SYMBOL_IS_CPLUS_TEMPLATE_FUNCTION (function))
 541         {
 542           struct template_symbol *templ
 543             = (struct template_symbol *) function;
 544           struct symbol *sym = search_symbol_list (name,
 545                                                    templ->n_template_arguments,
 546                                                    templ->template_arguments);
 547
 548           if (sym != NULL)
 549             {
 550               if (symbol_lookup_debug)
 551                 {
 552                   fprintf_unfiltered (gdb_stdlog,
 553                                       "cp_lookup_symbol_imports_or_template"
 554                                       " (...) = %s\n",
 555                                       host_address_to_string (sym));
 556                 }
 557               return (struct block_symbol) {sym, block};
 558             }
 559         }
 560
 561       /* Search the template parameters of the function's defining
 562          context.  */
 563       if (SYMBOL_NATURAL_NAME (function))
 564         {
 565           struct type *context;
 566           std::string name_copy (SYMBOL_NATURAL_NAME (function));
 567           const struct language_defn *lang = language_def (language_cplus);
 568           struct gdbarch *arch = symbol_arch (function);
 569           const struct block *parent = BLOCK_SUPERBLOCK (block);
 570           struct symbol *sym;
 571
 572           while (1)
 573             {
 574               unsigned int prefix_len
 575                 = cp_entire_prefix_len (name_copy.c_str ());
 576
 577               if (prefix_len == 0)
 578                 context = NULL;
 579               else
 580                 {
 581                   name_copy.erase (prefix_len);
 582                   context = lookup_typename (lang, arch,
 583                                              name_copy.c_str (),
 584                                              parent, 1);
 585                 }
 586
 587               if (context == NULL)
 588                 break;
 589
 590               sym
 591                 = search_symbol_list (name,
 592                                       TYPE_N_TEMPLATE_ARGUMENTS (context),
 593                                       TYPE_TEMPLATE_ARGUMENTS (context));
 594               if (sym != NULL)
 595                 {
 596                   if (symbol_lookup_debug)
 597                     {
 598                       fprintf_unfiltered
 599                         (gdb_stdlog,
 600                          "cp_lookup_symbol_imports_or_template (...) = %s\n",
 601                          host_address_to_string (sym));
 602                     }
 603                   return (struct block_symbol) {sym, parent};
 604                 }
 605             }
 606         }
 607     }
 608
 609   result = cp_lookup_symbol_via_imports (scope, name, block, domain, 0, 1, 1);
 610   if (symbol_lookup_debug)
 611     {
 612       fprintf_unfiltered (gdb_stdlog,
 613                           "cp_lookup_symbol_imports_or_template (...) = %s\n",
 614                           result.symbol != NULL
 615                           ? host_address_to_string (result.symbol) : "NULL");
 616     }
 617   return result;
 618 }
 619
 620 /* Search for NAME by applying relevant import statements belonging to BLOCK
 621    and its parents.  SCOPE is the namespace scope of the context in which the
 622    search is being evaluated.  */
 623
 624 static struct block_symbol
 625 cp_lookup_symbol_via_all_imports (const char *scope, const char *name,
 626                                   const struct block *block,
 627                                   const domain_enum domain)
 628 {
 629   struct block_symbol sym;
 630
 631   while (block != NULL)
 632     {
 633       sym = cp_lookup_symbol_via_imports (scope, name, block, domain, 0, 0, 1);
 634       if (sym.symbol)
 635         return sym;
 636
 637       block = BLOCK_SUPERBLOCK (block);
 638     }
 639
 640   return null_block_symbol;
 641 }
 642
 643 /* Searches for NAME in the current namespace, and by applying
 644    relevant import statements belonging to BLOCK and its parents.
 645    SCOPE is the namespace scope of the context in which the search is
 646    being evaluated.  */
 647
 648 struct block_symbol
 649 cp_lookup_symbol_namespace (const char *scope,
 650                             const char *name,
 651                             const struct block *block,
 652                             const domain_enum domain)
 653 {
 654   struct block_symbol sym;
 655
 656   if (symbol_lookup_debug)
 657     {
 658       fprintf_unfiltered (gdb_stdlog,
 659                           "cp_lookup_symbol_namespace (%s, %s, %s, %s)\n",
 660                           scope, name, host_address_to_string (block),
 661                           domain_name (domain));
 662     }
 663
 664   /* First, try to find the symbol in the given namespace.  */
 665   sym = cp_lookup_symbol_in_namespace (scope, name, block, domain, 1);
 666
 667   /* Search for name in namespaces imported to this and parent blocks.  */
 668   if (sym.symbol == NULL)
 669     sym = cp_lookup_symbol_via_all_imports (scope, name, block, domain);
 670
 671   if (symbol_lookup_debug)
 672     {
 673       fprintf_unfiltered (gdb_stdlog,
 674                           "cp_lookup_symbol_namespace (...) = %s\n",
 675                           sym.symbol != NULL
 676                             ? host_address_to_string (sym.symbol) : "NULL");
 677     }
 678   return sym;
 679 }
 680
 681 /* Lookup NAME at namespace scope (or, in C terms, in static and
 682    global variables).  SCOPE is the namespace that the current
 683    function is defined within; only consider namespaces whose length
 684    is at least SCOPE_LEN.  Other arguments are as in
 685    cp_lookup_symbol_nonlocal.
 686
 687    For example, if we're within a function A::B::f and looking for a
 688    symbol x, this will get called with NAME = "x", SCOPE = "A::B", and
 689    SCOPE_LEN = 0.  It then calls itself with NAME and SCOPE the same,
 690    but with SCOPE_LEN = 1.  And then it calls itself with NAME and
 691    SCOPE the same, but with SCOPE_LEN = 4.  This third call looks for
 692    "A::B::x"; if it doesn't find it, then the second call looks for
 693    "A::x", and if that call fails, then the first call looks for
 694    "x".  */
 695
 696 static struct block_symbol
 697 lookup_namespace_scope (const struct language_defn *langdef,
 698                         const char *name,
 699                         const struct block *block,
 700                         const domain_enum domain,
 701                         const char *scope,
 702                         int scope_len)
 703 {
 704   char *the_namespace;
 705
 706   if (scope[scope_len] != '\0')
 707     {
 708       /* Recursively search for names in child namespaces first.  */
 709
 710       struct block_symbol sym;
 711       int new_scope_len = scope_len;
 712
 713       /* If the current scope is followed by "::", skip past that.  */
 714       if (new_scope_len != 0)
 715         {
 716           gdb_assert (scope[new_scope_len] == ':');
 717           new_scope_len += 2;
 718         }
 719       new_scope_len += cp_find_first_component (scope + new_scope_len);
 720       sym = lookup_namespace_scope (langdef, name, block, domain,
 721                                     scope, new_scope_len);
 722       if (sym.symbol != NULL)
 723         return sym;
 724     }
 725
 726   /* Okay, we didn't find a match in our children, so look for the
 727      name in the current namespace.
 728
 729      If we there is no scope and we know we have a bare symbol, then short
 730      circuit everything and call cp_lookup_bare_symbol directly.
 731      This isn't an optimization, rather it allows us to pass LANGDEF which
 732      is needed for primitive type lookup.  The test doesn't have to be
 733      perfect: if NAME is a bare symbol that our test doesn't catch (e.g., a
 734      template symbol with "::" in the argument list) then
 735      cp_lookup_symbol_in_namespace will catch it.  */
 736
 737   if (scope_len == 0 && strchr (name, ':') == NULL)
 738     return cp_lookup_bare_symbol (langdef, name, block, domain, 1);
 739
 740   the_namespace = (char *) alloca (scope_len + 1);
 741   strncpy (the_namespace, scope, scope_len);
 742   the_namespace[scope_len] = '\0';
 743   return cp_lookup_symbol_in_namespace (the_namespace, name,
 744                                         block, domain, 1);
 745 }
 746
 747 /* The C++-specific version of name lookup for static and global
 748    names.  This makes sure that names get looked for in all namespaces
 749    that are in scope.  NAME is the natural name of the symbol that
 750    we're looking for, BLOCK is the block that we're searching within,
 751    DOMAIN says what kind of symbols we're looking for.  */
 752
 753 struct block_symbol
 754 cp_lookup_symbol_nonlocal (const struct language_defn *langdef,
 755                            const char *name,
 756                            const struct block *block,
 757                            const domain_enum domain)
 758 {
 759   struct block_symbol sym;
 760   const char *scope = block_scope (block);
 761
 762   if (symbol_lookup_debug)
 763     {
 764       fprintf_unfiltered (gdb_stdlog,
 765                           "cp_lookup_symbol_non_local"
 766                           " (%s, %s (scope %s), %s)\n",
 767                           name, host_address_to_string (block), scope,
 768                           domain_name (domain));
 769     }
 770
 771   /* First, try to find the symbol in the given namespace, and all
 772      containing namespaces.  */
 773   sym = lookup_namespace_scope (langdef, name, block, domain, scope, 0);
 774
 775   /* Search for name in namespaces imported to this and parent blocks.  */
 776   if (sym.symbol == NULL)
 777     sym = cp_lookup_symbol_via_all_imports (scope, name, block, domain);
 778
 779   if (symbol_lookup_debug)
 780     {
 781       fprintf_unfiltered (gdb_stdlog,
 782                           "cp_lookup_symbol_nonlocal (...) = %s\n",
 783                           (sym.symbol != NULL
 784                            ? host_address_to_string (sym.symbol)
 785                            : "NULL"));
 786     }
 787   return sym;
 788 }
 789
 790 /* Search through the base classes of PARENT_TYPE for a base class
 791    named NAME and return its type.  If not found, return NULL.  */
 792
 793 struct type *
 794 cp_find_type_baseclass_by_name (struct type *parent_type, const char *name)
 795 {
 796   int i;
 797
 798   parent_type = check_typedef (parent_type);
 799   for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
 800     {
 801       struct type *type = check_typedef (TYPE_BASECLASS (parent_type, i));
 802       const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
 803
 804       if (base_name == NULL)
 805         continue;
 806
 807       if (streq (base_name, name))
 808         return type;
 809
 810       type = cp_find_type_baseclass_by_name (type, name);
 811       if (type != NULL)
 812         return type;
 813     }
 814
 815   return NULL;
 816 }
 817
 818 /* Search through the base classes of PARENT_TYPE for a symbol named
 819    NAME in block BLOCK.  */
 820
 821 static struct block_symbol
 822 find_symbol_in_baseclass (struct type *parent_type, const char *name,
 823                           const struct block *block, const domain_enum domain,
 824                           int is_in_anonymous)
 825 {
 826   int i;
 827   struct block_symbol sym;
 828
 829   sym.symbol = NULL;
 830   sym.block = NULL;
 831
 832   for (i = 0; i < TYPE_N_BASECLASSES (parent_type); ++i)
 833     {
 834       struct type *base_type = TYPE_BASECLASS (parent_type, i);
 835       const char *base_name = TYPE_BASECLASS_NAME (parent_type, i);
 836
 837       if (base_name == NULL)
 838         continue;
 839
 840       std::string concatenated_name = std::string (base_name) + "::" + name;
 841
 842       sym = cp_lookup_nested_symbol_1 (base_type, name,
 843                                        concatenated_name.c_str (),
 844                                        block, domain, 1, is_in_anonymous);
 845       if (sym.symbol != NULL)
 846         break;
 847     }
 848
 849   return sym;
 850 }
 851
 852 /* Helper function to look up NESTED_NAME in CONTAINER_TYPE and in DOMAIN
 853    and within the context of BLOCK.
 854    NESTED_NAME may have scope ("::").
 855    CONTAINER_TYPE needn't have been "check_typedef'd" yet.
 856    CONCATENATED_NAME is the fully scoped spelling of NESTED_NAME, it is
 857    passed as an argument so that callers can control how space for it is
 858    allocated.
 859    If BASIC_LOOKUP is non-zero then perform a basic lookup of
 860    CONCATENATED_NAME.  See cp_basic_lookup_symbol for details.
 861    If IS_IN_ANONYMOUS is non-zero then CONCATENATED_NAME is in an anonymous
 862    namespace.  */
 863
 864 static struct block_symbol
 865 cp_lookup_nested_symbol_1 (struct type *container_type,
 866                            const char *nested_name,
 867                            const char *concatenated_name,
 868                            const struct block *block,
 869                            const domain_enum domain,
 870                            int basic_lookup, int is_in_anonymous)
 871 {
 872   struct block_symbol sym;
 873
 874   /* NOTE: carlton/2003-11-10: We don't treat C++ class members
 875      of classes like, say, data or function members.  Instead,
 876      they're just represented by symbols whose names are
 877      qualified by the name of the surrounding class.  This is
 878      just like members of namespaces; in particular,
 879      cp_basic_lookup_symbol works when looking them up.  */
 880
 881   if (basic_lookup)
 882     {
 883       sym = cp_basic_lookup_symbol (concatenated_name, block, domain,
 884                                     is_in_anonymous);
 885       if (sym.symbol != NULL)
 886         return sym;
 887     }
 888
 889   /* Now search all static file-level symbols.  We have to do this for things
 890      like typedefs in the class.  We do not try to guess any imported
 891      namespace as even the fully specified namespace search is already not
 892      C++ compliant and more assumptions could make it too magic.  */
 893
 894   /* First search in this symtab, what we want is possibly there.  */
 895   sym = lookup_symbol_in_static_block (concatenated_name, block, domain);
 896   if (sym.symbol != NULL)
 897     return sym;
 898
 899   /* Nope.  We now have to search all static blocks in all objfiles,
 900      even if block != NULL, because there's no guarantees as to which
 901      symtab the symbol we want is in.  Except for symbols defined in
 902      anonymous namespaces should be treated as local to a single file,
 903      which we just searched.  */
 904   if (!is_in_anonymous)
 905     {
 906       sym = lookup_static_symbol (concatenated_name, domain);
 907       if (sym.symbol != NULL)
 908         return sym;
 909     }
 910
 911   /* If this is a class with baseclasses, search them next.  */
 912   container_type = check_typedef (container_type);
 913   if (TYPE_N_BASECLASSES (container_type) > 0)
 914     {
 915       sym = find_symbol_in_baseclass (container_type, nested_name, block,
 916                                       domain, is_in_anonymous);
 917       if (sym.symbol != NULL)
 918         return sym;
 919     }
 920
 921   return null_block_symbol;
 922 }
 923
 924 /* Look up a symbol named NESTED_NAME that is nested inside the C++
 925    class or namespace given by PARENT_TYPE, from within the context
 926    given by BLOCK, and in DOMAIN.
 927    Return NULL if there is no such nested symbol.  */
 928
 929 struct block_symbol
 930 cp_lookup_nested_symbol (struct type *parent_type,
 931                          const char *nested_name,
 932                          const struct block *block,
 933                          const domain_enum domain)
 934 {
 935   /* type_name_no_tag_or_error provides better error reporting using the
 936      original type.  */
 937   struct type *saved_parent_type = parent_type;
 938
 939   parent_type = check_typedef (parent_type);
 940
 941   if (symbol_lookup_debug)
 942     {
 943       const char *type_name = type_name_no_tag (saved_parent_type);
 944
 945       fprintf_unfiltered (gdb_stdlog,
 946                           "cp_lookup_nested_symbol (%s, %s, %s, %s)\n",
 947                           type_name != NULL ? type_name : "unnamed",
 948                           nested_name, host_address_to_string (block),
 949                           domain_name (domain));
 950     }
 951
 952   switch (TYPE_CODE (parent_type))
 953     {
 954     case TYPE_CODE_STRUCT:
 955     case TYPE_CODE_NAMESPACE:
 956     case TYPE_CODE_UNION:
 957     case TYPE_CODE_ENUM:
 958     /* NOTE: Handle modules here as well, because Fortran is re-using the C++
 959        specific code to lookup nested symbols in modules, by calling the
 960        function pointer la_lookup_symbol_nonlocal, which ends up here.  */
 961     case TYPE_CODE_MODULE:
 962       {
 963         int size;
 964         const char *parent_name = type_name_no_tag_or_error (saved_parent_type);
 965         struct block_symbol sym;
 966         char *concatenated_name;
 967         int is_in_anonymous;
 968
 969         size = strlen (parent_name) + 2 + strlen (nested_name) + 1;
 970         concatenated_name = (char *) alloca (size);
 971         xsnprintf (concatenated_name, size, "%s::%s",
 972                    parent_name, nested_name);
 973         is_in_anonymous = cp_is_in_anonymous (concatenated_name);
 974
 975         sym = cp_lookup_nested_symbol_1 (parent_type, nested_name,
 976                                          concatenated_name, block, domain,
 977                                          1, is_in_anonymous);
 978
 979         if (symbol_lookup_debug)
 980           {
 981             fprintf_unfiltered (gdb_stdlog,
 982                                 "cp_lookup_nested_symbol (...) = %s\n",
 983                                 (sym.symbol != NULL
 984                                  ? host_address_to_string (sym.symbol)
 985                                  : "NULL"));
 986           }
 987         return sym;
 988       }
 989
 990     case TYPE_CODE_FUNC:
 991     case TYPE_CODE_METHOD:
 992       if (symbol_lookup_debug)
 993         {
 994           fprintf_unfiltered (gdb_stdlog,
 995                               "cp_lookup_nested_symbol (...) = NULL"
 996                               " (func/method)\n");
 997         }
 998       return null_block_symbol;
 999
1000     default:
1001       internal_error (__FILE__, __LINE__,
1002                       _("cp_lookup_nested_symbol called "
1003                         "on a non-aggregate type."));
1004     }
1005 }
1006
1007 /* The C++-version of lookup_transparent_type.  */
1008
1009 /* FIXME: carlton/2004-01-16: The problem that this is trying to
1010    address is that, unfortunately, sometimes NAME is wrong: it may not
1011    include the name of namespaces enclosing the type in question.
1012    lookup_transparent_type gets called when the type in question
1013    is a declaration, and we're trying to find its definition; but, for
1014    declarations, our type name deduction mechanism doesn't work.
1015    There's nothing we can do to fix this in general, I think, in the
1016    absence of debug information about namespaces (I've filed PR
1017    gdb/1511 about this); until such debug information becomes more
1018    prevalent, one heuristic which sometimes looks is to search for the
1019    definition in namespaces containing the current namespace.
1020
1021    We should delete this functions once the appropriate debug
1022    information becomes more widespread.  (GCC 3.4 will be the first
1023    released version of GCC with such information.)  */
1024
1025 struct type *
1026 cp_lookup_transparent_type (const char *name)
1027 {
1028   /* First, try the honest way of looking up the definition.  */
1029   struct type *t = basic_lookup_transparent_type (name);
1030   const char *scope;
1031
1032   if (t != NULL)
1033     return t;
1034
1035   /* If that doesn't work and we're within a namespace, look there
1036      instead.  */
1037   scope = block_scope (get_selected_block (0));
1038
1039   if (scope[0] == '\0')
1040     return NULL;
1041
1042   return cp_lookup_transparent_type_loop (name, scope, 0);
1043 }
1044
1045 /* Lookup the type definition associated to NAME in namespaces/classes
1046    containing SCOPE whose name is strictly longer than LENGTH.  LENGTH
1047    must be the index of the start of a component of SCOPE.  */
1048
1049 static struct type *
1050 cp_lookup_transparent_type_loop (const char *name,
1051                                  const char *scope,
1052                                  int length)
1053 {
1054   int scope_length = length + cp_find_first_component (scope + length);
1055   char *full_name;
1056
1057   /* If the current scope is followed by "::", look in the next
1058      component.  */
1059   if (scope[scope_length] == ':')
1060     {
1061       struct type *retval
1062         = cp_lookup_transparent_type_loop (name, scope,
1063                                            scope_length + 2);
1064
1065       if (retval != NULL)
1066         return retval;
1067     }
1068
1069   full_name = (char *) alloca (scope_length + 2 + strlen (name) + 1);
1070   strncpy (full_name, scope, scope_length);
1071   strncpy (full_name + scope_length, "::", 2);
1072   strcpy (full_name + scope_length + 2, name);
1073
1074   return basic_lookup_transparent_type (full_name);
1075 }
1076
1077 /* This used to do something but was removed when it became
1078    obsolete.  */
1079
1080 static void
1081 maintenance_cplus_namespace (const char *args, int from_tty)
1082 {
1083   printf_unfiltered (_("The `maint namespace' command was removed.\n"));
1084 }
1085
1086 void
1087 _initialize_cp_namespace (void)
1088 {
1089   struct cmd_list_element *cmd;
1090
1091   cmd = add_cmd ("namespace", class_maintenance,
1092                  maintenance_cplus_namespace,
1093                  _("Deprecated placeholder for removed functionality."),
1094                  &maint_cplus_cmd_list);
1095   deprecate_cmd (cmd, NULL);
1096 }