image.c:winpr_Data_Write_UINT8: 221| 498| { 222| 498| WINPR_ASSERT(d); ------------------ | | 76| 498|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 498| do \ | | | | 61| 498| { \ | | | | 62| 498| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 498| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 498| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 498| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 498| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 498| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 498| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 498| \ | | | | 70| 498| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 498| do \ | | | | | | 32| 498| { \ | | | | | | 33| 498| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 498] | | | | | | ------------------ | | | | | | 34| 498| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 498| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 498] | | | | | | ------------------ | | | | ------------------ | | | | 71| 498| \ | | | | 72| 498| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 498| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 498| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 498| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 498] | | | | ------------------ | | ------------------ ------------------ 223| 498| BYTE* b = WINPR_ENDIAN_CAST(BYTE*, d); ------------------ | | 31| 498|#define WINPR_ENDIAN_CAST(t, val) WINPR_CXX_COMPAT_CAST(t, val) | | ------------------ | | | | 34| 498|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ ------------------ 224| 498| *b = v; 225| 498| } image.c:winpr_Data_Write_UINT32: 258| 1.74k| { 259| 1.74k| WINPR_ASSERT(d); ------------------ | | 76| 1.74k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1.74k| do \ | | | | 61| 1.74k| { \ | | | | 62| 1.74k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1.74k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1.74k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1.74k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1.74k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1.74k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1.74k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1.74k| \ | | | | 70| 1.74k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1.74k| do \ | | | | | | 32| 1.74k| { \ | | | | | | 33| 1.74k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1.74k] | | | | | | ------------------ | | | | | | 34| 1.74k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1.74k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1.74k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1.74k| \ | | | | 72| 1.74k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1.74k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1.74k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1.74k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1.74k] | | | | ------------------ | | ------------------ ------------------ 260| 1.74k| BYTE* b = WINPR_ENDIAN_CAST(BYTE*, d); ------------------ | | 31| 1.74k|#define WINPR_ENDIAN_CAST(t, val) WINPR_CXX_COMPAT_CAST(t, val) | | ------------------ | | | | 34| 1.74k|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ ------------------ 261| 1.74k| winpr_Data_Write_UINT16(b, v & 0xFFFF); 262| 1.74k| winpr_Data_Write_UINT16(b + 2, (v >> 16) & 0xFFFF); 263| 1.74k| } image.c:winpr_Data_Write_UINT16: 235| 6.47k| { 236| 6.47k| WINPR_ASSERT(d); ------------------ | | 76| 6.47k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 6.47k| do \ | | | | 61| 6.47k| { \ | | | | 62| 6.47k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 6.47k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 6.47k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 6.47k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 6.47k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 6.47k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 6.47k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 6.47k| \ | | | | 70| 6.47k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 6.47k| do \ | | | | | | 32| 6.47k| { \ | | | | | | 33| 6.47k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 6.47k] | | | | | | ------------------ | | | | | | 34| 6.47k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 6.47k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 6.47k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 6.47k| \ | | | | 72| 6.47k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 6.47k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 6.47k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 6.47k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 6.47k] | | | | ------------------ | | ------------------ ------------------ 237| 6.47k| BYTE* b = WINPR_ENDIAN_CAST(BYTE*, d); ------------------ | | 31| 6.47k|#define WINPR_ENDIAN_CAST(t, val) WINPR_CXX_COMPAT_CAST(t, val) | | ------------------ | | | | 34| 6.47k|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ ------------------ 238| 6.47k| b[0] = v & 0xFF; 239| 6.47k| b[1] = (v >> 8) & 0xFF; 240| 6.47k| } image.c:winpr_Data_Get_UINT8: 39| 2.31k| { 40| 2.31k| WINPR_ASSERT(d); ------------------ | | 76| 2.31k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 2.31k| do \ | | | | 61| 2.31k| { \ | | | | 62| 2.31k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 2.31k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 2.31k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 2.31k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 2.31k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 2.31k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 2.31k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 2.31k| \ | | | | 70| 2.31k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 2.31k| do \ | | | | | | 32| 2.31k| { \ | | | | | | 33| 2.31k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 2.31k] | | | | | | ------------------ | | | | | | 34| 2.31k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 2.31k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 2.31k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 2.31k| \ | | | | 72| 2.31k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 2.31k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 2.31k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 2.31k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 2.31k] | | | | ------------------ | | ------------------ ------------------ 41| 2.31k| const UINT8* ptr = WINPR_ENDIAN_CAST(const UINT8*, d); ------------------ | | 31| 2.31k|#define WINPR_ENDIAN_CAST(t, val) WINPR_CXX_COMPAT_CAST(t, val) | | ------------------ | | | | 34| 2.31k|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ ------------------ 42| 2.31k| return *ptr; 43| 2.31k| } image.c:winpr_Data_Get_UINT32: 113| 11.7k| { 114| 11.7k| WINPR_ASSERT(d); ------------------ | | 76| 11.7k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 11.7k| do \ | | | | 61| 11.7k| { \ | | | | 62| 11.7k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 11.7k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 11.7k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 11.7k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 11.7k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 11.7k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 11.7k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 11.7k| \ | | | | 70| 11.7k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 11.7k| do \ | | | | | | 32| 11.7k| { \ | | | | | | 33| 11.7k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 11.7k] | | | | | | ------------------ | | | | | | 34| 11.7k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 11.7k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 11.7k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 11.7k| \ | | | | 72| 11.7k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 11.7k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 11.7k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 11.7k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 11.7k] | | | | ------------------ | | ------------------ ------------------ 115| 11.7k| const UINT8* ptr = WINPR_ENDIAN_CAST(const UINT8*, d); ------------------ | | 31| 11.7k|#define WINPR_ENDIAN_CAST(t, val) WINPR_CXX_COMPAT_CAST(t, val) | | ------------------ | | | | 34| 11.7k|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ ------------------ 116| 11.7k| const size_t typesize = sizeof(UINT32); 117| 11.7k| UINT32 v = 0; 118| 58.8k| for (size_t x = 0; x < typesize; x++) ------------------ | Branch (118:22): [True: 47.0k, False: 11.7k] ------------------ 119| 47.0k| { 120| 47.0k| v <<= 8; 121| 47.0k| v |= ptr[typesize - x - 1]; 122| 47.0k| } 123| 11.7k| return v; 124| 11.7k| } image.c:winpr_Data_Get_UINT16: 59| 4.41k| { 60| 4.41k| WINPR_ASSERT(d); ------------------ | | 76| 4.41k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 4.41k| do \ | | | | 61| 4.41k| { \ | | | | 62| 4.41k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 4.41k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 4.41k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 4.41k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 4.41k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 4.41k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 4.41k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 4.41k| \ | | | | 70| 4.41k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 4.41k| do \ | | | | | | 32| 4.41k| { \ | | | | | | 33| 4.41k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 4.41k] | | | | | | ------------------ | | | | | | 34| 4.41k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 4.41k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 4.41k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 4.41k| \ | | | | 72| 4.41k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 4.41k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 4.41k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 4.41k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 4.41k] | | | | ------------------ | | ------------------ ------------------ 61| 4.41k| const UINT8* ptr = WINPR_ENDIAN_CAST(const UINT8*, d); ------------------ | | 31| 4.41k|#define WINPR_ENDIAN_CAST(t, val) WINPR_CXX_COMPAT_CAST(t, val) | | ------------------ | | | | 34| 4.41k|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ ------------------ 62| 4.41k| const size_t typesize = sizeof(UINT16); 63| 4.41k| UINT16 v = 0; 64| 13.2k| for (size_t x = 0; x < typesize; x++) ------------------ | Branch (64:22): [True: 8.82k, False: 4.41k] ------------------ 65| 8.82k| { 66| 8.82k| v <<= 8; 67| 8.82k| v |= ptr[typesize - x - 1]; 68| 8.82k| } 69| 4.41k| return v; 70| 4.41k| } image.c:winpr_Data_Write_INT32: 341| 996| { 342| 996| WINPR_ASSERT(d); ------------------ | | 76| 996|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 996| do \ | | | | 61| 996| { \ | | | | 62| 996| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 996| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 996| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 996| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 996| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 996| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 996| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 996| \ | | | | 70| 996| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 996| do \ | | | | | | 32| 996| { \ | | | | | | 33| 996| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 996] | | | | | | ------------------ | | | | | | 34| 996| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 996| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 996] | | | | | | ------------------ | | | | ------------------ | | | | 71| 996| \ | | | | 72| 996| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 996| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 996| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 996| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 996] | | | | ------------------ | | ------------------ ------------------ 343| 996| BYTE* b = WINPR_ENDIAN_CAST(BYTE*, d); ------------------ | | 31| 996|#define WINPR_ENDIAN_CAST(t, val) WINPR_CXX_COMPAT_CAST(t, val) | | ------------------ | | | | 34| 996|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ ------------------ 344| 996| winpr_Data_Write_UINT16(b, v & 0xFFFF); 345| 996| winpr_Data_Write_UINT16(b + 2, (v >> 16) & 0xFFFF); 346| 996| } image.c:winpr_Data_Get_INT32: 148| 4.20k| { 149| 4.20k| const UINT32 u32 = winpr_Data_Get_UINT32(d); 150| 4.20k| return WINPR_ENDIAN_CAST(INT32, u32); ------------------ | | 31| 4.20k|#define WINPR_ENDIAN_CAST(t, val) WINPR_CXX_COMPAT_CAST(t, val) | | ------------------ | | | | 34| 4.20k|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ ------------------ 151| 4.20k| } image.c:Stream_Write_UINT8_unchecked: 872| 498| { 873| 498| WINPR_ASSERT(_s); ------------------ | | 76| 498|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 498| do \ | | | | 61| 498| { \ | | | | 62| 498| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 498| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 498| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 498| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 498| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 498| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 498| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 498| \ | | | | 70| 498| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 498| do \ | | | | | | 32| 498| { \ | | | | | | 33| 498| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 498] | | | | | | ------------------ | | | | | | 34| 498| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 498| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 498] | | | | | | ------------------ | | | | ------------------ | | | | 71| 498| \ | | | | 72| 498| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 498| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 498| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 498| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 498] | | | | ------------------ | | ------------------ ------------------ 874| 498| WINPR_ASSERT(_s->pointer); ------------------ | | 76| 498|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 498| do \ | | | | 61| 498| { \ | | | | 62| 498| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 498| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 498| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 498| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 498| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 498| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 498| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 498| \ | | | | 70| 498| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 498| do \ | | | | | | 32| 498| { \ | | | | | | 33| 498| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 498] | | | | | | ------------------ | | | | | | 34| 498| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 498| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 498] | | | | | | ------------------ | | | | ------------------ | | | | 71| 498| \ | | | | 72| 498| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 498| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 498| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 498| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 498] | | | | ------------------ | | ------------------ ------------------ 875| 498| WINPR_ASSERT(Stream_GetRemainingCapacity(_s) >= 1); ------------------ | | 76| 498|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 498| do \ | | | | 61| 498| { \ | | | | 62| 498| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 498| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 498| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 498| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 498| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 498| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 498| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 498| \ | | | | 70| 498| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 498| do \ | | | | | | 32| 498| { \ | | | | | | 33| 498| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 498] | | | | | | ------------------ | | | | | | 34| 498| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 498| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 498] | | | | | | ------------------ | | | | ------------------ | | | | 71| 498| \ | | | | 72| 498| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 498| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 498| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 498| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 498] | | | | ------------------ | | ------------------ ------------------ 876| | 877| 498| winpr_Data_Write_UINT8(_s->pointer, _v); 878| 498| _s->pointer += 1; 879| 498| } image.c:Stream_Write_UINT32_unchecked: 1086| 1.74k| { 1087| 1.74k| WINPR_ASSERT(_s); ------------------ | | 76| 1.74k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1.74k| do \ | | | | 61| 1.74k| { \ | | | | 62| 1.74k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1.74k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1.74k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1.74k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1.74k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1.74k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1.74k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1.74k| \ | | | | 70| 1.74k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1.74k| do \ | | | | | | 32| 1.74k| { \ | | | | | | 33| 1.74k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1.74k] | | | | | | ------------------ | | | | | | 34| 1.74k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1.74k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1.74k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1.74k| \ | | | | 72| 1.74k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1.74k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1.74k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1.74k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1.74k] | | | | ------------------ | | ------------------ ------------------ 1088| 1.74k| WINPR_ASSERT(_s->pointer); ------------------ | | 76| 1.74k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1.74k| do \ | | | | 61| 1.74k| { \ | | | | 62| 1.74k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1.74k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1.74k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1.74k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1.74k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1.74k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1.74k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1.74k| \ | | | | 70| 1.74k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1.74k| do \ | | | | | | 32| 1.74k| { \ | | | | | | 33| 1.74k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1.74k] | | | | | | ------------------ | | | | | | 34| 1.74k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1.74k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1.74k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1.74k| \ | | | | 72| 1.74k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1.74k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1.74k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1.74k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1.74k] | | | | ------------------ | | ------------------ ------------------ 1089| 1.74k| WINPR_ASSERT(Stream_GetRemainingCapacity(_s) >= 4); ------------------ | | 76| 1.74k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1.74k| do \ | | | | 61| 1.74k| { \ | | | | 62| 1.74k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1.74k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1.74k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1.74k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1.74k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1.74k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1.74k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1.74k| \ | | | | 70| 1.74k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1.74k| do \ | | | | | | 32| 1.74k| { \ | | | | | | 33| 1.74k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1.74k] | | | | | | ------------------ | | | | | | 34| 1.74k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1.74k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1.74k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1.74k| \ | | | | 72| 1.74k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1.74k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1.74k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1.74k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1.74k] | | | | ------------------ | | ------------------ ------------------ 1090| | 1091| 1.74k| winpr_Data_Write_UINT32(_s->pointer, _v); 1092| 1.74k| _s->pointer += 4; 1093| 1.74k| } image.c:Stream_Write_UINT16_unchecked: 924| 996| { 925| 996| WINPR_ASSERT(_s); ------------------ | | 76| 996|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 996| do \ | | | | 61| 996| { \ | | | | 62| 996| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 996| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 996| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 996| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 996| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 996| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 996| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 996| \ | | | | 70| 996| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 996| do \ | | | | | | 32| 996| { \ | | | | | | 33| 996| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 996] | | | | | | ------------------ | | | | | | 34| 996| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 996| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 996] | | | | | | ------------------ | | | | ------------------ | | | | 71| 996| \ | | | | 72| 996| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 996| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 996| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 996| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 996] | | | | ------------------ | | ------------------ ------------------ 926| 996| WINPR_ASSERT(_s->pointer); ------------------ | | 76| 996|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 996| do \ | | | | 61| 996| { \ | | | | 62| 996| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 996| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 996| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 996| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 996| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 996| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 996| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 996| \ | | | | 70| 996| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 996| do \ | | | | | | 32| 996| { \ | | | | | | 33| 996| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 996] | | | | | | ------------------ | | | | | | 34| 996| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 996| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 996] | | | | | | ------------------ | | | | ------------------ | | | | 71| 996| \ | | | | 72| 996| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 996| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 996| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 996| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 996] | | | | ------------------ | | ------------------ ------------------ 927| 996| WINPR_ASSERT(Stream_GetRemainingCapacity(_s) >= 2); ------------------ | | 76| 996|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 996| do \ | | | | 61| 996| { \ | | | | 62| 996| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 996| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 996| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 996| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 996| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 996| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 996| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 996| \ | | | | 70| 996| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 996| do \ | | | | | | 32| 996| { \ | | | | | | 33| 996| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 996] | | | | | | ------------------ | | | | | | 34| 996| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 996| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 996] | | | | | | ------------------ | | | | ------------------ | | | | 71| 996| \ | | | | 72| 996| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 996| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 996| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 996| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 996] | | | | ------------------ | | ------------------ ------------------ 928| | 929| 996| winpr_Data_Write_UINT16(_s->pointer, _v); 930| 996| _s->pointer += 2; 931| 996| } image.c:stream_read_u8: 176| 2.31k| { 177| 2.31k| WINPR_ASSERT(_s); ------------------ | | 76| 2.31k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 2.31k| do \ | | | | 61| 2.31k| { \ | | | | 62| 2.31k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 2.31k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 2.31k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 2.31k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 2.31k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 2.31k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 2.31k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 2.31k| \ | | | | 70| 2.31k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 2.31k| do \ | | | | | | 32| 2.31k| { \ | | | | | | 33| 2.31k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 2.31k] | | | | | | ------------------ | | | | | | 34| 2.31k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 2.31k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 2.31k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 2.31k| \ | | | | 72| 2.31k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 2.31k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 2.31k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 2.31k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 2.31k] | | | | ------------------ | | ------------------ ------------------ 178| 2.31k| WINPR_ASSERT(Stream_GetRemainingLength(_s) >= sizeof(UINT8)); ------------------ | | 76| 2.31k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 2.31k| do \ | | | | 61| 2.31k| { \ | | | | 62| 2.31k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 2.31k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 2.31k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 2.31k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 2.31k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 2.31k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 2.31k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 2.31k| \ | | | | 70| 2.31k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 2.31k| do \ | | | | | | 32| 2.31k| { \ | | | | | | 33| 2.31k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 2.31k] | | | | | | ------------------ | | | | | | 34| 2.31k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 2.31k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 2.31k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 2.31k| \ | | | | 72| 2.31k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 2.31k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 2.31k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 2.31k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 2.31k] | | | | ------------------ | | ------------------ ------------------ 179| | 180| 2.31k| const UINT8 v = winpr_Data_Get_UINT8(_s->pointer); 181| 2.31k| if (seek) ------------------ | Branch (181:7): [True: 2.31k, False: 0] ------------------ 182| 2.31k| Stream_Seek(_s, sizeof(UINT8)); 183| 2.31k| return v; 184| 2.31k| } image.c:Stream_Seek: 157| 5.80M| { 158| 5.80M| WINPR_ASSERT(s); ------------------ | | 76| 5.80M|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 5.80M| do \ | | | | 61| 5.80M| { \ | | | | 62| 5.80M| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 5.80M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 5.80M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 5.80M| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 5.80M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 5.80M| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 5.80M| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 5.80M| \ | | | | 70| 5.80M| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 5.80M| do \ | | | | | | 32| 5.80M| { \ | | | | | | 33| 5.80M| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 5.80M] | | | | | | ------------------ | | | | | | 34| 5.80M| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 5.80M| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 5.80M] | | | | | | ------------------ | | | | ------------------ | | | | 71| 5.80M| \ | | | | 72| 5.80M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 5.80M| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 5.80M| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 5.80M| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 5.80M] | | | | ------------------ | | ------------------ ------------------ 159| 5.80M| WINPR_ASSERT(Stream_GetRemainingCapacity(s) >= _offset); ------------------ | | 76| 5.80M|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 5.80M| do \ | | | | 61| 5.80M| { \ | | | | 62| 5.80M| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 5.80M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 5.80M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 5.80M| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 5.80M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 5.80M| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 5.80M| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 5.80M| \ | | | | 70| 5.80M| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 5.80M| do \ | | | | | | 32| 5.80M| { \ | | | | | | 33| 5.80M| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 5.80M] | | | | | | ------------------ | | | | | | 34| 5.80M| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 5.80M| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 5.80M] | | | | | | ------------------ | | | | ------------------ | | | | 71| 5.80M| \ | | | | 72| 5.80M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 5.80M| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 5.80M| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 5.80M| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 5.80M] | | | | ------------------ | | ------------------ ------------------ 160| 5.80M| s->pointer += (_offset); 161| 5.80M| } image.c:stream_read_u32_le: 243| 7.56k| { 244| 7.56k| const size_t typesize = sizeof(UINT32); 245| 7.56k| WINPR_ASSERT(_s); ------------------ | | 76| 7.56k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 7.56k| do \ | | | | 61| 7.56k| { \ | | | | 62| 7.56k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 7.56k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 7.56k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 7.56k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 7.56k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 7.56k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 7.56k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 7.56k| \ | | | | 70| 7.56k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 7.56k| do \ | | | | | | 32| 7.56k| { \ | | | | | | 33| 7.56k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 7.56k] | | | | | | ------------------ | | | | | | 34| 7.56k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 7.56k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 7.56k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 7.56k| \ | | | | 72| 7.56k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 7.56k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 7.56k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 7.56k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 7.56k] | | | | ------------------ | | ------------------ ------------------ 246| 7.56k| WINPR_ASSERT(Stream_GetRemainingLength(_s) >= typesize); ------------------ | | 76| 7.56k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 7.56k| do \ | | | | 61| 7.56k| { \ | | | | 62| 7.56k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 7.56k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 7.56k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 7.56k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 7.56k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 7.56k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 7.56k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 7.56k| \ | | | | 70| 7.56k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 7.56k| do \ | | | | | | 32| 7.56k| { \ | | | | | | 33| 7.56k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 7.56k] | | | | | | ------------------ | | | | | | 34| 7.56k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 7.56k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 7.56k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 7.56k| \ | | | | 72| 7.56k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 7.56k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 7.56k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 7.56k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 7.56k] | | | | ------------------ | | ------------------ ------------------ 247| | 248| 7.56k| const UINT32 v = winpr_Data_Get_UINT32(_s->pointer); 249| 7.56k| if (seek) ------------------ | Branch (249:7): [True: 7.56k, False: 0] ------------------ 250| 7.56k| Stream_Seek(_s, typesize); 251| 7.56k| return v; 252| 7.56k| } image.c:stream_read_u16_le: 195| 4.41k| { 196| 4.41k| const size_t typesize = sizeof(UINT16); 197| 4.41k| WINPR_ASSERT(_s); ------------------ | | 76| 4.41k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 4.41k| do \ | | | | 61| 4.41k| { \ | | | | 62| 4.41k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 4.41k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 4.41k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 4.41k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 4.41k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 4.41k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 4.41k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 4.41k| \ | | | | 70| 4.41k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 4.41k| do \ | | | | | | 32| 4.41k| { \ | | | | | | 33| 4.41k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 4.41k] | | | | | | ------------------ | | | | | | 34| 4.41k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 4.41k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 4.41k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 4.41k| \ | | | | 72| 4.41k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 4.41k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 4.41k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 4.41k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 4.41k] | | | | ------------------ | | ------------------ ------------------ 198| 4.41k| WINPR_ASSERT(Stream_GetRemainingLength(_s) >= typesize); ------------------ | | 76| 4.41k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 4.41k| do \ | | | | 61| 4.41k| { \ | | | | 62| 4.41k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 4.41k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 4.41k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 4.41k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 4.41k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 4.41k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 4.41k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 4.41k| \ | | | | 70| 4.41k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 4.41k| do \ | | | | | | 32| 4.41k| { \ | | | | | | 33| 4.41k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 4.41k] | | | | | | ------------------ | | | | | | 34| 4.41k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 4.41k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 4.41k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 4.41k| \ | | | | 72| 4.41k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 4.41k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 4.41k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 4.41k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 4.41k] | | | | ------------------ | | ------------------ ------------------ 199| | 200| 4.41k| const UINT16 v = winpr_Data_Get_UINT16(_s->pointer); 201| 4.41k| if (seek) ------------------ | Branch (201:7): [True: 4.41k, False: 0] ------------------ 202| 4.41k| Stream_Seek(_s, typesize); 203| 4.41k| return v; 204| 4.41k| } image.c:Stream_Write_INT32_unchecked: 1032| 996| { 1033| 996| WINPR_ASSERT(_s); ------------------ | | 76| 996|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 996| do \ | | | | 61| 996| { \ | | | | 62| 996| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 996| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 996| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 996| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 996| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 996| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 996| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 996| \ | | | | 70| 996| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 996| do \ | | | | | | 32| 996| { \ | | | | | | 33| 996| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 996] | | | | | | ------------------ | | | | | | 34| 996| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 996| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 996] | | | | | | ------------------ | | | | ------------------ | | | | 71| 996| \ | | | | 72| 996| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 996| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 996| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 996| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 996] | | | | ------------------ | | ------------------ ------------------ 1034| 996| WINPR_ASSERT(_s->pointer); ------------------ | | 76| 996|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 996| do \ | | | | 61| 996| { \ | | | | 62| 996| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 996| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 996| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 996| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 996| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 996| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 996| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 996| \ | | | | 70| 996| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 996| do \ | | | | | | 32| 996| { \ | | | | | | 33| 996| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 996] | | | | | | ------------------ | | | | | | 34| 996| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 996| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 996] | | | | | | ------------------ | | | | ------------------ | | | | 71| 996| \ | | | | 72| 996| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 996| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 996| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 996| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 996] | | | | ------------------ | | ------------------ ------------------ 1035| 996| WINPR_ASSERT(Stream_GetRemainingCapacity(_s) >= 4); ------------------ | | 76| 996|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 996| do \ | | | | 61| 996| { \ | | | | 62| 996| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 996| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 996| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 996| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 996| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 996| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 996| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 996| \ | | | | 70| 996| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 996| do \ | | | | | | 32| 996| { \ | | | | | | 33| 996| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 996] | | | | | | ------------------ | | | | | | 34| 996| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 996| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 996] | | | | | | ------------------ | | | | ------------------ | | | | 71| 996| \ | | | | 72| 996| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 996| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 996| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 996| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 996] | | | | ------------------ | | ------------------ ------------------ 1036| | 1037| 996| winpr_Data_Write_INT32(_s->pointer, _v); 1038| 996| _s->pointer += 4; 1039| 996| } image.c:Stream_GetPosition: 1362| 3.14k| { 1363| 3.14k| WINPR_ASSERT(_s); ------------------ | | 76| 3.14k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 3.14k| do \ | | | | 61| 3.14k| { \ | | | | 62| 3.14k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 3.14k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 3.14k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 3.14k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 3.14k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 3.14k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 3.14k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 3.14k| \ | | | | 70| 3.14k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 3.14k| do \ | | | | | | 32| 3.14k| { \ | | | | | | 33| 3.14k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 3.14k] | | | | | | ------------------ | | | | | | 34| 3.14k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 3.14k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 3.14k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 3.14k| \ | | | | 72| 3.14k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 3.14k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 3.14k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 3.14k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 3.14k] | | | | ------------------ | | ------------------ ------------------ 1364| 3.14k| WINPR_ASSERT(_s->buffer <= _s->pointer); ------------------ | | 76| 3.14k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 3.14k| do \ | | | | 61| 3.14k| { \ | | | | 62| 3.14k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 3.14k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 3.14k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 3.14k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 3.14k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 3.14k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 3.14k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 3.14k| \ | | | | 70| 3.14k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 3.14k| do \ | | | | | | 32| 3.14k| { \ | | | | | | 33| 3.14k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 3.14k] | | | | | | ------------------ | | | | | | 34| 3.14k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 3.14k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 3.14k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 3.14k| \ | | | | 72| 3.14k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 3.14k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 3.14k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 3.14k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 3.14k] | | | | ------------------ | | ------------------ ------------------ 1365| 3.14k| return WINPR_ASSERTING_INT_CAST(size_t, (_s->pointer - _s->buffer)); ------------------ | | 180| 3.14k| __extension__({ \ | | 181| 3.14k| __typeof(ivar) var = ivar; \ | | 182| 3.14k| WINPR_ASSERT((var) == \ | | ------------------ | | | | 76| 3.14k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 3.14k| do \ | | | | | | 61| 3.14k| { \ | | | | | | 62| 3.14k| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 3.14k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 3.14k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 3.14k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 3.14k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 3.14k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 3.14k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 3.14k| \ | | | | | | 70| 3.14k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 3.14k| do \ | | | | | | | | 32| 3.14k| { \ | | | | | | | | 33| 3.14k| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 3.14k] | | | | | | | | ------------------ | | | | | | | | 34| 3.14k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 3.14k| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 3.14k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 3.14k| \ | | | | | | 72| 3.14k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 3.14k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 3.14k| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 3.14k| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 3.14k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 183| 3.14k| WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \ | | 184| 3.14k| WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) || \ | | ------------------ | | | | 76| 3.14k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 3.14k| do \ | | | | | | 61| 3.14k| { \ | | | | | | 62| 3.14k| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 3.14k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 3.14k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 3.14k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 3.14k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 3.14k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 3.14k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 3.14k| \ | | | | | | 70| 3.14k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 3.14k| do \ | | | | | | | | 32| 3.14k| { \ | | | | | | | | 33| 9.42k| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:9): [True: 3.14k, False: 0] | | | | | | | | | Branch (33:9): [True: 3.14k, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 3.14k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 3.14k| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 3.14k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 3.14k| \ | | | | | | 72| 3.14k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 3.14k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 3.14k| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 3.14k| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 3.14k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 185| 3.14k| (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0)); \ | | 186| 3.14k| WINPR_CXX_COMPAT_CAST(type, (var)); \ | | ------------------ | | | | 34| 3.14k|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ | | 187| 3.14k| }) ------------------ 1366| 3.14k| } image.c:stream_read_i32_le: 267| 4.20k| { 268| 4.20k| const size_t typesize = sizeof(INT32); 269| 4.20k| WINPR_ASSERT(_s); ------------------ | | 76| 4.20k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 4.20k| do \ | | | | 61| 4.20k| { \ | | | | 62| 4.20k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 4.20k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 4.20k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 4.20k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 4.20k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 4.20k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 4.20k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 4.20k| \ | | | | 70| 4.20k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 4.20k| do \ | | | | | | 32| 4.20k| { \ | | | | | | 33| 4.20k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 4.20k] | | | | | | ------------------ | | | | | | 34| 4.20k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 4.20k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 4.20k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 4.20k| \ | | | | 72| 4.20k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 4.20k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 4.20k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 4.20k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 4.20k] | | | | ------------------ | | ------------------ ------------------ 270| 4.20k| WINPR_ASSERT(Stream_GetRemainingLength(_s) >= typesize); ------------------ | | 76| 4.20k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 4.20k| do \ | | | | 61| 4.20k| { \ | | | | 62| 4.20k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 4.20k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 4.20k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 4.20k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 4.20k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 4.20k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 4.20k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 4.20k| \ | | | | 70| 4.20k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 4.20k| do \ | | | | | | 32| 4.20k| { \ | | | | | | 33| 4.20k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 4.20k] | | | | | | ------------------ | | | | | | 34| 4.20k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 4.20k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 4.20k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 4.20k| \ | | | | 72| 4.20k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 4.20k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 4.20k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 4.20k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 4.20k] | | | | ------------------ | | ------------------ ------------------ 271| | 272| 4.20k| const INT32 v = winpr_Data_Get_INT32(_s->pointer); 273| 4.20k| if (seek) ------------------ | Branch (273:7): [True: 4.20k, False: 0] ------------------ 274| 4.20k| Stream_Seek(_s, typesize); 275| 4.20k| return v; 276| 4.20k| } image.c:Stream_Zero: 1240| 1.92M| { 1241| 1.92M| Stream_Fill(_s, '\0', _n); 1242| 1.92M| } image.c:Stream_Fill: 1232| 1.92M| { 1233| 1.92M| WINPR_ASSERT(_s); ------------------ | | 76| 1.92M|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1.92M| do \ | | | | 61| 1.92M| { \ | | | | 62| 1.92M| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1.92M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1.92M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1.92M| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1.92M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1.92M| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1.92M| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1.92M| \ | | | | 70| 1.92M| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1.92M| do \ | | | | | | 32| 1.92M| { \ | | | | | | 33| 1.92M| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1.92M] | | | | | | ------------------ | | | | | | 34| 1.92M| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1.92M| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1.92M] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1.92M| \ | | | | 72| 1.92M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1.92M| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1.92M| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1.92M| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1.92M] | | | | ------------------ | | ------------------ ------------------ 1234| 1.92M| WINPR_ASSERT(Stream_GetRemainingCapacity(_s) >= (_n)); ------------------ | | 76| 1.92M|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1.92M| do \ | | | | 61| 1.92M| { \ | | | | 62| 1.92M| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1.92M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1.92M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1.92M| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1.92M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1.92M| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1.92M| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1.92M| \ | | | | 70| 1.92M| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1.92M| do \ | | | | | | 32| 1.92M| { \ | | | | | | 33| 1.92M| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1.92M] | | | | | | ------------------ | | | | | | 34| 1.92M| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1.92M| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1.92M] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1.92M| \ | | | | 72| 1.92M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1.92M| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1.92M| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1.92M| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1.92M] | | | | ------------------ | | ------------------ ------------------ 1235| 1.92M| memset(_s->pointer, _v, (_n)); 1236| 1.92M| Stream_Seek(_s, _n); 1237| 1.92M| } image.c:Stream_Buffer: 1284| 249| { 1285| 249| WINPR_ASSERT(_s); ------------------ | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 249| do \ | | | | 61| 249| { \ | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 249| \ | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 249| do \ | | | | | | 32| 249| { \ | | | | | | 33| 249| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | ------------------ | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | | | 71| 249| \ | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 249| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 249] | | | | ------------------ | | ------------------ ------------------ 1286| 249| return _s->buffer; 1287| 249| } image.c:Stream_Write: 1186| 1.92M| { 1187| 1.92M| if (_n > 0) ------------------ | Branch (1187:7): [True: 1.92M, False: 0] ------------------ 1188| 1.92M| { 1189| 1.92M| WINPR_ASSERT(_s); ------------------ | | 76| 1.92M|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1.92M| do \ | | | | 61| 1.92M| { \ | | | | 62| 1.92M| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1.92M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1.92M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1.92M| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1.92M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1.92M| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1.92M| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1.92M| \ | | | | 70| 1.92M| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1.92M| do \ | | | | | | 32| 1.92M| { \ | | | | | | 33| 1.92M| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1.92M] | | | | | | ------------------ | | | | | | 34| 1.92M| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1.92M| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1.92M] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1.92M| \ | | | | 72| 1.92M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1.92M| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1.92M| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1.92M| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1.92M] | | | | ------------------ | | ------------------ ------------------ 1190| 1.92M| WINPR_ASSERT(_b); ------------------ | | 76| 1.92M|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1.92M| do \ | | | | 61| 1.92M| { \ | | | | 62| 1.92M| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1.92M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1.92M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1.92M| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1.92M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1.92M| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1.92M| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1.92M| \ | | | | 70| 1.92M| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1.92M| do \ | | | | | | 32| 1.92M| { \ | | | | | | 33| 1.92M| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1.92M] | | | | | | ------------------ | | | | | | 34| 1.92M| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1.92M| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1.92M] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1.92M| \ | | | | 72| 1.92M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1.92M| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1.92M| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1.92M| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1.92M] | | | | ------------------ | | ------------------ ------------------ 1191| 1.92M| WINPR_ASSERT(Stream_GetRemainingCapacity(_s) >= _n); ------------------ | | 76| 1.92M|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1.92M| do \ | | | | 61| 1.92M| { \ | | | | 62| 1.92M| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1.92M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1.92M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1.92M| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1.92M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1.92M| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1.92M| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1.92M| \ | | | | 70| 1.92M| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1.92M| do \ | | | | | | 32| 1.92M| { \ | | | | | | 33| 1.92M| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1.92M] | | | | | | ------------------ | | | | | | 34| 1.92M| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1.92M| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1.92M] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1.92M| \ | | | | 72| 1.92M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1.92M| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1.92M| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1.92M| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1.92M] | | | | ------------------ | | ------------------ ------------------ 1192| 1.92M| memcpy(_s->pointer, (_b), (_n)); 1193| 1.92M| Stream_Seek(_s, _n); 1194| 1.92M| } 1195| 1.92M| } image.c:Stream_Read: 731| 1.92M| { 732| 1.92M| WINPR_ASSERT(_s); ------------------ | | 76| 1.92M|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1.92M| do \ | | | | 61| 1.92M| { \ | | | | 62| 1.92M| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1.92M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1.92M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1.92M| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1.92M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1.92M| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1.92M| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1.92M| \ | | | | 70| 1.92M| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1.92M| do \ | | | | | | 32| 1.92M| { \ | | | | | | 33| 1.92M| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1.92M] | | | | | | ------------------ | | | | | | 34| 1.92M| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1.92M| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1.92M] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1.92M| \ | | | | 72| 1.92M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1.92M| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1.92M| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1.92M| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1.92M] | | | | ------------------ | | ------------------ ------------------ 733| 1.92M| WINPR_ASSERT(_b || (_n == 0)); ------------------ | | 76| 1.92M|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1.92M| do \ | | | | 61| 1.92M| { \ | | | | 62| 1.92M| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1.92M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1.92M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1.92M| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1.92M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1.92M| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1.92M| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1.92M| \ | | | | 70| 1.92M| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1.92M| do \ | | | | | | 32| 1.92M| { \ | | | | | | 33| 1.92M| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:9): [True: 1.92M, False: 0] | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 34| 1.92M| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1.92M| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1.92M] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1.92M| \ | | | | 72| 1.92M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1.92M| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1.92M| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1.92M| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1.92M] | | | | ------------------ | | ------------------ ------------------ 734| 1.92M| WINPR_ASSERT(Stream_GetRemainingCapacity(_s) >= _n); ------------------ | | 76| 1.92M|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1.92M| do \ | | | | 61| 1.92M| { \ | | | | 62| 1.92M| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1.92M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1.92M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1.92M| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1.92M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1.92M| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1.92M| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1.92M| \ | | | | 70| 1.92M| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1.92M| do \ | | | | | | 32| 1.92M| { \ | | | | | | 33| 1.92M| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1.92M] | | | | | | ------------------ | | | | | | 34| 1.92M| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1.92M| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1.92M] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1.92M| \ | | | | 72| 1.92M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1.92M| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1.92M| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1.92M| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1.92M] | | | | ------------------ | | ------------------ ------------------ 735| 1.92M| memcpy(_b, (_s->pointer), (_n)); 736| 1.92M| Stream_Seek(_s, _n); 737| 1.92M| } stream.c:Stream_GetPosition: 1362| 1.99M| { 1363| 1.99M| WINPR_ASSERT(_s); ------------------ | | 76| 1.99M|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1.99M| do \ | | | | 61| 1.99M| { \ | | | | 62| 1.99M| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1.99M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1.99M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1.99M| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1.99M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1.99M| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1.99M| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1.99M| \ | | | | 70| 1.99M| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1.99M| do \ | | | | | | 32| 1.99M| { \ | | | | | | 33| 1.99M| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1.99M] | | | | | | ------------------ | | | | | | 34| 1.99M| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1.99M| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1.99M] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1.99M| \ | | | | 72| 1.99M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1.99M| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1.99M| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1.99M| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1.99M] | | | | ------------------ | | ------------------ ------------------ 1364| 1.99M| WINPR_ASSERT(_s->buffer <= _s->pointer); ------------------ | | 76| 1.99M|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1.99M| do \ | | | | 61| 1.99M| { \ | | | | 62| 1.99M| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1.99M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1.99M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1.99M| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1.99M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1.99M| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1.99M| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1.99M| \ | | | | 70| 1.99M| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1.99M| do \ | | | | | | 32| 1.99M| { \ | | | | | | 33| 1.99M| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1.99M] | | | | | | ------------------ | | | | | | 34| 1.99M| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1.99M| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1.99M] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1.99M| \ | | | | 72| 1.99M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1.99M| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1.99M| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1.99M| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1.99M] | | | | ------------------ | | ------------------ ------------------ 1365| 1.99M| return WINPR_ASSERTING_INT_CAST(size_t, (_s->pointer - _s->buffer)); ------------------ | | 180| 1.99M| __extension__({ \ | | 181| 1.99M| __typeof(ivar) var = ivar; \ | | 182| 1.99M| WINPR_ASSERT((var) == \ | | ------------------ | | | | 76| 1.99M|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 1.99M| do \ | | | | | | 61| 1.99M| { \ | | | | | | 62| 1.99M| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 1.99M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 1.99M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 1.99M| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 1.99M| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 1.99M| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 1.99M| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 1.99M| \ | | | | | | 70| 1.99M| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 1.99M| do \ | | | | | | | | 32| 1.99M| { \ | | | | | | | | 33| 1.99M| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 1.99M] | | | | | | | | ------------------ | | | | | | | | 34| 1.99M| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 1.99M| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 1.99M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 1.99M| \ | | | | | | 72| 1.99M| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 1.99M| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 1.99M| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 1.99M| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 1.99M] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 183| 1.99M| WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \ | | 184| 1.99M| WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) || \ | | ------------------ | | | | 76| 1.99M|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 1.99M| do \ | | | | | | 61| 1.99M| { \ | | | | | | 62| 1.99M| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 1.99M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 1.99M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 1.99M| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 1.99M| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 1.99M| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 1.99M| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 1.99M| \ | | | | | | 70| 1.99M| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 1.99M| do \ | | | | | | | | 32| 1.99M| { \ | | | | | | | | 33| 5.98M| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:9): [True: 1.99M, False: 249] | | | | | | | | | Branch (33:9): [True: 1.99M, False: 0] | | | | | | | | | Branch (33:9): [True: 249, False: 0] | | | | | | | | | Branch (33:9): [True: 249, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 1.99M| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 1.99M| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 1.99M] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 1.99M| \ | | | | | | 72| 1.99M| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 1.99M| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 1.99M| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 1.99M| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 1.99M] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 185| 1.99M| (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0)); \ | | 186| 1.99M| WINPR_CXX_COMPAT_CAST(type, (var)); \ | | ------------------ | | | | 34| 1.99M|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ | | 187| 1.99M| }) ------------------ 1366| 1.99M| } stream.c:Stream_Capacity: 1354| 2.05M| { 1355| 2.05M| WINPR_ASSERT(_s); ------------------ | | 76| 2.05M|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 2.05M| do \ | | | | 61| 2.05M| { \ | | | | 62| 2.05M| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 2.05M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 2.05M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 2.05M| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 2.05M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 2.05M| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 2.05M| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 2.05M| \ | | | | 70| 2.05M| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 2.05M| do \ | | | | | | 32| 2.05M| { \ | | | | | | 33| 2.05M| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 2.05M] | | | | | | ------------------ | | | | | | 34| 2.05M| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 2.05M| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 2.05M] | | | | | | ------------------ | | | | ------------------ | | | | 71| 2.05M| \ | | | | 72| 2.05M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 2.05M| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 2.05M| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 2.05M| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 2.05M] | | | | ------------------ | | ------------------ ------------------ 1356| 2.05M| return _s->capacity; 1357| 2.05M| } stream.c:Stream_Seek: 157| 1.17k| { 158| 1.17k| WINPR_ASSERT(s); ------------------ | | 76| 1.17k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1.17k| do \ | | | | 61| 1.17k| { \ | | | | 62| 1.17k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1.17k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1.17k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1.17k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1.17k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1.17k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1.17k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1.17k| \ | | | | 70| 1.17k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1.17k| do \ | | | | | | 32| 1.17k| { \ | | | | | | 33| 1.17k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1.17k] | | | | | | ------------------ | | | | | | 34| 1.17k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1.17k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1.17k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1.17k| \ | | | | 72| 1.17k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1.17k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1.17k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1.17k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1.17k] | | | | ------------------ | | ------------------ ------------------ 159| 1.17k| WINPR_ASSERT(Stream_GetRemainingCapacity(s) >= _offset); ------------------ | | 76| 1.17k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1.17k| do \ | | | | 61| 1.17k| { \ | | | | 62| 1.17k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1.17k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1.17k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1.17k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1.17k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1.17k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1.17k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1.17k| \ | | | | 70| 1.17k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1.17k| do \ | | | | | | 32| 1.17k| { \ | | | | | | 33| 1.17k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1.17k] | | | | | | ------------------ | | | | | | 34| 1.17k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1.17k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1.17k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1.17k| \ | | | | 72| 1.17k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1.17k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1.17k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1.17k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1.17k] | | | | ------------------ | | ------------------ ------------------ 160| 1.17k| s->pointer += (_offset); 161| 1.17k| } image.c:WLog_Print_dbg_tag: 323| 541| { 324| 541| static wLog* log_cached_ptr = nullptr; 325| 541| if (!log_cached_ptr) ------------------ | Branch (325:7): [True: 1, False: 540] ------------------ 326| 1| log_cached_ptr = WLog_Get(tag); 327| | 328| 541| if (WLog_IsLevelActive(log_cached_ptr, log_level)) ------------------ | Branch (328:7): [True: 541, False: 0] ------------------ 329| 541| { 330| 541| va_list ap = WINPR_C_ARRAY_INIT; ------------------ | | 85| 541| { \ | | 86| 541| } /** @since version 3.24.0 */ ------------------ 331| 541| va_start(ap, fmt); 332| 541| WLog_PrintTextMessageVA(log_cached_ptr, log_level, line, file, fkt, fmt, ap); 333| | va_end(ap); 334| 541| } 335| 541| } _strdup: 303| 7|{ 304| 7| if (strSource == nullptr) ------------------ | Branch (304:6): [True: 0, False: 7] ------------------ 305| 0| return nullptr; 306| | 307| 7| char* strDestination = strdup(strSource); 308| | 309| 7| if (strDestination == nullptr) ------------------ | Branch (309:6): [True: 0, False: 7] ------------------ 310| 0| WLog_ERR(TAG, "strdup"); ------------------ | | 348| 0| WLog_Print_dbg_tag(tag, WLOG_ERROR, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 311| | 312| 7| return strDestination; 313| 7|} GetEnvironmentVariableA: 168| 4|{ 169| 4|#if !defined(_UWP) 170| 4| size_t length = 0; 171| | 172| | // NOLINTNEXTLINE(concurrency-mt-unsafe) 173| 4| char* env = getenv(lpName); 174| | 175| 4| if (!env) ------------------ | Branch (175:6): [True: 4, False: 0] ------------------ 176| 4| { 177| 4| SetLastError(ERROR_ENVVAR_NOT_FOUND); ------------------ | | 342| 4|#define ERROR_ENVVAR_NOT_FOUND 0x000000CB ------------------ 178| 4| return 0; 179| 4| } 180| | 181| 0| length = strlen(env); 182| | 183| 0| if ((length + 1 > nSize) || (!lpBuffer)) ------------------ | Branch (183:6): [True: 0, False: 0] | Branch (183:30): [True: 0, False: 0] ------------------ 184| 0| return (DWORD)length + 1; 185| | 186| 0| CopyMemory(lpBuffer, env, length); ------------------ | | 123| 0|#define CopyMemory(Destination, Source, Length) memcpy((Destination), (Source), (Length)) ------------------ 187| 0| lpBuffer[length] = '\0'; 188| | 189| 0| return (DWORD)length; 190| |#else 191| | SetLastError(ERROR_ENVVAR_NOT_FOUND); 192| | return 0; 193| |#endif 194| 0|} SetLastError: 54| 4|{ 55| 4| PTEB pt = NtCurrentTeb(); 56| 4| if (pt) ------------------ | Branch (56:6): [True: 4, False: 0] ------------------ 57| 4| { 58| 4| pt->LastErrorValue = dwErrCode; 59| 4| } 60| 4|} InterlockedIncrement: 240| 5.67k|{ 241| 5.67k| WINPR_ASSERT(Addend); ------------------ | | 76| 5.67k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 5.67k| do \ | | | | 61| 5.67k| { \ | | | | 62| 5.67k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 5.67k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 5.67k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 5.67k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 5.67k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 5.67k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 5.67k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 5.67k| \ | | | | 70| 5.67k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 5.67k| do \ | | | | | | 32| 5.67k| { \ | | | | | | 33| 5.67k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 5.67k] | | | | | | ------------------ | | | | | | 34| 5.67k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 5.67k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 5.67k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 5.67k| \ | | | | 72| 5.67k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 5.67k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 5.67k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 5.67k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 5.67k] | | | | ------------------ | | ------------------ ------------------ 242| | 243| 5.67k|#if defined(__GNUC__) || defined(__clang__) 244| 5.67k| WINPR_PRAGMA_DIAG_PUSH 245| 5.67k| WINPR_PRAGMA_DIAG_IGNORED_ATOMIC_SEQ_CST 246| 5.67k| return __sync_add_and_fetch(Addend, 1); 247| 5.67k| WINPR_PRAGMA_DIAG_POP 248| |#else 249| | return 0; 250| |#endif 251| 5.67k|} InterlockedDecrement: 254| 5.67k|{ 255| 5.67k| WINPR_ASSERT(Addend); ------------------ | | 76| 5.67k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 5.67k| do \ | | | | 61| 5.67k| { \ | | | | 62| 5.67k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 5.67k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 5.67k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 5.67k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 5.67k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 5.67k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 5.67k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 5.67k| \ | | | | 70| 5.67k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 5.67k| do \ | | | | | | 32| 5.67k| { \ | | | | | | 33| 5.67k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 5.67k] | | | | | | ------------------ | | | | | | 34| 5.67k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 5.67k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 5.67k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 5.67k| \ | | | | 72| 5.67k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 5.67k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 5.67k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 5.67k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 5.67k] | | | | ------------------ | | ------------------ ------------------ 256| | 257| 5.67k|#if defined(__GNUC__) || defined(__clang__) 258| 5.67k| WINPR_PRAGMA_DIAG_PUSH 259| 5.67k| WINPR_PRAGMA_DIAG_IGNORED_ATOMIC_SEQ_CST 260| 5.67k| return __sync_sub_and_fetch(Addend, 1); 261| 5.67k| WINPR_PRAGMA_DIAG_POP 262| |#else 263| | return 0; 264| |#endif 265| 5.67k|} InterlockedCompareExchangePointer: 311| 1|{ 312| 1| WINPR_ASSERT(Destination); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 313| | 314| 1|#if defined(__GNUC__) || defined(__clang__) 315| 1| WINPR_PRAGMA_DIAG_PUSH 316| 1| WINPR_PRAGMA_DIAG_IGNORED_ATOMIC_SEQ_CST 317| 1| return __sync_val_compare_and_swap(Destination, Comperand, Exchange); 318| 1| WINPR_PRAGMA_DIAG_POP 319| |#else 320| | return 0; 321| |#endif 322| 1|} NtCurrentTeb: 50| 4|{ 51| 4| PTEB teb = nullptr; 52| | 53| 4| if (pthread_once(&sTebOnceControl, sTebInitOnce) == 0) ------------------ | Branch (53:6): [True: 4, False: 0] ------------------ 54| 4| { 55| 4| if ((teb = pthread_getspecific(sTebKey)) == nullptr) ------------------ | Branch (55:7): [True: 1, False: 3] ------------------ 56| 1| { 57| 1| teb = calloc(1, sizeof(TEB)); 58| 1| if (teb) ------------------ | Branch (58:8): [True: 1, False: 0] ------------------ 59| 1| pthread_setspecific(sTebKey, teb); 60| 1| } 61| 4| } 62| 4| return teb; 63| 4|} nt.c:sTebInitOnce: 45| 1|{ 46| 1| pthread_key_create(&sTebKey, sTebDestruct); 47| 1|} InitializeCriticalSectionEx: 55| 4|{ 56| 4| WINPR_ASSERT(lpCriticalSection); ------------------ | | 76| 4|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 4| do \ | | | | 61| 4| { \ | | | | 62| 4| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 4| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 4| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 4| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 4| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 4| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 4| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 4| \ | | | | 70| 4| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 4| do \ | | | | | | 32| 4| { \ | | | | | | 33| 4| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 34| 4| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 4| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 4] | | | | | | ------------------ | | | | ------------------ | | | | 71| 4| \ | | | | 72| 4| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 4| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 4| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 4| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 4] | | | | ------------------ | | ------------------ ------------------ 57| | /** 58| | * See http://msdn.microsoft.com/en-us/library/ff541979(v=vs.85).aspx 59| | * - The LockCount field indicates the number of times that any thread has 60| | * called the EnterCriticalSection routine for this critical section, 61| | * minus one. This field starts at -1 for an unlocked critical section. 62| | * Each call of EnterCriticalSection increments this value; each call of 63| | * LeaveCriticalSection decrements it. 64| | * - The RecursionCount field indicates the number of times that the owning 65| | * thread has called EnterCriticalSection for this critical section. 66| | */ 67| 4| if (Flags != 0) ------------------ | Branch (67:6): [True: 0, False: 4] ------------------ 68| 0| { 69| 0| WLog_WARN(TAG, "Flags unimplemented"); ------------------ | | 346| 0| WLog_Print_dbg_tag(tag, WLOG_WARN, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 70| 0| } 71| | 72| 4| lpCriticalSection->DebugInfo = nullptr; 73| 4| lpCriticalSection->LockCount = -1; 74| 4| lpCriticalSection->SpinCount = 0; 75| 4| lpCriticalSection->RecursionCount = 0; 76| 4| lpCriticalSection->OwningThread = nullptr; 77| 4| lpCriticalSection->LockSemaphore = (winpr_sem_t*)malloc(sizeof(winpr_sem_t)); 78| | 79| 4| if (!lpCriticalSection->LockSemaphore) ------------------ | Branch (79:6): [True: 0, False: 4] ------------------ 80| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 81| | 82| |#if defined(__APPLE__) 83| | 84| | if (semaphore_create(mach_task_self(), lpCriticalSection->LockSemaphore, SYNC_POLICY_FIFO, 0) != 85| | KERN_SUCCESS) 86| | goto out_fail; 87| | 88| |#else 89| | 90| 4| if (sem_init(lpCriticalSection->LockSemaphore, 0, 0) != 0) ------------------ | Branch (90:6): [True: 0, False: 4] ------------------ 91| 0| goto out_fail; 92| | 93| 4|#endif 94| 4| SetCriticalSectionSpinCount(lpCriticalSection, dwSpinCount); 95| 4| return TRUE; ------------------ | | 126| 4|#define TRUE true ------------------ 96| 0|out_fail: 97| 0| free(lpCriticalSection->LockSemaphore); 98| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 99| 4|} InitializeCriticalSectionAndSpinCount: 102| 4|{ 103| 4| return InitializeCriticalSectionEx(lpCriticalSection, dwSpinCount, 0); 104| 4|} SetCriticalSectionSpinCount: 108| 4|{ 109| 4| WINPR_ASSERT(lpCriticalSection); ------------------ | | 76| 4|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 4| do \ | | | | 61| 4| { \ | | | | 62| 4| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 4| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 4| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 4| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 4| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 4| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 4| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 4| \ | | | | 70| 4| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 4| do \ | | | | | | 32| 4| { \ | | | | | | 33| 4| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 34| 4| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 4| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 4] | | | | | | ------------------ | | | | ------------------ | | | | 71| 4| \ | | | | 72| 4| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 4| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 4| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 4| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 4] | | | | ------------------ | | ------------------ ------------------ 110| |#if !defined(WINPR_CRITICAL_SECTION_DISABLE_SPINCOUNT) 111| | SYSTEM_INFO sysinfo; 112| | DWORD dwPreviousSpinCount = lpCriticalSection->SpinCount; 113| | 114| | if (dwSpinCount) 115| | { 116| | /* Don't spin on uniprocessor systems! */ 117| | GetNativeSystemInfo(&sysinfo); 118| | 119| | if (sysinfo.dwNumberOfProcessors < 2) 120| | dwSpinCount = 0; 121| | } 122| | 123| | lpCriticalSection->SpinCount = dwSpinCount; 124| | return dwPreviousSpinCount; 125| |#else 126| | // WLog_ERR("TODO", "TODO: implement"); 127| 4| return 0; 128| 4|#endif 129| 4|} EnterCriticalSection: 155| 5.67k|{ 156| 5.67k| WINPR_ASSERT(lpCriticalSection); ------------------ | | 76| 5.67k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 5.67k| do \ | | | | 61| 5.67k| { \ | | | | 62| 5.67k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 5.67k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 5.67k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 5.67k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 5.67k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 5.67k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 5.67k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 5.67k| \ | | | | 70| 5.67k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 5.67k| do \ | | | | | | 32| 5.67k| { \ | | | | | | 33| 5.67k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 5.67k] | | | | | | ------------------ | | | | | | 34| 5.67k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 5.67k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 5.67k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 5.67k| \ | | | | 72| 5.67k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 5.67k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 5.67k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 5.67k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 5.67k] | | | | ------------------ | | ------------------ ------------------ 157| |#if !defined(WINPR_CRITICAL_SECTION_DISABLE_SPINCOUNT) 158| | ULONG SpinCount = lpCriticalSection->SpinCount; 159| | 160| | /* If we're lucky or if the current thread is already owner we can return early */ 161| | if (SpinCount && TryEnterCriticalSection(lpCriticalSection)) 162| | return; 163| | 164| | /* Spin requested times but don't compete with another waiting thread */ 165| | while (SpinCount-- && lpCriticalSection->LockCount < 1) 166| | { 167| | /* Atomically try to acquire and check the if the section is free. */ 168| | if (InterlockedCompareExchange(&lpCriticalSection->LockCount, 0, -1) == -1) 169| | { 170| | lpCriticalSection->RecursionCount = 1; 171| | lpCriticalSection->OwningThread = (HANDLE)(ULONG_PTR)GetCurrentThreadId(); 172| | return; 173| | } 174| | 175| | /* Failed to get the lock. Let the scheduler know that we're spinning. */ 176| | if (sched_yield() != 0) 177| | { 178| | /** 179| | * On some operating systems sched_yield is a stub. 180| | * usleep should at least trigger a context switch if any thread is waiting. 181| | * A ThreadYield() would be nice in winpr ... 182| | */ 183| | usleep(1); 184| | } 185| | } 186| | 187| |#endif 188| | 189| | /* First try the fastest possible path to get the lock. */ 190| 5.67k| if (InterlockedIncrement(&lpCriticalSection->LockCount)) ------------------ | Branch (190:6): [True: 0, False: 5.67k] ------------------ 191| 0| { 192| | /* Section is already locked. Check if it is owned by the current thread. */ 193| 0| if (lpCriticalSection->OwningThread == (HANDLE)(ULONG_PTR)GetCurrentThreadId()) ------------------ | Branch (193:7): [True: 0, False: 0] ------------------ 194| 0| { 195| | /* Recursion. No need to wait. */ 196| 0| lpCriticalSection->RecursionCount++; 197| 0| return; 198| 0| } 199| | 200| | /* Section is locked by another thread. We have to wait. */ 201| 0| WaitForCriticalSection(lpCriticalSection); 202| 0| } 203| | 204| | /* We got the lock. Own it ... */ 205| 5.67k| lpCriticalSection->RecursionCount = 1; 206| 5.67k| lpCriticalSection->OwningThread = (HANDLE)(ULONG_PTR)GetCurrentThreadId(); 207| 5.67k|} LeaveCriticalSection: 236| 5.67k|{ 237| 5.67k| WINPR_ASSERT(lpCriticalSection); ------------------ | | 76| 5.67k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 5.67k| do \ | | | | 61| 5.67k| { \ | | | | 62| 5.67k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 5.67k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 5.67k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 5.67k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 5.67k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 5.67k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 5.67k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 5.67k| \ | | | | 70| 5.67k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 5.67k| do \ | | | | | | 32| 5.67k| { \ | | | | | | 33| 5.67k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 5.67k] | | | | | | ------------------ | | | | | | 34| 5.67k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 5.67k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 5.67k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 5.67k| \ | | | | 72| 5.67k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 5.67k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 5.67k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 5.67k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 5.67k] | | | | ------------------ | | ------------------ ------------------ 238| | 239| | /* Decrement RecursionCount and check if this is the last LeaveCriticalSection call ...*/ 240| 5.67k| if (--lpCriticalSection->RecursionCount < 1) ------------------ | Branch (240:6): [True: 5.67k, False: 0] ------------------ 241| 5.67k| { 242| | /* Last recursion, clear owner, unlock and if there are other waiting threads ... */ 243| 5.67k| lpCriticalSection->OwningThread = nullptr; 244| | 245| 5.67k| if (InterlockedDecrement(&lpCriticalSection->LockCount) >= 0) ------------------ | Branch (245:7): [True: 0, False: 5.67k] ------------------ 246| 0| { 247| | /* ...signal the semaphore to unblock the next waiting thread */ 248| 0| UnWaitCriticalSection(lpCriticalSection); 249| 0| } 250| 5.67k| } 251| 0| else 252| 0| { 253| 0| (void)InterlockedDecrement(&lpCriticalSection->LockCount); 254| 0| } 255| 5.67k|} DeleteCriticalSection: 258| 4|{ 259| 4| WINPR_ASSERT(lpCriticalSection); ------------------ | | 76| 4|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 4| do \ | | | | 61| 4| { \ | | | | 62| 4| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 4| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 4| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 4| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 4| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 4| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 4| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 4| \ | | | | 70| 4| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 4| do \ | | | | | | 32| 4| { \ | | | | | | 33| 4| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 4] | | | | | | ------------------ | | | | | | 34| 4| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 4| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 4] | | | | | | ------------------ | | | | ------------------ | | | | 71| 4| \ | | | | 72| 4| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 4| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 4| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 4| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 4] | | | | ------------------ | | ------------------ ------------------ 260| | 261| 4| lpCriticalSection->LockCount = -1; 262| 4| lpCriticalSection->SpinCount = 0; 263| 4| lpCriticalSection->RecursionCount = 0; 264| 4| lpCriticalSection->OwningThread = nullptr; 265| | 266| 4| if (lpCriticalSection->LockSemaphore != nullptr) ------------------ | Branch (266:6): [True: 4, False: 0] ------------------ 267| 4| { 268| |#if defined __APPLE__ 269| | semaphore_destroy(mach_task_self(), *((winpr_sem_t*)lpCriticalSection->LockSemaphore)); 270| |#else 271| 4| sem_destroy((winpr_sem_t*)lpCriticalSection->LockSemaphore); 272| 4|#endif 273| 4| free(lpCriticalSection->LockSemaphore); 274| 4| lpCriticalSection->LockSemaphore = nullptr; 275| 4| } 276| 4|} winpr_InitOnceExecuteOnce: 55| 236|{ 56| 236| for (;;) 57| 236| { 58| 236| switch ((ULONG_PTR)InitOnce->Ptr & 3) 59| 236| { 60| 235| case 2: ------------------ | Branch (60:4): [True: 235, False: 1] ------------------ 61| | /* already completed successfully */ 62| 235| return TRUE; ------------------ | | 126| 235|#define TRUE true ------------------ 63| | 64| 1| case 0: ------------------ | Branch (64:4): [True: 1, False: 235] ------------------ 65| | 66| | /* first time */ 67| 1| if (InterlockedCompareExchangePointer(&InitOnce->Ptr, (PVOID)1, (PVOID)0) != ------------------ | Branch (67:9): [True: 0, False: 1] ------------------ 68| 1| (PVOID)0) 69| 0| { 70| | /* some other thread was faster */ 71| 0| break; 72| 0| } 73| | 74| | /* it's our job to call the init function */ 75| 1| if (InitFn(InitOnce, Parameter, Context)) ------------------ | Branch (75:9): [True: 1, False: 0] ------------------ 76| 1| { 77| | /* success */ 78| 1| InitOnce->Ptr = (PVOID)2; 79| 1| return TRUE; ------------------ | | 126| 1|#define TRUE true ------------------ 80| 1| } 81| | 82| | /* the init function returned an error, reset the status */ 83| 0| InitOnce->Ptr = (PVOID)0; 84| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 85| | 86| 0| case 1: ------------------ | Branch (86:4): [True: 0, False: 236] ------------------ 87| | /* in progress */ 88| 0| break; 89| | 90| 0| default: ------------------ | Branch (90:4): [True: 0, False: 236] ------------------ 91| 0| WLog_ERR(TAG, "internal error"); ------------------ | | 348| 0| WLog_Print_dbg_tag(tag, WLOG_ERROR, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 92| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 93| 236| } 94| | 95| 0| Sleep(5); 96| 0| } 97| 236|} GetLocalTime: 308| 5.43k|{ 309| 5.43k| time_t ct = 0; 310| 5.43k| struct tm tres; 311| 5.43k| struct tm* ltm = nullptr; 312| 5.43k| WORD wMilliseconds = 0; 313| 5.43k| UINT64 now = winpr_GetUnixTimeNS(); 314| 5.43k| ct = WINPR_TIME_NS_TO_S(now); ------------------ | | 400| 5.43k|#define WINPR_TIME_NS_TO_S(ns) ((ns) / 1000000000ull) /** @since version 3.4.0 */ ------------------ 315| 5.43k| wMilliseconds = (WORD)(WINPR_TIME_NS_REM_MS(now)); ------------------ | | 406| 5.43k|#define WINPR_TIME_NS_REM_MS(ns) (WINPR_TIME_NS_REM_US(ns) / 1000ull) /** @since version 3.4.0 */ | | ------------------ | | | | 405| 5.43k|#define WINPR_TIME_NS_REM_US(ns) (WINPR_TIME_NS_REM_NS(ns) / 1000ull) /** @since version 3.4.0 */ | | | | ------------------ | | | | | | 404| 5.43k|#define WINPR_TIME_NS_REM_NS(ns) ((ns) % 1000000000ull) /** @since version 3.4.0 */ | | | | ------------------ | | ------------------ ------------------ 316| 5.43k| ltm = localtime_r(&ct, &tres); 317| 5.43k| ZeroMemory(lpSystemTime, sizeof(SYSTEMTIME)); ------------------ | | 126| 5.43k|#define ZeroMemory(Destination, Length) memset((Destination), 0, (Length)) ------------------ 318| | 319| 5.43k| if (ltm) ------------------ | Branch (319:6): [True: 5.43k, False: 0] ------------------ 320| 5.43k| { 321| 5.43k| lpSystemTime->wYear = (WORD)(ltm->tm_year + 1900); 322| 5.43k| lpSystemTime->wMonth = (WORD)(ltm->tm_mon + 1); 323| 5.43k| lpSystemTime->wDayOfWeek = (WORD)ltm->tm_wday; 324| 5.43k| lpSystemTime->wDay = (WORD)ltm->tm_mday; 325| 5.43k| lpSystemTime->wHour = (WORD)ltm->tm_hour; 326| 5.43k| lpSystemTime->wMinute = (WORD)ltm->tm_min; 327| 5.43k| lpSystemTime->wSecond = (WORD)ltm->tm_sec; 328| 5.43k| lpSystemTime->wMilliseconds = wMilliseconds; 329| 5.43k| } 330| 5.43k|} winpr_GetUnixTimeNS: 1042| 5.43k|{ 1043| |#if defined(_WIN32) 1044| | 1045| | union 1046| | { 1047| | UINT64 u64; 1048| | FILETIME ft; 1049| | } t = WINPR_C_ARRAY_INIT; 1050| | GetSystemTimeAsFileTime(&t.ft); 1051| | return (t.u64 - FILETIME_TO_UNIX_OFFSET_S * 10000000ull) * 100ull; 1052| |#elif defined(_POSIX_C_SOURCE) && (_POSIX_C_SOURCE >= 199309L) 1053| 5.43k| struct timespec ts = WINPR_C_ARRAY_INIT; ------------------ | | 85| 5.43k| { \ | | 86| 5.43k| } /** @since version 3.24.0 */ ------------------ 1054| 5.43k| if (clock_gettime(CLOCK_REALTIME, &ts) != 0) ------------------ | Branch (1054:6): [True: 0, False: 5.43k] ------------------ 1055| 0| return 0; 1056| 5.43k| return WINPR_ASSERTING_INT_CAST(uint64_t, ts.tv_sec) * 1000000000ull + ------------------ | | 180| 5.43k| __extension__({ \ | | 181| 5.43k| __typeof(ivar) var = ivar; \ | | 182| 5.43k| WINPR_ASSERT((var) == \ | | ------------------ | | | | 76| 5.43k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 5.43k| do \ | | | | | | 61| 5.43k| { \ | | | | | | 62| 5.43k| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 5.43k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 5.43k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 5.43k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 5.43k| \ | | | | | | 70| 5.43k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 5.43k| do \ | | | | | | | | 32| 5.43k| { \ | | | | | | | | 33| 5.43k| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 5.43k] | | | | | | | | ------------------ | | | | | | | | 34| 5.43k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 5.43k| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 5.43k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 5.43k| \ | | | | | | 72| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 5.43k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 5.43k| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 5.43k| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 5.43k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 183| 5.43k| WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \ | | 184| 5.43k| WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) || \ | | ------------------ | | | | 76| 5.43k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 5.43k| do \ | | | | | | 61| 5.43k| { \ | | | | | | 62| 5.43k| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 5.43k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 5.43k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 5.43k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 5.43k| \ | | | | | | 70| 5.43k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 5.43k| do \ | | | | | | | | 32| 5.43k| { \ | | | | | | | | 33| 16.3k| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:9): [True: 5.43k, False: 0] | | | | | | | | | Branch (33:9): [True: 5.43k, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 5.43k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 5.43k| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 5.43k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 5.43k| \ | | | | | | 72| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 5.43k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 5.43k| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 5.43k| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 5.43k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 185| 5.43k| (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0)); \ | | 186| 5.43k| WINPR_CXX_COMPAT_CAST(type, (var)); \ | | ------------------ | | | | 34| 5.43k|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ | | 187| 5.43k| }) ------------------ 1057| 5.43k| WINPR_ASSERTING_INT_CAST(uint64_t, ts.tv_nsec); ------------------ | | 180| 5.43k| __extension__({ \ | | 181| 5.43k| __typeof(ivar) var = ivar; \ | | 182| 5.43k| WINPR_ASSERT((var) == \ | | ------------------ | | | | 76| 5.43k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 5.43k| do \ | | | | | | 61| 5.43k| { \ | | | | | | 62| 5.43k| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 5.43k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 5.43k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 5.43k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 5.43k| \ | | | | | | 70| 5.43k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 5.43k| do \ | | | | | | | | 32| 5.43k| { \ | | | | | | | | 33| 5.43k| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 5.43k] | | | | | | | | ------------------ | | | | | | | | 34| 5.43k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 5.43k| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 5.43k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 5.43k| \ | | | | | | 72| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 5.43k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 5.43k| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 5.43k| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 5.43k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 183| 5.43k| WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \ | | 184| 5.43k| WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) || \ | | ------------------ | | | | 76| 5.43k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 5.43k| do \ | | | | | | 61| 5.43k| { \ | | | | | | 62| 5.43k| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 5.43k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 5.43k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 5.43k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 5.43k| \ | | | | | | 70| 5.43k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 5.43k| do \ | | | | | | | | 32| 5.43k| { \ | | | | | | | | 33| 16.3k| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:9): [True: 5.43k, False: 0] | | | | | | | | | Branch (33:9): [True: 5.43k, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 5.43k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 5.43k| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 5.43k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 5.43k| \ | | | | | | 72| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 5.43k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 5.43k| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 5.43k| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 5.43k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 185| 5.43k| (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0)); \ | | 186| 5.43k| WINPR_CXX_COMPAT_CAST(type, (var)); \ | | ------------------ | | | | 34| 5.43k|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ | | 187| 5.43k| }) ------------------ 1058| |#else 1059| | struct timeval tv = WINPR_C_ARRAY_INIT; 1060| | if (gettimeofday(&tv, nullptr) != 0) 1061| | return 0; 1062| | return tv.tv_sec * 1000000000ULL + tv.tv_usec * 1000ull; 1063| |#endif 1064| 5.43k|} GetCurrentProcessId: 684| 5.43k|{ 685| 5.43k| return ((DWORD)getpid()); 686| 5.43k|} GetCurrentThreadId: 910| 5.67k|{ 911| |#if defined(__FreeBSD__) 912| | return WINPR_CXX_COMPAT_CAST(DWORD, pthread_getthreadid_np()); 913| |#elif defined(__OpenBSD__) 914| | return WINPR_CXX_COMPAT_CAST(DWORD, getthrid()); 915| |#elif defined(__linux__) 916| 5.67k| return WINPR_CXX_COMPAT_CAST(DWORD, syscall(SYS_gettid)); ------------------ | | 34| 5.67k|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) ------------------ 917| |#else 918| | pthread_t tid = pthread_self(); 919| | /* Since pthread_t can be 64-bits on some systems, take just the */ 920| | /* lower 32-bits of it for the thread ID returned by this function. */ 921| | uintptr_t ptid = WINPR_REINTERPRET_CAST(tid, pthread_t, uintptr_t); 922| | return (ptid & UINT32_MAX) ^ (ptid >> 32); 923| |#endif 924| 5.67k|} winpr_atexit: 33| 1|{ 34| 1| atexit_count++; 35| 1| const int rc = atexit(fkt); 36| 1| if (rc != 0) ------------------ | Branch (36:6): [True: 0, False: 1] ------------------ 37| 0| { 38| 0| char buffer[128] = WINPR_C_ARRAY_INIT; ------------------ | | 85| 0| { \ | | 86| 0| } /** @since version 3.24.0 */ ------------------ 39| 0| WLog_ERR(TAG, "atexit[%" PRIuz "] failed: %s [%d]", atexit_count, ------------------ | | 348| 0| WLog_Print_dbg_tag(tag, WLOG_ERROR, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 40| 0| winpr_strerror(errno, buffer, sizeof(buffer)), errno); 41| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 42| 0| } 43| 1| return TRUE; ------------------ | | 126| 1|#define TRUE true ------------------ 44| 1|} winpr_backtrace_free: 68| 328|{ 69| 328| if (!buffer) ------------------ | Branch (69:6): [True: 0, False: 328] ------------------ 70| 0| return; 71| | 72| 328|#if defined(USE_UNWIND) 73| 328| winpr_unwind_backtrace_free(buffer); 74| |#elif defined(USE_EXECINFO) 75| | winpr_execinfo_backtrace_free(buffer); 76| |#elif defined(WINPR_HAVE_CORKSCREW) 77| | winpr_corkscrew_backtrace_free(buffer); 78| |#elif defined(_WIN32) || defined(_WIN64) 79| | winpr_win_backtrace_free(buffer); 80| |#else 81| | free(buffer); 82| | WLog_FATAL(TAG, "%s", support_msg); 83| |#endif 84| 328|} winpr_backtrace: 87| 328|{ 88| 328|#if defined(USE_UNWIND) 89| 328| return winpr_unwind_backtrace(size); 90| |#elif defined(USE_EXECINFO) 91| | return winpr_execinfo_backtrace(size); 92| |#elif defined(WINPR_HAVE_CORKSCREW) 93| | return winpr_corkscrew_backtrace(size); 94| |#elif (defined(_WIN32) || defined(_WIN64)) && !defined(_UWP) 95| | return winpr_win_backtrace(size); 96| |#else 97| | WLog_FATAL(TAG, "%s", support_msg); 98| | /* return a non nullptr buffer to allow the backtrace function family to succeed without failing 99| | */ 100| | return strndup(support_msg, sizeof(support_msg)); 101| |#endif 102| 328|} winpr_backtrace_symbols: 105| 328|{ 106| 328| if (used) ------------------ | Branch (106:6): [True: 328, False: 0] ------------------ 107| 328| *used = 0; 108| | 109| 328| if (!buffer) ------------------ | Branch (109:6): [True: 0, False: 328] ------------------ 110| 0| { 111| 0| WLog_FATAL(TAG, "%s", support_msg); ------------------ | | 350| 0| WLog_Print_dbg_tag(tag, WLOG_FATAL, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 112| 0| return nullptr; 113| 0| } 114| | 115| 328|#if defined(USE_UNWIND) 116| 328| return winpr_unwind_backtrace_symbols(buffer, used); 117| |#elif defined(USE_EXECINFO) 118| | return winpr_execinfo_backtrace_symbols(buffer, used); 119| |#elif defined(WINPR_HAVE_CORKSCREW) 120| | return winpr_corkscrew_backtrace_symbols(buffer, used); 121| |#elif (defined(_WIN32) || defined(_WIN64)) && !defined(_UWP) 122| | return winpr_win_backtrace_symbols(buffer, used); 123| |#else 124| | WLog_FATAL(TAG, "%s", support_msg); 125| | 126| | /* We return a char** on heap that is compatible with free: 127| | * 128| | * 1. We allocate sizeof(char*) + strlen + 1 bytes. 129| | * 2. The first sizeof(char*) bytes contain the pointer to the string following the pointer. 130| | * 3. The at data + sizeof(char*) contains the actual string 131| | */ 132| | size_t len = strnlen(support_msg, sizeof(support_msg)); 133| | char* ppmsg = calloc(sizeof(char*) + len + 1, sizeof(char)); 134| | if (!ppmsg) 135| | return nullptr; 136| | char** msgptr = (char**)ppmsg; 137| | char* msg = &ppmsg[sizeof(char*)]; 138| | 139| | *msgptr = msg; 140| | strncpy(msg, support_msg, len); 141| | *used = 1; 142| | return msgptr; 143| |#endif 144| 328|} winpr_log_backtrace_ex: 179| 328|{ 180| 328| if (!WLog_IsLevelActive(log, level)) ------------------ | Branch (180:6): [True: 0, False: 328] ------------------ 181| 0| return; 182| | 183| 328| size_t used = 0; 184| 328| char** msg = nullptr; 185| 328| void* stack = winpr_backtrace(20); 186| | 187| 328| if (!stack) ------------------ | Branch (187:6): [True: 0, False: 328] ------------------ 188| 0| { 189| 0| WLog_Print(log, WLOG_ERROR, "winpr_backtrace failed!\n"); ------------------ | | 257| 0| do \ | | 258| 0| { \ | | 259| 0| if (WLog_IsLevelActive(_log, _log_level)) \ | | ------------------ | | | Branch (259:7): [True: 0, False: 0] | | ------------------ | | 260| 0| { \ | | 261| 0| WLog_Print_unchecked(_log, _log_level, __VA_ARGS__); \ | | ------------------ | | | | 251| 0| do \ | | | | 252| 0| { \ | | | | 253| 0| WLog_PrintTextMessage(_log, _log_level, __LINE__, __FILE__, __func__, __VA_ARGS__); \ | | | | 254| 0| } while (0) | | | | ------------------ | | | | | Branch (254:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 262| 0| } \ | | 263| 0| } while (0) | | ------------------ | | | Branch (263:11): [Folded, False: 0] | | ------------------ ------------------ 190| 0| goto fail; 191| 0| } 192| | 193| 328| msg = winpr_backtrace_symbols(stack, &used); 194| | 195| 328| if (msg) ------------------ | Branch (195:6): [True: 328, False: 0] ------------------ 196| 328| { 197| 4.88k| for (size_t x = 0; x < used; x++) ------------------ | Branch (197:22): [True: 4.55k, False: 328] ------------------ 198| 4.55k| WLog_Print(log, level, "%" PRIuz ": %s", x, msg[x]); ------------------ | | 257| 4.55k| do \ | | 258| 4.55k| { \ | | 259| 4.55k| if (WLog_IsLevelActive(_log, _log_level)) \ | | ------------------ | | | Branch (259:7): [True: 4.55k, False: 0] | | ------------------ | | 260| 4.55k| { \ | | 261| 4.55k| WLog_Print_unchecked(_log, _log_level, __VA_ARGS__); \ | | ------------------ | | | | 251| 4.55k| do \ | | | | 252| 4.55k| { \ | | | | 253| 4.55k| WLog_PrintTextMessage(_log, _log_level, __LINE__, __FILE__, __func__, __VA_ARGS__); \ | | | | 254| 4.55k| } while (0) | | | | ------------------ | | | | | Branch (254:11): [Folded, False: 4.55k] | | | | ------------------ | | ------------------ | | 262| 4.55k| } \ | | 263| 4.55k| } while (0) | | ------------------ | | | Branch (263:11): [Folded, False: 4.55k] | | ------------------ ------------------ 199| 328| } 200| 328| free((void*)msg); 201| | 202| 328|fail: 203| 328| winpr_backtrace_free(stack); 204| 328|} writeBitmapFileHeader: 99| 249|{ 100| 249| if (!Stream_EnsureRemainingCapacity(s, sizeof(WINPR_BITMAP_FILE_HEADER))) ------------------ | Branch (100:6): [True: 0, False: 249] ------------------ 101| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 102| | 103| 249| Stream_Write_UINT8(s, bf->bfType[0]); ------------------ | | 857| 249| do \ | | 858| 249| { \ | | 859| 249| WINPR_ASSERT((v) <= UINT8_MAX); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 860| 249| WINPR_ASSERT((v) >= 0); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 861| 249| Stream_Write_UINT8_unchecked((s), (v)); \ | | 862| 249| } while (0) | | ------------------ | | | Branch (862:11): [Folded, False: 249] | | ------------------ ------------------ 104| 249| Stream_Write_UINT8(s, bf->bfType[1]); ------------------ | | 857| 249| do \ | | 858| 249| { \ | | 859| 249| WINPR_ASSERT((v) <= UINT8_MAX); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 860| 249| WINPR_ASSERT((v) >= 0); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 861| 249| Stream_Write_UINT8_unchecked((s), (v)); \ | | 862| 249| } while (0) | | ------------------ | | | Branch (862:11): [Folded, False: 249] | | ------------------ ------------------ 105| 249| Stream_Write_UINT32(s, bf->bfSize); ------------------ | | 1070| 249| do \ | | 1071| 249| { \ | | 1072| 249| WINPR_ASSERT((v) <= UINT32_MAX); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1073| 249| WINPR_ASSERT((v) >= 0); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1074| 249| Stream_Write_UINT32_unchecked((s), (v)); \ | | 1075| 249| } while (0) | | ------------------ | | | Branch (1075:11): [Folded, False: 249] | | ------------------ ------------------ 106| 249| Stream_Write_UINT16(s, bf->bfReserved1); ------------------ | | 908| 249| do \ | | 909| 249| { \ | | 910| 249| WINPR_ASSERT((v) <= UINT16_MAX); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 911| 249| WINPR_ASSERT((v) >= 0); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 912| 249| Stream_Write_UINT16_unchecked((s), (v)); \ | | 913| 249| } while (0) | | ------------------ | | | Branch (913:11): [Folded, False: 249] | | ------------------ ------------------ 107| 249| Stream_Write_UINT16(s, bf->bfReserved2); ------------------ | | 908| 249| do \ | | 909| 249| { \ | | 910| 249| WINPR_ASSERT((v) <= UINT16_MAX); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 911| 249| WINPR_ASSERT((v) >= 0); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 912| 249| Stream_Write_UINT16_unchecked((s), (v)); \ | | 913| 249| } while (0) | | ------------------ | | | Branch (913:11): [Folded, False: 249] | | ------------------ ------------------ 108| 249| Stream_Write_UINT32(s, bf->bfOffBits); ------------------ | | 1070| 249| do \ | | 1071| 249| { \ | | 1072| 249| WINPR_ASSERT((v) <= UINT32_MAX); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1073| 249| WINPR_ASSERT((v) >= 0); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1074| 249| Stream_Write_UINT32_unchecked((s), (v)); \ | | 1075| 249| } while (0) | | ------------------ | | | Branch (1075:11): [Folded, False: 249] | | ------------------ ------------------ 109| 249| return TRUE; ------------------ | | 126| 249|#define TRUE true ------------------ 110| 249|} readBitmapFileHeader: 113| 1.16k|{ 114| 1.16k| static wLog* log = nullptr; 115| 1.16k| if (!log) ------------------ | Branch (115:6): [True: 1, False: 1.16k] ------------------ 116| 1| log = WLog_Get(TAG); ------------------ | | 75| 1|#define TAG WINPR_TAG("utils.image") | | ------------------ | | | | 25| 1|#define WINPR_TAG(tag) "com.winpr." tag | | ------------------ ------------------ 117| | 118| 1.16k| if (!s || !bf || ------------------ | Branch (118:6): [True: 0, False: 1.16k] | Branch (118:12): [True: 0, False: 1.16k] ------------------ 119| 1.16k| (!Stream_CheckAndLogRequiredLengthWLog(log, s, sizeof(WINPR_BITMAP_FILE_HEADER)))) ------------------ | | 144| 1.16k| Stream_CheckAndLogRequiredLengthOfSizeWLog(log, s, len, 1) | | ------------------ | | | | 141| 1.16k| Stream_CheckAndLogRequiredLengthWLogEx(log, WLOG_WARN, s, nmemb, size, "%s(%s:%" PRIuz ")", \ | | | | 142| 1.16k| __func__, __FILE__, (size_t)__LINE__) | | ------------------ ------------------ | Branch (119:6): [True: 6, False: 1.15k] ------------------ 120| 6| return FALSE; ------------------ | | 122| 6|#define FALSE false ------------------ 121| | 122| 1.15k| Stream_Read_UINT8(s, bf->bfType[0]); ------------------ | | 647| 1.15k| do \ | | 648| 1.15k| { \ | | 649| 1.15k| _v = stream_read_u8(_s, TRUE); \ | | ------------------ | | | | 126| 1.15k|#define TRUE true | | ------------------ | | 650| 1.15k| } while (0) | | ------------------ | | | Branch (650:11): [Folded, False: 1.15k] | | ------------------ ------------------ 123| 1.15k| Stream_Read_UINT8(s, bf->bfType[1]); ------------------ | | 647| 1.15k| do \ | | 648| 1.15k| { \ | | 649| 1.15k| _v = stream_read_u8(_s, TRUE); \ | | ------------------ | | | | 126| 1.15k|#define TRUE true | | ------------------ | | 650| 1.15k| } while (0) | | ------------------ | | | Branch (650:11): [Folded, False: 1.15k] | | ------------------ ------------------ 124| 1.15k| Stream_Read_UINT32(s, bf->bfSize); ------------------ | | 683| 1.15k| do \ | | 684| 1.15k| { \ | | 685| 1.15k| _v = stream_read_u32_le(_s, TRUE); \ | | ------------------ | | | | 126| 1.15k|#define TRUE true | | ------------------ | | 686| 1.15k| } while (0) | | ------------------ | | | Branch (686:11): [Folded, False: 1.15k] | | ------------------ ------------------ 125| 1.15k| Stream_Read_UINT16(s, bf->bfReserved1); ------------------ | | 659| 1.15k| do \ | | 660| 1.15k| { \ | | 661| 1.15k| _v = stream_read_u16_le(_s, TRUE); \ | | ------------------ | | | | 126| 1.15k|#define TRUE true | | ------------------ | | 662| 1.15k| } while (0) | | ------------------ | | | Branch (662:11): [Folded, False: 1.15k] | | ------------------ ------------------ 126| 1.15k| Stream_Read_UINT16(s, bf->bfReserved2); ------------------ | | 659| 1.15k| do \ | | 660| 1.15k| { \ | | 661| 1.15k| _v = stream_read_u16_le(_s, TRUE); \ | | ------------------ | | | | 126| 1.15k|#define TRUE true | | ------------------ | | 662| 1.15k| } while (0) | | ------------------ | | | Branch (662:11): [Folded, False: 1.15k] | | ------------------ ------------------ 127| 1.15k| Stream_Read_UINT32(s, bf->bfOffBits); ------------------ | | 683| 1.15k| do \ | | 684| 1.15k| { \ | | 685| 1.15k| _v = stream_read_u32_le(_s, TRUE); \ | | ------------------ | | | | 126| 1.15k|#define TRUE true | | ------------------ | | 686| 1.15k| } while (0) | | ------------------ | | | Branch (686:11): [Folded, False: 1.15k] | | ------------------ ------------------ 128| | 129| 1.15k| if (bf->bfSize < sizeof(WINPR_BITMAP_FILE_HEADER)) ------------------ | Branch (129:6): [True: 7, False: 1.14k] ------------------ 130| 7| { 131| 7| WLog_Print(log, WLOG_ERROR, "Invalid bitmap::bfSize=%" PRIu32 ", require at least %" PRIuz, ------------------ | | 257| 7| do \ | | 258| 7| { \ | | 259| 7| if (WLog_IsLevelActive(_log, _log_level)) \ | | ------------------ | | | Branch (259:7): [True: 7, False: 0] | | ------------------ | | 260| 7| { \ | | 261| 7| WLog_Print_unchecked(_log, _log_level, __VA_ARGS__); \ | | ------------------ | | | | 251| 7| do \ | | | | 252| 7| { \ | | | | 253| 7| WLog_PrintTextMessage(_log, _log_level, __LINE__, __FILE__, __func__, __VA_ARGS__); \ | | | | 254| 7| } while (0) | | | | ------------------ | | | | | Branch (254:11): [Folded, False: 7] | | | | ------------------ | | ------------------ | | 262| 7| } \ | | 263| 7| } while (0) | | ------------------ | | | Branch (263:11): [Folded, False: 7] | | ------------------ ------------------ 132| 7| bf->bfSize, sizeof(WINPR_BITMAP_FILE_HEADER)); 133| 7| return FALSE; ------------------ | | 122| 7|#define FALSE false ------------------ 134| 7| } 135| | 136| 1.14k| if ((bf->bfType[0] != 'B') || (bf->bfType[1] != 'M')) ------------------ | Branch (136:6): [True: 0, False: 1.14k] | Branch (136:32): [True: 0, False: 1.14k] ------------------ 137| 0| { 138| 0| WLog_Print(log, WLOG_ERROR, "Invalid bitmap header [%c%c], expected [BM]", bf->bfType[0], ------------------ | | 257| 0| do \ | | 258| 0| { \ | | 259| 0| if (WLog_IsLevelActive(_log, _log_level)) \ | | ------------------ | | | Branch (259:7): [True: 0, False: 0] | | ------------------ | | 260| 0| { \ | | 261| 0| WLog_Print_unchecked(_log, _log_level, __VA_ARGS__); \ | | ------------------ | | | | 251| 0| do \ | | | | 252| 0| { \ | | | | 253| 0| WLog_PrintTextMessage(_log, _log_level, __LINE__, __FILE__, __func__, __VA_ARGS__); \ | | | | 254| 0| } while (0) | | | | ------------------ | | | | | Branch (254:11): [Folded, False: 0] | | | | ------------------ | | ------------------ | | 262| 0| } \ | | 263| 0| } while (0) | | ------------------ | | | Branch (263:11): [Folded, False: 0] | | ------------------ ------------------ 139| 0| bf->bfType[1]); 140| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 141| 0| } 142| 1.14k| return Stream_CheckAndLogRequiredLengthWLog(log, s, ------------------ | | 144| 1.14k| Stream_CheckAndLogRequiredLengthOfSizeWLog(log, s, len, 1) | | ------------------ | | | | 141| 1.14k| Stream_CheckAndLogRequiredLengthWLogEx(log, WLOG_WARN, s, nmemb, size, "%s(%s:%" PRIuz ")", \ | | | | 142| 1.14k| __func__, __FILE__, (size_t)__LINE__) | | ------------------ ------------------ 143| 1.14k| bf->bfSize - sizeof(WINPR_BITMAP_FILE_HEADER)); 144| 1.14k|} writeBitmapInfoHeader: 147| 249|{ 148| 249| if (!Stream_EnsureRemainingCapacity(s, sizeof(WINPR_BITMAP_INFO_HEADER))) ------------------ | Branch (148:6): [True: 0, False: 249] ------------------ 149| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 150| | 151| 249| Stream_Write_UINT32(s, bi->biSize); ------------------ | | 1070| 249| do \ | | 1071| 249| { \ | | 1072| 249| WINPR_ASSERT((v) <= UINT32_MAX); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1073| 249| WINPR_ASSERT((v) >= 0); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1074| 249| Stream_Write_UINT32_unchecked((s), (v)); \ | | 1075| 249| } while (0) | | ------------------ | | | Branch (1075:11): [Folded, False: 249] | | ------------------ ------------------ 152| 249| Stream_Write_INT32(s, bi->biWidth); ------------------ | | 1016| 249| do \ | | 1017| 249| { \ | | 1018| 249| WINPR_ASSERT((v) <= INT32_MAX); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1019| 249| WINPR_ASSERT((v) >= INT32_MIN); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1020| 249| Stream_Write_INT32_unchecked((s), (v)); \ | | 1021| 249| } while (0) | | ------------------ | | | Branch (1021:11): [Folded, False: 249] | | ------------------ ------------------ 153| 249| Stream_Write_INT32(s, bi->biHeight); ------------------ | | 1016| 249| do \ | | 1017| 249| { \ | | 1018| 249| WINPR_ASSERT((v) <= INT32_MAX); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1019| 249| WINPR_ASSERT((v) >= INT32_MIN); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1020| 249| Stream_Write_INT32_unchecked((s), (v)); \ | | 1021| 249| } while (0) | | ------------------ | | | Branch (1021:11): [Folded, False: 249] | | ------------------ ------------------ 154| 249| Stream_Write_UINT16(s, bi->biPlanes); ------------------ | | 908| 249| do \ | | 909| 249| { \ | | 910| 249| WINPR_ASSERT((v) <= UINT16_MAX); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 911| 249| WINPR_ASSERT((v) >= 0); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 912| 249| Stream_Write_UINT16_unchecked((s), (v)); \ | | 913| 249| } while (0) | | ------------------ | | | Branch (913:11): [Folded, False: 249] | | ------------------ ------------------ 155| 249| Stream_Write_UINT16(s, bi->biBitCount); ------------------ | | 908| 249| do \ | | 909| 249| { \ | | 910| 249| WINPR_ASSERT((v) <= UINT16_MAX); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 911| 249| WINPR_ASSERT((v) >= 0); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 912| 249| Stream_Write_UINT16_unchecked((s), (v)); \ | | 913| 249| } while (0) | | ------------------ | | | Branch (913:11): [Folded, False: 249] | | ------------------ ------------------ 156| 249| Stream_Write_UINT32(s, bi->biCompression); ------------------ | | 1070| 249| do \ | | 1071| 249| { \ | | 1072| 249| WINPR_ASSERT((v) <= UINT32_MAX); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1073| 249| WINPR_ASSERT((v) >= 0); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1074| 249| Stream_Write_UINT32_unchecked((s), (v)); \ | | 1075| 249| } while (0) | | ------------------ | | | Branch (1075:11): [Folded, False: 249] | | ------------------ ------------------ 157| 249| Stream_Write_UINT32(s, bi->biSizeImage); ------------------ | | 1070| 249| do \ | | 1071| 249| { \ | | 1072| 249| WINPR_ASSERT((v) <= UINT32_MAX); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1073| 249| WINPR_ASSERT((v) >= 0); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1074| 249| Stream_Write_UINT32_unchecked((s), (v)); \ | | 1075| 249| } while (0) | | ------------------ | | | Branch (1075:11): [Folded, False: 249] | | ------------------ ------------------ 158| 249| Stream_Write_INT32(s, bi->biXPelsPerMeter); ------------------ | | 1016| 249| do \ | | 1017| 249| { \ | | 1018| 249| WINPR_ASSERT((v) <= INT32_MAX); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1019| 249| WINPR_ASSERT((v) >= INT32_MIN); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1020| 249| Stream_Write_INT32_unchecked((s), (v)); \ | | 1021| 249| } while (0) | | ------------------ | | | Branch (1021:11): [Folded, False: 249] | | ------------------ ------------------ 159| 249| Stream_Write_INT32(s, bi->biYPelsPerMeter); ------------------ | | 1016| 249| do \ | | 1017| 249| { \ | | 1018| 249| WINPR_ASSERT((v) <= INT32_MAX); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1019| 249| WINPR_ASSERT((v) >= INT32_MIN); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1020| 249| Stream_Write_INT32_unchecked((s), (v)); \ | | 1021| 249| } while (0) | | ------------------ | | | Branch (1021:11): [Folded, False: 249] | | ------------------ ------------------ 160| 249| Stream_Write_UINT32(s, bi->biClrUsed); ------------------ | | 1070| 249| do \ | | 1071| 249| { \ | | 1072| 249| WINPR_ASSERT((v) <= UINT32_MAX); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1073| 249| WINPR_ASSERT((v) >= 0); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1074| 249| Stream_Write_UINT32_unchecked((s), (v)); \ | | 1075| 249| } while (0) | | ------------------ | | | Branch (1075:11): [Folded, False: 249] | | ------------------ ------------------ 161| 249| Stream_Write_UINT32(s, bi->biClrImportant); ------------------ | | 1070| 249| do \ | | 1071| 249| { \ | | 1072| 249| WINPR_ASSERT((v) <= UINT32_MAX); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1073| 249| WINPR_ASSERT((v) >= 0); \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 1074| 249| Stream_Write_UINT32_unchecked((s), (v)); \ | | 1075| 249| } while (0) | | ------------------ | | | Branch (1075:11): [Folded, False: 249] | | ------------------ ------------------ 162| 249| return TRUE; ------------------ | | 126| 249|#define TRUE true ------------------ 163| 249|} readBitmapInfoHeader: 166| 1.06k|{ 167| 1.06k| if (!s || !bi || (!Stream_CheckAndLogRequiredLength(TAG, s, sizeof(WINPR_BITMAP_INFO_HEADER)))) ------------------ | | 128| 1.06k| Stream_CheckAndLogRequiredLengthOfSize(tag, s, len, 1) | | ------------------ | | | | 125| 1.06k| Stream_CheckAndLogRequiredLengthEx(tag, WLOG_WARN, s, nmemb, size, "%s(%s:%" PRIuz ")", \ | | | | 126| 1.06k| __func__, __FILE__, (size_t)__LINE__) | | ------------------ ------------------ | Branch (167:6): [True: 0, False: 1.06k] | Branch (167:12): [True: 0, False: 1.06k] | Branch (167:19): [True: 9, False: 1.05k] ------------------ 168| 9| return FALSE; ------------------ | | 122| 9|#define FALSE false ------------------ 169| | 170| 1.05k| const size_t start = Stream_GetPosition(s); 171| 1.05k| Stream_Read_UINT32(s, bi->biSize); ------------------ | | 683| 1.05k| do \ | | 684| 1.05k| { \ | | 685| 1.05k| _v = stream_read_u32_le(_s, TRUE); \ | | ------------------ | | | | 126| 1.05k|#define TRUE true | | ------------------ | | 686| 1.05k| } while (0) | | ------------------ | | | Branch (686:11): [Folded, False: 1.05k] | | ------------------ ------------------ 172| 1.05k| Stream_Read_INT32(s, bi->biWidth); ------------------ | | 689| 1.05k| do \ | | 690| 1.05k| { \ | | 691| 1.05k| _v = stream_read_i32_le(_s, TRUE); \ | | ------------------ | | | | 126| 1.05k|#define TRUE true | | ------------------ | | 692| 1.05k| } while (0) | | ------------------ | | | Branch (692:11): [Folded, False: 1.05k] | | ------------------ ------------------ 173| 1.05k| Stream_Read_INT32(s, bi->biHeight); ------------------ | | 689| 1.05k| do \ | | 690| 1.05k| { \ | | 691| 1.05k| _v = stream_read_i32_le(_s, TRUE); \ | | ------------------ | | | | 126| 1.05k|#define TRUE true | | ------------------ | | 692| 1.05k| } while (0) | | ------------------ | | | Branch (692:11): [Folded, False: 1.05k] | | ------------------ ------------------ 174| 1.05k| Stream_Read_UINT16(s, bi->biPlanes); ------------------ | | 659| 1.05k| do \ | | 660| 1.05k| { \ | | 661| 1.05k| _v = stream_read_u16_le(_s, TRUE); \ | | ------------------ | | | | 126| 1.05k|#define TRUE true | | ------------------ | | 662| 1.05k| } while (0) | | ------------------ | | | Branch (662:11): [Folded, False: 1.05k] | | ------------------ ------------------ 175| 1.05k| Stream_Read_UINT16(s, bi->biBitCount); ------------------ | | 659| 1.05k| do \ | | 660| 1.05k| { \ | | 661| 1.05k| _v = stream_read_u16_le(_s, TRUE); \ | | ------------------ | | | | 126| 1.05k|#define TRUE true | | ------------------ | | 662| 1.05k| } while (0) | | ------------------ | | | Branch (662:11): [Folded, False: 1.05k] | | ------------------ ------------------ 176| 1.05k| Stream_Read_UINT32(s, bi->biCompression); ------------------ | | 683| 1.05k| do \ | | 684| 1.05k| { \ | | 685| 1.05k| _v = stream_read_u32_le(_s, TRUE); \ | | ------------------ | | | | 126| 1.05k|#define TRUE true | | ------------------ | | 686| 1.05k| } while (0) | | ------------------ | | | Branch (686:11): [Folded, False: 1.05k] | | ------------------ ------------------ 177| 1.05k| Stream_Read_UINT32(s, bi->biSizeImage); ------------------ | | 683| 1.05k| do \ | | 684| 1.05k| { \ | | 685| 1.05k| _v = stream_read_u32_le(_s, TRUE); \ | | ------------------ | | | | 126| 1.05k|#define TRUE true | | ------------------ | | 686| 1.05k| } while (0) | | ------------------ | | | Branch (686:11): [Folded, False: 1.05k] | | ------------------ ------------------ 178| 1.05k| Stream_Read_INT32(s, bi->biXPelsPerMeter); ------------------ | | 689| 1.05k| do \ | | 690| 1.05k| { \ | | 691| 1.05k| _v = stream_read_i32_le(_s, TRUE); \ | | ------------------ | | | | 126| 1.05k|#define TRUE true | | ------------------ | | 692| 1.05k| } while (0) | | ------------------ | | | Branch (692:11): [Folded, False: 1.05k] | | ------------------ ------------------ 179| 1.05k| Stream_Read_INT32(s, bi->biYPelsPerMeter); ------------------ | | 689| 1.05k| do \ | | 690| 1.05k| { \ | | 691| 1.05k| _v = stream_read_i32_le(_s, TRUE); \ | | ------------------ | | | | 126| 1.05k|#define TRUE true | | ------------------ | | 692| 1.05k| } while (0) | | ------------------ | | | Branch (692:11): [Folded, False: 1.05k] | | ------------------ ------------------ 180| 1.05k| Stream_Read_UINT32(s, bi->biClrUsed); ------------------ | | 683| 1.05k| do \ | | 684| 1.05k| { \ | | 685| 1.05k| _v = stream_read_u32_le(_s, TRUE); \ | | ------------------ | | | | 126| 1.05k|#define TRUE true | | ------------------ | | 686| 1.05k| } while (0) | | ------------------ | | | Branch (686:11): [Folded, False: 1.05k] | | ------------------ ------------------ 181| 1.05k| Stream_Read_UINT32(s, bi->biClrImportant); ------------------ | | 683| 1.05k| do \ | | 684| 1.05k| { \ | | 685| 1.05k| _v = stream_read_u32_le(_s, TRUE); \ | | ------------------ | | | | 126| 1.05k|#define TRUE true | | ------------------ | | 686| 1.05k| } while (0) | | ------------------ | | | Branch (686:11): [Folded, False: 1.05k] | | ------------------ ------------------ 182| | 183| 1.05k| switch (bi->biBitCount) 184| 1.05k| { 185| 286| case 1: ------------------ | Branch (185:3): [True: 286, False: 765] ------------------ 186| 362| case 4: ------------------ | Branch (186:3): [True: 76, False: 975] ------------------ 187| 456| case 8: ------------------ | Branch (187:3): [True: 94, False: 957] ------------------ 188| 744| case 16: ------------------ | Branch (188:3): [True: 288, False: 763] ------------------ 189| 933| case 24: ------------------ | Branch (189:3): [True: 189, False: 862] ------------------ 190| 945| case 32: ------------------ | Branch (190:3): [True: 12, False: 1.03k] ------------------ 191| 945| break; 192| 106| default: ------------------ | Branch (192:3): [True: 106, False: 945] ------------------ 193| 106| WLog_WARN(TAG, "invalid biBitCount=%" PRIu32, bi->biBitCount); ------------------ | | 346| 106| WLog_Print_dbg_tag(tag, WLOG_WARN, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 194| 106| return FALSE; ------------------ | | 122| 106|#define FALSE false ------------------ 195| 1.05k| } 196| | 197| 945| if (bi->biWidth < 0) ------------------ | Branch (197:6): [True: 30, False: 915] ------------------ 198| 30| { 199| 30| WLog_WARN(TAG, "negative biWidth=%" PRId32, bi->biWidth); ------------------ | | 346| 30| WLog_Print_dbg_tag(tag, WLOG_WARN, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 200| 30| return FALSE; ------------------ | | 122| 30|#define FALSE false ------------------ 201| 30| } 202| | 203| | /* https://learn.microsoft.com/en-us/windows/win32/api/wingdi/ns-wingdi-bitmapinfoheader */ 204| 915| size_t offset = 0; 205| 915| switch (bi->biCompression) 206| 915| { 207| 834| case BI_RGB: ------------------ | | 160| 834|#define BI_RGB 0 ------------------ | Branch (207:3): [True: 834, False: 81] ------------------ 208| 834| if (bi->biBitCount <= 8) ------------------ | Branch (208:8): [True: 428, False: 406] ------------------ 209| 428| { 210| 428| DWORD used = bi->biClrUsed; 211| 428| if (used == 0) ------------------ | Branch (211:9): [True: 79, False: 349] ------------------ 212| 79| used = 1u << bi->biBitCount; 213| 428| offset += sizeof(RGBQUAD) * used; 214| 428| } 215| 834| if (bi->biSizeImage == 0) ------------------ | Branch (215:8): [True: 347, False: 487] ------------------ 216| 347| { 217| 347| const UINT64 rawustride = 218| 347| WINPR_ASSERTING_INT_CAST(UINT64, bi->biWidth) * bi->biBitCount; ------------------ | | 180| 347| __extension__({ \ | | 181| 347| __typeof(ivar) var = ivar; \ | | 182| 347| WINPR_ASSERT((var) == \ | | ------------------ | | | | 76| 347|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 347| do \ | | | | | | 61| 347| { \ | | | | | | 62| 347| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 347| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 347| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 347| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 347| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 347| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 347| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 347| \ | | | | | | 70| 347| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 347| do \ | | | | | | | | 32| 347| { \ | | | | | | | | 33| 347| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 347] | | | | | | | | ------------------ | | | | | | | | 34| 347| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 347| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 347] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 347| \ | | | | | | 72| 347| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 347| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 347| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 347| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 347] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 183| 347| WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \ | | 184| 347| WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) || \ | | ------------------ | | | | 76| 347|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 347| do \ | | | | | | 61| 347| { \ | | | | | | 62| 347| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 347| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 347| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 347| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 347| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 347| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 347| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 347| \ | | | | | | 70| 347| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 347| do \ | | | | | | | | 32| 347| { \ | | | | | | | | 33| 1.04k| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:9): [True: 347, False: 0] | | | | | | | | | Branch (33:9): [True: 347, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 347| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 347| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 347] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 347| \ | | | | | | 72| 347| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 347| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 347| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 347| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 347] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 185| 347| (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0)); \ | | 186| 347| WINPR_CXX_COMPAT_CAST(type, (var)); \ | | ------------------ | | | | 34| 347|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ | | 187| 347| }) ------------------ 219| 347| const UINT64 ustride = ((rawustride + 31) & ~31u) >> 3; 220| 347| if (ustride > UINT32_MAX) ------------------ | Branch (220:9): [True: 0, False: 347] ------------------ 221| 0| { 222| 0| WLog_ERR(TAG, "bi->biWidth * bi->biBitCount > UINT32_MAX"); ------------------ | | 348| 0| WLog_Print_dbg_tag(tag, WLOG_ERROR, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 223| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 224| 0| } 225| | 226| 347| const UINT32 stride = WINPR_ASSERTING_INT_CAST(uint32_t, ustride); ------------------ | | 180| 347| __extension__({ \ | | 181| 347| __typeof(ivar) var = ivar; \ | | 182| 347| WINPR_ASSERT((var) == \ | | ------------------ | | | | 76| 347|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 347| do \ | | | | | | 61| 347| { \ | | | | | | 62| 347| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 347| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 347| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 347| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 347| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 347| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 347| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 347| \ | | | | | | 70| 347| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 347| do \ | | | | | | | | 32| 347| { \ | | | | | | | | 33| 347| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 347] | | | | | | | | ------------------ | | | | | | | | 34| 347| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 347| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 347] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 347| \ | | | | | | 72| 347| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 347| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 347| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 347| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 347] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 183| 347| WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \ | | 184| 347| WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) || \ | | ------------------ | | | | 76| 347|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 347| do \ | | | | | | 61| 347| { \ | | | | | | 62| 347| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 347| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 347| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 347| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 347| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 347| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 347| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 347| \ | | | | | | 70| 347| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 347| do \ | | | | | | | | 32| 347| { \ | | | | | | | | 33| 1.04k| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:9): [True: 347, False: 0] | | | | | | | | | Branch (33:9): [True: 347, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 347| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 347| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 347] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 347| \ | | | | | | 72| 347| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 347| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 347| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 347| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 347] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 185| 347| (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0)); \ | | 186| 347| WINPR_CXX_COMPAT_CAST(type, (var)); \ | | ------------------ | | | | 34| 347|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ | | 187| 347| }) ------------------ 227| 347| const UINT64 usize = WINPR_ASSERTING_INT_CAST(UINT64, llabs(bi->biHeight)) * stride; ------------------ | | 180| 347| __extension__({ \ | | 181| 347| __typeof(ivar) var = ivar; \ | | 182| 347| WINPR_ASSERT((var) == \ | | ------------------ | | | | 76| 347|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 347| do \ | | | | | | 61| 347| { \ | | | | | | 62| 347| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 347| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 347| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 347| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 347| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 347| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 347| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 347| \ | | | | | | 70| 347| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 347| do \ | | | | | | | | 32| 347| { \ | | | | | | | | 33| 347| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 347] | | | | | | | | ------------------ | | | | | | | | 34| 347| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 347| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 347] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 347| \ | | | | | | 72| 347| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 347| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 347| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 347| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 347] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 183| 347| WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \ | | 184| 347| WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) || \ | | ------------------ | | | | 76| 347|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 347| do \ | | | | | | 61| 347| { \ | | | | | | 62| 347| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 347| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 347| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 347| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 347| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 347| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 347| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 347| \ | | | | | | 70| 347| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 347| do \ | | | | | | | | 32| 347| { \ | | | | | | | | 33| 1.04k| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:9): [True: 346, False: 1] | | | | | | | | | Branch (33:9): [True: 346, False: 0] | | | | | | | | | Branch (33:9): [True: 1, False: 0] | | | | | | | | | Branch (33:9): [True: 1, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 347| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 347| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 347] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 347| \ | | | | | | 72| 347| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 347| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 347| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 347| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 347] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 185| 347| (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0)); \ | | 186| 347| WINPR_CXX_COMPAT_CAST(type, (var)); \ | | ------------------ | | | | 34| 347|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ | | 187| 347| }) ------------------ 228| 347| if (usize > UINT32_MAX) ------------------ | Branch (228:9): [True: 37, False: 310] ------------------ 229| 37| { 230| 37| WLog_ERR(TAG, "abs(bi->biHeight) * stride > UINT32_MAX"); ------------------ | | 348| 37| WLog_Print_dbg_tag(tag, WLOG_ERROR, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 231| 37| return FALSE; ------------------ | | 122| 37|#define FALSE false ------------------ 232| 37| } 233| 310| bi->biSizeImage = WINPR_ASSERTING_INT_CAST(uint32_t, usize); ------------------ | | 180| 310| __extension__({ \ | | 181| 310| __typeof(ivar) var = ivar; \ | | 182| 310| WINPR_ASSERT((var) == \ | | ------------------ | | | | 76| 310|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 310| do \ | | | | | | 61| 310| { \ | | | | | | 62| 310| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 310| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 310| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 310| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 310| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 310| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 310| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 310| \ | | | | | | 70| 310| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 310| do \ | | | | | | | | 32| 310| { \ | | | | | | | | 33| 310| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 310] | | | | | | | | ------------------ | | | | | | | | 34| 310| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 310| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 310] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 310| \ | | | | | | 72| 310| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 310| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 310| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 310| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 310] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 183| 310| WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \ | | 184| 310| WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) || \ | | ------------------ | | | | 76| 310|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 310| do \ | | | | | | 61| 310| { \ | | | | | | 62| 310| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 310| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 310| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 310| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 310| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 310| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 310| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 310| \ | | | | | | 70| 310| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 310| do \ | | | | | | | | 32| 310| { \ | | | | | | | | 33| 932| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:9): [True: 309, False: 1] | | | | | | | | | Branch (33:9): [True: 309, False: 0] | | | | | | | | | Branch (33:9): [True: 1, False: 0] | | | | | | | | | Branch (33:9): [True: 1, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 310| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 310| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 310] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 310| \ | | | | | | 72| 310| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 310| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 310| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 310| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 310] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 185| 310| (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0)); \ | | 186| 310| WINPR_CXX_COMPAT_CAST(type, (var)); \ | | ------------------ | | | | 34| 310|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ | | 187| 310| }) ------------------ 234| 310| } 235| 797| break; 236| 797| case BI_BITFIELDS: ------------------ | | 163| 76|#define BI_BITFIELDS 3 ------------------ | Branch (236:3): [True: 76, False: 839] ------------------ 237| | /* BITMAPV4HEADER and BITMAPV5HEADER include the color masks in biSize. */ 238| 76| if (bi->biSize == sizeof(WINPR_BITMAP_INFO_HEADER)) ------------------ | Branch (238:8): [True: 11, False: 65] ------------------ 239| 11| offset += sizeof(DWORD) * 3; // 3 DWORD color masks 240| 76| break; 241| 5| default: ------------------ | Branch (241:3): [True: 5, False: 910] ------------------ 242| 5| WLog_ERR(TAG, "unsupported biCompression %" PRIu32, bi->biCompression); ------------------ | | 348| 5| WLog_Print_dbg_tag(tag, WLOG_ERROR, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 243| 5| return FALSE; ------------------ | | 122| 5|#define FALSE false ------------------ 244| 915| } 245| | 246| 873| if (bi->biSizeImage == 0) ------------------ | Branch (246:6): [True: 2, False: 871] ------------------ 247| 2| { 248| 2| WLog_ERR(TAG, "invalid biSizeImage %" PRIu32, bi->biSizeImage); ------------------ | | 348| 2| WLog_Print_dbg_tag(tag, WLOG_ERROR, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 249| 2| return FALSE; ------------------ | | 122| 2|#define FALSE false ------------------ 250| 2| } 251| | 252| 871| const size_t pos = Stream_GetPosition(s) - start; 253| 871| if (bi->biSize < pos) ------------------ | Branch (253:6): [True: 14, False: 857] ------------------ 254| 14| { 255| 14| WLog_ERR(TAG, "invalid biSize %" PRIu32 " < (actual) offset %" PRIuz, bi->biSize, pos); ------------------ | | 348| 14| WLog_Print_dbg_tag(tag, WLOG_ERROR, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 256| 14| return FALSE; ------------------ | | 122| 14|#define FALSE false ------------------ 257| 14| } 258| | 259| 857| *poffset = offset; 260| 857| return Stream_SafeSeek(s, bi->biSize - pos); ------------------ | | 1393| 857|#define Stream_SafeSeek(s, size) Stream_SafeSeekEx(s, size, __FILE__, __LINE__, __func__) ------------------ 261| 871|} winpr_image_read_buffer: 728| 1.43k|{ 729| 1.43k| BYTE sig[12] = WINPR_C_ARRAY_INIT; ------------------ | | 85| 1.43k| { \ | | 86| 1.43k| } /** @since version 3.24.0 */ ------------------ 730| 1.43k| int status = -1; 731| | 732| 1.43k| if (size < sizeof(sig)) ------------------ | Branch (732:6): [True: 7, False: 1.42k] ------------------ 733| 7| return -1; 734| | 735| 1.42k| CopyMemory(sig, buffer, sizeof(sig)); ------------------ | | 123| 1.42k|#define CopyMemory(Destination, Source, Length) memcpy((Destination), (Source), (Length)) ------------------ 736| | 737| 1.42k| if ((sig[0] == 'B') && (sig[1] == 'M')) ------------------ | Branch (737:6): [True: 1.16k, False: 266] | Branch (737:25): [True: 1.16k, False: 2] ------------------ 738| 1.16k| { 739| 1.16k| image->type = WINPR_IMAGE_BITMAP; ------------------ | | 66| 1.16k|#define WINPR_IMAGE_BITMAP 0 ------------------ 740| 1.16k| status = winpr_image_bitmap_read_buffer(image, buffer, size); 741| 1.16k| } 742| 268| else if ((sig[0] == 'R') && (sig[1] == 'I') && (sig[2] == 'F') && (sig[3] == 'F') && ------------------ | Branch (742:11): [True: 79, False: 189] | Branch (742:30): [True: 69, False: 10] | Branch (742:49): [True: 58, False: 11] | Branch (742:68): [True: 47, False: 11] ------------------ 743| 47| (sig[8] == 'W') && (sig[9] == 'E') && (sig[10] == 'B') && (sig[11] == 'P')) ------------------ | Branch (743:11): [True: 35, False: 12] | Branch (743:30): [True: 23, False: 12] | Branch (743:49): [True: 12, False: 11] | Branch (743:69): [True: 1, False: 11] ------------------ 744| 1| { 745| 1| image->type = WINPR_IMAGE_WEBP; ------------------ | | 69| 1|#define WINPR_IMAGE_WEBP 3 /** @since version 3.3.0 */ ------------------ 746| 1| const SSIZE_T rc = 747| 1| winpr_convert_from_webp(buffer, size, &image->width, &image->height, 748| 1| &image->bitsPerPixel, &image->data, &image->scanline); 749| 1| if (rc >= 0) ------------------ | Branch (749:7): [True: 0, False: 1] ------------------ 750| 0| { 751| 0| image->bytesPerPixel = (image->bitsPerPixel + 7) / 8; 752| 0| status = 1; 753| 0| } 754| 1| } 755| 267| else if ((sig[0] == 0xFF) && (sig[1] == 0xD8) && (sig[2] == 0xFF) && (sig[3] == 0xE0) && ------------------ | Branch (755:11): [True: 85, False: 182] | Branch (755:31): [True: 73, False: 12] | Branch (755:51): [True: 61, False: 12] | Branch (755:71): [True: 49, False: 12] ------------------ 756| 49| (sig[6] == 0x4A) && (sig[7] == 0x46) && (sig[8] == 0x49) && (sig[9] == 0x46) && ------------------ | Branch (756:11): [True: 38, False: 11] | Branch (756:31): [True: 26, False: 12] | Branch (756:51): [True: 15, False: 11] | Branch (756:71): [True: 10, False: 5] ------------------ 757| 10| (sig[10] == 0x00)) ------------------ | Branch (757:11): [True: 1, False: 9] ------------------ 758| 1| { 759| 1| image->type = WINPR_IMAGE_JPEG; ------------------ | | 68| 1|#define WINPR_IMAGE_JPEG 2 /** @since version 3.3.0 */ ------------------ 760| 1| const SSIZE_T rc = 761| 1| winpr_convert_from_jpeg(buffer, size, &image->width, &image->height, 762| 1| &image->bitsPerPixel, &image->data, &image->scanline); 763| 1| if (rc >= 0) ------------------ | Branch (763:7): [True: 0, False: 1] ------------------ 764| 0| { 765| 0| image->bytesPerPixel = (image->bitsPerPixel + 7) / 8; 766| 0| status = 1; 767| 0| } 768| 1| } 769| 266| else if ((sig[0] == 0x89) && (sig[1] == 'P') && (sig[2] == 'N') && (sig[3] == 'G') && ------------------ | Branch (769:11): [True: 74, False: 192] | Branch (769:31): [True: 61, False: 13] | Branch (769:50): [True: 49, False: 12] | Branch (769:69): [True: 39, False: 10] ------------------ 770| 39| (sig[4] == '\r') && (sig[5] == '\n') && (sig[6] == 0x1A) && (sig[7] == '\n')) ------------------ | Branch (770:11): [True: 30, False: 9] | Branch (770:31): [True: 21, False: 9] | Branch (770:51): [True: 11, False: 10] | Branch (770:71): [True: 1, False: 10] ------------------ 771| 1| { 772| 1| image->type = WINPR_IMAGE_PNG; ------------------ | | 67| 1|#define WINPR_IMAGE_PNG 1 ------------------ 773| 1| const SSIZE_T rc = 774| 1| winpr_convert_from_png(buffer, size, &image->width, &image->height, 775| 1| &image->bitsPerPixel, &image->data, &image->scanline); 776| 1| if (rc >= 0) ------------------ | Branch (776:7): [True: 0, False: 1] ------------------ 777| 0| { 778| 0| image->bytesPerPixel = (image->bitsPerPixel + 7) / 8; 779| 0| status = 1; 780| 0| } 781| 1| } 782| | 783| 1.42k| return status; 784| 1.43k|} winpr_image_new: 787| 1.43k|{ 788| 1.43k| wImage* image = (wImage*)calloc(1, sizeof(wImage)); 789| | 790| 1.43k| if (!image) ------------------ | Branch (790:6): [True: 0, False: 1.43k] ------------------ 791| 0| return nullptr; 792| | 793| 1.43k| return image; 794| 1.43k|} winpr_image_free: 797| 1.43k|{ 798| 1.43k| if (!image) ------------------ | Branch (798:6): [True: 0, False: 1.43k] ------------------ 799| 0| return; 800| | 801| 1.43k| if (bFreeBuffer) ------------------ | Branch (801:6): [True: 1.43k, False: 0] ------------------ 802| 1.43k| free(image->data); 803| | 804| 1.43k| free(image); 805| 1.43k|} winpr_image_write_buffer: 1598| 249|{ 1599| 249| WINPR_ASSERT(image); ------------------ | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 249| do \ | | | | 61| 249| { \ | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 249| \ | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 249| do \ | | | | | | 32| 249| { \ | | | | | | 33| 249| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | ------------------ | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | | | 71| 249| \ | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 249| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 249] | | | | ------------------ | | ------------------ ------------------ 1600| 249| switch (format) 1601| 249| { 1602| 249| case WINPR_IMAGE_BITMAP: ------------------ | | 66| 249|#define WINPR_IMAGE_BITMAP 0 ------------------ | Branch (1602:3): [True: 249, False: 0] ------------------ 1603| 249| { 1604| 249| UINT32 outsize = 0; 1605| 249| size_t size = 1ull * image->height * image->scanline; 1606| 249| void* data = winpr_bitmap_write_buffer(image->data, size, image->width, image->height, 1607| 249| image->scanline, image->bitsPerPixel, &outsize); 1608| 249| *psize = outsize; 1609| 249| return data; 1610| 0| } 1611| 0| case WINPR_IMAGE_WEBP: ------------------ | | 69| 0|#define WINPR_IMAGE_WEBP 3 /** @since version 3.3.0 */ ------------------ | Branch (1611:3): [True: 0, False: 249] ------------------ 1612| 0| { 1613| 0| UINT32 outsize = 0; 1614| 0| size_t size = 1ull * image->height * image->scanline; 1615| 0| void* data = winpr_convert_to_webp(image->data, size, image->width, image->height, 1616| 0| image->scanline, image->bitsPerPixel, &outsize); 1617| 0| *psize = outsize; 1618| 0| return data; 1619| 0| } 1620| 0| case WINPR_IMAGE_JPEG: ------------------ | | 68| 0|#define WINPR_IMAGE_JPEG 2 /** @since version 3.3.0 */ ------------------ | Branch (1620:3): [True: 0, False: 249] ------------------ 1621| 0| { 1622| 0| UINT32 outsize = 0; 1623| 0| size_t size = 1ull * image->height * image->scanline; 1624| 0| void* data = winpr_convert_to_jpeg(image->data, size, image->width, image->height, 1625| 0| image->scanline, image->bitsPerPixel, &outsize); 1626| 0| *psize = outsize; 1627| 0| return data; 1628| 0| } 1629| 0| case WINPR_IMAGE_PNG: ------------------ | | 67| 0|#define WINPR_IMAGE_PNG 1 ------------------ | Branch (1629:3): [True: 0, False: 249] ------------------ 1630| 0| { 1631| 0| UINT32 outsize = 0; 1632| 0| size_t size = 1ull * image->height * image->scanline; 1633| 0| void* data = winpr_convert_to_png(image->data, size, image->width, image->height, 1634| 0| image->scanline, image->bitsPerPixel, &outsize); 1635| 0| *psize = outsize; 1636| 0| return data; 1637| 0| } 1638| 0| default: ------------------ | Branch (1638:3): [True: 0, False: 249] ------------------ 1639| 0| *psize = 0; 1640| 0| return nullptr; 1641| 249| } 1642| 249|} image.c:winpr_bitmap_construct_header_stream: 266| 249|{ 267| 249| WINPR_BITMAP_FILE_HEADER bf = WINPR_C_ARRAY_INIT; ------------------ | | 85| 249| { \ | | 86| 249| } /** @since version 3.24.0 */ ------------------ 268| 249| WINPR_BITMAP_INFO_HEADER bi = WINPR_C_ARRAY_INIT; ------------------ | | 85| 249| { \ | | 86| 249| } /** @since version 3.24.0 */ ------------------ 269| | 270| 249| size_t stride = (width * bpp + 7) / 8; 271| 249| if ((stride % 4) != 0) ------------------ | Branch (271:6): [True: 202, False: 47] ------------------ 272| 202| stride += 4 - (stride % 4); 273| | 274| 249| size_t imgSize = stride * height; 275| 249| if ((width > INT32_MAX) || (height > INT32_MAX) || (bpp > UINT16_MAX) || (imgSize > UINT32_MAX)) ------------------ | Branch (275:6): [True: 0, False: 249] | Branch (275:29): [True: 0, False: 249] | Branch (275:53): [True: 0, False: 249] | Branch (275:75): [True: 0, False: 249] ------------------ 276| 0| return nullptr; 277| | 278| 249| wStream* s = Stream_New(nullptr, WINPR_IMAGE_BMP_HEADER_LEN); ------------------ | | 72| 249|#define WINPR_IMAGE_BMP_HEADER_LEN 54 ------------------ 279| 249| if (!s) ------------------ | Branch (279:6): [True: 0, False: 249] ------------------ 280| 0| return nullptr; 281| | 282| 249| bf.bfType[0] = 'B'; 283| 249| bf.bfType[1] = 'M'; 284| 249| bf.bfReserved1 = 0; 285| 249| bf.bfReserved2 = 0; 286| 249| bi.biSize = (UINT32)sizeof(WINPR_BITMAP_INFO_HEADER); 287| 249| bf.bfOffBits = (UINT32)sizeof(WINPR_BITMAP_FILE_HEADER) + bi.biSize; 288| 249| bi.biSizeImage = (UINT32)imgSize; 289| 249| bf.bfSize = bf.bfOffBits + bi.biSizeImage; 290| 249| bi.biWidth = (INT32)width; 291| 249| bi.biHeight = bottomUp ? (INT32)height : -1 * (INT32)height; ------------------ | Branch (291:16): [True: 249, False: 0] ------------------ 292| 249| bi.biPlanes = 1; 293| 249| bi.biBitCount = (UINT16)bpp; 294| 249| bi.biCompression = BI_RGB; ------------------ | | 160| 249|#define BI_RGB 0 ------------------ 295| 249| bi.biXPelsPerMeter = (INT32)width; 296| 249| bi.biYPelsPerMeter = (INT32)height; 297| 249| bi.biClrUsed = 0; 298| 249| bi.biClrImportant = 0; 299| | 300| 249| size_t offset = 0; 301| 249| switch (bi.biCompression) 302| 249| { 303| 249| case BI_RGB: ------------------ | | 160| 249|#define BI_RGB 0 ------------------ | Branch (303:3): [True: 249, False: 0] ------------------ 304| 249| if (bi.biBitCount <= 8) ------------------ | Branch (304:8): [True: 130, False: 119] ------------------ 305| 130| { 306| 130| DWORD used = bi.biClrUsed; 307| 130| if (used == 0) ------------------ | Branch (307:9): [True: 130, False: 0] ------------------ 308| 130| used = 1u << bi.biBitCount; 309| 130| offset += sizeof(RGBQUAD) * used; 310| 130| } 311| 249| if (bi.biSizeImage == 0) ------------------ | Branch (311:8): [True: 0, False: 249] ------------------ 312| 0| { 313| 0| const UINT64 rawustride = 314| 0| WINPR_ASSERTING_INT_CAST(UINT64, bi.biWidth) * bi.biBitCount; ------------------ | | 180| 0| __extension__({ \ | | 181| 0| __typeof(ivar) var = ivar; \ | | 182| 0| WINPR_ASSERT((var) == \ | | ------------------ | | | | 76| 0|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 0| do \ | | | | | | 61| 0| { \ | | | | | | 62| 0| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 0| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 0| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 0| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 0| \ | | | | | | 70| 0| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 0| do \ | | | | | | | | 32| 0| { \ | | | | | | | | 33| 0| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 0| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 0| \ | | | | | | 72| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 0| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 0| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 183| 0| WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \ | | 184| 0| WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) || \ | | ------------------ | | | | 76| 0|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 0| do \ | | | | | | 61| 0| { \ | | | | | | 62| 0| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 0| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 0| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 0| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 0| \ | | | | | | 70| 0| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 0| do \ | | | | | | | | 32| 0| { \ | | | | | | | | 33| 0| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 0| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 0| \ | | | | | | 72| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 0| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 0| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 185| 0| (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0)); \ | | 186| 0| WINPR_CXX_COMPAT_CAST(type, (var)); \ | | ------------------ | | | | 34| 0|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ | | 187| 0| }) ------------------ 315| 0| const UINT64 ustride = ((rawustride + 31) & ~31u) >> 3; 316| 0| if (ustride > UINT32_MAX) ------------------ | Branch (316:9): [True: 0, False: 0] ------------------ 317| 0| { 318| 0| WLog_ERR(TAG, "bi->biWidth * bi->biBitCount > UINT32_MAX"); ------------------ | | 348| 0| WLog_Print_dbg_tag(tag, WLOG_ERROR, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 319| 0| goto fail; 320| 0| } 321| | 322| 0| const UINT32 xstride = WINPR_ASSERTING_INT_CAST(uint32_t, ustride); ------------------ | | 180| 0| __extension__({ \ | | 181| 0| __typeof(ivar) var = ivar; \ | | 182| 0| WINPR_ASSERT((var) == \ | | ------------------ | | | | 76| 0|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 0| do \ | | | | | | 61| 0| { \ | | | | | | 62| 0| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 0| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 0| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 0| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 0| \ | | | | | | 70| 0| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 0| do \ | | | | | | | | 32| 0| { \ | | | | | | | | 33| 0| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 0| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 0| \ | | | | | | 72| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 0| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 0| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 183| 0| WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \ | | 184| 0| WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) || \ | | ------------------ | | | | 76| 0|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 0| do \ | | | | | | 61| 0| { \ | | | | | | 62| 0| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 0| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 0| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 0| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 0| \ | | | | | | 70| 0| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 0| do \ | | | | | | | | 32| 0| { \ | | | | | | | | 33| 0| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 0| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 0| \ | | | | | | 72| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 0| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 0| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 185| 0| (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0)); \ | | 186| 0| WINPR_CXX_COMPAT_CAST(type, (var)); \ | | ------------------ | | | | 34| 0|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ | | 187| 0| }) ------------------ 323| 0| const UINT64 usize = WINPR_ASSERTING_INT_CAST(UINT64, llabs(bi.biHeight)) * xstride; ------------------ | | 180| 0| __extension__({ \ | | 181| 0| __typeof(ivar) var = ivar; \ | | 182| 0| WINPR_ASSERT((var) == \ | | ------------------ | | | | 76| 0|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 0| do \ | | | | | | 61| 0| { \ | | | | | | 62| 0| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 0| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 0| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 0| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 0| \ | | | | | | 70| 0| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 0| do \ | | | | | | | | 32| 0| { \ | | | | | | | | 33| 0| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 0| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 0| \ | | | | | | 72| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 0| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 0| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 183| 0| WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \ | | 184| 0| WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) || \ | | ------------------ | | | | 76| 0|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 0| do \ | | | | | | 61| 0| { \ | | | | | | 62| 0| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 0| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 0| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 0| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 0| \ | | | | | | 70| 0| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 0| do \ | | | | | | | | 32| 0| { \ | | | | | | | | 33| 0| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 0| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 0| \ | | | | | | 72| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 0| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 0| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 185| 0| (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0)); \ | | 186| 0| WINPR_CXX_COMPAT_CAST(type, (var)); \ | | ------------------ | | | | 34| 0|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ | | 187| 0| }) ------------------ 324| 0| if (usize > UINT32_MAX) ------------------ | Branch (324:9): [True: 0, False: 0] ------------------ 325| 0| { 326| 0| WLog_ERR(TAG, "abs(bi->biHeight) * stride > UINT32_MAX"); ------------------ | | 348| 0| WLog_Print_dbg_tag(tag, WLOG_ERROR, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 327| 0| goto fail; 328| 0| } 329| 0| bi.biSizeImage = WINPR_ASSERTING_INT_CAST(uint32_t, usize); ------------------ | | 180| 0| __extension__({ \ | | 181| 0| __typeof(ivar) var = ivar; \ | | 182| 0| WINPR_ASSERT((var) == \ | | ------------------ | | | | 76| 0|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 0| do \ | | | | | | 61| 0| { \ | | | | | | 62| 0| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 0| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 0| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 0| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 0| \ | | | | | | 70| 0| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 0| do \ | | | | | | | | 32| 0| { \ | | | | | | | | 33| 0| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 0| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 0| \ | | | | | | 72| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 0| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 0| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 183| 0| WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \ | | 184| 0| WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) || \ | | ------------------ | | | | 76| 0|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 0| do \ | | | | | | 61| 0| { \ | | | | | | 62| 0| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 0| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 0| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 0| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 0| \ | | | | | | 70| 0| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 0| do \ | | | | | | | | 32| 0| { \ | | | | | | | | 33| 0| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 0| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 0| \ | | | | | | 72| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 0| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 0| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 185| 0| (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0)); \ | | 186| 0| WINPR_CXX_COMPAT_CAST(type, (var)); \ | | ------------------ | | | | 34| 0|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ | | 187| 0| }) ------------------ 330| 0| } 331| 249| break; 332| 249| case BI_BITFIELDS: ------------------ | | 163| 0|#define BI_BITFIELDS 3 ------------------ | Branch (332:3): [True: 0, False: 249] ------------------ 333| 0| offset += sizeof(DWORD) * 3; // 3 DWORD color masks 334| 0| break; 335| 0| default: ------------------ | Branch (335:3): [True: 0, False: 249] ------------------ 336| 0| return nullptr; 337| 249| } 338| | 339| 249| if (offset > UINT32_MAX - bf.bfOffBits) ------------------ | Branch (339:6): [True: 0, False: 249] ------------------ 340| 0| goto fail; 341| 249| bf.bfOffBits += WINPR_ASSERTING_INT_CAST(UINT32, offset); ------------------ | | 180| 249| __extension__({ \ | | 181| 249| __typeof(ivar) var = ivar; \ | | 182| 249| WINPR_ASSERT((var) == \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 249| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 183| 249| WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \ | | 184| 249| WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) || \ | | ------------------ | | | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 249| do \ | | | | | | 61| 249| { \ | | | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 249| \ | | | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 249| do \ | | | | | | | | 32| 249| { \ | | | | | | | | 33| 985| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:9): [True: 130, False: 119] | | | | | | | | | Branch (33:9): [True: 130, False: 0] | | | | | | | | | Branch (33:9): [True: 119, False: 0] | | | | | | | | | Branch (33:9): [True: 119, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 249| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 249| \ | | | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 185| 249| (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0)); \ | | 186| 249| WINPR_CXX_COMPAT_CAST(type, (var)); \ | | ------------------ | | | | 34| 249|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ | | 187| 249| }) ------------------ 342| | 343| 249| if (!writeBitmapFileHeader(s, &bf)) ------------------ | Branch (343:6): [True: 0, False: 249] ------------------ 344| 0| goto fail; 345| | 346| 249| if (!writeBitmapInfoHeader(s, &bi)) ------------------ | Branch (346:6): [True: 0, False: 249] ------------------ 347| 0| goto fail; 348| | 349| 249| if (!Stream_EnsureRemainingCapacity(s, offset)) ------------------ | Branch (349:6): [True: 0, False: 249] ------------------ 350| 0| goto fail; 351| | 352| 249| Stream_Zero(s, offset); 353| 249| const size_t pos = Stream_GetPosition(s); 354| 249| if (pos != bf.bfOffBits) ------------------ | Branch (354:6): [True: 0, False: 249] ------------------ 355| 0| goto fail; 356| 249| return s; 357| 0|fail: 358| 0| Stream_Free(s, TRUE); ------------------ | | 126| 0|#define TRUE true ------------------ 359| 0| return nullptr; 360| 249|} image.c:winpr_bitmap_write_buffer: 379| 249|{ 380| 249| WINPR_ASSERT(data || (size == 0)); ------------------ | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 249| do \ | | | | 61| 249| { \ | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 249| \ | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 249| do \ | | | | | | 32| 249| { \ | | | | | | 33| 249| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:9): [True: 249, False: 0] | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | | | 71| 249| \ | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 249| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 249] | | | | ------------------ | | ------------------ ------------------ 381| 249| WINPR_ASSERT(pSize); ------------------ | | 76| 249|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 249| do \ | | | | 61| 249| { \ | | | | 62| 249| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 249| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 249| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 249| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 249| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 249| \ | | | | 70| 249| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 249| do \ | | | | | | 32| 249| { \ | | | | | | 33| 249| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 249] | | | | | | ------------------ | | | | | | 34| 249| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 249| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 249] | | | | | | ------------------ | | | | ------------------ | | | | 71| 249| \ | | | | 72| 249| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 249| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 249| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 249| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 249] | | | | ------------------ | | ------------------ ------------------ 382| | 383| 249| void* result = nullptr; 384| 249| if ((height == 0) || (width == 0) || (bpp == 0) || (width > SIZE_MAX / height) || ------------------ | Branch (384:6): [True: 0, False: 249] | Branch (384:23): [True: 0, False: 249] | Branch (384:39): [True: 0, False: 249] | Branch (384:53): [True: 0, False: 249] ------------------ 385| 249| (width > SIZE_MAX / bpp)) ------------------ | Branch (385:6): [True: 0, False: 249] ------------------ 386| 0| return nullptr; 387| | 388| 249| size_t bpp_stride = 1ull * width * bpp; 389| 249| if (bpp < 8) ------------------ | Branch (389:6): [True: 124, False: 125] ------------------ 390| 124| { 391| 124| if ((bpp_stride % 8) != 0) ------------------ | Branch (391:7): [True: 95, False: 29] ------------------ 392| 95| bpp_stride += 8 - (bpp_stride % 8); 393| 124| } 394| 249| bpp_stride /= 8ull; 395| | 396| 249| if ((bpp_stride % 4) != 0) ------------------ | Branch (396:6): [True: 202, False: 47] ------------------ 397| 202| bpp_stride += 4 - (bpp_stride % 4); 398| | 399| 249| if ((bpp_stride < 4) || (bpp_stride > UINT32_MAX)) ------------------ | Branch (399:6): [True: 0, False: 249] | Branch (399:26): [True: 0, False: 249] ------------------ 400| 0| return nullptr; 401| | 402| | /* the pixels of a row, without the padding to 4 bytes BMP requires */ 403| 249| if (width > (SIZE_MAX - 7ull) / bpp) ------------------ | Branch (403:6): [True: 0, False: 249] ------------------ 404| 0| return nullptr; 405| 249| const size_t row = (1ull * width * bpp + 7ull) / 8ull; 406| | 407| 249| if (stride == 0) ------------------ | Branch (407:6): [True: 0, False: 249] ------------------ 408| 0| stride = (UINT32)bpp_stride; 409| | 410| 249| if (stride > SIZE_MAX / height) ------------------ | Branch (410:6): [True: 0, False: 249] ------------------ 411| 0| return nullptr; 412| | 413| 249| if (stride > size / height) ------------------ | Branch (413:6): [True: 0, False: 249] ------------------ 414| 0| return nullptr; 415| | 416| 249| if (row > stride) ------------------ | Branch (416:6): [True: 0, False: 249] ------------------ 417| 0| return nullptr; 418| | 419| | /* Store the rows bottom-up: some readers, e.g. Windows when synthesizing CF_BITMAP from a 420| | * CF_DIB, do not handle top-down bitmaps. */ 421| 249| wStream* s = winpr_bitmap_construct_header_stream(width, height, bpp, TRUE); ------------------ | | 126| 249|#define TRUE true ------------------ 422| 249| if (!s) ------------------ | Branch (422:6): [True: 0, False: 249] ------------------ 423| 0| goto fail; 424| | 425| | /* The source rows may be padded differently, e.g. not at all for a 24 bpp PNG: write each 426| | * row with the padding the header announces. */ 427| 1.92M| for (size_t y = height; y > 0; y--) ------------------ | Branch (427:26): [True: 1.92M, False: 249] ------------------ 428| 1.92M| { 429| 1.92M| if (!Stream_EnsureRemainingCapacity(s, bpp_stride)) ------------------ | Branch (429:7): [True: 0, False: 1.92M] ------------------ 430| 0| goto fail; 431| | 432| 1.92M| const size_t offset = (y - 1) * stride; 433| 1.92M| Stream_Write(s, &data[offset], row); 434| 1.92M| Stream_Zero(s, bpp_stride - row); 435| 1.92M| } 436| | 437| 249| result = Stream_Buffer(s); 438| 249| { 439| 249| const size_t pos = Stream_GetPosition(s); 440| 249| if (pos > UINT32_MAX) ------------------ | Branch (440:7): [True: 0, False: 249] ------------------ 441| 0| goto fail; 442| 249| *pSize = (UINT32)pos; 443| 249| } 444| 249|fail: 445| 249| Stream_Free(s, result == nullptr); 446| 249| return result; 447| 249|} image.c:winpr_image_bitmap_read_buffer: 541| 1.16k|{ 542| 1.16k| int rc = -1; 543| 1.16k| BOOL vFlip = 0; 544| 1.16k| WINPR_BITMAP_FILE_HEADER bf = WINPR_C_ARRAY_INIT; ------------------ | | 85| 1.16k| { \ | | 86| 1.16k| } /** @since version 3.24.0 */ ------------------ 545| 1.16k| WINPR_BITMAP_INFO_HEADER bi = WINPR_C_ARRAY_INIT; ------------------ | | 85| 1.16k| { \ | | 86| 1.16k| } /** @since version 3.24.0 */ ------------------ 546| 1.16k| wStream sbuffer = WINPR_C_ARRAY_INIT; ------------------ | | 85| 1.16k| { \ | | 86| 1.16k| } /** @since version 3.24.0 */ ------------------ 547| 1.16k| wStream* s = Stream_StaticConstInit(&sbuffer, buffer, size); 548| | 549| 1.16k| if (!s) ------------------ | Branch (549:6): [True: 0, False: 1.16k] ------------------ 550| 0| return -1; 551| | 552| 1.16k| size_t bmpoffset = 0; 553| 1.16k| if (!readBitmapFileHeader(s, &bf) || !readBitmapInfoHeader(s, &bi, &bmpoffset)) ------------------ | Branch (553:6): [True: 101, False: 1.06k] | Branch (553:39): [True: 340, False: 720] ------------------ 554| 441| goto fail; 555| | 556| 720| if ((bf.bfType[0] != 'B') || (bf.bfType[1] != 'M')) ------------------ | Branch (556:6): [True: 0, False: 720] | Branch (556:31): [True: 0, False: 720] ------------------ 557| 0| { 558| 0| WLog_WARN(TAG, "Invalid bitmap header %c%c", bf.bfType[0], bf.bfType[1]); ------------------ | | 346| 0| WLog_Print_dbg_tag(tag, WLOG_WARN, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 559| 0| goto fail; 560| 0| } 561| | 562| 720| image->type = WINPR_IMAGE_BITMAP; ------------------ | | 66| 720|#define WINPR_IMAGE_BITMAP 0 ------------------ 563| | 564| 720| { 565| | /* bfOffBits may include color masks, a color table or padding after the 566| | * info header. It must leave room for the required color data. */ 567| 720| const size_t pos = Stream_GetPosition(s); 568| 720| const size_t expect = bf.bfOffBits; 569| 720| if ((pos > expect) || (bmpoffset > expect - pos)) ------------------ | Branch (569:7): [True: 49, False: 671] | Branch (569:25): [True: 161, False: 510] ------------------ 570| 210| { 571| 210| WLog_WARN(TAG, "pos=%" PRIuz ", expected %" PRIuz ", offset=%" PRIuz, pos, expect, ------------------ | | 346| 210| WLog_Print_dbg_tag(tag, WLOG_WARN, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 572| 210| bmpoffset); 573| 210| goto fail; 574| 210| } 575| | 576| 510| if (!Stream_SafeSeek(s, expect - pos)) ------------------ | | 1393| 510|#define Stream_SafeSeek(s, size) Stream_SafeSeekEx(s, size, __FILE__, __LINE__, __func__) ------------------ | Branch (576:7): [True: 54, False: 456] ------------------ 577| 54| goto fail; 578| 510| } 579| | 580| 456| if (!Stream_CheckAndLogRequiredLength(TAG, s, bi.biSizeImage)) ------------------ | | 128| 456| Stream_CheckAndLogRequiredLengthOfSize(tag, s, len, 1) | | ------------------ | | | | 125| 456| Stream_CheckAndLogRequiredLengthEx(tag, WLOG_WARN, s, nmemb, size, "%s(%s:%" PRIuz ")", \ | | | | 126| 456| __func__, __FILE__, (size_t)__LINE__) | | ------------------ ------------------ | Branch (580:6): [True: 34, False: 422] ------------------ 581| 34| goto fail; 582| | 583| 422| if (bi.biWidth <= 0) ------------------ | Branch (583:6): [True: 1, False: 421] ------------------ 584| 1| { 585| 1| WLog_WARN(TAG, "bi.biWidth=%" PRId32, bi.biWidth); ------------------ | | 346| 1| WLog_Print_dbg_tag(tag, WLOG_WARN, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 586| 1| goto fail; 587| 1| } 588| | 589| 421| image->width = (UINT32)bi.biWidth; 590| | 591| 421| if (bi.biHeight < 0) ------------------ | Branch (591:6): [True: 247, False: 174] ------------------ 592| 247| { 593| 247| vFlip = FALSE; ------------------ | | 122| 247|#define FALSE false ------------------ 594| 247| image->height = (UINT32)(-1ll * bi.biHeight); 595| 247| } 596| 174| else 597| 174| { 598| 174| vFlip = TRUE; ------------------ | | 126| 174|#define TRUE true ------------------ 599| 174| image->height = (UINT32)bi.biHeight; 600| 174| } 601| | 602| 421| if (image->width <= 0) ------------------ | Branch (602:6): [True: 0, False: 421] ------------------ 603| 0| { 604| 0| WLog_WARN(TAG, "image->width=%" PRIu32, image->width); ------------------ | | 346| 0| WLog_Print_dbg_tag(tag, WLOG_WARN, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 605| 0| goto fail; 606| 0| } 607| | 608| 421| if (image->height <= 0) ------------------ | Branch (608:6): [True: 1, False: 420] ------------------ 609| 1| { 610| 1| WLog_WARN(TAG, "image->height=%" PRIu32, image->height); ------------------ | | 346| 1| WLog_Print_dbg_tag(tag, WLOG_WARN, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 611| 1| goto fail; 612| 1| } 613| | 614| 420| image->bitsPerPixel = bi.biBitCount; 615| 420| { 616| 420| const size_t bpp = (bi.biBitCount + 7UL) / 8UL; 617| 420| image->bytesPerPixel = WINPR_ASSERTING_INT_CAST(uint32_t, bpp); ------------------ | | 180| 420| __extension__({ \ | | 181| 420| __typeof(ivar) var = ivar; \ | | 182| 420| WINPR_ASSERT((var) == \ | | ------------------ | | | | 76| 420|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 420| do \ | | | | | | 61| 420| { \ | | | | | | 62| 420| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 420| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 420| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 420| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 420| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 420| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 420| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 420| \ | | | | | | 70| 420| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 420| do \ | | | | | | | | 32| 420| { \ | | | | | | | | 33| 420| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 420] | | | | | | | | ------------------ | | | | | | | | 34| 420| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 420| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 420] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 420| \ | | | | | | 72| 420| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 420| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 420| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 420| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 420] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 183| 420| WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \ | | 184| 420| WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) || \ | | ------------------ | | | | 76| 420|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 420| do \ | | | | | | 61| 420| { \ | | | | | | 62| 420| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 420| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 420| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 420| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 420| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 420| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 420| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 420| \ | | | | | | 70| 420| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 420| do \ | | | | | | | | 32| 420| { \ | | | | | | | | 33| 1.26k| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:9): [True: 420, False: 0] | | | | | | | | | Branch (33:9): [True: 420, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 420| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 420| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 420] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 420| \ | | | | | | 72| 420| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 420| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 420| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 420| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 420] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 185| 420| (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0)); \ | | 186| 420| WINPR_CXX_COMPAT_CAST(type, (var)); \ | | ------------------ | | | | 34| 420|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ | | 187| 420| }) ------------------ 618| 420| if (image->bytesPerPixel == 0) ------------------ | Branch (618:7): [True: 0, False: 420] ------------------ 619| 0| goto fail; 620| | 621| 420| if (image->width > (UINT32_MAX / image->bytesPerPixel) - 4ull) ------------------ | Branch (621:7): [True: 6, False: 414] ------------------ 622| 6| goto fail; 623| | 624| 414| image->scanline = image->width * image->bytesPerPixel; 625| 414| if ((image->scanline % 4) != 0) ------------------ | Branch (625:7): [True: 319, False: 95] ------------------ 626| 319| image->scanline += 4 - image->scanline % 4; 627| | 628| 414| if (image->height > UINT32_MAX / image->scanline) ------------------ | Branch (628:7): [True: 80, False: 334] ------------------ 629| 80| goto fail; 630| | 631| 334| { 632| 334| const size_t bmpsize = 1ULL * image->scanline * image->height; 633| 334| if (bmpsize != bi.biSizeImage) ------------------ | Branch (633:8): [True: 132, False: 202] ------------------ 634| 132| WLog_WARN(TAG, "bmpsize=%" PRIuz " != bi.biSizeImage=%" PRIu32, bmpsize, ------------------ | | 346| 132| WLog_Print_dbg_tag(tag, WLOG_WARN, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 635| 334| bi.biSizeImage); 636| | 637| 334| { 638| 334| size_t scanline = image->scanline; 639| 334| if (bi.biSizeImage < bmpsize) ------------------ | Branch (639:9): [True: 119, False: 215] ------------------ 640| 119| { 641| | /* Workaround for unaligned bitmaps */ 642| 119| const size_t uscanline = image->width * bpp; 643| 119| const size_t unaligned = image->height * uscanline; 644| 119| if (bi.biSizeImage != unaligned) ------------------ | Branch (644:10): [True: 85, False: 34] ------------------ 645| 85| goto fail; 646| 34| scanline = uscanline; 647| 34| } 648| | 649| 249| image->data = nullptr; 650| 249| { 651| 249| const size_t asize = 1ULL * image->scanline * image->height; 652| 249| if (asize > 0) ------------------ | Branch (652:10): [True: 249, False: 0] ------------------ 653| 249| image->data = (BYTE*)malloc(asize); 654| 249| } 655| | 656| 249| if (!image->data) ------------------ | Branch (656:9): [True: 0, False: 249] ------------------ 657| 0| goto fail; 658| | 659| 249| if (!vFlip) ------------------ | Branch (659:9): [True: 149, False: 100] ------------------ 660| 149| { 661| 149| BYTE* pDstData = image->data; 662| | 663| 393k| for (size_t index = 0; index < image->height; index++) ------------------ | Branch (663:29): [True: 393k, False: 149] ------------------ 664| 393k| { 665| 393k| Stream_Read(s, pDstData, scanline); 666| 393k| pDstData += image->scanline; 667| 393k| } 668| 149| } 669| 100| else 670| 100| { 671| 100| BYTE* pDstData = &(image->data[(image->height - 1ull) * image->scanline]); 672| | 673| 1.53M| for (size_t index = 0; index < image->height; index++) ------------------ | Branch (673:29): [True: 1.53M, False: 100] ------------------ 674| 1.53M| { 675| 1.53M| Stream_Read(s, pDstData, scanline); 676| 1.53M| pDstData -= image->scanline; 677| 1.53M| } 678| 100| } 679| 249| } 680| 249| } 681| 249| } 682| | 683| 0| rc = 1; 684| 1.16k|fail: 685| | 686| 1.16k| if (rc < 0) ------------------ | Branch (686:6): [True: 912, False: 249] ------------------ 687| 912| { 688| 912| free(image->data); 689| 912| image->data = nullptr; 690| 912| } 691| | 692| 1.16k| return rc; 693| 249|} image.c:winpr_convert_from_jpeg: 898| 1|{ 899| 1| WINPR_ASSERT(comp_data || (comp_data_bytes == 0)); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:9): [True: 1, False: 0] | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 900| 1| WINPR_ASSERT(width); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 901| 1| WINPR_ASSERT(height); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 902| 1| WINPR_ASSERT(bpp); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 903| 1| WINPR_ASSERT(ppdecomp_data); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 904| 1| WINPR_ASSERT(scanline); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 905| | 906| 1| *width = 0; 907| 1| *height = 0; 908| 1| *bpp = 0; 909| 1| *ppdecomp_data = nullptr; 910| 1| *scanline = 0; 911| | 912| 1|#if !defined(WINPR_UTILS_IMAGE_JPEG) 913| 1| WLog_WARN(TAG, "JPEG not supported in this build"); ------------------ | | 346| 1| WLog_Print_dbg_tag(tag, WLOG_WARN, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 914| 1| return -1; 915| |#else 916| | struct jpeg_decompress_struct cinfo = WINPR_C_ARRAY_INIT; 917| | WINPR_JPEG_ERROR_MGR jerr = WINPR_C_ARRAY_INIT; 918| | SSIZE_T size = -1; 919| | BYTE* decomp_data = nullptr; 920| | 921| | cinfo.err = jpeg_std_error(&jerr.pub); 922| | jerr.pub.error_exit = winpr_jpeg_error_exit; 923| | jpeg_create_decompress(&cinfo); 924| | 925| | /* Set up error handling (must be after jpeg_create_decompress). */ 926| | if (setjmp(jerr.jump) != 0) 927| | goto fail; 928| | 929| | jpeg_mem_src(&cinfo, comp_data, comp_data_bytes); 930| | 931| | if (jpeg_read_header(&cinfo, 1) != JPEG_HEADER_OK) 932| | goto fail; 933| | 934| | cinfo.out_color_space = cinfo.num_components > 3 ? JCS_EXT_RGBA : JCS_EXT_BGR; 935| | const int components = MAX(3, cinfo.num_components); 936| | 937| | *width = WINPR_ASSERTING_INT_CAST(uint32_t, cinfo.image_width); 938| | *height = WINPR_ASSERTING_INT_CAST(uint32_t, cinfo.image_height); 939| | *bpp = WINPR_ASSERTING_INT_CAST(uint32_t, cinfo.num_components * 8); 940| | 941| | if (!jpeg_start_decompress(&cinfo)) 942| | goto fail; 943| | 944| | size_t stride = 1ULL * cinfo.image_width * WINPR_ASSERTING_INT_CAST(size_t, components); 945| | 946| | if ((stride == 0) || (cinfo.image_height == 0) || (stride > UINT32_MAX)) 947| | goto fail; 948| | *scanline = (UINT32)stride; 949| | 950| | decomp_data = calloc(stride, cinfo.image_height); 951| | if (decomp_data) 952| | { 953| | while (cinfo.output_scanline < cinfo.image_height) 954| | { 955| | JSAMPROW row = &decomp_data[cinfo.output_scanline * stride]; 956| | if (jpeg_read_scanlines(&cinfo, &row, 1) != 1) 957| | goto fail; 958| | } 959| | const size_t ssize = stride * cinfo.image_height; 960| | WINPR_ASSERT(ssize < SSIZE_MAX); 961| | size = (SSIZE_T)ssize; 962| | } 963| | jpeg_finish_decompress(&cinfo); 964| | 965| |fail: 966| | jpeg_destroy_decompress(&cinfo); 967| | *ppdecomp_data = decomp_data; 968| | return size; 969| |#endif 970| 1|} image.c:winpr_convert_from_webp: 1023| 1|{ 1024| 1| WINPR_ASSERT(comp_data || (comp_data_bytes == 0)); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:9): [True: 1, False: 0] | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1025| 1| WINPR_ASSERT(width); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1026| 1| WINPR_ASSERT(height); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1027| 1| WINPR_ASSERT(bpp); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1028| 1| WINPR_ASSERT(ppdecomp_data); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1029| 1| WINPR_ASSERT(scanline); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1030| | 1031| 1| *width = 0; 1032| 1| *height = 0; 1033| 1| *bpp = 0; 1034| 1| *ppdecomp_data = nullptr; 1035| 1| *scanline = 0; 1036| | 1037| 1|#if !defined(WINPR_UTILS_IMAGE_WEBP) 1038| 1| WLog_WARN(TAG, "WEBP not supported in this build"); ------------------ | | 346| 1| WLog_Print_dbg_tag(tag, WLOG_WARN, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 1039| 1| return -1; 1040| |#else 1041| | 1042| | int w = 0; 1043| | int h = 0; 1044| | uint8_t* dst = WebPDecodeBGRA(comp_data, comp_data_bytes, &w, &h); 1045| | if (!dst || (w < 0) || (h < 0)) 1046| | { 1047| | free(dst); 1048| | return -1; 1049| | } 1050| | 1051| | if ((w <= 0) || ((UINT32)w > UINT32_MAX / 4ull) || (h <= 0) || 1052| | ((UINT32)h > UINT32_MAX / 4ul / (UINT32)w)) 1053| | { 1054| | free(dst); 1055| | return -1; 1056| | } 1057| | *width = WINPR_ASSERTING_INT_CAST(uint32_t, w); 1058| | *height = WINPR_ASSERTING_INT_CAST(uint32_t, h); 1059| | *bpp = 32; 1060| | *scanline = (*width) * 4ul; 1061| | *ppdecomp_data = dst; 1062| | return 1ll * (*scanline) * h; 1063| |#endif 1064| 1|} image.c:winpr_convert_from_png: 1377| 1|{ 1378| 1| WINPR_ASSERT(comp_data || (comp_data_bytes == 0)); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:9): [True: 1, False: 0] | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1379| 1| WINPR_ASSERT(width); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1380| 1| WINPR_ASSERT(height); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1381| 1| WINPR_ASSERT(bpp); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1382| 1| WINPR_ASSERT(ppdecomp_data); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1383| 1| WINPR_ASSERT(scanline); ------------------ | | 76| 1|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1| do \ | | | | 61| 1| { \ | | | | 62| 1| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1| \ | | | | 70| 1| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1| do \ | | | | | | 32| 1| { \ | | | | | | 33| 1| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1] | | | | | | ------------------ | | | | | | 34| 1| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1| \ | | | | 72| 1| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1] | | | | ------------------ | | ------------------ ------------------ 1384| | 1385| 1| *width = 0; 1386| 1| *height = 0; 1387| 1| *bpp = 0; 1388| 1| *ppdecomp_data = nullptr; 1389| 1| *scanline = 0; 1390| | 1391| |#if defined(WINPR_UTILS_IMAGE_PNG) 1392| | size_t len = 0; 1393| | *ppdecomp_data = 1394| | winpr_read_png_from_buffer(comp_data, comp_data_bytes, &len, width, height, bpp, scanline); 1395| | if (!*ppdecomp_data) 1396| | return -1; 1397| | return (SSIZE_T)len; 1398| |#elif defined(WITH_LODEPNG) 1399| | *bpp = 32; 1400| | if (*width > UINT32_MAX / 4) 1401| | return -1; 1402| | 1403| | SSIZE_T rc = 1404| | lodepng_decode32((unsigned char**)ppdecomp_data, width, height, comp_data, comp_data_bytes); 1405| | *scanline = *width * 4; 1406| | return rc; 1407| |#else 1408| 1| WLog_WARN(TAG, "PNG not supported in this build"); ------------------ | | 346| 1| WLog_Print_dbg_tag(tag, WLOG_WARN, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 1409| 1| return -1; 1410| 1|#endif 1411| 1|} Stream_ResizeToCapacity: 45| 63.9k|{ 46| 63.9k| const size_t old_capacity = s->capacity; 47| 63.9k| const size_t new_capacity = size; 48| 63.9k| size_t position = Stream_GetPosition(s); 49| | 50| 63.9k| BYTE* new_buf = nullptr; 51| 63.9k| if (!s->isOwner) ------------------ | Branch (51:6): [True: 0, False: 63.9k] ------------------ 52| 0| { 53| 0| new_buf = (BYTE*)malloc(new_capacity); 54| 0| if (!new_buf) ------------------ | Branch (54:7): [True: 0, False: 0] ------------------ 55| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 56| | 57| 0| CopyMemory(new_buf, s->buffer, s->capacity); ------------------ | | 123| 0|#define CopyMemory(Destination, Source, Length) memcpy((Destination), (Source), (Length)) ------------------ 58| 0| s->isOwner = TRUE; ------------------ | | 126| 0|#define TRUE true ------------------ 59| 0| } 60| 63.9k| else 61| 63.9k| { 62| 63.9k| new_buf = (BYTE*)realloc(s->buffer, new_capacity); 63| 63.9k| if (!new_buf) ------------------ | Branch (63:7): [True: 0, False: 63.9k] ------------------ 64| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 65| 63.9k| } 66| | 67| 63.9k| s->buffer = new_buf; 68| 63.9k| s->capacity = new_capacity; 69| 63.9k| s->length = new_capacity; 70| 63.9k| if (old_capacity < new_capacity) ------------------ | Branch (70:6): [True: 63.9k, False: 0] ------------------ 71| 63.9k| ZeroMemory(&s->buffer[old_capacity], s->capacity - old_capacity); ------------------ | | 126| 63.9k|#define ZeroMemory(Destination, Length) memset((Destination), 0, (Length)) ------------------ 72| | 73| 63.9k| if (position > new_capacity) ------------------ | Branch (73:6): [True: 0, False: 63.9k] ------------------ 74| 0| position = new_capacity; 75| 63.9k| return Stream_SetPosition(s, position); 76| 63.9k|} Stream_EnsureCapacity: 79| 63.9k|{ 80| 63.9k| WINPR_ASSERT(s); ------------------ | | 76| 63.9k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 63.9k| do \ | | | | 61| 63.9k| { \ | | | | 62| 63.9k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 63.9k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 63.9k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 63.9k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 63.9k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 63.9k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 63.9k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 63.9k| \ | | | | 70| 63.9k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 63.9k| do \ | | | | | | 32| 63.9k| { \ | | | | | | 33| 63.9k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 63.9k] | | | | | | ------------------ | | | | | | 34| 63.9k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 63.9k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 63.9k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 63.9k| \ | | | | 72| 63.9k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 63.9k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 63.9k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 63.9k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 63.9k] | | | | ------------------ | | ------------------ ------------------ 81| 63.9k| if (s->capacity >= size) ------------------ | Branch (81:6): [True: 0, False: 63.9k] ------------------ 82| 0| return TRUE; ------------------ | | 126| 0|#define TRUE true ------------------ 83| | 84| 63.9k| const size_t increment = 128ull; 85| 63.9k| if (size > SIZE_MAX - increment) ------------------ | Branch (85:6): [True: 0, False: 63.9k] ------------------ 86| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 87| | 88| 63.9k| const size_t new_capacity = size + increment - size % increment; 89| 63.9k| return Stream_ResizeToCapacity(s, new_capacity); 90| 63.9k|} Stream_EnsureRemainingCapacity: 93| 1.93M|{ 94| 1.93M| const size_t pos = Stream_GetPosition(s); 95| 1.93M| if (pos > SIZE_MAX - size) ------------------ | Branch (95:6): [True: 0, False: 1.93M] ------------------ 96| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 97| 1.93M| if (pos + size > Stream_Capacity(s)) ------------------ | Branch (97:6): [True: 63.9k, False: 1.86M] ------------------ 98| 63.9k| return Stream_EnsureCapacity(s, Stream_Capacity(s) + size); 99| 1.86M| return TRUE; ------------------ | | 126| 1.86M|#define TRUE true ------------------ 100| 1.93M|} Stream_New: 103| 249|{ 104| 249| wStream* s = nullptr; 105| | 106| 249| if (!buffer && !size) ------------------ | Branch (106:6): [True: 249, False: 0] | Branch (106:17): [True: 0, False: 249] ------------------ 107| 0| return nullptr; 108| | 109| 249| s = calloc(1, sizeof(wStream)); 110| 249| if (!s) ------------------ | Branch (110:6): [True: 0, False: 249] ------------------ 111| 0| return nullptr; 112| | 113| 249| if (buffer) ------------------ | Branch (113:6): [True: 0, False: 249] ------------------ 114| 0| s->buffer = buffer; 115| 249| else 116| 249| s->buffer = (BYTE*)calloc(size, sizeof(BYTE)); 117| | 118| 249| if (!s->buffer) ------------------ | Branch (118:6): [True: 0, False: 249] ------------------ 119| 0| { 120| 0| free(s); 121| 0| return nullptr; 122| 0| } 123| | 124| 249| s->pointer = s->buffer; 125| 249| s->capacity = size; 126| 249| s->length = size; 127| | 128| 249| s->pool = nullptr; 129| 249| s->count = 1; 130| 249| s->isAllocatedStream = TRUE; ------------------ | | 126| 249|#define TRUE true ------------------ 131| 249| s->isOwner = TRUE; ------------------ | | 126| 249|#define TRUE true ------------------ 132| 249| return s; 133| 249|} Stream_StaticConstInit: 136| 1.16k|{ 137| 1.16k| union 138| 1.16k| { 139| 1.16k| BYTE* b; 140| 1.16k| const BYTE* cb; 141| 1.16k| } cnv; 142| | 143| 1.16k| cnv.cb = buffer; 144| 1.16k| return Stream_StaticInit(s, cnv.b, size); 145| 1.16k|} Stream_StaticInit: 148| 1.16k|{ 149| 1.16k| const wStream empty = WINPR_C_ARRAY_INIT; ------------------ | | 85| 1.16k| { \ | | 86| 1.16k| } /** @since version 3.24.0 */ ------------------ 150| | 151| 1.16k| WINPR_ASSERT(s); ------------------ | | 76| 1.16k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1.16k| do \ | | | | 61| 1.16k| { \ | | | | 62| 1.16k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1.16k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1.16k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1.16k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1.16k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1.16k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1.16k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1.16k| \ | | | | 70| 1.16k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1.16k| do \ | | | | | | 32| 1.16k| { \ | | | | | | 33| 1.16k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1.16k] | | | | | | ------------------ | | | | | | 34| 1.16k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1.16k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1.16k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1.16k| \ | | | | 72| 1.16k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1.16k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1.16k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1.16k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1.16k] | | | | ------------------ | | ------------------ ------------------ 152| 1.16k| WINPR_ASSERT(buffer); ------------------ | | 76| 1.16k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 1.16k| do \ | | | | 61| 1.16k| { \ | | | | 62| 1.16k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 1.16k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 1.16k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 1.16k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 1.16k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 1.16k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 1.16k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 1.16k| \ | | | | 70| 1.16k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 1.16k| do \ | | | | | | 32| 1.16k| { \ | | | | | | 33| 1.16k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 1.16k] | | | | | | ------------------ | | | | | | 34| 1.16k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 1.16k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 1.16k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 1.16k| \ | | | | 72| 1.16k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 1.16k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 1.16k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 1.16k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 1.16k] | | | | ------------------ | | ------------------ ------------------ 153| | 154| 1.16k| *s = empty; 155| 1.16k| s->buffer = s->pointer = buffer; 156| 1.16k| s->capacity = s->length = size; 157| 1.16k| s->pool = nullptr; 158| 1.16k| s->count = 1; 159| 1.16k| s->isAllocatedStream = FALSE; ------------------ | | 122| 1.16k|#define FALSE false ------------------ 160| 1.16k| s->isOwner = FALSE; ------------------ | | 122| 1.16k|#define FALSE false ------------------ 161| 1.16k| return s; 162| 1.16k|} Stream_EnsureValidity: 165| 249|{ 166| 249| size_t cur = 0; 167| | 168| 249| STREAM_ASSERT(s); ------------------ | | 33| 249| do \ | | 34| 249| { \ | | 35| 249| if (!(cond)) \ | | ------------------ | | | Branch (35:7): [True: 0, False: 249] | | ------------------ | | 36| 249| { \ | | 37| 0| WLog_FATAL(STREAM_TAG, "%s [%s:%s:%" PRIuz "]", #cond, __FILE__, __func__, \ | | ------------------ | | | | 350| 0| WLog_Print_dbg_tag(tag, WLOG_FATAL, __LINE__, __FILE__, __func__, __VA_ARGS__) | | ------------------ | | 38| 0| (size_t)__LINE__); \ | | 39| 0| winpr_log_backtrace(STREAM_TAG, WLOG_FATAL, 20); \ | | ------------------ | | | | 30| 0|#define STREAM_TAG WINPR_TAG("wStream") | | | | ------------------ | | | | | | 25| 0|#define WINPR_TAG(tag) "com.winpr." tag | | | | ------------------ | | ------------------ | | 40| 0| abort(); \ | | 41| 0| } \ | | 42| 249| } while (0) | | ------------------ | | | Branch (42:11): [Folded, False: 249] | | ------------------ ------------------ 169| 249| STREAM_ASSERT(s->pointer >= s->buffer); ------------------ | | 33| 249| do \ | | 34| 249| { \ | | 35| 249| if (!(cond)) \ | | ------------------ | | | Branch (35:7): [True: 0, False: 249] | | ------------------ | | 36| 249| { \ | | 37| 0| WLog_FATAL(STREAM_TAG, "%s [%s:%s:%" PRIuz "]", #cond, __FILE__, __func__, \ | | ------------------ | | | | 350| 0| WLog_Print_dbg_tag(tag, WLOG_FATAL, __LINE__, __FILE__, __func__, __VA_ARGS__) | | ------------------ | | 38| 0| (size_t)__LINE__); \ | | 39| 0| winpr_log_backtrace(STREAM_TAG, WLOG_FATAL, 20); \ | | ------------------ | | | | 30| 0|#define STREAM_TAG WINPR_TAG("wStream") | | | | ------------------ | | | | | | 25| 0|#define WINPR_TAG(tag) "com.winpr." tag | | | | ------------------ | | ------------------ | | 40| 0| abort(); \ | | 41| 0| } \ | | 42| 249| } while (0) | | ------------------ | | | Branch (42:11): [Folded, False: 249] | | ------------------ ------------------ 170| | 171| 249| cur = (size_t)(s->pointer - s->buffer); 172| 249| STREAM_ASSERT(cur <= s->capacity); ------------------ | | 33| 249| do \ | | 34| 249| { \ | | 35| 249| if (!(cond)) \ | | ------------------ | | | Branch (35:7): [True: 0, False: 249] | | ------------------ | | 36| 249| { \ | | 37| 0| WLog_FATAL(STREAM_TAG, "%s [%s:%s:%" PRIuz "]", #cond, __FILE__, __func__, \ | | ------------------ | | | | 350| 0| WLog_Print_dbg_tag(tag, WLOG_FATAL, __LINE__, __FILE__, __func__, __VA_ARGS__) | | ------------------ | | 38| 0| (size_t)__LINE__); \ | | 39| 0| winpr_log_backtrace(STREAM_TAG, WLOG_FATAL, 20); \ | | ------------------ | | | | 30| 0|#define STREAM_TAG WINPR_TAG("wStream") | | | | ------------------ | | | | | | 25| 0|#define WINPR_TAG(tag) "com.winpr." tag | | | | ------------------ | | ------------------ | | 40| 0| abort(); \ | | 41| 0| } \ | | 42| 249| } while (0) | | ------------------ | | | Branch (42:11): [Folded, False: 249] | | ------------------ ------------------ 173| 249| STREAM_ASSERT(s->length <= s->capacity); ------------------ | | 33| 249| do \ | | 34| 249| { \ | | 35| 249| if (!(cond)) \ | | ------------------ | | | Branch (35:7): [True: 0, False: 249] | | ------------------ | | 36| 249| { \ | | 37| 0| WLog_FATAL(STREAM_TAG, "%s [%s:%s:%" PRIuz "]", #cond, __FILE__, __func__, \ | | ------------------ | | | | 350| 0| WLog_Print_dbg_tag(tag, WLOG_FATAL, __LINE__, __FILE__, __func__, __VA_ARGS__) | | ------------------ | | 38| 0| (size_t)__LINE__); \ | | 39| 0| winpr_log_backtrace(STREAM_TAG, WLOG_FATAL, 20); \ | | ------------------ | | | | 30| 0|#define STREAM_TAG WINPR_TAG("wStream") | | | | ------------------ | | | | | | 25| 0|#define WINPR_TAG(tag) "com.winpr." tag | | | | ------------------ | | ------------------ | | 40| 0| abort(); \ | | 41| 0| } \ | | 42| 249| } while (0) | | ------------------ | | | Branch (42:11): [Folded, False: 249] | | ------------------ ------------------ 174| 249|} Stream_Free: 177| 249|{ 178| 249| if (s) ------------------ | Branch (178:6): [True: 249, False: 0] ------------------ 179| 249| { 180| 249| Stream_EnsureValidity(s); 181| 249| if (bFreeBuffer && s->isOwner) ------------------ | Branch (181:7): [True: 0, False: 249] | Branch (181:22): [True: 0, False: 0] ------------------ 182| 0| free(s->buffer); 183| | 184| 249| if (s->isAllocatedStream) ------------------ | Branch (184:7): [True: 249, False: 0] ------------------ 185| 249| free(s); 186| 249| } 187| 249|} Stream_SetPosition: 201| 63.9k|{ 202| 63.9k| if ((_p) > Stream_Capacity(_s)) ------------------ | Branch (202:6): [True: 0, False: 63.9k] ------------------ 203| 0| { 204| 0| _s->pointer = _s->buffer; 205| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 206| 0| } 207| 63.9k| _s->pointer = _s->buffer + (_p); 208| 63.9k| return TRUE; ------------------ | | 126| 63.9k|#define TRUE true ------------------ 209| 63.9k|} Stream_GetRemainingCapacity: 260| 11.6M|{ 261| 11.6M| size_t cur = 0; 262| 11.6M| WINPR_ASSERT(_s); ------------------ | | 76| 11.6M|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 11.6M| do \ | | | | 61| 11.6M| { \ | | | | 62| 11.6M| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 11.6M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 11.6M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 11.6M| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 11.6M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 11.6M| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 11.6M| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 11.6M| \ | | | | 70| 11.6M| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 11.6M| do \ | | | | | | 32| 11.6M| { \ | | | | | | 33| 11.6M| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 11.6M] | | | | | | ------------------ | | | | | | 34| 11.6M| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 11.6M| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 11.6M] | | | | | | ------------------ | | | | ------------------ | | | | 71| 11.6M| \ | | | | 72| 11.6M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 11.6M| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 11.6M| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 11.6M| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 11.6M] | | | | ------------------ | | ------------------ ------------------ 263| 11.6M| WINPR_ASSERT(_s->buffer <= _s->pointer); ------------------ | | 76| 11.6M|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 11.6M| do \ | | | | 61| 11.6M| { \ | | | | 62| 11.6M| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 11.6M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 11.6M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 11.6M| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 11.6M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 11.6M| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 11.6M| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 11.6M| \ | | | | 70| 11.6M| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 11.6M| do \ | | | | | | 32| 11.6M| { \ | | | | | | 33| 11.6M| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 11.6M] | | | | | | ------------------ | | | | | | 34| 11.6M| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 11.6M| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 11.6M] | | | | | | ------------------ | | | | ------------------ | | | | 71| 11.6M| \ | | | | 72| 11.6M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 11.6M| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 11.6M| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 11.6M| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 11.6M] | | | | ------------------ | | ------------------ ------------------ 264| 11.6M| cur = (size_t)(_s->pointer - _s->buffer); 265| 11.6M| WINPR_ASSERT(cur <= _s->capacity); ------------------ | | 76| 11.6M|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 11.6M| do \ | | | | 61| 11.6M| { \ | | | | 62| 11.6M| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 11.6M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 11.6M| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 11.6M| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 11.6M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 11.6M| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 11.6M| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 11.6M| \ | | | | 70| 11.6M| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 11.6M| do \ | | | | | | 32| 11.6M| { \ | | | | | | 33| 11.6M| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 11.6M] | | | | | | ------------------ | | | | | | 34| 11.6M| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 11.6M| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 11.6M] | | | | | | ------------------ | | | | ------------------ | | | | 71| 11.6M| \ | | | | 72| 11.6M| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 11.6M| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 11.6M| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 11.6M| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 11.6M] | | | | ------------------ | | ------------------ ------------------ 266| 11.6M| if (cur > _s->capacity) ------------------ | Branch (266:6): [True: 0, False: 11.6M] ------------------ 267| 0| { 268| 0| WLog_FATAL(STREAM_TAG, "wStream API misuse: stream was written out of bounds"); ------------------ | | 350| 0| WLog_Print_dbg_tag(tag, WLOG_FATAL, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 269| 0| winpr_log_backtrace(STREAM_TAG, WLOG_FATAL, 20); ------------------ | | 30| 0|#define STREAM_TAG WINPR_TAG("wStream") | | ------------------ | | | | 25| 0|#define WINPR_TAG(tag) "com.winpr." tag | | ------------------ ------------------ 270| 0| return 0; 271| 0| } 272| 11.6M| return (_s->capacity - cur); 273| 11.6M|} Stream_GetRemainingLength: 276| 24.2k|{ 277| 24.2k| size_t cur = 0; 278| 24.2k| WINPR_ASSERT(_s); ------------------ | | 76| 24.2k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 24.2k| do \ | | | | 61| 24.2k| { \ | | | | 62| 24.2k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 24.2k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 24.2k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 24.2k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 24.2k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 24.2k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 24.2k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 24.2k| \ | | | | 70| 24.2k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 24.2k| do \ | | | | | | 32| 24.2k| { \ | | | | | | 33| 24.2k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 24.2k] | | | | | | ------------------ | | | | | | 34| 24.2k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 24.2k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 24.2k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 24.2k| \ | | | | 72| 24.2k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 24.2k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 24.2k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 24.2k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 24.2k] | | | | ------------------ | | ------------------ ------------------ 279| 24.2k| WINPR_ASSERT(_s->buffer <= _s->pointer); ------------------ | | 76| 24.2k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 24.2k| do \ | | | | 61| 24.2k| { \ | | | | 62| 24.2k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 24.2k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 24.2k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 24.2k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 24.2k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 24.2k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 24.2k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 24.2k| \ | | | | 70| 24.2k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 24.2k| do \ | | | | | | 32| 24.2k| { \ | | | | | | 33| 24.2k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 24.2k] | | | | | | ------------------ | | | | | | 34| 24.2k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 24.2k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 24.2k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 24.2k| \ | | | | 72| 24.2k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 24.2k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 24.2k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 24.2k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 24.2k] | | | | ------------------ | | ------------------ ------------------ 280| 24.2k| WINPR_ASSERT(_s->length <= _s->capacity); ------------------ | | 76| 24.2k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 24.2k| do \ | | | | 61| 24.2k| { \ | | | | 62| 24.2k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 24.2k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 24.2k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 24.2k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 24.2k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 24.2k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 24.2k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 24.2k| \ | | | | 70| 24.2k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 24.2k| do \ | | | | | | 32| 24.2k| { \ | | | | | | 33| 24.2k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 24.2k] | | | | | | ------------------ | | | | | | 34| 24.2k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 24.2k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 24.2k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 24.2k| \ | | | | 72| 24.2k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 24.2k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 24.2k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 24.2k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 24.2k] | | | | ------------------ | | ------------------ ------------------ 281| 24.2k| cur = (size_t)(_s->pointer - _s->buffer); 282| 24.2k| WINPR_ASSERT(cur <= _s->length); ------------------ | | 76| 24.2k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 24.2k| do \ | | | | 61| 24.2k| { \ | | | | 62| 24.2k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 24.2k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 24.2k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 24.2k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 24.2k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 24.2k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 24.2k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 24.2k| \ | | | | 70| 24.2k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 24.2k| do \ | | | | | | 32| 24.2k| { \ | | | | | | 33| 24.2k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 24.2k] | | | | | | ------------------ | | | | | | 34| 24.2k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 24.2k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 24.2k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 24.2k| \ | | | | 72| 24.2k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 24.2k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 24.2k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 24.2k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 24.2k] | | | | ------------------ | | ------------------ ------------------ 283| 24.2k| if (cur > _s->length) ------------------ | Branch (283:6): [True: 0, False: 24.2k] ------------------ 284| 0| { 285| 0| WLog_FATAL(STREAM_TAG, "wStream API misuse: stream was read out of bounds"); ------------------ | | 350| 0| WLog_Print_dbg_tag(tag, WLOG_FATAL, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 286| 0| winpr_log_backtrace(STREAM_TAG, WLOG_FATAL, 20); ------------------ | | 30| 0|#define STREAM_TAG WINPR_TAG("wStream") | | ------------------ | | | | 25| 0|#define WINPR_TAG(tag) "com.winpr." tag | | ------------------ ------------------ 287| 0| return 0; 288| 0| } 289| 24.2k| return (_s->length - cur); 290| 24.2k|} Stream_CheckAndLogRequiredLengthEx: 402| 2.88k|{ 403| 2.88k| WINPR_ASSERT(size > 0); ------------------ | | 76| 2.88k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 2.88k| do \ | | | | 61| 2.88k| { \ | | | | 62| 2.88k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 2.88k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 2.88k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 2.88k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 2.88k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 2.88k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 2.88k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 2.88k| \ | | | | 70| 2.88k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 2.88k| do \ | | | | | | 32| 2.88k| { \ | | | | | | 33| 2.88k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 2.88k] | | | | | | ------------------ | | | | | | 34| 2.88k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 2.88k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 2.88k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 2.88k| \ | | | | 72| 2.88k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 2.88k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 2.88k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 2.88k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 2.88k] | | | | ------------------ | | ------------------ ------------------ 404| 2.88k| const size_t actual = Stream_GetRemainingLength(s) / size; 405| | 406| 2.88k| if (actual < nmemb) ------------------ | Branch (406:6): [True: 234, False: 2.64k] ------------------ 407| 234| { 408| 234| va_list args = WINPR_C_ARRAY_INIT; ------------------ | | 85| 234| { \ | | 86| 234| } /** @since version 3.24.0 */ ------------------ 409| | 410| 234| va_start(args, fmt); 411| 234| const BOOL rc = Stream_CheckAndLogRequiredLengthExVa(tag, level, s, nmemb, size, fmt, args); 412| 234| va_end(args); 413| 234| return rc; 414| 234| } 415| 2.64k| return TRUE; ------------------ | | 126| 2.64k|#define TRUE true ------------------ 416| 2.88k|} Stream_CheckAndLogRequiredLengthExVa: 420| 234|{ 421| 234| WINPR_ASSERT(size > 0); ------------------ | | 76| 234|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 234| do \ | | | | 61| 234| { \ | | | | 62| 234| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 234| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 234| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 234| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 234| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 234| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 234| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 234| \ | | | | 70| 234| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 234| do \ | | | | | | 32| 234| { \ | | | | | | 33| 234| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 234] | | | | | | ------------------ | | | | | | 34| 234| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 234| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 234] | | | | | | ------------------ | | | | ------------------ | | | | 71| 234| \ | | | | 72| 234| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 234| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 234| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 234| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 234] | | | | ------------------ | | ------------------ ------------------ 422| 234| const size_t actual = Stream_GetRemainingLength(s) / size; 423| | 424| 234| if (actual < nmemb) ------------------ | Branch (424:6): [True: 234, False: 0] ------------------ 425| 234| return Stream_CheckAndLogRequiredLengthWLogExVa(WLog_Get(tag), level, s, nmemb, size, fmt, 426| 234| args); 427| 0| return TRUE; ------------------ | | 126| 0|#define TRUE true ------------------ 428| 234|} Stream_CheckAndLogRequiredLengthWLogEx: 432| 2.30k|{ 433| 2.30k| WINPR_ASSERT(size > 0); ------------------ | | 76| 2.30k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 2.30k| do \ | | | | 61| 2.30k| { \ | | | | 62| 2.30k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 2.30k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 2.30k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 2.30k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 2.30k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 2.30k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 2.30k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 2.30k| \ | | | | 70| 2.30k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 2.30k| do \ | | | | | | 32| 2.30k| { \ | | | | | | 33| 2.30k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 2.30k] | | | | | | ------------------ | | | | | | 34| 2.30k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 2.30k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 2.30k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 2.30k| \ | | | | 72| 2.30k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 2.30k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 2.30k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 2.30k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 2.30k] | | | | ------------------ | | ------------------ ------------------ 434| 2.30k| const size_t actual = Stream_GetRemainingLength(s) / size; 435| | 436| 2.30k| if (actual < nmemb) ------------------ | Branch (436:6): [True: 94, False: 2.21k] ------------------ 437| 94| { 438| 94| va_list args = WINPR_C_ARRAY_INIT; ------------------ | | 85| 94| { \ | | 86| 94| } /** @since version 3.24.0 */ ------------------ 439| | 440| 94| va_start(args, fmt); 441| 94| const BOOL rc = 442| 94| Stream_CheckAndLogRequiredLengthWLogExVa(log, level, s, nmemb, size, fmt, args); 443| 94| va_end(args); 444| 94| return rc; 445| 94| } 446| 2.21k| return TRUE; ------------------ | | 126| 2.21k|#define TRUE true ------------------ 447| 2.30k|} Stream_CheckAndLogRequiredLengthWLogExVa: 453| 328|{ 454| 328| WINPR_ASSERT(size > 0); ------------------ | | 76| 328|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 328| do \ | | | | 61| 328| { \ | | | | 62| 328| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 328| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 328| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 328| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 328| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 328| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 328| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 328| \ | | | | 70| 328| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 328| do \ | | | | | | 32| 328| { \ | | | | | | 33| 328| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 328] | | | | | | ------------------ | | | | | | 34| 328| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 328| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 328] | | | | | | ------------------ | | | | ------------------ | | | | 71| 328| \ | | | | 72| 328| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 328| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 328| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 328| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 328] | | | | ------------------ | | ------------------ ------------------ 455| 328| const size_t actual = Stream_GetRemainingLength(s) / size; 456| | 457| 328| if (actual < nmemb) ------------------ | Branch (457:6): [True: 328, False: 0] ------------------ 458| 328| { 459| 328| if (WLog_IsLevelActive(log, level)) ------------------ | Branch (459:7): [True: 328, False: 0] ------------------ 460| 328| { 461| 328| char prefix[1024] = WINPR_C_ARRAY_INIT; ------------------ | | 85| 328| { \ | | 86| 328| } /** @since version 3.24.0 */ ------------------ 462| | 463| 328| (void)vsnprintf(prefix, sizeof(prefix), fmt, args); 464| | 465| 328| WLog_Print(log, level, ------------------ | | 257| 328| do \ | | 258| 328| { \ | | 259| 328| if (WLog_IsLevelActive(_log, _log_level)) \ | | ------------------ | | | Branch (259:7): [True: 328, False: 0] | | ------------------ | | 260| 328| { \ | | 261| 328| WLog_Print_unchecked(_log, _log_level, __VA_ARGS__); \ | | ------------------ | | | | 251| 328| do \ | | | | 252| 328| { \ | | | | 253| 328| WLog_PrintTextMessage(_log, _log_level, __LINE__, __FILE__, __func__, __VA_ARGS__); \ | | | | 254| 328| } while (0) | | | | ------------------ | | | | | Branch (254:11): [Folded, False: 328] | | | | ------------------ | | ------------------ | | 262| 328| } \ | | 263| 328| } while (0) | | ------------------ | | | Branch (263:11): [Folded, False: 328] | | ------------------ ------------------ 466| 328| "[%s] invalid length, got %" PRIuz ", require at least %" PRIuz 467| 328| " [element size=%" PRIuz "]", 468| 328| prefix, actual, nmemb, size); 469| 328| winpr_log_backtrace_ex(log, level, 20); 470| 328| } 471| 328| return FALSE; ------------------ | | 122| 328|#define FALSE false ------------------ 472| 328| } 473| 0| return TRUE; ------------------ | | 126| 0|#define TRUE true ------------------ 474| 328|} Stream_SafeSeekEx: 530| 1.36k|{ 531| 1.36k| if (!Stream_CheckAndLogRequiredLengthEx(STREAM_TAG, WLOG_WARN, s, size, 1, "%s(%s:%" PRIuz ")", ------------------ | | 30| 1.36k|#define STREAM_TAG WINPR_TAG("wStream") | | ------------------ | | | | 25| 1.36k|#define WINPR_TAG(tag) "com.winpr." tag | | ------------------ ------------------ | Branch (531:6): [True: 191, False: 1.17k] ------------------ 532| 1.36k| fkt, file, line)) 533| 191| return FALSE; ------------------ | | 122| 191|#define FALSE false ------------------ 534| | 535| 1.17k| Stream_Seek(s, size); 536| 1.17k| return TRUE; ------------------ | | 126| 1.17k|#define TRUE true ------------------ 537| 1.36k|} LLVMFuzzerTestOneInput: 19| 1.43k|{ 20| 1.43k| if ((Size < 1) || (Size > (1u << 24))) ------------------ | Branch (20:6): [True: 0, False: 1.43k] | Branch (20:20): [True: 0, False: 1.43k] ------------------ 21| 0| return 0; 22| | 23| 1.43k| wImage* img = winpr_image_new(); 24| 1.43k| if (!img) ------------------ | Branch (24:6): [True: 0, False: 1.43k] ------------------ 25| 0| return 0; 26| | 27| 1.43k| const int rc = winpr_image_read_buffer(img, Data, Size); 28| 1.43k| if (rc > 0) ------------------ | Branch (28:6): [True: 249, False: 1.18k] ------------------ 29| 249| { 30| 249| const UINT32 formats[] = { 31| 249| WINPR_IMAGE_BITMAP, ------------------ | | 66| 249|#define WINPR_IMAGE_BITMAP 0 ------------------ 32| |#if defined(WINPR_UTILS_IMAGE_PNG) 33| | WINPR_IMAGE_PNG, 34| |#endif 35| |#if defined(WINPR_UTILS_IMAGE_JPEG) 36| | WINPR_IMAGE_JPEG, 37| |#endif 38| |#if defined(WINPR_UTILS_IMAGE_WEBP) 39| | WINPR_IMAGE_WEBP, 40| |#endif 41| 249| }; 42| 498| for (size_t i = 0; i < ARRAYSIZE(formats); i++) ------------------ | | 962| 498|#define ARRAYSIZE(A) RTL_NUMBER_OF_V2(A) | | ------------------ | | | | 958| 498|#define RTL_NUMBER_OF_V2(A) RTL_NUMBER_OF_V1(A) | | | | ------------------ | | | | | | 957| 498|#define RTL_NUMBER_OF_V1(A) (sizeof(A) / sizeof((A)[0])) | | | | ------------------ | | ------------------ ------------------ | Branch (42:22): [True: 249, False: 249] ------------------ 43| 249| { 44| 249| size_t osize = 0; 45| 249| void* out = winpr_image_write_buffer(img, formats[i], &osize); 46| 249| free(out); 47| 249| } 48| 249| } 49| | 50| 1.43k| winpr_image_free(img, TRUE); ------------------ | | 126| 1.43k|#define TRUE true ------------------ 51| 1.43k| return 0; 52| 1.43k|} winpr_unwind_backtrace: 129| 328|{ 130| 328| _Unwind_Reason_Code rc = _URC_FOREIGN_EXCEPTION_CAUGHT; 131| 328| unwind_context_t* ctx = calloc(1, sizeof(unwind_context_t)); 132| 328| if (!ctx) ------------------ | Branch (132:6): [True: 0, False: 328] ------------------ 133| 0| goto fail; 134| 328| ctx->size = size; 135| 328| ctx->info = calloc(size, sizeof(unwind_info_t)); 136| 328| if (!ctx->info) ------------------ | Branch (136:6): [True: 0, False: 328] ------------------ 137| 0| goto fail; 138| | 139| 328| rc = _Unwind_Backtrace(unwind_backtrace_callback, ctx); 140| 328| if (rc != _URC_END_OF_STACK) ------------------ | Branch (140:6): [True: 0, False: 328] ------------------ 141| 0| { 142| | /* https://github.com/FreeRDP/FreeRDP/issues/11490 143| | * 144| | * there seems to be no consensus on what to return from this function. 145| | * so we just warn about unexpected return codes and return the context regardless. 146| | */ 147| 0| char buffer[64] = WINPR_C_ARRAY_INIT; ------------------ | | 85| 0| { \ | | 86| 0| } /** @since version 3.24.0 */ ------------------ 148| 0| WLog_WARN(TAG, "_Unwind_Backtrace failed with %s", ------------------ | | 346| 0| WLog_Print_dbg_tag(tag, WLOG_WARN, __LINE__, __FILE__, __func__, __VA_ARGS__) ------------------ 149| 0| unwind_reason_str_buffer(rc, buffer, sizeof(buffer))); 150| 0| } 151| | 152| 328| return ctx; 153| 0|fail: 154| 0| winpr_unwind_backtrace_free(ctx); 155| 0| return nullptr; 156| 328|} winpr_unwind_backtrace_free: 159| 328|{ 160| 328| unwind_context_t* ctx = buffer; 161| 328| if (!ctx) ------------------ | Branch (161:6): [True: 0, False: 328] ------------------ 162| 0| return; 163| 328| free(ctx->info); 164| 328| free(ctx); 165| 328|} winpr_unwind_backtrace_symbols: 168| 328|{ 169| 328| union 170| 328| { 171| 328| void* pv; 172| 328| char* cp; 173| 328| char** cpp; 174| 328| } cnv; 175| 328| unwind_context_t* ctx = buffer; 176| 328| cnv.cpp = nullptr; 177| | 178| 328| if (!ctx) ------------------ | Branch (178:6): [True: 0, False: 328] ------------------ 179| 0| return nullptr; 180| | 181| 328| cnv.pv = calloc(ctx->pos * (sizeof(char*) + UNWIND_MAX_LINE_SIZE), sizeof(char*)); ------------------ | | 39| 328|#define UNWIND_MAX_LINE_SIZE 1024ULL ------------------ 182| 328| if (!cnv.pv) ------------------ | Branch (182:6): [True: 0, False: 328] ------------------ 183| 0| return nullptr; 184| | 185| 328| if (used) ------------------ | Branch (185:6): [True: 328, False: 0] ------------------ 186| 328| *used = ctx->pos; 187| | 188| 4.88k| for (size_t x = 0; x < ctx->pos; x++) ------------------ | Branch (188:21): [True: 4.55k, False: 328] ------------------ 189| 4.55k| { 190| 4.55k| char* msg = cnv.cp + ctx->pos * sizeof(char*) + x * UNWIND_MAX_LINE_SIZE; ------------------ | | 39| 4.55k|#define UNWIND_MAX_LINE_SIZE 1024ULL ------------------ 191| 4.55k| const unwind_info_t* info = &ctx->info[x]; 192| 4.55k| Dl_info dlinfo = WINPR_C_ARRAY_INIT; ------------------ | | 85| 4.55k| { \ | | 86| 4.55k| } /** @since version 3.24.0 */ ------------------ 193| 4.55k| int rc = dladdr(info->pc.pv, &dlinfo); 194| | 195| 4.55k| cnv.cpp[x] = msg; 196| | 197| 4.55k| if (rc == 0) ------------------ | Branch (197:7): [True: 328, False: 4.23k] ------------------ 198| 328| (void)_snprintf(msg, UNWIND_MAX_LINE_SIZE, "address=%p, unresolvable", info->pc.pv); ------------------ | | 295| 328|#define _snprintf snprintf ------------------ (void)_snprintf(msg, UNWIND_MAX_LINE_SIZE, "address=%p, unresolvable", info->pc.pv); ------------------ | | 39| 328|#define UNWIND_MAX_LINE_SIZE 1024ULL ------------------ 199| 4.23k| else 200| 4.23k| (void)_snprintf(msg, UNWIND_MAX_LINE_SIZE, ------------------ | | 295| 4.23k|#define _snprintf snprintf ------------------ (void)_snprintf(msg, UNWIND_MAX_LINE_SIZE, ------------------ | | 39| 4.23k|#define UNWIND_MAX_LINE_SIZE 1024ULL ------------------ 201| 4.23k| "address=%p dli_fname=%s [%p], dli_sname=%s [%p]", info->pc.pv, 202| 4.23k| dlinfo.dli_fname, dlinfo.dli_fbase, dlinfo.dli_sname, dlinfo.dli_saddr); 203| 4.55k| } 204| | 205| | // NOLINTNEXTLINE(clang-analyzer-unix.Malloc): function is an allocator 206| 328| return cnv.cpp; 207| 328|} debug.c:unwind_backtrace_callback: 108| 4.55k|{ 109| 4.55k| unwind_context_t* ctx = arg; 110| | 111| 4.55k| assert(ctx); ------------------ | Branch (111:2): [True: 0, False: 4.55k] | Branch (111:2): [True: 4.55k, False: 0] ------------------ 112| | 113| 4.55k| if (ctx->pos < ctx->size) ------------------ | Branch (113:6): [True: 4.55k, False: 0] ------------------ 114| 4.55k| { 115| 4.55k| unwind_info_t* info = &ctx->info[ctx->pos++]; 116| 4.55k| info->pc.uw = _Unwind_GetIP(context); 117| | 118| | /* _Unwind_GetLanguageSpecificData has various return value definitions, 119| | * cast to the type we expect and disable linter warnings 120| | */ 121| | // NOLINTNEXTLINE(google-readability-casting,readability-redundant-casting) 122| 4.55k| info->langSpecificData.pv = (void*)_Unwind_GetLanguageSpecificData(context); 123| 4.55k| } 124| | 125| 4.55k| return _URC_NO_REASON; 126| 4.55k|} WLog_Appender_Free: 25| 1|{ 26| 1| if (!appender) ------------------ | Branch (26:6): [True: 0, False: 1] ------------------ 27| 0| return; 28| | 29| 1| if (appender->Layout) ------------------ | Branch (29:6): [True: 1, False: 0] ------------------ 30| 1| { 31| 1| WLog_Layout_Free(log, appender->Layout); 32| 1| appender->Layout = nullptr; 33| 1| } 34| | 35| 1| DeleteCriticalSection(&appender->lock); 36| 1| appender->Free(appender); 37| 1|} WLog_GetLogAppender: 40| 10.8k|{ 41| 10.8k| if (!log) ------------------ | Branch (41:6): [True: 0, False: 10.8k] ------------------ 42| 0| return nullptr; 43| | 44| 10.8k| if (!log->Appender) ------------------ | Branch (44:6): [True: 5.43k, False: 5.43k] ------------------ 45| 5.43k| return WLog_GetLogAppender(log->Parent); 46| | 47| 5.43k| return log->Appender; 48| 10.8k|} WLog_OpenAppender: 51| 1|{ 52| 1| int status = 0; 53| 1| wLogAppender* appender = nullptr; 54| | 55| 1| appender = WLog_GetLogAppender(log); 56| | 57| 1| if (!appender) ------------------ | Branch (57:6): [True: 0, False: 1] ------------------ 58| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 59| | 60| 1| if (!appender->Open) ------------------ | Branch (60:6): [True: 0, False: 1] ------------------ 61| 0| return TRUE; ------------------ | | 126| 0|#define TRUE true ------------------ 62| | 63| 1| if (!appender->active) ------------------ | Branch (63:6): [True: 1, False: 0] ------------------ 64| 1| { 65| 1| status = appender->Open(log, appender); 66| 1| appender->active = TRUE; ------------------ | | 126| 1|#define TRUE true ------------------ 67| 1| } 68| | 69| 1| return status; 70| 1|} WLog_SetLogAppenderType: 157| 1|{ 158| 1| if (!log) ------------------ | Branch (158:6): [True: 0, False: 1] ------------------ 159| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 160| | 161| 1| if (log->Appender) ------------------ | Branch (161:6): [True: 0, False: 1] ------------------ 162| 0| { 163| 0| WLog_Appender_Free(log, log->Appender); 164| 0| log->Appender = nullptr; 165| 0| } 166| | 167| 1| log->Appender = WLog_Appender_New(log, logAppenderType); 168| 1| return log->Appender != nullptr; 169| 1|} Appender.c:WLog_Appender_New: 95| 1|{ 96| 1| wLogAppender* appender = nullptr; 97| | 98| 1| if (!log) ------------------ | Branch (98:6): [True: 0, False: 1] ------------------ 99| 0| return nullptr; 100| | 101| 1| switch (logAppenderType) 102| 1| { 103| 1| case WLOG_APPENDER_CONSOLE: ------------------ | Branch (103:3): [True: 1, False: 0] ------------------ 104| 1| appender = WLog_ConsoleAppender_New(log); 105| 1| break; 106| 0| case WLOG_APPENDER_FILE: ------------------ | Branch (106:3): [True: 0, False: 1] ------------------ 107| 0| appender = WLog_FileAppender_New(log); 108| 0| break; 109| 0| case WLOG_APPENDER_BINARY: ------------------ | Branch (109:3): [True: 0, False: 1] ------------------ 110| 0| appender = WLog_BinaryAppender_New(log); 111| 0| break; 112| 0| case WLOG_APPENDER_CALLBACK: ------------------ | Branch (112:3): [True: 0, False: 1] ------------------ 113| 0| appender = WLog_CallbackAppender_New(log); 114| 0| break; 115| 0|#ifdef WINPR_HAVE_SYSLOG_H 116| 0| case WLOG_APPENDER_SYSLOG: ------------------ | Branch (116:3): [True: 0, False: 1] ------------------ 117| 0| appender = WLog_SyslogAppender_New(log); 118| 0| break; 119| 0|#endif 120| |#ifdef WINPR_HAVE_JOURNALD_H 121| | case WLOG_APPENDER_JOURNALD: 122| | appender = WLog_JournaldAppender_New(log); 123| | break; 124| |#endif 125| 0| case WLOG_APPENDER_UDP: ------------------ | Branch (125:3): [True: 0, False: 1] ------------------ 126| 0| appender = WLog_UdpAppender_New(log); 127| 0| break; 128| 0| default: ------------------ | Branch (128:3): [True: 0, False: 1] ------------------ 129| 0| (void)fprintf(stderr, "%s: unknown handler type %" PRIu32 "\n", __func__, 130| 0| logAppenderType); 131| 0| appender = nullptr; 132| 0| break; 133| 1| } 134| | 135| 1| if (!appender) ------------------ | Branch (135:6): [True: 0, False: 1] ------------------ 136| 0| appender = WLog_ConsoleAppender_New(log); 137| | 138| 1| if (!appender) ------------------ | Branch (138:6): [True: 0, False: 1] ------------------ 139| 0| return nullptr; 140| | 141| 1| if (!(appender->Layout = WLog_Layout_New(log))) ------------------ | Branch (141:6): [True: 0, False: 1] ------------------ 142| 0| { 143| 0| WLog_Appender_Free(log, appender); 144| 0| return nullptr; 145| 0| } 146| | 147| 1| if (!InitializeCriticalSectionAndSpinCount(&appender->lock, 4000)) ------------------ | Branch (147:6): [True: 0, False: 1] ------------------ 148| 0| { 149| 0| WLog_Appender_Free(log, appender); 150| 0| return nullptr; 151| 0| } 152| | 153| 1| return appender; 154| 1|} WLog_ConsoleAppender_New: 243| 1|{ 244| 1| wLogConsoleAppender* ConsoleAppender = 245| 1| (wLogConsoleAppender*)calloc(1, sizeof(wLogConsoleAppender)); 246| | 247| 1| if (!ConsoleAppender) ------------------ | Branch (247:6): [True: 0, False: 1] ------------------ 248| 0| return nullptr; 249| | 250| 1| ConsoleAppender->common.Type = WLOG_APPENDER_CONSOLE; 251| 1| ConsoleAppender->common.Open = WLog_ConsoleAppender_Open; 252| 1| ConsoleAppender->common.Close = WLog_ConsoleAppender_Close; 253| 1| ConsoleAppender->common.WriteMessage = WLog_ConsoleAppender_WriteMessage; 254| 1| ConsoleAppender->common.WriteDataMessage = WLog_ConsoleAppender_WriteDataMessage; 255| 1| ConsoleAppender->common.WriteImageMessage = WLog_ConsoleAppender_WriteImageMessage; 256| 1| ConsoleAppender->common.WritePacketMessage = WLog_ConsoleAppender_WritePacketMessage; 257| 1| ConsoleAppender->common.Set = WLog_ConsoleAppender_Set; 258| 1| ConsoleAppender->common.Free = WLog_ConsoleAppender_Free; 259| | 260| 1| ConsoleAppender->outputStream = WLOG_CONSOLE_DEFAULT; ------------------ | | 29| 1|#define WLOG_CONSOLE_DEFAULT 0 ------------------ 261| | 262| |#ifdef _WIN32 263| | if (IsDebuggerPresent()) 264| | ConsoleAppender->outputStream = WLOG_CONSOLE_DEBUG; 265| |#endif 266| | 267| 1| return &ConsoleAppender->common; 268| 1|} ConsoleAppender.c:WLog_ConsoleAppender_Open: 43| 1|{ 44| 1| return TRUE; ------------------ | | 126| 1|#define TRUE true ------------------ 45| 1|} ConsoleAppender.c:WLog_ConsoleAppender_WriteMessage: 55| 5.43k|{ 56| 5.43k| if (!appender) ------------------ | Branch (56:6): [True: 0, False: 5.43k] ------------------ 57| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 58| | 59| 5.43k| wLogConsoleAppender* consoleAppender = (wLogConsoleAppender*)appender; 60| | 61| 5.43k| char prefix[WLOG_MAX_PREFIX_SIZE] = WINPR_C_ARRAY_INIT; ------------------ | | 85| 5.43k| { \ | | 86| 5.43k| } /** @since version 3.24.0 */ ------------------ 62| 5.43k| WLog_Layout_GetMessagePrefix(log, appender->Layout, cmessage, prefix, sizeof(prefix)); 63| | 64| |#ifdef _WIN32 65| | if (consoleAppender->outputStream == WLOG_CONSOLE_DEBUG) 66| | { 67| | OutputDebugStringA(prefix); 68| | OutputDebugStringA(cmessage->TextString); 69| | OutputDebugStringA("\n"); 70| | 71| | return TRUE; 72| | } 73| |#endif 74| |#ifdef ANDROID 75| | android_LogPriority level; 76| | switch (cmessage->Level) 77| | { 78| | case WLOG_TRACE: 79| | level = ANDROID_LOG_VERBOSE; 80| | break; 81| | case WLOG_DEBUG: 82| | level = ANDROID_LOG_DEBUG; 83| | break; 84| | case WLOG_INFO: 85| | level = ANDROID_LOG_INFO; 86| | break; 87| | case WLOG_WARN: 88| | level = ANDROID_LOG_WARN; 89| | break; 90| | case WLOG_ERROR: 91| | level = ANDROID_LOG_ERROR; 92| | break; 93| | case WLOG_FATAL: 94| | level = ANDROID_LOG_FATAL; 95| | break; 96| | case WLOG_OFF: 97| | level = ANDROID_LOG_SILENT; 98| | break; 99| | default: 100| | level = ANDROID_LOG_FATAL; 101| | break; 102| | } 103| | 104| | if (level != ANDROID_LOG_SILENT) 105| | __android_log_print(level, log->Name, "%s%s", prefix, cmessage->TextString); 106| | 107| |#else 108| 5.43k| FILE* fp = nullptr; 109| 5.43k| switch (consoleAppender->outputStream) 110| 5.43k| { 111| 0| case WLOG_CONSOLE_STDOUT: ------------------ | | 30| 0|#define WLOG_CONSOLE_STDOUT 1 ------------------ | Branch (111:3): [True: 0, False: 5.43k] ------------------ 112| 0| fp = stdout; 113| 0| break; 114| 0| case WLOG_CONSOLE_STDERR: ------------------ | | 31| 0|#define WLOG_CONSOLE_STDERR 2 ------------------ | Branch (114:3): [True: 0, False: 5.43k] ------------------ 115| 0| fp = stderr; 116| 0| break; 117| 5.43k| default: ------------------ | Branch (117:3): [True: 5.43k, False: 0] ------------------ 118| 5.43k| switch (cmessage->Level) 119| 5.43k| { 120| 0| case WLOG_TRACE: ------------------ | Branch (120:5): [True: 0, False: 5.43k] ------------------ 121| 0| case WLOG_DEBUG: ------------------ | Branch (121:5): [True: 0, False: 5.43k] ------------------ 122| 0| case WLOG_INFO: ------------------ | Branch (122:5): [True: 0, False: 5.43k] ------------------ 123| 0| fp = stdout; 124| 0| break; 125| 5.43k| default: ------------------ | Branch (125:5): [True: 5.43k, False: 0] ------------------ 126| 5.43k| fp = stderr; 127| 5.43k| break; 128| 5.43k| } 129| 5.43k| break; 130| 5.43k| } 131| | 132| 5.43k| if (cmessage->Level != WLOG_OFF) ------------------ | Branch (132:6): [True: 5.43k, False: 0] ------------------ 133| 5.43k| (void)fprintf(fp, "%s%s\n", prefix, cmessage->TextString); 134| 5.43k|#endif 135| 5.43k| return TRUE; ------------------ | | 126| 5.43k|#define TRUE true ------------------ 136| 5.43k|} ConsoleAppender.c:WLog_ConsoleAppender_Free: 230| 1|{ 231| 1| if (appender) ------------------ | Branch (231:6): [True: 1, False: 0] ------------------ 232| 1| { 233| 1| if (appender->PacketMessageContext) ------------------ | Branch (233:7): [True: 0, False: 1] ------------------ 234| 0| { 235| 0| Pcap_Close((wPcap*)appender->PacketMessageContext); 236| 0| } 237| | 238| 1| free(appender); 239| 1| } 240| 1|} WLog_Layout_GetMessagePrefix: 246| 5.43k|{ 247| 5.43k| char format[WLOG_MAX_PREFIX_SIZE] = WINPR_C_ARRAY_INIT; ------------------ | | 85| 5.43k| { \ | | 86| 5.43k| } /** @since version 3.24.0 */ ------------------ 248| | 249| 5.43k| WINPR_ASSERT(layout); ------------------ | | 76| 5.43k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 5.43k| do \ | | | | 61| 5.43k| { \ | | | | 62| 5.43k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 5.43k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 5.43k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 5.43k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 5.43k| \ | | | | 70| 5.43k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 5.43k| do \ | | | | | | 32| 5.43k| { \ | | | | | | 33| 5.43k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 5.43k] | | | | | | ------------------ | | | | | | 34| 5.43k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 5.43k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 5.43k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 5.43k| \ | | | | 72| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 5.43k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 5.43k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 5.43k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 5.43k] | | | | ------------------ | | ------------------ ------------------ 250| 5.43k| WINPR_ASSERT(message); ------------------ | | 76| 5.43k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 5.43k| do \ | | | | 61| 5.43k| { \ | | | | 62| 5.43k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 5.43k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 5.43k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 5.43k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 5.43k| \ | | | | 70| 5.43k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 5.43k| do \ | | | | | | 32| 5.43k| { \ | | | | | | 33| 5.43k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 5.43k] | | | | | | ------------------ | | | | | | 34| 5.43k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 5.43k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 5.43k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 5.43k| \ | | | | 72| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 5.43k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 5.43k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 5.43k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 5.43k] | | | | ------------------ | | ------------------ ------------------ 251| 5.43k| WINPR_ASSERT(prefix); ------------------ | | 76| 5.43k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 5.43k| do \ | | | | 61| 5.43k| { \ | | | | 62| 5.43k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 5.43k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 5.43k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 5.43k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 5.43k| \ | | | | 70| 5.43k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 5.43k| do \ | | | | | | 32| 5.43k| { \ | | | | | | 33| 5.43k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 5.43k] | | | | | | ------------------ | | | | | | 34| 5.43k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 5.43k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 5.43k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 5.43k| \ | | | | 72| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 5.43k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 5.43k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 5.43k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 5.43k] | | | | ------------------ | | ------------------ ------------------ 252| | 253| 5.43k| struct format_tid_arg targ = WINPR_C_ARRAY_INIT; ------------------ | | 85| 5.43k| { \ | | 86| 5.43k| } /** @since version 3.24.0 */ ------------------ 254| | 255| 5.43k| SYSTEMTIME localTime = WINPR_C_ARRAY_INIT; ------------------ | | 85| 5.43k| { \ | | 86| 5.43k| } /** @since version 3.24.0 */ ------------------ 256| 5.43k| GetLocalTime(&localTime); 257| | 258| 5.43k| struct format_option_recurse recurse = { 259| 5.43k| .options = nullptr, .nroptions = 0, .log = log, .layout = layout, .message = message 260| 5.43k| }; 261| | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 263| 5.43k| struct format_option options[] = { 264| 5.43k| { ENTRY("%ctx"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 265| 5.43k| ENTRY("%s"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 266| 5.43k| log->custom, 267| 5.43k| { .pv = log->context }, 268| 5.43k| nullptr, 269| 5.43k| &recurse }, /* log context */ 270| 5.43k| { ENTRY("%dw"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 271| 5.43k| ENTRY("%u"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 272| 5.43k| nullptr, 273| 5.43k| { .s = localTime.wDayOfWeek }, 274| 5.43k| nullptr, 275| 5.43k| &recurse }, /* day of week */ 276| 5.43k| { ENTRY("%dy"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 277| 5.43k| ENTRY("%u"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 278| 5.43k| nullptr, 279| 5.43k| { .s = localTime.wDay }, 280| 5.43k| nullptr, 281| 5.43k| &recurse }, /* day of year 282| | */ 283| 5.43k| { ENTRY("%fl"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 284| 5.43k| ENTRY("%s"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 285| 5.43k| nullptr, 286| 5.43k| { .cpv = message->FileName }, 287| 5.43k| nullptr, 288| 5.43k| &recurse }, /* file 289| | */ 290| 5.43k| { ENTRY("%fn"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 291| 5.43k| ENTRY("%s"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 292| 5.43k| nullptr, 293| 5.43k| { .cpv = message->FunctionName }, 294| 5.43k| nullptr, 295| 5.43k| &recurse }, /* function 296| | */ 297| 5.43k| { ENTRY("%hr"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 298| 5.43k| ENTRY("%02u"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 299| 5.43k| nullptr, 300| 5.43k| { .s = localTime.wHour }, 301| 5.43k| nullptr, 302| 5.43k| &recurse }, /* hours 303| | */ 304| 5.43k| { ENTRY("%ln"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 305| 5.43k| ENTRY("%" PRIuz), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 306| 5.43k| nullptr, 307| 5.43k| { .s = message->LineNumber }, 308| 5.43k| nullptr, 309| 5.43k| &recurse }, /* line number */ 310| 5.43k| { ENTRY("%lv"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 311| 5.43k| ENTRY("%s"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 312| 5.43k| nullptr, 313| 5.43k| { .cpv = WLOG_LEVELS[message->Level] }, 314| 5.43k| nullptr, 315| 5.43k| &recurse }, /* log level */ 316| 5.43k| { ENTRY("%mi"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 317| 5.43k| ENTRY("%02u"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 318| 5.43k| nullptr, 319| 5.43k| { .s = localTime.wMinute }, 320| 5.43k| nullptr, 321| 5.43k| &recurse }, /* minutes 322| | */ 323| 5.43k| { ENTRY("%ml"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 324| 5.43k| ENTRY("%03u"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 325| 5.43k| nullptr, 326| 5.43k| { .s = localTime.wMilliseconds }, 327| 5.43k| nullptr, 328| 5.43k| &recurse }, /* milliseconds */ 329| 5.43k| { ENTRY("%mn"), ENTRY("%s"), nullptr, { .cpv = log->Name }, nullptr, &recurse }, /* module ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ { ENTRY("%mn"), ENTRY("%s"), nullptr, { .cpv = log->Name }, nullptr, &recurse }, /* module ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 330| | name */ 331| 5.43k| { ENTRY("%mo"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 332| 5.43k| ENTRY("%u"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 333| 5.43k| nullptr, 334| 5.43k| { .s = localTime.wMonth }, 335| 5.43k| nullptr, 336| 5.43k| &recurse }, /* month 337| | */ 338| 5.43k| { ENTRY("%pid"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 339| 5.43k| ENTRY("%u"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 340| 5.43k| nullptr, 341| 5.43k| { .s = GetCurrentProcessId() }, 342| 5.43k| nullptr, 343| 5.43k| &recurse }, /* process id */ 344| 5.43k| { ENTRY("%se"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 345| 5.43k| ENTRY("%02u"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 346| 5.43k| nullptr, 347| 5.43k| { .s = localTime.wSecond }, 348| 5.43k| nullptr, 349| 5.43k| &recurse }, /* seconds 350| | */ 351| 5.43k| { ENTRY("%tid"), ENTRY("%s"), get_tid, { .pv = &targ }, nullptr, &recurse }, /* thread id */ ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ { ENTRY("%tid"), ENTRY("%s"), get_tid, { .pv = &targ }, nullptr, &recurse }, /* thread id */ ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 352| 5.43k| { ENTRY("%yr"), ENTRY("%u"), nullptr, { .s = localTime.wYear }, nullptr, &recurse }, /* year ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ { ENTRY("%yr"), ENTRY("%u"), nullptr, { .s = localTime.wYear }, nullptr, &recurse }, /* year ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 353| | */ 354| 5.43k| { ENTRY("%{"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 355| 5.43k| ENTRY("%}"), ------------------ | | 262| 5.43k|#define ENTRY(x) x, sizeof(x) - 1 ------------------ 356| 5.43k| nullptr, 357| 5.43k| { .pv = log->context }, 358| 5.43k| skip_if_null, 359| 5.43k| &recurse }, /* skip if no context */ 360| 5.43k| }; 361| | 362| 5.43k| recurse.options = options; 363| 5.43k| recurse.nroptions = ARRAYSIZE(options); ------------------ | | 962| 5.43k|#define ARRAYSIZE(A) RTL_NUMBER_OF_V2(A) | | ------------------ | | | | 958| 5.43k|#define RTL_NUMBER_OF_V2(A) RTL_NUMBER_OF_V1(A) | | | | ------------------ | | | | | | 957| 5.43k|#define RTL_NUMBER_OF_V1(A) (sizeof(A) / sizeof((A)[0])) | | | | ------------------ | | ------------------ ------------------ 364| | 365| 5.43k| if (!replace_format_string(layout->FormatString, &recurse, format, ARRAYSIZE(format))) ------------------ | | 962| 5.43k|#define ARRAYSIZE(A) RTL_NUMBER_OF_V2(A) | | ------------------ | | | | 958| 5.43k|#define RTL_NUMBER_OF_V2(A) RTL_NUMBER_OF_V1(A) | | | | ------------------ | | | | | | 957| 5.43k|#define RTL_NUMBER_OF_V1(A) (sizeof(A) / sizeof((A)[0])) | | | | ------------------ | | ------------------ ------------------ | Branch (365:6): [True: 0, False: 5.43k] ------------------ 366| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 367| | 368| 5.43k| WINPR_PRAGMA_DIAG_PUSH 369| 5.43k| WINPR_PRAGMA_DIAG_IGNORED_FORMAT_SECURITY 370| | 371| 5.43k| WLog_PrintMessagePrefix(prefix, prefixlen, format); 372| | 373| 5.43k| WINPR_PRAGMA_DIAG_POP 374| | 375| 5.43k| return TRUE; ------------------ | | 126| 5.43k|#define TRUE true ------------------ 376| 5.43k|} WLog_Layout_New: 403| 1|{ 404| 1| LPCSTR prefix = "WLOG_PREFIX"; 405| 1| DWORD nSize = 0; 406| 1| char* env = nullptr; 407| 1| wLogLayout* layout = nullptr; 408| 1| layout = (wLogLayout*)calloc(1, sizeof(wLogLayout)); 409| | 410| 1| if (!layout) ------------------ | Branch (410:6): [True: 0, False: 1] ------------------ 411| 0| return nullptr; 412| | 413| 1| nSize = GetEnvironmentVariableA(prefix, nullptr, 0); 414| | 415| 1| if (nSize) ------------------ | Branch (415:6): [True: 0, False: 1] ------------------ 416| 0| { 417| 0| env = (LPSTR)malloc(nSize); 418| | 419| 0| if (!env) ------------------ | Branch (419:7): [True: 0, False: 0] ------------------ 420| 0| { 421| 0| free(layout); 422| 0| return nullptr; 423| 0| } 424| | 425| 0| if (GetEnvironmentVariableA(prefix, env, nSize) != nSize - 1) ------------------ | Branch (425:7): [True: 0, False: 0] ------------------ 426| 0| { 427| 0| free(env); 428| 0| free(layout); 429| 0| return nullptr; 430| 0| } 431| 0| } 432| | 433| 1| if (env) ------------------ | Branch (433:6): [True: 0, False: 1] ------------------ 434| 0| layout->FormatString = env; 435| 1| else 436| 1| { 437| |#ifdef ANDROID 438| | layout->FormatString = _strdup("[pid=%pid:tid=%tid] - [%fn]%{[%ctx]%}: "); 439| |#else 440| 1| layout->FormatString = 441| 1| _strdup("[%hr:%mi:%se:%ml] [%pid:%tid] [%lv][%mn] - [%fn]%{[%ctx]%}: "); 442| 1|#endif 443| | 444| 1| if (!layout->FormatString) ------------------ | Branch (444:7): [True: 0, False: 1] ------------------ 445| 0| { 446| 0| free(layout); 447| 0| return nullptr; 448| 0| } 449| 1| } 450| | 451| 1| return layout; 452| 1|} WLog_Layout_Free: 455| 1|{ 456| 1| if (layout) ------------------ | Branch (456:6): [True: 1, False: 0] ------------------ 457| 1| { 458| 1| if (layout->FormatString) ------------------ | Branch (458:7): [True: 1, False: 0] ------------------ 459| 1| { 460| 1| free(layout->FormatString); 461| 1| layout->FormatString = nullptr; 462| 1| } 463| | 464| 1| free(layout); 465| 1| } 466| 1|} Layout.c:get_tid: 101| 5.43k|{ 102| 5.43k| struct format_tid_arg* targ = arg; 103| 5.43k| WINPR_ASSERT(targ); ------------------ | | 76| 5.43k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 5.43k| do \ | | | | 61| 5.43k| { \ | | | | 62| 5.43k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 5.43k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 5.43k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 5.43k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 5.43k| \ | | | | 70| 5.43k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 5.43k| do \ | | | | | | 32| 5.43k| { \ | | | | | | 33| 5.43k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 5.43k] | | | | | | ------------------ | | | | | | 34| 5.43k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 5.43k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 5.43k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 5.43k| \ | | | | 72| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 5.43k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 5.43k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 5.43k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 5.43k] | | | | ------------------ | | ------------------ ------------------ 104| | 105| 5.43k| size_t tid = 0; 106| 5.43k|#if defined __linux__ && !defined ANDROID 107| | /* On Linux we prefer to see the LWP id */ 108| 5.43k| tid = (size_t)syscall(SYS_gettid); 109| |#else 110| | tid = (size_t)GetCurrentThreadId(); 111| |#endif 112| 5.43k| (void)_snprintf(targ->tid, sizeof(targ->tid), "%08" PRIxz, tid); ------------------ | | 295| 5.43k|#define _snprintf snprintf ------------------ (void)_snprintf(targ->tid, sizeof(targ->tid), "%08" PRIxz, tid); ------------------ | | 487| 5.43k|#define PRIxz "zx" ------------------ 113| 5.43k| return targ->tid; 114| 5.43k|} Layout.c:skip_if_null: 150| 5.43k|{ 151| 5.43k| WINPR_ASSERT(opt); ------------------ | | 76| 5.43k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 5.43k| do \ | | | | 61| 5.43k| { \ | | | | 62| 5.43k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 5.43k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 5.43k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 5.43k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 5.43k| \ | | | | 70| 5.43k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 5.43k| do \ | | | | | | 32| 5.43k| { \ | | | | | | 33| 5.43k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 5.43k] | | | | | | ------------------ | | | | | | 34| 5.43k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 5.43k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 5.43k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 5.43k| \ | | | | 72| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 5.43k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 5.43k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 5.43k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 5.43k] | | | | ------------------ | | ------------------ ------------------ 152| 5.43k| WINPR_ASSERT(fmt); ------------------ | | 76| 5.43k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 5.43k| do \ | | | | 61| 5.43k| { \ | | | | 62| 5.43k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 5.43k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 5.43k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 5.43k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 5.43k| \ | | | | 70| 5.43k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 5.43k| do \ | | | | | | 32| 5.43k| { \ | | | | | | 33| 5.43k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 5.43k] | | | | | | ------------------ | | | | | | 34| 5.43k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 5.43k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 5.43k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 5.43k| \ | | | | 72| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 5.43k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 5.43k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 5.43k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 5.43k] | | | | ------------------ | | ------------------ ------------------ 153| 5.43k| WINPR_ASSERT(preplacelen); ------------------ | | 76| 5.43k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 5.43k| do \ | | | | 61| 5.43k| { \ | | | | 62| 5.43k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 5.43k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 5.43k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 5.43k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 5.43k| \ | | | | 70| 5.43k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 5.43k| do \ | | | | | | 32| 5.43k| { \ | | | | | | 33| 5.43k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 5.43k] | | | | | | ------------------ | | | | | | 34| 5.43k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 5.43k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 5.43k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 5.43k| \ | | | | 72| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 5.43k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 5.43k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 5.43k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 5.43k] | | | | ------------------ | | ------------------ ------------------ 154| 5.43k| WINPR_ASSERT(pskiplen); ------------------ | | 76| 5.43k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 5.43k| do \ | | | | 61| 5.43k| { \ | | | | 62| 5.43k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 5.43k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 5.43k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 5.43k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 5.43k| \ | | | | 70| 5.43k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 5.43k| do \ | | | | | | 32| 5.43k| { \ | | | | | | 33| 5.43k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 5.43k] | | | | | | ------------------ | | | | | | 34| 5.43k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 5.43k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 5.43k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 5.43k| \ | | | | 72| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 5.43k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 5.43k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 5.43k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 5.43k] | | | | ------------------ | | ------------------ ------------------ 155| | 156| 5.43k| *preplacelen = 0; 157| 5.43k| *pskiplen = 0; 158| | 159| 5.43k| const char* str = &fmt[opt->fmtlen]; /* Skip first %{ from string */ 160| 5.43k| const char* end = strstr(str, opt->replace); 161| 5.43k| if (!end) ------------------ | Branch (161:6): [True: 0, False: 5.43k] ------------------ 162| 0| return nullptr; 163| 5.43k| *pskiplen = WINPR_ASSERTING_INT_CAST(size_t, end - fmt) + opt->replacelen; ------------------ | | 180| 5.43k| __extension__({ \ | | 181| 5.43k| __typeof(ivar) var = ivar; \ | | 182| 5.43k| WINPR_ASSERT((var) == \ | | ------------------ | | | | 76| 5.43k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 5.43k| do \ | | | | | | 61| 5.43k| { \ | | | | | | 62| 5.43k| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 5.43k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 5.43k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 5.43k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 5.43k| \ | | | | | | 70| 5.43k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 5.43k| do \ | | | | | | | | 32| 5.43k| { \ | | | | | | | | 33| 5.43k| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 5.43k] | | | | | | | | ------------------ | | | | | | | | 34| 5.43k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 5.43k| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 5.43k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 5.43k| \ | | | | | | 72| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 5.43k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 5.43k| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 5.43k| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 5.43k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 183| 5.43k| WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \ | | 184| 5.43k| WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) || \ | | ------------------ | | | | 76| 5.43k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 5.43k| do \ | | | | | | 61| 5.43k| { \ | | | | | | 62| 5.43k| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 5.43k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 5.43k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 5.43k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 5.43k| \ | | | | | | 70| 5.43k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 5.43k| do \ | | | | | | | | 32| 5.43k| { \ | | | | | | | | 33| 16.3k| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:9): [True: 5.43k, False: 0] | | | | | | | | | Branch (33:9): [True: 5.43k, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 5.43k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 5.43k| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 5.43k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 5.43k| \ | | | | | | 72| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 5.43k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 5.43k| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 5.43k| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 5.43k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 185| 5.43k| (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0)); \ | | 186| 5.43k| WINPR_CXX_COMPAT_CAST(type, (var)); \ | | ------------------ | | | | 34| 5.43k|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ | | 187| 5.43k| }) ------------------ 164| | 165| 5.43k| if (!opt->arg.cpv) ------------------ | Branch (165:6): [True: 5.43k, False: 0] ------------------ 166| 5.43k| return nullptr; 167| | 168| 0| const size_t replacelen = WINPR_ASSERTING_INT_CAST(size_t, end - str); ------------------ | | 180| 0| __extension__({ \ | | 181| 0| __typeof(ivar) var = ivar; \ | | 182| 0| WINPR_ASSERT((var) == \ | | ------------------ | | | | 76| 0|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 0| do \ | | | | | | 61| 0| { \ | | | | | | 62| 0| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 0| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 0| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 0| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 0| \ | | | | | | 70| 0| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 0| do \ | | | | | | | | 32| 0| { \ | | | | | | | | 33| 0| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 0| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 0| \ | | | | | | 72| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 0| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 0| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 183| 0| WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \ | | 184| 0| WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) || \ | | ------------------ | | | | 76| 0|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 0| do \ | | | | | | 61| 0| { \ | | | | | | 62| 0| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 0| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 0| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 0| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 0| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 0| \ | | | | | | 70| 0| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 0| do \ | | | | | | | | 32| 0| { \ | | | | | | | | 33| 0| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 0| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 0| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 0] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 0| \ | | | | | | 72| 0| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 0| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 0| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 0| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 0] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 185| 0| (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0)); \ | | 186| 0| WINPR_CXX_COMPAT_CAST(type, (var)); \ | | ------------------ | | | | 34| 0|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ | | 187| 0| }) ------------------ 169| | 170| 0| char buffer[WLOG_MAX_PREFIX_SIZE] = WINPR_C_ARRAY_INIT; ------------------ | | 85| 0| { \ | | 86| 0| } /** @since version 3.24.0 */ ------------------ 171| 0| memcpy(buffer, str, MIN(replacelen, ARRAYSIZE(buffer) - 1)); ------------------ | | 42| 0|#define MIN(x, y) (((x) < (y)) ? (x) : (y)) | | ------------------ | | | Branch (42:20): [True: 0, False: 0] | | ------------------ ------------------ 172| | 173| 0| if (!replace_format_string(buffer, opt->recurse, opt->recurse->buffer, ------------------ | Branch (173:6): [True: 0, False: 0] ------------------ 174| 0| ARRAYSIZE(opt->recurse->buffer))) ------------------ | | 962| 0|#define ARRAYSIZE(A) RTL_NUMBER_OF_V2(A) | | ------------------ | | | | 958| 0|#define RTL_NUMBER_OF_V2(A) RTL_NUMBER_OF_V1(A) | | | | ------------------ | | | | | | 957| 0|#define RTL_NUMBER_OF_V1(A) (sizeof(A) / sizeof((A)[0])) | | | | ------------------ | | ------------------ ------------------ 175| 0| return nullptr; 176| | 177| 0| *preplacelen = strnlen(opt->recurse->buffer, ARRAYSIZE(opt->recurse->buffer)); ------------------ | | 962| 0|#define ARRAYSIZE(A) RTL_NUMBER_OF_V2(A) | | ------------------ | | | | 958| 0|#define RTL_NUMBER_OF_V2(A) RTL_NUMBER_OF_V1(A) | | | | ------------------ | | | | | | 957| 0|#define RTL_NUMBER_OF_V1(A) (sizeof(A) / sizeof((A)[0])) | | | | ------------------ | | ------------------ ------------------ 178| 0| return opt->recurse->buffer; 179| 0|} Layout.c:replace_format_string: 183| 5.43k|{ 184| 5.43k| WINPR_ASSERT(FormatString); ------------------ | | 76| 5.43k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 5.43k| do \ | | | | 61| 5.43k| { \ | | | | 62| 5.43k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 5.43k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 5.43k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 5.43k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 5.43k| \ | | | | 70| 5.43k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 5.43k| do \ | | | | | | 32| 5.43k| { \ | | | | | | 33| 5.43k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 5.43k] | | | | | | ------------------ | | | | | | 34| 5.43k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 5.43k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 5.43k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 5.43k| \ | | | | 72| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 5.43k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 5.43k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 5.43k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 5.43k] | | | | ------------------ | | ------------------ ------------------ 185| 5.43k| WINPR_ASSERT(recurse); ------------------ | | 76| 5.43k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 5.43k| do \ | | | | 61| 5.43k| { \ | | | | 62| 5.43k| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 5.43k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 5.43k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 5.43k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 5.43k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 5.43k| \ | | | | 70| 5.43k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 5.43k| do \ | | | | | | 32| 5.43k| { \ | | | | | | 33| 5.43k| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 5.43k] | | | | | | ------------------ | | | | | | 34| 5.43k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 5.43k| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 5.43k] | | | | | | ------------------ | | | | ------------------ | | | | 71| 5.43k| \ | | | | 72| 5.43k| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 5.43k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 5.43k| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 5.43k| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 5.43k] | | | | ------------------ | | ------------------ ------------------ 186| | 187| 5.43k| size_t index = 0; 188| 5.43k| const char* prefix = WLog_GetGlobalPrefix(); 189| 5.43k| if (prefix) ------------------ | Branch (189:6): [True: 0, False: 5.43k] ------------------ 190| 0| { 191| 0| const int res = _snprintf(format, formatlen, "{%s}", prefix); ------------------ | | 295| 0|#define _snprintf snprintf ------------------ 192| 0| if (res < 0) ------------------ | Branch (192:7): [True: 0, False: 0] ------------------ 193| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 194| 0| index = (size_t)res; 195| 0| } 196| | 197| 173k| while (*FormatString) ------------------ | Branch (197:9): [True: 168k, False: 5.43k] ------------------ 198| 168k| { 199| 168k| const struct format_option* opt = 200| 168k| bsearch(FormatString, recurse->options, recurse->nroptions, 201| 168k| sizeof(struct format_option), opt_compare_fn); 202| 168k| if (opt) ------------------ | Branch (202:7): [True: 54.3k, False: 114k] ------------------ 203| 54.3k| { 204| 54.3k| size_t replacelen = opt->replacelen; 205| 54.3k| size_t fmtlen = opt->fmtlen; 206| 54.3k| const char* replace = opt->replace; 207| 54.3k| const void* arg = opt->arg.cpv; 208| | 209| 54.3k| if (opt->ext) ------------------ | Branch (209:8): [True: 5.43k, False: 48.9k] ------------------ 210| 5.43k| replace = opt->ext(opt, FormatString, &replacelen, &fmtlen); 211| 54.3k| if (opt->fkt) ------------------ | Branch (211:8): [True: 5.43k, False: 48.9k] ------------------ 212| 5.43k| arg = opt->fkt(opt->arg.pv); 213| | 214| 54.3k| if (replace && (replacelen > 0)) ------------------ | Branch (214:8): [True: 48.9k, False: 5.43k] | Branch (214:19): [True: 48.9k, False: 0] ------------------ 215| 48.9k| { 216| 48.9k| WINPR_PRAGMA_DIAG_PUSH 217| 48.9k| WINPR_PRAGMA_DIAG_IGNORED_FORMAT_NONLITERAL 218| 48.9k| const int rc = _snprintf(&format[index], formatlen - index, replace, arg); ------------------ | | 295| 48.9k|#define _snprintf snprintf ------------------ 219| 48.9k| WINPR_PRAGMA_DIAG_POP 220| 48.9k| if (rc < 0) ------------------ | Branch (220:9): [True: 0, False: 48.9k] ------------------ 221| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 222| 48.9k| if (!check_and_log_format_size(format, formatlen, index, ------------------ | Branch (222:9): [True: 0, False: 48.9k] ------------------ 223| 48.9k| WINPR_ASSERTING_INT_CAST(size_t, rc))) ------------------ | | 180| 48.9k| __extension__({ \ | | 181| 48.9k| __typeof(ivar) var = ivar; \ | | 182| 48.9k| WINPR_ASSERT((var) == \ | | ------------------ | | | | 76| 48.9k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 48.9k| do \ | | | | | | 61| 48.9k| { \ | | | | | | 62| 48.9k| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 48.9k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 48.9k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 48.9k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 48.9k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 48.9k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 48.9k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 48.9k| \ | | | | | | 70| 48.9k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 48.9k| do \ | | | | | | | | 32| 48.9k| { \ | | | | | | | | 33| 48.9k| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 48.9k] | | | | | | | | ------------------ | | | | | | | | 34| 48.9k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 48.9k| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 48.9k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 48.9k| \ | | | | | | 72| 48.9k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 48.9k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 48.9k| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 48.9k| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 48.9k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 183| 48.9k| WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \ | | 184| 48.9k| WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) || \ | | ------------------ | | | | 76| 48.9k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 48.9k| do \ | | | | | | 61| 48.9k| { \ | | | | | | 62| 48.9k| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 48.9k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 48.9k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 48.9k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 48.9k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 48.9k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 48.9k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 48.9k| \ | | | | | | 70| 48.9k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 48.9k| do \ | | | | | | | | 32| 48.9k| { \ | | | | | | | | 33| 146k| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:9): [True: 48.9k, False: 0] | | | | | | | | | Branch (33:9): [True: 48.9k, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 48.9k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 48.9k| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 48.9k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 48.9k| \ | | | | | | 72| 48.9k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 48.9k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 48.9k| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 48.9k| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 48.9k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 185| 48.9k| (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0)); \ | | 186| 48.9k| WINPR_CXX_COMPAT_CAST(type, (var)); \ | | ------------------ | | | | 34| 48.9k|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ | | 187| 48.9k| }) ------------------ 224| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 225| 48.9k| index += WINPR_ASSERTING_INT_CAST(size_t, rc); ------------------ | | 180| 48.9k| __extension__({ \ | | 181| 48.9k| __typeof(ivar) var = ivar; \ | | 182| 48.9k| WINPR_ASSERT((var) == \ | | ------------------ | | | | 76| 48.9k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 48.9k| do \ | | | | | | 61| 48.9k| { \ | | | | | | 62| 48.9k| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 48.9k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 48.9k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 48.9k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 48.9k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 48.9k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 48.9k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 48.9k| \ | | | | | | 70| 48.9k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 48.9k| do \ | | | | | | | | 32| 48.9k| { \ | | | | | | | | 33| 48.9k| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:7): [True: 0, False: 48.9k] | | | | | | | | ------------------ | | | | | | | | 34| 48.9k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 48.9k| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 48.9k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 48.9k| \ | | | | | | 72| 48.9k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 48.9k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 48.9k| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 48.9k| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 48.9k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 183| 48.9k| WINPR_CXX_COMPAT_CAST(__typeof(var), WINPR_CXX_COMPAT_CAST(type, (var)))); \ | | 184| 48.9k| WINPR_ASSERT((((var) > 0) && (WINPR_CXX_COMPAT_CAST(type, (var)) > 0)) || \ | | ------------------ | | | | 76| 48.9k|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | | | ------------------ | | | | | | 60| 48.9k| do \ | | | | | | 61| 48.9k| { \ | | | | | | 62| 48.9k| WINPR_PRAGMA_DIAG_PUSH \ | | | | | | 63| 48.9k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | | | 64| 48.9k| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | | | 65| 48.9k| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | | | 66| 48.9k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 67| 48.9k| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | | | 68| 48.9k| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | | | 69| 48.9k| \ | | | | | | 70| 48.9k| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | | | ------------------ | | | | | | | | 31| 48.9k| do \ | | | | | | | | 32| 48.9k| { \ | | | | | | | | 33| 146k| if (!(cond)) \ | | | | | | | | ------------------ | | | | | | | | | Branch (33:9): [True: 48.9k, False: 0] | | | | | | | | | Branch (33:9): [True: 48.9k, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | | Branch (33:9): [True: 0, False: 0] | | | | | | | | ------------------ | | | | | | | | 34| 48.9k| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | | | 35| 48.9k| } while (0) | | | | | | | | ------------------ | | | | | | | | | Branch (35:11): [Folded, False: 48.9k] | | | | | | | | ------------------ | | | | | | ------------------ | | | | | | 71| 48.9k| \ | | | | | | 72| 48.9k| WINPR_DO_COVERITY_PRAGMA( \ | | | | | | 73| 48.9k| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | | | 74| 48.9k| WINPR_PRAGMA_DIAG_POP \ | | | | | | 75| 48.9k| } while (0) | | | | | | ------------------ | | | | | | | Branch (75:11): [Folded, False: 48.9k] | | | | | | ------------------ | | | | ------------------ | | ------------------ | | 185| 48.9k| (((var) <= 0) && WINPR_CXX_COMPAT_CAST(type, (var)) <= 0)); \ | | 186| 48.9k| WINPR_CXX_COMPAT_CAST(type, (var)); \ | | ------------------ | | | | 34| 48.9k|#define WINPR_CXX_COMPAT_CAST(t, val) ((t)(val)) | | ------------------ | | 187| 48.9k| }) ------------------ 226| 48.9k| } 227| 54.3k| FormatString += fmtlen; 228| 54.3k| } 229| 114k| else 230| 114k| { 231| | /* Unknown format string */ 232| 114k| if (*FormatString == '%') ------------------ | Branch (232:8): [True: 0, False: 114k] ------------------ 233| 0| return log_invalid_fmt(FormatString); 234| | 235| 114k| if (!check_and_log_format_size(format, formatlen, index, 1)) ------------------ | Branch (235:8): [True: 0, False: 114k] ------------------ 236| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 237| 114k| format[index++] = *FormatString++; 238| 114k| } 239| 168k| } 240| | 241| 5.43k| return check_and_log_format_size(format, formatlen, index, 0); 242| 5.43k|} Layout.c:opt_compare_fn: 137| 668k|{ 138| 668k| const char* what = a; 139| 668k| const struct format_option* opt = b; 140| 668k| if (!opt) ------------------ | Branch (140:6): [True: 0, False: 668k] ------------------ 141| 0| return -1; 142| 668k| return strncmp(what, opt->fmt, opt->fmtlen); 143| 668k|} Layout.c:check_and_log_format_size: 123| 168k|{ 124| | /* format string must be '\0' terminated, so abort at size - 1 */ 125| 168k| if (index + add + 1 >= size) ------------------ | Branch (125:6): [True: 0, False: 168k] ------------------ 126| 0| { 127| 0| (void)fprintf(stderr, 128| 0| "Format string too long ['%s', max %" PRIuz ", used %" PRIuz 129| 0| ", adding %" PRIuz "]\n", 130| 0| format, size, index, add); 131| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 132| 0| } 133| 168k| return TRUE; ------------------ | | 126| 168k|#define TRUE true ------------------ 134| 168k|} Layout.c:WLog_PrintMessagePrefix: 93| 5.43k|{ 94| 5.43k| va_list args = WINPR_C_ARRAY_INIT; ------------------ | | 85| 5.43k| { \ | | 86| 5.43k| } /** @since version 3.24.0 */ ------------------ 95| 5.43k| va_start(args, format); 96| 5.43k| WLog_PrintMessagePrefixVA(prefix, prefixlen, format, args); 97| | va_end(args); 98| 5.43k|} Layout.c:WLog_PrintMessagePrefixVA: 86| 5.43k|{ 87| 5.43k| (void)vsnprintf(prefix, prefixlen, format, args); 88| 5.43k|} WLog_PrintTextMessageVA: 420| 5.43k|{ 421| 5.43k| wLogMessage message = WINPR_C_ARRAY_INIT; ------------------ | | 85| 5.43k| { \ | | 86| 5.43k| } /** @since version 3.24.0 */ ------------------ 422| 5.43k| message.Type = WLOG_MESSAGE_TEXT; 423| 5.43k| message.Level = level; 424| 5.43k| message.LineNumber = line; 425| 5.43k| message.FileName = file; 426| 5.43k| message.FunctionName = function; 427| | 428| 5.43k| message.FormatString = fmt; 429| | 430| 5.43k| return WLog_PrintTextMessageInternal(log, &message, args); 431| 5.43k|} WLog_PrintTextMessage: 446| 4.89k|{ 447| 4.89k| BOOL status = 0; 448| 4.89k| va_list args = WINPR_C_ARRAY_INIT; ------------------ | | 85| 4.89k| { \ | | 86| 4.89k| } /** @since version 3.24.0 */ ------------------ 449| 4.89k| va_start(args, fmt); 450| 4.89k| status = WLog_PrintTextMessageVA(log, level, line, file, function, fmt, args); 451| | va_end(args); 452| 4.89k| return status; 453| 4.89k|} WLog_GetLogLevel: 456| 6.09k|{ 457| 6.09k| if (!log) ------------------ | Branch (457:6): [True: 0, False: 6.09k] ------------------ 458| 0| return WLOG_OFF; 459| | 460| 6.09k| if (log->FilterLevel <= WLOG_FILTER_NOT_INITIALIZED) ------------------ | | 53| 6.09k|#define WLOG_FILTER_NOT_INITIALIZED (-2) ------------------ | Branch (460:6): [True: 0, False: 6.09k] ------------------ 461| 0| log->FilterLevel = WLog_GetFilterLogLevel(log); 462| | 463| 6.09k| if (log->FilterLevel > WLOG_FILTER_NOT_FILTERED) ------------------ | | 52| 6.09k|#define WLOG_FILTER_NOT_FILTERED (-1) ------------------ | Branch (463:6): [True: 0, False: 6.09k] ------------------ 464| 0| return (DWORD)log->FilterLevel; 465| 6.09k| else if (log->Level == WLOG_LEVEL_INHERIT) ------------------ | Branch (465:11): [True: 2, False: 6.09k] ------------------ 466| 2| log->Level = WLog_GetLogLevel(log->Parent); 467| | 468| 6.09k| return log->Level; 469| 6.09k|} WLog_IsLevelActive: 472| 6.09k|{ 473| 6.09k| DWORD level = 0; 474| | 475| 6.09k| if (!_log) ------------------ | Branch (475:6): [True: 0, False: 6.09k] ------------------ 476| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 477| | 478| 6.09k| level = WLog_GetLogLevel(_log); 479| | 480| 6.09k| if (level == WLOG_OFF) ------------------ | Branch (480:6): [True: 0, False: 6.09k] ------------------ 481| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 482| | 483| 6.09k| return _log_level >= level; 484| 6.09k|} WLog_GetRoot: 954| 236|{ 955| 236| if (!InitOnceExecuteOnce(&g_WLogInitialized, WLog_InitializeRoot, nullptr, nullptr)) ------------------ | | 424| 236|#define InitOnceExecuteOnce winpr_InitOnceExecuteOnce ------------------ | Branch (955:6): [True: 0, False: 236] ------------------ 956| 0| return nullptr; 957| | 958| 236| return g_RootLog; 959| 236|} WLog_Get: 1053| 236|{ 1054| 236| wLog* root = WLog_GetRoot(); 1055| 236| return WLog_Get_int(root, name); 1056| 236|} WLog_GetGlobalPrefix: 1111| 5.43k|{ 1112| 5.43k| return g_GlobalPrefix; 1113| 5.43k|} wlog.c:WLog_PrintTextMessageInternal: 354| 5.43k|{ 355| 5.43k| assert(cmessage); ------------------ | Branch (355:2): [True: 0, False: 5.43k] | Branch (355:2): [True: 5.43k, False: 0] ------------------ 356| | 357| 5.43k| char formattedLogMessage[WLOG_MAX_STRING_SIZE] = WINPR_C_ARRAY_INIT; ------------------ | | 85| 5.43k| { \ | | 86| 5.43k| } /** @since version 3.24.0 */ ------------------ 358| 5.43k| wLogMessage message = *cmessage; 359| 5.43k| message.TextString = formattedLogMessage; 360| | 361| 5.43k| WINPR_PRAGMA_DIAG_PUSH 362| 5.43k| WINPR_PRAGMA_DIAG_IGNORED_FORMAT_NONLITERAL 363| 5.43k| if (vsnprintf(formattedLogMessage, ARRAYSIZE(formattedLogMessage) - 1, cmessage->FormatString, ------------------ | | 962| 5.43k|#define ARRAYSIZE(A) RTL_NUMBER_OF_V2(A) | | ------------------ | | | | 958| 5.43k|#define RTL_NUMBER_OF_V2(A) RTL_NUMBER_OF_V1(A) | | | | ------------------ | | | | | | 957| 5.43k|#define RTL_NUMBER_OF_V1(A) (sizeof(A) / sizeof((A)[0])) | | | | ------------------ | | ------------------ ------------------ | Branch (363:6): [True: 0, False: 5.43k] ------------------ 364| 5.43k| args) < 0) 365| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 366| 5.43k| WINPR_PRAGMA_DIAG_POP 367| | 368| 5.43k| return WLog_Write(log, &message); 369| 5.43k|} wlog.c:WLog_Write: 232| 5.43k|{ 233| 5.43k| BOOL status = FALSE; ------------------ | | 122| 5.43k|#define FALSE false ------------------ 234| 5.43k| wLogAppender* appender = WLog_GetLogAppender(log); 235| | 236| 5.43k| if (!appender) ------------------ | Branch (236:6): [True: 0, False: 5.43k] ------------------ 237| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 238| | 239| 5.43k| if (!appender->active) ------------------ | Branch (239:6): [True: 1, False: 5.43k] ------------------ 240| 1| if (!WLog_OpenAppender(log)) ------------------ | Branch (240:7): [True: 0, False: 1] ------------------ 241| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 242| | 243| 5.43k| EnterCriticalSection(&appender->lock); 244| | 245| 5.43k| if (appender->WriteMessage) ------------------ | Branch (245:6): [True: 5.43k, False: 0] ------------------ 246| 5.43k| { 247| 5.43k| if (appender->recursive) ------------------ | Branch (247:7): [True: 0, False: 5.43k] ------------------ 248| 0| status = log_recursion(message->FileName, message->FunctionName, message->LineNumber); 249| 5.43k| else 250| 5.43k| { 251| 5.43k| appender->recursive = TRUE; ------------------ | | 126| 5.43k|#define TRUE true ------------------ 252| 5.43k| status = appender->WriteMessage(log, appender, message); 253| 5.43k| appender->recursive = FALSE; ------------------ | | 122| 5.43k|#define FALSE false ------------------ 254| 5.43k| } 255| 5.43k| } 256| | 257| 5.43k| LeaveCriticalSection(&appender->lock); 258| 5.43k| return status; 259| 5.43k|} wlog.c:WLog_GetFilterLogLevel: 767| 3|{ 768| 3| BOOL match = FALSE; ------------------ | | 122| 3|#define FALSE false ------------------ 769| | 770| 3| if (log->FilterLevel >= 0) ------------------ | Branch (770:6): [True: 0, False: 3] ------------------ 771| 0| return log->FilterLevel; 772| | 773| 3| log->FilterLevel = WLOG_FILTER_NOT_FILTERED; ------------------ | | 52| 3|#define WLOG_FILTER_NOT_FILTERED (-1) ------------------ 774| 3| for (DWORD i = 0; i < g_FilterCount; i++) ------------------ | Branch (774:20): [True: 0, False: 3] ------------------ 775| 0| { 776| 0| const wLogFilter* filter = &g_Filters[i]; 777| 0| for (DWORD j = 0; j < filter->NameCount; j++) ------------------ | Branch (777:21): [True: 0, False: 0] ------------------ 778| 0| { 779| 0| if (j >= log->NameCount) ------------------ | Branch (779:8): [True: 0, False: 0] ------------------ 780| 0| break; 781| | 782| 0| if (_stricmp(filter->Names[j], "*") == 0) ------------------ | Branch (782:8): [True: 0, False: 0] ------------------ 783| 0| { 784| 0| match = TRUE; ------------------ | | 126| 0|#define TRUE true ------------------ 785| 0| assert(filter->Level <= INT32_MAX); ------------------ | Branch (785:5): [True: 0, False: 0] | Branch (785:5): [True: 0, False: 0] ------------------ 786| 0| log->FilterLevel = (LONG)filter->Level; 787| 0| break; 788| 0| } 789| | 790| 0| if (_stricmp(filter->Names[j], log->Names[j]) != 0) ------------------ | Branch (790:8): [True: 0, False: 0] ------------------ 791| 0| break; 792| | 793| 0| if (j == (log->NameCount - 1)) ------------------ | Branch (793:8): [True: 0, False: 0] ------------------ 794| 0| { 795| 0| match = log->NameCount == filter->NameCount; 796| 0| if (match) ------------------ | Branch (796:9): [True: 0, False: 0] ------------------ 797| 0| { 798| 0| assert(filter->Level <= INT32_MAX); ------------------ | Branch (798:6): [True: 0, False: 0] | Branch (798:6): [True: 0, False: 0] ------------------ 799| 0| log->FilterLevel = (LONG)filter->Level; 800| 0| } 801| 0| break; 802| 0| } 803| 0| } 804| | 805| 0| if (match) ------------------ | Branch (805:7): [True: 0, False: 0] ------------------ 806| 0| break; 807| 0| } 808| | 809| 3| return log->FilterLevel; 810| 3|} wlog.c:WLog_InitializeRoot: 113| 1|{ 114| 1| char* env = nullptr; 115| 1| DWORD nSize = 0; 116| 1| DWORD logAppenderType = 0; 117| 1| LPCSTR appender = "WLOG_APPENDER"; 118| | 119| 1| WINPR_UNUSED(InitOnce); ------------------ | | 758| 1|#define WINPR_UNUSED(x) (void)(x) ------------------ 120| 1| WINPR_UNUSED(Parameter); ------------------ | | 758| 1|#define WINPR_UNUSED(x) (void)(x) ------------------ 121| 1| WINPR_UNUSED(Context); ------------------ | | 758| 1|#define WINPR_UNUSED(x) (void)(x) ------------------ 122| | 123| 1| if (!(g_RootLog = WLog_New("", nullptr))) ------------------ | Branch (123:6): [True: 0, False: 1] ------------------ 124| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 125| | 126| 1| g_RootLog->IsRoot = TRUE; ------------------ | | 126| 1|#define TRUE true ------------------ 127| 1| logAppenderType = WLOG_APPENDER_CONSOLE; 128| 1| nSize = GetEnvironmentVariableA(appender, nullptr, 0); 129| | 130| 1| if (nSize) ------------------ | Branch (130:6): [True: 0, False: 1] ------------------ 131| 0| { 132| 0| env = (LPSTR)malloc(nSize); 133| | 134| 0| if (!env) ------------------ | Branch (134:7): [True: 0, False: 0] ------------------ 135| 0| goto fail; 136| | 137| 0| if (GetEnvironmentVariableA(appender, env, nSize) != nSize - 1) ------------------ | Branch (137:7): [True: 0, False: 0] ------------------ 138| 0| { 139| 0| (void)fprintf(stderr, "%s environment variable modified in my back", appender); 140| 0| free(env); 141| 0| goto fail; 142| 0| } 143| | 144| 0| if (_stricmp(env, "CONSOLE") == 0) ------------------ | Branch (144:7): [True: 0, False: 0] ------------------ 145| 0| logAppenderType = WLOG_APPENDER_CONSOLE; 146| 0| else if (_stricmp(env, "FILE") == 0) ------------------ | Branch (146:12): [True: 0, False: 0] ------------------ 147| 0| logAppenderType = WLOG_APPENDER_FILE; 148| 0| else if (_stricmp(env, "BINARY") == 0) ------------------ | Branch (148:12): [True: 0, False: 0] ------------------ 149| 0| logAppenderType = WLOG_APPENDER_BINARY; 150| | 151| 0|#ifdef WINPR_HAVE_SYSLOG_H 152| 0| else if (_stricmp(env, "SYSLOG") == 0) ------------------ | Branch (152:12): [True: 0, False: 0] ------------------ 153| 0| logAppenderType = WLOG_APPENDER_SYSLOG; 154| | 155| 0|#endif /* WINPR_HAVE_SYSLOG_H */ 156| |#ifdef WINPR_HAVE_JOURNALD_H 157| | else if (_stricmp(env, "JOURNALD") == 0) 158| | logAppenderType = WLOG_APPENDER_JOURNALD; 159| | 160| |#endif 161| 0| else if (_stricmp(env, "UDP") == 0) ------------------ | Branch (161:12): [True: 0, False: 0] ------------------ 162| 0| logAppenderType = WLOG_APPENDER_UDP; 163| | 164| 0| free(env); 165| 0| } 166| | 167| 1| if (!WLog_SetLogAppenderType(g_RootLog, logAppenderType)) ------------------ | Branch (167:6): [True: 0, False: 1] ------------------ 168| 0| goto fail; 169| | 170| 1| if (!WLog_ParseFilters(g_RootLog)) ------------------ | Branch (170:6): [True: 0, False: 1] ------------------ 171| 0| goto fail; 172| | 173| 1| (void)winpr_atexit(WLog_Uninit_); 174| | 175| 1| return TRUE; ------------------ | | 126| 1|#define TRUE true ------------------ 176| 0|fail: 177| 0| WLog_Uninit_(); 178| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 179| 1|} wlog.c:WLog_ParseFilters: 741| 1|{ 742| 1| LPCSTR filter = "WLOG_FILTER"; 743| 1| BOOL res = FALSE; ------------------ | | 122| 1|#define FALSE false ------------------ 744| 1| char* env = nullptr; 745| 1| DWORD nSize = 0; 746| 1| free(g_Filters); 747| 1| g_Filters = nullptr; 748| 1| g_FilterCount = 0; 749| 1| nSize = GetEnvironmentVariableA(filter, nullptr, 0); 750| | 751| 1| if (nSize < 1) ------------------ | Branch (751:6): [True: 1, False: 0] ------------------ 752| 1| return TRUE; ------------------ | | 126| 1|#define TRUE true ------------------ 753| | 754| 0| env = (LPSTR)malloc(nSize); 755| | 756| 0| if (!env) ------------------ | Branch (756:6): [True: 0, False: 0] ------------------ 757| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 758| | 759| 0| if (GetEnvironmentVariableA(filter, env, nSize) == nSize - 1) ------------------ | Branch (759:6): [True: 0, False: 0] ------------------ 760| 0| res = WLog_AddStringLogFilters_int(root, env); 761| | 762| 0| free(env); 763| 0| return res; 764| 0|} wlog.c:WLog_Uninit_: 81| 1|{ 82| 1| wLog* child = nullptr; 83| 1| wLog* root = g_RootLog; 84| | 85| 1| if (!root) ------------------ | Branch (85:6): [True: 0, False: 1] ------------------ 86| 0| return; 87| | 88| 3| for (DWORD index = 0; index < root->ChildrenCount; index++) ------------------ | Branch (88:24): [True: 2, False: 1] ------------------ 89| 2| { 90| 2| child = root->Children[index]; 91| 2| WLog_Free(child); 92| 2| } 93| | 94| 1| WLog_Free(root); 95| 1| g_RootLog = nullptr; 96| 1| free(g_GlobalPrefix); 97| 1| g_GlobalPrefix = nullptr; 98| 1|} wlog.c:WLog_Get_int: 1031| 236|{ 1032| 236| wLog* log = nullptr; 1033| | 1034| 236| if (!(log = WLog_FindChild(root, name))) ------------------ | Branch (1034:6): [True: 2, False: 234] ------------------ 1035| 2| { 1036| 2| if (!root) ------------------ | Branch (1036:7): [True: 0, False: 2] ------------------ 1037| 0| return nullptr; 1038| | 1039| 2| if (!(log = WLog_New(name, root))) ------------------ | Branch (1039:7): [True: 0, False: 2] ------------------ 1040| 0| return nullptr; 1041| | 1042| 2| if (!WLog_AddChild(root, log)) ------------------ | Branch (1042:7): [True: 0, False: 2] ------------------ 1043| 0| { 1044| 0| WLog_Free(log); 1045| 0| return nullptr; 1046| 0| } 1047| 2| } 1048| | 1049| 236| return log; 1050| 236|} wlog.c:WLog_FindChild: 1006| 236|{ 1007| 236| wLog* child = nullptr; 1008| | 1009| 236| if (!root) ------------------ | Branch (1009:6): [True: 0, False: 236] ------------------ 1010| 0| return nullptr; 1011| | 1012| 236| WLog_Lock(root); 1013| | 1014| 427| for (DWORD index = 0; index < root->ChildrenCount; index++) ------------------ | Branch (1014:24): [True: 425, False: 2] ------------------ 1015| 425| { 1016| 425| wLog* cchild = root->Children[index]; 1017| | 1018| 425| if (strcmp(cchild->Name, name) == 0) ------------------ | Branch (1018:7): [True: 234, False: 191] ------------------ 1019| 234| { 1020| 234| child = cchild; 1021| 234| break; 1022| 234| } 1023| 425| } 1024| | 1025| 236| WLog_Unlock(root); 1026| | 1027| 236| return child; 1028| 236|} wlog.c:WLog_Lock: 101| 238|{ 102| 238| WINPR_ASSERT(log); ------------------ | | 76| 238|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 238| do \ | | | | 61| 238| { \ | | | | 62| 238| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 238| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 238| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 238| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 238| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 238| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 238| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 238| \ | | | | 70| 238| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 238| do \ | | | | | | 32| 238| { \ | | | | | | 33| 238| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 238] | | | | | | ------------------ | | | | | | 34| 238| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 238| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 238] | | | | | | ------------------ | | | | ------------------ | | | | 71| 238| \ | | | | 72| 238| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 238| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 238| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 238| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 238] | | | | ------------------ | | ------------------ ------------------ 103| 238| EnterCriticalSection(&log->lock); 104| 238|} wlog.c:WLog_Unlock: 107| 238|{ 108| 238| WINPR_ASSERT(log); ------------------ | | 76| 238|#define WINPR_ASSERT(cond) WINPR_ASSERT_AT((cond), __FILE__, __func__, __LINE__) | | ------------------ | | | | 60| 238| do \ | | | | 61| 238| { \ | | | | 62| 238| WINPR_PRAGMA_DIAG_PUSH \ | | | | 63| 238| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARE \ | | | | 64| 238| WINPR_PRAGMA_DIAG_TAUTOLOGICAL_VALUE_RANGE_COMPARE \ | | | | 65| 238| WINPR_PRAGMA_DIAG_IGNORED_UNKNOWN_PRAGMAS \ | | | | 66| 238| WINPR_DO_COVERITY_PRAGMA( \ | | | | 67| 238| coverity compliance block deviate 'CONSTANT_EXPRESSION_RESULT' 'WINPR_ASSERT') \ | | | | 68| 238| WINPR_DO_COVERITY_PRAGMA(coverity compliance block deviate : 2 'NO_EFFECT' 'WINPR_ASSERT') \ | | | | 69| 238| \ | | | | 70| 238| winpr_internal_assert((cond), (file), (fkt), (line)); \ | | | | ------------------ | | | | | | 31| 238| do \ | | | | | | 32| 238| { \ | | | | | | 33| 238| if (!(cond)) \ | | | | | | ------------------ | | | | | | | Branch (33:7): [True: 0, False: 238] | | | | | | ------------------ | | | | | | 34| 238| winpr_int_assert(#cond, (file), (fkt), (line)); \ | | | | | | 35| 238| } while (0) | | | | | | ------------------ | | | | | | | Branch (35:11): [Folded, False: 238] | | | | | | ------------------ | | | | ------------------ | | | | 71| 238| \ | | | | 72| 238| WINPR_DO_COVERITY_PRAGMA( \ | | | | 73| 238| coverity compliance end_block 'CONSTANT_EXPRESSION_RESULT' 'NO_EFFECT') \ | | | | 74| 238| WINPR_PRAGMA_DIAG_POP \ | | | | 75| 238| } while (0) | | | | ------------------ | | | | | Branch (75:11): [Folded, False: 238] | | | | ------------------ | | ------------------ ------------------ 109| 238| LeaveCriticalSection(&log->lock); 110| 238|} wlog.c:WLog_AddChild: 962| 2|{ 963| 2| BOOL status = FALSE; ------------------ | | 122| 2|#define FALSE false ------------------ 964| | 965| 2| WLog_Lock(parent); 966| | 967| 2| if (parent->ChildrenCount >= parent->ChildrenSize) ------------------ | Branch (967:6): [True: 1, False: 1] ------------------ 968| 1| { 969| 1| parent->ChildrenSize = parent->ChildrenCount + 4; 970| | 971| 1| if (parent->ChildrenSize == 0) ------------------ | Branch (971:7): [True: 0, False: 1] ------------------ 972| 0| { 973| 0| free((void*)parent->Children); 974| 0| parent->Children = nullptr; 975| 0| } 976| 1| else 977| 1| { 978| 1| wLog** tmp = 979| 1| (wLog**)realloc((void*)parent->Children, sizeof(wLog*) * parent->ChildrenSize); 980| | 981| 1| if (!tmp) ------------------ | Branch (981:8): [True: 0, False: 1] ------------------ 982| 0| { 983| 0| free((void*)parent->Children); 984| 0| parent->Children = nullptr; 985| 0| goto exit; 986| 0| } 987| | 988| 1| parent->Children = tmp; 989| 1| } 990| 1| } 991| | 992| 2| if (!parent->Children) ------------------ | Branch (992:6): [True: 0, False: 2] ------------------ 993| 0| goto exit; 994| | 995| 2| parent->Children[parent->ChildrenCount++] = child; 996| 2| child->Parent = parent; 997| | 998| 2| WLog_Unlock(parent); 999| | 1000| 2| status = TRUE; ------------------ | | 126| 2|#define TRUE true ------------------ 1001| 2|exit: 1002| 2| return status; 1003| 2|} wlog.c:WLog_New: 857| 3|{ 858| 3| wLog* log = nullptr; 859| 3| char* env = nullptr; 860| 3| DWORD nSize = 0; 861| 3| int iLevel = 0; 862| 3| log = (wLog*)calloc(1, sizeof(wLog)); 863| | 864| 3| if (!log) ------------------ | Branch (864:6): [True: 0, False: 3] ------------------ 865| 0| return nullptr; 866| | 867| 3| log->Name = _strdup(name); 868| | 869| 3| if (!log->Name) ------------------ | Branch (869:6): [True: 0, False: 3] ------------------ 870| 0| goto out_fail; 871| | 872| 3| if (!WLog_ParseName(log, name)) ------------------ | Branch (872:6): [True: 0, False: 3] ------------------ 873| 0| goto out_fail; 874| | 875| 3| log->Parent = rootLogger; 876| 3| log->FilterLevel = WLOG_FILTER_NOT_INITIALIZED; ------------------ | | 53| 3|#define WLOG_FILTER_NOT_INITIALIZED (-2) ------------------ 877| | 878| 3| if (rootLogger) ------------------ | Branch (878:6): [True: 2, False: 1] ------------------ 879| 2| { 880| 2| log->Level = WLOG_LEVEL_INHERIT; 881| 2| log->inherit = TRUE; ------------------ | | 126| 2|#define TRUE true ------------------ 882| 2| } 883| 1| else 884| 1| { 885| 1| LPCSTR level = "WLOG_LEVEL"; 886| 1| log->Level = WLOG_INFO; 887| 1| nSize = GetEnvironmentVariableA(level, nullptr, 0); 888| | 889| 1| if (nSize) ------------------ | Branch (889:7): [True: 0, False: 1] ------------------ 890| 0| { 891| 0| env = (LPSTR)malloc(nSize); 892| | 893| 0| if (!env) ------------------ | Branch (893:8): [True: 0, False: 0] ------------------ 894| 0| goto out_fail; 895| | 896| 0| if (GetEnvironmentVariableA(level, env, nSize) != nSize - 1) ------------------ | Branch (896:8): [True: 0, False: 0] ------------------ 897| 0| { 898| 0| (void)fprintf(stderr, "%s environment variable changed in my back !\n", level); 899| 0| free(env); 900| 0| goto out_fail; 901| 0| } 902| | 903| 0| iLevel = WLog_ParseLogLevel(env); 904| 0| free(env); 905| | 906| 0| if (iLevel >= 0) ------------------ | Branch (906:8): [True: 0, False: 0] ------------------ 907| 0| { 908| 0| if (!WLog_SetLogLevel(log, (DWORD)iLevel)) ------------------ | Branch (908:9): [True: 0, False: 0] ------------------ 909| 0| goto out_fail; 910| 0| } 911| 0| } 912| 1| } 913| | 914| 3| iLevel = WLog_GetFilterLogLevel(log); 915| | 916| 3| if (iLevel >= 0) ------------------ | Branch (916:6): [True: 0, False: 3] ------------------ 917| 0| { 918| 0| if (!WLog_SetLogLevel(log, (DWORD)iLevel)) ------------------ | Branch (918:7): [True: 0, False: 0] ------------------ 919| 0| goto out_fail; 920| 0| } 921| | 922| 3| if (!InitializeCriticalSectionAndSpinCount(&log->lock, 4000)) ------------------ | Branch (922:6): [True: 0, False: 3] ------------------ 923| 0| goto out_fail; 924| | 925| 3| return log; 926| 0|out_fail: 927| 0| WLog_Free(log); 928| 0| return nullptr; 929| 3|} wlog.c:WLog_ParseName: 813| 3|{ 814| 3| const char* cp = name; 815| 3| char* p = nullptr; 816| 3| size_t count = 1; 817| 3| LPSTR names = nullptr; 818| | 819| 8| while ((cp = strchr(cp, '.')) != nullptr) ------------------ | Branch (819:9): [True: 5, False: 3] ------------------ 820| 5| { 821| 5| count++; 822| 5| cp++; 823| 5| } 824| | 825| 3| names = _strdup(name); 826| | 827| 3| if (!names) ------------------ | Branch (827:6): [True: 0, False: 3] ------------------ 828| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 829| | 830| 3| log->NameCount = count; 831| 3| log->Names = (LPSTR*)calloc((count + 1UL), sizeof(LPSTR)); 832| | 833| 3| if (!log->Names) ------------------ | Branch (833:6): [True: 0, False: 3] ------------------ 834| 0| { 835| 0| free(names); 836| 0| return FALSE; ------------------ | | 122| 0|#define FALSE false ------------------ 837| 0| } 838| | 839| 3| log->Names[count] = nullptr; 840| 3| count = 0; 841| 3| p = (char*)names; 842| 3| log->Names[count++] = p; 843| | 844| 8| while ((p = strchr(p, '.')) != nullptr) ------------------ | Branch (844:9): [True: 5, False: 3] ------------------ 845| 5| { 846| 5| if (count < log->NameCount) ------------------ | Branch (846:7): [True: 5, False: 0] ------------------ 847| 5| log->Names[count++] = p + 1; 848| | 849| 5| *p = '\0'; 850| 5| p++; 851| 5| } 852| | 853| 3| return TRUE; ------------------ | | 126| 3|#define TRUE true ------------------ 854| 3|} wlog.c:WLog_Free: 932| 3|{ 933| 3| if (log) ------------------ | Branch (933:6): [True: 3, False: 0] ------------------ 934| 3| { 935| 3| if (log->Appender) ------------------ | Branch (935:7): [True: 1, False: 2] ------------------ 936| 1| { 937| 1| WLog_Appender_Free(log, log->Appender); 938| 1| log->Appender = nullptr; 939| 1| } 940| | 941| 3| free(log->Name); 942| | 943| | /* The first element in this array is allocated, the rest are indices into this variable */ 944| 3| if (log->Names) ------------------ | Branch (944:7): [True: 3, False: 0] ------------------ 945| 3| free(log->Names[0]); 946| 3| free((void*)log->Names); 947| 3| free((void*)log->Children); 948| 3| DeleteCriticalSection(&log->lock); 949| 3| free(log); 950| 3| } 951| 3|}