#include "errorlogger.h"

#include "cppcheck.h"

#include "mathlib.h"

#include "path.h"

#include "token.h"

#include "tokenlist.h"

#include "utils.h"

#include <tinyxml2.h>

#include <array>

#include <cassert>

#include <cctype>

#include <cstdlib>

#include <cstring>

#include <iomanip>

InternalError::InternalError(const Token *tok, const std::string &errorMsg, Type type) :

}

ErrorLogger::ErrorMessage::ErrorMessage()

: _severity(Severity::none), _cwe(0U), _inconclusive(false)

{

}

ErrorLogger::ErrorMessage::ErrorMessage(const std::list<FileLocation> &callStack, const std::string& file1, Severity::SeverityType severity, const std::string &msg, const std::string &id, bool inconclusive) :

_callStack(callStack), // locations for this error message

_id(id), // set the message id

file0(file1),

_severity(severity), // severity for this error message

_cwe(0U),

_inconclusive(inconclusive)

{

// set the summary and verbose messages

setmsg(msg);

}

ErrorLogger::ErrorMessage::ErrorMessage(const std::list<FileLocation> &callStack, const std::string& file1, Severity::SeverityType severity, const std::string &msg, const std::string &id, const CWE &cwe, bool inconclusive) :

_callStack(callStack), // locations for this error message

_id(id), // set the message id

file0(file1),

_severity(severity), // severity for this error message

_cwe(cwe.id),

_inconclusive(inconclusive)

{

// set the summary and verbose messages

setmsg(msg);

}

ErrorLogger::ErrorMessage::ErrorMessage(const std::list<const Token*>& callstack, const TokenList* list, Severity::SeverityType severity, const std::string& id, const std::string& msg, bool inconclusive)

: _id(id), _severity(severity), _cwe(0U), _inconclusive(inconclusive)

{

// Format callstack

for (std::list<const Token *>::const_iterator it = callstack.begin(); it != callstack.end(); ++it) {

// --errorlist can provide null values here

if (!(*it))

continue;

_callStack.emplace_back(*it, list);

}

if (list && !list->getFiles().empty())

file0 = list->getFiles()[0];

setmsg(msg);

}

ErrorLogger::ErrorMessage::ErrorMessage(const std::list<const Token*>& callstack, const TokenList* list, Severity::SeverityType severity, const std::string& id, const std::string& msg, const CWE &cwe, bool inconclusive)

: _id(id), _severity(severity), _cwe(cwe.id), _inconclusive(inconclusive)

{

// Format callstack

for (std::list<const Token *>::const_iterator it = callstack.begin(); it != callstack.end(); ++it) {

// --errorlist can provide null values here

if (!(*it))

continue;

_callStack.emplace_back(*it, list);

}

if (list && !list->getFiles().empty())

file0 = list->getFiles()[0];

setmsg(msg);

}

ErrorLogger::ErrorMessage::ErrorMessage(const ErrorPath &errorPath, const TokenList *tokenList, Severity::SeverityType severity, const char id[], const std::string &msg, const CWE &cwe, bool inconclusive)

: _id(id), _severity(severity), _cwe(cwe.id), _inconclusive(inconclusive)

{

// Format callstack

for (ErrorPath::const_iterator it = errorPath.begin(); it != errorPath.end(); ++it) {

const Token *tok = it->first;

const std::string &info = it->second;

// --errorlist can provide null values here

if (tok)

_callStack.emplace_back(tok, info, tokenList);

}

if (tokenList && !tokenList->getFiles().empty())

file0 = tokenList->getFiles()[0];

setmsg(msg);

}

ErrorLogger::ErrorMessage::ErrorMessage(const tinyxml2::XMLElement * const errmsg)

: _severity(Severity::none),

_cwe(0U),

_inconclusive(false)

