void ErrorLogger::reportUnmatchedSuppressions(const std::list<Settings::Suppressions::SuppressionEntry> &unmatched)

for (std::list<Settings::Suppressions::SuppressionEntry>::const_iterator i = unmatched.begin(); i != unmatched.end(); ++i)

void reportUnmatchedSuppressions(const std::list<Settings::Suppressions::SuppressionEntry> &unmatched);

std::string Settings::Suppressions::parseFile(std::istream &istr)

{

// Change '\r' to '\n' in the istr

std::string filedata;

std::string line;

while (std::getline(istr, line))

filedata += line + "\n";

while (filedata.find("\r") != std::string::npos)

filedata[filedata.find("\r")] = '\n';

// Parse filedata..

std::istringstream istr2(filedata);

while (std::getline(istr2, line))

{

// Skip empty lines

if (line.empty())

continue;

// Skip comments

if (line.length() >= 2 && line[0] == '/' && line[1] == '/')

continue;

const std::string errmsg(addSuppressionLine(line));

if (!errmsg.empty())

return errmsg;

}

return "";

}

std::string Settings::Suppressions::addSuppressionLine(const std::string &line)

{

std::istringstream lineStream(line);

std::string id;

std::string file;

unsigned int lineNumber = 0;

if (std::getline(lineStream, id, ':'))

{

if (std::getline(lineStream, file))

{

// If there is not a dot after the last colon in "file" then

// the colon is a separator and the contents after the colon

// is a line number..

// Get position of last colon

const std::string::size_type pos = file.rfind(":");

// if a colon is found and there is no dot after it..

if (pos != std::string::npos &&

file.find(".", pos) == std::string::npos)

{

// Try to parse out the line number

try

{

std::istringstream istr1(file.substr(pos+1));

istr1 >> lineNumber;

}

catch (...)

{

lineNumber = 0;

}

if (lineNumber > 0)

{

file.erase(pos);

}

}

}

}

// We could perhaps check if the id is valid and return error if it is not

const std::string errmsg(addSuppression(id, file, lineNumber));

if (!errmsg.empty())

return errmsg;

return "";

}

bool Settings::Suppressions::FileMatcher::match(const std::string &pattern, const std::string &name)

{

const char *p = pattern.c_str();

const char *n = name.c_str();

std::stack<std::pair<const char *, const char *> > backtrack;

for (;;)

{

bool matching = true;

while (*p != '\0' && matching)

{

switch (*p)

{

case '*':

// Step forward until we match the next character after *

while (*n != '\0' && *n != p[1])

{

n++;

}

if (*n != '\0')

{

// If this isn't the last possibility, save it for later

backtrack.push(std::make_pair(p, n));

}

break;

case '?':

// Any character matches unless we're at the end of the name

if (*n != '\0')

{

n++;

}

else

{

matching = false;

}

break;

default:

// Non-wildcard characters match literally

if (*n == *p)

{

n++;

}

else

{

matching = false;

}

break;

}

p++;

}

// If we haven't failed matching and we've reached the end of the name, then success

if (matching && *n == '\0')

{

return true;

}

// If there are no other paths to tray, then fail

if (backtrack.empty())

{

return false;

}

// Restore pointers from backtrack stack

p = backtrack.top().first;

n = backtrack.top().second;

backtrack.pop();

// Advance name pointer by one because the current position didn't work

n++;

}

}

std::string Settings::Suppressions::FileMatcher::addFile(const std::string &name, unsigned int line)

{

if (name.find_first_of("*?") != std::string::npos)

{

for (std::string::const_iterator i = name.begin(); i != name.end(); ++i)

{

if (*i == '*')

{

std::string::const_iterator j = i + 1;

if (j != name.end() && (*j == '*' || *j == '?'))

{

return "Failed to add suppression. Syntax error in glob.";

}

}

}

_globs[name][line] = false;

}

else if (name.empty())

{

_globs["*"][0U] = false;

}

else

{

_files[Path::simplifyPath(name.c_str())][line] = false;

}

return "";

}

