+/* Search NAME in DOMAIN in all static blocks, and then in all baseclasses.
+ BLOCK specifies the context in which to perform the search.
+ NAME is guaranteed to have scope (contain "::") and PREFIX_LEN specifies
+ the length of the entire scope of NAME (up to, but not including, the last
+ "::".
+
+ Note: At least in the case of Fortran, which also uses this code, there
+ may be no text after the last "::". */
+
+static struct block_symbol
+cp_search_static_and_baseclasses (const char *name,
+ const struct block *block,
+ const domain_enum domain,
+ unsigned int prefix_len,
+ int is_in_anonymous)
+{
+ struct block_symbol sym;
+ struct block_symbol klass_sym;
+ struct type *klass_type;
+
+ /* Check for malformed input. */
+ if (prefix_len + 2 > strlen (name) || name[prefix_len + 1] != ':')
+ return null_block_symbol;
+
+ /* Find the name of the class and the name of the method, variable, etc. */
+
+ /* The class name is everything up to and including PREFIX_LEN. */
+ std::string klass (name, prefix_len);
+
+ /* The rest of the name is everything else past the initial scope
+ operator. */
+ std::string nested (name + prefix_len + 2);
+
+ /* Lookup a class named KLASS. If none is found, there is nothing
+ more that can be done. KLASS could be a namespace, so always look
+ in VAR_DOMAIN. This works for classes too because of
+ symbol_matches_domain (which should be replaced with something else,
+ but it's what we have today). */
+ klass_sym = lookup_global_symbol (klass.c_str (), block, VAR_DOMAIN);
+ if (klass_sym.symbol == NULL)
+ return null_block_symbol;
+ klass_type = SYMBOL_TYPE (klass_sym.symbol);
+
+ /* Look for a symbol named NESTED in this class.
+ The caller is assumed to have already have done a basic lookup of NAME.
+ So we pass zero for BASIC_LOOKUP to cp_lookup_nested_symbol_1 here. */
+ sym = cp_lookup_nested_symbol_1 (klass_type, nested.c_str (), name,
+ block, domain, 0, is_in_anonymous);