1 //===--- ModuleMap.cpp - Describe the layout of modules ---------*- 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 ModuleMap implementation, which describes the layout 11 // of a module as it relates to headers. 12 // 13 //===----------------------------------------------------------------------===// 14 #include "clang/Lex/ModuleMap.h" 15 #include "clang/Lex/Lexer.h" 16 #include "clang/Lex/LiteralSupport.h" 17 #include "clang/Lex/LexDiagnostic.h" 18 #include "clang/Basic/Diagnostic.h" 19 #include "clang/Basic/FileManager.h" 20 #include "clang/Basic/TargetInfo.h" 21 #include "clang/Basic/TargetOptions.h" 22 #include "llvm/Support/Allocator.h" 23 #include "llvm/Support/FileSystem.h" 24 #include "llvm/Support/Host.h" 25 #include "llvm/Support/PathV2.h" 26 #include "llvm/Support/raw_ostream.h" 27 #include "llvm/ADT/StringRef.h" 28 #include "llvm/ADT/StringSwitch.h" 29 using namespace clang; 30 31 Module::ExportDecl 32 ModuleMap::resolveExport(Module *Mod, 33 const Module::UnresolvedExportDecl &Unresolved, 34 bool Complain) { 35 // We may have just a wildcard. 36 if (Unresolved.Id.empty()) { 37 assert(Unresolved.Wildcard && "Invalid unresolved export"); 38 return Module::ExportDecl(0, true); 39 } 40 41 // Find the starting module. 42 Module *Context = lookupModuleUnqualified(Unresolved.Id[0].first, Mod); 43 if (!Context) { 44 if (Complain) 45 Diags->Report(Unresolved.Id[0].second, 46 diag::err_mmap_missing_module_unqualified) 47 << Unresolved.Id[0].first << Mod->getFullModuleName(); 48 49 return Module::ExportDecl(); 50 } 51 52 // Dig into the module path. 53 for (unsigned I = 1, N = Unresolved.Id.size(); I != N; ++I) { 54 Module *Sub = lookupModuleQualified(Unresolved.Id[I].first, 55 Context); 56 if (!Sub) { 57 if (Complain) 58 Diags->Report(Unresolved.Id[I].second, 59 diag::err_mmap_missing_module_qualified) 60 << Unresolved.Id[I].first << Context->getFullModuleName() 61 << SourceRange(Unresolved.Id[0].second, Unresolved.Id[I-1].second); 62 63 return Module::ExportDecl(); 64 } 65 66 Context = Sub; 67 } 68 69 return Module::ExportDecl(Context, Unresolved.Wildcard); 70 } 71 72 ModuleMap::ModuleMap(FileManager &FileMgr, const DiagnosticConsumer &DC, 73 const LangOptions &LangOpts, const TargetInfo *Target) 74 : LangOpts(LangOpts), Target(Target), BuiltinIncludeDir(0) 75 { 76 IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(new DiagnosticIDs); 77 Diags = IntrusiveRefCntPtr<DiagnosticsEngine>( 78 new DiagnosticsEngine(DiagIDs)); 79 Diags->setClient(DC.clone(*Diags), /*ShouldOwnClient=*/true); 80 SourceMgr = new SourceManager(*Diags, FileMgr); 81 } 82 83 ModuleMap::~ModuleMap() { 84 for (llvm::StringMap<Module *>::iterator I = Modules.begin(), 85 IEnd = Modules.end(); 86 I != IEnd; ++I) { 87 delete I->getValue(); 88 } 89 90 delete SourceMgr; 91 } 92 93 void ModuleMap::setTarget(const TargetInfo &Target) { 94 assert((!this->Target || this->Target == &Target) && 95 "Improper target override"); 96 this->Target = &Target; 97 } 98 99 Module *ModuleMap::findModuleForHeader(const FileEntry *File) { 100 llvm::DenseMap<const FileEntry *, Module *>::iterator Known 101 = Headers.find(File); 102 if (Known != Headers.end()) { 103 // If a header corresponds to an unavailable module, don't report 104 // that it maps to anything. 105 if (!Known->second->isAvailable()) 106 return 0; 107 108 return Known->second; 109 } 110 111 const DirectoryEntry *Dir = File->getDir(); 112 llvm::SmallVector<const DirectoryEntry *, 2> SkippedDirs; 113 StringRef DirName = Dir->getName(); 114 115 // Keep walking up the directory hierarchy, looking for a directory with 116 // an umbrella header. 117 do { 118 llvm::DenseMap<const DirectoryEntry *, Module *>::iterator KnownDir 119 = UmbrellaDirs.find(Dir); 120 if (KnownDir != UmbrellaDirs.end()) { 121 Module *Result = KnownDir->second; 122 123 // Search up the module stack until we find a module with an umbrella 124 // directory. 125 Module *UmbrellaModule = Result; 126 while (!UmbrellaModule->getUmbrellaDir() && UmbrellaModule->Parent) 127 UmbrellaModule = UmbrellaModule->Parent; 128 129 if (UmbrellaModule->InferSubmodules) { 130 // Infer submodules for each of the directories we found between 131 // the directory of the umbrella header and the directory where 132 // the actual header is located. 133 bool Explicit = UmbrellaModule->InferExplicitSubmodules; 134 135 for (unsigned I = SkippedDirs.size(); I != 0; --I) { 136 // Find or create the module that corresponds to this directory name. 137 StringRef Name = llvm::sys::path::stem(SkippedDirs[I-1]->getName()); 138 Result = findOrCreateModule(Name, Result, /*IsFramework=*/false, 139 Explicit).first; 140 141 // Associate the module and the directory. 142 UmbrellaDirs[SkippedDirs[I-1]] = Result; 143 144 // If inferred submodules export everything they import, add a 145 // wildcard to the set of exports. 146 if (UmbrellaModule->InferExportWildcard && Result->Exports.empty()) 147 Result->Exports.push_back(Module::ExportDecl(0, true)); 148 } 149 150 // Infer a submodule with the same name as this header file. 151 StringRef Name = llvm::sys::path::stem(File->getName()); 152 Result = findOrCreateModule(Name, Result, /*IsFramework=*/false, 153 Explicit).first; 154 155 // If inferred submodules export everything they import, add a 156 // wildcard to the set of exports. 157 if (UmbrellaModule->InferExportWildcard && Result->Exports.empty()) 158 Result->Exports.push_back(Module::ExportDecl(0, true)); 159 } else { 160 // Record each of the directories we stepped through as being part of 161 // the module we found, since the umbrella header covers them all. 162 for (unsigned I = 0, N = SkippedDirs.size(); I != N; ++I) 163 UmbrellaDirs[SkippedDirs[I]] = Result; 164 } 165 166 Headers[File] = Result; 167 168 // If a header corresponds to an unavailable module, don't report 169 // that it maps to anything. 170 if (!Result->isAvailable()) 171 return 0; 172 173 return Result; 174 } 175 176 SkippedDirs.push_back(Dir); 177 178 // Retrieve our parent path. 179 DirName = llvm::sys::path::parent_path(DirName); 180 if (DirName.empty()) 181 break; 182 183 // Resolve the parent path to a directory entry. 184 Dir = SourceMgr->getFileManager().getDirectory(DirName); 185 } while (Dir); 186 187 return 0; 188 } 189 190 bool ModuleMap::isHeaderInUnavailableModule(const FileEntry *Header) { 191 llvm::DenseMap<const FileEntry *, Module *>::iterator Known 192 = Headers.find(Header); 193 if (Known != Headers.end()) 194 return !Known->second->isAvailable(); 195 196 const DirectoryEntry *Dir = Header->getDir(); 197 llvm::SmallVector<const DirectoryEntry *, 2> SkippedDirs; 198 StringRef DirName = Dir->getName(); 199 200 // Keep walking up the directory hierarchy, looking for a directory with 201 // an umbrella header. 202 do { 203 llvm::DenseMap<const DirectoryEntry *, Module *>::iterator KnownDir 204 = UmbrellaDirs.find(Dir); 205 if (KnownDir != UmbrellaDirs.end()) { 206 Module *Found = KnownDir->second; 207 if (!Found->isAvailable()) 208 return true; 209 210 // Search up the module stack until we find a module with an umbrella 211 // directory. 212 Module *UmbrellaModule = Found; 213 while (!UmbrellaModule->getUmbrellaDir() && UmbrellaModule->Parent) 214 UmbrellaModule = UmbrellaModule->Parent; 215 216 if (UmbrellaModule->InferSubmodules) { 217 for (unsigned I = SkippedDirs.size(); I != 0; --I) { 218 // Find or create the module that corresponds to this directory name. 219 StringRef Name = llvm::sys::path::stem(SkippedDirs[I-1]->getName()); 220 Found = lookupModuleQualified(Name, Found); 221 if (!Found) 222 return false; 223 if (!Found->isAvailable()) 224 return true; 225 } 226 227 // Infer a submodule with the same name as this header file. 228 StringRef Name = llvm::sys::path::stem(Header->getName()); 229 Found = lookupModuleQualified(Name, Found); 230 if (!Found) 231 return false; 232 } 233 234 return !Found->isAvailable(); 235 } 236 237 SkippedDirs.push_back(Dir); 238 239 // Retrieve our parent path. 240 DirName = llvm::sys::path::parent_path(DirName); 241 if (DirName.empty()) 242 break; 243 244 // Resolve the parent path to a directory entry. 245 Dir = SourceMgr->getFileManager().getDirectory(DirName); 246 } while (Dir); 247 248 return false; 249 } 250 251 Module *ModuleMap::findModule(StringRef Name) { 252 llvm::StringMap<Module *>::iterator Known = Modules.find(Name); 253 if (Known != Modules.end()) 254 return Known->getValue(); 255 256 return 0; 257 } 258 259 Module *ModuleMap::lookupModuleUnqualified(StringRef Name, Module *Context) { 260 for(; Context; Context = Context->Parent) { 261 if (Module *Sub = lookupModuleQualified(Name, Context)) 262 return Sub; 263 } 264 265 return findModule(Name); 266 } 267 268 Module *ModuleMap::lookupModuleQualified(StringRef Name, Module *Context) { 269 if (!Context) 270 return findModule(Name); 271 272 return Context->findSubmodule(Name); 273 } 274 275 std::pair<Module *, bool> 276 ModuleMap::findOrCreateModule(StringRef Name, Module *Parent, bool IsFramework, 277 bool IsExplicit) { 278 // Try to find an existing module with this name. 279 if (Module *Sub = lookupModuleQualified(Name, Parent)) 280 return std::make_pair(Sub, false); 281 282 // Create a new module with this name. 283 Module *Result = new Module(Name, SourceLocation(), Parent, IsFramework, 284 IsExplicit); 285 if (!Parent) 286 Modules[Name] = Result; 287 return std::make_pair(Result, true); 288 } 289 290 Module * 291 ModuleMap::inferFrameworkModule(StringRef ModuleName, 292 const DirectoryEntry *FrameworkDir, 293 bool IsSystem, 294 Module *Parent) { 295 // Check whether we've already found this module. 296 if (Module *Mod = lookupModuleQualified(ModuleName, Parent)) 297 return Mod; 298 299 FileManager &FileMgr = SourceMgr->getFileManager(); 300 301 // Look for an umbrella header. 302 SmallString<128> UmbrellaName = StringRef(FrameworkDir->getName()); 303 llvm::sys::path::append(UmbrellaName, "Headers"); 304 llvm::sys::path::append(UmbrellaName, ModuleName + ".h"); 305 const FileEntry *UmbrellaHeader = FileMgr.getFile(UmbrellaName); 306 307 // FIXME: If there's no umbrella header, we could probably scan the 308 // framework to load *everything*. But, it's not clear that this is a good 309 // idea. 310 if (!UmbrellaHeader) 311 return 0; 312 313 Module *Result = new Module(ModuleName, SourceLocation(), Parent, 314 /*IsFramework=*/true, /*IsExplicit=*/false); 315 if (IsSystem) 316 Result->IsSystem = IsSystem; 317 318 if (!Parent) 319 Modules[ModuleName] = Result; 320 321 // umbrella header "umbrella-header-name" 322 Result->Umbrella = UmbrellaHeader; 323 Headers[UmbrellaHeader] = Result; 324 UmbrellaDirs[UmbrellaHeader->getDir()] = Result; 325 326 // export * 327 Result->Exports.push_back(Module::ExportDecl(0, true)); 328 329 // module * { export * } 330 Result->InferSubmodules = true; 331 Result->InferExportWildcard = true; 332 333 // Look for subframeworks. 334 llvm::error_code EC; 335 SmallString<128> SubframeworksDirName 336 = StringRef(FrameworkDir->getName()); 337 llvm::sys::path::append(SubframeworksDirName, "Frameworks"); 338 SmallString<128> SubframeworksDirNameNative; 339 llvm::sys::path::native(SubframeworksDirName.str(), 340 SubframeworksDirNameNative); 341 for (llvm::sys::fs::directory_iterator 342 Dir(SubframeworksDirNameNative.str(), EC), DirEnd; 343 Dir != DirEnd && !EC; Dir.increment(EC)) { 344 if (!StringRef(Dir->path()).endswith(".framework")) 345 continue; 346 347 if (const DirectoryEntry *SubframeworkDir 348 = FileMgr.getDirectory(Dir->path())) { 349 // FIXME: Do we want to warn about subframeworks without umbrella headers? 350 inferFrameworkModule(llvm::sys::path::stem(Dir->path()), SubframeworkDir, 351 IsSystem, Result); 352 } 353 } 354 355 return Result; 356 } 357 358 void ModuleMap::setUmbrellaHeader(Module *Mod, const FileEntry *UmbrellaHeader){ 359 Headers[UmbrellaHeader] = Mod; 360 Mod->Umbrella = UmbrellaHeader; 361 UmbrellaDirs[UmbrellaHeader->getDir()] = Mod; 362 } 363 364 void ModuleMap::setUmbrellaDir(Module *Mod, const DirectoryEntry *UmbrellaDir) { 365 Mod->Umbrella = UmbrellaDir; 366 UmbrellaDirs[UmbrellaDir] = Mod; 367 } 368 369 void ModuleMap::addHeader(Module *Mod, const FileEntry *Header) { 370 Mod->Headers.push_back(Header); 371 Headers[Header] = Mod; 372 } 373 374 const FileEntry * 375 ModuleMap::getContainingModuleMapFile(Module *Module) { 376 if (Module->DefinitionLoc.isInvalid() || !SourceMgr) 377 return 0; 378 379 return SourceMgr->getFileEntryForID( 380 SourceMgr->getFileID(Module->DefinitionLoc)); 381 } 382 383 void ModuleMap::dump() { 384 llvm::errs() << "Modules:"; 385 for (llvm::StringMap<Module *>::iterator M = Modules.begin(), 386 MEnd = Modules.end(); 387 M != MEnd; ++M) 388 M->getValue()->print(llvm::errs(), 2); 389 390 llvm::errs() << "Headers:"; 391 for (llvm::DenseMap<const FileEntry *, Module *>::iterator 392 H = Headers.begin(), 393 HEnd = Headers.end(); 394 H != HEnd; ++H) { 395 llvm::errs() << " \"" << H->first->getName() << "\" -> " 396 << H->second->getFullModuleName() << "\n"; 397 } 398 } 399 400 bool ModuleMap::resolveExports(Module *Mod, bool Complain) { 401 bool HadError = false; 402 for (unsigned I = 0, N = Mod->UnresolvedExports.size(); I != N; ++I) { 403 Module::ExportDecl Export = resolveExport(Mod, Mod->UnresolvedExports[I], 404 Complain); 405 if (Export.getPointer() || Export.getInt()) 406 Mod->Exports.push_back(Export); 407 else 408 HadError = true; 409 } 410 Mod->UnresolvedExports.clear(); 411 return HadError; 412 } 413 414 Module *ModuleMap::inferModuleFromLocation(FullSourceLoc Loc) { 415 if (Loc.isInvalid()) 416 return 0; 417 418 // Use the expansion location to determine which module we're in. 419 FullSourceLoc ExpansionLoc = Loc.getExpansionLoc(); 420 if (!ExpansionLoc.isFileID()) 421 return 0; 422 423 424 const SourceManager &SrcMgr = Loc.getManager(); 425 FileID ExpansionFileID = ExpansionLoc.getFileID(); 426 427 while (const FileEntry *ExpansionFile 428 = SrcMgr.getFileEntryForID(ExpansionFileID)) { 429 // Find the module that owns this header (if any). 430 if (Module *Mod = findModuleForHeader(ExpansionFile)) 431 return Mod; 432 433 // No module owns this header, so look up the inclusion chain to see if 434 // any included header has an associated module. 435 SourceLocation IncludeLoc = SrcMgr.getIncludeLoc(ExpansionFileID); 436 if (IncludeLoc.isInvalid()) 437 return 0; 438 439 ExpansionFileID = SrcMgr.getFileID(IncludeLoc); 440 } 441 442 return 0; 443 } 444 445 //----------------------------------------------------------------------------// 446 // Module map file parser 447 //----------------------------------------------------------------------------// 448 449 namespace clang { 450 /// \brief A token in a module map file. 451 struct MMToken { 452 enum TokenKind { 453 Comma, 454 EndOfFile, 455 HeaderKeyword, 456 Identifier, 457 ExplicitKeyword, 458 ExportKeyword, 459 FrameworkKeyword, 460 ModuleKeyword, 461 Period, 462 UmbrellaKeyword, 463 RequiresKeyword, 464 Star, 465 StringLiteral, 466 LBrace, 467 RBrace, 468 LSquare, 469 RSquare 470 } Kind; 471 472 unsigned Location; 473 unsigned StringLength; 474 const char *StringData; 475 476 void clear() { 477 Kind = EndOfFile; 478 Location = 0; 479 StringLength = 0; 480 StringData = 0; 481 } 482 483 bool is(TokenKind K) const { return Kind == K; } 484 485 SourceLocation getLocation() const { 486 return SourceLocation::getFromRawEncoding(Location); 487 } 488 489 StringRef getString() const { 490 return StringRef(StringData, StringLength); 491 } 492 }; 493 494 class ModuleMapParser { 495 Lexer &L; 496 SourceManager &SourceMgr; 497 DiagnosticsEngine &Diags; 498 ModuleMap ⤅ 499 500 /// \brief The directory that this module map resides in. 501 const DirectoryEntry *Directory; 502 503 /// \brief The directory containing Clang-supplied headers. 504 const DirectoryEntry *BuiltinIncludeDir; 505 506 /// \brief Whether an error occurred. 507 bool HadError; 508 509 /// \brief Default target information, used only for string literal 510 /// parsing. 511 OwningPtr<TargetInfo> Target; 512 513 /// \brief Stores string data for the various string literals referenced 514 /// during parsing. 515 llvm::BumpPtrAllocator StringData; 516 517 /// \brief The current token. 518 MMToken Tok; 519 520 /// \brief The active module. 521 Module *ActiveModule; 522 523 /// \brief Consume the current token and return its location. 524 SourceLocation consumeToken(); 525 526 /// \brief Skip tokens until we reach the a token with the given kind 527 /// (or the end of the file). 528 void skipUntil(MMToken::TokenKind K); 529 530 typedef llvm::SmallVector<std::pair<std::string, SourceLocation>, 2> 531 ModuleId; 532 bool parseModuleId(ModuleId &Id); 533 void parseModuleDecl(); 534 void parseRequiresDecl(); 535 void parseHeaderDecl(SourceLocation UmbrellaLoc); 536 void parseUmbrellaDirDecl(SourceLocation UmbrellaLoc); 537 void parseExportDecl(); 538 void parseInferredSubmoduleDecl(bool Explicit); 539 540 const DirectoryEntry *getOverriddenHeaderSearchDir(); 541 542 public: 543 explicit ModuleMapParser(Lexer &L, SourceManager &SourceMgr, 544 DiagnosticsEngine &Diags, 545 ModuleMap &Map, 546 const DirectoryEntry *Directory, 547 const DirectoryEntry *BuiltinIncludeDir) 548 : L(L), SourceMgr(SourceMgr), Diags(Diags), Map(Map), 549 Directory(Directory), BuiltinIncludeDir(BuiltinIncludeDir), 550 HadError(false), ActiveModule(0) 551 { 552 TargetOptions TargetOpts; 553 TargetOpts.Triple = llvm::sys::getDefaultTargetTriple(); 554 Target.reset(TargetInfo::CreateTargetInfo(Diags, TargetOpts)); 555 556 Tok.clear(); 557 consumeToken(); 558 } 559 560 bool parseModuleMapFile(); 561 }; 562 } 563 564 SourceLocation ModuleMapParser::consumeToken() { 565 retry: 566 SourceLocation Result = Tok.getLocation(); 567 Tok.clear(); 568 569 Token LToken; 570 L.LexFromRawLexer(LToken); 571 Tok.Location = LToken.getLocation().getRawEncoding(); 572 switch (LToken.getKind()) { 573 case tok::raw_identifier: 574 Tok.StringData = LToken.getRawIdentifierData(); 575 Tok.StringLength = LToken.getLength(); 576 Tok.Kind = llvm::StringSwitch<MMToken::TokenKind>(Tok.getString()) 577 .Case("header", MMToken::HeaderKeyword) 578 .Case("explicit", MMToken::ExplicitKeyword) 579 .Case("export", MMToken::ExportKeyword) 580 .Case("framework", MMToken::FrameworkKeyword) 581 .Case("module", MMToken::ModuleKeyword) 582 .Case("requires", MMToken::RequiresKeyword) 583 .Case("umbrella", MMToken::UmbrellaKeyword) 584 .Default(MMToken::Identifier); 585 break; 586 587 case tok::comma: 588 Tok.Kind = MMToken::Comma; 589 break; 590 591 case tok::eof: 592 Tok.Kind = MMToken::EndOfFile; 593 break; 594 595 case tok::l_brace: 596 Tok.Kind = MMToken::LBrace; 597 break; 598 599 case tok::l_square: 600 Tok.Kind = MMToken::LSquare; 601 break; 602 603 case tok::period: 604 Tok.Kind = MMToken::Period; 605 break; 606 607 case tok::r_brace: 608 Tok.Kind = MMToken::RBrace; 609 break; 610 611 case tok::r_square: 612 Tok.Kind = MMToken::RSquare; 613 break; 614 615 case tok::star: 616 Tok.Kind = MMToken::Star; 617 break; 618 619 case tok::string_literal: { 620 if (LToken.hasUDSuffix()) { 621 Diags.Report(LToken.getLocation(), diag::err_invalid_string_udl); 622 HadError = true; 623 goto retry; 624 } 625 626 // Parse the string literal. 627 LangOptions LangOpts; 628 StringLiteralParser StringLiteral(<oken, 1, SourceMgr, LangOpts, *Target); 629 if (StringLiteral.hadError) 630 goto retry; 631 632 // Copy the string literal into our string data allocator. 633 unsigned Length = StringLiteral.GetStringLength(); 634 char *Saved = StringData.Allocate<char>(Length + 1); 635 memcpy(Saved, StringLiteral.GetString().data(), Length); 636 Saved[Length] = 0; 637 638 // Form the token. 639 Tok.Kind = MMToken::StringLiteral; 640 Tok.StringData = Saved; 641 Tok.StringLength = Length; 642 break; 643 } 644 645 case tok::comment: 646 goto retry; 647 648 default: 649 Diags.Report(LToken.getLocation(), diag::err_mmap_unknown_token); 650 HadError = true; 651 goto retry; 652 } 653 654 return Result; 655 } 656 657 void ModuleMapParser::skipUntil(MMToken::TokenKind K) { 658 unsigned braceDepth = 0; 659 unsigned squareDepth = 0; 660 do { 661 switch (Tok.Kind) { 662 case MMToken::EndOfFile: 663 return; 664 665 case MMToken::LBrace: 666 if (Tok.is(K) && braceDepth == 0 && squareDepth == 0) 667 return; 668 669 ++braceDepth; 670 break; 671 672 case MMToken::LSquare: 673 if (Tok.is(K) && braceDepth == 0 && squareDepth == 0) 674 return; 675 676 ++squareDepth; 677 break; 678 679 case MMToken::RBrace: 680 if (braceDepth > 0) 681 --braceDepth; 682 else if (Tok.is(K)) 683 return; 684 break; 685 686 case MMToken::RSquare: 687 if (squareDepth > 0) 688 --squareDepth; 689 else if (Tok.is(K)) 690 return; 691 break; 692 693 default: 694 if (braceDepth == 0 && squareDepth == 0 && Tok.is(K)) 695 return; 696 break; 697 } 698 699 consumeToken(); 700 } while (true); 701 } 702 703 /// \brief Parse a module-id. 704 /// 705 /// module-id: 706 /// identifier 707 /// identifier '.' module-id 708 /// 709 /// \returns true if an error occurred, false otherwise. 710 bool ModuleMapParser::parseModuleId(ModuleId &Id) { 711 Id.clear(); 712 do { 713 if (Tok.is(MMToken::Identifier)) { 714 Id.push_back(std::make_pair(Tok.getString(), Tok.getLocation())); 715 consumeToken(); 716 } else { 717 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module_name); 718 return true; 719 } 720 721 if (!Tok.is(MMToken::Period)) 722 break; 723 724 consumeToken(); 725 } while (true); 726 727 return false; 728 } 729 730 namespace { 731 /// \brief Enumerates the known attributes. 732 enum AttributeKind { 733 /// \brief An unknown attribute. 734 AT_unknown, 735 /// \brief The 'system' attribute. 736 AT_system 737 }; 738 } 739 740 /// \brief Parse a module declaration. 741 /// 742 /// module-declaration: 743 /// 'explicit'[opt] 'framework'[opt] 'module' module-id attributes[opt] 744 /// { module-member* } 745 /// 746 /// attributes: 747 /// attribute attributes 748 /// attribute 749 /// 750 /// attribute: 751 /// [ identifier ] 752 /// 753 /// module-member: 754 /// requires-declaration 755 /// header-declaration 756 /// submodule-declaration 757 /// export-declaration 758 /// 759 /// submodule-declaration: 760 /// module-declaration 761 /// inferred-submodule-declaration 762 void ModuleMapParser::parseModuleDecl() { 763 assert(Tok.is(MMToken::ExplicitKeyword) || Tok.is(MMToken::ModuleKeyword) || 764 Tok.is(MMToken::FrameworkKeyword)); 765 // Parse 'explicit' or 'framework' keyword, if present. 766 SourceLocation ExplicitLoc; 767 bool Explicit = false; 768 bool Framework = false; 769 770 // Parse 'explicit' keyword, if present. 771 if (Tok.is(MMToken::ExplicitKeyword)) { 772 ExplicitLoc = consumeToken(); 773 Explicit = true; 774 } 775 776 // Parse 'framework' keyword, if present. 777 if (Tok.is(MMToken::FrameworkKeyword)) { 778 consumeToken(); 779 Framework = true; 780 } 781 782 // Parse 'module' keyword. 783 if (!Tok.is(MMToken::ModuleKeyword)) { 784 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module); 785 consumeToken(); 786 HadError = true; 787 return; 788 } 789 consumeToken(); // 'module' keyword 790 791 // If we have a wildcard for the module name, this is an inferred submodule. 792 // Parse it. 793 if (Tok.is(MMToken::Star)) 794 return parseInferredSubmoduleDecl(Explicit); 795 796 // Parse the module name. 797 ModuleId Id; 798 if (parseModuleId(Id)) { 799 HadError = true; 800 return; 801 } 802 803 if (ActiveModule) { 804 if (Id.size() > 1) { 805 Diags.Report(Id.front().second, diag::err_mmap_nested_submodule_id) 806 << SourceRange(Id.front().second, Id.back().second); 807 808 HadError = true; 809 return; 810 } 811 } else if (Id.size() == 1 && Explicit) { 812 // Top-level modules can't be explicit. 813 Diags.Report(ExplicitLoc, diag::err_mmap_explicit_top_level); 814 Explicit = false; 815 ExplicitLoc = SourceLocation(); 816 HadError = true; 817 } 818 819 Module *PreviousActiveModule = ActiveModule; 820 if (Id.size() > 1) { 821 // This module map defines a submodule. Go find the module of which it 822 // is a submodule. 823 ActiveModule = 0; 824 for (unsigned I = 0, N = Id.size() - 1; I != N; ++I) { 825 if (Module *Next = Map.lookupModuleQualified(Id[I].first, ActiveModule)) { 826 ActiveModule = Next; 827 continue; 828 } 829 830 if (ActiveModule) { 831 Diags.Report(Id[I].second, diag::err_mmap_missing_module_qualified) 832 << Id[I].first << ActiveModule->getTopLevelModule(); 833 } else { 834 Diags.Report(Id[I].second, diag::err_mmap_expected_module_name); 835 } 836 HadError = true; 837 return; 838 } 839 } 840 841 StringRef ModuleName = Id.back().first; 842 SourceLocation ModuleNameLoc = Id.back().second; 843 844 // Parse the optional attribute list. 845 bool IsSystem = false; 846 while (Tok.is(MMToken::LSquare)) { 847 // Consume the '['. 848 SourceLocation LSquareLoc = consumeToken(); 849 850 // Check whether we have an attribute name here. 851 if (!Tok.is(MMToken::Identifier)) { 852 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_attribute); 853 skipUntil(MMToken::RSquare); 854 if (Tok.is(MMToken::RSquare)) 855 consumeToken(); 856 continue; 857 } 858 859 // Decode the attribute name. 860 AttributeKind Attribute 861 = llvm::StringSwitch<AttributeKind>(Tok.getString()) 862 .Case("system", AT_system) 863 .Default(AT_unknown); 864 switch (Attribute) { 865 case AT_unknown: 866 Diags.Report(Tok.getLocation(), diag::warn_mmap_unknown_attribute) 867 << Tok.getString(); 868 break; 869 870 case AT_system: 871 IsSystem = true; 872 break; 873 } 874 consumeToken(); 875 876 // Consume the ']'. 877 if (!Tok.is(MMToken::RSquare)) { 878 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rsquare); 879 Diags.Report(LSquareLoc, diag::note_mmap_lsquare_match); 880 skipUntil(MMToken::RSquare); 881 } 882 883 if (Tok.is(MMToken::RSquare)) 884 consumeToken(); 885 } 886 887 // Parse the opening brace. 888 if (!Tok.is(MMToken::LBrace)) { 889 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_lbrace) 890 << ModuleName; 891 HadError = true; 892 return; 893 } 894 SourceLocation LBraceLoc = consumeToken(); 895 896 // Determine whether this (sub)module has already been defined. 897 if (Module *Existing = Map.lookupModuleQualified(ModuleName, ActiveModule)) { 898 if (Existing->DefinitionLoc.isInvalid() && !ActiveModule) { 899 // Skip the module definition. 900 skipUntil(MMToken::RBrace); 901 if (Tok.is(MMToken::RBrace)) 902 consumeToken(); 903 else { 904 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace); 905 Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match); 906 HadError = true; 907 } 908 return; 909 } 910 911 Diags.Report(ModuleNameLoc, diag::err_mmap_module_redefinition) 912 << ModuleName; 913 Diags.Report(Existing->DefinitionLoc, diag::note_mmap_prev_definition); 914 915 // Skip the module definition. 916 skipUntil(MMToken::RBrace); 917 if (Tok.is(MMToken::RBrace)) 918 consumeToken(); 919 920 HadError = true; 921 return; 922 } 923 924 // Start defining this module. 925 ActiveModule = Map.findOrCreateModule(ModuleName, ActiveModule, Framework, 926 Explicit).first; 927 ActiveModule->DefinitionLoc = ModuleNameLoc; 928 if (IsSystem) 929 ActiveModule->IsSystem = true; 930 931 bool Done = false; 932 do { 933 switch (Tok.Kind) { 934 case MMToken::EndOfFile: 935 case MMToken::RBrace: 936 Done = true; 937 break; 938 939 case MMToken::ExplicitKeyword: 940 case MMToken::FrameworkKeyword: 941 case MMToken::ModuleKeyword: 942 parseModuleDecl(); 943 break; 944 945 case MMToken::ExportKeyword: 946 parseExportDecl(); 947 break; 948 949 case MMToken::RequiresKeyword: 950 parseRequiresDecl(); 951 break; 952 953 case MMToken::UmbrellaKeyword: { 954 SourceLocation UmbrellaLoc = consumeToken(); 955 if (Tok.is(MMToken::HeaderKeyword)) 956 parseHeaderDecl(UmbrellaLoc); 957 else 958 parseUmbrellaDirDecl(UmbrellaLoc); 959 break; 960 } 961 962 case MMToken::HeaderKeyword: 963 parseHeaderDecl(SourceLocation()); 964 break; 965 966 default: 967 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_member); 968 consumeToken(); 969 break; 970 } 971 } while (!Done); 972 973 if (Tok.is(MMToken::RBrace)) 974 consumeToken(); 975 else { 976 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace); 977 Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match); 978 HadError = true; 979 } 980 981 // We're done parsing this module. Pop back to the previous module. 982 ActiveModule = PreviousActiveModule; 983 } 984 985 /// \brief Parse a requires declaration. 986 /// 987 /// requires-declaration: 988 /// 'requires' feature-list 989 /// 990 /// feature-list: 991 /// identifier ',' feature-list 992 /// identifier 993 void ModuleMapParser::parseRequiresDecl() { 994 assert(Tok.is(MMToken::RequiresKeyword)); 995 996 // Parse 'requires' keyword. 997 consumeToken(); 998 999 // Parse the feature-list. 1000 do { 1001 if (!Tok.is(MMToken::Identifier)) { 1002 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_feature); 1003 HadError = true; 1004 return; 1005 } 1006 1007 // Consume the feature name. 1008 std::string Feature = Tok.getString(); 1009 consumeToken(); 1010 1011 // Add this feature. 1012 ActiveModule->addRequirement(Feature, Map.LangOpts, *Map.Target); 1013 1014 if (!Tok.is(MMToken::Comma)) 1015 break; 1016 1017 // Consume the comma. 1018 consumeToken(); 1019 } while (true); 1020 } 1021 1022 /// \brief Append to \p Paths the set of paths needed to get to the 1023 /// subframework in which the given module lives. 1024 static void appendSubframeworkPaths(Module *Mod, 1025 llvm::SmallVectorImpl<char> &Path) { 1026 // Collect the framework names from the given module to the top-level module. 1027 llvm::SmallVector<StringRef, 2> Paths; 1028 for (; Mod; Mod = Mod->Parent) { 1029 if (Mod->IsFramework) 1030 Paths.push_back(Mod->Name); 1031 } 1032 1033 if (Paths.empty()) 1034 return; 1035 1036 // Add Frameworks/Name.framework for each subframework. 1037 for (unsigned I = Paths.size() - 1; I != 0; --I) { 1038 llvm::sys::path::append(Path, "Frameworks"); 1039 llvm::sys::path::append(Path, Paths[I-1] + ".framework"); 1040 } 1041 } 1042 1043 /// \brief Determine whether the given file name is the name of a builtin 1044 /// header, supplied by Clang to replace, override, or augment existing system 1045 /// headers. 1046 static bool isBuiltinHeader(StringRef FileName) { 1047 return llvm::StringSwitch<bool>(FileName) 1048 .Case("float.h", true) 1049 .Case("iso646.h", true) 1050 .Case("limits.h", true) 1051 .Case("stdalign.h", true) 1052 .Case("stdarg.h", true) 1053 .Case("stdbool.h", true) 1054 .Case("stddef.h", true) 1055 .Case("stdint.h", true) 1056 .Case("tgmath.h", true) 1057 .Case("unwind.h", true) 1058 .Default(false); 1059 } 1060 1061 /// \brief Parse a header declaration. 1062 /// 1063 /// header-declaration: 1064 /// 'umbrella'[opt] 'header' string-literal 1065 void ModuleMapParser::parseHeaderDecl(SourceLocation UmbrellaLoc) { 1066 assert(Tok.is(MMToken::HeaderKeyword)); 1067 consumeToken(); 1068 1069 bool Umbrella = UmbrellaLoc.isValid(); 1070 1071 // Parse the header name. 1072 if (!Tok.is(MMToken::StringLiteral)) { 1073 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header) 1074 << "header"; 1075 HadError = true; 1076 return; 1077 } 1078 std::string FileName = Tok.getString(); 1079 SourceLocation FileNameLoc = consumeToken(); 1080 1081 // Check whether we already have an umbrella. 1082 if (Umbrella && ActiveModule->Umbrella) { 1083 Diags.Report(FileNameLoc, diag::err_mmap_umbrella_clash) 1084 << ActiveModule->getFullModuleName(); 1085 HadError = true; 1086 return; 1087 } 1088 1089 // Look for this file. 1090 const FileEntry *File = 0; 1091 const FileEntry *BuiltinFile = 0; 1092 SmallString<128> PathName; 1093 if (llvm::sys::path::is_absolute(FileName)) { 1094 PathName = FileName; 1095 File = SourceMgr.getFileManager().getFile(PathName); 1096 } else if (const DirectoryEntry *Dir = getOverriddenHeaderSearchDir()) { 1097 PathName = Dir->getName(); 1098 llvm::sys::path::append(PathName, FileName); 1099 File = SourceMgr.getFileManager().getFile(PathName); 1100 } else { 1101 // Search for the header file within the search directory. 1102 PathName = Directory->getName(); 1103 unsigned PathLength = PathName.size(); 1104 1105 if (ActiveModule->isPartOfFramework()) { 1106 appendSubframeworkPaths(ActiveModule, PathName); 1107 1108 // Check whether this file is in the public headers. 1109 llvm::sys::path::append(PathName, "Headers"); 1110 llvm::sys::path::append(PathName, FileName); 1111 File = SourceMgr.getFileManager().getFile(PathName); 1112 1113 if (!File) { 1114 // Check whether this file is in the private headers. 1115 PathName.resize(PathLength); 1116 llvm::sys::path::append(PathName, "PrivateHeaders"); 1117 llvm::sys::path::append(PathName, FileName); 1118 File = SourceMgr.getFileManager().getFile(PathName); 1119 } 1120 } else { 1121 // Lookup for normal headers. 1122 llvm::sys::path::append(PathName, FileName); 1123 File = SourceMgr.getFileManager().getFile(PathName); 1124 1125 // If this is a system module with a top-level header, this header 1126 // may have a counterpart (or replacement) in the set of headers 1127 // supplied by Clang. Find that builtin header. 1128 if (ActiveModule->IsSystem && !Umbrella && BuiltinIncludeDir && 1129 BuiltinIncludeDir != Directory && isBuiltinHeader(FileName)) { 1130 SmallString<128> BuiltinPathName(BuiltinIncludeDir->getName()); 1131 llvm::sys::path::append(BuiltinPathName, FileName); 1132 BuiltinFile = SourceMgr.getFileManager().getFile(BuiltinPathName); 1133 1134 // If Clang supplies this header but the underlying system does not, 1135 // just silently swap in our builtin version. Otherwise, we'll end 1136 // up adding both (later). 1137 if (!File && BuiltinFile) { 1138 File = BuiltinFile; 1139 BuiltinFile = 0; 1140 } 1141 } 1142 } 1143 } 1144 1145 // FIXME: We shouldn't be eagerly stat'ing every file named in a module map. 1146 // Come up with a lazy way to do this. 1147 if (File) { 1148 if (const Module *OwningModule = Map.Headers[File]) { 1149 Diags.Report(FileNameLoc, diag::err_mmap_header_conflict) 1150 << FileName << OwningModule->getFullModuleName(); 1151 HadError = true; 1152 } else if (Umbrella) { 1153 const DirectoryEntry *UmbrellaDir = File->getDir(); 1154 if ((OwningModule = Map.UmbrellaDirs[UmbrellaDir])) { 1155 Diags.Report(UmbrellaLoc, diag::err_mmap_umbrella_clash) 1156 << OwningModule->getFullModuleName(); 1157 HadError = true; 1158 } else { 1159 // Record this umbrella header. 1160 Map.setUmbrellaHeader(ActiveModule, File); 1161 } 1162 } else { 1163 // Record this header. 1164 Map.addHeader(ActiveModule, File); 1165 1166 // If there is a builtin counterpart to this file, add it now. 1167 if (BuiltinFile) 1168 Map.addHeader(ActiveModule, BuiltinFile); 1169 } 1170 } else { 1171 Diags.Report(FileNameLoc, diag::err_mmap_header_not_found) 1172 << Umbrella << FileName; 1173 HadError = true; 1174 } 1175 } 1176 1177 /// \brief Parse an umbrella directory declaration. 1178 /// 1179 /// umbrella-dir-declaration: 1180 /// umbrella string-literal 1181 void ModuleMapParser::parseUmbrellaDirDecl(SourceLocation UmbrellaLoc) { 1182 // Parse the directory name. 1183 if (!Tok.is(MMToken::StringLiteral)) { 1184 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header) 1185 << "umbrella"; 1186 HadError = true; 1187 return; 1188 } 1189 1190 std::string DirName = Tok.getString(); 1191 SourceLocation DirNameLoc = consumeToken(); 1192 1193 // Check whether we already have an umbrella. 1194 if (ActiveModule->Umbrella) { 1195 Diags.Report(DirNameLoc, diag::err_mmap_umbrella_clash) 1196 << ActiveModule->getFullModuleName(); 1197 HadError = true; 1198 return; 1199 } 1200 1201 // Look for this file. 1202 const DirectoryEntry *Dir = 0; 1203 if (llvm::sys::path::is_absolute(DirName)) 1204 Dir = SourceMgr.getFileManager().getDirectory(DirName); 1205 else { 1206 SmallString<128> PathName; 1207 PathName = Directory->getName(); 1208 llvm::sys::path::append(PathName, DirName); 1209 Dir = SourceMgr.getFileManager().getDirectory(PathName); 1210 } 1211 1212 if (!Dir) { 1213 Diags.Report(DirNameLoc, diag::err_mmap_umbrella_dir_not_found) 1214 << DirName; 1215 HadError = true; 1216 return; 1217 } 1218 1219 if (Module *OwningModule = Map.UmbrellaDirs[Dir]) { 1220 Diags.Report(UmbrellaLoc, diag::err_mmap_umbrella_clash) 1221 << OwningModule->getFullModuleName(); 1222 HadError = true; 1223 return; 1224 } 1225 1226 // Record this umbrella directory. 1227 Map.setUmbrellaDir(ActiveModule, Dir); 1228 } 1229 1230 /// \brief Parse a module export declaration. 1231 /// 1232 /// export-declaration: 1233 /// 'export' wildcard-module-id 1234 /// 1235 /// wildcard-module-id: 1236 /// identifier 1237 /// '*' 1238 /// identifier '.' wildcard-module-id 1239 void ModuleMapParser::parseExportDecl() { 1240 assert(Tok.is(MMToken::ExportKeyword)); 1241 SourceLocation ExportLoc = consumeToken(); 1242 1243 // Parse the module-id with an optional wildcard at the end. 1244 ModuleId ParsedModuleId; 1245 bool Wildcard = false; 1246 do { 1247 if (Tok.is(MMToken::Identifier)) { 1248 ParsedModuleId.push_back(std::make_pair(Tok.getString(), 1249 Tok.getLocation())); 1250 consumeToken(); 1251 1252 if (Tok.is(MMToken::Period)) { 1253 consumeToken(); 1254 continue; 1255 } 1256 1257 break; 1258 } 1259 1260 if(Tok.is(MMToken::Star)) { 1261 Wildcard = true; 1262 consumeToken(); 1263 break; 1264 } 1265 1266 Diags.Report(Tok.getLocation(), diag::err_mmap_export_module_id); 1267 HadError = true; 1268 return; 1269 } while (true); 1270 1271 Module::UnresolvedExportDecl Unresolved = { 1272 ExportLoc, ParsedModuleId, Wildcard 1273 }; 1274 ActiveModule->UnresolvedExports.push_back(Unresolved); 1275 } 1276 1277 void ModuleMapParser::parseInferredSubmoduleDecl(bool Explicit) { 1278 assert(Tok.is(MMToken::Star)); 1279 SourceLocation StarLoc = consumeToken(); 1280 bool Failed = false; 1281 1282 // Inferred modules must be submodules. 1283 if (!ActiveModule) { 1284 Diags.Report(StarLoc, diag::err_mmap_top_level_inferred_submodule); 1285 Failed = true; 1286 } 1287 1288 // Inferred modules must have umbrella directories. 1289 if (!Failed && !ActiveModule->getUmbrellaDir()) { 1290 Diags.Report(StarLoc, diag::err_mmap_inferred_no_umbrella); 1291 Failed = true; 1292 } 1293 1294 // Check for redefinition of an inferred module. 1295 if (!Failed && ActiveModule->InferSubmodules) { 1296 Diags.Report(StarLoc, diag::err_mmap_inferred_redef); 1297 if (ActiveModule->InferredSubmoduleLoc.isValid()) 1298 Diags.Report(ActiveModule->InferredSubmoduleLoc, 1299 diag::note_mmap_prev_definition); 1300 Failed = true; 1301 } 1302 1303 // If there were any problems with this inferred submodule, skip its body. 1304 if (Failed) { 1305 if (Tok.is(MMToken::LBrace)) { 1306 consumeToken(); 1307 skipUntil(MMToken::RBrace); 1308 if (Tok.is(MMToken::RBrace)) 1309 consumeToken(); 1310 } 1311 HadError = true; 1312 return; 1313 } 1314 1315 // Note that we have an inferred submodule. 1316 ActiveModule->InferSubmodules = true; 1317 ActiveModule->InferredSubmoduleLoc = StarLoc; 1318 ActiveModule->InferExplicitSubmodules = Explicit; 1319 1320 // Parse the opening brace. 1321 if (!Tok.is(MMToken::LBrace)) { 1322 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_lbrace_wildcard); 1323 HadError = true; 1324 return; 1325 } 1326 SourceLocation LBraceLoc = consumeToken(); 1327 1328 // Parse the body of the inferred submodule. 1329 bool Done = false; 1330 do { 1331 switch (Tok.Kind) { 1332 case MMToken::EndOfFile: 1333 case MMToken::RBrace: 1334 Done = true; 1335 break; 1336 1337 case MMToken::ExportKeyword: { 1338 consumeToken(); 1339 if (Tok.is(MMToken::Star)) 1340 ActiveModule->InferExportWildcard = true; 1341 else 1342 Diags.Report(Tok.getLocation(), 1343 diag::err_mmap_expected_export_wildcard); 1344 consumeToken(); 1345 break; 1346 } 1347 1348 case MMToken::ExplicitKeyword: 1349 case MMToken::ModuleKeyword: 1350 case MMToken::HeaderKeyword: 1351 case MMToken::UmbrellaKeyword: 1352 default: 1353 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_wildcard_member); 1354 consumeToken(); 1355 break; 1356 } 1357 } while (!Done); 1358 1359 if (Tok.is(MMToken::RBrace)) 1360 consumeToken(); 1361 else { 1362 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace); 1363 Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match); 1364 HadError = true; 1365 } 1366 } 1367 1368 /// \brief If there is a specific header search directory due the presence 1369 /// of an umbrella directory, retrieve that directory. Otherwise, returns null. 1370 const DirectoryEntry *ModuleMapParser::getOverriddenHeaderSearchDir() { 1371 for (Module *Mod = ActiveModule; Mod; Mod = Mod->Parent) { 1372 // If we have an umbrella directory, use that. 1373 if (Mod->hasUmbrellaDir()) 1374 return Mod->getUmbrellaDir(); 1375 1376 // If we have a framework directory, stop looking. 1377 if (Mod->IsFramework) 1378 return 0; 1379 } 1380 1381 return 0; 1382 } 1383 1384 /// \brief Parse a module map file. 1385 /// 1386 /// module-map-file: 1387 /// module-declaration* 1388 bool ModuleMapParser::parseModuleMapFile() { 1389 do { 1390 switch (Tok.Kind) { 1391 case MMToken::EndOfFile: 1392 return HadError; 1393 1394 case MMToken::ExplicitKeyword: 1395 case MMToken::ModuleKeyword: 1396 case MMToken::FrameworkKeyword: 1397 parseModuleDecl(); 1398 break; 1399 1400 case MMToken::Comma: 1401 case MMToken::ExportKeyword: 1402 case MMToken::HeaderKeyword: 1403 case MMToken::Identifier: 1404 case MMToken::LBrace: 1405 case MMToken::LSquare: 1406 case MMToken::Period: 1407 case MMToken::RBrace: 1408 case MMToken::RSquare: 1409 case MMToken::RequiresKeyword: 1410 case MMToken::Star: 1411 case MMToken::StringLiteral: 1412 case MMToken::UmbrellaKeyword: 1413 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module); 1414 HadError = true; 1415 consumeToken(); 1416 break; 1417 } 1418 } while (true); 1419 } 1420 1421 bool ModuleMap::parseModuleMapFile(const FileEntry *File) { 1422 assert(Target != 0 && "Missing target information"); 1423 FileID ID = SourceMgr->createFileID(File, SourceLocation(), SrcMgr::C_User); 1424 const llvm::MemoryBuffer *Buffer = SourceMgr->getBuffer(ID); 1425 if (!Buffer) 1426 return true; 1427 1428 // Parse this module map file. 1429 Lexer L(ID, SourceMgr->getBuffer(ID), *SourceMgr, MMapLangOpts); 1430 Diags->getClient()->BeginSourceFile(MMapLangOpts); 1431 ModuleMapParser Parser(L, *SourceMgr, *Diags, *this, File->getDir(), 1432 BuiltinIncludeDir); 1433 bool Result = Parser.parseModuleMapFile(); 1434 Diags->getClient()->EndSourceFile(); 1435 1436 return Result; 1437 } 1438