Substituted all instances of the string "Objc" for "ObjC". This fixes
some naming inconsistencies in the names of classes pertaining to Objective-C
support in clang.
git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@45715 91177308-0d34-0410-b5e6-96231b3b80d8
diff --git a/AST/ASTContext.cpp b/AST/ASTContext.cpp
index 85ccfd7..a9a3d57 100644
--- a/AST/ASTContext.cpp
+++ b/AST/ASTContext.cpp
@@ -48,8 +48,8 @@
unsigned NumFunctionNP = 0, NumTypeName = 0, NumTagged = 0, NumReference = 0;
unsigned NumTagStruct = 0, NumTagUnion = 0, NumTagEnum = 0, NumTagClass = 0;
- unsigned NumObjcInterfaces = 0, NumObjcQualifiedInterfaces = 0;
- unsigned NumObjcQualifiedIds = 0;
+ unsigned NumObjCInterfaces = 0, NumObjCQualifiedInterfaces = 0;
+ unsigned NumObjCQualifiedIds = 0;
for (unsigned i = 0, e = Types.size(); i != e; ++i) {
Type *T = Types[i];
@@ -80,12 +80,12 @@
case Decl::Class: ++NumTagClass; break;
case Decl::Enum: ++NumTagEnum; break;
}
- } else if (isa<ObjcInterfaceType>(T))
- ++NumObjcInterfaces;
- else if (isa<ObjcQualifiedInterfaceType>(T))
- ++NumObjcQualifiedInterfaces;
- else if (isa<ObjcQualifiedIdType>(T))
- ++NumObjcQualifiedIds;
+ } else if (isa<ObjCInterfaceType>(T))
+ ++NumObjCInterfaces;
+ else if (isa<ObjCQualifiedInterfaceType>(T))
+ ++NumObjCQualifiedInterfaces;
+ else if (isa<ObjCQualifiedIdType>(T))
+ ++NumObjCQualifiedIds;
else {
QualType(T, 0).dump();
assert(0 && "Unknown type!");
@@ -106,11 +106,11 @@
fprintf(stderr, " %d union types\n", NumTagUnion);
fprintf(stderr, " %d class types\n", NumTagClass);
fprintf(stderr, " %d enum types\n", NumTagEnum);
- fprintf(stderr, " %d interface types\n", NumObjcInterfaces);
+ fprintf(stderr, " %d interface types\n", NumObjCInterfaces);
fprintf(stderr, " %d protocol qualified interface types\n",
- NumObjcQualifiedInterfaces);
+ NumObjCQualifiedInterfaces);
fprintf(stderr, " %d protocol qualified id types\n",
- NumObjcQualifiedIds);
+ NumObjCQualifiedIds);
fprintf(stderr, "Total bytes = %d\n", int(NumBuiltin*sizeof(BuiltinType)+
NumPointer*sizeof(PointerType)+NumArray*sizeof(ArrayType)+
NumComplex*sizeof(ComplexType)+NumVector*sizeof(VectorType)+
@@ -162,12 +162,12 @@
LongDoubleComplexTy = getComplexType(LongDoubleTy);
BuiltinVaListType = QualType();
- ObjcIdType = QualType();
+ ObjCIdType = QualType();
IdStructType = 0;
- ObjcClassType = QualType();
+ ObjCClassType = QualType();
ClassStructType = 0;
- ObjcConstantStringType = QualType();
+ ObjCConstantStringType = QualType();
// void * type
VoidPtrTy = getPointerType(VoidTy);
@@ -256,7 +256,7 @@
}
break;
}
- case Type::ObjcQualifiedId:
+ case Type::ObjCQualifiedId:
Target.getPointerInfo(Size, Align, getFullLoc(L));
break;
case Type::Pointer:
@@ -691,65 +691,65 @@
return QualType(Decl->TypeForDecl, 0);
}
-/// getObjcInterfaceType - Return the unique reference to the type for the
+/// getObjCInterfaceType - Return the unique reference to the type for the
/// specified ObjC interface decl.
-QualType ASTContext::getObjcInterfaceType(ObjcInterfaceDecl *Decl) {
+QualType ASTContext::getObjCInterfaceType(ObjCInterfaceDecl *Decl) {
if (Decl->TypeForDecl) return QualType(Decl->TypeForDecl, 0);
- Decl->TypeForDecl = new ObjcInterfaceType(Type::ObjcInterface, Decl);
+ Decl->TypeForDecl = new ObjCInterfaceType(Type::ObjCInterface, Decl);
Types.push_back(Decl->TypeForDecl);
return QualType(Decl->TypeForDecl, 0);
}
-/// getObjcQualifiedInterfaceType - Return a
-/// ObjcQualifiedInterfaceType type for the given interface decl and
+/// getObjCQualifiedInterfaceType - Return a
+/// ObjCQualifiedInterfaceType type for the given interface decl and
/// the conforming protocol list.
-QualType ASTContext::getObjcQualifiedInterfaceType(ObjcInterfaceDecl *Decl,
- ObjcProtocolDecl **Protocols, unsigned NumProtocols) {
+QualType ASTContext::getObjCQualifiedInterfaceType(ObjCInterfaceDecl *Decl,
+ ObjCProtocolDecl **Protocols, unsigned NumProtocols) {
llvm::FoldingSetNodeID ID;
- ObjcQualifiedInterfaceType::Profile(ID, Protocols, NumProtocols);
+ ObjCQualifiedInterfaceType::Profile(ID, Protocols, NumProtocols);
void *InsertPos = 0;
- if (ObjcQualifiedInterfaceType *QT =
- ObjcQualifiedInterfaceTypes.FindNodeOrInsertPos(ID, InsertPos))
+ if (ObjCQualifiedInterfaceType *QT =
+ ObjCQualifiedInterfaceTypes.FindNodeOrInsertPos(ID, InsertPos))
return QualType(QT, 0);
// No Match;
- ObjcQualifiedInterfaceType *QType =
- new ObjcQualifiedInterfaceType(Decl, Protocols, NumProtocols);
+ ObjCQualifiedInterfaceType *QType =
+ new ObjCQualifiedInterfaceType(Decl, Protocols, NumProtocols);
Types.push_back(QType);
- ObjcQualifiedInterfaceTypes.InsertNode(QType, InsertPos);
+ ObjCQualifiedInterfaceTypes.InsertNode(QType, InsertPos);
return QualType(QType, 0);
}
-/// getObjcQualifiedIdType - Return a
-/// getObjcQualifiedIdType type for the 'id' decl and
+/// getObjCQualifiedIdType - Return a
+/// getObjCQualifiedIdType type for the 'id' decl and
/// the conforming protocol list.
-QualType ASTContext::getObjcQualifiedIdType(QualType idType,
- ObjcProtocolDecl **Protocols,
+QualType ASTContext::getObjCQualifiedIdType(QualType idType,
+ ObjCProtocolDecl **Protocols,
unsigned NumProtocols) {
llvm::FoldingSetNodeID ID;
- ObjcQualifiedIdType::Profile(ID, Protocols, NumProtocols);
+ ObjCQualifiedIdType::Profile(ID, Protocols, NumProtocols);
void *InsertPos = 0;
- if (ObjcQualifiedIdType *QT =
- ObjcQualifiedIdTypes.FindNodeOrInsertPos(ID, InsertPos))
+ if (ObjCQualifiedIdType *QT =
+ ObjCQualifiedIdTypes.FindNodeOrInsertPos(ID, InsertPos))
return QualType(QT, 0);
// No Match;
QualType Canonical;
if (!idType->isCanonical()) {
- Canonical = getObjcQualifiedIdType(idType.getCanonicalType(),
+ Canonical = getObjCQualifiedIdType(idType.getCanonicalType(),
Protocols, NumProtocols);
- ObjcQualifiedIdType *NewQT =
- ObjcQualifiedIdTypes.FindNodeOrInsertPos(ID, InsertPos);
+ ObjCQualifiedIdType *NewQT =
+ ObjCQualifiedIdTypes.FindNodeOrInsertPos(ID, InsertPos);
assert(NewQT == 0 && "Shouldn't be in the map!");
}
- ObjcQualifiedIdType *QType =
- new ObjcQualifiedIdType(Canonical, Protocols, NumProtocols);
+ ObjCQualifiedIdType *QType =
+ new ObjCQualifiedIdType(Canonical, Protocols, NumProtocols);
Types.push_back(QType);
- ObjcQualifiedIdTypes.InsertNode(QType, InsertPos);
+ ObjCQualifiedIdTypes.InsertNode(QType, InsertPos);
return QualType(QType, 0);
}
@@ -961,9 +961,9 @@
return false;
}
-/// getObjcEncodingTypeSize returns size of type for objective-c encoding
+/// getObjCEncodingTypeSize returns size of type for objective-c encoding
/// purpose.
-int ASTContext::getObjcEncodingTypeSize(QualType type) {
+int ASTContext::getObjCEncodingTypeSize(QualType type) {
SourceLocation Loc;
uint64_t sz = getTypeSize(type, Loc);
@@ -976,15 +976,15 @@
return sz / getTypeSize(CharTy, Loc);
}
-/// getObjcEncodingForMethodDecl - Return the encoded type for this method
+/// getObjCEncodingForMethodDecl - Return the encoded type for this method
/// declaration.
-void ASTContext::getObjcEncodingForMethodDecl(ObjcMethodDecl *Decl,
+void ASTContext::getObjCEncodingForMethodDecl(ObjCMethodDecl *Decl,
std::string& S)
{
// Encode type qualifer, 'in', 'inout', etc. for the return type.
- getObjcEncodingForTypeQualifier(Decl->getObjcDeclQualifier(), S);
+ getObjCEncodingForTypeQualifier(Decl->getObjCDeclQualifier(), S);
// Encode result type.
- getObjcEncodingForType(Decl->getResultType(), S);
+ getObjCEncodingForType(Decl->getResultType(), S);
// Compute size of all parameters.
// Start with computing size of a pointer in number of bytes.
// FIXME: There might(should) be a better way of doing this computation!
@@ -996,8 +996,8 @@
int NumOfParams = Decl->getNumParams();
for (int i = 0; i < NumOfParams; i++) {
QualType PType = Decl->getParamDecl(i)->getType();
- int sz = getObjcEncodingTypeSize (PType);
- assert (sz > 0 && "getObjcEncodingForMethodDecl - Incomplete param type");
+ int sz = getObjCEncodingTypeSize (PType);
+ assert (sz > 0 && "getObjCEncodingForMethodDecl - Incomplete param type");
ParmOffset += sz;
}
S += llvm::utostr(ParmOffset);
@@ -1010,15 +1010,15 @@
QualType PType = Decl->getParamDecl(i)->getType();
// Process argument qualifiers for user supplied arguments; such as,
// 'in', 'inout', etc.
- getObjcEncodingForTypeQualifier(
- Decl->getParamDecl(i)->getObjcDeclQualifier(), S);
- getObjcEncodingForType(PType, S);
+ getObjCEncodingForTypeQualifier(
+ Decl->getParamDecl(i)->getObjCDeclQualifier(), S);
+ getObjCEncodingForType(PType, S);
S += llvm::utostr(ParmOffset);
- ParmOffset += getObjcEncodingTypeSize(PType);
+ ParmOffset += getObjCEncodingTypeSize(PType);
}
}
-void ASTContext::getObjcEncodingForType(QualType T, std::string& S) const
+void ASTContext::getObjCEncodingForType(QualType T, std::string& S) const
{
// FIXME: This currently doesn't encode:
// @ An object (whether statically typed or typed id)
@@ -1084,20 +1084,20 @@
S += encoding;
}
- else if (T->isObjcQualifiedIdType()) {
+ else if (T->isObjCQualifiedIdType()) {
// Treat id<P...> same as 'id' for encoding purposes.
- return getObjcEncodingForType(getObjcIdType(), S);
+ return getObjCEncodingForType(getObjCIdType(), S);
}
else if (const PointerType *PT = T->getAsPointerType()) {
QualType PointeeTy = PT->getPointeeType();
- if (isObjcIdType(PointeeTy) || PointeeTy->isObjcInterfaceType()) {
+ if (isObjCIdType(PointeeTy) || PointeeTy->isObjCInterfaceType()) {
S += '@';
return;
- } else if (isObjcClassType(PointeeTy)) {
+ } else if (isObjCClassType(PointeeTy)) {
S += '#';
return;
- } else if (isObjcSelType(PointeeTy)) {
+ } else if (isObjCSelType(PointeeTy)) {
S += ':';
return;
}
@@ -1112,7 +1112,7 @@
}
S += '^';
- getObjcEncodingForType(PT->getPointeeType(), S);
+ getObjCEncodingForType(PT->getPointeeType(), S);
} else if (const ArrayType *AT = T->getAsArrayType()) {
S += '[';
@@ -1121,7 +1121,7 @@
else
assert(0 && "Unhandled array type!");
- getObjcEncodingForType(AT->getElementType(), S);
+ getObjCEncodingForType(AT->getElementType(), S);
S += ']';
} else if (T->getAsFunctionType()) {
S += '?';
@@ -1132,7 +1132,7 @@
S += '=';
for (int i = 0; i < RDecl->getNumMembers(); i++) {
FieldDecl *field = RDecl->getMember(i);
- getObjcEncodingForType(field->getType(), S);
+ getObjCEncodingForType(field->getType(), S);
}
S += '}';
} else if (T->isEnumeralType()) {
@@ -1141,7 +1141,7 @@
assert(0 && "@encode for type not implemented!");
}
-void ASTContext::getObjcEncodingForTypeQualifier(Decl::ObjcDeclQualifier QT,
+void ASTContext::getObjCEncodingForTypeQualifier(Decl::ObjCDeclQualifier QT,
std::string& S) const {
if (QT & Decl::OBJC_TQ_In)
S += 'n';
@@ -1164,11 +1164,11 @@
BuiltinVaListType = T;
}
-void ASTContext::setObjcIdType(TypedefDecl *TD)
+void ASTContext::setObjCIdType(TypedefDecl *TD)
{
- assert(ObjcIdType.isNull() && "'id' type already set!");
+ assert(ObjCIdType.isNull() && "'id' type already set!");
- ObjcIdType = getTypedefType(TD);
+ ObjCIdType = getTypedefType(TD);
// typedef struct objc_object *id;
const PointerType *ptr = TD->getUnderlyingType()->getAsPointerType();
@@ -1178,11 +1178,11 @@
IdStructType = rec;
}
-void ASTContext::setObjcSelType(TypedefDecl *TD)
+void ASTContext::setObjCSelType(TypedefDecl *TD)
{
- assert(ObjcSelType.isNull() && "'SEL' type already set!");
+ assert(ObjCSelType.isNull() && "'SEL' type already set!");
- ObjcSelType = getTypedefType(TD);
+ ObjCSelType = getTypedefType(TD);
// typedef struct objc_selector *SEL;
const PointerType *ptr = TD->getUnderlyingType()->getAsPointerType();
@@ -1192,17 +1192,17 @@
SelStructType = rec;
}
-void ASTContext::setObjcProtoType(QualType QT)
+void ASTContext::setObjCProtoType(QualType QT)
{
- assert(ObjcProtoType.isNull() && "'Protocol' type already set!");
- ObjcProtoType = QT;
+ assert(ObjCProtoType.isNull() && "'Protocol' type already set!");
+ ObjCProtoType = QT;
}
-void ASTContext::setObjcClassType(TypedefDecl *TD)
+void ASTContext::setObjCClassType(TypedefDecl *TD)
{
- assert(ObjcClassType.isNull() && "'Class' type already set!");
+ assert(ObjCClassType.isNull() && "'Class' type already set!");
- ObjcClassType = getTypedefType(TD);
+ ObjCClassType = getTypedefType(TD);
// typedef struct objc_class *Class;
const PointerType *ptr = TD->getUnderlyingType()->getAsPointerType();
@@ -1212,11 +1212,11 @@
ClassStructType = rec;
}
-void ASTContext::setObjcConstantStringInterface(ObjcInterfaceDecl *Decl) {
- assert(ObjcConstantStringType.isNull() &&
+void ASTContext::setObjCConstantStringInterface(ObjCInterfaceDecl *Decl) {
+ assert(ObjCConstantStringType.isNull() &&
"'NSConstantString' type already set!");
- ObjcConstantStringType = getObjcInterfaceType(Decl);
+ ObjCConstantStringType = getObjCInterfaceType(Decl);
}
bool ASTContext::builtinTypesAreCompatible(QualType lhs, QualType rhs) {
@@ -1231,20 +1231,20 @@
/// a qualified interface type and the other type is of a different class.
/// Example, II or II<P>.
bool ASTContext::objcTypesAreCompatible(QualType lhs, QualType rhs) {
- if (lhs->isObjcInterfaceType() && isObjcIdType(rhs))
+ if (lhs->isObjCInterfaceType() && isObjCIdType(rhs))
return true;
- else if (isObjcIdType(lhs) && rhs->isObjcInterfaceType())
+ else if (isObjCIdType(lhs) && rhs->isObjCInterfaceType())
return true;
- if (ObjcInterfaceType *lhsIT =
- dyn_cast<ObjcInterfaceType>(lhs.getCanonicalType().getTypePtr())) {
- ObjcQualifiedInterfaceType *rhsQI =
- dyn_cast<ObjcQualifiedInterfaceType>(rhs.getCanonicalType().getTypePtr());
+ if (ObjCInterfaceType *lhsIT =
+ dyn_cast<ObjCInterfaceType>(lhs.getCanonicalType().getTypePtr())) {
+ ObjCQualifiedInterfaceType *rhsQI =
+ dyn_cast<ObjCQualifiedInterfaceType>(rhs.getCanonicalType().getTypePtr());
return rhsQI && (lhsIT->getDecl() == rhsQI->getDecl());
}
- else if (ObjcInterfaceType *rhsIT =
- dyn_cast<ObjcInterfaceType>(rhs.getCanonicalType().getTypePtr())) {
- ObjcQualifiedInterfaceType *lhsQI =
- dyn_cast<ObjcQualifiedInterfaceType>(lhs.getCanonicalType().getTypePtr());
+ else if (ObjCInterfaceType *rhsIT =
+ dyn_cast<ObjCInterfaceType>(rhs.getCanonicalType().getTypePtr())) {
+ ObjCQualifiedInterfaceType *lhsQI =
+ dyn_cast<ObjCQualifiedInterfaceType>(lhs.getCanonicalType().getTypePtr());
return lhsQI && (rhsIT->getDecl() == lhsQI->getDecl());
}
return false;
@@ -1253,10 +1253,10 @@
bool ASTContext::interfaceTypesAreCompatible(QualType lhs, QualType rhs) {
if (lhs == rhs)
return true;
- ObjcInterfaceType *lhsIT = cast<ObjcInterfaceType>(lhs.getTypePtr());
- ObjcInterfaceType *rhsIT = cast<ObjcInterfaceType>(rhs.getTypePtr());
- ObjcInterfaceDecl *rhsIDecl = rhsIT->getDecl();
- ObjcInterfaceDecl *lhsIDecl = lhsIT->getDecl();
+ ObjCInterfaceType *lhsIT = cast<ObjCInterfaceType>(lhs.getTypePtr());
+ ObjCInterfaceType *rhsIT = cast<ObjCInterfaceType>(rhs.getTypePtr());
+ ObjCInterfaceDecl *rhsIDecl = rhsIT->getDecl();
+ ObjCInterfaceDecl *lhsIDecl = lhsIT->getDecl();
// rhs is derived from lhs it is OK; else it is not OK.
while (rhsIDecl != NULL) {
if (rhsIDecl == lhsIDecl)
@@ -1268,21 +1268,21 @@
bool ASTContext::QualifiedInterfaceTypesAreCompatible(QualType lhs,
QualType rhs) {
- ObjcQualifiedInterfaceType *lhsQI =
- dyn_cast<ObjcQualifiedInterfaceType>(lhs.getCanonicalType().getTypePtr());
+ ObjCQualifiedInterfaceType *lhsQI =
+ dyn_cast<ObjCQualifiedInterfaceType>(lhs.getCanonicalType().getTypePtr());
assert(lhsQI && "QualifiedInterfaceTypesAreCompatible - bad lhs type");
- ObjcQualifiedInterfaceType *rhsQI =
- dyn_cast<ObjcQualifiedInterfaceType>(rhs.getCanonicalType().getTypePtr());
+ ObjCQualifiedInterfaceType *rhsQI =
+ dyn_cast<ObjCQualifiedInterfaceType>(rhs.getCanonicalType().getTypePtr());
assert(rhsQI && "QualifiedInterfaceTypesAreCompatible - bad rhs type");
- if (!interfaceTypesAreCompatible(getObjcInterfaceType(lhsQI->getDecl()),
- getObjcInterfaceType(rhsQI->getDecl())))
+ if (!interfaceTypesAreCompatible(getObjCInterfaceType(lhsQI->getDecl()),
+ getObjCInterfaceType(rhsQI->getDecl())))
return false;
/* All protocols in lhs must have a presense in rhs. */
for (unsigned i =0; i < lhsQI->getNumProtocols(); i++) {
bool match = false;
- ObjcProtocolDecl *lhsProto = lhsQI->getProtocols(i);
+ ObjCProtocolDecl *lhsProto = lhsQI->getProtocols(i);
for (unsigned j = 0; j < rhsQI->getNumProtocols(); j++) {
- ObjcProtocolDecl *rhsProto = rhsQI->getProtocols(j);
+ ObjCProtocolDecl *rhsProto = rhsQI->getProtocols(j);
if (lhsProto == rhsProto) {
match = true;
break;
@@ -1296,11 +1296,11 @@
/// ProtocolCompatibleWithProtocol - return 'true' if 'lProto' is in the
/// inheritance hierarchy of 'rProto'.
-static bool ProtocolCompatibleWithProtocol(ObjcProtocolDecl *lProto,
- ObjcProtocolDecl *rProto) {
+static bool ProtocolCompatibleWithProtocol(ObjCProtocolDecl *lProto,
+ ObjCProtocolDecl *rProto) {
if (lProto == rProto)
return true;
- ObjcProtocolDecl** RefPDecl = rProto->getReferencedProtocols();
+ ObjCProtocolDecl** RefPDecl = rProto->getReferencedProtocols();
for (unsigned i = 0; i < rProto->getNumReferencedProtocols(); i++)
if (ProtocolCompatibleWithProtocol(lProto, RefPDecl[i]))
return true;
@@ -1310,12 +1310,12 @@
/// ClassImplementsProtocol - Checks that 'lProto' protocol
/// has been implemented in IDecl class, its super class or categories (if
/// lookupCategory is true).
-static bool ClassImplementsProtocol(ObjcProtocolDecl *lProto,
- ObjcInterfaceDecl *IDecl,
+static bool ClassImplementsProtocol(ObjCProtocolDecl *lProto,
+ ObjCInterfaceDecl *IDecl,
bool lookupCategory) {
// 1st, look up the class.
- ObjcProtocolDecl **protoList = IDecl->getReferencedProtocols();
+ ObjCProtocolDecl **protoList = IDecl->getReferencedProtocols();
for (unsigned i = 0; i < IDecl->getNumIntfRefProtocols(); i++) {
if (ProtocolCompatibleWithProtocol(lProto, protoList[i]))
return true;
@@ -1323,7 +1323,7 @@
// 2nd, look up the category.
if (lookupCategory)
- for (ObjcCategoryDecl *CDecl = IDecl->getCategoryList(); CDecl;
+ for (ObjCCategoryDecl *CDecl = IDecl->getCategoryList(); CDecl;
CDecl = CDecl->getNextClassCategory()) {
protoList = CDecl->getReferencedProtocols();
for (unsigned i = 0; i < CDecl->getNumReferencedProtocols(); i++) {
@@ -1340,42 +1340,42 @@
return false;
}
-/// ObjcQualifiedIdTypesAreCompatible - Compares two types, at least
+/// ObjCQualifiedIdTypesAreCompatible - Compares two types, at least
/// one of which is a protocol qualified 'id' type. When 'compare'
/// is true it is for comparison; when false, for assignment/initialization.
-bool ASTContext::ObjcQualifiedIdTypesAreCompatible(QualType lhs,
+bool ASTContext::ObjCQualifiedIdTypesAreCompatible(QualType lhs,
QualType rhs,
bool compare) {
// match id<P..> with an 'id' type in all cases.
if (const PointerType *PT = lhs->getAsPointerType()) {
QualType PointeeTy = PT->getPointeeType();
- if (isObjcIdType(PointeeTy) || PointeeTy->isVoidType())
+ if (isObjCIdType(PointeeTy) || PointeeTy->isVoidType())
return true;
}
else if (const PointerType *PT = rhs->getAsPointerType()) {
QualType PointeeTy = PT->getPointeeType();
- if (isObjcIdType(PointeeTy) || PointeeTy->isVoidType())
+ if (isObjCIdType(PointeeTy) || PointeeTy->isVoidType())
return true;
}
- ObjcQualifiedInterfaceType *lhsQI = 0;
- ObjcQualifiedInterfaceType *rhsQI = 0;
- ObjcInterfaceDecl *lhsID = 0;
- ObjcInterfaceDecl *rhsID = 0;
- ObjcQualifiedIdType *lhsQID = dyn_cast<ObjcQualifiedIdType>(lhs);
- ObjcQualifiedIdType *rhsQID = dyn_cast<ObjcQualifiedIdType>(rhs);
+ ObjCQualifiedInterfaceType *lhsQI = 0;
+ ObjCQualifiedInterfaceType *rhsQI = 0;
+ ObjCInterfaceDecl *lhsID = 0;
+ ObjCInterfaceDecl *rhsID = 0;
+ ObjCQualifiedIdType *lhsQID = dyn_cast<ObjCQualifiedIdType>(lhs);
+ ObjCQualifiedIdType *rhsQID = dyn_cast<ObjCQualifiedIdType>(rhs);
if (lhsQID) {
if (!rhsQID && rhs->getTypeClass() == Type::Pointer) {
QualType rtype =
cast<PointerType>(rhs.getCanonicalType())->getPointeeType();
rhsQI =
- dyn_cast<ObjcQualifiedInterfaceType>(
+ dyn_cast<ObjCQualifiedInterfaceType>(
rtype.getCanonicalType().getTypePtr());
if (!rhsQI) {
- ObjcInterfaceType *IT = dyn_cast<ObjcInterfaceType>(
+ ObjCInterfaceType *IT = dyn_cast<ObjCInterfaceType>(
rtype.getCanonicalType().getTypePtr());
if (IT)
rhsID = IT->getDecl();
@@ -1385,7 +1385,7 @@
return false;
unsigned numRhsProtocols = 0;
- ObjcProtocolDecl **rhsProtoList = 0;
+ ObjCProtocolDecl **rhsProtoList = 0;
if (rhsQI) {
numRhsProtocols = rhsQI->getNumProtocols();
rhsProtoList = rhsQI->getReferencedProtocols();
@@ -1396,7 +1396,7 @@
}
for (unsigned i =0; i < lhsQID->getNumProtocols(); i++) {
- ObjcProtocolDecl *lhsProto = lhsQID->getProtocols(i);
+ ObjCProtocolDecl *lhsProto = lhsQID->getProtocols(i);
bool match = false;
// when comparing an id<P> on lhs with a static type on rhs,
@@ -1407,7 +1407,7 @@
match = true;
}
else for (unsigned j = 0; j < numRhsProtocols; j++) {
- ObjcProtocolDecl *rhsProto = rhsProtoList[j];
+ ObjCProtocolDecl *rhsProto = rhsProtoList[j];
if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto)) {
match = true;
@@ -1423,10 +1423,10 @@
QualType ltype =
cast<PointerType>(lhs.getCanonicalType())->getPointeeType();
lhsQI =
- dyn_cast<ObjcQualifiedInterfaceType>(
+ dyn_cast<ObjCQualifiedInterfaceType>(
ltype.getCanonicalType().getTypePtr());
if (!lhsQI) {
- ObjcInterfaceType *IT = dyn_cast<ObjcInterfaceType>(
+ ObjCInterfaceType *IT = dyn_cast<ObjCInterfaceType>(
ltype.getCanonicalType().getTypePtr());
if (IT)
lhsID = IT->getDecl();
@@ -1436,7 +1436,7 @@
return false;
unsigned numLhsProtocols = 0;
- ObjcProtocolDecl **lhsProtoList = 0;
+ ObjCProtocolDecl **lhsProtoList = 0;
if (lhsQI) {
numLhsProtocols = lhsQI->getNumProtocols();
lhsProtoList = lhsQI->getReferencedProtocols();
@@ -1450,7 +1450,7 @@
// one of 'id's protocols.
if (lhsID) {
for (unsigned j = 0; j < rhsQID->getNumProtocols(); j++) {
- ObjcProtocolDecl *rhsProto = rhsQID->getProtocols(j);
+ ObjCProtocolDecl *rhsProto = rhsQID->getProtocols(j);
if (ClassImplementsProtocol(rhsProto, lhsID, compare)) {
match = true;
break;
@@ -1459,9 +1459,9 @@
}
else for (unsigned i =0; i < numLhsProtocols; i++) {
match = false;
- ObjcProtocolDecl *lhsProto = lhsProtoList[i];
+ ObjCProtocolDecl *lhsProto = lhsProtoList[i];
for (unsigned j = 0; j < rhsQID->getNumProtocols(); j++) {
- ObjcProtocolDecl *rhsProto = rhsQID->getProtocols(j);
+ ObjCProtocolDecl *rhsProto = rhsQID->getProtocols(j);
if (ProtocolCompatibleWithProtocol(lhsProto, rhsProto) ||
compare && ProtocolCompatibleWithProtocol(rhsProto, lhsProto)) {
match = true;
@@ -1501,8 +1501,8 @@
return true;
}
// "Class" and "id" are compatible built-in structure types.
- if (isObjcIdType(lhs) && isObjcClassType(rhs) ||
- isObjcClassType(lhs) && isObjcIdType(rhs))
+ if (isObjCIdType(lhs) && isObjCClassType(rhs) ||
+ isObjCClassType(lhs) && isObjCIdType(rhs))
return true;
return false;
}
@@ -1616,7 +1616,7 @@
// For Objective-C, it is possible for two types to be compatible
// when their classes don't match (when dealing with "id"). If either type
// is an interface, we defer to objcTypesAreCompatible().
- if (lcanon->isObjcInterfaceType() || rcanon->isObjcInterfaceType())
+ if (lcanon->isObjCInterfaceType() || rcanon->isObjCInterfaceType())
return objcTypesAreCompatible(lcanon, rcanon);
return false;
}
@@ -1633,12 +1633,12 @@
return tagTypesAreCompatible(lcanon, rcanon);
case Type::Builtin:
return builtinTypesAreCompatible(lcanon, rcanon);
- case Type::ObjcInterface:
+ case Type::ObjCInterface:
return interfaceTypesAreCompatible(lcanon, rcanon);
case Type::Vector:
case Type::OCUVector:
return vectorTypesAreCompatible(lcanon, rcanon);
- case Type::ObjcQualifiedInterface:
+ case Type::ObjCQualifiedInterface:
return QualifiedInterfaceTypesAreCompatible(lcanon, rcanon);
default:
assert(0 && "unexpected type");
diff --git a/AST/Decl.cpp b/AST/Decl.cpp
index a69d6dd..f67d712 100644
--- a/AST/Decl.cpp
+++ b/AST/Decl.cpp
@@ -33,10 +33,10 @@
static unsigned nForwardProtocolDecls = 0;
static unsigned nCategoryDecls = 0;
static unsigned nIvarDecls = 0;
-static unsigned nObjcImplementationDecls = 0;
-static unsigned nObjcCategoryImpl = 0;
-static unsigned nObjcCompatibleAlias = 0;
-static unsigned nObjcPropertyDecl = 0;
+static unsigned nObjCImplementationDecls = 0;
+static unsigned nObjCCategoryImpl = 0;
+static unsigned nObjCCompatibleAlias = 0;
+static unsigned nObjCPropertyDecl = 0;
static bool StatSwitch = false;
@@ -55,16 +55,16 @@
return "ParmVar";
case EnumConstant:
return "EnumConstant";
- case ObjcInterface:
- return "ObjcInterface";
- case ObjcClass:
- return "ObjcClass";
- case ObjcMethod:
- return "ObjcMethod";
- case ObjcProtocol:
- return "ObjcProtocol";
- case ObjcForwardProtocol:
- return "ObjcForwardProtocol";
+ case ObjCInterface:
+ return "ObjCInterface";
+ case ObjCClass:
+ return "ObjCClass";
+ case ObjCMethod:
+ return "ObjCMethod";
+ case ObjCProtocol:
+ return "ObjCProtocol";
+ case ObjCForwardProtocol:
+ return "ObjCForwardProtocol";
case Struct:
return "Struct";
case Union:
@@ -114,49 +114,49 @@
nTypedef, (int)sizeof(TypedefDecl),int(nTypedef*sizeof(TypedefDecl)));
// Objective-C decls...
fprintf(stderr, " %d interface decls, %d each (%d bytes)\n",
- nInterfaceDecls, (int)sizeof(ObjcInterfaceDecl),
- int(nInterfaceDecls*sizeof(ObjcInterfaceDecl)));
+ nInterfaceDecls, (int)sizeof(ObjCInterfaceDecl),
+ int(nInterfaceDecls*sizeof(ObjCInterfaceDecl)));
fprintf(stderr, " %d instance variable decls, %d each (%d bytes)\n",
- nIvarDecls, (int)sizeof(ObjcIvarDecl),
- int(nIvarDecls*sizeof(ObjcIvarDecl)));
+ nIvarDecls, (int)sizeof(ObjCIvarDecl),
+ int(nIvarDecls*sizeof(ObjCIvarDecl)));
fprintf(stderr, " %d class decls, %d each (%d bytes)\n",
- nClassDecls, (int)sizeof(ObjcClassDecl),
- int(nClassDecls*sizeof(ObjcClassDecl)));
+ nClassDecls, (int)sizeof(ObjCClassDecl),
+ int(nClassDecls*sizeof(ObjCClassDecl)));
fprintf(stderr, " %d method decls, %d each (%d bytes)\n",
- nMethodDecls, (int)sizeof(ObjcMethodDecl),
- int(nMethodDecls*sizeof(ObjcMethodDecl)));
+ nMethodDecls, (int)sizeof(ObjCMethodDecl),
+ int(nMethodDecls*sizeof(ObjCMethodDecl)));
fprintf(stderr, " %d protocol decls, %d each (%d bytes)\n",
- nProtocolDecls, (int)sizeof(ObjcProtocolDecl),
- int(nProtocolDecls*sizeof(ObjcProtocolDecl)));
+ nProtocolDecls, (int)sizeof(ObjCProtocolDecl),
+ int(nProtocolDecls*sizeof(ObjCProtocolDecl)));
fprintf(stderr, " %d forward protocol decls, %d each (%d bytes)\n",
- nForwardProtocolDecls, (int)sizeof(ObjcForwardProtocolDecl),
- int(nForwardProtocolDecls*sizeof(ObjcForwardProtocolDecl)));
+ nForwardProtocolDecls, (int)sizeof(ObjCForwardProtocolDecl),
+ int(nForwardProtocolDecls*sizeof(ObjCForwardProtocolDecl)));
fprintf(stderr, " %d category decls, %d each (%d bytes)\n",
- nCategoryDecls, (int)sizeof(ObjcCategoryDecl),
- int(nCategoryDecls*sizeof(ObjcCategoryDecl)));
+ nCategoryDecls, (int)sizeof(ObjCCategoryDecl),
+ int(nCategoryDecls*sizeof(ObjCCategoryDecl)));
fprintf(stderr, " %d class implementation decls, %d each (%d bytes)\n",
- nObjcImplementationDecls, (int)sizeof(ObjcImplementationDecl),
- int(nObjcImplementationDecls*sizeof(ObjcImplementationDecl)));
+ nObjCImplementationDecls, (int)sizeof(ObjCImplementationDecl),
+ int(nObjCImplementationDecls*sizeof(ObjCImplementationDecl)));
fprintf(stderr, " %d class implementation decls, %d each (%d bytes)\n",
- nObjcCategoryImpl, (int)sizeof(ObjcCategoryImplDecl),
- int(nObjcCategoryImpl*sizeof(ObjcCategoryImplDecl)));
+ nObjCCategoryImpl, (int)sizeof(ObjCCategoryImplDecl),
+ int(nObjCCategoryImpl*sizeof(ObjCCategoryImplDecl)));
fprintf(stderr, " %d compatibility alias decls, %d each (%d bytes)\n",
- nObjcCompatibleAlias, (int)sizeof(ObjcCompatibleAliasDecl),
- int(nObjcCompatibleAlias*sizeof(ObjcCompatibleAliasDecl)));
+ nObjCCompatibleAlias, (int)sizeof(ObjCCompatibleAliasDecl),
+ int(nObjCCompatibleAlias*sizeof(ObjCCompatibleAliasDecl)));
fprintf(stderr, " %d property decls, %d each (%d bytes)\n",
- nObjcPropertyDecl, (int)sizeof(ObjcPropertyDecl),
- int(nObjcPropertyDecl*sizeof(ObjcPropertyDecl)));
+ nObjCPropertyDecl, (int)sizeof(ObjCPropertyDecl),
+ int(nObjCPropertyDecl*sizeof(ObjCPropertyDecl)));
fprintf(stderr, "Total bytes = %d\n",
int(nFuncs*sizeof(FunctionDecl)+nBlockVars*sizeof(BlockVarDecl)+
nFileVars*sizeof(FileVarDecl)+nParmVars*sizeof(ParmVarDecl)+
nFieldDecls*sizeof(FieldDecl)+nSUC*sizeof(RecordDecl)+
nEnumDecls*sizeof(EnumDecl)+nEnumConst*sizeof(EnumConstantDecl)+
- nTypedef*sizeof(TypedefDecl)) /* FIXME: add Objc decls */);
+ nTypedef*sizeof(TypedefDecl)) /* FIXME: add ObjC decls */);
}
void Decl::addDeclKind(const Kind k) {
@@ -190,38 +190,38 @@
case Enum:
nEnumDecls++;
break;
- case ObjcInterface:
+ case ObjCInterface:
nInterfaceDecls++;
break;
- case ObjcClass:
+ case ObjCClass:
nClassDecls++;
break;
- case ObjcMethod:
+ case ObjCMethod:
nMethodDecls++;
break;
- case ObjcProtocol:
+ case ObjCProtocol:
nProtocolDecls++;
break;
- case ObjcForwardProtocol:
+ case ObjCForwardProtocol:
nForwardProtocolDecls++;
break;
- case ObjcCategory:
+ case ObjCCategory:
nCategoryDecls++;
break;
- case ObjcIvar:
+ case ObjCIvar:
nIvarDecls++;
break;
- case ObjcImplementation:
- nObjcImplementationDecls++;
+ case ObjCImplementation:
+ nObjCImplementationDecls++;
break;
- case ObjcCategoryImpl:
- nObjcCategoryImpl++;
+ case ObjCCategoryImpl:
+ nObjCCategoryImpl++;
break;
case CompatibleAlias:
- nObjcCompatibleAlias++;
+ nObjCCompatibleAlias++;
break;
case PropertyDecl:
- nObjcPropertyDecl++;
+ nObjCPropertyDecl++;
break;
}
}
@@ -283,7 +283,7 @@
return 0;
}
-void ObjcMethodDecl::setMethodParams(ParmVarDecl **NewParamInfo,
+void ObjCMethodDecl::setMethodParams(ParmVarDecl **NewParamInfo,
unsigned NumParams) {
assert(ParamInfo == 0 && "Already has param info!");
@@ -295,103 +295,103 @@
}
}
-ObjcMethodDecl::~ObjcMethodDecl() {
+ObjCMethodDecl::~ObjCMethodDecl() {
delete[] ParamInfo;
}
-/// ObjcAddInstanceVariablesToClass - Inserts instance variables
-/// into ObjcInterfaceDecl's fields.
+/// ObjCAddInstanceVariablesToClass - Inserts instance variables
+/// into ObjCInterfaceDecl's fields.
///
-void ObjcInterfaceDecl::addInstanceVariablesToClass(ObjcIvarDecl **ivars,
+void ObjCInterfaceDecl::addInstanceVariablesToClass(ObjCIvarDecl **ivars,
unsigned numIvars,
SourceLocation RBrac) {
NumIvars = numIvars;
if (numIvars) {
- Ivars = new ObjcIvarDecl*[numIvars];
- memcpy(Ivars, ivars, numIvars*sizeof(ObjcIvarDecl*));
+ Ivars = new ObjCIvarDecl*[numIvars];
+ memcpy(Ivars, ivars, numIvars*sizeof(ObjCIvarDecl*));
}
setLocEnd(RBrac);
}
-/// ObjcAddInstanceVariablesToClassImpl - Checks for correctness of Instance
+/// ObjCAddInstanceVariablesToClassImpl - Checks for correctness of Instance
/// Variables (Ivars) relative to what declared in @implementation;s class.
-/// Ivars into ObjcImplementationDecl's fields.
+/// Ivars into ObjCImplementationDecl's fields.
///
-void ObjcImplementationDecl::ObjcAddInstanceVariablesToClassImpl(
- ObjcIvarDecl **ivars, unsigned numIvars) {
+void ObjCImplementationDecl::ObjCAddInstanceVariablesToClassImpl(
+ ObjCIvarDecl **ivars, unsigned numIvars) {
NumIvars = numIvars;
if (numIvars) {
- Ivars = new ObjcIvarDecl*[numIvars];
- memcpy(Ivars, ivars, numIvars*sizeof(ObjcIvarDecl*));
+ Ivars = new ObjCIvarDecl*[numIvars];
+ memcpy(Ivars, ivars, numIvars*sizeof(ObjCIvarDecl*));
}
}
/// addMethods - Insert instance and methods declarations into
-/// ObjcInterfaceDecl's InsMethods and ClsMethods fields.
+/// ObjCInterfaceDecl's InsMethods and ClsMethods fields.
///
-void ObjcInterfaceDecl::addMethods(ObjcMethodDecl **insMethods,
+void ObjCInterfaceDecl::addMethods(ObjCMethodDecl **insMethods,
unsigned numInsMembers,
- ObjcMethodDecl **clsMethods,
+ ObjCMethodDecl **clsMethods,
unsigned numClsMembers,
SourceLocation endLoc) {
NumInstanceMethods = numInsMembers;
if (numInsMembers) {
- InstanceMethods = new ObjcMethodDecl*[numInsMembers];
- memcpy(InstanceMethods, insMethods, numInsMembers*sizeof(ObjcMethodDecl*));
+ InstanceMethods = new ObjCMethodDecl*[numInsMembers];
+ memcpy(InstanceMethods, insMethods, numInsMembers*sizeof(ObjCMethodDecl*));
}
NumClassMethods = numClsMembers;
if (numClsMembers) {
- ClassMethods = new ObjcMethodDecl*[numClsMembers];
- memcpy(ClassMethods, clsMethods, numClsMembers*sizeof(ObjcMethodDecl*));
+ ClassMethods = new ObjCMethodDecl*[numClsMembers];
+ memcpy(ClassMethods, clsMethods, numClsMembers*sizeof(ObjCMethodDecl*));
}
AtEndLoc = endLoc;
}
/// addMethods - Insert instance and methods declarations into
-/// ObjcProtocolDecl's ProtoInsMethods and ProtoClsMethods fields.
+/// ObjCProtocolDecl's ProtoInsMethods and ProtoClsMethods fields.
///
-void ObjcProtocolDecl::addMethods(ObjcMethodDecl **insMethods,
+void ObjCProtocolDecl::addMethods(ObjCMethodDecl **insMethods,
unsigned numInsMembers,
- ObjcMethodDecl **clsMethods,
+ ObjCMethodDecl **clsMethods,
unsigned numClsMembers,
SourceLocation endLoc) {
NumInstanceMethods = numInsMembers;
if (numInsMembers) {
- InstanceMethods = new ObjcMethodDecl*[numInsMembers];
- memcpy(InstanceMethods, insMethods, numInsMembers*sizeof(ObjcMethodDecl*));
+ InstanceMethods = new ObjCMethodDecl*[numInsMembers];
+ memcpy(InstanceMethods, insMethods, numInsMembers*sizeof(ObjCMethodDecl*));
}
NumClassMethods = numClsMembers;
if (numClsMembers) {
- ClassMethods = new ObjcMethodDecl*[numClsMembers];
- memcpy(ClassMethods, clsMethods, numClsMembers*sizeof(ObjcMethodDecl*));
+ ClassMethods = new ObjCMethodDecl*[numClsMembers];
+ memcpy(ClassMethods, clsMethods, numClsMembers*sizeof(ObjCMethodDecl*));
}
AtEndLoc = endLoc;
}
/// addMethods - Insert instance and methods declarations into
-/// ObjcCategoryDecl's CatInsMethods and CatClsMethods fields.
+/// ObjCCategoryDecl's CatInsMethods and CatClsMethods fields.
///
-void ObjcCategoryDecl::addMethods(ObjcMethodDecl **insMethods,
+void ObjCCategoryDecl::addMethods(ObjCMethodDecl **insMethods,
unsigned numInsMembers,
- ObjcMethodDecl **clsMethods,
+ ObjCMethodDecl **clsMethods,
unsigned numClsMembers,
SourceLocation endLoc) {
NumInstanceMethods = numInsMembers;
if (numInsMembers) {
- InstanceMethods = new ObjcMethodDecl*[numInsMembers];
- memcpy(InstanceMethods, insMethods, numInsMembers*sizeof(ObjcMethodDecl*));
+ InstanceMethods = new ObjCMethodDecl*[numInsMembers];
+ memcpy(InstanceMethods, insMethods, numInsMembers*sizeof(ObjCMethodDecl*));
}
NumClassMethods = numClsMembers;
if (numClsMembers) {
- ClassMethods = new ObjcMethodDecl*[numClsMembers];
- memcpy(ClassMethods, clsMethods, numClsMembers*sizeof(ObjcMethodDecl*));
+ ClassMethods = new ObjCMethodDecl*[numClsMembers];
+ memcpy(ClassMethods, clsMethods, numClsMembers*sizeof(ObjCMethodDecl*));
}
AtEndLoc = endLoc;
}
-ObjcIvarDecl *ObjcInterfaceDecl::lookupInstanceVariable(
- IdentifierInfo *ID, ObjcInterfaceDecl *&clsDeclared) {
- ObjcInterfaceDecl* ClassDecl = this;
+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) {
@@ -407,23 +407,23 @@
/// 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;
+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();
+ 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();
+ ObjCCategoryDecl *CatDecl = ClassDecl->getCategoryList();
while (CatDecl) {
if ((MethodDecl = CatDecl->getInstanceMethod(Sel)))
return MethodDecl;
@@ -436,23 +436,23 @@
// 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;
+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();
+ 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();
+ ObjCCategoryDecl *CatDecl = ClassDecl->getCategoryList();
while (CatDecl) {
if ((MethodDecl = CatDecl->getClassMethod(Sel)))
return MethodDecl;
@@ -466,7 +466,7 @@
/// 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) {
+ObjCMethodDecl *ObjCImplementationDecl::getInstanceMethod(Selector Sel) {
for (instmeth_iterator I = instmeth_begin(), E = instmeth_end(); I != E; ++I)
if ((*I)->getSelector() == Sel)
return *I;
@@ -476,7 +476,7 @@
/// 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) {
+ObjCMethodDecl *ObjCImplementationDecl::getClassMethod(Selector Sel) {
for (classmeth_iterator I = classmeth_begin(), E = classmeth_end();
I != E; ++I)
if ((*I)->getSelector() == Sel)
@@ -487,7 +487,7 @@
// 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) {
+ObjCMethodDecl *ObjCCategoryImplDecl::getInstanceMethod(Selector Sel) {
for (instmeth_iterator I = instmeth_begin(), E = instmeth_end(); I != E; ++I)
if ((*I)->getSelector() == Sel)
return *I;
@@ -497,7 +497,7 @@
// 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) {
+ObjCMethodDecl *ObjCCategoryImplDecl::getClassMethod(Selector Sel) {
for (classmeth_iterator I = classmeth_begin(), E = classmeth_end();
I != E; ++I)
if ((*I)->getSelector() == Sel)
@@ -507,14 +507,14 @@
// lookupInstanceMethod - Lookup a instance method in the protocol and protocols
// it inherited.
-ObjcMethodDecl *ObjcProtocolDecl::lookupInstanceMethod(Selector Sel) {
- ObjcMethodDecl *MethodDecl = NULL;
+ObjCMethodDecl *ObjCProtocolDecl::lookupInstanceMethod(Selector Sel) {
+ ObjCMethodDecl *MethodDecl = NULL;
if ((MethodDecl = getInstanceMethod(Sel)))
return MethodDecl;
if (getNumReferencedProtocols() > 0) {
- ObjcProtocolDecl **RefPDecl = getReferencedProtocols();
+ ObjCProtocolDecl **RefPDecl = getReferencedProtocols();
for (unsigned i = 0; i < getNumReferencedProtocols(); i++) {
if ((MethodDecl = RefPDecl[i]->getInstanceMethod(Sel)))
@@ -526,14 +526,14 @@
// lookupInstanceMethod - Lookup a class method in the protocol and protocols
// it inherited.
-ObjcMethodDecl *ObjcProtocolDecl::lookupClassMethod(Selector Sel) {
- ObjcMethodDecl *MethodDecl = NULL;
+ObjCMethodDecl *ObjCProtocolDecl::lookupClassMethod(Selector Sel) {
+ ObjCMethodDecl *MethodDecl = NULL;
if ((MethodDecl = getClassMethod(Sel)))
return MethodDecl;
if (getNumReferencedProtocols() > 0) {
- ObjcProtocolDecl **RefPDecl = getReferencedProtocols();
+ ObjCProtocolDecl **RefPDecl = getReferencedProtocols();
for(unsigned i = 0; i < getNumReferencedProtocols(); i++) {
if ((MethodDecl = RefPDecl[i]->getClassMethod(Sel)))
@@ -543,16 +543,16 @@
return NULL;
}
-ObjcInterfaceDecl *const ObjcMethodDecl::getClassInterface() const {
- if (ObjcInterfaceDecl *ID = dyn_cast<ObjcInterfaceDecl>(MethodContext))
+ObjCInterfaceDecl *const ObjCMethodDecl::getClassInterface() const {
+ if (ObjCInterfaceDecl *ID = dyn_cast<ObjCInterfaceDecl>(MethodContext))
return ID;
- if (ObjcCategoryDecl *CD = dyn_cast<ObjcCategoryDecl>(MethodContext))
+ if (ObjCCategoryDecl *CD = dyn_cast<ObjCCategoryDecl>(MethodContext))
return CD->getClassInterface();
- if (ObjcImplementationDecl *IMD =
- dyn_cast<ObjcImplementationDecl>(MethodContext))
+ if (ObjCImplementationDecl *IMD =
+ dyn_cast<ObjCImplementationDecl>(MethodContext))
return IMD->getClassInterface();
- if (ObjcCategoryImplDecl *CID =
- dyn_cast<ObjcCategoryImplDecl>(MethodContext))
+ if (ObjCCategoryImplDecl *CID =
+ dyn_cast<ObjCCategoryImplDecl>(MethodContext))
return CID->getClassInterface();
assert(false && "unknown method context");
return 0;
diff --git a/AST/DeclSerialization.cpp b/AST/DeclSerialization.cpp
index 0e0e0ff..6baa262 100644
--- a/AST/DeclSerialization.cpp
+++ b/AST/DeclSerialization.cpp
@@ -217,7 +217,7 @@
void ParmVarDecl::EmitImpl(llvm::Serializer& S) const {
VarDecl::EmitImpl(S);
- S.EmitInt(getObjcDeclQualifier()); // From ParmVarDecl.
+ S.EmitInt(getObjCDeclQualifier()); // From ParmVarDecl.
}
ParmVarDecl* ParmVarDecl::CreateImpl(Deserializer& D) {
@@ -225,7 +225,7 @@
new ParmVarDecl(SourceLocation(),NULL,QualType(),None,NULL);
decl->VarDecl::ReadImpl(D);
- decl->objcDeclQualifier = static_cast<ObjcDeclQualifier>(D.ReadInt());
+ decl->objcDeclQualifier = static_cast<ObjCDeclQualifier>(D.ReadInt());
return decl;
}
diff --git a/AST/Expr.cpp b/AST/Expr.cpp
index ed62559..236c783 100644
--- a/AST/Expr.cpp
+++ b/AST/Expr.cpp
@@ -985,7 +985,7 @@
// constructor for instance messages.
ObjCMessageExpr::ObjCMessageExpr(Expr *receiver, Selector selInfo,
- QualType retType, ObjcMethodDecl *mproto,
+ QualType retType, ObjCMethodDecl *mproto,
SourceLocation LBrac, SourceLocation RBrac,
Expr **ArgExprs, unsigned nargs)
: Expr(ObjCMessageExprClass, retType), SelName(selInfo),
@@ -1004,7 +1004,7 @@
// constructor for class messages.
// FIXME: clsName should be typed to ObjCInterfaceType
ObjCMessageExpr::ObjCMessageExpr(IdentifierInfo *clsName, Selector selInfo,
- QualType retType, ObjcMethodDecl *mproto,
+ QualType retType, ObjCMethodDecl *mproto,
SourceLocation LBrac, SourceLocation RBrac,
Expr **ArgExprs, unsigned nargs)
: Expr(ObjCMessageExprClass, retType), SelName(selInfo),
diff --git a/AST/Stmt.cpp b/AST/Stmt.cpp
index 95d077c..8d4f613 100644
--- a/AST/Stmt.cpp
+++ b/AST/Stmt.cpp
@@ -183,11 +183,11 @@
Stmt::child_iterator ForStmt::child_begin() { return &SubExprs[0]; }
Stmt::child_iterator ForStmt::child_end() { return &SubExprs[0]+END_EXPR; }
-// ObjcForCollectionStmt
-Stmt::child_iterator ObjcForCollectionStmt::child_begin() {
+// ObjCForCollectionStmt
+Stmt::child_iterator ObjCForCollectionStmt::child_begin() {
return &SubExprs[0];
}
-Stmt::child_iterator ObjcForCollectionStmt::child_end() {
+Stmt::child_iterator ObjCForCollectionStmt::child_end() {
return &SubExprs[0]+END_EXPR;
}
@@ -225,27 +225,27 @@
Stmt::child_iterator AsmStmt::child_begin() { return child_iterator(); }
Stmt::child_iterator AsmStmt::child_end() { return child_iterator(); }
-// ObjcAtCatchStmt
-Stmt::child_iterator ObjcAtCatchStmt::child_begin() { return &SubExprs[0]; }
-Stmt::child_iterator ObjcAtCatchStmt::child_end() {
+// ObjCAtCatchStmt
+Stmt::child_iterator ObjCAtCatchStmt::child_begin() { return &SubExprs[0]; }
+Stmt::child_iterator ObjCAtCatchStmt::child_end() {
return &SubExprs[0]+END_EXPR;
}
-// ObjcAtFinallyStmt
-Stmt::child_iterator ObjcAtFinallyStmt::child_begin() { return &AtFinallyStmt; }
-Stmt::child_iterator ObjcAtFinallyStmt::child_end() { return &AtFinallyStmt+1; }
+// ObjCAtFinallyStmt
+Stmt::child_iterator ObjCAtFinallyStmt::child_begin() { return &AtFinallyStmt; }
+Stmt::child_iterator ObjCAtFinallyStmt::child_end() { return &AtFinallyStmt+1; }
-// ObjcAtTryStmt
-Stmt::child_iterator ObjcAtTryStmt::child_begin() { return &SubStmts[0]; }
-Stmt::child_iterator ObjcAtTryStmt::child_end() {
+// ObjCAtTryStmt
+Stmt::child_iterator ObjCAtTryStmt::child_begin() { return &SubStmts[0]; }
+Stmt::child_iterator ObjCAtTryStmt::child_end() {
return &SubStmts[0]+END_EXPR;
}
-// ObjcAtThrowStmt
-Stmt::child_iterator ObjcAtThrowStmt::child_begin() {
+// ObjCAtThrowStmt
+Stmt::child_iterator ObjCAtThrowStmt::child_begin() {
return &Throw;
}
-Stmt::child_iterator ObjcAtThrowStmt::child_end() {
+Stmt::child_iterator ObjCAtThrowStmt::child_end() {
return &Throw+1;
}
diff --git a/AST/StmtDumper.cpp b/AST/StmtDumper.cpp
index 0125dfb..b7a3122 100644
--- a/AST/StmtDumper.cpp
+++ b/AST/StmtDumper.cpp
@@ -284,8 +284,8 @@
case Decl::Union: fprintf(F,"Union"); break;
case Decl::Class: fprintf(F,"Class"); break;
case Decl::Enum: fprintf(F,"Enum"); break;
- case Decl::ObjcInterface: fprintf(F,"ObjcInterface"); break;
- case Decl::ObjcClass: fprintf(F,"ObjcClass"); break;
+ case Decl::ObjCInterface: fprintf(F,"ObjCInterface"); break;
+ case Decl::ObjCClass: fprintf(F,"ObjCClass"); break;
default: fprintf(F,"Decl"); break;
}
diff --git a/AST/StmtPrinter.cpp b/AST/StmtPrinter.cpp
index 099dd28..6bfe735 100644
--- a/AST/StmtPrinter.cpp
+++ b/AST/StmtPrinter.cpp
@@ -296,7 +296,7 @@
}
}
-void StmtPrinter::VisitObjcForCollectionStmt(ObjcForCollectionStmt *Node) {
+void StmtPrinter::VisitObjCForCollectionStmt(ObjCForCollectionStmt *Node) {
Indent() << "for (";
if (DeclStmt *DS = dyn_cast<DeclStmt>(Node->getElement()))
PrintRawDecl(DS->getDecl());
@@ -406,18 +406,18 @@
OS << ");\n";
}
-void StmtPrinter::VisitObjcAtTryStmt(ObjcAtTryStmt *Node) {
+void StmtPrinter::VisitObjCAtTryStmt(ObjCAtTryStmt *Node) {
Indent() << "@try";
if (CompoundStmt *TS = dyn_cast<CompoundStmt>(Node->getTryBody())) {
PrintRawCompoundStmt(TS);
OS << "\n";
}
- for (ObjcAtCatchStmt *catchStmt =
- static_cast<ObjcAtCatchStmt *>(Node->getCatchStmts());
+ for (ObjCAtCatchStmt *catchStmt =
+ static_cast<ObjCAtCatchStmt *>(Node->getCatchStmts());
catchStmt;
catchStmt =
- static_cast<ObjcAtCatchStmt *>(catchStmt->getNextCatchStmt())) {
+ static_cast<ObjCAtCatchStmt *>(catchStmt->getNextCatchStmt())) {
Indent() << "@catch(";
if (catchStmt->getCatchParamStmt()) {
if (DeclStmt *DS = dyn_cast<DeclStmt>(catchStmt->getCatchParamStmt()))
@@ -431,7 +431,7 @@
}
}
- if (ObjcAtFinallyStmt *FS =static_cast<ObjcAtFinallyStmt *>(
+ if (ObjCAtFinallyStmt *FS =static_cast<ObjCAtFinallyStmt *>(
Node->getFinallyStmt())) {
Indent() << "@finally";
PrintRawCompoundStmt(dyn_cast<CompoundStmt>(FS->getFinallyBody()));
@@ -439,14 +439,14 @@
}
}
-void StmtPrinter::VisitObjcAtFinallyStmt(ObjcAtFinallyStmt *Node) {
+void StmtPrinter::VisitObjCAtFinallyStmt(ObjCAtFinallyStmt *Node) {
}
-void StmtPrinter::VisitObjcAtCatchStmt (ObjcAtCatchStmt *Node) {
+void StmtPrinter::VisitObjCAtCatchStmt (ObjCAtCatchStmt *Node) {
Indent() << "@catch (...) { /* todo */ } \n";
}
-void StmtPrinter::VisitObjcAtThrowStmt (ObjcAtThrowStmt *Node) {
+void StmtPrinter::VisitObjCAtThrowStmt (ObjCAtThrowStmt *Node) {
Indent() << "@throw";
if (Node->getThrowExpr()) {
OS << " ";
diff --git a/AST/StmtSerialization.cpp b/AST/StmtSerialization.cpp
index 330ebcb..56d4e2f 100644
--- a/AST/StmtSerialization.cpp
+++ b/AST/StmtSerialization.cpp
@@ -156,23 +156,23 @@
// Objective C
//==--------------------------------------==//
- case ObjcAtCatchStmtClass:
- return ObjcAtCatchStmt::CreateImpl(D);
+ case ObjCAtCatchStmtClass:
+ return ObjCAtCatchStmt::CreateImpl(D);
- case ObjcAtFinallyStmtClass:
- return ObjcAtFinallyStmt::CreateImpl(D);
+ case ObjCAtFinallyStmtClass:
+ return ObjCAtFinallyStmt::CreateImpl(D);
- case ObjcAtThrowStmtClass:
- return ObjcAtThrowStmt::CreateImpl(D);
+ case ObjCAtThrowStmtClass:
+ return ObjCAtThrowStmt::CreateImpl(D);
- case ObjcAtTryStmtClass:
- return ObjcAtTryStmt::CreateImpl(D);
+ case ObjCAtTryStmtClass:
+ return ObjCAtTryStmt::CreateImpl(D);
case ObjCEncodeExprClass:
return ObjCEncodeExpr::CreateImpl(D);
- case ObjcForCollectionStmtClass:
- return ObjcForCollectionStmt::CreateImpl(D);
+ case ObjCForCollectionStmtClass:
+ return ObjCForCollectionStmt::CreateImpl(D);
case ObjCIvarRefExprClass:
return ObjCIvarRefExpr::CreateImpl(D);
@@ -851,18 +851,18 @@
// Objective C Serialization
//===----------------------------------------------------------------------===//
-void ObjcAtCatchStmt::EmitImpl(Serializer& S) const {
+void ObjCAtCatchStmt::EmitImpl(Serializer& S) const {
S.Emit(AtCatchLoc);
S.Emit(RParenLoc);
S.EmitPtr(NextAtCatchStmt);
S.BatchEmitOwnedPtrs((unsigned) END_EXPR,&SubExprs[0]);
}
-ObjcAtCatchStmt* ObjcAtCatchStmt::CreateImpl(Deserializer& D) {
+ObjCAtCatchStmt* ObjCAtCatchStmt::CreateImpl(Deserializer& D) {
SourceLocation AtCatchLoc = SourceLocation::ReadVal(D);
SourceLocation RParenLoc = SourceLocation::ReadVal(D);
- ObjcAtCatchStmt* stmt = new ObjcAtCatchStmt(AtCatchLoc,RParenLoc);
+ ObjCAtCatchStmt* stmt = new ObjCAtCatchStmt(AtCatchLoc,RParenLoc);
D.ReadPtr(stmt->NextAtCatchStmt); // Allows backpatching.
D.BatchReadOwnedPtrs((unsigned) END_EXPR, &stmt->SubExprs[0]);
@@ -870,36 +870,36 @@
return stmt;
}
-void ObjcAtFinallyStmt::EmitImpl(Serializer& S) const {
+void ObjCAtFinallyStmt::EmitImpl(Serializer& S) const {
S.Emit(AtFinallyLoc);
S.EmitOwnedPtr(AtFinallyStmt);
}
-ObjcAtFinallyStmt* ObjcAtFinallyStmt::CreateImpl(Deserializer& D) {
+ObjCAtFinallyStmt* ObjCAtFinallyStmt::CreateImpl(Deserializer& D) {
SourceLocation Loc = SourceLocation::ReadVal(D);
Stmt* AtFinallyStmt = D.ReadOwnedPtr<Stmt>();
- return new ObjcAtFinallyStmt(Loc,AtFinallyStmt);
+ return new ObjCAtFinallyStmt(Loc,AtFinallyStmt);
}
-void ObjcAtThrowStmt::EmitImpl(Serializer& S) const {
+void ObjCAtThrowStmt::EmitImpl(Serializer& S) const {
S.Emit(AtThrowLoc);
S.EmitOwnedPtr(Throw);
}
-ObjcAtThrowStmt* ObjcAtThrowStmt::CreateImpl(Deserializer& D) {
+ObjCAtThrowStmt* ObjCAtThrowStmt::CreateImpl(Deserializer& D) {
SourceLocation L = SourceLocation::ReadVal(D);
Stmt* Throw = D.ReadOwnedPtr<Stmt>();
- return new ObjcAtThrowStmt(L,Throw);
+ return new ObjCAtThrowStmt(L,Throw);
}
-void ObjcAtTryStmt::EmitImpl(Serializer& S) const {
+void ObjCAtTryStmt::EmitImpl(Serializer& S) const {
S.Emit(AtTryLoc);
S.BatchEmitOwnedPtrs((unsigned) END_EXPR, &SubStmts[0]);
}
-ObjcAtTryStmt* ObjcAtTryStmt::CreateImpl(Deserializer& D) {
+ObjCAtTryStmt* ObjCAtTryStmt::CreateImpl(Deserializer& D) {
SourceLocation L = SourceLocation::ReadVal(D);
- ObjcAtTryStmt* stmt = new ObjcAtTryStmt(L,NULL,NULL,NULL);
+ ObjCAtTryStmt* stmt = new ObjCAtTryStmt(L,NULL,NULL,NULL);
D.BatchReadOwnedPtrs((unsigned) END_EXPR, &stmt->SubStmts[0]);
return stmt;
}
@@ -919,18 +919,18 @@
return new ObjCEncodeExpr(T,ET,AtLoc,RParenLoc);
}
-void ObjcForCollectionStmt::EmitImpl(Serializer& S) const {
+void ObjCForCollectionStmt::EmitImpl(Serializer& S) const {
S.Emit(ForLoc);
S.BatchEmitOwnedPtrs(getElement(),getCollection(),getBody());
}
-ObjcForCollectionStmt* ObjcForCollectionStmt::CreateImpl(Deserializer& D) {
+ObjCForCollectionStmt* ObjCForCollectionStmt::CreateImpl(Deserializer& D) {
SourceLocation ForLoc = SourceLocation::ReadVal(D);
Stmt* Element;
Expr* Collection;
Stmt* Body;
D.BatchReadOwnedPtrs(Element,Collection,Body);
- return new ObjcForCollectionStmt(Element,Collection,Body,ForLoc);
+ return new ObjCForCollectionStmt(Element,Collection,Body,ForLoc);
}
void ObjCIvarRefExpr::EmitImpl(Serializer& S) const {
diff --git a/AST/Type.cpp b/AST/Type.cpp
index af96830..610cd8f 100644
--- a/AST/Type.cpp
+++ b/AST/Type.cpp
@@ -434,7 +434,7 @@
}
return isa<PointerType>(CanonicalType) || isa<ComplexType>(CanonicalType) ||
isa<VectorType>(CanonicalType) ||
- isa<ObjcQualifiedIdType>(CanonicalType);
+ isa<ObjCQualifiedIdType>(CanonicalType);
}
bool Type::isAggregateType() const {
@@ -529,25 +529,25 @@
Profile(ID, getResultType(), arg_type_begin(), NumArgs, isVariadic());
}
-void ObjcQualifiedInterfaceType::Profile(llvm::FoldingSetNodeID &ID,
- ObjcProtocolDecl **protocols,
+void ObjCQualifiedInterfaceType::Profile(llvm::FoldingSetNodeID &ID,
+ ObjCProtocolDecl **protocols,
unsigned NumProtocols) {
for (unsigned i = 0; i != NumProtocols; i++)
ID.AddPointer(protocols[i]);
}
-void ObjcQualifiedInterfaceType::Profile(llvm::FoldingSetNodeID &ID) {
+void ObjCQualifiedInterfaceType::Profile(llvm::FoldingSetNodeID &ID) {
Profile(ID, &Protocols[0], getNumProtocols());
}
-void ObjcQualifiedIdType::Profile(llvm::FoldingSetNodeID &ID,
- ObjcProtocolDecl **protocols,
+void ObjCQualifiedIdType::Profile(llvm::FoldingSetNodeID &ID,
+ ObjCProtocolDecl **protocols,
unsigned NumProtocols) {
for (unsigned i = 0; i != NumProtocols; i++)
ID.AddPointer(protocols[i]);
}
-void ObjcQualifiedIdType::Profile(llvm::FoldingSetNodeID &ID) {
+void ObjCQualifiedIdType::Profile(llvm::FoldingSetNodeID &ID) {
Profile(ID, &Protocols[0], getNumProtocols());
}
@@ -770,42 +770,42 @@
InnerString = getDecl()->getIdentifier()->getName() + InnerString;
}
-void ObjcInterfaceType::getAsStringInternal(std::string &InnerString) const {
+void ObjCInterfaceType::getAsStringInternal(std::string &InnerString) const {
if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'.
InnerString = ' ' + InnerString;
InnerString = getDecl()->getIdentifier()->getName() + InnerString;
}
-void ObjcQualifiedInterfaceType::getAsStringInternal(
+void ObjCQualifiedInterfaceType::getAsStringInternal(
std::string &InnerString) const {
if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'.
InnerString = ' ' + InnerString;
- std::string ObjcQIString = getDecl()->getName();
- ObjcQIString += '<';
+ std::string ObjCQIString = getDecl()->getName();
+ ObjCQIString += '<';
int num = getNumProtocols();
for (int i = 0; i < num; i++) {
- ObjcQIString += getProtocols(i)->getName();
+ ObjCQIString += getProtocols(i)->getName();
if (i < num-1)
- ObjcQIString += ',';
+ ObjCQIString += ',';
}
- ObjcQIString += '>';
- InnerString = ObjcQIString + InnerString;
+ ObjCQIString += '>';
+ InnerString = ObjCQIString + InnerString;
}
-void ObjcQualifiedIdType::getAsStringInternal(
+void ObjCQualifiedIdType::getAsStringInternal(
std::string &InnerString) const {
if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'.
InnerString = ' ' + InnerString;
- std::string ObjcQIString = "id";
- ObjcQIString += '<';
+ std::string ObjCQIString = "id";
+ ObjCQIString += '<';
int num = getNumProtocols();
for (int i = 0; i < num; i++) {
- ObjcQIString += getProtocols(i)->getName();
+ ObjCQIString += getProtocols(i)->getName();
if (i < num-1)
- ObjcQIString += ',';
+ ObjCQIString += ',';
}
- ObjcQIString += '>';
- InnerString = ObjcQIString + InnerString;
+ ObjCQIString += '>';
+ InnerString = ObjCQIString + InnerString;
}
void TagType::getAsStringInternal(std::string &InnerString) const {