From 86dbb30d76f752f68baff48f89fa08cea7148444 Mon Sep 17 00:00:00 2001 From: David Welch Date: Tue, 29 May 2012 02:13:41 -0400 Subject: [PATCH] adding zlib test --- zlib/Makefile | 158 ++++ zlib/a.c | 38 + zlib/adler32.c | 179 ++++ zlib/compress.c | 80 ++ zlib/crc32.c | 425 +++++++++ zlib/crc32.h | 441 +++++++++ zlib/deflate.c | 1965 +++++++++++++++++++++++++++++++++++++++++ zlib/deflate.h | 346 ++++++++ zlib/gzguts.h | 198 +++++ zlib/inffast.c | 340 +++++++ zlib/inffast.h | 11 + zlib/inffixed.h | 94 ++ zlib/inflate.c | 1496 +++++++++++++++++++++++++++++++ zlib/inflate.h | 122 +++ zlib/inftrees.c | 306 +++++++ zlib/inftrees.h | 62 ++ zlib/memmap | 12 + zlib/testdata.h | 630 +++++++++++++ zlib/thumb/Makefile | 87 ++ zlib/thumb/adler32.c | 179 ++++ zlib/thumb/compress.c | 80 ++ zlib/thumb/crc32.c | 425 +++++++++ zlib/thumb/crc32.h | 441 +++++++++ zlib/thumb/deflate.c | 1965 +++++++++++++++++++++++++++++++++++++++++ zlib/thumb/deflate.h | 346 ++++++++ zlib/thumb/gzguts.h | 198 +++++ zlib/thumb/inffast.c | 340 +++++++ zlib/thumb/inffast.h | 11 + zlib/thumb/inffixed.h | 94 ++ zlib/thumb/inflate.c | 1496 +++++++++++++++++++++++++++++++ zlib/thumb/inflate.h | 122 +++ zlib/thumb/inftrees.c | 306 +++++++ zlib/thumb/inftrees.h | 62 ++ zlib/thumb/libgcc.a | Bin 0 -> 5162692 bytes zlib/thumb/memmap | 12 + zlib/thumb/testdata.h | 630 +++++++++++++ zlib/thumb/trees.c | 1224 +++++++++++++++++++++++++ zlib/thumb/trees.h | 128 +++ zlib/thumb/twain.txt | 251 ++++++ zlib/thumb/uart.c | 94 ++ zlib/thumb/uncompr.c | 59 ++ zlib/thumb/vectors.s | 41 + zlib/thumb/zconf.h | 506 +++++++++++ zlib/thumb/zlib.h | 1744 ++++++++++++++++++++++++++++++++++++ zlib/thumb/zlibtest.c | 111 +++ zlib/thumb/zutil.c | 324 +++++++ zlib/thumb/zutil.h | 188 ++++ zlib/trees.c | 1224 +++++++++++++++++++++++++ zlib/trees.h | 128 +++ zlib/twain.txt | 251 ++++++ zlib/uart.c | 94 ++ zlib/uncompr.c | 59 ++ zlib/vectors.s | 34 + zlib/zconf.h | 506 +++++++++++ zlib/zlib.h | 1744 ++++++++++++++++++++++++++++++++++++ zlib/zlibtest.c | 111 +++ zlib/zutil.c | 324 +++++++ zlib/zutil.h | 188 ++++ 58 files changed, 23030 insertions(+) create mode 100644 zlib/Makefile create mode 100644 zlib/a.c create mode 100644 zlib/adler32.c create mode 100644 zlib/compress.c create mode 100644 zlib/crc32.c create mode 100644 zlib/crc32.h create mode 100644 zlib/deflate.c create mode 100644 zlib/deflate.h create mode 100644 zlib/gzguts.h create mode 100644 zlib/inffast.c create mode 100644 zlib/inffast.h create mode 100644 zlib/inffixed.h create mode 100644 zlib/inflate.c create mode 100644 zlib/inflate.h create mode 100644 zlib/inftrees.c create mode 100644 zlib/inftrees.h create mode 100644 zlib/memmap create mode 100644 zlib/testdata.h create mode 100644 zlib/thumb/Makefile create mode 100644 zlib/thumb/adler32.c create mode 100644 zlib/thumb/compress.c create mode 100644 zlib/thumb/crc32.c create mode 100644 zlib/thumb/crc32.h create mode 100644 zlib/thumb/deflate.c create mode 100644 zlib/thumb/deflate.h create mode 100644 zlib/thumb/gzguts.h create mode 100644 zlib/thumb/inffast.c create mode 100644 zlib/thumb/inffast.h create mode 100644 zlib/thumb/inffixed.h create mode 100644 zlib/thumb/inflate.c create mode 100644 zlib/thumb/inflate.h create mode 100644 zlib/thumb/inftrees.c create mode 100644 zlib/thumb/inftrees.h create mode 100644 zlib/thumb/libgcc.a create mode 100644 zlib/thumb/memmap create mode 100644 zlib/thumb/testdata.h create mode 100644 zlib/thumb/trees.c create mode 100644 zlib/thumb/trees.h create mode 100644 zlib/thumb/twain.txt create mode 100644 zlib/thumb/uart.c create mode 100644 zlib/thumb/uncompr.c create mode 100644 zlib/thumb/vectors.s create mode 100644 zlib/thumb/zconf.h create mode 100644 zlib/thumb/zlib.h create mode 100644 zlib/thumb/zlibtest.c create mode 100644 zlib/thumb/zutil.c create mode 100644 zlib/thumb/zutil.h create mode 100644 zlib/trees.c create mode 100644 zlib/trees.h create mode 100644 zlib/twain.txt create mode 100644 zlib/uart.c create mode 100644 zlib/uncompr.c create mode 100644 zlib/vectors.s create mode 100644 zlib/zconf.h create mode 100644 zlib/zlib.h create mode 100644 zlib/zlibtest.c create mode 100644 zlib/zutil.c create mode 100644 zlib/zutil.h diff --git a/zlib/Makefile b/zlib/Makefile new file mode 100644 index 0000000..59a1985 --- /dev/null +++ b/zlib/Makefile @@ -0,0 +1,158 @@ + +ARMGNU ?= arm-none-eabi + +COPS = -Wall -O2 -nostdlib -nostartfiles -ffreestanding + +gcc : zlibtest.hex zlibtest.bin + +all : gcc clang + +clean : + rm -f *.o + rm -f *.bin + rm -f *.hex + rm -f *.elf + rm -f *.list + rm -f *.img + rm -f *.bc + rm -f *.opt.s + + +GOBJLIST = vectors.o zlibtest.o uart.o compress.o deflate.o zutil.o adler32.o crc32.o trees.o inflate.o uncompr.o inftrees.o inffast.o + +vectors.o : vectors.s + $(ARMGNU)-as vectors.s -o vectors.o + +zlibtest.o : zlibtest.c + $(ARMGNU)-gcc $(COPS) -c zlibtest.c -o zlibtest.o + +zlibtest.elf : memmap $(GOBJLIST) + $(ARMGNU)-ld $(GOBJLIST) -T memmap -o zlibtest.elf + $(ARMGNU)-objdump -D zlibtest.elf > zlibtest.list + +zlibtest.bin : zlibtest.elf + $(ARMGNU)-objcopy zlibtest.elf -O binary zlibtest.bin + +zlibtest.hex : zlibtest.elf + $(ARMGNU)-objcopy zlibtest.elf -O ihex zlibtest.hex + + +uart.o : uart.c + $(ARMGNU)-gcc $(COPS) -c uart.c -o uart.o + +compress.o : compress.c + $(ARMGNU)-gcc $(COPS) -c compress.c -o compress.o + +deflate.o : deflate.c + $(ARMGNU)-gcc $(COPS) -c deflate.c -o deflate.o + +zutil.o : zutil.c + $(ARMGNU)-gcc $(COPS) -c zutil.c -o zutil.o + +adler32.o : adler32.c + $(ARMGNU)-gcc $(COPS) -c adler32.c -o adler32.o + +crc32.o : crc32.c + $(ARMGNU)-gcc $(COPS) -c crc32.c -o crc32.o + +trees.o : trees.c + $(ARMGNU)-gcc $(COPS) -c trees.c -o trees.o + +inflate.o : inflate.c + $(ARMGNU)-gcc $(COPS) -c inflate.c -o inflate.o + +uncompr.o : uncompr.c + $(ARMGNU)-gcc $(COPS) -c uncompr.c -o uncompr.o + +inftrees.o : inftrees.c + $(ARMGNU)-gcc $(COPS) -c inftrees.c -o inftrees.o + +inffast.o : inffast.c + $(ARMGNU)-gcc $(COPS) -c inffast.c -o inffast.o + + + + + +LOPS = -Wall -m32 -emit-llvm +LLCOPS = -mtriple=arm-none-eabi -march=arm -mcpu=arm1176jzf-s +LLCOPS0 = -march=arm +LLCOPS1 = -march=arm -mcpu=arm1176jzf-s +COPS = -Wall -O2 -nostdlib -nostartfiles -ffreestanding +OOPS = -std-compile-opts + +clang : zlibtest.clang.hex zlibtest.clang.bin + +COBJLIST = zlibtest.bc uart.bc compress.bc deflate.bc zutil.bc adler32.bc crc32.bc trees.bc inflate.bc uncompr.bc inftrees.bc inffast.bc + +zlibtest.bc : zlibtest.c + clang $(LOPS) -c zlibtest.c -o zlibtest.bc + +uart.bc : uart.c + clang $(LOPS) -c uart.c -o uart.bc + +compress.bc : compress.c + clang $(LOPS) -c compress.c -o compress.bc + +deflate.bc : deflate.c + clang $(LOPS) -c deflate.c -o deflate.bc + +zutil.bc : zutil.c + clang $(LOPS) -c zutil.c -o zutil.bc + +adler32.bc : adler32.c + clang $(LOPS) -c adler32.c -o adler32.bc + +crc32.bc : crc32.c + clang $(LOPS) -c crc32.c -o crc32.bc + +trees.bc : trees.c + clang $(LOPS) -c trees.c -o trees.bc + +inflate.bc : inflate.c + clang $(LOPS) -c inflate.c -o inflate.bc + +uncompr.bc : uncompr.c + clang $(LOPS) -c uncompr.c -o uncompr.bc + +inftrees.bc : inftrees.c + clang $(LOPS) -c inftrees.c -o inftrees.bc + +inffast.bc : inffast.c + clang $(LOPS) -c inffast.c -o inffast.bc + +zlibtest.clang.bc : $(COBJLIST) + llvm-link -o zlibtest.clang.bc $(COBJLIST) + +zlibtest.clang.opt.elf : memmap vectors.o zlibtest.clang.bc + opt $(OOPS) zlibtest.clang.bc -o zlibtest.clang.opt.bc + llc $(LLCOPS) zlibtest.clang.opt.bc -o zlibtest.clang.opt.s + $(ARMGNU)-as zlibtest.clang.opt.s -o zlibtest.clang.opt.o + $(ARMGNU)-ld -o zlibtest.clang.opt.elf -T memmap vectors.o zlibtest.clang.opt.o + $(ARMGNU)-objdump -D zlibtest.clang.opt.elf > zlibtest.clang.opt.list + +zlibtest.clang.hex : zlibtest.clang.opt.elf + $(ARMGNU)-objcopy zlibtest.clang.opt.elf zlibtest.clang.hex -O ihex + +zlibtest.clang.bin : zlibtest.clang.opt.elf + $(ARMGNU)-objcopy zlibtest.clang.opt.elf zlibtest.clang.bin -O binary + + + + + + + + + + + + + + + + + + + + diff --git a/zlib/a.c b/zlib/a.c new file mode 100644 index 0000000..ceda34c --- /dev/null +++ b/zlib/a.c @@ -0,0 +1,38 @@ + +#include +#include +#include + +FILE *fp; + +unsigned char data[10000]; + +int main ( void ) +{ + unsigned int ra; + + fp=fopen("twain.txt","rb"); + if(fp==NULL) return(1); + fread(data,1,sizeof(data),fp); + fclose(fp); + + fp=fopen("testdata.h","wt"); + if(fp==NULL) return(1); + fprintf(fp,"\n"); + fprintf(fp,"#define TESTDATALEN %u\n",(unsigned int)sizeof(data)); + fprintf(fp,"const unsigned char testdata[TESTDATALEN]=\n"); + fprintf(fp,"{"); + for(ra=0;ra> 16; \ + a &= 0xffffUL; \ + a += (tmp << 4) - tmp; \ + } while (0) +# define MOD28(a) \ + do { \ + CHOP(a); \ + if (a >= BASE) a -= BASE; \ + } while (0) +# define MOD(a) \ + do { \ + CHOP(a); \ + MOD28(a); \ + } while (0) +# define MOD63(a) \ + do { /* this assumes a is not negative */ \ + z_off64_t tmp = a >> 32; \ + a &= 0xffffffffL; \ + a += (tmp << 8) - (tmp << 5) + tmp; \ + tmp = a >> 16; \ + a &= 0xffffL; \ + a += (tmp << 4) - tmp; \ + tmp = a >> 16; \ + a &= 0xffffL; \ + a += (tmp << 4) - tmp; \ + if (a >= BASE) a -= BASE; \ + } while (0) +#else +# define MOD(a) a %= BASE +# define MOD28(a) a %= BASE +# define MOD63(a) a %= BASE +#endif + +/* ========================================================================= */ +uInt ZEXPORT adler32(adler, buf, len) + uInt adler; + const Bytef *buf; + uInt len; +{ + unsigned int sum2; + unsigned n; + + /* split Adler-32 into component sums */ + sum2 = (adler >> 16) & 0xffff; + adler &= 0xffff; + + /* in case user likes doing a byte at a time, keep it fast */ + if (len == 1) { + adler += buf[0]; + if (adler >= BASE) + adler -= BASE; + sum2 += adler; + if (sum2 >= BASE) + sum2 -= BASE; + return adler | (sum2 << 16); + } + + /* initial Adler-32 value (deferred check for len == 1 speed) */ + if (buf == Z_NULL) + return 1L; + + /* in case short lengths are provided, keep it somewhat fast */ + if (len < 16) { + while (len--) { + adler += *buf++; + sum2 += adler; + } + if (adler >= BASE) + adler -= BASE; + MOD28(sum2); /* only added so many BASE's */ + return adler | (sum2 << 16); + } + + /* do length NMAX blocks -- requires just one modulo operation */ + while (len >= NMAX) { + len -= NMAX; + n = NMAX / 16; /* NMAX is divisible by 16 */ + do { + DO16(buf); /* 16 sums unrolled */ + buf += 16; + } while (--n); + MOD(adler); + MOD(sum2); + } + + /* do remaining bytes (less than NMAX, still just one modulo) */ + if (len) { /* avoid modulos if none remaining */ + while (len >= 16) { + len -= 16; + DO16(buf); + buf += 16; + } + while (len--) { + adler += *buf++; + sum2 += adler; + } + MOD(adler); + MOD(sum2); + } + + /* return recombined sums */ + return adler | (sum2 << 16); +} + +/* ========================================================================= */ +local uInt adler32_combine_(adler1, adler2, len2) + uInt adler1; + uInt adler2; + z_off64_t len2; +{ + unsigned int sum1; + unsigned int sum2; + unsigned rem; + + /* for negative len, return invalid adler32 as a clue for debugging */ + if (len2 < 0) + return 0xffffffffUL; + + /* the derivation of this formula is left as an exercise for the reader */ + MOD63(len2); /* assumes len2 >= 0 */ + rem = (unsigned)len2; + sum1 = adler1 & 0xffff; + sum2 = rem * sum1; + MOD(sum2); + sum1 += (adler2 & 0xffff) + BASE - 1; + sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem; + if (sum1 >= BASE) sum1 -= BASE; + if (sum1 >= BASE) sum1 -= BASE; + if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1); + if (sum2 >= BASE) sum2 -= BASE; + return sum1 | (sum2 << 16); +} + +/* ========================================================================= */ +uInt ZEXPORT adler32_combine(adler1, adler2, len2) + uInt adler1; + uInt adler2; + z_off_t len2; +{ + return adler32_combine_(adler1, adler2, len2); +} + +uInt ZEXPORT adler32_combine64(adler1, adler2, len2) + uInt adler1; + uInt adler2; + z_off64_t len2; +{ + return adler32_combine_(adler1, adler2, len2); +} diff --git a/zlib/compress.c b/zlib/compress.c new file mode 100644 index 0000000..0471550 --- /dev/null +++ b/zlib/compress.c @@ -0,0 +1,80 @@ +/* compress.c -- compress a memory buffer + * Copyright (C) 1995-2005 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#define ZLIB_INTERNAL +#include "zlib.h" + +/* =========================================================================== + 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. + + 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. +*/ +int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) + Bytef *dest; + uIntf *destLen; + const Bytef *source; + uInt sourceLen; + int level; +{ + z_stream stream; + int err; + + stream.next_in = (Bytef*)source; + stream.avail_in = (uInt)sourceLen; +#ifdef MAXSEG_64K + /* Check for source > 64K on 16-bit machine: */ + if ((uInt)stream.avail_in != sourceLen) return Z_BUF_ERROR; +#endif + stream.next_out = dest; + stream.avail_out = (uInt)*destLen; + if ((uInt)stream.avail_out != *destLen) return Z_BUF_ERROR; + + stream.zalloc = (alloc_func)0; + stream.zfree = (free_func)0; + stream.opaque = (voidpf)0; + + err = deflateInit(&stream, level); + if (err != Z_OK) return err; + + err = deflate(&stream, Z_FINISH); + if (err != Z_STREAM_END) { + deflateEnd(&stream); + return err == Z_OK ? Z_BUF_ERROR : err; + } + *destLen = stream.total_out; + + err = deflateEnd(&stream); + return err; +} + +/* =========================================================================== + */ +int ZEXPORT compress (dest, destLen, source, sourceLen) + Bytef *dest; + uIntf *destLen; + const Bytef *source; + uInt sourceLen; +{ + return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION); +} + +/* =========================================================================== + If the default memLevel or windowBits for deflateInit() is changed, then + this function needs to be updated. + */ +uInt ZEXPORT compressBound (sourceLen) + uInt sourceLen; +{ + return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + + (sourceLen >> 25) + 13; +} diff --git a/zlib/crc32.c b/zlib/crc32.c new file mode 100644 index 0000000..99fa227 --- /dev/null +++ b/zlib/crc32.c @@ -0,0 +1,425 @@ +/* crc32.c -- compute the CRC-32 of a data stream + * Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + * + * Thanks to Rodney Brown for his contribution of faster + * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing + * tables for updating the shift register in one step with three exclusive-ors + * instead of four steps with four exclusive-ors. This results in about a + * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3. + */ + +/* @(#) $Id$ */ + +/* + Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore + protection on the static variables used to control the first-use generation + of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should + first call get_crc_table() to initialize the tables before allowing more than + one thread to use crc32(). + + DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h. + */ + +#ifdef MAKECRCH +# include +# ifndef DYNAMIC_CRC_TABLE +# define DYNAMIC_CRC_TABLE +# endif /* !DYNAMIC_CRC_TABLE */ +#endif /* MAKECRCH */ + +#include "zutil.h" /* for STDC and FAR definitions */ + +#define local static + +/* Definitions for doing the crc four data bytes at a time. */ +#if !defined(NOBYFOUR) && defined(Z_U4) +# define BYFOUR +#endif +#ifdef BYFOUR + local unsigned int crc32_little OF((unsigned int, + const unsigned char FAR *, unsigned)); + local unsigned int crc32_big OF((unsigned int, + const unsigned char FAR *, unsigned)); +# define TBLS 8 +#else +# define TBLS 1 +#endif /* BYFOUR */ + +/* Local functions for crc concatenation */ +local unsigned int gf2_matrix_times OF((unsigned int *mat, + unsigned int vec)); +local void gf2_matrix_square OF((unsigned int *square, unsigned int *mat)); +local uInt crc32_combine_ OF((uInt crc1, uInt crc2, z_off64_t len2)); + + +#ifdef DYNAMIC_CRC_TABLE + +local volatile int crc_table_empty = 1; +local z_crc_t FAR crc_table[TBLS][256]; +local void make_crc_table OF((void)); +#ifdef MAKECRCH + local void write_table OF((FILE *, const z_crc_t FAR *)); +#endif /* MAKECRCH */ +/* + Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: + x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1. + + Polynomials over GF(2) are represented in binary, one bit per coefficient, + with the lowest powers in the most significant bit. Then adding polynomials + is just exclusive-or, and multiplying a polynomial by x is a right shift by + one. If we call the above polynomial p, and represent a byte as the + polynomial q, also with the lowest power in the most significant bit (so the + byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, + where a mod b means the remainder after dividing a by b. + + This calculation is done using the shift-register method of multiplying and + taking the remainder. The register is initialized to zero, and for each + incoming bit, x^32 is added mod p to the register if the bit is a one (where + x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by + x (which is shifting right by one and adding x^32 mod p if the bit shifted + out is a one). We start with the highest power (least significant bit) of + q and repeat for all eight bits of q. + + The first table is simply the CRC of all possible eight bit values. This is + all the information needed to generate CRCs on data a byte at a time for all + combinations of CRC register values and incoming bytes. The remaining tables + allow for word-at-a-time CRC calculation for both big-endian and little- + endian machines, where a word is four bytes. +*/ +local void make_crc_table() +{ + z_crc_t c; + int n, k; + z_crc_t poly; /* polynomial exclusive-or pattern */ + /* terms of polynomial defining this crc (except x^32): */ + static volatile int first = 1; /* flag to limit concurrent making */ + static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; + + /* See if another task is already doing this (not thread-safe, but better + than nothing -- significantly reduces duration of vulnerability in + case the advice about DYNAMIC_CRC_TABLE is ignored) */ + if (first) { + first = 0; + + /* make exclusive-or pattern from polynomial (0xedb88320UL) */ + poly = 0; + for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++) + poly |= (z_crc_t)1 << (31 - p[n]); + + /* generate a crc for every 8-bit value */ + for (n = 0; n < 256; n++) { + c = (z_crc_t)n; + for (k = 0; k < 8; k++) + c = c & 1 ? poly ^ (c >> 1) : c >> 1; + crc_table[0][n] = c; + } + +#ifdef BYFOUR + /* generate crc for each value followed by one, two, and three zeros, + and then the byte reversal of those as well as the first table */ + for (n = 0; n < 256; n++) { + c = crc_table[0][n]; + crc_table[4][n] = ZSWAP32(c); + for (k = 1; k < 4; k++) { + c = crc_table[0][c & 0xff] ^ (c >> 8); + crc_table[k][n] = c; + crc_table[k + 4][n] = ZSWAP32(c); + } + } +#endif /* BYFOUR */ + + crc_table_empty = 0; + } + else { /* not first */ + /* wait for the other guy to finish (not efficient, but rare) */ + while (crc_table_empty) + ; + } + +#ifdef MAKECRCH + /* write out CRC tables to crc32.h */ + { + FILE *out; + + out = fopen("crc32.h", "w"); + if (out == NULL) return; + fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n"); + fprintf(out, " * Generated automatically by crc32.c\n */\n\n"); + fprintf(out, "local const z_crc_t FAR "); + fprintf(out, "crc_table[TBLS][256] =\n{\n {\n"); + write_table(out, crc_table[0]); +# ifdef BYFOUR + fprintf(out, "#ifdef BYFOUR\n"); + for (k = 1; k < 8; k++) { + fprintf(out, " },\n {\n"); + write_table(out, crc_table[k]); + } + fprintf(out, "#endif\n"); +# endif /* BYFOUR */ + fprintf(out, " }\n};\n"); + fclose(out); + } +#endif /* MAKECRCH */ +} + +#ifdef MAKECRCH +local void write_table(out, table) + FILE *out; + const z_crc_t FAR *table; +{ + int n; + + for (n = 0; n < 256; n++) + fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", + (unsigned int)(table[n]), + n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", ")); +} +#endif /* MAKECRCH */ + +#else /* !DYNAMIC_CRC_TABLE */ +/* ======================================================================== + * Tables of CRC-32s of all single-byte values, made by make_crc_table(). + */ +#include "crc32.h" +#endif /* DYNAMIC_CRC_TABLE */ + +/* ========================================================================= + * This function can be used by asm versions of crc32() + */ +const z_crc_t FAR * ZEXPORT get_crc_table() +{ +#ifdef DYNAMIC_CRC_TABLE + if (crc_table_empty) + make_crc_table(); +#endif /* DYNAMIC_CRC_TABLE */ + return (const z_crc_t FAR *)crc_table; +} + +/* ========================================================================= */ +#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8) +#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1 + +/* ========================================================================= */ +unsigned int ZEXPORT crc32(crc, buf, len) + unsigned int crc; + const unsigned char FAR *buf; + uInt len; +{ + if (buf == Z_NULL) return 0UL; + +#ifdef DYNAMIC_CRC_TABLE + if (crc_table_empty) + make_crc_table(); +#endif /* DYNAMIC_CRC_TABLE */ + +#ifdef BYFOUR + if (sizeof(void *) == sizeof(ptrdiff_t)) { + z_crc_t endian; + + endian = 1; + if (*((unsigned char *)(&endian))) + return crc32_little(crc, buf, len); + else + return crc32_big(crc, buf, len); + } +#endif /* BYFOUR */ + crc = crc ^ 0xffffffffUL; + while (len >= 8) { + DO8; + len -= 8; + } + if (len) do { + DO1; + } while (--len); + return crc ^ 0xffffffffUL; +} + +#ifdef BYFOUR + +/* ========================================================================= */ +#define DOLIT4 c ^= *buf4++; \ + c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \ + crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24] +#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4 + +/* ========================================================================= */ +local unsigned int crc32_little(crc, buf, len) + unsigned int crc; + const unsigned char FAR *buf; + unsigned len; +{ + register z_crc_t c; + register const z_crc_t FAR *buf4; + + c = (z_crc_t)crc; + c = ~c; + while (len && ((ptrdiff_t)buf & 3)) { + c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); + len--; + } + + buf4 = (const z_crc_t FAR *)(const void FAR *)buf; + while (len >= 32) { + DOLIT32; + len -= 32; + } + while (len >= 4) { + DOLIT4; + len -= 4; + } + buf = (const unsigned char FAR *)buf4; + + if (len) do { + c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); + } while (--len); + c = ~c; + return (unsigned int)c; +} + +/* ========================================================================= */ +#define DOBIG4 c ^= *++buf4; \ + c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \ + crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24] +#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4 + +/* ========================================================================= */ +local unsigned int crc32_big(crc, buf, len) + unsigned int crc; + const unsigned char FAR *buf; + unsigned len; +{ + register z_crc_t c; + register const z_crc_t FAR *buf4; + + c = ZSWAP32((z_crc_t)crc); + c = ~c; + while (len && ((ptrdiff_t)buf & 3)) { + c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); + len--; + } + + buf4 = (const z_crc_t FAR *)(const void FAR *)buf; + buf4--; + while (len >= 32) { + DOBIG32; + len -= 32; + } + while (len >= 4) { + DOBIG4; + len -= 4; + } + buf4++; + buf = (const unsigned char FAR *)buf4; + + if (len) do { + c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); + } while (--len); + c = ~c; + return (unsigned int)(ZSWAP32(c)); +} + +#endif /* BYFOUR */ + +#define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */ + +/* ========================================================================= */ +local unsigned int gf2_matrix_times(mat, vec) + unsigned int *mat; + unsigned int vec; +{ + unsigned int sum; + + sum = 0; + while (vec) { + if (vec & 1) + sum ^= *mat; + vec >>= 1; + mat++; + } + return sum; +} + +/* ========================================================================= */ +local void gf2_matrix_square(square, mat) + unsigned int *square; + unsigned int *mat; +{ + int n; + + for (n = 0; n < GF2_DIM; n++) + square[n] = gf2_matrix_times(mat, mat[n]); +} + +/* ========================================================================= */ +local uInt crc32_combine_(crc1, crc2, len2) + uInt crc1; + uInt crc2; + z_off64_t len2; +{ + int n; + unsigned int row; + unsigned int even[GF2_DIM]; /* even-power-of-two zeros operator */ + unsigned int odd[GF2_DIM]; /* odd-power-of-two zeros operator */ + + /* degenerate case (also disallow negative lengths) */ + if (len2 <= 0) + return crc1; + + /* put operator for one zero bit in odd */ + odd[0] = 0xedb88320UL; /* CRC-32 polynomial */ + row = 1; + for (n = 1; n < GF2_DIM; n++) { + odd[n] = row; + row <<= 1; + } + + /* put operator for two zero bits in even */ + gf2_matrix_square(even, odd); + + /* put operator for four zero bits in odd */ + gf2_matrix_square(odd, even); + + /* apply len2 zeros to crc1 (first square will put the operator for one + zero byte, eight zero bits, in even) */ + do { + /* apply zeros operator for this bit of len2 */ + gf2_matrix_square(even, odd); + if (len2 & 1) + crc1 = gf2_matrix_times(even, crc1); + len2 >>= 1; + + /* if no more bits set, then done */ + if (len2 == 0) + break; + + /* another iteration of the loop with odd and even swapped */ + gf2_matrix_square(odd, even); + if (len2 & 1) + crc1 = gf2_matrix_times(odd, crc1); + len2 >>= 1; + + /* if no more bits set, then done */ + } while (len2 != 0); + + /* return combined crc */ + crc1 ^= crc2; + return crc1; +} + +/* ========================================================================= */ +uInt ZEXPORT crc32_combine(crc1, crc2, len2) + uInt crc1; + uInt crc2; + z_off_t len2; +{ + return crc32_combine_(crc1, crc2, len2); +} + +uInt ZEXPORT crc32_combine64(crc1, crc2, len2) + uInt crc1; + uInt crc2; + z_off64_t len2; +{ + return crc32_combine_(crc1, crc2, len2); +} diff --git a/zlib/crc32.h b/zlib/crc32.h new file mode 100644 index 0000000..9e0c778 --- /dev/null +++ b/zlib/crc32.h @@ -0,0 +1,441 @@ +/* crc32.h -- tables for rapid CRC calculation + * Generated automatically by crc32.c + */ + +local const z_crc_t FAR crc_table[TBLS][256] = +{ + { + 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL, + 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL, + 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL, + 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL, + 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL, + 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL, + 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL, + 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL, + 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL, + 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL, + 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL, + 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL, + 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL, + 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL, + 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL, + 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL, + 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL, + 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL, + 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL, + 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL, + 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL, + 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL, + 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL, + 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL, + 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL, + 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL, + 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL, + 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL, + 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL, + 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL, + 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL, + 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL, + 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL, + 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL, + 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL, + 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL, + 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL, + 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL, + 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL, + 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL, + 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL, + 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL, + 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL, + 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL, + 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL, + 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL, + 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL, + 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL, + 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL, + 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL, + 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL, + 0x2d02ef8dUL +#ifdef BYFOUR + }, + { + 0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL, + 0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL, + 0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL, + 0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL, + 0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL, + 0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL, + 0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL, + 0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL, + 0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL, + 0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL, + 0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL, + 0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL, + 0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL, + 0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL, + 0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL, + 0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL, + 0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL, + 0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL, + 0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL, + 0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL, + 0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL, + 0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL, + 0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL, + 0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL, + 0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL, + 0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL, + 0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL, + 0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL, + 0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL, + 0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL, + 0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL, + 0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL, + 0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL, + 0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL, + 0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL, + 0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL, + 0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL, + 0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL, + 0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL, + 0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL, + 0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL, + 0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL, + 0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL, + 0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL, + 0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL, + 0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL, + 0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL, + 0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL, + 0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL, + 0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL, + 0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL, + 0x9324fd72UL + }, + { + 0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL, + 0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL, + 0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL, + 0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL, + 0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL, + 0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL, + 0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL, + 0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL, + 0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL, + 0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL, + 0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL, + 0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL, + 0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL, + 0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL, + 0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL, + 0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL, + 0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL, + 0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL, + 0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL, + 0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL, + 0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL, + 0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL, + 0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL, + 0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL, + 0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL, + 0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL, + 0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL, + 0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL, + 0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL, + 0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL, + 0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL, + 0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL, + 0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL, + 0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL, + 0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL, + 0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL, + 0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL, + 0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL, + 0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL, + 0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL, + 0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL, + 0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL, + 0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL, + 0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL, + 0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL, + 0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL, + 0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL, + 0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL, + 0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL, + 0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL, + 0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL, + 0xbe9834edUL + }, + { + 0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL, + 0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL, + 0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL, + 0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL, + 0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL, + 0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL, + 0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL, + 0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL, + 0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL, + 0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL, + 0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL, + 0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL, + 0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL, + 0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL, + 0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL, + 0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL, + 0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL, + 0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL, + 0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL, + 0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL, + 0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL, + 0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL, + 0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL, + 0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL, + 0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL, + 0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL, + 0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL, + 0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL, + 0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL, + 0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL, + 0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL, + 0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL, + 0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL, + 0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL, + 0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL, + 0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL, + 0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL, + 0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL, + 0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL, + 0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL, + 0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL, + 0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL, + 0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL, + 0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL, + 0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL, + 0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL, + 0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL, + 0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL, + 0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL, + 0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL, + 0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL, + 0xde0506f1UL + }, + { + 0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL, + 0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL, + 0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL, + 0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL, + 0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL, + 0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL, + 0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL, + 0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL, + 0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL, + 0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL, + 0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL, + 0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL, + 0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL, + 0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL, + 0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL, + 0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL, + 0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL, + 0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL, + 0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL, + 0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL, + 0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL, + 0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL, + 0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL, + 0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL, + 0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL, + 0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL, + 0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL, + 0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL, + 0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL, + 0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL, + 0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL, + 0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL, + 0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL, + 0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL, + 0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL, + 0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL, + 0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL, + 0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL, + 0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL, + 0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL, + 0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL, + 0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL, + 0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL, + 0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL, + 0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL, + 0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL, + 0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL, + 0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL, + 0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL, + 0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL, + 0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL, + 0x8def022dUL + }, + { + 0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL, + 0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL, + 0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL, + 0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL, + 0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL, + 0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL, + 0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL, + 0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL, + 0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL, + 0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL, + 0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL, + 0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL, + 0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL, + 0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL, + 0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL, + 0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL, + 0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL, + 0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL, + 0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL, + 0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL, + 0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL, + 0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL, + 0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL, + 0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL, + 0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL, + 0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL, + 0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL, + 0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL, + 0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL, + 0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL, + 0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL, + 0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL, + 0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL, + 0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL, + 0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL, + 0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL, + 0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL, + 0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL, + 0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL, + 0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL, + 0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL, + 0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL, + 0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL, + 0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL, + 0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL, + 0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL, + 0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL, + 0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL, + 0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL, + 0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL, + 0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL, + 0x72fd2493UL + }, + { + 0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL, + 0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL, + 0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL, + 0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL, + 0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL, + 0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL, + 0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL, + 0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL, + 0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL, + 0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL, + 0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL, + 0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL, + 0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL, + 0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL, + 0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL, + 0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL, + 0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL, + 0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL, + 0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL, + 0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL, + 0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL, + 0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL, + 0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL, + 0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL, + 0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL, + 0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL, + 0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL, + 0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL, + 0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL, + 0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL, + 0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL, + 0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL, + 0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL, + 0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL, + 0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL, + 0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL, + 0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL, + 0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL, + 0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL, + 0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL, + 0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL, + 0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL, + 0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL, + 0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL, + 0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL, + 0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL, + 0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL, + 0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL, + 0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL, + 0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL, + 0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL, + 0xed3498beUL + }, + { + 0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL, + 0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL, + 0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL, + 0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL, + 0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL, + 0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL, + 0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL, + 0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL, + 0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL, + 0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL, + 0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL, + 0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL, + 0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL, + 0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL, + 0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL, + 0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL, + 0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL, + 0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL, + 0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL, + 0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL, + 0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL, + 0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL, + 0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL, + 0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL, + 0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL, + 0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL, + 0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL, + 0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL, + 0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL, + 0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL, + 0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL, + 0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL, + 0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL, + 0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL, + 0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL, + 0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL, + 0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL, + 0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL, + 0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL, + 0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL, + 0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL, + 0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL, + 0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL, + 0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL, + 0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL, + 0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL, + 0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL, + 0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL, + 0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL, + 0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL, + 0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL, + 0xf10605deUL +#endif + } +}; diff --git a/zlib/deflate.c b/zlib/deflate.c new file mode 100644 index 0000000..d630741 --- /dev/null +++ b/zlib/deflate.c @@ -0,0 +1,1965 @@ +/* deflate.c -- compress data using the deflation algorithm + * Copyright (C) 1995-2012 Jean-loup Gailly and Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* + * ALGORITHM + * + * The "deflation" process depends on being able to identify portions + * of the input text which are identical to earlier input (within a + * sliding window trailing behind the input currently being processed). + * + * The most straightforward technique turns out to be the fastest for + * most input files: try all possible matches and select the longest. + * The key feature of this algorithm is that insertions into the string + * dictionary are very simple and thus fast, and deletions are avoided + * completely. Insertions are performed at each input character, whereas + * string matches are performed only when the previous match ends. So it + * is preferable to spend more time in matches to allow very fast string + * insertions and avoid deletions. The matching algorithm for small + * strings is inspired from that of Rabin & Karp. A brute force approach + * is used to find longer strings when a small match has been found. + * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze + * (by Leonid Broukhis). + * A previous version of this file used a more sophisticated algorithm + * (by Fiala and Greene) which is guaranteed to run in linear amortized + * time, but has a larger average cost, uses more memory and is patented. + * However the F&G algorithm may be faster for some highly redundant + * files if the parameter max_chain_length (described below) is too large. + * + * ACKNOWLEDGEMENTS + * + * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and + * I found it in 'freeze' written by Leonid Broukhis. + * Thanks to many people for bug reports and testing. + * + * REFERENCES + * + * Deutsch, L.P.,"DEFLATE Compressed Data Format Specification". + * Available in http://tools.ietf.org/html/rfc1951 + * + * A description of the Rabin and Karp algorithm is given in the book + * "Algorithms" by R. Sedgewick, Addison-Wesley, p252. + * + * Fiala,E.R., and Greene,D.H. + * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595 + * + */ + +/* @(#) $Id$ */ + +#include "deflate.h" + +const char deflate_copyright[] = + " deflate 1.2.7 Copyright 1995-2012 Jean-loup Gailly and Mark Adler "; +/* + If you use the zlib library in a product, an acknowledgment is welcome + in the documentation of your product. If for some reason you cannot + include such an acknowledgment, I would appreciate that you keep this + copyright string in the executable of your product. + */ + +/* =========================================================================== + * Function prototypes. + */ +typedef enum { + need_more, /* block not completed, need more input or more output */ + block_done, /* block flush performed */ + finish_started, /* finish started, need only more output at next deflate */ + finish_done /* finish done, accept no more input or output */ +} block_state; + +typedef block_state (*compress_func) OF((deflate_state *s, int flush)); +/* Compression function. Returns the block state after the call. */ + +local void fill_window OF((deflate_state *s)); +local block_state deflate_stored OF((deflate_state *s, int flush)); +local block_state deflate_fast OF((deflate_state *s, int flush)); +#ifndef FASTEST +local block_state deflate_slow OF((deflate_state *s, int flush)); +#endif +local block_state deflate_rle OF((deflate_state *s, int flush)); +local block_state deflate_huff OF((deflate_state *s, int flush)); +local void lm_init OF((deflate_state *s)); +local void putShortMSB OF((deflate_state *s, uInt b)); +local void flush_pending OF((z_streamp strm)); +local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); +#ifdef ASMV + void match_init OF((void)); /* asm code initialization */ + uInt longest_match OF((deflate_state *s, IPos cur_match)); +#else +local uInt longest_match OF((deflate_state *s, IPos cur_match)); +#endif + +#ifdef DEBUG +local void check_match OF((deflate_state *s, IPos start, IPos match, + int length)); +#endif + +/* =========================================================================== + * Local data + */ + +#define NIL 0 +/* Tail of hash chains */ + +#ifndef TOO_FAR +# define TOO_FAR 4096 +#endif +/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */ + +/* Values for max_lazy_match, good_match and max_chain_length, depending on + * the desired pack level (0..9). The values given below have been tuned to + * exclude worst case performance for pathological files. Better values may be + * found for specific files. + */ +typedef struct config_s { + ush good_length; /* reduce lazy search above this match length */ + ush max_lazy; /* do not perform lazy search above this match length */ + ush nice_length; /* quit search above this match length */ + ush max_chain; + compress_func func; +} config; + +#ifdef FASTEST +local const config configuration_table[2] = { +/* good lazy nice chain */ +/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ +/* 1 */ {4, 4, 8, 4, deflate_fast}}; /* max speed, no lazy matches */ +#else +local const config configuration_table[10] = { +/* good lazy nice chain */ +/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ +/* 1 */ {4, 4, 8, 4, deflate_fast}, /* max speed, no lazy matches */ +/* 2 */ {4, 5, 16, 8, deflate_fast}, +/* 3 */ {4, 6, 32, 32, deflate_fast}, + +/* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */ +/* 5 */ {8, 16, 32, 32, deflate_slow}, +/* 6 */ {8, 16, 128, 128, deflate_slow}, +/* 7 */ {8, 32, 128, 256, deflate_slow}, +/* 8 */ {32, 128, 258, 1024, deflate_slow}, +/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */ +#endif + +/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 + * For deflate_fast() (levels <= 3) good is ignored and lazy has a different + * meaning. + */ + +#define EQUAL 0 +/* result of memcmp for equal strings */ + +#ifndef NO_DUMMY_DECL +struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ +#endif + +/* rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH */ +#define RANK(f) (((f) << 1) - ((f) > 4 ? 9 : 0)) + +/* =========================================================================== + * Update a hash value with the given input byte + * IN assertion: all calls to to UPDATE_HASH are made with consecutive + * input characters, so that a running hash key can be computed from the + * previous key instead of complete recalculation each time. + */ +#define UPDATE_HASH(s,h,c) (h = (((h)<hash_shift) ^ (c)) & s->hash_mask) + + +/* =========================================================================== + * Insert string str in the dictionary and set match_head to the previous head + * of the hash chain (the most recent string with same hash key). Return + * the previous length of the hash chain. + * If this file is compiled with -DFASTEST, the compression level is forced + * to 1, and no hash chains are maintained. + * IN assertion: all calls to to INSERT_STRING are made with consecutive + * input characters and the first MIN_MATCH bytes of str are valid + * (except for the last MIN_MATCH-1 bytes of the input file). + */ +#ifdef FASTEST +#define INSERT_STRING(s, str, match_head) \ + (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ + match_head = s->head[s->ins_h], \ + s->head[s->ins_h] = (Pos)(str)) +#else +#define INSERT_STRING(s, str, match_head) \ + (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ + match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \ + s->head[s->ins_h] = (Pos)(str)) +#endif + +/* =========================================================================== + * Initialize the hash table (avoiding 64K overflow for 16 bit systems). + * prev[] will be initialized on the fly. + */ +#define CLEAR_HASH(s) \ + s->head[s->hash_size-1] = NIL; \ + zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); + +/* ========================================================================= */ +int ZEXPORT deflateInit_(strm, level, version, stream_size) + z_streamp strm; + int level; + const char *version; + int stream_size; +{ + return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, + Z_DEFAULT_STRATEGY, version, stream_size); + /* To do: ignore strm->next_in if we use it as window */ +} + +/* ========================================================================= */ +int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, + version, stream_size) + z_streamp strm; + int level; + int method; + int windowBits; + int memLevel; + int strategy; + const char *version; + int stream_size; +{ + deflate_state *s; + int wrap = 1; + static const char my_version[] = ZLIB_VERSION; + + ushf *overlay; + /* We overlay pending_buf and d_buf+l_buf. This works since the average + * output size for (length,distance) codes is <= 24 bits. + */ + + if (version == Z_NULL || version[0] != my_version[0] || + stream_size != sizeof(z_stream)) { + return Z_VERSION_ERROR; + } + if (strm == Z_NULL) return Z_STREAM_ERROR; + + strm->msg = Z_NULL; + if (strm->zalloc == (alloc_func)0) { +#ifdef Z_SOLO + return Z_STREAM_ERROR; +#else + strm->zalloc = zcalloc; + strm->opaque = (voidpf)0; +#endif + } + if (strm->zfree == (free_func)0) +#ifdef Z_SOLO + return Z_STREAM_ERROR; +#else + strm->zfree = zcfree; +#endif + +#ifdef FASTEST + if (level != 0) level = 1; +#else + if (level == Z_DEFAULT_COMPRESSION) level = 6; +#endif + + if (windowBits < 0) { /* suppress zlib wrapper */ + wrap = 0; + windowBits = -windowBits; + } +#ifdef GZIP + else if (windowBits > 15) { + wrap = 2; /* write gzip wrapper instead */ + windowBits -= 16; + } +#endif + if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED || + windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || + strategy < 0 || strategy > Z_FIXED) { + return Z_STREAM_ERROR; + } + if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */ + s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state)); + if (s == Z_NULL) return Z_MEM_ERROR; + strm->state = (struct internal_state FAR *)s; + s->strm = strm; + + s->wrap = wrap; + s->gzhead = Z_NULL; + s->w_bits = windowBits; + s->w_size = 1 << s->w_bits; + s->w_mask = s->w_size - 1; + + s->hash_bits = memLevel + 7; + s->hash_size = 1 << s->hash_bits; + s->hash_mask = s->hash_size - 1; + s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); + + s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte)); + s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos)); + s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos)); + + s->high_water = 0; /* nothing written to s->window yet */ + + s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ + + overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2); + s->pending_buf = (uchf *) overlay; + s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L); + + if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || + s->pending_buf == Z_NULL) { + s->status = FINISH_STATE; + strm->msg = (char*)ERR_MSG(Z_MEM_ERROR); + deflateEnd (strm); + return Z_MEM_ERROR; + } + s->d_buf = overlay + s->lit_bufsize/sizeof(ush); + s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize; + + s->level = level; + s->strategy = strategy; + s->method = (Byte)method; + + return deflateReset(strm); +} + +/* ========================================================================= */ +int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) + z_streamp strm; + const Bytef *dictionary; + uInt dictLength; +{ + deflate_state *s; + uInt str, n; + int wrap; + unsigned avail; + unsigned char *next; + + if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL) + return Z_STREAM_ERROR; + s = strm->state; + wrap = s->wrap; + if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead) + return Z_STREAM_ERROR; + + /* when using zlib wrappers, compute Adler-32 for provided dictionary */ + if (wrap == 1) + strm->adler = adler32(strm->adler, dictionary, dictLength); + s->wrap = 0; /* avoid computing Adler-32 in read_buf */ + + /* if dictionary would fill window, just replace the history */ + if (dictLength >= s->w_size) { + if (wrap == 0) { /* already empty otherwise */ + CLEAR_HASH(s); + s->strstart = 0; + s->block_start = 0L; + s->insert = 0; + } + dictionary += dictLength - s->w_size; /* use the tail */ + dictLength = s->w_size; + } + + /* insert dictionary into window and hash */ + avail = strm->avail_in; + next = strm->next_in; + strm->avail_in = dictLength; + strm->next_in = (Bytef *)dictionary; + fill_window(s); + while (s->lookahead >= MIN_MATCH) { + str = s->strstart; + n = s->lookahead - (MIN_MATCH-1); + do { + UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); +#ifndef FASTEST + s->prev[str & s->w_mask] = s->head[s->ins_h]; +#endif + s->head[s->ins_h] = (Pos)str; + str++; + } while (--n); + s->strstart = str; + s->lookahead = MIN_MATCH-1; + fill_window(s); + } + s->strstart += s->lookahead; + s->block_start = (int)s->strstart; + s->insert = s->lookahead; + s->lookahead = 0; + s->match_length = s->prev_length = MIN_MATCH-1; + s->match_available = 0; + strm->next_in = next; + strm->avail_in = avail; + s->wrap = wrap; + return Z_OK; +} + +/* ========================================================================= */ +int ZEXPORT deflateResetKeep (strm) + z_streamp strm; +{ + deflate_state *s; + + if (strm == Z_NULL || strm->state == Z_NULL || + strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) { + return Z_STREAM_ERROR; + } + + strm->total_in = strm->total_out = 0; + strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */ + strm->data_type = Z_UNKNOWN; + + s = (deflate_state *)strm->state; + s->pending = 0; + s->pending_out = s->pending_buf; + + if (s->wrap < 0) { + s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */ + } + s->status = s->wrap ? INIT_STATE : BUSY_STATE; + strm->adler = +#ifdef GZIP + s->wrap == 2 ? crc32(0L, Z_NULL, 0) : +#endif + adler32(0L, Z_NULL, 0); + s->last_flush = Z_NO_FLUSH; + + _tr_init(s); + + return Z_OK; +} + +/* ========================================================================= */ +int ZEXPORT deflateReset (strm) + z_streamp strm; +{ + int ret; + + ret = deflateResetKeep(strm); + if (ret == Z_OK) + lm_init(strm->state); + return ret; +} + +/* ========================================================================= */ +int ZEXPORT deflateSetHeader (strm, head) + z_streamp strm; + gz_headerp head; +{ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + if (strm->state->wrap != 2) return Z_STREAM_ERROR; + strm->state->gzhead = head; + return Z_OK; +} + +/* ========================================================================= */ +int ZEXPORT deflatePending (strm, pending, bits) + unsigned *pending; + int *bits; + z_streamp strm; +{ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + if (pending != Z_NULL) + *pending = strm->state->pending; + if (bits != Z_NULL) + *bits = strm->state->bi_valid; + return Z_OK; +} + +/* ========================================================================= */ +int ZEXPORT deflatePrime (strm, bits, value) + z_streamp strm; + int bits; + int value; +{ + deflate_state *s; + int put; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + s = strm->state; + if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3)) + return Z_BUF_ERROR; + do { + put = Buf_size - s->bi_valid; + if (put > bits) + put = bits; + s->bi_buf |= (ush)((value & ((1 << put) - 1)) << s->bi_valid); + s->bi_valid += put; + _tr_flush_bits(s); + value >>= put; + bits -= put; + } while (bits); + return Z_OK; +} + +/* ========================================================================= */ +int ZEXPORT deflateParams(strm, level, strategy) + z_streamp strm; + int level; + int strategy; +{ + deflate_state *s; + compress_func func; + int err = Z_OK; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + s = strm->state; + +#ifdef FASTEST + if (level != 0) level = 1; +#else + if (level == Z_DEFAULT_COMPRESSION) level = 6; +#endif + if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { + return Z_STREAM_ERROR; + } + func = configuration_table[s->level].func; + + if ((strategy != s->strategy || func != configuration_table[level].func) && + strm->total_in != 0) { + /* Flush the last buffer: */ + err = deflate(strm, Z_BLOCK); + } + if (s->level != level) { + s->level = level; + s->max_lazy_match = configuration_table[level].max_lazy; + s->good_match = configuration_table[level].good_length; + s->nice_match = configuration_table[level].nice_length; + s->max_chain_length = configuration_table[level].max_chain; + } + s->strategy = strategy; + return err; +} + +/* ========================================================================= */ +int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain) + z_streamp strm; + int good_length; + int max_lazy; + int nice_length; + int max_chain; +{ + deflate_state *s; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + s = strm->state; + s->good_match = good_length; + s->max_lazy_match = max_lazy; + s->nice_match = nice_length; + s->max_chain_length = max_chain; + return Z_OK; +} + +/* ========================================================================= + * For the default windowBits of 15 and memLevel of 8, this function returns + * a close to exact, as well as small, upper bound on the compressed size. + * They are coded as constants here for a reason--if the #define's are + * changed, then this function needs to be changed as well. The return + * value for 15 and 8 only works for those exact settings. + * + * For any setting other than those defaults for windowBits and memLevel, + * the value returned is a conservative worst case for the maximum expansion + * resulting from using fixed blocks instead of stored blocks, which deflate + * can emit on compressed data for some combinations of the parameters. + * + * This function could be more sophisticated to provide closer upper bounds for + * every combination of windowBits and memLevel. But even the conservative + * upper bound of about 14% expansion does not seem onerous for output buffer + * allocation. + */ +uInt ZEXPORT deflateBound(strm, sourceLen) + z_streamp strm; + uInt sourceLen; +{ + deflate_state *s; + uInt complen, wraplen; + Bytef *str; + + /* conservative upper bound for compressed data */ + complen = sourceLen + + ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5; + + /* if can't get parameters, return conservative bound plus zlib wrapper */ + if (strm == Z_NULL || strm->state == Z_NULL) + return complen + 6; + + /* compute wrapper length */ + s = strm->state; + switch (s->wrap) { + case 0: /* raw deflate */ + wraplen = 0; + break; + case 1: /* zlib wrapper */ + wraplen = 6 + (s->strstart ? 4 : 0); + break; + case 2: /* gzip wrapper */ + wraplen = 18; + if (s->gzhead != Z_NULL) { /* user-supplied gzip header */ + if (s->gzhead->extra != Z_NULL) + wraplen += 2 + s->gzhead->extra_len; + str = s->gzhead->name; + if (str != Z_NULL) + do { + wraplen++; + } while (*str++); + str = s->gzhead->comment; + if (str != Z_NULL) + do { + wraplen++; + } while (*str++); + if (s->gzhead->hcrc) + wraplen += 2; + } + break; + default: /* for compiler happiness */ + wraplen = 6; + } + + /* if not default parameters, return conservative bound */ + if (s->w_bits != 15 || s->hash_bits != 8 + 7) + return complen + wraplen; + + /* default settings: return tight bound for that case */ + return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + + (sourceLen >> 25) + 13 - 6 + wraplen; +} + +/* ========================================================================= + * Put a short in the pending buffer. The 16-bit value is put in MSB order. + * IN assertion: the stream state is correct and there is enough room in + * pending_buf. + */ +local void putShortMSB (s, b) + deflate_state *s; + uInt b; +{ + put_byte(s, (Byte)(b >> 8)); + put_byte(s, (Byte)(b & 0xff)); +} + +/* ========================================================================= + * Flush as much pending output as possible. All deflate() output goes + * through this function so some applications may wish to modify it + * to avoid allocating a large strm->next_out buffer and copying into it. + * (See also read_buf()). + */ +local void flush_pending(strm) + z_streamp strm; +{ + unsigned len; + deflate_state *s = strm->state; + + _tr_flush_bits(s); + len = s->pending; + if (len > strm->avail_out) len = strm->avail_out; + if (len == 0) return; + + zmemcpy(strm->next_out, s->pending_out, len); + strm->next_out += len; + s->pending_out += len; + strm->total_out += len; + strm->avail_out -= len; + s->pending -= len; + if (s->pending == 0) { + s->pending_out = s->pending_buf; + } +} + +/* ========================================================================= */ +int ZEXPORT deflate (strm, flush) + z_streamp strm; + int flush; +{ + int old_flush; /* value of flush param for previous deflate call */ + deflate_state *s; + + if (strm == Z_NULL || strm->state == Z_NULL || + flush > Z_BLOCK || flush < 0) { + return Z_STREAM_ERROR; + } + s = strm->state; + + if (strm->next_out == Z_NULL || + (strm->next_in == Z_NULL && strm->avail_in != 0) || + (s->status == FINISH_STATE && flush != Z_FINISH)) { + ERR_RETURN(strm, Z_STREAM_ERROR); + } + if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR); + + s->strm = strm; /* just in case */ + old_flush = s->last_flush; + s->last_flush = flush; + + /* Write the header */ + if (s->status == INIT_STATE) { +#ifdef GZIP + if (s->wrap == 2) { + strm->adler = crc32(0L, Z_NULL, 0); + put_byte(s, 31); + put_byte(s, 139); + put_byte(s, 8); + if (s->gzhead == Z_NULL) { + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, s->level == 9 ? 2 : + (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? + 4 : 0)); + put_byte(s, OS_CODE); + s->status = BUSY_STATE; + } + else { + put_byte(s, (s->gzhead->text ? 1 : 0) + + (s->gzhead->hcrc ? 2 : 0) + + (s->gzhead->extra == Z_NULL ? 0 : 4) + + (s->gzhead->name == Z_NULL ? 0 : 8) + + (s->gzhead->comment == Z_NULL ? 0 : 16) + ); + put_byte(s, (Byte)(s->gzhead->time & 0xff)); + put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff)); + put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff)); + put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff)); + put_byte(s, s->level == 9 ? 2 : + (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? + 4 : 0)); + put_byte(s, s->gzhead->os & 0xff); + if (s->gzhead->extra != Z_NULL) { + put_byte(s, s->gzhead->extra_len & 0xff); + put_byte(s, (s->gzhead->extra_len >> 8) & 0xff); + } + if (s->gzhead->hcrc) + strm->adler = crc32(strm->adler, s->pending_buf, + s->pending); + s->gzindex = 0; + s->status = EXTRA_STATE; + } + } + else +#endif + { + uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8; + uInt level_flags; + + if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2) + level_flags = 0; + else if (s->level < 6) + level_flags = 1; + else if (s->level == 6) + level_flags = 2; + else + level_flags = 3; + header |= (level_flags << 6); + if (s->strstart != 0) header |= PRESET_DICT; + header += 31 - (header % 31); + + s->status = BUSY_STATE; + putShortMSB(s, header); + + /* Save the adler32 of the preset dictionary: */ + if (s->strstart != 0) { + putShortMSB(s, (uInt)(strm->adler >> 16)); + putShortMSB(s, (uInt)(strm->adler & 0xffff)); + } + strm->adler = adler32(0L, Z_NULL, 0); + } + } +#ifdef GZIP + if (s->status == EXTRA_STATE) { + if (s->gzhead->extra != Z_NULL) { + uInt beg = s->pending; /* start of bytes to update crc */ + + while (s->gzindex < (s->gzhead->extra_len & 0xffff)) { + if (s->pending == s->pending_buf_size) { + if (s->gzhead->hcrc && s->pending > beg) + strm->adler = crc32(strm->adler, s->pending_buf + beg, + s->pending - beg); + flush_pending(strm); + beg = s->pending; + if (s->pending == s->pending_buf_size) + break; + } + put_byte(s, s->gzhead->extra[s->gzindex]); + s->gzindex++; + } + if (s->gzhead->hcrc && s->pending > beg) + strm->adler = crc32(strm->adler, s->pending_buf + beg, + s->pending - beg); + if (s->gzindex == s->gzhead->extra_len) { + s->gzindex = 0; + s->status = NAME_STATE; + } + } + else + s->status = NAME_STATE; + } + if (s->status == NAME_STATE) { + if (s->gzhead->name != Z_NULL) { + uInt beg = s->pending; /* start of bytes to update crc */ + int val; + + do { + if (s->pending == s->pending_buf_size) { + if (s->gzhead->hcrc && s->pending > beg) + strm->adler = crc32(strm->adler, s->pending_buf + beg, + s->pending - beg); + flush_pending(strm); + beg = s->pending; + if (s->pending == s->pending_buf_size) { + val = 1; + break; + } + } + val = s->gzhead->name[s->gzindex++]; + put_byte(s, val); + } while (val != 0); + if (s->gzhead->hcrc && s->pending > beg) + strm->adler = crc32(strm->adler, s->pending_buf + beg, + s->pending - beg); + if (val == 0) { + s->gzindex = 0; + s->status = COMMENT_STATE; + } + } + else + s->status = COMMENT_STATE; + } + if (s->status == COMMENT_STATE) { + if (s->gzhead->comment != Z_NULL) { + uInt beg = s->pending; /* start of bytes to update crc */ + int val; + + do { + if (s->pending == s->pending_buf_size) { + if (s->gzhead->hcrc && s->pending > beg) + strm->adler = crc32(strm->adler, s->pending_buf + beg, + s->pending - beg); + flush_pending(strm); + beg = s->pending; + if (s->pending == s->pending_buf_size) { + val = 1; + break; + } + } + val = s->gzhead->comment[s->gzindex++]; + put_byte(s, val); + } while (val != 0); + if (s->gzhead->hcrc && s->pending > beg) + strm->adler = crc32(strm->adler, s->pending_buf + beg, + s->pending - beg); + if (val == 0) + s->status = HCRC_STATE; + } + else + s->status = HCRC_STATE; + } + if (s->status == HCRC_STATE) { + if (s->gzhead->hcrc) { + if (s->pending + 2 > s->pending_buf_size) + flush_pending(strm); + if (s->pending + 2 <= s->pending_buf_size) { + put_byte(s, (Byte)(strm->adler & 0xff)); + put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); + strm->adler = crc32(0L, Z_NULL, 0); + s->status = BUSY_STATE; + } + } + else + s->status = BUSY_STATE; + } +#endif + + /* Flush as much pending output as possible */ + if (s->pending != 0) { + flush_pending(strm); + if (strm->avail_out == 0) { + /* Since avail_out is 0, deflate will be called again with + * more output space, but possibly with both pending and + * avail_in equal to zero. There won't be anything to do, + * but this is not an error situation so make sure we + * return OK instead of BUF_ERROR at next call of deflate: + */ + s->last_flush = -1; + return Z_OK; + } + + /* Make sure there is something to do and avoid duplicate consecutive + * flushes. For repeated and useless calls with Z_FINISH, we keep + * returning Z_STREAM_END instead of Z_BUF_ERROR. + */ + } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) && + flush != Z_FINISH) { + ERR_RETURN(strm, Z_BUF_ERROR); + } + + /* User must not provide more input after the first FINISH: */ + if (s->status == FINISH_STATE && strm->avail_in != 0) { + ERR_RETURN(strm, Z_BUF_ERROR); + } + + /* Start a new block or continue the current one. + */ + if (strm->avail_in != 0 || s->lookahead != 0 || + (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) { + block_state bstate; + + bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : + (s->strategy == Z_RLE ? deflate_rle(s, flush) : + (*(configuration_table[s->level].func))(s, flush)); + + if (bstate == finish_started || bstate == finish_done) { + s->status = FINISH_STATE; + } + if (bstate == need_more || bstate == finish_started) { + if (strm->avail_out == 0) { + s->last_flush = -1; /* avoid BUF_ERROR next call, see above */ + } + return Z_OK; + /* If flush != Z_NO_FLUSH && avail_out == 0, the next call + * of deflate should use the same flush parameter to make sure + * that the flush is complete. So we don't have to output an + * empty block here, this will be done at next call. This also + * ensures that for a very small output buffer, we emit at most + * one empty block. + */ + } + if (bstate == block_done) { + if (flush == Z_PARTIAL_FLUSH) { + _tr_align(s); + } else if (flush != Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */ + _tr_stored_block(s, (char*)0, 0L, 0); + /* For a full flush, this empty block will be recognized + * as a special marker by inflate_sync(). + */ + if (flush == Z_FULL_FLUSH) { + CLEAR_HASH(s); /* forget history */ + if (s->lookahead == 0) { + s->strstart = 0; + s->block_start = 0L; + s->insert = 0; + } + } + } + flush_pending(strm); + if (strm->avail_out == 0) { + s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */ + return Z_OK; + } + } + } + Assert(strm->avail_out > 0, "bug2"); + + if (flush != Z_FINISH) return Z_OK; + if (s->wrap <= 0) return Z_STREAM_END; + + /* Write the trailer */ +#ifdef GZIP + if (s->wrap == 2) { + put_byte(s, (Byte)(strm->adler & 0xff)); + put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); + put_byte(s, (Byte)((strm->adler >> 16) & 0xff)); + put_byte(s, (Byte)((strm->adler >> 24) & 0xff)); + put_byte(s, (Byte)(strm->total_in & 0xff)); + put_byte(s, (Byte)((strm->total_in >> 8) & 0xff)); + put_byte(s, (Byte)((strm->total_in >> 16) & 0xff)); + put_byte(s, (Byte)((strm->total_in >> 24) & 0xff)); + } + else +#endif + { + putShortMSB(s, (uInt)(strm->adler >> 16)); + putShortMSB(s, (uInt)(strm->adler & 0xffff)); + } + flush_pending(strm); + /* If avail_out is zero, the application will call deflate again + * to flush the rest. + */ + if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */ + return s->pending != 0 ? Z_OK : Z_STREAM_END; +} + +/* ========================================================================= */ +int ZEXPORT deflateEnd (strm) + z_streamp strm; +{ + int status; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + + status = strm->state->status; + if (status != INIT_STATE && + status != EXTRA_STATE && + status != NAME_STATE && + status != COMMENT_STATE && + status != HCRC_STATE && + status != BUSY_STATE && + status != FINISH_STATE) { + return Z_STREAM_ERROR; + } + + /* Deallocate in reverse order of allocations: */ + TRY_FREE(strm, strm->state->pending_buf); + TRY_FREE(strm, strm->state->head); + TRY_FREE(strm, strm->state->prev); + TRY_FREE(strm, strm->state->window); + + ZFREE(strm, strm->state); + strm->state = Z_NULL; + + return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK; +} + +/* ========================================================================= + * Copy the source state to the destination state. + * To simplify the source, this is not supported for 16-bit MSDOS (which + * doesn't have enough memory anyway to duplicate compression states). + */ +int ZEXPORT deflateCopy (dest, source) + z_streamp dest; + z_streamp source; +{ +#ifdef MAXSEG_64K + return Z_STREAM_ERROR; +#else + deflate_state *ds; + deflate_state *ss; + ushf *overlay; + + + if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) { + return Z_STREAM_ERROR; + } + + ss = source->state; + + zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream)); + + ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state)); + if (ds == Z_NULL) return Z_MEM_ERROR; + dest->state = (struct internal_state FAR *) ds; + zmemcpy((voidpf)ds, (voidpf)ss, sizeof(deflate_state)); + ds->strm = dest; + + ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte)); + ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos)); + ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos)); + overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2); + ds->pending_buf = (uchf *) overlay; + + if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL || + ds->pending_buf == Z_NULL) { + deflateEnd (dest); + return Z_MEM_ERROR; + } + /* following zmemcpy do not work for 16-bit MSDOS */ + zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte)); + zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos)); + zmemcpy((voidpf)ds->head, (voidpf)ss->head, ds->hash_size * sizeof(Pos)); + zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size); + + ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); + ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush); + ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize; + + ds->l_desc.dyn_tree = ds->dyn_ltree; + ds->d_desc.dyn_tree = ds->dyn_dtree; + ds->bl_desc.dyn_tree = ds->bl_tree; + + return Z_OK; +#endif /* MAXSEG_64K */ +} + +/* =========================================================================== + * Read a new buffer from the current input stream, update the adler32 + * and total number of bytes read. All deflate() input goes through + * this function so some applications may wish to modify it to avoid + * allocating a large strm->next_in buffer and copying from it. + * (See also flush_pending()). + */ +local int read_buf(strm, buf, size) + z_streamp strm; + Bytef *buf; + unsigned size; +{ + unsigned len = strm->avail_in; + + if (len > size) len = size; + if (len == 0) return 0; + + strm->avail_in -= len; + + zmemcpy(buf, strm->next_in, len); + if (strm->state->wrap == 1) { + strm->adler = adler32(strm->adler, buf, len); + } +#ifdef GZIP + else if (strm->state->wrap == 2) { + strm->adler = crc32(strm->adler, buf, len); + } +#endif + strm->next_in += len; + strm->total_in += len; + + return (int)len; +} + +/* =========================================================================== + * Initialize the "longest match" routines for a new zlib stream + */ +local void lm_init (s) + deflate_state *s; +{ + s->window_size = (ulg)2L*s->w_size; + + CLEAR_HASH(s); + + /* Set the default configuration parameters: + */ + s->max_lazy_match = configuration_table[s->level].max_lazy; + s->good_match = configuration_table[s->level].good_length; + s->nice_match = configuration_table[s->level].nice_length; + s->max_chain_length = configuration_table[s->level].max_chain; + + s->strstart = 0; + s->block_start = 0L; + s->lookahead = 0; + s->insert = 0; + s->match_length = s->prev_length = MIN_MATCH-1; + s->match_available = 0; + s->ins_h = 0; +#ifndef FASTEST +#ifdef ASMV + match_init(); /* initialize the asm code */ +#endif +#endif +} + +#ifndef FASTEST +/* =========================================================================== + * Set match_start to the longest match starting at the given string and + * return its length. Matches shorter or equal to prev_length are discarded, + * in which case the result is equal to prev_length and match_start is + * garbage. + * IN assertions: cur_match is the head of the hash chain for the current + * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 + * OUT assertion: the match length is not greater than s->lookahead. + */ +#ifndef ASMV +/* For 80x86 and 680x0, an optimized version will be provided in match.asm or + * match.S. The code will be functionally equivalent. + */ +local uInt longest_match(s, cur_match) + deflate_state *s; + IPos cur_match; /* current match */ +{ + unsigned chain_length = s->max_chain_length;/* max hash chain length */ + register Bytef *scan = s->window + s->strstart; /* current string */ + register Bytef *match; /* matched string */ + register int len; /* length of current match */ + int best_len = s->prev_length; /* best match length so far */ + int nice_match = s->nice_match; /* stop if match long enough */ + IPos limit = s->strstart > (IPos)MAX_DIST(s) ? + s->strstart - (IPos)MAX_DIST(s) : NIL; + /* Stop when cur_match becomes <= limit. To simplify the code, + * we prevent matches with the string of window index 0. + */ + Posf *prev = s->prev; + uInt wmask = s->w_mask; + +#ifdef UNALIGNED_OK + /* Compare two bytes at a time. Note: this is not always beneficial. + * Try with and without -DUNALIGNED_OK to check. + */ + register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1; + register ush scan_start = *(ushf*)scan; + register ush scan_end = *(ushf*)(scan+best_len-1); +#else + register Bytef *strend = s->window + s->strstart + MAX_MATCH; + register Byte scan_end1 = scan[best_len-1]; + register Byte scan_end = scan[best_len]; +#endif + + /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. + * It is easy to get rid of this optimization if necessary. + */ + Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); + + /* Do not waste too much time if we already have a good match: */ + if (s->prev_length >= s->good_match) { + chain_length >>= 2; + } + /* Do not look for matches beyond the end of the input. This is necessary + * to make deflate deterministic. + */ + if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; + + Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); + + do { + Assert(cur_match < s->strstart, "no future"); + match = s->window + cur_match; + + /* Skip to next match if the match length cannot increase + * or if the match length is less than 2. Note that the checks below + * for insufficient lookahead only occur occasionally for performance + * reasons. Therefore uninitialized memory will be accessed, and + * conditional jumps will be made that depend on those values. + * However the length of the match is limited to the lookahead, so + * the output of deflate is not affected by the uninitialized values. + */ +#if (defined(UNALIGNED_OK) && MAX_MATCH == 258) + /* This code assumes sizeof(unsigned short) == 2. Do not use + * UNALIGNED_OK if your compiler uses a different size. + */ + if (*(ushf*)(match+best_len-1) != scan_end || + *(ushf*)match != scan_start) continue; + + /* It is not necessary to compare scan[2] and match[2] since they are + * always equal when the other bytes match, given that the hash keys + * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at + * strstart+3, +5, ... up to strstart+257. We check for insufficient + * lookahead only every 4th comparison; the 128th check will be made + * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is + * necessary to put more guard bytes at the end of the window, or + * to check more often for insufficient lookahead. + */ + Assert(scan[2] == match[2], "scan[2]?"); + scan++, match++; + do { + } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) && + *(ushf*)(scan+=2) == *(ushf*)(match+=2) && + *(ushf*)(scan+=2) == *(ushf*)(match+=2) && + *(ushf*)(scan+=2) == *(ushf*)(match+=2) && + scan < strend); + /* The funny "do {}" generates better code on most compilers */ + + /* Here, scan <= window+strstart+257 */ + Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + if (*scan == *match) scan++; + + len = (MAX_MATCH - 1) - (int)(strend-scan); + scan = strend - (MAX_MATCH-1); + +#else /* UNALIGNED_OK */ + + if (match[best_len] != scan_end || + match[best_len-1] != scan_end1 || + *match != *scan || + *++match != scan[1]) continue; + + /* The check at best_len-1 can be removed because it will be made + * again later. (This heuristic is not always a win.) + * It is not necessary to compare scan[2] and match[2] since they + * are always equal when the other bytes match, given that + * the hash keys are equal and that HASH_BITS >= 8. + */ + scan += 2, match++; + Assert(*scan == *match, "match[2]?"); + + /* We check for insufficient lookahead only every 8th comparison; + * the 256th check will be made at strstart+258. + */ + do { + } while (*++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + scan < strend); + + Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + + len = MAX_MATCH - (int)(strend - scan); + scan = strend - MAX_MATCH; + +#endif /* UNALIGNED_OK */ + + if (len > best_len) { + s->match_start = cur_match; + best_len = len; + if (len >= nice_match) break; +#ifdef UNALIGNED_OK + scan_end = *(ushf*)(scan+best_len-1); +#else + scan_end1 = scan[best_len-1]; + scan_end = scan[best_len]; +#endif + } + } while ((cur_match = prev[cur_match & wmask]) > limit + && --chain_length != 0); + + if ((uInt)best_len <= s->lookahead) return (uInt)best_len; + return s->lookahead; +} +#endif /* ASMV */ + +#else /* FASTEST */ + +/* --------------------------------------------------------------------------- + * Optimized version for FASTEST only + */ +local uInt longest_match(s, cur_match) + deflate_state *s; + IPos cur_match; /* current match */ +{ + register Bytef *scan = s->window + s->strstart; /* current string */ + register Bytef *match; /* matched string */ + register int len; /* length of current match */ + register Bytef *strend = s->window + s->strstart + MAX_MATCH; + + /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. + * It is easy to get rid of this optimization if necessary. + */ + Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); + + Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); + + Assert(cur_match < s->strstart, "no future"); + + match = s->window + cur_match; + + /* Return failure if the match length is less than 2: + */ + if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1; + + /* The check at best_len-1 can be removed because it will be made + * again later. (This heuristic is not always a win.) + * It is not necessary to compare scan[2] and match[2] since they + * are always equal when the other bytes match, given that + * the hash keys are equal and that HASH_BITS >= 8. + */ + scan += 2, match += 2; + Assert(*scan == *match, "match[2]?"); + + /* We check for insufficient lookahead only every 8th comparison; + * the 256th check will be made at strstart+258. + */ + do { + } while (*++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + scan < strend); + + Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + + len = MAX_MATCH - (int)(strend - scan); + + if (len < MIN_MATCH) return MIN_MATCH - 1; + + s->match_start = cur_match; + return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead; +} + +#endif /* FASTEST */ + +#ifdef DEBUG +/* =========================================================================== + * Check that the match at match_start is indeed a match. + */ +local void check_match(s, start, match, length) + deflate_state *s; + IPos start, match; + int length; +{ + /* check that the match is indeed a match */ + if (zmemcmp(s->window + match, + s->window + start, length) != EQUAL) { + fprintf(stderr, " start %u, match %u, length %d\n", + start, match, length); + do { + fprintf(stderr, "%c%c", s->window[match++], s->window[start++]); + } while (--length != 0); + z_error("invalid match"); + } + if (z_verbose > 1) { + fprintf(stderr,"\\[%d,%d]", start-match, length); + do { putc(s->window[start++], stderr); } while (--length != 0); + } +} +#else +# define check_match(s, start, match, length) +#endif /* DEBUG */ + +/* =========================================================================== + * Fill the window when the lookahead becomes insufficient. + * Updates strstart and lookahead. + * + * IN assertion: lookahead < MIN_LOOKAHEAD + * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD + * At least one byte has been read, or avail_in == 0; reads are + * performed for at least two bytes (required for the zip translate_eol + * option -- not supported here). + */ +local void fill_window(s) + deflate_state *s; +{ + register unsigned n, m; + register Posf *p; + unsigned more; /* Amount of free space at the end of the window. */ + uInt wsize = s->w_size; + + Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead"); + + do { + more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); + + /* Deal with !@#$% 64K limit: */ + if (sizeof(int) <= 2) { + if (more == 0 && s->strstart == 0 && s->lookahead == 0) { + more = wsize; + + } else if (more == (unsigned)(-1)) { + /* Very unlikely, but possible on 16 bit machine if + * strstart == 0 && lookahead == 1 (input done a byte at time) + */ + more--; + } + } + + /* If the window is almost full and there is insufficient lookahead, + * move the upper half to the lower one to make room in the upper half. + */ + if (s->strstart >= wsize+MAX_DIST(s)) { + + zmemcpy(s->window, s->window+wsize, (unsigned)wsize); + s->match_start -= wsize; + s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ + s->block_start -= (int) wsize; + + /* Slide the hash table (could be avoided with 32 bit values + at the expense of memory usage). We slide even when level == 0 + to keep the hash table consistent if we switch back to level > 0 + later. (Using level 0 permanently is not an optimal usage of + zlib, so we don't care about this pathological case.) + */ + n = s->hash_size; + p = &s->head[n]; + do { + m = *--p; + *p = (Pos)(m >= wsize ? m-wsize : NIL); + } while (--n); + + n = wsize; +#ifndef FASTEST + p = &s->prev[n]; + do { + m = *--p; + *p = (Pos)(m >= wsize ? m-wsize : NIL); + /* If n is not on any hash chain, prev[n] is garbage but + * its value will never be used. + */ + } while (--n); +#endif + more += wsize; + } + if (s->strm->avail_in == 0) break; + + /* If there was no sliding: + * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && + * more == window_size - lookahead - strstart + * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) + * => more >= window_size - 2*WSIZE + 2 + * In the BIG_MEM or MMAP case (not yet supported), + * window_size == input_size + MIN_LOOKAHEAD && + * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. + * Otherwise, window_size == 2*WSIZE so more >= 2. + * If there was sliding, more >= WSIZE. So in all cases, more >= 2. + */ + Assert(more >= 2, "more < 2"); + + n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more); + s->lookahead += n; + + /* Initialize the hash value now that we have some input: */ + if (s->lookahead + s->insert >= MIN_MATCH) { + uInt str = s->strstart - s->insert; + s->ins_h = s->window[str]; + UPDATE_HASH(s, s->ins_h, s->window[str + 1]); +#if MIN_MATCH != 3 + Call UPDATE_HASH() MIN_MATCH-3 more times +#endif + while (s->insert) { + UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); +#ifndef FASTEST + s->prev[str & s->w_mask] = s->head[s->ins_h]; +#endif + s->head[s->ins_h] = (Pos)str; + str++; + s->insert--; + if (s->lookahead + s->insert < MIN_MATCH) + break; + } + } + /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, + * but this is not important since only literal bytes will be emitted. + */ + + } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); + + /* If the WIN_INIT bytes after the end of the current data have never been + * written, then zero those bytes in order to avoid memory check reports of + * the use of uninitialized (or uninitialised as Julian writes) bytes by + * the longest match routines. Update the high water mark for the next + * time through here. WIN_INIT is set to MAX_MATCH since the longest match + * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. + */ + if (s->high_water < s->window_size) { + ulg curr = s->strstart + (ulg)(s->lookahead); + ulg init; + + if (s->high_water < curr) { + /* Previous high water mark below current data -- zero WIN_INIT + * bytes or up to end of window, whichever is less. + */ + init = s->window_size - curr; + if (init > WIN_INIT) + init = WIN_INIT; + zmemzero(s->window + curr, (unsigned)init); + s->high_water = curr + init; + } + else if (s->high_water < (ulg)curr + WIN_INIT) { + /* High water mark at or above current data, but below current data + * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up + * to end of window, whichever is less. + */ + init = (ulg)curr + WIN_INIT - s->high_water; + if (init > s->window_size - s->high_water) + init = s->window_size - s->high_water; + zmemzero(s->window + s->high_water, (unsigned)init); + s->high_water += init; + } + } + + Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, + "not enough room for search"); +} + +/* =========================================================================== + * Flush the current block, with given end-of-file flag. + * IN assertion: strstart is set to the end of the current match. + */ +#define FLUSH_BLOCK_ONLY(s, last) { \ + _tr_flush_block(s, (s->block_start >= 0L ? \ + (charf *)&s->window[(unsigned)s->block_start] : \ + (charf *)Z_NULL), \ + (ulg)((int)s->strstart - s->block_start), \ + (last)); \ + s->block_start = s->strstart; \ + flush_pending(s->strm); \ + Tracev((stderr,"[FLUSH]")); \ +} + +/* Same but force premature exit if necessary. */ +#define FLUSH_BLOCK(s, last) { \ + FLUSH_BLOCK_ONLY(s, last); \ + if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \ +} + +/* =========================================================================== + * Copy without compression as much as possible from the input stream, return + * the current block state. + * This function does not insert new strings in the dictionary since + * uncompressible data is probably not useful. This function is used + * only for the level=0 compression option. + * NOTE: this function should be optimized to avoid extra copying from + * window to pending_buf. + */ +local block_state deflate_stored(s, flush) + deflate_state *s; + int flush; +{ + /* Stored blocks are limited to 0xffff bytes, pending_buf is limited + * to pending_buf_size, and each stored block has a 5 byte header: + */ + ulg max_block_size = 0xffff; + ulg max_start; + + if (max_block_size > s->pending_buf_size - 5) { + max_block_size = s->pending_buf_size - 5; + } + + /* Copy as much as possible from input to output: */ + for (;;) { + /* Fill the window as much as possible: */ + if (s->lookahead <= 1) { + + Assert(s->strstart < s->w_size+MAX_DIST(s) || + s->block_start >= (int)s->w_size, "slide too late"); + + fill_window(s); + if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more; + + if (s->lookahead == 0) break; /* flush the current block */ + } + Assert(s->block_start >= 0L, "block gone"); + + s->strstart += s->lookahead; + s->lookahead = 0; + + /* Emit a stored block if pending_buf will be full: */ + max_start = s->block_start + max_block_size; + if (s->strstart == 0 || (ulg)s->strstart >= max_start) { + /* strstart == 0 is possible when wraparound on 16-bit machine */ + s->lookahead = (uInt)(s->strstart - max_start); + s->strstart = (uInt)max_start; + FLUSH_BLOCK(s, 0); + } + /* Flush if we may have to slide, otherwise block_start may become + * negative and the data will be gone: + */ + if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) { + FLUSH_BLOCK(s, 0); + } + } + s->insert = 0; + if (flush == Z_FINISH) { + FLUSH_BLOCK(s, 1); + return finish_done; + } + if ((int)s->strstart > s->block_start) + FLUSH_BLOCK(s, 0); + return block_done; +} + +/* =========================================================================== + * Compress as much as possible from the input stream, return the current + * block state. + * This function does not perform lazy evaluation of matches and inserts + * new strings in the dictionary only for unmatched strings or for short + * matches. It is used only for the fast compression options. + */ +local block_state deflate_fast(s, flush) + deflate_state *s; + int flush; +{ + IPos hash_head; /* head of the hash chain */ + int bflush; /* set if current block must be flushed */ + + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the next match, plus MIN_MATCH bytes to insert the + * string following the next match. + */ + if (s->lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { + return need_more; + } + if (s->lookahead == 0) break; /* flush the current block */ + } + + /* Insert the string window[strstart .. strstart+2] in the + * dictionary, and set hash_head to the head of the hash chain: + */ + hash_head = NIL; + if (s->lookahead >= MIN_MATCH) { + INSERT_STRING(s, s->strstart, hash_head); + } + + /* Find the longest match, discarding those <= prev_length. + * At this point we have always match_length < MIN_MATCH + */ + if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) { + /* To simplify the code, we prevent matches with the string + * of window index 0 (in particular we have to avoid a match + * of the string with itself at the start of the input file). + */ + s->match_length = longest_match (s, hash_head); + /* longest_match() sets match_start */ + } + if (s->match_length >= MIN_MATCH) { + check_match(s, s->strstart, s->match_start, s->match_length); + + _tr_tally_dist(s, s->strstart - s->match_start, + s->match_length - MIN_MATCH, bflush); + + s->lookahead -= s->match_length; + + /* Insert new strings in the hash table only if the match length + * is not too large. This saves time but degrades compression. + */ +#ifndef FASTEST + if (s->match_length <= s->max_insert_length && + s->lookahead >= MIN_MATCH) { + s->match_length--; /* string at strstart already in table */ + do { + s->strstart++; + INSERT_STRING(s, s->strstart, hash_head); + /* strstart never exceeds WSIZE-MAX_MATCH, so there are + * always MIN_MATCH bytes ahead. + */ + } while (--s->match_length != 0); + s->strstart++; + } else +#endif + { + s->strstart += s->match_length; + s->match_length = 0; + s->ins_h = s->window[s->strstart]; + UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); +#if MIN_MATCH != 3 + Call UPDATE_HASH() MIN_MATCH-3 more times +#endif + /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not + * matter since it will be recomputed at next deflate call. + */ + } + } else { + /* No match, output a literal byte */ + Tracevv((stderr,"%c", s->window[s->strstart])); + _tr_tally_lit (s, s->window[s->strstart], bflush); + s->lookahead--; + s->strstart++; + } + if (bflush) FLUSH_BLOCK(s, 0); + } + s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; + if (flush == Z_FINISH) { + FLUSH_BLOCK(s, 1); + return finish_done; + } + if (s->last_lit) + FLUSH_BLOCK(s, 0); + return block_done; +} + +#ifndef FASTEST +/* =========================================================================== + * Same as above, but achieves better compression. We use a lazy + * evaluation for matches: a match is finally adopted only if there is + * no better match at the next window position. + */ +local block_state deflate_slow(s, flush) + deflate_state *s; + int flush; +{ + IPos hash_head; /* head of hash chain */ + int bflush; /* set if current block must be flushed */ + + /* Process the input block. */ + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the next match, plus MIN_MATCH bytes to insert the + * string following the next match. + */ + if (s->lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { + return need_more; + } + if (s->lookahead == 0) break; /* flush the current block */ + } + + /* Insert the string window[strstart .. strstart+2] in the + * dictionary, and set hash_head to the head of the hash chain: + */ + hash_head = NIL; + if (s->lookahead >= MIN_MATCH) { + INSERT_STRING(s, s->strstart, hash_head); + } + + /* Find the longest match, discarding those <= prev_length. + */ + s->prev_length = s->match_length, s->prev_match = s->match_start; + s->match_length = MIN_MATCH-1; + + if (hash_head != NIL && s->prev_length < s->max_lazy_match && + s->strstart - hash_head <= MAX_DIST(s)) { + /* To simplify the code, we prevent matches with the string + * of window index 0 (in particular we have to avoid a match + * of the string with itself at the start of the input file). + */ + s->match_length = longest_match (s, hash_head); + /* longest_match() sets match_start */ + + if (s->match_length <= 5 && (s->strategy == Z_FILTERED +#if TOO_FAR <= 32767 + || (s->match_length == MIN_MATCH && + s->strstart - s->match_start > TOO_FAR) +#endif + )) { + + /* If prev_match is also MIN_MATCH, match_start is garbage + * but we will ignore the current match anyway. + */ + s->match_length = MIN_MATCH-1; + } + } + /* If there was a match at the previous step and the current + * match is not better, output the previous match: + */ + if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) { + uInt max_insert = s->strstart + s->lookahead - MIN_MATCH; + /* Do not insert strings in hash table beyond this. */ + + check_match(s, s->strstart-1, s->prev_match, s->prev_length); + + _tr_tally_dist(s, s->strstart -1 - s->prev_match, + s->prev_length - MIN_MATCH, bflush); + + /* Insert in hash table all strings up to the end of the match. + * strstart-1 and strstart are already inserted. If there is not + * enough lookahead, the last two strings are not inserted in + * the hash table. + */ + s->lookahead -= s->prev_length-1; + s->prev_length -= 2; + do { + if (++s->strstart <= max_insert) { + INSERT_STRING(s, s->strstart, hash_head); + } + } while (--s->prev_length != 0); + s->match_available = 0; + s->match_length = MIN_MATCH-1; + s->strstart++; + + if (bflush) FLUSH_BLOCK(s, 0); + + } else if (s->match_available) { + /* If there was no match at the previous position, output a + * single literal. If there was a match but the current match + * is longer, truncate the previous match to a single literal. + */ + Tracevv((stderr,"%c", s->window[s->strstart-1])); + _tr_tally_lit(s, s->window[s->strstart-1], bflush); + if (bflush) { + FLUSH_BLOCK_ONLY(s, 0); + } + s->strstart++; + s->lookahead--; + if (s->strm->avail_out == 0) return need_more; + } else { + /* There is no previous match to compare with, wait for + * the next step to decide. + */ + s->match_available = 1; + s->strstart++; + s->lookahead--; + } + } + Assert (flush != Z_NO_FLUSH, "no flush?"); + if (s->match_available) { + Tracevv((stderr,"%c", s->window[s->strstart-1])); + _tr_tally_lit(s, s->window[s->strstart-1], bflush); + s->match_available = 0; + } + s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; + if (flush == Z_FINISH) { + FLUSH_BLOCK(s, 1); + return finish_done; + } + if (s->last_lit) + FLUSH_BLOCK(s, 0); + return block_done; +} +#endif /* FASTEST */ + +/* =========================================================================== + * For Z_RLE, simply look for runs of bytes, generate matches only of distance + * one. Do not maintain a hash table. (It will be regenerated if this run of + * deflate switches away from Z_RLE.) + */ +local block_state deflate_rle(s, flush) + deflate_state *s; + int flush; +{ + int bflush; /* set if current block must be flushed */ + uInt prev; /* byte at distance one to match */ + Bytef *scan, *strend; /* scan goes up to strend for length of run */ + + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the longest run, plus one for the unrolled loop. + */ + if (s->lookahead <= MAX_MATCH) { + fill_window(s); + if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) { + return need_more; + } + if (s->lookahead == 0) break; /* flush the current block */ + } + + /* See how many times the previous byte repeats */ + s->match_length = 0; + if (s->lookahead >= MIN_MATCH && s->strstart > 0) { + scan = s->window + s->strstart - 1; + prev = *scan; + if (prev == *++scan && prev == *++scan && prev == *++scan) { + strend = s->window + s->strstart + MAX_MATCH; + do { + } while (prev == *++scan && prev == *++scan && + prev == *++scan && prev == *++scan && + prev == *++scan && prev == *++scan && + prev == *++scan && prev == *++scan && + scan < strend); + s->match_length = MAX_MATCH - (int)(strend - scan); + if (s->match_length > s->lookahead) + s->match_length = s->lookahead; + } + Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan"); + } + + /* Emit match if have run of MIN_MATCH or longer, else emit literal */ + if (s->match_length >= MIN_MATCH) { + check_match(s, s->strstart, s->strstart - 1, s->match_length); + + _tr_tally_dist(s, 1, s->match_length - MIN_MATCH, bflush); + + s->lookahead -= s->match_length; + s->strstart += s->match_length; + s->match_length = 0; + } else { + /* No match, output a literal byte */ + Tracevv((stderr,"%c", s->window[s->strstart])); + _tr_tally_lit (s, s->window[s->strstart], bflush); + s->lookahead--; + s->strstart++; + } + if (bflush) FLUSH_BLOCK(s, 0); + } + s->insert = 0; + if (flush == Z_FINISH) { + FLUSH_BLOCK(s, 1); + return finish_done; + } + if (s->last_lit) + FLUSH_BLOCK(s, 0); + return block_done; +} + +/* =========================================================================== + * For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table. + * (It will be regenerated if this run of deflate switches away from Huffman.) + */ +local block_state deflate_huff(s, flush) + deflate_state *s; + int flush; +{ + int bflush; /* set if current block must be flushed */ + + for (;;) { + /* Make sure that we have a literal to write. */ + if (s->lookahead == 0) { + fill_window(s); + if (s->lookahead == 0) { + if (flush == Z_NO_FLUSH) + return need_more; + break; /* flush the current block */ + } + } + + /* Output a literal byte */ + s->match_length = 0; + Tracevv((stderr,"%c", s->window[s->strstart])); + _tr_tally_lit (s, s->window[s->strstart], bflush); + s->lookahead--; + s->strstart++; + if (bflush) FLUSH_BLOCK(s, 0); + } + s->insert = 0; + if (flush == Z_FINISH) { + FLUSH_BLOCK(s, 1); + return finish_done; + } + if (s->last_lit) + FLUSH_BLOCK(s, 0); + return block_done; +} diff --git a/zlib/deflate.h b/zlib/deflate.h new file mode 100644 index 0000000..064b3ea --- /dev/null +++ b/zlib/deflate.h @@ -0,0 +1,346 @@ +/* deflate.h -- internal compression state + * Copyright (C) 1995-2012 Jean-loup Gailly + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +/* @(#) $Id$ */ + +#ifndef DEFLATE_H +#define DEFLATE_H + +#include "zutil.h" + +/* define NO_GZIP when compiling if you want to disable gzip header and + trailer creation by deflate(). NO_GZIP would be used to avoid linking in + the crc code when it is not needed. For shared libraries, gzip encoding + should be left enabled. */ +#ifndef NO_GZIP +# define GZIP +#endif + +/* =========================================================================== + * Internal compression state. + */ + +#define LENGTH_CODES 29 +/* number of length codes, not counting the special END_BLOCK code */ + +#define LITERALS 256 +/* number of literal bytes 0..255 */ + +#define L_CODES (LITERALS+1+LENGTH_CODES) +/* number of Literal or Length codes, including the END_BLOCK code */ + +#define D_CODES 30 +/* number of distance codes */ + +#define BL_CODES 19 +/* number of codes used to transfer the bit lengths */ + +#define HEAP_SIZE (2*L_CODES+1) +/* maximum heap size */ + +#define MAX_BITS 15 +/* All codes must not exceed MAX_BITS bits */ + +#define Buf_size 16 +/* size of bit buffer in bi_buf */ + +#define INIT_STATE 42 +#define EXTRA_STATE 69 +#define NAME_STATE 73 +#define COMMENT_STATE 91 +#define HCRC_STATE 103 +#define BUSY_STATE 113 +#define FINISH_STATE 666 +/* Stream status */ + + +/* Data structure describing a single value and its code string. */ +typedef struct ct_data_s { + union { + ush freq; /* frequency count */ + ush code; /* bit string */ + } fc; + union { + ush dad; /* father node in Huffman tree */ + ush len; /* length of bit string */ + } dl; +} FAR ct_data; + +#define Freq fc.freq +#define Code fc.code +#define Dad dl.dad +#define Len dl.len + +typedef struct static_tree_desc_s static_tree_desc; + +typedef struct tree_desc_s { + ct_data *dyn_tree; /* the dynamic tree */ + int max_code; /* largest code with non zero frequency */ + static_tree_desc *stat_desc; /* the corresponding static tree */ +} FAR tree_desc; + +typedef ush Pos; +typedef Pos FAR Posf; +typedef unsigned IPos; + +/* A Pos is an index in the character window. We use short instead of int to + * save space in the various tables. IPos is used only for parameter passing. + */ + +typedef struct internal_state { + z_streamp strm; /* pointer back to this zlib stream */ + int status; /* as the name implies */ + Bytef *pending_buf; /* output still pending */ + ulg pending_buf_size; /* size of pending_buf */ + Bytef *pending_out; /* next pending byte to output to the stream */ + uInt pending; /* nb of bytes in the pending buffer */ + int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ + gz_headerp gzhead; /* gzip header information to write */ + uInt gzindex; /* where in extra, name, or comment */ + Byte method; /* STORED (for zip only) or DEFLATED */ + int last_flush; /* value of flush param for previous deflate call */ + + /* used by deflate.c: */ + + uInt w_size; /* LZ77 window size (32K by default) */ + uInt w_bits; /* log2(w_size) (8..16) */ + uInt w_mask; /* w_size - 1 */ + + Bytef *window; + /* Sliding window. Input bytes are read into the second half of the window, + * and move to the first half later to keep a dictionary of at least wSize + * bytes. With this organization, matches are limited to a distance of + * wSize-MAX_MATCH bytes, but this ensures that IO is always + * performed with a length multiple of the block size. Also, it limits + * the window size to 64K, which is quite useful on MSDOS. + * To do: use the user input buffer as sliding window. + */ + + ulg window_size; + /* Actual size of window: 2*wSize, except when the user input buffer + * is directly used as sliding window. + */ + + Posf *prev; + /* Link to older string with same hash index. To limit the size of this + * array to 64K, this link is maintained only for the last 32K strings. + * An index in this array is thus a window index modulo 32K. + */ + + Posf *head; /* Heads of the hash chains or NIL. */ + + uInt ins_h; /* hash index of string to be inserted */ + uInt hash_size; /* number of elements in hash table */ + uInt hash_bits; /* log2(hash_size) */ + uInt hash_mask; /* hash_size-1 */ + + uInt hash_shift; + /* Number of bits by which ins_h must be shifted at each input + * step. It must be such that after MIN_MATCH steps, the oldest + * byte no longer takes part in the hash key, that is: + * hash_shift * MIN_MATCH >= hash_bits + */ + + int block_start; + /* Window position at the beginning of the current output block. Gets + * negative when the window is moved backwards. + */ + + uInt match_length; /* length of best match */ + IPos prev_match; /* previous match */ + int match_available; /* set if previous match exists */ + uInt strstart; /* start of string to insert */ + uInt match_start; /* start of matching string */ + uInt lookahead; /* number of valid bytes ahead in window */ + + uInt prev_length; + /* Length of the best match at previous step. Matches not greater than this + * are discarded. This is used in the lazy match evaluation. + */ + + uInt max_chain_length; + /* To speed up deflation, hash chains are never searched beyond this + * length. A higher limit improves compression ratio but degrades the + * speed. + */ + + uInt max_lazy_match; + /* Attempt to find a better match only when the current match is strictly + * smaller than this value. This mechanism is used only for compression + * levels >= 4. + */ +# define max_insert_length max_lazy_match + /* Insert new strings in the hash table only if the match length is not + * greater than this length. This saves time but degrades compression. + * max_insert_length is used only for compression levels <= 3. + */ + + int level; /* compression level (1..9) */ + int strategy; /* favor or force Huffman coding*/ + + uInt good_match; + /* Use a faster search when the previous match is longer than this */ + + int nice_match; /* Stop searching when current match exceeds this */ + + /* used by trees.c: */ + /* Didn't use ct_data typedef below to suppress compiler warning */ + struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ + struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ + struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ + + struct tree_desc_s l_desc; /* desc. for literal tree */ + struct tree_desc_s d_desc; /* desc. for distance tree */ + struct tree_desc_s bl_desc; /* desc. for bit length tree */ + + ush bl_count[MAX_BITS+1]; + /* number of codes at each bit length for an optimal tree */ + + int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ + int heap_len; /* number of elements in the heap */ + int heap_max; /* element of largest frequency */ + /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. + * The same heap array is used to build all trees. + */ + + uch depth[2*L_CODES+1]; + /* Depth of each subtree used as tie breaker for trees of equal frequency + */ + + uchf *l_buf; /* buffer for literals or lengths */ + + uInt lit_bufsize; + /* Size of match buffer for literals/lengths. There are 4 reasons for + * limiting lit_bufsize to 64K: + * - frequencies can be kept in 16 bit counters + * - if compression is not successful for the first block, all input + * data is still in the window so we can still emit a stored block even + * when input comes from standard input. (This can also be done for + * all blocks if lit_bufsize is not greater than 32K.) + * - if compression is not successful for a file smaller than 64K, we can + * even emit a stored file instead of a stored block (saving 5 bytes). + * This is applicable only for zip (not gzip or zlib). + * - creating new Huffman trees less frequently may not provide fast + * adaptation to changes in the input data statistics. (Take for + * example a binary file with poorly compressible code followed by + * a highly compressible string table.) Smaller buffer sizes give + * fast adaptation but have of course the overhead of transmitting + * trees more frequently. + * - I can't count above 4 + */ + + uInt last_lit; /* running index in l_buf */ + + ushf *d_buf; + /* Buffer for distances. To simplify the code, d_buf and l_buf have + * the same number of elements. To use different lengths, an extra flag + * array would be necessary. + */ + + ulg opt_len; /* bit length of current block with optimal trees */ + ulg static_len; /* bit length of current block with static trees */ + uInt matches; /* number of string matches in current block */ + uInt insert; /* bytes at end of window left to insert */ + +#ifdef DEBUG + ulg compressed_len; /* total bit length of compressed file mod 2^32 */ + ulg bits_sent; /* bit length of compressed data sent mod 2^32 */ +#endif + + ush bi_buf; + /* Output buffer. bits are inserted starting at the bottom (least + * significant bits). + */ + int bi_valid; + /* Number of valid bits in bi_buf. All bits above the last valid bit + * are always zero. + */ + + ulg high_water; + /* High water mark offset in window for initialized bytes -- bytes above + * this are set to zero in order to avoid memory check warnings when + * longest match routines access bytes past the input. This is then + * updated to the new high water mark. + */ + +} FAR deflate_state; + +/* Output a byte on the stream. + * IN assertion: there is enough room in pending_buf. + */ +#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);} + + +#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) +/* Minimum amount of lookahead, except at the end of the input file. + * See deflate.c for comments about the MIN_MATCH+1. + */ + +#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD) +/* In order to simplify the code, particularly on 16 bit machines, match + * distances are limited to MAX_DIST instead of WSIZE. + */ + +#define WIN_INIT MAX_MATCH +/* Number of bytes after end of data in window to initialize in order to avoid + memory checker errors from longest match routines */ + + /* in trees.c */ +void ZLIB_INTERNAL _tr_init OF((deflate_state *s)); +int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); +void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf, + ulg stored_len, int last)); +void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s)); +void ZLIB_INTERNAL _tr_align OF((deflate_state *s)); +void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf, + ulg stored_len, int last)); + +#define d_code(dist) \ + ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) +/* Mapping from a distance to a distance code. dist is the distance - 1 and + * must not have side effects. _dist_code[256] and _dist_code[257] are never + * used. + */ + +#ifndef DEBUG +/* Inline versions of _tr_tally for speed: */ + +#if defined(GEN_TREES_H) || !defined(STDC) + extern uch ZLIB_INTERNAL _length_code[]; + extern uch ZLIB_INTERNAL _dist_code[]; +#else + extern const uch ZLIB_INTERNAL _length_code[]; + extern const uch ZLIB_INTERNAL _dist_code[]; +#endif + +# define _tr_tally_lit(s, c, flush) \ + { uch cc = (c); \ + s->d_buf[s->last_lit] = 0; \ + s->l_buf[s->last_lit++] = cc; \ + s->dyn_ltree[cc].Freq++; \ + flush = (s->last_lit == s->lit_bufsize-1); \ + } +# define _tr_tally_dist(s, distance, length, flush) \ + { uch len = (length); \ + ush dist = (distance); \ + s->d_buf[s->last_lit] = dist; \ + s->l_buf[s->last_lit++] = len; \ + dist--; \ + s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ + s->dyn_dtree[d_code(dist)].Freq++; \ + flush = (s->last_lit == s->lit_bufsize-1); \ + } +#else +# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c) +# define _tr_tally_dist(s, distance, length, flush) \ + flush = _tr_tally(s, distance, length) +#endif + +#endif /* DEFLATE_H */ diff --git a/zlib/gzguts.h b/zlib/gzguts.h new file mode 100644 index 0000000..245a793 --- /dev/null +++ b/zlib/gzguts.h @@ -0,0 +1,198 @@ +/* gzguts.h -- zlib internal header definitions for gz* operations + * Copyright (C) 2004, 2005, 2010, 2011, 2012 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#ifdef _LARGEFILE64_SOURCE +# ifndef _LARGEFILE_SOURCE +# define _LARGEFILE_SOURCE 1 +# endif +# ifdef _FILE_OFFSET_BITS +# undef _FILE_OFFSET_BITS +# endif +#endif + +#ifdef HAVE_HIDDEN +# define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) +#else +# define ZLIB_INTERNAL +#endif + +//#include +#include "zlib.h" +#ifdef STDC +//# include +void *ZMEMCPY(void *dest, const void *src, int n); +void *ZMEMSET(void *s, int c, int n); +//# include +void *ZCALLOC(int nmemb, int size); +void *ZMALLOC(int size); +void free(void *ptr); +//# include +#endif +//#include + +#ifdef _WIN32 +# include +#endif + +#if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32) +# include +#endif + +#ifdef NO_DEFLATE /* for compatibility with old definition */ +# define NO_GZCOMPRESS +#endif + +#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550) +# ifndef HAVE_VSNPRINTF +# define HAVE_VSNPRINTF +# endif +#endif + +#if defined(__CYGWIN__) +# ifndef HAVE_VSNPRINTF +# define HAVE_VSNPRINTF +# endif +#endif + +#if defined(MSDOS) && defined(__BORLANDC__) && (BORLANDC > 0x410) +# ifndef HAVE_VSNPRINTF +# define HAVE_VSNPRINTF +# endif +#endif + +#ifndef HAVE_VSNPRINTF +# ifdef MSDOS +/* vsnprintf may exist on some MS-DOS compilers (DJGPP?), + but for now we just assume it doesn't. */ +# define NO_vsnprintf +# endif +# ifdef __TURBOC__ +# define NO_vsnprintf +# endif +# ifdef WIN32 +/* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */ +# if !defined(vsnprintf) && !defined(NO_vsnprintf) +# if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 ) +# define vsnprintf _vsnprintf +# endif +# endif +# endif +# ifdef __SASC +# define NO_vsnprintf +# endif +# ifdef VMS +# define NO_vsnprintf +# endif +# ifdef __OS400__ +# define NO_vsnprintf +# endif +# ifdef __MVS__ +# define NO_vsnprintf +# endif +#endif + +#ifndef local +# define local static +#endif +/* compile with -Dlocal if your debugger can't find static symbols */ + +/* gz* functions always use library allocation functions */ +#ifndef STDC + extern voidp malloc OF((uInt size)); + extern void free OF((voidpf ptr)); +#endif + +/* get errno and strerror definition */ +#if defined UNDER_CE +# include +# define zstrerror() gz_strwinerror((DWORD)GetLastError()) +#else +# ifndef NO_STRERROR +//# include +# define zstrerror() strerror(errno) +# else +# define zstrerror() "stdio error (consult errno)" +# endif +#endif + +/* provide prototypes for these when building zlib without LFS */ +#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0 + ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); + ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); + ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); + ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); +#endif + +/* default memLevel */ +#if MAX_MEM_LEVEL >= 8 +# define DEF_MEM_LEVEL 8 +#else +# define DEF_MEM_LEVEL MAX_MEM_LEVEL +#endif + +/* default i/o buffer size -- double this for output when reading */ +#define GZBUFSIZE 8192 + +/* gzip modes, also provide a little integrity check on the passed structure */ +#define GZ_NONE 0 +#define GZ_READ 7247 +#define GZ_WRITE 31153 +#define GZ_APPEND 1 /* mode set to GZ_WRITE after the file is opened */ + +/* values for gz_state how */ +#define LOOK 0 /* look for a gzip header */ +#define COPY 1 /* copy input directly */ +#define GZIP 2 /* decompress a gzip stream */ + +/* internal gzip file state data structure */ +typedef struct { + /* exposed contents for gzgetc() macro */ + struct gzFile_s x; /* "x" for exposed */ + /* x.have: number of bytes available at x.next */ + /* x.next: next output data to deliver or write */ + /* x.pos: current position in uncompressed data */ + /* used for both reading and writing */ + int mode; /* see gzip modes above */ + int fd; /* file descriptor */ + char *path; /* path or fd for error messages */ + unsigned size; /* buffer size, zero if not allocated yet */ + unsigned want; /* requested buffer size, default is GZBUFSIZE */ + unsigned char *in; /* input buffer */ + unsigned char *out; /* output buffer (double-sized when reading) */ + int direct; /* 0 if processing gzip, 1 if transparent */ + /* just for reading */ + int how; /* 0: get header, 1: copy, 2: decompress */ + z_off64_t start; /* where the gzip data started, for rewinding */ + int eof; /* true if end of input file reached */ + int past; /* true if read requested past end */ + /* just for writing */ + int level; /* compression level */ + int strategy; /* compression strategy */ + /* seek request */ + z_off64_t skip; /* amount to skip (already rewound if backwards) */ + int seek; /* true if seek request pending */ + /* error information */ + int err; /* error code */ + char *msg; /* error message */ + /* zlib inflate or deflate stream */ + z_stream strm; /* stream structure in-place (not a pointer) */ +} gz_state; +typedef gz_state FAR *gz_statep; + +/* shared functions */ +void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *)); +#if defined UNDER_CE +char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error)); +#endif + +/* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t + value -- needed when comparing unsigned to z_off64_t, which is signed + (possible z_off64_t types off_t, off64_t, and long are all signed) */ +#ifdef INT_MAX +# define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX) +#else +unsigned ZLIB_INTERNAL gz_intmax OF((void)); +# define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax()) +#endif diff --git a/zlib/inffast.c b/zlib/inffast.c new file mode 100644 index 0000000..900f2c2 --- /dev/null +++ b/zlib/inffast.c @@ -0,0 +1,340 @@ +/* inffast.c -- fast decoding + * Copyright (C) 1995-2008, 2010 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "zutil.h" +#include "inftrees.h" +#include "inflate.h" +#include "inffast.h" + +#ifndef ASMINF + +/* Allow machine dependent optimization for post-increment or pre-increment. + Based on testing to date, + Pre-increment preferred for: + - PowerPC G3 (Adler) + - MIPS R5000 (Randers-Pehrson) + Post-increment preferred for: + - none + No measurable difference: + - Pentium III (Anderson) + - M68060 (Nikl) + */ +#ifdef POSTINC +# define OFF 0 +# define PUP(a) *(a)++ +#else +# define OFF 1 +# define PUP(a) *++(a) +#endif + +/* + Decode literal, length, and distance codes and write out the resulting + literal and match bytes until either not enough input or output is + available, an end-of-block is encountered, or a data error is encountered. + When large enough input and output buffers are supplied to inflate(), for + example, a 16K input buffer and a 64K output buffer, more than 95% of the + inflate execution time is spent in this routine. + + Entry assumptions: + + state->mode == LEN + strm->avail_in >= 6 + strm->avail_out >= 258 + start >= strm->avail_out + state->bits < 8 + + On return, state->mode is one of: + + LEN -- ran out of enough output space or enough available input + TYPE -- reached end of block code, inflate() to interpret next block + BAD -- error in block data + + Notes: + + - The maximum input bits used by a length/distance pair is 15 bits for the + length code, 5 bits for the length extra, 15 bits for the distance code, + and 13 bits for the distance extra. This totals 48 bits, or six bytes. + Therefore if strm->avail_in >= 6, then there is enough input to avoid + checking for available input while decoding. + + - The maximum bytes that a single length/distance pair can output is 258 + bytes, which is the maximum length that can be coded. inflate_fast() + requires strm->avail_out >= 258 for each loop to avoid checking for + output space. + */ +void ZLIB_INTERNAL inflate_fast(strm, start) +z_streamp strm; +unsigned start; /* inflate()'s starting value for strm->avail_out */ +{ + struct inflate_state FAR *state; + unsigned char FAR *in; /* local strm->next_in */ + unsigned char FAR *last; /* while in < last, enough input available */ + unsigned char FAR *out; /* local strm->next_out */ + unsigned char FAR *beg; /* inflate()'s initial strm->next_out */ + unsigned char FAR *end; /* while out < end, enough space available */ +#ifdef INFLATE_STRICT + unsigned dmax; /* maximum distance from zlib header */ +#endif + unsigned wsize; /* window size or zero if not using window */ + unsigned whave; /* valid bytes in the window */ + unsigned wnext; /* window write index */ + unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */ + unsigned int hold; /* local strm->hold */ + unsigned bits; /* local strm->bits */ + code const FAR *lcode; /* local strm->lencode */ + code const FAR *dcode; /* local strm->distcode */ + unsigned lmask; /* mask for first level of length codes */ + unsigned dmask; /* mask for first level of distance codes */ + code here; /* retrieved table entry */ + unsigned op; /* code bits, operation, extra bits, or */ + /* window position, window bytes to copy */ + unsigned len; /* match length, unused bytes */ + unsigned dist; /* match distance */ + unsigned char FAR *from; /* where to copy match from */ + + /* copy state to local variables */ + state = (struct inflate_state FAR *)strm->state; + in = strm->next_in - OFF; + last = in + (strm->avail_in - 5); + out = strm->next_out - OFF; + beg = out - (start - strm->avail_out); + end = out + (strm->avail_out - 257); +#ifdef INFLATE_STRICT + dmax = state->dmax; +#endif + wsize = state->wsize; + whave = state->whave; + wnext = state->wnext; + window = state->window; + hold = state->hold; + bits = state->bits; + lcode = state->lencode; + dcode = state->distcode; + lmask = (1U << state->lenbits) - 1; + dmask = (1U << state->distbits) - 1; + + /* decode literals and length/distances until end-of-block or not enough + input data or output space */ + do { + if (bits < 15) { + hold += (unsigned int)(PUP(in)) << bits; + bits += 8; + hold += (unsigned int)(PUP(in)) << bits; + bits += 8; + } + here = lcode[hold & lmask]; + dolen: + op = (unsigned)(here.bits); + hold >>= op; + bits -= op; + op = (unsigned)(here.op); + if (op == 0) { /* literal */ + Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? + "inflate: literal '%c'\n" : + "inflate: literal 0x%02x\n", here.val)); + PUP(out) = (unsigned char)(here.val); + } + else if (op & 16) { /* length base */ + len = (unsigned)(here.val); + op &= 15; /* number of extra bits */ + if (op) { + if (bits < op) { + hold += (unsigned int)(PUP(in)) << bits; + bits += 8; + } + len += (unsigned)hold & ((1U << op) - 1); + hold >>= op; + bits -= op; + } + Tracevv((stderr, "inflate: length %u\n", len)); + if (bits < 15) { + hold += (unsigned int)(PUP(in)) << bits; + bits += 8; + hold += (unsigned int)(PUP(in)) << bits; + bits += 8; + } + here = dcode[hold & dmask]; + dodist: + op = (unsigned)(here.bits); + hold >>= op; + bits -= op; + op = (unsigned)(here.op); + if (op & 16) { /* distance base */ + dist = (unsigned)(here.val); + op &= 15; /* number of extra bits */ + if (bits < op) { + hold += (unsigned int)(PUP(in)) << bits; + bits += 8; + if (bits < op) { + hold += (unsigned int)(PUP(in)) << bits; + bits += 8; + } + } + dist += (unsigned)hold & ((1U << op) - 1); +#ifdef INFLATE_STRICT + if (dist > dmax) { + strm->msg = (char *)"invalid distance too far back"; + state->mode = BAD; + break; + } +#endif + hold >>= op; + bits -= op; + Tracevv((stderr, "inflate: distance %u\n", dist)); + op = (unsigned)(out - beg); /* max distance in output */ + if (dist > op) { /* see if copy from window */ + op = dist - op; /* distance back in window */ + if (op > whave) { + if (state->sane) { + strm->msg = + (char *)"invalid distance too far back"; + state->mode = BAD; + break; + } +#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR + if (len <= op - whave) { + do { + PUP(out) = 0; + } while (--len); + continue; + } + len -= op - whave; + do { + PUP(out) = 0; + } while (--op > whave); + if (op == 0) { + from = out - dist; + do { + PUP(out) = PUP(from); + } while (--len); + continue; + } +#endif + } + from = window - OFF; + if (wnext == 0) { /* very common case */ + from += wsize - op; + if (op < len) { /* some from window */ + len -= op; + do { + PUP(out) = PUP(from); + } while (--op); + from = out - dist; /* rest from output */ + } + } + else if (wnext < op) { /* wrap around window */ + from += wsize + wnext - op; + op -= wnext; + if (op < len) { /* some from end of window */ + len -= op; + do { + PUP(out) = PUP(from); + } while (--op); + from = window - OFF; + if (wnext < len) { /* some from start of window */ + op = wnext; + len -= op; + do { + PUP(out) = PUP(from); + } while (--op); + from = out - dist; /* rest from output */ + } + } + } + else { /* contiguous in window */ + from += wnext - op; + if (op < len) { /* some from window */ + len -= op; + do { + PUP(out) = PUP(from); + } while (--op); + from = out - dist; /* rest from output */ + } + } + while (len > 2) { + PUP(out) = PUP(from); + PUP(out) = PUP(from); + PUP(out) = PUP(from); + len -= 3; + } + if (len) { + PUP(out) = PUP(from); + if (len > 1) + PUP(out) = PUP(from); + } + } + else { + from = out - dist; /* copy direct from output */ + do { /* minimum length is three */ + PUP(out) = PUP(from); + PUP(out) = PUP(from); + PUP(out) = PUP(from); + len -= 3; + } while (len > 2); + if (len) { + PUP(out) = PUP(from); + if (len > 1) + PUP(out) = PUP(from); + } + } + } + else if ((op & 64) == 0) { /* 2nd level distance code */ + here = dcode[here.val + (hold & ((1U << op) - 1))]; + goto dodist; + } + else { + strm->msg = (char *)"invalid distance code"; + state->mode = BAD; + break; + } + } + else if ((op & 64) == 0) { /* 2nd level length code */ + here = lcode[here.val + (hold & ((1U << op) - 1))]; + goto dolen; + } + else if (op & 32) { /* end-of-block */ + Tracevv((stderr, "inflate: end of block\n")); + state->mode = TYPE; + break; + } + else { + strm->msg = (char *)"invalid literal/length code"; + state->mode = BAD; + break; + } + } while (in < last && out < end); + + /* return unused bytes (on entry, bits < 8, so in won't go too far back) */ + len = bits >> 3; + in -= len; + bits -= len << 3; + hold &= (1U << bits) - 1; + + /* update state and return */ + strm->next_in = in + OFF; + strm->next_out = out + OFF; + strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last)); + strm->avail_out = (unsigned)(out < end ? + 257 + (end - out) : 257 - (out - end)); + state->hold = hold; + state->bits = bits; + return; +} + +/* + inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe): + - Using bit fields for code structure + - Different op definition to avoid & for extra bits (do & for table bits) + - Three separate decoding do-loops for direct, window, and wnext == 0 + - Special case for distance > 1 copies to do overlapped load and store copy + - Explicit branch predictions (based on measured branch probabilities) + - Deferring match copy and interspersed it with decoding subsequent codes + - Swapping literal/length else + - Swapping window/direct else + - Larger unrolled copy loops (three is about right) + - Moving len -= 3 statement into middle of loop + */ + +#endif /* !ASMINF */ diff --git a/zlib/inffast.h b/zlib/inffast.h new file mode 100644 index 0000000..e5c1aa4 --- /dev/null +++ b/zlib/inffast.h @@ -0,0 +1,11 @@ +/* inffast.h -- header to use inffast.c + * Copyright (C) 1995-2003, 2010 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start)); diff --git a/zlib/inffixed.h b/zlib/inffixed.h new file mode 100644 index 0000000..d628327 --- /dev/null +++ b/zlib/inffixed.h @@ -0,0 +1,94 @@ + /* inffixed.h -- table for decoding fixed codes + * Generated automatically by makefixed(). + */ + + /* WARNING: this file should *not* be used by applications. + It is part of the implementation of this library and is + subject to change. Applications should only use zlib.h. + */ + + static const code lenfix[512] = { + {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48}, + {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128}, + {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59}, + {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176}, + {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20}, + {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100}, + {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8}, + {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216}, + {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76}, + {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114}, + {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2}, + {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148}, + {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42}, + {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86}, + {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15}, + {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236}, + {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62}, + {0,9,220},{18,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,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31}, + {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162}, + {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25}, + {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105}, + {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4}, + {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202}, + {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69}, + {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125}, + {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13}, + {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195}, + {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35}, + {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91}, + {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19}, + {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246}, + {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55}, + {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135}, + {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99}, + {0,8,127},{0,8,63},{0,9,222},{18,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,0},{0,8,80},{0,8,16}, + {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96}, + {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6}, + {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209}, + {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72}, + {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116}, + {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4}, + {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153}, + {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44}, + {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82}, + {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11}, + {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229}, + {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58}, + {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138}, + {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51}, + {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173}, + {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30}, + {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,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,0}, + {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195}, + {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65}, + {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121}, + {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9}, + {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258}, + {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37}, + {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93}, + {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23}, + {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251}, + {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51}, + {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131}, + {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67}, + {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183}, + {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23}, + {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103}, + {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9}, + {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223}, + {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79}, + {0,9,255} + }; + + static const code distfix[32] = { + {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025}, + {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193}, + {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385}, + {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577}, + {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073}, + {22,5,193},{64,5,0} + }; diff --git a/zlib/inflate.c b/zlib/inflate.c new file mode 100644 index 0000000..de5812f --- /dev/null +++ b/zlib/inflate.c @@ -0,0 +1,1496 @@ +/* inflate.c -- zlib decompression + * Copyright (C) 1995-2012 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* + * Change history: + * + * 1.2.beta0 24 Nov 2002 + * - First version -- complete rewrite of inflate to simplify code, avoid + * creation of window when not needed, minimize use of window when it is + * needed, make inffast.c even faster, implement gzip decoding, and to + * improve code readability and style over the previous zlib inflate code + * + * 1.2.beta1 25 Nov 2002 + * - Use pointers for available input and output checking in inffast.c + * - Remove input and output counters in inffast.c + * - Change inffast.c entry and loop from avail_in >= 7 to >= 6 + * - Remove unnecessary second byte pull from length extra in inffast.c + * - Unroll direct copy to three copies per loop in inffast.c + * + * 1.2.beta2 4 Dec 2002 + * - Change external routine names to reduce potential conflicts + * - Correct filename to inffixed.h for fixed tables in inflate.c + * - Make hbuf[] unsigned char to match parameter type in inflate.c + * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset) + * to avoid negation problem on Alphas (64 bit) in inflate.c + * + * 1.2.beta3 22 Dec 2002 + * - Add comments on state->bits assertion in inffast.c + * - Add comments on op field in inftrees.h + * - Fix bug in reuse of allocated window after inflateReset() + * - Remove bit fields--back to byte structure for speed + * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths + * - Change post-increments to pre-increments in inflate_fast(), PPC biased? + * - Add compile time option, POSTINC, to use post-increments instead (Intel?) + * - Make MATCH copy in inflate() much faster for when inflate_fast() not used + * - Use local copies of stream next and avail values, as well as local bit + * buffer and bit count in inflate()--for speed when inflate_fast() not used + * + * 1.2.beta4 1 Jan 2003 + * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings + * - Move a comment on output buffer sizes from inffast.c to inflate.c + * - Add comments in inffast.c to introduce the inflate_fast() routine + * - Rearrange window copies in inflate_fast() for speed and simplification + * - Unroll last copy for window match in inflate_fast() + * - Use local copies of window variables in inflate_fast() for speed + * - Pull out common wnext == 0 case for speed in inflate_fast() + * - Make op and len in inflate_fast() unsigned for consistency + * - Add FAR to lcode and dcode declarations in inflate_fast() + * - Simplified bad distance check in inflate_fast() + * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new + * source file infback.c to provide a call-back interface to inflate for + * programs like gzip and unzip -- uses window as output buffer to avoid + * window copying + * + * 1.2.beta5 1 Jan 2003 + * - Improved inflateBack() interface to allow the caller to provide initial + * input in strm. + * - Fixed stored blocks bug in inflateBack() + * + * 1.2.beta6 4 Jan 2003 + * - Added comments in inffast.c on effectiveness of POSTINC + * - Typecasting all around to reduce compiler warnings + * - Changed loops from while (1) or do {} while (1) to for (;;), again to + * make compilers happy + * - Changed type of window in inflateBackInit() to unsigned char * + * + * 1.2.beta7 27 Jan 2003 + * - Changed many types to unsigned or unsigned short to avoid warnings + * - Added inflateCopy() function + * + * 1.2.0 9 Mar 2003 + * - Changed inflateBack() interface to provide separate opaque descriptors + * for the in() and out() functions + * - Changed inflateBack() argument and in_func typedef to swap the length + * and buffer address return values for the input function + * - Check next_in and next_out for Z_NULL on entry to inflate() + * + * The history for versions after 1.2.0 are in ChangeLog in zlib distribution. + */ + +#include "zutil.h" +#include "inftrees.h" +#include "inflate.h" +#include "inffast.h" + +#ifdef MAKEFIXED +# ifndef BUILDFIXED +# define BUILDFIXED +# endif +#endif + +/* function prototypes */ +local void fixedtables OF((struct inflate_state FAR *state)); +local int updatewindow OF((z_streamp strm, unsigned out)); +#ifdef BUILDFIXED + void makefixed OF((void)); +#endif +local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf, + unsigned len)); + +int ZEXPORT inflateResetKeep(strm) +z_streamp strm; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + strm->total_in = strm->total_out = state->total = 0; + strm->msg = Z_NULL; + if (state->wrap) /* to support ill-conceived Java test suite */ + strm->adler = state->wrap & 1; + state->mode = HEAD; + state->last = 0; + state->havedict = 0; + state->dmax = 32768U; + state->head = Z_NULL; + state->hold = 0; + state->bits = 0; + state->lencode = state->distcode = state->next = state->codes; + state->sane = 1; + state->back = -1; + Tracev((stderr, "inflate: reset\n")); + return Z_OK; +} + +int ZEXPORT inflateReset(strm) +z_streamp strm; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + state->wsize = 0; + state->whave = 0; + state->wnext = 0; + return inflateResetKeep(strm); +} + +int ZEXPORT inflateReset2(strm, windowBits) +z_streamp strm; +int windowBits; +{ + int wrap; + struct inflate_state FAR *state; + + /* get the state */ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + + /* extract wrap request from windowBits parameter */ + if (windowBits < 0) { + wrap = 0; + windowBits = -windowBits; + } + else { + wrap = (windowBits >> 4) + 1; +#ifdef GUNZIP + if (windowBits < 48) + windowBits &= 15; +#endif + } + + /* set number of window bits, free window if different */ + if (windowBits && (windowBits < 8 || windowBits > 15)) + return Z_STREAM_ERROR; + if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) { + ZFREE(strm, state->window); + state->window = Z_NULL; + } + + /* update state and reset the rest of it */ + state->wrap = wrap; + state->wbits = (unsigned)windowBits; + return inflateReset(strm); +} + +int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size) +z_streamp strm; +int windowBits; +const char *version; +int stream_size; +{ + int ret; + struct inflate_state FAR *state; + + if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || + stream_size != (int)(sizeof(z_stream))) + return Z_VERSION_ERROR; + if (strm == Z_NULL) return Z_STREAM_ERROR; + strm->msg = Z_NULL; /* in case we return an error */ + if (strm->zalloc == (alloc_func)0) { +#ifdef Z_SOLO + return Z_STREAM_ERROR; +#else + strm->zalloc = zcalloc; + strm->opaque = (voidpf)0; +#endif + } + if (strm->zfree == (free_func)0) +#ifdef Z_SOLO + return Z_STREAM_ERROR; +#else + strm->zfree = zcfree; +#endif + state = (struct inflate_state FAR *) + ZALLOC(strm, 1, sizeof(struct inflate_state)); + if (state == Z_NULL) return Z_MEM_ERROR; + Tracev((stderr, "inflate: allocated\n")); + strm->state = (struct internal_state FAR *)state; + state->window = Z_NULL; + ret = inflateReset2(strm, windowBits); + if (ret != Z_OK) { + ZFREE(strm, state); + strm->state = Z_NULL; + } + return ret; +} + +int ZEXPORT inflateInit_(strm, version, stream_size) +z_streamp strm; +const char *version; +int stream_size; +{ + return inflateInit2_(strm, DEF_WBITS, version, stream_size); +} + +int ZEXPORT inflatePrime(strm, bits, value) +z_streamp strm; +int bits; +int value; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (bits < 0) { + state->hold = 0; + state->bits = 0; + return Z_OK; + } + if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR; + value &= (1L << bits) - 1; + state->hold += value << state->bits; + state->bits += bits; + return Z_OK; +} + +/* + Return state with length and distance decoding tables and index sizes set to + fixed code decoding. Normally this returns fixed tables from inffixed.h. + If BUILDFIXED is defined, then instead this routine builds the tables the + first time it's called, and returns those tables the first time and + thereafter. This reduces the size of the code by about 2K bytes, in + exchange for a little execution time. However, BUILDFIXED should not be + used for threaded applications, since the rewriting of the tables and virgin + may not be thread-safe. + */ +local void fixedtables(state) +struct inflate_state FAR *state; +{ +#ifdef BUILDFIXED + static int virgin = 1; + static code *lenfix, *distfix; + static code fixed[544]; + + /* build fixed huffman tables if first call (may not be thread safe) */ + if (virgin) { + unsigned sym, bits; + static code *next; + + /* literal/length table */ + sym = 0; + while (sym < 144) state->lens[sym++] = 8; + while (sym < 256) state->lens[sym++] = 9; + while (sym < 280) state->lens[sym++] = 7; + while (sym < 288) state->lens[sym++] = 8; + next = fixed; + lenfix = next; + bits = 9; + inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); + + /* distance table */ + sym = 0; + while (sym < 32) state->lens[sym++] = 5; + distfix = next; + bits = 5; + inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); + + /* do this just once */ + virgin = 0; + } +#else /* !BUILDFIXED */ +# include "inffixed.h" +#endif /* BUILDFIXED */ + state->lencode = lenfix; + state->lenbits = 9; + state->distcode = distfix; + state->distbits = 5; +} + +#ifdef MAKEFIXED +#include + +/* + Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also + defines BUILDFIXED, so the tables are built on the fly. makefixed() writes + those tables to stdout, which would be piped to inffixed.h. A small program + can simply call makefixed to do this: + + void makefixed(void); + + int main(void) + { + makefixed(); + return 0; + } + + Then that can be linked with zlib built with MAKEFIXED defined and run: + + a.out > inffixed.h + */ +void makefixed() +{ + unsigned low, size; + struct inflate_state state; + + fixedtables(&state); + puts(" /* inffixed.h -- table for decoding fixed codes"); + puts(" * Generated automatically by makefixed()."); + puts(" */"); + puts(""); + puts(" /* WARNING: this file should *not* be used by applications."); + puts(" It is part of the implementation of this library and is"); + puts(" subject to change. Applications should only use zlib.h."); + puts(" */"); + puts(""); + size = 1U << 9; + printf(" static const code lenfix[%u] = {", size); + low = 0; + for (;;) { + if ((low % 7) == 0) printf("\n "); + printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op, + state.lencode[low].bits, state.lencode[low].val); + if (++low == size) break; + putchar(','); + } + puts("\n };"); + size = 1U << 5; + printf("\n static const code distfix[%u] = {", size); + low = 0; + for (;;) { + if ((low % 6) == 0) printf("\n "); + printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits, + state.distcode[low].val); + if (++low == size) break; + putchar(','); + } + puts("\n };"); +} +#endif /* MAKEFIXED */ + +/* + Update the window with the last wsize (normally 32K) bytes written before + returning. If window does not exist yet, create it. This is only called + when a window is already in use, or when output has been written during this + inflate call, but the end of the deflate stream has not been reached yet. + It is also called to create a window for dictionary data when a dictionary + is loaded. + + Providing output buffers larger than 32K to inflate() should provide a speed + advantage, since only the last 32K of output is copied to the sliding window + upon return from inflate(), and since all distances after the first 32K of + output will fall in the output data, making match copies simpler and faster. + The advantage may be dependent on the size of the processor's data caches. + */ +local int updatewindow(strm, out) +z_streamp strm; +unsigned out; +{ + struct inflate_state FAR *state; + unsigned copy, dist; + + state = (struct inflate_state FAR *)strm->state; + + /* if it hasn't been done already, allocate space for the window */ + if (state->window == Z_NULL) { + state->window = (unsigned char FAR *) + ZALLOC(strm, 1U << state->wbits, + sizeof(unsigned char)); + if (state->window == Z_NULL) return 1; + } + + /* if window not in use yet, initialize */ + if (state->wsize == 0) { + state->wsize = 1U << state->wbits; + state->wnext = 0; + state->whave = 0; + } + + /* copy state->wsize or less output bytes into the circular window */ + copy = out - strm->avail_out; + if (copy >= state->wsize) { + zmemcpy(state->window, strm->next_out - state->wsize, state->wsize); + state->wnext = 0; + state->whave = state->wsize; + } + else { + dist = state->wsize - state->wnext; + if (dist > copy) dist = copy; + zmemcpy(state->window + state->wnext, strm->next_out - copy, dist); + copy -= dist; + if (copy) { + zmemcpy(state->window, strm->next_out - copy, copy); + state->wnext = copy; + state->whave = state->wsize; + } + else { + state->wnext += dist; + if (state->wnext == state->wsize) state->wnext = 0; + if (state->whave < state->wsize) state->whave += dist; + } + } + return 0; +} + +/* Macros for inflate(): */ + +/* check function to use adler32() for zlib or crc32() for gzip */ +#ifdef GUNZIP +# define UPDATE(check, buf, len) \ + (state->flags ? crc32(check, buf, len) : adler32(check, buf, len)) +#else +# define UPDATE(check, buf, len) adler32(check, buf, len) +#endif + +/* check macros for header crc */ +#ifdef GUNZIP +# define CRC2(check, word) \ + do { \ + hbuf[0] = (unsigned char)(word); \ + hbuf[1] = (unsigned char)((word) >> 8); \ + check = crc32(check, hbuf, 2); \ + } while (0) + +# define CRC4(check, word) \ + do { \ + hbuf[0] = (unsigned char)(word); \ + hbuf[1] = (unsigned char)((word) >> 8); \ + hbuf[2] = (unsigned char)((word) >> 16); \ + hbuf[3] = (unsigned char)((word) >> 24); \ + check = crc32(check, hbuf, 4); \ + } while (0) +#endif + +/* Load registers with state in inflate() for speed */ +#define LOAD() \ + do { \ + put = strm->next_out; \ + left = strm->avail_out; \ + next = strm->next_in; \ + have = strm->avail_in; \ + hold = state->hold; \ + bits = state->bits; \ + } while (0) + +/* Restore state from registers in inflate() */ +#define RESTORE() \ + do { \ + strm->next_out = put; \ + strm->avail_out = left; \ + strm->next_in = next; \ + strm->avail_in = have; \ + state->hold = hold; \ + state->bits = bits; \ + } while (0) + +/* Clear the input bit accumulator */ +#define INITBITS() \ + do { \ + hold = 0; \ + bits = 0; \ + } while (0) + +/* Get a byte of input into the bit accumulator, or return from inflate() + if there is no input available. */ +#define PULLBYTE() \ + do { \ + if (have == 0) goto inf_leave; \ + have--; \ + hold += (unsigned int)(*next++) << bits; \ + bits += 8; \ + } while (0) + +/* Assure that there are at least n bits in the bit accumulator. If there is + not enough available input to do that, then return from inflate(). */ +#define NEEDBITS(n) \ + do { \ + while (bits < (unsigned)(n)) \ + PULLBYTE(); \ + } while (0) + +/* Return the low n bits of the bit accumulator (n < 16) */ +#define BITS(n) \ + ((unsigned)hold & ((1U << (n)) - 1)) + +/* Remove n bits from the bit accumulator */ +#define DROPBITS(n) \ + do { \ + hold >>= (n); \ + bits -= (unsigned)(n); \ + } while (0) + +/* Remove zero to seven bits as needed to go to a byte boundary */ +#define BYTEBITS() \ + do { \ + hold >>= bits & 7; \ + bits -= bits & 7; \ + } while (0) + +/* + inflate() uses a state machine to process as much input data and generate as + much output data as possible before returning. The state machine is + structured roughly as follows: + + for (;;) switch (state) { + ... + case STATEn: + if (not enough input data or output space to make progress) + return; + ... make progress ... + state = STATEm; + break; + ... + } + + so when inflate() is called again, the same case is attempted again, and + if the appropriate resources are provided, the machine proceeds to the + next state. The NEEDBITS() macro is usually the way the state evaluates + whether it can proceed or should return. NEEDBITS() does the return if + the requested bits are not available. The typical use of the BITS macros + is: + + NEEDBITS(n); + ... do something with BITS(n) ... + DROPBITS(n); + + where NEEDBITS(n) either returns from inflate() if there isn't enough + input left to load n bits into the accumulator, or it continues. BITS(n) + gives the low n bits in the accumulator. When done, DROPBITS(n) drops + the low n bits off the accumulator. INITBITS() clears the accumulator + and sets the number of available bits to zero. BYTEBITS() discards just + enough bits to put the accumulator on a byte boundary. After BYTEBITS() + and a NEEDBITS(8), then BITS(8) would return the next byte in the stream. + + NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return + if there is no input available. The decoding of variable length codes uses + PULLBYTE() directly in order to pull just enough bytes to decode the next + code, and no more. + + Some states loop until they get enough input, making sure that enough + state information is maintained to continue the loop where it left off + if NEEDBITS() returns in the loop. For example, want, need, and keep + would all have to actually be part of the saved state in case NEEDBITS() + returns: + + case STATEw: + while (want < need) { + NEEDBITS(n); + keep[want++] = BITS(n); + DROPBITS(n); + } + state = STATEx; + case STATEx: + + As shown above, if the next state is also the next case, then the break + is omitted. + + A state may also return if there is not enough output space available to + complete that state. Those states are copying stored data, writing a + literal byte, and copying a matching string. + + When returning, a "goto inf_leave" is used to update the total counters, + update the check value, and determine whether any progress has been made + during that inflate() call in order to return the proper return code. + Progress is defined as a change in either strm->avail_in or strm->avail_out. + When there is a window, goto inf_leave will update the window with the last + output written. If a goto inf_leave occurs in the middle of decompression + and there is no window currently, goto inf_leave will create one and copy + output to the window for the next call of inflate(). + + In this implementation, the flush parameter of inflate() only affects the + return code (per zlib.h). inflate() always writes as much as possible to + strm->next_out, given the space available and the provided input--the effect + documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers + the allocation of and copying into a sliding window until necessary, which + provides the effect documented in zlib.h for Z_FINISH when the entire input + stream available. So the only thing the flush parameter actually does is: + when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it + will return Z_BUF_ERROR if it has not reached the end of the stream. + */ + +int ZEXPORT inflate(strm, flush) +z_streamp strm; +int flush; +{ + struct inflate_state FAR *state; + unsigned char FAR *next; /* next input */ + unsigned char FAR *put; /* next output */ + unsigned have, left; /* available input and output */ + unsigned int hold; /* bit buffer */ + unsigned bits; /* bits in bit buffer */ + unsigned in, out; /* save starting available input and output */ + unsigned copy; /* number of stored or match bytes to copy */ + unsigned char FAR *from; /* where to copy match bytes from */ + code here; /* current decoding table entry */ + code last; /* parent table entry */ + unsigned len; /* length to copy for repeats, bits to drop */ + int ret; /* return code */ +#ifdef GUNZIP + unsigned char hbuf[4]; /* buffer for gzip header crc calculation */ +#endif + static const unsigned short order[19] = /* permutation of code lengths */ + {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; + + if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL || + (strm->next_in == Z_NULL && strm->avail_in != 0)) + return Z_STREAM_ERROR; + + state = (struct inflate_state FAR *)strm->state; + if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */ + LOAD(); + in = have; + out = left; + ret = Z_OK; + for (;;) + switch (state->mode) { + case HEAD: + if (state->wrap == 0) { + state->mode = TYPEDO; + break; + } + NEEDBITS(16); +#ifdef GUNZIP + if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */ + state->check = crc32(0L, Z_NULL, 0); + CRC2(state->check, hold); + INITBITS(); + state->mode = FLAGS; + break; + } + state->flags = 0; /* expect zlib header */ + if (state->head != Z_NULL) + state->head->done = -1; + if (!(state->wrap & 1) || /* check if zlib header allowed */ +#else + if ( +#endif + ((BITS(8) << 8) + (hold >> 8)) % 31) { + strm->msg = (char *)"incorrect header check"; + state->mode = BAD; + break; + } + if (BITS(4) != Z_DEFLATED) { + strm->msg = (char *)"unknown compression method"; + state->mode = BAD; + break; + } + DROPBITS(4); + len = BITS(4) + 8; + if (state->wbits == 0) + state->wbits = len; + else if (len > state->wbits) { + strm->msg = (char *)"invalid window size"; + state->mode = BAD; + break; + } + state->dmax = 1U << len; + Tracev((stderr, "inflate: zlib header ok\n")); + strm->adler = state->check = adler32(0L, Z_NULL, 0); + state->mode = hold & 0x200 ? DICTID : TYPE; + INITBITS(); + break; +#ifdef GUNZIP + case FLAGS: + NEEDBITS(16); + state->flags = (int)(hold); + if ((state->flags & 0xff) != Z_DEFLATED) { + strm->msg = (char *)"unknown compression method"; + state->mode = BAD; + break; + } + if (state->flags & 0xe000) { + strm->msg = (char *)"unknown header flags set"; + state->mode = BAD; + break; + } + if (state->head != Z_NULL) + state->head->text = (int)((hold >> 8) & 1); + if (state->flags & 0x0200) CRC2(state->check, hold); + INITBITS(); + state->mode = TIME; + case TIME: + NEEDBITS(32); + if (state->head != Z_NULL) + state->head->time = hold; + if (state->flags & 0x0200) CRC4(state->check, hold); + INITBITS(); + state->mode = OS; + case OS: + NEEDBITS(16); + if (state->head != Z_NULL) { + state->head->xflags = (int)(hold & 0xff); + state->head->os = (int)(hold >> 8); + } + if (state->flags & 0x0200) CRC2(state->check, hold); + INITBITS(); + state->mode = EXLEN; + case EXLEN: + if (state->flags & 0x0400) { + NEEDBITS(16); + state->length = (unsigned)(hold); + if (state->head != Z_NULL) + state->head->extra_len = (unsigned)hold; + if (state->flags & 0x0200) CRC2(state->check, hold); + INITBITS(); + } + else if (state->head != Z_NULL) + state->head->extra = Z_NULL; + state->mode = EXTRA; + case EXTRA: + if (state->flags & 0x0400) { + copy = state->length; + if (copy > have) copy = have; + if (copy) { + if (state->head != Z_NULL && + state->head->extra != Z_NULL) { + len = state->head->extra_len - state->length; + zmemcpy(state->head->extra + len, next, + len + copy > state->head->extra_max ? + state->head->extra_max - len : copy); + } + if (state->flags & 0x0200) + state->check = crc32(state->check, next, copy); + have -= copy; + next += copy; + state->length -= copy; + } + if (state->length) goto inf_leave; + } + state->length = 0; + state->mode = NAME; + case NAME: + if (state->flags & 0x0800) { + if (have == 0) goto inf_leave; + copy = 0; + do { + len = (unsigned)(next[copy++]); + if (state->head != Z_NULL && + state->head->name != Z_NULL && + state->length < state->head->name_max) + state->head->name[state->length++] = len; + } while (len && copy < have); + if (state->flags & 0x0200) + state->check = crc32(state->check, next, copy); + have -= copy; + next += copy; + if (len) goto inf_leave; + } + else if (state->head != Z_NULL) + state->head->name = Z_NULL; + state->length = 0; + state->mode = COMMENT; + case COMMENT: + if (state->flags & 0x1000) { + if (have == 0) goto inf_leave; + copy = 0; + do { + len = (unsigned)(next[copy++]); + if (state->head != Z_NULL && + state->head->comment != Z_NULL && + state->length < state->head->comm_max) + state->head->comment[state->length++] = len; + } while (len && copy < have); + if (state->flags & 0x0200) + state->check = crc32(state->check, next, copy); + have -= copy; + next += copy; + if (len) goto inf_leave; + } + else if (state->head != Z_NULL) + state->head->comment = Z_NULL; + state->mode = HCRC; + case HCRC: + if (state->flags & 0x0200) { + NEEDBITS(16); + if (hold != (state->check & 0xffff)) { + strm->msg = (char *)"header crc mismatch"; + state->mode = BAD; + break; + } + INITBITS(); + } + if (state->head != Z_NULL) { + state->head->hcrc = (int)((state->flags >> 9) & 1); + state->head->done = 1; + } + strm->adler = state->check = crc32(0L, Z_NULL, 0); + state->mode = TYPE; + break; +#endif + case DICTID: + NEEDBITS(32); + strm->adler = state->check = ZSWAP32(hold); + INITBITS(); + state->mode = DICT; + case DICT: + if (state->havedict == 0) { + RESTORE(); + return Z_NEED_DICT; + } + strm->adler = state->check = adler32(0L, Z_NULL, 0); + state->mode = TYPE; + case TYPE: + if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave; + case TYPEDO: + if (state->last) { + BYTEBITS(); + state->mode = CHECK; + break; + } + NEEDBITS(3); + state->last = BITS(1); + DROPBITS(1); + switch (BITS(2)) { + case 0: /* stored block */ + Tracev((stderr, "inflate: stored block%s\n", + state->last ? " (last)" : "")); + state->mode = STORED; + break; + case 1: /* fixed block */ + fixedtables(state); + Tracev((stderr, "inflate: fixed codes block%s\n", + state->last ? " (last)" : "")); + state->mode = LEN_; /* decode codes */ + if (flush == Z_TREES) { + DROPBITS(2); + goto inf_leave; + } + break; + case 2: /* dynamic block */ + Tracev((stderr, "inflate: dynamic codes block%s\n", + state->last ? " (last)" : "")); + state->mode = TABLE; + break; + case 3: + strm->msg = (char *)"invalid block type"; + state->mode = BAD; + } + DROPBITS(2); + break; + case STORED: + BYTEBITS(); /* go to byte boundary */ + NEEDBITS(32); + if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { + strm->msg = (char *)"invalid stored block lengths"; + state->mode = BAD; + break; + } + state->length = (unsigned)hold & 0xffff; + Tracev((stderr, "inflate: stored length %u\n", + state->length)); + INITBITS(); + state->mode = COPY_; + if (flush == Z_TREES) goto inf_leave; + case COPY_: + state->mode = COPY; + case COPY: + copy = state->length; + if (copy) { + if (copy > have) copy = have; + if (copy > left) copy = left; + if (copy == 0) goto inf_leave; + zmemcpy(put, next, copy); + have -= copy; + next += copy; + left -= copy; + put += copy; + state->length -= copy; + break; + } + Tracev((stderr, "inflate: stored end\n")); + state->mode = TYPE; + break; + case TABLE: + NEEDBITS(14); + state->nlen = BITS(5) + 257; + DROPBITS(5); + state->ndist = BITS(5) + 1; + DROPBITS(5); + state->ncode = BITS(4) + 4; + DROPBITS(4); +#ifndef PKZIP_BUG_WORKAROUND + if (state->nlen > 286 || state->ndist > 30) { + strm->msg = (char *)"too many length or distance symbols"; + state->mode = BAD; + break; + } +#endif + Tracev((stderr, "inflate: table sizes ok\n")); + state->have = 0; + state->mode = LENLENS; + case LENLENS: + while (state->have < state->ncode) { + NEEDBITS(3); + state->lens[order[state->have++]] = (unsigned short)BITS(3); + DROPBITS(3); + } + while (state->have < 19) + state->lens[order[state->have++]] = 0; + state->next = state->codes; + state->lencode = (code const FAR *)(state->next); + state->lenbits = 7; + ret = inflate_table(CODES, state->lens, 19, &(state->next), + &(state->lenbits), state->work); + if (ret) { + strm->msg = (char *)"invalid code lengths set"; + state->mode = BAD; + break; + } + Tracev((stderr, "inflate: code lengths ok\n")); + state->have = 0; + state->mode = CODELENS; + case CODELENS: + while (state->have < state->nlen + state->ndist) { + for (;;) { + here = state->lencode[BITS(state->lenbits)]; + if ((unsigned)(here.bits) <= bits) break; + PULLBYTE(); + } + if (here.val < 16) { + DROPBITS(here.bits); + state->lens[state->have++] = here.val; + } + else { + if (here.val == 16) { + NEEDBITS(here.bits + 2); + DROPBITS(here.bits); + if (state->have == 0) { + strm->msg = (char *)"invalid bit length repeat"; + state->mode = BAD; + break; + } + len = state->lens[state->have - 1]; + copy = 3 + BITS(2); + DROPBITS(2); + } + else if (here.val == 17) { + NEEDBITS(here.bits + 3); + DROPBITS(here.bits); + len = 0; + copy = 3 + BITS(3); + DROPBITS(3); + } + else { + NEEDBITS(here.bits + 7); + DROPBITS(here.bits); + len = 0; + copy = 11 + BITS(7); + DROPBITS(7); + } + if (state->have + copy > state->nlen + state->ndist) { + strm->msg = (char *)"invalid bit length repeat"; + state->mode = BAD; + break; + } + while (copy--) + state->lens[state->have++] = (unsigned short)len; + } + } + + /* handle error breaks in while */ + if (state->mode == BAD) break; + + /* check for end-of-block code (better have one) */ + if (state->lens[256] == 0) { + strm->msg = (char *)"invalid code -- missing end-of-block"; + state->mode = BAD; + break; + } + + /* build code tables -- note: do not change the lenbits or distbits + values here (9 and 6) without reading the comments in inftrees.h + concerning the ENOUGH constants, which depend on those values */ + state->next = state->codes; + state->lencode = (code const FAR *)(state->next); + state->lenbits = 9; + ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), + &(state->lenbits), state->work); + if (ret) { + strm->msg = (char *)"invalid literal/lengths set"; + state->mode = BAD; + break; + } + state->distcode = (code const FAR *)(state->next); + state->distbits = 6; + ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, + &(state->next), &(state->distbits), state->work); + if (ret) { + strm->msg = (char *)"invalid distances set"; + state->mode = BAD; + break; + } + Tracev((stderr, "inflate: codes ok\n")); + state->mode = LEN_; + if (flush == Z_TREES) goto inf_leave; + case LEN_: + state->mode = LEN; + case LEN: + if (have >= 6 && left >= 258) { + RESTORE(); + inflate_fast(strm, out); + LOAD(); + if (state->mode == TYPE) + state->back = -1; + break; + } + state->back = 0; + for (;;) { + here = state->lencode[BITS(state->lenbits)]; + if ((unsigned)(here.bits) <= bits) break; + PULLBYTE(); + } + if (here.op && (here.op & 0xf0) == 0) { + last = here; + for (;;) { + here = state->lencode[last.val + + (BITS(last.bits + last.op) >> last.bits)]; + if ((unsigned)(last.bits + here.bits) <= bits) break; + PULLBYTE(); + } + DROPBITS(last.bits); + state->back += last.bits; + } + DROPBITS(here.bits); + state->back += here.bits; + state->length = (unsigned)here.val; + if ((int)(here.op) == 0) { + Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? + "inflate: literal '%c'\n" : + "inflate: literal 0x%02x\n", here.val)); + state->mode = LIT; + break; + } + if (here.op & 32) { + Tracevv((stderr, "inflate: end of block\n")); + state->back = -1; + state->mode = TYPE; + break; + } + if (here.op & 64) { + strm->msg = (char *)"invalid literal/length code"; + state->mode = BAD; + break; + } + state->extra = (unsigned)(here.op) & 15; + state->mode = LENEXT; + case LENEXT: + if (state->extra) { + NEEDBITS(state->extra); + state->length += BITS(state->extra); + DROPBITS(state->extra); + state->back += state->extra; + } + Tracevv((stderr, "inflate: length %u\n", state->length)); + state->was = state->length; + state->mode = DIST; + case DIST: + for (;;) { + here = state->distcode[BITS(state->distbits)]; + if ((unsigned)(here.bits) <= bits) break; + PULLBYTE(); + } + if ((here.op & 0xf0) == 0) { + last = here; + for (;;) { + here = state->distcode[last.val + + (BITS(last.bits + last.op) >> last.bits)]; + if ((unsigned)(last.bits + here.bits) <= bits) break; + PULLBYTE(); + } + DROPBITS(last.bits); + state->back += last.bits; + } + DROPBITS(here.bits); + state->back += here.bits; + if (here.op & 64) { + strm->msg = (char *)"invalid distance code"; + state->mode = BAD; + break; + } + state->offset = (unsigned)here.val; + state->extra = (unsigned)(here.op) & 15; + state->mode = DISTEXT; + case DISTEXT: + if (state->extra) { + NEEDBITS(state->extra); + state->offset += BITS(state->extra); + DROPBITS(state->extra); + state->back += state->extra; + } +#ifdef INFLATE_STRICT + if (state->offset > state->dmax) { + strm->msg = (char *)"invalid distance too far back"; + state->mode = BAD; + break; + } +#endif + Tracevv((stderr, "inflate: distance %u\n", state->offset)); + state->mode = MATCH; + case MATCH: + if (left == 0) goto inf_leave; + copy = out - left; + if (state->offset > copy) { /* copy from window */ + copy = state->offset - copy; + if (copy > state->whave) { + if (state->sane) { + strm->msg = (char *)"invalid distance too far back"; + state->mode = BAD; + break; + } +#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR + Trace((stderr, "inflate.c too far\n")); + copy -= state->whave; + if (copy > state->length) copy = state->length; + if (copy > left) copy = left; + left -= copy; + state->length -= copy; + do { + *put++ = 0; + } while (--copy); + if (state->length == 0) state->mode = LEN; + break; +#endif + } + if (copy > state->wnext) { + copy -= state->wnext; + from = state->window + (state->wsize - copy); + } + else + from = state->window + (state->wnext - copy); + if (copy > state->length) copy = state->length; + } + else { /* copy from output */ + from = put - state->offset; + copy = state->length; + } + if (copy > left) copy = left; + left -= copy; + state->length -= copy; + do { + *put++ = *from++; + } while (--copy); + if (state->length == 0) state->mode = LEN; + break; + case LIT: + if (left == 0) goto inf_leave; + *put++ = (unsigned char)(state->length); + left--; + state->mode = LEN; + break; + case CHECK: + if (state->wrap) { + NEEDBITS(32); + out -= left; + strm->total_out += out; + state->total += out; + if (out) + strm->adler = state->check = + UPDATE(state->check, put - out, out); + out = left; + if (( +#ifdef GUNZIP + state->flags ? hold : +#endif + ZSWAP32(hold)) != state->check) { + strm->msg = (char *)"incorrect data check"; + state->mode = BAD; + break; + } + INITBITS(); + Tracev((stderr, "inflate: check matches trailer\n")); + } +#ifdef GUNZIP + state->mode = LENGTH; + case LENGTH: + if (state->wrap && state->flags) { + NEEDBITS(32); + if (hold != (state->total & 0xffffffffUL)) { + strm->msg = (char *)"incorrect length check"; + state->mode = BAD; + break; + } + INITBITS(); + Tracev((stderr, "inflate: length matches trailer\n")); + } +#endif + state->mode = DONE; + case DONE: + ret = Z_STREAM_END; + goto inf_leave; + case BAD: + ret = Z_DATA_ERROR; + goto inf_leave; + case MEM: + return Z_MEM_ERROR; + case SYNC: + default: + return Z_STREAM_ERROR; + } + + /* + Return from inflate(), updating the total counts and the check value. + If there was no progress during the inflate() call, return a buffer + error. Call updatewindow() to create and/or update the window state. + Note: a memory error from inflate() is non-recoverable. + */ + inf_leave: + RESTORE(); + if (state->wsize || (out != strm->avail_out && state->mode < BAD && + (state->mode < CHECK || flush != Z_FINISH))) + if (updatewindow(strm, out)) { + state->mode = MEM; + return Z_MEM_ERROR; + } + in -= strm->avail_in; + out -= strm->avail_out; + strm->total_in += in; + strm->total_out += out; + state->total += out; + if (state->wrap && out) + strm->adler = state->check = + UPDATE(state->check, strm->next_out - out, out); + strm->data_type = state->bits + (state->last ? 64 : 0) + + (state->mode == TYPE ? 128 : 0) + + (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0); + if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK) + ret = Z_BUF_ERROR; + return ret; +} + +int ZEXPORT inflateEnd(strm) +z_streamp strm; +{ + struct inflate_state FAR *state; + if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) + return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (state->window != Z_NULL) ZFREE(strm, state->window); + ZFREE(strm, strm->state); + strm->state = Z_NULL; + Tracev((stderr, "inflate: end\n")); + return Z_OK; +} + +int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength) +z_streamp strm; +const Bytef *dictionary; +uInt dictLength; +{ + struct inflate_state FAR *state; + unsigned int dictid; + unsigned char *next; + unsigned avail; + int ret; + + /* check state */ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (state->wrap != 0 && state->mode != DICT) + return Z_STREAM_ERROR; + + /* check for correct dictionary identifier */ + if (state->mode == DICT) { + dictid = adler32(0L, Z_NULL, 0); + dictid = adler32(dictid, dictionary, dictLength); + if (dictid != state->check) + return Z_DATA_ERROR; + } + + /* copy dictionary to window using updatewindow(), which will amend the + existing dictionary if appropriate */ + next = strm->next_out; + avail = strm->avail_out; + strm->next_out = (Bytef *)dictionary + dictLength; + strm->avail_out = 0; + ret = updatewindow(strm, dictLength); + strm->avail_out = avail; + strm->next_out = next; + if (ret) { + state->mode = MEM; + return Z_MEM_ERROR; + } + state->havedict = 1; + Tracev((stderr, "inflate: dictionary set\n")); + return Z_OK; +} + +int ZEXPORT inflateGetHeader(strm, head) +z_streamp strm; +gz_headerp head; +{ + struct inflate_state FAR *state; + + /* check state */ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if ((state->wrap & 2) == 0) return Z_STREAM_ERROR; + + /* save header structure */ + state->head = head; + head->done = 0; + return Z_OK; +} + +/* + Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found + or when out of input. When called, *have is the number of pattern bytes + found in order so far, in 0..3. On return *have is updated to the new + state. If on return *have equals four, then the pattern was found and the + return value is how many bytes were read including the last byte of the + pattern. If *have is less than four, then the pattern has not been found + yet and the return value is len. In the latter case, syncsearch() can be + called again with more data and the *have state. *have is initialized to + zero for the first call. + */ +local unsigned syncsearch(have, buf, len) +unsigned FAR *have; +unsigned char FAR *buf; +unsigned len; +{ + unsigned got; + unsigned next; + + got = *have; + next = 0; + while (next < len && got < 4) { + if ((int)(buf[next]) == (got < 2 ? 0 : 0xff)) + got++; + else if (buf[next]) + got = 0; + else + got = 4 - got; + next++; + } + *have = got; + return next; +} + +int ZEXPORT inflateSync(strm) +z_streamp strm; +{ + unsigned len; /* number of bytes to look at or looked at */ + unsigned int in, out; /* temporary to save total_in and total_out */ + unsigned char buf[4]; /* to restore bit buffer to byte string */ + struct inflate_state FAR *state; + + /* check parameters */ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR; + + /* if first time, start search in bit buffer */ + if (state->mode != SYNC) { + state->mode = SYNC; + state->hold <<= state->bits & 7; + state->bits -= state->bits & 7; + len = 0; + while (state->bits >= 8) { + buf[len++] = (unsigned char)(state->hold); + state->hold >>= 8; + state->bits -= 8; + } + state->have = 0; + syncsearch(&(state->have), buf, len); + } + + /* search available input */ + len = syncsearch(&(state->have), strm->next_in, strm->avail_in); + strm->avail_in -= len; + strm->next_in += len; + strm->total_in += len; + + /* return no joy or set up to restart inflate() on a new block */ + if (state->have != 4) return Z_DATA_ERROR; + in = strm->total_in; out = strm->total_out; + inflateReset(strm); + strm->total_in = in; strm->total_out = out; + state->mode = TYPE; + return Z_OK; +} + +/* + Returns true if inflate is currently at the end of a block generated by + Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP + implementation to provide an additional safety check. PPP uses + Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored + block. When decompressing, PPP checks that at the end of input packet, + inflate is waiting for these length bytes. + */ +int ZEXPORT inflateSyncPoint(strm) +z_streamp strm; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + return state->mode == STORED && state->bits == 0; +} + +int ZEXPORT inflateCopy(dest, source) +z_streamp dest; +z_streamp source; +{ + struct inflate_state FAR *state; + struct inflate_state FAR *copy; + unsigned char FAR *window; + unsigned wsize; + + /* check input */ + if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL || + source->zalloc == (alloc_func)0 || source->zfree == (free_func)0) + return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)source->state; + + /* allocate space */ + copy = (struct inflate_state FAR *) + ZALLOC(source, 1, sizeof(struct inflate_state)); + if (copy == Z_NULL) return Z_MEM_ERROR; + window = Z_NULL; + if (state->window != Z_NULL) { + window = (unsigned char FAR *) + ZALLOC(source, 1U << state->wbits, sizeof(unsigned char)); + if (window == Z_NULL) { + ZFREE(source, copy); + return Z_MEM_ERROR; + } + } + + /* copy state */ + zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream)); + zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state)); + if (state->lencode >= state->codes && + state->lencode <= state->codes + ENOUGH - 1) { + copy->lencode = copy->codes + (state->lencode - state->codes); + copy->distcode = copy->codes + (state->distcode - state->codes); + } + copy->next = copy->codes + (state->next - state->codes); + if (window != Z_NULL) { + wsize = 1U << state->wbits; + zmemcpy(window, state->window, wsize); + } + copy->window = window; + dest->state = (struct internal_state FAR *)copy; + return Z_OK; +} + +int ZEXPORT inflateUndermine(strm, subvert) +z_streamp strm; +int subvert; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + state->sane = !subvert; +#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR + return Z_OK; +#else + state->sane = 1; + return Z_DATA_ERROR; +#endif +} + +int ZEXPORT inflateMark(strm) +z_streamp strm; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16; + state = (struct inflate_state FAR *)strm->state; + return ((int)(state->back) << 16) + + (state->mode == COPY ? state->length : + (state->mode == MATCH ? state->was - state->length : 0)); +} diff --git a/zlib/inflate.h b/zlib/inflate.h new file mode 100644 index 0000000..18b070c --- /dev/null +++ b/zlib/inflate.h @@ -0,0 +1,122 @@ +/* inflate.h -- internal inflate state definition + * Copyright (C) 1995-2009 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +/* define NO_GZIP when compiling if you want to disable gzip header and + trailer decoding by inflate(). NO_GZIP would be used to avoid linking in + the crc code when it is not needed. For shared libraries, gzip decoding + should be left enabled. */ +#ifndef NO_GZIP +# define GUNZIP +#endif + +/* Possible inflate modes between inflate() calls */ +typedef enum { + HEAD, /* i: waiting for magic header */ + FLAGS, /* i: waiting for method and flags (gzip) */ + TIME, /* i: waiting for modification time (gzip) */ + OS, /* i: waiting for extra flags and operating system (gzip) */ + EXLEN, /* i: waiting for extra length (gzip) */ + EXTRA, /* i: waiting for extra bytes (gzip) */ + NAME, /* i: waiting for end of file name (gzip) */ + COMMENT, /* i: waiting for end of comment (gzip) */ + HCRC, /* i: waiting for header crc (gzip) */ + DICTID, /* i: waiting for dictionary check value */ + DICT, /* waiting for inflateSetDictionary() call */ + TYPE, /* i: waiting for type bits, including last-flag bit */ + TYPEDO, /* i: same, but skip check to exit inflate on new block */ + STORED, /* i: waiting for stored size (length and complement) */ + COPY_, /* i/o: same as COPY below, but only first time in */ + COPY, /* i/o: waiting for input or output to copy stored block */ + TABLE, /* i: waiting for dynamic block table lengths */ + LENLENS, /* i: waiting for code length code lengths */ + CODELENS, /* i: waiting for length/lit and distance code lengths */ + LEN_, /* i: same as LEN below, but only first time in */ + LEN, /* i: waiting for length/lit/eob code */ + LENEXT, /* i: waiting for length extra bits */ + DIST, /* i: waiting for distance code */ + DISTEXT, /* i: waiting for distance extra bits */ + MATCH, /* o: waiting for output space to copy string */ + LIT, /* o: waiting for output space to write literal */ + CHECK, /* i: waiting for 32-bit check value */ + LENGTH, /* i: waiting for 32-bit length (gzip) */ + DONE, /* finished check, done -- remain here until reset */ + BAD, /* got a data error -- remain here until reset */ + MEM, /* got an inflate() memory error -- remain here until reset */ + SYNC /* looking for synchronization bytes to restart inflate() */ +} inflate_mode; + +/* + State transitions between above modes - + + (most modes can go to BAD or MEM on error -- not shown for clarity) + + Process header: + HEAD -> (gzip) or (zlib) or (raw) + (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT -> + HCRC -> TYPE + (zlib) -> DICTID or TYPE + DICTID -> DICT -> TYPE + (raw) -> TYPEDO + Read deflate blocks: + TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK + STORED -> COPY_ -> COPY -> TYPE + TABLE -> LENLENS -> CODELENS -> LEN_ + LEN_ -> LEN + Read deflate codes in fixed or dynamic block: + LEN -> LENEXT or LIT or TYPE + LENEXT -> DIST -> DISTEXT -> MATCH -> LEN + LIT -> LEN + Process trailer: + CHECK -> LENGTH -> DONE + */ + +/* state maintained between inflate() calls. Approximately 10K bytes. */ +struct inflate_state { + inflate_mode mode; /* current inflate mode */ + int last; /* true if processing last block */ + int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ + int havedict; /* true if dictionary provided */ + int flags; /* gzip header method and flags (0 if zlib) */ + unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */ + unsigned int check; /* protected copy of check value */ + unsigned int total; /* protected copy of output count */ + gz_headerp head; /* where to save gzip header information */ + /* sliding window */ + unsigned wbits; /* log base 2 of requested window size */ + unsigned wsize; /* window size or zero if not using window */ + unsigned whave; /* valid bytes in the window */ + unsigned wnext; /* window write index */ + unsigned char FAR *window; /* allocated sliding window, if needed */ + /* bit accumulator */ + unsigned int hold; /* input bit accumulator */ + unsigned bits; /* number of bits in "in" */ + /* for string and stored block copying */ + unsigned length; /* literal or length of data to copy */ + unsigned offset; /* distance back to copy string from */ + /* for table and code decoding */ + unsigned extra; /* extra bits needed */ + /* fixed and dynamic code tables */ + code const FAR *lencode; /* starting table for length/literal codes */ + code const FAR *distcode; /* starting table for distance codes */ + unsigned lenbits; /* index bits for lencode */ + unsigned distbits; /* index bits for distcode */ + /* dynamic table building */ + unsigned ncode; /* number of code length code lengths */ + unsigned nlen; /* number of length code lengths */ + unsigned ndist; /* number of distance code lengths */ + unsigned have; /* number of code lengths in lens[] */ + code FAR *next; /* next available space in codes[] */ + unsigned short lens[320]; /* temporary storage for code lengths */ + unsigned short work[288]; /* work area for code table building */ + code codes[ENOUGH]; /* space for code tables */ + int sane; /* if false, allow invalid distance too far */ + int back; /* bits back of last unprocessed length/lit */ + unsigned was; /* initial length of match */ +}; diff --git a/zlib/inftrees.c b/zlib/inftrees.c new file mode 100644 index 0000000..abcd7c4 --- /dev/null +++ b/zlib/inftrees.c @@ -0,0 +1,306 @@ +/* inftrees.c -- generate Huffman trees for efficient decoding + * Copyright (C) 1995-2012 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "zutil.h" +#include "inftrees.h" + +#define MAXBITS 15 + +const char inflate_copyright[] = + " inflate 1.2.7 Copyright 1995-2012 Mark Adler "; +/* + If you use the zlib library in a product, an acknowledgment is welcome + in the documentation of your product. If for some reason you cannot + include such an acknowledgment, I would appreciate that you keep this + copyright string in the executable of your product. + */ + +/* + Build a set of tables to decode the provided canonical Huffman code. + The code lengths are lens[0..codes-1]. The result starts at *table, + whose indices are 0..2^bits-1. work is a writable array of at least + lens shorts, which is used as a work area. type is the type of code + to be generated, CODES, LENS, or DISTS. On return, zero is success, + -1 is an invalid code, and +1 means that ENOUGH isn't enough. table + on return points to the next available entry's address. bits is the + requested root table index bits, and on return it is the actual root + table index bits. It will differ if the request is greater than the + longest code or if it is less than the shortest code. + */ +int ZLIB_INTERNAL inflate_table(type, lens, codes, table, bits, work) +codetype type; +unsigned short FAR *lens; +unsigned codes; +code FAR * FAR *table; +unsigned FAR *bits; +unsigned short FAR *work; +{ + unsigned len; /* a code's length in bits */ + unsigned sym; /* index of code symbols */ + unsigned min, max; /* minimum and maximum code lengths */ + unsigned root; /* number of index bits for root table */ + unsigned curr; /* number of index bits for current table */ + unsigned drop; /* code bits to drop for sub-table */ + int left; /* number of prefix codes available */ + unsigned used; /* code entries in table used */ + unsigned huff; /* Huffman code */ + unsigned incr; /* for incrementing code, index */ + unsigned fill; /* index for replicating entries */ + unsigned low; /* low bits for current root entry */ + unsigned mask; /* mask for low root bits */ + code here; /* table entry for duplication */ + code FAR *next; /* next available space in table */ + const unsigned short FAR *base; /* base value table to use */ + const unsigned short FAR *extra; /* extra bits table to use */ + int end; /* use base and extra for symbol > end */ + unsigned short count[MAXBITS+1]; /* number of codes of each length */ + unsigned short offs[MAXBITS+1]; /* offsets in table for each length */ + static const unsigned short lbase[31] = { /* Length codes 257..285 base */ + 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, + 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; + static const unsigned short lext[31] = { /* Length codes 257..285 extra */ + 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, + 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 78, 68}; + static const unsigned short dbase[32] = { /* Distance codes 0..29 base */ + 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, + 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, + 8193, 12289, 16385, 24577, 0, 0}; + static const unsigned short dext[32] = { /* Distance codes 0..29 extra */ + 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, + 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, + 28, 28, 29, 29, 64, 64}; + + /* + Process a set of code lengths to create a canonical Huffman code. The + code lengths are lens[0..codes-1]. Each length corresponds to the + symbols 0..codes-1. The Huffman code is generated by first sorting the + symbols by length from short to long, and retaining the symbol order + for codes with equal lengths. Then the code starts with all zero bits + for the first code of the shortest length, and the codes are integer + increments for the same length, and zeros are appended as the length + increases. For the deflate format, these bits are stored backwards + from their more natural integer increment ordering, and so when the + decoding tables are built in the large loop below, the integer codes + are incremented backwards. + + This routine assumes, but does not check, that all of the entries in + lens[] are in the range 0..MAXBITS. The caller must assure this. + 1..MAXBITS is interpreted as that code length. zero means that that + symbol does not occur in this code. + + The codes are sorted by computing a count of codes for each length, + creating from that a table of starting indices for each length in the + sorted table, and then entering the symbols in order in the sorted + table. The sorted table is work[], with that space being provided by + the caller. + + The length counts are used for other purposes as well, i.e. finding + the minimum and maximum length codes, determining if there are any + codes at all, checking for a valid set of lengths, and looking ahead + at length counts to determine sub-table sizes when building the + decoding tables. + */ + + /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ + for (len = 0; len <= MAXBITS; len++) + count[len] = 0; + for (sym = 0; sym < codes; sym++) + count[lens[sym]]++; + + /* bound code lengths, force root to be within code lengths */ + root = *bits; + for (max = MAXBITS; max >= 1; max--) + if (count[max] != 0) break; + if (root > max) root = max; + if (max == 0) { /* no symbols to code at all */ + here.op = (unsigned char)64; /* invalid code marker */ + here.bits = (unsigned char)1; + here.val = (unsigned short)0; + *(*table)++ = here; /* make a table to force an error */ + *(*table)++ = here; + *bits = 1; + return 0; /* no symbols, but wait for decoding to report error */ + } + for (min = 1; min < max; min++) + if (count[min] != 0) break; + if (root < min) root = min; + + /* check for an over-subscribed or incomplete set of lengths */ + left = 1; + for (len = 1; len <= MAXBITS; len++) { + left <<= 1; + left -= count[len]; + if (left < 0) return -1; /* over-subscribed */ + } + if (left > 0 && (type == CODES || max != 1)) + return -1; /* incomplete set */ + + /* generate offsets into symbol table for each length for sorting */ + offs[1] = 0; + for (len = 1; len < MAXBITS; len++) + offs[len + 1] = offs[len] + count[len]; + + /* sort symbols by length, by symbol order within each length */ + for (sym = 0; sym < codes; sym++) + if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym; + + /* + Create and fill in decoding tables. In this loop, the table being + filled is at next and has curr index bits. The code being used is huff + with length len. That code is converted to an index by dropping drop + bits off of the bottom. For codes where len is less than drop + curr, + those top drop + curr - len bits are incremented through all values to + fill the table with replicated entries. + + root is the number of index bits for the root table. When len exceeds + root, sub-tables are created pointed to by the root entry with an index + of the low root bits of huff. This is saved in low to check for when a + new sub-table should be started. drop is zero when the root table is + being filled, and drop is root when sub-tables are being filled. + + When a new sub-table is needed, it is necessary to look ahead in the + code lengths to determine what size sub-table is needed. The length + counts are used for this, and so count[] is decremented as codes are + entered in the tables. + + used keeps track of how many table entries have been allocated from the + provided *table space. It is checked for LENS and DIST tables against + the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in + the initial root table size constants. See the comments in inftrees.h + for more information. + + sym increments through all symbols, and the loop terminates when + all codes of length max, i.e. all codes, have been processed. This + routine permits incomplete codes, so another loop after this one fills + in the rest of the decoding tables with invalid code markers. + */ + + /* set up for code type */ + switch (type) { + case CODES: + base = extra = work; /* dummy value--not used */ + end = 19; + break; + case LENS: + base = lbase; + base -= 257; + extra = lext; + extra -= 257; + end = 256; + break; + default: /* DISTS */ + base = dbase; + extra = dext; + end = -1; + } + + /* initialize state for loop */ + huff = 0; /* starting code */ + sym = 0; /* starting code symbol */ + len = min; /* starting code length */ + next = *table; /* current table to fill in */ + curr = root; /* current table index bits */ + drop = 0; /* current bits to drop from code for index */ + low = (unsigned)(-1); /* trigger new sub-table when len > root */ + used = 1U << root; /* use root table entries */ + mask = used - 1; /* mask for comparing low */ + + /* check available table space */ + if ((type == LENS && used >= ENOUGH_LENS) || + (type == DISTS && used >= ENOUGH_DISTS)) + return 1; + + /* process all codes and make table entries */ + for (;;) { + /* create table entry */ + here.bits = (unsigned char)(len - drop); + if ((int)(work[sym]) < end) { + here.op = (unsigned char)0; + here.val = work[sym]; + } + else if ((int)(work[sym]) > end) { + here.op = (unsigned char)(extra[work[sym]]); + here.val = base[work[sym]]; + } + else { + here.op = (unsigned char)(32 + 64); /* end of block */ + here.val = 0; + } + + /* replicate for those indices with low len bits equal to huff */ + incr = 1U << (len - drop); + fill = 1U << curr; + min = fill; /* save offset to next table */ + do { + fill -= incr; + next[(huff >> drop) + fill] = here; + } while (fill != 0); + + /* backwards increment the len-bit code huff */ + incr = 1U << (len - 1); + while (huff & incr) + incr >>= 1; + if (incr != 0) { + huff &= incr - 1; + huff += incr; + } + else + huff = 0; + + /* go to next symbol, update count, len */ + sym++; + if (--(count[len]) == 0) { + if (len == max) break; + len = lens[work[sym]]; + } + + /* create new sub-table if needed */ + if (len > root && (huff & mask) != low) { + /* if first time, transition to sub-tables */ + if (drop == 0) + drop = root; + + /* increment past last table */ + next += min; /* here min is 1 << curr */ + + /* determine length of next table */ + curr = len - drop; + left = (int)(1 << curr); + while (curr + drop < max) { + left -= count[curr + drop]; + if (left <= 0) break; + curr++; + left <<= 1; + } + + /* check for enough space */ + used += 1U << curr; + if ((type == LENS && used >= ENOUGH_LENS) || + (type == DISTS && used >= ENOUGH_DISTS)) + return 1; + + /* point entry in root table to sub-table */ + low = huff & mask; + (*table)[low].op = (unsigned char)curr; + (*table)[low].bits = (unsigned char)root; + (*table)[low].val = (unsigned short)(next - *table); + } + } + + /* fill in remaining table entry if code is incomplete (guaranteed to have + at most one remaining entry, since if the code is incomplete, the + maximum code length that was allowed to get this far is one bit) */ + if (huff != 0) { + here.op = (unsigned char)64; /* invalid code marker */ + here.bits = (unsigned char)(len - drop); + here.val = (unsigned short)0; + next[huff] = here; + } + + /* set return parameters */ + *table += used; + *bits = root; + return 0; +} diff --git a/zlib/inftrees.h b/zlib/inftrees.h new file mode 100644 index 0000000..baa53a0 --- /dev/null +++ b/zlib/inftrees.h @@ -0,0 +1,62 @@ +/* inftrees.h -- header to use inftrees.c + * Copyright (C) 1995-2005, 2010 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +/* Structure for decoding tables. Each entry provides either the + information needed to do the operation requested by the code that + indexed that table entry, or it provides a pointer to another + table that indexes more bits of the code. op indicates whether + the entry is a pointer to another table, a literal, a length or + distance, an end-of-block, or an invalid code. For a table + pointer, the low four bits of op is the number of index bits of + that table. For a length or distance, the low four bits of op + is the number of extra bits to get after the code. bits is + the number of bits in this code or part of the code to drop off + of the bit buffer. val is the actual byte to output in the case + of a literal, the base length or distance, or the offset from + the current table to the next table. Each entry is four bytes. */ +typedef struct { + unsigned char op; /* operation, extra bits, table bits */ + unsigned char bits; /* bits in this part of the code */ + unsigned short val; /* offset in table or code value */ +} code; + +/* op values as set by inflate_table(): + 00000000 - literal + 0000tttt - table link, tttt != 0 is the number of table index bits + 0001eeee - length or distance, eeee is the number of extra bits + 01100000 - end of block + 01000000 - invalid code + */ + +/* Maximum size of the dynamic table. The maximum number of code structures is + 1444, which is the sum of 852 for literal/length codes and 592 for distance + codes. These values were found by exhaustive searches using the program + examples/enough.c found in the zlib distribtution. The arguments to that + program are the number of symbols, the initial root table size, and the + maximum bit length of a code. "enough 286 9 15" for literal/length codes + returns returns 852, and "enough 30 6 15" for distance codes returns 592. + The initial root table size (9 or 6) is found in the fifth argument of the + inflate_table() calls in inflate.c and infback.c. If the root table size is + changed, then these maximum sizes would be need to be recalculated and + updated. */ +#define ENOUGH_LENS 852 +#define ENOUGH_DISTS 592 +#define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS) + +/* Type of code to build for inflate_table() */ +typedef enum { + CODES, + LENS, + DISTS +} codetype; + +int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens, + unsigned codes, code FAR * FAR *table, + unsigned FAR *bits, unsigned short FAR *work)); diff --git a/zlib/memmap b/zlib/memmap new file mode 100644 index 0000000..d08c78d --- /dev/null +++ b/zlib/memmap @@ -0,0 +1,12 @@ + +MEMORY +{ + ram : ORIGIN = 0x00000000, LENGTH = 0x80000 +} + +SECTIONS +{ + .text : { *(.text*) } > ram + .bss : { *(.bss*) } > ram +} + diff --git a/zlib/testdata.h b/zlib/testdata.h new file mode 100644 index 0000000..54ac04f --- /dev/null +++ b/zlib/testdata.h @@ -0,0 +1,630 @@ + +#define TESTDATALEN 10000 +const unsigned char testdata[TESTDATALEN]= +{ +0x0A,0x4D,0x6F,0x73,0x74,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x50,0x61,0x72, +0x74,0x68,0x65,0x6E,0x6F,0x6E,0x27,0x73,0x20,0x69,0x6D,0x70,0x6F,0x73,0x69,0x6E, +0x67,0x20,0x63,0x6F,0x6C,0x75,0x6D,0x6E,0x73,0x20,0x61,0x72,0x65,0x20,0x73,0x74, +0x69,0x6C,0x6C,0x20,0x73,0x74,0x61,0x6E,0x64,0x69,0x6E,0x67,0x2C,0x20,0x62,0x75, +0x74,0x20,0x74,0x68,0x65,0x20,0x72,0x6F,0x6F,0x66,0x0A,0x69,0x73,0x20,0x67,0x6F, +0x6E,0x65,0x2E,0x20,0x20,0x49,0x74,0x20,0x77,0x61,0x73,0x20,0x61,0x20,0x70,0x65, +0x72,0x66,0x65,0x63,0x74,0x20,0x62,0x75,0x69,0x6C,0x64,0x69,0x6E,0x67,0x20,0x74, +0x77,0x6F,0x20,0x68,0x75,0x6E,0x64,0x72,0x65,0x64,0x20,0x61,0x6E,0x64,0x20,0x66, +0x69,0x66,0x74,0x79,0x20,0x79,0x65,0x61,0x72,0x73,0x20,0x61,0x67,0x6F,0x2C,0x20, +0x77,0x68,0x65,0x6E,0x0A,0x61,0x20,0x73,0x68,0x65,0x6C,0x6C,0x20,0x64,0x72,0x6F, +0x70,0x70,0x65,0x64,0x20,0x69,0x6E,0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x56,0x65, +0x6E,0x65,0x74,0x69,0x61,0x6E,0x20,0x6D,0x61,0x67,0x61,0x7A,0x69,0x6E,0x65,0x20, +0x73,0x74,0x6F,0x72,0x65,0x64,0x20,0x68,0x65,0x72,0x65,0x2C,0x20,0x61,0x6E,0x64, +0x20,0x74,0x68,0x65,0x20,0x65,0x78,0x70,0x6C,0x6F,0x73,0x69,0x6F,0x6E,0x0A,0x77, +0x68,0x69,0x63,0x68,0x20,0x66,0x6F,0x6C,0x6C,0x6F,0x77,0x65,0x64,0x20,0x77,0x72, +0x65,0x63,0x6B,0x65,0x64,0x20,0x61,0x6E,0x64,0x20,0x75,0x6E,0x72,0x6F,0x6F,0x66, +0x65,0x64,0x20,0x69,0x74,0x2E,0x20,0x20,0x49,0x20,0x72,0x65,0x6D,0x65,0x6D,0x62, +0x65,0x72,0x20,0x62,0x75,0x74,0x20,0x6C,0x69,0x74,0x74,0x6C,0x65,0x20,0x61,0x62, +0x6F,0x75,0x74,0x20,0x74,0x68,0x65,0x0A,0x50,0x61,0x72,0x74,0x68,0x65,0x6E,0x6F, +0x6E,0x2C,0x20,0x61,0x6E,0x64,0x20,0x49,0x20,0x68,0x61,0x76,0x65,0x20,0x70,0x75, +0x74,0x20,0x69,0x6E,0x20,0x6F,0x6E,0x65,0x20,0x6F,0x72,0x20,0x74,0x77,0x6F,0x20, +0x66,0x61,0x63,0x74,0x73,0x20,0x61,0x6E,0x64,0x20,0x66,0x69,0x67,0x75,0x72,0x65, +0x73,0x20,0x66,0x6F,0x72,0x20,0x74,0x68,0x65,0x20,0x75,0x73,0x65,0x20,0x6F,0x66, +0x0A,0x6F,0x74,0x68,0x65,0x72,0x20,0x70,0x65,0x6F,0x70,0x6C,0x65,0x20,0x77,0x69, +0x74,0x68,0x20,0x73,0x68,0x6F,0x72,0x74,0x20,0x6D,0x65,0x6D,0x6F,0x72,0x69,0x65, +0x73,0x2E,0x20,0x20,0x47,0x6F,0x74,0x20,0x74,0x68,0x65,0x6D,0x20,0x66,0x72,0x6F, +0x6D,0x20,0x74,0x68,0x65,0x20,0x67,0x75,0x69,0x64,0x65,0x2D,0x62,0x6F,0x6F,0x6B, +0x2E,0x0A,0x0A,0x41,0x73,0x20,0x77,0x65,0x20,0x77,0x61,0x6E,0x64,0x65,0x72,0x65, +0x64,0x20,0x74,0x68,0x6F,0x75,0x67,0x68,0x74,0x66,0x75,0x6C,0x6C,0x79,0x20,0x64, +0x6F,0x77,0x6E,0x20,0x74,0x68,0x65,0x20,0x6D,0x61,0x72,0x62,0x6C,0x65,0x2D,0x70, +0x61,0x76,0x65,0x64,0x20,0x6C,0x65,0x6E,0x67,0x74,0x68,0x20,0x6F,0x66,0x20,0x74, +0x68,0x69,0x73,0x20,0x73,0x74,0x61,0x74,0x65,0x6C,0x79,0x0A,0x74,0x65,0x6D,0x70, +0x6C,0x65,0x2C,0x20,0x74,0x68,0x65,0x20,0x73,0x63,0x65,0x6E,0x65,0x20,0x61,0x62, +0x6F,0x75,0x74,0x20,0x75,0x73,0x20,0x77,0x61,0x73,0x20,0x73,0x74,0x72,0x61,0x6E, +0x67,0x65,0x6C,0x79,0x20,0x69,0x6D,0x70,0x72,0x65,0x73,0x73,0x69,0x76,0x65,0x2E, +0x20,0x20,0x48,0x65,0x72,0x65,0x20,0x61,0x6E,0x64,0x20,0x74,0x68,0x65,0x72,0x65, +0x2C,0x20,0x69,0x6E,0x0A,0x6C,0x61,0x76,0x69,0x73,0x68,0x20,0x70,0x72,0x6F,0x66, +0x75,0x73,0x69,0x6F,0x6E,0x2C,0x20,0x77,0x65,0x72,0x65,0x20,0x67,0x6C,0x65,0x61, +0x6D,0x69,0x6E,0x67,0x20,0x77,0x68,0x69,0x74,0x65,0x20,0x73,0x74,0x61,0x74,0x75, +0x65,0x73,0x20,0x6F,0x66,0x20,0x6D,0x65,0x6E,0x20,0x61,0x6E,0x64,0x20,0x77,0x6F, +0x6D,0x65,0x6E,0x2C,0x20,0x70,0x72,0x6F,0x70,0x70,0x65,0x64,0x0A,0x61,0x67,0x61, +0x69,0x6E,0x73,0x74,0x20,0x62,0x6C,0x6F,0x63,0x6B,0x73,0x20,0x6F,0x66,0x20,0x6D, +0x61,0x72,0x62,0x6C,0x65,0x2C,0x20,0x73,0x6F,0x6D,0x65,0x20,0x6F,0x66,0x20,0x74, +0x68,0x65,0x6D,0x20,0x61,0x72,0x6D,0x6C,0x65,0x73,0x73,0x2C,0x20,0x73,0x6F,0x6D, +0x65,0x20,0x77,0x69,0x74,0x68,0x6F,0x75,0x74,0x20,0x6C,0x65,0x67,0x73,0x2C,0x20, +0x6F,0x74,0x68,0x65,0x72,0x73,0x0A,0x68,0x65,0x61,0x64,0x6C,0x65,0x73,0x73,0x2D, +0x2D,0x62,0x75,0x74,0x20,0x61,0x6C,0x6C,0x20,0x6C,0x6F,0x6F,0x6B,0x69,0x6E,0x67, +0x20,0x6D,0x6F,0x75,0x72,0x6E,0x66,0x75,0x6C,0x20,0x69,0x6E,0x20,0x74,0x68,0x65, +0x20,0x6D,0x6F,0x6F,0x6E,0x6C,0x69,0x67,0x68,0x74,0x2C,0x20,0x61,0x6E,0x64,0x20, +0x73,0x74,0x61,0x72,0x74,0x6C,0x69,0x6E,0x67,0x6C,0x79,0x0A,0x68,0x75,0x6D,0x61, +0x6E,0x21,0x20,0x20,0x54,0x68,0x65,0x79,0x20,0x72,0x6F,0x73,0x65,0x20,0x75,0x70, +0x20,0x61,0x6E,0x64,0x20,0x63,0x6F,0x6E,0x66,0x72,0x6F,0x6E,0x74,0x65,0x64,0x20, +0x74,0x68,0x65,0x20,0x6D,0x69,0x64,0x6E,0x69,0x67,0x68,0x74,0x20,0x69,0x6E,0x74, +0x72,0x75,0x64,0x65,0x72,0x20,0x6F,0x6E,0x20,0x65,0x76,0x65,0x72,0x79,0x20,0x73, +0x69,0x64,0x65,0x0A,0x2D,0x2D,0x74,0x68,0x65,0x79,0x20,0x73,0x74,0x61,0x72,0x65, +0x64,0x20,0x61,0x74,0x20,0x68,0x69,0x6D,0x20,0x77,0x69,0x74,0x68,0x20,0x73,0x74, +0x6F,0x6E,0x79,0x20,0x65,0x79,0x65,0x73,0x20,0x66,0x72,0x6F,0x6D,0x20,0x75,0x6E, +0x6C,0x6F,0x6F,0x6B,0x65,0x64,0x2D,0x66,0x6F,0x72,0x20,0x6E,0x6F,0x6F,0x6B,0x73, +0x20,0x61,0x6E,0x64,0x20,0x72,0x65,0x63,0x65,0x73,0x73,0x65,0x73,0x3B,0x0A,0x74, +0x68,0x65,0x79,0x20,0x70,0x65,0x65,0x72,0x65,0x64,0x20,0x61,0x74,0x20,0x68,0x69, +0x6D,0x20,0x6F,0x76,0x65,0x72,0x20,0x66,0x72,0x61,0x67,0x6D,0x65,0x6E,0x74,0x61, +0x72,0x79,0x20,0x68,0x65,0x61,0x70,0x73,0x20,0x66,0x61,0x72,0x20,0x64,0x6F,0x77, +0x6E,0x20,0x74,0x68,0x65,0x20,0x64,0x65,0x73,0x6F,0x6C,0x61,0x74,0x65,0x0A,0x63, +0x6F,0x72,0x72,0x69,0x64,0x6F,0x72,0x73,0x3B,0x20,0x74,0x68,0x65,0x79,0x20,0x62, +0x61,0x72,0x72,0x65,0x64,0x20,0x68,0x69,0x73,0x20,0x77,0x61,0x79,0x20,0x69,0x6E, +0x20,0x74,0x68,0x65,0x20,0x6D,0x69,0x64,0x73,0x74,0x20,0x6F,0x66,0x20,0x74,0x68, +0x65,0x20,0x62,0x72,0x6F,0x61,0x64,0x20,0x66,0x6F,0x72,0x75,0x6D,0x2C,0x20,0x61, +0x6E,0x64,0x0A,0x73,0x6F,0x6C,0x65,0x6D,0x6E,0x6C,0x79,0x20,0x70,0x6F,0x69,0x6E, +0x74,0x65,0x64,0x20,0x77,0x69,0x74,0x68,0x20,0x68,0x61,0x6E,0x64,0x6C,0x65,0x73, +0x73,0x20,0x61,0x72,0x6D,0x73,0x20,0x74,0x68,0x65,0x20,0x77,0x61,0x79,0x20,0x66, +0x72,0x6F,0x6D,0x20,0x74,0x68,0x65,0x20,0x73,0x61,0x63,0x72,0x65,0x64,0x20,0x66, +0x61,0x6E,0x65,0x3B,0x20,0x61,0x6E,0x64,0x0A,0x74,0x68,0x72,0x6F,0x75,0x67,0x68, +0x20,0x74,0x68,0x65,0x20,0x72,0x6F,0x6F,0x66,0x6C,0x65,0x73,0x73,0x20,0x74,0x65, +0x6D,0x70,0x6C,0x65,0x20,0x74,0x68,0x65,0x20,0x6D,0x6F,0x6F,0x6E,0x20,0x6C,0x6F, +0x6F,0x6B,0x65,0x64,0x20,0x64,0x6F,0x77,0x6E,0x2C,0x20,0x61,0x6E,0x64,0x20,0x62, +0x61,0x6E,0x64,0x65,0x64,0x20,0x74,0x68,0x65,0x20,0x66,0x6C,0x6F,0x6F,0x72,0x0A, +0x61,0x6E,0x64,0x20,0x64,0x61,0x72,0x6B,0x65,0x6E,0x65,0x64,0x20,0x74,0x68,0x65, +0x20,0x73,0x63,0x61,0x74,0x74,0x65,0x72,0x65,0x64,0x20,0x66,0x72,0x61,0x67,0x6D, +0x65,0x6E,0x74,0x73,0x20,0x61,0x6E,0x64,0x20,0x62,0x72,0x6F,0x6B,0x65,0x6E,0x20, +0x73,0x74,0x61,0x74,0x75,0x65,0x73,0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x68,0x65, +0x20,0x73,0x6C,0x61,0x6E,0x74,0x69,0x6E,0x67,0x0A,0x73,0x68,0x61,0x64,0x6F,0x77, +0x73,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x63,0x6F,0x6C,0x75,0x6D,0x6E,0x73, +0x2E,0x0A,0x0A,0x57,0x68,0x61,0x74,0x20,0x61,0x20,0x77,0x6F,0x72,0x6C,0x64,0x20, +0x6F,0x66,0x20,0x72,0x75,0x69,0x6E,0x65,0x64,0x20,0x73,0x63,0x75,0x6C,0x70,0x74, +0x75,0x72,0x65,0x20,0x77,0x61,0x73,0x20,0x61,0x62,0x6F,0x75,0x74,0x20,0x75,0x73, +0x21,0x20,0x20,0x53,0x65,0x74,0x20,0x75,0x70,0x20,0x69,0x6E,0x20,0x72,0x6F,0x77, +0x73,0x2D,0x2D,0x73,0x74,0x61,0x63,0x6B,0x65,0x64,0x0A,0x75,0x70,0x20,0x69,0x6E, +0x20,0x70,0x69,0x6C,0x65,0x73,0x2D,0x2D,0x73,0x63,0x61,0x74,0x74,0x65,0x72,0x65, +0x64,0x20,0x62,0x72,0x6F,0x61,0x64,0x63,0x61,0x73,0x74,0x20,0x6F,0x76,0x65,0x72, +0x20,0x74,0x68,0x65,0x20,0x77,0x69,0x64,0x65,0x20,0x61,0x72,0x65,0x61,0x20,0x6F, +0x66,0x20,0x74,0x68,0x65,0x20,0x41,0x63,0x72,0x6F,0x70,0x6F,0x6C,0x69,0x73,0x0A, +0x2D,0x2D,0x77,0x65,0x72,0x65,0x20,0x68,0x75,0x6E,0x64,0x72,0x65,0x64,0x73,0x20, +0x6F,0x66,0x20,0x63,0x72,0x69,0x70,0x70,0x6C,0x65,0x64,0x20,0x73,0x74,0x61,0x74, +0x75,0x65,0x73,0x20,0x6F,0x66,0x20,0x61,0x6C,0x6C,0x20,0x73,0x69,0x7A,0x65,0x73, +0x20,0x61,0x6E,0x64,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x6D,0x6F,0x73,0x74, +0x20,0x65,0x78,0x71,0x75,0x69,0x73,0x69,0x74,0x65,0x0A,0x77,0x6F,0x72,0x6B,0x6D, +0x61,0x6E,0x73,0x68,0x69,0x70,0x3B,0x20,0x61,0x6E,0x64,0x20,0x76,0x61,0x73,0x74, +0x20,0x66,0x72,0x61,0x67,0x6D,0x65,0x6E,0x74,0x73,0x20,0x6F,0x66,0x20,0x6D,0x61, +0x72,0x62,0x6C,0x65,0x20,0x74,0x68,0x61,0x74,0x20,0x6F,0x6E,0x63,0x65,0x20,0x62, +0x65,0x6C,0x6F,0x6E,0x67,0x65,0x64,0x20,0x74,0x6F,0x20,0x74,0x68,0x65,0x0A,0x65, +0x6E,0x74,0x61,0x62,0x6C,0x61,0x74,0x75,0x72,0x65,0x73,0x2C,0x20,0x63,0x6F,0x76, +0x65,0x72,0x65,0x64,0x20,0x77,0x69,0x74,0x68,0x20,0x62,0x61,0x73,0x2D,0x72,0x65, +0x6C,0x69,0x65,0x66,0x73,0x20,0x72,0x65,0x70,0x72,0x65,0x73,0x65,0x6E,0x74,0x69, +0x6E,0x67,0x20,0x62,0x61,0x74,0x74,0x6C,0x65,0x73,0x20,0x61,0x6E,0x64,0x20,0x73, +0x69,0x65,0x67,0x65,0x73,0x2C,0x0A,0x73,0x68,0x69,0x70,0x73,0x20,0x6F,0x66,0x20, +0x77,0x61,0x72,0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x68,0x72,0x65,0x65,0x20,0x61, +0x6E,0x64,0x20,0x66,0x6F,0x75,0x72,0x20,0x74,0x69,0x65,0x72,0x73,0x20,0x6F,0x66, +0x20,0x6F,0x61,0x72,0x73,0x2C,0x20,0x70,0x61,0x67,0x65,0x61,0x6E,0x74,0x73,0x20, +0x61,0x6E,0x64,0x20,0x70,0x72,0x6F,0x63,0x65,0x73,0x73,0x69,0x6F,0x6E,0x73,0x0A, +0x2D,0x2D,0x65,0x76,0x65,0x72,0x79,0x20,0x74,0x68,0x69,0x6E,0x67,0x20,0x6F,0x6E, +0x65,0x20,0x63,0x6F,0x75,0x6C,0x64,0x20,0x74,0x68,0x69,0x6E,0x6B,0x20,0x6F,0x66, +0x2E,0x20,0x20,0x48,0x69,0x73,0x74,0x6F,0x72,0x79,0x20,0x73,0x61,0x79,0x73,0x20, +0x74,0x68,0x61,0x74,0x20,0x74,0x68,0x65,0x20,0x74,0x65,0x6D,0x70,0x6C,0x65,0x73, +0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x0A,0x41,0x63,0x72,0x6F,0x70,0x6F,0x6C,0x69, +0x73,0x20,0x77,0x65,0x72,0x65,0x20,0x66,0x69,0x6C,0x6C,0x65,0x64,0x20,0x77,0x69, +0x74,0x68,0x20,0x74,0x68,0x65,0x20,0x6E,0x6F,0x62,0x6C,0x65,0x73,0x74,0x20,0x77, +0x6F,0x72,0x6B,0x73,0x20,0x6F,0x66,0x20,0x50,0x72,0x61,0x78,0x69,0x74,0x65,0x6C, +0x65,0x73,0x20,0x61,0x6E,0x64,0x20,0x50,0x68,0x69,0x64,0x69,0x61,0x73,0x2C,0x0A, +0x61,0x6E,0x64,0x20,0x6F,0x66,0x20,0x6D,0x61,0x6E,0x79,0x20,0x61,0x20,0x67,0x72, +0x65,0x61,0x74,0x20,0x6D,0x61,0x73,0x74,0x65,0x72,0x20,0x69,0x6E,0x20,0x73,0x63, +0x75,0x6C,0x70,0x74,0x75,0x72,0x65,0x20,0x62,0x65,0x73,0x69,0x64,0x65,0x73,0x2D, +0x2D,0x61,0x6E,0x64,0x20,0x73,0x75,0x72,0x65,0x6C,0x79,0x20,0x74,0x68,0x65,0x73, +0x65,0x20,0x65,0x6C,0x65,0x67,0x61,0x6E,0x74,0x0A,0x66,0x72,0x61,0x67,0x6D,0x65, +0x6E,0x74,0x73,0x20,0x61,0x74,0x74,0x65,0x73,0x74,0x20,0x69,0x74,0x2E,0x0A,0x0A, +0x57,0x65,0x20,0x77,0x61,0x6C,0x6B,0x65,0x64,0x20,0x6F,0x75,0x74,0x20,0x69,0x6E, +0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x67,0x72,0x61,0x73,0x73,0x2D,0x67,0x72,0x6F, +0x77,0x6E,0x2C,0x20,0x66,0x72,0x61,0x67,0x6D,0x65,0x6E,0x74,0x2D,0x73,0x74,0x72, +0x65,0x77,0x6E,0x20,0x63,0x6F,0x75,0x72,0x74,0x20,0x62,0x65,0x79,0x6F,0x6E,0x64, +0x20,0x74,0x68,0x65,0x0A,0x50,0x61,0x72,0x74,0x68,0x65,0x6E,0x6F,0x6E,0x2E,0x20, +0x20,0x49,0x74,0x20,0x73,0x74,0x61,0x72,0x74,0x6C,0x65,0x64,0x20,0x75,0x73,0x2C, +0x20,0x65,0x76,0x65,0x72,0x79,0x20,0x6E,0x6F,0x77,0x20,0x61,0x6E,0x64,0x20,0x74, +0x68,0x65,0x6E,0x2C,0x20,0x74,0x6F,0x20,0x73,0x65,0x65,0x20,0x61,0x20,0x73,0x74, +0x6F,0x6E,0x79,0x20,0x77,0x68,0x69,0x74,0x65,0x20,0x66,0x61,0x63,0x65,0x0A,0x73, +0x74,0x61,0x72,0x65,0x20,0x73,0x75,0x64,0x64,0x65,0x6E,0x6C,0x79,0x20,0x75,0x70, +0x20,0x61,0x74,0x20,0x75,0x73,0x20,0x6F,0x75,0x74,0x20,0x6F,0x66,0x20,0x74,0x68, +0x65,0x20,0x67,0x72,0x61,0x73,0x73,0x20,0x77,0x69,0x74,0x68,0x20,0x69,0x74,0x73, +0x20,0x64,0x65,0x61,0x64,0x20,0x65,0x79,0x65,0x73,0x2E,0x20,0x20,0x54,0x68,0x65, +0x20,0x70,0x6C,0x61,0x63,0x65,0x0A,0x73,0x65,0x65,0x6D,0x65,0x64,0x20,0x61,0x6C, +0x69,0x76,0x65,0x20,0x77,0x69,0x74,0x68,0x20,0x67,0x68,0x6F,0x73,0x74,0x73,0x2E, +0x20,0x20,0x49,0x20,0x68,0x61,0x6C,0x66,0x20,0x65,0x78,0x70,0x65,0x63,0x74,0x65, +0x64,0x20,0x74,0x6F,0x20,0x73,0x65,0x65,0x20,0x74,0x68,0x65,0x20,0x41,0x74,0x68, +0x65,0x6E,0x69,0x61,0x6E,0x20,0x68,0x65,0x72,0x6F,0x65,0x73,0x20,0x6F,0x66,0x0A, +0x74,0x77,0x65,0x6E,0x74,0x79,0x20,0x63,0x65,0x6E,0x74,0x75,0x72,0x69,0x65,0x73, +0x20,0x61,0x67,0x6F,0x20,0x67,0x6C,0x69,0x64,0x65,0x20,0x6F,0x75,0x74,0x20,0x6F, +0x66,0x20,0x74,0x68,0x65,0x20,0x73,0x68,0x61,0x64,0x6F,0x77,0x73,0x20,0x61,0x6E, +0x64,0x20,0x73,0x74,0x65,0x61,0x6C,0x20,0x69,0x6E,0x74,0x6F,0x20,0x74,0x68,0x65, +0x20,0x6F,0x6C,0x64,0x0A,0x74,0x65,0x6D,0x70,0x6C,0x65,0x20,0x74,0x68,0x65,0x79, +0x20,0x6B,0x6E,0x65,0x77,0x20,0x73,0x6F,0x20,0x77,0x65,0x6C,0x6C,0x20,0x61,0x6E, +0x64,0x20,0x72,0x65,0x67,0x61,0x72,0x64,0x65,0x64,0x20,0x77,0x69,0x74,0x68,0x20, +0x73,0x75,0x63,0x68,0x20,0x62,0x6F,0x75,0x6E,0x64,0x6C,0x65,0x73,0x73,0x20,0x70, +0x72,0x69,0x64,0x65,0x2E,0x0A,0x0A,0x54,0x68,0x65,0x20,0x66,0x75,0x6C,0x6C,0x20, +0x6D,0x6F,0x6F,0x6E,0x20,0x77,0x61,0x73,0x20,0x72,0x69,0x64,0x69,0x6E,0x67,0x20, +0x68,0x69,0x67,0x68,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x63,0x6C,0x6F,0x75, +0x64,0x6C,0x65,0x73,0x73,0x20,0x68,0x65,0x61,0x76,0x65,0x6E,0x73,0x2C,0x20,0x6E, +0x6F,0x77,0x2E,0x20,0x20,0x57,0x65,0x0A,0x73,0x61,0x75,0x6E,0x74,0x65,0x72,0x65, +0x64,0x20,0x63,0x61,0x72,0x65,0x6C,0x65,0x73,0x73,0x6C,0x79,0x20,0x61,0x6E,0x64, +0x20,0x75,0x6E,0x74,0x68,0x69,0x6E,0x6B,0x69,0x6E,0x67,0x6C,0x79,0x20,0x74,0x6F, +0x20,0x74,0x68,0x65,0x20,0x65,0x64,0x67,0x65,0x20,0x6F,0x66,0x20,0x74,0x68,0x65, +0x20,0x6C,0x6F,0x66,0x74,0x79,0x0A,0x62,0x61,0x74,0x74,0x6C,0x65,0x6D,0x65,0x6E, +0x74,0x73,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x63,0x69,0x74,0x61,0x64,0x65, +0x6C,0x2C,0x20,0x61,0x6E,0x64,0x20,0x6C,0x6F,0x6F,0x6B,0x65,0x64,0x20,0x64,0x6F, +0x77,0x6E,0x2D,0x2D,0x61,0x20,0x76,0x69,0x73,0x69,0x6F,0x6E,0x21,0x20,0x20,0x41, +0x6E,0x64,0x20,0x73,0x75,0x63,0x68,0x20,0x61,0x0A,0x76,0x69,0x73,0x69,0x6F,0x6E, +0x21,0x20,0x20,0x41,0x74,0x68,0x65,0x6E,0x73,0x20,0x62,0x79,0x20,0x6D,0x6F,0x6F, +0x6E,0x6C,0x69,0x67,0x68,0x74,0x21,0x20,0x20,0x54,0x68,0x65,0x20,0x70,0x72,0x6F, +0x70,0x68,0x65,0x74,0x20,0x74,0x68,0x61,0x74,0x20,0x74,0x68,0x6F,0x75,0x67,0x68, +0x74,0x20,0x74,0x68,0x65,0x20,0x73,0x70,0x6C,0x65,0x6E,0x64,0x6F,0x72,0x73,0x20, +0x6F,0x66,0x0A,0x74,0x68,0x65,0x20,0x4E,0x65,0x77,0x20,0x4A,0x65,0x72,0x75,0x73, +0x61,0x6C,0x65,0x6D,0x20,0x77,0x65,0x72,0x65,0x20,0x72,0x65,0x76,0x65,0x61,0x6C, +0x65,0x64,0x20,0x74,0x6F,0x20,0x68,0x69,0x6D,0x2C,0x20,0x73,0x75,0x72,0x65,0x6C, +0x79,0x20,0x73,0x61,0x77,0x20,0x74,0x68,0x69,0x73,0x20,0x69,0x6E,0x73,0x74,0x65, +0x61,0x64,0x21,0x20,0x20,0x49,0x74,0x20,0x6C,0x61,0x79,0x0A,0x69,0x6E,0x20,0x74, +0x68,0x65,0x20,0x6C,0x65,0x76,0x65,0x6C,0x20,0x70,0x6C,0x61,0x69,0x6E,0x20,0x72, +0x69,0x67,0x68,0x74,0x20,0x75,0x6E,0x64,0x65,0x72,0x20,0x6F,0x75,0x72,0x20,0x66, +0x65,0x65,0x74,0x2D,0x2D,0x61,0x6C,0x6C,0x20,0x73,0x70,0x72,0x65,0x61,0x64,0x20, +0x61,0x62,0x72,0x6F,0x61,0x64,0x20,0x6C,0x69,0x6B,0x65,0x20,0x61,0x0A,0x70,0x69, +0x63,0x74,0x75,0x72,0x65,0x2D,0x2D,0x61,0x6E,0x64,0x20,0x77,0x65,0x20,0x6C,0x6F, +0x6F,0x6B,0x65,0x64,0x20,0x64,0x6F,0x77,0x6E,0x20,0x75,0x70,0x6F,0x6E,0x20,0x69, +0x74,0x20,0x61,0x73,0x20,0x77,0x65,0x20,0x6D,0x69,0x67,0x68,0x74,0x20,0x68,0x61, +0x76,0x65,0x20,0x6C,0x6F,0x6F,0x6B,0x65,0x64,0x20,0x66,0x72,0x6F,0x6D,0x20,0x61, +0x0A,0x62,0x61,0x6C,0x6C,0x6F,0x6F,0x6E,0x2E,0x20,0x20,0x57,0x65,0x20,0x73,0x61, +0x77,0x20,0x6E,0x6F,0x20,0x73,0x65,0x6D,0x62,0x6C,0x61,0x6E,0x63,0x65,0x20,0x6F, +0x66,0x20,0x61,0x20,0x73,0x74,0x72,0x65,0x65,0x74,0x2C,0x20,0x62,0x75,0x74,0x20, +0x65,0x76,0x65,0x72,0x79,0x20,0x68,0x6F,0x75,0x73,0x65,0x2C,0x20,0x65,0x76,0x65, +0x72,0x79,0x20,0x77,0x69,0x6E,0x64,0x6F,0x77,0x2C,0x0A,0x65,0x76,0x65,0x72,0x79, +0x20,0x63,0x6C,0x69,0x6E,0x67,0x69,0x6E,0x67,0x20,0x76,0x69,0x6E,0x65,0x2C,0x20, +0x65,0x76,0x65,0x72,0x79,0x20,0x70,0x72,0x6F,0x6A,0x65,0x63,0x74,0x69,0x6F,0x6E, +0x20,0x77,0x61,0x73,0x20,0x61,0x73,0x20,0x64,0x69,0x73,0x74,0x69,0x6E,0x63,0x74, +0x20,0x61,0x6E,0x64,0x20,0x73,0x68,0x61,0x72,0x70,0x6C,0x79,0x20,0x6D,0x61,0x72, +0x6B,0x65,0x64,0x0A,0x61,0x73,0x20,0x69,0x66,0x20,0x74,0x68,0x65,0x20,0x74,0x69, +0x6D,0x65,0x20,0x77,0x65,0x72,0x65,0x20,0x6E,0x6F,0x6F,0x6E,0x2D,0x64,0x61,0x79, +0x3B,0x20,0x61,0x6E,0x64,0x20,0x79,0x65,0x74,0x20,0x74,0x68,0x65,0x72,0x65,0x20, +0x77,0x61,0x73,0x20,0x6E,0x6F,0x20,0x67,0x6C,0x61,0x72,0x65,0x2C,0x20,0x6E,0x6F, +0x20,0x67,0x6C,0x69,0x74,0x74,0x65,0x72,0x2C,0x0A,0x6E,0x6F,0x74,0x68,0x69,0x6E, +0x67,0x20,0x68,0x61,0x72,0x73,0x68,0x20,0x6F,0x72,0x20,0x72,0x65,0x70,0x75,0x6C, +0x73,0x69,0x76,0x65,0x2D,0x2D,0x74,0x68,0x65,0x20,0x6E,0x6F,0x69,0x73,0x65,0x6C, +0x65,0x73,0x73,0x20,0x63,0x69,0x74,0x79,0x20,0x77,0x61,0x73,0x20,0x66,0x6C,0x6F, +0x6F,0x64,0x65,0x64,0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x68,0x65,0x0A,0x6D,0x65, +0x6C,0x6C,0x6F,0x77,0x65,0x73,0x74,0x20,0x6C,0x69,0x67,0x68,0x74,0x20,0x74,0x68, +0x61,0x74,0x20,0x65,0x76,0x65,0x72,0x20,0x73,0x74,0x72,0x65,0x61,0x6D,0x65,0x64, +0x20,0x66,0x72,0x6F,0x6D,0x20,0x74,0x68,0x65,0x20,0x6D,0x6F,0x6F,0x6E,0x2C,0x20, +0x61,0x6E,0x64,0x20,0x73,0x65,0x65,0x6D,0x65,0x64,0x20,0x6C,0x69,0x6B,0x65,0x20, +0x73,0x6F,0x6D,0x65,0x0A,0x6C,0x69,0x76,0x69,0x6E,0x67,0x20,0x63,0x72,0x65,0x61, +0x74,0x75,0x72,0x65,0x20,0x77,0x72,0x61,0x70,0x70,0x65,0x64,0x20,0x69,0x6E,0x20, +0x70,0x65,0x61,0x63,0x65,0x66,0x75,0x6C,0x20,0x73,0x6C,0x75,0x6D,0x62,0x65,0x72, +0x2E,0x20,0x20,0x4F,0x6E,0x20,0x69,0x74,0x73,0x20,0x66,0x75,0x72,0x74,0x68,0x65, +0x72,0x20,0x73,0x69,0x64,0x65,0x20,0x77,0x61,0x73,0x20,0x61,0x0A,0x6C,0x69,0x74, +0x74,0x6C,0x65,0x20,0x74,0x65,0x6D,0x70,0x6C,0x65,0x2C,0x20,0x77,0x68,0x6F,0x73, +0x65,0x20,0x64,0x65,0x6C,0x69,0x63,0x61,0x74,0x65,0x20,0x70,0x69,0x6C,0x6C,0x61, +0x72,0x73,0x20,0x61,0x6E,0x64,0x20,0x6F,0x72,0x6E,0x61,0x74,0x65,0x20,0x66,0x72, +0x6F,0x6E,0x74,0x20,0x67,0x6C,0x6F,0x77,0x65,0x64,0x20,0x77,0x69,0x74,0x68,0x20, +0x61,0x20,0x72,0x69,0x63,0x68,0x0A,0x6C,0x75,0x73,0x74,0x72,0x65,0x20,0x74,0x68, +0x61,0x74,0x20,0x63,0x68,0x61,0x69,0x6E,0x65,0x64,0x20,0x74,0x68,0x65,0x20,0x65, +0x79,0x65,0x20,0x6C,0x69,0x6B,0x65,0x20,0x61,0x20,0x73,0x70,0x65,0x6C,0x6C,0x3B, +0x20,0x61,0x6E,0x64,0x20,0x6E,0x65,0x61,0x72,0x65,0x72,0x20,0x62,0x79,0x2C,0x20, +0x74,0x68,0x65,0x20,0x70,0x61,0x6C,0x61,0x63,0x65,0x20,0x6F,0x66,0x0A,0x74,0x68, +0x65,0x20,0x6B,0x69,0x6E,0x67,0x20,0x72,0x65,0x61,0x72,0x65,0x64,0x20,0x69,0x74, +0x73,0x20,0x63,0x72,0x65,0x61,0x6D,0x79,0x20,0x77,0x61,0x6C,0x6C,0x73,0x20,0x6F, +0x75,0x74,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x6D,0x69,0x64,0x73,0x74,0x20, +0x6F,0x66,0x20,0x61,0x20,0x67,0x72,0x65,0x61,0x74,0x20,0x67,0x61,0x72,0x64,0x65, +0x6E,0x20,0x6F,0x66,0x0A,0x73,0x68,0x72,0x75,0x62,0x62,0x65,0x72,0x79,0x20,0x74, +0x68,0x61,0x74,0x20,0x77,0x61,0x73,0x20,0x66,0x6C,0x65,0x63,0x6B,0x65,0x64,0x20, +0x61,0x6C,0x6C,0x20,0x6F,0x76,0x65,0x72,0x20,0x77,0x69,0x74,0x68,0x20,0x61,0x20, +0x72,0x61,0x6E,0x64,0x6F,0x6D,0x20,0x73,0x68,0x6F,0x77,0x65,0x72,0x20,0x6F,0x66, +0x20,0x61,0x6D,0x62,0x65,0x72,0x20,0x6C,0x69,0x67,0x68,0x74,0x73,0x0A,0x2D,0x2D, +0x61,0x20,0x73,0x70,0x72,0x61,0x79,0x20,0x6F,0x66,0x20,0x67,0x6F,0x6C,0x64,0x65, +0x6E,0x20,0x73,0x70,0x61,0x72,0x6B,0x73,0x20,0x74,0x68,0x61,0x74,0x20,0x6C,0x6F, +0x73,0x74,0x20,0x74,0x68,0x65,0x69,0x72,0x20,0x62,0x72,0x69,0x67,0x68,0x74,0x6E, +0x65,0x73,0x73,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x67,0x6C,0x6F,0x72,0x79, +0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x0A,0x6D,0x6F,0x6F,0x6E,0x2C,0x20,0x61,0x6E, +0x64,0x20,0x67,0x6C,0x69,0x6E,0x74,0x65,0x64,0x20,0x73,0x6F,0x66,0x74,0x6C,0x79, +0x20,0x75,0x70,0x6F,0x6E,0x20,0x74,0x68,0x65,0x20,0x73,0x65,0x61,0x20,0x6F,0x66, +0x20,0x64,0x61,0x72,0x6B,0x20,0x66,0x6F,0x6C,0x69,0x61,0x67,0x65,0x20,0x6C,0x69, +0x6B,0x65,0x20,0x74,0x68,0x65,0x20,0x70,0x61,0x6C,0x6C,0x69,0x64,0x0A,0x73,0x74, +0x61,0x72,0x73,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x6D,0x69,0x6C,0x6B,0x79, +0x2D,0x77,0x61,0x79,0x2E,0x20,0x20,0x4F,0x76,0x65,0x72,0x68,0x65,0x61,0x64,0x20, +0x74,0x68,0x65,0x20,0x73,0x74,0x61,0x74,0x65,0x6C,0x79,0x20,0x63,0x6F,0x6C,0x75, +0x6D,0x6E,0x73,0x2C,0x20,0x6D,0x61,0x6A,0x65,0x73,0x74,0x69,0x63,0x20,0x73,0x74, +0x69,0x6C,0x6C,0x20,0x69,0x6E,0x0A,0x74,0x68,0x65,0x69,0x72,0x20,0x72,0x75,0x69, +0x6E,0x2D,0x2D,0x75,0x6E,0x64,0x65,0x72,0x20,0x66,0x6F,0x6F,0x74,0x20,0x74,0x68, +0x65,0x20,0x64,0x72,0x65,0x61,0x6D,0x69,0x6E,0x67,0x20,0x63,0x69,0x74,0x79,0x2D, +0x2D,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x64,0x69,0x73,0x74,0x61,0x6E,0x63,0x65, +0x20,0x74,0x68,0x65,0x20,0x73,0x69,0x6C,0x76,0x65,0x72,0x20,0x73,0x65,0x61,0x0A, +0x2D,0x2D,0x6E,0x6F,0x74,0x20,0x6F,0x6E,0x20,0x74,0x68,0x65,0x20,0x62,0x72,0x6F, +0x61,0x64,0x20,0x65,0x61,0x72,0x74,0x68,0x20,0x69,0x73,0x20,0x74,0x68,0x65,0x72, +0x65,0x20,0x61,0x6E,0x20,0x6F,0x74,0x68,0x65,0x72,0x20,0x70,0x69,0x63,0x74,0x75, +0x72,0x65,0x20,0x68,0x61,0x6C,0x66,0x20,0x73,0x6F,0x20,0x62,0x65,0x61,0x75,0x74, +0x69,0x66,0x75,0x6C,0x21,0x0A,0x0A,0x41,0x73,0x20,0x77,0x65,0x20,0x74,0x75,0x72, +0x6E,0x65,0x64,0x20,0x61,0x6E,0x64,0x20,0x6D,0x6F,0x76,0x65,0x64,0x20,0x61,0x67, +0x61,0x69,0x6E,0x20,0x74,0x68,0x72,0x6F,0x75,0x67,0x68,0x20,0x74,0x68,0x65,0x20, +0x74,0x65,0x6D,0x70,0x6C,0x65,0x2C,0x20,0x49,0x20,0x77,0x69,0x73,0x68,0x65,0x64, +0x20,0x74,0x68,0x61,0x74,0x20,0x74,0x68,0x65,0x0A,0x69,0x6C,0x6C,0x75,0x73,0x74, +0x72,0x69,0x6F,0x75,0x73,0x20,0x6D,0x65,0x6E,0x20,0x77,0x68,0x6F,0x20,0x68,0x61, +0x64,0x20,0x73,0x61,0x74,0x20,0x69,0x6E,0x20,0x69,0x74,0x20,0x69,0x6E,0x20,0x74, +0x68,0x65,0x20,0x72,0x65,0x6D,0x6F,0x74,0x65,0x20,0x61,0x67,0x65,0x73,0x20,0x63, +0x6F,0x75,0x6C,0x64,0x20,0x76,0x69,0x73,0x69,0x74,0x20,0x69,0x74,0x20,0x61,0x67, +0x61,0x69,0x6E,0x0A,0x61,0x6E,0x64,0x20,0x72,0x65,0x76,0x65,0x61,0x6C,0x20,0x74, +0x68,0x65,0x6D,0x73,0x65,0x6C,0x76,0x65,0x73,0x20,0x74,0x6F,0x20,0x6F,0x75,0x72, +0x20,0x63,0x75,0x72,0x69,0x6F,0x75,0x73,0x20,0x65,0x79,0x65,0x73,0x2D,0x2D,0x50, +0x6C,0x61,0x74,0x6F,0x2C,0x20,0x41,0x72,0x69,0x73,0x74,0x6F,0x74,0x6C,0x65,0x2C, +0x20,0x44,0x65,0x6D,0x6F,0x73,0x74,0x68,0x65,0x6E,0x65,0x73,0x2C,0x0A,0x53,0x6F, +0x63,0x72,0x61,0x74,0x65,0x73,0x2C,0x20,0x50,0x68,0x6F,0x63,0x69,0x6F,0x6E,0x2C, +0x20,0x50,0x79,0x74,0x68,0x61,0x67,0x6F,0x72,0x61,0x73,0x2C,0x20,0x45,0x75,0x63, +0x6C,0x69,0x64,0x2C,0x20,0x50,0x69,0x6E,0x64,0x61,0x72,0x2C,0x20,0x58,0x65,0x6E, +0x6F,0x70,0x68,0x6F,0x6E,0x2C,0x20,0x48,0x65,0x72,0x6F,0x64,0x6F,0x74,0x75,0x73, +0x2C,0x0A,0x50,0x72,0x61,0x78,0x69,0x74,0x65,0x6C,0x65,0x73,0x20,0x61,0x6E,0x64, +0x20,0x50,0x68,0x69,0x64,0x69,0x61,0x73,0x2C,0x20,0x5A,0x65,0x75,0x78,0x69,0x73, +0x20,0x74,0x68,0x65,0x20,0x70,0x61,0x69,0x6E,0x74,0x65,0x72,0x2E,0x20,0x20,0x57, +0x68,0x61,0x74,0x20,0x61,0x20,0x63,0x6F,0x6E,0x73,0x74,0x65,0x6C,0x6C,0x61,0x74, +0x69,0x6F,0x6E,0x20,0x6F,0x66,0x0A,0x63,0x65,0x6C,0x65,0x62,0x72,0x61,0x74,0x65, +0x64,0x20,0x6E,0x61,0x6D,0x65,0x73,0x21,0x20,0x20,0x42,0x75,0x74,0x20,0x6D,0x6F, +0x72,0x65,0x20,0x74,0x68,0x61,0x6E,0x20,0x61,0x6C,0x6C,0x2C,0x20,0x49,0x20,0x77, +0x69,0x73,0x68,0x65,0x64,0x20,0x74,0x68,0x61,0x74,0x20,0x6F,0x6C,0x64,0x20,0x44, +0x69,0x6F,0x67,0x65,0x6E,0x65,0x73,0x2C,0x20,0x67,0x72,0x6F,0x70,0x69,0x6E,0x67, +0x0A,0x73,0x6F,0x20,0x70,0x61,0x74,0x69,0x65,0x6E,0x74,0x6C,0x79,0x20,0x77,0x69, +0x74,0x68,0x20,0x68,0x69,0x73,0x20,0x6C,0x61,0x6E,0x74,0x65,0x72,0x6E,0x2C,0x20, +0x73,0x65,0x61,0x72,0x63,0x68,0x69,0x6E,0x67,0x20,0x73,0x6F,0x20,0x7A,0x65,0x61, +0x6C,0x6F,0x75,0x73,0x6C,0x79,0x20,0x66,0x6F,0x72,0x20,0x6F,0x6E,0x65,0x20,0x73, +0x6F,0x6C,0x69,0x74,0x61,0x72,0x79,0x0A,0x68,0x6F,0x6E,0x65,0x73,0x74,0x20,0x6D, +0x61,0x6E,0x20,0x69,0x6E,0x20,0x61,0x6C,0x6C,0x20,0x74,0x68,0x65,0x20,0x77,0x6F, +0x72,0x6C,0x64,0x2C,0x20,0x6D,0x69,0x67,0x68,0x74,0x20,0x6D,0x65,0x61,0x6E,0x64, +0x65,0x72,0x20,0x61,0x6C,0x6F,0x6E,0x67,0x20,0x61,0x6E,0x64,0x20,0x73,0x74,0x75, +0x6D,0x62,0x6C,0x65,0x20,0x6F,0x6E,0x20,0x6F,0x75,0x72,0x0A,0x70,0x61,0x72,0x74, +0x79,0x2E,0x20,0x20,0x49,0x20,0x6F,0x75,0x67,0x68,0x74,0x20,0x6E,0x6F,0x74,0x20, +0x74,0x6F,0x20,0x73,0x61,0x79,0x20,0x69,0x74,0x2C,0x20,0x6D,0x61,0x79,0x20,0x62, +0x65,0x2C,0x20,0x62,0x75,0x74,0x20,0x73,0x74,0x69,0x6C,0x6C,0x20,0x49,0x20,0x73, +0x75,0x70,0x70,0x6F,0x73,0x65,0x20,0x68,0x65,0x20,0x77,0x6F,0x75,0x6C,0x64,0x20, +0x68,0x61,0x76,0x65,0x0A,0x70,0x75,0x74,0x20,0x6F,0x75,0x74,0x20,0x68,0x69,0x73, +0x20,0x6C,0x69,0x67,0x68,0x74,0x2E,0x0A,0x0A,0x57,0x65,0x20,0x6C,0x65,0x66,0x74, +0x20,0x74,0x68,0x65,0x20,0x50,0x61,0x72,0x74,0x68,0x65,0x6E,0x6F,0x6E,0x20,0x74, +0x6F,0x20,0x6B,0x65,0x65,0x70,0x20,0x69,0x74,0x73,0x20,0x77,0x61,0x74,0x63,0x68, +0x20,0x6F,0x76,0x65,0x72,0x20,0x6F,0x6C,0x64,0x20,0x41,0x74,0x68,0x65,0x6E,0x73, +0x2C,0x20,0x61,0x73,0x20,0x69,0x74,0x20,0x68,0x61,0x64,0x20,0x6B,0x65,0x70,0x74, +0x0A,0x69,0x74,0x20,0x66,0x6F,0x72,0x20,0x74,0x77,0x65,0x6E,0x74,0x79,0x2D,0x74, +0x68,0x72,0x65,0x65,0x20,0x68,0x75,0x6E,0x64,0x72,0x65,0x64,0x20,0x79,0x65,0x61, +0x72,0x73,0x2C,0x20,0x61,0x6E,0x64,0x20,0x77,0x65,0x6E,0x74,0x20,0x61,0x6E,0x64, +0x20,0x73,0x74,0x6F,0x6F,0x64,0x20,0x6F,0x75,0x74,0x73,0x69,0x64,0x65,0x20,0x74, +0x68,0x65,0x20,0x77,0x61,0x6C,0x6C,0x73,0x0A,0x6F,0x66,0x20,0x74,0x68,0x65,0x20, +0x63,0x69,0x74,0x61,0x64,0x65,0x6C,0x2E,0x20,0x20,0x49,0x6E,0x20,0x74,0x68,0x65, +0x20,0x64,0x69,0x73,0x74,0x61,0x6E,0x63,0x65,0x20,0x77,0x61,0x73,0x20,0x74,0x68, +0x65,0x20,0x61,0x6E,0x63,0x69,0x65,0x6E,0x74,0x2C,0x20,0x62,0x75,0x74,0x20,0x73, +0x74,0x69,0x6C,0x6C,0x20,0x61,0x6C,0x6D,0x6F,0x73,0x74,0x0A,0x70,0x65,0x72,0x66, +0x65,0x63,0x74,0x20,0x54,0x65,0x6D,0x70,0x6C,0x65,0x20,0x6F,0x66,0x20,0x54,0x68, +0x65,0x73,0x65,0x75,0x73,0x2C,0x20,0x61,0x6E,0x64,0x20,0x63,0x6C,0x6F,0x73,0x65, +0x20,0x62,0x79,0x2C,0x20,0x6C,0x6F,0x6F,0x6B,0x69,0x6E,0x67,0x20,0x74,0x6F,0x20, +0x74,0x68,0x65,0x20,0x77,0x65,0x73,0x74,0x2C,0x20,0x77,0x61,0x73,0x20,0x74,0x68, +0x65,0x0A,0x42,0x65,0x6D,0x61,0x2C,0x20,0x66,0x72,0x6F,0x6D,0x20,0x77,0x68,0x65, +0x6E,0x63,0x65,0x20,0x44,0x65,0x6D,0x6F,0x73,0x74,0x68,0x65,0x6E,0x65,0x73,0x20, +0x74,0x68,0x75,0x6E,0x64,0x65,0x72,0x65,0x64,0x20,0x68,0x69,0x73,0x20,0x70,0x68, +0x69,0x6C,0x69,0x70,0x70,0x69,0x63,0x73,0x20,0x61,0x6E,0x64,0x20,0x66,0x69,0x72, +0x65,0x64,0x20,0x74,0x68,0x65,0x0A,0x77,0x61,0x76,0x65,0x72,0x69,0x6E,0x67,0x20, +0x70,0x61,0x74,0x72,0x69,0x6F,0x74,0x69,0x73,0x6D,0x20,0x6F,0x66,0x20,0x68,0x69, +0x73,0x20,0x63,0x6F,0x75,0x6E,0x74,0x72,0x79,0x6D,0x65,0x6E,0x2E,0x20,0x20,0x54, +0x6F,0x20,0x74,0x68,0x65,0x20,0x72,0x69,0x67,0x68,0x74,0x20,0x77,0x61,0x73,0x20, +0x4D,0x61,0x72,0x73,0x20,0x48,0x69,0x6C,0x6C,0x2C,0x20,0x77,0x68,0x65,0x72,0x65, +0x0A,0x74,0x68,0x65,0x20,0x41,0x72,0x65,0x6F,0x70,0x61,0x67,0x75,0x73,0x20,0x73, +0x61,0x74,0x20,0x69,0x6E,0x20,0x61,0x6E,0x63,0x69,0x65,0x6E,0x74,0x20,0x74,0x69, +0x6D,0x65,0x73,0x20,0x61,0x6E,0x64,0x20,0x77,0x68,0x65,0x72,0x65,0x20,0x53,0x74, +0x2E,0x20,0x50,0x61,0x75,0x6C,0x20,0x64,0x65,0x66,0x69,0x6E,0x65,0x64,0x20,0x68, +0x69,0x73,0x0A,0x70,0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,0x2C,0x20,0x61,0x6E,0x64, +0x20,0x62,0x65,0x6C,0x6F,0x77,0x20,0x77,0x61,0x73,0x20,0x74,0x68,0x65,0x20,0x6D, +0x61,0x72,0x6B,0x65,0x74,0x2D,0x70,0x6C,0x61,0x63,0x65,0x20,0x77,0x68,0x65,0x72, +0x65,0x20,0x68,0x65,0x20,0x22,0x64,0x69,0x73,0x70,0x75,0x74,0x65,0x64,0x20,0x64, +0x61,0x69,0x6C,0x79,0x22,0x20,0x77,0x69,0x74,0x68,0x0A,0x74,0x68,0x65,0x20,0x67, +0x6F,0x73,0x73,0x69,0x70,0x2D,0x6C,0x6F,0x76,0x69,0x6E,0x67,0x20,0x41,0x74,0x68, +0x65,0x6E,0x69,0x61,0x6E,0x73,0x2E,0x20,0x20,0x57,0x65,0x20,0x63,0x6C,0x69,0x6D, +0x62,0x65,0x64,0x20,0x74,0x68,0x65,0x20,0x73,0x74,0x6F,0x6E,0x65,0x20,0x73,0x74, +0x65,0x70,0x73,0x20,0x53,0x74,0x2E,0x20,0x50,0x61,0x75,0x6C,0x0A,0x61,0x73,0x63, +0x65,0x6E,0x64,0x65,0x64,0x2C,0x20,0x61,0x6E,0x64,0x20,0x73,0x74,0x6F,0x6F,0x64, +0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x73,0x71,0x75,0x61,0x72,0x65,0x2D,0x63, +0x75,0x74,0x20,0x70,0x6C,0x61,0x63,0x65,0x20,0x68,0x65,0x20,0x73,0x74,0x6F,0x6F, +0x64,0x20,0x69,0x6E,0x2C,0x20,0x61,0x6E,0x64,0x20,0x74,0x72,0x69,0x65,0x64,0x20, +0x74,0x6F,0x0A,0x72,0x65,0x63,0x6F,0x6C,0x6C,0x65,0x63,0x74,0x20,0x74,0x68,0x65, +0x20,0x42,0x69,0x62,0x6C,0x65,0x20,0x61,0x63,0x63,0x6F,0x75,0x6E,0x74,0x20,0x6F, +0x66,0x20,0x74,0x68,0x65,0x20,0x6D,0x61,0x74,0x74,0x65,0x72,0x2D,0x2D,0x62,0x75, +0x74,0x20,0x66,0x6F,0x72,0x20,0x63,0x65,0x72,0x74,0x61,0x69,0x6E,0x20,0x72,0x65, +0x61,0x73,0x6F,0x6E,0x73,0x2C,0x20,0x49,0x0A,0x63,0x6F,0x75,0x6C,0x64,0x20,0x6E, +0x6F,0x74,0x20,0x72,0x65,0x63,0x61,0x6C,0x6C,0x20,0x74,0x68,0x65,0x20,0x77,0x6F, +0x72,0x64,0x73,0x2E,0x20,0x20,0x49,0x20,0x68,0x61,0x76,0x65,0x20,0x66,0x6F,0x75, +0x6E,0x64,0x20,0x74,0x68,0x65,0x6D,0x20,0x73,0x69,0x6E,0x63,0x65,0x3A,0x0A,0x0A, +0x20,0x20,0x20,0x20,0x20,0x22,0x4E,0x6F,0x77,0x20,0x77,0x68,0x69,0x6C,0x65,0x20, +0x50,0x61,0x75,0x6C,0x20,0x77,0x61,0x69,0x74,0x65,0x64,0x20,0x66,0x6F,0x72,0x20, +0x74,0x68,0x65,0x6D,0x20,0x61,0x74,0x20,0x41,0x74,0x68,0x65,0x6E,0x73,0x2C,0x20, +0x68,0x69,0x73,0x20,0x73,0x70,0x69,0x72,0x69,0x74,0x20,0x77,0x61,0x73,0x20,0x73, +0x74,0x69,0x72,0x72,0x65,0x64,0x20,0x69,0x6E,0x0A,0x20,0x20,0x20,0x20,0x20,0x68, +0x69,0x6D,0x2C,0x20,0x77,0x68,0x65,0x6E,0x20,0x68,0x65,0x20,0x73,0x61,0x77,0x20, +0x74,0x68,0x65,0x20,0x63,0x69,0x74,0x79,0x20,0x77,0x68,0x6F,0x6C,0x6C,0x79,0x20, +0x67,0x69,0x76,0x65,0x6E,0x20,0x75,0x70,0x20,0x74,0x6F,0x20,0x69,0x64,0x6F,0x6C, +0x61,0x74,0x72,0x79,0x2E,0x20,0x20,0x54,0x68,0x65,0x72,0x65,0x66,0x6F,0x72,0x65, +0x0A,0x20,0x20,0x20,0x20,0x20,0x64,0x69,0x73,0x70,0x75,0x74,0x65,0x64,0x20,0x68, +0x65,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x73,0x79,0x6E,0x61,0x67,0x6F,0x67, +0x75,0x65,0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x68,0x65,0x20,0x4A,0x65,0x77,0x73, +0x2C,0x20,0x61,0x6E,0x64,0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x68,0x65,0x20,0x64, +0x65,0x76,0x6F,0x75,0x74,0x0A,0x20,0x20,0x20,0x20,0x20,0x70,0x65,0x72,0x73,0x6F, +0x6E,0x73,0x2C,0x20,0x61,0x6E,0x64,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x6D, +0x61,0x72,0x6B,0x65,0x74,0x20,0x64,0x61,0x69,0x6C,0x79,0x20,0x77,0x69,0x74,0x68, +0x20,0x74,0x68,0x65,0x6D,0x20,0x74,0x68,0x61,0x74,0x20,0x6D,0x65,0x74,0x20,0x77, +0x69,0x74,0x68,0x20,0x68,0x69,0x6D,0x2E,0x0A,0x20,0x20,0x20,0x20,0x20,0x20,0x20, +0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20, +0x20,0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20, +0x2A,0x20,0x2A,0x0A,0x20,0x20,0x20,0x20,0x20,0x22,0x41,0x6E,0x64,0x20,0x74,0x68, +0x65,0x79,0x20,0x74,0x6F,0x6F,0x6B,0x20,0x68,0x69,0x6D,0x20,0x61,0x6E,0x64,0x20, +0x62,0x72,0x6F,0x75,0x67,0x68,0x74,0x20,0x68,0x69,0x6D,0x20,0x75,0x6E,0x74,0x6F, +0x20,0x41,0x72,0x65,0x6F,0x70,0x61,0x67,0x75,0x73,0x2C,0x20,0x73,0x61,0x79,0x69, +0x6E,0x67,0x2C,0x20,0x4D,0x61,0x79,0x20,0x77,0x65,0x0A,0x20,0x20,0x20,0x20,0x20, +0x6B,0x6E,0x6F,0x77,0x20,0x77,0x68,0x61,0x74,0x20,0x74,0x68,0x69,0x73,0x20,0x6E, +0x65,0x77,0x20,0x64,0x6F,0x63,0x74,0x72,0x69,0x6E,0x65,0x20,0x77,0x68,0x65,0x72, +0x65,0x6F,0x66,0x20,0x74,0x68,0x6F,0x75,0x20,0x73,0x70,0x65,0x61,0x6B,0x65,0x73, +0x74,0x20,0x69,0x73,0x3F,0x0A,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20, +0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x2A, +0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20,0x2A, +0x0A,0x20,0x20,0x20,0x20,0x20,0x22,0x54,0x68,0x65,0x6E,0x20,0x50,0x61,0x75,0x6C, +0x20,0x73,0x74,0x6F,0x6F,0x64,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x6D,0x69, +0x64,0x73,0x74,0x20,0x6F,0x66,0x20,0x4D,0x61,0x72,0x73,0x20,0x68,0x69,0x6C,0x6C, +0x2C,0x20,0x61,0x6E,0x64,0x20,0x73,0x61,0x69,0x64,0x2C,0x20,0x59,0x65,0x20,0x6D, +0x65,0x6E,0x20,0x6F,0x66,0x0A,0x20,0x20,0x20,0x20,0x20,0x41,0x74,0x68,0x65,0x6E, +0x73,0x2C,0x20,0x49,0x20,0x70,0x65,0x72,0x63,0x65,0x69,0x76,0x65,0x20,0x74,0x68, +0x61,0x74,0x20,0x69,0x6E,0x20,0x61,0x6C,0x6C,0x20,0x74,0x68,0x69,0x6E,0x67,0x73, +0x20,0x79,0x65,0x20,0x61,0x72,0x65,0x20,0x74,0x6F,0x6F,0x20,0x73,0x75,0x70,0x65, +0x72,0x73,0x74,0x69,0x74,0x69,0x6F,0x75,0x73,0x3B,0x20,0x46,0x6F,0x72,0x0A,0x20, +0x20,0x20,0x20,0x20,0x61,0x73,0x20,0x49,0x20,0x70,0x61,0x73,0x73,0x65,0x64,0x20, +0x62,0x79,0x20,0x61,0x6E,0x64,0x20,0x62,0x65,0x68,0x65,0x6C,0x64,0x20,0x79,0x6F, +0x75,0x72,0x20,0x64,0x65,0x76,0x6F,0x74,0x69,0x6F,0x6E,0x73,0x2C,0x20,0x49,0x20, +0x66,0x6F,0x75,0x6E,0x64,0x20,0x61,0x6E,0x20,0x61,0x6C,0x74,0x61,0x72,0x20,0x77, +0x69,0x74,0x68,0x20,0x74,0x68,0x69,0x73,0x0A,0x20,0x20,0x20,0x20,0x20,0x69,0x6E, +0x73,0x63,0x72,0x69,0x70,0x74,0x69,0x6F,0x6E,0x3A,0x20,0x54,0x6F,0x20,0x54,0x48, +0x45,0x20,0x55,0x4E,0x4B,0x4E,0x4F,0x57,0x4E,0x20,0x47,0x4F,0x44,0x2E,0x20,0x20, +0x57,0x68,0x6F,0x6D,0x2C,0x20,0x74,0x68,0x65,0x72,0x65,0x66,0x6F,0x72,0x65,0x2C, +0x20,0x79,0x65,0x20,0x69,0x67,0x6E,0x6F,0x72,0x61,0x6E,0x74,0x6C,0x79,0x0A,0x20, +0x20,0x20,0x20,0x20,0x77,0x6F,0x72,0x73,0x68,0x69,0x70,0x2C,0x20,0x68,0x69,0x6D, +0x20,0x64,0x65,0x63,0x6C,0x61,0x72,0x65,0x20,0x49,0x20,0x75,0x6E,0x74,0x6F,0x20, +0x79,0x6F,0x75,0x2E,0x22,0x2D,0x2D,0x41,0x63,0x74,0x73,0x2C,0x20,0x63,0x68,0x2E, +0x20,0x78,0x76,0x69,0x69,0x2E,0x22,0x0A,0x0A,0x49,0x74,0x20,0x6F,0x63,0x63,0x75, +0x72,0x72,0x65,0x64,0x20,0x74,0x6F,0x20,0x75,0x73,0x2C,0x20,0x61,0x66,0x74,0x65, +0x72,0x20,0x61,0x20,0x77,0x68,0x69,0x6C,0x65,0x2C,0x20,0x74,0x68,0x61,0x74,0x20, +0x69,0x66,0x20,0x77,0x65,0x20,0x77,0x61,0x6E,0x74,0x65,0x64,0x20,0x74,0x6F,0x20, +0x67,0x65,0x74,0x20,0x68,0x6F,0x6D,0x65,0x20,0x62,0x65,0x66,0x6F,0x72,0x65,0x0A, +0x64,0x61,0x79,0x6C,0x69,0x67,0x68,0x74,0x20,0x62,0x65,0x74,0x72,0x61,0x79,0x65, +0x64,0x20,0x75,0x73,0x2C,0x20,0x77,0x65,0x20,0x68,0x61,0x64,0x20,0x62,0x65,0x74, +0x74,0x65,0x72,0x20,0x62,0x65,0x20,0x6D,0x6F,0x76,0x69,0x6E,0x67,0x2E,0x20,0x20, +0x53,0x6F,0x20,0x77,0x65,0x20,0x68,0x75,0x72,0x72,0x69,0x65,0x64,0x20,0x61,0x77, +0x61,0x79,0x2E,0x20,0x20,0x57,0x68,0x65,0x6E,0x0A,0x66,0x61,0x72,0x20,0x6F,0x6E, +0x20,0x6F,0x75,0x72,0x20,0x72,0x6F,0x61,0x64,0x2C,0x20,0x77,0x65,0x20,0x68,0x61, +0x64,0x20,0x61,0x20,0x70,0x61,0x72,0x74,0x69,0x6E,0x67,0x20,0x76,0x69,0x65,0x77, +0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x50,0x61,0x72,0x74,0x68,0x65,0x6E,0x6F, +0x6E,0x2C,0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x68,0x65,0x0A,0x6D,0x6F,0x6F,0x6E, +0x6C,0x69,0x67,0x68,0x74,0x20,0x73,0x74,0x72,0x65,0x61,0x6D,0x69,0x6E,0x67,0x20, +0x74,0x68,0x72,0x6F,0x75,0x67,0x68,0x20,0x69,0x74,0x73,0x20,0x6F,0x70,0x65,0x6E, +0x20,0x63,0x6F,0x6C,0x6F,0x6E,0x6E,0x61,0x64,0x65,0x73,0x20,0x61,0x6E,0x64,0x20, +0x74,0x6F,0x75,0x63,0x68,0x69,0x6E,0x67,0x20,0x69,0x74,0x73,0x20,0x63,0x61,0x70, +0x69,0x74,0x61,0x6C,0x73,0x0A,0x77,0x69,0x74,0x68,0x20,0x73,0x69,0x6C,0x76,0x65, +0x72,0x2E,0x20,0x20,0x41,0x73,0x20,0x69,0x74,0x20,0x6C,0x6F,0x6F,0x6B,0x65,0x64, +0x20,0x74,0x68,0x65,0x6E,0x2C,0x20,0x73,0x6F,0x6C,0x65,0x6D,0x6E,0x2C,0x20,0x67, +0x72,0x61,0x6E,0x64,0x2C,0x20,0x61,0x6E,0x64,0x20,0x62,0x65,0x61,0x75,0x74,0x69, +0x66,0x75,0x6C,0x20,0x69,0x74,0x20,0x77,0x69,0x6C,0x6C,0x0A,0x61,0x6C,0x77,0x61, +0x79,0x73,0x20,0x72,0x65,0x6D,0x61,0x69,0x6E,0x20,0x69,0x6E,0x20,0x6F,0x75,0x72, +0x20,0x6D,0x65,0x6D,0x6F,0x72,0x69,0x65,0x73,0x2E,0x0A,0x0A,0x41,0x73,0x20,0x77, +0x65,0x20,0x6D,0x61,0x72,0x63,0x68,0x65,0x64,0x20,0x61,0x6C,0x6F,0x6E,0x67,0x2C, +0x20,0x77,0x65,0x20,0x62,0x65,0x67,0x61,0x6E,0x20,0x74,0x6F,0x20,0x67,0x65,0x74, +0x20,0x6F,0x76,0x65,0x72,0x20,0x6F,0x75,0x72,0x20,0x66,0x65,0x61,0x72,0x73,0x2C, +0x20,0x61,0x6E,0x64,0x20,0x63,0x65,0x61,0x73,0x65,0x64,0x20,0x74,0x6F,0x20,0x63, +0x61,0x72,0x65,0x0A,0x6D,0x75,0x63,0x68,0x20,0x61,0x62,0x6F,0x75,0x74,0x20,0x71, +0x75,0x61,0x72,0x61,0x6E,0x74,0x69,0x6E,0x65,0x20,0x73,0x63,0x6F,0x75,0x74,0x73, +0x20,0x6F,0x72,0x20,0x61,0x6E,0x79,0x20,0x62,0x6F,0x64,0x79,0x20,0x65,0x6C,0x73, +0x65,0x2E,0x20,0x20,0x57,0x65,0x20,0x67,0x72,0x65,0x77,0x20,0x62,0x6F,0x6C,0x64, +0x20,0x61,0x6E,0x64,0x0A,0x72,0x65,0x63,0x6B,0x6C,0x65,0x73,0x73,0x3B,0x20,0x61, +0x6E,0x64,0x20,0x6F,0x6E,0x63,0x65,0x2C,0x20,0x69,0x6E,0x20,0x61,0x20,0x73,0x75, +0x64,0x64,0x65,0x6E,0x20,0x62,0x75,0x72,0x73,0x74,0x20,0x6F,0x66,0x20,0x63,0x6F, +0x75,0x72,0x61,0x67,0x65,0x2C,0x20,0x49,0x20,0x65,0x76,0x65,0x6E,0x20,0x74,0x68, +0x72,0x65,0x77,0x20,0x61,0x20,0x73,0x74,0x6F,0x6E,0x65,0x20,0x61,0x74,0x0A,0x61, +0x20,0x64,0x6F,0x67,0x2E,0x20,0x20,0x49,0x74,0x20,0x77,0x61,0x73,0x20,0x61,0x20, +0x70,0x6C,0x65,0x61,0x73,0x61,0x6E,0x74,0x20,0x72,0x65,0x66,0x6C,0x65,0x63,0x74, +0x69,0x6F,0x6E,0x2C,0x20,0x74,0x68,0x6F,0x75,0x67,0x68,0x2C,0x20,0x74,0x68,0x61, +0x74,0x20,0x49,0x20,0x64,0x69,0x64,0x20,0x6E,0x6F,0x74,0x20,0x68,0x69,0x74,0x20, +0x68,0x69,0x6D,0x2C,0x0A,0x62,0x65,0x63,0x61,0x75,0x73,0x65,0x20,0x68,0x69,0x73, +0x20,0x6D,0x61,0x73,0x74,0x65,0x72,0x20,0x6D,0x69,0x67,0x68,0x74,0x20,0x6A,0x75, +0x73,0x74,0x20,0x70,0x6F,0x73,0x73,0x69,0x62,0x6C,0x79,0x20,0x68,0x61,0x76,0x65, +0x20,0x62,0x65,0x65,0x6E,0x20,0x61,0x20,0x70,0x6F,0x6C,0x69,0x63,0x65,0x6D,0x61, +0x6E,0x2E,0x20,0x20,0x49,0x6E,0x73,0x70,0x69,0x72,0x65,0x64,0x0A,0x62,0x79,0x20, +0x74,0x68,0x69,0x73,0x20,0x68,0x61,0x70,0x70,0x79,0x20,0x66,0x61,0x69,0x6C,0x75, +0x72,0x65,0x2C,0x20,0x6D,0x79,0x20,0x76,0x61,0x6C,0x6F,0x72,0x20,0x62,0x65,0x63, +0x61,0x6D,0x65,0x20,0x75,0x74,0x74,0x65,0x72,0x6C,0x79,0x20,0x75,0x6E,0x63,0x6F, +0x6E,0x74,0x72,0x6F,0x6C,0x6C,0x61,0x62,0x6C,0x65,0x2C,0x20,0x61,0x6E,0x64,0x20, +0x61,0x74,0x0A,0x69,0x6E,0x74,0x65,0x72,0x76,0x61,0x6C,0x73,0x20,0x49,0x20,0x61, +0x62,0x73,0x6F,0x6C,0x75,0x74,0x65,0x6C,0x79,0x20,0x77,0x68,0x69,0x73,0x74,0x6C, +0x65,0x64,0x2C,0x20,0x74,0x68,0x6F,0x75,0x67,0x68,0x20,0x6F,0x6E,0x20,0x61,0x20, +0x6D,0x6F,0x64,0x65,0x72,0x61,0x74,0x65,0x20,0x6B,0x65,0x79,0x2E,0x20,0x20,0x42, +0x75,0x74,0x20,0x62,0x6F,0x6C,0x64,0x6E,0x65,0x73,0x73,0x0A,0x62,0x72,0x65,0x65, +0x64,0x73,0x20,0x62,0x6F,0x6C,0x64,0x6E,0x65,0x73,0x73,0x2C,0x20,0x61,0x6E,0x64, +0x20,0x73,0x68,0x6F,0x72,0x74,0x6C,0x79,0x20,0x49,0x20,0x70,0x6C,0x75,0x6E,0x67, +0x65,0x64,0x20,0x69,0x6E,0x74,0x6F,0x20,0x61,0x20,0x56,0x69,0x6E,0x65,0x79,0x61, +0x72,0x64,0x2C,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x66,0x75,0x6C,0x6C,0x20, +0x6C,0x69,0x67,0x68,0x74,0x0A,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x6D,0x6F,0x6F, +0x6E,0x2C,0x20,0x61,0x6E,0x64,0x20,0x63,0x61,0x70,0x74,0x75,0x72,0x65,0x64,0x20, +0x61,0x20,0x67,0x61,0x6C,0x6C,0x6F,0x6E,0x20,0x6F,0x66,0x20,0x73,0x75,0x70,0x65, +0x72,0x62,0x20,0x67,0x72,0x61,0x70,0x65,0x73,0x2C,0x20,0x6E,0x6F,0x74,0x20,0x65, +0x76,0x65,0x6E,0x20,0x6D,0x69,0x6E,0x64,0x69,0x6E,0x67,0x20,0x74,0x68,0x65,0x0A, +0x70,0x72,0x65,0x73,0x65,0x6E,0x63,0x65,0x20,0x6F,0x66,0x20,0x61,0x20,0x70,0x65, +0x61,0x73,0x61,0x6E,0x74,0x20,0x77,0x68,0x6F,0x20,0x72,0x6F,0x64,0x65,0x20,0x62, +0x79,0x20,0x6F,0x6E,0x20,0x61,0x20,0x6D,0x75,0x6C,0x65,0x2E,0x20,0x20,0x44,0x65, +0x6E,0x6E,0x79,0x20,0x61,0x6E,0x64,0x20,0x42,0x69,0x72,0x63,0x68,0x20,0x66,0x6F, +0x6C,0x6C,0x6F,0x77,0x65,0x64,0x20,0x6D,0x79,0x0A,0x65,0x78,0x61,0x6D,0x70,0x6C, +0x65,0x2E,0x0A,0x0A,0x4E,0x6F,0x77,0x20,0x49,0x20,0x68,0x61,0x64,0x20,0x67,0x72, +0x61,0x70,0x65,0x73,0x20,0x65,0x6E,0x6F,0x75,0x67,0x68,0x20,0x66,0x6F,0x72,0x20, +0x61,0x20,0x64,0x6F,0x7A,0x65,0x6E,0x2C,0x20,0x62,0x75,0x74,0x20,0x74,0x68,0x65, +0x6E,0x20,0x4A,0x61,0x63,0x6B,0x73,0x6F,0x6E,0x20,0x77,0x61,0x73,0x20,0x61,0x6C, +0x6C,0x20,0x73,0x77,0x6F,0x6C,0x6C,0x65,0x6E,0x20,0x75,0x70,0x0A,0x77,0x69,0x74, +0x68,0x20,0x63,0x6F,0x75,0x72,0x61,0x67,0x65,0x2C,0x20,0x74,0x6F,0x6F,0x2C,0x20, +0x61,0x6E,0x64,0x20,0x68,0x65,0x20,0x77,0x61,0x73,0x20,0x6F,0x62,0x6C,0x69,0x67, +0x65,0x64,0x20,0x74,0x6F,0x20,0x65,0x6E,0x74,0x65,0x72,0x20,0x61,0x20,0x76,0x69, +0x6E,0x65,0x79,0x61,0x72,0x64,0x20,0x70,0x72,0x65,0x73,0x65,0x6E,0x74,0x6C,0x79, +0x2E,0x20,0x20,0x54,0x68,0x65,0x0A,0x66,0x69,0x72,0x73,0x74,0x20,0x62,0x75,0x6E, +0x63,0x68,0x20,0x68,0x65,0x20,0x73,0x65,0x69,0x7A,0x65,0x64,0x20,0x62,0x72,0x6F, +0x75,0x67,0x68,0x74,0x20,0x74,0x72,0x6F,0x75,0x62,0x6C,0x65,0x2E,0x20,0x20,0x41, +0x20,0x66,0x72,0x6F,0x77,0x73,0x79,0x2C,0x20,0x62,0x65,0x61,0x72,0x64,0x65,0x64, +0x20,0x62,0x72,0x69,0x67,0x61,0x6E,0x64,0x20,0x73,0x70,0x72,0x61,0x6E,0x67,0x0A, +0x69,0x6E,0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x72,0x6F,0x61,0x64,0x20,0x77,0x69, +0x74,0x68,0x20,0x61,0x20,0x73,0x68,0x6F,0x75,0x74,0x2C,0x20,0x61,0x6E,0x64,0x20, +0x66,0x6C,0x6F,0x75,0x72,0x69,0x73,0x68,0x65,0x64,0x20,0x61,0x20,0x6D,0x75,0x73, +0x6B,0x65,0x74,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x6C,0x69,0x67,0x68,0x74, +0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x0A,0x6D,0x6F,0x6F,0x6E,0x21,0x20,0x20,0x57, +0x65,0x20,0x73,0x69,0x64,0x6C,0x65,0x64,0x20,0x74,0x6F,0x77,0x61,0x72,0x64,0x20, +0x74,0x68,0x65,0x20,0x50,0x69,0x72,0x61,0x65,0x75,0x73,0x2D,0x2D,0x6E,0x6F,0x74, +0x20,0x72,0x75,0x6E,0x6E,0x69,0x6E,0x67,0x20,0x79,0x6F,0x75,0x20,0x75,0x6E,0x64, +0x65,0x72,0x73,0x74,0x61,0x6E,0x64,0x2C,0x20,0x62,0x75,0x74,0x20,0x6F,0x6E,0x6C, +0x79,0x0A,0x61,0x64,0x76,0x61,0x6E,0x63,0x69,0x6E,0x67,0x20,0x77,0x69,0x74,0x68, +0x20,0x63,0x65,0x6C,0x65,0x72,0x69,0x74,0x79,0x2E,0x20,0x20,0x54,0x68,0x65,0x20, +0x62,0x72,0x69,0x67,0x61,0x6E,0x64,0x20,0x73,0x68,0x6F,0x75,0x74,0x65,0x64,0x20, +0x61,0x67,0x61,0x69,0x6E,0x2C,0x20,0x62,0x75,0x74,0x20,0x73,0x74,0x69,0x6C,0x6C, +0x20,0x77,0x65,0x0A,0x61,0x64,0x76,0x61,0x6E,0x63,0x65,0x64,0x2E,0x20,0x20,0x49, +0x74,0x20,0x77,0x61,0x73,0x20,0x67,0x65,0x74,0x74,0x69,0x6E,0x67,0x20,0x6C,0x61, +0x74,0x65,0x2C,0x20,0x61,0x6E,0x64,0x20,0x77,0x65,0x20,0x68,0x61,0x64,0x20,0x6E, +0x6F,0x20,0x74,0x69,0x6D,0x65,0x20,0x74,0x6F,0x20,0x66,0x6F,0x6F,0x6C,0x20,0x61, +0x77,0x61,0x79,0x20,0x6F,0x6E,0x20,0x65,0x76,0x65,0x72,0x79,0x0A,0x61,0x73,0x73, +0x20,0x74,0x68,0x61,0x74,0x20,0x77,0x61,0x6E,0x74,0x65,0x64,0x20,0x74,0x6F,0x20, +0x64,0x72,0x69,0x76,0x65,0x6C,0x20,0x47,0x72,0x65,0x65,0x6B,0x20,0x70,0x6C,0x61, +0x74,0x69,0x74,0x75,0x64,0x65,0x73,0x20,0x74,0x6F,0x20,0x75,0x73,0x2E,0x20,0x20, +0x57,0x65,0x20,0x77,0x6F,0x75,0x6C,0x64,0x20,0x6A,0x75,0x73,0x74,0x20,0x61,0x73, +0x20,0x73,0x6F,0x6F,0x6E,0x0A,0x68,0x61,0x76,0x65,0x20,0x74,0x61,0x6C,0x6B,0x65, +0x64,0x20,0x77,0x69,0x74,0x68,0x20,0x68,0x69,0x6D,0x20,0x61,0x73,0x20,0x6E,0x6F, +0x74,0x20,0x69,0x66,0x20,0x77,0x65,0x20,0x68,0x61,0x64,0x20,0x6E,0x6F,0x74,0x20, +0x62,0x65,0x65,0x6E,0x20,0x69,0x6E,0x20,0x61,0x20,0x68,0x75,0x72,0x72,0x79,0x2E, +0x20,0x20,0x50,0x72,0x65,0x73,0x65,0x6E,0x74,0x6C,0x79,0x0A,0x44,0x65,0x6E,0x6E, +0x79,0x20,0x73,0x61,0x69,0x64,0x2C,0x20,0x22,0x54,0x68,0x6F,0x73,0x65,0x20,0x66, +0x65,0x6C,0x6C,0x6F,0x77,0x73,0x20,0x61,0x72,0x65,0x20,0x66,0x6F,0x6C,0x6C,0x6F, +0x77,0x69,0x6E,0x67,0x20,0x75,0x73,0x21,0x22,0x0A,0x0A,0x57,0x65,0x20,0x74,0x75, +0x72,0x6E,0x65,0x64,0x2C,0x20,0x61,0x6E,0x64,0x2C,0x20,0x73,0x75,0x72,0x65,0x20, +0x65,0x6E,0x6F,0x75,0x67,0x68,0x2C,0x20,0x74,0x68,0x65,0x72,0x65,0x20,0x74,0x68, +0x65,0x79,0x20,0x77,0x65,0x72,0x65,0x2D,0x2D,0x74,0x68,0x72,0x65,0x65,0x20,0x66, +0x61,0x6E,0x74,0x61,0x73,0x74,0x69,0x63,0x20,0x70,0x69,0x72,0x61,0x74,0x65,0x73, +0x0A,0x61,0x72,0x6D,0x65,0x64,0x20,0x77,0x69,0x74,0x68,0x20,0x67,0x75,0x6E,0x73, +0x2E,0x20,0x20,0x57,0x65,0x20,0x73,0x6C,0x61,0x63,0x6B,0x65,0x6E,0x65,0x64,0x20, +0x6F,0x75,0x72,0x20,0x70,0x61,0x63,0x65,0x20,0x74,0x6F,0x20,0x6C,0x65,0x74,0x20, +0x74,0x68,0x65,0x6D,0x20,0x63,0x6F,0x6D,0x65,0x20,0x75,0x70,0x2C,0x20,0x61,0x6E, +0x64,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x0A,0x6D,0x65,0x61,0x6E,0x74,0x69,0x6D, +0x65,0x20,0x49,0x20,0x67,0x6F,0x74,0x20,0x6F,0x75,0x74,0x20,0x6D,0x79,0x20,0x63, +0x61,0x72,0x67,0x6F,0x20,0x6F,0x66,0x20,0x67,0x72,0x61,0x70,0x65,0x73,0x20,0x61, +0x6E,0x64,0x20,0x64,0x72,0x6F,0x70,0x70,0x65,0x64,0x20,0x74,0x68,0x65,0x6D,0x20, +0x66,0x69,0x72,0x6D,0x6C,0x79,0x20,0x62,0x75,0x74,0x0A,0x72,0x65,0x6C,0x75,0x63, +0x74,0x61,0x6E,0x74,0x6C,0x79,0x20,0x69,0x6E,0x74,0x6F,0x20,0x74,0x68,0x65,0x20, +0x73,0x68,0x61,0x64,0x6F,0x77,0x73,0x20,0x62,0x79,0x20,0x74,0x68,0x65,0x20,0x77, +0x61,0x79,0x73,0x69,0x64,0x65,0x2E,0x20,0x20,0x42,0x75,0x74,0x20,0x49,0x20,0x77, +0x61,0x73,0x20,0x6E,0x6F,0x74,0x20,0x61,0x66,0x72,0x61,0x69,0x64,0x2E,0x20,0x20, +0x49,0x0A,0x6F,0x6E,0x6C,0x79,0x20,0x66,0x65,0x6C,0x74,0x20,0x74,0x68,0x61,0x74, +0x20,0x69,0x74,0x20,0x77,0x61,0x73,0x20,0x6E,0x6F,0x74,0x20,0x72,0x69,0x67,0x68, +0x74,0x20,0x74,0x6F,0x20,0x73,0x74,0x65,0x61,0x6C,0x20,0x67,0x72,0x61,0x70,0x65, +0x73,0x2E,0x20,0x20,0x41,0x6E,0x64,0x20,0x61,0x6C,0x6C,0x20,0x74,0x68,0x65,0x20, +0x6D,0x6F,0x72,0x65,0x20,0x73,0x6F,0x0A,0x77,0x68,0x65,0x6E,0x20,0x74,0x68,0x65, +0x20,0x6F,0x77,0x6E,0x65,0x72,0x20,0x77,0x61,0x73,0x20,0x61,0x72,0x6F,0x75,0x6E, +0x64,0x2D,0x2D,0x61,0x6E,0x64,0x20,0x6E,0x6F,0x74,0x20,0x6F,0x6E,0x6C,0x79,0x20, +0x61,0x72,0x6F,0x75,0x6E,0x64,0x2C,0x20,0x62,0x75,0x74,0x20,0x77,0x69,0x74,0x68, +0x20,0x68,0x69,0x73,0x20,0x66,0x72,0x69,0x65,0x6E,0x64,0x73,0x0A,0x61,0x72,0x6F, +0x75,0x6E,0x64,0x20,0x61,0x6C,0x73,0x6F,0x2E,0x20,0x20,0x54,0x68,0x65,0x20,0x76, +0x69,0x6C,0x6C,0x61,0x69,0x6E,0x73,0x20,0x63,0x61,0x6D,0x65,0x20,0x75,0x70,0x20, +0x61,0x6E,0x64,0x20,0x73,0x65,0x61,0x72,0x63,0x68,0x65,0x64,0x20,0x61,0x20,0x62, +0x75,0x6E,0x64,0x6C,0x65,0x20,0x44,0x72,0x2E,0x20,0x42,0x69,0x72,0x63,0x68,0x20, +0x68,0x61,0x64,0x20,0x69,0x6E,0x0A,0x68,0x69,0x73,0x20,0x68,0x61,0x6E,0x64,0x2C, +0x20,0x61,0x6E,0x64,0x20,0x73,0x63,0x6F,0x77,0x6C,0x65,0x64,0x20,0x75,0x70,0x6F, +0x6E,0x20,0x68,0x69,0x6D,0x20,0x77,0x68,0x65,0x6E,0x20,0x74,0x68,0x65,0x79,0x20, +0x66,0x6F,0x75,0x6E,0x64,0x20,0x69,0x74,0x20,0x68,0x61,0x64,0x20,0x6E,0x6F,0x74, +0x68,0x69,0x6E,0x67,0x20,0x69,0x6E,0x20,0x69,0x74,0x20,0x62,0x75,0x74,0x0A,0x73, +0x6F,0x6D,0x65,0x20,0x68,0x6F,0x6C,0x79,0x20,0x72,0x6F,0x63,0x6B,0x73,0x20,0x66, +0x72,0x6F,0x6D,0x20,0x4D,0x61,0x72,0x73,0x20,0x48,0x69,0x6C,0x6C,0x2C,0x20,0x61, +0x6E,0x64,0x20,0x74,0x68,0x65,0x73,0x65,0x20,0x77,0x65,0x72,0x65,0x20,0x6E,0x6F, +0x74,0x20,0x63,0x6F,0x6E,0x74,0x72,0x61,0x62,0x61,0x6E,0x64,0x2E,0x20,0x20,0x54, +0x68,0x65,0x79,0x0A,0x65,0x76,0x69,0x64,0x65,0x6E,0x74,0x6C,0x79,0x20,0x73,0x75, +0x73,0x70,0x65,0x63,0x74,0x65,0x64,0x20,0x68,0x69,0x6D,0x20,0x6F,0x66,0x20,0x70, +0x6C,0x61,0x79,0x69,0x6E,0x67,0x20,0x73,0x6F,0x6D,0x65,0x20,0x77,0x72,0x65,0x74, +0x63,0x68,0x65,0x64,0x20,0x66,0x72,0x61,0x75,0x64,0x20,0x75,0x70,0x6F,0x6E,0x20, +0x74,0x68,0x65,0x6D,0x2C,0x20,0x61,0x6E,0x64,0x0A,0x73,0x65,0x65,0x6D,0x65,0x64, +0x20,0x68,0x61,0x6C,0x66,0x20,0x69,0x6E,0x63,0x6C,0x69,0x6E,0x65,0x64,0x20,0x74, +0x6F,0x20,0x73,0x63,0x61,0x6C,0x70,0x20,0x74,0x68,0x65,0x20,0x70,0x61,0x72,0x74, +0x79,0x2E,0x20,0x20,0x42,0x75,0x74,0x20,0x66,0x69,0x6E,0x61,0x6C,0x6C,0x79,0x20, +0x74,0x68,0x65,0x79,0x20,0x64,0x69,0x73,0x6D,0x69,0x73,0x73,0x65,0x64,0x20,0x75, +0x73,0x0A,0x77,0x69,0x74,0x68,0x20,0x61,0x20,0x77,0x61,0x72,0x6E,0x69,0x6E,0x67, +0x2C,0x20,0x63,0x6F,0x75,0x63,0x68,0x65,0x64,0x20,0x69,0x6E,0x20,0x65,0x78,0x63, +0x65,0x6C,0x6C,0x65,0x6E,0x74,0x20,0x47,0x72,0x65,0x65,0x6B,0x2C,0x20,0x49,0x20, +0x73,0x75,0x70,0x70,0x6F,0x73,0x65,0x2C,0x20,0x61,0x6E,0x64,0x20,0x64,0x72,0x6F, +0x70,0x70,0x65,0x64,0x0A,0x74,0x72,0x61,0x6E,0x71,0x75,0x69,0x6C,0x6C,0x79,0x20, +0x69,0x6E,0x20,0x6F,0x75,0x72,0x20,0x77,0x61,0x6B,0x65,0x2E,0x20,0x20,0x57,0x68, +0x65,0x6E,0x20,0x74,0x68,0x65,0x79,0x20,0x68,0x61,0x64,0x20,0x67,0x6F,0x6E,0x65, +0x20,0x74,0x68,0x72,0x65,0x65,0x20,0x68,0x75,0x6E,0x64,0x72,0x65,0x64,0x20,0x79, +0x61,0x72,0x64,0x73,0x20,0x74,0x68,0x65,0x79,0x0A,0x73,0x74,0x6F,0x70,0x70,0x65, +0x64,0x2C,0x20,0x61,0x6E,0x64,0x20,0x77,0x65,0x20,0x77,0x65,0x6E,0x74,0x20,0x6F, +0x6E,0x20,0x72,0x65,0x6A,0x6F,0x69,0x63,0x65,0x64,0x2E,0x20,0x20,0x42,0x75,0x74, +0x20,0x62,0x65,0x68,0x6F,0x6C,0x64,0x2C,0x20,0x61,0x6E,0x6F,0x74,0x68,0x65,0x72, +0x20,0x61,0x72,0x6D,0x65,0x64,0x20,0x72,0x61,0x73,0x63,0x61,0x6C,0x20,0x63,0x61, +0x6D,0x65,0x0A,0x6F,0x75,0x74,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x73,0x68, +0x61,0x64,0x6F,0x77,0x73,0x20,0x61,0x6E,0x64,0x20,0x74,0x6F,0x6F,0x6B,0x20,0x74, +0x68,0x65,0x69,0x72,0x20,0x70,0x6C,0x61,0x63,0x65,0x2C,0x20,0x61,0x6E,0x64,0x20, +0x66,0x6F,0x6C,0x6C,0x6F,0x77,0x65,0x64,0x20,0x75,0x73,0x20,0x74,0x77,0x6F,0x20, +0x68,0x75,0x6E,0x64,0x72,0x65,0x64,0x0A,0x79,0x61,0x72,0x64,0x73,0x2E,0x20,0x20, +0x54,0x68,0x65,0x6E,0x20,0x68,0x65,0x20,0x64,0x65,0x6C,0x69,0x76,0x65,0x72,0x65, +0x64,0x20,0x75,0x73,0x20,0x6F,0x76,0x65,0x72,0x20,0x74,0x6F,0x20,0x61,0x6E,0x6F, +0x74,0x68,0x65,0x72,0x20,0x6D,0x69,0x73,0x63,0x72,0x65,0x61,0x6E,0x74,0x2C,0x20, +0x77,0x68,0x6F,0x20,0x65,0x6D,0x65,0x72,0x67,0x65,0x64,0x20,0x66,0x72,0x6F,0x6D, +0x0A,0x73,0x6F,0x6D,0x65,0x20,0x6D,0x79,0x73,0x74,0x65,0x72,0x69,0x6F,0x75,0x73, +0x20,0x70,0x6C,0x61,0x63,0x65,0x2C,0x20,0x61,0x6E,0x64,0x20,0x68,0x65,0x20,0x69, +0x6E,0x20,0x74,0x75,0x72,0x6E,0x20,0x74,0x6F,0x20,0x61,0x6E,0x6F,0x74,0x68,0x65, +0x72,0x21,0x20,0x20,0x46,0x6F,0x72,0x20,0x61,0x20,0x6D,0x69,0x6C,0x65,0x20,0x61, +0x6E,0x64,0x20,0x61,0x20,0x68,0x61,0x6C,0x66,0x0A,0x6F,0x75,0x72,0x20,0x72,0x65, +0x61,0x72,0x20,0x77,0x61,0x73,0x20,0x67,0x75,0x61,0x72,0x64,0x65,0x64,0x20,0x61, +0x6C,0x6C,0x20,0x74,0x68,0x65,0x20,0x77,0x68,0x69,0x6C,0x65,0x20,0x62,0x79,0x20, +0x61,0x72,0x6D,0x65,0x64,0x20,0x6D,0x65,0x6E,0x2E,0x20,0x20,0x49,0x20,0x6E,0x65, +0x76,0x65,0x72,0x20,0x74,0x72,0x61,0x76,0x65,0x6C,0x65,0x64,0x20,0x69,0x6E,0x20, +0x73,0x6F,0x0A,0x6D,0x75,0x63,0x68,0x20,0x73,0x74,0x61,0x74,0x65,0x20,0x62,0x65, +0x66,0x6F,0x72,0x65,0x20,0x69,0x6E,0x20,0x61,0x6C,0x6C,0x20,0x6D,0x79,0x20,0x6C, +0x69,0x66,0x65,0x2E,0x0A,0x0A,0x49,0x74,0x20,0x77,0x61,0x73,0x20,0x61,0x20,0x67, +0x6F,0x6F,0x64,0x20,0x77,0x68,0x69,0x6C,0x65,0x20,0x61,0x66,0x74,0x65,0x72,0x20, +0x74,0x68,0x61,0x74,0x20,0x62,0x65,0x66,0x6F,0x72,0x65,0x20,0x77,0x65,0x20,0x76, +0x65,0x6E,0x74,0x75,0x72,0x65,0x64,0x20,0x74,0x6F,0x20,0x73,0x74,0x65,0x61,0x6C, +0x20,0x61,0x6E,0x79,0x20,0x6D,0x6F,0x72,0x65,0x0A,0x67,0x72,0x61,0x70,0x65,0x73, +0x2C,0x20,0x61,0x6E,0x64,0x20,0x77,0x68,0x65,0x6E,0x20,0x77,0x65,0x20,0x64,0x69, +0x64,0x20,0x77,0x65,0x20,0x73,0x74,0x69,0x72,0x72,0x65,0x64,0x20,0x75,0x70,0x20, +0x61,0x6E,0x6F,0x74,0x68,0x65,0x72,0x20,0x74,0x72,0x6F,0x75,0x62,0x6C,0x65,0x73, +0x6F,0x6D,0x65,0x20,0x62,0x72,0x69,0x67,0x61,0x6E,0x64,0x2C,0x20,0x61,0x6E,0x64, +0x0A,0x74,0x68,0x65,0x6E,0x20,0x77,0x65,0x20,0x63,0x65,0x61,0x73,0x65,0x64,0x20, +0x61,0x6C,0x6C,0x20,0x66,0x75,0x72,0x74,0x68,0x65,0x72,0x20,0x73,0x70,0x65,0x63, +0x75,0x6C,0x61,0x74,0x69,0x6F,0x6E,0x20,0x69,0x6E,0x20,0x74,0x68,0x61,0x74,0x20, +0x6C,0x69,0x6E,0x65,0x2E,0x20,0x20,0x49,0x20,0x73,0x75,0x70,0x70,0x6F,0x73,0x65, +0x20,0x74,0x68,0x61,0x74,0x0A,0x66,0x65,0x6C,0x6C,0x6F,0x77,0x20,0x74,0x68,0x61, +0x74,0x20,0x72,0x6F,0x64,0x65,0x20,0x62,0x79,0x20,0x6F,0x6E,0x20,0x74,0x68,0x65, +0x20,0x6D,0x75,0x6C,0x65,0x20,0x70,0x6F,0x73,0x74,0x65,0x64,0x20,0x61,0x6C,0x6C, +0x20,0x74,0x68,0x65,0x20,0x73,0x65,0x6E,0x74,0x69,0x6E,0x65,0x6C,0x73,0x2C,0x20, +0x66,0x72,0x6F,0x6D,0x20,0x41,0x74,0x68,0x65,0x6E,0x73,0x20,0x74,0x6F,0x0A,0x74, +0x68,0x65,0x20,0x50,0x69,0x72,0x61,0x65,0x75,0x73,0x2C,0x20,0x61,0x62,0x6F,0x75, +0x74,0x20,0x75,0x73,0x2E,0x0A,0x0A,0x45,0x76,0x65,0x72,0x79,0x20,0x66,0x69,0x65, +0x6C,0x64,0x20,0x6F,0x6E,0x20,0x74,0x68,0x61,0x74,0x20,0x6C,0x6F,0x6E,0x67,0x20, +0x72,0x6F,0x75,0x74,0x65,0x20,0x77,0x61,0x73,0x20,0x77,0x61,0x74,0x63,0x68,0x65, +0x64,0x20,0x62,0x79,0x20,0x61,0x6E,0x20,0x61,0x72,0x6D,0x65,0x64,0x20,0x73,0x65, +0x6E,0x74,0x69,0x6E,0x65,0x6C,0x2C,0x20,0x73,0x6F,0x6D,0x65,0x20,0x6F,0x66,0x0A, +0x77,0x68,0x6F,0x6D,0x20,0x68,0x61,0x64,0x20,0x66,0x61,0x6C,0x6C,0x65,0x6E,0x20, +0x61,0x73,0x6C,0x65,0x65,0x70,0x2C,0x20,0x6E,0x6F,0x20,0x64,0x6F,0x75,0x62,0x74, +0x2C,0x20,0x62,0x75,0x74,0x20,0x77,0x65,0x72,0x65,0x20,0x6F,0x6E,0x20,0x68,0x61, +0x6E,0x64,0x2C,0x20,0x6E,0x65,0x76,0x65,0x72,0x74,0x68,0x65,0x6C,0x65,0x73,0x73, +0x2E,0x20,0x20,0x54,0x68,0x69,0x73,0x0A,0x73,0x68,0x6F,0x77,0x73,0x20,0x77,0x68, +0x61,0x74,0x20,0x73,0x6F,0x72,0x74,0x20,0x6F,0x66,0x20,0x61,0x20,0x63,0x6F,0x75, +0x6E,0x74,0x72,0x79,0x20,0x6D,0x6F,0x64,0x65,0x72,0x6E,0x20,0x41,0x74,0x74,0x69, +0x63,0x61,0x20,0x69,0x73,0x2D,0x2D,0x61,0x20,0x63,0x6F,0x6D,0x6D,0x75,0x6E,0x69, +0x74,0x79,0x20,0x6F,0x66,0x0A,0x71,0x75,0x65,0x73,0x74,0x69,0x6F,0x6E,0x61,0x62, +0x6C,0x65,0x20,0x63,0x68,0x61,0x72,0x61,0x63,0x74,0x65,0x72,0x73,0x2E,0x20,0x20, +0x54,0x68,0x65,0x73,0x65,0x20,0x6D,0x65,0x6E,0x20,0x77,0x65,0x72,0x65,0x20,0x6E, +0x6F,0x74,0x20,0x74,0x68,0x65,0x72,0x65,0x20,0x74,0x6F,0x20,0x67,0x75,0x61,0x72, +0x64,0x20,0x74,0x68,0x65,0x69,0x72,0x0A,0x70,0x6F,0x73,0x73,0x65,0x73,0x73,0x69, +0x6F,0x6E,0x73,0x20,0x61,0x67,0x61,0x69,0x6E,0x73,0x74,0x20,0x73,0x74,0x72,0x61, +}; diff --git a/zlib/thumb/Makefile b/zlib/thumb/Makefile new file mode 100644 index 0000000..13a89b0 --- /dev/null +++ b/zlib/thumb/Makefile @@ -0,0 +1,87 @@ + +ARMGNU ?= arm-none-eabi + +COPS = -mthumb -Wall -O2 -nostdlib -nostartfiles -ffreestanding + +gcc : zlibtest.hex zlibtest.bin + +clean : + rm -f *.o + rm -f *.bin + rm -f *.hex + rm -f *.elf + rm -f *.list + rm -f *.img + rm -f *.bc + rm -f *.opt.s + +GOBJLIST = vectors.o zlibtest.o uart.o compress.o deflate.o zutil.o adler32.o crc32.o trees.o inflate.o uncompr.o inftrees.o inffast.o + +vectors.o : vectors.s + $(ARMGNU)-as vectors.s -o vectors.o + +zlibtest.o : zlibtest.c + $(ARMGNU)-gcc $(COPS) -c zlibtest.c -o zlibtest.o + +zlibtest.elf : memmap $(GOBJLIST) + $(ARMGNU)-ld $(GOBJLIST) -T memmap -o zlibtest.elf libgcc.a + $(ARMGNU)-objdump -D zlibtest.elf > zlibtest.list + +zlibtest.bin : zlibtest.elf + $(ARMGNU)-objcopy zlibtest.elf -O binary zlibtest.bin + +zlibtest.hex : zlibtest.elf + $(ARMGNU)-objcopy zlibtest.elf -O ihex zlibtest.hex + + +uart.o : uart.c + $(ARMGNU)-gcc $(COPS) -c uart.c -o uart.o + +compress.o : compress.c + $(ARMGNU)-gcc $(COPS) -c compress.c -o compress.o + +deflate.o : deflate.c + $(ARMGNU)-gcc $(COPS) -c deflate.c -o deflate.o + +zutil.o : zutil.c + $(ARMGNU)-gcc $(COPS) -c zutil.c -o zutil.o + +adler32.o : adler32.c + $(ARMGNU)-gcc $(COPS) -c adler32.c -o adler32.o + +crc32.o : crc32.c + $(ARMGNU)-gcc $(COPS) -c crc32.c -o crc32.o + +trees.o : trees.c + $(ARMGNU)-gcc $(COPS) -c trees.c -o trees.o + +inflate.o : inflate.c + $(ARMGNU)-gcc $(COPS) -c inflate.c -o inflate.o + +uncompr.o : uncompr.c + $(ARMGNU)-gcc $(COPS) -c uncompr.c -o uncompr.o + +inftrees.o : inftrees.c + $(ARMGNU)-gcc $(COPS) -c inftrees.c -o inftrees.o + +inffast.o : inffast.c + $(ARMGNU)-gcc $(COPS) -c inffast.c -o inffast.o + + + + + + + + + + + + + + + + + + + diff --git a/zlib/thumb/adler32.c b/zlib/thumb/adler32.c new file mode 100644 index 0000000..4531b2c --- /dev/null +++ b/zlib/thumb/adler32.c @@ -0,0 +1,179 @@ +/* adler32.c -- compute the Adler-32 checksum of a data stream + * Copyright (C) 1995-2011 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#include "zutil.h" + +#define local static + +local uInt adler32_combine_ OF((uInt adler1, uInt adler2, z_off64_t len2)); + +#define BASE 65521 /* largest prime smaller than 65536 */ +#define NMAX 5552 +/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ + +#define DO1(buf,i) {adler += (buf)[i]; sum2 += adler;} +#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); +#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); +#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); +#define DO16(buf) DO8(buf,0); DO8(buf,8); + +/* use NO_DIVIDE if your processor does not do division in hardware -- + try it both ways to see which is faster */ +#ifdef NO_DIVIDE +/* note that this assumes BASE is 65521, where 65536 % 65521 == 15 + (thank you to John Reiser for pointing this out) */ +# define CHOP(a) \ + do { \ + unsigned int tmp = a >> 16; \ + a &= 0xffffUL; \ + a += (tmp << 4) - tmp; \ + } while (0) +# define MOD28(a) \ + do { \ + CHOP(a); \ + if (a >= BASE) a -= BASE; \ + } while (0) +# define MOD(a) \ + do { \ + CHOP(a); \ + MOD28(a); \ + } while (0) +# define MOD63(a) \ + do { /* this assumes a is not negative */ \ + z_off64_t tmp = a >> 32; \ + a &= 0xffffffffL; \ + a += (tmp << 8) - (tmp << 5) + tmp; \ + tmp = a >> 16; \ + a &= 0xffffL; \ + a += (tmp << 4) - tmp; \ + tmp = a >> 16; \ + a &= 0xffffL; \ + a += (tmp << 4) - tmp; \ + if (a >= BASE) a -= BASE; \ + } while (0) +#else +# define MOD(a) a %= BASE +# define MOD28(a) a %= BASE +# define MOD63(a) a %= BASE +#endif + +/* ========================================================================= */ +uInt ZEXPORT adler32(adler, buf, len) + uInt adler; + const Bytef *buf; + uInt len; +{ + unsigned int sum2; + unsigned n; + + /* split Adler-32 into component sums */ + sum2 = (adler >> 16) & 0xffff; + adler &= 0xffff; + + /* in case user likes doing a byte at a time, keep it fast */ + if (len == 1) { + adler += buf[0]; + if (adler >= BASE) + adler -= BASE; + sum2 += adler; + if (sum2 >= BASE) + sum2 -= BASE; + return adler | (sum2 << 16); + } + + /* initial Adler-32 value (deferred check for len == 1 speed) */ + if (buf == Z_NULL) + return 1L; + + /* in case short lengths are provided, keep it somewhat fast */ + if (len < 16) { + while (len--) { + adler += *buf++; + sum2 += adler; + } + if (adler >= BASE) + adler -= BASE; + MOD28(sum2); /* only added so many BASE's */ + return adler | (sum2 << 16); + } + + /* do length NMAX blocks -- requires just one modulo operation */ + while (len >= NMAX) { + len -= NMAX; + n = NMAX / 16; /* NMAX is divisible by 16 */ + do { + DO16(buf); /* 16 sums unrolled */ + buf += 16; + } while (--n); + MOD(adler); + MOD(sum2); + } + + /* do remaining bytes (less than NMAX, still just one modulo) */ + if (len) { /* avoid modulos if none remaining */ + while (len >= 16) { + len -= 16; + DO16(buf); + buf += 16; + } + while (len--) { + adler += *buf++; + sum2 += adler; + } + MOD(adler); + MOD(sum2); + } + + /* return recombined sums */ + return adler | (sum2 << 16); +} + +/* ========================================================================= */ +local uInt adler32_combine_(adler1, adler2, len2) + uInt adler1; + uInt adler2; + z_off64_t len2; +{ + unsigned int sum1; + unsigned int sum2; + unsigned rem; + + /* for negative len, return invalid adler32 as a clue for debugging */ + if (len2 < 0) + return 0xffffffffUL; + + /* the derivation of this formula is left as an exercise for the reader */ + MOD63(len2); /* assumes len2 >= 0 */ + rem = (unsigned)len2; + sum1 = adler1 & 0xffff; + sum2 = rem * sum1; + MOD(sum2); + sum1 += (adler2 & 0xffff) + BASE - 1; + sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem; + if (sum1 >= BASE) sum1 -= BASE; + if (sum1 >= BASE) sum1 -= BASE; + if (sum2 >= (BASE << 1)) sum2 -= (BASE << 1); + if (sum2 >= BASE) sum2 -= BASE; + return sum1 | (sum2 << 16); +} + +/* ========================================================================= */ +uInt ZEXPORT adler32_combine(adler1, adler2, len2) + uInt adler1; + uInt adler2; + z_off_t len2; +{ + return adler32_combine_(adler1, adler2, len2); +} + +uInt ZEXPORT adler32_combine64(adler1, adler2, len2) + uInt adler1; + uInt adler2; + z_off64_t len2; +{ + return adler32_combine_(adler1, adler2, len2); +} diff --git a/zlib/thumb/compress.c b/zlib/thumb/compress.c new file mode 100644 index 0000000..0471550 --- /dev/null +++ b/zlib/thumb/compress.c @@ -0,0 +1,80 @@ +/* compress.c -- compress a memory buffer + * Copyright (C) 1995-2005 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#define ZLIB_INTERNAL +#include "zlib.h" + +/* =========================================================================== + 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. + + 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. +*/ +int ZEXPORT compress2 (dest, destLen, source, sourceLen, level) + Bytef *dest; + uIntf *destLen; + const Bytef *source; + uInt sourceLen; + int level; +{ + z_stream stream; + int err; + + stream.next_in = (Bytef*)source; + stream.avail_in = (uInt)sourceLen; +#ifdef MAXSEG_64K + /* Check for source > 64K on 16-bit machine: */ + if ((uInt)stream.avail_in != sourceLen) return Z_BUF_ERROR; +#endif + stream.next_out = dest; + stream.avail_out = (uInt)*destLen; + if ((uInt)stream.avail_out != *destLen) return Z_BUF_ERROR; + + stream.zalloc = (alloc_func)0; + stream.zfree = (free_func)0; + stream.opaque = (voidpf)0; + + err = deflateInit(&stream, level); + if (err != Z_OK) return err; + + err = deflate(&stream, Z_FINISH); + if (err != Z_STREAM_END) { + deflateEnd(&stream); + return err == Z_OK ? Z_BUF_ERROR : err; + } + *destLen = stream.total_out; + + err = deflateEnd(&stream); + return err; +} + +/* =========================================================================== + */ +int ZEXPORT compress (dest, destLen, source, sourceLen) + Bytef *dest; + uIntf *destLen; + const Bytef *source; + uInt sourceLen; +{ + return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION); +} + +/* =========================================================================== + If the default memLevel or windowBits for deflateInit() is changed, then + this function needs to be updated. + */ +uInt ZEXPORT compressBound (sourceLen) + uInt sourceLen; +{ + return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + + (sourceLen >> 25) + 13; +} diff --git a/zlib/thumb/crc32.c b/zlib/thumb/crc32.c new file mode 100644 index 0000000..99fa227 --- /dev/null +++ b/zlib/thumb/crc32.c @@ -0,0 +1,425 @@ +/* crc32.c -- compute the CRC-32 of a data stream + * Copyright (C) 1995-2006, 2010, 2011, 2012 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + * + * Thanks to Rodney Brown for his contribution of faster + * CRC methods: exclusive-oring 32 bits of data at a time, and pre-computing + * tables for updating the shift register in one step with three exclusive-ors + * instead of four steps with four exclusive-ors. This results in about a + * factor of two increase in speed on a Power PC G4 (PPC7455) using gcc -O3. + */ + +/* @(#) $Id$ */ + +/* + Note on the use of DYNAMIC_CRC_TABLE: there is no mutex or semaphore + protection on the static variables used to control the first-use generation + of the crc tables. Therefore, if you #define DYNAMIC_CRC_TABLE, you should + first call get_crc_table() to initialize the tables before allowing more than + one thread to use crc32(). + + DYNAMIC_CRC_TABLE and MAKECRCH can be #defined to write out crc32.h. + */ + +#ifdef MAKECRCH +# include +# ifndef DYNAMIC_CRC_TABLE +# define DYNAMIC_CRC_TABLE +# endif /* !DYNAMIC_CRC_TABLE */ +#endif /* MAKECRCH */ + +#include "zutil.h" /* for STDC and FAR definitions */ + +#define local static + +/* Definitions for doing the crc four data bytes at a time. */ +#if !defined(NOBYFOUR) && defined(Z_U4) +# define BYFOUR +#endif +#ifdef BYFOUR + local unsigned int crc32_little OF((unsigned int, + const unsigned char FAR *, unsigned)); + local unsigned int crc32_big OF((unsigned int, + const unsigned char FAR *, unsigned)); +# define TBLS 8 +#else +# define TBLS 1 +#endif /* BYFOUR */ + +/* Local functions for crc concatenation */ +local unsigned int gf2_matrix_times OF((unsigned int *mat, + unsigned int vec)); +local void gf2_matrix_square OF((unsigned int *square, unsigned int *mat)); +local uInt crc32_combine_ OF((uInt crc1, uInt crc2, z_off64_t len2)); + + +#ifdef DYNAMIC_CRC_TABLE + +local volatile int crc_table_empty = 1; +local z_crc_t FAR crc_table[TBLS][256]; +local void make_crc_table OF((void)); +#ifdef MAKECRCH + local void write_table OF((FILE *, const z_crc_t FAR *)); +#endif /* MAKECRCH */ +/* + Generate tables for a byte-wise 32-bit CRC calculation on the polynomial: + x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1. + + Polynomials over GF(2) are represented in binary, one bit per coefficient, + with the lowest powers in the most significant bit. Then adding polynomials + is just exclusive-or, and multiplying a polynomial by x is a right shift by + one. If we call the above polynomial p, and represent a byte as the + polynomial q, also with the lowest power in the most significant bit (so the + byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, + where a mod b means the remainder after dividing a by b. + + This calculation is done using the shift-register method of multiplying and + taking the remainder. The register is initialized to zero, and for each + incoming bit, x^32 is added mod p to the register if the bit is a one (where + x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by + x (which is shifting right by one and adding x^32 mod p if the bit shifted + out is a one). We start with the highest power (least significant bit) of + q and repeat for all eight bits of q. + + The first table is simply the CRC of all possible eight bit values. This is + all the information needed to generate CRCs on data a byte at a time for all + combinations of CRC register values and incoming bytes. The remaining tables + allow for word-at-a-time CRC calculation for both big-endian and little- + endian machines, where a word is four bytes. +*/ +local void make_crc_table() +{ + z_crc_t c; + int n, k; + z_crc_t poly; /* polynomial exclusive-or pattern */ + /* terms of polynomial defining this crc (except x^32): */ + static volatile int first = 1; /* flag to limit concurrent making */ + static const unsigned char p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; + + /* See if another task is already doing this (not thread-safe, but better + than nothing -- significantly reduces duration of vulnerability in + case the advice about DYNAMIC_CRC_TABLE is ignored) */ + if (first) { + first = 0; + + /* make exclusive-or pattern from polynomial (0xedb88320UL) */ + poly = 0; + for (n = 0; n < (int)(sizeof(p)/sizeof(unsigned char)); n++) + poly |= (z_crc_t)1 << (31 - p[n]); + + /* generate a crc for every 8-bit value */ + for (n = 0; n < 256; n++) { + c = (z_crc_t)n; + for (k = 0; k < 8; k++) + c = c & 1 ? poly ^ (c >> 1) : c >> 1; + crc_table[0][n] = c; + } + +#ifdef BYFOUR + /* generate crc for each value followed by one, two, and three zeros, + and then the byte reversal of those as well as the first table */ + for (n = 0; n < 256; n++) { + c = crc_table[0][n]; + crc_table[4][n] = ZSWAP32(c); + for (k = 1; k < 4; k++) { + c = crc_table[0][c & 0xff] ^ (c >> 8); + crc_table[k][n] = c; + crc_table[k + 4][n] = ZSWAP32(c); + } + } +#endif /* BYFOUR */ + + crc_table_empty = 0; + } + else { /* not first */ + /* wait for the other guy to finish (not efficient, but rare) */ + while (crc_table_empty) + ; + } + +#ifdef MAKECRCH + /* write out CRC tables to crc32.h */ + { + FILE *out; + + out = fopen("crc32.h", "w"); + if (out == NULL) return; + fprintf(out, "/* crc32.h -- tables for rapid CRC calculation\n"); + fprintf(out, " * Generated automatically by crc32.c\n */\n\n"); + fprintf(out, "local const z_crc_t FAR "); + fprintf(out, "crc_table[TBLS][256] =\n{\n {\n"); + write_table(out, crc_table[0]); +# ifdef BYFOUR + fprintf(out, "#ifdef BYFOUR\n"); + for (k = 1; k < 8; k++) { + fprintf(out, " },\n {\n"); + write_table(out, crc_table[k]); + } + fprintf(out, "#endif\n"); +# endif /* BYFOUR */ + fprintf(out, " }\n};\n"); + fclose(out); + } +#endif /* MAKECRCH */ +} + +#ifdef MAKECRCH +local void write_table(out, table) + FILE *out; + const z_crc_t FAR *table; +{ + int n; + + for (n = 0; n < 256; n++) + fprintf(out, "%s0x%08lxUL%s", n % 5 ? "" : " ", + (unsigned int)(table[n]), + n == 255 ? "\n" : (n % 5 == 4 ? ",\n" : ", ")); +} +#endif /* MAKECRCH */ + +#else /* !DYNAMIC_CRC_TABLE */ +/* ======================================================================== + * Tables of CRC-32s of all single-byte values, made by make_crc_table(). + */ +#include "crc32.h" +#endif /* DYNAMIC_CRC_TABLE */ + +/* ========================================================================= + * This function can be used by asm versions of crc32() + */ +const z_crc_t FAR * ZEXPORT get_crc_table() +{ +#ifdef DYNAMIC_CRC_TABLE + if (crc_table_empty) + make_crc_table(); +#endif /* DYNAMIC_CRC_TABLE */ + return (const z_crc_t FAR *)crc_table; +} + +/* ========================================================================= */ +#define DO1 crc = crc_table[0][((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8) +#define DO8 DO1; DO1; DO1; DO1; DO1; DO1; DO1; DO1 + +/* ========================================================================= */ +unsigned int ZEXPORT crc32(crc, buf, len) + unsigned int crc; + const unsigned char FAR *buf; + uInt len; +{ + if (buf == Z_NULL) return 0UL; + +#ifdef DYNAMIC_CRC_TABLE + if (crc_table_empty) + make_crc_table(); +#endif /* DYNAMIC_CRC_TABLE */ + +#ifdef BYFOUR + if (sizeof(void *) == sizeof(ptrdiff_t)) { + z_crc_t endian; + + endian = 1; + if (*((unsigned char *)(&endian))) + return crc32_little(crc, buf, len); + else + return crc32_big(crc, buf, len); + } +#endif /* BYFOUR */ + crc = crc ^ 0xffffffffUL; + while (len >= 8) { + DO8; + len -= 8; + } + if (len) do { + DO1; + } while (--len); + return crc ^ 0xffffffffUL; +} + +#ifdef BYFOUR + +/* ========================================================================= */ +#define DOLIT4 c ^= *buf4++; \ + c = crc_table[3][c & 0xff] ^ crc_table[2][(c >> 8) & 0xff] ^ \ + crc_table[1][(c >> 16) & 0xff] ^ crc_table[0][c >> 24] +#define DOLIT32 DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4; DOLIT4 + +/* ========================================================================= */ +local unsigned int crc32_little(crc, buf, len) + unsigned int crc; + const unsigned char FAR *buf; + unsigned len; +{ + register z_crc_t c; + register const z_crc_t FAR *buf4; + + c = (z_crc_t)crc; + c = ~c; + while (len && ((ptrdiff_t)buf & 3)) { + c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); + len--; + } + + buf4 = (const z_crc_t FAR *)(const void FAR *)buf; + while (len >= 32) { + DOLIT32; + len -= 32; + } + while (len >= 4) { + DOLIT4; + len -= 4; + } + buf = (const unsigned char FAR *)buf4; + + if (len) do { + c = crc_table[0][(c ^ *buf++) & 0xff] ^ (c >> 8); + } while (--len); + c = ~c; + return (unsigned int)c; +} + +/* ========================================================================= */ +#define DOBIG4 c ^= *++buf4; \ + c = crc_table[4][c & 0xff] ^ crc_table[5][(c >> 8) & 0xff] ^ \ + crc_table[6][(c >> 16) & 0xff] ^ crc_table[7][c >> 24] +#define DOBIG32 DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4; DOBIG4 + +/* ========================================================================= */ +local unsigned int crc32_big(crc, buf, len) + unsigned int crc; + const unsigned char FAR *buf; + unsigned len; +{ + register z_crc_t c; + register const z_crc_t FAR *buf4; + + c = ZSWAP32((z_crc_t)crc); + c = ~c; + while (len && ((ptrdiff_t)buf & 3)) { + c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); + len--; + } + + buf4 = (const z_crc_t FAR *)(const void FAR *)buf; + buf4--; + while (len >= 32) { + DOBIG32; + len -= 32; + } + while (len >= 4) { + DOBIG4; + len -= 4; + } + buf4++; + buf = (const unsigned char FAR *)buf4; + + if (len) do { + c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8); + } while (--len); + c = ~c; + return (unsigned int)(ZSWAP32(c)); +} + +#endif /* BYFOUR */ + +#define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */ + +/* ========================================================================= */ +local unsigned int gf2_matrix_times(mat, vec) + unsigned int *mat; + unsigned int vec; +{ + unsigned int sum; + + sum = 0; + while (vec) { + if (vec & 1) + sum ^= *mat; + vec >>= 1; + mat++; + } + return sum; +} + +/* ========================================================================= */ +local void gf2_matrix_square(square, mat) + unsigned int *square; + unsigned int *mat; +{ + int n; + + for (n = 0; n < GF2_DIM; n++) + square[n] = gf2_matrix_times(mat, mat[n]); +} + +/* ========================================================================= */ +local uInt crc32_combine_(crc1, crc2, len2) + uInt crc1; + uInt crc2; + z_off64_t len2; +{ + int n; + unsigned int row; + unsigned int even[GF2_DIM]; /* even-power-of-two zeros operator */ + unsigned int odd[GF2_DIM]; /* odd-power-of-two zeros operator */ + + /* degenerate case (also disallow negative lengths) */ + if (len2 <= 0) + return crc1; + + /* put operator for one zero bit in odd */ + odd[0] = 0xedb88320UL; /* CRC-32 polynomial */ + row = 1; + for (n = 1; n < GF2_DIM; n++) { + odd[n] = row; + row <<= 1; + } + + /* put operator for two zero bits in even */ + gf2_matrix_square(even, odd); + + /* put operator for four zero bits in odd */ + gf2_matrix_square(odd, even); + + /* apply len2 zeros to crc1 (first square will put the operator for one + zero byte, eight zero bits, in even) */ + do { + /* apply zeros operator for this bit of len2 */ + gf2_matrix_square(even, odd); + if (len2 & 1) + crc1 = gf2_matrix_times(even, crc1); + len2 >>= 1; + + /* if no more bits set, then done */ + if (len2 == 0) + break; + + /* another iteration of the loop with odd and even swapped */ + gf2_matrix_square(odd, even); + if (len2 & 1) + crc1 = gf2_matrix_times(odd, crc1); + len2 >>= 1; + + /* if no more bits set, then done */ + } while (len2 != 0); + + /* return combined crc */ + crc1 ^= crc2; + return crc1; +} + +/* ========================================================================= */ +uInt ZEXPORT crc32_combine(crc1, crc2, len2) + uInt crc1; + uInt crc2; + z_off_t len2; +{ + return crc32_combine_(crc1, crc2, len2); +} + +uInt ZEXPORT crc32_combine64(crc1, crc2, len2) + uInt crc1; + uInt crc2; + z_off64_t len2; +{ + return crc32_combine_(crc1, crc2, len2); +} diff --git a/zlib/thumb/crc32.h b/zlib/thumb/crc32.h new file mode 100644 index 0000000..9e0c778 --- /dev/null +++ b/zlib/thumb/crc32.h @@ -0,0 +1,441 @@ +/* crc32.h -- tables for rapid CRC calculation + * Generated automatically by crc32.c + */ + +local const z_crc_t FAR crc_table[TBLS][256] = +{ + { + 0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL, + 0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL, + 0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL, + 0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL, + 0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL, + 0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL, + 0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL, + 0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL, + 0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL, + 0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL, + 0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL, + 0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL, + 0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL, + 0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL, + 0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL, + 0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL, + 0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL, + 0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL, + 0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL, + 0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL, + 0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL, + 0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL, + 0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL, + 0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL, + 0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL, + 0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL, + 0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL, + 0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL, + 0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL, + 0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL, + 0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL, + 0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL, + 0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL, + 0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL, + 0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL, + 0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL, + 0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL, + 0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL, + 0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL, + 0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL, + 0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL, + 0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL, + 0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL, + 0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL, + 0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL, + 0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL, + 0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL, + 0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL, + 0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL, + 0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL, + 0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL, + 0x2d02ef8dUL +#ifdef BYFOUR + }, + { + 0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL, + 0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL, + 0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL, + 0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL, + 0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL, + 0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL, + 0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL, + 0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL, + 0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL, + 0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL, + 0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL, + 0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL, + 0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL, + 0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL, + 0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL, + 0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL, + 0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL, + 0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL, + 0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL, + 0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL, + 0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL, + 0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL, + 0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL, + 0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL, + 0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL, + 0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL, + 0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL, + 0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL, + 0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL, + 0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL, + 0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL, + 0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL, + 0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL, + 0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL, + 0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL, + 0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL, + 0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL, + 0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL, + 0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL, + 0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL, + 0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL, + 0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL, + 0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL, + 0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL, + 0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL, + 0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL, + 0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL, + 0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL, + 0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL, + 0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL, + 0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL, + 0x9324fd72UL + }, + { + 0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL, + 0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL, + 0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL, + 0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL, + 0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL, + 0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL, + 0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL, + 0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL, + 0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL, + 0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL, + 0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL, + 0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL, + 0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL, + 0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL, + 0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL, + 0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL, + 0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL, + 0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL, + 0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL, + 0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL, + 0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL, + 0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL, + 0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL, + 0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL, + 0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL, + 0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL, + 0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL, + 0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL, + 0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL, + 0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL, + 0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL, + 0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL, + 0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL, + 0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL, + 0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL, + 0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL, + 0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL, + 0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL, + 0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL, + 0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL, + 0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL, + 0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL, + 0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL, + 0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL, + 0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL, + 0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL, + 0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL, + 0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL, + 0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL, + 0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL, + 0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL, + 0xbe9834edUL + }, + { + 0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL, + 0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL, + 0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL, + 0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL, + 0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL, + 0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL, + 0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL, + 0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL, + 0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL, + 0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL, + 0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL, + 0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL, + 0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL, + 0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL, + 0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL, + 0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL, + 0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL, + 0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL, + 0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL, + 0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL, + 0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL, + 0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL, + 0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL, + 0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL, + 0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL, + 0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL, + 0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL, + 0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL, + 0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL, + 0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL, + 0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL, + 0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL, + 0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL, + 0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL, + 0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL, + 0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL, + 0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL, + 0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL, + 0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL, + 0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL, + 0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL, + 0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL, + 0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL, + 0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL, + 0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL, + 0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL, + 0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL, + 0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL, + 0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL, + 0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL, + 0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL, + 0xde0506f1UL + }, + { + 0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL, + 0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL, + 0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL, + 0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL, + 0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL, + 0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL, + 0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL, + 0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL, + 0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL, + 0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL, + 0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL, + 0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL, + 0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL, + 0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL, + 0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL, + 0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL, + 0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL, + 0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL, + 0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL, + 0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL, + 0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL, + 0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL, + 0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL, + 0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL, + 0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL, + 0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL, + 0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL, + 0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL, + 0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL, + 0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL, + 0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL, + 0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL, + 0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL, + 0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL, + 0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL, + 0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL, + 0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL, + 0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL, + 0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL, + 0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL, + 0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL, + 0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL, + 0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL, + 0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL, + 0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL, + 0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL, + 0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL, + 0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL, + 0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL, + 0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL, + 0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL, + 0x8def022dUL + }, + { + 0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL, + 0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL, + 0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL, + 0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL, + 0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL, + 0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL, + 0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL, + 0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL, + 0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL, + 0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL, + 0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL, + 0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL, + 0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL, + 0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL, + 0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL, + 0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL, + 0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL, + 0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL, + 0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL, + 0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL, + 0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL, + 0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL, + 0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL, + 0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL, + 0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL, + 0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL, + 0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL, + 0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL, + 0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL, + 0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL, + 0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL, + 0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL, + 0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL, + 0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL, + 0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL, + 0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL, + 0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL, + 0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL, + 0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL, + 0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL, + 0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL, + 0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL, + 0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL, + 0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL, + 0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL, + 0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL, + 0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL, + 0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL, + 0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL, + 0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL, + 0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL, + 0x72fd2493UL + }, + { + 0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL, + 0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL, + 0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL, + 0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL, + 0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL, + 0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL, + 0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL, + 0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL, + 0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL, + 0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL, + 0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL, + 0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL, + 0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL, + 0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL, + 0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL, + 0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL, + 0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL, + 0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL, + 0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL, + 0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL, + 0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL, + 0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL, + 0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL, + 0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL, + 0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL, + 0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL, + 0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL, + 0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL, + 0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL, + 0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL, + 0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL, + 0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL, + 0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL, + 0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL, + 0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL, + 0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL, + 0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL, + 0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL, + 0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL, + 0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL, + 0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL, + 0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL, + 0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL, + 0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL, + 0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL, + 0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL, + 0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL, + 0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL, + 0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL, + 0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL, + 0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL, + 0xed3498beUL + }, + { + 0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL, + 0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL, + 0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL, + 0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL, + 0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL, + 0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL, + 0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL, + 0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL, + 0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL, + 0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL, + 0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL, + 0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL, + 0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL, + 0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL, + 0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL, + 0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL, + 0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL, + 0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL, + 0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL, + 0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL, + 0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL, + 0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL, + 0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL, + 0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL, + 0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL, + 0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL, + 0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL, + 0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL, + 0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL, + 0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL, + 0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL, + 0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL, + 0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL, + 0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL, + 0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL, + 0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL, + 0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL, + 0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL, + 0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL, + 0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL, + 0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL, + 0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL, + 0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL, + 0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL, + 0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL, + 0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL, + 0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL, + 0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL, + 0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL, + 0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL, + 0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL, + 0xf10605deUL +#endif + } +}; diff --git a/zlib/thumb/deflate.c b/zlib/thumb/deflate.c new file mode 100644 index 0000000..d630741 --- /dev/null +++ b/zlib/thumb/deflate.c @@ -0,0 +1,1965 @@ +/* deflate.c -- compress data using the deflation algorithm + * Copyright (C) 1995-2012 Jean-loup Gailly and Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* + * ALGORITHM + * + * The "deflation" process depends on being able to identify portions + * of the input text which are identical to earlier input (within a + * sliding window trailing behind the input currently being processed). + * + * The most straightforward technique turns out to be the fastest for + * most input files: try all possible matches and select the longest. + * The key feature of this algorithm is that insertions into the string + * dictionary are very simple and thus fast, and deletions are avoided + * completely. Insertions are performed at each input character, whereas + * string matches are performed only when the previous match ends. So it + * is preferable to spend more time in matches to allow very fast string + * insertions and avoid deletions. The matching algorithm for small + * strings is inspired from that of Rabin & Karp. A brute force approach + * is used to find longer strings when a small match has been found. + * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze + * (by Leonid Broukhis). + * A previous version of this file used a more sophisticated algorithm + * (by Fiala and Greene) which is guaranteed to run in linear amortized + * time, but has a larger average cost, uses more memory and is patented. + * However the F&G algorithm may be faster for some highly redundant + * files if the parameter max_chain_length (described below) is too large. + * + * ACKNOWLEDGEMENTS + * + * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and + * I found it in 'freeze' written by Leonid Broukhis. + * Thanks to many people for bug reports and testing. + * + * REFERENCES + * + * Deutsch, L.P.,"DEFLATE Compressed Data Format Specification". + * Available in http://tools.ietf.org/html/rfc1951 + * + * A description of the Rabin and Karp algorithm is given in the book + * "Algorithms" by R. Sedgewick, Addison-Wesley, p252. + * + * Fiala,E.R., and Greene,D.H. + * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595 + * + */ + +/* @(#) $Id$ */ + +#include "deflate.h" + +const char deflate_copyright[] = + " deflate 1.2.7 Copyright 1995-2012 Jean-loup Gailly and Mark Adler "; +/* + If you use the zlib library in a product, an acknowledgment is welcome + in the documentation of your product. If for some reason you cannot + include such an acknowledgment, I would appreciate that you keep this + copyright string in the executable of your product. + */ + +/* =========================================================================== + * Function prototypes. + */ +typedef enum { + need_more, /* block not completed, need more input or more output */ + block_done, /* block flush performed */ + finish_started, /* finish started, need only more output at next deflate */ + finish_done /* finish done, accept no more input or output */ +} block_state; + +typedef block_state (*compress_func) OF((deflate_state *s, int flush)); +/* Compression function. Returns the block state after the call. */ + +local void fill_window OF((deflate_state *s)); +local block_state deflate_stored OF((deflate_state *s, int flush)); +local block_state deflate_fast OF((deflate_state *s, int flush)); +#ifndef FASTEST +local block_state deflate_slow OF((deflate_state *s, int flush)); +#endif +local block_state deflate_rle OF((deflate_state *s, int flush)); +local block_state deflate_huff OF((deflate_state *s, int flush)); +local void lm_init OF((deflate_state *s)); +local void putShortMSB OF((deflate_state *s, uInt b)); +local void flush_pending OF((z_streamp strm)); +local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); +#ifdef ASMV + void match_init OF((void)); /* asm code initialization */ + uInt longest_match OF((deflate_state *s, IPos cur_match)); +#else +local uInt longest_match OF((deflate_state *s, IPos cur_match)); +#endif + +#ifdef DEBUG +local void check_match OF((deflate_state *s, IPos start, IPos match, + int length)); +#endif + +/* =========================================================================== + * Local data + */ + +#define NIL 0 +/* Tail of hash chains */ + +#ifndef TOO_FAR +# define TOO_FAR 4096 +#endif +/* Matches of length 3 are discarded if their distance exceeds TOO_FAR */ + +/* Values for max_lazy_match, good_match and max_chain_length, depending on + * the desired pack level (0..9). The values given below have been tuned to + * exclude worst case performance for pathological files. Better values may be + * found for specific files. + */ +typedef struct config_s { + ush good_length; /* reduce lazy search above this match length */ + ush max_lazy; /* do not perform lazy search above this match length */ + ush nice_length; /* quit search above this match length */ + ush max_chain; + compress_func func; +} config; + +#ifdef FASTEST +local const config configuration_table[2] = { +/* good lazy nice chain */ +/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ +/* 1 */ {4, 4, 8, 4, deflate_fast}}; /* max speed, no lazy matches */ +#else +local const config configuration_table[10] = { +/* good lazy nice chain */ +/* 0 */ {0, 0, 0, 0, deflate_stored}, /* store only */ +/* 1 */ {4, 4, 8, 4, deflate_fast}, /* max speed, no lazy matches */ +/* 2 */ {4, 5, 16, 8, deflate_fast}, +/* 3 */ {4, 6, 32, 32, deflate_fast}, + +/* 4 */ {4, 4, 16, 16, deflate_slow}, /* lazy matches */ +/* 5 */ {8, 16, 32, 32, deflate_slow}, +/* 6 */ {8, 16, 128, 128, deflate_slow}, +/* 7 */ {8, 32, 128, 256, deflate_slow}, +/* 8 */ {32, 128, 258, 1024, deflate_slow}, +/* 9 */ {32, 258, 258, 4096, deflate_slow}}; /* max compression */ +#endif + +/* Note: the deflate() code requires max_lazy >= MIN_MATCH and max_chain >= 4 + * For deflate_fast() (levels <= 3) good is ignored and lazy has a different + * meaning. + */ + +#define EQUAL 0 +/* result of memcmp for equal strings */ + +#ifndef NO_DUMMY_DECL +struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ +#endif + +/* rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH */ +#define RANK(f) (((f) << 1) - ((f) > 4 ? 9 : 0)) + +/* =========================================================================== + * Update a hash value with the given input byte + * IN assertion: all calls to to UPDATE_HASH are made with consecutive + * input characters, so that a running hash key can be computed from the + * previous key instead of complete recalculation each time. + */ +#define UPDATE_HASH(s,h,c) (h = (((h)<hash_shift) ^ (c)) & s->hash_mask) + + +/* =========================================================================== + * Insert string str in the dictionary and set match_head to the previous head + * of the hash chain (the most recent string with same hash key). Return + * the previous length of the hash chain. + * If this file is compiled with -DFASTEST, the compression level is forced + * to 1, and no hash chains are maintained. + * IN assertion: all calls to to INSERT_STRING are made with consecutive + * input characters and the first MIN_MATCH bytes of str are valid + * (except for the last MIN_MATCH-1 bytes of the input file). + */ +#ifdef FASTEST +#define INSERT_STRING(s, str, match_head) \ + (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ + match_head = s->head[s->ins_h], \ + s->head[s->ins_h] = (Pos)(str)) +#else +#define INSERT_STRING(s, str, match_head) \ + (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ + match_head = s->prev[(str) & s->w_mask] = s->head[s->ins_h], \ + s->head[s->ins_h] = (Pos)(str)) +#endif + +/* =========================================================================== + * Initialize the hash table (avoiding 64K overflow for 16 bit systems). + * prev[] will be initialized on the fly. + */ +#define CLEAR_HASH(s) \ + s->head[s->hash_size-1] = NIL; \ + zmemzero((Bytef *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); + +/* ========================================================================= */ +int ZEXPORT deflateInit_(strm, level, version, stream_size) + z_streamp strm; + int level; + const char *version; + int stream_size; +{ + return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, + Z_DEFAULT_STRATEGY, version, stream_size); + /* To do: ignore strm->next_in if we use it as window */ +} + +/* ========================================================================= */ +int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, + version, stream_size) + z_streamp strm; + int level; + int method; + int windowBits; + int memLevel; + int strategy; + const char *version; + int stream_size; +{ + deflate_state *s; + int wrap = 1; + static const char my_version[] = ZLIB_VERSION; + + ushf *overlay; + /* We overlay pending_buf and d_buf+l_buf. This works since the average + * output size for (length,distance) codes is <= 24 bits. + */ + + if (version == Z_NULL || version[0] != my_version[0] || + stream_size != sizeof(z_stream)) { + return Z_VERSION_ERROR; + } + if (strm == Z_NULL) return Z_STREAM_ERROR; + + strm->msg = Z_NULL; + if (strm->zalloc == (alloc_func)0) { +#ifdef Z_SOLO + return Z_STREAM_ERROR; +#else + strm->zalloc = zcalloc; + strm->opaque = (voidpf)0; +#endif + } + if (strm->zfree == (free_func)0) +#ifdef Z_SOLO + return Z_STREAM_ERROR; +#else + strm->zfree = zcfree; +#endif + +#ifdef FASTEST + if (level != 0) level = 1; +#else + if (level == Z_DEFAULT_COMPRESSION) level = 6; +#endif + + if (windowBits < 0) { /* suppress zlib wrapper */ + wrap = 0; + windowBits = -windowBits; + } +#ifdef GZIP + else if (windowBits > 15) { + wrap = 2; /* write gzip wrapper instead */ + windowBits -= 16; + } +#endif + if (memLevel < 1 || memLevel > MAX_MEM_LEVEL || method != Z_DEFLATED || + windowBits < 8 || windowBits > 15 || level < 0 || level > 9 || + strategy < 0 || strategy > Z_FIXED) { + return Z_STREAM_ERROR; + } + if (windowBits == 8) windowBits = 9; /* until 256-byte window bug fixed */ + s = (deflate_state *) ZALLOC(strm, 1, sizeof(deflate_state)); + if (s == Z_NULL) return Z_MEM_ERROR; + strm->state = (struct internal_state FAR *)s; + s->strm = strm; + + s->wrap = wrap; + s->gzhead = Z_NULL; + s->w_bits = windowBits; + s->w_size = 1 << s->w_bits; + s->w_mask = s->w_size - 1; + + s->hash_bits = memLevel + 7; + s->hash_size = 1 << s->hash_bits; + s->hash_mask = s->hash_size - 1; + s->hash_shift = ((s->hash_bits+MIN_MATCH-1)/MIN_MATCH); + + s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte)); + s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos)); + s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos)); + + s->high_water = 0; /* nothing written to s->window yet */ + + s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ + + overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2); + s->pending_buf = (uchf *) overlay; + s->pending_buf_size = (ulg)s->lit_bufsize * (sizeof(ush)+2L); + + if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || + s->pending_buf == Z_NULL) { + s->status = FINISH_STATE; + strm->msg = (char*)ERR_MSG(Z_MEM_ERROR); + deflateEnd (strm); + return Z_MEM_ERROR; + } + s->d_buf = overlay + s->lit_bufsize/sizeof(ush); + s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize; + + s->level = level; + s->strategy = strategy; + s->method = (Byte)method; + + return deflateReset(strm); +} + +/* ========================================================================= */ +int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength) + z_streamp strm; + const Bytef *dictionary; + uInt dictLength; +{ + deflate_state *s; + uInt str, n; + int wrap; + unsigned avail; + unsigned char *next; + + if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL) + return Z_STREAM_ERROR; + s = strm->state; + wrap = s->wrap; + if (wrap == 2 || (wrap == 1 && s->status != INIT_STATE) || s->lookahead) + return Z_STREAM_ERROR; + + /* when using zlib wrappers, compute Adler-32 for provided dictionary */ + if (wrap == 1) + strm->adler = adler32(strm->adler, dictionary, dictLength); + s->wrap = 0; /* avoid computing Adler-32 in read_buf */ + + /* if dictionary would fill window, just replace the history */ + if (dictLength >= s->w_size) { + if (wrap == 0) { /* already empty otherwise */ + CLEAR_HASH(s); + s->strstart = 0; + s->block_start = 0L; + s->insert = 0; + } + dictionary += dictLength - s->w_size; /* use the tail */ + dictLength = s->w_size; + } + + /* insert dictionary into window and hash */ + avail = strm->avail_in; + next = strm->next_in; + strm->avail_in = dictLength; + strm->next_in = (Bytef *)dictionary; + fill_window(s); + while (s->lookahead >= MIN_MATCH) { + str = s->strstart; + n = s->lookahead - (MIN_MATCH-1); + do { + UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); +#ifndef FASTEST + s->prev[str & s->w_mask] = s->head[s->ins_h]; +#endif + s->head[s->ins_h] = (Pos)str; + str++; + } while (--n); + s->strstart = str; + s->lookahead = MIN_MATCH-1; + fill_window(s); + } + s->strstart += s->lookahead; + s->block_start = (int)s->strstart; + s->insert = s->lookahead; + s->lookahead = 0; + s->match_length = s->prev_length = MIN_MATCH-1; + s->match_available = 0; + strm->next_in = next; + strm->avail_in = avail; + s->wrap = wrap; + return Z_OK; +} + +/* ========================================================================= */ +int ZEXPORT deflateResetKeep (strm) + z_streamp strm; +{ + deflate_state *s; + + if (strm == Z_NULL || strm->state == Z_NULL || + strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0) { + return Z_STREAM_ERROR; + } + + strm->total_in = strm->total_out = 0; + strm->msg = Z_NULL; /* use zfree if we ever allocate msg dynamically */ + strm->data_type = Z_UNKNOWN; + + s = (deflate_state *)strm->state; + s->pending = 0; + s->pending_out = s->pending_buf; + + if (s->wrap < 0) { + s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */ + } + s->status = s->wrap ? INIT_STATE : BUSY_STATE; + strm->adler = +#ifdef GZIP + s->wrap == 2 ? crc32(0L, Z_NULL, 0) : +#endif + adler32(0L, Z_NULL, 0); + s->last_flush = Z_NO_FLUSH; + + _tr_init(s); + + return Z_OK; +} + +/* ========================================================================= */ +int ZEXPORT deflateReset (strm) + z_streamp strm; +{ + int ret; + + ret = deflateResetKeep(strm); + if (ret == Z_OK) + lm_init(strm->state); + return ret; +} + +/* ========================================================================= */ +int ZEXPORT deflateSetHeader (strm, head) + z_streamp strm; + gz_headerp head; +{ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + if (strm->state->wrap != 2) return Z_STREAM_ERROR; + strm->state->gzhead = head; + return Z_OK; +} + +/* ========================================================================= */ +int ZEXPORT deflatePending (strm, pending, bits) + unsigned *pending; + int *bits; + z_streamp strm; +{ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + if (pending != Z_NULL) + *pending = strm->state->pending; + if (bits != Z_NULL) + *bits = strm->state->bi_valid; + return Z_OK; +} + +/* ========================================================================= */ +int ZEXPORT deflatePrime (strm, bits, value) + z_streamp strm; + int bits; + int value; +{ + deflate_state *s; + int put; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + s = strm->state; + if ((Bytef *)(s->d_buf) < s->pending_out + ((Buf_size + 7) >> 3)) + return Z_BUF_ERROR; + do { + put = Buf_size - s->bi_valid; + if (put > bits) + put = bits; + s->bi_buf |= (ush)((value & ((1 << put) - 1)) << s->bi_valid); + s->bi_valid += put; + _tr_flush_bits(s); + value >>= put; + bits -= put; + } while (bits); + return Z_OK; +} + +/* ========================================================================= */ +int ZEXPORT deflateParams(strm, level, strategy) + z_streamp strm; + int level; + int strategy; +{ + deflate_state *s; + compress_func func; + int err = Z_OK; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + s = strm->state; + +#ifdef FASTEST + if (level != 0) level = 1; +#else + if (level == Z_DEFAULT_COMPRESSION) level = 6; +#endif + if (level < 0 || level > 9 || strategy < 0 || strategy > Z_FIXED) { + return Z_STREAM_ERROR; + } + func = configuration_table[s->level].func; + + if ((strategy != s->strategy || func != configuration_table[level].func) && + strm->total_in != 0) { + /* Flush the last buffer: */ + err = deflate(strm, Z_BLOCK); + } + if (s->level != level) { + s->level = level; + s->max_lazy_match = configuration_table[level].max_lazy; + s->good_match = configuration_table[level].good_length; + s->nice_match = configuration_table[level].nice_length; + s->max_chain_length = configuration_table[level].max_chain; + } + s->strategy = strategy; + return err; +} + +/* ========================================================================= */ +int ZEXPORT deflateTune(strm, good_length, max_lazy, nice_length, max_chain) + z_streamp strm; + int good_length; + int max_lazy; + int nice_length; + int max_chain; +{ + deflate_state *s; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + s = strm->state; + s->good_match = good_length; + s->max_lazy_match = max_lazy; + s->nice_match = nice_length; + s->max_chain_length = max_chain; + return Z_OK; +} + +/* ========================================================================= + * For the default windowBits of 15 and memLevel of 8, this function returns + * a close to exact, as well as small, upper bound on the compressed size. + * They are coded as constants here for a reason--if the #define's are + * changed, then this function needs to be changed as well. The return + * value for 15 and 8 only works for those exact settings. + * + * For any setting other than those defaults for windowBits and memLevel, + * the value returned is a conservative worst case for the maximum expansion + * resulting from using fixed blocks instead of stored blocks, which deflate + * can emit on compressed data for some combinations of the parameters. + * + * This function could be more sophisticated to provide closer upper bounds for + * every combination of windowBits and memLevel. But even the conservative + * upper bound of about 14% expansion does not seem onerous for output buffer + * allocation. + */ +uInt ZEXPORT deflateBound(strm, sourceLen) + z_streamp strm; + uInt sourceLen; +{ + deflate_state *s; + uInt complen, wraplen; + Bytef *str; + + /* conservative upper bound for compressed data */ + complen = sourceLen + + ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5; + + /* if can't get parameters, return conservative bound plus zlib wrapper */ + if (strm == Z_NULL || strm->state == Z_NULL) + return complen + 6; + + /* compute wrapper length */ + s = strm->state; + switch (s->wrap) { + case 0: /* raw deflate */ + wraplen = 0; + break; + case 1: /* zlib wrapper */ + wraplen = 6 + (s->strstart ? 4 : 0); + break; + case 2: /* gzip wrapper */ + wraplen = 18; + if (s->gzhead != Z_NULL) { /* user-supplied gzip header */ + if (s->gzhead->extra != Z_NULL) + wraplen += 2 + s->gzhead->extra_len; + str = s->gzhead->name; + if (str != Z_NULL) + do { + wraplen++; + } while (*str++); + str = s->gzhead->comment; + if (str != Z_NULL) + do { + wraplen++; + } while (*str++); + if (s->gzhead->hcrc) + wraplen += 2; + } + break; + default: /* for compiler happiness */ + wraplen = 6; + } + + /* if not default parameters, return conservative bound */ + if (s->w_bits != 15 || s->hash_bits != 8 + 7) + return complen + wraplen; + + /* default settings: return tight bound for that case */ + return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + + (sourceLen >> 25) + 13 - 6 + wraplen; +} + +/* ========================================================================= + * Put a short in the pending buffer. The 16-bit value is put in MSB order. + * IN assertion: the stream state is correct and there is enough room in + * pending_buf. + */ +local void putShortMSB (s, b) + deflate_state *s; + uInt b; +{ + put_byte(s, (Byte)(b >> 8)); + put_byte(s, (Byte)(b & 0xff)); +} + +/* ========================================================================= + * Flush as much pending output as possible. All deflate() output goes + * through this function so some applications may wish to modify it + * to avoid allocating a large strm->next_out buffer and copying into it. + * (See also read_buf()). + */ +local void flush_pending(strm) + z_streamp strm; +{ + unsigned len; + deflate_state *s = strm->state; + + _tr_flush_bits(s); + len = s->pending; + if (len > strm->avail_out) len = strm->avail_out; + if (len == 0) return; + + zmemcpy(strm->next_out, s->pending_out, len); + strm->next_out += len; + s->pending_out += len; + strm->total_out += len; + strm->avail_out -= len; + s->pending -= len; + if (s->pending == 0) { + s->pending_out = s->pending_buf; + } +} + +/* ========================================================================= */ +int ZEXPORT deflate (strm, flush) + z_streamp strm; + int flush; +{ + int old_flush; /* value of flush param for previous deflate call */ + deflate_state *s; + + if (strm == Z_NULL || strm->state == Z_NULL || + flush > Z_BLOCK || flush < 0) { + return Z_STREAM_ERROR; + } + s = strm->state; + + if (strm->next_out == Z_NULL || + (strm->next_in == Z_NULL && strm->avail_in != 0) || + (s->status == FINISH_STATE && flush != Z_FINISH)) { + ERR_RETURN(strm, Z_STREAM_ERROR); + } + if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR); + + s->strm = strm; /* just in case */ + old_flush = s->last_flush; + s->last_flush = flush; + + /* Write the header */ + if (s->status == INIT_STATE) { +#ifdef GZIP + if (s->wrap == 2) { + strm->adler = crc32(0L, Z_NULL, 0); + put_byte(s, 31); + put_byte(s, 139); + put_byte(s, 8); + if (s->gzhead == Z_NULL) { + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, 0); + put_byte(s, s->level == 9 ? 2 : + (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? + 4 : 0)); + put_byte(s, OS_CODE); + s->status = BUSY_STATE; + } + else { + put_byte(s, (s->gzhead->text ? 1 : 0) + + (s->gzhead->hcrc ? 2 : 0) + + (s->gzhead->extra == Z_NULL ? 0 : 4) + + (s->gzhead->name == Z_NULL ? 0 : 8) + + (s->gzhead->comment == Z_NULL ? 0 : 16) + ); + put_byte(s, (Byte)(s->gzhead->time & 0xff)); + put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff)); + put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff)); + put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff)); + put_byte(s, s->level == 9 ? 2 : + (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ? + 4 : 0)); + put_byte(s, s->gzhead->os & 0xff); + if (s->gzhead->extra != Z_NULL) { + put_byte(s, s->gzhead->extra_len & 0xff); + put_byte(s, (s->gzhead->extra_len >> 8) & 0xff); + } + if (s->gzhead->hcrc) + strm->adler = crc32(strm->adler, s->pending_buf, + s->pending); + s->gzindex = 0; + s->status = EXTRA_STATE; + } + } + else +#endif + { + uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8; + uInt level_flags; + + if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2) + level_flags = 0; + else if (s->level < 6) + level_flags = 1; + else if (s->level == 6) + level_flags = 2; + else + level_flags = 3; + header |= (level_flags << 6); + if (s->strstart != 0) header |= PRESET_DICT; + header += 31 - (header % 31); + + s->status = BUSY_STATE; + putShortMSB(s, header); + + /* Save the adler32 of the preset dictionary: */ + if (s->strstart != 0) { + putShortMSB(s, (uInt)(strm->adler >> 16)); + putShortMSB(s, (uInt)(strm->adler & 0xffff)); + } + strm->adler = adler32(0L, Z_NULL, 0); + } + } +#ifdef GZIP + if (s->status == EXTRA_STATE) { + if (s->gzhead->extra != Z_NULL) { + uInt beg = s->pending; /* start of bytes to update crc */ + + while (s->gzindex < (s->gzhead->extra_len & 0xffff)) { + if (s->pending == s->pending_buf_size) { + if (s->gzhead->hcrc && s->pending > beg) + strm->adler = crc32(strm->adler, s->pending_buf + beg, + s->pending - beg); + flush_pending(strm); + beg = s->pending; + if (s->pending == s->pending_buf_size) + break; + } + put_byte(s, s->gzhead->extra[s->gzindex]); + s->gzindex++; + } + if (s->gzhead->hcrc && s->pending > beg) + strm->adler = crc32(strm->adler, s->pending_buf + beg, + s->pending - beg); + if (s->gzindex == s->gzhead->extra_len) { + s->gzindex = 0; + s->status = NAME_STATE; + } + } + else + s->status = NAME_STATE; + } + if (s->status == NAME_STATE) { + if (s->gzhead->name != Z_NULL) { + uInt beg = s->pending; /* start of bytes to update crc */ + int val; + + do { + if (s->pending == s->pending_buf_size) { + if (s->gzhead->hcrc && s->pending > beg) + strm->adler = crc32(strm->adler, s->pending_buf + beg, + s->pending - beg); + flush_pending(strm); + beg = s->pending; + if (s->pending == s->pending_buf_size) { + val = 1; + break; + } + } + val = s->gzhead->name[s->gzindex++]; + put_byte(s, val); + } while (val != 0); + if (s->gzhead->hcrc && s->pending > beg) + strm->adler = crc32(strm->adler, s->pending_buf + beg, + s->pending - beg); + if (val == 0) { + s->gzindex = 0; + s->status = COMMENT_STATE; + } + } + else + s->status = COMMENT_STATE; + } + if (s->status == COMMENT_STATE) { + if (s->gzhead->comment != Z_NULL) { + uInt beg = s->pending; /* start of bytes to update crc */ + int val; + + do { + if (s->pending == s->pending_buf_size) { + if (s->gzhead->hcrc && s->pending > beg) + strm->adler = crc32(strm->adler, s->pending_buf + beg, + s->pending - beg); + flush_pending(strm); + beg = s->pending; + if (s->pending == s->pending_buf_size) { + val = 1; + break; + } + } + val = s->gzhead->comment[s->gzindex++]; + put_byte(s, val); + } while (val != 0); + if (s->gzhead->hcrc && s->pending > beg) + strm->adler = crc32(strm->adler, s->pending_buf + beg, + s->pending - beg); + if (val == 0) + s->status = HCRC_STATE; + } + else + s->status = HCRC_STATE; + } + if (s->status == HCRC_STATE) { + if (s->gzhead->hcrc) { + if (s->pending + 2 > s->pending_buf_size) + flush_pending(strm); + if (s->pending + 2 <= s->pending_buf_size) { + put_byte(s, (Byte)(strm->adler & 0xff)); + put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); + strm->adler = crc32(0L, Z_NULL, 0); + s->status = BUSY_STATE; + } + } + else + s->status = BUSY_STATE; + } +#endif + + /* Flush as much pending output as possible */ + if (s->pending != 0) { + flush_pending(strm); + if (strm->avail_out == 0) { + /* Since avail_out is 0, deflate will be called again with + * more output space, but possibly with both pending and + * avail_in equal to zero. There won't be anything to do, + * but this is not an error situation so make sure we + * return OK instead of BUF_ERROR at next call of deflate: + */ + s->last_flush = -1; + return Z_OK; + } + + /* Make sure there is something to do and avoid duplicate consecutive + * flushes. For repeated and useless calls with Z_FINISH, we keep + * returning Z_STREAM_END instead of Z_BUF_ERROR. + */ + } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) && + flush != Z_FINISH) { + ERR_RETURN(strm, Z_BUF_ERROR); + } + + /* User must not provide more input after the first FINISH: */ + if (s->status == FINISH_STATE && strm->avail_in != 0) { + ERR_RETURN(strm, Z_BUF_ERROR); + } + + /* Start a new block or continue the current one. + */ + if (strm->avail_in != 0 || s->lookahead != 0 || + (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) { + block_state bstate; + + bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : + (s->strategy == Z_RLE ? deflate_rle(s, flush) : + (*(configuration_table[s->level].func))(s, flush)); + + if (bstate == finish_started || bstate == finish_done) { + s->status = FINISH_STATE; + } + if (bstate == need_more || bstate == finish_started) { + if (strm->avail_out == 0) { + s->last_flush = -1; /* avoid BUF_ERROR next call, see above */ + } + return Z_OK; + /* If flush != Z_NO_FLUSH && avail_out == 0, the next call + * of deflate should use the same flush parameter to make sure + * that the flush is complete. So we don't have to output an + * empty block here, this will be done at next call. This also + * ensures that for a very small output buffer, we emit at most + * one empty block. + */ + } + if (bstate == block_done) { + if (flush == Z_PARTIAL_FLUSH) { + _tr_align(s); + } else if (flush != Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */ + _tr_stored_block(s, (char*)0, 0L, 0); + /* For a full flush, this empty block will be recognized + * as a special marker by inflate_sync(). + */ + if (flush == Z_FULL_FLUSH) { + CLEAR_HASH(s); /* forget history */ + if (s->lookahead == 0) { + s->strstart = 0; + s->block_start = 0L; + s->insert = 0; + } + } + } + flush_pending(strm); + if (strm->avail_out == 0) { + s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */ + return Z_OK; + } + } + } + Assert(strm->avail_out > 0, "bug2"); + + if (flush != Z_FINISH) return Z_OK; + if (s->wrap <= 0) return Z_STREAM_END; + + /* Write the trailer */ +#ifdef GZIP + if (s->wrap == 2) { + put_byte(s, (Byte)(strm->adler & 0xff)); + put_byte(s, (Byte)((strm->adler >> 8) & 0xff)); + put_byte(s, (Byte)((strm->adler >> 16) & 0xff)); + put_byte(s, (Byte)((strm->adler >> 24) & 0xff)); + put_byte(s, (Byte)(strm->total_in & 0xff)); + put_byte(s, (Byte)((strm->total_in >> 8) & 0xff)); + put_byte(s, (Byte)((strm->total_in >> 16) & 0xff)); + put_byte(s, (Byte)((strm->total_in >> 24) & 0xff)); + } + else +#endif + { + putShortMSB(s, (uInt)(strm->adler >> 16)); + putShortMSB(s, (uInt)(strm->adler & 0xffff)); + } + flush_pending(strm); + /* If avail_out is zero, the application will call deflate again + * to flush the rest. + */ + if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */ + return s->pending != 0 ? Z_OK : Z_STREAM_END; +} + +/* ========================================================================= */ +int ZEXPORT deflateEnd (strm) + z_streamp strm; +{ + int status; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + + status = strm->state->status; + if (status != INIT_STATE && + status != EXTRA_STATE && + status != NAME_STATE && + status != COMMENT_STATE && + status != HCRC_STATE && + status != BUSY_STATE && + status != FINISH_STATE) { + return Z_STREAM_ERROR; + } + + /* Deallocate in reverse order of allocations: */ + TRY_FREE(strm, strm->state->pending_buf); + TRY_FREE(strm, strm->state->head); + TRY_FREE(strm, strm->state->prev); + TRY_FREE(strm, strm->state->window); + + ZFREE(strm, strm->state); + strm->state = Z_NULL; + + return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK; +} + +/* ========================================================================= + * Copy the source state to the destination state. + * To simplify the source, this is not supported for 16-bit MSDOS (which + * doesn't have enough memory anyway to duplicate compression states). + */ +int ZEXPORT deflateCopy (dest, source) + z_streamp dest; + z_streamp source; +{ +#ifdef MAXSEG_64K + return Z_STREAM_ERROR; +#else + deflate_state *ds; + deflate_state *ss; + ushf *overlay; + + + if (source == Z_NULL || dest == Z_NULL || source->state == Z_NULL) { + return Z_STREAM_ERROR; + } + + ss = source->state; + + zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream)); + + ds = (deflate_state *) ZALLOC(dest, 1, sizeof(deflate_state)); + if (ds == Z_NULL) return Z_MEM_ERROR; + dest->state = (struct internal_state FAR *) ds; + zmemcpy((voidpf)ds, (voidpf)ss, sizeof(deflate_state)); + ds->strm = dest; + + ds->window = (Bytef *) ZALLOC(dest, ds->w_size, 2*sizeof(Byte)); + ds->prev = (Posf *) ZALLOC(dest, ds->w_size, sizeof(Pos)); + ds->head = (Posf *) ZALLOC(dest, ds->hash_size, sizeof(Pos)); + overlay = (ushf *) ZALLOC(dest, ds->lit_bufsize, sizeof(ush)+2); + ds->pending_buf = (uchf *) overlay; + + if (ds->window == Z_NULL || ds->prev == Z_NULL || ds->head == Z_NULL || + ds->pending_buf == Z_NULL) { + deflateEnd (dest); + return Z_MEM_ERROR; + } + /* following zmemcpy do not work for 16-bit MSDOS */ + zmemcpy(ds->window, ss->window, ds->w_size * 2 * sizeof(Byte)); + zmemcpy((voidpf)ds->prev, (voidpf)ss->prev, ds->w_size * sizeof(Pos)); + zmemcpy((voidpf)ds->head, (voidpf)ss->head, ds->hash_size * sizeof(Pos)); + zmemcpy(ds->pending_buf, ss->pending_buf, (uInt)ds->pending_buf_size); + + ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf); + ds->d_buf = overlay + ds->lit_bufsize/sizeof(ush); + ds->l_buf = ds->pending_buf + (1+sizeof(ush))*ds->lit_bufsize; + + ds->l_desc.dyn_tree = ds->dyn_ltree; + ds->d_desc.dyn_tree = ds->dyn_dtree; + ds->bl_desc.dyn_tree = ds->bl_tree; + + return Z_OK; +#endif /* MAXSEG_64K */ +} + +/* =========================================================================== + * Read a new buffer from the current input stream, update the adler32 + * and total number of bytes read. All deflate() input goes through + * this function so some applications may wish to modify it to avoid + * allocating a large strm->next_in buffer and copying from it. + * (See also flush_pending()). + */ +local int read_buf(strm, buf, size) + z_streamp strm; + Bytef *buf; + unsigned size; +{ + unsigned len = strm->avail_in; + + if (len > size) len = size; + if (len == 0) return 0; + + strm->avail_in -= len; + + zmemcpy(buf, strm->next_in, len); + if (strm->state->wrap == 1) { + strm->adler = adler32(strm->adler, buf, len); + } +#ifdef GZIP + else if (strm->state->wrap == 2) { + strm->adler = crc32(strm->adler, buf, len); + } +#endif + strm->next_in += len; + strm->total_in += len; + + return (int)len; +} + +/* =========================================================================== + * Initialize the "longest match" routines for a new zlib stream + */ +local void lm_init (s) + deflate_state *s; +{ + s->window_size = (ulg)2L*s->w_size; + + CLEAR_HASH(s); + + /* Set the default configuration parameters: + */ + s->max_lazy_match = configuration_table[s->level].max_lazy; + s->good_match = configuration_table[s->level].good_length; + s->nice_match = configuration_table[s->level].nice_length; + s->max_chain_length = configuration_table[s->level].max_chain; + + s->strstart = 0; + s->block_start = 0L; + s->lookahead = 0; + s->insert = 0; + s->match_length = s->prev_length = MIN_MATCH-1; + s->match_available = 0; + s->ins_h = 0; +#ifndef FASTEST +#ifdef ASMV + match_init(); /* initialize the asm code */ +#endif +#endif +} + +#ifndef FASTEST +/* =========================================================================== + * Set match_start to the longest match starting at the given string and + * return its length. Matches shorter or equal to prev_length are discarded, + * in which case the result is equal to prev_length and match_start is + * garbage. + * IN assertions: cur_match is the head of the hash chain for the current + * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 + * OUT assertion: the match length is not greater than s->lookahead. + */ +#ifndef ASMV +/* For 80x86 and 680x0, an optimized version will be provided in match.asm or + * match.S. The code will be functionally equivalent. + */ +local uInt longest_match(s, cur_match) + deflate_state *s; + IPos cur_match; /* current match */ +{ + unsigned chain_length = s->max_chain_length;/* max hash chain length */ + register Bytef *scan = s->window + s->strstart; /* current string */ + register Bytef *match; /* matched string */ + register int len; /* length of current match */ + int best_len = s->prev_length; /* best match length so far */ + int nice_match = s->nice_match; /* stop if match long enough */ + IPos limit = s->strstart > (IPos)MAX_DIST(s) ? + s->strstart - (IPos)MAX_DIST(s) : NIL; + /* Stop when cur_match becomes <= limit. To simplify the code, + * we prevent matches with the string of window index 0. + */ + Posf *prev = s->prev; + uInt wmask = s->w_mask; + +#ifdef UNALIGNED_OK + /* Compare two bytes at a time. Note: this is not always beneficial. + * Try with and without -DUNALIGNED_OK to check. + */ + register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1; + register ush scan_start = *(ushf*)scan; + register ush scan_end = *(ushf*)(scan+best_len-1); +#else + register Bytef *strend = s->window + s->strstart + MAX_MATCH; + register Byte scan_end1 = scan[best_len-1]; + register Byte scan_end = scan[best_len]; +#endif + + /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. + * It is easy to get rid of this optimization if necessary. + */ + Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); + + /* Do not waste too much time if we already have a good match: */ + if (s->prev_length >= s->good_match) { + chain_length >>= 2; + } + /* Do not look for matches beyond the end of the input. This is necessary + * to make deflate deterministic. + */ + if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; + + Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); + + do { + Assert(cur_match < s->strstart, "no future"); + match = s->window + cur_match; + + /* Skip to next match if the match length cannot increase + * or if the match length is less than 2. Note that the checks below + * for insufficient lookahead only occur occasionally for performance + * reasons. Therefore uninitialized memory will be accessed, and + * conditional jumps will be made that depend on those values. + * However the length of the match is limited to the lookahead, so + * the output of deflate is not affected by the uninitialized values. + */ +#if (defined(UNALIGNED_OK) && MAX_MATCH == 258) + /* This code assumes sizeof(unsigned short) == 2. Do not use + * UNALIGNED_OK if your compiler uses a different size. + */ + if (*(ushf*)(match+best_len-1) != scan_end || + *(ushf*)match != scan_start) continue; + + /* It is not necessary to compare scan[2] and match[2] since they are + * always equal when the other bytes match, given that the hash keys + * are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at + * strstart+3, +5, ... up to strstart+257. We check for insufficient + * lookahead only every 4th comparison; the 128th check will be made + * at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is + * necessary to put more guard bytes at the end of the window, or + * to check more often for insufficient lookahead. + */ + Assert(scan[2] == match[2], "scan[2]?"); + scan++, match++; + do { + } while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) && + *(ushf*)(scan+=2) == *(ushf*)(match+=2) && + *(ushf*)(scan+=2) == *(ushf*)(match+=2) && + *(ushf*)(scan+=2) == *(ushf*)(match+=2) && + scan < strend); + /* The funny "do {}" generates better code on most compilers */ + + /* Here, scan <= window+strstart+257 */ + Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + if (*scan == *match) scan++; + + len = (MAX_MATCH - 1) - (int)(strend-scan); + scan = strend - (MAX_MATCH-1); + +#else /* UNALIGNED_OK */ + + if (match[best_len] != scan_end || + match[best_len-1] != scan_end1 || + *match != *scan || + *++match != scan[1]) continue; + + /* The check at best_len-1 can be removed because it will be made + * again later. (This heuristic is not always a win.) + * It is not necessary to compare scan[2] and match[2] since they + * are always equal when the other bytes match, given that + * the hash keys are equal and that HASH_BITS >= 8. + */ + scan += 2, match++; + Assert(*scan == *match, "match[2]?"); + + /* We check for insufficient lookahead only every 8th comparison; + * the 256th check will be made at strstart+258. + */ + do { + } while (*++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + scan < strend); + + Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + + len = MAX_MATCH - (int)(strend - scan); + scan = strend - MAX_MATCH; + +#endif /* UNALIGNED_OK */ + + if (len > best_len) { + s->match_start = cur_match; + best_len = len; + if (len >= nice_match) break; +#ifdef UNALIGNED_OK + scan_end = *(ushf*)(scan+best_len-1); +#else + scan_end1 = scan[best_len-1]; + scan_end = scan[best_len]; +#endif + } + } while ((cur_match = prev[cur_match & wmask]) > limit + && --chain_length != 0); + + if ((uInt)best_len <= s->lookahead) return (uInt)best_len; + return s->lookahead; +} +#endif /* ASMV */ + +#else /* FASTEST */ + +/* --------------------------------------------------------------------------- + * Optimized version for FASTEST only + */ +local uInt longest_match(s, cur_match) + deflate_state *s; + IPos cur_match; /* current match */ +{ + register Bytef *scan = s->window + s->strstart; /* current string */ + register Bytef *match; /* matched string */ + register int len; /* length of current match */ + register Bytef *strend = s->window + s->strstart + MAX_MATCH; + + /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. + * It is easy to get rid of this optimization if necessary. + */ + Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever"); + + Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); + + Assert(cur_match < s->strstart, "no future"); + + match = s->window + cur_match; + + /* Return failure if the match length is less than 2: + */ + if (match[0] != scan[0] || match[1] != scan[1]) return MIN_MATCH-1; + + /* The check at best_len-1 can be removed because it will be made + * again later. (This heuristic is not always a win.) + * It is not necessary to compare scan[2] and match[2] since they + * are always equal when the other bytes match, given that + * the hash keys are equal and that HASH_BITS >= 8. + */ + scan += 2, match += 2; + Assert(*scan == *match, "match[2]?"); + + /* We check for insufficient lookahead only every 8th comparison; + * the 256th check will be made at strstart+258. + */ + do { + } while (*++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + *++scan == *++match && *++scan == *++match && + scan < strend); + + Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); + + len = MAX_MATCH - (int)(strend - scan); + + if (len < MIN_MATCH) return MIN_MATCH - 1; + + s->match_start = cur_match; + return (uInt)len <= s->lookahead ? (uInt)len : s->lookahead; +} + +#endif /* FASTEST */ + +#ifdef DEBUG +/* =========================================================================== + * Check that the match at match_start is indeed a match. + */ +local void check_match(s, start, match, length) + deflate_state *s; + IPos start, match; + int length; +{ + /* check that the match is indeed a match */ + if (zmemcmp(s->window + match, + s->window + start, length) != EQUAL) { + fprintf(stderr, " start %u, match %u, length %d\n", + start, match, length); + do { + fprintf(stderr, "%c%c", s->window[match++], s->window[start++]); + } while (--length != 0); + z_error("invalid match"); + } + if (z_verbose > 1) { + fprintf(stderr,"\\[%d,%d]", start-match, length); + do { putc(s->window[start++], stderr); } while (--length != 0); + } +} +#else +# define check_match(s, start, match, length) +#endif /* DEBUG */ + +/* =========================================================================== + * Fill the window when the lookahead becomes insufficient. + * Updates strstart and lookahead. + * + * IN assertion: lookahead < MIN_LOOKAHEAD + * OUT assertions: strstart <= window_size-MIN_LOOKAHEAD + * At least one byte has been read, or avail_in == 0; reads are + * performed for at least two bytes (required for the zip translate_eol + * option -- not supported here). + */ +local void fill_window(s) + deflate_state *s; +{ + register unsigned n, m; + register Posf *p; + unsigned more; /* Amount of free space at the end of the window. */ + uInt wsize = s->w_size; + + Assert(s->lookahead < MIN_LOOKAHEAD, "already enough lookahead"); + + do { + more = (unsigned)(s->window_size -(ulg)s->lookahead -(ulg)s->strstart); + + /* Deal with !@#$% 64K limit: */ + if (sizeof(int) <= 2) { + if (more == 0 && s->strstart == 0 && s->lookahead == 0) { + more = wsize; + + } else if (more == (unsigned)(-1)) { + /* Very unlikely, but possible on 16 bit machine if + * strstart == 0 && lookahead == 1 (input done a byte at time) + */ + more--; + } + } + + /* If the window is almost full and there is insufficient lookahead, + * move the upper half to the lower one to make room in the upper half. + */ + if (s->strstart >= wsize+MAX_DIST(s)) { + + zmemcpy(s->window, s->window+wsize, (unsigned)wsize); + s->match_start -= wsize; + s->strstart -= wsize; /* we now have strstart >= MAX_DIST */ + s->block_start -= (int) wsize; + + /* Slide the hash table (could be avoided with 32 bit values + at the expense of memory usage). We slide even when level == 0 + to keep the hash table consistent if we switch back to level > 0 + later. (Using level 0 permanently is not an optimal usage of + zlib, so we don't care about this pathological case.) + */ + n = s->hash_size; + p = &s->head[n]; + do { + m = *--p; + *p = (Pos)(m >= wsize ? m-wsize : NIL); + } while (--n); + + n = wsize; +#ifndef FASTEST + p = &s->prev[n]; + do { + m = *--p; + *p = (Pos)(m >= wsize ? m-wsize : NIL); + /* If n is not on any hash chain, prev[n] is garbage but + * its value will never be used. + */ + } while (--n); +#endif + more += wsize; + } + if (s->strm->avail_in == 0) break; + + /* If there was no sliding: + * strstart <= WSIZE+MAX_DIST-1 && lookahead <= MIN_LOOKAHEAD - 1 && + * more == window_size - lookahead - strstart + * => more >= window_size - (MIN_LOOKAHEAD-1 + WSIZE + MAX_DIST-1) + * => more >= window_size - 2*WSIZE + 2 + * In the BIG_MEM or MMAP case (not yet supported), + * window_size == input_size + MIN_LOOKAHEAD && + * strstart + s->lookahead <= input_size => more >= MIN_LOOKAHEAD. + * Otherwise, window_size == 2*WSIZE so more >= 2. + * If there was sliding, more >= WSIZE. So in all cases, more >= 2. + */ + Assert(more >= 2, "more < 2"); + + n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more); + s->lookahead += n; + + /* Initialize the hash value now that we have some input: */ + if (s->lookahead + s->insert >= MIN_MATCH) { + uInt str = s->strstart - s->insert; + s->ins_h = s->window[str]; + UPDATE_HASH(s, s->ins_h, s->window[str + 1]); +#if MIN_MATCH != 3 + Call UPDATE_HASH() MIN_MATCH-3 more times +#endif + while (s->insert) { + UPDATE_HASH(s, s->ins_h, s->window[str + MIN_MATCH-1]); +#ifndef FASTEST + s->prev[str & s->w_mask] = s->head[s->ins_h]; +#endif + s->head[s->ins_h] = (Pos)str; + str++; + s->insert--; + if (s->lookahead + s->insert < MIN_MATCH) + break; + } + } + /* If the whole input has less than MIN_MATCH bytes, ins_h is garbage, + * but this is not important since only literal bytes will be emitted. + */ + + } while (s->lookahead < MIN_LOOKAHEAD && s->strm->avail_in != 0); + + /* If the WIN_INIT bytes after the end of the current data have never been + * written, then zero those bytes in order to avoid memory check reports of + * the use of uninitialized (or uninitialised as Julian writes) bytes by + * the longest match routines. Update the high water mark for the next + * time through here. WIN_INIT is set to MAX_MATCH since the longest match + * routines allow scanning to strstart + MAX_MATCH, ignoring lookahead. + */ + if (s->high_water < s->window_size) { + ulg curr = s->strstart + (ulg)(s->lookahead); + ulg init; + + if (s->high_water < curr) { + /* Previous high water mark below current data -- zero WIN_INIT + * bytes or up to end of window, whichever is less. + */ + init = s->window_size - curr; + if (init > WIN_INIT) + init = WIN_INIT; + zmemzero(s->window + curr, (unsigned)init); + s->high_water = curr + init; + } + else if (s->high_water < (ulg)curr + WIN_INIT) { + /* High water mark at or above current data, but below current data + * plus WIN_INIT -- zero out to current data plus WIN_INIT, or up + * to end of window, whichever is less. + */ + init = (ulg)curr + WIN_INIT - s->high_water; + if (init > s->window_size - s->high_water) + init = s->window_size - s->high_water; + zmemzero(s->window + s->high_water, (unsigned)init); + s->high_water += init; + } + } + + Assert((ulg)s->strstart <= s->window_size - MIN_LOOKAHEAD, + "not enough room for search"); +} + +/* =========================================================================== + * Flush the current block, with given end-of-file flag. + * IN assertion: strstart is set to the end of the current match. + */ +#define FLUSH_BLOCK_ONLY(s, last) { \ + _tr_flush_block(s, (s->block_start >= 0L ? \ + (charf *)&s->window[(unsigned)s->block_start] : \ + (charf *)Z_NULL), \ + (ulg)((int)s->strstart - s->block_start), \ + (last)); \ + s->block_start = s->strstart; \ + flush_pending(s->strm); \ + Tracev((stderr,"[FLUSH]")); \ +} + +/* Same but force premature exit if necessary. */ +#define FLUSH_BLOCK(s, last) { \ + FLUSH_BLOCK_ONLY(s, last); \ + if (s->strm->avail_out == 0) return (last) ? finish_started : need_more; \ +} + +/* =========================================================================== + * Copy without compression as much as possible from the input stream, return + * the current block state. + * This function does not insert new strings in the dictionary since + * uncompressible data is probably not useful. This function is used + * only for the level=0 compression option. + * NOTE: this function should be optimized to avoid extra copying from + * window to pending_buf. + */ +local block_state deflate_stored(s, flush) + deflate_state *s; + int flush; +{ + /* Stored blocks are limited to 0xffff bytes, pending_buf is limited + * to pending_buf_size, and each stored block has a 5 byte header: + */ + ulg max_block_size = 0xffff; + ulg max_start; + + if (max_block_size > s->pending_buf_size - 5) { + max_block_size = s->pending_buf_size - 5; + } + + /* Copy as much as possible from input to output: */ + for (;;) { + /* Fill the window as much as possible: */ + if (s->lookahead <= 1) { + + Assert(s->strstart < s->w_size+MAX_DIST(s) || + s->block_start >= (int)s->w_size, "slide too late"); + + fill_window(s); + if (s->lookahead == 0 && flush == Z_NO_FLUSH) return need_more; + + if (s->lookahead == 0) break; /* flush the current block */ + } + Assert(s->block_start >= 0L, "block gone"); + + s->strstart += s->lookahead; + s->lookahead = 0; + + /* Emit a stored block if pending_buf will be full: */ + max_start = s->block_start + max_block_size; + if (s->strstart == 0 || (ulg)s->strstart >= max_start) { + /* strstart == 0 is possible when wraparound on 16-bit machine */ + s->lookahead = (uInt)(s->strstart - max_start); + s->strstart = (uInt)max_start; + FLUSH_BLOCK(s, 0); + } + /* Flush if we may have to slide, otherwise block_start may become + * negative and the data will be gone: + */ + if (s->strstart - (uInt)s->block_start >= MAX_DIST(s)) { + FLUSH_BLOCK(s, 0); + } + } + s->insert = 0; + if (flush == Z_FINISH) { + FLUSH_BLOCK(s, 1); + return finish_done; + } + if ((int)s->strstart > s->block_start) + FLUSH_BLOCK(s, 0); + return block_done; +} + +/* =========================================================================== + * Compress as much as possible from the input stream, return the current + * block state. + * This function does not perform lazy evaluation of matches and inserts + * new strings in the dictionary only for unmatched strings or for short + * matches. It is used only for the fast compression options. + */ +local block_state deflate_fast(s, flush) + deflate_state *s; + int flush; +{ + IPos hash_head; /* head of the hash chain */ + int bflush; /* set if current block must be flushed */ + + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the next match, plus MIN_MATCH bytes to insert the + * string following the next match. + */ + if (s->lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { + return need_more; + } + if (s->lookahead == 0) break; /* flush the current block */ + } + + /* Insert the string window[strstart .. strstart+2] in the + * dictionary, and set hash_head to the head of the hash chain: + */ + hash_head = NIL; + if (s->lookahead >= MIN_MATCH) { + INSERT_STRING(s, s->strstart, hash_head); + } + + /* Find the longest match, discarding those <= prev_length. + * At this point we have always match_length < MIN_MATCH + */ + if (hash_head != NIL && s->strstart - hash_head <= MAX_DIST(s)) { + /* To simplify the code, we prevent matches with the string + * of window index 0 (in particular we have to avoid a match + * of the string with itself at the start of the input file). + */ + s->match_length = longest_match (s, hash_head); + /* longest_match() sets match_start */ + } + if (s->match_length >= MIN_MATCH) { + check_match(s, s->strstart, s->match_start, s->match_length); + + _tr_tally_dist(s, s->strstart - s->match_start, + s->match_length - MIN_MATCH, bflush); + + s->lookahead -= s->match_length; + + /* Insert new strings in the hash table only if the match length + * is not too large. This saves time but degrades compression. + */ +#ifndef FASTEST + if (s->match_length <= s->max_insert_length && + s->lookahead >= MIN_MATCH) { + s->match_length--; /* string at strstart already in table */ + do { + s->strstart++; + INSERT_STRING(s, s->strstart, hash_head); + /* strstart never exceeds WSIZE-MAX_MATCH, so there are + * always MIN_MATCH bytes ahead. + */ + } while (--s->match_length != 0); + s->strstart++; + } else +#endif + { + s->strstart += s->match_length; + s->match_length = 0; + s->ins_h = s->window[s->strstart]; + UPDATE_HASH(s, s->ins_h, s->window[s->strstart+1]); +#if MIN_MATCH != 3 + Call UPDATE_HASH() MIN_MATCH-3 more times +#endif + /* If lookahead < MIN_MATCH, ins_h is garbage, but it does not + * matter since it will be recomputed at next deflate call. + */ + } + } else { + /* No match, output a literal byte */ + Tracevv((stderr,"%c", s->window[s->strstart])); + _tr_tally_lit (s, s->window[s->strstart], bflush); + s->lookahead--; + s->strstart++; + } + if (bflush) FLUSH_BLOCK(s, 0); + } + s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; + if (flush == Z_FINISH) { + FLUSH_BLOCK(s, 1); + return finish_done; + } + if (s->last_lit) + FLUSH_BLOCK(s, 0); + return block_done; +} + +#ifndef FASTEST +/* =========================================================================== + * Same as above, but achieves better compression. We use a lazy + * evaluation for matches: a match is finally adopted only if there is + * no better match at the next window position. + */ +local block_state deflate_slow(s, flush) + deflate_state *s; + int flush; +{ + IPos hash_head; /* head of hash chain */ + int bflush; /* set if current block must be flushed */ + + /* Process the input block. */ + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the next match, plus MIN_MATCH bytes to insert the + * string following the next match. + */ + if (s->lookahead < MIN_LOOKAHEAD) { + fill_window(s); + if (s->lookahead < MIN_LOOKAHEAD && flush == Z_NO_FLUSH) { + return need_more; + } + if (s->lookahead == 0) break; /* flush the current block */ + } + + /* Insert the string window[strstart .. strstart+2] in the + * dictionary, and set hash_head to the head of the hash chain: + */ + hash_head = NIL; + if (s->lookahead >= MIN_MATCH) { + INSERT_STRING(s, s->strstart, hash_head); + } + + /* Find the longest match, discarding those <= prev_length. + */ + s->prev_length = s->match_length, s->prev_match = s->match_start; + s->match_length = MIN_MATCH-1; + + if (hash_head != NIL && s->prev_length < s->max_lazy_match && + s->strstart - hash_head <= MAX_DIST(s)) { + /* To simplify the code, we prevent matches with the string + * of window index 0 (in particular we have to avoid a match + * of the string with itself at the start of the input file). + */ + s->match_length = longest_match (s, hash_head); + /* longest_match() sets match_start */ + + if (s->match_length <= 5 && (s->strategy == Z_FILTERED +#if TOO_FAR <= 32767 + || (s->match_length == MIN_MATCH && + s->strstart - s->match_start > TOO_FAR) +#endif + )) { + + /* If prev_match is also MIN_MATCH, match_start is garbage + * but we will ignore the current match anyway. + */ + s->match_length = MIN_MATCH-1; + } + } + /* If there was a match at the previous step and the current + * match is not better, output the previous match: + */ + if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) { + uInt max_insert = s->strstart + s->lookahead - MIN_MATCH; + /* Do not insert strings in hash table beyond this. */ + + check_match(s, s->strstart-1, s->prev_match, s->prev_length); + + _tr_tally_dist(s, s->strstart -1 - s->prev_match, + s->prev_length - MIN_MATCH, bflush); + + /* Insert in hash table all strings up to the end of the match. + * strstart-1 and strstart are already inserted. If there is not + * enough lookahead, the last two strings are not inserted in + * the hash table. + */ + s->lookahead -= s->prev_length-1; + s->prev_length -= 2; + do { + if (++s->strstart <= max_insert) { + INSERT_STRING(s, s->strstart, hash_head); + } + } while (--s->prev_length != 0); + s->match_available = 0; + s->match_length = MIN_MATCH-1; + s->strstart++; + + if (bflush) FLUSH_BLOCK(s, 0); + + } else if (s->match_available) { + /* If there was no match at the previous position, output a + * single literal. If there was a match but the current match + * is longer, truncate the previous match to a single literal. + */ + Tracevv((stderr,"%c", s->window[s->strstart-1])); + _tr_tally_lit(s, s->window[s->strstart-1], bflush); + if (bflush) { + FLUSH_BLOCK_ONLY(s, 0); + } + s->strstart++; + s->lookahead--; + if (s->strm->avail_out == 0) return need_more; + } else { + /* There is no previous match to compare with, wait for + * the next step to decide. + */ + s->match_available = 1; + s->strstart++; + s->lookahead--; + } + } + Assert (flush != Z_NO_FLUSH, "no flush?"); + if (s->match_available) { + Tracevv((stderr,"%c", s->window[s->strstart-1])); + _tr_tally_lit(s, s->window[s->strstart-1], bflush); + s->match_available = 0; + } + s->insert = s->strstart < MIN_MATCH-1 ? s->strstart : MIN_MATCH-1; + if (flush == Z_FINISH) { + FLUSH_BLOCK(s, 1); + return finish_done; + } + if (s->last_lit) + FLUSH_BLOCK(s, 0); + return block_done; +} +#endif /* FASTEST */ + +/* =========================================================================== + * For Z_RLE, simply look for runs of bytes, generate matches only of distance + * one. Do not maintain a hash table. (It will be regenerated if this run of + * deflate switches away from Z_RLE.) + */ +local block_state deflate_rle(s, flush) + deflate_state *s; + int flush; +{ + int bflush; /* set if current block must be flushed */ + uInt prev; /* byte at distance one to match */ + Bytef *scan, *strend; /* scan goes up to strend for length of run */ + + for (;;) { + /* Make sure that we always have enough lookahead, except + * at the end of the input file. We need MAX_MATCH bytes + * for the longest run, plus one for the unrolled loop. + */ + if (s->lookahead <= MAX_MATCH) { + fill_window(s); + if (s->lookahead <= MAX_MATCH && flush == Z_NO_FLUSH) { + return need_more; + } + if (s->lookahead == 0) break; /* flush the current block */ + } + + /* See how many times the previous byte repeats */ + s->match_length = 0; + if (s->lookahead >= MIN_MATCH && s->strstart > 0) { + scan = s->window + s->strstart - 1; + prev = *scan; + if (prev == *++scan && prev == *++scan && prev == *++scan) { + strend = s->window + s->strstart + MAX_MATCH; + do { + } while (prev == *++scan && prev == *++scan && + prev == *++scan && prev == *++scan && + prev == *++scan && prev == *++scan && + prev == *++scan && prev == *++scan && + scan < strend); + s->match_length = MAX_MATCH - (int)(strend - scan); + if (s->match_length > s->lookahead) + s->match_length = s->lookahead; + } + Assert(scan <= s->window+(uInt)(s->window_size-1), "wild scan"); + } + + /* Emit match if have run of MIN_MATCH or longer, else emit literal */ + if (s->match_length >= MIN_MATCH) { + check_match(s, s->strstart, s->strstart - 1, s->match_length); + + _tr_tally_dist(s, 1, s->match_length - MIN_MATCH, bflush); + + s->lookahead -= s->match_length; + s->strstart += s->match_length; + s->match_length = 0; + } else { + /* No match, output a literal byte */ + Tracevv((stderr,"%c", s->window[s->strstart])); + _tr_tally_lit (s, s->window[s->strstart], bflush); + s->lookahead--; + s->strstart++; + } + if (bflush) FLUSH_BLOCK(s, 0); + } + s->insert = 0; + if (flush == Z_FINISH) { + FLUSH_BLOCK(s, 1); + return finish_done; + } + if (s->last_lit) + FLUSH_BLOCK(s, 0); + return block_done; +} + +/* =========================================================================== + * For Z_HUFFMAN_ONLY, do not look for matches. Do not maintain a hash table. + * (It will be regenerated if this run of deflate switches away from Huffman.) + */ +local block_state deflate_huff(s, flush) + deflate_state *s; + int flush; +{ + int bflush; /* set if current block must be flushed */ + + for (;;) { + /* Make sure that we have a literal to write. */ + if (s->lookahead == 0) { + fill_window(s); + if (s->lookahead == 0) { + if (flush == Z_NO_FLUSH) + return need_more; + break; /* flush the current block */ + } + } + + /* Output a literal byte */ + s->match_length = 0; + Tracevv((stderr,"%c", s->window[s->strstart])); + _tr_tally_lit (s, s->window[s->strstart], bflush); + s->lookahead--; + s->strstart++; + if (bflush) FLUSH_BLOCK(s, 0); + } + s->insert = 0; + if (flush == Z_FINISH) { + FLUSH_BLOCK(s, 1); + return finish_done; + } + if (s->last_lit) + FLUSH_BLOCK(s, 0); + return block_done; +} diff --git a/zlib/thumb/deflate.h b/zlib/thumb/deflate.h new file mode 100644 index 0000000..064b3ea --- /dev/null +++ b/zlib/thumb/deflate.h @@ -0,0 +1,346 @@ +/* deflate.h -- internal compression state + * Copyright (C) 1995-2012 Jean-loup Gailly + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +/* @(#) $Id$ */ + +#ifndef DEFLATE_H +#define DEFLATE_H + +#include "zutil.h" + +/* define NO_GZIP when compiling if you want to disable gzip header and + trailer creation by deflate(). NO_GZIP would be used to avoid linking in + the crc code when it is not needed. For shared libraries, gzip encoding + should be left enabled. */ +#ifndef NO_GZIP +# define GZIP +#endif + +/* =========================================================================== + * Internal compression state. + */ + +#define LENGTH_CODES 29 +/* number of length codes, not counting the special END_BLOCK code */ + +#define LITERALS 256 +/* number of literal bytes 0..255 */ + +#define L_CODES (LITERALS+1+LENGTH_CODES) +/* number of Literal or Length codes, including the END_BLOCK code */ + +#define D_CODES 30 +/* number of distance codes */ + +#define BL_CODES 19 +/* number of codes used to transfer the bit lengths */ + +#define HEAP_SIZE (2*L_CODES+1) +/* maximum heap size */ + +#define MAX_BITS 15 +/* All codes must not exceed MAX_BITS bits */ + +#define Buf_size 16 +/* size of bit buffer in bi_buf */ + +#define INIT_STATE 42 +#define EXTRA_STATE 69 +#define NAME_STATE 73 +#define COMMENT_STATE 91 +#define HCRC_STATE 103 +#define BUSY_STATE 113 +#define FINISH_STATE 666 +/* Stream status */ + + +/* Data structure describing a single value and its code string. */ +typedef struct ct_data_s { + union { + ush freq; /* frequency count */ + ush code; /* bit string */ + } fc; + union { + ush dad; /* father node in Huffman tree */ + ush len; /* length of bit string */ + } dl; +} FAR ct_data; + +#define Freq fc.freq +#define Code fc.code +#define Dad dl.dad +#define Len dl.len + +typedef struct static_tree_desc_s static_tree_desc; + +typedef struct tree_desc_s { + ct_data *dyn_tree; /* the dynamic tree */ + int max_code; /* largest code with non zero frequency */ + static_tree_desc *stat_desc; /* the corresponding static tree */ +} FAR tree_desc; + +typedef ush Pos; +typedef Pos FAR Posf; +typedef unsigned IPos; + +/* A Pos is an index in the character window. We use short instead of int to + * save space in the various tables. IPos is used only for parameter passing. + */ + +typedef struct internal_state { + z_streamp strm; /* pointer back to this zlib stream */ + int status; /* as the name implies */ + Bytef *pending_buf; /* output still pending */ + ulg pending_buf_size; /* size of pending_buf */ + Bytef *pending_out; /* next pending byte to output to the stream */ + uInt pending; /* nb of bytes in the pending buffer */ + int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ + gz_headerp gzhead; /* gzip header information to write */ + uInt gzindex; /* where in extra, name, or comment */ + Byte method; /* STORED (for zip only) or DEFLATED */ + int last_flush; /* value of flush param for previous deflate call */ + + /* used by deflate.c: */ + + uInt w_size; /* LZ77 window size (32K by default) */ + uInt w_bits; /* log2(w_size) (8..16) */ + uInt w_mask; /* w_size - 1 */ + + Bytef *window; + /* Sliding window. Input bytes are read into the second half of the window, + * and move to the first half later to keep a dictionary of at least wSize + * bytes. With this organization, matches are limited to a distance of + * wSize-MAX_MATCH bytes, but this ensures that IO is always + * performed with a length multiple of the block size. Also, it limits + * the window size to 64K, which is quite useful on MSDOS. + * To do: use the user input buffer as sliding window. + */ + + ulg window_size; + /* Actual size of window: 2*wSize, except when the user input buffer + * is directly used as sliding window. + */ + + Posf *prev; + /* Link to older string with same hash index. To limit the size of this + * array to 64K, this link is maintained only for the last 32K strings. + * An index in this array is thus a window index modulo 32K. + */ + + Posf *head; /* Heads of the hash chains or NIL. */ + + uInt ins_h; /* hash index of string to be inserted */ + uInt hash_size; /* number of elements in hash table */ + uInt hash_bits; /* log2(hash_size) */ + uInt hash_mask; /* hash_size-1 */ + + uInt hash_shift; + /* Number of bits by which ins_h must be shifted at each input + * step. It must be such that after MIN_MATCH steps, the oldest + * byte no longer takes part in the hash key, that is: + * hash_shift * MIN_MATCH >= hash_bits + */ + + int block_start; + /* Window position at the beginning of the current output block. Gets + * negative when the window is moved backwards. + */ + + uInt match_length; /* length of best match */ + IPos prev_match; /* previous match */ + int match_available; /* set if previous match exists */ + uInt strstart; /* start of string to insert */ + uInt match_start; /* start of matching string */ + uInt lookahead; /* number of valid bytes ahead in window */ + + uInt prev_length; + /* Length of the best match at previous step. Matches not greater than this + * are discarded. This is used in the lazy match evaluation. + */ + + uInt max_chain_length; + /* To speed up deflation, hash chains are never searched beyond this + * length. A higher limit improves compression ratio but degrades the + * speed. + */ + + uInt max_lazy_match; + /* Attempt to find a better match only when the current match is strictly + * smaller than this value. This mechanism is used only for compression + * levels >= 4. + */ +# define max_insert_length max_lazy_match + /* Insert new strings in the hash table only if the match length is not + * greater than this length. This saves time but degrades compression. + * max_insert_length is used only for compression levels <= 3. + */ + + int level; /* compression level (1..9) */ + int strategy; /* favor or force Huffman coding*/ + + uInt good_match; + /* Use a faster search when the previous match is longer than this */ + + int nice_match; /* Stop searching when current match exceeds this */ + + /* used by trees.c: */ + /* Didn't use ct_data typedef below to suppress compiler warning */ + struct ct_data_s dyn_ltree[HEAP_SIZE]; /* literal and length tree */ + struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */ + struct ct_data_s bl_tree[2*BL_CODES+1]; /* Huffman tree for bit lengths */ + + struct tree_desc_s l_desc; /* desc. for literal tree */ + struct tree_desc_s d_desc; /* desc. for distance tree */ + struct tree_desc_s bl_desc; /* desc. for bit length tree */ + + ush bl_count[MAX_BITS+1]; + /* number of codes at each bit length for an optimal tree */ + + int heap[2*L_CODES+1]; /* heap used to build the Huffman trees */ + int heap_len; /* number of elements in the heap */ + int heap_max; /* element of largest frequency */ + /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. + * The same heap array is used to build all trees. + */ + + uch depth[2*L_CODES+1]; + /* Depth of each subtree used as tie breaker for trees of equal frequency + */ + + uchf *l_buf; /* buffer for literals or lengths */ + + uInt lit_bufsize; + /* Size of match buffer for literals/lengths. There are 4 reasons for + * limiting lit_bufsize to 64K: + * - frequencies can be kept in 16 bit counters + * - if compression is not successful for the first block, all input + * data is still in the window so we can still emit a stored block even + * when input comes from standard input. (This can also be done for + * all blocks if lit_bufsize is not greater than 32K.) + * - if compression is not successful for a file smaller than 64K, we can + * even emit a stored file instead of a stored block (saving 5 bytes). + * This is applicable only for zip (not gzip or zlib). + * - creating new Huffman trees less frequently may not provide fast + * adaptation to changes in the input data statistics. (Take for + * example a binary file with poorly compressible code followed by + * a highly compressible string table.) Smaller buffer sizes give + * fast adaptation but have of course the overhead of transmitting + * trees more frequently. + * - I can't count above 4 + */ + + uInt last_lit; /* running index in l_buf */ + + ushf *d_buf; + /* Buffer for distances. To simplify the code, d_buf and l_buf have + * the same number of elements. To use different lengths, an extra flag + * array would be necessary. + */ + + ulg opt_len; /* bit length of current block with optimal trees */ + ulg static_len; /* bit length of current block with static trees */ + uInt matches; /* number of string matches in current block */ + uInt insert; /* bytes at end of window left to insert */ + +#ifdef DEBUG + ulg compressed_len; /* total bit length of compressed file mod 2^32 */ + ulg bits_sent; /* bit length of compressed data sent mod 2^32 */ +#endif + + ush bi_buf; + /* Output buffer. bits are inserted starting at the bottom (least + * significant bits). + */ + int bi_valid; + /* Number of valid bits in bi_buf. All bits above the last valid bit + * are always zero. + */ + + ulg high_water; + /* High water mark offset in window for initialized bytes -- bytes above + * this are set to zero in order to avoid memory check warnings when + * longest match routines access bytes past the input. This is then + * updated to the new high water mark. + */ + +} FAR deflate_state; + +/* Output a byte on the stream. + * IN assertion: there is enough room in pending_buf. + */ +#define put_byte(s, c) {s->pending_buf[s->pending++] = (c);} + + +#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1) +/* Minimum amount of lookahead, except at the end of the input file. + * See deflate.c for comments about the MIN_MATCH+1. + */ + +#define MAX_DIST(s) ((s)->w_size-MIN_LOOKAHEAD) +/* In order to simplify the code, particularly on 16 bit machines, match + * distances are limited to MAX_DIST instead of WSIZE. + */ + +#define WIN_INIT MAX_MATCH +/* Number of bytes after end of data in window to initialize in order to avoid + memory checker errors from longest match routines */ + + /* in trees.c */ +void ZLIB_INTERNAL _tr_init OF((deflate_state *s)); +int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); +void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf, + ulg stored_len, int last)); +void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s)); +void ZLIB_INTERNAL _tr_align OF((deflate_state *s)); +void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf, + ulg stored_len, int last)); + +#define d_code(dist) \ + ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)]) +/* Mapping from a distance to a distance code. dist is the distance - 1 and + * must not have side effects. _dist_code[256] and _dist_code[257] are never + * used. + */ + +#ifndef DEBUG +/* Inline versions of _tr_tally for speed: */ + +#if defined(GEN_TREES_H) || !defined(STDC) + extern uch ZLIB_INTERNAL _length_code[]; + extern uch ZLIB_INTERNAL _dist_code[]; +#else + extern const uch ZLIB_INTERNAL _length_code[]; + extern const uch ZLIB_INTERNAL _dist_code[]; +#endif + +# define _tr_tally_lit(s, c, flush) \ + { uch cc = (c); \ + s->d_buf[s->last_lit] = 0; \ + s->l_buf[s->last_lit++] = cc; \ + s->dyn_ltree[cc].Freq++; \ + flush = (s->last_lit == s->lit_bufsize-1); \ + } +# define _tr_tally_dist(s, distance, length, flush) \ + { uch len = (length); \ + ush dist = (distance); \ + s->d_buf[s->last_lit] = dist; \ + s->l_buf[s->last_lit++] = len; \ + dist--; \ + s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \ + s->dyn_dtree[d_code(dist)].Freq++; \ + flush = (s->last_lit == s->lit_bufsize-1); \ + } +#else +# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c) +# define _tr_tally_dist(s, distance, length, flush) \ + flush = _tr_tally(s, distance, length) +#endif + +#endif /* DEFLATE_H */ diff --git a/zlib/thumb/gzguts.h b/zlib/thumb/gzguts.h new file mode 100644 index 0000000..245a793 --- /dev/null +++ b/zlib/thumb/gzguts.h @@ -0,0 +1,198 @@ +/* gzguts.h -- zlib internal header definitions for gz* operations + * Copyright (C) 2004, 2005, 2010, 2011, 2012 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#ifdef _LARGEFILE64_SOURCE +# ifndef _LARGEFILE_SOURCE +# define _LARGEFILE_SOURCE 1 +# endif +# ifdef _FILE_OFFSET_BITS +# undef _FILE_OFFSET_BITS +# endif +#endif + +#ifdef HAVE_HIDDEN +# define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) +#else +# define ZLIB_INTERNAL +#endif + +//#include +#include "zlib.h" +#ifdef STDC +//# include +void *ZMEMCPY(void *dest, const void *src, int n); +void *ZMEMSET(void *s, int c, int n); +//# include +void *ZCALLOC(int nmemb, int size); +void *ZMALLOC(int size); +void free(void *ptr); +//# include +#endif +//#include + +#ifdef _WIN32 +# include +#endif + +#if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32) +# include +#endif + +#ifdef NO_DEFLATE /* for compatibility with old definition */ +# define NO_GZCOMPRESS +#endif + +#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550) +# ifndef HAVE_VSNPRINTF +# define HAVE_VSNPRINTF +# endif +#endif + +#if defined(__CYGWIN__) +# ifndef HAVE_VSNPRINTF +# define HAVE_VSNPRINTF +# endif +#endif + +#if defined(MSDOS) && defined(__BORLANDC__) && (BORLANDC > 0x410) +# ifndef HAVE_VSNPRINTF +# define HAVE_VSNPRINTF +# endif +#endif + +#ifndef HAVE_VSNPRINTF +# ifdef MSDOS +/* vsnprintf may exist on some MS-DOS compilers (DJGPP?), + but for now we just assume it doesn't. */ +# define NO_vsnprintf +# endif +# ifdef __TURBOC__ +# define NO_vsnprintf +# endif +# ifdef WIN32 +/* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */ +# if !defined(vsnprintf) && !defined(NO_vsnprintf) +# if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 ) +# define vsnprintf _vsnprintf +# endif +# endif +# endif +# ifdef __SASC +# define NO_vsnprintf +# endif +# ifdef VMS +# define NO_vsnprintf +# endif +# ifdef __OS400__ +# define NO_vsnprintf +# endif +# ifdef __MVS__ +# define NO_vsnprintf +# endif +#endif + +#ifndef local +# define local static +#endif +/* compile with -Dlocal if your debugger can't find static symbols */ + +/* gz* functions always use library allocation functions */ +#ifndef STDC + extern voidp malloc OF((uInt size)); + extern void free OF((voidpf ptr)); +#endif + +/* get errno and strerror definition */ +#if defined UNDER_CE +# include +# define zstrerror() gz_strwinerror((DWORD)GetLastError()) +#else +# ifndef NO_STRERROR +//# include +# define zstrerror() strerror(errno) +# else +# define zstrerror() "stdio error (consult errno)" +# endif +#endif + +/* provide prototypes for these when building zlib without LFS */ +#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0 + ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); + ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); + ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); + ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); +#endif + +/* default memLevel */ +#if MAX_MEM_LEVEL >= 8 +# define DEF_MEM_LEVEL 8 +#else +# define DEF_MEM_LEVEL MAX_MEM_LEVEL +#endif + +/* default i/o buffer size -- double this for output when reading */ +#define GZBUFSIZE 8192 + +/* gzip modes, also provide a little integrity check on the passed structure */ +#define GZ_NONE 0 +#define GZ_READ 7247 +#define GZ_WRITE 31153 +#define GZ_APPEND 1 /* mode set to GZ_WRITE after the file is opened */ + +/* values for gz_state how */ +#define LOOK 0 /* look for a gzip header */ +#define COPY 1 /* copy input directly */ +#define GZIP 2 /* decompress a gzip stream */ + +/* internal gzip file state data structure */ +typedef struct { + /* exposed contents for gzgetc() macro */ + struct gzFile_s x; /* "x" for exposed */ + /* x.have: number of bytes available at x.next */ + /* x.next: next output data to deliver or write */ + /* x.pos: current position in uncompressed data */ + /* used for both reading and writing */ + int mode; /* see gzip modes above */ + int fd; /* file descriptor */ + char *path; /* path or fd for error messages */ + unsigned size; /* buffer size, zero if not allocated yet */ + unsigned want; /* requested buffer size, default is GZBUFSIZE */ + unsigned char *in; /* input buffer */ + unsigned char *out; /* output buffer (double-sized when reading) */ + int direct; /* 0 if processing gzip, 1 if transparent */ + /* just for reading */ + int how; /* 0: get header, 1: copy, 2: decompress */ + z_off64_t start; /* where the gzip data started, for rewinding */ + int eof; /* true if end of input file reached */ + int past; /* true if read requested past end */ + /* just for writing */ + int level; /* compression level */ + int strategy; /* compression strategy */ + /* seek request */ + z_off64_t skip; /* amount to skip (already rewound if backwards) */ + int seek; /* true if seek request pending */ + /* error information */ + int err; /* error code */ + char *msg; /* error message */ + /* zlib inflate or deflate stream */ + z_stream strm; /* stream structure in-place (not a pointer) */ +} gz_state; +typedef gz_state FAR *gz_statep; + +/* shared functions */ +void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *)); +#if defined UNDER_CE +char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error)); +#endif + +/* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t + value -- needed when comparing unsigned to z_off64_t, which is signed + (possible z_off64_t types off_t, off64_t, and long are all signed) */ +#ifdef INT_MAX +# define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX) +#else +unsigned ZLIB_INTERNAL gz_intmax OF((void)); +# define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax()) +#endif diff --git a/zlib/thumb/inffast.c b/zlib/thumb/inffast.c new file mode 100644 index 0000000..900f2c2 --- /dev/null +++ b/zlib/thumb/inffast.c @@ -0,0 +1,340 @@ +/* inffast.c -- fast decoding + * Copyright (C) 1995-2008, 2010 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "zutil.h" +#include "inftrees.h" +#include "inflate.h" +#include "inffast.h" + +#ifndef ASMINF + +/* Allow machine dependent optimization for post-increment or pre-increment. + Based on testing to date, + Pre-increment preferred for: + - PowerPC G3 (Adler) + - MIPS R5000 (Randers-Pehrson) + Post-increment preferred for: + - none + No measurable difference: + - Pentium III (Anderson) + - M68060 (Nikl) + */ +#ifdef POSTINC +# define OFF 0 +# define PUP(a) *(a)++ +#else +# define OFF 1 +# define PUP(a) *++(a) +#endif + +/* + Decode literal, length, and distance codes and write out the resulting + literal and match bytes until either not enough input or output is + available, an end-of-block is encountered, or a data error is encountered. + When large enough input and output buffers are supplied to inflate(), for + example, a 16K input buffer and a 64K output buffer, more than 95% of the + inflate execution time is spent in this routine. + + Entry assumptions: + + state->mode == LEN + strm->avail_in >= 6 + strm->avail_out >= 258 + start >= strm->avail_out + state->bits < 8 + + On return, state->mode is one of: + + LEN -- ran out of enough output space or enough available input + TYPE -- reached end of block code, inflate() to interpret next block + BAD -- error in block data + + Notes: + + - The maximum input bits used by a length/distance pair is 15 bits for the + length code, 5 bits for the length extra, 15 bits for the distance code, + and 13 bits for the distance extra. This totals 48 bits, or six bytes. + Therefore if strm->avail_in >= 6, then there is enough input to avoid + checking for available input while decoding. + + - The maximum bytes that a single length/distance pair can output is 258 + bytes, which is the maximum length that can be coded. inflate_fast() + requires strm->avail_out >= 258 for each loop to avoid checking for + output space. + */ +void ZLIB_INTERNAL inflate_fast(strm, start) +z_streamp strm; +unsigned start; /* inflate()'s starting value for strm->avail_out */ +{ + struct inflate_state FAR *state; + unsigned char FAR *in; /* local strm->next_in */ + unsigned char FAR *last; /* while in < last, enough input available */ + unsigned char FAR *out; /* local strm->next_out */ + unsigned char FAR *beg; /* inflate()'s initial strm->next_out */ + unsigned char FAR *end; /* while out < end, enough space available */ +#ifdef INFLATE_STRICT + unsigned dmax; /* maximum distance from zlib header */ +#endif + unsigned wsize; /* window size or zero if not using window */ + unsigned whave; /* valid bytes in the window */ + unsigned wnext; /* window write index */ + unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */ + unsigned int hold; /* local strm->hold */ + unsigned bits; /* local strm->bits */ + code const FAR *lcode; /* local strm->lencode */ + code const FAR *dcode; /* local strm->distcode */ + unsigned lmask; /* mask for first level of length codes */ + unsigned dmask; /* mask for first level of distance codes */ + code here; /* retrieved table entry */ + unsigned op; /* code bits, operation, extra bits, or */ + /* window position, window bytes to copy */ + unsigned len; /* match length, unused bytes */ + unsigned dist; /* match distance */ + unsigned char FAR *from; /* where to copy match from */ + + /* copy state to local variables */ + state = (struct inflate_state FAR *)strm->state; + in = strm->next_in - OFF; + last = in + (strm->avail_in - 5); + out = strm->next_out - OFF; + beg = out - (start - strm->avail_out); + end = out + (strm->avail_out - 257); +#ifdef INFLATE_STRICT + dmax = state->dmax; +#endif + wsize = state->wsize; + whave = state->whave; + wnext = state->wnext; + window = state->window; + hold = state->hold; + bits = state->bits; + lcode = state->lencode; + dcode = state->distcode; + lmask = (1U << state->lenbits) - 1; + dmask = (1U << state->distbits) - 1; + + /* decode literals and length/distances until end-of-block or not enough + input data or output space */ + do { + if (bits < 15) { + hold += (unsigned int)(PUP(in)) << bits; + bits += 8; + hold += (unsigned int)(PUP(in)) << bits; + bits += 8; + } + here = lcode[hold & lmask]; + dolen: + op = (unsigned)(here.bits); + hold >>= op; + bits -= op; + op = (unsigned)(here.op); + if (op == 0) { /* literal */ + Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? + "inflate: literal '%c'\n" : + "inflate: literal 0x%02x\n", here.val)); + PUP(out) = (unsigned char)(here.val); + } + else if (op & 16) { /* length base */ + len = (unsigned)(here.val); + op &= 15; /* number of extra bits */ + if (op) { + if (bits < op) { + hold += (unsigned int)(PUP(in)) << bits; + bits += 8; + } + len += (unsigned)hold & ((1U << op) - 1); + hold >>= op; + bits -= op; + } + Tracevv((stderr, "inflate: length %u\n", len)); + if (bits < 15) { + hold += (unsigned int)(PUP(in)) << bits; + bits += 8; + hold += (unsigned int)(PUP(in)) << bits; + bits += 8; + } + here = dcode[hold & dmask]; + dodist: + op = (unsigned)(here.bits); + hold >>= op; + bits -= op; + op = (unsigned)(here.op); + if (op & 16) { /* distance base */ + dist = (unsigned)(here.val); + op &= 15; /* number of extra bits */ + if (bits < op) { + hold += (unsigned int)(PUP(in)) << bits; + bits += 8; + if (bits < op) { + hold += (unsigned int)(PUP(in)) << bits; + bits += 8; + } + } + dist += (unsigned)hold & ((1U << op) - 1); +#ifdef INFLATE_STRICT + if (dist > dmax) { + strm->msg = (char *)"invalid distance too far back"; + state->mode = BAD; + break; + } +#endif + hold >>= op; + bits -= op; + Tracevv((stderr, "inflate: distance %u\n", dist)); + op = (unsigned)(out - beg); /* max distance in output */ + if (dist > op) { /* see if copy from window */ + op = dist - op; /* distance back in window */ + if (op > whave) { + if (state->sane) { + strm->msg = + (char *)"invalid distance too far back"; + state->mode = BAD; + break; + } +#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR + if (len <= op - whave) { + do { + PUP(out) = 0; + } while (--len); + continue; + } + len -= op - whave; + do { + PUP(out) = 0; + } while (--op > whave); + if (op == 0) { + from = out - dist; + do { + PUP(out) = PUP(from); + } while (--len); + continue; + } +#endif + } + from = window - OFF; + if (wnext == 0) { /* very common case */ + from += wsize - op; + if (op < len) { /* some from window */ + len -= op; + do { + PUP(out) = PUP(from); + } while (--op); + from = out - dist; /* rest from output */ + } + } + else if (wnext < op) { /* wrap around window */ + from += wsize + wnext - op; + op -= wnext; + if (op < len) { /* some from end of window */ + len -= op; + do { + PUP(out) = PUP(from); + } while (--op); + from = window - OFF; + if (wnext < len) { /* some from start of window */ + op = wnext; + len -= op; + do { + PUP(out) = PUP(from); + } while (--op); + from = out - dist; /* rest from output */ + } + } + } + else { /* contiguous in window */ + from += wnext - op; + if (op < len) { /* some from window */ + len -= op; + do { + PUP(out) = PUP(from); + } while (--op); + from = out - dist; /* rest from output */ + } + } + while (len > 2) { + PUP(out) = PUP(from); + PUP(out) = PUP(from); + PUP(out) = PUP(from); + len -= 3; + } + if (len) { + PUP(out) = PUP(from); + if (len > 1) + PUP(out) = PUP(from); + } + } + else { + from = out - dist; /* copy direct from output */ + do { /* minimum length is three */ + PUP(out) = PUP(from); + PUP(out) = PUP(from); + PUP(out) = PUP(from); + len -= 3; + } while (len > 2); + if (len) { + PUP(out) = PUP(from); + if (len > 1) + PUP(out) = PUP(from); + } + } + } + else if ((op & 64) == 0) { /* 2nd level distance code */ + here = dcode[here.val + (hold & ((1U << op) - 1))]; + goto dodist; + } + else { + strm->msg = (char *)"invalid distance code"; + state->mode = BAD; + break; + } + } + else if ((op & 64) == 0) { /* 2nd level length code */ + here = lcode[here.val + (hold & ((1U << op) - 1))]; + goto dolen; + } + else if (op & 32) { /* end-of-block */ + Tracevv((stderr, "inflate: end of block\n")); + state->mode = TYPE; + break; + } + else { + strm->msg = (char *)"invalid literal/length code"; + state->mode = BAD; + break; + } + } while (in < last && out < end); + + /* return unused bytes (on entry, bits < 8, so in won't go too far back) */ + len = bits >> 3; + in -= len; + bits -= len << 3; + hold &= (1U << bits) - 1; + + /* update state and return */ + strm->next_in = in + OFF; + strm->next_out = out + OFF; + strm->avail_in = (unsigned)(in < last ? 5 + (last - in) : 5 - (in - last)); + strm->avail_out = (unsigned)(out < end ? + 257 + (end - out) : 257 - (out - end)); + state->hold = hold; + state->bits = bits; + return; +} + +/* + inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe): + - Using bit fields for code structure + - Different op definition to avoid & for extra bits (do & for table bits) + - Three separate decoding do-loops for direct, window, and wnext == 0 + - Special case for distance > 1 copies to do overlapped load and store copy + - Explicit branch predictions (based on measured branch probabilities) + - Deferring match copy and interspersed it with decoding subsequent codes + - Swapping literal/length else + - Swapping window/direct else + - Larger unrolled copy loops (three is about right) + - Moving len -= 3 statement into middle of loop + */ + +#endif /* !ASMINF */ diff --git a/zlib/thumb/inffast.h b/zlib/thumb/inffast.h new file mode 100644 index 0000000..e5c1aa4 --- /dev/null +++ b/zlib/thumb/inffast.h @@ -0,0 +1,11 @@ +/* inffast.h -- header to use inffast.c + * Copyright (C) 1995-2003, 2010 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start)); diff --git a/zlib/thumb/inffixed.h b/zlib/thumb/inffixed.h new file mode 100644 index 0000000..d628327 --- /dev/null +++ b/zlib/thumb/inffixed.h @@ -0,0 +1,94 @@ + /* inffixed.h -- table for decoding fixed codes + * Generated automatically by makefixed(). + */ + + /* WARNING: this file should *not* be used by applications. + It is part of the implementation of this library and is + subject to change. Applications should only use zlib.h. + */ + + static const code lenfix[512] = { + {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48}, + {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128}, + {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59}, + {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176}, + {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20}, + {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100}, + {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8}, + {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216}, + {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76}, + {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114}, + {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2}, + {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148}, + {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42}, + {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86}, + {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15}, + {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236}, + {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62}, + {0,9,220},{18,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,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31}, + {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162}, + {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25}, + {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105}, + {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4}, + {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202}, + {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69}, + {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125}, + {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13}, + {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195}, + {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35}, + {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91}, + {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19}, + {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246}, + {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55}, + {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135}, + {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99}, + {0,8,127},{0,8,63},{0,9,222},{18,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,0},{0,8,80},{0,8,16}, + {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96}, + {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6}, + {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209}, + {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72}, + {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116}, + {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4}, + {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153}, + {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44}, + {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82}, + {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11}, + {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229}, + {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58}, + {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138}, + {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51}, + {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173}, + {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30}, + {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,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,0}, + {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195}, + {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65}, + {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121}, + {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9}, + {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258}, + {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37}, + {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93}, + {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23}, + {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251}, + {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51}, + {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131}, + {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67}, + {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183}, + {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23}, + {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103}, + {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9}, + {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223}, + {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79}, + {0,9,255} + }; + + static const code distfix[32] = { + {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025}, + {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193}, + {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385}, + {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577}, + {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073}, + {22,5,193},{64,5,0} + }; diff --git a/zlib/thumb/inflate.c b/zlib/thumb/inflate.c new file mode 100644 index 0000000..de5812f --- /dev/null +++ b/zlib/thumb/inflate.c @@ -0,0 +1,1496 @@ +/* inflate.c -- zlib decompression + * Copyright (C) 1995-2012 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* + * Change history: + * + * 1.2.beta0 24 Nov 2002 + * - First version -- complete rewrite of inflate to simplify code, avoid + * creation of window when not needed, minimize use of window when it is + * needed, make inffast.c even faster, implement gzip decoding, and to + * improve code readability and style over the previous zlib inflate code + * + * 1.2.beta1 25 Nov 2002 + * - Use pointers for available input and output checking in inffast.c + * - Remove input and output counters in inffast.c + * - Change inffast.c entry and loop from avail_in >= 7 to >= 6 + * - Remove unnecessary second byte pull from length extra in inffast.c + * - Unroll direct copy to three copies per loop in inffast.c + * + * 1.2.beta2 4 Dec 2002 + * - Change external routine names to reduce potential conflicts + * - Correct filename to inffixed.h for fixed tables in inflate.c + * - Make hbuf[] unsigned char to match parameter type in inflate.c + * - Change strm->next_out[-state->offset] to *(strm->next_out - state->offset) + * to avoid negation problem on Alphas (64 bit) in inflate.c + * + * 1.2.beta3 22 Dec 2002 + * - Add comments on state->bits assertion in inffast.c + * - Add comments on op field in inftrees.h + * - Fix bug in reuse of allocated window after inflateReset() + * - Remove bit fields--back to byte structure for speed + * - Remove distance extra == 0 check in inflate_fast()--only helps for lengths + * - Change post-increments to pre-increments in inflate_fast(), PPC biased? + * - Add compile time option, POSTINC, to use post-increments instead (Intel?) + * - Make MATCH copy in inflate() much faster for when inflate_fast() not used + * - Use local copies of stream next and avail values, as well as local bit + * buffer and bit count in inflate()--for speed when inflate_fast() not used + * + * 1.2.beta4 1 Jan 2003 + * - Split ptr - 257 statements in inflate_table() to avoid compiler warnings + * - Move a comment on output buffer sizes from inffast.c to inflate.c + * - Add comments in inffast.c to introduce the inflate_fast() routine + * - Rearrange window copies in inflate_fast() for speed and simplification + * - Unroll last copy for window match in inflate_fast() + * - Use local copies of window variables in inflate_fast() for speed + * - Pull out common wnext == 0 case for speed in inflate_fast() + * - Make op and len in inflate_fast() unsigned for consistency + * - Add FAR to lcode and dcode declarations in inflate_fast() + * - Simplified bad distance check in inflate_fast() + * - Added inflateBackInit(), inflateBack(), and inflateBackEnd() in new + * source file infback.c to provide a call-back interface to inflate for + * programs like gzip and unzip -- uses window as output buffer to avoid + * window copying + * + * 1.2.beta5 1 Jan 2003 + * - Improved inflateBack() interface to allow the caller to provide initial + * input in strm. + * - Fixed stored blocks bug in inflateBack() + * + * 1.2.beta6 4 Jan 2003 + * - Added comments in inffast.c on effectiveness of POSTINC + * - Typecasting all around to reduce compiler warnings + * - Changed loops from while (1) or do {} while (1) to for (;;), again to + * make compilers happy + * - Changed type of window in inflateBackInit() to unsigned char * + * + * 1.2.beta7 27 Jan 2003 + * - Changed many types to unsigned or unsigned short to avoid warnings + * - Added inflateCopy() function + * + * 1.2.0 9 Mar 2003 + * - Changed inflateBack() interface to provide separate opaque descriptors + * for the in() and out() functions + * - Changed inflateBack() argument and in_func typedef to swap the length + * and buffer address return values for the input function + * - Check next_in and next_out for Z_NULL on entry to inflate() + * + * The history for versions after 1.2.0 are in ChangeLog in zlib distribution. + */ + +#include "zutil.h" +#include "inftrees.h" +#include "inflate.h" +#include "inffast.h" + +#ifdef MAKEFIXED +# ifndef BUILDFIXED +# define BUILDFIXED +# endif +#endif + +/* function prototypes */ +local void fixedtables OF((struct inflate_state FAR *state)); +local int updatewindow OF((z_streamp strm, unsigned out)); +#ifdef BUILDFIXED + void makefixed OF((void)); +#endif +local unsigned syncsearch OF((unsigned FAR *have, unsigned char FAR *buf, + unsigned len)); + +int ZEXPORT inflateResetKeep(strm) +z_streamp strm; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + strm->total_in = strm->total_out = state->total = 0; + strm->msg = Z_NULL; + if (state->wrap) /* to support ill-conceived Java test suite */ + strm->adler = state->wrap & 1; + state->mode = HEAD; + state->last = 0; + state->havedict = 0; + state->dmax = 32768U; + state->head = Z_NULL; + state->hold = 0; + state->bits = 0; + state->lencode = state->distcode = state->next = state->codes; + state->sane = 1; + state->back = -1; + Tracev((stderr, "inflate: reset\n")); + return Z_OK; +} + +int ZEXPORT inflateReset(strm) +z_streamp strm; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + state->wsize = 0; + state->whave = 0; + state->wnext = 0; + return inflateResetKeep(strm); +} + +int ZEXPORT inflateReset2(strm, windowBits) +z_streamp strm; +int windowBits; +{ + int wrap; + struct inflate_state FAR *state; + + /* get the state */ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + + /* extract wrap request from windowBits parameter */ + if (windowBits < 0) { + wrap = 0; + windowBits = -windowBits; + } + else { + wrap = (windowBits >> 4) + 1; +#ifdef GUNZIP + if (windowBits < 48) + windowBits &= 15; +#endif + } + + /* set number of window bits, free window if different */ + if (windowBits && (windowBits < 8 || windowBits > 15)) + return Z_STREAM_ERROR; + if (state->window != Z_NULL && state->wbits != (unsigned)windowBits) { + ZFREE(strm, state->window); + state->window = Z_NULL; + } + + /* update state and reset the rest of it */ + state->wrap = wrap; + state->wbits = (unsigned)windowBits; + return inflateReset(strm); +} + +int ZEXPORT inflateInit2_(strm, windowBits, version, stream_size) +z_streamp strm; +int windowBits; +const char *version; +int stream_size; +{ + int ret; + struct inflate_state FAR *state; + + if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || + stream_size != (int)(sizeof(z_stream))) + return Z_VERSION_ERROR; + if (strm == Z_NULL) return Z_STREAM_ERROR; + strm->msg = Z_NULL; /* in case we return an error */ + if (strm->zalloc == (alloc_func)0) { +#ifdef Z_SOLO + return Z_STREAM_ERROR; +#else + strm->zalloc = zcalloc; + strm->opaque = (voidpf)0; +#endif + } + if (strm->zfree == (free_func)0) +#ifdef Z_SOLO + return Z_STREAM_ERROR; +#else + strm->zfree = zcfree; +#endif + state = (struct inflate_state FAR *) + ZALLOC(strm, 1, sizeof(struct inflate_state)); + if (state == Z_NULL) return Z_MEM_ERROR; + Tracev((stderr, "inflate: allocated\n")); + strm->state = (struct internal_state FAR *)state; + state->window = Z_NULL; + ret = inflateReset2(strm, windowBits); + if (ret != Z_OK) { + ZFREE(strm, state); + strm->state = Z_NULL; + } + return ret; +} + +int ZEXPORT inflateInit_(strm, version, stream_size) +z_streamp strm; +const char *version; +int stream_size; +{ + return inflateInit2_(strm, DEF_WBITS, version, stream_size); +} + +int ZEXPORT inflatePrime(strm, bits, value) +z_streamp strm; +int bits; +int value; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (bits < 0) { + state->hold = 0; + state->bits = 0; + return Z_OK; + } + if (bits > 16 || state->bits + bits > 32) return Z_STREAM_ERROR; + value &= (1L << bits) - 1; + state->hold += value << state->bits; + state->bits += bits; + return Z_OK; +} + +/* + Return state with length and distance decoding tables and index sizes set to + fixed code decoding. Normally this returns fixed tables from inffixed.h. + If BUILDFIXED is defined, then instead this routine builds the tables the + first time it's called, and returns those tables the first time and + thereafter. This reduces the size of the code by about 2K bytes, in + exchange for a little execution time. However, BUILDFIXED should not be + used for threaded applications, since the rewriting of the tables and virgin + may not be thread-safe. + */ +local void fixedtables(state) +struct inflate_state FAR *state; +{ +#ifdef BUILDFIXED + static int virgin = 1; + static code *lenfix, *distfix; + static code fixed[544]; + + /* build fixed huffman tables if first call (may not be thread safe) */ + if (virgin) { + unsigned sym, bits; + static code *next; + + /* literal/length table */ + sym = 0; + while (sym < 144) state->lens[sym++] = 8; + while (sym < 256) state->lens[sym++] = 9; + while (sym < 280) state->lens[sym++] = 7; + while (sym < 288) state->lens[sym++] = 8; + next = fixed; + lenfix = next; + bits = 9; + inflate_table(LENS, state->lens, 288, &(next), &(bits), state->work); + + /* distance table */ + sym = 0; + while (sym < 32) state->lens[sym++] = 5; + distfix = next; + bits = 5; + inflate_table(DISTS, state->lens, 32, &(next), &(bits), state->work); + + /* do this just once */ + virgin = 0; + } +#else /* !BUILDFIXED */ +# include "inffixed.h" +#endif /* BUILDFIXED */ + state->lencode = lenfix; + state->lenbits = 9; + state->distcode = distfix; + state->distbits = 5; +} + +#ifdef MAKEFIXED +#include + +/* + Write out the inffixed.h that is #include'd above. Defining MAKEFIXED also + defines BUILDFIXED, so the tables are built on the fly. makefixed() writes + those tables to stdout, which would be piped to inffixed.h. A small program + can simply call makefixed to do this: + + void makefixed(void); + + int main(void) + { + makefixed(); + return 0; + } + + Then that can be linked with zlib built with MAKEFIXED defined and run: + + a.out > inffixed.h + */ +void makefixed() +{ + unsigned low, size; + struct inflate_state state; + + fixedtables(&state); + puts(" /* inffixed.h -- table for decoding fixed codes"); + puts(" * Generated automatically by makefixed()."); + puts(" */"); + puts(""); + puts(" /* WARNING: this file should *not* be used by applications."); + puts(" It is part of the implementation of this library and is"); + puts(" subject to change. Applications should only use zlib.h."); + puts(" */"); + puts(""); + size = 1U << 9; + printf(" static const code lenfix[%u] = {", size); + low = 0; + for (;;) { + if ((low % 7) == 0) printf("\n "); + printf("{%u,%u,%d}", (low & 127) == 99 ? 64 : state.lencode[low].op, + state.lencode[low].bits, state.lencode[low].val); + if (++low == size) break; + putchar(','); + } + puts("\n };"); + size = 1U << 5; + printf("\n static const code distfix[%u] = {", size); + low = 0; + for (;;) { + if ((low % 6) == 0) printf("\n "); + printf("{%u,%u,%d}", state.distcode[low].op, state.distcode[low].bits, + state.distcode[low].val); + if (++low == size) break; + putchar(','); + } + puts("\n };"); +} +#endif /* MAKEFIXED */ + +/* + Update the window with the last wsize (normally 32K) bytes written before + returning. If window does not exist yet, create it. This is only called + when a window is already in use, or when output has been written during this + inflate call, but the end of the deflate stream has not been reached yet. + It is also called to create a window for dictionary data when a dictionary + is loaded. + + Providing output buffers larger than 32K to inflate() should provide a speed + advantage, since only the last 32K of output is copied to the sliding window + upon return from inflate(), and since all distances after the first 32K of + output will fall in the output data, making match copies simpler and faster. + The advantage may be dependent on the size of the processor's data caches. + */ +local int updatewindow(strm, out) +z_streamp strm; +unsigned out; +{ + struct inflate_state FAR *state; + unsigned copy, dist; + + state = (struct inflate_state FAR *)strm->state; + + /* if it hasn't been done already, allocate space for the window */ + if (state->window == Z_NULL) { + state->window = (unsigned char FAR *) + ZALLOC(strm, 1U << state->wbits, + sizeof(unsigned char)); + if (state->window == Z_NULL) return 1; + } + + /* if window not in use yet, initialize */ + if (state->wsize == 0) { + state->wsize = 1U << state->wbits; + state->wnext = 0; + state->whave = 0; + } + + /* copy state->wsize or less output bytes into the circular window */ + copy = out - strm->avail_out; + if (copy >= state->wsize) { + zmemcpy(state->window, strm->next_out - state->wsize, state->wsize); + state->wnext = 0; + state->whave = state->wsize; + } + else { + dist = state->wsize - state->wnext; + if (dist > copy) dist = copy; + zmemcpy(state->window + state->wnext, strm->next_out - copy, dist); + copy -= dist; + if (copy) { + zmemcpy(state->window, strm->next_out - copy, copy); + state->wnext = copy; + state->whave = state->wsize; + } + else { + state->wnext += dist; + if (state->wnext == state->wsize) state->wnext = 0; + if (state->whave < state->wsize) state->whave += dist; + } + } + return 0; +} + +/* Macros for inflate(): */ + +/* check function to use adler32() for zlib or crc32() for gzip */ +#ifdef GUNZIP +# define UPDATE(check, buf, len) \ + (state->flags ? crc32(check, buf, len) : adler32(check, buf, len)) +#else +# define UPDATE(check, buf, len) adler32(check, buf, len) +#endif + +/* check macros for header crc */ +#ifdef GUNZIP +# define CRC2(check, word) \ + do { \ + hbuf[0] = (unsigned char)(word); \ + hbuf[1] = (unsigned char)((word) >> 8); \ + check = crc32(check, hbuf, 2); \ + } while (0) + +# define CRC4(check, word) \ + do { \ + hbuf[0] = (unsigned char)(word); \ + hbuf[1] = (unsigned char)((word) >> 8); \ + hbuf[2] = (unsigned char)((word) >> 16); \ + hbuf[3] = (unsigned char)((word) >> 24); \ + check = crc32(check, hbuf, 4); \ + } while (0) +#endif + +/* Load registers with state in inflate() for speed */ +#define LOAD() \ + do { \ + put = strm->next_out; \ + left = strm->avail_out; \ + next = strm->next_in; \ + have = strm->avail_in; \ + hold = state->hold; \ + bits = state->bits; \ + } while (0) + +/* Restore state from registers in inflate() */ +#define RESTORE() \ + do { \ + strm->next_out = put; \ + strm->avail_out = left; \ + strm->next_in = next; \ + strm->avail_in = have; \ + state->hold = hold; \ + state->bits = bits; \ + } while (0) + +/* Clear the input bit accumulator */ +#define INITBITS() \ + do { \ + hold = 0; \ + bits = 0; \ + } while (0) + +/* Get a byte of input into the bit accumulator, or return from inflate() + if there is no input available. */ +#define PULLBYTE() \ + do { \ + if (have == 0) goto inf_leave; \ + have--; \ + hold += (unsigned int)(*next++) << bits; \ + bits += 8; \ + } while (0) + +/* Assure that there are at least n bits in the bit accumulator. If there is + not enough available input to do that, then return from inflate(). */ +#define NEEDBITS(n) \ + do { \ + while (bits < (unsigned)(n)) \ + PULLBYTE(); \ + } while (0) + +/* Return the low n bits of the bit accumulator (n < 16) */ +#define BITS(n) \ + ((unsigned)hold & ((1U << (n)) - 1)) + +/* Remove n bits from the bit accumulator */ +#define DROPBITS(n) \ + do { \ + hold >>= (n); \ + bits -= (unsigned)(n); \ + } while (0) + +/* Remove zero to seven bits as needed to go to a byte boundary */ +#define BYTEBITS() \ + do { \ + hold >>= bits & 7; \ + bits -= bits & 7; \ + } while (0) + +/* + inflate() uses a state machine to process as much input data and generate as + much output data as possible before returning. The state machine is + structured roughly as follows: + + for (;;) switch (state) { + ... + case STATEn: + if (not enough input data or output space to make progress) + return; + ... make progress ... + state = STATEm; + break; + ... + } + + so when inflate() is called again, the same case is attempted again, and + if the appropriate resources are provided, the machine proceeds to the + next state. The NEEDBITS() macro is usually the way the state evaluates + whether it can proceed or should return. NEEDBITS() does the return if + the requested bits are not available. The typical use of the BITS macros + is: + + NEEDBITS(n); + ... do something with BITS(n) ... + DROPBITS(n); + + where NEEDBITS(n) either returns from inflate() if there isn't enough + input left to load n bits into the accumulator, or it continues. BITS(n) + gives the low n bits in the accumulator. When done, DROPBITS(n) drops + the low n bits off the accumulator. INITBITS() clears the accumulator + and sets the number of available bits to zero. BYTEBITS() discards just + enough bits to put the accumulator on a byte boundary. After BYTEBITS() + and a NEEDBITS(8), then BITS(8) would return the next byte in the stream. + + NEEDBITS(n) uses PULLBYTE() to get an available byte of input, or to return + if there is no input available. The decoding of variable length codes uses + PULLBYTE() directly in order to pull just enough bytes to decode the next + code, and no more. + + Some states loop until they get enough input, making sure that enough + state information is maintained to continue the loop where it left off + if NEEDBITS() returns in the loop. For example, want, need, and keep + would all have to actually be part of the saved state in case NEEDBITS() + returns: + + case STATEw: + while (want < need) { + NEEDBITS(n); + keep[want++] = BITS(n); + DROPBITS(n); + } + state = STATEx; + case STATEx: + + As shown above, if the next state is also the next case, then the break + is omitted. + + A state may also return if there is not enough output space available to + complete that state. Those states are copying stored data, writing a + literal byte, and copying a matching string. + + When returning, a "goto inf_leave" is used to update the total counters, + update the check value, and determine whether any progress has been made + during that inflate() call in order to return the proper return code. + Progress is defined as a change in either strm->avail_in or strm->avail_out. + When there is a window, goto inf_leave will update the window with the last + output written. If a goto inf_leave occurs in the middle of decompression + and there is no window currently, goto inf_leave will create one and copy + output to the window for the next call of inflate(). + + In this implementation, the flush parameter of inflate() only affects the + return code (per zlib.h). inflate() always writes as much as possible to + strm->next_out, given the space available and the provided input--the effect + documented in zlib.h of Z_SYNC_FLUSH. Furthermore, inflate() always defers + the allocation of and copying into a sliding window until necessary, which + provides the effect documented in zlib.h for Z_FINISH when the entire input + stream available. So the only thing the flush parameter actually does is: + when flush is set to Z_FINISH, inflate() cannot return Z_OK. Instead it + will return Z_BUF_ERROR if it has not reached the end of the stream. + */ + +int ZEXPORT inflate(strm, flush) +z_streamp strm; +int flush; +{ + struct inflate_state FAR *state; + unsigned char FAR *next; /* next input */ + unsigned char FAR *put; /* next output */ + unsigned have, left; /* available input and output */ + unsigned int hold; /* bit buffer */ + unsigned bits; /* bits in bit buffer */ + unsigned in, out; /* save starting available input and output */ + unsigned copy; /* number of stored or match bytes to copy */ + unsigned char FAR *from; /* where to copy match bytes from */ + code here; /* current decoding table entry */ + code last; /* parent table entry */ + unsigned len; /* length to copy for repeats, bits to drop */ + int ret; /* return code */ +#ifdef GUNZIP + unsigned char hbuf[4]; /* buffer for gzip header crc calculation */ +#endif + static const unsigned short order[19] = /* permutation of code lengths */ + {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}; + + if (strm == Z_NULL || strm->state == Z_NULL || strm->next_out == Z_NULL || + (strm->next_in == Z_NULL && strm->avail_in != 0)) + return Z_STREAM_ERROR; + + state = (struct inflate_state FAR *)strm->state; + if (state->mode == TYPE) state->mode = TYPEDO; /* skip check */ + LOAD(); + in = have; + out = left; + ret = Z_OK; + for (;;) + switch (state->mode) { + case HEAD: + if (state->wrap == 0) { + state->mode = TYPEDO; + break; + } + NEEDBITS(16); +#ifdef GUNZIP + if ((state->wrap & 2) && hold == 0x8b1f) { /* gzip header */ + state->check = crc32(0L, Z_NULL, 0); + CRC2(state->check, hold); + INITBITS(); + state->mode = FLAGS; + break; + } + state->flags = 0; /* expect zlib header */ + if (state->head != Z_NULL) + state->head->done = -1; + if (!(state->wrap & 1) || /* check if zlib header allowed */ +#else + if ( +#endif + ((BITS(8) << 8) + (hold >> 8)) % 31) { + strm->msg = (char *)"incorrect header check"; + state->mode = BAD; + break; + } + if (BITS(4) != Z_DEFLATED) { + strm->msg = (char *)"unknown compression method"; + state->mode = BAD; + break; + } + DROPBITS(4); + len = BITS(4) + 8; + if (state->wbits == 0) + state->wbits = len; + else if (len > state->wbits) { + strm->msg = (char *)"invalid window size"; + state->mode = BAD; + break; + } + state->dmax = 1U << len; + Tracev((stderr, "inflate: zlib header ok\n")); + strm->adler = state->check = adler32(0L, Z_NULL, 0); + state->mode = hold & 0x200 ? DICTID : TYPE; + INITBITS(); + break; +#ifdef GUNZIP + case FLAGS: + NEEDBITS(16); + state->flags = (int)(hold); + if ((state->flags & 0xff) != Z_DEFLATED) { + strm->msg = (char *)"unknown compression method"; + state->mode = BAD; + break; + } + if (state->flags & 0xe000) { + strm->msg = (char *)"unknown header flags set"; + state->mode = BAD; + break; + } + if (state->head != Z_NULL) + state->head->text = (int)((hold >> 8) & 1); + if (state->flags & 0x0200) CRC2(state->check, hold); + INITBITS(); + state->mode = TIME; + case TIME: + NEEDBITS(32); + if (state->head != Z_NULL) + state->head->time = hold; + if (state->flags & 0x0200) CRC4(state->check, hold); + INITBITS(); + state->mode = OS; + case OS: + NEEDBITS(16); + if (state->head != Z_NULL) { + state->head->xflags = (int)(hold & 0xff); + state->head->os = (int)(hold >> 8); + } + if (state->flags & 0x0200) CRC2(state->check, hold); + INITBITS(); + state->mode = EXLEN; + case EXLEN: + if (state->flags & 0x0400) { + NEEDBITS(16); + state->length = (unsigned)(hold); + if (state->head != Z_NULL) + state->head->extra_len = (unsigned)hold; + if (state->flags & 0x0200) CRC2(state->check, hold); + INITBITS(); + } + else if (state->head != Z_NULL) + state->head->extra = Z_NULL; + state->mode = EXTRA; + case EXTRA: + if (state->flags & 0x0400) { + copy = state->length; + if (copy > have) copy = have; + if (copy) { + if (state->head != Z_NULL && + state->head->extra != Z_NULL) { + len = state->head->extra_len - state->length; + zmemcpy(state->head->extra + len, next, + len + copy > state->head->extra_max ? + state->head->extra_max - len : copy); + } + if (state->flags & 0x0200) + state->check = crc32(state->check, next, copy); + have -= copy; + next += copy; + state->length -= copy; + } + if (state->length) goto inf_leave; + } + state->length = 0; + state->mode = NAME; + case NAME: + if (state->flags & 0x0800) { + if (have == 0) goto inf_leave; + copy = 0; + do { + len = (unsigned)(next[copy++]); + if (state->head != Z_NULL && + state->head->name != Z_NULL && + state->length < state->head->name_max) + state->head->name[state->length++] = len; + } while (len && copy < have); + if (state->flags & 0x0200) + state->check = crc32(state->check, next, copy); + have -= copy; + next += copy; + if (len) goto inf_leave; + } + else if (state->head != Z_NULL) + state->head->name = Z_NULL; + state->length = 0; + state->mode = COMMENT; + case COMMENT: + if (state->flags & 0x1000) { + if (have == 0) goto inf_leave; + copy = 0; + do { + len = (unsigned)(next[copy++]); + if (state->head != Z_NULL && + state->head->comment != Z_NULL && + state->length < state->head->comm_max) + state->head->comment[state->length++] = len; + } while (len && copy < have); + if (state->flags & 0x0200) + state->check = crc32(state->check, next, copy); + have -= copy; + next += copy; + if (len) goto inf_leave; + } + else if (state->head != Z_NULL) + state->head->comment = Z_NULL; + state->mode = HCRC; + case HCRC: + if (state->flags & 0x0200) { + NEEDBITS(16); + if (hold != (state->check & 0xffff)) { + strm->msg = (char *)"header crc mismatch"; + state->mode = BAD; + break; + } + INITBITS(); + } + if (state->head != Z_NULL) { + state->head->hcrc = (int)((state->flags >> 9) & 1); + state->head->done = 1; + } + strm->adler = state->check = crc32(0L, Z_NULL, 0); + state->mode = TYPE; + break; +#endif + case DICTID: + NEEDBITS(32); + strm->adler = state->check = ZSWAP32(hold); + INITBITS(); + state->mode = DICT; + case DICT: + if (state->havedict == 0) { + RESTORE(); + return Z_NEED_DICT; + } + strm->adler = state->check = adler32(0L, Z_NULL, 0); + state->mode = TYPE; + case TYPE: + if (flush == Z_BLOCK || flush == Z_TREES) goto inf_leave; + case TYPEDO: + if (state->last) { + BYTEBITS(); + state->mode = CHECK; + break; + } + NEEDBITS(3); + state->last = BITS(1); + DROPBITS(1); + switch (BITS(2)) { + case 0: /* stored block */ + Tracev((stderr, "inflate: stored block%s\n", + state->last ? " (last)" : "")); + state->mode = STORED; + break; + case 1: /* fixed block */ + fixedtables(state); + Tracev((stderr, "inflate: fixed codes block%s\n", + state->last ? " (last)" : "")); + state->mode = LEN_; /* decode codes */ + if (flush == Z_TREES) { + DROPBITS(2); + goto inf_leave; + } + break; + case 2: /* dynamic block */ + Tracev((stderr, "inflate: dynamic codes block%s\n", + state->last ? " (last)" : "")); + state->mode = TABLE; + break; + case 3: + strm->msg = (char *)"invalid block type"; + state->mode = BAD; + } + DROPBITS(2); + break; + case STORED: + BYTEBITS(); /* go to byte boundary */ + NEEDBITS(32); + if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) { + strm->msg = (char *)"invalid stored block lengths"; + state->mode = BAD; + break; + } + state->length = (unsigned)hold & 0xffff; + Tracev((stderr, "inflate: stored length %u\n", + state->length)); + INITBITS(); + state->mode = COPY_; + if (flush == Z_TREES) goto inf_leave; + case COPY_: + state->mode = COPY; + case COPY: + copy = state->length; + if (copy) { + if (copy > have) copy = have; + if (copy > left) copy = left; + if (copy == 0) goto inf_leave; + zmemcpy(put, next, copy); + have -= copy; + next += copy; + left -= copy; + put += copy; + state->length -= copy; + break; + } + Tracev((stderr, "inflate: stored end\n")); + state->mode = TYPE; + break; + case TABLE: + NEEDBITS(14); + state->nlen = BITS(5) + 257; + DROPBITS(5); + state->ndist = BITS(5) + 1; + DROPBITS(5); + state->ncode = BITS(4) + 4; + DROPBITS(4); +#ifndef PKZIP_BUG_WORKAROUND + if (state->nlen > 286 || state->ndist > 30) { + strm->msg = (char *)"too many length or distance symbols"; + state->mode = BAD; + break; + } +#endif + Tracev((stderr, "inflate: table sizes ok\n")); + state->have = 0; + state->mode = LENLENS; + case LENLENS: + while (state->have < state->ncode) { + NEEDBITS(3); + state->lens[order[state->have++]] = (unsigned short)BITS(3); + DROPBITS(3); + } + while (state->have < 19) + state->lens[order[state->have++]] = 0; + state->next = state->codes; + state->lencode = (code const FAR *)(state->next); + state->lenbits = 7; + ret = inflate_table(CODES, state->lens, 19, &(state->next), + &(state->lenbits), state->work); + if (ret) { + strm->msg = (char *)"invalid code lengths set"; + state->mode = BAD; + break; + } + Tracev((stderr, "inflate: code lengths ok\n")); + state->have = 0; + state->mode = CODELENS; + case CODELENS: + while (state->have < state->nlen + state->ndist) { + for (;;) { + here = state->lencode[BITS(state->lenbits)]; + if ((unsigned)(here.bits) <= bits) break; + PULLBYTE(); + } + if (here.val < 16) { + DROPBITS(here.bits); + state->lens[state->have++] = here.val; + } + else { + if (here.val == 16) { + NEEDBITS(here.bits + 2); + DROPBITS(here.bits); + if (state->have == 0) { + strm->msg = (char *)"invalid bit length repeat"; + state->mode = BAD; + break; + } + len = state->lens[state->have - 1]; + copy = 3 + BITS(2); + DROPBITS(2); + } + else if (here.val == 17) { + NEEDBITS(here.bits + 3); + DROPBITS(here.bits); + len = 0; + copy = 3 + BITS(3); + DROPBITS(3); + } + else { + NEEDBITS(here.bits + 7); + DROPBITS(here.bits); + len = 0; + copy = 11 + BITS(7); + DROPBITS(7); + } + if (state->have + copy > state->nlen + state->ndist) { + strm->msg = (char *)"invalid bit length repeat"; + state->mode = BAD; + break; + } + while (copy--) + state->lens[state->have++] = (unsigned short)len; + } + } + + /* handle error breaks in while */ + if (state->mode == BAD) break; + + /* check for end-of-block code (better have one) */ + if (state->lens[256] == 0) { + strm->msg = (char *)"invalid code -- missing end-of-block"; + state->mode = BAD; + break; + } + + /* build code tables -- note: do not change the lenbits or distbits + values here (9 and 6) without reading the comments in inftrees.h + concerning the ENOUGH constants, which depend on those values */ + state->next = state->codes; + state->lencode = (code const FAR *)(state->next); + state->lenbits = 9; + ret = inflate_table(LENS, state->lens, state->nlen, &(state->next), + &(state->lenbits), state->work); + if (ret) { + strm->msg = (char *)"invalid literal/lengths set"; + state->mode = BAD; + break; + } + state->distcode = (code const FAR *)(state->next); + state->distbits = 6; + ret = inflate_table(DISTS, state->lens + state->nlen, state->ndist, + &(state->next), &(state->distbits), state->work); + if (ret) { + strm->msg = (char *)"invalid distances set"; + state->mode = BAD; + break; + } + Tracev((stderr, "inflate: codes ok\n")); + state->mode = LEN_; + if (flush == Z_TREES) goto inf_leave; + case LEN_: + state->mode = LEN; + case LEN: + if (have >= 6 && left >= 258) { + RESTORE(); + inflate_fast(strm, out); + LOAD(); + if (state->mode == TYPE) + state->back = -1; + break; + } + state->back = 0; + for (;;) { + here = state->lencode[BITS(state->lenbits)]; + if ((unsigned)(here.bits) <= bits) break; + PULLBYTE(); + } + if (here.op && (here.op & 0xf0) == 0) { + last = here; + for (;;) { + here = state->lencode[last.val + + (BITS(last.bits + last.op) >> last.bits)]; + if ((unsigned)(last.bits + here.bits) <= bits) break; + PULLBYTE(); + } + DROPBITS(last.bits); + state->back += last.bits; + } + DROPBITS(here.bits); + state->back += here.bits; + state->length = (unsigned)here.val; + if ((int)(here.op) == 0) { + Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ? + "inflate: literal '%c'\n" : + "inflate: literal 0x%02x\n", here.val)); + state->mode = LIT; + break; + } + if (here.op & 32) { + Tracevv((stderr, "inflate: end of block\n")); + state->back = -1; + state->mode = TYPE; + break; + } + if (here.op & 64) { + strm->msg = (char *)"invalid literal/length code"; + state->mode = BAD; + break; + } + state->extra = (unsigned)(here.op) & 15; + state->mode = LENEXT; + case LENEXT: + if (state->extra) { + NEEDBITS(state->extra); + state->length += BITS(state->extra); + DROPBITS(state->extra); + state->back += state->extra; + } + Tracevv((stderr, "inflate: length %u\n", state->length)); + state->was = state->length; + state->mode = DIST; + case DIST: + for (;;) { + here = state->distcode[BITS(state->distbits)]; + if ((unsigned)(here.bits) <= bits) break; + PULLBYTE(); + } + if ((here.op & 0xf0) == 0) { + last = here; + for (;;) { + here = state->distcode[last.val + + (BITS(last.bits + last.op) >> last.bits)]; + if ((unsigned)(last.bits + here.bits) <= bits) break; + PULLBYTE(); + } + DROPBITS(last.bits); + state->back += last.bits; + } + DROPBITS(here.bits); + state->back += here.bits; + if (here.op & 64) { + strm->msg = (char *)"invalid distance code"; + state->mode = BAD; + break; + } + state->offset = (unsigned)here.val; + state->extra = (unsigned)(here.op) & 15; + state->mode = DISTEXT; + case DISTEXT: + if (state->extra) { + NEEDBITS(state->extra); + state->offset += BITS(state->extra); + DROPBITS(state->extra); + state->back += state->extra; + } +#ifdef INFLATE_STRICT + if (state->offset > state->dmax) { + strm->msg = (char *)"invalid distance too far back"; + state->mode = BAD; + break; + } +#endif + Tracevv((stderr, "inflate: distance %u\n", state->offset)); + state->mode = MATCH; + case MATCH: + if (left == 0) goto inf_leave; + copy = out - left; + if (state->offset > copy) { /* copy from window */ + copy = state->offset - copy; + if (copy > state->whave) { + if (state->sane) { + strm->msg = (char *)"invalid distance too far back"; + state->mode = BAD; + break; + } +#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR + Trace((stderr, "inflate.c too far\n")); + copy -= state->whave; + if (copy > state->length) copy = state->length; + if (copy > left) copy = left; + left -= copy; + state->length -= copy; + do { + *put++ = 0; + } while (--copy); + if (state->length == 0) state->mode = LEN; + break; +#endif + } + if (copy > state->wnext) { + copy -= state->wnext; + from = state->window + (state->wsize - copy); + } + else + from = state->window + (state->wnext - copy); + if (copy > state->length) copy = state->length; + } + else { /* copy from output */ + from = put - state->offset; + copy = state->length; + } + if (copy > left) copy = left; + left -= copy; + state->length -= copy; + do { + *put++ = *from++; + } while (--copy); + if (state->length == 0) state->mode = LEN; + break; + case LIT: + if (left == 0) goto inf_leave; + *put++ = (unsigned char)(state->length); + left--; + state->mode = LEN; + break; + case CHECK: + if (state->wrap) { + NEEDBITS(32); + out -= left; + strm->total_out += out; + state->total += out; + if (out) + strm->adler = state->check = + UPDATE(state->check, put - out, out); + out = left; + if (( +#ifdef GUNZIP + state->flags ? hold : +#endif + ZSWAP32(hold)) != state->check) { + strm->msg = (char *)"incorrect data check"; + state->mode = BAD; + break; + } + INITBITS(); + Tracev((stderr, "inflate: check matches trailer\n")); + } +#ifdef GUNZIP + state->mode = LENGTH; + case LENGTH: + if (state->wrap && state->flags) { + NEEDBITS(32); + if (hold != (state->total & 0xffffffffUL)) { + strm->msg = (char *)"incorrect length check"; + state->mode = BAD; + break; + } + INITBITS(); + Tracev((stderr, "inflate: length matches trailer\n")); + } +#endif + state->mode = DONE; + case DONE: + ret = Z_STREAM_END; + goto inf_leave; + case BAD: + ret = Z_DATA_ERROR; + goto inf_leave; + case MEM: + return Z_MEM_ERROR; + case SYNC: + default: + return Z_STREAM_ERROR; + } + + /* + Return from inflate(), updating the total counts and the check value. + If there was no progress during the inflate() call, return a buffer + error. Call updatewindow() to create and/or update the window state. + Note: a memory error from inflate() is non-recoverable. + */ + inf_leave: + RESTORE(); + if (state->wsize || (out != strm->avail_out && state->mode < BAD && + (state->mode < CHECK || flush != Z_FINISH))) + if (updatewindow(strm, out)) { + state->mode = MEM; + return Z_MEM_ERROR; + } + in -= strm->avail_in; + out -= strm->avail_out; + strm->total_in += in; + strm->total_out += out; + state->total += out; + if (state->wrap && out) + strm->adler = state->check = + UPDATE(state->check, strm->next_out - out, out); + strm->data_type = state->bits + (state->last ? 64 : 0) + + (state->mode == TYPE ? 128 : 0) + + (state->mode == LEN_ || state->mode == COPY_ ? 256 : 0); + if (((in == 0 && out == 0) || flush == Z_FINISH) && ret == Z_OK) + ret = Z_BUF_ERROR; + return ret; +} + +int ZEXPORT inflateEnd(strm) +z_streamp strm; +{ + struct inflate_state FAR *state; + if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0) + return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (state->window != Z_NULL) ZFREE(strm, state->window); + ZFREE(strm, strm->state); + strm->state = Z_NULL; + Tracev((stderr, "inflate: end\n")); + return Z_OK; +} + +int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength) +z_streamp strm; +const Bytef *dictionary; +uInt dictLength; +{ + struct inflate_state FAR *state; + unsigned int dictid; + unsigned char *next; + unsigned avail; + int ret; + + /* check state */ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (state->wrap != 0 && state->mode != DICT) + return Z_STREAM_ERROR; + + /* check for correct dictionary identifier */ + if (state->mode == DICT) { + dictid = adler32(0L, Z_NULL, 0); + dictid = adler32(dictid, dictionary, dictLength); + if (dictid != state->check) + return Z_DATA_ERROR; + } + + /* copy dictionary to window using updatewindow(), which will amend the + existing dictionary if appropriate */ + next = strm->next_out; + avail = strm->avail_out; + strm->next_out = (Bytef *)dictionary + dictLength; + strm->avail_out = 0; + ret = updatewindow(strm, dictLength); + strm->avail_out = avail; + strm->next_out = next; + if (ret) { + state->mode = MEM; + return Z_MEM_ERROR; + } + state->havedict = 1; + Tracev((stderr, "inflate: dictionary set\n")); + return Z_OK; +} + +int ZEXPORT inflateGetHeader(strm, head) +z_streamp strm; +gz_headerp head; +{ + struct inflate_state FAR *state; + + /* check state */ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if ((state->wrap & 2) == 0) return Z_STREAM_ERROR; + + /* save header structure */ + state->head = head; + head->done = 0; + return Z_OK; +} + +/* + Search buf[0..len-1] for the pattern: 0, 0, 0xff, 0xff. Return when found + or when out of input. When called, *have is the number of pattern bytes + found in order so far, in 0..3. On return *have is updated to the new + state. If on return *have equals four, then the pattern was found and the + return value is how many bytes were read including the last byte of the + pattern. If *have is less than four, then the pattern has not been found + yet and the return value is len. In the latter case, syncsearch() can be + called again with more data and the *have state. *have is initialized to + zero for the first call. + */ +local unsigned syncsearch(have, buf, len) +unsigned FAR *have; +unsigned char FAR *buf; +unsigned len; +{ + unsigned got; + unsigned next; + + got = *have; + next = 0; + while (next < len && got < 4) { + if ((int)(buf[next]) == (got < 2 ? 0 : 0xff)) + got++; + else if (buf[next]) + got = 0; + else + got = 4 - got; + next++; + } + *have = got; + return next; +} + +int ZEXPORT inflateSync(strm) +z_streamp strm; +{ + unsigned len; /* number of bytes to look at or looked at */ + unsigned int in, out; /* temporary to save total_in and total_out */ + unsigned char buf[4]; /* to restore bit buffer to byte string */ + struct inflate_state FAR *state; + + /* check parameters */ + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + if (strm->avail_in == 0 && state->bits < 8) return Z_BUF_ERROR; + + /* if first time, start search in bit buffer */ + if (state->mode != SYNC) { + state->mode = SYNC; + state->hold <<= state->bits & 7; + state->bits -= state->bits & 7; + len = 0; + while (state->bits >= 8) { + buf[len++] = (unsigned char)(state->hold); + state->hold >>= 8; + state->bits -= 8; + } + state->have = 0; + syncsearch(&(state->have), buf, len); + } + + /* search available input */ + len = syncsearch(&(state->have), strm->next_in, strm->avail_in); + strm->avail_in -= len; + strm->next_in += len; + strm->total_in += len; + + /* return no joy or set up to restart inflate() on a new block */ + if (state->have != 4) return Z_DATA_ERROR; + in = strm->total_in; out = strm->total_out; + inflateReset(strm); + strm->total_in = in; strm->total_out = out; + state->mode = TYPE; + return Z_OK; +} + +/* + Returns true if inflate is currently at the end of a block generated by + Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP + implementation to provide an additional safety check. PPP uses + Z_SYNC_FLUSH but removes the length bytes of the resulting empty stored + block. When decompressing, PPP checks that at the end of input packet, + inflate is waiting for these length bytes. + */ +int ZEXPORT inflateSyncPoint(strm) +z_streamp strm; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + return state->mode == STORED && state->bits == 0; +} + +int ZEXPORT inflateCopy(dest, source) +z_streamp dest; +z_streamp source; +{ + struct inflate_state FAR *state; + struct inflate_state FAR *copy; + unsigned char FAR *window; + unsigned wsize; + + /* check input */ + if (dest == Z_NULL || source == Z_NULL || source->state == Z_NULL || + source->zalloc == (alloc_func)0 || source->zfree == (free_func)0) + return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)source->state; + + /* allocate space */ + copy = (struct inflate_state FAR *) + ZALLOC(source, 1, sizeof(struct inflate_state)); + if (copy == Z_NULL) return Z_MEM_ERROR; + window = Z_NULL; + if (state->window != Z_NULL) { + window = (unsigned char FAR *) + ZALLOC(source, 1U << state->wbits, sizeof(unsigned char)); + if (window == Z_NULL) { + ZFREE(source, copy); + return Z_MEM_ERROR; + } + } + + /* copy state */ + zmemcpy((voidpf)dest, (voidpf)source, sizeof(z_stream)); + zmemcpy((voidpf)copy, (voidpf)state, sizeof(struct inflate_state)); + if (state->lencode >= state->codes && + state->lencode <= state->codes + ENOUGH - 1) { + copy->lencode = copy->codes + (state->lencode - state->codes); + copy->distcode = copy->codes + (state->distcode - state->codes); + } + copy->next = copy->codes + (state->next - state->codes); + if (window != Z_NULL) { + wsize = 1U << state->wbits; + zmemcpy(window, state->window, wsize); + } + copy->window = window; + dest->state = (struct internal_state FAR *)copy; + return Z_OK; +} + +int ZEXPORT inflateUndermine(strm, subvert) +z_streamp strm; +int subvert; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; + state = (struct inflate_state FAR *)strm->state; + state->sane = !subvert; +#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR + return Z_OK; +#else + state->sane = 1; + return Z_DATA_ERROR; +#endif +} + +int ZEXPORT inflateMark(strm) +z_streamp strm; +{ + struct inflate_state FAR *state; + + if (strm == Z_NULL || strm->state == Z_NULL) return -1L << 16; + state = (struct inflate_state FAR *)strm->state; + return ((int)(state->back) << 16) + + (state->mode == COPY ? state->length : + (state->mode == MATCH ? state->was - state->length : 0)); +} diff --git a/zlib/thumb/inflate.h b/zlib/thumb/inflate.h new file mode 100644 index 0000000..18b070c --- /dev/null +++ b/zlib/thumb/inflate.h @@ -0,0 +1,122 @@ +/* inflate.h -- internal inflate state definition + * Copyright (C) 1995-2009 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +/* define NO_GZIP when compiling if you want to disable gzip header and + trailer decoding by inflate(). NO_GZIP would be used to avoid linking in + the crc code when it is not needed. For shared libraries, gzip decoding + should be left enabled. */ +#ifndef NO_GZIP +# define GUNZIP +#endif + +/* Possible inflate modes between inflate() calls */ +typedef enum { + HEAD, /* i: waiting for magic header */ + FLAGS, /* i: waiting for method and flags (gzip) */ + TIME, /* i: waiting for modification time (gzip) */ + OS, /* i: waiting for extra flags and operating system (gzip) */ + EXLEN, /* i: waiting for extra length (gzip) */ + EXTRA, /* i: waiting for extra bytes (gzip) */ + NAME, /* i: waiting for end of file name (gzip) */ + COMMENT, /* i: waiting for end of comment (gzip) */ + HCRC, /* i: waiting for header crc (gzip) */ + DICTID, /* i: waiting for dictionary check value */ + DICT, /* waiting for inflateSetDictionary() call */ + TYPE, /* i: waiting for type bits, including last-flag bit */ + TYPEDO, /* i: same, but skip check to exit inflate on new block */ + STORED, /* i: waiting for stored size (length and complement) */ + COPY_, /* i/o: same as COPY below, but only first time in */ + COPY, /* i/o: waiting for input or output to copy stored block */ + TABLE, /* i: waiting for dynamic block table lengths */ + LENLENS, /* i: waiting for code length code lengths */ + CODELENS, /* i: waiting for length/lit and distance code lengths */ + LEN_, /* i: same as LEN below, but only first time in */ + LEN, /* i: waiting for length/lit/eob code */ + LENEXT, /* i: waiting for length extra bits */ + DIST, /* i: waiting for distance code */ + DISTEXT, /* i: waiting for distance extra bits */ + MATCH, /* o: waiting for output space to copy string */ + LIT, /* o: waiting for output space to write literal */ + CHECK, /* i: waiting for 32-bit check value */ + LENGTH, /* i: waiting for 32-bit length (gzip) */ + DONE, /* finished check, done -- remain here until reset */ + BAD, /* got a data error -- remain here until reset */ + MEM, /* got an inflate() memory error -- remain here until reset */ + SYNC /* looking for synchronization bytes to restart inflate() */ +} inflate_mode; + +/* + State transitions between above modes - + + (most modes can go to BAD or MEM on error -- not shown for clarity) + + Process header: + HEAD -> (gzip) or (zlib) or (raw) + (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT -> + HCRC -> TYPE + (zlib) -> DICTID or TYPE + DICTID -> DICT -> TYPE + (raw) -> TYPEDO + Read deflate blocks: + TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK + STORED -> COPY_ -> COPY -> TYPE + TABLE -> LENLENS -> CODELENS -> LEN_ + LEN_ -> LEN + Read deflate codes in fixed or dynamic block: + LEN -> LENEXT or LIT or TYPE + LENEXT -> DIST -> DISTEXT -> MATCH -> LEN + LIT -> LEN + Process trailer: + CHECK -> LENGTH -> DONE + */ + +/* state maintained between inflate() calls. Approximately 10K bytes. */ +struct inflate_state { + inflate_mode mode; /* current inflate mode */ + int last; /* true if processing last block */ + int wrap; /* bit 0 true for zlib, bit 1 true for gzip */ + int havedict; /* true if dictionary provided */ + int flags; /* gzip header method and flags (0 if zlib) */ + unsigned dmax; /* zlib header max distance (INFLATE_STRICT) */ + unsigned int check; /* protected copy of check value */ + unsigned int total; /* protected copy of output count */ + gz_headerp head; /* where to save gzip header information */ + /* sliding window */ + unsigned wbits; /* log base 2 of requested window size */ + unsigned wsize; /* window size or zero if not using window */ + unsigned whave; /* valid bytes in the window */ + unsigned wnext; /* window write index */ + unsigned char FAR *window; /* allocated sliding window, if needed */ + /* bit accumulator */ + unsigned int hold; /* input bit accumulator */ + unsigned bits; /* number of bits in "in" */ + /* for string and stored block copying */ + unsigned length; /* literal or length of data to copy */ + unsigned offset; /* distance back to copy string from */ + /* for table and code decoding */ + unsigned extra; /* extra bits needed */ + /* fixed and dynamic code tables */ + code const FAR *lencode; /* starting table for length/literal codes */ + code const FAR *distcode; /* starting table for distance codes */ + unsigned lenbits; /* index bits for lencode */ + unsigned distbits; /* index bits for distcode */ + /* dynamic table building */ + unsigned ncode; /* number of code length code lengths */ + unsigned nlen; /* number of length code lengths */ + unsigned ndist; /* number of distance code lengths */ + unsigned have; /* number of code lengths in lens[] */ + code FAR *next; /* next available space in codes[] */ + unsigned short lens[320]; /* temporary storage for code lengths */ + unsigned short work[288]; /* work area for code table building */ + code codes[ENOUGH]; /* space for code tables */ + int sane; /* if false, allow invalid distance too far */ + int back; /* bits back of last unprocessed length/lit */ + unsigned was; /* initial length of match */ +}; diff --git a/zlib/thumb/inftrees.c b/zlib/thumb/inftrees.c new file mode 100644 index 0000000..abcd7c4 --- /dev/null +++ b/zlib/thumb/inftrees.c @@ -0,0 +1,306 @@ +/* inftrees.c -- generate Huffman trees for efficient decoding + * Copyright (C) 1995-2012 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +#include "zutil.h" +#include "inftrees.h" + +#define MAXBITS 15 + +const char inflate_copyright[] = + " inflate 1.2.7 Copyright 1995-2012 Mark Adler "; +/* + If you use the zlib library in a product, an acknowledgment is welcome + in the documentation of your product. If for some reason you cannot + include such an acknowledgment, I would appreciate that you keep this + copyright string in the executable of your product. + */ + +/* + Build a set of tables to decode the provided canonical Huffman code. + The code lengths are lens[0..codes-1]. The result starts at *table, + whose indices are 0..2^bits-1. work is a writable array of at least + lens shorts, which is used as a work area. type is the type of code + to be generated, CODES, LENS, or DISTS. On return, zero is success, + -1 is an invalid code, and +1 means that ENOUGH isn't enough. table + on return points to the next available entry's address. bits is the + requested root table index bits, and on return it is the actual root + table index bits. It will differ if the request is greater than the + longest code or if it is less than the shortest code. + */ +int ZLIB_INTERNAL inflate_table(type, lens, codes, table, bits, work) +codetype type; +unsigned short FAR *lens; +unsigned codes; +code FAR * FAR *table; +unsigned FAR *bits; +unsigned short FAR *work; +{ + unsigned len; /* a code's length in bits */ + unsigned sym; /* index of code symbols */ + unsigned min, max; /* minimum and maximum code lengths */ + unsigned root; /* number of index bits for root table */ + unsigned curr; /* number of index bits for current table */ + unsigned drop; /* code bits to drop for sub-table */ + int left; /* number of prefix codes available */ + unsigned used; /* code entries in table used */ + unsigned huff; /* Huffman code */ + unsigned incr; /* for incrementing code, index */ + unsigned fill; /* index for replicating entries */ + unsigned low; /* low bits for current root entry */ + unsigned mask; /* mask for low root bits */ + code here; /* table entry for duplication */ + code FAR *next; /* next available space in table */ + const unsigned short FAR *base; /* base value table to use */ + const unsigned short FAR *extra; /* extra bits table to use */ + int end; /* use base and extra for symbol > end */ + unsigned short count[MAXBITS+1]; /* number of codes of each length */ + unsigned short offs[MAXBITS+1]; /* offsets in table for each length */ + static const unsigned short lbase[31] = { /* Length codes 257..285 base */ + 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, + 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; + static const unsigned short lext[31] = { /* Length codes 257..285 extra */ + 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, + 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 78, 68}; + static const unsigned short dbase[32] = { /* Distance codes 0..29 base */ + 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, + 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, + 8193, 12289, 16385, 24577, 0, 0}; + static const unsigned short dext[32] = { /* Distance codes 0..29 extra */ + 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, + 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, + 28, 28, 29, 29, 64, 64}; + + /* + Process a set of code lengths to create a canonical Huffman code. The + code lengths are lens[0..codes-1]. Each length corresponds to the + symbols 0..codes-1. The Huffman code is generated by first sorting the + symbols by length from short to long, and retaining the symbol order + for codes with equal lengths. Then the code starts with all zero bits + for the first code of the shortest length, and the codes are integer + increments for the same length, and zeros are appended as the length + increases. For the deflate format, these bits are stored backwards + from their more natural integer increment ordering, and so when the + decoding tables are built in the large loop below, the integer codes + are incremented backwards. + + This routine assumes, but does not check, that all of the entries in + lens[] are in the range 0..MAXBITS. The caller must assure this. + 1..MAXBITS is interpreted as that code length. zero means that that + symbol does not occur in this code. + + The codes are sorted by computing a count of codes for each length, + creating from that a table of starting indices for each length in the + sorted table, and then entering the symbols in order in the sorted + table. The sorted table is work[], with that space being provided by + the caller. + + The length counts are used for other purposes as well, i.e. finding + the minimum and maximum length codes, determining if there are any + codes at all, checking for a valid set of lengths, and looking ahead + at length counts to determine sub-table sizes when building the + decoding tables. + */ + + /* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */ + for (len = 0; len <= MAXBITS; len++) + count[len] = 0; + for (sym = 0; sym < codes; sym++) + count[lens[sym]]++; + + /* bound code lengths, force root to be within code lengths */ + root = *bits; + for (max = MAXBITS; max >= 1; max--) + if (count[max] != 0) break; + if (root > max) root = max; + if (max == 0) { /* no symbols to code at all */ + here.op = (unsigned char)64; /* invalid code marker */ + here.bits = (unsigned char)1; + here.val = (unsigned short)0; + *(*table)++ = here; /* make a table to force an error */ + *(*table)++ = here; + *bits = 1; + return 0; /* no symbols, but wait for decoding to report error */ + } + for (min = 1; min < max; min++) + if (count[min] != 0) break; + if (root < min) root = min; + + /* check for an over-subscribed or incomplete set of lengths */ + left = 1; + for (len = 1; len <= MAXBITS; len++) { + left <<= 1; + left -= count[len]; + if (left < 0) return -1; /* over-subscribed */ + } + if (left > 0 && (type == CODES || max != 1)) + return -1; /* incomplete set */ + + /* generate offsets into symbol table for each length for sorting */ + offs[1] = 0; + for (len = 1; len < MAXBITS; len++) + offs[len + 1] = offs[len] + count[len]; + + /* sort symbols by length, by symbol order within each length */ + for (sym = 0; sym < codes; sym++) + if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym; + + /* + Create and fill in decoding tables. In this loop, the table being + filled is at next and has curr index bits. The code being used is huff + with length len. That code is converted to an index by dropping drop + bits off of the bottom. For codes where len is less than drop + curr, + those top drop + curr - len bits are incremented through all values to + fill the table with replicated entries. + + root is the number of index bits for the root table. When len exceeds + root, sub-tables are created pointed to by the root entry with an index + of the low root bits of huff. This is saved in low to check for when a + new sub-table should be started. drop is zero when the root table is + being filled, and drop is root when sub-tables are being filled. + + When a new sub-table is needed, it is necessary to look ahead in the + code lengths to determine what size sub-table is needed. The length + counts are used for this, and so count[] is decremented as codes are + entered in the tables. + + used keeps track of how many table entries have been allocated from the + provided *table space. It is checked for LENS and DIST tables against + the constants ENOUGH_LENS and ENOUGH_DISTS to guard against changes in + the initial root table size constants. See the comments in inftrees.h + for more information. + + sym increments through all symbols, and the loop terminates when + all codes of length max, i.e. all codes, have been processed. This + routine permits incomplete codes, so another loop after this one fills + in the rest of the decoding tables with invalid code markers. + */ + + /* set up for code type */ + switch (type) { + case CODES: + base = extra = work; /* dummy value--not used */ + end = 19; + break; + case LENS: + base = lbase; + base -= 257; + extra = lext; + extra -= 257; + end = 256; + break; + default: /* DISTS */ + base = dbase; + extra = dext; + end = -1; + } + + /* initialize state for loop */ + huff = 0; /* starting code */ + sym = 0; /* starting code symbol */ + len = min; /* starting code length */ + next = *table; /* current table to fill in */ + curr = root; /* current table index bits */ + drop = 0; /* current bits to drop from code for index */ + low = (unsigned)(-1); /* trigger new sub-table when len > root */ + used = 1U << root; /* use root table entries */ + mask = used - 1; /* mask for comparing low */ + + /* check available table space */ + if ((type == LENS && used >= ENOUGH_LENS) || + (type == DISTS && used >= ENOUGH_DISTS)) + return 1; + + /* process all codes and make table entries */ + for (;;) { + /* create table entry */ + here.bits = (unsigned char)(len - drop); + if ((int)(work[sym]) < end) { + here.op = (unsigned char)0; + here.val = work[sym]; + } + else if ((int)(work[sym]) > end) { + here.op = (unsigned char)(extra[work[sym]]); + here.val = base[work[sym]]; + } + else { + here.op = (unsigned char)(32 + 64); /* end of block */ + here.val = 0; + } + + /* replicate for those indices with low len bits equal to huff */ + incr = 1U << (len - drop); + fill = 1U << curr; + min = fill; /* save offset to next table */ + do { + fill -= incr; + next[(huff >> drop) + fill] = here; + } while (fill != 0); + + /* backwards increment the len-bit code huff */ + incr = 1U << (len - 1); + while (huff & incr) + incr >>= 1; + if (incr != 0) { + huff &= incr - 1; + huff += incr; + } + else + huff = 0; + + /* go to next symbol, update count, len */ + sym++; + if (--(count[len]) == 0) { + if (len == max) break; + len = lens[work[sym]]; + } + + /* create new sub-table if needed */ + if (len > root && (huff & mask) != low) { + /* if first time, transition to sub-tables */ + if (drop == 0) + drop = root; + + /* increment past last table */ + next += min; /* here min is 1 << curr */ + + /* determine length of next table */ + curr = len - drop; + left = (int)(1 << curr); + while (curr + drop < max) { + left -= count[curr + drop]; + if (left <= 0) break; + curr++; + left <<= 1; + } + + /* check for enough space */ + used += 1U << curr; + if ((type == LENS && used >= ENOUGH_LENS) || + (type == DISTS && used >= ENOUGH_DISTS)) + return 1; + + /* point entry in root table to sub-table */ + low = huff & mask; + (*table)[low].op = (unsigned char)curr; + (*table)[low].bits = (unsigned char)root; + (*table)[low].val = (unsigned short)(next - *table); + } + } + + /* fill in remaining table entry if code is incomplete (guaranteed to have + at most one remaining entry, since if the code is incomplete, the + maximum code length that was allowed to get this far is one bit) */ + if (huff != 0) { + here.op = (unsigned char)64; /* invalid code marker */ + here.bits = (unsigned char)(len - drop); + here.val = (unsigned short)0; + next[huff] = here; + } + + /* set return parameters */ + *table += used; + *bits = root; + return 0; +} diff --git a/zlib/thumb/inftrees.h b/zlib/thumb/inftrees.h new file mode 100644 index 0000000..baa53a0 --- /dev/null +++ b/zlib/thumb/inftrees.h @@ -0,0 +1,62 @@ +/* inftrees.h -- header to use inftrees.c + * Copyright (C) 1995-2005, 2010 Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +/* Structure for decoding tables. Each entry provides either the + information needed to do the operation requested by the code that + indexed that table entry, or it provides a pointer to another + table that indexes more bits of the code. op indicates whether + the entry is a pointer to another table, a literal, a length or + distance, an end-of-block, or an invalid code. For a table + pointer, the low four bits of op is the number of index bits of + that table. For a length or distance, the low four bits of op + is the number of extra bits to get after the code. bits is + the number of bits in this code or part of the code to drop off + of the bit buffer. val is the actual byte to output in the case + of a literal, the base length or distance, or the offset from + the current table to the next table. Each entry is four bytes. */ +typedef struct { + unsigned char op; /* operation, extra bits, table bits */ + unsigned char bits; /* bits in this part of the code */ + unsigned short val; /* offset in table or code value */ +} code; + +/* op values as set by inflate_table(): + 00000000 - literal + 0000tttt - table link, tttt != 0 is the number of table index bits + 0001eeee - length or distance, eeee is the number of extra bits + 01100000 - end of block + 01000000 - invalid code + */ + +/* Maximum size of the dynamic table. The maximum number of code structures is + 1444, which is the sum of 852 for literal/length codes and 592 for distance + codes. These values were found by exhaustive searches using the program + examples/enough.c found in the zlib distribtution. The arguments to that + program are the number of symbols, the initial root table size, and the + maximum bit length of a code. "enough 286 9 15" for literal/length codes + returns returns 852, and "enough 30 6 15" for distance codes returns 592. + The initial root table size (9 or 6) is found in the fifth argument of the + inflate_table() calls in inflate.c and infback.c. If the root table size is + changed, then these maximum sizes would be need to be recalculated and + updated. */ +#define ENOUGH_LENS 852 +#define ENOUGH_DISTS 592 +#define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS) + +/* Type of code to build for inflate_table() */ +typedef enum { + CODES, + LENS, + DISTS +} codetype; + +int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens, + unsigned codes, code FAR * FAR *table, + unsigned FAR *bits, unsigned short FAR *work)); diff --git a/zlib/thumb/libgcc.a b/zlib/thumb/libgcc.a new file mode 100644 index 0000000000000000000000000000000000000000..78bef1bd6ecb5e0f024e0667be565a231e8075cf GIT binary patch literal 5162692 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

+~+k@aD8cb4fl0S!)q3xk$fF5 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 OsC12iHsDC@P-F`!;rv^|5mc+7JXM`A_EO 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 t$%aFh@ZEwn_5P3~A5oeHF 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%0DZOEnS29zh-Nr#b|x=U+N~E*nwnI(NI*6PoR>c3 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%0DC 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 ram + .bss : { *(.bss*) } > ram +} + diff --git a/zlib/thumb/testdata.h b/zlib/thumb/testdata.h new file mode 100644 index 0000000..54ac04f --- /dev/null +++ b/zlib/thumb/testdata.h @@ -0,0 +1,630 @@ + +#define TESTDATALEN 10000 +const unsigned char testdata[TESTDATALEN]= +{ +0x0A,0x4D,0x6F,0x73,0x74,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x50,0x61,0x72, +0x74,0x68,0x65,0x6E,0x6F,0x6E,0x27,0x73,0x20,0x69,0x6D,0x70,0x6F,0x73,0x69,0x6E, +0x67,0x20,0x63,0x6F,0x6C,0x75,0x6D,0x6E,0x73,0x20,0x61,0x72,0x65,0x20,0x73,0x74, +0x69,0x6C,0x6C,0x20,0x73,0x74,0x61,0x6E,0x64,0x69,0x6E,0x67,0x2C,0x20,0x62,0x75, +0x74,0x20,0x74,0x68,0x65,0x20,0x72,0x6F,0x6F,0x66,0x0A,0x69,0x73,0x20,0x67,0x6F, +0x6E,0x65,0x2E,0x20,0x20,0x49,0x74,0x20,0x77,0x61,0x73,0x20,0x61,0x20,0x70,0x65, +0x72,0x66,0x65,0x63,0x74,0x20,0x62,0x75,0x69,0x6C,0x64,0x69,0x6E,0x67,0x20,0x74, +0x77,0x6F,0x20,0x68,0x75,0x6E,0x64,0x72,0x65,0x64,0x20,0x61,0x6E,0x64,0x20,0x66, +0x69,0x66,0x74,0x79,0x20,0x79,0x65,0x61,0x72,0x73,0x20,0x61,0x67,0x6F,0x2C,0x20, +0x77,0x68,0x65,0x6E,0x0A,0x61,0x20,0x73,0x68,0x65,0x6C,0x6C,0x20,0x64,0x72,0x6F, +0x70,0x70,0x65,0x64,0x20,0x69,0x6E,0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x56,0x65, +0x6E,0x65,0x74,0x69,0x61,0x6E,0x20,0x6D,0x61,0x67,0x61,0x7A,0x69,0x6E,0x65,0x20, +0x73,0x74,0x6F,0x72,0x65,0x64,0x20,0x68,0x65,0x72,0x65,0x2C,0x20,0x61,0x6E,0x64, +0x20,0x74,0x68,0x65,0x20,0x65,0x78,0x70,0x6C,0x6F,0x73,0x69,0x6F,0x6E,0x0A,0x77, +0x68,0x69,0x63,0x68,0x20,0x66,0x6F,0x6C,0x6C,0x6F,0x77,0x65,0x64,0x20,0x77,0x72, +0x65,0x63,0x6B,0x65,0x64,0x20,0x61,0x6E,0x64,0x20,0x75,0x6E,0x72,0x6F,0x6F,0x66, +0x65,0x64,0x20,0x69,0x74,0x2E,0x20,0x20,0x49,0x20,0x72,0x65,0x6D,0x65,0x6D,0x62, +0x65,0x72,0x20,0x62,0x75,0x74,0x20,0x6C,0x69,0x74,0x74,0x6C,0x65,0x20,0x61,0x62, +0x6F,0x75,0x74,0x20,0x74,0x68,0x65,0x0A,0x50,0x61,0x72,0x74,0x68,0x65,0x6E,0x6F, +0x6E,0x2C,0x20,0x61,0x6E,0x64,0x20,0x49,0x20,0x68,0x61,0x76,0x65,0x20,0x70,0x75, +0x74,0x20,0x69,0x6E,0x20,0x6F,0x6E,0x65,0x20,0x6F,0x72,0x20,0x74,0x77,0x6F,0x20, +0x66,0x61,0x63,0x74,0x73,0x20,0x61,0x6E,0x64,0x20,0x66,0x69,0x67,0x75,0x72,0x65, +0x73,0x20,0x66,0x6F,0x72,0x20,0x74,0x68,0x65,0x20,0x75,0x73,0x65,0x20,0x6F,0x66, +0x0A,0x6F,0x74,0x68,0x65,0x72,0x20,0x70,0x65,0x6F,0x70,0x6C,0x65,0x20,0x77,0x69, +0x74,0x68,0x20,0x73,0x68,0x6F,0x72,0x74,0x20,0x6D,0x65,0x6D,0x6F,0x72,0x69,0x65, +0x73,0x2E,0x20,0x20,0x47,0x6F,0x74,0x20,0x74,0x68,0x65,0x6D,0x20,0x66,0x72,0x6F, +0x6D,0x20,0x74,0x68,0x65,0x20,0x67,0x75,0x69,0x64,0x65,0x2D,0x62,0x6F,0x6F,0x6B, +0x2E,0x0A,0x0A,0x41,0x73,0x20,0x77,0x65,0x20,0x77,0x61,0x6E,0x64,0x65,0x72,0x65, +0x64,0x20,0x74,0x68,0x6F,0x75,0x67,0x68,0x74,0x66,0x75,0x6C,0x6C,0x79,0x20,0x64, +0x6F,0x77,0x6E,0x20,0x74,0x68,0x65,0x20,0x6D,0x61,0x72,0x62,0x6C,0x65,0x2D,0x70, +0x61,0x76,0x65,0x64,0x20,0x6C,0x65,0x6E,0x67,0x74,0x68,0x20,0x6F,0x66,0x20,0x74, +0x68,0x69,0x73,0x20,0x73,0x74,0x61,0x74,0x65,0x6C,0x79,0x0A,0x74,0x65,0x6D,0x70, +0x6C,0x65,0x2C,0x20,0x74,0x68,0x65,0x20,0x73,0x63,0x65,0x6E,0x65,0x20,0x61,0x62, +0x6F,0x75,0x74,0x20,0x75,0x73,0x20,0x77,0x61,0x73,0x20,0x73,0x74,0x72,0x61,0x6E, +0x67,0x65,0x6C,0x79,0x20,0x69,0x6D,0x70,0x72,0x65,0x73,0x73,0x69,0x76,0x65,0x2E, +0x20,0x20,0x48,0x65,0x72,0x65,0x20,0x61,0x6E,0x64,0x20,0x74,0x68,0x65,0x72,0x65, +0x2C,0x20,0x69,0x6E,0x0A,0x6C,0x61,0x76,0x69,0x73,0x68,0x20,0x70,0x72,0x6F,0x66, +0x75,0x73,0x69,0x6F,0x6E,0x2C,0x20,0x77,0x65,0x72,0x65,0x20,0x67,0x6C,0x65,0x61, +0x6D,0x69,0x6E,0x67,0x20,0x77,0x68,0x69,0x74,0x65,0x20,0x73,0x74,0x61,0x74,0x75, +0x65,0x73,0x20,0x6F,0x66,0x20,0x6D,0x65,0x6E,0x20,0x61,0x6E,0x64,0x20,0x77,0x6F, +0x6D,0x65,0x6E,0x2C,0x20,0x70,0x72,0x6F,0x70,0x70,0x65,0x64,0x0A,0x61,0x67,0x61, +0x69,0x6E,0x73,0x74,0x20,0x62,0x6C,0x6F,0x63,0x6B,0x73,0x20,0x6F,0x66,0x20,0x6D, +0x61,0x72,0x62,0x6C,0x65,0x2C,0x20,0x73,0x6F,0x6D,0x65,0x20,0x6F,0x66,0x20,0x74, +0x68,0x65,0x6D,0x20,0x61,0x72,0x6D,0x6C,0x65,0x73,0x73,0x2C,0x20,0x73,0x6F,0x6D, +0x65,0x20,0x77,0x69,0x74,0x68,0x6F,0x75,0x74,0x20,0x6C,0x65,0x67,0x73,0x2C,0x20, +0x6F,0x74,0x68,0x65,0x72,0x73,0x0A,0x68,0x65,0x61,0x64,0x6C,0x65,0x73,0x73,0x2D, +0x2D,0x62,0x75,0x74,0x20,0x61,0x6C,0x6C,0x20,0x6C,0x6F,0x6F,0x6B,0x69,0x6E,0x67, +0x20,0x6D,0x6F,0x75,0x72,0x6E,0x66,0x75,0x6C,0x20,0x69,0x6E,0x20,0x74,0x68,0x65, +0x20,0x6D,0x6F,0x6F,0x6E,0x6C,0x69,0x67,0x68,0x74,0x2C,0x20,0x61,0x6E,0x64,0x20, +0x73,0x74,0x61,0x72,0x74,0x6C,0x69,0x6E,0x67,0x6C,0x79,0x0A,0x68,0x75,0x6D,0x61, +0x6E,0x21,0x20,0x20,0x54,0x68,0x65,0x79,0x20,0x72,0x6F,0x73,0x65,0x20,0x75,0x70, +0x20,0x61,0x6E,0x64,0x20,0x63,0x6F,0x6E,0x66,0x72,0x6F,0x6E,0x74,0x65,0x64,0x20, +0x74,0x68,0x65,0x20,0x6D,0x69,0x64,0x6E,0x69,0x67,0x68,0x74,0x20,0x69,0x6E,0x74, +0x72,0x75,0x64,0x65,0x72,0x20,0x6F,0x6E,0x20,0x65,0x76,0x65,0x72,0x79,0x20,0x73, +0x69,0x64,0x65,0x0A,0x2D,0x2D,0x74,0x68,0x65,0x79,0x20,0x73,0x74,0x61,0x72,0x65, +0x64,0x20,0x61,0x74,0x20,0x68,0x69,0x6D,0x20,0x77,0x69,0x74,0x68,0x20,0x73,0x74, +0x6F,0x6E,0x79,0x20,0x65,0x79,0x65,0x73,0x20,0x66,0x72,0x6F,0x6D,0x20,0x75,0x6E, +0x6C,0x6F,0x6F,0x6B,0x65,0x64,0x2D,0x66,0x6F,0x72,0x20,0x6E,0x6F,0x6F,0x6B,0x73, +0x20,0x61,0x6E,0x64,0x20,0x72,0x65,0x63,0x65,0x73,0x73,0x65,0x73,0x3B,0x0A,0x74, +0x68,0x65,0x79,0x20,0x70,0x65,0x65,0x72,0x65,0x64,0x20,0x61,0x74,0x20,0x68,0x69, +0x6D,0x20,0x6F,0x76,0x65,0x72,0x20,0x66,0x72,0x61,0x67,0x6D,0x65,0x6E,0x74,0x61, +0x72,0x79,0x20,0x68,0x65,0x61,0x70,0x73,0x20,0x66,0x61,0x72,0x20,0x64,0x6F,0x77, +0x6E,0x20,0x74,0x68,0x65,0x20,0x64,0x65,0x73,0x6F,0x6C,0x61,0x74,0x65,0x0A,0x63, +0x6F,0x72,0x72,0x69,0x64,0x6F,0x72,0x73,0x3B,0x20,0x74,0x68,0x65,0x79,0x20,0x62, +0x61,0x72,0x72,0x65,0x64,0x20,0x68,0x69,0x73,0x20,0x77,0x61,0x79,0x20,0x69,0x6E, +0x20,0x74,0x68,0x65,0x20,0x6D,0x69,0x64,0x73,0x74,0x20,0x6F,0x66,0x20,0x74,0x68, +0x65,0x20,0x62,0x72,0x6F,0x61,0x64,0x20,0x66,0x6F,0x72,0x75,0x6D,0x2C,0x20,0x61, +0x6E,0x64,0x0A,0x73,0x6F,0x6C,0x65,0x6D,0x6E,0x6C,0x79,0x20,0x70,0x6F,0x69,0x6E, +0x74,0x65,0x64,0x20,0x77,0x69,0x74,0x68,0x20,0x68,0x61,0x6E,0x64,0x6C,0x65,0x73, +0x73,0x20,0x61,0x72,0x6D,0x73,0x20,0x74,0x68,0x65,0x20,0x77,0x61,0x79,0x20,0x66, +0x72,0x6F,0x6D,0x20,0x74,0x68,0x65,0x20,0x73,0x61,0x63,0x72,0x65,0x64,0x20,0x66, +0x61,0x6E,0x65,0x3B,0x20,0x61,0x6E,0x64,0x0A,0x74,0x68,0x72,0x6F,0x75,0x67,0x68, +0x20,0x74,0x68,0x65,0x20,0x72,0x6F,0x6F,0x66,0x6C,0x65,0x73,0x73,0x20,0x74,0x65, +0x6D,0x70,0x6C,0x65,0x20,0x74,0x68,0x65,0x20,0x6D,0x6F,0x6F,0x6E,0x20,0x6C,0x6F, +0x6F,0x6B,0x65,0x64,0x20,0x64,0x6F,0x77,0x6E,0x2C,0x20,0x61,0x6E,0x64,0x20,0x62, +0x61,0x6E,0x64,0x65,0x64,0x20,0x74,0x68,0x65,0x20,0x66,0x6C,0x6F,0x6F,0x72,0x0A, +0x61,0x6E,0x64,0x20,0x64,0x61,0x72,0x6B,0x65,0x6E,0x65,0x64,0x20,0x74,0x68,0x65, +0x20,0x73,0x63,0x61,0x74,0x74,0x65,0x72,0x65,0x64,0x20,0x66,0x72,0x61,0x67,0x6D, +0x65,0x6E,0x74,0x73,0x20,0x61,0x6E,0x64,0x20,0x62,0x72,0x6F,0x6B,0x65,0x6E,0x20, +0x73,0x74,0x61,0x74,0x75,0x65,0x73,0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x68,0x65, +0x20,0x73,0x6C,0x61,0x6E,0x74,0x69,0x6E,0x67,0x0A,0x73,0x68,0x61,0x64,0x6F,0x77, +0x73,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x63,0x6F,0x6C,0x75,0x6D,0x6E,0x73, +0x2E,0x0A,0x0A,0x57,0x68,0x61,0x74,0x20,0x61,0x20,0x77,0x6F,0x72,0x6C,0x64,0x20, +0x6F,0x66,0x20,0x72,0x75,0x69,0x6E,0x65,0x64,0x20,0x73,0x63,0x75,0x6C,0x70,0x74, +0x75,0x72,0x65,0x20,0x77,0x61,0x73,0x20,0x61,0x62,0x6F,0x75,0x74,0x20,0x75,0x73, +0x21,0x20,0x20,0x53,0x65,0x74,0x20,0x75,0x70,0x20,0x69,0x6E,0x20,0x72,0x6F,0x77, +0x73,0x2D,0x2D,0x73,0x74,0x61,0x63,0x6B,0x65,0x64,0x0A,0x75,0x70,0x20,0x69,0x6E, +0x20,0x70,0x69,0x6C,0x65,0x73,0x2D,0x2D,0x73,0x63,0x61,0x74,0x74,0x65,0x72,0x65, +0x64,0x20,0x62,0x72,0x6F,0x61,0x64,0x63,0x61,0x73,0x74,0x20,0x6F,0x76,0x65,0x72, +0x20,0x74,0x68,0x65,0x20,0x77,0x69,0x64,0x65,0x20,0x61,0x72,0x65,0x61,0x20,0x6F, +0x66,0x20,0x74,0x68,0x65,0x20,0x41,0x63,0x72,0x6F,0x70,0x6F,0x6C,0x69,0x73,0x0A, +0x2D,0x2D,0x77,0x65,0x72,0x65,0x20,0x68,0x75,0x6E,0x64,0x72,0x65,0x64,0x73,0x20, +0x6F,0x66,0x20,0x63,0x72,0x69,0x70,0x70,0x6C,0x65,0x64,0x20,0x73,0x74,0x61,0x74, +0x75,0x65,0x73,0x20,0x6F,0x66,0x20,0x61,0x6C,0x6C,0x20,0x73,0x69,0x7A,0x65,0x73, +0x20,0x61,0x6E,0x64,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x6D,0x6F,0x73,0x74, +0x20,0x65,0x78,0x71,0x75,0x69,0x73,0x69,0x74,0x65,0x0A,0x77,0x6F,0x72,0x6B,0x6D, +0x61,0x6E,0x73,0x68,0x69,0x70,0x3B,0x20,0x61,0x6E,0x64,0x20,0x76,0x61,0x73,0x74, +0x20,0x66,0x72,0x61,0x67,0x6D,0x65,0x6E,0x74,0x73,0x20,0x6F,0x66,0x20,0x6D,0x61, +0x72,0x62,0x6C,0x65,0x20,0x74,0x68,0x61,0x74,0x20,0x6F,0x6E,0x63,0x65,0x20,0x62, +0x65,0x6C,0x6F,0x6E,0x67,0x65,0x64,0x20,0x74,0x6F,0x20,0x74,0x68,0x65,0x0A,0x65, +0x6E,0x74,0x61,0x62,0x6C,0x61,0x74,0x75,0x72,0x65,0x73,0x2C,0x20,0x63,0x6F,0x76, +0x65,0x72,0x65,0x64,0x20,0x77,0x69,0x74,0x68,0x20,0x62,0x61,0x73,0x2D,0x72,0x65, +0x6C,0x69,0x65,0x66,0x73,0x20,0x72,0x65,0x70,0x72,0x65,0x73,0x65,0x6E,0x74,0x69, +0x6E,0x67,0x20,0x62,0x61,0x74,0x74,0x6C,0x65,0x73,0x20,0x61,0x6E,0x64,0x20,0x73, +0x69,0x65,0x67,0x65,0x73,0x2C,0x0A,0x73,0x68,0x69,0x70,0x73,0x20,0x6F,0x66,0x20, +0x77,0x61,0x72,0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x68,0x72,0x65,0x65,0x20,0x61, +0x6E,0x64,0x20,0x66,0x6F,0x75,0x72,0x20,0x74,0x69,0x65,0x72,0x73,0x20,0x6F,0x66, +0x20,0x6F,0x61,0x72,0x73,0x2C,0x20,0x70,0x61,0x67,0x65,0x61,0x6E,0x74,0x73,0x20, +0x61,0x6E,0x64,0x20,0x70,0x72,0x6F,0x63,0x65,0x73,0x73,0x69,0x6F,0x6E,0x73,0x0A, +0x2D,0x2D,0x65,0x76,0x65,0x72,0x79,0x20,0x74,0x68,0x69,0x6E,0x67,0x20,0x6F,0x6E, +0x65,0x20,0x63,0x6F,0x75,0x6C,0x64,0x20,0x74,0x68,0x69,0x6E,0x6B,0x20,0x6F,0x66, +0x2E,0x20,0x20,0x48,0x69,0x73,0x74,0x6F,0x72,0x79,0x20,0x73,0x61,0x79,0x73,0x20, +0x74,0x68,0x61,0x74,0x20,0x74,0x68,0x65,0x20,0x74,0x65,0x6D,0x70,0x6C,0x65,0x73, +0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x0A,0x41,0x63,0x72,0x6F,0x70,0x6F,0x6C,0x69, +0x73,0x20,0x77,0x65,0x72,0x65,0x20,0x66,0x69,0x6C,0x6C,0x65,0x64,0x20,0x77,0x69, +0x74,0x68,0x20,0x74,0x68,0x65,0x20,0x6E,0x6F,0x62,0x6C,0x65,0x73,0x74,0x20,0x77, +0x6F,0x72,0x6B,0x73,0x20,0x6F,0x66,0x20,0x50,0x72,0x61,0x78,0x69,0x74,0x65,0x6C, +0x65,0x73,0x20,0x61,0x6E,0x64,0x20,0x50,0x68,0x69,0x64,0x69,0x61,0x73,0x2C,0x0A, +0x61,0x6E,0x64,0x20,0x6F,0x66,0x20,0x6D,0x61,0x6E,0x79,0x20,0x61,0x20,0x67,0x72, +0x65,0x61,0x74,0x20,0x6D,0x61,0x73,0x74,0x65,0x72,0x20,0x69,0x6E,0x20,0x73,0x63, +0x75,0x6C,0x70,0x74,0x75,0x72,0x65,0x20,0x62,0x65,0x73,0x69,0x64,0x65,0x73,0x2D, +0x2D,0x61,0x6E,0x64,0x20,0x73,0x75,0x72,0x65,0x6C,0x79,0x20,0x74,0x68,0x65,0x73, +0x65,0x20,0x65,0x6C,0x65,0x67,0x61,0x6E,0x74,0x0A,0x66,0x72,0x61,0x67,0x6D,0x65, +0x6E,0x74,0x73,0x20,0x61,0x74,0x74,0x65,0x73,0x74,0x20,0x69,0x74,0x2E,0x0A,0x0A, +0x57,0x65,0x20,0x77,0x61,0x6C,0x6B,0x65,0x64,0x20,0x6F,0x75,0x74,0x20,0x69,0x6E, +0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x67,0x72,0x61,0x73,0x73,0x2D,0x67,0x72,0x6F, +0x77,0x6E,0x2C,0x20,0x66,0x72,0x61,0x67,0x6D,0x65,0x6E,0x74,0x2D,0x73,0x74,0x72, +0x65,0x77,0x6E,0x20,0x63,0x6F,0x75,0x72,0x74,0x20,0x62,0x65,0x79,0x6F,0x6E,0x64, +0x20,0x74,0x68,0x65,0x0A,0x50,0x61,0x72,0x74,0x68,0x65,0x6E,0x6F,0x6E,0x2E,0x20, +0x20,0x49,0x74,0x20,0x73,0x74,0x61,0x72,0x74,0x6C,0x65,0x64,0x20,0x75,0x73,0x2C, +0x20,0x65,0x76,0x65,0x72,0x79,0x20,0x6E,0x6F,0x77,0x20,0x61,0x6E,0x64,0x20,0x74, +0x68,0x65,0x6E,0x2C,0x20,0x74,0x6F,0x20,0x73,0x65,0x65,0x20,0x61,0x20,0x73,0x74, +0x6F,0x6E,0x79,0x20,0x77,0x68,0x69,0x74,0x65,0x20,0x66,0x61,0x63,0x65,0x0A,0x73, +0x74,0x61,0x72,0x65,0x20,0x73,0x75,0x64,0x64,0x65,0x6E,0x6C,0x79,0x20,0x75,0x70, +0x20,0x61,0x74,0x20,0x75,0x73,0x20,0x6F,0x75,0x74,0x20,0x6F,0x66,0x20,0x74,0x68, +0x65,0x20,0x67,0x72,0x61,0x73,0x73,0x20,0x77,0x69,0x74,0x68,0x20,0x69,0x74,0x73, +0x20,0x64,0x65,0x61,0x64,0x20,0x65,0x79,0x65,0x73,0x2E,0x20,0x20,0x54,0x68,0x65, +0x20,0x70,0x6C,0x61,0x63,0x65,0x0A,0x73,0x65,0x65,0x6D,0x65,0x64,0x20,0x61,0x6C, +0x69,0x76,0x65,0x20,0x77,0x69,0x74,0x68,0x20,0x67,0x68,0x6F,0x73,0x74,0x73,0x2E, +0x20,0x20,0x49,0x20,0x68,0x61,0x6C,0x66,0x20,0x65,0x78,0x70,0x65,0x63,0x74,0x65, +0x64,0x20,0x74,0x6F,0x20,0x73,0x65,0x65,0x20,0x74,0x68,0x65,0x20,0x41,0x74,0x68, +0x65,0x6E,0x69,0x61,0x6E,0x20,0x68,0x65,0x72,0x6F,0x65,0x73,0x20,0x6F,0x66,0x0A, +0x74,0x77,0x65,0x6E,0x74,0x79,0x20,0x63,0x65,0x6E,0x74,0x75,0x72,0x69,0x65,0x73, +0x20,0x61,0x67,0x6F,0x20,0x67,0x6C,0x69,0x64,0x65,0x20,0x6F,0x75,0x74,0x20,0x6F, +0x66,0x20,0x74,0x68,0x65,0x20,0x73,0x68,0x61,0x64,0x6F,0x77,0x73,0x20,0x61,0x6E, +0x64,0x20,0x73,0x74,0x65,0x61,0x6C,0x20,0x69,0x6E,0x74,0x6F,0x20,0x74,0x68,0x65, +0x20,0x6F,0x6C,0x64,0x0A,0x74,0x65,0x6D,0x70,0x6C,0x65,0x20,0x74,0x68,0x65,0x79, +0x20,0x6B,0x6E,0x65,0x77,0x20,0x73,0x6F,0x20,0x77,0x65,0x6C,0x6C,0x20,0x61,0x6E, +0x64,0x20,0x72,0x65,0x67,0x61,0x72,0x64,0x65,0x64,0x20,0x77,0x69,0x74,0x68,0x20, +0x73,0x75,0x63,0x68,0x20,0x62,0x6F,0x75,0x6E,0x64,0x6C,0x65,0x73,0x73,0x20,0x70, +0x72,0x69,0x64,0x65,0x2E,0x0A,0x0A,0x54,0x68,0x65,0x20,0x66,0x75,0x6C,0x6C,0x20, +0x6D,0x6F,0x6F,0x6E,0x20,0x77,0x61,0x73,0x20,0x72,0x69,0x64,0x69,0x6E,0x67,0x20, +0x68,0x69,0x67,0x68,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x63,0x6C,0x6F,0x75, +0x64,0x6C,0x65,0x73,0x73,0x20,0x68,0x65,0x61,0x76,0x65,0x6E,0x73,0x2C,0x20,0x6E, +0x6F,0x77,0x2E,0x20,0x20,0x57,0x65,0x0A,0x73,0x61,0x75,0x6E,0x74,0x65,0x72,0x65, +0x64,0x20,0x63,0x61,0x72,0x65,0x6C,0x65,0x73,0x73,0x6C,0x79,0x20,0x61,0x6E,0x64, +0x20,0x75,0x6E,0x74,0x68,0x69,0x6E,0x6B,0x69,0x6E,0x67,0x6C,0x79,0x20,0x74,0x6F, +0x20,0x74,0x68,0x65,0x20,0x65,0x64,0x67,0x65,0x20,0x6F,0x66,0x20,0x74,0x68,0x65, +0x20,0x6C,0x6F,0x66,0x74,0x79,0x0A,0x62,0x61,0x74,0x74,0x6C,0x65,0x6D,0x65,0x6E, +0x74,0x73,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x63,0x69,0x74,0x61,0x64,0x65, +0x6C,0x2C,0x20,0x61,0x6E,0x64,0x20,0x6C,0x6F,0x6F,0x6B,0x65,0x64,0x20,0x64,0x6F, +0x77,0x6E,0x2D,0x2D,0x61,0x20,0x76,0x69,0x73,0x69,0x6F,0x6E,0x21,0x20,0x20,0x41, +0x6E,0x64,0x20,0x73,0x75,0x63,0x68,0x20,0x61,0x0A,0x76,0x69,0x73,0x69,0x6F,0x6E, +0x21,0x20,0x20,0x41,0x74,0x68,0x65,0x6E,0x73,0x20,0x62,0x79,0x20,0x6D,0x6F,0x6F, +0x6E,0x6C,0x69,0x67,0x68,0x74,0x21,0x20,0x20,0x54,0x68,0x65,0x20,0x70,0x72,0x6F, +0x70,0x68,0x65,0x74,0x20,0x74,0x68,0x61,0x74,0x20,0x74,0x68,0x6F,0x75,0x67,0x68, +0x74,0x20,0x74,0x68,0x65,0x20,0x73,0x70,0x6C,0x65,0x6E,0x64,0x6F,0x72,0x73,0x20, +0x6F,0x66,0x0A,0x74,0x68,0x65,0x20,0x4E,0x65,0x77,0x20,0x4A,0x65,0x72,0x75,0x73, +0x61,0x6C,0x65,0x6D,0x20,0x77,0x65,0x72,0x65,0x20,0x72,0x65,0x76,0x65,0x61,0x6C, +0x65,0x64,0x20,0x74,0x6F,0x20,0x68,0x69,0x6D,0x2C,0x20,0x73,0x75,0x72,0x65,0x6C, +0x79,0x20,0x73,0x61,0x77,0x20,0x74,0x68,0x69,0x73,0x20,0x69,0x6E,0x73,0x74,0x65, +0x61,0x64,0x21,0x20,0x20,0x49,0x74,0x20,0x6C,0x61,0x79,0x0A,0x69,0x6E,0x20,0x74, +0x68,0x65,0x20,0x6C,0x65,0x76,0x65,0x6C,0x20,0x70,0x6C,0x61,0x69,0x6E,0x20,0x72, +0x69,0x67,0x68,0x74,0x20,0x75,0x6E,0x64,0x65,0x72,0x20,0x6F,0x75,0x72,0x20,0x66, +0x65,0x65,0x74,0x2D,0x2D,0x61,0x6C,0x6C,0x20,0x73,0x70,0x72,0x65,0x61,0x64,0x20, +0x61,0x62,0x72,0x6F,0x61,0x64,0x20,0x6C,0x69,0x6B,0x65,0x20,0x61,0x0A,0x70,0x69, +0x63,0x74,0x75,0x72,0x65,0x2D,0x2D,0x61,0x6E,0x64,0x20,0x77,0x65,0x20,0x6C,0x6F, +0x6F,0x6B,0x65,0x64,0x20,0x64,0x6F,0x77,0x6E,0x20,0x75,0x70,0x6F,0x6E,0x20,0x69, +0x74,0x20,0x61,0x73,0x20,0x77,0x65,0x20,0x6D,0x69,0x67,0x68,0x74,0x20,0x68,0x61, +0x76,0x65,0x20,0x6C,0x6F,0x6F,0x6B,0x65,0x64,0x20,0x66,0x72,0x6F,0x6D,0x20,0x61, +0x0A,0x62,0x61,0x6C,0x6C,0x6F,0x6F,0x6E,0x2E,0x20,0x20,0x57,0x65,0x20,0x73,0x61, +0x77,0x20,0x6E,0x6F,0x20,0x73,0x65,0x6D,0x62,0x6C,0x61,0x6E,0x63,0x65,0x20,0x6F, +0x66,0x20,0x61,0x20,0x73,0x74,0x72,0x65,0x65,0x74,0x2C,0x20,0x62,0x75,0x74,0x20, +0x65,0x76,0x65,0x72,0x79,0x20,0x68,0x6F,0x75,0x73,0x65,0x2C,0x20,0x65,0x76,0x65, +0x72,0x79,0x20,0x77,0x69,0x6E,0x64,0x6F,0x77,0x2C,0x0A,0x65,0x76,0x65,0x72,0x79, +0x20,0x63,0x6C,0x69,0x6E,0x67,0x69,0x6E,0x67,0x20,0x76,0x69,0x6E,0x65,0x2C,0x20, +0x65,0x76,0x65,0x72,0x79,0x20,0x70,0x72,0x6F,0x6A,0x65,0x63,0x74,0x69,0x6F,0x6E, +0x20,0x77,0x61,0x73,0x20,0x61,0x73,0x20,0x64,0x69,0x73,0x74,0x69,0x6E,0x63,0x74, +0x20,0x61,0x6E,0x64,0x20,0x73,0x68,0x61,0x72,0x70,0x6C,0x79,0x20,0x6D,0x61,0x72, +0x6B,0x65,0x64,0x0A,0x61,0x73,0x20,0x69,0x66,0x20,0x74,0x68,0x65,0x20,0x74,0x69, +0x6D,0x65,0x20,0x77,0x65,0x72,0x65,0x20,0x6E,0x6F,0x6F,0x6E,0x2D,0x64,0x61,0x79, +0x3B,0x20,0x61,0x6E,0x64,0x20,0x79,0x65,0x74,0x20,0x74,0x68,0x65,0x72,0x65,0x20, +0x77,0x61,0x73,0x20,0x6E,0x6F,0x20,0x67,0x6C,0x61,0x72,0x65,0x2C,0x20,0x6E,0x6F, +0x20,0x67,0x6C,0x69,0x74,0x74,0x65,0x72,0x2C,0x0A,0x6E,0x6F,0x74,0x68,0x69,0x6E, +0x67,0x20,0x68,0x61,0x72,0x73,0x68,0x20,0x6F,0x72,0x20,0x72,0x65,0x70,0x75,0x6C, +0x73,0x69,0x76,0x65,0x2D,0x2D,0x74,0x68,0x65,0x20,0x6E,0x6F,0x69,0x73,0x65,0x6C, +0x65,0x73,0x73,0x20,0x63,0x69,0x74,0x79,0x20,0x77,0x61,0x73,0x20,0x66,0x6C,0x6F, +0x6F,0x64,0x65,0x64,0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x68,0x65,0x0A,0x6D,0x65, +0x6C,0x6C,0x6F,0x77,0x65,0x73,0x74,0x20,0x6C,0x69,0x67,0x68,0x74,0x20,0x74,0x68, +0x61,0x74,0x20,0x65,0x76,0x65,0x72,0x20,0x73,0x74,0x72,0x65,0x61,0x6D,0x65,0x64, +0x20,0x66,0x72,0x6F,0x6D,0x20,0x74,0x68,0x65,0x20,0x6D,0x6F,0x6F,0x6E,0x2C,0x20, +0x61,0x6E,0x64,0x20,0x73,0x65,0x65,0x6D,0x65,0x64,0x20,0x6C,0x69,0x6B,0x65,0x20, +0x73,0x6F,0x6D,0x65,0x0A,0x6C,0x69,0x76,0x69,0x6E,0x67,0x20,0x63,0x72,0x65,0x61, +0x74,0x75,0x72,0x65,0x20,0x77,0x72,0x61,0x70,0x70,0x65,0x64,0x20,0x69,0x6E,0x20, +0x70,0x65,0x61,0x63,0x65,0x66,0x75,0x6C,0x20,0x73,0x6C,0x75,0x6D,0x62,0x65,0x72, +0x2E,0x20,0x20,0x4F,0x6E,0x20,0x69,0x74,0x73,0x20,0x66,0x75,0x72,0x74,0x68,0x65, +0x72,0x20,0x73,0x69,0x64,0x65,0x20,0x77,0x61,0x73,0x20,0x61,0x0A,0x6C,0x69,0x74, +0x74,0x6C,0x65,0x20,0x74,0x65,0x6D,0x70,0x6C,0x65,0x2C,0x20,0x77,0x68,0x6F,0x73, +0x65,0x20,0x64,0x65,0x6C,0x69,0x63,0x61,0x74,0x65,0x20,0x70,0x69,0x6C,0x6C,0x61, +0x72,0x73,0x20,0x61,0x6E,0x64,0x20,0x6F,0x72,0x6E,0x61,0x74,0x65,0x20,0x66,0x72, +0x6F,0x6E,0x74,0x20,0x67,0x6C,0x6F,0x77,0x65,0x64,0x20,0x77,0x69,0x74,0x68,0x20, +0x61,0x20,0x72,0x69,0x63,0x68,0x0A,0x6C,0x75,0x73,0x74,0x72,0x65,0x20,0x74,0x68, +0x61,0x74,0x20,0x63,0x68,0x61,0x69,0x6E,0x65,0x64,0x20,0x74,0x68,0x65,0x20,0x65, +0x79,0x65,0x20,0x6C,0x69,0x6B,0x65,0x20,0x61,0x20,0x73,0x70,0x65,0x6C,0x6C,0x3B, +0x20,0x61,0x6E,0x64,0x20,0x6E,0x65,0x61,0x72,0x65,0x72,0x20,0x62,0x79,0x2C,0x20, +0x74,0x68,0x65,0x20,0x70,0x61,0x6C,0x61,0x63,0x65,0x20,0x6F,0x66,0x0A,0x74,0x68, +0x65,0x20,0x6B,0x69,0x6E,0x67,0x20,0x72,0x65,0x61,0x72,0x65,0x64,0x20,0x69,0x74, +0x73,0x20,0x63,0x72,0x65,0x61,0x6D,0x79,0x20,0x77,0x61,0x6C,0x6C,0x73,0x20,0x6F, +0x75,0x74,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x6D,0x69,0x64,0x73,0x74,0x20, +0x6F,0x66,0x20,0x61,0x20,0x67,0x72,0x65,0x61,0x74,0x20,0x67,0x61,0x72,0x64,0x65, +0x6E,0x20,0x6F,0x66,0x0A,0x73,0x68,0x72,0x75,0x62,0x62,0x65,0x72,0x79,0x20,0x74, +0x68,0x61,0x74,0x20,0x77,0x61,0x73,0x20,0x66,0x6C,0x65,0x63,0x6B,0x65,0x64,0x20, +0x61,0x6C,0x6C,0x20,0x6F,0x76,0x65,0x72,0x20,0x77,0x69,0x74,0x68,0x20,0x61,0x20, +0x72,0x61,0x6E,0x64,0x6F,0x6D,0x20,0x73,0x68,0x6F,0x77,0x65,0x72,0x20,0x6F,0x66, +0x20,0x61,0x6D,0x62,0x65,0x72,0x20,0x6C,0x69,0x67,0x68,0x74,0x73,0x0A,0x2D,0x2D, +0x61,0x20,0x73,0x70,0x72,0x61,0x79,0x20,0x6F,0x66,0x20,0x67,0x6F,0x6C,0x64,0x65, +0x6E,0x20,0x73,0x70,0x61,0x72,0x6B,0x73,0x20,0x74,0x68,0x61,0x74,0x20,0x6C,0x6F, +0x73,0x74,0x20,0x74,0x68,0x65,0x69,0x72,0x20,0x62,0x72,0x69,0x67,0x68,0x74,0x6E, +0x65,0x73,0x73,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x67,0x6C,0x6F,0x72,0x79, +0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x0A,0x6D,0x6F,0x6F,0x6E,0x2C,0x20,0x61,0x6E, +0x64,0x20,0x67,0x6C,0x69,0x6E,0x74,0x65,0x64,0x20,0x73,0x6F,0x66,0x74,0x6C,0x79, +0x20,0x75,0x70,0x6F,0x6E,0x20,0x74,0x68,0x65,0x20,0x73,0x65,0x61,0x20,0x6F,0x66, +0x20,0x64,0x61,0x72,0x6B,0x20,0x66,0x6F,0x6C,0x69,0x61,0x67,0x65,0x20,0x6C,0x69, +0x6B,0x65,0x20,0x74,0x68,0x65,0x20,0x70,0x61,0x6C,0x6C,0x69,0x64,0x0A,0x73,0x74, +0x61,0x72,0x73,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x6D,0x69,0x6C,0x6B,0x79, +0x2D,0x77,0x61,0x79,0x2E,0x20,0x20,0x4F,0x76,0x65,0x72,0x68,0x65,0x61,0x64,0x20, +0x74,0x68,0x65,0x20,0x73,0x74,0x61,0x74,0x65,0x6C,0x79,0x20,0x63,0x6F,0x6C,0x75, +0x6D,0x6E,0x73,0x2C,0x20,0x6D,0x61,0x6A,0x65,0x73,0x74,0x69,0x63,0x20,0x73,0x74, +0x69,0x6C,0x6C,0x20,0x69,0x6E,0x0A,0x74,0x68,0x65,0x69,0x72,0x20,0x72,0x75,0x69, +0x6E,0x2D,0x2D,0x75,0x6E,0x64,0x65,0x72,0x20,0x66,0x6F,0x6F,0x74,0x20,0x74,0x68, +0x65,0x20,0x64,0x72,0x65,0x61,0x6D,0x69,0x6E,0x67,0x20,0x63,0x69,0x74,0x79,0x2D, +0x2D,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x64,0x69,0x73,0x74,0x61,0x6E,0x63,0x65, +0x20,0x74,0x68,0x65,0x20,0x73,0x69,0x6C,0x76,0x65,0x72,0x20,0x73,0x65,0x61,0x0A, +0x2D,0x2D,0x6E,0x6F,0x74,0x20,0x6F,0x6E,0x20,0x74,0x68,0x65,0x20,0x62,0x72,0x6F, +0x61,0x64,0x20,0x65,0x61,0x72,0x74,0x68,0x20,0x69,0x73,0x20,0x74,0x68,0x65,0x72, +0x65,0x20,0x61,0x6E,0x20,0x6F,0x74,0x68,0x65,0x72,0x20,0x70,0x69,0x63,0x74,0x75, +0x72,0x65,0x20,0x68,0x61,0x6C,0x66,0x20,0x73,0x6F,0x20,0x62,0x65,0x61,0x75,0x74, +0x69,0x66,0x75,0x6C,0x21,0x0A,0x0A,0x41,0x73,0x20,0x77,0x65,0x20,0x74,0x75,0x72, +0x6E,0x65,0x64,0x20,0x61,0x6E,0x64,0x20,0x6D,0x6F,0x76,0x65,0x64,0x20,0x61,0x67, +0x61,0x69,0x6E,0x20,0x74,0x68,0x72,0x6F,0x75,0x67,0x68,0x20,0x74,0x68,0x65,0x20, +0x74,0x65,0x6D,0x70,0x6C,0x65,0x2C,0x20,0x49,0x20,0x77,0x69,0x73,0x68,0x65,0x64, +0x20,0x74,0x68,0x61,0x74,0x20,0x74,0x68,0x65,0x0A,0x69,0x6C,0x6C,0x75,0x73,0x74, +0x72,0x69,0x6F,0x75,0x73,0x20,0x6D,0x65,0x6E,0x20,0x77,0x68,0x6F,0x20,0x68,0x61, +0x64,0x20,0x73,0x61,0x74,0x20,0x69,0x6E,0x20,0x69,0x74,0x20,0x69,0x6E,0x20,0x74, +0x68,0x65,0x20,0x72,0x65,0x6D,0x6F,0x74,0x65,0x20,0x61,0x67,0x65,0x73,0x20,0x63, +0x6F,0x75,0x6C,0x64,0x20,0x76,0x69,0x73,0x69,0x74,0x20,0x69,0x74,0x20,0x61,0x67, +0x61,0x69,0x6E,0x0A,0x61,0x6E,0x64,0x20,0x72,0x65,0x76,0x65,0x61,0x6C,0x20,0x74, +0x68,0x65,0x6D,0x73,0x65,0x6C,0x76,0x65,0x73,0x20,0x74,0x6F,0x20,0x6F,0x75,0x72, +0x20,0x63,0x75,0x72,0x69,0x6F,0x75,0x73,0x20,0x65,0x79,0x65,0x73,0x2D,0x2D,0x50, +0x6C,0x61,0x74,0x6F,0x2C,0x20,0x41,0x72,0x69,0x73,0x74,0x6F,0x74,0x6C,0x65,0x2C, +0x20,0x44,0x65,0x6D,0x6F,0x73,0x74,0x68,0x65,0x6E,0x65,0x73,0x2C,0x0A,0x53,0x6F, +0x63,0x72,0x61,0x74,0x65,0x73,0x2C,0x20,0x50,0x68,0x6F,0x63,0x69,0x6F,0x6E,0x2C, +0x20,0x50,0x79,0x74,0x68,0x61,0x67,0x6F,0x72,0x61,0x73,0x2C,0x20,0x45,0x75,0x63, +0x6C,0x69,0x64,0x2C,0x20,0x50,0x69,0x6E,0x64,0x61,0x72,0x2C,0x20,0x58,0x65,0x6E, +0x6F,0x70,0x68,0x6F,0x6E,0x2C,0x20,0x48,0x65,0x72,0x6F,0x64,0x6F,0x74,0x75,0x73, +0x2C,0x0A,0x50,0x72,0x61,0x78,0x69,0x74,0x65,0x6C,0x65,0x73,0x20,0x61,0x6E,0x64, +0x20,0x50,0x68,0x69,0x64,0x69,0x61,0x73,0x2C,0x20,0x5A,0x65,0x75,0x78,0x69,0x73, +0x20,0x74,0x68,0x65,0x20,0x70,0x61,0x69,0x6E,0x74,0x65,0x72,0x2E,0x20,0x20,0x57, +0x68,0x61,0x74,0x20,0x61,0x20,0x63,0x6F,0x6E,0x73,0x74,0x65,0x6C,0x6C,0x61,0x74, +0x69,0x6F,0x6E,0x20,0x6F,0x66,0x0A,0x63,0x65,0x6C,0x65,0x62,0x72,0x61,0x74,0x65, +0x64,0x20,0x6E,0x61,0x6D,0x65,0x73,0x21,0x20,0x20,0x42,0x75,0x74,0x20,0x6D,0x6F, +0x72,0x65,0x20,0x74,0x68,0x61,0x6E,0x20,0x61,0x6C,0x6C,0x2C,0x20,0x49,0x20,0x77, +0x69,0x73,0x68,0x65,0x64,0x20,0x74,0x68,0x61,0x74,0x20,0x6F,0x6C,0x64,0x20,0x44, +0x69,0x6F,0x67,0x65,0x6E,0x65,0x73,0x2C,0x20,0x67,0x72,0x6F,0x70,0x69,0x6E,0x67, +0x0A,0x73,0x6F,0x20,0x70,0x61,0x74,0x69,0x65,0x6E,0x74,0x6C,0x79,0x20,0x77,0x69, +0x74,0x68,0x20,0x68,0x69,0x73,0x20,0x6C,0x61,0x6E,0x74,0x65,0x72,0x6E,0x2C,0x20, +0x73,0x65,0x61,0x72,0x63,0x68,0x69,0x6E,0x67,0x20,0x73,0x6F,0x20,0x7A,0x65,0x61, +0x6C,0x6F,0x75,0x73,0x6C,0x79,0x20,0x66,0x6F,0x72,0x20,0x6F,0x6E,0x65,0x20,0x73, +0x6F,0x6C,0x69,0x74,0x61,0x72,0x79,0x0A,0x68,0x6F,0x6E,0x65,0x73,0x74,0x20,0x6D, +0x61,0x6E,0x20,0x69,0x6E,0x20,0x61,0x6C,0x6C,0x20,0x74,0x68,0x65,0x20,0x77,0x6F, +0x72,0x6C,0x64,0x2C,0x20,0x6D,0x69,0x67,0x68,0x74,0x20,0x6D,0x65,0x61,0x6E,0x64, +0x65,0x72,0x20,0x61,0x6C,0x6F,0x6E,0x67,0x20,0x61,0x6E,0x64,0x20,0x73,0x74,0x75, +0x6D,0x62,0x6C,0x65,0x20,0x6F,0x6E,0x20,0x6F,0x75,0x72,0x0A,0x70,0x61,0x72,0x74, +0x79,0x2E,0x20,0x20,0x49,0x20,0x6F,0x75,0x67,0x68,0x74,0x20,0x6E,0x6F,0x74,0x20, +0x74,0x6F,0x20,0x73,0x61,0x79,0x20,0x69,0x74,0x2C,0x20,0x6D,0x61,0x79,0x20,0x62, +0x65,0x2C,0x20,0x62,0x75,0x74,0x20,0x73,0x74,0x69,0x6C,0x6C,0x20,0x49,0x20,0x73, +0x75,0x70,0x70,0x6F,0x73,0x65,0x20,0x68,0x65,0x20,0x77,0x6F,0x75,0x6C,0x64,0x20, +0x68,0x61,0x76,0x65,0x0A,0x70,0x75,0x74,0x20,0x6F,0x75,0x74,0x20,0x68,0x69,0x73, +0x20,0x6C,0x69,0x67,0x68,0x74,0x2E,0x0A,0x0A,0x57,0x65,0x20,0x6C,0x65,0x66,0x74, +0x20,0x74,0x68,0x65,0x20,0x50,0x61,0x72,0x74,0x68,0x65,0x6E,0x6F,0x6E,0x20,0x74, +0x6F,0x20,0x6B,0x65,0x65,0x70,0x20,0x69,0x74,0x73,0x20,0x77,0x61,0x74,0x63,0x68, +0x20,0x6F,0x76,0x65,0x72,0x20,0x6F,0x6C,0x64,0x20,0x41,0x74,0x68,0x65,0x6E,0x73, +0x2C,0x20,0x61,0x73,0x20,0x69,0x74,0x20,0x68,0x61,0x64,0x20,0x6B,0x65,0x70,0x74, +0x0A,0x69,0x74,0x20,0x66,0x6F,0x72,0x20,0x74,0x77,0x65,0x6E,0x74,0x79,0x2D,0x74, +0x68,0x72,0x65,0x65,0x20,0x68,0x75,0x6E,0x64,0x72,0x65,0x64,0x20,0x79,0x65,0x61, +0x72,0x73,0x2C,0x20,0x61,0x6E,0x64,0x20,0x77,0x65,0x6E,0x74,0x20,0x61,0x6E,0x64, +0x20,0x73,0x74,0x6F,0x6F,0x64,0x20,0x6F,0x75,0x74,0x73,0x69,0x64,0x65,0x20,0x74, +0x68,0x65,0x20,0x77,0x61,0x6C,0x6C,0x73,0x0A,0x6F,0x66,0x20,0x74,0x68,0x65,0x20, +0x63,0x69,0x74,0x61,0x64,0x65,0x6C,0x2E,0x20,0x20,0x49,0x6E,0x20,0x74,0x68,0x65, +0x20,0x64,0x69,0x73,0x74,0x61,0x6E,0x63,0x65,0x20,0x77,0x61,0x73,0x20,0x74,0x68, +0x65,0x20,0x61,0x6E,0x63,0x69,0x65,0x6E,0x74,0x2C,0x20,0x62,0x75,0x74,0x20,0x73, +0x74,0x69,0x6C,0x6C,0x20,0x61,0x6C,0x6D,0x6F,0x73,0x74,0x0A,0x70,0x65,0x72,0x66, +0x65,0x63,0x74,0x20,0x54,0x65,0x6D,0x70,0x6C,0x65,0x20,0x6F,0x66,0x20,0x54,0x68, +0x65,0x73,0x65,0x75,0x73,0x2C,0x20,0x61,0x6E,0x64,0x20,0x63,0x6C,0x6F,0x73,0x65, +0x20,0x62,0x79,0x2C,0x20,0x6C,0x6F,0x6F,0x6B,0x69,0x6E,0x67,0x20,0x74,0x6F,0x20, +0x74,0x68,0x65,0x20,0x77,0x65,0x73,0x74,0x2C,0x20,0x77,0x61,0x73,0x20,0x74,0x68, +0x65,0x0A,0x42,0x65,0x6D,0x61,0x2C,0x20,0x66,0x72,0x6F,0x6D,0x20,0x77,0x68,0x65, +0x6E,0x63,0x65,0x20,0x44,0x65,0x6D,0x6F,0x73,0x74,0x68,0x65,0x6E,0x65,0x73,0x20, +0x74,0x68,0x75,0x6E,0x64,0x65,0x72,0x65,0x64,0x20,0x68,0x69,0x73,0x20,0x70,0x68, +0x69,0x6C,0x69,0x70,0x70,0x69,0x63,0x73,0x20,0x61,0x6E,0x64,0x20,0x66,0x69,0x72, +0x65,0x64,0x20,0x74,0x68,0x65,0x0A,0x77,0x61,0x76,0x65,0x72,0x69,0x6E,0x67,0x20, +0x70,0x61,0x74,0x72,0x69,0x6F,0x74,0x69,0x73,0x6D,0x20,0x6F,0x66,0x20,0x68,0x69, +0x73,0x20,0x63,0x6F,0x75,0x6E,0x74,0x72,0x79,0x6D,0x65,0x6E,0x2E,0x20,0x20,0x54, +0x6F,0x20,0x74,0x68,0x65,0x20,0x72,0x69,0x67,0x68,0x74,0x20,0x77,0x61,0x73,0x20, +0x4D,0x61,0x72,0x73,0x20,0x48,0x69,0x6C,0x6C,0x2C,0x20,0x77,0x68,0x65,0x72,0x65, +0x0A,0x74,0x68,0x65,0x20,0x41,0x72,0x65,0x6F,0x70,0x61,0x67,0x75,0x73,0x20,0x73, +0x61,0x74,0x20,0x69,0x6E,0x20,0x61,0x6E,0x63,0x69,0x65,0x6E,0x74,0x20,0x74,0x69, +0x6D,0x65,0x73,0x20,0x61,0x6E,0x64,0x20,0x77,0x68,0x65,0x72,0x65,0x20,0x53,0x74, +0x2E,0x20,0x50,0x61,0x75,0x6C,0x20,0x64,0x65,0x66,0x69,0x6E,0x65,0x64,0x20,0x68, +0x69,0x73,0x0A,0x70,0x6F,0x73,0x69,0x74,0x69,0x6F,0x6E,0x2C,0x20,0x61,0x6E,0x64, +0x20,0x62,0x65,0x6C,0x6F,0x77,0x20,0x77,0x61,0x73,0x20,0x74,0x68,0x65,0x20,0x6D, +0x61,0x72,0x6B,0x65,0x74,0x2D,0x70,0x6C,0x61,0x63,0x65,0x20,0x77,0x68,0x65,0x72, +0x65,0x20,0x68,0x65,0x20,0x22,0x64,0x69,0x73,0x70,0x75,0x74,0x65,0x64,0x20,0x64, +0x61,0x69,0x6C,0x79,0x22,0x20,0x77,0x69,0x74,0x68,0x0A,0x74,0x68,0x65,0x20,0x67, +0x6F,0x73,0x73,0x69,0x70,0x2D,0x6C,0x6F,0x76,0x69,0x6E,0x67,0x20,0x41,0x74,0x68, +0x65,0x6E,0x69,0x61,0x6E,0x73,0x2E,0x20,0x20,0x57,0x65,0x20,0x63,0x6C,0x69,0x6D, +0x62,0x65,0x64,0x20,0x74,0x68,0x65,0x20,0x73,0x74,0x6F,0x6E,0x65,0x20,0x73,0x74, +0x65,0x70,0x73,0x20,0x53,0x74,0x2E,0x20,0x50,0x61,0x75,0x6C,0x0A,0x61,0x73,0x63, +0x65,0x6E,0x64,0x65,0x64,0x2C,0x20,0x61,0x6E,0x64,0x20,0x73,0x74,0x6F,0x6F,0x64, +0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x73,0x71,0x75,0x61,0x72,0x65,0x2D,0x63, +0x75,0x74,0x20,0x70,0x6C,0x61,0x63,0x65,0x20,0x68,0x65,0x20,0x73,0x74,0x6F,0x6F, +0x64,0x20,0x69,0x6E,0x2C,0x20,0x61,0x6E,0x64,0x20,0x74,0x72,0x69,0x65,0x64,0x20, +0x74,0x6F,0x0A,0x72,0x65,0x63,0x6F,0x6C,0x6C,0x65,0x63,0x74,0x20,0x74,0x68,0x65, +0x20,0x42,0x69,0x62,0x6C,0x65,0x20,0x61,0x63,0x63,0x6F,0x75,0x6E,0x74,0x20,0x6F, +0x66,0x20,0x74,0x68,0x65,0x20,0x6D,0x61,0x74,0x74,0x65,0x72,0x2D,0x2D,0x62,0x75, +0x74,0x20,0x66,0x6F,0x72,0x20,0x63,0x65,0x72,0x74,0x61,0x69,0x6E,0x20,0x72,0x65, +0x61,0x73,0x6F,0x6E,0x73,0x2C,0x20,0x49,0x0A,0x63,0x6F,0x75,0x6C,0x64,0x20,0x6E, +0x6F,0x74,0x20,0x72,0x65,0x63,0x61,0x6C,0x6C,0x20,0x74,0x68,0x65,0x20,0x77,0x6F, +0x72,0x64,0x73,0x2E,0x20,0x20,0x49,0x20,0x68,0x61,0x76,0x65,0x20,0x66,0x6F,0x75, +0x6E,0x64,0x20,0x74,0x68,0x65,0x6D,0x20,0x73,0x69,0x6E,0x63,0x65,0x3A,0x0A,0x0A, +0x20,0x20,0x20,0x20,0x20,0x22,0x4E,0x6F,0x77,0x20,0x77,0x68,0x69,0x6C,0x65,0x20, +0x50,0x61,0x75,0x6C,0x20,0x77,0x61,0x69,0x74,0x65,0x64,0x20,0x66,0x6F,0x72,0x20, +0x74,0x68,0x65,0x6D,0x20,0x61,0x74,0x20,0x41,0x74,0x68,0x65,0x6E,0x73,0x2C,0x20, +0x68,0x69,0x73,0x20,0x73,0x70,0x69,0x72,0x69,0x74,0x20,0x77,0x61,0x73,0x20,0x73, +0x74,0x69,0x72,0x72,0x65,0x64,0x20,0x69,0x6E,0x0A,0x20,0x20,0x20,0x20,0x20,0x68, +0x69,0x6D,0x2C,0x20,0x77,0x68,0x65,0x6E,0x20,0x68,0x65,0x20,0x73,0x61,0x77,0x20, +0x74,0x68,0x65,0x20,0x63,0x69,0x74,0x79,0x20,0x77,0x68,0x6F,0x6C,0x6C,0x79,0x20, +0x67,0x69,0x76,0x65,0x6E,0x20,0x75,0x70,0x20,0x74,0x6F,0x20,0x69,0x64,0x6F,0x6C, +0x61,0x74,0x72,0x79,0x2E,0x20,0x20,0x54,0x68,0x65,0x72,0x65,0x66,0x6F,0x72,0x65, +0x0A,0x20,0x20,0x20,0x20,0x20,0x64,0x69,0x73,0x70,0x75,0x74,0x65,0x64,0x20,0x68, +0x65,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x73,0x79,0x6E,0x61,0x67,0x6F,0x67, +0x75,0x65,0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x68,0x65,0x20,0x4A,0x65,0x77,0x73, +0x2C,0x20,0x61,0x6E,0x64,0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x68,0x65,0x20,0x64, +0x65,0x76,0x6F,0x75,0x74,0x0A,0x20,0x20,0x20,0x20,0x20,0x70,0x65,0x72,0x73,0x6F, +0x6E,0x73,0x2C,0x20,0x61,0x6E,0x64,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x6D, +0x61,0x72,0x6B,0x65,0x74,0x20,0x64,0x61,0x69,0x6C,0x79,0x20,0x77,0x69,0x74,0x68, +0x20,0x74,0x68,0x65,0x6D,0x20,0x74,0x68,0x61,0x74,0x20,0x6D,0x65,0x74,0x20,0x77, +0x69,0x74,0x68,0x20,0x68,0x69,0x6D,0x2E,0x0A,0x20,0x20,0x20,0x20,0x20,0x20,0x20, +0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20, +0x20,0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20, +0x2A,0x20,0x2A,0x0A,0x20,0x20,0x20,0x20,0x20,0x22,0x41,0x6E,0x64,0x20,0x74,0x68, +0x65,0x79,0x20,0x74,0x6F,0x6F,0x6B,0x20,0x68,0x69,0x6D,0x20,0x61,0x6E,0x64,0x20, +0x62,0x72,0x6F,0x75,0x67,0x68,0x74,0x20,0x68,0x69,0x6D,0x20,0x75,0x6E,0x74,0x6F, +0x20,0x41,0x72,0x65,0x6F,0x70,0x61,0x67,0x75,0x73,0x2C,0x20,0x73,0x61,0x79,0x69, +0x6E,0x67,0x2C,0x20,0x4D,0x61,0x79,0x20,0x77,0x65,0x0A,0x20,0x20,0x20,0x20,0x20, +0x6B,0x6E,0x6F,0x77,0x20,0x77,0x68,0x61,0x74,0x20,0x74,0x68,0x69,0x73,0x20,0x6E, +0x65,0x77,0x20,0x64,0x6F,0x63,0x74,0x72,0x69,0x6E,0x65,0x20,0x77,0x68,0x65,0x72, +0x65,0x6F,0x66,0x20,0x74,0x68,0x6F,0x75,0x20,0x73,0x70,0x65,0x61,0x6B,0x65,0x73, +0x74,0x20,0x69,0x73,0x3F,0x0A,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20, +0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x20,0x2A, +0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20,0x2A,0x20,0x2A, +0x0A,0x20,0x20,0x20,0x20,0x20,0x22,0x54,0x68,0x65,0x6E,0x20,0x50,0x61,0x75,0x6C, +0x20,0x73,0x74,0x6F,0x6F,0x64,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x6D,0x69, +0x64,0x73,0x74,0x20,0x6F,0x66,0x20,0x4D,0x61,0x72,0x73,0x20,0x68,0x69,0x6C,0x6C, +0x2C,0x20,0x61,0x6E,0x64,0x20,0x73,0x61,0x69,0x64,0x2C,0x20,0x59,0x65,0x20,0x6D, +0x65,0x6E,0x20,0x6F,0x66,0x0A,0x20,0x20,0x20,0x20,0x20,0x41,0x74,0x68,0x65,0x6E, +0x73,0x2C,0x20,0x49,0x20,0x70,0x65,0x72,0x63,0x65,0x69,0x76,0x65,0x20,0x74,0x68, +0x61,0x74,0x20,0x69,0x6E,0x20,0x61,0x6C,0x6C,0x20,0x74,0x68,0x69,0x6E,0x67,0x73, +0x20,0x79,0x65,0x20,0x61,0x72,0x65,0x20,0x74,0x6F,0x6F,0x20,0x73,0x75,0x70,0x65, +0x72,0x73,0x74,0x69,0x74,0x69,0x6F,0x75,0x73,0x3B,0x20,0x46,0x6F,0x72,0x0A,0x20, +0x20,0x20,0x20,0x20,0x61,0x73,0x20,0x49,0x20,0x70,0x61,0x73,0x73,0x65,0x64,0x20, +0x62,0x79,0x20,0x61,0x6E,0x64,0x20,0x62,0x65,0x68,0x65,0x6C,0x64,0x20,0x79,0x6F, +0x75,0x72,0x20,0x64,0x65,0x76,0x6F,0x74,0x69,0x6F,0x6E,0x73,0x2C,0x20,0x49,0x20, +0x66,0x6F,0x75,0x6E,0x64,0x20,0x61,0x6E,0x20,0x61,0x6C,0x74,0x61,0x72,0x20,0x77, +0x69,0x74,0x68,0x20,0x74,0x68,0x69,0x73,0x0A,0x20,0x20,0x20,0x20,0x20,0x69,0x6E, +0x73,0x63,0x72,0x69,0x70,0x74,0x69,0x6F,0x6E,0x3A,0x20,0x54,0x6F,0x20,0x54,0x48, +0x45,0x20,0x55,0x4E,0x4B,0x4E,0x4F,0x57,0x4E,0x20,0x47,0x4F,0x44,0x2E,0x20,0x20, +0x57,0x68,0x6F,0x6D,0x2C,0x20,0x74,0x68,0x65,0x72,0x65,0x66,0x6F,0x72,0x65,0x2C, +0x20,0x79,0x65,0x20,0x69,0x67,0x6E,0x6F,0x72,0x61,0x6E,0x74,0x6C,0x79,0x0A,0x20, +0x20,0x20,0x20,0x20,0x77,0x6F,0x72,0x73,0x68,0x69,0x70,0x2C,0x20,0x68,0x69,0x6D, +0x20,0x64,0x65,0x63,0x6C,0x61,0x72,0x65,0x20,0x49,0x20,0x75,0x6E,0x74,0x6F,0x20, +0x79,0x6F,0x75,0x2E,0x22,0x2D,0x2D,0x41,0x63,0x74,0x73,0x2C,0x20,0x63,0x68,0x2E, +0x20,0x78,0x76,0x69,0x69,0x2E,0x22,0x0A,0x0A,0x49,0x74,0x20,0x6F,0x63,0x63,0x75, +0x72,0x72,0x65,0x64,0x20,0x74,0x6F,0x20,0x75,0x73,0x2C,0x20,0x61,0x66,0x74,0x65, +0x72,0x20,0x61,0x20,0x77,0x68,0x69,0x6C,0x65,0x2C,0x20,0x74,0x68,0x61,0x74,0x20, +0x69,0x66,0x20,0x77,0x65,0x20,0x77,0x61,0x6E,0x74,0x65,0x64,0x20,0x74,0x6F,0x20, +0x67,0x65,0x74,0x20,0x68,0x6F,0x6D,0x65,0x20,0x62,0x65,0x66,0x6F,0x72,0x65,0x0A, +0x64,0x61,0x79,0x6C,0x69,0x67,0x68,0x74,0x20,0x62,0x65,0x74,0x72,0x61,0x79,0x65, +0x64,0x20,0x75,0x73,0x2C,0x20,0x77,0x65,0x20,0x68,0x61,0x64,0x20,0x62,0x65,0x74, +0x74,0x65,0x72,0x20,0x62,0x65,0x20,0x6D,0x6F,0x76,0x69,0x6E,0x67,0x2E,0x20,0x20, +0x53,0x6F,0x20,0x77,0x65,0x20,0x68,0x75,0x72,0x72,0x69,0x65,0x64,0x20,0x61,0x77, +0x61,0x79,0x2E,0x20,0x20,0x57,0x68,0x65,0x6E,0x0A,0x66,0x61,0x72,0x20,0x6F,0x6E, +0x20,0x6F,0x75,0x72,0x20,0x72,0x6F,0x61,0x64,0x2C,0x20,0x77,0x65,0x20,0x68,0x61, +0x64,0x20,0x61,0x20,0x70,0x61,0x72,0x74,0x69,0x6E,0x67,0x20,0x76,0x69,0x65,0x77, +0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x50,0x61,0x72,0x74,0x68,0x65,0x6E,0x6F, +0x6E,0x2C,0x20,0x77,0x69,0x74,0x68,0x20,0x74,0x68,0x65,0x0A,0x6D,0x6F,0x6F,0x6E, +0x6C,0x69,0x67,0x68,0x74,0x20,0x73,0x74,0x72,0x65,0x61,0x6D,0x69,0x6E,0x67,0x20, +0x74,0x68,0x72,0x6F,0x75,0x67,0x68,0x20,0x69,0x74,0x73,0x20,0x6F,0x70,0x65,0x6E, +0x20,0x63,0x6F,0x6C,0x6F,0x6E,0x6E,0x61,0x64,0x65,0x73,0x20,0x61,0x6E,0x64,0x20, +0x74,0x6F,0x75,0x63,0x68,0x69,0x6E,0x67,0x20,0x69,0x74,0x73,0x20,0x63,0x61,0x70, +0x69,0x74,0x61,0x6C,0x73,0x0A,0x77,0x69,0x74,0x68,0x20,0x73,0x69,0x6C,0x76,0x65, +0x72,0x2E,0x20,0x20,0x41,0x73,0x20,0x69,0x74,0x20,0x6C,0x6F,0x6F,0x6B,0x65,0x64, +0x20,0x74,0x68,0x65,0x6E,0x2C,0x20,0x73,0x6F,0x6C,0x65,0x6D,0x6E,0x2C,0x20,0x67, +0x72,0x61,0x6E,0x64,0x2C,0x20,0x61,0x6E,0x64,0x20,0x62,0x65,0x61,0x75,0x74,0x69, +0x66,0x75,0x6C,0x20,0x69,0x74,0x20,0x77,0x69,0x6C,0x6C,0x0A,0x61,0x6C,0x77,0x61, +0x79,0x73,0x20,0x72,0x65,0x6D,0x61,0x69,0x6E,0x20,0x69,0x6E,0x20,0x6F,0x75,0x72, +0x20,0x6D,0x65,0x6D,0x6F,0x72,0x69,0x65,0x73,0x2E,0x0A,0x0A,0x41,0x73,0x20,0x77, +0x65,0x20,0x6D,0x61,0x72,0x63,0x68,0x65,0x64,0x20,0x61,0x6C,0x6F,0x6E,0x67,0x2C, +0x20,0x77,0x65,0x20,0x62,0x65,0x67,0x61,0x6E,0x20,0x74,0x6F,0x20,0x67,0x65,0x74, +0x20,0x6F,0x76,0x65,0x72,0x20,0x6F,0x75,0x72,0x20,0x66,0x65,0x61,0x72,0x73,0x2C, +0x20,0x61,0x6E,0x64,0x20,0x63,0x65,0x61,0x73,0x65,0x64,0x20,0x74,0x6F,0x20,0x63, +0x61,0x72,0x65,0x0A,0x6D,0x75,0x63,0x68,0x20,0x61,0x62,0x6F,0x75,0x74,0x20,0x71, +0x75,0x61,0x72,0x61,0x6E,0x74,0x69,0x6E,0x65,0x20,0x73,0x63,0x6F,0x75,0x74,0x73, +0x20,0x6F,0x72,0x20,0x61,0x6E,0x79,0x20,0x62,0x6F,0x64,0x79,0x20,0x65,0x6C,0x73, +0x65,0x2E,0x20,0x20,0x57,0x65,0x20,0x67,0x72,0x65,0x77,0x20,0x62,0x6F,0x6C,0x64, +0x20,0x61,0x6E,0x64,0x0A,0x72,0x65,0x63,0x6B,0x6C,0x65,0x73,0x73,0x3B,0x20,0x61, +0x6E,0x64,0x20,0x6F,0x6E,0x63,0x65,0x2C,0x20,0x69,0x6E,0x20,0x61,0x20,0x73,0x75, +0x64,0x64,0x65,0x6E,0x20,0x62,0x75,0x72,0x73,0x74,0x20,0x6F,0x66,0x20,0x63,0x6F, +0x75,0x72,0x61,0x67,0x65,0x2C,0x20,0x49,0x20,0x65,0x76,0x65,0x6E,0x20,0x74,0x68, +0x72,0x65,0x77,0x20,0x61,0x20,0x73,0x74,0x6F,0x6E,0x65,0x20,0x61,0x74,0x0A,0x61, +0x20,0x64,0x6F,0x67,0x2E,0x20,0x20,0x49,0x74,0x20,0x77,0x61,0x73,0x20,0x61,0x20, +0x70,0x6C,0x65,0x61,0x73,0x61,0x6E,0x74,0x20,0x72,0x65,0x66,0x6C,0x65,0x63,0x74, +0x69,0x6F,0x6E,0x2C,0x20,0x74,0x68,0x6F,0x75,0x67,0x68,0x2C,0x20,0x74,0x68,0x61, +0x74,0x20,0x49,0x20,0x64,0x69,0x64,0x20,0x6E,0x6F,0x74,0x20,0x68,0x69,0x74,0x20, +0x68,0x69,0x6D,0x2C,0x0A,0x62,0x65,0x63,0x61,0x75,0x73,0x65,0x20,0x68,0x69,0x73, +0x20,0x6D,0x61,0x73,0x74,0x65,0x72,0x20,0x6D,0x69,0x67,0x68,0x74,0x20,0x6A,0x75, +0x73,0x74,0x20,0x70,0x6F,0x73,0x73,0x69,0x62,0x6C,0x79,0x20,0x68,0x61,0x76,0x65, +0x20,0x62,0x65,0x65,0x6E,0x20,0x61,0x20,0x70,0x6F,0x6C,0x69,0x63,0x65,0x6D,0x61, +0x6E,0x2E,0x20,0x20,0x49,0x6E,0x73,0x70,0x69,0x72,0x65,0x64,0x0A,0x62,0x79,0x20, +0x74,0x68,0x69,0x73,0x20,0x68,0x61,0x70,0x70,0x79,0x20,0x66,0x61,0x69,0x6C,0x75, +0x72,0x65,0x2C,0x20,0x6D,0x79,0x20,0x76,0x61,0x6C,0x6F,0x72,0x20,0x62,0x65,0x63, +0x61,0x6D,0x65,0x20,0x75,0x74,0x74,0x65,0x72,0x6C,0x79,0x20,0x75,0x6E,0x63,0x6F, +0x6E,0x74,0x72,0x6F,0x6C,0x6C,0x61,0x62,0x6C,0x65,0x2C,0x20,0x61,0x6E,0x64,0x20, +0x61,0x74,0x0A,0x69,0x6E,0x74,0x65,0x72,0x76,0x61,0x6C,0x73,0x20,0x49,0x20,0x61, +0x62,0x73,0x6F,0x6C,0x75,0x74,0x65,0x6C,0x79,0x20,0x77,0x68,0x69,0x73,0x74,0x6C, +0x65,0x64,0x2C,0x20,0x74,0x68,0x6F,0x75,0x67,0x68,0x20,0x6F,0x6E,0x20,0x61,0x20, +0x6D,0x6F,0x64,0x65,0x72,0x61,0x74,0x65,0x20,0x6B,0x65,0x79,0x2E,0x20,0x20,0x42, +0x75,0x74,0x20,0x62,0x6F,0x6C,0x64,0x6E,0x65,0x73,0x73,0x0A,0x62,0x72,0x65,0x65, +0x64,0x73,0x20,0x62,0x6F,0x6C,0x64,0x6E,0x65,0x73,0x73,0x2C,0x20,0x61,0x6E,0x64, +0x20,0x73,0x68,0x6F,0x72,0x74,0x6C,0x79,0x20,0x49,0x20,0x70,0x6C,0x75,0x6E,0x67, +0x65,0x64,0x20,0x69,0x6E,0x74,0x6F,0x20,0x61,0x20,0x56,0x69,0x6E,0x65,0x79,0x61, +0x72,0x64,0x2C,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x66,0x75,0x6C,0x6C,0x20, +0x6C,0x69,0x67,0x68,0x74,0x0A,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x6D,0x6F,0x6F, +0x6E,0x2C,0x20,0x61,0x6E,0x64,0x20,0x63,0x61,0x70,0x74,0x75,0x72,0x65,0x64,0x20, +0x61,0x20,0x67,0x61,0x6C,0x6C,0x6F,0x6E,0x20,0x6F,0x66,0x20,0x73,0x75,0x70,0x65, +0x72,0x62,0x20,0x67,0x72,0x61,0x70,0x65,0x73,0x2C,0x20,0x6E,0x6F,0x74,0x20,0x65, +0x76,0x65,0x6E,0x20,0x6D,0x69,0x6E,0x64,0x69,0x6E,0x67,0x20,0x74,0x68,0x65,0x0A, +0x70,0x72,0x65,0x73,0x65,0x6E,0x63,0x65,0x20,0x6F,0x66,0x20,0x61,0x20,0x70,0x65, +0x61,0x73,0x61,0x6E,0x74,0x20,0x77,0x68,0x6F,0x20,0x72,0x6F,0x64,0x65,0x20,0x62, +0x79,0x20,0x6F,0x6E,0x20,0x61,0x20,0x6D,0x75,0x6C,0x65,0x2E,0x20,0x20,0x44,0x65, +0x6E,0x6E,0x79,0x20,0x61,0x6E,0x64,0x20,0x42,0x69,0x72,0x63,0x68,0x20,0x66,0x6F, +0x6C,0x6C,0x6F,0x77,0x65,0x64,0x20,0x6D,0x79,0x0A,0x65,0x78,0x61,0x6D,0x70,0x6C, +0x65,0x2E,0x0A,0x0A,0x4E,0x6F,0x77,0x20,0x49,0x20,0x68,0x61,0x64,0x20,0x67,0x72, +0x61,0x70,0x65,0x73,0x20,0x65,0x6E,0x6F,0x75,0x67,0x68,0x20,0x66,0x6F,0x72,0x20, +0x61,0x20,0x64,0x6F,0x7A,0x65,0x6E,0x2C,0x20,0x62,0x75,0x74,0x20,0x74,0x68,0x65, +0x6E,0x20,0x4A,0x61,0x63,0x6B,0x73,0x6F,0x6E,0x20,0x77,0x61,0x73,0x20,0x61,0x6C, +0x6C,0x20,0x73,0x77,0x6F,0x6C,0x6C,0x65,0x6E,0x20,0x75,0x70,0x0A,0x77,0x69,0x74, +0x68,0x20,0x63,0x6F,0x75,0x72,0x61,0x67,0x65,0x2C,0x20,0x74,0x6F,0x6F,0x2C,0x20, +0x61,0x6E,0x64,0x20,0x68,0x65,0x20,0x77,0x61,0x73,0x20,0x6F,0x62,0x6C,0x69,0x67, +0x65,0x64,0x20,0x74,0x6F,0x20,0x65,0x6E,0x74,0x65,0x72,0x20,0x61,0x20,0x76,0x69, +0x6E,0x65,0x79,0x61,0x72,0x64,0x20,0x70,0x72,0x65,0x73,0x65,0x6E,0x74,0x6C,0x79, +0x2E,0x20,0x20,0x54,0x68,0x65,0x0A,0x66,0x69,0x72,0x73,0x74,0x20,0x62,0x75,0x6E, +0x63,0x68,0x20,0x68,0x65,0x20,0x73,0x65,0x69,0x7A,0x65,0x64,0x20,0x62,0x72,0x6F, +0x75,0x67,0x68,0x74,0x20,0x74,0x72,0x6F,0x75,0x62,0x6C,0x65,0x2E,0x20,0x20,0x41, +0x20,0x66,0x72,0x6F,0x77,0x73,0x79,0x2C,0x20,0x62,0x65,0x61,0x72,0x64,0x65,0x64, +0x20,0x62,0x72,0x69,0x67,0x61,0x6E,0x64,0x20,0x73,0x70,0x72,0x61,0x6E,0x67,0x0A, +0x69,0x6E,0x74,0x6F,0x20,0x74,0x68,0x65,0x20,0x72,0x6F,0x61,0x64,0x20,0x77,0x69, +0x74,0x68,0x20,0x61,0x20,0x73,0x68,0x6F,0x75,0x74,0x2C,0x20,0x61,0x6E,0x64,0x20, +0x66,0x6C,0x6F,0x75,0x72,0x69,0x73,0x68,0x65,0x64,0x20,0x61,0x20,0x6D,0x75,0x73, +0x6B,0x65,0x74,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x20,0x6C,0x69,0x67,0x68,0x74, +0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x0A,0x6D,0x6F,0x6F,0x6E,0x21,0x20,0x20,0x57, +0x65,0x20,0x73,0x69,0x64,0x6C,0x65,0x64,0x20,0x74,0x6F,0x77,0x61,0x72,0x64,0x20, +0x74,0x68,0x65,0x20,0x50,0x69,0x72,0x61,0x65,0x75,0x73,0x2D,0x2D,0x6E,0x6F,0x74, +0x20,0x72,0x75,0x6E,0x6E,0x69,0x6E,0x67,0x20,0x79,0x6F,0x75,0x20,0x75,0x6E,0x64, +0x65,0x72,0x73,0x74,0x61,0x6E,0x64,0x2C,0x20,0x62,0x75,0x74,0x20,0x6F,0x6E,0x6C, +0x79,0x0A,0x61,0x64,0x76,0x61,0x6E,0x63,0x69,0x6E,0x67,0x20,0x77,0x69,0x74,0x68, +0x20,0x63,0x65,0x6C,0x65,0x72,0x69,0x74,0x79,0x2E,0x20,0x20,0x54,0x68,0x65,0x20, +0x62,0x72,0x69,0x67,0x61,0x6E,0x64,0x20,0x73,0x68,0x6F,0x75,0x74,0x65,0x64,0x20, +0x61,0x67,0x61,0x69,0x6E,0x2C,0x20,0x62,0x75,0x74,0x20,0x73,0x74,0x69,0x6C,0x6C, +0x20,0x77,0x65,0x0A,0x61,0x64,0x76,0x61,0x6E,0x63,0x65,0x64,0x2E,0x20,0x20,0x49, +0x74,0x20,0x77,0x61,0x73,0x20,0x67,0x65,0x74,0x74,0x69,0x6E,0x67,0x20,0x6C,0x61, +0x74,0x65,0x2C,0x20,0x61,0x6E,0x64,0x20,0x77,0x65,0x20,0x68,0x61,0x64,0x20,0x6E, +0x6F,0x20,0x74,0x69,0x6D,0x65,0x20,0x74,0x6F,0x20,0x66,0x6F,0x6F,0x6C,0x20,0x61, +0x77,0x61,0x79,0x20,0x6F,0x6E,0x20,0x65,0x76,0x65,0x72,0x79,0x0A,0x61,0x73,0x73, +0x20,0x74,0x68,0x61,0x74,0x20,0x77,0x61,0x6E,0x74,0x65,0x64,0x20,0x74,0x6F,0x20, +0x64,0x72,0x69,0x76,0x65,0x6C,0x20,0x47,0x72,0x65,0x65,0x6B,0x20,0x70,0x6C,0x61, +0x74,0x69,0x74,0x75,0x64,0x65,0x73,0x20,0x74,0x6F,0x20,0x75,0x73,0x2E,0x20,0x20, +0x57,0x65,0x20,0x77,0x6F,0x75,0x6C,0x64,0x20,0x6A,0x75,0x73,0x74,0x20,0x61,0x73, +0x20,0x73,0x6F,0x6F,0x6E,0x0A,0x68,0x61,0x76,0x65,0x20,0x74,0x61,0x6C,0x6B,0x65, +0x64,0x20,0x77,0x69,0x74,0x68,0x20,0x68,0x69,0x6D,0x20,0x61,0x73,0x20,0x6E,0x6F, +0x74,0x20,0x69,0x66,0x20,0x77,0x65,0x20,0x68,0x61,0x64,0x20,0x6E,0x6F,0x74,0x20, +0x62,0x65,0x65,0x6E,0x20,0x69,0x6E,0x20,0x61,0x20,0x68,0x75,0x72,0x72,0x79,0x2E, +0x20,0x20,0x50,0x72,0x65,0x73,0x65,0x6E,0x74,0x6C,0x79,0x0A,0x44,0x65,0x6E,0x6E, +0x79,0x20,0x73,0x61,0x69,0x64,0x2C,0x20,0x22,0x54,0x68,0x6F,0x73,0x65,0x20,0x66, +0x65,0x6C,0x6C,0x6F,0x77,0x73,0x20,0x61,0x72,0x65,0x20,0x66,0x6F,0x6C,0x6C,0x6F, +0x77,0x69,0x6E,0x67,0x20,0x75,0x73,0x21,0x22,0x0A,0x0A,0x57,0x65,0x20,0x74,0x75, +0x72,0x6E,0x65,0x64,0x2C,0x20,0x61,0x6E,0x64,0x2C,0x20,0x73,0x75,0x72,0x65,0x20, +0x65,0x6E,0x6F,0x75,0x67,0x68,0x2C,0x20,0x74,0x68,0x65,0x72,0x65,0x20,0x74,0x68, +0x65,0x79,0x20,0x77,0x65,0x72,0x65,0x2D,0x2D,0x74,0x68,0x72,0x65,0x65,0x20,0x66, +0x61,0x6E,0x74,0x61,0x73,0x74,0x69,0x63,0x20,0x70,0x69,0x72,0x61,0x74,0x65,0x73, +0x0A,0x61,0x72,0x6D,0x65,0x64,0x20,0x77,0x69,0x74,0x68,0x20,0x67,0x75,0x6E,0x73, +0x2E,0x20,0x20,0x57,0x65,0x20,0x73,0x6C,0x61,0x63,0x6B,0x65,0x6E,0x65,0x64,0x20, +0x6F,0x75,0x72,0x20,0x70,0x61,0x63,0x65,0x20,0x74,0x6F,0x20,0x6C,0x65,0x74,0x20, +0x74,0x68,0x65,0x6D,0x20,0x63,0x6F,0x6D,0x65,0x20,0x75,0x70,0x2C,0x20,0x61,0x6E, +0x64,0x20,0x69,0x6E,0x20,0x74,0x68,0x65,0x0A,0x6D,0x65,0x61,0x6E,0x74,0x69,0x6D, +0x65,0x20,0x49,0x20,0x67,0x6F,0x74,0x20,0x6F,0x75,0x74,0x20,0x6D,0x79,0x20,0x63, +0x61,0x72,0x67,0x6F,0x20,0x6F,0x66,0x20,0x67,0x72,0x61,0x70,0x65,0x73,0x20,0x61, +0x6E,0x64,0x20,0x64,0x72,0x6F,0x70,0x70,0x65,0x64,0x20,0x74,0x68,0x65,0x6D,0x20, +0x66,0x69,0x72,0x6D,0x6C,0x79,0x20,0x62,0x75,0x74,0x0A,0x72,0x65,0x6C,0x75,0x63, +0x74,0x61,0x6E,0x74,0x6C,0x79,0x20,0x69,0x6E,0x74,0x6F,0x20,0x74,0x68,0x65,0x20, +0x73,0x68,0x61,0x64,0x6F,0x77,0x73,0x20,0x62,0x79,0x20,0x74,0x68,0x65,0x20,0x77, +0x61,0x79,0x73,0x69,0x64,0x65,0x2E,0x20,0x20,0x42,0x75,0x74,0x20,0x49,0x20,0x77, +0x61,0x73,0x20,0x6E,0x6F,0x74,0x20,0x61,0x66,0x72,0x61,0x69,0x64,0x2E,0x20,0x20, +0x49,0x0A,0x6F,0x6E,0x6C,0x79,0x20,0x66,0x65,0x6C,0x74,0x20,0x74,0x68,0x61,0x74, +0x20,0x69,0x74,0x20,0x77,0x61,0x73,0x20,0x6E,0x6F,0x74,0x20,0x72,0x69,0x67,0x68, +0x74,0x20,0x74,0x6F,0x20,0x73,0x74,0x65,0x61,0x6C,0x20,0x67,0x72,0x61,0x70,0x65, +0x73,0x2E,0x20,0x20,0x41,0x6E,0x64,0x20,0x61,0x6C,0x6C,0x20,0x74,0x68,0x65,0x20, +0x6D,0x6F,0x72,0x65,0x20,0x73,0x6F,0x0A,0x77,0x68,0x65,0x6E,0x20,0x74,0x68,0x65, +0x20,0x6F,0x77,0x6E,0x65,0x72,0x20,0x77,0x61,0x73,0x20,0x61,0x72,0x6F,0x75,0x6E, +0x64,0x2D,0x2D,0x61,0x6E,0x64,0x20,0x6E,0x6F,0x74,0x20,0x6F,0x6E,0x6C,0x79,0x20, +0x61,0x72,0x6F,0x75,0x6E,0x64,0x2C,0x20,0x62,0x75,0x74,0x20,0x77,0x69,0x74,0x68, +0x20,0x68,0x69,0x73,0x20,0x66,0x72,0x69,0x65,0x6E,0x64,0x73,0x0A,0x61,0x72,0x6F, +0x75,0x6E,0x64,0x20,0x61,0x6C,0x73,0x6F,0x2E,0x20,0x20,0x54,0x68,0x65,0x20,0x76, +0x69,0x6C,0x6C,0x61,0x69,0x6E,0x73,0x20,0x63,0x61,0x6D,0x65,0x20,0x75,0x70,0x20, +0x61,0x6E,0x64,0x20,0x73,0x65,0x61,0x72,0x63,0x68,0x65,0x64,0x20,0x61,0x20,0x62, +0x75,0x6E,0x64,0x6C,0x65,0x20,0x44,0x72,0x2E,0x20,0x42,0x69,0x72,0x63,0x68,0x20, +0x68,0x61,0x64,0x20,0x69,0x6E,0x0A,0x68,0x69,0x73,0x20,0x68,0x61,0x6E,0x64,0x2C, +0x20,0x61,0x6E,0x64,0x20,0x73,0x63,0x6F,0x77,0x6C,0x65,0x64,0x20,0x75,0x70,0x6F, +0x6E,0x20,0x68,0x69,0x6D,0x20,0x77,0x68,0x65,0x6E,0x20,0x74,0x68,0x65,0x79,0x20, +0x66,0x6F,0x75,0x6E,0x64,0x20,0x69,0x74,0x20,0x68,0x61,0x64,0x20,0x6E,0x6F,0x74, +0x68,0x69,0x6E,0x67,0x20,0x69,0x6E,0x20,0x69,0x74,0x20,0x62,0x75,0x74,0x0A,0x73, +0x6F,0x6D,0x65,0x20,0x68,0x6F,0x6C,0x79,0x20,0x72,0x6F,0x63,0x6B,0x73,0x20,0x66, +0x72,0x6F,0x6D,0x20,0x4D,0x61,0x72,0x73,0x20,0x48,0x69,0x6C,0x6C,0x2C,0x20,0x61, +0x6E,0x64,0x20,0x74,0x68,0x65,0x73,0x65,0x20,0x77,0x65,0x72,0x65,0x20,0x6E,0x6F, +0x74,0x20,0x63,0x6F,0x6E,0x74,0x72,0x61,0x62,0x61,0x6E,0x64,0x2E,0x20,0x20,0x54, +0x68,0x65,0x79,0x0A,0x65,0x76,0x69,0x64,0x65,0x6E,0x74,0x6C,0x79,0x20,0x73,0x75, +0x73,0x70,0x65,0x63,0x74,0x65,0x64,0x20,0x68,0x69,0x6D,0x20,0x6F,0x66,0x20,0x70, +0x6C,0x61,0x79,0x69,0x6E,0x67,0x20,0x73,0x6F,0x6D,0x65,0x20,0x77,0x72,0x65,0x74, +0x63,0x68,0x65,0x64,0x20,0x66,0x72,0x61,0x75,0x64,0x20,0x75,0x70,0x6F,0x6E,0x20, +0x74,0x68,0x65,0x6D,0x2C,0x20,0x61,0x6E,0x64,0x0A,0x73,0x65,0x65,0x6D,0x65,0x64, +0x20,0x68,0x61,0x6C,0x66,0x20,0x69,0x6E,0x63,0x6C,0x69,0x6E,0x65,0x64,0x20,0x74, +0x6F,0x20,0x73,0x63,0x61,0x6C,0x70,0x20,0x74,0x68,0x65,0x20,0x70,0x61,0x72,0x74, +0x79,0x2E,0x20,0x20,0x42,0x75,0x74,0x20,0x66,0x69,0x6E,0x61,0x6C,0x6C,0x79,0x20, +0x74,0x68,0x65,0x79,0x20,0x64,0x69,0x73,0x6D,0x69,0x73,0x73,0x65,0x64,0x20,0x75, +0x73,0x0A,0x77,0x69,0x74,0x68,0x20,0x61,0x20,0x77,0x61,0x72,0x6E,0x69,0x6E,0x67, +0x2C,0x20,0x63,0x6F,0x75,0x63,0x68,0x65,0x64,0x20,0x69,0x6E,0x20,0x65,0x78,0x63, +0x65,0x6C,0x6C,0x65,0x6E,0x74,0x20,0x47,0x72,0x65,0x65,0x6B,0x2C,0x20,0x49,0x20, +0x73,0x75,0x70,0x70,0x6F,0x73,0x65,0x2C,0x20,0x61,0x6E,0x64,0x20,0x64,0x72,0x6F, +0x70,0x70,0x65,0x64,0x0A,0x74,0x72,0x61,0x6E,0x71,0x75,0x69,0x6C,0x6C,0x79,0x20, +0x69,0x6E,0x20,0x6F,0x75,0x72,0x20,0x77,0x61,0x6B,0x65,0x2E,0x20,0x20,0x57,0x68, +0x65,0x6E,0x20,0x74,0x68,0x65,0x79,0x20,0x68,0x61,0x64,0x20,0x67,0x6F,0x6E,0x65, +0x20,0x74,0x68,0x72,0x65,0x65,0x20,0x68,0x75,0x6E,0x64,0x72,0x65,0x64,0x20,0x79, +0x61,0x72,0x64,0x73,0x20,0x74,0x68,0x65,0x79,0x0A,0x73,0x74,0x6F,0x70,0x70,0x65, +0x64,0x2C,0x20,0x61,0x6E,0x64,0x20,0x77,0x65,0x20,0x77,0x65,0x6E,0x74,0x20,0x6F, +0x6E,0x20,0x72,0x65,0x6A,0x6F,0x69,0x63,0x65,0x64,0x2E,0x20,0x20,0x42,0x75,0x74, +0x20,0x62,0x65,0x68,0x6F,0x6C,0x64,0x2C,0x20,0x61,0x6E,0x6F,0x74,0x68,0x65,0x72, +0x20,0x61,0x72,0x6D,0x65,0x64,0x20,0x72,0x61,0x73,0x63,0x61,0x6C,0x20,0x63,0x61, +0x6D,0x65,0x0A,0x6F,0x75,0x74,0x20,0x6F,0x66,0x20,0x74,0x68,0x65,0x20,0x73,0x68, +0x61,0x64,0x6F,0x77,0x73,0x20,0x61,0x6E,0x64,0x20,0x74,0x6F,0x6F,0x6B,0x20,0x74, +0x68,0x65,0x69,0x72,0x20,0x70,0x6C,0x61,0x63,0x65,0x2C,0x20,0x61,0x6E,0x64,0x20, +0x66,0x6F,0x6C,0x6C,0x6F,0x77,0x65,0x64,0x20,0x75,0x73,0x20,0x74,0x77,0x6F,0x20, +0x68,0x75,0x6E,0x64,0x72,0x65,0x64,0x0A,0x79,0x61,0x72,0x64,0x73,0x2E,0x20,0x20, +0x54,0x68,0x65,0x6E,0x20,0x68,0x65,0x20,0x64,0x65,0x6C,0x69,0x76,0x65,0x72,0x65, +0x64,0x20,0x75,0x73,0x20,0x6F,0x76,0x65,0x72,0x20,0x74,0x6F,0x20,0x61,0x6E,0x6F, +0x74,0x68,0x65,0x72,0x20,0x6D,0x69,0x73,0x63,0x72,0x65,0x61,0x6E,0x74,0x2C,0x20, +0x77,0x68,0x6F,0x20,0x65,0x6D,0x65,0x72,0x67,0x65,0x64,0x20,0x66,0x72,0x6F,0x6D, +0x0A,0x73,0x6F,0x6D,0x65,0x20,0x6D,0x79,0x73,0x74,0x65,0x72,0x69,0x6F,0x75,0x73, +0x20,0x70,0x6C,0x61,0x63,0x65,0x2C,0x20,0x61,0x6E,0x64,0x20,0x68,0x65,0x20,0x69, +0x6E,0x20,0x74,0x75,0x72,0x6E,0x20,0x74,0x6F,0x20,0x61,0x6E,0x6F,0x74,0x68,0x65, +0x72,0x21,0x20,0x20,0x46,0x6F,0x72,0x20,0x61,0x20,0x6D,0x69,0x6C,0x65,0x20,0x61, +0x6E,0x64,0x20,0x61,0x20,0x68,0x61,0x6C,0x66,0x0A,0x6F,0x75,0x72,0x20,0x72,0x65, +0x61,0x72,0x20,0x77,0x61,0x73,0x20,0x67,0x75,0x61,0x72,0x64,0x65,0x64,0x20,0x61, +0x6C,0x6C,0x20,0x74,0x68,0x65,0x20,0x77,0x68,0x69,0x6C,0x65,0x20,0x62,0x79,0x20, +0x61,0x72,0x6D,0x65,0x64,0x20,0x6D,0x65,0x6E,0x2E,0x20,0x20,0x49,0x20,0x6E,0x65, +0x76,0x65,0x72,0x20,0x74,0x72,0x61,0x76,0x65,0x6C,0x65,0x64,0x20,0x69,0x6E,0x20, +0x73,0x6F,0x0A,0x6D,0x75,0x63,0x68,0x20,0x73,0x74,0x61,0x74,0x65,0x20,0x62,0x65, +0x66,0x6F,0x72,0x65,0x20,0x69,0x6E,0x20,0x61,0x6C,0x6C,0x20,0x6D,0x79,0x20,0x6C, +0x69,0x66,0x65,0x2E,0x0A,0x0A,0x49,0x74,0x20,0x77,0x61,0x73,0x20,0x61,0x20,0x67, +0x6F,0x6F,0x64,0x20,0x77,0x68,0x69,0x6C,0x65,0x20,0x61,0x66,0x74,0x65,0x72,0x20, +0x74,0x68,0x61,0x74,0x20,0x62,0x65,0x66,0x6F,0x72,0x65,0x20,0x77,0x65,0x20,0x76, +0x65,0x6E,0x74,0x75,0x72,0x65,0x64,0x20,0x74,0x6F,0x20,0x73,0x74,0x65,0x61,0x6C, +0x20,0x61,0x6E,0x79,0x20,0x6D,0x6F,0x72,0x65,0x0A,0x67,0x72,0x61,0x70,0x65,0x73, +0x2C,0x20,0x61,0x6E,0x64,0x20,0x77,0x68,0x65,0x6E,0x20,0x77,0x65,0x20,0x64,0x69, +0x64,0x20,0x77,0x65,0x20,0x73,0x74,0x69,0x72,0x72,0x65,0x64,0x20,0x75,0x70,0x20, +0x61,0x6E,0x6F,0x74,0x68,0x65,0x72,0x20,0x74,0x72,0x6F,0x75,0x62,0x6C,0x65,0x73, +0x6F,0x6D,0x65,0x20,0x62,0x72,0x69,0x67,0x61,0x6E,0x64,0x2C,0x20,0x61,0x6E,0x64, +0x0A,0x74,0x68,0x65,0x6E,0x20,0x77,0x65,0x20,0x63,0x65,0x61,0x73,0x65,0x64,0x20, +0x61,0x6C,0x6C,0x20,0x66,0x75,0x72,0x74,0x68,0x65,0x72,0x20,0x73,0x70,0x65,0x63, +0x75,0x6C,0x61,0x74,0x69,0x6F,0x6E,0x20,0x69,0x6E,0x20,0x74,0x68,0x61,0x74,0x20, +0x6C,0x69,0x6E,0x65,0x2E,0x20,0x20,0x49,0x20,0x73,0x75,0x70,0x70,0x6F,0x73,0x65, +0x20,0x74,0x68,0x61,0x74,0x0A,0x66,0x65,0x6C,0x6C,0x6F,0x77,0x20,0x74,0x68,0x61, +0x74,0x20,0x72,0x6F,0x64,0x65,0x20,0x62,0x79,0x20,0x6F,0x6E,0x20,0x74,0x68,0x65, +0x20,0x6D,0x75,0x6C,0x65,0x20,0x70,0x6F,0x73,0x74,0x65,0x64,0x20,0x61,0x6C,0x6C, +0x20,0x74,0x68,0x65,0x20,0x73,0x65,0x6E,0x74,0x69,0x6E,0x65,0x6C,0x73,0x2C,0x20, +0x66,0x72,0x6F,0x6D,0x20,0x41,0x74,0x68,0x65,0x6E,0x73,0x20,0x74,0x6F,0x0A,0x74, +0x68,0x65,0x20,0x50,0x69,0x72,0x61,0x65,0x75,0x73,0x2C,0x20,0x61,0x62,0x6F,0x75, +0x74,0x20,0x75,0x73,0x2E,0x0A,0x0A,0x45,0x76,0x65,0x72,0x79,0x20,0x66,0x69,0x65, +0x6C,0x64,0x20,0x6F,0x6E,0x20,0x74,0x68,0x61,0x74,0x20,0x6C,0x6F,0x6E,0x67,0x20, +0x72,0x6F,0x75,0x74,0x65,0x20,0x77,0x61,0x73,0x20,0x77,0x61,0x74,0x63,0x68,0x65, +0x64,0x20,0x62,0x79,0x20,0x61,0x6E,0x20,0x61,0x72,0x6D,0x65,0x64,0x20,0x73,0x65, +0x6E,0x74,0x69,0x6E,0x65,0x6C,0x2C,0x20,0x73,0x6F,0x6D,0x65,0x20,0x6F,0x66,0x0A, +0x77,0x68,0x6F,0x6D,0x20,0x68,0x61,0x64,0x20,0x66,0x61,0x6C,0x6C,0x65,0x6E,0x20, +0x61,0x73,0x6C,0x65,0x65,0x70,0x2C,0x20,0x6E,0x6F,0x20,0x64,0x6F,0x75,0x62,0x74, +0x2C,0x20,0x62,0x75,0x74,0x20,0x77,0x65,0x72,0x65,0x20,0x6F,0x6E,0x20,0x68,0x61, +0x6E,0x64,0x2C,0x20,0x6E,0x65,0x76,0x65,0x72,0x74,0x68,0x65,0x6C,0x65,0x73,0x73, +0x2E,0x20,0x20,0x54,0x68,0x69,0x73,0x0A,0x73,0x68,0x6F,0x77,0x73,0x20,0x77,0x68, +0x61,0x74,0x20,0x73,0x6F,0x72,0x74,0x20,0x6F,0x66,0x20,0x61,0x20,0x63,0x6F,0x75, +0x6E,0x74,0x72,0x79,0x20,0x6D,0x6F,0x64,0x65,0x72,0x6E,0x20,0x41,0x74,0x74,0x69, +0x63,0x61,0x20,0x69,0x73,0x2D,0x2D,0x61,0x20,0x63,0x6F,0x6D,0x6D,0x75,0x6E,0x69, +0x74,0x79,0x20,0x6F,0x66,0x0A,0x71,0x75,0x65,0x73,0x74,0x69,0x6F,0x6E,0x61,0x62, +0x6C,0x65,0x20,0x63,0x68,0x61,0x72,0x61,0x63,0x74,0x65,0x72,0x73,0x2E,0x20,0x20, +0x54,0x68,0x65,0x73,0x65,0x20,0x6D,0x65,0x6E,0x20,0x77,0x65,0x72,0x65,0x20,0x6E, +0x6F,0x74,0x20,0x74,0x68,0x65,0x72,0x65,0x20,0x74,0x6F,0x20,0x67,0x75,0x61,0x72, +0x64,0x20,0x74,0x68,0x65,0x69,0x72,0x0A,0x70,0x6F,0x73,0x73,0x65,0x73,0x73,0x69, +0x6F,0x6E,0x73,0x20,0x61,0x67,0x61,0x69,0x6E,0x73,0x74,0x20,0x73,0x74,0x72,0x61, +}; diff --git a/zlib/thumb/trees.c b/zlib/thumb/trees.c new file mode 100644 index 0000000..75bf914 --- /dev/null +++ b/zlib/thumb/trees.c @@ -0,0 +1,1224 @@ +/* trees.c -- output deflated data using Huffman coding + * Copyright (C) 1995-2012 Jean-loup Gailly + * detect_data_type() function provided freely by Cosmin Truta, 2006 + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* + * ALGORITHM + * + * The "deflation" process uses several Huffman trees. The more + * common source values are represented by shorter bit sequences. + * + * Each code tree is stored in a compressed form which is itself + * a Huffman encoding of the lengths of all the code strings (in + * ascending order by source values). The actual code strings are + * reconstructed from the lengths in the inflate process, as described + * in the deflate specification. + * + * REFERENCES + * + * Deutsch, L.P.,"'Deflate' Compressed Data Format Specification". + * Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc + * + * Storer, James A. + * Data Compression: Methods and Theory, pp. 49-50. + * Computer Science Press, 1988. ISBN 0-7167-8156-5. + * + * Sedgewick, R. + * Algorithms, p290. + * Addison-Wesley, 1983. ISBN 0-201-06672-6. + */ + +/* @(#) $Id$ */ + +/* #define GEN_TREES_H */ + +#include "deflate.h" + +#ifdef DEBUG +# include +#endif + +/* =========================================================================== + * Constants + */ + +#define MAX_BL_BITS 7 +/* Bit length codes must not exceed MAX_BL_BITS bits */ + +#define END_BLOCK 256 +/* end of block literal code */ + +#define REP_3_6 16 +/* repeat previous bit length 3-6 times (2 bits of repeat count) */ + +#define REPZ_3_10 17 +/* repeat a zero length 3-10 times (3 bits of repeat count) */ + +#define REPZ_11_138 18 +/* repeat a zero length 11-138 times (7 bits of repeat count) */ + +local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */ + = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0}; + +local const int extra_dbits[D_CODES] /* extra bits for each distance code */ + = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */ + = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7}; + +local const uch bl_order[BL_CODES] + = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15}; +/* The lengths of the bit length codes are sent in order of decreasing + * probability, to avoid transmitting the lengths for unused bit length codes. + */ + +/* =========================================================================== + * Local data. These are initialized only once. + */ + +#define DIST_CODE_LEN 512 /* see definition of array dist_code below */ + +#if defined(GEN_TREES_H) || !defined(STDC) +/* non ANSI compilers may not accept trees.h */ + +local ct_data static_ltree[L_CODES+2]; +/* The static literal tree. Since the bit lengths are imposed, there is no + * need for the L_CODES extra codes used during heap construction. However + * The codes 286 and 287 are needed to build a canonical tree (see _tr_init + * below). + */ + +local ct_data static_dtree[D_CODES]; +/* The static distance tree. (Actually a trivial tree since all codes use + * 5 bits.) + */ + +uch _dist_code[DIST_CODE_LEN]; +/* Distance codes. The first 256 values correspond to the distances + * 3 .. 258, the last 256 values correspond to the top 8 bits of + * the 15 bit distances. + */ + +uch _length_code[MAX_MATCH-MIN_MATCH+1]; +/* length code for each normalized match length (0 == MIN_MATCH) */ + +local int base_length[LENGTH_CODES]; +/* First normalized length for each code (0 = MIN_MATCH) */ + +local int base_dist[D_CODES]; +/* First normalized distance for each code (0 = distance of 1) */ + +#else +# include "trees.h" +#endif /* GEN_TREES_H */ + +struct static_tree_desc_s { + const ct_data *static_tree; /* static tree or NULL */ + const intf *extra_bits; /* extra bits for each code or NULL */ + int extra_base; /* base index for extra_bits */ + int elems; /* max number of elements in the tree */ + int max_length; /* max bit length for the codes */ +}; + +local static_tree_desc static_l_desc = +{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS}; + +local static_tree_desc static_d_desc = +{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS}; + +local static_tree_desc static_bl_desc = +{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS}; + +/* =========================================================================== + * Local (static) routines in this file. + */ + +local void tr_static_init OF((void)); +local void init_block OF((deflate_state *s)); +local void pqdownheap OF((deflate_state *s, ct_data *tree, int k)); +local void gen_bitlen OF((deflate_state *s, tree_desc *desc)); +local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count)); +local void build_tree OF((deflate_state *s, tree_desc *desc)); +local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code)); +local void send_tree OF((deflate_state *s, ct_data *tree, int max_code)); +local int build_bl_tree OF((deflate_state *s)); +local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes, + int blcodes)); +local void compress_block OF((deflate_state *s, ct_data *ltree, + ct_data *dtree)); +local int detect_data_type OF((deflate_state *s)); +local unsigned bi_reverse OF((unsigned value, int length)); +local void bi_windup OF((deflate_state *s)); +local void bi_flush OF((deflate_state *s)); +local void copy_block OF((deflate_state *s, charf *buf, unsigned len, + int header)); + +#ifdef GEN_TREES_H +local void gen_trees_header OF((void)); +#endif + +#ifndef DEBUG +# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len) + /* Send a code of the given tree. c and tree must not have side effects */ + +#else /* DEBUG */ +# define send_code(s, c, tree) \ + { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \ + send_bits(s, tree[c].Code, tree[c].Len); } +#endif + +/* =========================================================================== + * Output a short LSB first on the stream. + * IN assertion: there is enough room in pendingBuf. + */ +#define put_short(s, w) { \ + put_byte(s, (uch)((w) & 0xff)); \ + put_byte(s, (uch)((ush)(w) >> 8)); \ +} + +/* =========================================================================== + * Send a value on a given number of bits. + * IN assertion: length <= 16 and value fits in length bits. + */ +#ifdef DEBUG +local void send_bits OF((deflate_state *s, int value, int length)); + +local void send_bits(s, value, length) + deflate_state *s; + int value; /* value to send */ + int length; /* number of bits */ +{ + Tracevv((stderr," l %2d v %4x ", length, value)); + Assert(length > 0 && length <= 15, "invalid length"); + s->bits_sent += (ulg)length; + + /* If not enough room in bi_buf, use (valid) bits from bi_buf and + * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid)) + * unused bits in value. + */ + if (s->bi_valid > (int)Buf_size - length) { + s->bi_buf |= (ush)value << s->bi_valid; + put_short(s, s->bi_buf); + s->bi_buf = (ush)value >> (Buf_size - s->bi_valid); + s->bi_valid += length - Buf_size; + } else { + s->bi_buf |= (ush)value << s->bi_valid; + s->bi_valid += length; + } +} +#else /* !DEBUG */ + +#define send_bits(s, value, length) \ +{ int len = length;\ + if (s->bi_valid > (int)Buf_size - len) {\ + int val = value;\ + s->bi_buf |= (ush)val << s->bi_valid;\ + put_short(s, s->bi_buf);\ + s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\ + s->bi_valid += len - Buf_size;\ + } else {\ + s->bi_buf |= (ush)(value) << s->bi_valid;\ + s->bi_valid += len;\ + }\ +} +#endif /* DEBUG */ + + +/* the arguments must not have side effects */ + +/* =========================================================================== + * Initialize the various 'constant' tables. + */ +local void tr_static_init() +{ +#if defined(GEN_TREES_H) || !defined(STDC) + static int static_init_done = 0; + int n; /* iterates over tree elements */ + int bits; /* bit counter */ + int length; /* length value */ + int code; /* code value */ + int dist; /* distance index */ + ush bl_count[MAX_BITS+1]; + /* number of codes at each bit length for an optimal tree */ + + if (static_init_done) return; + + /* For some embedded targets, global variables are not initialized: */ +#ifdef NO_INIT_GLOBAL_POINTERS + static_l_desc.static_tree = static_ltree; + static_l_desc.extra_bits = extra_lbits; + static_d_desc.static_tree = static_dtree; + static_d_desc.extra_bits = extra_dbits; + static_bl_desc.extra_bits = extra_blbits; +#endif + + /* Initialize the mapping length (0..255) -> length code (0..28) */ + length = 0; + for (code = 0; code < LENGTH_CODES-1; code++) { + base_length[code] = length; + for (n = 0; n < (1< dist code (0..29) */ + dist = 0; + for (code = 0 ; code < 16; code++) { + base_dist[code] = dist; + for (n = 0; n < (1<>= 7; /* from now on, all distances are divided by 128 */ + for ( ; code < D_CODES; code++) { + base_dist[code] = dist << 7; + for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) { + _dist_code[256 + dist++] = (uch)code; + } + } + Assert (dist == 256, "tr_static_init: 256+dist != 512"); + + /* Construct the codes of the static literal tree */ + for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0; + n = 0; + while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++; + while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++; + while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++; + while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++; + /* Codes 286 and 287 do not exist, but we must include them in the + * tree construction to get a canonical Huffman tree (longest code + * all ones) + */ + gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count); + + /* The static distance tree is trivial: */ + for (n = 0; n < D_CODES; n++) { + static_dtree[n].Len = 5; + static_dtree[n].Code = bi_reverse((unsigned)n, 5); + } + static_init_done = 1; + +# ifdef GEN_TREES_H + gen_trees_header(); +# endif +#endif /* defined(GEN_TREES_H) || !defined(STDC) */ +} + +/* =========================================================================== + * Genererate the file trees.h describing the static trees. + */ +#ifdef GEN_TREES_H +# ifndef DEBUG +# include +# endif + +# define SEPARATOR(i, last, width) \ + ((i) == (last)? "\n};\n\n" : \ + ((i) % (width) == (width)-1 ? ",\n" : ", ")) + +void gen_trees_header() +{ + FILE *header = fopen("trees.h", "w"); + int i; + + Assert (header != NULL, "Can't open trees.h"); + fprintf(header, + "/* header created automatically with -DGEN_TREES_H */\n\n"); + + fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n"); + for (i = 0; i < L_CODES+2; i++) { + fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code, + static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5)); + } + + fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n"); + for (i = 0; i < D_CODES; i++) { + fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code, + static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5)); + } + + fprintf(header, "const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {\n"); + for (i = 0; i < DIST_CODE_LEN; i++) { + fprintf(header, "%2u%s", _dist_code[i], + SEPARATOR(i, DIST_CODE_LEN-1, 20)); + } + + fprintf(header, + "const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {\n"); + for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) { + fprintf(header, "%2u%s", _length_code[i], + SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20)); + } + + fprintf(header, "local const int base_length[LENGTH_CODES] = {\n"); + for (i = 0; i < LENGTH_CODES; i++) { + fprintf(header, "%1u%s", base_length[i], + SEPARATOR(i, LENGTH_CODES-1, 20)); + } + + fprintf(header, "local const int base_dist[D_CODES] = {\n"); + for (i = 0; i < D_CODES; i++) { + fprintf(header, "%5u%s", base_dist[i], + SEPARATOR(i, D_CODES-1, 10)); + } + + fclose(header); +} +#endif /* GEN_TREES_H */ + +/* =========================================================================== + * Initialize the tree data structures for a new zlib stream. + */ +void ZLIB_INTERNAL _tr_init(s) + deflate_state *s; +{ + tr_static_init(); + + s->l_desc.dyn_tree = s->dyn_ltree; + s->l_desc.stat_desc = &static_l_desc; + + s->d_desc.dyn_tree = s->dyn_dtree; + s->d_desc.stat_desc = &static_d_desc; + + s->bl_desc.dyn_tree = s->bl_tree; + s->bl_desc.stat_desc = &static_bl_desc; + + s->bi_buf = 0; + s->bi_valid = 0; +#ifdef DEBUG + s->compressed_len = 0L; + s->bits_sent = 0L; +#endif + + /* Initialize the first block of the first file: */ + init_block(s); +} + +/* =========================================================================== + * Initialize a new block. + */ +local void init_block(s) + deflate_state *s; +{ + int n; /* iterates over tree elements */ + + /* Initialize the trees. */ + for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0; + for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0; + for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0; + + s->dyn_ltree[END_BLOCK].Freq = 1; + s->opt_len = s->static_len = 0L; + s->last_lit = s->matches = 0; +} + +#define SMALLEST 1 +/* Index within the heap array of least frequent node in the Huffman tree */ + + +/* =========================================================================== + * Remove the smallest element from the heap and recreate the heap with + * one less element. Updates heap and heap_len. + */ +#define pqremove(s, tree, top) \ +{\ + top = s->heap[SMALLEST]; \ + s->heap[SMALLEST] = s->heap[s->heap_len--]; \ + pqdownheap(s, tree, SMALLEST); \ +} + +/* =========================================================================== + * Compares to subtrees, using the tree depth as tie breaker when + * the subtrees have equal frequency. This minimizes the worst case length. + */ +#define smaller(tree, n, m, depth) \ + (tree[n].Freq < tree[m].Freq || \ + (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m])) + +/* =========================================================================== + * Restore the heap property by moving down the tree starting at node k, + * exchanging a node with the smallest of its two sons if necessary, stopping + * when the heap property is re-established (each father smaller than its + * two sons). + */ +local void pqdownheap(s, tree, k) + deflate_state *s; + ct_data *tree; /* the tree to restore */ + int k; /* node to move down */ +{ + int v = s->heap[k]; + int j = k << 1; /* left son of k */ + while (j <= s->heap_len) { + /* Set j to the smallest of the two sons: */ + if (j < s->heap_len && + smaller(tree, s->heap[j+1], s->heap[j], s->depth)) { + j++; + } + /* Exit if v is smaller than both sons */ + if (smaller(tree, v, s->heap[j], s->depth)) break; + + /* Exchange v with the smallest son */ + s->heap[k] = s->heap[j]; k = j; + + /* And continue down the tree, setting j to the left son of k */ + j <<= 1; + } + s->heap[k] = v; +} + +/* =========================================================================== + * Compute the optimal bit lengths for a tree and update the total bit length + * for the current block. + * IN assertion: the fields freq and dad are set, heap[heap_max] and + * above are the tree nodes sorted by increasing frequency. + * OUT assertions: the field len is set to the optimal bit length, the + * array bl_count contains the frequencies for each bit length. + * The length opt_len is updated; static_len is also updated if stree is + * not null. + */ +local void gen_bitlen(s, desc) + deflate_state *s; + tree_desc *desc; /* the tree descriptor */ +{ + ct_data *tree = desc->dyn_tree; + int max_code = desc->max_code; + const ct_data *stree = desc->stat_desc->static_tree; + const intf *extra = desc->stat_desc->extra_bits; + int base = desc->stat_desc->extra_base; + int max_length = desc->stat_desc->max_length; + int h; /* heap index */ + int n, m; /* iterate over the tree elements */ + int bits; /* bit length */ + int xbits; /* extra bits */ + ush f; /* frequency */ + int overflow = 0; /* number of elements with bit length too large */ + + for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0; + + /* In a first pass, compute the optimal bit lengths (which may + * overflow in the case of the bit length tree). + */ + tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */ + + for (h = s->heap_max+1; h < HEAP_SIZE; h++) { + n = s->heap[h]; + bits = tree[tree[n].Dad].Len + 1; + if (bits > max_length) bits = max_length, overflow++; + tree[n].Len = (ush)bits; + /* We overwrite tree[n].Dad which is no longer needed */ + + if (n > max_code) continue; /* not a leaf node */ + + s->bl_count[bits]++; + xbits = 0; + if (n >= base) xbits = extra[n-base]; + f = tree[n].Freq; + s->opt_len += (ulg)f * (bits + xbits); + if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits); + } + if (overflow == 0) return; + + Trace((stderr,"\nbit length overflow\n")); + /* This happens for example on obj2 and pic of the Calgary corpus */ + + /* Find the first bit length which could increase: */ + do { + bits = max_length-1; + while (s->bl_count[bits] == 0) bits--; + s->bl_count[bits]--; /* move one leaf down the tree */ + s->bl_count[bits+1] += 2; /* move one overflow item as its brother */ + s->bl_count[max_length]--; + /* The brother of the overflow item also moves one step up, + * but this does not affect bl_count[max_length] + */ + overflow -= 2; + } while (overflow > 0); + + /* Now recompute all bit lengths, scanning in increasing frequency. + * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all + * lengths instead of fixing only the wrong ones. This idea is taken + * from 'ar' written by Haruhiko Okumura.) + */ + for (bits = max_length; bits != 0; bits--) { + n = s->bl_count[bits]; + while (n != 0) { + m = s->heap[--h]; + if (m > max_code) continue; + if ((unsigned) tree[m].Len != (unsigned) bits) { + Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits)); + s->opt_len += ((int)bits - (int)tree[m].Len) + *(int)tree[m].Freq; + tree[m].Len = (ush)bits; + } + n--; + } + } +} + +/* =========================================================================== + * Generate the codes for a given tree and bit counts (which need not be + * optimal). + * IN assertion: the array bl_count contains the bit length statistics for + * the given tree and the field len is set for all tree elements. + * OUT assertion: the field code is set for all tree elements of non + * zero code length. + */ +local void gen_codes (tree, max_code, bl_count) + ct_data *tree; /* the tree to decorate */ + int max_code; /* largest code with non zero frequency */ + ushf *bl_count; /* number of codes at each bit length */ +{ + ush next_code[MAX_BITS+1]; /* next code value for each bit length */ + ush code = 0; /* running code value */ + int bits; /* bit index */ + int n; /* code index */ + + /* The distribution counts are first used to generate the code values + * without bit reversal. + */ + for (bits = 1; bits <= MAX_BITS; bits++) { + next_code[bits] = code = (code + bl_count[bits-1]) << 1; + } + /* Check that the bit counts in bl_count are consistent. The last code + * must be all ones. + */ + Assert (code + bl_count[MAX_BITS]-1 == (1<dyn_tree; + const ct_data *stree = desc->stat_desc->static_tree; + int elems = desc->stat_desc->elems; + int n, m; /* iterate over heap elements */ + int max_code = -1; /* largest code with non zero frequency */ + int node; /* new node being created */ + + /* Construct the initial heap, with least frequent element in + * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. + * heap[0] is not used. + */ + s->heap_len = 0, s->heap_max = HEAP_SIZE; + + for (n = 0; n < elems; n++) { + if (tree[n].Freq != 0) { + s->heap[++(s->heap_len)] = max_code = n; + s->depth[n] = 0; + } else { + tree[n].Len = 0; + } + } + + /* The pkzip format requires that at least one distance code exists, + * and that at least one bit should be sent even if there is only one + * possible code. So to avoid special checks later on we force at least + * two codes of non zero frequency. + */ + while (s->heap_len < 2) { + node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0); + tree[node].Freq = 1; + s->depth[node] = 0; + s->opt_len--; if (stree) s->static_len -= stree[node].Len; + /* node is 0 or 1 so it does not have extra bits */ + } + desc->max_code = max_code; + + /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, + * establish sub-heaps of increasing lengths: + */ + for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n); + + /* Construct the Huffman tree by repeatedly combining the least two + * frequent nodes. + */ + node = elems; /* next internal node of the tree */ + do { + pqremove(s, tree, n); /* n = node of least frequency */ + m = s->heap[SMALLEST]; /* m = node of next least frequency */ + + s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */ + s->heap[--(s->heap_max)] = m; + + /* Create a new node father of n and m */ + tree[node].Freq = tree[n].Freq + tree[m].Freq; + s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ? + s->depth[n] : s->depth[m]) + 1); + tree[n].Dad = tree[m].Dad = (ush)node; +#ifdef DUMP_BL_TREE + if (tree == s->bl_tree) { + fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)", + node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq); + } +#endif + /* and insert the new node in the heap */ + s->heap[SMALLEST] = node++; + pqdownheap(s, tree, SMALLEST); + + } while (s->heap_len >= 2); + + s->heap[--(s->heap_max)] = s->heap[SMALLEST]; + + /* At this point, the fields freq and dad are set. We can now + * generate the bit lengths. + */ + gen_bitlen(s, (tree_desc *)desc); + + /* The field len is now set, we can generate the bit codes */ + gen_codes ((ct_data *)tree, max_code, s->bl_count); +} + +/* =========================================================================== + * Scan a literal or distance tree to determine the frequencies of the codes + * in the bit length tree. + */ +local void scan_tree (s, tree, max_code) + deflate_state *s; + ct_data *tree; /* the tree to be scanned */ + int max_code; /* and its largest code of non zero frequency */ +{ + int n; /* iterates over all tree elements */ + int prevlen = -1; /* last emitted length */ + int curlen; /* length of current code */ + int nextlen = tree[0].Len; /* length of next code */ + int count = 0; /* repeat count of the current code */ + int max_count = 7; /* max repeat count */ + int min_count = 4; /* min repeat count */ + + if (nextlen == 0) max_count = 138, min_count = 3; + tree[max_code+1].Len = (ush)0xffff; /* guard */ + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; nextlen = tree[n+1].Len; + if (++count < max_count && curlen == nextlen) { + continue; + } else if (count < min_count) { + s->bl_tree[curlen].Freq += count; + } else if (curlen != 0) { + if (curlen != prevlen) s->bl_tree[curlen].Freq++; + s->bl_tree[REP_3_6].Freq++; + } else if (count <= 10) { + s->bl_tree[REPZ_3_10].Freq++; + } else { + s->bl_tree[REPZ_11_138].Freq++; + } + count = 0; prevlen = curlen; + if (nextlen == 0) { + max_count = 138, min_count = 3; + } else if (curlen == nextlen) { + max_count = 6, min_count = 3; + } else { + max_count = 7, min_count = 4; + } + } +} + +/* =========================================================================== + * Send a literal or distance tree in compressed form, using the codes in + * bl_tree. + */ +local void send_tree (s, tree, max_code) + deflate_state *s; + ct_data *tree; /* the tree to be scanned */ + int max_code; /* and its largest code of non zero frequency */ +{ + int n; /* iterates over all tree elements */ + int prevlen = -1; /* last emitted length */ + int curlen; /* length of current code */ + int nextlen = tree[0].Len; /* length of next code */ + int count = 0; /* repeat count of the current code */ + int max_count = 7; /* max repeat count */ + int min_count = 4; /* min repeat count */ + + /* tree[max_code+1].Len = -1; */ /* guard already set */ + if (nextlen == 0) max_count = 138, min_count = 3; + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; nextlen = tree[n+1].Len; + if (++count < max_count && curlen == nextlen) { + continue; + } else if (count < min_count) { + do { send_code(s, curlen, s->bl_tree); } while (--count != 0); + + } else if (curlen != 0) { + if (curlen != prevlen) { + send_code(s, curlen, s->bl_tree); count--; + } + Assert(count >= 3 && count <= 6, " 3_6?"); + send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2); + + } else if (count <= 10) { + send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3); + + } else { + send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7); + } + count = 0; prevlen = curlen; + if (nextlen == 0) { + max_count = 138, min_count = 3; + } else if (curlen == nextlen) { + max_count = 6, min_count = 3; + } else { + max_count = 7, min_count = 4; + } + } +} + +/* =========================================================================== + * Construct the Huffman tree for the bit lengths and return the index in + * bl_order of the last bit length code to send. + */ +local int build_bl_tree(s) + deflate_state *s; +{ + int max_blindex; /* index of last bit length code of non zero freq */ + + /* Determine the bit length frequencies for literal and distance trees */ + scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code); + scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code); + + /* Build the bit length tree: */ + build_tree(s, (tree_desc *)(&(s->bl_desc))); + /* opt_len now includes the length of the tree representations, except + * the lengths of the bit lengths codes and the 5+5+4 bits for the counts. + */ + + /* Determine the number of bit length codes to send. The pkzip format + * requires that at least 4 bit length codes be sent. (appnote.txt says + * 3 but the actual value used is 4.) + */ + for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) { + if (s->bl_tree[bl_order[max_blindex]].Len != 0) break; + } + /* Update opt_len to include the bit length tree and counts */ + s->opt_len += 3*(max_blindex+1) + 5+5+4; + Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", + s->opt_len, s->static_len)); + + return max_blindex; +} + +/* =========================================================================== + * Send the header for a block using dynamic Huffman trees: the counts, the + * lengths of the bit length codes, the literal tree and the distance tree. + * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. + */ +local void send_all_trees(s, lcodes, dcodes, blcodes) + deflate_state *s; + int lcodes, dcodes, blcodes; /* number of codes for each tree */ +{ + int rank; /* index in bl_order */ + + Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); + Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, + "too many codes"); + Tracev((stderr, "\nbl counts: ")); + send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */ + send_bits(s, dcodes-1, 5); + send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */ + for (rank = 0; rank < blcodes; rank++) { + Tracev((stderr, "\nbl code %2d ", bl_order[rank])); + send_bits(s, s->bl_tree[bl_order[rank]].Len, 3); + } + Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent)); + + send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */ + Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent)); + + send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */ + Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent)); +} + +/* =========================================================================== + * Send a stored block + */ +void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last) + deflate_state *s; + charf *buf; /* input block */ + ulg stored_len; /* length of input block */ + int last; /* one if this is the last block for a file */ +{ + send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */ +#ifdef DEBUG + s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L; + s->compressed_len += (stored_len + 4) << 3; +#endif + copy_block(s, buf, (unsigned)stored_len, 1); /* with header */ +} + +/* =========================================================================== + * Flush the bits in the bit buffer to pending output (leaves at most 7 bits) + */ +void ZLIB_INTERNAL _tr_flush_bits(s) + deflate_state *s; +{ + bi_flush(s); +} + +/* =========================================================================== + * Send one empty static block to give enough lookahead for inflate. + * This takes 10 bits, of which 7 may remain in the bit buffer. + */ +void ZLIB_INTERNAL _tr_align(s) + deflate_state *s; +{ + send_bits(s, STATIC_TREES<<1, 3); + send_code(s, END_BLOCK, static_ltree); +#ifdef DEBUG + s->compressed_len += 10L; /* 3 for block type, 7 for EOB */ +#endif + bi_flush(s); +} + +/* =========================================================================== + * Determine the best encoding for the current block: dynamic trees, static + * trees or store, and output the encoded block to the zip file. + */ +void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) + deflate_state *s; + charf *buf; /* input block, or NULL if too old */ + ulg stored_len; /* length of input block */ + int last; /* one if this is the last block for a file */ +{ + ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ + int max_blindex = 0; /* index of last bit length code of non zero freq */ + + /* Build the Huffman trees unless a stored block is forced */ + if (s->level > 0) { + + /* Check if the file is binary or text */ + if (s->strm->data_type == Z_UNKNOWN) + s->strm->data_type = detect_data_type(s); + + /* Construct the literal and distance trees */ + build_tree(s, (tree_desc *)(&(s->l_desc))); + Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len, + s->static_len)); + + build_tree(s, (tree_desc *)(&(s->d_desc))); + Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len, + s->static_len)); + /* At this point, opt_len and static_len are the total bit lengths of + * the compressed block data, excluding the tree representations. + */ + + /* Build the bit length tree for the above two trees, and get the index + * in bl_order of the last bit length code to send. + */ + max_blindex = build_bl_tree(s); + + /* Determine the best encoding. Compute the block lengths in bytes. */ + opt_lenb = (s->opt_len+3+7)>>3; + static_lenb = (s->static_len+3+7)>>3; + + Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ", + opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, + s->last_lit)); + + if (static_lenb <= opt_lenb) opt_lenb = static_lenb; + + } else { + Assert(buf != (char*)0, "lost buf"); + opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ + } + +#ifdef FORCE_STORED + if (buf != (char*)0) { /* force stored block */ +#else + if (stored_len+4 <= opt_lenb && buf != (char*)0) { + /* 4: two words for the lengths */ +#endif + /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. + * Otherwise we can't have processed more than WSIZE input bytes since + * the last block flush, because compression would have been + * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to + * transform a block into a stored block. + */ + _tr_stored_block(s, buf, stored_len, last); + +#ifdef FORCE_STATIC + } else if (static_lenb >= 0) { /* force static trees */ +#else + } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) { +#endif + send_bits(s, (STATIC_TREES<<1)+last, 3); + compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree); +#ifdef DEBUG + s->compressed_len += 3 + s->static_len; +#endif + } else { + send_bits(s, (DYN_TREES<<1)+last, 3); + send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1, + max_blindex+1); + compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree); +#ifdef DEBUG + s->compressed_len += 3 + s->opt_len; +#endif + } + Assert (s->compressed_len == s->bits_sent, "bad compressed size"); + /* The above check is made mod 2^32, for files larger than 512 MB + * and uInt implemented on 32 bits. + */ + init_block(s); + + if (last) { + bi_windup(s); +#ifdef DEBUG + s->compressed_len += 7; /* align on byte boundary */ +#endif + } + Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3, + s->compressed_len-7*last)); +} + +/* =========================================================================== + * Save the match info and tally the frequency counts. Return true if + * the current block must be flushed. + */ +int ZLIB_INTERNAL _tr_tally (s, dist, lc) + deflate_state *s; + unsigned dist; /* distance of matched string */ + unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ +{ + s->d_buf[s->last_lit] = (ush)dist; + s->l_buf[s->last_lit++] = (uch)lc; + if (dist == 0) { + /* lc is the unmatched char */ + s->dyn_ltree[lc].Freq++; + } else { + s->matches++; + /* Here, lc is the match length - MIN_MATCH */ + dist--; /* dist = match distance - 1 */ + Assert((ush)dist < (ush)MAX_DIST(s) && + (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && + (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match"); + + s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++; + s->dyn_dtree[d_code(dist)].Freq++; + } + +#ifdef TRUNCATE_BLOCK + /* Try to guess if it is profitable to stop the current block here */ + if ((s->last_lit & 0x1fff) == 0 && s->level > 2) { + /* Compute an upper bound for the compressed length */ + ulg out_length = (ulg)s->last_lit*8L; + ulg in_length = (ulg)((int)s->strstart - s->block_start); + int dcode; + for (dcode = 0; dcode < D_CODES; dcode++) { + out_length += (ulg)s->dyn_dtree[dcode].Freq * + (5L+extra_dbits[dcode]); + } + out_length >>= 3; + Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ", + s->last_lit, in_length, out_length, + 100L - out_length*100L/in_length)); + if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1; + } +#endif + return (s->last_lit == s->lit_bufsize-1); + /* We avoid equality with lit_bufsize because of wraparound at 64K + * on 16 bit machines and because stored blocks are restricted to + * 64K-1 bytes. + */ +} + +/* =========================================================================== + * Send the block data compressed using the given Huffman trees + */ +local void compress_block(s, ltree, dtree) + deflate_state *s; + ct_data *ltree; /* literal tree */ + ct_data *dtree; /* distance tree */ +{ + unsigned dist; /* distance of matched string */ + int lc; /* match length or unmatched char (if dist == 0) */ + unsigned lx = 0; /* running index in l_buf */ + unsigned code; /* the code to send */ + int extra; /* number of extra bits to send */ + + if (s->last_lit != 0) do { + dist = s->d_buf[lx]; + lc = s->l_buf[lx++]; + if (dist == 0) { + send_code(s, lc, ltree); /* send a literal byte */ + Tracecv(isgraph(lc), (stderr," '%c' ", lc)); + } else { + /* Here, lc is the match length - MIN_MATCH */ + code = _length_code[lc]; + send_code(s, code+LITERALS+1, ltree); /* send the length code */ + extra = extra_lbits[code]; + if (extra != 0) { + lc -= base_length[code]; + send_bits(s, lc, extra); /* send the extra length bits */ + } + dist--; /* dist is now the match distance - 1 */ + code = d_code(dist); + Assert (code < D_CODES, "bad d_code"); + + send_code(s, code, dtree); /* send the distance code */ + extra = extra_dbits[code]; + if (extra != 0) { + dist -= base_dist[code]; + send_bits(s, dist, extra); /* send the extra distance bits */ + } + } /* literal or match pair ? */ + + /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ + Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx, + "pendingBuf overflow"); + + } while (lx < s->last_lit); + + send_code(s, END_BLOCK, ltree); +} + +/* =========================================================================== + * Check if the data type is TEXT or BINARY, using the following algorithm: + * - TEXT if the two conditions below are satisfied: + * a) There are no non-portable control characters belonging to the + * "black list" (0..6, 14..25, 28..31). + * b) There is at least one printable character belonging to the + * "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255). + * - BINARY otherwise. + * - The following partially-portable control characters form a + * "gray list" that is ignored in this detection algorithm: + * (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}). + * IN assertion: the fields Freq of dyn_ltree are set. + */ +local int detect_data_type(s) + deflate_state *s; +{ + /* black_mask is the bit mask of black-listed bytes + * set bits 0..6, 14..25, and 28..31 + * 0xf3ffc07f = binary 11110011111111111100000001111111 + */ + unsigned int black_mask = 0xf3ffc07fUL; + int n; + + /* Check for non-textual ("black-listed") bytes. */ + for (n = 0; n <= 31; n++, black_mask >>= 1) + if ((black_mask & 1) && (s->dyn_ltree[n].Freq != 0)) + return Z_BINARY; + + /* Check for textual ("white-listed") bytes. */ + if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0 + || s->dyn_ltree[13].Freq != 0) + return Z_TEXT; + for (n = 32; n < LITERALS; n++) + if (s->dyn_ltree[n].Freq != 0) + return Z_TEXT; + + /* There are no "black-listed" or "white-listed" bytes: + * this stream either is empty or has tolerated ("gray-listed") bytes only. + */ + return Z_BINARY; +} + +/* =========================================================================== + * Reverse the first len bits of a code, using straightforward code (a faster + * method would use a table) + * IN assertion: 1 <= len <= 15 + */ +local unsigned bi_reverse(code, len) + unsigned code; /* the value to invert */ + int len; /* its bit length */ +{ + register unsigned res = 0; + do { + res |= code & 1; + code >>= 1, res <<= 1; + } while (--len > 0); + return res >> 1; +} + +/* =========================================================================== + * Flush the bit buffer, keeping at most 7 bits in it. + */ +local void bi_flush(s) + deflate_state *s; +{ + if (s->bi_valid == 16) { + put_short(s, s->bi_buf); + s->bi_buf = 0; + s->bi_valid = 0; + } else if (s->bi_valid >= 8) { + put_byte(s, (Byte)s->bi_buf); + s->bi_buf >>= 8; + s->bi_valid -= 8; + } +} + +/* =========================================================================== + * Flush the bit buffer and align the output on a byte boundary + */ +local void bi_windup(s) + deflate_state *s; +{ + if (s->bi_valid > 8) { + put_short(s, s->bi_buf); + } else if (s->bi_valid > 0) { + put_byte(s, (Byte)s->bi_buf); + } + s->bi_buf = 0; + s->bi_valid = 0; +#ifdef DEBUG + s->bits_sent = (s->bits_sent+7) & ~7; +#endif +} + +/* =========================================================================== + * Copy a stored block, storing first the length and its + * one's complement if requested. + */ +local void copy_block(s, buf, len, header) + deflate_state *s; + charf *buf; /* the input data */ + unsigned len; /* its length */ + int header; /* true if block header must be written */ +{ + bi_windup(s); /* align on byte boundary */ + + if (header) { + put_short(s, (ush)len); + put_short(s, (ush)~len); +#ifdef DEBUG + s->bits_sent += 2*16; +#endif + } +#ifdef DEBUG + s->bits_sent += (ulg)len<<3; +#endif + while (len--) { + put_byte(s, *buf++); + } +} diff --git a/zlib/thumb/trees.h b/zlib/thumb/trees.h new file mode 100644 index 0000000..d35639d --- /dev/null +++ b/zlib/thumb/trees.h @@ -0,0 +1,128 @@ +/* header created automatically with -DGEN_TREES_H */ + +local const ct_data static_ltree[L_CODES+2] = { +{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}}, +{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}}, +{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}}, +{{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}}, +{{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}}, +{{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}}, +{{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}}, +{{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}}, +{{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}}, +{{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}}, +{{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}}, +{{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}}, +{{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}}, +{{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}}, +{{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}}, +{{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}}, +{{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}}, +{{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}}, +{{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}}, +{{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}}, +{{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}}, +{{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}}, +{{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}}, +{{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}}, +{{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}}, +{{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}}, +{{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}}, +{{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}}, +{{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}}, +{{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}}, +{{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}}, +{{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}}, +{{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}}, +{{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}}, +{{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}}, +{{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}}, +{{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}}, +{{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}}, +{{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}}, +{{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}}, +{{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}}, +{{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}}, +{{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}}, +{{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}}, +{{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}}, +{{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}}, +{{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}}, +{{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}}, +{{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}}, +{{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}}, +{{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}}, +{{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}}, +{{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}}, +{{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}}, +{{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}}, +{{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}}, +{{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}}, +{{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}} +}; + +local const ct_data static_dtree[D_CODES] = { +{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}}, +{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}}, +{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}}, +{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}}, +{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}}, +{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}} +}; + +const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = { + 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, + 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, +10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, +11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, +12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, +13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, +13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17, +18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, +23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, +29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, +29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, +29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 +}; + +const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, +13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, +17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, +19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, +21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, +22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, +23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 +}; + +local const int base_length[LENGTH_CODES] = { +0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, +64, 80, 96, 112, 128, 160, 192, 224, 0 +}; + +local const int base_dist[D_CODES] = { + 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, + 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, + 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576 +}; + diff --git a/zlib/thumb/twain.txt b/zlib/thumb/twain.txt new file mode 100644 index 0000000..19597cb --- /dev/null +++ b/zlib/thumb/twain.txt @@ -0,0 +1,251 @@ + +Most of the Parthenon's imposing columns are still standing, but the roof +is gone. It was a perfect building two hundred and fifty years ago, when +a shell dropped into the Venetian magazine stored here, and the explosion +which followed wrecked and unroofed it. I remember but little about the +Parthenon, and I have put in one or two facts and figures for the use of +other people with short memories. Got them from the guide-book. + +As we wandered thoughtfully down the marble-paved length of this stately +temple, the scene about us was strangely impressive. Here and there, in +lavish profusion, were gleaming white statues of men and women, propped +against blocks of marble, some of them armless, some without legs, others +headless--but all looking mournful in the moonlight, and startlingly +human! They rose up and confronted the midnight intruder on every side +--they stared at him with stony eyes from unlooked-for nooks and recesses; +they peered at him over fragmentary heaps far down the desolate +corridors; they barred his way in the midst of the broad forum, and +solemnly pointed with handless arms the way from the sacred fane; and +through the roofless temple the moon looked down, and banded the floor +and darkened the scattered fragments and broken statues with the slanting +shadows of the columns. + +What a world of ruined sculpture was about us! Set up in rows--stacked +up in piles--scattered broadcast over the wide area of the Acropolis +--were hundreds of crippled statues of all sizes and of the most exquisite +workmanship; and vast fragments of marble that once belonged to the +entablatures, covered with bas-reliefs representing battles and sieges, +ships of war with three and four tiers of oars, pageants and processions +--every thing one could think of. History says that the temples of the +Acropolis were filled with the noblest works of Praxiteles and Phidias, +and of many a great master in sculpture besides--and surely these elegant +fragments attest it. + +We walked out into the grass-grown, fragment-strewn court beyond the +Parthenon. It startled us, every now and then, to see a stony white face +stare suddenly up at us out of the grass with its dead eyes. The place +seemed alive with ghosts. I half expected to see the Athenian heroes of +twenty centuries ago glide out of the shadows and steal into the old +temple they knew so well and regarded with such boundless pride. + +The full moon was riding high in the cloudless heavens, now. We +sauntered carelessly and unthinkingly to the edge of the lofty +battlements of the citadel, and looked down--a vision! And such a +vision! Athens by moonlight! The prophet that thought the splendors of +the New Jerusalem were revealed to him, surely saw this instead! It lay +in the level plain right under our feet--all spread abroad like a +picture--and we looked down upon it as we might have looked from a +balloon. We saw no semblance of a street, but every house, every window, +every clinging vine, every projection was as distinct and sharply marked +as if the time were noon-day; and yet there was no glare, no glitter, +nothing harsh or repulsive--the noiseless city was flooded with the +mellowest light that ever streamed from the moon, and seemed like some +living creature wrapped in peaceful slumber. On its further side was a +little temple, whose delicate pillars and ornate front glowed with a rich +lustre that chained the eye like a spell; and nearer by, the palace of +the king reared its creamy walls out of the midst of a great garden of +shrubbery that was flecked all over with a random shower of amber lights +--a spray of golden sparks that lost their brightness in the glory of the +moon, and glinted softly upon the sea of dark foliage like the pallid +stars of the milky-way. Overhead the stately columns, majestic still in +their ruin--under foot the dreaming city--in the distance the silver sea +--not on the broad earth is there an other picture half so beautiful! + +As we turned and moved again through the temple, I wished that the +illustrious men who had sat in it in the remote ages could visit it again +and reveal themselves to our curious eyes--Plato, Aristotle, Demosthenes, +Socrates, Phocion, Pythagoras, Euclid, Pindar, Xenophon, Herodotus, +Praxiteles and Phidias, Zeuxis the painter. What a constellation of +celebrated names! But more than all, I wished that old Diogenes, groping +so patiently with his lantern, searching so zealously for one solitary +honest man in all the world, might meander along and stumble on our +party. I ought not to say it, may be, but still I suppose he would have +put out his light. + +We left the Parthenon to keep its watch over old Athens, as it had kept +it for twenty-three hundred years, and went and stood outside the walls +of the citadel. In the distance was the ancient, but still almost +perfect Temple of Theseus, and close by, looking to the west, was the +Bema, from whence Demosthenes thundered his philippics and fired the +wavering patriotism of his countrymen. To the right was Mars Hill, where +the Areopagus sat in ancient times and where St. Paul defined his +position, and below was the market-place where he "disputed daily" with +the gossip-loving Athenians. We climbed the stone steps St. Paul +ascended, and stood in the square-cut place he stood in, and tried to +recollect the Bible account of the matter--but for certain reasons, I +could not recall the words. I have found them since: + + "Now while Paul waited for them at Athens, his spirit was stirred in + him, when he saw the city wholly given up to idolatry. Therefore + disputed he in the synagogue with the Jews, and with the devout + persons, and in the market daily with them that met with him. + * * * * * * * * * + "And they took him and brought him unto Areopagus, saying, May we + know what this new doctrine whereof thou speakest is? + * * * * * * * * * + "Then Paul stood in the midst of Mars hill, and said, Ye men of + Athens, I perceive that in all things ye are too superstitious; For + as I passed by and beheld your devotions, I found an altar with this + inscription: To THE UNKNOWN GOD. Whom, therefore, ye ignorantly + worship, him declare I unto you."--Acts, ch. xvii." + +It occurred to us, after a while, that if we wanted to get home before +daylight betrayed us, we had better be moving. So we hurried away. When +far on our road, we had a parting view of the Parthenon, with the +moonlight streaming through its open colonnades and touching its capitals +with silver. As it looked then, solemn, grand, and beautiful it will +always remain in our memories. + +As we marched along, we began to get over our fears, and ceased to care +much about quarantine scouts or any body else. We grew bold and +reckless; and once, in a sudden burst of courage, I even threw a stone at +a dog. It was a pleasant reflection, though, that I did not hit him, +because his master might just possibly have been a policeman. Inspired +by this happy failure, my valor became utterly uncontrollable, and at +intervals I absolutely whistled, though on a moderate key. But boldness +breeds boldness, and shortly I plunged into a Vineyard, in the full light +of the moon, and captured a gallon of superb grapes, not even minding the +presence of a peasant who rode by on a mule. Denny and Birch followed my +example. + +Now I had grapes enough for a dozen, but then Jackson was all swollen up +with courage, too, and he was obliged to enter a vineyard presently. The +first bunch he seized brought trouble. A frowsy, bearded brigand sprang +into the road with a shout, and flourished a musket in the light of the +moon! We sidled toward the Piraeus--not running you understand, but only +advancing with celerity. The brigand shouted again, but still we +advanced. It was getting late, and we had no time to fool away on every +ass that wanted to drivel Greek platitudes to us. We would just as soon +have talked with him as not if we had not been in a hurry. Presently +Denny said, "Those fellows are following us!" + +We turned, and, sure enough, there they were--three fantastic pirates +armed with guns. We slackened our pace to let them come up, and in the +meantime I got out my cargo of grapes and dropped them firmly but +reluctantly into the shadows by the wayside. But I was not afraid. I +only felt that it was not right to steal grapes. And all the more so +when the owner was around--and not only around, but with his friends +around also. The villains came up and searched a bundle Dr. Birch had in +his hand, and scowled upon him when they found it had nothing in it but +some holy rocks from Mars Hill, and these were not contraband. They +evidently suspected him of playing some wretched fraud upon them, and +seemed half inclined to scalp the party. But finally they dismissed us +with a warning, couched in excellent Greek, I suppose, and dropped +tranquilly in our wake. When they had gone three hundred yards they +stopped, and we went on rejoiced. But behold, another armed rascal came +out of the shadows and took their place, and followed us two hundred +yards. Then he delivered us over to another miscreant, who emerged from +some mysterious place, and he in turn to another! For a mile and a half +our rear was guarded all the while by armed men. I never traveled in so +much state before in all my life. + +It was a good while after that before we ventured to steal any more +grapes, and when we did we stirred up another troublesome brigand, and +then we ceased all further speculation in that line. I suppose that +fellow that rode by on the mule posted all the sentinels, from Athens to +the Piraeus, about us. + +Every field on that long route was watched by an armed sentinel, some of +whom had fallen asleep, no doubt, but were on hand, nevertheless. This +shows what sort of a country modern Attica is--a community of +questionable characters. These men were not there to guard their +possessions against strangers, but against each other; for strangers +seldom visit Athens and the Piraeus, and when they do, they go in +daylight, and can buy all the grapes they want for a trifle. The modern +inhabitants are confiscators and falsifiers of high repute, if gossip +speaks truly concerning them, and I freely believe it does. + +Just as the earliest tinges of the dawn flushed the eastern sky and +turned the pillared Parthenon to a broken harp hung in the pearly +horizon, we closed our thirteenth mile of weary, round-about marching, +and emerged upon the sea-shore abreast the ships, with our usual escort +of fifteen hundred Piraean dogs howling at our heels. We hailed a boat +that was two or three hundred yards from shore, and discovered +in a moment that it was a police-boat on the lookout for any +quarantine-breakers that might chance to be abroad. So we dodged--we +were used to that by this time--and when the scouts reached the spot we +had so lately occupied, we were absent. They cruised along the shore, +but in the wrong direction, and shortly our own boat issued from the +gloom and took us aboard. They had heard our signal on the ship. We +rowed noiselessly away, and before the police-boat came in sight again, +we were safe at home once more. + +Four more of our passengers were anxious to visit Athens, and started +half an hour after we returned; but they had not been ashore five minutes +till the police discovered and chased them so hotly that they barely +escaped to their boat again, and that was all. They pursued the +enterprise no further. + +We set sail for Constantinople to-day, but some of us little care for +that. We have seen all there was to see in the old city that had its +birth sixteen hundred years before Christ was born, and was an old town +before the foundations of Troy were laid--and saw it in its most +attractive aspect. Wherefore, why should we worry? + +Two other passengers ran the blockade successfully last night. So we +learned this morning. They slipped away so quietly that they were not +missed from the ship for several hours. They had the hardihood to march +into the Piraeus in the early dusk and hire a carriage. They ran some +danger of adding two or three months' imprisonment to the other novelties +of their Holy Land Pleasure Excursion. I admire "cheek."--[Quotation +from the Pilgrims.]--But they went and came safely, and never walked a +step. + + + + +CHAPTER XXXIII. + +From Athens all through the islands of the Grecian Archipelago, we saw +little but forbidding sea-walls and barren hills, sometimes surmounted by +three or four graceful columns of some ancient temple, lonely and +deserted--a fitting symbol of the desolation that has come upon all +Greece in these latter ages. We saw no ploughed fields, very few +villages, no trees or grass or vegetation of any kind, scarcely, and +hardly ever an isolated house. Greece is a bleak, unsmiling desert, +without agriculture, manufactures or commerce, apparently. What supports +its poverty-stricken people or its Government, is a mystery. + +I suppose that ancient Greece and modern Greece compared, furnish the +most extravagant contrast to be found in history. George I., an infant +of eighteen, and a scraggy nest of foreign office holders, sit in the +places of Themistocles, Pericles, and the illustrious scholars and +generals of the Golden Age of Greece. The fleets that were the wonder of +the world when the Parthenon was new, are a beggarly handful of +fishing-smacks now, and the manly people that performed such miracles of +valor at Marathon are only a tribe of unconsidered slaves to-day. The +classic Illyssus has gone dry, and so have all the sources of Grecian +wealth and greatness. The nation numbers only eight hundred thousand +souls, and there is poverty and misery and mendacity enough among them +to furnish forty millions and be liberal about it. Under King Otho the +revenues of the State were five millions of dollars--raised from a tax +of one-tenth of all the agricultural products of the land (which tenth +the farmer had to bring to the royal granaries on pack-mules any +distance not exceeding six leagues) and from extravagant taxes on trade +and commerce. Out of that five millions the small tyrant tried to keep +an army of ten thousand men, pay all the hundreds of useless Grand +Equerries in Waiting, First Grooms of the Bedchamber, Lord High +Chancellors of the Exploded Exchequer, and all the other absurdities +which these puppy-kingdoms indulge in, in imitation of the great +monarchies; and in addition he set about building a white marble palace +to cost about five millions itself. The result was, simply: ten into +five goes no times and none over. All these things could not be done +with five millions, and Otho fell into trouble. + +The Greek throne, with its unpromising adjuncts of a ragged population of +ingenious rascals who were out of employment eight months in the year +because there was little for them to borrow and less to confiscate, and a +waste of barren hills and weed-grown deserts, went begging for a good +while. It was offered to one of Victoria's sons, and afterwards to +various other younger sons of royalty who had no thrones and were out of +business, but they all had t diff --git a/zlib/thumb/uart.c b/zlib/thumb/uart.c new file mode 100644 index 0000000..5b6e3cc --- /dev/null +++ b/zlib/thumb/uart.c @@ -0,0 +1,94 @@ + +//------------------------------------------------------------------------- +//------------------------------------------------------------------------- + +extern void PUT32 ( unsigned int, unsigned int ); +extern unsigned int GET32 ( unsigned int ); +extern void dummy ( unsigned int ); + +#define GPFSEL1 0x20200004 +#define GPSET0 0x2020001C +#define GPCLR0 0x20200028 +#define GPPUD 0x20200094 +#define GPPUDCLK0 0x20200098 + +#define AUX_ENABLES 0x20215004 +#define AUX_MU_IO_REG 0x20215040 +#define AUX_MU_IER_REG 0x20215044 +#define AUX_MU_IIR_REG 0x20215048 +#define AUX_MU_LCR_REG 0x2021504C +#define AUX_MU_MCR_REG 0x20215050 +#define AUX_MU_LSR_REG 0x20215054 +#define AUX_MU_MSR_REG 0x20215058 +#define AUX_MU_SCRATCH 0x2021505C +#define AUX_MU_CNTL_REG 0x20215060 +#define AUX_MU_STAT_REG 0x20215064 +#define AUX_MU_BAUD_REG 0x20215068 + +//GPIO14 TXD0 and TXD1 +//GPIO15 RXD0 and RXD1 +//alt function 5 for uart1 + +//((250,000,000/115200)/8)-1 = 270 +//------------------------------------------------------------------------ +void uart_putc ( unsigned int c ) +{ + while(1) + { + if(GET32(AUX_MU_LSR_REG)&0x20) break; + } + PUT32(AUX_MU_IO_REG,c); +} +//------------------------------------------------------------------------ +void hexstrings ( unsigned int d ) +{ + //unsigned int ra; + unsigned int rb; + unsigned int rc; + + rb=32; + while(1) + { + rb-=4; + rc=(d>>rb)&0xF; + if(rc>9) rc+=0x37; else rc+=0x30; + uart_putc(rc); + if(rb==0) break; + } + uart_putc(0x20); +} +//------------------------------------------------------------------------ +void hexstring ( unsigned int d ) +{ + hexstrings(d); + uart_putc(0x0D); + uart_putc(0x0A); +} +//------------------------------------------------------------------------ +void uart_init ( void ) +{ + unsigned int ra; + + PUT32(AUX_ENABLES,1); + PUT32(AUX_MU_IER_REG,0); + PUT32(AUX_MU_CNTL_REG,0); + PUT32(AUX_MU_LCR_REG,3); + PUT32(AUX_MU_MCR_REG,0); + PUT32(AUX_MU_IER_REG,0); + PUT32(AUX_MU_IIR_REG,0xC6); + PUT32(AUX_MU_BAUD_REG,270); + ra=GET32(GPFSEL1); + ra&=~(7<<12); //gpio14 + ra|=2<<12; //alt5 + ra&=~(7<<15); //gpio15 + ra|=2<<15; //alt5 + PUT32(GPFSEL1,ra); + PUT32(GPPUD,0); + for(ra=0;ra<150;ra++) dummy(ra); + PUT32(GPPUDCLK0,(1<<14)|(1<<15)); + for(ra=0;ra<150;ra++) dummy(ra); + PUT32(GPPUDCLK0,0); + PUT32(AUX_MU_CNTL_REG,3); +} +//------------------------------------------------------------------------- +//------------------------------------------------------------------------- diff --git a/zlib/thumb/uncompr.c b/zlib/thumb/uncompr.c new file mode 100644 index 0000000..4f2d25c --- /dev/null +++ b/zlib/thumb/uncompr.c @@ -0,0 +1,59 @@ +/* uncompr.c -- decompress a memory buffer + * Copyright (C) 1995-2003, 2010 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#define ZLIB_INTERNAL +#include "zlib.h" + +/* =========================================================================== + Decompresses 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 large enough to hold the + entire uncompressed data. (The size of the uncompressed data must have + been saved previously by the compressor and transmitted to the decompressor + by some mechanism outside the scope of this compression library.) + Upon exit, destLen is the actual size of the compressed buffer. + + 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. +*/ +int ZEXPORT uncompress (dest, destLen, source, sourceLen) + Bytef *dest; + uIntf *destLen; + const Bytef *source; + uInt sourceLen; +{ + z_stream stream; + int err; + + stream.next_in = (Bytef*)source; + stream.avail_in = (uInt)sourceLen; + /* Check for source > 64K on 16-bit machine: */ + if ((uInt)stream.avail_in != sourceLen) return Z_BUF_ERROR; + + stream.next_out = dest; + stream.avail_out = (uInt)*destLen; + if ((uInt)stream.avail_out != *destLen) return Z_BUF_ERROR; + + stream.zalloc = (alloc_func)0; + stream.zfree = (free_func)0; + + err = inflateInit(&stream); + if (err != Z_OK) return err; + + err = inflate(&stream, Z_FINISH); + if (err != Z_STREAM_END) { + inflateEnd(&stream); + if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0)) + return Z_DATA_ERROR; + return err; + } + *destLen = stream.total_out; + + err = inflateEnd(&stream); + return err; +} diff --git a/zlib/thumb/vectors.s b/zlib/thumb/vectors.s new file mode 100644 index 0000000..01fdede --- /dev/null +++ b/zlib/thumb/vectors.s @@ -0,0 +1,41 @@ + +.globl _start +_start: + b reset + b hang + b hang + b hang + b hang + b hang + b hang + b hang + +reset: + mov sp,#0x200000 + bl thumb_start +hang: b hang + +.thumb +.thumb_func +thumb_start: + ldr r0,=notmain + bx r0 + + +.thumb_func +.globl PUT32 +PUT32: + str r1,[r0] + bx lr + +.thumb_func +.globl GET32 +GET32: + ldr r0,[r0] + bx lr + +.thumb_func +.globl dummy +dummy: + bx lr + diff --git a/zlib/thumb/zconf.h b/zlib/thumb/zconf.h new file mode 100644 index 0000000..2bd7c39 --- /dev/null +++ b/zlib/thumb/zconf.h @@ -0,0 +1,506 @@ +/* zconf.h -- configuration of the zlib compression library + * Copyright (C) 1995-2012 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#ifndef ZCONF_H +#define ZCONF_H + +/* + * If you *really* need a unique prefix for all types and library functions, + * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. + * Even better than compiling with -DZ_PREFIX would be to use configure to set + * this permanently in zconf.h using "./configure --zprefix". + */ +#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */ +# define Z_PREFIX_SET + +/* all linked symbols */ +# define _dist_code z__dist_code +# define _length_code z__length_code +# define _tr_align z__tr_align +# define _tr_flush_block z__tr_flush_block +# define _tr_init z__tr_init +# define _tr_stored_block z__tr_stored_block +# define _tr_tally z__tr_tally +# define adler32 z_adler32 +# define adler32_combine z_adler32_combine +# define adler32_combine64 z_adler32_combine64 +# ifndef Z_SOLO +# define compress z_compress +# define compress2 z_compress2 +# define compressBound z_compressBound +# endif +# define crc32 z_crc32 +# define crc32_combine z_crc32_combine +# define crc32_combine64 z_crc32_combine64 +# define deflate z_deflate +# define deflateBound z_deflateBound +# define deflateCopy z_deflateCopy +# define deflateEnd z_deflateEnd +# define deflateInit2_ z_deflateInit2_ +# define deflateInit_ z_deflateInit_ +# define deflateParams z_deflateParams +# define deflatePending z_deflatePending +# define deflatePrime z_deflatePrime +# define deflateReset z_deflateReset +# define deflateResetKeep z_deflateResetKeep +# define deflateSetDictionary z_deflateSetDictionary +# define deflateSetHeader z_deflateSetHeader +# define deflateTune z_deflateTune +# define deflate_copyright z_deflate_copyright +# define get_crc_table z_get_crc_table +# ifndef Z_SOLO +# define gz_error z_gz_error +# define gz_intmax z_gz_intmax +# define gz_strwinerror z_gz_strwinerror +# define gzbuffer z_gzbuffer +# define gzclearerr z_gzclearerr +# define gzclose z_gzclose +# define gzclose_r z_gzclose_r +# define gzclose_w z_gzclose_w +# define gzdirect z_gzdirect +# define gzdopen z_gzdopen +# define gzeof z_gzeof +# define gzerror z_gzerror +# define gzflush z_gzflush +# define gzgetc z_gzgetc +# define gzgetc_ z_gzgetc_ +# define gzgets z_gzgets +# define gzoffset z_gzoffset +# define gzoffset64 z_gzoffset64 +# define gzopen z_gzopen +# define gzopen64 z_gzopen64 +# ifdef _WIN32 +# define gzopen_w z_gzopen_w +# endif +# define gzprintf z_gzprintf +# define gzputc z_gzputc +# define gzputs z_gzputs +# define gzread z_gzread +# define gzrewind z_gzrewind +# define gzseek z_gzseek +# define gzseek64 z_gzseek64 +# define gzsetparams z_gzsetparams +# define gztell z_gztell +# define gztell64 z_gztell64 +# define gzungetc z_gzungetc +# define gzwrite z_gzwrite +# endif +# define inflate z_inflate +# define inflateBack z_inflateBack +# define inflateBackEnd z_inflateBackEnd +# define inflateBackInit_ z_inflateBackInit_ +# define inflateCopy z_inflateCopy +# define inflateEnd z_inflateEnd +# define inflateGetHeader z_inflateGetHeader +# define inflateInit2_ z_inflateInit2_ +# define inflateInit_ z_inflateInit_ +# define inflateMark z_inflateMark +# define inflatePrime z_inflatePrime +# define inflateReset z_inflateReset +# define inflateReset2 z_inflateReset2 +# define inflateSetDictionary z_inflateSetDictionary +# define inflateSync z_inflateSync +# define inflateSyncPoint z_inflateSyncPoint +# define inflateUndermine z_inflateUndermine +# define inflateResetKeep z_inflateResetKeep +# define inflate_copyright z_inflate_copyright +# define inflate_fast z_inflate_fast +# define inflate_table z_inflate_table +# ifndef Z_SOLO +# define uncompress z_uncompress +# endif +# define zError z_zError +# ifndef Z_SOLO +# define zcalloc z_zcalloc +# define zcfree z_zcfree +# endif +# define zlibCompileFlags z_zlibCompileFlags +# define zlibVersion z_zlibVersion + +/* all zlib typedefs in zlib.h and zconf.h */ +# define Byte z_Byte +# define Bytef z_Bytef +# define alloc_func z_alloc_func +# define charf z_charf +# define free_func z_free_func +# ifndef Z_SOLO +# define gzFile z_gzFile +# endif +# define gz_header z_gz_header +# define gz_headerp z_gz_headerp +# define in_func z_in_func +# define intf z_intf +# define out_func z_out_func +# define uInt z_uInt +# define uIntf z_uIntf +# define uInt z_uInt +# define uIntf z_uIntf +# define voidp z_voidp +# define voidpc z_voidpc +# define voidpf z_voidpf + +/* all zlib structs in zlib.h and zconf.h */ +# define gz_header_s z_gz_header_s +# define internal_state z_internal_state + +#endif + +#if defined(__MSDOS__) && !defined(MSDOS) +# define MSDOS +#endif +#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) +# define OS2 +#endif +#if defined(_WINDOWS) && !defined(WINDOWS) +# define WINDOWS +#endif +#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) +# ifndef WIN32 +# define WIN32 +# endif +#endif +#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) +# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) +# ifndef SYS16BIT +# define SYS16BIT +# endif +# endif +#endif + +/* + * Compile with -DMAXSEG_64K if the alloc function cannot allocate more + * than 64k bytes at a time (needed on systems with 16-bit int). + */ +#ifdef SYS16BIT +# define MAXSEG_64K +#endif +#ifdef MSDOS +# define UNALIGNED_OK +#endif + +#ifdef __STDC_VERSION__ +# ifndef STDC +# define STDC +# endif +# if __STDC_VERSION__ >= 199901L +# ifndef STDC99 +# define STDC99 +# endif +# endif +#endif +#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) +# define STDC +#endif +#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) +# define STDC +#endif +#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) +# define STDC +#endif +#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) +# define STDC +#endif + +#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ +# define STDC +#endif + +#ifndef STDC +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const /* note: need a more gentle solution here */ +# endif +#endif + +#if defined(ZLIB_CONST) && !defined(z_const) +# define z_const const +#else +# define z_const +#endif + +/* Some Mac compilers merge all .h files incorrectly: */ +#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) +# define NO_DUMMY_DECL +#endif + +/* Maximum value for memLevel in deflateInit2 */ +#ifndef MAX_MEM_LEVEL +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif +#endif + +/* Maximum value for windowBits in deflateInit2 and inflateInit2. + * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files + * created by gzip. (Files created by minigzip can still be extracted by + * gzip.) + */ +#ifndef MAX_WBITS +# define MAX_WBITS 15 /* 32K LZ77 window */ +#endif + +/* The memory requirements for deflate are (in bytes): + (1 << (windowBits+2)) + (1 << (memLevel+9)) + that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) + plus a few kilobytes for small objects. For example, if you want to reduce + the default memory requirements from 256K to 128K, compile with + make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" + Of course this will generally degrade compression (there's no free lunch). + + The memory requirements for inflate are (in bytes) 1 << windowBits + that is, 32K for windowBits=15 (default value) plus a few kilobytes + for small objects. +*/ + + /* Type declarations */ + +#ifndef OF /* function prototypes */ +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif +#endif + +#ifndef Z_ARG /* function prototypes for stdarg */ +# if defined(STDC) || defined(Z_HAVE_STDARG_H) +# define Z_ARG(args) args +# else +# define Z_ARG(args) () +# endif +#endif + +/* The following definitions for FAR are needed only for MSDOS mixed + * model programming (small or medium model with some far allocations). + * This was tested only with MSC; for other MSDOS compilers you may have + * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, + * just define FAR to be empty. + */ +#ifdef SYS16BIT +# if defined(M_I86SM) || defined(M_I86MM) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +# endif +# if (defined(__SMALL__) || defined(__MEDIUM__)) + /* Turbo C small or medium model */ +# define SMALL_MEDIUM +# ifdef __BORLANDC__ +# define FAR _far +# else +# define FAR far +# endif +# endif +#endif + +#if defined(WINDOWS) || defined(WIN32) + /* If building or using zlib as a DLL, define ZLIB_DLL. + * This is not mandatory, but it offers a little performance increase. + */ +# ifdef ZLIB_DLL +# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) +# ifdef ZLIB_INTERNAL +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +# endif +# endif /* ZLIB_DLL */ + /* If building or using zlib with the WINAPI/WINAPIV calling convention, + * define ZLIB_WINAPI. + * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. + */ +# ifdef ZLIB_WINAPI +# ifdef FAR +# undef FAR +# endif +# include + /* No need for _export, use ZLIB.DEF instead. */ + /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR CDECL +# endif +# endif +#endif + +#if defined (__BEOS__) +# ifdef ZLIB_DLL +# ifdef ZLIB_INTERNAL +# define ZEXPORT __declspec(dllexport) +# define ZEXPORTVA __declspec(dllexport) +# else +# define ZEXPORT __declspec(dllimport) +# define ZEXPORTVA __declspec(dllimport) +# endif +# endif +#endif + +#ifndef ZEXTERN +# define ZEXTERN extern +#endif +#ifndef ZEXPORT +# define ZEXPORT +#endif +#ifndef ZEXPORTVA +# define ZEXPORTVA +#endif + +#ifndef FAR +# define FAR +#endif + +#if !defined(__MACTYPES__) +typedef unsigned char Byte; /* 8 bits */ +#endif +//typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned int uInt; /* 32 bits or more */ + +#ifdef SMALL_MEDIUM + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR +#else + typedef Byte FAR Bytef; +#endif +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; +//typedef uInt FAR uIntf; + +#ifdef STDC + typedef void const *voidpc; + typedef void FAR *voidpf; + typedef void *voidp; +#else + typedef Byte const *voidpc; + typedef Byte FAR *voidpf; + typedef Byte *voidp; +#endif + +/* ./configure may #define Z_U4 here */ + +#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC) +//# include +# if (UINT_MAX == 0xffffffffUL) +# define Z_U4 unsigned +# else +# if (uInt_MAX == 0xffffffffUL) +# define Z_U4 unsigned int +# else +# if (USHRT_MAX == 0xffffffffUL) +# define Z_U4 unsigned short +# endif +# endif +# endif +#endif + +#ifdef Z_U4 + typedef Z_U4 z_crc_t; +#else + typedef unsigned int z_crc_t; +#endif + +#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ +# define Z_HAVE_UNISTD_H +#endif + +#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */ +# define Z_HAVE_STDARG_H +#endif + +#ifdef STDC +# ifndef Z_SOLO +//**/# include /* for off_t */ +# endif +#endif + +#ifdef _WIN32 +# include /* for wchar_t */ +#endif + +/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and + * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even + * though the former does not conform to the LFS document), but considering + * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as + * equivalently requesting no 64-bit operations + */ +#if defined(LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1 +# undef _LARGEFILE64_SOURCE +#endif + +#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H) +# define Z_HAVE_UNISTD_H +#endif +#ifndef Z_SOLO +# if defined(Z_HAVE_UNISTD_H) || defined(LARGEFILE64_SOURCE) +# include /* for SEEK_*, off_t, and _LFS64_LARGEFILE */ +# ifdef VMS +# include /* for off_t */ +# endif +# ifndef z_off_t +# define z_off_t off_t +# endif +# endif +#endif + +#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0 +# define Z_LFS64 +#endif + +#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64) +# define Z_LARGE64 +#endif + +#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64) +# define Z_WANT64 +#endif + +#if !defined(SEEK_SET) && !defined(Z_SOLO) +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +#endif + +#ifndef z_off_t +# define z_off_t int +#endif + +#if !defined(_WIN32) && defined(Z_LARGE64) +# define z_off64_t off64_t +#else +# if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO) +# define z_off64_t __int64 +# else +# define z_off64_t z_off_t +# endif +#endif + +/* MVS linker does not support external names larger than 8 bytes */ +#if defined(__MVS__) + #pragma map(deflateInit_,"DEIN") + #pragma map(deflateInit2_,"DEIN2") + #pragma map(deflateEnd,"DEEND") + #pragma map(deflateBound,"DEBND") + #pragma map(inflateInit_,"ININ") + #pragma map(inflateInit2_,"ININ2") + #pragma map(inflateEnd,"INEND") + #pragma map(inflateSync,"INSY") + #pragma map(inflateSetDictionary,"INSEDI") + #pragma map(compressBound,"CMBND") + #pragma map(inflate_table,"INTABL") + #pragma map(inflate_fast,"INFA") + #pragma map(inflate_copyright,"INCOPY") +#endif + +#endif /* ZCONF_H */ diff --git a/zlib/thumb/zlib.h b/zlib/thumb/zlib.h new file mode 100644 index 0000000..dbacc8f --- /dev/null +++ b/zlib/thumb/zlib.h @@ -0,0 +1,1744 @@ +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.2.7, May 2nd, 2012 + + Copyright (C) 1995-2012 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 http://tools.ietf.org/html/rfc1950 + (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). +*/ + +#ifndef ZLIB_H +#define ZLIB_H + +#include "zconf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ZLIB_VERSION "1.2.7" +#define ZLIB_VERNUM 0x1270 +#define ZLIB_VER_MAJOR 1 +#define ZLIB_VER_MINOR 2 +#define ZLIB_VER_REVISION 7 +#define ZLIB_VER_SUBREVISION 0 + +/* + 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, + 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 compressed data format used by default 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 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. + + This library can optionally read and write gzip streams in memory as well. + + 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. + + 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. +*/ + +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address)); + +struct internal_state; + +typedef struct z_stream_s { + z_const Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uInt total_in; /* total number of input bytes read so far */ + + Bytef *next_out; /* next output byte should be put there */ + uInt avail_out; /* remaining free space at next_out */ + uInt total_out; /* total number of bytes output so far */ + + z_const char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *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: binary or text */ + uInt adler; /* adler32 value of the uncompressed data */ + uInt reserved; /* reserved for future use */ +} z_stream; + +typedef z_stream FAR *z_streamp; + +/* + gzip header information passed to and from zlib routines. See RFC 1952 + for more details on the meanings of these fields. +*/ +typedef struct gz_header_s { + int text; /* true if compressed data believed to be text */ + uInt time; /* modification time */ + int xflags; /* extra flags (not used when writing a gzip file) */ + int os; /* operating system */ + Bytef *extra; /* pointer to extra field or Z_NULL if none */ + uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ + uInt extra_max; /* space at extra (only when reading header) */ + Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ + uInt name_max; /* space at name (only when reading header) */ + Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ + uInt comm_max; /* space at comment (only when reading header) */ + int hcrc; /* true if there was or will be a header crc */ + int done; /* true when done reading gzip header (not used + when writing a gzip file) */ +} gz_header; + +typedef gz_header FAR *gz_headerp; + +/* + 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. + + On 16-bit systems, the functions zalloc and zfree must be able to allocate + exactly 65536 bytes, but will not be required to allocate more than this if + the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, pointers + returned by zalloc for objects of exactly 65536 bytes *must* have their + offset normalized to zero. The default allocation function provided by this + library ensures this (see zutil.c). To reduce memory requirements and avoid + any allocation of 64K objects, at the expense of compression ratio, compile + the library with -DMAX_WBITS=14 (see zconf.h). + + 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). +*/ + + /* 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 +/* Allowed flush values; see deflate() and inflate() below for details */ + +#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) +/* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ + +#define Z_NO_COMPRESSION 0 +#define Z_BEST_SPEED 1 +#define Z_BEST_COMPRESSION 9 +#define Z_DEFAULT_COMPRESSION (-1) +/* compression levels */ + +#define Z_FILTERED 1 +#define Z_HUFFMAN_ONLY 2 +#define Z_RLE 3 +#define Z_FIXED 4 +#define Z_DEFAULT_STRATEGY 0 +/* compression strategy; see deflateInit2() below for details */ + +#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 +/* 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) */ + +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ + +#define zlib_version zlibVersion() +/* for compatibility with versions < 1.0.2 */ + + + /* basic functions */ + +ZEXTERN const char * ZEXPORT zlibVersion OF((void)); +/* The application can compare zlibVersion and ZLIB_VERSION for consistency. + If the first character differs, the library code actually used is not + compatible with the zlib.h header file used by the application. 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 + zalloc, zfree and opaque must be initialized before by the caller. If + zalloc and zfree are set to Z_NULL, deflateInit updates them to use default + allocation functions. + + The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: + 1 gives best speed, 9 gives best compression, 0 gives no compression at all + (the input data is simply copied a block at a time). Z_DEFAULT_COMPRESSION + requests a default compromise between speed and compression (currently + equivalent to level 6). + + deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if level is not a valid compression level, or + Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible + with the version assumed by the caller (ZLIB_VERSION). msg is set to null + if there is no error message. deflateInit does not perform any compression: + this will be done by deflate(). +*/ + + +ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); +/* + deflate compresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce + some output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. deflate performs one or both of the + following actions: + + - Compress 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 and avail_in are updated and + processing will resume at this point for the next call of deflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. This action is forced if the parameter flush is non zero. + Forcing flush frequently degrades the compression ratio, so this parameter + should be set only when necessary (in interactive applications). Some + output may be provided even if flush is not set. + + Before the call of deflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming more + output, and updating avail_in or avail_out accordingly; avail_out should + never be zero before the call. The application can consume the compressed + output when it wants, for example when the output buffer is full (avail_out + == 0), or after each call of deflate(). If deflate 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. + + Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to + decide how much data to accumulate before producing output, in order to + maximize compression. + + If the parameter flush is set to Z_SYNC_FLUSH, all pending output is + flushed to the output buffer and the output is aligned on a byte boundary, so + that the decompressor can get all input data available so far. (In + particular avail_in is zero after the call if enough output space has been + provided before the call.) Flushing may degrade compression for some + compression algorithms and so it should be used only when necessary. This + completes the current deflate block and follows it with an empty stored block + that is three bits plus filler bits to the next byte, followed by four bytes + (00 00 ff ff). + + If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the + output buffer, but the output is not aligned to a byte boundary. All of the + input data so far will be available to the decompressor, as for Z_SYNC_FLUSH. + This completes the current deflate block and follows it with an empty fixed + codes block that is 10 bits long. This assures that enough bytes are output + in order for the decompressor to finish the block before the empty fixed code + block. + + If flush is set to Z_BLOCK, a deflate block is completed and emitted, as + for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to + seven bits of the current block are held to be written as the next byte after + the next deflate block is completed. In this case, the decompressor may not + be provided enough bits at this point in order to complete decompression of + the data provided so far to the compressor. It may need to wait for the next + block to be emitted. This is for advanced applications that need to control + the emission of deflate blocks. + + If flush is set to Z_FULL_FLUSH, all output is flushed as with + Z_SYNC_FLUSH, and the compression state is reset so that decompression can + restart from this point if previous compressed data has been damaged or if + random access is desired. Using Z_FULL_FLUSH too often can seriously degrade + compression. + + 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). 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 was + enough output space; if deflate returns with Z_OK, this function must be + called again with Z_FINISH and more output space (updated avail_out) but no + 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 the + value returned by deflateBound (see below). Then deflate is guaranteed to + return Z_STREAM_END. If not enough output space is provided, deflate will + not return Z_STREAM_END, and it must be called again as described above. + + deflate() sets strm->adler to the adler32 checksum of all input read + so far (that is, total_in bytes). + + deflate() may update strm->data_type if it can make a good guess about + the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered + binary. This field is only for information purposes and does not affect the + compression algorithm in any manner. + + deflate() returns Z_OK if some progress has been made (more input + processed or more output produced), Z_STREAM_END if all input has been + 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 Z_NULL), Z_BUF_ERROR if no progress is possible + (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. +*/ + + +ZEXTERN int ZEXPORT deflateEnd OF((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. + + deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the + stream state was inconsistent, Z_DATA_ERROR if the stream was freed + prematurely (some input or output was discarded). In the error case, msg + may be set but then points to a static string (which must not be + deallocated). +*/ + + +/* +ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); + + Initializes the internal stream state for decompression. The fields + next_in, avail_in, zalloc, zfree and opaque must be initialized before by + the caller. If next_in is not Z_NULL and avail_in is large enough (the + exact value depends on the compression method), inflateInit determines the + compression method from the zlib header and allocates all data structures + accordingly; otherwise the allocation will be deferred to the first call of + inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to + use default allocation functions. + + inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller, or Z_STREAM_ERROR if the parameters are + invalid, such as a null pointer to the structure. msg is set to null if + there is no error message. inflateInit does not perform any decompression + apart from possibly reading the zlib header if present: actual decompression + will be done by inflate(). (So next_in and avail_in may be modified, but + next_out and avail_out are unused and unchanged.) The current implementation + of inflateInit() does not process any header information -- that is deferred + until inflate() is called. +*/ + + +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 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. + + The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH, + Z_BLOCK, or Z_TREES. 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 gets 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. data_type is set as noted here every time inflate() returns for all + flush options, and so can be used to determine the amount of currently + consumed input in bits. + + The Z_TREES option behaves as Z_BLOCK does, but it also returns when the + end of each deflate block header is reached, before any actual data in that + block is decoded. This allows the caller to determine the length of the + deflate block header for later use in random access within a deflate block. + 256 is added to the value of strm->data_type when inflate() returns + immediately after reaching the end of the deflate block header. + + 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 of the uncompressed data for the + operation to complete. (The size of the uncompressed data may have been + saved by the compressor for this purpose.) The use of Z_FINISH is not + required to perform an inflation in one step. However it may be used to + inform inflate that a faster approach can be used for the single inflate() + call. Z_FINISH also informs inflate to not maintain a sliding window if the + stream completes, which reduces inflate's memory footprint. If the stream + does not complete, either because not all of the stream is provided or not + enough output space is provided, then a sliding window will be allocated and + inflate() can be called again to continue the operation as if Z_NO_FLUSH had + been used. + + 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 effects of the flush parameter in this implementation are + on the return value of inflate() as noted below, when inflate() returns early + when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of + memory for a sliding window when Z_FINISH is used. + + If a preset dictionary is needed after this call (see inflateSetDictionary + below), inflate sets strm->adler to the Adler-32 checksum of the dictionary + chosen by the compressor and returns Z_NEED_DICT; otherwise it sets + strm->adler to the Adler-32 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() can decompress and check either zlib-wrapped or gzip-wrapped + deflate data. The header type is detected automatically, if requested when + initializing with inflateInit2(). 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. When processing + gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output + producted so far. The CRC-32 is checked against the gzip 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 check + value), Z_STREAM_ERROR if the stream structure was inconsistent (for example + next_in or next_out was Z_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. +*/ + + +ZEXTERN int ZEXPORT inflateEnd OF((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. +*/ + +/* +ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, + int level, + int method, + int windowBits, + int memLevel, + int strategy)); + + This is another version of deflateInit with more compression options. The + fields next_in, zalloc, zfree and opaque must be initialized before by the + caller. + + The method parameter is the compression method. It must be Z_DEFLATED in + 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 + 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). If a + gzip stream is being written, strm->adler is a crc32 instead of an adler32. + + 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 for + optimal speed. The default value is 8. See zconf.h for total memory usage + as a function of windowBits and memLevel. + + 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), 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_STRATEGY 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. + Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler + decoder for special applications. + + deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid + method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is + incompatible with the version assumed by the caller (ZLIB_VERSION). 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)); +/* + Initializes the compression dictionary from the given byte sequence + without producing any compressed output. When using the zlib format, this + function must be called immediately after deflateInit, deflateInit2 or + deflateReset, and before any call of deflate. When doing raw deflate, this + function must be called either before any call of deflate, or immediately + after the completion of a deflate block, i.e. after all input has been + consumed and all output has been delivered when using any of the flush + options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH. The + compressor and decompressor must use exactly the same dictionary (see + inflateSetDictionary). + + The dictionary should consist of strings (byte sequences) that are likely + to be encountered later in the data to be compressed, with the most commonly + used strings preferably put towards the end of the dictionary. Using a + dictionary is most useful when the data to be compressed is short and can be + predicted with good accuracy; the data can then be compressed better than + with the default empty dictionary. + + Depending on the size of the compression data structures selected by + deflateInit or deflateInit2, a part of the dictionary may in effect be + discarded, for example if the dictionary is larger than the window size + provided in deflateInit or deflateInit2. Thus the strings most likely to be + useful should be put at the end of the dictionary, not at the front. In + addition, the current implementation of deflate will use at most the window + size minus 262 bytes of the provided dictionary. + + 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 + applies to the whole dictionary even if only a subset of the dictionary is + 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 (e.g. dictionary being Z_NULL) or the stream state is + inconsistent (for example if deflate has already been called for this stream + or if not at a block boundary for raw deflate). deflateSetDictionary does + not perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateCopy 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 several compression strategies will be + tried, for example when there are several ways of pre-processing the input + data with a filter. The streams that will be discarded should then be freed + by calling deflateEnd. Note that deflateCopy duplicates the internal + compression state which can be quite large, so this strategy is slow and can + consume lots of memory. + + deflateCopy 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 Z_NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); +/* + This function is equivalent to deflateEnd followed by deflateInit, + but does not free and reallocate all the internal compression state. The + stream will keep the same compression level and any other attributes that + may have been set by deflateInit2. + + deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being Z_NULL). +*/ + +ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, + 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 + used to switch between compression and straight copy of the input data, or + to switch to a different kind of input data requiring a different strategy. + If the compression level is changed, the input available so far is + compressed with the old level (and may be flushed); the new level will take + effect only at the next call of deflate(). + + Before the call of deflateParams, the stream state must be set as for + a call of deflate(), since the currently available input may have to be + compressed and flushed. In particular, strm->avail_out must be non-zero. + + deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source + stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if + strm->avail_out was zero. +*/ + +ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, + int good_length, + int max_lazy, + int nice_length, + int max_chain)); +/* + Fine tune deflate's internal compression parameters. This should only be + used by someone who understands the algorithm used by zlib's deflate for + searching for the best matching string, and even then only by the most + fanatic optimizer trying to squeeze out the last compressed bit for their + specific input data. Read the deflate.c source code for the meaning of the + max_lazy, good_length, nice_length, and max_chain parameters. + + deflateTune() can be called after deflateInit() or deflateInit2(), and + returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. + */ + +ZEXTERN uInt ZEXPORT deflateBound OF((z_streamp strm, + uInt sourceLen)); +/* + deflateBound() returns an upper bound on the compressed size after + deflation of sourceLen bytes. It must be called after deflateInit() or + deflateInit2(), and after deflateSetHeader(), if used. This would be used + to allocate an output buffer for deflation in a single pass, and so would be + called before deflate(). If that first deflate() call is provided the + sourceLen input bytes, an output buffer allocated to the size returned by + deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed + to return Z_STREAM_END. Note that it is possible for the compressed size to + be larger than the value returned by deflateBound() if flush options other + than Z_FINISH or Z_NO_FLUSH are used. +*/ + +ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, + unsigned *pending, + int *bits)); +/* + deflatePending() returns the number of bytes and bits of output that have + been generated, but not yet provided in the available output. The bytes not + provided would be due to the available output space having being consumed. + The number of bits of output not provided are between 0 and 7, where they + await more bits to join them in order to fill out a full byte. If pending + or bits are Z_NULL, then those values are not set. + + deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. + */ + +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, Z_BUF_ERROR if there was not enough + room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the + source stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, + gz_headerp head)); +/* + deflateSetHeader() provides gzip header information for when a gzip + stream is requested by deflateInit2(). deflateSetHeader() may be called + after deflateInit2() or deflateReset() and before the first call of + deflate(). The text, time, os, extra field, name, and comment information + in the provided gz_header structure are written to the gzip header (xflag is + ignored -- the extra flags are set according to the compression level). The + caller must assure that, if not Z_NULL, name and comment are terminated with + a zero byte, and that if extra is not Z_NULL, that extra_len bytes are + available there. If hcrc is true, a gzip header crc is included. Note that + the current versions of the command-line version of gzip (up through version + 1.3.x) do not support header crc's, and will report that it is a "multi-part + gzip file" and give up. + + If deflateSetHeader is not used, the default gzip header has text false, + the time set to zero, and os set to 255, with no extra, name, or comment + fields. The gzip header is returned to the default state by deflateReset(). + + deflateSetHeader 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)); + + This is another version of inflateInit with an extra parameter. The + fields next_in, avail_in, zalloc, zfree and opaque must be initialized + before by the caller. + + 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. 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. + + windowBits can also be zero to request that inflate use the window size in + the zlib header of the compressed stream. + + 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). If a gzip stream is being decoded, strm->adler is a + crc32 instead of an adler32. + + inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller, or Z_STREAM_ERROR if the parameters are + invalid, such as a null pointer to the structure. msg is set to null if + there is no error message. inflateInit2 does not perform any decompression + apart from possibly reading the zlib header if present: actual decompression + will be done by inflate(). (So next_in and avail_in may be modified, but + next_out and avail_out are unused and unchanged.) The current implementation + of inflateInit2() does not process any header information -- that is + deferred until inflate() is called. +*/ + +ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, + const Bytef *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 that call returned Z_NEED_DICT. The dictionary chosen by the compressor + can be determined from the adler32 value returned by that call of inflate. + The compressor and decompressor must use exactly the same dictionary (see + deflateSetDictionary). For raw inflate, this function can be called at any + time to set the dictionary. If the provided dictionary is smaller than the + window and there is already data in the window, then the provided dictionary + will amend what's there. The application must insure that the dictionary + that was used for compression is provided. + + inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a + parameter is invalid (e.g. dictionary being Z_NULL) 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(). +*/ + +ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); +/* + Skips invalid compressed data until a possible full flush point (see above + for the description of deflate with Z_FULL_FLUSH) can be found, or until all + available input is skipped. No output is provided. + + inflateSync searches for a 00 00 FF FF pattern in the compressed data. + All full flush points have this pattern, but not all occurences of this + pattern are full flush points. + + inflateSync returns Z_OK if a possible 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. +*/ + +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 Z_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, + 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 Z_NULL). +*/ + +ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, + int windowBits)); +/* + This function is the same as inflateReset, but it also permits changing + the wrap and window size requests. The windowBits parameter is interpreted + the same as it is for inflateInit2. + + inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being Z_NULL), or if + the windowBits parameter is invalid. +*/ + +ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, + int bits, + int value)); +/* + This function inserts bits in the inflate input stream. The intent is + that this function is used to start inflating at a bit position in the + middle of a byte. The provided bits will be used before any bytes are used + from next_in. This function should only be used with raw inflate, and + should be used before the first inflate() call after inflateInit2() or + inflateReset(). bits must be less than or equal to 16, and that many of the + least significant bits of value will be inserted in the input. + + If bits is negative, then the input stream bit buffer is emptied. Then + inflatePrime() can be called again to put bits in the buffer. This is used + to clear out bits leftover after feeding inflate a block description prior + to feeding inflate codes. + + inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT inflateMark OF((z_streamp strm)); +/* + This function returns two values, one in the lower 16 bits of the return + value, and the other in the remaining upper bits, obtained by shifting the + return value down 16 bits. If the upper value is -1 and the lower value is + zero, then inflate() is currently decoding information outside of a block. + If the upper value is -1 and the lower value is non-zero, then inflate is in + the middle of a stored block, with the lower value equaling the number of + bytes from the input remaining to copy. If the upper value is not -1, then + it is the number of bits back from the current bit position in the input of + the code (literal or length/distance pair) currently being processed. In + that case the lower value is the number of bytes already emitted for that + code. + + A code is being processed if inflate is waiting for more input to complete + decoding of the code, or if it has completed decoding but is waiting for + more output space to write the literal or match data. + + inflateMark() is used to mark locations in the input data for random + access, which may be at bit positions, and to note those cases where the + output of a code may span boundaries of random access blocks. The current + location in the input stream can be determined from avail_in and data_type + as noted in the description for the Z_BLOCK flush parameter for inflate. + + inflateMark returns the value noted above or -1 << 16 if the provided + source stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, + gz_headerp head)); +/* + inflateGetHeader() requests that gzip header information be stored in the + provided gz_header structure. inflateGetHeader() may be called after + inflateInit2() or inflateReset(), and before the first call of inflate(). + As inflate() processes the gzip stream, head->done is zero until the header + is completed, at which time head->done is set to one. If a zlib stream is + being decoded, then head->done is set to -1 to indicate that there will be + no gzip header information forthcoming. Note that Z_BLOCK or Z_TREES can be + used to force inflate() to return immediately after header processing is + complete and before any actual data is decompressed. + + The text, time, xflags, and os fields are filled in with the gzip header + contents. hcrc is set to true if there is a header CRC. (The header CRC + was valid if done is set to one.) If extra is not Z_NULL, then extra_max + contains the maximum number of bytes to write to extra. Once done is true, + extra_len contains the actual extra field length, and extra contains the + extra field, or that field truncated if extra_max is less than extra_len. + If name is not Z_NULL, then up to name_max characters are written there, + terminated with a zero unless the length is greater than name_max. If + comment is not Z_NULL, then up to comm_max characters are written there, + terminated with a zero unless the length is greater than comm_max. When any + of extra, name, or comment are not Z_NULL and the respective field is not + present in the header, then that field is set to Z_NULL to signal its + absence. This allows the use of deflateSetHeader() with the returned + structure to duplicate the header. However if those fields are set to + allocated memory, then the application will need to save those pointers + elsewhere so that they can be eventually freed. + + If inflateGetHeader is not used, then the header information is simply + discarded. The header is always checked for validity, including the header + CRC if present. inflateReset() will reset the process to discard the header + information. The application would need to call inflateGetHeader() again to + retrieve the header from the next gzip stream. + + inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +/* +ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp 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 parameters 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_streamp 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_in 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_streamp 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 uInt 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 uInt + 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) + */ + +#ifndef Z_SOLO + + /* utility functions */ + +/* + The following utility functions are implemented on top of the basic + stream-oriented functions. To simplify the interface, some default options + are assumed (compression level and memory usage, standard memory allocation + functions). The source code of these utility functions can be modified if + you need special options. +*/ + +ZEXTERN int ZEXPORT compress OF((Bytef *dest, uIntf *destLen, + const Bytef *source, uInt sourceLen)); +/* + 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 the value returned by + compressBound(sourceLen). Upon exit, destLen is the actual size of the + compressed buffer. + + compress 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. +*/ + +ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uIntf *destLen, + const Bytef *source, uInt sourceLen, + int level)); +/* + 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 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 uInt ZEXPORT compressBound OF((uInt 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, uIntf *destLen, + const Bytef *source, uInt sourceLen)); +/* + Decompresses 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 large enough to hold the entire + uncompressed data. (The size of the uncompressed data must have been saved + previously by the compressor and transmitted to the decompressor by some + mechanism outside the scope of this compression library.) Upon exit, destLen + is the actual size of the uncompressed buffer. + + 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 or incomplete. In + the case where there is not enough room, uncompress() will fill the output + buffer with the uncompressed data up to that point. +*/ + + /* gzip file access functions */ + +/* + This library supports reading and writing files in gzip (.gz) format 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. +*/ + +typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */ + +/* +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", 'R' for run-length encoding as in "wb1R", or 'F' + for fixed code compression as in "wb9F". (See the description of + deflateInit2 for more information about the strategy parameter.) 'T' will + request transparent writing or appending with no compression and not using + the gzip format. + + "a" can be used instead of "w" to request that the gzip stream that will + be written be appended to the file. "+" will result in an error, since + reading and writing to the same gzip file is not supported. The addition of + "x" when writing will create the file exclusively, which fails if the file + already exists. On systems that support it, the addition of "e" when + reading or writing will set the flag to close the file on an execve() call. + + These functions, as well as gzip, will read and decode a sequence of gzip + streams in a file. The append function of gzopen() can be used to create + such a file. (Also see gzflush() for another way to do this.) When + appending, gzopen does not test whether the file begins with a gzip stream, + nor does it look for the end of the gzip streams to begin appending. gzopen + will simply append a gzip stream to the existing file. + + 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. When + reading, this will be detected automatically by looking for the magic two- + byte gzip header. + + gzopen returns NULL if the file could not be opened, if there was + insufficient memory to allocate the gzFile state, or if an invalid mode was + specified (an 'r', 'w', or 'a' was not provided, or '+' was provided). + errno can be checked to determine if the reason gzopen failed was that the + file could not be opened. +*/ + +ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); +/* + gzdopen associates a gzFile with the file descriptor fd. File descriptors + are obtained from calls like open, dup, creat, pipe or fileno (if the file + has been previously opened with fopen). The mode parameter is as in gzopen. + + The next call of gzclose on the returned gzFile will also close the file + descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor + fd. If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd, + mode);. The duplicated descriptor should be saved to avoid a leak, since + gzdopen does not close fd if it fails. If you are using fileno() to get the + file descriptor from a FILE *, then you will have to use dup() to avoid + double-close()ing the file descriptor. Both gzclose() and fclose() will + close the associated file descriptor, so they need to have different file + descriptors. + + gzdopen returns NULL if there was insufficient memory to allocate the + gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not + provided, or '+' was provided), or if fd is -1. The file descriptor is not + used until the next gz* read, write, seek, or close operation, so gzdopen + will not detect if fd is invalid (unless fd is -1). +*/ + +ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); +/* + Set the internal buffer size used by this library's functions. The + default buffer size is 8192 bytes. This function must be called after + gzopen() or gzdopen(), and before any other calls that read or write the + file. The buffer memory allocation is always deferred to the first read or + write. Two buffers are allocated, either both of the specified size when + writing, or one of the specified size and the other twice that size when + reading. A larger buffer size of, for example, 64K or 128K bytes will + noticeably increase the speed of decompression (reading). + + The new buffer size also affects the maximum length for gzprintf(). + + gzbuffer() returns 0 on success, or -1 on failure, such as being called + too late. +*/ + +ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); +/* + Dynamically update the compression level or strategy. See the description + of deflateInit2 for the meaning of these parameters. + + gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not + opened for writing. +*/ + +ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); +/* + Reads the given number of uncompressed bytes from the compressed file. If + the input file is not in gzip format, gzread copies the given number of + bytes into the buffer directly from the file. + + After reaching the end of a gzip stream in the input, gzread will continue + to read, looking for another gzip stream. Any number of gzip streams may be + concatenated in the input file, and will all be decompressed by gzread(). + If something other than a gzip stream is encountered after a gzip stream, + that remaining trailing garbage is ignored (and no error is returned). + + gzread can be used to read a gzip file that is being concurrently written. + Upon reaching the end of the input, gzread will return with the available + data. If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then + gzclearerr can be used to clear the end of file indicator in order to permit + gzread to be tried again. Z_OK indicates that a gzip stream was completed + on the last gzread. Z_BUF_ERROR indicates that the input file ended in the + middle of a gzip stream. Note that gzread does not return -1 in the event + of an incomplete gzip stream. This error is deferred until gzclose(), which + will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip + stream. Alternatively, gzerror can be used before gzclose to detect this + case. + + gzread returns the number of uncompressed bytes actually read, less than + len for end of file, or -1 for error. +*/ + +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 written or 0 in case of + error. +*/ + +ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...)); +/* + Converts, formats, and writes the arguments to the compressed file under + control of the format string, as in fprintf. gzprintf returns the number of + uncompressed bytes actually written, or 0 in case of error. The number of + uncompressed bytes written is limited to 8191, or one less than the buffer + size given to gzbuffer(). The caller should assure that this limit is not + exceeded. If it is exceeded, then gzprintf() will 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. This can be determined using + zlibCompileFlags(). +*/ + +ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +/* + Writes the given null-terminated string to the compressed file, excluding + the terminating null character. + + gzputs returns the number of characters written, or -1 in case of error. +*/ + +ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); +/* + Reads bytes from the compressed file until len-1 characters are read, or a + newline character is read and transferred to buf, or an end-of-file + condition is encountered. If any characters are read or if len == 1, the + string is terminated with a null character. If no characters are read due + to an end-of-file or len < 1, then the buffer is left untouched. + + gzgets returns buf which is a null-terminated string, or it returns NULL + for end-of-file or in case of error. If there was an error, the contents at + buf are indeterminate. +*/ + +ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); +/* + Writes c, converted to an unsigned char, into the compressed file. gzputc + returns the value that was written, or -1 in case of error. +*/ + +ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); +/* + Reads one byte from the compressed file. gzgetc returns this byte or -1 + in case of end of file or error. This is implemented as a macro for speed. + As such, it does not do all of the checking the other functions do. I.e. + it does not check to see if file is NULL, nor whether the structure file + points to has been clobbered or not. +*/ + +ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); +/* + Push one character back onto the stream to be read as the first character + on the next read. At least one character of push-back is allowed. + gzungetc() returns the character pushed, or -1 on failure. gzungetc() will + fail if c is -1, and may fail if a character has been pushed but not read + yet. If gzungetc is used immediately after gzopen or gzdopen, at least the + output buffer size of pushed characters is allowed. (See gzbuffer above.) + 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 flush + is as in the deflate() function. The return value is the zlib error number + (see function gzerror below). gzflush is only permitted when writing. + + If the flush parameter is Z_FINISH, the remaining data is written and the + gzip stream is completed in the output. If gzwrite() is called again, a new + gzip stream will be started in the output. gzread() is able to read such + concatented gzip streams. + + gzflush should be called only when strictly necessary because it will + degrade compression if called too often. +*/ + +/* +ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, + 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); + the value SEEK_END is not supported. + + If the file is opened for reading, this function is emulated but can be + extremely slow. If the file is opened for writing, only forward seeks are + supported; gzseek then compresses a sequence of zeroes up to the new + starting position. + + gzseek returns the resulting offset location as measured in bytes from + the beginning of the uncompressed stream, or -1 in case of error, in + particular if the file is opened for writing and the new starting position + would be before the current position. +*/ + +ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); +/* + Rewinds the given file. This function is supported only for reading. + + gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) +*/ + +/* +ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); + + Returns the starting position for the next gzread or gzwrite on the given + compressed file. This position represents a number of bytes in the + uncompressed data stream, and is zero when starting, even if appending or + reading a gzip stream from the middle of a file using gzdopen(). + + gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) +*/ + +/* +ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file)); + + Returns the current offset in the file being read or written. This offset + includes the count of bytes that precede the gzip stream, for example when + appending or when using gzdopen() for reading. When reading, the offset + does not include as yet unused buffered input. This information can be used + for a progress indicator. On error, gzoffset() returns -1. +*/ + +ZEXTERN int ZEXPORT gzeof OF((gzFile file)); +/* + Returns true (1) if the end-of-file indicator has been set while reading, + false (0) otherwise. Note that the end-of-file indicator is set only if the + read tried to go past the end of the input, but came up short. Therefore, + just like feof(), gzeof() may return false even if there is no more data to + read, in the event that the last read request was for the exact number of + bytes remaining in the input file. This will happen if the input file size + is an exact multiple of the buffer size. + + If gzeof() returns true, then the read functions will return no more data, + unless the end-of-file indicator is reset by gzclearerr() and the input file + has grown since the previous end of file was detected. +*/ + +ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); +/* + Returns true (1) if file is being copied directly while reading, or false + (0) if file is a gzip stream being decompressed. + + If the input file is empty, gzdirect() will return true, since the input + does not contain a gzip stream. + + If gzdirect() is used immediately after gzopen() or gzdopen() it will + cause buffers to be allocated to allow reading the file to determine if it + is a gzip file. Therefore if gzbuffer() is used, it should be called before + gzdirect(). + + When writing, gzdirect() returns true (1) if transparent writing was + requested ("wT" for the gzopen() mode), or false (0) otherwise. (Note: + gzdirect() is not needed when writing. Transparent writing must be + explicitly requested, so the application already knows the answer. When + linking statically, using gzdirect() will include all of the zlib code for + gzip file reading and decompression, which may not be desired.) +*/ + +ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +/* + Flushes all pending output if necessary, closes the compressed file and + deallocates the (de)compression state. Note that once file is closed, you + cannot call gzerror with file, since its structures have been deallocated. + gzclose must not be called more than once on the same file, just as free + must not be called more than once on the same allocation. + + gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a + file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the + last read ended in the middle of a gzip stream, or Z_OK on success. +*/ + +ZEXTERN int ZEXPORT gzclose_r OF((gzFile file)); +ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); +/* + Same as gzclose(), but gzclose_r() is only for use when reading, and + gzclose_w() is only for use when writing or appending. The advantage to + using these instead of gzclose() is that they avoid linking in zlib + compression or decompression code that is not used when only reading or only + writing respectively. If gzclose() is used, then both compression and + decompression code will be included the application when linking to a static + zlib library. +*/ + +ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); +/* + Returns the error message for the last error which occurred on the given + compressed file. errnum is set to zlib error number. If an error occurred + in the file system and not in the compression library, errnum is set to + Z_ERRNO and the application may consult errno to get the exact error code. + + The application must not modify the returned string. Future calls to + this function may invalidate the previously returned string. If file is + closed, then the string previously returned by gzerror will no longer be + available. + + gzerror() should be used to distinguish errors from end-of-file for those + functions above that do not distinguish those cases in their return values. +*/ + +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. +*/ + +#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. +*/ + +ZEXTERN uInt ZEXPORT adler32 OF((uInt adler, const Bytef *buf, uInt len)); +/* + Update a running Adler-32 checksum with the bytes buf[0..len-1] and + return the updated checksum. If buf is Z_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: + + uInt adler = adler32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + adler = adler32(adler, buffer, length); + } + if (adler != original_adler) error(); +*/ + +/* +ZEXTERN uInt ZEXPORT adler32_combine OF((uInt adler1, uInt adler2, + z_off_t len2)); + + Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 + and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for + each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of + seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. Note + that the z_off_t type (like off_t) is a signed integer. If len2 is + negative, the result has no meaning or utility. +*/ + +ZEXTERN uInt ZEXPORT crc32 OF((uInt crc, const Bytef *buf, uInt len)); +/* + Update a running CRC-32 with the bytes buf[0..len-1] and return the + updated CRC-32. If buf is Z_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: + + uInt crc = crc32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + crc = crc32(crc, buffer, length); + } + if (crc != original_crc) error(); +*/ + +/* +ZEXTERN uInt ZEXPORT crc32_combine OF((uInt crc1, uInt crc2, z_off_t len2)); + + Combine two CRC-32 check values into one. For two sequences of bytes, + seq1 and seq2 with lengths len1 and len2, CRC-32 check values were + calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32 + check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and + len2. +*/ + + + /* 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_ OF((z_streamp strm, int level, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, + int windowBits, int memLevel, + int strategy, const char *version, + 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_streamp strm, int windowBits, + unsigned char FAR *window, + const char *version, + int stream_size)); +#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)) + +#ifndef Z_SOLO + +/* gzgetc() macro and its supporting function and exposed data structure. Note + * that the real internal state is much larger than the exposed structure. + * This abbreviated structure exposes just enough for the gzgetc() macro. The + * user should not mess with these exposed elements, since their names or + * behavior could change in the future, perhaps even capriciously. They can + * only be used by the gzgetc() macro. You have been warned. + */ +struct gzFile_s { + unsigned have; + unsigned char *next; + z_off64_t pos; +}; +ZEXTERN int ZEXPORT gzgetc_ OF((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 OF((const char *, const char *)); + ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); + ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); + ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); + ZEXTERN uInt ZEXPORT adler32_combine64 OF((uInt, uInt, z_off64_t)); + ZEXTERN uInt ZEXPORT crc32_combine64 OF((uInt, uInt, 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 +# else +# define gzopen gzopen64 +# define gzseek gzseek64 +# define gztell gztell64 +# define gzoffset gzoffset64 +# define adler32_combine adler32_combine64 +# define crc32_combine crc32_combine64 +# endif +# ifndef Z_LARGE64 + ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); + ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int)); + ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile)); + ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile)); + ZEXTERN uInt ZEXPORT adler32_combine64 OF((uInt, uInt, z_off_t)); + ZEXTERN uInt ZEXPORT crc32_combine64 OF((uInt, uInt, z_off_t)); +# endif +#else + ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *)); + ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int)); + ZEXTERN z_off_t ZEXPORT gztell OF((gzFile)); + ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile)); + ZEXTERN uInt ZEXPORT adler32_combine OF((uInt, uInt, z_off_t)); + ZEXTERN uInt ZEXPORT crc32_combine OF((uInt, uInt, z_off_t)); +#endif + +#else /* Z_SOLO */ + + ZEXTERN uInt ZEXPORT adler32_combine OF((uInt, uInt, z_off_t)); + ZEXTERN uInt ZEXPORT crc32_combine OF((uInt, uInt, z_off_t)); + +#endif /* !Z_SOLO */ + +/* hack for buggy compilers */ +#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) + struct internal_state {int dummy;}; +#endif + +/* undocumented functions */ +ZEXTERN const char * ZEXPORT zError OF((int)); +ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp)); +ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void)); +ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); +ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp)); +ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp)); +#if defined(_WIN32) && !defined(Z_SOLO) +ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path, + const char *mode)); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* ZLIB_H */ diff --git a/zlib/thumb/zlibtest.c b/zlib/thumb/zlibtest.c new file mode 100644 index 0000000..db3e4fb --- /dev/null +++ b/zlib/thumb/zlibtest.c @@ -0,0 +1,111 @@ + +//------------------------------------------------------------------------- +//------------------------------------------------------------------------- +#include "testdata.h" +#include "zlib.h" + +#define ARM_TIMER_CTL 0x2000B408 +#define ARM_TIMER_CNT 0x2000B420 + +unsigned int heap_offset; +unsigned int complen; +unsigned int uncomplen; +unsigned char compressed[TESTDATALEN]; +unsigned char uncompressed[TESTDATALEN]; + +//------------------------------------------------------------------------- +extern void PUT32 ( unsigned int, unsigned int ); +extern unsigned int GET32 ( unsigned int ); +extern void dummy ( unsigned int ); +extern void * mkptr ( unsigned int ); +//------------------------------------------------------------------------ +void uart_init ( void ); +void hexstring ( unsigned int d ); +void hexstrings ( unsigned int d ); +//------------------------------------------------------------------------ +unsigned char *ZMEMCPY(unsigned char *dest, const unsigned char *src, unsigned int n) +{ + unsigned int ra; + for(ra=0;ra s2[j])-1; + } + return 0; +} + +void ZLIB_INTERNAL zmemzero(dest, len) + Bytef* dest; + uInt len; +{ + if (len == 0) return; + do { + *dest++ = 0; /* ??? to be unrolled */ + } while (--len != 0); +} +#endif + +#ifndef Z_SOLO + +#ifdef SYS16BIT + +#ifdef __TURBOC__ +/* Turbo C in 16-bit mode */ + +# define MY_ZCALLOC + +/* Turbo C malloc() does not allow dynamic allocation of 64K bytes + * and farmalloc(64K) returns a pointer with an offset of 8, so we + * must fix the pointer. Warning: the pointer must be put back to its + * original form in order to free it, use zcfree(). + */ + +#define MAX_PTR 10 +/* 10*64K = 640K */ + +local int next_ptr = 0; + +typedef struct ptr_table_s { + voidpf org_ptr; + voidpf new_ptr; +} ptr_table; + +local ptr_table table[MAX_PTR]; +/* This table is used to remember the original form of pointers + * to large buffers (64K). Such pointers are normalized with a zero offset. + * Since MSDOS is not a preemptive multitasking OS, this table is not + * protected from concurrent access. This hack doesn't work anyway on + * a protected system like OS/2. Use Microsoft C instead. + */ + +voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size) +{ + voidpf buf = opaque; /* just to make some compilers happy */ + ulg bsize = (ulg)items*size; + + /* If we allocate less than 65520 bytes, we assume that farmalloc + * will return a usable pointer which doesn't have to be normalized. + */ + if (bsize < 65520L) { + buf = farmalloc(bsize); + if (*(ush*)&buf != 0) return buf; + } else { + buf = farmalloc(bsize + 16L); + } + if (buf == NULL || next_ptr >= MAX_PTR) return NULL; + table[next_ptr].org_ptr = buf; + + /* Normalize the pointer to seg:0 */ + *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4; + *(ush*)&buf = 0; + table[next_ptr++].new_ptr = buf; + return buf; +} + +void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) +{ + int n; + if (*(ush*)&ptr != 0) { /* object < 64K */ + farfree(ptr); + return; + } + /* Find the original pointer */ + for (n = 0; n < next_ptr; n++) { + if (ptr != table[n].new_ptr) continue; + + farfree(table[n].org_ptr); + while (++n < next_ptr) { + table[n-1] = table[n]; + } + next_ptr--; + return; + } + ptr = opaque; /* just to make some compilers happy */ + Assert(0, "zcfree: ptr not found"); +} + +#endif /* __TURBOC__ */ + + +#ifdef M_I86 +/* Microsoft C in 16-bit mode */ + +# define MY_ZCALLOC + +#if (!defined(_MSC_VER) || (_MSC_VER <= 600)) +# define _halloc halloc +# define _hfree hfree +#endif + +voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size) +{ + if (opaque) opaque = 0; /* to make compiler happy */ + return _halloc((int)items, size); +} + +void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) +{ + if (opaque) opaque = 0; /* to make compiler happy */ + _hfree(ptr); +} + +#endif /* M_I86 */ + +#endif /* SYS16BIT */ + + +#ifndef MY_ZCALLOC /* Any system without a special alloc function */ + +#ifndef STDC +extern voidp malloc OF((uInt size)); +extern voidp calloc OF((uInt items, uInt size)); +extern void free OF((voidpf ptr)); +#endif + +voidpf ZLIB_INTERNAL zcalloc (opaque, items, size) + voidpf opaque; + unsigned items; + unsigned size; +{ + if (opaque) items += size - size; /* make compiler happy */ + return sizeof(uInt) > 2 ? (voidpf)ZMALLOC(items * size) : + (voidpf)ZCALLOC(items, size); +} + +void ZLIB_INTERNAL zcfree (opaque, ptr) + voidpf opaque; + voidpf ptr; +{ + free(ptr); + if (opaque) return; /* make compiler happy */ +} + +#endif /* MY_ZCALLOC */ + +#endif /* !Z_SOLO */ diff --git a/zlib/thumb/zutil.h b/zlib/thumb/zutil.h new file mode 100644 index 0000000..abcdf5a --- /dev/null +++ b/zlib/thumb/zutil.h @@ -0,0 +1,188 @@ +/* zutil.h -- internal interface and configuration of the compression library + * Copyright (C) 1995-2012 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +/* @(#) $Id$ */ + +#ifndef ZUTIL_H +#define ZUTIL_H + +#ifdef HAVE_HIDDEN +# define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) +#else +# define ZLIB_INTERNAL +#endif + +#include "zlib.h" + +#if defined(STDC) && !defined(Z_SOLO) +# if !(defined(_WIN32_WCE) && defined(_MSC_VER)) +# include +# endif +//# include +void *ZMEMCPY(void *dest, const void *src, int n); +void *ZMEMSET(void *s, int c, int n); +//# include +void *ZCALLOC(int nmemb, int size); +void *ZMALLOC(int size); +//void free(void *ptr); +#endif + +#ifdef Z_SOLO + typedef int ptrdiff_t; /* guess -- will be caught if guess is wrong */ +#endif + +#ifndef local +# define local static +#endif +/* compile with -Dlocal if your debugger can't find static symbols */ + +typedef unsigned char uch; +typedef uch FAR uchf; +typedef unsigned short ush; +typedef ush FAR ushf; +typedef unsigned int ulg; + +extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ +/* (size given to avoid silly warnings with Visual C++) */ + +#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 */ + +#ifndef DEF_WBITS +# define DEF_WBITS MAX_WBITS +#endif +/* default windowBits for decompression. MAX_WBITS is for compression only */ + +#if MAX_MEM_LEVEL >= 8 +# define DEF_MEM_LEVEL 8 +#else +# define DEF_MEM_LEVEL MAX_MEM_LEVEL +#endif +/* default memLevel */ + +#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 */ + +#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32)) +# define OS_CODE 0x00 +# ifndef Z_SOLO +# if defined(__TURBOC__) || defined(__BORLANDC__) +# if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__)) + /* Allow compilation with ANSI keywords only enabled */ + void _Cdecl farfree( void *block ); + void *_Cdecl farmalloc( unsigned int nbytes ); +# else +# include +# endif +# else /* MSC or DJGPP */ +# include +# endif +# endif +#endif + + +/* provide prototypes for these when building zlib without LFS */ +#if !defined(_WIN32) && (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0) + ZEXTERN uInt ZEXPORT adler32_combine64 OF((uInt, uInt, z_off_t)); + ZEXTERN uInt ZEXPORT crc32_combine64 OF((uInt, uInt, z_off_t)); +#endif + + /* common defaults */ + +#ifndef OS_CODE +# define OS_CODE 0x03 /* assume Unix */ +#endif + +#ifndef F_OPEN +# define F_OPEN(name, mode) fopen((name), (mode)) +#endif + + /* functions */ + +#if defined(pyr) || defined(Z_SOLO) +# define NO_MEMCPY +#endif +#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__) + /* Use our own functions for small and medium model with MSC <= 5.0. + * You may have to use the same strategy for Borland C (untested). + * The __SC__ check is for Symantec. + */ +# define NO_MEMCPY +#endif +#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY) +# define HAVE_MEMCPY +#endif +#ifdef HAVE_MEMCPY +# ifdef SMALL_MEDIUM /* MSDOS small or medium model */ +# define zmemcpy _fmemcpy +# define zmemcmp _fmemcmp +# define zmemzero(dest, len) _fmemset(dest, 0, len) +# else +# define zmemcpy ZMEMCPY +# define zmemcmp memcmp +# define zmemzero(dest, len) ZMEMSET(dest, 0, len) +# endif +#else + void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)); + int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len)); + void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len)); +#endif + +/* Diagnostic functions */ +#ifdef DEBUG +# include + extern int ZLIB_INTERNAL z_verbose; + extern void ZLIB_INTERNAL z_error OF((char *m)); +# define Assert(cond,msg) {if(!(cond)) z_error(msg);} +# define Trace(x) {if (z_verbose>=0) fprintf x ;} +# define Tracev(x) {if (z_verbose>0) fprintf x ;} +# define Tracevv(x) {if (z_verbose>1) fprintf x ;} +# define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;} +# define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;} +#else +# define Assert(cond,msg) +# define Trace(x) +# define Tracev(x) +# define Tracevv(x) +# define Tracec(c,x) +# define Tracecv(c,x) +#endif + +#ifndef Z_SOLO + voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items, + unsigned size)); + void ZLIB_INTERNAL zcfree OF((voidpf opaque, voidpf ptr)); +#endif + +#define ZALLOC(strm, items, size) \ + (*((strm)->zalloc))((strm)->opaque, (items), (size)) +#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr)) +#define TRY_FREE(s, p) {if (p) ZFREE(s, p);} + +/* Reverse the bytes in a 32-bit value */ +#define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \ + (((q) & 0xff00) << 8) + (((q) & 0xff) << 24)) + +#endif /* ZUTIL_H */ diff --git a/zlib/trees.c b/zlib/trees.c new file mode 100644 index 0000000..75bf914 --- /dev/null +++ b/zlib/trees.c @@ -0,0 +1,1224 @@ +/* trees.c -- output deflated data using Huffman coding + * Copyright (C) 1995-2012 Jean-loup Gailly + * detect_data_type() function provided freely by Cosmin Truta, 2006 + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* + * ALGORITHM + * + * The "deflation" process uses several Huffman trees. The more + * common source values are represented by shorter bit sequences. + * + * Each code tree is stored in a compressed form which is itself + * a Huffman encoding of the lengths of all the code strings (in + * ascending order by source values). The actual code strings are + * reconstructed from the lengths in the inflate process, as described + * in the deflate specification. + * + * REFERENCES + * + * Deutsch, L.P.,"'Deflate' Compressed Data Format Specification". + * Available in ftp.uu.net:/pub/archiving/zip/doc/deflate-1.1.doc + * + * Storer, James A. + * Data Compression: Methods and Theory, pp. 49-50. + * Computer Science Press, 1988. ISBN 0-7167-8156-5. + * + * Sedgewick, R. + * Algorithms, p290. + * Addison-Wesley, 1983. ISBN 0-201-06672-6. + */ + +/* @(#) $Id$ */ + +/* #define GEN_TREES_H */ + +#include "deflate.h" + +#ifdef DEBUG +# include +#endif + +/* =========================================================================== + * Constants + */ + +#define MAX_BL_BITS 7 +/* Bit length codes must not exceed MAX_BL_BITS bits */ + +#define END_BLOCK 256 +/* end of block literal code */ + +#define REP_3_6 16 +/* repeat previous bit length 3-6 times (2 bits of repeat count) */ + +#define REPZ_3_10 17 +/* repeat a zero length 3-10 times (3 bits of repeat count) */ + +#define REPZ_11_138 18 +/* repeat a zero length 11-138 times (7 bits of repeat count) */ + +local const int extra_lbits[LENGTH_CODES] /* extra bits for each length code */ + = {0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0}; + +local const int extra_dbits[D_CODES] /* extra bits for each distance code */ + = {0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13}; + +local const int extra_blbits[BL_CODES]/* extra bits for each bit length code */ + = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7}; + +local const uch bl_order[BL_CODES] + = {16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15}; +/* The lengths of the bit length codes are sent in order of decreasing + * probability, to avoid transmitting the lengths for unused bit length codes. + */ + +/* =========================================================================== + * Local data. These are initialized only once. + */ + +#define DIST_CODE_LEN 512 /* see definition of array dist_code below */ + +#if defined(GEN_TREES_H) || !defined(STDC) +/* non ANSI compilers may not accept trees.h */ + +local ct_data static_ltree[L_CODES+2]; +/* The static literal tree. Since the bit lengths are imposed, there is no + * need for the L_CODES extra codes used during heap construction. However + * The codes 286 and 287 are needed to build a canonical tree (see _tr_init + * below). + */ + +local ct_data static_dtree[D_CODES]; +/* The static distance tree. (Actually a trivial tree since all codes use + * 5 bits.) + */ + +uch _dist_code[DIST_CODE_LEN]; +/* Distance codes. The first 256 values correspond to the distances + * 3 .. 258, the last 256 values correspond to the top 8 bits of + * the 15 bit distances. + */ + +uch _length_code[MAX_MATCH-MIN_MATCH+1]; +/* length code for each normalized match length (0 == MIN_MATCH) */ + +local int base_length[LENGTH_CODES]; +/* First normalized length for each code (0 = MIN_MATCH) */ + +local int base_dist[D_CODES]; +/* First normalized distance for each code (0 = distance of 1) */ + +#else +# include "trees.h" +#endif /* GEN_TREES_H */ + +struct static_tree_desc_s { + const ct_data *static_tree; /* static tree or NULL */ + const intf *extra_bits; /* extra bits for each code or NULL */ + int extra_base; /* base index for extra_bits */ + int elems; /* max number of elements in the tree */ + int max_length; /* max bit length for the codes */ +}; + +local static_tree_desc static_l_desc = +{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS}; + +local static_tree_desc static_d_desc = +{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS}; + +local static_tree_desc static_bl_desc = +{(const ct_data *)0, extra_blbits, 0, BL_CODES, MAX_BL_BITS}; + +/* =========================================================================== + * Local (static) routines in this file. + */ + +local void tr_static_init OF((void)); +local void init_block OF((deflate_state *s)); +local void pqdownheap OF((deflate_state *s, ct_data *tree, int k)); +local void gen_bitlen OF((deflate_state *s, tree_desc *desc)); +local void gen_codes OF((ct_data *tree, int max_code, ushf *bl_count)); +local void build_tree OF((deflate_state *s, tree_desc *desc)); +local void scan_tree OF((deflate_state *s, ct_data *tree, int max_code)); +local void send_tree OF((deflate_state *s, ct_data *tree, int max_code)); +local int build_bl_tree OF((deflate_state *s)); +local void send_all_trees OF((deflate_state *s, int lcodes, int dcodes, + int blcodes)); +local void compress_block OF((deflate_state *s, ct_data *ltree, + ct_data *dtree)); +local int detect_data_type OF((deflate_state *s)); +local unsigned bi_reverse OF((unsigned value, int length)); +local void bi_windup OF((deflate_state *s)); +local void bi_flush OF((deflate_state *s)); +local void copy_block OF((deflate_state *s, charf *buf, unsigned len, + int header)); + +#ifdef GEN_TREES_H +local void gen_trees_header OF((void)); +#endif + +#ifndef DEBUG +# define send_code(s, c, tree) send_bits(s, tree[c].Code, tree[c].Len) + /* Send a code of the given tree. c and tree must not have side effects */ + +#else /* DEBUG */ +# define send_code(s, c, tree) \ + { if (z_verbose>2) fprintf(stderr,"\ncd %3d ",(c)); \ + send_bits(s, tree[c].Code, tree[c].Len); } +#endif + +/* =========================================================================== + * Output a short LSB first on the stream. + * IN assertion: there is enough room in pendingBuf. + */ +#define put_short(s, w) { \ + put_byte(s, (uch)((w) & 0xff)); \ + put_byte(s, (uch)((ush)(w) >> 8)); \ +} + +/* =========================================================================== + * Send a value on a given number of bits. + * IN assertion: length <= 16 and value fits in length bits. + */ +#ifdef DEBUG +local void send_bits OF((deflate_state *s, int value, int length)); + +local void send_bits(s, value, length) + deflate_state *s; + int value; /* value to send */ + int length; /* number of bits */ +{ + Tracevv((stderr," l %2d v %4x ", length, value)); + Assert(length > 0 && length <= 15, "invalid length"); + s->bits_sent += (ulg)length; + + /* If not enough room in bi_buf, use (valid) bits from bi_buf and + * (16 - bi_valid) bits from value, leaving (width - (16-bi_valid)) + * unused bits in value. + */ + if (s->bi_valid > (int)Buf_size - length) { + s->bi_buf |= (ush)value << s->bi_valid; + put_short(s, s->bi_buf); + s->bi_buf = (ush)value >> (Buf_size - s->bi_valid); + s->bi_valid += length - Buf_size; + } else { + s->bi_buf |= (ush)value << s->bi_valid; + s->bi_valid += length; + } +} +#else /* !DEBUG */ + +#define send_bits(s, value, length) \ +{ int len = length;\ + if (s->bi_valid > (int)Buf_size - len) {\ + int val = value;\ + s->bi_buf |= (ush)val << s->bi_valid;\ + put_short(s, s->bi_buf);\ + s->bi_buf = (ush)val >> (Buf_size - s->bi_valid);\ + s->bi_valid += len - Buf_size;\ + } else {\ + s->bi_buf |= (ush)(value) << s->bi_valid;\ + s->bi_valid += len;\ + }\ +} +#endif /* DEBUG */ + + +/* the arguments must not have side effects */ + +/* =========================================================================== + * Initialize the various 'constant' tables. + */ +local void tr_static_init() +{ +#if defined(GEN_TREES_H) || !defined(STDC) + static int static_init_done = 0; + int n; /* iterates over tree elements */ + int bits; /* bit counter */ + int length; /* length value */ + int code; /* code value */ + int dist; /* distance index */ + ush bl_count[MAX_BITS+1]; + /* number of codes at each bit length for an optimal tree */ + + if (static_init_done) return; + + /* For some embedded targets, global variables are not initialized: */ +#ifdef NO_INIT_GLOBAL_POINTERS + static_l_desc.static_tree = static_ltree; + static_l_desc.extra_bits = extra_lbits; + static_d_desc.static_tree = static_dtree; + static_d_desc.extra_bits = extra_dbits; + static_bl_desc.extra_bits = extra_blbits; +#endif + + /* Initialize the mapping length (0..255) -> length code (0..28) */ + length = 0; + for (code = 0; code < LENGTH_CODES-1; code++) { + base_length[code] = length; + for (n = 0; n < (1< dist code (0..29) */ + dist = 0; + for (code = 0 ; code < 16; code++) { + base_dist[code] = dist; + for (n = 0; n < (1<>= 7; /* from now on, all distances are divided by 128 */ + for ( ; code < D_CODES; code++) { + base_dist[code] = dist << 7; + for (n = 0; n < (1<<(extra_dbits[code]-7)); n++) { + _dist_code[256 + dist++] = (uch)code; + } + } + Assert (dist == 256, "tr_static_init: 256+dist != 512"); + + /* Construct the codes of the static literal tree */ + for (bits = 0; bits <= MAX_BITS; bits++) bl_count[bits] = 0; + n = 0; + while (n <= 143) static_ltree[n++].Len = 8, bl_count[8]++; + while (n <= 255) static_ltree[n++].Len = 9, bl_count[9]++; + while (n <= 279) static_ltree[n++].Len = 7, bl_count[7]++; + while (n <= 287) static_ltree[n++].Len = 8, bl_count[8]++; + /* Codes 286 and 287 do not exist, but we must include them in the + * tree construction to get a canonical Huffman tree (longest code + * all ones) + */ + gen_codes((ct_data *)static_ltree, L_CODES+1, bl_count); + + /* The static distance tree is trivial: */ + for (n = 0; n < D_CODES; n++) { + static_dtree[n].Len = 5; + static_dtree[n].Code = bi_reverse((unsigned)n, 5); + } + static_init_done = 1; + +# ifdef GEN_TREES_H + gen_trees_header(); +# endif +#endif /* defined(GEN_TREES_H) || !defined(STDC) */ +} + +/* =========================================================================== + * Genererate the file trees.h describing the static trees. + */ +#ifdef GEN_TREES_H +# ifndef DEBUG +# include +# endif + +# define SEPARATOR(i, last, width) \ + ((i) == (last)? "\n};\n\n" : \ + ((i) % (width) == (width)-1 ? ",\n" : ", ")) + +void gen_trees_header() +{ + FILE *header = fopen("trees.h", "w"); + int i; + + Assert (header != NULL, "Can't open trees.h"); + fprintf(header, + "/* header created automatically with -DGEN_TREES_H */\n\n"); + + fprintf(header, "local const ct_data static_ltree[L_CODES+2] = {\n"); + for (i = 0; i < L_CODES+2; i++) { + fprintf(header, "{{%3u},{%3u}}%s", static_ltree[i].Code, + static_ltree[i].Len, SEPARATOR(i, L_CODES+1, 5)); + } + + fprintf(header, "local const ct_data static_dtree[D_CODES] = {\n"); + for (i = 0; i < D_CODES; i++) { + fprintf(header, "{{%2u},{%2u}}%s", static_dtree[i].Code, + static_dtree[i].Len, SEPARATOR(i, D_CODES-1, 5)); + } + + fprintf(header, "const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {\n"); + for (i = 0; i < DIST_CODE_LEN; i++) { + fprintf(header, "%2u%s", _dist_code[i], + SEPARATOR(i, DIST_CODE_LEN-1, 20)); + } + + fprintf(header, + "const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {\n"); + for (i = 0; i < MAX_MATCH-MIN_MATCH+1; i++) { + fprintf(header, "%2u%s", _length_code[i], + SEPARATOR(i, MAX_MATCH-MIN_MATCH, 20)); + } + + fprintf(header, "local const int base_length[LENGTH_CODES] = {\n"); + for (i = 0; i < LENGTH_CODES; i++) { + fprintf(header, "%1u%s", base_length[i], + SEPARATOR(i, LENGTH_CODES-1, 20)); + } + + fprintf(header, "local const int base_dist[D_CODES] = {\n"); + for (i = 0; i < D_CODES; i++) { + fprintf(header, "%5u%s", base_dist[i], + SEPARATOR(i, D_CODES-1, 10)); + } + + fclose(header); +} +#endif /* GEN_TREES_H */ + +/* =========================================================================== + * Initialize the tree data structures for a new zlib stream. + */ +void ZLIB_INTERNAL _tr_init(s) + deflate_state *s; +{ + tr_static_init(); + + s->l_desc.dyn_tree = s->dyn_ltree; + s->l_desc.stat_desc = &static_l_desc; + + s->d_desc.dyn_tree = s->dyn_dtree; + s->d_desc.stat_desc = &static_d_desc; + + s->bl_desc.dyn_tree = s->bl_tree; + s->bl_desc.stat_desc = &static_bl_desc; + + s->bi_buf = 0; + s->bi_valid = 0; +#ifdef DEBUG + s->compressed_len = 0L; + s->bits_sent = 0L; +#endif + + /* Initialize the first block of the first file: */ + init_block(s); +} + +/* =========================================================================== + * Initialize a new block. + */ +local void init_block(s) + deflate_state *s; +{ + int n; /* iterates over tree elements */ + + /* Initialize the trees. */ + for (n = 0; n < L_CODES; n++) s->dyn_ltree[n].Freq = 0; + for (n = 0; n < D_CODES; n++) s->dyn_dtree[n].Freq = 0; + for (n = 0; n < BL_CODES; n++) s->bl_tree[n].Freq = 0; + + s->dyn_ltree[END_BLOCK].Freq = 1; + s->opt_len = s->static_len = 0L; + s->last_lit = s->matches = 0; +} + +#define SMALLEST 1 +/* Index within the heap array of least frequent node in the Huffman tree */ + + +/* =========================================================================== + * Remove the smallest element from the heap and recreate the heap with + * one less element. Updates heap and heap_len. + */ +#define pqremove(s, tree, top) \ +{\ + top = s->heap[SMALLEST]; \ + s->heap[SMALLEST] = s->heap[s->heap_len--]; \ + pqdownheap(s, tree, SMALLEST); \ +} + +/* =========================================================================== + * Compares to subtrees, using the tree depth as tie breaker when + * the subtrees have equal frequency. This minimizes the worst case length. + */ +#define smaller(tree, n, m, depth) \ + (tree[n].Freq < tree[m].Freq || \ + (tree[n].Freq == tree[m].Freq && depth[n] <= depth[m])) + +/* =========================================================================== + * Restore the heap property by moving down the tree starting at node k, + * exchanging a node with the smallest of its two sons if necessary, stopping + * when the heap property is re-established (each father smaller than its + * two sons). + */ +local void pqdownheap(s, tree, k) + deflate_state *s; + ct_data *tree; /* the tree to restore */ + int k; /* node to move down */ +{ + int v = s->heap[k]; + int j = k << 1; /* left son of k */ + while (j <= s->heap_len) { + /* Set j to the smallest of the two sons: */ + if (j < s->heap_len && + smaller(tree, s->heap[j+1], s->heap[j], s->depth)) { + j++; + } + /* Exit if v is smaller than both sons */ + if (smaller(tree, v, s->heap[j], s->depth)) break; + + /* Exchange v with the smallest son */ + s->heap[k] = s->heap[j]; k = j; + + /* And continue down the tree, setting j to the left son of k */ + j <<= 1; + } + s->heap[k] = v; +} + +/* =========================================================================== + * Compute the optimal bit lengths for a tree and update the total bit length + * for the current block. + * IN assertion: the fields freq and dad are set, heap[heap_max] and + * above are the tree nodes sorted by increasing frequency. + * OUT assertions: the field len is set to the optimal bit length, the + * array bl_count contains the frequencies for each bit length. + * The length opt_len is updated; static_len is also updated if stree is + * not null. + */ +local void gen_bitlen(s, desc) + deflate_state *s; + tree_desc *desc; /* the tree descriptor */ +{ + ct_data *tree = desc->dyn_tree; + int max_code = desc->max_code; + const ct_data *stree = desc->stat_desc->static_tree; + const intf *extra = desc->stat_desc->extra_bits; + int base = desc->stat_desc->extra_base; + int max_length = desc->stat_desc->max_length; + int h; /* heap index */ + int n, m; /* iterate over the tree elements */ + int bits; /* bit length */ + int xbits; /* extra bits */ + ush f; /* frequency */ + int overflow = 0; /* number of elements with bit length too large */ + + for (bits = 0; bits <= MAX_BITS; bits++) s->bl_count[bits] = 0; + + /* In a first pass, compute the optimal bit lengths (which may + * overflow in the case of the bit length tree). + */ + tree[s->heap[s->heap_max]].Len = 0; /* root of the heap */ + + for (h = s->heap_max+1; h < HEAP_SIZE; h++) { + n = s->heap[h]; + bits = tree[tree[n].Dad].Len + 1; + if (bits > max_length) bits = max_length, overflow++; + tree[n].Len = (ush)bits; + /* We overwrite tree[n].Dad which is no longer needed */ + + if (n > max_code) continue; /* not a leaf node */ + + s->bl_count[bits]++; + xbits = 0; + if (n >= base) xbits = extra[n-base]; + f = tree[n].Freq; + s->opt_len += (ulg)f * (bits + xbits); + if (stree) s->static_len += (ulg)f * (stree[n].Len + xbits); + } + if (overflow == 0) return; + + Trace((stderr,"\nbit length overflow\n")); + /* This happens for example on obj2 and pic of the Calgary corpus */ + + /* Find the first bit length which could increase: */ + do { + bits = max_length-1; + while (s->bl_count[bits] == 0) bits--; + s->bl_count[bits]--; /* move one leaf down the tree */ + s->bl_count[bits+1] += 2; /* move one overflow item as its brother */ + s->bl_count[max_length]--; + /* The brother of the overflow item also moves one step up, + * but this does not affect bl_count[max_length] + */ + overflow -= 2; + } while (overflow > 0); + + /* Now recompute all bit lengths, scanning in increasing frequency. + * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all + * lengths instead of fixing only the wrong ones. This idea is taken + * from 'ar' written by Haruhiko Okumura.) + */ + for (bits = max_length; bits != 0; bits--) { + n = s->bl_count[bits]; + while (n != 0) { + m = s->heap[--h]; + if (m > max_code) continue; + if ((unsigned) tree[m].Len != (unsigned) bits) { + Trace((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits)); + s->opt_len += ((int)bits - (int)tree[m].Len) + *(int)tree[m].Freq; + tree[m].Len = (ush)bits; + } + n--; + } + } +} + +/* =========================================================================== + * Generate the codes for a given tree and bit counts (which need not be + * optimal). + * IN assertion: the array bl_count contains the bit length statistics for + * the given tree and the field len is set for all tree elements. + * OUT assertion: the field code is set for all tree elements of non + * zero code length. + */ +local void gen_codes (tree, max_code, bl_count) + ct_data *tree; /* the tree to decorate */ + int max_code; /* largest code with non zero frequency */ + ushf *bl_count; /* number of codes at each bit length */ +{ + ush next_code[MAX_BITS+1]; /* next code value for each bit length */ + ush code = 0; /* running code value */ + int bits; /* bit index */ + int n; /* code index */ + + /* The distribution counts are first used to generate the code values + * without bit reversal. + */ + for (bits = 1; bits <= MAX_BITS; bits++) { + next_code[bits] = code = (code + bl_count[bits-1]) << 1; + } + /* Check that the bit counts in bl_count are consistent. The last code + * must be all ones. + */ + Assert (code + bl_count[MAX_BITS]-1 == (1<dyn_tree; + const ct_data *stree = desc->stat_desc->static_tree; + int elems = desc->stat_desc->elems; + int n, m; /* iterate over heap elements */ + int max_code = -1; /* largest code with non zero frequency */ + int node; /* new node being created */ + + /* Construct the initial heap, with least frequent element in + * heap[SMALLEST]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. + * heap[0] is not used. + */ + s->heap_len = 0, s->heap_max = HEAP_SIZE; + + for (n = 0; n < elems; n++) { + if (tree[n].Freq != 0) { + s->heap[++(s->heap_len)] = max_code = n; + s->depth[n] = 0; + } else { + tree[n].Len = 0; + } + } + + /* The pkzip format requires that at least one distance code exists, + * and that at least one bit should be sent even if there is only one + * possible code. So to avoid special checks later on we force at least + * two codes of non zero frequency. + */ + while (s->heap_len < 2) { + node = s->heap[++(s->heap_len)] = (max_code < 2 ? ++max_code : 0); + tree[node].Freq = 1; + s->depth[node] = 0; + s->opt_len--; if (stree) s->static_len -= stree[node].Len; + /* node is 0 or 1 so it does not have extra bits */ + } + desc->max_code = max_code; + + /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, + * establish sub-heaps of increasing lengths: + */ + for (n = s->heap_len/2; n >= 1; n--) pqdownheap(s, tree, n); + + /* Construct the Huffman tree by repeatedly combining the least two + * frequent nodes. + */ + node = elems; /* next internal node of the tree */ + do { + pqremove(s, tree, n); /* n = node of least frequency */ + m = s->heap[SMALLEST]; /* m = node of next least frequency */ + + s->heap[--(s->heap_max)] = n; /* keep the nodes sorted by frequency */ + s->heap[--(s->heap_max)] = m; + + /* Create a new node father of n and m */ + tree[node].Freq = tree[n].Freq + tree[m].Freq; + s->depth[node] = (uch)((s->depth[n] >= s->depth[m] ? + s->depth[n] : s->depth[m]) + 1); + tree[n].Dad = tree[m].Dad = (ush)node; +#ifdef DUMP_BL_TREE + if (tree == s->bl_tree) { + fprintf(stderr,"\nnode %d(%d), sons %d(%d) %d(%d)", + node, tree[node].Freq, n, tree[n].Freq, m, tree[m].Freq); + } +#endif + /* and insert the new node in the heap */ + s->heap[SMALLEST] = node++; + pqdownheap(s, tree, SMALLEST); + + } while (s->heap_len >= 2); + + s->heap[--(s->heap_max)] = s->heap[SMALLEST]; + + /* At this point, the fields freq and dad are set. We can now + * generate the bit lengths. + */ + gen_bitlen(s, (tree_desc *)desc); + + /* The field len is now set, we can generate the bit codes */ + gen_codes ((ct_data *)tree, max_code, s->bl_count); +} + +/* =========================================================================== + * Scan a literal or distance tree to determine the frequencies of the codes + * in the bit length tree. + */ +local void scan_tree (s, tree, max_code) + deflate_state *s; + ct_data *tree; /* the tree to be scanned */ + int max_code; /* and its largest code of non zero frequency */ +{ + int n; /* iterates over all tree elements */ + int prevlen = -1; /* last emitted length */ + int curlen; /* length of current code */ + int nextlen = tree[0].Len; /* length of next code */ + int count = 0; /* repeat count of the current code */ + int max_count = 7; /* max repeat count */ + int min_count = 4; /* min repeat count */ + + if (nextlen == 0) max_count = 138, min_count = 3; + tree[max_code+1].Len = (ush)0xffff; /* guard */ + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; nextlen = tree[n+1].Len; + if (++count < max_count && curlen == nextlen) { + continue; + } else if (count < min_count) { + s->bl_tree[curlen].Freq += count; + } else if (curlen != 0) { + if (curlen != prevlen) s->bl_tree[curlen].Freq++; + s->bl_tree[REP_3_6].Freq++; + } else if (count <= 10) { + s->bl_tree[REPZ_3_10].Freq++; + } else { + s->bl_tree[REPZ_11_138].Freq++; + } + count = 0; prevlen = curlen; + if (nextlen == 0) { + max_count = 138, min_count = 3; + } else if (curlen == nextlen) { + max_count = 6, min_count = 3; + } else { + max_count = 7, min_count = 4; + } + } +} + +/* =========================================================================== + * Send a literal or distance tree in compressed form, using the codes in + * bl_tree. + */ +local void send_tree (s, tree, max_code) + deflate_state *s; + ct_data *tree; /* the tree to be scanned */ + int max_code; /* and its largest code of non zero frequency */ +{ + int n; /* iterates over all tree elements */ + int prevlen = -1; /* last emitted length */ + int curlen; /* length of current code */ + int nextlen = tree[0].Len; /* length of next code */ + int count = 0; /* repeat count of the current code */ + int max_count = 7; /* max repeat count */ + int min_count = 4; /* min repeat count */ + + /* tree[max_code+1].Len = -1; */ /* guard already set */ + if (nextlen == 0) max_count = 138, min_count = 3; + + for (n = 0; n <= max_code; n++) { + curlen = nextlen; nextlen = tree[n+1].Len; + if (++count < max_count && curlen == nextlen) { + continue; + } else if (count < min_count) { + do { send_code(s, curlen, s->bl_tree); } while (--count != 0); + + } else if (curlen != 0) { + if (curlen != prevlen) { + send_code(s, curlen, s->bl_tree); count--; + } + Assert(count >= 3 && count <= 6, " 3_6?"); + send_code(s, REP_3_6, s->bl_tree); send_bits(s, count-3, 2); + + } else if (count <= 10) { + send_code(s, REPZ_3_10, s->bl_tree); send_bits(s, count-3, 3); + + } else { + send_code(s, REPZ_11_138, s->bl_tree); send_bits(s, count-11, 7); + } + count = 0; prevlen = curlen; + if (nextlen == 0) { + max_count = 138, min_count = 3; + } else if (curlen == nextlen) { + max_count = 6, min_count = 3; + } else { + max_count = 7, min_count = 4; + } + } +} + +/* =========================================================================== + * Construct the Huffman tree for the bit lengths and return the index in + * bl_order of the last bit length code to send. + */ +local int build_bl_tree(s) + deflate_state *s; +{ + int max_blindex; /* index of last bit length code of non zero freq */ + + /* Determine the bit length frequencies for literal and distance trees */ + scan_tree(s, (ct_data *)s->dyn_ltree, s->l_desc.max_code); + scan_tree(s, (ct_data *)s->dyn_dtree, s->d_desc.max_code); + + /* Build the bit length tree: */ + build_tree(s, (tree_desc *)(&(s->bl_desc))); + /* opt_len now includes the length of the tree representations, except + * the lengths of the bit lengths codes and the 5+5+4 bits for the counts. + */ + + /* Determine the number of bit length codes to send. The pkzip format + * requires that at least 4 bit length codes be sent. (appnote.txt says + * 3 but the actual value used is 4.) + */ + for (max_blindex = BL_CODES-1; max_blindex >= 3; max_blindex--) { + if (s->bl_tree[bl_order[max_blindex]].Len != 0) break; + } + /* Update opt_len to include the bit length tree and counts */ + s->opt_len += 3*(max_blindex+1) + 5+5+4; + Tracev((stderr, "\ndyn trees: dyn %ld, stat %ld", + s->opt_len, s->static_len)); + + return max_blindex; +} + +/* =========================================================================== + * Send the header for a block using dynamic Huffman trees: the counts, the + * lengths of the bit length codes, the literal tree and the distance tree. + * IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. + */ +local void send_all_trees(s, lcodes, dcodes, blcodes) + deflate_state *s; + int lcodes, dcodes, blcodes; /* number of codes for each tree */ +{ + int rank; /* index in bl_order */ + + Assert (lcodes >= 257 && dcodes >= 1 && blcodes >= 4, "not enough codes"); + Assert (lcodes <= L_CODES && dcodes <= D_CODES && blcodes <= BL_CODES, + "too many codes"); + Tracev((stderr, "\nbl counts: ")); + send_bits(s, lcodes-257, 5); /* not +255 as stated in appnote.txt */ + send_bits(s, dcodes-1, 5); + send_bits(s, blcodes-4, 4); /* not -3 as stated in appnote.txt */ + for (rank = 0; rank < blcodes; rank++) { + Tracev((stderr, "\nbl code %2d ", bl_order[rank])); + send_bits(s, s->bl_tree[bl_order[rank]].Len, 3); + } + Tracev((stderr, "\nbl tree: sent %ld", s->bits_sent)); + + send_tree(s, (ct_data *)s->dyn_ltree, lcodes-1); /* literal tree */ + Tracev((stderr, "\nlit tree: sent %ld", s->bits_sent)); + + send_tree(s, (ct_data *)s->dyn_dtree, dcodes-1); /* distance tree */ + Tracev((stderr, "\ndist tree: sent %ld", s->bits_sent)); +} + +/* =========================================================================== + * Send a stored block + */ +void ZLIB_INTERNAL _tr_stored_block(s, buf, stored_len, last) + deflate_state *s; + charf *buf; /* input block */ + ulg stored_len; /* length of input block */ + int last; /* one if this is the last block for a file */ +{ + send_bits(s, (STORED_BLOCK<<1)+last, 3); /* send block type */ +#ifdef DEBUG + s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L; + s->compressed_len += (stored_len + 4) << 3; +#endif + copy_block(s, buf, (unsigned)stored_len, 1); /* with header */ +} + +/* =========================================================================== + * Flush the bits in the bit buffer to pending output (leaves at most 7 bits) + */ +void ZLIB_INTERNAL _tr_flush_bits(s) + deflate_state *s; +{ + bi_flush(s); +} + +/* =========================================================================== + * Send one empty static block to give enough lookahead for inflate. + * This takes 10 bits, of which 7 may remain in the bit buffer. + */ +void ZLIB_INTERNAL _tr_align(s) + deflate_state *s; +{ + send_bits(s, STATIC_TREES<<1, 3); + send_code(s, END_BLOCK, static_ltree); +#ifdef DEBUG + s->compressed_len += 10L; /* 3 for block type, 7 for EOB */ +#endif + bi_flush(s); +} + +/* =========================================================================== + * Determine the best encoding for the current block: dynamic trees, static + * trees or store, and output the encoded block to the zip file. + */ +void ZLIB_INTERNAL _tr_flush_block(s, buf, stored_len, last) + deflate_state *s; + charf *buf; /* input block, or NULL if too old */ + ulg stored_len; /* length of input block */ + int last; /* one if this is the last block for a file */ +{ + ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ + int max_blindex = 0; /* index of last bit length code of non zero freq */ + + /* Build the Huffman trees unless a stored block is forced */ + if (s->level > 0) { + + /* Check if the file is binary or text */ + if (s->strm->data_type == Z_UNKNOWN) + s->strm->data_type = detect_data_type(s); + + /* Construct the literal and distance trees */ + build_tree(s, (tree_desc *)(&(s->l_desc))); + Tracev((stderr, "\nlit data: dyn %ld, stat %ld", s->opt_len, + s->static_len)); + + build_tree(s, (tree_desc *)(&(s->d_desc))); + Tracev((stderr, "\ndist data: dyn %ld, stat %ld", s->opt_len, + s->static_len)); + /* At this point, opt_len and static_len are the total bit lengths of + * the compressed block data, excluding the tree representations. + */ + + /* Build the bit length tree for the above two trees, and get the index + * in bl_order of the last bit length code to send. + */ + max_blindex = build_bl_tree(s); + + /* Determine the best encoding. Compute the block lengths in bytes. */ + opt_lenb = (s->opt_len+3+7)>>3; + static_lenb = (s->static_len+3+7)>>3; + + Tracev((stderr, "\nopt %lu(%lu) stat %lu(%lu) stored %lu lit %u ", + opt_lenb, s->opt_len, static_lenb, s->static_len, stored_len, + s->last_lit)); + + if (static_lenb <= opt_lenb) opt_lenb = static_lenb; + + } else { + Assert(buf != (char*)0, "lost buf"); + opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ + } + +#ifdef FORCE_STORED + if (buf != (char*)0) { /* force stored block */ +#else + if (stored_len+4 <= opt_lenb && buf != (char*)0) { + /* 4: two words for the lengths */ +#endif + /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. + * Otherwise we can't have processed more than WSIZE input bytes since + * the last block flush, because compression would have been + * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to + * transform a block into a stored block. + */ + _tr_stored_block(s, buf, stored_len, last); + +#ifdef FORCE_STATIC + } else if (static_lenb >= 0) { /* force static trees */ +#else + } else if (s->strategy == Z_FIXED || static_lenb == opt_lenb) { +#endif + send_bits(s, (STATIC_TREES<<1)+last, 3); + compress_block(s, (ct_data *)static_ltree, (ct_data *)static_dtree); +#ifdef DEBUG + s->compressed_len += 3 + s->static_len; +#endif + } else { + send_bits(s, (DYN_TREES<<1)+last, 3); + send_all_trees(s, s->l_desc.max_code+1, s->d_desc.max_code+1, + max_blindex+1); + compress_block(s, (ct_data *)s->dyn_ltree, (ct_data *)s->dyn_dtree); +#ifdef DEBUG + s->compressed_len += 3 + s->opt_len; +#endif + } + Assert (s->compressed_len == s->bits_sent, "bad compressed size"); + /* The above check is made mod 2^32, for files larger than 512 MB + * and uInt implemented on 32 bits. + */ + init_block(s); + + if (last) { + bi_windup(s); +#ifdef DEBUG + s->compressed_len += 7; /* align on byte boundary */ +#endif + } + Tracev((stderr,"\ncomprlen %lu(%lu) ", s->compressed_len>>3, + s->compressed_len-7*last)); +} + +/* =========================================================================== + * Save the match info and tally the frequency counts. Return true if + * the current block must be flushed. + */ +int ZLIB_INTERNAL _tr_tally (s, dist, lc) + deflate_state *s; + unsigned dist; /* distance of matched string */ + unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ +{ + s->d_buf[s->last_lit] = (ush)dist; + s->l_buf[s->last_lit++] = (uch)lc; + if (dist == 0) { + /* lc is the unmatched char */ + s->dyn_ltree[lc].Freq++; + } else { + s->matches++; + /* Here, lc is the match length - MIN_MATCH */ + dist--; /* dist = match distance - 1 */ + Assert((ush)dist < (ush)MAX_DIST(s) && + (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && + (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match"); + + s->dyn_ltree[_length_code[lc]+LITERALS+1].Freq++; + s->dyn_dtree[d_code(dist)].Freq++; + } + +#ifdef TRUNCATE_BLOCK + /* Try to guess if it is profitable to stop the current block here */ + if ((s->last_lit & 0x1fff) == 0 && s->level > 2) { + /* Compute an upper bound for the compressed length */ + ulg out_length = (ulg)s->last_lit*8L; + ulg in_length = (ulg)((int)s->strstart - s->block_start); + int dcode; + for (dcode = 0; dcode < D_CODES; dcode++) { + out_length += (ulg)s->dyn_dtree[dcode].Freq * + (5L+extra_dbits[dcode]); + } + out_length >>= 3; + Tracev((stderr,"\nlast_lit %u, in %ld, out ~%ld(%ld%%) ", + s->last_lit, in_length, out_length, + 100L - out_length*100L/in_length)); + if (s->matches < s->last_lit/2 && out_length < in_length/2) return 1; + } +#endif + return (s->last_lit == s->lit_bufsize-1); + /* We avoid equality with lit_bufsize because of wraparound at 64K + * on 16 bit machines and because stored blocks are restricted to + * 64K-1 bytes. + */ +} + +/* =========================================================================== + * Send the block data compressed using the given Huffman trees + */ +local void compress_block(s, ltree, dtree) + deflate_state *s; + ct_data *ltree; /* literal tree */ + ct_data *dtree; /* distance tree */ +{ + unsigned dist; /* distance of matched string */ + int lc; /* match length or unmatched char (if dist == 0) */ + unsigned lx = 0; /* running index in l_buf */ + unsigned code; /* the code to send */ + int extra; /* number of extra bits to send */ + + if (s->last_lit != 0) do { + dist = s->d_buf[lx]; + lc = s->l_buf[lx++]; + if (dist == 0) { + send_code(s, lc, ltree); /* send a literal byte */ + Tracecv(isgraph(lc), (stderr," '%c' ", lc)); + } else { + /* Here, lc is the match length - MIN_MATCH */ + code = _length_code[lc]; + send_code(s, code+LITERALS+1, ltree); /* send the length code */ + extra = extra_lbits[code]; + if (extra != 0) { + lc -= base_length[code]; + send_bits(s, lc, extra); /* send the extra length bits */ + } + dist--; /* dist is now the match distance - 1 */ + code = d_code(dist); + Assert (code < D_CODES, "bad d_code"); + + send_code(s, code, dtree); /* send the distance code */ + extra = extra_dbits[code]; + if (extra != 0) { + dist -= base_dist[code]; + send_bits(s, dist, extra); /* send the extra distance bits */ + } + } /* literal or match pair ? */ + + /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ + Assert((uInt)(s->pending) < s->lit_bufsize + 2*lx, + "pendingBuf overflow"); + + } while (lx < s->last_lit); + + send_code(s, END_BLOCK, ltree); +} + +/* =========================================================================== + * Check if the data type is TEXT or BINARY, using the following algorithm: + * - TEXT if the two conditions below are satisfied: + * a) There are no non-portable control characters belonging to the + * "black list" (0..6, 14..25, 28..31). + * b) There is at least one printable character belonging to the + * "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255). + * - BINARY otherwise. + * - The following partially-portable control characters form a + * "gray list" that is ignored in this detection algorithm: + * (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}). + * IN assertion: the fields Freq of dyn_ltree are set. + */ +local int detect_data_type(s) + deflate_state *s; +{ + /* black_mask is the bit mask of black-listed bytes + * set bits 0..6, 14..25, and 28..31 + * 0xf3ffc07f = binary 11110011111111111100000001111111 + */ + unsigned int black_mask = 0xf3ffc07fUL; + int n; + + /* Check for non-textual ("black-listed") bytes. */ + for (n = 0; n <= 31; n++, black_mask >>= 1) + if ((black_mask & 1) && (s->dyn_ltree[n].Freq != 0)) + return Z_BINARY; + + /* Check for textual ("white-listed") bytes. */ + if (s->dyn_ltree[9].Freq != 0 || s->dyn_ltree[10].Freq != 0 + || s->dyn_ltree[13].Freq != 0) + return Z_TEXT; + for (n = 32; n < LITERALS; n++) + if (s->dyn_ltree[n].Freq != 0) + return Z_TEXT; + + /* There are no "black-listed" or "white-listed" bytes: + * this stream either is empty or has tolerated ("gray-listed") bytes only. + */ + return Z_BINARY; +} + +/* =========================================================================== + * Reverse the first len bits of a code, using straightforward code (a faster + * method would use a table) + * IN assertion: 1 <= len <= 15 + */ +local unsigned bi_reverse(code, len) + unsigned code; /* the value to invert */ + int len; /* its bit length */ +{ + register unsigned res = 0; + do { + res |= code & 1; + code >>= 1, res <<= 1; + } while (--len > 0); + return res >> 1; +} + +/* =========================================================================== + * Flush the bit buffer, keeping at most 7 bits in it. + */ +local void bi_flush(s) + deflate_state *s; +{ + if (s->bi_valid == 16) { + put_short(s, s->bi_buf); + s->bi_buf = 0; + s->bi_valid = 0; + } else if (s->bi_valid >= 8) { + put_byte(s, (Byte)s->bi_buf); + s->bi_buf >>= 8; + s->bi_valid -= 8; + } +} + +/* =========================================================================== + * Flush the bit buffer and align the output on a byte boundary + */ +local void bi_windup(s) + deflate_state *s; +{ + if (s->bi_valid > 8) { + put_short(s, s->bi_buf); + } else if (s->bi_valid > 0) { + put_byte(s, (Byte)s->bi_buf); + } + s->bi_buf = 0; + s->bi_valid = 0; +#ifdef DEBUG + s->bits_sent = (s->bits_sent+7) & ~7; +#endif +} + +/* =========================================================================== + * Copy a stored block, storing first the length and its + * one's complement if requested. + */ +local void copy_block(s, buf, len, header) + deflate_state *s; + charf *buf; /* the input data */ + unsigned len; /* its length */ + int header; /* true if block header must be written */ +{ + bi_windup(s); /* align on byte boundary */ + + if (header) { + put_short(s, (ush)len); + put_short(s, (ush)~len); +#ifdef DEBUG + s->bits_sent += 2*16; +#endif + } +#ifdef DEBUG + s->bits_sent += (ulg)len<<3; +#endif + while (len--) { + put_byte(s, *buf++); + } +} diff --git a/zlib/trees.h b/zlib/trees.h new file mode 100644 index 0000000..d35639d --- /dev/null +++ b/zlib/trees.h @@ -0,0 +1,128 @@ +/* header created automatically with -DGEN_TREES_H */ + +local const ct_data static_ltree[L_CODES+2] = { +{{ 12},{ 8}}, {{140},{ 8}}, {{ 76},{ 8}}, {{204},{ 8}}, {{ 44},{ 8}}, +{{172},{ 8}}, {{108},{ 8}}, {{236},{ 8}}, {{ 28},{ 8}}, {{156},{ 8}}, +{{ 92},{ 8}}, {{220},{ 8}}, {{ 60},{ 8}}, {{188},{ 8}}, {{124},{ 8}}, +{{252},{ 8}}, {{ 2},{ 8}}, {{130},{ 8}}, {{ 66},{ 8}}, {{194},{ 8}}, +{{ 34},{ 8}}, {{162},{ 8}}, {{ 98},{ 8}}, {{226},{ 8}}, {{ 18},{ 8}}, +{{146},{ 8}}, {{ 82},{ 8}}, {{210},{ 8}}, {{ 50},{ 8}}, {{178},{ 8}}, +{{114},{ 8}}, {{242},{ 8}}, {{ 10},{ 8}}, {{138},{ 8}}, {{ 74},{ 8}}, +{{202},{ 8}}, {{ 42},{ 8}}, {{170},{ 8}}, {{106},{ 8}}, {{234},{ 8}}, +{{ 26},{ 8}}, {{154},{ 8}}, {{ 90},{ 8}}, {{218},{ 8}}, {{ 58},{ 8}}, +{{186},{ 8}}, {{122},{ 8}}, {{250},{ 8}}, {{ 6},{ 8}}, {{134},{ 8}}, +{{ 70},{ 8}}, {{198},{ 8}}, {{ 38},{ 8}}, {{166},{ 8}}, {{102},{ 8}}, +{{230},{ 8}}, {{ 22},{ 8}}, {{150},{ 8}}, {{ 86},{ 8}}, {{214},{ 8}}, +{{ 54},{ 8}}, {{182},{ 8}}, {{118},{ 8}}, {{246},{ 8}}, {{ 14},{ 8}}, +{{142},{ 8}}, {{ 78},{ 8}}, {{206},{ 8}}, {{ 46},{ 8}}, {{174},{ 8}}, +{{110},{ 8}}, {{238},{ 8}}, {{ 30},{ 8}}, {{158},{ 8}}, {{ 94},{ 8}}, +{{222},{ 8}}, {{ 62},{ 8}}, {{190},{ 8}}, {{126},{ 8}}, {{254},{ 8}}, +{{ 1},{ 8}}, {{129},{ 8}}, {{ 65},{ 8}}, {{193},{ 8}}, {{ 33},{ 8}}, +{{161},{ 8}}, {{ 97},{ 8}}, {{225},{ 8}}, {{ 17},{ 8}}, {{145},{ 8}}, +{{ 81},{ 8}}, {{209},{ 8}}, {{ 49},{ 8}}, {{177},{ 8}}, {{113},{ 8}}, +{{241},{ 8}}, {{ 9},{ 8}}, {{137},{ 8}}, {{ 73},{ 8}}, {{201},{ 8}}, +{{ 41},{ 8}}, {{169},{ 8}}, {{105},{ 8}}, {{233},{ 8}}, {{ 25},{ 8}}, +{{153},{ 8}}, {{ 89},{ 8}}, {{217},{ 8}}, {{ 57},{ 8}}, {{185},{ 8}}, +{{121},{ 8}}, {{249},{ 8}}, {{ 5},{ 8}}, {{133},{ 8}}, {{ 69},{ 8}}, +{{197},{ 8}}, {{ 37},{ 8}}, {{165},{ 8}}, {{101},{ 8}}, {{229},{ 8}}, +{{ 21},{ 8}}, {{149},{ 8}}, {{ 85},{ 8}}, {{213},{ 8}}, {{ 53},{ 8}}, +{{181},{ 8}}, {{117},{ 8}}, {{245},{ 8}}, {{ 13},{ 8}}, {{141},{ 8}}, +{{ 77},{ 8}}, {{205},{ 8}}, {{ 45},{ 8}}, {{173},{ 8}}, {{109},{ 8}}, +{{237},{ 8}}, {{ 29},{ 8}}, {{157},{ 8}}, {{ 93},{ 8}}, {{221},{ 8}}, +{{ 61},{ 8}}, {{189},{ 8}}, {{125},{ 8}}, {{253},{ 8}}, {{ 19},{ 9}}, +{{275},{ 9}}, {{147},{ 9}}, {{403},{ 9}}, {{ 83},{ 9}}, {{339},{ 9}}, +{{211},{ 9}}, {{467},{ 9}}, {{ 51},{ 9}}, {{307},{ 9}}, {{179},{ 9}}, +{{435},{ 9}}, {{115},{ 9}}, {{371},{ 9}}, {{243},{ 9}}, {{499},{ 9}}, +{{ 11},{ 9}}, {{267},{ 9}}, {{139},{ 9}}, {{395},{ 9}}, {{ 75},{ 9}}, +{{331},{ 9}}, {{203},{ 9}}, {{459},{ 9}}, {{ 43},{ 9}}, {{299},{ 9}}, +{{171},{ 9}}, {{427},{ 9}}, {{107},{ 9}}, {{363},{ 9}}, {{235},{ 9}}, +{{491},{ 9}}, {{ 27},{ 9}}, {{283},{ 9}}, {{155},{ 9}}, {{411},{ 9}}, +{{ 91},{ 9}}, {{347},{ 9}}, {{219},{ 9}}, {{475},{ 9}}, {{ 59},{ 9}}, +{{315},{ 9}}, {{187},{ 9}}, {{443},{ 9}}, {{123},{ 9}}, {{379},{ 9}}, +{{251},{ 9}}, {{507},{ 9}}, {{ 7},{ 9}}, {{263},{ 9}}, {{135},{ 9}}, +{{391},{ 9}}, {{ 71},{ 9}}, {{327},{ 9}}, {{199},{ 9}}, {{455},{ 9}}, +{{ 39},{ 9}}, {{295},{ 9}}, {{167},{ 9}}, {{423},{ 9}}, {{103},{ 9}}, +{{359},{ 9}}, {{231},{ 9}}, {{487},{ 9}}, {{ 23},{ 9}}, {{279},{ 9}}, +{{151},{ 9}}, {{407},{ 9}}, {{ 87},{ 9}}, {{343},{ 9}}, {{215},{ 9}}, +{{471},{ 9}}, {{ 55},{ 9}}, {{311},{ 9}}, {{183},{ 9}}, {{439},{ 9}}, +{{119},{ 9}}, {{375},{ 9}}, {{247},{ 9}}, {{503},{ 9}}, {{ 15},{ 9}}, +{{271},{ 9}}, {{143},{ 9}}, {{399},{ 9}}, {{ 79},{ 9}}, {{335},{ 9}}, +{{207},{ 9}}, {{463},{ 9}}, {{ 47},{ 9}}, {{303},{ 9}}, {{175},{ 9}}, +{{431},{ 9}}, {{111},{ 9}}, {{367},{ 9}}, {{239},{ 9}}, {{495},{ 9}}, +{{ 31},{ 9}}, {{287},{ 9}}, {{159},{ 9}}, {{415},{ 9}}, {{ 95},{ 9}}, +{{351},{ 9}}, {{223},{ 9}}, {{479},{ 9}}, {{ 63},{ 9}}, {{319},{ 9}}, +{{191},{ 9}}, {{447},{ 9}}, {{127},{ 9}}, {{383},{ 9}}, {{255},{ 9}}, +{{511},{ 9}}, {{ 0},{ 7}}, {{ 64},{ 7}}, {{ 32},{ 7}}, {{ 96},{ 7}}, +{{ 16},{ 7}}, {{ 80},{ 7}}, {{ 48},{ 7}}, {{112},{ 7}}, {{ 8},{ 7}}, +{{ 72},{ 7}}, {{ 40},{ 7}}, {{104},{ 7}}, {{ 24},{ 7}}, {{ 88},{ 7}}, +{{ 56},{ 7}}, {{120},{ 7}}, {{ 4},{ 7}}, {{ 68},{ 7}}, {{ 36},{ 7}}, +{{100},{ 7}}, {{ 20},{ 7}}, {{ 84},{ 7}}, {{ 52},{ 7}}, {{116},{ 7}}, +{{ 3},{ 8}}, {{131},{ 8}}, {{ 67},{ 8}}, {{195},{ 8}}, {{ 35},{ 8}}, +{{163},{ 8}}, {{ 99},{ 8}}, {{227},{ 8}} +}; + +local const ct_data static_dtree[D_CODES] = { +{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}}, +{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}}, +{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}}, +{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}}, +{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}}, +{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}} +}; + +const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = { + 0, 1, 2, 3, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, + 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, +10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, +11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, +12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13, +13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, +13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, +14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, +15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 0, 0, 16, 17, +18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, +23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, +28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, +29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, +29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, +29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29 +}; + +const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= { + 0, 1, 2, 3, 4, 5, 6, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 12, 12, +13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, +17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19, +19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, +21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22, +22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, +23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, +25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, +26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, +27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28 +}; + +local const int base_length[LENGTH_CODES] = { +0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56, +64, 80, 96, 112, 128, 160, 192, 224, 0 +}; + +local const int base_dist[D_CODES] = { + 0, 1, 2, 3, 4, 6, 8, 12, 16, 24, + 32, 48, 64, 96, 128, 192, 256, 384, 512, 768, + 1024, 1536, 2048, 3072, 4096, 6144, 8192, 12288, 16384, 24576 +}; + diff --git a/zlib/twain.txt b/zlib/twain.txt new file mode 100644 index 0000000..19597cb --- /dev/null +++ b/zlib/twain.txt @@ -0,0 +1,251 @@ + +Most of the Parthenon's imposing columns are still standing, but the roof +is gone. It was a perfect building two hundred and fifty years ago, when +a shell dropped into the Venetian magazine stored here, and the explosion +which followed wrecked and unroofed it. I remember but little about the +Parthenon, and I have put in one or two facts and figures for the use of +other people with short memories. Got them from the guide-book. + +As we wandered thoughtfully down the marble-paved length of this stately +temple, the scene about us was strangely impressive. Here and there, in +lavish profusion, were gleaming white statues of men and women, propped +against blocks of marble, some of them armless, some without legs, others +headless--but all looking mournful in the moonlight, and startlingly +human! They rose up and confronted the midnight intruder on every side +--they stared at him with stony eyes from unlooked-for nooks and recesses; +they peered at him over fragmentary heaps far down the desolate +corridors; they barred his way in the midst of the broad forum, and +solemnly pointed with handless arms the way from the sacred fane; and +through the roofless temple the moon looked down, and banded the floor +and darkened the scattered fragments and broken statues with the slanting +shadows of the columns. + +What a world of ruined sculpture was about us! Set up in rows--stacked +up in piles--scattered broadcast over the wide area of the Acropolis +--were hundreds of crippled statues of all sizes and of the most exquisite +workmanship; and vast fragments of marble that once belonged to the +entablatures, covered with bas-reliefs representing battles and sieges, +ships of war with three and four tiers of oars, pageants and processions +--every thing one could think of. History says that the temples of the +Acropolis were filled with the noblest works of Praxiteles and Phidias, +and of many a great master in sculpture besides--and surely these elegant +fragments attest it. + +We walked out into the grass-grown, fragment-strewn court beyond the +Parthenon. It startled us, every now and then, to see a stony white face +stare suddenly up at us out of the grass with its dead eyes. The place +seemed alive with ghosts. I half expected to see the Athenian heroes of +twenty centuries ago glide out of the shadows and steal into the old +temple they knew so well and regarded with such boundless pride. + +The full moon was riding high in the cloudless heavens, now. We +sauntered carelessly and unthinkingly to the edge of the lofty +battlements of the citadel, and looked down--a vision! And such a +vision! Athens by moonlight! The prophet that thought the splendors of +the New Jerusalem were revealed to him, surely saw this instead! It lay +in the level plain right under our feet--all spread abroad like a +picture--and we looked down upon it as we might have looked from a +balloon. We saw no semblance of a street, but every house, every window, +every clinging vine, every projection was as distinct and sharply marked +as if the time were noon-day; and yet there was no glare, no glitter, +nothing harsh or repulsive--the noiseless city was flooded with the +mellowest light that ever streamed from the moon, and seemed like some +living creature wrapped in peaceful slumber. On its further side was a +little temple, whose delicate pillars and ornate front glowed with a rich +lustre that chained the eye like a spell; and nearer by, the palace of +the king reared its creamy walls out of the midst of a great garden of +shrubbery that was flecked all over with a random shower of amber lights +--a spray of golden sparks that lost their brightness in the glory of the +moon, and glinted softly upon the sea of dark foliage like the pallid +stars of the milky-way. Overhead the stately columns, majestic still in +their ruin--under foot the dreaming city--in the distance the silver sea +--not on the broad earth is there an other picture half so beautiful! + +As we turned and moved again through the temple, I wished that the +illustrious men who had sat in it in the remote ages could visit it again +and reveal themselves to our curious eyes--Plato, Aristotle, Demosthenes, +Socrates, Phocion, Pythagoras, Euclid, Pindar, Xenophon, Herodotus, +Praxiteles and Phidias, Zeuxis the painter. What a constellation of +celebrated names! But more than all, I wished that old Diogenes, groping +so patiently with his lantern, searching so zealously for one solitary +honest man in all the world, might meander along and stumble on our +party. I ought not to say it, may be, but still I suppose he would have +put out his light. + +We left the Parthenon to keep its watch over old Athens, as it had kept +it for twenty-three hundred years, and went and stood outside the walls +of the citadel. In the distance was the ancient, but still almost +perfect Temple of Theseus, and close by, looking to the west, was the +Bema, from whence Demosthenes thundered his philippics and fired the +wavering patriotism of his countrymen. To the right was Mars Hill, where +the Areopagus sat in ancient times and where St. Paul defined his +position, and below was the market-place where he "disputed daily" with +the gossip-loving Athenians. We climbed the stone steps St. Paul +ascended, and stood in the square-cut place he stood in, and tried to +recollect the Bible account of the matter--but for certain reasons, I +could not recall the words. I have found them since: + + "Now while Paul waited for them at Athens, his spirit was stirred in + him, when he saw the city wholly given up to idolatry. Therefore + disputed he in the synagogue with the Jews, and with the devout + persons, and in the market daily with them that met with him. + * * * * * * * * * + "And they took him and brought him unto Areopagus, saying, May we + know what this new doctrine whereof thou speakest is? + * * * * * * * * * + "Then Paul stood in the midst of Mars hill, and said, Ye men of + Athens, I perceive that in all things ye are too superstitious; For + as I passed by and beheld your devotions, I found an altar with this + inscription: To THE UNKNOWN GOD. Whom, therefore, ye ignorantly + worship, him declare I unto you."--Acts, ch. xvii." + +It occurred to us, after a while, that if we wanted to get home before +daylight betrayed us, we had better be moving. So we hurried away. When +far on our road, we had a parting view of the Parthenon, with the +moonlight streaming through its open colonnades and touching its capitals +with silver. As it looked then, solemn, grand, and beautiful it will +always remain in our memories. + +As we marched along, we began to get over our fears, and ceased to care +much about quarantine scouts or any body else. We grew bold and +reckless; and once, in a sudden burst of courage, I even threw a stone at +a dog. It was a pleasant reflection, though, that I did not hit him, +because his master might just possibly have been a policeman. Inspired +by this happy failure, my valor became utterly uncontrollable, and at +intervals I absolutely whistled, though on a moderate key. But boldness +breeds boldness, and shortly I plunged into a Vineyard, in the full light +of the moon, and captured a gallon of superb grapes, not even minding the +presence of a peasant who rode by on a mule. Denny and Birch followed my +example. + +Now I had grapes enough for a dozen, but then Jackson was all swollen up +with courage, too, and he was obliged to enter a vineyard presently. The +first bunch he seized brought trouble. A frowsy, bearded brigand sprang +into the road with a shout, and flourished a musket in the light of the +moon! We sidled toward the Piraeus--not running you understand, but only +advancing with celerity. The brigand shouted again, but still we +advanced. It was getting late, and we had no time to fool away on every +ass that wanted to drivel Greek platitudes to us. We would just as soon +have talked with him as not if we had not been in a hurry. Presently +Denny said, "Those fellows are following us!" + +We turned, and, sure enough, there they were--three fantastic pirates +armed with guns. We slackened our pace to let them come up, and in the +meantime I got out my cargo of grapes and dropped them firmly but +reluctantly into the shadows by the wayside. But I was not afraid. I +only felt that it was not right to steal grapes. And all the more so +when the owner was around--and not only around, but with his friends +around also. The villains came up and searched a bundle Dr. Birch had in +his hand, and scowled upon him when they found it had nothing in it but +some holy rocks from Mars Hill, and these were not contraband. They +evidently suspected him of playing some wretched fraud upon them, and +seemed half inclined to scalp the party. But finally they dismissed us +with a warning, couched in excellent Greek, I suppose, and dropped +tranquilly in our wake. When they had gone three hundred yards they +stopped, and we went on rejoiced. But behold, another armed rascal came +out of the shadows and took their place, and followed us two hundred +yards. Then he delivered us over to another miscreant, who emerged from +some mysterious place, and he in turn to another! For a mile and a half +our rear was guarded all the while by armed men. I never traveled in so +much state before in all my life. + +It was a good while after that before we ventured to steal any more +grapes, and when we did we stirred up another troublesome brigand, and +then we ceased all further speculation in that line. I suppose that +fellow that rode by on the mule posted all the sentinels, from Athens to +the Piraeus, about us. + +Every field on that long route was watched by an armed sentinel, some of +whom had fallen asleep, no doubt, but were on hand, nevertheless. This +shows what sort of a country modern Attica is--a community of +questionable characters. These men were not there to guard their +possessions against strangers, but against each other; for strangers +seldom visit Athens and the Piraeus, and when they do, they go in +daylight, and can buy all the grapes they want for a trifle. The modern +inhabitants are confiscators and falsifiers of high repute, if gossip +speaks truly concerning them, and I freely believe it does. + +Just as the earliest tinges of the dawn flushed the eastern sky and +turned the pillared Parthenon to a broken harp hung in the pearly +horizon, we closed our thirteenth mile of weary, round-about marching, +and emerged upon the sea-shore abreast the ships, with our usual escort +of fifteen hundred Piraean dogs howling at our heels. We hailed a boat +that was two or three hundred yards from shore, and discovered +in a moment that it was a police-boat on the lookout for any +quarantine-breakers that might chance to be abroad. So we dodged--we +were used to that by this time--and when the scouts reached the spot we +had so lately occupied, we were absent. They cruised along the shore, +but in the wrong direction, and shortly our own boat issued from the +gloom and took us aboard. They had heard our signal on the ship. We +rowed noiselessly away, and before the police-boat came in sight again, +we were safe at home once more. + +Four more of our passengers were anxious to visit Athens, and started +half an hour after we returned; but they had not been ashore five minutes +till the police discovered and chased them so hotly that they barely +escaped to their boat again, and that was all. They pursued the +enterprise no further. + +We set sail for Constantinople to-day, but some of us little care for +that. We have seen all there was to see in the old city that had its +birth sixteen hundred years before Christ was born, and was an old town +before the foundations of Troy were laid--and saw it in its most +attractive aspect. Wherefore, why should we worry? + +Two other passengers ran the blockade successfully last night. So we +learned this morning. They slipped away so quietly that they were not +missed from the ship for several hours. They had the hardihood to march +into the Piraeus in the early dusk and hire a carriage. They ran some +danger of adding two or three months' imprisonment to the other novelties +of their Holy Land Pleasure Excursion. I admire "cheek."--[Quotation +from the Pilgrims.]--But they went and came safely, and never walked a +step. + + + + +CHAPTER XXXIII. + +From Athens all through the islands of the Grecian Archipelago, we saw +little but forbidding sea-walls and barren hills, sometimes surmounted by +three or four graceful columns of some ancient temple, lonely and +deserted--a fitting symbol of the desolation that has come upon all +Greece in these latter ages. We saw no ploughed fields, very few +villages, no trees or grass or vegetation of any kind, scarcely, and +hardly ever an isolated house. Greece is a bleak, unsmiling desert, +without agriculture, manufactures or commerce, apparently. What supports +its poverty-stricken people or its Government, is a mystery. + +I suppose that ancient Greece and modern Greece compared, furnish the +most extravagant contrast to be found in history. George I., an infant +of eighteen, and a scraggy nest of foreign office holders, sit in the +places of Themistocles, Pericles, and the illustrious scholars and +generals of the Golden Age of Greece. The fleets that were the wonder of +the world when the Parthenon was new, are a beggarly handful of +fishing-smacks now, and the manly people that performed such miracles of +valor at Marathon are only a tribe of unconsidered slaves to-day. The +classic Illyssus has gone dry, and so have all the sources of Grecian +wealth and greatness. The nation numbers only eight hundred thousand +souls, and there is poverty and misery and mendacity enough among them +to furnish forty millions and be liberal about it. Under King Otho the +revenues of the State were five millions of dollars--raised from a tax +of one-tenth of all the agricultural products of the land (which tenth +the farmer had to bring to the royal granaries on pack-mules any +distance not exceeding six leagues) and from extravagant taxes on trade +and commerce. Out of that five millions the small tyrant tried to keep +an army of ten thousand men, pay all the hundreds of useless Grand +Equerries in Waiting, First Grooms of the Bedchamber, Lord High +Chancellors of the Exploded Exchequer, and all the other absurdities +which these puppy-kingdoms indulge in, in imitation of the great +monarchies; and in addition he set about building a white marble palace +to cost about five millions itself. The result was, simply: ten into +five goes no times and none over. All these things could not be done +with five millions, and Otho fell into trouble. + +The Greek throne, with its unpromising adjuncts of a ragged population of +ingenious rascals who were out of employment eight months in the year +because there was little for them to borrow and less to confiscate, and a +waste of barren hills and weed-grown deserts, went begging for a good +while. It was offered to one of Victoria's sons, and afterwards to +various other younger sons of royalty who had no thrones and were out of +business, but they all had t diff --git a/zlib/uart.c b/zlib/uart.c new file mode 100644 index 0000000..5b6e3cc --- /dev/null +++ b/zlib/uart.c @@ -0,0 +1,94 @@ + +//------------------------------------------------------------------------- +//------------------------------------------------------------------------- + +extern void PUT32 ( unsigned int, unsigned int ); +extern unsigned int GET32 ( unsigned int ); +extern void dummy ( unsigned int ); + +#define GPFSEL1 0x20200004 +#define GPSET0 0x2020001C +#define GPCLR0 0x20200028 +#define GPPUD 0x20200094 +#define GPPUDCLK0 0x20200098 + +#define AUX_ENABLES 0x20215004 +#define AUX_MU_IO_REG 0x20215040 +#define AUX_MU_IER_REG 0x20215044 +#define AUX_MU_IIR_REG 0x20215048 +#define AUX_MU_LCR_REG 0x2021504C +#define AUX_MU_MCR_REG 0x20215050 +#define AUX_MU_LSR_REG 0x20215054 +#define AUX_MU_MSR_REG 0x20215058 +#define AUX_MU_SCRATCH 0x2021505C +#define AUX_MU_CNTL_REG 0x20215060 +#define AUX_MU_STAT_REG 0x20215064 +#define AUX_MU_BAUD_REG 0x20215068 + +//GPIO14 TXD0 and TXD1 +//GPIO15 RXD0 and RXD1 +//alt function 5 for uart1 + +//((250,000,000/115200)/8)-1 = 270 +//------------------------------------------------------------------------ +void uart_putc ( unsigned int c ) +{ + while(1) + { + if(GET32(AUX_MU_LSR_REG)&0x20) break; + } + PUT32(AUX_MU_IO_REG,c); +} +//------------------------------------------------------------------------ +void hexstrings ( unsigned int d ) +{ + //unsigned int ra; + unsigned int rb; + unsigned int rc; + + rb=32; + while(1) + { + rb-=4; + rc=(d>>rb)&0xF; + if(rc>9) rc+=0x37; else rc+=0x30; + uart_putc(rc); + if(rb==0) break; + } + uart_putc(0x20); +} +//------------------------------------------------------------------------ +void hexstring ( unsigned int d ) +{ + hexstrings(d); + uart_putc(0x0D); + uart_putc(0x0A); +} +//------------------------------------------------------------------------ +void uart_init ( void ) +{ + unsigned int ra; + + PUT32(AUX_ENABLES,1); + PUT32(AUX_MU_IER_REG,0); + PUT32(AUX_MU_CNTL_REG,0); + PUT32(AUX_MU_LCR_REG,3); + PUT32(AUX_MU_MCR_REG,0); + PUT32(AUX_MU_IER_REG,0); + PUT32(AUX_MU_IIR_REG,0xC6); + PUT32(AUX_MU_BAUD_REG,270); + ra=GET32(GPFSEL1); + ra&=~(7<<12); //gpio14 + ra|=2<<12; //alt5 + ra&=~(7<<15); //gpio15 + ra|=2<<15; //alt5 + PUT32(GPFSEL1,ra); + PUT32(GPPUD,0); + for(ra=0;ra<150;ra++) dummy(ra); + PUT32(GPPUDCLK0,(1<<14)|(1<<15)); + for(ra=0;ra<150;ra++) dummy(ra); + PUT32(GPPUDCLK0,0); + PUT32(AUX_MU_CNTL_REG,3); +} +//------------------------------------------------------------------------- +//------------------------------------------------------------------------- diff --git a/zlib/uncompr.c b/zlib/uncompr.c new file mode 100644 index 0000000..4f2d25c --- /dev/null +++ b/zlib/uncompr.c @@ -0,0 +1,59 @@ +/* uncompr.c -- decompress a memory buffer + * Copyright (C) 1995-2003, 2010 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#define ZLIB_INTERNAL +#include "zlib.h" + +/* =========================================================================== + Decompresses 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 large enough to hold the + entire uncompressed data. (The size of the uncompressed data must have + been saved previously by the compressor and transmitted to the decompressor + by some mechanism outside the scope of this compression library.) + Upon exit, destLen is the actual size of the compressed buffer. + + 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. +*/ +int ZEXPORT uncompress (dest, destLen, source, sourceLen) + Bytef *dest; + uIntf *destLen; + const Bytef *source; + uInt sourceLen; +{ + z_stream stream; + int err; + + stream.next_in = (Bytef*)source; + stream.avail_in = (uInt)sourceLen; + /* Check for source > 64K on 16-bit machine: */ + if ((uInt)stream.avail_in != sourceLen) return Z_BUF_ERROR; + + stream.next_out = dest; + stream.avail_out = (uInt)*destLen; + if ((uInt)stream.avail_out != *destLen) return Z_BUF_ERROR; + + stream.zalloc = (alloc_func)0; + stream.zfree = (free_func)0; + + err = inflateInit(&stream); + if (err != Z_OK) return err; + + err = inflate(&stream, Z_FINISH); + if (err != Z_STREAM_END) { + inflateEnd(&stream); + if (err == Z_NEED_DICT || (err == Z_BUF_ERROR && stream.avail_in == 0)) + return Z_DATA_ERROR; + return err; + } + *destLen = stream.total_out; + + err = inflateEnd(&stream); + return err; +} diff --git a/zlib/vectors.s b/zlib/vectors.s new file mode 100644 index 0000000..b0b3a90 --- /dev/null +++ b/zlib/vectors.s @@ -0,0 +1,34 @@ + +.globl _start +_start: + b reset + b hang + b hang + b hang + b hang + b hang + b hang + b hang + +reset: + mov sp,#0x200000 + bl notmain +hang: b hang + +.globl PUT32 +PUT32: + str r1,[r0] + bx lr + +.globl GET32 +GET32: + ldr r0,[r0] + bx lr + +.globl dummy +dummy: + bx lr + +.globl memset +memset: + b ZMEMSET diff --git a/zlib/zconf.h b/zlib/zconf.h new file mode 100644 index 0000000..2bd7c39 --- /dev/null +++ b/zlib/zconf.h @@ -0,0 +1,506 @@ +/* zconf.h -- configuration of the zlib compression library + * Copyright (C) 1995-2012 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#ifndef ZCONF_H +#define ZCONF_H + +/* + * If you *really* need a unique prefix for all types and library functions, + * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. + * Even better than compiling with -DZ_PREFIX would be to use configure to set + * this permanently in zconf.h using "./configure --zprefix". + */ +#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */ +# define Z_PREFIX_SET + +/* all linked symbols */ +# define _dist_code z__dist_code +# define _length_code z__length_code +# define _tr_align z__tr_align +# define _tr_flush_block z__tr_flush_block +# define _tr_init z__tr_init +# define _tr_stored_block z__tr_stored_block +# define _tr_tally z__tr_tally +# define adler32 z_adler32 +# define adler32_combine z_adler32_combine +# define adler32_combine64 z_adler32_combine64 +# ifndef Z_SOLO +# define compress z_compress +# define compress2 z_compress2 +# define compressBound z_compressBound +# endif +# define crc32 z_crc32 +# define crc32_combine z_crc32_combine +# define crc32_combine64 z_crc32_combine64 +# define deflate z_deflate +# define deflateBound z_deflateBound +# define deflateCopy z_deflateCopy +# define deflateEnd z_deflateEnd +# define deflateInit2_ z_deflateInit2_ +# define deflateInit_ z_deflateInit_ +# define deflateParams z_deflateParams +# define deflatePending z_deflatePending +# define deflatePrime z_deflatePrime +# define deflateReset z_deflateReset +# define deflateResetKeep z_deflateResetKeep +# define deflateSetDictionary z_deflateSetDictionary +# define deflateSetHeader z_deflateSetHeader +# define deflateTune z_deflateTune +# define deflate_copyright z_deflate_copyright +# define get_crc_table z_get_crc_table +# ifndef Z_SOLO +# define gz_error z_gz_error +# define gz_intmax z_gz_intmax +# define gz_strwinerror z_gz_strwinerror +# define gzbuffer z_gzbuffer +# define gzclearerr z_gzclearerr +# define gzclose z_gzclose +# define gzclose_r z_gzclose_r +# define gzclose_w z_gzclose_w +# define gzdirect z_gzdirect +# define gzdopen z_gzdopen +# define gzeof z_gzeof +# define gzerror z_gzerror +# define gzflush z_gzflush +# define gzgetc z_gzgetc +# define gzgetc_ z_gzgetc_ +# define gzgets z_gzgets +# define gzoffset z_gzoffset +# define gzoffset64 z_gzoffset64 +# define gzopen z_gzopen +# define gzopen64 z_gzopen64 +# ifdef _WIN32 +# define gzopen_w z_gzopen_w +# endif +# define gzprintf z_gzprintf +# define gzputc z_gzputc +# define gzputs z_gzputs +# define gzread z_gzread +# define gzrewind z_gzrewind +# define gzseek z_gzseek +# define gzseek64 z_gzseek64 +# define gzsetparams z_gzsetparams +# define gztell z_gztell +# define gztell64 z_gztell64 +# define gzungetc z_gzungetc +# define gzwrite z_gzwrite +# endif +# define inflate z_inflate +# define inflateBack z_inflateBack +# define inflateBackEnd z_inflateBackEnd +# define inflateBackInit_ z_inflateBackInit_ +# define inflateCopy z_inflateCopy +# define inflateEnd z_inflateEnd +# define inflateGetHeader z_inflateGetHeader +# define inflateInit2_ z_inflateInit2_ +# define inflateInit_ z_inflateInit_ +# define inflateMark z_inflateMark +# define inflatePrime z_inflatePrime +# define inflateReset z_inflateReset +# define inflateReset2 z_inflateReset2 +# define inflateSetDictionary z_inflateSetDictionary +# define inflateSync z_inflateSync +# define inflateSyncPoint z_inflateSyncPoint +# define inflateUndermine z_inflateUndermine +# define inflateResetKeep z_inflateResetKeep +# define inflate_copyright z_inflate_copyright +# define inflate_fast z_inflate_fast +# define inflate_table z_inflate_table +# ifndef Z_SOLO +# define uncompress z_uncompress +# endif +# define zError z_zError +# ifndef Z_SOLO +# define zcalloc z_zcalloc +# define zcfree z_zcfree +# endif +# define zlibCompileFlags z_zlibCompileFlags +# define zlibVersion z_zlibVersion + +/* all zlib typedefs in zlib.h and zconf.h */ +# define Byte z_Byte +# define Bytef z_Bytef +# define alloc_func z_alloc_func +# define charf z_charf +# define free_func z_free_func +# ifndef Z_SOLO +# define gzFile z_gzFile +# endif +# define gz_header z_gz_header +# define gz_headerp z_gz_headerp +# define in_func z_in_func +# define intf z_intf +# define out_func z_out_func +# define uInt z_uInt +# define uIntf z_uIntf +# define uInt z_uInt +# define uIntf z_uIntf +# define voidp z_voidp +# define voidpc z_voidpc +# define voidpf z_voidpf + +/* all zlib structs in zlib.h and zconf.h */ +# define gz_header_s z_gz_header_s +# define internal_state z_internal_state + +#endif + +#if defined(__MSDOS__) && !defined(MSDOS) +# define MSDOS +#endif +#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) +# define OS2 +#endif +#if defined(_WINDOWS) && !defined(WINDOWS) +# define WINDOWS +#endif +#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) +# ifndef WIN32 +# define WIN32 +# endif +#endif +#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) +# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) +# ifndef SYS16BIT +# define SYS16BIT +# endif +# endif +#endif + +/* + * Compile with -DMAXSEG_64K if the alloc function cannot allocate more + * than 64k bytes at a time (needed on systems with 16-bit int). + */ +#ifdef SYS16BIT +# define MAXSEG_64K +#endif +#ifdef MSDOS +# define UNALIGNED_OK +#endif + +#ifdef __STDC_VERSION__ +# ifndef STDC +# define STDC +# endif +# if __STDC_VERSION__ >= 199901L +# ifndef STDC99 +# define STDC99 +# endif +# endif +#endif +#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) +# define STDC +#endif +#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) +# define STDC +#endif +#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) +# define STDC +#endif +#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) +# define STDC +#endif + +#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ +# define STDC +#endif + +#ifndef STDC +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const /* note: need a more gentle solution here */ +# endif +#endif + +#if defined(ZLIB_CONST) && !defined(z_const) +# define z_const const +#else +# define z_const +#endif + +/* Some Mac compilers merge all .h files incorrectly: */ +#if defined(__MWERKS__)||defined(applec)||defined(THINK_C)||defined(__SC__) +# define NO_DUMMY_DECL +#endif + +/* Maximum value for memLevel in deflateInit2 */ +#ifndef MAX_MEM_LEVEL +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif +#endif + +/* Maximum value for windowBits in deflateInit2 and inflateInit2. + * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files + * created by gzip. (Files created by minigzip can still be extracted by + * gzip.) + */ +#ifndef MAX_WBITS +# define MAX_WBITS 15 /* 32K LZ77 window */ +#endif + +/* The memory requirements for deflate are (in bytes): + (1 << (windowBits+2)) + (1 << (memLevel+9)) + that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) + plus a few kilobytes for small objects. For example, if you want to reduce + the default memory requirements from 256K to 128K, compile with + make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" + Of course this will generally degrade compression (there's no free lunch). + + The memory requirements for inflate are (in bytes) 1 << windowBits + that is, 32K for windowBits=15 (default value) plus a few kilobytes + for small objects. +*/ + + /* Type declarations */ + +#ifndef OF /* function prototypes */ +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif +#endif + +#ifndef Z_ARG /* function prototypes for stdarg */ +# if defined(STDC) || defined(Z_HAVE_STDARG_H) +# define Z_ARG(args) args +# else +# define Z_ARG(args) () +# endif +#endif + +/* The following definitions for FAR are needed only for MSDOS mixed + * model programming (small or medium model with some far allocations). + * This was tested only with MSC; for other MSDOS compilers you may have + * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, + * just define FAR to be empty. + */ +#ifdef SYS16BIT +# if defined(M_I86SM) || defined(M_I86MM) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +# endif +# if (defined(__SMALL__) || defined(__MEDIUM__)) + /* Turbo C small or medium model */ +# define SMALL_MEDIUM +# ifdef __BORLANDC__ +# define FAR _far +# else +# define FAR far +# endif +# endif +#endif + +#if defined(WINDOWS) || defined(WIN32) + /* If building or using zlib as a DLL, define ZLIB_DLL. + * This is not mandatory, but it offers a little performance increase. + */ +# ifdef ZLIB_DLL +# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) +# ifdef ZLIB_INTERNAL +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +# endif +# endif /* ZLIB_DLL */ + /* If building or using zlib with the WINAPI/WINAPIV calling convention, + * define ZLIB_WINAPI. + * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. + */ +# ifdef ZLIB_WINAPI +# ifdef FAR +# undef FAR +# endif +# include + /* No need for _export, use ZLIB.DEF instead. */ + /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR CDECL +# endif +# endif +#endif + +#if defined (__BEOS__) +# ifdef ZLIB_DLL +# ifdef ZLIB_INTERNAL +# define ZEXPORT __declspec(dllexport) +# define ZEXPORTVA __declspec(dllexport) +# else +# define ZEXPORT __declspec(dllimport) +# define ZEXPORTVA __declspec(dllimport) +# endif +# endif +#endif + +#ifndef ZEXTERN +# define ZEXTERN extern +#endif +#ifndef ZEXPORT +# define ZEXPORT +#endif +#ifndef ZEXPORTVA +# define ZEXPORTVA +#endif + +#ifndef FAR +# define FAR +#endif + +#if !defined(__MACTYPES__) +typedef unsigned char Byte; /* 8 bits */ +#endif +//typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned int uInt; /* 32 bits or more */ + +#ifdef SMALL_MEDIUM + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR +#else + typedef Byte FAR Bytef; +#endif +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; +//typedef uInt FAR uIntf; + +#ifdef STDC + typedef void const *voidpc; + typedef void FAR *voidpf; + typedef void *voidp; +#else + typedef Byte const *voidpc; + typedef Byte FAR *voidpf; + typedef Byte *voidp; +#endif + +/* ./configure may #define Z_U4 here */ + +#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC) +//# include +# if (UINT_MAX == 0xffffffffUL) +# define Z_U4 unsigned +# else +# if (uInt_MAX == 0xffffffffUL) +# define Z_U4 unsigned int +# else +# if (USHRT_MAX == 0xffffffffUL) +# define Z_U4 unsigned short +# endif +# endif +# endif +#endif + +#ifdef Z_U4 + typedef Z_U4 z_crc_t; +#else + typedef unsigned int z_crc_t; +#endif + +#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ +# define Z_HAVE_UNISTD_H +#endif + +#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */ +# define Z_HAVE_STDARG_H +#endif + +#ifdef STDC +# ifndef Z_SOLO +//**/# include /* for off_t */ +# endif +#endif + +#ifdef _WIN32 +# include /* for wchar_t */ +#endif + +/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and + * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even + * though the former does not conform to the LFS document), but considering + * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as + * equivalently requesting no 64-bit operations + */ +#if defined(LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1 +# undef _LARGEFILE64_SOURCE +#endif + +#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H) +# define Z_HAVE_UNISTD_H +#endif +#ifndef Z_SOLO +# if defined(Z_HAVE_UNISTD_H) || defined(LARGEFILE64_SOURCE) +# include /* for SEEK_*, off_t, and _LFS64_LARGEFILE */ +# ifdef VMS +# include /* for off_t */ +# endif +# ifndef z_off_t +# define z_off_t off_t +# endif +# endif +#endif + +#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0 +# define Z_LFS64 +#endif + +#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64) +# define Z_LARGE64 +#endif + +#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64) +# define Z_WANT64 +#endif + +#if !defined(SEEK_SET) && !defined(Z_SOLO) +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +#endif + +#ifndef z_off_t +# define z_off_t int +#endif + +#if !defined(_WIN32) && defined(Z_LARGE64) +# define z_off64_t off64_t +#else +# if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO) +# define z_off64_t __int64 +# else +# define z_off64_t z_off_t +# endif +#endif + +/* MVS linker does not support external names larger than 8 bytes */ +#if defined(__MVS__) + #pragma map(deflateInit_,"DEIN") + #pragma map(deflateInit2_,"DEIN2") + #pragma map(deflateEnd,"DEEND") + #pragma map(deflateBound,"DEBND") + #pragma map(inflateInit_,"ININ") + #pragma map(inflateInit2_,"ININ2") + #pragma map(inflateEnd,"INEND") + #pragma map(inflateSync,"INSY") + #pragma map(inflateSetDictionary,"INSEDI") + #pragma map(compressBound,"CMBND") + #pragma map(inflate_table,"INTABL") + #pragma map(inflate_fast,"INFA") + #pragma map(inflate_copyright,"INCOPY") +#endif + +#endif /* ZCONF_H */ diff --git a/zlib/zlib.h b/zlib/zlib.h new file mode 100644 index 0000000..dbacc8f --- /dev/null +++ b/zlib/zlib.h @@ -0,0 +1,1744 @@ +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.2.7, May 2nd, 2012 + + Copyright (C) 1995-2012 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 http://tools.ietf.org/html/rfc1950 + (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). +*/ + +#ifndef ZLIB_H +#define ZLIB_H + +#include "zconf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ZLIB_VERSION "1.2.7" +#define ZLIB_VERNUM 0x1270 +#define ZLIB_VER_MAJOR 1 +#define ZLIB_VER_MINOR 2 +#define ZLIB_VER_REVISION 7 +#define ZLIB_VER_SUBREVISION 0 + +/* + 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, + 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 compressed data format used by default 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 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. + + This library can optionally read and write gzip streams in memory as well. + + 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. + + 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. +*/ + +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address)); + +struct internal_state; + +typedef struct z_stream_s { + z_const Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uInt total_in; /* total number of input bytes read so far */ + + Bytef *next_out; /* next output byte should be put there */ + uInt avail_out; /* remaining free space at next_out */ + uInt total_out; /* total number of bytes output so far */ + + z_const char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *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: binary or text */ + uInt adler; /* adler32 value of the uncompressed data */ + uInt reserved; /* reserved for future use */ +} z_stream; + +typedef z_stream FAR *z_streamp; + +/* + gzip header information passed to and from zlib routines. See RFC 1952 + for more details on the meanings of these fields. +*/ +typedef struct gz_header_s { + int text; /* true if compressed data believed to be text */ + uInt time; /* modification time */ + int xflags; /* extra flags (not used when writing a gzip file) */ + int os; /* operating system */ + Bytef *extra; /* pointer to extra field or Z_NULL if none */ + uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ + uInt extra_max; /* space at extra (only when reading header) */ + Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ + uInt name_max; /* space at name (only when reading header) */ + Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ + uInt comm_max; /* space at comment (only when reading header) */ + int hcrc; /* true if there was or will be a header crc */ + int done; /* true when done reading gzip header (not used + when writing a gzip file) */ +} gz_header; + +typedef gz_header FAR *gz_headerp; + +/* + 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. + + On 16-bit systems, the functions zalloc and zfree must be able to allocate + exactly 65536 bytes, but will not be required to allocate more than this if + the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS, pointers + returned by zalloc for objects of exactly 65536 bytes *must* have their + offset normalized to zero. The default allocation function provided by this + library ensures this (see zutil.c). To reduce memory requirements and avoid + any allocation of 64K objects, at the expense of compression ratio, compile + the library with -DMAX_WBITS=14 (see zconf.h). + + 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). +*/ + + /* 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 +/* Allowed flush values; see deflate() and inflate() below for details */ + +#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) +/* Return codes for the compression/decompression functions. Negative values + * are errors, positive values are used for special but normal events. + */ + +#define Z_NO_COMPRESSION 0 +#define Z_BEST_SPEED 1 +#define Z_BEST_COMPRESSION 9 +#define Z_DEFAULT_COMPRESSION (-1) +/* compression levels */ + +#define Z_FILTERED 1 +#define Z_HUFFMAN_ONLY 2 +#define Z_RLE 3 +#define Z_FIXED 4 +#define Z_DEFAULT_STRATEGY 0 +/* compression strategy; see deflateInit2() below for details */ + +#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 +/* 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) */ + +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ + +#define zlib_version zlibVersion() +/* for compatibility with versions < 1.0.2 */ + + + /* basic functions */ + +ZEXTERN const char * ZEXPORT zlibVersion OF((void)); +/* The application can compare zlibVersion and ZLIB_VERSION for consistency. + If the first character differs, the library code actually used is not + compatible with the zlib.h header file used by the application. 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 + zalloc, zfree and opaque must be initialized before by the caller. If + zalloc and zfree are set to Z_NULL, deflateInit updates them to use default + allocation functions. + + The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9: + 1 gives best speed, 9 gives best compression, 0 gives no compression at all + (the input data is simply copied a block at a time). Z_DEFAULT_COMPRESSION + requests a default compromise between speed and compression (currently + equivalent to level 6). + + deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if level is not a valid compression level, or + Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible + with the version assumed by the caller (ZLIB_VERSION). msg is set to null + if there is no error message. deflateInit does not perform any compression: + this will be done by deflate(). +*/ + + +ZEXTERN int ZEXPORT deflate OF((z_streamp strm, int flush)); +/* + deflate compresses as much data as possible, and stops when the input + buffer becomes empty or the output buffer becomes full. It may introduce + some output latency (reading input without producing any output) except when + forced to flush. + + The detailed semantics are as follows. deflate performs one or both of the + following actions: + + - Compress 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 and avail_in are updated and + processing will resume at this point for the next call of deflate(). + + - Provide more output starting at next_out and update next_out and avail_out + accordingly. This action is forced if the parameter flush is non zero. + Forcing flush frequently degrades the compression ratio, so this parameter + should be set only when necessary (in interactive applications). Some + output may be provided even if flush is not set. + + Before the call of deflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming more + output, and updating avail_in or avail_out accordingly; avail_out should + never be zero before the call. The application can consume the compressed + output when it wants, for example when the output buffer is full (avail_out + == 0), or after each call of deflate(). If deflate 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. + + Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to + decide how much data to accumulate before producing output, in order to + maximize compression. + + If the parameter flush is set to Z_SYNC_FLUSH, all pending output is + flushed to the output buffer and the output is aligned on a byte boundary, so + that the decompressor can get all input data available so far. (In + particular avail_in is zero after the call if enough output space has been + provided before the call.) Flushing may degrade compression for some + compression algorithms and so it should be used only when necessary. This + completes the current deflate block and follows it with an empty stored block + that is three bits plus filler bits to the next byte, followed by four bytes + (00 00 ff ff). + + If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the + output buffer, but the output is not aligned to a byte boundary. All of the + input data so far will be available to the decompressor, as for Z_SYNC_FLUSH. + This completes the current deflate block and follows it with an empty fixed + codes block that is 10 bits long. This assures that enough bytes are output + in order for the decompressor to finish the block before the empty fixed code + block. + + If flush is set to Z_BLOCK, a deflate block is completed and emitted, as + for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to + seven bits of the current block are held to be written as the next byte after + the next deflate block is completed. In this case, the decompressor may not + be provided enough bits at this point in order to complete decompression of + the data provided so far to the compressor. It may need to wait for the next + block to be emitted. This is for advanced applications that need to control + the emission of deflate blocks. + + If flush is set to Z_FULL_FLUSH, all output is flushed as with + Z_SYNC_FLUSH, and the compression state is reset so that decompression can + restart from this point if previous compressed data has been damaged or if + random access is desired. Using Z_FULL_FLUSH too often can seriously degrade + compression. + + 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). 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 was + enough output space; if deflate returns with Z_OK, this function must be + called again with Z_FINISH and more output space (updated avail_out) but no + 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 the + value returned by deflateBound (see below). Then deflate is guaranteed to + return Z_STREAM_END. If not enough output space is provided, deflate will + not return Z_STREAM_END, and it must be called again as described above. + + deflate() sets strm->adler to the adler32 checksum of all input read + so far (that is, total_in bytes). + + deflate() may update strm->data_type if it can make a good guess about + the input data type (Z_BINARY or Z_TEXT). In doubt, the data is considered + binary. This field is only for information purposes and does not affect the + compression algorithm in any manner. + + deflate() returns Z_OK if some progress has been made (more input + processed or more output produced), Z_STREAM_END if all input has been + 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 Z_NULL), Z_BUF_ERROR if no progress is possible + (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. +*/ + + +ZEXTERN int ZEXPORT deflateEnd OF((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. + + deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the + stream state was inconsistent, Z_DATA_ERROR if the stream was freed + prematurely (some input or output was discarded). In the error case, msg + may be set but then points to a static string (which must not be + deallocated). +*/ + + +/* +ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); + + Initializes the internal stream state for decompression. The fields + next_in, avail_in, zalloc, zfree and opaque must be initialized before by + the caller. If next_in is not Z_NULL and avail_in is large enough (the + exact value depends on the compression method), inflateInit determines the + compression method from the zlib header and allocates all data structures + accordingly; otherwise the allocation will be deferred to the first call of + inflate. If zalloc and zfree are set to Z_NULL, inflateInit updates them to + use default allocation functions. + + inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller, or Z_STREAM_ERROR if the parameters are + invalid, such as a null pointer to the structure. msg is set to null if + there is no error message. inflateInit does not perform any decompression + apart from possibly reading the zlib header if present: actual decompression + will be done by inflate(). (So next_in and avail_in may be modified, but + next_out and avail_out are unused and unchanged.) The current implementation + of inflateInit() does not process any header information -- that is deferred + until inflate() is called. +*/ + + +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 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. + + The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH, + Z_BLOCK, or Z_TREES. 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 gets 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. data_type is set as noted here every time inflate() returns for all + flush options, and so can be used to determine the amount of currently + consumed input in bits. + + The Z_TREES option behaves as Z_BLOCK does, but it also returns when the + end of each deflate block header is reached, before any actual data in that + block is decoded. This allows the caller to determine the length of the + deflate block header for later use in random access within a deflate block. + 256 is added to the value of strm->data_type when inflate() returns + immediately after reaching the end of the deflate block header. + + 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 of the uncompressed data for the + operation to complete. (The size of the uncompressed data may have been + saved by the compressor for this purpose.) The use of Z_FINISH is not + required to perform an inflation in one step. However it may be used to + inform inflate that a faster approach can be used for the single inflate() + call. Z_FINISH also informs inflate to not maintain a sliding window if the + stream completes, which reduces inflate's memory footprint. If the stream + does not complete, either because not all of the stream is provided or not + enough output space is provided, then a sliding window will be allocated and + inflate() can be called again to continue the operation as if Z_NO_FLUSH had + been used. + + 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 effects of the flush parameter in this implementation are + on the return value of inflate() as noted below, when inflate() returns early + when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of + memory for a sliding window when Z_FINISH is used. + + If a preset dictionary is needed after this call (see inflateSetDictionary + below), inflate sets strm->adler to the Adler-32 checksum of the dictionary + chosen by the compressor and returns Z_NEED_DICT; otherwise it sets + strm->adler to the Adler-32 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() can decompress and check either zlib-wrapped or gzip-wrapped + deflate data. The header type is detected automatically, if requested when + initializing with inflateInit2(). 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. When processing + gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output + producted so far. The CRC-32 is checked against the gzip 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 check + value), Z_STREAM_ERROR if the stream structure was inconsistent (for example + next_in or next_out was Z_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. +*/ + + +ZEXTERN int ZEXPORT inflateEnd OF((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. +*/ + +/* +ZEXTERN int ZEXPORT deflateInit2 OF((z_streamp strm, + int level, + int method, + int windowBits, + int memLevel, + int strategy)); + + This is another version of deflateInit with more compression options. The + fields next_in, zalloc, zfree and opaque must be initialized before by the + caller. + + The method parameter is the compression method. It must be Z_DEFLATED in + 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 + 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). If a + gzip stream is being written, strm->adler is a crc32 instead of an adler32. + + 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 for + optimal speed. The default value is 8. See zconf.h for total memory usage + as a function of windowBits and memLevel. + + 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), 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_STRATEGY 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. + Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler + decoder for special applications. + + deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid + method), or Z_VERSION_ERROR if the zlib library version (zlib_version) is + incompatible with the version assumed by the caller (ZLIB_VERSION). 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)); +/* + Initializes the compression dictionary from the given byte sequence + without producing any compressed output. When using the zlib format, this + function must be called immediately after deflateInit, deflateInit2 or + deflateReset, and before any call of deflate. When doing raw deflate, this + function must be called either before any call of deflate, or immediately + after the completion of a deflate block, i.e. after all input has been + consumed and all output has been delivered when using any of the flush + options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH. The + compressor and decompressor must use exactly the same dictionary (see + inflateSetDictionary). + + The dictionary should consist of strings (byte sequences) that are likely + to be encountered later in the data to be compressed, with the most commonly + used strings preferably put towards the end of the dictionary. Using a + dictionary is most useful when the data to be compressed is short and can be + predicted with good accuracy; the data can then be compressed better than + with the default empty dictionary. + + Depending on the size of the compression data structures selected by + deflateInit or deflateInit2, a part of the dictionary may in effect be + discarded, for example if the dictionary is larger than the window size + provided in deflateInit or deflateInit2. Thus the strings most likely to be + useful should be put at the end of the dictionary, not at the front. In + addition, the current implementation of deflate will use at most the window + size minus 262 bytes of the provided dictionary. + + 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 + applies to the whole dictionary even if only a subset of the dictionary is + 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 (e.g. dictionary being Z_NULL) or the stream state is + inconsistent (for example if deflate has already been called for this stream + or if not at a block boundary for raw deflate). deflateSetDictionary does + not perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateCopy 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 several compression strategies will be + tried, for example when there are several ways of pre-processing the input + data with a filter. The streams that will be discarded should then be freed + by calling deflateEnd. Note that deflateCopy duplicates the internal + compression state which can be quite large, so this strategy is slow and can + consume lots of memory. + + deflateCopy 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 Z_NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); +/* + This function is equivalent to deflateEnd followed by deflateInit, + but does not free and reallocate all the internal compression state. The + stream will keep the same compression level and any other attributes that + may have been set by deflateInit2. + + deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being Z_NULL). +*/ + +ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, + 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 + used to switch between compression and straight copy of the input data, or + to switch to a different kind of input data requiring a different strategy. + If the compression level is changed, the input available so far is + compressed with the old level (and may be flushed); the new level will take + effect only at the next call of deflate(). + + Before the call of deflateParams, the stream state must be set as for + a call of deflate(), since the currently available input may have to be + compressed and flushed. In particular, strm->avail_out must be non-zero. + + deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source + stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR if + strm->avail_out was zero. +*/ + +ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, + int good_length, + int max_lazy, + int nice_length, + int max_chain)); +/* + Fine tune deflate's internal compression parameters. This should only be + used by someone who understands the algorithm used by zlib's deflate for + searching for the best matching string, and even then only by the most + fanatic optimizer trying to squeeze out the last compressed bit for their + specific input data. Read the deflate.c source code for the meaning of the + max_lazy, good_length, nice_length, and max_chain parameters. + + deflateTune() can be called after deflateInit() or deflateInit2(), and + returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. + */ + +ZEXTERN uInt ZEXPORT deflateBound OF((z_streamp strm, + uInt sourceLen)); +/* + deflateBound() returns an upper bound on the compressed size after + deflation of sourceLen bytes. It must be called after deflateInit() or + deflateInit2(), and after deflateSetHeader(), if used. This would be used + to allocate an output buffer for deflation in a single pass, and so would be + called before deflate(). If that first deflate() call is provided the + sourceLen input bytes, an output buffer allocated to the size returned by + deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed + to return Z_STREAM_END. Note that it is possible for the compressed size to + be larger than the value returned by deflateBound() if flush options other + than Z_FINISH or Z_NO_FLUSH are used. +*/ + +ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, + unsigned *pending, + int *bits)); +/* + deflatePending() returns the number of bytes and bits of output that have + been generated, but not yet provided in the available output. The bytes not + provided would be due to the available output space having being consumed. + The number of bits of output not provided are between 0 and 7, where they + await more bits to join them in order to fill out a full byte. If pending + or bits are Z_NULL, then those values are not set. + + deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. + */ + +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, Z_BUF_ERROR if there was not enough + room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the + source stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, + gz_headerp head)); +/* + deflateSetHeader() provides gzip header information for when a gzip + stream is requested by deflateInit2(). deflateSetHeader() may be called + after deflateInit2() or deflateReset() and before the first call of + deflate(). The text, time, os, extra field, name, and comment information + in the provided gz_header structure are written to the gzip header (xflag is + ignored -- the extra flags are set according to the compression level). The + caller must assure that, if not Z_NULL, name and comment are terminated with + a zero byte, and that if extra is not Z_NULL, that extra_len bytes are + available there. If hcrc is true, a gzip header crc is included. Note that + the current versions of the command-line version of gzip (up through version + 1.3.x) do not support header crc's, and will report that it is a "multi-part + gzip file" and give up. + + If deflateSetHeader is not used, the default gzip header has text false, + the time set to zero, and os set to 255, with no extra, name, or comment + fields. The gzip header is returned to the default state by deflateReset(). + + deflateSetHeader 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)); + + This is another version of inflateInit with an extra parameter. The + fields next_in, avail_in, zalloc, zfree and opaque must be initialized + before by the caller. + + 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. 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. + + windowBits can also be zero to request that inflate use the window size in + the zlib header of the compressed stream. + + 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). If a gzip stream is being decoded, strm->adler is a + crc32 instead of an adler32. + + inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller, or Z_STREAM_ERROR if the parameters are + invalid, such as a null pointer to the structure. msg is set to null if + there is no error message. inflateInit2 does not perform any decompression + apart from possibly reading the zlib header if present: actual decompression + will be done by inflate(). (So next_in and avail_in may be modified, but + next_out and avail_out are unused and unchanged.) The current implementation + of inflateInit2() does not process any header information -- that is + deferred until inflate() is called. +*/ + +ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, + const Bytef *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 that call returned Z_NEED_DICT. The dictionary chosen by the compressor + can be determined from the adler32 value returned by that call of inflate. + The compressor and decompressor must use exactly the same dictionary (see + deflateSetDictionary). For raw inflate, this function can be called at any + time to set the dictionary. If the provided dictionary is smaller than the + window and there is already data in the window, then the provided dictionary + will amend what's there. The application must insure that the dictionary + that was used for compression is provided. + + inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a + parameter is invalid (e.g. dictionary being Z_NULL) 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(). +*/ + +ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); +/* + Skips invalid compressed data until a possible full flush point (see above + for the description of deflate with Z_FULL_FLUSH) can be found, or until all + available input is skipped. No output is provided. + + inflateSync searches for a 00 00 FF FF pattern in the compressed data. + All full flush points have this pattern, but not all occurences of this + pattern are full flush points. + + inflateSync returns Z_OK if a possible 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. +*/ + +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 Z_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, + 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 Z_NULL). +*/ + +ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, + int windowBits)); +/* + This function is the same as inflateReset, but it also permits changing + the wrap and window size requests. The windowBits parameter is interpreted + the same as it is for inflateInit2. + + inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being Z_NULL), or if + the windowBits parameter is invalid. +*/ + +ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, + int bits, + int value)); +/* + This function inserts bits in the inflate input stream. The intent is + that this function is used to start inflating at a bit position in the + middle of a byte. The provided bits will be used before any bytes are used + from next_in. This function should only be used with raw inflate, and + should be used before the first inflate() call after inflateInit2() or + inflateReset(). bits must be less than or equal to 16, and that many of the + least significant bits of value will be inserted in the input. + + If bits is negative, then the input stream bit buffer is emptied. Then + inflatePrime() can be called again to put bits in the buffer. This is used + to clear out bits leftover after feeding inflate a block description prior + to feeding inflate codes. + + inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT inflateMark OF((z_streamp strm)); +/* + This function returns two values, one in the lower 16 bits of the return + value, and the other in the remaining upper bits, obtained by shifting the + return value down 16 bits. If the upper value is -1 and the lower value is + zero, then inflate() is currently decoding information outside of a block. + If the upper value is -1 and the lower value is non-zero, then inflate is in + the middle of a stored block, with the lower value equaling the number of + bytes from the input remaining to copy. If the upper value is not -1, then + it is the number of bits back from the current bit position in the input of + the code (literal or length/distance pair) currently being processed. In + that case the lower value is the number of bytes already emitted for that + code. + + A code is being processed if inflate is waiting for more input to complete + decoding of the code, or if it has completed decoding but is waiting for + more output space to write the literal or match data. + + inflateMark() is used to mark locations in the input data for random + access, which may be at bit positions, and to note those cases where the + output of a code may span boundaries of random access blocks. The current + location in the input stream can be determined from avail_in and data_type + as noted in the description for the Z_BLOCK flush parameter for inflate. + + inflateMark returns the value noted above or -1 << 16 if the provided + source stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, + gz_headerp head)); +/* + inflateGetHeader() requests that gzip header information be stored in the + provided gz_header structure. inflateGetHeader() may be called after + inflateInit2() or inflateReset(), and before the first call of inflate(). + As inflate() processes the gzip stream, head->done is zero until the header + is completed, at which time head->done is set to one. If a zlib stream is + being decoded, then head->done is set to -1 to indicate that there will be + no gzip header information forthcoming. Note that Z_BLOCK or Z_TREES can be + used to force inflate() to return immediately after header processing is + complete and before any actual data is decompressed. + + The text, time, xflags, and os fields are filled in with the gzip header + contents. hcrc is set to true if there is a header CRC. (The header CRC + was valid if done is set to one.) If extra is not Z_NULL, then extra_max + contains the maximum number of bytes to write to extra. Once done is true, + extra_len contains the actual extra field length, and extra contains the + extra field, or that field truncated if extra_max is less than extra_len. + If name is not Z_NULL, then up to name_max characters are written there, + terminated with a zero unless the length is greater than name_max. If + comment is not Z_NULL, then up to comm_max characters are written there, + terminated with a zero unless the length is greater than comm_max. When any + of extra, name, or comment are not Z_NULL and the respective field is not + present in the header, then that field is set to Z_NULL to signal its + absence. This allows the use of deflateSetHeader() with the returned + structure to duplicate the header. However if those fields are set to + allocated memory, then the application will need to save those pointers + elsewhere so that they can be eventually freed. + + If inflateGetHeader is not used, then the header information is simply + discarded. The header is always checked for validity, including the header + CRC if present. inflateReset() will reset the process to discard the header + information. The application would need to call inflateGetHeader() again to + retrieve the header from the next gzip stream. + + inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +/* +ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp 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 parameters 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_streamp 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_in 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_streamp 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 uInt 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 uInt + 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) + */ + +#ifndef Z_SOLO + + /* utility functions */ + +/* + The following utility functions are implemented on top of the basic + stream-oriented functions. To simplify the interface, some default options + are assumed (compression level and memory usage, standard memory allocation + functions). The source code of these utility functions can be modified if + you need special options. +*/ + +ZEXTERN int ZEXPORT compress OF((Bytef *dest, uIntf *destLen, + const Bytef *source, uInt sourceLen)); +/* + 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 the value returned by + compressBound(sourceLen). Upon exit, destLen is the actual size of the + compressed buffer. + + compress 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. +*/ + +ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uIntf *destLen, + const Bytef *source, uInt sourceLen, + int level)); +/* + 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 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 uInt ZEXPORT compressBound OF((uInt 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, uIntf *destLen, + const Bytef *source, uInt sourceLen)); +/* + Decompresses 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 large enough to hold the entire + uncompressed data. (The size of the uncompressed data must have been saved + previously by the compressor and transmitted to the decompressor by some + mechanism outside the scope of this compression library.) Upon exit, destLen + is the actual size of the uncompressed buffer. + + 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 or incomplete. In + the case where there is not enough room, uncompress() will fill the output + buffer with the uncompressed data up to that point. +*/ + + /* gzip file access functions */ + +/* + This library supports reading and writing files in gzip (.gz) format 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. +*/ + +typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */ + +/* +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", 'R' for run-length encoding as in "wb1R", or 'F' + for fixed code compression as in "wb9F". (See the description of + deflateInit2 for more information about the strategy parameter.) 'T' will + request transparent writing or appending with no compression and not using + the gzip format. + + "a" can be used instead of "w" to request that the gzip stream that will + be written be appended to the file. "+" will result in an error, since + reading and writing to the same gzip file is not supported. The addition of + "x" when writing will create the file exclusively, which fails if the file + already exists. On systems that support it, the addition of "e" when + reading or writing will set the flag to close the file on an execve() call. + + These functions, as well as gzip, will read and decode a sequence of gzip + streams in a file. The append function of gzopen() can be used to create + such a file. (Also see gzflush() for another way to do this.) When + appending, gzopen does not test whether the file begins with a gzip stream, + nor does it look for the end of the gzip streams to begin appending. gzopen + will simply append a gzip stream to the existing file. + + 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. When + reading, this will be detected automatically by looking for the magic two- + byte gzip header. + + gzopen returns NULL if the file could not be opened, if there was + insufficient memory to allocate the gzFile state, or if an invalid mode was + specified (an 'r', 'w', or 'a' was not provided, or '+' was provided). + errno can be checked to determine if the reason gzopen failed was that the + file could not be opened. +*/ + +ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); +/* + gzdopen associates a gzFile with the file descriptor fd. File descriptors + are obtained from calls like open, dup, creat, pipe or fileno (if the file + has been previously opened with fopen). The mode parameter is as in gzopen. + + The next call of gzclose on the returned gzFile will also close the file + descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor + fd. If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd, + mode);. The duplicated descriptor should be saved to avoid a leak, since + gzdopen does not close fd if it fails. If you are using fileno() to get the + file descriptor from a FILE *, then you will have to use dup() to avoid + double-close()ing the file descriptor. Both gzclose() and fclose() will + close the associated file descriptor, so they need to have different file + descriptors. + + gzdopen returns NULL if there was insufficient memory to allocate the + gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not + provided, or '+' was provided), or if fd is -1. The file descriptor is not + used until the next gz* read, write, seek, or close operation, so gzdopen + will not detect if fd is invalid (unless fd is -1). +*/ + +ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); +/* + Set the internal buffer size used by this library's functions. The + default buffer size is 8192 bytes. This function must be called after + gzopen() or gzdopen(), and before any other calls that read or write the + file. The buffer memory allocation is always deferred to the first read or + write. Two buffers are allocated, either both of the specified size when + writing, or one of the specified size and the other twice that size when + reading. A larger buffer size of, for example, 64K or 128K bytes will + noticeably increase the speed of decompression (reading). + + The new buffer size also affects the maximum length for gzprintf(). + + gzbuffer() returns 0 on success, or -1 on failure, such as being called + too late. +*/ + +ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); +/* + Dynamically update the compression level or strategy. See the description + of deflateInit2 for the meaning of these parameters. + + gzsetparams returns Z_OK if success, or Z_STREAM_ERROR if the file was not + opened for writing. +*/ + +ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); +/* + Reads the given number of uncompressed bytes from the compressed file. If + the input file is not in gzip format, gzread copies the given number of + bytes into the buffer directly from the file. + + After reaching the end of a gzip stream in the input, gzread will continue + to read, looking for another gzip stream. Any number of gzip streams may be + concatenated in the input file, and will all be decompressed by gzread(). + If something other than a gzip stream is encountered after a gzip stream, + that remaining trailing garbage is ignored (and no error is returned). + + gzread can be used to read a gzip file that is being concurrently written. + Upon reaching the end of the input, gzread will return with the available + data. If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then + gzclearerr can be used to clear the end of file indicator in order to permit + gzread to be tried again. Z_OK indicates that a gzip stream was completed + on the last gzread. Z_BUF_ERROR indicates that the input file ended in the + middle of a gzip stream. Note that gzread does not return -1 in the event + of an incomplete gzip stream. This error is deferred until gzclose(), which + will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip + stream. Alternatively, gzerror can be used before gzclose to detect this + case. + + gzread returns the number of uncompressed bytes actually read, less than + len for end of file, or -1 for error. +*/ + +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 written or 0 in case of + error. +*/ + +ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...)); +/* + Converts, formats, and writes the arguments to the compressed file under + control of the format string, as in fprintf. gzprintf returns the number of + uncompressed bytes actually written, or 0 in case of error. The number of + uncompressed bytes written is limited to 8191, or one less than the buffer + size given to gzbuffer(). The caller should assure that this limit is not + exceeded. If it is exceeded, then gzprintf() will 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. This can be determined using + zlibCompileFlags(). +*/ + +ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +/* + Writes the given null-terminated string to the compressed file, excluding + the terminating null character. + + gzputs returns the number of characters written, or -1 in case of error. +*/ + +ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); +/* + Reads bytes from the compressed file until len-1 characters are read, or a + newline character is read and transferred to buf, or an end-of-file + condition is encountered. If any characters are read or if len == 1, the + string is terminated with a null character. If no characters are read due + to an end-of-file or len < 1, then the buffer is left untouched. + + gzgets returns buf which is a null-terminated string, or it returns NULL + for end-of-file or in case of error. If there was an error, the contents at + buf are indeterminate. +*/ + +ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); +/* + Writes c, converted to an unsigned char, into the compressed file. gzputc + returns the value that was written, or -1 in case of error. +*/ + +ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); +/* + Reads one byte from the compressed file. gzgetc returns this byte or -1 + in case of end of file or error. This is implemented as a macro for speed. + As such, it does not do all of the checking the other functions do. I.e. + it does not check to see if file is NULL, nor whether the structure file + points to has been clobbered or not. +*/ + +ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); +/* + Push one character back onto the stream to be read as the first character + on the next read. At least one character of push-back is allowed. + gzungetc() returns the character pushed, or -1 on failure. gzungetc() will + fail if c is -1, and may fail if a character has been pushed but not read + yet. If gzungetc is used immediately after gzopen or gzdopen, at least the + output buffer size of pushed characters is allowed. (See gzbuffer above.) + 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 flush + is as in the deflate() function. The return value is the zlib error number + (see function gzerror below). gzflush is only permitted when writing. + + If the flush parameter is Z_FINISH, the remaining data is written and the + gzip stream is completed in the output. If gzwrite() is called again, a new + gzip stream will be started in the output. gzread() is able to read such + concatented gzip streams. + + gzflush should be called only when strictly necessary because it will + degrade compression if called too often. +*/ + +/* +ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, + 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); + the value SEEK_END is not supported. + + If the file is opened for reading, this function is emulated but can be + extremely slow. If the file is opened for writing, only forward seeks are + supported; gzseek then compresses a sequence of zeroes up to the new + starting position. + + gzseek returns the resulting offset location as measured in bytes from + the beginning of the uncompressed stream, or -1 in case of error, in + particular if the file is opened for writing and the new starting position + would be before the current position. +*/ + +ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); +/* + Rewinds the given file. This function is supported only for reading. + + gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) +*/ + +/* +ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); + + Returns the starting position for the next gzread or gzwrite on the given + compressed file. This position represents a number of bytes in the + uncompressed data stream, and is zero when starting, even if appending or + reading a gzip stream from the middle of a file using gzdopen(). + + gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) +*/ + +/* +ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file)); + + Returns the current offset in the file being read or written. This offset + includes the count of bytes that precede the gzip stream, for example when + appending or when using gzdopen() for reading. When reading, the offset + does not include as yet unused buffered input. This information can be used + for a progress indicator. On error, gzoffset() returns -1. +*/ + +ZEXTERN int ZEXPORT gzeof OF((gzFile file)); +/* + Returns true (1) if the end-of-file indicator has been set while reading, + false (0) otherwise. Note that the end-of-file indicator is set only if the + read tried to go past the end of the input, but came up short. Therefore, + just like feof(), gzeof() may return false even if there is no more data to + read, in the event that the last read request was for the exact number of + bytes remaining in the input file. This will happen if the input file size + is an exact multiple of the buffer size. + + If gzeof() returns true, then the read functions will return no more data, + unless the end-of-file indicator is reset by gzclearerr() and the input file + has grown since the previous end of file was detected. +*/ + +ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); +/* + Returns true (1) if file is being copied directly while reading, or false + (0) if file is a gzip stream being decompressed. + + If the input file is empty, gzdirect() will return true, since the input + does not contain a gzip stream. + + If gzdirect() is used immediately after gzopen() or gzdopen() it will + cause buffers to be allocated to allow reading the file to determine if it + is a gzip file. Therefore if gzbuffer() is used, it should be called before + gzdirect(). + + When writing, gzdirect() returns true (1) if transparent writing was + requested ("wT" for the gzopen() mode), or false (0) otherwise. (Note: + gzdirect() is not needed when writing. Transparent writing must be + explicitly requested, so the application already knows the answer. When + linking statically, using gzdirect() will include all of the zlib code for + gzip file reading and decompression, which may not be desired.) +*/ + +ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +/* + Flushes all pending output if necessary, closes the compressed file and + deallocates the (de)compression state. Note that once file is closed, you + cannot call gzerror with file, since its structures have been deallocated. + gzclose must not be called more than once on the same file, just as free + must not be called more than once on the same allocation. + + gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a + file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the + last read ended in the middle of a gzip stream, or Z_OK on success. +*/ + +ZEXTERN int ZEXPORT gzclose_r OF((gzFile file)); +ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); +/* + Same as gzclose(), but gzclose_r() is only for use when reading, and + gzclose_w() is only for use when writing or appending. The advantage to + using these instead of gzclose() is that they avoid linking in zlib + compression or decompression code that is not used when only reading or only + writing respectively. If gzclose() is used, then both compression and + decompression code will be included the application when linking to a static + zlib library. +*/ + +ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); +/* + Returns the error message for the last error which occurred on the given + compressed file. errnum is set to zlib error number. If an error occurred + in the file system and not in the compression library, errnum is set to + Z_ERRNO and the application may consult errno to get the exact error code. + + The application must not modify the returned string. Future calls to + this function may invalidate the previously returned string. If file is + closed, then the string previously returned by gzerror will no longer be + available. + + gzerror() should be used to distinguish errors from end-of-file for those + functions above that do not distinguish those cases in their return values. +*/ + +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. +*/ + +#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. +*/ + +ZEXTERN uInt ZEXPORT adler32 OF((uInt adler, const Bytef *buf, uInt len)); +/* + Update a running Adler-32 checksum with the bytes buf[0..len-1] and + return the updated checksum. If buf is Z_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: + + uInt adler = adler32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + adler = adler32(adler, buffer, length); + } + if (adler != original_adler) error(); +*/ + +/* +ZEXTERN uInt ZEXPORT adler32_combine OF((uInt adler1, uInt adler2, + z_off_t len2)); + + Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 + and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for + each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of + seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. Note + that the z_off_t type (like off_t) is a signed integer. If len2 is + negative, the result has no meaning or utility. +*/ + +ZEXTERN uInt ZEXPORT crc32 OF((uInt crc, const Bytef *buf, uInt len)); +/* + Update a running CRC-32 with the bytes buf[0..len-1] and return the + updated CRC-32. If buf is Z_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: + + uInt crc = crc32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + crc = crc32(crc, buffer, length); + } + if (crc != original_crc) error(); +*/ + +/* +ZEXTERN uInt ZEXPORT crc32_combine OF((uInt crc1, uInt crc2, z_off_t len2)); + + Combine two CRC-32 check values into one. For two sequences of bytes, + seq1 and seq2 with lengths len1 and len2, CRC-32 check values were + calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32 + check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and + len2. +*/ + + + /* 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_ OF((z_streamp strm, int level, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, + int windowBits, int memLevel, + int strategy, const char *version, + 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_streamp strm, int windowBits, + unsigned char FAR *window, + const char *version, + int stream_size)); +#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)) + +#ifndef Z_SOLO + +/* gzgetc() macro and its supporting function and exposed data structure. Note + * that the real internal state is much larger than the exposed structure. + * This abbreviated structure exposes just enough for the gzgetc() macro. The + * user should not mess with these exposed elements, since their names or + * behavior could change in the future, perhaps even capriciously. They can + * only be used by the gzgetc() macro. You have been warned. + */ +struct gzFile_s { + unsigned have; + unsigned char *next; + z_off64_t pos; +}; +ZEXTERN int ZEXPORT gzgetc_ OF((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 OF((const char *, const char *)); + ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); + ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); + ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); + ZEXTERN uInt ZEXPORT adler32_combine64 OF((uInt, uInt, z_off64_t)); + ZEXTERN uInt ZEXPORT crc32_combine64 OF((uInt, uInt, 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 +# else +# define gzopen gzopen64 +# define gzseek gzseek64 +# define gztell gztell64 +# define gzoffset gzoffset64 +# define adler32_combine adler32_combine64 +# define crc32_combine crc32_combine64 +# endif +# ifndef Z_LARGE64 + ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); + ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int)); + ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile)); + ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile)); + ZEXTERN uInt ZEXPORT adler32_combine64 OF((uInt, uInt, z_off_t)); + ZEXTERN uInt ZEXPORT crc32_combine64 OF((uInt, uInt, z_off_t)); +# endif +#else + ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *)); + ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int)); + ZEXTERN z_off_t ZEXPORT gztell OF((gzFile)); + ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile)); + ZEXTERN uInt ZEXPORT adler32_combine OF((uInt, uInt, z_off_t)); + ZEXTERN uInt ZEXPORT crc32_combine OF((uInt, uInt, z_off_t)); +#endif + +#else /* Z_SOLO */ + + ZEXTERN uInt ZEXPORT adler32_combine OF((uInt, uInt, z_off_t)); + ZEXTERN uInt ZEXPORT crc32_combine OF((uInt, uInt, z_off_t)); + +#endif /* !Z_SOLO */ + +/* hack for buggy compilers */ +#if !defined(ZUTIL_H) && !defined(NO_DUMMY_DECL) + struct internal_state {int dummy;}; +#endif + +/* undocumented functions */ +ZEXTERN const char * ZEXPORT zError OF((int)); +ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp)); +ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void)); +ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); +ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp)); +ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp)); +#if defined(_WIN32) && !defined(Z_SOLO) +ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path, + const char *mode)); +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* ZLIB_H */ diff --git a/zlib/zlibtest.c b/zlib/zlibtest.c new file mode 100644 index 0000000..db3e4fb --- /dev/null +++ b/zlib/zlibtest.c @@ -0,0 +1,111 @@ + +//------------------------------------------------------------------------- +//------------------------------------------------------------------------- +#include "testdata.h" +#include "zlib.h" + +#define ARM_TIMER_CTL 0x2000B408 +#define ARM_TIMER_CNT 0x2000B420 + +unsigned int heap_offset; +unsigned int complen; +unsigned int uncomplen; +unsigned char compressed[TESTDATALEN]; +unsigned char uncompressed[TESTDATALEN]; + +//------------------------------------------------------------------------- +extern void PUT32 ( unsigned int, unsigned int ); +extern unsigned int GET32 ( unsigned int ); +extern void dummy ( unsigned int ); +extern void * mkptr ( unsigned int ); +//------------------------------------------------------------------------ +void uart_init ( void ); +void hexstring ( unsigned int d ); +void hexstrings ( unsigned int d ); +//------------------------------------------------------------------------ +unsigned char *ZMEMCPY(unsigned char *dest, const unsigned char *src, unsigned int n) +{ + unsigned int ra; + for(ra=0;ra s2[j])-1; + } + return 0; +} + +void ZLIB_INTERNAL zmemzero(dest, len) + Bytef* dest; + uInt len; +{ + if (len == 0) return; + do { + *dest++ = 0; /* ??? to be unrolled */ + } while (--len != 0); +} +#endif + +#ifndef Z_SOLO + +#ifdef SYS16BIT + +#ifdef __TURBOC__ +/* Turbo C in 16-bit mode */ + +# define MY_ZCALLOC + +/* Turbo C malloc() does not allow dynamic allocation of 64K bytes + * and farmalloc(64K) returns a pointer with an offset of 8, so we + * must fix the pointer. Warning: the pointer must be put back to its + * original form in order to free it, use zcfree(). + */ + +#define MAX_PTR 10 +/* 10*64K = 640K */ + +local int next_ptr = 0; + +typedef struct ptr_table_s { + voidpf org_ptr; + voidpf new_ptr; +} ptr_table; + +local ptr_table table[MAX_PTR]; +/* This table is used to remember the original form of pointers + * to large buffers (64K). Such pointers are normalized with a zero offset. + * Since MSDOS is not a preemptive multitasking OS, this table is not + * protected from concurrent access. This hack doesn't work anyway on + * a protected system like OS/2. Use Microsoft C instead. + */ + +voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size) +{ + voidpf buf = opaque; /* just to make some compilers happy */ + ulg bsize = (ulg)items*size; + + /* If we allocate less than 65520 bytes, we assume that farmalloc + * will return a usable pointer which doesn't have to be normalized. + */ + if (bsize < 65520L) { + buf = farmalloc(bsize); + if (*(ush*)&buf != 0) return buf; + } else { + buf = farmalloc(bsize + 16L); + } + if (buf == NULL || next_ptr >= MAX_PTR) return NULL; + table[next_ptr].org_ptr = buf; + + /* Normalize the pointer to seg:0 */ + *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4; + *(ush*)&buf = 0; + table[next_ptr++].new_ptr = buf; + return buf; +} + +void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) +{ + int n; + if (*(ush*)&ptr != 0) { /* object < 64K */ + farfree(ptr); + return; + } + /* Find the original pointer */ + for (n = 0; n < next_ptr; n++) { + if (ptr != table[n].new_ptr) continue; + + farfree(table[n].org_ptr); + while (++n < next_ptr) { + table[n-1] = table[n]; + } + next_ptr--; + return; + } + ptr = opaque; /* just to make some compilers happy */ + Assert(0, "zcfree: ptr not found"); +} + +#endif /* __TURBOC__ */ + + +#ifdef M_I86 +/* Microsoft C in 16-bit mode */ + +# define MY_ZCALLOC + +#if (!defined(_MSC_VER) || (_MSC_VER <= 600)) +# define _halloc halloc +# define _hfree hfree +#endif + +voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size) +{ + if (opaque) opaque = 0; /* to make compiler happy */ + return _halloc((int)items, size); +} + +void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr) +{ + if (opaque) opaque = 0; /* to make compiler happy */ + _hfree(ptr); +} + +#endif /* M_I86 */ + +#endif /* SYS16BIT */ + + +#ifndef MY_ZCALLOC /* Any system without a special alloc function */ + +#ifndef STDC +extern voidp malloc OF((uInt size)); +extern voidp calloc OF((uInt items, uInt size)); +extern void free OF((voidpf ptr)); +#endif + +voidpf ZLIB_INTERNAL zcalloc (opaque, items, size) + voidpf opaque; + unsigned items; + unsigned size; +{ + if (opaque) items += size - size; /* make compiler happy */ + return sizeof(uInt) > 2 ? (voidpf)ZMALLOC(items * size) : + (voidpf)ZCALLOC(items, size); +} + +void ZLIB_INTERNAL zcfree (opaque, ptr) + voidpf opaque; + voidpf ptr; +{ + free(ptr); + if (opaque) return; /* make compiler happy */ +} + +#endif /* MY_ZCALLOC */ + +#endif /* !Z_SOLO */ diff --git a/zlib/zutil.h b/zlib/zutil.h new file mode 100644 index 0000000..abcdf5a --- /dev/null +++ b/zlib/zutil.h @@ -0,0 +1,188 @@ +/* zutil.h -- internal interface and configuration of the compression library + * Copyright (C) 1995-2012 Jean-loup Gailly. + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* WARNING: this file should *not* be used by applications. It is + part of the implementation of the compression library and is + subject to change. Applications should only use zlib.h. + */ + +/* @(#) $Id$ */ + +#ifndef ZUTIL_H +#define ZUTIL_H + +#ifdef HAVE_HIDDEN +# define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) +#else +# define ZLIB_INTERNAL +#endif + +#include "zlib.h" + +#if defined(STDC) && !defined(Z_SOLO) +# if !(defined(_WIN32_WCE) && defined(_MSC_VER)) +# include +# endif +//# include +void *ZMEMCPY(void *dest, const void *src, int n); +void *ZMEMSET(void *s, int c, int n); +//# include +void *ZCALLOC(int nmemb, int size); +void *ZMALLOC(int size); +//void free(void *ptr); +#endif + +#ifdef Z_SOLO + typedef int ptrdiff_t; /* guess -- will be caught if guess is wrong */ +#endif + +#ifndef local +# define local static +#endif +/* compile with -Dlocal if your debugger can't find static symbols */ + +typedef unsigned char uch; +typedef uch FAR uchf; +typedef unsigned short ush; +typedef ush FAR ushf; +typedef unsigned int ulg; + +extern const char * const z_errmsg[10]; /* indexed by 2-zlib_error */ +/* (size given to avoid silly warnings with Visual C++) */ + +#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 */ + +#ifndef DEF_WBITS +# define DEF_WBITS MAX_WBITS +#endif +/* default windowBits for decompression. MAX_WBITS is for compression only */ + +#if MAX_MEM_LEVEL >= 8 +# define DEF_MEM_LEVEL 8 +#else +# define DEF_MEM_LEVEL MAX_MEM_LEVEL +#endif +/* default memLevel */ + +#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 */ + +#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32)) +# define OS_CODE 0x00 +# ifndef Z_SOLO +# if defined(__TURBOC__) || defined(__BORLANDC__) +# if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__)) + /* Allow compilation with ANSI keywords only enabled */ + void _Cdecl farfree( void *block ); + void *_Cdecl farmalloc( unsigned int nbytes ); +# else +# include +# endif +# else /* MSC or DJGPP */ +# include +# endif +# endif +#endif + + +/* provide prototypes for these when building zlib without LFS */ +#if !defined(_WIN32) && (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0) + ZEXTERN uInt ZEXPORT adler32_combine64 OF((uInt, uInt, z_off_t)); + ZEXTERN uInt ZEXPORT crc32_combine64 OF((uInt, uInt, z_off_t)); +#endif + + /* common defaults */ + +#ifndef OS_CODE +# define OS_CODE 0x03 /* assume Unix */ +#endif + +#ifndef F_OPEN +# define F_OPEN(name, mode) fopen((name), (mode)) +#endif + + /* functions */ + +#if defined(pyr) || defined(Z_SOLO) +# define NO_MEMCPY +#endif +#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__) + /* Use our own functions for small and medium model with MSC <= 5.0. + * You may have to use the same strategy for Borland C (untested). + * The __SC__ check is for Symantec. + */ +# define NO_MEMCPY +#endif +#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY) +# define HAVE_MEMCPY +#endif +#ifdef HAVE_MEMCPY +# ifdef SMALL_MEDIUM /* MSDOS small or medium model */ +# define zmemcpy _fmemcpy +# define zmemcmp _fmemcmp +# define zmemzero(dest, len) _fmemset(dest, 0, len) +# else +# define zmemcpy ZMEMCPY +# define zmemcmp memcmp +# define zmemzero(dest, len) ZMEMSET(dest, 0, len) +# endif +#else + void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len)); + int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len)); + void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len)); +#endif + +/* Diagnostic functions */ +#ifdef DEBUG +# include + extern int ZLIB_INTERNAL z_verbose; + extern void ZLIB_INTERNAL z_error OF((char *m)); +# define Assert(cond,msg) {if(!(cond)) z_error(msg);} +# define Trace(x) {if (z_verbose>=0) fprintf x ;} +# define Tracev(x) {if (z_verbose>0) fprintf x ;} +# define Tracevv(x) {if (z_verbose>1) fprintf x ;} +# define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;} +# define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;} +#else +# define Assert(cond,msg) +# define Trace(x) +# define Tracev(x) +# define Tracevv(x) +# define Tracec(c,x) +# define Tracecv(c,x) +#endif + +#ifndef Z_SOLO + voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items, + unsigned size)); + void ZLIB_INTERNAL zcfree OF((voidpf opaque, voidpf ptr)); +#endif + +#define ZALLOC(strm, items, size) \ + (*((strm)->zalloc))((strm)->opaque, (items), (size)) +#define ZFREE(strm, addr) (*((strm)->zfree))((strm)->opaque, (voidpf)(addr)) +#define TRY_FREE(s, p) {if (p) ZFREE(s, p);} + +/* Reverse the bytes in a 32-bit value */ +#define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \ + (((q) & 0xff00) << 8) + (((q) & 0xff) << 24)) + +#endif /* ZUTIL_H */