contrib/llvm/tools/clang/lib/Rewrite/HTMLRewrite.cpp

   1 //== HTMLRewrite.cpp - Translate source code into prettified HTML --*- 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 HTMLRewriter clas, which is used to translate the
  11 //  text of a source file into prettified HTML.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "clang/Lex/Preprocessor.h"
  16 #include "clang/Rewrite/Rewriter.h"
  17 #include "clang/Rewrite/HTMLRewrite.h"
  18 #include "clang/Lex/TokenConcatenation.h"
  19 #include "clang/Lex/Preprocessor.h"
  20 #include "clang/Basic/SourceManager.h"
  21 #include "llvm/ADT/SmallString.h"
  22 #include "llvm/ADT/OwningPtr.h"
  23 #include "llvm/Support/ErrorHandling.h"
  24 #include "llvm/Support/MemoryBuffer.h"
  25 #include "llvm/Support/raw_ostream.h"
  26 using namespace clang;
  27
  28
  29 /// HighlightRange - Highlight a range in the source code with the specified
  30 /// start/end tags.  B/E must be in the same file.  This ensures that
  31 /// start/end tags are placed at the start/end of each line if the range is
  32 /// multiline.
  33 void html::HighlightRange(Rewriter &R, SourceLocation B, SourceLocation E,
  34                           const char *StartTag, const char *EndTag) {
  35   SourceManager &SM = R.getSourceMgr();
  36   B = SM.getExpansionLoc(B);
  37   E = SM.getExpansionLoc(E);
  38   FileID FID = SM.getFileID(B);
  39   assert(SM.getFileID(E) == FID && "B/E not in the same file!");
  40
  41   unsigned BOffset = SM.getFileOffset(B);
  42   unsigned EOffset = SM.getFileOffset(E);
  43
  44   // Include the whole end token in the range.
  45   EOffset += Lexer::MeasureTokenLength(E, R.getSourceMgr(), R.getLangOpts());
  46
  47   bool Invalid = false;
  48   const char *BufferStart = SM.getBufferData(FID, &Invalid).data();
  49   if (Invalid)
  50     return;
  51
  52   HighlightRange(R.getEditBuffer(FID), BOffset, EOffset,
  53                  BufferStart, StartTag, EndTag);
  54 }
  55
  56 /// HighlightRange - This is the same as the above method, but takes
  57 /// decomposed file locations.
  58 void html::HighlightRange(RewriteBuffer &RB, unsigned B, unsigned E,
  59                           const char *BufferStart,
  60                           const char *StartTag, const char *EndTag) {
  61   // Insert the tag at the absolute start/end of the range.
  62   RB.InsertTextAfter(B, StartTag);
  63   RB.InsertTextBefore(E, EndTag);
  64
  65   // Scan the range to see if there is a \r or \n.  If so, and if the line is
  66   // not blank, insert tags on that line as well.
  67   bool HadOpenTag = true;
  68
  69   unsigned LastNonWhiteSpace = B;
  70   for (unsigned i = B; i != E; ++i) {
  71     switch (BufferStart[i]) {
  72     case '\r':
  73     case '\n':
  74       // Okay, we found a newline in the range.  If we have an open tag, we need
  75       // to insert a close tag at the first non-whitespace before the newline.
  76       if (HadOpenTag)
  77         RB.InsertTextBefore(LastNonWhiteSpace+1, EndTag);
  78
  79       // Instead of inserting an open tag immediately after the newline, we
  80       // wait until we see a non-whitespace character.  This prevents us from
  81       // inserting tags around blank lines, and also allows the open tag to
  82       // be put *after* whitespace on a non-blank line.
  83       HadOpenTag = false;
  84       break;
  85     case '\0':
  86     case ' ':
  87     case '\t':
  88     case '\f':
  89     case '\v':
  90       // Ignore whitespace.
  91       break;
  92
  93     default:
  94       // If there is no tag open, do it now.
  95       if (!HadOpenTag) {
  96         RB.InsertTextAfter(i, StartTag);
  97         HadOpenTag = true;
  98       }
  99
 100       // Remember this character.
 101       LastNonWhiteSpace = i;
 102       break;
 103     }
 104   }
 105 }
 106
 107 void html::EscapeText(Rewriter &R, FileID FID,
 108                       bool EscapeSpaces, bool ReplaceTabs) {
 109
 110   const llvm::MemoryBuffer *Buf = R.getSourceMgr().getBuffer(FID);
 111   const char* C = Buf->getBufferStart();
 112   const char* FileEnd = Buf->getBufferEnd();
 113
 114   assert (C <= FileEnd);
 115
 116   RewriteBuffer &RB = R.getEditBuffer(FID);
 117
 118   unsigned ColNo = 0;
 119   for (unsigned FilePos = 0; C != FileEnd ; ++C, ++FilePos) {
 120     switch (*C) {
 121     default: ++ColNo; break;
 122     case '\n':
 123     case '\r':
 124       ColNo = 0;
 125       break;
 126
 127     case ' ':
 128       if (EscapeSpaces)
 129         RB.ReplaceText(FilePos, 1, "&nbsp;");
 130       ++ColNo;
 131       break;
 132     case '\f':
 133       RB.ReplaceText(FilePos, 1, "<hr>");
 134       ColNo = 0;
 135       break;
 136
 137     case '\t': {
 138       if (!ReplaceTabs)
 139         break;
 140       unsigned NumSpaces = 8-(ColNo&7);
 141       if (EscapeSpaces)
 142         RB.ReplaceText(FilePos, 1,
 143                        StringRef("&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;"
 144                                        "&nbsp;&nbsp;&nbsp;", 6*NumSpaces));
 145       else
 146         RB.ReplaceText(FilePos, 1, StringRef("        ", NumSpaces));
 147       ColNo += NumSpaces;
 148       break;
 149     }
 150     case '<':
 151       RB.ReplaceText(FilePos, 1, "&lt;");
 152       ++ColNo;
 153       break;
 154
 155     case '>':
 156       RB.ReplaceText(FilePos, 1, "&gt;");
 157       ++ColNo;
 158       break;
 159
 160     case '&':
 161       RB.ReplaceText(FilePos, 1, "&amp;");
 162       ++ColNo;
 163       break;
 164     }
 165   }
 166 }
 167
 168 std::string html::EscapeText(const std::string& s, bool EscapeSpaces,
 169                              bool ReplaceTabs) {
 170
 171   unsigned len = s.size();
 172   std::string Str;
 173   llvm::raw_string_ostream os(Str);
 174
 175   for (unsigned i = 0 ; i < len; ++i) {
 176
 177     char c = s[i];
 178     switch (c) {
 179     default:
 180       os << c; break;
 181
 182     case ' ':
 183       if (EscapeSpaces) os << "&nbsp;";
 184       else os << ' ';
 185       break;
 186
 187     case '\t':
 188       if (ReplaceTabs) {
 189         if (EscapeSpaces)
 190           for (unsigned i = 0; i < 4; ++i)
 191             os << "&nbsp;";
 192         else
 193           for (unsigned i = 0; i < 4; ++i)
 194             os << " ";
 195       }
 196       else
 197         os << c;
 198
 199       break;
 200
 201     case '<': os << "&lt;"; break;
 202     case '>': os << "&gt;"; break;
 203     case '&': os << "&amp;"; break;
 204     }
 205   }
 206
 207   return os.str();
 208 }
 209
 210 static void AddLineNumber(RewriteBuffer &RB, unsigned LineNo,
 211                           unsigned B, unsigned E) {
 212   llvm::SmallString<256> Str;
 213   llvm::raw_svector_ostream OS(Str);
 214
 215   OS << "<tr><td class=\"num\" id=\"LN"
 216      << LineNo << "\">"
 217      << LineNo << "</td><td class=\"line\">";
 218
 219   if (B == E) { // Handle empty lines.
 220     OS << " </td></tr>";
 221     RB.InsertTextBefore(B, OS.str());
 222   } else {
 223     RB.InsertTextBefore(B, OS.str());
 224     RB.InsertTextBefore(E, "</td></tr>");
 225   }
 226 }
 227
 228 void html::AddLineNumbers(Rewriter& R, FileID FID) {
 229
 230   const llvm::MemoryBuffer *Buf = R.getSourceMgr().getBuffer(FID);
 231   const char* FileBeg = Buf->getBufferStart();
 232   const char* FileEnd = Buf->getBufferEnd();
 233   const char* C = FileBeg;
 234   RewriteBuffer &RB = R.getEditBuffer(FID);
 235
 236   assert (C <= FileEnd);
 237
 238   unsigned LineNo = 0;
 239   unsigned FilePos = 0;
 240
 241   while (C != FileEnd) {
 242
 243     ++LineNo;
 244     unsigned LineStartPos = FilePos;
 245     unsigned LineEndPos = FileEnd - FileBeg;
 246
 247     assert (FilePos <= LineEndPos);
 248     assert (C < FileEnd);
 249
 250     // Scan until the newline (or end-of-file).
 251
 252     while (C != FileEnd) {
 253       char c = *C;
 254       ++C;
 255
 256       if (c == '\n') {
 257         LineEndPos = FilePos++;
 258         break;
 259       }
 260
 261       ++FilePos;
 262     }
 263
 264     AddLineNumber(RB, LineNo, LineStartPos, LineEndPos);
 265   }
 266
 267   // Add one big table tag that surrounds all of the code.
 268   RB.InsertTextBefore(0, "<table class=\"code\">\n");
 269   RB.InsertTextAfter(FileEnd - FileBeg, "</table>");
 270 }
 271
 272 void html::AddHeaderFooterInternalBuiltinCSS(Rewriter& R, FileID FID,
 273                                              const char *title) {
 274
 275   const llvm::MemoryBuffer *Buf = R.getSourceMgr().getBuffer(FID);
 276   const char* FileStart = Buf->getBufferStart();
 277   const char* FileEnd = Buf->getBufferEnd();
 278
 279   SourceLocation StartLoc = R.getSourceMgr().getLocForStartOfFile(FID);
 280   SourceLocation EndLoc = StartLoc.getLocWithOffset(FileEnd-FileStart);
 281
 282   std::string s;
 283   llvm::raw_string_ostream os(s);
 284   os << "<!doctype html>\n" // Use HTML 5 doctype
 285         "<html>\n<head>\n";
 286
 287   if (title)
 288     os << "<title>" << html::EscapeText(title) << "</title>\n";
 289
 290   os << "<style type=\"text/css\">\n"
 291       " body { color:#000000; background-color:#ffffff }\n"
 292       " body { font-family:Helvetica, sans-serif; font-size:10pt }\n"
 293       " h1 { font-size:14pt }\n"
 294       " .code { border-collapse:collapse; width:100%; }\n"
 295       " .code { font-family: \"Andale Mono\", monospace; font-size:10pt }\n"
 296       " .code { line-height: 1.2em }\n"
 297       " .comment { color: green; font-style: oblique }\n"
 298       " .keyword { color: blue }\n"
 299       " .string_literal { color: red }\n"
 300       " .directive { color: darkmagenta }\n"
 301       // Macro expansions.
 302       " .expansion { display: none; }\n"
 303       " .macro:hover .expansion { display: block; border: 2px solid #FF0000; "
 304           "padding: 2px; background-color:#FFF0F0; font-weight: normal; "
 305           "  -webkit-border-radius:5px;  -webkit-box-shadow:1px 1px 7px #000; "
 306           "position: absolute; top: -1em; left:10em; z-index: 1 } \n"
 307       " .macro { color: darkmagenta; background-color:LemonChiffon;"
 308              // Macros are position: relative to provide base for expansions.
 309              " position: relative }\n"
 310       " .num { width:2.5em; padding-right:2ex; background-color:#eeeeee }\n"
 311       " .num { text-align:right; font-size:8pt }\n"
 312       " .num { color:#444444 }\n"
 313       " .line { padding-left: 1ex; border-left: 3px solid #ccc }\n"
 314       " .line { white-space: pre }\n"
 315       " .msg { -webkit-box-shadow:1px 1px 7px #000 }\n"
 316       " .msg { -webkit-border-radius:5px }\n"
 317       " .msg { font-family:Helvetica, sans-serif; font-size:8pt }\n"
 318       " .msg { float:left }\n"
 319       " .msg { padding:0.25em 1ex 0.25em 1ex }\n"
 320       " .msg { margin-top:10px; margin-bottom:10px }\n"
 321       " .msg { font-weight:bold }\n"
 322       " .msg { max-width:60em; word-wrap: break-word; white-space: pre-wrap }\n"
 323       " .msgT { padding:0x; spacing:0x }\n"
 324       " .msgEvent { background-color:#fff8b4; color:#000000 }\n"
 325       " .msgControl { background-color:#bbbbbb; color:#000000 }\n"
 326       " .mrange { background-color:#dfddf3 }\n"
 327       " .mrange { border-bottom:1px solid #6F9DBE }\n"
 328       " .PathIndex { font-weight: bold; padding:0px 5px 0px 5px; "
 329         "margin-right:5px; }\n"
 330       " .PathIndex { -webkit-border-radius:8px }\n"
 331       " .PathIndexEvent { background-color:#bfba87 }\n"
 332       " .PathIndexControl { background-color:#8c8c8c }\n"
 333       " .CodeInsertionHint { font-weight: bold; background-color: #10dd10 }\n"
 334       " .CodeRemovalHint { background-color:#de1010 }\n"
 335       " .CodeRemovalHint { border-bottom:1px solid #6F9DBE }\n"
 336       " table.simpletable {\n"
 337       "   padding: 5px;\n"
 338       "   font-size:12pt;\n"
 339       "   margin:20px;\n"
 340       "   border-collapse: collapse; border-spacing: 0px;\n"
 341       " }\n"
 342       " td.rowname {\n"
 343       "   text-align:right; font-weight:bold; color:#444444;\n"
 344       "   padding-right:2ex; }\n"
 345       "</style>\n</head>\n<body>";
 346
 347   // Generate header
 348   R.InsertTextBefore(StartLoc, os.str());
 349   // Generate footer
 350
 351   R.InsertTextAfter(EndLoc, "</body></html>\n");
 352 }
 353
 354 /// SyntaxHighlight - Relex the specified FileID and annotate the HTML with
 355 /// information about keywords, macro expansions etc.  This uses the macro
 356 /// table state from the end of the file, so it won't be perfectly perfect,
 357 /// but it will be reasonably close.
 358 void html::SyntaxHighlight(Rewriter &R, FileID FID, const Preprocessor &PP) {
 359   RewriteBuffer &RB = R.getEditBuffer(FID);
 360
 361   const SourceManager &SM = PP.getSourceManager();
 362   const llvm::MemoryBuffer *FromFile = SM.getBuffer(FID);
 363   Lexer L(FID, FromFile, SM, PP.getLangOptions());
 364   const char *BufferStart = L.getBufferStart();
 365
 366   // Inform the preprocessor that we want to retain comments as tokens, so we
 367   // can highlight them.
 368   L.SetCommentRetentionState(true);
 369
 370   // Lex all the tokens in raw mode, to avoid entering #includes or expanding
 371   // macros.
 372   Token Tok;
 373   L.LexFromRawLexer(Tok);
 374
 375   while (Tok.isNot(tok::eof)) {
 376     // Since we are lexing unexpanded tokens, all tokens are from the main
 377     // FileID.
 378     unsigned TokOffs = SM.getFileOffset(Tok.getLocation());
 379     unsigned TokLen = Tok.getLength();
 380     switch (Tok.getKind()) {
 381     default: break;
 382     case tok::identifier:
 383       llvm_unreachable("tok::identifier in raw lexing mode!");
 384       break;
 385     case tok::raw_identifier: {
 386       // Fill in Result.IdentifierInfo and update the token kind,
 387       // looking up the identifier in the identifier table.
 388       PP.LookUpIdentifierInfo(Tok);
 389
 390       // If this is a pp-identifier, for a keyword, highlight it as such.
 391       if (Tok.isNot(tok::identifier))
 392         HighlightRange(RB, TokOffs, TokOffs+TokLen, BufferStart,
 393                        "<span class='keyword'>", "</span>");
 394       break;
 395     }
 396     case tok::comment:
 397       HighlightRange(RB, TokOffs, TokOffs+TokLen, BufferStart,
 398                      "<span class='comment'>", "</span>");
 399       break;
 400     case tok::utf8_string_literal:
 401       // Chop off the u part of u8 prefix
 402       ++TokOffs;
 403       --TokLen;
 404       // FALL THROUGH to chop the 8
 405     case tok::wide_string_literal:
 406     case tok::utf16_string_literal:
 407     case tok::utf32_string_literal:
 408       // Chop off the L, u, U or 8 prefix
 409       ++TokOffs;
 410       --TokLen;
 411       // FALL THROUGH.
 412     case tok::string_literal:
 413       HighlightRange(RB, TokOffs, TokOffs+TokLen, BufferStart,
 414                      "<span class='string_literal'>", "</span>");
 415       break;
 416     case tok::hash: {
 417       // If this is a preprocessor directive, all tokens to end of line are too.
 418       if (!Tok.isAtStartOfLine())
 419         break;
 420
 421       // Eat all of the tokens until we get to the next one at the start of
 422       // line.
 423       unsigned TokEnd = TokOffs+TokLen;
 424       L.LexFromRawLexer(Tok);
 425       while (!Tok.isAtStartOfLine() && Tok.isNot(tok::eof)) {
 426         TokEnd = SM.getFileOffset(Tok.getLocation())+Tok.getLength();
 427         L.LexFromRawLexer(Tok);
 428       }
 429
 430       // Find end of line.  This is a hack.
 431       HighlightRange(RB, TokOffs, TokEnd, BufferStart,
 432                      "<span class='directive'>", "</span>");
 433
 434       // Don't skip the next token.
 435       continue;
 436     }
 437     }
 438
 439     L.LexFromRawLexer(Tok);
 440   }
 441 }
 442
 443 /// HighlightMacros - This uses the macro table state from the end of the
 444 /// file, to re-expand macros and insert (into the HTML) information about the
 445 /// macro expansions.  This won't be perfectly perfect, but it will be
 446 /// reasonably close.
 447 void html::HighlightMacros(Rewriter &R, FileID FID, const Preprocessor& PP) {
 448   // Re-lex the raw token stream into a token buffer.
 449   const SourceManager &SM = PP.getSourceManager();
 450   std::vector<Token> TokenStream;
 451
 452   const llvm::MemoryBuffer *FromFile = SM.getBuffer(FID);
 453   Lexer L(FID, FromFile, SM, PP.getLangOptions());
 454
 455   // Lex all the tokens in raw mode, to avoid entering #includes or expanding
 456   // macros.
 457   while (1) {
 458     Token Tok;
 459     L.LexFromRawLexer(Tok);
 460
 461     // If this is a # at the start of a line, discard it from the token stream.
 462     // We don't want the re-preprocess step to see #defines, #includes or other
 463     // preprocessor directives.
 464     if (Tok.is(tok::hash) && Tok.isAtStartOfLine())
 465       continue;
 466
 467     // If this is a ## token, change its kind to unknown so that repreprocessing
 468     // it will not produce an error.
 469     if (Tok.is(tok::hashhash))
 470       Tok.setKind(tok::unknown);
 471
 472     // If this raw token is an identifier, the raw lexer won't have looked up
 473     // the corresponding identifier info for it.  Do this now so that it will be
 474     // macro expanded when we re-preprocess it.
 475     if (Tok.is(tok::raw_identifier))
 476       PP.LookUpIdentifierInfo(Tok);
 477
 478     TokenStream.push_back(Tok);
 479
 480     if (Tok.is(tok::eof)) break;
 481   }
 482
 483   // Temporarily change the diagnostics object so that we ignore any generated
 484   // diagnostics from this pass.
 485   DiagnosticsEngine TmpDiags(PP.getDiagnostics().getDiagnosticIDs(),
 486                       new IgnoringDiagConsumer);
 487
 488   // FIXME: This is a huge hack; we reuse the input preprocessor because we want
 489   // its state, but we aren't actually changing it (we hope). This should really
 490   // construct a copy of the preprocessor.
 491   Preprocessor &TmpPP = const_cast<Preprocessor&>(PP);
 492   DiagnosticsEngine *OldDiags = &TmpPP.getDiagnostics();
 493   TmpPP.setDiagnostics(TmpDiags);
 494
 495   // Inform the preprocessor that we don't want comments.
 496   TmpPP.SetCommentRetentionState(false, false);
 497
 498   // Enter the tokens we just lexed.  This will cause them to be macro expanded
 499   // but won't enter sub-files (because we removed #'s).
 500   TmpPP.EnterTokenStream(&TokenStream[0], TokenStream.size(), false, false);
 501
 502   TokenConcatenation ConcatInfo(TmpPP);
 503
 504   // Lex all the tokens.
 505   Token Tok;
 506   TmpPP.Lex(Tok);
 507   while (Tok.isNot(tok::eof)) {
 508     // Ignore non-macro tokens.
 509     if (!Tok.getLocation().isMacroID()) {
 510       TmpPP.Lex(Tok);
 511       continue;
 512     }
 513
 514     // Okay, we have the first token of a macro expansion: highlight the
 515     // expansion by inserting a start tag before the macro expansion and
 516     // end tag after it.
 517     std::pair<SourceLocation, SourceLocation> LLoc =
 518       SM.getExpansionRange(Tok.getLocation());
 519
 520     // Ignore tokens whose instantiation location was not the main file.
 521     if (SM.getFileID(LLoc.first) != FID) {
 522       TmpPP.Lex(Tok);
 523       continue;
 524     }
 525
 526     assert(SM.getFileID(LLoc.second) == FID &&
 527            "Start and end of expansion must be in the same ultimate file!");
 528
 529     std::string Expansion = EscapeText(TmpPP.getSpelling(Tok));
 530     unsigned LineLen = Expansion.size();
 531
 532     Token PrevPrevTok;
 533     Token PrevTok = Tok;
 534     // Okay, eat this token, getting the next one.
 535     TmpPP.Lex(Tok);
 536
 537     // Skip all the rest of the tokens that are part of this macro
 538     // instantiation.  It would be really nice to pop up a window with all the
 539     // spelling of the tokens or something.
 540     while (!Tok.is(tok::eof) &&
 541            SM.getExpansionLoc(Tok.getLocation()) == LLoc.first) {
 542       // Insert a newline if the macro expansion is getting large.
 543       if (LineLen > 60) {
 544         Expansion += "<br>";
 545         LineLen = 0;
 546       }
 547
 548       LineLen -= Expansion.size();
 549
 550       // If the tokens were already space separated, or if they must be to avoid
 551       // them being implicitly pasted, add a space between them.
 552       if (Tok.hasLeadingSpace() ||
 553           ConcatInfo.AvoidConcat(PrevPrevTok, PrevTok, Tok))
 554         Expansion += ' ';
 555
 556       // Escape any special characters in the token text.
 557       Expansion += EscapeText(TmpPP.getSpelling(Tok));
 558       LineLen += Expansion.size();
 559
 560       PrevPrevTok = PrevTok;
 561       PrevTok = Tok;
 562       TmpPP.Lex(Tok);
 563     }
 564
 565
 566     // Insert the expansion as the end tag, so that multi-line macros all get
 567     // highlighted.
 568     Expansion = "<span class='expansion'>" + Expansion + "</span></span>";
 569
 570     HighlightRange(R, LLoc.first, LLoc.second,
 571                    "<span class='macro'>", Expansion.c_str());
 572   }
 573
 574   // Restore diagnostics object back to its own thing.
 575   TmpPP.setDiagnostics(*OldDiags);
 576 }