// Test library configuration for std.cfg

//

// Usage:

// $ cppcheck --check-library --library=std --enable=style,information --inconclusive --error-exitcode=1 --inline-suppr test/cfg/std.c

// =>

// No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0

//

// cppcheck-suppress-file [valueFlowBailout,purgedConfiguration]

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <tgmath.h> // frexp

#include <wchar.h>

#if defined(__STD_UTF_16__) || defined(__STD_UTF_32__)

#include <uchar.h>

#endif

#include <ctype.h>

#include <wctype.h>

#include <fenv.h>

#include <setjmp.h>

#define __STDC_WANT_LIB_EXT1__ 1

#include <time.h>

#include <stdbool.h>

#ifndef __STDC_NO_THREADS__

#include <threads.h>

#endif

#include <inttypes.h>

#include <float.h>

#include <stdarg.h>

#include <assert.h>

#include <alloca.h>

#include <locale.h>

#include <signal.h>

#include <complex.h>

#include <math.h>

#include <stddef.h>

void test_int32_min() {

// cppcheck-suppress shiftNegativeLHS

// cppcheck-suppress shiftTooManyBits ; tests that INT32_MIN is a 32-bit expression (not 64-bit expression)

(void)(INT32_MIN >> 40);

}

void test_int64_min() {

// cppcheck-suppress compareValueOutOfTypeRangeError ; tests that INT64_MIN is a signed expression

if (INT64_MIN < 0) {}

}

size_t invalidFunctionArgStr_wcslen(void)

{

const wchar_t terminated0[] = L"ABCDEF49620910";

const wchar_t terminated1[3] = { L'a', L'b', L'\0' };

const wchar_t notTerminated[3] = { L'a', L'b', L'c' };

// cppcheck-suppress invalidFunctionArgStr

(void) wcslen(notTerminated);

(void) wcslen(terminated0);

return wcslen(terminated1);

}

int invalidFunctionArgStr_strcpn(void)

{

const char str1[] = "ABCDEF49620910";

const char str2[] = "42";

const char pattern[3] = { -42, -43, -44 };

// cppcheck-suppress invalidFunctionArgStr

(void) strcspn(str1, pattern);

return strcspn(str1, str2);

}

void invalidFunctionArgStr_strncat(void)

{

char str1[20];

strcpy (str1,"test");

const char src = '/';

// No warning is expected for

strncat (str1, &src, 1);

puts (str1);

}

char * invalidFunctionArgStr_strpbrk( const char *p )

{

const char search[] = { -42, -43, -44 };

const char pattern[3] = { -42, -43, -44 };

(void) strpbrk( "abc42", "42" );

// cppcheck-suppress invalidFunctionArgStr

(void) strpbrk( search, "42" );

// cppcheck-suppress invalidFunctionArgStr

(void) strpbrk( search, pattern );

// cppcheck-suppress invalidFunctionArgStr

return strpbrk( p, pattern );

}

int invalidFunctionArgStr_strncmp( const char *p )

{

const char string[] = "foo";

char other[5] = { 0 };

memcpy(other, "foo", 4);

if (strncmp(other, string, 5) != 0) {}

// No warning is expected for:

const char emdash[3] = { -42, -43, -44 };

return strncmp( p, emdash, 3 );

}

float invalidFunctionArg_float_remquo (float x, float y, int* quo )

{

// cppcheck-suppress invalidFunctionArg

(void) remquo(x,0.0f,quo);

// cppcheck-suppress invalidFunctionArg

(void) remquof(x,0.0f,quo);

return remquo(x,y,quo);

}

double invalidFunctionArg_double_remquo (double x, double y, int* quo )

{

// cppcheck-suppress invalidFunctionArg

(void) remquo(x,0.0,quo);

// cppcheck-suppress invalidFunctionArg

(void) remquo(x,0.0f,quo);

// cppcheck-suppress invalidFunctionArg

(void) remquo(x,0.0L,quo);

return remquo(x,y,quo);

}

double invalidFunctionArg_long_double_remquo (long double x, long double y, int* quo )

{

// cppcheck-suppress invalidFunctionArg

(void) remquo(x,0.0L,quo);

// cppcheck-suppress invalidFunctionArg

(void) remquol(x,0.0L,quo);

return remquo(x,y,quo);

}

void invalidFunctionArg_remainderl(long double f1, long double f2)

{

// cppcheck-suppress invalidFunctionArg

(void)remainderl(f1,0.0);

// cppcheck-suppress invalidFunctionArg

(void)remainderl(f1,0.0L);

(void)remainderl(f1,f2);

}

void invalidFunctionArg_remainder(double f1, double f2)

{

// cppcheck-suppress invalidFunctionArg

(void)remainder(f1,0.0);

(void)remainder(f1,f2);

}

void invalidFunctionArg_remainderf(float f1, float f2)

{

// cppcheck-suppress invalidFunctionArg

(void)remainderf(f1,0.0);

// cppcheck-suppress invalidFunctionArg

(void)remainderf(f1,0.0f);

(void)remainderf(f1,f2);

}

int qsort_cmpfunc (const void * a, const void * b) {

return (*(int*)a - *(int*)b);

}

void nullPointer_qsort(void *base, size_t n, size_t size, int (*cmp)(const void *, const void *))

{

// cppcheck-suppress nullPointer

qsort(NULL, n, size, qsort_cmpfunc);

// cppcheck-suppress nullPointer

qsort(base, n, size, NULL);

qsort(base, n, size, qsort_cmpfunc);

}

// As with all bounds-checked functions, localtime_s is only guaranteed to be available if __STDC_LIB_EXT1__ is defined by the implementation and if the user defines __STDC_WANT_LIB_EXT1__ to the integer constant 1 before including time.h.

#ifdef __STDC_LIB_EXT1__

void uninitvar_localtime_s(const time_t *restrict time, struct tm *restrict result)

{

const time_t *restrict Time;

// cppcheck-suppress uninitvar

(void)localtime_s(Time, result);

(void)localtime_s(time, result);

}

void nullPointer_localtime_s(const time_t *restrict time, struct tm *restrict result)

{

// cppcheck-suppress nullPointer

(void)localtime_s(NULL, result);

// cppcheck-suppress nullPointer

(void)localtime_s(time, NULL);

(void)localtime_s(time, result);

}

#endif // __STDC_LIB_EXT1__

size_t bufferAccessOutOfBounds_wcsrtombs(char * dest, const wchar_t ** src, size_t len, mbstate_t * ps)

{

char buf[42];

(void)wcsrtombs(buf,src,42,ps);

// cppcheck-suppress bufferAccessOutOfBounds

(void)wcsrtombs(buf,src,43,ps);

return wcsrtombs(dest,src,len,ps);

}

void bufferAccessOutOfBounds(void)

{

char a[5];

// cppcheck-suppress valueFlowBailoutIncompleteVar

fgets(a,5,stdin);

// cppcheck-suppress bufferAccessOutOfBounds

fgets(a,6,stdin);

sprintf(a, "ab%s", "cd");

// cppcheck-suppress bufferAccessOutOfBounds

// TODO cppcheck-suppress redundantCopy

sprintf(a, "ab%s", "cde");

// TODO cppcheck-suppress redundantCopy

snprintf(a, 5, "abcde%i", 1);

// TODO cppcheck-suppress redundantCopy

// cppcheck-suppress bufferAccessOutOfBounds

snprintf(a, 6, "abcde%i", 1);

// TODO cppcheck-suppress redundantCopy

strcpy(a,"abcd");

// cppcheck-suppress bufferAccessOutOfBounds

// TODO cppcheck-suppress redundantCopy

strcpy(a, "abcde");

#ifdef __STDC_LIB_EXT1__

// cppcheck-suppress bufferAccessOutOfBounds

strcpy_s(a, 10, "abcdefghij");

#endif

// TODO cppcheck-suppress redundantCopy

// cppcheck-suppress terminateStrncpy

strncpy(a,"abcde",5);

// cppcheck-suppress bufferAccessOutOfBounds

// TODO cppcheck-suppress redundantCopy

strncpy(a,"abcde",6);

// cppcheck-suppress bufferAccessOutOfBounds

// TODO cppcheck-suppress redundantCopy

strncpy(a,"a",6);

// TODO cppcheck-suppress redundantCopy

strncpy(a,"abcdefgh",4);

#ifdef __STDC_LIB_EXT1__

// valid call

strncpy_s(a,5,"abcd",5);

// string will be truncated, error is returned, but no buffer overflow

strncpy_s(a,5,"abcde",6);

// TODO cppcheck-suppress bufferAccessOutOfBounds

strncpy_s(a,5,"a",6);

strncpy_s(a,5,"abcdefgh",4);

// valid call

strncat_s(a,5,"1",2);

// cppcheck-suppress bufferAccessOutOfBounds

strncat_s(a,10,"1",2);

// TODO cppcheck-suppress bufferAccessOutOfBounds

strncat_s(a,5,"1",5);

#endif

fread(a,1,5,stdin);

// cppcheck-suppress bufferAccessOutOfBounds

fread(a,1,6,stdin);

fwrite(a,1,5,stdout);

// cppcheck-suppress bufferAccessOutOfBounds

fread(a,1,6,stdout);

char * pAlloc1 = aligned_alloc(8, 16);

// cppcheck-suppress nullPointerOutOfMemory

memset(pAlloc1, 0, 16);

// cppcheck-suppress bufferAccessOutOfBounds

// cppcheck-suppress nullPointerOutOfMemory

memset(pAlloc1, 0, 17);

free(pAlloc1);

}

