/// \brief Produce a diagnostic highlighting some portion of a literal.
///
/// Emits the diagnostic \p DiagID, highlighting the range of characters from
/// \p TokRangeBegin (inclusive) to \p TokRangeEnd (exclusive), which must be
/// a substring of a spelling buffer for the token beginning at \p TokBegin.
static DiagnosticBuilder Diag(DiagnosticsEngine *Diags,
const LangOptions &Features, FullSourceLoc TokLoc,
const char *TokBegin, const char *TokRangeBegin,
const char *TokRangeEnd, unsigned DiagID) {
SourceLocation Begin =
Lexer::AdvanceToTokenCharacter(TokLoc, TokRangeBegin - TokBegin,
TokLoc.getManager(), Features);
return Diags->Report(Begin, DiagID) <<
MakeCharSourceRange(Features, TokLoc, TokBegin, TokRangeBegin, TokRangeEnd);
}
static bool compareCrossTUSourceLocs(FullSourceLoc XL, FullSourceLoc YL) {
std::pair<FileID, unsigned> XOffs = XL.getDecomposedLoc();
std::pair<FileID, unsigned> YOffs = YL.getDecomposedLoc();
const SourceManager &SM = XL.getManager();
std::pair<bool, bool> InSameTU = SM.isInTheSameTranslationUnit(XOffs, YOffs);
if (InSameTU.first)
return XL.isBeforeInTranslationUnitThan(YL);
const FileEntry *XFE = SM.getFileEntryForID(XL.getSpellingLoc().getFileID());
const FileEntry *YFE = SM.getFileEntryForID(YL.getSpellingLoc().getFileID());
if (!XFE || !YFE)
return XFE && !YFE;
int NameCmp = XFE->getName().compare(YFE->getName());
if (NameCmp != 0)
return NameCmp == -1;
// Last resort: Compare raw file IDs that are possibly expansions.
return XL.getFileID() < YL.getFileID();
}
/*--------------------------------------------------------------------------*/
void getAbsoluteLocation(const FullSourceLoc& lb, const FullSourceLoc& le,
int64* pBegin, int64* pEnd, const LangOptions& lopt)
{
const SourceManager& sm = lb.getManager();
// I need to know the starting point of the file
FileID f = lb.getFileID();
SourceLocation fl = sm.getLocForStartOfFile(f);
FullSourceLoc e(clang::Lexer::getLocForEndOfToken(le, 0, sm, lopt), sm);
const char* fstart = sm.getCharacterData(fl);
const char* lbegin = sm.getCharacterData(lb);
const char* lend = sm.getCharacterData(e);
*pBegin = (int64)(lbegin-fstart);
*pEnd = (int64)(lend-fstart);
}
static Optional<bool> comparePiece(const PathDiagnosticPiece &X,
const PathDiagnosticPiece &Y) {
if (X.getKind() != Y.getKind())
return X.getKind() < Y.getKind();
FullSourceLoc XL = X.getLocation().asLocation();
FullSourceLoc YL = Y.getLocation().asLocation();
if (XL != YL)
return XL.isBeforeInTranslationUnitThan(YL);
if (X.getString() != Y.getString())
return X.getString() < Y.getString();
if (X.getRanges().size() != Y.getRanges().size())
return X.getRanges().size() < Y.getRanges().size();
const SourceManager &SM = XL.getManager();
for (unsigned i = 0, n = X.getRanges().size(); i < n; ++i) {
SourceRange XR = X.getRanges()[i];
SourceRange YR = Y.getRanges()[i];
if (XR != YR) {
if (XR.getBegin() != YR.getBegin())
return SM.isBeforeInTranslationUnit(XR.getBegin(), YR.getBegin());
return SM.isBeforeInTranslationUnit(XR.getEnd(), YR.getEnd());
}
}
switch (X.getKind()) {
case PathDiagnosticPiece::ControlFlow:
return compareControlFlow(cast<PathDiagnosticControlFlowPiece>(X),
cast<PathDiagnosticControlFlowPiece>(Y));
case PathDiagnosticPiece::Event:
case PathDiagnosticPiece::Note:
return None;
case PathDiagnosticPiece::Macro:
return compareMacro(cast<PathDiagnosticMacroPiece>(X),
cast<PathDiagnosticMacroPiece>(Y));
case PathDiagnosticPiece::Call:
return compareCall(cast<PathDiagnosticCallPiece>(X),
cast<PathDiagnosticCallPiece>(Y));
}
llvm_unreachable("all cases handled");
}
static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y) {
FullSourceLoc XL = X.getLocation().asLocation();
FullSourceLoc YL = Y.getLocation().asLocation();
if (XL != YL)
return compareCrossTUSourceLocs(XL, YL);
if (X.getBugType() != Y.getBugType())
return X.getBugType() < Y.getBugType();
if (X.getCategory() != Y.getCategory())
return X.getCategory() < Y.getCategory();
if (X.getVerboseDescription() != Y.getVerboseDescription())
return X.getVerboseDescription() < Y.getVerboseDescription();
if (X.getShortDescription() != Y.getShortDescription())
return X.getShortDescription() < Y.getShortDescription();
if (X.getDeclWithIssue() != Y.getDeclWithIssue()) {
const Decl *XD = X.getDeclWithIssue();
if (!XD)
return true;
const Decl *YD = Y.getDeclWithIssue();
if (!YD)
return false;
SourceLocation XDL = XD->getLocation();
SourceLocation YDL = YD->getLocation();
if (XDL != YDL) {
const SourceManager &SM = XL.getManager();
return compareCrossTUSourceLocs(FullSourceLoc(XDL, SM),
FullSourceLoc(YDL, SM));
}
}
PathDiagnostic::meta_iterator XI = X.meta_begin(), XE = X.meta_end();
PathDiagnostic::meta_iterator YI = Y.meta_begin(), YE = Y.meta_end();
if (XE - XI != YE - YI)
return (XE - XI) < (YE - YI);
for ( ; XI != XE ; ++XI, ++YI) {
if (*XI != *YI)
return (*XI) < (*YI);
}
Optional<bool> b = comparePath(X.path, Y.path);
assert(b.hasValue());
return b.getValue();
}
PathDiagnosticLocation PathDiagnosticLocation::createSingleLocation(
const PathDiagnosticLocation &PDL) {
FullSourceLoc L = PDL.asLocation();
return PathDiagnosticLocation(L, L.getManager(), SingleLocK);
}
void HTMLDiagnostics::HandlePiece(Rewriter& R, FileID BugFileID,
const PathDiagnosticPiece& P,
unsigned num, unsigned max) {
// For now, just draw a box above the line in question, and emit the
// warning.
FullSourceLoc Pos = P.getLocation().asLocation();
if (!Pos.isValid())
return;
SourceManager &SM = R.getSourceMgr();
assert(&Pos.getManager() == &SM && "SourceManagers are different!");
std::pair<FileID, unsigned> LPosInfo = SM.getDecomposedExpansionLoc(Pos);
if (LPosInfo.first != BugFileID)
return;
const llvm::MemoryBuffer *Buf = SM.getBuffer(LPosInfo.first);
const char* FileStart = Buf->getBufferStart();
// Compute the column number. Rewind from the current position to the start
// of the line.
unsigned ColNo = SM.getColumnNumber(LPosInfo.first, LPosInfo.second);
const char *TokInstantiationPtr =Pos.getExpansionLoc().getCharacterData();
const char *LineStart = TokInstantiationPtr-ColNo;
// Compute LineEnd.
const char *LineEnd = TokInstantiationPtr;
const char* FileEnd = Buf->getBufferEnd();
while (*LineEnd != '\n' && LineEnd != FileEnd)
++LineEnd;
// Compute the margin offset by counting tabs and non-tabs.
unsigned PosNo = 0;
for (const char* c = LineStart; c != TokInstantiationPtr; ++c)
PosNo += *c == '\t' ? 8 : 1;
// Create the html for the message.
const char *Kind = 0;
switch (P.getKind()) {
case PathDiagnosticPiece::Call:
llvm_unreachable("Calls should already be handled");
case PathDiagnosticPiece::Event: Kind = "Event"; break;
case PathDiagnosticPiece::ControlFlow: Kind = "Control"; break;
// Setting Kind to "Control" is intentional.
case PathDiagnosticPiece::Macro: Kind = "Control"; break;
}
std::string sbuf;
llvm::raw_string_ostream os(sbuf);
os << "\n<tr><td class=\"num\"></td><td class=\"line\"><div id=\"";
if (num == max)
os << "EndPath";
else
os << "Path" << num;
os << "\" class=\"msg";
if (Kind)
os << " msg" << Kind;
os << "\" style=\"margin-left:" << PosNo << "ex";
// Output a maximum size.
if (!isa<PathDiagnosticMacroPiece>(P)) {
// Get the string and determining its maximum substring.
const std::string& Msg = P.getString();
unsigned max_token = 0;
unsigned cnt = 0;
unsigned len = Msg.size();
for (std::string::const_iterator I=Msg.begin(), E=Msg.end(); I!=E; ++I)
switch (*I) {
default:
++cnt;
continue;
case ' ':
case '\t':
case '\n':
if (cnt > max_token) max_token = cnt;
cnt = 0;
}
if (cnt > max_token)
max_token = cnt;
// Determine the approximate size of the message bubble in em.
unsigned em;
const unsigned max_line = 120;
if (max_token >= max_line)
em = max_token / 2;
else {
unsigned characters = max_line;
unsigned lines = len / max_line;
if (lines > 0) {
for (; characters > max_token; --characters)
if (len / characters > lines) {
++characters;
break;
}
}
em = characters / 2;
}
if (em < max_line/2)
os << "; max-width:" << em << "em";
}
else
os << "; max-width:100em";
os << "\">";
if (max > 1) {
os << "<table class=\"msgT\"><tr><td valign=\"top\">";
os << "<div class=\"PathIndex";
if (Kind) os << " PathIndex" << Kind;
os << "\">" << num << "</div>";
if (num > 1) {
os << "</td><td><div class=\"PathNav\"><a href=\"#Path"
<< (num - 1)
<< "\" title=\"Previous event ("
<< (num - 1)
<< ")\">←</a></div></td>";
}
os << "</td><td>";
}
if (const PathDiagnosticMacroPiece *MP =
dyn_cast<PathDiagnosticMacroPiece>(&P)) {
os << "Within the expansion of the macro '";
// Get the name of the macro by relexing it.
{
FullSourceLoc L = MP->getLocation().asLocation().getExpansionLoc();
assert(L.isFileID());
StringRef BufferInfo = L.getBufferData();
std::pair<FileID, unsigned> LocInfo = L.getDecomposedLoc();
const char* MacroName = LocInfo.second + BufferInfo.data();
Lexer rawLexer(SM.getLocForStartOfFile(LocInfo.first), PP.getLangOpts(),
BufferInfo.begin(), MacroName, BufferInfo.end());
Token TheTok;
rawLexer.LexFromRawLexer(TheTok);
for (unsigned i = 0, n = TheTok.getLength(); i < n; ++i)
os << MacroName[i];
}
os << "':\n";
if (max > 1) {
os << "</td>";
if (num < max) {
os << "<td><div class=\"PathNav\"><a href=\"#";
if (num == max - 1)
os << "EndPath";
else
os << "Path" << (num + 1);
os << "\" title=\"Next event ("
<< (num + 1)
<< ")\">→</a></div></td>";
}
os << "</tr></table>";
}
// Within a macro piece. Write out each event.
ProcessMacroPiece(os, *MP, 0);
}
else {
os << html::EscapeText(P.getString());
if (max > 1) {
os << "</td>";
if (num < max) {
os << "<td><div class=\"PathNav\"><a href=\"#";
if (num == max - 1)
os << "EndPath";
else
os << "Path" << (num + 1);
os << "\" title=\"Next event ("
<< (num + 1)
<< ")\">→</a></div></td>";
}
os << "</tr></table>";
}
}
os << "</div></td></tr>";
// Insert the new html.
unsigned DisplayPos = LineEnd - FileStart;
SourceLocation Loc =
SM.getLocForStartOfFile(LPosInfo.first).getLocWithOffset(DisplayPos);
R.InsertTextBefore(Loc, os.str());
// Now highlight the ranges.
ArrayRef<SourceRange> Ranges = P.getRanges();
for (ArrayRef<SourceRange>::iterator I = Ranges.begin(),
E = Ranges.end(); I != E; ++I) {
HighlightRange(R, LPosInfo.first, *I);
}
}
/// Print out the file/line/column information and include trace.
///
/// This method handlen the emission of the diagnostic location information.
/// This includes extracting as much location information as is present for
/// the diagnostic and printing it, as well as any include stack or source
/// ranges necessary.
void TextDiagnostic::emitDiagnosticLoc(FullSourceLoc Loc, PresumedLoc PLoc,
DiagnosticsEngine::Level Level,
ArrayRef<CharSourceRange> Ranges) {
if (PLoc.isInvalid()) {
// At least print the file name if available:
FileID FID = Loc.getFileID();
if (FID.isValid()) {
const FileEntry *FE = Loc.getFileEntry();
if (FE && FE->isValid()) {
emitFilename(FE->getName(), Loc.getManager());
if (FE->isInPCH())
OS << " (in PCH)";
OS << ": ";
}
}
return;
}
unsigned LineNo = PLoc.getLine();
if (!DiagOpts->ShowLocation)
return;
if (DiagOpts->ShowColors)
OS.changeColor(savedColor, true);
emitFilename(PLoc.getFilename(), Loc.getManager());
switch (DiagOpts->getFormat()) {
case DiagnosticOptions::Clang: OS << ':' << LineNo; break;
case DiagnosticOptions::MSVC: OS << '(' << LineNo; break;
case DiagnosticOptions::Vi: OS << " +" << LineNo; break;
}
if (DiagOpts->ShowColumn)
// Compute the column number.
if (unsigned ColNo = PLoc.getColumn()) {
if (DiagOpts->getFormat() == DiagnosticOptions::MSVC) {
OS << ',';
// Visual Studio 2010 or earlier expects column number to be off by one
if (LangOpts.MSCompatibilityVersion &&
!LangOpts.isCompatibleWithMSVC(LangOptions::MSVC2012))
ColNo--;
} else
OS << ':';
OS << ColNo;
}
switch (DiagOpts->getFormat()) {
case DiagnosticOptions::Clang:
case DiagnosticOptions::Vi: OS << ':'; break;
case DiagnosticOptions::MSVC:
// MSVC2013 and before print 'file(4) : error'. MSVC2015 gets rid of the
// space and prints 'file(4): error'.
OS << ')';
if (LangOpts.MSCompatibilityVersion &&
!LangOpts.isCompatibleWithMSVC(LangOptions::MSVC2015))
OS << ' ';
OS << ": ";
break;
}
if (DiagOpts->ShowSourceRanges && !Ranges.empty()) {
FileID CaretFileID = Loc.getExpansionLoc().getFileID();
bool PrintedRange = false;
for (ArrayRef<CharSourceRange>::const_iterator RI = Ranges.begin(),
RE = Ranges.end();
RI != RE; ++RI) {
// Ignore invalid ranges.
if (!RI->isValid()) continue;
auto &SM = Loc.getManager();
SourceLocation B = SM.getExpansionLoc(RI->getBegin());
CharSourceRange ERange = SM.getExpansionRange(RI->getEnd());
SourceLocation E = ERange.getEnd();
bool IsTokenRange = ERange.isTokenRange();
std::pair<FileID, unsigned> BInfo = SM.getDecomposedLoc(B);
std::pair<FileID, unsigned> EInfo = SM.getDecomposedLoc(E);
// If the start or end of the range is in another file, just discard
// it.
if (BInfo.first != CaretFileID || EInfo.first != CaretFileID)
continue;
// Add in the length of the token, so that we cover multi-char
// tokens.
unsigned TokSize = 0;
if (IsTokenRange)
TokSize = Lexer::MeasureTokenLength(E, SM, LangOpts);
FullSourceLoc BF(B, SM), EF(E, SM);
OS << '{'
<< BF.getLineNumber() << ':' << BF.getColumnNumber() << '-'
<< EF.getLineNumber() << ':' << (EF.getColumnNumber() + TokSize)
<< '}';
PrintedRange = true;
}
if (PrintedRange)
OS << ':';
}
OS << ' ';
}
/// Emit a code snippet and caret line.
///
/// This routine emits a single line's code snippet and caret line..
///
/// \param Loc The location for the caret.
/// \param Ranges The underlined ranges for this code snippet.
/// \param Hints The FixIt hints active for this diagnostic.
void TextDiagnostic::emitSnippetAndCaret(
FullSourceLoc Loc, DiagnosticsEngine::Level Level,
SmallVectorImpl<CharSourceRange> &Ranges, ArrayRef<FixItHint> Hints) {
assert(Loc.isValid() && "must have a valid source location here");
assert(Loc.isFileID() && "must have a file location here");
// If caret diagnostics are enabled and we have location, we want to
// emit the caret. However, we only do this if the location moved
// from the last diagnostic, if the last diagnostic was a note that
// was part of a different warning or error diagnostic, or if the
// diagnostic has ranges. We don't want to emit the same caret
// multiple times if one loc has multiple diagnostics.
if (!DiagOpts->ShowCarets)
return;
if (Loc == LastLoc && Ranges.empty() && Hints.empty() &&
(LastLevel != DiagnosticsEngine::Note || Level == LastLevel))
return;
// Decompose the location into a FID/Offset pair.
std::pair<FileID, unsigned> LocInfo = Loc.getDecomposedLoc();
FileID FID = LocInfo.first;
const SourceManager &SM = Loc.getManager();
// Get information about the buffer it points into.
bool Invalid = false;
StringRef BufData = Loc.getBufferData(&Invalid);
if (Invalid)
return;
unsigned CaretLineNo = Loc.getLineNumber();
unsigned CaretColNo = Loc.getColumnNumber();
// Arbitrarily stop showing snippets when the line is too long.
static const size_t MaxLineLengthToPrint = 4096;
if (CaretColNo > MaxLineLengthToPrint)
return;
// Find the set of lines to include.
const unsigned MaxLines = DiagOpts->SnippetLineLimit;
std::pair<unsigned, unsigned> Lines = {CaretLineNo, CaretLineNo};
for (SmallVectorImpl<CharSourceRange>::iterator I = Ranges.begin(),
E = Ranges.end();
I != E; ++I)
if (auto OptionalRange = findLinesForRange(*I, FID, SM))
Lines = maybeAddRange(Lines, *OptionalRange, MaxLines);
for (unsigned LineNo = Lines.first; LineNo != Lines.second + 1; ++LineNo) {
const char *BufStart = BufData.data();
const char *BufEnd = BufStart + BufData.size();
// Rewind from the current position to the start of the line.
const char *LineStart =
BufStart +
SM.getDecomposedLoc(SM.translateLineCol(FID, LineNo, 1)).second;
if (LineStart == BufEnd)
break;
// Compute the line end.
const char *LineEnd = LineStart;
while (*LineEnd != '\n' && *LineEnd != '\r' && LineEnd != BufEnd)
++LineEnd;
// Arbitrarily stop showing snippets when the line is too long.
// FIXME: Don't print any lines in this case.
if (size_t(LineEnd - LineStart) > MaxLineLengthToPrint)
return;
// Trim trailing null-bytes.
StringRef Line(LineStart, LineEnd - LineStart);
while (!Line.empty() && Line.back() == '\0' &&
(LineNo != CaretLineNo || Line.size() > CaretColNo))
Line = Line.drop_back();
// Copy the line of code into an std::string for ease of manipulation.
std::string SourceLine(Line.begin(), Line.end());
// Build the byte to column map.
const SourceColumnMap sourceColMap(SourceLine, DiagOpts->TabStop);
// Create a line for the caret that is filled with spaces that is the same
// number of columns as the line of source code.
std::string CaretLine(sourceColMap.columns(), ' ');
// Highlight all of the characters covered by Ranges with ~ characters.
for (SmallVectorImpl<CharSourceRange>::iterator I = Ranges.begin(),
E = Ranges.end();
I != E; ++I)
highlightRange(*I, LineNo, FID, sourceColMap, CaretLine, SM, LangOpts);
// Next, insert the caret itself.
if (CaretLineNo == LineNo) {
CaretColNo = sourceColMap.byteToContainingColumn(CaretColNo - 1);
if (CaretLine.size() < CaretColNo + 1)
CaretLine.resize(CaretColNo + 1, ' ');
CaretLine[CaretColNo] = '^';
}
std::string FixItInsertionLine = buildFixItInsertionLine(
FID, LineNo, sourceColMap, Hints, SM, DiagOpts.get());
// If the source line is too long for our terminal, select only the
// "interesting" source region within that line.
unsigned Columns = DiagOpts->MessageLength;
if (Columns)
selectInterestingSourceRegion(SourceLine, CaretLine, FixItInsertionLine,
Columns, sourceColMap);
// If we are in -fdiagnostics-print-source-range-info mode, we are trying
// to produce easily machine parsable output. Add a space before the
// source line and the caret to make it trivial to tell the main diagnostic
// line from what the user is intended to see.
if (DiagOpts->ShowSourceRanges) {
SourceLine = ' ' + SourceLine;
CaretLine = ' ' + CaretLine;
}
// Finally, remove any blank spaces from the end of CaretLine.
while (!CaretLine.empty() && CaretLine[CaretLine.size() - 1] == ' ')
CaretLine.erase(CaretLine.end() - 1);
// Emit what we have computed.
emitSnippet(SourceLine);
if (!CaretLine.empty()) {
if (DiagOpts->ShowColors)
OS.changeColor(caretColor, true);
OS << CaretLine << '\n';
if (DiagOpts->ShowColors)
OS.resetColor();
}
if (!FixItInsertionLine.empty()) {
if (DiagOpts->ShowColors)
// Print fixit line in color
OS.changeColor(fixitColor, false);
if (DiagOpts->ShowSourceRanges)
OS << ' ';
OS << FixItInsertionLine << '\n';
if (DiagOpts->ShowColors)
OS.resetColor();
}
}
// Print out any parseable fixit information requested by the options.
emitParseableFixits(Hints, SM);
}
void TextDiagnosticPrinter::HandleDiagnostic(Diagnostic &Diags,
Diagnostic::Level Level,
FullSourceLoc Pos,
diag::kind ID,
const std::string *Strs,
unsigned NumStrs,
const SourceRange *Ranges,
unsigned NumRanges) {
unsigned LineNo = 0, ColNo = 0;
const char *LineStart = 0, *LineEnd = 0;
if (Pos.isValid()) {
FullSourceLoc LPos = Pos.getLogicalLoc();
LineNo = LPos.getLineNumber();
// First, if this diagnostic is not in the main file, print out the
// "included from" lines.
if (LastWarningLoc != LPos.getIncludeLoc()) {
LastWarningLoc = LPos.getIncludeLoc();
PrintIncludeStack(LastWarningLoc);
}
// Compute the column number. Rewind from the current position to the start
// of the line.
ColNo = LPos.getColumnNumber();
const char *TokLogicalPtr = LPos.getCharacterData();
LineStart = TokLogicalPtr-ColNo+1; // Column # is 1-based
// Compute the line end. Scan forward from the error position to the end of
// the line.
const llvm::MemoryBuffer *Buffer = LPos.getBuffer();
const char *BufEnd = Buffer->getBufferEnd();
LineEnd = TokLogicalPtr;
while (LineEnd != BufEnd &&
*LineEnd != '\n' && *LineEnd != '\r')
++LineEnd;
std::cerr << Buffer->getBufferIdentifier()
<< ":" << LineNo << ":";
if (ColNo && !NoShowColumn)
std::cerr << ColNo << ":";
std::cerr << " ";
}
switch (Level) {
default: assert(0 && "Unknown diagnostic type!");
case Diagnostic::Note: std::cerr << "note: "; break;
case Diagnostic::Warning: std::cerr << "warning: "; break;
case Diagnostic::Error: std::cerr << "error: "; break;
case Diagnostic::Fatal: std::cerr << "fatal error: "; break;
break;
}
std::cerr << FormatDiagnostic(Diags, Level, ID, Strs, NumStrs) << "\n";
if (!NoCaretDiagnostics && Pos.isValid()) {
// Get the line of the source file.
std::string SourceLine(LineStart, LineEnd);
// Create a line for the carat that is filled with spaces that is the same
// length as the line of source code.
std::string CaratLine(LineEnd-LineStart, ' ');
// Highlight all of the characters covered by Ranges with ~ characters.
for (unsigned i = 0; i != NumRanges; ++i)
HighlightRange(Ranges[i], Pos.getManager(),LineNo, CaratLine, SourceLine);
// Next, insert the carat itself.
if (ColNo-1 < CaratLine.size())
CaratLine[ColNo-1] = '^';
else
CaratLine.push_back('^');
// Scan the source line, looking for tabs. If we find any, manually expand
// them to 8 characters and update the CaratLine to match.
for (unsigned i = 0; i != SourceLine.size(); ++i) {
if (SourceLine[i] != '\t') continue;
// Replace this tab with at least one space.
SourceLine[i] = ' ';
// Compute the number of spaces we need to insert.
unsigned NumSpaces = ((i+8)&~7) - (i+1);
assert(NumSpaces < 8 && "Invalid computation of space amt");
// Insert spaces into the SourceLine.
SourceLine.insert(i+1, NumSpaces, ' ');
// Insert spaces or ~'s into CaratLine.
CaratLine.insert(i+1, NumSpaces, CaratLine[i] == '~' ? '~' : ' ');
}
// Finally, remove any blank spaces from the end of CaratLine.
while (CaratLine[CaratLine.size()-1] == ' ')
CaratLine.erase(CaratLine.end()-1);
// Emit what we have computed.
std::cerr << SourceLine << "\n";
std::cerr << CaratLine << "\n";
}
}
// http://clang.llvm.org/doxygen/classclang_1_1Stmt.html
// For each declaration
// http://clang.llvm.org/doxygen/classclang_1_1Decl.html
// http://clang.llvm.org/doxygen/classclang_1_1CXXRecordDecl.html
// and
// http://clang.llvm.org/doxygen/classclang_1_1RecursiveASTVisitor.html
bool VisitCXXRecordDecl(CXXRecordDecl *record) {
if(Context==NULL)
return true ;
if(record==NULL)
return true ;
auto& smanager = Context->getSourceManager() ;
FullSourceLoc FullLocation = Context->getFullLoc(record->getLocStart());
// Check this declaration is not in the system headers...
if ( FullLocation.isValid() && !exclude(FullLocation.getManager() , record) )
{
// Check the class name.
// it should be in writtent in UpperCamlCase
string classname=record->getNameAsString();
if(!isUpperCamlCase(classname)){
SourceRange declsr=record->getMostRecentDecl()->getSourceRange() ;
SourceLocation sl=declsr.getBegin();
auto fileinfo = smanager.getFileEntryForID(smanager.getFileID(sl)) ;
if(fileinfo && !isInExcludedPath(fileinfo->getName(), excludedPathPatterns)){
printErrorM4(fileinfo->getName(),
smanager.getPresumedLineNumber(sl),
smanager.getPresumedColumnNumber(sl),
classname) ;
}
}
// Check the function definitions
//
if(qualityLevel>=Q2){
for(auto f=record->method_begin();f!=record->method_end();++f){
SourceRange declsr=(*f)->getSourceRange() ;
SourceLocation sl=declsr.getBegin();
auto fileinfo = smanager.getFileEntryForID(smanager.getFileID(sl)) ;
if(fileinfo!=NULL && !isInExcludedPath(fileinfo->getName(), excludedPathPatterns))
{
// Rules C1: check that a function definition is not in a body.
if((*f)->hasBody())
{
Stmt* body=(*f)->getBody();
SourceRange bodysr=body->getSourceRange() ;
SourceLocation bodysl=bodysr.getBegin();
SourceLocation bodyend=bodysr.getEnd();
auto fileinfobody = smanager.getFileEntryForID(smanager.getFileID(bodysl)) ;
if(fileinfobody
&& isInHeader(fileinfobody->getName())
&& smanager.getPresumedLineNumber(bodyend)- smanager.getPresumedLineNumber(bodysl) > 1 ){
printErrorC1(fileinfo->getName(), smanager.getPresumedLineNumber(sl), smanager.getPresumedColumnNumber(sl),
record->getNameAsString(), f->getNameAsString());
}
}
// Rules C2: check that a method name is following a LowerCamlCase mode
if(!isLowerCamlCase(f->getNameAsString())
&& !f->isCopyAssignmentOperator()
&& !f->isMoveAssignmentOperator()
&& !CXXConstructorDecl::classof(*f)
&& !CXXDestructorDecl::classof(*f)
&& !f->isOverloadedOperator())
{
printErrorC2(fileinfo->getName(), smanager.getPresumedLineNumber(sl), smanager.getPresumedColumnNumber(sl),
record->getNameAsString(), f->getNameAsString());
}
// Rules M3: check that all ExecParam are the first param and that they have no default arg.
for(auto p=(*f)->param_begin();p!=(*f)->param_end();++p)
{
string fullname=(*p)->getOriginalType().getCanonicalType().getAsString() ;
if(isAnExecParam(fullname)){
if( (*p)->hasUnparsedDefaultArg() ||
(*p)->hasDefaultArg() ){
printErrorW4(fileinfo->getName(), smanager.getPresumedLineNumber(sl), smanager.getPresumedColumnNumber(sl),
fullname, (*p)->getName());
}
if( p != (*f)->param_begin() ){
printErrorW5(fileinfo->getName(), smanager.getPresumedLineNumber(sl), smanager.getPresumedColumnNumber(sl),
fullname, (*p)->getName());
}
}
}
}
}
}
// Now check the attributes...
RecordDecl::field_iterator it=record->field_begin() ;
for(;it!=record->field_end();it++){
clang::FieldDecl* ff=*it;
SourceRange declsr=ff->getMostRecentDecl()->getSourceRange() ;
SourceLocation sl=declsr.getBegin();
std::string name=ff->getName() ;
auto fileinfo = smanager.getFileEntryForID(smanager.getFileID(sl)) ;
if( fileinfo == NULL ){
continue ;
}
if(isInExcludedPath(fileinfo->getName(), excludedPathPatterns)){
continue ;
}
if(name.size()==0){
continue ;
}
const std::string filename=fileinfo->getName() ;
const int line = smanager.getPresumedLineNumber(sl) ;
const int col = smanager.getPresumedColumnNumber(sl) ;
// RULES NUMBER 1: The name of members cannot be terminated by an underscore.
if(name.rfind("_")!=name.size()-1){
}else{
printErrorM5(filename, line, col, classname, name);
}
/// THESES TWO RULES ARE NOW DEPRECATED BUT I KEEP THEM FOR HISTORY REASON
// THE FOLLOWING RULES ARE ONLY CHECK ON PRIVATE & PROTECTED FIELDS
if(ff->getAccess()==AS_public){
continue ;
}
CXXRecordDecl* rd=ff->getType()->getAsCXXRecordDecl() ;
if(rd){
std::string type=rd->getNameAsString() ;
if(type.find("Data")!=std::string::npos){
if(name.find("d_")==0){
}else{
printErrorM1(filename, line, col,
classname, name) ;
}
}else if(type.find("SingleLink")!=std::string::npos || type.find("DualLink")!=std::string::npos){
if(name.find("d_")==0){
}else{
printErrorM2(filename, line, col, classname, name) ;
}
}
}else{
if(name.find("m_")==0){
}else{
printErrorM3(filename, line, col, classname, name) ;
}
}
}
}
return true;
}
bool VisitDecl(Decl* decl)
{
if(Context==NULL)
return true ;
if(decl==NULL)
return true ;
FullSourceLoc FullLocation = Context->getFullLoc(decl->getLocStart());
if ( !FullLocation.isValid() || exclude(FullLocation.getManager() , decl) )
return true ;
/// Implement the different check on namespace naming.
NamespaceDecl* nsdecl= dyn_cast<NamespaceDecl>(decl) ;
if( nsdecl ){
string nsname=nsdecl->getNameAsString() ;
if( islower(nsname) )
return true ;
auto& smanager = Context->getSourceManager() ;
Decl* mrdecl=decl->getMostRecentDecl() ;
if(mrdecl!=NULL)
decl=mrdecl ;
SourceRange sr=decl->getSourceRange() ;
SourceLocation sl=sr.getBegin();
auto fileinfo=smanager.getFileEntryForID(smanager.getFileID(sl)) ;
if(fileinfo==NULL || isInExcludedPath(fileinfo->getName(), excludedPathPatterns))
return true ;
printErrorN1(fileinfo->getName(),
smanager.getPresumedLineNumber(sl),
smanager.getPresumedColumnNumber(sl),
nsname) ;
return true;
}
UsingDirectiveDecl* udecl = dyn_cast<UsingDirectiveDecl>(decl) ;
if(udecl){
auto& smanager = Context->getSourceManager() ;
SourceRange sr=decl->getSourceRange() ;
SourceLocation sl=sr.getBegin();
auto fileinfo=smanager.getFileEntryForID(smanager.getFileID(sl)) ;
string nsname = udecl->getNominatedNamespaceAsWritten()->getName() ;
if(fileinfo==NULL || isInExcludedPath(fileinfo->getName(), excludedPathPatterns))
return true ;
if(isInHeader(fileinfo->getName()) ){
printErrorW3(fileinfo->getName(),
smanager.getPresumedLineNumber(sl),
smanager.getPresumedColumnNumber(sl),
nsname);
}
return true ;
}
return RecursiveASTVisitor<StyleChecker>::VisitDecl(decl) ;
}
bool VisitStmt(Stmt* stmt){
if(Context == NULL )
return true ;
if( stmt == NULL )
return true ;
FullSourceLoc FullLocation = Context->getFullLoc(stmt->getLocStart()) ;
if ( !FullLocation.isValid() || exclude(FullLocation.getManager() , stmt) )
return true ;
// If we are on a declaration statement, check that we
// correctly provide a default value.
if(stmt->getStmtClass() == Stmt::DeclStmtClass) {
auto& smanager=Context->getSourceManager() ;
DeclStmt* declstmt=dyn_cast<DeclStmt>(stmt) ;
for(auto cs=declstmt->decl_begin(); cs!=declstmt->decl_end();++cs) {
Decl* decl = *cs;
VarDecl* vardecl = dyn_cast<VarDecl>(decl) ;
if(vardecl){
auto tmp=vardecl->getMostRecentDecl() ;
if(tmp)
decl=tmp ;
SourceRange declsr=decl->getSourceRange() ;
SourceLocation sl=declsr.getBegin();
auto fileinfo=smanager.getFileEntryForID(smanager.getFileID(sl)) ;
if(fileinfo==NULL || isInExcludedPath(fileinfo->getName(), excludedPathPatterns))
continue ;
if( vardecl->getAnyInitializer() == NULL ){
printErrorV1(fileinfo->getName(),
smanager.getPresumedLineNumber(sl),
smanager.getPresumedColumnNumber(sl),
vardecl->getNameAsString()) ;
}
}
}
}else if(stmt->getStmtClass() == Stmt::GotoStmtClass){
SourceRange sr=stmt->getSourceRange() ;
SourceLocation sl=sr.getBegin() ;
auto& smanager=Context->getSourceManager() ;
auto fileinfo=smanager.getFileEntryForID(smanager.getFileID(sl)) ;
if(fileinfo==NULL || isInExcludedPath(fileinfo->getName(), excludedPathPatterns))
return true ;
printErrorW1(fileinfo->getName(),
smanager.getPresumedLineNumber(sl),
smanager.getPresumedColumnNumber(sl));
}else if(stmt->getStmtClass() == Stmt::CallExprClass){
CallExpr* callexpr=dyn_cast<CallExpr>(stmt) ;
FunctionDecl* fctdecl=callexpr->getDirectCallee() ;
if(fctdecl){
const string& fctname = fctdecl->getNameAsString() ;
for(auto p : oldccode)
{
if(fctname == p.first){
SourceRange sr=stmt->getSourceRange() ;
SourceLocation sl=sr.getBegin() ;
auto& smanager=Context->getSourceManager() ;
auto fileinfo=smanager.getFileEntryForID(smanager.getFileID(sl)) ;
if(fileinfo==NULL || isInExcludedPath(fileinfo->getName(), excludedPathPatterns))
return true ;
printErrorW2(fileinfo->getName(),
smanager.getPresumedLineNumber(sl),
smanager.getPresumedColumnNumber(sl),
p.first, p.second);
break ;
}
}
}
}
return true ;
}