offs[len + 1] = offs[len] + h->count[len];    /*     * put symbols in table sorted by length, by symbol order within each     * length     */    for (symbol = 0; symbol < n; symbol++)        if (length[symbol] != 0)            h->symbol[offs[length[symbol]]++] = symbol;    /* return zero for complete set, positive for incomplete set */    return left;}/* * Decode PKWare Compression Library stream. * * Format notes: * * - First byte is 0 if literals are uncoded or 1 if they are coded.  Second *   byte is 4, 5, or 6 for the number of extra bits in the distance code. *   This is the base-2 logarithm of the dictionary size minus six. * * - Compressed data is a combination of literals and length/distance pairs *   terminated by an end code.  Literals are either Huffman coded or *   uncoded bytes.  A length/distance pair is a coded length followed by a *   coded distance to represent a string that occurs earlier in the *   uncompressed data that occurs again at the current location. * * - A bit preceding a literal or length/distance pair indicates which comes *   next, 0 for literals, 1 for length/distance. * * - If literals are uncoded, then the next eight bits are the literal, in the *   normal bit order in th stream, i.e. no bit-reversal is needed. Similarly, *   no bit reversal is needed for either the length extra bits or the distance *   extra bits. * * - Literal bytes are simply written to the output.  A length/distance pair is *   an instruction to copy previously uncompressed bytes to the output.  The *   copy is from distance bytes back in the output stream, copying for length *   bytes. * * - Distances pointing before the beginning of the output data are not *   permitted. * * - Overlapped copies, where the length is greater than the distance, are *   allowed and common.  For example, a distance of one and a length of 518 *   simply copies the last byte 518 times.  A distance of four and a length of *   twelve copies the last four bytes three times.  A simple forward copy *   ignoring whether the length is greater than the distance or not implements *   this correctly. */local int decomp(struct state *s){    int lit;            /* true if literals are coded */    int dict;           /* log2(dictionary size) - 6 */    int symbol;         /* decoded symbol, extra bits for distance */    int len;            /* length for copy */    int dist;           /* distance for copy */    int copy;           /* copy counter */    unsigned char *from, *to;   /* copy pointers */    static int virgin = 1;                              /* build tables once */    static short litcnt[MAXBITS+1], litsym[256];        /* litcode memory */    static short lencnt[MAXBITS+1], lensym[16];         /* lencode memory */    static short distcnt[MAXBITS+1], distsym[64];       /* distcode memory */    static struct huffman litcode = {litcnt, litsym};   /* length code */    static struct huffman lencode = {lencnt, lensym};   /* length code */    static struct huffman distcode = {distcnt, distsym};/* distance code */        /* bit lengths of literal codes */    static const unsigned char litlen[] = {        11, 124, 8, 7, 28, 7, 188, 13, 76, 4, 10, 8, 12, 10, 12, 10, 8, 23, 8,        9, 7, 6, 7, 8, 7, 6, 55, 8, 23, 24, 12, 11, 7, 9, 11, 12, 6, 7, 22, 5,        7, 24, 6, 11, 9, 6, 7, 22, 7, 11, 38, 7, 9, 8, 25, 11, 8, 11, 9, 12,        8, 12, 5, 38, 5, 38, 5, 11, 7, 5, 6, 21, 6, 10, 53, 8, 7, 24, 10, 27,        44, 253, 253, 253, 252, 252, 252, 13, 12, 45, 12, 45, 12, 61, 12, 45,        44, 173};        /* bit lengths of length codes 0..15 */    static const unsigned char lenlen[] = {2, 35, 36, 53, 38, 23};        /* bit lengths of distance codes 0..63 */    static const unsigned char distlen[] = {2, 20, 53, 230, 247, 151, 248};    static const short base[16] = {     /* base for length codes */        3, 2, 4, 5, 6, 7, 8, 9, 10, 12, 16, 24, 40, 72, 136, 264};    static const char extra[16] = {     /* extra bits for length codes */        0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8};    /* set up decoding tables (once--might not be thread-safe) */    if (virgin) {        construct(&litcode, litlen, sizeof(litlen));        construct(&lencode, lenlen, sizeof(lenlen));        construct(&distcode, distlen, sizeof(distlen));        virgin = 0;    }    /* read header */    lit = bits(s, 8);    if (lit > 1) return -1;    dict = bits(s, 8);    if (dict < 4 || dict > 6) return -2;    /* decode literals and length/distance pairs */    do {        if (bits(s, 1)) {            /* get length */            symbol = decode(s, &lencode);            len = base[symbol] + bits(s, extra[symbol]);            if (len == 519) break;              /* end code */            /* get distance */            symbol = len == 2 ? 2 : dict;            dist = decode(s, &distcode) << symbol;            dist += bits(s, symbol);            dist++;            if (s->first && dist > s->next)                return -3;              /* distance too far back */            /* copy length bytes from distance bytes back */            do {                to = s->out + s->next;                from = to - dist;                copy = MAXWIN;                if (s->next < dist) {                    from += copy;                    copy = dist;                }                copy -= s->next;                if (copy > len) copy = len;                len -= copy;                s->next += copy;                do {                    *to++ = *from++;                } while (--copy);                if (s->next == MAXWIN) {                    if (s->outfun(s->outhow, s->out, s->next)) return 1;                    s->next = 0;                    s->first = 0;                }            } while (len != 0);        }        else {            /* get literal and write it */            symbol = lit ? decode(s, &litcode) : bits(s, 8);            s->out[s->next++] = symbol;            if (s->next == MAXWIN) {                if (s->outfun(s->outhow, s->out, s->next)) return 1;                s->next = 0;                s->first = 0;            }        }    } while (1);    return 0;}/* See comments in blast.h */int blast(blast_in infun, void *inhow, blast_out outfun, void *outhow){    struct state s;             /* input/output state */    int err;                    /* return value */    /* initialize input state */    s.infun = infun;    s.inhow = inhow;    s.left = 0;    s.bitbuf = 0;    s.bitcnt = 0;    /* initialize output state */    s.outfun = outfun;    s.outhow = outhow;    s.next = 0;    s.first = 1;    /* return if bits() or decode() tries to read past available input */    if (setjmp(s.env) != 0)             /* if came back here via longjmp(), */        err = 2;                        /*  then skip decomp(), return error */    else        err = decomp(&s);               /* decompress */    /* write any leftover output and update the error code if needed */    if (err != 1 && s.next && s.outfun(s.outhow, s.out, s.next) && err == 0)        err = 1;    return err;}#ifdef TEST/* Example of how to use blast() */#include <stdio.h>#include <stdlib.h>#define CHUNK 16384local unsigned inf(void *how, unsigned char **buf){    static unsigned char hold[CHUNK];    *buf = hold;    return fread(hold, 1, CHUNK, (FILE *)how);}local int outf(void *how, unsigned char *buf, unsigned len){    return fwrite(buf, 1, len, (FILE *)how) != len;}/* Decompress a PKWare Compression Library stream from stdin to stdout */int main(void){    int ret, n;    /* decompress to stdout */    ret = blast(inf, stdin, outf, stdout);    if (ret != 0) fprintf(stderr, "blast error: %d\n", ret);    /* see if there are any leftover bytes */    n = 0;    while (getchar() != EOF) n++;    if (n) fprintf(stderr, "blast warning: %d unused bytes of input\n", n);    /* return blast() error code */    return ret;}#endif