PTHLexer.cpp revision d0a69696acca62798dfc8b98f97c92bfa7fa0490
1//===--- PTHLexer.cpp - Lex from a token stream ---------------------------===// 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 PTHLexer interface. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Basic/TokenKinds.h" 15#include "clang/Basic/FileManager.h" 16#include "clang/Basic/IdentifierTable.h" 17#include "clang/Lex/PTHLexer.h" 18#include "clang/Lex/Preprocessor.h" 19#include "clang/Lex/PTHManager.h" 20#include "clang/Lex/Token.h" 21#include "clang/Lex/Preprocessor.h" 22#include "llvm/Support/Compiler.h" 23#include "llvm/Support/MemoryBuffer.h" 24#include "llvm/ADT/StringMap.h" 25#include "llvm/ADT/OwningPtr.h" 26using namespace clang; 27 28#define DISK_TOKEN_SIZE (1+1+2+4+4) 29 30//===----------------------------------------------------------------------===// 31// Utility methods for reading from the mmap'ed PTH file. 32//===----------------------------------------------------------------------===// 33 34static inline uint8_t Read8(const unsigned char *&Data) { 35 uint8_t V = Data[0]; 36 Data += 1; 37 return V; 38} 39 40static inline uint16_t Read16(const unsigned char *&Data) { 41// Targets that directly support unaligned little-endian 16-bit loads can just 42// use them. 43#if defined(__i386__) || defined(__x86_64__) 44 uint16_t V = *((uint16_t*)Data); 45#else 46 uint16_t V = ((uint16_t)Data[0] << 0) | 47 ((uint16_t)Data[1] << 8); 48#endif 49 Data += 2; 50 return V; 51} 52 53static inline uint32_t Read24(const unsigned char *&Data) { 54// Targets that directly support unaligned little-endian 16-bit loads can just 55// use them. 56#if defined(__i386__) || defined(__x86_64__) 57 uint32_t V = ((uint16_t*)Data)[0] | 58 ((uint32_t)Data[2] << 16); 59#else 60 uint32_t V = ((uint32_t)Data[0] << 0) | 61 ((uint32_t)Data[1] << 8) | 62 ((uint32_t)Data[2] << 16); 63#endif 64 65 Data += 3; 66 return V; 67} 68 69static inline uint32_t Read32(const unsigned char *&Data) { 70// Targets that directly support unaligned little-endian 32-bit loads can just 71// use them. 72#if defined(__i386__) || defined(__x86_64__) 73 uint32_t V = *((uint32_t*)Data); 74#else 75 uint32_t V = ((uint32_t)Data[0] << 0) | 76 ((uint32_t)Data[1] << 8) | 77 ((uint32_t)Data[2] << 16) | 78 ((uint32_t)Data[3] << 24); 79#endif 80 Data += 4; 81 return V; 82} 83 84 85//===----------------------------------------------------------------------===// 86// PTHLexer methods. 87//===----------------------------------------------------------------------===// 88 89PTHLexer::PTHLexer(Preprocessor &PP, FileID FID, const unsigned char *D, 90 const unsigned char *ppcond, 91 PTHSpellingSearch &mySpellingSrch, PTHManager &PM) 92 : PreprocessorLexer(&PP, FID), TokBuf(D), CurPtr(D), LastHashTokPtr(0), 93 PPCond(ppcond), CurPPCondPtr(ppcond), MySpellingSrch(mySpellingSrch), 94 PTHMgr(PM) { 95 96 FileStartLoc = PP.getSourceManager().getLocForStartOfFile(FID); 97} 98 99void PTHLexer::Lex(Token& Tok) { 100LexNextToken: 101 102 //===--------------------------------------==// 103 // Read the raw token data. 104 //===--------------------------------------==// 105 106 // Shadow CurPtr into an automatic variable. 107 const unsigned char *CurPtrShadow = CurPtr; 108 109 // Read in the data for the token. 110 unsigned Word0 = Read32(CurPtrShadow); 111 uint32_t IdentifierID = Read32(CurPtrShadow); 112 uint32_t FileOffset = Read32(CurPtrShadow); 113 114 tok::TokenKind TKind = (tok::TokenKind) (Word0 & 0xFF); 115 Token::TokenFlags TFlags = (Token::TokenFlags) ((Word0 >> 8) & 0xFF); 116 uint32_t Len = Word0 >> 16; 117 118 CurPtr = CurPtrShadow; 119 120 //===--------------------------------------==// 121 // Construct the token itself. 122 //===--------------------------------------==// 123 124 Tok.startToken(); 125 Tok.setKind(TKind); 126 Tok.setFlag(TFlags); 127 assert(!LexingRawMode); 128 Tok.setLocation(FileStartLoc.getFileLocWithOffset(FileOffset)); 129 Tok.setLength(Len); 130 131 // Handle identifiers. 132 if (IdentifierID) { 133 MIOpt.ReadToken(); 134 IdentifierInfo *II = PTHMgr.GetIdentifierInfo(IdentifierID-1); 135 Tok.setIdentifierInfo(II); 136 if (II->isHandleIdentifierCase()) 137 PP->HandleIdentifier(Tok); 138 return; 139 } 140 141 //===--------------------------------------==// 142 // Process the token. 143 //===--------------------------------------==// 144#if 0 145 SourceManager& SM = PP->getSourceManager(); 146 llvm::cerr << SM.getFileEntryForID(FileID)->getName() 147 << ':' << SM.getLogicalLineNumber(Tok.getLocation()) 148 << ':' << SM.getLogicalColumnNumber(Tok.getLocation()) 149 << '\n'; 150#endif 151 152 if (TKind == tok::eof) { 153 // Save the end-of-file token. 154 EofToken = Tok; 155 156 Preprocessor *PPCache = PP; 157 158 assert(!ParsingPreprocessorDirective); 159 assert(!LexingRawMode); 160 161 // FIXME: Issue diagnostics similar to Lexer. 162 if (PP->HandleEndOfFile(Tok, false)) 163 return; 164 165 assert(PPCache && "Raw buffer::LexEndOfFile should return a token"); 166 return PPCache->Lex(Tok); 167 } 168 169 if (TKind == tok::hash && Tok.isAtStartOfLine()) { 170 LastHashTokPtr = CurPtr - DISK_TOKEN_SIZE; 171 assert(!LexingRawMode); 172 PP->HandleDirective(Tok); 173 174 if (PP->isCurrentLexer(this)) 175 goto LexNextToken; 176 177 return PP->Lex(Tok); 178 } 179 180 if (TKind == tok::eom) { 181 assert(ParsingPreprocessorDirective); 182 ParsingPreprocessorDirective = false; 183 return; 184 } 185 186 MIOpt.ReadToken(); 187} 188 189// FIXME: We can just grab the last token instead of storing a copy 190// into EofToken. 191void PTHLexer::getEOF(Token& Tok) { 192 assert(EofToken.is(tok::eof)); 193 Tok = EofToken; 194} 195 196void PTHLexer::DiscardToEndOfLine() { 197 assert(ParsingPreprocessorDirective && ParsingFilename == false && 198 "Must be in a preprocessing directive!"); 199 200 // We assume that if the preprocessor wishes to discard to the end of 201 // the line that it also means to end the current preprocessor directive. 202 ParsingPreprocessorDirective = false; 203 204 // Skip tokens by only peeking at their token kind and the flags. 205 // We don't need to actually reconstruct full tokens from the token buffer. 206 // This saves some copies and it also reduces IdentifierInfo* lookup. 207 const unsigned char* p = CurPtr; 208 while (1) { 209 // Read the token kind. Are we at the end of the file? 210 tok::TokenKind x = (tok::TokenKind) (uint8_t) *p; 211 if (x == tok::eof) break; 212 213 // Read the token flags. Are we at the start of the next line? 214 Token::TokenFlags y = (Token::TokenFlags) (uint8_t) p[1]; 215 if (y & Token::StartOfLine) break; 216 217 // Skip to the next token. 218 p += DISK_TOKEN_SIZE; 219 } 220 221 CurPtr = p; 222} 223 224/// SkipBlock - Used by Preprocessor to skip the current conditional block. 225bool PTHLexer::SkipBlock() { 226 assert(CurPPCondPtr && "No cached PP conditional information."); 227 assert(LastHashTokPtr && "No known '#' token."); 228 229 const unsigned char* HashEntryI = 0; 230 uint32_t Offset; 231 uint32_t TableIdx; 232 233 do { 234 // Read the token offset from the side-table. 235 Offset = Read32(CurPPCondPtr); 236 237 // Read the target table index from the side-table. 238 TableIdx = Read32(CurPPCondPtr); 239 240 // Compute the actual memory address of the '#' token data for this entry. 241 HashEntryI = TokBuf + Offset; 242 243 // Optmization: "Sibling jumping". #if...#else...#endif blocks can 244 // contain nested blocks. In the side-table we can jump over these 245 // nested blocks instead of doing a linear search if the next "sibling" 246 // entry is not at a location greater than LastHashTokPtr. 247 if (HashEntryI < LastHashTokPtr && TableIdx) { 248 // In the side-table we are still at an entry for a '#' token that 249 // is earlier than the last one we saw. Check if the location we would 250 // stride gets us closer. 251 const unsigned char* NextPPCondPtr = 252 PPCond + TableIdx*(sizeof(uint32_t)*2); 253 assert(NextPPCondPtr >= CurPPCondPtr); 254 // Read where we should jump to. 255 uint32_t TmpOffset = Read32(NextPPCondPtr); 256 const unsigned char* HashEntryJ = TokBuf + TmpOffset; 257 258 if (HashEntryJ <= LastHashTokPtr) { 259 // Jump directly to the next entry in the side table. 260 HashEntryI = HashEntryJ; 261 Offset = TmpOffset; 262 TableIdx = Read32(NextPPCondPtr); 263 CurPPCondPtr = NextPPCondPtr; 264 } 265 } 266 } 267 while (HashEntryI < LastHashTokPtr); 268 assert(HashEntryI == LastHashTokPtr && "No PP-cond entry found for '#'"); 269 assert(TableIdx && "No jumping from #endifs."); 270 271 // Update our side-table iterator. 272 const unsigned char* NextPPCondPtr = PPCond + TableIdx*(sizeof(uint32_t)*2); 273 assert(NextPPCondPtr >= CurPPCondPtr); 274 CurPPCondPtr = NextPPCondPtr; 275 276 // Read where we should jump to. 277 HashEntryI = TokBuf + Read32(NextPPCondPtr); 278 uint32_t NextIdx = Read32(NextPPCondPtr); 279 280 // By construction NextIdx will be zero if this is a #endif. This is useful 281 // to know to obviate lexing another token. 282 bool isEndif = NextIdx == 0; 283 284 // This case can occur when we see something like this: 285 // 286 // #if ... 287 // /* a comment or nothing */ 288 // #elif 289 // 290 // If we are skipping the first #if block it will be the case that CurPtr 291 // already points 'elif'. Just return. 292 293 if (CurPtr > HashEntryI) { 294 assert(CurPtr == HashEntryI + DISK_TOKEN_SIZE); 295 // Did we reach a #endif? If so, go ahead and consume that token as well. 296 if (isEndif) 297 CurPtr += DISK_TOKEN_SIZE*2; 298 else 299 LastHashTokPtr = HashEntryI; 300 301 return isEndif; 302 } 303 304 // Otherwise, we need to advance. Update CurPtr to point to the '#' token. 305 CurPtr = HashEntryI; 306 307 // Update the location of the last observed '#'. This is useful if we 308 // are skipping multiple blocks. 309 LastHashTokPtr = CurPtr; 310 311 // Skip the '#' token. 312 assert(((tok::TokenKind)*CurPtr) == tok::hash); 313 CurPtr += DISK_TOKEN_SIZE; 314 315 // Did we reach a #endif? If so, go ahead and consume that token as well. 316 if (isEndif) { CurPtr += DISK_TOKEN_SIZE*2; } 317 318 return isEndif; 319} 320 321SourceLocation PTHLexer::getSourceLocation() { 322 // getSourceLocation is not on the hot path. It is used to get the location 323 // of the next token when transitioning back to this lexer when done 324 // handling a #included file. Just read the necessary data from the token 325 // data buffer to construct the SourceLocation object. 326 // NOTE: This is a virtual function; hence it is defined out-of-line. 327 const unsigned char *OffsetPtr = CurPtr + (1 + 1 + 3); 328 uint32_t Offset = Read32(OffsetPtr); 329 return FileStartLoc.getFileLocWithOffset(Offset); 330} 331 332//===----------------------------------------------------------------------===// 333// getSpelling() - Use cached data in PTH files for getSpelling(). 334//===----------------------------------------------------------------------===// 335 336unsigned PTHManager::getSpelling(FileID FID, unsigned FPos, 337 const char *&Buffer) { 338 llvm::DenseMap<FileID, PTHSpellingSearch*>::iterator I =SpellingMap.find(FID); 339 340 if (I == SpellingMap.end()) 341 return 0; 342 343 return I->second->getSpellingBinarySearch(FPos, Buffer); 344} 345 346unsigned PTHManager::getSpelling(SourceLocation Loc, const char *&Buffer) { 347 SourceManager &SM = PP->getSourceManager(); 348 Loc = SM.getSpellingLoc(Loc); 349 std::pair<FileID, unsigned> LocInfo = SM.getDecomposedFileLoc(Loc); 350 return getSpelling(LocInfo.first, LocInfo.second, Buffer); 351} 352 353unsigned PTHManager::getSpellingAtPTHOffset(unsigned PTHOffset, 354 const char *&Buffer) { 355 assert(PTHOffset < Buf->getBufferSize()); 356 const unsigned char* Ptr = 357 (const unsigned char*)Buf->getBufferStart() + PTHOffset; 358 359 // The string is prefixed by 16 bits for its length, followed by the string 360 // itself. 361 unsigned Len = Read16(Ptr); 362 Buffer = (const char *)Ptr; 363 return Len; 364} 365 366unsigned PTHSpellingSearch::getSpellingLinearSearch(unsigned FPos, 367 const char *&Buffer) { 368 const unsigned char *Ptr = LinearItr; 369 unsigned Len = 0; 370 371 if (Ptr == TableEnd) 372 return getSpellingBinarySearch(FPos, Buffer); 373 374 do { 375 uint32_t TokOffset = Read32(Ptr); 376 377 if (TokOffset > FPos) 378 return getSpellingBinarySearch(FPos, Buffer); 379 380 // Did we find a matching token offset for this spelling? 381 if (TokOffset == FPos) { 382 uint32_t SpellingPTHOffset = Read32(Ptr); 383 Len = PTHMgr.getSpellingAtPTHOffset(SpellingPTHOffset, Buffer); 384 break; 385 } 386 } while (Ptr != TableEnd); 387 388 LinearItr = Ptr; 389 return Len; 390} 391 392 393unsigned PTHSpellingSearch::getSpellingBinarySearch(unsigned FPos, 394 const char *&Buffer) { 395 396 assert((TableEnd - TableBeg) % SpellingEntrySize == 0); 397 assert(TableEnd >= TableBeg); 398 399 if (TableEnd == TableBeg) 400 return 0; 401 402 unsigned min = 0; 403 const unsigned char *tb = TableBeg; 404 unsigned max = NumSpellings; 405 406 do { 407 unsigned i = (max - min) / 2 + min; 408 const unsigned char *Ptr = tb + (i * SpellingEntrySize); 409 410 uint32_t TokOffset = Read32(Ptr); 411 if (TokOffset > FPos) { 412 max = i; 413 assert(!(max == min) || (min == i)); 414 continue; 415 } 416 417 if (TokOffset < FPos) { 418 if (i == min) 419 break; 420 421 min = i; 422 continue; 423 } 424 425 uint32_t SpellingPTHOffset = Read32(Ptr); 426 return PTHMgr.getSpellingAtPTHOffset(SpellingPTHOffset, Buffer); 427 } 428 while (min != max); 429 430 return 0; 431} 432 433unsigned PTHLexer::getSpelling(SourceLocation Loc, const char *&Buffer) { 434 SourceManager &SM = PP->getSourceManager(); 435 Loc = SM.getSpellingLoc(Loc); 436 std::pair<FileID, unsigned> LocInfo = SM.getDecomposedFileLoc(Loc); 437 438 FileID FID = LocInfo.first; 439 unsigned FPos = LocInfo.second; 440 441 if (FID == getFileID()) 442 return MySpellingSrch.getSpellingLinearSearch(FPos, Buffer); 443 return PTHMgr.getSpelling(FID, FPos, Buffer); 444} 445 446//===----------------------------------------------------------------------===// 447// Internal Data Structures for PTH file lookup and resolving identifiers. 448//===----------------------------------------------------------------------===// 449 450 451/// PTHFileLookup - This internal data structure is used by the PTHManager 452/// to map from FileEntry objects managed by FileManager to offsets within 453/// the PTH file. 454namespace { 455class VISIBILITY_HIDDEN PTHFileLookup { 456public: 457 class Val { 458 uint32_t TokenOff; 459 uint32_t PPCondOff; 460 uint32_t SpellingOff; 461 public: 462 Val() : TokenOff(~0) {} 463 Val(uint32_t toff, uint32_t poff, uint32_t soff) 464 : TokenOff(toff), PPCondOff(poff), SpellingOff(soff) {} 465 466 bool isValid() const { return TokenOff != ~((uint32_t)0); } 467 468 uint32_t getTokenOffset() const { 469 assert(isValid() && "PTHFileLookup entry initialized."); 470 return TokenOff; 471 } 472 473 uint32_t getPPCondOffset() const { 474 assert(isValid() && "PTHFileLookup entry initialized."); 475 return PPCondOff; 476 } 477 478 uint32_t getSpellingOffset() const { 479 assert(isValid() && "PTHFileLookup entry initialized."); 480 return SpellingOff; 481 } 482 }; 483 484private: 485 llvm::StringMap<Val> FileMap; 486 487public: 488 PTHFileLookup() {}; 489 490 bool isEmpty() const { 491 return FileMap.empty(); 492 } 493 494 Val Lookup(const FileEntry* FE) { 495 const char* s = FE->getName(); 496 unsigned size = strlen(s); 497 return FileMap.GetOrCreateValue(s, s+size).getValue(); 498 } 499 500 void ReadTable(const unsigned char* D) { 501 uint32_t N = Read32(D); // Read the length of the table. 502 503 for ( ; N > 0; --N) { // The rest of the data is the table itself. 504 uint32_t Len = Read32(D); 505 const char* s = (const char *)D; 506 D += Len; 507 508 uint32_t TokenOff = Read32(D); 509 uint32_t PPCondOff = Read32(D); 510 uint32_t SpellingOff = Read32(D); 511 512 FileMap.GetOrCreateValue(s, s+Len).getValue() = 513 Val(TokenOff, PPCondOff, SpellingOff); 514 } 515 } 516}; 517} // end anonymous namespace 518 519//===----------------------------------------------------------------------===// 520// PTHManager methods. 521//===----------------------------------------------------------------------===// 522 523PTHManager::PTHManager(const llvm::MemoryBuffer* buf, void* fileLookup, 524 const unsigned char* idDataTable, 525 IdentifierInfo** perIDCache, 526 const unsigned char* sortedIdTable, unsigned numIds) 527: Buf(buf), PerIDCache(perIDCache), FileLookup(fileLookup), 528 IdDataTable(idDataTable), SortedIdTable(sortedIdTable), 529 NumIds(numIds), PP(0) {} 530 531PTHManager::~PTHManager() { 532 delete Buf; 533 delete (PTHFileLookup*) FileLookup; 534 free(PerIDCache); 535} 536 537PTHManager* PTHManager::Create(const std::string& file) { 538 // Memory map the PTH file. 539 llvm::OwningPtr<llvm::MemoryBuffer> 540 File(llvm::MemoryBuffer::getFile(file.c_str())); 541 542 if (!File) 543 return 0; 544 545 // Get the buffer ranges and check if there are at least three 32-bit 546 // words at the end of the file. 547 const unsigned char* BufBeg = (unsigned char*)File->getBufferStart(); 548 const unsigned char* BufEnd = (unsigned char*)File->getBufferEnd(); 549 550 if(!(BufEnd > BufBeg + sizeof(uint32_t)*3)) { 551 assert(false && "Invalid PTH file."); 552 return 0; // FIXME: Proper error diagnostic? 553 } 554 555 // Compute the address of the index table at the end of the PTH file. 556 // This table contains the offset of the file lookup table, the 557 // persistent ID -> identifer data table. 558 // FIXME: We should just embed this offset in the PTH file. 559 const unsigned char* EndTable = BufEnd - sizeof(uint32_t)*4; 560 561 // Construct the file lookup table. This will be used for mapping from 562 // FileEntry*'s to cached tokens. 563 const unsigned char* FileTableOffset = EndTable + sizeof(uint32_t)*3; 564 const unsigned char* FileTable = BufBeg + Read32(FileTableOffset); 565 566 if (!(FileTable > BufBeg && FileTable < BufEnd)) { 567 assert(false && "Invalid PTH file."); 568 return 0; // FIXME: Proper error diagnostic? 569 } 570 571 llvm::OwningPtr<PTHFileLookup> FL(new PTHFileLookup()); 572 FL->ReadTable(FileTable); 573 574 if (FL->isEmpty()) 575 return 0; 576 577 // Get the location of the table mapping from persistent ids to the 578 // data needed to reconstruct identifiers. 579 const unsigned char* IDTableOffset = EndTable + sizeof(uint32_t)*1; 580 const unsigned char* IData = BufBeg + Read32(IDTableOffset); 581 582 if (!(IData >= BufBeg && IData < BufEnd)) { 583 assert(false && "Invalid PTH file."); 584 return 0; // FIXME: Proper error diagnostic? 585 } 586 587 // Get the location of the lexigraphically-sorted table of persistent IDs. 588 const unsigned char* SortedIdTableOffset = EndTable + sizeof(uint32_t)*2; 589 const unsigned char* SortedIdTable = BufBeg + Read32(SortedIdTableOffset); 590 if (!(SortedIdTable >= BufBeg && SortedIdTable < BufEnd)) { 591 assert(false && "Invalid PTH file."); 592 return 0; // FIXME: Proper error diagnostic? 593 } 594 595 // Get the number of IdentifierInfos and pre-allocate the identifier cache. 596 uint32_t NumIds = Read32(IData); 597 598 // Pre-allocate the peristent ID -> IdentifierInfo* cache. We use calloc() 599 // so that we in the best case only zero out memory once when the OS returns 600 // us new pages. 601 IdentifierInfo** PerIDCache = 0; 602 603 if (NumIds) { 604 PerIDCache = (IdentifierInfo**)calloc(NumIds, sizeof(*PerIDCache)); 605 if (!PerIDCache) { 606 assert(false && "Could not allocate Persistent ID cache."); 607 return 0; 608 } 609 } 610 611 // Create the new PTHManager. 612 return new PTHManager(File.take(), FL.take(), IData, PerIDCache, 613 SortedIdTable, NumIds); 614} 615IdentifierInfo* PTHManager::LazilyCreateIdentifierInfo(unsigned PersistentID) { 616 // Look in the PTH file for the string data for the IdentifierInfo object. 617 const unsigned char* TableEntry = IdDataTable + sizeof(uint32_t)*PersistentID; 618 const unsigned char* IDData = 619 (const unsigned char*)Buf->getBufferStart() + Read32(TableEntry); 620 assert(IDData < (const unsigned char*)Buf->getBufferEnd()); 621 622 // Allocate the object. 623 std::pair<IdentifierInfo,const unsigned char*> *Mem = 624 Alloc.Allocate<std::pair<IdentifierInfo,const unsigned char*> >(); 625 626 Mem->second = IDData; 627 IdentifierInfo *II = new ((void*) Mem) IdentifierInfo(); 628 629 // Store the new IdentifierInfo in the cache. 630 PerIDCache[PersistentID] = II; 631 return II; 632} 633 634IdentifierInfo* PTHManager::get(const char *NameStart, const char *NameEnd) { 635 unsigned min = 0; 636 unsigned max = NumIds; 637 unsigned Len = NameEnd - NameStart; 638 639 do { 640 unsigned i = (max - min) / 2 + min; 641 const unsigned char *Ptr = SortedIdTable + (i * 4); 642 643 // Read the persistentID. 644 unsigned perID = Read32(Ptr); 645 646 // Get the IdentifierInfo. 647 IdentifierInfo* II = GetIdentifierInfo(perID); 648 649 // First compare the lengths. 650 unsigned IILen = II->getLength(); 651 if (Len < IILen) goto IsLess; 652 if (Len > IILen) goto IsGreater; 653 654 // Now compare the strings! 655 { 656 signed comp = strncmp(NameStart, II->getName(), Len); 657 if (comp < 0) goto IsLess; 658 if (comp > 0) goto IsGreater; 659 } 660 // We found a match! 661 return II; 662 663 IsGreater: 664 if (i == min) break; 665 min = i; 666 continue; 667 668 IsLess: 669 max = i; 670 assert(!(max == min) || (min == i)); 671 } 672 while (min != max); 673 674 return 0; 675} 676 677 678PTHLexer *PTHManager::CreateLexer(FileID FID) { 679 const FileEntry *FE = PP->getSourceManager().getFileEntryForID(FID); 680 if (!FE) 681 return 0; 682 683 // Lookup the FileEntry object in our file lookup data structure. It will 684 // return a variant that indicates whether or not there is an offset within 685 // the PTH file that contains cached tokens. 686 PTHFileLookup::Val FileData = ((PTHFileLookup*)FileLookup)->Lookup(FE); 687 688 if (!FileData.isValid()) // No tokens available. 689 return 0; 690 691 const unsigned char *BufStart = (const unsigned char *)Buf->getBufferStart(); 692 // Compute the offset of the token data within the buffer. 693 const unsigned char* data = BufStart + FileData.getTokenOffset(); 694 695 // Get the location of pp-conditional table. 696 const unsigned char* ppcond = BufStart + FileData.getPPCondOffset(); 697 uint32_t Len = Read32(ppcond); 698 if (Len == 0) ppcond = 0; 699 700 // Get the location of the spelling table. 701 const unsigned char* spellingTable = BufStart + FileData.getSpellingOffset(); 702 703 Len = Read32(spellingTable); 704 if (Len == 0) spellingTable = 0; 705 706 assert(data < (const unsigned char*)Buf->getBufferEnd()); 707 708 // Create the SpellingSearch object for this FileID. 709 PTHSpellingSearch* ss = new PTHSpellingSearch(*this, Len, spellingTable); 710 SpellingMap[FID] = ss; 711 712 assert(PP && "No preprocessor set yet!"); 713 return new PTHLexer(*PP, FID, data, ppcond, *ss, *this); 714} 715