wchar_t* nullPointer_fgetws(wchar_t* buffer, int n, FILE* stream)

{

// cppcheck-suppress nullPointer

(void)fgetws(NULL,n,stream);

// cppcheck-suppress nullPointer

(void)fgetws(buffer,n,NULL);

// No warning is expected

return fgetws(buffer, n, stream);

}

char* nullPointer_fgets(char *buffer, int n, FILE *stream)

{

// cppcheck-suppress nullPointer

(void)fgets(NULL,n,stream);

// cppcheck-suppress nullPointer

(void)fgets(buffer,n,NULL);

// No warning is expected

return fgets(buffer, n, stream);

}

void memleak_aligned_alloc(void)

{

// cppcheck-suppress [unusedAllocatedMemory, unreadVariable, constVariablePointer]

char * alignedBuf = aligned_alloc(8, 16);

// cppcheck-suppress memleak

}

void pointerLessThanZero_aligned_alloc(void)

{

char * alignedBuf = aligned_alloc(8, 16);

// cppcheck-suppress pointerLessThanZero

if (alignedBuf < 0) return;

free(alignedBuf);

// no warning is expected for

alignedBuf = aligned_alloc(8, 16);

if (alignedBuf == 0) return;

free(alignedBuf);

// no warning is expected for

alignedBuf = aligned_alloc(8, 16);

if (alignedBuf) free(alignedBuf);

}

void unusedRetVal_aligned_alloc(void)

{

// cppcheck-suppress leakReturnValNotUsed

aligned_alloc(8, 16);

}

void uninitvar_aligned_alloc(size_t alignment, size_t size)

{

size_t uninitVar1, uninitVar2, uninitVar3;

// cppcheck-suppress uninitvar

free(aligned_alloc(uninitVar1, size));

// cppcheck-suppress uninitvar

free(aligned_alloc(alignment, uninitVar2));

// cppcheck-suppress uninitvar

free(aligned_alloc(uninitVar3, uninitVar3));

// no warning is expected

free(aligned_alloc(alignment, size));

}

void bufferAccessOutOfBounds_libraryDirectionConfiguration(void)

{

// This tests whether the argument to isdigit() is configured with direction "in". This allows

// Cppcheck to report the error without marking it as inconclusive.

char arr[10];

char c = 'A';

(void)isdigit(c);

// cppcheck-suppress arrayIndexOutOfBounds

// cppcheck-suppress unreadVariable

arr[c] = 'x';

}

void internalError_libraryDirectionConfiguration(char* str) { // #12824

const char* s = str;

char* end = str;

if (1) {

// cppcheck-suppress unreadVariable

unsigned long val = strtoul(&s[1], &end, 10);

}

}

void arrayIndexOutOfBounds()

