Method invalidFunctionUsage

lib/checkfunctions.cpp:108–198

--------------------------------------------------------------------------- Check , and ---------------------------------------------------------------------------

// Check <valid>, <strz> and <not-bool>
//---------------------------------------------------------------------------
void CheckFunctionsImpl::invalidFunctionUsage()
{
    logChecker("CheckFunctions::invalidFunctionUsage");
    const SymbolDatabase* symbolDatabase = mTokenizer->getSymbolDatabase();
    for (const Scope *scope : symbolDatabase->functionScopes) {
        for (const Token* tok = scope->bodyStart->next(); tok != scope->bodyEnd; tok = tok->next()) {
            tok = skipUnreachableBranch(tok);
            if (!Token::Match(tok, "%name% ( !!)"))
                continue;
            const Token * const functionToken = tok;
            const std::vector<const Token *> arguments = getArguments(tok);
            for (int argnr = 1; argnr <= arguments.size(); ++argnr) {
                const Token * const argtok = arguments[argnr-1];

                // check <valid>...</valid>
                const ValueFlow::Value *invalidValue = argtok->getInvalidValue(functionToken,argnr,mSettings);
                if (invalidValue) {
                    invalidFunctionArgError(argtok, functionToken->next()->astOperand1()->expressionString(), argnr, invalidValue, mSettings.library.validarg(functionToken, argnr));
                }

                if (astIsBool(argtok)) {
                    // check <not-bool>
                    if (mSettings.library.isboolargbad(functionToken, argnr))
                        invalidFunctionArgBoolError(argtok, functionToken->str(), argnr);

                    // Are the values 0 and 1 valid?
                    else if (!mSettings.library.isIntArgValid(functionToken, argnr, 0, mSettings))
                        invalidFunctionArgError(argtok, functionToken->str(), argnr, nullptr, mSettings.library.validarg(functionToken, argnr));
                    else if (!mSettings.library.isIntArgValid(functionToken, argnr, 1, mSettings))
                        invalidFunctionArgError(argtok, functionToken->str(), argnr, nullptr, mSettings.library.validarg(functionToken, argnr));
                }
                // check <strz>
                if (mSettings.library.isargstrz(functionToken, argnr)) {
                    if (Token::Match(argtok, "& %var% !![") && argtok->next() && argtok->next()->valueType()) {
                        const ValueType * valueType = argtok->next()->valueType();
                        const Variable * variable = argtok->next()->variable();
                        if ((valueType->type == ValueType::Type::CHAR || valueType->type == ValueType::Type::WCHAR_T || (valueType->type == ValueType::Type::RECORD && Token::Match(argtok, "& %var% . %var% ,|)"))) &&
                            !variable->isArray() &&
                            (variable->isConst() || !variable->isGlobal()) &&
                            (!argtok->next()->hasKnownValue() || argtok->next()->getValue(0) == nullptr)) {
                            invalidFunctionArgStrError(argtok, functionToken->str(), argnr);
                        }
                    }
                    const ValueType* const valueType = argtok->valueType();
                    const Variable* const variable = argtok->variable();
                    // Is non-null terminated local variable of type char (e.g. char buf[] = {'x'};) ?
                    if (variable && variable->isLocal()
                        && valueType && (valueType->type == ValueType::Type::CHAR || valueType->type == ValueType::Type::WCHAR_T)
                        && !isVariablesChanged(variable->declEndToken(), functionToken, valueType->pointer, { variable }, mSettings)) {
                        const Token* varTok = variable->declEndToken();
                        MathLib::bigint count = -1; // Find out explicitly set count, e.g.: char buf[3] = {...}. Variable 'count' is set to 3 then.
                        if (varTok && Token::simpleMatch(varTok->astOperand1(), "["))
                        {
                            const Token* const countTok = varTok->astOperand1()->astOperand2();
                            if (countTok && countTok->hasKnownIntValue())
                                count = countTok->getKnownIntValue();
                        }
                        if (Token::simpleMatch(varTok, "= {")) {