Type.cpp revision afa74448a07a16c3146accbe0ff03e9c8b0995e5
1//===--- Type.cpp - Type representation and manipulation ------------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This file implements type-related functionality. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/AST/ASTContext.h" 15#include "clang/AST/Type.h" 16#include "clang/AST/DeclCXX.h" 17#include "clang/AST/DeclObjC.h" 18#include "clang/AST/DeclTemplate.h" 19#include "clang/AST/Expr.h" 20#include "llvm/ADT/StringExtras.h" 21 22using namespace clang; 23 24bool QualType::isConstant(ASTContext &Ctx) const { 25 if (isConstQualified()) 26 return true; 27 28 if (getTypePtr()->isArrayType()) 29 return Ctx.getAsArrayType(*this)->getElementType().isConstant(Ctx); 30 31 return false; 32} 33 34void Type::Destroy(ASTContext& C) { 35 this->~Type(); 36 C.Deallocate(this); 37} 38 39void VariableArrayType::Destroy(ASTContext& C) { 40 SizeExpr->Destroy(C); 41 this->~VariableArrayType(); 42 C.Deallocate(this); 43} 44 45void DependentSizedArrayType::Destroy(ASTContext& C) { 46 SizeExpr->Destroy(C); 47 this->~DependentSizedArrayType(); 48 C.Deallocate(this); 49} 50 51/// getArrayElementTypeNoTypeQual - If this is an array type, return the 52/// element type of the array, potentially with type qualifiers missing. 53/// This method should never be used when type qualifiers are meaningful. 54const Type *Type::getArrayElementTypeNoTypeQual() const { 55 // If this is directly an array type, return it. 56 if (const ArrayType *ATy = dyn_cast<ArrayType>(this)) 57 return ATy->getElementType().getTypePtr(); 58 59 // If the canonical form of this type isn't the right kind, reject it. 60 if (!isa<ArrayType>(CanonicalType)) { 61 // Look through type qualifiers 62 if (ArrayType *AT = dyn_cast<ArrayType>(CanonicalType.getUnqualifiedType())) 63 return AT->getElementType().getTypePtr(); 64 return 0; 65 } 66 67 // If this is a typedef for an array type, strip the typedef off without 68 // losing all typedef information. 69 return getDesugaredType()->getArrayElementTypeNoTypeQual(); 70} 71 72/// getDesugaredType - Return the specified type with any "sugar" removed from 73/// type type. This takes off typedefs, typeof's etc. If the outer level of 74/// the type is already concrete, it returns it unmodified. This is similar 75/// to getting the canonical type, but it doesn't remove *all* typedefs. For 76/// example, it return "T*" as "T*", (not as "int*"), because the pointer is 77/// concrete. 78QualType Type::getDesugaredType() const { 79 if (const TypedefType *TDT = dyn_cast<TypedefType>(this)) 80 return TDT->LookThroughTypedefs(); 81 if (const TypeOfExpr *TOE = dyn_cast<TypeOfExpr>(this)) 82 return TOE->getUnderlyingExpr()->getType(); 83 if (const TypeOfType *TOT = dyn_cast<TypeOfType>(this)) 84 return TOT->getUnderlyingType(); 85 if (const ClassTemplateSpecializationType *Spec 86 = dyn_cast<ClassTemplateSpecializationType>(this)) 87 return Spec->getCanonicalTypeInternal(); 88 89 // FIXME: remove this cast. 90 return QualType(const_cast<Type*>(this), 0); 91} 92 93/// isVoidType - Helper method to determine if this is the 'void' type. 94bool Type::isVoidType() const { 95 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 96 return BT->getKind() == BuiltinType::Void; 97 if (const ExtQualType *AS = dyn_cast<ExtQualType>(CanonicalType)) 98 return AS->getBaseType()->isVoidType(); 99 return false; 100} 101 102bool Type::isObjectType() const { 103 if (isa<FunctionType>(CanonicalType) || isa<ReferenceType>(CanonicalType)) 104 return false; 105 if (const ExtQualType *AS = dyn_cast<ExtQualType>(CanonicalType)) 106 return AS->getBaseType()->isObjectType(); 107 return !CanonicalType->isIncompleteType(); 108} 109 110bool Type::isDerivedType() const { 111 switch (CanonicalType->getTypeClass()) { 112 case ExtQual: 113 return cast<ExtQualType>(CanonicalType)->getBaseType()->isDerivedType(); 114 case Pointer: 115 case VariableArray: 116 case ConstantArray: 117 case IncompleteArray: 118 case FunctionProto: 119 case FunctionNoProto: 120 case Reference: 121 return true; 122 case Tagged: 123 return !cast<TagType>(CanonicalType)->getDecl()->isEnum(); 124 default: 125 return false; 126 } 127} 128 129bool Type::isClassType() const { 130 if (const RecordType *RT = getAsRecordType()) 131 return RT->getDecl()->isClass(); 132 return false; 133} 134bool Type::isStructureType() const { 135 if (const RecordType *RT = getAsRecordType()) 136 return RT->getDecl()->isStruct(); 137 return false; 138} 139bool Type::isUnionType() const { 140 if (const RecordType *RT = getAsRecordType()) 141 return RT->getDecl()->isUnion(); 142 return false; 143} 144 145bool Type::isComplexType() const { 146 if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType)) 147 return CT->getElementType()->isFloatingType(); 148 if (const ExtQualType *AS = dyn_cast<ExtQualType>(CanonicalType)) 149 return AS->getBaseType()->isComplexType(); 150 return false; 151} 152 153bool Type::isComplexIntegerType() const { 154 // Check for GCC complex integer extension. 155 if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType)) 156 return CT->getElementType()->isIntegerType(); 157 if (const ExtQualType *AS = dyn_cast<ExtQualType>(CanonicalType)) 158 return AS->getBaseType()->isComplexIntegerType(); 159 return false; 160} 161 162const ComplexType *Type::getAsComplexIntegerType() const { 163 // Are we directly a complex type? 164 if (const ComplexType *CTy = dyn_cast<ComplexType>(this)) { 165 if (CTy->getElementType()->isIntegerType()) 166 return CTy; 167 return 0; 168 } 169 170 // If the canonical form of this type isn't what we want, reject it. 171 if (!isa<ComplexType>(CanonicalType)) { 172 // Look through type qualifiers (e.g. ExtQualType's). 173 if (isa<ComplexType>(CanonicalType.getUnqualifiedType())) 174 return CanonicalType.getUnqualifiedType()->getAsComplexIntegerType(); 175 return 0; 176 } 177 178 // If this is a typedef for a complex type, strip the typedef off without 179 // losing all typedef information. 180 return getDesugaredType()->getAsComplexIntegerType(); 181} 182 183const BuiltinType *Type::getAsBuiltinType() const { 184 // If this is directly a builtin type, return it. 185 if (const BuiltinType *BTy = dyn_cast<BuiltinType>(this)) 186 return BTy; 187 188 // If the canonical form of this type isn't a builtin type, reject it. 189 if (!isa<BuiltinType>(CanonicalType)) { 190 // Look through type qualifiers (e.g. ExtQualType's). 191 if (isa<BuiltinType>(CanonicalType.getUnqualifiedType())) 192 return CanonicalType.getUnqualifiedType()->getAsBuiltinType(); 193 return 0; 194 } 195 196 // If this is a typedef for a builtin type, strip the typedef off without 197 // losing all typedef information. 198 return getDesugaredType()->getAsBuiltinType(); 199} 200 201const FunctionType *Type::getAsFunctionType() const { 202 // If this is directly a function type, return it. 203 if (const FunctionType *FTy = dyn_cast<FunctionType>(this)) 204 return FTy; 205 206 // If the canonical form of this type isn't the right kind, reject it. 207 if (!isa<FunctionType>(CanonicalType)) { 208 // Look through type qualifiers 209 if (isa<FunctionType>(CanonicalType.getUnqualifiedType())) 210 return CanonicalType.getUnqualifiedType()->getAsFunctionType(); 211 return 0; 212 } 213 214 // If this is a typedef for a function type, strip the typedef off without 215 // losing all typedef information. 216 return getDesugaredType()->getAsFunctionType(); 217} 218 219const FunctionTypeNoProto *Type::getAsFunctionTypeNoProto() const { 220 return dyn_cast_or_null<FunctionTypeNoProto>(getAsFunctionType()); 221} 222 223const FunctionTypeProto *Type::getAsFunctionTypeProto() const { 224 return dyn_cast_or_null<FunctionTypeProto>(getAsFunctionType()); 225} 226 227 228const PointerLikeType *Type::getAsPointerLikeType() const { 229 // If this is directly a pointer-like type, return it. 230 if (const PointerLikeType *PTy = dyn_cast<PointerLikeType>(this)) 231 return PTy; 232 233 // If the canonical form of this type isn't the right kind, reject it. 234 if (!isa<PointerLikeType>(CanonicalType)) { 235 // Look through type qualifiers 236 if (isa<PointerLikeType>(CanonicalType.getUnqualifiedType())) 237 return CanonicalType.getUnqualifiedType()->getAsPointerLikeType(); 238 return 0; 239 } 240 241 // If this is a typedef for a pointer type, strip the typedef off without 242 // losing all typedef information. 243 return getDesugaredType()->getAsPointerLikeType(); 244} 245 246const PointerType *Type::getAsPointerType() const { 247 // If this is directly a pointer type, return it. 248 if (const PointerType *PTy = dyn_cast<PointerType>(this)) 249 return PTy; 250 251 // If the canonical form of this type isn't the right kind, reject it. 252 if (!isa<PointerType>(CanonicalType)) { 253 // Look through type qualifiers 254 if (isa<PointerType>(CanonicalType.getUnqualifiedType())) 255 return CanonicalType.getUnqualifiedType()->getAsPointerType(); 256 return 0; 257 } 258 259 // If this is a typedef for a pointer type, strip the typedef off without 260 // losing all typedef information. 261 return getDesugaredType()->getAsPointerType(); 262} 263 264const BlockPointerType *Type::getAsBlockPointerType() const { 265 // If this is directly a block pointer type, return it. 266 if (const BlockPointerType *PTy = dyn_cast<BlockPointerType>(this)) 267 return PTy; 268 269 // If the canonical form of this type isn't the right kind, reject it. 270 if (!isa<BlockPointerType>(CanonicalType)) { 271 // Look through type qualifiers 272 if (isa<BlockPointerType>(CanonicalType.getUnqualifiedType())) 273 return CanonicalType.getUnqualifiedType()->getAsBlockPointerType(); 274 return 0; 275 } 276 277 // If this is a typedef for a block pointer type, strip the typedef off 278 // without losing all typedef information. 279 return getDesugaredType()->getAsBlockPointerType(); 280} 281 282const ReferenceType *Type::getAsReferenceType() const { 283 // If this is directly a reference type, return it. 284 if (const ReferenceType *RTy = dyn_cast<ReferenceType>(this)) 285 return RTy; 286 287 // If the canonical form of this type isn't the right kind, reject it. 288 if (!isa<ReferenceType>(CanonicalType)) { 289 // Look through type qualifiers 290 if (isa<ReferenceType>(CanonicalType.getUnqualifiedType())) 291 return CanonicalType.getUnqualifiedType()->getAsReferenceType(); 292 return 0; 293 } 294 295 // If this is a typedef for a reference type, strip the typedef off without 296 // losing all typedef information. 297 return getDesugaredType()->getAsReferenceType(); 298} 299 300const MemberPointerType *Type::getAsMemberPointerType() const { 301 // If this is directly a member pointer type, return it. 302 if (const MemberPointerType *MTy = dyn_cast<MemberPointerType>(this)) 303 return MTy; 304 305 // If the canonical form of this type isn't the right kind, reject it. 306 if (!isa<MemberPointerType>(CanonicalType)) { 307 // Look through type qualifiers 308 if (isa<MemberPointerType>(CanonicalType.getUnqualifiedType())) 309 return CanonicalType.getUnqualifiedType()->getAsMemberPointerType(); 310 return 0; 311 } 312 313 // If this is a typedef for a member pointer type, strip the typedef off 314 // without losing all typedef information. 315 return getDesugaredType()->getAsMemberPointerType(); 316} 317 318/// isVariablyModifiedType (C99 6.7.5p3) - Return true for variable length 319/// array types and types that contain variable array types in their 320/// declarator 321bool Type::isVariablyModifiedType() const { 322 // A VLA is a variably modified type. 323 if (isVariableArrayType()) 324 return true; 325 326 // An array can contain a variably modified type 327 if (const Type *T = getArrayElementTypeNoTypeQual()) 328 return T->isVariablyModifiedType(); 329 330 // A pointer can point to a variably modified type. 331 // Also, C++ references and member pointers can point to a variably modified 332 // type, where VLAs appear as an extension to C++, and should be treated 333 // correctly. 334 if (const PointerLikeType *PT = getAsPointerLikeType()) 335 return PT->getPointeeType()->isVariablyModifiedType(); 336 if (const MemberPointerType *PT = getAsMemberPointerType()) 337 return PT->getPointeeType()->isVariablyModifiedType(); 338 339 // A function can return a variably modified type 340 // This one isn't completely obvious, but it follows from the 341 // definition in C99 6.7.5p3. Because of this rule, it's 342 // illegal to declare a function returning a variably modified type. 343 if (const FunctionType *FT = getAsFunctionType()) 344 return FT->getResultType()->isVariablyModifiedType(); 345 346 return false; 347} 348 349const RecordType *Type::getAsRecordType() const { 350 // If this is directly a reference type, return it. 351 if (const RecordType *RTy = dyn_cast<RecordType>(this)) 352 return RTy; 353 354 // If the canonical form of this type isn't the right kind, reject it. 355 if (!isa<RecordType>(CanonicalType)) { 356 // Look through type qualifiers 357 if (isa<RecordType>(CanonicalType.getUnqualifiedType())) 358 return CanonicalType.getUnqualifiedType()->getAsRecordType(); 359 return 0; 360 } 361 362 // If this is a typedef for a record type, strip the typedef off without 363 // losing all typedef information. 364 return getDesugaredType()->getAsRecordType(); 365} 366 367const RecordType *Type::getAsStructureType() const { 368 // If this is directly a structure type, return it. 369 if (const RecordType *RT = dyn_cast<RecordType>(this)) { 370 if (RT->getDecl()->isStruct()) 371 return RT; 372 } 373 374 // If the canonical form of this type isn't the right kind, reject it. 375 if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) { 376 if (!RT->getDecl()->isStruct()) 377 return 0; 378 379 // If this is a typedef for a structure type, strip the typedef off without 380 // losing all typedef information. 381 return getDesugaredType()->getAsStructureType(); 382 } 383 // Look through type qualifiers 384 if (isa<RecordType>(CanonicalType.getUnqualifiedType())) 385 return CanonicalType.getUnqualifiedType()->getAsStructureType(); 386 return 0; 387} 388 389const RecordType *Type::getAsUnionType() const { 390 // If this is directly a union type, return it. 391 if (const RecordType *RT = dyn_cast<RecordType>(this)) { 392 if (RT->getDecl()->isUnion()) 393 return RT; 394 } 395 396 // If the canonical form of this type isn't the right kind, reject it. 397 if (const RecordType *RT = dyn_cast<RecordType>(CanonicalType)) { 398 if (!RT->getDecl()->isUnion()) 399 return 0; 400 401 // If this is a typedef for a union type, strip the typedef off without 402 // losing all typedef information. 403 return getDesugaredType()->getAsUnionType(); 404 } 405 406 // Look through type qualifiers 407 if (isa<RecordType>(CanonicalType.getUnqualifiedType())) 408 return CanonicalType.getUnqualifiedType()->getAsUnionType(); 409 return 0; 410} 411 412const EnumType *Type::getAsEnumType() const { 413 // Check the canonicalized unqualified type directly; the more complex 414 // version is unnecessary because there isn't any typedef information 415 // to preserve. 416 return dyn_cast<EnumType>(CanonicalType.getUnqualifiedType()); 417} 418 419const ComplexType *Type::getAsComplexType() const { 420 // Are we directly a complex type? 421 if (const ComplexType *CTy = dyn_cast<ComplexType>(this)) 422 return CTy; 423 424 // If the canonical form of this type isn't the right kind, reject it. 425 if (!isa<ComplexType>(CanonicalType)) { 426 // Look through type qualifiers 427 if (isa<ComplexType>(CanonicalType.getUnqualifiedType())) 428 return CanonicalType.getUnqualifiedType()->getAsComplexType(); 429 return 0; 430 } 431 432 // If this is a typedef for a complex type, strip the typedef off without 433 // losing all typedef information. 434 return getDesugaredType()->getAsComplexType(); 435} 436 437const VectorType *Type::getAsVectorType() const { 438 // Are we directly a vector type? 439 if (const VectorType *VTy = dyn_cast<VectorType>(this)) 440 return VTy; 441 442 // If the canonical form of this type isn't the right kind, reject it. 443 if (!isa<VectorType>(CanonicalType)) { 444 // Look through type qualifiers 445 if (isa<VectorType>(CanonicalType.getUnqualifiedType())) 446 return CanonicalType.getUnqualifiedType()->getAsVectorType(); 447 return 0; 448 } 449 450 // If this is a typedef for a vector type, strip the typedef off without 451 // losing all typedef information. 452 return getDesugaredType()->getAsVectorType(); 453} 454 455const ExtVectorType *Type::getAsExtVectorType() const { 456 // Are we directly an OpenCU vector type? 457 if (const ExtVectorType *VTy = dyn_cast<ExtVectorType>(this)) 458 return VTy; 459 460 // If the canonical form of this type isn't the right kind, reject it. 461 if (!isa<ExtVectorType>(CanonicalType)) { 462 // Look through type qualifiers 463 if (isa<ExtVectorType>(CanonicalType.getUnqualifiedType())) 464 return CanonicalType.getUnqualifiedType()->getAsExtVectorType(); 465 return 0; 466 } 467 468 // If this is a typedef for an extended vector type, strip the typedef off 469 // without losing all typedef information. 470 return getDesugaredType()->getAsExtVectorType(); 471} 472 473const ObjCInterfaceType *Type::getAsObjCInterfaceType() const { 474 // There is no sugar for ObjCInterfaceType's, just return the canonical 475 // type pointer if it is the right class. There is no typedef information to 476 // return and these cannot be Address-space qualified. 477 return dyn_cast<ObjCInterfaceType>(CanonicalType); 478} 479 480const ObjCQualifiedInterfaceType * 481Type::getAsObjCQualifiedInterfaceType() const { 482 // There is no sugar for ObjCQualifiedInterfaceType's, just return the 483 // canonical type pointer if it is the right class. 484 return dyn_cast<ObjCQualifiedInterfaceType>(CanonicalType); 485} 486 487const ObjCQualifiedIdType *Type::getAsObjCQualifiedIdType() const { 488 // There is no sugar for ObjCQualifiedIdType's, just return the canonical 489 // type pointer if it is the right class. 490 return dyn_cast<ObjCQualifiedIdType>(CanonicalType); 491} 492 493const TemplateTypeParmType *Type::getAsTemplateTypeParmType() const { 494 // There is no sugar for template type parameters, so just return 495 // the canonical type pointer if it is the right class. 496 // FIXME: can these be address-space qualified? 497 return dyn_cast<TemplateTypeParmType>(CanonicalType); 498} 499 500const ClassTemplateSpecializationType * 501Type::getClassTemplateSpecializationType() const { 502 // There is no sugar for class template specialization types, so 503 // just return the canonical type pointer if it is the right class. 504 return dyn_cast<ClassTemplateSpecializationType>(CanonicalType); 505} 506 507 508bool Type::isIntegerType() const { 509 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 510 return BT->getKind() >= BuiltinType::Bool && 511 BT->getKind() <= BuiltinType::LongLong; 512 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 513 // Incomplete enum types are not treated as integer types. 514 // FIXME: In C++, enum types are never integer types. 515 if (TT->getDecl()->isEnum() && TT->getDecl()->isDefinition()) 516 return true; 517 if (isa<FixedWidthIntType>(CanonicalType)) 518 return true; 519 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 520 return VT->getElementType()->isIntegerType(); 521 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 522 return EXTQT->getBaseType()->isIntegerType(); 523 return false; 524} 525 526bool Type::isIntegralType() const { 527 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 528 return BT->getKind() >= BuiltinType::Bool && 529 BT->getKind() <= BuiltinType::LongLong; 530 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 531 if (TT->getDecl()->isEnum() && TT->getDecl()->isDefinition()) 532 return true; // Complete enum types are integral. 533 // FIXME: In C++, enum types are never integral. 534 if (isa<FixedWidthIntType>(CanonicalType)) 535 return true; 536 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 537 return EXTQT->getBaseType()->isIntegralType(); 538 return false; 539} 540 541bool Type::isEnumeralType() const { 542 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 543 return TT->getDecl()->isEnum(); 544 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 545 return EXTQT->getBaseType()->isEnumeralType(); 546 return false; 547} 548 549bool Type::isBooleanType() const { 550 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 551 return BT->getKind() == BuiltinType::Bool; 552 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 553 return EXTQT->getBaseType()->isBooleanType(); 554 return false; 555} 556 557bool Type::isCharType() const { 558 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 559 return BT->getKind() == BuiltinType::Char_U || 560 BT->getKind() == BuiltinType::UChar || 561 BT->getKind() == BuiltinType::Char_S || 562 BT->getKind() == BuiltinType::SChar; 563 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 564 return EXTQT->getBaseType()->isCharType(); 565 return false; 566} 567 568bool Type::isWideCharType() const { 569 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 570 return BT->getKind() == BuiltinType::WChar; 571 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 572 return EXTQT->getBaseType()->isWideCharType(); 573 return false; 574} 575 576/// isSignedIntegerType - Return true if this is an integer type that is 577/// signed, according to C99 6.2.5p4 [char, signed char, short, int, long..], 578/// an enum decl which has a signed representation, or a vector of signed 579/// integer element type. 580bool Type::isSignedIntegerType() const { 581 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) { 582 return BT->getKind() >= BuiltinType::Char_S && 583 BT->getKind() <= BuiltinType::LongLong; 584 } 585 586 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 587 return ET->getDecl()->getIntegerType()->isSignedIntegerType(); 588 589 if (const FixedWidthIntType *FWIT = 590 dyn_cast<FixedWidthIntType>(CanonicalType)) 591 return FWIT->isSigned(); 592 593 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 594 return VT->getElementType()->isSignedIntegerType(); 595 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 596 return EXTQT->getBaseType()->isSignedIntegerType(); 597 return false; 598} 599 600/// isUnsignedIntegerType - Return true if this is an integer type that is 601/// unsigned, according to C99 6.2.5p6 [which returns true for _Bool], an enum 602/// decl which has an unsigned representation, or a vector of unsigned integer 603/// element type. 604bool Type::isUnsignedIntegerType() const { 605 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) { 606 return BT->getKind() >= BuiltinType::Bool && 607 BT->getKind() <= BuiltinType::ULongLong; 608 } 609 610 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 611 return ET->getDecl()->getIntegerType()->isUnsignedIntegerType(); 612 613 if (const FixedWidthIntType *FWIT = 614 dyn_cast<FixedWidthIntType>(CanonicalType)) 615 return !FWIT->isSigned(); 616 617 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 618 return VT->getElementType()->isUnsignedIntegerType(); 619 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 620 return EXTQT->getBaseType()->isUnsignedIntegerType(); 621 return false; 622} 623 624bool Type::isFloatingType() const { 625 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 626 return BT->getKind() >= BuiltinType::Float && 627 BT->getKind() <= BuiltinType::LongDouble; 628 if (const ComplexType *CT = dyn_cast<ComplexType>(CanonicalType)) 629 return CT->getElementType()->isFloatingType(); 630 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 631 return VT->getElementType()->isFloatingType(); 632 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 633 return EXTQT->getBaseType()->isFloatingType(); 634 return false; 635} 636 637bool Type::isRealFloatingType() const { 638 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 639 return BT->getKind() >= BuiltinType::Float && 640 BT->getKind() <= BuiltinType::LongDouble; 641 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 642 return VT->getElementType()->isRealFloatingType(); 643 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 644 return EXTQT->getBaseType()->isRealFloatingType(); 645 return false; 646} 647 648bool Type::isRealType() const { 649 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 650 return BT->getKind() >= BuiltinType::Bool && 651 BT->getKind() <= BuiltinType::LongDouble; 652 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) 653 return TT->getDecl()->isEnum() && TT->getDecl()->isDefinition(); 654 if (isa<FixedWidthIntType>(CanonicalType)) 655 return true; 656 if (const VectorType *VT = dyn_cast<VectorType>(CanonicalType)) 657 return VT->getElementType()->isRealType(); 658 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 659 return EXTQT->getBaseType()->isRealType(); 660 return false; 661} 662 663bool Type::isArithmeticType() const { 664 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 665 return BT->getKind() >= BuiltinType::Bool && 666 BT->getKind() <= BuiltinType::LongDouble; 667 if (const EnumType *ET = dyn_cast<EnumType>(CanonicalType)) 668 // GCC allows forward declaration of enum types (forbid by C99 6.7.2.3p2). 669 // If a body isn't seen by the time we get here, return false. 670 return ET->getDecl()->isDefinition(); 671 if (isa<FixedWidthIntType>(CanonicalType)) 672 return true; 673 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 674 return EXTQT->getBaseType()->isArithmeticType(); 675 return isa<ComplexType>(CanonicalType) || isa<VectorType>(CanonicalType); 676} 677 678bool Type::isScalarType() const { 679 if (const BuiltinType *BT = dyn_cast<BuiltinType>(CanonicalType)) 680 return BT->getKind() != BuiltinType::Void; 681 if (const TagType *TT = dyn_cast<TagType>(CanonicalType)) { 682 // Enums are scalar types, but only if they are defined. Incomplete enums 683 // are not treated as scalar types. 684 if (TT->getDecl()->isEnum() && TT->getDecl()->isDefinition()) 685 return true; 686 return false; 687 } 688 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 689 return EXTQT->getBaseType()->isScalarType(); 690 if (isa<FixedWidthIntType>(CanonicalType)) 691 return true; 692 return isa<PointerType>(CanonicalType) || 693 isa<BlockPointerType>(CanonicalType) || 694 isa<MemberPointerType>(CanonicalType) || 695 isa<ComplexType>(CanonicalType) || 696 isa<ObjCQualifiedIdType>(CanonicalType); 697} 698 699/// \brief Determines whether the type is a C++ aggregate type or C 700/// aggregate or union type. 701/// 702/// An aggregate type is an array or a class type (struct, union, or 703/// class) that has no user-declared constructors, no private or 704/// protected non-static data members, no base classes, and no virtual 705/// functions (C++ [dcl.init.aggr]p1). The notion of an aggregate type 706/// subsumes the notion of C aggregates (C99 6.2.5p21) because it also 707/// includes union types. 708bool Type::isAggregateType() const { 709 if (const CXXRecordType *CXXClassType = dyn_cast<CXXRecordType>(CanonicalType)) 710 return CXXClassType->getDecl()->isAggregate(); 711 if (isa<RecordType>(CanonicalType)) 712 return true; 713 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 714 return EXTQT->getBaseType()->isAggregateType(); 715 return isa<ArrayType>(CanonicalType); 716} 717 718/// isConstantSizeType - Return true if this is not a variable sized type, 719/// according to the rules of C99 6.7.5p3. It is not legal to call this on 720/// incomplete types or dependent types. 721bool Type::isConstantSizeType() const { 722 if (const ExtQualType *EXTQT = dyn_cast<ExtQualType>(CanonicalType)) 723 return EXTQT->getBaseType()->isConstantSizeType(); 724 assert(!isIncompleteType() && "This doesn't make sense for incomplete types"); 725 assert(!isDependentType() && "This doesn't make sense for dependent types"); 726 // The VAT must have a size, as it is known to be complete. 727 return !isa<VariableArrayType>(CanonicalType); 728} 729 730/// isIncompleteType - Return true if this is an incomplete type (C99 6.2.5p1) 731/// - a type that can describe objects, but which lacks information needed to 732/// determine its size. 733bool Type::isIncompleteType() const { 734 switch (CanonicalType->getTypeClass()) { 735 default: return false; 736 case ExtQual: 737 return cast<ExtQualType>(CanonicalType)->getBaseType()->isIncompleteType(); 738 case Builtin: 739 // Void is the only incomplete builtin type. Per C99 6.2.5p19, it can never 740 // be completed. 741 return isVoidType(); 742 case Tagged: 743 // A tagged type (struct/union/enum/class) is incomplete if the decl is a 744 // forward declaration, but not a full definition (C99 6.2.5p22). 745 return !cast<TagType>(CanonicalType)->getDecl()->isDefinition(); 746 case IncompleteArray: 747 // An array of unknown size is an incomplete type (C99 6.2.5p22). 748 return true; 749 } 750} 751 752/// isPODType - Return true if this is a plain-old-data type (C++ 3.9p10) 753bool Type::isPODType() const { 754 // The compiler shouldn't query this for incomplete types, but the user might. 755 // We return false for that case. 756 if (isIncompleteType()) 757 return false; 758 759 switch (CanonicalType->getTypeClass()) { 760 // Everything not explicitly mentioned is not POD. 761 default: return false; 762 case ExtQual: 763 return cast<ExtQualType>(CanonicalType)->getBaseType()->isPODType(); 764 case VariableArray: 765 case ConstantArray: 766 // IncompleteArray is caught by isIncompleteType() above. 767 return cast<ArrayType>(CanonicalType)->getElementType()->isPODType(); 768 769 case Builtin: 770 case Complex: 771 case Pointer: 772 case MemberPointer: 773 case Vector: 774 case ExtVector: 775 case ObjCQualifiedId: 776 return true; 777 778 case Tagged: 779 if (isEnumeralType()) 780 return true; 781 if (CXXRecordDecl *RDecl = dyn_cast<CXXRecordDecl>( 782 cast<TagType>(CanonicalType)->getDecl())) 783 return RDecl->isPOD(); 784 // C struct/union is POD. 785 return true; 786 } 787} 788 789bool Type::isPromotableIntegerType() const { 790 if (const BuiltinType *BT = getAsBuiltinType()) 791 switch (BT->getKind()) { 792 case BuiltinType::Bool: 793 case BuiltinType::Char_S: 794 case BuiltinType::Char_U: 795 case BuiltinType::SChar: 796 case BuiltinType::UChar: 797 case BuiltinType::Short: 798 case BuiltinType::UShort: 799 return true; 800 default: 801 return false; 802 } 803 return false; 804} 805 806const char *BuiltinType::getName() const { 807 switch (getKind()) { 808 default: assert(0 && "Unknown builtin type!"); 809 case Void: return "void"; 810 case Bool: return "_Bool"; 811 case Char_S: return "char"; 812 case Char_U: return "char"; 813 case SChar: return "signed char"; 814 case Short: return "short"; 815 case Int: return "int"; 816 case Long: return "long"; 817 case LongLong: return "long long"; 818 case UChar: return "unsigned char"; 819 case UShort: return "unsigned short"; 820 case UInt: return "unsigned int"; 821 case ULong: return "unsigned long"; 822 case ULongLong: return "unsigned long long"; 823 case Float: return "float"; 824 case Double: return "double"; 825 case LongDouble: return "long double"; 826 case WChar: return "wchar_t"; 827 case Overload: return "<overloaded function type>"; 828 case Dependent: return "<dependent type>"; 829 } 830} 831 832void FunctionTypeProto::Profile(llvm::FoldingSetNodeID &ID, QualType Result, 833 arg_type_iterator ArgTys, 834 unsigned NumArgs, bool isVariadic, 835 unsigned TypeQuals) { 836 ID.AddPointer(Result.getAsOpaquePtr()); 837 for (unsigned i = 0; i != NumArgs; ++i) 838 ID.AddPointer(ArgTys[i].getAsOpaquePtr()); 839 ID.AddInteger(isVariadic); 840 ID.AddInteger(TypeQuals); 841} 842 843void FunctionTypeProto::Profile(llvm::FoldingSetNodeID &ID) { 844 Profile(ID, getResultType(), arg_type_begin(), NumArgs, isVariadic(), 845 getTypeQuals()); 846} 847 848void ObjCQualifiedInterfaceType::Profile(llvm::FoldingSetNodeID &ID, 849 const ObjCInterfaceDecl *Decl, 850 ObjCProtocolDecl **protocols, 851 unsigned NumProtocols) { 852 ID.AddPointer(Decl); 853 for (unsigned i = 0; i != NumProtocols; i++) 854 ID.AddPointer(protocols[i]); 855} 856 857void ObjCQualifiedInterfaceType::Profile(llvm::FoldingSetNodeID &ID) { 858 Profile(ID, getDecl(), &Protocols[0], getNumProtocols()); 859} 860 861void ObjCQualifiedIdType::Profile(llvm::FoldingSetNodeID &ID, 862 ObjCProtocolDecl **protocols, 863 unsigned NumProtocols) { 864 for (unsigned i = 0; i != NumProtocols; i++) 865 ID.AddPointer(protocols[i]); 866} 867 868void ObjCQualifiedIdType::Profile(llvm::FoldingSetNodeID &ID) { 869 Profile(ID, &Protocols[0], getNumProtocols()); 870} 871 872/// LookThroughTypedefs - Return the ultimate type this typedef corresponds to 873/// potentially looking through *all* consequtive typedefs. This returns the 874/// sum of the type qualifiers, so if you have: 875/// typedef const int A; 876/// typedef volatile A B; 877/// looking through the typedefs for B will give you "const volatile A". 878/// 879QualType TypedefType::LookThroughTypedefs() const { 880 // Usually, there is only a single level of typedefs, be fast in that case. 881 QualType FirstType = getDecl()->getUnderlyingType(); 882 if (!isa<TypedefType>(FirstType)) 883 return FirstType; 884 885 // Otherwise, do the fully general loop. 886 unsigned TypeQuals = 0; 887 const TypedefType *TDT = this; 888 while (1) { 889 QualType CurType = TDT->getDecl()->getUnderlyingType(); 890 891 892 /// FIXME: 893 /// FIXME: This is incorrect for ExtQuals! 894 /// FIXME: 895 TypeQuals |= CurType.getCVRQualifiers(); 896 897 TDT = dyn_cast<TypedefType>(CurType); 898 if (TDT == 0) 899 return QualType(CurType.getTypePtr(), TypeQuals); 900 } 901} 902 903TypeOfExpr::TypeOfExpr(Expr *E, QualType can) 904 : Type(TypeOfExp, can, E->isTypeDependent()), TOExpr(E) { 905 assert(!isa<TypedefType>(can) && "Invalid canonical type"); 906} 907 908bool RecordType::classof(const TagType *TT) { 909 return isa<RecordDecl>(TT->getDecl()); 910} 911 912bool CXXRecordType::classof(const TagType *TT) { 913 return isa<CXXRecordDecl>(TT->getDecl()); 914} 915 916bool EnumType::classof(const TagType *TT) { 917 return isa<EnumDecl>(TT->getDecl()); 918} 919 920void 921ClassTemplateSpecializationType:: 922packBooleanValues(unsigned NumArgs, bool *Values, uintptr_t *Words) { 923 const unsigned BitsPerWord = sizeof(uintptr_t) * 8; 924 925 for (unsigned PW = 0, NumPackedWords = getNumPackedWords(NumArgs), Arg = 0; 926 PW != NumPackedWords; ++PW) { 927 uintptr_t Word = 0; 928 for (unsigned Bit = 0; Bit < BitsPerWord && Arg < NumArgs; ++Bit, ++Arg) { 929 Word <<= 1; 930 Word |= Values[Arg]; 931 } 932 Words[PW] = Word; 933 } 934} 935 936ClassTemplateSpecializationType:: 937ClassTemplateSpecializationType(TemplateDecl *T, unsigned NumArgs, 938 uintptr_t *Args, bool *ArgIsType, 939 QualType Canon) 940 : Type(ClassTemplateSpecialization, Canon, /*FIXME:Dependent=*/false), 941 Template(T), NumArgs(NumArgs) 942{ 943 uintptr_t *Data = reinterpret_cast<uintptr_t *>(this + 1); 944 945 // Pack the argument-is-type values into the words just after the 946 // class template specialization type. 947 packBooleanValues(NumArgs, ArgIsType, Data); 948 949 // Copy the template arguments after the packed words. 950 Data += getNumPackedWords(NumArgs); 951 for (unsigned Arg = 0; Arg < NumArgs; ++Arg) 952 Data[Arg] = Args[Arg]; 953} 954 955void ClassTemplateSpecializationType::Destroy(ASTContext& C) { 956 for (unsigned Arg = 0; Arg < NumArgs; ++Arg) 957 if (!isArgType(Arg)) 958 getArgAsExpr(Arg)->Destroy(C); 959} 960 961uintptr_t 962ClassTemplateSpecializationType::getArgAsOpaqueValue(unsigned Arg) const { 963 const uintptr_t *Data = reinterpret_cast<const uintptr_t *>(this + 1); 964 Data += getNumPackedWords(NumArgs); 965 return Data[Arg]; 966} 967 968bool ClassTemplateSpecializationType::isArgType(unsigned Arg) const { 969 const unsigned BitsPerWord = sizeof(uintptr_t) * 8; 970 const uintptr_t *Data = reinterpret_cast<const uintptr_t *>(this + 1); 971 Data += Arg / BitsPerWord; 972 return (*Data >> ((NumArgs - Arg) % BitsPerWord - 1)) & 0x01; 973} 974 975//===----------------------------------------------------------------------===// 976// Type Printing 977//===----------------------------------------------------------------------===// 978 979void QualType::dump(const char *msg) const { 980 std::string R = "identifier"; 981 getAsStringInternal(R); 982 if (msg) 983 fprintf(stderr, "%s: %s\n", msg, R.c_str()); 984 else 985 fprintf(stderr, "%s\n", R.c_str()); 986} 987void QualType::dump() const { 988 dump(""); 989} 990 991void Type::dump() const { 992 std::string S = "identifier"; 993 getAsStringInternal(S); 994 fprintf(stderr, "%s\n", S.c_str()); 995} 996 997 998 999static void AppendTypeQualList(std::string &S, unsigned TypeQuals) { 1000 // Note: funkiness to ensure we get a space only between quals. 1001 bool NonePrinted = true; 1002 if (TypeQuals & QualType::Const) 1003 S += "const", NonePrinted = false; 1004 if (TypeQuals & QualType::Volatile) 1005 S += (NonePrinted+" volatile"), NonePrinted = false; 1006 if (TypeQuals & QualType::Restrict) 1007 S += (NonePrinted+" restrict"), NonePrinted = false; 1008} 1009 1010void QualType::getAsStringInternal(std::string &S) const { 1011 if (isNull()) { 1012 S += "NULL TYPE"; 1013 return; 1014 } 1015 1016 // Print qualifiers as appropriate. 1017 if (unsigned Tq = getCVRQualifiers()) { 1018 std::string TQS; 1019 AppendTypeQualList(TQS, Tq); 1020 if (!S.empty()) 1021 S = TQS + ' ' + S; 1022 else 1023 S = TQS; 1024 } 1025 1026 getTypePtr()->getAsStringInternal(S); 1027} 1028 1029void BuiltinType::getAsStringInternal(std::string &S) const { 1030 if (S.empty()) { 1031 S = getName(); 1032 } else { 1033 // Prefix the basic type, e.g. 'int X'. 1034 S = ' ' + S; 1035 S = getName() + S; 1036 } 1037} 1038 1039void FixedWidthIntType::getAsStringInternal(std::string &S) const { 1040 // FIXME: Once we get bitwidth attribute, write as 1041 // "int __attribute__((bitwidth(x)))". 1042 std::string prefix = "__clang_fixedwidth"; 1043 prefix += llvm::utostr_32(Width); 1044 prefix += (char)(Signed ? 'S' : 'U'); 1045 if (S.empty()) { 1046 S = prefix; 1047 } else { 1048 // Prefix the basic type, e.g. 'int X'. 1049 S = prefix + S; 1050 } 1051} 1052 1053 1054void ComplexType::getAsStringInternal(std::string &S) const { 1055 ElementType->getAsStringInternal(S); 1056 S = "_Complex " + S; 1057} 1058 1059void ExtQualType::getAsStringInternal(std::string &S) const { 1060 bool NeedsSpace = false; 1061 if (AddressSpace) { 1062 S = "__attribute__((address_space("+llvm::utostr_32(AddressSpace)+")))" + S; 1063 NeedsSpace = true; 1064 } 1065 if (GCAttrType != QualType::GCNone) { 1066 if (NeedsSpace) 1067 S += ' '; 1068 S += "__attribute__((objc_gc("; 1069 if (GCAttrType == QualType::Weak) 1070 S += "weak"; 1071 else 1072 S += "strong"; 1073 S += ")))"; 1074 } 1075 BaseType->getAsStringInternal(S); 1076} 1077 1078void PointerType::getAsStringInternal(std::string &S) const { 1079 S = '*' + S; 1080 1081 // Handle things like 'int (*A)[4];' correctly. 1082 // FIXME: this should include vectors, but vectors use attributes I guess. 1083 if (isa<ArrayType>(getPointeeType())) 1084 S = '(' + S + ')'; 1085 1086 getPointeeType().getAsStringInternal(S); 1087} 1088 1089void BlockPointerType::getAsStringInternal(std::string &S) const { 1090 S = '^' + S; 1091 PointeeType.getAsStringInternal(S); 1092} 1093 1094void ReferenceType::getAsStringInternal(std::string &S) const { 1095 S = '&' + S; 1096 1097 // Handle things like 'int (&A)[4];' correctly. 1098 // FIXME: this should include vectors, but vectors use attributes I guess. 1099 if (isa<ArrayType>(getPointeeType())) 1100 S = '(' + S + ')'; 1101 1102 getPointeeType().getAsStringInternal(S); 1103} 1104 1105void MemberPointerType::getAsStringInternal(std::string &S) const { 1106 std::string C; 1107 Class->getAsStringInternal(C); 1108 C += "::*"; 1109 S = C + S; 1110 1111 // Handle things like 'int (&A)[4];' correctly. 1112 // FIXME: this should include vectors, but vectors use attributes I guess. 1113 if (isa<ArrayType>(getPointeeType())) 1114 S = '(' + S + ')'; 1115 1116 getPointeeType().getAsStringInternal(S); 1117} 1118 1119void ConstantArrayType::getAsStringInternal(std::string &S) const { 1120 S += '['; 1121 S += llvm::utostr(getSize().getZExtValue()); 1122 S += ']'; 1123 1124 getElementType().getAsStringInternal(S); 1125} 1126 1127void IncompleteArrayType::getAsStringInternal(std::string &S) const { 1128 S += "[]"; 1129 1130 getElementType().getAsStringInternal(S); 1131} 1132 1133void VariableArrayType::getAsStringInternal(std::string &S) const { 1134 S += '['; 1135 1136 if (getIndexTypeQualifier()) { 1137 AppendTypeQualList(S, getIndexTypeQualifier()); 1138 S += ' '; 1139 } 1140 1141 if (getSizeModifier() == Static) 1142 S += "static"; 1143 else if (getSizeModifier() == Star) 1144 S += '*'; 1145 1146 if (getSizeExpr()) { 1147 std::string SStr; 1148 llvm::raw_string_ostream s(SStr); 1149 getSizeExpr()->printPretty(s); 1150 S += s.str(); 1151 } 1152 S += ']'; 1153 1154 getElementType().getAsStringInternal(S); 1155} 1156 1157void DependentSizedArrayType::getAsStringInternal(std::string &S) const { 1158 S += '['; 1159 1160 if (getIndexTypeQualifier()) { 1161 AppendTypeQualList(S, getIndexTypeQualifier()); 1162 S += ' '; 1163 } 1164 1165 if (getSizeModifier() == Static) 1166 S += "static"; 1167 else if (getSizeModifier() == Star) 1168 S += '*'; 1169 1170 if (getSizeExpr()) { 1171 std::string SStr; 1172 llvm::raw_string_ostream s(SStr); 1173 getSizeExpr()->printPretty(s); 1174 S += s.str(); 1175 } 1176 S += ']'; 1177 1178 getElementType().getAsStringInternal(S); 1179} 1180 1181void VectorType::getAsStringInternal(std::string &S) const { 1182 // FIXME: We prefer to print the size directly here, but have no way 1183 // to get the size of the type. 1184 S += " __attribute__((__vector_size__("; 1185 S += llvm::utostr_32(NumElements); // convert back to bytes. 1186 S += " * sizeof(" + ElementType.getAsString() + "))))"; 1187} 1188 1189void ExtVectorType::getAsStringInternal(std::string &S) const { 1190 S += " __attribute__((ext_vector_type("; 1191 S += llvm::utostr_32(NumElements); 1192 S += ")))"; 1193 ElementType.getAsStringInternal(S); 1194} 1195 1196void TypeOfExpr::getAsStringInternal(std::string &InnerString) const { 1197 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typeof(e) X'. 1198 InnerString = ' ' + InnerString; 1199 std::string Str; 1200 llvm::raw_string_ostream s(Str); 1201 getUnderlyingExpr()->printPretty(s); 1202 InnerString = "typeof(" + s.str() + ")" + InnerString; 1203} 1204 1205void TypeOfType::getAsStringInternal(std::string &InnerString) const { 1206 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typeof(t) X'. 1207 InnerString = ' ' + InnerString; 1208 std::string Tmp; 1209 getUnderlyingType().getAsStringInternal(Tmp); 1210 InnerString = "typeof(" + Tmp + ")" + InnerString; 1211} 1212 1213void FunctionTypeNoProto::getAsStringInternal(std::string &S) const { 1214 // If needed for precedence reasons, wrap the inner part in grouping parens. 1215 if (!S.empty()) 1216 S = "(" + S + ")"; 1217 1218 S += "()"; 1219 getResultType().getAsStringInternal(S); 1220} 1221 1222void FunctionTypeProto::getAsStringInternal(std::string &S) const { 1223 // If needed for precedence reasons, wrap the inner part in grouping parens. 1224 if (!S.empty()) 1225 S = "(" + S + ")"; 1226 1227 S += "("; 1228 std::string Tmp; 1229 for (unsigned i = 0, e = getNumArgs(); i != e; ++i) { 1230 if (i) S += ", "; 1231 getArgType(i).getAsStringInternal(Tmp); 1232 S += Tmp; 1233 Tmp.clear(); 1234 } 1235 1236 if (isVariadic()) { 1237 if (getNumArgs()) 1238 S += ", "; 1239 S += "..."; 1240 } else if (getNumArgs() == 0) { 1241 // Do not emit int() if we have a proto, emit 'int(void)'. 1242 S += "void"; 1243 } 1244 1245 S += ")"; 1246 getResultType().getAsStringInternal(S); 1247} 1248 1249 1250void TypedefType::getAsStringInternal(std::string &InnerString) const { 1251 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 1252 InnerString = ' ' + InnerString; 1253 InnerString = getDecl()->getIdentifier()->getName() + InnerString; 1254} 1255 1256void TemplateTypeParmType::getAsStringInternal(std::string &InnerString) const { 1257 if (!InnerString.empty()) // Prefix the basic type, e.g. 'parmname X'. 1258 InnerString = ' ' + InnerString; 1259 1260 if (!Name) 1261 InnerString = "type-parameter-" + llvm::utostr_32(Depth) + '-' + 1262 llvm::utostr_32(Index) + InnerString; 1263 else 1264 InnerString = Name->getName() + InnerString; 1265} 1266 1267void 1268ClassTemplateSpecializationType:: 1269getAsStringInternal(std::string &InnerString) const { 1270 std::string SpecString = Template->getNameAsString(); 1271 SpecString += '<'; 1272 for (unsigned Arg = 0; Arg < NumArgs; ++Arg) { 1273 if (Arg) 1274 SpecString += ", "; 1275 1276 // Print the argument into a string. 1277 std::string ArgString; 1278 if (isArgType(Arg)) 1279 getArgAsType(Arg).getAsStringInternal(ArgString); 1280 else { 1281 llvm::raw_string_ostream s(ArgString); 1282 getArgAsExpr(Arg)->printPretty(s); 1283 } 1284 1285 // If this is the first argument and its string representation 1286 // begins with the global scope specifier ('::foo'), add a space 1287 // to avoid printing the diagraph '<:'. 1288 if (!Arg && !ArgString.empty() && ArgString[0] == ':') 1289 SpecString += ' '; 1290 1291 SpecString += ArgString; 1292 } 1293 1294 // If the last character of our string is '>', add another space to 1295 // keep the two '>''s separate tokens. We don't *have* to do this in 1296 // C++0x, but it's still good hygiene. 1297 if (SpecString[SpecString.size() - 1] == '>') 1298 SpecString += ' '; 1299 1300 SpecString += '>'; 1301 1302 if (InnerString.empty()) 1303 InnerString.swap(SpecString); 1304 else 1305 InnerString = SpecString + ' ' + InnerString; 1306} 1307 1308void ObjCInterfaceType::getAsStringInternal(std::string &InnerString) const { 1309 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 1310 InnerString = ' ' + InnerString; 1311 InnerString = getDecl()->getIdentifier()->getName() + InnerString; 1312} 1313 1314void ObjCQualifiedInterfaceType::getAsStringInternal( 1315 std::string &InnerString) const { 1316 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 1317 InnerString = ' ' + InnerString; 1318 std::string ObjCQIString = getDecl()->getNameAsString(); 1319 ObjCQIString += '<'; 1320 bool isFirst = true; 1321 for (qual_iterator I = qual_begin(), E = qual_end(); I != E; ++I) { 1322 if (isFirst) 1323 isFirst = false; 1324 else 1325 ObjCQIString += ','; 1326 ObjCQIString += (*I)->getNameAsString(); 1327 } 1328 ObjCQIString += '>'; 1329 InnerString = ObjCQIString + InnerString; 1330} 1331 1332void ObjCQualifiedIdType::getAsStringInternal(std::string &InnerString) const { 1333 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 1334 InnerString = ' ' + InnerString; 1335 std::string ObjCQIString = "id"; 1336 ObjCQIString += '<'; 1337 int num = getNumProtocols(); 1338 for (int i = 0; i < num; i++) { 1339 ObjCQIString += getProtocols(i)->getNameAsString(); 1340 if (i < num-1) 1341 ObjCQIString += ','; 1342 } 1343 ObjCQIString += '>'; 1344 InnerString = ObjCQIString + InnerString; 1345} 1346 1347void TagType::getAsStringInternal(std::string &InnerString) const { 1348 if (!InnerString.empty()) // Prefix the basic type, e.g. 'typedefname X'. 1349 InnerString = ' ' + InnerString; 1350 1351 const char *Kind = getDecl()->getKindName(); 1352 const char *ID; 1353 if (const IdentifierInfo *II = getDecl()->getIdentifier()) 1354 ID = II->getName(); 1355 else 1356 ID = "<anonymous>"; 1357 1358 InnerString = std::string(Kind) + " " + ID + InnerString; 1359} 1360