DeclSpec.h revision aa4a99b4a62615db243f7a5c433169f2fc704420
1//===--- DeclSpec.h - Parsed declaration specifiers -------------*- C++ -*-===// 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 defines the classes used to store parsed information about 11// declaration-specifiers and declarators. 12// 13// static const int volatile x, *y, *(*(*z)[10])(const void *x); 14// ------------------------- - -- --------------------------- 15// declaration-specifiers \ | / 16// declarators 17// 18//===----------------------------------------------------------------------===// 19 20#ifndef LLVM_CLANG_SEMA_DECLSPEC_H 21#define LLVM_CLANG_SEMA_DECLSPEC_H 22 23#include "clang/Sema/AttributeList.h" 24#include "clang/Sema/Ownership.h" 25#include "clang/AST/NestedNameSpecifier.h" 26#include "clang/Lex/Token.h" 27#include "clang/Basic/ExceptionSpecificationType.h" 28#include "clang/Basic/OperatorKinds.h" 29#include "clang/Basic/Specifiers.h" 30#include "llvm/ADT/SmallVector.h" 31#include "llvm/Support/ErrorHandling.h" 32 33namespace clang { 34 class ASTContext; 35 class TypeLoc; 36 class LangOptions; 37 class DiagnosticsEngine; 38 class IdentifierInfo; 39 class NamespaceAliasDecl; 40 class NamespaceDecl; 41 class NestedNameSpecifier; 42 class NestedNameSpecifierLoc; 43 class ObjCDeclSpec; 44 class Preprocessor; 45 class Sema; 46 class Declarator; 47 struct TemplateIdAnnotation; 48 49/// CXXScopeSpec - Represents a C++ nested-name-specifier or a global scope 50/// specifier. These can be in 3 states: 51/// 1) Not present, identified by isEmpty() 52/// 2) Present, identified by isNotEmpty() 53/// 2.a) Valid, idenified by isValid() 54/// 2.b) Invalid, identified by isInvalid(). 55/// 56/// isSet() is deprecated because it mostly corresponded to "valid" but was 57/// often used as if it meant "present". 58/// 59/// The actual scope is described by getScopeRep(). 60class CXXScopeSpec { 61 SourceRange Range; 62 NestedNameSpecifierLocBuilder Builder; 63 64public: 65 const SourceRange &getRange() const { return Range; } 66 void setRange(const SourceRange &R) { Range = R; } 67 void setBeginLoc(SourceLocation Loc) { Range.setBegin(Loc); } 68 void setEndLoc(SourceLocation Loc) { Range.setEnd(Loc); } 69 SourceLocation getBeginLoc() const { return Range.getBegin(); } 70 SourceLocation getEndLoc() const { return Range.getEnd(); } 71 72 /// \brief Retrieve the representation of the nested-name-specifier. 73 NestedNameSpecifier *getScopeRep() const { 74 return Builder.getRepresentation(); 75 } 76 77 /// \brief Extend the current nested-name-specifier by another 78 /// nested-name-specifier component of the form 'type::'. 79 /// 80 /// \param Context The AST context in which this nested-name-specifier 81 /// resides. 82 /// 83 /// \param TemplateKWLoc The location of the 'template' keyword, if present. 84 /// 85 /// \param TL The TypeLoc that describes the type preceding the '::'. 86 /// 87 /// \param ColonColonLoc The location of the trailing '::'. 88 void Extend(ASTContext &Context, SourceLocation TemplateKWLoc, TypeLoc TL, 89 SourceLocation ColonColonLoc); 90 91 /// \brief Extend the current nested-name-specifier by another 92 /// nested-name-specifier component of the form 'identifier::'. 93 /// 94 /// \param Context The AST context in which this nested-name-specifier 95 /// resides. 96 /// 97 /// \param Identifier The identifier. 98 /// 99 /// \param IdentifierLoc The location of the identifier. 100 /// 101 /// \param ColonColonLoc The location of the trailing '::'. 102 void Extend(ASTContext &Context, IdentifierInfo *Identifier, 103 SourceLocation IdentifierLoc, SourceLocation ColonColonLoc); 104 105 /// \brief Extend the current nested-name-specifier by another 106 /// nested-name-specifier component of the form 'namespace::'. 107 /// 108 /// \param Context The AST context in which this nested-name-specifier 109 /// resides. 110 /// 111 /// \param Namespace The namespace. 112 /// 113 /// \param NamespaceLoc The location of the namespace name. 114 /// 115 /// \param ColonColonLoc The location of the trailing '::'. 116 void Extend(ASTContext &Context, NamespaceDecl *Namespace, 117 SourceLocation NamespaceLoc, SourceLocation ColonColonLoc); 118 119 /// \brief Extend the current nested-name-specifier by another 120 /// nested-name-specifier component of the form 'namespace-alias::'. 121 /// 122 /// \param Context The AST context in which this nested-name-specifier 123 /// resides. 124 /// 125 /// \param Alias The namespace alias. 126 /// 127 /// \param AliasLoc The location of the namespace alias 128 /// name. 129 /// 130 /// \param ColonColonLoc The location of the trailing '::'. 131 void Extend(ASTContext &Context, NamespaceAliasDecl *Alias, 132 SourceLocation AliasLoc, SourceLocation ColonColonLoc); 133 134 /// \brief Turn this (empty) nested-name-specifier into the global 135 /// nested-name-specifier '::'. 136 void MakeGlobal(ASTContext &Context, SourceLocation ColonColonLoc); 137 138 /// \brief Make a new nested-name-specifier from incomplete source-location 139 /// information. 140 /// 141 /// FIXME: This routine should be used very, very rarely, in cases where we 142 /// need to synthesize a nested-name-specifier. Most code should instead use 143 /// \c Adopt() with a proper \c NestedNameSpecifierLoc. 144 void MakeTrivial(ASTContext &Context, NestedNameSpecifier *Qualifier, 145 SourceRange R); 146 147 /// \brief Adopt an existing nested-name-specifier (with source-range 148 /// information). 149 void Adopt(NestedNameSpecifierLoc Other); 150 151 /// \brief Retrieve a nested-name-specifier with location information, copied 152 /// into the given AST context. 153 /// 154 /// \param Context The context into which this nested-name-specifier will be 155 /// copied. 156 NestedNameSpecifierLoc getWithLocInContext(ASTContext &Context) const; 157 158 /// \brief Retrieve the location of the name in the last qualifier 159 /// in this nested name specifier. For example: 160 /// ::foo::bar<0>:: 161 /// ^~~ 162 SourceLocation getLastQualifierNameLoc() const; 163 164 /// No scope specifier. 165 bool isEmpty() const { return !Range.isValid(); } 166 /// A scope specifier is present, but may be valid or invalid. 167 bool isNotEmpty() const { return !isEmpty(); } 168 169 /// An error occurred during parsing of the scope specifier. 170 bool isInvalid() const { return isNotEmpty() && getScopeRep() == 0; } 171 /// A scope specifier is present, and it refers to a real scope. 172 bool isValid() const { return isNotEmpty() && getScopeRep() != 0; } 173 174 /// \brief Indicate that this nested-name-specifier is invalid. 175 void SetInvalid(SourceRange R) { 176 assert(R.isValid() && "Must have a valid source range"); 177 if (Range.getBegin().isInvalid()) 178 Range.setBegin(R.getBegin()); 179 Range.setEnd(R.getEnd()); 180 Builder.Clear(); 181 } 182 183 /// Deprecated. Some call sites intend isNotEmpty() while others intend 184 /// isValid(). 185 bool isSet() const { return getScopeRep() != 0; } 186 187 void clear() { 188 Range = SourceRange(); 189 Builder.Clear(); 190 } 191 192 /// \brief Retrieve the data associated with the source-location information. 193 char *location_data() const { return Builder.getBuffer().first; } 194 195 /// \brief Retrieve the size of the data associated with source-location 196 /// information. 197 unsigned location_size() const { return Builder.getBuffer().second; } 198}; 199 200/// DeclSpec - This class captures information about "declaration specifiers", 201/// which encompasses storage-class-specifiers, type-specifiers, 202/// type-qualifiers, and function-specifiers. 203class DeclSpec { 204public: 205 // storage-class-specifier 206 // Note: The order of these enumerators is important for diagnostics. 207 enum SCS { 208 SCS_unspecified = 0, 209 SCS_typedef, 210 SCS_extern, 211 SCS_static, 212 SCS_auto, 213 SCS_register, 214 SCS_private_extern, 215 SCS_mutable 216 }; 217 218 // Import type specifier width enumeration and constants. 219 typedef TypeSpecifierWidth TSW; 220 static const TSW TSW_unspecified = clang::TSW_unspecified; 221 static const TSW TSW_short = clang::TSW_short; 222 static const TSW TSW_long = clang::TSW_long; 223 static const TSW TSW_longlong = clang::TSW_longlong; 224 225 enum TSC { 226 TSC_unspecified, 227 TSC_imaginary, 228 TSC_complex 229 }; 230 231 // Import type specifier sign enumeration and constants. 232 typedef TypeSpecifierSign TSS; 233 static const TSS TSS_unspecified = clang::TSS_unspecified; 234 static const TSS TSS_signed = clang::TSS_signed; 235 static const TSS TSS_unsigned = clang::TSS_unsigned; 236 237 // Import type specifier type enumeration and constants. 238 typedef TypeSpecifierType TST; 239 static const TST TST_unspecified = clang::TST_unspecified; 240 static const TST TST_void = clang::TST_void; 241 static const TST TST_char = clang::TST_char; 242 static const TST TST_wchar = clang::TST_wchar; 243 static const TST TST_char16 = clang::TST_char16; 244 static const TST TST_char32 = clang::TST_char32; 245 static const TST TST_int = clang::TST_int; 246 static const TST TST_half = clang::TST_half; 247 static const TST TST_float = clang::TST_float; 248 static const TST TST_double = clang::TST_double; 249 static const TST TST_bool = clang::TST_bool; 250 static const TST TST_decimal32 = clang::TST_decimal32; 251 static const TST TST_decimal64 = clang::TST_decimal64; 252 static const TST TST_decimal128 = clang::TST_decimal128; 253 static const TST TST_enum = clang::TST_enum; 254 static const TST TST_union = clang::TST_union; 255 static const TST TST_struct = clang::TST_struct; 256 static const TST TST_class = clang::TST_class; 257 static const TST TST_typename = clang::TST_typename; 258 static const TST TST_typeofType = clang::TST_typeofType; 259 static const TST TST_typeofExpr = clang::TST_typeofExpr; 260 static const TST TST_decltype = clang::TST_decltype; 261 static const TST TST_underlyingType = clang::TST_underlyingType; 262 static const TST TST_auto = clang::TST_auto; 263 static const TST TST_unknown_anytype = clang::TST_unknown_anytype; 264 static const TST TST_atomic = clang::TST_atomic; 265 static const TST TST_error = clang::TST_error; 266 267 // type-qualifiers 268 enum TQ { // NOTE: These flags must be kept in sync with Qualifiers::TQ. 269 TQ_unspecified = 0, 270 TQ_const = 1, 271 TQ_restrict = 2, 272 TQ_volatile = 4 273 }; 274 275 /// ParsedSpecifiers - Flags to query which specifiers were applied. This is 276 /// returned by getParsedSpecifiers. 277 enum ParsedSpecifiers { 278 PQ_None = 0, 279 PQ_StorageClassSpecifier = 1, 280 PQ_TypeSpecifier = 2, 281 PQ_TypeQualifier = 4, 282 PQ_FunctionSpecifier = 8 283 }; 284 285private: 286 // storage-class-specifier 287 /*SCS*/unsigned StorageClassSpec : 3; 288 unsigned SCS_thread_specified : 1; 289 unsigned SCS_extern_in_linkage_spec : 1; 290 291 // type-specifier 292 /*TSW*/unsigned TypeSpecWidth : 2; 293 /*TSC*/unsigned TypeSpecComplex : 2; 294 /*TSS*/unsigned TypeSpecSign : 2; 295 /*TST*/unsigned TypeSpecType : 5; 296 unsigned TypeAltiVecVector : 1; 297 unsigned TypeAltiVecPixel : 1; 298 unsigned TypeAltiVecBool : 1; 299 unsigned TypeSpecOwned : 1; 300 301 // type-qualifiers 302 unsigned TypeQualifiers : 3; // Bitwise OR of TQ. 303 304 // function-specifier 305 unsigned FS_inline_specified : 1; 306 unsigned FS_virtual_specified : 1; 307 unsigned FS_explicit_specified : 1; 308 309 // friend-specifier 310 unsigned Friend_specified : 1; 311 312 // constexpr-specifier 313 unsigned Constexpr_specified : 1; 314 315 /*SCS*/unsigned StorageClassSpecAsWritten : 3; 316 317 union { 318 UnionParsedType TypeRep; 319 Decl *DeclRep; 320 Expr *ExprRep; 321 }; 322 323 // attributes. 324 ParsedAttributes Attrs; 325 326 // Scope specifier for the type spec, if applicable. 327 CXXScopeSpec TypeScope; 328 329 // List of protocol qualifiers for objective-c classes. Used for 330 // protocol-qualified interfaces "NString<foo>" and protocol-qualified id 331 // "id<foo>". 332 Decl * const *ProtocolQualifiers; 333 unsigned NumProtocolQualifiers; 334 SourceLocation ProtocolLAngleLoc; 335 SourceLocation *ProtocolLocs; 336 337 // SourceLocation info. These are null if the item wasn't specified or if 338 // the setting was synthesized. 339 SourceRange Range; 340 341 SourceLocation StorageClassSpecLoc, SCS_threadLoc; 342 SourceLocation TSWLoc, TSCLoc, TSSLoc, TSTLoc, AltiVecLoc; 343 /// TSTNameLoc - If TypeSpecType is any of class, enum, struct, union, 344 /// typename, then this is the location of the named type (if present); 345 /// otherwise, it is the same as TSTLoc. Hence, the pair TSTLoc and 346 /// TSTNameLoc provides source range info for tag types. 347 SourceLocation TSTNameLoc; 348 SourceRange TypeofParensRange; 349 SourceLocation TQ_constLoc, TQ_restrictLoc, TQ_volatileLoc; 350 SourceLocation FS_inlineLoc, FS_virtualLoc, FS_explicitLoc; 351 SourceLocation FriendLoc, ModulePrivateLoc, ConstexprLoc; 352 353 WrittenBuiltinSpecs writtenBS; 354 void SaveWrittenBuiltinSpecs(); 355 void SaveStorageSpecifierAsWritten(); 356 357 ObjCDeclSpec *ObjCQualifiers; 358 359 static bool isTypeRep(TST T) { 360 return (T == TST_typename || T == TST_typeofType || 361 T == TST_underlyingType || T == TST_atomic); 362 } 363 static bool isExprRep(TST T) { 364 return (T == TST_typeofExpr || T == TST_decltype); 365 } 366 static bool isDeclRep(TST T) { 367 return (T == TST_enum || T == TST_struct || 368 T == TST_union || T == TST_class); 369 } 370 371 DeclSpec(const DeclSpec&); // DO NOT IMPLEMENT 372 void operator=(const DeclSpec&); // DO NOT IMPLEMENT 373public: 374 375 DeclSpec(AttributeFactory &attrFactory) 376 : StorageClassSpec(SCS_unspecified), 377 SCS_thread_specified(false), 378 SCS_extern_in_linkage_spec(false), 379 TypeSpecWidth(TSW_unspecified), 380 TypeSpecComplex(TSC_unspecified), 381 TypeSpecSign(TSS_unspecified), 382 TypeSpecType(TST_unspecified), 383 TypeAltiVecVector(false), 384 TypeAltiVecPixel(false), 385 TypeAltiVecBool(false), 386 TypeSpecOwned(false), 387 TypeQualifiers(TQ_unspecified), 388 FS_inline_specified(false), 389 FS_virtual_specified(false), 390 FS_explicit_specified(false), 391 Friend_specified(false), 392 Constexpr_specified(false), 393 StorageClassSpecAsWritten(SCS_unspecified), 394 Attrs(attrFactory), 395 ProtocolQualifiers(0), 396 NumProtocolQualifiers(0), 397 ProtocolLocs(0), 398 writtenBS(), 399 ObjCQualifiers(0) { 400 } 401 ~DeclSpec() { 402 delete [] ProtocolQualifiers; 403 delete [] ProtocolLocs; 404 } 405 // storage-class-specifier 406 SCS getStorageClassSpec() const { return (SCS)StorageClassSpec; } 407 bool isThreadSpecified() const { return SCS_thread_specified; } 408 bool isExternInLinkageSpec() const { return SCS_extern_in_linkage_spec; } 409 void setExternInLinkageSpec(bool Value) { 410 SCS_extern_in_linkage_spec = Value; 411 } 412 413 SourceLocation getStorageClassSpecLoc() const { return StorageClassSpecLoc; } 414 SourceLocation getThreadSpecLoc() const { return SCS_threadLoc; } 415 416 void ClearStorageClassSpecs() { 417 StorageClassSpec = DeclSpec::SCS_unspecified; 418 SCS_thread_specified = false; 419 SCS_extern_in_linkage_spec = false; 420 StorageClassSpecLoc = SourceLocation(); 421 SCS_threadLoc = SourceLocation(); 422 } 423 424 // type-specifier 425 TSW getTypeSpecWidth() const { return (TSW)TypeSpecWidth; } 426 TSC getTypeSpecComplex() const { return (TSC)TypeSpecComplex; } 427 TSS getTypeSpecSign() const { return (TSS)TypeSpecSign; } 428 TST getTypeSpecType() const { return (TST)TypeSpecType; } 429 bool isTypeAltiVecVector() const { return TypeAltiVecVector; } 430 bool isTypeAltiVecPixel() const { return TypeAltiVecPixel; } 431 bool isTypeAltiVecBool() const { return TypeAltiVecBool; } 432 bool isTypeSpecOwned() const { return TypeSpecOwned; } 433 ParsedType getRepAsType() const { 434 assert(isTypeRep((TST) TypeSpecType) && "DeclSpec does not store a type"); 435 return TypeRep; 436 } 437 Decl *getRepAsDecl() const { 438 assert(isDeclRep((TST) TypeSpecType) && "DeclSpec does not store a decl"); 439 return DeclRep; 440 } 441 Expr *getRepAsExpr() const { 442 assert(isExprRep((TST) TypeSpecType) && "DeclSpec does not store an expr"); 443 return ExprRep; 444 } 445 CXXScopeSpec &getTypeSpecScope() { return TypeScope; } 446 const CXXScopeSpec &getTypeSpecScope() const { return TypeScope; } 447 448 const SourceRange &getSourceRange() const { return Range; } 449 SourceLocation getTypeSpecWidthLoc() const { return TSWLoc; } 450 SourceLocation getTypeSpecComplexLoc() const { return TSCLoc; } 451 SourceLocation getTypeSpecSignLoc() const { return TSSLoc; } 452 SourceLocation getTypeSpecTypeLoc() const { return TSTLoc; } 453 SourceLocation getAltiVecLoc() const { return AltiVecLoc; } 454 455 SourceLocation getTypeSpecTypeNameLoc() const { 456 assert(isDeclRep((TST) TypeSpecType) || TypeSpecType == TST_typename); 457 return TSTNameLoc; 458 } 459 460 SourceRange getTypeofParensRange() const { return TypeofParensRange; } 461 void setTypeofParensRange(SourceRange range) { TypeofParensRange = range; } 462 463 /// getSpecifierName - Turn a type-specifier-type into a string like "_Bool" 464 /// or "union". 465 static const char *getSpecifierName(DeclSpec::TST T); 466 static const char *getSpecifierName(DeclSpec::TQ Q); 467 static const char *getSpecifierName(DeclSpec::TSS S); 468 static const char *getSpecifierName(DeclSpec::TSC C); 469 static const char *getSpecifierName(DeclSpec::TSW W); 470 static const char *getSpecifierName(DeclSpec::SCS S); 471 472 // type-qualifiers 473 474 /// getTypeQualifiers - Return a set of TQs. 475 unsigned getTypeQualifiers() const { return TypeQualifiers; } 476 SourceLocation getConstSpecLoc() const { return TQ_constLoc; } 477 SourceLocation getRestrictSpecLoc() const { return TQ_restrictLoc; } 478 SourceLocation getVolatileSpecLoc() const { return TQ_volatileLoc; } 479 480 /// \brief Clear out all of the type qualifiers. 481 void ClearTypeQualifiers() { 482 TypeQualifiers = 0; 483 TQ_constLoc = SourceLocation(); 484 TQ_restrictLoc = SourceLocation(); 485 TQ_volatileLoc = SourceLocation(); 486 } 487 488 // function-specifier 489 bool isInlineSpecified() const { return FS_inline_specified; } 490 SourceLocation getInlineSpecLoc() const { return FS_inlineLoc; } 491 492 bool isVirtualSpecified() const { return FS_virtual_specified; } 493 SourceLocation getVirtualSpecLoc() const { return FS_virtualLoc; } 494 495 bool isExplicitSpecified() const { return FS_explicit_specified; } 496 SourceLocation getExplicitSpecLoc() const { return FS_explicitLoc; } 497 498 void ClearFunctionSpecs() { 499 FS_inline_specified = false; 500 FS_inlineLoc = SourceLocation(); 501 FS_virtual_specified = false; 502 FS_virtualLoc = SourceLocation(); 503 FS_explicit_specified = false; 504 FS_explicitLoc = SourceLocation(); 505 } 506 507 /// hasTypeSpecifier - Return true if any type-specifier has been found. 508 bool hasTypeSpecifier() const { 509 return getTypeSpecType() != DeclSpec::TST_unspecified || 510 getTypeSpecWidth() != DeclSpec::TSW_unspecified || 511 getTypeSpecComplex() != DeclSpec::TSC_unspecified || 512 getTypeSpecSign() != DeclSpec::TSS_unspecified; 513 } 514 515 /// getParsedSpecifiers - Return a bitmask of which flavors of specifiers this 516 /// DeclSpec includes. 517 /// 518 unsigned getParsedSpecifiers() const; 519 520 SCS getStorageClassSpecAsWritten() const { 521 return (SCS)StorageClassSpecAsWritten; 522 } 523 524 /// isEmpty - Return true if this declaration specifier is completely empty: 525 /// no tokens were parsed in the production of it. 526 bool isEmpty() const { 527 return getParsedSpecifiers() == DeclSpec::PQ_None; 528 } 529 530 void SetRangeStart(SourceLocation Loc) { Range.setBegin(Loc); } 531 void SetRangeEnd(SourceLocation Loc) { Range.setEnd(Loc); } 532 533 /// These methods set the specified attribute of the DeclSpec and 534 /// return false if there was no error. If an error occurs (for 535 /// example, if we tried to set "auto" on a spec with "extern" 536 /// already set), they return true and set PrevSpec and DiagID 537 /// such that 538 /// Diag(Loc, DiagID) << PrevSpec; 539 /// will yield a useful result. 540 /// 541 /// TODO: use a more general approach that still allows these 542 /// diagnostics to be ignored when desired. 543 bool SetStorageClassSpec(Sema &S, SCS SC, SourceLocation Loc, 544 const char *&PrevSpec, unsigned &DiagID); 545 bool SetStorageClassSpecThread(SourceLocation Loc, const char *&PrevSpec, 546 unsigned &DiagID); 547 bool SetTypeSpecWidth(TSW W, SourceLocation Loc, const char *&PrevSpec, 548 unsigned &DiagID); 549 bool SetTypeSpecComplex(TSC C, SourceLocation Loc, const char *&PrevSpec, 550 unsigned &DiagID); 551 bool SetTypeSpecSign(TSS S, SourceLocation Loc, const char *&PrevSpec, 552 unsigned &DiagID); 553 bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, 554 unsigned &DiagID); 555 bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, 556 unsigned &DiagID, ParsedType Rep); 557 bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, 558 unsigned &DiagID, Decl *Rep, bool Owned); 559 bool SetTypeSpecType(TST T, SourceLocation TagKwLoc, 560 SourceLocation TagNameLoc, const char *&PrevSpec, 561 unsigned &DiagID, ParsedType Rep); 562 bool SetTypeSpecType(TST T, SourceLocation TagKwLoc, 563 SourceLocation TagNameLoc, const char *&PrevSpec, 564 unsigned &DiagID, Decl *Rep, bool Owned); 565 566 bool SetTypeSpecType(TST T, SourceLocation Loc, const char *&PrevSpec, 567 unsigned &DiagID, Expr *Rep); 568 bool SetTypeAltiVecVector(bool isAltiVecVector, SourceLocation Loc, 569 const char *&PrevSpec, unsigned &DiagID); 570 bool SetTypeAltiVecPixel(bool isAltiVecPixel, SourceLocation Loc, 571 const char *&PrevSpec, unsigned &DiagID); 572 bool SetTypeSpecError(); 573 void UpdateDeclRep(Decl *Rep) { 574 assert(isDeclRep((TST) TypeSpecType)); 575 DeclRep = Rep; 576 } 577 void UpdateTypeRep(ParsedType Rep) { 578 assert(isTypeRep((TST) TypeSpecType)); 579 TypeRep = Rep; 580 } 581 void UpdateExprRep(Expr *Rep) { 582 assert(isExprRep((TST) TypeSpecType)); 583 ExprRep = Rep; 584 } 585 586 bool SetTypeQual(TQ T, SourceLocation Loc, const char *&PrevSpec, 587 unsigned &DiagID, const LangOptions &Lang); 588 589 bool SetFunctionSpecInline(SourceLocation Loc, const char *&PrevSpec, 590 unsigned &DiagID); 591 bool SetFunctionSpecVirtual(SourceLocation Loc, const char *&PrevSpec, 592 unsigned &DiagID); 593 bool SetFunctionSpecExplicit(SourceLocation Loc, const char *&PrevSpec, 594 unsigned &DiagID); 595 596 bool SetFriendSpec(SourceLocation Loc, const char *&PrevSpec, 597 unsigned &DiagID); 598 bool setModulePrivateSpec(SourceLocation Loc, const char *&PrevSpec, 599 unsigned &DiagID); 600 bool SetConstexprSpec(SourceLocation Loc, const char *&PrevSpec, 601 unsigned &DiagID); 602 603 bool isFriendSpecified() const { return Friend_specified; } 604 SourceLocation getFriendSpecLoc() const { return FriendLoc; } 605 606 bool isModulePrivateSpecified() const { return ModulePrivateLoc.isValid(); } 607 SourceLocation getModulePrivateSpecLoc() const { return ModulePrivateLoc; } 608 609 bool isConstexprSpecified() const { return Constexpr_specified; } 610 SourceLocation getConstexprSpecLoc() const { return ConstexprLoc; } 611 612 AttributePool &getAttributePool() const { 613 return Attrs.getPool(); 614 } 615 616 /// AddAttributes - contatenates two attribute lists. 617 /// The GCC attribute syntax allows for the following: 618 /// 619 /// short __attribute__(( unused, deprecated )) 620 /// int __attribute__(( may_alias, aligned(16) )) var; 621 /// 622 /// This declares 4 attributes using 2 lists. The following syntax is 623 /// also allowed and equivalent to the previous declaration. 624 /// 625 /// short __attribute__((unused)) __attribute__((deprecated)) 626 /// int __attribute__((may_alias)) __attribute__((aligned(16))) var; 627 /// 628 void addAttributes(AttributeList *AL) { 629 Attrs.addAll(AL); 630 } 631 void setAttributes(AttributeList *AL) { 632 Attrs.set(AL); 633 } 634 635 bool hasAttributes() const { return !Attrs.empty(); } 636 637 ParsedAttributes &getAttributes() { return Attrs; } 638 const ParsedAttributes &getAttributes() const { return Attrs; } 639 640 /// TakeAttributes - Return the current attribute list and remove them from 641 /// the DeclSpec so that it doesn't own them. 642 ParsedAttributes takeAttributes() { 643 // The non-const "copy" constructor clears the operand automatically. 644 return Attrs; 645 } 646 647 void takeAttributesFrom(ParsedAttributes &attrs) { 648 Attrs.takeAllFrom(attrs); 649 } 650 651 typedef Decl * const *ProtocolQualifierListTy; 652 ProtocolQualifierListTy getProtocolQualifiers() const { 653 return ProtocolQualifiers; 654 } 655 SourceLocation *getProtocolLocs() const { return ProtocolLocs; } 656 unsigned getNumProtocolQualifiers() const { 657 return NumProtocolQualifiers; 658 } 659 SourceLocation getProtocolLAngleLoc() const { return ProtocolLAngleLoc; } 660 void setProtocolQualifiers(Decl * const *Protos, unsigned NP, 661 SourceLocation *ProtoLocs, 662 SourceLocation LAngleLoc); 663 664 /// Finish - This does final analysis of the declspec, issuing diagnostics for 665 /// things like "_Imaginary" (lacking an FP type). After calling this method, 666 /// DeclSpec is guaranteed self-consistent, even if an error occurred. 667 void Finish(DiagnosticsEngine &D, Preprocessor &PP); 668 669 const WrittenBuiltinSpecs& getWrittenBuiltinSpecs() const { 670 return writtenBS; 671 } 672 673 ObjCDeclSpec *getObjCQualifiers() const { return ObjCQualifiers; } 674 void setObjCQualifiers(ObjCDeclSpec *quals) { ObjCQualifiers = quals; } 675 676 /// isMissingDeclaratorOk - This checks if this DeclSpec can stand alone, 677 /// without a Declarator. Only tag declspecs can stand alone. 678 bool isMissingDeclaratorOk(); 679}; 680 681/// ObjCDeclSpec - This class captures information about 682/// "declaration specifiers" specific to objective-c 683class ObjCDeclSpec { 684public: 685 /// ObjCDeclQualifier - Qualifier used on types in method 686 /// declarations. Not all combinations are sensible. Parameters 687 /// can be one of { in, out, inout } with one of { bycopy, byref }. 688 /// Returns can either be { oneway } or not. 689 /// 690 /// This should be kept in sync with Decl::ObjCDeclQualifier. 691 enum ObjCDeclQualifier { 692 DQ_None = 0x0, 693 DQ_In = 0x1, 694 DQ_Inout = 0x2, 695 DQ_Out = 0x4, 696 DQ_Bycopy = 0x8, 697 DQ_Byref = 0x10, 698 DQ_Oneway = 0x20 699 }; 700 701 /// PropertyAttributeKind - list of property attributes. 702 enum ObjCPropertyAttributeKind { 703 DQ_PR_noattr = 0x0, 704 DQ_PR_readonly = 0x01, 705 DQ_PR_getter = 0x02, 706 DQ_PR_assign = 0x04, 707 DQ_PR_readwrite = 0x08, 708 DQ_PR_retain = 0x10, 709 DQ_PR_copy = 0x20, 710 DQ_PR_nonatomic = 0x40, 711 DQ_PR_setter = 0x80, 712 DQ_PR_atomic = 0x100, 713 DQ_PR_weak = 0x200, 714 DQ_PR_strong = 0x400, 715 DQ_PR_unsafe_unretained = 0x800 716 }; 717 718 719 ObjCDeclSpec() 720 : objcDeclQualifier(DQ_None), PropertyAttributes(DQ_PR_noattr), 721 GetterName(0), SetterName(0) { } 722 ObjCDeclQualifier getObjCDeclQualifier() const { return objcDeclQualifier; } 723 void setObjCDeclQualifier(ObjCDeclQualifier DQVal) { 724 objcDeclQualifier = (ObjCDeclQualifier) (objcDeclQualifier | DQVal); 725 } 726 727 ObjCPropertyAttributeKind getPropertyAttributes() const { 728 return ObjCPropertyAttributeKind(PropertyAttributes); 729 } 730 void setPropertyAttributes(ObjCPropertyAttributeKind PRVal) { 731 PropertyAttributes = 732 (ObjCPropertyAttributeKind)(PropertyAttributes | PRVal); 733 } 734 735 const IdentifierInfo *getGetterName() const { return GetterName; } 736 IdentifierInfo *getGetterName() { return GetterName; } 737 void setGetterName(IdentifierInfo *name) { GetterName = name; } 738 739 const IdentifierInfo *getSetterName() const { return SetterName; } 740 IdentifierInfo *getSetterName() { return SetterName; } 741 void setSetterName(IdentifierInfo *name) { SetterName = name; } 742 743private: 744 // FIXME: These two are unrelated and mutially exclusive. So perhaps 745 // we can put them in a union to reflect their mutual exclusiveness 746 // (space saving is negligible). 747 ObjCDeclQualifier objcDeclQualifier : 6; 748 749 // NOTE: VC++ treats enums as signed, avoid using ObjCPropertyAttributeKind 750 unsigned PropertyAttributes : 12; 751 IdentifierInfo *GetterName; // getter name of NULL if no getter 752 IdentifierInfo *SetterName; // setter name of NULL if no setter 753}; 754 755/// \brief Represents a C++ unqualified-id that has been parsed. 756class UnqualifiedId { 757private: 758 const UnqualifiedId &operator=(const UnqualifiedId &); // DO NOT IMPLEMENT 759 760public: 761 /// \brief Describes the kind of unqualified-id parsed. 762 enum IdKind { 763 /// \brief An identifier. 764 IK_Identifier, 765 /// \brief An overloaded operator name, e.g., operator+. 766 IK_OperatorFunctionId, 767 /// \brief A conversion function name, e.g., operator int. 768 IK_ConversionFunctionId, 769 /// \brief A user-defined literal name, e.g., operator "" _i. 770 IK_LiteralOperatorId, 771 /// \brief A constructor name. 772 IK_ConstructorName, 773 /// \brief A constructor named via a template-id. 774 IK_ConstructorTemplateId, 775 /// \brief A destructor name. 776 IK_DestructorName, 777 /// \brief A template-id, e.g., f<int>. 778 IK_TemplateId, 779 /// \brief An implicit 'self' parameter 780 IK_ImplicitSelfParam 781 } Kind; 782 783 /// \brief Anonymous union that holds extra data associated with the 784 /// parsed unqualified-id. 785 union { 786 /// \brief When Kind == IK_Identifier, the parsed identifier, or when Kind 787 /// == IK_UserLiteralId, the identifier suffix. 788 IdentifierInfo *Identifier; 789 790 /// \brief When Kind == IK_OperatorFunctionId, the overloaded operator 791 /// that we parsed. 792 struct { 793 /// \brief The kind of overloaded operator. 794 OverloadedOperatorKind Operator; 795 796 /// \brief The source locations of the individual tokens that name 797 /// the operator, e.g., the "new", "[", and "]" tokens in 798 /// operator new []. 799 /// 800 /// Different operators have different numbers of tokens in their name, 801 /// up to three. Any remaining source locations in this array will be 802 /// set to an invalid value for operators with fewer than three tokens. 803 unsigned SymbolLocations[3]; 804 } OperatorFunctionId; 805 806 /// \brief When Kind == IK_ConversionFunctionId, the type that the 807 /// conversion function names. 808 UnionParsedType ConversionFunctionId; 809 810 /// \brief When Kind == IK_ConstructorName, the class-name of the type 811 /// whose constructor is being referenced. 812 UnionParsedType ConstructorName; 813 814 /// \brief When Kind == IK_DestructorName, the type referred to by the 815 /// class-name. 816 UnionParsedType DestructorName; 817 818 /// \brief When Kind == IK_TemplateId or IK_ConstructorTemplateId, 819 /// the template-id annotation that contains the template name and 820 /// template arguments. 821 TemplateIdAnnotation *TemplateId; 822 }; 823 824 /// \brief The location of the first token that describes this unqualified-id, 825 /// which will be the location of the identifier, "operator" keyword, 826 /// tilde (for a destructor), or the template name of a template-id. 827 SourceLocation StartLocation; 828 829 /// \brief The location of the last token that describes this unqualified-id. 830 SourceLocation EndLocation; 831 832 UnqualifiedId() : Kind(IK_Identifier), Identifier(0) { } 833 834 /// \brief Do not use this copy constructor. It is temporary, and only 835 /// exists because we are holding FieldDeclarators in a SmallVector when we 836 /// don't actually need them. 837 /// 838 /// FIXME: Kill this copy constructor. 839 UnqualifiedId(const UnqualifiedId &Other) 840 : Kind(IK_Identifier), Identifier(Other.Identifier), 841 StartLocation(Other.StartLocation), EndLocation(Other.EndLocation) { 842 assert(Other.Kind == IK_Identifier && "Cannot copy non-identifiers"); 843 } 844 845 /// \brief Destroy this unqualified-id. 846 ~UnqualifiedId() { clear(); } 847 848 /// \brief Clear out this unqualified-id, setting it to default (invalid) 849 /// state. 850 void clear(); 851 852 /// \brief Determine whether this unqualified-id refers to a valid name. 853 bool isValid() const { return StartLocation.isValid(); } 854 855 /// \brief Determine whether this unqualified-id refers to an invalid name. 856 bool isInvalid() const { return !isValid(); } 857 858 /// \brief Determine what kind of name we have. 859 IdKind getKind() const { return Kind; } 860 void setKind(IdKind kind) { Kind = kind; } 861 862 /// \brief Specify that this unqualified-id was parsed as an identifier. 863 /// 864 /// \param Id the parsed identifier. 865 /// \param IdLoc the location of the parsed identifier. 866 void setIdentifier(const IdentifierInfo *Id, SourceLocation IdLoc) { 867 Kind = IK_Identifier; 868 Identifier = const_cast<IdentifierInfo *>(Id); 869 StartLocation = EndLocation = IdLoc; 870 } 871 872 /// \brief Specify that this unqualified-id was parsed as an 873 /// operator-function-id. 874 /// 875 /// \param OperatorLoc the location of the 'operator' keyword. 876 /// 877 /// \param Op the overloaded operator. 878 /// 879 /// \param SymbolLocations the locations of the individual operator symbols 880 /// in the operator. 881 void setOperatorFunctionId(SourceLocation OperatorLoc, 882 OverloadedOperatorKind Op, 883 SourceLocation SymbolLocations[3]); 884 885 /// \brief Specify that this unqualified-id was parsed as a 886 /// conversion-function-id. 887 /// 888 /// \param OperatorLoc the location of the 'operator' keyword. 889 /// 890 /// \param Ty the type to which this conversion function is converting. 891 /// 892 /// \param EndLoc the location of the last token that makes up the type name. 893 void setConversionFunctionId(SourceLocation OperatorLoc, 894 ParsedType Ty, 895 SourceLocation EndLoc) { 896 Kind = IK_ConversionFunctionId; 897 StartLocation = OperatorLoc; 898 EndLocation = EndLoc; 899 ConversionFunctionId = Ty; 900 } 901 902 /// \brief Specific that this unqualified-id was parsed as a 903 /// literal-operator-id. 904 /// 905 /// \param Id the parsed identifier. 906 /// 907 /// \param OpLoc the location of the 'operator' keyword. 908 /// 909 /// \param IdLoc the location of the identifier. 910 void setLiteralOperatorId(const IdentifierInfo *Id, SourceLocation OpLoc, 911 SourceLocation IdLoc) { 912 Kind = IK_LiteralOperatorId; 913 Identifier = const_cast<IdentifierInfo *>(Id); 914 StartLocation = OpLoc; 915 EndLocation = IdLoc; 916 } 917 918 /// \brief Specify that this unqualified-id was parsed as a constructor name. 919 /// 920 /// \param ClassType the class type referred to by the constructor name. 921 /// 922 /// \param ClassNameLoc the location of the class name. 923 /// 924 /// \param EndLoc the location of the last token that makes up the type name. 925 void setConstructorName(ParsedType ClassType, 926 SourceLocation ClassNameLoc, 927 SourceLocation EndLoc) { 928 Kind = IK_ConstructorName; 929 StartLocation = ClassNameLoc; 930 EndLocation = EndLoc; 931 ConstructorName = ClassType; 932 } 933 934 /// \brief Specify that this unqualified-id was parsed as a 935 /// template-id that names a constructor. 936 /// 937 /// \param TemplateId the template-id annotation that describes the parsed 938 /// template-id. This UnqualifiedId instance will take ownership of the 939 /// \p TemplateId and will free it on destruction. 940 void setConstructorTemplateId(TemplateIdAnnotation *TemplateId); 941 942 /// \brief Specify that this unqualified-id was parsed as a destructor name. 943 /// 944 /// \param TildeLoc the location of the '~' that introduces the destructor 945 /// name. 946 /// 947 /// \param ClassType the name of the class referred to by the destructor name. 948 void setDestructorName(SourceLocation TildeLoc, 949 ParsedType ClassType, 950 SourceLocation EndLoc) { 951 Kind = IK_DestructorName; 952 StartLocation = TildeLoc; 953 EndLocation = EndLoc; 954 DestructorName = ClassType; 955 } 956 957 /// \brief Specify that this unqualified-id was parsed as a template-id. 958 /// 959 /// \param TemplateId the template-id annotation that describes the parsed 960 /// template-id. This UnqualifiedId instance will take ownership of the 961 /// \p TemplateId and will free it on destruction. 962 void setTemplateId(TemplateIdAnnotation *TemplateId); 963 964 /// \brief Return the source range that covers this unqualified-id. 965 SourceRange getSourceRange() const { 966 return SourceRange(StartLocation, EndLocation); 967 } 968}; 969 970/// CachedTokens - A set of tokens that has been cached for later 971/// parsing. 972typedef SmallVector<Token, 4> CachedTokens; 973 974/// DeclaratorChunk - One instance of this struct is used for each type in a 975/// declarator that is parsed. 976/// 977/// This is intended to be a small value object. 978struct DeclaratorChunk { 979 enum { 980 Pointer, Reference, Array, Function, BlockPointer, MemberPointer, Paren 981 } Kind; 982 983 /// Loc - The place where this type was defined. 984 SourceLocation Loc; 985 /// EndLoc - If valid, the place where this chunck ends. 986 SourceLocation EndLoc; 987 988 struct TypeInfoCommon { 989 AttributeList *AttrList; 990 }; 991 992 struct PointerTypeInfo : TypeInfoCommon { 993 /// The type qualifiers: const/volatile/restrict. 994 unsigned TypeQuals : 3; 995 996 /// The location of the const-qualifier, if any. 997 unsigned ConstQualLoc; 998 999 /// The location of the volatile-qualifier, if any. 1000 unsigned VolatileQualLoc; 1001 1002 /// The location of the restrict-qualifier, if any. 1003 unsigned RestrictQualLoc; 1004 1005 void destroy() { 1006 } 1007 }; 1008 1009 struct ReferenceTypeInfo : TypeInfoCommon { 1010 /// The type qualifier: restrict. [GNU] C++ extension 1011 bool HasRestrict : 1; 1012 /// True if this is an lvalue reference, false if it's an rvalue reference. 1013 bool LValueRef : 1; 1014 void destroy() { 1015 } 1016 }; 1017 1018 struct ArrayTypeInfo : TypeInfoCommon { 1019 /// The type qualifiers for the array: const/volatile/restrict. 1020 unsigned TypeQuals : 3; 1021 1022 /// True if this dimension included the 'static' keyword. 1023 bool hasStatic : 1; 1024 1025 /// True if this dimension was [*]. In this case, NumElts is null. 1026 bool isStar : 1; 1027 1028 /// This is the size of the array, or null if [] or [*] was specified. 1029 /// Since the parser is multi-purpose, and we don't want to impose a root 1030 /// expression class on all clients, NumElts is untyped. 1031 Expr *NumElts; 1032 1033 void destroy() {} 1034 }; 1035 1036 /// ParamInfo - An array of paraminfo objects is allocated whenever a function 1037 /// declarator is parsed. There are two interesting styles of arguments here: 1038 /// K&R-style identifier lists and parameter type lists. K&R-style identifier 1039 /// lists will have information about the identifier, but no type information. 1040 /// Parameter type lists will have type info (if the actions module provides 1041 /// it), but may have null identifier info: e.g. for 'void foo(int X, int)'. 1042 struct ParamInfo { 1043 IdentifierInfo *Ident; 1044 SourceLocation IdentLoc; 1045 Decl *Param; 1046 1047 /// DefaultArgTokens - When the parameter's default argument 1048 /// cannot be parsed immediately (because it occurs within the 1049 /// declaration of a member function), it will be stored here as a 1050 /// sequence of tokens to be parsed once the class definition is 1051 /// complete. Non-NULL indicates that there is a default argument. 1052 CachedTokens *DefaultArgTokens; 1053 1054 ParamInfo() {} 1055 ParamInfo(IdentifierInfo *ident, SourceLocation iloc, 1056 Decl *param, 1057 CachedTokens *DefArgTokens = 0) 1058 : Ident(ident), IdentLoc(iloc), Param(param), 1059 DefaultArgTokens(DefArgTokens) {} 1060 }; 1061 1062 struct TypeAndRange { 1063 ParsedType Ty; 1064 SourceRange Range; 1065 }; 1066 1067 struct FunctionTypeInfo : TypeInfoCommon { 1068 /// hasPrototype - This is true if the function had at least one typed 1069 /// argument. If the function is () or (a,b,c), then it has no prototype, 1070 /// and is treated as a K&R-style function. 1071 unsigned hasPrototype : 1; 1072 1073 /// isVariadic - If this function has a prototype, and if that 1074 /// proto ends with ',...)', this is true. When true, EllipsisLoc 1075 /// contains the location of the ellipsis. 1076 unsigned isVariadic : 1; 1077 1078 /// \brief Whether the ref-qualifier (if any) is an lvalue reference. 1079 /// Otherwise, it's an rvalue reference. 1080 unsigned RefQualifierIsLValueRef : 1; 1081 1082 /// The type qualifiers: const/volatile/restrict. 1083 /// The qualifier bitmask values are the same as in QualType. 1084 unsigned TypeQuals : 3; 1085 1086 /// ExceptionSpecType - An ExceptionSpecificationType value. 1087 unsigned ExceptionSpecType : 3; 1088 1089 /// DeleteArgInfo - If this is true, we need to delete[] ArgInfo. 1090 unsigned DeleteArgInfo : 1; 1091 1092 /// When isVariadic is true, the location of the ellipsis in the source. 1093 unsigned EllipsisLoc; 1094 1095 /// NumArgs - This is the number of formal arguments provided for the 1096 /// declarator. 1097 unsigned NumArgs; 1098 1099 /// NumExceptions - This is the number of types in the dynamic-exception- 1100 /// decl, if the function has one. 1101 unsigned NumExceptions; 1102 1103 /// \brief The location of the ref-qualifier, if any. 1104 /// 1105 /// If this is an invalid location, there is no ref-qualifier. 1106 unsigned RefQualifierLoc; 1107 1108 /// \brief The location of the 'mutable' qualifer in a lambda-declarator, if 1109 /// any. 1110 unsigned MutableLoc; 1111 1112 /// \brief When ExceptionSpecType isn't EST_None or EST_Delayed, the 1113 /// location of the keyword introducing the spec. 1114 unsigned ExceptionSpecLoc; 1115 1116 /// ArgInfo - This is a pointer to a new[]'d array of ParamInfo objects that 1117 /// describe the arguments for this function declarator. This is null if 1118 /// there are no arguments specified. 1119 ParamInfo *ArgInfo; 1120 1121 union { 1122 /// \brief Pointer to a new[]'d array of TypeAndRange objects that 1123 /// contain the types in the function's dynamic exception specification 1124 /// and their locations, if there is one. 1125 TypeAndRange *Exceptions; 1126 1127 /// \brief Pointer to the expression in the noexcept-specifier of this 1128 /// function, if it has one. 1129 Expr *NoexceptExpr; 1130 }; 1131 1132 /// TrailingReturnType - If this isn't null, it's the trailing return type 1133 /// specified. This is actually a ParsedType, but stored as void* to 1134 /// allow union storage. 1135 void *TrailingReturnType; 1136 1137 /// freeArgs - reset the argument list to having zero arguments. This is 1138 /// used in various places for error recovery. 1139 void freeArgs() { 1140 if (DeleteArgInfo) { 1141 delete[] ArgInfo; 1142 DeleteArgInfo = false; 1143 } 1144 NumArgs = 0; 1145 } 1146 1147 void destroy() { 1148 if (DeleteArgInfo) 1149 delete[] ArgInfo; 1150 if (getExceptionSpecType() == EST_Dynamic) 1151 delete[] Exceptions; 1152 } 1153 1154 /// isKNRPrototype - Return true if this is a K&R style identifier list, 1155 /// like "void foo(a,b,c)". In a function definition, this will be followed 1156 /// by the argument type definitions. 1157 bool isKNRPrototype() const { 1158 return !hasPrototype && NumArgs != 0; 1159 } 1160 1161 SourceLocation getEllipsisLoc() const { 1162 return SourceLocation::getFromRawEncoding(EllipsisLoc); 1163 } 1164 SourceLocation getExceptionSpecLoc() const { 1165 return SourceLocation::getFromRawEncoding(ExceptionSpecLoc); 1166 } 1167 1168 /// \brief Retrieve the location of the ref-qualifier, if any. 1169 SourceLocation getRefQualifierLoc() const { 1170 return SourceLocation::getFromRawEncoding(RefQualifierLoc); 1171 } 1172 1173 /// \brief Retrieve the location of the 'mutable' qualifier, if any. 1174 SourceLocation getMutableLoc() const { 1175 return SourceLocation::getFromRawEncoding(MutableLoc); 1176 } 1177 1178 /// \brief Determine whether this function declaration contains a 1179 /// ref-qualifier. 1180 bool hasRefQualifier() const { return getRefQualifierLoc().isValid(); } 1181 1182 /// \brief Determine whether this lambda-declarator contains a 'mutable' 1183 /// qualifier. 1184 bool hasMutableQualifier() const { return getMutableLoc().isValid(); } 1185 1186 /// \brief Get the type of exception specification this function has. 1187 ExceptionSpecificationType getExceptionSpecType() const { 1188 return static_cast<ExceptionSpecificationType>(ExceptionSpecType); 1189 } 1190 }; 1191 1192 struct BlockPointerTypeInfo : TypeInfoCommon { 1193 /// For now, sema will catch these as invalid. 1194 /// The type qualifiers: const/volatile/restrict. 1195 unsigned TypeQuals : 3; 1196 1197 void destroy() { 1198 } 1199 }; 1200 1201 struct MemberPointerTypeInfo : TypeInfoCommon { 1202 /// The type qualifiers: const/volatile/restrict. 1203 unsigned TypeQuals : 3; 1204 // CXXScopeSpec has a constructor, so it can't be a direct member. 1205 // So we need some pointer-aligned storage and a bit of trickery. 1206 union { 1207 void *Aligner; 1208 char Mem[sizeof(CXXScopeSpec)]; 1209 } ScopeMem; 1210 CXXScopeSpec &Scope() { 1211 return *reinterpret_cast<CXXScopeSpec*>(ScopeMem.Mem); 1212 } 1213 const CXXScopeSpec &Scope() const { 1214 return *reinterpret_cast<const CXXScopeSpec*>(ScopeMem.Mem); 1215 } 1216 void destroy() { 1217 Scope().~CXXScopeSpec(); 1218 } 1219 }; 1220 1221 union { 1222 TypeInfoCommon Common; 1223 PointerTypeInfo Ptr; 1224 ReferenceTypeInfo Ref; 1225 ArrayTypeInfo Arr; 1226 FunctionTypeInfo Fun; 1227 BlockPointerTypeInfo Cls; 1228 MemberPointerTypeInfo Mem; 1229 }; 1230 1231 void destroy() { 1232 switch (Kind) { 1233 default: llvm_unreachable("Unknown decl type!"); 1234 case DeclaratorChunk::Function: return Fun.destroy(); 1235 case DeclaratorChunk::Pointer: return Ptr.destroy(); 1236 case DeclaratorChunk::BlockPointer: return Cls.destroy(); 1237 case DeclaratorChunk::Reference: return Ref.destroy(); 1238 case DeclaratorChunk::Array: return Arr.destroy(); 1239 case DeclaratorChunk::MemberPointer: return Mem.destroy(); 1240 case DeclaratorChunk::Paren: return; 1241 } 1242 } 1243 1244 /// getAttrs - If there are attributes applied to this declaratorchunk, return 1245 /// them. 1246 const AttributeList *getAttrs() const { 1247 return Common.AttrList; 1248 } 1249 1250 AttributeList *&getAttrListRef() { 1251 return Common.AttrList; 1252 } 1253 1254 /// getPointer - Return a DeclaratorChunk for a pointer. 1255 /// 1256 static DeclaratorChunk getPointer(unsigned TypeQuals, SourceLocation Loc, 1257 SourceLocation ConstQualLoc, 1258 SourceLocation VolatileQualLoc, 1259 SourceLocation RestrictQualLoc) { 1260 DeclaratorChunk I; 1261 I.Kind = Pointer; 1262 I.Loc = Loc; 1263 I.Ptr.TypeQuals = TypeQuals; 1264 I.Ptr.ConstQualLoc = ConstQualLoc.getRawEncoding(); 1265 I.Ptr.VolatileQualLoc = VolatileQualLoc.getRawEncoding(); 1266 I.Ptr.RestrictQualLoc = RestrictQualLoc.getRawEncoding(); 1267 I.Ptr.AttrList = 0; 1268 return I; 1269 } 1270 1271 /// getReference - Return a DeclaratorChunk for a reference. 1272 /// 1273 static DeclaratorChunk getReference(unsigned TypeQuals, SourceLocation Loc, 1274 bool lvalue) { 1275 DeclaratorChunk I; 1276 I.Kind = Reference; 1277 I.Loc = Loc; 1278 I.Ref.HasRestrict = (TypeQuals & DeclSpec::TQ_restrict) != 0; 1279 I.Ref.LValueRef = lvalue; 1280 I.Ref.AttrList = 0; 1281 return I; 1282 } 1283 1284 /// getArray - Return a DeclaratorChunk for an array. 1285 /// 1286 static DeclaratorChunk getArray(unsigned TypeQuals, 1287 bool isStatic, bool isStar, Expr *NumElts, 1288 SourceLocation LBLoc, SourceLocation RBLoc) { 1289 DeclaratorChunk I; 1290 I.Kind = Array; 1291 I.Loc = LBLoc; 1292 I.EndLoc = RBLoc; 1293 I.Arr.AttrList = 0; 1294 I.Arr.TypeQuals = TypeQuals; 1295 I.Arr.hasStatic = isStatic; 1296 I.Arr.isStar = isStar; 1297 I.Arr.NumElts = NumElts; 1298 return I; 1299 } 1300 1301 /// DeclaratorChunk::getFunction - Return a DeclaratorChunk for a function. 1302 /// "TheDeclarator" is the declarator that this will be added to. 1303 static DeclaratorChunk getFunction(bool hasProto, bool isVariadic, 1304 SourceLocation EllipsisLoc, 1305 ParamInfo *ArgInfo, unsigned NumArgs, 1306 unsigned TypeQuals, 1307 bool RefQualifierIsLvalueRef, 1308 SourceLocation RefQualifierLoc, 1309 SourceLocation MutableLoc, 1310 ExceptionSpecificationType ESpecType, 1311 SourceLocation ESpecLoc, 1312 ParsedType *Exceptions, 1313 SourceRange *ExceptionRanges, 1314 unsigned NumExceptions, 1315 Expr *NoexceptExpr, 1316 SourceLocation LocalRangeBegin, 1317 SourceLocation LocalRangeEnd, 1318 Declarator &TheDeclarator, 1319 ParsedType TrailingReturnType = 1320 ParsedType()); 1321 1322 /// getBlockPointer - Return a DeclaratorChunk for a block. 1323 /// 1324 static DeclaratorChunk getBlockPointer(unsigned TypeQuals, 1325 SourceLocation Loc) { 1326 DeclaratorChunk I; 1327 I.Kind = BlockPointer; 1328 I.Loc = Loc; 1329 I.Cls.TypeQuals = TypeQuals; 1330 I.Cls.AttrList = 0; 1331 return I; 1332 } 1333 1334 static DeclaratorChunk getMemberPointer(const CXXScopeSpec &SS, 1335 unsigned TypeQuals, 1336 SourceLocation Loc) { 1337 DeclaratorChunk I; 1338 I.Kind = MemberPointer; 1339 I.Loc = Loc; 1340 I.Mem.TypeQuals = TypeQuals; 1341 I.Mem.AttrList = 0; 1342 new (I.Mem.ScopeMem.Mem) CXXScopeSpec(SS); 1343 return I; 1344 } 1345 1346 /// getParen - Return a DeclaratorChunk for a paren. 1347 /// 1348 static DeclaratorChunk getParen(SourceLocation LParenLoc, 1349 SourceLocation RParenLoc) { 1350 DeclaratorChunk I; 1351 I.Kind = Paren; 1352 I.Loc = LParenLoc; 1353 I.EndLoc = RParenLoc; 1354 I.Common.AttrList = 0; 1355 return I; 1356 } 1357 1358}; 1359 1360/// Declarator - Information about one declarator, including the parsed type 1361/// information and the identifier. When the declarator is fully formed, this 1362/// is turned into the appropriate Decl object. 1363/// 1364/// Declarators come in two types: normal declarators and abstract declarators. 1365/// Abstract declarators are used when parsing types, and don't have an 1366/// identifier. Normal declarators do have ID's. 1367/// 1368/// Instances of this class should be a transient object that lives on the 1369/// stack, not objects that are allocated in large quantities on the heap. 1370class Declarator { 1371public: 1372 enum TheContext { 1373 FileContext, // File scope declaration. 1374 PrototypeContext, // Within a function prototype. 1375 ObjCResultContext, // An ObjC method result type. 1376 ObjCParameterContext,// An ObjC method parameter type. 1377 KNRTypeListContext, // K&R type definition list for formals. 1378 TypeNameContext, // Abstract declarator for types. 1379 MemberContext, // Struct/Union field. 1380 BlockContext, // Declaration within a block in a function. 1381 ForContext, // Declaration within first part of a for loop. 1382 ConditionContext, // Condition declaration in a C++ if/switch/while/for. 1383 TemplateParamContext,// Within a template parameter list. 1384 CXXNewContext, // C++ new-expression. 1385 CXXCatchContext, // C++ catch exception-declaration 1386 ObjCCatchContext, // Objective-C catch exception-declaration 1387 BlockLiteralContext, // Block literal declarator. 1388 TemplateTypeArgContext, // Template type argument. 1389 AliasDeclContext, // C++0x alias-declaration. 1390 AliasTemplateContext // C++0x alias-declaration template. 1391 }; 1392 1393private: 1394 const DeclSpec &DS; 1395 CXXScopeSpec SS; 1396 UnqualifiedId Name; 1397 SourceRange Range; 1398 1399 /// Context - Where we are parsing this declarator. 1400 /// 1401 TheContext Context; 1402 1403 /// DeclTypeInfo - This holds each type that the declarator includes as it is 1404 /// parsed. This is pushed from the identifier out, which means that element 1405 /// #0 will be the most closely bound to the identifier, and 1406 /// DeclTypeInfo.back() will be the least closely bound. 1407 SmallVector<DeclaratorChunk, 8> DeclTypeInfo; 1408 1409 /// InvalidType - Set by Sema::GetTypeForDeclarator(). 1410 bool InvalidType : 1; 1411 1412 /// GroupingParens - Set by Parser::ParseParenDeclarator(). 1413 bool GroupingParens : 1; 1414 1415 /// FunctionDefinition - Is this Declarator for a function or member defintion 1416 bool FunctionDefinition : 1; 1417 1418 // Redeclaration - Is this Declarator is a redeclaration. 1419 bool Redeclaration : 1; 1420 1421 /// Attrs - Attributes. 1422 ParsedAttributes Attrs; 1423 1424 /// AsmLabel - The asm label, if specified. 1425 Expr *AsmLabel; 1426 1427 /// InlineParams - This is a local array used for the first function decl 1428 /// chunk to avoid going to the heap for the common case when we have one 1429 /// function chunk in the declarator. 1430 DeclaratorChunk::ParamInfo InlineParams[16]; 1431 bool InlineParamsUsed; 1432 1433 /// Extension - true if the declaration is preceded by __extension__. 1434 bool Extension : 1; 1435 1436 /// \brief If provided, the source location of the ellipsis used to describe 1437 /// this declarator as a parameter pack. 1438 SourceLocation EllipsisLoc; 1439 1440 friend struct DeclaratorChunk; 1441 1442public: 1443 Declarator(const DeclSpec &ds, TheContext C) 1444 : DS(ds), Range(ds.getSourceRange()), Context(C), 1445 InvalidType(DS.getTypeSpecType() == DeclSpec::TST_error), 1446 GroupingParens(false), FunctionDefinition(false), Redeclaration(false), 1447 Attrs(ds.getAttributePool().getFactory()), AsmLabel(0), 1448 InlineParamsUsed(false), Extension(false) { 1449 } 1450 1451 ~Declarator() { 1452 clear(); 1453 } 1454 1455 /// getDeclSpec - Return the declaration-specifier that this declarator was 1456 /// declared with. 1457 const DeclSpec &getDeclSpec() const { return DS; } 1458 1459 /// getMutableDeclSpec - Return a non-const version of the DeclSpec. This 1460 /// should be used with extreme care: declspecs can often be shared between 1461 /// multiple declarators, so mutating the DeclSpec affects all of the 1462 /// Declarators. This should only be done when the declspec is known to not 1463 /// be shared or when in error recovery etc. 1464 DeclSpec &getMutableDeclSpec() { return const_cast<DeclSpec &>(DS); } 1465 1466 AttributePool &getAttributePool() const { 1467 return Attrs.getPool(); 1468 } 1469 1470 /// getCXXScopeSpec - Return the C++ scope specifier (global scope or 1471 /// nested-name-specifier) that is part of the declarator-id. 1472 const CXXScopeSpec &getCXXScopeSpec() const { return SS; } 1473 CXXScopeSpec &getCXXScopeSpec() { return SS; } 1474 1475 /// \brief Retrieve the name specified by this declarator. 1476 UnqualifiedId &getName() { return Name; } 1477 1478 TheContext getContext() const { return Context; } 1479 1480 bool isPrototypeContext() const { 1481 return (Context == PrototypeContext || 1482 Context == ObjCParameterContext || 1483 Context == ObjCResultContext); 1484 } 1485 1486 /// getSourceRange - Get the source range that spans this declarator. 1487 const SourceRange &getSourceRange() const { return Range; } 1488 1489 void SetSourceRange(SourceRange R) { Range = R; } 1490 /// SetRangeBegin - Set the start of the source range to Loc, unless it's 1491 /// invalid. 1492 void SetRangeBegin(SourceLocation Loc) { 1493 if (!Loc.isInvalid()) 1494 Range.setBegin(Loc); 1495 } 1496 /// SetRangeEnd - Set the end of the source range to Loc, unless it's invalid. 1497 void SetRangeEnd(SourceLocation Loc) { 1498 if (!Loc.isInvalid()) 1499 Range.setEnd(Loc); 1500 } 1501 /// ExtendWithDeclSpec - Extend the declarator source range to include the 1502 /// given declspec, unless its location is invalid. Adopts the range start if 1503 /// the current range start is invalid. 1504 void ExtendWithDeclSpec(const DeclSpec &DS) { 1505 const SourceRange &SR = DS.getSourceRange(); 1506 if (Range.getBegin().isInvalid()) 1507 Range.setBegin(SR.getBegin()); 1508 if (!SR.getEnd().isInvalid()) 1509 Range.setEnd(SR.getEnd()); 1510 } 1511 1512 /// clear - Reset the contents of this Declarator. 1513 void clear() { 1514 SS.clear(); 1515 Name.clear(); 1516 Range = DS.getSourceRange(); 1517 1518 for (unsigned i = 0, e = DeclTypeInfo.size(); i != e; ++i) 1519 DeclTypeInfo[i].destroy(); 1520 DeclTypeInfo.clear(); 1521 Attrs.clear(); 1522 AsmLabel = 0; 1523 InlineParamsUsed = false; 1524 } 1525 1526 /// mayOmitIdentifier - Return true if the identifier is either optional or 1527 /// not allowed. This is true for typenames, prototypes, and template 1528 /// parameter lists. 1529 bool mayOmitIdentifier() const { 1530 switch (Context) { 1531 case FileContext: 1532 case KNRTypeListContext: 1533 case MemberContext: 1534 case BlockContext: 1535 case ForContext: 1536 case ConditionContext: 1537 return false; 1538 1539 case TypeNameContext: 1540 case AliasDeclContext: 1541 case AliasTemplateContext: 1542 case PrototypeContext: 1543 case ObjCParameterContext: 1544 case ObjCResultContext: 1545 case TemplateParamContext: 1546 case CXXNewContext: 1547 case CXXCatchContext: 1548 case ObjCCatchContext: 1549 case BlockLiteralContext: 1550 case TemplateTypeArgContext: 1551 return true; 1552 } 1553 llvm_unreachable("unknown context kind!"); 1554 } 1555 1556 /// mayHaveIdentifier - Return true if the identifier is either optional or 1557 /// required. This is true for normal declarators and prototypes, but not 1558 /// typenames. 1559 bool mayHaveIdentifier() const { 1560 switch (Context) { 1561 case FileContext: 1562 case KNRTypeListContext: 1563 case MemberContext: 1564 case BlockContext: 1565 case ForContext: 1566 case ConditionContext: 1567 case PrototypeContext: 1568 case TemplateParamContext: 1569 case CXXCatchContext: 1570 case ObjCCatchContext: 1571 return true; 1572 1573 case TypeNameContext: 1574 case CXXNewContext: 1575 case AliasDeclContext: 1576 case AliasTemplateContext: 1577 case ObjCParameterContext: 1578 case ObjCResultContext: 1579 case BlockLiteralContext: 1580 case TemplateTypeArgContext: 1581 return false; 1582 } 1583 llvm_unreachable("unknown context kind!"); 1584 } 1585 1586 /// mayBeFollowedByCXXDirectInit - Return true if the declarator can be 1587 /// followed by a C++ direct initializer, e.g. "int x(1);". 1588 bool mayBeFollowedByCXXDirectInit() const { 1589 if (hasGroupingParens()) return false; 1590 1591 switch (Context) { 1592 case FileContext: 1593 case BlockContext: 1594 case ForContext: 1595 return true; 1596 1597 case KNRTypeListContext: 1598 case MemberContext: 1599 case ConditionContext: 1600 case PrototypeContext: 1601 case ObjCParameterContext: 1602 case ObjCResultContext: 1603 case TemplateParamContext: 1604 case CXXCatchContext: 1605 case ObjCCatchContext: 1606 case TypeNameContext: 1607 case CXXNewContext: 1608 case AliasDeclContext: 1609 case AliasTemplateContext: 1610 case BlockLiteralContext: 1611 case TemplateTypeArgContext: 1612 return false; 1613 } 1614 llvm_unreachable("unknown context kind!"); 1615 } 1616 1617 /// isPastIdentifier - Return true if we have parsed beyond the point where 1618 /// the 1619 bool isPastIdentifier() const { return Name.isValid(); } 1620 1621 /// hasName - Whether this declarator has a name, which might be an 1622 /// identifier (accessible via getIdentifier()) or some kind of 1623 /// special C++ name (constructor, destructor, etc.). 1624 bool hasName() const { 1625 return Name.getKind() != UnqualifiedId::IK_Identifier || Name.Identifier; 1626 } 1627 1628 IdentifierInfo *getIdentifier() const { 1629 if (Name.getKind() == UnqualifiedId::IK_Identifier) 1630 return Name.Identifier; 1631 1632 return 0; 1633 } 1634 SourceLocation getIdentifierLoc() const { return Name.StartLocation; } 1635 1636 /// \brief Set the name of this declarator to be the given identifier. 1637 void SetIdentifier(IdentifierInfo *Id, SourceLocation IdLoc) { 1638 Name.setIdentifier(Id, IdLoc); 1639 } 1640 1641 /// AddTypeInfo - Add a chunk to this declarator. Also extend the range to 1642 /// EndLoc, which should be the last token of the chunk. 1643 void AddTypeInfo(const DeclaratorChunk &TI, 1644 ParsedAttributes &attrs, 1645 SourceLocation EndLoc) { 1646 DeclTypeInfo.push_back(TI); 1647 DeclTypeInfo.back().getAttrListRef() = attrs.getList(); 1648 getAttributePool().takeAllFrom(attrs.getPool()); 1649 1650 if (!EndLoc.isInvalid()) 1651 SetRangeEnd(EndLoc); 1652 } 1653 1654 /// AddInnermostTypeInfo - Add a new innermost chunk to this declarator. 1655 void AddInnermostTypeInfo(const DeclaratorChunk &TI) { 1656 DeclTypeInfo.insert(DeclTypeInfo.begin(), TI); 1657 } 1658 1659 /// getNumTypeObjects() - Return the number of types applied to this 1660 /// declarator. 1661 unsigned getNumTypeObjects() const { return DeclTypeInfo.size(); } 1662 1663 /// Return the specified TypeInfo from this declarator. TypeInfo #0 is 1664 /// closest to the identifier. 1665 const DeclaratorChunk &getTypeObject(unsigned i) const { 1666 assert(i < DeclTypeInfo.size() && "Invalid type chunk"); 1667 return DeclTypeInfo[i]; 1668 } 1669 DeclaratorChunk &getTypeObject(unsigned i) { 1670 assert(i < DeclTypeInfo.size() && "Invalid type chunk"); 1671 return DeclTypeInfo[i]; 1672 } 1673 1674 void DropFirstTypeObject() 1675 { 1676 assert(!DeclTypeInfo.empty() && "No type chunks to drop."); 1677 DeclTypeInfo.front().destroy(); 1678 DeclTypeInfo.erase(DeclTypeInfo.begin()); 1679 } 1680 1681 /// isArrayOfUnknownBound - This method returns true if the declarator 1682 /// is a declarator for an array of unknown bound (looking through 1683 /// parentheses). 1684 bool isArrayOfUnknownBound() const { 1685 for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) { 1686 switch (DeclTypeInfo[i].Kind) { 1687 case DeclaratorChunk::Paren: 1688 continue; 1689 case DeclaratorChunk::Function: 1690 case DeclaratorChunk::Pointer: 1691 case DeclaratorChunk::Reference: 1692 case DeclaratorChunk::BlockPointer: 1693 case DeclaratorChunk::MemberPointer: 1694 return false; 1695 case DeclaratorChunk::Array: 1696 return !DeclTypeInfo[i].Arr.NumElts; 1697 } 1698 llvm_unreachable("Invalid type chunk"); 1699 return false; 1700 } 1701 return false; 1702 } 1703 1704 /// isFunctionDeclarator - This method returns true if the declarator 1705 /// is a function declarator (looking through parentheses). 1706 /// If true is returned, then the reference type parameter idx is 1707 /// assigned with the index of the declaration chunk. 1708 bool isFunctionDeclarator(unsigned& idx) const { 1709 for (unsigned i = 0, i_end = DeclTypeInfo.size(); i < i_end; ++i) { 1710 switch (DeclTypeInfo[i].Kind) { 1711 case DeclaratorChunk::Function: 1712 idx = i; 1713 return true; 1714 case DeclaratorChunk::Paren: 1715 continue; 1716 case DeclaratorChunk::Pointer: 1717 case DeclaratorChunk::Reference: 1718 case DeclaratorChunk::Array: 1719 case DeclaratorChunk::BlockPointer: 1720 case DeclaratorChunk::MemberPointer: 1721 return false; 1722 } 1723 llvm_unreachable("Invalid type chunk"); 1724 return false; 1725 } 1726 return false; 1727 } 1728 1729 /// isFunctionDeclarator - Once this declarator is fully parsed and formed, 1730 /// this method returns true if the identifier is a function declarator 1731 /// (looking through parentheses). 1732 bool isFunctionDeclarator() const { 1733 unsigned index; 1734 return isFunctionDeclarator(index); 1735 } 1736 1737 /// getFunctionTypeInfo - Retrieves the function type info object 1738 /// (looking through parentheses). 1739 DeclaratorChunk::FunctionTypeInfo &getFunctionTypeInfo() { 1740 assert(isFunctionDeclarator() && "Not a function declarator!"); 1741 unsigned index = 0; 1742 isFunctionDeclarator(index); 1743 return DeclTypeInfo[index].Fun; 1744 } 1745 1746 /// getFunctionTypeInfo - Retrieves the function type info object 1747 /// (looking through parentheses). 1748 const DeclaratorChunk::FunctionTypeInfo &getFunctionTypeInfo() const { 1749 return const_cast<Declarator*>(this)->getFunctionTypeInfo(); 1750 } 1751 1752 /// \brief Determine whether the declaration that will be produced from 1753 /// this declaration will be a function. 1754 /// 1755 /// A declaration can declare a function even if the declarator itself 1756 /// isn't a function declarator, if the type specifier refers to a function 1757 /// type. This routine checks for both cases. 1758 bool isDeclarationOfFunction() const; 1759 1760 /// takeAttributes - Takes attributes from the given parsed-attributes 1761 /// set and add them to this declarator. 1762 /// 1763 /// These examples both add 3 attributes to "var": 1764 /// short int var __attribute__((aligned(16),common,deprecated)); 1765 /// short int x, __attribute__((aligned(16)) var 1766 /// __attribute__((common,deprecated)); 1767 /// 1768 /// Also extends the range of the declarator. 1769 void takeAttributes(ParsedAttributes &attrs, SourceLocation lastLoc) { 1770 Attrs.takeAllFrom(attrs); 1771 1772 if (!lastLoc.isInvalid()) 1773 SetRangeEnd(lastLoc); 1774 } 1775 1776 const AttributeList *getAttributes() const { return Attrs.getList(); } 1777 AttributeList *getAttributes() { return Attrs.getList(); } 1778 1779 AttributeList *&getAttrListRef() { return Attrs.getListRef(); } 1780 1781 /// hasAttributes - do we contain any attributes? 1782 bool hasAttributes() const { 1783 if (getAttributes() || getDeclSpec().hasAttributes()) return true; 1784 for (unsigned i = 0, e = getNumTypeObjects(); i != e; ++i) 1785 if (getTypeObject(i).getAttrs()) 1786 return true; 1787 return false; 1788 } 1789 1790 void setAsmLabel(Expr *E) { AsmLabel = E; } 1791 Expr *getAsmLabel() const { return AsmLabel; } 1792 1793 void setExtension(bool Val = true) { Extension = Val; } 1794 bool getExtension() const { return Extension; } 1795 1796 void setInvalidType(bool Val = true) { InvalidType = Val; } 1797 bool isInvalidType() const { 1798 return InvalidType || DS.getTypeSpecType() == DeclSpec::TST_error; 1799 } 1800 1801 void setGroupingParens(bool flag) { GroupingParens = flag; } 1802 bool hasGroupingParens() const { return GroupingParens; } 1803 1804 bool hasEllipsis() const { return EllipsisLoc.isValid(); } 1805 SourceLocation getEllipsisLoc() const { return EllipsisLoc; } 1806 void setEllipsisLoc(SourceLocation EL) { EllipsisLoc = EL; } 1807 1808 void setFunctionDefinition(bool Val) { FunctionDefinition = Val; } 1809 bool isFunctionDefinition() const { return FunctionDefinition; } 1810 1811 void setRedeclaration(bool Val) { Redeclaration = Val; } 1812 bool isRedeclaration() const { return Redeclaration; } 1813}; 1814 1815/// FieldDeclarator - This little struct is used to capture information about 1816/// structure field declarators, which is basically just a bitfield size. 1817struct FieldDeclarator { 1818 Declarator D; 1819 Expr *BitfieldSize; 1820 explicit FieldDeclarator(DeclSpec &DS) : D(DS, Declarator::MemberContext) { 1821 BitfieldSize = 0; 1822 } 1823}; 1824 1825/// VirtSpecifiers - Represents a C++0x virt-specifier-seq. 1826class VirtSpecifiers { 1827public: 1828 enum Specifier { 1829 VS_None = 0, 1830 VS_Override = 1, 1831 VS_Final = 2 1832 }; 1833 1834 VirtSpecifiers() : Specifiers(0) { } 1835 1836 bool SetSpecifier(Specifier VS, SourceLocation Loc, 1837 const char *&PrevSpec); 1838 1839 bool isOverrideSpecified() const { return Specifiers & VS_Override; } 1840 SourceLocation getOverrideLoc() const { return VS_overrideLoc; } 1841 1842 bool isFinalSpecified() const { return Specifiers & VS_Final; } 1843 SourceLocation getFinalLoc() const { return VS_finalLoc; } 1844 1845 void clear() { Specifiers = 0; } 1846 1847 static const char *getSpecifierName(Specifier VS); 1848 1849 SourceLocation getLastLocation() const { return LastLocation; } 1850 1851private: 1852 unsigned Specifiers; 1853 1854 SourceLocation VS_overrideLoc, VS_finalLoc; 1855 SourceLocation LastLocation; 1856}; 1857 1858/// LambdaCaptureDefault - The default, if any, capture method for a 1859/// lambda expression. 1860enum LambdaCaptureDefault { 1861 LCD_None, 1862 LCD_ByCopy, 1863 LCD_ByRef 1864}; 1865 1866/// LambdaCaptureKind - The different capture forms in a lambda 1867/// introducer: 'this' or a copied or referenced variable. 1868enum LambdaCaptureKind { 1869 LCK_This, 1870 LCK_ByCopy, 1871 LCK_ByRef 1872}; 1873 1874/// LambdaCapture - An individual capture in a lambda introducer. 1875struct LambdaCapture { 1876 LambdaCaptureKind Kind; 1877 SourceLocation Loc; 1878 IdentifierInfo* Id; 1879 1880 LambdaCapture(LambdaCaptureKind Kind, 1881 SourceLocation Loc, 1882 IdentifierInfo* Id = 0) 1883 : Kind(Kind), Loc(Loc), Id(Id) 1884 {} 1885}; 1886 1887/// LambdaIntroducer - Represents a complete lambda introducer. 1888struct LambdaIntroducer { 1889 SourceRange Range; 1890 LambdaCaptureDefault Default; 1891 llvm::SmallVector<LambdaCapture, 4> Captures; 1892 1893 LambdaIntroducer() 1894 : Default(LCD_None) {} 1895 1896 /// addCapture - Append a capture in a lambda introducer. 1897 void addCapture(LambdaCaptureKind Kind, 1898 SourceLocation Loc, 1899 IdentifierInfo* Id = 0) { 1900 Captures.push_back(LambdaCapture(Kind, Loc, Id)); 1901 } 1902 1903}; 1904 1905} // end namespace clang 1906 1907#endif 1908