clang  8.0.0svn
IdentifierTable.cpp
Go to the documentation of this file.
1 //===- IdentifierTable.cpp - Hash table for identifier lookup -------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the IdentifierInfo, IdentifierVisitor, and
11 // IdentifierTable interfaces.
12 //
13 //===----------------------------------------------------------------------===//
14 
16 #include "clang/Basic/CharInfo.h"
19 #include "clang/Basic/Specifiers.h"
20 #include "clang/Basic/TokenKinds.h"
21 #include "llvm/ADT/DenseMapInfo.h"
22 #include "llvm/ADT/FoldingSet.h"
23 #include "llvm/ADT/SmallString.h"
24 #include "llvm/ADT/StringMap.h"
25 #include "llvm/ADT/StringRef.h"
26 #include "llvm/Support/Allocator.h"
27 #include "llvm/Support/ErrorHandling.h"
28 #include "llvm/Support/raw_ostream.h"
29 #include <cassert>
30 #include <cstdio>
31 #include <cstring>
32 #include <string>
33 
34 using namespace clang;
35 
36 //===----------------------------------------------------------------------===//
37 // IdentifierInfo Implementation
38 //===----------------------------------------------------------------------===//
39 
41  TokenID = tok::identifier;
42  ObjCOrBuiltinID = 0;
43  HasMacro = false;
44  HadMacro = false;
45  IsExtension = false;
46  IsFutureCompatKeyword = false;
47  IsPoisoned = false;
48  IsCPPOperatorKeyword = false;
49  NeedsHandleIdentifier = false;
50  IsFromAST = false;
51  ChangedAfterLoad = false;
52  FEChangedAfterLoad = false;
53  RevertedTokenID = false;
54  OutOfDate = false;
55  IsModulesImport = false;
56 }
57 
58 //===----------------------------------------------------------------------===//
59 // IdentifierTable Implementation
60 //===----------------------------------------------------------------------===//
61 
63 
65 
66 namespace {
67 
68 /// A simple identifier lookup iterator that represents an
69 /// empty sequence of identifiers.
70 class EmptyLookupIterator : public IdentifierIterator
71 {
72 public:
73  StringRef Next() override { return StringRef(); }
74 };
75 
76 } // namespace
77 
79  return new EmptyLookupIterator();
80 }
81 
83  : HashTable(8192), // Start with space for 8K identifiers.
84  ExternalLookup(ExternalLookup) {}
85 
87  IdentifierInfoLookup *ExternalLookup)
88  : IdentifierTable(ExternalLookup) {
89  // Populate the identifier table with info about keywords for the current
90  // language.
91  AddKeywords(LangOpts);
92 }
93 
94 //===----------------------------------------------------------------------===//
95 // Language Keyword Implementation
96 //===----------------------------------------------------------------------===//
97 
98 // Constants for TokenKinds.def
99 namespace {
100 
101  enum {
102  KEYC99 = 0x1,
103  KEYCXX = 0x2,
104  KEYCXX11 = 0x4,
105  KEYGNU = 0x8,
106  KEYMS = 0x10,
107  BOOLSUPPORT = 0x20,
108  KEYALTIVEC = 0x40,
109  KEYNOCXX = 0x80,
110  KEYBORLAND = 0x100,
111  KEYOPENCLC = 0x200,
112  KEYC11 = 0x400,
113  KEYNOMS18 = 0x800,
114  KEYNOOPENCL = 0x1000,
115  WCHARSUPPORT = 0x2000,
116  HALFSUPPORT = 0x4000,
117  CHAR8SUPPORT = 0x8000,
118  KEYCONCEPTS = 0x10000,
119  KEYOBJC = 0x20000,
120  KEYZVECTOR = 0x40000,
121  KEYCOROUTINES = 0x80000,
122  KEYMODULES = 0x100000,
123  KEYCXX2A = 0x200000,
124  KEYOPENCLCXX = 0x400000,
125  KEYALLCXX = KEYCXX | KEYCXX11 | KEYCXX2A,
126  KEYALL = (0xffffff & ~KEYNOMS18 &
127  ~KEYNOOPENCL) // KEYNOMS18 and KEYNOOPENCL are used to exclude.
128  };
129 
130  /// How a keyword is treated in the selected standard.
132  KS_Disabled, // Disabled
133  KS_Extension, // Is an extension
134  KS_Enabled, // Enabled
135  KS_Future // Is a keyword in future standard
136  };
137 
138 } // namespace
139 
140 /// Translates flags as specified in TokenKinds.def into keyword status
141 /// in the given language standard.
143  unsigned Flags) {
144  if (Flags == KEYALL) return KS_Enabled;
145  if (LangOpts.CPlusPlus && (Flags & KEYCXX)) return KS_Enabled;
146  if (LangOpts.CPlusPlus11 && (Flags & KEYCXX11)) return KS_Enabled;
147  if (LangOpts.CPlusPlus2a && (Flags & KEYCXX2A)) return KS_Enabled;
148  if (LangOpts.C99 && (Flags & KEYC99)) return KS_Enabled;
149  if (LangOpts.GNUKeywords && (Flags & KEYGNU)) return KS_Extension;
150  if (LangOpts.MicrosoftExt && (Flags & KEYMS)) return KS_Extension;
151  if (LangOpts.Borland && (Flags & KEYBORLAND)) return KS_Extension;
152  if (LangOpts.Bool && (Flags & BOOLSUPPORT)) return KS_Enabled;
153  if (LangOpts.Half && (Flags & HALFSUPPORT)) return KS_Enabled;
154  if (LangOpts.WChar && (Flags & WCHARSUPPORT)) return KS_Enabled;
155  if (LangOpts.Char8 && (Flags & CHAR8SUPPORT)) return KS_Enabled;
156  if (LangOpts.AltiVec && (Flags & KEYALTIVEC)) return KS_Enabled;
157  if (LangOpts.ZVector && (Flags & KEYZVECTOR)) return KS_Enabled;
158  if (LangOpts.OpenCL && !LangOpts.OpenCLCPlusPlus && (Flags & KEYOPENCLC))
159  return KS_Enabled;
160  if (LangOpts.OpenCLCPlusPlus && (Flags & KEYOPENCLCXX)) return KS_Enabled;
161  if (!LangOpts.CPlusPlus && (Flags & KEYNOCXX)) return KS_Enabled;
162  if (LangOpts.C11 && (Flags & KEYC11)) return KS_Enabled;
163  // We treat bridge casts as objective-C keywords so we can warn on them
164  // in non-arc mode.
165  if (LangOpts.ObjC && (Flags & KEYOBJC)) return KS_Enabled;
166  if (LangOpts.ConceptsTS && (Flags & KEYCONCEPTS)) return KS_Enabled;
167  if (LangOpts.CoroutinesTS && (Flags & KEYCOROUTINES)) return KS_Enabled;
168  if (LangOpts.ModulesTS && (Flags & KEYMODULES)) return KS_Enabled;
169  if (LangOpts.CPlusPlus && (Flags & KEYALLCXX)) return KS_Future;
170  return KS_Disabled;
171 }
172 
173 /// AddKeyword - This method is used to associate a token ID with specific
174 /// identifiers because they are language keywords. This causes the lexer to
175 /// automatically map matching identifiers to specialized token codes.
176 static void AddKeyword(StringRef Keyword,
177  tok::TokenKind TokenCode, unsigned Flags,
178  const LangOptions &LangOpts, IdentifierTable &Table) {
179  KeywordStatus AddResult = getKeywordStatus(LangOpts, Flags);
180 
181  // Don't add this keyword under MSVCCompat.
182  if (LangOpts.MSVCCompat && (Flags & KEYNOMS18) &&
184  return;
185 
186  // Don't add this keyword under OpenCL.
187  if (LangOpts.OpenCL && (Flags & KEYNOOPENCL))
188  return;
189 
190  // Don't add this keyword if disabled in this language.
191  if (AddResult == KS_Disabled) return;
192 
193  IdentifierInfo &Info =
194  Table.get(Keyword, AddResult == KS_Future ? tok::identifier : TokenCode);
195  Info.setIsExtensionToken(AddResult == KS_Extension);
196  Info.setIsFutureCompatKeyword(AddResult == KS_Future);
197 }
198 
199 /// AddCXXOperatorKeyword - Register a C++ operator keyword alternative
200 /// representations.
201 static void AddCXXOperatorKeyword(StringRef Keyword,
202  tok::TokenKind TokenCode,
203  IdentifierTable &Table) {
204  IdentifierInfo &Info = Table.get(Keyword, TokenCode);
206 }
207 
208 /// AddObjCKeyword - Register an Objective-C \@keyword like "class" "selector"
209 /// or "property".
210 static void AddObjCKeyword(StringRef Name,
211  tok::ObjCKeywordKind ObjCID,
212  IdentifierTable &Table) {
213  Table.get(Name).setObjCKeywordID(ObjCID);
214 }
215 
216 /// AddKeywords - Add all keywords to the symbol table.
217 ///
219  // Add keywords and tokens for the current language.
220 #define KEYWORD(NAME, FLAGS) \
221  AddKeyword(StringRef(#NAME), tok::kw_ ## NAME, \
222  FLAGS, LangOpts, *this);
223 #define ALIAS(NAME, TOK, FLAGS) \
224  AddKeyword(StringRef(NAME), tok::kw_ ## TOK, \
225  FLAGS, LangOpts, *this);
226 #define CXX_KEYWORD_OPERATOR(NAME, ALIAS) \
227  if (LangOpts.CXXOperatorNames) \
228  AddCXXOperatorKeyword(StringRef(#NAME), tok::ALIAS, *this);
229 #define OBJC_AT_KEYWORD(NAME) \
230  if (LangOpts.ObjC) \
231  AddObjCKeyword(StringRef(#NAME), tok::objc_##NAME, *this);
232 #define TESTING_KEYWORD(NAME, FLAGS)
233 #include "clang/Basic/TokenKinds.def"
234 
235  if (LangOpts.ParseUnknownAnytype)
236  AddKeyword("__unknown_anytype", tok::kw___unknown_anytype, KEYALL,
237  LangOpts, *this);
238 
239  if (LangOpts.DeclSpecKeyword)
240  AddKeyword("__declspec", tok::kw___declspec, KEYALL, LangOpts, *this);
241 
242  // Add the '_experimental_modules_import' contextual keyword.
243  get("import").setModulesImport(true);
244 }
245 
246 /// Checks if the specified token kind represents a keyword in the
247 /// specified language.
248 /// \returns Status of the keyword in the language.
250  tok::TokenKind K) {
251  switch (K) {
252 #define KEYWORD(NAME, FLAGS) \
253  case tok::kw_##NAME: return getKeywordStatus(LangOpts, FLAGS);
254 #include "clang/Basic/TokenKinds.def"
255  default: return KS_Disabled;
256  }
257 }
258 
259 /// Returns true if the identifier represents a keyword in the
260 /// specified language.
261 bool IdentifierInfo::isKeyword(const LangOptions &LangOpts) const {
262  switch (getTokenKwStatus(LangOpts, getTokenID())) {
263  case KS_Enabled:
264  case KS_Extension:
265  return true;
266  default:
267  return false;
268  }
269 }
270 
271 /// Returns true if the identifier represents a C++ keyword in the
272 /// specified language.
273 bool IdentifierInfo::isCPlusPlusKeyword(const LangOptions &LangOpts) const {
274  if (!LangOpts.CPlusPlus || !isKeyword(LangOpts))
275  return false;
276  // This is a C++ keyword if this identifier is not a keyword when checked
277  // using LangOptions without C++ support.
278  LangOptions LangOptsNoCPP = LangOpts;
279  LangOptsNoCPP.CPlusPlus = false;
280  LangOptsNoCPP.CPlusPlus11 = false;
281  LangOptsNoCPP.CPlusPlus2a = false;
282  return !isKeyword(LangOptsNoCPP);
283 }
284 
286  // We use a perfect hash function here involving the length of the keyword,
287  // the first and third character. For preprocessor ID's there are no
288  // collisions (if there were, the switch below would complain about duplicate
289  // case values). Note that this depends on 'if' being null terminated.
290 
291 #define HASH(LEN, FIRST, THIRD) \
292  (LEN << 5) + (((FIRST-'a') + (THIRD-'a')) & 31)
293 #define CASE(LEN, FIRST, THIRD, NAME) \
294  case HASH(LEN, FIRST, THIRD): \
295  return memcmp(Name, #NAME, LEN) ? tok::pp_not_keyword : tok::pp_ ## NAME
296 
297  unsigned Len = getLength();
298  if (Len < 2) return tok::pp_not_keyword;
299  const char *Name = getNameStart();
300  switch (HASH(Len, Name[0], Name[2])) {
301  default: return tok::pp_not_keyword;
302  CASE( 2, 'i', '\0', if);
303  CASE( 4, 'e', 'i', elif);
304  CASE( 4, 'e', 's', else);
305  CASE( 4, 'l', 'n', line);
306  CASE( 4, 's', 'c', sccs);
307  CASE( 5, 'e', 'd', endif);
308  CASE( 5, 'e', 'r', error);
309  CASE( 5, 'i', 'e', ident);
310  CASE( 5, 'i', 'd', ifdef);
311  CASE( 5, 'u', 'd', undef);
312 
313  CASE( 6, 'a', 's', assert);
314  CASE( 6, 'd', 'f', define);
315  CASE( 6, 'i', 'n', ifndef);
316  CASE( 6, 'i', 'p', import);
317  CASE( 6, 'p', 'a', pragma);
318 
319  CASE( 7, 'd', 'f', defined);
320  CASE( 7, 'i', 'c', include);
321  CASE( 7, 'w', 'r', warning);
322 
323  CASE( 8, 'u', 'a', unassert);
324  CASE(12, 'i', 'c', include_next);
325 
326  CASE(14, '_', 'p', __public_macro);
327 
328  CASE(15, '_', 'p', __private_macro);
329 
330  CASE(16, '_', 'i', __include_macros);
331 #undef CASE
332 #undef HASH
333  }
334 }
335 
336 //===----------------------------------------------------------------------===//
337 // Stats Implementation
338 //===----------------------------------------------------------------------===//
339 
340 /// PrintStats - Print statistics about how well the identifier table is doing
341 /// at hashing identifiers.
343  unsigned NumBuckets = HashTable.getNumBuckets();
344  unsigned NumIdentifiers = HashTable.getNumItems();
345  unsigned NumEmptyBuckets = NumBuckets-NumIdentifiers;
346  unsigned AverageIdentifierSize = 0;
347  unsigned MaxIdentifierLength = 0;
348 
349  // TODO: Figure out maximum times an identifier had to probe for -stats.
350  for (llvm::StringMap<IdentifierInfo*, llvm::BumpPtrAllocator>::const_iterator
351  I = HashTable.begin(), E = HashTable.end(); I != E; ++I) {
352  unsigned IdLen = I->getKeyLength();
353  AverageIdentifierSize += IdLen;
354  if (MaxIdentifierLength < IdLen)
355  MaxIdentifierLength = IdLen;
356  }
357 
358  fprintf(stderr, "\n*** Identifier Table Stats:\n");
359  fprintf(stderr, "# Identifiers: %d\n", NumIdentifiers);
360  fprintf(stderr, "# Empty Buckets: %d\n", NumEmptyBuckets);
361  fprintf(stderr, "Hash density (#identifiers per bucket): %f\n",
362  NumIdentifiers/(double)NumBuckets);
363  fprintf(stderr, "Ave identifier length: %f\n",
364  (AverageIdentifierSize/(double)NumIdentifiers));
365  fprintf(stderr, "Max identifier length: %d\n", MaxIdentifierLength);
366 
367  // Compute statistics about the memory allocated for identifiers.
368  HashTable.getAllocator().PrintStats();
369 }
370 
371 //===----------------------------------------------------------------------===//
372 // SelectorTable Implementation
373 //===----------------------------------------------------------------------===//
374 
377 }
378 
379 namespace clang {
380 
381 /// One of these variable length records is kept for each
382 /// selector containing more than one keyword. We use a folding set
383 /// to unique aggregate names (keyword selectors in ObjC parlance). Access to
384 /// this class is provided strictly through Selector.
385 class alignas(IdentifierInfoAlignment) MultiKeywordSelector
387  public llvm::FoldingSetNode {
388  MultiKeywordSelector(unsigned nKeys) : DeclarationNameExtra(nKeys) {}
389 
390 public:
391  // Constructor for keyword selectors.
392  MultiKeywordSelector(unsigned nKeys, IdentifierInfo **IIV)
393  : DeclarationNameExtra(nKeys) {
394  assert((nKeys > 1) && "not a multi-keyword selector");
395 
396  // Fill in the trailing keyword array.
397  IdentifierInfo **KeyInfo = reinterpret_cast<IdentifierInfo **>(this + 1);
398  for (unsigned i = 0; i != nKeys; ++i)
399  KeyInfo[i] = IIV[i];
400  }
401 
402  // getName - Derive the full selector name and return it.
403  std::string getName() const;
404 
405  using DeclarationNameExtra::getNumArgs;
406 
408 
410  return reinterpret_cast<keyword_iterator>(this + 1);
411  }
412 
414  return keyword_begin() + getNumArgs();
415  }
416 
418  assert(i < getNumArgs() && "getIdentifierInfoForSlot(): illegal index");
419  return keyword_begin()[i];
420  }
421 
422  static void Profile(llvm::FoldingSetNodeID &ID, keyword_iterator ArgTys,
423  unsigned NumArgs) {
424  ID.AddInteger(NumArgs);
425  for (unsigned i = 0; i != NumArgs; ++i)
426  ID.AddPointer(ArgTys[i]);
427  }
428 
429  void Profile(llvm::FoldingSetNodeID &ID) {
430  Profile(ID, keyword_begin(), getNumArgs());
431  }
432 };
433 
434 } // namespace clang.
435 
436 unsigned Selector::getNumArgs() const {
437  unsigned IIF = getIdentifierInfoFlag();
438  if (IIF <= ZeroArg)
439  return 0;
440  if (IIF == OneArg)
441  return 1;
442  // We point to a MultiKeywordSelector.
443  MultiKeywordSelector *SI = getMultiKeywordSelector();
444  return SI->getNumArgs();
445 }
446 
448  if (getIdentifierInfoFlag() < MultiArg) {
449  assert(argIndex == 0 && "illegal keyword index");
450  return getAsIdentifierInfo();
451  }
452 
453  // We point to a MultiKeywordSelector.
454  MultiKeywordSelector *SI = getMultiKeywordSelector();
455  return SI->getIdentifierInfoForSlot(argIndex);
456 }
457 
458 StringRef Selector::getNameForSlot(unsigned int argIndex) const {
459  IdentifierInfo *II = getIdentifierInfoForSlot(argIndex);
460  return II ? II->getName() : StringRef();
461 }
462 
463 std::string MultiKeywordSelector::getName() const {
464  SmallString<256> Str;
465  llvm::raw_svector_ostream OS(Str);
466  for (keyword_iterator I = keyword_begin(), E = keyword_end(); I != E; ++I) {
467  if (*I)
468  OS << (*I)->getName();
469  OS << ':';
470  }
471 
472  return OS.str();
473 }
474 
475 std::string Selector::getAsString() const {
476  if (InfoPtr == 0)
477  return "<null selector>";
478 
479  if (getIdentifierInfoFlag() < MultiArg) {
480  IdentifierInfo *II = getAsIdentifierInfo();
481 
482  if (getNumArgs() == 0) {
483  assert(II && "If the number of arguments is 0 then II is guaranteed to "
484  "not be null.");
485  return II->getName();
486  }
487 
488  if (!II)
489  return ":";
490 
491  return II->getName().str() + ":";
492  }
493 
494  // We have a multiple keyword selector.
495  return getMultiKeywordSelector()->getName();
496 }
497 
498 void Selector::print(llvm::raw_ostream &OS) const {
499  OS << getAsString();
500 }
501 
502 LLVM_DUMP_METHOD void Selector::dump() const { print(llvm::errs()); }
503 
504 /// Interpreting the given string using the normal CamelCase
505 /// conventions, determine whether the given string starts with the
506 /// given "word", which is assumed to end in a lowercase letter.
507 static bool startsWithWord(StringRef name, StringRef word) {
508  if (name.size() < word.size()) return false;
509  return ((name.size() == word.size() || !isLowercase(name[word.size()])) &&
510  name.startswith(word));
511 }
512 
513 ObjCMethodFamily Selector::getMethodFamilyImpl(Selector sel) {
515  if (!first) return OMF_None;
516 
517  StringRef name = first->getName();
518  if (sel.isUnarySelector()) {
519  if (name == "autorelease") return OMF_autorelease;
520  if (name == "dealloc") return OMF_dealloc;
521  if (name == "finalize") return OMF_finalize;
522  if (name == "release") return OMF_release;
523  if (name == "retain") return OMF_retain;
524  if (name == "retainCount") return OMF_retainCount;
525  if (name == "self") return OMF_self;
526  if (name == "initialize") return OMF_initialize;
527  }
528 
529  if (name == "performSelector" || name == "performSelectorInBackground" ||
530  name == "performSelectorOnMainThread")
531  return OMF_performSelector;
532 
533  // The other method families may begin with a prefix of underscores.
534  while (!name.empty() && name.front() == '_')
535  name = name.substr(1);
536 
537  if (name.empty()) return OMF_None;
538  switch (name.front()) {
539  case 'a':
540  if (startsWithWord(name, "alloc")) return OMF_alloc;
541  break;
542  case 'c':
543  if (startsWithWord(name, "copy")) return OMF_copy;
544  break;
545  case 'i':
546  if (startsWithWord(name, "init")) return OMF_init;
547  break;
548  case 'm':
549  if (startsWithWord(name, "mutableCopy")) return OMF_mutableCopy;
550  break;
551  case 'n':
552  if (startsWithWord(name, "new")) return OMF_new;
553  break;
554  default:
555  break;
556  }
557 
558  return OMF_None;
559 }
560 
563  if (!first) return OIT_None;
564 
565  StringRef name = first->getName();
566 
567  if (name.empty()) return OIT_None;
568  switch (name.front()) {
569  case 'a':
570  if (startsWithWord(name, "array")) return OIT_Array;
571  break;
572  case 'd':
573  if (startsWithWord(name, "default")) return OIT_ReturnsSelf;
574  if (startsWithWord(name, "dictionary")) return OIT_Dictionary;
575  break;
576  case 's':
577  if (startsWithWord(name, "shared")) return OIT_ReturnsSelf;
578  if (startsWithWord(name, "standard")) return OIT_Singleton;
579  break;
580  case 'i':
581  if (startsWithWord(name, "init")) return OIT_Init;
582  break;
583  default:
584  break;
585  }
586  return OIT_None;
587 }
588 
589 ObjCStringFormatFamily Selector::getStringFormatFamilyImpl(Selector sel) {
591  if (!first) return SFF_None;
592 
593  StringRef name = first->getName();
594 
595  switch (name.front()) {
596  case 'a':
597  if (name == "appendFormat") return SFF_NSString;
598  break;
599 
600  case 'i':
601  if (name == "initWithFormat") return SFF_NSString;
602  break;
603 
604  case 'l':
605  if (name == "localizedStringWithFormat") return SFF_NSString;
606  break;
607 
608  case 's':
609  if (name == "stringByAppendingFormat" ||
610  name == "stringWithFormat") return SFF_NSString;
611  break;
612  }
613  return SFF_None;
614 }
615 
616 namespace {
617 
618 struct SelectorTableImpl {
619  llvm::FoldingSet<MultiKeywordSelector> Table;
620  llvm::BumpPtrAllocator Allocator;
621 };
622 
623 } // namespace
624 
625 static SelectorTableImpl &getSelectorTableImpl(void *P) {
626  return *static_cast<SelectorTableImpl*>(P);
627 }
628 
631  SmallString<64> SetterName("set");
632  SetterName += Name;
633  SetterName[3] = toUppercase(SetterName[3]);
634  return SetterName;
635 }
636 
637 Selector
639  SelectorTable &SelTable,
640  const IdentifierInfo *Name) {
641  IdentifierInfo *SetterName =
642  &Idents.get(constructSetterName(Name->getName()));
643  return SelTable.getUnarySelector(SetterName);
644 }
645 
647  StringRef Name = Sel.getNameForSlot(0);
648  assert(Name.startswith("set") && "invalid setter name");
649  return (Twine(toLowercase(Name[3])) + Name.drop_front(4)).str();
650 }
651 
653  SelectorTableImpl &SelTabImpl = getSelectorTableImpl(Impl);
654  return SelTabImpl.Allocator.getTotalMemory();
655 }
656 
658  if (nKeys < 2)
659  return Selector(IIV[0], nKeys);
660 
661  SelectorTableImpl &SelTabImpl = getSelectorTableImpl(Impl);
662 
663  // Unique selector, to guarantee there is one per name.
664  llvm::FoldingSetNodeID ID;
665  MultiKeywordSelector::Profile(ID, IIV, nKeys);
666 
667  void *InsertPos = nullptr;
668  if (MultiKeywordSelector *SI =
669  SelTabImpl.Table.FindNodeOrInsertPos(ID, InsertPos))
670  return Selector(SI);
671 
672  // MultiKeywordSelector objects are not allocated with new because they have a
673  // variable size array (for parameter types) at the end of them.
674  unsigned Size = sizeof(MultiKeywordSelector) + nKeys*sizeof(IdentifierInfo *);
676  (MultiKeywordSelector *)SelTabImpl.Allocator.Allocate(
677  Size, alignof(MultiKeywordSelector));
678  new (SI) MultiKeywordSelector(nKeys, IIV);
679  SelTabImpl.Table.InsertNode(SI, InsertPos);
680  return Selector(SI);
681 }
682 
684  Impl = new SelectorTableImpl();
685 }
686 
688  delete &getSelectorTableImpl(Impl);
689 }
690 
692  switch (Operator) {
693  case OO_None:
695  return nullptr;
696 
697 #define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) \
698  case OO_##Name: return Spelling;
699 #include "clang/Basic/OperatorKinds.def"
700  }
701 
702  llvm_unreachable("Invalid OverloadedOperatorKind!");
703 }
704 
706  bool isContextSensitive) {
707  switch (kind) {
709  return isContextSensitive ? "nonnull" : "_Nonnull";
710 
712  return isContextSensitive ? "nullable" : "_Nullable";
713 
715  return isContextSensitive ? "null_unspecified" : "_Null_unspecified";
716  }
717  llvm_unreachable("Unknown nullability kind.");
718 }
ObjCStringFormatFamily
void AddKeywords(const LangOptions &LangOpts)
Populate the identifier table with info about the language keywords for the language specified by Lan...
Smart pointer class that efficiently represents Objective-C method names.
DeclarationNameExtra is used as a base of various uncommon special names.
void * getAsOpaquePtr() const
unsigned getNumArgs() const
Return the number of arguments in an ObjC selector.
bool isCompatibleWithMSVC(MSVCMajorVersion MajorVersion) const
Definition: LangOptions.h:273
void PrintStats() const
Print some statistics to stderr that indicate how well the hashing is doing.
NullabilityKind
Describes the nullability of a particular type.
Definition: Specifiers.h:285
void setIsExtensionToken(bool Val)
StringRef P
static SelectorTableImpl & getSelectorTableImpl(void *P)
virtual IdentifierIterator * getIdentifiers()
Retrieve an iterator into the set of all identifiers known to this identifier lookup source...
KeywordStatus
How a keyword is treated in the selected standard.
static void AddKeyword(StringRef Keyword, tok::TokenKind TokenCode, unsigned Flags, const LangOptions &LangOpts, IdentifierTable &Table)
AddKeyword - This method is used to associate a token ID with specific identifiers because they are l...
IdentifierInfo * getIdentifierInfoForSlot(unsigned i) const
std::string getName(ArrayRef< StringRef > Parts) const
Get the platform-specific name separator.
Selector getUnarySelector(IdentifierInfo *ID)
One of these records is kept for each identifier that is lexed.
static ObjCInstanceTypeFamily getInstTypeMethodFamily(Selector sel)
This table allows us to fully hide how we implement multi-keyword caching.
ObjCMethodFamily
A family of Objective-C methods.
IdentifierInfo *const * keyword_iterator
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:50
static KeywordStatus getTokenKwStatus(const LangOptions &LangOpts, tok::TokenKind K)
Checks if the specified token kind represents a keyword in the specified language.
IdentifierTable(IdentifierInfoLookup *ExternalLookup=nullptr)
Create the identifier table.
Values of this type can be null.
bool isUnarySelector() const
void setIsFutureCompatKeyword(bool Val)
static SmallString< 64 > constructSetterName(StringRef Name)
Return the default setter name for the given identifier.
static Selector constructSetterSelector(IdentifierTable &Idents, SelectorTable &SelTable, const IdentifierInfo *Name)
Return the default setter selector for the given identifier.
void Profile(llvm::FoldingSetNodeID &ID)
Whether values of this type can be null is (explicitly) unspecified.
Values of this type can never be null.
static void AddCXXOperatorKeyword(StringRef Keyword, tok::TokenKind TokenCode, IdentifierTable &Table)
AddCXXOperatorKeyword - Register a C++ operator keyword alternative representations.
size_t getTotalMemory() const
Return the total amount of memory allocated for managing selectors.
bool isCPlusPlusKeyword(const LangOptions &LangOpts) const
Return true if this token is a C++ keyword in the specified language.
return Out str()
Provides lookups to, and iteration over, IdentiferInfo objects.
void setIsCPlusPlusOperatorKeyword(bool Val=true)
isCPlusPlusOperatorKeyword/setIsCPlusPlusOperatorKeyword controls whether this identifier is a C++ al...
One of these variable length records is kept for each selector containing more than one keyword...
Defines the clang::LangOptions interface.
llvm::StringRef getAsString(SyncScope S)
Definition: SyncScope.h:51
Implements an efficient mapping from strings to IdentifierInfo nodes.
Defines an enumeration for C++ overloaded operators.
PPKeywordKind
Provides a namespace for preprocessor keywords which start with a &#39;#&#39; at the beginning of the line...
Definition: TokenKinds.h:33
StringRef getNameForSlot(unsigned argIndex) const
Retrieve the name at a given position in the selector.
#define CASE(LEN, FIRST, THIRD, NAME)
ObjCInstanceTypeFamily
A family of Objective-C methods.
static KeywordStatus getKeywordStatus(const LangOptions &LangOpts, unsigned Flags)
Translates flags as specified in TokenKinds.def into keyword status in the given language standard...
An iterator that walks over all of the known identifiers in the lookup table.
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
void print(llvm::raw_ostream &OS) const
Prints the full selector name (e.g. "foo:bar:").
unsigned getNumArgs() const
ObjCKeywordKind
Provides a namespace for Objective-C keywords which start with an &#39;@&#39;.
Definition: TokenKinds.h:41
void setObjCKeywordID(tok::ObjCKeywordKind ID)
bool isKeyword(const LangOptions &LangOpts) const
Return true if this token is a keyword in the specified language.
static bool startsWithWord(StringRef name, StringRef word)
Interpreting the given string using the normal CamelCase conventions, determine whether the given str...
static void Profile(llvm::FoldingSetNodeID &ID, keyword_iterator ArgTys, unsigned NumArgs)
std::string getAsString() const
Derive the full selector name (e.g.
LLVM_READONLY char toLowercase(char c)
Converts the given ASCII character to its lowercase equivalent.
Definition: CharInfo.h:165
IdentifierInfo * getIdentifierInfoForSlot(unsigned argIndex) const
Retrieve the identifier at a given position in the selector.
IdentifierInfo & get(StringRef Name)
Return the identifier token info for the specified named identifier.
TokenKind
Provides a simple uniform namespace for tokens from all C languages.
Definition: TokenKinds.h:25
keyword_iterator keyword_begin() const
static void AddObjCKeyword(StringRef Name, tok::ObjCKeywordKind ObjCID, IdentifierTable &Table)
AddObjCKeyword - Register an Objective-C @keyword like "class" "selector" or "property".
LLVM_READONLY bool isLowercase(unsigned char c)
Return true if this character is a lowercase ASCII letter: [a-z].
Definition: CharInfo.h:100
Defines various enumerations that describe declaration and type specifiers.
StringRef getName() const
Return the actual identifier string.
Dataflow Directional Tag Classes.
static std::string getPropertyNameFromSetterSelector(Selector Sel)
Return the property name for the given setter selector.
OverloadedOperatorKind
Enumeration specifying the different kinds of C++ overloaded operators.
Definition: OperatorKinds.h:22
tok::PPKeywordKind getPPKeywordID() const
Return the preprocessor keyword ID for this identifier.
Not an overloaded operator.
Definition: OperatorKinds.h:23
MultiKeywordSelector(unsigned nKeys, IdentifierInfo **IIV)
Selector getSelector(unsigned NumArgs, IdentifierInfo **IIV)
Can create any sort of selector.
const char * getOperatorSpelling(OverloadedOperatorKind Operator)
Retrieve the spelling of the given overloaded operator, without the preceding "operator" keyword...
#define HASH(LEN, FIRST, THIRD)
Defines the clang::TokenKind enum and support functions.
No particular method family.
unsigned kind
All of the diagnostics that can be emitted by the frontend.
Definition: DiagnosticIDs.h:61
keyword_iterator keyword_end() const
LLVM_READONLY char toUppercase(char c)
Converts the given ASCII character to its uppercase equivalent.
Definition: CharInfo.h:174
llvm::StringRef getNullabilitySpelling(NullabilityKind kind, bool isContextSensitive=false)
Retrieve the spelling of the given nullability kind.