{

char * pAlloc1 = aligned_alloc(8, 16);

// cppcheck-suppress nullPointerOutOfMemory

pAlloc1[15] = '\0';

// cppcheck-suppress arrayIndexOutOfBounds

// cppcheck-suppress nullPointerOutOfMemory

pAlloc1[16] = '1';

free(pAlloc1);

char * pAlloc2 = malloc(9);

// cppcheck-suppress nullPointerOutOfMemory

pAlloc2[8] = 'a';

// cppcheck-suppress arrayIndexOutOfBounds

// cppcheck-suppress nullPointerOutOfMemory

pAlloc2[9] = 'a';

// #1379

// cppcheck-suppress memleakOnRealloc

pAlloc2 = realloc(pAlloc2, 8);

pAlloc2[7] = 'b';

// cppcheck-suppress arrayIndexOutOfBounds

pAlloc2[8] = 0;

// cppcheck-suppress memleakOnRealloc

pAlloc2 = realloc(pAlloc2, 20);

pAlloc2[19] = 'b';

// cppcheck-suppress arrayIndexOutOfBounds

pAlloc2[20] = 0;

free(pAlloc2);

char * pAlloc3 = calloc(2,3);

// cppcheck-suppress nullPointerOutOfMemory

pAlloc3[5] = 'a';

// cppcheck-suppress arrayIndexOutOfBounds

// cppcheck-suppress nullPointerOutOfMemory

pAlloc3[6] = 1;

free(pAlloc3);

}

void resourceLeak_tmpfile(void)

{

// cppcheck-suppress [unreadVariable, constVariablePointer]

FILE * fp = tmpfile();

// cppcheck-suppress resourceLeak

}

// memory leak

void ignoreleak(void)

{

char *p = (char *)malloc(10);

memset(&(p[0]), 0, 10);

// cppcheck-suppress memleak

}

// null pointer

void nullpointer(int value)

{

int res = 0;

FILE *fp;

wchar_t *pWcsUninit;

#ifndef __CYGWIN__

// cppcheck-suppress nullPointer

clearerr(0);

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress nullPointer

feof(0);

#endif

// cppcheck-suppress nullPointer

(void)fgetc(0);

// cppcheck-suppress nullPointer

fclose(0);

#ifndef __CYGWIN__

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress nullPointer

ferror(0);

#endif

// cppcheck-suppress nullPointer

(void)ftell(0);

// cppcheck-suppress nullPointer

puts(0);

// cppcheck-suppress nullPointer

fp=fopen(0,0);

// cppcheck-suppress nullPointerOutOfResources

fclose(fp);

fp = 0;

// No FP

fflush(0); // If stream is a null pointer, all streams are flushed.

// cppcheck-suppress valueFlowBailoutIncompleteVar

fp = freopen(0,"abc",stdin);

fclose(fp);

fp = NULL;

// cppcheck-suppress nullPointer

fputc(0,0);

// cppcheck-suppress nullPointer

fputs(0,0);

// cppcheck-suppress nullPointer

fgetpos(0,0);

// cppcheck-suppress nullPointer

frexp(1.0,0);

// cppcheck-suppress nullPointer

fsetpos(0,0);

#ifdef _WIN32 // not available on non-Windows compilers

// cppcheck-suppress nullPointer

itoa(123,0,10);

#endif

putchar(0);

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress nullPointer

strchr(0,0);

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress nullPointer

wcschr(0,0);

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress nullPointer

strlen(0);

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress nullPointer

wcslen(0);

// cppcheck-suppress nullPointer

strcpy(0,0);

// cppcheck-suppress nullPointer

wcscpy(0,0);

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress nullPointer

strspn(0,0);

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress nullPointer

wcsspn(0,0);

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress nullPointer

strcspn(0,0);

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress nullPointer

wcscspn(0,0);

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress nullPointer

strcoll(0,0);

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress nullPointer

wcscoll(0,0);

// cppcheck-suppress nullPointer

strcat(0,0);

// cppcheck-suppress nullPointer

wcscat(0,0);

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress nullPointer

strcmp(0,0);

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress nullPointer

wcscmp(0,0);

#ifdef __STDC_LIB_EXT1__

// cppcheck-suppress nullPointer

strcpy_s(0,1,1);

// cppcheck-suppress nullPointer

strcpy_s(1,1,0);

#endif

// cppcheck-suppress nullPointer

strncpy(0,0,1);

#ifdef __STDC_LIB_EXT1__

// cppcheck-suppress nullPointer

strncpy_s(0,1,1,1);

// cppcheck-suppress nullPointer

strncpy_s(1,1,0,1);

#endif

// cppcheck-suppress nullPointer

wcsncpy(0,0,1);

// cppcheck-suppress nullPointer

strncat(0,0,1);

#ifdef __STDC_LIB_EXT1__

// cppcheck-suppress nullPointer

strncat_s(0,1,1,1);

// cppcheck-suppress nullPointer

strncat_s(1,1,0,1);

#endif

// cppcheck-suppress nullPointer

wcsncat(0,0,1);

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress nullPointer

strncmp(0,0,1);

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress nullPointer

wcsncmp(0,0,1);

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress nullPointer

strstr(0,0);

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress nullPointer

wcsstr(0,0);

// cppcheck-suppress nullPointer

strtoul(0,0,0);

// cppcheck-suppress nullPointer

wcstoul(0,0,0);

// cppcheck-suppress nullPointer

strtoull(0,0,0);

// cppcheck-suppress nullPointer

wcstoull(0,0,0);

// cppcheck-suppress nullPointer

strtol(0,0,0);

// cppcheck-suppress nullPointer

wcstol(0,0,0);

// #6100 False positive nullPointer - calling mbstowcs(NULL,)

res += mbstowcs(0,"",0);

res += wcstombs(0,L"",0);

strtok(NULL,"xyz");

wcstok(NULL,L"xyz",&pWcsUninit);

strxfrm(0,"foo",0);

// TODO: error message (#6306 and http://trac.cppcheck.net/changeset/d11eb4931aea51cf2cb74faccdcd2a3289b818d6/)

strxfrm(0,"foo",42);

wcsxfrm(0,L"foo",0);

// TODO: error message when arg1==NULL and arg3!=0 #6306: https://trac.cppcheck.net/ticket/6306#comment:2

wcsxfrm(0,L"foo",42);

snprintf(NULL, 0, "someformatstring"); // legal

// cppcheck-suppress nullPointer

snprintf(NULL, 42, "someformatstring"); // not legal

scanf("%i", &res);

// cppcheck-suppress nullPointer

scanf("%i", NULL);

wscanf(L"%i", &res);

// cppcheck-suppress nullPointer

wscanf(L"%i", NULL);

}

