zlib.h

Go to the documentation of this file.

 
#ifndef ZLIB_H
#define ZLIB_H
 
#include "zconf.h"
 
#ifdef __cplusplus
extern "C" {
#endif
 
#define ZLIB_VERSION "1.3.0.f-neacsum"  
#define ZLIB_VERNUM 0x130f              
#define ZLIB_VER_MAJOR 1                
#define ZLIB_VER_MINOR 3                
#define ZLIB_VER_REVISION 0             
#define ZLIB_VER_SUBREVISION f          
 
 
typedef voidpf (*alloc_func)(voidpf opaque, uInt items, uInt size);
typedef void   (*free_func)(voidpf opaque, voidpf address);
 
struct internal_state;
 
typedef struct z_stream_s {
    const Bytef *next_in;   
    uInt     avail_in;      
    uLong    total_in;      
 
    Bytef    *next_out;     
    uInt     avail_out;     
    uLong    total_out;     
 
    const char *msg;        
    struct internal_state *state; 
 
    alloc_func zalloc;      
    free_func  zfree;       
    voidpf     opaque;      
 
    int     data_type;      
    uLong   adler;          
    uLong   reserved;       
} z_stream;
 
typedef z_stream *z_streamp;
 
typedef struct gz_header_s {
    int     text;       
    uLong   time;       
    int     xflags;     
    int     os;         
    Bytef   *extra;     
    uInt    extra_len;  
    uInt    extra_max;  
    Bytef   *name;      
    uInt    name_max;   
    Bytef   *comment;   
    uInt    comm_max;   
    int     hcrc;       
    int     done;       
} gz_header;
 
typedef gz_header *gz_headerp;
 
 
                        /* constants */
 
#define Z_NO_FLUSH      0
#define Z_PARTIAL_FLUSH 1
#define Z_SYNC_FLUSH    2
#define Z_FULL_FLUSH    3
#define Z_FINISH        4
#define Z_BLOCK         5
#define Z_TREES         6
 
#define Z_OK            0     
#define Z_STREAM_END    1     
#define Z_NEED_DICT     2
#define Z_ERRNO        (-1)
#define Z_STREAM_ERROR (-2)   
#define Z_DATA_ERROR   (-3)   
#define Z_MEM_ERROR    (-4)   
#define Z_BUF_ERROR    (-5)   
#define Z_VERSION_ERROR (-6)  
 
#define Z_NO_COMPRESSION         0
#define Z_BEST_SPEED             1
#define Z_BEST_COMPRESSION       9
#define Z_DEFAULT_COMPRESSION  (-1)
 
#define Z_FILTERED            1
#define Z_HUFFMAN_ONLY        2
#define Z_RLE                 3
#define Z_FIXED               4
#define Z_DEFAULT_STRATEGY    0
 
#define Z_BINARY   0
#define Z_TEXT     1
#define Z_ASCII    Z_TEXT   /* for compatibility with 1.2.2 and earlier */
#define Z_UNKNOWN  2
 
#define Z_DEFLATED   8
 
#define Z_NULL  0 
 
#define zlib_version zlibVersion()
 
 
const char* ZEXPORT zlibVersion (void);
 
int ZEXPORT deflate(z_streamp strm, int flush);
 
int ZEXPORT deflateEnd(z_streamp strm);
 
int ZEXPORT inflate(z_streamp strm, int flush);
 
int ZEXPORT inflateEnd(z_streamp strm);
 
int ZEXPORT deflateSetDictionary(z_streamp strm,
                                 const Bytef *dictionary,
                                 uInt  dictLength);
 
int ZEXPORT deflateGetDictionary(z_streamp strm,
                                 Bytef *dictionary,
                                 uInt  *dictLength);
 
int ZEXPORT deflateCopy(z_streamp dest,
                        z_streamp source);
 
int ZEXPORT deflateReset(z_streamp strm);
 
int ZEXPORT deflateParams(z_streamp strm,
                          int level,
                          int strategy);
 
int ZEXPORT deflateTune(z_streamp strm,
                        int good_length,
                        int max_lazy,
                        int nice_length,
                        int max_chain);
 
uLong ZEXPORT deflateBound(z_streamp strm,
                           uLong sourceLen);
 
int ZEXPORT deflatePending(z_streamp strm,
                           unsigned *pending,
                           int *bits);
 
int ZEXPORT deflatePrime(z_streamp strm,
                         int bits,
                         int value);
 
int ZEXPORT deflateSetHeader(z_streamp strm,
                             gz_headerp head);
 
int ZEXPORT inflateSetDictionary(z_streamp strm,
                                 const Bytef *dictionary,
                                 uInt  dictLength);
 
int ZEXPORT inflateGetDictionary(z_streamp strm,
                                 Bytef *dictionary,
                                 uInt  *dictLength);
 
int ZEXPORT inflateSync(z_streamp strm);
 
ZEXTERN int ZEXPORT inflateCopy(z_streamp dest,
                                z_streamp source);
 
int ZEXPORT inflateReset(z_streamp strm);
 
int ZEXPORT inflateReset2(z_streamp strm,
                          int windowBits);
 
int ZEXPORT inflatePrime(z_streamp strm,
                         int bits,
                         int value);
 
long ZEXPORT inflateMark(z_streamp strm);
 
int ZEXPORT inflateGetHeader(z_streamp strm,
                             gz_headerp head);
 
typedef unsigned (*in_func)(void*, const unsigned char* *);
 
typedef int (*out_func)(void*, unsigned char *, unsigned);
 
int ZEXPORT inflateBack(z_streamp strm,
                        in_func in, void* in_desc,
                        out_func out, void* out_desc);
 
int ZEXPORT inflateBackEnd(z_streamp strm);
 
uLong ZEXPORT zlibCompileFlags(void);
 
#ifndef Z_SOLO
 
int ZEXPORT compress(Bytef *dest,   uLongf *destLen,
                     const Bytef *source, uLong sourceLen);
 
int ZEXPORT compress2(Bytef *dest,   uLongf *destLen,
                              const Bytef *source, uLong sourceLen,
                              int level);
 
uLong ZEXPORT compressBound(uLong sourceLen);
 
int ZEXPORT uncompress(Bytef *dest,   uLongf *destLen,
                       const Bytef *source, uLong sourceLen);
 
int ZEXPORT uncompress2(Bytef *dest,   uLongf *destLen,
                        const Bytef *source, uLong *sourceLen);
 
 
struct gzFile_s {
  unsigned have;
  unsigned char* next;
  z_off64_t pos;
}; 
 
typedef struct gzFile_s *gzFile;
 
gzFile ZEXPORT gzdopen(int fd, const char *mode);
 
int ZEXPORT gzbuffer(gzFile file, unsigned size);
 
int ZEXPORT gzsetparams(gzFile file, int level, int strategy);
 
int ZEXPORT gzread(gzFile file, voidp buf, unsigned len);
 
z_size_t ZEXPORT gzfread(voidp buf, z_size_t size, z_size_t nitems,
                                 gzFile file);
 
int ZEXPORT gzwrite(gzFile file, voidpc buf, unsigned len);
 
z_size_t ZEXPORT gzfwrite(voidpc buf, z_size_t size,
                                  z_size_t nitems, gzFile file);
 
int ZEXPORTVA gzprintf(gzFile file, const char *format, ...);
 
int ZEXPORT gzputs(gzFile file, const char *s);
 
char* ZEXPORT gzgets(gzFile file, char *buf, int len);
 
int ZEXPORT gzputc(gzFile file, int c);
 
int ZEXPORT gzgetc(gzFile file);
 
int ZEXPORT gzungetc(int c, gzFile file);
 
int ZEXPORT gzflush(gzFile file, int flush);
 
int ZEXPORT gzrewind(gzFile file);
 
int ZEXPORT gzeof(gzFile file);
 
int ZEXPORT gzdirect(gzFile file);
 
int ZEXPORT gzclose(gzFile file);
 
int ZEXPORT gzclose_r(gzFile file);
int ZEXPORT gzclose_w(gzFile file);
 
const char * ZEXPORT gzerror(gzFile file, int *errnum);
 
ZEXTERN void ZEXPORT gzclearerr(gzFile file);
 
#endif /* !Z_SOLO */
 
                        /* checksum functions */
 
/*
     These functions are not related to compression but are exported
   anyway because they might be useful in applications using the compression
   library.
*/
 
uLong ZEXPORT adler32(uLong adler, const Bytef *buf, uInt len);
uLong ZEXPORT adler32_z(uLong adler, const Bytef *buf,
                        z_size_t len);
 
uLong ZEXPORT crc32(uLong crc, const Bytef *buf, uInt len);
 
uLong ZEXPORT crc32_z(uLong crc, const Bytef *buf,
                      z_size_t len);
 
/*
ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t len2);
 
     Return the operator corresponding to length len2, to be used with
   crc32_combine_op().
*/
 
ZEXTERN uLong ZEXPORT crc32_combine_op(uLong crc1, uLong crc2, uLong op);
 
 
                        /* various hacks, don't look :) */
 
/* deflateInit and inflateInit are macros to allow checking the zlib version
 * and the compiler's view of z_stream:
 */
ZEXTERN int ZEXPORT deflateInit_(z_streamp strm, int level,
                                 const char *version, int stream_size);
 
 
int ZEXPORT inflateInit_(z_streamp strm,
                         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);
 
int ZEXPORT inflateInit2_(z_streamp strm, int  windowBits,
                          const char *version, int stream_size);
 
 
int ZEXPORT inflateBackInit_(z_streamp strm, int windowBits,
                             unsigned char* window,
                             const char *version,
                             int stream_size);
#ifdef Z_PREFIX_SET
#  define z_deflateInit(strm, level) \
          deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
 
#  define z_inflateInit(strm) \
          inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
#  define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
          deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
                        (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
 
#  define z_inflateInit2(strm, windowBits) \
          inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
                        (int)sizeof(z_stream))
 
#  define z_inflateBackInit(strm, windowBits, window) \
          inflateBackInit_((strm), (windowBits), (window), \
                           ZLIB_VERSION, (int)sizeof(z_stream))
#else
#  define deflateInit(strm, level) \
          deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
 
#  define inflateInit(strm) \
          inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
 
#  define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
          deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
                        (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
 
#  define inflateInit2(strm, windowBits) \
          inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
                        (int)sizeof(z_stream))
 
#  define inflateBackInit(strm, windowBits, window) \
          inflateBackInit_((strm), (windowBits), (window), \
                           ZLIB_VERSION, (int)sizeof(z_stream))
#endif
 
#ifndef Z_SOLO
 
/* gzgetc() macro and its supporting function and exposed data structure. */
 
ZEXTERN int ZEXPORT gzgetc_(gzFile file);       /* backward compatibility */
#ifdef Z_PREFIX_SET
#  undef z_gzgetc
#  define z_gzgetc(g) \
          ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
#else
#  define gzgetc(g) \
          ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g))
