Subversion Repositories spk

#include <windows.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <tchar.h>

#include "unzip.h"

// THIS FILE is almost entirely based upon code by Jean-loup Gailly

// and Mark Adler. It has been modified by Lucian Wischik.

// The modifications were: incorporate the bugfixes of 1.1.4, allow

// unzipping to/from handles/pipes/files/memory, encryption, unicode,

// a windowsish api, and putting everything into a single .cpp file.

// The original code may be found at http://www.gzip.org/zlib/

// The original copyright text follows.

//

//

//

// zlib.h -- interface of the 'zlib' general purpose compression library

//  version 1.1.3, July 9th, 1998

//

//  Copyright (C) 1995-1998 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

//  arising from the use of this software.

//

//  Permission is granted to anyone to use this software for any purpose,

//  including commercial applications, and to alter it and redistribute it

//  freely, subject to the following restrictions:

//

//  1. The origin of this software must not be misrepresented; you must not

//     claim that you wrote the original software. If you use this software

//     in a product, an acknowledgment in the product documentation would be

//     appreciated but is not required.

//  2. Altered source versions must be plainly marked as such, and must not be

//     misrepresented as being the original software.

//  3. This notice may not be removed or altered from any source distribution.

//

//  Jean-loup Gailly        Mark Adler

//  jloup@gzip.org          madler@alumni.caltech.edu

//

//

//  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

//  (zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).

//

//

//     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

//  (deflation) but other algorithms will be added later and will have the same

//  stream interface.

//

//     Compression can be done in a single step if the buffers are large

//  enough (for example if an input file is mmap'ed), or can be done by

//  repeated calls of the compression function.  In the latter case, the

//  application must provide more input and/or consume the output

//  (providing more output space) before each call.

//

//     The library also supports reading and writing files in gzip (.gz) format

//  with an interface similar to that of stdio.

//

//     The library does not install any signal handler. The decoder checks

//  the consistency of the compressed data, so the library should never

//  crash even in case of corrupted input.

//

// for more info about .ZIP format, see ftp://ftp.cdrom.com/pub/infozip/doc/appnote-970311-iz.zip

//   PkWare has also a specification at ftp://ftp.pkware.com/probdesc.zip

#define ZIP_HANDLE   1

#define ZIP_FILENAME 2

#define ZIP_MEMORY   3

#define zmalloc(len) malloc(len)

#define zfree(p) free(p)

/*

void *zmalloc(unsigned int len)

{ char *buf = new char[len+32];

  for (int i=0; i<16; i++)

  { buf[i]=i;

    buf[len+31-i]=i;

  }

  *((unsigned int*)buf) = len;

  char c[1000]; wsprintf(c,"malloc 0x%lx  - %lu",buf+16,len);

  OutputDebugString(c);

  return buf+16;

}

void zfree(void *buf)

{ char c[1000]; wsprintf(c,"free   0x%lx",buf);

  OutputDebugString(c);

  char *p = ((char*)buf)-16;

  unsigned int len = *((unsigned int*)p);

  bool blown=false;

  for (int i=0; i<16; i++)

  { char lo = p[i];

    char hi = p[len+31-i];

    if (hi!=i || (lo!=i && i>4)) blown=true;

  }

  if (blown)

  { OutputDebugString("BLOWN!!!");

  }

  delete[] p;

}

*/

typedef struct tm_unz_s

{ unsigned int tm_sec;            // seconds after the minute - [0,59]

  unsigned int tm_min;            // minutes after the hour - [0,59]

  unsigned int tm_hour;           // hours since midnight - [0,23]

  unsigned int tm_mday;           // day of the month - [1,31]

  unsigned int tm_mon;            // months since January - [0,11]

  unsigned int tm_year;           // years - [1980..2044]

} tm_unz;

// unz_global_info structure contain global data about the ZIPfile

typedef struct unz_global_info_s

{ unsigned long number_entry;         // total number of entries in the central dir on this disk

  unsigned long size_comment;         // size of the global comment of the zipfile

} unz_global_info;

// unz_file_info contain information about a file in the zipfile

typedef struct unz_file_info_s