void nullPointer_wcsftime(wchar_t* ptr, size_t maxsize, const wchar_t* format, const struct tm* timeptr)

{

// cppcheck-suppress nullPointer

(void)wcsftime(NULL, maxsize, format, timeptr);

// cppcheck-suppress nullPointer

(void)wcsftime(ptr, maxsize, NULL, timeptr);

// cppcheck-suppress nullPointer

(void)wcsftime(ptr, maxsize, format, NULL);

(void)wcsftime(ptr, maxsize, format, timeptr);

}

void bufferAccessOutOfBounds_wcsftime(wchar_t* ptr, size_t maxsize, const wchar_t* format, const struct tm* timeptr)

{

wchar_t buf[42];

(void)wcsftime(buf, 42, format, timeptr);

// TODO cppcheck-suppress bufferAccessOutOfBounds

(void)wcsftime(buf, 43, format, timeptr);

(void)wcsftime(ptr, maxsize, format, timeptr);

}

void bufferAccessOutOfBounds_wcsncpy()

{

wchar_t s[16];

wcsncpy(s, L"abc", 16);

// cppcheck-suppress bufferAccessOutOfBounds

wcsncpy(s, L"abc", 17);

}

int nullPointer_wcsncmp(const wchar_t* s1, const wchar_t* s2, size_t n)

{

// cppcheck-suppress nullPointer

(void) wcsncmp(NULL,s2,n);

// cppcheck-suppress nullPointer

(void) wcsncmp(s1,NULL,n);

return wcsncmp(s1,s2,n);

}

wchar_t* nullPointer_wcsncpy(wchar_t *s, const wchar_t *cs, size_t n)

