1 //===--- ModuleMap.cpp - Describe the layout of modules ---------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the ModuleMap implementation, which describes the layout
11 // of a module as it relates to headers.
13 //===----------------------------------------------------------------------===//
14 #include "clang/Lex/ModuleMap.h"
15 #include "clang/Basic/CharInfo.h"
16 #include "clang/Basic/Diagnostic.h"
17 #include "clang/Basic/DiagnosticOptions.h"
18 #include "clang/Basic/FileManager.h"
19 #include "clang/Basic/TargetInfo.h"
20 #include "clang/Basic/TargetOptions.h"
21 #include "clang/Lex/HeaderSearch.h"
22 #include "clang/Lex/LexDiagnostic.h"
23 #include "clang/Lex/Lexer.h"
24 #include "clang/Lex/LiteralSupport.h"
25 #include "llvm/ADT/StringRef.h"
26 #include "llvm/ADT/StringSwitch.h"
27 #include "llvm/Support/Allocator.h"
28 #include "llvm/Support/FileSystem.h"
29 #include "llvm/Support/Host.h"
30 #include "llvm/Support/PathV2.h"
31 #include "llvm/Support/raw_ostream.h"
33 #if defined(LLVM_ON_UNIX)
36 using namespace clang;
39 ModuleMap::resolveExport(Module *Mod,
40 const Module::UnresolvedExportDecl &Unresolved,
41 bool Complain) const {
42 // We may have just a wildcard.
43 if (Unresolved.Id.empty()) {
44 assert(Unresolved.Wildcard && "Invalid unresolved export");
45 return Module::ExportDecl(0, true);
48 // Resolve the module-id.
49 Module *Context = resolveModuleId(Unresolved.Id, Mod, Complain);
51 return Module::ExportDecl();
53 return Module::ExportDecl(Context, Unresolved.Wildcard);
56 Module *ModuleMap::resolveModuleId(const ModuleId &Id, Module *Mod,
57 bool Complain) const {
58 // Find the starting module.
59 Module *Context = lookupModuleUnqualified(Id[0].first, Mod);
62 Diags->Report(Id[0].second, diag::err_mmap_missing_module_unqualified)
63 << Id[0].first << Mod->getFullModuleName();
68 // Dig into the module path.
69 for (unsigned I = 1, N = Id.size(); I != N; ++I) {
70 Module *Sub = lookupModuleQualified(Id[I].first, Context);
73 Diags->Report(Id[I].second, diag::err_mmap_missing_module_qualified)
74 << Id[I].first << Context->getFullModuleName()
75 << SourceRange(Id[0].second, Id[I-1].second);
86 ModuleMap::ModuleMap(FileManager &FileMgr, DiagnosticConsumer &DC,
87 const LangOptions &LangOpts, const TargetInfo *Target,
88 HeaderSearch &HeaderInfo)
89 : LangOpts(LangOpts), Target(Target), HeaderInfo(HeaderInfo),
92 IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(new DiagnosticIDs);
93 Diags = IntrusiveRefCntPtr<DiagnosticsEngine>(
94 new DiagnosticsEngine(DiagIDs, new DiagnosticOptions));
95 Diags->setClient(new ForwardingDiagnosticConsumer(DC),
96 /*ShouldOwnClient=*/true);
97 SourceMgr = new SourceManager(*Diags, FileMgr);
100 ModuleMap::~ModuleMap() {
101 for (llvm::StringMap<Module *>::iterator I = Modules.begin(),
102 IEnd = Modules.end();
104 delete I->getValue();
110 void ModuleMap::setTarget(const TargetInfo &Target) {
111 assert((!this->Target || this->Target == &Target) &&
112 "Improper target override");
113 this->Target = &Target;
116 /// \brief "Sanitize" a filename so that it can be used as an identifier.
117 static StringRef sanitizeFilenameAsIdentifier(StringRef Name,
118 SmallVectorImpl<char> &Buffer) {
122 if (!isValidIdentifier(Name)) {
123 // If we don't already have something with the form of an identifier,
124 // create a buffer with the sanitized name.
126 if (isDigit(Name[0]))
127 Buffer.push_back('_');
128 Buffer.reserve(Buffer.size() + Name.size());
129 for (unsigned I = 0, N = Name.size(); I != N; ++I) {
130 if (isIdentifierBody(Name[I]))
131 Buffer.push_back(Name[I]);
133 Buffer.push_back('_');
136 Name = StringRef(Buffer.data(), Buffer.size());
139 while (llvm::StringSwitch<bool>(Name)
140 #define KEYWORD(Keyword,Conditions) .Case(#Keyword, true)
141 #define ALIAS(Keyword, AliasOf, Conditions) .Case(Keyword, true)
142 #include "clang/Basic/TokenKinds.def"
144 if (Name.data() != Buffer.data())
145 Buffer.append(Name.begin(), Name.end());
146 Buffer.push_back('_');
147 Name = StringRef(Buffer.data(), Buffer.size());
153 /// \brief Determine whether the given file name is the name of a builtin
154 /// header, supplied by Clang to replace, override, or augment existing system
156 static bool isBuiltinHeader(StringRef FileName) {
157 return llvm::StringSwitch<bool>(FileName)
158 .Case("float.h", true)
159 .Case("iso646.h", true)
160 .Case("limits.h", true)
161 .Case("stdalign.h", true)
162 .Case("stdarg.h", true)
163 .Case("stdbool.h", true)
164 .Case("stddef.h", true)
165 .Case("stdint.h", true)
166 .Case("tgmath.h", true)
167 .Case("unwind.h", true)
171 Module *ModuleMap::findModuleForHeader(const FileEntry *File) {
172 HeadersMap::iterator Known = Headers.find(File);
173 if (Known != Headers.end()) {
174 // If a header is not available, don't report that it maps to anything.
175 if (!Known->second.isAvailable())
178 return Known->second.getModule();
181 // If we've found a builtin header within Clang's builtin include directory,
182 // load all of the module maps to see if it will get associated with a
183 // specific module (e.g., in /usr/include).
184 if (File->getDir() == BuiltinIncludeDir &&
185 isBuiltinHeader(llvm::sys::path::filename(File->getName()))) {
186 SmallVector<Module *, 4> AllModules;
187 HeaderInfo.collectAllModules(AllModules);
190 Known = Headers.find(File);
191 if (Known != Headers.end()) {
192 // If a header is not available, don't report that it maps to anything.
193 if (!Known->second.isAvailable())
196 return Known->second.getModule();
200 const DirectoryEntry *Dir = File->getDir();
201 SmallVector<const DirectoryEntry *, 2> SkippedDirs;
203 // Note: as an egregious but useful hack we use the real path here, because
204 // frameworks moving from top-level frameworks to embedded frameworks tend
205 // to be symlinked from the top-level location to the embedded location,
206 // and we need to resolve lookups as if we had found the embedded location.
207 StringRef DirName = SourceMgr->getFileManager().getCanonicalName(Dir);
209 // Keep walking up the directory hierarchy, looking for a directory with
210 // an umbrella header.
212 llvm::DenseMap<const DirectoryEntry *, Module *>::iterator KnownDir
213 = UmbrellaDirs.find(Dir);
214 if (KnownDir != UmbrellaDirs.end()) {
215 Module *Result = KnownDir->second;
217 // Search up the module stack until we find a module with an umbrella
219 Module *UmbrellaModule = Result;
220 while (!UmbrellaModule->getUmbrellaDir() && UmbrellaModule->Parent)
221 UmbrellaModule = UmbrellaModule->Parent;
223 if (UmbrellaModule->InferSubmodules) {
224 // Infer submodules for each of the directories we found between
225 // the directory of the umbrella header and the directory where
226 // the actual header is located.
227 bool Explicit = UmbrellaModule->InferExplicitSubmodules;
229 for (unsigned I = SkippedDirs.size(); I != 0; --I) {
230 // Find or create the module that corresponds to this directory name.
231 SmallString<32> NameBuf;
232 StringRef Name = sanitizeFilenameAsIdentifier(
233 llvm::sys::path::stem(SkippedDirs[I-1]->getName()),
235 Result = findOrCreateModule(Name, Result, /*IsFramework=*/false,
238 // Associate the module and the directory.
239 UmbrellaDirs[SkippedDirs[I-1]] = Result;
241 // If inferred submodules export everything they import, add a
242 // wildcard to the set of exports.
243 if (UmbrellaModule->InferExportWildcard && Result->Exports.empty())
244 Result->Exports.push_back(Module::ExportDecl(0, true));
247 // Infer a submodule with the same name as this header file.
248 SmallString<32> NameBuf;
249 StringRef Name = sanitizeFilenameAsIdentifier(
250 llvm::sys::path::stem(File->getName()), NameBuf);
251 Result = findOrCreateModule(Name, Result, /*IsFramework=*/false,
253 Result->addTopHeader(File);
255 // If inferred submodules export everything they import, add a
256 // wildcard to the set of exports.
257 if (UmbrellaModule->InferExportWildcard && Result->Exports.empty())
258 Result->Exports.push_back(Module::ExportDecl(0, true));
260 // Record each of the directories we stepped through as being part of
261 // the module we found, since the umbrella header covers them all.
262 for (unsigned I = 0, N = SkippedDirs.size(); I != N; ++I)
263 UmbrellaDirs[SkippedDirs[I]] = Result;
266 Headers[File] = KnownHeader(Result, /*Excluded=*/false);
268 // If a header corresponds to an unavailable module, don't report
269 // that it maps to anything.
270 if (!Result->isAvailable())
276 SkippedDirs.push_back(Dir);
278 // Retrieve our parent path.
279 DirName = llvm::sys::path::parent_path(DirName);
283 // Resolve the parent path to a directory entry.
284 Dir = SourceMgr->getFileManager().getDirectory(DirName);
290 bool ModuleMap::isHeaderInUnavailableModule(const FileEntry *Header) const {
291 HeadersMap::const_iterator Known = Headers.find(Header);
292 if (Known != Headers.end())
293 return !Known->second.isAvailable();
295 const DirectoryEntry *Dir = Header->getDir();
296 SmallVector<const DirectoryEntry *, 2> SkippedDirs;
297 StringRef DirName = Dir->getName();
299 // Keep walking up the directory hierarchy, looking for a directory with
300 // an umbrella header.
302 llvm::DenseMap<const DirectoryEntry *, Module *>::const_iterator KnownDir
303 = UmbrellaDirs.find(Dir);
304 if (KnownDir != UmbrellaDirs.end()) {
305 Module *Found = KnownDir->second;
306 if (!Found->isAvailable())
309 // Search up the module stack until we find a module with an umbrella
311 Module *UmbrellaModule = Found;
312 while (!UmbrellaModule->getUmbrellaDir() && UmbrellaModule->Parent)
313 UmbrellaModule = UmbrellaModule->Parent;
315 if (UmbrellaModule->InferSubmodules) {
316 for (unsigned I = SkippedDirs.size(); I != 0; --I) {
317 // Find or create the module that corresponds to this directory name.
318 SmallString<32> NameBuf;
319 StringRef Name = sanitizeFilenameAsIdentifier(
320 llvm::sys::path::stem(SkippedDirs[I-1]->getName()),
322 Found = lookupModuleQualified(Name, Found);
325 if (!Found->isAvailable())
329 // Infer a submodule with the same name as this header file.
330 SmallString<32> NameBuf;
331 StringRef Name = sanitizeFilenameAsIdentifier(
332 llvm::sys::path::stem(Header->getName()),
334 Found = lookupModuleQualified(Name, Found);
339 return !Found->isAvailable();
342 SkippedDirs.push_back(Dir);
344 // Retrieve our parent path.
345 DirName = llvm::sys::path::parent_path(DirName);
349 // Resolve the parent path to a directory entry.
350 Dir = SourceMgr->getFileManager().getDirectory(DirName);
356 Module *ModuleMap::findModule(StringRef Name) const {
357 llvm::StringMap<Module *>::const_iterator Known = Modules.find(Name);
358 if (Known != Modules.end())
359 return Known->getValue();
364 Module *ModuleMap::lookupModuleUnqualified(StringRef Name,
365 Module *Context) const {
366 for(; Context; Context = Context->Parent) {
367 if (Module *Sub = lookupModuleQualified(Name, Context))
371 return findModule(Name);
374 Module *ModuleMap::lookupModuleQualified(StringRef Name, Module *Context) const{
376 return findModule(Name);
378 return Context->findSubmodule(Name);
381 std::pair<Module *, bool>
382 ModuleMap::findOrCreateModule(StringRef Name, Module *Parent, bool IsFramework,
384 // Try to find an existing module with this name.
385 if (Module *Sub = lookupModuleQualified(Name, Parent))
386 return std::make_pair(Sub, false);
388 // Create a new module with this name.
389 Module *Result = new Module(Name, SourceLocation(), Parent, IsFramework,
392 Modules[Name] = Result;
393 return std::make_pair(Result, true);
396 bool ModuleMap::canInferFrameworkModule(const DirectoryEntry *ParentDir,
397 StringRef Name, bool &IsSystem) const {
398 // Check whether we have already looked into the parent directory
400 llvm::DenseMap<const DirectoryEntry *, InferredDirectory>::const_iterator
401 inferred = InferredDirectories.find(ParentDir);
402 if (inferred == InferredDirectories.end())
405 if (!inferred->second.InferModules)
408 // We're allowed to infer for this directory, but make sure it's okay
409 // to infer this particular module.
410 bool canInfer = std::find(inferred->second.ExcludedModules.begin(),
411 inferred->second.ExcludedModules.end(),
412 Name) == inferred->second.ExcludedModules.end();
414 if (canInfer && inferred->second.InferSystemModules)
420 /// \brief For a framework module, infer the framework against which we
422 static void inferFrameworkLink(Module *Mod, const DirectoryEntry *FrameworkDir,
423 FileManager &FileMgr) {
424 assert(Mod->IsFramework && "Can only infer linking for framework modules");
425 assert(!Mod->isSubFramework() &&
426 "Can only infer linking for top-level frameworks");
428 SmallString<128> LibName;
429 LibName += FrameworkDir->getName();
430 llvm::sys::path::append(LibName, Mod->Name);
431 if (FileMgr.getFile(LibName)) {
432 Mod->LinkLibraries.push_back(Module::LinkLibrary(Mod->Name,
433 /*IsFramework=*/true));
438 ModuleMap::inferFrameworkModule(StringRef ModuleName,
439 const DirectoryEntry *FrameworkDir,
442 // Check whether we've already found this module.
443 if (Module *Mod = lookupModuleQualified(ModuleName, Parent))
446 FileManager &FileMgr = SourceMgr->getFileManager();
448 // If the framework has a parent path from which we're allowed to infer
449 // a framework module, do so.
451 // Determine whether we're allowed to infer a module map.
453 // Note: as an egregious but useful hack we use the real path here, because
454 // we might be looking at an embedded framework that symlinks out to a
455 // top-level framework, and we need to infer as if we were naming the
456 // top-level framework.
457 StringRef FrameworkDirName
458 = SourceMgr->getFileManager().getCanonicalName(FrameworkDir);
460 bool canInfer = false;
461 if (llvm::sys::path::has_parent_path(FrameworkDirName)) {
462 // Figure out the parent path.
463 StringRef Parent = llvm::sys::path::parent_path(FrameworkDirName);
464 if (const DirectoryEntry *ParentDir = FileMgr.getDirectory(Parent)) {
465 // Check whether we have already looked into the parent directory
467 llvm::DenseMap<const DirectoryEntry *, InferredDirectory>::const_iterator
468 inferred = InferredDirectories.find(ParentDir);
469 if (inferred == InferredDirectories.end()) {
470 // We haven't looked here before. Load a module map, if there is
472 SmallString<128> ModMapPath = Parent;
473 llvm::sys::path::append(ModMapPath, "module.map");
474 if (const FileEntry *ModMapFile = FileMgr.getFile(ModMapPath)) {
475 parseModuleMapFile(ModMapFile);
476 inferred = InferredDirectories.find(ParentDir);
479 if (inferred == InferredDirectories.end())
480 inferred = InferredDirectories.insert(
481 std::make_pair(ParentDir, InferredDirectory())).first;
484 if (inferred->second.InferModules) {
485 // We're allowed to infer for this directory, but make sure it's okay
486 // to infer this particular module.
487 StringRef Name = llvm::sys::path::stem(FrameworkDirName);
488 canInfer = std::find(inferred->second.ExcludedModules.begin(),
489 inferred->second.ExcludedModules.end(),
490 Name) == inferred->second.ExcludedModules.end();
492 if (inferred->second.InferSystemModules)
498 // If we're not allowed to infer a framework module, don't.
504 // Look for an umbrella header.
505 SmallString<128> UmbrellaName = StringRef(FrameworkDir->getName());
506 llvm::sys::path::append(UmbrellaName, "Headers");
507 llvm::sys::path::append(UmbrellaName, ModuleName + ".h");
508 const FileEntry *UmbrellaHeader = FileMgr.getFile(UmbrellaName);
510 // FIXME: If there's no umbrella header, we could probably scan the
511 // framework to load *everything*. But, it's not clear that this is a good
516 Module *Result = new Module(ModuleName, SourceLocation(), Parent,
517 /*IsFramework=*/true, /*IsExplicit=*/false);
519 Result->IsSystem = IsSystem;
522 Modules[ModuleName] = Result;
524 // umbrella header "umbrella-header-name"
525 Result->Umbrella = UmbrellaHeader;
526 Headers[UmbrellaHeader] = KnownHeader(Result, /*Excluded=*/false);
527 UmbrellaDirs[UmbrellaHeader->getDir()] = Result;
530 Result->Exports.push_back(Module::ExportDecl(0, true));
532 // module * { export * }
533 Result->InferSubmodules = true;
534 Result->InferExportWildcard = true;
536 // Look for subframeworks.
538 SmallString<128> SubframeworksDirName
539 = StringRef(FrameworkDir->getName());
540 llvm::sys::path::append(SubframeworksDirName, "Frameworks");
541 SmallString<128> SubframeworksDirNameNative;
542 llvm::sys::path::native(SubframeworksDirName.str(),
543 SubframeworksDirNameNative);
544 for (llvm::sys::fs::directory_iterator
545 Dir(SubframeworksDirNameNative.str(), EC), DirEnd;
546 Dir != DirEnd && !EC; Dir.increment(EC)) {
547 if (!StringRef(Dir->path()).endswith(".framework"))
550 if (const DirectoryEntry *SubframeworkDir
551 = FileMgr.getDirectory(Dir->path())) {
552 // Note: as an egregious but useful hack, we use the real path here and
553 // check whether it is actually a subdirectory of the parent directory.
554 // This will not be the case if the 'subframework' is actually a symlink
555 // out to a top-level framework.
556 StringRef SubframeworkDirName = FileMgr.getCanonicalName(SubframeworkDir);
557 bool FoundParent = false;
559 // Get the parent directory name.
561 = llvm::sys::path::parent_path(SubframeworkDirName);
562 if (SubframeworkDirName.empty())
565 if (FileMgr.getDirectory(SubframeworkDirName) == FrameworkDir) {
574 // FIXME: Do we want to warn about subframeworks without umbrella headers?
575 SmallString<32> NameBuf;
576 inferFrameworkModule(sanitizeFilenameAsIdentifier(
577 llvm::sys::path::stem(Dir->path()), NameBuf),
578 SubframeworkDir, IsSystem, Result);
582 // If the module is a top-level framework, automatically link against the
584 if (!Result->isSubFramework()) {
585 inferFrameworkLink(Result, FrameworkDir, FileMgr);
591 void ModuleMap::setUmbrellaHeader(Module *Mod, const FileEntry *UmbrellaHeader){
592 Headers[UmbrellaHeader] = KnownHeader(Mod, /*Excluded=*/false);
593 Mod->Umbrella = UmbrellaHeader;
594 UmbrellaDirs[UmbrellaHeader->getDir()] = Mod;
597 void ModuleMap::setUmbrellaDir(Module *Mod, const DirectoryEntry *UmbrellaDir) {
598 Mod->Umbrella = UmbrellaDir;
599 UmbrellaDirs[UmbrellaDir] = Mod;
602 void ModuleMap::addHeader(Module *Mod, const FileEntry *Header,
605 Mod->ExcludedHeaders.push_back(Header);
607 Mod->Headers.push_back(Header);
608 HeaderInfo.MarkFileModuleHeader(Header);
610 Headers[Header] = KnownHeader(Mod, Excluded);
614 ModuleMap::getContainingModuleMapFile(Module *Module) const {
615 if (Module->DefinitionLoc.isInvalid() || !SourceMgr)
618 return SourceMgr->getFileEntryForID(
619 SourceMgr->getFileID(Module->DefinitionLoc));
622 void ModuleMap::dump() {
623 llvm::errs() << "Modules:";
624 for (llvm::StringMap<Module *>::iterator M = Modules.begin(),
625 MEnd = Modules.end();
627 M->getValue()->print(llvm::errs(), 2);
629 llvm::errs() << "Headers:";
630 for (HeadersMap::iterator H = Headers.begin(), HEnd = Headers.end();
632 llvm::errs() << " \"" << H->first->getName() << "\" -> "
633 << H->second.getModule()->getFullModuleName() << "\n";
637 bool ModuleMap::resolveExports(Module *Mod, bool Complain) {
638 bool HadError = false;
639 for (unsigned I = 0, N = Mod->UnresolvedExports.size(); I != N; ++I) {
640 Module::ExportDecl Export = resolveExport(Mod, Mod->UnresolvedExports[I],
642 if (Export.getPointer() || Export.getInt())
643 Mod->Exports.push_back(Export);
647 Mod->UnresolvedExports.clear();
651 bool ModuleMap::resolveConflicts(Module *Mod, bool Complain) {
652 bool HadError = false;
653 for (unsigned I = 0, N = Mod->UnresolvedConflicts.size(); I != N; ++I) {
654 Module *OtherMod = resolveModuleId(Mod->UnresolvedConflicts[I].Id,
661 Module::Conflict Conflict;
662 Conflict.Other = OtherMod;
663 Conflict.Message = Mod->UnresolvedConflicts[I].Message;
664 Mod->Conflicts.push_back(Conflict);
666 Mod->UnresolvedConflicts.clear();
670 Module *ModuleMap::inferModuleFromLocation(FullSourceLoc Loc) {
674 // Use the expansion location to determine which module we're in.
675 FullSourceLoc ExpansionLoc = Loc.getExpansionLoc();
676 if (!ExpansionLoc.isFileID())
680 const SourceManager &SrcMgr = Loc.getManager();
681 FileID ExpansionFileID = ExpansionLoc.getFileID();
683 while (const FileEntry *ExpansionFile
684 = SrcMgr.getFileEntryForID(ExpansionFileID)) {
685 // Find the module that owns this header (if any).
686 if (Module *Mod = findModuleForHeader(ExpansionFile))
689 // No module owns this header, so look up the inclusion chain to see if
690 // any included header has an associated module.
691 SourceLocation IncludeLoc = SrcMgr.getIncludeLoc(ExpansionFileID);
692 if (IncludeLoc.isInvalid())
695 ExpansionFileID = SrcMgr.getFileID(IncludeLoc);
701 //----------------------------------------------------------------------------//
702 // Module map file parser
703 //----------------------------------------------------------------------------//
706 /// \brief A token in a module map file.
733 unsigned StringLength;
734 const char *StringData;
743 bool is(TokenKind K) const { return Kind == K; }
745 SourceLocation getLocation() const {
746 return SourceLocation::getFromRawEncoding(Location);
749 StringRef getString() const {
750 return StringRef(StringData, StringLength);
754 /// \brief The set of attributes that can be attached to a module.
756 Attributes() : IsSystem(), IsExhaustive() { }
758 /// \brief Whether this is a system module.
759 unsigned IsSystem : 1;
761 /// \brief Whether this is an exhaustive set of configuration macros.
762 unsigned IsExhaustive : 1;
766 class ModuleMapParser {
768 SourceManager &SourceMgr;
770 /// \brief Default target information, used only for string literal
772 const TargetInfo *Target;
774 DiagnosticsEngine &Diags;
777 /// \brief The directory that this module map resides in.
778 const DirectoryEntry *Directory;
780 /// \brief The directory containing Clang-supplied headers.
781 const DirectoryEntry *BuiltinIncludeDir;
783 /// \brief Whether an error occurred.
786 /// \brief Stores string data for the various string literals referenced
788 llvm::BumpPtrAllocator StringData;
790 /// \brief The current token.
793 /// \brief The active module.
794 Module *ActiveModule;
796 /// \brief Consume the current token and return its location.
797 SourceLocation consumeToken();
799 /// \brief Skip tokens until we reach the a token with the given kind
800 /// (or the end of the file).
801 void skipUntil(MMToken::TokenKind K);
803 typedef SmallVector<std::pair<std::string, SourceLocation>, 2> ModuleId;
804 bool parseModuleId(ModuleId &Id);
805 void parseModuleDecl();
806 void parseRequiresDecl();
807 void parseHeaderDecl(SourceLocation UmbrellaLoc, SourceLocation ExcludeLoc);
808 void parseUmbrellaDirDecl(SourceLocation UmbrellaLoc);
809 void parseExportDecl();
810 void parseLinkDecl();
811 void parseConfigMacros();
812 void parseConflict();
813 void parseInferredModuleDecl(bool Framework, bool Explicit);
814 bool parseOptionalAttributes(Attributes &Attrs);
816 const DirectoryEntry *getOverriddenHeaderSearchDir();
819 explicit ModuleMapParser(Lexer &L, SourceManager &SourceMgr,
820 const TargetInfo *Target,
821 DiagnosticsEngine &Diags,
823 const DirectoryEntry *Directory,
824 const DirectoryEntry *BuiltinIncludeDir)
825 : L(L), SourceMgr(SourceMgr), Target(Target), Diags(Diags), Map(Map),
826 Directory(Directory), BuiltinIncludeDir(BuiltinIncludeDir),
827 HadError(false), ActiveModule(0)
833 bool parseModuleMapFile();
837 SourceLocation ModuleMapParser::consumeToken() {
839 SourceLocation Result = Tok.getLocation();
843 L.LexFromRawLexer(LToken);
844 Tok.Location = LToken.getLocation().getRawEncoding();
845 switch (LToken.getKind()) {
846 case tok::raw_identifier:
847 Tok.StringData = LToken.getRawIdentifierData();
848 Tok.StringLength = LToken.getLength();
849 Tok.Kind = llvm::StringSwitch<MMToken::TokenKind>(Tok.getString())
850 .Case("config_macros", MMToken::ConfigMacros)
851 .Case("conflict", MMToken::Conflict)
852 .Case("exclude", MMToken::ExcludeKeyword)
853 .Case("explicit", MMToken::ExplicitKeyword)
854 .Case("export", MMToken::ExportKeyword)
855 .Case("framework", MMToken::FrameworkKeyword)
856 .Case("header", MMToken::HeaderKeyword)
857 .Case("link", MMToken::LinkKeyword)
858 .Case("module", MMToken::ModuleKeyword)
859 .Case("requires", MMToken::RequiresKeyword)
860 .Case("umbrella", MMToken::UmbrellaKeyword)
861 .Default(MMToken::Identifier);
865 Tok.Kind = MMToken::Comma;
869 Tok.Kind = MMToken::EndOfFile;
873 Tok.Kind = MMToken::LBrace;
877 Tok.Kind = MMToken::LSquare;
881 Tok.Kind = MMToken::Period;
885 Tok.Kind = MMToken::RBrace;
889 Tok.Kind = MMToken::RSquare;
893 Tok.Kind = MMToken::Star;
896 case tok::string_literal: {
897 if (LToken.hasUDSuffix()) {
898 Diags.Report(LToken.getLocation(), diag::err_invalid_string_udl);
903 // Parse the string literal.
904 LangOptions LangOpts;
905 StringLiteralParser StringLiteral(<oken, 1, SourceMgr, LangOpts, *Target);
906 if (StringLiteral.hadError)
909 // Copy the string literal into our string data allocator.
910 unsigned Length = StringLiteral.GetStringLength();
911 char *Saved = StringData.Allocate<char>(Length + 1);
912 memcpy(Saved, StringLiteral.GetString().data(), Length);
916 Tok.Kind = MMToken::StringLiteral;
917 Tok.StringData = Saved;
918 Tok.StringLength = Length;
926 Diags.Report(LToken.getLocation(), diag::err_mmap_unknown_token);
934 void ModuleMapParser::skipUntil(MMToken::TokenKind K) {
935 unsigned braceDepth = 0;
936 unsigned squareDepth = 0;
939 case MMToken::EndOfFile:
942 case MMToken::LBrace:
943 if (Tok.is(K) && braceDepth == 0 && squareDepth == 0)
949 case MMToken::LSquare:
950 if (Tok.is(K) && braceDepth == 0 && squareDepth == 0)
956 case MMToken::RBrace:
963 case MMToken::RSquare:
971 if (braceDepth == 0 && squareDepth == 0 && Tok.is(K))
980 /// \brief Parse a module-id.
984 /// identifier '.' module-id
986 /// \returns true if an error occurred, false otherwise.
987 bool ModuleMapParser::parseModuleId(ModuleId &Id) {
990 if (Tok.is(MMToken::Identifier)) {
991 Id.push_back(std::make_pair(Tok.getString(), Tok.getLocation()));
994 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module_name);
998 if (!Tok.is(MMToken::Period))
1008 /// \brief Enumerates the known attributes.
1009 enum AttributeKind {
1010 /// \brief An unknown attribute.
1012 /// \brief The 'system' attribute.
1014 /// \brief The 'exhaustive' attribute.
1019 /// \brief Parse a module declaration.
1021 /// module-declaration:
1022 /// 'explicit'[opt] 'framework'[opt] 'module' module-id attributes[opt]
1023 /// { module-member* }
1026 /// requires-declaration
1027 /// header-declaration
1028 /// submodule-declaration
1029 /// export-declaration
1030 /// link-declaration
1032 /// submodule-declaration:
1033 /// module-declaration
1034 /// inferred-submodule-declaration
1035 void ModuleMapParser::parseModuleDecl() {
1036 assert(Tok.is(MMToken::ExplicitKeyword) || Tok.is(MMToken::ModuleKeyword) ||
1037 Tok.is(MMToken::FrameworkKeyword));
1038 // Parse 'explicit' or 'framework' keyword, if present.
1039 SourceLocation ExplicitLoc;
1040 bool Explicit = false;
1041 bool Framework = false;
1043 // Parse 'explicit' keyword, if present.
1044 if (Tok.is(MMToken::ExplicitKeyword)) {
1045 ExplicitLoc = consumeToken();
1049 // Parse 'framework' keyword, if present.
1050 if (Tok.is(MMToken::FrameworkKeyword)) {
1055 // Parse 'module' keyword.
1056 if (!Tok.is(MMToken::ModuleKeyword)) {
1057 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module);
1062 consumeToken(); // 'module' keyword
1064 // If we have a wildcard for the module name, this is an inferred submodule.
1066 if (Tok.is(MMToken::Star))
1067 return parseInferredModuleDecl(Framework, Explicit);
1069 // Parse the module name.
1071 if (parseModuleId(Id)) {
1077 if (Id.size() > 1) {
1078 Diags.Report(Id.front().second, diag::err_mmap_nested_submodule_id)
1079 << SourceRange(Id.front().second, Id.back().second);
1084 } else if (Id.size() == 1 && Explicit) {
1085 // Top-level modules can't be explicit.
1086 Diags.Report(ExplicitLoc, diag::err_mmap_explicit_top_level);
1088 ExplicitLoc = SourceLocation();
1092 Module *PreviousActiveModule = ActiveModule;
1093 if (Id.size() > 1) {
1094 // This module map defines a submodule. Go find the module of which it
1097 for (unsigned I = 0, N = Id.size() - 1; I != N; ++I) {
1098 if (Module *Next = Map.lookupModuleQualified(Id[I].first, ActiveModule)) {
1099 ActiveModule = Next;
1104 Diags.Report(Id[I].second, diag::err_mmap_missing_module_qualified)
1105 << Id[I].first << ActiveModule->getTopLevelModule();
1107 Diags.Report(Id[I].second, diag::err_mmap_expected_module_name);
1114 StringRef ModuleName = Id.back().first;
1115 SourceLocation ModuleNameLoc = Id.back().second;
1117 // Parse the optional attribute list.
1119 parseOptionalAttributes(Attrs);
1121 // Parse the opening brace.
1122 if (!Tok.is(MMToken::LBrace)) {
1123 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_lbrace)
1128 SourceLocation LBraceLoc = consumeToken();
1130 // Determine whether this (sub)module has already been defined.
1131 if (Module *Existing = Map.lookupModuleQualified(ModuleName, ActiveModule)) {
1132 if (Existing->DefinitionLoc.isInvalid() && !ActiveModule) {
1133 // Skip the module definition.
1134 skipUntil(MMToken::RBrace);
1135 if (Tok.is(MMToken::RBrace))
1138 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace);
1139 Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match);
1145 Diags.Report(ModuleNameLoc, diag::err_mmap_module_redefinition)
1147 Diags.Report(Existing->DefinitionLoc, diag::note_mmap_prev_definition);
1149 // Skip the module definition.
1150 skipUntil(MMToken::RBrace);
1151 if (Tok.is(MMToken::RBrace))
1158 // Start defining this module.
1159 ActiveModule = Map.findOrCreateModule(ModuleName, ActiveModule, Framework,
1161 ActiveModule->DefinitionLoc = ModuleNameLoc;
1163 ActiveModule->IsSystem = true;
1168 case MMToken::EndOfFile:
1169 case MMToken::RBrace:
1173 case MMToken::ConfigMacros:
1174 parseConfigMacros();
1177 case MMToken::Conflict:
1181 case MMToken::ExplicitKeyword:
1182 case MMToken::FrameworkKeyword:
1183 case MMToken::ModuleKeyword:
1187 case MMToken::ExportKeyword:
1191 case MMToken::RequiresKeyword:
1192 parseRequiresDecl();
1195 case MMToken::UmbrellaKeyword: {
1196 SourceLocation UmbrellaLoc = consumeToken();
1197 if (Tok.is(MMToken::HeaderKeyword))
1198 parseHeaderDecl(UmbrellaLoc, SourceLocation());
1200 parseUmbrellaDirDecl(UmbrellaLoc);
1204 case MMToken::ExcludeKeyword: {
1205 SourceLocation ExcludeLoc = consumeToken();
1206 if (Tok.is(MMToken::HeaderKeyword)) {
1207 parseHeaderDecl(SourceLocation(), ExcludeLoc);
1209 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header)
1215 case MMToken::HeaderKeyword:
1216 parseHeaderDecl(SourceLocation(), SourceLocation());
1219 case MMToken::LinkKeyword:
1224 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_member);
1230 if (Tok.is(MMToken::RBrace))
1233 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace);
1234 Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match);
1238 // If the active module is a top-level framework, and there are no link
1239 // libraries, automatically link against the framework.
1240 if (ActiveModule->IsFramework && !ActiveModule->isSubFramework() &&
1241 ActiveModule->LinkLibraries.empty()) {
1242 inferFrameworkLink(ActiveModule, Directory, SourceMgr.getFileManager());
1245 // We're done parsing this module. Pop back to the previous module.
1246 ActiveModule = PreviousActiveModule;
1249 /// \brief Parse a requires declaration.
1251 /// requires-declaration:
1252 /// 'requires' feature-list
1255 /// identifier ',' feature-list
1257 void ModuleMapParser::parseRequiresDecl() {
1258 assert(Tok.is(MMToken::RequiresKeyword));
1260 // Parse 'requires' keyword.
1263 // Parse the feature-list.
1265 if (!Tok.is(MMToken::Identifier)) {
1266 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_feature);
1271 // Consume the feature name.
1272 std::string Feature = Tok.getString();
1275 // Add this feature.
1276 ActiveModule->addRequirement(Feature, Map.LangOpts, *Map.Target);
1278 if (!Tok.is(MMToken::Comma))
1281 // Consume the comma.
1286 /// \brief Append to \p Paths the set of paths needed to get to the
1287 /// subframework in which the given module lives.
1288 static void appendSubframeworkPaths(Module *Mod,
1289 SmallVectorImpl<char> &Path) {
1290 // Collect the framework names from the given module to the top-level module.
1291 SmallVector<StringRef, 2> Paths;
1292 for (; Mod; Mod = Mod->Parent) {
1293 if (Mod->IsFramework)
1294 Paths.push_back(Mod->Name);
1300 // Add Frameworks/Name.framework for each subframework.
1301 for (unsigned I = Paths.size() - 1; I != 0; --I) {
1302 llvm::sys::path::append(Path, "Frameworks");
1303 llvm::sys::path::append(Path, Paths[I-1] + ".framework");
1307 /// \brief Parse a header declaration.
1309 /// header-declaration:
1310 /// 'umbrella'[opt] 'header' string-literal
1311 /// 'exclude'[opt] 'header' string-literal
1312 void ModuleMapParser::parseHeaderDecl(SourceLocation UmbrellaLoc,
1313 SourceLocation ExcludeLoc) {
1314 assert(Tok.is(MMToken::HeaderKeyword));
1317 bool Umbrella = UmbrellaLoc.isValid();
1318 bool Exclude = ExcludeLoc.isValid();
1319 assert(!(Umbrella && Exclude) && "Cannot have both 'umbrella' and 'exclude'");
1320 // Parse the header name.
1321 if (!Tok.is(MMToken::StringLiteral)) {
1322 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header)
1327 std::string FileName = Tok.getString();
1328 SourceLocation FileNameLoc = consumeToken();
1330 // Check whether we already have an umbrella.
1331 if (Umbrella && ActiveModule->Umbrella) {
1332 Diags.Report(FileNameLoc, diag::err_mmap_umbrella_clash)
1333 << ActiveModule->getFullModuleName();
1338 // Look for this file.
1339 const FileEntry *File = 0;
1340 const FileEntry *BuiltinFile = 0;
1341 SmallString<128> PathName;
1342 if (llvm::sys::path::is_absolute(FileName)) {
1343 PathName = FileName;
1344 File = SourceMgr.getFileManager().getFile(PathName);
1345 } else if (const DirectoryEntry *Dir = getOverriddenHeaderSearchDir()) {
1346 PathName = Dir->getName();
1347 llvm::sys::path::append(PathName, FileName);
1348 File = SourceMgr.getFileManager().getFile(PathName);
1350 // Search for the header file within the search directory.
1351 PathName = Directory->getName();
1352 unsigned PathLength = PathName.size();
1354 if (ActiveModule->isPartOfFramework()) {
1355 appendSubframeworkPaths(ActiveModule, PathName);
1357 // Check whether this file is in the public headers.
1358 llvm::sys::path::append(PathName, "Headers");
1359 llvm::sys::path::append(PathName, FileName);
1360 File = SourceMgr.getFileManager().getFile(PathName);
1363 // Check whether this file is in the private headers.
1364 PathName.resize(PathLength);
1365 llvm::sys::path::append(PathName, "PrivateHeaders");
1366 llvm::sys::path::append(PathName, FileName);
1367 File = SourceMgr.getFileManager().getFile(PathName);
1370 // Lookup for normal headers.
1371 llvm::sys::path::append(PathName, FileName);
1372 File = SourceMgr.getFileManager().getFile(PathName);
1374 // If this is a system module with a top-level header, this header
1375 // may have a counterpart (or replacement) in the set of headers
1376 // supplied by Clang. Find that builtin header.
1377 if (ActiveModule->IsSystem && !Umbrella && BuiltinIncludeDir &&
1378 BuiltinIncludeDir != Directory && isBuiltinHeader(FileName)) {
1379 SmallString<128> BuiltinPathName(BuiltinIncludeDir->getName());
1380 llvm::sys::path::append(BuiltinPathName, FileName);
1381 BuiltinFile = SourceMgr.getFileManager().getFile(BuiltinPathName);
1383 // If Clang supplies this header but the underlying system does not,
1384 // just silently swap in our builtin version. Otherwise, we'll end
1385 // up adding both (later).
1386 if (!File && BuiltinFile) {
1394 // FIXME: We shouldn't be eagerly stat'ing every file named in a module map.
1395 // Come up with a lazy way to do this.
1397 if (ModuleMap::KnownHeader OwningModule = Map.Headers[File]) {
1398 Diags.Report(FileNameLoc, diag::err_mmap_header_conflict)
1399 << FileName << OwningModule.getModule()->getFullModuleName();
1401 } else if (Umbrella) {
1402 const DirectoryEntry *UmbrellaDir = File->getDir();
1403 if (Module *UmbrellaModule = Map.UmbrellaDirs[UmbrellaDir]) {
1404 Diags.Report(UmbrellaLoc, diag::err_mmap_umbrella_clash)
1405 << UmbrellaModule->getFullModuleName();
1408 // Record this umbrella header.
1409 Map.setUmbrellaHeader(ActiveModule, File);
1412 // Record this header.
1413 Map.addHeader(ActiveModule, File, Exclude);
1415 // If there is a builtin counterpart to this file, add it now.
1417 Map.addHeader(ActiveModule, BuiltinFile, Exclude);
1419 } else if (!Exclude) {
1420 // Ignore excluded header files. They're optional anyway.
1422 Diags.Report(FileNameLoc, diag::err_mmap_header_not_found)
1423 << Umbrella << FileName;
1428 /// \brief Parse an umbrella directory declaration.
1430 /// umbrella-dir-declaration:
1431 /// umbrella string-literal
1432 void ModuleMapParser::parseUmbrellaDirDecl(SourceLocation UmbrellaLoc) {
1433 // Parse the directory name.
1434 if (!Tok.is(MMToken::StringLiteral)) {
1435 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header)
1441 std::string DirName = Tok.getString();
1442 SourceLocation DirNameLoc = consumeToken();
1444 // Check whether we already have an umbrella.
1445 if (ActiveModule->Umbrella) {
1446 Diags.Report(DirNameLoc, diag::err_mmap_umbrella_clash)
1447 << ActiveModule->getFullModuleName();
1452 // Look for this file.
1453 const DirectoryEntry *Dir = 0;
1454 if (llvm::sys::path::is_absolute(DirName))
1455 Dir = SourceMgr.getFileManager().getDirectory(DirName);
1457 SmallString<128> PathName;
1458 PathName = Directory->getName();
1459 llvm::sys::path::append(PathName, DirName);
1460 Dir = SourceMgr.getFileManager().getDirectory(PathName);
1464 Diags.Report(DirNameLoc, diag::err_mmap_umbrella_dir_not_found)
1470 if (Module *OwningModule = Map.UmbrellaDirs[Dir]) {
1471 Diags.Report(UmbrellaLoc, diag::err_mmap_umbrella_clash)
1472 << OwningModule->getFullModuleName();
1477 // Record this umbrella directory.
1478 Map.setUmbrellaDir(ActiveModule, Dir);
1481 /// \brief Parse a module export declaration.
1483 /// export-declaration:
1484 /// 'export' wildcard-module-id
1486 /// wildcard-module-id:
1489 /// identifier '.' wildcard-module-id
1490 void ModuleMapParser::parseExportDecl() {
1491 assert(Tok.is(MMToken::ExportKeyword));
1492 SourceLocation ExportLoc = consumeToken();
1494 // Parse the module-id with an optional wildcard at the end.
1495 ModuleId ParsedModuleId;
1496 bool Wildcard = false;
1498 if (Tok.is(MMToken::Identifier)) {
1499 ParsedModuleId.push_back(std::make_pair(Tok.getString(),
1500 Tok.getLocation()));
1503 if (Tok.is(MMToken::Period)) {
1511 if(Tok.is(MMToken::Star)) {
1517 Diags.Report(Tok.getLocation(), diag::err_mmap_export_module_id);
1522 Module::UnresolvedExportDecl Unresolved = {
1523 ExportLoc, ParsedModuleId, Wildcard
1525 ActiveModule->UnresolvedExports.push_back(Unresolved);
1528 /// \brief Parse a link declaration.
1530 /// module-declaration:
1531 /// 'link' 'framework'[opt] string-literal
1532 void ModuleMapParser::parseLinkDecl() {
1533 assert(Tok.is(MMToken::LinkKeyword));
1534 SourceLocation LinkLoc = consumeToken();
1536 // Parse the optional 'framework' keyword.
1537 bool IsFramework = false;
1538 if (Tok.is(MMToken::FrameworkKeyword)) {
1543 // Parse the library name
1544 if (!Tok.is(MMToken::StringLiteral)) {
1545 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_library_name)
1546 << IsFramework << SourceRange(LinkLoc);
1551 std::string LibraryName = Tok.getString();
1553 ActiveModule->LinkLibraries.push_back(Module::LinkLibrary(LibraryName,
1557 /// \brief Parse a configuration macro declaration.
1559 /// module-declaration:
1560 /// 'config_macros' attributes[opt] config-macro-list?
1562 /// config-macro-list:
1563 /// identifier (',' identifier)?
1564 void ModuleMapParser::parseConfigMacros() {
1565 assert(Tok.is(MMToken::ConfigMacros));
1566 SourceLocation ConfigMacrosLoc = consumeToken();
1568 // Only top-level modules can have configuration macros.
1569 if (ActiveModule->Parent) {
1570 Diags.Report(ConfigMacrosLoc, diag::err_mmap_config_macro_submodule);
1573 // Parse the optional attributes.
1575 parseOptionalAttributes(Attrs);
1576 if (Attrs.IsExhaustive && !ActiveModule->Parent) {
1577 ActiveModule->ConfigMacrosExhaustive = true;
1580 // If we don't have an identifier, we're done.
1581 if (!Tok.is(MMToken::Identifier))
1584 // Consume the first identifier.
1585 if (!ActiveModule->Parent) {
1586 ActiveModule->ConfigMacros.push_back(Tok.getString().str());
1591 // If there's a comma, consume it.
1592 if (!Tok.is(MMToken::Comma))
1596 // We expect to see a macro name here.
1597 if (!Tok.is(MMToken::Identifier)) {
1598 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_config_macro);
1602 // Consume the macro name.
1603 if (!ActiveModule->Parent) {
1604 ActiveModule->ConfigMacros.push_back(Tok.getString().str());
1610 /// \brief Format a module-id into a string.
1611 static std::string formatModuleId(const ModuleId &Id) {
1614 llvm::raw_string_ostream OS(result);
1616 for (unsigned I = 0, N = Id.size(); I != N; ++I) {
1626 /// \brief Parse a conflict declaration.
1628 /// module-declaration:
1629 /// 'conflict' module-id ',' string-literal
1630 void ModuleMapParser::parseConflict() {
1631 assert(Tok.is(MMToken::Conflict));
1632 SourceLocation ConflictLoc = consumeToken();
1633 Module::UnresolvedConflict Conflict;
1635 // Parse the module-id.
1636 if (parseModuleId(Conflict.Id))
1640 if (!Tok.is(MMToken::Comma)) {
1641 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_conflicts_comma)
1642 << SourceRange(ConflictLoc);
1647 // Parse the message.
1648 if (!Tok.is(MMToken::StringLiteral)) {
1649 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_conflicts_message)
1650 << formatModuleId(Conflict.Id);
1653 Conflict.Message = Tok.getString().str();
1656 // Add this unresolved conflict.
1657 ActiveModule->UnresolvedConflicts.push_back(Conflict);
1660 /// \brief Parse an inferred module declaration (wildcard modules).
1662 /// module-declaration:
1663 /// 'explicit'[opt] 'framework'[opt] 'module' * attributes[opt]
1664 /// { inferred-module-member* }
1666 /// inferred-module-member:
1668 /// 'exclude' identifier
1669 void ModuleMapParser::parseInferredModuleDecl(bool Framework, bool Explicit) {
1670 assert(Tok.is(MMToken::Star));
1671 SourceLocation StarLoc = consumeToken();
1672 bool Failed = false;
1674 // Inferred modules must be submodules.
1675 if (!ActiveModule && !Framework) {
1676 Diags.Report(StarLoc, diag::err_mmap_top_level_inferred_submodule);
1681 // Inferred modules must have umbrella directories.
1682 if (!Failed && !ActiveModule->getUmbrellaDir()) {
1683 Diags.Report(StarLoc, diag::err_mmap_inferred_no_umbrella);
1687 // Check for redefinition of an inferred module.
1688 if (!Failed && ActiveModule->InferSubmodules) {
1689 Diags.Report(StarLoc, diag::err_mmap_inferred_redef);
1690 if (ActiveModule->InferredSubmoduleLoc.isValid())
1691 Diags.Report(ActiveModule->InferredSubmoduleLoc,
1692 diag::note_mmap_prev_definition);
1696 // Check for the 'framework' keyword, which is not permitted here.
1698 Diags.Report(StarLoc, diag::err_mmap_inferred_framework_submodule);
1701 } else if (Explicit) {
1702 Diags.Report(StarLoc, diag::err_mmap_explicit_inferred_framework);
1706 // If there were any problems with this inferred submodule, skip its body.
1708 if (Tok.is(MMToken::LBrace)) {
1710 skipUntil(MMToken::RBrace);
1711 if (Tok.is(MMToken::RBrace))
1718 // Parse optional attributes.
1720 parseOptionalAttributes(Attrs);
1723 // Note that we have an inferred submodule.
1724 ActiveModule->InferSubmodules = true;
1725 ActiveModule->InferredSubmoduleLoc = StarLoc;
1726 ActiveModule->InferExplicitSubmodules = Explicit;
1728 // We'll be inferring framework modules for this directory.
1729 Map.InferredDirectories[Directory].InferModules = true;
1730 Map.InferredDirectories[Directory].InferSystemModules = Attrs.IsSystem;
1733 // Parse the opening brace.
1734 if (!Tok.is(MMToken::LBrace)) {
1735 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_lbrace_wildcard);
1739 SourceLocation LBraceLoc = consumeToken();
1741 // Parse the body of the inferred submodule.
1745 case MMToken::EndOfFile:
1746 case MMToken::RBrace:
1750 case MMToken::ExcludeKeyword: {
1752 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_inferred_member)
1753 << (ActiveModule != 0);
1759 if (!Tok.is(MMToken::Identifier)) {
1760 Diags.Report(Tok.getLocation(), diag::err_mmap_missing_exclude_name);
1764 Map.InferredDirectories[Directory].ExcludedModules
1765 .push_back(Tok.getString());
1770 case MMToken::ExportKeyword:
1771 if (!ActiveModule) {
1772 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_inferred_member)
1773 << (ActiveModule != 0);
1779 if (Tok.is(MMToken::Star))
1780 ActiveModule->InferExportWildcard = true;
1782 Diags.Report(Tok.getLocation(),
1783 diag::err_mmap_expected_export_wildcard);
1787 case MMToken::ExplicitKeyword:
1788 case MMToken::ModuleKeyword:
1789 case MMToken::HeaderKeyword:
1790 case MMToken::UmbrellaKeyword:
1792 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_inferred_member)
1793 << (ActiveModule != 0);
1799 if (Tok.is(MMToken::RBrace))
1802 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace);
1803 Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match);
1808 /// \brief Parse optional attributes.
1811 /// attribute attributes
1817 /// \param Attrs Will be filled in with the parsed attributes.
1819 /// \returns true if an error occurred, false otherwise.
1820 bool ModuleMapParser::parseOptionalAttributes(Attributes &Attrs) {
1821 bool HadError = false;
1823 while (Tok.is(MMToken::LSquare)) {
1825 SourceLocation LSquareLoc = consumeToken();
1827 // Check whether we have an attribute name here.
1828 if (!Tok.is(MMToken::Identifier)) {
1829 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_attribute);
1830 skipUntil(MMToken::RSquare);
1831 if (Tok.is(MMToken::RSquare))
1836 // Decode the attribute name.
1837 AttributeKind Attribute
1838 = llvm::StringSwitch<AttributeKind>(Tok.getString())
1839 .Case("exhaustive", AT_exhaustive)
1840 .Case("system", AT_system)
1841 .Default(AT_unknown);
1842 switch (Attribute) {
1844 Diags.Report(Tok.getLocation(), diag::warn_mmap_unknown_attribute)
1849 Attrs.IsSystem = true;
1853 Attrs.IsExhaustive = true;
1859 if (!Tok.is(MMToken::RSquare)) {
1860 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rsquare);
1861 Diags.Report(LSquareLoc, diag::note_mmap_lsquare_match);
1862 skipUntil(MMToken::RSquare);
1866 if (Tok.is(MMToken::RSquare))
1873 /// \brief If there is a specific header search directory due the presence
1874 /// of an umbrella directory, retrieve that directory. Otherwise, returns null.
1875 const DirectoryEntry *ModuleMapParser::getOverriddenHeaderSearchDir() {
1876 for (Module *Mod = ActiveModule; Mod; Mod = Mod->Parent) {
1877 // If we have an umbrella directory, use that.
1878 if (Mod->hasUmbrellaDir())
1879 return Mod->getUmbrellaDir();
1881 // If we have a framework directory, stop looking.
1882 if (Mod->IsFramework)
1889 /// \brief Parse a module map file.
1891 /// module-map-file:
1892 /// module-declaration*
1893 bool ModuleMapParser::parseModuleMapFile() {
1896 case MMToken::EndOfFile:
1899 case MMToken::ExplicitKeyword:
1900 case MMToken::ModuleKeyword:
1901 case MMToken::FrameworkKeyword:
1905 case MMToken::Comma:
1906 case MMToken::ConfigMacros:
1907 case MMToken::Conflict:
1908 case MMToken::ExcludeKeyword:
1909 case MMToken::ExportKeyword:
1910 case MMToken::HeaderKeyword:
1911 case MMToken::Identifier:
1912 case MMToken::LBrace:
1913 case MMToken::LinkKeyword:
1914 case MMToken::LSquare:
1915 case MMToken::Period:
1916 case MMToken::RBrace:
1917 case MMToken::RSquare:
1918 case MMToken::RequiresKeyword:
1920 case MMToken::StringLiteral:
1921 case MMToken::UmbrellaKeyword:
1922 Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module);
1930 bool ModuleMap::parseModuleMapFile(const FileEntry *File) {
1931 llvm::DenseMap<const FileEntry *, bool>::iterator Known
1932 = ParsedModuleMap.find(File);
1933 if (Known != ParsedModuleMap.end())
1934 return Known->second;
1936 assert(Target != 0 && "Missing target information");
1937 FileID ID = SourceMgr->createFileID(File, SourceLocation(), SrcMgr::C_User);
1938 const llvm::MemoryBuffer *Buffer = SourceMgr->getBuffer(ID);
1940 return ParsedModuleMap[File] = true;
1942 // Parse this module map file.
1943 Lexer L(ID, SourceMgr->getBuffer(ID), *SourceMgr, MMapLangOpts);
1944 Diags->getClient()->BeginSourceFile(MMapLangOpts);
1945 ModuleMapParser Parser(L, *SourceMgr, Target, *Diags, *this, File->getDir(),
1947 bool Result = Parser.parseModuleMapFile();
1948 Diags->getClient()->EndSourceFile();
1949 ParsedModuleMap[File] = Result;