1
2 // Test library configuration for std.cfg
3 //
4 // Usage:
5 // $ cppcheck --check-library --enable=information --error-exitcode=1 --suppress=missingIncludeSystem --inline-suppr test/cfg/std.cpp
6 // =>
7 // No warnings about bad library configuration, unmatched suppressions, etc. exitcode=0
8 //
9
10 #include <bitset>
11 #include <cassert>
12 #include <cctype>
13 #include <cfenv>
14 #include <cinttypes>
15 #include <clocale>
16 #include <cmath>
17 #include <complex>
18 #include <csetjmp>
19 #include <csignal>
20 #include <cstdarg>
21 #include <cstdio>
22 #include <cstdlib>
23 #include <cstring>
24 #include <ctime>
25 #include <cwchar>
26 #include <fstream>
27 #include <functional>
28 #include <iomanip>
29 #include <iostream>
30 #include <istream>
31 #include <iterator>
32 #include <vector>
33
invalidFunctionArg_log10(double d=0.0)34 double invalidFunctionArg_log10(double d = 0.0) {
35 // cppcheck-suppress invalidFunctionArg
36 return log10(d);
37 }
38
uninitvar_std_next(const std::vector<int> & v,int count)39 void uninitvar_std_next(const std::vector<int> &v, int count)
40 {
41 // No warning shall be shown:
42 if (std::next(v.begin()) != v.end()) {}
43 if (std::next(v.begin(), count) != v.end()) {}
44
45 std::vector<int>::iterator it;
46 // TODO-cppcheck-suppress uninitvar
47 if (std::next(it) != v.end()) {}
48
49 std::vector<int>::const_iterator const_it;
50 // TODO-cppcheck-suppress uninitvar
51 if (std::next(const_it) != v.end()) {}
52
53 std::vector<int>::reverse_iterator rit;
54 // TODO-cppcheck-suppress uninitvar
55 if (std::next(rit) != v.rend()) {}
56
57 std::vector<int>::const_reverse_iterator const_rit;
58 // TODO-cppcheck-suppress uninitvar
59 if (std::next(const_rit) != v.rend()) {}
60 }
61
uninitvar_std_prev(const std::vector<int> & v,int count)62 void uninitvar_std_prev(const std::vector<int> &v, int count)
63 {
64 // No warning shall be shown:
65 if (std::prev(v.begin()) != v.end()) {}
66 if (std::prev(v.begin(), count) != v.end()) {}
67
68 std::vector<int>::iterator it;
69 // TODO-cppcheck-suppress uninitvar
70 if (std::prev(it) != v.end()) {}
71
72 std::vector<int>::const_iterator const_it;
73 // TODO-cppcheck-suppress uninitvar
74 if (std::prev(const_it) != v.end()) {}
75
76 std::vector<int>::reverse_iterator rit;
77 // TODO-cppcheck-suppress uninitvar
78 if (std::prev(rit) != v.rend()) {}
79
80 std::vector<int>::const_reverse_iterator const_rit;
81 // TODO-cppcheck-suppress uninitvar
82 if (std::prev(const_rit) != v.rend()) {}
83 }
84
overlappingWriteFunction_wcscat(wchar_t * src,wchar_t * dest)85 void overlappingWriteFunction_wcscat(wchar_t *src, wchar_t *dest)
86 {
87 // No warning shall be shown:
88 (void)wcscat(dest, src);
89 // cppcheck-suppress overlappingWriteFunction
90 (void)wcscat(src, src);
91 }
92
overlappingWriteFunction_strcat(char * src,char * dest)93 char * overlappingWriteFunction_strcat(char *src, char *dest)
94 {
95 // No warning shall be shown:
96 (void)strcat(dest, src);
97 // cppcheck-suppress overlappingWriteFunction
98 return strcat(src, src);
99 }
100
overlappingWriteFunction_strncat(char * src,char * dest,const std::size_t count)101 char * overlappingWriteFunction_strncat(char *src, char *dest, const std::size_t count)
102 {
103 // No warning shall be shown:
104 (void)strncat(dest, src, 42);
105 (void)strncat(dest, src, count);
106 (void)strncat(dest, dest, count);
107 // cppcheck-suppress overlappingWriteFunction
108 (void)strncat(dest, dest+1, 2);
109 char buffer[] = "strncat";
110 // cppcheck-suppress overlappingWriteFunction
111 return strncat(buffer, buffer + 1, 3);
112 }
113
overlappingWriteFunction_wcsncat(wchar_t * src,wchar_t * dest,const std::size_t count)114 wchar_t * overlappingWriteFunction_wcsncat(wchar_t *src, wchar_t *dest, const std::size_t count)
115 {
116 // No warning shall be shown:
117 (void)wcsncat(dest, src, 42);
118 (void)wcsncat(dest, src, count);
119 (void)wcsncat(dest, dest, count);
120 // cppcheck-suppress overlappingWriteFunction
121 (void)wcsncat(dest, dest+1, 2);
122 wchar_t buffer[] = L"strncat";
123 // cppcheck-suppress overlappingWriteFunction
124 return wcsncat(buffer, buffer + 1, 3);
125 }
126
overlappingWriteFunction_wcscpy(wchar_t * src,wchar_t * dest)127 wchar_t * overlappingWriteFunction_wcscpy(wchar_t *src, wchar_t *dest)
128 {
129 // No warning shall be shown:
130 (void)wcscpy(dest, src);
131 const wchar_t * destBuf = dest;
132 // TODO-cppcheck-suppress overlappingWriteFunction #10355
133 (void)wcscpy(dest, destBuf);
134 // cppcheck-suppress overlappingWriteFunction
135 return wcscpy(src, src);
136 }
137
overlappingWriteFunction_wcsncpy(wchar_t * buf,const std::size_t count)138 wchar_t * overlappingWriteFunction_wcsncpy(wchar_t *buf, const std::size_t count)
139 {
140 // No warning shall be shown:
141 (void)wcsncpy(&buf[0], &buf[3], count); // size is not known
142 (void)wcsncpy(&buf[0], &buf[3], 3U); // no-overlap
143 // cppcheck-suppress overlappingWriteFunction
144 return wcsncpy(&buf[0], &buf[3], 4U);
145 }
146
overlappingWriteFunction_strncpy(char * buf,const std::size_t count)147 char * overlappingWriteFunction_strncpy(char *buf, const std::size_t count)
148 {
149 // No warning shall be shown:
150 (void)strncpy(&buf[0], &buf[3], count); // size is not known
151 (void)strncpy(&buf[0], &buf[3], 3U); // no-overlap
152 // cppcheck-suppress overlappingWriteFunction
153 return strncpy(&buf[0], &buf[3], 4U);
154 }
155
overlappingWriteFunction_memmove(void)156 void * overlappingWriteFunction_memmove(void)
157 {
158 // No warning shall be shown:
159 char str[] = "memmove handles overlapping data well";
160 return memmove(str,str+3,4);
161 }
162
std_bitset_test_ignoredReturnValue()163 std::bitset<10> std_bitset_test_ignoredReturnValue()
164 {
165 std::bitset<10> b1("1111010000");
166 // cppcheck-suppress ignoredReturnValue
167 b1.test(2);
168 return b1;
169 }
170
std_bitset_all_ignoredReturnValue()171 std::bitset<10> std_bitset_all_ignoredReturnValue()
172 {
173 std::bitset<10> b1("1111010000");
174 // cppcheck-suppress ignoredReturnValue
175 b1.all();
176 return b1;
177 }
178
std_bitset_none_ignoredReturnValue()179 std::bitset<10> std_bitset_none_ignoredReturnValue()
180 {
181 std::bitset<10> b1("1111010000");
182 // cppcheck-suppress ignoredReturnValue
183 b1.none();
184 return b1;
185 }
186
std_bitset_any_ignoredReturnValue()187 std::bitset<10> std_bitset_any_ignoredReturnValue()
188 {
189 std::bitset<10> b1("1111010000");
190 // cppcheck-suppress ignoredReturnValue
191 b1.any();
192 return b1;
193 }
194
std_bitset_size_ignoredReturnValue()195 std::bitset<10> std_bitset_size_ignoredReturnValue()
196 {
197 std::bitset<10> b1("1111010000");
198 // cppcheck-suppress ignoredReturnValue
199 b1.size();
200 return b1;
201 }
202
std_bitset_count_ignoredReturnValue()203 std::bitset<10> std_bitset_count_ignoredReturnValue()
204 {
205 std::bitset<10> b1("1111010000");
206 // cppcheck-suppress ignoredReturnValue
207 b1.count();
208 return b1;
209 }
210
valid_code()211 void valid_code()
212 {
213 std::vector<int> vecInt{0, 1, 2};
214 std::fill_n(vecInt.begin(), 2, 0);
215 vecInt.push_back(1);
216 vecInt.pop_back();
217 }
218
returnValue_std_isgreater(void)219 void returnValue_std_isgreater(void)
220 {
221 // cppcheck-suppress knownConditionTrueFalse
222 if (std::isgreater(4,2) == 0) {}
223 // @todo support floats
224 if (std::isgreater(4.0f,2.0f) == 0) {}
225 }
226
returnValue_std_isgreaterequal(void)227 void returnValue_std_isgreaterequal(void)
228 {
229 // cppcheck-suppress knownConditionTrueFalse
230 if (std::isgreaterequal(4,2) == 0) {}
231 // @todo support floats
232 if (std::isgreaterequal(4.0f,2.0f) == 0) {}
233 }
234
returnValue_std_isless(void)235 void returnValue_std_isless(void)
236 {
237 // cppcheck-suppress knownConditionTrueFalse
238 if (std::isless(4,2) == 0) {}
239 // @todo support floats
240 if (std::isless(4.0f,2.0f) == 0) {}
241 }
242
returnValue_std_islessequal(void)243 void returnValue_std_islessequal(void)
244 {
245 // cppcheck-suppress knownConditionTrueFalse
246 if (std::islessequal(4,2) == 0) {}
247 // @todo support floats
248 if (std::islessequal(4.0f,2.0f) == 0) {}
249 }
250
returnValue_std_islessgreater(void)251 void returnValue_std_islessgreater(void)
252 {
253 // cppcheck-suppress knownConditionTrueFalse
254 if (std::islessgreater(4,2) == 0) {}
255 // cppcheck-suppress knownConditionTrueFalse
256 if (std::islessgreater(2,4) == 0) {}
257
258 if (std::islessgreater(4.0f,2.0f) == 0) {} // @todo support floats
259 if (std::islessgreater(2.0f,4.0f) == 0) {} // @todo support floats
260 }
261
bufferAccessOutOfBounds(void)262 void bufferAccessOutOfBounds(void)
263 {
264 char a[5];
265 std::strcpy(a,"abcd");
266 // cppcheck-suppress bufferAccessOutOfBounds
267 // TODO cppcheck-suppress redundantCopy
268 std::strcpy(a, "abcde");
269 // TODO cppcheck-suppress redundantCopy
270 // cppcheck-suppress terminateStrncpy
271 std::strncpy(a,"abcde",5);
272 // cppcheck-suppress bufferAccessOutOfBounds
273 // TODO cppcheck-suppress redundantCopy
274 std::strncpy(a,"abcde",6);
275 }
276
uninitvar_abs(void)277 void uninitvar_abs(void)
278 {
279 int i;
280 // cppcheck-suppress uninitvar
281 (void)std::abs(i);
282 }
283
uninivar_imaxabs(void)284 void uninivar_imaxabs(void)
285 {
286 intmax_t i1, i2;
287 // cppcheck-suppress uninitvar
288 (void)std::imaxabs(i1);
289 // cppcheck-suppress uninitvar
290 (void)imaxabs(i2);
291 }
292
uninitvar_isalnum(void)293 void uninitvar_isalnum(void)
294 {
295 int i;
296 // cppcheck-suppress uninitvar
297 (void)std::isalnum(i);
298 }
299
uninitvar_isalpha(void)300 void uninitvar_isalpha(void)
301 {
302 int i;
303 // cppcheck-suppress uninitvar
304 (void)std::isalpha(i);
305 }
306
uninitvar_iscntrl(void)307 void uninitvar_iscntrl(void)
308 {
309 int i;
310 // cppcheck-suppress uninitvar
311 (void)std::iscntrl(i);
312 }
313
uninitvar_isdigit(void)314 void uninitvar_isdigit(void)
315 {
316 int i;
317 // cppcheck-suppress uninitvar
318 (void)std::isdigit(i);
319 }
320
uninitvar_isgraph(void)321 void uninitvar_isgraph(void)
322 {
323 int i;
324 // cppcheck-suppress uninitvar
325 (void)std::isgraph(i);
326 }
327
uninitvar_islower(void)328 void uninitvar_islower(void)
329 {
330 int i;
331 // cppcheck-suppress uninitvar
332 (void)std::islower(i);
333 }
334
uninitvar_isprint(void)335 void uninitvar_isprint(void)
336 {
337 int i;
338 // cppcheck-suppress uninitvar
339 (void)std::isprint(i);
340 }
341
uninitvar_isspace(void)342 void uninitvar_isspace(void)
343 {
344 int i;
345 // cppcheck-suppress uninitvar
346 (void)std::isspace(i);
347 }
348
uninitvar_isupper(void)349 void uninitvar_isupper(void)
350 {
351 int i;
352 // cppcheck-suppress uninitvar
353 (void)std::isupper(i);
354 }
355
uninitvar_isxdigit(void)356 void uninitvar_isxdigit(void)
357 {
358 int i;
359 // cppcheck-suppress uninitvar
360 (void)std::isxdigit(i);
361 }
362
uninitvar_proj(void)363 void uninitvar_proj(void)
364 {
365 double d;
366 const std::complex<double> dc(d,d);
367 // TODO cppcheck-suppress uninitvar
368 (void)std::proj(dc);
369 }
370
uninitvar_acos(void)371 void uninitvar_acos(void)
372 {
373 float f;
374 // cppcheck-suppress uninitvar
375 (void)std::acos(f);
376
377 double d;
378 // cppcheck-suppress uninitvar
379 (void)std::acos(d);
380
381 long double ld;
382 // cppcheck-suppress uninitvar
383 (void)std::acos(ld);
384 }
385
uninitvar_acosh(void)386 void uninitvar_acosh(void)
387 {
388 float f;
389 // cppcheck-suppress uninitvar
390 (void)std::acoshf(f);
391
392 double d;
393 // cppcheck-suppress uninitvar
394 (void)std::acosh(d);
395
396 long double ld;
397 // cppcheck-suppress uninitvar
398 (void)std::acoshl(ld);
399 }
400
uninitvar_asctime(void)401 void uninitvar_asctime(void)
402 {
403 const struct tm *tm;
404 // cppcheck-suppress uninitvar
405 // cppcheck-suppress asctimeCalled
406 (void)std::asctime(tm);
407 }
408
uninitvar_sqrt(void)409 void uninitvar_sqrt(void)
410 {
411 float f;
412 // cppcheck-suppress uninitvar
413 (void)std::sqrt(f);
414
415 double d;
416 // cppcheck-suppress uninitvar
417 (void)std::sqrt(d);
418
419 long double ld;
420 // cppcheck-suppress uninitvar
421 (void)std::sqrt(ld);
422 }
423
uninitvar_sinh(void)424 void uninitvar_sinh(void)
425 {
426 float f;
427 // cppcheck-suppress uninitvar
428 (void)std::sinh(f);
429
430 double d;
431 // cppcheck-suppress uninitvar
432 (void)std::sinh(d);
433
434 long double ld;
435 // cppcheck-suppress uninitvar
436 (void)std::sinh(ld);
437 }
438
uninitvar_sin(void)439 void uninitvar_sin(void)
440 {
441 float f;
442 // cppcheck-suppress uninitvar
443 (void)std::sin(f);
444
445 double d;
446 // cppcheck-suppress uninitvar
447 (void)std::sin(d);
448
449 long double ld;
450 // cppcheck-suppress uninitvar
451 (void)std::sin(ld);
452 }
453
uninitvar_asin(void)454 void uninitvar_asin(void)
455 {
456 float f;
457 // cppcheck-suppress uninitvar
458 (void)std::asin(f);
459
460 double d;
461 // cppcheck-suppress uninitvar
462 (void)std::asin(d);
463
464 long double ld;
465 // cppcheck-suppress uninitvar
466 (void)std::asin(ld);
467 }
468
uninitvar_asinh(void)469 void uninitvar_asinh(void)
470 {
471 float f;
472 // cppcheck-suppress uninitvar
473 (void)std::asinhf(f);
474
475 double d;
476 // cppcheck-suppress uninitvar
477 (void)std::asinh(d);
478
479 long double ld;
480 // cppcheck-suppress uninitvar
481 (void)std::asinhl(ld);
482 }
483
uninitvar_wcsftime(wchar_t * ptr)484 void uninitvar_wcsftime(wchar_t* ptr)
485 {
486 size_t maxsize;
487 wchar_t* format;
488 struct tm* timeptr;
489 // cppcheck-suppress uninitvar
490 (void)std::wcsftime(ptr, maxsize, format, timeptr);
491 }
492
uninitvar_tan(void)493 void uninitvar_tan(void)
494 {
495 float f;
496 // cppcheck-suppress uninitvar
497 (void)std::tan(f);
498
499 double d;
500 // cppcheck-suppress uninitvar
501 (void)std::tan(d);
502
503 long double ld;
504 // cppcheck-suppress uninitvar
505 (void)std::tan(ld);
506 }
507
uninitvar_tanh(void)508 void uninitvar_tanh(void)
509 {
510 float f;
511 // cppcheck-suppress uninitvar
512 (void)std::tanh(f);
513
514 double d;
515 // cppcheck-suppress uninitvar
516 (void)std::tanh(d);
517
518 long double ld;
519 // cppcheck-suppress uninitvar
520 (void)std::tanh(ld);
521 }
522
uninitvar_atan(void)523 void uninitvar_atan(void)
524 {
525 float f;
526 // cppcheck-suppress uninitvar
527 (void)std::atan(f);
528
529 double d;
530 // cppcheck-suppress uninitvar
531 (void)std::atan(d);
532
533 long double ld;
534 // cppcheck-suppress uninitvar
535 (void)std::atan(ld);
536 }
537
uninitvar_tgamma(void)538 void uninitvar_tgamma(void)
539 {
540 float f;
541 // cppcheck-suppress uninitvar
542 (void)std::tgammaf(f);
543
544 double d;
545 // cppcheck-suppress uninitvar
546 (void)std::tgamma(d);
547
548 long double ld;
549 // cppcheck-suppress uninitvar
550 (void)std::tgammal(ld);
551 }
552
uninitvar_trunc(void)553 void uninitvar_trunc(void)
554 {
555 float f;
556 // cppcheck-suppress uninitvar
557 (void)std::truncf(f);
558
559 double d;
560 // cppcheck-suppress uninitvar
561 (void)std::trunc(d);
562
563 long double ld;
564 // cppcheck-suppress uninitvar
565 (void)std::truncl(ld);
566 }
567
uninitvar_atanh(void)568 void uninitvar_atanh(void)
569 {
570 float f;
571 // cppcheck-suppress uninitvar
572 (void)std::atanhf(f);
573
574 double d;
575 // cppcheck-suppress uninitvar
576 (void)std::atanh(d);
577
578 long double ld;
579 // cppcheck-suppress uninitvar
580 (void)std::atanhl(ld);
581 }
582
uninitvar_atan2(void)583 void uninitvar_atan2(void)
584 {
585 float f1,f2;
586 // cppcheck-suppress uninitvar
587 (void)std::atan2(f1,f2);
588
589 double d1,d2;
590 // cppcheck-suppress uninitvar
591 (void)std::atan2(d1,d2);
592
593 long double ld1,ld2;
594 // cppcheck-suppress uninitvar
595 (void)std::atan2(ld1,ld2);
596 }
597
uninitvar_atof(void)598 void uninitvar_atof(void)
599 {
600 char * c;
601 // cppcheck-suppress uninitvar
602 (void)std::atof(c);
603 }
604
uninitvar_atol(void)605 void uninitvar_atol(void)
606 {
607 char * c;
608 // cppcheck-suppress uninitvar
609 (void)std::atoi(c);
610
611 // cppcheck-suppress uninitvar
612 (void)std::atol(c);
613
614 // cppcheck-suppress uninitvar
615 (void)std::atoll(c);
616 }
617
uninitvar_ceil(void)618 void uninitvar_ceil(void)
619 {
620 float f;
621 // cppcheck-suppress uninitvar
622 (void)std::ceil(f);
623
624 double d;
625 // cppcheck-suppress uninitvar
626 (void)std::ceil(d);
627
628 long double ld;
629 // cppcheck-suppress uninitvar
630 (void)std::ceil(ld);
631 }
632
uninitvar_copysign(void)633 void uninitvar_copysign(void)
634 {
635 float f1, f2;
636 // cppcheck-suppress uninitvar
637 (void)std::copysignf(f1, f2);
638
639 double d1, d2;
640 // cppcheck-suppress uninitvar
641 (void)std::copysign(d1, d2);
642
643 long double ld1, ld2;
644 // cppcheck-suppress uninitvar
645 (void)std::copysignl(ld1, ld2);
646 }
647
uninitvar_cbrt(void)648 void uninitvar_cbrt(void)
649 {
650 float f;
651 // cppcheck-suppress uninitvar
652 (void)std::cbrtf(f);
653
654 double d;
655 // cppcheck-suppress uninitvar
656 (void)std::cbrt(d);
657
658 long double ld;
659 // cppcheck-suppress uninitvar
660 (void)std::cbrtl(ld);
661 }
662
uninitvar_cos(void)663 void uninitvar_cos(void)
664 {
665 float f;
666 // cppcheck-suppress uninitvar
667 (void)std::cos(f);
668
669 double d;
670 // cppcheck-suppress uninitvar
671 (void)std::cos(d);
672
673 long double ld;
674 // cppcheck-suppress uninitvar
675 (void)std::cos(ld);
676 }
677
uninitvar_clearerr(void)678 void uninitvar_clearerr(void)
679 {
680 FILE * stream;
681 // cppcheck-suppress uninitvar
682 std::clearerr(stream);
683 }
684
uninitvar_cosh(void)685 void uninitvar_cosh(void)
686 {
687 float f;
688 // cppcheck-suppress uninitvar
689 (void)std::cosh(f);
690
691 double d;
692 // cppcheck-suppress uninitvar
693 (void)std::cosh(d);
694
695 long double ld;
696 // cppcheck-suppress uninitvar
697 (void)std::cosh(ld);
698 }
699
uninitvar_feraiseexcept(void)700 void uninitvar_feraiseexcept(void)
701 {
702 int expects;
703 // cppcheck-suppress uninitvar
704 (void)std::feraiseexcept(expects);
705 }
706
uninitvar_fesetexceptflag(fexcept_t * flagp)707 void uninitvar_fesetexceptflag(fexcept_t* flagp)
708 {
709 int expects;
710 // cppcheck-suppress uninitvar
711 (void)std::fesetexceptflag(flagp, expects);
712 }
713
uninitvar_feclearexcept(void)714 void uninitvar_feclearexcept(void)
715 {
716 int i;
717 // cppcheck-suppress uninitvar
718 (void)std::feclearexcept(i);
719 }
720
uninitvar_fesetenv(void)721 void uninitvar_fesetenv(void)
722 {
723 fenv_t* envp;
724 // cppcheck-suppress uninitvar
725 (void)std::fesetenv(envp);
726 }
727
uninitvar_fesetround(void)728 void uninitvar_fesetround(void)
729 {
730 int i;
731 // cppcheck-suppress uninitvar
732 (void)std::fesetround(i);
733 }
734
uninitvar_fetestexcept(void)735 void uninitvar_fetestexcept(void)
736 {
737 int i;
738 // cppcheck-suppress uninitvar
739 (void)std::fetestexcept(i);
740 }
741
uninitvar_feupdateenv(void)742 void uninitvar_feupdateenv(void)
743 {
744 fenv_t* envp;
745 // cppcheck-suppress uninitvar
746 (void)std::feupdateenv(envp);
747 }
748
uninitvar_ctime(void)749 void uninitvar_ctime(void)
750 {
751 time_t *tp;
752 // cppcheck-suppress uninitvar
753 (void)std::ctime(tp);
754 }
755
uninitvar_difftime(void)756 void uninitvar_difftime(void)
757 {
758 time_t t1,t2;
759 // cppcheck-suppress uninitvar
760 (void)std::difftime(t1, t2);
761 }
762
uninitvar_div(void)763 void uninitvar_div(void)
764 {
765 int num;
766 int denom;
767 // cppcheck-suppress uninitvar
768 (void)std::div(num,denom);
769 }
770
uninitvar_imaxdiv(void)771 void uninitvar_imaxdiv(void)
772 {
773 intmax_t numer1, numer2;
774 intmax_t denom1, denom2;
775 // cppcheck-suppress uninitvar
776 (void)std::imaxdiv(numer1,denom1);
777 // cppcheck-suppress uninitvar
778 (void)imaxdiv(numer2,denom2);
779 }
780
uninitvar_exit(void)781 void uninitvar_exit(void)
782 {
783 int i;
784 // cppcheck-suppress uninitvar
785 std::exit(i);
786 }
787
uninitvar_erf(void)788 void uninitvar_erf(void)
789 {
790 float f;
791 // cppcheck-suppress uninitvar
792 (void)std::erff(f);
793
794 double d;
795 // cppcheck-suppress uninitvar
796 (void)std::erf(d);
797
798 long double ld;
799 // cppcheck-suppress uninitvar
800 (void)std::erfl(ld);
801 }
802
uninitvar_erfc(void)803 void uninitvar_erfc(void)
804 {
805 float f;
806 // cppcheck-suppress uninitvar
807 (void)std::erfcf(f);
808
809 double d;
810 // cppcheck-suppress uninitvar
811 (void)std::erfc(d);
812
813 long double ld;
814 // cppcheck-suppress uninitvar
815 (void)std::erfcl(ld);
816 }
817
uninitvar_exp(void)818 void uninitvar_exp(void)
819 {
820 float f;
821 // cppcheck-suppress uninitvar
822 (void)std::exp(f);
823
824 double d;
825 // cppcheck-suppress uninitvar
826 (void)std::exp(d);
827
828 long double ld;
829 // cppcheck-suppress uninitvar
830 (void)std::exp(ld);
831 }
832
uninitvar_exp2(void)833 void uninitvar_exp2(void)
834 {
835 float f;
836 // cppcheck-suppress uninitvar
837 (void)std::exp2f(f);
838
839 double d;
840 // cppcheck-suppress uninitvar
841 (void)std::exp2(d);
842
843 long double ld;
844 // cppcheck-suppress uninitvar
845 (void)std::exp2l(ld);
846 }
847
uninitvar_expm1(void)848 void uninitvar_expm1(void)
849 {
850 float f;
851 // cppcheck-suppress uninitvar
852 (void)std::expm1f(f);
853
854 double d;
855 // cppcheck-suppress uninitvar
856 (void)std::expm1(d);
857
858 long double ld;
859 // cppcheck-suppress uninitvar
860 (void)std::expm1l(ld);
861 }
862
uninitvar_fabs(void)863 void uninitvar_fabs(void)
864 {
865 float f;
866 // cppcheck-suppress uninitvar
867 (void)std::fabs(f);
868
869 double d;
870 // cppcheck-suppress uninitvar
871 (void)std::fabs(d);
872
873 long double ld;
874 // cppcheck-suppress uninitvar
875 (void)std::fabs(ld);
876 }
877
uninitvar_fdim(void)878 void uninitvar_fdim(void)
879 {
880 float f1,f2;
881 // cppcheck-suppress uninitvar
882 (void)std::fdimf(f1,f2);
883
884 double d1,d2;
885 // cppcheck-suppress uninitvar
886 (void)std::fdim(d1,d2);
887
888 long double ld1,ld2;
889 // cppcheck-suppress uninitvar
890 (void)std::fdiml(ld1,ld2);
891 }
892
uninitvar_fclose(void)893 void uninitvar_fclose(void)
894 {
895 FILE *stream;
896 // cppcheck-suppress uninitvar
897 (void)std::fclose(stream);
898 }
899
uninitvar_ferror(void)900 void uninitvar_ferror(void)
901 {
902 FILE *stream;
903 // cppcheck-suppress uninitvar
904 (void)std::ferror(stream);
905 }
906
uninitvar_feof(void)907 void uninitvar_feof(void)
908 {
909 FILE *stream;
910 // cppcheck-suppress uninitvar
911 (void)std::feof(stream);
912 }
913
uninitvar_fflush(void)914 void uninitvar_fflush(void)
915 {
916 FILE *stream;
917 // cppcheck-suppress uninitvar
918 (void)std::fflush(stream);
919 }
920
uninitvar_fgetc(void)921 void uninitvar_fgetc(void)
922 {
923 FILE *stream;
924 // cppcheck-suppress uninitvar
925 (void)std::fgetc(stream);
926 }
927
uninitvar_fgetwc(void)928 void uninitvar_fgetwc(void)
929 {
930 FILE *stream;
931 // cppcheck-suppress uninitvar
932 (void)std::fgetwc(stream);
933 }
934
uninitvar_fgetpos(void)935 void uninitvar_fgetpos(void)
936 {
937 FILE* stream;
938 fpos_t *ptr;
939 // cppcheck-suppress uninitvar
940 (void)std::fgetpos(stream,ptr);
941 }
942
uninitvar_floor(void)943 void uninitvar_floor(void)
944 {
945 float f;
946 // cppcheck-suppress uninitvar
947 (void)std::floor(f);
948
949 double d;
950 // cppcheck-suppress uninitvar
951 (void)std::floor(d);
952
953 long double ld;
954 // cppcheck-suppress uninitvar
955 (void)std::floor(ld);
956 }
957
uninitvar_fma(void)958 void uninitvar_fma(void)
959 {
960 float f1,f2,f3;
961 // cppcheck-suppress uninitvar
962 (void)std::fmaf(f1,f2,f3);
963
964 double d1,d2,d3;
965 // cppcheck-suppress uninitvar
966 (void)std::fma(d1,d2,d3);
967
968 long double ld1,ld2,ld3;
969 // cppcheck-suppress uninitvar
970 (void)std::fmal(ld1,ld2,ld3);
971 }
972
uninitvar_fmax(void)973 void uninitvar_fmax(void)
974 {
975 float f1,f2;
976 // cppcheck-suppress uninitvar
977 (void)std::fmaxf(f1,f2);
978
979 double d1,d2;
980 // cppcheck-suppress uninitvar
981 (void)std::fmax(d1,d2);
982
983 long double ld1,ld2;
984 // cppcheck-suppress uninitvar
985 (void)std::fmaxl(ld1,ld2);
986 }
987
uninitvar_fmin(void)988 void uninitvar_fmin(void)
989 {
990 float f1,f2;
991 // cppcheck-suppress uninitvar
992 (void)std::fminf(f1,f2);
993
994 double d1,d2;
995 // cppcheck-suppress uninitvar
996 (void)std::fmin(d1,d2);
997
998 long double ld1,ld2;
999 // cppcheck-suppress uninitvar
1000 (void)std::fminl(ld1,ld2);
1001 }
1002
uninitvar_fmod(void)1003 void uninitvar_fmod(void)
1004 {
1005 float f1,f2;
1006 // cppcheck-suppress uninitvar
1007 (void)std::fmod(f1,f2);
1008
1009 double d1,d2;
1010 // cppcheck-suppress uninitvar
1011 (void)std::fmod(d1,d2);
1012
1013 long double ld1,ld2;
1014 // cppcheck-suppress uninitvar
1015 (void)std::fmod(ld1,ld2);
1016 }
1017
uninitar_fopen(void)1018 void uninitar_fopen(void)
1019 {
1020 char *filename;
1021 char *mode;
1022 // cppcheck-suppress uninitvar
1023 FILE * fp = std::fopen(filename, mode);
1024 fclose(fp);
1025 }
1026
uninitar_fprintf(FILE * Stream,char * Format,int Argument)1027 void uninitar_fprintf(FILE *Stream, char *Format, int Argument)
1028 {
1029 FILE *stream;
1030 char *format1, *format2;
1031 int argument1, argument2;
1032 // cppcheck-suppress uninitvar
1033 (void)std::fprintf(stream, format1, argument1);
1034 // cppcheck-suppress uninitvar
1035 (void)std::fprintf(stream, Format, Argument);
1036 // cppcheck-suppress uninitvar
1037 (void)std::fprintf(Stream, format2, Argument);
1038 // cppcheck-suppress uninitvar
1039 (void)std::fprintf(Stream, Format, argument2);
1040
1041 // no warning is expected
1042 (void)std::fprintf(Stream, Format, Argument);
1043 }
1044
uninitar_vfprintf(FILE * Stream,const char * Format,va_list Arg)1045 void uninitar_vfprintf(FILE *Stream, const char *Format, va_list Arg)
1046 {
1047 FILE *stream;
1048 char *format1, *format2;
1049 va_list arg;
1050 // cppcheck-suppress va_list_usedBeforeStarted
1051 // cppcheck-suppress uninitvar
1052 (void)std::vfprintf(stream, format1, arg);
1053 // cppcheck-suppress uninitvar
1054 (void)std::vfprintf(stream, Format, Arg);
1055 // cppcheck-suppress uninitvar
1056 (void)std::vfprintf(Stream, format2, Arg);
1057
1058 // no warning is expected
1059 (void)std::vfprintf(Stream, Format, Arg);
1060 // cppcheck-suppress va_list_usedBeforeStarted
1061 (void)std::vfprintf(Stream, Format, arg);
1062 }
1063
uninitar_vfwprintf(FILE * Stream,wchar_t * Format,va_list Arg)1064 void uninitar_vfwprintf(FILE *Stream, wchar_t *Format, va_list Arg)
1065 {
1066 FILE *stream;
1067 wchar_t *format1, *format2;
1068 va_list arg;
1069 // cppcheck-suppress va_list_usedBeforeStarted
1070 // cppcheck-suppress uninitvar
1071 (void)std::vfwprintf(stream, format1, arg);
1072 // cppcheck-suppress uninitvar
1073 (void)std::vfwprintf(stream, Format, Arg);
1074 // cppcheck-suppress uninitvar
1075 (void)std::vfwprintf(Stream, format2, Arg);
1076
1077 // no warning is expected
1078 (void)std::vfwprintf(Stream, Format, Arg);
1079 // cppcheck-suppress va_list_usedBeforeStarted
1080 (void)std::vfwprintf(Stream, Format, arg);
1081 }
1082
uninitvar_fputc(void)1083 void uninitvar_fputc(void)
1084 {
1085 int c;
1086 FILE *stream;
1087 // cppcheck-suppress uninitvar
1088 (void)std::fputc(c,stream);
1089 }
1090
uninitvar_fputwc(void)1091 void uninitvar_fputwc(void)
1092 {
1093 wchar_t c;
1094 FILE *stream;
1095 // cppcheck-suppress uninitvar
1096 (void)std::fputwc(c,stream);
1097 }
1098
uninitvar_fputs(void)1099 void uninitvar_fputs(void)
1100 {
1101 char *string;
1102 FILE *stream;
1103 // cppcheck-suppress uninitvar
1104 (void)std::fputs(string,stream);
1105 }
1106
uninitvar_fputws(void)1107 void uninitvar_fputws(void)
1108 {
1109 wchar_t *string;
1110 FILE *stream;
1111 // cppcheck-suppress uninitvar
1112 (void)std::fputws(string,stream);
1113 }
1114
uninitvar_fread(void)1115 void uninitvar_fread(void)
1116 {
1117 void *ptr;
1118 size_t size;
1119 size_t nobj;
1120 FILE *stream;
1121 // cppcheck-suppress uninitvar
1122 (void)std::fread(ptr,size,nobj,stream);
1123 }
1124
uninitvar_free(void)1125 void uninitvar_free(void)
1126 {
1127 // cppcheck-suppress unassignedVariable
1128 void *block;
1129 // cppcheck-suppress uninitvar
1130 std::free(block);
1131 }
1132
uninitvar_freopen(void)1133 void uninitvar_freopen(void)
1134 {
1135 char *filename;
1136 char *mode;
1137 FILE *stream;
1138 // cppcheck-suppress uninitvar
1139 FILE * p = std::freopen(filename,mode,stream);
1140 free(p);
1141 }
1142
uninitvar_frexp(void)1143 void uninitvar_frexp(void)
1144 {
1145 float f1;
1146 int *i1;
1147 // cppcheck-suppress uninitvar
1148 (void)std::frexp(f1,i1);
1149
1150 double d1;
1151 int *i2;
1152 // cppcheck-suppress uninitvar
1153 (void)std::frexp(d1,i2);
1154
1155 long double ld1;
1156 int *i3;
1157 // cppcheck-suppress uninitvar
1158 (void)std::frexp(ld1,i3);
1159 }
1160
uninitvar_hypot(void)1161 void uninitvar_hypot(void)
1162 {
1163 float f1,f2;
1164 // cppcheck-suppress uninitvar
1165 (void)std::hypotf(f1,f2);
1166
1167 double d1,d2;
1168 // cppcheck-suppress uninitvar
1169 (void)std::hypot(d1,d2);
1170
1171 long double ld1,ld2;
1172 // cppcheck-suppress uninitvar
1173 (void)std::hypotl(ld1,ld2);
1174 }
1175
uninitvar_fscanf(void)1176 void uninitvar_fscanf(void)
1177 {
1178 FILE *stream;
1179 char *format;
1180 int i;
1181 // cppcheck-suppress uninitvar
1182 (void)std::fscanf(stream,format,i);
1183 }
1184
uninitvar_vfscanf(void)1185 void uninitvar_vfscanf(void)
1186 {
1187 FILE *stream;
1188 char *format;
1189 va_list arg;
1190 // cppcheck-suppress va_list_usedBeforeStarted
1191 // cppcheck-suppress uninitvar
1192 (void)std::vfscanf(stream,format,arg);
1193 }
1194
uninitvar_vfwscanf(void)1195 void uninitvar_vfwscanf(void)
1196 {
1197 FILE *stream;
1198 wchar_t *format;
1199 va_list arg;
1200 // cppcheck-suppress va_list_usedBeforeStarted
1201 // cppcheck-suppress uninitvar
1202 (void)std::vfwscanf(stream,format,arg);
1203 }
1204
uninitvar_fseek(void)1205 void uninitvar_fseek(void)
1206 {
1207 FILE* stream;
1208 long int offset;
1209 int origin;
1210 // cppcheck-suppress uninitvar
1211 (void)std::fseek(stream,offset,origin);
1212 }
1213
uninitvar_fsetpos(void)1214 void uninitvar_fsetpos(void)
1215 {
1216 FILE* stream;
1217 fpos_t *ptr;
1218 // cppcheck-suppress uninitvar
1219 (void)std::fsetpos(stream,ptr);
1220 }
1221
uninitvar_fgets(void)1222 void uninitvar_fgets(void)
1223 {
1224 char *buffer;
1225 int n;
1226 FILE *stream;
1227 // cppcheck-suppress uninitvar
1228 (void)std::fgets(buffer,n,stream);
1229 }
1230
uninitvar_fgetws(void)1231 void uninitvar_fgetws(void)
1232 {
1233 wchar_t *buffer;
1234 int n;
1235 FILE *stream;
1236 // cppcheck-suppress uninitvar
1237 (void)std::fgetws(buffer,n,stream);
1238 }
1239
uninitvar_ftell(void)1240 void uninitvar_ftell(void)
1241 {
1242 FILE *stream;
1243 // cppcheck-suppress uninitvar
1244 (void)std::ftell(stream);
1245 }
1246
uninitvar_fwide(void)1247 void uninitvar_fwide(void)
1248 {
1249 FILE *stream;
1250 int mode;
1251 // cppcheck-suppress uninitvar
1252 (void)std::fwide(stream,mode);
1253 }
1254
uninitvar_fwrite(void)1255 void uninitvar_fwrite(void)
1256 {
1257 void *ptr;
1258 size_t size;
1259 size_t nobj;
1260 FILE *stream;
1261 // cppcheck-suppress uninitvar
1262 (void)std::fwrite(ptr,size,nobj,stream);
1263 }
1264
uninitvar_mblen(void)1265 void uninitvar_mblen(void)
1266 {
1267 char *string;
1268 size_t size;
1269 // cppcheck-suppress uninitvar
1270 (void)std::mblen(string,size);
1271 }
1272
uninitvar_mbtowc(void)1273 void uninitvar_mbtowc(void)
1274 {
1275 wchar_t* pwc;
1276 char* pmb;
1277 size_t max;
1278 // cppcheck-suppress uninitvar
1279 (void)std::mbtowc(pwc,pmb,max);
1280 }
1281
uninitvar_mbrlen(const char * p,size_t m,mbstate_t * s)1282 void uninitvar_mbrlen(const char* p, size_t m, mbstate_t* s)
1283 {
1284 char* pmb;
1285 size_t max1, max2;
1286 mbstate_t* ps1, *ps2;
1287 // cppcheck-suppress uninitvar
1288 (void)std::mbrlen(pmb,max1,ps1);
1289 // cppcheck-suppress uninitvar
1290 (void)std::mbrlen(pmb,m,s);
1291 // cppcheck-suppress uninitvar
1292 (void)std::mbrlen(p,max2,s);
1293 // cppcheck-suppress uninitvar
1294 (void)std::mbrlen(p,m,ps2);
1295 // no warning is expected
1296 (void)std::mbrlen(p,m,s);
1297 }
1298
nullPointer_mbrlen(const char * p,size_t m,mbstate_t * s)1299 void nullPointer_mbrlen(const char* p, size_t m, mbstate_t* s)
1300 {
1301 // no warning is expected: A call to the function with a null pointer as pmb resets the shift state (and ignores parameter max).
1302 (void)std::mbrlen(NULL,m,s);
1303 (void)std::mbrlen(NULL,0,s);
1304 // cppcheck-suppress nullPointer
1305 (void)std::mbrlen(p,m,NULL);
1306 }
1307
uninitvar_btowc(void)1308 void uninitvar_btowc(void)
1309 {
1310 int c;
1311 // cppcheck-suppress uninitvar
1312 (void)std::btowc(c);
1313 }
1314
uninitvar_mbsinit(void)1315 void uninitvar_mbsinit(void)
1316 {
1317 mbstate_t* ps;
1318 // cppcheck-suppress uninitvar
1319 (void)std::mbsinit(ps);
1320 }
1321
uninitvar_mbstowcs(void)1322 void uninitvar_mbstowcs(void)
1323 {
1324 wchar_t *ws;
1325 char *s;
1326 size_t n;
1327 // cppcheck-suppress uninitvar
1328 (void)std::mbstowcs(ws,s,n);
1329 }
1330
uninitvar_mbsrtowcs(void)1331 void uninitvar_mbsrtowcs(void)
1332 {
1333 wchar_t* dest;
1334 const char* src;
1335 size_t max;
1336 mbstate_t* ps;
1337 // cppcheck-suppress uninitvar
1338 (void)std::mbsrtowcs(dest,&src,max,ps);
1339 }
1340
uninitvar_wctob(void)1341 void uninitvar_wctob(void)
1342 {
1343 wint_t wc;
1344 // cppcheck-suppress uninitvar
1345 (void)std::wctob(wc);
1346 }
1347
uninitvar_wctomb(void)1348 void uninitvar_wctomb(void)
1349 {
1350 char *s;
1351 wchar_t wc;
1352 // cppcheck-suppress uninitvar
1353 (void)std::wctomb(s,wc);
1354 }
1355
uninitvar_wcstombs(void)1356 void uninitvar_wcstombs(void)
1357 {
1358 char *mbstr;
1359 wchar_t *wcstr;
1360 size_t n;
1361 // cppcheck-suppress uninitvar
1362 (void)std::wcstombs(mbstr,wcstr,n);
1363 }
1364
uninitvar_getc(void)1365 void uninitvar_getc(void)
1366 {
1367 FILE *stream;
1368 // cppcheck-suppress uninitvar
1369 (void)std::getc(stream);
1370 }
1371
uninitvar_getwc(void)1372 void uninitvar_getwc(void)
1373 {
1374 FILE *stream;
1375 // cppcheck-suppress uninitvar
1376 (void)std::getwc(stream);
1377 }
1378
uninitvar_ungetc(void)1379 void uninitvar_ungetc(void)
1380 {
1381 int c;
1382 FILE *stream;
1383 // cppcheck-suppress uninitvar
1384 (void)std::ungetc(c,stream);
1385 }
1386
uninitvar_ungetwc(void)1387 void uninitvar_ungetwc(void)
1388 {
1389 wint_t c;
1390 FILE *stream;
1391 // cppcheck-suppress uninitvar
1392 (void)std::ungetwc(c,stream);
1393 }
1394
uninitvar_getenv(void)1395 void uninitvar_getenv(void)
1396 {
1397 char *name;
1398 // cppcheck-suppress uninitvar
1399 (void)std::getenv(name);
1400 }
1401
uninitvar_gmtime(void)1402 void uninitvar_gmtime(void)
1403 {
1404 time_t *tp;
1405 // cppcheck-suppress uninitvar
1406 (void)std::gmtime(tp);
1407 }
1408
uninitvar_iswalnum(void)1409 void uninitvar_iswalnum(void)
1410 {
1411 wint_t i;
1412 // cppcheck-suppress uninitvar
1413 (void)std::iswalnum(i);
1414 }
1415
uninitvar_iswalpha(void)1416 void uninitvar_iswalpha(void)
1417 {
1418 wint_t i;
1419 // cppcheck-suppress uninitvar
1420 (void)std::iswalpha(i);
1421 }
1422
uninitvar_isblank(void)1423 void uninitvar_isblank(void)
1424 {
1425 int i;
1426 // cppcheck-suppress uninitvar
1427 (void)std::isblank(i);
1428 }
1429
uninitvar_iswblank(void)1430 void uninitvar_iswblank(void)
1431 {
1432 wint_t i;
1433 // cppcheck-suppress uninitvar
1434 (void)std::iswblank(i);
1435 }
1436
uninitvar_iswcntrl(void)1437 void uninitvar_iswcntrl(void)
1438 {
1439 wint_t i;
1440 // cppcheck-suppress uninitvar
1441 (void)std::iswcntrl(i);
1442 }
1443
uninitvar_iswctype(void)1444 void uninitvar_iswctype(void)
1445 {
1446 wint_t c;
1447 wctype_t desc;
1448 // cppcheck-suppress uninitvar
1449 (void)std::iswctype(c,desc);
1450 }
1451
uninitvar_iswdigit(void)1452 void uninitvar_iswdigit(void)
1453 {
1454 wint_t i;
1455 // cppcheck-suppress uninitvar
1456 (void)std::iswdigit(i);
1457 }
1458
uninitvar_iswgraph(void)1459 void uninitvar_iswgraph(void)
1460 {
1461 wint_t i;
1462 // cppcheck-suppress uninitvar
1463 (void)std::iswgraph(i);
1464 }
1465
uninitvar_iswlower(void)1466 void uninitvar_iswlower(void)
1467 {
1468 wint_t i;
1469 // cppcheck-suppress uninitvar
1470 (void)std::iswlower(i);
1471 }
1472
uninitvar_iswprint(void)1473 void uninitvar_iswprint(void)
1474 {
1475 wint_t i;
1476 // cppcheck-suppress uninitvar
1477 (void)std::iswprint(i);
1478 }
1479
uninitvar_ispunct(void)1480 void uninitvar_ispunct(void)
1481 {
1482 int i;
1483 // cppcheck-suppress uninitvar
1484 (void)std::ispunct(i);
1485 }
1486
uninitvar_iswpunct(void)1487 void uninitvar_iswpunct(void)
1488 {
1489 wint_t i;
1490 // cppcheck-suppress uninitvar
1491 (void)std::iswpunct(i);
1492 }
1493
uninitvar_iswspace(void)1494 void uninitvar_iswspace(void)
1495 {
1496 wint_t i;
1497 // cppcheck-suppress uninitvar
1498 (void)std::iswspace(i);
1499 }
1500
uninitvar_iswupper(void)1501 void uninitvar_iswupper(void)
1502 {
1503 wint_t i;
1504 // cppcheck-suppress uninitvar
1505 (void)std::iswupper(i);
1506 }
1507
uninitvar_iswxdigit(void)1508 void uninitvar_iswxdigit(void)
1509 {
1510 wint_t i;
1511 // cppcheck-suppress uninitvar
1512 (void)std::iswxdigit(i);
1513 }
1514
uninitvar_towctrans(void)1515 void uninitvar_towctrans(void)
1516 {
1517 wint_t c;
1518 wctrans_t desc;
1519 // cppcheck-suppress uninitvar
1520 (void)std::towctrans(c,desc);
1521 }
1522
uninitvar_towlower(void)1523 void uninitvar_towlower(void)
1524 {
1525 wint_t i;
1526 // cppcheck-suppress uninitvar
1527 (void)std::towlower(i);
1528 }
1529
uninitvar_towupper(void)1530 void uninitvar_towupper(void)
1531 {
1532 wint_t i;
1533 // cppcheck-suppress uninitvar
1534 (void)std::towupper(i);
1535 }
1536
uninitvar_wctrans(void)1537 void uninitvar_wctrans(void)
1538 {
1539 char* property;
1540 // cppcheck-suppress uninitvar
1541 (void)std::wctrans(property);
1542 }
1543
uninitvar_wctype(void)1544 void uninitvar_wctype(void)
1545 {
1546 char* property;
1547 // cppcheck-suppress uninitvar
1548 (void)std::wctype(property);
1549 }
1550
uninitvar_labs(void)1551 void uninitvar_labs(void)
1552 {
1553 long int li;
1554 // cppcheck-suppress uninitvar
1555 (void)std::labs(li);
1556
1557 long long int lli;
1558 // cppcheck-suppress uninitvar
1559 (void)std::llabs(lli);
1560 }
1561
uninitvar_ldexp(void)1562 void uninitvar_ldexp(void)
1563 {
1564 float fd;
1565 int e1;
1566 // cppcheck-suppress uninitvar
1567 (void)std::ldexp(fd,e1);
1568
1569 double dc;
1570 int e2;
1571 // cppcheck-suppress uninitvar
1572 (void)std::ldexp(dc,e2);
1573
1574 long double ldc;
1575 int e3;
1576 // cppcheck-suppress uninitvar
1577 (void)std::ldexp(ldc,e3);
1578 }
1579
uninitvar_lgamma(void)1580 void uninitvar_lgamma(void)
1581 {
1582 float f;
1583 // cppcheck-suppress uninitvar
1584 (void)std::lgammaf(f);
1585
1586 double d;
1587 // cppcheck-suppress uninitvar
1588 (void)std::lgamma(d);
1589
1590 long double ld;
1591 // cppcheck-suppress uninitvar
1592 (void)std::lgammal(ld);
1593 }
1594
uninitvar_rint(void)1595 void uninitvar_rint(void)
1596 {
1597 float f;
1598 // cppcheck-suppress uninitvar
1599 (void)std::rintf(f);
1600
1601 double d;
1602 // cppcheck-suppress uninitvar
1603 (void)std::rint(d);
1604
1605 long double ld;
1606 // cppcheck-suppress uninitvar
1607 (void)std::rintl(ld);
1608 }
1609
uninitvar_lrint(void)1610 void uninitvar_lrint(void)
1611 {
1612 float f;
1613 // cppcheck-suppress uninitvar
1614 (void)std::lrintf(f);
1615
1616 double d;
1617 // cppcheck-suppress uninitvar
1618 (void)std::lrint(d);
1619
1620 long double ld;
1621 // cppcheck-suppress uninitvar
1622 (void)std::lrintl(ld);
1623 }
1624
uninitvar_llrint(void)1625 void uninitvar_llrint(void)
1626 {
1627 float f;
1628 // cppcheck-suppress uninitvar
1629 (void)std::llrintf(f);
1630
1631 double d;
1632 // cppcheck-suppress uninitvar
1633 (void)std::llrint(d);
1634
1635 long double ld;
1636 // cppcheck-suppress uninitvar
1637 (void)std::llrintl(ld);
1638 }
1639
uninitvar_lround(void)1640 void uninitvar_lround(void)
1641 {
1642 float f;
1643 // cppcheck-suppress uninitvar
1644 (void)std::lroundf(f);
1645
1646 double d;
1647 // cppcheck-suppress uninitvar
1648 (void)std::lround(d);
1649
1650 long double ld;
1651 // cppcheck-suppress uninitvar
1652 (void)std::lroundl(ld);
1653 }
1654
uninitvar_llround(void)1655 void uninitvar_llround(void)
1656 {
1657 float f;
1658 // cppcheck-suppress uninitvar
1659 (void)std::llroundf(f);
1660
1661 double d;
1662 // cppcheck-suppress uninitvar
1663 (void)std::llround(d);
1664
1665 long double ld;
1666 // cppcheck-suppress uninitvar
1667 (void)std::llroundl(ld);
1668 }
1669
uninitvar_srand(void)1670 void uninitvar_srand(void)
1671 {
1672 unsigned int seed;
1673 // cppcheck-suppress uninitvar
1674 (void)std::srand(seed);
1675 }
1676
uninitvar_ldiv(void)1677 void uninitvar_ldiv(void)
1678 {
1679 long int l1;
1680 long int l2;
1681 // cppcheck-suppress uninitvar
1682 (void)std::ldiv(l1,l2);
1683
1684 long long int ll1;
1685 long long int ll2;
1686 // cppcheck-suppress uninitvar
1687 (void)std::lldiv(ll1,ll2);
1688 }
1689
uninitvar_localtime(void)1690 void uninitvar_localtime(void)
1691 {
1692 time_t *tp;
1693 // cppcheck-suppress uninitvar
1694 (void)std::localtime(tp);
1695 }
1696
uninitvar_log(void)1697 void uninitvar_log(void)
1698 {
1699 float f;
1700 // cppcheck-suppress uninitvar
1701 (void)std::log(f);
1702
1703 double d;
1704 // cppcheck-suppress uninitvar
1705 (void)std::log(d);
1706
1707 long double ld;
1708 // cppcheck-suppress uninitvar
1709 (void)std::log(ld);
1710 }
1711
uninitvar_fpclassify(void)1712 void uninitvar_fpclassify(void)
1713 {
1714 float f;
1715 // cppcheck-suppress uninitvar
1716 (void)std::fpclassify(f);
1717
1718 double d;
1719 // cppcheck-suppress uninitvar
1720 (void)std::fpclassify(d);
1721
1722 long double ld;
1723 // cppcheck-suppress uninitvar
1724 (void)std::fpclassify(ld);
1725 }
1726
uninitvar_isfinite(void)1727 void uninitvar_isfinite(void)
1728 {
1729 float f;
1730 // cppcheck-suppress uninitvar
1731 (void)std::isfinite(f);
1732
1733 double d;
1734 // cppcheck-suppress uninitvar
1735 (void)std::isfinite(d);
1736
1737 long double ld;
1738 // cppcheck-suppress uninitvar
1739 (void)std::isfinite(ld);
1740 }
1741
uninitvar_isgreater(void)1742 void uninitvar_isgreater(void)
1743 {
1744 float f1,f2;
1745 // cppcheck-suppress uninitvar
1746 (void)std::isgreater(f1,f2);
1747
1748 double d1,d2;
1749 // cppcheck-suppress uninitvar
1750 (void)std::isgreater(d1,d2);
1751
1752 long double ld1,ld2;
1753 // cppcheck-suppress uninitvar
1754 (void)std::isgreater(ld1,ld2);
1755 }
1756
uninitvar_isgreaterequal(void)1757 void uninitvar_isgreaterequal(void)
1758 {
1759 float f1,f2;
1760 // cppcheck-suppress uninitvar
1761 (void)std::isgreaterequal(f1,f2);
1762
1763 double d1,d2;
1764 // cppcheck-suppress uninitvar
1765 (void)std::isgreaterequal(d1,d2);
1766
1767 long double ld1,ld2;
1768 // cppcheck-suppress uninitvar
1769 (void)std::isgreaterequal(ld1,ld2);
1770 }
1771
uninitvar_isinf(void)1772 void uninitvar_isinf(void)
1773 {
1774 double d;
1775 // cppcheck-suppress uninitvar
1776 (void)std::isinf(d);
1777 }
1778
uninitvar_logb(void)1779 void uninitvar_logb(void)
1780 {
1781 float f;
1782 // cppcheck-suppress uninitvar
1783 (void)std::logbf(f);
1784
1785 double d;
1786 // cppcheck-suppress uninitvar
1787 (void)std::logb(d);
1788
1789 long double ld;
1790 // cppcheck-suppress uninitvar
1791 (void)std::logbl(ld);
1792 }
1793
uninitvar_isless(void)1794 void uninitvar_isless(void)
1795 {
1796 float f1,f2;
1797 // cppcheck-suppress uninitvar
1798 (void)std::isless(f1,f2);
1799
1800 double d1,d2;
1801 // cppcheck-suppress uninitvar
1802 (void)std::isless(d1,d2);
1803
1804 long double ld1,ld2;
1805 // cppcheck-suppress uninitvar
1806 (void)std::isless(ld1,ld2);
1807 }
1808
uninitvar_islessequal(void)1809 void uninitvar_islessequal(void)
1810 {
1811 float f1,f2;
1812 // cppcheck-suppress uninitvar
1813 (void)std::islessequal(f1,f2);
1814
1815 double d1,d2;
1816 // cppcheck-suppress uninitvar
1817 (void)std::islessequal(d1,d2);
1818
1819 long double ld1,ld2;
1820 // cppcheck-suppress uninitvar
1821 (void)std::islessequal(ld1,ld2);
1822 }
1823
uninitvar_islessgreater(void)1824 void uninitvar_islessgreater(void)
1825 {
1826 float f1,f2;
1827 // cppcheck-suppress uninitvar
1828 (void)std::islessgreater(f1,f2);
1829
1830 double d1,d2;
1831 // cppcheck-suppress uninitvar
1832 (void)std::islessgreater(d1,d2);
1833
1834 long double ld1,ld2;
1835 // cppcheck-suppress uninitvar
1836 (void)std::islessgreater(ld1,ld2);
1837 }
1838
uninitvar_nan(void)1839 void uninitvar_nan(void)
1840 {
1841 char *tagp;
1842 // cppcheck-suppress uninitvar
1843 (void)std::nanf(tagp);
1844 // cppcheck-suppress uninitvar
1845 (void)std::nan(tagp);
1846 // cppcheck-suppress uninitvar
1847 (void)std::nanl(tagp);
1848 }
1849
uninitvar_isnan(void)1850 void uninitvar_isnan(void)
1851 {
1852 double d;
1853 // cppcheck-suppress uninitvar
1854 (void)std::isnan(d);
1855 }
1856
uninitvar_isnormal(void)1857 void uninitvar_isnormal(void)
1858 {
1859 double d;
1860 // cppcheck-suppress uninitvar
1861 (void)std::isnormal(d);
1862 }
1863
uninitvar_isunordered(void)1864 void uninitvar_isunordered(void)
1865 {
1866 double d1,d2;
1867 // cppcheck-suppress uninitvar
1868 (void)std::isunordered(d1,d2);
1869 }
1870
uninitvar_ilogb(void)1871 void uninitvar_ilogb(void)
1872 {
1873 float f;
1874 // cppcheck-suppress uninitvar
1875 (void)std::ilogb(f);
1876
1877 double d;
1878 // cppcheck-suppress uninitvar
1879 (void)std::ilogb(d);
1880
1881 long double ld;
1882 // cppcheck-suppress uninitvar
1883 (void)std::ilogb(ld);
1884 }
1885
uninitvar_log10(void)1886 void uninitvar_log10(void)
1887 {
1888 float f;
1889 // cppcheck-suppress uninitvar
1890 (void)std::log10(f);
1891
1892 double d;
1893 // cppcheck-suppress uninitvar
1894 (void)std::log10(d);
1895
1896 long double ld;
1897 // cppcheck-suppress uninitvar
1898 (void)std::log10(ld);
1899 }
1900
uninitvar_log1p(void)1901 void uninitvar_log1p(void)
1902 {
1903 float f;
1904 // cppcheck-suppress uninitvar
1905 (void)std::log1pf(f);
1906
1907 double d;
1908 // cppcheck-suppress uninitvar
1909 (void)std::log1p(d);
1910
1911 long double ld;
1912 // cppcheck-suppress uninitvar
1913 (void)std::log1pl(ld);
1914 }
1915
uninitvar_log2(void)1916 void uninitvar_log2(void)
1917 {
1918 float f;
1919 // cppcheck-suppress uninitvar
1920 (void)std::log2f(f);
1921
1922 double d;
1923 // cppcheck-suppress uninitvar
1924 (void)std::log2(d);
1925
1926 long double ld;
1927 // cppcheck-suppress uninitvar
1928 (void)std::log2l(ld);
1929 }
1930
uninitvar_nearbyint(void)1931 void uninitvar_nearbyint(void)
1932 {
1933 float f;
1934 // cppcheck-suppress uninitvar
1935 (void)std::nearbyintf(f);
1936
1937 double d;
1938 // cppcheck-suppress uninitvar
1939 (void)std::nearbyint(d);
1940
1941 long double ld;
1942 // cppcheck-suppress uninitvar
1943 (void)std::nearbyintl(ld);
1944 }
1945
uninitvar_nextafter(void)1946 void uninitvar_nextafter(void)
1947 {
1948 float f1,f2;
1949 // cppcheck-suppress uninitvar
1950 (void)std::nextafterf(f1,f2);
1951
1952 double d1,d2;
1953 // cppcheck-suppress uninitvar
1954 (void)std::nextafter(d1,d2);
1955
1956 long double ld1,ld2;
1957 // cppcheck-suppress uninitvar
1958 (void)std::nextafterl(ld1,ld2);
1959 }
1960
uninitvar_nexttoward(void)1961 void uninitvar_nexttoward(void)
1962 {
1963 float f1,f2;
1964 // cppcheck-suppress uninitvar
1965 (void)std::nexttowardf(f1,f2);
1966
1967 double d1,d2;
1968 // cppcheck-suppress uninitvar
1969 (void)std::nexttoward(d1,d2);
1970
1971 long double ld1,ld2;
1972 // cppcheck-suppress uninitvar
1973 (void)std::nexttowardl(ld1,ld2);
1974 }
1975
uninitvar_longjmp(void)1976 void uninitvar_longjmp(void)
1977 {
1978 jmp_buf env;
1979 int val;
1980 // cppcheck-suppress uninitvar
1981 (void)std::longjmp(env,val);
1982 }
1983
uninitvar_malloc(void)1984 void uninitvar_malloc(void)
1985 {
1986 size_t size;
1987 // cppcheck-suppress uninitvar
1988 int *p = (int*)std::malloc(size);
1989 free(p);
1990 }
1991
uninitvar_memchr(void)1992 void uninitvar_memchr(void)
1993 {
1994 void *cs;
1995 int c;
1996 size_t n;
1997 // cppcheck-suppress uninitvar
1998 (void)std::memchr(cs,c,n);
1999 }
2000
uninitvar_wmemchr(void)2001 void uninitvar_wmemchr(void)
2002 {
2003 wchar_t *cs;
2004 wchar_t c;
2005 size_t n;
2006 // cppcheck-suppress uninitvar
2007 (void)std::wmemchr(cs,c,n);
2008 }
2009
uninitvar_memcmp(void)2010 void uninitvar_memcmp(void)
2011 {
2012 void *s1;
2013 void *s2;
2014 size_t n;
2015 // cppcheck-suppress uninitvar
2016 (void)std::memcmp(s1,s2,n);
2017 }
2018
uninitvar_wmemcmp(void)2019 void uninitvar_wmemcmp(void)
2020 {
2021 wchar_t *s1;
2022 wchar_t *s2;
2023 size_t n;
2024 // cppcheck-suppress uninitvar
2025 (void)std::wmemcmp(s1,s2,n);
2026 }
2027
uninitvar_memcpy(void)2028 void uninitvar_memcpy(void)
2029 {
2030 void *ct;
2031 void *cs;
2032 size_t n;
2033 // cppcheck-suppress uninitvar
2034 (void)std::memcpy(ct,cs,n);
2035 }
2036
uninitvar_wmemcpy(void)2037 void uninitvar_wmemcpy(void)
2038 {
2039 wchar_t *cs;
2040 wchar_t *c;
2041 size_t n;
2042 // cppcheck-suppress uninitvar
2043 (void)std::wmemcpy(cs,c,n);
2044 }
2045
uninitvar_memmove(void)2046 void uninitvar_memmove(void)
2047 {
2048 void *ct;
2049 void *cs;
2050 size_t n;
2051 // cppcheck-suppress uninitvar
2052 (void)std::memmove(ct,cs,n);
2053 }
2054
uninitvar_wmemmove(void)2055 void uninitvar_wmemmove(void)
2056 {
2057 wchar_t *cs;
2058 wchar_t *c;
2059 size_t n;
2060 // cppcheck-suppress uninitvar
2061 (void)std::wmemmove(cs,c,n);
2062 }
2063
uninitvar_memset(void)2064 void uninitvar_memset(void)
2065 {
2066 void *s;
2067 int c;
2068 size_t n;
2069 // cppcheck-suppress uninitvar
2070 (void)std::memset(s,c,n);
2071 }
2072
uninitvar_wmemset(void)2073 void uninitvar_wmemset(void)
2074 {
2075 wchar_t *cs;
2076 wchar_t c;
2077 size_t n;
2078 // cppcheck-suppress uninitvar
2079 (void)std::wmemset(cs,c,n);
2080 }
2081
uninitvar_mktime(void)2082 void uninitvar_mktime(void)
2083 {
2084 struct tm *tp;
2085 // cppcheck-suppress uninitvar
2086 (void)std::mktime(tp);
2087 }
2088
uninivar_modf(void)2089 void uninivar_modf(void)
2090 {
2091 float f1;
2092 float *f2;
2093 // cppcheck-suppress uninitvar
2094 (void)std::modf(f1,f2);
2095
2096 double d1;
2097 double *d2;
2098 // cppcheck-suppress uninitvar
2099 (void)std::modf(d1,d2);
2100
2101 long double ld1;
2102 long double *ld2;
2103 // cppcheck-suppress uninitvar
2104 (void)std::modf(ld1,ld2);
2105 }
2106
uninivar_perror(void)2107 void uninivar_perror(void)
2108 {
2109 char *string;
2110 // cppcheck-suppress uninitvar
2111 (void)std::perror(string);
2112 }
2113
uninitvar_pow(void)2114 void uninitvar_pow(void)
2115 {
2116 float f1,f2;
2117 // cppcheck-suppress uninitvar
2118 (void)std::pow(f1,f2);
2119
2120 double d1,d2;
2121 // cppcheck-suppress uninitvar
2122 (void)std::pow(d1,d2);
2123
2124 long double ld1,ld2;
2125 // cppcheck-suppress uninitvar
2126 (void)std::pow(ld1,ld2);
2127 }
2128
uninitvar_remainder(void)2129 void uninitvar_remainder(void)
2130 {
2131 float f1,f2;
2132 // cppcheck-suppress uninitvar
2133 (void)std::remainderf(f1,f2);
2134
2135 double d1,d2;
2136 // cppcheck-suppress uninitvar
2137 (void)std::remainder(d1,d2);
2138
2139 long double ld1,ld2;
2140 // cppcheck-suppress uninitvar
2141 (void)std::remainderl(ld1,ld2);
2142 }
2143
uninitvar_remquo(void)2144 void uninitvar_remquo(void)
2145 {
2146 float f1,f2;
2147 int *i1;
2148 // cppcheck-suppress uninitvar
2149 (void)std::remquof(f1,f2,i1);
2150
2151 double d1,d2;
2152 int *i2;
2153 // cppcheck-suppress uninitvar
2154 (void)std::remquo(d1,d2,i2);
2155
2156 long double ld1,ld2;
2157 int *i3;
2158 // cppcheck-suppress uninitvar
2159 (void)std::remquol(ld1,ld2,i3);
2160 }
2161
uninivar_printf(char * Format,int Argument)2162 void uninivar_printf(char *Format, int Argument)
2163 {
2164 char * format_1, * format_2, * format_3;
2165 int argument1, argument2;
2166 // no warning is expected
2167 (void)std::printf("x");
2168 // cppcheck-suppress uninitvar
2169 (void)std::printf(format_1,argument1);
2170 // cppcheck-suppress uninitvar
2171 (void)std::printf(Format,argument2);
2172 // cppcheck-suppress uninitvar
2173 (void)std::printf(format_2,Argument);
2174 // cppcheck-suppress uninitvar
2175 (void)std::printf(format_3,1);
2176
2177 // no warning is expected
2178 (void)std::printf(Format,Argument);
2179 }
2180
uninivar_vprintf(char * Format,va_list Arg)2181 void uninivar_vprintf(char *Format, va_list Arg)
2182 {
2183 char * format1, *format2;
2184 va_list arg;
2185 // cppcheck-suppress va_list_usedBeforeStarted
2186 // cppcheck-suppress uninitvar
2187 (void)std::vprintf(format1,arg);
2188 // cppcheck-suppress uninitvar
2189 (void)std::vprintf(format2,Arg);
2190
2191 // no warning is expected
2192 (void)std::vprintf(Format,Arg);
2193 // cppcheck-suppress va_list_usedBeforeStarted
2194 (void)std::vprintf(Format,arg);
2195 }
2196
uninivar_vwprintf(wchar_t * Format,va_list Arg)2197 void uninivar_vwprintf(wchar_t *Format, va_list Arg)
2198 {
2199 wchar_t * format1, *format2;
2200 va_list arg;
2201 // cppcheck-suppress va_list_usedBeforeStarted
2202 // cppcheck-suppress uninitvar
2203 (void)std::vwprintf(format1,arg);
2204 // cppcheck-suppress uninitvar
2205 (void)std::vwprintf(format2,Arg);
2206
2207 // no warning is expected
2208 (void)std::vwprintf(Format,Arg);
2209 // cppcheck-suppress va_list_usedBeforeStarted
2210 (void)std::vwprintf(Format,arg);
2211 }
2212
uninivar_bsearch(void)2213 void uninivar_bsearch(void)
2214 {
2215 void* key;
2216 void* base;
2217 size_t num;
2218 size_t size;
2219 // cppcheck-suppress uninitvar
2220 (void)std::bsearch(key,base,num,size,(int (*)(const void*,const void*))strcmp);
2221 }
2222
minsize_bsearch(const void * key,const void * base,size_t num,size_t size,int (* compar)(const void *,const void *))2223 void minsize_bsearch(const void* key, const void* base,
2224 size_t num, size_t size,
2225 int (*compar)(const void*,const void*))
2226 {
2227 int Base[3] = {42, 43, 44};
2228
2229 (void)std::bsearch(key,Base,2,size,(int (*)(const void*,const void*))strcmp);
2230 (void)std::bsearch(key,Base,3,size,(int (*)(const void*,const void*))strcmp);
2231 (void)std::bsearch(key,Base,4,size,(int (*)(const void*,const void*))strcmp);
2232
2233 (void)std::bsearch(key,base,2,size,(int (*)(const void*,const void*))strcmp);
2234 }
2235
uninitvar_qsort(void)2236 void uninitvar_qsort(void)
2237 {
2238 void *base;
2239 size_t n;
2240 size_t size;
2241 // cppcheck-suppress uninitvar
2242 (void)std::qsort(base,n,size, (int (*)(const void*,const void*))strcmp);
2243 }
2244
uninitvar_putc(void)2245 void uninitvar_putc(void)
2246 {
2247 int c;
2248 FILE *stream;
2249 // cppcheck-suppress uninitvar
2250 (void)std::putc(c,stream);
2251 }
2252
uninitvar_putwc(void)2253 void uninitvar_putwc(void)
2254 {
2255 wchar_t c;
2256 FILE *stream;
2257 // cppcheck-suppress uninitvar
2258 (void)std::putc(c,stream);
2259 }
2260
uninitvar_putchar(void)2261 void uninitvar_putchar(void)
2262 {
2263 int c;
2264 // cppcheck-suppress uninitvar
2265 (void)std::putchar(c);
2266 }
2267
uninitvar_putwchar(void)2268 void uninitvar_putwchar(void)
2269 {
2270 wchar_t c;
2271 // cppcheck-suppress uninitvar
2272 (void)std::putwchar(c);
2273 }
2274
uninitvar_puts(void)2275 void uninitvar_puts(void)
2276 {
2277 char *s;
2278 // cppcheck-suppress uninitvar
2279 (void)std::puts(s);
2280 }
2281
uninitvar_realloc(void)2282 void uninitvar_realloc(void)
2283 {
2284 void *block;
2285 size_t newsize;
2286 // cppcheck-suppress uninitvar
2287 void *p = std::realloc(block, newsize);
2288 free(p);
2289 }
2290
uninitvar_remove(void)2291 void uninitvar_remove(void)
2292 {
2293 char *s;
2294 // cppcheck-suppress uninitvar
2295 (void)std::remove(s);
2296 }
2297
uninitvar_rename(void)2298 void uninitvar_rename(void)
2299 {
2300 char *s1;
2301 char *s2;
2302 // cppcheck-suppress uninitvar
2303 (void)std::rename(s1,s2);
2304 }
2305
uninitvar_rewind(void)2306 void uninitvar_rewind(void)
2307 {
2308 FILE *f;
2309 // cppcheck-suppress uninitvar
2310 (void)std::rewind(f);
2311 }
2312
uninitvar_round(void)2313 void uninitvar_round(void)
2314 {
2315 float f;
2316 // cppcheck-suppress uninitvar
2317 (void)std::roundf(f);
2318
2319 double d;
2320 // cppcheck-suppress uninitvar
2321 (void)std::round(d);
2322
2323 long double ld;
2324 // cppcheck-suppress uninitvar
2325 (void)std::roundl(ld);
2326 }
2327
uninivar_scalbn(void)2328 void uninivar_scalbn(void)
2329 {
2330 float f;
2331 int i1;
2332 // cppcheck-suppress uninitvar
2333 (void)std::scalbnf(f,i1);
2334
2335 double d;
2336 int i2;
2337 // cppcheck-suppress uninitvar
2338 (void)std::scalbn(d,i2);
2339
2340 long double ld;
2341 int i3;
2342 // cppcheck-suppress uninitvar
2343 (void)std::scalbnl(ld,i3);
2344 }
2345
uninivar_scalbln(void)2346 void uninivar_scalbln(void)
2347 {
2348 float f;
2349 long int i1;
2350 // cppcheck-suppress uninitvar
2351 (void)std::scalblnf(f,i1);
2352
2353 double d;
2354 long int i2;
2355 // cppcheck-suppress uninitvar
2356 (void)std::scalbln(d,i2);
2357
2358 long double ld;
2359 long int i3;
2360 // cppcheck-suppress uninitvar
2361 (void)std::scalblnl(ld,i3);
2362 }
2363
uninitvar_signbit(void)2364 void uninitvar_signbit(void)
2365 {
2366 double d;
2367 // cppcheck-suppress uninitvar
2368 (void)std::signbit(d);
2369 }
2370
uninivar_signal(void)2371 void uninivar_signal(void)
2372 {
2373 int i;
2374 // cppcheck-suppress uninitvar
2375 std::signal(i, exit);
2376 }
2377
uninivar_raise(void)2378 void uninivar_raise(void)
2379 {
2380 int i;
2381 // cppcheck-suppress uninitvar
2382 (void)std::raise(i);
2383 }
2384
uninivar_scanf(void)2385 void uninivar_scanf(void)
2386 {
2387 char *format;
2388 char str[42];
2389 // cppcheck-suppress uninitvar
2390 (void)std::scanf(format, str);
2391 }
2392
uninivar_vsscanf(void)2393 void uninivar_vsscanf(void)
2394 {
2395 char *s;
2396 char *format;
2397 va_list arg;
2398 // cppcheck-suppress va_list_usedBeforeStarted
2399 // cppcheck-suppress uninitvar
2400 (void)std::vsscanf(s,format,arg);
2401 }
2402
uninivar_vswscanf(void)2403 void uninivar_vswscanf(void)
2404 {
2405 wchar_t *s;
2406 wchar_t *format;
2407 va_list arg;
2408 // cppcheck-suppress va_list_usedBeforeStarted
2409 // cppcheck-suppress uninitvar
2410 (void)std::vswscanf(s,format,arg);
2411 }
2412
uninivar_vscanf(void)2413 void uninivar_vscanf(void)
2414 {
2415 char *format;
2416 va_list arg;
2417 // cppcheck-suppress va_list_usedBeforeStarted
2418 // cppcheck-suppress uninitvar
2419 (void)std::vscanf(format,arg);
2420 }
2421
uninivar_vwscanf(void)2422 void uninivar_vwscanf(void)
2423 {
2424 wchar_t *format;
2425 va_list arg;
2426 // cppcheck-suppress va_list_usedBeforeStarted
2427 // cppcheck-suppress uninitvar
2428 (void)std::vwscanf(format,arg);
2429 }
2430
uninivar_setbuf(void)2431 void uninivar_setbuf(void)
2432 {
2433 FILE *stream;
2434 char *buf;
2435 // cppcheck-suppress uninitvar
2436 (void)std::setbuf(stream,buf);
2437 }
2438
uninivar_setvbuf(void)2439 void uninivar_setvbuf(void)
2440 {
2441 FILE *stream;
2442 char *buf;
2443 int mode;
2444 size_t size;
2445 // cppcheck-suppress uninitvar
2446 (void)std::setvbuf(stream,buf,mode,size);
2447 }
2448
uninitvar_strcat(char * dest,const char * const source)2449 void uninitvar_strcat(char *dest, const char * const source)
2450 {
2451 char *deststr1, *deststr2;
2452 char *srcstr;
2453 // cppcheck-suppress uninitvar
2454 (void)std::strcat(deststr1,srcstr);
2455 // cppcheck-suppress uninitvar
2456 (void)std::strcat(dest,srcstr);
2457 // cppcheck-suppress uninitvar
2458 (void)std::strcat(deststr2,source);
2459
2460 // no warning shall be shown for
2461 (void)std::strcat(dest,source);
2462 }
2463
uninitvar_wcscat(wchar_t * dest,const wchar_t * const source)2464 void uninitvar_wcscat(wchar_t *dest, const wchar_t * const source)
2465 {
2466 wchar_t *deststr_1, *deststr_2;
2467 wchar_t *srcstr;
2468 // cppcheck-suppress uninitvar
2469 (void)std::wcscat(deststr_1,srcstr);
2470 // cppcheck-suppress uninitvar
2471 (void)std::wcscat(dest,srcstr);
2472 // cppcheck-suppress uninitvar
2473 (void)std::wcscat(deststr_2,source);
2474
2475 // no warning shall be shown for
2476 (void)std::wcscat(dest,source);
2477 }
2478
uninivar_wcrtomb(void)2479 void uninivar_wcrtomb(void)
2480 {
2481 char *s;
2482 wchar_t wc;
2483 mbstate_t *ps;
2484 // cppcheck-suppress uninitvar
2485 (void)std::wcrtomb(s,wc,ps);
2486 }
2487
uninivar_strchr(void)2488 void uninivar_strchr(void)
2489 {
2490 char *cs;
2491 int c;
2492 // cppcheck-suppress uninitvar
2493 (void)std::strchr(cs,c);
2494 }
2495
uninivar_wcschr(void)2496 void uninivar_wcschr(void)
2497 {
2498 wchar_t *cs;
2499 wchar_t c;
2500 // cppcheck-suppress uninitvar
2501 (void)std::wcschr(cs,c);
2502 }
2503
uninivar_strcmp(void)2504 void uninivar_strcmp(void)
2505 {
2506 char *str1;
2507 char *str2;
2508 // cppcheck-suppress uninitvar
2509 (void)std::strcmp(str1,str2);
2510 }
2511
uninivar_wcscmp(void)2512 void uninivar_wcscmp(void)
2513 {
2514 wchar_t *str1;
2515 wchar_t *str2;
2516 // cppcheck-suppress uninitvar
2517 (void)std::wcscmp(str1,str2);
2518 }
2519
uninivar_strcpy(void)2520 void uninivar_strcpy(void)
2521 {
2522 char *str1;
2523 char *str2;
2524 // cppcheck-suppress uninitvar
2525 (void)std::strcpy(str1,str2);
2526 }
2527
uninivar_wcscpy(void)2528 void uninivar_wcscpy(void)
2529 {
2530 wchar_t *str1;
2531 wchar_t *str2;
2532 // cppcheck-suppress uninitvar
2533 (void)std::wcscpy(str1,str2);
2534 }
2535
uninivar_strftime(void)2536 void uninivar_strftime(void)
2537 {
2538 char *s;
2539 size_t max;
2540 char *fmt;
2541 struct tm *p;
2542 // cppcheck-suppress uninitvar
2543 (void)std::strftime(s,max,fmt,p);
2544 }
2545
uninivar_strlen(void)2546 void uninivar_strlen(void)
2547 {
2548 char *s;
2549 // cppcheck-suppress uninitvar
2550 (void)std::strlen(s);
2551 }
2552
uninivar_wcslen(void)2553 void uninivar_wcslen(void)
2554 {
2555 wchar_t *s;
2556 // cppcheck-suppress uninitvar
2557 (void)std::wcslen(s);
2558 }
2559
uninivar_strncpy(void)2560 void uninivar_strncpy(void)
2561 {
2562 char *s;
2563 char *ct;
2564 size_t n;
2565 // cppcheck-suppress uninitvar
2566 (void)std::strncpy(s,ct,n);
2567 }
2568
uninivar_strpbrk(void)2569 void uninivar_strpbrk(void)
2570 {
2571 char *cs;
2572 char *ct;
2573 // cppcheck-suppress uninitvar
2574 (void)std::strpbrk(cs,ct);
2575 }
2576
uninivar_strncat(char * Ct,char * S,size_t N)2577 void uninivar_strncat(char *Ct, char *S, size_t N)
2578 {
2579 char *ct_1, *ct_2;
2580 char *s;
2581 size_t n1, n2;
2582 // cppcheck-suppress uninitvar
2583 (void)std::strncat(ct_1,s,n1);
2584 // cppcheck-suppress uninitvar
2585 (void)std::strncat(ct_2,S,N);
2586 // cppcheck-suppress uninitvar
2587 (void)std::strncat(Ct,s,N);
2588 // cppcheck-suppress uninitvar
2589 (void)std::strncat(Ct,S,n2);
2590
2591 // no warning is expected for
2592 (void)std::strncat(Ct,S,N);
2593 }
2594
uninivar_wcsncat(wchar_t * Ct,wchar_t * S,size_t N)2595 void uninivar_wcsncat(wchar_t *Ct, wchar_t *S, size_t N)
2596 {
2597 wchar_t *ct_1, *ct_2;
2598 wchar_t *s;
2599 size_t n1, n2;
2600 // cppcheck-suppress uninitvar
2601 (void)std::wcsncat(ct_1,s,n1);
2602 // cppcheck-suppress uninitvar
2603 (void)std::wcsncat(ct_2,S,N);
2604 // cppcheck-suppress uninitvar
2605 (void)std::wcsncat(Ct,s,N);
2606 // cppcheck-suppress uninitvar
2607 (void)std::wcsncat(Ct,S,n2);
2608
2609 // no warning is expected for
2610 (void)std::wcsncat(Ct,S,N);
2611 }
2612
uninivar_strncmp(char * Ct,char * S,size_t N)2613 void uninivar_strncmp(char *Ct, char *S, size_t N)
2614 {
2615 char *ct;
2616 char *s;
2617 size_t n1, n2;
2618 // cppcheck-suppress uninitvar
2619 (void)std::strncmp(ct,s,n1);
2620 // cppcheck-suppress uninitvar
2621 (void)std::strncmp(ct,S,N);
2622 // cppcheck-suppress uninitvar
2623 (void)std::strncmp(Ct,s,N);
2624 // cppcheck-suppress uninitvar
2625 (void)std::strncmp(Ct,S,n2);
2626
2627 // no warning is expected for
2628 (void)std::strncmp(Ct,S,N);
2629 }
2630
uninivar_wcsncmp(wchar_t * Ct,wchar_t * S,size_t N)2631 void uninivar_wcsncmp(wchar_t *Ct, wchar_t *S, size_t N)
2632 {
2633 wchar_t *ct;
2634 wchar_t *s;
2635 size_t n1, n2;
2636 // cppcheck-suppress uninitvar
2637 (void)std::wcsncmp(ct,s,n1);
2638 // cppcheck-suppress uninitvar
2639 (void)std::wcsncmp(ct,S,N);
2640 // cppcheck-suppress uninitvar
2641 (void)std::wcsncmp(Ct,s,N);
2642 // cppcheck-suppress uninitvar
2643 (void)std::wcsncmp(Ct,S,n2);
2644
2645 // no warning is expected for
2646 (void)std::wcsncmp(Ct,S,N);
2647 }
2648
uninivar_strstr(void)2649 void uninivar_strstr(void)
2650 {
2651 char *cs;
2652 char *ct;
2653 // cppcheck-suppress uninitvar
2654 (void)std::strstr(cs,ct);
2655 }
2656
uninivar_wcsstr(void)2657 void uninivar_wcsstr(void)
2658 {
2659 wchar_t *cs;
2660 wchar_t *ct;
2661 // cppcheck-suppress uninitvar
2662 (void)std::wcsstr(cs,ct);
2663 }
2664
uninivar_strspn(void)2665 void uninivar_strspn(void)
2666 {
2667 char *cs;
2668 char *ct;
2669 // cppcheck-suppress uninitvar
2670 (void)std::strspn(cs,ct);
2671 }
2672
uninivar_strxfrm(void)2673 void uninivar_strxfrm(void)
2674 {
2675 char *ds;
2676 char *ss;
2677 size_t n;
2678 // cppcheck-suppress uninitvar
2679 (void)std::strxfrm(ds,ss,n);
2680 }
2681
uninivar_wcsxfrm(void)2682 void uninivar_wcsxfrm(void)
2683 {
2684 wchar_t *ds;
2685 wchar_t *ss;
2686 size_t n;
2687 // cppcheck-suppress uninitvar
2688 (void)std::wcsxfrm(ds,ss,n);
2689 }
2690
uninivar_wcsspn(void)2691 void uninivar_wcsspn(void)
2692 {
2693 wchar_t *ds;
2694 wchar_t *ss;
2695 // cppcheck-suppress uninitvar
2696 (void)std::wcsspn(ds,ss);
2697 }
2698
uninivar_setlocale(void)2699 void uninivar_setlocale(void)
2700 {
2701 int category;
2702 char* locale;
2703 // cppcheck-suppress uninitvar
2704 (void)std::setlocale(category,locale);
2705 }
uninivar_strerror(void)2706 void uninivar_strerror(void)
2707 {
2708 int i;
2709 // cppcheck-suppress uninitvar
2710 (void)std::strerror(i);
2711 }
2712
uninivar_strcspn(void)2713 void uninivar_strcspn(void)
2714 {
2715 char *cs;
2716 char *ct;
2717 // cppcheck-suppress uninitvar
2718 (void)std::strcspn(cs,ct);
2719 }
2720
uninivar_wcscspn(void)2721 void uninivar_wcscspn(void)
2722 {
2723 wchar_t *cs;
2724 wchar_t *ct;
2725 // cppcheck-suppress uninitvar
2726 (void)std::wcscspn(cs,ct);
2727 }
2728
uninivar_wcspbrk(void)2729 void uninivar_wcspbrk(void)
2730 {
2731 wchar_t *cs;
2732 wchar_t *ct;
2733 // cppcheck-suppress uninitvar
2734 (void)std::wcspbrk(cs,ct);
2735 }
2736
uninivar_wcsncpy(void)2737 void uninivar_wcsncpy(void)
2738 {
2739 wchar_t *cs;
2740 wchar_t *ct;
2741 size_t n;
2742 // cppcheck-suppress uninitvar
2743 (void)std::wcsncpy(cs,ct,n);
2744 }
2745
uninivar_strcoll(void)2746 void uninivar_strcoll(void)
2747 {
2748 char *cs;
2749 char *ct;
2750 // cppcheck-suppress uninitvar
2751 (void)std::strcoll(cs,ct);
2752 }
2753
uninivar_wcscoll(void)2754 void uninivar_wcscoll(void)
2755 {
2756 wchar_t *cs;
2757 wchar_t *ct;
2758 // cppcheck-suppress uninitvar
2759 (void)std::wcscoll(cs,ct);
2760 }
2761
uninivar_strrchr(void)2762 void uninivar_strrchr(void)
2763 {
2764 char * str;
2765 int c;
2766 // cppcheck-suppress uninitvar
2767 (void)std::strrchr(str,c);
2768 }
2769
uninivar_wcsrchr(void)2770 void uninivar_wcsrchr(void)
2771 {
2772 wchar_t* ws;
2773 wchar_t wc;
2774 // cppcheck-suppress uninitvar
2775 (void)std::wcsrchr(ws,wc);
2776 }
2777
uninivar_wcsrtombs(void)2778 void uninivar_wcsrtombs(void)
2779 {
2780 char *dst;
2781 const wchar_t * p;;
2782 size_t len;
2783 mbstate_t *ps;
2784 // cppcheck-suppress uninitvar
2785 (void)std::wcsrtombs(dst,&p,len,ps);
2786 }
2787
uninivar_strtok(void)2788 void uninivar_strtok(void)
2789 {
2790 char *s;
2791 char *ct;
2792 // cppcheck-suppress uninitvar
2793 (void)std::strtok(s,ct);
2794 }
2795
uninivar_strtoimax(void)2796 void uninivar_strtoimax(void)
2797 {
2798 const char *s;
2799 char **endp;
2800 int base;
2801 // cppcheck-suppress uninitvar
2802 (void)std::strtoimax(s,endp,base);
2803 // cppcheck-suppress uninitvar
2804 (void)std::strtoumax(s,endp,base);
2805 }
2806
uninivar_strtof(void)2807 void uninivar_strtof(void)
2808 {
2809 const char *s;
2810 char **endp;
2811 // cppcheck-suppress uninitvar
2812 (void)std::strtof(s,endp);
2813 // cppcheck-suppress uninitvar
2814 (void)std::strtod(s,endp);
2815 // cppcheck-suppress uninitvar
2816 (void)std::strtold(s,endp);
2817 }
2818
uninivar_strtol(void)2819 void uninivar_strtol(void)
2820 {
2821 const char *s;
2822 char **endp;
2823 int base;
2824 // cppcheck-suppress uninitvar
2825 (void)std::strtol(s,endp,base);
2826 // cppcheck-suppress uninitvar
2827 (void)std::strtoll(s,endp,base);
2828 // cppcheck-suppress uninitvar
2829 (void)std::strtoul(s,endp,base);
2830 // cppcheck-suppress uninitvar
2831 (void)std::strtoull(s,endp,base);
2832 // cppcheck-suppress uninitvar
2833 (void)std::strtoimax(s,endp,base);
2834 // cppcheck-suppress uninitvar
2835 (void)strtoimax(s,endp,base);
2836 // cppcheck-suppress uninitvar
2837 (void)std::strtoumax(s,endp,base);
2838 // cppcheck-suppress uninitvar
2839 (void)strtoumax(s,endp,base);
2840 }
2841
uninitvar_time(void)2842 void uninitvar_time(void)
2843 {
2844 time_t *tp;
2845 // cppcheck-suppress uninitvar
2846 (void)std::time(tp);
2847 }
2848
uninitvar_tmpnam(void)2849 void uninitvar_tmpnam(void)
2850 {
2851 char *s;
2852 // cppcheck-suppress uninitvar
2853 (void)std::tmpnam(s);
2854 }
2855
uninivar_tolower(void)2856 void uninivar_tolower(void)
2857 {
2858 int c;
2859 // cppcheck-suppress uninitvar
2860 (void)std::tolower(c);
2861 }
2862
uninivar_toupper(void)2863 void uninivar_toupper(void)
2864 {
2865 int c;
2866 // cppcheck-suppress uninitvar
2867 (void)std::toupper(c);
2868 }
2869
uninivar_wcstof(void)2870 void uninivar_wcstof(void)
2871 {
2872 const wchar_t *s;
2873 wchar_t **endp;
2874 // cppcheck-suppress uninitvar
2875 (void)std::wcstof(s,endp);
2876 // cppcheck-suppress uninitvar
2877 (void)std::wcstod(s,endp);
2878 // cppcheck-suppress uninitvar
2879 (void)std::wcstold(s,endp);
2880 }
2881
uninivar_stoX(void)2882 void uninivar_stoX(void)
2883 {
2884 std::string str;
2885 std::wstring wstr;
2886 size_t* idx1;
2887 size_t* idx2;
2888 size_t* idx3;
2889 size_t* idx4;
2890 size_t* idx5;
2891 size_t* idx6;
2892 size_t* idx7;
2893 size_t* idx8;
2894 size_t* idx9;
2895 size_t* idx10;
2896 size_t* idx11;
2897 size_t* idx12;
2898 size_t* idx13;
2899 size_t* idx14;
2900 size_t* idx15;
2901 size_t* idx16;
2902 // cppcheck-suppress uninitvar
2903 (void)std::stod(str,idx1);
2904 // cppcheck-suppress uninitvar
2905 (void)std::stod(wstr,idx2);
2906 // cppcheck-suppress uninitvar
2907 (void)std::stof(str,idx3);
2908 // cppcheck-suppress uninitvar
2909 (void)std::stof(wstr,idx4);
2910 // cppcheck-suppress uninitvar
2911 (void)std::stoi(str,idx5);
2912 // cppcheck-suppress uninitvar
2913 (void)std::stoi(wstr,idx6);
2914 // cppcheck-suppress uninitvar
2915 (void)std::stol(str,idx7);
2916 // cppcheck-suppress uninitvar
2917 (void)std::stol(wstr,idx8);
2918 // cppcheck-suppress uninitvar
2919 (void)std::stold(str,idx9);
2920 // cppcheck-suppress uninitvar
2921 (void)std::stold(wstr,idx10);
2922 // cppcheck-suppress uninitvar
2923 (void)std::stoll(str,idx11);
2924 // cppcheck-suppress uninitvar
2925 (void)std::stoll(wstr,idx12);
2926 // cppcheck-suppress uninitvar
2927 (void)std::stoul(str,idx13);
2928 // cppcheck-suppress uninitvar
2929 (void)std::stoul(wstr,idx14);
2930 // cppcheck-suppress uninitvar
2931 (void)std::stoull(str,idx15);
2932 // cppcheck-suppress uninitvar
2933 (void)std::stoull(wstr,idx16);
2934 }
2935
uninivar_to_string(void)2936 void uninivar_to_string(void)
2937 {
2938 int i;
2939 long l;
2940 long long ll;
2941 unsigned u;
2942 unsigned long ul;
2943 unsigned long long ull;
2944 float f;
2945 double d;
2946 long double ld;
2947 // cppcheck-suppress uninitvar
2948 (void)std::to_string(i);
2949 // cppcheck-suppress uninitvar
2950 (void)std::to_string(l);
2951 // cppcheck-suppress uninitvar
2952 (void)std::to_string(ll);
2953 // cppcheck-suppress uninitvar
2954 (void)std::to_string(u);
2955 // cppcheck-suppress uninitvar
2956 (void)std::to_string(ul);
2957 // cppcheck-suppress uninitvar
2958 (void)std::to_string(ull);
2959 // cppcheck-suppress uninitvar
2960 (void)std::to_string(f);
2961 // cppcheck-suppress uninitvar
2962 (void)std::to_string(d);
2963 // cppcheck-suppress uninitvar
2964 (void)std::to_string(ld);
2965 }
2966
uninivar_to_wstring(void)2967 void uninivar_to_wstring(void)
2968 {
2969 int i;
2970 long l;
2971 long long ll;
2972 unsigned u;
2973 unsigned long ul;
2974 unsigned long long ull;
2975 float f;
2976 double d;
2977 long double ld;
2978 // cppcheck-suppress uninitvar
2979 (void)std::to_wstring(i);
2980 // cppcheck-suppress uninitvar
2981 (void)std::to_wstring(l);
2982 // cppcheck-suppress uninitvar
2983 (void)std::to_wstring(ll);
2984 // cppcheck-suppress uninitvar
2985 (void)std::to_wstring(u);
2986 // cppcheck-suppress uninitvar
2987 (void)std::to_wstring(ul);
2988 // cppcheck-suppress uninitvar
2989 (void)std::to_wstring(ull);
2990 // cppcheck-suppress uninitvar
2991 (void)std::to_wstring(f);
2992 // cppcheck-suppress uninitvar
2993 (void)std::to_wstring(d);
2994 // cppcheck-suppress uninitvar
2995 (void)std::to_wstring(ld);
2996 }
2997
uninivar_mbrtowc(void)2998 void uninivar_mbrtowc(void)
2999 {
3000 wchar_t* pwc;
3001 const char* pmb;
3002 size_t max;
3003 mbstate_t* ps;
3004 // cppcheck-suppress uninitvar
3005 (void)std::mbrtowc(pwc,pmb,max,ps);
3006 }
3007
uninivar_wcstok(void)3008 void uninivar_wcstok(void)
3009 {
3010 wchar_t *s;
3011 const wchar_t *ct;
3012 wchar_t **ptr;
3013 // cppcheck-suppress uninitvar
3014 (void)std::wcstok(s,ct,ptr);
3015 }
3016
uninivar_wcstoimax(void)3017 void uninivar_wcstoimax(void)
3018 {
3019 const wchar_t *s;
3020 wchar_t ** endp;
3021 int base;
3022 // cppcheck-suppress uninitvar
3023 (void)std::wcstoimax(s,endp,base);
3024 // cppcheck-suppress uninitvar
3025 (void)std::wcstoumax(s,endp,base);
3026 }
3027
uninivar_wcstol(void)3028 void uninivar_wcstol(void)
3029 {
3030 const wchar_t *s;
3031 wchar_t ** endp;
3032 int base;
3033 // cppcheck-suppress uninitvar
3034 (void)std::wcstol(s,endp,base);
3035 // cppcheck-suppress uninitvar
3036 (void)std::wcstoll(s,endp,base);
3037 // cppcheck-suppress uninitvar
3038 (void)std::wcstoul(s,endp,base);
3039 // cppcheck-suppress uninitvar
3040 (void)std::wcstoull(s,endp,base);
3041 // cppcheck-suppress uninitvar
3042 (void)std::wcstoimax(s,endp,base);
3043 // cppcheck-suppress uninitvar
3044 (void)wcstoimax(s,endp,base);
3045 // cppcheck-suppress uninitvar
3046 (void)std::wcstoumax(s,endp,base);
3047 // cppcheck-suppress uninitvar
3048 (void)wcstoumax(s,endp,base);
3049 }
3050
uninitvar_wprintf(wchar_t * Format,int Argument)3051 void uninitvar_wprintf(wchar_t *Format, int Argument)
3052 {
3053 const wchar_t *format;
3054 int argument1, argument2;
3055 // cppcheck-suppress uninitvar
3056 (void)std::wprintf(format,argument1);
3057 // cppcheck-suppress uninitvar
3058 (void)std::wprintf(format);
3059 // cppcheck-suppress uninitvar
3060 (void)std::wprintf(Format,argument2);
3061 // cppcheck-suppress uninitvar
3062 (void)std::wprintf(format,Argument);
3063 // no warning is expected
3064 (void)std::wprintf(Format,Argument);
3065 (void)std::wprintf(Format);
3066 }
3067
uninitvar_sprintf(void)3068 void uninitvar_sprintf(void)
3069 {
3070 char *s;
3071 const char *format;
3072 int i;
3073 // cppcheck-suppress uninitvar
3074 (void)std::sprintf(s,format,i);
3075 }
3076
uninitvar_swprintf(void)3077 void uninitvar_swprintf(void)
3078 {
3079 wchar_t *s;
3080 size_t n;
3081 const wchar_t *format;
3082 // cppcheck-suppress uninitvar
3083 (void)std::swprintf(s,n,format);
3084 }
3085
uninitvar_vsprintf(void)3086 void uninitvar_vsprintf(void)
3087 {
3088 char *s;
3089 const char *format;
3090 va_list arg;
3091 // cppcheck-suppress va_list_usedBeforeStarted
3092 // cppcheck-suppress uninitvar
3093 (void)std::vsprintf(s,format,arg);
3094 }
3095
nullPointer_vsprintf(va_list arg,const char * format)3096 void nullPointer_vsprintf(va_list arg,const char *format)
3097 {
3098 char *s = NULL;
3099 (void)std::vsprintf(s,format,arg); // Its allowed to provide 's' as NULL pointer
3100 // cppcheck-suppress nullPointer
3101 (void)std::vsprintf(s,NULL,arg);
3102 }
3103
uninitvar_vswprintf(void)3104 void uninitvar_vswprintf(void)
3105 {
3106 wchar_t *s;
3107 size_t n;
3108 const wchar_t *format;
3109 va_list arg;
3110 // cppcheck-suppress va_list_usedBeforeStarted
3111 // cppcheck-suppress uninitvar
3112 (void)std::vswprintf(s,n,format,arg);
3113 }
3114
uninivar_fwprintf(void)3115 void uninivar_fwprintf(void)
3116 {
3117 FILE* stream;
3118 const wchar_t* format;
3119 int i;
3120 // cppcheck-suppress uninitvar
3121 (void)std::fwprintf(stream,format,i);
3122 }
3123
uninivar_snprintf(char * S,size_t N,char * Format,int Int)3124 void uninivar_snprintf(char *S, size_t N, char *Format, int Int)
3125 {
3126 size_t n1, n2;
3127 char *format;
3128 int i1, i2;
3129 char *s1, *s2;
3130 // cppcheck-suppress uninitvar
3131 (void)std::snprintf(s1,n1,format,i1);
3132 // cppcheck-suppress uninitvar
3133 (void)std::snprintf(S,n2,Format,Int); // n is uninitialized
3134 // cppcheck-suppress uninitvar
3135 (void)std::snprintf(S,N,format,Int); // format is uninitialized
3136 // cppcheck-suppress uninitvar
3137 (void)std::snprintf(S,N,Format,i2); // i is uninitialized
3138 // cppcheck-suppress uninitvar
3139 (void)std::snprintf(s2,N,Format,Int);
3140
3141 // no warning is expected for
3142 (void)std::snprintf(S,N,Format,Int);
3143 }
3144
uninivar_vsnprintf(char * S,size_t N,char * Format,va_list Arg)3145 void uninivar_vsnprintf(char *S, size_t N, char *Format, va_list Arg)
3146 {
3147 char *s1, *s2;
3148 size_t n1, n2;
3149 char *format;
3150 va_list arg;
3151 // cppcheck-suppress va_list_usedBeforeStarted
3152 // cppcheck-suppress uninitvar
3153 (void)std::vsnprintf(s1,n1,format,arg);
3154 // cppcheck-suppress uninitvar
3155 (void)std::vsnprintf(s2,N,Format,Arg);
3156 // cppcheck-suppress uninitvar
3157 (void)std::vsnprintf(S,n2,Format,Arg);
3158 // cppcheck-suppress uninitvar
3159 (void)std::vsnprintf(S,N,format,Arg);
3160
3161 // no warning is expected for
3162 (void)std::vsnprintf(S,N,Format,Arg);
3163 // cppcheck-suppress va_list_usedBeforeStarted
3164 (void)std::vsnprintf(S,N,Format,arg);
3165 }
3166
uninivar_wscanf(void)3167 void uninivar_wscanf(void)
3168 {
3169 wchar_t *format;
3170 int i;
3171 // cppcheck-suppress uninitvar
3172 (void)std::wscanf(format);
3173 // cppcheck-suppress uninitvar
3174 (void)std::wscanf(format,&i);
3175 }
3176
uninivar_sscanf(void)3177 void uninivar_sscanf(void)
3178 {
3179 char *string;
3180 const char * format;
3181 int i;
3182 // cppcheck-suppress uninitvar
3183 (void)std::sscanf(string,format);
3184 // cppcheck-suppress uninitvar
3185 (void)std::sscanf(string,format,&i);
3186 }
3187
uninivar_fwscanf(void)3188 void uninivar_fwscanf(void)
3189 {
3190 FILE* stream;
3191 wchar_t* format1, *format2;
3192 int i;
3193 // cppcheck-suppress uninitvar
3194 (void)std::fwscanf(stream,format1);
3195 // cppcheck-suppress uninitvar
3196 (void)std::fwscanf(stream,format2,&i);
3197 }
3198
uninivar_swscanf(void)3199 void uninivar_swscanf(void)
3200 {
3201 wchar_t* s;
3202 wchar_t* format1, *format2;
3203 int i;
3204 // cppcheck-suppress uninitvar
3205 (void)std::swscanf(s,format1);
3206 // cppcheck-suppress uninitvar
3207 (void)std::swscanf(s,format2,&i);
3208 }
3209
uninitvar_system(void)3210 void uninitvar_system(void)
3211 {
3212 char *c;
3213 // cppcheck-suppress uninitvar
3214 (void)std::system(c);
3215 }
3216
uninitvar_setw(void)3217 void uninitvar_setw(void)
3218 {
3219 int i;
3220 // cppcheck-suppress uninitvar
3221 std::cout << std::setw(i);
3222 }
3223
uninitvar_setiosflags(void)3224 void uninitvar_setiosflags(void)
3225 {
3226 std::ios_base::fmtflags mask;
3227 // TODO cppcheck-suppress uninitvar
3228 std::cout << std::setiosflags(mask); // #6987 - false negative
3229 }
3230
uninitvar_resetiosflags(void)3231 void uninitvar_resetiosflags(void)
3232 {
3233 std::ios_base::fmtflags mask;
3234 // TODO cppcheck-suppress uninitvar
3235 std::cout << std::resetiosflags(mask); // #6987 - false negative
3236 }
3237
uninitvar_setfill(void)3238 void uninitvar_setfill(void)
3239 {
3240 char c;
3241 // cppcheck-suppress uninitvar
3242 std::cout << std::setfill(c);
3243
3244 wchar_t wc;
3245 // cppcheck-suppress uninitvar
3246 std::wcout << std::setfill(wc);
3247 }
3248
uninitvar_setprecision(void)3249 void uninitvar_setprecision(void)
3250 {
3251 int p;
3252 // cppcheck-suppress uninitvar
3253 std::cout << std::setprecision(p);
3254 }
3255
uninitvar_setbase(void)3256 void uninitvar_setbase(void)
3257 {
3258 int p;
3259 // cppcheck-suppress uninitvar
3260 std::cout << std::setbase(p);
3261 }
3262
uninitvar_find(std::string s)3263 void uninitvar_find(std::string s)
3264 {
3265 // testing of size_t find (const string& str, size_t pos = 0)
3266 size_t pos1, pos2, pos3, pos4, pos5, pos6, pos7;
3267 // cppcheck-suppress uninitvar
3268 (void)s.find("find",pos1); // #6991
3269
3270 // testing of size_t find (const char* s, size_t pos = 0) const;
3271 char *pc, *pc2;
3272 // cppcheck-suppress uninitvar
3273 (void)s.find(pc,0);
3274 // cppcheck-suppress uninitvar
3275 (void)s.find(pc,pos2);
3276 // cppcheck-suppress uninitvar
3277 (void)s.find("test",pos3);
3278
3279 // testing of size_t find (char c, size_t pos = 0) const;
3280 char c;
3281 // cppcheck-suppress uninitvar
3282 (void)s.find(c,pos4);
3283
3284 // testing of size_t find (const char* pc, size_t pos, size_t n) const;
3285 size_t n1,n2,n3;
3286 // cppcheck-suppress uninitvar
3287 (void)s.find(pc,pos5,n1); // #6991
3288 // cppcheck-suppress uninitvar
3289 (void)s.find("test",pos6,n2);
3290 // cppcheck-suppress uninitvar
3291 (void)s.find("test",1,n3);
3292 // cppcheck-suppress uninitvar
3293 (void)s.find("test",pos7,1);
3294 // cppcheck-suppress uninitvar
3295 (void)s.find(pc2,1,1);
3296 }
3297
uninivar_ifstream_read(std::ifstream & f)3298 void uninivar_ifstream_read(std::ifstream &f)
3299 {
3300 int size;
3301 char buffer[10];
3302 // cppcheck-suppress uninitvar
3303 f.read(buffer, size);
3304 }
3305
uninivar_istream_read(std::istream & f)3306 void uninivar_istream_read(std::istream &f)
3307 {
3308 int size;
3309 char buffer[10];
3310 // cppcheck-suppress uninitvar
3311 f.read(buffer, size);
3312 }
3313
uninitvar_string_compare(std::string & teststr,std::wstring & testwstr)3314 void uninitvar_string_compare(std::string &teststr, std::wstring &testwstr)
3315 {
3316 char *pStrUninit;
3317 // cppcheck-suppress uninitvar
3318 (void)teststr.compare(pStrUninit);
3319
3320 wchar_t *pWStrUninit;
3321 // cppcheck-suppress uninitvar
3322 (void)testwstr.compare(pWStrUninit);
3323 }
3324
invalidFunctionArgBool_abs(bool b,double x,double y)3325 void invalidFunctionArgBool_abs(bool b, double x, double y)
3326 {
3327 // cppcheck-suppress invalidFunctionArgBool
3328 (void)std::abs(true); // #6990
3329 // cppcheck-suppress invalidFunctionArgBool
3330 (void)std::abs(b); // #6990
3331 // cppcheck-suppress invalidFunctionArgBool
3332 (void)std::abs(x<y); // #5635
3333 }
3334
ignoredReturnValue_abs(int i)3335 void ignoredReturnValue_abs(int i)
3336 {
3337 // cppcheck-suppress ignoredReturnValue
3338 std::abs(i);
3339 // cppcheck-suppress ignoredReturnValue
3340 std::abs(-199);
3341 }
3342
ignoredReturnValue_string_compare(std::string teststr,std::wstring testwstr)3343 void ignoredReturnValue_string_compare(std::string teststr, std::wstring testwstr)
3344 {
3345 // cppcheck-suppress ignoredReturnValue
3346 teststr.compare("test");
3347 // cppcheck-suppress ignoredReturnValue
3348 testwstr.compare(L"wtest");
3349 }
3350
ignoredReturnValue_locale_global(const std::locale & loc)3351 void ignoredReturnValue_locale_global(const std::locale& loc)
3352 {
3353 // no ignoredReturnValue shall be shown for
3354 std::locale::global(loc);
3355 }
3356
ignoredReturnValue_make_pair()3357 void ignoredReturnValue_make_pair()
3358 {
3359 // cppcheck-suppress ignoredReturnValue
3360 std::make_pair(1, 2);
3361 }
3362
nullPointer_ifstream_read(std::ifstream & f)3363 void nullPointer_ifstream_read(std::ifstream &f)
3364 {
3365 // cppcheck-suppress nullPointer
3366 f.read(NULL, 10);
3367 }
3368
nullPointer_istream_read(std::istream & f)3369 void nullPointer_istream_read(std::istream &f)
3370 {
3371 // cppcheck-suppress nullPointer
3372 f.read(NULL, 10);
3373 }
3374
nullPointer_asctime(void)3375 void nullPointer_asctime(void)
3376 {
3377 struct tm *tm = 0;
3378 // cppcheck-suppress asctimeCalled
3379 // cppcheck-suppress nullPointer
3380 (void)std::asctime(tm);
3381 // cppcheck-suppress asctimeCalled
3382 // cppcheck-suppress nullPointer
3383 (void)std::asctime(0);
3384 }
3385
nullPointer_wcsftime(size_t maxsize)3386 void nullPointer_wcsftime(size_t maxsize)
3387 {
3388 wchar_t* ptr = 0;
3389 wchar_t* format = 0;
3390 struct tm* timeptr = 0;
3391 // cppcheck-suppress nullPointer
3392 (void)std::wcsftime(ptr,maxsize,format,timeptr);
3393 // cppcheck-suppress nullPointer
3394 (void)std::wcsftime(0,maxsize,0,0);
3395 }
3396
nullPointer_fegetenv(void)3397 void nullPointer_fegetenv(void)
3398 {
3399 fenv_t* envp = 0;
3400 // cppcheck-suppress nullPointer
3401 (void)std::fegetenv(envp);
3402 // cppcheck-suppress nullPointer
3403 (void)std::fegetenv(0);
3404 }
3405
nullPointer_fegetexceptflag(int expects)3406 void nullPointer_fegetexceptflag(int expects)
3407 {
3408 fexcept_t* flagp = 0;
3409 // cppcheck-suppress nullPointer
3410 (void)std::fegetexceptflag(flagp,expects);
3411 // cppcheck-suppress nullPointer
3412 (void)std::fegetexceptflag(0,expects);
3413 }
3414
nullPointer_feholdexcept(void)3415 void nullPointer_feholdexcept(void)
3416 {
3417 fenv_t* envp = 0;
3418 // cppcheck-suppress nullPointer
3419 (void)std::feholdexcept(envp);
3420 // cppcheck-suppress nullPointer
3421 (void)std::feholdexcept(0);
3422 }
3423
nullPointer_fesetenv(void)3424 void nullPointer_fesetenv(void)
3425 {
3426 fenv_t* envp = 0;
3427 // cppcheck-suppress nullPointer
3428 (void)std::fesetenv(envp);
3429 // cppcheck-suppress nullPointer
3430 (void)std::fesetenv(0);
3431 }
3432
nullPointer_fesetexceptflag(int expects)3433 void nullPointer_fesetexceptflag(int expects)
3434 {
3435 fexcept_t* flagp = 0;
3436 // cppcheck-suppress nullPointer
3437 (void)std::fesetexceptflag(flagp,expects);
3438 // cppcheck-suppress nullPointer
3439 (void)std::fesetexceptflag(0,expects);
3440 }
3441
nullPointer_feupdateenv(void)3442 void nullPointer_feupdateenv(void)
3443 {
3444 fenv_t* envp = 0;
3445 // cppcheck-suppress nullPointer
3446 (void)std::feupdateenv(envp);
3447 // cppcheck-suppress nullPointer
3448 (void)std::feupdateenv(0);
3449 }
3450
nullPointer_atexit(void)3451 void nullPointer_atexit(void)
3452 {
3453 // cppcheck-suppress nullPointer
3454 (void)std::atexit(0);
3455 }
3456
nullPointer_atof(void)3457 void nullPointer_atof(void)
3458 {
3459 char * c = 0;
3460 // cppcheck-suppress nullPointer
3461 (void)std::atof(c);
3462 // cppcheck-suppress nullPointer
3463 (void)std::atof(0);
3464 }
3465
nullPointer_memcmp(char * p)3466 void nullPointer_memcmp(char *p)
3467 {
3468 // cppcheck-suppress nullPointer
3469 (void)std::memcmp(p, 0, 123);
3470 }
3471
nullPointer_wmemcmp(wchar_t * p)3472 void nullPointer_wmemcmp(wchar_t *p)
3473 {
3474 // cppcheck-suppress nullPointer
3475 (void)std::wmemcmp(p, 0, 123);
3476 }
3477
3478 ///////////////////////////////////////////////////////////////////////
3479 // <algorithm>
3480 ///////////////////////////////////////////////////////////////////////
3481
3482 #include <algorithm>
3483 #include <list>
3484
3485 #define pred [] (int i) {return i==0;}
3486
3487
stdalgorithm(const std::list<int> & ints1,const std::list<int> & ints2)3488 void stdalgorithm(const std::list<int> &ints1, const std::list<int> &ints2)
3489 {
3490 // <!-- InputIterator std::find(InputIterator first, InputIterator last, T val) -->
3491 // cppcheck-suppress mismatchingContainers
3492 // cppcheck-suppress ignoredReturnValue
3493 std::find(ints1.begin(), ints2.end(), 123);
3494 // cppcheck-suppress mismatchingContainers
3495 if (std::find(ints1.begin(), ints1.end(), 123) == ints2.end()) {}
3496
3497 // #9455
3498 std::list<int>::const_iterator uninitItBegin;
3499 std::list<int>::const_iterator uninitItEnd;
3500 // @todo cppcheck-suppress uninitvar
3501 if (std::find(uninitItBegin, uninitItEnd, 123) == uninitItEnd) {}
3502
3503 // <!-- InputIterator std::find_if(InputIterator first, InputIterator last, UnaryPredicate val) -->
3504 // cppcheck-suppress mismatchingContainers
3505 // cppcheck-suppress ignoredReturnValue
3506 std::find_if(ints1.begin(), ints2.end(), pred);
3507 // cppcheck-suppress mismatchingContainers
3508 if (std::find_if(ints1.begin(), ints1.end(), pred) == ints2.end()) {}
3509
3510 // <!-- InputIterator std::find_if_not(InputIterator first, InputIterator last, UnaryPredicate val) -->
3511 // cppcheck-suppress mismatchingContainers
3512 // cppcheck-suppress ignoredReturnValue
3513 std::find_if_not(ints1.begin(), ints2.end(), pred);
3514 // cppcheck-suppress mismatchingContainers
3515 if (std::find_if_not(ints1.begin(), ints1.end(), pred) == ints2.end()) {}
3516
3517 // <!-- bool std::all_of(InputIterator first, InputIterator last, UnaryPredicate pred) -->
3518 // cppcheck-suppress mismatchingContainers
3519 // cppcheck-suppress ignoredReturnValue
3520 std::all_of(ints1.begin(), ints2.end(), pred);
3521
3522 // <!-- bool std::any_of(InputIterator first, InputIterator last, UnaryPredicate pred) -->
3523 // cppcheck-suppress mismatchingContainers
3524 // cppcheck-suppress ignoredReturnValue
3525 std::any_of(ints1.begin(), ints2.end(), pred);
3526
3527 // <!-- bool std::none_of(InputIterator first, InputIterator last, UnaryPredicate pred) -->
3528 // cppcheck-suppress mismatchingContainers
3529 // cppcheck-suppress ignoredReturnValue
3530 std::none_of(ints1.begin(), ints2.end(), pred);
3531
3532 // <!-- difference_type std::count(InputIterator first, InputIterator last, T val) -->
3533 // cppcheck-suppress mismatchingContainers
3534 // cppcheck-suppress ignoredReturnValue
3535 std::count(ints1.begin(), ints2.end(), 123);
3536
3537 // <!-- difference_type std::count_if(InputIterator first, InputIterator last, UnaryPredicate val) -->
3538 // cppcheck-suppress mismatchingContainers
3539 // cppcheck-suppress ignoredReturnValue
3540 std::count_if(ints1.begin(), ints2.end(), pred);
3541
3542 // <!-- Function std::for_each(InputIterator first, InputIterator last, Function func) -->
3543 // cppcheck-suppress mismatchingContainers
3544 std::for_each(ints1.begin(), ints2.end(), [](int i) {});
3545 }
3546
getline()3547 void getline()
3548 {
3549 // #837
3550 std::ifstream in("test1.txt");
3551
3552 char cBuf[10];
3553 // cppcheck-suppress bufferAccessOutOfBounds
3554 in.getline(cBuf, 100);
3555 // cppcheck-suppress bufferAccessOutOfBounds
3556 in.read(cBuf, 100);
3557 // cppcheck-suppress bufferAccessOutOfBounds
3558 in.readsome(cBuf, 100);
3559 // cppcheck-suppress bufferAccessOutOfBounds
3560 in.get(cBuf, 100);
3561 // cppcheck-suppress bufferAccessOutOfBounds
3562 in.get(cBuf, 100, 'a');
3563 // cppcheck-suppress bufferAccessOutOfBounds
3564 in.getline(cBuf, 100, 'a');
3565
3566 in.close();
3567 }
3568
stdstring()3569 void stdstring()
3570 {
3571 std::string s;
3572 // cppcheck-suppress ignoredReturnValue
3573 s.size();
3574
3575 // valid
3576 s.assign("a");
3577 }
3578
stdvector()3579 void stdvector()
3580 {
3581 int uninit1, uninit2, uninit3;
3582 std::vector<int> v;
3583 // cppcheck-suppress ignoredReturnValue
3584 v.size();
3585 // cppcheck-suppress ignoredReturnValue
3586 v.capacity();
3587 // cppcheck-suppress uselessCallsEmpty
3588 // cppcheck-suppress ignoredReturnValue
3589 v.empty();
3590 // cppcheck-suppress ignoredReturnValue
3591 v.max_size();
3592 // cppcheck-suppress uninitvar
3593 v.push_back(uninit1);
3594 // cppcheck-suppress uninitvar
3595 v.reserve(uninit2);
3596 // cppcheck-suppress invalidFunctionArg
3597 v.reserve(-1);
3598 // no warning is expected for capacity 0 as it simply has no effect
3599 v.reserve(0);
3600 // cppcheck-suppress uninitvar
3601 v.resize(uninit3);
3602 // cppcheck-suppress invalidFunctionArg
3603 v.resize(-1);
3604
3605 v.clear();
3606 v.shrink_to_fit();
3607
3608 // no warning is expected for pop_back()
3609 v.push_back(42);
3610 v.pop_back();
3611
3612 v.push_back(42);
3613 // cppcheck-suppress ignoredReturnValue
3614 v.back();
3615 // cppcheck-suppress ignoredReturnValue
3616 v.front();
3617 }
3618
stdbind_helper(int a)3619 void stdbind_helper(int a)
3620 {
3621 printf("%d", a);
3622 }
3623
stdbind()3624 void stdbind()
3625 {
3626 using namespace std::placeholders;
3627
3628 // TODO cppcheck-suppress ignoredReturnValue #9369
3629 std::bind(stdbind_helper, 1);
3630
3631 // cppcheck-suppress unreadVariable
3632 auto f1 = std::bind(stdbind_helper, _1);
3633 // cppcheck-suppress unreadVariable
3634 auto f2 = std::bind(stdbind_helper, 10);
3635 }
3636