{ unsigned long version;              // version made by                 2 bytes

  unsigned long version_needed;       // version needed to extract       2 bytes

  unsigned long flag;                 // general purpose bit flag        2 bytes

  unsigned long compression_method;   // compression method              2 bytes

  unsigned long dosDate;              // last mod file date in Dos fmt   4 bytes

  unsigned long crc;                  // crc-32                          4 bytes

  unsigned long compressed_size;      // compressed size                 4 bytes

  unsigned long uncompressed_size;    // uncompressed size               4 bytes

  unsigned long size_filename;        // filename length                 2 bytes

  unsigned long size_file_extra;      // extra field length              2 bytes

  unsigned long size_file_comment;    // file comment length             2 bytes

  unsigned long disk_num_start;       // disk number start               2 bytes

  unsigned long internal_fa;          // internal file attributes        2 bytes

  unsigned long external_fa;          // external file attributes        4 bytes

  tm_unz tmu_date;

} unz_file_info;

#define UNZ_OK                  (0)

#define UNZ_END_OF_LIST_OF_FILE (-100)

#define UNZ_ERRNO               (Z_ERRNO)

#define UNZ_EOF                 (0)

#define UNZ_PARAMERROR          (-102)

#define UNZ_BADZIPFILE          (-103)

#define UNZ_INTERNALERROR       (-104)

#define UNZ_CRCERROR            (-105)

#define UNZ_PASSWORD            (-106)

#define ZLIB_VERSION "1.1.3"

// Allowed flush values; see deflate() for details

#define Z_NO_FLUSH      0

#define Z_SYNC_FLUSH    2

#define Z_FULL_FLUSH    3

#define Z_FINISH        4

// compression levels

#define Z_NO_COMPRESSION         0

#define Z_BEST_SPEED             1

#define Z_BEST_COMPRESSION       9

#define Z_DEFAULT_COMPRESSION  (-1)

// compression strategy; see deflateInit2() for details

#define Z_FILTERED            1

#define Z_HUFFMAN_ONLY        2

#define Z_DEFAULT_STRATEGY    0

// Possible values of the data_type field

#define Z_BINARY   0

#define Z_ASCII    1

#define Z_UNKNOWN  2

// The deflate compression method (the only one supported in this version)

#define Z_DEFLATED   8

// for initializing zalloc, zfree, opaque

#define Z_NULL  0

// case sensitivity when searching for filenames

#define CASE_SENSITIVE 1

#define CASE_INSENSITIVE 2

// Return codes for the compression/decompression functions. Negative

// values are errors, positive values are used for special but normal events.

#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)

// Basic data types

typedef unsigned char  Byte;  // 8 bits

typedef unsigned int   uInt;  // 16 bits or more

typedef unsigned long  uLong; // 32 bits or more

typedef void *voidpf;

typedef void     *voidp;

typedef long z_off_t;

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 {

    Byte    *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

    Byte    *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

    char     *msg;      // last error message, NULL if no error

    struct internal_state *state; // not visible by applications

    alloc_func zalloc;  // used to allocate the internal state

    free_func  zfree;   // used to free the internal state

    voidpf     opaque;  // private data object passed to zalloc and zfree

    int     data_type;  // best guess about the data type: ascii or binary

    uLong   adler;      // adler32 value of the uncompressed data

    uLong   reserved;   // reserved for future use

} z_stream;

typedef z_stream *z_streamp;

//   The application must update next_in and avail_in when avail_in has

//   dropped to zero. It must update next_out and avail_out when avail_out

//   has dropped to zero. The application must initialize zalloc, zfree and

//   opaque before calling the init function. All other fields are set by the

//   compression library and must not be updated by the application.

//

//   The opaque value provided by the application will be passed as the first

//   parameter for calls of zalloc and zfree. This can be useful for custom

//   memory management. The compression library attaches no meaning to the

//   opaque value.

//

//   zalloc must return Z_NULL if there is not enough memory for the object.

//   If zlib is used in a multi-threaded application, zalloc and zfree must be

//   thread safe.

//

//   The fields total_in and total_out can be used for statistics or

//   progress reports. After compression, total_in holds the total size of

//   the uncompressed data and may be saved for use in the decompressor

//   (particularly if the decompressor wants to decompress everything in

//   a single step).

//

// basic functions

const char *zlibVersion ();

// The application can compare zlibVersion and ZLIB_VERSION for consistency.

// If the first character differs, the library code actually used is

// not compatible with the zlib.h header file used by the application.

// This check is automatically made by inflateInit.