{

const char * const unknown = "<UNKNOWN>";

const char *attr = errmsg->Attribute("id");

_id = attr ? attr : unknown;

attr = errmsg->Attribute("severity");

_severity = attr ? Severity::fromString(attr) : Severity::none;

attr = errmsg->Attribute("cwe");

std::istringstream(attr ? attr : "0") >> _cwe.id;

attr = errmsg->Attribute("inconclusive");

_inconclusive = attr && (std::strcmp(attr, "true") == 0);

attr = errmsg->Attribute("msg");

mShortMessage = attr ? attr : "";

attr = errmsg->Attribute("verbose");

mVerboseMessage = attr ? attr : "";

for (const tinyxml2::XMLElement *e = errmsg->FirstChildElement(); e; e = e->NextSiblingElement()) {

if (std::strcmp(e->Name(),"location")==0) {

const char *strfile = e->Attribute("file");

const char *strinfo = e->Attribute("info");

const char *strline = e->Attribute("line");

const char *file = strfile ? strfile : unknown;

const char *info = strinfo ? strinfo : "";

const int line = strline ? std::atoi(strline) : 0;

_callStack.emplace_back(file, info, line);

}

}

}

static std::string replaceStr(std::string s, const std::string &from, const std::string &to)

}

void ErrorLogger::ErrorMessage::setmsg(const std::string &msg)

{

// If a message ends to a '\n' and contains only a one '\n'

// it will cause the mVerboseMessage to be empty which will show

// as an empty message to the user if --verbose is used.

// Even this doesn't cause problems with messages that have multiple

// lines, none of the error messages should end into it.

assert(!endsWith(msg,'\n'));

// The summary and verbose message are separated by a newline

// If there is no newline then both the summary and verbose messages

// are the given message

const std::string::size_type pos = msg.find('\n');

const std::string symbolName = mSymbolNames.empty() ? std::string() : mSymbolNames.substr(0, mSymbolNames.find('\n'));

if (pos == std::string::npos) {

mShortMessage = replaceStr(msg, "$symbol", symbolName);

mVerboseMessage = replaceStr(msg, "$symbol", symbolName);

} else if (msg.compare(0,8,"$symbol:") == 0) {

mSymbolNames += msg.substr(8, pos-7);

setmsg(msg.substr(pos + 1));

} else {

mShortMessage = replaceStr(msg.substr(0, pos), "$symbol", symbolName);

mVerboseMessage = replaceStr(msg.substr(pos + 1), "$symbol", symbolName);

}

}

Suppressions::ErrorMessage ErrorLogger::ErrorMessage::toSuppressionsErrorMessage() const

{

Suppressions::ErrorMessage ret;

ret.errorId = _id;

if (!_callStack.empty()) {

ret.setFileName(_callStack.back().getfile(false));

ret.lineNumber = _callStack.back().line;

}

ret.inconclusive = _inconclusive;

ret.symbolNames = mSymbolNames;

return ret;

}

std::string ErrorLogger::ErrorMessage::serialize() const

{

// Serialize this message into a simple string

std::ostringstream oss;

oss << _id.length() << " " << _id;

oss << Severity::toString(_severity).length() << " " << Severity::toString(_severity);

oss << MathLib::toString(_cwe.id).length() << " " << MathLib::toString(_cwe.id);

if (_inconclusive) {

const std::string inconclusive("inconclusive");

oss << inconclusive.length() << " " << inconclusive;

}

const std::string saneShortMessage = fixInvalidChars(mShortMessage);

const std::string saneVerboseMessage = fixInvalidChars(mVerboseMessage);

oss << saneShortMessage.length() << " " << saneShortMessage;

oss << saneVerboseMessage.length() << " " << saneVerboseMessage;

oss << _callStack.size() << " ";

for (std::list<ErrorLogger::ErrorMessage::FileLocation>::const_iterator loc = _callStack.begin(); loc != _callStack.end(); ++loc) {

std::ostringstream smallStream;

smallStream << (*loc).line << ':' << (*loc).getfile() << '\t' << loc->getinfo();

oss << smallStream.str().length() << " " << smallStream.str();

}

return oss.str();

}

