ModuleMap.cpp 20 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676
  1. //===--- ModuleMap.cpp - Describe the layout of modules ---------*- C++ -*-===//
  2. //
  3. // The LLVM Compiler Infrastructure
  4. //
  5. // This file is distributed under the University of Illinois Open Source
  6. // License. See LICENSE.TXT for details.
  7. //
  8. //===----------------------------------------------------------------------===//
  9. //
  10. // This file defines the ModuleMap implementation, which describes the layout
  11. // of a module as it relates to headers.
  12. //
  13. //===----------------------------------------------------------------------===//
  14. #include "clang/Lex/ModuleMap.h"
  15. #include "clang/Lex/Lexer.h"
  16. #include "clang/Lex/LiteralSupport.h"
  17. #include "clang/Lex/LexDiagnostic.h"
  18. #include "clang/Basic/Diagnostic.h"
  19. #include "clang/Basic/FileManager.h"
  20. #include "clang/Basic/TargetInfo.h"
  21. #include "clang/Basic/TargetOptions.h"
  22. #include "llvm/Support/Allocator.h"
  23. #include "llvm/Support/Host.h"
  24. #include "llvm/Support/PathV2.h"
  25. #include "llvm/Support/raw_ostream.h"
  26. #include "llvm/ADT/StringRef.h"
  27. #include "llvm/ADT/StringSwitch.h"
  28. using namespace clang;
  29. ModuleMap::ModuleMap(FileManager &FileMgr, const DiagnosticConsumer &DC) {
  30. llvm::IntrusiveRefCntPtr<DiagnosticIDs> DiagIDs(new DiagnosticIDs);
  31. Diags = llvm::IntrusiveRefCntPtr<DiagnosticsEngine>(
  32. new DiagnosticsEngine(DiagIDs));
  33. Diags->setClient(DC.clone(*Diags), /*ShouldOwnClient=*/true);
  34. SourceMgr = new SourceManager(*Diags, FileMgr);
  35. }
  36. ModuleMap::~ModuleMap() {
  37. for (llvm::StringMap<Module *>::iterator I = Modules.begin(),
  38. IEnd = Modules.end();
  39. I != IEnd; ++I) {
  40. delete I->getValue();
  41. }
  42. delete SourceMgr;
  43. }
  44. Module *ModuleMap::findModuleForHeader(const FileEntry *File) {
  45. llvm::DenseMap<const FileEntry *, Module *>::iterator Known
  46. = Headers.find(File);
  47. if (Known != Headers.end())
  48. return Known->second;
  49. const DirectoryEntry *Dir = File->getDir();
  50. llvm::DenseMap<const DirectoryEntry *, Module *>::iterator KnownDir
  51. = UmbrellaDirs.find(Dir);
  52. if (KnownDir != UmbrellaDirs.end())
  53. return KnownDir->second;
  54. // Walk up the directory hierarchy looking for umbrella headers.
  55. llvm::SmallVector<const DirectoryEntry *, 2> SkippedDirs;
  56. StringRef DirName = Dir->getName();
  57. do {
  58. // Retrieve our parent path.
  59. DirName = llvm::sys::path::parent_path(DirName);
  60. if (DirName.empty())
  61. break;
  62. // Resolve the parent path to a directory entry.
  63. Dir = SourceMgr->getFileManager().getDirectory(DirName);
  64. if (!Dir)
  65. break;
  66. KnownDir = UmbrellaDirs.find(Dir);
  67. if (KnownDir != UmbrellaDirs.end()) {
  68. Module *Result = KnownDir->second;
  69. // Record each of the directories we stepped through as being part of
  70. // the module we found, since the umbrella header covers them all.
  71. for (unsigned I = 0, N = SkippedDirs.size(); I != N; ++I)
  72. UmbrellaDirs[SkippedDirs[I]] = Result;
  73. return Result;
  74. }
  75. SkippedDirs.push_back(Dir);
  76. } while (true);
  77. return 0;
  78. }
  79. Module *ModuleMap::findModule(StringRef Name) {
  80. llvm::StringMap<Module *>::iterator Known = Modules.find(Name);
  81. if (Known != Modules.end())
  82. return Known->getValue();
  83. return 0;
  84. }
  85. std::pair<Module *, bool>
  86. ModuleMap::findOrCreateModule(StringRef Name, Module *Parent, bool IsFramework,
  87. bool IsExplicit) {
  88. // Try to find an existing module with this name.
  89. if (Module *Found = Parent? Parent->SubModules[Name] : Modules[Name])
  90. return std::make_pair(Found, false);
  91. // Create a new module with this name.
  92. Module *Result = new Module(Name, SourceLocation(), Parent, IsFramework,
  93. IsExplicit);
  94. if (Parent)
  95. Parent->SubModules[Name] = Result;
  96. else
  97. Modules[Name] = Result;
  98. return std::make_pair(Result, true);
  99. }
  100. Module *
  101. ModuleMap::inferFrameworkModule(StringRef ModuleName,
  102. const DirectoryEntry *FrameworkDir) {
  103. // Check whether we've already found this module.
  104. if (Module *Module = findModule(ModuleName))
  105. return Module;
  106. // Look for an umbrella header.
  107. llvm::SmallString<128> UmbrellaName = StringRef(FrameworkDir->getName());
  108. llvm::sys::path::append(UmbrellaName, "Headers");
  109. llvm::sys::path::append(UmbrellaName, ModuleName + ".h");
  110. const FileEntry *UmbrellaHeader
  111. = SourceMgr->getFileManager().getFile(UmbrellaName);
  112. // FIXME: If there's no umbrella header, we could probably scan the
  113. // framework to load *everything*. But, it's not clear that this is a good
  114. // idea.
  115. if (!UmbrellaHeader)
  116. return 0;
  117. Module *Result = new Module(ModuleName, SourceLocation(),
  118. /*IsFramework=*/true);
  119. Result->UmbrellaHeader = UmbrellaHeader;
  120. Headers[UmbrellaHeader] = Result;
  121. UmbrellaDirs[FrameworkDir] = Result;
  122. Modules[ModuleName] = Result;
  123. return Result;
  124. }
  125. const FileEntry *
  126. ModuleMap::getContainingModuleMapFile(Module *Module) {
  127. if (Module->DefinitionLoc.isInvalid() || !SourceMgr)
  128. return 0;
  129. return SourceMgr->getFileEntryForID(
  130. SourceMgr->getFileID(Module->DefinitionLoc));
  131. }
  132. void ModuleMap::dump() {
  133. llvm::errs() << "Modules:";
  134. for (llvm::StringMap<Module *>::iterator M = Modules.begin(),
  135. MEnd = Modules.end();
  136. M != MEnd; ++M)
  137. M->getValue()->print(llvm::errs(), 2);
  138. llvm::errs() << "Headers:";
  139. for (llvm::DenseMap<const FileEntry *, Module *>::iterator
  140. H = Headers.begin(),
  141. HEnd = Headers.end();
  142. H != HEnd; ++H) {
  143. llvm::errs() << " \"" << H->first->getName() << "\" -> "
  144. << H->second->getFullModuleName() << "\n";
  145. }
  146. }
  147. //----------------------------------------------------------------------------//
  148. // Module map file parser
  149. //----------------------------------------------------------------------------//
  150. namespace clang {
  151. /// \brief A token in a module map file.
  152. struct MMToken {
  153. enum TokenKind {
  154. EndOfFile,
  155. HeaderKeyword,
  156. Identifier,
  157. ExplicitKeyword,
  158. FrameworkKeyword,
  159. ModuleKeyword,
  160. UmbrellaKeyword,
  161. StringLiteral,
  162. LBrace,
  163. RBrace
  164. } Kind;
  165. unsigned Location;
  166. unsigned StringLength;
  167. const char *StringData;
  168. void clear() {
  169. Kind = EndOfFile;
  170. Location = 0;
  171. StringLength = 0;
  172. StringData = 0;
  173. }
  174. bool is(TokenKind K) const { return Kind == K; }
  175. SourceLocation getLocation() const {
  176. return SourceLocation::getFromRawEncoding(Location);
  177. }
  178. StringRef getString() const {
  179. return StringRef(StringData, StringLength);
  180. }
  181. };
  182. class ModuleMapParser {
  183. Lexer &L;
  184. SourceManager &SourceMgr;
  185. DiagnosticsEngine &Diags;
  186. ModuleMap &Map;
  187. /// \brief The directory that this module map resides in.
  188. const DirectoryEntry *Directory;
  189. /// \brief Whether an error occurred.
  190. bool HadError;
  191. /// \brief Default target information, used only for string literal
  192. /// parsing.
  193. TargetInfo *Target;
  194. /// \brief Stores string data for the various string literals referenced
  195. /// during parsing.
  196. llvm::BumpPtrAllocator StringData;
  197. /// \brief The current token.
  198. MMToken Tok;
  199. /// \brief The active module.
  200. Module *ActiveModule;
  201. /// \brief Consume the current token and return its location.
  202. SourceLocation consumeToken();
  203. /// \brief Skip tokens until we reach the a token with the given kind
  204. /// (or the end of the file).
  205. void skipUntil(MMToken::TokenKind K);
  206. void parseModuleDecl();
  207. void parseUmbrellaDecl();
  208. void parseHeaderDecl();
  209. public:
  210. typedef Module Module;
  211. explicit ModuleMapParser(Lexer &L, SourceManager &SourceMgr,
  212. DiagnosticsEngine &Diags,
  213. ModuleMap &Map,
  214. const DirectoryEntry *Directory)
  215. : L(L), SourceMgr(SourceMgr), Diags(Diags), Map(Map),
  216. Directory(Directory), HadError(false), ActiveModule(0)
  217. {
  218. TargetOptions TargetOpts;
  219. TargetOpts.Triple = llvm::sys::getDefaultTargetTriple();
  220. Target = TargetInfo::CreateTargetInfo(Diags, TargetOpts);
  221. Tok.clear();
  222. consumeToken();
  223. }
  224. bool parseModuleMapFile();
  225. };
  226. }
  227. SourceLocation ModuleMapParser::consumeToken() {
  228. retry:
  229. SourceLocation Result = Tok.getLocation();
  230. Tok.clear();
  231. Token LToken;
  232. L.LexFromRawLexer(LToken);
  233. Tok.Location = LToken.getLocation().getRawEncoding();
  234. switch (LToken.getKind()) {
  235. case tok::raw_identifier:
  236. Tok.StringData = LToken.getRawIdentifierData();
  237. Tok.StringLength = LToken.getLength();
  238. Tok.Kind = llvm::StringSwitch<MMToken::TokenKind>(Tok.getString())
  239. .Case("header", MMToken::HeaderKeyword)
  240. .Case("explicit", MMToken::ExplicitKeyword)
  241. .Case("framework", MMToken::FrameworkKeyword)
  242. .Case("module", MMToken::ModuleKeyword)
  243. .Case("umbrella", MMToken::UmbrellaKeyword)
  244. .Default(MMToken::Identifier);
  245. break;
  246. case tok::eof:
  247. Tok.Kind = MMToken::EndOfFile;
  248. break;
  249. case tok::l_brace:
  250. Tok.Kind = MMToken::LBrace;
  251. break;
  252. case tok::r_brace:
  253. Tok.Kind = MMToken::RBrace;
  254. break;
  255. case tok::string_literal: {
  256. // Parse the string literal.
  257. LangOptions LangOpts;
  258. StringLiteralParser StringLiteral(&LToken, 1, SourceMgr, LangOpts, *Target);
  259. if (StringLiteral.hadError)
  260. goto retry;
  261. // Copy the string literal into our string data allocator.
  262. unsigned Length = StringLiteral.GetStringLength();
  263. char *Saved = StringData.Allocate<char>(Length + 1);
  264. memcpy(Saved, StringLiteral.GetString().data(), Length);
  265. Saved[Length] = 0;
  266. // Form the token.
  267. Tok.Kind = MMToken::StringLiteral;
  268. Tok.StringData = Saved;
  269. Tok.StringLength = Length;
  270. break;
  271. }
  272. case tok::comment:
  273. goto retry;
  274. default:
  275. Diags.Report(LToken.getLocation(), diag::err_mmap_unknown_token);
  276. HadError = true;
  277. goto retry;
  278. }
  279. return Result;
  280. }
  281. void ModuleMapParser::skipUntil(MMToken::TokenKind K) {
  282. unsigned braceDepth = 0;
  283. do {
  284. switch (Tok.Kind) {
  285. case MMToken::EndOfFile:
  286. return;
  287. case MMToken::LBrace:
  288. if (Tok.is(K) && braceDepth == 0)
  289. return;
  290. ++braceDepth;
  291. break;
  292. case MMToken::RBrace:
  293. if (braceDepth > 0)
  294. --braceDepth;
  295. else if (Tok.is(K))
  296. return;
  297. break;
  298. default:
  299. if (braceDepth == 0 && Tok.is(K))
  300. return;
  301. break;
  302. }
  303. consumeToken();
  304. } while (true);
  305. }
  306. /// \brief Parse a module declaration.
  307. ///
  308. /// module-declaration:
  309. /// 'framework'[opt] 'module' identifier { module-member* }
  310. ///
  311. /// module-member:
  312. /// umbrella-declaration
  313. /// header-declaration
  314. /// 'explicit'[opt] module-declaration
  315. void ModuleMapParser::parseModuleDecl() {
  316. assert(Tok.is(MMToken::ExplicitKeyword) || Tok.is(MMToken::ModuleKeyword) ||
  317. Tok.is(MMToken::FrameworkKeyword));
  318. // Parse 'framework' or 'explicit' keyword, if present.
  319. bool Framework = false;
  320. bool Explicit = false;
  321. if (Tok.is(MMToken::FrameworkKeyword)) {
  322. consumeToken();
  323. Framework = true;
  324. }
  325. // Parse 'explicit' keyword, if present.
  326. else if (Tok.is(MMToken::ExplicitKeyword)) {
  327. consumeToken();
  328. Explicit = true;
  329. }
  330. // Parse 'module' keyword.
  331. if (!Tok.is(MMToken::ModuleKeyword)) {
  332. Diags.Report(Tok.getLocation(),
  333. diag::err_mmap_expected_module_after_explicit);
  334. consumeToken();
  335. HadError = true;
  336. return;
  337. }
  338. consumeToken(); // 'module' keyword
  339. // Parse the module name.
  340. if (!Tok.is(MMToken::Identifier)) {
  341. Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module_name);
  342. HadError = true;
  343. return;
  344. }
  345. StringRef ModuleName = Tok.getString();
  346. SourceLocation ModuleNameLoc = consumeToken();
  347. // Parse the opening brace.
  348. if (!Tok.is(MMToken::LBrace)) {
  349. Diags.Report(Tok.getLocation(), diag::err_mmap_expected_lbrace)
  350. << ModuleName;
  351. HadError = true;
  352. return;
  353. }
  354. SourceLocation LBraceLoc = consumeToken();
  355. // Determine whether this (sub)module has already been defined.
  356. llvm::StringMap<Module *> &ModuleSpace
  357. = ActiveModule? ActiveModule->SubModules : Map.Modules;
  358. llvm::StringMap<Module *>::iterator ExistingModule
  359. = ModuleSpace.find(ModuleName);
  360. if (ExistingModule != ModuleSpace.end()) {
  361. Diags.Report(ModuleNameLoc, diag::err_mmap_module_redefinition)
  362. << ModuleName;
  363. Diags.Report(ExistingModule->getValue()->DefinitionLoc,
  364. diag::note_mmap_prev_definition);
  365. // Skip the module definition.
  366. skipUntil(MMToken::RBrace);
  367. if (Tok.is(MMToken::RBrace))
  368. consumeToken();
  369. HadError = true;
  370. return;
  371. }
  372. // Start defining this module.
  373. ActiveModule = new Module(ModuleName, ModuleNameLoc, ActiveModule, Framework,
  374. Explicit);
  375. ModuleSpace[ModuleName] = ActiveModule;
  376. bool Done = false;
  377. do {
  378. switch (Tok.Kind) {
  379. case MMToken::EndOfFile:
  380. case MMToken::RBrace:
  381. Done = true;
  382. break;
  383. case MMToken::ExplicitKeyword:
  384. case MMToken::ModuleKeyword:
  385. parseModuleDecl();
  386. break;
  387. case MMToken::HeaderKeyword:
  388. parseHeaderDecl();
  389. break;
  390. case MMToken::UmbrellaKeyword:
  391. parseUmbrellaDecl();
  392. break;
  393. default:
  394. Diags.Report(Tok.getLocation(), diag::err_mmap_expected_member);
  395. consumeToken();
  396. break;
  397. }
  398. } while (!Done);
  399. if (Tok.is(MMToken::RBrace))
  400. consumeToken();
  401. else {
  402. Diags.Report(Tok.getLocation(), diag::err_mmap_expected_rbrace);
  403. Diags.Report(LBraceLoc, diag::note_mmap_lbrace_match);
  404. HadError = true;
  405. }
  406. // We're done parsing this module. Pop back to our parent scope.
  407. ActiveModule = ActiveModule->Parent;
  408. }
  409. /// \brief Parse an umbrella header declaration.
  410. ///
  411. /// umbrella-declaration:
  412. /// 'umbrella' string-literal
  413. void ModuleMapParser::parseUmbrellaDecl() {
  414. assert(Tok.is(MMToken::UmbrellaKeyword));
  415. SourceLocation UmbrellaLoc = consumeToken();
  416. // Parse the header name.
  417. if (!Tok.is(MMToken::StringLiteral)) {
  418. Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header)
  419. << "umbrella";
  420. HadError = true;
  421. return;
  422. }
  423. StringRef FileName = Tok.getString();
  424. SourceLocation FileNameLoc = consumeToken();
  425. // Check whether we already have an umbrella header.
  426. if (ActiveModule->UmbrellaHeader) {
  427. Diags.Report(FileNameLoc, diag::err_mmap_umbrella_header_conflict)
  428. << ActiveModule->getFullModuleName()
  429. << ActiveModule->UmbrellaHeader->getName();
  430. HadError = true;
  431. return;
  432. }
  433. // Only top-level modules can have umbrella headers.
  434. if (ActiveModule->Parent) {
  435. Diags.Report(UmbrellaLoc, diag::err_mmap_umbrella_header_submodule)
  436. << ActiveModule->getFullModuleName();
  437. HadError = true;
  438. return;
  439. }
  440. // Look for this file.
  441. llvm::SmallString<128> PathName;
  442. const FileEntry *File = 0;
  443. if (llvm::sys::path::is_absolute(FileName)) {
  444. PathName = FileName;
  445. File = SourceMgr.getFileManager().getFile(PathName);
  446. } else {
  447. // Search for the header file within the search directory.
  448. PathName += Directory->getName();
  449. unsigned PathLength = PathName.size();
  450. if (ActiveModule->isPartOfFramework()) {
  451. // Check whether this file is in the public headers.
  452. llvm::sys::path::append(PathName, "Headers");
  453. llvm::sys::path::append(PathName, FileName);
  454. File = SourceMgr.getFileManager().getFile(PathName);
  455. if (!File) {
  456. // Check whether this file is in the private headers.
  457. PathName.resize(PathLength);
  458. llvm::sys::path::append(PathName, "PrivateHeaders");
  459. llvm::sys::path::append(PathName, FileName);
  460. File = SourceMgr.getFileManager().getFile(PathName);
  461. }
  462. // FIXME: Deal with subframeworks.
  463. } else {
  464. // Lookup for normal headers.
  465. llvm::sys::path::append(PathName, FileName);
  466. File = SourceMgr.getFileManager().getFile(PathName);
  467. }
  468. }
  469. // FIXME: We shouldn't be eagerly stat'ing every file named in a module map.
  470. // Come up with a lazy way to do this.
  471. if (File) {
  472. if (const Module *OwningModule = Map.Headers[File]) {
  473. Diags.Report(FileNameLoc, diag::err_mmap_header_conflict)
  474. << FileName << OwningModule->getFullModuleName();
  475. HadError = true;
  476. } else if ((OwningModule = Map.UmbrellaDirs[Directory])) {
  477. Diags.Report(UmbrellaLoc, diag::err_mmap_umbrella_clash)
  478. << OwningModule->getFullModuleName();
  479. HadError = true;
  480. } else {
  481. // Record this umbrella header.
  482. ActiveModule->UmbrellaHeader = File;
  483. Map.Headers[File] = ActiveModule;
  484. Map.UmbrellaDirs[Directory] = ActiveModule;
  485. }
  486. } else {
  487. Diags.Report(FileNameLoc, diag::err_mmap_header_not_found)
  488. << true << FileName;
  489. HadError = true;
  490. }
  491. }
  492. /// \brief Parse a header declaration.
  493. ///
  494. /// header-declaration:
  495. /// 'header' string-literal
  496. void ModuleMapParser::parseHeaderDecl() {
  497. assert(Tok.is(MMToken::HeaderKeyword));
  498. consumeToken();
  499. // Parse the header name.
  500. if (!Tok.is(MMToken::StringLiteral)) {
  501. Diags.Report(Tok.getLocation(), diag::err_mmap_expected_header)
  502. << "header";
  503. HadError = true;
  504. return;
  505. }
  506. StringRef FileName = Tok.getString();
  507. SourceLocation FileNameLoc = consumeToken();
  508. // Look for this file.
  509. llvm::SmallString<128> PathName;
  510. if (llvm::sys::path::is_relative(FileName)) {
  511. // FIXME: Change this search to also look for private headers!
  512. PathName += Directory->getName();
  513. if (ActiveModule->isPartOfFramework())
  514. llvm::sys::path::append(PathName, "Headers");
  515. }
  516. llvm::sys::path::append(PathName, FileName);
  517. // FIXME: We shouldn't be eagerly stat'ing every file named in a module map.
  518. // Come up with a lazy way to do this.
  519. if (const FileEntry *File = SourceMgr.getFileManager().getFile(PathName)) {
  520. if (const Module *OwningModule = Map.Headers[File]) {
  521. Diags.Report(FileNameLoc, diag::err_mmap_header_conflict)
  522. << FileName << OwningModule->getFullModuleName();
  523. HadError = true;
  524. } else {
  525. // Record this file.
  526. ActiveModule->Headers.push_back(File);
  527. Map.Headers[File] = ActiveModule;
  528. }
  529. } else {
  530. Diags.Report(FileNameLoc, diag::err_mmap_header_not_found)
  531. << false << FileName;
  532. HadError = true;
  533. }
  534. }
  535. /// \brief Parse a module map file.
  536. ///
  537. /// module-map-file:
  538. /// module-declaration*
  539. bool ModuleMapParser::parseModuleMapFile() {
  540. do {
  541. switch (Tok.Kind) {
  542. case MMToken::EndOfFile:
  543. return HadError;
  544. case MMToken::ModuleKeyword:
  545. case MMToken::FrameworkKeyword:
  546. parseModuleDecl();
  547. break;
  548. case MMToken::ExplicitKeyword:
  549. case MMToken::HeaderKeyword:
  550. case MMToken::Identifier:
  551. case MMToken::LBrace:
  552. case MMToken::RBrace:
  553. case MMToken::StringLiteral:
  554. case MMToken::UmbrellaKeyword:
  555. Diags.Report(Tok.getLocation(), diag::err_mmap_expected_module);
  556. HadError = true;
  557. consumeToken();
  558. break;
  559. }
  560. } while (true);
  561. return HadError;
  562. }
  563. bool ModuleMap::parseModuleMapFile(const FileEntry *File) {
  564. FileID ID = SourceMgr->createFileID(File, SourceLocation(), SrcMgr::C_User);
  565. const llvm::MemoryBuffer *Buffer = SourceMgr->getBuffer(ID);
  566. if (!Buffer)
  567. return true;
  568. // Parse this module map file.
  569. Lexer L(ID, SourceMgr->getBuffer(ID), *SourceMgr, LangOpts);
  570. Diags->getClient()->BeginSourceFile(LangOpts);
  571. ModuleMapParser Parser(L, *SourceMgr, *Diags, *this, File->getDir());
  572. bool Result = Parser.parseModuleMapFile();
  573. Diags->getClient()->EndSourceFile();
  574. return Result;
  575. }