contrib/gdb-7/gdb/cp-namespace.c
struct symbol *
cp_lookup_symbol_imports (const char *scope,
                          const char *name,
                          const struct block *block,
                          const domain_enum domain,
                          const int declaration_only,
                          const int search_parents)
{
  struct using_direct *current;
  struct symbol *sym = NULL;
  int len;
  int directive_match;
  struct cleanup *searched_cleanup;

  /* First, try to find the symbol in the given namespace.  */
  if (!declaration_only)
    sym = cp_lookup_symbol_in_namespace (scope, name,
					 block, domain);
  
  if (sym != NULL)
    return sym;

  /* Go through the using directives.  If any of them add new names to
     the namespace we're searching in, see if we can find a match by
     applying them.  */

  for (current = block_using (block);
       current != NULL;
       current = current->next)
    {
      const char **excludep;

      len = strlen (current->import_dest);
      directive_match = (search_parents
                         ? (strncmp (scope, current->import_dest,
                                     strlen (current->import_dest)) == 0
                            && (len == 0
                                || scope[len] == ':'
				|| scope[len] == '\0'))
                         : strcmp (scope, current->import_dest) == 0);

      /* If the import destination is the current scope or one of its
         ancestors then it is applicable.  */
      if (directive_match && !current->searched)
	{
	  /* Mark this import as searched so that the recursive call
	     does not search it again.  */
	  current->searched = 1;
	  searched_cleanup = make_cleanup (reset_directive_searched,
					   current);

	  /* If there is an import of a single declaration, compare the
	     imported declaration (after optional renaming by its alias)
	     with the sought out name.  If there is a match pass
	     current->import_src as NAMESPACE to direct the search
	     towards the imported namespace.  */
	  if (current->declaration
	      && strcmp (name, current->alias
			 ? current->alias : current->declaration) == 0)
	    sym = cp_lookup_symbol_in_namespace (current->import_src,
						 current->declaration,
						 block, domain);

	  /* If this is a DECLARATION_ONLY search or a symbol was found
	     or this import statement was an import declaration, the
	     search of this import is complete.  */
	  if (declaration_only || sym != NULL || current->declaration)
	    {
	      current->searched = 0;
	      discard_cleanups (searched_cleanup);

	      if (sym != NULL)
		return sym;

	      continue;
	    }

	  /* Do not follow CURRENT if NAME matches its EXCLUDES.  */
	  for (excludep = current->excludes; *excludep; excludep++)
	    if (strcmp (name, *excludep) == 0)
	      break;
	  if (*excludep)
	    {
	      discard_cleanups (searched_cleanup);
	      continue;
	    }

	  if (current->alias != NULL
	      && strcmp (name, current->alias) == 0)
	    /* If the import is creating an alias and the alias matches
	       the sought name.  Pass current->import_src as the NAME to
	       direct the search towards the aliased namespace.  */
	    {
	      sym = cp_lookup_symbol_in_namespace (scope,
						   current->import_src,
						   block, domain);
	    }
	  else if (current->alias == NULL)
	    {
	      /* If this import statement creates no alias, pass
		 current->inner as NAMESPACE to direct the search
		 towards the imported namespace.  */
	      sym = cp_lookup_symbol_imports (current->import_src,
					      name, block,
					      domain, 0, 0);
	    }
	  current->searched = 0;
	  discard_cleanups (searched_cleanup);

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

  return NULL;
}
/* Search for NAME by applying all import statements belonging to
   BLOCK which are applicable in SCOPE.  If DECLARATION_ONLY the
   search is restricted to using declarations.
   Example:

     namespace A {
       int x;
     }
     using A::x;

   If SEARCH_PARENTS the search will include imports which are
   applicable in parents of SCOPE.
   Example:

     namespace A {
       using namespace X;
       namespace B {
         using namespace Y;
       }
     }

   If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
   namespaces X and Y will be considered.  If SEARCH_PARENTS is false
   only the import of Y is considered.  */
Search for NAME by applying all import statements belonging to
BLOCK which are applicable in SCOPE.  If DECLARATION_ONLY the
search is restricted to using declarations.
Example.

namespace A {
int x;
}
using A::x.

If SEARCH_PARENTS the search will include imports which are
applicable in parents of SCOPE.
Example.



If SCOPE is "A::B" and SEARCH_PARENTS is true the imports of
namespaces X and Y will be considered.  If SEARCH_PARENTS is false
only the import of Y is considered.
Search for NAME by applying all import statements belonging to BLOCK which are applicable in SCOPE . If DECLARATION_ONLY the search is restricted to using declarations . Example . namespace A { int x ; } using A :: x . If SEARCH_PARENTS the search will include imports which are applicable in parents of SCOPE . Example . If SCOPE is " A :: B " and SEARCH_PARENTS is true the imports of namespaces X and Y will be considered . If SEARCH_PARENTS is false only the import of Y is considered .
struct symbol *
cp_lookup_symbol_imports (const char *scope,
                          const char *name,
                          const struct block *block,
                          const domain_enum domain,
                          const int declaration_only,
                          const int search_parents)
{
  struct using_direct *current;
  struct symbol *sym = NULL;
  int len;
  int directive_match;
  struct cleanup *searched_cleanup;
  if (!declaration_only)
    sym = cp_lookup_symbol_in_namespace (scope, name,
					 block, domain);
  if (sym != NULL)
    return sym;
  for (current = block_using (block);
       current != NULL;
       current = current->next)
    {
      const char **excludep;
      len = strlen (current->import_dest);
      directive_match = (search_parents
                         ? (strncmp (scope, current->import_dest,
                                     strlen (current->import_dest)) == 0
                            && (len == 0
                                || scope[len] == ':'
				|| scope[len] == '\0'))
                         : strcmp (scope, current->import_dest) == 0);
      if (directive_match && !current->searched)
	{
	  current->searched = 1;
	  searched_cleanup = make_cleanup (reset_directive_searched,
					   current);
	  if (current->declaration
	      && strcmp (name, current->alias
			 ? current->alias : current->declaration) == 0)
	    sym = cp_lookup_symbol_in_namespace (current->import_src,
						 current->declaration,
						 block, domain);
	  if (declaration_only || sym != NULL || current->declaration)
	    {
	      current->searched = 0;
	      discard_cleanups (searched_cleanup);
	      if (sym != NULL)
		return sym;
	      continue;
	    }
	  for (excludep = current->excludes; *excludep; excludep++)
	    if (strcmp (name, *excludep) == 0)
	      break;
	  if (*excludep)
	    {
	      discard_cleanups (searched_cleanup);
	      continue;
	    }
	  if (current->alias != NULL
	      && strcmp (name, current->alias) == 0)
	    {
	      sym = cp_lookup_symbol_in_namespace (scope,
						   current->import_src,
						   block, domain);
	    }
	  else if (current->alias == NULL)
	    {
	      sym = cp_lookup_symbol_imports (current->import_src,
					      name, block,
					      domain, 0, 0);
	    }
	  current->searched = 0;
	  discard_cleanups (searched_cleanup);
	  if (sym != NULL)
	    return sym;
	}
    }
  return NULL;
}
struct symbol * cp_lookup_symbol_imports ( const char * scope , const char * name , const struct block * block , const domain_enum domain , const int declaration_only , const int search_parents ) { struct using_direct * current ; struct symbol * sym = NULL ; int len ; int directive_match ; struct cleanup * searched_cleanup ; if ( ! declaration_only ) sym = cp_lookup_symbol_in_namespace ( scope , name , block , domain ) ; if ( sym != NULL ) return sym ; for ( current = block_using ( block ) ; current != NULL ; current = current -> next ) { const char * * excludep ; len = strlen ( current -> import_dest ) ; directive_match = ( search_parents ? ( strncmp ( scope , current -> import_dest , strlen ( current -> import_dest ) ) == 0 && ( len == 0 || scope [ len ] == ' ' || scope [ len ] == ' \0 ' ) ) : strcmp ( scope , current -> import_dest ) == 0 ) ; if ( directive_match && ! current -> searched ) { current -> searched = 1 ; searched_cleanup = make_cleanup ( reset_directive_searched , current ) ; if ( current -> declaration && strcmp ( name , current -> alias ? current -> alias : current -> declaration ) == 0 ) sym = cp_lookup_symbol_in_namespace ( current -> import_src , current -> declaration , block , domain ) ; if ( declaration_only || sym != NULL || current -> declaration ) { current -> searched = 0 ; discard_cleanups ( searched_cleanup ) ; if ( sym != NULL ) return sym ; continue ; } for ( excludep = current -> excludes ; * excludep ; excludep ++ ) if ( strcmp ( name , * excludep ) == 0 ) break ; if ( * excludep ) { discard_cleanups ( searched_cleanup ) ; continue ; } if ( current -> alias != NULL && strcmp ( name , current -> alias ) == 0 ) { sym = cp_lookup_symbol_in_namespace ( scope , current -> import_src , block , domain ) ; } else if ( current -> alias == NULL ) { sym = cp_lookup_symbol_imports ( current -> import_src , name , block , domain , 0 , 0 ) ; } current -> searched = 0 ; discard_cleanups ( searched_cleanup ) ; if ( sym != NULL ) return sym ; } } return NULL ; }
Search for NAME by applying all import statements belonging to
BLOCK which are applicable in SCOPE.
Search for NAME by applying all import statements belonging to BLOCK which are applicable in SCOPE .
/* First, try to find the symbol in the given namespace.  */ /* Go through the using directives.  If any of them add new names to
     the namespace we're searching in, see if we can find a match by
     applying them.  */ /* If the import destination is the current scope or one of its
         ancestors then it is applicable.  */ /* Mark this import as searched so that the recursive call
	     does not search it again.  */ /* If there is an import of a single declaration, compare the
	     imported declaration (after optional renaming by its alias)
	     with the sought out name.  If there is a match pass
	     current->import_src as NAMESPACE to direct the search
	     towards the imported namespace.  */ /* If this is a DECLARATION_ONLY search or a symbol was found
	     or this import statement was an import declaration, the
	     search of this import is complete.  */ /* Do not follow CURRENT if NAME matches its EXCLUDES.  */ /* If the import is creating an alias and the alias matches
	       the sought name.  Pass current->import_src as the NAME to
	       direct the search towards the aliased namespace.  */ /* If this import statement creates no alias, pass
		 current->inner as NAMESPACE to direct the search
		 towards the imported namespace.  */