Плохой режим доступа к файлам или состояние происходит, когда вы используете функции в fopen или open группа с недопустимыми или несовместимыми режимами доступа к файлам, флагами создания файлов или флагами состояния файлов в качестве аргументов. Для образца, для open функция, примеры действительных:

Дефект может возникнуть в следующих ситуациях.

Исправление зависит от первопричины дефекта. Часто детали результата показывают последовательность событий, которые привели к дефекту. Вы можете реализовать исправление на любом событии в последовательности. Если сведения о результате не отображают историю событий, можно отследить их с помощью опций правого щелчка в исходном коде и просмотреть предыдущие связанные события. Смотрите также Результаты интерпретации Bug Finder в интерфейсе пользователя Polyspace Desktop.

См. примеры исправлений ниже.

Если вы не хотите устранять проблему, добавьте комментарии к своему результату или коду, чтобы избежать другой проверки. Смотрите Адрес Результаты Polyspace через исправления ошибок или обоснования.

#include <stdio.h>

void func(void) {
    FILE *file = fopen("data.txt", "rw");
    if(file!=NULL) {
        fputs("new data",file);
        fclose(file);
    }
}

В этом примере режим доступа rw недопустимо. Потому что r указывает, что вы открываете файл для чтения и w указывает, что вы создаете новый файл для записи, два режима доступа несовместимы.

Одной из возможных коррекций является использование режима доступа, соответствующего тому, что вы намереваетесь сделать.

#include <stdio.h>

void func(void) {
    FILE *file = fopen("data.txt", "w");
    if(file!=NULL) {
        fputs("new data",file);
        fclose(file);
    }
}

Ненадежное приведение указателя на функцию происходит, когда указатель на функцию приведен к другому указателю на функцию, который имеет другой аргумент или возвращаемый тип.

Этот дефект применяется только в том случае, если языком кода для проекта является C.

Если вы приведете указатель на функцию к другому указателю на функцию с другим аргументом или возвращаемым типом, а затем используете последний указатель на функцию для вызова функции, поведение не определено.

Избегайте приведения между двумя указателями на функцию с несовпадением аргументов или возвращаемых типов.

См. примеры исправлений ниже.

Если вы не хотите устранять проблему, добавьте комментарии к своему результату или коду, чтобы избежать другой проверки. Смотрите Адрес Результаты Polyspace через исправления ошибок или обоснования.

#include <stdio.h>
#include <math.h>
#include <stdio.h>
#define PI 3.142
 
double Calculate_Sum(int (*fptr)(double))
{
    double  sum = 0.0;
    double  y;
	  
    for (int i = 0;  i <= 100;  i++)
    {
        y = (*fptr)(i*PI/100);
        sum += y;
    }
    return sum / 100;
}
 
int main(void)
{
    double  (*fp)(double);      
    double  sum;
 
    fp = sin;
    sum = Calculate_Sum(fp); 
    /* Defect: fp implicitly cast to int(*) (double) */

    printf("sum(sin): %f\n", sum);
    return 0;
}

Указатель на функцию fp объявлен как double (*)(double). Однако, проходя его, чтобы функционировать Calculate_Sum, fp неявно приведено к int (*)(double).

Одной из возможных коррекций является проверка того, что указатель на функцию в определении Calculate_Sum имеет тот же аргумент и тип возврата, что и fp. Этот шаг гарантирует, что fp неявно приведен к другому аргументу или возвращаемому типу.

#include <stdio.h>
#include <math.h>
#include <stdio.h>
# define PI 3.142
 
/*Fix: fptr has same argument and return type everywhere*/
double Calculate_Sum(double (*fptr)(double)) 
{
    double  sum = 0.0;
    double y;
	    
    for (int i = 0;  i <= 100;  i++)
    {
        y = (*fptr)(i*PI/100);
        sum += y;
    }
    return sum / 100;
}
 
int main(void)
{
    double  (*fp)(double);      
    double  sum;
 
    
    fp = sin;
    sum = Calculate_Sum(fp);
    printf("sum(sin): %f\n", sum);
 
    return 0;
}

Стандартный вызов функции с неправильными аргументами происходит, когда аргументы к определенным стандартным функциям не соответствуют требованиям к их использованию в функциях.

Например, аргументы в эти функции могут быть недопустимыми следующими способами.

Исправление зависит от первопричины дефекта. Часто детали результата показывают последовательность событий, которые привели к дефекту. Вы можете реализовать исправление на любом событии в последовательности. Если сведения о результате не отображают историю событий, можно отследить их с помощью опций правого щелчка в исходном коде и просмотреть предыдущие связанные события. Смотрите также Результаты интерпретации Bug Finder в интерфейсе пользователя Polyspace Desktop.

См. примеры исправлений ниже.

Если вы не хотите устранять проблему, добавьте комментарии к своему результату или коду, чтобы избежать другой проверки. Смотрите Адрес Результаты Polyspace через исправления ошибок или обоснования.

#include <string.h>
#include <stdlib.h>

enum {
    SIZE10 = 10,
    SIZE20 = 20
};

int func() {
    char* s = NULL;
    return strnlen(s, SIZE20);
}

В этом примере a NULL указатель передается следующим strnlen аргумент вместо NULL-terminated string.

Перед выполнением анализа кода укажите компилятор GNU. См. Compiler (-compiler).

Передайте NULL-терминатная строка как первый аргумент strnlen.

#include <string.h>
#include <stdlib.h>

enum {
    SIZE10 = 10,
    SIZE20 = 20
};

int func() {
    char* s = "";
    return strnlen(s, SIZE20);
}

Неподдерживаемые комплексные аргументы возникают, когда эти функции вызываются со complex аргумент:

