mirrors/zint-barcode-generator
1
0
Fork 0
mirror of https://git.code.sf.net/p/zint/code synced 2025-05-30 06:45:28 -04:00
Code Issues Projects Releases Packages Wiki Activity

general: cmake: add ZINT_SANITIZEM (clang -fsanitize=memory) option

Browse source 
and suppress errors in lib and backend tests (pretty sure they're
  nearly all false positives apart from maybe 2 non-initializations
  in "gif.c" (`pOut` buffer) and "raster.c" (`rotated_pixbuf`)
github: install de_DE.UTF-8 locale in ubuntu-debug also
This commit is contained in:
gitlost 2025-02-19 01:15:58 +00:00
parent 33135fc146
commit c7cf006e71
38 changed files with 177 additions and 129 deletions

4
.github/workflows/ci.yml vendored
View file

@ -65,6 +65,10 @@ jobs:
- name: Install libpng-dev - name: Install libpng-dev
run: sudo apt-get install libpng-dev run: sudo apt-get install libpng-dev
- name: Install locale
shell: bash
run: sudo locale-gen de_DE.UTF-8 && sudo update-locale
- name: Create Build Environment - name: Create Build Environment
run: cmake -E make_directory ${{runner.workspace}}/build run: cmake -E make_directory ${{runner.workspace}}/build

3
CMakeLists.txt
View file

@ -17,7 +17,8 @@ add_definitions(-DZINT_VERSION=\"${ZINT_VERSION}\")
option(ZINT_DEBUG "Set debug compile flags" OFF) option(ZINT_DEBUG "Set debug compile flags" OFF)
option(ZINT_NOOPT "Set no optimize compile flags" OFF) option(ZINT_NOOPT "Set no optimize compile flags" OFF)
option(ZINT_SANITIZE "Set sanitize compile/link flags" OFF) option(ZINT_SANITIZE "Set sanitize address/undefined" OFF)
option(ZINT_SANITIZEM "Set sanitize memory (ignored if ZINT_SANITIZE)" OFF)
option(ZINT_TEST "Set test compile flag" OFF) option(ZINT_TEST "Set test compile flag" OFF)
option(ZINT_COVERAGE "Set code coverage flags" OFF) option(ZINT_COVERAGE "Set code coverage flags" OFF)
option(ZINT_SHARED "Build shared library" ON) option(ZINT_SHARED "Build shared library" ON)

31
README.linux
View file

@ -1,4 +1,4 @@
% README.linux 2025-02-02 % README.linux 2025-02-19
% Tested on Ubuntu 20.04.4 LTS, Ubuntu 22.04 LTS, Ubuntu 24.04 LTS and % Tested on Ubuntu 20.04.4 LTS, Ubuntu 22.04 LTS, Ubuntu 24.04 LTS and
% Fedora Linux 41 (Workstation Edition) % Fedora Linux 41 (Workstation Edition)
@ -122,21 +122,26 @@ On Fedora you may have to set LD_LIBRARY_PATH for zint ("libzint.so") and zint-q
A number of options are available: A number of options are available:
ZINT_COVERAGE:BOOL=OFF # Set code coverage flags ZINT_COVERAGE:BOOL=OFF # Set code coverage flags
ZINT_DEBUG:BOOL=OFF # Set debug compile flags ZINT_DEBUG:BOOL=OFF # Set debug compile flags
ZINT_FRONTEND:BOOL=ON # Build frontend ZINT_FRONTEND:BOOL=ON # Build frontend
ZINT_NOOPT:BOOL=OFF # Set no optimize compile flags ZINT_NOOPT:BOOL=OFF # Set no optimize compile flags
ZINT_SANITIZE:BOOL=OFF # Set sanitize compile/link flags ZINT_SANITIZE:BOOL=OFF # Set sanitize compile/link flags
ZINT_SHARED:BOOL=ON # Build shared library ZINT_SANITIZE:BOOL=OFF # Set sanitize address/undefined
ZINT_STATIC:BOOL=OFF # Build static library ZINT_SANITIZEM:BOOL=OFF # Set sanitize memory (ignored if ZINT_SANITIZE)
ZINT_TEST:BOOL=OFF # Set test compile flag ZINT_SHARED:BOOL=ON # Build shared library
ZINT_UNINSTALL:BOOL=ON # Add uninstall target ZINT_STATIC:BOOL=OFF # Build static library
ZINT_USE_PNG:BOOL=ON # Build with PNG support ZINT_TEST:BOOL=OFF # Set test compile flag
ZINT_USE_QT:BOOL=ON # Build with Qt support ZINT_UNINSTALL:BOOL=ON # Add uninstall target
ZINT_QT6:BOOL=OFF # If ZINT_USE_QT, use Qt6 ZINT_USE_PNG:BOOL=ON # Build with PNG support
ZINT_USE_QT:BOOL=ON # Build with Qt support
ZINT_QT6:BOOL=OFF # If ZINT_USE_QT, use Qt6
which can be set by doing e.g. which can be set by doing e.g.
cmake -DZINT_SANITIZE=ON .. cmake -DZINT_SANITIZE=ON ..
Note that ZINT_SANITIZEM (Clang only) is incompatible with ZINT_SANITIZE, and also with
ZINT_USE_PNG, unless libpng has also been instrumented with -fsanitize=memory.
For details on ZINT_TEST and building the zint test suite, see "backend/tests/README". For details on ZINT_TEST and building the zint test suite, see "backend/tests/README".

7
backend/CMakeLists.txt
View file

@ -88,6 +88,13 @@ else()
message(STATUS "Not using PNG") message(STATUS "Not using PNG")
endif() endif()
# Incompatible with ZINT_SANITIZE (and also with ZINT_USE_PNG unless libpng instrumented)
if(NOT ZINT_SANITIZE AND ZINT_SANITIZEM AND CMAKE_C_COMPILER_ID MATCHES "Clang")
add_compile_options(-fsanitize=memory -fsanitize-memory-track-origins -fno-omit-frame-pointer -O2)
link_libraries(-fsanitize=memory)
zint_target_compile_definitions(PRIVATE ZINT_SANITIZEM)
endif()
if(ZINT_TEST) if(ZINT_TEST)
zint_target_compile_definitions(PUBLIC ZINT_TEST) zint_target_compile_definitions(PUBLIC ZINT_TEST)
endif() endif()

6
backend/filemem.c
View file

@ -108,6 +108,9 @@ INTERNAL int fm_open(struct filemem *restrict const fmp, struct zint_symbol *sym
if (!(fmp->mem = (unsigned char *) malloc(FM_PAGE_SIZE))) { if (!(fmp->mem = (unsigned char *) malloc(FM_PAGE_SIZE))) {
return fm_seterr(fmp, ENOMEM); return fm_seterr(fmp, ENOMEM);
} }
#ifdef ZINT_SANITIZEM /* Suppress clang -fsanitize=memory false positive */
memset(fmp->mem, 0, FM_PAGE_SIZE);
#endif
fmp->memsize = FM_PAGE_SIZE; fmp->memsize = FM_PAGE_SIZE;
if (symbol->memfile) { if (symbol->memfile) {
free(symbol->memfile); free(symbol->memfile);
@ -160,6 +163,9 @@ static int fm_mem_expand(struct filemem *restrict const fmp, const size_t size)
fm_clear_mem(fmp); fm_clear_mem(fmp);
return fm_seterr(fmp, new_size > 0x40000000 ? EINVAL : ENOMEM); return fm_seterr(fmp, new_size > 0x40000000 ? EINVAL : ENOMEM);
} }
#ifdef ZINT_SANITIZEM /* Suppress clang -fsanitize=memory false positive */
memset(new_mem + fmp->memsize, 0, new_size - fmp->memsize);
#endif
fmp->mem = new_mem; fmp->mem = new_mem;
fmp->memsize = new_size; fmp->memsize = new_size;
return 1; return 1;

2
backend/gif.c
View file

@ -268,7 +268,7 @@ INTERNAL int gif_pixel_plot(struct zint_symbol *symbol, unsigned char *pixelbuf)
if (State.fOutPaged) { if (State.fOutPaged) {
State.OutLength = GIF_LZW_PAGE_SIZE; State.OutLength = GIF_LZW_PAGE_SIZE;
} }
if (!(State.pOut = (unsigned char *) malloc(State.OutLength))) { if (!(State.pOut = (unsigned char *) calloc(1, State.OutLength))) {
return errtxt(ZINT_ERROR_MEMORY, symbol, 614, "Insufficient memory for GIF LZW buffer"); return errtxt(ZINT_ERROR_MEMORY, symbol, 614, "Insufficient memory for GIF LZW buffer");
} }

8
backend/raster.c
View file

@ -115,6 +115,9 @@ static int buffer_plot(struct zint_symbol *symbol, const unsigned char *pixelbuf
if (!(symbol->bitmap = (unsigned char *) raster_malloc(bm_bitmap_size, 0 /*prev_size*/))) { if (!(symbol->bitmap = (unsigned char *) raster_malloc(bm_bitmap_size, 0 /*prev_size*/))) {
return errtxt(ZINT_ERROR_MEMORY, symbol, 661, "Insufficient memory for bitmap buffer"); return errtxt(ZINT_ERROR_MEMORY, symbol, 661, "Insufficient memory for bitmap buffer");
} }
#ifdef ZINT_SANITIZEM /* Suppress clang -fsanitize=memory false positive */
memset(symbol->bitmap, 0, bm_bitmap_size);
#endif
if (plot_alpha) { if (plot_alpha) {
const size_t alpha_size = (size_t) symbol->bitmap_width * symbol->bitmap_height; const size_t alpha_size = (size_t) symbol->bitmap_width * symbol->bitmap_height;
@ -178,10 +181,11 @@ static int save_raster_image_to_file(struct zint_symbol *symbol, const int image
} }
if (rotate_angle) { if (rotate_angle) {
if (!(rotated_pixbuf = (unsigned char *) raster_malloc((size_t) image_width * image_height, size_t image_size = (size_t) image_width * image_height;
0 /*prev_size*/))) { if (!(rotated_pixbuf = (unsigned char *) raster_malloc((size_t) image_size, 0 /*prev_size*/))) {
return errtxt(ZINT_ERROR_MEMORY, symbol, 650, "Insufficient memory for pixel buffer"); return errtxt(ZINT_ERROR_MEMORY, symbol, 650, "Insufficient memory for pixel buffer");
} }
memset(rotated_pixbuf, DEFAULT_PAPER, image_size);
} }
/* Rotate image before plotting */ /* Rotate image before plotting */

84
backend/tests/test_2of5.c
View file

@ -77,7 +77,7 @@ static void test_large(const testCtx *const p_ctx) {
int i, length, ret; int i, length, ret;
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
char data_buf[4096]; char data_buf[4096] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStartSymbol("test_large", &symbol); testStartSymbol("test_large", &symbol);
@ -128,47 +128,47 @@ static void test_hrt(const testCtx *const p_ctx) {
/* 4*/ { BARCODE_C25STANDARD, 2, -1, "123456789", "123456789" }, /* Suppresses printing of check digit */ /* 4*/ { BARCODE_C25STANDARD, 2, -1, "123456789", "123456789" }, /* Suppresses printing of check digit */
/* 5*/ { BARCODE_C25STANDARD, 2, BARCODE_PLAIN_HRT, "123456789", "1234567895" }, /* Unless plain HRT */ /* 5*/ { BARCODE_C25STANDARD, 2, BARCODE_PLAIN_HRT, "123456789", "1234567895" }, /* Unless plain HRT */
/* 6*/ { BARCODE_C25INTER, -1, -1, "123456789", "0123456789" }, /* Adds leading zero if odd */ /* 6*/ { BARCODE_C25INTER, -1, -1, "123456789", "0123456789" }, /* Adds leading zero if odd */
/* 6*/ { BARCODE_C25INTER, -1, BARCODE_PLAIN_HRT, "123456789", "0123456789" }, /* 7*/ { BARCODE_C25INTER, -1, BARCODE_PLAIN_HRT, "123456789", "0123456789" },
/* 7*/ { BARCODE_C25INTER, 1, -1, "123456789", "1234567895" }, /* Unless check digit added when it becomes even */ /* 8*/ { BARCODE_C25INTER, 1, -1, "123456789", "1234567895" }, /* Unless check digit added when it becomes even */
/* 8*/ { BARCODE_C25INTER, 1, BARCODE_PLAIN_HRT, "123456789", "1234567895" }, /* 9*/ { BARCODE_C25INTER, 1, BARCODE_PLAIN_HRT, "123456789", "1234567895" },
/* 9*/ { BARCODE_C25INTER, 2, -1, "123456789", "123456789" }, /* 10*/ { BARCODE_C25INTER, 2, -1, "123456789", "123456789" },
/* 10*/ { BARCODE_C25INTER, 2, BARCODE_PLAIN_HRT, "123456789", "1234567895" }, /* 11*/ { BARCODE_C25INTER, 2, BARCODE_PLAIN_HRT, "123456789", "1234567895" },
/* 11*/ { BARCODE_C25INTER, -1, -1, "1234567890", "1234567890" }, /* No leading zero if even */ /* 12*/ { BARCODE_C25INTER, -1, -1, "1234567890", "1234567890" }, /* No leading zero if even */
/* 12*/ { BARCODE_C25INTER, -1, BARCODE_PLAIN_HRT, "1234567890", "1234567890" }, /* 13*/ { BARCODE_C25INTER, -1, BARCODE_PLAIN_HRT, "1234567890", "1234567890" },
/* 13*/ { BARCODE_C25INTER, 1, -1, "1234567890", "012345678905" }, /* Unless check digit added when it becomes odd */ /* 14*/ { BARCODE_C25INTER, 1, -1, "1234567890", "012345678905" }, /* Unless check digit added when it becomes odd */
/* 14*/ { BARCODE_C25INTER, 1, BARCODE_PLAIN_HRT, "1234567890", "012345678905" }, /* 15*/ { BARCODE_C25INTER, 1, BARCODE_PLAIN_HRT, "1234567890", "012345678905" },
/* 15*/ { BARCODE_C25INTER, 2, -1, "1234567890", "01234567890" }, /* 16*/ { BARCODE_C25INTER, 2, -1, "1234567890", "01234567890" },
/* 16*/ { BARCODE_C25INTER, 2, BARCODE_PLAIN_HRT, "1234567890", "012345678905" }, /* 17*/ { BARCODE_C25INTER, 2, BARCODE_PLAIN_HRT, "1234567890", "012345678905" },
/* 17*/ { BARCODE_C25IATA, -1, -1, "123456789", "123456789" }, /* 18*/ { BARCODE_C25IATA, -1, -1, "123456789", "123456789" },
/* 18*/ { BARCODE_C25IATA, -1, BARCODE_PLAIN_HRT, "123456789", "123456789" }, /* 19*/ { BARCODE_C25IATA, -1, BARCODE_PLAIN_HRT, "123456789", "123456789" },
/* 19*/ { BARCODE_C25IATA, 1, -1, "123456789", "1234567895" }, /* 20*/ { BARCODE_C25IATA, 1, -1, "123456789", "1234567895" },
/* 20*/ { BARCODE_C25IATA, 1, BARCODE_PLAIN_HRT, "123456789", "1234567895" }, /* 21*/ { BARCODE_C25IATA, 1, BARCODE_PLAIN_HRT, "123456789", "1234567895" },
/* 21*/ { BARCODE_C25IATA, 2, -1, "123456789", "123456789" }, /* 22*/ { BARCODE_C25IATA, 2, -1, "123456789", "123456789" },
/* 22*/ { BARCODE_C25IATA, 2, BARCODE_PLAIN_HRT, "123456789", "1234567895" }, /* 23*/ { BARCODE_C25IATA, 2, BARCODE_PLAIN_HRT, "123456789", "1234567895" },
/* 23*/ { BARCODE_C25LOGIC, -1, -1, "123456789", "123456789" }, /* 24*/ { BARCODE_C25LOGIC, -1, -1, "123456789", "123456789" },
/* 24*/ { BARCODE_C25LOGIC, -1, BARCODE_PLAIN_HRT, "123456789", "123456789" }, /* 25*/ { BARCODE_C25LOGIC, -1, BARCODE_PLAIN_HRT, "123456789", "123456789" },
/* 25*/ { BARCODE_C25LOGIC, 1, -1, "123456789", "1234567895" }, /* 26*/ { BARCODE_C25LOGIC, 1, -1, "123456789", "1234567895" },
/* 26*/ { BARCODE_C25LOGIC, 1, BARCODE_PLAIN_HRT, "123456789", "1234567895" }, /* 27*/ { BARCODE_C25LOGIC, 1, BARCODE_PLAIN_HRT, "123456789", "1234567895" },
/* 27*/ { BARCODE_C25LOGIC, 2, -1, "123456789", "123456789" }, /* 28*/ { BARCODE_C25LOGIC, 2, -1, "123456789", "123456789" },
/* 28*/ { BARCODE_C25LOGIC, 2, BARCODE_PLAIN_HRT, "123456789", "1234567895" }, /* 29*/ { BARCODE_C25LOGIC, 2, BARCODE_PLAIN_HRT, "123456789", "1234567895" },
/* 29*/ { BARCODE_C25IND, -1, -1, "123456789", "123456789" }, /* 30*/ { BARCODE_C25IND, -1, -1, "123456789", "123456789" },
/* 30*/ { BARCODE_C25IND, -1, BARCODE_PLAIN_HRT, "123456789", "123456789" }, /* 31*/ { BARCODE_C25IND, -1, BARCODE_PLAIN_HRT, "123456789", "123456789" },
/* 31*/ { BARCODE_C25IND, 1, -1, "123456789", "1234567895" }, /* 32*/ { BARCODE_C25IND, 1, -1, "123456789", "1234567895" },
/* 32*/ { BARCODE_C25IND, 1, BARCODE_PLAIN_HRT, "123456789", "1234567895" }, /* 33*/ { BARCODE_C25IND, 1, BARCODE_PLAIN_HRT, "123456789", "1234567895" },
/* 33*/ { BARCODE_C25IND, 2, -1, "123456789", "123456789" }, /* 34*/ { BARCODE_C25IND, 2, -1, "123456789", "123456789" },
/* 34*/ { BARCODE_C25IND, 2, BARCODE_PLAIN_HRT, "123456789", "1234567895" }, /* 35*/ { BARCODE_C25IND, 2, BARCODE_PLAIN_HRT, "123456789", "1234567895" },
/* 35*/ { BARCODE_DPLEIT, -1, -1, "123456789", "00001.234.567.890" }, /* Leading zeroes added to make 13 + appended checksum */ /* 36*/ { BARCODE_DPLEIT, -1, -1, "123456789", "00001.234.567.890" }, /* Leading zeroes added to make 13 + appended checksum */
/* 36*/ { BARCODE_DPLEIT, -1, BARCODE_PLAIN_HRT, "123456789", "00001234567890" }, /* 37*/ { BARCODE_DPLEIT, -1, BARCODE_PLAIN_HRT, "123456789", "00001234567890" },
/* 37*/ { BARCODE_DPLEIT, -1, -1, "1234567890123", "12345.678.901.236" }, /* 38*/ { BARCODE_DPLEIT, -1, -1, "1234567890123", "12345.678.901.236" },
/* 38*/ { BARCODE_DPLEIT, -1, BARCODE_PLAIN_HRT, "1234567890123", "12345678901236" }, /* 39*/ { BARCODE_DPLEIT, -1, BARCODE_PLAIN_HRT, "1234567890123", "12345678901236" },
/* 39*/ { BARCODE_DPIDENT, -1, -1, "123456789", "00.12 3.456.789 0" }, /* Leading zeroes added to make 11 + appended checksum */ /* 40*/ { BARCODE_DPIDENT, -1, -1, "123456789", "00.12 3.456.789 0" }, /* Leading zeroes added to make 11 + appended checksum */
/* 40*/ { BARCODE_DPIDENT, -1, BARCODE_PLAIN_HRT, "123456789", "001234567890" }, /* 41*/ { BARCODE_DPIDENT, -1, BARCODE_PLAIN_HRT, "123456789", "001234567890" },
/* 41*/ { BARCODE_DPIDENT, -1, -1, "12345678901", "12.34 5.678.901 6" }, /* 42*/ { BARCODE_DPIDENT, -1, -1, "12345678901", "12.34 5.678.901 6" },
/* 42*/ { BARCODE_DPIDENT, -1, BARCODE_PLAIN_HRT, "12345678901", "123456789016" }, /* 43*/ { BARCODE_DPIDENT, -1, BARCODE_PLAIN_HRT, "12345678901", "123456789016" },
/* 43*/ { BARCODE_ITF14, -1, -1, "123456789", "00001234567895" }, /* Leading zeroes added to make 13 + appended checksum */ /* 44*/ { BARCODE_ITF14, -1, -1, "123456789", "00001234567895" }, /* Leading zeroes added to make 13 + appended checksum */
/* 44*/ { BARCODE_ITF14, -1, BARCODE_PLAIN_HRT, "123456789", "00001234567895" }, /* 45*/ { BARCODE_ITF14, -1, BARCODE_PLAIN_HRT, "123456789", "00001234567895" },
/* 45*/ { BARCODE_ITF14, -1, -1, "1234567890123", "12345678901231" }, /* 46*/ { BARCODE_ITF14, -1, -1, "1234567890123", "12345678901231" },
/* 46*/ { BARCODE_ITF14, -1, BARCODE_PLAIN_HRT, "1234567890123", "12345678901231" }, /* 47*/ { BARCODE_ITF14, -1, BARCODE_PLAIN_HRT, "1234567890123", "12345678901231" },
}; };
const int data_size = ARRAY_SIZE(data); const int data_size = ARRAY_SIZE(data);
int i, length, ret; int i, length, ret;

4
backend/tests/test_big5.c
View file

@ -43,7 +43,7 @@ INTERNAL int u_big5_test(const unsigned int u, unsigned char *dest);
/* Version of `u_big5()` taking unsigned int destination for backward-compatible testing */ /* Version of `u_big5()` taking unsigned int destination for backward-compatible testing */
static int u_big5_int(unsigned int u, unsigned int *d) { static int u_big5_int(unsigned int u, unsigned int *d) {
unsigned char dest[2]; unsigned char dest[2] = {0}; /* Suppress clang -fsanitize=memory false positive */
int ret = u_big5_test(u, dest); int ret = u_big5_test(u, dest);
if (ret) { if (ret) {
*d = ret == 1 ? dest[0] : ((dest[0] << 8) | dest[1]); *d = ret == 1 ? dest[0] : ((dest[0] << 8) | dest[1]);
@ -157,6 +157,8 @@ static int big5_utf8(struct zint_symbol *symbol, const unsigned char source[], i
unsigned int i, length; unsigned int i, length;
unsigned int *utfdata = (unsigned int *) z_alloca(sizeof(unsigned int) * (*p_length + 1)); unsigned int *utfdata = (unsigned int *) z_alloca(sizeof(unsigned int) * (*p_length + 1));
memset(utfdata, 0, sizeof(unsigned int) * (*p_length + 1)); /* Suppress clang -fsanitize=memory false positive */
error_number = utf8_to_unicode(symbol, source, utfdata, p_length, 0 /*disallow_4byte*/); error_number = utf8_to_unicode(symbol, source, utfdata, p_length, 0 /*disallow_4byte*/);
if (error_number != 0) { if (error_number != 0) {
return error_number; return error_number;

2
backend/tests/test_bmp.c
View file

@ -155,7 +155,7 @@ static void test_print(const testCtx *const p_ctx) {
char expected_file[4096]; char expected_file[4096];
char escaped[1024]; char escaped[1024];
int escaped_size = 1024; int escaped_size = 1024;
unsigned char filebuf[32768]; unsigned char filebuf[32768] = {0}; /* Suppress clang -fsanitize=memory false positive */
int filebuf_size; int filebuf_size;
const char *const have_identify = testUtilHaveIdentify(); const char *const have_identify = testUtilHaveIdentify();

2
backend/tests/test_code11.c
View file

@ -55,7 +55,7 @@ static void test_large(const testCtx *const p_ctx) {
int i, length, ret; int i, length, ret;
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
char data_buf[4096]; char data_buf[4096] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStartSymbol("test_large", &symbol); testStartSymbol("test_large", &symbol);

2
backend/tests/test_code128.c
View file

@ -103,7 +103,7 @@ static void test_large(const testCtx *const p_ctx) {
char escaped2[1024]; char escaped2[1024];
char cmp_buf[8192]; char cmp_buf[8192];
char cmp_msg[1024]; char cmp_msg[1024];
char ret_buf[8192]; char ret_buf[8192] = {0}; /* Suppress clang -fsanitize=memory false positive */
int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */ int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */
int do_zxingcpp = (debug & ZINT_DEBUG_TEST_ZXINGCPP) && testUtilHaveZXingCPPDecoder(); /* Only do ZXing-C++ test if asked, too slow otherwise */ int do_zxingcpp = (debug & ZINT_DEBUG_TEST_ZXINGCPP) && testUtilHaveZXingCPPDecoder(); /* Only do ZXing-C++ test if asked, too slow otherwise */

4
backend/tests/test_common.c
View file

@ -342,7 +342,7 @@ static void test_not_sane_lookup(const testCtx *const p_ctx) {
const int data_size = ARRAY_SIZE(data); const int data_size = ARRAY_SIZE(data);
int i, length, ret; int i, length, ret;
int test_length; int test_length;
int posns[32]; int posns[32] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStart("test_not_sane_lookup"); testStart("test_not_sane_lookup");
@ -666,7 +666,7 @@ static void test_utf8_to_unicode(const testCtx *const p_ctx) {
const int data_size = ARRAY_SIZE(data); const int data_size = ARRAY_SIZE(data);
int i, length, ret; int i, length, ret;
unsigned int vals[20]; unsigned int vals[20] = {0}; /* Suppress clang -fsanitize=memory false positive */
struct zint_symbol s_symbol; struct zint_symbol s_symbol;
struct zint_symbol *symbol = &s_symbol; struct zint_symbol *symbol = &s_symbol;

12
backend/tests/test_composite.c
View file

@ -1534,7 +1534,7 @@ static void test_examples(const testCtx *const p_ctx) {
char escaped[1024]; char escaped[1024];
char esc_composite[4096]; char esc_composite[4096];
char bwipp_buf[32768]; char bwipp_buf[32768] = {0}; /* Suppress clang -fsanitize=memory false positive */
char bwipp_msg[1024]; char bwipp_msg[1024];
int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */ int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */
@ -1836,7 +1836,7 @@ static void test_ean128_cc_shift(const testCtx *const p_ctx) {
int i, length, composite_length, ret; int i, length, composite_length, ret;
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
char bwipp_buf[8192]; char bwipp_buf[8192] = {0}; /* Suppress clang -fsanitize=memory false positive */
char bwipp_msg[1024]; char bwipp_msg[1024];
int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */ int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */
@ -2384,7 +2384,7 @@ static void test_encodation_0(const testCtx *const p_ctx) {
int i, length, composite_length, ret; int i, length, composite_length, ret;
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
char bwipp_buf[8192]; char bwipp_buf[8192] = {0}; /* Suppress clang -fsanitize=memory false positive */
char bwipp_msg[1024]; char bwipp_msg[1024];
int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */ int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */
@ -2522,7 +2522,7 @@ static void test_encodation_10(const testCtx *const p_ctx) {
int i, length, composite_length, ret; int i, length, composite_length, ret;
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
char bwipp_buf[8192]; char bwipp_buf[8192] = {0}; /* Suppress clang -fsanitize=memory false positive */
char bwipp_msg[1024]; char bwipp_msg[1024];
int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */ int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */
@ -2938,7 +2938,7 @@ static void test_encodation_11(const testCtx *const p_ctx) {
int i, length, composite_length, ret; int i, length, composite_length, ret;
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
char bwipp_buf[8192]; char bwipp_buf[8192] = {0}; /* Suppress clang -fsanitize=memory false positive */
char bwipp_msg[1024]; char bwipp_msg[1024];
int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */ int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */
@ -3089,7 +3089,7 @@ static void test_addongap(const testCtx *const p_ctx) {
int i, length, composite_length, ret; int i, length, composite_length, ret;
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
char bwipp_buf[8192]; char bwipp_buf[8192] = {0}; /* Suppress clang -fsanitize=memory false positive */
char bwipp_msg[1024]; char bwipp_msg[1024];
const char *composite = "[91]12"; const char *composite = "[91]12";

10
backend/tests/test_eci.c
View file

@ -758,7 +758,7 @@ static void test_utf8_to_eci_ascii(const testCtx *const p_ctx) {
int data_size = ARRAY_SIZE(data); int data_size = ARRAY_SIZE(data);
int i, length, ret; int i, length, ret;
char dest[128]; char dest[128] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStart("test_utf8_to_eci_ascii"); testStart("test_utf8_to_eci_ascii");
@ -815,7 +815,7 @@ static void test_utf8_to_eci_utf16be(const testCtx *const p_ctx) {
for (i = 0; i < data_size; i++) { for (i = 0; i < data_size; i++) {
int out_length, eci_length; int out_length, eci_length;
char dest[1024]; char dest[1024] = {0}; /* Suppress clang -fsanitize=memory false positive */
if (testContinue(p_ctx, i)) continue; if (testContinue(p_ctx, i)) continue;
@ -880,7 +880,7 @@ static void test_utf8_to_eci_utf16le(const testCtx *const p_ctx) {
for (i = 0; i < data_size; i++) { for (i = 0; i < data_size; i++) {
int out_length, eci_length; int out_length, eci_length;
char dest[1024]; char dest[1024] = {0}; /* Suppress clang -fsanitize=memory false positive */
if (testContinue(p_ctx, i)) continue; if (testContinue(p_ctx, i)) continue;
@ -942,7 +942,7 @@ static void test_utf8_to_eci_utf32be(const testCtx *const p_ctx) {
for (i = 0; i < data_size; i++) { for (i = 0; i < data_size; i++) {
int out_length, eci_length; int out_length, eci_length;
char dest[1024]; char dest[1024] = {0}; /* Suppress clang -fsanitize=memory false positive */
if (testContinue(p_ctx, i)) continue; if (testContinue(p_ctx, i)) continue;
@ -1006,7 +1006,7 @@ static void test_utf8_to_eci_utf32le(const testCtx *const p_ctx) {
for (i = 0; i < data_size; i++) { for (i = 0; i < data_size; i++) {
int out_length, eci_length; int out_length, eci_length;
char dest[1024]; char dest[1024] = {0}; /* Suppress clang -fsanitize=memory false positive */
if (testContinue(p_ctx, i)) continue; if (testContinue(p_ctx, i)) continue;

6
backend/tests/test_filemem.c
View file

@ -96,7 +96,7 @@ static void test_svg(const testCtx *const p_ctx) {
assert_equal(symbol->memfile_size, expected_size, "i:%d memfile_size %d != %d (%s)\n", assert_equal(symbol->memfile_size, expected_size, "i:%d memfile_size %d != %d (%s)\n",
i, symbol->memfile_size, expected_size, symbol->errtxt); i, symbol->memfile_size, expected_size, symbol->errtxt);
ret = memcmp(symbol->memfile, data[i].expected, symbol->memfile_size); ret = memcmp(symbol->memfile, data[i].expected, expected_size);
assert_zero(ret, "i:%d memcmp() %d != 0\n", i, ret); assert_zero(ret, "i:%d memcmp() %d != 0\n", i, ret);
} else { } else {
assert_null(symbol->memfile, "i:%d memfile != NULL (%s)\n", i, symbol->errtxt); assert_null(symbol->memfile, "i:%d memfile != NULL (%s)\n", i, symbol->errtxt);
@ -147,7 +147,7 @@ static void test_putsf(const testCtx *const p_ctx) {
struct zint_symbol symbol_data = {0}; struct zint_symbol symbol_data = {0};
struct zint_symbol *const symbol = &symbol_data; struct zint_symbol *const symbol = &symbol_data;
struct filemem fm; struct filemem fm = {0}; /* Suppress clang -fsanitize=memory false positive */
struct filemem *const fmp = &fm; struct filemem *const fmp = &fm;
#ifndef ZINT_TEST_NO_FMEMOPEN #ifndef ZINT_TEST_NO_FMEMOPEN
FILE *fp; FILE *fp;
@ -338,7 +338,7 @@ static void test_seek(const testCtx *const p_ctx) {
int j; int j;
struct zint_symbol symbol_data = {0}; struct zint_symbol symbol_data = {0};
struct zint_symbol *const symbol = &symbol_data; struct zint_symbol *const symbol = &symbol_data;
struct filemem fm; struct filemem fm = {0}; /* Suppress clang -fsanitize=memory false positive */
struct filemem *const fmp = &fm; struct filemem *const fmp = &fm;
const char outfile[] = "test_seek.tst"; const char outfile[] = "test_seek.tst";

6
backend/tests/test_gb18030.c
View file

@ -282,7 +282,7 @@ static void test_gb18030_utf8(const testCtx *const p_ctx) {
int i, length, ret; int i, length, ret;
struct zint_symbol symbol = {0}; struct zint_symbol symbol = {0};
unsigned int gbdata[30]; unsigned int gbdata[30] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStart("test_gb18030_utf8"); testStart("test_gb18030_utf8");
@ -399,7 +399,7 @@ static void test_gb18030_utf8_to_eci(const testCtx *const p_ctx) {
int data_size = ARRAY_SIZE(data); int data_size = ARRAY_SIZE(data);
int i, length, ret; int i, length, ret;
unsigned int gbdata[30]; unsigned int gbdata[30] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStart("test_gb18030_utf8_to_eci"); testStart("test_gb18030_utf8_to_eci");
@ -455,7 +455,7 @@ static void test_gb18030_cpy(const testCtx *const p_ctx) {
int data_size = ARRAY_SIZE(data); int data_size = ARRAY_SIZE(data);
int i, length; int i, length;
unsigned int gbdata[30]; unsigned int gbdata[30] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStart("test_gb18030_cpy"); testStart("test_gb18030_cpy");

6
backend/tests/test_gb2312.c
View file

@ -188,7 +188,7 @@ static void test_gb2312_utf8(const testCtx *const p_ctx) {
int i, length, ret; int i, length, ret;
struct zint_symbol symbol = {0}; struct zint_symbol symbol = {0};
unsigned int gbdata[20]; unsigned int gbdata[20] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStart("test_gb2312_utf8"); testStart("test_gb2312_utf8");
@ -290,7 +290,7 @@ static void test_gb2312_utf8_to_eci(const testCtx *const p_ctx) {
int data_size = ARRAY_SIZE(data); int data_size = ARRAY_SIZE(data);
int i, length, ret; int i, length, ret;
unsigned int gbdata[20]; unsigned int gbdata[20] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStart("test_gb2312_utf8_to_eci"); testStart("test_gb2312_utf8_to_eci");
@ -346,7 +346,7 @@ static void test_gb2312_cpy(const testCtx *const p_ctx) {
int data_size = ARRAY_SIZE(data); int data_size = ARRAY_SIZE(data);
int i, length; int i, length;
unsigned int gbdata[20]; unsigned int gbdata[20] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStart("test_gb2312_cpy"); testStart("test_gb2312_cpy");

8
backend/tests/test_gs1.c
View file

@ -1446,9 +1446,9 @@ static void test_gs1_verify(const testCtx *const p_ctx) {
const int data_size = ARRAY_SIZE(data); const int data_size = ARRAY_SIZE(data);
int i, length, ret; int i, length, ret;
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
int reduced_length; int reduced_length = 0; /* Suppress clang -fsanitize=memory false positive */
char reduced[1024]; char reduced[1024] = {0}; /* Suppress clang -fsanitize=memory false positive */
char escaped[1024]; char escaped[1024];
testStartSymbol("test_gs1_verify", &symbol); testStartSymbol("test_gs1_verify", &symbol);
@ -2154,9 +2154,9 @@ static void test_gs1_lint(const testCtx *const p_ctx) {
const int data_size = ARRAY_SIZE(data); const int data_size = ARRAY_SIZE(data);
int i, length, ret; int i, length, ret;
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
int reduced_length; int reduced_length = 0; /* Suppress clang -fsanitize=memory false positive */
char reduced[1024]; char reduced[1024] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStartSymbol("test_gs1_lint", &symbol); testStartSymbol("test_gs1_lint", &symbol);

2
backend/tests/test_hanxin.c
View file

@ -3452,7 +3452,7 @@ static void test_encode_segs(const testCtx *const p_ctx) {
int i, j, seg_count, ret; int i, j, seg_count, ret;
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
char escaped[8192]; char escaped[8192] = {0}; /* Suppress clang -fsanitize=memory false positive */
char cmp_buf[32768]; char cmp_buf[32768];
char cmp_msg[1024]; char cmp_msg[1024];

2
backend/tests/test_imail.c
View file

@ -239,7 +239,7 @@ static void test_input(const testCtx *const p_ctx) {
int i, length, ret; int i, length, ret;
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
char cmp_buf[8192]; char cmp_buf[8192] = {0}; /* Suppress clang -fsanitize=memory false positive */
char cmp_msg[1024]; char cmp_msg[1024];
int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */ int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */

2
backend/tests/test_ksx1001.c
View file

@ -44,7 +44,7 @@ INTERNAL int u_ksx1001_test(const unsigned int u, unsigned char *dest);
/* Version of `u_ksx1001()` taking unsigned int destination for backward-compatible testing */ /* Version of `u_ksx1001()` taking unsigned int destination for backward-compatible testing */
static int u_ksx1001_int(const unsigned int u, unsigned int *d) { static int u_ksx1001_int(const unsigned int u, unsigned int *d) {
unsigned char dest[2]; unsigned char dest[2] = {0}; /* Suppress clang -fsanitize=memory false positive */
int ret = u_ksx1001_test(u, dest); int ret = u_ksx1001_test(u, dest);
if (ret) { if (ret) {
*d = ret == 1 ? dest[0] : ((dest[0] << 8) | dest[1]); *d = ret == 1 ? dest[0] : ((dest[0] << 8) | dest[1]);

2
backend/tests/test_library.c
View file

@ -1577,7 +1577,7 @@ static int test_prev_ZBarcode_BarcodeName(int symbol_id, char name[32]) {
static void test_barcode_name(const testCtx *const p_ctx) { static void test_barcode_name(const testCtx *const p_ctx) {
int ret; int ret;
char name[32]; char name[32] = {0}; /* Suppress clang -fsanitize=memory false positive */
int symbol_id; int symbol_id;
(void)p_ctx; (void)p_ctx;

2
backend/tests/test_maxicode.c
View file

@ -255,7 +255,7 @@ static void test_input(const testCtx *const p_ctx) {
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
char escaped[1024]; char escaped[1024];
char cmp_buf[32768]; char cmp_buf[32768] = {0}; /* Suppress clang -fsanitize=memory false positive */
char cmp_msg[1024]; char cmp_msg[1024];
int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */ int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */

9
backend/tests/test_output.c
View file

@ -68,7 +68,7 @@ static void test_check_colour_options(const testCtx *const p_ctx) {
}; };
const int data_size = ARRAY_SIZE(data); const int data_size = ARRAY_SIZE(data);
int i, ret; int i, ret;
struct zint_symbol symbol; struct zint_symbol symbol = {0}; /* Suppress clang -fsanitize=memory false positive */
testStart("test_check_colour_options"); testStart("test_check_colour_options");
@ -121,7 +121,7 @@ static void test_colour_get_rgb(const testCtx *const p_ctx) {
for (i = 0; i < data_size; i++) { for (i = 0; i < data_size; i++) {
/* Suppress clang-16 run-time exception MemorySanitizer: use-of-uninitialized-value (fixed in clang-17) */ /* Suppress clang-16 run-time exception MemorySanitizer: use-of-uninitialized-value (fixed in clang-17) */
unsigned char red = 0, green = 0, blue = 0, alpha = 0, rgb_alpha = 0; unsigned char red = 0, green = 0, blue = 0, alpha = 0, rgb_alpha = 0;
int cyan, magenta, yellow, black; int cyan = 0, magenta = 0, yellow = 0, black = 0; /* Suppress clang -fsanitize=memory false positive */
int have_alpha; int have_alpha;
char rgb[64]; char rgb[64];
char cmyk[64]; char cmyk[64];
@ -179,8 +179,9 @@ static void test_colour_get_cmyk(const testCtx *const p_ctx) {
testStart("test_colour_get_cmyk"); testStart("test_colour_get_cmyk");
for (i = 0; i < data_size; i++) { for (i = 0; i < data_size; i++) {
int cyan, magenta, yellow, black; /* Suppress clang -fsanitize=memory false positives */
unsigned char red, green, blue, alpha, rgb_alpha; int cyan = 0, magenta = 0, yellow = 0, black = 0;
unsigned char red = '\0', green = '\0', blue = '\0', alpha = '\0', rgb_alpha = '\0';
char rgb[16]; char rgb[16];
if (testContinue(p_ctx, i)) continue; if (testContinue(p_ctx, i)) continue;

2
backend/tests/test_pdf417.c
View file

@ -5762,7 +5762,7 @@ static void test_numbprocess(const testCtx *const p_ctx) {
const int data_size = ARRAY_SIZE(data); const int data_size = ARRAY_SIZE(data);
int i, length; int i, length;
short chainemc[32]; short chainemc[32] = {0}; /* Suppress clang -fsanitize=memory false positive */
int mclength; int mclength;
testStart("test_numbprocess"); testStart("test_numbprocess");

2
backend/tests/test_plessey.c
View file

@ -71,7 +71,7 @@ static void test_large(const testCtx *const p_ctx) {
int i, length, ret; int i, length, ret;
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
char data_buf[4096]; char data_buf[4096] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStartSymbol("test_large", &symbol); testStartSymbol("test_large", &symbol);

2
backend/tests/test_postal.c
View file

@ -82,7 +82,7 @@ static void test_large(const testCtx *const p_ctx) {
int i, length, ret; int i, length, ret;
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
char data_buf[4096]; char data_buf[4096] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStartSymbol("test_large", &symbol); testStartSymbol("test_large", &symbol);

2
backend/tests/test_ps.c
View file

@ -235,7 +235,7 @@ static void test_ps_convert(const testCtx *const p_ctx) {
const int data_size = ARRAY_SIZE(data); const int data_size = ARRAY_SIZE(data);
int i; int i;
unsigned char converted[256]; unsigned char converted[256] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStart("test_ps_convert"); testStart("test_ps_convert");

10
backend/tests/test_qr.c
View file

@ -72,8 +72,8 @@ static void test_qr_large(const testCtx *const p_ctx) {
char data_buf[ZINT_MAX_DATA_LEN]; char data_buf[ZINT_MAX_DATA_LEN];
char escaped[ZINT_MAX_DATA_LEN]; char escaped[ZINT_MAX_DATA_LEN] = {0}; /* Suppress clang -fsanitize=memory false positive */
char cmp_buf[177 * 177 + 1]; char cmp_buf[177 * 177 + 1] = {0}; /* Suppress clang -fsanitize=memory false positive */
char cmp_msg[1024]; char cmp_msg[1024];
int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */ int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */
@ -433,7 +433,7 @@ static void test_qr_input(const testCtx *const p_ctx) {
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
char escaped[4096]; char escaped[4096];
char cmp_buf[32768]; char cmp_buf[32768] = {0}; /* Suppress clang -fsanitize=memory false positive */
char cmp_msg[1024]; char cmp_msg[1024];
int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */ int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */
@ -763,7 +763,7 @@ static void test_qr_optimize(const testCtx *const p_ctx) {
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
char escaped[4096]; char escaped[4096];
char cmp_buf[32768]; char cmp_buf[32768] = {0}; /* Suppress clang -fsanitize=memory false positive */
char cmp_msg[1024]; char cmp_msg[1024];
int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */ int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */
@ -8874,7 +8874,7 @@ static void test_rmqr_encode_segs(const testCtx *const p_ctx) {
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
char escaped[4096]; char escaped[4096];
char cmp_buf[32768]; char cmp_buf[32768] = {0}; /* Suppress clang -fsanitize=memory false positive */
char cmp_msg[1024]; char cmp_msg[1024];
int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */ int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */

4
backend/tests/test_reedsol.c
View file

@ -1,6 +1,6 @@
/* /*
libzint - the open source barcode library libzint - the open source barcode library
Copyright (C) 2020-2022 Robin Stuart <rstuart114@gmail.com> Copyright (C) 2020-2025 Robin Stuart <rstuart114@gmail.com>
Redistribution and use in source and binary forms, with or without Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions modification, are permitted provided that the following conditions
@ -263,7 +263,7 @@ static void test_uint_encoding(const testCtx *const p_ctx) {
for (i = 0; i < data_size; i++) { for (i = 0; i < data_size; i++) {
int j; int j;
rs_uint_t rs_uint; rs_uint_t rs_uint = {0}; /* Suppress clang -fsanitize=memory false positive */
unsigned int res[1024]; unsigned int res[1024];
if (testContinue(p_ctx, i)) continue; if (testContinue(p_ctx, i)) continue;

2
backend/tests/test_rss.c
View file

@ -865,7 +865,7 @@ static void test_examples(const testCtx *const p_ctx) {
int i, length, ret; int i, length, ret;
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
char escaped[4096]; char escaped[4096] = {0}; /* Suppress clang -fsanitize=memory false positive */
char cmp_buf[16384]; char cmp_buf[16384];
char cmp_msg[1024]; char cmp_msg[1024];

6
backend/tests/test_sjis.c
View file

@ -210,7 +210,7 @@ static void test_sjis_utf8(const testCtx *const p_ctx) {
int i, length, ret; int i, length, ret;
struct zint_symbol symbol = {0}; struct zint_symbol symbol = {0};
unsigned int jisdata[20]; unsigned int jisdata[20] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStart("test_sjis_utf8"); testStart("test_sjis_utf8");
@ -302,7 +302,7 @@ static void test_sjis_utf8_to_eci(const testCtx *const p_ctx) {
int data_size = ARRAY_SIZE(data); int data_size = ARRAY_SIZE(data);
int i, length, ret; int i, length, ret;
unsigned int jisdata[20]; unsigned int jisdata[20] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStart("test_sjis_utf8_to_eci"); testStart("test_sjis_utf8_to_eci");
@ -354,7 +354,7 @@ static void test_sjis_cpy(const testCtx *const p_ctx) {
int data_size = ARRAY_SIZE(data); int data_size = ARRAY_SIZE(data);
int i, length; int i, length;
unsigned int jisdata[20]; unsigned int jisdata[20] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStart("test_sjis_cpy"); testStart("test_sjis_cpy");

8
backend/tests/test_upcean.c
View file

@ -99,8 +99,8 @@ static void test_upce_input(const testCtx *const p_ctx) {
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
char escaped[4096]; char escaped[4096];
char cmp_buf[4096]; char cmp_buf[4096] = {0}; /* Suppress clang -fsanitize=memory false positive */
char cmp_msg[1024]; char cmp_msg[1024] = {0}; /* Suppress clang -fsanitize=memory false positive */
int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */ int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */
int do_zxingcpp = (debug & ZINT_DEBUG_TEST_ZXINGCPP) && testUtilHaveZXingCPPDecoder(); /* Only do ZXing-C++ test if asked, too slow otherwise */ int do_zxingcpp = (debug & ZINT_DEBUG_TEST_ZXINGCPP) && testUtilHaveZXingCPPDecoder(); /* Only do ZXing-C++ test if asked, too slow otherwise */
@ -834,7 +834,7 @@ static void test_vector_same(const testCtx *const p_ctx) {
} }
for (j = 0; j < vectors_size; j++) { for (j = 0; j < vectors_size; j++) {
struct zint_symbol symbol_vector; struct zint_symbol symbol_vector = {0}; /* Suppress clang -fsanitize=memory false positive */
symbol_vector.vector = vectors[j]; symbol_vector.vector = vectors[j];
vector_free(&symbol_vector); vector_free(&symbol_vector);
} }
@ -974,7 +974,7 @@ static void test_encode(const testCtx *const p_ctx) {
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
char escaped[4096]; char escaped[4096];
char cmp_buf[4096]; char cmp_buf[4096] = {0}; /* Suppress clang -fsanitize=memory false positive */
char cmp_msg[1024]; char cmp_msg[1024];
int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */ int do_bwipp = (debug & ZINT_DEBUG_TEST_BWIPP) && testUtilHaveGhostscript(); /* Only do BWIPP test if asked, too slow otherwise */

4
backend/tests/test_vector.c
View file

@ -689,7 +689,7 @@ static void test_buffer_vector(const testCtx *const p_ctx) {
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
const char *text; const char *text;
char errmsg[128]; char errmsg[128] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStartSymbol("test_buffer_vector", &symbol); testStartSymbol("test_buffer_vector", &symbol);
@ -858,7 +858,7 @@ static void test_has_hrt(const testCtx *const p_ctx) {
struct zint_symbol *symbol = NULL; struct zint_symbol *symbol = NULL;
const char *text; const char *text;
char errmsg[128]; char errmsg[128] = {0}; /* Suppress clang -fsanitize=memory false positive */
testStartSymbol("test_has_hrt", &symbol); testStartSymbol("test_has_hrt", &symbol);

16
backend/tests/testcommon.c
View file

@ -1869,8 +1869,8 @@ int testUtilCmpTxts(const char *txt1, const char *txt2) {
int ret = -1; int ret = -1;
FILE *fp1; FILE *fp1;
FILE *fp2; FILE *fp2;
char buf1[1024]; char buf1[1024] = {0}; /* Suppress clang -fsanitize=memory false positive */
char buf2[1024]; char buf2[1024] = {0}; /* Suppress clang -fsanitize=memory false positive */
size_t len1 = 0, len2 = 0; size_t len1 = 0, len2 = 0;
fp1 = testUtilOpen(txt1, "r"); fp1 = testUtilOpen(txt1, "r");
@ -1920,8 +1920,8 @@ int testUtilCmpBins(const char *bin1, const char *bin2) {
int ret = -1; int ret = -1;
FILE *fp1; FILE *fp1;
FILE *fp2; FILE *fp2;
char buf1[1024]; char buf1[1024] = {0}; /* Suppress clang -fsanitize=memory false positive */
char buf2[1024]; char buf2[1024] = {0}; /* Suppress clang -fsanitize=memory false positive */
size_t len1 = 0, len2 = 0; size_t len1 = 0, len2 = 0;
fp1 = testUtilOpen(bin1, "rb"); fp1 = testUtilOpen(bin1, "rb");
@ -1970,8 +1970,8 @@ int testUtilCmpEpss(const char *eps1, const char *eps2) {
int ret = -1; int ret = -1;
FILE *fp1; FILE *fp1;
FILE *fp2; FILE *fp2;
char buf1[1024]; char buf1[1024] = {0}; /* Suppress clang -fsanitize=memory false positive */
char buf2[1024]; char buf2[1024] = {0}; /* Suppress clang -fsanitize=memory false positive */
size_t len1 = 0, len2 = 0; size_t len1 = 0, len2 = 0;
static char first_line[] = "%!PS-Adobe-3.0 EPSF-3.0\n"; static char first_line[] = "%!PS-Adobe-3.0 EPSF-3.0\n";
static char second_line_start[] = "%%Creator: Zint "; static char second_line_start[] = "%%Creator: Zint ";
@ -2053,7 +2053,7 @@ const char *testUtilHaveIdentify(void) {
/* Check raster files */ /* Check raster files */
int testUtilVerifyIdentify(const char *const prog, const char *filename, int debug) { int testUtilVerifyIdentify(const char *const prog, const char *filename, int debug) {
char cmd[512 + 128]; char cmd[512 + 128] = {0}; /* Suppress clang -fsanitize=memory false positive */
if (strlen(filename) > 512) { if (strlen(filename) > 512) {
return -1; return -1;
@ -2210,7 +2210,7 @@ int testUtilHaveTiffInfo(void) {
/* Check TIF files */ /* Check TIF files */
int testUtilVerifyTiffInfo(const char *filename, int debug) { int testUtilVerifyTiffInfo(const char *filename, int debug) {
char cmd[512 + 128]; char cmd[512 + 128] = {0}; /* Suppress clang -fsanitize=memory false positive */
if (strlen(filename) > 512) { if (strlen(filename) > 512) {
return -1; return -1;

18
backend/vector.c
View file

@ -48,6 +48,9 @@ static int vector_add_rect(struct zint_symbol *symbol, const float x, const floa
errtxt(0, symbol, 691, "Insufficient memory for vector rectangle"); errtxt(0, symbol, 691, "Insufficient memory for vector rectangle");
return 0; return 0;
} }
#ifdef ZINT_SANITIZEM /* Suppress clang -fsanitize=memory false positive */
memset(rect, 0, sizeof(struct zint_vector_rect));
#endif
rect->next = NULL; rect->next = NULL;
rect->x = x; rect->x = x;
@ -73,6 +76,9 @@ static int vector_add_hexagon(struct zint_symbol *symbol, const float x, const f
if (!(hexagon = (struct zint_vector_hexagon *) malloc(sizeof(struct zint_vector_hexagon)))) { if (!(hexagon = (struct zint_vector_hexagon *) malloc(sizeof(struct zint_vector_hexagon)))) {
return errtxt(0, symbol, 692, "Insufficient memory for vector hexagon"); return errtxt(0, symbol, 692, "Insufficient memory for vector hexagon");
} }
#ifdef ZINT_SANITIZEM /* Suppress clang -fsanitize=memory false positive */
memset(hexagon, 0, sizeof(struct zint_vector_hexagon));
#endif
hexagon->next = NULL; hexagon->next = NULL;
hexagon->x = x; hexagon->x = x;
hexagon->y = y; hexagon->y = y;
@ -96,6 +102,9 @@ static int vector_add_circle(struct zint_symbol *symbol, const float x, const fl
if (!(circle = (struct zint_vector_circle *) malloc(sizeof(struct zint_vector_circle)))) { if (!(circle = (struct zint_vector_circle *) malloc(sizeof(struct zint_vector_circle)))) {
return errtxt(0, symbol, 693, "Insufficient memory for vector circle"); return errtxt(0, symbol, 693, "Insufficient memory for vector circle");
} }
#ifdef ZINT_SANITIZEM /* Suppress clang -fsanitize=memory false positive */
memset(circle, 0, sizeof(struct zint_vector_circle));
#endif
circle->next = NULL; circle->next = NULL;
circle->x = x; circle->x = x;
circle->y = y; circle->y = y;
@ -121,6 +130,9 @@ static int vector_add_string(struct zint_symbol *symbol, const unsigned char *te
if (!(string = (struct zint_vector_string *) malloc(sizeof(struct zint_vector_string)))) { if (!(string = (struct zint_vector_string *) malloc(sizeof(struct zint_vector_string)))) {
return errtxt(0, symbol, 694, "Insufficient memory for vector string"); return errtxt(0, symbol, 694, "Insufficient memory for vector string");
} }
#ifdef ZINT_SANITIZEM /* Suppress clang -fsanitize=memory false positive */
memset(string, 0, sizeof(struct zint_vector_string));
#endif
string->next = NULL; string->next = NULL;
string->x = x; string->x = x;
string->y = y; string->y = y;
@ -133,6 +145,9 @@ static int vector_add_string(struct zint_symbol *symbol, const unsigned char *te
free(string); free(string);
return errtxt(0, symbol, 695, "Insufficient memory for vector string text"); return errtxt(0, symbol, 695, "Insufficient memory for vector string text");
} }
#ifdef ZINT_SANITIZEM /* Suppress clang -fsanitize=memory false positive */
memset(string->text, 0, string->length + 1);
#endif
memcpy(string->text, text, string->length); memcpy(string->text, text, string->length);
string->text[string->length] = '\0'; string->text[string->length] = '\0';
@ -444,6 +459,9 @@ INTERNAL int plot_vector(struct zint_symbol *symbol, int rotate_angle, int file_
if (!(vector = symbol->vector = (struct zint_vector *) malloc(sizeof(struct zint_vector)))) { if (!(vector = symbol->vector = (struct zint_vector *) malloc(sizeof(struct zint_vector)))) {
return errtxt(ZINT_ERROR_MEMORY, symbol, 696, "Insufficient memory for vector header"); return errtxt(ZINT_ERROR_MEMORY, symbol, 696, "Insufficient memory for vector header");
} }
#ifdef ZINT_SANITIZEM /* Suppress clang -fsanitize=memory false positive */
memset(vector, 0, sizeof(struct zint_vector));
#endif
vector->rectangles = NULL; vector->rectangles = NULL;
vector->hexagons = NULL; vector->hexagons = NULL;
vector->circles = NULL; vector->circles = NULL;

4
backend_qt/qzint.h
View file

@ -1,7 +1,7 @@
/*************************************************************************** /***************************************************************************
* Copyright (C) 2008 by BogDan Vatra * * Copyright (C) 2008 by BogDan Vatra *
* bogdan@licentia.eu * * bogdan@licentia.eu *
* Copyright (C) 2010-2023 Robin Stuart * * Copyright (C) 2010-2025 Robin Stuart *
* * * *
* This program is free software: you can redistribute it and/or modify * * This program is free software: you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by * * it under the terms of the GNU General Public License as published by *
@ -107,7 +107,7 @@ public:
/* Dotty mode */ /* Dotty mode */
bool dotty() const; // `symbol->input_mode | BARCODE_DOTTY_MODE` bool dotty() const; // `symbol->input_mode | BARCODE_DOTTY_MODE`
void setDotty(bool botty); void setDotty(bool dotty);
/* Size of dots used in BARCODE_DOTTY_MODE */ /* Size of dots used in BARCODE_DOTTY_MODE */
float dotSize() const; // `symbol->dot_size` float dotSize() const; // `symbol->dot_size`