int inflate (z_streamp strm, int flush);

//

//    inflate decompresses as much data as possible, and stops when the input

//  buffer becomes empty or the output buffer becomes full. It may some

//  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:

//

//  - Decompress more input starting at next_in and update next_in and avail_in

//    accordingly. If not all input can be processed (because there is not

//    enough room in the output buffer), next_in is updated and processing

//    will resume at this point for the next call of inflate().

//

//  - Provide more output starting at next_out and update next_out and avail_out

//    accordingly.  inflate() provides as much output as possible, until there

//    is no more input data or no more space in the output buffer (see below

//    about the flush parameter).

//

//  Before the call of inflate(), the application should ensure that at least

//  one of the actions is possible, by providing more input and/or consuming

//  more output, and updating the next_* and avail_* values accordingly.

//  The application can consume the uncompressed output when it wants, for

//  example when the output buffer is full (avail_out == 0), or after each

//  call of inflate(). If inflate returns Z_OK and with zero avail_out, it

//  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.

//

//    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

//  (a single call of inflate), the parameter flush should be set to

//  Z_FINISH. In this case all pending input is processed and all pending

//  output is flushed; avail_out must be large enough to hold all the

//  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

//  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.

//

//    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.

//

int inflateEnd (z_streamp strm);

//

//     All dynamically allocated data structures for this stream are freed.

//   This function discards any unprocessed input and does not flush any

//   pending output.

//

//     inflateEnd returns Z_OK if success, Z_STREAM_ERROR if the stream state

//   was inconsistent. In the error case, msg may be set but then points to a

//   static string (which must not be deallocated).

                        // Advanced functions 

//  The following functions are needed only in some special applications.

int inflateSetDictionary (z_streamp strm,

                                             const Byte *dictionary,

                                             uInt  dictLength);

//

//     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

//   inflate. The compressor and decompressor must use exactly the same

//   dictionary. 

//

//     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

//   perform any decompression: this will be done by subsequent calls of

//   inflate().

int inflateSync (z_streamp strm);

// 

//    Skips invalid compressed data until a full flush point can be found, or until all

//  available input is skipped. No output is provided.

//

//    inflateSync returns Z_OK if a full flush point has been found, Z_BUF_ERROR

//  if no more input was provided, Z_DATA_ERROR if no flush point has been found,

//  or Z_STREAM_ERROR if the stream structure was inconsistent. In the success

//  case, the application may save the current current value of total_in which

//  indicates where valid compressed data was found. In the error case, the

//  application may repeatedly call inflateSync, providing more input each time,

//  until success or end of the input data.

int inflateReset (z_streamp strm);

//     This function is equivalent to inflateEnd followed by inflateInit,

//   but does not free and reallocate all the internal decompression state.

//   The stream will keep attributes that may have been set by inflateInit2.

//

//      inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source

//   stream state was inconsistent (such as zalloc or state being NULL).

//

// 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 adler32 (uLong adler, const Byte *buf, uInt len);

//     Update a running Adler-32 checksum with the bytes buf[0..len-1] and

//   return the updated checksum. If buf is NULL, this function returns

//   the required initial value for the checksum.

//   An Adler-32 checksum is almost as reliable as a CRC32 but can be computed

//   much faster. Usage example:

//

//     uLong adler = adler32(0L, Z_NULL, 0);

//

//     while (read_buffer(buffer, length) != EOF) {

//       adler = adler32(adler, buffer, length);

//     }

//     if (adler != original_adler) error();

