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