#endif
 
/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or
 * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if
 * both are true, the application gets the *64 functions, and the regular
 * functions are changed to 64 bits) -- in case these are set on systems
 * without large file support, _LFS64_LARGEFILE must also be true
 */
#ifdef Z_LARGE64
   ZEXTERN gzFile ZEXPORT gzopen64(const char *, const char *);
   ZEXTERN z_off64_t ZEXPORT gzseek64(gzFile, z_off64_t, int);
   ZEXTERN z_off64_t ZEXPORT gztell64(gzFile);
   ZEXTERN z_off64_t ZEXPORT gzoffset64(gzFile);
   ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off64_t);
   ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off64_t);
   ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off64_t);
#endif
 
#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64)
#  ifdef Z_PREFIX_SET
#    define z_gzopen z_gzopen64
#    define z_gzseek z_gzseek64
#    define z_gztell z_gztell64
#    define z_gzoffset z_gzoffset64
#    define z_adler32_combine z_adler32_combine64
#    define z_crc32_combine z_crc32_combine64
#    define z_crc32_combine_gen z_crc32_combine_gen64
#  else
#    define gzopen gzopen64
#    define gzseek gzseek64
#    define gztell gztell64
#    define gzoffset gzoffset64
#    define adler32_combine adler32_combine64
#    define crc32_combine crc32_combine64
#    define crc32_combine_gen crc32_combine_gen64
#  endif
#  ifndef Z_LARGE64
     ZEXTERN gzFile ZEXPORT gzopen64(const char *, const char *);
     ZEXTERN z_off_t ZEXPORT gzseek64(gzFile, z_off_t, int);
     ZEXTERN z_off_t ZEXPORT gztell64(gzFile);
     ZEXTERN z_off_t ZEXPORT gzoffset64(gzFile);
     ZEXTERN uLong ZEXPORT adler32_combine64(uLong, uLong, z_off_t);
     ZEXTERN uLong ZEXPORT crc32_combine64(uLong, uLong, z_off_t);
     ZEXTERN uLong ZEXPORT crc32_combine_gen64(z_off_t);