uLong ucrc32   (uLong crc, const Byte *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

//   for the crc. Pre- and post-conditioning (one's complement) is performed

//   within this function so it shouldn't be done by the application.

//   Usage example:

//

//     uLong crc = crc32(0L, Z_NULL, 0);

//

//     while (read_buffer(buffer, length) != EOF) {

//       crc = crc32(crc, buffer, length);

//     }

//     if (crc != original_crc) error();

const char   *zError           (int err);

int           inflateSyncPoint (z_streamp z);

const uLong *get_crc_table    (void);

typedef unsigned char  uch;

typedef uch uchf;

typedef unsigned short ush;

typedef ush ushf;

typedef unsigned long  ulg;

const char * const z_errmsg[10] = { // indexed by 2-zlib_error

"need dictionary",     // Z_NEED_DICT       2

"stream end",          // Z_STREAM_END      1

"",                    // Z_OK              0

"file error",          // Z_ERRNO         (-1)

"stream error",        // Z_STREAM_ERROR  (-2)

"data error",          // Z_DATA_ERROR    (-3)

"insufficient memory", // Z_MEM_ERROR     (-4)

"buffer error",        // Z_BUF_ERROR     (-5)

"incompatible version",// Z_VERSION_ERROR (-6)

""};

#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]

#define ERR_RETURN(strm,err) \

  return (strm->msg = (char*)ERR_MSG(err), (err))

// To be used only when the state is known to be valid 

        // common constants

#define STORED_BLOCK 0

#define STATIC_TREES 1

#define DYN_TREES    2

// The three kinds of block type 

#define MIN_MATCH  3

#define MAX_MATCH  258

// The minimum and maximum match lengths 

#define PRESET_DICT 0x20 // preset dictionary flag in zlib header 

        // target dependencies 

#define OS_CODE  0x0b  // Window 95 & Windows NT

         // functions 

#define zmemzero(dest, len) memset(dest, 0, len)

// Diagnostic functions

#define LuAssert(cond,msg)

#define LuTrace(x)

#define LuTracev(x)

#define LuTracevv(x)

#define LuTracec(c,x)

#define LuTracecv(c,x)

typedef uLong (*check_func) (uLong check, const Byte *buf, uInt len);

voidpf zcalloc (voidpf opaque, unsigned items, unsigned size);

void   zcfree  (voidpf opaque, voidpf ptr);

#define ZALLOC(strm, items, size) \

           (*((strm)->zalloc))((strm)->opaque, (items), (size))

#define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))

//void ZFREE(z_streamp strm,voidpf addr)

//{ *((strm)->zfree))((strm)->opaque, addr);

//}

#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}

// Huffman code lookup table entry--this entry is four bytes for machines

// that have 16-bit pointers (e.g. PC's in the small or medium model).

typedef struct inflate_huft_s inflate_huft;

struct inflate_huft_s {

  union {

    struct {

      Byte Exop;        // number of extra bits or operation

      Byte Bits;        // number of bits in this code or subcode

    } what;

    uInt pad;           // pad structure to a power of 2 (4 bytes for

  } word;               //  16-bit, 8 bytes for 32-bit int's)

  uInt base;            // literal, length base, distance base, or table offset

};

// Maximum size of dynamic tree.  The maximum found in a long but non-

//   exhaustive search was 1004 huft structures (850 for length/literals

//   and 154 for distances, the latter actually the result of an

//   exhaustive search).  The actual maximum is not known, but the

//   value below is more than safe.

#define MANY 1440

int inflate_trees_bits (

    uInt *,                    // 19 code lengths

    uInt *,                    // bits tree desired/actual depth

    inflate_huft * *,       // bits tree result

    inflate_huft *,             // space for trees

    z_streamp);                // for messages

int inflate_trees_dynamic (

    uInt,                       // number of literal/length codes

    uInt,                       // number of distance codes

    uInt *,                    // that many (total) code lengths

    uInt *,                    // literal desired/actual bit depth

    uInt *,                    // distance desired/actual bit depth

    inflate_huft * *,       // literal/length tree result

    inflate_huft * *,       // distance tree result

    inflate_huft *,             // space for trees

    z_streamp);                // for messages

int inflate_trees_fixed (

    uInt *,                    // literal desired/actual bit depth

    uInt *,                    // distance desired/actual bit depth

    const inflate_huft * *,       // literal/length tree result

    const inflate_huft * *,       // distance tree result

    z_streamp);                // for memory allocation

struct inflate_blocks_state;

typedef struct inflate_blocks_state inflate_blocks_statef;

inflate_blocks_statef * inflate_blocks_new (

    z_streamp z,

    check_func c,               // check function

    uInt w);                   // window size

int inflate_blocks (

    inflate_blocks_statef *,

    z_streamp ,

    int);                      // initial return code

void inflate_blocks_reset (

    inflate_blocks_statef *,

    z_streamp ,

    uLong *);                  // check value on output

int inflate_blocks_free (

    inflate_blocks_statef *,

    z_streamp);

void inflate_set_dictionary (

    inflate_blocks_statef *s,

    const Byte *d,  // dictionary

    uInt  n);       // dictionary length

int inflate_blocks_sync_point (

    inflate_blocks_statef *s);

struct inflate_codes_state;

typedef struct inflate_codes_state inflate_codes_statef;

inflate_codes_statef *inflate_codes_new (

    uInt, uInt,

    const inflate_huft *, const inflate_huft *,

    z_streamp );

int inflate_codes (

    inflate_blocks_statef *,

    z_streamp ,

    int);

void inflate_codes_free (

    inflate_codes_statef *,

    z_streamp );

typedef enum {

      IBM_TYPE,     // get type bits (3, including end bit)

      IBM_LENS,     // get lengths for stored

      IBM_STORED,   // processing stored block

      IBM_TABLE,    // get table lengths

      IBM_BTREE,    // get bit lengths tree for a dynamic block

      IBM_DTREE,    // get length, distance trees for a dynamic block

      IBM_CODES,    // processing fixed or dynamic block

      IBM_DRY,      // output remaining window bytes

      IBM_DONE,     // finished last block, done 

      IBM_BAD}      // got a data error--stuck here 

inflate_block_mode;

// inflate blocks semi-private state 

struct inflate_blocks_state {

  // mode 

  inflate_block_mode  mode;     // current inflate_block mode 

  // mode dependent information 

  union {

    uInt left;          // if STORED, bytes left to copy 

    struct {

      uInt table;               // table lengths (14 bits) 

      uInt index;               // index into blens (or border)

      uInt *blens;             // bit lengths of codes

      uInt bb;                  // bit length tree depth 

      inflate_huft *tb;         // bit length decoding tree 

    } trees;            // if DTREE, decoding info for trees 

    struct {

      inflate_codes_statef 

         *codes;

    } decode;           // if CODES, current state 

  } sub;                // submode

  uInt last;            // true if this block is the last block 

  // mode independent information 

  uInt bitk;            // bits in bit buffer 

  uLong bitb;           // bit buffer 

  inflate_huft *hufts;  // single malloc for tree space 

  Byte *window;        // sliding window 

  Byte *end;           // one byte after sliding window 

  Byte *read;          // window read pointer 

  Byte *write;         // window write pointer 

  check_func checkfn;   // check function 

  uLong check;          // check on output 

};

// defines for inflate input/output

//   update pointers and return 

#define UPDBITS {s->bitb=b;s->bitk=k;}

#define UPDIN {z->avail_in=n;z->total_in+=(uLong)(p-z->next_in);z->next_in=p;}

#define UPDOUT {s->write=q;}

#define UPDATE {UPDBITS UPDIN UPDOUT}

#define LEAVE {UPDATE return inflate_flush(s,z,r);}

//   get bytes and bits 

#define LOADIN {p=z->next_in;n=z->avail_in;b=s->bitb;k=s->bitk;}

#define NEEDBYTE {if(n)r=Z_OK;else LEAVE}

#define NEXTBYTE (n--,*p++)

#define NEEDBITS(j) {while(k<(j)){NEEDBYTE;b|=((uLong)NEXTBYTE)<<k;k+=8;}}

#define DUMPBITS(j) {b>>=(j);k-=(j);}

//   output bytes 

#define WAVAIL (uInt)(q<s->read?s->read-q-1:s->end-q)

#define LOADOUT {q=s->write;m=(uInt)WAVAIL;m;}

#define WRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=(uInt)WAVAIL;}}

#define FLUSH {UPDOUT r=inflate_flush(s,z,r); LOADOUT}

#define NEEDOUT {if(m==0){WRAP if(m==0){FLUSH WRAP if(m==0) LEAVE}}r=Z_OK;}

#define OUTBYTE(a) {*q++=(Byte)(a);m--;}

//   load local pointers 

#define LOAD {LOADIN LOADOUT}

// masks for lower bits (size given to avoid silly warnings with Visual C++) 

// And'ing with mask[n] masks the lower n bits

const uInt inflate_mask[17] = {

    0x0000,

    0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff,

    0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff

};

// copy as much as possible from the sliding window to the output area

int inflate_flush (inflate_blocks_statef *, z_streamp, int);

int inflate_fast (uInt, uInt, const inflate_huft *, const inflate_huft *, inflate_blocks_statef *, z_streamp );

const uInt fixed_bl = 9;

const uInt fixed_bd = 5;

const inflate_huft fixed_tl[] = {

    {{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115},

    {{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},192},

    {{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},160},

    {{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},224},

    {{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},144},

    {{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},208},

    {{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},176},

    {{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},240},

    {{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227},

    {{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},200},

    {{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},168},

    {{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},232},

    {{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},152},

    {{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},216},

    {{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},184},

    {{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},248},

    {{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163},

    {{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},196},

    {{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},164},

    {{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},228},

    {{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},148},

    {{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},212},

    {{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},180},

    {{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},244},

    {{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0},

    {{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},204},

    {{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},172},

    {{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},236},

    {{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},156},

    {{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},220},

    {{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},188},

    {{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},252},

    {{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131},

    {{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},194},

    {{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},162},

    {{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},226},

    {{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},146},

    {{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},210},

    {{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},178},

    {{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},242},

    {{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258},

    {{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},202},

    {{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},170},

    {{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},234},

    {{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},154},

    {{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},218},

    {{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},186},

    {{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},250},

    {{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195},

    {{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},198},

    {{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},166},

    {{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},230},

    {{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},150},

    {{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},214},

    {{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},182},

    {{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},246},

    {{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0},

    {{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},206},

    {{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},174},

    {{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},238},

    {{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},158},

    {{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},222},

    {{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},190},

    {{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},254},

    {{{96,7}},256}, {{{0,8}},80}, {{{0,8}},16}, {{{84,8}},115},

    {{{82,7}},31}, {{{0,8}},112}, {{{0,8}},48}, {{{0,9}},193},

    {{{80,7}},10}, {{{0,8}},96}, {{{0,8}},32}, {{{0,9}},161},

    {{{0,8}},0}, {{{0,8}},128}, {{{0,8}},64}, {{{0,9}},225},

    {{{80,7}},6}, {{{0,8}},88}, {{{0,8}},24}, {{{0,9}},145},

    {{{83,7}},59}, {{{0,8}},120}, {{{0,8}},56}, {{{0,9}},209},

    {{{81,7}},17}, {{{0,8}},104}, {{{0,8}},40}, {{{0,9}},177},

    {{{0,8}},8}, {{{0,8}},136}, {{{0,8}},72}, {{{0,9}},241},

    {{{80,7}},4}, {{{0,8}},84}, {{{0,8}},20}, {{{85,8}},227},

    {{{83,7}},43}, {{{0,8}},116}, {{{0,8}},52}, {{{0,9}},201},

    {{{81,7}},13}, {{{0,8}},100}, {{{0,8}},36}, {{{0,9}},169},

    {{{0,8}},4}, {{{0,8}},132}, {{{0,8}},68}, {{{0,9}},233},

    {{{80,7}},8}, {{{0,8}},92}, {{{0,8}},28}, {{{0,9}},153},

    {{{84,7}},83}, {{{0,8}},124}, {{{0,8}},60}, {{{0,9}},217},

    {{{82,7}},23}, {{{0,8}},108}, {{{0,8}},44}, {{{0,9}},185},

    {{{0,8}},12}, {{{0,8}},140}, {{{0,8}},76}, {{{0,9}},249},

    {{{80,7}},3}, {{{0,8}},82}, {{{0,8}},18}, {{{85,8}},163},

    {{{83,7}},35}, {{{0,8}},114}, {{{0,8}},50}, {{{0,9}},197},

    {{{81,7}},11}, {{{0,8}},98}, {{{0,8}},34}, {{{0,9}},165},

    {{{0,8}},2}, {{{0,8}},130}, {{{0,8}},66}, {{{0,9}},229},

    {{{80,7}},7}, {{{0,8}},90}, {{{0,8}},26}, {{{0,9}},149},

    {{{84,7}},67}, {{{0,8}},122}, {{{0,8}},58}, {{{0,9}},213},

    {{{82,7}},19}, {{{0,8}},106}, {{{0,8}},42}, {{{0,9}},181},

    {{{0,8}},10}, {{{0,8}},138}, {{{0,8}},74}, {{{0,9}},245},

    {{{80,7}},5}, {{{0,8}},86}, {{{0,8}},22}, {{{192,8}},0},

    {{{83,7}},51}, {{{0,8}},118}, {{{0,8}},54}, {{{0,9}},205},

    {{{81,7}},15}, {{{0,8}},102}, {{{0,8}},38}, {{{0,9}},173},

    {{{0,8}},6}, {{{0,8}},134}, {{{0,8}},70}, {{{0,9}},237},

    {{{80,7}},9}, {{{0,8}},94}, {{{0,8}},30}, {{{0,9}},157},

    {{{84,7}},99}, {{{0,8}},126}, {{{0,8}},62}, {{{0,9}},221},

    {{{82,7}},27}, {{{0,8}},110}, {{{0,8}},46}, {{{0,9}},189},

    {{{0,8}},14}, {{{0,8}},142}, {{{0,8}},78}, {{{0,9}},253},

    {{{96,7}},256}, {{{0,8}},81}, {{{0,8}},17}, {{{85,8}},131},

    {{{82,7}},31}, {{{0,8}},113}, {{{0,8}},49}, {{{0,9}},195},

    {{{80,7}},10}, {{{0,8}},97}, {{{0,8}},33}, {{{0,9}},163},

    {{{0,8}},1}, {{{0,8}},129}, {{{0,8}},65}, {{{0,9}},227},

    {{{80,7}},6}, {{{0,8}},89}, {{{0,8}},25}, {{{0,9}},147},

    {{{83,7}},59}, {{{0,8}},121}, {{{0,8}},57}, {{{0,9}},211},

    {{{81,7}},17}, {{{0,8}},105}, {{{0,8}},41}, {{{0,9}},179},

    {{{0,8}},9}, {{{0,8}},137}, {{{0,8}},73}, {{{0,9}},243},

    {{{80,7}},4}, {{{0,8}},85}, {{{0,8}},21}, {{{80,8}},258},

    {{{83,7}},43}, {{{0,8}},117}, {{{0,8}},53}, {{{0,9}},203},

    {{{81,7}},13}, {{{0,8}},101}, {{{0,8}},37}, {{{0,9}},171},

    {{{0,8}},5}, {{{0,8}},133}, {{{0,8}},69}, {{{0,9}},235},

    {{{80,7}},8}, {{{0,8}},93}, {{{0,8}},29}, {{{0,9}},155},

    {{{84,7}},83}, {{{0,8}},125}, {{{0,8}},61}, {{{0,9}},219},

    {{{82,7}},23}, {{{0,8}},109}, {{{0,8}},45}, {{{0,9}},187},

    {{{0,8}},13}, {{{0,8}},141}, {{{0,8}},77}, {{{0,9}},251},

    {{{80,7}},3}, {{{0,8}},83}, {{{0,8}},19}, {{{85,8}},195},

    {{{83,7}},35}, {{{0,8}},115}, {{{0,8}},51}, {{{0,9}},199},

    {{{81,7}},11}, {{{0,8}},99}, {{{0,8}},35}, {{{0,9}},167},

    {{{0,8}},3}, {{{0,8}},131}, {{{0,8}},67}, {{{0,9}},231},

    {{{80,7}},7}, {{{0,8}},91}, {{{0,8}},27}, {{{0,9}},151},

    {{{84,7}},67}, {{{0,8}},123}, {{{0,8}},59}, {{{0,9}},215},

    {{{82,7}},19}, {{{0,8}},107}, {{{0,8}},43}, {{{0,9}},183},

    {{{0,8}},11}, {{{0,8}},139}, {{{0,8}},75}, {{{0,9}},247},

    {{{80,7}},5}, {{{0,8}},87}, {{{0,8}},23}, {{{192,8}},0},

    {{{83,7}},51}, {{{0,8}},119}, {{{0,8}},55}, {{{0,9}},207},

    {{{81,7}},15}, {{{0,8}},103}, {{{0,8}},39}, {{{0,9}},175},

    {{{0,8}},7}, {{{0,8}},135}, {{{0,8}},71}, {{{0,9}},239},

    {{{80,7}},9}, {{{0,8}},95}, {{{0,8}},31}, {{{0,9}},159},

    {{{84,7}},99}, {{{0,8}},127}, {{{0,8}},63}, {{{0,9}},223},

    {{{82,7}},27}, {{{0,8}},111}, {{{0,8}},47}, {{{0,9}},191},

    {{{0,8}},15}, {{{0,8}},143}, {{{0,8}},79}, {{{0,9}},255}

  };

const inflate_huft fixed_td[] = {

    {{{80,5}},1}, {{{87,5}},257}, {{{83,5}},17}, {{{91,5}},4097},

    {{{81,5}},5}, {{{89,5}},1025}, {{{85,5}},65}, {{{93,5}},16385},

    {{{80,5}},3}, {{{88,5}},513}, {{{84,5}},33}, {{{92,5}},8193},

    {{{82,5}},9}, {{{90,5}},2049}, {{{86,5}},129}, {{{192,5}},24577},

    {{{80,5}},2}, {{{87,5}},385}, {{{83,5}},25}, {{{91,5}},6145},

    {{{81,5}},7}, {{{89,5}},1537}, {{{85,5}},97}, {{{93,5}},24577},

    {{{80,5}},4}, {{{88,5}},769}, {{{84,5}},49}, {{{92,5}},12289},

    {{{82,5}},13}, {{{90,5}},3073}, {{{86,5}},193}, {{{192,5}},24577}

  };

// copy as much as possible from the sliding window to the output area

int inflate_flush(inflate_blocks_statef *s,z_streamp z,int r)

{

  uInt n;

  Byte *p;

  Byte *q;

  // local copies of source and destination pointers 

  p = z->next_out;

  q = s->read;

  // compute number of bytes to copy as far as end of window 

  n = (uInt)((q <= s->write ? s->write : s->end) - q);

  if (n > z->avail_out) n = z->avail_out;

  if (n && r == Z_BUF_ERROR) r = Z_OK;

  // update counters

  z->avail_out -= n;

  z->total_out += n;

  // update check information 

  if (s->checkfn != Z_NULL)

    z->adler = s->check = (*s->checkfn)(s->check, q, n);

  // copy as far as end of window 

  if (n!=0)          // check for n!=0 to avoid waking up CodeGuard

  { memcpy(p, q, n);

    p += n;

    q += n;

  }

  // see if more to copy at beginning of window

  if (q == s->end)

  {

    // wrap pointers 

    q = s->window;

    if (s->write == s->end)

      s->write = s->window;

    // compute bytes to copy 

    n = (uInt)(s->write - q);

    if (n > z->avail_out) n = z->avail_out;

    if (n && r == Z_BUF_ERROR) r = Z_OK;

    // update counters 

    z->avail_out -= n;

    z->total_out += n;

    // update check information 

    if (s->checkfn != Z_NULL)

      z->adler = s->check = (*s->checkfn)(s->check, q, n);

    // copy

    if (n!=0) {memcpy(p,q,n); p+=n; q+=n;}

  }

  // update pointers

  z->next_out = p;

  s->read = q;

  // done

  return r;

}

// simplify the use of the inflate_huft type with some defines

#define exop word.what.Exop

#define bits word.what.Bits

typedef enum {        // waiting for "i:"=input, "o:"=output, "x:"=nothing 

      START,    // x: set up for LEN 

      LEN,      // i: get length/literal/eob next 

      LENEXT,   // i: getting length extra (have base) 

      DIST,     // i: get distance next 

      DISTEXT,  // i: getting distance extra 

      COPY,     // o: copying bytes in window, waiting for space

      LIT,      // o: got literal, waiting for output space 

      WASH,     // o: got eob, possibly still output waiting 

      END,      // x: got eob and all data flushed 

      BADCODE}  // x: got error 

inflate_codes_mode;

// inflate codes private state

struct inflate_codes_state {

  // mode 

  inflate_codes_mode mode;      // current inflate_codes mode 

  // mode dependent information 

  uInt len;

  union {

    struct {

      const inflate_huft *tree;       // pointer into tree 

      uInt need;                // bits needed 

    } code;             // if LEN or DIST, where in tree 

    uInt lit;           // if LIT, literal 

    struct {

      uInt get;                 // bits to get for extra 

      uInt dist;                // distance back to copy from 

    } copy;             // if EXT or COPY, where and how much 

  } sub;                // submode

  // mode independent information 

  Byte lbits;           // ltree bits decoded per branch 

  Byte dbits;           // dtree bits decoder per branch 

  const inflate_huft *ltree;          // literal/length/eob tree

  const inflate_huft *dtree;          // distance tree

};

inflate_codes_statef *inflate_codes_new(

uInt bl, uInt bd,

const inflate_huft *tl,

const inflate_huft *td, // need separate declaration for Borland C++

z_streamp z)

{

  inflate_codes_statef *c;