{

// cppcheck-suppress nullPointer

(void) wcsncpy(NULL,cs,n);

// cppcheck-suppress nullPointer

(void) wcsncpy(s,NULL,n);

return wcsncpy(s,cs,n);

}

size_t nullPointer_strlen(const char *s)

{

// cppcheck-suppress nullPointer

(void) strlen(NULL);

return strlen(s);

}

void nullpointerMemchr1(char *p, const char *s)

{

p = memchr(s, 'p', strlen(s));

(void)p;

}

void nullpointerMemchr2(char *p, const char *s)

{

p = memchr(s, 0, strlen(s));

(void)p;

}

void nullPointer_memchr(char *p)

{

const char *s = 0;

// cppcheck-suppress nullPointer

p = memchr(s, 0, strlen(s));

(void)p;

}

void nullPointer_vsnprintf(const char * format, ...)

{

va_list args;

// valid

char buffer[256];

va_start(args, format);

vsnprintf(buffer, 256, format, args);

printf("%s", buffer);

va_end(args);

// valid

va_start(args, format);

vsnprintf(NULL, 0, format, args);

va_end(args);

// invalid

va_start(args, format);

// TODO #9410 cppcheck-suppress nullPointer

vsnprintf(NULL, 10, format, args);

va_end(args);

}

// uninit pointers

void uninitvar_abs(void)

{

int i;

// cppcheck-suppress uninitvar

(void)abs(i);

}

void uninitvar_clearerr(void)

{

FILE *fp;

// cppcheck-suppress uninitvar

clearerr(fp);

}

void uninitvar_fclose(void)

{

// cppcheck-suppress unassignedVariable

FILE *fp;

// cppcheck-suppress uninitvar

fclose(fp);

}

void uninitvar_fopen(void)

{

const char *filename, *mode;

FILE *fp;

// cppcheck-suppress uninitvar

fp = fopen(filename, "rt");

// cppcheck-suppress nullPointerOutOfResources

fclose(fp);

// cppcheck-suppress uninitvar

fp = fopen("filename.txt", mode);

// cppcheck-suppress nullPointerOutOfResources

fclose(fp);

}

void uninitvar_feof(void)

{

FILE *fp1, *fp2;

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress uninitvar

feof(fp1);

// cppcheck-suppress uninitvar

(void)feof(fp2);

}

void uninitvar_ferror(void)

{

FILE *fp1, *fp2;

// cppcheck-suppress ignoredReturnValue

// cppcheck-suppress uninitvar

ferror(fp1);

// cppcheck-suppress uninitvar

(void)ferror(fp2);

}

void uninitvar_fflush(void)

{

FILE *fp;

// cppcheck-suppress uninitvar

fflush(fp);

}

void uninitvar_fgetc(void)

{

FILE *fp;

// cppcheck-suppress uninitvar

(void)fgetc(fp);

}

void uninitvar_fgetpos(void)

{

FILE *fp;

fpos_t pos;

fpos_t *ppos;

// cppcheck-suppress uninitvar

fgetpos(fp,&pos);

fp = fopen("filename","rt");

// cppcheck-suppress uninitvar

// cppcheck-suppress nullPointerOutOfResources

fgetpos(fp,ppos);

// cppcheck-suppress nullPointerOutOfResources

fclose(fp);

}

void uninitvar_fsetpos(void)

{

FILE *fp;

fpos_t pos;

const fpos_t *ppos;

// cppcheck-suppress uninitvar

fsetpos(fp,&pos);

fp = fopen("filename","rt");

// cppcheck-suppress uninitvar

// cppcheck-suppress nullPointerOutOfResources

fsetpos(fp,ppos);

// cppcheck-suppress nullPointerOutOfResources

fclose(fp);

}

void uninitvar_fgets(void)

{

FILE *fp;

char buf[10];

char *str;

int n;

// cppcheck-suppress valueFlowBailoutIncompleteVar

fgets(buf,10,stdin);

// cppcheck-suppress uninitvar

fgets(str,10,stdin);

// cppcheck-suppress uninitvar

fgets(buf,10,fp);

// cppcheck-suppress uninitvar

fgets(buf,n,stdin);

}

void uninitvar_fputc(void)

