bool Sema::OOPLookupName(LookupResult &R, Scope *S) {
assert(getLangOptions().OOP && "Can perform only OOP lookup");
DefinitionName Name = R.getLookupName();
IdentifierResolver::iterator I = IdResolver.begin(Name),
IEnd = IdResolver.end();
// First we lookup local scope.
for (; S /*&& !isNamespaceOrTranslationUnitScope(S)*/; S = S->getParent()) {
DefnContext *Ctx = static_cast<DefnContext *>(S->getEntity());
// Check whether the IdResolver has anything in this scope.
bool Found = false;
for (; I != IEnd && S->isDefnScope(*I); ++I) {
if (R.isAcceptableDefn(*I)) {
Found = true;
R.addDefn(*I);
}
}
if (Found) {
R.resolveKind();
if (S->isClassScope())
if (UserClassDefn *Record = dyn_cast_or_null<UserClassDefn>(Ctx))
R.setNamingClass(Record);
return true;
}
if (Ctx) {
for (; Ctx; Ctx = Ctx->getParent()) {
// We do not look directly into function or method contexts,
// since all of the local variables and parameters of the
// function/method are present within the Scope.
if (Ctx->isFunctionOrMethod()) {
continue;
}
// Perform qualified name lookup into this context.
// FIXME: In some cases, we know that every name that could be found by
// this qualified name lookup will also be on the identifier chain. For
// example, inside a class without any base classes, we never need to
// perform qualified lookup because all of the members are on top of the
// identifier chain.
if (LookupQualifiedName(R, Ctx, /*InUnqualifiedLookup=*/true))
return true;
}
}
}
// Stop if we ran out of scopes.
// FIXME: This really, really shouldn't be happening.
if (!S) return false;
// If we are looking for members, no need to look into global/namespace scope.
if (R.getLookupKind() == LookupMemberName)
return false;
return !R.empty();
}
/// LookupBuiltin - Lookup for built-in functions
static bool LookupBuiltin(Sema &S, LookupResult &R) {
Sema::LookupNameKind NameKind = R.getLookupKind();
// If we didn't find a use of this identifier, and if the identifier
// corresponds to a compiler builtin, create the defn object for the builtin
// now, injecting it into system scope, and return it.
if (NameKind == Sema::LookupOrdinaryName) {
IdentifierInfo *II = R.getLookupName().getAsIdentifierInfo();
if (II) {
// If this is a builtin on this (or all) targets, create the defn.
if (unsigned BuiltinID = II->getBuiltinID()) {
if (NamedDefn *D = S.LazilyCreateBuiltin((IdentifierInfo *)II,
BuiltinID, S.BaseWorkspace,
/*R.isForRedeclaration()*/false,
R.getNameLoc())) {
R.addDefn(D);
return true;
}
//FIXME yabin
// should i deal with this situation in gmat?
// if (R.isForRedeclaration()) {
// // If we're redeclaring this function anyway, forget that
// // this was a builtin at all.
// S.Context.BuiltinInfo.ForgetBuiltin(BuiltinID,
// S.Context.Idents);
// }
return false;
}
}
}
return false;
}
//===----------------------------------------------------------------------===//
// Sema
//===----------------------------------------------------------------------===//
bool Sema::LookupName(LookupResult &R, Scope *S, bool AllowBuiltinCreation) {
DefinitionName Name = R.getLookupName();
if (!Name) return false;
// FIXME yabin
// LookupNameKind NameKind = R.getLookupKind();
if (!getLangOptions().OOP) {
// Unqualified name lookup in non-oop is purely lexical, so
// search in the definitions attached to the name.
unsigned IDNS = R.getIdentifierNamespace();
// Scan up the scope chain looking for a defn that matches this
// identifier that is in the appropriate namespace. This search
// should not take long, as shadowing of names is uncommon, and
// deep shadowing is extremely uncommon.
// bool LeftStartingScope = false;
for (IdentifierResolver::iterator I = IdResolver.begin(Name), IEnd =
IdResolver.end(); I != IEnd; ++I) {
if ((*I)->isInIdentifierNamespace(IDNS)) {
R.addDefn(*I);
R.resolveKind();
return true;
}
}
} else {
// Perform OOP unqualified name lookup.
if (OOPLookupName(R, S))
return true;
}
// If we didn't find a use of this identifier, and if the identifier
// corresponds to a compiler builtin, create the defn object for the builtin
// now, injecting it into top scope, and return it.
if (AllowBuiltinCreation)
return LookupBuiltin(*this, R);
return false;
}