bool ErrorLogger::ErrorMessage::deserialize(const std::string &data)

{

_inconclusive = false;

_callStack.clear();

std::istringstream iss(data);

std::array<std::string, 5> results;

std::size_t elem = 0;

while (iss.good()) {

unsigned int len = 0;

if (!(iss >> len))

return false;

iss.get();

std::string temp;

for (unsigned int i = 0; i < len && iss.good(); ++i) {

const char c = static_cast<char>(iss.get());

temp.append(1, c);

}

if (temp == "inconclusive") {

_inconclusive = true;

continue;

}

results[elem++] = temp;

if (elem == 5)

break;

}

if (elem != 5)

throw InternalError(nullptr, "Internal Error: Deserialization of error message failed");

_id = results[0];

_severity = Severity::fromString(results[1]);

std::istringstream scwe(results[2]);

scwe >> _cwe.id;

mShortMessage = results[3];

mVerboseMessage = results[4];

unsigned int stackSize = 0;

if (!(iss >> stackSize))

return false;

while (iss.good()) {

unsigned int len = 0;

if (!(iss >> len))

return false;

iss.get();

std::string temp;

for (unsigned int i = 0; i < len && iss.good(); ++i) {

const char c = static_cast<char>(iss.get());

temp.append(1, c);

}

const std::string::size_type colonPos = temp.find(':');

if (colonPos == std::string::npos)

throw InternalError(nullptr, "Internal Error: No colon found in <filename:line> pattern");

const std::string::size_type tabPos = temp.find('\t');

if (tabPos == std::string::npos)

throw InternalError(nullptr, "Internal Error: No tab found in <filename:line> pattern");

const std::string tempinfo = temp.substr(tabPos + 1);

temp.erase(tabPos);

const std::string tempfile = temp.substr(colonPos + 1);

temp.erase(colonPos);

const std::string templine = temp;

ErrorLogger::ErrorMessage::FileLocation loc;

loc.setfile(tempfile);

loc.setinfo(tempinfo);

std::istringstream fiss(templine);

fiss >> loc.line;

_callStack.push_back(loc);

if (_callStack.size() >= stackSize)

break;

}

return true;

}

std::string ErrorLogger::ErrorMessage::getXMLHeader()

{

// xml_version 1 is the default xml format

tinyxml2::XMLPrinter printer;

// standard xml header

printer.PushDeclaration("xml version=\"1.0\" encoding=\"UTF-8\"");

// header

printer.OpenElement("results", false);

printer.PushAttribute("version", 2);

printer.OpenElement("cppcheck", false);

printer.PushAttribute("version", CppCheck::version());

printer.CloseElement(false);

printer.OpenElement("errors", false);

return std::string(printer.CStr()) + '>';

}

std::string ErrorLogger::ErrorMessage::getXMLFooter()

{

return " </errors>\n</results>";

}

std::string ErrorLogger::ErrorMessage::fixInvalidChars(const std::string& raw)

{

std::string result;

result.reserve(raw.length());

std::string::const_iterator from=raw.begin();

while (from!=raw.end()) {

if (std::isprint(static_cast<unsigned char>(*from))) {

result.push_back(*from);

} else {

std::ostringstream es;

// straight cast to (unsigned) doesn't work out.

const unsigned uFrom = (unsigned char)*from;

es << '\\' << std::setbase(8) << std::setw(3) << std::setfill('0') << uFrom;

result += es.str();

}

++from;

}

return result;

}

std::string ErrorLogger::ErrorMessage::toXML() const

