errorlogger.h

cppcheck is a static C/C++ code analyzer that checks for memory leaks, mismatching allocation-deallo

        _writemsg(tokenizer, Location, "error", "Deallocating a deallocated pointer: " + varname + "", "deallocDealloc");
    }
    static bool deallocDealloc()
    {
        return true;
    }

    void deallocuse(const Tokenizer *tokenizer, const Token *Location, const std::string &varname)
    {
        _writemsg(tokenizer, Location, "error", "Using '" + varname + "' after it is deallocated / released", "deallocuse");
    }
    static bool deallocuse()
    {
        return true;
    }

    void mismatchSize(const Tokenizer *tokenizer, const Token *Location, const std::string &sz)
    {
        _writemsg(tokenizer, Location, "error", "The given size " + sz + " is mismatching", "mismatchSize");
    }
    static bool mismatchSize()
    {
        return true;
    }

    void cstyleCast(const Tokenizer *tokenizer, const Token *Location)
    {
        _writemsg(tokenizer, Location, "style", "C-style pointer casting", "cstyleCast");
    }
    static bool cstyleCast(const Settings &s)
    {
        return s._checkCodingStyle;
    }

    void redundantIfDelete0(const Tokenizer *tokenizer, const Token *Location)
    {
        _writemsg(tokenizer, Location, "style", "Redundant condition. It is safe to deallocate a NULL pointer", "redundantIfDelete0");
    }
    static bool redundantIfDelete0(const Settings &s)
    {
        return s._checkCodingStyle;
    }

    void redundantIfRemove(const Tokenizer *tokenizer, const Token *Location)
    {
        _writemsg(tokenizer, Location, "style", "Redundant condition. The remove function in the STL will not do anything if element doesn't exist", "redundantIfRemove");
    }
    static bool redundantIfRemove(const Settings &s)
    {
        return s._checkCodingStyle;
    }

    void dangerousUsageStrtol(const Tokenizer *tokenizer, const Token *Location)
    {
        _writemsg(tokenizer, Location, "error", "Invalid radix in call to strtol or strtoul. Must be 0 or 2-36", "dangerousUsageStrtol");
    }
    static bool dangerousUsageStrtol()
    {
        return true;
    }

    void ifNoAction(const Tokenizer *tokenizer, const Token *Location)
    {
        _writemsg(tokenizer, Location, "style", "Found redundant if condition - 'if (condition);'", "ifNoAction");
    }
    static bool ifNoAction(const Settings &s)
    {
        return s._checkCodingStyle;
    }

    void sprintfOverlappingData(const Tokenizer *tokenizer, const Token *Location, const std::string &varname)
    {
        _writemsg(tokenizer, Location, "error", "Overlapping data buffer " + varname + "", "sprintfOverlappingData");
    }
    static bool sprintfOverlappingData()
    {
        return true;
    }

    void udivError(const Tokenizer *tokenizer, const Token *Location)
    {
        _writemsg(tokenizer, Location, "error", "Unsigned division. The result will be wrong.", "udivError");
    }
    static bool udivError()
    {
        return true;
    }

    void udivWarning(const Tokenizer *tokenizer, const Token *Location)
    {
        _writemsg(tokenizer, Location, "all style", "Warning: Division with signed and unsigned operators", "udivWarning");
    }
    static bool udivWarning(const Settings &s)
    {
        return s._checkCodingStyle || s._showAll;
    }

    void unusedStructMember(const Tokenizer *tokenizer, const Token *Location, const std::string &structname, const std::string &varname)
    {
        _writemsg(tokenizer, Location, "style", "struct or union member '" + structname + "::" + varname + "' is never used", "unusedStructMember");
    }
    static bool unusedStructMember(const Settings &s)
    {
        return s._checkCodingStyle;
    }

    void passedByValue(const Tokenizer *tokenizer, const Token *Location, const std::string &parname)
    {
        _writemsg(tokenizer, Location, "style", "Function parameter '" + parname + "' is passed by value. It could be passed by reference instead.", "passedByValue");
    }
    static bool passedByValue(const Settings &s)
    {
        return s._checkCodingStyle;
    }

    void constStatement(const Tokenizer *tokenizer, const Token *Location, const std::string &type)
    {
        _writemsg(tokenizer, Location, "style", "Redundant code: Found a statement that begins with " + type + " constant", "constStatement");
    }
    static bool constStatement(const Settings &s)
    {
        return s._checkCodingStyle;
    }

    void charArrayIndex(const Tokenizer *tokenizer, const Token *Location)
    {
        _writemsg(tokenizer, Location, "style", "Warning - using char variable as array index", "charArrayIndex");
    }
    static bool charArrayIndex(const Settings &s)
    {
        return s._checkCodingStyle;
    }

    void charBitOp(const Tokenizer *tokenizer, const Token *Location)
    {
        _writemsg(tokenizer, Location, "style", "Warning - using char variable in bit operation", "charBitOp");
    }
    static bool charBitOp(const Settings &s)
    {
        return s._checkCodingStyle;
    }

    void variableScope(const Tokenizer *tokenizer, const Token *Location, const std::string &varname)
    {
        _writemsg(tokenizer, Location, "never", "The scope of the variable " + varname + " can be limited", "variableScope");
    }
    static bool variableScope()
    {
        return false;
    }

    void conditionAlwaysTrueFalse(const Tokenizer *tokenizer, const Token *Location, const std::string &truefalse)
    {
        _writemsg(tokenizer, Location, "style", "Condition is always " + truefalse + "", "conditionAlwaysTrueFalse");
    }
    static bool conditionAlwaysTrueFalse(const Settings &s)
    {
        return s._checkCodingStyle;
    }

    void strPlusChar(const Tokenizer *tokenizer, const Token *Location)
    {
        _writemsg(tokenizer, Location, "error", "Unusual pointer arithmetic", "strPlusChar");
    }
    static bool strPlusChar()
    {
        return true;
    }

    void returnLocalVariable(const Tokenizer *tokenizer, const Token *Location)
    {
        _writemsg(tokenizer, Location, "error", "Returning pointer to local array variable", "returnLocalVariable");
    }
    static bool returnLocalVariable()
    {
        return true;
    }

    void dangerousFunctionmktemp(const Tokenizer *tokenizer, const Token *Location)
    {
        _writemsg(tokenizer, Location, "style", "Found 'mktemp'. You should use 'mkstemp' instead", "dangerousFunctionmktemp");
    }
    static bool dangerousFunctionmktemp(const Settings &s)
    {
        return s._checkCodingStyle;
    }

    void dangerousFunctiongets(const Tokenizer *tokenizer, const Token *Location)
    {
        _writemsg(tokenizer, Location, "style", "Found 'gets'. You should use 'fgets' instead", "dangerousFunctiongets");
    }
    static bool dangerousFunctiongets(const Settings &s)
    {
        return s._checkCodingStyle;
    }

    void dangerousFunctionscanf(const Tokenizer *tokenizer, const Token *Location)
    {
        _writemsg(tokenizer, Location, "style", "Found 'scanf'. You should use 'fgets' instead", "dangerousFunctionscanf");
    }
    static bool dangerousFunctionscanf(const Settings &s)
    {
        return s._checkCodingStyle;
    }

    void iteratorUsage(const Tokenizer *tokenizer, const Token *Location, const std::string &container1, const std::string &container2)
    {
        _writemsg(tokenizer, Location, "error", "Same iterator is used with both " + container1 + " and " + container2 + "", "iteratorUsage");
    }
    static bool iteratorUsage()
    {
        return true;
    }

    void erase(const Tokenizer *tokenizer, const Token *Location)
    {
        _writemsg(tokenizer, Location, "error", "Dangerous usage of erase", "erase");
    }
    static bool erase()
    {
        return true;
    }

    void pushback(const Tokenizer *tokenizer, const Token *Location, const std::string &iterator_name)
    {
        _writemsg(tokenizer, Location, "error", "After push_back or push_front, the iterator '" + iterator_name + "' may be invalid", "pushback");
    }
    static bool pushback()
    {
        return true;
    }

    void unvalidatedInput(const Tokenizer *tokenizer, const Token *Location)
    {
        _writemsg(tokenizer, Location, "security", "Unvalidated input", "unvalidatedInput");
    }
    static bool unvalidatedInput(const Settings &s)
    {
        return s._security;
    }


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

private:
    void _writemsg(const Tokenizer *tokenizer, const Token *tok, const char severity[], const std::string &msg, const std::string &id);
    void _writemsg(const Tokenizer *tokenizer, const std::list<const Token *> &callstack, const char severity[], const std::string &msg, const std::string &id);
    void _writemsg(const std::string &msg, const std::string &id);
};
#endif