bool Settings::Suppressions::FileMatcher::isSuppressed(const std::string &file, unsigned int line)

{

if (isSuppressedLocal(file, line))

return true;

for (std::map<std::string, std::map<unsigned int, bool> >::iterator g = _globs.begin(); g != _globs.end(); ++g)

{

if (match(g->first, file))

{

if (g->second.find(0U) != g->second.end())

{

g->second[0U] = true;

return true;

}

std::map<unsigned int, bool>::iterator l = g->second.find(line);

if (l != g->second.end())

{

l->second = true;

return true;

}

}

}

return false;

}

bool Settings::Suppressions::FileMatcher::isSuppressedLocal(const std::string &file, unsigned int line)

{

std::map<std::string, std::map<unsigned int, bool> >::iterator f = _files.find(file);

if (f != _files.end())

{

if (f->second.find(0U) != f->second.end())

{

f->second[0U] = true;

return true;

}

std::map<unsigned int, bool>::iterator l = f->second.find(line);

if (l != f->second.end())

{

l->second = true;

return true;

}

}

return false;

}

std::string Settings::Suppressions::addSuppression(const std::string &errorId, const std::string &file, unsigned int line)

{

// Check that errorId is valid..

if (errorId.empty())

{

return "Failed to add suppression. No id.";

}

if (errorId != "*")

{

for (std::string::size_type pos = 0; pos < errorId.length(); ++pos)

{

if (errorId[pos] < 0 || !std::isalnum(errorId[pos]))

{

return "Failed to add suppression. Invalid id \"" + errorId + "\"";

}

if (pos == 0 && std::isdigit(errorId[pos]))

{

return "Failed to add suppression. Invalid id \"" + errorId + "\"";

}

}

}

return _suppressions[errorId].addFile(file, line);

}

bool Settings::Suppressions::isSuppressed(const std::string &errorId, const std::string &file, unsigned int line)

{

if (errorId != "unmatchedSuppression" && _suppressions.find("*") != _suppressions.end())

if (_suppressions["*"].isSuppressed(file, line))

return true;

if (_suppressions.find(errorId) == _suppressions.end())

return false;

return _suppressions[errorId].isSuppressed(file, line);

}

bool Settings::Suppressions::isSuppressedLocal(const std::string &errorId, const std::string &file, unsigned int line)

{

if (errorId != "unmatchedSuppression" && _suppressions.find("*") != _suppressions.end())

if (_suppressions["*"].isSuppressedLocal(file, line))

return true;

if (_suppressions.find(errorId) == _suppressions.end())

return false;

return _suppressions[errorId].isSuppressedLocal(file, line);

}

std::list<Settings::Suppressions::SuppressionEntry> Settings::Suppressions::getUnmatchedLocalSuppressions(const std::string &file) const

{

std::list<SuppressionEntry> r;

for (std::map<std::string, FileMatcher>::const_iterator i = _suppressions.begin(); i != _suppressions.end(); ++i)

{

std::map<std::string, std::map<unsigned int, bool> >::const_iterator f = i->second._files.find(file);

if (f != i->second._files.end())

{

for (std::map<unsigned int, bool>::const_iterator l = f->second.begin(); l != f->second.end(); ++l)

{

if (!l->second)

{

r.push_back(SuppressionEntry(i->first, f->first, l->first));

}

}

}

}

return r;

}

std::list<Settings::Suppressions::SuppressionEntry> Settings::Suppressions::getUnmatchedGlobalSuppressions() const

{

std::list<SuppressionEntry> r;

for (std::map<std::string, FileMatcher>::const_iterator i = _suppressions.begin(); i != _suppressions.end(); ++i)

{

for (std::map<std::string, std::map<unsigned int, bool> >::const_iterator g = i->second._globs.begin(); g != i->second._globs.end(); ++g)

{

for (std::map<unsigned int, bool>::const_iterator l = g->second.begin(); l != g->second.end(); ++l)

{

if (!l->second)

{

r.push_back(SuppressionEntry(i->first, g->first, l->first));

}

}

}

}

return r;

}