#  endif
#else
   gzFile ZEXPORT gzopen(const char *, const char *);
   z_off_t ZEXPORT gzseek(gzFile, z_off_t, int);
   z_off_t ZEXPORT gztell(gzFile);
   z_off_t ZEXPORT gzoffset(gzFile);
   ZEXTERN uLong ZEXPORT adler32_combine(uLong, uLong, z_off_t);
   ZEXTERN uLong ZEXPORT crc32_combine(uLong, uLong, z_off_t);
   ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t);
#endif
 
#else /* Z_SOLO */
 
   ZEXTERN uLong ZEXPORT adler32_combine(uLong, uLong, z_off_t);
   ZEXTERN uLong ZEXPORT crc32_combine(uLong, uLong, z_off_t);
   ZEXTERN uLong ZEXPORT crc32_combine_gen(z_off_t);
 
#endif /* !Z_SOLO */
 
/* undocumented functions */
ZEXTERN const char   * ZEXPORT zError(int);
ZEXTERN int            ZEXPORT inflateSyncPoint(z_streamp);
ZEXTERN const z_crc_t* ZEXPORT get_crc_table(void);
ZEXTERN int            ZEXPORT inflateUndermine(z_streamp, int);
ZEXTERN int            ZEXPORT inflateValidate(z_streamp, int);
ZEXTERN unsigned long  ZEXPORT inflateCodesUsed(z_streamp);
ZEXTERN int            ZEXPORT inflateResetKeep(z_streamp);
ZEXTERN int            ZEXPORT deflateResetKeep(z_streamp);
#if defined(_WIN32) && !defined(Z_SOLO)
ZEXTERN gzFile         ZEXPORT gzopen_w(const wchar_t *path,
                                        const char *mode);
#endif
#if defined(STDC) || defined(Z_HAVE_STDARG_H)
#  ifndef Z_SOLO
ZEXTERN int            ZEXPORTVA gzvprintf(gzFile file,
                                           const char *format,
                                           va_list va);
#  endif
#endif
 
#ifdef __cplusplus
}
#endif
 
#endif /* ZLIB_H */