mirror of
https://github.com/MariaDB/server.git
synced 2026-05-15 11:27:39 +02:00
First step of implementation of WL#1518 "make bundled zlib
usable for unix builds": zlib 1.2.1 imported BitKeeper/deleted/.del-Make_vms.com~95dd9cc7505c3153: Delete: zlib/Make_vms.com BitKeeper/deleted/.del-Makefile.riscos~f85c6493d3e51733: Delete: zlib/Makefile.riscos BitKeeper/deleted/.del-Makefile.pup~b0e9ed99224cc5f4: Delete: zlib/amiga/Makefile.pup BitKeeper/deleted/.del-Makefile.sas~be103e936c85b66a: Delete: zlib/amiga/Makefile.sas BitKeeper/deleted/.del-README.contrib~2924ba28ef1f9fab: Delete: zlib/contrib/README.contrib BitKeeper/deleted/.del-gvmat32.asm~edf721a2de30e964: Delete: zlib/contrib/asm386/gvmat32.asm BitKeeper/deleted/.del-visual-basic.txt~859fcbcb668ffbb3: Delete: zlib/contrib/visual-basic.txt BitKeeper/deleted/.del-gvmat32c.c~2e97d7d65dd59113: Delete: zlib/contrib/asm386/gvmat32c.c BitKeeper/deleted/.del-mkgvmt32.bat~5a92cf0febe3dc81: Delete: zlib/contrib/asm386/mkgvmt32.bat BitKeeper/deleted/.del-zlibvc.def~67961fa7815b9267: Delete: zlib/contrib/asm386/zlibvc.def BitKeeper/deleted/.del-zlibvc.dsp~a3323c77bcd12995: Delete: zlib/contrib/asm386/zlibvc.dsp BitKeeper/deleted/.del-match.s~51b8fef5136642ed: Delete: zlib/contrib/asm586/match.s BitKeeper/deleted/.del-readme.586~cb1bb7136b0803bb: Delete: zlib/contrib/asm586/readme.586 BitKeeper/deleted/.del-zlibvc.dsw~e3dca9d8f342e64e: Delete: zlib/contrib/asm386/zlibvc.dsw BitKeeper/deleted/.del-match.s~e4bbe1fa486d1c6c: Delete: zlib/contrib/asm686/match.s BitKeeper/deleted/.del-readme.686~98a220c13809fce5: Delete: zlib/contrib/asm686/readme.686 BitKeeper/deleted/.del-zlib.mak~70f7c5f6947fd807: Delete: zlib/contrib/delphi/zlib.mak BitKeeper/deleted/.del-d_zlib.bpr~cefb1beee520d6e8: Delete: zlib/contrib/delphi2/d_zlib.bpr BitKeeper/deleted/.del-d_zlib.cpp~62dff1931881afa6: Delete: zlib/contrib/delphi2/d_zlib.cpp BitKeeper/deleted/.del-zlibdef.pas~780244c8d12b6c53: Delete: zlib/contrib/delphi/zlibdef.pas BitKeeper/deleted/.del-readme.txt~8222e54ca00f2729: Delete: zlib/contrib/delphi2/readme.txt BitKeeper/deleted/.del-zlib.bpg~fbd9308275ad8e3: Delete: zlib/contrib/delphi2/zlib.bpg BitKeeper/deleted/.del-zlib.bpr~fe8bf5d1c4a2ce5a: Delete: zlib/contrib/delphi2/zlib.bpr BitKeeper/deleted/.del-zlib.cpp~bb0c3df062410f5c: Delete: zlib/contrib/delphi2/zlib.cpp BitKeeper/deleted/.del-zlib.pas~1d5285e2449b50a3: Delete: zlib/contrib/delphi2/zlib.pas BitKeeper/deleted/.del-zlib32.bpr~c2a9f0aa47a1d9ad: Delete: zlib/contrib/delphi2/zlib32.bpr BitKeeper/deleted/.del-test.cpp~4480297b204dc360: Delete: zlib/contrib/iostream/test.cpp BitKeeper/deleted/.del-zfstream.cpp~943ecbd558e86dde: Delete: zlib/contrib/iostream/zfstream.cpp BitKeeper/deleted/.del-zlib32.cpp~bbb4a200d2fe6497: Delete: zlib/contrib/delphi2/zlib32.cpp BitKeeper/deleted/.del-ChangeLogUnzip~a3ae0ba899cadd: Delete: zlib/contrib/minizip/ChangeLogUnzip BitKeeper/deleted/.del-zfstream.h~71ee057bdc6366ac: Delete: zlib/contrib/iostream/zfstream.h BitKeeper/deleted/.del-zstream.h~a6f6be5634962c81: Delete: zlib/contrib/iostream2/zstream.h BitKeeper/deleted/.del-zstream_test.cpp~e471b51e7fb553ec: Delete: zlib/contrib/iostream2/zstream_test.cpp BitKeeper/deleted/.del-miniunz.c~9da181975b3a48: Delete: zlib/contrib/minizip/miniunz.c BitKeeper/deleted/.del-minizip.c~4a49a0addb97272b: Delete: zlib/contrib/minizip/minizip.c BitKeeper/deleted/.del-readme.txt~174eb00680149f6b: Delete: zlib/contrib/minizip/readme.txt BitKeeper/deleted/.del-unzip.c~662c5ba4edbb3a19: Delete: zlib/contrib/minizip/unzip.c BitKeeper/deleted/.del-unzip.def~8a0ad6f745ee5cd4: Delete: zlib/contrib/minizip/unzip.def BitKeeper/deleted/.del-unzip.h~d5e800088a368c32: Delete: zlib/contrib/minizip/unzip.h BitKeeper/deleted/.del-zip.c~9750c19a123f3057: Delete: zlib/contrib/minizip/zip.c BitKeeper/deleted/.del-zip.def~4ffe888e9fd7b5aa: Delete: zlib/contrib/minizip/zip.def BitKeeper/deleted/.del-zip.h~4c72b8fcc492f055: Delete: zlib/contrib/minizip/zip.h BitKeeper/deleted/.del-zlibvc.def~dd272b3ed71647ba: Delete: zlib/contrib/minizip/zlibvc.def BitKeeper/deleted/.del-zlibvc.dsp~ad83fb048811e2d2: Delete: zlib/contrib/minizip/zlibvc.dsp BitKeeper/deleted/.del-zlibvc.dsw~c66b33a2d52f37c5: Delete: zlib/contrib/minizip/zlibvc.dsw BitKeeper/deleted/.del-makefile.w32~6507530fa1b017c: Delete: zlib/contrib/untgz/makefile.w32 BitKeeper/deleted/.del-untgz.c~4e8f1a3a2c145373: Delete: zlib/contrib/untgz/untgz.c BitKeeper/deleted/.del-Makefile.os2~8ab058477b24d1ff: Delete: zlib/os2/Makefile.os2 BitKeeper/deleted/.del-zlib.def~385b56ed82784ff3: Delete: zlib/os2/zlib.def BitKeeper/deleted/.del-Makefile.b32~10ffaac6cc41847a: Delete: zlib/msdos/Makefile.b32 BitKeeper/deleted/.del-Makefile.bor~121b2bc837b6367: Delete: zlib/msdos/Makefile.bor BitKeeper/deleted/.del-Makefile.dj2~a069623cad6ce7f4: Delete: zlib/msdos/Makefile.dj2 BitKeeper/deleted/.del-Makefile.emx~11a9e6c8a719ba60: Delete: zlib/msdos/Makefile.emx BitKeeper/deleted/.del-Makefile.msc~ba5ad7709ff22aab: Delete: zlib/msdos/Makefile.msc BitKeeper/deleted/.del-Makefile.tc~d1398368648e8836: Delete: zlib/msdos/Makefile.tc BitKeeper/deleted/.del-Makefile.w32~921a473e873d94d1: Delete: zlib/msdos/Makefile.w32 BitKeeper/deleted/.del-Makefile.wat~b2b51cbc2c2bc2f4: Delete: zlib/msdos/Makefile.wat BitKeeper/deleted/.del-zlib.def~189fba701e5e4b9c: Delete: zlib/msdos/zlib.def BitKeeper/deleted/.del-zlib.rc~e5ce22c7c915ec00: Delete: zlib/msdos/zlib.rc BitKeeper/deleted/.del-Makefile.emx~b5fa0633cbe6fe01: Delete: zlib/nt/Makefile.emx BitKeeper/deleted/.del-Makefile.gcc~7fcd3dd326341fa0: Delete: zlib/nt/Makefile.gcc BitKeeper/deleted/.del-Makefile.nt~9910c98f5da056de: Delete: zlib/nt/Makefile.nt BitKeeper/deleted/.del-zlib.dnt~8160c636eb3eeed7: Delete: zlib/nt/zlib.dnt BitKeeper/deleted/.del-zlib.dsp~a8abac2fb721276e: Delete: zlib/zlib.dsp BitKeeper/deleted/.del-zlib.html~2e74efd497dcd4d0: Delete: zlib/zlib.html BitKeeper/deleted/.del-minigzip.c~1f21a5863f457cb0: Delete: zlib/minigzip.c BitKeeper/deleted/.del-example.c~5ea43c929ccd2a4f: Delete: zlib/example.c BitKeeper/deleted/.del-descrip.mms~51cd5d1792d76b9c: Delete: zlib/descrip.mms BitKeeper/deleted/.del-infblock.h~7d4f40c3a1d4cdf8: Delete: zlib/infblock.h BitKeeper/deleted/.del-infblock.c~3c866934e0f44c43: Delete: zlib/infblock.c BitKeeper/deleted/.del-infutil.c~43d2340436244b52: Delete: zlib/infutil.c BitKeeper/deleted/.del-infutil.h~a6bd0dcbbdc187ac: Delete: zlib/infutil.h BitKeeper/deleted/.del-infcodes.h~c9f64a612c2cc56a: Delete: zlib/infcodes.h BitKeeper/deleted/.del-infcodes.c~7ed73df8a54d6d55: Delete: zlib/infcodes.c BitKeeper/deleted/.del-maketree.c~846b8b96ac6872d8: Delete: zlib/maketree.c VC++Files/zlib/zlib.dsp: Modified to suit zlib upgrade. mysys/my_crc32.c: Modified to suit zlib upgrade. zlib/ChangeLog: zlib 1.2.1 imported zlib/FAQ: zlib 1.2.1 imported zlib/INDEX: zlib 1.2.1 imported zlib/README: zlib 1.2.1 imported zlib/adler32.c: zlib 1.2.1 imported zlib/algorithm.txt: zlib 1.2.1 imported zlib/compress.c: zlib 1.2.1 imported zlib/crc32.c: zlib 1.2.1 imported zlib/deflate.c: zlib 1.2.1 imported zlib/deflate.h: zlib 1.2.1 imported zlib/gzio.c: zlib 1.2.1 imported zlib/inffast.c: zlib 1.2.1 imported zlib/inffast.h: zlib 1.2.1 imported zlib/inffixed.h: zlib 1.2.1 imported zlib/inflate.c: zlib 1.2.1 imported zlib/inftrees.c: zlib 1.2.1 imported zlib/inftrees.h: zlib 1.2.1 imported zlib/trees.c: zlib 1.2.1 imported zlib/uncompr.c: zlib 1.2.1 imported zlib/zconf.h: zlib 1.2.1 imported zlib/zlib.3: zlib 1.2.1 imported zlib/zlib.h: zlib 1.2.1 imported zlib/zutil.c: zlib 1.2.1 imported zlib/zutil.h: zlib 1.2.1 imported
This commit is contained in:
unknown
parent
2f26571fdc
commit
9fe0a2fa8d
107 changed files with 5734 additions and 16663 deletions
463
zlib/zlib.h
463
zlib/zlib.h
|
|
@ -1,7 +1,7 @@
|
|||
/* zlib.h -- interface of the 'zlib' general purpose compression library
|
||||
version 1.1.4, March 11th, 2002
|
||||
version 1.2.1, November 17th, 2003
|
||||
|
||||
Copyright (C) 1995-2002 Jean-loup Gailly and Mark Adler
|
||||
Copyright (C) 1995-2003 Jean-loup Gailly and Mark Adler
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
|
|
@ -24,12 +24,12 @@
|
|||
|
||||
|
||||
The data format used by the zlib library is described by RFCs (Request for
|
||||
Comments) 1950 to 1952 in the files ftp://ds.internic.net/rfc/rfc1950.txt
|
||||
Comments) 1950 to 1952 in the files http://www.ietf.org/rfc/rfc1950.txt
|
||||
(zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
|
||||
*/
|
||||
|
||||
#ifndef _ZLIB_H
|
||||
#define _ZLIB_H
|
||||
#ifndef ZLIB_H
|
||||
#define ZLIB_H
|
||||
|
||||
#include "zconf.h"
|
||||
|
||||
|
|
@ -37,9 +37,10 @@
|
|||
extern "C" {
|
||||
#endif
|
||||
|
||||
#define ZLIB_VERSION "1.1.4"
|
||||
#define ZLIB_VERSION "1.2.1"
|
||||
#define ZLIB_VERNUM 0x1210
|
||||
|
||||
/*
|
||||
/*
|
||||
The 'zlib' compression library provides in-memory compression and
|
||||
decompression functions, including integrity checks of the uncompressed
|
||||
data. This version of the library supports only one compression method
|
||||
|
|
@ -52,8 +53,23 @@ extern "C" {
|
|||
application must provide more input and/or consume the output
|
||||
(providing more output space) before each call.
|
||||
|
||||
The compressed data format used by the in-memory functions is the zlib
|
||||
format, which is a zlib wrapper documented in RFC 1950, wrapped around a
|
||||
deflate stream, which is itself documented in RFC 1951.
|
||||
|
||||
The library also supports reading and writing files in gzip (.gz) format
|
||||
with an interface similar to that of stdio.
|
||||
with an interface similar to that of stdio using the functions that start
|
||||
with "gz". The gzip format is different from the zlib format. gzip is a
|
||||
gzip wrapper, documented in RFC 1952, wrapped around a deflate stream.
|
||||
|
||||
The zlib format was designed to be compact and fast for use in memory
|
||||
and on communications channels. The gzip format was designed for single-
|
||||
file compression on file systems, has a larger header than zlib to maintain
|
||||
directory information, and uses a different, slower check method than zlib.
|
||||
|
||||
This library does not provide any functions to write gzip files in memory.
|
||||
However such functions could be easily written using zlib's deflate function,
|
||||
the documentation in the gzip RFC, and the examples in gzio.c.
|
||||
|
||||
The library does not install any signal handler. The decoder checks
|
||||
the consistency of the compressed data, so the library should never
|
||||
|
|
@ -127,7 +143,8 @@ typedef z_stream FAR *z_streamp;
|
|||
#define Z_SYNC_FLUSH 2
|
||||
#define Z_FULL_FLUSH 3
|
||||
#define Z_FINISH 4
|
||||
/* Allowed flush values; see deflate() below for details */
|
||||
#define Z_BLOCK 5
|
||||
/* Allowed flush values; see deflate() and inflate() below for details */
|
||||
|
||||
#define Z_OK 0
|
||||
#define Z_STREAM_END 1
|
||||
|
|
@ -150,13 +167,14 @@ typedef z_stream FAR *z_streamp;
|
|||
|
||||
#define Z_FILTERED 1
|
||||
#define Z_HUFFMAN_ONLY 2
|
||||
#define Z_RLE 3
|
||||
#define Z_DEFAULT_STRATEGY 0
|
||||
/* compression strategy; see deflateInit2() below for details */
|
||||
|
||||
#define Z_BINARY 0
|
||||
#define Z_ASCII 1
|
||||
#define Z_UNKNOWN 2
|
||||
/* Possible values of the data_type field */
|
||||
/* Possible values of the data_type field (though see inflate()) */
|
||||
|
||||
#define Z_DEFLATED 8
|
||||
/* The deflate compression method (the only one supported in this version) */
|
||||
|
|
@ -175,7 +193,7 @@ ZEXTERN const char * ZEXPORT zlibVersion OF((void));
|
|||
This check is automatically made by deflateInit and inflateInit.
|
||||
*/
|
||||
|
||||
/*
|
||||
/*
|
||||
ZEXTERN int ZEXPORT deflateInit OF((z_streamp strm, int level));
|
||||
|
||||
Initializes the internal stream state for compression. The fields
|
||||
|
|
@ -244,7 +262,9 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
|
|||
If deflate returns with avail_out == 0, this function must be called again
|
||||
with the same value of the flush parameter and more output space (updated
|
||||
avail_out), until the flush is complete (deflate returns with non-zero
|
||||
avail_out).
|
||||
avail_out). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that
|
||||
avail_out is greater than six to avoid repeated flush markers due to
|
||||
avail_out == 0 on return.
|
||||
|
||||
If the parameter flush is set to Z_FINISH, pending input is processed,
|
||||
pending output is flushed and deflate returns with Z_STREAM_END if there
|
||||
|
|
@ -253,10 +273,10 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
|
|||
more input data, until it returns with Z_STREAM_END or an error. After
|
||||
deflate has returned Z_STREAM_END, the only possible operations on the
|
||||
stream are deflateReset or deflateEnd.
|
||||
|
||||
|
||||
Z_FINISH can be used immediately after deflateInit if all the compression
|
||||
is to be done in a single step. In this case, avail_out must be at least
|
||||
0.1% larger than avail_in plus 12 bytes. If deflate does not return
|
||||
the value returned by deflateBound (see below). If deflate does not return
|
||||
Z_STREAM_END, then it must be called again as described above.
|
||||
|
||||
deflate() sets strm->adler to the adler32 checksum of all input read
|
||||
|
|
@ -272,7 +292,9 @@ ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush));
|
|||
consumed and all output has been produced (only when flush is set to
|
||||
Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
|
||||
if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
|
||||
(for example avail_in or avail_out was zero).
|
||||
(for example avail_in or avail_out was zero). Note that Z_BUF_ERROR is not
|
||||
fatal, and deflate() can be called again with more input and more output
|
||||
space to continue compressing.
|
||||
*/
|
||||
|
||||
|
||||
|
|
@ -290,7 +312,7 @@ ZEXTERN int ZEXPORT deflateEnd OF((z_streamp strm));
|
|||
*/
|
||||
|
||||
|
||||
/*
|
||||
/*
|
||||
ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
|
||||
|
||||
Initializes the internal stream state for decompression. The fields
|
||||
|
|
@ -314,9 +336,9 @@ ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm));
|
|||
ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
|
||||
/*
|
||||
inflate decompresses as much data as possible, and stops when the input
|
||||
buffer becomes empty or the output buffer becomes full. It may some
|
||||
introduce some output latency (reading input without producing any output)
|
||||
except when forced to flush.
|
||||
buffer becomes empty or the output buffer becomes full. It may introduce
|
||||
some output latency (reading input without producing any output) except when
|
||||
forced to flush.
|
||||
|
||||
The detailed semantics are as follows. inflate performs one or both of the
|
||||
following actions:
|
||||
|
|
@ -340,11 +362,26 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
|
|||
must be called again after making room in the output buffer because there
|
||||
might be more output pending.
|
||||
|
||||
If the parameter flush is set to Z_SYNC_FLUSH, inflate flushes as much
|
||||
output as possible to the output buffer. The flushing behavior of inflate is
|
||||
not specified for values of the flush parameter other than Z_SYNC_FLUSH
|
||||
and Z_FINISH, but the current implementation actually flushes as much output
|
||||
as possible anyway.
|
||||
The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH,
|
||||
Z_FINISH, or Z_BLOCK. Z_SYNC_FLUSH requests that inflate() flush as much
|
||||
output as possible to the output buffer. Z_BLOCK requests that inflate() stop
|
||||
if and when it get to the next deflate block boundary. When decoding the zlib
|
||||
or gzip format, this will cause inflate() to return immediately after the
|
||||
header and before the first block. When doing a raw inflate, inflate() will
|
||||
go ahead and process the first block, and will return when it gets to the end
|
||||
of that block, or when it runs out of data.
|
||||
|
||||
The Z_BLOCK option assists in appending to or combining deflate streams.
|
||||
Also to assist in this, on return inflate() will set strm->data_type to the
|
||||
number of unused bits in the last byte taken from strm->next_in, plus 64
|
||||
if inflate() is currently decoding the last block in the deflate stream,
|
||||
plus 128 if inflate() returned immediately after decoding an end-of-block
|
||||
code or decoding the complete header up to just before the first byte of the
|
||||
deflate stream. The end-of-block will not be indicated until all of the
|
||||
uncompressed data from that block has been written to strm->next_out. The
|
||||
number of unused bits may in general be greater than seven, except when
|
||||
bit 7 of data_type is set, in which case the number of unused bits will be
|
||||
less than eight.
|
||||
|
||||
inflate() should normally be called until it returns Z_STREAM_END or an
|
||||
error. However if all decompression is to be performed in a single step
|
||||
|
|
@ -354,29 +391,44 @@ ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush));
|
|||
uncompressed data. (The size of the uncompressed data may have been saved
|
||||
by the compressor for this purpose.) The next operation on this stream must
|
||||
be inflateEnd to deallocate the decompression state. The use of Z_FINISH
|
||||
is never required, but can be used to inform inflate that a faster routine
|
||||
is never required, but can be used to inform inflate that a faster approach
|
||||
may be used for the single inflate() call.
|
||||
|
||||
If a preset dictionary is needed at this point (see inflateSetDictionary
|
||||
below), inflate sets strm-adler to the adler32 checksum of the
|
||||
dictionary chosen by the compressor and returns Z_NEED_DICT; otherwise
|
||||
it sets strm->adler to the adler32 checksum of all output produced
|
||||
so far (that is, total_out bytes) and returns Z_OK, Z_STREAM_END or
|
||||
an error code as described below. At the end of the stream, inflate()
|
||||
checks that its computed adler32 checksum is equal to that saved by the
|
||||
compressor and returns Z_STREAM_END only if the checksum is correct.
|
||||
In this implementation, inflate() always flushes as much output as
|
||||
possible to the output buffer, and always uses the faster approach on the
|
||||
first call. So the only effect of the flush parameter in this implementation
|
||||
is on the return value of inflate(), as noted below, or when it returns early
|
||||
because Z_BLOCK is used.
|
||||
|
||||
If a preset dictionary is needed after this call (see inflateSetDictionary
|
||||
below), inflate sets strm-adler to the adler32 checksum of the dictionary
|
||||
chosen by the compressor and returns Z_NEED_DICT; otherwise it sets
|
||||
strm->adler to the adler32 checksum of all output produced so far (that is,
|
||||
total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described
|
||||
below. At the end of the stream, inflate() checks that its computed adler32
|
||||
checksum is equal to that saved by the compressor and returns Z_STREAM_END
|
||||
only if the checksum is correct.
|
||||
|
||||
inflate() will decompress and check either zlib-wrapped or gzip-wrapped
|
||||
deflate data. The header type is detected automatically. Any information
|
||||
contained in the gzip header is not retained, so applications that need that
|
||||
information should instead use raw inflate, see inflateInit2() below, or
|
||||
inflateBack() and perform their own processing of the gzip header and
|
||||
trailer.
|
||||
|
||||
inflate() returns Z_OK if some progress has been made (more input processed
|
||||
or more output produced), Z_STREAM_END if the end of the compressed data has
|
||||
been reached and all uncompressed output has been produced, Z_NEED_DICT if a
|
||||
preset dictionary is needed at this point, Z_DATA_ERROR if the input data was
|
||||
corrupted (input stream not conforming to the zlib format or incorrect
|
||||
adler32 checksum), Z_STREAM_ERROR if the stream structure was inconsistent
|
||||
(for example if next_in or next_out was NULL), Z_MEM_ERROR if there was not
|
||||
enough memory, Z_BUF_ERROR if no progress is possible or if there was not
|
||||
enough room in the output buffer when Z_FINISH is used. In the Z_DATA_ERROR
|
||||
case, the application may then call inflateSync to look for a good
|
||||
compression block.
|
||||
corrupted (input stream not conforming to the zlib format or incorrect check
|
||||
value), Z_STREAM_ERROR if the stream structure was inconsistent (for example
|
||||
if next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory,
|
||||
Z_BUF_ERROR if no progress is possible or if there was not enough room in the
|
||||
output buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and
|
||||
inflate() can be called again with more input and more output space to
|
||||
continue decompressing. If Z_DATA_ERROR is returned, the application may then
|
||||
call inflateSync() to look for a good compression block if a partial recovery
|
||||
of the data is desired.
|
||||
*/
|
||||
|
||||
|
||||
|
|
@ -397,7 +449,7 @@ ZEXTERN int ZEXPORT inflateEnd OF((z_streamp strm));
|
|||
The following functions are needed only in some special applications.
|
||||
*/
|
||||
|
||||
/*
|
||||
/*
|
||||
ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
|
||||
int level,
|
||||
int method,
|
||||
|
|
@ -413,11 +465,21 @@ ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
|
|||
this version of the library.
|
||||
|
||||
The windowBits parameter is the base two logarithm of the window size
|
||||
(the size of the history buffer). It should be in the range 8..15 for this
|
||||
(the size of the history buffer). It should be in the range 8..15 for this
|
||||
version of the library. Larger values of this parameter result in better
|
||||
compression at the expense of memory usage. The default value is 15 if
|
||||
deflateInit is used instead.
|
||||
|
||||
windowBits can also be -8..-15 for raw deflate. In this case, -windowBits
|
||||
determines the window size. deflate() will then generate raw deflate data
|
||||
with no zlib header or trailer, and will not compute an adler32 check value.
|
||||
|
||||
windowBits can also be greater than 15 for optional gzip encoding. Add
|
||||
16 to windowBits to write a simple gzip header and trailer around the
|
||||
compressed data instead of a zlib wrapper. The gzip header will have no
|
||||
file name, no extra data, no comment, no modification time (set to zero),
|
||||
no header crc, and the operating system will be set to 255 (unknown).
|
||||
|
||||
The memLevel parameter specifies how much memory should be allocated
|
||||
for the internal compression state. memLevel=1 uses minimum memory but
|
||||
is slow and reduces compression ratio; memLevel=9 uses maximum memory
|
||||
|
|
@ -426,21 +488,23 @@ ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm,
|
|||
|
||||
The strategy parameter is used to tune the compression algorithm. Use the
|
||||
value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
|
||||
filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no
|
||||
string match). Filtered data consists mostly of small values with a
|
||||
somewhat random distribution. In this case, the compression algorithm is
|
||||
tuned to compress them better. The effect of Z_FILTERED is to force more
|
||||
Huffman coding and less string matching; it is somewhat intermediate
|
||||
between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects
|
||||
the compression ratio but not the correctness of the compressed output even
|
||||
if it is not set appropriately.
|
||||
filter (or predictor), Z_HUFFMAN_ONLY to force Huffman encoding only (no
|
||||
string match), or Z_RLE to limit match distances to one (run-length
|
||||
encoding). Filtered data consists mostly of small values with a somewhat
|
||||
random distribution. In this case, the compression algorithm is tuned to
|
||||
compress them better. The effect of Z_FILTERED is to force more Huffman
|
||||
coding and less string matching; it is somewhat intermediate between
|
||||
Z_DEFAULT and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as fast as
|
||||
Z_HUFFMAN_ONLY, but give better compression for PNG image data. The strategy
|
||||
parameter only affects the compression ratio but not the correctness of the
|
||||
compressed output even if it is not set appropriately.
|
||||
|
||||
deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
||||
memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
|
||||
method). msg is set to null if there is no error message. deflateInit2 does
|
||||
not perform any compression: this will be done by deflate().
|
||||
*/
|
||||
|
||||
|
||||
ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
|
||||
const Bytef *dictionary,
|
||||
uInt dictLength));
|
||||
|
|
@ -464,11 +528,12 @@ ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm,
|
|||
deflate or deflate2. Thus the strings most likely to be useful should be
|
||||
put at the end of the dictionary, not at the front.
|
||||
|
||||
Upon return of this function, strm->adler is set to the Adler32 value
|
||||
Upon return of this function, strm->adler is set to the adler32 value
|
||||
of the dictionary; the decompressor may later use this value to determine
|
||||
which dictionary has been used by the compressor. (The Adler32 value
|
||||
which dictionary has been used by the compressor. (The adler32 value
|
||||
applies to the whole dictionary even if only a subset of the dictionary is
|
||||
actually used by the compressor.)
|
||||
actually used by the compressor.) If a raw deflate was requested, then the
|
||||
adler32 value is not computed and strm->adler is not set.
|
||||
|
||||
deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a
|
||||
parameter is invalid (such as NULL dictionary) or the stream state is
|
||||
|
|
@ -507,8 +572,8 @@ ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm));
|
|||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
|
||||
int level,
|
||||
int strategy));
|
||||
int level,
|
||||
int strategy));
|
||||
/*
|
||||
Dynamically update the compression level and compression strategy. The
|
||||
interpretation of level and strategy is as in deflateInit2. This can be
|
||||
|
|
@ -527,7 +592,32 @@ ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm,
|
|||
if strm->avail_out was zero.
|
||||
*/
|
||||
|
||||
/*
|
||||
ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm,
|
||||
uLong sourceLen));
|
||||
/*
|
||||
deflateBound() returns an upper bound on the compressed size after
|
||||
deflation of sourceLen bytes. It must be called after deflateInit()
|
||||
or deflateInit2(). This would be used to allocate an output buffer
|
||||
for deflation in a single pass, and so would be called before deflate().
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm,
|
||||
int bits,
|
||||
int value));
|
||||
/*
|
||||
deflatePrime() inserts bits in the deflate output stream. The intent
|
||||
is that this function is used to start off the deflate output with the
|
||||
bits leftover from a previous deflate stream when appending to it. As such,
|
||||
this function can only be used for raw deflate, and must be used before the
|
||||
first deflate() call after a deflateInit2() or deflateReset(). bits must be
|
||||
less than or equal to 16, and that many of the least significant bits of
|
||||
value will be inserted in the output.
|
||||
|
||||
deflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source
|
||||
stream state was inconsistent.
|
||||
*/
|
||||
|
||||
/*
|
||||
ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
|
||||
int windowBits));
|
||||
|
||||
|
|
@ -538,11 +628,30 @@ ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm,
|
|||
The windowBits parameter is the base two logarithm of the maximum window
|
||||
size (the size of the history buffer). It should be in the range 8..15 for
|
||||
this version of the library. The default value is 15 if inflateInit is used
|
||||
instead. If a compressed stream with a larger window size is given as
|
||||
input, inflate() will return with the error code Z_DATA_ERROR instead of
|
||||
trying to allocate a larger window.
|
||||
instead. windowBits must be greater than or equal to the windowBits value
|
||||
provided to deflateInit2() while compressing, or it must be equal to 15 if
|
||||
deflateInit2() was not used. If a compressed stream with a larger window
|
||||
size is given as input, inflate() will return with the error code
|
||||
Z_DATA_ERROR instead of trying to allocate a larger window.
|
||||
|
||||
inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
||||
windowBits can also be -8..-15 for raw inflate. In this case, -windowBits
|
||||
determines the window size. inflate() will then process raw deflate data,
|
||||
not looking for a zlib or gzip header, not generating a check value, and not
|
||||
looking for any check values for comparison at the end of the stream. This
|
||||
is for use with other formats that use the deflate compressed data format
|
||||
such as zip. Those formats provide their own check values. If a custom
|
||||
format is developed using the raw deflate format for compressed data, it is
|
||||
recommended that a check value such as an adler32 or a crc32 be applied to
|
||||
the uncompressed data as is done in the zlib, gzip, and zip formats. For
|
||||
most applications, the zlib format should be used as is. Note that comments
|
||||
above on the use in deflateInit2() applies to the magnitude of windowBits.
|
||||
|
||||
windowBits can also be greater than 15 for optional gzip decoding. Add
|
||||
32 to windowBits to enable zlib and gzip decoding with automatic header
|
||||
detection, or add 16 to decode only the gzip format (the zlib format will
|
||||
return a Z_DATA_ERROR).
|
||||
|
||||
inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
||||
memory, Z_STREAM_ERROR if a parameter is invalid (such as a negative
|
||||
memLevel). msg is set to null if there is no error message. inflateInit2
|
||||
does not perform any decompression apart from reading the zlib header if
|
||||
|
|
@ -557,20 +666,20 @@ ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm,
|
|||
Initializes the decompression dictionary from the given uncompressed byte
|
||||
sequence. This function must be called immediately after a call of inflate
|
||||
if this call returned Z_NEED_DICT. The dictionary chosen by the compressor
|
||||
can be determined from the Adler32 value returned by this call of
|
||||
can be determined from the adler32 value returned by this call of
|
||||
inflate. The compressor and decompressor must use exactly the same
|
||||
dictionary (see deflateSetDictionary).
|
||||
|
||||
inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a
|
||||
parameter is invalid (such as NULL dictionary) or the stream state is
|
||||
inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the
|
||||
expected one (incorrect Adler32 value). inflateSetDictionary does not
|
||||
expected one (incorrect adler32 value). inflateSetDictionary does not
|
||||
perform any decompression: this will be done by subsequent calls of
|
||||
inflate().
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT inflateSync OF((z_streamp 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
|
||||
available input is skipped. No output is provided.
|
||||
|
|
@ -584,6 +693,22 @@ ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm));
|
|||
until success or end of the input data.
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest,
|
||||
z_streamp source));
|
||||
/*
|
||||
Sets the destination stream as a complete copy of the source stream.
|
||||
|
||||
This function can be useful when randomly accessing a large stream. The
|
||||
first pass through the stream can periodically record the inflate state,
|
||||
allowing restarting inflate at those points when randomly accessing the
|
||||
stream.
|
||||
|
||||
inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not
|
||||
enough memory, Z_STREAM_ERROR if the source stream state was inconsistent
|
||||
(such as zalloc being NULL). msg is left unchanged in both source and
|
||||
destination.
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
|
||||
/*
|
||||
This function is equivalent to inflateEnd followed by inflateInit,
|
||||
|
|
@ -594,6 +719,149 @@ ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm));
|
|||
stream state was inconsistent (such as zalloc or state being NULL).
|
||||
*/
|
||||
|
||||
/*
|
||||
ZEXTERN int ZEXPORT inflateBackInit OF((z_stream FAR *strm, int windowBits,
|
||||
unsigned char FAR *window));
|
||||
|
||||
Initialize the internal stream state for decompression using inflateBack()
|
||||
calls. The fields zalloc, zfree and opaque in strm must be initialized
|
||||
before the call. If zalloc and zfree are Z_NULL, then the default library-
|
||||
derived memory allocation routines are used. windowBits is the base two
|
||||
logarithm of the window size, in the range 8..15. window is a caller
|
||||
supplied buffer of that size. Except for special applications where it is
|
||||
assured that deflate was used with small window sizes, windowBits must be 15
|
||||
and a 32K byte window must be supplied to be able to decompress general
|
||||
deflate streams.
|
||||
|
||||
See inflateBack() for the usage of these routines.
|
||||
|
||||
inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of
|
||||
the paramaters are invalid, Z_MEM_ERROR if the internal state could not
|
||||
be allocated, or Z_VERSION_ERROR if the version of the library does not
|
||||
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));
|
||||
|
||||
ZEXTERN int ZEXPORT inflateBack OF((z_stream FAR *strm,
|
||||
in_func in, void FAR *in_desc,
|
||||
out_func out, void FAR *out_desc));
|
||||
/*
|
||||
inflateBack() does a raw inflate with a single call using a call-back
|
||||
interface for input and output. This is more efficient than inflate() for
|
||||
file i/o applications in that it avoids copying between the output and the
|
||||
sliding window by simply making the window itself the output buffer. This
|
||||
function trusts the application to not change the output buffer passed by
|
||||
the output function, at least until inflateBack() returns.
|
||||
|
||||
inflateBackInit() must be called first to allocate the internal state
|
||||
and to initialize the state with the user-provided window buffer.
|
||||
inflateBack() may then be used multiple times to inflate a complete, raw
|
||||
deflate stream with each call. inflateBackEnd() is then called to free
|
||||
the allocated state.
|
||||
|
||||
A raw deflate stream is one with no zlib or gzip header or trailer.
|
||||
This routine would normally be used in a utility that reads zip or gzip
|
||||
files and writes out uncompressed files. The utility would decode the
|
||||
header and process the trailer on its own, hence this routine expects
|
||||
only the raw deflate stream to decompress. This is different from the
|
||||
normal behavior of inflate(), which expects either a zlib or gzip header and
|
||||
trailer around the deflate stream.
|
||||
|
||||
inflateBack() uses two subroutines supplied by the caller that are then
|
||||
called by inflateBack() for input and output. inflateBack() calls those
|
||||
routines until it reads a complete deflate stream and writes out all of the
|
||||
uncompressed data, or until it encounters an error. The function's
|
||||
parameters and return types are defined above in the in_func and out_func
|
||||
typedefs. inflateBack() will call in(in_desc, &buf) which should return the
|
||||
number of bytes of provided input, and a pointer to that input in buf. If
|
||||
there is no input available, in() must return zero--buf is ignored in that
|
||||
case--and inflateBack() will return a buffer error. inflateBack() will call
|
||||
out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. out()
|
||||
should return zero on success, or non-zero on failure. If out() returns
|
||||
non-zero, inflateBack() will return with an error. Neither in() nor out()
|
||||
are permitted to change the contents of the window provided to
|
||||
inflateBackInit(), which is also the buffer that out() uses to write from.
|
||||
The length written by out() will be at most the window size. Any non-zero
|
||||
amount of input may be provided by in().
|
||||
|
||||
For convenience, inflateBack() can be provided input on the first call by
|
||||
setting strm->next_in and strm->avail_in. If that input is exhausted, then
|
||||
in() will be called. Therefore strm->next_in must be initialized before
|
||||
calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called
|
||||
immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in
|
||||
must also be initialized, and then if strm->avail_in is not zero, input will
|
||||
initially be taken from strm->next_in[0 .. strm->avail_in - 1].
|
||||
|
||||
The in_desc and out_desc parameters of inflateBack() is passed as the
|
||||
first parameter of in() and out() respectively when they are called. These
|
||||
descriptors can be optionally used to pass any information that the caller-
|
||||
supplied in() and out() functions need to do their job.
|
||||
|
||||
On return, inflateBack() will set strm->next_in and strm->avail_in to
|
||||
pass back any unused input that was provided by the last in() call. The
|
||||
return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR
|
||||
if in() or out() returned an error, Z_DATA_ERROR if there was a format
|
||||
error in the deflate stream (in which case strm->msg is set to indicate the
|
||||
nature of the error), or Z_STREAM_ERROR if the stream was not properly
|
||||
initialized. In the case of Z_BUF_ERROR, an input or output error can be
|
||||
distinguished using strm->next_in which will be Z_NULL only if in() returned
|
||||
an error. If strm->next is not Z_NULL, then the Z_BUF_ERROR was due to
|
||||
out() returning non-zero. (in() will always be called before out(), so
|
||||
strm->next_in is assured to be defined if out() returns non-zero.) Note
|
||||
that inflateBack() cannot return Z_OK.
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT inflateBackEnd OF((z_stream FAR *strm));
|
||||
/*
|
||||
All memory allocated by inflateBackInit() is freed.
|
||||
|
||||
inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream
|
||||
state was inconsistent.
|
||||
*/
|
||||
|
||||
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:
|
||||
1.0: size of uInt
|
||||
3.2: size of uLong
|
||||
5.4: size of voidpf (pointer)
|
||||
7.6: size of z_off_t
|
||||
|
||||
Compiler, assembler, and debug options:
|
||||
8: DEBUG
|
||||
9: ASMV or ASMINF -- use ASM code
|
||||
10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention
|
||||
11: 0 (reserved)
|
||||
|
||||
One-time table building (smaller code, but not thread-safe if true):
|
||||
12: BUILDFIXED -- build static block decoding tables when needed
|
||||
13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed
|
||||
14,15: 0 (reserved)
|
||||
|
||||
Library content (indicates missing functionality):
|
||||
16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking
|
||||
deflate code when not needed)
|
||||
17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect
|
||||
and decode gzip streams (to avoid linking crc code)
|
||||
18-19: 0 (reserved)
|
||||
|
||||
Operation variations (changes in library functionality):
|
||||
20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate
|
||||
21: FASTEST -- deflate algorithm with only one, lowest compression level
|
||||
22,23: 0 (reserved)
|
||||
|
||||
The sprintf variant used by gzprintf (zero is best):
|
||||
24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format
|
||||
25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure!
|
||||
26: 0 = returns value, 1 = void -- 1 means inferred string length returned
|
||||
|
||||
Remainder:
|
||||
27-31: 0 (reserved)
|
||||
*/
|
||||
|
||||
|
||||
/* utility functions */
|
||||
|
||||
|
|
@ -610,8 +878,8 @@ ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen,
|
|||
/*
|
||||
Compresses the source buffer into the destination buffer. sourceLen is
|
||||
the byte length of the source buffer. Upon entry, destLen is the total
|
||||
size of the destination buffer, which must be at least 0.1% larger than
|
||||
sourceLen plus 12 bytes. Upon exit, destLen is the actual size of the
|
||||
size of the destination buffer, which must be at least the value returned
|
||||
by compressBound(sourceLen). Upon exit, destLen is the actual size of the
|
||||
compressed buffer.
|
||||
This function can be used to compress a whole file at once if the
|
||||
input file is mmap'ed.
|
||||
|
|
@ -627,14 +895,22 @@ ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen,
|
|||
Compresses the source buffer into the destination buffer. The level
|
||||
parameter has the same meaning as in deflateInit. sourceLen is the byte
|
||||
length of the source buffer. Upon entry, destLen is the total size of the
|
||||
destination buffer, which must be at least 0.1% larger than sourceLen plus
|
||||
12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
|
||||
destination buffer, which must be at least the value returned by
|
||||
compressBound(sourceLen). Upon exit, destLen is the actual size of the
|
||||
compressed buffer.
|
||||
|
||||
compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
||||
memory, Z_BUF_ERROR if there was not enough room in the output buffer,
|
||||
Z_STREAM_ERROR if the level parameter is invalid.
|
||||
*/
|
||||
|
||||
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
|
||||
a compress() or compress2() call to allocate the destination buffer.
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen,
|
||||
const Bytef *source, uLong sourceLen));
|
||||
/*
|
||||
|
|
@ -650,7 +926,7 @@ ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen,
|
|||
|
||||
uncompress returns Z_OK if success, Z_MEM_ERROR if there was not
|
||||
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.
|
||||
buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete.
|
||||
*/
|
||||
|
||||
|
||||
|
|
@ -661,8 +937,9 @@ ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode));
|
|||
Opens a gzip (.gz) file for reading or writing. The mode parameter
|
||||
is as in fopen ("rb" or "wb") but can also include a compression level
|
||||
("wb9") or a strategy: 'f' for filtered data as in "wb6f", 'h' for
|
||||
Huffman only compression as in "wb1h". (See the description
|
||||
of deflateInit2 for more information about the strategy parameter.)
|
||||
Huffman only compression as in "wb1h", or 'R' for run-length encoding
|
||||
as in "wb1R". (See the description of deflateInit2 for more information
|
||||
about the strategy parameter.)
|
||||
|
||||
gzopen can be used to read a file which is not in gzip format; in this
|
||||
case gzread will directly read from the file without decompression.
|
||||
|
|
@ -701,8 +978,8 @@ ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len));
|
|||
gzread returns the number of uncompressed bytes actually read (0 for
|
||||
end of file, -1 for error). */
|
||||
|
||||
ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
|
||||
const voidp buf, unsigned len));
|
||||
ZEXTERN int ZEXPORT gzwrite OF((gzFile file,
|
||||
voidpc buf, unsigned len));
|
||||
/*
|
||||
Writes the given number of uncompressed bytes into the compressed file.
|
||||
gzwrite returns the number of uncompressed bytes actually written
|
||||
|
|
@ -713,7 +990,13 @@ ZEXTERN int ZEXPORTVA gzprintf OF((gzFile file, const char *format, ...));
|
|||
/*
|
||||
Converts, formats, and writes the args to the compressed file under
|
||||
control of the format string, as in fprintf. gzprintf returns the number of
|
||||
uncompressed bytes actually written (0 in case of error).
|
||||
uncompressed bytes actually written (0 in case of error). The number of
|
||||
uncompressed bytes written is limited to 4095. The caller should assure that
|
||||
this limit is not exceeded. If it is exceeded, then gzprintf() will return
|
||||
return an error (0) with nothing written. In this case, there may also be a
|
||||
buffer overflow with unpredictable consequences, which is possible only if
|
||||
zlib was compiled with the insecure functions sprintf() or vsprintf()
|
||||
because the secure snprintf() or vsnprintf() functions were not available.
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s));
|
||||
|
|
@ -744,6 +1027,16 @@ ZEXTERN int ZEXPORT gzgetc OF((gzFile file));
|
|||
or -1 in case of end of file or error.
|
||||
*/
|
||||
|
||||
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
|
||||
character pushed, or -1 on failure. gzungetc() will fail if a
|
||||
character has been pushed but not read yet, or if c is -1. The pushed
|
||||
character will be discarded if the stream is repositioned with gzseek()
|
||||
or gzrewind().
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
|
||||
/*
|
||||
Flushes all pending output into the compressed file. The parameter
|
||||
|
|
@ -755,8 +1048,8 @@ ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush));
|
|||
*/
|
||||
|
||||
ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file,
|
||||
z_off_t offset, int whence));
|
||||
/*
|
||||
z_off_t offset, int whence));
|
||||
/*
|
||||
Sets the starting position for the next gzread or gzwrite on the
|
||||
given compressed file. The offset represents a number of bytes in the
|
||||
uncompressed data stream. The whence parameter is defined as in lseek(2);
|
||||
|
|
@ -810,6 +1103,13 @@ ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum));
|
|||
to get the exact error code.
|
||||
*/
|
||||
|
||||
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
|
||||
file that is being written concurrently.
|
||||
*/
|
||||
|
||||
/* checksum functions */
|
||||
|
||||
/*
|
||||
|
|
@ -867,6 +1167,10 @@ ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method,
|
|||
int stream_size));
|
||||
ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits,
|
||||
const char *version, int stream_size));
|
||||
ZEXTERN int ZEXPORT inflateBackInit_ OF((z_stream FAR *strm, int windowBits,
|
||||
unsigned char FAR *window,
|
||||
const char *version,
|
||||
int stream_size));
|
||||
#define deflateInit(strm, level) \
|
||||
deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream))
|
||||
#define inflateInit(strm) \
|
||||
|
|
@ -876,9 +1180,12 @@ ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits,
|
|||
(strategy), ZLIB_VERSION, sizeof(z_stream))
|
||||
#define inflateInit2(strm, windowBits) \
|
||||
inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream))
|
||||
#define inflateBackInit(strm, windowBits, window) \
|
||||
inflateBackInit_((strm), (windowBits), (window), \
|
||||
ZLIB_VERSION, sizeof(z_stream))
|
||||
|
||||
|
||||
#if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL)
|
||||
#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL)
|
||||
struct internal_state {int dummy;}; /* hack for buggy compilers */
|
||||
#endif
|
||||
|
||||
|
|
@ -890,4 +1197,4 @@ ZEXTERN const uLongf * ZEXPORT get_crc_table OF((void));
|
|||
}
|
||||
#endif
|
||||
|
||||
#endif /* _ZLIB_H */
|
||||
#endif /* ZLIB_H */
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue