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

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

Фиксация зависит от первопричины дефекта. Часто детали результата показывают последовательность событий, которые привели к дефекту. Можно реализовать закрепление на любом событии в последовательности. Если детали результата не показывают историю события, можно проследить использование, щелкните правой кнопкой по опциям по исходному коду и смотрите предыдущие связанные события. См. также Интерпретируют Результаты Bug Finder в Пользовательском интерфейсе Рабочего стола 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);
    }
}

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

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

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

Смотрите примеры мер ниже.

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

int f(char c) {
	return c;
}

int g(int i) {
	return i;
}

typedef int (*fptr_t)(char);
typedef int (*gptr_t)(int);

void call() {
	gptr_t ptr = (gptr_t) f;//Noncompliant
	int i = ptr(511); // Undefined behavior
}

В этом примере, указателе на функциональный f брошен к gptr_t, который является типом функционального g. Когда указатель функции используется, чтобы вызвать f при помощи целых чисел поведение кода не определено. Polyspace^® отмечает ненадежный бросок указателя функции.

Чтобы избежать неопределенного поведения, осуществите рефакторинг свой код так, чтобы функциональный f не брошен в различный тип аргумента. Например:

 int f(int c) { //Fix: declare f with int argument
	return c;
}

int g(int i) {
	return i;
}

typedef int (*fptr_t)(char);
typedef int (*gptr_t)(int);

void call() {
	gptr_t ptr = (gptr_t) f;//Compliant
	int i = ptr(511); 
}

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

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

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

Смотрите примеры мер ниже.

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

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

enum {
    SIZE10 = 10,
    SIZE20 = 20
};

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

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

Перед рабочим анализом кода задайте компилятор GNU. Смотрите Compiler (-compiler).

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

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

enum {
    SIZE10 = 10,
    SIZE20 = 20
};

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

Несоответствие объявления функции происходит когда прототип extern "C" функция не совпадает со своим определением. Несоответствие типов между аргументами функционального определения и прототипа функции может зависеть от вашей среды. Polyspace рассматривает два типа как совместимые, если у них есть тот же размер и со знаком в среде, которую вы используете. Например, если ваш задавать -target как i386, Polyspace рассматривает long и int как совместимые типы.

На C++, если функция не задана как extern "C" и его прототип не совпадает ни с каким функциональным определением, компилятор обрабатывает прототип как ту из неопределенной перегрузки функции. Polyspace не отмечает вызовы таких неопределенных функций.

Средство проверки не отмечает эту проблему в Polyspace по умолчанию как Вы Анализ кода. Смотрите Средства проверки, Деактивированные в Polyspace, когда Вы Кодируете Анализ По умолчанию.

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

// file1.c
extern "C" void foo(int iVar){
	//...
}
extern "C" void bar(int iVar){
	//...
}
extern "C" void fubar(int A, ...){
	//...
}

//prototype.h
extern "C" void foo(void);
extern "C" void fubar(int A, ...);
extern "C" void bar(long iVar);

//file2.c
//file2.c
#include"prototype.h"
void call_funcs(){
	int iTemp;
	float fTemp;
	long lTemp;
	foo(); //Noncompliant
	bar(lTemp);//Noncompliant in x86_64
	fubar(iTemp,fTemp);//Compliant
	
}

В этом примере, функции fooпанель, и fubar заданы в файле file1.c. Их прототипы объявляются в prototype.h. Эти функции затем вызваны в файле file2.c.

Фиксация для этого дефекта должна объявить полные и точные прототипы для вызванных функций. В этом случае устраните поднятые вопросы путем решения несоответствий между функциональным определением и объявлением прототипа. Обновите вызовы функции совпадать с обновленными прототипами.

// file1.c
extern "C" void foo(int iVar){
	//...
}
extern "C" void bar(int iVar){
	//...
}
extern "C" void fubar(int A, ...){
	//...
}

//prototype.h
extern "C" void foo(int);
extern "C" void fubar(int A, ...);
extern "C" void bar(int iVar);

//file2.c
//file2.c
#include"prototype.h"
void call_funcs(){
	int iTemp;
	float fTemp;
	long lTemp;
	foo(iTemp); //Compliant
	bar(iTemp);//Compliant in x86_64
	fubar(iTemp,fTemp);//Compliant
	
}

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

extern long foo(int);

long bar(long i) {
    return foo(i); //Noncompliant: calls foo(int) with a long              
}

На C++, эта дефектная причина силы ошибка компиляции.

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

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

extern long foo1(int);
extern long foo2(long);
void bar(){
	int varI;
	long varL;
	foo1(varL);//Noncompliant
	foo2(varI);//Compliant
}

В этом примере, внешнем функциональном foo1 вызван long аргумент, в то время как прототип задает параметр как int. В x86 архитектура, размер long больше, чем размер int. Вызов foo1(varL) может привести к неопределенному поведению. Polyspace отмечает вызов. Вызов foo2(varI) использует int аргумент, в то время как параметр задан как long. Этот тип несоответствия совместим с этим правилом потому что размер int не больше, чем размер long.

Чтобы запустить этот пример в Polyspace, используйте эти опции:

Смотрите Target processor type (-target).

Чтобы устранить эту проблему, бросьте аргумент foo1 явным образом так, чтобы тип аргумента и параметр вводят соответствия.

extern long foo1(int);
extern long foo2(long);
void bar(){
	int varI;
	long varL;
	foo1((int)varL);//Compliant
	foo2(varI);//Compliant
}