Вызов любой из предыдущих функций с complex аргумент является неопределенным поведением в стандарте C++, что может привести к неожиданным результатам. Потому что некоторые математические функции поддерживают complex аргументы в то время как функции в предыдущем списке нет, неожиданные результаты могут оказаться трудными для отладки. Выполнение некоторых из этих математических операций на complex возможно, номер не является математически звуком, что указывает на проблему в основной логике вашего кода.

Избегайте вызова предыдущих функций с помощью complex входной параметр. Чтобы выполнить предыдущие математические операции над комплексным числом, задайте альтернативные функции, которые поддерживают complex аргументы.

#include <complex.h>
#include <tgmath.h>
typedef double complex cDouble;
cDouble Noncompliant (void)
{
    cDouble Z = 2.0 + 4.0 * I;
    cDouble result = log2 (Z); //Noncompliant
    return trunc(result);//Noncompliant
}

В этом примере функция Noncompliant вычисляет базовый два логарифма комплексного числа, обрезает результат и возвращает его. Функции log2 и trunc не поддерживает сложный аргумент. Polyspace^® помечает эти операции.

Одним из возможных коррекций является определение альтернативных функций, которые поддержка комплексные числа. Для образца, в то время log2 не поддерживает complex числа, функции log делает. Задайте complexLog2 функции который использует log для вычисления основы два логарифма комплексного числа. Точно так же trunc не поддерживает complex числа и математическое правило для усечения комплексного числа не четко задано. Задайте complexTrunc функции что обрезает комплексное число путем усечения его вещественных и мнимых частей отдельно.

#include <complex.h>
#include <tgmath.h>
typedef double complex cDouble;

cDouble complexLog2(cDouble z) {
    return log (z) / log (2);  // Compliant
}

cDouble complexTrunc(cDouble z){
	return trunc(creal(z)) + I*trunc(cimag(z));  //Compliant
}
 
cDouble Compliant (void)
{
    cDouble Z = 2.0 + 4.0 * I;
    cDouble result = complexLog2 (Z); //Compliant
    return complexTrunc(result);//Compliant
}

Несоответствие объявления функции происходит, когда прототип функции не соответствует ее определению. Если в функции отсутствует прототип в файле, где он вызывается, Polyspace выводит его прототип на основе подписи вызова. Если выведенный прототип не соответствует определению функции, Polyspace поднимает этот дефект. Прототип вариадной функции не может быть выведен из ее вызова функции. Если вы вызываете вариадную функцию, не задавая ее прототип в том же файле, Polyspace поднимает этот дефект.

При выведении прототипа функции из вызова такой функции Polyspace делает следующие предположения:

Чекер не помечает эту проблему в Polyspace по умолчанию во время анализа You Code. Смотрите Checkers Deactivated in Polyspace как You Code Default Analysis (Polyspace Bug Finder Access).

Согласно стандарту C, несоответствие объявления функции может привести к неопределенному поведению, хотя такой код может успешно компилироваться, выдавая только предупреждения во время компиляции. Поскольку код с этой проблемой может успешно скомпилироваться, несоответствия объявления функции могут привести к неожиданным результатам, которые трудно диагностировать.

Когда предоставляются полные прототипы вызываемых функций, компилятор пытается разрешить любые несоответствия объявления функции через неявное приведение. Если компилятору не удается устранить несоответствие, компиляция прекращает работать, что препятствует непредвиденному поведению. Чтобы исправить такие ошибки компиляции, вызывайте функции с помощью типов аргументов и чисел, которые совпадают с определением функции.

// file1.c
void foo(int iVar){
	//...
}
void bar(float fVar1, float fVar2){
	//...
}
void bar2(float fVar1){
	//...
}
void fubar(const char* str,...){
	//...
}
void foo2(char cVar){
	//...
}
void call_variadic(){
	fubar("String");
}

//file2.c
void bar2(float);
void foo2(int);
void call_funcs(){
	int iTemp;
	float fTemp;
	foo();//Noncompliant
	bar(fTemp,fTemp);//Noncompliant
	fubar("String"); //Noncompliant	
	bar2(iTemp);//Compliant
	foo2(iTemp); //Noncompliant
}

В этом примере функции foo, foo2, bar, bar2, и fubar определяются в файле file1.c. Затем эти функции вызываются в файле file2.c.

Исправление этого дефекта состоит в том, чтобы объявить полные прототипы для вызываемых функций во всех модулях компиляции. Это - лучшая практика объединить объявления прототипа функции в заголовочном файле, а затем включить его в файлы, где вызываются функции. В этом случае решите отмеченные проблемы, включив такой заголовочный файл prototype.h в file2.c. После объявления правильного прототипа вызов foo() в file2.c приводит к отказу компиляции, поскольку компилятору не удается устранить несоответствие между вызовом и объявленным прототипом. Функции foo с int для устранения отказа компиляции.

// file1.c
void foo(int iVar){
	//...
}
void bar(float fVar1, float fVar2){
	//...
}
void bar2(float fVar1){
	//...
}
void fubar(const char* str,...){
	//...
}
void foo2(char cVar){
	//...
}
void call_variadic(){
	fubar("String");
}

//prototypes.h
void foo(int iVar);
void bar(float fVar1, float fVar2);
void fubar(const char* str,...);
void bar2(float);
void foo2(char);
void call_variadic(void);
void call_funcs(void);

//file2.c
#include"prototype.h"
void call_funcs(){
	int iTemp;
	float fTemp;
	//foo(); This call results in compile failure
	foo(iTemp);//Compliant
	bar(fTemp,fTemp);//Compliant
	fubar("String"); //Compliant	
	bar2(iTemp);//Compliant
	foo2('a'); //Compliant
}