| //== HTMLRewrite.cpp - Translate source code into prettified HTML --*- C++ -*-// | |
| // | |
| // 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 file defines the HTMLRewriter class, which is used to translate the | |
| // text of a source file into prettified HTML. | |
| // | |
| //===----------------------------------------------------------------------===// | |
| #include "clang/Rewrite/Core/HTMLRewrite.h" | |
| #include "clang/Basic/SourceManager.h" | |
| #include "clang/Lex/Preprocessor.h" | |
| #include "clang/Lex/TokenConcatenation.h" | |
| #include "clang/Rewrite/Core/Rewriter.h" | |
| #include "llvm/ADT/RewriteBuffer.h" | |
| #include "llvm/Support/ErrorHandling.h" | |
| #include "llvm/Support/raw_ostream.h" | |
| #include <memory> | |
| using namespace clang; | |
| using namespace llvm; | |
| using namespace html; | |
| /// HighlightRange - Highlight a range in the source code with the specified | |
| /// start/end tags. B/E must be in the same file. This ensures that | |
| /// start/end tags are placed at the start/end of each line if the range is | |
| /// multiline. | |
| void html::HighlightRange(Rewriter &R, SourceLocation B, SourceLocation E, | |
| const char *StartTag, const char *EndTag, | |
| bool IsTokenRange) { | |
| SourceManager &SM = R.getSourceMgr(); | |
| B = SM.getExpansionLoc(B); | |
| E = SM.getExpansionLoc(E); | |
| FileID FID = SM.getFileID(B); | |
| assert(SM.getFileID(E) == FID && "B/E not in the same file!"); | |
| unsigned BOffset = SM.getFileOffset(B); | |
| unsigned EOffset = SM.getFileOffset(E); | |
| // Include the whole end token in the range. | |
| if (IsTokenRange) | |
| EOffset += Lexer::MeasureTokenLength(E, R.getSourceMgr(), R.getLangOpts()); | |
| bool Invalid = false; | |
| const char *BufferStart = SM.getBufferData(FID, &Invalid).data(); | |
| if (Invalid) | |
| return; | |
| HighlightRange(R.getEditBuffer(FID), BOffset, EOffset, | |
| BufferStart, StartTag, EndTag); | |
| } | |
| /// HighlightRange - This is the same as the above method, but takes | |
| /// decomposed file locations. | |
| void html::HighlightRange(RewriteBuffer &RB, unsigned B, unsigned E, | |
| const char *BufferStart, | |
| const char *StartTag, const char *EndTag) { | |
| // Insert the tag at the absolute start/end of the range. | |
| RB.InsertTextAfter(B, StartTag); | |
| RB.InsertTextBefore(E, EndTag); | |
| // Scan the range to see if there is a \r or \n. If so, and if the line is | |
| // not blank, insert tags on that line as well. | |
| bool HadOpenTag = true; | |
| unsigned LastNonWhiteSpace = B; | |
| for (unsigned i = B; i != E; ++i) { | |
| switch (BufferStart[i]) { | |
| case '\r': | |
| case '\n': | |
| // Okay, we found a newline in the range. If we have an open tag, we need | |
| // to insert a close tag at the first non-whitespace before the newline. | |
| if (HadOpenTag) | |
| RB.InsertTextBefore(LastNonWhiteSpace+1, EndTag); | |
| // Instead of inserting an open tag immediately after the newline, we | |
| // wait until we see a non-whitespace character. This prevents us from | |
| // inserting tags around blank lines, and also allows the open tag to | |
| // be put *after* whitespace on a non-blank line. | |
| HadOpenTag = false; | |
| break; | |
| case '\0': | |
| case ' ': | |
| case '\t': | |
| case '\f': | |
| case '\v': | |
| // Ignore whitespace. | |
| break; | |
| default: | |
| // If there is no tag open, do it now. | |
| if (!HadOpenTag) { | |
| RB.InsertTextAfter(i, StartTag); | |
| HadOpenTag = true; | |
| } | |
| // Remember this character. | |
| LastNonWhiteSpace = i; | |
| break; | |
| } | |
| } | |
| } | |
| namespace clang::html { | |
| struct RelexRewriteCache { | |
| // These structs mimic input arguments of HighlightRange(). | |
| struct Highlight { | |
| SourceLocation B, E; | |
| std::string StartTag, EndTag; | |
| bool IsTokenRange; | |
| }; | |
| struct RawHighlight { | |
| unsigned B, E; | |
| std::string StartTag, EndTag; | |
| }; | |
| // SmallVector isn't appropriate because these vectors are almost never small. | |
| using HighlightList = std::vector<Highlight>; | |
| using RawHighlightList = std::vector<RawHighlight>; | |
| DenseMap<FileID, RawHighlightList> SyntaxHighlights; | |
| DenseMap<FileID, HighlightList> MacroHighlights; | |
| }; | |
| } // namespace clang::html | |
| html::RelexRewriteCacheRef html::instantiateRelexRewriteCache() { | |
| return std::make_shared<RelexRewriteCache>(); | |
| } | |
| void html::EscapeText(Rewriter &R, FileID FID, | |
| bool EscapeSpaces, bool ReplaceTabs) { | |
| llvm::MemoryBufferRef Buf = R.getSourceMgr().getBufferOrFake(FID); | |
| const char* C = Buf.getBufferStart(); | |
| const char* FileEnd = Buf.getBufferEnd(); | |
| assert (C <= FileEnd); | |
| RewriteBuffer &RB = R.getEditBuffer(FID); | |
| unsigned ColNo = 0; | |
| for (unsigned FilePos = 0; C != FileEnd ; ++C, ++FilePos) { | |
| switch (*C) { | |
| default: ++ColNo; break; | |
| case '\n': | |
| case '\r': | |
| ColNo = 0; | |
| break; | |
| case ' ': | |
| if (EscapeSpaces) | |
| RB.ReplaceText(FilePos, 1, " "); | |
| ++ColNo; | |
| break; | |
| case '\f': | |
| RB.ReplaceText(FilePos, 1, "<hr>"); | |
| ColNo = 0; | |
| break; | |
| case '\t': { | |
| if (!ReplaceTabs) | |
| break; | |
| unsigned NumSpaces = 8-(ColNo&7); | |
| if (EscapeSpaces) | |
| RB.ReplaceText(FilePos, 1, | |
| StringRef(" " | |
| " ", 6*NumSpaces)); | |
| else | |
| RB.ReplaceText(FilePos, 1, StringRef(" ", NumSpaces)); | |
| ColNo += NumSpaces; | |
| break; | |
| } | |
| case '<': | |
| RB.ReplaceText(FilePos, 1, "<"); | |
| ++ColNo; | |
| break; | |
| case '>': | |
| RB.ReplaceText(FilePos, 1, ">"); | |
| ++ColNo; | |
| break; | |
| case '&': | |
| RB.ReplaceText(FilePos, 1, "&"); | |
| ++ColNo; | |
| break; | |
| } | |
| } | |
| } | |
| std::string html::EscapeText(StringRef s, bool EscapeSpaces, bool ReplaceTabs) { | |
| unsigned len = s.size(); | |
| std::string Str; | |
| llvm::raw_string_ostream os(Str); | |
| for (unsigned i = 0 ; i < len; ++i) { | |
| char c = s[i]; | |
| switch (c) { | |
| default: | |
| os << c; break; | |
| case ' ': | |
| if (EscapeSpaces) os << " "; | |
| else os << ' '; | |
| break; | |
| case '\t': | |
| if (ReplaceTabs) { | |
| if (EscapeSpaces) | |
| for (unsigned i = 0; i < 4; ++i) | |
| os << " "; | |
| else | |
| for (unsigned i = 0; i < 4; ++i) | |
| os << " "; | |
| } | |
| else | |
| os << c; | |
| break; | |
| case '<': os << "<"; break; | |
| case '>': os << ">"; break; | |
| case '&': os << "&"; break; | |
| } | |
| } | |
| return Str; | |
| } | |
| static void AddLineNumber(RewriteBuffer &RB, unsigned LineNo, | |
| unsigned B, unsigned E) { | |
| SmallString<256> Str; | |
| llvm::raw_svector_ostream OS(Str); | |
| OS << "<tr class=\"codeline\" data-linenumber=\"" << LineNo << "\">" | |
| << "<td class=\"num\" id=\"LN" << LineNo << "\">" << LineNo | |
| << "</td><td class=\"line\">"; | |
| if (B == E) { // Handle empty lines. | |
| OS << " </td></tr>"; | |
| RB.InsertTextBefore(B, OS.str()); | |
| } else { | |
| RB.InsertTextBefore(B, OS.str()); | |
| RB.InsertTextBefore(E, "</td></tr>"); | |
| } | |
| } | |
| void html::AddLineNumbers(Rewriter& R, FileID FID) { | |
| llvm::MemoryBufferRef Buf = R.getSourceMgr().getBufferOrFake(FID); | |
| const char* FileBeg = Buf.getBufferStart(); | |
| const char* FileEnd = Buf.getBufferEnd(); | |
| const char* C = FileBeg; | |
| RewriteBuffer &RB = R.getEditBuffer(FID); | |
| assert (C <= FileEnd); | |
| unsigned LineNo = 0; | |
| unsigned FilePos = 0; | |
| while (C != FileEnd) { | |
| ++LineNo; | |
| unsigned LineStartPos = FilePos; | |
| unsigned LineEndPos = FileEnd - FileBeg; | |
| assert (FilePos <= LineEndPos); | |
| assert (C < FileEnd); | |
| // Scan until the newline (or end-of-file). | |
| while (C != FileEnd) { | |
| char c = *C; | |
| ++C; | |
| if (c == '\n') { | |
| LineEndPos = FilePos++; | |
| break; | |
| } | |
| ++FilePos; | |
| } | |
| AddLineNumber(RB, LineNo, LineStartPos, LineEndPos); | |
| } | |
| // Add one big table tag that surrounds all of the code. | |
| std::string s; | |
| llvm::raw_string_ostream os(s); | |
| os << "<table class=\"code\" data-fileid=\"" << FID.getHashValue() << "\">\n"; | |
| RB.InsertTextBefore(0, os.str()); | |
| RB.InsertTextAfter(FileEnd - FileBeg, "</table>"); | |
| } | |
| void html::AddHeaderFooterInternalBuiltinCSS(Rewriter &R, FileID FID, | |
| StringRef title) { | |
| llvm::MemoryBufferRef Buf = R.getSourceMgr().getBufferOrFake(FID); | |
| const char* FileStart = Buf.getBufferStart(); | |
| const char* FileEnd = Buf.getBufferEnd(); | |
| SourceLocation StartLoc = R.getSourceMgr().getLocForStartOfFile(FID); | |
| SourceLocation EndLoc = StartLoc.getLocWithOffset(FileEnd-FileStart); | |
| std::string s; | |
| llvm::raw_string_ostream os(s); | |
| os << "<!doctype html>\n" // Use HTML 5 doctype | |
| "<html>\n<head>\n"; | |
| if (!title.empty()) | |
| os << "<title>" << html::EscapeText(title) << "</title>\n"; | |
| os << R"<<<( | |
| <style type="text/css"> | |
| body { color:#000000; background-color:#ffffff } | |
| body { font-family:Helvetica, sans-serif; font-size:10pt } | |
| h1 { font-size:14pt } | |
| .FileName { margin-top: 5px; margin-bottom: 5px; display: inline; } | |
| .FileNav { margin-left: 5px; margin-right: 5px; display: inline; } | |
| .FileNav a { text-decoration:none; font-size: larger; } | |
| .divider { margin-top: 30px; margin-bottom: 30px; height: 15px; } | |
| .divider { background-color: gray; } | |
| .code { border-collapse:collapse; width:100%; } | |
| .code { font-family: "Monospace", monospace; font-size:10pt } | |
| .code { line-height: 1.2em } | |
| .comment { color: green; font-style: oblique } | |
| .keyword { color: blue } | |
| .string_literal { color: red } | |
| .directive { color: darkmagenta } | |
| /* Macros and variables could have pop-up notes hidden by default. | |
| - Macro pop-up: expansion of the macro | |
| - Variable pop-up: value (table) of the variable */ | |
| .macro_popup, .variable_popup { display: none; } | |
| /* Pop-up appears on mouse-hover event. */ | |
| .macro:hover .macro_popup, .variable:hover .variable_popup { | |
| display: block; | |
| padding: 2px; | |
| -webkit-border-radius:5px; | |
| -webkit-box-shadow:1px 1px 7px #000; | |
| border-radius:5px; | |
| box-shadow:1px 1px 7px #000; | |
| position: absolute; | |
| top: -1em; | |
| left:10em; | |
| z-index: 1 | |
| } | |
| .macro_popup { | |
| border: 2px solid red; | |
| background-color:#FFF0F0; | |
| font-weight: normal; | |
| } | |
| .variable_popup { | |
| border: 2px solid blue; | |
| background-color:#F0F0FF; | |
| font-weight: bold; | |
| font-family: Helvetica, sans-serif; | |
| font-size: 9pt; | |
| } | |
| /* Pop-up notes needs a relative position as a base where they pops up. */ | |
| .macro, .variable { | |
| background-color: PaleGoldenRod; | |
| position: relative; | |
| } | |
| .macro { color: DarkMagenta; } | |
| #tooltiphint { | |
| position: fixed; | |
| width: 50em; | |
| margin-left: -25em; | |
| left: 50%; | |
| padding: 10px; | |
| border: 1px solid #b0b0b0; | |
| border-radius: 2px; | |
| box-shadow: 1px 1px 7px black; | |
| background-color: #c0c0c0; | |
| z-index: 2; | |
| } | |
| .num { width:2.5em; padding-right:2ex; background-color:#eeeeee } | |
| .num { text-align:right; font-size:8pt } | |
| .num { color:#444444 } | |
| .line { padding-left: 1ex; border-left: 3px solid #ccc } | |
| .line { white-space: pre } | |
| .msg { -webkit-box-shadow:1px 1px 7px #000 } | |
| .msg { box-shadow:1px 1px 7px #000 } | |
| .msg { -webkit-border-radius:5px } | |
| .msg { border-radius:5px } | |
| .msg { font-family:Helvetica, sans-serif; font-size:8pt } | |
| .msg { float:left } | |
| .msg { position:relative } | |
| .msg { padding:0.25em 1ex 0.25em 1ex } | |
| .msg { margin-top:10px; margin-bottom:10px } | |
| .msg { font-weight:bold } | |
| .msg { max-width:60em; word-wrap: break-word; white-space: pre-wrap } | |
| .msgT { padding:0x; spacing:0x } | |
| .msgEvent { background-color:#fff8b4; color:#000000 } | |
| .msgControl { background-color:#bbbbbb; color:#000000 } | |
| .msgNote { background-color:#ddeeff; color:#000000 } | |
| .mrange { background-color:#dfddf3 } | |
| .mrange { border-bottom:1px solid #6F9DBE } | |
| .PathIndex { font-weight: bold; padding:0px 5px; margin-right:5px; } | |
| .PathIndex { -webkit-border-radius:8px } | |
| .PathIndex { border-radius:8px } | |
| .PathIndexEvent { background-color:#bfba87 } | |
| .PathIndexControl { background-color:#8c8c8c } | |
| .PathIndexPopUp { background-color: #879abc; } | |
| .PathNav a { text-decoration:none; font-size: larger } | |
| .CodeInsertionHint { font-weight: bold; background-color: #10dd10 } | |
| .CodeRemovalHint { background-color:#de1010 } | |
| .CodeRemovalHint { border-bottom:1px solid #6F9DBE } | |
| .msg.selected{ background-color:orange !important; } | |
| table.simpletable { | |
| padding: 5px; | |
| font-size:12pt; | |
| margin:20px; | |
| border-collapse: collapse; border-spacing: 0px; | |
| } | |
| td.rowname { | |
| text-align: right; | |
| vertical-align: top; | |
| font-weight: bold; | |
| color:#444444; | |
| padding-right:2ex; | |
| } | |
| /* Hidden text. */ | |
| input.spoilerhider + label { | |
| cursor: pointer; | |
| text-decoration: underline; | |
| display: block; | |
| } | |
| input.spoilerhider { | |
| display: none; | |
| } | |
| input.spoilerhider ~ .spoiler { | |
| overflow: hidden; | |
| margin: 10px auto 0; | |
| height: 0; | |
| opacity: 0; | |
| } | |
| input.spoilerhider:checked + label + .spoiler{ | |
| height: auto; | |
| opacity: 1; | |
| } | |
| </style> | |
| </head> | |
| <body>)<<<"; | |
| // Generate header | |
| R.InsertTextBefore(StartLoc, os.str()); | |
| // Generate footer | |
| R.InsertTextAfter(EndLoc, "</body></html>\n"); | |
| } | |
| /// SyntaxHighlight - Relex the specified FileID and annotate the HTML with | |
| /// information about keywords, macro expansions etc. This uses the macro | |
| /// table state from the end of the file, so it won't be perfectly perfect, | |
| /// but it will be reasonably close. | |
| static void SyntaxHighlightImpl( | |
| Rewriter &R, FileID FID, const Preprocessor &PP, | |
| llvm::function_ref<void(RewriteBuffer &, unsigned, unsigned, const char *, | |
| const char *, const char *)> | |
| HighlightRangeCallback) { | |
| RewriteBuffer &RB = R.getEditBuffer(FID); | |
| const SourceManager &SM = PP.getSourceManager(); | |
| llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(FID); | |
| const char *BufferStart = FromFile.getBuffer().data(); | |
| Lexer L(FID, FromFile, SM, PP.getLangOpts()); | |
| // Inform the preprocessor that we want to retain comments as tokens, so we | |
| // can highlight them. | |
| L.SetCommentRetentionState(true); | |
| // Lex all the tokens in raw mode, to avoid entering #includes or expanding | |
| // macros. | |
| Token Tok; | |
| L.LexFromRawLexer(Tok); | |
| while (Tok.isNot(tok::eof)) { | |
| // Since we are lexing unexpanded tokens, all tokens are from the main | |
| // FileID. | |
| unsigned TokOffs = SM.getFileOffset(Tok.getLocation()); | |
| unsigned TokLen = Tok.getLength(); | |
| switch (Tok.getKind()) { | |
| default: break; | |
| case tok::identifier: | |
| llvm_unreachable("tok::identifier in raw lexing mode!"); | |
| case tok::raw_identifier: { | |
| // Fill in Result.IdentifierInfo and update the token kind, | |
| // looking up the identifier in the identifier table. | |
| PP.LookUpIdentifierInfo(Tok); | |
| // If this is a pp-identifier, for a keyword, highlight it as such. | |
| if (Tok.isNot(tok::identifier)) | |
| HighlightRangeCallback(RB, TokOffs, TokOffs + TokLen, BufferStart, | |
| "<span class='keyword'>", "</span>"); | |
| break; | |
| } | |
| case tok::comment: | |
| HighlightRangeCallback(RB, TokOffs, TokOffs + TokLen, BufferStart, | |
| "<span class='comment'>", "</span>"); | |
| break; | |
| case tok::utf8_string_literal: | |
| // Chop off the u part of u8 prefix | |
| ++TokOffs; | |
| --TokLen; | |
| // FALL THROUGH to chop the 8 | |
| [[fallthrough]]; | |
| case tok::wide_string_literal: | |
| case tok::utf16_string_literal: | |
| case tok::utf32_string_literal: | |
| // Chop off the L, u, U or 8 prefix | |
| ++TokOffs; | |
| --TokLen; | |
| [[fallthrough]]; | |
| case tok::string_literal: | |
| // FIXME: Exclude the optional ud-suffix from the highlighted range. | |
| HighlightRangeCallback(RB, TokOffs, TokOffs + TokLen, BufferStart, | |
| "<span class='string_literal'>", "</span>"); | |
| break; | |
| case tok::hash: { | |
| // If this is a preprocessor directive, all tokens to end of line are too. | |
| if (!Tok.isAtStartOfLine()) | |
| break; | |
| // Eat all of the tokens until we get to the next one at the start of | |
| // line. | |
| unsigned TokEnd = TokOffs+TokLen; | |
| L.LexFromRawLexer(Tok); | |
| while (!Tok.isAtStartOfLine() && Tok.isNot(tok::eof)) { | |
| TokEnd = SM.getFileOffset(Tok.getLocation())+Tok.getLength(); | |
| L.LexFromRawLexer(Tok); | |
| } | |
| // Find end of line. This is a hack. | |
| HighlightRangeCallback(RB, TokOffs, TokEnd, BufferStart, | |
| "<span class='directive'>", "</span>"); | |
| // Don't skip the next token. | |
| continue; | |
| } | |
| } | |
| L.LexFromRawLexer(Tok); | |
| } | |
| } | |
| void html::SyntaxHighlight(Rewriter &R, FileID FID, const Preprocessor &PP, | |
| RelexRewriteCacheRef Cache) { | |
| RewriteBuffer &RB = R.getEditBuffer(FID); | |
| const SourceManager &SM = PP.getSourceManager(); | |
| llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(FID); | |
| const char *BufferStart = FromFile.getBuffer().data(); | |
| if (Cache) { | |
| auto CacheIt = Cache->SyntaxHighlights.find(FID); | |
| if (CacheIt != Cache->SyntaxHighlights.end()) { | |
| for (const RelexRewriteCache::RawHighlight &H : CacheIt->second) { | |
| HighlightRange(RB, H.B, H.E, BufferStart, H.StartTag.data(), | |
| H.EndTag.data()); | |
| } | |
| return; | |
| } | |
| } | |
| // "Every time you would call HighlightRange, cache the inputs as well." | |
| auto HighlightRangeCallback = [&](RewriteBuffer &RB, unsigned B, unsigned E, | |
| const char *BufferStart, | |
| const char *StartTag, const char *EndTag) { | |
| HighlightRange(RB, B, E, BufferStart, StartTag, EndTag); | |
| if (Cache) | |
| Cache->SyntaxHighlights[FID].push_back({B, E, StartTag, EndTag}); | |
| }; | |
| SyntaxHighlightImpl(R, FID, PP, HighlightRangeCallback); | |
| } | |
| static void HighlightMacrosImpl( | |
| Rewriter &R, FileID FID, const Preprocessor &PP, | |
| llvm::function_ref<void(Rewriter &, SourceLocation, SourceLocation, | |
| const char *, const char *, bool)> | |
| HighlightRangeCallback) { | |
| // Re-lex the raw token stream into a token buffer. | |
| const SourceManager &SM = PP.getSourceManager(); | |
| std::vector<Token> TokenStream; | |
| llvm::MemoryBufferRef FromFile = SM.getBufferOrFake(FID); | |
| Lexer L(FID, FromFile, SM, PP.getLangOpts()); | |
| // Lex all the tokens in raw mode, to avoid entering #includes or expanding | |
| // macros. | |
| while (true) { | |
| Token Tok; | |
| L.LexFromRawLexer(Tok); | |
| // If this is a # at the start of a line, discard it from the token stream. | |
| // We don't want the re-preprocess step to see #defines, #includes or other | |
| // preprocessor directives. | |
| if (Tok.is(tok::hash) && Tok.isAtStartOfLine()) | |
| continue; | |
| // If this is a ## token, change its kind to unknown so that repreprocessing | |
| // it will not produce an error. | |
| if (Tok.is(tok::hashhash)) | |
| Tok.setKind(tok::unknown); | |
| // If this raw token is an identifier, the raw lexer won't have looked up | |
| // the corresponding identifier info for it. Do this now so that it will be | |
| // macro expanded when we re-preprocess it. | |
| if (Tok.is(tok::raw_identifier)) | |
| PP.LookUpIdentifierInfo(Tok); | |
| TokenStream.push_back(Tok); | |
| if (Tok.is(tok::eof)) break; | |
| } | |
| // Temporarily change the diagnostics object so that we ignore any generated | |
| // diagnostics from this pass. | |
| DiagnosticsEngine TmpDiags(PP.getDiagnostics().getDiagnosticIDs(), | |
| PP.getDiagnostics().getDiagnosticOptions(), | |
| new IgnoringDiagConsumer); | |
| // FIXME: This is a huge hack; we reuse the input preprocessor because we want | |
| // its state, but we aren't actually changing it (we hope). This should really | |
| // construct a copy of the preprocessor. | |
| Preprocessor &TmpPP = const_cast<Preprocessor&>(PP); | |
| DiagnosticsEngine *OldDiags = &TmpPP.getDiagnostics(); | |
| TmpPP.setDiagnostics(TmpDiags); | |
| // Inform the preprocessor that we don't want comments. | |
| TmpPP.SetCommentRetentionState(false, false); | |
| // We don't want pragmas either. Although we filtered out #pragma, removing | |
| // _Pragma and __pragma is much harder. | |
| bool PragmasPreviouslyEnabled = TmpPP.getPragmasEnabled(); | |
| TmpPP.setPragmasEnabled(false); | |
| // Enter the tokens we just lexed. This will cause them to be macro expanded | |
| // but won't enter sub-files (because we removed #'s). | |
| TmpPP.EnterTokenStream(TokenStream, false, /*IsReinject=*/false); | |
| TokenConcatenation ConcatInfo(TmpPP); | |
| // Lex all the tokens. | |
| Token Tok; | |
| TmpPP.Lex(Tok); | |
| while (Tok.isNot(tok::eof)) { | |
| // Ignore non-macro tokens. | |
| if (!Tok.getLocation().isMacroID()) { | |
| TmpPP.Lex(Tok); | |
| continue; | |
| } | |
| // Okay, we have the first token of a macro expansion: highlight the | |
| // expansion by inserting a start tag before the macro expansion and | |
| // end tag after it. | |
| CharSourceRange LLoc = SM.getExpansionRange(Tok.getLocation()); | |
| // Ignore tokens whose instantiation location was not the main file. | |
| if (SM.getFileID(LLoc.getBegin()) != FID) { | |
| TmpPP.Lex(Tok); | |
| continue; | |
| } | |
| assert(SM.getFileID(LLoc.getEnd()) == FID && | |
| "Start and end of expansion must be in the same ultimate file!"); | |
| std::string Expansion = EscapeText(TmpPP.getSpelling(Tok)); | |
| unsigned LineLen = Expansion.size(); | |
| Token PrevPrevTok; | |
| Token PrevTok = Tok; | |
| // Okay, eat this token, getting the next one. | |
| TmpPP.Lex(Tok); | |
| // Skip all the rest of the tokens that are part of this macro | |
| // instantiation. It would be really nice to pop up a window with all the | |
| // spelling of the tokens or something. | |
| while (!Tok.is(tok::eof) && | |
| SM.getExpansionLoc(Tok.getLocation()) == LLoc.getBegin()) { | |
| // Insert a newline if the macro expansion is getting large. | |
| if (LineLen > 60) { | |
| Expansion += "<br>"; | |
| LineLen = 0; | |
| } | |
| LineLen -= Expansion.size(); | |
| // If the tokens were already space separated, or if they must be to avoid | |
| // them being implicitly pasted, add a space between them. | |
| if (Tok.hasLeadingSpace() || | |
| ConcatInfo.AvoidConcat(PrevPrevTok, PrevTok, Tok)) | |
| Expansion += ' '; | |
| // Escape any special characters in the token text. | |
| Expansion += EscapeText(TmpPP.getSpelling(Tok)); | |
| LineLen += Expansion.size(); | |
| PrevPrevTok = PrevTok; | |
| PrevTok = Tok; | |
| TmpPP.Lex(Tok); | |
| } | |
| // Insert the 'macro_popup' as the end tag, so that multi-line macros all | |
| // get highlighted. | |
| Expansion = "<span class='macro_popup'>" + Expansion + "</span></span>"; | |
| HighlightRangeCallback(R, LLoc.getBegin(), LLoc.getEnd(), | |
| "<span class='macro'>", Expansion.c_str(), | |
| LLoc.isTokenRange()); | |
| } | |
| // Restore the preprocessor's old state. | |
| TmpPP.setDiagnostics(*OldDiags); | |
| TmpPP.setPragmasEnabled(PragmasPreviouslyEnabled); | |
| } | |
| /// HighlightMacros - This uses the macro table state from the end of the | |
| /// file, to re-expand macros and insert (into the HTML) information about the | |
| /// macro expansions. This won't be perfectly perfect, but it will be | |
| /// reasonably close. | |
| void html::HighlightMacros(Rewriter &R, FileID FID, const Preprocessor &PP, | |
| RelexRewriteCacheRef Cache) { | |
| if (Cache) { | |
| auto CacheIt = Cache->MacroHighlights.find(FID); | |
| if (CacheIt != Cache->MacroHighlights.end()) { | |
| for (const RelexRewriteCache::Highlight &H : CacheIt->second) { | |
| HighlightRange(R, H.B, H.E, H.StartTag.data(), H.EndTag.data(), | |
| H.IsTokenRange); | |
| } | |
| return; | |
| } | |
| } | |
| // "Every time you would call HighlightRange, cache the inputs as well." | |
| auto HighlightRangeCallback = [&](Rewriter &R, SourceLocation B, | |
| SourceLocation E, const char *StartTag, | |
| const char *EndTag, bool isTokenRange) { | |
| HighlightRange(R, B, E, StartTag, EndTag, isTokenRange); | |
| if (Cache) { | |
| Cache->MacroHighlights[FID].push_back( | |
| {B, E, StartTag, EndTag, isTokenRange}); | |
| } | |
| }; | |
| HighlightMacrosImpl(R, FID, PP, HighlightRangeCallback); | |
| } |