TextDiagnosticPrinter.cpp revision e44433c29e59a57ef1fac9cd252a2a98a0afb2e7
1//===--- TextDiagnosticPrinter.cpp - Diagnostic Printer -------------------===// 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 diagnostic client prints out their diagnostic messages. 11// 12//===----------------------------------------------------------------------===// 13 14#include "clang/Frontend/TextDiagnosticPrinter.h" 15#include "clang/Basic/SourceManager.h" 16#include "clang/Frontend/DiagnosticOptions.h" 17#include "clang/Lex/Lexer.h" 18#include "llvm/Support/MemoryBuffer.h" 19#include "llvm/Support/raw_ostream.h" 20#include "llvm/ADT/SmallString.h" 21#include <algorithm> 22using namespace clang; 23 24static const enum llvm::raw_ostream::Colors noteColor = 25 llvm::raw_ostream::BLACK; 26static const enum llvm::raw_ostream::Colors fixitColor = 27 llvm::raw_ostream::GREEN; 28static const enum llvm::raw_ostream::Colors caretColor = 29 llvm::raw_ostream::GREEN; 30static const enum llvm::raw_ostream::Colors warningColor = 31 llvm::raw_ostream::MAGENTA; 32static const enum llvm::raw_ostream::Colors errorColor = llvm::raw_ostream::RED; 33static const enum llvm::raw_ostream::Colors fatalColor = llvm::raw_ostream::RED; 34// used for changing only the bold attribute 35static const enum llvm::raw_ostream::Colors savedColor = 36 llvm::raw_ostream::SAVEDCOLOR; 37 38/// \brief Number of spaces to indent when word-wrapping. 39const unsigned WordWrapIndentation = 6; 40 41TextDiagnosticPrinter::TextDiagnosticPrinter(llvm::raw_ostream &os, 42 const DiagnosticOptions &diags, 43 bool _OwnsOutputStream) 44 : OS(os), LangOpts(0), DiagOpts(&diags), 45 LastCaretDiagnosticWasNote(0), 46 OwnsOutputStream(_OwnsOutputStream) { 47} 48 49TextDiagnosticPrinter::~TextDiagnosticPrinter() { 50 if (OwnsOutputStream) 51 delete &OS; 52} 53 54void TextDiagnosticPrinter:: 55PrintIncludeStack(SourceLocation Loc, const SourceManager &SM) { 56 if (Loc.isInvalid()) return; 57 58 PresumedLoc PLoc = SM.getPresumedLoc(Loc); 59 60 // Print out the other include frames first. 61 PrintIncludeStack(PLoc.getIncludeLoc(), SM); 62 63 if (DiagOpts->ShowLocation) 64 OS << "In file included from " << PLoc.getFilename() 65 << ':' << PLoc.getLine() << ":\n"; 66 else 67 OS << "In included file:\n"; 68} 69 70/// HighlightRange - Given a SourceRange and a line number, highlight (with ~'s) 71/// any characters in LineNo that intersect the SourceRange. 72void TextDiagnosticPrinter::HighlightRange(const SourceRange &R, 73 const SourceManager &SM, 74 unsigned LineNo, FileID FID, 75 std::string &CaretLine, 76 const std::string &SourceLine) { 77 assert(CaretLine.size() == SourceLine.size() && 78 "Expect a correspondence between source and caret line!"); 79 if (!R.isValid()) return; 80 81 SourceLocation Begin = SM.getInstantiationLoc(R.getBegin()); 82 SourceLocation End = SM.getInstantiationLoc(R.getEnd()); 83 84 // If the End location and the start location are the same and are a macro 85 // location, then the range was something that came from a macro expansion 86 // or _Pragma. If this is an object-like macro, the best we can do is to 87 // highlight the range. If this is a function-like macro, we'd also like to 88 // highlight the arguments. 89 if (Begin == End && R.getEnd().isMacroID()) 90 End = SM.getInstantiationRange(R.getEnd()).second; 91 92 unsigned StartLineNo = SM.getInstantiationLineNumber(Begin); 93 if (StartLineNo > LineNo || SM.getFileID(Begin) != FID) 94 return; // No intersection. 95 96 unsigned EndLineNo = SM.getInstantiationLineNumber(End); 97 if (EndLineNo < LineNo || SM.getFileID(End) != FID) 98 return; // No intersection. 99 100 // Compute the column number of the start. 101 unsigned StartColNo = 0; 102 if (StartLineNo == LineNo) { 103 StartColNo = SM.getInstantiationColumnNumber(Begin); 104 if (StartColNo) --StartColNo; // Zero base the col #. 105 } 106 107 // Pick the first non-whitespace column. 108 while (StartColNo < SourceLine.size() && 109 (SourceLine[StartColNo] == ' ' || SourceLine[StartColNo] == '\t')) 110 ++StartColNo; 111 112 // Compute the column number of the end. 113 unsigned EndColNo = CaretLine.size(); 114 if (EndLineNo == LineNo) { 115 EndColNo = SM.getInstantiationColumnNumber(End); 116 if (EndColNo) { 117 --EndColNo; // Zero base the col #. 118 119 // Add in the length of the token, so that we cover multi-char tokens. 120 EndColNo += Lexer::MeasureTokenLength(End, SM, *LangOpts); 121 } else { 122 EndColNo = CaretLine.size(); 123 } 124 } 125 126 // Pick the last non-whitespace column. 127 if (EndColNo <= SourceLine.size()) 128 while (EndColNo-1 && 129 (SourceLine[EndColNo-1] == ' ' || SourceLine[EndColNo-1] == '\t')) 130 --EndColNo; 131 else 132 EndColNo = SourceLine.size(); 133 134 // Fill the range with ~'s. 135 assert(StartColNo <= EndColNo && "Invalid range!"); 136 for (unsigned i = StartColNo; i < EndColNo; ++i) 137 CaretLine[i] = '~'; 138} 139 140/// \brief When the source code line we want to print is too long for 141/// the terminal, select the "interesting" region. 142static void SelectInterestingSourceRegion(std::string &SourceLine, 143 std::string &CaretLine, 144 std::string &FixItInsertionLine, 145 unsigned EndOfCaretToken, 146 unsigned Columns) { 147 if (CaretLine.size() > SourceLine.size()) 148 SourceLine.resize(CaretLine.size(), ' '); 149 150 // Find the slice that we need to display the full caret line 151 // correctly. 152 unsigned CaretStart = 0, CaretEnd = CaretLine.size(); 153 for (; CaretStart != CaretEnd; ++CaretStart) 154 if (!isspace(CaretLine[CaretStart])) 155 break; 156 157 for (; CaretEnd != CaretStart; --CaretEnd) 158 if (!isspace(CaretLine[CaretEnd - 1])) 159 break; 160 161 // Make sure we don't chop the string shorter than the caret token 162 // itself. 163 if (CaretEnd < EndOfCaretToken) 164 CaretEnd = EndOfCaretToken; 165 166 // If we have a fix-it line, make sure the slice includes all of the 167 // fix-it information. 168 if (!FixItInsertionLine.empty()) { 169 unsigned FixItStart = 0, FixItEnd = FixItInsertionLine.size(); 170 for (; FixItStart != FixItEnd; ++FixItStart) 171 if (!isspace(FixItInsertionLine[FixItStart])) 172 break; 173 174 for (; FixItEnd != FixItStart; --FixItEnd) 175 if (!isspace(FixItInsertionLine[FixItEnd - 1])) 176 break; 177 178 if (FixItStart < CaretStart) 179 CaretStart = FixItStart; 180 if (FixItEnd > CaretEnd) 181 CaretEnd = FixItEnd; 182 } 183 184 // CaretLine[CaretStart, CaretEnd) contains all of the interesting 185 // parts of the caret line. While this slice is smaller than the 186 // number of columns we have, try to grow the slice to encompass 187 // more context. 188 189 // If the end of the interesting region comes before we run out of 190 // space in the terminal, start at the beginning of the line. 191 if (Columns > 3 && CaretEnd < Columns - 3) 192 CaretStart = 0; 193 194 unsigned TargetColumns = Columns; 195 if (TargetColumns > 8) 196 TargetColumns -= 8; // Give us extra room for the ellipses. 197 unsigned SourceLength = SourceLine.size(); 198 while ((CaretEnd - CaretStart) < TargetColumns) { 199 bool ExpandedRegion = false; 200 // Move the start of the interesting region left until we've 201 // pulled in something else interesting. 202 if (CaretStart == 1) 203 CaretStart = 0; 204 else if (CaretStart > 1) { 205 unsigned NewStart = CaretStart - 1; 206 207 // Skip over any whitespace we see here; we're looking for 208 // another bit of interesting text. 209 while (NewStart && isspace(SourceLine[NewStart])) 210 --NewStart; 211 212 // Skip over this bit of "interesting" text. 213 while (NewStart && !isspace(SourceLine[NewStart])) 214 --NewStart; 215 216 // Move up to the non-whitespace character we just saw. 217 if (NewStart) 218 ++NewStart; 219 220 // If we're still within our limit, update the starting 221 // position within the source/caret line. 222 if (CaretEnd - NewStart <= TargetColumns) { 223 CaretStart = NewStart; 224 ExpandedRegion = true; 225 } 226 } 227 228 // Move the end of the interesting region right until we've 229 // pulled in something else interesting. 230 if (CaretEnd != SourceLength) { 231 assert(CaretEnd < SourceLength && "Unexpected caret position!"); 232 unsigned NewEnd = CaretEnd; 233 234 // Skip over any whitespace we see here; we're looking for 235 // another bit of interesting text. 236 while (NewEnd != SourceLength && isspace(SourceLine[NewEnd - 1])) 237 ++NewEnd; 238 239 // Skip over this bit of "interesting" text. 240 while (NewEnd != SourceLength && !isspace(SourceLine[NewEnd - 1])) 241 ++NewEnd; 242 243 if (NewEnd - CaretStart <= TargetColumns) { 244 CaretEnd = NewEnd; 245 ExpandedRegion = true; 246 } 247 } 248 249 if (!ExpandedRegion) 250 break; 251 } 252 253 // [CaretStart, CaretEnd) is the slice we want. Update the various 254 // output lines to show only this slice, with two-space padding 255 // before the lines so that it looks nicer. 256 if (CaretEnd < SourceLine.size()) 257 SourceLine.replace(CaretEnd, std::string::npos, "..."); 258 if (CaretEnd < CaretLine.size()) 259 CaretLine.erase(CaretEnd, std::string::npos); 260 if (FixItInsertionLine.size() > CaretEnd) 261 FixItInsertionLine.erase(CaretEnd, std::string::npos); 262 263 if (CaretStart > 2) { 264 SourceLine.replace(0, CaretStart, " ..."); 265 CaretLine.replace(0, CaretStart, " "); 266 if (FixItInsertionLine.size() >= CaretStart) 267 FixItInsertionLine.replace(0, CaretStart, " "); 268 } 269} 270 271void TextDiagnosticPrinter::EmitCaretDiagnostic(SourceLocation Loc, 272 SourceRange *Ranges, 273 unsigned NumRanges, 274 SourceManager &SM, 275 const CodeModificationHint *Hints, 276 unsigned NumHints, 277 unsigned Columns) { 278 assert(LangOpts && "Unexpected diagnostic outside source file processing"); 279 assert(!Loc.isInvalid() && "must have a valid source location here"); 280 281 // If this is a macro ID, first emit information about where this was 282 // instantiated (recursively) then emit information about where the token was 283 // spelled from. 284 if (!Loc.isFileID()) { 285 SourceLocation OneLevelUp = SM.getImmediateInstantiationRange(Loc).first; 286 // FIXME: Map ranges? 287 EmitCaretDiagnostic(OneLevelUp, Ranges, NumRanges, SM, 0, 0, Columns); 288 289 // Map the location. 290 Loc = SM.getImmediateSpellingLoc(Loc); 291 292 // Map the ranges. 293 for (unsigned i = 0; i != NumRanges; ++i) { 294 SourceLocation S = Ranges[i].getBegin(), E = Ranges[i].getEnd(); 295 if (S.isMacroID()) S = SM.getImmediateSpellingLoc(S); 296 if (E.isMacroID()) E = SM.getImmediateSpellingLoc(E); 297 Ranges[i] = SourceRange(S, E); 298 } 299 300 // Get the pretty name, according to #line directives etc. 301 PresumedLoc PLoc = SM.getPresumedLoc(Loc); 302 303 // If this diagnostic is not in the main file, print out the "included from" 304 // lines. 305 if (LastWarningLoc != PLoc.getIncludeLoc()) { 306 LastWarningLoc = PLoc.getIncludeLoc(); 307 PrintIncludeStack(LastWarningLoc, SM); 308 } 309 310 if (DiagOpts->ShowLocation) { 311 // Emit the file/line/column that this expansion came from. 312 OS << PLoc.getFilename() << ':' << PLoc.getLine() << ':'; 313 if (DiagOpts->ShowColumn) 314 OS << PLoc.getColumn() << ':'; 315 OS << ' '; 316 } 317 OS << "note: instantiated from:\n"; 318 319 EmitCaretDiagnostic(Loc, Ranges, NumRanges, SM, Hints, NumHints, Columns); 320 return; 321 } 322 323 // Decompose the location into a FID/Offset pair. 324 std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(Loc); 325 FileID FID = LocInfo.first; 326 unsigned FileOffset = LocInfo.second; 327 328 // Get information about the buffer it points into. 329 std::pair<const char*, const char*> BufferInfo = SM.getBufferData(FID); 330 const char *BufStart = BufferInfo.first; 331 332 unsigned ColNo = SM.getColumnNumber(FID, FileOffset); 333 unsigned CaretEndColNo 334 = ColNo + Lexer::MeasureTokenLength(Loc, SM, *LangOpts); 335 336 // Rewind from the current position to the start of the line. 337 const char *TokPtr = BufStart+FileOffset; 338 const char *LineStart = TokPtr-ColNo+1; // Column # is 1-based. 339 340 341 // Compute the line end. Scan forward from the error position to the end of 342 // the line. 343 const char *LineEnd = TokPtr; 344 while (*LineEnd != '\n' && *LineEnd != '\r' && *LineEnd != '\0') 345 ++LineEnd; 346 347 // FIXME: This shouldn't be necessary, but the CaretEndColNo can extend past 348 // the source line length as currently being computed. See 349 // test/Misc/message-length.c. 350 CaretEndColNo = std::min(CaretEndColNo, unsigned(LineEnd - LineStart)); 351 352 // Copy the line of code into an std::string for ease of manipulation. 353 std::string SourceLine(LineStart, LineEnd); 354 355 // Create a line for the caret that is filled with spaces that is the same 356 // length as the line of source code. 357 std::string CaretLine(LineEnd-LineStart, ' '); 358 359 // Highlight all of the characters covered by Ranges with ~ characters. 360 if (NumRanges) { 361 unsigned LineNo = SM.getLineNumber(FID, FileOffset); 362 363 for (unsigned i = 0, e = NumRanges; i != e; ++i) 364 HighlightRange(Ranges[i], SM, LineNo, FID, CaretLine, SourceLine); 365 } 366 367 // Next, insert the caret itself. 368 if (ColNo-1 < CaretLine.size()) 369 CaretLine[ColNo-1] = '^'; 370 else 371 CaretLine.push_back('^'); 372 373 // Scan the source line, looking for tabs. If we find any, manually expand 374 // them to spaces and update the CaretLine to match. 375 for (unsigned i = 0; i != SourceLine.size(); ++i) { 376 if (SourceLine[i] != '\t') continue; 377 378 // Replace this tab with at least one space. 379 SourceLine[i] = ' '; 380 381 // Compute the number of spaces we need to insert. 382 unsigned TabStop = DiagOpts->TabStop; 383 assert(0 < TabStop && TabStop <= DiagnosticOptions::MaxTabStop && 384 "Invalid -ftabstop value"); 385 unsigned NumSpaces = ((i+TabStop)/TabStop * TabStop) - (i+1); 386 assert(NumSpaces < TabStop && "Invalid computation of space amt"); 387 388 // Insert spaces into the SourceLine. 389 SourceLine.insert(i+1, NumSpaces, ' '); 390 391 // Insert spaces or ~'s into CaretLine. 392 CaretLine.insert(i+1, NumSpaces, CaretLine[i] == '~' ? '~' : ' '); 393 } 394 395 // If we are in -fdiagnostics-print-source-range-info mode, we are trying to 396 // produce easily machine parsable output. Add a space before the source line 397 // and the caret to make it trivial to tell the main diagnostic line from what 398 // the user is intended to see. 399 if (DiagOpts->ShowSourceRanges) { 400 SourceLine = ' ' + SourceLine; 401 CaretLine = ' ' + CaretLine; 402 } 403 404 std::string FixItInsertionLine; 405 if (NumHints && DiagOpts->ShowFixits) { 406 for (const CodeModificationHint *Hint = Hints, *LastHint = Hints + NumHints; 407 Hint != LastHint; ++Hint) { 408 if (Hint->InsertionLoc.isValid()) { 409 // We have an insertion hint. Determine whether the inserted 410 // code is on the same line as the caret. 411 std::pair<FileID, unsigned> HintLocInfo 412 = SM.getDecomposedInstantiationLoc(Hint->InsertionLoc); 413 if (SM.getLineNumber(HintLocInfo.first, HintLocInfo.second) == 414 SM.getLineNumber(FID, FileOffset)) { 415 // Insert the new code into the line just below the code 416 // that the user wrote. 417 unsigned HintColNo 418 = SM.getColumnNumber(HintLocInfo.first, HintLocInfo.second); 419 unsigned LastColumnModified 420 = HintColNo - 1 + Hint->CodeToInsert.size(); 421 if (LastColumnModified > FixItInsertionLine.size()) 422 FixItInsertionLine.resize(LastColumnModified, ' '); 423 std::copy(Hint->CodeToInsert.begin(), Hint->CodeToInsert.end(), 424 FixItInsertionLine.begin() + HintColNo - 1); 425 } else { 426 FixItInsertionLine.clear(); 427 break; 428 } 429 } 430 } 431 // Now that we have the entire fixit line, expand the tabs in it. 432 // Since we don't want to insert spaces in the middle of a word, 433 // find each word and the column it should line up with and insert 434 // spaces until they match. 435 if (!FixItInsertionLine.empty()) { 436 unsigned FixItPos = 0; 437 unsigned LinePos = 0; 438 unsigned TabExpandedCol = 0; 439 unsigned LineLength = LineEnd - LineStart; 440 441 while (FixItPos < FixItInsertionLine.size() && LinePos < LineLength) { 442 // Find the next word in the FixIt line. 443 while (FixItPos < FixItInsertionLine.size() && 444 FixItInsertionLine[FixItPos] == ' ') 445 ++FixItPos; 446 unsigned CharDistance = FixItPos - TabExpandedCol; 447 448 // Walk forward in the source line, keeping track of 449 // the tab-expanded column. 450 for (unsigned I = 0; I < CharDistance; ++I, ++LinePos) 451 if (LinePos >= LineLength || LineStart[LinePos] != '\t') 452 ++TabExpandedCol; 453 else 454 TabExpandedCol = 455 (TabExpandedCol/DiagOpts->TabStop + 1) * DiagOpts->TabStop; 456 457 // Adjust the fixit line to match this column. 458 FixItInsertionLine.insert(FixItPos, TabExpandedCol-FixItPos, ' '); 459 FixItPos = TabExpandedCol; 460 461 // Walk to the end of the word. 462 while (FixItPos < FixItInsertionLine.size() && 463 FixItInsertionLine[FixItPos] != ' ') 464 ++FixItPos; 465 } 466 } 467 } 468 469 // If the source line is too long for our terminal, select only the 470 // "interesting" source region within that line. 471 if (Columns && SourceLine.size() > Columns) 472 SelectInterestingSourceRegion(SourceLine, CaretLine, FixItInsertionLine, 473 CaretEndColNo, Columns); 474 475 // Finally, remove any blank spaces from the end of CaretLine. 476 while (CaretLine[CaretLine.size()-1] == ' ') 477 CaretLine.erase(CaretLine.end()-1); 478 479 // Emit what we have computed. 480 OS << SourceLine << '\n'; 481 482 if (DiagOpts->ShowColors) 483 OS.changeColor(caretColor, true); 484 OS << CaretLine << '\n'; 485 if (DiagOpts->ShowColors) 486 OS.resetColor(); 487 488 if (!FixItInsertionLine.empty()) { 489 if (DiagOpts->ShowColors) 490 // Print fixit line in color 491 OS.changeColor(fixitColor, false); 492 if (DiagOpts->ShowSourceRanges) 493 OS << ' '; 494 OS << FixItInsertionLine << '\n'; 495 if (DiagOpts->ShowColors) 496 OS.resetColor(); 497 } 498} 499 500/// \brief Skip over whitespace in the string, starting at the given 501/// index. 502/// 503/// \returns The index of the first non-whitespace character that is 504/// greater than or equal to Idx or, if no such character exists, 505/// returns the end of the string. 506static unsigned skipWhitespace(unsigned Idx, 507 const llvm::SmallVectorImpl<char> &Str, 508 unsigned Length) { 509 while (Idx < Length && isspace(Str[Idx])) 510 ++Idx; 511 return Idx; 512} 513 514/// \brief If the given character is the start of some kind of 515/// balanced punctuation (e.g., quotes or parentheses), return the 516/// character that will terminate the punctuation. 517/// 518/// \returns The ending punctuation character, if any, or the NULL 519/// character if the input character does not start any punctuation. 520static inline char findMatchingPunctuation(char c) { 521 switch (c) { 522 case '\'': return '\''; 523 case '`': return '\''; 524 case '"': return '"'; 525 case '(': return ')'; 526 case '[': return ']'; 527 case '{': return '}'; 528 default: break; 529 } 530 531 return 0; 532} 533 534/// \brief Find the end of the word starting at the given offset 535/// within a string. 536/// 537/// \returns the index pointing one character past the end of the 538/// word. 539static unsigned findEndOfWord(unsigned Start, 540 const llvm::SmallVectorImpl<char> &Str, 541 unsigned Length, unsigned Column, 542 unsigned Columns) { 543 assert(Start < Str.size() && "Invalid start position!"); 544 unsigned End = Start + 1; 545 546 // If we are already at the end of the string, take that as the word. 547 if (End == Str.size()) 548 return End; 549 550 // Determine if the start of the string is actually opening 551 // punctuation, e.g., a quote or parentheses. 552 char EndPunct = findMatchingPunctuation(Str[Start]); 553 if (!EndPunct) { 554 // This is a normal word. Just find the first space character. 555 while (End < Length && !isspace(Str[End])) 556 ++End; 557 return End; 558 } 559 560 // We have the start of a balanced punctuation sequence (quotes, 561 // parentheses, etc.). Determine the full sequence is. 562 llvm::SmallVector<char, 16> PunctuationEndStack; 563 PunctuationEndStack.push_back(EndPunct); 564 while (End < Length && !PunctuationEndStack.empty()) { 565 if (Str[End] == PunctuationEndStack.back()) 566 PunctuationEndStack.pop_back(); 567 else if (char SubEndPunct = findMatchingPunctuation(Str[End])) 568 PunctuationEndStack.push_back(SubEndPunct); 569 570 ++End; 571 } 572 573 // Find the first space character after the punctuation ended. 574 while (End < Length && !isspace(Str[End])) 575 ++End; 576 577 unsigned PunctWordLength = End - Start; 578 if (// If the word fits on this line 579 Column + PunctWordLength <= Columns || 580 // ... or the word is "short enough" to take up the next line 581 // without too much ugly white space 582 PunctWordLength < Columns/3) 583 return End; // Take the whole thing as a single "word". 584 585 // The whole quoted/parenthesized string is too long to print as a 586 // single "word". Instead, find the "word" that starts just after 587 // the punctuation and use that end-point instead. This will recurse 588 // until it finds something small enough to consider a word. 589 return findEndOfWord(Start + 1, Str, Length, Column + 1, Columns); 590} 591 592/// \brief Print the given string to a stream, word-wrapping it to 593/// some number of columns in the process. 594/// 595/// \brief OS the stream to which the word-wrapping string will be 596/// emitted. 597/// 598/// \brief Str the string to word-wrap and output. 599/// 600/// \brief Columns the number of columns to word-wrap to. 601/// 602/// \brief Column the column number at which the first character of \p 603/// Str will be printed. This will be non-zero when part of the first 604/// line has already been printed. 605/// 606/// \brief Indentation the number of spaces to indent any lines beyond 607/// the first line. 608/// 609/// \returns true if word-wrapping was required, or false if the 610/// string fit on the first line. 611static bool PrintWordWrapped(llvm::raw_ostream &OS, 612 const llvm::SmallVectorImpl<char> &Str, 613 unsigned Columns, 614 unsigned Column = 0, 615 unsigned Indentation = WordWrapIndentation) { 616 unsigned Length = Str.size(); 617 618 // If there is a newline in this message somewhere, find that 619 // newline and split the message into the part before the newline 620 // (which will be word-wrapped) and the part from the newline one 621 // (which will be emitted unchanged). 622 for (unsigned I = 0; I != Length; ++I) 623 if (Str[I] == '\n') { 624 Length = I; 625 break; 626 } 627 628 // The string used to indent each line. 629 llvm::SmallString<16> IndentStr; 630 IndentStr.assign(Indentation, ' '); 631 bool Wrapped = false; 632 for (unsigned WordStart = 0, WordEnd; WordStart < Length; 633 WordStart = WordEnd) { 634 // Find the beginning of the next word. 635 WordStart = skipWhitespace(WordStart, Str, Length); 636 if (WordStart == Length) 637 break; 638 639 // Find the end of this word. 640 WordEnd = findEndOfWord(WordStart, Str, Length, Column, Columns); 641 642 // Does this word fit on the current line? 643 unsigned WordLength = WordEnd - WordStart; 644 if (Column + WordLength < Columns) { 645 // This word fits on the current line; print it there. 646 if (WordStart) { 647 OS << ' '; 648 Column += 1; 649 } 650 OS.write(&Str[WordStart], WordLength); 651 Column += WordLength; 652 continue; 653 } 654 655 // This word does not fit on the current line, so wrap to the next 656 // line. 657 OS << '\n'; 658 OS.write(&IndentStr[0], Indentation); 659 OS.write(&Str[WordStart], WordLength); 660 Column = Indentation + WordLength; 661 Wrapped = true; 662 } 663 664 if (Length == Str.size()) 665 return Wrapped; // We're done. 666 667 // There is a newline in the message, followed by something that 668 // will not be word-wrapped. Print that. 669 OS.write(&Str[Length], Str.size() - Length); 670 return true; 671} 672 673void TextDiagnosticPrinter::HandleDiagnostic(Diagnostic::Level Level, 674 const DiagnosticInfo &Info) { 675 // Keeps track of the the starting position of the location 676 // information (e.g., "foo.c:10:4:") that precedes the error 677 // message. We use this information to determine how long the 678 // file+line+column number prefix is. 679 uint64_t StartOfLocationInfo = OS.tell(); 680 681 // If the location is specified, print out a file/line/col and include trace 682 // if enabled. 683 if (Info.getLocation().isValid()) { 684 const SourceManager &SM = Info.getLocation().getManager(); 685 PresumedLoc PLoc = SM.getPresumedLoc(Info.getLocation()); 686 unsigned LineNo = PLoc.getLine(); 687 688 // First, if this diagnostic is not in the main file, print out the 689 // "included from" lines. 690 if (LastWarningLoc != PLoc.getIncludeLoc()) { 691 LastWarningLoc = PLoc.getIncludeLoc(); 692 PrintIncludeStack(LastWarningLoc, SM); 693 StartOfLocationInfo = OS.tell(); 694 } 695 696 // Compute the column number. 697 if (DiagOpts->ShowLocation) { 698 if (DiagOpts->ShowColors) 699 OS.changeColor(savedColor, true); 700 701 // Emit a Visual Studio compatible line number syntax. 702 if (LangOpts && LangOpts->Microsoft) { 703 OS << PLoc.getFilename() << '(' << LineNo << ')'; 704 OS << " : "; 705 } else { 706 OS << PLoc.getFilename() << ':' << LineNo << ':'; 707 if (DiagOpts->ShowColumn) 708 if (unsigned ColNo = PLoc.getColumn()) 709 OS << ColNo << ':'; 710 } 711 if (DiagOpts->ShowSourceRanges && Info.getNumRanges()) { 712 FileID CaretFileID = 713 SM.getFileID(SM.getInstantiationLoc(Info.getLocation())); 714 bool PrintedRange = false; 715 716 for (unsigned i = 0, e = Info.getNumRanges(); i != e; ++i) { 717 // Ignore invalid ranges. 718 if (!Info.getRange(i).isValid()) continue; 719 720 SourceLocation B = Info.getRange(i).getBegin(); 721 SourceLocation E = Info.getRange(i).getEnd(); 722 B = SM.getInstantiationLoc(B); 723 E = SM.getInstantiationLoc(E); 724 725 // If the End location and the start location are the same and are a 726 // macro location, then the range was something that came from a macro 727 // expansion or _Pragma. If this is an object-like macro, the best we 728 // can do is to highlight the range. If this is a function-like 729 // macro, we'd also like to highlight the arguments. 730 if (B == E && Info.getRange(i).getEnd().isMacroID()) 731 E = SM.getInstantiationRange(Info.getRange(i).getEnd()).second; 732 733 std::pair<FileID, unsigned> BInfo = SM.getDecomposedLoc(B); 734 std::pair<FileID, unsigned> EInfo = SM.getDecomposedLoc(E); 735 736 // If the start or end of the range is in another file, just discard 737 // it. 738 if (BInfo.first != CaretFileID || EInfo.first != CaretFileID) 739 continue; 740 741 // Add in the length of the token, so that we cover multi-char tokens. 742 unsigned TokSize = Lexer::MeasureTokenLength(E, SM, *LangOpts); 743 744 OS << '{' << SM.getLineNumber(BInfo.first, BInfo.second) << ':' 745 << SM.getColumnNumber(BInfo.first, BInfo.second) << '-' 746 << SM.getLineNumber(EInfo.first, EInfo.second) << ':' 747 << (SM.getColumnNumber(EInfo.first, EInfo.second)+TokSize) << '}'; 748 PrintedRange = true; 749 } 750 751 if (PrintedRange) 752 OS << ':'; 753 } 754 OS << ' '; 755 if (DiagOpts->ShowColors) 756 OS.resetColor(); 757 } 758 } 759 760 if (DiagOpts->ShowColors) { 761 // Print diagnostic category in bold and color 762 switch (Level) { 763 case Diagnostic::Ignored: assert(0 && "Invalid diagnostic type"); 764 case Diagnostic::Note: OS.changeColor(noteColor, true); break; 765 case Diagnostic::Warning: OS.changeColor(warningColor, true); break; 766 case Diagnostic::Error: OS.changeColor(errorColor, true); break; 767 case Diagnostic::Fatal: OS.changeColor(fatalColor, true); break; 768 } 769 } 770 771 switch (Level) { 772 case Diagnostic::Ignored: assert(0 && "Invalid diagnostic type"); 773 case Diagnostic::Note: OS << "note: "; break; 774 case Diagnostic::Warning: OS << "warning: "; break; 775 case Diagnostic::Error: OS << "error: "; break; 776 case Diagnostic::Fatal: OS << "fatal error: "; break; 777 } 778 779 if (DiagOpts->ShowColors) 780 OS.resetColor(); 781 782 llvm::SmallString<100> OutStr; 783 Info.FormatDiagnostic(OutStr); 784 785 if (DiagOpts->ShowOptionNames) 786 if (const char *Opt = Diagnostic::getWarningOptionForDiag(Info.getID())) { 787 OutStr += " [-W"; 788 OutStr += Opt; 789 OutStr += ']'; 790 } 791 792 if (DiagOpts->ShowColors) { 793 // Print warnings, errors and fatal errors in bold, no color 794 switch (Level) { 795 case Diagnostic::Warning: OS.changeColor(savedColor, true); break; 796 case Diagnostic::Error: OS.changeColor(savedColor, true); break; 797 case Diagnostic::Fatal: OS.changeColor(savedColor, true); break; 798 default: break; //don't bold notes 799 } 800 } 801 802 if (DiagOpts->MessageLength) { 803 // We will be word-wrapping the error message, so compute the 804 // column number where we currently are (after printing the 805 // location information). 806 unsigned Column = OS.tell() - StartOfLocationInfo; 807 PrintWordWrapped(OS, OutStr, DiagOpts->MessageLength, Column); 808 } else { 809 OS.write(OutStr.begin(), OutStr.size()); 810 } 811 OS << '\n'; 812 if (DiagOpts->ShowColors) 813 OS.resetColor(); 814 815 // If caret diagnostics are enabled and we have location, we want to 816 // emit the caret. However, we only do this if the location moved 817 // from the last diagnostic, if the last diagnostic was a note that 818 // was part of a different warning or error diagnostic, or if the 819 // diagnostic has ranges. We don't want to emit the same caret 820 // multiple times if one loc has multiple diagnostics. 821 if (DiagOpts->ShowCarets && Info.getLocation().isValid() && 822 ((LastLoc != Info.getLocation()) || Info.getNumRanges() || 823 (LastCaretDiagnosticWasNote && Level != Diagnostic::Note) || 824 Info.getNumCodeModificationHints())) { 825 // Cache the LastLoc, it allows us to omit duplicate source/caret spewage. 826 LastLoc = Info.getLocation(); 827 LastCaretDiagnosticWasNote = (Level == Diagnostic::Note); 828 829 // Get the ranges into a local array we can hack on. 830 SourceRange Ranges[20]; 831 unsigned NumRanges = Info.getNumRanges(); 832 assert(NumRanges < 20 && "Out of space"); 833 for (unsigned i = 0; i != NumRanges; ++i) 834 Ranges[i] = Info.getRange(i); 835 836 unsigned NumHints = Info.getNumCodeModificationHints(); 837 for (unsigned idx = 0; idx < NumHints; ++idx) { 838 const CodeModificationHint &Hint = Info.getCodeModificationHint(idx); 839 if (Hint.RemoveRange.isValid()) { 840 assert(NumRanges < 20 && "Out of space"); 841 Ranges[NumRanges++] = Hint.RemoveRange; 842 } 843 } 844 845 EmitCaretDiagnostic(LastLoc, Ranges, NumRanges, LastLoc.getManager(), 846 Info.getCodeModificationHints(), 847 Info.getNumCodeModificationHints(), 848 DiagOpts->MessageLength); 849 } 850 851 OS.flush(); 852} 853