| //===--- InclusionRewriter.cpp - Rewrite includes into their expansions ---===// | |
| // | |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. | |
| // See https://llvm.org/LICENSE.txt for license information. | |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception | |
| // | |
| //===----------------------------------------------------------------------===// | |
| // | |
| // This code rewrites include invocations into their expansions. This gives you | |
| // a file with all included files merged into it. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "clang/Basic/SourceManager.h" | |
| #include "clang/Frontend/PreprocessorOutputOptions.h" | |
| #include "clang/Lex/Pragma.h" | |
| #include "clang/Lex/Preprocessor.h" | |
| #include "clang/Rewrite/Frontend/Rewriters.h" | |
| #include "llvm/ADT/SmallString.h" | |
| #include "llvm/Support/Path.h" | |
| #include "llvm/Support/raw_ostream.h" | |
| #include <optional> | |
| using namespace clang; | |
| using namespace llvm; | |
| namespace { | |
| class InclusionRewriter : public PPCallbacks { | |
| /// Information about which #includes were actually performed, | |
| /// created by preprocessor callbacks. | |
| struct IncludedFile { | |
| FileID Id; | |
| SrcMgr::CharacteristicKind FileType; | |
| IncludedFile(FileID Id, SrcMgr::CharacteristicKind FileType) | |
| : Id(Id), FileType(FileType) {} | |
| }; | |
| Preprocessor &PP; ///< Used to find inclusion directives. | |
| SourceManager &SM; ///< Used to read and manage source files. | |
| raw_ostream &OS; ///< The destination stream for rewritten contents. | |
| StringRef MainEOL; ///< The line ending marker to use. | |
| llvm::MemoryBufferRef PredefinesBuffer; ///< The preprocessor predefines. | |
| bool ShowLineMarkers; ///< Show #line markers. | |
| bool UseLineDirectives; ///< Use of line directives or line markers. | |
| /// Tracks where inclusions that change the file are found. | |
| std::map<SourceLocation, IncludedFile> FileIncludes; | |
| /// Tracks where inclusions that import modules are found. | |
| std::map<SourceLocation, const Module *> ModuleIncludes; | |
| /// Tracks where inclusions that enter modules (in a module build) are found. | |
| std::map<SourceLocation, const Module *> ModuleEntryIncludes; | |
| /// Tracks where #if and #elif directives get evaluated and whether to true. | |
| std::map<SourceLocation, bool> IfConditions; | |
| /// Used transitively for building up the FileIncludes mapping over the | |
| /// various \c PPCallbacks callbacks. | |
| SourceLocation LastInclusionLocation; | |
| public: | |
| InclusionRewriter(Preprocessor &PP, raw_ostream &OS, bool ShowLineMarkers, | |
| bool UseLineDirectives); | |
| void Process(FileID FileId, SrcMgr::CharacteristicKind FileType); | |
| void setPredefinesBuffer(const llvm::MemoryBufferRef &Buf) { | |
| PredefinesBuffer = Buf; | |
| } | |
| void detectMainFileEOL(); | |
| void handleModuleBegin(Token &Tok) { | |
| assert(Tok.getKind() == tok::annot_module_begin); | |
| ModuleEntryIncludes.insert( | |
| {Tok.getLocation(), (Module *)Tok.getAnnotationValue()}); | |
| } | |
| private: | |
| void FileChanged(SourceLocation Loc, FileChangeReason Reason, | |
| SrcMgr::CharacteristicKind FileType, | |
| FileID PrevFID) override; | |
| void FileSkipped(const FileEntryRef &SkippedFile, const Token &FilenameTok, | |
| SrcMgr::CharacteristicKind FileType) override; | |
| void InclusionDirective(SourceLocation HashLoc, const Token &IncludeTok, | |
| StringRef FileName, bool IsAngled, | |
| CharSourceRange FilenameRange, | |
| OptionalFileEntryRef File, StringRef SearchPath, | |
| StringRef RelativePath, const Module *SuggestedModule, | |
| bool ModuleImported, | |
| SrcMgr::CharacteristicKind FileType) override; | |
| void If(SourceLocation Loc, SourceRange ConditionRange, | |
| ConditionValueKind ConditionValue) override; | |
| void Elif(SourceLocation Loc, SourceRange ConditionRange, | |
| ConditionValueKind ConditionValue, SourceLocation IfLoc) override; | |
| void WriteLineInfo(StringRef Filename, int Line, | |
| SrcMgr::CharacteristicKind FileType, | |
| StringRef Extra = StringRef()); | |
| void WriteImplicitModuleImport(const Module *Mod); | |
| void OutputContentUpTo(const MemoryBufferRef &FromFile, unsigned &WriteFrom, | |
| unsigned WriteTo, StringRef EOL, int &lines, | |
| bool EnsureNewline); | |
| void CommentOutDirective(Lexer &DirectivesLex, const Token &StartToken, | |
| const MemoryBufferRef &FromFile, StringRef EOL, | |
| unsigned &NextToWrite, int &Lines, | |
| const IncludedFile *Inc = nullptr); | |
| const IncludedFile *FindIncludeAtLocation(SourceLocation Loc) const; | |
| StringRef getIncludedFileName(const IncludedFile *Inc) const; | |
| const Module *FindModuleAtLocation(SourceLocation Loc) const; | |
| const Module *FindEnteredModule(SourceLocation Loc) const; | |
| bool IsIfAtLocationTrue(SourceLocation Loc) const; | |
| StringRef NextIdentifierName(Lexer &RawLex, Token &RawToken); | |
| }; | |
| } // end anonymous namespace | |
| /// Initializes an InclusionRewriter with a \p PP source and \p OS destination. | |
| InclusionRewriter::InclusionRewriter(Preprocessor &PP, raw_ostream &OS, | |
| bool ShowLineMarkers, | |
| bool UseLineDirectives) | |
| : PP(PP), SM(PP.getSourceManager()), OS(OS), MainEOL("\n"), | |
| ShowLineMarkers(ShowLineMarkers), UseLineDirectives(UseLineDirectives), | |
| LastInclusionLocation(SourceLocation()) {} | |
| /// Write appropriate line information as either #line directives or GNU line | |
| /// markers depending on what mode we're in, including the \p Filename and | |
| /// \p Line we are located at, using the specified \p EOL line separator, and | |
| /// any \p Extra context specifiers in GNU line directives. | |
| void InclusionRewriter::WriteLineInfo(StringRef Filename, int Line, | |
| SrcMgr::CharacteristicKind FileType, | |
| StringRef Extra) { | |
| if (!ShowLineMarkers) | |
| return; | |
| if (UseLineDirectives) { | |
| OS << "#line" << ' ' << Line << ' ' << '"'; | |
| OS << Filename; | |
| OS << '"'; | |
| } else { | |
| // Use GNU linemarkers as described here: | |
| // http://gcc.gnu.org/onlinedocs/cpp/Preprocessor-Output.html | |
| OS << '#' << ' ' << Line << ' ' << '"'; | |
| OS << Filename; | |
| OS << '"'; | |
| if (!Extra.empty()) | |
| OS << Extra; | |
| if (FileType == SrcMgr::C_System) | |
| // "`3' This indicates that the following text comes from a system header | |
| // file, so certain warnings should be suppressed." | |
| OS << " 3"; | |
| else if (FileType == SrcMgr::C_ExternCSystem) | |
| // as above for `3', plus "`4' This indicates that the following text | |
| // should be treated as being wrapped in an implicit extern "C" block." | |
| OS << " 3 4"; | |
| } | |
| OS << MainEOL; | |
| } | |
| void InclusionRewriter::WriteImplicitModuleImport(const Module *Mod) { | |
| OS << "#pragma clang module import " << Mod->getFullModuleName(true) | |
| << " /* clang -frewrite-includes: implicit import */" << MainEOL; | |
| } | |
| /// FileChanged - Whenever the preprocessor enters or exits a #include file | |
| /// it invokes this handler. | |
| void InclusionRewriter::FileChanged(SourceLocation Loc, | |
| FileChangeReason Reason, | |
| SrcMgr::CharacteristicKind NewFileType, | |
| FileID) { | |
| if (Reason != EnterFile) | |
| return; | |
| if (LastInclusionLocation.isInvalid()) | |
| // we didn't reach this file (eg: the main file) via an inclusion directive | |
| return; | |
| FileID Id = FullSourceLoc(Loc, SM).getFileID(); | |
| auto P = FileIncludes.insert( | |
| std::make_pair(LastInclusionLocation, IncludedFile(Id, NewFileType))); | |
| (void)P; | |
| assert(P.second && "Unexpected revisitation of the same include directive"); | |
| LastInclusionLocation = SourceLocation(); | |
| } | |
| /// Called whenever an inclusion is skipped due to canonical header protection | |
| /// macros. | |
| void InclusionRewriter::FileSkipped(const FileEntryRef & /*SkippedFile*/, | |
| const Token & /*FilenameTok*/, | |
| SrcMgr::CharacteristicKind /*FileType*/) { | |
| assert(LastInclusionLocation.isValid() && | |
| "A file, that wasn't found via an inclusion directive, was skipped"); | |
| LastInclusionLocation = SourceLocation(); | |
| } | |
| /// This should be called whenever the preprocessor encounters include | |
| /// directives. It does not say whether the file has been included, but it | |
| /// provides more information about the directive (hash location instead | |
| /// of location inside the included file). It is assumed that the matching | |
| /// FileChanged() or FileSkipped() is called after this (or neither is | |
| /// called if this #include results in an error or does not textually include | |
| /// anything). | |
| void InclusionRewriter::InclusionDirective( | |
| SourceLocation HashLoc, const Token & /*IncludeTok*/, | |
| StringRef /*FileName*/, bool /*IsAngled*/, | |
| CharSourceRange /*FilenameRange*/, OptionalFileEntryRef /*File*/, | |
| StringRef /*SearchPath*/, StringRef /*RelativePath*/, | |
| const Module *SuggestedModule, bool ModuleImported, | |
| SrcMgr::CharacteristicKind FileType) { | |
| if (ModuleImported) { | |
| auto P = ModuleIncludes.insert(std::make_pair(HashLoc, SuggestedModule)); | |
| (void)P; | |
| assert(P.second && "Unexpected revisitation of the same include directive"); | |
| } else | |
| LastInclusionLocation = HashLoc; | |
| } | |
| void InclusionRewriter::If(SourceLocation Loc, SourceRange ConditionRange, | |
| ConditionValueKind ConditionValue) { | |
| auto P = IfConditions.insert(std::make_pair(Loc, ConditionValue == CVK_True)); | |
| (void)P; | |
| assert(P.second && "Unexpected revisitation of the same if directive"); | |
| } | |
| void InclusionRewriter::Elif(SourceLocation Loc, SourceRange ConditionRange, | |
| ConditionValueKind ConditionValue, | |
| SourceLocation IfLoc) { | |
| auto P = IfConditions.insert(std::make_pair(Loc, ConditionValue == CVK_True)); | |
| (void)P; | |
| assert(P.second && "Unexpected revisitation of the same elif directive"); | |
| } | |
| /// Simple lookup for a SourceLocation (specifically one denoting the hash in | |
| /// an inclusion directive) in the map of inclusion information, FileChanges. | |
| const InclusionRewriter::IncludedFile * | |
| InclusionRewriter::FindIncludeAtLocation(SourceLocation Loc) const { | |
| const auto I = FileIncludes.find(Loc); | |
| if (I != FileIncludes.end()) | |
| return &I->second; | |
| return nullptr; | |
| } | |
| /// Simple lookup for a SourceLocation (specifically one denoting the hash in | |
| /// an inclusion directive) in the map of module inclusion information. | |
| const Module * | |
| InclusionRewriter::FindModuleAtLocation(SourceLocation Loc) const { | |
| const auto I = ModuleIncludes.find(Loc); | |
| if (I != ModuleIncludes.end()) | |
| return I->second; | |
| return nullptr; | |
| } | |
| /// Simple lookup for a SourceLocation (specifically one denoting the hash in | |
| /// an inclusion directive) in the map of module entry information. | |
| const Module * | |
| InclusionRewriter::FindEnteredModule(SourceLocation Loc) const { | |
| const auto I = ModuleEntryIncludes.find(Loc); | |
| if (I != ModuleEntryIncludes.end()) | |
| return I->second; | |
| return nullptr; | |
| } | |
| bool InclusionRewriter::IsIfAtLocationTrue(SourceLocation Loc) const { | |
| const auto I = IfConditions.find(Loc); | |
| if (I != IfConditions.end()) | |
| return I->second; | |
| return false; | |
| } | |
| void InclusionRewriter::detectMainFileEOL() { | |
| std::optional<MemoryBufferRef> FromFile = | |
| *SM.getBufferOrNone(SM.getMainFileID()); | |
| assert(FromFile); | |
| if (!FromFile) | |
| return; // Should never happen, but whatever. | |
| MainEOL = FromFile->getBuffer().detectEOL(); | |
| } | |
| /// Writes out bytes from \p FromFile, starting at \p NextToWrite and ending at | |
| /// \p WriteTo - 1. | |
| void InclusionRewriter::OutputContentUpTo(const MemoryBufferRef &FromFile, | |
| unsigned &WriteFrom, unsigned WriteTo, | |
| StringRef LocalEOL, int &Line, | |
| bool EnsureNewline) { | |
| if (WriteTo <= WriteFrom) | |
| return; | |
| if (FromFile == PredefinesBuffer) { | |
| // Ignore the #defines of the predefines buffer. | |
| WriteFrom = WriteTo; | |
| return; | |
| } | |
| // If we would output half of a line ending, advance one character to output | |
| // the whole line ending. All buffers are null terminated, so looking ahead | |
| // one byte is safe. | |
| if (LocalEOL.size() == 2 && | |
| LocalEOL[0] == (FromFile.getBufferStart() + WriteTo)[-1] && | |
| LocalEOL[1] == (FromFile.getBufferStart() + WriteTo)[0]) | |
| WriteTo++; | |
| StringRef TextToWrite(FromFile.getBufferStart() + WriteFrom, | |
| WriteTo - WriteFrom); | |
| // count lines manually, it's faster than getPresumedLoc() | |
| Line += TextToWrite.count(LocalEOL); | |
| if (MainEOL == LocalEOL) { | |
| OS << TextToWrite; | |
| } else { | |
| // Output the file one line at a time, rewriting the line endings as we go. | |
| StringRef Rest = TextToWrite; | |
| while (!Rest.empty()) { | |
| // Identify and output the next line excluding an EOL sequence if present. | |
| size_t Idx = Rest.find(LocalEOL); | |
| StringRef LineText = Rest.substr(0, Idx); | |
| OS << LineText; | |
| if (Idx != StringRef::npos) { | |
| // An EOL sequence was present, output the EOL sequence for the | |
| // main source file and skip past the local EOL sequence. | |
| OS << MainEOL; | |
| Idx += LocalEOL.size(); | |
| } | |
| // Strip the line just handled. If Idx is npos or matches the end of the | |
| // text, Rest will be set to an empty string and the loop will terminate. | |
| Rest = Rest.substr(Idx); | |
| } | |
| } | |
| if (EnsureNewline && !TextToWrite.ends_with(LocalEOL)) | |
| OS << MainEOL; | |
| WriteFrom = WriteTo; | |
| } | |
| StringRef | |
| InclusionRewriter::getIncludedFileName(const IncludedFile *Inc) const { | |
| if (Inc) { | |
| auto B = SM.getBufferOrNone(Inc->Id); | |
| assert(B && "Attempting to process invalid inclusion"); | |
| if (B) | |
| return llvm::sys::path::filename(B->getBufferIdentifier()); | |
| } | |
| return StringRef(); | |
| } | |
| /// Print characters from \p FromFile starting at \p NextToWrite up until the | |
| /// inclusion directive at \p StartToken, then print out the inclusion | |
| /// inclusion directive disabled by a #if directive, updating \p NextToWrite | |
| /// and \p Line to track the number of source lines visited and the progress | |
| /// through the \p FromFile buffer. | |
| void InclusionRewriter::CommentOutDirective(Lexer &DirectiveLex, | |
| const Token &StartToken, | |
| const MemoryBufferRef &FromFile, | |
| StringRef LocalEOL, | |
| unsigned &NextToWrite, int &Line, | |
| const IncludedFile *Inc) { | |
| OutputContentUpTo(FromFile, NextToWrite, | |
| SM.getFileOffset(StartToken.getLocation()), LocalEOL, Line, | |
| false); | |
| Token DirectiveToken; | |
| do { | |
| DirectiveLex.LexFromRawLexer(DirectiveToken); | |
| } while (!DirectiveToken.is(tok::eod) && DirectiveToken.isNot(tok::eof)); | |
| if (FromFile == PredefinesBuffer) { | |
| // OutputContentUpTo() would not output anything anyway. | |
| return; | |
| } | |
| if (Inc) { | |
| OS << "#if defined(__CLANG_REWRITTEN_INCLUDES) "; | |
| if (isSystem(Inc->FileType)) | |
| OS << "|| defined(__CLANG_REWRITTEN_SYSTEM_INCLUDES) "; | |
| OS << "/* " << getIncludedFileName(Inc); | |
| } else { | |
| OS << "#if 0 /*"; | |
| } | |
| OS << " expanded by -frewrite-includes */" << MainEOL; | |
| OutputContentUpTo(FromFile, NextToWrite, | |
| SM.getFileOffset(DirectiveToken.getLocation()) + | |
| DirectiveToken.getLength(), | |
| LocalEOL, Line, true); | |
| OS << (Inc ? "#else /* " : "#endif /*") << getIncludedFileName(Inc) | |
| << " expanded by -frewrite-includes */" << MainEOL; | |
| } | |
| /// Find the next identifier in the pragma directive specified by \p RawToken. | |
| StringRef InclusionRewriter::NextIdentifierName(Lexer &RawLex, | |
| Token &RawToken) { | |
| RawLex.LexFromRawLexer(RawToken); | |
| if (RawToken.is(tok::raw_identifier)) | |
| PP.LookUpIdentifierInfo(RawToken); | |
| if (RawToken.is(tok::identifier)) | |
| return RawToken.getIdentifierInfo()->getName(); | |
| return StringRef(); | |
| } | |
| /// Use a raw lexer to analyze \p FileId, incrementally copying parts of it | |
| /// and including content of included files recursively. | |
| void InclusionRewriter::Process(FileID FileId, | |
| SrcMgr::CharacteristicKind FileType) { | |
| MemoryBufferRef FromFile; | |
| { | |
| auto B = SM.getBufferOrNone(FileId); | |
| assert(B && "Attempting to process invalid inclusion"); | |
| if (B) | |
| FromFile = *B; | |
| } | |
| StringRef FileName = FromFile.getBufferIdentifier(); | |
| Lexer RawLex(FileId, FromFile, PP.getSourceManager(), PP.getLangOpts()); | |
| RawLex.SetCommentRetentionState(false); | |
| StringRef LocalEOL = FromFile.getBuffer().detectEOL(); | |
| // Per the GNU docs: "1" indicates entering a new file. | |
| if (FileId == SM.getMainFileID() || FileId == PP.getPredefinesFileID()) | |
| WriteLineInfo(FileName, 1, FileType, ""); | |
| else | |
| WriteLineInfo(FileName, 1, FileType, " 1"); | |
| if (SM.getFileIDSize(FileId) == 0) | |
| return; | |
| // The next byte to be copied from the source file, which may be non-zero if | |
| // the lexer handled a BOM. | |
| unsigned NextToWrite = SM.getFileOffset(RawLex.getSourceLocation()); | |
| assert(SM.getLineNumber(FileId, NextToWrite) == 1); | |
| int Line = 1; // The current input file line number. | |
| Token RawToken; | |
| RawLex.LexFromRawLexer(RawToken); | |
| // TODO: Consider adding a switch that strips possibly unimportant content, | |
| // such as comments, to reduce the size of repro files. | |
| while (RawToken.isNot(tok::eof)) { | |
| if (RawToken.is(tok::hash) && RawToken.isAtStartOfLine()) { | |
| RawLex.setParsingPreprocessorDirective(true); | |
| Token HashToken = RawToken; | |
| RawLex.LexFromRawLexer(RawToken); | |
| if (RawToken.is(tok::raw_identifier)) | |
| PP.LookUpIdentifierInfo(RawToken); | |
| if (RawToken.getIdentifierInfo() != nullptr) { | |
| switch (RawToken.getIdentifierInfo()->getPPKeywordID()) { | |
| case tok::pp_include: | |
| case tok::pp_include_next: | |
| case tok::pp_import: { | |
| SourceLocation Loc = HashToken.getLocation(); | |
| const IncludedFile *Inc = FindIncludeAtLocation(Loc); | |
| CommentOutDirective(RawLex, HashToken, FromFile, LocalEOL, | |
| NextToWrite, Line, Inc); | |
| if (FileId != PP.getPredefinesFileID()) | |
| WriteLineInfo(FileName, Line - 1, FileType, ""); | |
| StringRef LineInfoExtra; | |
| if (const Module *Mod = FindModuleAtLocation(Loc)) | |
| WriteImplicitModuleImport(Mod); | |
| else if (Inc) { | |
| const Module *Mod = FindEnteredModule(Loc); | |
| if (Mod) | |
| OS << "#pragma clang module begin " | |
| << Mod->getFullModuleName(true) << "\n"; | |
| // Include and recursively process the file. | |
| Process(Inc->Id, Inc->FileType); | |
| if (Mod) | |
| OS << "#pragma clang module end /*" | |
| << Mod->getFullModuleName(true) << "*/\n"; | |
| // There's no #include, therefore no #if, for -include files. | |
| if (FromFile != PredefinesBuffer) { | |
| OS << "#endif /* " << getIncludedFileName(Inc) | |
| << " expanded by -frewrite-includes */" << LocalEOL; | |
| } | |
| // Add line marker to indicate we're returning from an included | |
| // file. | |
| LineInfoExtra = " 2"; | |
| } | |
| // fix up lineinfo (since commented out directive changed line | |
| // numbers) for inclusions that were skipped due to header guards | |
| WriteLineInfo(FileName, Line, FileType, LineInfoExtra); | |
| break; | |
| } | |
| case tok::pp_pragma: { | |
| StringRef Identifier = NextIdentifierName(RawLex, RawToken); | |
| if (Identifier == "clang" || Identifier == "GCC") { | |
| if (NextIdentifierName(RawLex, RawToken) == "system_header") { | |
| // keep the directive in, commented out | |
| CommentOutDirective(RawLex, HashToken, FromFile, LocalEOL, | |
| NextToWrite, Line); | |
| // update our own type | |
| FileType = SM.getFileCharacteristic(RawToken.getLocation()); | |
| WriteLineInfo(FileName, Line, FileType); | |
| } | |
| } else if (Identifier == "once") { | |
| // keep the directive in, commented out | |
| CommentOutDirective(RawLex, HashToken, FromFile, LocalEOL, | |
| NextToWrite, Line); | |
| WriteLineInfo(FileName, Line, FileType); | |
| } | |
| break; | |
| } | |
| case tok::pp_if: | |
| case tok::pp_elif: { | |
| bool elif = (RawToken.getIdentifierInfo()->getPPKeywordID() == | |
| tok::pp_elif); | |
| bool isTrue = IsIfAtLocationTrue(RawToken.getLocation()); | |
| OutputContentUpTo(FromFile, NextToWrite, | |
| SM.getFileOffset(HashToken.getLocation()), | |
| LocalEOL, Line, /*EnsureNewline=*/true); | |
| do { | |
| RawLex.LexFromRawLexer(RawToken); | |
| } while (!RawToken.is(tok::eod) && RawToken.isNot(tok::eof)); | |
| // We need to disable the old condition, but that is tricky. | |
| // Trying to comment it out can easily lead to comment nesting. | |
| // So instead make the condition harmless by making it enclose | |
| // and empty block. Moreover, put it itself inside an #if 0 block | |
| // to disable it from getting evaluated (e.g. __has_include_next | |
| // warns if used from the primary source file). | |
| OS << "#if 0 /* disabled by -frewrite-includes */" << MainEOL; | |
| if (elif) { | |
| OS << "#if 0" << MainEOL; | |
| } | |
| OutputContentUpTo(FromFile, NextToWrite, | |
| SM.getFileOffset(RawToken.getLocation()) + | |
| RawToken.getLength(), | |
| LocalEOL, Line, /*EnsureNewline=*/true); | |
| // Close the empty block and the disabling block. | |
| OS << "#endif" << MainEOL; | |
| OS << "#endif /* disabled by -frewrite-includes */" << MainEOL; | |
| OS << (elif ? "#elif " : "#if ") << (isTrue ? "1" : "0") | |
| << " /* evaluated by -frewrite-includes */" << MainEOL; | |
| WriteLineInfo(FileName, Line, FileType); | |
| break; | |
| } | |
| case tok::pp_endif: | |
| case tok::pp_else: { | |
| // We surround every #include by #if 0 to comment it out, but that | |
| // changes line numbers. These are fixed up right after that, but | |
| // the whole #include could be inside a preprocessor conditional | |
| // that is not processed. So it is necessary to fix the line | |
| // numbers one the next line after each #else/#endif as well. | |
| RawLex.SetKeepWhitespaceMode(true); | |
| do { | |
| RawLex.LexFromRawLexer(RawToken); | |
| } while (RawToken.isNot(tok::eod) && RawToken.isNot(tok::eof)); | |
| OutputContentUpTo(FromFile, NextToWrite, | |
| SM.getFileOffset(RawToken.getLocation()) + | |
| RawToken.getLength(), | |
| LocalEOL, Line, /*EnsureNewline=*/ true); | |
| WriteLineInfo(FileName, Line, FileType); | |
| RawLex.SetKeepWhitespaceMode(false); | |
| break; | |
| } | |
| default: | |
| break; | |
| } | |
| } | |
| RawLex.setParsingPreprocessorDirective(false); | |
| } | |
| RawLex.LexFromRawLexer(RawToken); | |
| } | |
| OutputContentUpTo(FromFile, NextToWrite, | |
| SM.getFileOffset(SM.getLocForEndOfFile(FileId)), LocalEOL, | |
| Line, /*EnsureNewline=*/true); | |
| } | |
| /// InclusionRewriterInInput - Implement -frewrite-includes mode. | |
| void clang::RewriteIncludesInInput(Preprocessor &PP, raw_ostream *OS, | |
| const PreprocessorOutputOptions &Opts) { | |
| SourceManager &SM = PP.getSourceManager(); | |
| InclusionRewriter *Rewrite = new InclusionRewriter( | |
| PP, *OS, Opts.ShowLineMarkers, Opts.UseLineDirectives); | |
| Rewrite->detectMainFileEOL(); | |
| PP.addPPCallbacks(std::unique_ptr<PPCallbacks>(Rewrite)); | |
| PP.IgnorePragmas(); | |
| // First let the preprocessor process the entire file and call callbacks. | |
| // Callbacks will record which #include's were actually performed. | |
| PP.EnterMainSourceFile(); | |
| Token Tok; | |
| // Only preprocessor directives matter here, so disable macro expansion | |
| // everywhere else as an optimization. | |
| // TODO: It would be even faster if the preprocessor could be switched | |
| // to a mode where it would parse only preprocessor directives and comments, | |
| // nothing else matters for parsing or processing. | |
| PP.SetMacroExpansionOnlyInDirectives(); | |
| do { | |
| PP.Lex(Tok); | |
| if (Tok.is(tok::annot_module_begin)) | |
| Rewrite->handleModuleBegin(Tok); | |
| } while (Tok.isNot(tok::eof)); | |
| Rewrite->setPredefinesBuffer(SM.getBufferOrFake(PP.getPredefinesFileID())); | |
| Rewrite->Process(PP.getPredefinesFileID(), SrcMgr::C_User); | |
| Rewrite->Process(SM.getMainFileID(), SrcMgr::C_User); | |
| OS->flush(); | |
| } |