{

tinyxml2::XMLPrinter printer(nullptr, false, 2);

printer.OpenElement("error", false);

printer.PushAttribute("id", _id.c_str());

printer.PushAttribute("severity", Severity::toString(_severity).c_str());

printer.PushAttribute("msg", fixInvalidChars(mShortMessage).c_str());

printer.PushAttribute("verbose", fixInvalidChars(mVerboseMessage).c_str());

if (_cwe.id)

printer.PushAttribute("cwe", _cwe.id);

if (_inconclusive)

printer.PushAttribute("inconclusive", "true");

for (std::list<FileLocation>::const_reverse_iterator it = _callStack.rbegin(); it != _callStack.rend(); ++it) {

printer.OpenElement("location", false);

if (!file0.empty() && (*it).getfile() != file0)

printer.PushAttribute("file0", Path::toNativeSeparators(file0).c_str());

printer.PushAttribute("file", (*it).getfile().c_str());

printer.PushAttribute("line", std::max((*it).line,0));

if (!it->getinfo().empty())

printer.PushAttribute("info", it->getinfo().c_str());

printer.CloseElement(false);

}

for (std::string::size_type pos = 0; pos < mSymbolNames.size();) {

const std::string::size_type pos2 = mSymbolNames.find('\n', pos);

std::string symbolName;

if (pos2 == std::string::npos) {

symbolName = mSymbolNames.substr(pos);

pos = pos2;

} else {

symbolName = mSymbolNames.substr(pos, pos2-pos);

pos = pos2 + 1;

}

printer.OpenElement("symbol", false);

printer.PushText(symbolName.c_str());

printer.CloseElement(false);

}

printer.CloseElement(false);

return printer.CStr();

}

void ErrorLogger::ErrorMessage::findAndReplace(std::string &source, const std::string &searchFor, const std::string &replaceWith)

{

std::string::size_type index = 0;

while ((index = source.find(searchFor, index)) != std::string::npos) {

source.replace(index, searchFor.length(), replaceWith);

index += replaceWith.length();

}

}

static std::string readCode(const std::string &file, unsigned int linenr, unsigned int column, const char endl[])

}

std::string ErrorLogger::ErrorMessage::toString(bool verbose, const std::string &templateFormat, const std::string &templateLocation) const

{

// Save this ErrorMessage in plain text.

// No template is given

if (templateFormat.empty()) {

std::ostringstream text;

if (!_callStack.empty())

text << callStackToString(_callStack) << ": ";

if (_severity != Severity::none) {

text << '(' << Severity::toString(_severity);

if (_inconclusive)

text << ", inconclusive";

text << ") ";

}

text << (verbose ? mVerboseMessage : mShortMessage);

return text.str();

}

// template is given. Reformat the output according to it

std::string result = templateFormat;

// Support a few special characters to allow to specific formatting, see http://sourceforge.net/apps/phpbb/cppcheck/viewtopic.php?f=4&t=494&sid=21715d362c0dbafd3791da4d9522f814

// Substitution should be done first so messages from cppcheck never get translated.

findAndReplace(result, "\\b", "\b");

findAndReplace(result, "\\n", "\n");

findAndReplace(result, "\\r", "\r");

findAndReplace(result, "\\t", "\t");

findAndReplace(result, "{id}", _id);

if (result.find("{inconclusive:") != std::string::npos) {

const std::string::size_type pos1 = result.find("{inconclusive:");

const std::string::size_type pos2 = result.find('}', pos1+1);

const std::string replaceFrom = result.substr(pos1,pos2-pos1+1);

const std::string replaceWith = _inconclusive ? result.substr(pos1+14, pos2-pos1-14) : std::string();

findAndReplace(result, replaceFrom, replaceWith);

}

findAndReplace(result, "{severity}", Severity::toString(_severity));

findAndReplace(result, "{cwe}", MathLib::toString(_cwe.id));

findAndReplace(result, "{message}", verbose ? mVerboseMessage : mShortMessage);

findAndReplace(result, "{callstack}", _callStack.empty() ? emptyString : callStackToString(_callStack));

if (!_callStack.empty()) {

findAndReplace(result, "{file}", _callStack.back().getfile());

findAndReplace(result, "{line}", MathLib::toString(_callStack.back().line));

findAndReplace(result, "{column}", MathLib::toString(_callStack.back().col));

if (result.find("{code}") != std::string::npos) {

const std::string::size_type pos = result.find('\r');

const char *endl;

if (pos == std::string::npos)

endl = "\n";

else if (pos+1 < result.size() && result[pos+1] == '\n')

endl = "\r\n";

else

endl = "\r";

findAndReplace(result, "{code}", readCode(_callStack.back().getOrigFile(), _callStack.back().line, _callStack.back().col, endl));

}

} else {

findAndReplace(result, "{file}", "nofile");

findAndReplace(result, "{line}", "0");

findAndReplace(result, "{column}", "0");

findAndReplace(result, "{code}", emptyString);

}

if (!templateLocation.empty() && _callStack.size() >= 2U) {

for (const FileLocation &fileLocation : _callStack) {

std::string text = templateLocation;

findAndReplace(text, "\\b", "\b");

findAndReplace(text, "\\n", "\n");

findAndReplace(text, "\\r", "\r");

findAndReplace(text, "\\t", "\t");

findAndReplace(text, "{file}", fileLocation.getfile());

findAndReplace(text, "{line}", MathLib::toString(fileLocation.line));

findAndReplace(text, "{column}", MathLib::toString(fileLocation.col));

findAndReplace(text, "{info}", fileLocation.getinfo().empty() ? mShortMessage : fileLocation.getinfo());

if (text.find("{code}") != std::string::npos) {

const std::string::size_type pos = text.find('\r');

const char *endl;

if (pos == std::string::npos)

endl = "\n";

else if (pos+1 < text.size() && text[pos+1] == '\n')

endl = "\r\n";

else

endl = "\r";

findAndReplace(text, "{code}", readCode(fileLocation.getOrigFile(), fileLocation.line, fileLocation.col, endl));

}

result += '\n' + text;

}

}

return result;

}

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

}

