Method checkForUnreleasedInputArgument

lib/checkmemoryleak.cpp:1004–1079

--------------------------------------------------------------------------- Checks if an input argument to a function is the return value of an allocation function like malloc(), and the function does not release it. ---------------------------------------------------------------------------

// like malloc(), and the function does not release it.
//---------------------------------------------------------------------------
void CheckMemoryLeakNoVarImpl::checkForUnreleasedInputArgument(const Scope *scope)
{
    // parse the executable scope until tok is reached...
    for (const Token *tok = scope->bodyStart; tok != scope->bodyEnd; tok = tok->next()) {
        // allocating memory in parameter for function call..
        if (tok->varId() || !Token::Match(tok, "%name% ("))
            continue;

        // check if the output of the function is assigned
        const Token* tok2 = tok->next()->astParent();
        while (tok2 && (tok2->isCast() || Token::Match(tok2, "?|:")))
            tok2 = tok2->astParent();
        const bool hasAssign = Token::Match(tok2, "%assign%");
        const bool hasReturn = Token::simpleMatch(tok->astTop(), "return");

        const std::string& functionName = tok->str();
        if ((tok->isCpp() && functionName == "delete") ||
            functionName == "return")
            continue;

        if (Token::simpleMatch(tok->next()->astParent(), "(")) // passed to another function
            continue;
        if (!tok->isKeyword() && !tok->function() && !mSettings.library.isLeakIgnore(functionName))
            continue;

        if ((hasAssign || hasReturn) && !tok->function()) {
            const std::string& ret = mSettings.library.returnValueType(tok);
            if (ret.empty() || endsWith(ret, "*"))
                continue;
        }

        const std::vector<const Token *> args = getArguments(tok);
        int argnr = -1;
        for (const Token* arg : args) {
            ++argnr;
            if (arg->isOp() && !(tok->isKeyword() && arg->str() == "*")) // e.g. switch (*new int)
                continue;
            while (arg->astOperand1()) {
                if (arg->isCpp() && Token::simpleMatch(arg, "new"))
                    break;
                arg = arg->astOperand1();
            }
            const AllocType alloc = getAllocationType(arg, 0);
            if (alloc == No)
                continue;
            if (alloc == New || alloc == NewArray) {
                const Token* typeTok = arg->next();
                bool bail = !typeTok->isStandardType() &&
                            (!typeTok->valueType() ||
                             (typeTok->valueType()->type < ValueType::Type::SMART_POINTER &&
                              typeTok->valueType()->type != ValueType::Type::POD)) &&
                            !mSettings.library.detectContainerOrIterator(typeTok) &&
                            !mSettings.library.podtype(typeTok->expressionString());
                if (bail && typeTok->type() && typeTok->type()->classScope &&
                    typeTok->type()->classScope->numConstructors == 0 &&
                    typeTok->type()->classScope->getDestructor() == nullptr) {
                    bail = false;
                }