contrib/llvm/tools/clang/lib/StaticAnalyzer/Core/HTMLDiagnostics.cpp

   1 //===--- HTMLDiagnostics.cpp - HTML Diagnostics for Paths ----*- 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 HTMLDiagnostics object.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/StaticAnalyzer/Core/PathDiagnosticConsumers.h"
  15 #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
  16 #include "clang/AST/ASTContext.h"
  17 #include "clang/AST/Decl.h"
  18 #include "clang/Basic/SourceManager.h"
  19 #include "clang/Basic/FileManager.h"
  20 #include "clang/Rewrite/Rewriter.h"
  21 #include "clang/Rewrite/HTMLRewrite.h"
  22 #include "clang/Lex/Lexer.h"
  23 #include "clang/Lex/Preprocessor.h"
  24 #include "llvm/Support/FileSystem.h"
  25 #include "llvm/Support/MemoryBuffer.h"
  26 #include "llvm/Support/raw_ostream.h"
  27 #include "llvm/Support/Path.h"
  28
  29 using namespace clang;
  30 using namespace ento;
  31
  32 //===----------------------------------------------------------------------===//
  33 // Boilerplate.
  34 //===----------------------------------------------------------------------===//
  35
  36 namespace {
  37
  38 class HTMLDiagnostics : public PathDiagnosticConsumer {
  39   llvm::sys::Path Directory, FilePrefix;
  40   bool createdDir, noDir;
  41   const Preprocessor &PP;
  42   std::vector<const PathDiagnostic*> BatchedDiags;
  43 public:
  44   HTMLDiagnostics(const std::string& prefix, const Preprocessor &pp);
  45
  46   virtual ~HTMLDiagnostics() { FlushDiagnostics(NULL); }
  47
  48   virtual void FlushDiagnostics(SmallVectorImpl<std::string> *FilesMade);
  49
  50   virtual void HandlePathDiagnosticImpl(const PathDiagnostic* D);
  51
  52   virtual StringRef getName() const {
  53     return "HTMLDiagnostics";
  54   }
  55
  56   unsigned ProcessMacroPiece(raw_ostream &os,
  57                              const PathDiagnosticMacroPiece& P,
  58                              unsigned num);
  59
  60   void HandlePiece(Rewriter& R, FileID BugFileID,
  61                    const PathDiagnosticPiece& P, unsigned num, unsigned max);
  62
  63   void HighlightRange(Rewriter& R, FileID BugFileID, SourceRange Range,
  64                       const char *HighlightStart = "<span class=\"mrange\">",
  65                       const char *HighlightEnd = "</span>");
  66
  67   void ReportDiag(const PathDiagnostic& D,
  68                   SmallVectorImpl<std::string> *FilesMade);
  69 };
  70
  71 } // end anonymous namespace
  72
  73 HTMLDiagnostics::HTMLDiagnostics(const std::string& prefix,
  74                                  const Preprocessor &pp)
  75   : Directory(prefix), FilePrefix(prefix), createdDir(false), noDir(false),
  76     PP(pp) {
  77   // All html files begin with "report"
  78   FilePrefix.appendComponent("report");
  79 }
  80
  81 PathDiagnosticConsumer*
  82 ento::createHTMLDiagnosticConsumer(const std::string& prefix,
  83                                  const Preprocessor &PP) {
  84   return new HTMLDiagnostics(prefix, PP);
  85 }
  86
  87 //===----------------------------------------------------------------------===//
  88 // Report processing.
  89 //===----------------------------------------------------------------------===//
  90
  91 void HTMLDiagnostics::HandlePathDiagnosticImpl(const PathDiagnostic* D) {
  92   if (!D)
  93     return;
  94
  95   if (D->empty()) {
  96     delete D;
  97     return;
  98   }
  99
 100   const_cast<PathDiagnostic*>(D)->flattenLocations();
 101   BatchedDiags.push_back(D);
 102 }
 103
 104 void
 105 HTMLDiagnostics::FlushDiagnostics(SmallVectorImpl<std::string> *FilesMade)
 106 {
 107   while (!BatchedDiags.empty()) {
 108     const PathDiagnostic* D = BatchedDiags.back();
 109     BatchedDiags.pop_back();
 110     ReportDiag(*D, FilesMade);
 111     delete D;
 112   }
 113
 114   BatchedDiags.clear();
 115 }
 116
 117 void HTMLDiagnostics::ReportDiag(const PathDiagnostic& D,
 118                                  SmallVectorImpl<std::string> *FilesMade){
 119   // Create the HTML directory if it is missing.
 120   if (!createdDir) {
 121     createdDir = true;
 122     std::string ErrorMsg;
 123     Directory.createDirectoryOnDisk(true, &ErrorMsg);
 124
 125     bool IsDirectory;
 126     if (llvm::sys::fs::is_directory(Directory.str(), IsDirectory) ||
 127         !IsDirectory) {
 128       llvm::errs() << "warning: could not create directory '"
 129                    << Directory.str() << "'\n"
 130                    << "reason: " << ErrorMsg << '\n';
 131
 132       noDir = true;
 133
 134       return;
 135     }
 136   }
 137
 138   if (noDir)
 139     return;
 140
 141   const SourceManager &SMgr = D.begin()->getLocation().getManager();
 142   FileID FID;
 143
 144   // Verify that the entire path is from the same FileID.
 145   for (PathDiagnostic::const_iterator I = D.begin(), E = D.end(); I != E; ++I) {
 146     FullSourceLoc L = I->getLocation().asLocation().getExpansionLoc();
 147
 148     if (FID.isInvalid()) {
 149       FID = SMgr.getFileID(L);
 150     } else if (SMgr.getFileID(L) != FID)
 151       return; // FIXME: Emit a warning?
 152
 153     // Check the source ranges.
 154     for (PathDiagnosticPiece::range_iterator RI=I->ranges_begin(),
 155                                              RE=I->ranges_end(); RI!=RE; ++RI) {
 156
 157       SourceLocation L = SMgr.getExpansionLoc(RI->getBegin());
 158
 159       if (!L.isFileID() || SMgr.getFileID(L) != FID)
 160         return; // FIXME: Emit a warning?
 161
 162       L = SMgr.getExpansionLoc(RI->getEnd());
 163
 164       if (!L.isFileID() || SMgr.getFileID(L) != FID)
 165         return; // FIXME: Emit a warning?
 166     }
 167   }
 168
 169   if (FID.isInvalid())
 170     return; // FIXME: Emit a warning?
 171
 172   // Create a new rewriter to generate HTML.
 173   Rewriter R(const_cast<SourceManager&>(SMgr), PP.getLangOptions());
 174
 175   // Process the path.
 176   unsigned n = D.size();
 177   unsigned max = n;
 178
 179   for (PathDiagnostic::const_reverse_iterator I=D.rbegin(), E=D.rend();
 180         I!=E; ++I, --n)
 181     HandlePiece(R, FID, *I, n, max);
 182
 183   // Add line numbers, header, footer, etc.
 184
 185   // unsigned FID = R.getSourceMgr().getMainFileID();
 186   html::EscapeText(R, FID);
 187   html::AddLineNumbers(R, FID);
 188
 189   // If we have a preprocessor, relex the file and syntax highlight.
 190   // We might not have a preprocessor if we come from a deserialized AST file,
 191   // for example.
 192
 193   html::SyntaxHighlight(R, FID, PP);
 194   html::HighlightMacros(R, FID, PP);
 195
 196   // Get the full directory name of the analyzed file.
 197
 198   const FileEntry* Entry = SMgr.getFileEntryForID(FID);
 199
 200   // This is a cludge; basically we want to append either the full
 201   // working directory if we have no directory information.  This is
 202   // a work in progress.
 203
 204   std::string DirName = "";
 205
 206   if (llvm::sys::path::is_relative(Entry->getName())) {
 207     llvm::sys::Path P = llvm::sys::Path::GetCurrentDirectory();
 208     DirName = P.str() + "/";
 209   }
 210
 211   // Add the name of the file as an <h1> tag.
 212
 213   {
 214     std::string s;
 215     llvm::raw_string_ostream os(s);
 216
 217     os << "<!-- REPORTHEADER -->\n"
 218       << "<h3>Bug Summary</h3>\n<table class=\"simpletable\">\n"
 219           "<tr><td class=\"rowname\">File:</td><td>"
 220       << html::EscapeText(DirName)
 221       << html::EscapeText(Entry->getName())
 222       << "</td></tr>\n<tr><td class=\"rowname\">Location:</td><td>"
 223          "<a href=\"#EndPath\">line "
 224       << (*D.rbegin()).getLocation().asLocation().getExpansionLineNumber()
 225       << ", column "
 226       << (*D.rbegin()).getLocation().asLocation().getExpansionColumnNumber()
 227       << "</a></td></tr>\n"
 228          "<tr><td class=\"rowname\">Description:</td><td>"
 229       << D.getDescription() << "</td></tr>\n";
 230
 231     // Output any other meta data.
 232
 233     for (PathDiagnostic::meta_iterator I=D.meta_begin(), E=D.meta_end();
 234          I!=E; ++I) {
 235       os << "<tr><td></td><td>" << html::EscapeText(*I) << "</td></tr>\n";
 236     }
 237
 238     os << "</table>\n<!-- REPORTSUMMARYEXTRA -->\n"
 239           "<h3>Annotated Source Code</h3>\n";
 240
 241     R.InsertTextBefore(SMgr.getLocForStartOfFile(FID), os.str());
 242   }
 243
 244   // Embed meta-data tags.
 245   {
 246     std::string s;
 247     llvm::raw_string_ostream os(s);
 248
 249     const std::string& BugDesc = D.getDescription();
 250     if (!BugDesc.empty())
 251       os << "\n<!-- BUGDESC " << BugDesc << " -->\n";
 252
 253     const std::string& BugType = D.getBugType();
 254     if (!BugType.empty())
 255       os << "\n<!-- BUGTYPE " << BugType << " -->\n";
 256
 257     const std::string& BugCategory = D.getCategory();
 258     if (!BugCategory.empty())
 259       os << "\n<!-- BUGCATEGORY " << BugCategory << " -->\n";
 260
 261     os << "\n<!-- BUGFILE " << DirName << Entry->getName() << " -->\n";
 262
 263     os << "\n<!-- BUGLINE "
 264        << D.back()->getLocation().asLocation().getExpansionLineNumber()
 265        << " -->\n";
 266
 267     os << "\n<!-- BUGPATHLENGTH " << D.size() << " -->\n";
 268
 269     // Mark the end of the tags.
 270     os << "\n<!-- BUGMETAEND -->\n";
 271
 272     // Insert the text.
 273     R.InsertTextBefore(SMgr.getLocForStartOfFile(FID), os.str());
 274   }
 275
 276   // Add CSS, header, and footer.
 277
 278   html::AddHeaderFooterInternalBuiltinCSS(R, FID, Entry->getName());
 279
 280   // Get the rewrite buffer.
 281   const RewriteBuffer *Buf = R.getRewriteBufferFor(FID);
 282
 283   if (!Buf) {
 284     llvm::errs() << "warning: no diagnostics generated for main file.\n";
 285     return;
 286   }
 287
 288   // Create a path for the target HTML file.
 289   llvm::sys::Path F(FilePrefix);
 290   F.makeUnique(false, NULL);
 291
 292   // Rename the file with an HTML extension.
 293   llvm::sys::Path H(F);
 294   H.appendSuffix("html");
 295   F.renamePathOnDisk(H, NULL);
 296
 297   std::string ErrorMsg;
 298   llvm::raw_fd_ostream os(H.c_str(), ErrorMsg);
 299
 300   if (!ErrorMsg.empty()) {
 301     llvm::errs() << "warning: could not create file '" << F.str()
 302                  << "'\n";
 303     return;
 304   }
 305
 306   if (FilesMade)
 307     FilesMade->push_back(llvm::sys::path::filename(H.str()));
 308
 309   // Emit the HTML to disk.
 310   for (RewriteBuffer::iterator I = Buf->begin(), E = Buf->end(); I!=E; ++I)
 311       os << *I;
 312 }
 313
 314 void HTMLDiagnostics::HandlePiece(Rewriter& R, FileID BugFileID,
 315                                   const PathDiagnosticPiece& P,
 316                                   unsigned num, unsigned max) {
 317
 318   // For now, just draw a box above the line in question, and emit the
 319   // warning.
 320   FullSourceLoc Pos = P.getLocation().asLocation();
 321
 322   if (!Pos.isValid())
 323     return;
 324
 325   SourceManager &SM = R.getSourceMgr();
 326   assert(&Pos.getManager() == &SM && "SourceManagers are different!");
 327   std::pair<FileID, unsigned> LPosInfo = SM.getDecomposedExpansionLoc(Pos);
 328
 329   if (LPosInfo.first != BugFileID)
 330     return;
 331
 332   const llvm::MemoryBuffer *Buf = SM.getBuffer(LPosInfo.first);
 333   const char* FileStart = Buf->getBufferStart();
 334
 335   // Compute the column number.  Rewind from the current position to the start
 336   // of the line.
 337   unsigned ColNo = SM.getColumnNumber(LPosInfo.first, LPosInfo.second);
 338   const char *TokInstantiationPtr =Pos.getExpansionLoc().getCharacterData();
 339   const char *LineStart = TokInstantiationPtr-ColNo;
 340
 341   // Compute LineEnd.
 342   const char *LineEnd = TokInstantiationPtr;
 343   const char* FileEnd = Buf->getBufferEnd();
 344   while (*LineEnd != '\n' && LineEnd != FileEnd)
 345     ++LineEnd;
 346
 347   // Compute the margin offset by counting tabs and non-tabs.
 348   unsigned PosNo = 0;
 349   for (const char* c = LineStart; c != TokInstantiationPtr; ++c)
 350     PosNo += *c == '\t' ? 8 : 1;
 351
 352   // Create the html for the message.
 353
 354   const char *Kind = 0;
 355   switch (P.getKind()) {
 356   case PathDiagnosticPiece::Event:  Kind = "Event"; break;
 357   case PathDiagnosticPiece::ControlFlow: Kind = "Control"; break;
 358     // Setting Kind to "Control" is intentional.
 359   case PathDiagnosticPiece::Macro: Kind = "Control"; break;
 360   }
 361
 362   std::string sbuf;
 363   llvm::raw_string_ostream os(sbuf);
 364
 365   os << "\n<tr><td class=\"num\"></td><td class=\"line\"><div id=\"";
 366
 367   if (num == max)
 368     os << "EndPath";
 369   else
 370     os << "Path" << num;
 371
 372   os << "\" class=\"msg";
 373   if (Kind)
 374     os << " msg" << Kind;
 375   os << "\" style=\"margin-left:" << PosNo << "ex";
 376
 377   // Output a maximum size.
 378   if (!isa<PathDiagnosticMacroPiece>(P)) {
 379     // Get the string and determining its maximum substring.
 380     const std::string& Msg = P.getString();
 381     unsigned max_token = 0;
 382     unsigned cnt = 0;
 383     unsigned len = Msg.size();
 384
 385     for (std::string::const_iterator I=Msg.begin(), E=Msg.end(); I!=E; ++I)
 386       switch (*I) {
 387       default:
 388         ++cnt;
 389         continue;
 390       case ' ':
 391       case '\t':
 392       case '\n':
 393         if (cnt > max_token) max_token = cnt;
 394         cnt = 0;
 395       }
 396
 397     if (cnt > max_token)
 398       max_token = cnt;
 399
 400     // Determine the approximate size of the message bubble in em.
 401     unsigned em;
 402     const unsigned max_line = 120;
 403
 404     if (max_token >= max_line)
 405       em = max_token / 2;
 406     else {
 407       unsigned characters = max_line;
 408       unsigned lines = len / max_line;
 409
 410       if (lines > 0) {
 411         for (; characters > max_token; --characters)
 412           if (len / characters > lines) {
 413             ++characters;
 414             break;
 415           }
 416       }
 417
 418       em = characters / 2;
 419     }
 420
 421     if (em < max_line/2)
 422       os << "; max-width:" << em << "em";
 423   }
 424   else
 425     os << "; max-width:100em";
 426
 427   os << "\">";
 428
 429   if (max > 1) {
 430     os << "<table class=\"msgT\"><tr><td valign=\"top\">";
 431     os << "<div class=\"PathIndex";
 432     if (Kind) os << " PathIndex" << Kind;
 433     os << "\">" << num << "</div>";
 434     os << "</td><td>";
 435   }
 436
 437   if (const PathDiagnosticMacroPiece *MP =
 438         dyn_cast<PathDiagnosticMacroPiece>(&P)) {
 439
 440     os << "Within the expansion of the macro '";
 441
 442     // Get the name of the macro by relexing it.
 443     {
 444       FullSourceLoc L = MP->getLocation().asLocation().getExpansionLoc();
 445       assert(L.isFileID());
 446       StringRef BufferInfo = L.getBufferData();
 447       const char* MacroName = L.getDecomposedLoc().second + BufferInfo.data();
 448       Lexer rawLexer(L, PP.getLangOptions(), BufferInfo.begin(),
 449                      MacroName, BufferInfo.end());
 450
 451       Token TheTok;
 452       rawLexer.LexFromRawLexer(TheTok);
 453       for (unsigned i = 0, n = TheTok.getLength(); i < n; ++i)
 454         os << MacroName[i];
 455     }
 456
 457     os << "':\n";
 458
 459     if (max > 1)
 460       os << "</td></tr></table>";
 461
 462     // Within a macro piece.  Write out each event.
 463     ProcessMacroPiece(os, *MP, 0);
 464   }
 465   else {
 466     os << html::EscapeText(P.getString());
 467
 468     if (max > 1)
 469       os << "</td></tr></table>";
 470   }
 471
 472   os << "</div></td></tr>";
 473
 474   // Insert the new html.
 475   unsigned DisplayPos = LineEnd - FileStart;
 476   SourceLocation Loc =
 477     SM.getLocForStartOfFile(LPosInfo.first).getLocWithOffset(DisplayPos);
 478
 479   R.InsertTextBefore(Loc, os.str());
 480
 481   // Now highlight the ranges.
 482   for (const SourceRange *I = P.ranges_begin(), *E = P.ranges_end();
 483         I != E; ++I)
 484     HighlightRange(R, LPosInfo.first, *I);
 485
 486 #if 0
 487   // If there is a code insertion hint, insert that code.
 488   // FIXME: This code is disabled because it seems to mangle the HTML
 489   // output. I'm leaving it here because it's generally the right idea,
 490   // but needs some help from someone more familiar with the rewriter.
 491   for (const FixItHint *Hint = P.fixit_begin(), *HintEnd = P.fixit_end();
 492        Hint != HintEnd; ++Hint) {
 493     if (Hint->RemoveRange.isValid()) {
 494       HighlightRange(R, LPosInfo.first, Hint->RemoveRange,
 495                      "<span class=\"CodeRemovalHint\">", "</span>");
 496     }
 497     if (Hint->InsertionLoc.isValid()) {
 498       std::string EscapedCode = html::EscapeText(Hint->CodeToInsert, true);
 499       EscapedCode = "<span class=\"CodeInsertionHint\">" + EscapedCode
 500         + "</span>";
 501       R.InsertTextBefore(Hint->InsertionLoc, EscapedCode);
 502     }
 503   }
 504 #endif
 505 }
 506
 507 static void EmitAlphaCounter(raw_ostream &os, unsigned n) {
 508   unsigned x = n % ('z' - 'a');
 509   n /= 'z' - 'a';
 510
 511   if (n > 0)
 512     EmitAlphaCounter(os, n);
 513
 514   os << char('a' + x);
 515 }
 516
 517 unsigned HTMLDiagnostics::ProcessMacroPiece(raw_ostream &os,
 518                                             const PathDiagnosticMacroPiece& P,
 519                                             unsigned num) {
 520
 521   for (PathDiagnosticMacroPiece::const_iterator I=P.begin(), E=P.end();
 522         I!=E; ++I) {
 523
 524     if (const PathDiagnosticMacroPiece *MP =
 525           dyn_cast<PathDiagnosticMacroPiece>(*I)) {
 526       num = ProcessMacroPiece(os, *MP, num);
 527       continue;
 528     }
 529
 530     if (PathDiagnosticEventPiece *EP = dyn_cast<PathDiagnosticEventPiece>(*I)) {
 531       os << "<div class=\"msg msgEvent\" style=\"width:94%; "
 532             "margin-left:5px\">"
 533             "<table class=\"msgT\"><tr>"
 534             "<td valign=\"top\"><div class=\"PathIndex PathIndexEvent\">";
 535       EmitAlphaCounter(os, num++);
 536       os << "</div></td><td valign=\"top\">"
 537          << html::EscapeText(EP->getString())
 538          << "</td></tr></table></div>\n";
 539     }
 540   }
 541
 542   return num;
 543 }
 544
 545 void HTMLDiagnostics::HighlightRange(Rewriter& R, FileID BugFileID,
 546                                      SourceRange Range,
 547                                      const char *HighlightStart,
 548                                      const char *HighlightEnd) {
 549   SourceManager &SM = R.getSourceMgr();
 550   const LangOptions &LangOpts = R.getLangOpts();
 551
 552   SourceLocation InstantiationStart = SM.getExpansionLoc(Range.getBegin());
 553   unsigned StartLineNo = SM.getExpansionLineNumber(InstantiationStart);
 554
 555   SourceLocation InstantiationEnd = SM.getExpansionLoc(Range.getEnd());
 556   unsigned EndLineNo = SM.getExpansionLineNumber(InstantiationEnd);
 557
 558   if (EndLineNo < StartLineNo)
 559     return;
 560
 561   if (SM.getFileID(InstantiationStart) != BugFileID ||
 562       SM.getFileID(InstantiationEnd) != BugFileID)
 563     return;
 564
 565   // Compute the column number of the end.
 566   unsigned EndColNo = SM.getExpansionColumnNumber(InstantiationEnd);
 567   unsigned OldEndColNo = EndColNo;
 568
 569   if (EndColNo) {
 570     // Add in the length of the token, so that we cover multi-char tokens.
 571     EndColNo += Lexer::MeasureTokenLength(Range.getEnd(), SM, LangOpts)-1;
 572   }
 573
 574   // Highlight the range.  Make the span tag the outermost tag for the
 575   // selected range.
 576
 577   SourceLocation E =
 578     InstantiationEnd.getLocWithOffset(EndColNo - OldEndColNo);
 579
 580   html::HighlightRange(R, InstantiationStart, E, HighlightStart, HighlightEnd);
 581 }