#include "errorlogger.h"

#include "color.h"

#include "cppcheck.h"

#include "path.h"

#include "settings.h"

#include "suppressions.h"

#include "symboldatabase.h"

#include "token.h"

#include "tokenlist.h"

#include "utils.h"

#include "checkers.h"

#include <algorithm>

#include <array>

#include <cassert>

#include <cctype>

#include <cstring>

#include <fstream>

#include <iomanip>

#include <numeric>

#include <sstream>

#include <string>

#include <unordered_map>

#include <utility>

#include "xml.h"

const std::set<std::string> ErrorLogger::mCriticalErrorIds{

"cppcheckError",

"cppcheckLimit",

"includeNestedTooDeeply",

"internalAstError",

"instantiationError",

"internalError",

"missingFile",

"premium-internalError",

"premium-invalidArgument",

"premium-invalidLicense",

"preprocessorErrorDirective",

"syntaxError",

"unhandledChar",

"unknownMacro"

};

ErrorMessage::ErrorMessage()

: severity(Severity::none), cwe(0U), certainty(Certainty::normal)

{}

ErrorMessage::ErrorMessage(std::list<FileLocation> callStack, std::string file1, Severity severity, const std::string &msg, std::string id, Certainty certainty) :

}

ErrorMessage::ErrorMessage(std::list<FileLocation> callStack, std::string file1, Severity severity, const std::string &msg, std::string id, const CWE &cwe, Certainty certainty) :

}

ErrorMessage::ErrorMessage(const std::list<const Token*>& callstack, const TokenList* list, Severity severity, std::string id, const std::string& msg, Certainty certainty)

}

ErrorMessage::ErrorMessage(const std::list<const Token*>& callstack, const TokenList* list, Severity severity, std::string id, const std::string& msg, const CWE &cwe, Certainty certainty)

}

ErrorMessage::ErrorMessage(ErrorPath errorPath, const TokenList *tokenList, Severity severity, const char id[], const std::string &msg, const CWE &cwe, Certainty certainty)

}

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

}

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

}

void ErrorMessage::calculateWarningHash(const std::list<const Token*>& callstack)

}

static void serializeString(std::string &oss, const std::string & str)

}

ErrorMessage ErrorMessage::fromInternalError(const InternalError &internalError, const TokenList *tokenList, const std::string &filename, const std::string& msg)

}

std::string ErrorMessage::serialize() const

}

void ErrorMessage::deserialize(const std::string &data)

}

std::string ErrorMessage::getXMLHeader(std::string productName, int xmlVersion)

}

std::string ErrorMessage::getXMLFooter(int xmlVersion)

{

return xmlVersion == 3 ? "</results>" : " </errors>\n</results>";

}

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

}

std::string ErrorMessage::toXML() const

}

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

}

static void replaceSpecialChars(std::string& source)

}

static void replace(std::string& source, const std::unordered_map<std::string, std::string> &substitutionMap)

}

static void replaceColors(std::string& source, bool erase) {

}

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

}

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

}

ErrorMessage::FileLocation::FileLocation(const std::string &file, int line, unsigned int column)

: fileIndex(0), line(line), column(column), mOrigFileName(file), mFileName(Path::simplifyPath(file))

{}

ErrorMessage::FileLocation::FileLocation(const std::string &file, std::string info, int line, unsigned int column)

: fileIndex(0), line(line), column(column), mOrigFileName(file), mFileName(Path::simplifyPath(file)), mInfo(std::move(info))

{}

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

: fileIndex(tok->fileIndex()), line(tok->linenr()), column(tok->column()), mOrigFileName(tokenList->getOrigFile(tok)), mFileName(Path::simplifyPath(tokenList->file(tok)))

{}

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

: fileIndex(tok->fileIndex()), line(tok->linenr()), column(tok->column()), mOrigFileName(tokenList->getOrigFile(tok)), mFileName(Path::simplifyPath(tokenList->file(tok))), mInfo(std::move(info))

{}

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

{

if (convert)

return Path::toNativeSeparators(mFileName);

return mFileName;

}

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

{

if (convert)

return Path::toNativeSeparators(mOrigFileName);

return mOrigFileName;

}

void ErrorMessage::FileLocation::setfile(std::string file)

{

mFileName = Path::simplifyPath(std::move(file));

}

std::string ErrorMessage::FileLocation::stringify(bool addcolumn) const

{

std::string str;

str += '[';

str += Path::toNativeSeparators(mFileName);

if (line != SuppressionList::Suppression::NO_LINE) { // TODO: should not depend on Suppression

str += ':';

str += std::to_string(line);

if (addcolumn) {

str += ':';

str += std::to_string(column);

}

}

str += ']';

return str;

}

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

}

std::string ErrorLogger::plistHeader(const std::string &version)

}

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

}

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

}

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