mirror of
https://github.com/Gericom/teak-llvm.git
synced 2025-06-26 14:58:59 -04:00
ca1e848588
the standard "set these as the list of protocols" interface instead of a strange "set this as the size and then set each one to the value" interface. The problem with the later is that it a) is completely different from everything else, b) is awkward, and c) doesn't handle the case when a referenced protocol is invalid: it set it to null. This meant that all clients downstream would have to handle null protocols in the protocol list, and empirically they didn't. Fix this by not setting invalid protocols in the referenced protocol list, fixing the crash on test/Sema/objc-interface-1.m While I'm at it, clean up some locations so that we produce: t.m:1:25: error: cannot find interface declaration for 'NSObject', superclass of 'NSWhatever' @interface NSWhatever : NSObject <NSCopying> ~~~~~~~~~~~~~~~~~~~~~ ^ instead of: t.m:1:1: error: cannot find interface declaration for 'NSObject', superclass of 'NSWhatever' @interface NSWhatever : NSObject <NSCopying> ^ llvm-svn: 53846
710 lines
26 KiB
C++
710 lines
26 KiB
C++
//===--- DeclObjC.cpp - ObjC Declaration AST Node Implementation ----------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file implements the Objective-C related Decl classes.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "clang/AST/DeclObjC.h"
|
|
#include "clang/AST/ASTContext.h"
|
|
using namespace clang;
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// ObjC Decl Allocation/Deallocation Method Implementations
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
ObjCMethodDecl *ObjCMethodDecl::Create(ASTContext &C,
|
|
SourceLocation beginLoc,
|
|
SourceLocation endLoc,
|
|
Selector SelInfo, QualType T,
|
|
Decl *contextDecl,
|
|
AttributeList *M, bool isInstance,
|
|
bool isVariadic,
|
|
bool isSynthesized,
|
|
ImplementationControl impControl) {
|
|
void *Mem = C.getAllocator().Allocate<ObjCMethodDecl>();
|
|
return new (Mem) ObjCMethodDecl(beginLoc, endLoc,
|
|
SelInfo, T, contextDecl,
|
|
M, isInstance,
|
|
isVariadic, isSynthesized, impControl);
|
|
}
|
|
|
|
ObjCMethodDecl::~ObjCMethodDecl() {
|
|
delete [] ParamInfo;
|
|
//delete [] MethodAttrs; // FIXME: Also destroy the stored Expr*.
|
|
}
|
|
|
|
void ObjCMethodDecl::Destroy(ASTContext& C) {
|
|
if (Body) Body->Destroy(C);
|
|
if (SelfDecl) SelfDecl->Destroy(C);
|
|
|
|
for (param_iterator I=param_begin(), E=param_end(); I!=E; ++I)
|
|
if (*I) (*I)->Destroy(C);
|
|
|
|
Decl::Destroy(C);
|
|
}
|
|
|
|
ObjCInterfaceDecl *ObjCInterfaceDecl::Create(ASTContext &C,
|
|
SourceLocation atLoc,
|
|
IdentifierInfo *Id,
|
|
SourceLocation ClassLoc,
|
|
bool ForwardDecl, bool isInternal){
|
|
void *Mem = C.getAllocator().Allocate<ObjCInterfaceDecl>();
|
|
return new (Mem) ObjCInterfaceDecl(atLoc, Id, ClassLoc, ForwardDecl,
|
|
isInternal);
|
|
}
|
|
|
|
ObjCInterfaceDecl::~ObjCInterfaceDecl() {
|
|
delete [] Ivars;
|
|
delete [] InstanceMethods;
|
|
delete [] ClassMethods;
|
|
delete [] PropertyDecl;
|
|
// FIXME: CategoryList?
|
|
}
|
|
|
|
void ObjCInterfaceDecl::Destroy(ASTContext& C) {
|
|
for (ivar_iterator I=ivar_begin(), E=ivar_end(); I!=E; ++I)
|
|
if (*I) (*I)->Destroy(C);
|
|
|
|
for (instmeth_iterator I=instmeth_begin(), E=instmeth_end(); I!=E; ++I)
|
|
if (*I) (*I)->Destroy(C);
|
|
|
|
for (classmeth_iterator I=classmeth_begin(), E=classmeth_end(); I!=E; ++I)
|
|
if (*I) (*I)->Destroy(C);
|
|
|
|
// FIXME: Because there is no clear ownership
|
|
// role between ObjCInterfaceDecls and the ObjCPropertyDecls that they
|
|
// reference, we destroy ObjCPropertyDecls in ~TranslationUnit.
|
|
|
|
Decl::Destroy(C);
|
|
}
|
|
|
|
|
|
ObjCIvarDecl *ObjCIvarDecl::Create(ASTContext &C, SourceLocation L,
|
|
IdentifierInfo *Id, QualType T, Expr *BW) {
|
|
void *Mem = C.getAllocator().Allocate<ObjCIvarDecl>();
|
|
return new (Mem) ObjCIvarDecl(L, Id, T, BW);
|
|
}
|
|
|
|
ObjCProtocolDecl *ObjCProtocolDecl::Create(ASTContext &C,
|
|
SourceLocation L,
|
|
unsigned numRefProtos,
|
|
IdentifierInfo *Id) {
|
|
void *Mem = C.getAllocator().Allocate<ObjCProtocolDecl>();
|
|
return new (Mem) ObjCProtocolDecl(L, numRefProtos, Id);
|
|
}
|
|
|
|
ObjCProtocolDecl::~ObjCProtocolDecl() {
|
|
delete [] ReferencedProtocols;
|
|
delete [] InstanceMethods;
|
|
delete [] ClassMethods;
|
|
delete [] PropertyDecl;
|
|
}
|
|
|
|
void ObjCProtocolDecl::Destroy(ASTContext& C) {
|
|
|
|
// Referenced Protocols are not owned, so don't Destroy them.
|
|
|
|
for (instmeth_iterator I=instmeth_begin(), E=instmeth_end(); I!=E; ++I)
|
|
if (*I) (*I)->Destroy(C);
|
|
|
|
for (classmeth_iterator I=classmeth_begin(), E=classmeth_end(); I!=E; ++I)
|
|
if (*I) (*I)->Destroy(C);
|
|
|
|
// FIXME: Because there is no clear ownership
|
|
// role between ObjCProtocolDecls and the ObjCPropertyDecls that they
|
|
// reference, we destroy ObjCPropertyDecls in ~TranslationUnit.
|
|
|
|
Decl::Destroy(C);
|
|
}
|
|
|
|
|
|
ObjCClassDecl *ObjCClassDecl::Create(ASTContext &C,
|
|
SourceLocation L,
|
|
ObjCInterfaceDecl **Elts, unsigned nElts) {
|
|
void *Mem = C.getAllocator().Allocate<ObjCClassDecl>();
|
|
return new (Mem) ObjCClassDecl(L, Elts, nElts);
|
|
}
|
|
|
|
ObjCClassDecl::~ObjCClassDecl() {
|
|
delete [] ForwardDecls;
|
|
}
|
|
|
|
void ObjCClassDecl::Destroy(ASTContext& C) {
|
|
|
|
// FIXME: There is no clear ownership policy now for referenced
|
|
// ObjCInterfaceDecls. Some of them can be forward declarations that
|
|
// are never later defined (in which case the ObjCClassDecl owns them)
|
|
// or the ObjCInterfaceDecl later becomes a real definition later. Ideally
|
|
// we should have separate objects for forward declarations and definitions,
|
|
// obviating this problem. Because of this situation, referenced
|
|
// ObjCInterfaceDecls are destroyed in ~TranslationUnit.
|
|
|
|
Decl::Destroy(C);
|
|
}
|
|
|
|
ObjCForwardProtocolDecl *
|
|
ObjCForwardProtocolDecl::Create(ASTContext &C,
|
|
SourceLocation L,
|
|
ObjCProtocolDecl **Elts, unsigned NumElts) {
|
|
void *Mem = C.getAllocator().Allocate<ObjCForwardProtocolDecl>();
|
|
return new (Mem) ObjCForwardProtocolDecl(L, Elts, NumElts);
|
|
}
|
|
|
|
ObjCForwardProtocolDecl::~ObjCForwardProtocolDecl() {
|
|
delete [] ReferencedProtocols;
|
|
}
|
|
|
|
ObjCCategoryDecl *ObjCCategoryDecl::Create(ASTContext &C,
|
|
SourceLocation L,
|
|
IdentifierInfo *Id) {
|
|
void *Mem = C.getAllocator().Allocate<ObjCCategoryDecl>();
|
|
return new (Mem) ObjCCategoryDecl(L, Id);
|
|
}
|
|
|
|
ObjCCategoryImplDecl *
|
|
ObjCCategoryImplDecl::Create(ASTContext &C,
|
|
SourceLocation L,IdentifierInfo *Id,
|
|
ObjCInterfaceDecl *ClassInterface) {
|
|
void *Mem = C.getAllocator().Allocate<ObjCCategoryImplDecl>();
|
|
return new (Mem) ObjCCategoryImplDecl(L, Id, ClassInterface);
|
|
}
|
|
|
|
ObjCImplementationDecl *
|
|
ObjCImplementationDecl::Create(ASTContext &C,
|
|
SourceLocation L,
|
|
IdentifierInfo *Id,
|
|
ObjCInterfaceDecl *ClassInterface,
|
|
ObjCInterfaceDecl *SuperDecl) {
|
|
void *Mem = C.getAllocator().Allocate<ObjCImplementationDecl>();
|
|
return new (Mem) ObjCImplementationDecl(L, Id, ClassInterface, SuperDecl);
|
|
}
|
|
|
|
ObjCCompatibleAliasDecl *
|
|
ObjCCompatibleAliasDecl::Create(ASTContext &C,
|
|
SourceLocation L,
|
|
IdentifierInfo *Id,
|
|
ObjCInterfaceDecl* AliasedClass) {
|
|
void *Mem = C.getAllocator().Allocate<ObjCCompatibleAliasDecl>();
|
|
return new (Mem) ObjCCompatibleAliasDecl(L, Id, AliasedClass);
|
|
}
|
|
|
|
ObjCPropertyDecl *ObjCPropertyDecl::Create(ASTContext &C,
|
|
SourceLocation L,
|
|
IdentifierInfo *Id,
|
|
QualType T,
|
|
PropertyControl propControl) {
|
|
void *Mem = C.getAllocator().Allocate<ObjCPropertyDecl>();
|
|
return new (Mem) ObjCPropertyDecl(L, Id, T);
|
|
}
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
// Objective-C Decl Implementation
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
void ObjCMethodDecl::setMethodParams(ParmVarDecl **NewParamInfo,
|
|
unsigned NumParams) {
|
|
assert(ParamInfo == 0 && "Already has param info!");
|
|
|
|
// Zero params -> null pointer.
|
|
if (NumParams) {
|
|
ParamInfo = new ParmVarDecl*[NumParams];
|
|
memcpy(ParamInfo, NewParamInfo, sizeof(ParmVarDecl*)*NumParams);
|
|
NumMethodParams = NumParams;
|
|
}
|
|
}
|
|
|
|
/// FindPropertyDeclaration - Finds declaration of the property given its name
|
|
/// in 'PropertyId' and returns it. It returns 0, if not found.
|
|
///
|
|
ObjCPropertyDecl *
|
|
ObjCInterfaceDecl::FindPropertyDeclaration(IdentifierInfo *PropertyId) const {
|
|
for (ObjCInterfaceDecl::classprop_iterator I = classprop_begin(),
|
|
E = classprop_end(); I != E; ++I) {
|
|
ObjCPropertyDecl *property = *I;
|
|
if (property->getIdentifier() == PropertyId)
|
|
return property;
|
|
}
|
|
// Look through categories.
|
|
for (ObjCCategoryDecl *Category = getCategoryList();
|
|
Category; Category = Category->getNextClassCategory()) {
|
|
ObjCPropertyDecl *property = Category->FindPropertyDeclaration(PropertyId);
|
|
if (property)
|
|
return property;
|
|
}
|
|
// Look through protocols.
|
|
for (ObjCInterfaceDecl::protocol_iterator I = protocol_begin(),
|
|
E = protocol_end(); I != E; ++I) {
|
|
ObjCProtocolDecl *Protocol = *I;
|
|
ObjCPropertyDecl *property = Protocol->FindPropertyDeclaration(PropertyId);
|
|
if (property)
|
|
return property;
|
|
}
|
|
if (getSuperClass())
|
|
return getSuperClass()->FindPropertyDeclaration(PropertyId);
|
|
return 0;
|
|
}
|
|
|
|
/// FindCategoryDeclaration - Finds category declaration in the list of
|
|
/// categories for this class and returns it. Name of the category is passed
|
|
/// in 'CategoryId'. If category not found, return 0;
|
|
///
|
|
ObjCCategoryDecl *
|
|
ObjCInterfaceDecl::FindCategoryDeclaration(IdentifierInfo *CategoryId) const {
|
|
for (ObjCCategoryDecl *Category = getCategoryList();
|
|
Category; Category = Category->getNextClassCategory())
|
|
if (Category->getIdentifier() == CategoryId)
|
|
return Category;
|
|
return 0;
|
|
}
|
|
|
|
/// FindIvarDeclaration - Find an Ivar declaration in this class given its
|
|
/// name in 'IvarId'. On failure to find, return 0;
|
|
///
|
|
ObjCIvarDecl *
|
|
ObjCInterfaceDecl::FindIvarDeclaration(IdentifierInfo *IvarId) const {
|
|
for (ObjCInterfaceDecl::ivar_iterator IVI = ivar_begin(),
|
|
IVE = ivar_end(); IVI != IVE; ++IVI) {
|
|
ObjCIvarDecl* Ivar = (*IVI);
|
|
if (Ivar->getIdentifier() == IvarId)
|
|
return Ivar;
|
|
}
|
|
if (getSuperClass())
|
|
return getSuperClass()->FindIvarDeclaration(IvarId);
|
|
return 0;
|
|
}
|
|
|
|
/// addReferencedProtocols - Set the list of protocols that this interface
|
|
/// implements.
|
|
void ObjCInterfaceDecl::addReferencedProtocols(ObjCProtocolDecl **OID,
|
|
unsigned numRefProtos) {
|
|
assert(NumReferencedProtocols == 0 && "refproto already set!");
|
|
NumReferencedProtocols = numRefProtos;
|
|
if (numRefProtos) {
|
|
ReferencedProtocols = new ObjCProtocolDecl*[numRefProtos];
|
|
memcpy(ReferencedProtocols, OID, numRefProtos*sizeof(ObjCProtocolDecl*));
|
|
}
|
|
}
|
|
|
|
/// ObjCAddInstanceVariablesToClass - Inserts instance variables
|
|
/// into ObjCInterfaceDecl's fields.
|
|
///
|
|
void ObjCInterfaceDecl::addInstanceVariablesToClass(ObjCIvarDecl **ivars,
|
|
unsigned numIvars,
|
|
SourceLocation RBrac) {
|
|
NumIvars = numIvars;
|
|
if (numIvars) {
|
|
Ivars = new ObjCIvarDecl*[numIvars];
|
|
memcpy(Ivars, ivars, numIvars*sizeof(ObjCIvarDecl*));
|
|
}
|
|
setLocEnd(RBrac);
|
|
}
|
|
|
|
/// ObjCAddInstanceVariablesToClassImpl - Checks for correctness of Instance
|
|
/// Variables (Ivars) relative to what declared in @implementation;s class.
|
|
/// Ivars into ObjCImplementationDecl's fields.
|
|
///
|
|
void ObjCImplementationDecl::ObjCAddInstanceVariablesToClassImpl(
|
|
ObjCIvarDecl **ivars, unsigned numIvars) {
|
|
NumIvars = numIvars;
|
|
if (numIvars) {
|
|
Ivars = new ObjCIvarDecl*[numIvars];
|
|
memcpy(Ivars, ivars, numIvars*sizeof(ObjCIvarDecl*));
|
|
}
|
|
}
|
|
|
|
/// addMethods - Insert instance and methods declarations into
|
|
/// ObjCInterfaceDecl's InsMethods and ClsMethods fields.
|
|
///
|
|
void ObjCInterfaceDecl::addMethods(ObjCMethodDecl **insMethods,
|
|
unsigned numInsMembers,
|
|
ObjCMethodDecl **clsMethods,
|
|
unsigned numClsMembers,
|
|
SourceLocation endLoc) {
|
|
NumInstanceMethods = numInsMembers;
|
|
if (numInsMembers) {
|
|
InstanceMethods = new ObjCMethodDecl*[numInsMembers];
|
|
memcpy(InstanceMethods, insMethods, numInsMembers*sizeof(ObjCMethodDecl*));
|
|
}
|
|
NumClassMethods = numClsMembers;
|
|
if (numClsMembers) {
|
|
ClassMethods = new ObjCMethodDecl*[numClsMembers];
|
|
memcpy(ClassMethods, clsMethods, numClsMembers*sizeof(ObjCMethodDecl*));
|
|
}
|
|
AtEndLoc = endLoc;
|
|
}
|
|
|
|
/// addProperties - Insert property declaration AST nodes into
|
|
/// ObjCInterfaceDecl's PropertyDecl field.
|
|
///
|
|
void ObjCInterfaceDecl::addProperties(ObjCPropertyDecl **Properties,
|
|
unsigned NumProperties) {
|
|
if (NumProperties == 0) return;
|
|
|
|
NumPropertyDecl = NumProperties;
|
|
PropertyDecl = new ObjCPropertyDecl*[NumProperties];
|
|
memcpy(PropertyDecl, Properties, NumProperties*sizeof(ObjCPropertyDecl*));
|
|
}
|
|
|
|
/// mergeProperties - Adds properties to the end of list of current properties
|
|
/// for this class.
|
|
|
|
void ObjCInterfaceDecl::mergeProperties(ObjCPropertyDecl **Properties,
|
|
unsigned NumNewProperties) {
|
|
if (NumNewProperties == 0) return;
|
|
|
|
if (PropertyDecl) {
|
|
ObjCPropertyDecl **newPropertyDecl =
|
|
new ObjCPropertyDecl*[NumNewProperties + NumPropertyDecl];
|
|
ObjCPropertyDecl **buf = newPropertyDecl;
|
|
// put back original properties in buffer.
|
|
memcpy(buf, PropertyDecl, NumPropertyDecl*sizeof(ObjCPropertyDecl*));
|
|
// Add new properties to this buffer.
|
|
memcpy(buf+NumPropertyDecl, Properties,
|
|
NumNewProperties*sizeof(ObjCPropertyDecl*));
|
|
delete[] PropertyDecl;
|
|
PropertyDecl = newPropertyDecl;
|
|
NumPropertyDecl += NumNewProperties;
|
|
}
|
|
else {
|
|
addProperties(Properties, NumNewProperties);
|
|
}
|
|
}
|
|
|
|
/// addPropertyMethods - Goes through list of properties declared in this class
|
|
/// and builds setter/getter method declartions depending on the setter/getter
|
|
/// attributes of the property.
|
|
///
|
|
void ObjCInterfaceDecl::addPropertyMethods(
|
|
ASTContext &Context,
|
|
ObjCPropertyDecl *property,
|
|
llvm::SmallVector<ObjCMethodDecl*, 32> &insMethods) {
|
|
// Find the default getter and if one not found, add one.
|
|
ObjCMethodDecl *GetterDecl = getInstanceMethod(property->getGetterName());
|
|
if (GetterDecl) {
|
|
// An instance method with same name as property getter name found.
|
|
property->setGetterMethodDecl(GetterDecl);
|
|
}
|
|
else {
|
|
// No instance method of same name as property getter name was found.
|
|
// Declare a getter method and add it to the list of methods
|
|
// for this class.
|
|
QualType resultDeclType = property->getType();
|
|
ObjCMethodDecl* ObjCMethod =
|
|
ObjCMethodDecl::Create(Context, property->getLocation(),
|
|
property->getLocation(),
|
|
property->getGetterName(), resultDeclType,
|
|
this, 0,
|
|
true, false, true, ObjCMethodDecl::Required);
|
|
property->setGetterMethodDecl(ObjCMethod);
|
|
insMethods.push_back(ObjCMethod);
|
|
}
|
|
}
|
|
|
|
/// addProperties - Insert property declaration AST nodes into
|
|
/// ObjCProtocolDecl's PropertyDecl field.
|
|
///
|
|
void ObjCProtocolDecl::addProperties(ObjCPropertyDecl **Properties,
|
|
unsigned NumProperties) {
|
|
if (NumProperties == 0) return;
|
|
|
|
NumPropertyDecl = NumProperties;
|
|
PropertyDecl = new ObjCPropertyDecl*[NumProperties];
|
|
memcpy(PropertyDecl, Properties, NumProperties*sizeof(ObjCPropertyDecl*));
|
|
}
|
|
|
|
/// addProperties - Insert property declaration AST nodes into
|
|
/// ObjCCategoryDecl's PropertyDecl field.
|
|
///
|
|
void ObjCCategoryDecl::addProperties(ObjCPropertyDecl **Properties,
|
|
unsigned NumProperties) {
|
|
if (NumProperties == 0) return;
|
|
|
|
NumPropertyDecl = NumProperties;
|
|
PropertyDecl = new ObjCPropertyDecl*[NumProperties];
|
|
memcpy(PropertyDecl, Properties, NumProperties*sizeof(ObjCPropertyDecl*));
|
|
}
|
|
|
|
/// addMethods - Insert instance and methods declarations into
|
|
/// ObjCProtocolDecl's ProtoInsMethods and ProtoClsMethods fields.
|
|
///
|
|
void ObjCProtocolDecl::addMethods(ObjCMethodDecl **insMethods,
|
|
unsigned numInsMembers,
|
|
ObjCMethodDecl **clsMethods,
|
|
unsigned numClsMembers,
|
|
SourceLocation endLoc) {
|
|
NumInstanceMethods = numInsMembers;
|
|
if (numInsMembers) {
|
|
InstanceMethods = new ObjCMethodDecl*[numInsMembers];
|
|
memcpy(InstanceMethods, insMethods, numInsMembers*sizeof(ObjCMethodDecl*));
|
|
}
|
|
NumClassMethods = numClsMembers;
|
|
if (numClsMembers) {
|
|
ClassMethods = new ObjCMethodDecl*[numClsMembers];
|
|
memcpy(ClassMethods, clsMethods, numClsMembers*sizeof(ObjCMethodDecl*));
|
|
}
|
|
AtEndLoc = endLoc;
|
|
}
|
|
|
|
void ObjCCategoryDecl::setReferencedProtocolList(ObjCProtocolDecl **List,
|
|
unsigned NumRPs) {
|
|
assert(NumReferencedProtocols == 0 && "Protocol list already set");
|
|
if (NumRPs == 0) return;
|
|
|
|
ReferencedProtocols = new ObjCProtocolDecl*[NumRPs];
|
|
memcpy(ReferencedProtocols, List, NumRPs*sizeof(ObjCProtocolDecl*));
|
|
NumReferencedProtocols = NumRPs;
|
|
}
|
|
|
|
|
|
/// addMethods - Insert instance and methods declarations into
|
|
/// ObjCCategoryDecl's CatInsMethods and CatClsMethods fields.
|
|
///
|
|
void ObjCCategoryDecl::addMethods(ObjCMethodDecl **insMethods,
|
|
unsigned numInsMembers,
|
|
ObjCMethodDecl **clsMethods,
|
|
unsigned numClsMembers,
|
|
SourceLocation endLoc) {
|
|
NumInstanceMethods = numInsMembers;
|
|
if (numInsMembers) {
|
|
InstanceMethods = new ObjCMethodDecl*[numInsMembers];
|
|
memcpy(InstanceMethods, insMethods, numInsMembers*sizeof(ObjCMethodDecl*));
|
|
}
|
|
NumClassMethods = numClsMembers;
|
|
if (numClsMembers) {
|
|
ClassMethods = new ObjCMethodDecl*[numClsMembers];
|
|
memcpy(ClassMethods, clsMethods, numClsMembers*sizeof(ObjCMethodDecl*));
|
|
}
|
|
AtEndLoc = endLoc;
|
|
}
|
|
|
|
/// FindPropertyDeclaration - Finds declaration of the property given its name
|
|
/// in 'PropertyId' and returns it. It returns 0, if not found.
|
|
///
|
|
ObjCPropertyDecl *
|
|
ObjCCategoryDecl::FindPropertyDeclaration(IdentifierInfo *PropertyId) const {
|
|
for (ObjCCategoryDecl::classprop_iterator I = classprop_begin(),
|
|
E = classprop_end(); I != E; ++I) {
|
|
ObjCPropertyDecl *property = *I;
|
|
if (property->getIdentifier() == PropertyId)
|
|
return property;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/// FindPropertyDeclaration - Finds declaration of the property given its name
|
|
/// in 'PropertyId' and returns it. It returns 0, if not found.
|
|
///
|
|
ObjCPropertyDecl *
|
|
ObjCProtocolDecl::FindPropertyDeclaration(IdentifierInfo *PropertyId) const {
|
|
for (ObjCProtocolDecl::classprop_iterator I = classprop_begin(),
|
|
E = classprop_end(); I != E; ++I) {
|
|
ObjCPropertyDecl *property = *I;
|
|
if (property->getIdentifier() == PropertyId)
|
|
return property;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
ObjCIvarDecl *ObjCInterfaceDecl::lookupInstanceVariable(
|
|
IdentifierInfo *ID, ObjCInterfaceDecl *&clsDeclared) {
|
|
ObjCInterfaceDecl* ClassDecl = this;
|
|
while (ClassDecl != NULL) {
|
|
for (ivar_iterator I = ClassDecl->ivar_begin(), E = ClassDecl->ivar_end();
|
|
I != E; ++I) {
|
|
if ((*I)->getIdentifier() == ID) {
|
|
clsDeclared = ClassDecl;
|
|
return *I;
|
|
}
|
|
}
|
|
ClassDecl = ClassDecl->getSuperClass();
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/// lookupInstanceMethod - This method returns an instance method by looking in
|
|
/// the class, its categories, and its super classes (using a linear search).
|
|
ObjCMethodDecl *ObjCInterfaceDecl::lookupInstanceMethod(Selector Sel) {
|
|
ObjCInterfaceDecl* ClassDecl = this;
|
|
ObjCMethodDecl *MethodDecl = 0;
|
|
|
|
while (ClassDecl != NULL) {
|
|
if ((MethodDecl = ClassDecl->getInstanceMethod(Sel)))
|
|
return MethodDecl;
|
|
|
|
// Didn't find one yet - look through protocols.
|
|
ObjCProtocolDecl **protocols = ClassDecl->getReferencedProtocols();
|
|
int numProtocols = ClassDecl->getNumIntfRefProtocols();
|
|
for (int pIdx = 0; pIdx < numProtocols; pIdx++) {
|
|
if ((MethodDecl = protocols[pIdx]->getInstanceMethod(Sel)))
|
|
return MethodDecl;
|
|
}
|
|
// Didn't find one yet - now look through categories.
|
|
ObjCCategoryDecl *CatDecl = ClassDecl->getCategoryList();
|
|
while (CatDecl) {
|
|
if ((MethodDecl = CatDecl->getInstanceMethod(Sel)))
|
|
return MethodDecl;
|
|
CatDecl = CatDecl->getNextClassCategory();
|
|
}
|
|
ClassDecl = ClassDecl->getSuperClass();
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
// lookupClassMethod - This method returns a class method by looking in the
|
|
// class, its categories, and its super classes (using a linear search).
|
|
ObjCMethodDecl *ObjCInterfaceDecl::lookupClassMethod(Selector Sel) {
|
|
ObjCInterfaceDecl* ClassDecl = this;
|
|
ObjCMethodDecl *MethodDecl = 0;
|
|
|
|
while (ClassDecl != NULL) {
|
|
if ((MethodDecl = ClassDecl->getClassMethod(Sel)))
|
|
return MethodDecl;
|
|
|
|
// Didn't find one yet - look through protocols.
|
|
ObjCProtocolDecl **protocols = ClassDecl->getReferencedProtocols();
|
|
int numProtocols = ClassDecl->getNumIntfRefProtocols();
|
|
for (int pIdx = 0; pIdx < numProtocols; pIdx++) {
|
|
if ((MethodDecl = protocols[pIdx]->getClassMethod(Sel)))
|
|
return MethodDecl;
|
|
}
|
|
// Didn't find one yet - now look through categories.
|
|
ObjCCategoryDecl *CatDecl = ClassDecl->getCategoryList();
|
|
while (CatDecl) {
|
|
if ((MethodDecl = CatDecl->getClassMethod(Sel)))
|
|
return MethodDecl;
|
|
CatDecl = CatDecl->getNextClassCategory();
|
|
}
|
|
ClassDecl = ClassDecl->getSuperClass();
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/// lookupInstanceMethod - This method returns an instance method by looking in
|
|
/// the class implementation. Unlike interfaces, we don't look outside the
|
|
/// implementation.
|
|
ObjCMethodDecl *ObjCImplementationDecl::getInstanceMethod(Selector Sel) {
|
|
for (instmeth_iterator I = instmeth_begin(), E = instmeth_end(); I != E; ++I)
|
|
if ((*I)->getSelector() == Sel)
|
|
return *I;
|
|
return NULL;
|
|
}
|
|
|
|
/// lookupClassMethod - This method returns a class method by looking in
|
|
/// the class implementation. Unlike interfaces, we don't look outside the
|
|
/// implementation.
|
|
ObjCMethodDecl *ObjCImplementationDecl::getClassMethod(Selector Sel) {
|
|
for (classmeth_iterator I = classmeth_begin(), E = classmeth_end();
|
|
I != E; ++I)
|
|
if ((*I)->getSelector() == Sel)
|
|
return *I;
|
|
return NULL;
|
|
}
|
|
|
|
// lookupInstanceMethod - This method returns an instance method by looking in
|
|
// the class implementation. Unlike interfaces, we don't look outside the
|
|
// implementation.
|
|
ObjCMethodDecl *ObjCCategoryImplDecl::getInstanceMethod(Selector Sel) {
|
|
for (instmeth_iterator I = instmeth_begin(), E = instmeth_end(); I != E; ++I)
|
|
if ((*I)->getSelector() == Sel)
|
|
return *I;
|
|
return NULL;
|
|
}
|
|
|
|
// lookupClassMethod - This method returns an instance method by looking in
|
|
// the class implementation. Unlike interfaces, we don't look outside the
|
|
// implementation.
|
|
ObjCMethodDecl *ObjCCategoryImplDecl::getClassMethod(Selector Sel) {
|
|
for (classmeth_iterator I = classmeth_begin(), E = classmeth_end();
|
|
I != E; ++I)
|
|
if ((*I)->getSelector() == Sel)
|
|
return *I;
|
|
return NULL;
|
|
}
|
|
|
|
// lookupInstanceMethod - Lookup a instance method in the protocol and protocols
|
|
// it inherited.
|
|
ObjCMethodDecl *ObjCProtocolDecl::lookupInstanceMethod(Selector Sel) {
|
|
ObjCMethodDecl *MethodDecl = NULL;
|
|
|
|
if ((MethodDecl = getInstanceMethod(Sel)))
|
|
return MethodDecl;
|
|
|
|
if (getNumReferencedProtocols() > 0) {
|
|
ObjCProtocolDecl **RefPDecl = getReferencedProtocols();
|
|
|
|
for (unsigned i = 0; i < getNumReferencedProtocols(); i++) {
|
|
if ((MethodDecl = RefPDecl[i]->getInstanceMethod(Sel)))
|
|
return MethodDecl;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
// lookupInstanceMethod - Lookup a class method in the protocol and protocols
|
|
// it inherited.
|
|
ObjCMethodDecl *ObjCProtocolDecl::lookupClassMethod(Selector Sel) {
|
|
ObjCMethodDecl *MethodDecl = NULL;
|
|
|
|
if ((MethodDecl = getClassMethod(Sel)))
|
|
return MethodDecl;
|
|
|
|
if (getNumReferencedProtocols() > 0) {
|
|
ObjCProtocolDecl **RefPDecl = getReferencedProtocols();
|
|
|
|
for(unsigned i = 0; i < getNumReferencedProtocols(); i++) {
|
|
if ((MethodDecl = RefPDecl[i]->getClassMethod(Sel)))
|
|
return MethodDecl;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/// getSynthesizedMethodSize - Compute size of synthesized method name
|
|
/// as done be the rewrite.
|
|
///
|
|
unsigned ObjCMethodDecl::getSynthesizedMethodSize() const {
|
|
// syntesized method name is a concatenation of -/+[class-name selector]
|
|
// Get length of this name.
|
|
unsigned length = 3; // _I_ or _C_
|
|
length += strlen(getClassInterface()->getName()) +1; // extra for _
|
|
NamedDecl *MethodContext = getMethodContext();
|
|
if (ObjCCategoryImplDecl *CID =
|
|
dyn_cast<ObjCCategoryImplDecl>(MethodContext))
|
|
length += strlen(CID->getName()) +1;
|
|
length += getSelector().getName().size(); // selector name
|
|
return length;
|
|
}
|
|
|
|
ObjCInterfaceDecl *ObjCMethodDecl::getClassInterface() {
|
|
if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(MethodContext))
|
|
return ID;
|
|
if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(MethodContext))
|
|
return CD->getClassInterface();
|
|
if (ObjCImplementationDecl *IMD =
|
|
dyn_cast<ObjCImplementationDecl>(MethodContext))
|
|
return IMD->getClassInterface();
|
|
if (ObjCCategoryImplDecl *CID = dyn_cast<ObjCCategoryImplDecl>(MethodContext))
|
|
return CID->getClassInterface();
|
|
assert(false && "unknown method context");
|
|
return 0;
|
|
}
|
|
|
|
ObjCPropertyImplDecl *ObjCPropertyImplDecl::Create(ASTContext &C,
|
|
SourceLocation atLoc,
|
|
SourceLocation L,
|
|
ObjCPropertyDecl *property,
|
|
PropertyImplKind kind,
|
|
ObjCIvarDecl *ivar) {
|
|
void *Mem = C.getAllocator().Allocate<ObjCPropertyImplDecl>();
|
|
return new (Mem) ObjCPropertyImplDecl(atLoc, L, property, kind, ivar);
|
|
}
|
|
|
|
|