StarMirror/sandboxed-api
1
0
Fork 0
mirror of https://github.com/google/sandboxed-api.git synced 2024-03-22 13:11:30 +08:00
Code Issues Projects Releases Wiki Activity
5de6b84111
sandboxed-api/sandboxed_api/bazel/external/zlib.patch
Christian Blichmann 254abe04fe Use unified diff for zlib patch 
PiperOrigin-RevId: 276075544
Change-Id: Icf06e360a400834e7304c2bde34954dbc71f135f
2019-10-22 09:04:29 -07:00

1288 lines
53 KiB
Diff
Raw Blame History

diff -ur zlib-1.2.11/adler32.c zlib-1.2.11__patched/adler32.c
--- zlib-1.2.11/adler32.c 2017-01-01 08:37:10.000000000 +0100
+++ zlib-1.2.11__patched/adler32.c 2019-10-22 17:36:13.389965314 +0200
@@ -7,7 +7,7 @@
#include "zutil.h"
-local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
+local uLong adler32_combine_ (uLong adler1, uLong adler2, z_off64_t len2);
#define BASE 65521U /* largest prime smaller than 65536 */
#define NMAX 5552
diff -ur zlib-1.2.11/crc32.c zlib-1.2.11__patched/crc32.c
--- zlib-1.2.11/crc32.c 2017-01-01 08:37:10.000000000 +0100
+++ zlib-1.2.11__patched/crc32.c 2019-10-22 17:36:13.393965277 +0200
@@ -35,29 +35,29 @@
# define BYFOUR
#endif
#ifdef BYFOUR
- local unsigned long crc32_little OF((unsigned long,
- const unsigned char FAR *, z_size_t));
- local unsigned long crc32_big OF((unsigned long,
- const unsigned char FAR *, z_size_t));
+ local unsigned long crc32_little (unsigned long,
+ const unsigned char FAR *, z_size_t);
+ local unsigned long crc32_big (unsigned long,
+ const unsigned char FAR *, z_size_t);
# define TBLS 8
#else
# define TBLS 1
#endif /* BYFOUR */
/* Local functions for crc concatenation */
-local unsigned long gf2_matrix_times OF((unsigned long *mat,
- unsigned long vec));
-local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
-local uLong crc32_combine_ OF((uLong crc1, uLong crc2, z_off64_t len2));
+local unsigned long gf2_matrix_times (unsigned long *mat,
+ unsigned long vec);
+local void gf2_matrix_square (unsigned long *square, unsigned long *mat);
+local uLong crc32_combine_ (uLong crc1, uLong crc2, z_off64_t len2);
#ifdef DYNAMIC_CRC_TABLE
local volatile int crc_table_empty = 1;
local z_crc_t FAR crc_table[TBLS][256];
-local void make_crc_table OF((void));
+local void make_crc_table (void);
#ifdef MAKECRCH
- local void write_table OF((FILE *, const z_crc_t FAR *));
+ local void write_table (FILE *, const z_crc_t FAR *);
#endif /* MAKECRCH */
/*
Generate tables for a byte-wise 32-bit CRC calculation on the polynomial:
diff -ur zlib-1.2.11/deflate.c zlib-1.2.11__patched/deflate.c
--- zlib-1.2.11/deflate.c 2017-01-15 18:29:40.000000000 +0100
+++ zlib-1.2.11__patched/deflate.c 2019-10-22 17:36:13.393965277 +0200
@@ -70,34 +70,34 @@
finish_done /* finish done, accept no more input or output */
} block_state;
-typedef block_state (*compress_func) OF((deflate_state *s, int flush));
+typedef block_state (*compress_func) (deflate_state *s, int flush);
/* Compression function. Returns the block state after the call. */
-local int deflateStateCheck OF((z_streamp strm));
-local void slide_hash OF((deflate_state *s));
-local void fill_window OF((deflate_state *s));
-local block_state deflate_stored OF((deflate_state *s, int flush));
-local block_state deflate_fast OF((deflate_state *s, int flush));
+local int deflateStateCheck (z_streamp strm);
+local void slide_hash (deflate_state *s);
+local void fill_window (deflate_state *s);
+local block_state deflate_stored (deflate_state *s, int flush);
+local block_state deflate_fast (deflate_state *s, int flush);
#ifndef FASTEST
-local block_state deflate_slow OF((deflate_state *s, int flush));
+local block_state deflate_slow (deflate_state *s, int flush);
#endif
-local block_state deflate_rle OF((deflate_state *s, int flush));
-local block_state deflate_huff OF((deflate_state *s, int flush));
-local void lm_init OF((deflate_state *s));
-local void putShortMSB OF((deflate_state *s, uInt b));
-local void flush_pending OF((z_streamp strm));
-local unsigned read_buf OF((z_streamp strm, Bytef *buf, unsigned size));
+local block_state deflate_rle (deflate_state *s, int flush);
+local block_state deflate_huff (deflate_state *s, int flush);
+local void lm_init (deflate_state *s);
+local void putShortMSB (deflate_state *s, uInt b);
+local void flush_pending (z_streamp strm);
+local unsigned read_buf (z_streamp strm, Bytef *buf, unsigned size);
#ifdef ASMV
# pragma message("Assembler code may have bugs -- use at your own risk")
- void match_init OF((void)); /* asm code initialization */
- uInt longest_match OF((deflate_state *s, IPos cur_match));
+ void match_init (void); /* asm code initialization */
+ uInt longest_match (deflate_state *s, IPos cur_match);
#else
-local uInt longest_match OF((deflate_state *s, IPos cur_match));
+local uInt longest_match (deflate_state *s, IPos cur_match);
#endif
#ifdef ZLIB_DEBUG
-local void check_match OF((deflate_state *s, IPos start, IPos match,
- int length));
+local void check_match (deflate_state *s, IPos start, IPos match,
+ int length);
#endif
/* ===========================================================================
diff -ur zlib-1.2.11/deflate.h zlib-1.2.11__patched/deflate.h
--- zlib-1.2.11/deflate.h 2017-01-01 08:37:10.000000000 +0100
+++ zlib-1.2.11__patched/deflate.h 2019-10-22 17:36:13.393965277 +0200
@@ -296,14 +296,14 @@
memory checker errors from longest match routines */
/* in trees.c */
-void ZLIB_INTERNAL _tr_init OF((deflate_state *s));
-int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
-void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf,
- ulg stored_len, int last));
-void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s));
-void ZLIB_INTERNAL _tr_align OF((deflate_state *s));
-void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
- ulg stored_len, int last));
+void ZLIB_INTERNAL _tr_init (deflate_state *s);
+int ZLIB_INTERNAL _tr_tally (deflate_state *s, unsigned dist, unsigned lc);
+void ZLIB_INTERNAL _tr_flush_block (deflate_state *s, charf *buf,
+ ulg stored_len, int last);
+void ZLIB_INTERNAL _tr_flush_bits (deflate_state *s);
+void ZLIB_INTERNAL _tr_align (deflate_state *s);
+void ZLIB_INTERNAL _tr_stored_block (deflate_state *s, charf *buf,
+ ulg stored_len, int last);
#define d_code(dist) \
((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
diff -ur zlib-1.2.11/gzguts.h zlib-1.2.11__patched/gzguts.h
--- zlib-1.2.11/gzguts.h 2017-01-01 08:37:10.000000000 +0100
+++ zlib-1.2.11__patched/gzguts.h 2019-10-22 17:36:13.393965277 +0200
@@ -119,8 +119,8 @@
/* gz* functions always use library allocation functions */
#ifndef STDC
- extern voidp malloc OF((uInt size));
- extern void free OF((voidpf ptr));
+ extern voidp malloc (uInt size);
+ extern void free (voidpf ptr);
#endif
/* get errno and strerror definition */
@@ -138,10 +138,10 @@
/* provide prototypes for these when building zlib without LFS */
#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0
- ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
- ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
- ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
- ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
+ ZEXTERN gzFile ZEXPORT gzopen64 (const char *, const char *);
+ ZEXTERN z_off64_t ZEXPORT gzseek64 (gzFile, z_off64_t, int);
+ ZEXTERN z_off64_t ZEXPORT gztell64 (gzFile);
+ ZEXTERN z_off64_t ZEXPORT gzoffset64 (gzFile);
#endif
/* default memLevel */
@@ -202,9 +202,9 @@
typedef gz_state FAR *gz_statep;
/* shared functions */
-void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *));
+void ZLIB_INTERNAL gz_error (gz_statep, int, const char *);
#if defined UNDER_CE
-char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error));
+char ZLIB_INTERNAL *gz_strwinerror (DWORD error);
#endif
/* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t
@@ -213,6 +213,6 @@
#ifdef INT_MAX
# define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX)
#else
-unsigned ZLIB_INTERNAL gz_intmax OF((void));
+unsigned ZLIB_INTERNAL gz_intmax (void);
# define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax())
#endif
diff -ur zlib-1.2.11/gzlib.c zlib-1.2.11__patched/gzlib.c
--- zlib-1.2.11/gzlib.c 2017-01-15 18:29:40.000000000 +0100
+++ zlib-1.2.11__patched/gzlib.c 2019-10-22 17:36:13.393965277 +0200
@@ -16,8 +16,8 @@
#endif
/* Local functions */
-local void gz_reset OF((gz_statep));
-local gzFile gz_open OF((const void *, int, const char *));
+local void gz_reset (gz_statep);
+local gzFile gz_open (const void *, int, const char *);
#if defined UNDER_CE
diff -ur zlib-1.2.11/gzread.c zlib-1.2.11__patched/gzread.c
--- zlib-1.2.11/gzread.c 2017-01-01 08:37:10.000000000 +0100
+++ zlib-1.2.11__patched/gzread.c 2019-10-22 17:36:13.393965277 +0200
@@ -6,13 +6,13 @@
#include "gzguts.h"
/* Local functions */
-local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *));
-local int gz_avail OF((gz_statep));
-local int gz_look OF((gz_statep));
-local int gz_decomp OF((gz_statep));
-local int gz_fetch OF((gz_statep));
-local int gz_skip OF((gz_statep, z_off64_t));
-local z_size_t gz_read OF((gz_statep, voidp, z_size_t));
+local int gz_load (gz_statep, unsigned char *, unsigned, unsigned *);
+local int gz_avail (gz_statep);
+local int gz_look (gz_statep);
+local int gz_decomp (gz_statep);
+local int gz_fetch (gz_statep);
+local int gz_skip (gz_statep, z_off64_t);
+local z_size_t gz_read (gz_statep, voidp, z_size_t);
/* Use read() to load a buffer -- return -1 on error, otherwise 0. Read from
state->fd, and update state->eof, state->err, and state->msg as appropriate.
diff -ur zlib-1.2.11/gzwrite.c zlib-1.2.11__patched/gzwrite.c
--- zlib-1.2.11/gzwrite.c 2017-01-15 18:29:40.000000000 +0100
+++ zlib-1.2.11__patched/gzwrite.c 2019-10-22 17:36:13.393965277 +0200
@@ -6,10 +6,10 @@
#include "gzguts.h"
/* Local functions */
-local int gz_init OF((gz_statep));
-local int gz_comp OF((gz_statep, int));
-local int gz_zero OF((gz_statep, z_off64_t));
-local z_size_t gz_write OF((gz_statep, voidpc, z_size_t));
+local int gz_init (gz_statep);
+local int gz_comp (gz_statep, int);
+local int gz_zero (gz_statep, z_off64_t);
+local z_size_t gz_write (gz_statep, voidpc, z_size_t);
/* Initialize state for writing a gzip file. Mark initialization by setting
state->size to non-zero. Return -1 on a memory allocation failure, or 0 on
diff -ur zlib-1.2.11/infback.c zlib-1.2.11__patched/infback.c
--- zlib-1.2.11/infback.c 2017-01-01 08:37:10.000000000 +0100
+++ zlib-1.2.11__patched/infback.c 2019-10-22 17:36:13.393965277 +0200
@@ -16,7 +16,7 @@
#include "inffast.h"
/* function prototypes */
-local void fixedtables OF((struct inflate_state FAR *state));
+local void fixedtables (struct inflate_state FAR *state);
/*
strm provides memory allocation functions in zalloc and zfree, or
diff -ur zlib-1.2.11/inffast.h zlib-1.2.11__patched/inffast.h
--- zlib-1.2.11/inffast.h 2010-04-19 06:16:01.000000000 +0200
+++ zlib-1.2.11__patched/inffast.h 2019-10-22 17:36:13.393965277 +0200
@@ -8,4 +8,4 @@
subject to change. Applications should only use zlib.h.
*/
-void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start));
+void ZLIB_INTERNAL inflate_fast (z_streamp strm, unsigned start);
diff -ur zlib-1.2.11/inflate.c zlib-1.2.11__patched/inflate.c
--- zlib-1.2.11/inflate.c 2017-01-01 08:37:10.000000000 +0100
+++ zlib-1.2.11__patched/inflate.c 2019-10-22 17:36:13.397965240 +0200
@@ -92,15 +92,15 @@
#endif
/* function prototypes */
-local int inflateStateCheck OF((z_streamp strm));
-local void fixedtables OF((struct inflate_state FAR *state));
-local int updatewindow OF((z_streamp strm, const unsigned char FAR *end,
- unsigned copy));
+local int inflateStateCheck (z_streamp strm);
+local void fixedtables (struct inflate_state FAR *state);
+local int updatewindow (z_streamp strm, const unsigned char FAR *end,
+ unsigned copy);
#ifdef BUILDFIXED
- void makefixed OF((void));
+ void makefixed (void);
#endif
-local unsigned syncsearch OF((unsigned FAR *have, const unsigned char FAR *buf,
- unsigned len));
+local unsigned syncsearch (unsigned FAR *have, const unsigned char FAR *buf,
+ unsigned len);
local int inflateStateCheck(strm)
z_streamp strm;
diff -ur zlib-1.2.11/inftrees.h zlib-1.2.11__patched/inftrees.h
--- zlib-1.2.11/inftrees.h 2010-04-19 06:15:26.000000000 +0200
+++ zlib-1.2.11__patched/inftrees.h 2019-10-22 17:36:13.397965240 +0200
@@ -57,6 +57,6 @@
DISTS
} codetype;
-int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens,
+int ZLIB_INTERNAL inflate_table (codetype type, unsigned short FAR *lens,
unsigned codes, code FAR * FAR *table,
- unsigned FAR *bits, unsigned short FAR *work));
+ unsigned FAR *bits, unsigned short FAR *work);
diff -ur zlib-1.2.11/trees.c zlib-1.2.11__patched/trees.c
--- zlib-1.2.11/trees.c 2017-01-15 18:07:14.000000000 +0100
+++ zlib-1.2.11__patched/trees.c 2019-10-22 17:36:13.397965240 +0200
@@ -135,26 +135,26 @@
* Local (static) routines in this file.
*/
-local void tr_static_init OF((void));
-local void init_block OF((deflate_state *s));
-local void pqdownheap OF((deflate_state *s, ct_data *tree, int k));
-local void gen_bitlen OF((deflate_state *s, tree_desc *desc));
-local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count));
-local void build_tree OF((deflate_state *s, tree_desc *desc));
-local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code));
-local void send_tree OF((deflate_state *s, ct_data *tree, int max_code));
-local int build_bl_tree OF((deflate_state *s));
-local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes,
- int blcodes));
-local void compress_block OF((deflate_state *s, const ct_data *ltree,
- const ct_data *dtree));
-local int detect_data_type OF((deflate_state *s));
-local unsigned bi_reverse OF((unsigned value, int length));
-local void bi_windup OF((deflate_state *s));
-local void bi_flush OF((deflate_state *s));
+local void tr_static_init (void);
+local void init_block (deflate_state *s);
+local void pqdownheap (deflate_state *s, ct_data *tree, int k);
+local void gen_bitlen (deflate_state *s, tree_desc *desc);
+local void gen_codes (ct_data *tree, int max_code, ushf *bl_count);
+local void build_tree (deflate_state *s, tree_desc *desc);
+local void scan_tree (deflate_state *s, ct_data *tree, int max_code);
+local void send_tree (deflate_state *s, ct_data *tree, int max_code);
+local int build_bl_tree (deflate_state *s);
+local void send_all_trees (deflate_state *s, int lcodes, int dcodes,
+ int blcodes);
+local void compress_block (deflate_state *s, const ct_data *ltree,
+ const ct_data *dtree);
+local int detect_data_type (deflate_state *s);
+local unsigned bi_reverse (unsigned value, int length);
+local void bi_windup (deflate_state *s);
+local void bi_flush (deflate_state *s);
#ifdef GEN_TREES_H
-local void gen_trees_header OF((void));
+local void gen_trees_header (void);
#endif
#ifndef ZLIB_DEBUG
@@ -181,7 +181,7 @@
* IN assertion: length <= 16 and value fits in length bits.
*/
#ifdef ZLIB_DEBUG
-local void send_bits OF((deflate_state *s, int value, int length));
+local void send_bits (deflate_state *s, int value, int length);
local void send_bits(s, value, length)
deflate_state *s;
diff -ur zlib-1.2.11/zconf.h zlib-1.2.11__patched/zconf.h
--- zlib-1.2.11/zconf.h 2017-01-01 08:37:10.000000000 +0100
+++ zlib-1.2.11__patched/zconf.h 2019-10-22 17:36:13.397965240 +0200
@@ -287,9 +287,9 @@
#ifndef OF /* function prototypes */
# ifdef STDC
-# define OF(args) args
+# define args args
# else
-# define OF(args) ()
+# define args ()
# endif
#endif
diff -ur zlib-1.2.11/zconf.h.cmakein zlib-1.2.11__patched/zconf.h.cmakein
--- zlib-1.2.11/zconf.h.cmakein 2017-01-01 08:37:10.000000000 +0100
+++ zlib-1.2.11__patched/zconf.h.cmakein 2019-10-22 17:36:13.397965240 +0200
@@ -289,9 +289,9 @@
#ifndef OF /* function prototypes */
# ifdef STDC
-# define OF(args) args
+# define args args
# else
-# define OF(args) ()
+# define args ()
# endif
#endif
diff -ur zlib-1.2.11/zconf.h.in zlib-1.2.11__patched/zconf.h.in
--- zlib-1.2.11/zconf.h.in 2017-01-01 08:37:10.000000000 +0100
+++ zlib-1.2.11__patched/zconf.h.in 2019-10-22 17:36:13.397965240 +0200
@@ -287,9 +287,9 @@
#ifndef OF /* function prototypes */
# ifdef STDC
-# define OF(args) args
+# define args args
# else
-# define OF(args) ()
+# define args ()
# endif
#endif
diff -ur zlib-1.2.11/zlib.h zlib-1.2.11__patched/zlib.h
--- zlib-1.2.11/zlib.h 2017-01-15 18:29:40.000000000 +0100
+++ zlib-1.2.11__patched/zlib.h 2019-10-22 17:36:13.397965240 +0200
@@ -78,8 +78,8 @@
even in the case of corrupted input.
*/
-typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size));
-typedef void (*free_func) OF((voidpf opaque, voidpf address));
+typedef voidpf (*alloc_func) (voidpf opaque, uInt items, uInt size);
+typedef void (*free_func) (voidpf opaque, voidpf address);
struct internal_state;
@@ -217,7 +217,7 @@
/* basic functions */
-ZEXTERN const char * ZEXPORT zlibVersion OF((void));
+ZEXTERN const char * ZEXPORT zlibVersion (void);
/* The application can compare zlibVersion and ZLIB_VERSION for consistency.
If the first character differs, the library code actually used is not
compatible with the zlib.h header file used by the application. This check
@@ -225,7 +225,7 @@
*/
/*
-ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
+ZEXTERN int ZEXPORT deflateInit (z_streamp strm, int level);
Initializes the internal stream state for compression. The fields
zalloc, zfree and opaque must be initialized before by the caller. If
@@ -247,7 +247,7 @@
*/
-ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
+ZEXTERN int ZEXPORT deflate (z_streamp strm, int flush);
/*
deflate compresses as much data as possible, and stops when the input
buffer becomes empty or the output buffer becomes full. It may introduce
@@ -360,7 +360,7 @@
*/
-ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
+ZEXTERN int ZEXPORT deflateEnd (z_streamp strm);
/*
All dynamically allocated data structures for this stream are freed.
This function discards any unprocessed input and does not flush any pending
@@ -375,7 +375,7 @@
/*
-ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
+ZEXTERN int ZEXPORT inflateInit (z_streamp strm);
Initializes the internal stream state for decompression. The fields
next_in, avail_in, zalloc, zfree and opaque must be initialized before by
@@ -397,7 +397,7 @@
*/
-ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
+ZEXTERN int ZEXPORT inflate (z_streamp strm, int flush);
/*
inflate decompresses as much data as possible, and stops when the input
buffer becomes empty or the output buffer becomes full. It may introduce
@@ -517,7 +517,7 @@
*/
-ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
+ZEXTERN int ZEXPORT inflateEnd (z_streamp strm);
/*
All dynamically allocated data structures for this stream are freed.
This function discards any unprocessed input and does not flush any pending
@@ -535,12 +535,12 @@
*/
/*
-ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
+ZEXTERN int ZEXPORT deflateInit2 (z_streamp strm,
int level,
int method,
int windowBits,
int memLevel,
- int strategy));
+ int strategy);
This is another version of deflateInit with more compression options. The
fields next_in, zalloc, zfree and opaque must be initialized before by the
@@ -608,9 +608,9 @@
compression: this will be done by deflate().
*/
-ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
+ZEXTERN int ZEXPORT deflateSetDictionary (z_streamp strm,
const Bytef *dictionary,
- uInt dictLength));
+ uInt dictLength);
/*
Initializes the compression dictionary from the given byte sequence
without producing any compressed output. When using the zlib format, this
@@ -652,9 +652,9 @@
not perform any compression: this will be done by deflate().
*/
-ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm,
+ZEXTERN int ZEXPORT deflateGetDictionary (z_streamp strm,
Bytef *dictionary,
- uInt *dictLength));
+ uInt *dictLength);
/*
Returns the sliding dictionary being maintained by deflate. dictLength is
set to the number of bytes in the dictionary, and that many bytes are copied
@@ -674,8 +674,8 @@
stream state is inconsistent.
*/
-ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest,
- z_streamp source));
+ZEXTERN int ZEXPORT deflateCopy (z_streamp dest,
+ z_streamp source);
/*
Sets the destination stream as a complete copy of the source stream.
@@ -692,7 +692,7 @@
destination.
*/
-ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
+ZEXTERN int ZEXPORT deflateReset (z_streamp strm);
/*
This function is equivalent to deflateEnd followed by deflateInit, but
does not free and reallocate the internal compression state. The stream
@@ -703,9 +703,9 @@
stream state was inconsistent (such as zalloc or state being Z_NULL).
*/
-ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
+ZEXTERN int ZEXPORT deflateParams (z_streamp strm,
int level,
- int strategy));
+ int strategy);
/*
Dynamically update the compression level and compression strategy. The
interpretation of level and strategy is as in deflateInit2(). This can be
@@ -740,11 +740,11 @@
retried with more output space.
*/
-ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm,
+ZEXTERN int ZEXPORT deflateTune (z_streamp strm,
int good_length,
int max_lazy,
int nice_length,
- int max_chain));
+ int max_chain);
/*
Fine tune deflate's internal compression parameters. This should only be
used by someone who understands the algorithm used by zlib's deflate for
@@ -757,8 +757,8 @@
returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream.
*/
-ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
- uLong sourceLen));
+ZEXTERN uLong ZEXPORT deflateBound (z_streamp strm,
+ uLong sourceLen);
/*
deflateBound() returns an upper bound on the compressed size after
deflation of sourceLen bytes. It must be called after deflateInit() or
@@ -772,9 +772,9 @@
than Z_FINISH or Z_NO_FLUSH are used.
*/
-ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm,
+ZEXTERN int ZEXPORT deflatePending (z_streamp strm,
unsigned *pending,
- int *bits));
+ int *bits);
/*
deflatePending() returns the number of bytes and bits of output that have
been generated, but not yet provided in the available output. The bytes not
@@ -787,9 +787,9 @@
stream state was inconsistent.
*/
-ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
+ZEXTERN int ZEXPORT deflatePrime (z_streamp strm,
int bits,
- int value));
+ int value);
/*
deflatePrime() inserts bits in the deflate output stream. The intent
is that this function is used to start off the deflate output with the bits
@@ -804,8 +804,8 @@
source stream state was inconsistent.
*/
-ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm,
- gz_headerp head));
+ZEXTERN int ZEXPORT deflateSetHeader (z_streamp strm,
+ gz_headerp head);
/*
deflateSetHeader() provides gzip header information for when a gzip
stream is requested by deflateInit2(). deflateSetHeader() may be called
@@ -829,8 +829,8 @@
*/
/*
-ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
- int windowBits));
+ZEXTERN int ZEXPORT inflateInit2 (z_streamp strm,
+ int windowBits);
This is another version of inflateInit with an extra parameter. The
fields next_in, avail_in, zalloc, zfree and opaque must be initialized
@@ -881,9 +881,9 @@
deferred until inflate() is called.
*/
-ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
+ZEXTERN int ZEXPORT inflateSetDictionary (z_streamp strm,
const Bytef *dictionary,
- uInt dictLength));
+ uInt dictLength);
/*
Initializes the decompression dictionary from the given uncompressed byte
sequence. This function must be called immediately after a call of inflate,
@@ -904,9 +904,9 @@
inflate().
*/
-ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm,
+ZEXTERN int ZEXPORT inflateGetDictionary (z_streamp strm,
Bytef *dictionary,
- uInt *dictLength));
+ uInt *dictLength);
/*
Returns the sliding dictionary being maintained by inflate. dictLength is
set to the number of bytes in the dictionary, and that many bytes are copied
@@ -919,7 +919,7 @@
stream state is inconsistent.
*/
-ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
+ZEXTERN int ZEXPORT inflateSync (z_streamp strm);
/*
Skips invalid compressed data until a possible full flush point (see above
for the description of deflate with Z_FULL_FLUSH) can be found, or until all
@@ -938,8 +938,8 @@
input each time, until success or end of the input data.
*/
-ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
- z_streamp source));
+ZEXTERN int ZEXPORT inflateCopy (z_streamp dest,
+ z_streamp source);
/*
Sets the destination stream as a complete copy of the source stream.
@@ -954,7 +954,7 @@
destination.
*/
-ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
+ZEXTERN int ZEXPORT inflateReset (z_streamp strm);
/*
This function is equivalent to inflateEnd followed by inflateInit,
but does not free and reallocate the internal decompression state. The
@@ -964,8 +964,8 @@
stream state was inconsistent (such as zalloc or state being Z_NULL).
*/
-ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm,
- int windowBits));
+ZEXTERN int ZEXPORT inflateReset2 (z_streamp strm,
+ int windowBits);
/*
This function is the same as inflateReset, but it also permits changing
the wrap and window size requests. The windowBits parameter is interpreted
@@ -978,9 +978,9 @@
the windowBits parameter is invalid.
*/
-ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm,
+ZEXTERN int ZEXPORT inflatePrime (z_streamp strm,
int bits,
- int value));
+ int value);
/*
This function inserts bits in the inflate input stream. The intent is
that this function is used to start inflating at a bit position in the
@@ -999,7 +999,7 @@
stream state was inconsistent.
*/
-ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm));
+ZEXTERN long ZEXPORT inflateMark (z_streamp strm);
/*
This function returns two values, one in the lower 16 bits of the return
value, and the other in the remaining upper bits, obtained by shifting the
@@ -1027,8 +1027,8 @@
source stream state was inconsistent.
*/
-ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm,
- gz_headerp head));
+ZEXTERN int ZEXPORT inflateGetHeader (z_streamp strm,
+ gz_headerp head);
/*
inflateGetHeader() requests that gzip header information be stored in the
provided gz_header structure. inflateGetHeader() may be called after
@@ -1068,8 +1068,8 @@
*/
/*
-ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits,
- unsigned char FAR *window));
+ZEXTERN int ZEXPORT inflateBackInit (z_streamp strm, int windowBits,
+ unsigned char FAR *window);
Initialize the internal stream state for decompression using inflateBack()
calls. The fields zalloc, zfree and opaque in strm must be initialized
@@ -1089,13 +1089,13 @@
the version of the header file.
*/
-typedef unsigned (*in_func) OF((void FAR *,
- z_const unsigned char FAR * FAR *));
-typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned));
+typedef unsigned (*in_func) (void FAR *,
+ z_const unsigned char FAR * FAR *);
+typedef int (*out_func) (void FAR *, unsigned char FAR *, unsigned);
-ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm,
+ZEXTERN int ZEXPORT inflateBack (z_streamp strm,
in_func in, void FAR *in_desc,
- out_func out, void FAR *out_desc));
+ out_func out, void FAR *out_desc);
/*
inflateBack() does a raw inflate with a single call using a call-back
interface for input and output. This is potentially more efficient than
@@ -1163,7 +1163,7 @@
cannot return Z_OK.
*/
-ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm));
+ZEXTERN int ZEXPORT inflateBackEnd (z_streamp strm);
/*
All memory allocated by inflateBackInit() is freed.
@@ -1171,7 +1171,7 @@
state was inconsistent.
*/
-ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void));
+ZEXTERN uLong ZEXPORT zlibCompileFlags (void);
/* Return flags indicating compile-time options.
Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
@@ -1224,8 +1224,8 @@
you need special options.
*/
-ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen,
- const Bytef *source, uLong sourceLen));
+ZEXTERN int ZEXPORT compress (Bytef *dest, uLongf *destLen,
+ const Bytef *source, uLong sourceLen);
/*
Compresses the source buffer into the destination buffer. sourceLen is
the byte length of the source buffer. Upon entry, destLen is the total size
@@ -1239,9 +1239,9 @@
buffer.
*/
-ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen,
+ZEXTERN int ZEXPORT compress2 (Bytef *dest, uLongf *destLen,
const Bytef *source, uLong sourceLen,
- int level));
+ int level);
/*
Compresses the source buffer into the destination buffer. The level
parameter has the same meaning as in deflateInit. sourceLen is the byte
@@ -1255,15 +1255,15 @@
Z_STREAM_ERROR if the level parameter is invalid.
*/
-ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
+ZEXTERN uLong ZEXPORT compressBound (uLong sourceLen);
/*
compressBound() returns an upper bound on the compressed size after
compress() or compress2() on sourceLen bytes. It would be used before a
compress() or compress2() call to allocate the destination buffer.
*/
-ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen,
- const Bytef *source, uLong sourceLen));
+ZEXTERN int ZEXPORT uncompress (Bytef *dest, uLongf *destLen,
+ const Bytef *source, uLong sourceLen);
/*
Decompresses the source buffer into the destination buffer. sourceLen is
the byte length of the source buffer. Upon entry, destLen is the total size
@@ -1280,8 +1280,8 @@
buffer with the uncompressed data up to that point.
*/
-ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest, uLongf *destLen,
- const Bytef *source, uLong *sourceLen));
+ZEXTERN int ZEXPORT uncompress2 (Bytef *dest, uLongf *destLen,
+ const Bytef *source, uLong *sourceLen);
/*
Same as uncompress, except that sourceLen is a pointer, where the
length of the source is *sourceLen. On return, *sourceLen is the number of
@@ -1300,7 +1300,7 @@
typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */
/*
-ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
+ZEXTERN gzFile ZEXPORT gzopen (const char *path, const char *mode);
Opens a gzip (.gz) file for reading or writing. The mode parameter is as
in fopen ("rb" or "wb") but can also include a compression level ("wb9") or
@@ -1337,7 +1337,7 @@
file could not be opened.
*/
-ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode));
+ZEXTERN gzFile ZEXPORT gzdopen (int fd, const char *mode);
/*
gzdopen associates a gzFile with the file descriptor fd. File descriptors
are obtained from calls like open, dup, creat, pipe or fileno (if the file
@@ -1360,7 +1360,7 @@
will not detect if fd is invalid (unless fd is -1).
*/
-ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size));
+ZEXTERN int ZEXPORT gzbuffer (gzFile file, unsigned size);
/*
Set the internal buffer size used by this library's functions. The
default buffer size is 8192 bytes. This function must be called after
@@ -1376,7 +1376,7 @@
too late.
*/
-ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy));
+ZEXTERN int ZEXPORT gzsetparams (gzFile file, int level, int strategy);
/*
Dynamically update the compression level or strategy. See the description
of deflateInit2 for the meaning of these parameters. Previously provided
@@ -1387,7 +1387,7 @@
or Z_MEM_ERROR if there is a memory allocation error.
*/
-ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
+ZEXTERN int ZEXPORT gzread (gzFile file, voidp buf, unsigned len);
/*
Reads the given number of uncompressed bytes from the compressed file. If
the input file is not in gzip format, gzread copies the given number of
@@ -1417,8 +1417,8 @@
Z_STREAM_ERROR.
*/
-ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems,
- gzFile file));
+ZEXTERN z_size_t ZEXPORT gzfread (voidp buf, z_size_t size, z_size_t nitems,
+ gzFile file);
/*
Read up to nitems items of size size from file to buf, otherwise operating
as gzread() does. This duplicates the interface of stdio's fread(), with
@@ -1443,16 +1443,16 @@
file, reseting and retrying on end-of-file, when size is not 1.
*/
-ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
- voidpc buf, unsigned len));
+ZEXTERN int ZEXPORT gzwrite (gzFile file,
+ voidpc buf, unsigned len);
/*
Writes the given number of uncompressed bytes into the compressed file.
gzwrite returns the number of uncompressed bytes written or 0 in case of
error.
*/
-ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size,
- z_size_t nitems, gzFile file));
+ZEXTERN z_size_t ZEXPORT gzfwrite (voidpc buf, z_size_t size,
+ z_size_t nitems, gzFile file);
/*
gzfwrite() writes nitems items of size size from buf to file, duplicating
the interface of stdio's fwrite(), with size_t request and return types. If
@@ -1480,7 +1480,7 @@
This can be determined using zlibCompileFlags().
*/
-ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
+ZEXTERN int ZEXPORT gzputs (gzFile file, const char *s);
/*
Writes the given null-terminated string to the compressed file, excluding
the terminating null character.
@@ -1488,7 +1488,7 @@
gzputs returns the number of characters written, or -1 in case of error.
*/
-ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len));
+ZEXTERN char * ZEXPORT gzgets (gzFile file, char *buf, int len);
/*
Reads bytes from the compressed file until len-1 characters are read, or a
newline character is read and transferred to buf, or an end-of-file
@@ -1501,13 +1501,13 @@
buf are indeterminate.
*/
-ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c));
+ZEXTERN int ZEXPORT gzputc (gzFile file, int c);
/*
Writes c, converted to an unsigned char, into the compressed file. gzputc
returns the value that was written, or -1 in case of error.
*/
-ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
+ZEXTERN int ZEXPORT gzgetc (gzFile file);
/*
Reads one byte from the compressed file. gzgetc returns this byte or -1
in case of end of file or error. This is implemented as a macro for speed.
@@ -1516,7 +1516,7 @@
points to has been clobbered or not.
*/
-ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file));
+ZEXTERN int ZEXPORT gzungetc (int c, gzFile file);
/*
Push one character back onto the stream to be read as the first character
on the next read. At least one character of push-back is allowed.
@@ -1528,7 +1528,7 @@
gzseek() or gzrewind().
*/
-ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
+ZEXTERN int ZEXPORT gzflush (gzFile file, int flush);
/*
Flushes all pending output into the compressed file. The parameter flush
is as in the deflate() function. The return value is the zlib error number
@@ -1544,8 +1544,8 @@
*/
/*
-ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file,
- z_off_t offset, int whence));
+ZEXTERN z_off_t ZEXPORT gzseek (gzFile file,
+ z_off_t offset, int whence);
Sets the starting position for the next gzread or gzwrite on the given
compressed file. The offset represents a number of bytes in the
@@ -1563,7 +1563,7 @@
would be before the current position.
*/
-ZEXTERN int ZEXPORT gzrewind OF((gzFile file));
+ZEXTERN int ZEXPORT gzrewind (gzFile file);
/*
Rewinds the given file. This function is supported only for reading.
@@ -1571,7 +1571,7 @@
*/
/*
-ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file));
+ZEXTERN z_off_t ZEXPORT gztell (gzFile file);
Returns the starting position for the next gzread or gzwrite on the given
compressed file. This position represents a number of bytes in the
@@ -1582,7 +1582,7 @@
*/
/*
-ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file));
+ZEXTERN z_off_t ZEXPORT gzoffset (gzFile file);
Returns the current offset in the file being read or written. This offset
includes the count of bytes that precede the gzip stream, for example when
@@ -1591,7 +1591,7 @@
for a progress indicator. On error, gzoffset() returns -1.
*/
-ZEXTERN int ZEXPORT gzeof OF((gzFile file));
+ZEXTERN int ZEXPORT gzeof (gzFile file);
/*
Returns true (1) if the end-of-file indicator has been set while reading,
false (0) otherwise. Note that the end-of-file indicator is set only if the
@@ -1606,7 +1606,7 @@
has grown since the previous end of file was detected.
*/
-ZEXTERN int ZEXPORT gzdirect OF((gzFile file));
+ZEXTERN int ZEXPORT gzdirect (gzFile file);
/*
Returns true (1) if file is being copied directly while reading, or false
(0) if file is a gzip stream being decompressed.
@@ -1627,7 +1627,7 @@
gzip file reading and decompression, which may not be desired.)
*/
-ZEXTERN int ZEXPORT gzclose OF((gzFile file));
+ZEXTERN int ZEXPORT gzclose (gzFile file);
/*
Flushes all pending output if necessary, closes the compressed file and
deallocates the (de)compression state. Note that once file is closed, you
@@ -1640,8 +1640,8 @@
last read ended in the middle of a gzip stream, or Z_OK on success.
*/
-ZEXTERN int ZEXPORT gzclose_r OF((gzFile file));
-ZEXTERN int ZEXPORT gzclose_w OF((gzFile file));
+ZEXTERN int ZEXPORT gzclose_r (gzFile file);
+ZEXTERN int ZEXPORT gzclose_w (gzFile file);
/*
Same as gzclose(), but gzclose_r() is only for use when reading, and
gzclose_w() is only for use when writing or appending. The advantage to
@@ -1652,7 +1652,7 @@
zlib library.
*/
-ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
+ZEXTERN const char * ZEXPORT gzerror (gzFile file, int *errnum);
/*
Returns the error message for the last error which occurred on the given
compressed file. errnum is set to zlib error number. If an error occurred
@@ -1668,7 +1668,7 @@
functions above that do not distinguish those cases in their return values.
*/
-ZEXTERN void ZEXPORT gzclearerr OF((gzFile file));
+ZEXTERN void ZEXPORT gzclearerr (gzFile file);
/*
Clears the error and end-of-file flags for file. This is analogous to the
clearerr() function in stdio. This is useful for continuing to read a gzip
@@ -1685,7 +1685,7 @@
library.
*/
-ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len));
+ZEXTERN uLong ZEXPORT adler32 (uLong adler, const Bytef *buf, uInt len);
/*
Update a running Adler-32 checksum with the bytes buf[0..len-1] and
return the updated checksum. If buf is Z_NULL, this function returns the
@@ -1704,15 +1704,15 @@
if (adler != original_adler) error();
*/
-ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef *buf,
- z_size_t len));
+ZEXTERN uLong ZEXPORT adler32_z (uLong adler, const Bytef *buf,
+ z_size_t len);
/*
Same as adler32(), but with a size_t length.
*/
/*
-ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2,
- z_off_t len2));
+ZEXTERN uLong ZEXPORT adler32_combine (uLong adler1, uLong adler2,
+ z_off_t len2);
Combine two Adler-32 checksums into one. For two sequences of bytes, seq1
and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for
@@ -1722,7 +1722,7 @@
negative, the result has no meaning or utility.
*/
-ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len));
+ZEXTERN uLong ZEXPORT crc32 (uLong crc, const Bytef *buf, uInt len);
/*
Update a running CRC-32 with the bytes buf[0..len-1] and return the
updated CRC-32. If buf is Z_NULL, this function returns the required
@@ -1739,14 +1739,14 @@
if (crc != original_crc) error();
*/
-ZEXTERN uLong ZEXPORT crc32_z OF((uLong adler, const Bytef *buf,
- z_size_t len));
+ZEXTERN uLong ZEXPORT crc32_z (uLong adler, const Bytef *buf,
+ z_size_t len);
/*
Same as crc32(), but with a size_t length.
*/
/*
-ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2));
+ZEXTERN uLong ZEXPORT crc32_combine (uLong crc1, uLong crc2, z_off_t len2);
Combine two CRC-32 check values into one. For two sequences of bytes,
seq1 and seq2 with lengths len1 and len2, CRC-32 check values were
@@ -1761,20 +1761,20 @@
/* deflateInit and inflateInit are macros to allow checking the zlib version
* and the compiler's view of z_stream:
*/
-ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level,
- const char *version, int stream_size));
-ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm,
- const char *version, int stream_size));
-ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method,
+ZEXTERN int ZEXPORT deflateInit_ (z_streamp strm, int level,
+ const char *version, int stream_size);
+ZEXTERN int ZEXPORT inflateInit_ (z_streamp strm,
+ const char *version, int stream_size);
+ZEXTERN int ZEXPORT deflateInit2_ (z_streamp strm, int level, int method,
int windowBits, int memLevel,
int strategy, const char *version,
- int stream_size));
-ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits,
- const char *version, int stream_size));
-ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits,
+ int stream_size);
+ZEXTERN int ZEXPORT inflateInit2_ (z_streamp strm, int windowBits,
+ const char *version, int stream_size);
+ZEXTERN int ZEXPORT inflateBackInit_ (z_streamp strm, int windowBits,
unsigned char FAR *window,
const char *version,
- int stream_size));
+ int stream_size);
#ifdef Z_PREFIX_SET
# define z_deflateInit(strm, level) \
deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
@@ -1819,7 +1819,7 @@
unsigned char *next;
z_off64_t pos;
};
-ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */
+ZEXTERN int ZEXPORT gzgetc_ (gzFile file); /* backward compatibility */
#ifdef Z_PREFIX_SET
# undef z_gzgetc
# define z_gzgetc(g) \
@@ -1836,12 +1836,12 @@
* without large file support, _LFS64_LARGEFILE must also be true
*/
#ifdef Z_LARGE64
- ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
- ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
- ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
- ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
- ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t));
- ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t));
+ ZEXTERN gzFile ZEXPORT gzopen64 (const char *, const char *);
+ ZEXTERN z_off64_t ZEXPORT gzseek64 (gzFile, z_off64_t, int);
+ ZEXTERN z_off64_t ZEXPORT gztell64 (gzFile);
+ ZEXTERN z_off64_t ZEXPORT gzoffset64 (gzFile);
+ ZEXTERN uLong ZEXPORT adler32_combine64 (uLong, uLong, z_off64_t);
+ ZEXTERN uLong ZEXPORT crc32_combine64 (uLong, uLong, z_off64_t);
#endif
#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64)
@@ -1861,41 +1861,41 @@
# define crc32_combine crc32_combine64
# endif
# ifndef Z_LARGE64
- ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
- ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int));
- ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile));
- ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile));
- ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
- ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
+ ZEXTERN gzFile ZEXPORT gzopen64 (const char *, const char *);
+ ZEXTERN z_off_t ZEXPORT gzseek64 (gzFile, z_off_t, int);
+ ZEXTERN z_off_t ZEXPORT gztell64 (gzFile);
+ ZEXTERN z_off_t ZEXPORT gzoffset64 (gzFile);
+ ZEXTERN uLong ZEXPORT adler32_combine64 (uLong, uLong, z_off_t);
+ ZEXTERN uLong ZEXPORT crc32_combine64 (uLong, uLong, z_off_t);
# endif
#else
- ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *));
- ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int));
- ZEXTERN z_off_t ZEXPORT gztell OF((gzFile));
- ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile));
- ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
- ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
+ ZEXTERN gzFile ZEXPORT gzopen (const char *, const char *);
+ ZEXTERN z_off_t ZEXPORT gzseek (gzFile, z_off_t, int);
+ ZEXTERN z_off_t ZEXPORT gztell (gzFile);
+ ZEXTERN z_off_t ZEXPORT gzoffset (gzFile);
+ ZEXTERN uLong ZEXPORT adler32_combine (uLong, uLong, z_off_t);
+ ZEXTERN uLong ZEXPORT crc32_combine (uLong, uLong, z_off_t);
#endif
#else /* Z_SOLO */
- ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
- ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
+ ZEXTERN uLong ZEXPORT adler32_combine (uLong, uLong, z_off_t);
+ ZEXTERN uLong ZEXPORT crc32_combine (uLong, uLong, z_off_t);
#endif /* !Z_SOLO */
/* undocumented functions */
-ZEXTERN const char * ZEXPORT zError OF((int));
-ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp));
-ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void));
-ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int));
-ZEXTERN int ZEXPORT inflateValidate OF((z_streamp, int));
-ZEXTERN unsigned long ZEXPORT inflateCodesUsed OF ((z_streamp));
-ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp));
-ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp));
+ZEXTERN const char * ZEXPORT zError (int);
+ZEXTERN int ZEXPORT inflateSyncPoint (z_streamp);
+ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table (void);
+ZEXTERN int ZEXPORT inflateUndermine (z_streamp, int);
+ZEXTERN int ZEXPORT inflateValidate (z_streamp, int);
+ZEXTERN unsigned long ZEXPORT inflateCodesUsed (z_streamp);
+ZEXTERN int ZEXPORT inflateResetKeep (z_streamp);
+ZEXTERN int ZEXPORT deflateResetKeep (z_streamp);
#if (defined(_WIN32) || defined(__CYGWIN__)) && !defined(Z_SOLO)
-ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path,
- const char *mode));
+ZEXTERN gzFile ZEXPORT gzopen_w (const wchar_t *path,
+ const char *mode);
#endif
#if defined(STDC) || defined(Z_HAVE_STDARG_H)
# ifndef Z_SOLO
diff -ur zlib-1.2.11/zutil.c zlib-1.2.11__patched/zutil.c
--- zlib-1.2.11/zutil.c 2017-01-15 18:29:40.000000000 +0100
+++ zlib-1.2.11__patched/zutil.c 2019-10-22 17:36:13.397965240 +0200
@@ -297,9 +297,9 @@
#ifndef MY_ZCALLOC /* Any system without a special alloc function */
#ifndef STDC
-extern voidp malloc OF((uInt size));
-extern voidp calloc OF((uInt items, uInt size));
-extern void free OF((voidpf ptr));
+extern voidp malloc (uInt size);
+extern voidp calloc (uInt items, uInt size);
+extern void free (voidpf ptr);
#endif
voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
diff -ur zlib-1.2.11/zutil.h zlib-1.2.11__patched/zutil.h
--- zlib-1.2.11/zutil.h 2017-01-01 08:37:10.000000000 +0100
+++ zlib-1.2.11__patched/zutil.h 2019-10-22 17:36:13.397965240 +0200
@@ -188,8 +188,8 @@
/* provide prototypes for these when building zlib without LFS */
#if !defined(_WIN32) && \
(!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0)
- ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
- ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
+ ZEXTERN uLong ZEXPORT adler32_combine64 (uLong, uLong, z_off_t);
+ ZEXTERN uLong ZEXPORT crc32_combine64 (uLong, uLong, z_off_t);
#endif
/* common defaults */
@@ -228,16 +228,16 @@
# define zmemzero(dest, len) memset(dest, 0, len)
# endif
#else
- void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len));
- int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len));
- void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len));
+ void ZLIB_INTERNAL zmemcpy (Bytef* dest, const Bytef* source, uInt len);
+ int ZLIB_INTERNAL zmemcmp (const Bytef* s1, const Bytef* s2, uInt len);
+ void ZLIB_INTERNAL zmemzero (Bytef* dest, uInt len);
#endif
/* Diagnostic functions */
#ifdef ZLIB_DEBUG
# include <stdio.h>
extern int ZLIB_INTERNAL z_verbose;
- extern void ZLIB_INTERNAL z_error OF((char *m));
+ extern void ZLIB_INTERNAL z_error (char *m);
# define Assert(cond,msg) {if(!(cond)) z_error(msg);}
# define Trace(x) {if (z_verbose>=0) fprintf x ;}
# define Tracev(x) {if (z_verbose>0) fprintf x ;}
@@ -254,9 +254,9 @@
#endif
#ifndef Z_SOLO
- voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items,
- unsigned size));
- void ZLIB_INTERNAL zcfree OF((voidpf opaque, voidpf ptr));
+ voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items,
+ unsigned size);
+ void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr);
#endif
#define ZALLOC(strm, items, size) \
Reference in New Issue View Git Blame Copy Permalink