contrib/llvm/tools/clang/lib/Lex/ModuleMap.cpp

   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 &Map;
 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(&LToken, 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 }