{

int i;

FILE *fp;

// cppcheck-suppress valueFlowBailoutIncompleteVar

fputc('a', stdout);

// cppcheck-suppress uninitvar

fputc(i, stdout);

// cppcheck-suppress uninitvar

fputc('a', fp);

}

void uninitvar_fputs(void)

{

const char *s;

FILE *fp;

// cppcheck-suppress valueFlowBailoutIncompleteVar

fputs("a", stdout);

// cppcheck-suppress uninitvar

fputs(s, stdout);

// cppcheck-suppress uninitvar

fputs("a", fp);

}

void uninitvar_ftell(void)

{

FILE *fp;

// cppcheck-suppress uninitvar

(void)ftell(fp);

}

void uninitvar_puts(void)

{

const char *s;

// cppcheck-suppress uninitvar

puts(s);

}

void uninitvar_putchar(void)

{

char c;

// cppcheck-suppress uninitvar

putchar(c);

}

void uninitvar_cproj(void) // #6939

{

float complex fc;

// cppcheck-suppress uninitvar

(void)cprojf(fc);

double complex dc;

// cppcheck-suppress uninitvar

(void)cproj(dc);

long double complex ldc;

// cppcheck-suppress uninitvar

(void)cprojl(ldc);

}

void uninitvar_creal(void)

{

float complex fc;

// cppcheck-suppress uninitvar

(void)crealf(fc);

double complex dc;

// cppcheck-suppress uninitvar

(void)creal(dc);

long double complex ldc;

// cppcheck-suppress uninitvar

(void)creall(ldc);

}

void uninitvar_acos(void)

{

float f;

// cppcheck-suppress uninitvar

(void)acosf(f);

double d;

// cppcheck-suppress uninitvar

(void)acos(d);

long double ld;

// cppcheck-suppress uninitvar

(void)acosl(ld);

}

void uninitvar_acosh(void)

{

float f;

// cppcheck-suppress uninitvar

(void)acoshf(f);

double d;

// cppcheck-suppress uninitvar

(void)acosh(d);

long double ld;

// cppcheck-suppress uninitvar

(void)acoshl(ld);

}

void invalidFunctionArg_acosh(void)

{

float f = .999f;

// cppcheck-suppress invalidFunctionArg

(void)acoshf(f);

f = 1.0f;

(void)acoshf(f);

double d = .999;

// cppcheck-suppress invalidFunctionArg

(void)acosh(d);

d = 1.0;

(void)acosh(d);

long double ld = .999L;

// cppcheck-suppress invalidFunctionArg

(void)acoshl(ld);

ld = 1.0;

(void)acoshl(ld);

}

void invalidFunctionArg_atanh(void)

{

float f = 1.00001f;

// cppcheck-suppress invalidFunctionArg

(void)atanhf(f);

f = 1.0f;

(void)atanhf(f);

f = -1.0f;

(void)atanhf(f);

f = -1.00001f;

// cppcheck-suppress invalidFunctionArg

(void)atanhf(f);

double d = 1.00001;

// cppcheck-suppress invalidFunctionArg

(void)atanh(d);

d = 1.0;

(void)atanh(d);

d = -1.0;

(void)atanh(d);

d = -1.00001;

// cppcheck-suppress invalidFunctionArg

(void)atanh(d);

long double ld = 1.00001L;

// cppcheck-suppress invalidFunctionArg

(void)atanhl(ld);

ld = 1.0L;

(void)atanhl(ld);

ld = -1.0L;

(void)atanhl(ld);

ld = -1.00001L;

// cppcheck-suppress invalidFunctionArg

(void)atanhl(ld);

}

void uninitvar_asctime(void)

{

const struct tm *tm;

// cppcheck-suppress uninitvar

// cppcheck-suppress asctimeCalled

(void)asctime(tm);

}

#ifdef __STDC_LIB_EXT1__

void uninitvar_asctime_s(void)

{

const struct tm *tm;

char buf[26];

// cppcheck-suppress uninitvar

// cppcheck-suppress asctime_sCalled

asctime_s(buf, sizeof(buf), tm);

}

#endif

void uninitvar_assert(void)

{

int i;

// cppcheck-suppress checkLibraryNoReturn

// cppcheck-suppress uninitvar

assert(i);

}

void uninitvar_sqrt(void)

{

float f;