Side effects annotated.
CVS patchset: 7385
CVS date: 2004/08/03 00:04:07
# --- in progress
-globs
--infloopsuncon
--internalglobs
--modunconnomods
--nullassign
--nullstate
--oldstyle
--staticinittrans
+-infloops # 1
+-nullassign # 1
+-staticinittrans # 5
-abstract # 4
-aliasunique # 2
-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
#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;
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;
/* ===========================================================================
*/
-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);
}
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;
}
# 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
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 */
/*
/* =========================================================================
* 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();
#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;
#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;
#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;
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
/* ===========================================================================
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);
}
/* ========================================================================= */
-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;
}
/* ========================================================================= */
-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;
}
/* ========================================================================= */
-int ZEXPORT deflateReset (strm)
- z_streamp strm;
+int ZEXPORT deflateReset (z_streamp strm)
{
deflate_state *s;
}
/* ========================================================================= */
-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;
}
/* ========================================================================= */
-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;
* 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;
* 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));
* 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;
}
/* ========================================================================= */
-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;
}
/* ========================================================================= */
-int ZEXPORT deflateEnd (strm)
- z_streamp strm;
+int ZEXPORT deflateEnd (z_streamp strm)
{
int status;
* 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;
* 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;
/* ===========================================================================
* 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;
/* 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 */
/* ---------------------------------------------------------------------------
* 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 */
/* ===========================================================================
* 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,
* 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;
* 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:
* 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 */
* 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 */
*/
/* 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)])
#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)
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' */
} 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
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 */
/* ===========================================================================
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);
}
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];
/* ===========================================================================
* 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;
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) {
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 */
* 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;
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 */
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;
/* ===========================================================================
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;
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;
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;
}
#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;
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 */
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));
}
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;
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);
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;
/* ===========================================================================
Rewinds input file.
*/
-int ZEXPORT gzrewind (file)
- gzFile file;
+int ZEXPORT gzrewind (gzFile file)
{
gz_stream *s = (gz_stream*)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);
}
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;
/* ===========================================================================
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++) {
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;
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;
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;
/* ===========================================================================
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;
#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
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;
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;
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 */
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;
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 */
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 @*/;
#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;
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;
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);
}
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;
a.out > inffixed.h
*/
-void makefixed()
+void makefixed(void)
{
unsigned low, size;
struct inflate_state state;
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;
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 */
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)
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;
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;
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 */
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;
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;
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 */
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 @*/;
* 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
* 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");
/* ===========================================================================
* 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;
((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;
/* ===========================================================================
* 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();
/* ===========================================================================
* 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 */
* 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 */
* 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;
* 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 */
* 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;
* 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 */
* 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 */
* 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 */
* 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 */
/* ===========================================================================
* 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
* 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);
* 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 */
* 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;
/* ===========================================================================
* 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) */
* 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;
/* ===========================================================================
* 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);
/* ===========================================================================
* 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);
* 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 */
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;
/* Type declarations */
#ifndef OF /* function prototypes */
-# ifdef STDC
+# if defined(STDC) || defined(__LCLINT__)
# define OF(args) args
# else
# define OF(args) ()
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 */
/* 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.
*/
-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
*/
-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
*/
-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
*/
-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
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
*/
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.
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.
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
*/
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()
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
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
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
*/
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.
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.
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
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.
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:
*/
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
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
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
*/
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
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
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
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.
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
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
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
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
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
*/
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
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
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
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
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
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
* 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) \
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
}
""};
-const char * ZEXPORT zlibVersion()
+const char * ZEXPORT zlibVersion(void)
{
return ZLIB_VERSION;
}
-uLong ZEXPORT zlibCompileFlags()
+uLong ZEXPORT zlibCompileFlags(void)
{
uLong flags;
# endif
int z_verbose = verbose;
-void z_error (m)
- char *m;
+void z_error (char *m)
{
fprintf(stderr, "%s\n", m);
exit(1);
/* 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);
}
#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 {
} 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;
return 0;
}
-void zmemzero(dest, len)
- Bytef* dest;
- uInt len;
+void zmemzero(Bytef* dest, uInt len)
{
if (len == 0) return;
do {
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 */
# 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 */
#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))
projects / tools / librpm-tizen.git / commitdiff