From: hansr Date: Sun, 12 Oct 2014 20:57:27 +0000 (+0200) Subject: Remove workarounds for non-ANSI-C compatible compilers (Part 2) X-Git-Tag: 1.9.9-b1~922 X-Git-Url: http://git.ipfire.org/cgi-bin/gitweb.cgi?a=commitdiff_plain;h=3f8e26e0b7605f49057b09d2eafce05511ce0c29;p=thirdparty%2Fzlib-ng.git Remove workarounds for non-ANSI-C compatible compilers (Part 2) -Removing usage of OF() definition --- diff --git a/adler32.c b/adler32.c index 1007e38af..248473d0f 100644 --- a/adler32.c +++ b/adler32.c @@ -9,7 +9,7 @@ #define local static -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 65521 /* largest prime smaller than 65536 */ #define NMAX 5552 diff --git a/crc32.c b/crc32.c index 23d815663..7176907f1 100644 --- a/crc32.c +++ b/crc32.c @@ -37,29 +37,26 @@ # define BYFOUR #endif #ifdef BYFOUR - local unsigned long crc32_little OF((unsigned long, - const unsigned char *, unsigned)); - local unsigned long crc32_big OF((unsigned long, - const unsigned char *, unsigned)); + local unsigned long crc32_little (unsigned long, const unsigned char *, unsigned); + local unsigned long crc32_big (unsigned long, const unsigned char *, unsigned); # 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 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 *)); + local void write_table (FILE *, const z_crc_t *); #endif /* MAKECRCH */ /* Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: diff --git a/deflate.c b/deflate.c index b26f4d1ab..f88c01b03 100644 --- a/deflate.c +++ b/deflate.c @@ -68,33 +68,32 @@ const char deflate_copyright[] = * Function prototypes. */ -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 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)); -block_state deflate_quick OF((deflate_state *s, int flush)); -local block_state deflate_medium OF((deflate_state *s, int flush)); +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); +block_state deflate_quick (deflate_state *s, int flush); +local block_state deflate_medium (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)); -ZLIB_INTERNAL void flush_pending OF((z_streamp strm)); -ZLIB_INTERNAL int 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); +ZLIB_INTERNAL void flush_pending (z_streamp strm); +ZLIB_INTERNAL int read_buf (z_streamp strm, Bytef *buf, unsigned size); #ifdef ASMV - 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 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 extern void crc_reset(deflate_state *const s); diff --git a/deflate.h b/deflate.h index 6a3ed9765..8ba824f64 100644 --- a/deflate.h +++ b/deflate.h @@ -331,15 +331,13 @@ typedef enum { 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 bi_windup OF((deflate_state *s)); +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); +void ZLIB_INTERNAL bi_windup (deflate_state *s); #define d_code(dist) \ ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) diff --git a/deflate_quick.c b/deflate_quick.c index ad97098ae..b481e48d0 100644 --- a/deflate_quick.c +++ b/deflate_quick.c @@ -17,7 +17,7 @@ #include extern void fill_window_sse(deflate_state *s); -extern void flush_pending OF((z_streamp strm)); +extern void flush_pending (z_streamp strm); local inline long compare258(z_const unsigned char *z_const src0, z_const unsigned char *z_const src1) diff --git a/fill_window_sse.c b/fill_window_sse.c index 6012fae96..12abd35ae 100644 --- a/fill_window_sse.c +++ b/fill_window_sse.c @@ -13,7 +13,7 @@ #include #include "deflate.h" -extern int read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); +extern int read_buf (z_streamp strm, Bytef *buf, unsigned size); void fill_window_sse(deflate_state *s) { diff --git a/gzguts.h b/gzguts.h index 6303d5aa0..5bbd15c7f 100644 --- a/gzguts.h +++ b/gzguts.h @@ -81,10 +81,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 */ @@ -145,9 +145,9 @@ typedef struct { typedef gz_state *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 @@ -156,6 +156,6 @@ char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error)); #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 --git a/gzlib.c b/gzlib.c index 68ed4a600..59aed4c71 100644 --- a/gzlib.c +++ b/gzlib.c @@ -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 --git a/gzread.c b/gzread.c index bf4538eb2..68bc2a36a 100644 --- a/gzread.c +++ b/gzread.c @@ -6,12 +6,12 @@ #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 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); /* 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 --git a/gzwrite.c b/gzwrite.c index 2cbf1e497..2c75d5946 100644 --- a/gzwrite.c +++ b/gzwrite.c @@ -6,9 +6,9 @@ #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 int gz_init (gz_statep); +local int gz_comp (gz_statep, int); +local int gz_zero (gz_statep, z_off64_t); /* Initialize state for writing a gzip file. Mark initialization by setting state->size to non-zero. Return -1 on failure or 0 on success. */ diff --git a/infback.c b/infback.c index 4f2bb5b38..c082388cf 100644 --- a/infback.c +++ b/infback.c @@ -16,7 +16,7 @@ #include "inffast.h" /* function prototypes */ -local void fixedtables OF((struct inflate_state *state)); +local void fixedtables (struct inflate_state *state); /* strm provides memory allocation functions in zalloc and zfree, or diff --git a/inffast.h b/inffast.h index e5c1aa4ca..96bd8abb8 100644 --- a/inffast.h +++ b/inffast.h @@ -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 --git a/inflate.c b/inflate.c index 9690bed78..58f806a71 100644 --- a/inflate.c +++ b/inflate.c @@ -92,14 +92,12 @@ #endif /* function prototypes */ -local void fixedtables OF((struct inflate_state *state)); -local int updatewindow OF((z_streamp strm, const unsigned char *end, - unsigned copy)); +local void fixedtables (struct inflate_state *state); +local int updatewindow (z_streamp strm, const unsigned char *end, unsigned copy); #ifdef BUILDFIXED - void makefixed OF((void)); + void makefixed (void); #endif -local unsigned syncsearch OF((unsigned *have, const unsigned char *buf, - unsigned len)); +local unsigned syncsearch (unsigned *have, const unsigned char *buf, unsigned len); int ZEXPORT inflateResetKeep(strm) z_streamp strm; diff --git a/inftrees.h b/inftrees.h index c20f96b69..a568d4094 100644 --- a/inftrees.h +++ b/inftrees.h @@ -57,6 +57,6 @@ typedef enum { DISTS } codetype; -int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short *lens, +int ZLIB_INTERNAL inflate_table (codetype type, unsigned short *lens, unsigned codes, code * *table, - unsigned *bits, unsigned short *work)); + unsigned *bits, unsigned short *work); diff --git a/test/example.c b/test/example.c index e9353da1b..62141e586 100644 --- a/test/example.c +++ b/test/example.c @@ -28,26 +28,26 @@ z_const char hello[] = "hello, hello!"; const char dictionary[] = "hello"; uLong dictId; /* Adler32 value of the dictionary */ -void test_deflate OF((Byte *compr, uLong comprLen)); -void test_inflate OF((Byte *compr, uLong comprLen, - Byte *uncompr, uLong uncomprLen)); -void test_large_deflate OF((Byte *compr, uLong comprLen, - Byte *uncompr, uLong uncomprLen)); -void test_large_inflate OF((Byte *compr, uLong comprLen, - Byte *uncompr, uLong uncomprLen)); -void test_flush OF((Byte *compr, uLong *comprLen)); -void test_sync OF((Byte *compr, uLong comprLen, - Byte *uncompr, uLong uncomprLen)); -void test_dict_deflate OF((Byte *compr, uLong comprLen)); -void test_dict_inflate OF((Byte *compr, uLong comprLen, - Byte *uncompr, uLong uncomprLen)); -int main OF((int argc, char *argv[])); +void test_deflate (Byte *compr, uLong comprLen); +void test_inflate (Byte *compr, uLong comprLen, + Byte *uncompr, uLong uncomprLen); +void test_large_deflate (Byte *compr, uLong comprLen, + Byte *uncompr, uLong uncomprLen); +void test_large_inflate (Byte *compr, uLong comprLen, + Byte *uncompr, uLong uncomprLen); +void test_flush (Byte *compr, uLong *comprLen); +void test_sync (Byte *compr, uLong comprLen, + Byte *uncompr, uLong uncomprLen); +void test_dict_deflate (Byte *compr, uLong comprLen); +void test_dict_inflate (Byte *compr, uLong comprLen, + Byte *uncompr, uLong uncomprLen); +int main (int argc, char *argv[]); #ifdef Z_SOLO -void *myalloc OF((void *, unsigned, unsigned)); -void myfree OF((void *, void *)); +void *myalloc (void *, unsigned, unsigned); +void myfree (void *, void *); void *myalloc(q, n, m) void *q; @@ -71,10 +71,10 @@ static free_func zfree = myfree; static alloc_func zalloc = (alloc_func)0; static free_func zfree = (free_func)0; -void test_compress OF((Byte *compr, uLong comprLen, - Byte *uncompr, uLong uncomprLen)); -void test_gzio OF((const char *fname, - Byte *uncompr, uLong uncomprLen)); +void test_compress (Byte *compr, uLong comprLen, + Byte *uncompr, uLong uncomprLen); +void test_gzio (const char *fname, + Byte *uncompr, uLong uncomprLen); /* =========================================================================== * Test compress() and uncompress() diff --git a/test/minigzip.c b/test/minigzip.c index f92aad728..227605d3a 100644 --- a/test/minigzip.c +++ b/test/minigzip.c @@ -52,7 +52,7 @@ #if !defined(Z_HAVE_UNISTD_H) && !defined(_LARGEFILE64_SOURCE) #ifndef WIN32 /* unlink already in stdio.h for WIN32 */ - extern int unlink OF((const char *)); + extern int unlink (const char *); #endif #endif @@ -142,8 +142,8 @@ static void pwinerror (s) # include /* for unlink() */ #endif -void *myalloc OF((void *, unsigned, unsigned)); -void myfree OF((void *, void *)); +void *myalloc (void *, unsigned, unsigned); +void myfree (void *, void *); void *myalloc(q, n, m) void *q; @@ -168,9 +168,9 @@ typedef struct gzFile_s { z_stream strm; } *gzFile; -gzFile gzopen OF((const char *, const char *)); -gzFile gzdopen OF((int, const char *)); -gzFile gz_open OF((const char *, int, const char *)); +gzFile gzopen (const char *, const char *); +gzFile gzdopen (int, const char *); +gzFile gz_open (const char *, int, const char *); gzFile gzopen(path, mode) const char *path; @@ -224,7 +224,7 @@ gzFile gz_open(path, fd, mode) return gz; } -int gzwrite OF((gzFile, const void *, unsigned)); +int gzwrite (gzFile, const void *, unsigned); int gzwrite(gz, buf, len) gzFile gz; @@ -248,7 +248,7 @@ int gzwrite(gz, buf, len) return len; } -int gzread OF((gzFile, void *, unsigned)); +int gzread (gzFile, void *, unsigned); int gzread(gz, buf, len) gzFile gz; @@ -285,7 +285,7 @@ int gzread(gz, buf, len) return len - strm->avail_out; } -int gzclose OF((gzFile)); +int gzclose (gzFile); int gzclose(gz) gzFile gz; @@ -314,7 +314,7 @@ int gzclose(gz) return Z_OK; } -const char *gzerror OF((gzFile, int *)); +const char *gzerror (gzFile, int *); const char *gzerror(gz, err) gzFile gz; @@ -328,15 +328,15 @@ const char *gzerror(gz, err) char *prog; -void error OF((const char *msg)); -void gz_compress OF((FILE *in, gzFile out)); +void error (const char *msg); +void gz_compress (FILE *in, gzFile out); #ifdef USE_MMAP -int gz_compress_mmap OF((FILE *in, gzFile out)); +int gz_compress_mmap (FILE *in, gzFile out); #endif -void gz_uncompress OF((gzFile in, FILE *out)); -void file_compress OF((char *file, char *mode)); -void file_uncompress OF((char *file)); -int main OF((int argc, char *argv[])); +void gz_uncompress (gzFile in, FILE *out); +void file_compress (char *file, char *mode); +void file_uncompress (char *file); +int main (int argc, char *argv[]); /* =========================================================================== * Display error message and exit diff --git a/trees.c b/trees.c index 69c092c0a..df6cec913 100644 --- a/trees.c +++ b/trees.c @@ -132,27 +132,24 @@ local static_tree_desc static_bl_desc = * 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_flush OF((deflate_state *s)); -local void copy_block OF((deflate_state *s, charf *buf, unsigned len, - int header)); +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_flush (deflate_state *s); +local void copy_block (deflate_state *s, charf *buf, unsigned len, int header); #ifdef GEN_TREES_H -local void gen_trees_header OF((void)); +local void gen_trees_header (void); #endif /* =========================================================================== diff --git a/zconf.h b/zconf.h index e1b73601a..538573b50 100644 --- a/zconf.h +++ b/zconf.h @@ -213,6 +213,7 @@ /* Type declarations */ +/* OF() definition is kept for compatibility purposes */ #ifndef OF /* function prototypes */ # define OF(args) args #endif diff --git a/zlib.h b/zlib.h index 793648213..8e390132a 100644 --- a/zlib.h +++ b/zlib.h @@ -77,8 +77,8 @@ extern "C" { even in 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; @@ -204,7 +204,7 @@ typedef gz_header *gz_headerp; /* 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 @@ -212,7 +212,7 @@ ZEXTERN const char * ZEXPORT zlibVersion OF((void)); */ /* -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 @@ -234,7 +234,7 @@ ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); */ -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 @@ -341,7 +341,7 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); */ -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 @@ -356,7 +356,7 @@ ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); /* -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 @@ -380,7 +380,7 @@ ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); */ -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 @@ -496,7 +496,7 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); */ -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 @@ -515,12 +515,12 @@ ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); */ /* -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 @@ -575,9 +575,9 @@ ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, 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 @@ -619,8 +619,8 @@ ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, not perform any compression: this will be done by deflate(). */ -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. @@ -637,7 +637,7 @@ ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, 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 all the internal compression state. The @@ -648,9 +648,9 @@ ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); 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 @@ -669,11 +669,11 @@ ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, strm->avail_out was zero. */ -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 @@ -686,8 +686,8 @@ ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, 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 @@ -701,9 +701,9 @@ ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, 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 @@ -716,9 +716,9 @@ ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, 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 @@ -733,8 +733,8 @@ ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, 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 @@ -758,8 +758,8 @@ ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, */ /* -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 @@ -807,9 +807,9 @@ ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, 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, @@ -830,9 +830,9 @@ ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, 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 @@ -845,7 +845,7 @@ ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm, 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 @@ -864,8 +864,8 @@ ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); 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. @@ -880,7 +880,7 @@ ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, 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 all the internal decompression state. The @@ -890,8 +890,8 @@ ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); 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 @@ -902,9 +902,9 @@ ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, 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 @@ -923,7 +923,7 @@ ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, 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 @@ -951,8 +951,8 @@ ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm)); 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 @@ -992,8 +992,8 @@ ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, */ /* -ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, - unsigned char *window)); +ZEXTERN int ZEXPORT inflateBackInit (z_streamp strm, int windowBits, + unsigned char *window); Initialize the internal stream state for decompression using inflateBack() calls. The fields zalloc, zfree and opaque in strm must be initialized @@ -1013,13 +1013,13 @@ ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, the version of the header file. */ -typedef unsigned (*in_func) OF((void *, - z_const unsigned char * *)); -typedef int (*out_func) OF((void *, unsigned char *, unsigned)); +typedef unsigned (*in_func) (void *, + z_const unsigned char * *); +typedef int (*out_func) (void *, unsigned char *, unsigned); -ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, +ZEXTERN int ZEXPORT inflateBack (z_streamp strm, in_func in, void *in_desc, - out_func out, void *out_desc)); + out_func out, void *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 @@ -1087,7 +1087,7 @@ ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, 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. @@ -1095,7 +1095,7 @@ ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); 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: @@ -1148,8 +1148,8 @@ ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); 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 @@ -1162,9 +1162,9 @@ ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, 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 @@ -1178,15 +1178,15 @@ ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, 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 @@ -1215,7 +1215,7 @@ ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, 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 @@ -1252,7 +1252,7 @@ ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); 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 @@ -1275,7 +1275,7 @@ ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); 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 @@ -1292,7 +1292,7 @@ ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); 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. @@ -1301,7 +1301,7 @@ ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); opened for writing. */ -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 @@ -1329,8 +1329,8 @@ ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); len for end of file, or -1 for error. */ -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 @@ -1352,7 +1352,7 @@ ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...)); 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. @@ -1360,7 +1360,7 @@ ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); 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 @@ -1373,13 +1373,13 @@ ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); 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. @@ -1388,7 +1388,7 @@ ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); 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. @@ -1400,7 +1400,7 @@ ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); 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 @@ -1416,8 +1416,8 @@ ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); */ /* -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 @@ -1435,7 +1435,7 @@ ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, 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. @@ -1443,7 +1443,7 @@ ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); */ /* -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 @@ -1454,7 +1454,7 @@ ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); */ /* -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 @@ -1463,7 +1463,7 @@ ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file)); 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 @@ -1478,7 +1478,7 @@ ZEXTERN int ZEXPORT gzeof OF((gzFile file)); 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. @@ -1499,7 +1499,7 @@ ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); 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 @@ -1512,8 +1512,8 @@ ZEXTERN int ZEXPORT gzclose OF((gzFile file)); 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 @@ -1524,7 +1524,7 @@ ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); 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 @@ -1540,7 +1540,7 @@ ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); 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 @@ -1557,7 +1557,7 @@ ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); 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 @@ -1577,8 +1577,8 @@ ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); */ /* -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 @@ -1588,7 +1588,7 @@ ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, 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 @@ -1606,7 +1606,7 @@ ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); */ /* -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 @@ -1621,20 +1621,13 @@ ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); /* 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, - 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, - unsigned char *window, - const char *version, - int stream_size)); +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_ (z_streamp strm, int windowBits, const char *version, int stream_size); +ZEXTERN int ZEXPORT inflateBackInit_ (z_streamp strm, int windowBits, unsigned char *window, + const char *version, int stream_size); #define deflateInit(strm, level) \ deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) #define inflateInit(strm) \ @@ -1663,7 +1656,7 @@ struct gzFile_s { 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) \ @@ -1680,12 +1673,12 @@ ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ * 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) @@ -1705,26 +1698,26 @@ ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ # 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 */ @@ -1734,14 +1727,14 @@ ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ #endif /* undocumented functions */ -ZEXTERN const char * ZEXPORT zError OF((int)); -ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp)); -ZEXTERN const z_crc_t * ZEXPORT get_crc_table OF((void)); -ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); -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 * ZEXPORT get_crc_table (void); +ZEXTERN int ZEXPORT inflateUndermine (z_streamp, int); +ZEXTERN int ZEXPORT inflateResetKeep (z_streamp); +ZEXTERN int ZEXPORT deflateResetKeep (z_streamp); #if defined(_WIN32) && !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 #ifndef Z_SOLO ZEXTERN int ZEXPORTVA gzvprintf Z_ARG((gzFile file, const char *format, va_list va)); diff --git a/zutil.h b/zutil.h index 8b9516d3c..83cebbddf 100644 --- a/zutil.h +++ b/zutil.h @@ -124,8 +124,8 @@ extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ /* 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 */ @@ -148,7 +148,7 @@ extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ #ifdef DEBUG # include 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 ;} @@ -165,9 +165,8 @@ extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ #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) \