1718292f2SDouglas Gregor //===--- ModuleMap.cpp - Describe the layout of modules ---------*- C++ -*-===// 2718292f2SDouglas Gregor // 3718292f2SDouglas Gregor // The LLVM Compiler Infrastructure 4718292f2SDouglas Gregor // 5718292f2SDouglas Gregor // This file is distributed under the University of Illinois Open Source 6718292f2SDouglas Gregor // License. See LICENSE.TXT for details. 7718292f2SDouglas Gregor // 8718292f2SDouglas Gregor //===----------------------------------------------------------------------===// 9718292f2SDouglas Gregor // 10718292f2SDouglas Gregor // This file defines the ModuleMap implementation, which describes the layout 11718292f2SDouglas Gregor // of a module as it relates to headers. 12718292f2SDouglas Gregor // 13718292f2SDouglas Gregor //===----------------------------------------------------------------------===// 14718292f2SDouglas Gregor #include "clang/Lex/ModuleMap.h" 15a7d03840SJordan Rose #include "clang/Basic/CharInfo.h" 16718292f2SDouglas Gregor #include "clang/Basic/Diagnostic.h" 17811db4eaSDouglas Gregor #include "clang/Basic/DiagnosticOptions.h" 18718292f2SDouglas Gregor #include "clang/Basic/FileManager.h" 19718292f2SDouglas Gregor #include "clang/Basic/TargetInfo.h" 20718292f2SDouglas Gregor #include "clang/Basic/TargetOptions.h" 21b146baabSArgyrios Kyrtzidis #include "clang/Lex/HeaderSearch.h" 223a02247dSChandler Carruth #include "clang/Lex/LexDiagnostic.h" 233a02247dSChandler Carruth #include "clang/Lex/Lexer.h" 243a02247dSChandler Carruth #include "clang/Lex/LiteralSupport.h" 253a02247dSChandler Carruth #include "llvm/ADT/StringRef.h" 263a02247dSChandler Carruth #include "llvm/ADT/StringSwitch.h" 27718292f2SDouglas Gregor #include "llvm/Support/Allocator.h" 28e89dbc1dSDouglas Gregor #include "llvm/Support/FileSystem.h" 29718292f2SDouglas Gregor #include "llvm/Support/Host.h" 30552c169eSRafael Espindola #include "llvm/Support/Path.h" 31718292f2SDouglas Gregor #include "llvm/Support/raw_ostream.h" 3207c22b78SDouglas Gregor #include <stdlib.h> 3301c7cfa2SDouglas Gregor #if defined(LLVM_ON_UNIX) 34eadae014SDmitri Gribenko #include <limits.h> 3501c7cfa2SDouglas Gregor #endif 36718292f2SDouglas Gregor using namespace clang; 37718292f2SDouglas Gregor 382b82c2a5SDouglas Gregor Module::ExportDecl 392b82c2a5SDouglas Gregor ModuleMap::resolveExport(Module *Mod, 402b82c2a5SDouglas Gregor const Module::UnresolvedExportDecl &Unresolved, 41e4412640SArgyrios Kyrtzidis bool Complain) const { 42f5eedd05SDouglas Gregor // We may have just a wildcard. 43f5eedd05SDouglas Gregor if (Unresolved.Id.empty()) { 44f5eedd05SDouglas Gregor assert(Unresolved.Wildcard && "Invalid unresolved export"); 45d2d442caSCraig Topper return Module::ExportDecl(nullptr, true); 46f5eedd05SDouglas Gregor } 47f5eedd05SDouglas Gregor 48fb912657SDouglas Gregor // Resolve the module-id. 49fb912657SDouglas Gregor Module *Context = resolveModuleId(Unresolved.Id, Mod, Complain); 50fb912657SDouglas Gregor if (!Context) 51fb912657SDouglas Gregor return Module::ExportDecl(); 52fb912657SDouglas Gregor 53fb912657SDouglas Gregor return Module::ExportDecl(Context, Unresolved.Wildcard); 54fb912657SDouglas Gregor } 55fb912657SDouglas Gregor 56fb912657SDouglas Gregor Module *ModuleMap::resolveModuleId(const ModuleId &Id, Module *Mod, 57fb912657SDouglas Gregor bool Complain) const { 582b82c2a5SDouglas Gregor // Find the starting module. 59fb912657SDouglas Gregor Module *Context = lookupModuleUnqualified(Id[0].first, Mod); 602b82c2a5SDouglas Gregor if (!Context) { 612b82c2a5SDouglas Gregor if (Complain) 620761a8a0SDaniel Jasper Diags.Report(Id[0].second, diag::err_mmap_missing_module_unqualified) 63fb912657SDouglas Gregor << Id[0].first << Mod->getFullModuleName(); 642b82c2a5SDouglas Gregor 65d2d442caSCraig Topper return nullptr; 662b82c2a5SDouglas Gregor } 672b82c2a5SDouglas Gregor 682b82c2a5SDouglas Gregor // Dig into the module path. 69fb912657SDouglas Gregor for (unsigned I = 1, N = Id.size(); I != N; ++I) { 70fb912657SDouglas Gregor Module *Sub = lookupModuleQualified(Id[I].first, Context); 712b82c2a5SDouglas Gregor if (!Sub) { 722b82c2a5SDouglas Gregor if (Complain) 730761a8a0SDaniel Jasper Diags.Report(Id[I].second, diag::err_mmap_missing_module_qualified) 74fb912657SDouglas Gregor << Id[I].first << Context->getFullModuleName() 75fb912657SDouglas Gregor << SourceRange(Id[0].second, Id[I-1].second); 762b82c2a5SDouglas Gregor 77d2d442caSCraig Topper return nullptr; 782b82c2a5SDouglas Gregor } 792b82c2a5SDouglas Gregor 802b82c2a5SDouglas Gregor Context = Sub; 812b82c2a5SDouglas Gregor } 822b82c2a5SDouglas Gregor 83fb912657SDouglas Gregor return Context; 842b82c2a5SDouglas Gregor } 852b82c2a5SDouglas Gregor 860761a8a0SDaniel Jasper ModuleMap::ModuleMap(SourceManager &SourceMgr, DiagnosticsEngine &Diags, 87b146baabSArgyrios Kyrtzidis const LangOptions &LangOpts, const TargetInfo *Target, 88b146baabSArgyrios Kyrtzidis HeaderSearch &HeaderInfo) 890761a8a0SDaniel Jasper : SourceMgr(SourceMgr), Diags(Diags), LangOpts(LangOpts), Target(Target), 90d2d442caSCraig Topper HeaderInfo(HeaderInfo), BuiltinIncludeDir(nullptr), 91d2d442caSCraig Topper CompilingModule(nullptr), SourceModule(nullptr) {} 92718292f2SDouglas Gregor 93718292f2SDouglas Gregor ModuleMap::~ModuleMap() { 945acdf59eSDouglas Gregor for (llvm::StringMap<Module *>::iterator I = Modules.begin(), 955acdf59eSDouglas Gregor IEnd = Modules.end(); 965acdf59eSDouglas Gregor I != IEnd; ++I) { 975acdf59eSDouglas Gregor delete I->getValue(); 985acdf59eSDouglas Gregor } 99718292f2SDouglas Gregor } 100718292f2SDouglas Gregor 10189929282SDouglas Gregor void ModuleMap::setTarget(const TargetInfo &Target) { 10289929282SDouglas Gregor assert((!this->Target || this->Target == &Target) && 10389929282SDouglas Gregor "Improper target override"); 10489929282SDouglas Gregor this->Target = &Target; 10589929282SDouglas Gregor } 10689929282SDouglas Gregor 107056396aeSDouglas Gregor /// \brief "Sanitize" a filename so that it can be used as an identifier. 108056396aeSDouglas Gregor static StringRef sanitizeFilenameAsIdentifier(StringRef Name, 109056396aeSDouglas Gregor SmallVectorImpl<char> &Buffer) { 110056396aeSDouglas Gregor if (Name.empty()) 111056396aeSDouglas Gregor return Name; 112056396aeSDouglas Gregor 113a7d03840SJordan Rose if (!isValidIdentifier(Name)) { 114056396aeSDouglas Gregor // If we don't already have something with the form of an identifier, 115056396aeSDouglas Gregor // create a buffer with the sanitized name. 116056396aeSDouglas Gregor Buffer.clear(); 117a7d03840SJordan Rose if (isDigit(Name[0])) 118056396aeSDouglas Gregor Buffer.push_back('_'); 119056396aeSDouglas Gregor Buffer.reserve(Buffer.size() + Name.size()); 120056396aeSDouglas Gregor for (unsigned I = 0, N = Name.size(); I != N; ++I) { 121a7d03840SJordan Rose if (isIdentifierBody(Name[I])) 122056396aeSDouglas Gregor Buffer.push_back(Name[I]); 123056396aeSDouglas Gregor else 124056396aeSDouglas Gregor Buffer.push_back('_'); 125056396aeSDouglas Gregor } 126056396aeSDouglas Gregor 127056396aeSDouglas Gregor Name = StringRef(Buffer.data(), Buffer.size()); 128056396aeSDouglas Gregor } 129056396aeSDouglas Gregor 130056396aeSDouglas Gregor while (llvm::StringSwitch<bool>(Name) 131056396aeSDouglas Gregor #define KEYWORD(Keyword,Conditions) .Case(#Keyword, true) 132056396aeSDouglas Gregor #define ALIAS(Keyword, AliasOf, Conditions) .Case(Keyword, true) 133056396aeSDouglas Gregor #include "clang/Basic/TokenKinds.def" 134056396aeSDouglas Gregor .Default(false)) { 135056396aeSDouglas Gregor if (Name.data() != Buffer.data()) 136056396aeSDouglas Gregor Buffer.append(Name.begin(), Name.end()); 137056396aeSDouglas Gregor Buffer.push_back('_'); 138056396aeSDouglas Gregor Name = StringRef(Buffer.data(), Buffer.size()); 139056396aeSDouglas Gregor } 140056396aeSDouglas Gregor 141056396aeSDouglas Gregor return Name; 142056396aeSDouglas Gregor } 143056396aeSDouglas Gregor 14434d52749SDouglas Gregor /// \brief Determine whether the given file name is the name of a builtin 14534d52749SDouglas Gregor /// header, supplied by Clang to replace, override, or augment existing system 14634d52749SDouglas Gregor /// headers. 14734d52749SDouglas Gregor static bool isBuiltinHeader(StringRef FileName) { 14834d52749SDouglas Gregor return llvm::StringSwitch<bool>(FileName) 14934d52749SDouglas Gregor .Case("float.h", true) 15034d52749SDouglas Gregor .Case("iso646.h", true) 15134d52749SDouglas Gregor .Case("limits.h", true) 15234d52749SDouglas Gregor .Case("stdalign.h", true) 15334d52749SDouglas Gregor .Case("stdarg.h", true) 15434d52749SDouglas Gregor .Case("stdbool.h", true) 15534d52749SDouglas Gregor .Case("stddef.h", true) 15634d52749SDouglas Gregor .Case("stdint.h", true) 15734d52749SDouglas Gregor .Case("tgmath.h", true) 15834d52749SDouglas Gregor .Case("unwind.h", true) 15934d52749SDouglas Gregor .Default(false); 16034d52749SDouglas Gregor } 16134d52749SDouglas Gregor 16292669ee4SDaniel Jasper ModuleMap::HeadersMap::iterator 16392669ee4SDaniel Jasper ModuleMap::findKnownHeader(const FileEntry *File) { 16459527666SDouglas Gregor HeadersMap::iterator Known = Headers.find(File); 1654eaf0a6cSDaniel Jasper if (Known == Headers.end() && File->getDir() == BuiltinIncludeDir && 1664eaf0a6cSDaniel Jasper isBuiltinHeader(llvm::sys::path::filename(File->getName()))) { 1674eaf0a6cSDaniel Jasper HeaderInfo.loadTopLevelSystemModules(); 16892669ee4SDaniel Jasper return Headers.find(File); 1694eaf0a6cSDaniel Jasper } 17092669ee4SDaniel Jasper return Known; 17192669ee4SDaniel Jasper } 17292669ee4SDaniel Jasper 1734469138eSBen Langmuir ModuleMap::KnownHeader 1744469138eSBen Langmuir ModuleMap::findHeaderInUmbrellaDirs(const FileEntry *File, 1754469138eSBen Langmuir SmallVectorImpl<const DirectoryEntry *> &IntermediateDirs) { 1764469138eSBen Langmuir const DirectoryEntry *Dir = File->getDir(); 1774469138eSBen Langmuir assert(Dir && "file in no directory"); 1784469138eSBen Langmuir 1794469138eSBen Langmuir // Note: as an egregious but useful hack we use the real path here, because 1804469138eSBen Langmuir // frameworks moving from top-level frameworks to embedded frameworks tend 1814469138eSBen Langmuir // to be symlinked from the top-level location to the embedded location, 1824469138eSBen Langmuir // and we need to resolve lookups as if we had found the embedded location. 1834469138eSBen Langmuir StringRef DirName = SourceMgr.getFileManager().getCanonicalName(Dir); 1844469138eSBen Langmuir 1854469138eSBen Langmuir // Keep walking up the directory hierarchy, looking for a directory with 1864469138eSBen Langmuir // an umbrella header. 1874469138eSBen Langmuir do { 1884469138eSBen Langmuir auto KnownDir = UmbrellaDirs.find(Dir); 1894469138eSBen Langmuir if (KnownDir != UmbrellaDirs.end()) 1904469138eSBen Langmuir return KnownHeader(KnownDir->second, NormalHeader); 1914469138eSBen Langmuir 1924469138eSBen Langmuir IntermediateDirs.push_back(Dir); 1934469138eSBen Langmuir 1944469138eSBen Langmuir // Retrieve our parent path. 1954469138eSBen Langmuir DirName = llvm::sys::path::parent_path(DirName); 1964469138eSBen Langmuir if (DirName.empty()) 1974469138eSBen Langmuir break; 1984469138eSBen Langmuir 1994469138eSBen Langmuir // Resolve the parent path to a directory entry. 2004469138eSBen Langmuir Dir = SourceMgr.getFileManager().getDirectory(DirName); 2014469138eSBen Langmuir } while (Dir); 2024469138eSBen Langmuir return KnownHeader(); 2034469138eSBen Langmuir } 2044469138eSBen Langmuir 20592669ee4SDaniel Jasper // Returns 'true' if 'RequestingModule directly uses 'RequestedModule'. 20692669ee4SDaniel Jasper static bool directlyUses(const Module *RequestingModule, 20792669ee4SDaniel Jasper const Module *RequestedModule) { 20892669ee4SDaniel Jasper return std::find(RequestingModule->DirectUses.begin(), 20992669ee4SDaniel Jasper RequestingModule->DirectUses.end(), 21092669ee4SDaniel Jasper RequestedModule) != RequestingModule->DirectUses.end(); 21192669ee4SDaniel Jasper } 21292669ee4SDaniel Jasper 21392669ee4SDaniel Jasper static bool violatesPrivateInclude(Module *RequestingModule, 21492669ee4SDaniel Jasper const FileEntry *IncFileEnt, 21592669ee4SDaniel Jasper ModuleMap::ModuleHeaderRole Role, 21692669ee4SDaniel Jasper Module *RequestedModule) { 21792669ee4SDaniel Jasper #ifndef NDEBUG 21892669ee4SDaniel Jasper // Check for consistency between the module header role 21992669ee4SDaniel Jasper // as obtained from the lookup and as obtained from the module. 22092669ee4SDaniel Jasper // This check is not cheap, so enable it only for debugging. 22192669ee4SDaniel Jasper SmallVectorImpl<const FileEntry *> &PvtHdrs 22292669ee4SDaniel Jasper = RequestedModule->PrivateHeaders; 22392669ee4SDaniel Jasper SmallVectorImpl<const FileEntry *>::iterator Look 22492669ee4SDaniel Jasper = std::find(PvtHdrs.begin(), PvtHdrs.end(), IncFileEnt); 22592669ee4SDaniel Jasper bool IsPrivate = Look != PvtHdrs.end(); 22692669ee4SDaniel Jasper assert((IsPrivate && Role == ModuleMap::PrivateHeader) 22792669ee4SDaniel Jasper || (!IsPrivate && Role != ModuleMap::PrivateHeader)); 22892669ee4SDaniel Jasper #endif 22992669ee4SDaniel Jasper return Role == ModuleMap::PrivateHeader && 23092669ee4SDaniel Jasper RequestedModule->getTopLevelModule() != RequestingModule; 23192669ee4SDaniel Jasper } 23292669ee4SDaniel Jasper 23371e1a64fSBen Langmuir static Module *getTopLevelOrNull(Module *M) { 23471e1a64fSBen Langmuir return M ? M->getTopLevelModule() : nullptr; 23571e1a64fSBen Langmuir } 23671e1a64fSBen Langmuir 23792669ee4SDaniel Jasper void ModuleMap::diagnoseHeaderInclusion(Module *RequestingModule, 23892669ee4SDaniel Jasper SourceLocation FilenameLoc, 23992669ee4SDaniel Jasper StringRef Filename, 24092669ee4SDaniel Jasper const FileEntry *File) { 24192669ee4SDaniel Jasper // No errors for indirect modules. This may be a bit of a problem for modules 24292669ee4SDaniel Jasper // with no source files. 24371e1a64fSBen Langmuir if (getTopLevelOrNull(RequestingModule) != getTopLevelOrNull(SourceModule)) 24492669ee4SDaniel Jasper return; 24592669ee4SDaniel Jasper 24692669ee4SDaniel Jasper if (RequestingModule) 24792669ee4SDaniel Jasper resolveUses(RequestingModule, /*Complain=*/false); 24892669ee4SDaniel Jasper 24971e1a64fSBen Langmuir bool Excluded = false; 250d2d442caSCraig Topper Module *Private = nullptr; 251d2d442caSCraig Topper Module *NotUsed = nullptr; 25271e1a64fSBen Langmuir 25371e1a64fSBen Langmuir HeadersMap::iterator Known = findKnownHeader(File); 25471e1a64fSBen Langmuir if (Known != Headers.end()) { 25571e1a64fSBen Langmuir for (const KnownHeader &Header : Known->second) { 25692669ee4SDaniel Jasper // Excluded headers don't really belong to a module. 25771e1a64fSBen Langmuir if (Header.getRole() == ModuleMap::ExcludedHeader) { 25871e1a64fSBen Langmuir Excluded = true; 25992669ee4SDaniel Jasper continue; 26071e1a64fSBen Langmuir } 26192669ee4SDaniel Jasper 26292669ee4SDaniel Jasper // If 'File' is part of 'RequestingModule' we can definitely include it. 26371e1a64fSBen Langmuir if (Header.getModule() == RequestingModule) 26492669ee4SDaniel Jasper return; 26592669ee4SDaniel Jasper 26692669ee4SDaniel Jasper // Remember private headers for later printing of a diagnostic. 26771e1a64fSBen Langmuir if (violatesPrivateInclude(RequestingModule, File, Header.getRole(), 26871e1a64fSBen Langmuir Header.getModule())) { 26971e1a64fSBen Langmuir Private = Header.getModule(); 27092669ee4SDaniel Jasper continue; 27192669ee4SDaniel Jasper } 27292669ee4SDaniel Jasper 27392669ee4SDaniel Jasper // If uses need to be specified explicitly, we are only allowed to return 27492669ee4SDaniel Jasper // modules that are explicitly used by the requesting module. 27592669ee4SDaniel Jasper if (RequestingModule && LangOpts.ModulesDeclUse && 27671e1a64fSBen Langmuir !directlyUses(RequestingModule, Header.getModule())) { 27771e1a64fSBen Langmuir NotUsed = Header.getModule(); 27892669ee4SDaniel Jasper continue; 27992669ee4SDaniel Jasper } 28092669ee4SDaniel Jasper 28192669ee4SDaniel Jasper // We have found a module that we can happily use. 28292669ee4SDaniel Jasper return; 28392669ee4SDaniel Jasper } 28471e1a64fSBen Langmuir } 28592669ee4SDaniel Jasper 28692669ee4SDaniel Jasper // We have found a header, but it is private. 287d2d442caSCraig Topper if (Private) { 28892669ee4SDaniel Jasper Diags.Report(FilenameLoc, diag::error_use_of_private_header_outside_module) 28992669ee4SDaniel Jasper << Filename; 29092669ee4SDaniel Jasper return; 29192669ee4SDaniel Jasper } 29292669ee4SDaniel Jasper 29392669ee4SDaniel Jasper // We have found a module, but we don't use it. 294d2d442caSCraig Topper if (NotUsed) { 29592669ee4SDaniel Jasper Diags.Report(FilenameLoc, diag::error_undeclared_use_of_module) 29692669ee4SDaniel Jasper << RequestingModule->getFullModuleName() << Filename; 29792669ee4SDaniel Jasper return; 29892669ee4SDaniel Jasper } 29992669ee4SDaniel Jasper 30071e1a64fSBen Langmuir if (Excluded || isHeaderInUmbrellaDirs(File)) 30171e1a64fSBen Langmuir return; 30271e1a64fSBen Langmuir 30371e1a64fSBen Langmuir // At this point, only non-modular includes remain. 30471e1a64fSBen Langmuir 30571e1a64fSBen Langmuir if (LangOpts.ModulesStrictDeclUse) { 30671e1a64fSBen Langmuir Diags.Report(FilenameLoc, diag::error_undeclared_use_of_module) 30771e1a64fSBen Langmuir << RequestingModule->getFullModuleName() << Filename; 30871e1a64fSBen Langmuir } else if (RequestingModule) { 30971e1a64fSBen Langmuir diag::kind DiagID = RequestingModule->getTopLevelModule()->IsFramework ? 31071e1a64fSBen Langmuir diag::warn_non_modular_include_in_framework_module : 31171e1a64fSBen Langmuir diag::warn_non_modular_include_in_module; 31271e1a64fSBen Langmuir Diags.Report(FilenameLoc, DiagID) << RequestingModule->getFullModuleName(); 31371e1a64fSBen Langmuir } 31492669ee4SDaniel Jasper } 31592669ee4SDaniel Jasper 31692669ee4SDaniel Jasper ModuleMap::KnownHeader 31792669ee4SDaniel Jasper ModuleMap::findModuleForHeader(const FileEntry *File, 31892669ee4SDaniel Jasper Module *RequestingModule) { 31992669ee4SDaniel Jasper HeadersMap::iterator Known = findKnownHeader(File); 3204eaf0a6cSDaniel Jasper 3211fb5c3a6SDouglas Gregor if (Known != Headers.end()) { 32297da9178SDaniel Jasper ModuleMap::KnownHeader Result = KnownHeader(); 3231fb5c3a6SDouglas Gregor 32497da9178SDaniel Jasper // Iterate over all modules that 'File' is part of to find the best fit. 32597da9178SDaniel Jasper for (SmallVectorImpl<KnownHeader>::iterator I = Known->second.begin(), 32697da9178SDaniel Jasper E = Known->second.end(); 32797da9178SDaniel Jasper I != E; ++I) { 3284eaf0a6cSDaniel Jasper // Cannot use a module if the header is excluded in it. 3294eaf0a6cSDaniel Jasper if (I->getRole() == ModuleMap::ExcludedHeader) 3304eaf0a6cSDaniel Jasper continue; 3314eaf0a6cSDaniel Jasper 3324eaf0a6cSDaniel Jasper // Cannot use a module if it is unavailable. 3334eaf0a6cSDaniel Jasper if (!I->getModule()->isAvailable()) 33497da9178SDaniel Jasper continue; 33597da9178SDaniel Jasper 33697da9178SDaniel Jasper // If 'File' is part of 'RequestingModule', 'RequestingModule' is the 33797da9178SDaniel Jasper // module we are looking for. 33897da9178SDaniel Jasper if (I->getModule() == RequestingModule) 33997da9178SDaniel Jasper return *I; 34097da9178SDaniel Jasper 34197da9178SDaniel Jasper // If uses need to be specified explicitly, we are only allowed to return 34297da9178SDaniel Jasper // modules that are explicitly used by the requesting module. 34397da9178SDaniel Jasper if (RequestingModule && LangOpts.ModulesDeclUse && 34492669ee4SDaniel Jasper !directlyUses(RequestingModule, I->getModule())) 34597da9178SDaniel Jasper continue; 3464eaf0a6cSDaniel Jasper 34797da9178SDaniel Jasper Result = *I; 34897da9178SDaniel Jasper // If 'File' is a public header of this module, this is as good as we 34997da9178SDaniel Jasper // are going to get. 3508c71eba1SRichard Smith // FIXME: If we have a RequestingModule, we should prefer the header from 3518c71eba1SRichard Smith // that module. 35297da9178SDaniel Jasper if (I->getRole() == ModuleMap::NormalHeader) 35397da9178SDaniel Jasper break; 35497da9178SDaniel Jasper } 35597da9178SDaniel Jasper return Result; 3561fb5c3a6SDouglas Gregor } 357ab0c8a84SDouglas Gregor 358f857950dSDmitri Gribenko SmallVector<const DirectoryEntry *, 2> SkippedDirs; 3594469138eSBen Langmuir KnownHeader H = findHeaderInUmbrellaDirs(File, SkippedDirs); 3604469138eSBen Langmuir if (H) { 3614469138eSBen Langmuir Module *Result = H.getModule(); 362930a85ccSDouglas Gregor 363930a85ccSDouglas Gregor // Search up the module stack until we find a module with an umbrella 36473141fa9SDouglas Gregor // directory. 365930a85ccSDouglas Gregor Module *UmbrellaModule = Result; 36673141fa9SDouglas Gregor while (!UmbrellaModule->getUmbrellaDir() && UmbrellaModule->Parent) 367930a85ccSDouglas Gregor UmbrellaModule = UmbrellaModule->Parent; 368930a85ccSDouglas Gregor 369930a85ccSDouglas Gregor if (UmbrellaModule->InferSubmodules) { 370*9d6448b1SBen Langmuir const FileEntry *UmbrellaModuleMap = 371*9d6448b1SBen Langmuir getModuleMapFileForUniquing(UmbrellaModule); 372*9d6448b1SBen Langmuir 373a89c5ac4SDouglas Gregor // Infer submodules for each of the directories we found between 374a89c5ac4SDouglas Gregor // the directory of the umbrella header and the directory where 375a89c5ac4SDouglas Gregor // the actual header is located. 3769458f82dSDouglas Gregor bool Explicit = UmbrellaModule->InferExplicitSubmodules; 3779458f82dSDouglas Gregor 3787033127bSDouglas Gregor for (unsigned I = SkippedDirs.size(); I != 0; --I) { 379a89c5ac4SDouglas Gregor // Find or create the module that corresponds to this directory name. 380056396aeSDouglas Gregor SmallString<32> NameBuf; 381056396aeSDouglas Gregor StringRef Name = sanitizeFilenameAsIdentifier( 3824469138eSBen Langmuir llvm::sys::path::stem(SkippedDirs[I-1]->getName()), NameBuf); 383*9d6448b1SBen Langmuir Result = findOrCreateModule(Name, Result, /*IsFramework=*/false, 384*9d6448b1SBen Langmuir Explicit).first; 385*9d6448b1SBen Langmuir InferredModuleAllowedBy[Result] = UmbrellaModuleMap; 386ffbafa2aSBen Langmuir Result->IsInferred = true; 387a89c5ac4SDouglas Gregor 388a89c5ac4SDouglas Gregor // Associate the module and the directory. 389a89c5ac4SDouglas Gregor UmbrellaDirs[SkippedDirs[I-1]] = Result; 390a89c5ac4SDouglas Gregor 391a89c5ac4SDouglas Gregor // If inferred submodules export everything they import, add a 392a89c5ac4SDouglas Gregor // wildcard to the set of exports. 393930a85ccSDouglas Gregor if (UmbrellaModule->InferExportWildcard && Result->Exports.empty()) 394d2d442caSCraig Topper Result->Exports.push_back(Module::ExportDecl(nullptr, true)); 395a89c5ac4SDouglas Gregor } 396a89c5ac4SDouglas Gregor 397a89c5ac4SDouglas Gregor // Infer a submodule with the same name as this header file. 398056396aeSDouglas Gregor SmallString<32> NameBuf; 399056396aeSDouglas Gregor StringRef Name = sanitizeFilenameAsIdentifier( 400056396aeSDouglas Gregor llvm::sys::path::stem(File->getName()), NameBuf); 401*9d6448b1SBen Langmuir Result = findOrCreateModule(Name, Result, /*IsFramework=*/false, 402*9d6448b1SBen Langmuir Explicit).first; 403*9d6448b1SBen Langmuir InferredModuleAllowedBy[Result] = UmbrellaModuleMap; 404ffbafa2aSBen Langmuir Result->IsInferred = true; 4053c5305c1SArgyrios Kyrtzidis Result->addTopHeader(File); 406a89c5ac4SDouglas Gregor 407a89c5ac4SDouglas Gregor // If inferred submodules export everything they import, add a 408a89c5ac4SDouglas Gregor // wildcard to the set of exports. 409930a85ccSDouglas Gregor if (UmbrellaModule->InferExportWildcard && Result->Exports.empty()) 410d2d442caSCraig Topper Result->Exports.push_back(Module::ExportDecl(nullptr, true)); 411a89c5ac4SDouglas Gregor } else { 412a89c5ac4SDouglas Gregor // Record each of the directories we stepped through as being part of 413a89c5ac4SDouglas Gregor // the module we found, since the umbrella header covers them all. 414a89c5ac4SDouglas Gregor for (unsigned I = 0, N = SkippedDirs.size(); I != N; ++I) 415a89c5ac4SDouglas Gregor UmbrellaDirs[SkippedDirs[I]] = Result; 416a89c5ac4SDouglas Gregor } 417a89c5ac4SDouglas Gregor 41897da9178SDaniel Jasper Headers[File].push_back(KnownHeader(Result, NormalHeader)); 4191fb5c3a6SDouglas Gregor 4201fb5c3a6SDouglas Gregor // If a header corresponds to an unavailable module, don't report 4211fb5c3a6SDouglas Gregor // that it maps to anything. 4221fb5c3a6SDouglas Gregor if (!Result->isAvailable()) 423b53e5483SLawrence Crowl return KnownHeader(); 4241fb5c3a6SDouglas Gregor 42597da9178SDaniel Jasper return Headers[File].back(); 426a89c5ac4SDouglas Gregor } 427a89c5ac4SDouglas Gregor 428b53e5483SLawrence Crowl return KnownHeader(); 429ab0c8a84SDouglas Gregor } 430ab0c8a84SDouglas Gregor 431e4412640SArgyrios Kyrtzidis bool ModuleMap::isHeaderInUnavailableModule(const FileEntry *Header) const { 432d2d442caSCraig Topper return isHeaderUnavailableInModule(Header, nullptr); 43350996ce1SRichard Smith } 43450996ce1SRichard Smith 43562bcd925SDmitri Gribenko bool 43662bcd925SDmitri Gribenko ModuleMap::isHeaderUnavailableInModule(const FileEntry *Header, 43762bcd925SDmitri Gribenko const Module *RequestingModule) const { 438e4412640SArgyrios Kyrtzidis HeadersMap::const_iterator Known = Headers.find(Header); 43997da9178SDaniel Jasper if (Known != Headers.end()) { 44097da9178SDaniel Jasper for (SmallVectorImpl<KnownHeader>::const_iterator 44197da9178SDaniel Jasper I = Known->second.begin(), 44297da9178SDaniel Jasper E = Known->second.end(); 44397da9178SDaniel Jasper I != E; ++I) { 44450996ce1SRichard Smith if (I->isAvailable() && (!RequestingModule || 44550996ce1SRichard Smith I->getModule()->isSubModuleOf(RequestingModule))) 44697da9178SDaniel Jasper return false; 44797da9178SDaniel Jasper } 44897da9178SDaniel Jasper return true; 44997da9178SDaniel Jasper } 4501fb5c3a6SDouglas Gregor 4511fb5c3a6SDouglas Gregor const DirectoryEntry *Dir = Header->getDir(); 452f857950dSDmitri Gribenko SmallVector<const DirectoryEntry *, 2> SkippedDirs; 4531fb5c3a6SDouglas Gregor StringRef DirName = Dir->getName(); 4541fb5c3a6SDouglas Gregor 45550996ce1SRichard Smith auto IsUnavailable = [&](const Module *M) { 45650996ce1SRichard Smith return !M->isAvailable() && (!RequestingModule || 45750996ce1SRichard Smith M->isSubModuleOf(RequestingModule)); 45850996ce1SRichard Smith }; 45950996ce1SRichard Smith 4601fb5c3a6SDouglas Gregor // Keep walking up the directory hierarchy, looking for a directory with 4611fb5c3a6SDouglas Gregor // an umbrella header. 4621fb5c3a6SDouglas Gregor do { 463e4412640SArgyrios Kyrtzidis llvm::DenseMap<const DirectoryEntry *, Module *>::const_iterator KnownDir 4641fb5c3a6SDouglas Gregor = UmbrellaDirs.find(Dir); 4651fb5c3a6SDouglas Gregor if (KnownDir != UmbrellaDirs.end()) { 4661fb5c3a6SDouglas Gregor Module *Found = KnownDir->second; 46750996ce1SRichard Smith if (IsUnavailable(Found)) 4681fb5c3a6SDouglas Gregor return true; 4691fb5c3a6SDouglas Gregor 4701fb5c3a6SDouglas Gregor // Search up the module stack until we find a module with an umbrella 4711fb5c3a6SDouglas Gregor // directory. 4721fb5c3a6SDouglas Gregor Module *UmbrellaModule = Found; 4731fb5c3a6SDouglas Gregor while (!UmbrellaModule->getUmbrellaDir() && UmbrellaModule->Parent) 4741fb5c3a6SDouglas Gregor UmbrellaModule = UmbrellaModule->Parent; 4751fb5c3a6SDouglas Gregor 4761fb5c3a6SDouglas Gregor if (UmbrellaModule->InferSubmodules) { 4771fb5c3a6SDouglas Gregor for (unsigned I = SkippedDirs.size(); I != 0; --I) { 4781fb5c3a6SDouglas Gregor // Find or create the module that corresponds to this directory name. 479056396aeSDouglas Gregor SmallString<32> NameBuf; 480056396aeSDouglas Gregor StringRef Name = sanitizeFilenameAsIdentifier( 481056396aeSDouglas Gregor llvm::sys::path::stem(SkippedDirs[I-1]->getName()), 482056396aeSDouglas Gregor NameBuf); 4831fb5c3a6SDouglas Gregor Found = lookupModuleQualified(Name, Found); 4841fb5c3a6SDouglas Gregor if (!Found) 4851fb5c3a6SDouglas Gregor return false; 48650996ce1SRichard Smith if (IsUnavailable(Found)) 4871fb5c3a6SDouglas Gregor return true; 4881fb5c3a6SDouglas Gregor } 4891fb5c3a6SDouglas Gregor 4901fb5c3a6SDouglas Gregor // Infer a submodule with the same name as this header file. 491056396aeSDouglas Gregor SmallString<32> NameBuf; 492056396aeSDouglas Gregor StringRef Name = sanitizeFilenameAsIdentifier( 493056396aeSDouglas Gregor llvm::sys::path::stem(Header->getName()), 494056396aeSDouglas Gregor NameBuf); 4951fb5c3a6SDouglas Gregor Found = lookupModuleQualified(Name, Found); 4961fb5c3a6SDouglas Gregor if (!Found) 4971fb5c3a6SDouglas Gregor return false; 4981fb5c3a6SDouglas Gregor } 4991fb5c3a6SDouglas Gregor 50050996ce1SRichard Smith return IsUnavailable(Found); 5011fb5c3a6SDouglas Gregor } 5021fb5c3a6SDouglas Gregor 5031fb5c3a6SDouglas Gregor SkippedDirs.push_back(Dir); 5041fb5c3a6SDouglas Gregor 5051fb5c3a6SDouglas Gregor // Retrieve our parent path. 5061fb5c3a6SDouglas Gregor DirName = llvm::sys::path::parent_path(DirName); 5071fb5c3a6SDouglas Gregor if (DirName.empty()) 5081fb5c3a6SDouglas Gregor break; 5091fb5c3a6SDouglas Gregor 5101fb5c3a6SDouglas Gregor // Resolve the parent path to a directory entry. 5111f76c4e8SManuel Klimek Dir = SourceMgr.getFileManager().getDirectory(DirName); 5121fb5c3a6SDouglas Gregor } while (Dir); 5131fb5c3a6SDouglas Gregor 5141fb5c3a6SDouglas Gregor return false; 5151fb5c3a6SDouglas Gregor } 5161fb5c3a6SDouglas Gregor 517e4412640SArgyrios Kyrtzidis Module *ModuleMap::findModule(StringRef Name) const { 518e4412640SArgyrios Kyrtzidis llvm::StringMap<Module *>::const_iterator Known = Modules.find(Name); 51988bdfb0eSDouglas Gregor if (Known != Modules.end()) 52088bdfb0eSDouglas Gregor return Known->getValue(); 52188bdfb0eSDouglas Gregor 522d2d442caSCraig Topper return nullptr; 52388bdfb0eSDouglas Gregor } 52488bdfb0eSDouglas Gregor 525e4412640SArgyrios Kyrtzidis Module *ModuleMap::lookupModuleUnqualified(StringRef Name, 526e4412640SArgyrios Kyrtzidis Module *Context) const { 5272b82c2a5SDouglas Gregor for(; Context; Context = Context->Parent) { 5282b82c2a5SDouglas Gregor if (Module *Sub = lookupModuleQualified(Name, Context)) 5292b82c2a5SDouglas Gregor return Sub; 5302b82c2a5SDouglas Gregor } 5312b82c2a5SDouglas Gregor 5322b82c2a5SDouglas Gregor return findModule(Name); 5332b82c2a5SDouglas Gregor } 5342b82c2a5SDouglas Gregor 535e4412640SArgyrios Kyrtzidis Module *ModuleMap::lookupModuleQualified(StringRef Name, Module *Context) const{ 5362b82c2a5SDouglas Gregor if (!Context) 5372b82c2a5SDouglas Gregor return findModule(Name); 5382b82c2a5SDouglas Gregor 539eb90e830SDouglas Gregor return Context->findSubmodule(Name); 5402b82c2a5SDouglas Gregor } 5412b82c2a5SDouglas Gregor 542de3ef502SDouglas Gregor std::pair<Module *, bool> 543*9d6448b1SBen Langmuir ModuleMap::findOrCreateModule(StringRef Name, Module *Parent, bool IsFramework, 54469021974SDouglas Gregor bool IsExplicit) { 54569021974SDouglas Gregor // Try to find an existing module with this name. 546eb90e830SDouglas Gregor if (Module *Sub = lookupModuleQualified(Name, Parent)) 547eb90e830SDouglas Gregor return std::make_pair(Sub, false); 54869021974SDouglas Gregor 54969021974SDouglas Gregor // Create a new module with this name. 550*9d6448b1SBen Langmuir Module *Result = new Module(Name, SourceLocation(), Parent, 551beee15e7SBen Langmuir IsFramework, IsExplicit); 552ba7f2f71SDaniel Jasper if (LangOpts.CurrentModule == Name) { 553ba7f2f71SDaniel Jasper SourceModule = Result; 554ba7f2f71SDaniel Jasper SourceModuleName = Name; 555ba7f2f71SDaniel Jasper } 5566f722b4eSArgyrios Kyrtzidis if (!Parent) { 55769021974SDouglas Gregor Modules[Name] = Result; 5586f722b4eSArgyrios Kyrtzidis if (!LangOpts.CurrentModule.empty() && !CompilingModule && 5596f722b4eSArgyrios Kyrtzidis Name == LangOpts.CurrentModule) { 5606f722b4eSArgyrios Kyrtzidis CompilingModule = Result; 5616f722b4eSArgyrios Kyrtzidis } 5626f722b4eSArgyrios Kyrtzidis } 56369021974SDouglas Gregor return std::make_pair(Result, true); 56469021974SDouglas Gregor } 56569021974SDouglas Gregor 5669194a91dSDouglas Gregor bool ModuleMap::canInferFrameworkModule(const DirectoryEntry *ParentDir, 567e4412640SArgyrios Kyrtzidis StringRef Name, bool &IsSystem) const { 5689194a91dSDouglas Gregor // Check whether we have already looked into the parent directory 5699194a91dSDouglas Gregor // for a module map. 570e4412640SArgyrios Kyrtzidis llvm::DenseMap<const DirectoryEntry *, InferredDirectory>::const_iterator 5719194a91dSDouglas Gregor inferred = InferredDirectories.find(ParentDir); 5729194a91dSDouglas Gregor if (inferred == InferredDirectories.end()) 5739194a91dSDouglas Gregor return false; 5749194a91dSDouglas Gregor 5759194a91dSDouglas Gregor if (!inferred->second.InferModules) 5769194a91dSDouglas Gregor return false; 5779194a91dSDouglas Gregor 5789194a91dSDouglas Gregor // We're allowed to infer for this directory, but make sure it's okay 5799194a91dSDouglas Gregor // to infer this particular module. 5809194a91dSDouglas Gregor bool canInfer = std::find(inferred->second.ExcludedModules.begin(), 5819194a91dSDouglas Gregor inferred->second.ExcludedModules.end(), 5829194a91dSDouglas Gregor Name) == inferred->second.ExcludedModules.end(); 5839194a91dSDouglas Gregor 5849194a91dSDouglas Gregor if (canInfer && inferred->second.InferSystemModules) 5859194a91dSDouglas Gregor IsSystem = true; 5869194a91dSDouglas Gregor 5879194a91dSDouglas Gregor return canInfer; 5889194a91dSDouglas Gregor } 5899194a91dSDouglas Gregor 59011dfe6feSDouglas Gregor /// \brief For a framework module, infer the framework against which we 59111dfe6feSDouglas Gregor /// should link. 59211dfe6feSDouglas Gregor static void inferFrameworkLink(Module *Mod, const DirectoryEntry *FrameworkDir, 59311dfe6feSDouglas Gregor FileManager &FileMgr) { 59411dfe6feSDouglas Gregor assert(Mod->IsFramework && "Can only infer linking for framework modules"); 59511dfe6feSDouglas Gregor assert(!Mod->isSubFramework() && 59611dfe6feSDouglas Gregor "Can only infer linking for top-level frameworks"); 59711dfe6feSDouglas Gregor 59811dfe6feSDouglas Gregor SmallString<128> LibName; 59911dfe6feSDouglas Gregor LibName += FrameworkDir->getName(); 60011dfe6feSDouglas Gregor llvm::sys::path::append(LibName, Mod->Name); 60111dfe6feSDouglas Gregor if (FileMgr.getFile(LibName)) { 60211dfe6feSDouglas Gregor Mod->LinkLibraries.push_back(Module::LinkLibrary(Mod->Name, 60311dfe6feSDouglas Gregor /*IsFramework=*/true)); 60411dfe6feSDouglas Gregor } 60511dfe6feSDouglas Gregor } 60611dfe6feSDouglas Gregor 607de3ef502SDouglas Gregor Module * 60856c64013SDouglas Gregor ModuleMap::inferFrameworkModule(StringRef ModuleName, 609e89dbc1dSDouglas Gregor const DirectoryEntry *FrameworkDir, 610a686e1b0SDouglas Gregor bool IsSystem, 611e89dbc1dSDouglas Gregor Module *Parent) { 61256c64013SDouglas Gregor // Check whether we've already found this module. 613e89dbc1dSDouglas Gregor if (Module *Mod = lookupModuleQualified(ModuleName, Parent)) 614e89dbc1dSDouglas Gregor return Mod; 615e89dbc1dSDouglas Gregor 6161f76c4e8SManuel Klimek FileManager &FileMgr = SourceMgr.getFileManager(); 61756c64013SDouglas Gregor 6189194a91dSDouglas Gregor // If the framework has a parent path from which we're allowed to infer 6199194a91dSDouglas Gregor // a framework module, do so. 620beee15e7SBen Langmuir const FileEntry *ModuleMapFile = nullptr; 6219194a91dSDouglas Gregor if (!Parent) { 6224ddf2221SDouglas Gregor // Determine whether we're allowed to infer a module map. 623e00c8b20SDouglas Gregor 6244ddf2221SDouglas Gregor // Note: as an egregious but useful hack we use the real path here, because 6254ddf2221SDouglas Gregor // we might be looking at an embedded framework that symlinks out to a 6264ddf2221SDouglas Gregor // top-level framework, and we need to infer as if we were naming the 6274ddf2221SDouglas Gregor // top-level framework. 628e00c8b20SDouglas Gregor StringRef FrameworkDirName 6291f76c4e8SManuel Klimek = SourceMgr.getFileManager().getCanonicalName(FrameworkDir); 6304ddf2221SDouglas Gregor 6316b7f7345SBen Langmuir // In case this is a case-insensitive filesystem, make sure the canonical 6326b7f7345SBen Langmuir // directory name matches ModuleName exactly. Modules are case-sensitive. 6336b7f7345SBen Langmuir // FIXME: we should be able to give a fix-it hint for the correct spelling. 6346b7f7345SBen Langmuir if (llvm::sys::path::stem(FrameworkDirName) != ModuleName) 6356b7f7345SBen Langmuir return nullptr; 6366b7f7345SBen Langmuir 6379194a91dSDouglas Gregor bool canInfer = false; 6384ddf2221SDouglas Gregor if (llvm::sys::path::has_parent_path(FrameworkDirName)) { 6399194a91dSDouglas Gregor // Figure out the parent path. 6404ddf2221SDouglas Gregor StringRef Parent = llvm::sys::path::parent_path(FrameworkDirName); 6419194a91dSDouglas Gregor if (const DirectoryEntry *ParentDir = FileMgr.getDirectory(Parent)) { 6429194a91dSDouglas Gregor // Check whether we have already looked into the parent directory 6439194a91dSDouglas Gregor // for a module map. 644e4412640SArgyrios Kyrtzidis llvm::DenseMap<const DirectoryEntry *, InferredDirectory>::const_iterator 6459194a91dSDouglas Gregor inferred = InferredDirectories.find(ParentDir); 6469194a91dSDouglas Gregor if (inferred == InferredDirectories.end()) { 6479194a91dSDouglas Gregor // We haven't looked here before. Load a module map, if there is 6489194a91dSDouglas Gregor // one. 649984e1df7SBen Langmuir bool IsFrameworkDir = Parent.endswith(".framework"); 650984e1df7SBen Langmuir if (const FileEntry *ModMapFile = 651984e1df7SBen Langmuir HeaderInfo.lookupModuleMapFile(ParentDir, IsFrameworkDir)) { 652963c5535SDouglas Gregor parseModuleMapFile(ModMapFile, IsSystem); 6539194a91dSDouglas Gregor inferred = InferredDirectories.find(ParentDir); 6549194a91dSDouglas Gregor } 6559194a91dSDouglas Gregor 6569194a91dSDouglas Gregor if (inferred == InferredDirectories.end()) 6579194a91dSDouglas Gregor inferred = InferredDirectories.insert( 6589194a91dSDouglas Gregor std::make_pair(ParentDir, InferredDirectory())).first; 6599194a91dSDouglas Gregor } 6609194a91dSDouglas Gregor 6619194a91dSDouglas Gregor if (inferred->second.InferModules) { 6629194a91dSDouglas Gregor // We're allowed to infer for this directory, but make sure it's okay 6639194a91dSDouglas Gregor // to infer this particular module. 6644ddf2221SDouglas Gregor StringRef Name = llvm::sys::path::stem(FrameworkDirName); 6659194a91dSDouglas Gregor canInfer = std::find(inferred->second.ExcludedModules.begin(), 6669194a91dSDouglas Gregor inferred->second.ExcludedModules.end(), 6679194a91dSDouglas Gregor Name) == inferred->second.ExcludedModules.end(); 6689194a91dSDouglas Gregor 6699194a91dSDouglas Gregor if (inferred->second.InferSystemModules) 6709194a91dSDouglas Gregor IsSystem = true; 671beee15e7SBen Langmuir ModuleMapFile = inferred->second.ModuleMapFile; 6729194a91dSDouglas Gregor } 6739194a91dSDouglas Gregor } 6749194a91dSDouglas Gregor } 6759194a91dSDouglas Gregor 6769194a91dSDouglas Gregor // If we're not allowed to infer a framework module, don't. 6779194a91dSDouglas Gregor if (!canInfer) 678d2d442caSCraig Topper return nullptr; 679beee15e7SBen Langmuir } else 680*9d6448b1SBen Langmuir ModuleMapFile = getModuleMapFileForUniquing(Parent); 6819194a91dSDouglas Gregor 6829194a91dSDouglas Gregor 68356c64013SDouglas Gregor // Look for an umbrella header. 6842c1dd271SDylan Noblesmith SmallString<128> UmbrellaName = StringRef(FrameworkDir->getName()); 68517381a06SBenjamin Kramer llvm::sys::path::append(UmbrellaName, "Headers", ModuleName + ".h"); 686e89dbc1dSDouglas Gregor const FileEntry *UmbrellaHeader = FileMgr.getFile(UmbrellaName); 68756c64013SDouglas Gregor 68856c64013SDouglas Gregor // FIXME: If there's no umbrella header, we could probably scan the 68956c64013SDouglas Gregor // framework to load *everything*. But, it's not clear that this is a good 69056c64013SDouglas Gregor // idea. 69156c64013SDouglas Gregor if (!UmbrellaHeader) 692d2d442caSCraig Topper return nullptr; 69356c64013SDouglas Gregor 694*9d6448b1SBen Langmuir Module *Result = new Module(ModuleName, SourceLocation(), Parent, 695e89dbc1dSDouglas Gregor /*IsFramework=*/true, /*IsExplicit=*/false); 696*9d6448b1SBen Langmuir InferredModuleAllowedBy[Result] = ModuleMapFile; 697*9d6448b1SBen Langmuir Result->IsInferred = true; 698ba7f2f71SDaniel Jasper if (LangOpts.CurrentModule == ModuleName) { 699ba7f2f71SDaniel Jasper SourceModule = Result; 700ba7f2f71SDaniel Jasper SourceModuleName = ModuleName; 701ba7f2f71SDaniel Jasper } 702a686e1b0SDouglas Gregor if (IsSystem) 703a686e1b0SDouglas Gregor Result->IsSystem = IsSystem; 704a686e1b0SDouglas Gregor 705eb90e830SDouglas Gregor if (!Parent) 706e89dbc1dSDouglas Gregor Modules[ModuleName] = Result; 707e89dbc1dSDouglas Gregor 708322f633cSDouglas Gregor // umbrella header "umbrella-header-name" 70973141fa9SDouglas Gregor Result->Umbrella = UmbrellaHeader; 71097da9178SDaniel Jasper Headers[UmbrellaHeader].push_back(KnownHeader(Result, NormalHeader)); 7114dc71835SDouglas Gregor UmbrellaDirs[UmbrellaHeader->getDir()] = Result; 712d8bd7537SDouglas Gregor 713d8bd7537SDouglas Gregor // export * 714d2d442caSCraig Topper Result->Exports.push_back(Module::ExportDecl(nullptr, true)); 715d8bd7537SDouglas Gregor 716a89c5ac4SDouglas Gregor // module * { export * } 717a89c5ac4SDouglas Gregor Result->InferSubmodules = true; 718a89c5ac4SDouglas Gregor Result->InferExportWildcard = true; 719a89c5ac4SDouglas Gregor 720e89dbc1dSDouglas Gregor // Look for subframeworks. 721c080917eSRafael Espindola std::error_code EC; 7222c1dd271SDylan Noblesmith SmallString<128> SubframeworksDirName 723ddaa69cbSDouglas Gregor = StringRef(FrameworkDir->getName()); 724e89dbc1dSDouglas Gregor llvm::sys::path::append(SubframeworksDirName, "Frameworks"); 7252d4d8cb3SBenjamin Kramer llvm::sys::path::native(SubframeworksDirName); 726ddaa69cbSDouglas Gregor for (llvm::sys::fs::directory_iterator 7272d4d8cb3SBenjamin Kramer Dir(SubframeworksDirName.str(), EC), DirEnd; 728e89dbc1dSDouglas Gregor Dir != DirEnd && !EC; Dir.increment(EC)) { 729e89dbc1dSDouglas Gregor if (!StringRef(Dir->path()).endswith(".framework")) 730e89dbc1dSDouglas Gregor continue; 731f2161a70SDouglas Gregor 732e89dbc1dSDouglas Gregor if (const DirectoryEntry *SubframeworkDir 733e89dbc1dSDouglas Gregor = FileMgr.getDirectory(Dir->path())) { 73407c22b78SDouglas Gregor // Note: as an egregious but useful hack, we use the real path here and 73507c22b78SDouglas Gregor // check whether it is actually a subdirectory of the parent directory. 73607c22b78SDouglas Gregor // This will not be the case if the 'subframework' is actually a symlink 73707c22b78SDouglas Gregor // out to a top-level framework. 738e00c8b20SDouglas Gregor StringRef SubframeworkDirName = FileMgr.getCanonicalName(SubframeworkDir); 73907c22b78SDouglas Gregor bool FoundParent = false; 74007c22b78SDouglas Gregor do { 74107c22b78SDouglas Gregor // Get the parent directory name. 74207c22b78SDouglas Gregor SubframeworkDirName 74307c22b78SDouglas Gregor = llvm::sys::path::parent_path(SubframeworkDirName); 74407c22b78SDouglas Gregor if (SubframeworkDirName.empty()) 74507c22b78SDouglas Gregor break; 74607c22b78SDouglas Gregor 74707c22b78SDouglas Gregor if (FileMgr.getDirectory(SubframeworkDirName) == FrameworkDir) { 74807c22b78SDouglas Gregor FoundParent = true; 74907c22b78SDouglas Gregor break; 75007c22b78SDouglas Gregor } 75107c22b78SDouglas Gregor } while (true); 75207c22b78SDouglas Gregor 75307c22b78SDouglas Gregor if (!FoundParent) 75407c22b78SDouglas Gregor continue; 75507c22b78SDouglas Gregor 756e89dbc1dSDouglas Gregor // FIXME: Do we want to warn about subframeworks without umbrella headers? 757056396aeSDouglas Gregor SmallString<32> NameBuf; 758056396aeSDouglas Gregor inferFrameworkModule(sanitizeFilenameAsIdentifier( 759056396aeSDouglas Gregor llvm::sys::path::stem(Dir->path()), NameBuf), 760056396aeSDouglas Gregor SubframeworkDir, IsSystem, Result); 761e89dbc1dSDouglas Gregor } 762e89dbc1dSDouglas Gregor } 763e89dbc1dSDouglas Gregor 76411dfe6feSDouglas Gregor // If the module is a top-level framework, automatically link against the 76511dfe6feSDouglas Gregor // framework. 76611dfe6feSDouglas Gregor if (!Result->isSubFramework()) { 76711dfe6feSDouglas Gregor inferFrameworkLink(Result, FrameworkDir, FileMgr); 76811dfe6feSDouglas Gregor } 76911dfe6feSDouglas Gregor 77056c64013SDouglas Gregor return Result; 77156c64013SDouglas Gregor } 77256c64013SDouglas Gregor 773a89c5ac4SDouglas Gregor void ModuleMap::setUmbrellaHeader(Module *Mod, const FileEntry *UmbrellaHeader){ 77497da9178SDaniel Jasper Headers[UmbrellaHeader].push_back(KnownHeader(Mod, NormalHeader)); 77573141fa9SDouglas Gregor Mod->Umbrella = UmbrellaHeader; 7767033127bSDouglas Gregor UmbrellaDirs[UmbrellaHeader->getDir()] = Mod; 777a89c5ac4SDouglas Gregor } 778a89c5ac4SDouglas Gregor 779524e33e1SDouglas Gregor void ModuleMap::setUmbrellaDir(Module *Mod, const DirectoryEntry *UmbrellaDir) { 780524e33e1SDouglas Gregor Mod->Umbrella = UmbrellaDir; 781524e33e1SDouglas Gregor UmbrellaDirs[UmbrellaDir] = Mod; 782524e33e1SDouglas Gregor } 783524e33e1SDouglas Gregor 78459527666SDouglas Gregor void ModuleMap::addHeader(Module *Mod, const FileEntry *Header, 785b53e5483SLawrence Crowl ModuleHeaderRole Role) { 786b53e5483SLawrence Crowl if (Role == ExcludedHeader) { 78759527666SDouglas Gregor Mod->ExcludedHeaders.push_back(Header); 788b146baabSArgyrios Kyrtzidis } else { 789b53e5483SLawrence Crowl if (Role == PrivateHeader) 790b53e5483SLawrence Crowl Mod->PrivateHeaders.push_back(Header); 791b53e5483SLawrence Crowl else 792b53e5483SLawrence Crowl Mod->NormalHeaders.push_back(Header); 7936f722b4eSArgyrios Kyrtzidis bool isCompilingModuleHeader = Mod->getTopLevelModule() == CompilingModule; 794b53e5483SLawrence Crowl HeaderInfo.MarkFileModuleHeader(Header, Role, isCompilingModuleHeader); 795b146baabSArgyrios Kyrtzidis } 79697da9178SDaniel Jasper Headers[Header].push_back(KnownHeader(Mod, Role)); 797a89c5ac4SDouglas Gregor } 798a89c5ac4SDouglas Gregor 799514b636aSDouglas Gregor const FileEntry * 800e4412640SArgyrios Kyrtzidis ModuleMap::getContainingModuleMapFile(Module *Module) const { 8011f76c4e8SManuel Klimek if (Module->DefinitionLoc.isInvalid()) 802d2d442caSCraig Topper return nullptr; 803514b636aSDouglas Gregor 8041f76c4e8SManuel Klimek return SourceMgr.getFileEntryForID( 8051f76c4e8SManuel Klimek SourceMgr.getFileID(Module->DefinitionLoc)); 806514b636aSDouglas Gregor } 807514b636aSDouglas Gregor 808*9d6448b1SBen Langmuir const FileEntry *ModuleMap::getModuleMapFileForUniquing(Module *M) const { 809*9d6448b1SBen Langmuir if (M->IsInferred) { 810*9d6448b1SBen Langmuir assert(InferredModuleAllowedBy.count(M) && "missing inferred module map"); 811*9d6448b1SBen Langmuir return InferredModuleAllowedBy.find(M)->second; 812*9d6448b1SBen Langmuir } 813*9d6448b1SBen Langmuir return getContainingModuleMapFile(M); 814*9d6448b1SBen Langmuir } 815*9d6448b1SBen Langmuir 816*9d6448b1SBen Langmuir void ModuleMap::setInferredModuleAllowedBy(Module *M, const FileEntry *ModMap) { 817*9d6448b1SBen Langmuir assert(M->IsInferred && "module not inferred"); 818*9d6448b1SBen Langmuir InferredModuleAllowedBy[M] = ModMap; 819*9d6448b1SBen Langmuir } 820*9d6448b1SBen Langmuir 821718292f2SDouglas Gregor void ModuleMap::dump() { 822718292f2SDouglas Gregor llvm::errs() << "Modules:"; 823718292f2SDouglas Gregor for (llvm::StringMap<Module *>::iterator M = Modules.begin(), 824718292f2SDouglas Gregor MEnd = Modules.end(); 825718292f2SDouglas Gregor M != MEnd; ++M) 826d28d1b8dSDouglas Gregor M->getValue()->print(llvm::errs(), 2); 827718292f2SDouglas Gregor 828718292f2SDouglas Gregor llvm::errs() << "Headers:"; 82959527666SDouglas Gregor for (HeadersMap::iterator H = Headers.begin(), HEnd = Headers.end(); 830718292f2SDouglas Gregor H != HEnd; ++H) { 83197da9178SDaniel Jasper llvm::errs() << " \"" << H->first->getName() << "\" -> "; 83297da9178SDaniel Jasper for (SmallVectorImpl<KnownHeader>::const_iterator I = H->second.begin(), 83397da9178SDaniel Jasper E = H->second.end(); 83497da9178SDaniel Jasper I != E; ++I) { 83597da9178SDaniel Jasper if (I != H->second.begin()) 83697da9178SDaniel Jasper llvm::errs() << ","; 83797da9178SDaniel Jasper llvm::errs() << I->getModule()->getFullModuleName(); 83897da9178SDaniel Jasper } 83997da9178SDaniel Jasper llvm::errs() << "\n"; 840718292f2SDouglas Gregor } 841718292f2SDouglas Gregor } 842718292f2SDouglas Gregor 8432b82c2a5SDouglas Gregor bool ModuleMap::resolveExports(Module *Mod, bool Complain) { 8442b82c2a5SDouglas Gregor bool HadError = false; 8452b82c2a5SDouglas Gregor for (unsigned I = 0, N = Mod->UnresolvedExports.size(); I != N; ++I) { 8462b82c2a5SDouglas Gregor Module::ExportDecl Export = resolveExport(Mod, Mod->UnresolvedExports[I], 8472b82c2a5SDouglas Gregor Complain); 848f5eedd05SDouglas Gregor if (Export.getPointer() || Export.getInt()) 8492b82c2a5SDouglas Gregor Mod->Exports.push_back(Export); 8502b82c2a5SDouglas Gregor else 8512b82c2a5SDouglas Gregor HadError = true; 8522b82c2a5SDouglas Gregor } 8532b82c2a5SDouglas Gregor Mod->UnresolvedExports.clear(); 8542b82c2a5SDouglas Gregor return HadError; 8552b82c2a5SDouglas Gregor } 8562b82c2a5SDouglas Gregor 857ba7f2f71SDaniel Jasper bool ModuleMap::resolveUses(Module *Mod, bool Complain) { 858ba7f2f71SDaniel Jasper bool HadError = false; 859ba7f2f71SDaniel Jasper for (unsigned I = 0, N = Mod->UnresolvedDirectUses.size(); I != N; ++I) { 860ba7f2f71SDaniel Jasper Module *DirectUse = 861ba7f2f71SDaniel Jasper resolveModuleId(Mod->UnresolvedDirectUses[I], Mod, Complain); 862ba7f2f71SDaniel Jasper if (DirectUse) 863ba7f2f71SDaniel Jasper Mod->DirectUses.push_back(DirectUse); 864ba7f2f71SDaniel Jasper else 865ba7f2f71SDaniel Jasper HadError = true; 866ba7f2f71SDaniel Jasper } 867ba7f2f71SDaniel Jasper Mod->UnresolvedDirectUses.clear(); 868ba7f2f71SDaniel Jasper return HadError; 869ba7f2f71SDaniel Jasper } 870ba7f2f71SDaniel Jasper 871fb912657SDouglas Gregor bool ModuleMap::resolveConflicts(Module *Mod, bool Complain) { 872fb912657SDouglas Gregor bool HadError = false; 873fb912657SDouglas Gregor for (unsigned I = 0, N = Mod->UnresolvedConflicts.size(); I != N; ++I) { 874fb912657SDouglas Gregor Module *OtherMod = resolveModuleId(Mod->UnresolvedConflicts[I].Id, 875fb912657SDouglas Gregor Mod, Complain); 876fb912657SDouglas Gregor if (!OtherMod) { 877fb912657SDouglas Gregor HadError = true; 878fb912657SDouglas Gregor continue; 879fb912657SDouglas Gregor } 880fb912657SDouglas Gregor 881fb912657SDouglas Gregor Module::Conflict Conflict; 882fb912657SDouglas Gregor Conflict.Other = OtherMod; 883fb912657SDouglas Gregor Conflict.Message = Mod->UnresolvedConflicts[I].Message; 884fb912657SDouglas Gregor Mod->Conflicts.push_back(Conflict); 885fb912657SDouglas Gregor } 886fb912657SDouglas Gregor Mod->UnresolvedConflicts.clear(); 887fb912657SDouglas Gregor return HadError; 888fb912657SDouglas Gregor } 889fb912657SDouglas Gregor 8900093b3c7SDouglas Gregor Module *ModuleMap::inferModuleFromLocation(FullSourceLoc Loc) { 8910093b3c7SDouglas Gregor if (Loc.isInvalid()) 892d2d442caSCraig Topper return nullptr; 8930093b3c7SDouglas Gregor 8940093b3c7SDouglas Gregor // Use the expansion location to determine which module we're in. 8950093b3c7SDouglas Gregor FullSourceLoc ExpansionLoc = Loc.getExpansionLoc(); 8960093b3c7SDouglas Gregor if (!ExpansionLoc.isFileID()) 897d2d442caSCraig Topper return nullptr; 8980093b3c7SDouglas Gregor 8990093b3c7SDouglas Gregor const SourceManager &SrcMgr = Loc.getManager(); 9000093b3c7SDouglas Gregor FileID ExpansionFileID = ExpansionLoc.getFileID(); 901224d8a74SDouglas Gregor 902224d8a74SDouglas Gregor while (const FileEntry *ExpansionFile 903224d8a74SDouglas Gregor = SrcMgr.getFileEntryForID(ExpansionFileID)) { 904224d8a74SDouglas Gregor // Find the module that owns this header (if any). 905b53e5483SLawrence Crowl if (Module *Mod = findModuleForHeader(ExpansionFile).getModule()) 906224d8a74SDouglas Gregor return Mod; 907224d8a74SDouglas Gregor 908224d8a74SDouglas Gregor // No module owns this header, so look up the inclusion chain to see if 909224d8a74SDouglas Gregor // any included header has an associated module. 910224d8a74SDouglas Gregor SourceLocation IncludeLoc = SrcMgr.getIncludeLoc(ExpansionFileID); 911224d8a74SDouglas Gregor if (IncludeLoc.isInvalid()) 912d2d442caSCraig Topper return nullptr; 9130093b3c7SDouglas Gregor 914224d8a74SDouglas Gregor ExpansionFileID = SrcMgr.getFileID(IncludeLoc); 915224d8a74SDouglas Gregor } 916224d8a74SDouglas Gregor 917d2d442caSCraig Topper return nullptr; 9180093b3c7SDouglas Gregor } 9190093b3c7SDouglas Gregor 920718292f2SDouglas Gregor //----------------------------------------------------------------------------// 921718292f2SDouglas Gregor // Module map file parser 922718292f2SDouglas Gregor //----------------------------------------------------------------------------// 923718292f2SDouglas Gregor 924718292f2SDouglas Gregor namespace clang { 925718292f2SDouglas Gregor /// \brief A token in a module map file. 926718292f2SDouglas Gregor struct MMToken { 927718292f2SDouglas Gregor enum TokenKind { 9281fb5c3a6SDouglas Gregor Comma, 92935b13eceSDouglas Gregor ConfigMacros, 930fb912657SDouglas Gregor Conflict, 931718292f2SDouglas Gregor EndOfFile, 932718292f2SDouglas Gregor HeaderKeyword, 933718292f2SDouglas Gregor Identifier, 934a3feee2aSRichard Smith Exclaim, 93559527666SDouglas Gregor ExcludeKeyword, 936718292f2SDouglas Gregor ExplicitKeyword, 9372b82c2a5SDouglas Gregor ExportKeyword, 93897292843SDaniel Jasper ExternKeyword, 939755b2055SDouglas Gregor FrameworkKeyword, 9406ddfca91SDouglas Gregor LinkKeyword, 941718292f2SDouglas Gregor ModuleKeyword, 9422b82c2a5SDouglas Gregor Period, 943b53e5483SLawrence Crowl PrivateKeyword, 944718292f2SDouglas Gregor UmbrellaKeyword, 945ba7f2f71SDaniel Jasper UseKeyword, 9461fb5c3a6SDouglas Gregor RequiresKeyword, 9472b82c2a5SDouglas Gregor Star, 948718292f2SDouglas Gregor StringLiteral, 949718292f2SDouglas Gregor LBrace, 950a686e1b0SDouglas Gregor RBrace, 951a686e1b0SDouglas Gregor LSquare, 952a686e1b0SDouglas Gregor RSquare 953718292f2SDouglas Gregor } Kind; 954718292f2SDouglas Gregor 955718292f2SDouglas Gregor unsigned Location; 956718292f2SDouglas Gregor unsigned StringLength; 957718292f2SDouglas Gregor const char *StringData; 958718292f2SDouglas Gregor 959718292f2SDouglas Gregor void clear() { 960718292f2SDouglas Gregor Kind = EndOfFile; 961718292f2SDouglas Gregor Location = 0; 962718292f2SDouglas Gregor StringLength = 0; 963d2d442caSCraig Topper StringData = nullptr; 964718292f2SDouglas Gregor } 965718292f2SDouglas Gregor 966718292f2SDouglas Gregor bool is(TokenKind K) const { return Kind == K; } 967718292f2SDouglas Gregor 968718292f2SDouglas Gregor SourceLocation getLocation() const { 969718292f2SDouglas Gregor return SourceLocation::getFromRawEncoding(Location); 970718292f2SDouglas Gregor } 971718292f2SDouglas Gregor 972718292f2SDouglas Gregor StringRef getString() const { 973718292f2SDouglas Gregor return StringRef(StringData, StringLength); 974718292f2SDouglas Gregor } 975718292f2SDouglas Gregor }; 976718292f2SDouglas Gregor 9779194a91dSDouglas Gregor /// \brief The set of attributes that can be attached to a module. 9784442605fSBill Wendling struct Attributes { 97977944868SRichard Smith Attributes() : IsSystem(), IsExternC(), IsExhaustive() { } 9809194a91dSDouglas Gregor 9819194a91dSDouglas Gregor /// \brief Whether this is a system module. 9829194a91dSDouglas Gregor unsigned IsSystem : 1; 98335b13eceSDouglas Gregor 98477944868SRichard Smith /// \brief Whether this is an extern "C" module. 98577944868SRichard Smith unsigned IsExternC : 1; 98677944868SRichard Smith 98735b13eceSDouglas Gregor /// \brief Whether this is an exhaustive set of configuration macros. 98835b13eceSDouglas Gregor unsigned IsExhaustive : 1; 9899194a91dSDouglas Gregor }; 9909194a91dSDouglas Gregor 9919194a91dSDouglas Gregor 992718292f2SDouglas Gregor class ModuleMapParser { 993718292f2SDouglas Gregor Lexer &L; 994718292f2SDouglas Gregor SourceManager &SourceMgr; 995bc10b9fbSDouglas Gregor 996bc10b9fbSDouglas Gregor /// \brief Default target information, used only for string literal 997bc10b9fbSDouglas Gregor /// parsing. 998bc10b9fbSDouglas Gregor const TargetInfo *Target; 999bc10b9fbSDouglas Gregor 1000718292f2SDouglas Gregor DiagnosticsEngine &Diags; 1001718292f2SDouglas Gregor ModuleMap ⤅ 1002718292f2SDouglas Gregor 1003beee15e7SBen Langmuir /// \brief The current module map file. 1004beee15e7SBen Langmuir const FileEntry *ModuleMapFile; 1005beee15e7SBen Langmuir 10065257fc63SDouglas Gregor /// \brief The directory that this module map resides in. 10075257fc63SDouglas Gregor const DirectoryEntry *Directory; 10085257fc63SDouglas Gregor 10093ec6663bSDouglas Gregor /// \brief The directory containing Clang-supplied headers. 10103ec6663bSDouglas Gregor const DirectoryEntry *BuiltinIncludeDir; 10113ec6663bSDouglas Gregor 1012963c5535SDouglas Gregor /// \brief Whether this module map is in a system header directory. 1013963c5535SDouglas Gregor bool IsSystem; 1014963c5535SDouglas Gregor 1015718292f2SDouglas Gregor /// \brief Whether an error occurred. 1016718292f2SDouglas Gregor bool HadError; 1017718292f2SDouglas Gregor 1018718292f2SDouglas Gregor /// \brief Stores string data for the various string literals referenced 1019718292f2SDouglas Gregor /// during parsing. 1020718292f2SDouglas Gregor llvm::BumpPtrAllocator StringData; 1021718292f2SDouglas Gregor 1022718292f2SDouglas Gregor /// \brief The current token. 1023718292f2SDouglas Gregor MMToken Tok; 1024718292f2SDouglas Gregor 1025718292f2SDouglas Gregor /// \brief The active module. 1026de3ef502SDouglas Gregor Module *ActiveModule; 1027718292f2SDouglas Gregor 1028718292f2SDouglas Gregor /// \brief Consume the current token and return its location. 1029718292f2SDouglas Gregor SourceLocation consumeToken(); 1030718292f2SDouglas Gregor 1031718292f2SDouglas Gregor /// \brief Skip tokens until we reach the a token with the given kind 1032718292f2SDouglas Gregor /// (or the end of the file). 1033718292f2SDouglas Gregor void skipUntil(MMToken::TokenKind K); 1034718292f2SDouglas Gregor 1035f857950dSDmitri Gribenko typedef SmallVector<std::pair<std::string, SourceLocation>, 2> ModuleId; 1036e7ab3669SDouglas Gregor bool parseModuleId(ModuleId &Id); 1037718292f2SDouglas Gregor void parseModuleDecl(); 103897292843SDaniel Jasper void parseExternModuleDecl(); 10391fb5c3a6SDouglas Gregor void parseRequiresDecl(); 1040b53e5483SLawrence Crowl void parseHeaderDecl(clang::MMToken::TokenKind, 1041b53e5483SLawrence Crowl SourceLocation LeadingLoc); 1042524e33e1SDouglas Gregor void parseUmbrellaDirDecl(SourceLocation UmbrellaLoc); 10432b82c2a5SDouglas Gregor void parseExportDecl(); 1044ba7f2f71SDaniel Jasper void parseUseDecl(); 10456ddfca91SDouglas Gregor void parseLinkDecl(); 104635b13eceSDouglas Gregor void parseConfigMacros(); 1047fb912657SDouglas Gregor void parseConflict(); 10489194a91dSDouglas Gregor void parseInferredModuleDecl(bool Framework, bool Explicit); 10494442605fSBill Wendling bool parseOptionalAttributes(Attributes &Attrs); 1050718292f2SDouglas Gregor 1051718292f2SDouglas Gregor public: 1052718292f2SDouglas Gregor explicit ModuleMapParser(Lexer &L, SourceManager &SourceMgr, 1053bc10b9fbSDouglas Gregor const TargetInfo *Target, 1054718292f2SDouglas Gregor DiagnosticsEngine &Diags, 10555257fc63SDouglas Gregor ModuleMap &Map, 1056beee15e7SBen Langmuir const FileEntry *ModuleMapFile, 10573ec6663bSDouglas Gregor const DirectoryEntry *Directory, 1058963c5535SDouglas Gregor const DirectoryEntry *BuiltinIncludeDir, 1059963c5535SDouglas Gregor bool IsSystem) 1060bc10b9fbSDouglas Gregor : L(L), SourceMgr(SourceMgr), Target(Target), Diags(Diags), Map(Map), 1061beee15e7SBen Langmuir ModuleMapFile(ModuleMapFile), Directory(Directory), 1062beee15e7SBen Langmuir BuiltinIncludeDir(BuiltinIncludeDir), IsSystem(IsSystem), 1063d2d442caSCraig Topper HadError(false), ActiveModule(nullptr) 1064718292f2SDouglas Gregor { 1065718292f2SDouglas Gregor Tok.clear(); 1066718292f2SDouglas Gregor consumeToken(); 1067718292f2SDouglas Gregor } 1068718292f2SDouglas Gregor 1069718292f2SDouglas Gregor bool parseModuleMapFile(); 1070718292f2SDouglas Gregor }; 1071718292f2SDouglas Gregor } 1072718292f2SDouglas Gregor 1073718292f2SDouglas Gregor SourceLocation ModuleMapParser::consumeToken() { 1074718292f2SDouglas Gregor retry: 1075718292f2SDouglas Gregor SourceLocation Result = Tok.getLocation(); 1076718292f2SDouglas Gregor Tok.clear(); 1077718292f2SDouglas Gregor 1078718292f2SDouglas Gregor Token LToken; 1079718292f2SDouglas Gregor L.LexFromRawLexer(LToken); 1080718292f2SDouglas Gregor Tok.Location = LToken.getLocation().getRawEncoding(); 1081718292f2SDouglas Gregor switch (LToken.getKind()) { 10822d57cea2SAlp Toker case tok::raw_identifier: { 10832d57cea2SAlp Toker StringRef RI = LToken.getRawIdentifier(); 10842d57cea2SAlp Toker Tok.StringData = RI.data(); 10852d57cea2SAlp Toker Tok.StringLength = RI.size(); 10862d57cea2SAlp Toker Tok.Kind = llvm::StringSwitch<MMToken::TokenKind>(RI) 108735b13eceSDouglas Gregor .Case("config_macros", MMToken::ConfigMacros) 1088fb912657SDouglas Gregor .Case("conflict", MMToken::Conflict) 108959527666SDouglas Gregor .Case("exclude", MMToken::ExcludeKeyword) 1090718292f2SDouglas Gregor .Case("explicit", MMToken::ExplicitKeyword) 10912b82c2a5SDouglas Gregor .Case("export", MMToken::ExportKeyword) 109297292843SDaniel Jasper .Case("extern", MMToken::ExternKeyword) 1093755b2055SDouglas Gregor .Case("framework", MMToken::FrameworkKeyword) 109435b13eceSDouglas Gregor .Case("header", MMToken::HeaderKeyword) 10956ddfca91SDouglas Gregor .Case("link", MMToken::LinkKeyword) 1096718292f2SDouglas Gregor .Case("module", MMToken::ModuleKeyword) 1097b53e5483SLawrence Crowl .Case("private", MMToken::PrivateKeyword) 10981fb5c3a6SDouglas Gregor .Case("requires", MMToken::RequiresKeyword) 1099718292f2SDouglas Gregor .Case("umbrella", MMToken::UmbrellaKeyword) 1100ba7f2f71SDaniel Jasper .Case("use", MMToken::UseKeyword) 1101718292f2SDouglas Gregor .Default(MMToken::Identifier); 1102718292f2SDouglas Gregor break; 11032d57cea2SAlp Toker } 1104718292f2SDouglas Gregor 11051fb5c3a6SDouglas Gregor case tok::comma: 11061fb5c3a6SDouglas Gregor Tok.Kind = MMToken::Comma; 11071fb5c3a6SDouglas Gregor break; 11081fb5c3a6SDouglas Gregor 1109718292f2SDouglas Gregor case tok::eof: 1110718292f2SDouglas Gregor Tok.Kind = MMToken::EndOfFile; 1111718292f2SDouglas Gregor break; 1112718292f2SDouglas Gregor 1113718292f2SDouglas Gregor case tok::l_brace: 1114718292f2SDouglas Gregor Tok.Kind = MMToken::LBrace; 1115718292f2SDouglas Gregor break; 1116718292f2SDouglas Gregor 1117a686e1b0SDouglas Gregor case tok::l_square: 1118a686e1b0SDouglas Gregor Tok.Kind = MMToken::LSquare; 1119a686e1b0SDouglas Gregor break; 1120a686e1b0SDouglas Gregor 11212b82c2a5SDouglas Gregor case tok::period: 11222b82c2a5SDouglas Gregor Tok.Kind = MMToken::Period; 11232b82c2a5SDouglas Gregor break; 11242b82c2a5SDouglas Gregor 1125718292f2SDouglas Gregor case tok::r_brace: 1126718292f2SDouglas Gregor Tok.Kind = MMToken::RBrace; 1127718292f2SDouglas Gregor break; 1128718292f2SDouglas Gregor 1129a686e1b0SDouglas Gregor case tok::r_square: 1130a686e1b0SDouglas Gregor Tok.Kind = MMToken::RSquare; 1131a686e1b0SDouglas Gregor break; 1132a686e1b0SDouglas Gregor 11332b82c2a5SDouglas Gregor case tok::star: 11342b82c2a5SDouglas Gregor Tok.Kind = MMToken::Star; 11352b82c2a5SDouglas Gregor break; 11362b82c2a5SDouglas Gregor 1137a3feee2aSRichard Smith case tok::exclaim: 1138a3feee2aSRichard Smith Tok.Kind = MMToken::Exclaim; 1139a3feee2aSRichard Smith break; 1140a3feee2aSRichard Smith 1141718292f2SDouglas Gregor case tok::string_literal: { 1142d67aea28SRichard Smith if (LToken.hasUDSuffix()) { 1143d67aea28SRichard Smith Diags.Report(LToken.getLocation(), diag::err_invalid_string_udl); 1144d67aea28SRichard Smith HadError = true; 1145d67aea28SRichard Smith goto retry; 1146d67aea28SRichard Smith } 1147d67aea28SRichard Smith 1148718292f2SDouglas Gregor // Parse the string literal. 1149718292f2SDouglas Gregor LangOptions LangOpts; 11509d5583efSCraig Topper StringLiteralParser StringLiteral(LToken, SourceMgr, LangOpts, *Target); 1151718292f2SDouglas Gregor if (StringLiteral.hadError) 1152718292f2SDouglas Gregor goto retry; 1153718292f2SDouglas Gregor 1154718292f2SDouglas Gregor // Copy the string literal into our string data allocator. 1155718292f2SDouglas Gregor unsigned Length = StringLiteral.GetStringLength(); 1156718292f2SDouglas Gregor char *Saved = StringData.Allocate<char>(Length + 1); 1157718292f2SDouglas Gregor memcpy(Saved, StringLiteral.GetString().data(), Length); 1158718292f2SDouglas Gregor Saved[Length] = 0; 1159718292f2SDouglas Gregor 1160718292f2SDouglas Gregor // Form the token. 1161718292f2SDouglas Gregor Tok.Kind = MMToken::StringLiteral; 1162718292f2SDouglas Gregor Tok.StringData = Saved; 1163718292f2SDouglas Gregor Tok.StringLength = Length; 1164718292f2SDouglas Gregor break; 1165718292f2SDouglas Gregor } 1166718292f2SDouglas Gregor 1167718292f2SDouglas Gregor case tok::comment: 1168718292f2SDouglas Gregor goto retry; 1169718292f2SDouglas Gregor 1170718292f2SDouglas Gregor default: 1171718292f2SDouglas Gregor Diags.Report(LToken.getLocation(), diag::err_mmap_unknown_token); 1172718292f2SDouglas Gregor HadError = true; 1173718292f2SDouglas Gregor goto retry; 1174718292f2SDouglas Gregor } 1175718292f2SDouglas Gregor 1176718292f2SDouglas Gregor return Result; 1177718292f2SDouglas Gregor } 1178718292f2SDouglas Gregor 1179718292f2SDouglas Gregor void ModuleMapParser::skipUntil(MMToken::TokenKind K) { 1180718292f2SDouglas Gregor unsigned braceDepth = 0; 1181a686e1b0SDouglas Gregor unsigned squareDepth = 0; 1182718292f2SDouglas Gregor do { 1183718292f2SDouglas Gregor switch (Tok.Kind) { 1184718292f2SDouglas Gregor case MMToken::EndOfFile: 1185718292f2SDouglas Gregor return; 1186718292f2SDouglas Gregor 1187718292f2SDouglas Gregor case MMToken::LBrace: 1188a686e1b0SDouglas Gregor if (Tok.is(K) && braceDepth == 0 && squareDepth == 0) 1189718292f2SDouglas Gregor return; 1190718292f2SDouglas Gregor 1191718292f2SDouglas Gregor ++braceDepth; 1192718292f2SDouglas Gregor break; 1193718292f2SDouglas Gregor 1194a686e1b0SDouglas Gregor case MMToken::LSquare: 1195a686e1b0SDouglas Gregor if (Tok.is(K) && braceDepth == 0 && squareDepth == 0) 1196a686e1b0SDouglas Gregor return; 1197a686e1b0SDouglas Gregor 1198a686e1b0SDouglas Gregor ++squareDepth; 1199a686e1b0SDouglas Gregor break; 1200a686e1b0SDouglas Gregor 1201718292f2SDouglas Gregor case MMToken::RBrace: 1202718292f2SDouglas Gregor if (braceDepth > 0) 1203718292f2SDouglas Gregor --braceDepth; 1204718292f2SDouglas Gregor else if (Tok.is(K)) 1205718292f2SDouglas Gregor return; 1206718292f2SDouglas Gregor break; 1207718292f2SDouglas Gregor 1208a686e1b0SDouglas Gregor case MMToken::RSquare: 1209a686e1b0SDouglas Gregor if (squareDepth > 0) 1210a686e1b0SDouglas Gregor --squareDepth; 1211a686e1b0SDouglas Gregor else if (Tok.is(K)) 1212a686e1b0SDouglas Gregor return; 1213a686e1b0SDouglas Gregor break; 1214a686e1b0SDouglas Gregor 1215718292f2SDouglas Gregor default: 1216a686e1b0SDouglas Gregor if (braceDepth == 0 && squareDepth == 0 && Tok.is(K)) 1217718292f2SDouglas Gregor return; 1218718292f2SDouglas Gregor break; 1219718292f2SDouglas Gregor } 1220718292f2SDouglas Gregor 1221718292f2SDouglas Gregor consumeToken(); 1222718292f2SDouglas Gregor } while (true); 1223718292f2SDouglas Gregor } 1224718292f2SDouglas Gregor 1225e7ab3669SDouglas Gregor /// \brief Parse a module-id. 1226e7ab3669SDouglas Gregor /// 1227e7ab3669SDouglas Gregor /// module-id: 1228e7ab3669SDouglas Gregor /// identifier 1229e7ab3669SDouglas Gregor /// identifier '.' module-id 1230e7ab3669SDouglas Gregor /// 1231e7ab3669SDouglas Gregor /// \returns true if an error occurred, false otherwise. 1232e7ab3669SDouglas Gregor bool ModuleMapParser::parseModuleId(ModuleId &Id) { 1233e7ab3669SDouglas Gregor Id.clear(); 1234e7ab3669SDouglas Gregor do { 12353cd34c76SDaniel Jasper if (Tok.is(MMToken::Identifier) || Tok.is(MMToken::StringLiteral)) { 1236e7ab3669SDouglas Gregor Id.push_back(std::make_pair(Tok.getString(), Tok.getLocation())); 1237e7ab3669SDouglas Gregor consumeToken(); 1238e7ab3669SDouglas Gregor } else { 1239e7ab3669SDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module_name); 1240e7ab3669SDouglas Gregor return true; 1241e7ab3669SDouglas Gregor } 1242e7ab3669SDouglas Gregor 1243e7ab3669SDouglas Gregor if (!Tok.is(MMToken::Period)) 1244e7ab3669SDouglas Gregor break; 1245e7ab3669SDouglas Gregor 1246e7ab3669SDouglas Gregor consumeToken(); 1247e7ab3669SDouglas Gregor } while (true); 1248e7ab3669SDouglas Gregor 1249e7ab3669SDouglas Gregor return false; 1250e7ab3669SDouglas Gregor } 1251e7ab3669SDouglas Gregor 1252a686e1b0SDouglas Gregor namespace { 1253a686e1b0SDouglas Gregor /// \brief Enumerates the known attributes. 1254a686e1b0SDouglas Gregor enum AttributeKind { 1255a686e1b0SDouglas Gregor /// \brief An unknown attribute. 1256a686e1b0SDouglas Gregor AT_unknown, 1257a686e1b0SDouglas Gregor /// \brief The 'system' attribute. 125835b13eceSDouglas Gregor AT_system, 125977944868SRichard Smith /// \brief The 'extern_c' attribute. 126077944868SRichard Smith AT_extern_c, 126135b13eceSDouglas Gregor /// \brief The 'exhaustive' attribute. 126235b13eceSDouglas Gregor AT_exhaustive 1263a686e1b0SDouglas Gregor }; 1264a686e1b0SDouglas Gregor } 1265a686e1b0SDouglas Gregor 1266718292f2SDouglas Gregor /// \brief Parse a module declaration. 1267718292f2SDouglas Gregor /// 1268718292f2SDouglas Gregor /// module-declaration: 126997292843SDaniel Jasper /// 'extern' 'module' module-id string-literal 1270a686e1b0SDouglas Gregor /// 'explicit'[opt] 'framework'[opt] 'module' module-id attributes[opt] 1271a686e1b0SDouglas Gregor /// { module-member* } 1272a686e1b0SDouglas Gregor /// 1273718292f2SDouglas Gregor /// module-member: 12741fb5c3a6SDouglas Gregor /// requires-declaration 1275718292f2SDouglas Gregor /// header-declaration 1276e7ab3669SDouglas Gregor /// submodule-declaration 12772b82c2a5SDouglas Gregor /// export-declaration 12786ddfca91SDouglas Gregor /// link-declaration 127973441091SDouglas Gregor /// 128073441091SDouglas Gregor /// submodule-declaration: 128173441091SDouglas Gregor /// module-declaration 128273441091SDouglas Gregor /// inferred-submodule-declaration 1283718292f2SDouglas Gregor void ModuleMapParser::parseModuleDecl() { 1284755b2055SDouglas Gregor assert(Tok.is(MMToken::ExplicitKeyword) || Tok.is(MMToken::ModuleKeyword) || 128597292843SDaniel Jasper Tok.is(MMToken::FrameworkKeyword) || Tok.is(MMToken::ExternKeyword)); 128697292843SDaniel Jasper if (Tok.is(MMToken::ExternKeyword)) { 128797292843SDaniel Jasper parseExternModuleDecl(); 128897292843SDaniel Jasper return; 128997292843SDaniel Jasper } 129097292843SDaniel Jasper 1291f2161a70SDouglas Gregor // Parse 'explicit' or 'framework' keyword, if present. 1292e7ab3669SDouglas Gregor SourceLocation ExplicitLoc; 1293718292f2SDouglas Gregor bool Explicit = false; 1294f2161a70SDouglas Gregor bool Framework = false; 1295755b2055SDouglas Gregor 1296f2161a70SDouglas Gregor // Parse 'explicit' keyword, if present. 1297f2161a70SDouglas Gregor if (Tok.is(MMToken::ExplicitKeyword)) { 1298e7ab3669SDouglas Gregor ExplicitLoc = consumeToken(); 1299f2161a70SDouglas Gregor Explicit = true; 1300f2161a70SDouglas Gregor } 1301f2161a70SDouglas Gregor 1302f2161a70SDouglas Gregor // Parse 'framework' keyword, if present. 1303755b2055SDouglas Gregor if (Tok.is(MMToken::FrameworkKeyword)) { 1304755b2055SDouglas Gregor consumeToken(); 1305755b2055SDouglas Gregor Framework = true; 1306755b2055SDouglas Gregor } 1307718292f2SDouglas Gregor 1308718292f2SDouglas Gregor // Parse 'module' keyword. 1309718292f2SDouglas Gregor if (!Tok.is(MMToken::ModuleKeyword)) { 1310d6343c99SDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module); 1311718292f2SDouglas Gregor consumeToken(); 1312718292f2SDouglas Gregor HadError = true; 1313718292f2SDouglas Gregor return; 1314718292f2SDouglas Gregor } 1315718292f2SDouglas Gregor consumeToken(); // 'module' keyword 1316718292f2SDouglas Gregor 131773441091SDouglas Gregor // If we have a wildcard for the module name, this is an inferred submodule. 131873441091SDouglas Gregor // Parse it. 131973441091SDouglas Gregor if (Tok.is(MMToken::Star)) 13209194a91dSDouglas Gregor return parseInferredModuleDecl(Framework, Explicit); 132173441091SDouglas Gregor 1322718292f2SDouglas Gregor // Parse the module name. 1323e7ab3669SDouglas Gregor ModuleId Id; 1324e7ab3669SDouglas Gregor if (parseModuleId(Id)) { 1325718292f2SDouglas Gregor HadError = true; 1326718292f2SDouglas Gregor return; 1327718292f2SDouglas Gregor } 1328e7ab3669SDouglas Gregor 1329e7ab3669SDouglas Gregor if (ActiveModule) { 1330e7ab3669SDouglas Gregor if (Id.size() > 1) { 1331e7ab3669SDouglas Gregor Diags.Report(Id.front().second, diag::err_mmap_nested_submodule_id) 1332e7ab3669SDouglas Gregor << SourceRange(Id.front().second, Id.back().second); 1333e7ab3669SDouglas Gregor 1334e7ab3669SDouglas Gregor HadError = true; 1335e7ab3669SDouglas Gregor return; 1336e7ab3669SDouglas Gregor } 1337e7ab3669SDouglas Gregor } else if (Id.size() == 1 && Explicit) { 1338e7ab3669SDouglas Gregor // Top-level modules can't be explicit. 1339e7ab3669SDouglas Gregor Diags.Report(ExplicitLoc, diag::err_mmap_explicit_top_level); 1340e7ab3669SDouglas Gregor Explicit = false; 1341e7ab3669SDouglas Gregor ExplicitLoc = SourceLocation(); 1342e7ab3669SDouglas Gregor HadError = true; 1343e7ab3669SDouglas Gregor } 1344e7ab3669SDouglas Gregor 1345e7ab3669SDouglas Gregor Module *PreviousActiveModule = ActiveModule; 1346e7ab3669SDouglas Gregor if (Id.size() > 1) { 1347e7ab3669SDouglas Gregor // This module map defines a submodule. Go find the module of which it 1348e7ab3669SDouglas Gregor // is a submodule. 1349d2d442caSCraig Topper ActiveModule = nullptr; 1350e7ab3669SDouglas Gregor for (unsigned I = 0, N = Id.size() - 1; I != N; ++I) { 1351e7ab3669SDouglas Gregor if (Module *Next = Map.lookupModuleQualified(Id[I].first, ActiveModule)) { 1352e7ab3669SDouglas Gregor ActiveModule = Next; 1353e7ab3669SDouglas Gregor continue; 1354e7ab3669SDouglas Gregor } 1355e7ab3669SDouglas Gregor 1356e7ab3669SDouglas Gregor if (ActiveModule) { 1357e7ab3669SDouglas Gregor Diags.Report(Id[I].second, diag::err_mmap_missing_module_qualified) 13585b5d21eaSRichard Smith << Id[I].first 13595b5d21eaSRichard Smith << ActiveModule->getTopLevelModule()->getFullModuleName(); 1360e7ab3669SDouglas Gregor } else { 1361e7ab3669SDouglas Gregor Diags.Report(Id[I].second, diag::err_mmap_expected_module_name); 1362e7ab3669SDouglas Gregor } 1363e7ab3669SDouglas Gregor HadError = true; 1364e7ab3669SDouglas Gregor return; 1365e7ab3669SDouglas Gregor } 1366e7ab3669SDouglas Gregor } 1367e7ab3669SDouglas Gregor 1368e7ab3669SDouglas Gregor StringRef ModuleName = Id.back().first; 1369e7ab3669SDouglas Gregor SourceLocation ModuleNameLoc = Id.back().second; 1370718292f2SDouglas Gregor 1371a686e1b0SDouglas Gregor // Parse the optional attribute list. 13724442605fSBill Wendling Attributes Attrs; 13739194a91dSDouglas Gregor parseOptionalAttributes(Attrs); 1374a686e1b0SDouglas Gregor 1375718292f2SDouglas Gregor // Parse the opening brace. 1376718292f2SDouglas Gregor if (!Tok.is(MMToken::LBrace)) { 1377718292f2SDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_lbrace) 1378718292f2SDouglas Gregor << ModuleName; 1379718292f2SDouglas Gregor HadError = true; 1380718292f2SDouglas Gregor return; 1381718292f2SDouglas Gregor } 1382718292f2SDouglas Gregor SourceLocation LBraceLoc = consumeToken(); 1383718292f2SDouglas Gregor 1384718292f2SDouglas Gregor // Determine whether this (sub)module has already been defined. 1385eb90e830SDouglas Gregor if (Module *Existing = Map.lookupModuleQualified(ModuleName, ActiveModule)) { 1386fcc54a3bSDouglas Gregor if (Existing->DefinitionLoc.isInvalid() && !ActiveModule) { 1387fcc54a3bSDouglas Gregor // Skip the module definition. 1388fcc54a3bSDouglas Gregor skipUntil(MMToken::RBrace); 1389fcc54a3bSDouglas Gregor if (Tok.is(MMToken::RBrace)) 1390fcc54a3bSDouglas Gregor consumeToken(); 1391fcc54a3bSDouglas Gregor else { 1392fcc54a3bSDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace); 1393fcc54a3bSDouglas Gregor Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match); 1394fcc54a3bSDouglas Gregor HadError = true; 1395fcc54a3bSDouglas Gregor } 1396fcc54a3bSDouglas Gregor return; 1397fcc54a3bSDouglas Gregor } 1398fcc54a3bSDouglas Gregor 1399718292f2SDouglas Gregor Diags.Report(ModuleNameLoc, diag::err_mmap_module_redefinition) 1400718292f2SDouglas Gregor << ModuleName; 1401eb90e830SDouglas Gregor Diags.Report(Existing->DefinitionLoc, diag::note_mmap_prev_definition); 1402718292f2SDouglas Gregor 1403718292f2SDouglas Gregor // Skip the module definition. 1404718292f2SDouglas Gregor skipUntil(MMToken::RBrace); 1405718292f2SDouglas Gregor if (Tok.is(MMToken::RBrace)) 1406718292f2SDouglas Gregor consumeToken(); 1407718292f2SDouglas Gregor 1408718292f2SDouglas Gregor HadError = true; 1409718292f2SDouglas Gregor return; 1410718292f2SDouglas Gregor } 1411718292f2SDouglas Gregor 1412718292f2SDouglas Gregor // Start defining this module. 1413*9d6448b1SBen Langmuir ActiveModule = Map.findOrCreateModule(ModuleName, ActiveModule, Framework, 1414*9d6448b1SBen Langmuir Explicit).first; 1415eb90e830SDouglas Gregor ActiveModule->DefinitionLoc = ModuleNameLoc; 1416963c5535SDouglas Gregor if (Attrs.IsSystem || IsSystem) 1417a686e1b0SDouglas Gregor ActiveModule->IsSystem = true; 141877944868SRichard Smith if (Attrs.IsExternC) 141977944868SRichard Smith ActiveModule->IsExternC = true; 1420718292f2SDouglas Gregor 1421718292f2SDouglas Gregor bool Done = false; 1422718292f2SDouglas Gregor do { 1423718292f2SDouglas Gregor switch (Tok.Kind) { 1424718292f2SDouglas Gregor case MMToken::EndOfFile: 1425718292f2SDouglas Gregor case MMToken::RBrace: 1426718292f2SDouglas Gregor Done = true; 1427718292f2SDouglas Gregor break; 1428718292f2SDouglas Gregor 142935b13eceSDouglas Gregor case MMToken::ConfigMacros: 143035b13eceSDouglas Gregor parseConfigMacros(); 143135b13eceSDouglas Gregor break; 143235b13eceSDouglas Gregor 1433fb912657SDouglas Gregor case MMToken::Conflict: 1434fb912657SDouglas Gregor parseConflict(); 1435fb912657SDouglas Gregor break; 1436fb912657SDouglas Gregor 1437718292f2SDouglas Gregor case MMToken::ExplicitKeyword: 143897292843SDaniel Jasper case MMToken::ExternKeyword: 1439f2161a70SDouglas Gregor case MMToken::FrameworkKeyword: 1440718292f2SDouglas Gregor case MMToken::ModuleKeyword: 1441718292f2SDouglas Gregor parseModuleDecl(); 1442718292f2SDouglas Gregor break; 1443718292f2SDouglas Gregor 14442b82c2a5SDouglas Gregor case MMToken::ExportKeyword: 14452b82c2a5SDouglas Gregor parseExportDecl(); 14462b82c2a5SDouglas Gregor break; 14472b82c2a5SDouglas Gregor 1448ba7f2f71SDaniel Jasper case MMToken::UseKeyword: 1449ba7f2f71SDaniel Jasper parseUseDecl(); 1450ba7f2f71SDaniel Jasper break; 1451ba7f2f71SDaniel Jasper 14521fb5c3a6SDouglas Gregor case MMToken::RequiresKeyword: 14531fb5c3a6SDouglas Gregor parseRequiresDecl(); 14541fb5c3a6SDouglas Gregor break; 14551fb5c3a6SDouglas Gregor 1456524e33e1SDouglas Gregor case MMToken::UmbrellaKeyword: { 1457524e33e1SDouglas Gregor SourceLocation UmbrellaLoc = consumeToken(); 1458524e33e1SDouglas Gregor if (Tok.is(MMToken::HeaderKeyword)) 1459b53e5483SLawrence Crowl parseHeaderDecl(MMToken::UmbrellaKeyword, UmbrellaLoc); 1460524e33e1SDouglas Gregor else 1461524e33e1SDouglas Gregor parseUmbrellaDirDecl(UmbrellaLoc); 1462718292f2SDouglas Gregor break; 1463524e33e1SDouglas Gregor } 1464718292f2SDouglas Gregor 146559527666SDouglas Gregor case MMToken::ExcludeKeyword: { 146659527666SDouglas Gregor SourceLocation ExcludeLoc = consumeToken(); 146759527666SDouglas Gregor if (Tok.is(MMToken::HeaderKeyword)) { 1468b53e5483SLawrence Crowl parseHeaderDecl(MMToken::ExcludeKeyword, ExcludeLoc); 146959527666SDouglas Gregor } else { 147059527666SDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header) 147159527666SDouglas Gregor << "exclude"; 147259527666SDouglas Gregor } 147359527666SDouglas Gregor break; 147459527666SDouglas Gregor } 147559527666SDouglas Gregor 1476b53e5483SLawrence Crowl case MMToken::PrivateKeyword: { 1477b53e5483SLawrence Crowl SourceLocation PrivateLoc = consumeToken(); 1478b53e5483SLawrence Crowl if (Tok.is(MMToken::HeaderKeyword)) { 1479b53e5483SLawrence Crowl parseHeaderDecl(MMToken::PrivateKeyword, PrivateLoc); 1480b53e5483SLawrence Crowl } else { 1481b53e5483SLawrence Crowl Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header) 1482b53e5483SLawrence Crowl << "private"; 1483b53e5483SLawrence Crowl } 1484b53e5483SLawrence Crowl break; 1485b53e5483SLawrence Crowl } 1486b53e5483SLawrence Crowl 1487322f633cSDouglas Gregor case MMToken::HeaderKeyword: 1488b53e5483SLawrence Crowl parseHeaderDecl(MMToken::HeaderKeyword, SourceLocation()); 1489718292f2SDouglas Gregor break; 1490718292f2SDouglas Gregor 14916ddfca91SDouglas Gregor case MMToken::LinkKeyword: 14926ddfca91SDouglas Gregor parseLinkDecl(); 14936ddfca91SDouglas Gregor break; 14946ddfca91SDouglas Gregor 1495718292f2SDouglas Gregor default: 1496718292f2SDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_member); 1497718292f2SDouglas Gregor consumeToken(); 1498718292f2SDouglas Gregor break; 1499718292f2SDouglas Gregor } 1500718292f2SDouglas Gregor } while (!Done); 1501718292f2SDouglas Gregor 1502718292f2SDouglas Gregor if (Tok.is(MMToken::RBrace)) 1503718292f2SDouglas Gregor consumeToken(); 1504718292f2SDouglas Gregor else { 1505718292f2SDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace); 1506718292f2SDouglas Gregor Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match); 1507718292f2SDouglas Gregor HadError = true; 1508718292f2SDouglas Gregor } 1509718292f2SDouglas Gregor 151011dfe6feSDouglas Gregor // If the active module is a top-level framework, and there are no link 151111dfe6feSDouglas Gregor // libraries, automatically link against the framework. 151211dfe6feSDouglas Gregor if (ActiveModule->IsFramework && !ActiveModule->isSubFramework() && 151311dfe6feSDouglas Gregor ActiveModule->LinkLibraries.empty()) { 151411dfe6feSDouglas Gregor inferFrameworkLink(ActiveModule, Directory, SourceMgr.getFileManager()); 151511dfe6feSDouglas Gregor } 151611dfe6feSDouglas Gregor 1517ec8c9752SBen Langmuir // If the module meets all requirements but is still unavailable, mark the 1518ec8c9752SBen Langmuir // whole tree as unavailable to prevent it from building. 1519ec8c9752SBen Langmuir if (!ActiveModule->IsAvailable && !ActiveModule->IsMissingRequirement && 1520ec8c9752SBen Langmuir ActiveModule->Parent) { 1521ec8c9752SBen Langmuir ActiveModule->getTopLevelModule()->markUnavailable(); 1522ec8c9752SBen Langmuir ActiveModule->getTopLevelModule()->MissingHeaders.append( 1523ec8c9752SBen Langmuir ActiveModule->MissingHeaders.begin(), ActiveModule->MissingHeaders.end()); 1524ec8c9752SBen Langmuir } 1525ec8c9752SBen Langmuir 1526e7ab3669SDouglas Gregor // We're done parsing this module. Pop back to the previous module. 1527e7ab3669SDouglas Gregor ActiveModule = PreviousActiveModule; 1528718292f2SDouglas Gregor } 1529718292f2SDouglas Gregor 153097292843SDaniel Jasper /// \brief Parse an extern module declaration. 153197292843SDaniel Jasper /// 153297292843SDaniel Jasper /// extern module-declaration: 153397292843SDaniel Jasper /// 'extern' 'module' module-id string-literal 153497292843SDaniel Jasper void ModuleMapParser::parseExternModuleDecl() { 153597292843SDaniel Jasper assert(Tok.is(MMToken::ExternKeyword)); 153697292843SDaniel Jasper consumeToken(); // 'extern' keyword 153797292843SDaniel Jasper 153897292843SDaniel Jasper // Parse 'module' keyword. 153997292843SDaniel Jasper if (!Tok.is(MMToken::ModuleKeyword)) { 154097292843SDaniel Jasper Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module); 154197292843SDaniel Jasper consumeToken(); 154297292843SDaniel Jasper HadError = true; 154397292843SDaniel Jasper return; 154497292843SDaniel Jasper } 154597292843SDaniel Jasper consumeToken(); // 'module' keyword 154697292843SDaniel Jasper 154797292843SDaniel Jasper // Parse the module name. 154897292843SDaniel Jasper ModuleId Id; 154997292843SDaniel Jasper if (parseModuleId(Id)) { 155097292843SDaniel Jasper HadError = true; 155197292843SDaniel Jasper return; 155297292843SDaniel Jasper } 155397292843SDaniel Jasper 155497292843SDaniel Jasper // Parse the referenced module map file name. 155597292843SDaniel Jasper if (!Tok.is(MMToken::StringLiteral)) { 155697292843SDaniel Jasper Diags.Report(Tok.getLocation(), diag::err_mmap_expected_mmap_file); 155797292843SDaniel Jasper HadError = true; 155897292843SDaniel Jasper return; 155997292843SDaniel Jasper } 156097292843SDaniel Jasper std::string FileName = Tok.getString(); 156197292843SDaniel Jasper consumeToken(); // filename 156297292843SDaniel Jasper 156397292843SDaniel Jasper StringRef FileNameRef = FileName; 156497292843SDaniel Jasper SmallString<128> ModuleMapFileName; 156597292843SDaniel Jasper if (llvm::sys::path::is_relative(FileNameRef)) { 156697292843SDaniel Jasper ModuleMapFileName += Directory->getName(); 156797292843SDaniel Jasper llvm::sys::path::append(ModuleMapFileName, FileName); 156897292843SDaniel Jasper FileNameRef = ModuleMapFileName.str(); 156997292843SDaniel Jasper } 157097292843SDaniel Jasper if (const FileEntry *File = SourceMgr.getFileManager().getFile(FileNameRef)) 157197292843SDaniel Jasper Map.parseModuleMapFile(File, /*IsSystem=*/false); 157297292843SDaniel Jasper } 157397292843SDaniel Jasper 15741fb5c3a6SDouglas Gregor /// \brief Parse a requires declaration. 15751fb5c3a6SDouglas Gregor /// 15761fb5c3a6SDouglas Gregor /// requires-declaration: 15771fb5c3a6SDouglas Gregor /// 'requires' feature-list 15781fb5c3a6SDouglas Gregor /// 15791fb5c3a6SDouglas Gregor /// feature-list: 1580a3feee2aSRichard Smith /// feature ',' feature-list 1581a3feee2aSRichard Smith /// feature 1582a3feee2aSRichard Smith /// 1583a3feee2aSRichard Smith /// feature: 1584a3feee2aSRichard Smith /// '!'[opt] identifier 15851fb5c3a6SDouglas Gregor void ModuleMapParser::parseRequiresDecl() { 15861fb5c3a6SDouglas Gregor assert(Tok.is(MMToken::RequiresKeyword)); 15871fb5c3a6SDouglas Gregor 15881fb5c3a6SDouglas Gregor // Parse 'requires' keyword. 15891fb5c3a6SDouglas Gregor consumeToken(); 15901fb5c3a6SDouglas Gregor 15911fb5c3a6SDouglas Gregor // Parse the feature-list. 15921fb5c3a6SDouglas Gregor do { 1593a3feee2aSRichard Smith bool RequiredState = true; 1594a3feee2aSRichard Smith if (Tok.is(MMToken::Exclaim)) { 1595a3feee2aSRichard Smith RequiredState = false; 1596a3feee2aSRichard Smith consumeToken(); 1597a3feee2aSRichard Smith } 1598a3feee2aSRichard Smith 15991fb5c3a6SDouglas Gregor if (!Tok.is(MMToken::Identifier)) { 16001fb5c3a6SDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_feature); 16011fb5c3a6SDouglas Gregor HadError = true; 16021fb5c3a6SDouglas Gregor return; 16031fb5c3a6SDouglas Gregor } 16041fb5c3a6SDouglas Gregor 16051fb5c3a6SDouglas Gregor // Consume the feature name. 16061fb5c3a6SDouglas Gregor std::string Feature = Tok.getString(); 16071fb5c3a6SDouglas Gregor consumeToken(); 16081fb5c3a6SDouglas Gregor 16091fb5c3a6SDouglas Gregor // Add this feature. 1610a3feee2aSRichard Smith ActiveModule->addRequirement(Feature, RequiredState, 1611a3feee2aSRichard Smith Map.LangOpts, *Map.Target); 16121fb5c3a6SDouglas Gregor 16131fb5c3a6SDouglas Gregor if (!Tok.is(MMToken::Comma)) 16141fb5c3a6SDouglas Gregor break; 16151fb5c3a6SDouglas Gregor 16161fb5c3a6SDouglas Gregor // Consume the comma. 16171fb5c3a6SDouglas Gregor consumeToken(); 16181fb5c3a6SDouglas Gregor } while (true); 16191fb5c3a6SDouglas Gregor } 16201fb5c3a6SDouglas Gregor 1621f2161a70SDouglas Gregor /// \brief Append to \p Paths the set of paths needed to get to the 1622f2161a70SDouglas Gregor /// subframework in which the given module lives. 1623bf8da9d7SBenjamin Kramer static void appendSubframeworkPaths(Module *Mod, 1624f857950dSDmitri Gribenko SmallVectorImpl<char> &Path) { 1625f2161a70SDouglas Gregor // Collect the framework names from the given module to the top-level module. 1626f857950dSDmitri Gribenko SmallVector<StringRef, 2> Paths; 1627f2161a70SDouglas Gregor for (; Mod; Mod = Mod->Parent) { 1628f2161a70SDouglas Gregor if (Mod->IsFramework) 1629f2161a70SDouglas Gregor Paths.push_back(Mod->Name); 1630f2161a70SDouglas Gregor } 1631f2161a70SDouglas Gregor 1632f2161a70SDouglas Gregor if (Paths.empty()) 1633f2161a70SDouglas Gregor return; 1634f2161a70SDouglas Gregor 1635f2161a70SDouglas Gregor // Add Frameworks/Name.framework for each subframework. 163617381a06SBenjamin Kramer for (unsigned I = Paths.size() - 1; I != 0; --I) 163717381a06SBenjamin Kramer llvm::sys::path::append(Path, "Frameworks", Paths[I-1] + ".framework"); 1638f2161a70SDouglas Gregor } 1639f2161a70SDouglas Gregor 1640718292f2SDouglas Gregor /// \brief Parse a header declaration. 1641718292f2SDouglas Gregor /// 1642718292f2SDouglas Gregor /// header-declaration: 1643322f633cSDouglas Gregor /// 'umbrella'[opt] 'header' string-literal 164459527666SDouglas Gregor /// 'exclude'[opt] 'header' string-literal 1645b53e5483SLawrence Crowl void ModuleMapParser::parseHeaderDecl(MMToken::TokenKind LeadingToken, 1646b53e5483SLawrence Crowl SourceLocation LeadingLoc) { 1647718292f2SDouglas Gregor assert(Tok.is(MMToken::HeaderKeyword)); 16481871ed3dSBenjamin Kramer consumeToken(); 1649718292f2SDouglas Gregor 1650718292f2SDouglas Gregor // Parse the header name. 1651718292f2SDouglas Gregor if (!Tok.is(MMToken::StringLiteral)) { 1652718292f2SDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header) 1653718292f2SDouglas Gregor << "header"; 1654718292f2SDouglas Gregor HadError = true; 1655718292f2SDouglas Gregor return; 1656718292f2SDouglas Gregor } 16570761a8a0SDaniel Jasper Module::HeaderDirective Header; 16580761a8a0SDaniel Jasper Header.FileName = Tok.getString(); 16590761a8a0SDaniel Jasper Header.FileNameLoc = consumeToken(); 1660718292f2SDouglas Gregor 1661524e33e1SDouglas Gregor // Check whether we already have an umbrella. 1662b53e5483SLawrence Crowl if (LeadingToken == MMToken::UmbrellaKeyword && ActiveModule->Umbrella) { 16630761a8a0SDaniel Jasper Diags.Report(Header.FileNameLoc, diag::err_mmap_umbrella_clash) 1664524e33e1SDouglas Gregor << ActiveModule->getFullModuleName(); 1665322f633cSDouglas Gregor HadError = true; 1666322f633cSDouglas Gregor return; 1667322f633cSDouglas Gregor } 1668322f633cSDouglas Gregor 16695257fc63SDouglas Gregor // Look for this file. 1670d2d442caSCraig Topper const FileEntry *File = nullptr; 1671d2d442caSCraig Topper const FileEntry *BuiltinFile = nullptr; 16722c1dd271SDylan Noblesmith SmallString<128> PathName; 16730761a8a0SDaniel Jasper if (llvm::sys::path::is_absolute(Header.FileName)) { 16740761a8a0SDaniel Jasper PathName = Header.FileName; 1675e7ab3669SDouglas Gregor File = SourceMgr.getFileManager().getFile(PathName); 1676e7ab3669SDouglas Gregor } else { 1677e7ab3669SDouglas Gregor // Search for the header file within the search directory. 16787033127bSDouglas Gregor PathName = Directory->getName(); 1679e7ab3669SDouglas Gregor unsigned PathLength = PathName.size(); 1680755b2055SDouglas Gregor 1681f2161a70SDouglas Gregor if (ActiveModule->isPartOfFramework()) { 1682f2161a70SDouglas Gregor appendSubframeworkPaths(ActiveModule, PathName); 1683755b2055SDouglas Gregor 1684e7ab3669SDouglas Gregor // Check whether this file is in the public headers. 16850761a8a0SDaniel Jasper llvm::sys::path::append(PathName, "Headers", Header.FileName); 1686e7ab3669SDouglas Gregor File = SourceMgr.getFileManager().getFile(PathName); 1687e7ab3669SDouglas Gregor 1688e7ab3669SDouglas Gregor if (!File) { 1689e7ab3669SDouglas Gregor // Check whether this file is in the private headers. 1690e7ab3669SDouglas Gregor PathName.resize(PathLength); 16910761a8a0SDaniel Jasper llvm::sys::path::append(PathName, "PrivateHeaders", Header.FileName); 1692e7ab3669SDouglas Gregor File = SourceMgr.getFileManager().getFile(PathName); 1693e7ab3669SDouglas Gregor } 1694e7ab3669SDouglas Gregor } else { 1695e7ab3669SDouglas Gregor // Lookup for normal headers. 16960761a8a0SDaniel Jasper llvm::sys::path::append(PathName, Header.FileName); 1697e7ab3669SDouglas Gregor File = SourceMgr.getFileManager().getFile(PathName); 16983ec6663bSDouglas Gregor 16993ec6663bSDouglas Gregor // If this is a system module with a top-level header, this header 17003ec6663bSDouglas Gregor // may have a counterpart (or replacement) in the set of headers 17013ec6663bSDouglas Gregor // supplied by Clang. Find that builtin header. 1702b53e5483SLawrence Crowl if (ActiveModule->IsSystem && LeadingToken != MMToken::UmbrellaKeyword && 1703b53e5483SLawrence Crowl BuiltinIncludeDir && BuiltinIncludeDir != Directory && 17040761a8a0SDaniel Jasper isBuiltinHeader(Header.FileName)) { 17052c1dd271SDylan Noblesmith SmallString<128> BuiltinPathName(BuiltinIncludeDir->getName()); 17060761a8a0SDaniel Jasper llvm::sys::path::append(BuiltinPathName, Header.FileName); 17073ec6663bSDouglas Gregor BuiltinFile = SourceMgr.getFileManager().getFile(BuiltinPathName); 17083ec6663bSDouglas Gregor 17093ec6663bSDouglas Gregor // If Clang supplies this header but the underlying system does not, 17103ec6663bSDouglas Gregor // just silently swap in our builtin version. Otherwise, we'll end 17113ec6663bSDouglas Gregor // up adding both (later). 17123ec6663bSDouglas Gregor if (!File && BuiltinFile) { 17133ec6663bSDouglas Gregor File = BuiltinFile; 1714d2d442caSCraig Topper BuiltinFile = nullptr; 17153ec6663bSDouglas Gregor } 17163ec6663bSDouglas Gregor } 1717e7ab3669SDouglas Gregor } 1718e7ab3669SDouglas Gregor } 17195257fc63SDouglas Gregor 17205257fc63SDouglas Gregor // FIXME: We shouldn't be eagerly stat'ing every file named in a module map. 17215257fc63SDouglas Gregor // Come up with a lazy way to do this. 1722e7ab3669SDouglas Gregor if (File) { 172397da9178SDaniel Jasper if (LeadingToken == MMToken::UmbrellaKeyword) { 1724322f633cSDouglas Gregor const DirectoryEntry *UmbrellaDir = File->getDir(); 172559527666SDouglas Gregor if (Module *UmbrellaModule = Map.UmbrellaDirs[UmbrellaDir]) { 1726b53e5483SLawrence Crowl Diags.Report(LeadingLoc, diag::err_mmap_umbrella_clash) 172759527666SDouglas Gregor << UmbrellaModule->getFullModuleName(); 1728322f633cSDouglas Gregor HadError = true; 17295257fc63SDouglas Gregor } else { 1730322f633cSDouglas Gregor // Record this umbrella header. 1731322f633cSDouglas Gregor Map.setUmbrellaHeader(ActiveModule, File); 1732322f633cSDouglas Gregor } 1733322f633cSDouglas Gregor } else { 1734322f633cSDouglas Gregor // Record this header. 1735b53e5483SLawrence Crowl ModuleMap::ModuleHeaderRole Role = ModuleMap::NormalHeader; 1736b53e5483SLawrence Crowl if (LeadingToken == MMToken::ExcludeKeyword) 1737b53e5483SLawrence Crowl Role = ModuleMap::ExcludedHeader; 1738b53e5483SLawrence Crowl else if (LeadingToken == MMToken::PrivateKeyword) 1739b53e5483SLawrence Crowl Role = ModuleMap::PrivateHeader; 1740b53e5483SLawrence Crowl else 1741b53e5483SLawrence Crowl assert(LeadingToken == MMToken::HeaderKeyword); 1742b53e5483SLawrence Crowl 1743b53e5483SLawrence Crowl Map.addHeader(ActiveModule, File, Role); 17443ec6663bSDouglas Gregor 17453ec6663bSDouglas Gregor // If there is a builtin counterpart to this file, add it now. 17463ec6663bSDouglas Gregor if (BuiltinFile) 1747b53e5483SLawrence Crowl Map.addHeader(ActiveModule, BuiltinFile, Role); 17485257fc63SDouglas Gregor } 1749b53e5483SLawrence Crowl } else if (LeadingToken != MMToken::ExcludeKeyword) { 17504b27a64bSDouglas Gregor // Ignore excluded header files. They're optional anyway. 17514b27a64bSDouglas Gregor 17520761a8a0SDaniel Jasper // If we find a module that has a missing header, we mark this module as 17530761a8a0SDaniel Jasper // unavailable and store the header directive for displaying diagnostics. 17540761a8a0SDaniel Jasper Header.IsUmbrella = LeadingToken == MMToken::UmbrellaKeyword; 1755ec8c9752SBen Langmuir ActiveModule->markUnavailable(); 17560761a8a0SDaniel Jasper ActiveModule->MissingHeaders.push_back(Header); 17575257fc63SDouglas Gregor } 1758718292f2SDouglas Gregor } 1759718292f2SDouglas Gregor 1760524e33e1SDouglas Gregor /// \brief Parse an umbrella directory declaration. 1761524e33e1SDouglas Gregor /// 1762524e33e1SDouglas Gregor /// umbrella-dir-declaration: 1763524e33e1SDouglas Gregor /// umbrella string-literal 1764524e33e1SDouglas Gregor void ModuleMapParser::parseUmbrellaDirDecl(SourceLocation UmbrellaLoc) { 1765524e33e1SDouglas Gregor // Parse the directory name. 1766524e33e1SDouglas Gregor if (!Tok.is(MMToken::StringLiteral)) { 1767524e33e1SDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header) 1768524e33e1SDouglas Gregor << "umbrella"; 1769524e33e1SDouglas Gregor HadError = true; 1770524e33e1SDouglas Gregor return; 1771524e33e1SDouglas Gregor } 1772524e33e1SDouglas Gregor 1773524e33e1SDouglas Gregor std::string DirName = Tok.getString(); 1774524e33e1SDouglas Gregor SourceLocation DirNameLoc = consumeToken(); 1775524e33e1SDouglas Gregor 1776524e33e1SDouglas Gregor // Check whether we already have an umbrella. 1777524e33e1SDouglas Gregor if (ActiveModule->Umbrella) { 1778524e33e1SDouglas Gregor Diags.Report(DirNameLoc, diag::err_mmap_umbrella_clash) 1779524e33e1SDouglas Gregor << ActiveModule->getFullModuleName(); 1780524e33e1SDouglas Gregor HadError = true; 1781524e33e1SDouglas Gregor return; 1782524e33e1SDouglas Gregor } 1783524e33e1SDouglas Gregor 1784524e33e1SDouglas Gregor // Look for this file. 1785d2d442caSCraig Topper const DirectoryEntry *Dir = nullptr; 1786524e33e1SDouglas Gregor if (llvm::sys::path::is_absolute(DirName)) 1787524e33e1SDouglas Gregor Dir = SourceMgr.getFileManager().getDirectory(DirName); 1788524e33e1SDouglas Gregor else { 17892c1dd271SDylan Noblesmith SmallString<128> PathName; 1790524e33e1SDouglas Gregor PathName = Directory->getName(); 1791524e33e1SDouglas Gregor llvm::sys::path::append(PathName, DirName); 1792524e33e1SDouglas Gregor Dir = SourceMgr.getFileManager().getDirectory(PathName); 1793524e33e1SDouglas Gregor } 1794524e33e1SDouglas Gregor 1795524e33e1SDouglas Gregor if (!Dir) { 1796524e33e1SDouglas Gregor Diags.Report(DirNameLoc, diag::err_mmap_umbrella_dir_not_found) 1797524e33e1SDouglas Gregor << DirName; 1798524e33e1SDouglas Gregor HadError = true; 1799524e33e1SDouglas Gregor return; 1800524e33e1SDouglas Gregor } 1801524e33e1SDouglas Gregor 1802524e33e1SDouglas Gregor if (Module *OwningModule = Map.UmbrellaDirs[Dir]) { 1803524e33e1SDouglas Gregor Diags.Report(UmbrellaLoc, diag::err_mmap_umbrella_clash) 1804524e33e1SDouglas Gregor << OwningModule->getFullModuleName(); 1805524e33e1SDouglas Gregor HadError = true; 1806524e33e1SDouglas Gregor return; 1807524e33e1SDouglas Gregor } 1808524e33e1SDouglas Gregor 1809524e33e1SDouglas Gregor // Record this umbrella directory. 1810524e33e1SDouglas Gregor Map.setUmbrellaDir(ActiveModule, Dir); 1811524e33e1SDouglas Gregor } 1812524e33e1SDouglas Gregor 18132b82c2a5SDouglas Gregor /// \brief Parse a module export declaration. 18142b82c2a5SDouglas Gregor /// 18152b82c2a5SDouglas Gregor /// export-declaration: 18162b82c2a5SDouglas Gregor /// 'export' wildcard-module-id 18172b82c2a5SDouglas Gregor /// 18182b82c2a5SDouglas Gregor /// wildcard-module-id: 18192b82c2a5SDouglas Gregor /// identifier 18202b82c2a5SDouglas Gregor /// '*' 18212b82c2a5SDouglas Gregor /// identifier '.' wildcard-module-id 18222b82c2a5SDouglas Gregor void ModuleMapParser::parseExportDecl() { 18232b82c2a5SDouglas Gregor assert(Tok.is(MMToken::ExportKeyword)); 18242b82c2a5SDouglas Gregor SourceLocation ExportLoc = consumeToken(); 18252b82c2a5SDouglas Gregor 18262b82c2a5SDouglas Gregor // Parse the module-id with an optional wildcard at the end. 18272b82c2a5SDouglas Gregor ModuleId ParsedModuleId; 18282b82c2a5SDouglas Gregor bool Wildcard = false; 18292b82c2a5SDouglas Gregor do { 18302b82c2a5SDouglas Gregor if (Tok.is(MMToken::Identifier)) { 18312b82c2a5SDouglas Gregor ParsedModuleId.push_back(std::make_pair(Tok.getString(), 18322b82c2a5SDouglas Gregor Tok.getLocation())); 18332b82c2a5SDouglas Gregor consumeToken(); 18342b82c2a5SDouglas Gregor 18352b82c2a5SDouglas Gregor if (Tok.is(MMToken::Period)) { 18362b82c2a5SDouglas Gregor consumeToken(); 18372b82c2a5SDouglas Gregor continue; 18382b82c2a5SDouglas Gregor } 18392b82c2a5SDouglas Gregor 18402b82c2a5SDouglas Gregor break; 18412b82c2a5SDouglas Gregor } 18422b82c2a5SDouglas Gregor 18432b82c2a5SDouglas Gregor if(Tok.is(MMToken::Star)) { 18442b82c2a5SDouglas Gregor Wildcard = true; 1845f5eedd05SDouglas Gregor consumeToken(); 18462b82c2a5SDouglas Gregor break; 18472b82c2a5SDouglas Gregor } 18482b82c2a5SDouglas Gregor 1849ba7f2f71SDaniel Jasper Diags.Report(Tok.getLocation(), diag::err_mmap_module_id); 18502b82c2a5SDouglas Gregor HadError = true; 18512b82c2a5SDouglas Gregor return; 18522b82c2a5SDouglas Gregor } while (true); 18532b82c2a5SDouglas Gregor 18542b82c2a5SDouglas Gregor Module::UnresolvedExportDecl Unresolved = { 18552b82c2a5SDouglas Gregor ExportLoc, ParsedModuleId, Wildcard 18562b82c2a5SDouglas Gregor }; 18572b82c2a5SDouglas Gregor ActiveModule->UnresolvedExports.push_back(Unresolved); 18582b82c2a5SDouglas Gregor } 18592b82c2a5SDouglas Gregor 1860ba7f2f71SDaniel Jasper /// \brief Parse a module uses declaration. 1861ba7f2f71SDaniel Jasper /// 1862ba7f2f71SDaniel Jasper /// uses-declaration: 1863ba7f2f71SDaniel Jasper /// 'uses' wildcard-module-id 1864ba7f2f71SDaniel Jasper void ModuleMapParser::parseUseDecl() { 1865ba7f2f71SDaniel Jasper assert(Tok.is(MMToken::UseKeyword)); 1866ba7f2f71SDaniel Jasper consumeToken(); 1867ba7f2f71SDaniel Jasper // Parse the module-id. 1868ba7f2f71SDaniel Jasper ModuleId ParsedModuleId; 18693cd34c76SDaniel Jasper parseModuleId(ParsedModuleId); 1870ba7f2f71SDaniel Jasper 1871ba7f2f71SDaniel Jasper ActiveModule->UnresolvedDirectUses.push_back(ParsedModuleId); 1872ba7f2f71SDaniel Jasper } 1873ba7f2f71SDaniel Jasper 18746ddfca91SDouglas Gregor /// \brief Parse a link declaration. 18756ddfca91SDouglas Gregor /// 18766ddfca91SDouglas Gregor /// module-declaration: 18776ddfca91SDouglas Gregor /// 'link' 'framework'[opt] string-literal 18786ddfca91SDouglas Gregor void ModuleMapParser::parseLinkDecl() { 18796ddfca91SDouglas Gregor assert(Tok.is(MMToken::LinkKeyword)); 18806ddfca91SDouglas Gregor SourceLocation LinkLoc = consumeToken(); 18816ddfca91SDouglas Gregor 18826ddfca91SDouglas Gregor // Parse the optional 'framework' keyword. 18836ddfca91SDouglas Gregor bool IsFramework = false; 18846ddfca91SDouglas Gregor if (Tok.is(MMToken::FrameworkKeyword)) { 18856ddfca91SDouglas Gregor consumeToken(); 18866ddfca91SDouglas Gregor IsFramework = true; 18876ddfca91SDouglas Gregor } 18886ddfca91SDouglas Gregor 18896ddfca91SDouglas Gregor // Parse the library name 18906ddfca91SDouglas Gregor if (!Tok.is(MMToken::StringLiteral)) { 18916ddfca91SDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_library_name) 18926ddfca91SDouglas Gregor << IsFramework << SourceRange(LinkLoc); 18936ddfca91SDouglas Gregor HadError = true; 18946ddfca91SDouglas Gregor return; 18956ddfca91SDouglas Gregor } 18966ddfca91SDouglas Gregor 18976ddfca91SDouglas Gregor std::string LibraryName = Tok.getString(); 18986ddfca91SDouglas Gregor consumeToken(); 18996ddfca91SDouglas Gregor ActiveModule->LinkLibraries.push_back(Module::LinkLibrary(LibraryName, 19006ddfca91SDouglas Gregor IsFramework)); 19016ddfca91SDouglas Gregor } 19026ddfca91SDouglas Gregor 190335b13eceSDouglas Gregor /// \brief Parse a configuration macro declaration. 190435b13eceSDouglas Gregor /// 190535b13eceSDouglas Gregor /// module-declaration: 190635b13eceSDouglas Gregor /// 'config_macros' attributes[opt] config-macro-list? 190735b13eceSDouglas Gregor /// 190835b13eceSDouglas Gregor /// config-macro-list: 190935b13eceSDouglas Gregor /// identifier (',' identifier)? 191035b13eceSDouglas Gregor void ModuleMapParser::parseConfigMacros() { 191135b13eceSDouglas Gregor assert(Tok.is(MMToken::ConfigMacros)); 191235b13eceSDouglas Gregor SourceLocation ConfigMacrosLoc = consumeToken(); 191335b13eceSDouglas Gregor 191435b13eceSDouglas Gregor // Only top-level modules can have configuration macros. 191535b13eceSDouglas Gregor if (ActiveModule->Parent) { 191635b13eceSDouglas Gregor Diags.Report(ConfigMacrosLoc, diag::err_mmap_config_macro_submodule); 191735b13eceSDouglas Gregor } 191835b13eceSDouglas Gregor 191935b13eceSDouglas Gregor // Parse the optional attributes. 192035b13eceSDouglas Gregor Attributes Attrs; 192135b13eceSDouglas Gregor parseOptionalAttributes(Attrs); 192235b13eceSDouglas Gregor if (Attrs.IsExhaustive && !ActiveModule->Parent) { 192335b13eceSDouglas Gregor ActiveModule->ConfigMacrosExhaustive = true; 192435b13eceSDouglas Gregor } 192535b13eceSDouglas Gregor 192635b13eceSDouglas Gregor // If we don't have an identifier, we're done. 192735b13eceSDouglas Gregor if (!Tok.is(MMToken::Identifier)) 192835b13eceSDouglas Gregor return; 192935b13eceSDouglas Gregor 193035b13eceSDouglas Gregor // Consume the first identifier. 193135b13eceSDouglas Gregor if (!ActiveModule->Parent) { 193235b13eceSDouglas Gregor ActiveModule->ConfigMacros.push_back(Tok.getString().str()); 193335b13eceSDouglas Gregor } 193435b13eceSDouglas Gregor consumeToken(); 193535b13eceSDouglas Gregor 193635b13eceSDouglas Gregor do { 193735b13eceSDouglas Gregor // If there's a comma, consume it. 193835b13eceSDouglas Gregor if (!Tok.is(MMToken::Comma)) 193935b13eceSDouglas Gregor break; 194035b13eceSDouglas Gregor consumeToken(); 194135b13eceSDouglas Gregor 194235b13eceSDouglas Gregor // We expect to see a macro name here. 194335b13eceSDouglas Gregor if (!Tok.is(MMToken::Identifier)) { 194435b13eceSDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_config_macro); 194535b13eceSDouglas Gregor break; 194635b13eceSDouglas Gregor } 194735b13eceSDouglas Gregor 194835b13eceSDouglas Gregor // Consume the macro name. 194935b13eceSDouglas Gregor if (!ActiveModule->Parent) { 195035b13eceSDouglas Gregor ActiveModule->ConfigMacros.push_back(Tok.getString().str()); 195135b13eceSDouglas Gregor } 195235b13eceSDouglas Gregor consumeToken(); 195335b13eceSDouglas Gregor } while (true); 195435b13eceSDouglas Gregor } 195535b13eceSDouglas Gregor 1956fb912657SDouglas Gregor /// \brief Format a module-id into a string. 1957fb912657SDouglas Gregor static std::string formatModuleId(const ModuleId &Id) { 1958fb912657SDouglas Gregor std::string result; 1959fb912657SDouglas Gregor { 1960fb912657SDouglas Gregor llvm::raw_string_ostream OS(result); 1961fb912657SDouglas Gregor 1962fb912657SDouglas Gregor for (unsigned I = 0, N = Id.size(); I != N; ++I) { 1963fb912657SDouglas Gregor if (I) 1964fb912657SDouglas Gregor OS << "."; 1965fb912657SDouglas Gregor OS << Id[I].first; 1966fb912657SDouglas Gregor } 1967fb912657SDouglas Gregor } 1968fb912657SDouglas Gregor 1969fb912657SDouglas Gregor return result; 1970fb912657SDouglas Gregor } 1971fb912657SDouglas Gregor 1972fb912657SDouglas Gregor /// \brief Parse a conflict declaration. 1973fb912657SDouglas Gregor /// 1974fb912657SDouglas Gregor /// module-declaration: 1975fb912657SDouglas Gregor /// 'conflict' module-id ',' string-literal 1976fb912657SDouglas Gregor void ModuleMapParser::parseConflict() { 1977fb912657SDouglas Gregor assert(Tok.is(MMToken::Conflict)); 1978fb912657SDouglas Gregor SourceLocation ConflictLoc = consumeToken(); 1979fb912657SDouglas Gregor Module::UnresolvedConflict Conflict; 1980fb912657SDouglas Gregor 1981fb912657SDouglas Gregor // Parse the module-id. 1982fb912657SDouglas Gregor if (parseModuleId(Conflict.Id)) 1983fb912657SDouglas Gregor return; 1984fb912657SDouglas Gregor 1985fb912657SDouglas Gregor // Parse the ','. 1986fb912657SDouglas Gregor if (!Tok.is(MMToken::Comma)) { 1987fb912657SDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_conflicts_comma) 1988fb912657SDouglas Gregor << SourceRange(ConflictLoc); 1989fb912657SDouglas Gregor return; 1990fb912657SDouglas Gregor } 1991fb912657SDouglas Gregor consumeToken(); 1992fb912657SDouglas Gregor 1993fb912657SDouglas Gregor // Parse the message. 1994fb912657SDouglas Gregor if (!Tok.is(MMToken::StringLiteral)) { 1995fb912657SDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_conflicts_message) 1996fb912657SDouglas Gregor << formatModuleId(Conflict.Id); 1997fb912657SDouglas Gregor return; 1998fb912657SDouglas Gregor } 1999fb912657SDouglas Gregor Conflict.Message = Tok.getString().str(); 2000fb912657SDouglas Gregor consumeToken(); 2001fb912657SDouglas Gregor 2002fb912657SDouglas Gregor // Add this unresolved conflict. 2003fb912657SDouglas Gregor ActiveModule->UnresolvedConflicts.push_back(Conflict); 2004fb912657SDouglas Gregor } 2005fb912657SDouglas Gregor 20066ddfca91SDouglas Gregor /// \brief Parse an inferred module declaration (wildcard modules). 20079194a91dSDouglas Gregor /// 20089194a91dSDouglas Gregor /// module-declaration: 20099194a91dSDouglas Gregor /// 'explicit'[opt] 'framework'[opt] 'module' * attributes[opt] 20109194a91dSDouglas Gregor /// { inferred-module-member* } 20119194a91dSDouglas Gregor /// 20129194a91dSDouglas Gregor /// inferred-module-member: 20139194a91dSDouglas Gregor /// 'export' '*' 20149194a91dSDouglas Gregor /// 'exclude' identifier 20159194a91dSDouglas Gregor void ModuleMapParser::parseInferredModuleDecl(bool Framework, bool Explicit) { 201673441091SDouglas Gregor assert(Tok.is(MMToken::Star)); 201773441091SDouglas Gregor SourceLocation StarLoc = consumeToken(); 201873441091SDouglas Gregor bool Failed = false; 201973441091SDouglas Gregor 202073441091SDouglas Gregor // Inferred modules must be submodules. 20219194a91dSDouglas Gregor if (!ActiveModule && !Framework) { 202273441091SDouglas Gregor Diags.Report(StarLoc, diag::err_mmap_top_level_inferred_submodule); 202373441091SDouglas Gregor Failed = true; 202473441091SDouglas Gregor } 202573441091SDouglas Gregor 20269194a91dSDouglas Gregor if (ActiveModule) { 2027524e33e1SDouglas Gregor // Inferred modules must have umbrella directories. 20284898cde4SBen Langmuir if (!Failed && ActiveModule->IsAvailable && 20294898cde4SBen Langmuir !ActiveModule->getUmbrellaDir()) { 203073441091SDouglas Gregor Diags.Report(StarLoc, diag::err_mmap_inferred_no_umbrella); 203173441091SDouglas Gregor Failed = true; 203273441091SDouglas Gregor } 203373441091SDouglas Gregor 203473441091SDouglas Gregor // Check for redefinition of an inferred module. 2035dd005f69SDouglas Gregor if (!Failed && ActiveModule->InferSubmodules) { 203673441091SDouglas Gregor Diags.Report(StarLoc, diag::err_mmap_inferred_redef); 2037dd005f69SDouglas Gregor if (ActiveModule->InferredSubmoduleLoc.isValid()) 2038dd005f69SDouglas Gregor Diags.Report(ActiveModule->InferredSubmoduleLoc, 203973441091SDouglas Gregor diag::note_mmap_prev_definition); 204073441091SDouglas Gregor Failed = true; 204173441091SDouglas Gregor } 204273441091SDouglas Gregor 20439194a91dSDouglas Gregor // Check for the 'framework' keyword, which is not permitted here. 20449194a91dSDouglas Gregor if (Framework) { 20459194a91dSDouglas Gregor Diags.Report(StarLoc, diag::err_mmap_inferred_framework_submodule); 20469194a91dSDouglas Gregor Framework = false; 20479194a91dSDouglas Gregor } 20489194a91dSDouglas Gregor } else if (Explicit) { 20499194a91dSDouglas Gregor Diags.Report(StarLoc, diag::err_mmap_explicit_inferred_framework); 20509194a91dSDouglas Gregor Explicit = false; 20519194a91dSDouglas Gregor } 20529194a91dSDouglas Gregor 205373441091SDouglas Gregor // If there were any problems with this inferred submodule, skip its body. 205473441091SDouglas Gregor if (Failed) { 205573441091SDouglas Gregor if (Tok.is(MMToken::LBrace)) { 205673441091SDouglas Gregor consumeToken(); 205773441091SDouglas Gregor skipUntil(MMToken::RBrace); 205873441091SDouglas Gregor if (Tok.is(MMToken::RBrace)) 205973441091SDouglas Gregor consumeToken(); 206073441091SDouglas Gregor } 206173441091SDouglas Gregor HadError = true; 206273441091SDouglas Gregor return; 206373441091SDouglas Gregor } 206473441091SDouglas Gregor 20659194a91dSDouglas Gregor // Parse optional attributes. 20664442605fSBill Wendling Attributes Attrs; 20679194a91dSDouglas Gregor parseOptionalAttributes(Attrs); 20689194a91dSDouglas Gregor 20699194a91dSDouglas Gregor if (ActiveModule) { 207073441091SDouglas Gregor // Note that we have an inferred submodule. 2071dd005f69SDouglas Gregor ActiveModule->InferSubmodules = true; 2072dd005f69SDouglas Gregor ActiveModule->InferredSubmoduleLoc = StarLoc; 2073dd005f69SDouglas Gregor ActiveModule->InferExplicitSubmodules = Explicit; 20749194a91dSDouglas Gregor } else { 20759194a91dSDouglas Gregor // We'll be inferring framework modules for this directory. 20769194a91dSDouglas Gregor Map.InferredDirectories[Directory].InferModules = true; 20779194a91dSDouglas Gregor Map.InferredDirectories[Directory].InferSystemModules = Attrs.IsSystem; 2078beee15e7SBen Langmuir Map.InferredDirectories[Directory].ModuleMapFile = ModuleMapFile; 2079131daca0SRichard Smith // FIXME: Handle the 'framework' keyword. 20809194a91dSDouglas Gregor } 208173441091SDouglas Gregor 208273441091SDouglas Gregor // Parse the opening brace. 208373441091SDouglas Gregor if (!Tok.is(MMToken::LBrace)) { 208473441091SDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_lbrace_wildcard); 208573441091SDouglas Gregor HadError = true; 208673441091SDouglas Gregor return; 208773441091SDouglas Gregor } 208873441091SDouglas Gregor SourceLocation LBraceLoc = consumeToken(); 208973441091SDouglas Gregor 209073441091SDouglas Gregor // Parse the body of the inferred submodule. 209173441091SDouglas Gregor bool Done = false; 209273441091SDouglas Gregor do { 209373441091SDouglas Gregor switch (Tok.Kind) { 209473441091SDouglas Gregor case MMToken::EndOfFile: 209573441091SDouglas Gregor case MMToken::RBrace: 209673441091SDouglas Gregor Done = true; 209773441091SDouglas Gregor break; 209873441091SDouglas Gregor 20999194a91dSDouglas Gregor case MMToken::ExcludeKeyword: { 21009194a91dSDouglas Gregor if (ActiveModule) { 21019194a91dSDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_inferred_member) 2102d2d442caSCraig Topper << (ActiveModule != nullptr); 21039194a91dSDouglas Gregor consumeToken(); 21049194a91dSDouglas Gregor break; 21059194a91dSDouglas Gregor } 21069194a91dSDouglas Gregor 21079194a91dSDouglas Gregor consumeToken(); 21089194a91dSDouglas Gregor if (!Tok.is(MMToken::Identifier)) { 21099194a91dSDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_missing_exclude_name); 21109194a91dSDouglas Gregor break; 21119194a91dSDouglas Gregor } 21129194a91dSDouglas Gregor 21139194a91dSDouglas Gregor Map.InferredDirectories[Directory].ExcludedModules 21149194a91dSDouglas Gregor .push_back(Tok.getString()); 21159194a91dSDouglas Gregor consumeToken(); 21169194a91dSDouglas Gregor break; 21179194a91dSDouglas Gregor } 21189194a91dSDouglas Gregor 21199194a91dSDouglas Gregor case MMToken::ExportKeyword: 21209194a91dSDouglas Gregor if (!ActiveModule) { 21219194a91dSDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_inferred_member) 2122d2d442caSCraig Topper << (ActiveModule != nullptr); 21239194a91dSDouglas Gregor consumeToken(); 21249194a91dSDouglas Gregor break; 21259194a91dSDouglas Gregor } 21269194a91dSDouglas Gregor 212773441091SDouglas Gregor consumeToken(); 212873441091SDouglas Gregor if (Tok.is(MMToken::Star)) 2129dd005f69SDouglas Gregor ActiveModule->InferExportWildcard = true; 213073441091SDouglas Gregor else 213173441091SDouglas Gregor Diags.Report(Tok.getLocation(), 213273441091SDouglas Gregor diag::err_mmap_expected_export_wildcard); 213373441091SDouglas Gregor consumeToken(); 213473441091SDouglas Gregor break; 213573441091SDouglas Gregor 213673441091SDouglas Gregor case MMToken::ExplicitKeyword: 213773441091SDouglas Gregor case MMToken::ModuleKeyword: 213873441091SDouglas Gregor case MMToken::HeaderKeyword: 2139b53e5483SLawrence Crowl case MMToken::PrivateKeyword: 214073441091SDouglas Gregor case MMToken::UmbrellaKeyword: 214173441091SDouglas Gregor default: 21429194a91dSDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_inferred_member) 2143d2d442caSCraig Topper << (ActiveModule != nullptr); 214473441091SDouglas Gregor consumeToken(); 214573441091SDouglas Gregor break; 214673441091SDouglas Gregor } 214773441091SDouglas Gregor } while (!Done); 214873441091SDouglas Gregor 214973441091SDouglas Gregor if (Tok.is(MMToken::RBrace)) 215073441091SDouglas Gregor consumeToken(); 215173441091SDouglas Gregor else { 215273441091SDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace); 215373441091SDouglas Gregor Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match); 215473441091SDouglas Gregor HadError = true; 215573441091SDouglas Gregor } 215673441091SDouglas Gregor } 215773441091SDouglas Gregor 21589194a91dSDouglas Gregor /// \brief Parse optional attributes. 21599194a91dSDouglas Gregor /// 21609194a91dSDouglas Gregor /// attributes: 21619194a91dSDouglas Gregor /// attribute attributes 21629194a91dSDouglas Gregor /// attribute 21639194a91dSDouglas Gregor /// 21649194a91dSDouglas Gregor /// attribute: 21659194a91dSDouglas Gregor /// [ identifier ] 21669194a91dSDouglas Gregor /// 21679194a91dSDouglas Gregor /// \param Attrs Will be filled in with the parsed attributes. 21689194a91dSDouglas Gregor /// 21699194a91dSDouglas Gregor /// \returns true if an error occurred, false otherwise. 21704442605fSBill Wendling bool ModuleMapParser::parseOptionalAttributes(Attributes &Attrs) { 21719194a91dSDouglas Gregor bool HadError = false; 21729194a91dSDouglas Gregor 21739194a91dSDouglas Gregor while (Tok.is(MMToken::LSquare)) { 21749194a91dSDouglas Gregor // Consume the '['. 21759194a91dSDouglas Gregor SourceLocation LSquareLoc = consumeToken(); 21769194a91dSDouglas Gregor 21779194a91dSDouglas Gregor // Check whether we have an attribute name here. 21789194a91dSDouglas Gregor if (!Tok.is(MMToken::Identifier)) { 21799194a91dSDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_attribute); 21809194a91dSDouglas Gregor skipUntil(MMToken::RSquare); 21819194a91dSDouglas Gregor if (Tok.is(MMToken::RSquare)) 21829194a91dSDouglas Gregor consumeToken(); 21839194a91dSDouglas Gregor HadError = true; 21849194a91dSDouglas Gregor } 21859194a91dSDouglas Gregor 21869194a91dSDouglas Gregor // Decode the attribute name. 21879194a91dSDouglas Gregor AttributeKind Attribute 21889194a91dSDouglas Gregor = llvm::StringSwitch<AttributeKind>(Tok.getString()) 218935b13eceSDouglas Gregor .Case("exhaustive", AT_exhaustive) 219077944868SRichard Smith .Case("extern_c", AT_extern_c) 21919194a91dSDouglas Gregor .Case("system", AT_system) 21929194a91dSDouglas Gregor .Default(AT_unknown); 21939194a91dSDouglas Gregor switch (Attribute) { 21949194a91dSDouglas Gregor case AT_unknown: 21959194a91dSDouglas Gregor Diags.Report(Tok.getLocation(), diag::warn_mmap_unknown_attribute) 21969194a91dSDouglas Gregor << Tok.getString(); 21979194a91dSDouglas Gregor break; 21989194a91dSDouglas Gregor 21999194a91dSDouglas Gregor case AT_system: 22009194a91dSDouglas Gregor Attrs.IsSystem = true; 22019194a91dSDouglas Gregor break; 220235b13eceSDouglas Gregor 220377944868SRichard Smith case AT_extern_c: 220477944868SRichard Smith Attrs.IsExternC = true; 220577944868SRichard Smith break; 220677944868SRichard Smith 220735b13eceSDouglas Gregor case AT_exhaustive: 220835b13eceSDouglas Gregor Attrs.IsExhaustive = true; 220935b13eceSDouglas Gregor break; 22109194a91dSDouglas Gregor } 22119194a91dSDouglas Gregor consumeToken(); 22129194a91dSDouglas Gregor 22139194a91dSDouglas Gregor // Consume the ']'. 22149194a91dSDouglas Gregor if (!Tok.is(MMToken::RSquare)) { 22159194a91dSDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rsquare); 22169194a91dSDouglas Gregor Diags.Report(LSquareLoc, diag::note_mmap_lsquare_match); 22179194a91dSDouglas Gregor skipUntil(MMToken::RSquare); 22189194a91dSDouglas Gregor HadError = true; 22199194a91dSDouglas Gregor } 22209194a91dSDouglas Gregor 22219194a91dSDouglas Gregor if (Tok.is(MMToken::RSquare)) 22229194a91dSDouglas Gregor consumeToken(); 22239194a91dSDouglas Gregor } 22249194a91dSDouglas Gregor 22259194a91dSDouglas Gregor return HadError; 22269194a91dSDouglas Gregor } 22279194a91dSDouglas Gregor 2228718292f2SDouglas Gregor /// \brief Parse a module map file. 2229718292f2SDouglas Gregor /// 2230718292f2SDouglas Gregor /// module-map-file: 2231718292f2SDouglas Gregor /// module-declaration* 2232718292f2SDouglas Gregor bool ModuleMapParser::parseModuleMapFile() { 2233718292f2SDouglas Gregor do { 2234718292f2SDouglas Gregor switch (Tok.Kind) { 2235718292f2SDouglas Gregor case MMToken::EndOfFile: 2236718292f2SDouglas Gregor return HadError; 2237718292f2SDouglas Gregor 2238e7ab3669SDouglas Gregor case MMToken::ExplicitKeyword: 223997292843SDaniel Jasper case MMToken::ExternKeyword: 2240718292f2SDouglas Gregor case MMToken::ModuleKeyword: 2241755b2055SDouglas Gregor case MMToken::FrameworkKeyword: 2242718292f2SDouglas Gregor parseModuleDecl(); 2243718292f2SDouglas Gregor break; 2244718292f2SDouglas Gregor 22451fb5c3a6SDouglas Gregor case MMToken::Comma: 224635b13eceSDouglas Gregor case MMToken::ConfigMacros: 2247fb912657SDouglas Gregor case MMToken::Conflict: 2248a3feee2aSRichard Smith case MMToken::Exclaim: 224959527666SDouglas Gregor case MMToken::ExcludeKeyword: 22502b82c2a5SDouglas Gregor case MMToken::ExportKeyword: 2251718292f2SDouglas Gregor case MMToken::HeaderKeyword: 2252718292f2SDouglas Gregor case MMToken::Identifier: 2253718292f2SDouglas Gregor case MMToken::LBrace: 22546ddfca91SDouglas Gregor case MMToken::LinkKeyword: 2255a686e1b0SDouglas Gregor case MMToken::LSquare: 22562b82c2a5SDouglas Gregor case MMToken::Period: 2257b53e5483SLawrence Crowl case MMToken::PrivateKeyword: 2258718292f2SDouglas Gregor case MMToken::RBrace: 2259a686e1b0SDouglas Gregor case MMToken::RSquare: 22601fb5c3a6SDouglas Gregor case MMToken::RequiresKeyword: 22612b82c2a5SDouglas Gregor case MMToken::Star: 2262718292f2SDouglas Gregor case MMToken::StringLiteral: 2263718292f2SDouglas Gregor case MMToken::UmbrellaKeyword: 2264ba7f2f71SDaniel Jasper case MMToken::UseKeyword: 2265718292f2SDouglas Gregor Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module); 2266718292f2SDouglas Gregor HadError = true; 2267718292f2SDouglas Gregor consumeToken(); 2268718292f2SDouglas Gregor break; 2269718292f2SDouglas Gregor } 2270718292f2SDouglas Gregor } while (true); 2271718292f2SDouglas Gregor } 2272718292f2SDouglas Gregor 2273963c5535SDouglas Gregor bool ModuleMap::parseModuleMapFile(const FileEntry *File, bool IsSystem) { 22744ddf2221SDouglas Gregor llvm::DenseMap<const FileEntry *, bool>::iterator Known 22754ddf2221SDouglas Gregor = ParsedModuleMap.find(File); 22764ddf2221SDouglas Gregor if (Known != ParsedModuleMap.end()) 22774ddf2221SDouglas Gregor return Known->second; 22784ddf2221SDouglas Gregor 2279d2d442caSCraig Topper assert(Target && "Missing target information"); 2280cb69b57bSBen Langmuir auto FileCharacter = IsSystem ? SrcMgr::C_System : SrcMgr::C_User; 2281cb69b57bSBen Langmuir FileID ID = SourceMgr.createFileID(File, SourceLocation(), FileCharacter); 22821f76c4e8SManuel Klimek const llvm::MemoryBuffer *Buffer = SourceMgr.getBuffer(ID); 2283718292f2SDouglas Gregor if (!Buffer) 22844ddf2221SDouglas Gregor return ParsedModuleMap[File] = true; 2285718292f2SDouglas Gregor 2286984e1df7SBen Langmuir // Find the directory for the module. For frameworks, that may require going 2287984e1df7SBen Langmuir // up from the 'Modules' directory. 2288984e1df7SBen Langmuir const DirectoryEntry *Dir = File->getDir(); 2289984e1df7SBen Langmuir StringRef DirName(Dir->getName()); 2290984e1df7SBen Langmuir if (llvm::sys::path::filename(DirName) == "Modules") { 2291984e1df7SBen Langmuir DirName = llvm::sys::path::parent_path(DirName); 2292984e1df7SBen Langmuir if (DirName.endswith(".framework")) 2293984e1df7SBen Langmuir Dir = SourceMgr.getFileManager().getDirectory(DirName); 2294984e1df7SBen Langmuir assert(Dir && "parent must exist"); 2295984e1df7SBen Langmuir } 2296984e1df7SBen Langmuir 2297718292f2SDouglas Gregor // Parse this module map file. 22981f76c4e8SManuel Klimek Lexer L(ID, SourceMgr.getBuffer(ID), SourceMgr, MMapLangOpts); 2299beee15e7SBen Langmuir ModuleMapParser Parser(L, SourceMgr, Target, Diags, *this, File, Dir, 2300963c5535SDouglas Gregor BuiltinIncludeDir, IsSystem); 2301718292f2SDouglas Gregor bool Result = Parser.parseModuleMapFile(); 23024ddf2221SDouglas Gregor ParsedModuleMap[File] = Result; 2303718292f2SDouglas Gregor return Result; 2304718292f2SDouglas Gregor } 2305