c/minizip-ng
1
0
Fork 0
mirror of https://github.com/zlib-ng/minizip-ng synced 2025-03-28 21:13:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

Revert "Remove inttypes.h."

Browse Source
This commit is contained in:
Nathan Moinvaziri 2018-11-13 17:42:13 -08:00
parent b2b082c67d
commit 264dc189b3
7 changed files with 78 additions and 71 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
minizip.c
View File

@ -14,6 +14,7 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include <time.h>
#include "mz.h"
@ -112,7 +113,7 @@ int32_t minizip_list(const char *path)
err = mz_zip_reader_open_file(reader, path);
if (err != MZ_OK)
{
printf("Error %d opening zip file %s\n", err, path);
printf("Error %"PRId32" opening zip file %s\n", err, path);
mz_zip_reader_delete(&reader);
return err;
}
@ -121,7 +122,7 @@ int32_t minizip_list(const char *path)
if (err != MZ_OK && err != MZ_END_OF_LIST)
{
printf("Error %d going to first entry in zip file\n", err);
printf("Error %"PRId32" going to first entry in zip file\n", err);
mz_zip_reader_delete(&reader);
return err;
}
@ -135,7 +136,7 @@ int32_t minizip_list(const char *path)
if (err != MZ_OK)
{
printf("Error %d getting entry info in zip file\n", err);
printf("Error %"PRId32" getting entry info in zip file\n", err);
break;
}
@ -175,8 +176,8 @@ int32_t minizip_list(const char *path)
mz_zip_time_t_to_tm(file_info->modified_date, &tmu_date);
printf("%12lld %12lld %3u%% %6s%c %8x %2.2u-%2.2u" \
"-%2.2u %2.2u:%2.2u %8.8x %s\n",
printf("%12"PRId64" %12"PRId64" %3"PRIu32"%% %6s%c %8"PRIx32" %2.2"PRIu32\
"-%2.2"PRIu32"-%2.2"PRIu32" %2.2"PRIu32":%2.2"PRIu32" %8.8"PRIx32" %s\n",
file_info->compressed_size, file_info->uncompressed_size, ratio,
string_method, crypt, file_info->external_fa,
(uint32_t)tmu_date.tm_mon + 1, (uint32_t)tmu_date.tm_mday,
@ -188,7 +189,7 @@ int32_t minizip_list(const char *path)
if (err != MZ_OK && err != MZ_END_OF_LIST)
{
printf("Error %d going to next entry in zip file\n", err);
printf("Error %"PRId32" going to next entry in zip file\n", err);
break;
}
}
@ -229,7 +230,7 @@ int32_t minizip_add_progress_cb(void *handle, void *userdata, mz_zip_file *file_
progress = ((double)position / file_info->uncompressed_size) * 100;
if (options->verbose)
printf("%s - %lld / %lld (%.02f%%)\n", file_info->filename, position,
printf("%s - %"PRIu64" / %"PRIu64" (%.02f%%)\n", file_info->filename, position,
file_info->uncompressed_size, progress);
return MZ_OK;
}
@ -302,18 +303,18 @@ int32_t minizip_add(const char *path, const char *password, minizip_opt *options
err = mz_zip_writer_add_path(writer, filename_in_zip, NULL, options->include_path, 1);
if (err != MZ_OK)
printf("Error %d adding path to zip %s\n", err, filename_in_zip);
printf("Error %"PRId32" adding path to zip %s\n", err, filename_in_zip);
}
}
else
{
printf("Error %d opening zip for writing\n", err);
printf("Error %"PRId32" opening zip for writing\n", err);
}
err_close = mz_zip_writer_close(writer);
if (err_close != MZ_OK)
{
printf("Error %d closing zip for writing %s\n", err_close, path);
printf("Error %"PRId32" closing zip for writing %s\n", err_close, path);
err = err_close;
}
@ -349,7 +350,7 @@ int32_t minizip_extract_progress_cb(void *handle, void *userdata, mz_zip_file *f
progress = ((double)position / file_info->uncompressed_size) * 100;
if (options->verbose)
printf("%s - %lld / %lld (%.02f%%)\n", file_info->filename, position,
printf("%s - %"PRIu64" / %"PRIu64" (%.02f%%)\n", file_info->filename, position,
file_info->uncompressed_size, progress);
return MZ_OK;
@ -406,7 +407,7 @@ int32_t minizip_extract(const char *path, const char *pattern, const char *desti
if (err != MZ_OK)
{
printf("Error %d opening zip file %s\n", err, path);
printf("Error %"PRId32" opening zip file %s\n", err, path);
}
else
{
@ -414,13 +415,13 @@ int32_t minizip_extract(const char *path, const char *pattern, const char *desti
if (err == MZ_END_OF_LIST && pattern != NULL)
printf("Files matching %s not found in zip file\n", pattern);
if (err != MZ_OK)
printf("Error %d saving zip entries to disk %s\n", err, path);
printf("Error %"PRId32" saving zip entries to disk %s\n", err, path);
}
err_close = mz_zip_reader_close(reader);
if (err_close != MZ_OK)
{
printf("Error %d closing zip for reading\n", err_close);
printf("Error %"PRId32" closing zip for reading\n", err_close);
err = err_close;
}
@ -445,7 +446,7 @@ int32_t minizip_erase(const char *src_path, const char *target_path, int32_t arg
err = mz_zip_reader_open_file(reader, src_path);
if (err != MZ_OK)
{
printf("Error %d opening zip for reading %s\n", err, src_path);
printf("Error %"PRId32" opening zip for reading %s\n", err, src_path);
mz_zip_reader_delete(&reader);
return err;
}
@ -453,7 +454,7 @@ int32_t minizip_erase(const char *src_path, const char *target_path, int32_t arg
err = mz_zip_writer_open_file(writer, target_path, 0, 0);
if (err != MZ_OK)
{
printf("Error %d opening zip for writing %s\n", err, target_path);
printf("Error %"PRId32" opening zip for writing %s\n", err, target_path);
mz_zip_reader_delete(&reader);
mz_zip_writer_delete(&writer);
return err;
@ -462,14 +463,14 @@ int32_t minizip_erase(const char *src_path, const char *target_path, int32_t arg
err = mz_zip_reader_goto_first_entry(reader);
if (err != MZ_OK && err != MZ_END_OF_LIST)
printf("Error %d going to first entry in zip file\n", err);
printf("Error %"PRId32" going to first entry in zip file\n", err);
while (err == MZ_OK)
{
err = mz_zip_reader_entry_get_info(reader, &file_info);
if (err != MZ_OK)
{
printf("Error %d getting info from zip\n", err);
printf("Error %"PRId32" getting info from zip\n", err);
break;
}
@ -490,14 +491,14 @@ int32_t minizip_erase(const char *src_path, const char *target_path, int32_t arg
if (err != MZ_OK)
{
printf("Error %d copying entry into new zip\n", err);
printf("Error %"PRId32" copying entry into new zip\n", err);
break;
}
err = mz_zip_reader_goto_next_entry(reader);
if (err != MZ_OK && err != MZ_END_OF_LIST)
printf("Error %d going to next entry in zip file\n", err);
printf("Error %"PRId32" going to next entry in zip file\n", err);
}
mz_zip_reader_close(reader);

25
mz_strm_buf.c
View File

@ -60,6 +60,7 @@ typedef struct mz_stream_buffered_s {
#if 0
# define mz_stream_buffered_print printf
#else
# include <inttypes.h>
# define mz_stream_buffered_print(fmt,...)
#endif
@ -81,7 +82,7 @@ static int32_t mz_stream_buffered_reset(void *stream)
int32_t mz_stream_buffered_open(void *stream, const char *path, int32_t mode)
{
mz_stream_buffered *buffered = (mz_stream_buffered *)stream;
mz_stream_buffered_print("Buffered - Open (mode %d)\n", mode);
mz_stream_buffered_print("Buffered - Open (mode %"PRId32")\n", mode);
mz_stream_buffered_reset(buffered);
return mz_stream_open(buffered->stream.base, path, mode);
}
@ -112,7 +113,7 @@ static int32_t mz_stream_buffered_flush(void *stream, int32_t *written)
buffered->writebuf_misses += 1;
mz_stream_buffered_print("Buffered - Write flush (%d:%d len %d)\n",
mz_stream_buffered_print("Buffered - Write flush (%"PRId32":%"PRId32" len %"PRId32")\n",
bytes_to_write, bytes_left_to_write, buffered->writebuf_len);
total_bytes_written += bytes_written;
@ -136,11 +137,11 @@ int32_t mz_stream_buffered_read(void *stream, void *buf, int32_t size)
int32_t bytes_left_to_read = size;
int32_t bytes_read = 0;
mz_stream_buffered_print("Buffered - Read (size %d pos %lld)\n", size, buffered->position);
mz_stream_buffered_print("Buffered - Read (size %"PRId32" pos %"PRId64")\n", size, buffered->position);
if (buffered->writebuf_len > 0)
{
mz_stream_buffered_print("Buffered - Switch from write to read, not yet supported (pos %lld)\n",
mz_stream_buffered_print("Buffered - Switch from write to read, not yet supported (pos %"PRId64")\n",
buffered->position);
}
@ -163,7 +164,7 @@ int32_t mz_stream_buffered_read(void *stream, void *buf, int32_t size)
buffered->readbuf_len += bytes_read;
buffered->position += bytes_read;
mz_stream_buffered_print("Buffered - Filled (read %d/%d buf %d:%d pos %lld)\n",
mz_stream_buffered_print("Buffered - Filled (read %"PRId32"/%"PRId32" buf %"PRId32":%"PRId32" pos %"PRId64")\n",
bytes_read, bytes_to_read, buffered->readbuf_pos, buffered->readbuf_len, buffered->position);
if (bytes_read == 0)
@ -184,7 +185,7 @@ int32_t mz_stream_buffered_read(void *stream, void *buf, int32_t size)
buffered->readbuf_hits += 1;
buffered->readbuf_pos += bytes_to_copy;
mz_stream_buffered_print("Buffered - Emptied (copied %d remaining %d buf %d:%d pos %lld)\n",
mz_stream_buffered_print("Buffered - Emptied (copied %"PRId32" remaining %"PRId32" buf %"PRId32":%"PRId32" pos %"PRId64")\n",
bytes_to_copy, bytes_left_to_read, buffered->readbuf_pos, buffered->readbuf_len, buffered->position);
}
}
@ -203,7 +204,7 @@ int32_t mz_stream_buffered_write(void *stream, const void *buf, int32_t size)
int32_t err = MZ_OK;
mz_stream_buffered_print("Buffered - Write (size %d len %d pos %lld)\n",
mz_stream_buffered_print("Buffered - Write (size %"PRId32" len %"PRId32" pos %"PRId64")\n",
size, buffered->writebuf_len, buffered->position);
if (buffered->readbuf_len > 0)
@ -214,7 +215,7 @@ int32_t mz_stream_buffered_write(void *stream, const void *buf, int32_t size)
buffered->readbuf_len = 0;
buffered->readbuf_pos = 0;
mz_stream_buffered_print("Buffered - Switch from read to write (pos %lld)\n", buffered->position);
mz_stream_buffered_print("Buffered - Switch from read to write (pos %"PRId64")\n", buffered->position);
err = mz_stream_seek(buffered->stream.base, buffered->position, MZ_SEEK_SET);
if (err != MZ_OK)
@ -244,7 +245,7 @@ int32_t mz_stream_buffered_write(void *stream, const void *buf, int32_t size)
memcpy(buffered->writebuf + buffered->writebuf_pos,
(const char *)buf + (bytes_to_write - bytes_left_to_write), bytes_to_copy);
mz_stream_buffered_print("Buffered - Write copy (remaining %d write %d:%d len %d)\n",
mz_stream_buffered_print("Buffered - Write copy (remaining %"PRId32" write %"PRId32":%"PRId32" len %"PRId32")\n",
bytes_to_copy, bytes_to_write, bytes_left_to_write, buffered->writebuf_len);
bytes_left_to_write -= bytes_to_copy;
@ -265,7 +266,7 @@ int64_t mz_stream_buffered_tell(void *stream)
buffered->position = position;
mz_stream_buffered_print("Buffered - Tell (pos %lld readpos %d writepos %d err %d)\n",
mz_stream_buffered_print("Buffered - Tell (pos %"PRId64" readpos %"PRId32" writepos %"PRId32" err %"PRId32")\n",
buffered->position, buffered->readbuf_pos, buffered->writebuf_pos, errno);
if (buffered->readbuf_len > 0)
@ -281,7 +282,7 @@ int32_t mz_stream_buffered_seek(void *stream, int64_t offset, int32_t origin)
int32_t bytes_flushed = 0;
int32_t err = MZ_OK;
mz_stream_buffered_print("Buffered - Seek (origin %d offset %lld pos %lld)\n",
mz_stream_buffered_print("Buffered - Seek (origin %"PRId32" offset %"PRId64" pos %"PRId64")\n",
origin, offset, buffered->position);
switch (origin)
@ -363,7 +364,7 @@ int32_t mz_stream_buffered_close(void *stream)
int32_t bytes_flushed = 0;
mz_stream_buffered_flush(stream, &bytes_flushed);
mz_stream_buffered_print("Buffered - Close (flushed %d)\n", bytes_flushed);
mz_stream_buffered_print("Buffered - Close (flushed %"PRId32")\n", bytes_flushed);
if (buffered->readbuf_hits + buffered->readbuf_misses > 0)
{

11
mz_strm_os_win32.c
View File

@ -70,6 +70,7 @@ typedef struct mz_stream_win32_s
#if 0
# define mz_stream_os_print printf
#else
# include <inttypes.h>
# define mz_stream_os_print(fmt,...)
#endif
@ -111,7 +112,7 @@ int32_t mz_stream_os_open(void *stream, const char *path, int32_t mode)
return MZ_PARAM_ERROR;
}
mz_stream_os_print("Win32 - Open - %s (mode %d)\n", path);
mz_stream_os_print("Win32 - Open - %s (mode %"PRId32")\n", path);
path_wide = mz_os_unicode_string_create(path, MZ_ENCODING_UTF8);
if (path_wide == NULL)
@ -162,7 +163,7 @@ int32_t mz_stream_os_read(void *stream, void *buf, int32_t size)
win32->error = 0;
}
mz_stream_os_print("Win32 - Read - %d\n", read);
mz_stream_os_print("Win32 - Read - %"PRId32"\n", read);
return read;
}
@ -182,7 +183,7 @@ int32_t mz_stream_os_write(void *stream, const void *buf, int32_t size)
win32->error = 0;
}
mz_stream_os_print("Win32 - Write - %d\n", written);
mz_stream_os_print("Win32 - Write - %"PRId32"\n", written);
return written;
}
@ -225,7 +226,7 @@ int64_t mz_stream_os_tell(void *stream)
if (mz_stream_os_seekinternal(win32->handle, large_pos, &large_pos, FILE_CURRENT) != MZ_OK)
win32->error = GetLastError();
mz_stream_os_print("Win32 - Tell - %lld\n", large_pos.QuadPart);
mz_stream_os_print("Win32 - Tell - %"PRId64"\n", large_pos.QuadPart);
return large_pos.QuadPart;
}
@ -256,7 +257,7 @@ int32_t mz_stream_os_seek(void *stream, int64_t offset, int32_t origin)
return MZ_SEEK_ERROR;
}
mz_stream_os_print("Win32 - Seek - %lld (origin %d)\n", offset, origin);
mz_stream_os_print("Win32 - Seek - %"PRId64" (origin %"PRId32")\n", offset, origin);
large_pos.QuadPart = offset;

15
mz_strm_split.c
View File

@ -12,6 +12,7 @@
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include "mz.h"
#include "mz_os.h"
@ -98,8 +99,8 @@ static int32_t mz_stream_split_open_disk(void *stream, int32_t number_disk)
{
if (split->path_disk[i] != '.')
continue;
snprintf(&split->path_disk[i], split->path_disk_size - (uint32_t)i, ".z%02d",
number_disk + 1);
snprintf(&split->path_disk[i], split->path_disk_size - (uint32_t)i,
".z%02"PRId32, number_disk + 1);
break;
}
}
@ -109,7 +110,7 @@ static int32_t mz_stream_split_open_disk(void *stream, int32_t number_disk)
split->path_disk[split->path_disk_size - 1] = 0;
}
mz_stream_split_print("Split - Goto disk - %s (disk %d)\n", split->path_disk, number_disk);
mz_stream_split_print("Split - Goto disk - %s (disk %"PRId32")\n", split->path_disk, number_disk);
// If disk part doesn't exist during reading then return MZ_EXIST_ERROR
if (disk_part == MZ_OPEN_MODE_READ)
@ -204,7 +205,7 @@ int32_t mz_stream_split_open(void *stream, const char *path, int32_t mode)
strncpy(split->path_cd, path, split->path_cd_size - 1);
split->path_cd[split->path_cd_size - 1] = 0;
mz_stream_split_print("Split - Open - %s (disk %d)\n", split->path_cd, number_disk);
mz_stream_split_print("Split - Open - %s (disk %"PRId32")\n", split->path_cd, number_disk);
split->path_disk_size = (uint32_t)strlen(path) + 10;
split->path_disk = (char *)MZ_ALLOC(split->path_disk_size);
@ -256,7 +257,7 @@ int32_t mz_stream_split_read(void *stream, void *buf, int32_t size)
{
read = mz_stream_read(split->stream.base, buf_ptr, bytes_left);
mz_stream_split_print("Split - Read disk - %d\n", read);
mz_stream_split_print("Split - Read disk - %"PRId32"\n", read);
if (read < 0)
return read;
@ -322,7 +323,7 @@ int32_t mz_stream_split_write(void *stream, const void *buf, int32_t size)
if (written != bytes_to_write)
return MZ_WRITE_ERROR;
mz_stream_split_print("Split - Write disk - %d\n", written);
mz_stream_split_print("Split - Write disk - %"PRId32"\n", written);
bytes_left -= written;
buf_ptr += written;
@ -350,7 +351,7 @@ int32_t mz_stream_split_seek(void *stream, int64_t offset, int32_t origin)
err = mz_stream_split_goto_disk(stream, split->number_disk);
if (err != MZ_OK)
return err;
mz_stream_split_print("Split - Seek disk - %lld (origin %d)\n", offset, origin);
mz_stream_split_print("Split - Seek disk - %"PRId64" (origin %"PRId32")\n", offset, origin);
return mz_stream_seek(split->stream.base, offset, origin);
}

31
mz_zip.c
View File

@ -20,6 +20,7 @@
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include <ctype.h>
#include <time.h>
#include <limits.h>
@ -428,12 +429,12 @@ static int32_t mz_zip_entry_read_header(void *stream, uint8_t local, mz_zip_file
{
mz_zip_print("Zip - Entry - Read header - %s (local %"PRId8")\n",
file_info->filename, local);
mz_zip_print("Zip - Entry - Read header compress (ucs %lld cs %lld crc 0x%08x)\n",
mz_zip_print("Zip - Entry - Read header compress (ucs %"PRId64" cs %"PRId64" crc 0x%08"PRIx32")\n",
file_info->uncompressed_size, file_info->compressed_size, file_info->crc);
if (!local)
mz_zip_print("Zip - Entry - Read header disk (disk %d offset %lld)\n",
mz_zip_print("Zip - Entry - Read header disk (disk %"PRId32" offset %"PRId64")\n",
file_info->disk_number, file_info->disk_offset);
mz_zip_print("Zip - Entry - Read header variable (fnl %d efs %d cms %d)\n",
mz_zip_print("Zip - Entry - Read header variable (fnl %"PRId32" efs %"PRId32" cms %"PRId32")\n",
file_info->filename_size, file_info->extrafield_size, file_info->comment_size);
}
@ -667,8 +668,8 @@ static int32_t mz_zip_entry_write_header(void *stream, uint8_t local, mz_zip_fil
if (mask)
{
snprintf(masked_name, sizeof(masked_name), "%x_%llx", file_info->disk_number,
file_info->disk_offset);
snprintf(masked_name, sizeof(masked_name), "%"PRIx32"_%"PRIx64,
file_info->disk_number, file_info->disk_offset);
filename = masked_name;
}
else
@ -970,7 +971,7 @@ static int32_t mz_zip_read_cd(void *handle)
if (err == MZ_OK)
{
mz_zip_print("Zip - Read cd (disk %d entries %lld offset %lld size %lld)\n",
mz_zip_print("Zip - Read cd (disk %"PRId32" entries %"PRId64" offset %"PRId64" size %"PRId64")\n",
zip->disk_number_with_cd, zip->number_entry, zip->cd_offset, zip->cd_size);
// Verify central directory signature exists at offset
@ -1037,7 +1038,7 @@ static int32_t mz_zip_write_cd(void *handle)
err = mz_stream_copy(zip->stream, zip->cd_mem_stream, (int32_t)zip->cd_size);
mz_zip_print("Zip - Write cd (disk %d entries %lld offset %lld size %lld)\n",
mz_zip_print("Zip - Write cd (disk %"PRId32" entries %"PRId64" offset %"PRId64" size %"PRId64")\n",
zip->disk_number_with_cd, zip->number_entry, zip->cd_offset, zip->cd_size);
// Write the ZIP64 central directory header
@ -1247,7 +1248,7 @@ static int32_t mz_zip_recover_cd(void *handle)
mz_stream_mem_delete(&local_file_info_stream);
mz_zip_print("Zip - Recover cd complete (cddisk %d entries %lld)\n",
mz_zip_print("Zip - Recover cd complete (cddisk %"PRId32" entries %"PRId64")\n",
disk_number_with_cd, number_entry);
if (number_entry == 0)
@ -1323,7 +1324,7 @@ int32_t mz_zip_open(void *handle, void *stream, int32_t mode)
err = mz_zip_read_cd(zip);
if (err != MZ_OK)
{
mz_zip_print("Zip - Error detected reading cd (%d)", err);
mz_zip_print("Zip - Error detected reading cd (%"PRId32")", err);
if (zip->recover && mz_zip_recover_cd(zip) == MZ_OK)
err = MZ_OK;
}
@ -1740,7 +1741,7 @@ int32_t mz_zip_entry_read_open(void *handle, uint8_t raw, const char *password)
else
mz_stream_set_prop_int64(zip->stream, MZ_STREAM_PROP_DISK_NUMBER, zip->file_info.disk_number);
mz_zip_print("Zip - Entry - Read open (disk %d "PRId16" offset %lld)\n",
mz_zip_print("Zip - Entry - Read open (disk %"PRId32" "PRId16" offset %"PRId64")\n",
zip->file_info.disk_number, zip->file_info.disk_offset);
err = mz_stream_seek(zip->stream, zip->file_info.disk_offset + zip->disk_offset_shift, MZ_SEEK_SET);
@ -1888,7 +1889,7 @@ int32_t mz_zip_entry_read(void *handle, void *buf, int32_t len)
if (read > 0)
zip->entry_crc32 = mz_crypt_crc32_update(zip->entry_crc32, buf, read);
mz_zip_print("Zip - Entry - Read - %d (max %d)\n", read, len);
mz_zip_print("Zip - Entry - Read - %"PRId32" (max %"PRId32")\n", read, len);
return read;
}
@ -1904,7 +1905,7 @@ int32_t mz_zip_entry_write(void *handle, const void *buf, int32_t len)
if (written > 0)
zip->entry_crc32 = mz_crypt_crc32_update(zip->entry_crc32, buf, written);
mz_zip_print("Zip - Entry - Write - %d (max %d)\n", written, len);
mz_zip_print("Zip - Entry - Write - %"PRId32" (max %"PRId32")\n", written, len);
return written;
}
@ -1967,7 +1968,7 @@ int32_t mz_zip_entry_close_raw(void *handle, int64_t uncompressed_size, uint32_t
if (!zip->entry_raw)
crc32 = zip->entry_crc32;
mz_zip_print("Zip - Entry - Close (ucs %lld crc 0x%08x)\n", compressed_size, crc32);
mz_zip_print("Zip - Entry - Close (ucs %"PRId64" crc 0x%08"PRIx32")\n", compressed_size, crc32);
if ((zip->open_mode & MZ_OPEN_MODE_WRITE) == 0)
{
@ -1983,7 +1984,7 @@ int32_t mz_zip_entry_close_raw(void *handle, int64_t uncompressed_size, uint32_t
{
if (crc32 != zip->file_info.crc)
{
mz_zip_print("Zip - Entry - Crc failed (actual 0x%08x expected 0x%08x)\n",
mz_zip_print("Zip - Entry - Crc failed (actual 0x%08"PRIx32" expected 0x%08"PRIx32")\n",
crc32, zip->file_info.crc);
err = MZ_CRC_ERROR;
@ -2018,7 +2019,7 @@ int32_t mz_zip_entry_close_raw(void *handle, int64_t uncompressed_size, uint32_t
zip->file_info.compressed_size = compressed_size;
zip->file_info.uncompressed_size = uncompressed_size;
mz_zip_print("Zip - Entry - Write cd (ucs %lld cs %lld crc 0x%08x)\n",
mz_zip_print("Zip - Entry - Write cd (ucs %"PRId64" cs %"PRId64" crc 0x%08"PRIx32")\n",
uncompressed_size, compressed_size, crc32);
if (err == MZ_OK)

9
test/fuzz/standalone.c
View File

@ -15,6 +15,7 @@
#include <stdint.h>
#include <stdio.h>
#include <string.h>
#include <inttypes.h>
#include "mz.h"
#include "mz_strm.h"
@ -40,7 +41,7 @@ int main(int argc, char **argv)
int32_t read = 0;
int32_t i = 0;
printf("Running %d inputs\n", argc - 1);
printf("Running %"PRId32" inputs\n", argc - 1);
for (i = 1; (i < argc) && (err == MZ_OK); i++)
{
@ -51,7 +52,7 @@ int main(int argc, char **argv)
if (err != MZ_OK)
{
printf("Skipping %s (%d)\n", argv[i], err);
printf("Skipping %s (%"PRId32")\n", argv[i], err);
}
else
{
@ -68,7 +69,7 @@ int main(int argc, char **argv)
if (buf != NULL)
{
printf("Running %s %d\n", argv[i], buf_length);
printf("Running %s %"PRId32"\n", argv[i], buf_length);
read = mz_stream_os_read(stream, buf, buf_length);
if (read == buf_length)
LLVMFuzzerTestOneInput(buf, buf_length);
@ -82,7 +83,7 @@ int main(int argc, char **argv)
}
mz_stream_os_delete(&stream);
printf("Done %s (%d)\n", argv[i], err);
printf("Done %s (%"PRId32")\n", argv[i], err);
}
return 0;

17
test/test.c
View File

@ -1,6 +1,7 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <inttypes.h>
#include <time.h>
#include <errno.h>
#include <fcntl.h>
@ -75,7 +76,7 @@ void test_path_resolve(void)
mz_path_resolve("c:\\test\\123\\..\\..\\..\\abc.txt", output, sizeof(output));
ok = (strcmp(output, "abc.txt") == 0);
memset(output, 'z', sizeof(output));
printf("ok = %d", ok);
printf("ok = %"PRId32"", ok);
}
void test_encrypt(char *method, mz_stream_create_cb crypt_create, char *password)
@ -119,7 +120,7 @@ void test_encrypt(char *method, mz_stream_create_cb crypt_create, char *password
mz_stream_os_close(out_stream);
printf("%s encrypted %d\n", encrypt_path, written);
printf("%s encrypted %"PRId32"\n", encrypt_path, written);
}
mz_stream_os_delete(&out_stream);
@ -142,7 +143,7 @@ void test_encrypt(char *method, mz_stream_create_cb crypt_create, char *password
mz_stream_os_close(in_stream);
printf("%s decrypted %d\n", decrypt_path, read);
printf("%s decrypted %"PRId32"\n", decrypt_path, read);
}
mz_stream_os_delete(&in_stream);
@ -295,7 +296,7 @@ void test_stream_wzaes(void)
}
else
{
printf("Pbkdf2 failed - %d", err);
printf("Pbkdf2 failed - %"PRId32"", err);
}
test_encrypt("aes", mz_stream_wzaes_create, "hello");
@ -447,7 +448,7 @@ int32_t test_stream_find_run(char *name, int32_t count, const uint8_t *find, int
last_pos = mz_stream_tell(mem_stream);
mz_stream_mem_delete(&mem_stream);
printf("Find postzero - %s (len %d pos %lld ok %d)\n",
printf("Find postzero - %s (len %"PRId32" pos %"PRId64" ok %"PRId32")\n",
name, find_size, position, (position == 0));
if (position != 0 || last_pos != position)
@ -468,7 +469,7 @@ int32_t test_stream_find_run(char *name, int32_t count, const uint8_t *find, int
last_pos = mz_stream_tell(mem_stream);
mz_stream_mem_delete(&mem_stream);
printf("Find prezero - %s (len %d pos %lld ok %d)\n",
printf("Find prezero - %s (len %"PRId32" pos %"PRId64" ok %"PRId32")\n",
name, find_size, position, (position == i));
if (position != i || last_pos != position)
@ -491,7 +492,7 @@ int32_t test_stream_find_run(char *name, int32_t count, const uint8_t *find, int
last_pos = mz_stream_tell(mem_stream);
mz_stream_mem_delete(&mem_stream);
printf("Find equalzero - %s (len %d pos %lld ok %d)\n",
printf("Find equalzero - %s (len %"PRId32" pos %"PRId64" ok %"PRId32")\n",
name, find_size, position, (position == i));
if (position != i || last_pos != position)
@ -515,7 +516,7 @@ int32_t test_stream_find_run(char *name, int32_t count, const uint8_t *find, int
last_pos = mz_stream_tell(mem_stream);
mz_stream_mem_delete(&mem_stream);
printf("Find unequalzero - %s (len %d pos %lld ok %d)\n",
printf("Find unequalzero - %s (len %"PRId32" pos %"PRId64" ok %"PRId32")\n",
name, find_size, position, (position == i));
if (position != i || last_pos != position)