1 //===--- IdentifierTable.h - Hash table for identifier lookup ---*- 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 IdentifierInfo, IdentifierTable, and Selector 11 // interfaces. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #ifndef LLVM_CLANG_BASIC_IDENTIFIERTABLE_H 16 #define LLVM_CLANG_BASIC_IDENTIFIERTABLE_H 17 18 #include "clang/Basic/OperatorKinds.h" 19 #include "clang/Basic/TokenKinds.h" 20 #include "clang/Basic/LLVM.h" 21 #include "llvm/ADT/StringMap.h" 22 #include "llvm/ADT/StringRef.h" 23 #include "llvm/ADT/SmallString.h" 24 #include "llvm/ADT/OwningPtr.h" 25 #include "llvm/Support/PointerLikeTypeTraits.h" 26 #include <cassert> 27 #include <cctype> 28 #include <string> 29 30 namespace llvm { 31 template <typename T> struct DenseMapInfo; 32 } 33 34 namespace clang { 35 class LangOptions; 36 class IdentifierInfo; 37 class IdentifierTable; 38 class SourceLocation; 39 class MultiKeywordSelector; // private class used by Selector 40 class DeclarationName; // AST class that stores declaration names 41 42 /// IdentifierLocPair - A simple pair of identifier info and location. 43 typedef std::pair<IdentifierInfo*, SourceLocation> IdentifierLocPair; 44 45 46 /// IdentifierInfo - One of these records is kept for each identifier that 47 /// is lexed. This contains information about whether the token was #define'd, 48 /// is a language keyword, or if it is a front-end token of some sort (e.g. a 49 /// variable or function name). The preprocessor keeps this information in a 50 /// set, and all tok::identifier tokens have a pointer to one of these. 51 class IdentifierInfo { 52 // Note: DON'T make TokenID a 'tok::TokenKind'; MSVC will treat it as a 53 // signed char and TokenKinds > 255 won't be handled correctly. 54 unsigned TokenID : 9; // Front-end token ID or tok::identifier. 55 // Objective-C keyword ('protocol' in '@protocol') or builtin (__builtin_inf). 56 // First NUM_OBJC_KEYWORDS values are for Objective-C, the remaining values 57 // are for builtins. 58 unsigned ObjCOrBuiltinID :11; 59 bool HasMacro : 1; // True if there is a #define for this. 60 bool IsExtension : 1; // True if identifier is a lang extension. 61 bool IsCXX11CompatKeyword : 1; // True if identifier is a keyword in C++11. 62 bool IsPoisoned : 1; // True if identifier is poisoned. 63 bool IsCPPOperatorKeyword : 1; // True if ident is a C++ operator keyword. 64 bool NeedsHandleIdentifier : 1; // See "RecomputeNeedsHandleIdentifier". 65 bool IsFromAST : 1; // True if identfier first appeared in an AST 66 // file and wasn't modified since. 67 bool RevertedTokenID : 1; // True if RevertTokenIDToIdentifier was 68 // called. 69 // 5 bits left in 32-bit word. 70 void *FETokenInfo; // Managed by the language front-end. 71 llvm::StringMapEntry<IdentifierInfo*> *Entry; 72 73 IdentifierInfo(const IdentifierInfo&); // NONCOPYABLE. 74 void operator=(const IdentifierInfo&); // NONASSIGNABLE. 75 76 friend class IdentifierTable; 77 78 public: 79 IdentifierInfo(); 80 81 82 /// isStr - Return true if this is the identifier for the specified string. 83 /// This is intended to be used for string literals only: II->isStr("foo"). 84 template <std::size_t StrLen> 85 bool isStr(const char (&Str)[StrLen]) const { 86 return getLength() == StrLen-1 && !memcmp(getNameStart(), Str, StrLen-1); 87 } 88 89 /// getNameStart - Return the beginning of the actual string for this 90 /// identifier. The returned string is properly null terminated. 91 /// 92 const char *getNameStart() const { 93 if (Entry) return Entry->getKeyData(); 94 // FIXME: This is gross. It would be best not to embed specific details 95 // of the PTH file format here. 96 // The 'this' pointer really points to a 97 // std::pair<IdentifierInfo, const char*>, where internal pointer 98 // points to the external string data. 99 typedef std::pair<IdentifierInfo, const char*> actualtype; 100 return ((const actualtype*) this)->second; 101 } 102 103 /// getLength - Efficiently return the length of this identifier info. 104 /// 105 unsigned getLength() const { 106 if (Entry) return Entry->getKeyLength(); 107 // FIXME: This is gross. It would be best not to embed specific details 108 // of the PTH file format here. 109 // The 'this' pointer really points to a 110 // std::pair<IdentifierInfo, const char*>, where internal pointer 111 // points to the external string data. 112 typedef std::pair<IdentifierInfo, const char*> actualtype; 113 const char* p = ((const actualtype*) this)->second - 2; 114 return (((unsigned) p[0]) | (((unsigned) p[1]) << 8)) - 1; 115 } 116 117 /// getName - Return the actual identifier string. 118 StringRef getName() const { 119 return StringRef(getNameStart(), getLength()); 120 } 121 122 /// hasMacroDefinition - Return true if this identifier is #defined to some 123 /// other value. 124 bool hasMacroDefinition() const { 125 return HasMacro; 126 } 127 void setHasMacroDefinition(bool Val) { 128 if (HasMacro == Val) return; 129 130 HasMacro = Val; 131 if (Val) 132 NeedsHandleIdentifier = 1; 133 else 134 RecomputeNeedsHandleIdentifier(); 135 IsFromAST = false; 136 } 137 138 /// getTokenID - If this is a source-language token (e.g. 'for'), this API 139 /// can be used to cause the lexer to map identifiers to source-language 140 /// tokens. 141 tok::TokenKind getTokenID() const { return (tok::TokenKind)TokenID; } 142 143 /// \brief True if RevertTokenIDToIdentifier() was called. 144 bool hasRevertedTokenIDToIdentifier() const { return RevertedTokenID; } 145 146 /// \brief Revert TokenID to tok::identifier; used for GNU libstdc++ 4.2 147 /// compatibility. 148 /// 149 /// TokenID is normally read-only but there are 2 instances where we revert it 150 /// to tok::identifier for libstdc++ 4.2. Keep track of when this happens 151 /// using this method so we can inform serialization about it. 152 void RevertTokenIDToIdentifier() { 153 assert(TokenID != tok::identifier && "Already at tok::identifier"); 154 TokenID = tok::identifier; 155 RevertedTokenID = true; 156 } 157 158 /// getPPKeywordID - Return the preprocessor keyword ID for this identifier. 159 /// For example, "define" will return tok::pp_define. 160 tok::PPKeywordKind getPPKeywordID() const; 161 162 /// getObjCKeywordID - Return the Objective-C keyword ID for the this 163 /// identifier. For example, 'class' will return tok::objc_class if ObjC is 164 /// enabled. 165 tok::ObjCKeywordKind getObjCKeywordID() const { 166 if (ObjCOrBuiltinID < tok::NUM_OBJC_KEYWORDS) 167 return tok::ObjCKeywordKind(ObjCOrBuiltinID); 168 else 169 return tok::objc_not_keyword; 170 } 171 void setObjCKeywordID(tok::ObjCKeywordKind ID) { ObjCOrBuiltinID = ID; } 172 173 /// getBuiltinID - Return a value indicating whether this is a builtin 174 /// function. 0 is not-built-in. 1 is builtin-for-some-nonprimary-target. 175 /// 2+ are specific builtin functions. 176 unsigned getBuiltinID() const { 177 if (ObjCOrBuiltinID >= tok::NUM_OBJC_KEYWORDS) 178 return ObjCOrBuiltinID - tok::NUM_OBJC_KEYWORDS; 179 else 180 return 0; 181 } 182 void setBuiltinID(unsigned ID) { 183 ObjCOrBuiltinID = ID + tok::NUM_OBJC_KEYWORDS; 184 assert(ObjCOrBuiltinID - unsigned(tok::NUM_OBJC_KEYWORDS) == ID 185 && "ID too large for field!"); 186 } 187 188 unsigned getObjCOrBuiltinID() const { return ObjCOrBuiltinID; } 189 void setObjCOrBuiltinID(unsigned ID) { ObjCOrBuiltinID = ID; } 190 191 /// get/setExtension - Initialize information about whether or not this 192 /// language token is an extension. This controls extension warnings, and is 193 /// only valid if a custom token ID is set. 194 bool isExtensionToken() const { return IsExtension; } 195 void setIsExtensionToken(bool Val) { 196 IsExtension = Val; 197 if (Val) 198 NeedsHandleIdentifier = 1; 199 else 200 RecomputeNeedsHandleIdentifier(); 201 } 202 203 /// is/setIsCXX11CompatKeyword - Initialize information about whether or not 204 /// this language token is a keyword in C++11. This controls compatibility 205 /// warnings, and is only true when not parsing C++11. Once a compatibility 206 /// problem has been diagnosed with this keyword, the flag will be cleared. 207 bool isCXX11CompatKeyword() const { return IsCXX11CompatKeyword; } 208 void setIsCXX11CompatKeyword(bool Val) { 209 IsCXX11CompatKeyword = Val; 210 if (Val) 211 NeedsHandleIdentifier = 1; 212 else 213 RecomputeNeedsHandleIdentifier(); 214 } 215 216 /// setIsPoisoned - Mark this identifier as poisoned. After poisoning, the 217 /// Preprocessor will emit an error every time this token is used. 218 void setIsPoisoned(bool Value = true) { 219 IsPoisoned = Value; 220 if (Value) 221 NeedsHandleIdentifier = 1; 222 else 223 RecomputeNeedsHandleIdentifier(); 224 IsFromAST = false; 225 } 226 227 /// isPoisoned - Return true if this token has been poisoned. 228 bool isPoisoned() const { return IsPoisoned; } 229 230 /// isCPlusPlusOperatorKeyword/setIsCPlusPlusOperatorKeyword controls whether 231 /// this identifier is a C++ alternate representation of an operator. 232 void setIsCPlusPlusOperatorKeyword(bool Val = true) { 233 IsCPPOperatorKeyword = Val; 234 if (Val) 235 NeedsHandleIdentifier = 1; 236 else 237 RecomputeNeedsHandleIdentifier(); 238 } 239 bool isCPlusPlusOperatorKeyword() const { return IsCPPOperatorKeyword; } 240 241 /// getFETokenInfo/setFETokenInfo - The language front-end is allowed to 242 /// associate arbitrary metadata with this token. 243 template<typename T> 244 T *getFETokenInfo() const { return static_cast<T*>(FETokenInfo); } 245 void setFETokenInfo(void *T) { FETokenInfo = T; } 246 247 /// isHandleIdentifierCase - Return true if the Preprocessor::HandleIdentifier 248 /// must be called on a token of this identifier. If this returns false, we 249 /// know that HandleIdentifier will not affect the token. 250 bool isHandleIdentifierCase() const { return NeedsHandleIdentifier; } 251 252 /// isFromAST - Return true if the identifier in its current state was loaded 253 /// from an AST file. 254 bool isFromAST() const { return IsFromAST; } 255 256 void setIsFromAST(bool FromAST = true) { IsFromAST = FromAST; } 257 258 private: 259 /// RecomputeNeedsHandleIdentifier - The Preprocessor::HandleIdentifier does 260 /// several special (but rare) things to identifiers of various sorts. For 261 /// example, it changes the "for" keyword token from tok::identifier to 262 /// tok::for. 263 /// 264 /// This method is very tied to the definition of HandleIdentifier. Any 265 /// change to it should be reflected here. 266 void RecomputeNeedsHandleIdentifier() { 267 NeedsHandleIdentifier = 268 (isPoisoned() | hasMacroDefinition() | isCPlusPlusOperatorKeyword() | 269 isExtensionToken() | isCXX11CompatKeyword() || 270 (getTokenID() == tok::kw___import_module__)); 271 } 272 }; 273 274 /// \brief an RAII object for [un]poisoning an identifier 275 /// within a certain scope. II is allowed to be null, in 276 /// which case, objects of this type have no effect. 277 class PoisonIdentifierRAIIObject { 278 IdentifierInfo *const II; 279 const bool OldValue; 280 public: 281 PoisonIdentifierRAIIObject(IdentifierInfo *II, bool NewValue) 282 : II(II), OldValue(II ? II->isPoisoned() : false) { 283 if(II) 284 II->setIsPoisoned(NewValue); 285 } 286 287 ~PoisonIdentifierRAIIObject() { 288 if(II) 289 II->setIsPoisoned(OldValue); 290 } 291 }; 292 293 /// \brief An iterator that walks over all of the known identifiers 294 /// in the lookup table. 295 /// 296 /// Since this iterator uses an abstract interface via virtual 297 /// functions, it uses an object-oriented interface rather than the 298 /// more standard C++ STL iterator interface. In this OO-style 299 /// iteration, the single function \c Next() provides dereference, 300 /// advance, and end-of-sequence checking in a single 301 /// operation. Subclasses of this iterator type will provide the 302 /// actual functionality. 303 class IdentifierIterator { 304 private: 305 IdentifierIterator(const IdentifierIterator&); // Do not implement 306 IdentifierIterator &operator=(const IdentifierIterator&); // Do not implement 307 308 protected: 309 IdentifierIterator() { } 310 311 public: 312 virtual ~IdentifierIterator(); 313 314 /// \brief Retrieve the next string in the identifier table and 315 /// advances the iterator for the following string. 316 /// 317 /// \returns The next string in the identifier table. If there is 318 /// no such string, returns an empty \c StringRef. 319 virtual StringRef Next() = 0; 320 }; 321 322 /// IdentifierInfoLookup - An abstract class used by IdentifierTable that 323 /// provides an interface for performing lookups from strings 324 /// (const char *) to IdentiferInfo objects. 325 class IdentifierInfoLookup { 326 public: 327 virtual ~IdentifierInfoLookup(); 328 329 /// get - Return the identifier token info for the specified named identifier. 330 /// Unlike the version in IdentifierTable, this returns a pointer instead 331 /// of a reference. If the pointer is NULL then the IdentifierInfo cannot 332 /// be found. 333 virtual IdentifierInfo* get(StringRef Name) = 0; 334 335 /// \brief Retrieve an iterator into the set of all identifiers 336 /// known to this identifier lookup source. 337 /// 338 /// This routine provides access to all of the identifiers known to 339 /// the identifier lookup, allowing access to the contents of the 340 /// identifiers without introducing the overhead of constructing 341 /// IdentifierInfo objects for each. 342 /// 343 /// \returns A new iterator into the set of known identifiers. The 344 /// caller is responsible for deleting this iterator. 345 virtual IdentifierIterator *getIdentifiers() const; 346 }; 347 348 /// \brief An abstract class used to resolve numerical identifier 349 /// references (meaningful only to some external source) into 350 /// IdentifierInfo pointers. 351 class ExternalIdentifierLookup { 352 public: 353 virtual ~ExternalIdentifierLookup(); 354 355 /// \brief Return the identifier associated with the given ID number. 356 /// 357 /// The ID 0 is associated with the NULL identifier. 358 virtual IdentifierInfo *GetIdentifier(unsigned ID) = 0; 359 }; 360 361 /// IdentifierTable - This table implements an efficient mapping from strings to 362 /// IdentifierInfo nodes. It has no other purpose, but this is an 363 /// extremely performance-critical piece of the code, as each occurrence of 364 /// every identifier goes through here when lexed. 365 class IdentifierTable { 366 // Shark shows that using MallocAllocator is *much* slower than using this 367 // BumpPtrAllocator! 368 typedef llvm::StringMap<IdentifierInfo*, llvm::BumpPtrAllocator> HashTableTy; 369 HashTableTy HashTable; 370 371 IdentifierInfoLookup* ExternalLookup; 372 373 public: 374 /// IdentifierTable ctor - Create the identifier table, populating it with 375 /// info about the language keywords for the language specified by LangOpts. 376 IdentifierTable(const LangOptions &LangOpts, 377 IdentifierInfoLookup* externalLookup = 0); 378 379 /// \brief Set the external identifier lookup mechanism. 380 void setExternalIdentifierLookup(IdentifierInfoLookup *IILookup) { 381 ExternalLookup = IILookup; 382 } 383 384 /// \brief Retrieve the external identifier lookup object, if any. 385 IdentifierInfoLookup *getExternalIdentifierLookup() const { 386 return ExternalLookup; 387 } 388 389 llvm::BumpPtrAllocator& getAllocator() { 390 return HashTable.getAllocator(); 391 } 392 393 /// get - Return the identifier token info for the specified named identifier. 394 /// 395 IdentifierInfo &get(StringRef Name) { 396 llvm::StringMapEntry<IdentifierInfo*> &Entry = 397 HashTable.GetOrCreateValue(Name); 398 399 IdentifierInfo *II = Entry.getValue(); 400 if (II) return *II; 401 402 // No entry; if we have an external lookup, look there first. 403 if (ExternalLookup) { 404 II = ExternalLookup->get(Name); 405 if (II) { 406 // Cache in the StringMap for subsequent lookups. 407 Entry.setValue(II); 408 return *II; 409 } 410 } 411 412 // Lookups failed, make a new IdentifierInfo. 413 void *Mem = getAllocator().Allocate<IdentifierInfo>(); 414 II = new (Mem) IdentifierInfo(); 415 Entry.setValue(II); 416 417 // Make sure getName() knows how to find the IdentifierInfo 418 // contents. 419 II->Entry = &Entry; 420 421 return *II; 422 } 423 424 IdentifierInfo &get(StringRef Name, tok::TokenKind TokenCode) { 425 IdentifierInfo &II = get(Name); 426 II.TokenID = TokenCode; 427 assert(II.TokenID == (unsigned) TokenCode && "TokenCode too large"); 428 return II; 429 } 430 431 /// \brief Gets an IdentifierInfo for the given name without consulting 432 /// external sources. 433 /// 434 /// This is a version of get() meant for external sources that want to 435 /// introduce or modify an identifier. If they called get(), they would 436 /// likely end up in a recursion. 437 IdentifierInfo &getOwn(StringRef Name) { 438 llvm::StringMapEntry<IdentifierInfo*> &Entry = 439 HashTable.GetOrCreateValue(Name); 440 441 IdentifierInfo *II = Entry.getValue(); 442 if (!II) { 443 444 // Lookups failed, make a new IdentifierInfo. 445 void *Mem = getAllocator().Allocate<IdentifierInfo>(); 446 II = new (Mem) IdentifierInfo(); 447 Entry.setValue(II); 448 449 // Make sure getName() knows how to find the IdentifierInfo 450 // contents. 451 II->Entry = &Entry; 452 } 453 454 return *II; 455 } 456 457 typedef HashTableTy::const_iterator iterator; 458 typedef HashTableTy::const_iterator const_iterator; 459 460 iterator begin() const { return HashTable.begin(); } 461 iterator end() const { return HashTable.end(); } 462 unsigned size() const { return HashTable.size(); } 463 464 /// PrintStats - Print some statistics to stderr that indicate how well the 465 /// hashing is doing. 466 void PrintStats() const; 467 468 void AddKeywords(const LangOptions &LangOpts); 469 }; 470 471 /// ObjCMethodFamily - A family of Objective-C methods. These 472 /// families have no inherent meaning in the language, but are 473 /// nonetheless central enough in the existing implementations to 474 /// merit direct AST support. While, in theory, arbitrary methods can 475 /// be considered to form families, we focus here on the methods 476 /// involving allocation and retain-count management, as these are the 477 /// most "core" and the most likely to be useful to diverse clients 478 /// without extra information. 479 /// 480 /// Both selectors and actual method declarations may be classified 481 /// into families. Method families may impose additional restrictions 482 /// beyond their selector name; for example, a method called '_init' 483 /// that returns void is not considered to be in the 'init' family 484 /// (but would be if it returned 'id'). It is also possible to 485 /// explicitly change or remove a method's family. Therefore the 486 /// method's family should be considered the single source of truth. 487 enum ObjCMethodFamily { 488 /// \brief No particular method family. 489 OMF_None, 490 491 // Selectors in these families may have arbitrary arity, may be 492 // written with arbitrary leading underscores, and may have 493 // additional CamelCase "words" in their first selector chunk 494 // following the family name. 495 OMF_alloc, 496 OMF_copy, 497 OMF_init, 498 OMF_mutableCopy, 499 OMF_new, 500 501 // These families are singletons consisting only of the nullary 502 // selector with the given name. 503 OMF_autorelease, 504 OMF_dealloc, 505 OMF_finalize, 506 OMF_release, 507 OMF_retain, 508 OMF_retainCount, 509 OMF_self, 510 511 // performSelector families 512 OMF_performSelector 513 }; 514 515 /// Enough bits to store any enumerator in ObjCMethodFamily or 516 /// InvalidObjCMethodFamily. 517 enum { ObjCMethodFamilyBitWidth = 4 }; 518 519 /// An invalid value of ObjCMethodFamily. 520 enum { InvalidObjCMethodFamily = (1 << ObjCMethodFamilyBitWidth) - 1 }; 521 522 /// Selector - This smart pointer class efficiently represents Objective-C 523 /// method names. This class will either point to an IdentifierInfo or a 524 /// MultiKeywordSelector (which is private). This enables us to optimize 525 /// selectors that take no arguments and selectors that take 1 argument, which 526 /// accounts for 78% of all selectors in Cocoa.h. 527 class Selector { 528 friend class Diagnostic; 529 530 enum IdentifierInfoFlag { 531 // MultiKeywordSelector = 0. 532 ZeroArg = 0x1, 533 OneArg = 0x2, 534 ArgFlags = ZeroArg|OneArg 535 }; 536 uintptr_t InfoPtr; // a pointer to the MultiKeywordSelector or IdentifierInfo. 537 538 Selector(IdentifierInfo *II, unsigned nArgs) { 539 InfoPtr = reinterpret_cast<uintptr_t>(II); 540 assert((InfoPtr & ArgFlags) == 0 &&"Insufficiently aligned IdentifierInfo"); 541 assert(nArgs < 2 && "nArgs not equal to 0/1"); 542 InfoPtr |= nArgs+1; 543 } 544 Selector(MultiKeywordSelector *SI) { 545 InfoPtr = reinterpret_cast<uintptr_t>(SI); 546 assert((InfoPtr & ArgFlags) == 0 &&"Insufficiently aligned IdentifierInfo"); 547 } 548 549 IdentifierInfo *getAsIdentifierInfo() const { 550 if (getIdentifierInfoFlag()) 551 return reinterpret_cast<IdentifierInfo *>(InfoPtr & ~ArgFlags); 552 return 0; 553 } 554 unsigned getIdentifierInfoFlag() const { 555 return InfoPtr & ArgFlags; 556 } 557 558 static ObjCMethodFamily getMethodFamilyImpl(Selector sel); 559 560 public: 561 friend class SelectorTable; // only the SelectorTable can create these 562 friend class DeclarationName; // and the AST's DeclarationName. 563 564 /// The default ctor should only be used when creating data structures that 565 /// will contain selectors. 566 Selector() : InfoPtr(0) {} 567 Selector(uintptr_t V) : InfoPtr(V) {} 568 569 /// operator==/!= - Indicate whether the specified selectors are identical. 570 bool operator==(Selector RHS) const { 571 return InfoPtr == RHS.InfoPtr; 572 } 573 bool operator!=(Selector RHS) const { 574 return InfoPtr != RHS.InfoPtr; 575 } 576 void *getAsOpaquePtr() const { 577 return reinterpret_cast<void*>(InfoPtr); 578 } 579 580 /// \brief Determine whether this is the empty selector. 581 bool isNull() const { return InfoPtr == 0; } 582 583 // Predicates to identify the selector type. 584 bool isKeywordSelector() const { 585 return getIdentifierInfoFlag() != ZeroArg; 586 } 587 bool isUnarySelector() const { 588 return getIdentifierInfoFlag() == ZeroArg; 589 } 590 unsigned getNumArgs() const; 591 592 593 /// \brief Retrieve the identifier at a given position in the selector. 594 /// 595 /// Note that the identifier pointer returned may be NULL. Clients that only 596 /// care about the text of the identifier string, and not the specific, 597 /// uniqued identifier pointer, should use \c getNameForSlot(), which returns 598 /// an empty string when the identifier pointer would be NULL. 599 /// 600 /// \param argIndex The index for which we want to retrieve the identifier. 601 /// This index shall be less than \c getNumArgs() unless this is a keyword 602 /// selector, in which case 0 is the only permissible value. 603 /// 604 /// \returns the uniqued identifier for this slot, or NULL if this slot has 605 /// no corresponding identifier. 606 IdentifierInfo *getIdentifierInfoForSlot(unsigned argIndex) const; 607 608 /// \brief Retrieve the name at a given position in the selector. 609 /// 610 /// \param argIndex The index for which we want to retrieve the name. 611 /// This index shall be less than \c getNumArgs() unless this is a keyword 612 /// selector, in which case 0 is the only permissible value. 613 /// 614 /// \returns the name for this slot, which may be the empty string if no 615 /// name was supplied. 616 StringRef getNameForSlot(unsigned argIndex) const; 617 618 /// getAsString - Derive the full selector name (e.g. "foo:bar:") and return 619 /// it as an std::string. 620 std::string getAsString() const; 621 622 /// getMethodFamily - Derive the conventional family of this method. 623 ObjCMethodFamily getMethodFamily() const { 624 return getMethodFamilyImpl(*this); 625 } 626 627 static Selector getEmptyMarker() { 628 return Selector(uintptr_t(-1)); 629 } 630 static Selector getTombstoneMarker() { 631 return Selector(uintptr_t(-2)); 632 } 633 }; 634 635 /// SelectorTable - This table allows us to fully hide how we implement 636 /// multi-keyword caching. 637 class SelectorTable { 638 void *Impl; // Actually a SelectorTableImpl 639 SelectorTable(const SelectorTable&); // DISABLED: DO NOT IMPLEMENT 640 void operator=(const SelectorTable&); // DISABLED: DO NOT IMPLEMENT 641 public: 642 SelectorTable(); 643 ~SelectorTable(); 644 645 /// getSelector - This can create any sort of selector. NumArgs indicates 646 /// whether this is a no argument selector "foo", a single argument selector 647 /// "foo:" or multi-argument "foo:bar:". 648 Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV); 649 650 Selector getUnarySelector(IdentifierInfo *ID) { 651 return Selector(ID, 1); 652 } 653 Selector getNullarySelector(IdentifierInfo *ID) { 654 return Selector(ID, 0); 655 } 656 657 /// Return the total amount of memory allocated for managing selectors. 658 size_t getTotalMemory() const; 659 660 /// constructSetterName - Return the setter name for the given 661 /// identifier, i.e. "set" + Name where the initial character of Name 662 /// has been capitalized. 663 static Selector constructSetterName(IdentifierTable &Idents, 664 SelectorTable &SelTable, 665 const IdentifierInfo *Name) { 666 llvm::SmallString<100> SelectorName; 667 SelectorName = "set"; 668 SelectorName += Name->getName(); 669 SelectorName[3] = toupper(SelectorName[3]); 670 IdentifierInfo *SetterName = &Idents.get(SelectorName); 671 return SelTable.getUnarySelector(SetterName); 672 } 673 }; 674 675 /// DeclarationNameExtra - Common base of the MultiKeywordSelector, 676 /// CXXSpecialName, and CXXOperatorIdName classes, all of which are 677 /// private classes that describe different kinds of names. 678 class DeclarationNameExtra { 679 public: 680 /// ExtraKind - The kind of "extra" information stored in the 681 /// DeclarationName. See @c ExtraKindOrNumArgs for an explanation of 682 /// how these enumerator values are used. 683 enum ExtraKind { 684 CXXConstructor = 0, 685 CXXDestructor, 686 CXXConversionFunction, 687 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \ 688 CXXOperator##Name, 689 #include "clang/Basic/OperatorKinds.def" 690 CXXLiteralOperator, 691 CXXUsingDirective, 692 NUM_EXTRA_KINDS 693 }; 694 695 /// ExtraKindOrNumArgs - Either the kind of C++ special name or 696 /// operator-id (if the value is one of the CXX* enumerators of 697 /// ExtraKind), in which case the DeclarationNameExtra is also a 698 /// CXXSpecialName, (for CXXConstructor, CXXDestructor, or 699 /// CXXConversionFunction) CXXOperatorIdName, or CXXLiteralOperatorName, 700 /// it may be also name common to C++ using-directives (CXXUsingDirective), 701 /// otherwise it is NUM_EXTRA_KINDS+NumArgs, where NumArgs is the number of 702 /// arguments in the Objective-C selector, in which case the 703 /// DeclarationNameExtra is also a MultiKeywordSelector. 704 unsigned ExtraKindOrNumArgs; 705 }; 706 707 } // end namespace clang 708 709 namespace llvm { 710 /// Define DenseMapInfo so that Selectors can be used as keys in DenseMap and 711 /// DenseSets. 712 template <> 713 struct DenseMapInfo<clang::Selector> { 714 static inline clang::Selector getEmptyKey() { 715 return clang::Selector::getEmptyMarker(); 716 } 717 static inline clang::Selector getTombstoneKey() { 718 return clang::Selector::getTombstoneMarker(); 719 } 720 721 static unsigned getHashValue(clang::Selector S); 722 723 static bool isEqual(clang::Selector LHS, clang::Selector RHS) { 724 return LHS == RHS; 725 } 726 }; 727 728 template <> 729 struct isPodLike<clang::Selector> { static const bool value = true; }; 730 731 template<> 732 class PointerLikeTypeTraits<clang::Selector> { 733 public: 734 static inline const void *getAsVoidPointer(clang::Selector P) { 735 return P.getAsOpaquePtr(); 736 } 737 static inline clang::Selector getFromVoidPointer(const void *P) { 738 return clang::Selector(reinterpret_cast<uintptr_t>(P)); 739 } 740 enum { NumLowBitsAvailable = 0 }; 741 }; 742 743 // Provide PointerLikeTypeTraits for IdentifierInfo pointers, which 744 // are not guaranteed to be 8-byte aligned. 745 template<> 746 class PointerLikeTypeTraits<clang::IdentifierInfo*> { 747 public: 748 static inline void *getAsVoidPointer(clang::IdentifierInfo* P) { 749 return P; 750 } 751 static inline clang::IdentifierInfo *getFromVoidPointer(void *P) { 752 return static_cast<clang::IdentifierInfo*>(P); 753 } 754 enum { NumLowBitsAvailable = 1 }; 755 }; 756 757 template<> 758 class PointerLikeTypeTraits<const clang::IdentifierInfo*> { 759 public: 760 static inline const void *getAsVoidPointer(const clang::IdentifierInfo* P) { 761 return P; 762 } 763 static inline const clang::IdentifierInfo *getFromVoidPointer(const void *P) { 764 return static_cast<const clang::IdentifierInfo*>(P); 765 } 766 enum { NumLowBitsAvailable = 1 }; 767 }; 768 769 } // end namespace llvm 770 #endif 771