std::string ErrorLogger::callStackToString(const std::list<ErrorLogger::ErrorMessage::FileLocation> &callStack)

}

ErrorLogger::ErrorMessage::FileLocation::FileLocation(const Token* tok, const TokenList* tokenList)

: fileIndex(tok->fileIndex()), line(tok->linenr()), col(tok->col()), mOrigFileName(tokenList->getOrigFile(tok)), mFileName(tokenList->file(tok))

{

}

ErrorLogger::ErrorMessage::FileLocation::FileLocation(const Token* tok, const std::string &info, const TokenList* tokenList)

: fileIndex(tok->fileIndex()), line(tok->linenr()), col(tok->col()), mOrigFileName(tokenList->getOrigFile(tok)), mFileName(tokenList->file(tok)), mInfo(info)

{

}

std::string ErrorLogger::ErrorMessage::FileLocation::getfile(bool convert) const

{

if (convert)

return Path::toNativeSeparators(mFileName);

return mFileName;

}

std::string ErrorLogger::ErrorMessage::FileLocation::getOrigFile(bool convert) const

{

if (convert)

return Path::toNativeSeparators(mOrigFileName);

return mOrigFileName;

}

void ErrorLogger::ErrorMessage::FileLocation::setfile(const std::string &file)

{

mFileName = file;

mFileName = Path::fromNativeSeparators(mFileName);

mFileName = Path::simplifyPath(mFileName);

}

std::string ErrorLogger::ErrorMessage::FileLocation::stringify() const

{

std::ostringstream oss;

oss << '[' << Path::toNativeSeparators(mFileName);

if (line != Suppressions::Suppression::NO_LINE)

oss << ':' << line;

oss << ']';

return oss.str();

}

std::string ErrorLogger::toxml(const std::string &str)

}

std::string ErrorLogger::plistHeader(const std::string &version, const std::vector<std::string> &files)

}

static std::string plistLoc(const char indent[], const ErrorLogger::ErrorMessage::FileLocation &loc)

}

std::string ErrorLogger::plistData(const ErrorLogger::ErrorMessage &msg)

}