1diff -ur zlib-1.2.11/adler32.c zlib-1.2.11__patched/adler32.c 2--- zlib-1.2.11/adler32.c 2017-01-01 08:37:10.000000000 +0100 3+++ zlib-1.2.11__patched/adler32.c 2019-10-22 17:36:13.389965314 +0200 4@@ -7,7 +7,7 @@ 5 6 #include "zutil.h" 7 8-local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2)); 9+local uLong adler32_combine_ (uLong adler1, uLong adler2, z_off64_t len2); 10 11 #define BASE 65521U /* largest prime smaller than 65536 */ 12 #define NMAX 5552 13diff -ur zlib-1.2.11/crc32.c zlib-1.2.11__patched/crc32.c 14--- zlib-1.2.11/crc32.c 2017-01-01 08:37:10.000000000 +0100 15+++ zlib-1.2.11__patched/crc32.c 2019-10-22 17:36:13.393965277 +0200 16@@ -35,29 +35,29 @@ 17 # define BYFOUR 18 #endif 19 #ifdef BYFOUR 20- local unsigned long crc32_little OF((unsigned long, 21- const unsigned char FAR *, z_size_t)); 22- local unsigned long crc32_big OF((unsigned long, 23- const unsigned char FAR *, z_size_t)); 24+ local unsigned long crc32_little (unsigned long, 25+ const unsigned char FAR *, z_size_t); 26+ local unsigned long crc32_big (unsigned long, 27+ const unsigned char FAR *, z_size_t); 28 # define TBLS 8 29 #else 30 # define TBLS 1 31 #endif /* BYFOUR */ 32 33 /* Local functions for crc concatenation */ 34-local unsigned long gf2_matrix_times OF((unsigned long *mat, 35- unsigned long vec)); 36-local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat)); 37-local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2)); 38+local unsigned long gf2_matrix_times (unsigned long *mat, 39+ unsigned long vec); 40+local void gf2_matrix_square (unsigned long *square, unsigned long *mat); 41+local uLong crc32_combine_ (uLong crc1, uLong crc2, z_off64_t len2); 42 43 44 #ifdef DYNAMIC_CRC_TABLE 45 46 local volatile int crc_table_empty = 1; 47 local z_crc_t FAR crc_table[TBLS][256]; 48-local void make_crc_table OF((void)); 49+local void make_crc_table (void); 50 #ifdef MAKECRCH 51- local void write_table OF((FILE *, const z_crc_t FAR *)); 52+ local void write_table (FILE *, const z_crc_t FAR *); 53 #endif /* MAKECRCH */ 54 /* 55 Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: 56diff -ur zlib-1.2.11/deflate.c zlib-1.2.11__patched/deflate.c 57--- zlib-1.2.11/deflate.c 2017-01-15 18:29:40.000000000 +0100 58+++ zlib-1.2.11__patched/deflate.c 2019-10-22 17:36:13.393965277 +0200 59@@ -70,34 +70,34 @@ 60 finish_done /* finish done, accept no more input or output */ 61 } block_state; 62 63-typedef block_state (*compress_func) OF((deflate_state *s, int flush)); 64+typedef block_state (*compress_func) (deflate_state *s, int flush); 65 /* Compression function. Returns the block state after the call. */ 66 67-local int deflateStateCheck OF((z_streamp strm)); 68-local void slide_hash OF((deflate_state *s)); 69-local void fill_window OF((deflate_state *s)); 70-local block_state deflate_stored OF((deflate_state *s, int flush)); 71-local block_state deflate_fast OF((deflate_state *s, int flush)); 72+local int deflateStateCheck (z_streamp strm); 73+local void slide_hash (deflate_state *s); 74+local void fill_window (deflate_state *s); 75+local block_state deflate_stored (deflate_state *s, int flush); 76+local block_state deflate_fast (deflate_state *s, int flush); 77 #ifndef FASTEST 78-local block_state deflate_slow OF((deflate_state *s, int flush)); 79+local block_state deflate_slow (deflate_state *s, int flush); 80 #endif 81-local block_state deflate_rle OF((deflate_state *s, int flush)); 82-local block_state deflate_huff OF((deflate_state *s, int flush)); 83-local void lm_init OF((deflate_state *s)); 84-local void putShortMSB OF((deflate_state *s, uInt b)); 85-local void flush_pending OF((z_streamp strm)); 86-local unsigned read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); 87+local block_state deflate_rle (deflate_state *s, int flush); 88+local block_state deflate_huff (deflate_state *s, int flush); 89+local void lm_init (deflate_state *s); 90+local void putShortMSB (deflate_state *s, uInt b); 91+local void flush_pending (z_streamp strm); 92+local unsigned read_buf (z_streamp strm, Bytef *buf, unsigned size); 93 #ifdef ASMV 94 # pragma message("Assembler code may have bugs -- use at your own risk") 95- void match_init OF((void)); /* asm code initialization */ 96- uInt longest_match OF((deflate_state *s, IPos cur_match)); 97+ void match_init (void); /* asm code initialization */ 98+ uInt longest_match (deflate_state *s, IPos cur_match); 99 #else 100-local uInt longest_match OF((deflate_state *s, IPos cur_match)); 101+local uInt longest_match (deflate_state *s, IPos cur_match); 102 #endif 103 104 #ifdef ZLIB_DEBUG 105-local void check_match OF((deflate_state *s, IPos start, IPos match, 106- int length)); 107+local void check_match (deflate_state *s, IPos start, IPos match, 108+ int length); 109 #endif 110 111 /* =========================================================================== 112diff -ur zlib-1.2.11/deflate.h zlib-1.2.11__patched/deflate.h 113--- zlib-1.2.11/deflate.h 2017-01-01 08:37:10.000000000 +0100 114+++ zlib-1.2.11__patched/deflate.h 2019-10-22 17:36:13.393965277 +0200 115@@ -296,14 +296,14 @@ 116 memory checker errors from longest match routines */ 117 118 /* in trees.c */ 119-void ZLIB_INTERNAL _tr_init OF((deflate_state *s)); 120-int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); 121-void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf, 122- ulg stored_len, int last)); 123-void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s)); 124-void ZLIB_INTERNAL _tr_align OF((deflate_state *s)); 125-void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf, 126- ulg stored_len, int last)); 127+void ZLIB_INTERNAL _tr_init (deflate_state *s); 128+int ZLIB_INTERNAL _tr_tally (deflate_state *s, unsigned dist, unsigned lc); 129+void ZLIB_INTERNAL _tr_flush_block (deflate_state *s, charf *buf, 130+ ulg stored_len, int last); 131+void ZLIB_INTERNAL _tr_flush_bits (deflate_state *s); 132+void ZLIB_INTERNAL _tr_align (deflate_state *s); 133+void ZLIB_INTERNAL _tr_stored_block (deflate_state *s, charf *buf, 134+ ulg stored_len, int last); 135 136 #define d_code(dist) \ 137 ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) 138diff -ur zlib-1.2.11/gzguts.h zlib-1.2.11__patched/gzguts.h 139--- zlib-1.2.11/gzguts.h 2017-01-01 08:37:10.000000000 +0100 140+++ zlib-1.2.11__patched/gzguts.h 2019-10-22 17:36:13.393965277 +0200 141@@ -119,8 +119,8 @@ 142 143 /* gz* functions always use library allocation functions */ 144 #ifndef STDC 145- extern voidp malloc OF((uInt size)); 146- extern void free OF((voidpf ptr)); 147+ extern voidp malloc (uInt size); 148+ extern void free (voidpf ptr); 149 #endif 150 151 /* get errno and strerror definition */ 152@@ -138,10 +138,10 @@ 153 154 /* provide prototypes for these when building zlib without LFS */ 155 #if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0 156- ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); 157- ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); 158- ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); 159- ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); 160+ ZEXTERN gzFile ZEXPORT gzopen64 (const char *, const char *); 161+ ZEXTERN z_off64_t ZEXPORT gzseek64 (gzFile, z_off64_t, int); 162+ ZEXTERN z_off64_t ZEXPORT gztell64 (gzFile); 163+ ZEXTERN z_off64_t ZEXPORT gzoffset64 (gzFile); 164 #endif 165 166 /* default memLevel */ 167@@ -202,9 +202,9 @@ 168 typedef gz_state FAR *gz_statep; 169 170 /* shared functions */ 171-void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *)); 172+void ZLIB_INTERNAL gz_error (gz_statep, int, const char *); 173 #if defined UNDER_CE 174-char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error)); 175+char ZLIB_INTERNAL *gz_strwinerror (DWORD error); 176 #endif 177 178 /* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t 179@@ -213,6 +213,6 @@ 180 #ifdef INT_MAX 181 # define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX) 182 #else 183-unsigned ZLIB_INTERNAL gz_intmax OF((void)); 184+unsigned ZLIB_INTERNAL gz_intmax (void); 185 # define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax()) 186 #endif 187diff -ur zlib-1.2.11/gzlib.c zlib-1.2.11__patched/gzlib.c 188--- zlib-1.2.11/gzlib.c 2017-01-15 18:29:40.000000000 +0100 189+++ zlib-1.2.11__patched/gzlib.c 2019-10-22 17:36:13.393965277 +0200 190@@ -16,8 +16,8 @@ 191 #endif 192 193 /* Local functions */ 194-local void gz_reset OF((gz_statep)); 195-local gzFile gz_open OF((const void *, int, const char *)); 196+local void gz_reset (gz_statep); 197+local gzFile gz_open (const void *, int, const char *); 198 199 #if defined UNDER_CE 200 201diff -ur zlib-1.2.11/gzread.c zlib-1.2.11__patched/gzread.c 202--- zlib-1.2.11/gzread.c 2017-01-01 08:37:10.000000000 +0100 203+++ zlib-1.2.11__patched/gzread.c 2019-10-22 17:36:13.393965277 +0200 204@@ -6,13 +6,13 @@ 205 #include "gzguts.h" 206 207 /* Local functions */ 208-local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *)); 209-local int gz_avail OF((gz_statep)); 210-local int gz_look OF((gz_statep)); 211-local int gz_decomp OF((gz_statep)); 212-local int gz_fetch OF((gz_statep)); 213-local int gz_skip OF((gz_statep, z_off64_t)); 214-local z_size_t gz_read OF((gz_statep, voidp, z_size_t)); 215+local int gz_load (gz_statep, unsigned char *, unsigned, unsigned *); 216+local int gz_avail (gz_statep); 217+local int gz_look (gz_statep); 218+local int gz_decomp (gz_statep); 219+local int gz_fetch (gz_statep); 220+local int gz_skip (gz_statep, z_off64_t); 221+local z_size_t gz_read (gz_statep, voidp, z_size_t); 222 223 /* Use read() to load a buffer -- return -1 on error, otherwise 0. Read from 224 state->fd, and update state->eof, state->err, and state->msg as appropriate. 225diff -ur zlib-1.2.11/gzwrite.c zlib-1.2.11__patched/gzwrite.c 226--- zlib-1.2.11/gzwrite.c 2017-01-15 18:29:40.000000000 +0100 227+++ zlib-1.2.11__patched/gzwrite.c 2019-10-22 17:36:13.393965277 +0200 228@@ -6,10 +6,10 @@ 229 #include "gzguts.h" 230 231 /* Local functions */ 232-local int gz_init OF((gz_statep)); 233-local int gz_comp OF((gz_statep, int)); 234-local int gz_zero OF((gz_statep, z_off64_t)); 235-local z_size_t gz_write OF((gz_statep, voidpc, z_size_t)); 236+local int gz_init (gz_statep); 237+local int gz_comp (gz_statep, int); 238+local int gz_zero (gz_statep, z_off64_t); 239+local z_size_t gz_write (gz_statep, voidpc, z_size_t); 240 241 /* Initialize state for writing a gzip file. Mark initialization by setting 242 state->size to non-zero. Return -1 on a memory allocation failure, or 0 on 243diff -ur zlib-1.2.11/infback.c zlib-1.2.11__patched/infback.c 244--- zlib-1.2.11/infback.c 2017-01-01 08:37:10.000000000 +0100 245+++ zlib-1.2.11__patched/infback.c 2019-10-22 17:36:13.393965277 +0200 246@@ -16,7 +16,7 @@ 247 #include "inffast.h" 248 249 /* function prototypes */ 250-local void fixedtables OF((struct inflate_state FAR *state)); 251+local void fixedtables (struct inflate_state FAR *state); 252 253 /* 254 strm provides memory allocation functions in zalloc and zfree, or 255diff -ur zlib-1.2.11/inffast.h zlib-1.2.11__patched/inffast.h 256--- zlib-1.2.11/inffast.h 2010-04-19 06:16:01.000000000 +0200 257+++ zlib-1.2.11__patched/inffast.h 2019-10-22 17:36:13.393965277 +0200 258@@ -8,4 +8,4 @@ 259 subject to change. Applications should only use zlib.h. 260 */ 261 262-void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start)); 263+void ZLIB_INTERNAL inflate_fast (z_streamp strm, unsigned start); 264diff -ur zlib-1.2.11/inflate.c zlib-1.2.11__patched/inflate.c 265--- zlib-1.2.11/inflate.c 2017-01-01 08:37:10.000000000 +0100 266+++ zlib-1.2.11__patched/inflate.c 2019-10-22 17:36:13.397965240 +0200 267@@ -92,15 +92,15 @@ 268 #endif 269 270 /* function prototypes */ 271-local int inflateStateCheck OF((z_streamp strm)); 272-local void fixedtables OF((struct inflate_state FAR *state)); 273-local int updatewindow OF((z_streamp strm, const unsigned char FAR *end, 274- unsigned copy)); 275+local int inflateStateCheck (z_streamp strm); 276+local void fixedtables (struct inflate_state FAR *state); 277+local int updatewindow (z_streamp strm, const unsigned char FAR *end, 278+ unsigned copy); 279 #ifdef BUILDFIXED 280- void makefixed OF((void)); 281+ void makefixed (void); 282 #endif 283-local unsigned syncsearch OF((unsigned FAR *have, const unsigned char FAR *buf, 284- unsigned len)); 285+local unsigned syncsearch (unsigned FAR *have, const unsigned char FAR *buf, 286+ unsigned len); 287 288 local int inflateStateCheck(strm) 289 z_streamp strm; 290diff -ur zlib-1.2.11/inftrees.h zlib-1.2.11__patched/inftrees.h 291--- zlib-1.2.11/inftrees.h 2010-04-19 06:15:26.000000000 +0200 292+++ zlib-1.2.11__patched/inftrees.h 2019-10-22 17:36:13.397965240 +0200 293@@ -57,6 +57,6 @@ 294 DISTS 295 } codetype; 296 297-int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens, 298+int ZLIB_INTERNAL inflate_table (codetype type, unsigned short FAR *lens, 299 unsigned codes, code FAR * FAR *table, 300- unsigned FAR *bits, unsigned short FAR *work)); 301+ unsigned FAR *bits, unsigned short FAR *work); 302diff -ur zlib-1.2.11/trees.c zlib-1.2.11__patched/trees.c 303--- zlib-1.2.11/trees.c 2017-01-15 18:07:14.000000000 +0100 304+++ zlib-1.2.11__patched/trees.c 2019-10-22 17:36:13.397965240 +0200 305@@ -135,26 +135,26 @@ 306 * Local (static) routines in this file. 307 */ 308 309-local void tr_static_init OF((void)); 310-local void init_block OF((deflate_state *s)); 311-local void pqdownheap OF((deflate_state *s, ct_data *tree, int k)); 312-local void gen_bitlen OF((deflate_state *s, tree_desc *desc)); 313-local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count)); 314-local void build_tree OF((deflate_state *s, tree_desc *desc)); 315-local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code)); 316-local void send_tree OF((deflate_state *s, ct_data *tree, int max_code)); 317-local int build_bl_tree OF((deflate_state *s)); 318-local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes, 319- int blcodes)); 320-local void compress_block OF((deflate_state *s, const ct_data *ltree, 321- const ct_data *dtree)); 322-local int detect_data_type OF((deflate_state *s)); 323-local unsigned bi_reverse OF((unsigned value, int length)); 324-local void bi_windup OF((deflate_state *s)); 325-local void bi_flush OF((deflate_state *s)); 326+local void tr_static_init (void); 327+local void init_block (deflate_state *s); 328+local void pqdownheap (deflate_state *s, ct_data *tree, int k); 329+local void gen_bitlen (deflate_state *s, tree_desc *desc); 330+local void gen_codes (ct_data *tree, int max_code, ushf *bl_count); 331+local void build_tree (deflate_state *s, tree_desc *desc); 332+local void scan_tree (deflate_state *s, ct_data *tree, int max_code); 333+local void send_tree (deflate_state *s, ct_data *tree, int max_code); 334+local int build_bl_tree (deflate_state *s); 335+local void send_all_trees (deflate_state *s, int lcodes, int dcodes, 336+ int blcodes); 337+local void compress_block (deflate_state *s, const ct_data *ltree, 338+ const ct_data *dtree); 339+local int detect_data_type (deflate_state *s); 340+local unsigned bi_reverse (unsigned value, int length); 341+local void bi_windup (deflate_state *s); 342+local void bi_flush (deflate_state *s); 343 344 #ifdef GEN_TREES_H 345-local void gen_trees_header OF((void)); 346+local void gen_trees_header (void); 347 #endif 348 349 #ifndef ZLIB_DEBUG 350@@ -181,7 +181,7 @@ 351 * IN assertion: length <= 16 and value fits in length bits. 352 */ 353 #ifdef ZLIB_DEBUG 354-local void send_bits OF((deflate_state *s, int value, int length)); 355+local void send_bits (deflate_state *s, int value, int length); 356 357 local void send_bits(s, value, length) 358 deflate_state *s; 359diff -ur zlib-1.2.11/zconf.h zlib-1.2.11__patched/zconf.h 360--- zlib-1.2.11/zconf.h 2017-01-01 08:37:10.000000000 +0100 361+++ zlib-1.2.11__patched/zconf.h 2019-10-22 17:36:13.397965240 +0200 362@@ -287,9 +287,9 @@ 363 364 #ifndef OF /* function prototypes */ 365 # ifdef STDC 366-# define OF(args) args 367+# define args args 368 # else 369-# define OF(args) () 370+# define args () 371 # endif 372 #endif 373 374diff -ur zlib-1.2.11/zconf.h.cmakein zlib-1.2.11__patched/zconf.h.cmakein 375--- zlib-1.2.11/zconf.h.cmakein 2017-01-01 08:37:10.000000000 +0100 376+++ zlib-1.2.11__patched/zconf.h.cmakein 2019-10-22 17:36:13.397965240 +0200 377@@ -289,9 +289,9 @@ 378 379 #ifndef OF /* function prototypes */ 380 # ifdef STDC 381-# define OF(args) args 382+# define args args 383 # else 384-# define OF(args) () 385+# define args () 386 # endif 387 #endif 388 389diff -ur zlib-1.2.11/zconf.h.in zlib-1.2.11__patched/zconf.h.in 390--- zlib-1.2.11/zconf.h.in 2017-01-01 08:37:10.000000000 +0100 391+++ zlib-1.2.11__patched/zconf.h.in 2019-10-22 17:36:13.397965240 +0200 392@@ -287,9 +287,9 @@ 393 394 #ifndef OF /* function prototypes */ 395 # ifdef STDC 396-# define OF(args) args 397+# define args args 398 # else 399-# define OF(args) () 400+# define args () 401 # endif 402 #endif 403 404diff -ur zlib-1.2.11/zlib.h zlib-1.2.11__patched/zlib.h 405--- zlib-1.2.11/zlib.h 2017-01-15 18:29:40.000000000 +0100 406+++ zlib-1.2.11__patched/zlib.h 2019-10-22 17:36:13.397965240 +0200 407@@ -78,8 +78,8 @@ 408 even in the case of corrupted input. 409 */ 410 411-typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); 412-typedef void (*free_func) OF((voidpf opaque, voidpf address)); 413+typedef voidpf (*alloc_func) (voidpf opaque, uInt items, uInt size); 414+typedef void (*free_func) (voidpf opaque, voidpf address); 415 416 struct internal_state; 417 418@@ -217,7 +217,7 @@ 419 420 /* basic functions */ 421 422-ZEXTERN const char * ZEXPORT zlibVersion OF((void)); 423+ZEXTERN const char * ZEXPORT zlibVersion (void); 424 /* The application can compare zlibVersion and ZLIB_VERSION for consistency. 425 If the first character differs, the library code actually used is not 426 compatible with the zlib.h header file used by the application. This check 427@@ -225,7 +225,7 @@ 428 */ 429 430 /* 431-ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); 432+ZEXTERN int ZEXPORT deflateInit (z_streamp strm, int level); 433 434 Initializes the internal stream state for compression. The fields 435 zalloc, zfree and opaque must be initialized before by the caller. If 436@@ -247,7 +247,7 @@ 437 */ 438 439 440-ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); 441+ZEXTERN int ZEXPORT deflate (z_streamp strm, int flush); 442 /* 443 deflate compresses as much data as possible, and stops when the input 444 buffer becomes empty or the output buffer becomes full. It may introduce 445@@ -360,7 +360,7 @@ 446 */ 447 448 449-ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); 450+ZEXTERN int ZEXPORT deflateEnd (z_streamp strm); 451 /* 452 All dynamically allocated data structures for this stream are freed. 453 This function discards any unprocessed input and does not flush any pending 454@@ -375,7 +375,7 @@ 455 456 457 /* 458-ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); 459+ZEXTERN int ZEXPORT inflateInit (z_streamp strm); 460 461 Initializes the internal stream state for decompression. The fields 462 next_in, avail_in, zalloc, zfree and opaque must be initialized before by 463@@ -397,7 +397,7 @@ 464 */ 465 466 467-ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); 468+ZEXTERN int ZEXPORT inflate (z_streamp strm, int flush); 469 /* 470 inflate decompresses as much data as possible, and stops when the input 471 buffer becomes empty or the output buffer becomes full. It may introduce 472@@ -517,7 +517,7 @@ 473 */ 474 475 476-ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); 477+ZEXTERN int ZEXPORT inflateEnd (z_streamp strm); 478 /* 479 All dynamically allocated data structures for this stream are freed. 480 This function discards any unprocessed input and does not flush any pending 481@@ -535,12 +535,12 @@ 482 */ 483 484 /* 485-ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, 486+ZEXTERN int ZEXPORT deflateInit2 (z_streamp strm, 487 int level, 488 int method, 489 int windowBits, 490 int memLevel, 491- int strategy)); 492+ int strategy); 493 494 This is another version of deflateInit with more compression options. The 495 fields next_in, zalloc, zfree and opaque must be initialized before by the 496@@ -608,9 +608,9 @@ 497 compression: this will be done by deflate(). 498 */ 499 500-ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, 501+ZEXTERN int ZEXPORT deflateSetDictionary (z_streamp strm, 502 const Bytef *dictionary, 503- uInt dictLength)); 504+ uInt dictLength); 505 /* 506 Initializes the compression dictionary from the given byte sequence 507 without producing any compressed output. When using the zlib format, this 508@@ -652,9 +652,9 @@ 509 not perform any compression: this will be done by deflate(). 510 */ 511 512-ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm, 513+ZEXTERN int ZEXPORT deflateGetDictionary (z_streamp strm, 514 Bytef *dictionary, 515- uInt *dictLength)); 516+ uInt *dictLength); 517 /* 518 Returns the sliding dictionary being maintained by deflate. dictLength is 519 set to the number of bytes in the dictionary, and that many bytes are copied 520@@ -674,8 +674,8 @@ 521 stream state is inconsistent. 522 */ 523 524-ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, 525- z_streamp source)); 526+ZEXTERN int ZEXPORT deflateCopy (z_streamp dest, 527+ z_streamp source); 528 /* 529 Sets the destination stream as a complete copy of the source stream. 530 531@@ -692,7 +692,7 @@ 532 destination. 533 */ 534 535-ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); 536+ZEXTERN int ZEXPORT deflateReset (z_streamp strm); 537 /* 538 This function is equivalent to deflateEnd followed by deflateInit, but 539 does not free and reallocate the internal compression state. The stream 540@@ -703,9 +703,9 @@ 541 stream state was inconsistent (such as zalloc or state being Z_NULL). 542 */ 543 544-ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, 545+ZEXTERN int ZEXPORT deflateParams (z_streamp strm, 546 int level, 547- int strategy)); 548+ int strategy); 549 /* 550 Dynamically update the compression level and compression strategy. The 551 interpretation of level and strategy is as in deflateInit2(). This can be 552@@ -740,11 +740,11 @@ 553 retried with more output space. 554 */ 555 556-ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, 557+ZEXTERN int ZEXPORT deflateTune (z_streamp strm, 558 int good_length, 559 int max_lazy, 560 int nice_length, 561- int max_chain)); 562+ int max_chain); 563 /* 564 Fine tune deflate's internal compression parameters. This should only be 565 used by someone who understands the algorithm used by zlib's deflate for 566@@ -757,8 +757,8 @@ 567 returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. 568 */ 569 570-ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, 571- uLong sourceLen)); 572+ZEXTERN uLong ZEXPORT deflateBound (z_streamp strm, 573+ uLong sourceLen); 574 /* 575 deflateBound() returns an upper bound on the compressed size after 576 deflation of sourceLen bytes. It must be called after deflateInit() or 577@@ -772,9 +772,9 @@ 578 than Z_FINISH or Z_NO_FLUSH are used. 579 */ 580 581-ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, 582+ZEXTERN int ZEXPORT deflatePending (z_streamp strm, 583 unsigned *pending, 584- int *bits)); 585+ int *bits); 586 /* 587 deflatePending() returns the number of bytes and bits of output that have 588 been generated, but not yet provided in the available output. The bytes not 589@@ -787,9 +787,9 @@ 590 stream state was inconsistent. 591 */ 592 593-ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, 594+ZEXTERN int ZEXPORT deflatePrime (z_streamp strm, 595 int bits, 596- int value)); 597+ int value); 598 /* 599 deflatePrime() inserts bits in the deflate output stream. The intent 600 is that this function is used to start off the deflate output with the bits 601@@ -804,8 +804,8 @@ 602 source stream state was inconsistent. 603 */ 604 605-ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, 606- gz_headerp head)); 607+ZEXTERN int ZEXPORT deflateSetHeader (z_streamp strm, 608+ gz_headerp head); 609 /* 610 deflateSetHeader() provides gzip header information for when a gzip 611 stream is requested by deflateInit2(). deflateSetHeader() may be called 612@@ -829,8 +829,8 @@ 613 */ 614 615 /* 616-ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, 617- int windowBits)); 618+ZEXTERN int ZEXPORT inflateInit2 (z_streamp strm, 619+ int windowBits); 620 621 This is another version of inflateInit with an extra parameter. The 622 fields next_in, avail_in, zalloc, zfree and opaque must be initialized 623@@ -881,9 +881,9 @@ 624 deferred until inflate() is called. 625 */ 626 627-ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, 628+ZEXTERN int ZEXPORT inflateSetDictionary (z_streamp strm, 629 const Bytef *dictionary, 630- uInt dictLength)); 631+ uInt dictLength); 632 /* 633 Initializes the decompression dictionary from the given uncompressed byte 634 sequence. This function must be called immediately after a call of inflate, 635@@ -904,9 +904,9 @@ 636 inflate(). 637 */ 638 639-ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm, 640+ZEXTERN int ZEXPORT inflateGetDictionary (z_streamp strm, 641 Bytef *dictionary, 642- uInt *dictLength)); 643+ uInt *dictLength); 644 /* 645 Returns the sliding dictionary being maintained by inflate. dictLength is 646 set to the number of bytes in the dictionary, and that many bytes are copied 647@@ -919,7 +919,7 @@ 648 stream state is inconsistent. 649 */ 650 651-ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); 652+ZEXTERN int ZEXPORT inflateSync (z_streamp strm); 653 /* 654 Skips invalid compressed data until a possible full flush point (see above 655 for the description of deflate with Z_FULL_FLUSH) can be found, or until all 656@@ -938,8 +938,8 @@ 657 input each time, until success or end of the input data. 658 */ 659 660-ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, 661- z_streamp source)); 662+ZEXTERN int ZEXPORT inflateCopy (z_streamp dest, 663+ z_streamp source); 664 /* 665 Sets the destination stream as a complete copy of the source stream. 666 667@@ -954,7 +954,7 @@ 668 destination. 669 */ 670 671-ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); 672+ZEXTERN int ZEXPORT inflateReset (z_streamp strm); 673 /* 674 This function is equivalent to inflateEnd followed by inflateInit, 675 but does not free and reallocate the internal decompression state. The 676@@ -964,8 +964,8 @@ 677 stream state was inconsistent (such as zalloc or state being Z_NULL). 678 */ 679 680-ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, 681- int windowBits)); 682+ZEXTERN int ZEXPORT inflateReset2 (z_streamp strm, 683+ int windowBits); 684 /* 685 This function is the same as inflateReset, but it also permits changing 686 the wrap and window size requests. The windowBits parameter is interpreted 687@@ -978,9 +978,9 @@ 688 the windowBits parameter is invalid. 689 */ 690 691-ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, 692+ZEXTERN int ZEXPORT inflatePrime (z_streamp strm, 693 int bits, 694- int value)); 695+ int value); 696 /* 697 This function inserts bits in the inflate input stream. The intent is 698 that this function is used to start inflating at a bit position in the 699@@ -999,7 +999,7 @@ 700 stream state was inconsistent. 701 */ 702 703-ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm)); 704+ZEXTERN long ZEXPORT inflateMark (z_streamp strm); 705 /* 706 This function returns two values, one in the lower 16 bits of the return 707 value, and the other in the remaining upper bits, obtained by shifting the 708@@ -1027,8 +1027,8 @@ 709 source stream state was inconsistent. 710 */ 711 712-ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, 713- gz_headerp head)); 714+ZEXTERN int ZEXPORT inflateGetHeader (z_streamp strm, 715+ gz_headerp head); 716 /* 717 inflateGetHeader() requests that gzip header information be stored in the 718 provided gz_header structure. inflateGetHeader() may be called after 719@@ -1068,8 +1068,8 @@ 720 */ 721 722 /* 723-ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, 724- unsigned char FAR *window)); 725+ZEXTERN int ZEXPORT inflateBackInit (z_streamp strm, int windowBits, 726+ unsigned char FAR *window); 727 728 Initialize the internal stream state for decompression using inflateBack() 729 calls. The fields zalloc, zfree and opaque in strm must be initialized 730@@ -1089,13 +1089,13 @@ 731 the version of the header file. 732 */ 733 734-typedef unsigned (*in_func) OF((void FAR *, 735- z_const unsigned char FAR * FAR *)); 736-typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); 737+typedef unsigned (*in_func) (void FAR *, 738+ z_const unsigned char FAR * FAR *); 739+typedef int (*out_func) (void FAR *, unsigned char FAR *, unsigned); 740 741-ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, 742+ZEXTERN int ZEXPORT inflateBack (z_streamp strm, 743 in_func in, void FAR *in_desc, 744- out_func out, void FAR *out_desc)); 745+ out_func out, void FAR *out_desc); 746 /* 747 inflateBack() does a raw inflate with a single call using a call-back 748 interface for input and output. This is potentially more efficient than 749@@ -1163,7 +1163,7 @@ 750 cannot return Z_OK. 751 */ 752 753-ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); 754+ZEXTERN int ZEXPORT inflateBackEnd (z_streamp strm); 755 /* 756 All memory allocated by inflateBackInit() is freed. 757 758@@ -1171,7 +1171,7 @@ 759 state was inconsistent. 760 */ 761 762-ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); 763+ZEXTERN uLong ZEXPORT zlibCompileFlags (void); 764 /* Return flags indicating compile-time options. 765 766 Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: 767@@ -1224,8 +1224,8 @@ 768 you need special options. 769 */ 770 771-ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, 772- const Bytef *source, uLong sourceLen)); 773+ZEXTERN int ZEXPORT compress (Bytef *dest, uLongf *destLen, 774+ const Bytef *source, uLong sourceLen); 775 /* 776 Compresses the source buffer into the destination buffer. sourceLen is 777 the byte length of the source buffer. Upon entry, destLen is the total size 778@@ -1239,9 +1239,9 @@ 779 buffer. 780 */ 781 782-ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, 783+ZEXTERN int ZEXPORT compress2 (Bytef *dest, uLongf *destLen, 784 const Bytef *source, uLong sourceLen, 785- int level)); 786+ int level); 787 /* 788 Compresses the source buffer into the destination buffer. The level 789 parameter has the same meaning as in deflateInit. sourceLen is the byte 790@@ -1255,15 +1255,15 @@ 791 Z_STREAM_ERROR if the level parameter is invalid. 792 */ 793 794-ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); 795+ZEXTERN uLong ZEXPORT compressBound (uLong sourceLen); 796 /* 797 compressBound() returns an upper bound on the compressed size after 798 compress() or compress2() on sourceLen bytes. It would be used before a 799 compress() or compress2() call to allocate the destination buffer. 800 */ 801 802-ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, 803- const Bytef *source, uLong sourceLen)); 804+ZEXTERN int ZEXPORT uncompress (Bytef *dest, uLongf *destLen, 805+ const Bytef *source, uLong sourceLen); 806 /* 807 Decompresses the source buffer into the destination buffer. sourceLen is 808 the byte length of the source buffer. Upon entry, destLen is the total size 809@@ -1280,8 +1280,8 @@ 810 buffer with the uncompressed data up to that point. 811 */ 812 813-ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest, uLongf *destLen, 814- const Bytef *source, uLong *sourceLen)); 815+ZEXTERN int ZEXPORT uncompress2 (Bytef *dest, uLongf *destLen, 816+ const Bytef *source, uLong *sourceLen); 817 /* 818 Same as uncompress, except that sourceLen is a pointer, where the 819 length of the source is *sourceLen. On return, *sourceLen is the number of 820@@ -1300,7 +1300,7 @@ 821 typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */ 822 823 /* 824-ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); 825+ZEXTERN gzFile ZEXPORT gzopen (const char *path, const char *mode); 826 827 Opens a gzip (.gz) file for reading or writing. The mode parameter is as 828 in fopen ("rb" or "wb") but can also include a compression level ("wb9") or 829@@ -1337,7 +1337,7 @@ 830 file could not be opened. 831 */ 832 833-ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); 834+ZEXTERN gzFile ZEXPORT gzdopen (int fd, const char *mode); 835 /* 836 gzdopen associates a gzFile with the file descriptor fd. File descriptors 837 are obtained from calls like open, dup, creat, pipe or fileno (if the file 838@@ -1360,7 +1360,7 @@ 839 will not detect if fd is invalid (unless fd is -1). 840 */ 841 842-ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); 843+ZEXTERN int ZEXPORT gzbuffer (gzFile file, unsigned size); 844 /* 845 Set the internal buffer size used by this library's functions. The 846 default buffer size is 8192 bytes. This function must be called after 847@@ -1376,7 +1376,7 @@ 848 too late. 849 */ 850 851-ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); 852+ZEXTERN int ZEXPORT gzsetparams (gzFile file, int level, int strategy); 853 /* 854 Dynamically update the compression level or strategy. See the description 855 of deflateInit2 for the meaning of these parameters. Previously provided 856@@ -1387,7 +1387,7 @@ 857 or Z_MEM_ERROR if there is a memory allocation error. 858 */ 859 860-ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); 861+ZEXTERN int ZEXPORT gzread (gzFile file, voidp buf, unsigned len); 862 /* 863 Reads the given number of uncompressed bytes from the compressed file. If 864 the input file is not in gzip format, gzread copies the given number of 865@@ -1417,8 +1417,8 @@ 866 Z_STREAM_ERROR. 867 */ 868 869-ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems, 870- gzFile file)); 871+ZEXTERN z_size_t ZEXPORT gzfread (voidp buf, z_size_t size, z_size_t nitems, 872+ gzFile file); 873 /* 874 Read up to nitems items of size size from file to buf, otherwise operating 875 as gzread() does. This duplicates the interface of stdio's fread(), with 876@@ -1443,16 +1443,16 @@ 877 file, reseting and retrying on end-of-file, when size is not 1. 878 */ 879 880-ZEXTERN int ZEXPORT gzwrite OF((gzFile file, 881- voidpc buf, unsigned len)); 882+ZEXTERN int ZEXPORT gzwrite (gzFile file, 883+ voidpc buf, unsigned len); 884 /* 885 Writes the given number of uncompressed bytes into the compressed file. 886 gzwrite returns the number of uncompressed bytes written or 0 in case of 887 error. 888 */ 889 890-ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size, 891- z_size_t nitems, gzFile file)); 892+ZEXTERN z_size_t ZEXPORT gzfwrite (voidpc buf, z_size_t size, 893+ z_size_t nitems, gzFile file); 894 /* 895 gzfwrite() writes nitems items of size size from buf to file, duplicating 896 the interface of stdio's fwrite(), with size_t request and return types. If 897@@ -1480,7 +1480,7 @@ 898 This can be determined using zlibCompileFlags(). 899 */ 900 901-ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); 902+ZEXTERN int ZEXPORT gzputs (gzFile file, const char *s); 903 /* 904 Writes the given null-terminated string to the compressed file, excluding 905 the terminating null character. 906@@ -1488,7 +1488,7 @@ 907 gzputs returns the number of characters written, or -1 in case of error. 908 */ 909 910-ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); 911+ZEXTERN char * ZEXPORT gzgets (gzFile file, char *buf, int len); 912 /* 913 Reads bytes from the compressed file until len-1 characters are read, or a 914 newline character is read and transferred to buf, or an end-of-file 915@@ -1501,13 +1501,13 @@ 916 buf are indeterminate. 917 */ 918 919-ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); 920+ZEXTERN int ZEXPORT gzputc (gzFile file, int c); 921 /* 922 Writes c, converted to an unsigned char, into the compressed file. gzputc 923 returns the value that was written, or -1 in case of error. 924 */ 925 926-ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); 927+ZEXTERN int ZEXPORT gzgetc (gzFile file); 928 /* 929 Reads one byte from the compressed file. gzgetc returns this byte or -1 930 in case of end of file or error. This is implemented as a macro for speed. 931@@ -1516,7 +1516,7 @@ 932 points to has been clobbered or not. 933 */ 934 935-ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); 936+ZEXTERN int ZEXPORT gzungetc (int c, gzFile file); 937 /* 938 Push one character back onto the stream to be read as the first character 939 on the next read. At least one character of push-back is allowed. 940@@ -1528,7 +1528,7 @@ 941 gzseek() or gzrewind(). 942 */ 943 944-ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); 945+ZEXTERN int ZEXPORT gzflush (gzFile file, int flush); 946 /* 947 Flushes all pending output into the compressed file. The parameter flush 948 is as in the deflate() function. The return value is the zlib error number 949@@ -1544,8 +1544,8 @@ 950 */ 951 952 /* 953-ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, 954- z_off_t offset, int whence)); 955+ZEXTERN z_off_t ZEXPORT gzseek (gzFile file, 956+ z_off_t offset, int whence); 957 958 Sets the starting position for the next gzread or gzwrite on the given 959 compressed file. The offset represents a number of bytes in the 960@@ -1563,7 +1563,7 @@ 961 would be before the current position. 962 */ 963 964-ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); 965+ZEXTERN int ZEXPORT gzrewind (gzFile file); 966 /* 967 Rewinds the given file. This function is supported only for reading. 968 969@@ -1571,7 +1571,7 @@ 970 */ 971 972 /* 973-ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); 974+ZEXTERN z_off_t ZEXPORT gztell (gzFile file); 975 976 Returns the starting position for the next gzread or gzwrite on the given 977 compressed file. This position represents a number of bytes in the 978@@ -1582,7 +1582,7 @@ 979 */ 980 981 /* 982-ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file)); 983+ZEXTERN z_off_t ZEXPORT gzoffset (gzFile file); 984 985 Returns the current offset in the file being read or written. This offset 986 includes the count of bytes that precede the gzip stream, for example when 987@@ -1591,7 +1591,7 @@ 988 for a progress indicator. On error, gzoffset() returns -1. 989 */ 990 991-ZEXTERN int ZEXPORT gzeof OF((gzFile file)); 992+ZEXTERN int ZEXPORT gzeof (gzFile file); 993 /* 994 Returns true (1) if the end-of-file indicator has been set while reading, 995 false (0) otherwise. Note that the end-of-file indicator is set only if the 996@@ -1606,7 +1606,7 @@ 997 has grown since the previous end of file was detected. 998 */ 999 1000-ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); 1001+ZEXTERN int ZEXPORT gzdirect (gzFile file); 1002 /* 1003 Returns true (1) if file is being copied directly while reading, or false 1004 (0) if file is a gzip stream being decompressed. 1005@@ -1627,7 +1627,7 @@ 1006 gzip file reading and decompression, which may not be desired.) 1007 */ 1008 1009-ZEXTERN int ZEXPORT gzclose OF((gzFile file)); 1010+ZEXTERN int ZEXPORT gzclose (gzFile file); 1011 /* 1012 Flushes all pending output if necessary, closes the compressed file and 1013 deallocates the (de)compression state. Note that once file is closed, you 1014@@ -1640,8 +1640,8 @@ 1015 last read ended in the middle of a gzip stream, or Z_OK on success. 1016 */ 1017 1018-ZEXTERN int ZEXPORT gzclose_r OF((gzFile file)); 1019-ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); 1020+ZEXTERN int ZEXPORT gzclose_r (gzFile file); 1021+ZEXTERN int ZEXPORT gzclose_w (gzFile file); 1022 /* 1023 Same as gzclose(), but gzclose_r() is only for use when reading, and 1024 gzclose_w() is only for use when writing or appending. The advantage to 1025@@ -1652,7 +1652,7 @@ 1026 zlib library. 1027 */ 1028 1029-ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); 1030+ZEXTERN const char * ZEXPORT gzerror (gzFile file, int *errnum); 1031 /* 1032 Returns the error message for the last error which occurred on the given 1033 compressed file. errnum is set to zlib error number. If an error occurred 1034@@ -1668,7 +1668,7 @@ 1035 functions above that do not distinguish those cases in their return values. 1036 */ 1037 1038-ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); 1039+ZEXTERN void ZEXPORT gzclearerr (gzFile file); 1040 /* 1041 Clears the error and end-of-file flags for file. This is analogous to the 1042 clearerr() function in stdio. This is useful for continuing to read a gzip 1043@@ -1685,7 +1685,7 @@ 1044 library. 1045 */ 1046 1047-ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); 1048+ZEXTERN uLong ZEXPORT adler32 (uLong adler, const Bytef *buf, uInt len); 1049 /* 1050 Update a running Adler-32 checksum with the bytes buf[0..len-1] and 1051 return the updated checksum. If buf is Z_NULL, this function returns the 1052@@ -1704,15 +1704,15 @@ 1053 if (adler != original_adler) error(); 1054 */ 1055 1056-ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef *buf, 1057- z_size_t len)); 1058+ZEXTERN uLong ZEXPORT adler32_z (uLong adler, const Bytef *buf, 1059+ z_size_t len); 1060 /* 1061 Same as adler32(), but with a size_t length. 1062 */ 1063 1064 /* 1065-ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, 1066- z_off_t len2)); 1067+ZEXTERN uLong ZEXPORT adler32_combine (uLong adler1, uLong adler2, 1068+ z_off_t len2); 1069 1070 Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 1071 and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for 1072@@ -1722,7 +1722,7 @@ 1073 negative, the result has no meaning or utility. 1074 */ 1075 1076-ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); 1077+ZEXTERN uLong ZEXPORT crc32 (uLong crc, const Bytef *buf, uInt len); 1078 /* 1079 Update a running CRC-32 with the bytes buf[0..len-1] and return the 1080 updated CRC-32. If buf is Z_NULL, this function returns the required 1081@@ -1739,14 +1739,14 @@ 1082 if (crc != original_crc) error(); 1083 */ 1084 1085-ZEXTERN uLong ZEXPORT crc32_z OF((uLong adler, const Bytef *buf, 1086- z_size_t len)); 1087+ZEXTERN uLong ZEXPORT crc32_z (uLong adler, const Bytef *buf, 1088+ z_size_t len); 1089 /* 1090 Same as crc32(), but with a size_t length. 1091 */ 1092 1093 /* 1094-ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); 1095+ZEXTERN uLong ZEXPORT crc32_combine (uLong crc1, uLong crc2, z_off_t len2); 1096 1097 Combine two CRC-32 check values into one. For two sequences of bytes, 1098 seq1 and seq2 with lengths len1 and len2, CRC-32 check values were 1099@@ -1761,20 +1761,20 @@ 1100 /* deflateInit and inflateInit are macros to allow checking the zlib version 1101 * and the compiler's view of z_stream: 1102 */ 1103-ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, 1104- const char *version, int stream_size)); 1105-ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, 1106- const char *version, int stream_size)); 1107-ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, 1108+ZEXTERN int ZEXPORT deflateInit_ (z_streamp strm, int level, 1109+ const char *version, int stream_size); 1110+ZEXTERN int ZEXPORT inflateInit_ (z_streamp strm, 1111+ const char *version, int stream_size); 1112+ZEXTERN int ZEXPORT deflateInit2_ (z_streamp strm, int level, int method, 1113 int windowBits, int memLevel, 1114 int strategy, const char *version, 1115- int stream_size)); 1116-ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, 1117- const char *version, int stream_size)); 1118-ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, 1119+ int stream_size); 1120+ZEXTERN int ZEXPORT inflateInit2_ (z_streamp strm, int windowBits, 1121+ const char *version, int stream_size); 1122+ZEXTERN int ZEXPORT inflateBackInit_ (z_streamp strm, int windowBits, 1123 unsigned char FAR *window, 1124 const char *version, 1125- int stream_size)); 1126+ int stream_size); 1127 #ifdef Z_PREFIX_SET 1128 # define z_deflateInit(strm, level) \ 1129 deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) 1130@@ -1819,7 +1819,7 @@ 1131 unsigned char *next; 1132 z_off64_t pos; 1133 }; 1134-ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ 1135+ZEXTERN int ZEXPORT gzgetc_ (gzFile file); /* backward compatibility */ 1136 #ifdef Z_PREFIX_SET 1137 # undef z_gzgetc 1138 # define z_gzgetc(g) \ 1139@@ -1836,12 +1836,12 @@ 1140 * without large file support, _LFS64_LARGEFILE must also be true 1141 */ 1142 #ifdef Z_LARGE64 1143- ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); 1144- ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); 1145- ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); 1146- ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); 1147- ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t)); 1148- ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t)); 1149+ ZEXTERN gzFile ZEXPORT gzopen64 (const char *, const char *); 1150+ ZEXTERN z_off64_t ZEXPORT gzseek64 (gzFile, z_off64_t, int); 1151+ ZEXTERN z_off64_t ZEXPORT gztell64 (gzFile); 1152+ ZEXTERN z_off64_t ZEXPORT gzoffset64 (gzFile); 1153+ ZEXTERN uLong ZEXPORT adler32_combine64 (uLong, uLong, z_off64_t); 1154+ ZEXTERN uLong ZEXPORT crc32_combine64 (uLong, uLong, z_off64_t); 1155 #endif 1156 1157 #if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) 1158@@ -1861,41 +1861,41 @@ 1159 # define crc32_combine crc32_combine64 1160 # endif 1161 # ifndef Z_LARGE64 1162- ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); 1163- ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int)); 1164- ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile)); 1165- ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile)); 1166- ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); 1167- ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); 1168+ ZEXTERN gzFile ZEXPORT gzopen64 (const char *, const char *); 1169+ ZEXTERN z_off_t ZEXPORT gzseek64 (gzFile, z_off_t, int); 1170+ ZEXTERN z_off_t ZEXPORT gztell64 (gzFile); 1171+ ZEXTERN z_off_t ZEXPORT gzoffset64 (gzFile); 1172+ ZEXTERN uLong ZEXPORT adler32_combine64 (uLong, uLong, z_off_t); 1173+ ZEXTERN uLong ZEXPORT crc32_combine64 (uLong, uLong, z_off_t); 1174 # endif 1175 #else 1176- ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *)); 1177- ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int)); 1178- ZEXTERN z_off_t ZEXPORT gztell OF((gzFile)); 1179- ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile)); 1180- ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); 1181- ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); 1182+ ZEXTERN gzFile ZEXPORT gzopen (const char *, const char *); 1183+ ZEXTERN z_off_t ZEXPORT gzseek (gzFile, z_off_t, int); 1184+ ZEXTERN z_off_t ZEXPORT gztell (gzFile); 1185+ ZEXTERN z_off_t ZEXPORT gzoffset (gzFile); 1186+ ZEXTERN uLong ZEXPORT adler32_combine (uLong, uLong, z_off_t); 1187+ ZEXTERN uLong ZEXPORT crc32_combine (uLong, uLong, z_off_t); 1188 #endif 1189 1190 #else /* Z_SOLO */ 1191 1192- ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); 1193- ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); 1194+ ZEXTERN uLong ZEXPORT adler32_combine (uLong, uLong, z_off_t); 1195+ ZEXTERN uLong ZEXPORT crc32_combine (uLong, uLong, z_off_t); 1196 1197 #endif /* !Z_SOLO */ 1198 1199 /* undocumented functions */ 1200-ZEXTERN const char * ZEXPORT zError OF((int)); 1201-ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp)); 1202-ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void)); 1203-ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); 1204-ZEXTERN int ZEXPORT inflateValidate OF((z_streamp, int)); 1205-ZEXTERN unsigned long ZEXPORT inflateCodesUsed OF ((z_streamp)); 1206-ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp)); 1207-ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp)); 1208+ZEXTERN const char * ZEXPORT zError (int); 1209+ZEXTERN int ZEXPORT inflateSyncPoint (z_streamp); 1210+ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table (void); 1211+ZEXTERN int ZEXPORT inflateUndermine (z_streamp, int); 1212+ZEXTERN int ZEXPORT inflateValidate (z_streamp, int); 1213+ZEXTERN unsigned long ZEXPORT inflateCodesUsed (z_streamp); 1214+ZEXTERN int ZEXPORT inflateResetKeep (z_streamp); 1215+ZEXTERN int ZEXPORT deflateResetKeep (z_streamp); 1216 #if (defined(_WIN32) || defined(__CYGWIN__)) && !defined(Z_SOLO) 1217-ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path, 1218- const char *mode)); 1219+ZEXTERN gzFile ZEXPORT gzopen_w (const wchar_t *path, 1220+ const char *mode); 1221 #endif 1222 #if defined(STDC) || defined(Z_HAVE_STDARG_H) 1223 # ifndef Z_SOLO 1224diff -ur zlib-1.2.11/zutil.c zlib-1.2.11__patched/zutil.c 1225--- zlib-1.2.11/zutil.c 2017-01-15 18:29:40.000000000 +0100 1226+++ zlib-1.2.11__patched/zutil.c 2019-10-22 17:36:13.397965240 +0200 1227@@ -297,9 +297,9 @@ 1228 #ifndef MY_ZCALLOC /* Any system without a special alloc function */ 1229 1230 #ifndef STDC 1231-extern voidp malloc OF((uInt size)); 1232-extern voidp calloc OF((uInt items, uInt size)); 1233-extern void free OF((voidpf ptr)); 1234+extern voidp malloc (uInt size); 1235+extern voidp calloc (uInt items, uInt size); 1236+extern void free (voidpf ptr); 1237 #endif 1238 1239 voidpf ZLIB_INTERNAL zcalloc (opaque, items, size) 1240diff -ur zlib-1.2.11/zutil.h zlib-1.2.11__patched/zutil.h 1241--- zlib-1.2.11/zutil.h 2017-01-01 08:37:10.000000000 +0100 1242+++ zlib-1.2.11__patched/zutil.h 2019-10-22 17:36:13.397965240 +0200 1243@@ -188,8 +188,8 @@ 1244 /* provide prototypes for these when building zlib without LFS */ 1245 #if !defined(_WIN32) && \ 1246 (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0) 1247- ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); 1248- ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); 1249+ ZEXTERN uLong ZEXPORT adler32_combine64 (uLong, uLong, z_off_t); 1250+ ZEXTERN uLong ZEXPORT crc32_combine64 (uLong, uLong, z_off_t); 1251 #endif 1252 1253 /* common defaults */ 1254@@ -228,16 +228,16 @@ 1255 # define zmemzero(dest, len) memset(dest, 0, len) 1256 # endif 1257 #else 1258- void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)); 1259- int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len)); 1260- void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len)); 1261+ void ZLIB_INTERNAL zmemcpy (Bytef* dest, const Bytef* source, uInt len); 1262+ int ZLIB_INTERNAL zmemcmp (const Bytef* s1, const Bytef* s2, uInt len); 1263+ void ZLIB_INTERNAL zmemzero (Bytef* dest, uInt len); 1264 #endif 1265 1266 /* Diagnostic functions */ 1267 #ifdef ZLIB_DEBUG 1268 # include <stdio.h> 1269 extern int ZLIB_INTERNAL z_verbose; 1270- extern void ZLIB_INTERNAL z_error OF((char *m)); 1271+ extern void ZLIB_INTERNAL z_error (char *m); 1272 # define Assert(cond,msg) {if(!(cond)) z_error(msg);} 1273 # define Trace(x) {if (z_verbose>=0) fprintf x ;} 1274 # define Tracev(x) {if (z_verbose>0) fprintf x ;} 1275@@ -254,9 +254,9 @@ 1276 #endif 1277 1278 #ifndef Z_SOLO 1279- voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items, 1280- unsigned size)); 1281- void ZLIB_INTERNAL zcfree OF((voidpf opaque, voidpf ptr)); 1282+ voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, 1283+ unsigned size); 1284+ void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr); 1285 #endif 1286 1287 #define ZALLOC(strm, items, size) \ 1288