/**
* Indicates whether any declarations matching <code>name</code> in enclosing (etc.) scopes
*
* <p>are hidden by a declaration in this scope. <br>
* <strong>note:</strong> you will generally use <code>searchLocalScope</code> to do a
*
* <p>proper search for matches in this scope prior to using this method.
*
* @param name the id to check
* @param flags any lookup flags - if the lookup is taking place for an id with an
* <p><em>elaborated type specifier</em>, the id will not be hidden by matches in this scope.
*/
protected boolean hidden(String name, LFlags flags) {
return (!(flags.contains(Cpp_LFlags.ELABTYPE) || scope.get(name) == null));
}
/**
* C++ - specific routine for qualified id lookup.
*
* <ul>
* ISO notes:
* <li>3.4.3-4 (global scope) case taken care of by <code>CTSymbolTable</code> before this
* routine is called
* </ul>
*
* @param name the scoped name (qualified id) to resolve
* @param flags any additional constraints on the lookup are indicated here
* @throws UndefinedSymbolException if any part of the qualifier doesn't resolve
*/
protected DeclarationSet qualifiedLookup(ScopedName name, LFlags flags)
throws UndefinedSymbolException {
d.msg(
Debug.COMPILE, ">>>welcome to common_sh qualified lookup, in " + this.getClass().getName());
// 3.4.3.4 (global scope) case taken care of before this method is called
// break references up
// current scope is local scope
// for each reference
// search for reference in current scope
// if found, new current scope is the namespace or class referred to
// this test may be overkill - is this method ever called outside of
// the CTSymbolTable and other ScopeHolders ?
if (!name.is_qualified()) Assert.apology(NOT_QUALIFIED, name.getName());
DeclarationSet matches = unqualifiedLookup(name, flags);
if (name.index.terminal()) { // reached terminal id in scoped name
name.index.reset();
return matches;
} else { // continue along qualifiers
if (matches.isEmpty()) {
throw new UndefinedSymbolException(name);
}
// getScopeHolder will check for multiple matches or
// non-scope-holder match
CommonSH msh = (CommonSH) matches.getScopeHolder();
name.index.advance();
// lookup for any id after the first qualifier is constrained by
// its qualifier (3.4.3-3)
// ** TODO ** special cases for destructor names and
// conversion-type-ids (3.4.3.1-1)
flags.set(Cpp_LFlags.QUALIFIED);
return msh.qualifiedLookup(name, flags);
}
// 3.4.3-3
// any name coming after a qualified name in a declaration is looked
// up in the scope of the qualified name's class or namespace
// anything before the qualified name is as normal
// - This is handled by CTSymbolTable and the algorithm in this method
// 3.4.3.1
// 1. a conversion-type-id of an operator-function-id is looked up
// both in the scope of the class and in the context in which
// the entire postfix-expression occurs and shall refer to the same
// type in both contexts
// - the approach currently taken is that since they 'shall refer
// to the same type', we can just look for it from the class scope.
// We don't need to check that the type is visible and equivalent
// in the pf-exp context.
// 2. destructor name is looked up as specified in 3.4.3-5
// - still need to detangle this one. Approach is to handle up
// front via lookup context flag QUALDEST.
}