walkero
/
cppcheck
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity

std.cfg: Added return-type for some functions.

This commit is contained in:
orbitcowboy 2017-07-28 16:47:17 +02:00
parent f3cef7f9eb
commit ad14d43aaf
1 changed files with 83 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
cfg/std.cfg
View File

@ -1693,6 +1693,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int iswcntrl(wint_t c, wctype_t desc); --> <!-- int iswcntrl(wint_t c, wctype_t desc); -->
<function name="iswctype,std::iswctype"> <function name="iswctype,std::iswctype">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -1890,6 +1891,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- wint_t towctrans(wint_t c, wctrans_t desc); --> <!-- wint_t towctrans(wint_t c, wctrans_t desc); -->
<function name="towctrans,std::towctrans"> <function name="towctrans,std::towctrans">
<use-retval/> <use-retval/>
<returnValue type="wint_t"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -1903,6 +1905,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- wint_t towlower(wint_t c); --> <!-- wint_t towlower(wint_t c); -->
<function name="towlower,std::towlower"> <function name="towlower,std::towlower">
<use-retval/> <use-retval/>
<returnValue type="wint_t"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -1913,6 +1916,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- wint_t towupper(wint_t c); --> <!-- wint_t towupper(wint_t c); -->
<function name="towupper,std::towupper"> <function name="towupper,std::towupper">
<use-retval/> <use-retval/>
<returnValue type="wint_t"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -1923,6 +1927,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- wctrans_t wctrans(const char* property); --> <!-- wctrans_t wctrans(const char* property); -->
<function name="wctrans,std::wctrans"> <function name="wctrans,std::wctrans">
<use-retval/> <use-retval/>
<returnValue type="wctype_t"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -1934,6 +1939,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- wctype_t wctype(const char* property); --> <!-- wctype_t wctype(const char* property); -->
<function name="wctype,std::wctype"> <function name="wctype,std::wctype">
<use-retval/> <use-retval/>
<returnValue type="wctype_t"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -2080,6 +2086,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int rand(void); --> <!-- int rand(void); -->
<function name="rand"> <function name="rand">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
</function> </function>
@ -2162,6 +2169,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int fpclassify(double x); --> <!-- int fpclassify(double x); -->
<function name="fpclassify,std::fpclassify"> <function name="fpclassify,std::fpclassify">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -2172,6 +2180,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int isfinite(double x); --> <!-- int isfinite(double x); -->
<function name="isfinite,std::isfinite"> <function name="isfinite,std::isfinite">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -2182,6 +2191,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int isgreater(double x, double y); --> <!-- int isgreater(double x, double y); -->
<function name="isgreater,std::isgreater"> <function name="isgreater,std::isgreater">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -2195,6 +2205,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int isgreaterequal(double x, double y); --> <!-- int isgreaterequal(double x, double y); -->
<function name="isgreaterequal,std::isgreaterequal"> <function name="isgreaterequal,std::isgreaterequal">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -2208,6 +2219,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int isinf(double x); --> <!-- int isinf(double x); -->
<function name="isinf,std::isinf"> <function name="isinf,std::isinf">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -2230,6 +2242,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int isless(double x, double y); --> <!-- int isless(double x, double y); -->
<function name="isless,std::isless"> <function name="isless,std::isless">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -2243,6 +2256,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int islessequal(double x, double y); --> <!-- int islessequal(double x, double y); -->
<function name="islessequal,std::islessequal"> <function name="islessequal,std::islessequal">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -2256,6 +2270,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int islessgreater(double x, double y); --> <!-- int islessgreater(double x, double y); -->
<function name="islessgreater,std::islessgreater"> <function name="islessgreater,std::islessgreater">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -2282,6 +2297,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int isnan(double x); --> <!-- int isnan(double x); -->
<function name="isnan,std::isnan"> <function name="isnan,std::isnan">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -2292,6 +2308,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int isnormal(double x); --> <!-- int isnormal(double x); -->
<function name="isnormal,std::isnormal"> <function name="isnormal,std::isnormal">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -2302,6 +2319,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int isunordered(double x, double y);--> <!-- int isunordered(double x, double y);-->
<function name="isunordered,std::isunordered"> <function name="isunordered,std::isunordered">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -2317,6 +2335,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int ilogbl(long double x); --> <!-- int ilogbl(long double x); -->
<function name="ilogb,std::ilogb,ilogbf,ilogbl"> <function name="ilogb,std::ilogb,ilogbf,ilogbl">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -2431,7 +2450,8 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<valid>0:</valid> <valid>0:</valid>
</arg> </arg>
</function> </function>
<!-- int memchr(const void *cs, int c, size_t n);--> <!-- const void * memchr ( const void * ptr, int value, size_t num );
void * memchr ( void * ptr, int value, size_t num );-->
<function name="memchr,std::memchr"> <function name="memchr,std::memchr">
<use-retval/> <use-retval/>
<pure/> <pure/>
@ -2478,6 +2498,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int memcmp(const void *s1, const void *s2, size_t n);--> <!-- int memcmp(const void *s1, const void *s2, size_t n);-->
<function name="memcmp,std::memcmp"> <function name="memcmp,std::memcmp">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -2500,6 +2521,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int wmemcmp (const wchar_t* ptr1, const wchar_t* ptr2, size_t num);--> <!-- int wmemcmp (const wchar_t* ptr1, const wchar_t* ptr2, size_t num);-->
<function name="wmemcmp,std::wmemcmp"> <function name="wmemcmp,std::wmemcmp">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -2543,6 +2565,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- errno_t wmemcpy_s( wchar_t *restrict dest, rsize_t destsz, const wchar_t *restrict src, rsize_t count );--> <!-- errno_t wmemcpy_s( wchar_t *restrict dest, rsize_t destsz, const wchar_t *restrict src, rsize_t count );-->
<function name="memcpy_s,wmemcpy_s"> <function name="memcpy_s,wmemcpy_s">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="errno_t"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-null/> <not-null/>
@ -2585,6 +2608,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- errno_t memset_s( void *dest, rsize_t destsz, int ch, rsize_t count ) --> <!-- errno_t memset_s( void *dest, rsize_t destsz, int ch, rsize_t count ) -->
<function name="memset_s"> <function name="memset_s">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="errno_t"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-null/> <not-null/>
@ -2640,6 +2664,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- time_t mkxtime(struct tmx *tp); --> <!-- time_t mkxtime(struct tmx *tp); -->
<function name="mktime,std::mktime,mkxtime"> <function name="mktime,std::mktime,mkxtime">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="time_t"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-null/> <not-null/>
@ -2733,6 +2758,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int printf(const char *format, ...); --> <!-- int printf(const char *format, ...); -->
<function name="printf,std::printf"> <function name="printf,std::printf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<formatstr/> <formatstr/>
<arg nr="1"> <arg nr="1">
@ -2743,6 +2769,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int vprintf(const char *format, va_list arg); --> <!-- int vprintf(const char *format, va_list arg); -->
<function name="vprintf,std::vprintf"> <function name="vprintf,std::vprintf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-uninit/> <not-uninit/>
@ -2752,6 +2779,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int vwprintf(const wchar_t *format, va_list arg); --> <!-- int vwprintf(const wchar_t *format, va_list arg); -->
<function name="vwprintf,std::vwprintf"> <function name="vwprintf,std::vwprintf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-uninit/> <not-uninit/>
@ -2809,6 +2837,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int putc(int c, FILE *stream); --> <!-- int putc(int c, FILE *stream); -->
<function name="putc,std::putc"> <function name="putc,std::putc">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-uninit/> <not-uninit/>
@ -2823,6 +2852,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- wint_t putwc(wchar_t wc, FILE* stream); --> <!-- wint_t putwc(wchar_t wc, FILE* stream); -->
<function name="putwc,std::putwc"> <function name="putwc,std::putwc">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="wint_t"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-uninit/> <not-uninit/>
@ -2835,6 +2865,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int puthchar(int c); --> <!-- int puthchar(int c); -->
<function name="putchar,std::putchar"> <function name="putchar,std::putchar">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-uninit/> <not-uninit/>
@ -2845,6 +2876,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- wint_t putwchar(wchar_t wc); --> <!-- wint_t putwchar(wchar_t wc); -->
<function name="putwchar,std::putwchar"> <function name="putwchar,std::putwchar">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="wint_t"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-uninit/> <not-uninit/>
@ -2853,6 +2885,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int puts(const char *string); --> <!-- int puts(const char *string); -->
<function name="puts,std::puts"> <function name="puts,std::puts">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-null/> <not-null/>
@ -2875,6 +2908,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int remove(const char *filename); --> <!-- int remove(const char *filename); -->
<function name="remove,std::remove"> <function name="remove,std::remove">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-null/> <not-null/>
@ -2885,6 +2919,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int rename(const char *oldname, const char *newname); --> <!-- int rename(const char *oldname, const char *newname); -->
<function name="rename,std::rename"> <function name="rename,std::rename">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-null/> <not-null/>
@ -2926,6 +2961,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- long long int scalblnl(long double x, long int n); --> <!-- long long int scalblnl(long double x, long int n); -->
<function name="scalbn,std::scalbn,scalbnf,std::scalbnf,scalbnl,std::scalbnl,scalbln,std::scalbln,scalblnf,std::scalblnf,scalblnl,std::scalblnl"> <function name="scalbn,std::scalbn,scalbnf,std::scalbnf,scalbnl,std::scalbnl,scalbln,std::scalbln,scalblnf,std::scalblnf,scalblnl,std::scalblnl">
<use-retval/> <use-retval/>
<returnValue type="long long int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -2939,6 +2975,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int signbit(double x); --> <!-- int signbit(double x); -->
<function name="signbit,std::signbit"> <function name="signbit,std::signbit">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -2957,6 +2994,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int raise(int sig); --> <!-- int raise(int sig); -->
<function name="raise,std::raise"> <function name="raise,std::raise">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<arg nr="1"> <arg nr="1">
<not-uninit/> <not-uninit/>
</arg> </arg>
@ -2964,6 +3002,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int scanf(const char *format, ...); --> <!-- int scanf(const char *format, ...); -->
<function name="scanf,std::scanf"> <function name="scanf,std::scanf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<formatstr scan="true"/> <formatstr scan="true"/>
<arg nr="1"> <arg nr="1">
@ -2975,6 +3014,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int vsscanf(const char *s, const char *format, va_list arg); --> <!-- int vsscanf(const char *s, const char *format, va_list arg); -->
<function name="vsscanf,std::vsscanf"> <function name="vsscanf,std::vsscanf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-null/> <not-null/>
@ -2989,6 +3029,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int vswscanf(const wchar_t *s, const wchar_t *format, va_list arg); --> <!-- int vswscanf(const wchar_t *s, const wchar_t *format, va_list arg); -->
<function name="vswscanf,std::vswscanf"> <function name="vswscanf,std::vswscanf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-null/> <not-null/>
@ -3003,6 +3044,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int vscanf(const char *format, va_list arg); --> <!-- int vscanf(const char *format, va_list arg); -->
<function name="vscanf,std::vscanf"> <function name="vscanf,std::vscanf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-null/> <not-null/>
@ -3013,6 +3055,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int vscanf(const wchar_t *format, va_list arg); --> <!-- int vscanf(const wchar_t *format, va_list arg); -->
<function name="vwscanf,std::vwscanf"> <function name="vwscanf,std::vwscanf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-null/> <not-null/>
@ -3022,6 +3065,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- void setbuf(FILE *stream, char *buf); --> <!-- void setbuf(FILE *stream, char *buf); -->
<function name="setbuf,std::setbuf"> <function name="setbuf,std::setbuf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-null/> <not-null/>
@ -3034,6 +3078,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int setvbuf(FILE* stream, char *buf, int mode, size_t size); --> <!-- int setvbuf(FILE* stream, char *buf, int mode, size_t size); -->
<function name="setvbuf,std::setvbuf"> <function name="setvbuf,std::setvbuf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-null/> <not-null/>
@ -3052,6 +3097,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
</function> </function>
<!-- int setjmp(jmp_buf env); --> <!-- int setjmp(jmp_buf env); -->
<function name="setjmp"> <function name="setjmp">
<returnValue type="int"/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
<arg nr="1"/> <arg nr="1"/>
@ -3073,6 +3119,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
</function> </function>
<!-- wchar_t wcscat(wchar_t *deststr, const char *srcstr); --> <!-- wchar_t wcscat(wchar_t *deststr, const char *srcstr); -->
<function name="wcscat,std::wcscat"> <function name="wcscat,std::wcscat">
<returnValue type="wchar_t"/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
@ -3086,6 +3133,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- size_t wcrtomb(char *s, wchar_t wc, mbstate_t *ps); --> <!-- size_t wcrtomb(char *s, wchar_t wc, mbstate_t *ps); -->
<function name="wcrtomb,std::wcrtomb"> <function name="wcrtomb,std::wcrtomb">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="size_t"/>
<leak-ignore/> <leak-ignore/>
<arg nr="2"> <arg nr="2">
<not-uninit/> <not-uninit/>
@ -3108,6 +3156,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
</function> </function>
<!-- wchar_t wcschr(const wchar_t *cs, wchar_t c); --> <!-- wchar_t wcschr(const wchar_t *cs, wchar_t c); -->
<function name="wcschr,std::wcschr"> <function name="wcschr,std::wcschr">
<returnValue type="wchar_t"/>
<use-retval/> <use-retval/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -3122,6 +3171,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int strcmp(const char *str1, const char *str2); --> <!-- int strcmp(const char *str1, const char *str2); -->
<function name="strcmp,std::strcmp"> <function name="strcmp,std::strcmp">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -3138,6 +3188,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
</function> </function>
<!-- int wcscmp(const wchar_t *str1, const wchar_t c); --> <!-- int wcscmp(const wchar_t *str1, const wchar_t c); -->
<function name="wcscmp,std::wcscmp"> <function name="wcscmp,std::wcscmp">
<returnValue type="int"/>
<use-retval/> <use-retval/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
@ -3167,6 +3218,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
</function> </function>
<!-- wchar_t *wcscpy(wchar_t *deststr, const wchar_t *srcstr); --> <!-- wchar_t *wcscpy(wchar_t *deststr, const wchar_t *srcstr); -->
<function name="wcscpy,std::wcscpy"> <function name="wcscpy,std::wcscpy">
<returnValue type="wchar_t"/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
@ -3181,6 +3233,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- size_t strfxtime(char *s, size_t max, const char *fmt, const struct tmx *p); --> <!-- size_t strfxtime(char *s, size_t max, const char *fmt, const struct tmx *p); -->
<function name="strftime,std::strftime,strfxtime"> <function name="strftime,std::strftime,strfxtime">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="size_t"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-null/> <not-null/>
@ -3202,6 +3255,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- size_t wcslen(const wchar_t *string); --> <!-- size_t wcslen(const wchar_t *string); -->
<function name="strlen,std::strlen,wcslen,std::wcslen"> <function name="strlen,std::strlen,wcslen,std::wcslen">
<use-retval/> <use-retval/>
<returnValue type="size_t"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -3288,6 +3342,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int strncmp(const char *s1, const char *s2, size_t n); --> <!-- int strncmp(const char *s1, const char *s2, size_t n); -->
<function name="strncmp,std::strncmp"> <function name="strncmp,std::strncmp">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -3308,6 +3363,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int wcsncmp(const wchar_t* wcs1, const wchar_t* wcs2, size_t num); --> <!-- int wcsncmp(const wchar_t* wcs1, const wchar_t* wcs2, size_t num); -->
<function name="wcsncmp,std::wcsncmp"> <function name="wcsncmp,std::wcsncmp">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
@ -3359,6 +3415,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- size_t strspn(const char *cs, const char *ct); --> <!-- size_t strspn(const char *cs, const char *ct); -->
<function name="strspn,std::strspn"> <function name="strspn,std::strspn">
<use-retval/> <use-retval/>
<returnValue type="size_t"/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
@ -3375,6 +3432,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- size_t strxfrm(char *ds, const char *ss, size_t n); --> <!-- size_t strxfrm(char *ds, const char *ss, size_t n); -->
<function name="strxfrm,std::strxfrm"> <function name="strxfrm,std::strxfrm">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="size_t"/>
<leak-ignore/> <leak-ignore/>
<arg nr="2"> <arg nr="2">
<not-null/> <not-null/>
@ -3388,6 +3446,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- size_t wcsxfrm(wchar_t *s1, const wchar_t *s2, size_t n); --> <!-- size_t wcsxfrm(wchar_t *s1, const wchar_t *s2, size_t n); -->
<function name="wcsxfrm,std::wcsxfrm"> <function name="wcsxfrm,std::wcsxfrm">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="size_t"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-null/> <not-null/>
@ -3403,6 +3462,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
</function> </function>
<!-- size_t wcsspn(const wchar_t *s1, const wchar_t *s2); --> <!-- size_t wcsspn(const wchar_t *s1, const wchar_t *s2); -->
<function name="wcsspn,std::wcsspn"> <function name="wcsspn,std::wcsspn">
<returnValue type="size_t"/>
<use-retval/> <use-retval/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
@ -3444,6 +3504,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
</function> </function>
<!-- size_t strcspn(const char *cs, const char *ct); --> <!-- size_t strcspn(const char *cs, const char *ct); -->
<function name="strcspn,std::strcspn"> <function name="strcspn,std::strcspn">
<returnValue type="size_t"/>
<use-retval/> <use-retval/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
@ -3459,6 +3520,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
</function> </function>
<!-- size_t wcscspn(const wchar_t *cs, const wchar_t *ct); --> <!-- size_t wcscspn(const wchar_t *cs, const wchar_t *ct); -->
<function name="wcscspn,std::wcscspn"> <function name="wcscspn,std::wcscspn">
<returnValue type="size_t"/>
<use-retval/> <use-retval/>
<pure/> <pure/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
@ -3504,6 +3566,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int strcoll(const char *cs, const char *c); --> <!-- int strcoll(const char *cs, const char *c); -->
<function name="strcoll,std::strcoll"> <function name="strcoll,std::strcoll">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
@ -3518,6 +3581,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int wcscoll(const wchar_t *s1, const wchar_t *s2); --> <!-- int wcscoll(const wchar_t *s1, const wchar_t *s2); -->
<function name="wcscoll,std::wcscoll"> <function name="wcscoll,std::wcscoll">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
@ -3578,6 +3642,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- size_t wcsrtombs(char *dst, const wchar_t **src, size_t len, mbstate_t *ps); --> <!-- size_t wcsrtombs(char *dst, const wchar_t **src, size_t len, mbstate_t *ps); -->
<function name="wcsrtombs,std::wcsrtombs"> <function name="wcsrtombs,std::wcsrtombs">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="size_t"/>
<leak-ignore/> <leak-ignore/>
<arg nr="2"> <arg nr="2">
<not-null/> <not-null/>
@ -3669,6 +3734,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- errno_t tmpnam_s(char *filename_s, rsize_t maxsize); --> <!-- errno_t tmpnam_s(char *filename_s, rsize_t maxsize); -->
<function name="tmpnam_s"> <function name="tmpnam_s">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="errno_t"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-uninit/> <not-uninit/>
@ -3686,6 +3752,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int tolower(int c); --> <!-- int tolower(int c); -->
<function name="tolower,std::tolower"> <function name="tolower,std::tolower">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
@ -3696,6 +3763,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int toupper(int c); --> <!-- int toupper(int c); -->
<function name="toupper,std::toupper"> <function name="toupper,std::toupper">
<use-retval/> <use-retval/>
<returnValue type="int"/>
<noreturn>false</noreturn> <noreturn>false</noreturn>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
@ -3807,6 +3875,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- size_t mbrtowc(wchar_t* pwc, const char* pmb, size_t max, mbstate_t* ps); --> <!-- size_t mbrtowc(wchar_t* pwc, const char* pmb, size_t max, mbstate_t* ps); -->
<function name="mbrtowc,std::mbrtowc"> <function name="mbrtowc,std::mbrtowc">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="size_t"/>
<leak-ignore/> <leak-ignore/>
<arg nr="2"> <arg nr="2">
<not-uninit/> <not-uninit/>
@ -3871,6 +3940,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int wprintf(const wchar_t *format, ...); --> <!-- int wprintf(const wchar_t *format, ...); -->
<function name="wprintf,std::wprintf"> <function name="wprintf,std::wprintf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<formatstr/> <formatstr/>
<arg nr="1"> <arg nr="1">
@ -3881,6 +3951,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int sprintf(char *s, const char *format, ...); --> <!-- int sprintf(char *s, const char *format, ...); -->
<function name="sprintf,std::sprintf"> <function name="sprintf,std::sprintf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-uninit/> <not-uninit/>
@ -3896,6 +3967,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int swprintf(wchar_t *s, size_t n, const wchar_t *format, ...); --> <!-- int swprintf(wchar_t *s, size_t n, const wchar_t *format, ...); -->
<function name="swprintf,std::swprintf"> <function name="swprintf,std::swprintf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<minsize type="argvalue" arg="2"/> <minsize type="argvalue" arg="2"/>
@ -3913,6 +3985,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int vsprintf(char *s, const char *format, va_list arg); --> <!-- int vsprintf(char *s, const char *format, va_list arg); -->
<function name="vsprintf,std::vsprintf"> <function name="vsprintf,std::vsprintf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-null/> <not-null/>
@ -3927,6 +4000,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int vswprintf(wchar_t *s, size_t n, const wchar_t *format, va_list arg); --> <!-- int vswprintf(wchar_t *s, size_t n, const wchar_t *format, va_list arg); -->
<function name="vswprintf,std::vswprintf"> <function name="vswprintf,std::vswprintf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-null/> <not-null/>
@ -3945,6 +4019,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int fwprintf(FILE* stream, const wchar_t* format, ...); --> <!-- int fwprintf(FILE* stream, const wchar_t* format, ...); -->
<function name="fwprintf,std::fwprintf"> <function name="fwprintf,std::fwprintf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-null/> <not-null/>
@ -3959,6 +4034,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int snprintf(char *s, size_t n, const char *format, ...); --> <!-- int snprintf(char *s, size_t n, const char *format, ...); -->
<function name="snprintf,std::snprintf"> <function name="snprintf,std::snprintf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<minsize type="argvalue" arg="2"/> <minsize type="argvalue" arg="2"/>
@ -3977,6 +4053,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int vsnprintf(char *s, size_t n, const char *format, va_list arg); --> <!-- int vsnprintf(char *s, size_t n, const char *format, va_list arg); -->
<function name="vsnprintf,std::vsnprintf"> <function name="vsnprintf,std::vsnprintf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-uninit/> <not-uninit/>
@ -3995,6 +4072,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int wscanf(const wchar_t *format, ...); --> <!-- int wscanf(const wchar_t *format, ...); -->
<function name="wscanf,std::wscanf"> <function name="wscanf,std::wscanf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<formatstr scan="true"/> <formatstr scan="true"/>
<arg nr="1"> <arg nr="1">
@ -4006,6 +4084,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int sscanf(const char *string, const char * format, ...); --> <!-- int sscanf(const char *string, const char * format, ...); -->
<function name="sscanf,std::sscanf"> <function name="sscanf,std::sscanf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-uninit/> <not-uninit/>
@ -4020,6 +4099,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int fwscanf(FILE* stream, const wchar_t* format, ...); --> <!-- int fwscanf(FILE* stream, const wchar_t* format, ...); -->
<function name="fwscanf,std::fwscanf"> <function name="fwscanf,std::fwscanf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-uninit/> <not-uninit/>
@ -4033,6 +4113,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int swscanf(const wchar_t *string, const wchar_t *format, ...); --> <!-- int swscanf(const wchar_t *string, const wchar_t *format, ...); -->
<function name="swscanf,std::swscanf"> <function name="swscanf,std::swscanf">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-uninit/> <not-uninit/>
@ -4046,6 +4127,7 @@ The obsolete function 'gets' is called. With 'gets' you'll get a buffer overrun
<!-- int system(const char *command); --> <!-- int system(const char *command); -->
<function name="system,std::system"> <function name="system,std::system">
<noreturn>false</noreturn> <noreturn>false</noreturn>
<returnValue type="int"/>
<leak-ignore/> <leak-ignore/>
<arg nr="1"> <arg nr="1">
<not-uninit/> <not-uninit/>