From: jbj Date: Tue, 3 Aug 2004 00:04:07 +0000 (+0000) Subject: Convert args to ANSI C. X-Git-Tag: tznext/4.11.0.1.tizen20130304~6399 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=8192896ba301cfa4a420a84b0ef9ccf097118dcf;p=tools%2Flibrpm-tizen.git Convert args to ANSI C. Side effects annotated. CVS patchset: 7385 CVS date: 2004/08/03 00:04:07 --- diff --git a/zlib/.splintrc b/zlib/.splintrc index 771469f..89f90ae 100644 --- a/zlib/.splintrc +++ b/zlib/.splintrc @@ -13,13 +13,9 @@ # --- in progress -globs --infloopsuncon --internalglobs --modunconnomods --nullassign --nullstate --oldstyle --staticinittrans +-infloops # 1 +-nullassign # 1 +-staticinittrans # 5 -abstract # 4 -aliasunique # 2 @@ -31,12 +27,12 @@ -compmempass # 37 -evalorder # 2 -globstate # 1 --mods # 13 +-mods # 5 -noeffectuncon # 10 -nullderef # 9 -nullpass # 24 -nullptrarith # 4 --nullret # 13 +-nullret # 11 -protoparammatch # 22 -redef # 4 -retalias # 4 diff --git a/zlib/adler32.c b/zlib/adler32.c index 624a169..19a7012 100644 --- a/zlib/adler32.c +++ b/zlib/adler32.c @@ -44,10 +44,7 @@ #endif /* ========================================================================= */ -uLong ZEXPORT adler32(adler, buf, len) - uLong adler; - const Bytef *buf; - uInt len; +uLong ZEXPORT adler32(uLong adler, const Bytef *buf, uInt len) { unsigned long s1 = adler & 0xffff; unsigned long s2 = (adler >> 16) & 0xffff; diff --git a/zlib/compress.c b/zlib/compress.c index 24ef029..232691b 100644 --- a/zlib/compress.c +++ b/zlib/compress.c @@ -19,12 +19,7 @@ memory, Z_BUF_ERROR if there was not enough room in the output buffer, Z_STREAM_ERROR if the level parameter is invalid. */ -int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) - Bytef *dest; - uLongf *destLen; - const Bytef *source; - uLong sourceLen; - int level; +int ZEXPORT compress2 (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen, int level) { z_stream stream; int err; @@ -59,11 +54,7 @@ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) /* =========================================================================== */ -int ZEXPORT compress (dest, destLen, source, sourceLen) - Bytef *dest; - uLongf *destLen; - const Bytef *source; - uLong sourceLen; +int ZEXPORT compress (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen) { return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION); } @@ -72,8 +63,7 @@ int ZEXPORT compress (dest, destLen, source, sourceLen) If the default memLevel or windowBits for deflateInit() is changed, then this function needs to be updated. */ -uLong ZEXPORT compressBound (sourceLen) - uLong sourceLen; +uLong ZEXPORT compressBound (uLong sourceLen) { return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + 11; } diff --git a/zlib/crc32.c b/zlib/crc32.c index 689b288..368061c 100644 --- a/zlib/crc32.c +++ b/zlib/crc32.c @@ -48,9 +48,11 @@ # define REV(w) (((w)>>24)+(((w)>>8)&0xff00)+ \ (((w)&0xff00)<<8)+(((w)&0xff)<<24)) local unsigned long crc32_little OF((unsigned long, - const unsigned char FAR *, unsigned)); + const unsigned char FAR *, unsigned)) + /*@*/; local unsigned long crc32_big OF((unsigned long, - const unsigned char FAR *, unsigned)); + const unsigned char FAR *, unsigned)) + /*@*/; # define TBLS 8 #else # define TBLS 1 @@ -60,9 +62,11 @@ local int crc_table_empty = 1; local unsigned long FAR crc_table[TBLS][256]; -local void make_crc_table OF((void)); +local void make_crc_table OF((void)) + /*@*/; #ifdef MAKECRCH - local void write_table OF((FILE *, const unsigned long FAR *)); + local void write_table OF((FILE *, const unsigned long FAR *)) + /*@*/; #endif /* MAKECRCH */ /* @@ -177,7 +181,7 @@ local void write_table(out, table) /* ========================================================================= * This function can be used by asm versions of crc32() */ -const unsigned long FAR * ZEXPORT get_crc_table() +const unsigned long FAR * ZEXPORT get_crc_table(void) { #ifdef DYNAMIC_CRC_TABLE if (crc_table_empty) make_crc_table(); @@ -190,10 +194,7 @@ const unsigned long FAR * ZEXPORT get_crc_table() #define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1 /* ========================================================================= */ -unsigned long ZEXPORT crc32(crc, buf, len) - unsigned long crc; - const unsigned char FAR *buf; - unsigned len; +unsigned long ZEXPORT crc32(unsigned long crc, const unsigned char FAR *buf, unsigned len) { if (buf == Z_NULL) return 0UL; @@ -233,10 +234,7 @@ unsigned long ZEXPORT crc32(crc, buf, len) #define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4 /* ========================================================================= */ -local unsigned long crc32_little(crc, buf, len) - unsigned long crc; - const unsigned char FAR *buf; - unsigned len; +local unsigned long crc32_little(unsigned long crc, const unsigned char FAR *buf, unsigned len) { register u4 c; register const u4 FAR *buf4; @@ -273,10 +271,7 @@ local unsigned long crc32_little(crc, buf, len) #define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4 /* ========================================================================= */ -local unsigned long crc32_big(crc, buf, len) - unsigned long crc; - const unsigned char FAR *buf; - unsigned len; +local unsigned long crc32_big(unsigned long crc, const unsigned char FAR *buf, unsigned len) { register u4 c; register const u4 FAR *buf4; diff --git a/zlib/deflate.c b/zlib/deflate.c index ada7cfd..3158197 100644 --- a/zlib/deflate.c +++ b/zlib/deflate.c @@ -70,32 +70,46 @@ typedef enum { 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) OF((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)); +local void fill_window OF((deflate_state *s)) + /*@modifies *s @*/; +local block_state deflate_stored OF((deflate_state *s, int flush)) + /*@modifies *s @*/; +local block_state deflate_fast OF((deflate_state *s, int flush)) + /*@modifies *s @*/; #ifndef FASTEST -local block_state deflate_slow OF((deflate_state *s, int flush)); +local block_state deflate_slow OF((deflate_state *s, int flush)) + /*@modifies *s @*/; #endif -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 int read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); +local void lm_init OF((deflate_state *s)) + /*@modifies *s @*/; +local void putShortMSB OF((deflate_state *s, uInt b)) + /*@modifies *s @*/; +local void flush_pending OF((z_streamp strm)) + /*@modifies strm @*/; +local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size)) + /*@modifies strm, *buf @*/; #ifndef FASTEST #ifdef ASMV - void match_init OF((void)); /* asm code initialization */ - uInt longest_match OF((deflate_state *s, IPos cur_match)); + void match_init OF((void)) /* asm code initialization */ + /*@*/; + uInt longest_match OF((deflate_state *s, IPos cur_match)) + /*@modifies *s @*/; #else -local uInt longest_match OF((deflate_state *s, IPos cur_match)); +local uInt longest_match OF((deflate_state *s, IPos cur_match)) + /*@modifies *s @*/; #endif #endif -local uInt longest_match_fast OF((deflate_state *s, IPos cur_match)); +local uInt longest_match_fast OF((deflate_state *s, IPos cur_match)) + /*@modifies *s @*/; #ifdef DEBUG local void check_match OF((deflate_state *s, IPos start, IPos match, - int length)); + int length)) + /*@*/; #endif /* =========================================================================== @@ -201,11 +215,7 @@ struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); /* ========================================================================= */ -int ZEXPORT deflateInit_(strm, level, version, stream_size) - z_streamp strm; - int level; - const char *version; - int stream_size; +int ZEXPORT deflateInit_(z_streamp strm, int level, const char *version, int stream_size) { return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, version, stream_size); @@ -213,16 +223,9 @@ int ZEXPORT deflateInit_(strm, level, version, stream_size) } /* ========================================================================= */ -int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, - version, stream_size) - z_streamp strm; - int level; - int method; - int windowBits; - int memLevel; - int strategy; - const char *version; - int stream_size; +int ZEXPORT deflateInit2_(z_streamp strm, int level, int method, + int windowBits, int memLevel, int strategy, + const char *version, int stream_size) { deflate_state *s; int wrap = 1; @@ -311,10 +314,7 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, } /* ========================================================================= */ -int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) - z_streamp strm; - const Bytef *dictionary; - uInt dictLength; +int ZEXPORT deflateSetDictionary (z_streamp strm, const Bytef *dictionary, uInt dictLength) { deflate_state *s; uInt length = dictLength; @@ -355,8 +355,7 @@ int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) } /* ========================================================================= */ -int ZEXPORT deflateReset (strm) - z_streamp strm; +int ZEXPORT deflateReset (z_streamp strm) { deflate_state *s; @@ -391,10 +390,7 @@ int ZEXPORT deflateReset (strm) } /* ========================================================================= */ -int ZEXPORT deflatePrime (strm, bits, value) - z_streamp strm; - int bits; - int value; +int ZEXPORT deflatePrime (z_streamp strm, int bits, int value) { if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; strm->state->bi_valid = bits; @@ -403,10 +399,7 @@ int ZEXPORT deflatePrime (strm, bits, value) } /* ========================================================================= */ -int ZEXPORT deflateParams(strm, level, strategy) - z_streamp strm; - int level; - int strategy; +int ZEXPORT deflateParams(z_streamp strm, int level, int strategy) { deflate_state *s; compress_func func; @@ -457,9 +450,7 @@ int ZEXPORT deflateParams(strm, level, strategy) * But even the conservative upper bound of about 14% expansion does not * seem onerous for output buffer allocation. */ -uLong ZEXPORT deflateBound(strm, sourceLen) - z_streamp strm; - uLong sourceLen; +uLong ZEXPORT deflateBound(z_streamp strm, uLong sourceLen) { deflate_state *s; uLong destLen; @@ -486,9 +477,7 @@ uLong ZEXPORT deflateBound(strm, sourceLen) * IN assertion: the stream state is correct and there is enough room in * pending_buf. */ -local void putShortMSB (s, b) - deflate_state *s; - uInt b; +local void putShortMSB (deflate_state *s, uInt b) { put_byte(s, (Byte)(b >> 8)); put_byte(s, (Byte)(b & 0xff)); @@ -500,8 +489,7 @@ local void putShortMSB (s, b) * to avoid allocating a large strm->next_out buffer and copying into it. * (See also read_buf()). */ -local void flush_pending(strm) - z_streamp strm; +local void flush_pending(z_streamp strm) { unsigned len = strm->state->pending; @@ -520,9 +508,7 @@ local void flush_pending(strm) } /* ========================================================================= */ -int ZEXPORT deflate (strm, flush) - z_streamp strm; - int flush; +int ZEXPORT deflate (z_streamp strm, int flush) { int old_flush; /* value of flush param for previous deflate call */ deflate_state *s; @@ -696,8 +682,7 @@ int ZEXPORT deflate (strm, flush) } /* ========================================================================= */ -int ZEXPORT deflateEnd (strm) - z_streamp strm; +int ZEXPORT deflateEnd (z_streamp strm) { int status; @@ -726,9 +711,7 @@ int ZEXPORT deflateEnd (strm) * To simplify the source, this is not supported for 16-bit MSDOS (which * doesn't have enough memory anyway to duplicate compression states). */ -int ZEXPORT deflateCopy (dest, source) - z_streamp dest; - z_streamp source; +int ZEXPORT deflateCopy (z_streamp dest, z_streamp source) { #ifdef MAXSEG_64K return Z_STREAM_ERROR; @@ -788,10 +771,7 @@ int ZEXPORT deflateCopy (dest, source) * allocating a large strm->next_in buffer and copying from it. * (See also flush_pending()). */ -local int read_buf(strm, buf, size) - z_streamp strm; - Bytef *buf; - unsigned size; +local int read_buf(z_streamp strm, Bytef *buf, unsigned size) { unsigned len = strm->avail_in; @@ -818,8 +798,7 @@ local int read_buf(strm, buf, size) /* =========================================================================== * Initialize the "longest match" routines for a new zlib stream */ -local void lm_init (s) - deflate_state *s; +local void lm_init (deflate_state *s) { s->window_size = (ulg)2L*s->w_size; @@ -857,9 +836,7 @@ local void lm_init (s) /* For 80x86 and 680x0, an optimized version will be provided in match.asm or * match.S. The code will be functionally equivalent. */ -local uInt longest_match(s, cur_match) - deflate_state *s; - IPos cur_match; /* current match */ +local uInt longest_match(deflate_state *s, IPos cur_match) { unsigned chain_length = s->max_chain_length;/* max hash chain length */ register Bytef *scan = s->window + s->strstart; /* current string */ @@ -1000,9 +977,7 @@ local uInt longest_match(s, cur_match) /* --------------------------------------------------------------------------- * Optimized version for level == 1 or strategy == Z_RLE only */ -local uInt longest_match_fast(s, cur_match) - deflate_state *s; - IPos cur_match; /* current match */ +local uInt longest_match_fast(deflate_state *s, IPos cur_match) { register Bytef *scan = s->window + s->strstart; /* current string */ register Bytef *match; /* matched string */ @@ -1057,10 +1032,7 @@ local uInt longest_match_fast(s, cur_match) /* =========================================================================== * Check that the match at match_start is indeed a match. */ -local void check_match(s, start, match, length) - deflate_state *s; - IPos start, match; - int length; +local void check_match(deflate_state *s, IPos start, IPos match, int length) { /* check that the match is indeed a match */ if (zmemcmp(s->window + match, @@ -1091,8 +1063,7 @@ local void check_match(s, start, match, length) * performed for at least two bytes (required for the zip translate_eol * option -- not supported here). */ -local void fill_window(s) - deflate_state *s; +local void fill_window(deflate_state *s) { register unsigned n, m; register Posf *p; @@ -1214,9 +1185,7 @@ local void fill_window(s) * NOTE: this function should be optimized to avoid extra copying from * window to pending_buf. */ -local block_state deflate_stored(s, flush) - deflate_state *s; - int flush; +local block_state deflate_stored(deflate_state *s, int flush) { /* Stored blocks are limited to 0xffff bytes, pending_buf is limited * to pending_buf_size, and each stored block has a 5 byte header: @@ -1272,9 +1241,7 @@ local block_state deflate_stored(s, flush) * new strings in the dictionary only for unmatched strings or for short * matches. It is used only for the fast compression options. */ -local block_state deflate_fast(s, flush) - deflate_state *s; - int flush; +local block_state deflate_fast(deflate_state *s, int flush) { IPos hash_head = NIL; /* head of the hash chain */ int bflush; /* set if current block must be flushed */ @@ -1378,9 +1345,7 @@ local block_state deflate_fast(s, flush) * evaluation for matches: a match is finally adopted only if there is * no better match at the next window position. */ -local block_state deflate_slow(s, flush) - deflate_state *s; - int flush; +local block_state deflate_slow(deflate_state *s, int flush) { IPos hash_head = NIL; /* head of hash chain */ int bflush; /* set if current block must be flushed */ diff --git a/zlib/deflate.h b/zlib/deflate.h index e31f66b..2aafca6 100644 --- a/zlib/deflate.h +++ b/zlib/deflate.h @@ -274,13 +274,19 @@ typedef struct internal_state { */ /* in trees.c */ -void _tr_init OF((deflate_state *s)); -int _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); +void _tr_init OF((deflate_state *s)) + /*@globals internalState @*/ + /*@modifies *s, internalState @*/; +int _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)) + /*@modifies *s @*/; void _tr_flush_block OF((deflate_state *s, charf *buf, ulg stored_len, - int eof)); -void _tr_align OF((deflate_state *s)); + int eof)) + /*@modifies *s @*/; +void _tr_align OF((deflate_state *s)) + /*@modifies *s @*/; void _tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len, - int eof)); + int eof)) + /*@modifies *s @*/; #define d_code(dist) \ ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) diff --git a/zlib/gzio.c b/zlib/gzio.c index 4afd102..0b85cb5 100644 --- a/zlib/gzio.c +++ b/zlib/gzio.c @@ -36,8 +36,10 @@ struct internal_state {int dummy;}; /* for buggy compilers */ #endif #ifndef STDC -extern voidp malloc OF((uInt size)); -extern void free OF((voidpf ptr)); +extern voidp malloc OF((uInt size)) + /*@*/; +extern void free OF((voidpf ptr)) + /*@*/; #endif #define ALLOC(size) malloc(size) @@ -57,11 +59,16 @@ typedef struct gz_stream { z_stream stream; int z_err; /* error code for last stream operation */ int z_eof; /* set if end of input file */ +/*@relnull@*/ FILE *file; /* .gz file */ +/*@relnull@*/ Byte *inbuf; /* input buffer */ +/*@relnull@*/ Byte *outbuf; /* output buffer */ uLong crc; /* crc32 of uncompressed data */ +/*@relnull@*/ char *msg; /* error message */ +/*@relnull@*/ char *path; /* path name for debugging only */ int transparent; /* 1 if input file is not a .gz file */ char mode; /* 'w' or 'r' */ @@ -73,13 +80,27 @@ typedef struct gz_stream { } gz_stream; -local gzFile gz_open OF((const char *path, const char *mode, int fd)); -local int do_flush OF((gzFile file, int flush)); -local int get_byte OF((gz_stream *s)); -local void check_header OF((gz_stream *s)); -local int destroy OF((gz_stream *s)); -local void putLong OF((FILE *file, uLong x)); -local uLong getLong OF((gz_stream *s)); +local gzFile gz_open OF((const char *path, const char *mode, int fd)) + /*@globals errno, fileSystem, internalState @*/ + /*@modifies errno, fileSystem, internalState @*/; +local int do_flush OF((gzFile file, int flush)) + /*@globals fileSystem @*/ + /*@modifies fileSystem @*/; +local int get_byte OF((gz_stream *s)) + /*@globals errno, fileSystem @*/ + /*@modifies s, errno, fileSystem @*/; +local void check_header OF((gz_stream *s)) + /*@globals errno, fileSystem @*/ + /*@modifies s, errno, fileSystem @*/; +local int destroy OF((gz_stream *s)) + /*@globals fileSystem @*/ + /*@modifies s, fileSystem @*/; +local void putLong OF((FILE *file, uLong x)) + /*@globals fileSystem @*/ + /*@modifies file, fileSystem @*/; +local uLong getLong OF((gz_stream *s)) + /*@globals fileSystem @*/ + /*@modifies s, fileSystem @*/; /* =========================================================================== Opens a gzip (.gz) file for reading or writing. The mode parameter @@ -90,10 +111,7 @@ local uLong getLong OF((gz_stream *s)); can be checked to distinguish the two cases (if errno is zero, the zlib error is Z_MEM_ERROR). */ -local gzFile gz_open (path, mode, fd) - const char *path; - const char *mode; - int fd; +local gzFile gz_open (const char *path, const char *mode, int fd) { int err; int level = Z_DEFAULT_COMPRESSION; /* compression level */ @@ -205,9 +223,7 @@ local gzFile gz_open (path, mode, fd) /* =========================================================================== Opens a gzip (.gz) file for reading or writing. */ -gzFile ZEXPORT gzopen (path, mode) - const char *path; - const char *mode; +gzFile ZEXPORT gzopen (const char *path, const char *mode) { return gz_open (path, mode, -1); } @@ -216,9 +232,7 @@ gzFile ZEXPORT gzopen (path, mode) Associate a gzFile with the file descriptor fd. fd is not dup'ed here to mimic the behavio(u)r of fdopen. */ -gzFile ZEXPORT gzdopen (fd, mode) - int fd; - const char *mode; +gzFile ZEXPORT gzdopen (int fd, const char *mode) { char name[20]; @@ -231,10 +245,7 @@ gzFile ZEXPORT gzdopen (fd, mode) /* =========================================================================== * Update the compression level and strategy */ -int ZEXPORT gzsetparams (file, level, strategy) - gzFile file; - int level; - int strategy; +int ZEXPORT gzsetparams (gzFile file, int level, int strategy) { gz_stream *s = (gz_stream*)file; @@ -258,8 +269,7 @@ int ZEXPORT gzsetparams (file, level, strategy) for end of file. IN assertion: the stream s has been sucessfully opened for reading. */ -local int get_byte(s) - gz_stream *s; +local int get_byte(gz_stream *s) { if (s->z_eof) return EOF; if (s->stream.avail_in == 0) { @@ -285,8 +295,7 @@ local int get_byte(s) s->stream.avail_in is zero for the first time, but may be non-zero for concatenated .gz files. */ -local void check_header(s) - gz_stream *s; +local void check_header(gz_stream *s) { int method; /* method byte */ int flags; /* flags byte */ @@ -352,8 +361,7 @@ local void check_header(s) * Cleanup then free the given gz_stream. Return a zlib error code. Try freeing in the reverse order of allocations. */ -local int destroy (s) - gz_stream *s; +local int destroy (gz_stream *s) { int err = Z_OK; @@ -391,10 +399,7 @@ local int destroy (s) Reads the given number of uncompressed bytes from the compressed file. gzread returns the number of bytes actually read (0 for end of file). */ -int ZEXPORT gzread (file, buf, len) - gzFile file; - voidp buf; - unsigned len; +int ZEXPORT gzread (gzFile file, voidp buf, unsigned len) { gz_stream *s = (gz_stream*)file; Bytef *start = (Bytef*)buf; /* starting point for crc computation */ @@ -496,8 +501,7 @@ int ZEXPORT gzread (file, buf, len) Reads one byte from the compressed file. gzgetc returns this byte or -1 in case of end of file or error. */ -int ZEXPORT gzgetc(file) - gzFile file; +int ZEXPORT gzgetc(gzFile file) { unsigned char c; @@ -508,9 +512,7 @@ int ZEXPORT gzgetc(file) /* =========================================================================== Push one byte back onto the stream. */ -int ZEXPORT gzungetc(c, file) - int c; - gzFile file; +int ZEXPORT gzungetc(int c, gzFile file) { gz_stream *s = (gz_stream*)file; @@ -533,10 +535,7 @@ int ZEXPORT gzungetc(c, file) The current implementation is not optimized at all. */ -char * ZEXPORT gzgets(file, buf, len) - gzFile file; - char *buf; - int len; +char * ZEXPORT gzgets(gzFile file, char *buf, int len) { char *b = buf; if (buf == Z_NULL || len <= 0) return Z_NULL; @@ -552,10 +551,7 @@ char * ZEXPORT gzgets(file, buf, len) Writes the given number of uncompressed bytes into the compressed file. gzwrite returns the number of bytes actually written (0 in case of error). */ -int ZEXPORT gzwrite (file, buf, len) - gzFile file; - voidpc buf; - unsigned len; +int ZEXPORT gzwrite (gzFile file, voidpc buf, unsigned len) { gz_stream *s = (gz_stream*)file; @@ -630,12 +626,11 @@ int ZEXPORTVA gzprintf (gzFile file, const char *format, /* args */ ...) } #else /* not ANSI C */ -int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, - a11, a12, a13, a14, a15, a16, a17, a18, a19, a20) - gzFile file; - const char *format; - int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, - a11, a12, a13, a14, a15, a16, a17, a18, a19, a20; +int ZEXPORTVA gzprintf (gzFile file, const char *format, + int a1, int a2, int a3, int a4, int a5, + int a6, int a7, int a8, int a9, int a10, + int a11, int a12, int a13, int a14, int a15, + int a16, int a17, int a18, int a19, int a20) { char buf[Z_PRINTF_BUFSIZE]; int len; @@ -671,9 +666,7 @@ int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, Writes c, converted to an unsigned char, into the compressed file. gzputc returns the value that was written, or -1 in case of error. */ -int ZEXPORT gzputc(file, c) - gzFile file; - int c; +int ZEXPORT gzputc(gzFile file, int c) { unsigned char cc = (unsigned char) c; /* required for big endian systems */ @@ -686,9 +679,7 @@ int ZEXPORT gzputc(file, c) the terminating null character. gzputs returns the number of characters written, or -1 in case of error. */ -int ZEXPORT gzputs(file, s) - gzFile file; - const char *s; +int ZEXPORT gzputs(gzFile file, const char *s) { return gzwrite(file, (char*)s, (unsigned)strlen(s)); } @@ -698,9 +689,7 @@ int ZEXPORT gzputs(file, s) Flushes all pending output into the compressed file. The parameter flush is as in the deflate() function. */ -local int do_flush (file, flush) - gzFile file; - int flush; +local int do_flush (gzFile file, int flush) { uInt len; int done = 0; @@ -739,9 +728,7 @@ local int do_flush (file, flush) return s->z_err == Z_STREAM_END ? Z_OK : s->z_err; } -int ZEXPORT gzflush (file, flush) - gzFile file; - int flush; +int ZEXPORT gzflush (gzFile file, int flush) { gz_stream *s = (gz_stream*)file; int err = do_flush (file, flush); @@ -760,10 +747,7 @@ int ZEXPORT gzflush (file, flush) SEEK_END is not implemented, returns error. In this version of the library, gzseek can be extremely slow. */ -z_off_t ZEXPORT gzseek (file, offset, whence) - gzFile file; - z_off_t offset; - int whence; +z_off_t ZEXPORT gzseek (gzFile file, z_off_t offset, int whence) { gz_stream *s = (gz_stream*)file; @@ -850,8 +834,7 @@ z_off_t ZEXPORT gzseek (file, offset, whence) /* =========================================================================== Rewinds input file. */ -int ZEXPORT gzrewind (file) - gzFile file; +int ZEXPORT gzrewind (gzFile file) { gz_stream *s = (gz_stream*)file; @@ -874,8 +857,7 @@ int ZEXPORT gzrewind (file) given compressed file. This position represents a number of bytes in the uncompressed data stream. */ -z_off_t ZEXPORT gztell (file) - gzFile file; +z_off_t ZEXPORT gztell (gzFile file) { return gzseek(file, 0L, SEEK_CUR); } @@ -884,8 +866,7 @@ z_off_t ZEXPORT gztell (file) Returns 1 when EOF has previously been detected reading the given input stream, otherwise zero. */ -int ZEXPORT gzeof (file) - gzFile file; +int ZEXPORT gzeof (gzFile file) { gz_stream *s = (gz_stream*)file; @@ -901,9 +882,7 @@ int ZEXPORT gzeof (file) /* =========================================================================== Outputs a long in LSB order to the given file */ -local void putLong (file, x) - FILE *file; - uLong x; +local void putLong (FILE *file, uLong x) { int n; for (n = 0; n < 4; n++) { @@ -916,8 +895,7 @@ local void putLong (file, x) Reads a long in LSB order from the given gz_stream. Sets z_err in case of error. */ -local uLong getLong (s) - gz_stream *s; +local uLong getLong (gz_stream *s) { uLong x = (uLong)get_byte(s); int c; @@ -934,8 +912,7 @@ local uLong getLong (s) Flushes all pending output if necessary, closes the compressed file and deallocates all the (de)compression state. */ -int ZEXPORT gzclose (file) - gzFile file; +int ZEXPORT gzclose (gzFile file) { int err; gz_stream *s = (gz_stream*)file; @@ -963,9 +940,7 @@ int ZEXPORT gzclose (file) errnum is set to Z_ERRNO and the application may consult errno to get the exact error code. */ -const char * ZEXPORT gzerror (file, errnum) - gzFile file; - int *errnum; +const char * ZEXPORT gzerror (gzFile file, int *errnum) { char *m; gz_stream *s = (gz_stream*)file; @@ -993,8 +968,7 @@ const char * ZEXPORT gzerror (file, errnum) /* =========================================================================== Clear the error and end-of-file flags, and do the same for the real file. */ -void ZEXPORT gzclearerr (file) - gzFile file; +void ZEXPORT gzclearerr (gzFile file) { gz_stream *s = (gz_stream*)file; diff --git a/zlib/infback.c b/zlib/infback.c index 110b03b..25b7466 100644 --- a/zlib/infback.c +++ b/zlib/infback.c @@ -16,7 +16,8 @@ #include "inffast.h" /* function prototypes */ -local void fixedtables OF((struct inflate_state FAR *state)); +local void fixedtables OF((struct inflate_state FAR *state)) + /*@modifies state @*/; /* strm provides memory allocation functions in zalloc and zfree, or @@ -25,12 +26,7 @@ local void fixedtables OF((struct inflate_state FAR *state)); windowBits is in the range 8..15, and window is a user-supplied window and output buffer that is 2**windowBits bytes. */ -int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size) -z_stream FAR *strm; -int windowBits; -unsigned char FAR *window; -const char *version; -int stream_size; +int ZEXPORT inflateBackInit_(z_stream FAR *strm, int windowBits, unsigned char FAR *window, const char *version, int stream_size) { struct inflate_state FAR *state; @@ -69,8 +65,7 @@ int stream_size; used for threaded applications, since the rewriting of the tables and virgin may not be thread-safe. */ -local void fixedtables(state) -struct inflate_state FAR *state; +local void fixedtables(struct inflate_state FAR *state) { #ifdef BUILDFIXED static int virgin = 1; @@ -237,12 +232,7 @@ struct inflate_state FAR *state; inflateBack() can also return Z_STREAM_ERROR if the input parameters are not correct, i.e. strm is Z_NULL or the state was not initialized. */ -int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc) -z_stream FAR *strm; -in_func in; -void FAR *in_desc; -out_func out; -void FAR *out_desc; +int ZEXPORT inflateBack(z_stream FAR *strm, in_func in, void FAR *in_desc, out_func out, void FAR *out_desc) { struct inflate_state FAR *state; unsigned char FAR *next; /* next input */ @@ -607,8 +597,7 @@ void FAR *out_desc; return ret; } -int ZEXPORT inflateBackEnd(strm) -z_stream FAR *strm; +int ZEXPORT inflateBackEnd(z_stream FAR *strm) { if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) return Z_STREAM_ERROR; diff --git a/zlib/inffast.c b/zlib/inffast.c index c716440..09659bd 100644 --- a/zlib/inffast.c +++ b/zlib/inffast.c @@ -64,9 +64,7 @@ requires strm->avail_out >= 258 for each loop to avoid checking for output space. */ -void inflate_fast(strm, start) -z_streamp strm; -unsigned start; /* inflate()'s starting value for strm->avail_out */ +void inflate_fast(z_streamp strm, unsigned start) { struct inflate_state FAR *state; unsigned char FAR *in; /* local strm->next_in */ diff --git a/zlib/inffast.h b/zlib/inffast.h index 1e88d2d..49704c5 100644 --- a/zlib/inffast.h +++ b/zlib/inffast.h @@ -8,4 +8,5 @@ subject to change. Applications should only use zlib.h. */ -void inflate_fast OF((z_streamp strm, unsigned start)); +void inflate_fast OF((z_streamp strm, unsigned start)) + /*@modifies strm @*/; diff --git a/zlib/inflate.c b/zlib/inflate.c index a53b5c7..1091a7d 100644 --- a/zlib/inflate.c +++ b/zlib/inflate.c @@ -92,16 +92,19 @@ #endif /* function prototypes */ -local void fixedtables OF((struct inflate_state FAR *state)); -local int updatewindow OF((z_streamp strm, unsigned out)); +local void fixedtables OF((struct inflate_state FAR *state)) + /*@modifies state @*/; +local int updatewindow OF((z_streamp strm, unsigned out)) + /*@*/; #ifdef BUILDFIXED - void makefixed OF((void)); + void makefixed OF((void)) + /*@*/; #endif local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf, - unsigned len)); + unsigned len)) + /*@modifies *have @*/; -int ZEXPORT inflateReset(strm) -z_streamp strm; +int ZEXPORT inflateReset(z_streamp strm) { struct inflate_state FAR *state; @@ -121,11 +124,7 @@ z_streamp strm; return Z_OK; } -int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size) -z_streamp strm; -int windowBits; -const char *version; -int stream_size; +int ZEXPORT inflateInit2_(z_streamp strm, int windowBits, const char *version, int stream_size) { struct inflate_state FAR *state; @@ -164,10 +163,7 @@ int stream_size; return inflateReset(strm); } -int ZEXPORT inflateInit_(strm, version, stream_size) -z_streamp strm; -const char *version; -int stream_size; +int ZEXPORT inflateInit_(z_streamp strm, const char *version, int stream_size) { return inflateInit2_(strm, DEF_WBITS, version, stream_size); } @@ -182,8 +178,7 @@ int stream_size; used for threaded applications, since the rewriting of the tables and virgin may not be thread-safe. */ -local void fixedtables(state) -struct inflate_state FAR *state; +local void fixedtables(struct inflate_state FAR *state) { #ifdef BUILDFIXED static int virgin = 1; @@ -246,7 +241,7 @@ struct inflate_state FAR *state; a.out > inffixed.h */ -void makefixed() +void makefixed(void) { unsigned low, size; struct inflate_state state; @@ -300,9 +295,7 @@ void makefixed() output will fall in the output data, making match copies simpler and faster. The advantage may be dependent on the size of the processor's data caches. */ -local int updatewindow(strm, out) -z_streamp strm; -unsigned out; +local int updatewindow(z_streamp strm, unsigned out) { struct inflate_state FAR *state; unsigned copy, dist; @@ -531,9 +524,7 @@ unsigned out; will return Z_BUF_ERROR if it has not reached the end of the stream. */ -int ZEXPORT inflate(strm, flush) -z_streamp strm; -int flush; +int ZEXPORT inflate(z_streamp strm, int flush) { struct inflate_state FAR *state; unsigned char FAR *next; /* next input */ @@ -1081,8 +1072,7 @@ int flush; return ret; } -int ZEXPORT inflateEnd(strm) -z_streamp strm; +int ZEXPORT inflateEnd(z_streamp strm) { struct inflate_state FAR *state; if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) @@ -1095,10 +1085,7 @@ z_streamp strm; return Z_OK; } -int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength) -z_streamp strm; -const Bytef *dictionary; -uInt dictLength; +int ZEXPORT inflateSetDictionary(z_streamp strm, const Bytef *dictionary, uInt dictLength) { struct inflate_state FAR *state; unsigned long id; @@ -1144,10 +1131,7 @@ uInt dictLength; called again with more data and the *have state. *have is initialized to zero for the first call. */ -local unsigned syncsearch(have, buf, len) -unsigned FAR *have; -unsigned char FAR *buf; -unsigned len; +local unsigned syncsearch(unsigned FAR *have, unsigned char FAR *buf, unsigned len) { unsigned got; unsigned next; @@ -1167,8 +1151,7 @@ unsigned len; return next; } -int ZEXPORT inflateSync(strm) -z_streamp strm; +int ZEXPORT inflateSync(z_streamp strm) { unsigned len; /* number of bytes to look at or looked at */ unsigned long in, out; /* temporary to save total_in and total_out */ @@ -1218,8 +1201,7 @@ z_streamp strm; block. When decompressing, PPP checks that at the end of input packet, inflate is waiting for these length bytes. */ -int ZEXPORT inflateSyncPoint(strm) -z_streamp strm; +int ZEXPORT inflateSyncPoint(z_streamp strm) { struct inflate_state FAR *state; @@ -1228,9 +1210,7 @@ z_streamp strm; return state->mode == STORED && state->bits == 0; } -int ZEXPORT inflateCopy(dest, source) -z_streamp dest; -z_streamp source; +int ZEXPORT inflateCopy(z_streamp dest, z_streamp source) { struct inflate_state FAR *state; struct inflate_state FAR *copy; diff --git a/zlib/inftrees.c b/zlib/inftrees.c index 767ae1f..01c58b9 100644 --- a/zlib/inftrees.c +++ b/zlib/inftrees.c @@ -29,13 +29,7 @@ const char inflate_copyright[] = table index bits. It will differ if the request is greater than the longest code or if it is less than the shortest code. */ -int inflate_table(type, lens, codes, table, bits, work) -codetype type; -unsigned short FAR *lens; -unsigned codes; -code FAR * FAR *table; -unsigned FAR *bits; -unsigned short FAR *work; +int inflate_table(codetype type, unsigned short FAR *lens, unsigned codes, code FAR * FAR *table, unsigned FAR *bits, unsigned short FAR *work) { unsigned len; /* a code's length in bits */ unsigned sym; /* index of code symbols */ diff --git a/zlib/inftrees.h b/zlib/inftrees.h index 82d365a..af4ed7b 100644 --- a/zlib/inftrees.h +++ b/zlib/inftrees.h @@ -52,4 +52,5 @@ typedef enum { extern int inflate_table OF((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)) + /*@modifies *lens, *table, *bits, *work @*/; diff --git a/zlib/trees.c b/zlib/trees.c index 9f8d637..4fa7db6 100644 --- a/zlib/trees.c +++ b/zlib/trees.c @@ -139,28 +139,46 @@ 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 tr_static_init OF((void)) + /*@globals internalState @*/ + /*@modifies internalState @*/; +local void init_block OF((deflate_state *s)) + /*@modifies *s @*/; +local void pqdownheap OF((deflate_state *s, ct_data *tree, int k)) + /*@modifies *s @*/; +local void gen_bitlen OF((deflate_state *s, tree_desc *desc)) + /*@modifies *s, *desc @*/; +local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count)) + /*@modifies *tree @*/; +local void build_tree OF((deflate_state *s, tree_desc *desc)) + /*@modifies *s, *desc @*/; +local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code)) + /*@modifies *s, *tree @*/; +local void send_tree OF((deflate_state *s, ct_data *tree, int max_code)) + /*@modifies *s @*/; +local int build_bl_tree OF((deflate_state *s)) + /*@modifies *s @*/; local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes, - int blcodes)); + int blcodes)) + /*@modifies *s @*/; local void compress_block OF((deflate_state *s, ct_data *ltree, - ct_data *dtree)); -local void set_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)); + ct_data *dtree)) + /*@modifies *s @*/; +local void set_data_type OF((deflate_state *s)) + /*@modifies *s @*/; +local unsigned bi_reverse OF((unsigned value, int length)) + /*@*/; +local void bi_windup OF((deflate_state *s)) + /*@modifies *s @*/; +local void bi_flush OF((deflate_state *s)) + /*@modifies *s @*/; local void copy_block OF((deflate_state *s, charf *buf, unsigned len, - int header)); + int header)) + /*@modifies *s @*/; #ifdef GEN_TREES_H -local void gen_trees_header OF((void)); +local void gen_trees_header OF((void)) + /*@*/; #endif #ifndef DEBUG @@ -187,12 +205,10 @@ local void gen_trees_header OF((void)); * IN assertion: length <= 16 and value fits in length bits. */ #ifdef DEBUG -local void send_bits OF((deflate_state *s, int value, int length)); +local void send_bits OF((deflate_state *s, int value, int length)) + /*@*/; -local void send_bits(s, value, length) - deflate_state *s; - int value; /* value to send */ - int length; /* number of bits */ +local void send_bits(deflate_state *s, int value, int length) { Tracevv((stderr," l %2d v %4x ", length, value)); Assert(length > 0 && length <= 15, "invalid length"); @@ -235,7 +251,7 @@ local void send_bits(s, value, length) /* =========================================================================== * Initialize the various 'constant' tables. */ -local void tr_static_init() +local void tr_static_init(void) { #if defined(GEN_TREES_H) || !defined(STDC) static int static_init_done = 0; @@ -327,7 +343,7 @@ local void tr_static_init() ((i) == (last)? "\n};\n\n" : \ ((i) % (width) == (width)-1 ? ",\n" : ", ")) -void gen_trees_header() +void gen_trees_header(void) { FILE *header = fopen("trees.h", "w"); int i; @@ -379,8 +395,7 @@ void gen_trees_header() /* =========================================================================== * Initialize the tree data structures for a new zlib stream. */ -void _tr_init(s) - deflate_state *s; +void _tr_init(deflate_state *s) { tr_static_init(); @@ -408,8 +423,7 @@ void _tr_init(s) /* =========================================================================== * Initialize a new block. */ -local void init_block(s) - deflate_state *s; +local void init_block(deflate_state *s) { int n; /* iterates over tree elements */ @@ -452,10 +466,7 @@ local void init_block(s) * when the heap property is re-established (each father smaller than its * two sons). */ -local void pqdownheap(s, tree, k) - deflate_state *s; - ct_data *tree; /* the tree to restore */ - int k; /* node to move down */ +local void pqdownheap(deflate_state *s, ct_data *tree, int k) { int v = s->heap[k]; int j = k << 1; /* left son of k */ @@ -487,9 +498,7 @@ local void pqdownheap(s, tree, k) * The length opt_len is updated; static_len is also updated if stree is * not null. */ -local void gen_bitlen(s, desc) - deflate_state *s; - tree_desc *desc; /* the tree descriptor */ +local void gen_bitlen(deflate_state *s, tree_desc *desc) { ct_data *tree = desc->dyn_tree; int max_code = desc->max_code; @@ -574,10 +583,7 @@ local void gen_bitlen(s, desc) * OUT assertion: the field code is set for all tree elements of non * zero code length. */ -local void gen_codes (tree, max_code, bl_count) - ct_data *tree; /* the tree to decorate */ - int max_code; /* largest code with non zero frequency */ - ushf *bl_count; /* number of codes at each bit length */ +local void gen_codes (ct_data *tree, int max_code, ushf *bl_count) { ush next_code[MAX_BITS+1]; /* next code value for each bit length */ ush code = 0; /* running code value */ @@ -616,9 +622,7 @@ local void gen_codes (tree, max_code, bl_count) * and corresponding code. The length opt_len is updated; static_len is * also updated if stree is not null. The field max_code is set. */ -local void build_tree(s, desc) - deflate_state *s; - tree_desc *desc; /* the tree descriptor */ +local void build_tree(deflate_state *s, tree_desc *desc) { ct_data *tree = desc->dyn_tree; const ct_data *stree = desc->stat_desc->static_tree; @@ -704,10 +708,7 @@ local void build_tree(s, desc) * Scan a literal or distance tree to determine the frequencies of the codes * in the bit length tree. */ -local void scan_tree (s, tree, max_code) - deflate_state *s; - ct_data *tree; /* the tree to be scanned */ - int max_code; /* and its largest code of non zero frequency */ +local void scan_tree (deflate_state *s, ct_data *tree, int max_code) { int n; /* iterates over all tree elements */ int prevlen = -1; /* last emitted length */ @@ -749,10 +750,7 @@ local void scan_tree (s, tree, max_code) * Send a literal or distance tree in compressed form, using the codes in * bl_tree. */ -local void send_tree (s, tree, max_code) - deflate_state *s; - ct_data *tree; /* the tree to be scanned */ - int max_code; /* and its largest code of non zero frequency */ +local void send_tree (deflate_state *s, ct_data *tree, int max_code) { int n; /* iterates over all tree elements */ int prevlen = -1; /* last emitted length */ @@ -800,8 +798,7 @@ local void send_tree (s, tree, max_code) * Construct the Huffman tree for the bit lengths and return the index in * bl_order of the last bit length code to send. */ -local int build_bl_tree(s) - deflate_state *s; +local int build_bl_tree(deflate_state *s) { int max_blindex; /* index of last bit length code of non zero freq */ @@ -835,9 +832,7 @@ local int build_bl_tree(s) * lengths of the bit length codes, the literal tree and the distance tree. * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. */ -local void send_all_trees(s, lcodes, dcodes, blcodes) - deflate_state *s; - int lcodes, dcodes, blcodes; /* number of codes for each tree */ +local void send_all_trees(deflate_state *s, int lcodes, int dcodes, int blcodes) { int rank; /* index in bl_order */ @@ -864,11 +859,7 @@ local void send_all_trees(s, lcodes, dcodes, blcodes) /* =========================================================================== * Send a stored block */ -void _tr_stored_block(s, buf, stored_len, eof) - deflate_state *s; - charf *buf; /* input block */ - ulg stored_len; /* length of input block */ - int eof; /* true if this is the last block for a file */ +void _tr_stored_block(deflate_state *s, charf *buf, ulg stored_len, int eof) { send_bits(s, (STORED_BLOCK<<1)+eof, 3); /* send block type */ #ifdef DEBUG @@ -889,8 +880,7 @@ void _tr_stored_block(s, buf, stored_len, eof) * To simplify the code, we assume the worst case of last real code encoded * on one bit only. */ -void _tr_align(s) - deflate_state *s; +void _tr_align(deflate_state *s) { send_bits(s, STATIC_TREES<<1, 3); send_code(s, END_BLOCK, static_ltree); @@ -918,11 +908,7 @@ void _tr_align(s) * Determine the best encoding for the current block: dynamic trees, static * trees or store, and output the encoded block to the zip file. */ -void _tr_flush_block(s, buf, stored_len, eof) - deflate_state *s; - charf *buf; /* input block, or NULL if too old */ - ulg stored_len; /* length of input block */ - int eof; /* true if this is the last block for a file */ +void _tr_flush_block(deflate_state *s, charf *buf, ulg stored_len, int eof) { ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ int max_blindex = 0; /* index of last bit length code of non zero freq */ @@ -1018,10 +1004,7 @@ void _tr_flush_block(s, buf, stored_len, eof) * Save the match info and tally the frequency counts. Return true if * the current block must be flushed. */ -int _tr_tally (s, dist, lc) - deflate_state *s; - unsigned dist; /* distance of matched string */ - unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ +int _tr_tally (deflate_state *s, unsigned dist, unsigned lc) { s->d_buf[s->last_lit] = (ush)dist; s->l_buf[s->last_lit++] = (uch)lc; @@ -1068,10 +1051,7 @@ int _tr_tally (s, dist, lc) /* =========================================================================== * Send the block data compressed using the given Huffman trees */ -local void compress_block(s, ltree, dtree) - deflate_state *s; - ct_data *ltree; /* literal tree */ - ct_data *dtree; /* distance tree */ +local void compress_block(deflate_state *s, ct_data *ltree, ct_data *dtree) { unsigned dist; /* distance of matched string */ int lc; /* match length or unmatched char (if dist == 0) */ @@ -1122,8 +1102,7 @@ local void compress_block(s, ltree, dtree) * IN assertion: the fields freq of dyn_ltree are set and the total of all * frequencies does not exceed 64K (to fit in an int on 16 bit machines). */ -local void set_data_type(s) - deflate_state *s; +local void set_data_type(deflate_state *s) { int n = 0; unsigned ascii_freq = 0; @@ -1152,8 +1131,7 @@ local unsigned bi_reverse(unsigned code, int len) /* =========================================================================== * Flush the bit buffer, keeping at most 7 bits in it. */ -local void bi_flush(s) - deflate_state *s; +local void bi_flush(deflate_state *s) { if (s->bi_valid == 16) { put_short(s, s->bi_buf); @@ -1169,8 +1147,7 @@ local void bi_flush(s) /* =========================================================================== * Flush the bit buffer and align the output on a byte boundary */ -local void bi_windup(s) - deflate_state *s; +local void bi_windup(deflate_state *s) { if (s->bi_valid > 8) { put_short(s, s->bi_buf); @@ -1188,11 +1165,7 @@ local void bi_windup(s) * Copy a stored block, storing first the length and its * one's complement if requested. */ -local void copy_block(s, buf, len, header) - deflate_state *s; - charf *buf; /* the input data */ - unsigned len; /* its length */ - int header; /* true if block header must be written */ +local void copy_block(deflate_state *s, charf *buf, unsigned len, int header) { bi_windup(s); /* align on byte boundary */ s->last_eob_len = 8; /* enough lookahead for inflate */ diff --git a/zlib/uncompr.c b/zlib/uncompr.c index b59e3d0..953fbd6 100644 --- a/zlib/uncompr.c +++ b/zlib/uncompr.c @@ -23,11 +23,7 @@ enough memory, Z_BUF_ERROR if there was not enough room in the output buffer, or Z_DATA_ERROR if the input data was corrupted. */ -int ZEXPORT uncompress (dest, destLen, source, sourceLen) - Bytef *dest; - uLongf *destLen; - const Bytef *source; - uLong sourceLen; +int ZEXPORT uncompress (Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen) { z_stream stream; int err; diff --git a/zlib/zconf.h b/zlib/zconf.h index 5e10dcf..f629313 100644 --- a/zlib/zconf.h +++ b/zlib/zconf.h @@ -155,7 +155,7 @@ /* Type declarations */ #ifndef OF /* function prototypes */ -# ifdef STDC +# if defined(STDC) || defined(__LCLINT__) # define OF(args) args # else # define OF(args) () diff --git a/zlib/zlib.h b/zlib/zlib.h index c97f682..3dc8130 100644 --- a/zlib/zlib.h +++ b/zlib/zlib.h @@ -76,25 +76,34 @@ extern "C" { crash 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) OF((voidpf opaque, uInt items, uInt size)) + /*@*/; +typedef void (*free_func) OF((voidpf opaque, voidpf address)) + /*@*/; struct internal_state; typedef struct z_stream_s { +/*@relnull@*/ Bytef *next_in; /* next input byte */ uInt avail_in; /* number of bytes available at next_in */ uLong total_in; /* total nb of input bytes read so far */ +/*@relnull@*/ Bytef *next_out; /* next output byte should be put there */ uInt avail_out; /* remaining free space at next_out */ uLong total_out; /* total nb of bytes output so far */ +/*@relnull@*/ char *msg; /* last error message, NULL if no error */ +/*@relnull@*/ struct internal_state FAR *state; /* not visible by applications */ +/*@relnull@*/ alloc_func zalloc; /* used to allocate the internal state */ +/*@relnull@*/ free_func zfree; /* used to free the internal state */ +/*@relnull@*/ voidpf opaque; /* private data object passed to zalloc and zfree */ int data_type; /* best guess about the data type: ascii or binary */ @@ -186,7 +195,8 @@ typedef z_stream FAR *z_streamp; /* basic functions */ -ZEXTERN const char * ZEXPORT zlibVersion OF((void)); +ZEXTERN const char * ZEXPORT zlibVersion OF((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. @@ -216,7 +226,8 @@ ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level)); */ -ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); +ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)) + /*@modifies strm @*/; /* deflate compresses as much data as possible, and stops when the input buffer becomes empty or the output buffer becomes full. It may introduce some @@ -298,7 +309,8 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); */ -ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)); +ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm)) + /*@modifies strm @*/; /* All dynamically allocated data structures for this stream are freed. This function discards any unprocessed input and does not flush any @@ -333,7 +345,8 @@ ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); */ -ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); +ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)) + /*@modifies strm @*/; /* inflate decompresses as much data as possible, and stops when the input buffer becomes empty or the output buffer becomes full. It may introduce @@ -432,7 +445,8 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); */ -ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)); +ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm)) + /*@modifies strm @*/; /* All dynamically allocated data structures for this stream are freed. This function discards any unprocessed input and does not flush any @@ -507,7 +521,8 @@ ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, const Bytef *dictionary, - uInt dictLength)); + uInt dictLength)) + /*@modifies strm @*/; /* Initializes the compression dictionary from the given byte sequence without producing any compressed output. This function must be called @@ -543,7 +558,8 @@ ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, */ ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, - z_streamp source)); + z_streamp source)) + /*@modifies dest, source @*/; /* Sets the destination stream as a complete copy of the source stream. @@ -560,7 +576,9 @@ ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, destination. */ -ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); +ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)) + /*@globals internalState @*/ + /*@modifies strm, internalState @*/; /* This function is equivalent to deflateEnd followed by deflateInit, but does not free and reallocate all the internal compression state. @@ -573,7 +591,8 @@ ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, int level, - int strategy)); + int strategy)) + /*@modifies strm @*/; /* Dynamically update the compression level and compression strategy. The interpretation of level and strategy is as in deflateInit2. This can be @@ -593,7 +612,8 @@ ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, */ ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, - uLong sourceLen)); + uLong sourceLen)) + /*@modifies strm @*/; /* deflateBound() returns an upper bound on the compressed size after deflation of sourceLen bytes. It must be called after deflateInit() @@ -603,7 +623,8 @@ ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, int bits, - int value)); + int value)) + /*@modifies strm @*/; /* deflatePrime() inserts bits in the deflate output stream. The intent is that this function is used to start off the deflate output with the @@ -661,7 +682,8 @@ ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, const Bytef *dictionary, - uInt dictLength)); + uInt dictLength)) + /*@modifies strm @*/; /* Initializes the decompression dictionary from the given uncompressed byte sequence. This function must be called immediately after a call of inflate @@ -678,7 +700,8 @@ ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, inflate(). */ -ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); +ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)) + /*@modifies strm @*/; /* Skips invalid compressed data until a full flush point (see above the description of deflate with Z_FULL_FLUSH) can be found, or until all @@ -694,7 +717,8 @@ ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); */ ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, - z_streamp source)); + z_streamp source)) + /*@modifies dest, source @*/; /* Sets the destination stream as a complete copy of the source stream. @@ -709,7 +733,8 @@ ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, destination. */ -ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); +ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)) + /*@modifies strm @*/; /* This function is equivalent to inflateEnd followed by inflateInit, but does not free and reallocate all the internal decompression state. @@ -741,12 +766,15 @@ ZEXTERN int ZEXPORT inflateBackInit OF((z_stream FAR *strm, int windowBits, match the version of the header file. */ -typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *)); -typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); +typedef unsigned (*in_func) OF((void FAR *, unsigned char FAR * FAR *)) + /*@*/; +typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)) + /*@*/; ZEXTERN int ZEXPORT inflateBack OF((z_stream FAR *strm, in_func in, void FAR *in_desc, - out_func out, void FAR *out_desc)); + out_func out, void FAR *out_desc)) + /*@modifies strm @*/; /* inflateBack() does a raw inflate with a single call using a call-back interface for input and output. This is more efficient than inflate() for @@ -813,7 +841,8 @@ ZEXTERN int ZEXPORT inflateBack OF((z_stream FAR *strm, that inflateBack() cannot return Z_OK. */ -ZEXTERN int ZEXPORT inflateBackEnd OF((z_stream FAR *strm)); +ZEXTERN int ZEXPORT inflateBackEnd OF((z_stream FAR *strm)) + /*@modifies strm @*/; /* All memory allocated by inflateBackInit() is freed. @@ -821,7 +850,8 @@ ZEXTERN int ZEXPORT inflateBackEnd OF((z_stream FAR *strm)); state was inconsistent. */ -ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); +ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)) + /*@*/; /* Return flags indicating compile-time options. Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: @@ -874,7 +904,9 @@ ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); */ ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, - const Bytef *source, uLong sourceLen)); + const Bytef *source, uLong sourceLen)) + /*@globals internalState @*/ + /*@modifies *dest, *destLen, internalState @*/; /* Compresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total @@ -890,7 +922,9 @@ ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, const Bytef *source, uLong sourceLen, - int level)); + int level)) + /*@globals internalState @*/ + /*@modifies *dest, *destLen, internalState @*/; /* Compresses the source buffer into the destination buffer. The level parameter has the same meaning as in deflateInit. sourceLen is the byte @@ -904,7 +938,8 @@ 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 OF((uLong sourceLen)) + /*@*/; /* compressBound() returns an upper bound on the compressed size after compress() or compress2() on sourceLen bytes. It would be used before @@ -912,7 +947,8 @@ ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); */ ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, - const Bytef *source, uLong sourceLen)); + const Bytef *source, uLong sourceLen)) + /*@modifies *dest, *destLen @*/; /* Decompresses the source buffer into the destination buffer. sourceLen is the byte length of the source buffer. Upon entry, destLen is the total @@ -932,7 +968,9 @@ ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, typedef voidp gzFile; -ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); +ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)) + /*@globals fileSystem, internalState @*/ + /*@modifies fileSystem, internalState @*/; /* 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 @@ -949,7 +987,9 @@ ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); can be checked to distinguish the two cases (if errno is zero, the zlib error is Z_MEM_ERROR). */ -ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); +ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)) + /*@globals fileSystem, internalState @*/ + /*@modifies fileSystem, internalState @*/; /* gzdopen() associates a gzFile with the file descriptor fd. File descriptors are obtained from calls like open, dup, creat, pipe or @@ -962,7 +1002,9 @@ ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); the (de)compression state. */ -ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); +ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)) + /*@globals fileSystem @*/ + /*@modifies file, fileSystem @*/; /* Dynamically update the compression level or strategy. See the description of deflateInit2 for the meaning of these parameters. @@ -970,7 +1012,9 @@ 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 OF((gzFile file, voidp buf, unsigned len)) + /*@globals errno, fileSystem @*/ + /*@modifies file, *buf, errno, fileSystem @*/; /* Reads the given number of uncompressed bytes from the compressed file. If the input file was not in gzip format, gzread copies the given number @@ -979,14 +1023,18 @@ ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); end of file, -1 for error). */ ZEXTERN int ZEXPORT gzwrite OF((gzFile file, - voidpc buf, unsigned len)); + voidpc buf, unsigned len)) + /*@globals fileSystem @*/ + /*@modifies file, fileSystem @*/; /* Writes the given number of uncompressed bytes into the compressed file. gzwrite returns the number of uncompressed bytes actually written (0 in case of error). */ -ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); +ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)) + /*@globals fileSystem @*/ + /*@modifies file, fileSystem @*/; /* Converts, formats, and writes the args to the compressed file under control of the format string, as in fprintf. gzprintf returns the number of @@ -999,14 +1047,18 @@ ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...)); because the secure snprintf() or vsnprintf() functions were not available. */ -ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)) + /*@globals fileSystem @*/ + /*@modifies file, fileSystem @*/; /* Writes the given null-terminated string to the compressed file, excluding the terminating null character. 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 OF((gzFile file, char *buf, int len)) + /*@globals fileSystem @*/ + /*@modifies file, buf, fileSystem @*/; /* 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 @@ -1015,19 +1067,24 @@ ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); gzgets returns buf, or Z_NULL in case of error. */ -ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); +ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)) + /*@globals fileSystem @*/ + /*@modifies file, fileSystem @*/; /* 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 OF((gzFile file)) + /*@globals fileSystem @*/ + /*@modifies file, fileSystem @*/; /* Reads one byte from the compressed file. gzgetc returns this byte or -1 in case of end of file or error. */ -ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); +ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)) + /*@*/; /* Push one character back onto the stream to be read again later. Only one character of push-back is allowed. gzungetc() returns the @@ -1037,7 +1094,9 @@ ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); or gzrewind(). */ -ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); +ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)) + /*@globals fileSystem @*/ + /*@modifies file, fileSystem @*/; /* Flushes all pending output into the compressed file. The parameter flush is as in the deflate() function. The return value is the zlib @@ -1048,7 +1107,9 @@ ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); */ ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, - z_off_t offset, int whence)); + z_off_t offset, int whence)) + /*@globals fileSystem @*/ + /*@modifies file, fileSystem @*/; /* Sets the starting position for the next gzread or gzwrite on the given compressed file. The offset represents a number of bytes in the @@ -1065,14 +1126,18 @@ 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 OF((gzFile file)) + /*@globals fileSystem @*/ + /*@modifies file, fileSystem @*/; /* Rewinds the given file. This function is supported only for reading. gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) */ -ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); +ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)) + /*@globals fileSystem @*/ + /*@modifies file, fileSystem @*/; /* Returns the starting position for the next gzread or gzwrite on the given compressed file. This position represents a number of bytes in the @@ -1081,20 +1146,24 @@ ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) */ -ZEXTERN int ZEXPORT gzeof OF((gzFile file)); +ZEXTERN int ZEXPORT gzeof OF((gzFile file)) + /*@*/; /* Returns 1 when EOF has previously been detected reading the given input stream, otherwise zero. */ -ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +ZEXTERN int ZEXPORT gzclose OF((gzFile file)) + /*@globals fileSystem @*/ + /*@modifies file, fileSystem @*/; /* Flushes all pending output if necessary, closes the compressed file and deallocates all the (de)compression state. The return value is the zlib error number (see function gzerror below). */ -ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); +ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)) + /*@modifies *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 @@ -1103,7 +1172,8 @@ ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); to get the exact error code. */ -ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); +ZEXTERN void ZEXPORT gzclearerr OF((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 @@ -1118,7 +1188,8 @@ ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); compression library. */ -ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); +ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)) + /*@*/; /* Update a running Adler-32 checksum with the bytes buf[0..len-1] and @@ -1135,7 +1206,8 @@ ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); if (adler != original_adler) error(); */ -ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); +ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)) + /*@*/; /* Update a running crc with the bytes buf[0..len-1] and return the updated crc. If buf is NULL, this function returns the required initial value @@ -1158,19 +1230,26 @@ ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); * and the compiler's view of z_stream: */ ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, - const char *version, int stream_size)); + const char *version, int stream_size)) + /*@globals internalState @*/ + /*@modifies strm, internalState @*/; ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, - const char *version, int stream_size)); + const char *version, int stream_size)) + /*@modifies strm @*/; ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, int windowBits, int memLevel, int strategy, const char *version, - int stream_size)); + int stream_size)) + /*@globals internalState @*/ + /*@modifies strm, internalState @*/; ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, - const char *version, int stream_size)); + const char *version, int stream_size)) + /*@modifies strm @*/; ZEXTERN int ZEXPORT inflateBackInit_ OF((z_stream FAR *strm, int windowBits, unsigned char FAR *window, const char *version, - int stream_size)); + int stream_size)) + /*@modifies strm @*/; #define deflateInit(strm, level) \ deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) #define inflateInit(strm) \ @@ -1189,9 +1268,12 @@ ZEXTERN int ZEXPORT inflateBackInit_ OF((z_stream FAR *strm, int windowBits, struct internal_state {int dummy;}; /* hack for buggy compilers */ #endif -ZEXTERN const char * ZEXPORT zError OF((int err)); -ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)); -ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)); +ZEXTERN const char * ZEXPORT zError OF((int err)) + /*@*/; +ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp z)) + /*@modifies z @*/; +ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void)) + /*@*/; #ifdef __cplusplus } diff --git a/zlib/zutil.c b/zlib/zutil.c index 0ef4f99..06e078d 100644 --- a/zlib/zutil.c +++ b/zlib/zutil.c @@ -28,12 +28,12 @@ const char * const z_errmsg[10] = { ""}; -const char * ZEXPORT zlibVersion() +const char * ZEXPORT zlibVersion(void) { return ZLIB_VERSION; } -uLong ZEXPORT zlibCompileFlags() +uLong ZEXPORT zlibCompileFlags(void) { uLong flags; @@ -123,8 +123,7 @@ uLong ZEXPORT zlibCompileFlags() # endif int z_verbose = verbose; -void z_error (m) - char *m; +void z_error (char *m) { fprintf(stderr, "%s\n", m); exit(1); @@ -134,8 +133,7 @@ void z_error (m) /* exported to allow conversion of error code to string for compress() and * uncompress() */ -const char * ZEXPORT zError(err) - int err; +const char * ZEXPORT zError(int err) { return ERR_MSG(err); } @@ -147,10 +145,7 @@ const char * ZEXPORT zError(err) #ifndef HAVE_MEMCPY -void zmemcpy(dest, source, len) - Bytef* dest; - const Bytef* source; - uInt len; +void zmemcpy(Bytef* dest, const Bytef* source, uInt len) { if (len == 0) return; do { @@ -158,10 +153,7 @@ void zmemcpy(dest, source, len) } while (--len != 0); } -int zmemcmp(s1, s2, len) - const Bytef* s1; - const Bytef* s2; - uInt len; +int zmemcmp(const Bytef* s1, const Bytef* s2, uInt len) { uInt j; @@ -171,9 +163,7 @@ int zmemcmp(s1, s2, len) return 0; } -void zmemzero(dest, len) - Bytef* dest; - uInt len; +void zmemzero(Bytef* dest, uInt len) { if (len == 0) return; do { @@ -298,19 +288,14 @@ extern voidp calloc OF((uInt items, uInt size)); extern void free OF((voidpf ptr)); #endif -voidpf zcalloc (opaque, items, size) - voidpf opaque; - unsigned items; - unsigned size; +voidpf zcalloc (voidpf opaque, unsigned items, unsigned size) { if (opaque) items += size - size; /* make compiler happy */ return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) : (voidpf)calloc(items, size); } -void zcfree (opaque, ptr) - voidpf opaque; - voidpf ptr; +void zcfree (voidpf opaque, voidpf ptr) { free(ptr); if (opaque) return; /* make compiler happy */ diff --git a/zlib/zutil.h b/zlib/zutil.h index 87b70ac..904e032 100644 --- a/zlib/zutil.h +++ b/zlib/zutil.h @@ -221,9 +221,11 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ # define zmemzero(dest, len) memset(dest, 0, len) # endif #else - extern void zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)); - extern int zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len)); - extern void zmemzero OF((Bytef* dest, uInt len)); + extern void zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)) + /*@modifies dest @*/; + extern int zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len))\ /*@*/; + extern void zmemzero OF((Bytef* dest, uInt len)) + /*@modifies dest @*/; #endif /* Diagnostic functions */ @@ -247,8 +249,10 @@ extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ #endif -voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size)); -void zcfree OF((voidpf opaque, voidpf ptr)); +voidpf zcalloc OF((voidpf opaque, unsigned items, unsigned size)) + /*@*/; +void zcfree OF((voidpf opaque, voidpf ptr)) + /*@modifies ptr @*/; #define ZALLOC(strm, items, size) \ (*((strm)->zalloc))((strm)->opaque, (items), (size))