From aa3f9d5fbb12e893e47ce859934dc3d53a6e8b67 Mon Sep 17 00:00:00 2001
From: Andre Maroneze <andre.maroneze@cea.fr>
Date: Tue, 13 Jul 2021 11:35:45 +0200
Subject: [PATCH] [zlib] new case study
---
Makefile | 1 +
README.md | 1 +
zlib/.frama-c/GNUmakefile | 45 +
zlib/.frama-c/path.mk | 1 +
zlib/.frama-c/zlib-example.eva/alarms.csv | 2 +
zlib/.frama-c/zlib-example.eva/metrics.log | 99 +
zlib/.frama-c/zlib-example.eva/nonterm.log | 27 +
zlib/.frama-c/zlib-example.eva/warnings.log | 1 +
zlib/.frama-c/zlib-example.parse/framac.ast | 18435 ++++++++++++++++
zlib/.frama-c/zlib-example.parse/metrics.log | 96 +
zlib/.frama-c/zlib-example.parse/warnings.log | 1 +
zlib/CMakeLists.txt | 249 +
zlib/ChangeLog | 1515 ++
zlib/FAQ | 368 +
zlib/INDEX | 68 +
zlib/Makefile | 5 +
zlib/Makefile.in | 410 +
zlib/README | 115 +
zlib/adler32.c | 186 +
zlib/compress.c | 86 +
zlib/configure | 921 +
zlib/contrib/README.contrib | 78 +
zlib/contrib/blast/Makefile | 8 +
zlib/contrib/blast/README | 4 +
zlib/contrib/blast/blast.c | 466 +
zlib/contrib/blast/blast.h | 83 +
zlib/contrib/blast/test.pk | Bin 0 -> 8 bytes
zlib/contrib/blast/test.txt | 1 +
zlib/contrib/infback9/README | 1 +
zlib/contrib/infback9/infback9.c | 615 +
zlib/contrib/infback9/infback9.h | 37 +
zlib/contrib/infback9/inffix9.h | 107 +
zlib/contrib/infback9/inflate9.h | 47 +
zlib/contrib/infback9/inftree9.c | 324 +
zlib/contrib/infback9/inftree9.h | 61 +
zlib/contrib/minizip/Makefile | 25 +
zlib/contrib/minizip/Makefile.am | 45 +
zlib/contrib/minizip/MiniZip64_Changes.txt | 6 +
zlib/contrib/minizip/MiniZip64_info.txt | 74 +
zlib/contrib/minizip/configure.ac | 32 +
zlib/contrib/minizip/crypt.h | 131 +
zlib/contrib/minizip/ioapi.c | 247 +
zlib/contrib/minizip/ioapi.h | 208 +
zlib/contrib/minizip/iowin32.c | 462 +
zlib/contrib/minizip/iowin32.h | 28 +
zlib/contrib/minizip/make_vms.com | 25 +
zlib/contrib/minizip/miniunz.c | 660 +
zlib/contrib/minizip/miniunzip.1 | 63 +
zlib/contrib/minizip/minizip.1 | 46 +
zlib/contrib/minizip/minizip.c | 520 +
zlib/contrib/minizip/minizip.pc.in | 12 +
zlib/contrib/minizip/mztools.c | 291 +
zlib/contrib/minizip/mztools.h | 37 +
zlib/contrib/minizip/unzip.c | 2125 ++
zlib/contrib/minizip/unzip.h | 437 +
zlib/contrib/minizip/zip.c | 2007 ++
zlib/contrib/minizip/zip.h | 362 +
zlib/contrib/puff/Makefile | 42 +
zlib/contrib/puff/README | 63 +
zlib/contrib/puff/puff.c | 840 +
zlib/contrib/puff/puff.h | 35 +
zlib/contrib/puff/pufftest.c | 165 +
zlib/contrib/puff/zeros.raw | Bin 0 -> 2517 bytes
zlib/contrib/testzlib/testzlib.c | 275 +
zlib/contrib/testzlib/testzlib.txt | 10 +
zlib/contrib/untgz/Makefile | 14 +
zlib/contrib/untgz/Makefile.msc | 17 +
zlib/contrib/untgz/untgz.c | 674 +
zlib/crc32.c | 442 +
zlib/crc32.h | 441 +
zlib/deflate.c | 2163 ++
zlib/deflate.h | 349 +
zlib/doc/algorithm.txt | 209 +
zlib/doc/rfc1950.txt | 619 +
zlib/doc/rfc1951.txt | 955 +
zlib/doc/rfc1952.txt | 675 +
zlib/doc/txtvsbin.txt | 107 +
zlib/examples/README.examples | 49 +
zlib/examples/enough.c | 572 +
zlib/examples/fitblk.c | 233 +
zlib/examples/gun.c | 702 +
zlib/examples/gzappend.c | 504 +
zlib/examples/gzjoin.c | 449 +
zlib/examples/gzlog.c | 1059 +
zlib/examples/gzlog.h | 91 +
zlib/examples/zlib_how.html | 545 +
zlib/examples/zpipe.c | 205 +
zlib/examples/zran.c | 409 +
zlib/gzclose.c | 25 +
zlib/gzguts.h | 219 +
zlib/gzlib.c | 637 +
zlib/gzread.c | 654 +
zlib/gzwrite.c | 665 +
zlib/infback.c | 640 +
zlib/inffast.c | 323 +
zlib/inffast.h | 11 +
zlib/inffixed.h | 94 +
zlib/inflate.c | 1561 ++
zlib/inflate.h | 125 +
zlib/inftrees.c | 304 +
zlib/inftrees.h | 62 +
zlib/test/example.c | 602 +
zlib/test/infcover.c | 671 +
zlib/test/minigzip.c | 651 +
zlib/treebuild.xml | 116 +
zlib/trees.c | 1203 +
zlib/trees.h | 128 +
zlib/uncompr.c | 93 +
zlib/zconf.h | 534 +
zlib/zconf.h.cmakein | 536 +
zlib/zconf.h.in | 534 +
zlib/zlib.3 | 149 +
zlib/zlib.h | 1912 ++
zlib/zlib.map | 94 +
zlib/zlib.pc.cmakein | 13 +
zlib/zlib.pc.in | 13 +
zlib/zlib2ansi | 152 +
zlib/zutil.c | 325 +
zlib/zutil.h | 271 +
119 files changed, 58537 insertions(+)
create mode 100644 zlib/.frama-c/GNUmakefile
create mode 120000 zlib/.frama-c/path.mk
create mode 100644 zlib/.frama-c/zlib-example.eva/alarms.csv
create mode 100644 zlib/.frama-c/zlib-example.eva/metrics.log
create mode 100644 zlib/.frama-c/zlib-example.eva/nonterm.log
create mode 100644 zlib/.frama-c/zlib-example.eva/warnings.log
create mode 100644 zlib/.frama-c/zlib-example.parse/framac.ast
create mode 100644 zlib/.frama-c/zlib-example.parse/metrics.log
create mode 100644 zlib/.frama-c/zlib-example.parse/warnings.log
create mode 100644 zlib/CMakeLists.txt
create mode 100644 zlib/ChangeLog
create mode 100644 zlib/FAQ
create mode 100644 zlib/INDEX
create mode 100644 zlib/Makefile
create mode 100644 zlib/Makefile.in
create mode 100644 zlib/README
create mode 100644 zlib/adler32.c
create mode 100644 zlib/compress.c
create mode 100755 zlib/configure
create mode 100644 zlib/contrib/README.contrib
create mode 100644 zlib/contrib/blast/Makefile
create mode 100644 zlib/contrib/blast/README
create mode 100644 zlib/contrib/blast/blast.c
create mode 100644 zlib/contrib/blast/blast.h
create mode 100644 zlib/contrib/blast/test.pk
create mode 100644 zlib/contrib/blast/test.txt
create mode 100644 zlib/contrib/infback9/README
create mode 100644 zlib/contrib/infback9/infback9.c
create mode 100644 zlib/contrib/infback9/infback9.h
create mode 100644 zlib/contrib/infback9/inffix9.h
create mode 100644 zlib/contrib/infback9/inflate9.h
create mode 100644 zlib/contrib/infback9/inftree9.c
create mode 100644 zlib/contrib/infback9/inftree9.h
create mode 100644 zlib/contrib/minizip/Makefile
create mode 100644 zlib/contrib/minizip/Makefile.am
create mode 100644 zlib/contrib/minizip/MiniZip64_Changes.txt
create mode 100644 zlib/contrib/minizip/MiniZip64_info.txt
create mode 100644 zlib/contrib/minizip/configure.ac
create mode 100644 zlib/contrib/minizip/crypt.h
create mode 100644 zlib/contrib/minizip/ioapi.c
create mode 100644 zlib/contrib/minizip/ioapi.h
create mode 100644 zlib/contrib/minizip/iowin32.c
create mode 100644 zlib/contrib/minizip/iowin32.h
create mode 100644 zlib/contrib/minizip/make_vms.com
create mode 100644 zlib/contrib/minizip/miniunz.c
create mode 100644 zlib/contrib/minizip/miniunzip.1
create mode 100644 zlib/contrib/minizip/minizip.1
create mode 100644 zlib/contrib/minizip/minizip.c
create mode 100644 zlib/contrib/minizip/minizip.pc.in
create mode 100644 zlib/contrib/minizip/mztools.c
create mode 100644 zlib/contrib/minizip/mztools.h
create mode 100644 zlib/contrib/minizip/unzip.c
create mode 100644 zlib/contrib/minizip/unzip.h
create mode 100644 zlib/contrib/minizip/zip.c
create mode 100644 zlib/contrib/minizip/zip.h
create mode 100644 zlib/contrib/puff/Makefile
create mode 100644 zlib/contrib/puff/README
create mode 100644 zlib/contrib/puff/puff.c
create mode 100644 zlib/contrib/puff/puff.h
create mode 100644 zlib/contrib/puff/pufftest.c
create mode 100644 zlib/contrib/puff/zeros.raw
create mode 100644 zlib/contrib/testzlib/testzlib.c
create mode 100644 zlib/contrib/testzlib/testzlib.txt
create mode 100644 zlib/contrib/untgz/Makefile
create mode 100644 zlib/contrib/untgz/Makefile.msc
create mode 100644 zlib/contrib/untgz/untgz.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/doc/algorithm.txt
create mode 100644 zlib/doc/rfc1950.txt
create mode 100644 zlib/doc/rfc1951.txt
create mode 100644 zlib/doc/rfc1952.txt
create mode 100644 zlib/doc/txtvsbin.txt
create mode 100644 zlib/examples/README.examples
create mode 100644 zlib/examples/enough.c
create mode 100644 zlib/examples/fitblk.c
create mode 100644 zlib/examples/gun.c
create mode 100644 zlib/examples/gzappend.c
create mode 100644 zlib/examples/gzjoin.c
create mode 100644 zlib/examples/gzlog.c
create mode 100644 zlib/examples/gzlog.h
create mode 100644 zlib/examples/zlib_how.html
create mode 100644 zlib/examples/zpipe.c
create mode 100644 zlib/examples/zran.c
create mode 100644 zlib/gzclose.c
create mode 100644 zlib/gzguts.h
create mode 100644 zlib/gzlib.c
create mode 100644 zlib/gzread.c
create mode 100644 zlib/gzwrite.c
create mode 100644 zlib/infback.c
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/test/example.c
create mode 100644 zlib/test/infcover.c
create mode 100644 zlib/test/minigzip.c
create mode 100644 zlib/treebuild.xml
create mode 100644 zlib/trees.c
create mode 100644 zlib/trees.h
create mode 100644 zlib/uncompr.c
create mode 100644 zlib/zconf.h
create mode 100644 zlib/zconf.h.cmakein
create mode 100644 zlib/zconf.h.in
create mode 100644 zlib/zlib.3
create mode 100644 zlib/zlib.h
create mode 100644 zlib/zlib.map
create mode 100644 zlib/zlib.pc.cmakein
create mode 100644 zlib/zlib.pc.in
create mode 100755 zlib/zlib2ansi
create mode 100644 zlib/zutil.c
create mode 100644 zlib/zutil.h
diff --git a/Makefile b/Makefile
index 7246a021f..b5129a1fc 100644
--- a/Makefile
+++ b/Makefile
@@ -83,6 +83,7 @@ TARGETS=\
tsvc \
tweetnacl-usable \
x509-parser \
+ zlib \
help::
@echo ""
diff --git a/README.md b/README.md
index 89c44338a..c1286e194 100644
--- a/README.md
+++ b/README.md
@@ -161,3 +161,4 @@ when available. We also summarize the license of each directory below.
- `tsvc`: MIT, see `license.txt`
- `tweetnacl-usable`: public domain, see `LICENSE.txt`
- `x509-parser` : GPLv2 / BSD, see `LICENSE`
+- `zlib` : zlib licence, see `README`
diff --git a/zlib/.frama-c/GNUmakefile b/zlib/.frama-c/GNUmakefile
new file mode 100644
index 000000000..5418731b1
--- /dev/null
+++ b/zlib/.frama-c/GNUmakefile
@@ -0,0 +1,45 @@
+# Makefile template for Frama-C/Eva case studies.
+# For details and usage information, see the Frama-C User Manual.
+
+### Prologue. Do not modify this block. #######################################
+-include path.mk
+FRAMAC ?= frama-c
+include $(shell $(FRAMAC)-config -print-share-path)/analysis-scripts/prologue.mk
+###############################################################################
+
+# Edit below as needed. Suggested flags are optional.
+
+MACHDEP = x86_64
+
+## Preprocessing flags (for -cpp-extra-args)
+CPPFLAGS += \
+ -I .. \
+
+## General flags
+FCFLAGS += \
+ -add-symbolic-path=..:. \
+ -kernel-warn-key annot:missing-spec=abort \
+ -kernel-warn-key typing:implicit-function-declaration=abort \
+
+## Eva-specific flags
+EVAFLAGS += \
+ -eva-warn-key builtins:missing-spec=abort \
+ -eva-precision 4 \
+
+## GUI-only flags
+FCGUIFLAGS += \
+
+## Analysis targets (suffixed with .eva)
+TARGETS = zlib-example.eva
+
+### Each target <t>.eva needs a rule <t>.parse with source files as prerequisites
+zlib-example.parse: \
+ ../test/example.c \
+ $(sort $(wildcard ../*.c)) \
+
+### Epilogue. Do not modify this block. #######################################
+include $(shell $(FRAMAC)-config -print-share-path)/analysis-scripts/epilogue.mk
+###############################################################################
+
+# optional, for OSCS
+-include ../../Makefile.common
diff --git a/zlib/.frama-c/path.mk b/zlib/.frama-c/path.mk
new file mode 120000
index 000000000..57620d6d4
--- /dev/null
+++ b/zlib/.frama-c/path.mk
@@ -0,0 +1 @@
+../../path.mk
\ No newline at end of file
diff --git a/zlib/.frama-c/zlib-example.eva/alarms.csv b/zlib/.frama-c/zlib-example.eva/alarms.csv
new file mode 100644
index 000000000..686c4bb3c
--- /dev/null
+++ b/zlib/.frama-c/zlib-example.eva/alarms.csv
@@ -0,0 +1,2 @@
+directory file line function property kind status property
+. deflate.c 1958 deflate_slow initialization Invalid or unreachable \initialized(&s->match_start)
diff --git a/zlib/.frama-c/zlib-example.eva/metrics.log b/zlib/.frama-c/zlib-example.eva/metrics.log
new file mode 100644
index 000000000..9c16e4399
--- /dev/null
+++ b/zlib/.frama-c/zlib-example.eva/metrics.log
@@ -0,0 +1,99 @@
+[metrics] Eva coverage statistics
+=======================
+Syntactically reachable functions = 113 (out of 159)
+Semantically reached functions = 28
+Coverage estimation = 24.8%
+
+Unreached functions (85) =
+ <crc32.c>: crc32; crc32_big; crc32_little; crc32_z;
+ <deflate.c>: deflate_fast; deflate_huff; deflate_rle; deflate_stored;
+ deflateParams; deflateSetDictionary; longest_match; slide_hash;
+ <gzclose.c>: gzclose;
+ <gzlib.c>: gz_error; gz_open; gz_reset; gzerror; gzopen; gzrewind; gzseek;
+ gzseek64; gztell; gztell64;
+ <gzread.c>: gz_avail; gz_decomp; gz_fetch; gz_load; gz_look; gz_read;
+ gz_skip; gzclose_r; gzgetc; gzgets; gzread; gzungetc;
+ <gzwrite.c>: gz_comp; gz_init; gz_write; gz_zero; gzclose_w; gzprintf;
+ gzputc; gzputs; gzvprintf;
+ <inffast.c>: inflate_fast;
+ <inflate.c>: fixedtables_0; inflate; inflateEnd; inflateInit2_;
+ inflateInit_; inflateReset; inflateReset2; inflateResetKeep;
+ inflateSetDictionary; inflateStateCheck; inflateSync; syncsearch;
+ updatewindow;
+ <inftrees.c>: inflate_table;
+ <test/example.c>: test_deflate; test_dict_deflate; test_dict_inflate;
+ test_flush; test_gzio; test_inflate; test_large_deflate;
+ test_large_inflate; test_sync;
+ <trees.c>: _tr_align; _tr_flush_block; _tr_stored_block; bi_reverse;
+ bi_windup; build_bl_tree; build_tree; compress_block; detect_data_type;
+ gen_bitlen; gen_codes; pqdownheap; scan_tree; send_all_trees; send_tree;
+ <uncompr.c>: uncompress; uncompress2;
+[metrics] References to non-analyzed functions
+------------------------------------
+Function deflate calls crc32 (at deflate.c:851)
+Function deflate calls crc32 (at deflate.c:894)
+Function deflate calls crc32 (at deflate.c:909)
+Function deflate calls crc32 (at deflate.c:922)
+Function deflate calls crc32 (at deflate.c:933)
+Function deflate calls crc32 (at deflate.c:944)
+Function deflate calls crc32 (at deflate.c:955)
+Function deflate calls crc32 (at deflate.c:966)
+Function deflate calls crc32 (at deflate.c:981)
+Function deflate calls deflate_stored (at deflate.c:1000)
+Function deflate calls deflate_huff (at deflate.c:1001)
+Function deflate calls deflate_rle (at deflate.c:1002)
+Function deflate calls _tr_align (at deflate.c:1023)
+Function deflate calls _tr_stored_block (at deflate.c:1025)
+Function deflate_slow calls longest_match (at deflate.c:1967)
+Function deflate_slow calls _tr_flush_block (at deflate.c:2011)
+Function deflate_slow calls _tr_flush_block (at deflate.c:2021)
+Function deflate_slow calls _tr_flush_block (at deflate.c:2043)
+Function deflate_slow calls _tr_flush_block (at deflate.c:2047)
+Function deflateResetKeep calls crc32 (at deflate.c:494)
+Function fill_window calls slide_hash (at deflate.c:1516)
+Function main calls test_gzio (at test/example.c:581)
+Function main calls test_deflate (at test/example.c:585)
+Function main calls test_inflate (at test/example.c:586)
+Function main calls test_large_deflate (at test/example.c:588)
+Function main calls test_large_inflate (at test/example.c:589)
+Function main calls test_flush (at test/example.c:591)
+Function main calls test_sync (at test/example.c:592)
+Function main calls test_dict_deflate (at test/example.c:595)
+Function main calls test_dict_inflate (at test/example.c:596)
+Function read_buf calls crc32 (at deflate.c:1182)
+Function test_compress calls uncompress (at test/example.c:100)
+Initializer of configuration_table references deflate_stored (at deflate.c:136)
+Initializer of configuration_table references deflate_fast (at deflate.c:137)
+Initializer of configuration_table references deflate_fast (at deflate.c:138)
+Initializer of configuration_table references deflate_fast (at deflate.c:139)
+[metrics] Statements analyzed by Eva
+--------------------------
+1363 stmts in analyzed functions, 448 stmts analyzed (32.9%)
+_tr_flush_bits: 2 stmts out of 2 (100.0%)
+_tr_init: 11 stmts out of 11 (100.0%)
+adler32: 2 stmts out of 2 (100.0%)
+compress: 2 stmts out of 2 (100.0%)
+deflateInit_: 2 stmts out of 2 (100.0%)
+deflateReset: 4 stmts out of 4 (100.0%)
+init_block: 30 stmts out of 30 (100.0%)
+lm_init: 19 stmts out of 19 (100.0%)
+putShortMSB: 11 stmts out of 11 (100.0%)
+tr_static_init: 1 stmts out of 1 (100.0%)
+zcfree: 2 stmts out of 2 (100.0%)
+zlibVersion: 2 stmts out of 2 (100.0%)
+deflateEnd: 21 stmts out of 25 (84.0%)
+flush_pending: 14 stmts out of 17 (82.4%)
+deflateResetKeep: 25 stmts out of 32 (78.1%)
+zcalloc: 3 stmts out of 4 (75.0%)
+compress2: 30 stmts out of 41 (73.2%)
+deflateInit2_: 73 stmts out of 101 (72.3%)
+read_buf: 11 stmts out of 17 (64.7%)
+main: 21 stmts out of 44 (47.7%)
+fill_window: 28 stmts out of 59 (47.5%)
+deflateStateCheck: 16 stmts out of 34 (47.1%)
+zlibCompileFlags: 14 stmts out of 30 (46.7%)
+test_compress: 7 stmts out of 19 (36.8%)
+adler32_z: 27 stmts out of 170 (15.9%)
+bi_flush: 3 stmts out of 23 (13.0%)
+deflate: 50 stmts out of 484 (10.3%)
+deflate_slow: 17 stmts out of 175 (9.7%)
diff --git a/zlib/.frama-c/zlib-example.eva/nonterm.log b/zlib/.frama-c/zlib-example.eva/nonterm.log
new file mode 100644
index 000000000..25d21db9a
--- /dev/null
+++ b/zlib/.frama-c/zlib-example.eva/nonterm.log
@@ -0,0 +1,27 @@
+test/example.c:109:[nonterm:unreachable] warning: unreachable return
+test/example.c:601:[nonterm:unreachable] warning: unreachable return
+compress.c:49:[nonterm:stmt] warning: non-terminating loop
+stack: compress2 :: compress.c:74 <-
+ compress :: test/example.c:95 <-
+ test_compress :: test/example.c:579 <-
+ main
+deflate.c:1003:[nonterm:stmt] warning: non-terminating function call
+stack: deflate :: compress.c:58 <-
+ compress2 :: compress.c:74 <-
+ compress :: test/example.c:95 <-
+ test_compress :: test/example.c:579 <-
+ main
+deflate.c:1934:[nonterm:stmt] warning: non-terminating loop
+stack: deflate_slow :: deflate.c:1003 <-
+ deflate :: compress.c:58 <-
+ compress2 :: compress.c:74 <-
+ compress :: test/example.c:95 <-
+ test_compress :: test/example.c:579 <-
+ main
+deflate.c:1958:[nonterm:stmt] warning: non-terminating statement
+stack: deflate_slow :: deflate.c:1003 <-
+ deflate :: compress.c:58 <-
+ compress2 :: compress.c:74 <-
+ compress :: test/example.c:95 <-
+ test_compress :: test/example.c:579 <-
+ main
diff --git a/zlib/.frama-c/zlib-example.eva/warnings.log b/zlib/.frama-c/zlib-example.eva/warnings.log
new file mode 100644
index 000000000..73de02652
--- /dev/null
+++ b/zlib/.frama-c/zlib-example.eva/warnings.log
@@ -0,0 +1 @@
+compress.c:74:[eva:locals-escaping] warning: locals {stream} escaping the scope of compress2 through __malloc_zcalloc_l311
diff --git a/zlib/.frama-c/zlib-example.parse/framac.ast b/zlib/.frama-c/zlib-example.parse/framac.ast
new file mode 100644
index 000000000..e65fa13d8
--- /dev/null
+++ b/zlib/.frama-c/zlib-example.parse/framac.ast
@@ -0,0 +1,18435 @@
+/* Generated by Frama-C */
+#include "errno.h"
+#include "fcntl.h"
+#include "stdarg.h"
+#include "stddef.h"
+#include "stdio.h"
+#include "stdlib.h"
+#include "string.h"
+#include "strings.h"
+#include "sys/types.h"
+#include "unistd.h"
+typedef size_t z_size_t;
+typedef unsigned char Byte;
+typedef unsigned int uInt;
+typedef unsigned long uLong;
+typedef Byte Bytef;
+typedef char charf;
+typedef int intf;
+typedef uLong uLongf;
+typedef void const *voidpc;
+typedef void *voidpf;
+typedef void *voidp;
+typedef unsigned int z_crc_t;
+struct z_stream_s {
+ Bytef *next_in ;
+ uInt avail_in ;
+ uLong total_in ;
+ Bytef *next_out ;
+ uInt avail_out ;
+ uLong total_out ;
+ char *msg ;
+ struct internal_state *state ;
+ voidpf (*zalloc)(voidpf opaque, uInt items, uInt size) ;
+ void (*zfree)(voidpf opaque, voidpf address) ;
+ voidpf opaque ;
+ int data_type ;
+ uLong adler ;
+ uLong reserved ;
+};
+typedef struct z_stream_s z_stream;
+typedef z_stream *z_streamp;
+struct gz_header_s {
+ int text ;
+ uLong time ;
+ int xflags ;
+ int os ;
+ Bytef *extra ;
+ uInt extra_len ;
+ uInt extra_max ;
+ Bytef *name ;
+ uInt name_max ;
+ Bytef *comment ;
+ uInt comm_max ;
+ int hcrc ;
+ int done ;
+};
+typedef struct gz_header_s gz_header;
+typedef gz_header *gz_headerp;
+struct gzFile_s;
+typedef struct gzFile_s *gzFile;
+struct gzFile_s {
+ unsigned int have ;
+ unsigned char *next ;
+ long pos ;
+};
+typedef unsigned char uch;
+typedef uch uchf;
+typedef unsigned short ush;
+typedef ush ushf;
+typedef unsigned long ulg;
+union __anonunion_fc_1 {
+ ush freq ;
+ ush code ;
+};
+union __anonunion_dl_2 {
+ ush dad ;
+ ush len ;
+};
+struct ct_data_s {
+ union __anonunion_fc_1 fc ;
+ union __anonunion_dl_2 dl ;
+};
+typedef struct ct_data_s ct_data;
+typedef struct static_tree_desc_s static_tree_desc;
+struct tree_desc_s {
+ ct_data *dyn_tree ;
+ int max_code ;
+ static_tree_desc const *stat_desc ;
+};
+typedef struct tree_desc_s tree_desc;
+typedef ush Pos;
+typedef Pos Posf;
+typedef unsigned int IPos;
+struct internal_state {
+ z_streamp strm ;
+ int status ;
+ Bytef *pending_buf ;
+ ulg pending_buf_size ;
+ Bytef *pending_out ;
+ ulg pending ;
+ int wrap ;
+ gz_headerp gzhead ;
+ ulg gzindex ;
+ Byte method ;
+ int last_flush ;
+ uInt w_size ;
+ uInt w_bits ;
+ uInt w_mask ;
+ Bytef *window ;
+ ulg window_size ;
+ Posf *prev ;
+ Posf *head ;
+ uInt ins_h ;
+ uInt hash_size ;
+ uInt hash_bits ;
+ uInt hash_mask ;
+ uInt hash_shift ;
+ long block_start ;
+ uInt match_length ;
+ IPos prev_match ;
+ int match_available ;
+ uInt strstart ;
+ uInt match_start ;
+ uInt lookahead ;
+ uInt prev_length ;
+ uInt max_chain_length ;
+ uInt max_lazy_match ;
+ int level ;
+ int strategy ;
+ uInt good_match ;
+ int nice_match ;
+ struct ct_data_s dyn_ltree[2 * ((256 + 1) + 29) + 1] ;
+ struct ct_data_s dyn_dtree[2 * 30 + 1] ;
+ struct ct_data_s bl_tree[2 * 19 + 1] ;
+ struct tree_desc_s l_desc ;
+ struct tree_desc_s d_desc ;
+ struct tree_desc_s bl_desc ;
+ ush bl_count[15 + 1] ;
+ int heap[2 * ((256 + 1) + 29) + 1] ;
+ int heap_len ;
+ int heap_max ;
+ uch depth[2 * ((256 + 1) + 29) + 1] ;
+ uchf *l_buf ;
+ uInt lit_bufsize ;
+ uInt last_lit ;
+ ushf *d_buf ;
+ ulg opt_len ;
+ ulg static_len ;
+ uInt matches ;
+ uInt insert ;
+ ush bi_buf ;
+ int bi_valid ;
+ ulg high_water ;
+};
+typedef struct internal_state deflate_state;
+enum __anonenum_block_state_3 {
+ need_more = 0,
+ block_done = 1,
+ finish_started = 2,
+ finish_done = 3
+};
+typedef enum __anonenum_block_state_3 block_state;
+struct config_s {
+ ush good_length ;
+ ush max_lazy ;
+ ush nice_length ;
+ ush max_chain ;
+ block_state (*func)(deflate_state *s, int flush) ;
+};
+typedef struct config_s config;
+struct __anonstruct_gz_state_1 {
+ struct gzFile_s x ;
+ int mode ;
+ int fd ;
+ char *path ;
+ unsigned int size ;
+ unsigned int want ;
+ unsigned char *in ;
+ unsigned char *out ;
+ int direct ;
+ int how ;
+ long start ;
+ int eof ;
+ int past ;
+ int level ;
+ int strategy ;
+ long skip ;
+ int seek ;
+ int err ;
+ char *msg ;
+ z_stream strm ;
+};
+typedef struct __anonstruct_gz_state_1 gz_state;
+typedef gz_state *gz_statep;
+struct __anonstruct_code_1 {
+ unsigned char op ;
+ unsigned char bits ;
+ unsigned short val ;
+};
+typedef struct __anonstruct_code_1 code;
+enum __anonenum_codetype_2 {
+ CODES = 0,
+ LENS = 1,
+ DISTS = 2
+};
+typedef enum __anonenum_codetype_2 codetype;
+enum __anonenum_inflate_mode_3 {
+ HEAD = 16180,
+ FLAGS = 16181,
+ TIME = 16182,
+ OS = 16183,
+ EXLEN = 16184,
+ EXTRA = 16185,
+ NAME = 16186,
+ COMMENT = 16187,
+ HCRC = 16188,
+ DICTID = 16189,
+ DICT = 16190,
+ TYPE = 16191,
+ TYPEDO = 16192,
+ STORED = 16193,
+ COPY_ = 16194,
+ COPY = 16195,
+ TABLE = 16196,
+ LENLENS = 16197,
+ CODELENS = 16198,
+ LEN_ = 16199,
+ LEN = 16200,
+ LENEXT = 16201,
+ DIST = 16202,
+ DISTEXT = 16203,
+ MATCH = 16204,
+ LIT = 16205,
+ CHECK = 16206,
+ LENGTH = 16207,
+ DONE = 16208,
+ BAD = 16209,
+ MEM = 16210,
+ SYNC = 16211
+};
+typedef enum __anonenum_inflate_mode_3 inflate_mode;
+struct inflate_state {
+ z_streamp strm ;
+ inflate_mode mode ;
+ int last ;
+ int wrap ;
+ int havedict ;
+ int flags ;
+ unsigned int dmax ;
+ unsigned long check ;
+ unsigned long total ;
+ gz_headerp head ;
+ unsigned int wbits ;
+ unsigned int wsize ;
+ unsigned int whave ;
+ unsigned int wnext ;
+ unsigned char *window ;
+ unsigned long hold ;
+ unsigned int bits ;
+ unsigned int length ;
+ unsigned int offset ;
+ unsigned int extra ;
+ code const *lencode ;
+ code const *distcode ;
+ unsigned int lenbits ;
+ unsigned int distbits ;
+ unsigned int ncode ;
+ unsigned int nlen ;
+ unsigned int ndist ;
+ unsigned int have ;
+ code *next ;
+ unsigned short lens[320] ;
+ unsigned short work[288] ;
+ code codes[852 + 592] ;
+ int sane ;
+ int back ;
+ unsigned int was ;
+};
+struct static_tree_desc_s {
+ ct_data const *static_tree ;
+ intf const *extra_bits ;
+ int extra_base ;
+ int elems ;
+ int max_length ;
+};
+char const *zlibVersion(void);
+
+int deflate(z_streamp strm, int flush) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int deflateEnd(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int inflate(z_streamp strm, int flush) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int inflateEnd(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int deflateSetDictionary(z_streamp strm, Bytef const *dictionary_0,
+ uInt dictLength) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int deflateGetDictionary(z_streamp strm, Bytef *dictionary_0,
+ uInt *dictLength) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int deflateCopy(z_streamp dest, z_streamp source) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int deflateReset(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int deflateParams(z_streamp strm, int level, int strategy) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+int deflateTune(z_streamp strm, int good_length, int max_lazy,
+ int nice_length, int max_chain) __attribute__((__FC_OLDSTYLEPROTO__));
+
+uLong deflateBound(z_streamp strm, uLong sourceLen) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int deflatePending(z_streamp strm, unsigned int *pending, int *bits) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+int deflatePrime(z_streamp strm, int bits, int value) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+int deflateSetHeader(z_streamp strm, gz_headerp head) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+int inflateSetDictionary(z_streamp strm, Bytef const *dictionary_0,
+ uInt dictLength) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int inflateGetDictionary(z_streamp strm, Bytef *dictionary_0,
+ uInt *dictLength) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int inflateSync(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int inflateCopy(z_streamp dest, z_streamp source) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int inflateReset(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int inflateReset2(z_streamp strm, int windowBits) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int inflatePrime(z_streamp strm, int bits, int value) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+long inflateMark(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int inflateGetHeader(z_streamp strm, gz_headerp head) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+int inflateBack(z_streamp strm, unsigned int (*in)(void *, unsigned char **),
+ void *in_desc,
+ int (*out)(void *, unsigned char *, unsigned int ),
+ void *out_desc) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int inflateBackEnd(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+
+uLong zlibCompileFlags(void);
+
+int compress(Bytef *dest, uLongf *destLen, Bytef const *source,
+ uLong sourceLen) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int compress2(Bytef *dest, uLongf *destLen, Bytef const *source,
+ uLong sourceLen, int level) __attribute__((__FC_OLDSTYLEPROTO__));
+
+uLong compressBound(uLong sourceLen) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int uncompress(Bytef *dest, uLongf *destLen, Bytef const *source,
+ uLong sourceLen) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int uncompress2(Bytef *dest, uLongf *destLen, Bytef const *source,
+ uLong *sourceLen) __attribute__((__FC_OLDSTYLEPROTO__));
+
+gzFile gzdopen(int fd, char const *mode) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int gzbuffer(gzFile file, unsigned int size) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int gzsetparams(gzFile file, int level, int strategy) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+int gzread(gzFile file, voidp buf, unsigned int len) __attribute__((__FC_OLDSTYLEPROTO__));
+
+z_size_t gzfread(voidp buf, z_size_t size, z_size_t nitems, gzFile file) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+int gzwrite(gzFile file, voidpc buf, unsigned int len) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+z_size_t gzfwrite(voidpc buf, z_size_t size, z_size_t nitems, gzFile file) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+int gzprintf(gzFile file, char const *format, void * const *__va_params);
+
+int gzputs(gzFile file, char const *str) __attribute__((__FC_OLDSTYLEPROTO__));
+
+char *gzgets(gzFile file, char *buf, int len) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int gzputc(gzFile file, int c) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int gzgetc(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int gzungetc(int c, gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int gzflush(gzFile file, int flush) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int gzrewind(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int gzeof(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int gzdirect(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int gzclose(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int gzclose_r(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int gzclose_w(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+
+char const *gzerror(gzFile file, int *errnum) __attribute__((__FC_OLDSTYLEPROTO__));
+
+void gzclearerr(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+
+uLong adler32(uLong adler, Bytef const *buf, uInt len) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+uLong adler32_z(uLong adler, Bytef const *buf, z_size_t len) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+unsigned long crc32(unsigned long crc, unsigned char const *buf, uInt len) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+unsigned long crc32_z(unsigned long crc, unsigned char const *buf,
+ z_size_t len) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int deflateInit_(z_streamp strm, int level, char const *version,
+ int stream_size) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int inflateInit_(z_streamp strm, char const *version, int stream_size) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+int deflateInit2_(z_streamp strm, int level, int method, int windowBits,
+ int memLevel, int strategy, char const *version,
+ int stream_size) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int inflateInit2_(z_streamp strm, int windowBits, char const *version,
+ int stream_size) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int inflateBackInit_(z_streamp strm, int windowBits, unsigned char *window,
+ char const *version, int stream_size) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+int gzgetc_(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+
+gzFile gzopen(char const *path, char const *mode) __attribute__((__FC_OLDSTYLEPROTO__));
+
+long gzseek(gzFile file, long offset, int whence) __attribute__((__FC_OLDSTYLEPROTO__));
+
+long gztell(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+
+long gzoffset(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+
+uLong adler32_combine(uLong adler1, uLong adler2, long len2) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+uLong crc32_combine(uLong crc1, uLong crc2, long len2) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+char const *zError(int err) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int inflateSyncPoint(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+
+z_crc_t const *get_crc_table(void);
+
+int inflateUndermine(z_streamp strm, int subvert) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int inflateValidate(z_streamp strm, int check) __attribute__((__FC_OLDSTYLEPROTO__));
+
+unsigned long inflateCodesUsed(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int inflateResetKeep(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int deflateResetKeep(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int gzvprintf(gzFile file, char const *format, va_list va);
+
+static char hello[14] =
+ {(char)'h',
+ (char)'e',
+ (char)'l',
+ (char)'l',
+ (char)'o',
+ (char)',',
+ (char)' ',
+ (char)'h',
+ (char)'e',
+ (char)'l',
+ (char)'l',
+ (char)'o',
+ (char)'!',
+ (char)'\000'};
+static char const dictionary[6] =
+ {(char)'h', (char)'e', (char)'l', (char)'l', (char)'o', (char)'\000'};
+static uLong dictId;
+void test_deflate(Byte *compr, uLong comprLen) __attribute__((__FC_OLDSTYLEPROTO__));
+
+void test_inflate(Byte *compr, uLong comprLen, Byte *uncompr,
+ uLong uncomprLen) __attribute__((__FC_OLDSTYLEPROTO__));
+
+void test_large_deflate(Byte *compr, uLong comprLen, Byte *uncompr,
+ uLong uncomprLen) __attribute__((__FC_OLDSTYLEPROTO__));
+
+void test_large_inflate(Byte *compr, uLong comprLen, Byte *uncompr,
+ uLong uncomprLen) __attribute__((__FC_OLDSTYLEPROTO__));
+
+void test_flush(Byte *compr, uLong *comprLen) __attribute__((__FC_OLDSTYLEPROTO__));
+
+void test_sync(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+void test_dict_deflate(Byte *compr, uLong comprLen) __attribute__((__FC_OLDSTYLEPROTO__));
+
+void test_dict_inflate(Byte *compr, uLong comprLen, Byte *uncompr,
+ uLong uncomprLen) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int main(int argc, char **argv) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static voidpf (*zalloc)(voidpf opaque, uInt items, uInt size) =
+ (voidpf (*)(voidpf opaque, uInt items, uInt size))0;
+static void (*zfree)(voidpf opaque, voidpf address) =
+ (void (*)(voidpf opaque, voidpf address))0;
+void test_compress(Byte *compr, uLong comprLen, Byte *uncompr,
+ uLong uncomprLen) __attribute__((__FC_OLDSTYLEPROTO__));
+
+void test_gzio(char const *fname, Byte *uncompr, uLong uncomprLen) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_1(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_2(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..)));
+ */
+int fprintf_va_3(FILE * restrict stream, char const * restrict format);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ *(param0 + (0 ..));
+ */
+int printf_va_1(char const * restrict format, char *param0);
+
+void test_compress(Byte *compr, uLong comprLen, Byte *uncompr,
+ uLong uncomprLen) __attribute__((__FC_OLDSTYLEPROTO__));
+void test_compress(Byte *compr, uLong comprLen, Byte *uncompr,
+ uLong uncomprLen)
+{
+ int err;
+ size_t tmp;
+ int tmp_0;
+ tmp = strlen((char const *)(hello));
+ uLong len = tmp + (unsigned long)1;
+ err = compress(compr,& comprLen,(Bytef const *)(hello),len);
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"compress",err); /* fprintf_va_1 */
+ exit(1);
+ }
+ strcpy((char *)uncompr,"garbage");
+ err = uncompress(uncompr,& uncomprLen,(Bytef const *)compr,comprLen);
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"uncompress",err); /* fprintf_va_2 */
+ exit(1);
+ }
+ tmp_0 = strcmp((char const *)uncompr,(char const *)(hello));
+ if (tmp_0) {
+ fprintf(__fc_stderr,"bad uncompress\n"); /* fprintf_va_3 */
+ exit(1);
+ }
+ else printf("uncompress(): %s\n",(char *)uncompr); /* printf_va_1 */
+ return;
+}
+
+/*@ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..)));
+ */
+int fprintf_va_4(FILE * restrict stream, char const * restrict format);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), *(param0 + (0 ..));
+ */
+int fprintf_va_5(FILE * restrict stream, char const * restrict format,
+ char *param0);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), *(param0 + (0 ..));
+ */
+int fprintf_va_6(FILE * restrict stream, char const * restrict format,
+ char *param0);
+
+/*@ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..)));
+ */
+int fprintf_va_7(FILE * restrict stream, char const * restrict format);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), *(param0 + (0 ..));
+ */
+int fprintf_va_8(FILE * restrict stream, char const * restrict format,
+ char *param0);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), *(param0 + (0 ..));
+ */
+int fprintf_va_9(FILE * restrict stream, char const * restrict format,
+ char *param0);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ *(param0 + (0 ..));
+ */
+int printf_va_2(char const * restrict format, char *param0);
+
+/*@ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: param0);
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, param0;
+ */
+int fprintf_va_10(FILE * restrict stream, char const * restrict format,
+ long param0, long param1);
+
+/*@ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..)));
+ */
+int fprintf_va_11(FILE * restrict stream, char const * restrict format);
+
+/*@ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..)));
+ */
+int fprintf_va_12(FILE * restrict stream, char const * restrict format);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), *(param0 + (0 ..));
+ */
+int fprintf_va_13(FILE * restrict stream, char const * restrict format,
+ char *param0);
+
+/*@ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..)));
+ */
+int fprintf_va_14(FILE * restrict stream, char const * restrict format);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ *(param0 + (0 ..));
+ */
+int printf_va_3(char const * restrict format, char *param0);
+
+void test_gzio(char const *fname, Byte *uncompr, uLong uncomprLen) __attribute__((
+__FC_OLDSTYLEPROTO__));
+void test_gzio(char const *fname, Byte *uncompr, uLong uncomprLen)
+{
+ int err;
+ size_t tmp;
+ gzFile file;
+ long pos;
+ int tmp_1;
+ int tmp_3;
+ int tmp_5;
+ int tmp_6;
+ int tmp_11;
+ int tmp_12;
+ size_t tmp_14;
+ int tmp_15;
+ tmp = strlen((char const *)(hello));
+ int len = (int)tmp + 1;
+ file = gzopen(fname,"wb");
+ if (file == (gzFile)0) {
+ fprintf(__fc_stderr,"gzopen error\n"); /* fprintf_va_4 */
+ exit(1);
+ }
+ gzputc(file,'h');
+ tmp_1 = gzputs(file,"ello");
+ if (tmp_1 != 4) {
+ char const *tmp_0;
+ tmp_0 = gzerror(file,& err);
+ ;
+ fprintf(__fc_stderr,"gzputs err: %s\n",(char *)tmp_0); /* fprintf_va_5 */
+ exit(1);
+ }
+ {
+ char const *__va_arg0 = "hello";
+ void *__va_args[1] = {& __va_arg0};
+ tmp_3 = gzprintf(file,", %s!",(void * const *)(__va_args));
+ }
+ if (tmp_3 != 8) {
+ char const *tmp_2;
+ tmp_2 = gzerror(file,& err);
+ ;
+ fprintf(__fc_stderr,"gzprintf err: %s\n",(char *)tmp_2); /* fprintf_va_6 */
+ exit(1);
+ }
+ gzseek(file,1L,1);
+ gzclose(file);
+ file = gzopen(fname,"rb");
+ if (file == (gzFile)0) {
+ fprintf(__fc_stderr,"gzopen error\n"); /* fprintf_va_7 */
+ exit(1);
+ }
+ strcpy((char *)uncompr,"garbage");
+ tmp_5 = gzread(file,(void *)uncompr,(unsigned int)uncomprLen);
+ ;
+ if (tmp_5 != len) {
+ char const *tmp_4;
+ tmp_4 = gzerror(file,& err);
+ ;
+ fprintf(__fc_stderr,"gzread err: %s\n",(char *)tmp_4); /* fprintf_va_8 */
+ exit(1);
+ }
+ tmp_6 = strcmp((char const *)uncompr,(char const *)(hello));
+ if (tmp_6) {
+ fprintf(__fc_stderr,"bad gzread: %s\n",(char *)uncompr); /* fprintf_va_9 */
+ exit(1);
+ }
+ else printf("gzread(): %s\n",(char *)uncompr); /* printf_va_2 */
+ pos = gzseek(file,-8L,1);
+ if (pos != (long)6) goto _LOR;
+ else {
+ long tmp_8;
+ tmp_8 = gztell(file);
+ ;
+ if (tmp_8 != pos) {
+ _LOR:
+ {
+ long tmp_7;
+ tmp_7 = gztell(file);
+ ;
+ ;
+ fprintf(__fc_stderr,"gzseek error, pos=%ld, gztell=%ld\n",pos,tmp_7); /* fprintf_va_10 */
+ exit(1);
+ }
+ }
+ }
+ if (file->have) {
+ unsigned char *tmp_9;
+ (file->have) --;
+ (file->pos) ++;
+ tmp_9 = file->next;
+ (file->next) ++;
+ tmp_11 = (int)*tmp_9;
+ }
+ else tmp_11 = gzgetc(file);
+ if (tmp_11 != ' ') {
+ fprintf(__fc_stderr,"gzgetc error\n"); /* fprintf_va_11 */
+ exit(1);
+ }
+ tmp_12 = gzungetc(' ',file);
+ if (tmp_12 != ' ') {
+ fprintf(__fc_stderr,"gzungetc error\n"); /* fprintf_va_12 */
+ exit(1);
+ }
+ gzgets(file,(char *)uncompr,(int)uncomprLen);
+ tmp_14 = strlen((char const *)uncompr);
+ if (tmp_14 != (size_t)7) {
+ char const *tmp_13;
+ tmp_13 = gzerror(file,& err);
+ ;
+ fprintf(__fc_stderr,"gzgets err after gzseek: %s\n",(char *)tmp_13); /* fprintf_va_13 */
+ exit(1);
+ }
+ tmp_15 = strcmp((char const *)uncompr,(char const *)(& hello[6]));
+ if (tmp_15) {
+ fprintf(__fc_stderr,"bad gzgets after gzseek\n"); /* fprintf_va_14 */
+ exit(1);
+ }
+ else printf("gzgets() after gzseek: %s\n",(char *)uncompr); /* printf_va_3 */
+ gzclose(file);
+ return;
+}
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_15(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_16(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_17(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_18(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+void test_deflate(Byte *compr, uLong comprLen) __attribute__((__FC_OLDSTYLEPROTO__));
+void test_deflate(Byte *compr, uLong comprLen)
+{
+ z_stream c_stream;
+ int err;
+ size_t tmp;
+ tmp = strlen((char const *)(hello));
+ uLong len = tmp + (unsigned long)1;
+ c_stream.zalloc = zalloc;
+ c_stream.zfree = zfree;
+ c_stream.opaque = (void *)0;
+ err = deflateInit_(& c_stream,-1,"1.2.11",(int)sizeof(z_stream));
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"deflateInit",err); /* fprintf_va_15 */
+ exit(1);
+ }
+ c_stream.next_in = (unsigned char *)(hello);
+ c_stream.next_out = compr;
+ while (1) {
+ if (c_stream.total_in != len) {
+ if (! (c_stream.total_out < comprLen)) break;
+ }
+ else break;
+ c_stream.avail_out = (unsigned int)1;
+ c_stream.avail_in = c_stream.avail_out;
+ err = deflate(& c_stream,0);
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"deflate",err); /* fprintf_va_16 */
+ exit(1);
+ }
+ }
+ while (1) {
+ c_stream.avail_out = (unsigned int)1;
+ err = deflate(& c_stream,4);
+ if (err == 1) break;
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"deflate",err); /* fprintf_va_17 */
+ exit(1);
+ }
+ }
+ err = deflateEnd(& c_stream);
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"deflateEnd",err); /* fprintf_va_18 */
+ exit(1);
+ }
+ return;
+}
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_19(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_20(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_21(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..)));
+ */
+int fprintf_va_22(FILE * restrict stream, char const * restrict format);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ *(param0 + (0 ..));
+ */
+int printf_va_4(char const * restrict format, char *param0);
+
+void test_inflate(Byte *compr, uLong comprLen, Byte *uncompr,
+ uLong uncomprLen) __attribute__((__FC_OLDSTYLEPROTO__));
+void test_inflate(Byte *compr, uLong comprLen, Byte *uncompr,
+ uLong uncomprLen)
+{
+ int err;
+ z_stream d_stream;
+ int tmp;
+ strcpy((char *)uncompr,"garbage");
+ d_stream.zalloc = zalloc;
+ d_stream.zfree = zfree;
+ d_stream.opaque = (void *)0;
+ d_stream.next_in = compr;
+ d_stream.avail_in = (unsigned int)0;
+ d_stream.next_out = uncompr;
+ err = inflateInit_(& d_stream,"1.2.11",(int)sizeof(z_stream));
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"inflateInit",err); /* fprintf_va_19 */
+ exit(1);
+ }
+ while (1) {
+ if (d_stream.total_out < uncomprLen) {
+ if (! (d_stream.total_in < comprLen)) break;
+ }
+ else break;
+ d_stream.avail_out = (unsigned int)1;
+ d_stream.avail_in = d_stream.avail_out;
+ err = inflate(& d_stream,0);
+ if (err == 1) break;
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"inflate",err); /* fprintf_va_20 */
+ exit(1);
+ }
+ }
+ err = inflateEnd(& d_stream);
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"inflateEnd",err); /* fprintf_va_21 */
+ exit(1);
+ }
+ tmp = strcmp((char const *)uncompr,(char const *)(hello));
+ if (tmp) {
+ fprintf(__fc_stderr,"bad inflate\n"); /* fprintf_va_22 */
+ exit(1);
+ }
+ else printf("inflate(): %s\n",(char *)uncompr); /* printf_va_4 */
+ return;
+}
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_23(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_24(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..)));
+ */
+int fprintf_va_25(FILE * restrict stream, char const * restrict format);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_26(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_27(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..)));
+ */
+int fprintf_va_28(FILE * restrict stream, char const * restrict format);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_29(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+void test_large_deflate(Byte *compr, uLong comprLen, Byte *uncompr,
+ uLong uncomprLen) __attribute__((__FC_OLDSTYLEPROTO__));
+void test_large_deflate(Byte *compr, uLong comprLen, Byte *uncompr,
+ uLong uncomprLen)
+{
+ z_stream c_stream;
+ int err;
+ c_stream.zalloc = zalloc;
+ c_stream.zfree = zfree;
+ c_stream.opaque = (void *)0;
+ err = deflateInit_(& c_stream,1,"1.2.11",(int)sizeof(z_stream));
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"deflateInit",err); /* fprintf_va_23 */
+ exit(1);
+ }
+ c_stream.next_out = compr;
+ c_stream.avail_out = (unsigned int)comprLen;
+ c_stream.next_in = uncompr;
+ c_stream.avail_in = (unsigned int)uncomprLen;
+ err = deflate(& c_stream,0);
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"deflate",err); /* fprintf_va_24 */
+ exit(1);
+ }
+ if (c_stream.avail_in != (uInt)0) {
+ fprintf(__fc_stderr,"deflate not greedy\n"); /* fprintf_va_25 */
+ exit(1);
+ }
+ deflateParams(& c_stream,0,0);
+ c_stream.next_in = compr;
+ c_stream.avail_in = (unsigned int)comprLen / (unsigned int)2;
+ err = deflate(& c_stream,0);
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"deflate",err); /* fprintf_va_26 */
+ exit(1);
+ }
+ deflateParams(& c_stream,9,1);
+ c_stream.next_in = uncompr;
+ c_stream.avail_in = (unsigned int)uncomprLen;
+ err = deflate(& c_stream,0);
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"deflate",err); /* fprintf_va_27 */
+ exit(1);
+ }
+ err = deflate(& c_stream,4);
+ if (err != 1) {
+ fprintf(__fc_stderr,"deflate should report Z_STREAM_END\n"); /* fprintf_va_28 */
+ exit(1);
+ }
+ err = deflateEnd(& c_stream);
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"deflateEnd",err); /* fprintf_va_29 */
+ exit(1);
+ }
+ return;
+}
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_30(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_31(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_32(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param0);
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param0;
+ */
+int fprintf_va_33(FILE * restrict stream, char const * restrict format,
+ long param0);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_5(char const * restrict format);
+
+void test_large_inflate(Byte *compr, uLong comprLen, Byte *uncompr,
+ uLong uncomprLen) __attribute__((__FC_OLDSTYLEPROTO__));
+void test_large_inflate(Byte *compr, uLong comprLen, Byte *uncompr,
+ uLong uncomprLen)
+{
+ int err;
+ z_stream d_stream;
+ strcpy((char *)uncompr,"garbage");
+ d_stream.zalloc = zalloc;
+ d_stream.zfree = zfree;
+ d_stream.opaque = (void *)0;
+ d_stream.next_in = compr;
+ d_stream.avail_in = (unsigned int)comprLen;
+ err = inflateInit_(& d_stream,"1.2.11",(int)sizeof(z_stream));
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"inflateInit",err); /* fprintf_va_30 */
+ exit(1);
+ }
+ while (1) {
+ d_stream.next_out = uncompr;
+ d_stream.avail_out = (unsigned int)uncomprLen;
+ err = inflate(& d_stream,0);
+ if (err == 1) break;
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"large inflate",err); /* fprintf_va_31 */
+ exit(1);
+ }
+ }
+ err = inflateEnd(& d_stream);
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"inflateEnd",err); /* fprintf_va_32 */
+ exit(1);
+ }
+ if (d_stream.total_out != (uLong)2 * uncomprLen + comprLen / (uLong)2) {
+ fprintf(__fc_stderr,"bad large inflate: %ld\n",(long)d_stream.total_out); /* fprintf_va_33 */
+ exit(1);
+ }
+ else printf("large_inflate(): OK\n"); /* printf_va_5 */
+ return;
+}
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_34(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_35(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_36(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_37(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+void test_flush(Byte *compr, uLong *comprLen) __attribute__((__FC_OLDSTYLEPROTO__));
+void test_flush(Byte *compr, uLong *comprLen)
+{
+ z_stream c_stream;
+ int err;
+ size_t tmp;
+ tmp = strlen((char const *)(hello));
+ uInt len = (unsigned int)tmp + (unsigned int)1;
+ c_stream.zalloc = zalloc;
+ c_stream.zfree = zfree;
+ c_stream.opaque = (void *)0;
+ err = deflateInit_(& c_stream,-1,"1.2.11",(int)sizeof(z_stream));
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"deflateInit",err); /* fprintf_va_34 */
+ exit(1);
+ }
+ c_stream.next_in = (unsigned char *)(hello);
+ c_stream.next_out = compr;
+ c_stream.avail_in = (unsigned int)3;
+ c_stream.avail_out = (unsigned int)*comprLen;
+ err = deflate(& c_stream,3);
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"deflate",err); /* fprintf_va_35 */
+ exit(1);
+ }
+ *(compr + 3) = (unsigned char)((int)*(compr + 3) + 1);
+ c_stream.avail_in = len - (uInt)3;
+ err = deflate(& c_stream,4);
+ if (err != 1)
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"deflate",err); /* fprintf_va_36 */
+ exit(1);
+ }
+ err = deflateEnd(& c_stream);
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"deflateEnd",err); /* fprintf_va_37 */
+ exit(1);
+ }
+ *comprLen = c_stream.total_out;
+ return;
+}
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_38(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_39(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_40(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..)));
+ */
+int fprintf_va_41(FILE * restrict stream, char const * restrict format);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_42(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ *(param0 + (0 ..));
+ */
+int printf_va_6(char const * restrict format, char *param0);
+
+void test_sync(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen) __attribute__((
+__FC_OLDSTYLEPROTO__));
+void test_sync(Byte *compr, uLong comprLen, Byte *uncompr, uLong uncomprLen)
+{
+ int err;
+ z_stream d_stream;
+ strcpy((char *)uncompr,"garbage");
+ d_stream.zalloc = zalloc;
+ d_stream.zfree = zfree;
+ d_stream.opaque = (void *)0;
+ d_stream.next_in = compr;
+ d_stream.avail_in = (unsigned int)2;
+ err = inflateInit_(& d_stream,"1.2.11",(int)sizeof(z_stream));
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"inflateInit",err); /* fprintf_va_38 */
+ exit(1);
+ }
+ d_stream.next_out = uncompr;
+ d_stream.avail_out = (unsigned int)uncomprLen;
+ err = inflate(& d_stream,0);
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"inflate",err); /* fprintf_va_39 */
+ exit(1);
+ }
+ d_stream.avail_in = (unsigned int)comprLen - (unsigned int)2;
+ err = inflateSync(& d_stream);
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"inflateSync",err); /* fprintf_va_40 */
+ exit(1);
+ }
+ err = inflate(& d_stream,4);
+ if (err != -3) {
+ fprintf(__fc_stderr,"inflate should report DATA_ERROR\n"); /* fprintf_va_41 */
+ exit(1);
+ }
+ err = inflateEnd(& d_stream);
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"inflateEnd",err); /* fprintf_va_42 */
+ exit(1);
+ }
+ printf("after inflateSync(): hel%s\n",(char *)uncompr); /* printf_va_6 */
+ return;
+}
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_43(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_44(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..)));
+ */
+int fprintf_va_45(FILE * restrict stream, char const * restrict format);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_46(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+void test_dict_deflate(Byte *compr, uLong comprLen) __attribute__((__FC_OLDSTYLEPROTO__));
+void test_dict_deflate(Byte *compr, uLong comprLen)
+{
+ z_stream c_stream;
+ int err;
+ size_t tmp;
+ c_stream.zalloc = zalloc;
+ c_stream.zfree = zfree;
+ c_stream.opaque = (void *)0;
+ err = deflateInit_(& c_stream,9,"1.2.11",(int)sizeof(z_stream));
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"deflateInit",err); /* fprintf_va_43 */
+ exit(1);
+ }
+ err = deflateSetDictionary(& c_stream,(Bytef const *)(dictionary),
+ (unsigned int)((int)sizeof(dictionary)));
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"deflateSetDictionary",err); /* fprintf_va_44 */
+ exit(1);
+ }
+ dictId = c_stream.adler;
+ c_stream.next_out = compr;
+ c_stream.avail_out = (unsigned int)comprLen;
+ c_stream.next_in = (unsigned char *)(hello);
+ tmp = strlen((char const *)(hello));
+ c_stream.avail_in = (unsigned int)tmp + (unsigned int)1;
+ err = deflate(& c_stream,4);
+ if (err != 1) {
+ fprintf(__fc_stderr,"deflate should report Z_STREAM_END\n"); /* fprintf_va_45 */
+ exit(1);
+ }
+ err = deflateEnd(& c_stream);
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"deflateEnd",err); /* fprintf_va_46 */
+ exit(1);
+ }
+ return;
+}
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_47(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..)));
+ */
+int fprintf_va_48(FILE * restrict stream, char const * restrict format);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_49(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param1),
+ (indirect: *(param0 + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..))), param1, *(param0 + (0 ..));
+ */
+int fprintf_va_50(FILE * restrict stream, char const * restrict format,
+ char *param0, int param1);
+
+/*@ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..)));
+ */
+int fprintf_va_51(FILE * restrict stream, char const * restrict format);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ *(param0 + (0 ..));
+ */
+int printf_va_7(char const * restrict format, char *param0);
+
+void test_dict_inflate(Byte *compr, uLong comprLen, Byte *uncompr,
+ uLong uncomprLen) __attribute__((__FC_OLDSTYLEPROTO__));
+void test_dict_inflate(Byte *compr, uLong comprLen, Byte *uncompr,
+ uLong uncomprLen)
+{
+ int err;
+ z_stream d_stream;
+ int tmp;
+ strcpy((char *)uncompr,"garbage");
+ d_stream.zalloc = zalloc;
+ d_stream.zfree = zfree;
+ d_stream.opaque = (void *)0;
+ d_stream.next_in = compr;
+ d_stream.avail_in = (unsigned int)comprLen;
+ err = inflateInit_(& d_stream,"1.2.11",(int)sizeof(z_stream));
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"inflateInit",err); /* fprintf_va_47 */
+ exit(1);
+ }
+ d_stream.next_out = uncompr;
+ d_stream.avail_out = (unsigned int)uncomprLen;
+ while (1) {
+ err = inflate(& d_stream,0);
+ if (err == 1) break;
+ if (err == 2) {
+ if (d_stream.adler != dictId) {
+ fprintf(__fc_stderr,"unexpected dictionary"); /* fprintf_va_48 */
+ exit(1);
+ }
+ err = inflateSetDictionary(& d_stream,(Bytef const *)(dictionary),
+ (unsigned int)((int)sizeof(dictionary)));
+ }
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"inflate with dict",err); /* fprintf_va_49 */
+ exit(1);
+ }
+ }
+ err = inflateEnd(& d_stream);
+ if (err != 0) {
+ fprintf(__fc_stderr,"%s error: %d\n",(char *)"inflateEnd",err); /* fprintf_va_50 */
+ exit(1);
+ }
+ tmp = strcmp((char const *)uncompr,(char const *)(hello));
+ if (tmp) {
+ fprintf(__fc_stderr,"bad inflate with dict\n"); /* fprintf_va_51 */
+ exit(1);
+ }
+ else printf("inflate with dictionary: %s\n",(char *)uncompr); /* printf_va_7 */
+ return;
+}
+
+static char const *main_myVersion = "1.2.11";
+/*@ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..)));
+ */
+int fprintf_va_52(FILE * restrict stream, char const * restrict format);
+
+/*@ requires valid_read_string(format);
+ assigns \result, stream->__fc_FILE_data;
+ assigns \result
+ \from (indirect: stream->__fc_FILE_id),
+ (indirect: stream->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns stream->__fc_FILE_data
+ \from (indirect: stream->__fc_FILE_id), stream->__fc_FILE_data,
+ (indirect: *(format + (0 ..)));
+ */
+int fprintf_va_53(FILE * restrict stream, char const * restrict format);
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..))), (indirect: param2),
+ (indirect: param1), (indirect: *(param0 + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..))),
+ param2, param1, *(param0 + (0 ..));
+ */
+int printf_va_8(char const * restrict format, char *param0,
+ unsigned int param1, unsigned long param2);
+
+/*@ requires valid_read_string(format);
+ assigns \result, __fc_stdout->__fc_FILE_data;
+ assigns \result
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ (indirect: __fc_stdout->__fc_FILE_data),
+ (indirect: *(format + (0 ..)));
+ assigns __fc_stdout->__fc_FILE_data
+ \from (indirect: __fc_stdout->__fc_FILE_id),
+ __fc_stdout->__fc_FILE_data, (indirect: *(format + (0 ..)));
+ */
+int printf_va_9(char const * restrict format);
+
+int main(int argc, char **argv) __attribute__((__FC_OLDSTYLEPROTO__));
+int main(int argc, char **argv)
+{
+ int __retres;
+ Byte *compr;
+ Byte *uncompr;
+ char const *tmp_1;
+ uLong tmp_2;
+ char const *tmp_5;
+ uLong comprLen = (unsigned long)10000 * sizeof(int);
+ uLong uncomprLen = comprLen;
+ tmp_1 = zlibVersion();
+ ;
+ if ((int)*(tmp_1 + 0) != (int)*(main_myVersion + 0)) {
+ fprintf(__fc_stderr,"incompatible zlib version\n"); /* fprintf_va_52 */
+ exit(1);
+ }
+ else {
+ int tmp_0;
+ char const *tmp;
+ tmp = zlibVersion();
+ tmp_0 = strcmp(tmp,"1.2.11");
+ if (tmp_0 != 0) fprintf(__fc_stderr,"warning: different zlib version\n"); /* fprintf_va_53 */
+ }
+ tmp_2 = zlibCompileFlags();
+ printf("zlib version %s = 0x%04x, compile flags = 0x%lx\n",
+ (char *)"1.2.11",(unsigned int)0x12b0,tmp_2); /* printf_va_8 */
+ compr = (Byte *)calloc((unsigned long)((unsigned int)comprLen),
+ (unsigned long)1);
+ uncompr = (Byte *)calloc((unsigned long)((unsigned int)uncomprLen),
+ (unsigned long)1);
+ if (compr == (Byte *)0) goto _LOR;
+ else
+ if (uncompr == (Byte *)0) {
+ _LOR: {
+ printf("out of memory\n"); /* printf_va_9 */
+ exit(1);
+ }
+ }
+ test_compress(compr,comprLen,uncompr,uncomprLen);
+ ;
+ ;
+ if (argc > 1) tmp_5 = (char const *)*(argv + 1); else tmp_5 = "foo.gz";
+ test_gzio(tmp_5,uncompr,uncomprLen);
+ test_deflate(compr,comprLen);
+ test_inflate(compr,comprLen,uncompr,uncomprLen);
+ test_large_deflate(compr,comprLen,uncompr,uncomprLen);
+ test_large_inflate(compr,comprLen,uncompr,uncomprLen);
+ test_flush(compr,& comprLen);
+ test_sync(compr,comprLen,uncompr,uncomprLen);
+ comprLen = uncomprLen;
+ test_dict_deflate(compr,comprLen);
+ test_dict_inflate(compr,comprLen,uncompr,uncomprLen);
+ free((void *)compr);
+ free((void *)uncompr);
+ __retres = 0;
+ return __retres;
+}
+
+char * const z_errmsg[10];
+
+uLong adler32_combine64(uLong adler1, uLong adler2, long len2) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+uLong crc32_combine64(uLong crc1, uLong crc2, long len2) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+voidpf zcalloc(voidpf opaque, unsigned int items, unsigned int size) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+void zcfree(voidpf opaque, voidpf ptr) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static uLong adler32_combine_(uLong adler1, uLong adler2, long len2) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+uLong adler32_z(uLong adler, Bytef const *buf, z_size_t len) __attribute__((
+__FC_OLDSTYLEPROTO__));
+uLong adler32_z(uLong adler, Bytef const *buf, z_size_t len)
+{
+ uLong __retres;
+ unsigned long sum2;
+ unsigned int n;
+ sum2 = (adler >> 16) & (unsigned long)0xffff;
+ adler &= (unsigned long)0xffff;
+ if (len == (z_size_t)1) {
+ adler += (uLong)*(buf + 0);
+ if (adler >= (uLong)65521U) adler -= (uLong)65521U;
+ sum2 += adler;
+ if (sum2 >= (unsigned long)65521U) sum2 -= (unsigned long)65521U;
+ __retres = adler | (sum2 << 16);
+ goto return_label;
+ }
+ if (buf == (Bytef const *)0) {
+ __retres = (unsigned long)1L;
+ goto return_label;
+ }
+ if (len < (z_size_t)16) {
+ while (1) {
+ z_size_t tmp_0;
+ tmp_0 = len;
+ len -= (z_size_t)1;
+ ;
+ if (! tmp_0) break;
+ {
+ Bytef const *tmp;
+ tmp = buf;
+ buf ++;
+ adler += (uLong)*tmp;
+ sum2 += adler;
+ }
+ }
+ if (adler >= (uLong)65521U) adler -= (uLong)65521U;
+ sum2 %= (unsigned long)65521U;
+ __retres = adler | (sum2 << 16);
+ goto return_label;
+ }
+ while (len >= (z_size_t)5552) {
+ len -= (z_size_t)5552;
+ n = (unsigned int)(5552 / 16);
+ while (1) {
+ adler += (uLong)*(buf + 0);
+ sum2 += adler;
+ adler += (uLong)*(buf + (0 + 1));
+ sum2 += adler;
+ adler += (uLong)*(buf + (0 + 2));
+ sum2 += adler;
+ adler += (uLong)*(buf + ((0 + 2) + 1));
+ sum2 += adler;
+ adler += (uLong)*(buf + (0 + 4));
+ sum2 += adler;
+ adler += (uLong)*(buf + ((0 + 4) + 1));
+ sum2 += adler;
+ adler += (uLong)*(buf + ((0 + 4) + 2));
+ sum2 += adler;
+ adler += (uLong)*(buf + (((0 + 4) + 2) + 1));
+ sum2 += adler;
+ adler += (uLong)*(buf + 8);
+ sum2 += adler;
+ adler += (uLong)*(buf + (8 + 1));
+ sum2 += adler;
+ adler += (uLong)*(buf + (8 + 2));
+ sum2 += adler;
+ adler += (uLong)*(buf + ((8 + 2) + 1));
+ sum2 += adler;
+ adler += (uLong)*(buf + (8 + 4));
+ sum2 += adler;
+ adler += (uLong)*(buf + ((8 + 4) + 1));
+ sum2 += adler;
+ adler += (uLong)*(buf + ((8 + 4) + 2));
+ sum2 += adler;
+ adler += (uLong)*(buf + (((8 + 4) + 2) + 1));
+ sum2 += adler;
+ buf += 16;
+ n --;
+ if (! n) break;
+ }
+ adler %= (unsigned long)65521U;
+ sum2 %= (unsigned long)65521U;
+ }
+ if (len) {
+ while (len >= (z_size_t)16) {
+ len -= (z_size_t)16;
+ adler += (uLong)*(buf + 0);
+ sum2 += adler;
+ adler += (uLong)*(buf + (0 + 1));
+ sum2 += adler;
+ adler += (uLong)*(buf + (0 + 2));
+ sum2 += adler;
+ adler += (uLong)*(buf + ((0 + 2) + 1));
+ sum2 += adler;
+ adler += (uLong)*(buf + (0 + 4));
+ sum2 += adler;
+ adler += (uLong)*(buf + ((0 + 4) + 1));
+ sum2 += adler;
+ adler += (uLong)*(buf + ((0 + 4) + 2));
+ sum2 += adler;
+ adler += (uLong)*(buf + (((0 + 4) + 2) + 1));
+ sum2 += adler;
+ adler += (uLong)*(buf + 8);
+ sum2 += adler;
+ adler += (uLong)*(buf + (8 + 1));
+ sum2 += adler;
+ adler += (uLong)*(buf + (8 + 2));
+ sum2 += adler;
+ adler += (uLong)*(buf + ((8 + 2) + 1));
+ sum2 += adler;
+ adler += (uLong)*(buf + (8 + 4));
+ sum2 += adler;
+ adler += (uLong)*(buf + ((8 + 4) + 1));
+ sum2 += adler;
+ adler += (uLong)*(buf + ((8 + 4) + 2));
+ sum2 += adler;
+ adler += (uLong)*(buf + (((8 + 4) + 2) + 1));
+ sum2 += adler;
+ buf += 16;
+ }
+ while (1) {
+ z_size_t tmp_2;
+ tmp_2 = len;
+ len -= (z_size_t)1;
+ ;
+ if (! tmp_2) break;
+ {
+ Bytef const *tmp_1;
+ tmp_1 = buf;
+ buf ++;
+ adler += (uLong)*tmp_1;
+ sum2 += adler;
+ }
+ }
+ adler %= (unsigned long)65521U;
+ sum2 %= (unsigned long)65521U;
+ }
+ __retres = adler | (sum2 << 16);
+ return_label: return __retres;
+}
+
+uLong adler32(uLong adler, Bytef const *buf, uInt len) __attribute__((
+__FC_OLDSTYLEPROTO__));
+uLong adler32(uLong adler, Bytef const *buf, uInt len)
+{
+ uLong tmp;
+ tmp = adler32_z(adler,buf,(unsigned long)len);
+ return tmp;
+}
+
+static uLong adler32_combine_(uLong adler1, uLong adler2, long len2) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static uLong adler32_combine_(uLong adler1, uLong adler2, long len2)
+{
+ uLong __retres;
+ unsigned long sum1;
+ unsigned long sum2;
+ unsigned int rem;
+ if (len2 < (long)0) {
+ __retres = 0xffffffffUL;
+ goto return_label;
+ }
+ len2 %= (long)65521U;
+ rem = (unsigned int)len2;
+ sum1 = adler1 & (unsigned long)0xffff;
+ sum2 = (unsigned long)rem * sum1;
+ sum2 %= (unsigned long)65521U;
+ sum1 += ((adler2 & (unsigned long)0xffff) + (unsigned long)65521U) - (unsigned long)1;
+ sum2 += ((((adler1 >> 16) & (unsigned long)0xffff) + ((adler2 >> 16) & (unsigned long)0xffff)) + (unsigned long)65521U) - (unsigned long)rem;
+ if (sum1 >= (unsigned long)65521U) sum1 -= (unsigned long)65521U;
+ if (sum1 >= (unsigned long)65521U) sum1 -= (unsigned long)65521U;
+ if (sum2 >= (unsigned long)65521U << 1) sum2 -= (unsigned long)65521U << 1;
+ if (sum2 >= (unsigned long)65521U) sum2 -= (unsigned long)65521U;
+ __retres = sum1 | (sum2 << 16);
+ return_label: return __retres;
+}
+
+uLong adler32_combine(uLong adler1, uLong adler2, long len2) __attribute__((
+__FC_OLDSTYLEPROTO__));
+uLong adler32_combine(uLong adler1, uLong adler2, long len2)
+{
+ uLong tmp;
+ tmp = adler32_combine_(adler1,adler2,len2);
+ return tmp;
+}
+
+uLong adler32_combine64(uLong adler1, uLong adler2, long len2) __attribute__((
+__FC_OLDSTYLEPROTO__));
+uLong adler32_combine64(uLong adler1, uLong adler2, long len2)
+{
+ uLong tmp;
+ tmp = adler32_combine_(adler1,adler2,len2);
+ return tmp;
+}
+
+int compress2(Bytef *dest, uLongf *destLen, Bytef const *source,
+ uLong sourceLen, int level) __attribute__((__FC_OLDSTYLEPROTO__));
+int compress2(Bytef *dest, uLongf *destLen, Bytef const *source,
+ uLong sourceLen, int level)
+{
+ int __retres;
+ z_stream stream;
+ int err;
+ uLong left;
+ int tmp_0;
+ uInt const max = (unsigned int)(-1);
+ left = *destLen;
+ *destLen = (unsigned long)0;
+ stream.zalloc = (voidpf (*)(voidpf opaque, uInt items, uInt size))0;
+ stream.zfree = (void (*)(voidpf opaque, voidpf address))0;
+ stream.opaque = (void *)0;
+ err = deflateInit_(& stream,level,"1.2.11",(int)sizeof(z_stream));
+ if (err != 0) {
+ __retres = err;
+ goto return_label;
+ }
+ stream.next_out = dest;
+ stream.avail_out = (unsigned int)0;
+ stream.next_in = (Bytef *)source;
+ stream.avail_in = (unsigned int)0;
+ while (1) {
+ {
+ int tmp;
+ if (stream.avail_out == (uInt)0) {
+ if (left > (unsigned long)max) stream.avail_out = max;
+ else stream.avail_out = (unsigned int)left;
+ left -= (uLong)stream.avail_out;
+ }
+ if (stream.avail_in == (uInt)0) {
+ if (sourceLen > (unsigned long)max) stream.avail_in = max;
+ else stream.avail_in = (unsigned int)sourceLen;
+ sourceLen -= (uLong)stream.avail_in;
+ }
+ if (sourceLen) tmp = 0; else tmp = 4;
+ err = deflate(& stream,tmp);
+ }
+ if (! (err == 0)) break;
+ }
+ *destLen = stream.total_out;
+ deflateEnd(& stream);
+ if (err == 1) tmp_0 = 0; else tmp_0 = err;
+ __retres = tmp_0;
+ return_label: return __retres;
+}
+
+int compress(Bytef *dest, uLongf *destLen, Bytef const *source,
+ uLong sourceLen) __attribute__((__FC_OLDSTYLEPROTO__));
+int compress(Bytef *dest, uLongf *destLen, Bytef const *source,
+ uLong sourceLen)
+{
+ int tmp;
+ tmp = compress2(dest,destLen,source,sourceLen,-1);
+ return tmp;
+}
+
+uLong compressBound(uLong sourceLen) __attribute__((__FC_OLDSTYLEPROTO__));
+uLong compressBound(uLong sourceLen)
+{
+ uLong __retres;
+ __retres = (((sourceLen + (sourceLen >> 12)) + (sourceLen >> 14)) + (
+ sourceLen >> 25)) + (uLong)13;
+ return __retres;
+}
+
+static unsigned long crc32_little(unsigned long crc,
+ unsigned char const *buf, z_size_t len) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static unsigned long crc32_big(unsigned long crc, unsigned char const *buf,
+ z_size_t len) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static unsigned long gf2_matrix_times(unsigned long *mat, unsigned long vec) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static void gf2_matrix_square(unsigned long *square, unsigned long *mat) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static uLong crc32_combine_(uLong crc1, uLong crc2, long len2) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static z_crc_t const crc_table[8][256] =
+ {{(unsigned int)0x00000000UL,
+ (unsigned int)0x77073096UL,
+ (unsigned int)0xee0e612cUL,
+ (unsigned int)0x990951baUL,
+ (unsigned int)0x076dc419UL,
+ (unsigned int)0x706af48fUL,
+ (unsigned int)0xe963a535UL,
+ (unsigned int)0x9e6495a3UL,
+ (unsigned int)0x0edb8832UL,
+ (unsigned int)0x79dcb8a4UL,
+ (unsigned int)0xe0d5e91eUL,
+ (unsigned int)0x97d2d988UL,
+ (unsigned int)0x09b64c2bUL,
+ (unsigned int)0x7eb17cbdUL,
+ (unsigned int)0xe7b82d07UL,
+ (unsigned int)0x90bf1d91UL,
+ (unsigned int)0x1db71064UL,
+ (unsigned int)0x6ab020f2UL,
+ (unsigned int)0xf3b97148UL,
+ (unsigned int)0x84be41deUL,
+ (unsigned int)0x1adad47dUL,
+ (unsigned int)0x6ddde4ebUL,
+ (unsigned int)0xf4d4b551UL,
+ (unsigned int)0x83d385c7UL,
+ (unsigned int)0x136c9856UL,
+ (unsigned int)0x646ba8c0UL,
+ (unsigned int)0xfd62f97aUL,
+ (unsigned int)0x8a65c9ecUL,
+ (unsigned int)0x14015c4fUL,
+ (unsigned int)0x63066cd9UL,
+ (unsigned int)0xfa0f3d63UL,
+ (unsigned int)0x8d080df5UL,
+ (unsigned int)0x3b6e20c8UL,
+ (unsigned int)0x4c69105eUL,
+ (unsigned int)0xd56041e4UL,
+ (unsigned int)0xa2677172UL,
+ (unsigned int)0x3c03e4d1UL,
+ (unsigned int)0x4b04d447UL,
+ (unsigned int)0xd20d85fdUL,
+ (unsigned int)0xa50ab56bUL,
+ (unsigned int)0x35b5a8faUL,
+ (unsigned int)0x42b2986cUL,
+ (unsigned int)0xdbbbc9d6UL,
+ (unsigned int)0xacbcf940UL,
+ (unsigned int)0x32d86ce3UL,
+ (unsigned int)0x45df5c75UL,
+ (unsigned int)0xdcd60dcfUL,
+ (unsigned int)0xabd13d59UL,
+ (unsigned int)0x26d930acUL,
+ (unsigned int)0x51de003aUL,
+ (unsigned int)0xc8d75180UL,
+ (unsigned int)0xbfd06116UL,
+ (unsigned int)0x21b4f4b5UL,
+ (unsigned int)0x56b3c423UL,
+ (unsigned int)0xcfba9599UL,
+ (unsigned int)0xb8bda50fUL,
+ (unsigned int)0x2802b89eUL,
+ (unsigned int)0x5f058808UL,
+ (unsigned int)0xc60cd9b2UL,
+ (unsigned int)0xb10be924UL,
+ (unsigned int)0x2f6f7c87UL,
+ (unsigned int)0x58684c11UL,
+ (unsigned int)0xc1611dabUL,
+ (unsigned int)0xb6662d3dUL,
+ (unsigned int)0x76dc4190UL,
+ (unsigned int)0x01db7106UL,
+ (unsigned int)0x98d220bcUL,
+ (unsigned int)0xefd5102aUL,
+ (unsigned int)0x71b18589UL,
+ (unsigned int)0x06b6b51fUL,
+ (unsigned int)0x9fbfe4a5UL,
+ (unsigned int)0xe8b8d433UL,
+ (unsigned int)0x7807c9a2UL,
+ (unsigned int)0x0f00f934UL,
+ (unsigned int)0x9609a88eUL,
+ (unsigned int)0xe10e9818UL,
+ (unsigned int)0x7f6a0dbbUL,
+ (unsigned int)0x086d3d2dUL,
+ (unsigned int)0x91646c97UL,
+ (unsigned int)0xe6635c01UL,
+ (unsigned int)0x6b6b51f4UL,
+ (unsigned int)0x1c6c6162UL,
+ (unsigned int)0x856530d8UL,
+ (unsigned int)0xf262004eUL,
+ (unsigned int)0x6c0695edUL,
+ (unsigned int)0x1b01a57bUL,
+ (unsigned int)0x8208f4c1UL,
+ (unsigned int)0xf50fc457UL,
+ (unsigned int)0x65b0d9c6UL,
+ (unsigned int)0x12b7e950UL,
+ (unsigned int)0x8bbeb8eaUL,
+ (unsigned int)0xfcb9887cUL,
+ (unsigned int)0x62dd1ddfUL,
+ (unsigned int)0x15da2d49UL,
+ (unsigned int)0x8cd37cf3UL,
+ (unsigned int)0xfbd44c65UL,
+ (unsigned int)0x4db26158UL,
+ (unsigned int)0x3ab551ceUL,
+ (unsigned int)0xa3bc0074UL,
+ (unsigned int)0xd4bb30e2UL,
+ (unsigned int)0x4adfa541UL,
+ (unsigned int)0x3dd895d7UL,
+ (unsigned int)0xa4d1c46dUL,
+ (unsigned int)0xd3d6f4fbUL,
+ (unsigned int)0x4369e96aUL,
+ (unsigned int)0x346ed9fcUL,
+ (unsigned int)0xad678846UL,
+ (unsigned int)0xda60b8d0UL,
+ (unsigned int)0x44042d73UL,
+ (unsigned int)0x33031de5UL,
+ (unsigned int)0xaa0a4c5fUL,
+ (unsigned int)0xdd0d7cc9UL,
+ (unsigned int)0x5005713cUL,
+ (unsigned int)0x270241aaUL,
+ (unsigned int)0xbe0b1010UL,
+ (unsigned int)0xc90c2086UL,
+ (unsigned int)0x5768b525UL,
+ (unsigned int)0x206f85b3UL,
+ (unsigned int)0xb966d409UL,
+ (unsigned int)0xce61e49fUL,
+ (unsigned int)0x5edef90eUL,
+ (unsigned int)0x29d9c998UL,
+ (unsigned int)0xb0d09822UL,
+ (unsigned int)0xc7d7a8b4UL,
+ (unsigned int)0x59b33d17UL,
+ (unsigned int)0x2eb40d81UL,
+ (unsigned int)0xb7bd5c3bUL,
+ (unsigned int)0xc0ba6cadUL,
+ (unsigned int)0xedb88320UL,
+ (unsigned int)0x9abfb3b6UL,
+ (unsigned int)0x03b6e20cUL,
+ (unsigned int)0x74b1d29aUL,
+ (unsigned int)0xead54739UL,
+ (unsigned int)0x9dd277afUL,
+ (unsigned int)0x04db2615UL,
+ (unsigned int)0x73dc1683UL,
+ (unsigned int)0xe3630b12UL,
+ (unsigned int)0x94643b84UL,
+ (unsigned int)0x0d6d6a3eUL,
+ (unsigned int)0x7a6a5aa8UL,
+ (unsigned int)0xe40ecf0bUL,
+ (unsigned int)0x9309ff9dUL,
+ (unsigned int)0x0a00ae27UL,
+ (unsigned int)0x7d079eb1UL,
+ (unsigned int)0xf00f9344UL,
+ (unsigned int)0x8708a3d2UL,
+ (unsigned int)0x1e01f268UL,
+ (unsigned int)0x6906c2feUL,
+ (unsigned int)0xf762575dUL,
+ (unsigned int)0x806567cbUL,
+ (unsigned int)0x196c3671UL,
+ (unsigned int)0x6e6b06e7UL,
+ (unsigned int)0xfed41b76UL,
+ (unsigned int)0x89d32be0UL,
+ (unsigned int)0x10da7a5aUL,
+ (unsigned int)0x67dd4accUL,
+ (unsigned int)0xf9b9df6fUL,
+ (unsigned int)0x8ebeeff9UL,
+ (unsigned int)0x17b7be43UL,
+ (unsigned int)0x60b08ed5UL,
+ (unsigned int)0xd6d6a3e8UL,
+ (unsigned int)0xa1d1937eUL,
+ (unsigned int)0x38d8c2c4UL,
+ (unsigned int)0x4fdff252UL,
+ (unsigned int)0xd1bb67f1UL,
+ (unsigned int)0xa6bc5767UL,
+ (unsigned int)0x3fb506ddUL,
+ (unsigned int)0x48b2364bUL,
+ (unsigned int)0xd80d2bdaUL,
+ (unsigned int)0xaf0a1b4cUL,
+ (unsigned int)0x36034af6UL,
+ (unsigned int)0x41047a60UL,
+ (unsigned int)0xdf60efc3UL,
+ (unsigned int)0xa867df55UL,
+ (unsigned int)0x316e8eefUL,
+ (unsigned int)0x4669be79UL,
+ (unsigned int)0xcb61b38cUL,
+ (unsigned int)0xbc66831aUL,
+ (unsigned int)0x256fd2a0UL,
+ (unsigned int)0x5268e236UL,
+ (unsigned int)0xcc0c7795UL,
+ (unsigned int)0xbb0b4703UL,
+ (unsigned int)0x220216b9UL,
+ (unsigned int)0x5505262fUL,
+ (unsigned int)0xc5ba3bbeUL,
+ (unsigned int)0xb2bd0b28UL,
+ (unsigned int)0x2bb45a92UL,
+ (unsigned int)0x5cb36a04UL,
+ (unsigned int)0xc2d7ffa7UL,
+ (unsigned int)0xb5d0cf31UL,
+ (unsigned int)0x2cd99e8bUL,
+ (unsigned int)0x5bdeae1dUL,
+ (unsigned int)0x9b64c2b0UL,
+ (unsigned int)0xec63f226UL,
+ (unsigned int)0x756aa39cUL,
+ (unsigned int)0x026d930aUL,
+ (unsigned int)0x9c0906a9UL,
+ (unsigned int)0xeb0e363fUL,
+ (unsigned int)0x72076785UL,
+ (unsigned int)0x05005713UL,
+ (unsigned int)0x95bf4a82UL,
+ (unsigned int)0xe2b87a14UL,
+ (unsigned int)0x7bb12baeUL,
+ (unsigned int)0x0cb61b38UL,
+ (unsigned int)0x92d28e9bUL,
+ (unsigned int)0xe5d5be0dUL,
+ (unsigned int)0x7cdcefb7UL,
+ (unsigned int)0x0bdbdf21UL,
+ (unsigned int)0x86d3d2d4UL,
+ (unsigned int)0xf1d4e242UL,
+ (unsigned int)0x68ddb3f8UL,
+ (unsigned int)0x1fda836eUL,
+ (unsigned int)0x81be16cdUL,
+ (unsigned int)0xf6b9265bUL,
+ (unsigned int)0x6fb077e1UL,
+ (unsigned int)0x18b74777UL,
+ (unsigned int)0x88085ae6UL,
+ (unsigned int)0xff0f6a70UL,
+ (unsigned int)0x66063bcaUL,
+ (unsigned int)0x11010b5cUL,
+ (unsigned int)0x8f659effUL,
+ (unsigned int)0xf862ae69UL,
+ (unsigned int)0x616bffd3UL,
+ (unsigned int)0x166ccf45UL,
+ (unsigned int)0xa00ae278UL,
+ (unsigned int)0xd70dd2eeUL,
+ (unsigned int)0x4e048354UL,
+ (unsigned int)0x3903b3c2UL,
+ (unsigned int)0xa7672661UL,
+ (unsigned int)0xd06016f7UL,
+ (unsigned int)0x4969474dUL,
+ (unsigned int)0x3e6e77dbUL,
+ (unsigned int)0xaed16a4aUL,
+ (unsigned int)0xd9d65adcUL,
+ (unsigned int)0x40df0b66UL,
+ (unsigned int)0x37d83bf0UL,
+ (unsigned int)0xa9bcae53UL,
+ (unsigned int)0xdebb9ec5UL,
+ (unsigned int)0x47b2cf7fUL,
+ (unsigned int)0x30b5ffe9UL,
+ (unsigned int)0xbdbdf21cUL,
+ (unsigned int)0xcabac28aUL,
+ (unsigned int)0x53b39330UL,
+ (unsigned int)0x24b4a3a6UL,
+ (unsigned int)0xbad03605UL,
+ (unsigned int)0xcdd70693UL,
+ (unsigned int)0x54de5729UL,
+ (unsigned int)0x23d967bfUL,
+ (unsigned int)0xb3667a2eUL,
+ (unsigned int)0xc4614ab8UL,
+ (unsigned int)0x5d681b02UL,
+ (unsigned int)0x2a6f2b94UL,
+ (unsigned int)0xb40bbe37UL,
+ (unsigned int)0xc30c8ea1UL,
+ (unsigned int)0x5a05df1bUL,
+ (unsigned int)0x2d02ef8dUL},
+ {(unsigned int)0x00000000UL,
+ (unsigned int)0x191b3141UL,
+ (unsigned int)0x32366282UL,
+ (unsigned int)0x2b2d53c3UL,
+ (unsigned int)0x646cc504UL,
+ (unsigned int)0x7d77f445UL,
+ (unsigned int)0x565aa786UL,
+ (unsigned int)0x4f4196c7UL,
+ (unsigned int)0xc8d98a08UL,
+ (unsigned int)0xd1c2bb49UL,
+ (unsigned int)0xfaefe88aUL,
+ (unsigned int)0xe3f4d9cbUL,
+ (unsigned int)0xacb54f0cUL,
+ (unsigned int)0xb5ae7e4dUL,
+ (unsigned int)0x9e832d8eUL,
+ (unsigned int)0x87981ccfUL,
+ (unsigned int)0x4ac21251UL,
+ (unsigned int)0x53d92310UL,
+ (unsigned int)0x78f470d3UL,
+ (unsigned int)0x61ef4192UL,
+ (unsigned int)0x2eaed755UL,
+ (unsigned int)0x37b5e614UL,
+ (unsigned int)0x1c98b5d7UL,
+ (unsigned int)0x05838496UL,
+ (unsigned int)0x821b9859UL,
+ (unsigned int)0x9b00a918UL,
+ (unsigned int)0xb02dfadbUL,
+ (unsigned int)0xa936cb9aUL,
+ (unsigned int)0xe6775d5dUL,
+ (unsigned int)0xff6c6c1cUL,
+ (unsigned int)0xd4413fdfUL,
+ (unsigned int)0xcd5a0e9eUL,
+ (unsigned int)0x958424a2UL,
+ (unsigned int)0x8c9f15e3UL,
+ (unsigned int)0xa7b24620UL,
+ (unsigned int)0xbea97761UL,
+ (unsigned int)0xf1e8e1a6UL,
+ (unsigned int)0xe8f3d0e7UL,
+ (unsigned int)0xc3de8324UL,
+ (unsigned int)0xdac5b265UL,
+ (unsigned int)0x5d5daeaaUL,
+ (unsigned int)0x44469febUL,
+ (unsigned int)0x6f6bcc28UL,
+ (unsigned int)0x7670fd69UL,
+ (unsigned int)0x39316baeUL,
+ (unsigned int)0x202a5aefUL,
+ (unsigned int)0x0b07092cUL,
+ (unsigned int)0x121c386dUL,
+ (unsigned int)0xdf4636f3UL,
+ (unsigned int)0xc65d07b2UL,
+ (unsigned int)0xed705471UL,
+ (unsigned int)0xf46b6530UL,
+ (unsigned int)0xbb2af3f7UL,
+ (unsigned int)0xa231c2b6UL,
+ (unsigned int)0x891c9175UL,
+ (unsigned int)0x9007a034UL,
+ (unsigned int)0x179fbcfbUL,
+ (unsigned int)0x0e848dbaUL,
+ (unsigned int)0x25a9de79UL,
+ (unsigned int)0x3cb2ef38UL,
+ (unsigned int)0x73f379ffUL,
+ (unsigned int)0x6ae848beUL,
+ (unsigned int)0x41c51b7dUL,
+ (unsigned int)0x58de2a3cUL,
+ (unsigned int)0xf0794f05UL,
+ (unsigned int)0xe9627e44UL,
+ (unsigned int)0xc24f2d87UL,
+ (unsigned int)0xdb541cc6UL,
+ (unsigned int)0x94158a01UL,
+ (unsigned int)0x8d0ebb40UL,
+ (unsigned int)0xa623e883UL,
+ (unsigned int)0xbf38d9c2UL,
+ (unsigned int)0x38a0c50dUL,
+ (unsigned int)0x21bbf44cUL,
+ (unsigned int)0x0a96a78fUL,
+ (unsigned int)0x138d96ceUL,
+ (unsigned int)0x5ccc0009UL,
+ (unsigned int)0x45d73148UL,
+ (unsigned int)0x6efa628bUL,
+ (unsigned int)0x77e153caUL,
+ (unsigned int)0xbabb5d54UL,
+ (unsigned int)0xa3a06c15UL,
+ (unsigned int)0x888d3fd6UL,
+ (unsigned int)0x91960e97UL,
+ (unsigned int)0xded79850UL,
+ (unsigned int)0xc7cca911UL,
+ (unsigned int)0xece1fad2UL,
+ (unsigned int)0xf5facb93UL,
+ (unsigned int)0x7262d75cUL,
+ (unsigned int)0x6b79e61dUL,
+ (unsigned int)0x4054b5deUL,
+ (unsigned int)0x594f849fUL,
+ (unsigned int)0x160e1258UL,
+ (unsigned int)0x0f152319UL,
+ (unsigned int)0x243870daUL,
+ (unsigned int)0x3d23419bUL,
+ (unsigned int)0x65fd6ba7UL,
+ (unsigned int)0x7ce65ae6UL,
+ (unsigned int)0x57cb0925UL,
+ (unsigned int)0x4ed03864UL,
+ (unsigned int)0x0191aea3UL,
+ (unsigned int)0x188a9fe2UL,
+ (unsigned int)0x33a7cc21UL,
+ (unsigned int)0x2abcfd60UL,
+ (unsigned int)0xad24e1afUL,
+ (unsigned int)0xb43fd0eeUL,
+ (unsigned int)0x9f12832dUL,
+ (unsigned int)0x8609b26cUL,
+ (unsigned int)0xc94824abUL,
+ (unsigned int)0xd05315eaUL,
+ (unsigned int)0xfb7e4629UL,
+ (unsigned int)0xe2657768UL,
+ (unsigned int)0x2f3f79f6UL,
+ (unsigned int)0x362448b7UL,
+ (unsigned int)0x1d091b74UL,
+ (unsigned int)0x04122a35UL,
+ (unsigned int)0x4b53bcf2UL,
+ (unsigned int)0x52488db3UL,
+ (unsigned int)0x7965de70UL,
+ (unsigned int)0x607eef31UL,
+ (unsigned int)0xe7e6f3feUL,
+ (unsigned int)0xfefdc2bfUL,
+ (unsigned int)0xd5d0917cUL,
+ (unsigned int)0xcccba03dUL,
+ (unsigned int)0x838a36faUL,
+ (unsigned int)0x9a9107bbUL,
+ (unsigned int)0xb1bc5478UL,
+ (unsigned int)0xa8a76539UL,
+ (unsigned int)0x3b83984bUL,
+ (unsigned int)0x2298a90aUL,
+ (unsigned int)0x09b5fac9UL,
+ (unsigned int)0x10aecb88UL,
+ (unsigned int)0x5fef5d4fUL,
+ (unsigned int)0x46f46c0eUL,
+ (unsigned int)0x6dd93fcdUL,
+ (unsigned int)0x74c20e8cUL,
+ (unsigned int)0xf35a1243UL,
+ (unsigned int)0xea412302UL,
+ (unsigned int)0xc16c70c1UL,
+ (unsigned int)0xd8774180UL,
+ (unsigned int)0x9736d747UL,
+ (unsigned int)0x8e2de606UL,
+ (unsigned int)0xa500b5c5UL,
+ (unsigned int)0xbc1b8484UL,
+ (unsigned int)0x71418a1aUL,
+ (unsigned int)0x685abb5bUL,
+ (unsigned int)0x4377e898UL,
+ (unsigned int)0x5a6cd9d9UL,
+ (unsigned int)0x152d4f1eUL,
+ (unsigned int)0x0c367e5fUL,
+ (unsigned int)0x271b2d9cUL,
+ (unsigned int)0x3e001cddUL,
+ (unsigned int)0xb9980012UL,
+ (unsigned int)0xa0833153UL,
+ (unsigned int)0x8bae6290UL,
+ (unsigned int)0x92b553d1UL,
+ (unsigned int)0xddf4c516UL,
+ (unsigned int)0xc4eff457UL,
+ (unsigned int)0xefc2a794UL,
+ (unsigned int)0xf6d996d5UL,
+ (unsigned int)0xae07bce9UL,
+ (unsigned int)0xb71c8da8UL,
+ (unsigned int)0x9c31de6bUL,
+ (unsigned int)0x852aef2aUL,
+ (unsigned int)0xca6b79edUL,
+ (unsigned int)0xd37048acUL,
+ (unsigned int)0xf85d1b6fUL,
+ (unsigned int)0xe1462a2eUL,
+ (unsigned int)0x66de36e1UL,
+ (unsigned int)0x7fc507a0UL,
+ (unsigned int)0x54e85463UL,
+ (unsigned int)0x4df36522UL,
+ (unsigned int)0x02b2f3e5UL,
+ (unsigned int)0x1ba9c2a4UL,
+ (unsigned int)0x30849167UL,
+ (unsigned int)0x299fa026UL,
+ (unsigned int)0xe4c5aeb8UL,
+ (unsigned int)0xfdde9ff9UL,
+ (unsigned int)0xd6f3cc3aUL,
+ (unsigned int)0xcfe8fd7bUL,
+ (unsigned int)0x80a96bbcUL,
+ (unsigned int)0x99b25afdUL,
+ (unsigned int)0xb29f093eUL,
+ (unsigned int)0xab84387fUL,
+ (unsigned int)0x2c1c24b0UL,
+ (unsigned int)0x350715f1UL,
+ (unsigned int)0x1e2a4632UL,
+ (unsigned int)0x07317773UL,
+ (unsigned int)0x4870e1b4UL,
+ (unsigned int)0x516bd0f5UL,
+ (unsigned int)0x7a468336UL,
+ (unsigned int)0x635db277UL,
+ (unsigned int)0xcbfad74eUL,
+ (unsigned int)0xd2e1e60fUL,
+ (unsigned int)0xf9ccb5ccUL,
+ (unsigned int)0xe0d7848dUL,
+ (unsigned int)0xaf96124aUL,
+ (unsigned int)0xb68d230bUL,
+ (unsigned int)0x9da070c8UL,
+ (unsigned int)0x84bb4189UL,
+ (unsigned int)0x03235d46UL,
+ (unsigned int)0x1a386c07UL,
+ (unsigned int)0x31153fc4UL,
+ (unsigned int)0x280e0e85UL,
+ (unsigned int)0x674f9842UL,
+ (unsigned int)0x7e54a903UL,
+ (unsigned int)0x5579fac0UL,
+ (unsigned int)0x4c62cb81UL,
+ (unsigned int)0x8138c51fUL,
+ (unsigned int)0x9823f45eUL,
+ (unsigned int)0xb30ea79dUL,
+ (unsigned int)0xaa1596dcUL,
+ (unsigned int)0xe554001bUL,
+ (unsigned int)0xfc4f315aUL,
+ (unsigned int)0xd7626299UL,
+ (unsigned int)0xce7953d8UL,
+ (unsigned int)0x49e14f17UL,
+ (unsigned int)0x50fa7e56UL,
+ (unsigned int)0x7bd72d95UL,
+ (unsigned int)0x62cc1cd4UL,
+ (unsigned int)0x2d8d8a13UL,
+ (unsigned int)0x3496bb52UL,
+ (unsigned int)0x1fbbe891UL,
+ (unsigned int)0x06a0d9d0UL,
+ (unsigned int)0x5e7ef3ecUL,
+ (unsigned int)0x4765c2adUL,
+ (unsigned int)0x6c48916eUL,
+ (unsigned int)0x7553a02fUL,
+ (unsigned int)0x3a1236e8UL,
+ (unsigned int)0x230907a9UL,
+ (unsigned int)0x0824546aUL,
+ (unsigned int)0x113f652bUL,
+ (unsigned int)0x96a779e4UL,
+ (unsigned int)0x8fbc48a5UL,
+ (unsigned int)0xa4911b66UL,
+ (unsigned int)0xbd8a2a27UL,
+ (unsigned int)0xf2cbbce0UL,
+ (unsigned int)0xebd08da1UL,
+ (unsigned int)0xc0fdde62UL,
+ (unsigned int)0xd9e6ef23UL,
+ (unsigned int)0x14bce1bdUL,
+ (unsigned int)0x0da7d0fcUL,
+ (unsigned int)0x268a833fUL,
+ (unsigned int)0x3f91b27eUL,
+ (unsigned int)0x70d024b9UL,
+ (unsigned int)0x69cb15f8UL,
+ (unsigned int)0x42e6463bUL,
+ (unsigned int)0x5bfd777aUL,
+ (unsigned int)0xdc656bb5UL,
+ (unsigned int)0xc57e5af4UL,
+ (unsigned int)0xee530937UL,
+ (unsigned int)0xf7483876UL,
+ (unsigned int)0xb809aeb1UL,
+ (unsigned int)0xa1129ff0UL,
+ (unsigned int)0x8a3fcc33UL,
+ (unsigned int)0x9324fd72UL},
+ {(unsigned int)0x00000000UL,
+ (unsigned int)0x01c26a37UL,
+ (unsigned int)0x0384d46eUL,
+ (unsigned int)0x0246be59UL,
+ (unsigned int)0x0709a8dcUL,
+ (unsigned int)0x06cbc2ebUL,
+ (unsigned int)0x048d7cb2UL,
+ (unsigned int)0x054f1685UL,
+ (unsigned int)0x0e1351b8UL,
+ (unsigned int)0x0fd13b8fUL,
+ (unsigned int)0x0d9785d6UL,
+ (unsigned int)0x0c55efe1UL,
+ (unsigned int)0x091af964UL,
+ (unsigned int)0x08d89353UL,
+ (unsigned int)0x0a9e2d0aUL,
+ (unsigned int)0x0b5c473dUL,
+ (unsigned int)0x1c26a370UL,
+ (unsigned int)0x1de4c947UL,
+ (unsigned int)0x1fa2771eUL,
+ (unsigned int)0x1e601d29UL,
+ (unsigned int)0x1b2f0bacUL,
+ (unsigned int)0x1aed619bUL,
+ (unsigned int)0x18abdfc2UL,
+ (unsigned int)0x1969b5f5UL,
+ (unsigned int)0x1235f2c8UL,
+ (unsigned int)0x13f798ffUL,
+ (unsigned int)0x11b126a6UL,
+ (unsigned int)0x10734c91UL,
+ (unsigned int)0x153c5a14UL,
+ (unsigned int)0x14fe3023UL,
+ (unsigned int)0x16b88e7aUL,
+ (unsigned int)0x177ae44dUL,
+ (unsigned int)0x384d46e0UL,
+ (unsigned int)0x398f2cd7UL,
+ (unsigned int)0x3bc9928eUL,
+ (unsigned int)0x3a0bf8b9UL,
+ (unsigned int)0x3f44ee3cUL,
+ (unsigned int)0x3e86840bUL,
+ (unsigned int)0x3cc03a52UL,
+ (unsigned int)0x3d025065UL,
+ (unsigned int)0x365e1758UL,
+ (unsigned int)0x379c7d6fUL,
+ (unsigned int)0x35dac336UL,
+ (unsigned int)0x3418a901UL,
+ (unsigned int)0x3157bf84UL,
+ (unsigned int)0x3095d5b3UL,
+ (unsigned int)0x32d36beaUL,
+ (unsigned int)0x331101ddUL,
+ (unsigned int)0x246be590UL,
+ (unsigned int)0x25a98fa7UL,
+ (unsigned int)0x27ef31feUL,
+ (unsigned int)0x262d5bc9UL,
+ (unsigned int)0x23624d4cUL,
+ (unsigned int)0x22a0277bUL,
+ (unsigned int)0x20e69922UL,
+ (unsigned int)0x2124f315UL,
+ (unsigned int)0x2a78b428UL,
+ (unsigned int)0x2bbade1fUL,
+ (unsigned int)0x29fc6046UL,
+ (unsigned int)0x283e0a71UL,
+ (unsigned int)0x2d711cf4UL,
+ (unsigned int)0x2cb376c3UL,
+ (unsigned int)0x2ef5c89aUL,
+ (unsigned int)0x2f37a2adUL,
+ (unsigned int)0x709a8dc0UL,
+ (unsigned int)0x7158e7f7UL,
+ (unsigned int)0x731e59aeUL,
+ (unsigned int)0x72dc3399UL,
+ (unsigned int)0x7793251cUL,
+ (unsigned int)0x76514f2bUL,
+ (unsigned int)0x7417f172UL,
+ (unsigned int)0x75d59b45UL,
+ (unsigned int)0x7e89dc78UL,
+ (unsigned int)0x7f4bb64fUL,
+ (unsigned int)0x7d0d0816UL,
+ (unsigned int)0x7ccf6221UL,
+ (unsigned int)0x798074a4UL,
+ (unsigned int)0x78421e93UL,
+ (unsigned int)0x7a04a0caUL,
+ (unsigned int)0x7bc6cafdUL,
+ (unsigned int)0x6cbc2eb0UL,
+ (unsigned int)0x6d7e4487UL,
+ (unsigned int)0x6f38fadeUL,
+ (unsigned int)0x6efa90e9UL,
+ (unsigned int)0x6bb5866cUL,
+ (unsigned int)0x6a77ec5bUL,
+ (unsigned int)0x68315202UL,
+ (unsigned int)0x69f33835UL,
+ (unsigned int)0x62af7f08UL,
+ (unsigned int)0x636d153fUL,
+ (unsigned int)0x612bab66UL,
+ (unsigned int)0x60e9c151UL,
+ (unsigned int)0x65a6d7d4UL,
+ (unsigned int)0x6464bde3UL,
+ (unsigned int)0x662203baUL,
+ (unsigned int)0x67e0698dUL,
+ (unsigned int)0x48d7cb20UL,
+ (unsigned int)0x4915a117UL,
+ (unsigned int)0x4b531f4eUL,
+ (unsigned int)0x4a917579UL,
+ (unsigned int)0x4fde63fcUL,
+ (unsigned int)0x4e1c09cbUL,
+ (unsigned int)0x4c5ab792UL,
+ (unsigned int)0x4d98dda5UL,
+ (unsigned int)0x46c49a98UL,
+ (unsigned int)0x4706f0afUL,
+ (unsigned int)0x45404ef6UL,
+ (unsigned int)0x448224c1UL,
+ (unsigned int)0x41cd3244UL,
+ (unsigned int)0x400f5873UL,
+ (unsigned int)0x4249e62aUL,
+ (unsigned int)0x438b8c1dUL,
+ (unsigned int)0x54f16850UL,
+ (unsigned int)0x55330267UL,
+ (unsigned int)0x5775bc3eUL,
+ (unsigned int)0x56b7d609UL,
+ (unsigned int)0x53f8c08cUL,
+ (unsigned int)0x523aaabbUL,
+ (unsigned int)0x507c14e2UL,
+ (unsigned int)0x51be7ed5UL,
+ (unsigned int)0x5ae239e8UL,
+ (unsigned int)0x5b2053dfUL,
+ (unsigned int)0x5966ed86UL,
+ (unsigned int)0x58a487b1UL,
+ (unsigned int)0x5deb9134UL,
+ (unsigned int)0x5c29fb03UL,
+ (unsigned int)0x5e6f455aUL,
+ (unsigned int)0x5fad2f6dUL,
+ (unsigned int)0xe1351b80UL,
+ (unsigned int)0xe0f771b7UL,
+ (unsigned int)0xe2b1cfeeUL,
+ (unsigned int)0xe373a5d9UL,
+ (unsigned int)0xe63cb35cUL,
+ (unsigned int)0xe7fed96bUL,
+ (unsigned int)0xe5b86732UL,
+ (unsigned int)0xe47a0d05UL,
+ (unsigned int)0xef264a38UL,
+ (unsigned int)0xeee4200fUL,
+ (unsigned int)0xeca29e56UL,
+ (unsigned int)0xed60f461UL,
+ (unsigned int)0xe82fe2e4UL,
+ (unsigned int)0xe9ed88d3UL,
+ (unsigned int)0xebab368aUL,
+ (unsigned int)0xea695cbdUL,
+ (unsigned int)0xfd13b8f0UL,
+ (unsigned int)0xfcd1d2c7UL,
+ (unsigned int)0xfe976c9eUL,
+ (unsigned int)0xff5506a9UL,
+ (unsigned int)0xfa1a102cUL,
+ (unsigned int)0xfbd87a1bUL,
+ (unsigned int)0xf99ec442UL,
+ (unsigned int)0xf85cae75UL,
+ (unsigned int)0xf300e948UL,
+ (unsigned int)0xf2c2837fUL,
+ (unsigned int)0xf0843d26UL,
+ (unsigned int)0xf1465711UL,
+ (unsigned int)0xf4094194UL,
+ (unsigned int)0xf5cb2ba3UL,
+ (unsigned int)0xf78d95faUL,
+ (unsigned int)0xf64fffcdUL,
+ (unsigned int)0xd9785d60UL,
+ (unsigned int)0xd8ba3757UL,
+ (unsigned int)0xdafc890eUL,
+ (unsigned int)0xdb3ee339UL,
+ (unsigned int)0xde71f5bcUL,
+ (unsigned int)0xdfb39f8bUL,
+ (unsigned int)0xddf521d2UL,
+ (unsigned int)0xdc374be5UL,
+ (unsigned int)0xd76b0cd8UL,
+ (unsigned int)0xd6a966efUL,
+ (unsigned int)0xd4efd8b6UL,
+ (unsigned int)0xd52db281UL,
+ (unsigned int)0xd062a404UL,
+ (unsigned int)0xd1a0ce33UL,
+ (unsigned int)0xd3e6706aUL,
+ (unsigned int)0xd2241a5dUL,
+ (unsigned int)0xc55efe10UL,
+ (unsigned int)0xc49c9427UL,
+ (unsigned int)0xc6da2a7eUL,
+ (unsigned int)0xc7184049UL,
+ (unsigned int)0xc25756ccUL,
+ (unsigned int)0xc3953cfbUL,
+ (unsigned int)0xc1d382a2UL,
+ (unsigned int)0xc011e895UL,
+ (unsigned int)0xcb4dafa8UL,
+ (unsigned int)0xca8fc59fUL,
+ (unsigned int)0xc8c97bc6UL,
+ (unsigned int)0xc90b11f1UL,
+ (unsigned int)0xcc440774UL,
+ (unsigned int)0xcd866d43UL,
+ (unsigned int)0xcfc0d31aUL,
+ (unsigned int)0xce02b92dUL,
+ (unsigned int)0x91af9640UL,
+ (unsigned int)0x906dfc77UL,
+ (unsigned int)0x922b422eUL,
+ (unsigned int)0x93e92819UL,
+ (unsigned int)0x96a63e9cUL,
+ (unsigned int)0x976454abUL,
+ (unsigned int)0x9522eaf2UL,
+ (unsigned int)0x94e080c5UL,
+ (unsigned int)0x9fbcc7f8UL,
+ (unsigned int)0x9e7eadcfUL,
+ (unsigned int)0x9c381396UL,
+ (unsigned int)0x9dfa79a1UL,
+ (unsigned int)0x98b56f24UL,
+ (unsigned int)0x99770513UL,
+ (unsigned int)0x9b31bb4aUL,
+ (unsigned int)0x9af3d17dUL,
+ (unsigned int)0x8d893530UL,
+ (unsigned int)0x8c4b5f07UL,
+ (unsigned int)0x8e0de15eUL,
+ (unsigned int)0x8fcf8b69UL,
+ (unsigned int)0x8a809decUL,
+ (unsigned int)0x8b42f7dbUL,
+ (unsigned int)0x89044982UL,
+ (unsigned int)0x88c623b5UL,
+ (unsigned int)0x839a6488UL,
+ (unsigned int)0x82580ebfUL,
+ (unsigned int)0x801eb0e6UL,
+ (unsigned int)0x81dcdad1UL,
+ (unsigned int)0x8493cc54UL,
+ (unsigned int)0x8551a663UL,
+ (unsigned int)0x8717183aUL,
+ (unsigned int)0x86d5720dUL,
+ (unsigned int)0xa9e2d0a0UL,
+ (unsigned int)0xa820ba97UL,
+ (unsigned int)0xaa6604ceUL,
+ (unsigned int)0xaba46ef9UL,
+ (unsigned int)0xaeeb787cUL,
+ (unsigned int)0xaf29124bUL,
+ (unsigned int)0xad6fac12UL,
+ (unsigned int)0xacadc625UL,
+ (unsigned int)0xa7f18118UL,
+ (unsigned int)0xa633eb2fUL,
+ (unsigned int)0xa4755576UL,
+ (unsigned int)0xa5b73f41UL,
+ (unsigned int)0xa0f829c4UL,
+ (unsigned int)0xa13a43f3UL,
+ (unsigned int)0xa37cfdaaUL,
+ (unsigned int)0xa2be979dUL,
+ (unsigned int)0xb5c473d0UL,
+ (unsigned int)0xb40619e7UL,
+ (unsigned int)0xb640a7beUL,
+ (unsigned int)0xb782cd89UL,
+ (unsigned int)0xb2cddb0cUL,
+ (unsigned int)0xb30fb13bUL,
+ (unsigned int)0xb1490f62UL,
+ (unsigned int)0xb08b6555UL,
+ (unsigned int)0xbbd72268UL,
+ (unsigned int)0xba15485fUL,
+ (unsigned int)0xb853f606UL,
+ (unsigned int)0xb9919c31UL,
+ (unsigned int)0xbcde8ab4UL,
+ (unsigned int)0xbd1ce083UL,
+ (unsigned int)0xbf5a5edaUL,
+ (unsigned int)0xbe9834edUL},
+ {(unsigned int)0x00000000UL,
+ (unsigned int)0xb8bc6765UL,
+ (unsigned int)0xaa09c88bUL,
+ (unsigned int)0x12b5afeeUL,
+ (unsigned int)0x8f629757UL,
+ (unsigned int)0x37def032UL,
+ (unsigned int)0x256b5fdcUL,
+ (unsigned int)0x9dd738b9UL,
+ (unsigned int)0xc5b428efUL,
+ (unsigned int)0x7d084f8aUL,
+ (unsigned int)0x6fbde064UL,
+ (unsigned int)0xd7018701UL,
+ (unsigned int)0x4ad6bfb8UL,
+ (unsigned int)0xf26ad8ddUL,
+ (unsigned int)0xe0df7733UL,
+ (unsigned int)0x58631056UL,
+ (unsigned int)0x5019579fUL,
+ (unsigned int)0xe8a530faUL,
+ (unsigned int)0xfa109f14UL,
+ (unsigned int)0x42acf871UL,
+ (unsigned int)0xdf7bc0c8UL,
+ (unsigned int)0x67c7a7adUL,
+ (unsigned int)0x75720843UL,
+ (unsigned int)0xcdce6f26UL,
+ (unsigned int)0x95ad7f70UL,
+ (unsigned int)0x2d111815UL,
+ (unsigned int)0x3fa4b7fbUL,
+ (unsigned int)0x8718d09eUL,
+ (unsigned int)0x1acfe827UL,
+ (unsigned int)0xa2738f42UL,
+ (unsigned int)0xb0c620acUL,
+ (unsigned int)0x087a47c9UL,
+ (unsigned int)0xa032af3eUL,
+ (unsigned int)0x188ec85bUL,
+ (unsigned int)0x0a3b67b5UL,
+ (unsigned int)0xb28700d0UL,
+ (unsigned int)0x2f503869UL,
+ (unsigned int)0x97ec5f0cUL,
+ (unsigned int)0x8559f0e2UL,
+ (unsigned int)0x3de59787UL,
+ (unsigned int)0x658687d1UL,
+ (unsigned int)0xdd3ae0b4UL,
+ (unsigned int)0xcf8f4f5aUL,
+ (unsigned int)0x7733283fUL,
+ (unsigned int)0xeae41086UL,
+ (unsigned int)0x525877e3UL,
+ (unsigned int)0x40edd80dUL,
+ (unsigned int)0xf851bf68UL,
+ (unsigned int)0xf02bf8a1UL,
+ (unsigned int)0x48979fc4UL,
+ (unsigned int)0x5a22302aUL,
+ (unsigned int)0xe29e574fUL,
+ (unsigned int)0x7f496ff6UL,
+ (unsigned int)0xc7f50893UL,
+ (unsigned int)0xd540a77dUL,
+ (unsigned int)0x6dfcc018UL,
+ (unsigned int)0x359fd04eUL,
+ (unsigned int)0x8d23b72bUL,
+ (unsigned int)0x9f9618c5UL,
+ (unsigned int)0x272a7fa0UL,
+ (unsigned int)0xbafd4719UL,
+ (unsigned int)0x0241207cUL,
+ (unsigned int)0x10f48f92UL,
+ (unsigned int)0xa848e8f7UL,
+ (unsigned int)0x9b14583dUL,
+ (unsigned int)0x23a83f58UL,
+ (unsigned int)0x311d90b6UL,
+ (unsigned int)0x89a1f7d3UL,
+ (unsigned int)0x1476cf6aUL,
+ (unsigned int)0xaccaa80fUL,
+ (unsigned int)0xbe7f07e1UL,
+ (unsigned int)0x06c36084UL,
+ (unsigned int)0x5ea070d2UL,
+ (unsigned int)0xe61c17b7UL,
+ (unsigned int)0xf4a9b859UL,
+ (unsigned int)0x4c15df3cUL,
+ (unsigned int)0xd1c2e785UL,
+ (unsigned int)0x697e80e0UL,
+ (unsigned int)0x7bcb2f0eUL,
+ (unsigned int)0xc377486bUL,
+ (unsigned int)0xcb0d0fa2UL,
+ (unsigned int)0x73b168c7UL,
+ (unsigned int)0x6104c729UL,
+ (unsigned int)0xd9b8a04cUL,
+ (unsigned int)0x446f98f5UL,
+ (unsigned int)0xfcd3ff90UL,
+ (unsigned int)0xee66507eUL,
+ (unsigned int)0x56da371bUL,
+ (unsigned int)0x0eb9274dUL,
+ (unsigned int)0xb6054028UL,
+ (unsigned int)0xa4b0efc6UL,
+ (unsigned int)0x1c0c88a3UL,
+ (unsigned int)0x81dbb01aUL,
+ (unsigned int)0x3967d77fUL,
+ (unsigned int)0x2bd27891UL,
+ (unsigned int)0x936e1ff4UL,
+ (unsigned int)0x3b26f703UL,
+ (unsigned int)0x839a9066UL,
+ (unsigned int)0x912f3f88UL,
+ (unsigned int)0x299358edUL,
+ (unsigned int)0xb4446054UL,
+ (unsigned int)0x0cf80731UL,
+ (unsigned int)0x1e4da8dfUL,
+ (unsigned int)0xa6f1cfbaUL,
+ (unsigned int)0xfe92dfecUL,
+ (unsigned int)0x462eb889UL,
+ (unsigned int)0x549b1767UL,
+ (unsigned int)0xec277002UL,
+ (unsigned int)0x71f048bbUL,
+ (unsigned int)0xc94c2fdeUL,
+ (unsigned int)0xdbf98030UL,
+ (unsigned int)0x6345e755UL,
+ (unsigned int)0x6b3fa09cUL,
+ (unsigned int)0xd383c7f9UL,
+ (unsigned int)0xc1366817UL,
+ (unsigned int)0x798a0f72UL,
+ (unsigned int)0xe45d37cbUL,
+ (unsigned int)0x5ce150aeUL,
+ (unsigned int)0x4e54ff40UL,
+ (unsigned int)0xf6e89825UL,
+ (unsigned int)0xae8b8873UL,
+ (unsigned int)0x1637ef16UL,
+ (unsigned int)0x048240f8UL,
+ (unsigned int)0xbc3e279dUL,
+ (unsigned int)0x21e91f24UL,
+ (unsigned int)0x99557841UL,
+ (unsigned int)0x8be0d7afUL,
+ (unsigned int)0x335cb0caUL,
+ (unsigned int)0xed59b63bUL,
+ (unsigned int)0x55e5d15eUL,
+ (unsigned int)0x47507eb0UL,
+ (unsigned int)0xffec19d5UL,
+ (unsigned int)0x623b216cUL,
+ (unsigned int)0xda874609UL,
+ (unsigned int)0xc832e9e7UL,
+ (unsigned int)0x708e8e82UL,
+ (unsigned int)0x28ed9ed4UL,
+ (unsigned int)0x9051f9b1UL,
+ (unsigned int)0x82e4565fUL,
+ (unsigned int)0x3a58313aUL,
+ (unsigned int)0xa78f0983UL,
+ (unsigned int)0x1f336ee6UL,
+ (unsigned int)0x0d86c108UL,
+ (unsigned int)0xb53aa66dUL,
+ (unsigned int)0xbd40e1a4UL,
+ (unsigned int)0x05fc86c1UL,
+ (unsigned int)0x1749292fUL,
+ (unsigned int)0xaff54e4aUL,
+ (unsigned int)0x322276f3UL,
+ (unsigned int)0x8a9e1196UL,
+ (unsigned int)0x982bbe78UL,
+ (unsigned int)0x2097d91dUL,
+ (unsigned int)0x78f4c94bUL,
+ (unsigned int)0xc048ae2eUL,
+ (unsigned int)0xd2fd01c0UL,
+ (unsigned int)0x6a4166a5UL,
+ (unsigned int)0xf7965e1cUL,
+ (unsigned int)0x4f2a3979UL,
+ (unsigned int)0x5d9f9697UL,
+ (unsigned int)0xe523f1f2UL,
+ (unsigned int)0x4d6b1905UL,
+ (unsigned int)0xf5d77e60UL,
+ (unsigned int)0xe762d18eUL,
+ (unsigned int)0x5fdeb6ebUL,
+ (unsigned int)0xc2098e52UL,
+ (unsigned int)0x7ab5e937UL,
+ (unsigned int)0x680046d9UL,
+ (unsigned int)0xd0bc21bcUL,
+ (unsigned int)0x88df31eaUL,
+ (unsigned int)0x3063568fUL,
+ (unsigned int)0x22d6f961UL,
+ (unsigned int)0x9a6a9e04UL,
+ (unsigned int)0x07bda6bdUL,
+ (unsigned int)0xbf01c1d8UL,
+ (unsigned int)0xadb46e36UL,
+ (unsigned int)0x15080953UL,
+ (unsigned int)0x1d724e9aUL,
+ (unsigned int)0xa5ce29ffUL,
+ (unsigned int)0xb77b8611UL,
+ (unsigned int)0x0fc7e174UL,
+ (unsigned int)0x9210d9cdUL,
+ (unsigned int)0x2aacbea8UL,
+ (unsigned int)0x38191146UL,
+ (unsigned int)0x80a57623UL,
+ (unsigned int)0xd8c66675UL,
+ (unsigned int)0x607a0110UL,
+ (unsigned int)0x72cfaefeUL,
+ (unsigned int)0xca73c99bUL,
+ (unsigned int)0x57a4f122UL,
+ (unsigned int)0xef189647UL,
+ (unsigned int)0xfdad39a9UL,
+ (unsigned int)0x45115eccUL,
+ (unsigned int)0x764dee06UL,
+ (unsigned int)0xcef18963UL,
+ (unsigned int)0xdc44268dUL,
+ (unsigned int)0x64f841e8UL,
+ (unsigned int)0xf92f7951UL,
+ (unsigned int)0x41931e34UL,
+ (unsigned int)0x5326b1daUL,
+ (unsigned int)0xeb9ad6bfUL,
+ (unsigned int)0xb3f9c6e9UL,
+ (unsigned int)0x0b45a18cUL,
+ (unsigned int)0x19f00e62UL,
+ (unsigned int)0xa14c6907UL,
+ (unsigned int)0x3c9b51beUL,
+ (unsigned int)0x842736dbUL,
+ (unsigned int)0x96929935UL,
+ (unsigned int)0x2e2efe50UL,
+ (unsigned int)0x2654b999UL,
+ (unsigned int)0x9ee8defcUL,
+ (unsigned int)0x8c5d7112UL,
+ (unsigned int)0x34e11677UL,
+ (unsigned int)0xa9362eceUL,
+ (unsigned int)0x118a49abUL,
+ (unsigned int)0x033fe645UL,
+ (unsigned int)0xbb838120UL,
+ (unsigned int)0xe3e09176UL,
+ (unsigned int)0x5b5cf613UL,
+ (unsigned int)0x49e959fdUL,
+ (unsigned int)0xf1553e98UL,
+ (unsigned int)0x6c820621UL,
+ (unsigned int)0xd43e6144UL,
+ (unsigned int)0xc68bceaaUL,
+ (unsigned int)0x7e37a9cfUL,
+ (unsigned int)0xd67f4138UL,
+ (unsigned int)0x6ec3265dUL,
+ (unsigned int)0x7c7689b3UL,
+ (unsigned int)0xc4caeed6UL,
+ (unsigned int)0x591dd66fUL,
+ (unsigned int)0xe1a1b10aUL,
+ (unsigned int)0xf3141ee4UL,
+ (unsigned int)0x4ba87981UL,
+ (unsigned int)0x13cb69d7UL,
+ (unsigned int)0xab770eb2UL,
+ (unsigned int)0xb9c2a15cUL,
+ (unsigned int)0x017ec639UL,
+ (unsigned int)0x9ca9fe80UL,
+ (unsigned int)0x241599e5UL,
+ (unsigned int)0x36a0360bUL,
+ (unsigned int)0x8e1c516eUL,
+ (unsigned int)0x866616a7UL,
+ (unsigned int)0x3eda71c2UL,
+ (unsigned int)0x2c6fde2cUL,
+ (unsigned int)0x94d3b949UL,
+ (unsigned int)0x090481f0UL,
+ (unsigned int)0xb1b8e695UL,
+ (unsigned int)0xa30d497bUL,
+ (unsigned int)0x1bb12e1eUL,
+ (unsigned int)0x43d23e48UL,
+ (unsigned int)0xfb6e592dUL,
+ (unsigned int)0xe9dbf6c3UL,
+ (unsigned int)0x516791a6UL,
+ (unsigned int)0xccb0a91fUL,
+ (unsigned int)0x740cce7aUL,
+ (unsigned int)0x66b96194UL,
+ (unsigned int)0xde0506f1UL},
+ {(unsigned int)0x00000000UL,
+ (unsigned int)0x96300777UL,
+ (unsigned int)0x2c610eeeUL,
+ (unsigned int)0xba510999UL,
+ (unsigned int)0x19c46d07UL,
+ (unsigned int)0x8ff46a70UL,
+ (unsigned int)0x35a563e9UL,
+ (unsigned int)0xa395649eUL,
+ (unsigned int)0x3288db0eUL,
+ (unsigned int)0xa4b8dc79UL,
+ (unsigned int)0x1ee9d5e0UL,
+ (unsigned int)0x88d9d297UL,
+ (unsigned int)0x2b4cb609UL,
+ (unsigned int)0xbd7cb17eUL,
+ (unsigned int)0x072db8e7UL,
+ (unsigned int)0x911dbf90UL,
+ (unsigned int)0x6410b71dUL,
+ (unsigned int)0xf220b06aUL,
+ (unsigned int)0x4871b9f3UL,
+ (unsigned int)0xde41be84UL,
+ (unsigned int)0x7dd4da1aUL,
+ (unsigned int)0xebe4dd6dUL,
+ (unsigned int)0x51b5d4f4UL,
+ (unsigned int)0xc785d383UL,
+ (unsigned int)0x56986c13UL,
+ (unsigned int)0xc0a86b64UL,
+ (unsigned int)0x7af962fdUL,
+ (unsigned int)0xecc9658aUL,
+ (unsigned int)0x4f5c0114UL,
+ (unsigned int)0xd96c0663UL,
+ (unsigned int)0x633d0ffaUL,
+ (unsigned int)0xf50d088dUL,
+ (unsigned int)0xc8206e3bUL,
+ (unsigned int)0x5e10694cUL,
+ (unsigned int)0xe44160d5UL,
+ (unsigned int)0x727167a2UL,
+ (unsigned int)0xd1e4033cUL,
+ (unsigned int)0x47d4044bUL,
+ (unsigned int)0xfd850dd2UL,
+ (unsigned int)0x6bb50aa5UL,
+ (unsigned int)0xfaa8b535UL,
+ (unsigned int)0x6c98b242UL,
+ (unsigned int)0xd6c9bbdbUL,
+ (unsigned int)0x40f9bcacUL,
+ (unsigned int)0xe36cd832UL,
+ (unsigned int)0x755cdf45UL,
+ (unsigned int)0xcf0dd6dcUL,
+ (unsigned int)0x593dd1abUL,
+ (unsigned int)0xac30d926UL,
+ (unsigned int)0x3a00de51UL,
+ (unsigned int)0x8051d7c8UL,
+ (unsigned int)0x1661d0bfUL,
+ (unsigned int)0xb5f4b421UL,
+ (unsigned int)0x23c4b356UL,
+ (unsigned int)0x9995bacfUL,
+ (unsigned int)0x0fa5bdb8UL,
+ (unsigned int)0x9eb80228UL,
+ (unsigned int)0x0888055fUL,
+ (unsigned int)0xb2d90cc6UL,
+ (unsigned int)0x24e90bb1UL,
+ (unsigned int)0x877c6f2fUL,
+ (unsigned int)0x114c6858UL,
+ (unsigned int)0xab1d61c1UL,
+ (unsigned int)0x3d2d66b6UL,
+ (unsigned int)0x9041dc76UL,
+ (unsigned int)0x0671db01UL,
+ (unsigned int)0xbc20d298UL,
+ (unsigned int)0x2a10d5efUL,
+ (unsigned int)0x8985b171UL,
+ (unsigned int)0x1fb5b606UL,
+ (unsigned int)0xa5e4bf9fUL,
+ (unsigned int)0x33d4b8e8UL,
+ (unsigned int)0xa2c90778UL,
+ (unsigned int)0x34f9000fUL,
+ (unsigned int)0x8ea80996UL,
+ (unsigned int)0x18980ee1UL,
+ (unsigned int)0xbb0d6a7fUL,
+ (unsigned int)0x2d3d6d08UL,
+ (unsigned int)0x976c6491UL,
+ (unsigned int)0x015c63e6UL,
+ (unsigned int)0xf4516b6bUL,
+ (unsigned int)0x62616c1cUL,
+ (unsigned int)0xd8306585UL,
+ (unsigned int)0x4e0062f2UL,
+ (unsigned int)0xed95066cUL,
+ (unsigned int)0x7ba5011bUL,
+ (unsigned int)0xc1f40882UL,
+ (unsigned int)0x57c40ff5UL,
+ (unsigned int)0xc6d9b065UL,
+ (unsigned int)0x50e9b712UL,
+ (unsigned int)0xeab8be8bUL,
+ (unsigned int)0x7c88b9fcUL,
+ (unsigned int)0xdf1ddd62UL,
+ (unsigned int)0x492dda15UL,
+ (unsigned int)0xf37cd38cUL,
+ (unsigned int)0x654cd4fbUL,
+ (unsigned int)0x5861b24dUL,
+ (unsigned int)0xce51b53aUL,
+ (unsigned int)0x7400bca3UL,
+ (unsigned int)0xe230bbd4UL,
+ (unsigned int)0x41a5df4aUL,
+ (unsigned int)0xd795d83dUL,
+ (unsigned int)0x6dc4d1a4UL,
+ (unsigned int)0xfbf4d6d3UL,
+ (unsigned int)0x6ae96943UL,
+ (unsigned int)0xfcd96e34UL,
+ (unsigned int)0x468867adUL,
+ (unsigned int)0xd0b860daUL,
+ (unsigned int)0x732d0444UL,
+ (unsigned int)0xe51d0333UL,
+ (unsigned int)0x5f4c0aaaUL,
+ (unsigned int)0xc97c0dddUL,
+ (unsigned int)0x3c710550UL,
+ (unsigned int)0xaa410227UL,
+ (unsigned int)0x10100bbeUL,
+ (unsigned int)0x86200cc9UL,
+ (unsigned int)0x25b56857UL,
+ (unsigned int)0xb3856f20UL,
+ (unsigned int)0x09d466b9UL,
+ (unsigned int)0x9fe461ceUL,
+ (unsigned int)0x0ef9de5eUL,
+ (unsigned int)0x98c9d929UL,
+ (unsigned int)0x2298d0b0UL,
+ (unsigned int)0xb4a8d7c7UL,
+ (unsigned int)0x173db359UL,
+ (unsigned int)0x810db42eUL,
+ (unsigned int)0x3b5cbdb7UL,
+ (unsigned int)0xad6cbac0UL,
+ (unsigned int)0x2083b8edUL,
+ (unsigned int)0xb6b3bf9aUL,
+ (unsigned int)0x0ce2b603UL,
+ (unsigned int)0x9ad2b174UL,
+ (unsigned int)0x3947d5eaUL,
+ (unsigned int)0xaf77d29dUL,
+ (unsigned int)0x1526db04UL,
+ (unsigned int)0x8316dc73UL,
+ (unsigned int)0x120b63e3UL,
+ (unsigned int)0x843b6494UL,
+ (unsigned int)0x3e6a6d0dUL,
+ (unsigned int)0xa85a6a7aUL,
+ (unsigned int)0x0bcf0ee4UL,
+ (unsigned int)0x9dff0993UL,
+ (unsigned int)0x27ae000aUL,
+ (unsigned int)0xb19e077dUL,
+ (unsigned int)0x44930ff0UL,
+ (unsigned int)0xd2a30887UL,
+ (unsigned int)0x68f2011eUL,
+ (unsigned int)0xfec20669UL,
+ (unsigned int)0x5d5762f7UL,
+ (unsigned int)0xcb676580UL,
+ (unsigned int)0x71366c19UL,
+ (unsigned int)0xe7066b6eUL,
+ (unsigned int)0x761bd4feUL,
+ (unsigned int)0xe02bd389UL,
+ (unsigned int)0x5a7ada10UL,
+ (unsigned int)0xcc4add67UL,
+ (unsigned int)0x6fdfb9f9UL,
+ (unsigned int)0xf9efbe8eUL,
+ (unsigned int)0x43beb717UL,
+ (unsigned int)0xd58eb060UL,
+ (unsigned int)0xe8a3d6d6UL,
+ (unsigned int)0x7e93d1a1UL,
+ (unsigned int)0xc4c2d838UL,
+ (unsigned int)0x52f2df4fUL,
+ (unsigned int)0xf167bbd1UL,
+ (unsigned int)0x6757bca6UL,
+ (unsigned int)0xdd06b53fUL,
+ (unsigned int)0x4b36b248UL,
+ (unsigned int)0xda2b0dd8UL,
+ (unsigned int)0x4c1b0aafUL,
+ (unsigned int)0xf64a0336UL,
+ (unsigned int)0x607a0441UL,
+ (unsigned int)0xc3ef60dfUL,
+ (unsigned int)0x55df67a8UL,
+ (unsigned int)0xef8e6e31UL,
+ (unsigned int)0x79be6946UL,
+ (unsigned int)0x8cb361cbUL,
+ (unsigned int)0x1a8366bcUL,
+ (unsigned int)0xa0d26f25UL,
+ (unsigned int)0x36e26852UL,
+ (unsigned int)0x95770cccUL,
+ (unsigned int)0x03470bbbUL,
+ (unsigned int)0xb9160222UL,
+ (unsigned int)0x2f260555UL,
+ (unsigned int)0xbe3bbac5UL,
+ (unsigned int)0x280bbdb2UL,
+ (unsigned int)0x925ab42bUL,
+ (unsigned int)0x046ab35cUL,
+ (unsigned int)0xa7ffd7c2UL,
+ (unsigned int)0x31cfd0b5UL,
+ (unsigned int)0x8b9ed92cUL,
+ (unsigned int)0x1daede5bUL,
+ (unsigned int)0xb0c2649bUL,
+ (unsigned int)0x26f263ecUL,
+ (unsigned int)0x9ca36a75UL,
+ (unsigned int)0x0a936d02UL,
+ (unsigned int)0xa906099cUL,
+ (unsigned int)0x3f360eebUL,
+ (unsigned int)0x85670772UL,
+ (unsigned int)0x13570005UL,
+ (unsigned int)0x824abf95UL,
+ (unsigned int)0x147ab8e2UL,
+ (unsigned int)0xae2bb17bUL,
+ (unsigned int)0x381bb60cUL,
+ (unsigned int)0x9b8ed292UL,
+ (unsigned int)0x0dbed5e5UL,
+ (unsigned int)0xb7efdc7cUL,
+ (unsigned int)0x21dfdb0bUL,
+ (unsigned int)0xd4d2d386UL,
+ (unsigned int)0x42e2d4f1UL,
+ (unsigned int)0xf8b3dd68UL,
+ (unsigned int)0x6e83da1fUL,
+ (unsigned int)0xcd16be81UL,
+ (unsigned int)0x5b26b9f6UL,
+ (unsigned int)0xe177b06fUL,
+ (unsigned int)0x7747b718UL,
+ (unsigned int)0xe65a0888UL,
+ (unsigned int)0x706a0fffUL,
+ (unsigned int)0xca3b0666UL,
+ (unsigned int)0x5c0b0111UL,
+ (unsigned int)0xff9e658fUL,
+ (unsigned int)0x69ae62f8UL,
+ (unsigned int)0xd3ff6b61UL,
+ (unsigned int)0x45cf6c16UL,
+ (unsigned int)0x78e20aa0UL,
+ (unsigned int)0xeed20dd7UL,
+ (unsigned int)0x5483044eUL,
+ (unsigned int)0xc2b30339UL,
+ (unsigned int)0x612667a7UL,
+ (unsigned int)0xf71660d0UL,
+ (unsigned int)0x4d476949UL,
+ (unsigned int)0xdb776e3eUL,
+ (unsigned int)0x4a6ad1aeUL,
+ (unsigned int)0xdc5ad6d9UL,
+ (unsigned int)0x660bdf40UL,
+ (unsigned int)0xf03bd837UL,
+ (unsigned int)0x53aebca9UL,
+ (unsigned int)0xc59ebbdeUL,
+ (unsigned int)0x7fcfb247UL,
+ (unsigned int)0xe9ffb530UL,
+ (unsigned int)0x1cf2bdbdUL,
+ (unsigned int)0x8ac2bacaUL,
+ (unsigned int)0x3093b353UL,
+ (unsigned int)0xa6a3b424UL,
+ (unsigned int)0x0536d0baUL,
+ (unsigned int)0x9306d7cdUL,
+ (unsigned int)0x2957de54UL,
+ (unsigned int)0xbf67d923UL,
+ (unsigned int)0x2e7a66b3UL,
+ (unsigned int)0xb84a61c4UL,
+ (unsigned int)0x021b685dUL,
+ (unsigned int)0x942b6f2aUL,
+ (unsigned int)0x37be0bb4UL,
+ (unsigned int)0xa18e0cc3UL,
+ (unsigned int)0x1bdf055aUL,
+ (unsigned int)0x8def022dUL},
+ {(unsigned int)0x00000000UL,
+ (unsigned int)0x41311b19UL,
+ (unsigned int)0x82623632UL,
+ (unsigned int)0xc3532d2bUL,
+ (unsigned int)0x04c56c64UL,
+ (unsigned int)0x45f4777dUL,
+ (unsigned int)0x86a75a56UL,
+ (unsigned int)0xc796414fUL,
+ (unsigned int)0x088ad9c8UL,
+ (unsigned int)0x49bbc2d1UL,
+ (unsigned int)0x8ae8effaUL,
+ (unsigned int)0xcbd9f4e3UL,
+ (unsigned int)0x0c4fb5acUL,
+ (unsigned int)0x4d7eaeb5UL,
+ (unsigned int)0x8e2d839eUL,
+ (unsigned int)0xcf1c9887UL,
+ (unsigned int)0x5112c24aUL,
+ (unsigned int)0x1023d953UL,
+ (unsigned int)0xd370f478UL,
+ (unsigned int)0x9241ef61UL,
+ (unsigned int)0x55d7ae2eUL,
+ (unsigned int)0x14e6b537UL,
+ (unsigned int)0xd7b5981cUL,
+ (unsigned int)0x96848305UL,
+ (unsigned int)0x59981b82UL,
+ (unsigned int)0x18a9009bUL,
+ (unsigned int)0xdbfa2db0UL,
+ (unsigned int)0x9acb36a9UL,
+ (unsigned int)0x5d5d77e6UL,
+ (unsigned int)0x1c6c6cffUL,
+ (unsigned int)0xdf3f41d4UL,
+ (unsigned int)0x9e0e5acdUL,
+ (unsigned int)0xa2248495UL,
+ (unsigned int)0xe3159f8cUL,
+ (unsigned int)0x2046b2a7UL,
+ (unsigned int)0x6177a9beUL,
+ (unsigned int)0xa6e1e8f1UL,
+ (unsigned int)0xe7d0f3e8UL,
+ (unsigned int)0x2483dec3UL,
+ (unsigned int)0x65b2c5daUL,
+ (unsigned int)0xaaae5d5dUL,
+ (unsigned int)0xeb9f4644UL,
+ (unsigned int)0x28cc6b6fUL,
+ (unsigned int)0x69fd7076UL,
+ (unsigned int)0xae6b3139UL,
+ (unsigned int)0xef5a2a20UL,
+ (unsigned int)0x2c09070bUL,
+ (unsigned int)0x6d381c12UL,
+ (unsigned int)0xf33646dfUL,
+ (unsigned int)0xb2075dc6UL,
+ (unsigned int)0x715470edUL,
+ (unsigned int)0x30656bf4UL,
+ (unsigned int)0xf7f32abbUL,
+ (unsigned int)0xb6c231a2UL,
+ (unsigned int)0x75911c89UL,
+ (unsigned int)0x34a00790UL,
+ (unsigned int)0xfbbc9f17UL,
+ (unsigned int)0xba8d840eUL,
+ (unsigned int)0x79dea925UL,
+ (unsigned int)0x38efb23cUL,
+ (unsigned int)0xff79f373UL,
+ (unsigned int)0xbe48e86aUL,
+ (unsigned int)0x7d1bc541UL,
+ (unsigned int)0x3c2ade58UL,
+ (unsigned int)0x054f79f0UL,
+ (unsigned int)0x447e62e9UL,
+ (unsigned int)0x872d4fc2UL,
+ (unsigned int)0xc61c54dbUL,
+ (unsigned int)0x018a1594UL,
+ (unsigned int)0x40bb0e8dUL,
+ (unsigned int)0x83e823a6UL,
+ (unsigned int)0xc2d938bfUL,
+ (unsigned int)0x0dc5a038UL,
+ (unsigned int)0x4cf4bb21UL,
+ (unsigned int)0x8fa7960aUL,
+ (unsigned int)0xce968d13UL,
+ (unsigned int)0x0900cc5cUL,
+ (unsigned int)0x4831d745UL,
+ (unsigned int)0x8b62fa6eUL,
+ (unsigned int)0xca53e177UL,
+ (unsigned int)0x545dbbbaUL,
+ (unsigned int)0x156ca0a3UL,
+ (unsigned int)0xd63f8d88UL,
+ (unsigned int)0x970e9691UL,
+ (unsigned int)0x5098d7deUL,
+ (unsigned int)0x11a9ccc7UL,
+ (unsigned int)0xd2fae1ecUL,
+ (unsigned int)0x93cbfaf5UL,
+ (unsigned int)0x5cd76272UL,
+ (unsigned int)0x1de6796bUL,
+ (unsigned int)0xdeb55440UL,
+ (unsigned int)0x9f844f59UL,
+ (unsigned int)0x58120e16UL,
+ (unsigned int)0x1923150fUL,
+ (unsigned int)0xda703824UL,
+ (unsigned int)0x9b41233dUL,
+ (unsigned int)0xa76bfd65UL,
+ (unsigned int)0xe65ae67cUL,
+ (unsigned int)0x2509cb57UL,
+ (unsigned int)0x6438d04eUL,
+ (unsigned int)0xa3ae9101UL,
+ (unsigned int)0xe29f8a18UL,
+ (unsigned int)0x21cca733UL,
+ (unsigned int)0x60fdbc2aUL,
+ (unsigned int)0xafe124adUL,
+ (unsigned int)0xeed03fb4UL,
+ (unsigned int)0x2d83129fUL,
+ (unsigned int)0x6cb20986UL,
+ (unsigned int)0xab2448c9UL,
+ (unsigned int)0xea1553d0UL,
+ (unsigned int)0x29467efbUL,
+ (unsigned int)0x687765e2UL,
+ (unsigned int)0xf6793f2fUL,
+ (unsigned int)0xb7482436UL,
+ (unsigned int)0x741b091dUL,
+ (unsigned int)0x352a1204UL,
+ (unsigned int)0xf2bc534bUL,
+ (unsigned int)0xb38d4852UL,
+ (unsigned int)0x70de6579UL,
+ (unsigned int)0x31ef7e60UL,
+ (unsigned int)0xfef3e6e7UL,
+ (unsigned int)0xbfc2fdfeUL,
+ (unsigned int)0x7c91d0d5UL,
+ (unsigned int)0x3da0cbccUL,
+ (unsigned int)0xfa368a83UL,
+ (unsigned int)0xbb07919aUL,
+ (unsigned int)0x7854bcb1UL,
+ (unsigned int)0x3965a7a8UL,
+ (unsigned int)0x4b98833bUL,
+ (unsigned int)0x0aa99822UL,
+ (unsigned int)0xc9fab509UL,
+ (unsigned int)0x88cbae10UL,
+ (unsigned int)0x4f5def5fUL,
+ (unsigned int)0x0e6cf446UL,
+ (unsigned int)0xcd3fd96dUL,
+ (unsigned int)0x8c0ec274UL,
+ (unsigned int)0x43125af3UL,
+ (unsigned int)0x022341eaUL,
+ (unsigned int)0xc1706cc1UL,
+ (unsigned int)0x804177d8UL,
+ (unsigned int)0x47d73697UL,
+ (unsigned int)0x06e62d8eUL,
+ (unsigned int)0xc5b500a5UL,
+ (unsigned int)0x84841bbcUL,
+ (unsigned int)0x1a8a4171UL,
+ (unsigned int)0x5bbb5a68UL,
+ (unsigned int)0x98e87743UL,
+ (unsigned int)0xd9d96c5aUL,
+ (unsigned int)0x1e4f2d15UL,
+ (unsigned int)0x5f7e360cUL,
+ (unsigned int)0x9c2d1b27UL,
+ (unsigned int)0xdd1c003eUL,
+ (unsigned int)0x120098b9UL,
+ (unsigned int)0x533183a0UL,
+ (unsigned int)0x9062ae8bUL,
+ (unsigned int)0xd153b592UL,
+ (unsigned int)0x16c5f4ddUL,
+ (unsigned int)0x57f4efc4UL,
+ (unsigned int)0x94a7c2efUL,
+ (unsigned int)0xd596d9f6UL,
+ (unsigned int)0xe9bc07aeUL,
+ (unsigned int)0xa88d1cb7UL,
+ (unsigned int)0x6bde319cUL,
+ (unsigned int)0x2aef2a85UL,
+ (unsigned int)0xed796bcaUL,
+ (unsigned int)0xac4870d3UL,
+ (unsigned int)0x6f1b5df8UL,
+ (unsigned int)0x2e2a46e1UL,
+ (unsigned int)0xe136de66UL,
+ (unsigned int)0xa007c57fUL,
+ (unsigned int)0x6354e854UL,
+ (unsigned int)0x2265f34dUL,
+ (unsigned int)0xe5f3b202UL,
+ (unsigned int)0xa4c2a91bUL,
+ (unsigned int)0x67918430UL,
+ (unsigned int)0x26a09f29UL,
+ (unsigned int)0xb8aec5e4UL,
+ (unsigned int)0xf99fdefdUL,
+ (unsigned int)0x3accf3d6UL,
+ (unsigned int)0x7bfde8cfUL,
+ (unsigned int)0xbc6ba980UL,
+ (unsigned int)0xfd5ab299UL,
+ (unsigned int)0x3e099fb2UL,
+ (unsigned int)0x7f3884abUL,
+ (unsigned int)0xb0241c2cUL,
+ (unsigned int)0xf1150735UL,
+ (unsigned int)0x32462a1eUL,
+ (unsigned int)0x73773107UL,
+ (unsigned int)0xb4e17048UL,
+ (unsigned int)0xf5d06b51UL,
+ (unsigned int)0x3683467aUL,
+ (unsigned int)0x77b25d63UL,
+ (unsigned int)0x4ed7facbUL,
+ (unsigned int)0x0fe6e1d2UL,
+ (unsigned int)0xccb5ccf9UL,
+ (unsigned int)0x8d84d7e0UL,
+ (unsigned int)0x4a1296afUL,
+ (unsigned int)0x0b238db6UL,
+ (unsigned int)0xc870a09dUL,
+ (unsigned int)0x8941bb84UL,
+ (unsigned int)0x465d2303UL,
+ (unsigned int)0x076c381aUL,
+ (unsigned int)0xc43f1531UL,
+ (unsigned int)0x850e0e28UL,
+ (unsigned int)0x42984f67UL,
+ (unsigned int)0x03a9547eUL,
+ (unsigned int)0xc0fa7955UL,
+ (unsigned int)0x81cb624cUL,
+ (unsigned int)0x1fc53881UL,
+ (unsigned int)0x5ef42398UL,
+ (unsigned int)0x9da70eb3UL,
+ (unsigned int)0xdc9615aaUL,
+ (unsigned int)0x1b0054e5UL,
+ (unsigned int)0x5a314ffcUL,
+ (unsigned int)0x996262d7UL,
+ (unsigned int)0xd85379ceUL,
+ (unsigned int)0x174fe149UL,
+ (unsigned int)0x567efa50UL,
+ (unsigned int)0x952dd77bUL,
+ (unsigned int)0xd41ccc62UL,
+ (unsigned int)0x138a8d2dUL,
+ (unsigned int)0x52bb9634UL,
+ (unsigned int)0x91e8bb1fUL,
+ (unsigned int)0xd0d9a006UL,
+ (unsigned int)0xecf37e5eUL,
+ (unsigned int)0xadc26547UL,
+ (unsigned int)0x6e91486cUL,
+ (unsigned int)0x2fa05375UL,
+ (unsigned int)0xe836123aUL,
+ (unsigned int)0xa9070923UL,
+ (unsigned int)0x6a542408UL,
+ (unsigned int)0x2b653f11UL,
+ (unsigned int)0xe479a796UL,
+ (unsigned int)0xa548bc8fUL,
+ (unsigned int)0x661b91a4UL,
+ (unsigned int)0x272a8abdUL,
+ (unsigned int)0xe0bccbf2UL,
+ (unsigned int)0xa18dd0ebUL,
+ (unsigned int)0x62defdc0UL,
+ (unsigned int)0x23efe6d9UL,
+ (unsigned int)0xbde1bc14UL,
+ (unsigned int)0xfcd0a70dUL,
+ (unsigned int)0x3f838a26UL,
+ (unsigned int)0x7eb2913fUL,
+ (unsigned int)0xb924d070UL,
+ (unsigned int)0xf815cb69UL,
+ (unsigned int)0x3b46e642UL,
+ (unsigned int)0x7a77fd5bUL,
+ (unsigned int)0xb56b65dcUL,
+ (unsigned int)0xf45a7ec5UL,
+ (unsigned int)0x370953eeUL,
+ (unsigned int)0x763848f7UL,
+ (unsigned int)0xb1ae09b8UL,
+ (unsigned int)0xf09f12a1UL,
+ (unsigned int)0x33cc3f8aUL,
+ (unsigned int)0x72fd2493UL},
+ {(unsigned int)0x00000000UL,
+ (unsigned int)0x376ac201UL,
+ (unsigned int)0x6ed48403UL,
+ (unsigned int)0x59be4602UL,
+ (unsigned int)0xdca80907UL,
+ (unsigned int)0xebc2cb06UL,
+ (unsigned int)0xb27c8d04UL,
+ (unsigned int)0x85164f05UL,
+ (unsigned int)0xb851130eUL,
+ (unsigned int)0x8f3bd10fUL,
+ (unsigned int)0xd685970dUL,
+ (unsigned int)0xe1ef550cUL,
+ (unsigned int)0x64f91a09UL,
+ (unsigned int)0x5393d808UL,
+ (unsigned int)0x0a2d9e0aUL,
+ (unsigned int)0x3d475c0bUL,
+ (unsigned int)0x70a3261cUL,
+ (unsigned int)0x47c9e41dUL,
+ (unsigned int)0x1e77a21fUL,
+ (unsigned int)0x291d601eUL,
+ (unsigned int)0xac0b2f1bUL,
+ (unsigned int)0x9b61ed1aUL,
+ (unsigned int)0xc2dfab18UL,
+ (unsigned int)0xf5b56919UL,
+ (unsigned int)0xc8f23512UL,
+ (unsigned int)0xff98f713UL,
+ (unsigned int)0xa626b111UL,
+ (unsigned int)0x914c7310UL,
+ (unsigned int)0x145a3c15UL,
+ (unsigned int)0x2330fe14UL,
+ (unsigned int)0x7a8eb816UL,
+ (unsigned int)0x4de47a17UL,
+ (unsigned int)0xe0464d38UL,
+ (unsigned int)0xd72c8f39UL,
+ (unsigned int)0x8e92c93bUL,
+ (unsigned int)0xb9f80b3aUL,
+ (unsigned int)0x3cee443fUL,
+ (unsigned int)0x0b84863eUL,
+ (unsigned int)0x523ac03cUL,
+ (unsigned int)0x6550023dUL,
+ (unsigned int)0x58175e36UL,
+ (unsigned int)0x6f7d9c37UL,
+ (unsigned int)0x36c3da35UL,
+ (unsigned int)0x01a91834UL,
+ (unsigned int)0x84bf5731UL,
+ (unsigned int)0xb3d59530UL,
+ (unsigned int)0xea6bd332UL,
+ (unsigned int)0xdd011133UL,
+ (unsigned int)0x90e56b24UL,
+ (unsigned int)0xa78fa925UL,
+ (unsigned int)0xfe31ef27UL,
+ (unsigned int)0xc95b2d26UL,
+ (unsigned int)0x4c4d6223UL,
+ (unsigned int)0x7b27a022UL,
+ (unsigned int)0x2299e620UL,
+ (unsigned int)0x15f32421UL,
+ (unsigned int)0x28b4782aUL,
+ (unsigned int)0x1fdeba2bUL,
+ (unsigned int)0x4660fc29UL,
+ (unsigned int)0x710a3e28UL,
+ (unsigned int)0xf41c712dUL,
+ (unsigned int)0xc376b32cUL,
+ (unsigned int)0x9ac8f52eUL,
+ (unsigned int)0xada2372fUL,
+ (unsigned int)0xc08d9a70UL,
+ (unsigned int)0xf7e75871UL,
+ (unsigned int)0xae591e73UL,
+ (unsigned int)0x9933dc72UL,
+ (unsigned int)0x1c259377UL,
+ (unsigned int)0x2b4f5176UL,
+ (unsigned int)0x72f11774UL,
+ (unsigned int)0x459bd575UL,
+ (unsigned int)0x78dc897eUL,
+ (unsigned int)0x4fb64b7fUL,
+ (unsigned int)0x16080d7dUL,
+ (unsigned int)0x2162cf7cUL,
+ (unsigned int)0xa4748079UL,
+ (unsigned int)0x931e4278UL,
+ (unsigned int)0xcaa0047aUL,
+ (unsigned int)0xfdcac67bUL,
+ (unsigned int)0xb02ebc6cUL,
+ (unsigned int)0x87447e6dUL,
+ (unsigned int)0xdefa386fUL,
+ (unsigned int)0xe990fa6eUL,
+ (unsigned int)0x6c86b56bUL,
+ (unsigned int)0x5bec776aUL,
+ (unsigned int)0x02523168UL,
+ (unsigned int)0x3538f369UL,
+ (unsigned int)0x087faf62UL,
+ (unsigned int)0x3f156d63UL,
+ (unsigned int)0x66ab2b61UL,
+ (unsigned int)0x51c1e960UL,
+ (unsigned int)0xd4d7a665UL,
+ (unsigned int)0xe3bd6464UL,
+ (unsigned int)0xba032266UL,
+ (unsigned int)0x8d69e067UL,
+ (unsigned int)0x20cbd748UL,
+ (unsigned int)0x17a11549UL,
+ (unsigned int)0x4e1f534bUL,
+ (unsigned int)0x7975914aUL,
+ (unsigned int)0xfc63de4fUL,
+ (unsigned int)0xcb091c4eUL,
+ (unsigned int)0x92b75a4cUL,
+ (unsigned int)0xa5dd984dUL,
+ (unsigned int)0x989ac446UL,
+ (unsigned int)0xaff00647UL,
+ (unsigned int)0xf64e4045UL,
+ (unsigned int)0xc1248244UL,
+ (unsigned int)0x4432cd41UL,
+ (unsigned int)0x73580f40UL,
+ (unsigned int)0x2ae64942UL,
+ (unsigned int)0x1d8c8b43UL,
+ (unsigned int)0x5068f154UL,
+ (unsigned int)0x67023355UL,
+ (unsigned int)0x3ebc7557UL,
+ (unsigned int)0x09d6b756UL,
+ (unsigned int)0x8cc0f853UL,
+ (unsigned int)0xbbaa3a52UL,
+ (unsigned int)0xe2147c50UL,
+ (unsigned int)0xd57ebe51UL,
+ (unsigned int)0xe839e25aUL,
+ (unsigned int)0xdf53205bUL,
+ (unsigned int)0x86ed6659UL,
+ (unsigned int)0xb187a458UL,
+ (unsigned int)0x3491eb5dUL,
+ (unsigned int)0x03fb295cUL,
+ (unsigned int)0x5a456f5eUL,
+ (unsigned int)0x6d2fad5fUL,
+ (unsigned int)0x801b35e1UL,
+ (unsigned int)0xb771f7e0UL,
+ (unsigned int)0xeecfb1e2UL,
+ (unsigned int)0xd9a573e3UL,
+ (unsigned int)0x5cb33ce6UL,
+ (unsigned int)0x6bd9fee7UL,
+ (unsigned int)0x3267b8e5UL,
+ (unsigned int)0x050d7ae4UL,
+ (unsigned int)0x384a26efUL,
+ (unsigned int)0x0f20e4eeUL,
+ (unsigned int)0x569ea2ecUL,
+ (unsigned int)0x61f460edUL,
+ (unsigned int)0xe4e22fe8UL,
+ (unsigned int)0xd388ede9UL,
+ (unsigned int)0x8a36abebUL,
+ (unsigned int)0xbd5c69eaUL,
+ (unsigned int)0xf0b813fdUL,
+ (unsigned int)0xc7d2d1fcUL,
+ (unsigned int)0x9e6c97feUL,
+ (unsigned int)0xa90655ffUL,
+ (unsigned int)0x2c101afaUL,
+ (unsigned int)0x1b7ad8fbUL,
+ (unsigned int)0x42c49ef9UL,
+ (unsigned int)0x75ae5cf8UL,
+ (unsigned int)0x48e900f3UL,
+ (unsigned int)0x7f83c2f2UL,
+ (unsigned int)0x263d84f0UL,
+ (unsigned int)0x115746f1UL,
+ (unsigned int)0x944109f4UL,
+ (unsigned int)0xa32bcbf5UL,
+ (unsigned int)0xfa958df7UL,
+ (unsigned int)0xcdff4ff6UL,
+ (unsigned int)0x605d78d9UL,
+ (unsigned int)0x5737bad8UL,
+ (unsigned int)0x0e89fcdaUL,
+ (unsigned int)0x39e33edbUL,
+ (unsigned int)0xbcf571deUL,
+ (unsigned int)0x8b9fb3dfUL,
+ (unsigned int)0xd221f5ddUL,
+ (unsigned int)0xe54b37dcUL,
+ (unsigned int)0xd80c6bd7UL,
+ (unsigned int)0xef66a9d6UL,
+ (unsigned int)0xb6d8efd4UL,
+ (unsigned int)0x81b22dd5UL,
+ (unsigned int)0x04a462d0UL,
+ (unsigned int)0x33cea0d1UL,
+ (unsigned int)0x6a70e6d3UL,
+ (unsigned int)0x5d1a24d2UL,
+ (unsigned int)0x10fe5ec5UL,
+ (unsigned int)0x27949cc4UL,
+ (unsigned int)0x7e2adac6UL,
+ (unsigned int)0x494018c7UL,
+ (unsigned int)0xcc5657c2UL,
+ (unsigned int)0xfb3c95c3UL,
+ (unsigned int)0xa282d3c1UL,
+ (unsigned int)0x95e811c0UL,
+ (unsigned int)0xa8af4dcbUL,
+ (unsigned int)0x9fc58fcaUL,
+ (unsigned int)0xc67bc9c8UL,
+ (unsigned int)0xf1110bc9UL,
+ (unsigned int)0x740744ccUL,
+ (unsigned int)0x436d86cdUL,
+ (unsigned int)0x1ad3c0cfUL,
+ (unsigned int)0x2db902ceUL,
+ (unsigned int)0x4096af91UL,
+ (unsigned int)0x77fc6d90UL,
+ (unsigned int)0x2e422b92UL,
+ (unsigned int)0x1928e993UL,
+ (unsigned int)0x9c3ea696UL,
+ (unsigned int)0xab546497UL,
+ (unsigned int)0xf2ea2295UL,
+ (unsigned int)0xc580e094UL,
+ (unsigned int)0xf8c7bc9fUL,
+ (unsigned int)0xcfad7e9eUL,
+ (unsigned int)0x9613389cUL,
+ (unsigned int)0xa179fa9dUL,
+ (unsigned int)0x246fb598UL,
+ (unsigned int)0x13057799UL,
+ (unsigned int)0x4abb319bUL,
+ (unsigned int)0x7dd1f39aUL,
+ (unsigned int)0x3035898dUL,
+ (unsigned int)0x075f4b8cUL,
+ (unsigned int)0x5ee10d8eUL,
+ (unsigned int)0x698bcf8fUL,
+ (unsigned int)0xec9d808aUL,
+ (unsigned int)0xdbf7428bUL,
+ (unsigned int)0x82490489UL,
+ (unsigned int)0xb523c688UL,
+ (unsigned int)0x88649a83UL,
+ (unsigned int)0xbf0e5882UL,
+ (unsigned int)0xe6b01e80UL,
+ (unsigned int)0xd1dadc81UL,
+ (unsigned int)0x54cc9384UL,
+ (unsigned int)0x63a65185UL,
+ (unsigned int)0x3a181787UL,
+ (unsigned int)0x0d72d586UL,
+ (unsigned int)0xa0d0e2a9UL,
+ (unsigned int)0x97ba20a8UL,
+ (unsigned int)0xce0466aaUL,
+ (unsigned int)0xf96ea4abUL,
+ (unsigned int)0x7c78ebaeUL,
+ (unsigned int)0x4b1229afUL,
+ (unsigned int)0x12ac6fadUL,
+ (unsigned int)0x25c6adacUL,
+ (unsigned int)0x1881f1a7UL,
+ (unsigned int)0x2feb33a6UL,
+ (unsigned int)0x765575a4UL,
+ (unsigned int)0x413fb7a5UL,
+ (unsigned int)0xc429f8a0UL,
+ (unsigned int)0xf3433aa1UL,
+ (unsigned int)0xaafd7ca3UL,
+ (unsigned int)0x9d97bea2UL,
+ (unsigned int)0xd073c4b5UL,
+ (unsigned int)0xe71906b4UL,
+ (unsigned int)0xbea740b6UL,
+ (unsigned int)0x89cd82b7UL,
+ (unsigned int)0x0cdbcdb2UL,
+ (unsigned int)0x3bb10fb3UL,
+ (unsigned int)0x620f49b1UL,
+ (unsigned int)0x55658bb0UL,
+ (unsigned int)0x6822d7bbUL,
+ (unsigned int)0x5f4815baUL,
+ (unsigned int)0x06f653b8UL,
+ (unsigned int)0x319c91b9UL,
+ (unsigned int)0xb48adebcUL,
+ (unsigned int)0x83e01cbdUL,
+ (unsigned int)0xda5e5abfUL,
+ (unsigned int)0xed3498beUL},
+ {(unsigned int)0x00000000UL,
+ (unsigned int)0x6567bcb8UL,
+ (unsigned int)0x8bc809aaUL,
+ (unsigned int)0xeeafb512UL,
+ (unsigned int)0x5797628fUL,
+ (unsigned int)0x32f0de37UL,
+ (unsigned int)0xdc5f6b25UL,
+ (unsigned int)0xb938d79dUL,
+ (unsigned int)0xef28b4c5UL,
+ (unsigned int)0x8a4f087dUL,
+ (unsigned int)0x64e0bd6fUL,
+ (unsigned int)0x018701d7UL,
+ (unsigned int)0xb8bfd64aUL,
+ (unsigned int)0xddd86af2UL,
+ (unsigned int)0x3377dfe0UL,
+ (unsigned int)0x56106358UL,
+ (unsigned int)0x9f571950UL,
+ (unsigned int)0xfa30a5e8UL,
+ (unsigned int)0x149f10faUL,
+ (unsigned int)0x71f8ac42UL,
+ (unsigned int)0xc8c07bdfUL,
+ (unsigned int)0xada7c767UL,
+ (unsigned int)0x43087275UL,
+ (unsigned int)0x266fcecdUL,
+ (unsigned int)0x707fad95UL,
+ (unsigned int)0x1518112dUL,
+ (unsigned int)0xfbb7a43fUL,
+ (unsigned int)0x9ed01887UL,
+ (unsigned int)0x27e8cf1aUL,
+ (unsigned int)0x428f73a2UL,
+ (unsigned int)0xac20c6b0UL,
+ (unsigned int)0xc9477a08UL,
+ (unsigned int)0x3eaf32a0UL,
+ (unsigned int)0x5bc88e18UL,
+ (unsigned int)0xb5673b0aUL,
+ (unsigned int)0xd00087b2UL,
+ (unsigned int)0x6938502fUL,
+ (unsigned int)0x0c5fec97UL,
+ (unsigned int)0xe2f05985UL,
+ (unsigned int)0x8797e53dUL,
+ (unsigned int)0xd1878665UL,
+ (unsigned int)0xb4e03addUL,
+ (unsigned int)0x5a4f8fcfUL,
+ (unsigned int)0x3f283377UL,
+ (unsigned int)0x8610e4eaUL,
+ (unsigned int)0xe3775852UL,
+ (unsigned int)0x0dd8ed40UL,
+ (unsigned int)0x68bf51f8UL,
+ (unsigned int)0xa1f82bf0UL,
+ (unsigned int)0xc49f9748UL,
+ (unsigned int)0x2a30225aUL,
+ (unsigned int)0x4f579ee2UL,
+ (unsigned int)0xf66f497fUL,
+ (unsigned int)0x9308f5c7UL,
+ (unsigned int)0x7da740d5UL,
+ (unsigned int)0x18c0fc6dUL,
+ (unsigned int)0x4ed09f35UL,
+ (unsigned int)0x2bb7238dUL,
+ (unsigned int)0xc518969fUL,
+ (unsigned int)0xa07f2a27UL,
+ (unsigned int)0x1947fdbaUL,
+ (unsigned int)0x7c204102UL,
+ (unsigned int)0x928ff410UL,
+ (unsigned int)0xf7e848a8UL,
+ (unsigned int)0x3d58149bUL,
+ (unsigned int)0x583fa823UL,
+ (unsigned int)0xb6901d31UL,
+ (unsigned int)0xd3f7a189UL,
+ (unsigned int)0x6acf7614UL,
+ (unsigned int)0x0fa8caacUL,
+ (unsigned int)0xe1077fbeUL,
+ (unsigned int)0x8460c306UL,
+ (unsigned int)0xd270a05eUL,
+ (unsigned int)0xb7171ce6UL,
+ (unsigned int)0x59b8a9f4UL,
+ (unsigned int)0x3cdf154cUL,
+ (unsigned int)0x85e7c2d1UL,
+ (unsigned int)0xe0807e69UL,
+ (unsigned int)0x0e2fcb7bUL,
+ (unsigned int)0x6b4877c3UL,
+ (unsigned int)0xa20f0dcbUL,
+ (unsigned int)0xc768b173UL,
+ (unsigned int)0x29c70461UL,
+ (unsigned int)0x4ca0b8d9UL,
+ (unsigned int)0xf5986f44UL,
+ (unsigned int)0x90ffd3fcUL,
+ (unsigned int)0x7e5066eeUL,
+ (unsigned int)0x1b37da56UL,
+ (unsigned int)0x4d27b90eUL,
+ (unsigned int)0x284005b6UL,
+ (unsigned int)0xc6efb0a4UL,
+ (unsigned int)0xa3880c1cUL,
+ (unsigned int)0x1ab0db81UL,
+ (unsigned int)0x7fd76739UL,
+ (unsigned int)0x9178d22bUL,
+ (unsigned int)0xf41f6e93UL,
+ (unsigned int)0x03f7263bUL,
+ (unsigned int)0x66909a83UL,
+ (unsigned int)0x883f2f91UL,
+ (unsigned int)0xed589329UL,
+ (unsigned int)0x546044b4UL,
+ (unsigned int)0x3107f80cUL,
+ (unsigned int)0xdfa84d1eUL,
+ (unsigned int)0xbacff1a6UL,
+ (unsigned int)0xecdf92feUL,
+ (unsigned int)0x89b82e46UL,
+ (unsigned int)0x67179b54UL,
+ (unsigned int)0x027027ecUL,
+ (unsigned int)0xbb48f071UL,
+ (unsigned int)0xde2f4cc9UL,
+ (unsigned int)0x3080f9dbUL,
+ (unsigned int)0x55e74563UL,
+ (unsigned int)0x9ca03f6bUL,
+ (unsigned int)0xf9c783d3UL,
+ (unsigned int)0x176836c1UL,
+ (unsigned int)0x720f8a79UL,
+ (unsigned int)0xcb375de4UL,
+ (unsigned int)0xae50e15cUL,
+ (unsigned int)0x40ff544eUL,
+ (unsigned int)0x2598e8f6UL,
+ (unsigned int)0x73888baeUL,
+ (unsigned int)0x16ef3716UL,
+ (unsigned int)0xf8408204UL,
+ (unsigned int)0x9d273ebcUL,
+ (unsigned int)0x241fe921UL,
+ (unsigned int)0x41785599UL,
+ (unsigned int)0xafd7e08bUL,
+ (unsigned int)0xcab05c33UL,
+ (unsigned int)0x3bb659edUL,
+ (unsigned int)0x5ed1e555UL,
+ (unsigned int)0xb07e5047UL,
+ (unsigned int)0xd519ecffUL,
+ (unsigned int)0x6c213b62UL,
+ (unsigned int)0x094687daUL,
+ (unsigned int)0xe7e932c8UL,
+ (unsigned int)0x828e8e70UL,
+ (unsigned int)0xd49eed28UL,
+ (unsigned int)0xb1f95190UL,
+ (unsigned int)0x5f56e482UL,
+ (unsigned int)0x3a31583aUL,
+ (unsigned int)0x83098fa7UL,
+ (unsigned int)0xe66e331fUL,
+ (unsigned int)0x08c1860dUL,
+ (unsigned int)0x6da63ab5UL,
+ (unsigned int)0xa4e140bdUL,
+ (unsigned int)0xc186fc05UL,
+ (unsigned int)0x2f294917UL,
+ (unsigned int)0x4a4ef5afUL,
+ (unsigned int)0xf3762232UL,
+ (unsigned int)0x96119e8aUL,
+ (unsigned int)0x78be2b98UL,
+ (unsigned int)0x1dd99720UL,
+ (unsigned int)0x4bc9f478UL,
+ (unsigned int)0x2eae48c0UL,
+ (unsigned int)0xc001fdd2UL,
+ (unsigned int)0xa566416aUL,
+ (unsigned int)0x1c5e96f7UL,
+ (unsigned int)0x79392a4fUL,
+ (unsigned int)0x97969f5dUL,
+ (unsigned int)0xf2f123e5UL,
+ (unsigned int)0x05196b4dUL,
+ (unsigned int)0x607ed7f5UL,
+ (unsigned int)0x8ed162e7UL,
+ (unsigned int)0xebb6de5fUL,
+ (unsigned int)0x528e09c2UL,
+ (unsigned int)0x37e9b57aUL,
+ (unsigned int)0xd9460068UL,
+ (unsigned int)0xbc21bcd0UL,
+ (unsigned int)0xea31df88UL,
+ (unsigned int)0x8f566330UL,
+ (unsigned int)0x61f9d622UL,
+ (unsigned int)0x049e6a9aUL,
+ (unsigned int)0xbda6bd07UL,
+ (unsigned int)0xd8c101bfUL,
+ (unsigned int)0x366eb4adUL,
+ (unsigned int)0x53090815UL,
+ (unsigned int)0x9a4e721dUL,
+ (unsigned int)0xff29cea5UL,
+ (unsigned int)0x11867bb7UL,
+ (unsigned int)0x74e1c70fUL,
+ (unsigned int)0xcdd91092UL,
+ (unsigned int)0xa8beac2aUL,
+ (unsigned int)0x46111938UL,
+ (unsigned int)0x2376a580UL,
+ (unsigned int)0x7566c6d8UL,
+ (unsigned int)0x10017a60UL,
+ (unsigned int)0xfeaecf72UL,
+ (unsigned int)0x9bc973caUL,
+ (unsigned int)0x22f1a457UL,
+ (unsigned int)0x479618efUL,
+ (unsigned int)0xa939adfdUL,
+ (unsigned int)0xcc5e1145UL,
+ (unsigned int)0x06ee4d76UL,
+ (unsigned int)0x6389f1ceUL,
+ (unsigned int)0x8d2644dcUL,
+ (unsigned int)0xe841f864UL,
+ (unsigned int)0x51792ff9UL,
+ (unsigned int)0x341e9341UL,
+ (unsigned int)0xdab12653UL,
+ (unsigned int)0xbfd69aebUL,
+ (unsigned int)0xe9c6f9b3UL,
+ (unsigned int)0x8ca1450bUL,
+ (unsigned int)0x620ef019UL,
+ (unsigned int)0x07694ca1UL,
+ (unsigned int)0xbe519b3cUL,
+ (unsigned int)0xdb362784UL,
+ (unsigned int)0x35999296UL,
+ (unsigned int)0x50fe2e2eUL,
+ (unsigned int)0x99b95426UL,
+ (unsigned int)0xfcdee89eUL,
+ (unsigned int)0x12715d8cUL,
+ (unsigned int)0x7716e134UL,
+ (unsigned int)0xce2e36a9UL,
+ (unsigned int)0xab498a11UL,
+ (unsigned int)0x45e63f03UL,
+ (unsigned int)0x208183bbUL,
+ (unsigned int)0x7691e0e3UL,
+ (unsigned int)0x13f65c5bUL,
+ (unsigned int)0xfd59e949UL,
+ (unsigned int)0x983e55f1UL,
+ (unsigned int)0x2106826cUL,
+ (unsigned int)0x44613ed4UL,
+ (unsigned int)0xaace8bc6UL,
+ (unsigned int)0xcfa9377eUL,
+ (unsigned int)0x38417fd6UL,
+ (unsigned int)0x5d26c36eUL,
+ (unsigned int)0xb389767cUL,
+ (unsigned int)0xd6eecac4UL,
+ (unsigned int)0x6fd61d59UL,
+ (unsigned int)0x0ab1a1e1UL,
+ (unsigned int)0xe41e14f3UL,
+ (unsigned int)0x8179a84bUL,
+ (unsigned int)0xd769cb13UL,
+ (unsigned int)0xb20e77abUL,
+ (unsigned int)0x5ca1c2b9UL,
+ (unsigned int)0x39c67e01UL,
+ (unsigned int)0x80fea99cUL,
+ (unsigned int)0xe5991524UL,
+ (unsigned int)0x0b36a036UL,
+ (unsigned int)0x6e511c8eUL,
+ (unsigned int)0xa7166686UL,
+ (unsigned int)0xc271da3eUL,
+ (unsigned int)0x2cde6f2cUL,
+ (unsigned int)0x49b9d394UL,
+ (unsigned int)0xf0810409UL,
+ (unsigned int)0x95e6b8b1UL,
+ (unsigned int)0x7b490da3UL,
+ (unsigned int)0x1e2eb11bUL,
+ (unsigned int)0x483ed243UL,
+ (unsigned int)0x2d596efbUL,
+ (unsigned int)0xc3f6dbe9UL,
+ (unsigned int)0xa6916751UL,
+ (unsigned int)0x1fa9b0ccUL,
+ (unsigned int)0x7ace0c74UL,
+ (unsigned int)0x9461b966UL,
+ (unsigned int)0xf10605deUL}};
+z_crc_t const *get_crc_table(void)
+{
+ z_crc_t const *__retres;
+ __retres = (z_crc_t const *)(crc_table);
+ return __retres;
+}
+
+unsigned long crc32_z(unsigned long crc, unsigned char const *buf,
+ z_size_t len) __attribute__((__FC_OLDSTYLEPROTO__));
+unsigned long crc32_z(unsigned long crc, unsigned char const *buf,
+ z_size_t len)
+{
+ unsigned long __retres;
+ if (buf == (unsigned char const *)0) {
+ __retres = 0UL;
+ goto return_label;
+ }
+ if (sizeof(void *) == sizeof(ptrdiff_t)) {
+ z_crc_t endian;
+ endian = (unsigned int)1;
+ if (*((unsigned char *)(& endian))) {
+ unsigned long tmp;
+ tmp = crc32_little(crc,buf,len);
+ __retres = tmp;
+ goto return_label;
+ }
+ else {
+ unsigned long tmp_0;
+ tmp_0 = crc32_big(crc,buf,len);
+ __retres = tmp_0;
+ goto return_label;
+ }
+ }
+ crc ^= 0xffffffffUL;
+ while (len >= (z_size_t)8) {
+ unsigned char const *tmp_1;
+ unsigned char const *tmp_2;
+ unsigned char const *tmp_3;
+ unsigned char const *tmp_4;
+ unsigned char const *tmp_5;
+ unsigned char const *tmp_6;
+ unsigned char const *tmp_7;
+ unsigned char const *tmp_8;
+ tmp_1 = buf;
+ buf ++;
+ crc = (unsigned long)crc_table[0][((int)crc ^ (int)*tmp_1) & 0xff] ^ (
+ crc >> 8);
+ tmp_2 = buf;
+ buf ++;
+ crc = (unsigned long)crc_table[0][((int)crc ^ (int)*tmp_2) & 0xff] ^ (
+ crc >> 8);
+ tmp_3 = buf;
+ buf ++;
+ crc = (unsigned long)crc_table[0][((int)crc ^ (int)*tmp_3) & 0xff] ^ (
+ crc >> 8);
+ tmp_4 = buf;
+ buf ++;
+ crc = (unsigned long)crc_table[0][((int)crc ^ (int)*tmp_4) & 0xff] ^ (
+ crc >> 8);
+ tmp_5 = buf;
+ buf ++;
+ crc = (unsigned long)crc_table[0][((int)crc ^ (int)*tmp_5) & 0xff] ^ (
+ crc >> 8);
+ tmp_6 = buf;
+ buf ++;
+ crc = (unsigned long)crc_table[0][((int)crc ^ (int)*tmp_6) & 0xff] ^ (
+ crc >> 8);
+ tmp_7 = buf;
+ buf ++;
+ crc = (unsigned long)crc_table[0][((int)crc ^ (int)*tmp_7) & 0xff] ^ (
+ crc >> 8);
+ tmp_8 = buf;
+ buf ++;
+ crc = (unsigned long)crc_table[0][((int)crc ^ (int)*tmp_8) & 0xff] ^ (
+ crc >> 8);
+ len -= (z_size_t)8;
+ }
+ if (len)
+ while (1) {
+ {
+ unsigned char const *tmp_9;
+ tmp_9 = buf;
+ buf ++;
+ crc = (unsigned long)crc_table[0][((int)crc ^ (int)*tmp_9) & 0xff] ^ (
+ crc >> 8);
+ }
+ len -= (z_size_t)1;
+ if (! len) break;
+ }
+ __retres = crc ^ 0xffffffffUL;
+ return_label: return __retres;
+}
+
+unsigned long crc32(unsigned long crc, unsigned char const *buf, uInt len) __attribute__((
+__FC_OLDSTYLEPROTO__));
+unsigned long crc32(unsigned long crc, unsigned char const *buf, uInt len)
+{
+ unsigned long tmp;
+ tmp = crc32_z(crc,buf,(unsigned long)len);
+ return tmp;
+}
+
+static unsigned long crc32_little(unsigned long crc,
+ unsigned char const *buf, z_size_t len) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static unsigned long crc32_little(unsigned long crc,
+ unsigned char const *buf, z_size_t len)
+{
+ unsigned long __retres;
+ register z_crc_t c;
+ register z_crc_t const *buf4;
+ c = (unsigned int)crc;
+ c = ~ c;
+ while (1) {
+ if (len) {
+ if (! ((long)buf & (long)3)) break;
+ }
+ else break;
+ {
+ unsigned char const *tmp;
+ tmp = buf;
+ buf ++;
+ c = crc_table[0][(c ^ (unsigned int)*tmp) & (unsigned int)0xff] ^ (
+ c >> 8);
+ len -= (z_size_t)1;
+ }
+ }
+ buf4 = (z_crc_t const *)buf;
+ while (len >= (z_size_t)32) {
+ z_crc_t const *tmp_0;
+ z_crc_t const *tmp_1;
+ z_crc_t const *tmp_2;
+ z_crc_t const *tmp_3;
+ z_crc_t const *tmp_4;
+ z_crc_t const *tmp_5;
+ z_crc_t const *tmp_6;
+ z_crc_t const *tmp_7;
+ tmp_0 = buf4;
+ buf4 ++;
+ c ^= *tmp_0;
+ c = ((crc_table[3][c & (unsigned int)0xff] ^ crc_table[2][(c >> 8) & (unsigned int)0xff]) ^ crc_table[1][
+ (c >> 16) & (unsigned int)0xff]) ^ crc_table[0][c >> 24];
+ tmp_1 = buf4;
+ buf4 ++;
+ c ^= *tmp_1;
+ c = ((crc_table[3][c & (unsigned int)0xff] ^ crc_table[2][(c >> 8) & (unsigned int)0xff]) ^ crc_table[1][
+ (c >> 16) & (unsigned int)0xff]) ^ crc_table[0][c >> 24];
+ tmp_2 = buf4;
+ buf4 ++;
+ c ^= *tmp_2;
+ c = ((crc_table[3][c & (unsigned int)0xff] ^ crc_table[2][(c >> 8) & (unsigned int)0xff]) ^ crc_table[1][
+ (c >> 16) & (unsigned int)0xff]) ^ crc_table[0][c >> 24];
+ tmp_3 = buf4;
+ buf4 ++;
+ c ^= *tmp_3;
+ c = ((crc_table[3][c & (unsigned int)0xff] ^ crc_table[2][(c >> 8) & (unsigned int)0xff]) ^ crc_table[1][
+ (c >> 16) & (unsigned int)0xff]) ^ crc_table[0][c >> 24];
+ tmp_4 = buf4;
+ buf4 ++;
+ c ^= *tmp_4;
+ c = ((crc_table[3][c & (unsigned int)0xff] ^ crc_table[2][(c >> 8) & (unsigned int)0xff]) ^ crc_table[1][
+ (c >> 16) & (unsigned int)0xff]) ^ crc_table[0][c >> 24];
+ tmp_5 = buf4;
+ buf4 ++;
+ c ^= *tmp_5;
+ c = ((crc_table[3][c & (unsigned int)0xff] ^ crc_table[2][(c >> 8) & (unsigned int)0xff]) ^ crc_table[1][
+ (c >> 16) & (unsigned int)0xff]) ^ crc_table[0][c >> 24];
+ tmp_6 = buf4;
+ buf4 ++;
+ c ^= *tmp_6;
+ c = ((crc_table[3][c & (unsigned int)0xff] ^ crc_table[2][(c >> 8) & (unsigned int)0xff]) ^ crc_table[1][
+ (c >> 16) & (unsigned int)0xff]) ^ crc_table[0][c >> 24];
+ tmp_7 = buf4;
+ buf4 ++;
+ c ^= *tmp_7;
+ c = ((crc_table[3][c & (unsigned int)0xff] ^ crc_table[2][(c >> 8) & (unsigned int)0xff]) ^ crc_table[1][
+ (c >> 16) & (unsigned int)0xff]) ^ crc_table[0][c >> 24];
+ len -= (z_size_t)32;
+ }
+ while (len >= (z_size_t)4) {
+ z_crc_t const *tmp_8;
+ tmp_8 = buf4;
+ buf4 ++;
+ c ^= *tmp_8;
+ c = ((crc_table[3][c & (unsigned int)0xff] ^ crc_table[2][(c >> 8) & (unsigned int)0xff]) ^ crc_table[1][
+ (c >> 16) & (unsigned int)0xff]) ^ crc_table[0][c >> 24];
+ len -= (z_size_t)4;
+ }
+ buf = (unsigned char const *)buf4;
+ if (len)
+ while (1) {
+ {
+ unsigned char const *tmp_9;
+ tmp_9 = buf;
+ buf ++;
+ c = crc_table[0][(c ^ (unsigned int)*tmp_9) & (unsigned int)0xff] ^ (
+ c >> 8);
+ }
+ len -= (z_size_t)1;
+ if (! len) break;
+ }
+ c = ~ c;
+ __retres = (unsigned long)c;
+ return __retres;
+}
+
+static unsigned long crc32_big(unsigned long crc, unsigned char const *buf,
+ z_size_t len) __attribute__((__FC_OLDSTYLEPROTO__));
+static unsigned long crc32_big(unsigned long crc, unsigned char const *buf,
+ z_size_t len)
+{
+ unsigned long __retres;
+ register z_crc_t c;
+ register z_crc_t const *buf4;
+ c = (((((unsigned int)crc >> 24) & (unsigned int)0xff) + (((unsigned int)crc >> 8) & (unsigned int)0xff00)) + (
+ ((unsigned int)crc & (unsigned int)0xff00) << 8)) + (((unsigned int)crc & (unsigned int)0xff) << 24);
+ c = ~ c;
+ while (1) {
+ if (len) {
+ if (! ((long)buf & (long)3)) break;
+ }
+ else break;
+ {
+ unsigned char const *tmp;
+ tmp = buf;
+ buf ++;
+ c = crc_table[4][(c >> 24) ^ (unsigned int)*tmp] ^ (c << 8);
+ len -= (z_size_t)1;
+ }
+ }
+ buf4 = (z_crc_t const *)buf;
+ while (len >= (z_size_t)32) {
+ z_crc_t const *tmp_0;
+ z_crc_t const *tmp_1;
+ z_crc_t const *tmp_2;
+ z_crc_t const *tmp_3;
+ z_crc_t const *tmp_4;
+ z_crc_t const *tmp_5;
+ z_crc_t const *tmp_6;
+ z_crc_t const *tmp_7;
+ tmp_0 = buf4;
+ buf4 ++;
+ c ^= *tmp_0;
+ c = ((crc_table[4][c & (unsigned int)0xff] ^ crc_table[5][(c >> 8) & (unsigned int)0xff]) ^ crc_table[6][
+ (c >> 16) & (unsigned int)0xff]) ^ crc_table[7][c >> 24];
+ tmp_1 = buf4;
+ buf4 ++;
+ c ^= *tmp_1;
+ c = ((crc_table[4][c & (unsigned int)0xff] ^ crc_table[5][(c >> 8) & (unsigned int)0xff]) ^ crc_table[6][
+ (c >> 16) & (unsigned int)0xff]) ^ crc_table[7][c >> 24];
+ tmp_2 = buf4;
+ buf4 ++;
+ c ^= *tmp_2;
+ c = ((crc_table[4][c & (unsigned int)0xff] ^ crc_table[5][(c >> 8) & (unsigned int)0xff]) ^ crc_table[6][
+ (c >> 16) & (unsigned int)0xff]) ^ crc_table[7][c >> 24];
+ tmp_3 = buf4;
+ buf4 ++;
+ c ^= *tmp_3;
+ c = ((crc_table[4][c & (unsigned int)0xff] ^ crc_table[5][(c >> 8) & (unsigned int)0xff]) ^ crc_table[6][
+ (c >> 16) & (unsigned int)0xff]) ^ crc_table[7][c >> 24];
+ tmp_4 = buf4;
+ buf4 ++;
+ c ^= *tmp_4;
+ c = ((crc_table[4][c & (unsigned int)0xff] ^ crc_table[5][(c >> 8) & (unsigned int)0xff]) ^ crc_table[6][
+ (c >> 16) & (unsigned int)0xff]) ^ crc_table[7][c >> 24];
+ tmp_5 = buf4;
+ buf4 ++;
+ c ^= *tmp_5;
+ c = ((crc_table[4][c & (unsigned int)0xff] ^ crc_table[5][(c >> 8) & (unsigned int)0xff]) ^ crc_table[6][
+ (c >> 16) & (unsigned int)0xff]) ^ crc_table[7][c >> 24];
+ tmp_6 = buf4;
+ buf4 ++;
+ c ^= *tmp_6;
+ c = ((crc_table[4][c & (unsigned int)0xff] ^ crc_table[5][(c >> 8) & (unsigned int)0xff]) ^ crc_table[6][
+ (c >> 16) & (unsigned int)0xff]) ^ crc_table[7][c >> 24];
+ tmp_7 = buf4;
+ buf4 ++;
+ c ^= *tmp_7;
+ c = ((crc_table[4][c & (unsigned int)0xff] ^ crc_table[5][(c >> 8) & (unsigned int)0xff]) ^ crc_table[6][
+ (c >> 16) & (unsigned int)0xff]) ^ crc_table[7][c >> 24];
+ len -= (z_size_t)32;
+ }
+ while (len >= (z_size_t)4) {
+ z_crc_t const *tmp_8;
+ tmp_8 = buf4;
+ buf4 ++;
+ c ^= *tmp_8;
+ c = ((crc_table[4][c & (unsigned int)0xff] ^ crc_table[5][(c >> 8) & (unsigned int)0xff]) ^ crc_table[6][
+ (c >> 16) & (unsigned int)0xff]) ^ crc_table[7][c >> 24];
+ len -= (z_size_t)4;
+ }
+ buf = (unsigned char const *)buf4;
+ if (len)
+ while (1) {
+ {
+ unsigned char const *tmp_9;
+ tmp_9 = buf;
+ buf ++;
+ c = crc_table[4][(c >> 24) ^ (unsigned int)*tmp_9] ^ (c << 8);
+ }
+ len -= (z_size_t)1;
+ if (! len) break;
+ }
+ c = ~ c;
+ __retres = (unsigned long)(((((c >> 24) & (unsigned int)0xff) + ((c >> 8) & (unsigned int)0xff00)) + (
+ (c & (unsigned int)0xff00) << 8)) + ((c & (unsigned int)0xff) << 24));
+ return __retres;
+}
+
+static unsigned long gf2_matrix_times(unsigned long *mat, unsigned long vec) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static unsigned long gf2_matrix_times(unsigned long *mat, unsigned long vec)
+{
+ unsigned long sum;
+ sum = (unsigned long)0;
+ while (vec) {
+ if (vec & (unsigned long)1) sum ^= *mat;
+ vec >>= 1;
+ mat ++;
+ }
+ return sum;
+}
+
+static void gf2_matrix_square(unsigned long *square, unsigned long *mat) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static void gf2_matrix_square(unsigned long *square, unsigned long *mat)
+{
+ int n;
+ n = 0;
+ while (n < 32) {
+ *(square + n) = gf2_matrix_times(mat,*(mat + n));
+ n ++;
+ }
+ return;
+}
+
+static uLong crc32_combine_(uLong crc1, uLong crc2, long len2) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static uLong crc32_combine_(uLong crc1, uLong crc2, long len2)
+{
+ uLong __retres;
+ int n;
+ unsigned long row;
+ unsigned long even[32];
+ unsigned long odd[32];
+ if (len2 <= (long)0) {
+ __retres = crc1;
+ goto return_label;
+ }
+ odd[0] = 0xedb88320UL;
+ row = (unsigned long)1;
+ n = 1;
+ while (n < 32) {
+ odd[n] = row;
+ row <<= 1;
+ n ++;
+ }
+ gf2_matrix_square(even,odd);
+ gf2_matrix_square(odd,even);
+ while (1) {
+ gf2_matrix_square(even,odd);
+ if (len2 & (long)1) crc1 = gf2_matrix_times(even,crc1);
+ len2 >>= 1;
+ if (len2 == (long)0) break;
+ gf2_matrix_square(odd,even);
+ if (len2 & (long)1) crc1 = gf2_matrix_times(odd,crc1);
+ len2 >>= 1;
+ if (! (len2 != (long)0)) break;
+ }
+ crc1 ^= crc2;
+ __retres = crc1;
+ return_label: return __retres;
+}
+
+uLong crc32_combine(uLong crc1, uLong crc2, long len2) __attribute__((
+__FC_OLDSTYLEPROTO__));
+uLong crc32_combine(uLong crc1, uLong crc2, long len2)
+{
+ uLong tmp;
+ tmp = crc32_combine_(crc1,crc2,len2);
+ return tmp;
+}
+
+uLong crc32_combine64(uLong crc1, uLong crc2, long len2) __attribute__((
+__FC_OLDSTYLEPROTO__));
+uLong crc32_combine64(uLong crc1, uLong crc2, long len2)
+{
+ uLong tmp;
+ tmp = crc32_combine_(crc1,crc2,len2);
+ return tmp;
+}
+
+void _tr_init(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int _tr_tally(deflate_state *s, unsigned int dist, unsigned int lc) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+void _tr_flush_block(deflate_state *s, charf *buf, ulg stored_len, int last) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+void _tr_flush_bits(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+
+void _tr_align(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+
+void _tr_stored_block(deflate_state *s, charf *buf, ulg stored_len, int last) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+uch const _length_code[(258 - 3) + 1];
+
+uch const _dist_code[512];
+
+char const deflate_copyright[69] =
+ {(char)' ',
+ (char)'d',
+ (char)'e',
+ (char)'f',
+ (char)'l',
+ (char)'a',
+ (char)'t',
+ (char)'e',
+ (char)' ',
+ (char)'1',
+ (char)'.',
+ (char)'2',
+ (char)'.',
+ (char)'1',
+ (char)'1',
+ (char)' ',
+ (char)'C',
+ (char)'o',
+ (char)'p',
+ (char)'y',
+ (char)'r',
+ (char)'i',
+ (char)'g',
+ (char)'h',
+ (char)'t',
+ (char)' ',
+ (char)'1',
+ (char)'9',
+ (char)'9',
+ (char)'5',
+ (char)'-',
+ (char)'2',
+ (char)'0',
+ (char)'1',
+ (char)'7',
+ (char)' ',
+ (char)'J',
+ (char)'e',
+ (char)'a',
+ (char)'n',
+ (char)'-',
+ (char)'l',
+ (char)'o',
+ (char)'u',
+ (char)'p',
+ (char)' ',
+ (char)'G',
+ (char)'a',
+ (char)'i',
+ (char)'l',
+ (char)'l',
+ (char)'y',
+ (char)' ',
+ (char)'a',
+ (char)'n',
+ (char)'d',
+ (char)' ',
+ (char)'M',
+ (char)'a',
+ (char)'r',
+ (char)'k',
+ (char)' ',
+ (char)'A',
+ (char)'d',
+ (char)'l',
+ (char)'e',
+ (char)'r',
+ (char)' ',
+ (char)'\000'};
+static int deflateStateCheck(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static void slide_hash(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static void fill_window(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static block_state deflate_stored(deflate_state *s, int flush) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static block_state deflate_fast(deflate_state *s, int flush) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static block_state deflate_slow(deflate_state *s, int flush) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static block_state deflate_rle(deflate_state *s, int flush) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static block_state deflate_huff(deflate_state *s, int flush) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static void lm_init(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static void putShortMSB(deflate_state *s, uInt b) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static void flush_pending(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static unsigned int read_buf(z_streamp strm, Bytef *buf, unsigned int size) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static uInt longest_match(deflate_state *s, IPos cur_match) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static config const configuration_table[10] =
+ {{.good_length = (unsigned short)0,
+ .max_lazy = (unsigned short)0,
+ .nice_length = (unsigned short)0,
+ .max_chain = (unsigned short)0,
+ .func = & deflate_stored},
+ {.good_length = (unsigned short)4,
+ .max_lazy = (unsigned short)4,
+ .nice_length = (unsigned short)8,
+ .max_chain = (unsigned short)4,
+ .func = & deflate_fast},
+ {.good_length = (unsigned short)4,
+ .max_lazy = (unsigned short)5,
+ .nice_length = (unsigned short)16,
+ .max_chain = (unsigned short)8,
+ .func = & deflate_fast},
+ {.good_length = (unsigned short)4,
+ .max_lazy = (unsigned short)6,
+ .nice_length = (unsigned short)32,
+ .max_chain = (unsigned short)32,
+ .func = & deflate_fast},
+ {.good_length = (unsigned short)4,
+ .max_lazy = (unsigned short)4,
+ .nice_length = (unsigned short)16,
+ .max_chain = (unsigned short)16,
+ .func = & deflate_slow},
+ {.good_length = (unsigned short)8,
+ .max_lazy = (unsigned short)16,
+ .nice_length = (unsigned short)32,
+ .max_chain = (unsigned short)32,
+ .func = & deflate_slow},
+ {.good_length = (unsigned short)8,
+ .max_lazy = (unsigned short)16,
+ .nice_length = (unsigned short)128,
+ .max_chain = (unsigned short)128,
+ .func = & deflate_slow},
+ {.good_length = (unsigned short)8,
+ .max_lazy = (unsigned short)32,
+ .nice_length = (unsigned short)128,
+ .max_chain = (unsigned short)256,
+ .func = & deflate_slow},
+ {.good_length = (unsigned short)32,
+ .max_lazy = (unsigned short)128,
+ .nice_length = (unsigned short)258,
+ .max_chain = (unsigned short)1024,
+ .func = & deflate_slow},
+ {.good_length = (unsigned short)32,
+ .max_lazy = (unsigned short)258,
+ .nice_length = (unsigned short)258,
+ .max_chain = (unsigned short)4096,
+ .func = & deflate_slow}};
+static void slide_hash(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+static void slide_hash(deflate_state *s)
+{
+ unsigned int n;
+ unsigned int m;
+ Posf *p;
+ uInt wsize = s->w_size;
+ n = s->hash_size;
+ p = s->head + n;
+ while (1) {
+ {
+ unsigned int tmp;
+ p --;
+ m = (unsigned int)*p;
+ if (m >= wsize) tmp = m - wsize; else tmp = (unsigned int)0;
+ *p = (unsigned short)tmp;
+ }
+ n --;
+ if (! n) break;
+ }
+ n = wsize;
+ p = s->prev + n;
+ while (1) {
+ {
+ unsigned int tmp_0;
+ p --;
+ m = (unsigned int)*p;
+ if (m >= wsize) tmp_0 = m - wsize; else tmp_0 = (unsigned int)0;
+ *p = (unsigned short)tmp_0;
+ }
+ n --;
+ if (! n) break;
+ }
+ return;
+}
+
+int deflateInit_(z_streamp strm, int level, char const *version,
+ int stream_size) __attribute__((__FC_OLDSTYLEPROTO__));
+int deflateInit_(z_streamp strm, int level, char const *version,
+ int stream_size)
+{
+ int tmp;
+ tmp = deflateInit2_(strm,level,8,15,8,0,version,stream_size);
+ return tmp;
+}
+
+static char const deflateInit2__my_version[7] =
+ {(char)'1',
+ (char)'.',
+ (char)'2',
+ (char)'.',
+ (char)'1',
+ (char)'1',
+ (char)'\000'};
+int deflateInit2_(z_streamp strm, int level, int method, int windowBits,
+ int memLevel, int strategy, char const *version,
+ int stream_size) __attribute__((__FC_OLDSTYLEPROTO__));
+int deflateInit2_(z_streamp strm, int level, int method, int windowBits,
+ int memLevel, int strategy, char const *version,
+ int stream_size)
+{
+ int __retres;
+ deflate_state *s;
+ ushf *overlay;
+ int tmp_4;
+ int wrap = 1;
+ if (version == (char const *)0) goto _LOR;
+ else
+ if ((int)*(version + 0) != (int)deflateInit2__my_version[0]) goto _LOR;
+ else
+ if ((unsigned long)stream_size != sizeof(z_stream)) {
+ _LOR: {
+ __retres = -6;
+ goto return_label;
+ }
+ }
+ if (strm == (z_streamp)0) {
+ __retres = -2;
+ goto return_label;
+ }
+ strm->msg = (char *)0;
+ if (strm->zalloc == (voidpf (*)(voidpf opaque, uInt items, uInt size))0) {
+ strm->zalloc = & zcalloc;
+ strm->opaque = (void *)0;
+ }
+ if (strm->zfree == (void (*)(voidpf opaque, voidpf address))0) strm->zfree = & zcfree;
+ if (level == -1) level = 6;
+ if (windowBits < 0) {
+ wrap = 0;
+ windowBits = - windowBits;
+ }
+ else
+ if (windowBits > 15) {
+ wrap = 2;
+ windowBits -= 16;
+ }
+ if (memLevel < 1) goto _LOR_0;
+ else
+ if (memLevel > 9) goto _LOR_0;
+ else
+ if (method != 8) goto _LOR_0;
+ else
+ if (windowBits < 8) goto _LOR_0;
+ else
+ if (windowBits > 15) goto _LOR_0;
+ else
+ if (level < 0) goto _LOR_0;
+ else
+ if (level > 9) goto _LOR_0;
+ else
+ if (strategy < 0) goto _LOR_0;
+ else
+ if (strategy > 4) goto _LOR_0;
+ else
+ if (windowBits == 8)
+ if (wrap != 1) {
+ _LOR_0: {
+ __retres = -2;
+ goto return_label;
+ }
+ }
+ if (windowBits == 8) windowBits = 9;
+ s = (deflate_state *)(*(strm->zalloc))(strm->opaque,(unsigned int)1,
+ (unsigned int)sizeof(deflate_state));
+ if (s == (deflate_state *)0) {
+ __retres = -4;
+ goto return_label;
+ }
+ strm->state = s;
+ s->strm = strm;
+ s->status = 42;
+ s->wrap = wrap;
+ s->gzhead = (gz_header *)0;
+ s->w_bits = (unsigned int)windowBits;
+ s->w_size = (unsigned int)(1 << s->w_bits);
+ s->w_mask = s->w_size - (uInt)1;
+ s->hash_bits = (unsigned int)memLevel + (unsigned int)7;
+ s->hash_size = (unsigned int)(1 << s->hash_bits);
+ s->hash_mask = s->hash_size - (uInt)1;
+ s->hash_shift = ((s->hash_bits + (uInt)3) - (uInt)1) / (uInt)3;
+ s->window = (Bytef *)(*(strm->zalloc))(strm->opaque,s->w_size,
+ (unsigned int)((unsigned long)2 * sizeof(Byte)));
+ s->prev = (Posf *)(*(strm->zalloc))(strm->opaque,s->w_size,
+ (unsigned int)sizeof(Pos));
+ s->head = (Posf *)(*(strm->zalloc))(strm->opaque,s->hash_size,
+ (unsigned int)sizeof(Pos));
+ s->high_water = (unsigned long)0;
+ s->lit_bufsize = (unsigned int)(1 << (memLevel + 6));
+ overlay = (ushf *)(*(strm->zalloc))(strm->opaque,s->lit_bufsize,
+ (unsigned int)(sizeof(ush) + (unsigned long)2));
+ s->pending_buf = (uchf *)overlay;
+ s->pending_buf_size = (unsigned long)s->lit_bufsize * (sizeof(ush) + (unsigned long)2L);
+ if (s->window == (Bytef *)0) goto _LOR_1;
+ else
+ if (s->prev == (Posf *)0) goto _LOR_1;
+ else
+ if (s->head == (Posf *)0) goto _LOR_1;
+ else
+ if (s->pending_buf == (Bytef *)0) {
+ _LOR_1:
+ {
+ s->status = 666;
+ strm->msg = z_errmsg[2 - -4];
+ deflateEnd(strm);
+ __retres = -4;
+ goto return_label;
+ }
+ }
+ s->d_buf = overlay + (unsigned long)s->lit_bufsize / sizeof(ush);
+ s->l_buf = s->pending_buf + ((unsigned long)1 + sizeof(ush)) * (unsigned long)s->lit_bufsize;
+ s->level = level;
+ s->strategy = strategy;
+ s->method = (unsigned char)method;
+ tmp_4 = deflateReset(strm);
+ __retres = tmp_4;
+ return_label: return __retres;
+}
+
+static int deflateStateCheck(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+static int deflateStateCheck(z_streamp strm)
+{
+ int __retres;
+ deflate_state *s;
+ if (strm == (z_streamp)0) {
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (strm->zalloc == (voidpf (*)(voidpf opaque, uInt items, uInt size))0) {
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (strm->zfree == (void (*)(voidpf opaque, voidpf address))0) {
+ __retres = 1;
+ goto return_label;
+ }
+ s = strm->state;
+ if (s == (deflate_state *)0) {
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (s->strm != strm) {
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (s->status != 42)
+ if (s->status != 57)
+ if (s->status != 69)
+ if (s->status != 73)
+ if (s->status != 91)
+ if (s->status != 103)
+ if (s->status != 113)
+ if (s->status != 666) {
+ __retres = 1;
+ goto return_label;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int deflateSetDictionary(z_streamp strm, Bytef const *dictionary_0,
+ uInt dictLength) __attribute__((__FC_OLDSTYLEPROTO__));
+int deflateSetDictionary(z_streamp strm, Bytef const *dictionary_0,
+ uInt dictLength)
+{
+ int __retres;
+ deflate_state *s;
+ uInt str;
+ uInt n;
+ int wrap;
+ unsigned int avail;
+ unsigned char *next;
+ int tmp;
+ uInt tmp_0;
+ tmp = deflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ else
+ if (dictionary_0 == (Bytef const *)0) {
+ __retres = -2;
+ goto return_label;
+ }
+ s = strm->state;
+ wrap = s->wrap;
+ if (wrap == 2) {
+ __retres = -2;
+ goto return_label;
+ }
+ else
+ if (wrap == 1) {
+ if (s->status != 42) {
+ __retres = -2;
+ goto return_label;
+ }
+ else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (s->lookahead) {
+ __retres = -2;
+ goto return_label;
+ }
+ }
+ if (wrap == 1) strm->adler = adler32(strm->adler,dictionary_0,dictLength);
+ s->wrap = 0;
+ if (dictLength >= s->w_size) {
+ if (wrap == 0) {
+ *(s->head + (s->hash_size - (uInt)1)) = (unsigned short)0;
+ memset((void *)s->head,0,
+ (unsigned long)(s->hash_size - (uInt)1) * sizeof(*(s->head)));
+ s->strstart = (unsigned int)0;
+ s->block_start = 0L;
+ s->insert = (unsigned int)0;
+ }
+ dictionary_0 += dictLength - s->w_size;
+ dictLength = s->w_size;
+ }
+ avail = strm->avail_in;
+ next = strm->next_in;
+ strm->avail_in = dictLength;
+ strm->next_in = (Bytef *)dictionary_0;
+ fill_window(s);
+ while (s->lookahead >= (uInt)3) {
+ str = s->strstart;
+ n = s->lookahead - (uInt)(3 - 1);
+ while (1) {
+ s->ins_h = ((s->ins_h << s->hash_shift) ^ (unsigned int)*(s->window + (
+ (str + (uInt)3) - (uInt)1))) & s->hash_mask;
+ *(s->prev + (str & s->w_mask)) = *(s->head + s->ins_h);
+ *(s->head + s->ins_h) = (unsigned short)str;
+ str ++;
+ n --;
+ if (! n) break;
+ }
+ s->strstart = str;
+ s->lookahead = (unsigned int)(3 - 1);
+ fill_window(s);
+ }
+ s->strstart += s->lookahead;
+ s->block_start = (long)s->strstart;
+ s->insert = s->lookahead;
+ s->lookahead = (unsigned int)0;
+ tmp_0 = (unsigned int)(3 - 1);
+ s->prev_length = tmp_0;
+ s->match_length = tmp_0;
+ s->match_available = 0;
+ strm->next_in = next;
+ strm->avail_in = avail;
+ s->wrap = wrap;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int deflateGetDictionary(z_streamp strm, Bytef *dictionary_0,
+ uInt *dictLength) __attribute__((__FC_OLDSTYLEPROTO__));
+int deflateGetDictionary(z_streamp strm, Bytef *dictionary_0,
+ uInt *dictLength)
+{
+ int __retres;
+ deflate_state *s;
+ uInt len;
+ int tmp;
+ tmp = deflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ s = strm->state;
+ len = s->strstart + s->lookahead;
+ if (len > s->w_size) len = s->w_size;
+ if (dictionary_0 != (Bytef *)0)
+ if (len) memcpy((void *)dictionary_0,
+ (void const *)(((s->window + s->strstart) + s->lookahead) - len),
+ (unsigned long)len);
+ if (dictLength != (uInt *)0) *dictLength = len;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int deflateResetKeep(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+int deflateResetKeep(z_streamp strm)
+{
+ int __retres;
+ deflate_state *s;
+ int tmp;
+ uLong tmp_0;
+ tmp = deflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ tmp_0 = (unsigned long)0;
+ strm->total_out = tmp_0;
+ strm->total_in = tmp_0;
+ strm->msg = (char *)0;
+ strm->data_type = 2;
+ s = strm->state;
+ s->pending = (unsigned long)0;
+ s->pending_out = s->pending_buf;
+ if (s->wrap < 0) s->wrap = - s->wrap;
+ if (s->wrap == 2) s->status = 57;
+ else {
+ int tmp_1;
+ if (s->wrap) tmp_1 = 42; else tmp_1 = 113;
+ s->status = tmp_1;
+ }
+ if (s->wrap == 2) strm->adler = crc32((unsigned long)0L,(Bytef const *)0,
+ (unsigned int)0);
+ else strm->adler = adler32((unsigned long)0L,(Bytef const *)0,
+ (unsigned int)0);
+ s->last_flush = 0;
+ _tr_init(s);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int deflateReset(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+int deflateReset(z_streamp strm)
+{
+ int ret;
+ ret = deflateResetKeep(strm);
+ if (ret == 0) lm_init(strm->state);
+ return ret;
+}
+
+int deflateSetHeader(z_streamp strm, gz_headerp head) __attribute__((
+__FC_OLDSTYLEPROTO__));
+int deflateSetHeader(z_streamp strm, gz_headerp head)
+{
+ int __retres;
+ int tmp;
+ tmp = deflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ else
+ if ((strm->state)->wrap != 2) {
+ __retres = -2;
+ goto return_label;
+ }
+ (strm->state)->gzhead = head;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int deflatePending(z_streamp strm, unsigned int *pending, int *bits) __attribute__((
+__FC_OLDSTYLEPROTO__));
+int deflatePending(z_streamp strm, unsigned int *pending, int *bits)
+{
+ int __retres;
+ int tmp;
+ tmp = deflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ if (pending != (unsigned int *)0) *pending = (unsigned int)(strm->state)->pending;
+ if (bits != (int *)0) *bits = (strm->state)->bi_valid;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int deflatePrime(z_streamp strm, int bits, int value) __attribute__((
+__FC_OLDSTYLEPROTO__));
+int deflatePrime(z_streamp strm, int bits, int value)
+{
+ int __retres;
+ deflate_state *s;
+ int put;
+ int tmp;
+ tmp = deflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ s = strm->state;
+ if ((Bytef *)s->d_buf < s->pending_out + ((16 + 7) >> 3)) {
+ __retres = -5;
+ goto return_label;
+ }
+ while (1) {
+ put = 16 - s->bi_valid;
+ if (put > bits) put = bits;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | (int)((unsigned short)(
+ (value & ((1 << put) - 1)) << s->bi_valid)));
+ s->bi_valid += put;
+ _tr_flush_bits(s);
+ value >>= put;
+ bits -= put;
+ if (! bits) break;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int deflateParams(z_streamp strm, int level, int strategy) __attribute__((
+__FC_OLDSTYLEPROTO__));
+int deflateParams(z_streamp strm, int level, int strategy)
+{
+ int __retres;
+ deflate_state *s;
+ block_state (*func)(deflate_state *s, int flush);
+ int tmp;
+ tmp = deflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ s = strm->state;
+ if (level == -1) level = 6;
+ if (level < 0) goto _LOR;
+ else
+ if (level > 9) goto _LOR;
+ else
+ if (strategy < 0) goto _LOR;
+ else
+ if (strategy > 4) {
+ _LOR: {
+ __retres = -2;
+ goto return_label;
+ }
+ }
+ func = configuration_table[s->level].func;
+ if (strategy != s->strategy) goto _LOR_0;
+ else
+ if (func != configuration_table[level].func) {
+ _LOR_0: ;
+ if (s->high_water) {
+ int err = deflate(strm,5);
+ if (err == -2) {
+ __retres = err;
+ goto return_label;
+ }
+ if (strm->avail_out == (uInt)0) {
+ __retres = -5;
+ goto return_label;
+ }
+ }
+ }
+ if (s->level != level) {
+ if (s->level == 0)
+ if (s->matches != (uInt)0) {
+ if (s->matches == (uInt)1) slide_hash(s);
+ else *(s->head + (s->hash_size - (uInt)1)) = (unsigned short)0;
+ memset((void *)s->head,0,
+ (unsigned long)(s->hash_size - (uInt)1) * sizeof(*(s->head)));
+ s->matches = (unsigned int)0;
+ }
+ s->level = level;
+ s->max_lazy_match = (unsigned int)configuration_table[level].max_lazy;
+ s->good_match = (unsigned int)configuration_table[level].good_length;
+ s->nice_match = (int)configuration_table[level].nice_length;
+ s->max_chain_length = (unsigned int)configuration_table[level].max_chain;
+ }
+ s->strategy = strategy;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int deflateTune(z_streamp strm, int good_length, int max_lazy,
+ int nice_length, int max_chain) __attribute__((__FC_OLDSTYLEPROTO__));
+int deflateTune(z_streamp strm, int good_length, int max_lazy,
+ int nice_length, int max_chain)
+{
+ int __retres;
+ deflate_state *s;
+ int tmp;
+ tmp = deflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ s = strm->state;
+ s->good_match = (unsigned int)good_length;
+ s->max_lazy_match = (unsigned int)max_lazy;
+ s->nice_match = nice_length;
+ s->max_chain_length = (unsigned int)max_chain;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+uLong deflateBound(z_streamp strm, uLong sourceLen) __attribute__((__FC_OLDSTYLEPROTO__));
+uLong deflateBound(z_streamp strm, uLong sourceLen)
+{
+ uLong __retres;
+ deflate_state *s;
+ uLong complen;
+ uLong wraplen;
+ int tmp;
+ complen = ((sourceLen + ((sourceLen + (uLong)7) >> 3)) + ((sourceLen + (uLong)63) >> 6)) + (uLong)5;
+ tmp = deflateStateCheck(strm);
+ if (tmp) {
+ __retres = complen + (uLong)6;
+ goto return_label;
+ }
+ s = strm->state;
+ switch (s->wrap) {
+ int tmp_0;
+ case 0: wraplen = (unsigned long)0;
+ break;
+ case 1:
+ { /* sequence */
+ if (s->strstart) tmp_0 = 4; else tmp_0 = 0;
+ wraplen = (unsigned long)(6 + tmp_0);
+ }
+ break;
+ case 2: wraplen = (unsigned long)18;
+ if (s->gzhead != (gz_headerp)0) {
+ Bytef *str;
+ if ((s->gzhead)->extra != (Bytef *)0) wraplen += (uLong)((uInt)2 + (s->gzhead)->extra_len);
+ str = (s->gzhead)->name;
+ if (str != (Bytef *)0)
+ while (1) {
+ Bytef *tmp_1;
+ wraplen ++;
+ tmp_1 = str;
+ str ++;
+ ;
+ if (! *tmp_1) break;
+ }
+ str = (s->gzhead)->comment;
+ if (str != (Bytef *)0)
+ while (1) {
+ Bytef *tmp_2;
+ wraplen ++;
+ tmp_2 = str;
+ str ++;
+ ;
+ if (! *tmp_2) break;
+ }
+ if ((s->gzhead)->hcrc) wraplen += (uLong)2;
+ }
+ break;
+ default: wraplen = (unsigned long)6;
+ }
+ if (s->w_bits != (uInt)15) {
+ __retres = complen + wraplen;
+ goto return_label;
+ }
+ else
+ if (s->hash_bits != (uInt)(8 + 7)) {
+ __retres = complen + wraplen;
+ goto return_label;
+ }
+ __retres = (((((sourceLen + (sourceLen >> 12)) + (sourceLen >> 14)) + (
+ sourceLen >> 25)) + (uLong)13) - (uLong)6) + wraplen;
+ return_label: return __retres;
+}
+
+static void putShortMSB(deflate_state *s, uInt b) __attribute__((__FC_OLDSTYLEPROTO__));
+static void putShortMSB(deflate_state *s, uInt b)
+{
+ {
+ ulg tmp;
+ tmp = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp) = (unsigned char)(b >> 8);
+ }
+ {
+ ulg tmp_0;
+ tmp_0 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_0) = (unsigned char)(b & (unsigned int)0xff);
+ }
+ return;
+}
+
+static void flush_pending(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+static void flush_pending(z_streamp strm)
+{
+ unsigned int len;
+ deflate_state *s = strm->state;
+ _tr_flush_bits(s);
+ len = (unsigned int)s->pending;
+ if (len > strm->avail_out) len = strm->avail_out;
+ if (len == (unsigned int)0) goto return_label;
+ memcpy((void *)strm->next_out,(void const *)s->pending_out,
+ (unsigned long)len);
+ strm->next_out += len;
+ s->pending_out += len;
+ strm->total_out += (uLong)len;
+ strm->avail_out -= len;
+ s->pending -= (ulg)len;
+ if (s->pending == (ulg)0) s->pending_out = s->pending_buf;
+ return_label: return;
+}
+
+int deflate(z_streamp strm, int flush) __attribute__((__FC_OLDSTYLEPROTO__));
+int deflate(z_streamp strm, int flush)
+{
+ int __retres;
+ int old_flush;
+ deflate_state *s;
+ int tmp;
+ int tmp_50;
+ tmp = deflateStateCheck(strm);
+ if (tmp) goto _LOR;
+ else
+ if (flush > 5) goto _LOR;
+ else
+ if (flush < 0) {
+ _LOR: {
+ __retres = -2;
+ goto return_label;
+ }
+ }
+ s = strm->state;
+ if (strm->next_out == (Bytef *)0) goto _LOR_0;
+ else
+ if (strm->avail_in != (uInt)0) {
+ if (strm->next_in == (Bytef *)0) goto _LOR_0; else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (s->status == 666)
+ if (flush != 4) {
+ _LOR_0:
+ {
+ strm->msg = z_errmsg[2 - -2];
+ __retres = -2;
+ goto return_label;
+ }
+ }
+ }
+ if (strm->avail_out == (uInt)0) {
+ strm->msg = z_errmsg[2 - -5];
+ __retres = -5;
+ goto return_label;
+ }
+ old_flush = s->last_flush;
+ s->last_flush = flush;
+ if (s->pending != (ulg)0) {
+ flush_pending(strm);
+ if (strm->avail_out == (uInt)0) {
+ s->last_flush = -1;
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else
+ if (strm->avail_in == (uInt)0) {
+ int tmp_0;
+ int tmp_1;
+ if (flush > 4) tmp_0 = 9; else tmp_0 = 0;
+ if (old_flush > 4) tmp_1 = 9; else tmp_1 = 0;
+ ;
+ if (flush * 2 - tmp_0 <= old_flush * 2 - tmp_1)
+ if (flush != 4) {
+ strm->msg = z_errmsg[2 - -5];
+ __retres = -5;
+ goto return_label;
+ }
+ }
+ if (s->status == 666)
+ if (strm->avail_in != (uInt)0) {
+ strm->msg = z_errmsg[2 - -5];
+ __retres = -5;
+ goto return_label;
+ }
+ if (s->status == 42) {
+ uInt level_flags;
+ uInt header = ((uInt)8 + ((s->w_bits - (uInt)8) << 4)) << 8;
+ if (s->strategy >= 2) level_flags = (unsigned int)0;
+ else
+ if (s->level < 2) level_flags = (unsigned int)0;
+ else
+ if (s->level < 6) level_flags = (unsigned int)1;
+ else
+ if (s->level == 6) level_flags = (unsigned int)2;
+ else level_flags = (unsigned int)3;
+ header |= level_flags << 6;
+ if (s->strstart != (uInt)0) header |= (unsigned int)0x20;
+ header += (unsigned int)31 - header % (unsigned int)31;
+ putShortMSB(s,header);
+ if (s->strstart != (uInt)0) {
+ putShortMSB(s,(unsigned int)(strm->adler >> 16));
+ putShortMSB(s,(unsigned int)(strm->adler & (unsigned long)0xffff));
+ }
+ strm->adler = adler32((unsigned long)0L,(Bytef const *)0,(unsigned int)0);
+ s->status = 113;
+ flush_pending(strm);
+ if (s->pending != (ulg)0) {
+ s->last_flush = -1;
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (s->status == 57) {
+ strm->adler = crc32((unsigned long)0L,(Bytef const *)0,(unsigned int)0);
+ {
+ ulg tmp_2;
+ tmp_2 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_2) = (unsigned char)31;
+ }
+ {
+ ulg tmp_3;
+ tmp_3 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_3) = (unsigned char)139;
+ }
+ {
+ ulg tmp_4;
+ tmp_4 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_4) = (unsigned char)8;
+ }
+ if (s->gzhead == (gz_headerp)0) {
+ {
+ ulg tmp_5;
+ tmp_5 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_5) = (unsigned char)0;
+ }
+ {
+ ulg tmp_6;
+ tmp_6 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_6) = (unsigned char)0;
+ }
+ {
+ ulg tmp_7;
+ tmp_7 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_7) = (unsigned char)0;
+ }
+ {
+ ulg tmp_8;
+ tmp_8 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_8) = (unsigned char)0;
+ }
+ {
+ ulg tmp_9;
+ tmp_9 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_9) = (unsigned char)0;
+ }
+ {
+ ulg tmp_10;
+ int tmp_12;
+ tmp_10 = s->pending;
+ (s->pending) ++;
+ if (s->level == 9) tmp_12 = 2;
+ else {
+ int tmp_11;
+ if (s->strategy >= 2) tmp_11 = 4;
+ else
+ if (s->level < 2) tmp_11 = 4; else tmp_11 = 0;
+ tmp_12 = tmp_11;
+ }
+ *(s->pending_buf + tmp_10) = (unsigned char)tmp_12;
+ }
+ {
+ ulg tmp_13;
+ tmp_13 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_13) = (unsigned char)3;
+ }
+ s->status = 113;
+ flush_pending(strm);
+ if (s->pending != (ulg)0) {
+ s->last_flush = -1;
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ else {
+ {
+ ulg tmp_14;
+ int tmp_15;
+ int tmp_16;
+ int tmp_17;
+ int tmp_18;
+ int tmp_19;
+ tmp_14 = s->pending;
+ (s->pending) ++;
+ if ((s->gzhead)->text) tmp_15 = 1; else tmp_15 = 0;
+ if ((s->gzhead)->hcrc) tmp_16 = 2; else tmp_16 = 0;
+ if ((s->gzhead)->extra == (Bytef *)0) tmp_17 = 0; else tmp_17 = 4;
+ if ((s->gzhead)->name == (Bytef *)0) tmp_18 = 0; else tmp_18 = 8;
+ if ((s->gzhead)->comment == (Bytef *)0) tmp_19 = 0; else tmp_19 = 16;
+ *(s->pending_buf + tmp_14) = (unsigned char)((((tmp_15 + tmp_16) + tmp_17) + tmp_18) + tmp_19);
+ }
+ {
+ ulg tmp_20;
+ tmp_20 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_20) = (unsigned char)((s->gzhead)->time & (unsigned long)0xff);
+ }
+ {
+ ulg tmp_21;
+ tmp_21 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_21) = (unsigned char)(((s->gzhead)->time >> 8) & (unsigned long)0xff);
+ }
+ {
+ ulg tmp_22;
+ tmp_22 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_22) = (unsigned char)(((s->gzhead)->time >> 16) & (unsigned long)0xff);
+ }
+ {
+ ulg tmp_23;
+ tmp_23 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_23) = (unsigned char)(((s->gzhead)->time >> 24) & (unsigned long)0xff);
+ }
+ {
+ ulg tmp_24;
+ int tmp_26;
+ tmp_24 = s->pending;
+ (s->pending) ++;
+ if (s->level == 9) tmp_26 = 2;
+ else {
+ int tmp_25;
+ if (s->strategy >= 2) tmp_25 = 4;
+ else
+ if (s->level < 2) tmp_25 = 4; else tmp_25 = 0;
+ tmp_26 = tmp_25;
+ }
+ *(s->pending_buf + tmp_24) = (unsigned char)tmp_26;
+ }
+ {
+ ulg tmp_27;
+ tmp_27 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_27) = (unsigned char)((s->gzhead)->os & 0xff);
+ }
+ if ((s->gzhead)->extra != (Bytef *)0) {
+ {
+ ulg tmp_28;
+ tmp_28 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_28) = (unsigned char)((s->gzhead)->extra_len & (unsigned int)0xff);
+ }
+ {
+ ulg tmp_29;
+ tmp_29 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_29) = (unsigned char)(((s->gzhead)->extra_len >> 8) & (unsigned int)0xff);
+ }
+ }
+ if ((s->gzhead)->hcrc) strm->adler = crc32(strm->adler,
+ (Bytef const *)s->pending_buf,
+ (unsigned int)s->pending);
+ s->gzindex = (unsigned long)0;
+ s->status = 69;
+ }
+ }
+ if (s->status == 69) {
+ if ((s->gzhead)->extra != (Bytef *)0) {
+ ulg beg = s->pending;
+ uInt left =
+ (unsigned int)((ulg)((s->gzhead)->extra_len & (unsigned int)0xffff) - s->gzindex);
+ while (s->pending + (ulg)left > s->pending_buf_size) {
+ uInt copy = (unsigned int)(s->pending_buf_size - s->pending);
+ memcpy((void *)(s->pending_buf + s->pending),
+ (void const *)((s->gzhead)->extra + s->gzindex),
+ (unsigned long)copy);
+ s->pending = s->pending_buf_size;
+ if ((s->gzhead)->hcrc)
+ if (s->pending > beg) strm->adler = crc32(strm->adler,
+ (Bytef const *)(s->pending_buf + beg),
+ (unsigned int)(s->pending - beg));
+ s->gzindex += (ulg)copy;
+ flush_pending(strm);
+ if (s->pending != (ulg)0) {
+ s->last_flush = -1;
+ __retres = 0;
+ goto return_label;
+ }
+ beg = (unsigned long)0;
+ left -= copy;
+ }
+ memcpy((void *)(s->pending_buf + s->pending),
+ (void const *)((s->gzhead)->extra + s->gzindex),
+ (unsigned long)left);
+ s->pending += (ulg)left;
+ if ((s->gzhead)->hcrc)
+ if (s->pending > beg) strm->adler = crc32(strm->adler,
+ (Bytef const *)(s->pending_buf + beg),
+ (unsigned int)(s->pending - beg));
+ s->gzindex = (unsigned long)0;
+ }
+ s->status = 73;
+ }
+ if (s->status == 73) {
+ if ((s->gzhead)->name != (Bytef *)0) {
+ int val;
+ ulg beg_0 = s->pending;
+ while (1) {
+ {
+ ulg tmp_30;
+ if (s->pending == s->pending_buf_size) {
+ if ((s->gzhead)->hcrc)
+ if (s->pending > beg_0) strm->adler = crc32(strm->adler,
+ (Bytef const *)(
+ s->pending_buf + beg_0),
+ (unsigned int)(
+ s->pending - beg_0));
+ flush_pending(strm);
+ if (s->pending != (ulg)0) {
+ s->last_flush = -1;
+ __retres = 0;
+ goto return_label;
+ }
+ beg_0 = (unsigned long)0;
+ }
+ tmp_30 = s->gzindex;
+ (s->gzindex) ++;
+ val = (int)*((s->gzhead)->name + tmp_30);
+ {
+ ulg tmp_31;
+ tmp_31 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_31) = (unsigned char)val;
+ }
+ }
+ if (! (val != 0)) break;
+ }
+ if ((s->gzhead)->hcrc)
+ if (s->pending > beg_0) strm->adler = crc32(strm->adler,
+ (Bytef const *)(s->pending_buf + beg_0),
+ (unsigned int)(s->pending - beg_0));
+ s->gzindex = (unsigned long)0;
+ }
+ s->status = 91;
+ }
+ if (s->status == 91) {
+ if ((s->gzhead)->comment != (Bytef *)0) {
+ int val_0;
+ ulg beg_1 = s->pending;
+ while (1) {
+ {
+ ulg tmp_32;
+ if (s->pending == s->pending_buf_size) {
+ if ((s->gzhead)->hcrc)
+ if (s->pending > beg_1) strm->adler = crc32(strm->adler,
+ (Bytef const *)(
+ s->pending_buf + beg_1),
+ (unsigned int)(
+ s->pending - beg_1));
+ flush_pending(strm);
+ if (s->pending != (ulg)0) {
+ s->last_flush = -1;
+ __retres = 0;
+ goto return_label;
+ }
+ beg_1 = (unsigned long)0;
+ }
+ tmp_32 = s->gzindex;
+ (s->gzindex) ++;
+ val_0 = (int)*((s->gzhead)->comment + tmp_32);
+ {
+ ulg tmp_33;
+ tmp_33 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_33) = (unsigned char)val_0;
+ }
+ }
+ if (! (val_0 != 0)) break;
+ }
+ if ((s->gzhead)->hcrc)
+ if (s->pending > beg_1) strm->adler = crc32(strm->adler,
+ (Bytef const *)(s->pending_buf + beg_1),
+ (unsigned int)(s->pending - beg_1));
+ }
+ s->status = 103;
+ }
+ if (s->status == 103) {
+ if ((s->gzhead)->hcrc) {
+ if (s->pending + (ulg)2 > s->pending_buf_size) {
+ flush_pending(strm);
+ if (s->pending != (ulg)0) {
+ s->last_flush = -1;
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ {
+ ulg tmp_34;
+ tmp_34 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_34) = (unsigned char)(strm->adler & (unsigned long)0xff);
+ }
+ {
+ ulg tmp_35;
+ tmp_35 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_35) = (unsigned char)((strm->adler >> 8) & (unsigned long)0xff);
+ }
+ strm->adler = crc32((unsigned long)0L,(Bytef const *)0,(unsigned int)0);
+ }
+ s->status = 113;
+ flush_pending(strm);
+ if (s->pending != (ulg)0) {
+ s->last_flush = -1;
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (strm->avail_in != (uInt)0) goto _LOR_3;
+ else
+ if (s->lookahead != (uInt)0) goto _LOR_3;
+ else
+ if (flush != 0)
+ if (s->status != 666) {
+ _LOR_3:
+ {
+ block_state bstate;
+ if (s->level == 0) bstate = deflate_stored(s,flush);
+ else {
+ unsigned int tmp_41;
+ if (s->strategy == 2) {
+ block_state tmp_37;
+ tmp_37 = deflate_huff(s,flush);
+ tmp_41 = tmp_37;
+ }
+ else {
+ unsigned int tmp_40;
+ if (s->strategy == 3) {
+ block_state tmp_38;
+ tmp_38 = deflate_rle(s,flush);
+ tmp_40 = tmp_38;
+ }
+ else {
+ block_state tmp_39;
+ tmp_39 = (*(configuration_table[s->level].func))(s,flush);
+ tmp_40 = tmp_39;
+ }
+ tmp_41 = tmp_40;
+ }
+ bstate = tmp_41;
+ }
+ if (bstate == (unsigned int)finish_started) goto _LOR_1;
+ else
+ if (bstate == (unsigned int)finish_done) _LOR_1:
+ s->status = 666;
+ if (bstate == (unsigned int)need_more) goto _LOR_2;
+ else
+ if (bstate == (unsigned int)finish_started) {
+ _LOR_2:
+ {
+ if (strm->avail_out == (uInt)0) s->last_flush = -1;
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (bstate == (unsigned int)block_done) {
+ if (flush == 1) _tr_align(s);
+ else
+ if (flush != 5) {
+ _tr_stored_block(s,(char *)0,(unsigned long)0L,0);
+ if (flush == 3) {
+ *(s->head + (s->hash_size - (uInt)1)) = (unsigned short)0;
+ memset((void *)s->head,0,
+ (unsigned long)(s->hash_size - (uInt)1) * sizeof(*(s->head)));
+ if (s->lookahead == (uInt)0) {
+ s->strstart = (unsigned int)0;
+ s->block_start = 0L;
+ s->insert = (unsigned int)0;
+ }
+ }
+ }
+ flush_pending(strm);
+ if (strm->avail_out == (uInt)0) {
+ s->last_flush = -1;
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ }
+ }
+ if (flush != 4) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (s->wrap <= 0) {
+ __retres = 1;
+ goto return_label;
+ }
+ if (s->wrap == 2) {
+ {
+ ulg tmp_42;
+ tmp_42 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_42) = (unsigned char)(strm->adler & (unsigned long)0xff);
+ }
+ {
+ ulg tmp_43;
+ tmp_43 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_43) = (unsigned char)((strm->adler >> 8) & (unsigned long)0xff);
+ }
+ {
+ ulg tmp_44;
+ tmp_44 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_44) = (unsigned char)((strm->adler >> 16) & (unsigned long)0xff);
+ }
+ {
+ ulg tmp_45;
+ tmp_45 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_45) = (unsigned char)((strm->adler >> 24) & (unsigned long)0xff);
+ }
+ {
+ ulg tmp_46;
+ tmp_46 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_46) = (unsigned char)(strm->total_in & (unsigned long)0xff);
+ }
+ {
+ ulg tmp_47;
+ tmp_47 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_47) = (unsigned char)((strm->total_in >> 8) & (unsigned long)0xff);
+ }
+ {
+ ulg tmp_48;
+ tmp_48 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_48) = (unsigned char)((strm->total_in >> 16) & (unsigned long)0xff);
+ }
+ {
+ ulg tmp_49;
+ tmp_49 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_49) = (unsigned char)((strm->total_in >> 24) & (unsigned long)0xff);
+ }
+ }
+ else {
+ putShortMSB(s,(unsigned int)(strm->adler >> 16));
+ putShortMSB(s,(unsigned int)(strm->adler & (unsigned long)0xffff));
+ }
+ flush_pending(strm);
+ if (s->wrap > 0) s->wrap = - s->wrap;
+ if (s->pending != (ulg)0) tmp_50 = 0; else tmp_50 = 1;
+ __retres = tmp_50;
+ return_label: return __retres;
+}
+
+int deflateEnd(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+int deflateEnd(z_streamp strm)
+{
+ int __retres;
+ int status;
+ int tmp;
+ int tmp_0;
+ tmp = deflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ status = (strm->state)->status;
+ if ((strm->state)->pending_buf) (*(strm->zfree))(strm->opaque,
+ (void *)(strm->state)->pending_buf);
+ if ((strm->state)->head) (*(strm->zfree))(strm->opaque,
+ (void *)(strm->state)->head);
+ if ((strm->state)->prev) (*(strm->zfree))(strm->opaque,
+ (void *)(strm->state)->prev);
+ if ((strm->state)->window) (*(strm->zfree))(strm->opaque,
+ (void *)(strm->state)->window);
+ (*(strm->zfree))(strm->opaque,(void *)strm->state);
+ strm->state = (struct internal_state *)0;
+ if (status == 113) tmp_0 = -3; else tmp_0 = 0;
+ __retres = tmp_0;
+ return_label: return __retres;
+}
+
+int deflateCopy(z_streamp dest, z_streamp source) __attribute__((__FC_OLDSTYLEPROTO__));
+int deflateCopy(z_streamp dest, z_streamp source)
+{
+ int __retres;
+ deflate_state *ds;
+ deflate_state *ss;
+ ushf *overlay;
+ int tmp;
+ tmp = deflateStateCheck(source);
+ if (tmp) goto _LOR;
+ else
+ if (dest == (z_streamp)0) {
+ _LOR: {
+ __retres = -2;
+ goto return_label;
+ }
+ }
+ ss = source->state;
+ memcpy((void *)dest,(void const *)source,sizeof(z_stream));
+ ds = (deflate_state *)(*(dest->zalloc))(dest->opaque,(unsigned int)1,
+ (unsigned int)sizeof(deflate_state));
+ if (ds == (deflate_state *)0) {
+ __retres = -4;
+ goto return_label;
+ }
+ dest->state = ds;
+ memcpy((void *)ds,(void const *)ss,sizeof(deflate_state));
+ ds->strm = dest;
+ ds->window = (Bytef *)(*(dest->zalloc))(dest->opaque,ds->w_size,
+ (unsigned int)((unsigned long)2 * sizeof(Byte)));
+ ds->prev = (Posf *)(*(dest->zalloc))(dest->opaque,ds->w_size,
+ (unsigned int)sizeof(Pos));
+ ds->head = (Posf *)(*(dest->zalloc))(dest->opaque,ds->hash_size,
+ (unsigned int)sizeof(Pos));
+ overlay = (ushf *)(*(dest->zalloc))(dest->opaque,ds->lit_bufsize,
+ (unsigned int)(sizeof(ush) + (unsigned long)2));
+ ds->pending_buf = (uchf *)overlay;
+ if (ds->window == (Bytef *)0) goto _LOR_0;
+ else
+ if (ds->prev == (Posf *)0) goto _LOR_0;
+ else
+ if (ds->head == (Posf *)0) goto _LOR_0;
+ else
+ if (ds->pending_buf == (Bytef *)0) {
+ _LOR_0: {
+ deflateEnd(dest);
+ __retres = -4;
+ goto return_label;
+ }
+ }
+ memcpy((void *)ds->window,(void const *)ss->window,
+ (unsigned long)(ds->w_size * (uInt)2) * sizeof(Byte));
+ memcpy((void *)ds->prev,(void const *)ss->prev,
+ (unsigned long)ds->w_size * sizeof(Pos));
+ memcpy((void *)ds->head,(void const *)ss->head,
+ (unsigned long)ds->hash_size * sizeof(Pos));
+ memcpy((void *)ds->pending_buf,(void const *)ss->pending_buf,
+ (unsigned long)((unsigned int)ds->pending_buf_size));
+ ds->pending_out = ds->pending_buf + (ss->pending_out - ss->pending_buf);
+ ds->d_buf = overlay + (unsigned long)ds->lit_bufsize / sizeof(ush);
+ ds->l_buf = ds->pending_buf + ((unsigned long)1 + sizeof(ush)) * (unsigned long)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;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static unsigned int read_buf(z_streamp strm, Bytef *buf, unsigned int size) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static unsigned int read_buf(z_streamp strm, Bytef *buf, unsigned int size)
+{
+ unsigned int __retres;
+ unsigned int len = strm->avail_in;
+ if (len > size) len = size;
+ if (len == (unsigned int)0) {
+ __retres = (unsigned int)0;
+ goto return_label;
+ }
+ strm->avail_in -= len;
+ memcpy((void *)buf,(void const *)strm->next_in,(unsigned long)len);
+ if ((strm->state)->wrap == 1) strm->adler = adler32(strm->adler,
+ (Bytef const *)buf,len);
+ else
+ if ((strm->state)->wrap == 2) strm->adler = crc32(strm->adler,
+ (Bytef const *)buf,len);
+ strm->next_in += len;
+ strm->total_in += (uLong)len;
+ __retres = len;
+ return_label: return __retres;
+}
+
+static void lm_init(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+static void lm_init(deflate_state *s)
+{
+ uInt tmp;
+ s->window_size = (unsigned long)2L * (unsigned long)s->w_size;
+ *(s->head + (s->hash_size - (uInt)1)) = (unsigned short)0;
+ memset((void *)s->head,0,
+ (unsigned long)(s->hash_size - (uInt)1) * sizeof(*(s->head)));
+ s->max_lazy_match = (unsigned int)configuration_table[s->level].max_lazy;
+ s->good_match = (unsigned int)configuration_table[s->level].good_length;
+ s->nice_match = (int)configuration_table[s->level].nice_length;
+ s->max_chain_length = (unsigned int)configuration_table[s->level].max_chain;
+ s->strstart = (unsigned int)0;
+ s->block_start = 0L;
+ s->lookahead = (unsigned int)0;
+ s->insert = (unsigned int)0;
+ tmp = (unsigned int)(3 - 1);
+ s->prev_length = tmp;
+ s->match_length = tmp;
+ s->match_available = 0;
+ s->ins_h = (unsigned int)0;
+ return;
+}
+
+static uInt longest_match(deflate_state *s, IPos cur_match) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static uInt longest_match(deflate_state *s, IPos cur_match)
+{
+ uInt __retres;
+ register Bytef *match;
+ register int len;
+ uInt tmp;
+ unsigned int chain_length = s->max_chain_length;
+ register Bytef *scan = s->window + s->strstart;
+ int best_len = (int)s->prev_length;
+ int nice_match = s->nice_match;
+ if (s->strstart > s->w_size - (uInt)((258 + 3) + 1)) tmp = s->strstart - (
+ s->w_size - (uInt)(
+ (258 + 3) + 1));
+ else tmp = (unsigned int)0;
+ IPos limit = tmp;
+ Posf *prev = s->prev;
+ uInt wmask = s->w_mask;
+ register Bytef *strend = (s->window + s->strstart) + 258;
+ register Byte scan_end1 = *(scan + (best_len - 1));
+ register Byte scan_end = *(scan + best_len);
+ if (s->prev_length >= s->good_match) chain_length >>= 2;
+ if ((unsigned int)nice_match > s->lookahead) nice_match = (int)s->lookahead;
+ while (1) {
+ match = s->window + cur_match;
+ if ((int)*(match + best_len) != (int)scan_end) goto __Cont;
+ else
+ if ((int)*(match + (best_len - 1)) != (int)scan_end1) goto __Cont;
+ else
+ if ((int)*match != (int)*scan) goto __Cont;
+ else {
+ match ++;
+ ;
+ if ((int)*match != (int)*(scan + 1)) goto __Cont;
+ }
+ scan += 2;
+ match ++;
+ while (1) {
+ scan ++;
+ match ++;
+ ;
+ if ((int)*scan == (int)*match) {
+ scan ++;
+ match ++;
+ ;
+ if ((int)*scan == (int)*match) {
+ scan ++;
+ match ++;
+ ;
+ if ((int)*scan == (int)*match) {
+ scan ++;
+ match ++;
+ ;
+ if ((int)*scan == (int)*match) {
+ scan ++;
+ match ++;
+ ;
+ if ((int)*scan == (int)*match) {
+ scan ++;
+ match ++;
+ ;
+ if ((int)*scan == (int)*match) {
+ scan ++;
+ match ++;
+ ;
+ if ((int)*scan == (int)*match) {
+ scan ++;
+ match ++;
+ ;
+ if ((int)*scan == (int)*match) {
+ if (! (scan < strend)) break;
+ }
+ else break;
+ }
+ else break;
+ }
+ else break;
+ }
+ else break;
+ }
+ else break;
+ }
+ else break;
+ }
+ else break;
+ }
+ else break;
+ }
+ len = 258 - (int)(strend - scan);
+ scan = strend - 258;
+ if (len > best_len) {
+ s->match_start = cur_match;
+ best_len = len;
+ if (len >= nice_match) break;
+ scan_end1 = *(scan + (best_len - 1));
+ scan_end = *(scan + best_len);
+ }
+ __Cont:
+ { /* sequence */
+ cur_match = (unsigned int)*(prev + (cur_match & wmask));
+ ;
+ }
+ if (cur_match > limit) {
+ chain_length --;
+ if (! (chain_length != (unsigned int)0)) break;
+ }
+ else break;
+ }
+ if ((unsigned int)best_len <= s->lookahead) {
+ __retres = (unsigned int)best_len;
+ goto return_label;
+ }
+ __retres = s->lookahead;
+ return_label: return __retres;
+}
+
+static void fill_window(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+static void fill_window(deflate_state *s)
+{
+ unsigned int n;
+ unsigned int more;
+ uInt wsize = s->w_size;
+ while (1) {
+ more = (unsigned int)((s->window_size - (unsigned long)s->lookahead) - (unsigned long)s->strstart);
+ if (sizeof(int) <= (unsigned long)2)
+ if (more == (unsigned int)0) {
+ if (s->strstart == (uInt)0) {
+ if (s->lookahead == (uInt)0) more = wsize; else goto _LAND_0;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if (more == (unsigned int)(-1)) more --;
+ }
+ if (s->strstart >= wsize + (s->w_size - (uInt)((258 + 3) + 1))) {
+ memcpy((void *)s->window,(void const *)(s->window + wsize),
+ (unsigned long)(wsize - more));
+ s->match_start -= wsize;
+ s->strstart -= wsize;
+ s->block_start -= (long)wsize;
+ slide_hash(s);
+ more += wsize;
+ }
+ if ((s->strm)->avail_in == (uInt)0) break;
+ n = read_buf(s->strm,(s->window + s->strstart) + s->lookahead,more);
+ s->lookahead += n;
+ if (s->lookahead + s->insert >= (uInt)3) {
+ uInt str = s->strstart - s->insert;
+ s->ins_h = (unsigned int)*(s->window + str);
+ s->ins_h = ((s->ins_h << s->hash_shift) ^ (unsigned int)*(s->window + (
+ str + (uInt)1))) & s->hash_mask;
+ while (s->insert) {
+ s->ins_h = ((s->ins_h << s->hash_shift) ^ (unsigned int)*(s->window + (
+ (str + (uInt)3) - (uInt)1))) & s->hash_mask;
+ *(s->prev + (str & s->w_mask)) = *(s->head + s->ins_h);
+ *(s->head + s->ins_h) = (unsigned short)str;
+ str ++;
+ (s->insert) --;
+ if (s->lookahead + s->insert < (uInt)3) break;
+ }
+ }
+ if (s->lookahead < (uInt)((258 + 3) + 1)) {
+ if (! ((s->strm)->avail_in != (uInt)0)) break;
+ }
+ else break;
+ }
+ if (s->high_water < s->window_size) {
+ ulg init;
+ ulg curr = (unsigned long)s->strstart + (unsigned long)s->lookahead;
+ if (s->high_water < curr) {
+ init = s->window_size - curr;
+ if (init > (ulg)258) init = (unsigned long)258;
+ memset((void *)(s->window + curr),0,
+ (unsigned long)((unsigned int)init));
+ s->high_water = curr + init;
+ }
+ else
+ if (s->high_water < curr + (unsigned long)258) {
+ init = (curr + (unsigned long)258) - s->high_water;
+ if (init > s->window_size - s->high_water) init = s->window_size - s->high_water;
+ memset((void *)(s->window + s->high_water),0,
+ (unsigned long)((unsigned int)init));
+ s->high_water += init;
+ }
+ }
+ return;
+}
+
+static block_state deflate_stored(deflate_state *s, int flush) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static block_state deflate_stored(deflate_state *s, int flush)
+{
+ block_state __retres;
+ ulg tmp;
+ unsigned int len;
+ unsigned int left;
+ unsigned int have;
+ int tmp_1;
+ if (s->pending_buf_size - (ulg)5 > (ulg)s->w_size) tmp = (unsigned long)s->w_size;
+ else tmp = s->pending_buf_size - (ulg)5;
+ unsigned int min_block = (unsigned int)tmp;
+ unsigned int last = (unsigned int)0;
+ unsigned int used = (s->strm)->avail_in;
+ while (1) {
+ len = (unsigned int)65535;
+ have = (unsigned int)((s->bi_valid + 42) >> 3);
+ if ((s->strm)->avail_out < have) break;
+ have = (s->strm)->avail_out - have;
+ left = (unsigned int)((long)s->strstart - s->block_start);
+ if ((unsigned long)len > (unsigned long)left + (unsigned long)(s->strm)->avail_in)
+ len = left + (s->strm)->avail_in;
+ if (len > have) len = have;
+ if (len < min_block)
+ if (len == (unsigned int)0) {
+ if (flush != 4) break; else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (flush == 0) break;
+ else
+ if (len != left + (s->strm)->avail_in) break;
+ }
+ if (flush == 4)
+ if (len == left + (s->strm)->avail_in) last = (unsigned int)1;
+ else last = (unsigned int)0;
+ else last = (unsigned int)0;
+ _tr_stored_block(s,(char *)0,(unsigned long)0L,(int)last);
+ *(s->pending_buf + (s->pending - (ulg)4)) = (unsigned char)len;
+ *(s->pending_buf + (s->pending - (ulg)3)) = (unsigned char)(len >> 8);
+ *(s->pending_buf + (s->pending - (ulg)2)) = (unsigned char)(~ len);
+ *(s->pending_buf + (s->pending - (ulg)1)) = (unsigned char)(~ len >> 8);
+ flush_pending(s->strm);
+ if (left) {
+ if (left > len) left = len;
+ memcpy((void *)(s->strm)->next_out,
+ (void const *)(s->window + s->block_start),(unsigned long)left);
+ (s->strm)->next_out += left;
+ (s->strm)->avail_out -= left;
+ (s->strm)->total_out += (uLong)left;
+ s->block_start += (long)left;
+ len -= left;
+ }
+ if (len) {
+ read_buf(s->strm,(s->strm)->next_out,len);
+ (s->strm)->next_out += len;
+ (s->strm)->avail_out -= len;
+ (s->strm)->total_out += (uLong)len;
+ }
+ if (! (last == (unsigned int)0)) break;
+ }
+ used -= (s->strm)->avail_in;
+ if (used) {
+ uInt tmp_0;
+ if (used >= s->w_size) {
+ s->matches = (unsigned int)2;
+ memcpy((void *)s->window,
+ (void const *)((s->strm)->next_in - s->w_size),
+ (unsigned long)s->w_size);
+ s->strstart = s->w_size;
+ }
+ else {
+ if (s->window_size - (ulg)s->strstart <= (ulg)used) {
+ s->strstart -= s->w_size;
+ memcpy((void *)s->window,(void const *)(s->window + s->w_size),
+ (unsigned long)s->strstart);
+ if (s->matches < (uInt)2) (s->matches) ++;
+ }
+ memcpy((void *)(s->window + s->strstart),
+ (void const *)((s->strm)->next_in - used),(unsigned long)used);
+ s->strstart += used;
+ }
+ s->block_start = (long)s->strstart;
+ if (used > s->w_size - s->insert) tmp_0 = s->w_size - s->insert;
+ else tmp_0 = used;
+ s->insert += tmp_0;
+ }
+ if (s->high_water < (ulg)s->strstart) s->high_water = (unsigned long)s->strstart;
+ if (last) {
+ __retres = finish_done;
+ goto return_label;
+ }
+ if (flush != 0)
+ if (flush != 4)
+ if ((s->strm)->avail_in == (uInt)0)
+ if ((long)s->strstart == s->block_start) {
+ __retres = block_done;
+ goto return_label;
+ }
+ have = (unsigned int)((s->window_size - (ulg)s->strstart) - (ulg)1);
+ if ((s->strm)->avail_in > have)
+ if (s->block_start >= (long)s->w_size) {
+ s->block_start -= (long)s->w_size;
+ s->strstart -= s->w_size;
+ memcpy((void *)s->window,(void const *)(s->window + s->w_size),
+ (unsigned long)s->strstart);
+ if (s->matches < (uInt)2) (s->matches) ++;
+ have += s->w_size;
+ }
+ if (have > (s->strm)->avail_in) have = (s->strm)->avail_in;
+ if (have) {
+ read_buf(s->strm,s->window + s->strstart,have);
+ s->strstart += have;
+ }
+ if (s->high_water < (ulg)s->strstart) s->high_water = (unsigned long)s->strstart;
+ have = (unsigned int)((s->bi_valid + 42) >> 3);
+ if (s->pending_buf_size - (ulg)have > (ulg)65535) have = (unsigned int)65535;
+ else have = (unsigned int)(s->pending_buf_size - (ulg)have);
+ if (have > s->w_size) min_block = s->w_size; else min_block = have;
+ left = (unsigned int)((long)s->strstart - s->block_start);
+ if (left >= min_block) goto _LOR;
+ else
+ if (left) goto _LOR_0;
+ else
+ if (flush == 4) {
+ _LOR_0: ;
+ if (flush != 0)
+ if ((s->strm)->avail_in == (uInt)0)
+ if (left <= have) {
+ _LOR:
+ {
+ if (left > have) len = have; else len = left;
+ if (flush == 4)
+ if ((s->strm)->avail_in == (uInt)0)
+ if (len == left) last = (unsigned int)1;
+ else last = (unsigned int)0;
+ else last = (unsigned int)0;
+ else last = (unsigned int)0;
+ _tr_stored_block(s,(charf *)s->window + s->block_start,
+ (unsigned long)len,(int)last);
+ s->block_start += (long)len;
+ flush_pending(s->strm);
+ }
+ }
+ }
+ if (last) tmp_1 = finish_started; else tmp_1 = need_more;
+ __retres = (enum __anonenum_block_state_3)tmp_1;
+ return_label: return __retres;
+}
+
+static block_state deflate_fast(deflate_state *s, int flush) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static block_state deflate_fast(deflate_state *s, int flush)
+{
+ block_state __retres;
+ IPos hash_head;
+ int bflush;
+ while (1) {
+ if (s->lookahead < (uInt)((258 + 3) + 1)) {
+ fill_window(s);
+ if (s->lookahead < (uInt)((258 + 3) + 1))
+ if (flush == 0) {
+ __retres = need_more;
+ goto return_label;
+ }
+ if (s->lookahead == (uInt)0) break;
+ }
+ hash_head = (unsigned int)0;
+ if (s->lookahead >= (uInt)3) {
+ Posf tmp;
+ s->ins_h = ((s->ins_h << s->hash_shift) ^ (unsigned int)*(s->window + (
+ s->strstart + (uInt)(
+ 3 - 1)))) & s->hash_mask;
+ tmp = *(s->head + s->ins_h);
+ *(s->prev + (s->strstart & s->w_mask)) = tmp;
+ hash_head = (unsigned int)tmp;
+ *(s->head + s->ins_h) = (unsigned short)s->strstart;
+ }
+ if (hash_head != (IPos)0)
+ if (s->strstart - hash_head <= s->w_size - (uInt)((258 + 3) + 1))
+ s->match_length = longest_match(s,hash_head);
+ if (s->match_length >= (uInt)3) {
+ {
+ uInt tmp_0;
+ int tmp_1;
+ uch len = (unsigned char)(s->match_length - (uInt)3);
+ ush dist = (unsigned short)(s->strstart - s->match_start);
+ *(s->d_buf + s->last_lit) = dist;
+ tmp_0 = s->last_lit;
+ (s->last_lit) ++;
+ *(s->l_buf + tmp_0) = len;
+ dist = (unsigned short)((int)dist - 1);
+ s->dyn_ltree[((int)_length_code[len] + 256) + 1].fc.freq = (unsigned short)(
+ (int)s->dyn_ltree[((int)_length_code[len] + 256) + 1].fc.freq + 1);
+ if ((int)dist < 256) tmp_1 = (int)_dist_code[dist];
+ else tmp_1 = (int)_dist_code[256 + ((int)dist >> 7)];
+ s->dyn_dtree[tmp_1].fc.freq = (unsigned short)((int)s->dyn_dtree[tmp_1].fc.freq + 1);
+ bflush = s->last_lit == s->lit_bufsize - (uInt)1;
+ }
+ s->lookahead -= s->match_length;
+ if (s->match_length <= s->max_lazy_match) {
+ if (s->lookahead >= (uInt)3) {
+ (s->match_length) --;
+ while (1) {
+ {
+ Posf tmp_2;
+ (s->strstart) ++;
+ s->ins_h = ((s->ins_h << s->hash_shift) ^ (unsigned int)*(
+ s->window + (s->strstart + (uInt)(3 - 1)))) & s->hash_mask;
+ tmp_2 = *(s->head + s->ins_h);
+ *(s->prev + (s->strstart & s->w_mask)) = tmp_2;
+ hash_head = (unsigned int)tmp_2;
+ *(s->head + s->ins_h) = (unsigned short)s->strstart;
+ }
+ (s->match_length) --;
+ if (! (s->match_length != (uInt)0)) break;
+ }
+ (s->strstart) ++;
+ }
+ else goto _LAND;
+ }
+ else {
+ _LAND:
+ {
+ s->strstart += s->match_length;
+ s->match_length = (unsigned int)0;
+ s->ins_h = (unsigned int)*(s->window + s->strstart);
+ s->ins_h = ((s->ins_h << s->hash_shift) ^ (unsigned int)*(s->window + (
+ s->strstart + (uInt)1))) & s->hash_mask;
+ }
+ }
+ }
+ else {
+ {
+ uInt tmp_3;
+ uch cc = *(s->window + s->strstart);
+ *(s->d_buf + s->last_lit) = (unsigned short)0;
+ tmp_3 = s->last_lit;
+ (s->last_lit) ++;
+ *(s->l_buf + tmp_3) = cc;
+ s->dyn_ltree[cc].fc.freq = (unsigned short)((int)s->dyn_ltree[cc].fc.freq + 1);
+ bflush = s->last_lit == s->lit_bufsize - (uInt)1;
+ }
+ (s->lookahead) --;
+ (s->strstart) ++;
+ }
+ if (bflush) {
+ {
+ charf *tmp_4;
+ ;
+ if (s->block_start >= 0L) tmp_4 = (charf *)(s->window + (unsigned int)s->block_start);
+ else tmp_4 = (charf *)0;
+ ;
+ _tr_flush_block(s,tmp_4,
+ (unsigned long)((long)s->strstart - s->block_start),
+ 0);
+ s->block_start = (long)s->strstart;
+ flush_pending(s->strm);
+ }
+ if ((s->strm)->avail_out == (uInt)0) {
+ __retres = need_more;
+ goto return_label;
+ }
+ }
+ }
+ if (s->strstart < (uInt)(3 - 1)) s->insert = s->strstart;
+ else s->insert = (unsigned int)(3 - 1);
+ if (flush == 4) {
+ {
+ charf *tmp_5;
+ ;
+ if (s->block_start >= 0L) tmp_5 = (charf *)(s->window + (unsigned int)s->block_start);
+ else tmp_5 = (charf *)0;
+ ;
+ _tr_flush_block(s,tmp_5,
+ (unsigned long)((long)s->strstart - s->block_start),1);
+ s->block_start = (long)s->strstart;
+ flush_pending(s->strm);
+ }
+ if ((s->strm)->avail_out == (uInt)0) {
+ __retres = finish_started;
+ goto return_label;
+ }
+ __retres = finish_done;
+ goto return_label;
+ }
+ if (s->last_lit) {
+ {
+ charf *tmp_6;
+ ;
+ if (s->block_start >= 0L) tmp_6 = (charf *)(s->window + (unsigned int)s->block_start);
+ else tmp_6 = (charf *)0;
+ ;
+ _tr_flush_block(s,tmp_6,
+ (unsigned long)((long)s->strstart - s->block_start),0);
+ s->block_start = (long)s->strstart;
+ flush_pending(s->strm);
+ }
+ if ((s->strm)->avail_out == (uInt)0) {
+ __retres = need_more;
+ goto return_label;
+ }
+ }
+ __retres = block_done;
+ return_label: return __retres;
+}
+
+static block_state deflate_slow(deflate_state *s, int flush) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static block_state deflate_slow(deflate_state *s, int flush)
+{
+ block_state __retres;
+ IPos hash_head;
+ int bflush;
+ while (1) {
+ if (s->lookahead < (uInt)((258 + 3) + 1)) {
+ fill_window(s);
+ if (s->lookahead < (uInt)((258 + 3) + 1))
+ if (flush == 0) {
+ __retres = need_more;
+ goto return_label;
+ }
+ if (s->lookahead == (uInt)0) break;
+ }
+ hash_head = (unsigned int)0;
+ if (s->lookahead >= (uInt)3) {
+ Posf tmp;
+ s->ins_h = ((s->ins_h << s->hash_shift) ^ (unsigned int)*(s->window + (
+ s->strstart + (uInt)(
+ 3 - 1)))) & s->hash_mask;
+ tmp = *(s->head + s->ins_h);
+ *(s->prev + (s->strstart & s->w_mask)) = tmp;
+ hash_head = (unsigned int)tmp;
+ *(s->head + s->ins_h) = (unsigned short)s->strstart;
+ }
+ s->prev_length = s->match_length;
+ s->prev_match = s->match_start;
+ s->match_length = (unsigned int)(3 - 1);
+ if (hash_head != (IPos)0)
+ if (s->prev_length < s->max_lazy_match)
+ if (s->strstart - hash_head <= s->w_size - (uInt)((258 + 3) + 1)) {
+ s->match_length = longest_match(s,hash_head);
+ if (s->match_length <= (uInt)5)
+ if (s->strategy == 1) goto _LOR;
+ else
+ if (s->match_length == (uInt)3)
+ if (s->strstart - s->match_start > (uInt)4096) _LOR:
+ s->match_length = (unsigned int)(
+ 3 - 1);
+ }
+ if (s->prev_length >= (uInt)3) {
+ if (s->match_length <= s->prev_length) {
+ uInt max_insert = (s->strstart + s->lookahead) - (uInt)3;
+ {
+ uInt tmp_0;
+ int tmp_1;
+ uch len = (unsigned char)(s->prev_length - (uInt)3);
+ ush dist =
+ (unsigned short)((s->strstart - (uInt)1) - s->prev_match);
+ *(s->d_buf + s->last_lit) = dist;
+ tmp_0 = s->last_lit;
+ (s->last_lit) ++;
+ *(s->l_buf + tmp_0) = len;
+ dist = (unsigned short)((int)dist - 1);
+ s->dyn_ltree[((int)_length_code[len] + 256) + 1].fc.freq = (unsigned short)(
+ (int)s->dyn_ltree[((int)_length_code[len] + 256) + 1].fc.freq + 1);
+ if ((int)dist < 256) tmp_1 = (int)_dist_code[dist];
+ else tmp_1 = (int)_dist_code[256 + ((int)dist >> 7)];
+ s->dyn_dtree[tmp_1].fc.freq = (unsigned short)((int)s->dyn_dtree[tmp_1].fc.freq + 1);
+ bflush = s->last_lit == s->lit_bufsize - (uInt)1;
+ }
+ s->lookahead -= s->prev_length - (uInt)1;
+ s->prev_length -= (uInt)2;
+ while (1) {
+ (s->strstart) ++;
+ ;
+ if (s->strstart <= max_insert) {
+ Posf tmp_2;
+ s->ins_h = ((s->ins_h << s->hash_shift) ^ (unsigned int)*(
+ s->window + (s->strstart + (uInt)(3 - 1)))) & s->hash_mask;
+ tmp_2 = *(s->head + s->ins_h);
+ *(s->prev + (s->strstart & s->w_mask)) = tmp_2;
+ hash_head = (unsigned int)tmp_2;
+ *(s->head + s->ins_h) = (unsigned short)s->strstart;
+ }
+ (s->prev_length) --;
+ if (! (s->prev_length != (uInt)0)) break;
+ }
+ s->match_available = 0;
+ s->match_length = (unsigned int)(3 - 1);
+ (s->strstart) ++;
+ if (bflush) {
+ {
+ charf *tmp_3;
+ ;
+ if (s->block_start >= 0L) tmp_3 = (charf *)(s->window + (unsigned int)s->block_start);
+ else tmp_3 = (charf *)0;
+ ;
+ _tr_flush_block(s,tmp_3,
+ (unsigned long)((long)s->strstart - s->block_start),
+ 0);
+ s->block_start = (long)s->strstart;
+ flush_pending(s->strm);
+ }
+ if ((s->strm)->avail_out == (uInt)0) {
+ __retres = need_more;
+ goto return_label;
+ }
+ }
+ }
+ else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (s->match_available) {
+ {
+ uInt tmp_4;
+ uch cc = *(s->window + (s->strstart - (uInt)1));
+ *(s->d_buf + s->last_lit) = (unsigned short)0;
+ tmp_4 = s->last_lit;
+ (s->last_lit) ++;
+ *(s->l_buf + tmp_4) = cc;
+ s->dyn_ltree[cc].fc.freq = (unsigned short)((int)s->dyn_ltree[cc].fc.freq + 1);
+ bflush = s->last_lit == s->lit_bufsize - (uInt)1;
+ }
+ if (bflush) {
+ {
+ charf *tmp_5;
+ ;
+ if (s->block_start >= 0L) tmp_5 = (charf *)(s->window + (unsigned int)s->block_start);
+ else tmp_5 = (charf *)0;
+ ;
+ _tr_flush_block(s,tmp_5,
+ (unsigned long)((long)s->strstart - s->block_start),
+ 0);
+ s->block_start = (long)s->strstart;
+ flush_pending(s->strm);
+ }
+ }
+ (s->strstart) ++;
+ (s->lookahead) --;
+ if ((s->strm)->avail_out == (uInt)0) {
+ __retres = need_more;
+ goto return_label;
+ }
+ }
+ else {
+ s->match_available = 1;
+ (s->strstart) ++;
+ (s->lookahead) --;
+ }
+ }
+ }
+ if (s->match_available) {
+ {
+ uInt tmp_6;
+ uch cc_0 = *(s->window + (s->strstart - (uInt)1));
+ *(s->d_buf + s->last_lit) = (unsigned short)0;
+ tmp_6 = s->last_lit;
+ (s->last_lit) ++;
+ *(s->l_buf + tmp_6) = cc_0;
+ s->dyn_ltree[cc_0].fc.freq = (unsigned short)((int)s->dyn_ltree[cc_0].fc.freq + 1);
+ bflush = s->last_lit == s->lit_bufsize - (uInt)1;
+ }
+ s->match_available = 0;
+ }
+ if (s->strstart < (uInt)(3 - 1)) s->insert = s->strstart;
+ else s->insert = (unsigned int)(3 - 1);
+ if (flush == 4) {
+ {
+ charf *tmp_7;
+ ;
+ if (s->block_start >= 0L) tmp_7 = (charf *)(s->window + (unsigned int)s->block_start);
+ else tmp_7 = (charf *)0;
+ ;
+ _tr_flush_block(s,tmp_7,
+ (unsigned long)((long)s->strstart - s->block_start),1);
+ s->block_start = (long)s->strstart;
+ flush_pending(s->strm);
+ }
+ if ((s->strm)->avail_out == (uInt)0) {
+ __retres = finish_started;
+ goto return_label;
+ }
+ __retres = finish_done;
+ goto return_label;
+ }
+ if (s->last_lit) {
+ {
+ charf *tmp_8;
+ ;
+ if (s->block_start >= 0L) tmp_8 = (charf *)(s->window + (unsigned int)s->block_start);
+ else tmp_8 = (charf *)0;
+ ;
+ _tr_flush_block(s,tmp_8,
+ (unsigned long)((long)s->strstart - s->block_start),0);
+ s->block_start = (long)s->strstart;
+ flush_pending(s->strm);
+ }
+ if ((s->strm)->avail_out == (uInt)0) {
+ __retres = need_more;
+ goto return_label;
+ }
+ }
+ __retres = block_done;
+ return_label: return __retres;
+}
+
+static block_state deflate_rle(deflate_state *s, int flush) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static block_state deflate_rle(deflate_state *s, int flush)
+{
+ block_state __retres;
+ int bflush;
+ uInt prev;
+ Bytef *scan;
+ Bytef *strend;
+ while (1) {
+ if (s->lookahead <= (uInt)258) {
+ fill_window(s);
+ if (s->lookahead <= (uInt)258)
+ if (flush == 0) {
+ __retres = need_more;
+ goto return_label;
+ }
+ if (s->lookahead == (uInt)0) break;
+ }
+ s->match_length = (unsigned int)0;
+ if (s->lookahead >= (uInt)3)
+ if (s->strstart > (uInt)0) {
+ scan = (s->window + s->strstart) - 1;
+ prev = (unsigned int)*scan;
+ scan ++;
+ ;
+ if (prev == (uInt)*scan) {
+ scan ++;
+ ;
+ if (prev == (uInt)*scan) {
+ scan ++;
+ ;
+ if (prev == (uInt)*scan) {
+ strend = (s->window + s->strstart) + 258;
+ while (1) {
+ scan ++;
+ ;
+ if (prev == (uInt)*scan) {
+ scan ++;
+ ;
+ if (prev == (uInt)*scan) {
+ scan ++;
+ ;
+ if (prev == (uInt)*scan) {
+ scan ++;
+ ;
+ if (prev == (uInt)*scan) {
+ scan ++;
+ ;
+ if (prev == (uInt)*scan) {
+ scan ++;
+ ;
+ if (prev == (uInt)*scan) {
+ scan ++;
+ ;
+ if (prev == (uInt)*scan) {
+ scan ++;
+ ;
+ if (prev == (uInt)*scan) {
+ if (! (scan < strend)) break;
+ }
+ else break;
+ }
+ else break;
+ }
+ else break;
+ }
+ else break;
+ }
+ else break;
+ }
+ else break;
+ }
+ else break;
+ }
+ else break;
+ }
+ s->match_length = (unsigned int)258 - (unsigned int)(strend - scan);
+ if (s->match_length > s->lookahead) s->match_length = s->lookahead;
+ }
+ }
+ }
+ }
+ if (s->match_length >= (uInt)3) {
+ {
+ uInt tmp;
+ int tmp_0;
+ uch len = (unsigned char)(s->match_length - (uInt)3);
+ ush dist = (unsigned short)1;
+ *(s->d_buf + s->last_lit) = dist;
+ tmp = s->last_lit;
+ (s->last_lit) ++;
+ *(s->l_buf + tmp) = len;
+ dist = (unsigned short)((int)dist - 1);
+ s->dyn_ltree[((int)_length_code[len] + 256) + 1].fc.freq = (unsigned short)(
+ (int)s->dyn_ltree[((int)_length_code[len] + 256) + 1].fc.freq + 1);
+ if ((int)dist < 256) tmp_0 = (int)_dist_code[dist];
+ else tmp_0 = (int)_dist_code[256 + ((int)dist >> 7)];
+ s->dyn_dtree[tmp_0].fc.freq = (unsigned short)((int)s->dyn_dtree[tmp_0].fc.freq + 1);
+ bflush = s->last_lit == s->lit_bufsize - (uInt)1;
+ }
+ s->lookahead -= s->match_length;
+ s->strstart += s->match_length;
+ s->match_length = (unsigned int)0;
+ }
+ else {
+ {
+ uInt tmp_1;
+ uch cc = *(s->window + s->strstart);
+ *(s->d_buf + s->last_lit) = (unsigned short)0;
+ tmp_1 = s->last_lit;
+ (s->last_lit) ++;
+ *(s->l_buf + tmp_1) = cc;
+ s->dyn_ltree[cc].fc.freq = (unsigned short)((int)s->dyn_ltree[cc].fc.freq + 1);
+ bflush = s->last_lit == s->lit_bufsize - (uInt)1;
+ }
+ (s->lookahead) --;
+ (s->strstart) ++;
+ }
+ if (bflush) {
+ {
+ charf *tmp_2;
+ ;
+ if (s->block_start >= 0L) tmp_2 = (charf *)(s->window + (unsigned int)s->block_start);
+ else tmp_2 = (charf *)0;
+ ;
+ _tr_flush_block(s,tmp_2,
+ (unsigned long)((long)s->strstart - s->block_start),
+ 0);
+ s->block_start = (long)s->strstart;
+ flush_pending(s->strm);
+ }
+ if ((s->strm)->avail_out == (uInt)0) {
+ __retres = need_more;
+ goto return_label;
+ }
+ }
+ }
+ s->insert = (unsigned int)0;
+ if (flush == 4) {
+ {
+ charf *tmp_3;
+ ;
+ if (s->block_start >= 0L) tmp_3 = (charf *)(s->window + (unsigned int)s->block_start);
+ else tmp_3 = (charf *)0;
+ ;
+ _tr_flush_block(s,tmp_3,
+ (unsigned long)((long)s->strstart - s->block_start),1);
+ s->block_start = (long)s->strstart;
+ flush_pending(s->strm);
+ }
+ if ((s->strm)->avail_out == (uInt)0) {
+ __retres = finish_started;
+ goto return_label;
+ }
+ __retres = finish_done;
+ goto return_label;
+ }
+ if (s->last_lit) {
+ {
+ charf *tmp_4;
+ ;
+ if (s->block_start >= 0L) tmp_4 = (charf *)(s->window + (unsigned int)s->block_start);
+ else tmp_4 = (charf *)0;
+ ;
+ _tr_flush_block(s,tmp_4,
+ (unsigned long)((long)s->strstart - s->block_start),0);
+ s->block_start = (long)s->strstart;
+ flush_pending(s->strm);
+ }
+ if ((s->strm)->avail_out == (uInt)0) {
+ __retres = need_more;
+ goto return_label;
+ }
+ }
+ __retres = block_done;
+ return_label: return __retres;
+}
+
+static block_state deflate_huff(deflate_state *s, int flush) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static block_state deflate_huff(deflate_state *s, int flush)
+{
+ block_state __retres;
+ int bflush;
+ while (1) {
+ if (s->lookahead == (uInt)0) {
+ fill_window(s);
+ if (s->lookahead == (uInt)0) {
+ if (flush == 0) {
+ __retres = need_more;
+ goto return_label;
+ }
+ break;
+ }
+ }
+ s->match_length = (unsigned int)0;
+ {
+ uInt tmp;
+ uch cc = *(s->window + s->strstart);
+ *(s->d_buf + s->last_lit) = (unsigned short)0;
+ tmp = s->last_lit;
+ (s->last_lit) ++;
+ *(s->l_buf + tmp) = cc;
+ s->dyn_ltree[cc].fc.freq = (unsigned short)((int)s->dyn_ltree[cc].fc.freq + 1);
+ bflush = s->last_lit == s->lit_bufsize - (uInt)1;
+ }
+ (s->lookahead) --;
+ (s->strstart) ++;
+ if (bflush) {
+ {
+ charf *tmp_0;
+ ;
+ if (s->block_start >= 0L) tmp_0 = (charf *)(s->window + (unsigned int)s->block_start);
+ else tmp_0 = (charf *)0;
+ ;
+ _tr_flush_block(s,tmp_0,
+ (unsigned long)((long)s->strstart - s->block_start),
+ 0);
+ s->block_start = (long)s->strstart;
+ flush_pending(s->strm);
+ }
+ if ((s->strm)->avail_out == (uInt)0) {
+ __retres = need_more;
+ goto return_label;
+ }
+ }
+ }
+ s->insert = (unsigned int)0;
+ if (flush == 4) {
+ {
+ charf *tmp_1;
+ ;
+ if (s->block_start >= 0L) tmp_1 = (charf *)(s->window + (unsigned int)s->block_start);
+ else tmp_1 = (charf *)0;
+ ;
+ _tr_flush_block(s,tmp_1,
+ (unsigned long)((long)s->strstart - s->block_start),1);
+ s->block_start = (long)s->strstart;
+ flush_pending(s->strm);
+ }
+ if ((s->strm)->avail_out == (uInt)0) {
+ __retres = finish_started;
+ goto return_label;
+ }
+ __retres = finish_done;
+ goto return_label;
+ }
+ if (s->last_lit) {
+ {
+ charf *tmp_2;
+ ;
+ if (s->block_start >= 0L) tmp_2 = (charf *)(s->window + (unsigned int)s->block_start);
+ else tmp_2 = (charf *)0;
+ ;
+ _tr_flush_block(s,tmp_2,
+ (unsigned long)((long)s->strstart - s->block_start),0);
+ s->block_start = (long)s->strstart;
+ flush_pending(s->strm);
+ }
+ if ((s->strm)->avail_out == (uInt)0) {
+ __retres = need_more;
+ goto return_label;
+ }
+ }
+ __retres = block_done;
+ return_label: return __retres;
+}
+
+gzFile gzopen64(char const *path, char const *mode) __attribute__((__FC_OLDSTYLEPROTO__));
+
+long gzseek64(gzFile file, long offset, int whence) __attribute__((__FC_OLDSTYLEPROTO__));
+
+long gztell64(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+
+long gzoffset64(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+
+void gz_error(gz_statep state, int err, char const *msg) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+int gzclose(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+int gzclose(gzFile file)
+{
+ int __retres;
+ gz_statep state;
+ int tmp_1;
+ if (file == (gzFile)0) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode == 7247) tmp_1 = gzclose_r(file);
+ else tmp_1 = gzclose_w(file);
+ __retres = tmp_1;
+ return_label: return __retres;
+}
+
+static void gz_reset(gz_statep state) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static gzFile gz_open(void const *path, int fd, char const *mode) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static void gz_reset(gz_statep state) __attribute__((__FC_OLDSTYLEPROTO__));
+static void gz_reset(gz_statep state)
+{
+ state->x.have = (unsigned int)0;
+ if (state->mode == 7247) {
+ state->eof = 0;
+ state->past = 0;
+ state->how = 0;
+ }
+ state->seek = 0;
+ gz_error(state,0,(char const *)0);
+ state->x.pos = (long)0;
+ state->strm.avail_in = (unsigned int)0;
+ return;
+}
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(format);
+ requires
+ \valid(s + (0 .. n - 1)) ∨
+ \valid(s + (0 .. format_length(format) - 1));
+ assigns \result, *(s + (0 ..));
+ assigns \result
+ \from (indirect: n), (indirect: *(format + (0 ..))),
+ (indirect: *(param0 + (0 ..)));
+ assigns *(s + (0 ..))
+ \from (indirect: n), (indirect: *(format + (0 ..))), *(param0 + (0 ..));
+ */
+int snprintf_va_1(char * restrict s, size_t n, char const * restrict format,
+ char *param0);
+
+static gzFile gz_open(void const *path, int fd, char const *mode) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static gzFile gz_open(void const *path, int fd, char const *mode)
+{
+ gzFile __retres;
+ gz_statep state;
+ z_size_t len;
+ int oflag;
+ int tmp_1;
+ int tmp_4;
+ int cloexec = 0;
+ int exclusive = 0;
+ if (path == (void const *)0) {
+ __retres = (struct gzFile_s *)0;
+ goto return_label;
+ }
+ state = (gz_statep)malloc(sizeof(gz_state));
+ if (state == (gz_statep)0) {
+ __retres = (struct gzFile_s *)0;
+ goto return_label;
+ }
+ state->size = (unsigned int)0;
+ state->want = (unsigned int)8192;
+ state->msg = (char *)0;
+ state->mode = 0;
+ state->level = -1;
+ state->strategy = 0;
+ state->direct = 0;
+ while (*mode) {
+ if ((int)*mode >= '0') {
+ if ((int)*mode <= '9') state->level = (int)*mode - '0';
+ else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ switch ((int)*mode) {
+ case 'r': state->mode = 7247;
+ break;
+ case 'w': state->mode = 31153;
+ break;
+ case 'a': state->mode = 1;
+ break;
+ case '+': free((void *)state);
+ __retres = (struct gzFile_s *)0;
+ goto return_label;
+ case 'b': break;
+ case 'e': cloexec = 1;
+ break;
+ case 'x': exclusive = 1;
+ break;
+ case 'f': state->strategy = 1;
+ break;
+ case 'h': state->strategy = 2;
+ break;
+ case 'R': state->strategy = 3;
+ break;
+ case 'F': state->strategy = 4;
+ break;
+ case 'T': state->direct = 1;
+ break;
+ default: ;
+ }
+ }
+ mode ++;
+ }
+ if (state->mode == 0) {
+ free((void *)state);
+ __retres = (struct gzFile_s *)0;
+ goto return_label;
+ }
+ if (state->mode == 7247) {
+ if (state->direct) {
+ free((void *)state);
+ __retres = (struct gzFile_s *)0;
+ goto return_label;
+ }
+ state->direct = 1;
+ }
+ len = strlen((char const *)path);
+ state->path = (char *)malloc(len + (z_size_t)1);
+ if (state->path == (char *)0) {
+ free((void *)state);
+ __retres = (struct gzFile_s *)0;
+ goto return_label;
+ }
+ snprintf(state->path,len + (z_size_t)1,"%s",(char *)path); /* snprintf_va_1 */
+ if (cloexec) tmp_1 = 0x80000; else tmp_1 = 0;
+ if (state->mode == 7247) tmp_4 = 0;
+ else {
+ int tmp_2;
+ int tmp_3;
+ if (exclusive) tmp_2 = 0x80; else tmp_2 = 0;
+ if (state->mode == 31153) tmp_3 = 0x200; else tmp_3 = 0x400;
+ tmp_4 = ((1 | 0x40) | tmp_2) | tmp_3;
+ }
+ oflag = (0 | tmp_1) | tmp_4;
+ if (fd > -1) state->fd = fd;
+ else state->fd = open((char const *)path,oflag,(mode_t)0666); /* __va_open_mode_t */
+ if (state->fd == -1) {
+ free((void *)state->path);
+ free((void *)state);
+ __retres = (struct gzFile_s *)0;
+ goto return_label;
+ }
+ if (state->mode == 1) {
+ lseek(state->fd,(long)0,2);
+ state->mode = 31153;
+ }
+ if (state->mode == 7247) {
+ state->start = lseek(state->fd,(long)0,1);
+ if (state->start == (long)(-1)) state->start = (long)0;
+ }
+ gz_reset(state);
+ __retres = (struct gzFile_s *)state;
+ return_label: return __retres;
+}
+
+gzFile gzopen(char const *path, char const *mode) __attribute__((__FC_OLDSTYLEPROTO__));
+gzFile gzopen(char const *path, char const *mode)
+{
+ gzFile tmp;
+ tmp = gz_open((void const *)path,-1,mode);
+ return tmp;
+}
+
+gzFile gzopen64(char const *path, char const *mode) __attribute__((__FC_OLDSTYLEPROTO__));
+gzFile gzopen64(char const *path, char const *mode)
+{
+ gzFile tmp;
+ tmp = gz_open((void const *)path,-1,mode);
+ return tmp;
+}
+
+/*@ requires valid_read_string(format);
+ requires
+ \valid(s + (0 .. n - 1)) ∨
+ \valid(s + (0 .. format_length(format) - 1));
+ assigns \result, *(s + (0 ..));
+ assigns \result
+ \from (indirect: n), (indirect: *(format + (0 ..))), (indirect: param0);
+ assigns *(s + (0 ..))
+ \from (indirect: n), (indirect: *(format + (0 ..))), param0;
+ */
+int snprintf_va_2(char * restrict s, size_t n, char const * restrict format,
+ int param0);
+
+gzFile gzdopen(int fd, char const *mode) __attribute__((__FC_OLDSTYLEPROTO__));
+gzFile gzdopen(int fd, char const *mode)
+{
+ gzFile __retres;
+ char *path;
+ gzFile gz;
+ if (fd == -1) {
+ __retres = (struct gzFile_s *)0;
+ goto return_label;
+ }
+ else {
+ path = (char *)malloc((unsigned long)7 + (unsigned long)3 * sizeof(int));
+ if (path == (char *)0) {
+ __retres = (struct gzFile_s *)0;
+ goto return_label;
+ }
+ }
+ snprintf(path,(unsigned long)7 + (unsigned long)3 * sizeof(int),"<fd:%d>",
+ fd); /* snprintf_va_2 */
+ gz = gz_open((void const *)path,fd,mode);
+ free((void *)path);
+ __retres = gz;
+ return_label: return __retres;
+}
+
+int gzbuffer(gzFile file, unsigned int size) __attribute__((__FC_OLDSTYLEPROTO__));
+int gzbuffer(gzFile file, unsigned int size)
+{
+ int __retres;
+ gz_statep state;
+ if (file == (gzFile)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode != 7247)
+ if (state->mode != 31153) {
+ __retres = -1;
+ goto return_label;
+ }
+ if (state->size != (unsigned int)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ if (size << 1 < size) {
+ __retres = -1;
+ goto return_label;
+ }
+ if (size < (unsigned int)2) size = (unsigned int)2;
+ state->want = size;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int gzrewind(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+int gzrewind(gzFile file)
+{
+ int __retres;
+ gz_statep state;
+ off_t tmp;
+ if (file == (gzFile)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode != 7247) {
+ __retres = -1;
+ goto return_label;
+ }
+ else
+ if (state->err != 0)
+ if (state->err != -5) {
+ __retres = -1;
+ goto return_label;
+ }
+ tmp = lseek(state->fd,state->start,0);
+ if (tmp == (off_t)(-1)) {
+ __retres = -1;
+ goto return_label;
+ }
+ gz_reset(state);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+long gzseek64(gzFile file, long offset, int whence) __attribute__((__FC_OLDSTYLEPROTO__));
+long gzseek64(gzFile file, long offset, int whence)
+{
+ long __retres;
+ unsigned int n;
+ long ret;
+ gz_statep state;
+ if (file == (gzFile)0) {
+ __retres = (long)(-1);
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode != 7247)
+ if (state->mode != 31153) {
+ __retres = (long)(-1);
+ goto return_label;
+ }
+ if (state->err != 0)
+ if (state->err != -5) {
+ __retres = (long)(-1);
+ goto return_label;
+ }
+ if (whence != 0)
+ if (whence != 1) {
+ __retres = (long)(-1);
+ goto return_label;
+ }
+ if (whence == 0) offset -= state->x.pos;
+ else
+ if (state->seek) offset += state->skip;
+ state->seek = 0;
+ if (state->mode == 7247)
+ if (state->how == 1)
+ if (state->x.pos + offset >= (long)0) {
+ ret = lseek(state->fd,offset - (long)state->x.have,1);
+ if (ret == (long)(-1)) {
+ __retres = (long)(-1);
+ goto return_label;
+ }
+ state->x.have = (unsigned int)0;
+ state->eof = 0;
+ state->past = 0;
+ state->seek = 0;
+ gz_error(state,0,(char const *)0);
+ state->strm.avail_in = (unsigned int)0;
+ state->x.pos += offset;
+ __retres = state->x.pos;
+ goto return_label;
+ }
+ if (offset < (long)0) {
+ int tmp;
+ if (state->mode != 7247) {
+ __retres = (long)(-1);
+ goto return_label;
+ }
+ offset += state->x.pos;
+ if (offset < (long)0) {
+ __retres = (long)(-1);
+ goto return_label;
+ }
+ tmp = gzrewind(file);
+ if (tmp == -1) {
+ __retres = (long)(-1);
+ goto return_label;
+ }
+ }
+ if (state->mode == 7247) {
+ if (sizeof(int) == sizeof(long)) {
+ if (state->x.have > (unsigned int)2147483647) n = (unsigned int)offset;
+ else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if ((long)state->x.have > offset) n = (unsigned int)offset;
+ else n = state->x.have;
+ }
+ state->x.have -= n;
+ state->x.next += n;
+ state->x.pos += (long)n;
+ offset -= (long)n;
+ }
+ if (offset) {
+ state->seek = 1;
+ state->skip = offset;
+ }
+ __retres = state->x.pos + offset;
+ return_label: return __retres;
+}
+
+long gzseek(gzFile file, long offset, int whence) __attribute__((__FC_OLDSTYLEPROTO__));
+long gzseek(gzFile file, long offset, int whence)
+{
+ long ret;
+ long tmp;
+ ret = gzseek64(file,offset,whence);
+ if (ret == ret) tmp = ret; else tmp = (long)(-1);
+ return tmp;
+}
+
+long gztell64(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+long gztell64(gzFile file)
+{
+ long __retres;
+ gz_statep state;
+ long tmp;
+ if (file == (gzFile)0) {
+ __retres = (long)(-1);
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode != 7247)
+ if (state->mode != 31153) {
+ __retres = (long)(-1);
+ goto return_label;
+ }
+ if (state->seek) tmp = state->skip; else tmp = (long)0;
+ ;
+ __retres = state->x.pos + tmp;
+ return_label: return __retres;
+}
+
+long gztell(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+long gztell(gzFile file)
+{
+ long ret;
+ long tmp;
+ ret = gztell64(file);
+ if (ret == ret) tmp = ret; else tmp = (long)(-1);
+ return tmp;
+}
+
+long gzoffset64(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+long gzoffset64(gzFile file)
+{
+ long __retres;
+ long offset;
+ gz_statep state;
+ if (file == (gzFile)0) {
+ __retres = (long)(-1);
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode != 7247)
+ if (state->mode != 31153) {
+ __retres = (long)(-1);
+ goto return_label;
+ }
+ offset = lseek(state->fd,(long)0,1);
+ if (offset == (long)(-1)) {
+ __retres = (long)(-1);
+ goto return_label;
+ }
+ if (state->mode == 7247) offset -= (long)state->strm.avail_in;
+ __retres = offset;
+ return_label: return __retres;
+}
+
+long gzoffset(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+long gzoffset(gzFile file)
+{
+ long ret;
+ long tmp;
+ ret = gzoffset64(file);
+ if (ret == ret) tmp = ret; else tmp = (long)(-1);
+ return tmp;
+}
+
+int gzeof(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+int gzeof(gzFile file)
+{
+ int __retres;
+ gz_statep state;
+ int tmp;
+ if (file == (gzFile)0) {
+ __retres = 0;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode != 7247)
+ if (state->mode != 31153) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (state->mode == 7247) tmp = state->past; else tmp = 0;
+ __retres = tmp;
+ return_label: return __retres;
+}
+
+char const *gzerror(gzFile file, int *errnum) __attribute__((__FC_OLDSTYLEPROTO__));
+char const *gzerror(gzFile file, int *errnum)
+{
+ char const *__retres;
+ gz_statep state;
+ char const *tmp_0;
+ if (file == (gzFile)0) {
+ __retres = (char const *)0;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode != 7247)
+ if (state->mode != 31153) {
+ __retres = (char const *)0;
+ goto return_label;
+ }
+ if (errnum != (int *)0) *errnum = state->err;
+ if (state->err == -4) tmp_0 = "out of memory";
+ else {
+ char const *tmp;
+ if (state->msg == (char *)0) tmp = "";
+ else tmp = (char const *)state->msg;
+ tmp_0 = tmp;
+ }
+ __retres = tmp_0;
+ return_label: return __retres;
+}
+
+void gzclearerr(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+void gzclearerr(gzFile file)
+{
+ gz_statep state;
+ if (file == (gzFile)0) goto return_label;
+ state = (gz_state *)file;
+ if (state->mode != 7247)
+ if (state->mode != 31153) goto return_label;
+ if (state->mode == 7247) {
+ state->eof = 0;
+ state->past = 0;
+ }
+ gz_error(state,0,(char const *)0);
+ return_label: return;
+}
+
+/*@ requires valid_read_string(param0);
+ requires valid_read_string(param1);
+ requires valid_read_string(param2);
+ requires valid_read_string(format);
+ requires
+ \valid(s + (0 .. n - 1)) ∨
+ \valid(s + (0 .. format_length(format) - 1));
+ assigns \result, *(s + (0 ..));
+ assigns \result
+ \from (indirect: n), (indirect: *(format + (0 ..))),
+ (indirect: *(param2 + (0 ..))), (indirect: *(param1 + (0 ..))),
+ (indirect: *(param0 + (0 ..)));
+ assigns *(s + (0 ..))
+ \from (indirect: n), (indirect: *(format + (0 ..))),
+ *(param2 + (0 ..)), *(param1 + (0 ..)), *(param0 + (0 ..));
+ */
+int snprintf_va_3(char * restrict s, size_t n, char const * restrict format,
+ char *param0, char *param1, char *param2);
+
+void gz_error(gz_statep state, int err, char const *msg) __attribute__((
+__FC_OLDSTYLEPROTO__));
+void gz_error(gz_statep state, int err, char const *msg)
+{
+ void *tmp_2;
+ size_t tmp_0;
+ size_t tmp_1;
+ char *tmp;
+ size_t tmp_3;
+ size_t tmp_4;
+ if (state->msg != (char *)0) {
+ if (state->err != -4) free((void *)state->msg);
+ state->msg = (char *)0;
+ }
+ if (err != 0)
+ if (err != -5) state->x.have = (unsigned int)0;
+ state->err = err;
+ if (msg == (char const *)0) goto return_label;
+ if (err == -4) goto return_label;
+ tmp_0 = strlen((char const *)state->path);
+ tmp_1 = strlen(msg);
+ tmp_2 = malloc((tmp_0 + tmp_1) + (size_t)3);
+ tmp = (char *)tmp_2;
+ state->msg = tmp;
+ if (tmp == (char *)0) {
+ state->err = -4;
+ goto return_label;
+ }
+ ;
+ ;
+ tmp_3 = strlen((char const *)state->path);
+ tmp_4 = strlen(msg);
+ ;
+ snprintf(state->msg,(tmp_3 + tmp_4) + (size_t)3,"%s%s%s",state->path,
+ (char *)": ",(char *)msg); /* snprintf_va_3 */
+ return_label: return;
+}
+
+static int gz_load(gz_statep state, unsigned char *buf, unsigned int len,
+ unsigned int *have) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static int gz_avail(gz_statep state) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static int gz_look(gz_statep state) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static int gz_decomp(gz_statep state) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static int gz_fetch(gz_statep state) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static int gz_skip(gz_statep state, long len) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static z_size_t gz_read(gz_statep state, voidp buf, z_size_t len) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static int gz_load(gz_statep state, unsigned char *buf, unsigned int len,
+ unsigned int *have) __attribute__((__FC_OLDSTYLEPROTO__));
+static int gz_load(gz_statep state, unsigned char *buf, unsigned int len,
+ unsigned int *have)
+{
+ int __retres;
+ int ret;
+ unsigned int get;
+ unsigned int max = ((unsigned int)(-1) >> 2) + (unsigned int)1;
+ *have = (unsigned int)0;
+ while (1) {
+ {
+ ssize_t tmp;
+ get = len - *have;
+ if (get > max) get = max;
+ tmp = read(state->fd,(void *)(buf + *have),(unsigned long)get);
+ ret = (int)tmp;
+ if (ret <= 0) break;
+ *have += (unsigned int)ret;
+ }
+ if (! (*have < len)) break;
+ }
+ if (ret < 0) {
+ char *tmp_0;
+ tmp_0 = strerror(__fc_errno);
+ ;
+ gz_error(state,-1,(char const *)tmp_0);
+ __retres = -1;
+ goto return_label;
+ }
+ if (ret == 0) state->eof = 1;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int gz_avail(gz_statep state) __attribute__((__FC_OLDSTYLEPROTO__));
+static int gz_avail(gz_statep state)
+{
+ int __retres;
+ unsigned int got;
+ z_streamp strm = & state->strm;
+ if (state->err != 0)
+ if (state->err != -5) {
+ __retres = -1;
+ goto return_label;
+ }
+ if (state->eof == 0) {
+ int tmp_1;
+ if (strm->avail_in) {
+ unsigned char *p = state->in;
+ unsigned char const *q = (unsigned char const *)strm->next_in;
+ unsigned int n = strm->avail_in;
+ while (1) {
+ {
+ unsigned char *tmp;
+ unsigned char const *tmp_0;
+ tmp = p;
+ p ++;
+ tmp_0 = q;
+ q ++;
+ *tmp = *tmp_0;
+ }
+ n --;
+ if (! n) break;
+ }
+ }
+ tmp_1 = gz_load(state,state->in + strm->avail_in,
+ state->size - strm->avail_in,& got);
+ if (tmp_1 == -1) {
+ __retres = -1;
+ goto return_label;
+ }
+ strm->avail_in += got;
+ strm->next_in = state->in;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int gz_look(gz_statep state) __attribute__((__FC_OLDSTYLEPROTO__));
+static int gz_look(gz_statep state)
+{
+ int __retres;
+ z_streamp strm = & state->strm;
+ if (state->size == (unsigned int)0) {
+ int tmp_1;
+ state->in = (unsigned char *)malloc((unsigned long)state->want);
+ state->out = (unsigned char *)malloc((unsigned long)(state->want << 1));
+ if (state->in == (unsigned char *)0) goto _LOR;
+ else
+ if (state->out == (unsigned char *)0) {
+ _LOR:
+ {
+ free((void *)state->out);
+ free((void *)state->in);
+ gz_error(state,-4,"out of memory");
+ __retres = -1;
+ goto return_label;
+ }
+ }
+ state->size = state->want;
+ state->strm.zalloc = (voidpf (*)(voidpf opaque, uInt items, uInt size))0;
+ state->strm.zfree = (void (*)(voidpf opaque, voidpf address))0;
+ state->strm.opaque = (void *)0;
+ state->strm.avail_in = (unsigned int)0;
+ state->strm.next_in = (Bytef *)0;
+ tmp_1 = inflateInit2_(& state->strm,15 + 16,"1.2.11",
+ (int)sizeof(z_stream));
+ if (tmp_1 != 0) {
+ free((void *)state->out);
+ free((void *)state->in);
+ state->size = (unsigned int)0;
+ gz_error(state,-4,"out of memory");
+ __retres = -1;
+ goto return_label;
+ }
+ }
+ if (strm->avail_in < (uInt)2) {
+ int tmp_2;
+ tmp_2 = gz_avail(state);
+ if (tmp_2 == -1) {
+ __retres = -1;
+ goto return_label;
+ }
+ if (strm->avail_in == (uInt)0) {
+ __retres = 0;
+ goto return_label;
+ }
+ }
+ if (strm->avail_in > (uInt)1)
+ if ((int)*(strm->next_in + 0) == 31)
+ if ((int)*(strm->next_in + 1) == 139) {
+ inflateReset(strm);
+ state->how = 2;
+ state->direct = 0;
+ __retres = 0;
+ goto return_label;
+ }
+ if (state->direct == 0) {
+ strm->avail_in = (unsigned int)0;
+ state->eof = 1;
+ state->x.have = (unsigned int)0;
+ __retres = 0;
+ goto return_label;
+ }
+ state->x.next = state->out;
+ if (strm->avail_in) {
+ memcpy((void *)state->x.next,(void const *)strm->next_in,
+ (unsigned long)strm->avail_in);
+ state->x.have = strm->avail_in;
+ strm->avail_in = (unsigned int)0;
+ }
+ state->how = 1;
+ state->direct = 1;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int gz_decomp(gz_statep state) __attribute__((__FC_OLDSTYLEPROTO__));
+static int gz_decomp(gz_statep state)
+{
+ int __retres;
+ unsigned int had;
+ int ret = 0;
+ z_streamp strm = & state->strm;
+ had = strm->avail_out;
+ while (1) {
+ if (strm->avail_in == (uInt)0) {
+ int tmp;
+ tmp = gz_avail(state);
+ if (tmp == -1) {
+ __retres = -1;
+ goto return_label;
+ }
+ }
+ if (strm->avail_in == (uInt)0) {
+ gz_error(state,-5,"unexpected end of file");
+ break;
+ }
+ ret = inflate(strm,0);
+ if (ret == -2) goto _LOR;
+ else
+ if (ret == 2) {
+ _LOR:
+ {
+ gz_error(state,-2,"internal error: inflate stream corrupt");
+ __retres = -1;
+ goto return_label;
+ }
+ }
+ if (ret == -4) {
+ gz_error(state,-4,"out of memory");
+ __retres = -1;
+ goto return_label;
+ }
+ if (ret == -3) {
+ char const *tmp_0;
+ if (strm->msg == (char *)0) tmp_0 = "compressed data error";
+ else tmp_0 = (char const *)strm->msg;
+ ;
+ gz_error(state,-3,tmp_0);
+ __retres = -1;
+ goto return_label;
+ }
+ if (strm->avail_out) {
+ if (! (ret != 1)) break;
+ }
+ else break;
+ }
+ state->x.have = had - strm->avail_out;
+ state->x.next = strm->next_out - state->x.have;
+ if (ret == 1) state->how = 0;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int gz_fetch(gz_statep state) __attribute__((__FC_OLDSTYLEPROTO__));
+static int gz_fetch(gz_statep state)
+{
+ int __retres;
+ z_streamp strm = & state->strm;
+ while (1) {
+ switch (state->how) {
+ int tmp;
+ int tmp_0;
+ int tmp_1;
+ case 0: tmp = gz_look(state);
+ if (tmp == -1) {
+ __retres = -1;
+ goto return_label;
+ }
+ if (state->how == 0) {
+ __retres = 0;
+ goto return_label;
+ }
+ break;
+ case 1:
+ tmp_0 = gz_load(state,state->out,state->size << 1,& state->x.have);
+ if (tmp_0 == -1) {
+ __retres = -1;
+ goto return_label;
+ }
+ state->x.next = state->out;
+ __retres = 0;
+ goto return_label;
+ case 2: strm->avail_out = state->size << 1;
+ strm->next_out = state->out;
+ tmp_1 = gz_decomp(state);
+ if (tmp_1 == -1) {
+ __retres = -1;
+ goto return_label;
+ }
+ }
+ if (state->x.have == (unsigned int)0) {
+ if (! (! state->eof))
+ if (! strm->avail_in) break;
+ }
+ else break;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int gz_skip(gz_statep state, long len) __attribute__((__FC_OLDSTYLEPROTO__));
+static int gz_skip(gz_statep state, long len)
+{
+ int __retres;
+ unsigned int n;
+ while (len)
+ if (state->x.have) {
+ if (sizeof(int) == sizeof(long)) {
+ if (state->x.have > (unsigned int)2147483647) n = (unsigned int)len;
+ else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if ((long)state->x.have > len) n = (unsigned int)len;
+ else n = state->x.have;
+ }
+ state->x.have -= n;
+ state->x.next += n;
+ state->x.pos += (long)n;
+ len -= (long)n;
+ }
+ else
+ if (state->eof) {
+ if (state->strm.avail_in == (uInt)0) break; else goto _LAND_0;
+ }
+ else {
+ _LAND_0:
+ {
+ int tmp;
+ tmp = gz_fetch(state);
+ if (tmp == -1) {
+ __retres = -1;
+ goto return_label;
+ }
+ }
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static z_size_t gz_read(gz_statep state, voidp buf, z_size_t len) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static z_size_t gz_read(gz_statep state, voidp buf, z_size_t len)
+{
+ z_size_t __retres;
+ z_size_t got;
+ unsigned int n;
+ if (len == (z_size_t)0) {
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ if (state->seek) {
+ int tmp;
+ state->seek = 0;
+ tmp = gz_skip(state,state->skip);
+ if (tmp == -1) {
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ }
+ got = (unsigned long)0;
+ while (1) {
+ n = (unsigned int)(-1);
+ if ((z_size_t)n > len) n = (unsigned int)len;
+ if (state->x.have) {
+ if (state->x.have < n) n = state->x.have;
+ memcpy(buf,(void const *)state->x.next,(unsigned long)n);
+ state->x.next += n;
+ state->x.have -= n;
+ }
+ else
+ if (state->eof) {
+ if (state->strm.avail_in == (uInt)0) {
+ state->past = 1;
+ break;
+ }
+ else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (state->how == 0) goto _LOR;
+ else
+ if (n < state->size << 1) {
+ _LOR:
+ {
+ int tmp_0;
+ tmp_0 = gz_fetch(state);
+ if (tmp_0 == -1) {
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ goto __Cont;
+ }
+ }
+ else
+ if (state->how == 1) {
+ int tmp_1;
+ tmp_1 = gz_load(state,(unsigned char *)buf,n,& n);
+ if (tmp_1 == -1) {
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ }
+ else {
+ int tmp_2;
+ state->strm.avail_out = n;
+ state->strm.next_out = (unsigned char *)buf;
+ tmp_2 = gz_decomp(state);
+ if (tmp_2 == -1) {
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ n = state->x.have;
+ state->x.have = (unsigned int)0;
+ }
+ }
+ len -= (z_size_t)n;
+ buf = (void *)((char *)buf + n);
+ got += (z_size_t)n;
+ state->x.pos += (long)n;
+ __Cont: ;
+ if (! len) break;
+ }
+ __retres = got;
+ return_label: return __retres;
+}
+
+int gzread(gzFile file, voidp buf, unsigned int len) __attribute__((__FC_OLDSTYLEPROTO__));
+int gzread(gzFile file, voidp buf, unsigned int len)
+{
+ int __retres;
+ gz_statep state;
+ z_size_t tmp;
+ if (file == (gzFile)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode != 7247) {
+ __retres = -1;
+ goto return_label;
+ }
+ else
+ if (state->err != 0)
+ if (state->err != -5) {
+ __retres = -1;
+ goto return_label;
+ }
+ if ((int)len < 0) {
+ gz_error(state,-2,"request does not fit in an int");
+ __retres = -1;
+ goto return_label;
+ }
+ tmp = gz_read(state,buf,(unsigned long)len);
+ len = (unsigned int)tmp;
+ if (len == (unsigned int)0)
+ if (state->err != 0)
+ if (state->err != -5) {
+ __retres = -1;
+ goto return_label;
+ }
+ __retres = (int)len;
+ return_label: return __retres;
+}
+
+z_size_t gzfread(voidp buf, z_size_t size, z_size_t nitems, gzFile file) __attribute__((
+__FC_OLDSTYLEPROTO__));
+z_size_t gzfread(voidp buf, z_size_t size, z_size_t nitems, gzFile file)
+{
+ z_size_t __retres;
+ z_size_t len;
+ gz_statep state;
+ z_size_t tmp_0;
+ if (file == (gzFile)0) {
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode != 7247) {
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ else
+ if (state->err != 0)
+ if (state->err != -5) {
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ len = nitems * size;
+ if (size)
+ if (len / size != nitems) {
+ gz_error(state,-2,"request does not fit in a size_t");
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ if (len) {
+ z_size_t tmp;
+ tmp = gz_read(state,buf,len);
+ tmp_0 = tmp / size;
+ }
+ else tmp_0 = (unsigned long)0;
+ __retres = tmp_0;
+ return_label: return __retres;
+}
+
+int gzgetc(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+int gzgetc(gzFile file)
+{
+ int __retres;
+ int ret;
+ unsigned char buf[1];
+ gz_statep state;
+ z_size_t tmp_0;
+ int tmp_1;
+ if (file == (gzFile)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode != 7247) {
+ __retres = -1;
+ goto return_label;
+ }
+ else
+ if (state->err != 0)
+ if (state->err != -5) {
+ __retres = -1;
+ goto return_label;
+ }
+ if (state->x.have) {
+ unsigned char *tmp;
+ (state->x.have) --;
+ (state->x.pos) ++;
+ tmp = state->x.next;
+ (state->x.next) ++;
+ ;
+ __retres = (int)*tmp;
+ goto return_label;
+ }
+ tmp_0 = gz_read(state,(void *)(buf),(unsigned long)1);
+ ret = (int)tmp_0;
+ if (ret < 1) tmp_1 = -1; else tmp_1 = (int)buf[0];
+ __retres = tmp_1;
+ return_label: return __retres;
+}
+
+int gzgetc_(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+int gzgetc_(gzFile file)
+{
+ int tmp;
+ tmp = gzgetc(file);
+ return tmp;
+}
+
+int gzungetc(int c, gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+int gzungetc(int c, gzFile file)
+{
+ int __retres;
+ gz_statep state;
+ if (file == (gzFile)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode != 7247) {
+ __retres = -1;
+ goto return_label;
+ }
+ else
+ if (state->err != 0)
+ if (state->err != -5) {
+ __retres = -1;
+ goto return_label;
+ }
+ if (state->seek) {
+ int tmp;
+ state->seek = 0;
+ tmp = gz_skip(state,state->skip);
+ if (tmp == -1) {
+ __retres = -1;
+ goto return_label;
+ }
+ }
+ if (c < 0) {
+ __retres = -1;
+ goto return_label;
+ }
+ if (state->x.have == (unsigned int)0) {
+ state->x.have = (unsigned int)1;
+ state->x.next = (state->out + (state->size << 1)) - 1;
+ *(state->x.next + 0) = (unsigned char)c;
+ (state->x.pos) --;
+ state->past = 0;
+ __retres = c;
+ goto return_label;
+ }
+ if (state->x.have == state->size << 1) {
+ gz_error(state,-3,"out of room to push characters");
+ __retres = -1;
+ goto return_label;
+ }
+ if (state->x.next == state->out) {
+ unsigned char *src = state->out + state->x.have;
+ unsigned char *dest = state->out + (state->size << 1);
+ while (src > state->out) {
+ dest --;
+ src --;
+ *dest = *src;
+ }
+ state->x.next = dest;
+ }
+ (state->x.have) ++;
+ (state->x.next) --;
+ *(state->x.next + 0) = (unsigned char)c;
+ (state->x.pos) --;
+ state->past = 0;
+ __retres = c;
+ return_label: return __retres;
+}
+
+char *gzgets(gzFile file, char *buf, int len) __attribute__((__FC_OLDSTYLEPROTO__));
+char *gzgets(gzFile file, char *buf, int len)
+{
+ char *__retres;
+ unsigned int left;
+ unsigned int n;
+ char *str;
+ unsigned char *eol;
+ gz_statep state;
+ if (file == (gzFile)0) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ else
+ if (buf == (char *)0) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ else
+ if (len < 1) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode != 7247) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ else
+ if (state->err != 0)
+ if (state->err != -5) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ if (state->seek) {
+ int tmp;
+ state->seek = 0;
+ tmp = gz_skip(state,state->skip);
+ if (tmp == -1) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ }
+ str = buf;
+ left = (unsigned int)len - (unsigned int)1;
+ if (left)
+ while (1) {
+ if (state->x.have == (unsigned int)0) {
+ int tmp_0;
+ tmp_0 = gz_fetch(state);
+ if (tmp_0 == -1) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ }
+ if (state->x.have == (unsigned int)0) {
+ state->past = 1;
+ break;
+ }
+ if (state->x.have > left) n = left; else n = state->x.have;
+ eol = (unsigned char *)memchr((void const *)state->x.next,'\n',
+ (unsigned long)n);
+ if (eol != (unsigned char *)0) n = (unsigned int)(eol - state->x.next) + (unsigned int)1;
+ memcpy((void *)buf,(void const *)state->x.next,(unsigned long)n);
+ state->x.have -= n;
+ state->x.next += n;
+ state->x.pos += (long)n;
+ left -= n;
+ buf += n;
+ if (left) {
+ if (! (eol == (unsigned char *)0)) break;
+ }
+ else break;
+ }
+ if (buf == str) {
+ __retres = (char *)0;
+ goto return_label;
+ }
+ *(buf + 0) = (char)0;
+ __retres = str;
+ return_label: return __retres;
+}
+
+int gzdirect(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+int gzdirect(gzFile file)
+{
+ int __retres;
+ gz_statep state;
+ if (file == (gzFile)0) {
+ __retres = 0;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode == 7247)
+ if (state->how == 0)
+ if (state->x.have == (unsigned int)0) gz_look(state);
+ __retres = state->direct;
+ return_label: return __retres;
+}
+
+int gzclose_r(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+int gzclose_r(gzFile file)
+{
+ int __retres;
+ int ret;
+ int err;
+ gz_statep state;
+ int tmp;
+ if (file == (gzFile)0) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode != 7247) {
+ __retres = -2;
+ goto return_label;
+ }
+ if (state->size) {
+ inflateEnd(& state->strm);
+ free((void *)state->out);
+ free((void *)state->in);
+ }
+ if (state->err == -5) err = -5; else err = 0;
+ gz_error(state,0,(char const *)0);
+ free((void *)state->path);
+ ret = close(state->fd);
+ free((void *)state);
+ if (ret) tmp = -1; else tmp = err;
+ __retres = tmp;
+ return_label: return __retres;
+}
+
+static int gz_init(gz_statep state) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static int gz_comp(gz_statep state, int flush) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static int gz_zero(gz_statep state, long len) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static z_size_t gz_write(gz_statep state, voidpc buf, z_size_t len) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static int gz_init(gz_statep state) __attribute__((__FC_OLDSTYLEPROTO__));
+static int gz_init(gz_statep state)
+{
+ int __retres;
+ int ret;
+ z_streamp strm = & state->strm;
+ state->in = (unsigned char *)malloc((unsigned long)(state->want << 1));
+ if (state->in == (unsigned char *)0) {
+ gz_error(state,-4,"out of memory");
+ __retres = -1;
+ goto return_label;
+ }
+ if (! state->direct) {
+ state->out = (unsigned char *)malloc((unsigned long)state->want);
+ if (state->out == (unsigned char *)0) {
+ free((void *)state->in);
+ gz_error(state,-4,"out of memory");
+ __retres = -1;
+ goto return_label;
+ }
+ strm->zalloc = (voidpf (*)(voidpf opaque, uInt items, uInt size))0;
+ strm->zfree = (void (*)(voidpf opaque, voidpf address))0;
+ strm->opaque = (void *)0;
+ ret = deflateInit2_(strm,state->level,8,15 + 16,8,state->strategy,
+ "1.2.11",(int)sizeof(z_stream));
+ if (ret != 0) {
+ free((void *)state->out);
+ free((void *)state->in);
+ gz_error(state,-4,"out of memory");
+ __retres = -1;
+ goto return_label;
+ }
+ strm->next_in = (Bytef *)0;
+ }
+ state->size = state->want;
+ if (! state->direct) {
+ strm->avail_out = state->size;
+ strm->next_out = state->out;
+ state->x.next = strm->next_out;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int gz_comp(gz_statep state, int flush) __attribute__((__FC_OLDSTYLEPROTO__));
+static int gz_comp(gz_statep state, int flush)
+{
+ int __retres;
+ int ret;
+ int writ;
+ unsigned int have;
+ unsigned int put;
+ unsigned int max = ((unsigned int)(-1) >> 2) + (unsigned int)1;
+ z_streamp strm = & state->strm;
+ if (state->size == (unsigned int)0) {
+ int tmp;
+ tmp = gz_init(state);
+ if (tmp == -1) {
+ __retres = -1;
+ goto return_label;
+ }
+ }
+ if (state->direct) {
+ while (strm->avail_in) {
+ ssize_t tmp_0;
+ if (strm->avail_in > max) put = max; else put = strm->avail_in;
+ tmp_0 = write(state->fd,(void const *)strm->next_in,(unsigned long)put);
+ writ = (int)tmp_0;
+ if (writ < 0) {
+ char *tmp_1;
+ tmp_1 = strerror(__fc_errno);
+ ;
+ gz_error(state,-1,(char const *)tmp_1);
+ __retres = -1;
+ goto return_label;
+ }
+ strm->avail_in -= (unsigned int)writ;
+ strm->next_in += writ;
+ }
+ __retres = 0;
+ goto return_label;
+ }
+ ret = 0;
+ while (1) {
+ if (strm->avail_out == (uInt)0) goto _LOR_0;
+ else
+ if (flush != 0)
+ if (flush != 4) goto _LOR_0;
+ else
+ if (ret == 1) {
+ _LOR_0:
+ {
+ while (strm->next_out > state->x.next) {
+ ssize_t tmp_2;
+ if (strm->next_out - state->x.next > (long)((int)max))
+ put = max;
+ else put = (unsigned int)(strm->next_out - state->x.next);
+ tmp_2 = write(state->fd,(void const *)state->x.next,
+ (unsigned long)put);
+ writ = (int)tmp_2;
+ if (writ < 0) {
+ char *tmp_3;
+ tmp_3 = strerror(__fc_errno);
+ ;
+ gz_error(state,-1,(char const *)tmp_3);
+ __retres = -1;
+ goto return_label;
+ }
+ state->x.next += writ;
+ }
+ if (strm->avail_out == (uInt)0) {
+ strm->avail_out = state->size;
+ strm->next_out = state->out;
+ state->x.next = state->out;
+ }
+ }
+ }
+ have = strm->avail_out;
+ ret = deflate(strm,flush);
+ if (ret == -2) {
+ gz_error(state,-2,"internal error: deflate stream corrupt");
+ __retres = -1;
+ goto return_label;
+ }
+ have -= strm->avail_out;
+ if (! have) break;
+ }
+ if (flush == 4) deflateReset(strm);
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int gz_zero(gz_statep state, long len) __attribute__((__FC_OLDSTYLEPROTO__));
+static int gz_zero(gz_statep state, long len)
+{
+ int __retres;
+ int first;
+ unsigned int n;
+ z_streamp strm = & state->strm;
+ if (strm->avail_in) {
+ int tmp;
+ tmp = gz_comp(state,0);
+ if (tmp == -1) {
+ __retres = -1;
+ goto return_label;
+ }
+ }
+ first = 1;
+ while (len) {
+ int tmp_0;
+ if (sizeof(int) == sizeof(long)) {
+ if (state->size > (unsigned int)2147483647) n = (unsigned int)len;
+ else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if ((long)state->size > len) n = (unsigned int)len;
+ else n = state->size;
+ }
+ if (first) {
+ memset((void *)state->in,0,(unsigned long)n);
+ first = 0;
+ }
+ strm->avail_in = n;
+ strm->next_in = state->in;
+ state->x.pos += (long)n;
+ tmp_0 = gz_comp(state,0);
+ if (tmp_0 == -1) {
+ __retres = -1;
+ goto return_label;
+ }
+ len -= (long)n;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static z_size_t gz_write(gz_statep state, voidpc buf, z_size_t len) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static z_size_t gz_write(gz_statep state, voidpc buf, z_size_t len)
+{
+ z_size_t __retres;
+ z_size_t put = len;
+ if (len == (z_size_t)0) {
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ if (state->size == (unsigned int)0) {
+ int tmp;
+ tmp = gz_init(state);
+ if (tmp == -1) {
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ }
+ if (state->seek) {
+ int tmp_0;
+ state->seek = 0;
+ tmp_0 = gz_zero(state,state->skip);
+ if (tmp_0 == -1) {
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ }
+ if (len < (z_size_t)state->size)
+ while (1) {
+ {
+ unsigned int have;
+ unsigned int copy;
+ if (state->strm.avail_in == (uInt)0) state->strm.next_in = state->in;
+ have = (unsigned int)((state->strm.next_in + state->strm.avail_in) - state->in);
+ copy = state->size - have;
+ if ((z_size_t)copy > len) copy = (unsigned int)len;
+ memcpy((void *)(state->in + have),buf,(unsigned long)copy);
+ state->strm.avail_in += copy;
+ state->x.pos += (long)copy;
+ buf = (void const *)((char const *)buf + copy);
+ len -= (z_size_t)copy;
+ if (len) {
+ int tmp_1;
+ tmp_1 = gz_comp(state,0);
+ if (tmp_1 == -1) {
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ }
+ }
+ if (! len) break;
+ }
+ else {
+ if (state->strm.avail_in) {
+ int tmp_2;
+ tmp_2 = gz_comp(state,0);
+ if (tmp_2 == -1) {
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ }
+ state->strm.next_in = (Bytef *)buf;
+ while (1) {
+ {
+ int tmp_3;
+ unsigned int n = (unsigned int)(-1);
+ if ((z_size_t)n > len) n = (unsigned int)len;
+ state->strm.avail_in = n;
+ state->x.pos += (long)n;
+ tmp_3 = gz_comp(state,0);
+ if (tmp_3 == -1) {
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ len -= (z_size_t)n;
+ }
+ if (! len) break;
+ }
+ }
+ __retres = put;
+ return_label: return __retres;
+}
+
+int gzwrite(gzFile file, voidpc buf, unsigned int len) __attribute__((
+__FC_OLDSTYLEPROTO__));
+int gzwrite(gzFile file, voidpc buf, unsigned int len)
+{
+ int __retres;
+ gz_statep state;
+ z_size_t tmp;
+ if (file == (gzFile)0) {
+ __retres = 0;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode != 31153) {
+ __retres = 0;
+ goto return_label;
+ }
+ else
+ if (state->err != 0) {
+ __retres = 0;
+ goto return_label;
+ }
+ if ((int)len < 0) {
+ gz_error(state,-3,"requested length does not fit in int");
+ __retres = 0;
+ goto return_label;
+ }
+ tmp = gz_write(state,buf,(unsigned long)len);
+ __retres = (int)tmp;
+ return_label: return __retres;
+}
+
+z_size_t gzfwrite(voidpc buf, z_size_t size, z_size_t nitems, gzFile file) __attribute__((
+__FC_OLDSTYLEPROTO__));
+z_size_t gzfwrite(voidpc buf, z_size_t size, z_size_t nitems, gzFile file)
+{
+ z_size_t __retres;
+ z_size_t len;
+ gz_statep state;
+ z_size_t tmp_0;
+ if (file == (gzFile)0) {
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode != 31153) {
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ else
+ if (state->err != 0) {
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ len = nitems * size;
+ if (size)
+ if (len / size != nitems) {
+ gz_error(state,-2,"request does not fit in a size_t");
+ __retres = (unsigned long)0;
+ goto return_label;
+ }
+ if (len) {
+ z_size_t tmp;
+ tmp = gz_write(state,buf,len);
+ tmp_0 = tmp / size;
+ }
+ else tmp_0 = (unsigned long)0;
+ __retres = tmp_0;
+ return_label: return __retres;
+}
+
+int gzputc(gzFile file, int c) __attribute__((__FC_OLDSTYLEPROTO__));
+int gzputc(gzFile file, int c)
+{
+ int __retres;
+ unsigned int have;
+ unsigned char buf[1];
+ gz_statep state;
+ z_streamp strm;
+ z_size_t tmp_0;
+ if (file == (gzFile)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ strm = & state->strm;
+ if (state->mode != 31153) {
+ __retres = -1;
+ goto return_label;
+ }
+ else
+ if (state->err != 0) {
+ __retres = -1;
+ goto return_label;
+ }
+ if (state->seek) {
+ int tmp;
+ state->seek = 0;
+ tmp = gz_zero(state,state->skip);
+ if (tmp == -1) {
+ __retres = -1;
+ goto return_label;
+ }
+ }
+ if (state->size) {
+ if (strm->avail_in == (uInt)0) strm->next_in = state->in;
+ have = (unsigned int)((strm->next_in + strm->avail_in) - state->in);
+ if (have < state->size) {
+ *(state->in + have) = (unsigned char)c;
+ (strm->avail_in) ++;
+ (state->x.pos) ++;
+ __retres = c & 0xff;
+ goto return_label;
+ }
+ }
+ buf[0] = (unsigned char)c;
+ tmp_0 = gz_write(state,(void const *)(buf),(unsigned long)1);
+ if (tmp_0 != (z_size_t)1) {
+ __retres = -1;
+ goto return_label;
+ }
+ __retres = c & 0xff;
+ return_label: return __retres;
+}
+
+int gzputs(gzFile file, char const *str) __attribute__((__FC_OLDSTYLEPROTO__));
+int gzputs(gzFile file, char const *str)
+{
+ int __retres;
+ int ret;
+ z_size_t len;
+ gz_statep state;
+ z_size_t tmp;
+ int tmp_0;
+ if (file == (gzFile)0) {
+ __retres = -1;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode != 31153) {
+ __retres = -1;
+ goto return_label;
+ }
+ else
+ if (state->err != 0) {
+ __retres = -1;
+ goto return_label;
+ }
+ len = strlen(str);
+ tmp = gz_write(state,(void const *)str,len);
+ ret = (int)tmp;
+ if (ret == 0)
+ if (len != (z_size_t)0) tmp_0 = -1; else tmp_0 = ret;
+ else tmp_0 = ret;
+ __retres = tmp_0;
+ return_label: return __retres;
+}
+
+int gzvprintf(gzFile file, char const *format, va_list va)
+{
+ int __retres;
+ int len;
+ unsigned int left;
+ char *next;
+ gz_statep state;
+ z_streamp strm;
+ if (file == (gzFile)0) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ strm = & state->strm;
+ if (state->mode != 31153) {
+ __retres = -2;
+ goto return_label;
+ }
+ else
+ if (state->err != 0) {
+ __retres = -2;
+ goto return_label;
+ }
+ if (state->size == (unsigned int)0) {
+ int tmp;
+ tmp = gz_init(state);
+ if (tmp == -1) {
+ __retres = state->err;
+ goto return_label;
+ }
+ }
+ if (state->seek) {
+ int tmp_0;
+ state->seek = 0;
+ tmp_0 = gz_zero(state,state->skip);
+ if (tmp_0 == -1) {
+ __retres = state->err;
+ goto return_label;
+ }
+ }
+ if (strm->avail_in == (uInt)0) strm->next_in = state->in;
+ next = (char *)((state->in + (strm->next_in - state->in)) + strm->avail_in);
+ *(next + (state->size - (unsigned int)1)) = (char)0;
+ len = vsnprintf(next,(unsigned long)state->size,format,va);
+ if (len == 0) {
+ __retres = 0;
+ goto return_label;
+ }
+ else
+ if ((unsigned int)len >= state->size) {
+ __retres = 0;
+ goto return_label;
+ }
+ else
+ if ((int)*(next + (state->size - (unsigned int)1)) != 0) {
+ __retres = 0;
+ goto return_label;
+ }
+ strm->avail_in += (unsigned int)len;
+ state->x.pos += (long)len;
+ if (strm->avail_in >= state->size) {
+ int tmp_1;
+ left = strm->avail_in - state->size;
+ strm->avail_in = state->size;
+ tmp_1 = gz_comp(state,0);
+ if (tmp_1 == -1) {
+ __retres = state->err;
+ goto return_label;
+ }
+ memcpy((void *)state->in,(void const *)(state->in + state->size),
+ (unsigned long)left);
+ strm->next_in = state->in;
+ strm->avail_in = left;
+ }
+ __retres = len;
+ return_label: return __retres;
+}
+
+int gzprintf(gzFile file, char const *format, void * const *__va_params)
+{
+ va_list va;
+ int ret;
+ va = __va_params;
+ ret = gzvprintf(file,format,va);
+ return ret;
+}
+
+int gzflush(gzFile file, int flush) __attribute__((__FC_OLDSTYLEPROTO__));
+int gzflush(gzFile file, int flush)
+{
+ int __retres;
+ gz_statep state;
+ if (file == (gzFile)0) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode != 31153) {
+ __retres = -2;
+ goto return_label;
+ }
+ else
+ if (state->err != 0) {
+ __retres = -2;
+ goto return_label;
+ }
+ if (flush < 0) {
+ __retres = -2;
+ goto return_label;
+ }
+ else
+ if (flush > 4) {
+ __retres = -2;
+ goto return_label;
+ }
+ if (state->seek) {
+ int tmp;
+ state->seek = 0;
+ tmp = gz_zero(state,state->skip);
+ if (tmp == -1) {
+ __retres = state->err;
+ goto return_label;
+ }
+ }
+ gz_comp(state,flush);
+ __retres = state->err;
+ return_label: return __retres;
+}
+
+int gzsetparams(gzFile file, int level, int strategy) __attribute__((
+__FC_OLDSTYLEPROTO__));
+int gzsetparams(gzFile file, int level, int strategy)
+{
+ int __retres;
+ gz_statep state;
+ z_streamp strm;
+ if (file == (gzFile)0) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ strm = & state->strm;
+ if (state->mode != 31153) {
+ __retres = -2;
+ goto return_label;
+ }
+ else
+ if (state->err != 0) {
+ __retres = -2;
+ goto return_label;
+ }
+ if (level == state->level)
+ if (strategy == state->strategy) {
+ __retres = 0;
+ goto return_label;
+ }
+ if (state->seek) {
+ int tmp;
+ state->seek = 0;
+ tmp = gz_zero(state,state->skip);
+ if (tmp == -1) {
+ __retres = state->err;
+ goto return_label;
+ }
+ }
+ if (state->size) {
+ if (strm->avail_in) {
+ int tmp_0;
+ tmp_0 = gz_comp(state,5);
+ if (tmp_0 == -1) {
+ __retres = state->err;
+ goto return_label;
+ }
+ }
+ deflateParams(strm,level,strategy);
+ }
+ state->level = level;
+ state->strategy = strategy;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int gzclose_w(gzFile file) __attribute__((__FC_OLDSTYLEPROTO__));
+int gzclose_w(gzFile file)
+{
+ int __retres;
+ gz_statep state;
+ int tmp_0;
+ int tmp_1;
+ int ret = 0;
+ if (file == (gzFile)0) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (gz_state *)file;
+ if (state->mode != 31153) {
+ __retres = -2;
+ goto return_label;
+ }
+ if (state->seek) {
+ int tmp;
+ state->seek = 0;
+ tmp = gz_zero(state,state->skip);
+ if (tmp == -1) ret = state->err;
+ }
+ tmp_0 = gz_comp(state,4);
+ if (tmp_0 == -1) ret = state->err;
+ if (state->size) {
+ if (! state->direct) {
+ deflateEnd(& state->strm);
+ free((void *)state->out);
+ }
+ free((void *)state->in);
+ }
+ gz_error(state,0,(char const *)0);
+ free((void *)state->path);
+ tmp_1 = close(state->fd);
+ if (tmp_1 == -1) ret = -1;
+ free((void *)state);
+ __retres = ret;
+ return_label: return __retres;
+}
+
+int inflate_table(codetype type, unsigned short *lens, unsigned int codes,
+ code **table, unsigned int *bits, unsigned short *work) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+void inflate_fast(z_streamp strm, unsigned int start) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static void fixedtables(struct inflate_state *state) __attribute__((__FC_OLDSTYLEPROTO__));
+
+int inflateBackInit_(z_streamp strm, int windowBits, unsigned char *window,
+ char const *version, int stream_size) __attribute__((
+__FC_OLDSTYLEPROTO__));
+int inflateBackInit_(z_streamp strm, int windowBits, unsigned char *window,
+ char const *version, int stream_size)
+{
+ int __retres;
+ struct inflate_state *state;
+ if (version == (char const *)0) {
+ __retres = -6;
+ goto return_label;
+ }
+ else
+ if ((int)*(version + 0) != (int)*("1.2.11" + 0)) {
+ __retres = -6;
+ goto return_label;
+ }
+ else
+ if (stream_size != (int)sizeof(z_stream)) {
+ __retres = -6;
+ goto return_label;
+ }
+ if (strm == (z_streamp)0) {
+ __retres = -2;
+ goto return_label;
+ }
+ else
+ if (window == (unsigned char *)0) {
+ __retres = -2;
+ goto return_label;
+ }
+ else
+ if (windowBits < 8) {
+ __retres = -2;
+ goto return_label;
+ }
+ else
+ if (windowBits > 15) {
+ __retres = -2;
+ goto return_label;
+ }
+ strm->msg = (char *)0;
+ if (strm->zalloc == (voidpf (*)(voidpf opaque, uInt items, uInt size))0) {
+ strm->zalloc = & zcalloc;
+ strm->opaque = (void *)0;
+ }
+ if (strm->zfree == (void (*)(voidpf opaque, voidpf address))0) strm->zfree = & zcfree;
+ state = (struct inflate_state *)(*(strm->zalloc))(strm->opaque,
+ (unsigned int)1,
+ (unsigned int)sizeof(struct inflate_state));
+ if (state == (struct inflate_state *)0) {
+ __retres = -4;
+ goto return_label;
+ }
+ strm->state = (struct internal_state *)state;
+ state->dmax = 32768U;
+ state->wbits = (unsigned int)windowBits;
+ state->wsize = 1U << windowBits;
+ state->window = window;
+ state->wnext = (unsigned int)0;
+ state->whave = (unsigned int)0;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static code const fixedtables_lenfix[512] =
+ {{.op = (unsigned char)96,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)80},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)16},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)115},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)31},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)112},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)48},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)192},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)10},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)96},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)32},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)160},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)128},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)64},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)224},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)6},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)88},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)24},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)144},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)59},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)120},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)56},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)208},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)17},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)104},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)40},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)176},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)8},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)136},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)72},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)240},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)4},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)84},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)20},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)227},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)43},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)116},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)52},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)200},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)13},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)100},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)36},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)168},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)4},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)132},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)68},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)232},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)8},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)92},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)28},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)152},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)83},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)124},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)60},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)216},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)23},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)108},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)44},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)184},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)12},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)140},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)76},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)248},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)3},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)82},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)18},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)163},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)35},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)114},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)50},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)196},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)11},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)98},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)34},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)164},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)2},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)130},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)66},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)228},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)7},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)90},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)26},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)148},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)67},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)122},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)58},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)212},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)19},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)106},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)42},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)180},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)10},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)138},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)74},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)244},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)5},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)86},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)22},
+ {.op = (unsigned char)64,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)51},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)118},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)54},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)204},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)15},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)102},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)38},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)172},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)6},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)134},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)70},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)236},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)9},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)94},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)30},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)156},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)99},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)126},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)62},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)220},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)27},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)110},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)46},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)188},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)14},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)142},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)78},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)252},
+ {.op = (unsigned char)96,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)81},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)17},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)131},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)31},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)113},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)49},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)194},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)10},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)97},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)33},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)162},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)1},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)129},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)65},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)226},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)6},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)89},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)25},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)146},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)59},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)121},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)57},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)210},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)17},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)105},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)41},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)178},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)9},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)137},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)73},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)242},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)4},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)85},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)21},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)258},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)43},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)117},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)53},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)202},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)13},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)101},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)37},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)170},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)5},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)133},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)69},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)234},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)8},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)93},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)29},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)154},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)83},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)125},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)61},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)218},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)23},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)109},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)45},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)186},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)13},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)141},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)77},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)250},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)3},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)83},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)19},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)195},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)35},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)115},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)51},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)198},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)11},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)99},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)35},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)166},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)3},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)131},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)67},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)230},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)7},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)91},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)27},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)150},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)67},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)123},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)59},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)214},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)19},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)107},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)43},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)182},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)11},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)139},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)75},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)246},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)5},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)87},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)23},
+ {.op = (unsigned char)64,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)51},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)119},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)55},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)206},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)15},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)103},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)39},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)174},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)7},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)135},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)71},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)238},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)9},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)95},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)31},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)158},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)99},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)127},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)63},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)222},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)27},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)111},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)47},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)190},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)15},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)143},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)79},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)254},
+ {.op = (unsigned char)96,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)80},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)16},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)115},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)31},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)112},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)48},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)193},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)10},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)96},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)32},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)161},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)128},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)64},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)225},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)6},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)88},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)24},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)145},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)59},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)120},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)56},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)209},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)17},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)104},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)40},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)177},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)8},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)136},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)72},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)241},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)4},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)84},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)20},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)227},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)43},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)116},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)52},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)201},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)13},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)100},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)36},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)169},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)4},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)132},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)68},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)233},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)8},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)92},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)28},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)153},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)83},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)124},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)60},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)217},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)23},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)108},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)44},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)185},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)12},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)140},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)76},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)249},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)3},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)82},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)18},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)163},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)35},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)114},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)50},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)197},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)11},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)98},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)34},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)165},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)2},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)130},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)66},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)229},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)7},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)90},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)26},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)149},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)67},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)122},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)58},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)213},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)19},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)106},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)42},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)181},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)10},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)138},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)74},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)245},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)5},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)86},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)22},
+ {.op = (unsigned char)64,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)51},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)118},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)54},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)205},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)15},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)102},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)38},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)173},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)6},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)134},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)70},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)237},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)9},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)94},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)30},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)157},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)99},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)126},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)62},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)221},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)27},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)110},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)46},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)189},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)14},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)142},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)78},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)253},
+ {.op = (unsigned char)96,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)81},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)17},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)131},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)31},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)113},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)49},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)195},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)10},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)97},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)33},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)163},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)1},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)129},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)65},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)227},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)6},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)89},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)25},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)147},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)59},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)121},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)57},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)211},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)17},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)105},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)41},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)179},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)9},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)137},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)73},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)243},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)4},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)85},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)21},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)258},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)43},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)117},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)53},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)203},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)13},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)101},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)37},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)171},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)5},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)133},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)69},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)235},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)8},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)93},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)29},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)155},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)83},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)125},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)61},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)219},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)23},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)109},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)45},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)187},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)13},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)141},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)77},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)251},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)3},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)83},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)19},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)195},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)35},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)115},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)51},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)199},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)11},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)99},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)35},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)167},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)3},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)131},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)67},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)231},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)7},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)91},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)27},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)151},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)67},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)123},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)59},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)215},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)19},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)107},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)43},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)183},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)11},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)139},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)75},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)247},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)5},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)87},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)23},
+ {.op = (unsigned char)64,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)51},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)119},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)55},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)207},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)15},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)103},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)39},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)175},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)7},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)135},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)71},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)239},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)9},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)95},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)31},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)159},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)99},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)127},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)63},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)223},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)27},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)111},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)47},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)191},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)15},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)143},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)79},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)255}};
+static code const fixedtables_distfix[32] =
+ {{.op = (unsigned char)16,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)1},
+ {.op = (unsigned char)23,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)257},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)17},
+ {.op = (unsigned char)27,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)4097},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)5},
+ {.op = (unsigned char)25,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)1025},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)65},
+ {.op = (unsigned char)29,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)16385},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)3},
+ {.op = (unsigned char)24,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)513},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)33},
+ {.op = (unsigned char)28,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)8193},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)9},
+ {.op = (unsigned char)26,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)2049},
+ {.op = (unsigned char)22,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)129},
+ {.op = (unsigned char)64,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)2},
+ {.op = (unsigned char)23,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)385},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)25},
+ {.op = (unsigned char)27,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)6145},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)7},
+ {.op = (unsigned char)25,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)1537},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)97},
+ {.op = (unsigned char)29,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)24577},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)4},
+ {.op = (unsigned char)24,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)769},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)49},
+ {.op = (unsigned char)28,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)12289},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)13},
+ {.op = (unsigned char)26,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)3073},
+ {.op = (unsigned char)22,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)193},
+ {.op = (unsigned char)64,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)0}};
+static void fixedtables(struct inflate_state *state) __attribute__((__FC_OLDSTYLEPROTO__));
+static void fixedtables(struct inflate_state *state)
+{
+ state->lencode = fixedtables_lenfix;
+ state->lenbits = (unsigned int)9;
+ state->distcode = fixedtables_distfix;
+ state->distbits = (unsigned int)5;
+ return;
+}
+
+static unsigned short const inflateBack_order[19] =
+ {(unsigned short)16,
+ (unsigned short)17,
+ (unsigned short)18,
+ (unsigned short)0,
+ (unsigned short)8,
+ (unsigned short)7,
+ (unsigned short)9,
+ (unsigned short)6,
+ (unsigned short)10,
+ (unsigned short)5,
+ (unsigned short)11,
+ (unsigned short)4,
+ (unsigned short)12,
+ (unsigned short)3,
+ (unsigned short)13,
+ (unsigned short)2,
+ (unsigned short)14,
+ (unsigned short)1,
+ (unsigned short)15};
+int inflateBack(z_streamp strm, unsigned int (*in)(void *, unsigned char **),
+ void *in_desc,
+ int (*out)(void *, unsigned char *, unsigned int ),
+ void *out_desc) __attribute__((__FC_OLDSTYLEPROTO__));
+int inflateBack(z_streamp strm, unsigned int (*in)(void *, unsigned char **),
+ void *in_desc,
+ int (*out)(void *, unsigned char *, unsigned int ),
+ void *out_desc)
+{
+ int __retres;
+ struct inflate_state *state;
+ unsigned char *next;
+ unsigned char *put;
+ unsigned int have;
+ unsigned int left;
+ unsigned long hold;
+ unsigned int bits;
+ unsigned int copy;
+ unsigned char *from;
+ code here;
+ code last;
+ unsigned int len;
+ int ret;
+ if (strm == (z_streamp)0) {
+ __retres = -2;
+ goto return_label;
+ }
+ else
+ if (strm->state == (struct internal_state *)0) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (struct inflate_state *)strm->state;
+ strm->msg = (char *)0;
+ state->mode = TYPE;
+ state->last = 0;
+ state->whave = (unsigned int)0;
+ next = strm->next_in;
+ if (next != (unsigned char *)0) have = strm->avail_in;
+ else have = (unsigned int)0;
+ hold = (unsigned long)0;
+ bits = (unsigned int)0;
+ put = state->window;
+ left = state->wsize;
+ while (1)
+ switch (state->mode) {
+ unsigned int tmp_21;
+ case (inflate_mode)TYPE: ;
+ if (state->last) {
+ hold >>= bits & (unsigned int)7;
+ bits -= bits & (unsigned int)7;
+ state->mode = DONE;
+ break;
+ }
+ while (bits < (unsigned int)3) {
+ unsigned char *tmp;
+ if (have == (unsigned int)0) {
+ have = (*in)(in_desc,& next);
+ if (have == (unsigned int)0) {
+ next = (unsigned char *)0;
+ ret = -5;
+ goto inf_leave;
+ }
+ }
+ have --;
+ tmp = next;
+ next ++;
+ hold += (unsigned long)*tmp << bits;
+ bits += (unsigned int)8;
+ }
+ state->last = (int)((unsigned int)hold & ((1U << 1) - (unsigned int)1));
+ hold >>= 1;
+ bits -= (unsigned int)1;
+ switch ((unsigned int)hold & ((1U << 2) - (unsigned int)1)) {
+ case (unsigned int)0: ;
+ state->mode = STORED;
+ break;
+ case (unsigned int)1: fixedtables(state);
+ state->mode = LEN;
+ break;
+ case (unsigned int)2: ;
+ state->mode = TABLE;
+ break;
+ case (unsigned int)3: strm->msg = (char *)"invalid block type";
+ state->mode = BAD;
+ }
+ hold >>= 2;
+ bits -= (unsigned int)2;
+ break;
+ case (inflate_mode)STORED:
+ {
+ hold >>= bits & (unsigned int)7;
+ bits -= bits & (unsigned int)7;
+ }
+ while (bits < (unsigned int)32) {
+ unsigned char *tmp_0;
+ if (have == (unsigned int)0) {
+ have = (*in)(in_desc,& next);
+ if (have == (unsigned int)0) {
+ next = (unsigned char *)0;
+ ret = -5;
+ goto inf_leave;
+ }
+ }
+ have --;
+ tmp_0 = next;
+ next ++;
+ hold += (unsigned long)*tmp_0 << bits;
+ bits += (unsigned int)8;
+ }
+ if ((hold & (unsigned long)0xffff) != ((hold >> 16) ^ (unsigned long)0xffff)) {
+ strm->msg = (char *)"invalid stored block lengths";
+ state->mode = BAD;
+ break;
+ }
+ state->length = (unsigned int)hold & (unsigned int)0xffff;
+ hold = (unsigned long)0;
+ bits = (unsigned int)0;
+ while (state->length != (unsigned int)0) {
+ copy = state->length;
+ if (have == (unsigned int)0) {
+ have = (*in)(in_desc,& next);
+ if (have == (unsigned int)0) {
+ next = (unsigned char *)0;
+ ret = -5;
+ goto inf_leave;
+ }
+ }
+ if (left == (unsigned int)0) {
+ int tmp_1;
+ put = state->window;
+ left = state->wsize;
+ state->whave = left;
+ tmp_1 = (*out)(out_desc,put,left);
+ if (tmp_1) {
+ ret = -5;
+ goto inf_leave;
+ }
+ }
+ if (copy > have) copy = have;
+ if (copy > left) copy = left;
+ memcpy((void *)put,(void const *)next,(unsigned long)copy);
+ have -= copy;
+ next += copy;
+ left -= copy;
+ put += copy;
+ state->length -= copy;
+ }
+ state->mode = TYPE;
+ break;
+ case (inflate_mode)TABLE:
+ while (bits < (unsigned int)14) {
+ unsigned char *tmp_2;
+ if (have == (unsigned int)0) {
+ have = (*in)(in_desc,& next);
+ if (have == (unsigned int)0) {
+ next = (unsigned char *)0;
+ ret = -5;
+ goto inf_leave;
+ }
+ }
+ have --;
+ tmp_2 = next;
+ next ++;
+ hold += (unsigned long)*tmp_2 << bits;
+ bits += (unsigned int)8;
+ }
+ state->nlen = ((unsigned int)hold & ((1U << 5) - (unsigned int)1)) + (unsigned int)257;
+ hold >>= 5;
+ bits -= (unsigned int)5;
+ state->ndist = ((unsigned int)hold & ((1U << 5) - (unsigned int)1)) + (unsigned int)1;
+ hold >>= 5;
+ bits -= (unsigned int)5;
+ state->ncode = ((unsigned int)hold & ((1U << 4) - (unsigned int)1)) + (unsigned int)4;
+ hold >>= 4;
+ bits -= (unsigned int)4;
+ if (state->nlen > (unsigned int)286) goto _LOR;
+ else
+ if (state->ndist > (unsigned int)30) {
+ _LOR:
+ {
+ strm->msg = (char *)"too many length or distance symbols";
+ state->mode = BAD;
+ break;
+ }
+ }
+ state->have = (unsigned int)0;
+ while (state->have < state->ncode) {
+ unsigned int tmp_4;
+ while (bits < (unsigned int)3) {
+ unsigned char *tmp_3;
+ if (have == (unsigned int)0) {
+ have = (*in)(in_desc,& next);
+ if (have == (unsigned int)0) {
+ next = (unsigned char *)0;
+ ret = -5;
+ goto inf_leave;
+ }
+ }
+ have --;
+ tmp_3 = next;
+ next ++;
+ hold += (unsigned long)*tmp_3 << bits;
+ bits += (unsigned int)8;
+ }
+ tmp_4 = state->have;
+ (state->have) ++;
+ state->lens[inflateBack_order[tmp_4]] = (unsigned short)((unsigned int)hold & (
+ (1U << 3) - (unsigned int)1));
+ hold >>= 3;
+ bits -= (unsigned int)3;
+ }
+ while (state->have < (unsigned int)19) {
+ unsigned int tmp_5;
+ tmp_5 = state->have;
+ (state->have) ++;
+ state->lens[inflateBack_order[tmp_5]] = (unsigned short)0;
+ }
+ state->next = state->codes;
+ state->lencode = (code const *)state->next;
+ state->lenbits = (unsigned int)7;
+ ret = inflate_table(CODES,state->lens,(unsigned int)19,& state->next,
+ & state->lenbits,state->work);
+ if (ret) {
+ strm->msg = (char *)"invalid code lengths set";
+ state->mode = BAD;
+ break;
+ }
+ state->have = (unsigned int)0;
+ while (state->have < state->nlen + state->ndist) {
+ while (1) {
+ here = *(state->lencode + ((unsigned int)hold & ((1U << state->lenbits) - (unsigned int)1)));
+ if ((unsigned int)here.bits <= bits) break;
+ {
+ unsigned char *tmp_6;
+ if (have == (unsigned int)0) {
+ have = (*in)(in_desc,& next);
+ if (have == (unsigned int)0) {
+ next = (unsigned char *)0;
+ ret = -5;
+ goto inf_leave;
+ }
+ }
+ have --;
+ tmp_6 = next;
+ next ++;
+ hold += (unsigned long)*tmp_6 << bits;
+ bits += (unsigned int)8;
+ }
+ }
+ if ((int)here.val < 16) {
+ unsigned int tmp_7;
+ hold >>= (int)here.bits;
+ bits -= (unsigned int)here.bits;
+ tmp_7 = state->have;
+ (state->have) ++;
+ state->lens[tmp_7] = here.val;
+ }
+ else {
+ if ((int)here.val == 16) {
+ while (bits < (unsigned int)((int)here.bits + 2)) {
+ unsigned char *tmp_8;
+ if (have == (unsigned int)0) {
+ have = (*in)(in_desc,& next);
+ if (have == (unsigned int)0) {
+ next = (unsigned char *)0;
+ ret = -5;
+ goto inf_leave;
+ }
+ }
+ have --;
+ tmp_8 = next;
+ next ++;
+ hold += (unsigned long)*tmp_8 << bits;
+ bits += (unsigned int)8;
+ }
+ hold >>= (int)here.bits;
+ bits -= (unsigned int)here.bits;
+ if (state->have == (unsigned int)0) {
+ strm->msg = (char *)"invalid bit length repeat";
+ state->mode = BAD;
+ break;
+ }
+ len = (unsigned int)state->lens[state->have - (unsigned int)1];
+ copy = (unsigned int)3 + ((unsigned int)hold & ((1U << 2) - (unsigned int)1));
+ hold >>= 2;
+ bits -= (unsigned int)2;
+ }
+ else
+ if ((int)here.val == 17) {
+ while (bits < (unsigned int)((int)here.bits + 3)) {
+ unsigned char *tmp_9;
+ if (have == (unsigned int)0) {
+ have = (*in)(in_desc,& next);
+ if (have == (unsigned int)0) {
+ next = (unsigned char *)0;
+ ret = -5;
+ goto inf_leave;
+ }
+ }
+ have --;
+ tmp_9 = next;
+ next ++;
+ hold += (unsigned long)*tmp_9 << bits;
+ bits += (unsigned int)8;
+ }
+ hold >>= (int)here.bits;
+ bits -= (unsigned int)here.bits;
+ len = (unsigned int)0;
+ copy = (unsigned int)3 + ((unsigned int)hold & ((1U << 3) - (unsigned int)1));
+ hold >>= 3;
+ bits -= (unsigned int)3;
+ }
+ else {
+ while (bits < (unsigned int)((int)here.bits + 7)) {
+ unsigned char *tmp_10;
+ if (have == (unsigned int)0) {
+ have = (*in)(in_desc,& next);
+ if (have == (unsigned int)0) {
+ next = (unsigned char *)0;
+ ret = -5;
+ goto inf_leave;
+ }
+ }
+ have --;
+ tmp_10 = next;
+ next ++;
+ hold += (unsigned long)*tmp_10 << bits;
+ bits += (unsigned int)8;
+ }
+ hold >>= (int)here.bits;
+ bits -= (unsigned int)here.bits;
+ len = (unsigned int)0;
+ copy = (unsigned int)11 + ((unsigned int)hold & ((1U << 7) - (unsigned int)1));
+ hold >>= 7;
+ bits -= (unsigned int)7;
+ }
+ if (state->have + copy > state->nlen + state->ndist) {
+ strm->msg = (char *)"invalid bit length repeat";
+ state->mode = BAD;
+ break;
+ }
+ while (1) {
+ unsigned int tmp_12;
+ unsigned int tmp_11;
+ tmp_12 = copy;
+ copy --;
+ ;
+ if (! tmp_12) break;
+ tmp_11 = state->have;
+ (state->have) ++;
+ state->lens[tmp_11] = (unsigned short)len;
+ }
+ }
+ }
+ if (state->mode == (unsigned int)BAD) break;
+ if ((int)state->lens[256] == 0) {
+ strm->msg = (char *)"invalid code -- missing end-of-block";
+ state->mode = BAD;
+ break;
+ }
+ state->next = state->codes;
+ state->lencode = (code const *)state->next;
+ state->lenbits = (unsigned int)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 *)state->next;
+ state->distbits = (unsigned int)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;
+ }
+ state->mode = LEN;
+ case (inflate_mode)LEN: ;
+ if (have >= (unsigned int)6)
+ if (left >= (unsigned int)258) {
+ strm->next_out = put;
+ strm->avail_out = left;
+ strm->next_in = next;
+ strm->avail_in = have;
+ state->hold = hold;
+ state->bits = bits;
+ if (state->whave < state->wsize) state->whave = state->wsize - left;
+ inflate_fast(strm,state->wsize);
+ put = strm->next_out;
+ left = strm->avail_out;
+ next = strm->next_in;
+ have = strm->avail_in;
+ hold = state->hold;
+ bits = state->bits;
+ break;
+ }
+ while (1) {
+ here = *(state->lencode + ((unsigned int)hold & ((1U << state->lenbits) - (unsigned int)1)));
+ if ((unsigned int)here.bits <= bits) break;
+ {
+ unsigned char *tmp_13;
+ if (have == (unsigned int)0) {
+ have = (*in)(in_desc,& next);
+ if (have == (unsigned int)0) {
+ next = (unsigned char *)0;
+ ret = -5;
+ goto inf_leave;
+ }
+ }
+ have --;
+ tmp_13 = next;
+ next ++;
+ hold += (unsigned long)*tmp_13 << bits;
+ bits += (unsigned int)8;
+ }
+ }
+ if (here.op)
+ if (((int)here.op & 0xf0) == 0) {
+ last = here;
+ while (1) {
+ here = *(state->lencode + ((unsigned int)last.val + (((unsigned int)hold & (
+ (1U << (
+ (int)last.bits + (int)last.op)) - (unsigned int)1)) >> (int)last.bits)));
+ if ((unsigned int)((int)last.bits + (int)here.bits) <= bits)
+ break;
+ {
+ unsigned char *tmp_14;
+ if (have == (unsigned int)0) {
+ have = (*in)(in_desc,& next);
+ if (have == (unsigned int)0) {
+ next = (unsigned char *)0;
+ ret = -5;
+ goto inf_leave;
+ }
+ }
+ have --;
+ tmp_14 = next;
+ next ++;
+ hold += (unsigned long)*tmp_14 << bits;
+ bits += (unsigned int)8;
+ }
+ }
+ hold >>= (int)last.bits;
+ bits -= (unsigned int)last.bits;
+ }
+ hold >>= (int)here.bits;
+ bits -= (unsigned int)here.bits;
+ state->length = (unsigned int)here.val;
+ if ((int)here.op == 0) {
+ unsigned char *tmp_16;
+ if (left == (unsigned int)0) {
+ int tmp_15;
+ put = state->window;
+ left = state->wsize;
+ state->whave = left;
+ tmp_15 = (*out)(out_desc,put,left);
+ if (tmp_15) {
+ ret = -5;
+ goto inf_leave;
+ }
+ }
+ tmp_16 = put;
+ put ++;
+ *tmp_16 = (unsigned char)state->length;
+ left --;
+ state->mode = LEN;
+ break;
+ }
+ if ((int)here.op & 32) {
+ state->mode = TYPE;
+ break;
+ }
+ if ((int)here.op & 64) {
+ strm->msg = (char *)"invalid literal/length code";
+ state->mode = BAD;
+ break;
+ }
+ state->extra = (unsigned int)here.op & (unsigned int)15;
+ if (state->extra != (unsigned int)0) {
+ while (bits < state->extra) {
+ unsigned char *tmp_17;
+ if (have == (unsigned int)0) {
+ have = (*in)(in_desc,& next);
+ if (have == (unsigned int)0) {
+ next = (unsigned char *)0;
+ ret = -5;
+ goto inf_leave;
+ }
+ }
+ have --;
+ tmp_17 = next;
+ next ++;
+ hold += (unsigned long)*tmp_17 << bits;
+ bits += (unsigned int)8;
+ }
+ state->length += (unsigned int)hold & ((1U << state->extra) - (unsigned int)1);
+ hold >>= state->extra;
+ bits -= state->extra;
+ }
+ while (1) {
+ here = *(state->distcode + ((unsigned int)hold & ((1U << state->distbits) - (unsigned int)1)));
+ if ((unsigned int)here.bits <= bits) break;
+ {
+ unsigned char *tmp_18;
+ if (have == (unsigned int)0) {
+ have = (*in)(in_desc,& next);
+ if (have == (unsigned int)0) {
+ next = (unsigned char *)0;
+ ret = -5;
+ goto inf_leave;
+ }
+ }
+ have --;
+ tmp_18 = next;
+ next ++;
+ hold += (unsigned long)*tmp_18 << bits;
+ bits += (unsigned int)8;
+ }
+ }
+ if (((int)here.op & 0xf0) == 0) {
+ last = here;
+ while (1) {
+ here = *(state->distcode + ((unsigned int)last.val + (((unsigned int)hold & (
+ (1U << (
+ (int)last.bits + (int)last.op)) - (unsigned int)1)) >> (int)last.bits)));
+ if ((unsigned int)((int)last.bits + (int)here.bits) <= bits)
+ break;
+ {
+ unsigned char *tmp_19;
+ if (have == (unsigned int)0) {
+ have = (*in)(in_desc,& next);
+ if (have == (unsigned int)0) {
+ next = (unsigned char *)0;
+ ret = -5;
+ goto inf_leave;
+ }
+ }
+ have --;
+ tmp_19 = next;
+ next ++;
+ hold += (unsigned long)*tmp_19 << bits;
+ bits += (unsigned int)8;
+ }
+ }
+ hold >>= (int)last.bits;
+ bits -= (unsigned int)last.bits;
+ }
+ hold >>= (int)here.bits;
+ bits -= (unsigned int)here.bits;
+ if ((int)here.op & 64) {
+ strm->msg = (char *)"invalid distance code";
+ state->mode = BAD;
+ break;
+ }
+ state->offset = (unsigned int)here.val;
+ state->extra = (unsigned int)here.op & (unsigned int)15;
+ if (state->extra != (unsigned int)0) {
+ while (bits < state->extra) {
+ unsigned char *tmp_20;
+ if (have == (unsigned int)0) {
+ have = (*in)(in_desc,& next);
+ if (have == (unsigned int)0) {
+ next = (unsigned char *)0;
+ ret = -5;
+ goto inf_leave;
+ }
+ }
+ have --;
+ tmp_20 = next;
+ next ++;
+ hold += (unsigned long)*tmp_20 << bits;
+ bits += (unsigned int)8;
+ }
+ state->offset += (unsigned int)hold & ((1U << state->extra) - (unsigned int)1);
+ hold >>= state->extra;
+ bits -= state->extra;
+ }
+ if (state->whave < state->wsize) tmp_21 = left;
+ else tmp_21 = (unsigned int)0;
+ ;
+ if (state->offset > state->wsize - tmp_21) {
+ strm->msg = (char *)"invalid distance too far back";
+ state->mode = BAD;
+ break;
+ }
+ while (1) {
+ if (left == (unsigned int)0) {
+ int tmp_22;
+ put = state->window;
+ left = state->wsize;
+ state->whave = left;
+ tmp_22 = (*out)(out_desc,put,left);
+ if (tmp_22) {
+ ret = -5;
+ goto inf_leave;
+ }
+ }
+ copy = state->wsize - state->offset;
+ if (copy < left) {
+ from = put + copy;
+ copy = left - copy;
+ }
+ else {
+ from = put - state->offset;
+ copy = left;
+ }
+ if (copy > state->length) copy = state->length;
+ state->length -= copy;
+ left -= copy;
+ while (1) {
+ {
+ unsigned char *tmp_23;
+ unsigned char *tmp_24;
+ tmp_23 = put;
+ put ++;
+ tmp_24 = from;
+ from ++;
+ *tmp_23 = *tmp_24;
+ }
+ copy --;
+ if (! copy) break;
+ }
+ if (! (state->length != (unsigned int)0)) break;
+ }
+ break;
+ case (inflate_mode)DONE: ret = 1;
+ if (left < state->wsize) {
+ int tmp_25;
+ tmp_25 = (*out)(out_desc,state->window,state->wsize - left);
+ if (tmp_25) ret = -5;
+ }
+ goto inf_leave;
+ case (inflate_mode)BAD: ret = -3;
+ goto inf_leave;
+ default: ret = -2;
+ goto inf_leave;
+ }
+ inf_leave: strm->next_in = next;
+ strm->avail_in = have;
+ __retres = ret;
+ return_label: return __retres;
+}
+
+int inflateBackEnd(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+int inflateBackEnd(z_streamp strm)
+{
+ int __retres;
+ if (strm == (z_streamp)0) {
+ __retres = -2;
+ goto return_label;
+ }
+ else
+ if (strm->state == (struct internal_state *)0) {
+ __retres = -2;
+ goto return_label;
+ }
+ else
+ if (strm->zfree == (void (*)(voidpf opaque, voidpf address))0) {
+ __retres = -2;
+ goto return_label;
+ }
+ (*(strm->zfree))(strm->opaque,(void *)strm->state);
+ strm->state = (struct internal_state *)0;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+void inflate_fast(z_streamp strm, unsigned int start) __attribute__((
+__FC_OLDSTYLEPROTO__));
+void inflate_fast(z_streamp strm, unsigned int start)
+{
+ struct inflate_state *state;
+ unsigned char *in;
+ unsigned char *last;
+ unsigned char *out;
+ unsigned char *beg;
+ unsigned char *end;
+ unsigned int wsize;
+ unsigned int whave;
+ unsigned int wnext;
+ unsigned char *window;
+ unsigned long hold;
+ unsigned int bits;
+ code const *lcode;
+ code const *dcode;
+ unsigned int lmask;
+ unsigned int dmask;
+ code here;
+ unsigned int op;
+ unsigned int len;
+ unsigned int dist;
+ unsigned char *from;
+ long tmp_35;
+ long tmp_36;
+ state = (struct inflate_state *)strm->state;
+ in = strm->next_in;
+ last = in + (strm->avail_in - (uInt)5);
+ out = strm->next_out;
+ beg = out - (start - strm->avail_out);
+ end = out + (strm->avail_out - (uInt)257);
+ 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) - (unsigned int)1;
+ dmask = (1U << state->distbits) - (unsigned int)1;
+ while (1) {
+ if (bits < (unsigned int)15) {
+ unsigned char *tmp;
+ unsigned char *tmp_0;
+ tmp = in;
+ in ++;
+ hold += (unsigned long)*tmp << bits;
+ bits += (unsigned int)8;
+ tmp_0 = in;
+ in ++;
+ hold += (unsigned long)*tmp_0 << bits;
+ bits += (unsigned int)8;
+ }
+ here = *(lcode + (hold & (unsigned long)lmask));
+ dolen: op = (unsigned int)here.bits;
+ hold >>= op;
+ bits -= op;
+ op = (unsigned int)here.op;
+ if (op == (unsigned int)0) {
+ unsigned char *tmp_1;
+ tmp_1 = out;
+ out ++;
+ *tmp_1 = (unsigned char)here.val;
+ }
+ else
+ if (op & (unsigned int)16) {
+ len = (unsigned int)here.val;
+ op &= (unsigned int)15;
+ if (op) {
+ if (bits < op) {
+ unsigned char *tmp_2;
+ tmp_2 = in;
+ in ++;
+ hold += (unsigned long)*tmp_2 << bits;
+ bits += (unsigned int)8;
+ }
+ len += (unsigned int)hold & ((1U << op) - (unsigned int)1);
+ hold >>= op;
+ bits -= op;
+ }
+ if (bits < (unsigned int)15) {
+ unsigned char *tmp_3;
+ unsigned char *tmp_4;
+ tmp_3 = in;
+ in ++;
+ hold += (unsigned long)*tmp_3 << bits;
+ bits += (unsigned int)8;
+ tmp_4 = in;
+ in ++;
+ hold += (unsigned long)*tmp_4 << bits;
+ bits += (unsigned int)8;
+ }
+ here = *(dcode + (hold & (unsigned long)dmask));
+ dodist: op = (unsigned int)here.bits;
+ hold >>= op;
+ bits -= op;
+ op = (unsigned int)here.op;
+ if (op & (unsigned int)16) {
+ dist = (unsigned int)here.val;
+ op &= (unsigned int)15;
+ if (bits < op) {
+ unsigned char *tmp_5;
+ tmp_5 = in;
+ in ++;
+ hold += (unsigned long)*tmp_5 << bits;
+ bits += (unsigned int)8;
+ if (bits < op) {
+ unsigned char *tmp_6;
+ tmp_6 = in;
+ in ++;
+ hold += (unsigned long)*tmp_6 << bits;
+ bits += (unsigned int)8;
+ }
+ }
+ dist += (unsigned int)hold & ((1U << op) - (unsigned int)1);
+ hold >>= op;
+ bits -= op;
+ op = (unsigned int)(out - beg);
+ if (dist > op) {
+ op = dist - op;
+ if (op > whave)
+ if (state->sane) {
+ strm->msg = (char *)"invalid distance too far back";
+ state->mode = BAD;
+ break;
+ }
+ from = window;
+ if (wnext == (unsigned int)0) {
+ from += wsize - op;
+ if (op < len) {
+ len -= op;
+ while (1) {
+ {
+ unsigned char *tmp_7;
+ unsigned char *tmp_8;
+ tmp_7 = out;
+ out ++;
+ tmp_8 = from;
+ from ++;
+ *tmp_7 = *tmp_8;
+ }
+ op --;
+ if (! op) break;
+ }
+ from = out - dist;
+ }
+ }
+ else
+ if (wnext < op) {
+ from += (wsize + wnext) - op;
+ op -= wnext;
+ if (op < len) {
+ len -= op;
+ while (1) {
+ {
+ unsigned char *tmp_9;
+ unsigned char *tmp_10;
+ tmp_9 = out;
+ out ++;
+ tmp_10 = from;
+ from ++;
+ *tmp_9 = *tmp_10;
+ }
+ op --;
+ if (! op) break;
+ }
+ from = window;
+ if (wnext < len) {
+ op = wnext;
+ len -= op;
+ while (1) {
+ {
+ unsigned char *tmp_11;
+ unsigned char *tmp_12;
+ tmp_11 = out;
+ out ++;
+ tmp_12 = from;
+ from ++;
+ *tmp_11 = *tmp_12;
+ }
+ op --;
+ if (! op) break;
+ }
+ from = out - dist;
+ }
+ }
+ }
+ else {
+ from += wnext - op;
+ if (op < len) {
+ len -= op;
+ while (1) {
+ {
+ unsigned char *tmp_13;
+ unsigned char *tmp_14;
+ tmp_13 = out;
+ out ++;
+ tmp_14 = from;
+ from ++;
+ *tmp_13 = *tmp_14;
+ }
+ op --;
+ if (! op) break;
+ }
+ from = out - dist;
+ }
+ }
+ while (len > (unsigned int)2) {
+ unsigned char *tmp_15;
+ unsigned char *tmp_16;
+ unsigned char *tmp_17;
+ unsigned char *tmp_18;
+ unsigned char *tmp_19;
+ unsigned char *tmp_20;
+ tmp_15 = out;
+ out ++;
+ tmp_16 = from;
+ from ++;
+ *tmp_15 = *tmp_16;
+ tmp_17 = out;
+ out ++;
+ tmp_18 = from;
+ from ++;
+ *tmp_17 = *tmp_18;
+ tmp_19 = out;
+ out ++;
+ tmp_20 = from;
+ from ++;
+ *tmp_19 = *tmp_20;
+ len -= (unsigned int)3;
+ }
+ if (len) {
+ unsigned char *tmp_21;
+ unsigned char *tmp_22;
+ tmp_21 = out;
+ out ++;
+ tmp_22 = from;
+ from ++;
+ *tmp_21 = *tmp_22;
+ if (len > (unsigned int)1) {
+ unsigned char *tmp_23;
+ unsigned char *tmp_24;
+ tmp_23 = out;
+ out ++;
+ tmp_24 = from;
+ from ++;
+ *tmp_23 = *tmp_24;
+ }
+ }
+ }
+ else {
+ from = out - dist;
+ while (1) {
+ {
+ unsigned char *tmp_25;
+ unsigned char *tmp_26;
+ unsigned char *tmp_27;
+ unsigned char *tmp_28;
+ unsigned char *tmp_29;
+ unsigned char *tmp_30;
+ tmp_25 = out;
+ out ++;
+ tmp_26 = from;
+ from ++;
+ *tmp_25 = *tmp_26;
+ tmp_27 = out;
+ out ++;
+ tmp_28 = from;
+ from ++;
+ *tmp_27 = *tmp_28;
+ tmp_29 = out;
+ out ++;
+ tmp_30 = from;
+ from ++;
+ *tmp_29 = *tmp_30;
+ len -= (unsigned int)3;
+ }
+ if (! (len > (unsigned int)2)) break;
+ }
+ if (len) {
+ unsigned char *tmp_31;
+ unsigned char *tmp_32;
+ tmp_31 = out;
+ out ++;
+ tmp_32 = from;
+ from ++;
+ *tmp_31 = *tmp_32;
+ if (len > (unsigned int)1) {
+ unsigned char *tmp_33;
+ unsigned char *tmp_34;
+ tmp_33 = out;
+ out ++;
+ tmp_34 = from;
+ from ++;
+ *tmp_33 = *tmp_34;
+ }
+ }
+ }
+ }
+ else
+ if ((op & (unsigned int)64) == (unsigned int)0) {
+ here = *(dcode + ((unsigned long)here.val + (hold & (unsigned long)(
+ (1U << op) - (unsigned int)1))));
+ goto dodist;
+ }
+ else {
+ strm->msg = (char *)"invalid distance code";
+ state->mode = BAD;
+ break;
+ }
+ }
+ else
+ if ((op & (unsigned int)64) == (unsigned int)0) {
+ here = *(lcode + ((unsigned long)here.val + (hold & (unsigned long)(
+ (1U << op) - (unsigned int)1))));
+ goto dolen;
+ }
+ else
+ if (op & (unsigned int)32) {
+ state->mode = TYPE;
+ break;
+ }
+ else {
+ strm->msg = (char *)"invalid literal/length code";
+ state->mode = BAD;
+ break;
+ }
+ if (in < last) {
+ if (! (out < end)) break;
+ }
+ else break;
+ }
+ len = bits >> 3;
+ in -= len;
+ bits -= len << 3;
+ hold &= (unsigned long)((1U << bits) - (unsigned int)1);
+ strm->next_in = in;
+ strm->next_out = out;
+ if (in < last) tmp_35 = (long)5 + (last - in);
+ else tmp_35 = (long)5 - (in - last);
+ strm->avail_in = (unsigned int)tmp_35;
+ if (out < end) tmp_36 = (long)257 + (end - out);
+ else tmp_36 = (long)257 - (out - end);
+ strm->avail_out = (unsigned int)tmp_36;
+ state->hold = hold;
+ state->bits = bits;
+ return;
+}
+
+static int inflateStateCheck(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static void fixedtables_0(struct inflate_state *state) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static int updatewindow(z_streamp strm, unsigned char const *end,
+ unsigned int copy) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static unsigned int syncsearch(unsigned int *have, unsigned char const *buf,
+ unsigned int len) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static int inflateStateCheck(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+static int inflateStateCheck(z_streamp strm)
+{
+ int __retres;
+ struct inflate_state *state;
+ if (strm == (z_streamp)0) {
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (strm->zalloc == (voidpf (*)(voidpf opaque, uInt items, uInt size))0) {
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (strm->zfree == (void (*)(voidpf opaque, voidpf address))0) {
+ __retres = 1;
+ goto return_label;
+ }
+ state = (struct inflate_state *)strm->state;
+ if (state == (struct inflate_state *)0) {
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (state->strm != strm) {
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (state->mode < (unsigned int)HEAD) {
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if (state->mode > (unsigned int)SYNC) {
+ __retres = 1;
+ goto return_label;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int inflateResetKeep(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+int inflateResetKeep(z_streamp strm)
+{
+ int __retres;
+ struct inflate_state *state;
+ int tmp;
+ unsigned long tmp_1;
+ uLong tmp_0;
+ code *tmp_3;
+ code const *tmp_2;
+ tmp = inflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (struct inflate_state *)strm->state;
+ tmp_1 = (unsigned long)0;
+ state->total = tmp_1;
+ tmp_0 = tmp_1;
+ strm->total_out = tmp_0;
+ strm->total_in = tmp_0;
+ strm->msg = (char *)0;
+ if (state->wrap) strm->adler = (unsigned long)(state->wrap & 1);
+ state->mode = HEAD;
+ state->last = 0;
+ state->havedict = 0;
+ state->dmax = 32768U;
+ state->head = (gz_header *)0;
+ state->hold = (unsigned long)0;
+ state->bits = (unsigned int)0;
+ tmp_3 = state->codes;
+ state->next = tmp_3;
+ tmp_2 = (code const *)tmp_3;
+ state->distcode = tmp_2;
+ state->lencode = tmp_2;
+ state->sane = 1;
+ state->back = -1;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int inflateReset(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+int inflateReset(z_streamp strm)
+{
+ int __retres;
+ struct inflate_state *state;
+ int tmp;
+ int tmp_0;
+ tmp = inflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (struct inflate_state *)strm->state;
+ state->wsize = (unsigned int)0;
+ state->whave = (unsigned int)0;
+ state->wnext = (unsigned int)0;
+ tmp_0 = inflateResetKeep(strm);
+ __retres = tmp_0;
+ return_label: return __retres;
+}
+
+int inflateReset2(z_streamp strm, int windowBits) __attribute__((__FC_OLDSTYLEPROTO__));
+int inflateReset2(z_streamp strm, int windowBits)
+{
+ int __retres;
+ int wrap;
+ struct inflate_state *state;
+ int tmp;
+ int tmp_0;
+ tmp = inflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (struct inflate_state *)strm->state;
+ if (windowBits < 0) {
+ wrap = 0;
+ windowBits = - windowBits;
+ }
+ else {
+ wrap = (windowBits >> 4) + 5;
+ if (windowBits < 48) windowBits &= 15;
+ }
+ if (windowBits)
+ if (windowBits < 8) {
+ __retres = -2;
+ goto return_label;
+ }
+ else
+ if (windowBits > 15) {
+ __retres = -2;
+ goto return_label;
+ }
+ if (state->window != (unsigned char *)0)
+ if (state->wbits != (unsigned int)windowBits) {
+ (*(strm->zfree))(strm->opaque,(void *)state->window);
+ state->window = (unsigned char *)0;
+ }
+ state->wrap = wrap;
+ state->wbits = (unsigned int)windowBits;
+ tmp_0 = inflateReset(strm);
+ __retres = tmp_0;
+ return_label: return __retres;
+}
+
+int inflateInit2_(z_streamp strm, int windowBits, char const *version,
+ int stream_size) __attribute__((__FC_OLDSTYLEPROTO__));
+int inflateInit2_(z_streamp strm, int windowBits, char const *version,
+ int stream_size)
+{
+ int __retres;
+ int ret;
+ struct inflate_state *state;
+ if (version == (char const *)0) {
+ __retres = -6;
+ goto return_label;
+ }
+ else
+ if ((int)*(version + 0) != (int)*("1.2.11" + 0)) {
+ __retres = -6;
+ goto return_label;
+ }
+ else
+ if (stream_size != (int)sizeof(z_stream)) {
+ __retres = -6;
+ goto return_label;
+ }
+ if (strm == (z_streamp)0) {
+ __retres = -2;
+ goto return_label;
+ }
+ strm->msg = (char *)0;
+ if (strm->zalloc == (voidpf (*)(voidpf opaque, uInt items, uInt size))0) {
+ strm->zalloc = & zcalloc;
+ strm->opaque = (void *)0;
+ }
+ if (strm->zfree == (void (*)(voidpf opaque, voidpf address))0) strm->zfree = & zcfree;
+ state = (struct inflate_state *)(*(strm->zalloc))(strm->opaque,
+ (unsigned int)1,
+ (unsigned int)sizeof(struct inflate_state));
+ if (state == (struct inflate_state *)0) {
+ __retres = -4;
+ goto return_label;
+ }
+ strm->state = (struct internal_state *)state;
+ state->strm = strm;
+ state->window = (unsigned char *)0;
+ state->mode = HEAD;
+ ret = inflateReset2(strm,windowBits);
+ if (ret != 0) {
+ (*(strm->zfree))(strm->opaque,(void *)state);
+ strm->state = (struct internal_state *)0;
+ }
+ __retres = ret;
+ return_label: return __retres;
+}
+
+int inflateInit_(z_streamp strm, char const *version, int stream_size) __attribute__((
+__FC_OLDSTYLEPROTO__));
+int inflateInit_(z_streamp strm, char const *version, int stream_size)
+{
+ int tmp;
+ tmp = inflateInit2_(strm,15,version,stream_size);
+ return tmp;
+}
+
+int inflatePrime(z_streamp strm, int bits, int value) __attribute__((
+__FC_OLDSTYLEPROTO__));
+int inflatePrime(z_streamp strm, int bits, int value)
+{
+ int __retres;
+ struct inflate_state *state;
+ int tmp;
+ tmp = inflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (struct inflate_state *)strm->state;
+ if (bits < 0) {
+ state->hold = (unsigned long)0;
+ state->bits = (unsigned int)0;
+ __retres = 0;
+ goto return_label;
+ }
+ if (bits > 16) {
+ __retres = -2;
+ goto return_label;
+ }
+ else
+ if (state->bits + (unsigned int)bits > (unsigned int)32) {
+ __retres = -2;
+ goto return_label;
+ }
+ value = (int)((long)value & ((1L << bits) - (long)1));
+ state->hold += (unsigned long)((unsigned int)value << state->bits);
+ state->bits += (unsigned int)bits;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static code const fixedtables_lenfix_0[512] =
+ {{.op = (unsigned char)96,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)80},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)16},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)115},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)31},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)112},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)48},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)192},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)10},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)96},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)32},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)160},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)128},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)64},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)224},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)6},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)88},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)24},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)144},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)59},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)120},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)56},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)208},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)17},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)104},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)40},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)176},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)8},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)136},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)72},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)240},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)4},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)84},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)20},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)227},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)43},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)116},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)52},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)200},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)13},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)100},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)36},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)168},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)4},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)132},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)68},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)232},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)8},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)92},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)28},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)152},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)83},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)124},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)60},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)216},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)23},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)108},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)44},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)184},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)12},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)140},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)76},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)248},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)3},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)82},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)18},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)163},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)35},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)114},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)50},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)196},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)11},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)98},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)34},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)164},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)2},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)130},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)66},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)228},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)7},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)90},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)26},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)148},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)67},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)122},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)58},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)212},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)19},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)106},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)42},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)180},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)10},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)138},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)74},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)244},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)5},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)86},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)22},
+ {.op = (unsigned char)64,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)51},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)118},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)54},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)204},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)15},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)102},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)38},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)172},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)6},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)134},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)70},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)236},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)9},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)94},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)30},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)156},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)99},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)126},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)62},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)220},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)27},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)110},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)46},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)188},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)14},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)142},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)78},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)252},
+ {.op = (unsigned char)96,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)81},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)17},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)131},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)31},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)113},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)49},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)194},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)10},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)97},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)33},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)162},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)1},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)129},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)65},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)226},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)6},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)89},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)25},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)146},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)59},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)121},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)57},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)210},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)17},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)105},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)41},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)178},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)9},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)137},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)73},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)242},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)4},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)85},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)21},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)258},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)43},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)117},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)53},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)202},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)13},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)101},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)37},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)170},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)5},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)133},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)69},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)234},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)8},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)93},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)29},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)154},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)83},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)125},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)61},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)218},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)23},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)109},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)45},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)186},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)13},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)141},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)77},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)250},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)3},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)83},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)19},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)195},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)35},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)115},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)51},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)198},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)11},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)99},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)35},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)166},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)3},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)131},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)67},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)230},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)7},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)91},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)27},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)150},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)67},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)123},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)59},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)214},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)19},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)107},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)43},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)182},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)11},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)139},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)75},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)246},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)5},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)87},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)23},
+ {.op = (unsigned char)64,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)51},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)119},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)55},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)206},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)15},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)103},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)39},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)174},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)7},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)135},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)71},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)238},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)9},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)95},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)31},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)158},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)99},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)127},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)63},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)222},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)27},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)111},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)47},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)190},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)15},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)143},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)79},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)254},
+ {.op = (unsigned char)96,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)80},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)16},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)115},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)31},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)112},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)48},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)193},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)10},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)96},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)32},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)161},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)128},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)64},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)225},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)6},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)88},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)24},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)145},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)59},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)120},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)56},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)209},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)17},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)104},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)40},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)177},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)8},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)136},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)72},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)241},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)4},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)84},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)20},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)227},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)43},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)116},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)52},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)201},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)13},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)100},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)36},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)169},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)4},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)132},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)68},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)233},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)8},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)92},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)28},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)153},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)83},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)124},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)60},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)217},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)23},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)108},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)44},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)185},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)12},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)140},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)76},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)249},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)3},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)82},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)18},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)163},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)35},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)114},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)50},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)197},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)11},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)98},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)34},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)165},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)2},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)130},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)66},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)229},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)7},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)90},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)26},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)149},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)67},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)122},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)58},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)213},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)19},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)106},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)42},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)181},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)10},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)138},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)74},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)245},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)5},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)86},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)22},
+ {.op = (unsigned char)64,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)51},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)118},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)54},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)205},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)15},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)102},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)38},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)173},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)6},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)134},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)70},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)237},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)9},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)94},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)30},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)157},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)99},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)126},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)62},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)221},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)27},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)110},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)46},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)189},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)14},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)142},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)78},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)253},
+ {.op = (unsigned char)96,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)81},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)17},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)131},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)31},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)113},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)49},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)195},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)10},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)97},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)33},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)163},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)1},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)129},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)65},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)227},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)6},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)89},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)25},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)147},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)59},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)121},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)57},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)211},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)17},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)105},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)41},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)179},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)9},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)137},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)73},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)243},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)4},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)85},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)21},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)258},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)43},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)117},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)53},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)203},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)13},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)101},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)37},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)171},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)5},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)133},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)69},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)235},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)8},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)93},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)29},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)155},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)83},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)125},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)61},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)219},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)23},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)109},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)45},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)187},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)13},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)141},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)77},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)251},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)3},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)83},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)19},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)195},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)35},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)115},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)51},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)199},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)11},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)99},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)35},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)167},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)3},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)131},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)67},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)231},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)7},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)91},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)27},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)151},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)67},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)123},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)59},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)215},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)19},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)107},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)43},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)183},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)11},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)139},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)75},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)247},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)5},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)87},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)23},
+ {.op = (unsigned char)64,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)51},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)119},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)55},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)207},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)15},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)103},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)39},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)175},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)7},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)135},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)71},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)239},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)9},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)95},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)31},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)159},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)99},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)127},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)63},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)223},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)7,
+ .val = (unsigned short)27},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)111},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)47},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)191},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)15},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)143},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)8,
+ .val = (unsigned short)79},
+ {.op = (unsigned char)0,
+ .bits = (unsigned char)9,
+ .val = (unsigned short)255}};
+static code const fixedtables_distfix_0[32] =
+ {{.op = (unsigned char)16,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)1},
+ {.op = (unsigned char)23,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)257},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)17},
+ {.op = (unsigned char)27,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)4097},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)5},
+ {.op = (unsigned char)25,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)1025},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)65},
+ {.op = (unsigned char)29,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)16385},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)3},
+ {.op = (unsigned char)24,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)513},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)33},
+ {.op = (unsigned char)28,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)8193},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)9},
+ {.op = (unsigned char)26,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)2049},
+ {.op = (unsigned char)22,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)129},
+ {.op = (unsigned char)64,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)0},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)2},
+ {.op = (unsigned char)23,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)385},
+ {.op = (unsigned char)19,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)25},
+ {.op = (unsigned char)27,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)6145},
+ {.op = (unsigned char)17,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)7},
+ {.op = (unsigned char)25,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)1537},
+ {.op = (unsigned char)21,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)97},
+ {.op = (unsigned char)29,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)24577},
+ {.op = (unsigned char)16,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)4},
+ {.op = (unsigned char)24,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)769},
+ {.op = (unsigned char)20,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)49},
+ {.op = (unsigned char)28,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)12289},
+ {.op = (unsigned char)18,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)13},
+ {.op = (unsigned char)26,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)3073},
+ {.op = (unsigned char)22,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)193},
+ {.op = (unsigned char)64,
+ .bits = (unsigned char)5,
+ .val = (unsigned short)0}};
+static void fixedtables_0(struct inflate_state *state) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static void fixedtables_0(struct inflate_state *state)
+{
+ state->lencode = fixedtables_lenfix_0;
+ state->lenbits = (unsigned int)9;
+ state->distcode = fixedtables_distfix_0;
+ state->distbits = (unsigned int)5;
+ return;
+}
+
+static int updatewindow(z_streamp strm, unsigned char const *end,
+ unsigned int copy) __attribute__((__FC_OLDSTYLEPROTO__));
+static int updatewindow(z_streamp strm, unsigned char const *end,
+ unsigned int copy)
+{
+ int __retres;
+ struct inflate_state *state;
+ unsigned int dist;
+ state = (struct inflate_state *)strm->state;
+ if (state->window == (unsigned char *)0) {
+ state->window = (unsigned char *)(*(strm->zalloc))(strm->opaque,
+ 1U << state->wbits,
+ (unsigned int)sizeof(unsigned char));
+ if (state->window == (unsigned char *)0) {
+ __retres = 1;
+ goto return_label;
+ }
+ }
+ if (state->wsize == (unsigned int)0) {
+ state->wsize = 1U << state->wbits;
+ state->wnext = (unsigned int)0;
+ state->whave = (unsigned int)0;
+ }
+ if (copy >= state->wsize) {
+ memcpy((void *)state->window,(void const *)(end - state->wsize),
+ (unsigned long)state->wsize);
+ state->wnext = (unsigned int)0;
+ state->whave = state->wsize;
+ }
+ else {
+ dist = state->wsize - state->wnext;
+ if (dist > copy) dist = copy;
+ memcpy((void *)(state->window + state->wnext),(void const *)(end - copy),
+ (unsigned long)dist);
+ copy -= dist;
+ if (copy) {
+ memcpy((void *)state->window,(void const *)(end - copy),
+ (unsigned long)copy);
+ state->wnext = copy;
+ state->whave = state->wsize;
+ }
+ else {
+ state->wnext += dist;
+ if (state->wnext == state->wsize) state->wnext = (unsigned int)0;
+ if (state->whave < state->wsize) state->whave += dist;
+ }
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static unsigned short const inflate_order[19] =
+ {(unsigned short)16,
+ (unsigned short)17,
+ (unsigned short)18,
+ (unsigned short)0,
+ (unsigned short)8,
+ (unsigned short)7,
+ (unsigned short)9,
+ (unsigned short)6,
+ (unsigned short)10,
+ (unsigned short)5,
+ (unsigned short)11,
+ (unsigned short)4,
+ (unsigned short)12,
+ (unsigned short)3,
+ (unsigned short)13,
+ (unsigned short)2,
+ (unsigned short)14,
+ (unsigned short)1,
+ (unsigned short)15};
+int inflate(z_streamp strm, int flush) __attribute__((__FC_OLDSTYLEPROTO__));
+int inflate(z_streamp strm, int flush)
+{
+ int __retres;
+ struct inflate_state *state;
+ unsigned char *next;
+ unsigned char *put;
+ unsigned int have;
+ unsigned int left;
+ unsigned long hold;
+ unsigned int bits;
+ unsigned int in;
+ unsigned int out;
+ unsigned int copy;
+ unsigned char *from;
+ code here;
+ code last;
+ unsigned int len;
+ int ret;
+ unsigned char hbuf[4];
+ int tmp;
+ int tmp_48;
+ int tmp_49;
+ int tmp_50;
+ tmp = inflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ else
+ if (strm->next_out == (Bytef *)0) {
+ __retres = -2;
+ goto return_label;
+ }
+ else
+ if (strm->next_in == (Bytef *)0)
+ if (strm->avail_in != (uInt)0) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (struct inflate_state *)strm->state;
+ if (state->mode == (unsigned int)TYPE) state->mode = TYPEDO;
+ put = strm->next_out;
+ left = strm->avail_out;
+ next = strm->next_in;
+ have = strm->avail_in;
+ hold = state->hold;
+ bits = state->bits;
+ in = have;
+ out = left;
+ ret = 0;
+ while (1)
+ switch (state->mode) {
+ unsigned long tmp_1;
+ unsigned long tmp_12;
+ unsigned long tmp_14;
+ unsigned long tmp_15;
+ unsigned char *tmp_37;
+ case (inflate_mode)HEAD: ;
+ if (state->wrap == 0) {
+ state->mode = TYPEDO;
+ break;
+ }
+ while (bits < (unsigned int)16) {
+ unsigned char *tmp_0;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_0 = next;
+ next ++;
+ hold += (unsigned long)*tmp_0 << bits;
+ bits += (unsigned int)8;
+ }
+ if (state->wrap & 2)
+ if (hold == (unsigned long)0x8b1f) {
+ if (state->wbits == (unsigned int)0) state->wbits = (unsigned int)15;
+ state->check = crc32((unsigned long)0L,(Bytef const *)0,
+ (unsigned int)0);
+ hbuf[0] = (unsigned char)hold;
+ hbuf[1] = (unsigned char)(hold >> 8);
+ state->check = crc32(state->check,(Bytef const *)(hbuf),
+ (unsigned int)2);
+ hold = (unsigned long)0;
+ bits = (unsigned int)0;
+ state->mode = FLAGS;
+ break;
+ }
+ state->flags = 0;
+ if (state->head != (gz_headerp)0) (state->head)->done = -1;
+ if (! (state->wrap & 1)) goto _LOR;
+ else
+ if (((unsigned long)(((unsigned int)hold & ((1U << 8) - (unsigned int)1)) << 8) + (
+ hold >> 8)) % (unsigned long)31) {
+ _LOR:
+ {
+ strm->msg = (char *)"incorrect header check";
+ state->mode = BAD;
+ break;
+ }
+ }
+ if (((unsigned int)hold & ((1U << 4) - (unsigned int)1)) != (unsigned int)8) {
+ strm->msg = (char *)"unknown compression method";
+ state->mode = BAD;
+ break;
+ }
+ hold >>= 4;
+ bits -= (unsigned int)4;
+ len = ((unsigned int)hold & ((1U << 4) - (unsigned int)1)) + (unsigned int)8;
+ if (state->wbits == (unsigned int)0) state->wbits = len;
+ if (len > (unsigned int)15) goto _LOR_0;
+ else
+ if (len > state->wbits) {
+ _LOR_0:
+ {
+ strm->msg = (char *)"invalid window size";
+ state->mode = BAD;
+ break;
+ }
+ }
+ state->dmax = 1U << len;
+ tmp_1 = adler32((unsigned long)0L,(Bytef const *)0,(unsigned int)0);
+ state->check = tmp_1;
+ strm->adler = tmp_1;
+ if (hold & (unsigned long)0x200) state->mode = DICTID;
+ else state->mode = TYPE;
+ hold = (unsigned long)0;
+ bits = (unsigned int)0;
+ break;
+ case (inflate_mode)FLAGS:
+ while (bits < (unsigned int)16) {
+ unsigned char *tmp_2;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_2 = next;
+ next ++;
+ hold += (unsigned long)*tmp_2 << bits;
+ bits += (unsigned int)8;
+ }
+ state->flags = (int)hold;
+ if ((state->flags & 0xff) != 8) {
+ 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 != (gz_headerp)0) (state->head)->text = (int)((
+ hold >> 8) & (unsigned long)1);
+ if (state->flags & 0x0200)
+ if (state->wrap & 4) {
+ hbuf[0] = (unsigned char)hold;
+ hbuf[1] = (unsigned char)(hold >> 8);
+ state->check = crc32(state->check,(Bytef const *)(hbuf),
+ (unsigned int)2);
+ }
+ hold = (unsigned long)0;
+ bits = (unsigned int)0;
+ state->mode = TIME;
+ case (inflate_mode)TIME:
+ while (bits < (unsigned int)32) {
+ unsigned char *tmp_3;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_3 = next;
+ next ++;
+ hold += (unsigned long)*tmp_3 << bits;
+ bits += (unsigned int)8;
+ }
+ if (state->head != (gz_headerp)0) (state->head)->time = hold;
+ if (state->flags & 0x0200)
+ if (state->wrap & 4) {
+ hbuf[0] = (unsigned char)hold;
+ hbuf[1] = (unsigned char)(hold >> 8);
+ hbuf[2] = (unsigned char)(hold >> 16);
+ hbuf[3] = (unsigned char)(hold >> 24);
+ state->check = crc32(state->check,(Bytef const *)(hbuf),
+ (unsigned int)4);
+ }
+ hold = (unsigned long)0;
+ bits = (unsigned int)0;
+ state->mode = OS;
+ case (inflate_mode)OS:
+ while (bits < (unsigned int)16) {
+ unsigned char *tmp_4;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_4 = next;
+ next ++;
+ hold += (unsigned long)*tmp_4 << bits;
+ bits += (unsigned int)8;
+ }
+ if (state->head != (gz_headerp)0) {
+ (state->head)->xflags = (int)(hold & (unsigned long)0xff);
+ (state->head)->os = (int)(hold >> 8);
+ }
+ if (state->flags & 0x0200)
+ if (state->wrap & 4) {
+ hbuf[0] = (unsigned char)hold;
+ hbuf[1] = (unsigned char)(hold >> 8);
+ state->check = crc32(state->check,(Bytef const *)(hbuf),
+ (unsigned int)2);
+ }
+ hold = (unsigned long)0;
+ bits = (unsigned int)0;
+ state->mode = EXLEN;
+ case (inflate_mode)EXLEN: ;
+ if (state->flags & 0x0400) {
+ while (bits < (unsigned int)16) {
+ unsigned char *tmp_5;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_5 = next;
+ next ++;
+ hold += (unsigned long)*tmp_5 << bits;
+ bits += (unsigned int)8;
+ }
+ state->length = (unsigned int)hold;
+ if (state->head != (gz_headerp)0) (state->head)->extra_len = (unsigned int)hold;
+ if (state->flags & 0x0200)
+ if (state->wrap & 4) {
+ hbuf[0] = (unsigned char)hold;
+ hbuf[1] = (unsigned char)(hold >> 8);
+ state->check = crc32(state->check,(Bytef const *)(hbuf),
+ (unsigned int)2);
+ }
+ hold = (unsigned long)0;
+ bits = (unsigned int)0;
+ }
+ else
+ if (state->head != (gz_headerp)0) (state->head)->extra = (Bytef *)0;
+ state->mode = EXTRA;
+ case (inflate_mode)EXTRA: ;
+ if (state->flags & 0x0400) {
+ copy = state->length;
+ if (copy > have) copy = have;
+ if (copy) {
+ if (state->head != (gz_headerp)0)
+ if ((state->head)->extra != (Bytef *)0) {
+ uInt tmp_6;
+ len = (state->head)->extra_len - state->length;
+ if (len + copy > (state->head)->extra_max) tmp_6 = (state->head)->extra_max - len;
+ else tmp_6 = copy;
+ ;
+ ;
+ memcpy((void *)((state->head)->extra + len),(void const *)next,
+ (unsigned long)tmp_6);
+ }
+ if (state->flags & 0x0200)
+ if (state->wrap & 4) state->check = crc32(state->check,
+ (Bytef const *)next,
+ copy);
+ have -= copy;
+ next += copy;
+ state->length -= copy;
+ }
+ if (state->length) goto inf_leave;
+ }
+ state->length = (unsigned int)0;
+ state->mode = NAME;
+ case (inflate_mode)NAME: ;
+ if (state->flags & 0x0800) {
+ if (have == (unsigned int)0) goto inf_leave;
+ copy = (unsigned int)0;
+ while (1) {
+ {
+ unsigned int tmp_7;
+ tmp_7 = copy;
+ copy ++;
+ len = (unsigned int)*(next + tmp_7);
+ if (state->head != (gz_headerp)0)
+ if ((state->head)->name != (Bytef *)0)
+ if (state->length < (state->head)->name_max) {
+ unsigned int tmp_8;
+ tmp_8 = state->length;
+ (state->length) ++;
+ *((state->head)->name + tmp_8) = (unsigned char)len;
+ }
+ }
+ if (len) {
+ if (! (copy < have)) break;
+ }
+ else break;
+ }
+ if (state->flags & 0x0200)
+ if (state->wrap & 4) state->check = crc32(state->check,
+ (Bytef const *)next,copy);
+ have -= copy;
+ next += copy;
+ if (len) goto inf_leave;
+ }
+ else
+ if (state->head != (gz_headerp)0) (state->head)->name = (Bytef *)0;
+ state->length = (unsigned int)0;
+ state->mode = COMMENT;
+ case (inflate_mode)COMMENT: ;
+ if (state->flags & 0x1000) {
+ if (have == (unsigned int)0) goto inf_leave;
+ copy = (unsigned int)0;
+ while (1) {
+ {
+ unsigned int tmp_9;
+ tmp_9 = copy;
+ copy ++;
+ len = (unsigned int)*(next + tmp_9);
+ if (state->head != (gz_headerp)0)
+ if ((state->head)->comment != (Bytef *)0)
+ if (state->length < (state->head)->comm_max) {
+ unsigned int tmp_10;
+ tmp_10 = state->length;
+ (state->length) ++;
+ *((state->head)->comment + tmp_10) = (unsigned char)len;
+ }
+ }
+ if (len) {
+ if (! (copy < have)) break;
+ }
+ else break;
+ }
+ if (state->flags & 0x0200)
+ if (state->wrap & 4) state->check = crc32(state->check,
+ (Bytef const *)next,copy);
+ have -= copy;
+ next += copy;
+ if (len) goto inf_leave;
+ }
+ else
+ if (state->head != (gz_headerp)0) (state->head)->comment = (Bytef *)0;
+ state->mode = HCRC;
+ case (inflate_mode)HCRC: ;
+ if (state->flags & 0x0200) {
+ while (bits < (unsigned int)16) {
+ unsigned char *tmp_11;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_11 = next;
+ next ++;
+ hold += (unsigned long)*tmp_11 << bits;
+ bits += (unsigned int)8;
+ }
+ if (state->wrap & 4)
+ if (hold != (state->check & (unsigned long)0xffff)) {
+ strm->msg = (char *)"header crc mismatch";
+ state->mode = BAD;
+ break;
+ }
+ hold = (unsigned long)0;
+ bits = (unsigned int)0;
+ }
+ if (state->head != (gz_headerp)0) {
+ (state->head)->hcrc = (state->flags >> 9) & 1;
+ (state->head)->done = 1;
+ }
+ tmp_12 = crc32((unsigned long)0L,(Bytef const *)0,(unsigned int)0);
+ state->check = tmp_12;
+ strm->adler = tmp_12;
+ state->mode = TYPE;
+ break;
+ case (inflate_mode)DICTID:
+ while (bits < (unsigned int)32) {
+ unsigned char *tmp_13;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_13 = next;
+ next ++;
+ hold += (unsigned long)*tmp_13 << bits;
+ bits += (unsigned int)8;
+ }
+ tmp_14 = ((((hold >> 24) & (unsigned long)0xff) + ((hold >> 8) & (unsigned long)0xff00)) + (
+ (hold & (unsigned long)0xff00) << 8)) + ((hold & (unsigned long)0xff) << 24);
+ state->check = tmp_14;
+ strm->adler = tmp_14;
+ hold = (unsigned long)0;
+ bits = (unsigned int)0;
+ state->mode = DICT;
+ case (inflate_mode)DICT: ;
+ if (state->havedict == 0) {
+ strm->next_out = put;
+ strm->avail_out = left;
+ strm->next_in = next;
+ strm->avail_in = have;
+ state->hold = hold;
+ state->bits = bits;
+ __retres = 2;
+ goto return_label;
+ }
+ tmp_15 = adler32((unsigned long)0L,(Bytef const *)0,(unsigned int)0);
+ state->check = tmp_15;
+ strm->adler = tmp_15;
+ state->mode = TYPE;
+ case (inflate_mode)TYPE: ;
+ if (flush == 5) goto inf_leave;
+ else
+ if (flush == 6) goto inf_leave;
+ case (inflate_mode)TYPEDO: ;
+ if (state->last) {
+ hold >>= bits & (unsigned int)7;
+ bits -= bits & (unsigned int)7;
+ state->mode = CHECK;
+ break;
+ }
+ while (bits < (unsigned int)3) {
+ unsigned char *tmp_16;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_16 = next;
+ next ++;
+ hold += (unsigned long)*tmp_16 << bits;
+ bits += (unsigned int)8;
+ }
+ state->last = (int)((unsigned int)hold & ((1U << 1) - (unsigned int)1));
+ hold >>= 1;
+ bits -= (unsigned int)1;
+ switch ((unsigned int)hold & ((1U << 2) - (unsigned int)1)) {
+ case (unsigned int)0: ;
+ state->mode = STORED;
+ break;
+ case (unsigned int)1: fixedtables_0(state);
+ state->mode = LEN_;
+ if (flush == 6) {
+ hold >>= 2;
+ bits -= (unsigned int)2;
+ goto inf_leave;
+ }
+ break;
+ case (unsigned int)2: ;
+ state->mode = TABLE;
+ break;
+ case (unsigned int)3: strm->msg = (char *)"invalid block type";
+ state->mode = BAD;
+ }
+ hold >>= 2;
+ bits -= (unsigned int)2;
+ break;
+ case (inflate_mode)STORED:
+ {
+ hold >>= bits & (unsigned int)7;
+ bits -= bits & (unsigned int)7;
+ }
+ while (bits < (unsigned int)32) {
+ unsigned char *tmp_17;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_17 = next;
+ next ++;
+ hold += (unsigned long)*tmp_17 << bits;
+ bits += (unsigned int)8;
+ }
+ if ((hold & (unsigned long)0xffff) != ((hold >> 16) ^ (unsigned long)0xffff)) {
+ strm->msg = (char *)"invalid stored block lengths";
+ state->mode = BAD;
+ break;
+ }
+ state->length = (unsigned int)hold & (unsigned int)0xffff;
+ hold = (unsigned long)0;
+ bits = (unsigned int)0;
+ state->mode = COPY_;
+ if (flush == 6) goto inf_leave;
+ case (inflate_mode)COPY_: state->mode = COPY;
+ case (inflate_mode)COPY: copy = state->length;
+ if (copy) {
+ if (copy > have) copy = have;
+ if (copy > left) copy = left;
+ if (copy == (unsigned int)0) goto inf_leave;
+ memcpy((void *)put,(void const *)next,(unsigned long)copy);
+ have -= copy;
+ next += copy;
+ left -= copy;
+ put += copy;
+ state->length -= copy;
+ break;
+ }
+ state->mode = TYPE;
+ break;
+ case (inflate_mode)TABLE:
+ while (bits < (unsigned int)14) {
+ unsigned char *tmp_18;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_18 = next;
+ next ++;
+ hold += (unsigned long)*tmp_18 << bits;
+ bits += (unsigned int)8;
+ }
+ state->nlen = ((unsigned int)hold & ((1U << 5) - (unsigned int)1)) + (unsigned int)257;
+ hold >>= 5;
+ bits -= (unsigned int)5;
+ state->ndist = ((unsigned int)hold & ((1U << 5) - (unsigned int)1)) + (unsigned int)1;
+ hold >>= 5;
+ bits -= (unsigned int)5;
+ state->ncode = ((unsigned int)hold & ((1U << 4) - (unsigned int)1)) + (unsigned int)4;
+ hold >>= 4;
+ bits -= (unsigned int)4;
+ if (state->nlen > (unsigned int)286) goto _LOR_1;
+ else
+ if (state->ndist > (unsigned int)30) {
+ _LOR_1:
+ {
+ strm->msg = (char *)"too many length or distance symbols";
+ state->mode = BAD;
+ break;
+ }
+ }
+ state->have = (unsigned int)0;
+ state->mode = LENLENS;
+ case (inflate_mode)LENLENS:
+ while (state->have < state->ncode) {
+ unsigned int tmp_20;
+ while (bits < (unsigned int)3) {
+ unsigned char *tmp_19;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_19 = next;
+ next ++;
+ hold += (unsigned long)*tmp_19 << bits;
+ bits += (unsigned int)8;
+ }
+ tmp_20 = state->have;
+ (state->have) ++;
+ state->lens[inflate_order[tmp_20]] = (unsigned short)((unsigned int)hold & (
+ (1U << 3) - (unsigned int)1));
+ hold >>= 3;
+ bits -= (unsigned int)3;
+ }
+ while (state->have < (unsigned int)19) {
+ unsigned int tmp_21;
+ tmp_21 = state->have;
+ (state->have) ++;
+ state->lens[inflate_order[tmp_21]] = (unsigned short)0;
+ }
+ state->next = state->codes;
+ state->lencode = (code const *)state->next;
+ state->lenbits = (unsigned int)7;
+ ret = inflate_table(CODES,state->lens,(unsigned int)19,& state->next,
+ & state->lenbits,state->work);
+ if (ret) {
+ strm->msg = (char *)"invalid code lengths set";
+ state->mode = BAD;
+ break;
+ }
+ state->have = (unsigned int)0;
+ state->mode = CODELENS;
+ case (inflate_mode)CODELENS:
+ while (state->have < state->nlen + state->ndist) {
+ while (1) {
+ here = *(state->lencode + ((unsigned int)hold & ((1U << state->lenbits) - (unsigned int)1)));
+ if ((unsigned int)here.bits <= bits) break;
+ {
+ unsigned char *tmp_22;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_22 = next;
+ next ++;
+ hold += (unsigned long)*tmp_22 << bits;
+ bits += (unsigned int)8;
+ }
+ }
+ if ((int)here.val < 16) {
+ unsigned int tmp_23;
+ hold >>= (int)here.bits;
+ bits -= (unsigned int)here.bits;
+ tmp_23 = state->have;
+ (state->have) ++;
+ state->lens[tmp_23] = here.val;
+ }
+ else {
+ if ((int)here.val == 16) {
+ while (bits < (unsigned int)((int)here.bits + 2)) {
+ unsigned char *tmp_24;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_24 = next;
+ next ++;
+ hold += (unsigned long)*tmp_24 << bits;
+ bits += (unsigned int)8;
+ }
+ hold >>= (int)here.bits;
+ bits -= (unsigned int)here.bits;
+ if (state->have == (unsigned int)0) {
+ strm->msg = (char *)"invalid bit length repeat";
+ state->mode = BAD;
+ break;
+ }
+ len = (unsigned int)state->lens[state->have - (unsigned int)1];
+ copy = (unsigned int)3 + ((unsigned int)hold & ((1U << 2) - (unsigned int)1));
+ hold >>= 2;
+ bits -= (unsigned int)2;
+ }
+ else
+ if ((int)here.val == 17) {
+ while (bits < (unsigned int)((int)here.bits + 3)) {
+ unsigned char *tmp_25;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_25 = next;
+ next ++;
+ hold += (unsigned long)*tmp_25 << bits;
+ bits += (unsigned int)8;
+ }
+ hold >>= (int)here.bits;
+ bits -= (unsigned int)here.bits;
+ len = (unsigned int)0;
+ copy = (unsigned int)3 + ((unsigned int)hold & ((1U << 3) - (unsigned int)1));
+ hold >>= 3;
+ bits -= (unsigned int)3;
+ }
+ else {
+ while (bits < (unsigned int)((int)here.bits + 7)) {
+ unsigned char *tmp_26;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_26 = next;
+ next ++;
+ hold += (unsigned long)*tmp_26 << bits;
+ bits += (unsigned int)8;
+ }
+ hold >>= (int)here.bits;
+ bits -= (unsigned int)here.bits;
+ len = (unsigned int)0;
+ copy = (unsigned int)11 + ((unsigned int)hold & ((1U << 7) - (unsigned int)1));
+ hold >>= 7;
+ bits -= (unsigned int)7;
+ }
+ if (state->have + copy > state->nlen + state->ndist) {
+ strm->msg = (char *)"invalid bit length repeat";
+ state->mode = BAD;
+ break;
+ }
+ while (1) {
+ unsigned int tmp_28;
+ unsigned int tmp_27;
+ tmp_28 = copy;
+ copy --;
+ ;
+ if (! tmp_28) break;
+ tmp_27 = state->have;
+ (state->have) ++;
+ state->lens[tmp_27] = (unsigned short)len;
+ }
+ }
+ }
+ if (state->mode == (unsigned int)BAD) break;
+ if ((int)state->lens[256] == 0) {
+ strm->msg = (char *)"invalid code -- missing end-of-block";
+ state->mode = BAD;
+ break;
+ }
+ state->next = state->codes;
+ state->lencode = (code const *)state->next;
+ state->lenbits = (unsigned int)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 *)state->next;
+ state->distbits = (unsigned int)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;
+ }
+ state->mode = LEN_;
+ if (flush == 6) goto inf_leave;
+ case (inflate_mode)LEN_: state->mode = LEN;
+ case (inflate_mode)LEN: ;
+ if (have >= (unsigned int)6)
+ if (left >= (unsigned int)258) {
+ strm->next_out = put;
+ strm->avail_out = left;
+ strm->next_in = next;
+ strm->avail_in = have;
+ state->hold = hold;
+ state->bits = bits;
+ inflate_fast(strm,out);
+ put = strm->next_out;
+ left = strm->avail_out;
+ next = strm->next_in;
+ have = strm->avail_in;
+ hold = state->hold;
+ bits = state->bits;
+ if (state->mode == (unsigned int)TYPE) state->back = -1;
+ break;
+ }
+ state->back = 0;
+ while (1) {
+ here = *(state->lencode + ((unsigned int)hold & ((1U << state->lenbits) - (unsigned int)1)));
+ if ((unsigned int)here.bits <= bits) break;
+ {
+ unsigned char *tmp_29;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_29 = next;
+ next ++;
+ hold += (unsigned long)*tmp_29 << bits;
+ bits += (unsigned int)8;
+ }
+ }
+ if (here.op)
+ if (((int)here.op & 0xf0) == 0) {
+ last = here;
+ while (1) {
+ here = *(state->lencode + ((unsigned int)last.val + (((unsigned int)hold & (
+ (1U << (
+ (int)last.bits + (int)last.op)) - (unsigned int)1)) >> (int)last.bits)));
+ if ((unsigned int)((int)last.bits + (int)here.bits) <= bits)
+ break;
+ {
+ unsigned char *tmp_30;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_30 = next;
+ next ++;
+ hold += (unsigned long)*tmp_30 << bits;
+ bits += (unsigned int)8;
+ }
+ }
+ hold >>= (int)last.bits;
+ bits -= (unsigned int)last.bits;
+ state->back += (int)last.bits;
+ }
+ hold >>= (int)here.bits;
+ bits -= (unsigned int)here.bits;
+ state->back += (int)here.bits;
+ state->length = (unsigned int)here.val;
+ if ((int)here.op == 0) {
+ state->mode = LIT;
+ break;
+ }
+ if ((int)here.op & 32) {
+ state->back = -1;
+ state->mode = TYPE;
+ break;
+ }
+ if ((int)here.op & 64) {
+ strm->msg = (char *)"invalid literal/length code";
+ state->mode = BAD;
+ break;
+ }
+ state->extra = (unsigned int)here.op & (unsigned int)15;
+ state->mode = LENEXT;
+ case (inflate_mode)LENEXT: ;
+ if (state->extra) {
+ while (bits < state->extra) {
+ unsigned char *tmp_31;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_31 = next;
+ next ++;
+ hold += (unsigned long)*tmp_31 << bits;
+ bits += (unsigned int)8;
+ }
+ state->length += (unsigned int)hold & ((1U << state->extra) - (unsigned int)1);
+ hold >>= state->extra;
+ bits -= state->extra;
+ state->back = (int)((unsigned int)state->back + state->extra);
+ }
+ state->was = state->length;
+ state->mode = DIST;
+ case (inflate_mode)DIST:
+ while (1) {
+ here = *(state->distcode + ((unsigned int)hold & ((1U << state->distbits) - (unsigned int)1)));
+ if ((unsigned int)here.bits <= bits) break;
+ {
+ unsigned char *tmp_32;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_32 = next;
+ next ++;
+ hold += (unsigned long)*tmp_32 << bits;
+ bits += (unsigned int)8;
+ }
+ }
+ if (((int)here.op & 0xf0) == 0) {
+ last = here;
+ while (1) {
+ here = *(state->distcode + ((unsigned int)last.val + (((unsigned int)hold & (
+ (1U << (
+ (int)last.bits + (int)last.op)) - (unsigned int)1)) >> (int)last.bits)));
+ if ((unsigned int)((int)last.bits + (int)here.bits) <= bits)
+ break;
+ {
+ unsigned char *tmp_33;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_33 = next;
+ next ++;
+ hold += (unsigned long)*tmp_33 << bits;
+ bits += (unsigned int)8;
+ }
+ }
+ hold >>= (int)last.bits;
+ bits -= (unsigned int)last.bits;
+ state->back += (int)last.bits;
+ }
+ hold >>= (int)here.bits;
+ bits -= (unsigned int)here.bits;
+ state->back += (int)here.bits;
+ if ((int)here.op & 64) {
+ strm->msg = (char *)"invalid distance code";
+ state->mode = BAD;
+ break;
+ }
+ state->offset = (unsigned int)here.val;
+ state->extra = (unsigned int)here.op & (unsigned int)15;
+ state->mode = DISTEXT;
+ case (inflate_mode)DISTEXT: ;
+ if (state->extra) {
+ while (bits < state->extra) {
+ unsigned char *tmp_34;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_34 = next;
+ next ++;
+ hold += (unsigned long)*tmp_34 << bits;
+ bits += (unsigned int)8;
+ }
+ state->offset += (unsigned int)hold & ((1U << state->extra) - (unsigned int)1);
+ hold >>= state->extra;
+ bits -= state->extra;
+ state->back = (int)((unsigned int)state->back + state->extra);
+ }
+ state->mode = MATCH;
+ case (inflate_mode)MATCH: ;
+ if (left == (unsigned int)0) goto inf_leave;
+ copy = out - left;
+ if (state->offset > copy) {
+ copy = state->offset - copy;
+ if (copy > state->whave)
+ if (state->sane) {
+ strm->msg = (char *)"invalid distance too far back";
+ state->mode = BAD;
+ break;
+ }
+ 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 {
+ from = put - state->offset;
+ copy = state->length;
+ }
+ if (copy > left) copy = left;
+ left -= copy;
+ state->length -= copy;
+ while (1) {
+ {
+ unsigned char *tmp_35;
+ unsigned char *tmp_36;
+ tmp_35 = put;
+ put ++;
+ tmp_36 = from;
+ from ++;
+ *tmp_35 = *tmp_36;
+ }
+ copy --;
+ if (! copy) break;
+ }
+ if (state->length == (unsigned int)0) state->mode = LEN;
+ break;
+ case (inflate_mode)LIT: ;
+ if (left == (unsigned int)0) goto inf_leave;
+ tmp_37 = put;
+ put ++;
+ *tmp_37 = (unsigned char)state->length;
+ left --;
+ state->mode = LEN;
+ break;
+ case (inflate_mode)CHECK: ;
+ if (state->wrap) {
+ while (bits < (unsigned int)32) {
+ unsigned char *tmp_38;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_38 = next;
+ next ++;
+ hold += (unsigned long)*tmp_38 << bits;
+ bits += (unsigned int)8;
+ }
+ out -= left;
+ strm->total_out += (uLong)out;
+ state->total += (unsigned long)out;
+ if (state->wrap & 4)
+ if (out) {
+ unsigned long tmp_39;
+ if (state->flags) tmp_39 = crc32(state->check,
+ (Bytef const *)(put - out),out);
+ else tmp_39 = adler32(state->check,(Bytef const *)(put - out),
+ out);
+ state->check = tmp_39;
+ strm->adler = tmp_39;
+ }
+ out = left;
+ if (state->wrap & 4) {
+ unsigned long tmp_42;
+ if (state->flags) tmp_42 = hold;
+ else tmp_42 = ((((hold >> 24) & (unsigned long)0xff) + ((hold >> 8) & (unsigned long)0xff00)) + (
+ (hold & (unsigned long)0xff00) << 8)) + ((hold & (unsigned long)0xff) << 24);
+ ;
+ if (tmp_42 != state->check) {
+ strm->msg = (char *)"incorrect data check";
+ state->mode = BAD;
+ break;
+ }
+ }
+ hold = (unsigned long)0;
+ bits = (unsigned int)0;
+ }
+ state->mode = LENGTH;
+ case (inflate_mode)LENGTH: ;
+ if (state->wrap)
+ if (state->flags) {
+ while (bits < (unsigned int)32) {
+ unsigned char *tmp_43;
+ if (have == (unsigned int)0) goto inf_leave;
+ have --;
+ tmp_43 = next;
+ next ++;
+ hold += (unsigned long)*tmp_43 << bits;
+ bits += (unsigned int)8;
+ }
+ if (hold != (state->total & 0xffffffffUL)) {
+ strm->msg = (char *)"incorrect length check";
+ state->mode = BAD;
+ break;
+ }
+ hold = (unsigned long)0;
+ bits = (unsigned int)0;
+ }
+ state->mode = DONE;
+ case (inflate_mode)DONE: ret = 1;
+ goto inf_leave;
+ case (inflate_mode)BAD: ret = -3;
+ goto inf_leave;
+ case (inflate_mode)MEM: __retres = -4;
+ goto return_label;
+ case (inflate_mode)SYNC: default: __retres = -2;
+ goto return_label;
+ }
+ inf_leave:
+ {
+ strm->next_out = put;
+ strm->avail_out = left;
+ strm->next_in = next;
+ strm->avail_in = have;
+ state->hold = hold;
+ state->bits = bits;
+ }
+ if (state->wsize) goto _LOR_3;
+ else
+ if (out != strm->avail_out)
+ if (state->mode < (unsigned int)BAD)
+ if (state->mode < (unsigned int)CHECK) goto _LOR_3;
+ else
+ if (flush != 4) {
+ int tmp_44;
+ _LOR_3:
+ tmp_44 = updatewindow(strm,(unsigned char const *)strm->next_out,
+ out - strm->avail_out);
+ if (tmp_44) {
+ state->mode = MEM;
+ __retres = -4;
+ goto return_label;
+ }
+ }
+ in -= strm->avail_in;
+ out -= strm->avail_out;
+ strm->total_in += (uLong)in;
+ strm->total_out += (uLong)out;
+ state->total += (unsigned long)out;
+ if (state->wrap & 4)
+ if (out) {
+ unsigned long tmp_45;
+ if (state->flags) tmp_45 = crc32(state->check,
+ (Bytef const *)(strm->next_out - out),
+ out);
+ else tmp_45 = adler32(state->check,
+ (Bytef const *)(strm->next_out - out),out);
+ state->check = tmp_45;
+ strm->adler = tmp_45;
+ }
+ if (state->last) tmp_48 = 64; else tmp_48 = 0;
+ if (state->mode == (unsigned int)TYPE) tmp_49 = 128; else tmp_49 = 0;
+ if (state->mode == (unsigned int)LEN_) tmp_50 = 256;
+ else
+ if (state->mode == (unsigned int)COPY_) tmp_50 = 256; else tmp_50 = 0;
+ strm->data_type = (((int)state->bits + tmp_48) + tmp_49) + tmp_50;
+ if (in == (unsigned int)0) {
+ if (out == (unsigned int)0) goto _LOR_4; else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (flush == 4) {
+ _LOR_4: ;
+ if (ret == 0) ret = -5;
+ }
+ }
+ __retres = ret;
+ return_label: return __retres;
+}
+
+int inflateEnd(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+int inflateEnd(z_streamp strm)
+{
+ int __retres;
+ struct inflate_state *state;
+ int tmp;
+ tmp = inflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (struct inflate_state *)strm->state;
+ if (state->window != (unsigned char *)0) (*(strm->zfree))(strm->opaque,
+ (void *)state->window);
+ (*(strm->zfree))(strm->opaque,(void *)strm->state);
+ strm->state = (struct internal_state *)0;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int inflateGetDictionary(z_streamp strm, Bytef *dictionary_0,
+ uInt *dictLength) __attribute__((__FC_OLDSTYLEPROTO__));
+int inflateGetDictionary(z_streamp strm, Bytef *dictionary_0,
+ uInt *dictLength)
+{
+ int __retres;
+ struct inflate_state *state;
+ int tmp;
+ tmp = inflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (struct inflate_state *)strm->state;
+ if (state->whave)
+ if (dictionary_0 != (Bytef *)0) {
+ memcpy((void *)dictionary_0,
+ (void const *)(state->window + state->wnext),
+ (unsigned long)(state->whave - state->wnext));
+ memcpy((void *)((dictionary_0 + state->whave) - state->wnext),
+ (void const *)state->window,(unsigned long)state->wnext);
+ }
+ if (dictLength != (uInt *)0) *dictLength = state->whave;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int inflateSetDictionary(z_streamp strm, Bytef const *dictionary_0,
+ uInt dictLength) __attribute__((__FC_OLDSTYLEPROTO__));
+int inflateSetDictionary(z_streamp strm, Bytef const *dictionary_0,
+ uInt dictLength)
+{
+ int __retres;
+ struct inflate_state *state;
+ unsigned long dictid;
+ int ret;
+ int tmp;
+ tmp = inflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (struct inflate_state *)strm->state;
+ if (state->wrap != 0)
+ if (state->mode != (unsigned int)DICT) {
+ __retres = -2;
+ goto return_label;
+ }
+ if (state->mode == (unsigned int)DICT) {
+ dictid = adler32((unsigned long)0L,(Bytef const *)0,(unsigned int)0);
+ dictid = adler32(dictid,dictionary_0,dictLength);
+ if (dictid != state->check) {
+ __retres = -3;
+ goto return_label;
+ }
+ }
+ ret = updatewindow(strm,dictionary_0 + dictLength,dictLength);
+ if (ret) {
+ state->mode = MEM;
+ __retres = -4;
+ goto return_label;
+ }
+ state->havedict = 1;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int inflateGetHeader(z_streamp strm, gz_headerp head) __attribute__((
+__FC_OLDSTYLEPROTO__));
+int inflateGetHeader(z_streamp strm, gz_headerp head)
+{
+ int __retres;
+ struct inflate_state *state;
+ int tmp;
+ tmp = inflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (struct inflate_state *)strm->state;
+ if ((state->wrap & 2) == 0) {
+ __retres = -2;
+ goto return_label;
+ }
+ state->head = head;
+ head->done = 0;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static unsigned int syncsearch(unsigned int *have, unsigned char const *buf,
+ unsigned int len) __attribute__((__FC_OLDSTYLEPROTO__));
+static unsigned int syncsearch(unsigned int *have, unsigned char const *buf,
+ unsigned int len)
+{
+ unsigned int got;
+ unsigned int next;
+ got = *have;
+ next = (unsigned int)0;
+ while (1) {
+ if (next < len) {
+ if (! (got < (unsigned int)4)) break;
+ }
+ else break;
+ {
+ int tmp;
+ if (got < (unsigned int)2) tmp = 0; else tmp = 0xff;
+ ;
+ if ((int)*(buf + next) == tmp) got ++;
+ else
+ if (*(buf + next)) got = (unsigned int)0;
+ else got = (unsigned int)4 - got;
+ next ++;
+ }
+ }
+ *have = got;
+ return next;
+}
+
+int inflateSync(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+int inflateSync(z_streamp strm)
+{
+ int __retres;
+ unsigned int len;
+ unsigned long in;
+ unsigned long out;
+ unsigned char buf[4];
+ struct inflate_state *state;
+ int tmp;
+ tmp = inflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (struct inflate_state *)strm->state;
+ if (strm->avail_in == (uInt)0)
+ if (state->bits < (unsigned int)8) {
+ __retres = -5;
+ goto return_label;
+ }
+ if (state->mode != (unsigned int)SYNC) {
+ state->mode = SYNC;
+ state->hold <<= state->bits & (unsigned int)7;
+ state->bits -= state->bits & (unsigned int)7;
+ len = (unsigned int)0;
+ while (state->bits >= (unsigned int)8) {
+ unsigned int tmp_0;
+ tmp_0 = len;
+ len ++;
+ buf[tmp_0] = (unsigned char)state->hold;
+ state->hold >>= 8;
+ state->bits -= (unsigned int)8;
+ }
+ state->have = (unsigned int)0;
+ syncsearch(& state->have,(unsigned char const *)(buf),len);
+ }
+ len = syncsearch(& state->have,(unsigned char const *)strm->next_in,
+ strm->avail_in);
+ strm->avail_in -= len;
+ strm->next_in += len;
+ strm->total_in += (uLong)len;
+ if (state->have != (unsigned int)4) {
+ __retres = -3;
+ goto return_label;
+ }
+ in = strm->total_in;
+ out = strm->total_out;
+ inflateReset(strm);
+ strm->total_in = in;
+ strm->total_out = out;
+ state->mode = TYPE;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int inflateSyncPoint(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+int inflateSyncPoint(z_streamp strm)
+{
+ int __retres;
+ struct inflate_state *state;
+ int tmp;
+ int tmp_0;
+ tmp = inflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (struct inflate_state *)strm->state;
+ if (state->mode == (unsigned int)STORED)
+ if (state->bits == (unsigned int)0) tmp_0 = 1; else tmp_0 = 0;
+ else tmp_0 = 0;
+ __retres = tmp_0;
+ return_label: return __retres;
+}
+
+int inflateCopy(z_streamp dest, z_streamp source) __attribute__((__FC_OLDSTYLEPROTO__));
+int inflateCopy(z_streamp dest, z_streamp source)
+{
+ int __retres;
+ struct inflate_state *state;
+ struct inflate_state *copy;
+ unsigned char *window;
+ unsigned int wsize;
+ int tmp;
+ tmp = inflateStateCheck(source);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ else
+ if (dest == (z_streamp)0) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (struct inflate_state *)source->state;
+ copy = (struct inflate_state *)(*(source->zalloc))(source->opaque,
+ (unsigned int)1,
+ (unsigned int)sizeof(struct inflate_state));
+ if (copy == (struct inflate_state *)0) {
+ __retres = -4;
+ goto return_label;
+ }
+ window = (unsigned char *)0;
+ if (state->window != (unsigned char *)0) {
+ window = (unsigned char *)(*(source->zalloc))(source->opaque,
+ 1U << state->wbits,
+ (unsigned int)sizeof(unsigned char));
+ if (window == (unsigned char *)0) {
+ (*(source->zfree))(source->opaque,(void *)copy);
+ __retres = -4;
+ goto return_label;
+ }
+ }
+ memcpy((void *)dest,(void const *)source,sizeof(z_stream));
+ memcpy((void *)copy,(void const *)state,sizeof(struct inflate_state));
+ copy->strm = dest;
+ if ((void *)state->lencode >= (void *)(state->codes))
+ if ((void *)state->lencode <= (void *)(& state->codes[852 + 592] - 1)) {
+ copy->lencode = (code const *)(& copy->codes[state->lencode - state->codes]);
+ copy->distcode = (code const *)(& copy->codes[state->distcode - state->codes]);
+ }
+ copy->next = & copy->codes[state->next - state->codes];
+ if (window != (unsigned char *)0) {
+ wsize = 1U << state->wbits;
+ memcpy((void *)window,(void const *)state->window,(unsigned long)wsize);
+ }
+ copy->window = window;
+ dest->state = (struct internal_state *)copy;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+int inflateUndermine(z_streamp strm, int subvert) __attribute__((__FC_OLDSTYLEPROTO__));
+int inflateUndermine(z_streamp strm, int subvert)
+{
+ int __retres;
+ struct inflate_state *state;
+ int tmp;
+ tmp = inflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (struct inflate_state *)strm->state;
+ state->sane = 1;
+ __retres = -3;
+ return_label: return __retres;
+}
+
+int inflateValidate(z_streamp strm, int check) __attribute__((__FC_OLDSTYLEPROTO__));
+int inflateValidate(z_streamp strm, int check)
+{
+ int __retres;
+ struct inflate_state *state;
+ int tmp;
+ tmp = inflateStateCheck(strm);
+ if (tmp) {
+ __retres = -2;
+ goto return_label;
+ }
+ state = (struct inflate_state *)strm->state;
+ if (check) state->wrap |= 4; else state->wrap &= ~ 4;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+long inflateMark(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+long inflateMark(z_streamp strm)
+{
+ long __retres;
+ struct inflate_state *state;
+ int tmp;
+ unsigned int tmp_1;
+ tmp = inflateStateCheck(strm);
+ if (tmp) {
+ __retres = - (1L << 16);
+ goto return_label;
+ }
+ state = (struct inflate_state *)strm->state;
+ if (state->mode == (unsigned int)COPY) tmp_1 = state->length;
+ else {
+ unsigned int tmp_0;
+ if (state->mode == (unsigned int)MATCH) tmp_0 = state->was - state->length;
+ else tmp_0 = (unsigned int)0;
+ tmp_1 = tmp_0;
+ }
+ ;
+ __retres = (long)((unsigned long)((long)state->back) << 16) + (long)tmp_1;
+ return_label: return __retres;
+}
+
+unsigned long inflateCodesUsed(z_streamp strm) __attribute__((__FC_OLDSTYLEPROTO__));
+unsigned long inflateCodesUsed(z_streamp strm)
+{
+ unsigned long __retres;
+ struct inflate_state *state;
+ int tmp;
+ tmp = inflateStateCheck(strm);
+ if (tmp) {
+ __retres = (unsigned long)(-1);
+ goto return_label;
+ }
+ state = (struct inflate_state *)strm->state;
+ __retres = (unsigned long)(state->next - state->codes);
+ return_label: return __retres;
+}
+
+char const inflate_copyright[48] =
+ {(char)' ',
+ (char)'i',
+ (char)'n',
+ (char)'f',
+ (char)'l',
+ (char)'a',
+ (char)'t',
+ (char)'e',
+ (char)' ',
+ (char)'1',
+ (char)'.',
+ (char)'2',
+ (char)'.',
+ (char)'1',
+ (char)'1',
+ (char)' ',
+ (char)'C',
+ (char)'o',
+ (char)'p',
+ (char)'y',
+ (char)'r',
+ (char)'i',
+ (char)'g',
+ (char)'h',
+ (char)'t',
+ (char)' ',
+ (char)'1',
+ (char)'9',
+ (char)'9',
+ (char)'5',
+ (char)'-',
+ (char)'2',
+ (char)'0',
+ (char)'1',
+ (char)'7',
+ (char)' ',
+ (char)'M',
+ (char)'a',
+ (char)'r',
+ (char)'k',
+ (char)' ',
+ (char)'A',
+ (char)'d',
+ (char)'l',
+ (char)'e',
+ (char)'r',
+ (char)' ',
+ (char)'\000'};
+static unsigned short const inflate_table_lbase[31] =
+ {(unsigned short)3,
+ (unsigned short)4,
+ (unsigned short)5,
+ (unsigned short)6,
+ (unsigned short)7,
+ (unsigned short)8,
+ (unsigned short)9,
+ (unsigned short)10,
+ (unsigned short)11,
+ (unsigned short)13,
+ (unsigned short)15,
+ (unsigned short)17,
+ (unsigned short)19,
+ (unsigned short)23,
+ (unsigned short)27,
+ (unsigned short)31,
+ (unsigned short)35,
+ (unsigned short)43,
+ (unsigned short)51,
+ (unsigned short)59,
+ (unsigned short)67,
+ (unsigned short)83,
+ (unsigned short)99,
+ (unsigned short)115,
+ (unsigned short)131,
+ (unsigned short)163,
+ (unsigned short)195,
+ (unsigned short)227,
+ (unsigned short)258,
+ (unsigned short)0,
+ (unsigned short)0};
+static unsigned short const inflate_table_lext[31] =
+ {(unsigned short)16,
+ (unsigned short)16,
+ (unsigned short)16,
+ (unsigned short)16,
+ (unsigned short)16,
+ (unsigned short)16,
+ (unsigned short)16,
+ (unsigned short)16,
+ (unsigned short)17,
+ (unsigned short)17,
+ (unsigned short)17,
+ (unsigned short)17,
+ (unsigned short)18,
+ (unsigned short)18,
+ (unsigned short)18,
+ (unsigned short)18,
+ (unsigned short)19,
+ (unsigned short)19,
+ (unsigned short)19,
+ (unsigned short)19,
+ (unsigned short)20,
+ (unsigned short)20,
+ (unsigned short)20,
+ (unsigned short)20,
+ (unsigned short)21,
+ (unsigned short)21,
+ (unsigned short)21,
+ (unsigned short)21,
+ (unsigned short)16,
+ (unsigned short)77,
+ (unsigned short)202};
+static unsigned short const inflate_table_dbase[32] =
+ {(unsigned short)1,
+ (unsigned short)2,
+ (unsigned short)3,
+ (unsigned short)4,
+ (unsigned short)5,
+ (unsigned short)7,
+ (unsigned short)9,
+ (unsigned short)13,
+ (unsigned short)17,
+ (unsigned short)25,
+ (unsigned short)33,
+ (unsigned short)49,
+ (unsigned short)65,
+ (unsigned short)97,
+ (unsigned short)129,
+ (unsigned short)193,
+ (unsigned short)257,
+ (unsigned short)385,
+ (unsigned short)513,
+ (unsigned short)769,
+ (unsigned short)1025,
+ (unsigned short)1537,
+ (unsigned short)2049,
+ (unsigned short)3073,
+ (unsigned short)4097,
+ (unsigned short)6145,
+ (unsigned short)8193,
+ (unsigned short)12289,
+ (unsigned short)16385,
+ (unsigned short)24577,
+ (unsigned short)0,
+ (unsigned short)0};
+static unsigned short const inflate_table_dext[32] =
+ {(unsigned short)16,
+ (unsigned short)16,
+ (unsigned short)16,
+ (unsigned short)16,
+ (unsigned short)17,
+ (unsigned short)17,
+ (unsigned short)18,
+ (unsigned short)18,
+ (unsigned short)19,
+ (unsigned short)19,
+ (unsigned short)20,
+ (unsigned short)20,
+ (unsigned short)21,
+ (unsigned short)21,
+ (unsigned short)22,
+ (unsigned short)22,
+ (unsigned short)23,
+ (unsigned short)23,
+ (unsigned short)24,
+ (unsigned short)24,
+ (unsigned short)25,
+ (unsigned short)25,
+ (unsigned short)26,
+ (unsigned short)26,
+ (unsigned short)27,
+ (unsigned short)27,
+ (unsigned short)28,
+ (unsigned short)28,
+ (unsigned short)29,
+ (unsigned short)29,
+ (unsigned short)64,
+ (unsigned short)64};
+int inflate_table(codetype type, unsigned short *lens, unsigned int codes,
+ code **table, unsigned int *bits, unsigned short *work) __attribute__((
+__FC_OLDSTYLEPROTO__));
+int inflate_table(codetype type, unsigned short *lens, unsigned int codes,
+ code **table, unsigned int *bits, unsigned short *work)
+{
+ int __retres;
+ unsigned int len;
+ unsigned int sym;
+ unsigned int min;
+ unsigned int max;
+ unsigned int root;
+ unsigned int curr;
+ unsigned int drop;
+ int left;
+ unsigned int used;
+ unsigned int huff;
+ unsigned int incr;
+ unsigned int fill;
+ unsigned int low;
+ unsigned int mask;
+ code here;
+ code *next;
+ unsigned short const *base;
+ unsigned short const *extra;
+ unsigned int match;
+ unsigned short count[15 + 1];
+ unsigned short offs[15 + 1];
+ len = (unsigned int)0;
+ while (len <= (unsigned int)15) {
+ count[len] = (unsigned short)0;
+ len ++;
+ }
+ sym = (unsigned int)0;
+ while (sym < codes) {
+ count[*(lens + sym)] = (unsigned short)((int)count[*(lens + sym)] + 1);
+ sym ++;
+ }
+ root = *bits;
+ max = (unsigned int)15;
+ while (max >= (unsigned int)1) {
+ if ((int)count[max] != 0) break;
+ max --;
+ }
+ if (root > max) root = max;
+ if (max == (unsigned int)0) {
+ code *tmp;
+ code *tmp_0;
+ here.op = (unsigned char)64;
+ here.bits = (unsigned char)1;
+ here.val = (unsigned short)0;
+ tmp = *table;
+ (*table) ++;
+ *tmp = here;
+ tmp_0 = *table;
+ (*table) ++;
+ *tmp_0 = here;
+ *bits = (unsigned int)1;
+ __retres = 0;
+ goto return_label;
+ }
+ min = (unsigned int)1;
+ while (min < max) {
+ if ((int)count[min] != 0) break;
+ min ++;
+ }
+ if (root < min) root = min;
+ left = 1;
+ len = (unsigned int)1;
+ while (len <= (unsigned int)15) {
+ left <<= 1;
+ left -= (int)count[len];
+ if (left < 0) {
+ __retres = -1;
+ goto return_label;
+ }
+ len ++;
+ }
+ if (left > 0)
+ if (type == (unsigned int)CODES) {
+ __retres = -1;
+ goto return_label;
+ }
+ else
+ if (max != (unsigned int)1) {
+ __retres = -1;
+ goto return_label;
+ }
+ offs[1] = (unsigned short)0;
+ len = (unsigned int)1;
+ while (len < (unsigned int)15) {
+ offs[len + (unsigned int)1] = (unsigned short)((int)offs[len] + (int)count[len]);
+ len ++;
+ }
+ sym = (unsigned int)0;
+ while (sym < codes) {
+ if ((int)*(lens + sym) != 0) {
+ unsigned short tmp_1;
+ tmp_1 = offs[*(lens + sym)];
+ offs[*(lens + sym)] = (unsigned short)((int)offs[*(lens + sym)] + 1);
+ *(work + tmp_1) = (unsigned short)sym;
+ }
+ sym ++;
+ }
+ switch (type) {
+ case (codetype)CODES:
+ { /* sequence */
+ extra = (unsigned short const *)work;
+ base = extra;
+ }
+ match = (unsigned int)20;
+ break;
+ case (codetype)LENS: base = inflate_table_lbase;
+ extra = inflate_table_lext;
+ match = (unsigned int)257;
+ break;
+ default: base = inflate_table_dbase;
+ extra = inflate_table_dext;
+ match = (unsigned int)0;
+ }
+ huff = (unsigned int)0;
+ sym = (unsigned int)0;
+ len = min;
+ next = *table;
+ curr = root;
+ drop = (unsigned int)0;
+ low = (unsigned int)(-1);
+ used = 1U << root;
+ mask = used - (unsigned int)1;
+ if (type == (unsigned int)LENS) {
+ if (used > (unsigned int)852) {
+ __retres = 1;
+ goto return_label;
+ }
+ else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (type == (unsigned int)DISTS)
+ if (used > (unsigned int)592) {
+ __retres = 1;
+ goto return_label;
+ }
+ }
+ while (1) {
+ here.bits = (unsigned char)(len - drop);
+ if ((unsigned int)*(work + sym) + 1U < match) {
+ here.op = (unsigned char)0;
+ here.val = *(work + sym);
+ }
+ else
+ if ((unsigned int)*(work + sym) >= match) {
+ here.op = (unsigned char)*(extra + ((unsigned int)*(work + sym) - match));
+ here.val = *(base + ((unsigned int)*(work + sym) - match));
+ }
+ else {
+ here.op = (unsigned char)(32 + 64);
+ here.val = (unsigned short)0;
+ }
+ incr = 1U << (len - drop);
+ fill = 1U << curr;
+ min = fill;
+ while (1) {
+ fill -= incr;
+ *(next + ((huff >> drop) + fill)) = here;
+ if (! (fill != (unsigned int)0)) break;
+ }
+ incr = 1U << (len - (unsigned int)1);
+ while (huff & incr) incr >>= 1;
+ if (incr != (unsigned int)0) {
+ huff &= incr - (unsigned int)1;
+ huff += incr;
+ }
+ else huff = (unsigned int)0;
+ sym ++;
+ count[len] = (unsigned short)((int)count[len] - 1);
+ if ((int)count[len] == 0) {
+ if (len == max) break;
+ len = (unsigned int)*(lens + *(work + sym));
+ }
+ if (len > root)
+ if ((huff & mask) != low) {
+ if (drop == (unsigned int)0) drop = root;
+ next += min;
+ curr = len - drop;
+ left = 1 << curr;
+ while (curr + drop < max) {
+ left -= (int)count[curr + drop];
+ if (left <= 0) break;
+ curr ++;
+ left <<= 1;
+ }
+ used += 1U << curr;
+ if (type == (unsigned int)LENS) {
+ if (used > (unsigned int)852) {
+ __retres = 1;
+ goto return_label;
+ }
+ else goto _LAND_0;
+ }
+ else {
+ _LAND_0: ;
+ if (type == (unsigned int)DISTS)
+ if (used > (unsigned int)592) {
+ __retres = 1;
+ goto return_label;
+ }
+ }
+ low = huff & mask;
+ (*table + low)->op = (unsigned char)curr;
+ (*table + low)->bits = (unsigned char)root;
+ (*table + low)->val = (unsigned short)(next - *table);
+ }
+ }
+ if (huff != (unsigned int)0) {
+ here.op = (unsigned char)64;
+ here.bits = (unsigned char)(len - drop);
+ here.val = (unsigned short)0;
+ *(next + huff) = here;
+ }
+ *table += used;
+ *bits = root;
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static int const extra_lbits[29] =
+ {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};
+static int const extra_dbits[30] =
+ {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};
+static int const extra_blbits[19] =
+ {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7};
+static uch const bl_order[19] =
+ {(unsigned char)16,
+ (unsigned char)17,
+ (unsigned char)18,
+ (unsigned char)0,
+ (unsigned char)8,
+ (unsigned char)7,
+ (unsigned char)9,
+ (unsigned char)6,
+ (unsigned char)10,
+ (unsigned char)5,
+ (unsigned char)11,
+ (unsigned char)4,
+ (unsigned char)12,
+ (unsigned char)3,
+ (unsigned char)13,
+ (unsigned char)2,
+ (unsigned char)14,
+ (unsigned char)1,
+ (unsigned char)15};
+static ct_data const static_ltree[((256 + 1) + 29) + 2] =
+ {{.fc = {.freq = (unsigned short)12}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)140}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)76}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)204}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)44}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)172}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)108}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)236}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)28}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)156}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)92}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)220}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)60}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)188}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)124}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)252}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)2}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)130}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)66}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)194}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)34}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)162}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)98}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)226}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)18}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)146}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)82}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)210}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)50}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)178}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)114}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)242}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)10}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)138}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)74}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)202}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)42}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)170}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)106}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)234}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)26}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)154}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)90}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)218}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)58}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)186}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)122}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)250}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)6}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)134}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)70}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)198}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)38}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)166}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)102}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)230}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)22}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)150}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)86}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)214}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)54}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)182}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)118}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)246}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)14}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)142}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)78}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)206}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)46}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)174}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)110}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)238}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)30}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)158}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)94}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)222}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)62}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)190}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)126}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)254}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)1}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)129}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)65}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)193}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)33}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)161}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)97}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)225}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)17}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)145}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)81}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)209}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)49}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)177}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)113}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)241}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)9}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)137}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)73}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)201}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)41}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)169}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)105}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)233}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)25}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)153}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)89}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)217}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)57}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)185}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)121}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)249}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)5}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)133}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)69}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)197}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)37}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)165}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)101}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)229}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)21}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)149}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)85}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)213}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)53}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)181}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)117}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)245}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)13}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)141}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)77}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)205}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)45}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)173}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)109}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)237}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)29}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)157}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)93}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)221}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)61}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)189}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)125}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)253}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)19}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)275}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)147}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)403}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)83}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)339}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)211}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)467}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)51}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)307}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)179}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)435}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)115}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)371}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)243}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)499}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)11}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)267}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)139}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)395}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)75}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)331}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)203}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)459}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)43}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)299}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)171}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)427}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)107}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)363}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)235}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)491}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)27}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)283}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)155}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)411}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)91}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)347}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)219}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)475}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)59}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)315}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)187}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)443}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)123}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)379}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)251}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)507}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)7}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)263}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)135}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)391}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)71}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)327}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)199}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)455}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)39}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)295}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)167}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)423}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)103}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)359}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)231}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)487}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)23}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)279}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)151}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)407}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)87}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)343}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)215}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)471}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)55}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)311}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)183}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)439}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)119}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)375}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)247}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)503}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)15}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)271}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)143}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)399}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)79}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)335}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)207}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)463}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)47}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)303}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)175}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)431}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)111}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)367}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)239}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)495}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)31}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)287}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)159}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)415}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)95}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)351}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)223}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)479}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)63}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)319}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)191}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)447}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)127}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)383}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)255}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)511}, .dl = {.dad = (unsigned short)9}},
+ {.fc = {.freq = (unsigned short)0}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)64}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)32}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)96}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)16}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)80}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)48}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)112}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)8}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)72}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)40}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)104}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)24}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)88}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)56}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)120}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)4}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)68}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)36}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)100}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)20}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)84}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)52}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)116}, .dl = {.dad = (unsigned short)7}},
+ {.fc = {.freq = (unsigned short)3}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)131}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)67}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)195}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)35}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)163}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)99}, .dl = {.dad = (unsigned short)8}},
+ {.fc = {.freq = (unsigned short)227}, .dl = {.dad = (unsigned short)8}}};
+static ct_data const static_dtree[30] =
+ {{.fc = {.freq = (unsigned short)0}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)16}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)8}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)24}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)4}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)20}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)12}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)28}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)2}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)18}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)10}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)26}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)6}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)22}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)14}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)30}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)1}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)17}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)9}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)25}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)5}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)21}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)13}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)29}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)3}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)19}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)11}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)27}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)7}, .dl = {.dad = (unsigned short)5}},
+ {.fc = {.freq = (unsigned short)23}, .dl = {.dad = (unsigned short)5}}};
+uch const _dist_code[512] =
+ {(unsigned char)0,
+ (unsigned char)1,
+ (unsigned char)2,
+ (unsigned char)3,
+ (unsigned char)4,
+ (unsigned char)4,
+ (unsigned char)5,
+ (unsigned char)5,
+ (unsigned char)6,
+ (unsigned char)6,
+ (unsigned char)6,
+ (unsigned char)6,
+ (unsigned char)7,
+ (unsigned char)7,
+ (unsigned char)7,
+ (unsigned char)7,
+ (unsigned char)8,
+ (unsigned char)8,
+ (unsigned char)8,
+ (unsigned char)8,
+ (unsigned char)8,
+ (unsigned char)8,
+ (unsigned char)8,
+ (unsigned char)8,
+ (unsigned char)9,
+ (unsigned char)9,
+ (unsigned char)9,
+ (unsigned char)9,
+ (unsigned char)9,
+ (unsigned char)9,
+ (unsigned char)9,
+ (unsigned char)9,
+ (unsigned char)10,
+ (unsigned char)10,
+ (unsigned char)10,
+ (unsigned char)10,
+ (unsigned char)10,
+ (unsigned char)10,
+ (unsigned char)10,
+ (unsigned char)10,
+ (unsigned char)10,
+ (unsigned char)10,
+ (unsigned char)10,
+ (unsigned char)10,
+ (unsigned char)10,
+ (unsigned char)10,
+ (unsigned char)10,
+ (unsigned char)10,
+ (unsigned char)11,
+ (unsigned char)11,
+ (unsigned char)11,
+ (unsigned char)11,
+ (unsigned char)11,
+ (unsigned char)11,
+ (unsigned char)11,
+ (unsigned char)11,
+ (unsigned char)11,
+ (unsigned char)11,
+ (unsigned char)11,
+ (unsigned char)11,
+ (unsigned char)11,
+ (unsigned char)11,
+ (unsigned char)11,
+ (unsigned char)11,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)0,
+ (unsigned char)0,
+ (unsigned char)16,
+ (unsigned char)17,
+ (unsigned char)18,
+ (unsigned char)18,
+ (unsigned char)19,
+ (unsigned char)19,
+ (unsigned char)20,
+ (unsigned char)20,
+ (unsigned char)20,
+ (unsigned char)20,
+ (unsigned char)21,
+ (unsigned char)21,
+ (unsigned char)21,
+ (unsigned char)21,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)28,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29,
+ (unsigned char)29};
+uch const _length_code[(258 - 3) + 1] =
+ {(unsigned char)0,
+ (unsigned char)1,
+ (unsigned char)2,
+ (unsigned char)3,
+ (unsigned char)4,
+ (unsigned char)5,
+ (unsigned char)6,
+ (unsigned char)7,
+ (unsigned char)8,
+ (unsigned char)8,
+ (unsigned char)9,
+ (unsigned char)9,
+ (unsigned char)10,
+ (unsigned char)10,
+ (unsigned char)11,
+ (unsigned char)11,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)12,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)13,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)14,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)15,
+ (unsigned char)16,
+ (unsigned char)16,
+ (unsigned char)16,
+ (unsigned char)16,
+ (unsigned char)16,
+ (unsigned char)16,
+ (unsigned char)16,
+ (unsigned char)16,
+ (unsigned char)17,
+ (unsigned char)17,
+ (unsigned char)17,
+ (unsigned char)17,
+ (unsigned char)17,
+ (unsigned char)17,
+ (unsigned char)17,
+ (unsigned char)17,
+ (unsigned char)18,
+ (unsigned char)18,
+ (unsigned char)18,
+ (unsigned char)18,
+ (unsigned char)18,
+ (unsigned char)18,
+ (unsigned char)18,
+ (unsigned char)18,
+ (unsigned char)19,
+ (unsigned char)19,
+ (unsigned char)19,
+ (unsigned char)19,
+ (unsigned char)19,
+ (unsigned char)19,
+ (unsigned char)19,
+ (unsigned char)19,
+ (unsigned char)20,
+ (unsigned char)20,
+ (unsigned char)20,
+ (unsigned char)20,
+ (unsigned char)20,
+ (unsigned char)20,
+ (unsigned char)20,
+ (unsigned char)20,
+ (unsigned char)20,
+ (unsigned char)20,
+ (unsigned char)20,
+ (unsigned char)20,
+ (unsigned char)20,
+ (unsigned char)20,
+ (unsigned char)20,
+ (unsigned char)20,
+ (unsigned char)21,
+ (unsigned char)21,
+ (unsigned char)21,
+ (unsigned char)21,
+ (unsigned char)21,
+ (unsigned char)21,
+ (unsigned char)21,
+ (unsigned char)21,
+ (unsigned char)21,
+ (unsigned char)21,
+ (unsigned char)21,
+ (unsigned char)21,
+ (unsigned char)21,
+ (unsigned char)21,
+ (unsigned char)21,
+ (unsigned char)21,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)22,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)23,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)24,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)25,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)26,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)27,
+ (unsigned char)28};
+static int const base_length[29] =
+ {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};
+static int const base_dist[30] =
+ {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};
+static static_tree_desc const static_l_desc =
+ {.static_tree = static_ltree,
+ .extra_bits = extra_lbits,
+ .extra_base = 256 + 1,
+ .elems = (256 + 1) + 29,
+ .max_length = 15};
+static static_tree_desc const static_d_desc =
+ {.static_tree = static_dtree,
+ .extra_bits = extra_dbits,
+ .extra_base = 0,
+ .elems = 30,
+ .max_length = 15};
+static static_tree_desc const static_bl_desc =
+ {.static_tree = (ct_data const *)0,
+ .extra_bits = extra_blbits,
+ .extra_base = 0,
+ .elems = 19,
+ .max_length = 7};
+static void tr_static_init(void);
+
+static void init_block(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static void pqdownheap(deflate_state *s, ct_data *tree, int k) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static void gen_bitlen(deflate_state *s, tree_desc *desc) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static void gen_codes(ct_data *tree, int max_code, ushf *bl_count) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static void build_tree(deflate_state *s, tree_desc *desc) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static void scan_tree(deflate_state *s, ct_data *tree, int max_code) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static void send_tree(deflate_state *s, ct_data *tree, int max_code) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static int build_bl_tree(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static void send_all_trees(deflate_state *s, int lcodes, int dcodes,
+ int blcodes) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static void compress_block(deflate_state *s, ct_data const *ltree,
+ ct_data const *dtree) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static int detect_data_type(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static unsigned int bi_reverse(unsigned int code, int len) __attribute__((
+__FC_OLDSTYLEPROTO__));
+
+static void bi_windup(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static void bi_flush(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+
+static void tr_static_init(void)
+{
+ return;
+}
+
+void _tr_init(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+void _tr_init(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 = (unsigned short)0;
+ s->bi_valid = 0;
+ init_block(s);
+ return;
+}
+
+static void init_block(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+static void init_block(deflate_state *s)
+{
+ int n;
+ ulg tmp;
+ uInt tmp_0;
+ n = 0;
+ while (n < (256 + 1) + 29) {
+ s->dyn_ltree[n].fc.freq = (unsigned short)0;
+ n ++;
+ }
+ n = 0;
+ while (n < 30) {
+ s->dyn_dtree[n].fc.freq = (unsigned short)0;
+ n ++;
+ }
+ n = 0;
+ while (n < 19) {
+ s->bl_tree[n].fc.freq = (unsigned short)0;
+ n ++;
+ }
+ s->dyn_ltree[256].fc.freq = (unsigned short)1;
+ tmp = (unsigned long)0L;
+ s->static_len = tmp;
+ s->opt_len = tmp;
+ tmp_0 = (unsigned int)0;
+ s->matches = tmp_0;
+ s->last_lit = tmp_0;
+ return;
+}
+
+static void pqdownheap(deflate_state *s, ct_data *tree, int k) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static void pqdownheap(deflate_state *s, ct_data *tree, int k)
+{
+ int v = s->heap[k];
+ int j = k << 1;
+ while (j <= s->heap_len) {
+ if (j < s->heap_len)
+ if ((int)(tree + s->heap[j + 1])->fc.freq < (int)(tree + s->heap[j])->fc.freq)
+ goto _LOR;
+ else
+ if ((int)(tree + s->heap[j + 1])->fc.freq == (int)(tree + s->heap[j])->fc.freq)
+ if ((int)s->depth[s->heap[j + 1]] <= (int)s->depth[s->heap[j]])
+ _LOR:
+ j ++;
+ if ((int)(tree + v)->fc.freq < (int)(tree + s->heap[j])->fc.freq)
+ break;
+ else
+ if ((int)(tree + v)->fc.freq == (int)(tree + s->heap[j])->fc.freq)
+ if ((int)s->depth[v] <= (int)s->depth[s->heap[j]]) break;
+ s->heap[k] = s->heap[j];
+ k = j;
+ j <<= 1;
+ }
+ s->heap[k] = v;
+ return;
+}
+
+static void gen_bitlen(deflate_state *s, tree_desc *desc) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static void gen_bitlen(deflate_state *s, tree_desc *desc)
+{
+ int h;
+ int n;
+ int m;
+ int bits;
+ int xbits;
+ ush f;
+ ct_data *tree = desc->dyn_tree;
+ int max_code = desc->max_code;
+ ct_data const *stree = (desc->stat_desc)->static_tree;
+ intf const *extra = (desc->stat_desc)->extra_bits;
+ int base = (desc->stat_desc)->extra_base;
+ int max_length = (desc->stat_desc)->max_length;
+ int overflow = 0;
+ bits = 0;
+ while (bits <= 15) {
+ s->bl_count[bits] = (unsigned short)0;
+ bits ++;
+ }
+ (tree + s->heap[s->heap_max])->dl.len = (unsigned short)0;
+ h = s->heap_max + 1;
+ while (h < 2 * ((256 + 1) + 29) + 1) {
+ n = s->heap[h];
+ bits = (int)(tree + (tree + n)->dl.dad)->dl.len + 1;
+ if (bits > max_length) {
+ bits = max_length;
+ overflow ++;
+ }
+ (tree + n)->dl.len = (unsigned short)bits;
+ if (n > max_code) goto __Cont;
+ s->bl_count[bits] = (unsigned short)((int)s->bl_count[bits] + 1);
+ xbits = 0;
+ if (n >= base) xbits = *(extra + (n - base));
+ f = (tree + n)->fc.freq;
+ s->opt_len += (unsigned long)f * (unsigned long)((unsigned int)(bits + xbits));
+ if (stree) s->static_len += (unsigned long)f * (unsigned long)((unsigned int)(
+ (int)(stree + n)->dl.len + xbits));
+ __Cont: h ++;
+ }
+ if (overflow == 0) goto return_label;
+ while (1) {
+ bits = max_length - 1;
+ while ((int)s->bl_count[bits] == 0) bits --;
+ s->bl_count[bits] = (unsigned short)((int)s->bl_count[bits] - 1);
+ s->bl_count[bits + 1] = (unsigned short)((int)s->bl_count[bits + 1] + 2);
+ s->bl_count[max_length] = (unsigned short)((int)s->bl_count[max_length] - 1);
+ overflow -= 2;
+ if (! (overflow > 0)) break;
+ }
+ bits = max_length;
+ while (bits != 0) {
+ n = (int)s->bl_count[bits];
+ while (n != 0) {
+ h --;
+ m = s->heap[h];
+ if (m > max_code) continue;
+ if ((unsigned int)(tree + m)->dl.len != (unsigned int)bits) {
+ s->opt_len += ((unsigned long)bits - (unsigned long)(tree + m)->dl.len) * (unsigned long)(
+ tree + m)->fc.freq;
+ (tree + m)->dl.len = (unsigned short)bits;
+ }
+ n --;
+ }
+ bits --;
+ }
+ return_label: return;
+}
+
+static void gen_codes(ct_data *tree, int max_code, ushf *bl_count) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static void gen_codes(ct_data *tree, int max_code, ushf *bl_count)
+{
+ ush next_code[15 + 1];
+ int bits;
+ int n;
+ unsigned int code = (unsigned int)0;
+ bits = 1;
+ while (bits <= 15) {
+ code = (code + (unsigned int)*(bl_count + (bits - 1))) << 1;
+ next_code[bits] = (unsigned short)code;
+ bits ++;
+ }
+ n = 0;
+ while (n <= max_code) {
+ {
+ unsigned int tmp_0;
+ ush tmp;
+ int len = (int)(tree + n)->dl.len;
+ if (len == 0) goto __Cont;
+ ;
+ tmp = next_code[len];
+ next_code[len] = (unsigned short)((int)next_code[len] + 1);
+ ;
+ tmp_0 = bi_reverse((unsigned int)tmp,len);
+ (tree + n)->fc.code = (unsigned short)tmp_0;
+ }
+ __Cont: n ++;
+ }
+ return;
+}
+
+static void build_tree(deflate_state *s, tree_desc *desc) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static void build_tree(deflate_state *s, tree_desc *desc)
+{
+ int n;
+ int m;
+ int node;
+ ct_data *tree = desc->dyn_tree;
+ ct_data const *stree = (desc->stat_desc)->static_tree;
+ int elems = (desc->stat_desc)->elems;
+ int max_code = -1;
+ s->heap_len = 0;
+ s->heap_max = 2 * ((256 + 1) + 29) + 1;
+ n = 0;
+ while (n < elems) {
+ if ((int)(tree + n)->fc.freq != 0) {
+ (s->heap_len) ++;
+ max_code = n;
+ s->heap[s->heap_len] = max_code;
+ s->depth[n] = (unsigned char)0;
+ }
+ else (tree + n)->dl.len = (unsigned short)0;
+ n ++;
+ }
+ while (s->heap_len < 2) {
+ int tmp;
+ (s->heap_len) ++;
+ if (max_code < 2) {
+ max_code ++;
+ tmp = max_code;
+ }
+ else tmp = 0;
+ s->heap[s->heap_len] = tmp;
+ node = tmp;
+ (tree + node)->fc.freq = (unsigned short)1;
+ s->depth[node] = (unsigned char)0;
+ (s->opt_len) --;
+ if (stree) s->static_len -= (ulg)(stree + node)->dl.len;
+ }
+ desc->max_code = max_code;
+ n = s->heap_len / 2;
+ while (n >= 1) {
+ pqdownheap(s,tree,n);
+ n --;
+ }
+ node = elems;
+ while (1) {
+ {
+ int tmp_1;
+ ush tmp_2;
+ int tmp_3;
+ {
+ int tmp_0;
+ n = s->heap[1];
+ tmp_0 = s->heap_len;
+ (s->heap_len) --;
+ s->heap[1] = s->heap[tmp_0];
+ pqdownheap(s,tree,1);
+ }
+ m = s->heap[1];
+ (s->heap_max) --;
+ s->heap[s->heap_max] = n;
+ (s->heap_max) --;
+ s->heap[s->heap_max] = m;
+ (tree + node)->fc.freq = (unsigned short)((int)(tree + n)->fc.freq + (int)(
+ tree + m)->fc.freq);
+ if ((int)s->depth[n] >= (int)s->depth[m]) tmp_1 = (int)s->depth[n];
+ else tmp_1 = (int)s->depth[m];
+ s->depth[node] = (unsigned char)(tmp_1 + 1);
+ tmp_2 = (unsigned short)node;
+ (tree + m)->dl.dad = tmp_2;
+ (tree + n)->dl.dad = tmp_2;
+ tmp_3 = node;
+ node ++;
+ s->heap[1] = tmp_3;
+ pqdownheap(s,tree,1);
+ }
+ if (! (s->heap_len >= 2)) break;
+ }
+ (s->heap_max) --;
+ s->heap[s->heap_max] = s->heap[1];
+ gen_bitlen(s,desc);
+ gen_codes(tree,max_code,s->bl_count);
+ return;
+}
+
+static void scan_tree(deflate_state *s, ct_data *tree, int max_code) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static void scan_tree(deflate_state *s, ct_data *tree, int max_code)
+{
+ int n;
+ int curlen;
+ int prevlen = -1;
+ int nextlen = (int)(tree + 0)->dl.len;
+ int count = 0;
+ int max_count = 7;
+ int min_count = 4;
+ if (nextlen == 0) {
+ max_count = 138;
+ min_count = 3;
+ }
+ (tree + (max_code + 1))->dl.len = (unsigned short)0xffff;
+ n = 0;
+ while (n <= max_code) {
+ curlen = nextlen;
+ nextlen = (int)(tree + (n + 1))->dl.len;
+ count ++;
+ ;
+ if (count < max_count) {
+ if (curlen == nextlen) goto __Cont; else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (count < min_count) s->bl_tree[curlen].fc.freq = (unsigned short)(
+ (int)s->bl_tree[curlen].fc.freq + count);
+ else
+ if (curlen != 0) {
+ if (curlen != prevlen) s->bl_tree[curlen].fc.freq = (unsigned short)(
+ (int)s->bl_tree[curlen].fc.freq + 1);
+ s->bl_tree[16].fc.freq = (unsigned short)((int)s->bl_tree[16].fc.freq + 1);
+ }
+ else
+ if (count <= 10) s->bl_tree[17].fc.freq = (unsigned short)(
+ (int)s->bl_tree[17].fc.freq + 1);
+ else s->bl_tree[18].fc.freq = (unsigned short)((int)s->bl_tree[18].fc.freq + 1);
+ }
+ 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;
+ }
+ __Cont: n ++;
+ }
+ return;
+}
+
+static void send_tree(deflate_state *s, ct_data *tree, int max_code) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static void send_tree(deflate_state *s, ct_data *tree, int max_code)
+{
+ int n;
+ int curlen;
+ int prevlen = -1;
+ int nextlen = (int)(tree + 0)->dl.len;
+ int count = 0;
+ int max_count = 7;
+ int min_count = 4;
+ if (nextlen == 0) {
+ max_count = 138;
+ min_count = 3;
+ }
+ n = 0;
+ while (n <= max_code) {
+ curlen = nextlen;
+ nextlen = (int)(tree + (n + 1))->dl.len;
+ count ++;
+ ;
+ if (count < max_count) {
+ if (curlen == nextlen) goto __Cont; else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (count < min_count)
+ while (1) {
+ {
+ int len = (int)s->bl_tree[curlen].dl.len;
+ if (s->bi_valid > 16 - len) {
+ int val = (int)s->bl_tree[curlen].fc.code;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val) << s->bi_valid));
+ {
+ ulg tmp;
+ tmp = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_0;
+ tmp_0 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_0) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val) >> (
+ 16 - s->bi_valid));
+ s->bi_valid += len - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)s->bl_tree[curlen].fc.code << s->bi_valid));
+ s->bi_valid += len;
+ }
+ }
+ count --;
+ if (! (count != 0)) break;
+ }
+ else
+ if (curlen != 0) {
+ if (curlen != prevlen) {
+ {
+ int len_0 = (int)s->bl_tree[curlen].dl.len;
+ if (s->bi_valid > 16 - len_0) {
+ int val_0 = (int)s->bl_tree[curlen].fc.code;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val_0) << s->bi_valid));
+ {
+ ulg tmp_1;
+ tmp_1 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_1) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_2;
+ tmp_2 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_2) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val_0) >> (
+ 16 - s->bi_valid));
+ s->bi_valid += len_0 - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)s->bl_tree[curlen].fc.code << s->bi_valid));
+ s->bi_valid += len_0;
+ }
+ }
+ count --;
+ }
+ {
+ int len_1 = (int)s->bl_tree[16].dl.len;
+ if (s->bi_valid > 16 - len_1) {
+ int val_1 = (int)s->bl_tree[16].fc.code;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val_1) << s->bi_valid));
+ {
+ ulg tmp_3;
+ tmp_3 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_3) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_4;
+ tmp_4 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_4) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val_1) >> (
+ 16 - s->bi_valid));
+ s->bi_valid += len_1 - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)s->bl_tree[16].fc.code << s->bi_valid));
+ s->bi_valid += len_1;
+ }
+ }
+ {
+ int len_2 = 2;
+ if (s->bi_valid > 16 - len_2) {
+ int val_2 = count - 3;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val_2) << s->bi_valid));
+ {
+ ulg tmp_5;
+ tmp_5 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_5) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_6;
+ tmp_6 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_6) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val_2) >> (
+ 16 - s->bi_valid));
+ s->bi_valid += len_2 - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)(
+ count - 3)) << s->bi_valid));
+ s->bi_valid += len_2;
+ }
+ }
+ }
+ else
+ if (count <= 10) {
+ {
+ int len_3 = (int)s->bl_tree[17].dl.len;
+ if (s->bi_valid > 16 - len_3) {
+ int val_3 = (int)s->bl_tree[17].fc.code;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val_3) << s->bi_valid));
+ {
+ ulg tmp_7;
+ tmp_7 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_7) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_8;
+ tmp_8 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_8) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val_3) >> (
+ 16 - s->bi_valid));
+ s->bi_valid += len_3 - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)s->bl_tree[17].fc.code << s->bi_valid));
+ s->bi_valid += len_3;
+ }
+ }
+ {
+ int len_4 = 3;
+ if (s->bi_valid > 16 - len_4) {
+ int val_4 = count - 3;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val_4) << s->bi_valid));
+ {
+ ulg tmp_9;
+ tmp_9 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_9) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_10;
+ tmp_10 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_10) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val_4) >> (
+ 16 - s->bi_valid));
+ s->bi_valid += len_4 - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)(
+ count - 3)) << s->bi_valid));
+ s->bi_valid += len_4;
+ }
+ }
+ }
+ else {
+ {
+ int len_5 = (int)s->bl_tree[18].dl.len;
+ if (s->bi_valid > 16 - len_5) {
+ int val_5 = (int)s->bl_tree[18].fc.code;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val_5) << s->bi_valid));
+ {
+ ulg tmp_11;
+ tmp_11 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_11) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_12;
+ tmp_12 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_12) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val_5) >> (
+ 16 - s->bi_valid));
+ s->bi_valid += len_5 - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)s->bl_tree[18].fc.code << s->bi_valid));
+ s->bi_valid += len_5;
+ }
+ }
+ {
+ int len_6 = 7;
+ if (s->bi_valid > 16 - len_6) {
+ int val_6 = count - 11;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val_6) << s->bi_valid));
+ {
+ ulg tmp_13;
+ tmp_13 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_13) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_14;
+ tmp_14 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_14) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val_6) >> (
+ 16 - s->bi_valid));
+ s->bi_valid += len_6 - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)(
+ count - 11)) << s->bi_valid));
+ s->bi_valid += len_6;
+ }
+ }
+ }
+ }
+ 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;
+ }
+ __Cont: n ++;
+ }
+ return;
+}
+
+static int build_bl_tree(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+static int build_bl_tree(deflate_state *s)
+{
+ int max_blindex;
+ scan_tree(s,s->dyn_ltree,s->l_desc.max_code);
+ scan_tree(s,s->dyn_dtree,s->d_desc.max_code);
+ build_tree(s,& s->bl_desc);
+ max_blindex = 19 - 1;
+ while (max_blindex >= 3) {
+ if ((int)s->bl_tree[bl_order[max_blindex]].dl.len != 0) break;
+ max_blindex --;
+ }
+ s->opt_len += (((unsigned long)3 * ((unsigned long)max_blindex + (unsigned long)1) + (unsigned long)5) + (unsigned long)5) + (unsigned long)4;
+ return max_blindex;
+}
+
+static void send_all_trees(deflate_state *s, int lcodes, int dcodes,
+ int blcodes) __attribute__((__FC_OLDSTYLEPROTO__));
+static void send_all_trees(deflate_state *s, int lcodes, int dcodes,
+ int blcodes)
+{
+ int rank;
+ {
+ int len = 5;
+ if (s->bi_valid > 16 - len) {
+ int val = lcodes - 257;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val) << s->bi_valid));
+ {
+ ulg tmp;
+ tmp = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_0;
+ tmp_0 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_0) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val) >> (16 - s->bi_valid));
+ s->bi_valid += len - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)(
+ lcodes - 257)) << s->bi_valid));
+ s->bi_valid += len;
+ }
+ }
+ {
+ int len_0 = 5;
+ if (s->bi_valid > 16 - len_0) {
+ int val_0 = dcodes - 1;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val_0) << s->bi_valid));
+ {
+ ulg tmp_1;
+ tmp_1 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_1) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_2;
+ tmp_2 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_2) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val_0) >> (16 - s->bi_valid));
+ s->bi_valid += len_0 - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)(
+ dcodes - 1)) << s->bi_valid));
+ s->bi_valid += len_0;
+ }
+ }
+ {
+ int len_1 = 4;
+ if (s->bi_valid > 16 - len_1) {
+ int val_1 = blcodes - 4;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val_1) << s->bi_valid));
+ {
+ ulg tmp_3;
+ tmp_3 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_3) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_4;
+ tmp_4 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_4) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val_1) >> (16 - s->bi_valid));
+ s->bi_valid += len_1 - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)(
+ blcodes - 4)) << s->bi_valid));
+ s->bi_valid += len_1;
+ }
+ }
+ rank = 0;
+ while (rank < blcodes) {
+ {
+ int len_2 = 3;
+ if (s->bi_valid > 16 - len_2) {
+ int val_2 = (int)s->bl_tree[bl_order[rank]].dl.len;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val_2) << s->bi_valid));
+ {
+ ulg tmp_5;
+ tmp_5 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_5) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_6;
+ tmp_6 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_6) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val_2) >> (
+ 16 - s->bi_valid));
+ s->bi_valid += len_2 - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)s->bl_tree[bl_order[rank]].dl.len << s->bi_valid));
+ s->bi_valid += len_2;
+ }
+ }
+ rank ++;
+ }
+ send_tree(s,s->dyn_ltree,lcodes - 1);
+ send_tree(s,s->dyn_dtree,dcodes - 1);
+ return;
+}
+
+void _tr_stored_block(deflate_state *s, charf *buf, ulg stored_len, int last) __attribute__((
+__FC_OLDSTYLEPROTO__));
+void _tr_stored_block(deflate_state *s, charf *buf, ulg stored_len, int last)
+{
+ {
+ int len = 3;
+ if (s->bi_valid > 16 - len) {
+ int val = (0 << 1) + last;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val) << s->bi_valid));
+ {
+ ulg tmp;
+ tmp = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_0;
+ tmp_0 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_0) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val) >> (16 - s->bi_valid));
+ s->bi_valid += len - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)(
+ (0 << 1) + last)) << s->bi_valid));
+ s->bi_valid += len;
+ }
+ }
+ bi_windup(s);
+ {
+ ulg tmp_1;
+ tmp_1 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_1) = (unsigned char)((int)((unsigned short)stored_len) & 0xff);
+ }
+ {
+ ulg tmp_2;
+ tmp_2 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_2) = (unsigned char)((int)((unsigned short)stored_len) >> 8);
+ }
+ {
+ ulg tmp_3;
+ tmp_3 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_3) = (unsigned char)((int)((unsigned short)(~ stored_len)) & 0xff);
+ }
+ {
+ ulg tmp_4;
+ tmp_4 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_4) = (unsigned char)((int)((unsigned short)(~ stored_len)) >> 8);
+ }
+ memcpy((void *)(s->pending_buf + s->pending),(void const *)buf,stored_len);
+ s->pending += stored_len;
+ return;
+}
+
+void _tr_flush_bits(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+void _tr_flush_bits(deflate_state *s)
+{
+ bi_flush(s);
+ return;
+}
+
+void _tr_align(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+void _tr_align(deflate_state *s)
+{
+ {
+ int len = 3;
+ if (s->bi_valid > 16 - len) {
+ int val = 1 << 1;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val) << s->bi_valid));
+ {
+ ulg tmp;
+ tmp = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_0;
+ tmp_0 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_0) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val) >> (16 - s->bi_valid));
+ s->bi_valid += len - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)(
+ 1 << 1)) << s->bi_valid));
+ s->bi_valid += len;
+ }
+ }
+ {
+ int len_0 = (int)static_ltree[256].dl.len;
+ if (s->bi_valid > 16 - len_0) {
+ int val_0 = (int)static_ltree[256].fc.code;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val_0) << s->bi_valid));
+ {
+ ulg tmp_1;
+ tmp_1 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_1) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_2;
+ tmp_2 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_2) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val_0) >> (16 - s->bi_valid));
+ s->bi_valid += len_0 - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)static_ltree[256].fc.code << s->bi_valid));
+ s->bi_valid += len_0;
+ }
+ }
+ bi_flush(s);
+ return;
+}
+
+void _tr_flush_block(deflate_state *s, charf *buf, ulg stored_len, int last) __attribute__((
+__FC_OLDSTYLEPROTO__));
+void _tr_flush_block(deflate_state *s, charf *buf, ulg stored_len, int last)
+{
+ ulg opt_lenb;
+ ulg static_lenb;
+ int max_blindex = 0;
+ if (s->level > 0) {
+ if ((s->strm)->data_type == 2) (s->strm)->data_type = detect_data_type
+ (s);
+ build_tree(s,& s->l_desc);
+ build_tree(s,& s->d_desc);
+ max_blindex = build_bl_tree(s);
+ opt_lenb = ((s->opt_len + (ulg)3) + (ulg)7) >> 3;
+ static_lenb = ((s->static_len + (ulg)3) + (ulg)7) >> 3;
+ if (static_lenb <= opt_lenb) opt_lenb = static_lenb;
+ }
+ else {
+ static_lenb = stored_len + (ulg)5;
+ opt_lenb = static_lenb;
+ }
+ if (stored_len + (ulg)4 <= opt_lenb) {
+ if (buf != (char *)0) _tr_stored_block(s,buf,stored_len,last);
+ else goto _LAND;
+ }
+ else {
+ _LAND: ;
+ if (s->strategy == 4) goto _LOR;
+ else
+ if (static_lenb == opt_lenb) {
+ _LOR:
+ {
+ {
+ int len = 3;
+ if (s->bi_valid > 16 - len) {
+ int val = (1 << 1) + last;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val) << s->bi_valid));
+ {
+ ulg tmp;
+ tmp = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_0;
+ tmp_0 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_0) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val) >> (
+ 16 - s->bi_valid));
+ s->bi_valid += len - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)(
+ (1 << 1) + last)) << s->bi_valid));
+ s->bi_valid += len;
+ }
+ }
+ compress_block(s,static_ltree,static_dtree);
+ }
+ }
+ else {
+ {
+ int len_0 = 3;
+ if (s->bi_valid > 16 - len_0) {
+ int val_0 = (2 << 1) + last;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val_0) << s->bi_valid));
+ {
+ ulg tmp_1;
+ tmp_1 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_1) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_2;
+ tmp_2 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_2) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val_0) >> (
+ 16 - s->bi_valid));
+ s->bi_valid += len_0 - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)(
+ (2 << 1) + last)) << s->bi_valid));
+ s->bi_valid += len_0;
+ }
+ }
+ send_all_trees(s,s->l_desc.max_code + 1,s->d_desc.max_code + 1,
+ max_blindex + 1);
+ compress_block(s,(ct_data const *)(s->dyn_ltree),
+ (ct_data const *)(s->dyn_dtree));
+ }
+ }
+ init_block(s);
+ if (last) bi_windup(s);
+ return;
+}
+
+int _tr_tally(deflate_state *s, unsigned int dist, unsigned int lc) __attribute__((
+__FC_OLDSTYLEPROTO__));
+int _tr_tally(deflate_state *s, unsigned int dist, unsigned int lc)
+{
+ int __retres;
+ uInt tmp;
+ *(s->d_buf + s->last_lit) = (unsigned short)dist;
+ tmp = s->last_lit;
+ (s->last_lit) ++;
+ *(s->l_buf + tmp) = (unsigned char)lc;
+ if (dist == (unsigned int)0) s->dyn_ltree[lc].fc.freq = (unsigned short)(
+ (int)s->dyn_ltree[lc].fc.freq + 1);
+ else {
+ int tmp_0;
+ (s->matches) ++;
+ dist --;
+ s->dyn_ltree[((int)_length_code[lc] + 256) + 1].fc.freq = (unsigned short)(
+ (int)s->dyn_ltree[((int)_length_code[lc] + 256) + 1].fc.freq + 1);
+ if (dist < (unsigned int)256) tmp_0 = (int)_dist_code[dist];
+ else tmp_0 = (int)_dist_code[(unsigned int)256 + (dist >> 7)];
+ s->dyn_dtree[tmp_0].fc.freq = (unsigned short)((int)s->dyn_dtree[tmp_0].fc.freq + 1);
+ }
+ __retres = s->last_lit == s->lit_bufsize - (uInt)1;
+ return __retres;
+}
+
+static void compress_block(deflate_state *s, ct_data const *ltree,
+ ct_data const *dtree) __attribute__((__FC_OLDSTYLEPROTO__));
+static void compress_block(deflate_state *s, ct_data const *ltree,
+ ct_data const *dtree)
+{
+ unsigned int dist;
+ int lc;
+ unsigned int code;
+ int extra;
+ unsigned int lx = (unsigned int)0;
+ if (s->last_lit != (uInt)0)
+ while (1) {
+ {
+ unsigned int tmp;
+ dist = (unsigned int)*(s->d_buf + lx);
+ tmp = lx;
+ lx ++;
+ lc = (int)*(s->l_buf + tmp);
+ if (dist == (unsigned int)0) {
+ {
+ int len = (int)(ltree + lc)->dl.len;
+ if (s->bi_valid > 16 - len) {
+ int val = (int)(ltree + lc)->fc.code;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val) << s->bi_valid));
+ {
+ ulg tmp_0;
+ tmp_0 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_0) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_1;
+ tmp_1 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_1) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val) >> (
+ 16 - s->bi_valid));
+ s->bi_valid += len - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)(ltree + lc)->fc.code << s->bi_valid));
+ s->bi_valid += len;
+ }
+ }
+ }
+ else {
+ code = (unsigned int)_length_code[lc];
+ {
+ int len_0 =
+ (int)(ltree + ((code + (unsigned int)256) + (unsigned int)1))->dl.len;
+ if (s->bi_valid > 16 - len_0) {
+ int val_0 =
+ (int)(ltree + ((code + (unsigned int)256) + (unsigned int)1))->fc.code;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val_0) << s->bi_valid));
+ {
+ ulg tmp_2;
+ tmp_2 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_2) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_3;
+ tmp_3 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_3) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val_0) >> (
+ 16 - s->bi_valid));
+ s->bi_valid += len_0 - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)(ltree + (
+ (code + (unsigned int)256) + (unsigned int)1))->fc.code << s->bi_valid));
+ s->bi_valid += len_0;
+ }
+ }
+ extra = extra_lbits[code];
+ if (extra != 0) {
+ lc -= base_length[code];
+ {
+ int len_1 = extra;
+ if (s->bi_valid > 16 - len_1) {
+ int val_1 = lc;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val_1) << s->bi_valid));
+ {
+ ulg tmp_4;
+ tmp_4 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_4) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_5;
+ tmp_5 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_5) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val_1) >> (
+ 16 - s->bi_valid));
+ s->bi_valid += len_1 - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)lc) << s->bi_valid));
+ s->bi_valid += len_1;
+ }
+ }
+ }
+ dist --;
+ if (dist < (unsigned int)256) code = (unsigned int)_dist_code[dist];
+ else code = (unsigned int)_dist_code[(unsigned int)256 + (dist >> 7)];
+ {
+ int len_2 = (int)(dtree + code)->dl.len;
+ if (s->bi_valid > 16 - len_2) {
+ int val_2 = (int)(dtree + code)->fc.code;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val_2) << s->bi_valid));
+ {
+ ulg tmp_6;
+ tmp_6 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_6) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_7;
+ tmp_7 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_7) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val_2) >> (
+ 16 - s->bi_valid));
+ s->bi_valid += len_2 - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)(dtree + code)->fc.code << s->bi_valid));
+ s->bi_valid += len_2;
+ }
+ }
+ extra = extra_dbits[code];
+ if (extra != 0) {
+ dist -= (unsigned int)base_dist[code];
+ {
+ int len_3 = extra;
+ if (s->bi_valid > 16 - len_3) {
+ int val_3 = (int)dist;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val_3) << s->bi_valid));
+ {
+ ulg tmp_8;
+ tmp_8 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_8) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_9;
+ tmp_9 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_9) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val_3) >> (
+ 16 - s->bi_valid));
+ s->bi_valid += len_3 - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)dist) << s->bi_valid));
+ s->bi_valid += len_3;
+ }
+ }
+ }
+ }
+ }
+ if (! (lx < s->last_lit)) break;
+ }
+ {
+ int len_4 = (int)(ltree + 256)->dl.len;
+ if (s->bi_valid > 16 - len_4) {
+ int val_4 = (int)(ltree + 256)->fc.code;
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)((unsigned short)val_4) << s->bi_valid));
+ {
+ ulg tmp_10;
+ tmp_10 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_10) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_11;
+ tmp_11 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_11) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)((int)((unsigned short)val_4) >> (16 - s->bi_valid));
+ s->bi_valid += len_4 - 16;
+ }
+ else {
+ s->bi_buf = (unsigned short)((int)s->bi_buf | ((int)(ltree + 256)->fc.code << s->bi_valid));
+ s->bi_valid += len_4;
+ }
+ }
+ return;
+}
+
+static int detect_data_type(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+static int detect_data_type(deflate_state *s)
+{
+ int __retres;
+ int n;
+ unsigned long black_mask = 0xf3ffc07fUL;
+ n = 0;
+ while (n <= 31) {
+ if (black_mask & (unsigned long)1)
+ if ((int)s->dyn_ltree[n].fc.freq != 0) {
+ __retres = 0;
+ goto return_label;
+ }
+ n ++;
+ black_mask >>= 1;
+ }
+ if ((int)s->dyn_ltree[9].fc.freq != 0) {
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if ((int)s->dyn_ltree[10].fc.freq != 0) {
+ __retres = 1;
+ goto return_label;
+ }
+ else
+ if ((int)s->dyn_ltree[13].fc.freq != 0) {
+ __retres = 1;
+ goto return_label;
+ }
+ n = 32;
+ while (n < 256) {
+ if ((int)s->dyn_ltree[n].fc.freq != 0) {
+ __retres = 1;
+ goto return_label;
+ }
+ n ++;
+ }
+ __retres = 0;
+ return_label: return __retres;
+}
+
+static unsigned int bi_reverse(unsigned int code, int len) __attribute__((
+__FC_OLDSTYLEPROTO__));
+static unsigned int bi_reverse(unsigned int code, int len)
+{
+ unsigned int __retres;
+ register unsigned int res = (unsigned int)0;
+ while (1) {
+ res |= code & (unsigned int)1;
+ code >>= 1;
+ res <<= 1;
+ len --;
+ if (! (len > 0)) break;
+ }
+ __retres = res >> 1;
+ return __retres;
+}
+
+static void bi_flush(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+static void bi_flush(deflate_state *s)
+{
+ if (s->bi_valid == 16) {
+ {
+ ulg tmp;
+ tmp = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_0;
+ tmp_0 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_0) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ s->bi_buf = (unsigned short)0;
+ s->bi_valid = 0;
+ }
+ else
+ if (s->bi_valid >= 8) {
+ {
+ ulg tmp_1;
+ tmp_1 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_1) = (unsigned char)s->bi_buf;
+ }
+ s->bi_buf = (unsigned short)((int)s->bi_buf >> 8);
+ s->bi_valid -= 8;
+ }
+ return;
+}
+
+static void bi_windup(deflate_state *s) __attribute__((__FC_OLDSTYLEPROTO__));
+static void bi_windup(deflate_state *s)
+{
+ if (s->bi_valid > 8) {
+ {
+ ulg tmp;
+ tmp = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp) = (unsigned char)((int)s->bi_buf & 0xff);
+ }
+ {
+ ulg tmp_0;
+ tmp_0 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_0) = (unsigned char)((int)s->bi_buf >> 8);
+ }
+ }
+ else
+ if (s->bi_valid > 0) {
+ {
+ ulg tmp_1;
+ tmp_1 = s->pending;
+ (s->pending) ++;
+ *(s->pending_buf + tmp_1) = (unsigned char)s->bi_buf;
+ }
+ }
+ s->bi_buf = (unsigned short)0;
+ s->bi_valid = 0;
+ return;
+}
+
+int uncompress2(Bytef *dest, uLongf *destLen, Bytef const *source,
+ uLong *sourceLen) __attribute__((__FC_OLDSTYLEPROTO__));
+int uncompress2(Bytef *dest, uLongf *destLen, Bytef const *source,
+ uLong *sourceLen)
+{
+ int __retres;
+ z_stream stream;
+ int err;
+ uLong len;
+ uLong left;
+ Byte buf[1];
+ int tmp_1;
+ uInt const max = (unsigned int)(-1);
+ len = *sourceLen;
+ if (*destLen) {
+ left = *destLen;
+ *destLen = (unsigned long)0;
+ }
+ else {
+ left = (unsigned long)1;
+ dest = buf;
+ }
+ stream.next_in = (Bytef *)source;
+ stream.avail_in = (unsigned int)0;
+ stream.zalloc = (voidpf (*)(voidpf opaque, uInt items, uInt size))0;
+ stream.zfree = (void (*)(voidpf opaque, voidpf address))0;
+ stream.opaque = (void *)0;
+ err = inflateInit_(& stream,"1.2.11",(int)sizeof(z_stream));
+ if (err != 0) {
+ __retres = err;
+ goto return_label;
+ }
+ stream.next_out = dest;
+ stream.avail_out = (unsigned int)0;
+ while (1) {
+ if (stream.avail_out == (uInt)0) {
+ if (left > (unsigned long)max) stream.avail_out = max;
+ else stream.avail_out = (unsigned int)left;
+ left -= (uLong)stream.avail_out;
+ }
+ if (stream.avail_in == (uInt)0) {
+ if (len > (unsigned long)max) stream.avail_in = max;
+ else stream.avail_in = (unsigned int)len;
+ len -= (uLong)stream.avail_in;
+ }
+ err = inflate(& stream,0);
+ if (! (err == 0)) break;
+ }
+ *sourceLen -= len + (uLong)stream.avail_in;
+ if (dest != buf) *destLen = stream.total_out;
+ else
+ if (stream.total_out)
+ if (err == -5) left = (unsigned long)1;
+ inflateEnd(& stream);
+ if (err == 1) tmp_1 = 0;
+ else {
+ int tmp_0;
+ if (err == 2) tmp_0 = -3;
+ else {
+ int tmp;
+ if (err == -5)
+ if (left + (uLong)stream.avail_out) tmp = -3; else tmp = err;
+ else tmp = err;
+ tmp_0 = tmp;
+ }
+ tmp_1 = tmp_0;
+ }
+ __retres = tmp_1;
+ return_label: return __retres;
+}
+
+int uncompress(Bytef *dest, uLongf *destLen, Bytef const *source,
+ uLong sourceLen) __attribute__((__FC_OLDSTYLEPROTO__));
+int uncompress(Bytef *dest, uLongf *destLen, Bytef const *source,
+ uLong sourceLen)
+{
+ int tmp;
+ tmp = uncompress2(dest,destLen,source,& sourceLen);
+ return tmp;
+}
+
+char * const z_errmsg[10] =
+ {(char *)"need dictionary",
+ (char *)"stream end",
+ (char *)"",
+ (char *)"file error",
+ (char *)"stream error",
+ (char *)"data error",
+ (char *)"insufficient memory",
+ (char *)"buffer error",
+ (char *)"incompatible version",
+ (char *)""};
+char const *zlibVersion(void)
+{
+ char const *__retres;
+ __retres = "1.2.11";
+ return __retres;
+}
+
+uLong zlibCompileFlags(void)
+{
+ uLong flags;
+ flags = (unsigned long)0;
+ switch ((int)sizeof(uInt)) {
+ case 2: break;
+ case 4: flags += (uLong)1;
+ break;
+ case 8: flags += (uLong)2;
+ break;
+ default: flags += (uLong)3;
+ }
+ switch ((int)sizeof(uLong)) {
+ case 2: break;
+ case 4: flags += (uLong)(1 << 2);
+ break;
+ case 8: flags += (uLong)(2 << 2);
+ break;
+ default: flags += (uLong)(3 << 2);
+ }
+ switch ((int)sizeof(voidpf)) {
+ case 2: break;
+ case 4: flags += (uLong)(1 << 4);
+ break;
+ case 8: flags += (uLong)(2 << 4);
+ break;
+ default: flags += (uLong)(3 << 4);
+ }
+ switch ((int)sizeof(long)) {
+ case 2: break;
+ case 4: flags += (uLong)(1 << 6);
+ break;
+ case 8: flags += (uLong)(2 << 6);
+ break;
+ default: flags += (uLong)(3 << 6);
+ }
+ return flags;
+}
+
+char const *zError(int err) __attribute__((__FC_OLDSTYLEPROTO__));
+char const *zError(int err)
+{
+ char const *__retres;
+ __retres = (char const *)z_errmsg[2 - err];
+ return __retres;
+}
+
+voidpf zcalloc(voidpf opaque, unsigned int items, unsigned int size) __attribute__((
+__FC_OLDSTYLEPROTO__));
+voidpf zcalloc(voidpf opaque, unsigned int items, unsigned int size)
+{
+ void *tmp_1;
+ if (sizeof(uInt) > (unsigned long)2) tmp_1 = malloc((unsigned long)(
+ items * size));
+ else tmp_1 = calloc((unsigned long)items,(unsigned long)size);
+ return tmp_1;
+}
+
+void zcfree(voidpf opaque, voidpf ptr) __attribute__((__FC_OLDSTYLEPROTO__));
+void zcfree(voidpf opaque, voidpf ptr)
+{
+ free(ptr);
+ return;
+}
+
+
diff --git a/zlib/.frama-c/zlib-example.parse/metrics.log b/zlib/.frama-c/zlib-example.parse/metrics.log
new file mode 100644
index 000000000..9e047552d
--- /dev/null
+++ b/zlib/.frama-c/zlib-example.parse/metrics.log
@@ -0,0 +1,96 @@
+[metrics] Defined functions (159)
+=======================
+ _tr_align (1 call); _tr_flush_bits (2 calls); _tr_flush_block (13 calls);
+ _tr_init (1 call); _tr_stored_block (4 calls); _tr_tally (0 call);
+ adler32 (10 calls); adler32_combine (0 call); adler32_combine64 (0 call);
+ adler32_combine_ (2 calls); adler32_z (1 call); bi_flush (2 calls);
+ bi_reverse (1 call); bi_windup (2 calls); build_bl_tree (1 call);
+ build_tree (3 calls); compress (1 call); compress2 (1 call);
+ compressBound (0 call); compress_block (2 calls); crc32 (23 calls);
+ crc32_big (1 call); crc32_combine (0 call); crc32_combine64 (0 call);
+ crc32_combine_ (2 calls); crc32_little (1 call); crc32_z (1 call);
+ deflate (12 calls); deflateBound (0 call); deflateCopy (0 call);
+ deflateEnd (8 calls); deflateGetDictionary (0 call);
+ deflateInit2_ (2 calls); deflateInit_ (5 calls); deflateParams (3 calls);
+ deflatePending (0 call); deflatePrime (0 call); deflateReset (2 calls);
+ deflateResetKeep (1 call); deflateSetDictionary (1 call);
+ deflateSetHeader (0 call); deflateStateCheck (12 calls);
+ deflateTune (0 call); deflate_fast (address taken) (0 call);
+ deflate_huff (1 call); deflate_rle (1 call);
+ deflate_slow (address taken) (0 call);
+ deflate_stored (address taken) (1 call); detect_data_type (1 call);
+ fill_window (6 calls); fixedtables (1 call); fixedtables_0 (1 call);
+ flush_pending (25 calls); gen_bitlen (1 call); gen_codes (1 call);
+ get_crc_table (0 call); gf2_matrix_square (4 calls);
+ gf2_matrix_times (3 calls); gz_avail (2 calls); gz_comp (9 calls);
+ gz_decomp (2 calls); gz_error (23 calls); gz_fetch (3 calls);
+ gz_init (3 calls); gz_load (3 calls); gz_look (2 calls); gz_open (3 calls);
+ gz_read (3 calls); gz_reset (2 calls); gz_skip (3 calls);
+ gz_write (4 calls); gz_zero (6 calls); gzbuffer (0 call);
+ gzclearerr (0 call); gzclose (2 calls); gzclose_r (1 call);
+ gzclose_w (1 call); gzdirect (0 call); gzdopen (0 call); gzeof (0 call);
+ gzerror (4 calls); gzflush (0 call); gzfread (0 call); gzfwrite (0 call);
+ gzgetc (2 calls); gzgetc_ (0 call); gzgets (1 call); gzoffset (0 call);
+ gzoffset64 (1 call); gzopen (2 calls); gzopen64 (0 call); gzprintf (1 call);
+ gzputc (1 call); gzputs (1 call); gzread (1 call); gzrewind (1 call);
+ gzseek (2 calls); gzseek64 (1 call); gzsetparams (0 call); gztell (2 calls);
+ gztell64 (1 call); gzungetc (1 call); gzvprintf (1 call); gzwrite (0 call);
+ inflate (7 calls); inflateBack (0 call); inflateBackEnd (0 call);
+ inflateBackInit_ (0 call); inflateCodesUsed (0 call); inflateCopy (0 call);
+ inflateEnd (6 calls); inflateGetDictionary (0 call);
+ inflateGetHeader (0 call); inflateInit2_ (2 calls); inflateInit_ (5 calls);
+ inflateMark (0 call); inflatePrime (0 call); inflateReset (3 calls);
+ inflateReset2 (1 call); inflateResetKeep (1 call);
+ inflateSetDictionary (1 call); inflateStateCheck (16 calls);
+ inflateSync (1 call); inflateSyncPoint (0 call); inflateUndermine (0 call);
+ inflateValidate (0 call); inflate_fast (2 calls); inflate_table (6 calls);
+ init_block (2 calls); lm_init (1 call); longest_match (2 calls);
+ main (0 call); pqdownheap (3 calls); putShortMSB (5 calls);
+ read_buf (3 calls); scan_tree (2 calls); send_all_trees (1 call);
+ send_tree (2 calls); slide_hash (2 calls); syncsearch (2 calls);
+ test_compress (1 call); test_deflate (1 call); test_dict_deflate (1 call);
+ test_dict_inflate (1 call); test_flush (1 call); test_gzio (1 call);
+ test_inflate (1 call); test_large_deflate (1 call);
+ test_large_inflate (1 call); test_sync (1 call); tr_static_init (1 call);
+ uncompress (1 call); uncompress2 (1 call); updatewindow (2 calls);
+ zError (0 call); zcalloc (address taken) (0 call);
+ zcfree (address taken) (0 call); zlibCompileFlags (1 call);
+ zlibVersion (2 calls);
+
+Specified-only functions (0)
+============================
+
+
+Undefined and unspecified functions (0)
+=======================================
+
+
+'Extern' global variables (0)
+=============================
+
+
+Potential entry points (41)
+===========================
+ _tr_tally; adler32_combine; adler32_combine64; compressBound; crc32_combine;
+ crc32_combine64; deflateBound; deflateCopy; deflateGetDictionary;
+ deflatePending; deflatePrime; deflateSetHeader; deflateTune; get_crc_table;
+ gzbuffer; gzclearerr; gzdirect; gzdopen; gzeof; gzflush; gzfread; gzfwrite;
+ gzgetc_; gzoffset; gzopen64; gzsetparams; gzwrite; inflateBack;
+ inflateBackEnd; inflateBackInit_; inflateCodesUsed; inflateCopy;
+ inflateGetDictionary; inflateGetHeader; inflateMark; inflatePrime;
+ inflateSyncPoint; inflateUndermine; inflateValidate; main; zError;
+
+Global metrics
+==============
+Sloc = 8092
+Decision point = 1491
+Global variables = 35
+If = 1413
+Loop = 161
+Goto = 454
+Assignment = 3857
+Exit point = 159
+Function = 159
+Function call = 639
+Pointer dereferencing = 4157
+Cyclomatic complexity = 1650
diff --git a/zlib/.frama-c/zlib-example.parse/warnings.log b/zlib/.frama-c/zlib-example.parse/warnings.log
new file mode 100644
index 000000000..ef5c066a2
--- /dev/null
+++ b/zlib/.frama-c/zlib-example.parse/warnings.log
@@ -0,0 +1 @@
+test/example.c:365:[variadic] warning: Incorrect type for argument 3. The argument will be cast from uLong to long.
diff --git a/zlib/CMakeLists.txt b/zlib/CMakeLists.txt
new file mode 100644
index 000000000..0fe939df6
--- /dev/null
+++ b/zlib/CMakeLists.txt
@@ -0,0 +1,249 @@
+cmake_minimum_required(VERSION 2.4.4)
+set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS ON)
+
+project(zlib C)
+
+set(VERSION "1.2.11")
+
+option(ASM686 "Enable building i686 assembly implementation")
+option(AMD64 "Enable building amd64 assembly implementation")
+
+set(INSTALL_BIN_DIR "${CMAKE_INSTALL_PREFIX}/bin" CACHE PATH "Installation directory for executables")
+set(INSTALL_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib" CACHE PATH "Installation directory for libraries")
+set(INSTALL_INC_DIR "${CMAKE_INSTALL_PREFIX}/include" CACHE PATH "Installation directory for headers")
+set(INSTALL_MAN_DIR "${CMAKE_INSTALL_PREFIX}/share/man" CACHE PATH "Installation directory for manual pages")
+set(INSTALL_PKGCONFIG_DIR "${CMAKE_INSTALL_PREFIX}/share/pkgconfig" CACHE PATH "Installation directory for pkgconfig (.pc) files")
+
+include(CheckTypeSize)
+include(CheckFunctionExists)
+include(CheckIncludeFile)
+include(CheckCSourceCompiles)
+enable_testing()
+
+check_include_file(sys/types.h HAVE_SYS_TYPES_H)
+check_include_file(stdint.h HAVE_STDINT_H)
+check_include_file(stddef.h HAVE_STDDEF_H)
+
+#
+# Check to see if we have large file support
+#
+set(CMAKE_REQUIRED_DEFINITIONS -D_LARGEFILE64_SOURCE=1)
+# We add these other definitions here because CheckTypeSize.cmake
+# in CMake 2.4.x does not automatically do so and we want
+# compatibility with CMake 2.4.x.
+if(HAVE_SYS_TYPES_H)
+ list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_SYS_TYPES_H)
+endif()
+if(HAVE_STDINT_H)
+ list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDINT_H)
+endif()
+if(HAVE_STDDEF_H)
+ list(APPEND CMAKE_REQUIRED_DEFINITIONS -DHAVE_STDDEF_H)
+endif()
+check_type_size(off64_t OFF64_T)
+if(HAVE_OFF64_T)
+ add_definitions(-D_LARGEFILE64_SOURCE=1)
+endif()
+set(CMAKE_REQUIRED_DEFINITIONS) # clear variable
+
+#
+# Check for fseeko
+#
+check_function_exists(fseeko HAVE_FSEEKO)
+if(NOT HAVE_FSEEKO)
+ add_definitions(-DNO_FSEEKO)
+endif()
+
+#
+# Check for unistd.h
+#
+check_include_file(unistd.h Z_HAVE_UNISTD_H)
+
+if(MSVC)
+ set(CMAKE_DEBUG_POSTFIX "d")
+ add_definitions(-D_CRT_SECURE_NO_DEPRECATE)
+ add_definitions(-D_CRT_NONSTDC_NO_DEPRECATE)
+ include_directories(${CMAKE_CURRENT_SOURCE_DIR})
+endif()
+
+if(NOT CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR)
+ # If we're doing an out of source build and the user has a zconf.h
+ # in their source tree...
+ if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h)
+ message(STATUS "Renaming")
+ message(STATUS " ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h")
+ message(STATUS "to 'zconf.h.included' because this file is included with zlib")
+ message(STATUS "but CMake generates it automatically in the build directory.")
+ file(RENAME ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h.included)
+ endif()
+endif()
+
+set(ZLIB_PC ${CMAKE_CURRENT_BINARY_DIR}/zlib.pc)
+configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/zlib.pc.cmakein
+ ${ZLIB_PC} @ONLY)
+configure_file( ${CMAKE_CURRENT_SOURCE_DIR}/zconf.h.cmakein
+ ${CMAKE_CURRENT_BINARY_DIR}/zconf.h @ONLY)
+include_directories(${CMAKE_CURRENT_BINARY_DIR} ${CMAKE_SOURCE_DIR})
+
+
+#============================================================================
+# zlib
+#============================================================================
+
+set(ZLIB_PUBLIC_HDRS
+ ${CMAKE_CURRENT_BINARY_DIR}/zconf.h
+ zlib.h
+)
+set(ZLIB_PRIVATE_HDRS
+ crc32.h
+ deflate.h
+ gzguts.h
+ inffast.h
+ inffixed.h
+ inflate.h
+ inftrees.h
+ trees.h
+ zutil.h
+)
+set(ZLIB_SRCS
+ adler32.c
+ compress.c
+ crc32.c
+ deflate.c
+ gzclose.c
+ gzlib.c
+ gzread.c
+ gzwrite.c
+ inflate.c
+ infback.c
+ inftrees.c
+ inffast.c
+ trees.c
+ uncompr.c
+ zutil.c
+)
+
+if(NOT MINGW)
+ set(ZLIB_DLL_SRCS
+ win32/zlib1.rc # If present will override custom build rule below.
+ )
+endif()
+
+if(CMAKE_COMPILER_IS_GNUCC)
+ if(ASM686)
+ set(ZLIB_ASMS contrib/asm686/match.S)
+ elseif (AMD64)
+ set(ZLIB_ASMS contrib/amd64/amd64-match.S)
+ endif ()
+
+ if(ZLIB_ASMS)
+ add_definitions(-DASMV)
+ set_source_files_properties(${ZLIB_ASMS} PROPERTIES LANGUAGE C COMPILE_FLAGS -DNO_UNDERLINE)
+ endif()
+endif()
+
+if(MSVC)
+ if(ASM686)
+ ENABLE_LANGUAGE(ASM_MASM)
+ set(ZLIB_ASMS
+ contrib/masmx86/inffas32.asm
+ contrib/masmx86/match686.asm
+ )
+ elseif (AMD64)
+ ENABLE_LANGUAGE(ASM_MASM)
+ set(ZLIB_ASMS
+ contrib/masmx64/gvmat64.asm
+ contrib/masmx64/inffasx64.asm
+ )
+ endif()
+
+ if(ZLIB_ASMS)
+ add_definitions(-DASMV -DASMINF)
+ endif()
+endif()
+
+# parse the full version number from zlib.h and include in ZLIB_FULL_VERSION
+file(READ ${CMAKE_CURRENT_SOURCE_DIR}/zlib.h _zlib_h_contents)
+string(REGEX REPLACE ".*#define[ \t]+ZLIB_VERSION[ \t]+\"([-0-9A-Za-z.]+)\".*"
+ "\\1" ZLIB_FULL_VERSION ${_zlib_h_contents})
+
+if(MINGW)
+ # This gets us DLL resource information when compiling on MinGW.
+ if(NOT CMAKE_RC_COMPILER)
+ set(CMAKE_RC_COMPILER windres.exe)
+ endif()
+
+ add_custom_command(OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj
+ COMMAND ${CMAKE_RC_COMPILER}
+ -D GCC_WINDRES
+ -I ${CMAKE_CURRENT_SOURCE_DIR}
+ -I ${CMAKE_CURRENT_BINARY_DIR}
+ -o ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj
+ -i ${CMAKE_CURRENT_SOURCE_DIR}/win32/zlib1.rc)
+ set(ZLIB_DLL_SRCS ${CMAKE_CURRENT_BINARY_DIR}/zlib1rc.obj)
+endif(MINGW)
+
+add_library(zlib SHARED ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_DLL_SRCS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
+add_library(zlibstatic STATIC ${ZLIB_SRCS} ${ZLIB_ASMS} ${ZLIB_PUBLIC_HDRS} ${ZLIB_PRIVATE_HDRS})
+set_target_properties(zlib PROPERTIES DEFINE_SYMBOL ZLIB_DLL)
+set_target_properties(zlib PROPERTIES SOVERSION 1)
+
+if(NOT CYGWIN)
+ # This property causes shared libraries on Linux to have the full version
+ # encoded into their final filename. We disable this on Cygwin because
+ # it causes cygz-${ZLIB_FULL_VERSION}.dll to be created when cygz.dll
+ # seems to be the default.
+ #
+ # This has no effect with MSVC, on that platform the version info for
+ # the DLL comes from the resource file win32/zlib1.rc
+ set_target_properties(zlib PROPERTIES VERSION ${ZLIB_FULL_VERSION})
+endif()
+
+if(UNIX)
+ # On unix-like platforms the library is almost always called libz
+ set_target_properties(zlib zlibstatic PROPERTIES OUTPUT_NAME z)
+ if(NOT APPLE)
+ set_target_properties(zlib PROPERTIES LINK_FLAGS "-Wl,--version-script,\"${CMAKE_CURRENT_SOURCE_DIR}/zlib.map\"")
+ endif()
+elseif(BUILD_SHARED_LIBS AND WIN32)
+ # Creates zlib1.dll when building shared library version
+ set_target_properties(zlib PROPERTIES SUFFIX "1.dll")
+endif()
+
+if(NOT SKIP_INSTALL_LIBRARIES AND NOT SKIP_INSTALL_ALL )
+ install(TARGETS zlib zlibstatic
+ RUNTIME DESTINATION "${INSTALL_BIN_DIR}"
+ ARCHIVE DESTINATION "${INSTALL_LIB_DIR}"
+ LIBRARY DESTINATION "${INSTALL_LIB_DIR}" )
+endif()
+if(NOT SKIP_INSTALL_HEADERS AND NOT SKIP_INSTALL_ALL )
+ install(FILES ${ZLIB_PUBLIC_HDRS} DESTINATION "${INSTALL_INC_DIR}")
+endif()
+if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
+ install(FILES zlib.3 DESTINATION "${INSTALL_MAN_DIR}/man3")
+endif()
+if(NOT SKIP_INSTALL_FILES AND NOT SKIP_INSTALL_ALL )
+ install(FILES ${ZLIB_PC} DESTINATION "${INSTALL_PKGCONFIG_DIR}")
+endif()
+
+#============================================================================
+# Example binaries
+#============================================================================
+
+add_executable(example test/example.c)
+target_link_libraries(example zlib)
+add_test(example example)
+
+add_executable(minigzip test/minigzip.c)
+target_link_libraries(minigzip zlib)
+
+if(HAVE_OFF64_T)
+ add_executable(example64 test/example.c)
+ target_link_libraries(example64 zlib)
+ set_target_properties(example64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64")
+ add_test(example64 example64)
+
+ add_executable(minigzip64 test/minigzip.c)
+ target_link_libraries(minigzip64 zlib)
+ set_target_properties(minigzip64 PROPERTIES COMPILE_FLAGS "-D_FILE_OFFSET_BITS=64")
+endif()
diff --git a/zlib/ChangeLog b/zlib/ChangeLog
new file mode 100644
index 000000000..30199a65a
--- /dev/null
+++ b/zlib/ChangeLog
@@ -0,0 +1,1515 @@
+
+ ChangeLog file for zlib
+
+Changes in 1.2.11 (15 Jan 2017)
+- Fix deflate stored bug when pulling last block from window
+- Permit immediate deflateParams changes before any deflate input
+
+Changes in 1.2.10 (2 Jan 2017)
+- Avoid warnings on snprintf() return value
+- Fix bug in deflate_stored() for zero-length input
+- Fix bug in gzwrite.c that produced corrupt gzip files
+- Remove files to be installed before copying them in Makefile.in
+- Add warnings when compiling with assembler code
+
+Changes in 1.2.9 (31 Dec 2016)
+- Fix contrib/minizip to permit unzipping with desktop API [Zouzou]
+- Improve contrib/blast to return unused bytes
+- Assure that gzoffset() is correct when appending
+- Improve compress() and uncompress() to support large lengths
+- Fix bug in test/example.c where error code not saved
+- Remedy Coverity warning [Randers-Pehrson]
+- Improve speed of gzprintf() in transparent mode
+- Fix inflateInit2() bug when windowBits is 16 or 32
+- Change DEBUG macro to ZLIB_DEBUG
+- Avoid uninitialized access by gzclose_w()
+- Allow building zlib outside of the source directory
+- Fix bug that accepted invalid zlib header when windowBits is zero
+- Fix gzseek() problem on MinGW due to buggy _lseeki64 there
+- Loop on write() calls in gzwrite.c in case of non-blocking I/O
+- Add --warn (-w) option to ./configure for more compiler warnings
+- Reject a window size of 256 bytes if not using the zlib wrapper
+- Fix bug when level 0 used with Z_HUFFMAN or Z_RLE
+- Add --debug (-d) option to ./configure to define ZLIB_DEBUG
+- Fix bugs in creating a very large gzip header
+- Add uncompress2() function, which returns the input size used
+- Assure that deflateParams() will not switch functions mid-block
+- Dramatically speed up deflation for level 0 (storing)
+- Add gzfread(), duplicating the interface of fread()
+- Add gzfwrite(), duplicating the interface of fwrite()
+- Add deflateGetDictionary() function
+- Use snprintf() for later versions of Microsoft C
+- Fix *Init macros to use z_ prefix when requested
+- Replace as400 with os400 for OS/400 support [Monnerat]
+- Add crc32_z() and adler32_z() functions with size_t lengths
+- Update Visual Studio project files [AraHaan]
+
+Changes in 1.2.8 (28 Apr 2013)
+- Update contrib/minizip/iowin32.c for Windows RT [Vollant]
+- Do not force Z_CONST for C++
+- Clean up contrib/vstudio [Roß]
+- Correct spelling error in zlib.h
+- Fix mixed line endings in contrib/vstudio
+
+Changes in 1.2.7.3 (13 Apr 2013)
+- Fix version numbers and DLL names in contrib/vstudio/*/zlib.rc
+
+Changes in 1.2.7.2 (13 Apr 2013)
+- Change check for a four-byte type back to hexadecimal
+- Fix typo in win32/Makefile.msc
+- Add casts in gzwrite.c for pointer differences
+
+Changes in 1.2.7.1 (24 Mar 2013)
+- Replace use of unsafe string functions with snprintf if available
+- Avoid including stddef.h on Windows for Z_SOLO compile [Niessink]
+- Fix gzgetc undefine when Z_PREFIX set [Turk]
+- Eliminate use of mktemp in Makefile (not always available)
+- Fix bug in 'F' mode for gzopen()
+- Add inflateGetDictionary() function
+- Correct comment in deflate.h
+- Use _snprintf for snprintf in Microsoft C
+- On Darwin, only use /usr/bin/libtool if libtool is not Apple
+- Delete "--version" file if created by "ar --version" [Richard G.]
+- Fix configure check for veracity of compiler error return codes
+- Fix CMake compilation of static lib for MSVC2010 x64
+- Remove unused variable in infback9.c
+- Fix argument checks in gzlog_compress() and gzlog_write()
+- Clean up the usage of z_const and respect const usage within zlib
+- Clean up examples/gzlog.[ch] comparisons of different types
+- Avoid shift equal to bits in type (caused endless loop)
+- Fix uninitialized value bug in gzputc() introduced by const patches
+- Fix memory allocation error in examples/zran.c [Nor]
+- Fix bug where gzopen(), gzclose() would write an empty file
+- Fix bug in gzclose() when gzwrite() runs out of memory
+- Check for input buffer malloc failure in examples/gzappend.c
+- Add note to contrib/blast to use binary mode in stdio
+- Fix comparisons of differently signed integers in contrib/blast
+- Check for invalid code length codes in contrib/puff
+- Fix serious but very rare decompression bug in inftrees.c
+- Update inflateBack() comments, since inflate() can be faster
+- Use underscored I/O function names for WINAPI_FAMILY
+- Add _tr_flush_bits to the external symbols prefixed by --zprefix
+- Add contrib/vstudio/vc10 pre-build step for static only
+- Quote --version-script argument in CMakeLists.txt
+- Don't specify --version-script on Apple platforms in CMakeLists.txt
+- Fix casting error in contrib/testzlib/testzlib.c
+- Fix types in contrib/minizip to match result of get_crc_table()
+- Simplify contrib/vstudio/vc10 with 'd' suffix
+- Add TOP support to win32/Makefile.msc
+- Suport i686 and amd64 assembler builds in CMakeLists.txt
+- Fix typos in the use of _LARGEFILE64_SOURCE in zconf.h
+- Add vc11 and vc12 build files to contrib/vstudio
+- Add gzvprintf() as an undocumented function in zlib
+- Fix configure for Sun shell
+- Remove runtime check in configure for four-byte integer type
+- Add casts and consts to ease user conversion to C++
+- Add man pages for minizip and miniunzip
+- In Makefile uninstall, don't rm if preceding cd fails
+- Do not return Z_BUF_ERROR if deflateParam() has nothing to write
+
+Changes in 1.2.7 (2 May 2012)
+- Replace use of memmove() with a simple copy for portability
+- Test for existence of strerror
+- Restore gzgetc_ for backward compatibility with 1.2.6
+- Fix build with non-GNU make on Solaris
+- Require gcc 4.0 or later on Mac OS X to use the hidden attribute
+- Include unistd.h for Watcom C
+- Use __WATCOMC__ instead of __WATCOM__
+- Do not use the visibility attribute if NO_VIZ defined
+- Improve the detection of no hidden visibility attribute
+- Avoid using __int64 for gcc or solo compilation
+- Cast to char * in gzprintf to avoid warnings [Zinser]
+- Fix make_vms.com for VAX [Zinser]
+- Don't use library or built-in byte swaps
+- Simplify test and use of gcc hidden attribute
+- Fix bug in gzclose_w() when gzwrite() fails to allocate memory
+- Add "x" (O_EXCL) and "e" (O_CLOEXEC) modes support to gzopen()
+- Fix bug in test/minigzip.c for configure --solo
+- Fix contrib/vstudio project link errors [Mohanathas]
+- Add ability to choose the builder in make_vms.com [Schweda]
+- Add DESTDIR support to mingw32 win32/Makefile.gcc
+- Fix comments in win32/Makefile.gcc for proper usage
+- Allow overriding the default install locations for cmake
+- Generate and install the pkg-config file with cmake
+- Build both a static and a shared version of zlib with cmake
+- Include version symbols for cmake builds
+- If using cmake with MSVC, add the source directory to the includes
+- Remove unneeded EXTRA_CFLAGS from win32/Makefile.gcc [Truta]
+- Move obsolete emx makefile to old [Truta]
+- Allow the use of -Wundef when compiling or using zlib
+- Avoid the use of the -u option with mktemp
+- Improve inflate() documentation on the use of Z_FINISH
+- Recognize clang as gcc
+- Add gzopen_w() in Windows for wide character path names
+- Rename zconf.h in CMakeLists.txt to move it out of the way
+- Add source directory in CMakeLists.txt for building examples
+- Look in build directory for zlib.pc in CMakeLists.txt
+- Remove gzflags from zlibvc.def in vc9 and vc10
+- Fix contrib/minizip compilation in the MinGW environment
+- Update ./configure for Solaris, support --64 [Mooney]
+- Remove -R. from Solaris shared build (possible security issue)
+- Avoid race condition for parallel make (-j) running example
+- Fix type mismatch between get_crc_table() and crc_table
+- Fix parsing of version with "-" in CMakeLists.txt [Snider, Ziegler]
+- Fix the path to zlib.map in CMakeLists.txt
+- Force the native libtool in Mac OS X to avoid GNU libtool [Beebe]
+- Add instructions to win32/Makefile.gcc for shared install [Torri]
+
+Changes in 1.2.6.1 (12 Feb 2012)
+- Avoid the use of the Objective-C reserved name "id"
+- Include io.h in gzguts.h for Microsoft compilers
+- Fix problem with ./configure --prefix and gzgetc macro
+- Include gz_header definition when compiling zlib solo
+- Put gzflags() functionality back in zutil.c
+- Avoid library header include in crc32.c for Z_SOLO
+- Use name in GCC_CLASSIC as C compiler for coverage testing, if set
+- Minor cleanup in contrib/minizip/zip.c [Vollant]
+- Update make_vms.com [Zinser]
+- Remove unnecessary gzgetc_ function
+- Use optimized byte swap operations for Microsoft and GNU [Snyder]
+- Fix minor typo in zlib.h comments [Rzesniowiecki]
+
+Changes in 1.2.6 (29 Jan 2012)
+- Update the Pascal interface in contrib/pascal
+- Fix function numbers for gzgetc_ in zlibvc.def files
+- Fix configure.ac for contrib/minizip [Schiffer]
+- Fix large-entry detection in minizip on 64-bit systems [Schiffer]
+- Have ./configure use the compiler return code for error indication
+- Fix CMakeLists.txt for cross compilation [McClure]
+- Fix contrib/minizip/zip.c for 64-bit architectures [Dalsnes]
+- Fix compilation of contrib/minizip on FreeBSD [Marquez]
+- Correct suggested usages in win32/Makefile.msc [Shachar, Horvath]
+- Include io.h for Turbo C / Borland C on all platforms [Truta]
+- Make version explicit in contrib/minizip/configure.ac [Bosmans]
+- Avoid warning for no encryption in contrib/minizip/zip.c [Vollant]
+- Minor cleanup up contrib/minizip/unzip.c [Vollant]
+- Fix bug when compiling minizip with C++ [Vollant]
+- Protect for long name and extra fields in contrib/minizip [Vollant]
+- Avoid some warnings in contrib/minizip [Vollant]
+- Add -I../.. -L../.. to CFLAGS for minizip and miniunzip
+- Add missing libs to minizip linker command
+- Add support for VPATH builds in contrib/minizip
+- Add an --enable-demos option to contrib/minizip/configure
+- Add the generation of configure.log by ./configure
+- Exit when required parameters not provided to win32/Makefile.gcc
+- Have gzputc return the character written instead of the argument
+- Use the -m option on ldconfig for BSD systems [Tobias]
+- Correct in zlib.map when deflateResetKeep was added
+
+Changes in 1.2.5.3 (15 Jan 2012)
+- Restore gzgetc function for binary compatibility
+- Do not use _lseeki64 under Borland C++ [Truta]
+- Update win32/Makefile.msc to build test/*.c [Truta]
+- Remove old/visualc6 given CMakefile and other alternatives
+- Update AS400 build files and documentation [Monnerat]
+- Update win32/Makefile.gcc to build test/*.c [Truta]
+- Permit stronger flushes after Z_BLOCK flushes
+- Avoid extraneous empty blocks when doing empty flushes
+- Permit Z_NULL arguments to deflatePending
+- Allow deflatePrime() to insert bits in the middle of a stream
+- Remove second empty static block for Z_PARTIAL_FLUSH
+- Write out all of the available bits when using Z_BLOCK
+- Insert the first two strings in the hash table after a flush
+
+Changes in 1.2.5.2 (17 Dec 2011)
+- fix ld error: unable to find version dependency 'ZLIB_1.2.5'
+- use relative symlinks for shared libs
+- Avoid searching past window for Z_RLE strategy
+- Assure that high-water mark initialization is always applied in deflate
+- Add assertions to fill_window() in deflate.c to match comments
+- Update python link in README
+- Correct spelling error in gzread.c
+- Fix bug in gzgets() for a concatenated empty gzip stream
+- Correct error in comment for gz_make()
+- Change gzread() and related to ignore junk after gzip streams
+- Allow gzread() and related to continue after gzclearerr()
+- Allow gzrewind() and gzseek() after a premature end-of-file
+- Simplify gzseek() now that raw after gzip is ignored
+- Change gzgetc() to a macro for speed (~40% speedup in testing)
+- Fix gzclose() to return the actual error last encountered
+- Always add large file support for windows
+- Include zconf.h for windows large file support
+- Include zconf.h.cmakein for windows large file support
+- Update zconf.h.cmakein on make distclean
+- Merge vestigial vsnprintf determination from zutil.h to gzguts.h
+- Clarify how gzopen() appends in zlib.h comments
+- Correct documentation of gzdirect() since junk at end now ignored
+- Add a transparent write mode to gzopen() when 'T' is in the mode
+- Update python link in zlib man page
+- Get inffixed.h and MAKEFIXED result to match
+- Add a ./config --solo option to make zlib subset with no library use
+- Add undocumented inflateResetKeep() function for CAB file decoding
+- Add --cover option to ./configure for gcc coverage testing
+- Add #define ZLIB_CONST option to use const in the z_stream interface
+- Add comment to gzdopen() in zlib.h to use dup() when using fileno()
+- Note behavior of uncompress() to provide as much data as it can
+- Add files in contrib/minizip to aid in building libminizip
+- Split off AR options in Makefile.in and configure
+- Change ON macro to Z_ARG to avoid application conflicts
+- Facilitate compilation with Borland C++ for pragmas and vsnprintf
+- Include io.h for Turbo C / Borland C++
+- Move example.c and minigzip.c to test/
+- Simplify incomplete code table filling in inflate_table()
+- Remove code from inflate.c and infback.c that is impossible to execute
+- Test the inflate code with full coverage
+- Allow deflateSetDictionary, inflateSetDictionary at any time (in raw)
+- Add deflateResetKeep and fix inflateResetKeep to retain dictionary
+- Fix gzwrite.c to accommodate reduced memory zlib compilation
+- Have inflate() with Z_FINISH avoid the allocation of a window
+- Do not set strm->adler when doing raw inflate
+- Fix gzeof() to behave just like feof() when read is not past end of file
+- Fix bug in gzread.c when end-of-file is reached
+- Avoid use of Z_BUF_ERROR in gz* functions except for premature EOF
+- Document gzread() capability to read concurrently written files
+- Remove hard-coding of resource compiler in CMakeLists.txt [Blammo]
+
+Changes in 1.2.5.1 (10 Sep 2011)
+- Update FAQ entry on shared builds (#13)
+- Avoid symbolic argument to chmod in Makefile.in
+- Fix bug and add consts in contrib/puff [Oberhumer]
+- Update contrib/puff/zeros.raw test file to have all block types
+- Add full coverage test for puff in contrib/puff/Makefile
+- Fix static-only-build install in Makefile.in
+- Fix bug in unzGetCurrentFileInfo() in contrib/minizip [Kuno]
+- Add libz.a dependency to shared in Makefile.in for parallel builds
+- Spell out "number" (instead of "nb") in zlib.h for total_in, total_out
+- Replace $(...) with `...` in configure for non-bash sh [Bowler]
+- Add darwin* to Darwin* and solaris* to SunOS\ 5* in configure [Groffen]
+- Add solaris* to Linux* in configure to allow gcc use [Groffen]
+- Add *bsd* to Linux* case in configure [Bar-Lev]
+- Add inffast.obj to dependencies in win32/Makefile.msc
+- Correct spelling error in deflate.h [Kohler]
+- Change libzdll.a again to libz.dll.a (!) in win32/Makefile.gcc
+- Add test to configure for GNU C looking for gcc in output of $cc -v
+- Add zlib.pc generation to win32/Makefile.gcc [Weigelt]
+- Fix bug in zlib.h for _FILE_OFFSET_BITS set and _LARGEFILE64_SOURCE not
+- Add comment in zlib.h that adler32_combine with len2 < 0 makes no sense
+- Make NO_DIVIDE option in adler32.c much faster (thanks to John Reiser)
+- Make stronger test in zconf.h to include unistd.h for LFS
+- Apply Darwin patches for 64-bit file offsets to contrib/minizip [Slack]
+- Fix zlib.h LFS support when Z_PREFIX used
+- Add updated as400 support (removed from old) [Monnerat]
+- Avoid deflate sensitivity to volatile input data
+- Avoid division in adler32_combine for NO_DIVIDE
+- Clarify the use of Z_FINISH with deflateBound() amount of space
+- Set binary for output file in puff.c
+- Use u4 type for crc_table to avoid conversion warnings
+- Apply casts in zlib.h to avoid conversion warnings
+- Add OF to prototypes for adler32_combine_ and crc32_combine_ [Miller]
+- Improve inflateSync() documentation to note indeterminancy
+- Add deflatePending() function to return the amount of pending output
+- Correct the spelling of "specification" in FAQ [Randers-Pehrson]
+- Add a check in configure for stdarg.h, use for gzprintf()
+- Check that pointers fit in ints when gzprint() compiled old style
+- Add dummy name before $(SHAREDLIBV) in Makefile [Bar-Lev, Bowler]
+- Delete line in configure that adds -L. libz.a to LDFLAGS [Weigelt]
+- Add debug records in assmebler code [Londer]
+- Update RFC references to use http://tools.ietf.org/html/... [Li]
+- Add --archs option, use of libtool to configure for Mac OS X [Borstel]
+
+Changes in 1.2.5 (19 Apr 2010)
+- Disable visibility attribute in win32/Makefile.gcc [Bar-Lev]
+- Default to libdir as sharedlibdir in configure [Nieder]
+- Update copyright dates on modified source files
+- Update trees.c to be able to generate modified trees.h
+- Exit configure for MinGW, suggesting win32/Makefile.gcc
+- Check for NULL path in gz_open [Homurlu]
+
+Changes in 1.2.4.5 (18 Apr 2010)
+- Set sharedlibdir in configure [Torok]
+- Set LDFLAGS in Makefile.in [Bar-Lev]
+- Avoid mkdir objs race condition in Makefile.in [Bowler]
+- Add ZLIB_INTERNAL in front of internal inter-module functions and arrays
+- Define ZLIB_INTERNAL to hide internal functions and arrays for GNU C
+- Don't use hidden attribute when it is a warning generator (e.g. Solaris)
+
+Changes in 1.2.4.4 (18 Apr 2010)
+- Fix CROSS_PREFIX executable testing, CHOST extract, mingw* [Torok]
+- Undefine _LARGEFILE64_SOURCE in zconf.h if it is zero, but not if empty
+- Try to use bash or ksh regardless of functionality of /bin/sh
+- Fix configure incompatibility with NetBSD sh
+- Remove attempt to run under bash or ksh since have better NetBSD fix
+- Fix win32/Makefile.gcc for MinGW [Bar-Lev]
+- Add diagnostic messages when using CROSS_PREFIX in configure
+- Added --sharedlibdir option to configure [Weigelt]
+- Use hidden visibility attribute when available [Frysinger]
+
+Changes in 1.2.4.3 (10 Apr 2010)
+- Only use CROSS_PREFIX in configure for ar and ranlib if they exist
+- Use CROSS_PREFIX for nm [Bar-Lev]
+- Assume _LARGEFILE64_SOURCE defined is equivalent to true
+- Avoid use of undefined symbols in #if with && and ||
+- Make *64 prototypes in gzguts.h consistent with functions
+- Add -shared load option for MinGW in configure [Bowler]
+- Move z_off64_t to public interface, use instead of off64_t
+- Remove ! from shell test in configure (not portable to Solaris)
+- Change +0 macro tests to -0 for possibly increased portability
+
+Changes in 1.2.4.2 (9 Apr 2010)
+- Add consistent carriage returns to readme.txt's in masmx86 and masmx64
+- Really provide prototypes for *64 functions when building without LFS
+- Only define unlink() in minigzip.c if unistd.h not included
+- Update README to point to contrib/vstudio project files
+- Move projects/vc6 to old/ and remove projects/
+- Include stdlib.h in minigzip.c for setmode() definition under WinCE
+- Clean up assembler builds in win32/Makefile.msc [Rowe]
+- Include sys/types.h for Microsoft for off_t definition
+- Fix memory leak on error in gz_open()
+- Symbolize nm as $NM in configure [Weigelt]
+- Use TEST_LDSHARED instead of LDSHARED to link test programs [Weigelt]
+- Add +0 to _FILE_OFFSET_BITS and _LFS64_LARGEFILE in case not defined
+- Fix bug in gzeof() to take into account unused input data
+- Avoid initialization of structures with variables in puff.c
+- Updated win32/README-WIN32.txt [Rowe]
+
+Changes in 1.2.4.1 (28 Mar 2010)
+- Remove the use of [a-z] constructs for sed in configure [gentoo 310225]
+- Remove $(SHAREDLIB) from LIBS in Makefile.in [Creech]
+- Restore "for debugging" comment on sprintf() in gzlib.c
+- Remove fdopen for MVS from gzguts.h
+- Put new README-WIN32.txt in win32 [Rowe]
+- Add check for shell to configure and invoke another shell if needed
+- Fix big fat stinking bug in gzseek() on uncompressed files
+- Remove vestigial F_OPEN64 define in zutil.h
+- Set and check the value of _LARGEFILE_SOURCE and _LARGEFILE64_SOURCE
+- Avoid errors on non-LFS systems when applications define LFS macros
+- Set EXE to ".exe" in configure for MINGW [Kahle]
+- Match crc32() in crc32.c exactly to the prototype in zlib.h [Sherrill]
+- Add prefix for cross-compilation in win32/makefile.gcc [Bar-Lev]
+- Add DLL install in win32/makefile.gcc [Bar-Lev]
+- Allow Linux* or linux* from uname in configure [Bar-Lev]
+- Allow ldconfig to be redefined in configure and Makefile.in [Bar-Lev]
+- Add cross-compilation prefixes to configure [Bar-Lev]
+- Match type exactly in gz_load() invocation in gzread.c
+- Match type exactly of zcalloc() in zutil.c to zlib.h alloc_func
+- Provide prototypes for *64 functions when building zlib without LFS
+- Don't use -lc when linking shared library on MinGW
+- Remove errno.h check in configure and vestigial errno code in zutil.h
+
+Changes in 1.2.4 (14 Mar 2010)
+- Fix VER3 extraction in configure for no fourth subversion
+- Update zlib.3, add docs to Makefile.in to make .pdf out of it
+- Add zlib.3.pdf to distribution
+- Don't set error code in gzerror() if passed pointer is NULL
+- Apply destination directory fixes to CMakeLists.txt [Lowman]
+- Move #cmakedefine's to a new zconf.in.cmakein
+- Restore zconf.h for builds that don't use configure or cmake
+- Add distclean to dummy Makefile for convenience
+- Update and improve INDEX, README, and FAQ
+- Update CMakeLists.txt for the return of zconf.h [Lowman]
+- Update contrib/vstudio/vc9 and vc10 [Vollant]
+- Change libz.dll.a back to libzdll.a in win32/Makefile.gcc
+- Apply license and readme changes to contrib/asm686 [Raiter]
+- Check file name lengths and add -c option in minigzip.c [Li]
+- Update contrib/amd64 and contrib/masmx86/ [Vollant]
+- Avoid use of "eof" parameter in trees.c to not shadow library variable
+- Update make_vms.com for removal of zlibdefs.h [Zinser]
+- Update assembler code and vstudio projects in contrib [Vollant]
+- Remove outdated assembler code contrib/masm686 and contrib/asm586
+- Remove old vc7 and vc8 from contrib/vstudio
+- Update win32/Makefile.msc, add ZLIB_VER_SUBREVISION [Rowe]
+- Fix memory leaks in gzclose_r() and gzclose_w(), file leak in gz_open()
+- Add contrib/gcc_gvmat64 for longest_match and inflate_fast [Vollant]
+- Remove *64 functions from win32/zlib.def (they're not 64-bit yet)
+- Fix bug in void-returning vsprintf() case in gzwrite.c
+- Fix name change from inflate.h in contrib/inflate86/inffas86.c
+- Check if temporary file exists before removing in make_vms.com [Zinser]
+- Fix make install and uninstall for --static option
+- Fix usage of _MSC_VER in gzguts.h and zutil.h [Truta]
+- Update readme.txt in contrib/masmx64 and masmx86 to assemble
+
+Changes in 1.2.3.9 (21 Feb 2010)
+- Expunge gzio.c
+- Move as400 build information to old
+- Fix updates in contrib/minizip and contrib/vstudio
+- Add const to vsnprintf test in configure to avoid warnings [Weigelt]
+- Delete zconf.h (made by configure) [Weigelt]
+- Change zconf.in.h to zconf.h.in per convention [Weigelt]
+- Check for NULL buf in gzgets()
+- Return empty string for gzgets() with len == 1 (like fgets())
+- Fix description of gzgets() in zlib.h for end-of-file, NULL return
+- Update minizip to 1.1 [Vollant]
+- Avoid MSVC loss of data warnings in gzread.c, gzwrite.c
+- Note in zlib.h that gzerror() should be used to distinguish from EOF
+- Remove use of snprintf() from gzlib.c
+- Fix bug in gzseek()
+- Update contrib/vstudio, adding vc9 and vc10 [Kuno, Vollant]
+- Fix zconf.h generation in CMakeLists.txt [Lowman]
+- Improve comments in zconf.h where modified by configure
+
+Changes in 1.2.3.8 (13 Feb 2010)
+- Clean up text files (tabs, trailing whitespace, etc.) [Oberhumer]
+- Use z_off64_t in gz_zero() and gz_skip() to match state->skip
+- Avoid comparison problem when sizeof(int) == sizeof(z_off64_t)
+- Revert to Makefile.in from 1.2.3.6 (live with the clutter)
+- Fix missing error return in gzflush(), add zlib.h note
+- Add *64 functions to zlib.map [Levin]
+- Fix signed/unsigned comparison in gz_comp()
+- Use SFLAGS when testing shared linking in configure
+- Add --64 option to ./configure to use -m64 with gcc
+- Fix ./configure --help to correctly name options
+- Have make fail if a test fails [Levin]
+- Avoid buffer overrun in contrib/masmx64/gvmat64.asm [Simpson]
+- Remove assembler object files from contrib
+
+Changes in 1.2.3.7 (24 Jan 2010)
+- Always gzopen() with O_LARGEFILE if available
+- Fix gzdirect() to work immediately after gzopen() or gzdopen()
+- Make gzdirect() more precise when the state changes while reading
+- Improve zlib.h documentation in many places
+- Catch memory allocation failure in gz_open()
+- Complete close operation if seek forward in gzclose_w() fails
+- Return Z_ERRNO from gzclose_r() if close() fails
+- Return Z_STREAM_ERROR instead of EOF for gzclose() being passed NULL
+- Return zero for gzwrite() errors to match zlib.h description
+- Return -1 on gzputs() error to match zlib.h description
+- Add zconf.in.h to allow recovery from configure modification [Weigelt]
+- Fix static library permissions in Makefile.in [Weigelt]
+- Avoid warnings in configure tests that hide functionality [Weigelt]
+- Add *BSD and DragonFly to Linux case in configure [gentoo 123571]
+- Change libzdll.a to libz.dll.a in win32/Makefile.gcc [gentoo 288212]
+- Avoid access of uninitialized data for first inflateReset2 call [Gomes]
+- Keep object files in subdirectories to reduce the clutter somewhat
+- Remove default Makefile and zlibdefs.h, add dummy Makefile
+- Add new external functions to Z_PREFIX, remove duplicates, z_z_ -> z_
+- Remove zlibdefs.h completely -- modify zconf.h instead
+
+Changes in 1.2.3.6 (17 Jan 2010)
+- Avoid void * arithmetic in gzread.c and gzwrite.c
+- Make compilers happier with const char * for gz_error message
+- Avoid unused parameter warning in inflate.c
+- Avoid signed-unsigned comparison warning in inflate.c
+- Indent #pragma's for traditional C
+- Fix usage of strwinerror() in glib.c, change to gz_strwinerror()
+- Correct email address in configure for system options
+- Update make_vms.com and add make_vms.com to contrib/minizip [Zinser]
+- Update zlib.map [Brown]
+- Fix Makefile.in for Solaris 10 make of example64 and minizip64 [Torok]
+- Apply various fixes to CMakeLists.txt [Lowman]
+- Add checks on len in gzread() and gzwrite()
+- Add error message for no more room for gzungetc()
+- Remove zlib version check in gzwrite()
+- Defer compression of gzprintf() result until need to
+- Use snprintf() in gzdopen() if available
+- Remove USE_MMAP configuration determination (only used by minigzip)
+- Remove examples/pigz.c (available separately)
+- Update examples/gun.c to 1.6
+
+Changes in 1.2.3.5 (8 Jan 2010)
+- Add space after #if in zutil.h for some compilers
+- Fix relatively harmless bug in deflate_fast() [Exarevsky]
+- Fix same problem in deflate_slow()
+- Add $(SHAREDLIBV) to LIBS in Makefile.in [Brown]
+- Add deflate_rle() for faster Z_RLE strategy run-length encoding
+- Add deflate_huff() for faster Z_HUFFMAN_ONLY encoding
+- Change name of "write" variable in inffast.c to avoid library collisions
+- Fix premature EOF from gzread() in gzio.c [Brown]
+- Use zlib header window size if windowBits is 0 in inflateInit2()
+- Remove compressBound() call in deflate.c to avoid linking compress.o
+- Replace use of errno in gz* with functions, support WinCE [Alves]
+- Provide alternative to perror() in minigzip.c for WinCE [Alves]
+- Don't use _vsnprintf on later versions of MSVC [Lowman]
+- Add CMake build script and input file [Lowman]
+- Update contrib/minizip to 1.1 [Svensson, Vollant]
+- Moved nintendods directory from contrib to .
+- Replace gzio.c with a new set of routines with the same functionality
+- Add gzbuffer(), gzoffset(), gzclose_r(), gzclose_w() as part of above
+- Update contrib/minizip to 1.1b
+- Change gzeof() to return 0 on error instead of -1 to agree with zlib.h
+
+Changes in 1.2.3.4 (21 Dec 2009)
+- Use old school .SUFFIXES in Makefile.in for FreeBSD compatibility
+- Update comments in configure and Makefile.in for default --shared
+- Fix test -z's in configure [Marquess]
+- Build examplesh and minigzipsh when not testing
+- Change NULL's to Z_NULL's in deflate.c and in comments in zlib.h
+- Import LDFLAGS from the environment in configure
+- Fix configure to populate SFLAGS with discovered CFLAGS options
+- Adapt make_vms.com to the new Makefile.in [Zinser]
+- Add zlib2ansi script for C++ compilation [Marquess]
+- Add _FILE_OFFSET_BITS=64 test to make test (when applicable)
+- Add AMD64 assembler code for longest match to contrib [Teterin]
+- Include options from $SFLAGS when doing $LDSHARED
+- Simplify 64-bit file support by introducing z_off64_t type
+- Make shared object files in objs directory to work around old Sun cc
+- Use only three-part version number for Darwin shared compiles
+- Add rc option to ar in Makefile.in for when ./configure not run
+- Add -WI,-rpath,. to LDFLAGS for OSF 1 V4*
+- Set LD_LIBRARYN32_PATH for SGI IRIX shared compile
+- Protect against _FILE_OFFSET_BITS being defined when compiling zlib
+- Rename Makefile.in targets allstatic to static and allshared to shared
+- Fix static and shared Makefile.in targets to be independent
+- Correct error return bug in gz_open() by setting state [Brown]
+- Put spaces before ;;'s in configure for better sh compatibility
+- Add pigz.c (parallel implementation of gzip) to examples/
+- Correct constant in crc32.c to UL [Leventhal]
+- Reject negative lengths in crc32_combine()
+- Add inflateReset2() function to work like inflateEnd()/inflateInit2()
+- Include sys/types.h for _LARGEFILE64_SOURCE [Brown]
+- Correct typo in doc/algorithm.txt [Janik]
+- Fix bug in adler32_combine() [Zhu]
+- Catch missing-end-of-block-code error in all inflates and in puff
+ Assures that random input to inflate eventually results in an error
+- Added enough.c (calculation of ENOUGH for inftrees.h) to examples/
+- Update ENOUGH and its usage to reflect discovered bounds
+- Fix gzerror() error report on empty input file [Brown]
+- Add ush casts in trees.c to avoid pedantic runtime errors
+- Fix typo in zlib.h uncompress() description [Reiss]
+- Correct inflate() comments with regard to automatic header detection
+- Remove deprecation comment on Z_PARTIAL_FLUSH (it stays)
+- Put new version of gzlog (2.0) in examples with interruption recovery
+- Add puff compile option to permit invalid distance-too-far streams
+- Add puff TEST command options, ability to read piped input
+- Prototype the *64 functions in zlib.h when _FILE_OFFSET_BITS == 64, but
+ _LARGEFILE64_SOURCE not defined
+- Fix Z_FULL_FLUSH to truly erase the past by resetting s->strstart
+- Fix deflateSetDictionary() to use all 32K for output consistency
+- Remove extraneous #define MIN_LOOKAHEAD in deflate.c (in deflate.h)
+- Clear bytes after deflate lookahead to avoid use of uninitialized data
+- Change a limit in inftrees.c to be more transparent to Coverity Prevent
+- Update win32/zlib.def with exported symbols from zlib.h
+- Correct spelling errors in zlib.h [Willem, Sobrado]
+- Allow Z_BLOCK for deflate() to force a new block
+- Allow negative bits in inflatePrime() to delete existing bit buffer
+- Add Z_TREES flush option to inflate() to return at end of trees
+- Add inflateMark() to return current state information for random access
+- Add Makefile for NintendoDS to contrib [Costa]
+- Add -w in configure compile tests to avoid spurious warnings [Beucler]
+- Fix typos in zlib.h comments for deflateSetDictionary()
+- Fix EOF detection in transparent gzread() [Maier]
+
+Changes in 1.2.3.3 (2 October 2006)
+- Make --shared the default for configure, add a --static option
+- Add compile option to permit invalid distance-too-far streams
+- Add inflateUndermine() function which is required to enable above
+- Remove use of "this" variable name for C++ compatibility [Marquess]
+- Add testing of shared library in make test, if shared library built
+- Use ftello() and fseeko() if available instead of ftell() and fseek()
+- Provide two versions of all functions that use the z_off_t type for
+ binary compatibility -- a normal version and a 64-bit offset version,
+ per the Large File Support Extension when _LARGEFILE64_SOURCE is
+ defined; use the 64-bit versions by default when _FILE_OFFSET_BITS
+ is defined to be 64
+- Add a --uname= option to configure to perhaps help with cross-compiling
+
+Changes in 1.2.3.2 (3 September 2006)
+- Turn off silly Borland warnings [Hay]
+- Use off64_t and define _LARGEFILE64_SOURCE when present
+- Fix missing dependency on inffixed.h in Makefile.in
+- Rig configure --shared to build both shared and static [Teredesai, Truta]
+- Remove zconf.in.h and instead create a new zlibdefs.h file
+- Fix contrib/minizip/unzip.c non-encrypted after encrypted [Vollant]
+- Add treebuild.xml (see http://treebuild.metux.de/) [Weigelt]
+
+Changes in 1.2.3.1 (16 August 2006)
+- Add watcom directory with OpenWatcom make files [Daniel]
+- Remove #undef of FAR in zconf.in.h for MVS [Fedtke]
+- Update make_vms.com [Zinser]
+- Use -fPIC for shared build in configure [Teredesai, Nicholson]
+- Use only major version number for libz.so on IRIX and OSF1 [Reinholdtsen]
+- Use fdopen() (not _fdopen()) for Interix in zutil.h [Bäck]
+- Add some FAQ entries about the contrib directory
+- Update the MVS question in the FAQ
+- Avoid extraneous reads after EOF in gzio.c [Brown]
+- Correct spelling of "successfully" in gzio.c [Randers-Pehrson]
+- Add comments to zlib.h about gzerror() usage [Brown]
+- Set extra flags in gzip header in gzopen() like deflate() does
+- Make configure options more compatible with double-dash conventions
+ [Weigelt]
+- Clean up compilation under Solaris SunStudio cc [Rowe, Reinholdtsen]
+- Fix uninstall target in Makefile.in [Truta]
+- Add pkgconfig support [Weigelt]
+- Use $(DESTDIR) macro in Makefile.in [Reinholdtsen, Weigelt]
+- Replace set_data_type() with a more accurate detect_data_type() in
+ trees.c, according to the txtvsbin.txt document [Truta]
+- Swap the order of #include <stdio.h> and #include "zlib.h" in
+ gzio.c, example.c and minigzip.c [Truta]
+- Shut up annoying VS2005 warnings about standard C deprecation [Rowe,
+ Truta] (where?)
+- Fix target "clean" from win32/Makefile.bor [Truta]
+- Create .pdb and .manifest files in win32/makefile.msc [Ziegler, Rowe]
+- Update zlib www home address in win32/DLL_FAQ.txt [Truta]
+- Update contrib/masmx86/inffas32.asm for VS2005 [Vollant, Van Wassenhove]
+- Enable browse info in the "Debug" and "ASM Debug" configurations in
+ the Visual C++ 6 project, and set (non-ASM) "Debug" as default [Truta]
+- Add pkgconfig support [Weigelt]
+- Add ZLIB_VER_MAJOR, ZLIB_VER_MINOR and ZLIB_VER_REVISION in zlib.h,
+ for use in win32/zlib1.rc [Polushin, Rowe, Truta]
+- Add a document that explains the new text detection scheme to
+ doc/txtvsbin.txt [Truta]
+- Add rfc1950.txt, rfc1951.txt and rfc1952.txt to doc/ [Truta]
+- Move algorithm.txt into doc/ [Truta]
+- Synchronize FAQ with website
+- Fix compressBound(), was low for some pathological cases [Fearnley]
+- Take into account wrapper variations in deflateBound()
+- Set examples/zpipe.c input and output to binary mode for Windows
+- Update examples/zlib_how.html with new zpipe.c (also web site)
+- Fix some warnings in examples/gzlog.c and examples/zran.c (it seems
+ that gcc became pickier in 4.0)
+- Add zlib.map for Linux: "All symbols from zlib-1.1.4 remain
+ un-versioned, the patch adds versioning only for symbols introduced in
+ zlib-1.2.0 or later. It also declares as local those symbols which are
+ not designed to be exported." [Levin]
+- Update Z_PREFIX list in zconf.in.h, add --zprefix option to configure
+- Do not initialize global static by default in trees.c, add a response
+ NO_INIT_GLOBAL_POINTERS to initialize them if needed [Marquess]
+- Don't use strerror() in gzio.c under WinCE [Yakimov]
+- Don't use errno.h in zutil.h under WinCE [Yakimov]
+- Move arguments for AR to its usage to allow replacing ar [Marot]
+- Add HAVE_VISIBILITY_PRAGMA in zconf.in.h for Mozilla [Randers-Pehrson]
+- Improve inflateInit() and inflateInit2() documentation
+- Fix structure size comment in inflate.h
+- Change configure help option from --h* to --help [Santos]
+
+Changes in 1.2.3 (18 July 2005)
+- Apply security vulnerability fixes to contrib/infback9 as well
+- Clean up some text files (carriage returns, trailing space)
+- Update testzlib, vstudio, masmx64, and masmx86 in contrib [Vollant]
+
+Changes in 1.2.2.4 (11 July 2005)
+- Add inflatePrime() function for starting inflation at bit boundary
+- Avoid some Visual C warnings in deflate.c
+- Avoid more silly Visual C warnings in inflate.c and inftrees.c for 64-bit
+ compile
+- Fix some spelling errors in comments [Betts]
+- Correct inflateInit2() error return documentation in zlib.h
+- Add zran.c example of compressed data random access to examples
+ directory, shows use of inflatePrime()
+- Fix cast for assignments to strm->state in inflate.c and infback.c
+- Fix zlibCompileFlags() in zutil.c to use 1L for long shifts [Oberhumer]
+- Move declarations of gf2 functions to right place in crc32.c [Oberhumer]
+- Add cast in trees.c t avoid a warning [Oberhumer]
+- Avoid some warnings in fitblk.c, gun.c, gzjoin.c in examples [Oberhumer]
+- Update make_vms.com [Zinser]
+- Initialize state->write in inflateReset() since copied in inflate_fast()
+- Be more strict on incomplete code sets in inflate_table() and increase
+ ENOUGH and MAXD -- this repairs a possible security vulnerability for
+ invalid inflate input. Thanks to Tavis Ormandy and Markus Oberhumer for
+ discovering the vulnerability and providing test cases.
+- Add ia64 support to configure for HP-UX [Smith]
+- Add error return to gzread() for format or i/o error [Levin]
+- Use malloc.h for OS/2 [Necasek]
+
+Changes in 1.2.2.3 (27 May 2005)
+- Replace 1U constants in inflate.c and inftrees.c for 64-bit compile
+- Typecast fread() return values in gzio.c [Vollant]
+- Remove trailing space in minigzip.c outmode (VC++ can't deal with it)
+- Fix crc check bug in gzread() after gzungetc() [Heiner]
+- Add the deflateTune() function to adjust internal compression parameters
+- Add a fast gzip decompressor, gun.c, to examples (use of inflateBack)
+- Remove an incorrect assertion in examples/zpipe.c
+- Add C++ wrapper in infback9.h [Donais]
+- Fix bug in inflateCopy() when decoding fixed codes
+- Note in zlib.h how much deflateSetDictionary() actually uses
+- Remove USE_DICT_HEAD in deflate.c (would mess up inflate if used)
+- Add _WIN32_WCE to define WIN32 in zconf.in.h [Spencer]
+- Don't include stderr.h or errno.h for _WIN32_WCE in zutil.h [Spencer]
+- Add gzdirect() function to indicate transparent reads
+- Update contrib/minizip [Vollant]
+- Fix compilation of deflate.c when both ASMV and FASTEST [Oberhumer]
+- Add casts in crc32.c to avoid warnings [Oberhumer]
+- Add contrib/masmx64 [Vollant]
+- Update contrib/asm586, asm686, masmx86, testzlib, vstudio [Vollant]
+
+Changes in 1.2.2.2 (30 December 2004)
+- Replace structure assignments in deflate.c and inflate.c with zmemcpy to
+ avoid implicit memcpy calls (portability for no-library compilation)
+- Increase sprintf() buffer size in gzdopen() to allow for large numbers
+- Add INFLATE_STRICT to check distances against zlib header
+- Improve WinCE errno handling and comments [Chang]
+- Remove comment about no gzip header processing in FAQ
+- Add Z_FIXED strategy option to deflateInit2() to force fixed trees
+- Add updated make_vms.com [Coghlan], update README
+- Create a new "examples" directory, move gzappend.c there, add zpipe.c,
+ fitblk.c, gzlog.[ch], gzjoin.c, and zlib_how.html.
+- Add FAQ entry and comments in deflate.c on uninitialized memory access
+- Add Solaris 9 make options in configure [Gilbert]
+- Allow strerror() usage in gzio.c for STDC
+- Fix DecompressBuf in contrib/delphi/ZLib.pas [ManChesTer]
+- Update contrib/masmx86/inffas32.asm and gvmat32.asm [Vollant]
+- Use z_off_t for adler32_combine() and crc32_combine() lengths
+- Make adler32() much faster for small len
+- Use OS_CODE in deflate() default gzip header
+
+Changes in 1.2.2.1 (31 October 2004)
+- Allow inflateSetDictionary() call for raw inflate
+- Fix inflate header crc check bug for file names and comments
+- Add deflateSetHeader() and gz_header structure for custom gzip headers
+- Add inflateGetheader() to retrieve gzip headers
+- Add crc32_combine() and adler32_combine() functions
+- Add alloc_func, free_func, in_func, out_func to Z_PREFIX list
+- Use zstreamp consistently in zlib.h (inflate_back functions)
+- Remove GUNZIP condition from definition of inflate_mode in inflate.h
+ and in contrib/inflate86/inffast.S [Truta, Anderson]
+- Add support for AMD64 in contrib/inflate86/inffas86.c [Anderson]
+- Update projects/README.projects and projects/visualc6 [Truta]
+- Update win32/DLL_FAQ.txt [Truta]
+- Avoid warning under NO_GZCOMPRESS in gzio.c; fix typo [Truta]
+- Deprecate Z_ASCII; use Z_TEXT instead [Truta]
+- Use a new algorithm for setting strm->data_type in trees.c [Truta]
+- Do not define an exit() prototype in zutil.c unless DEBUG defined
+- Remove prototype of exit() from zutil.c, example.c, minigzip.c [Truta]
+- Add comment in zlib.h for Z_NO_FLUSH parameter to deflate()
+- Fix Darwin build version identification [Peterson]
+
+Changes in 1.2.2 (3 October 2004)
+- Update zlib.h comments on gzip in-memory processing
+- Set adler to 1 in inflateReset() to support Java test suite [Walles]
+- Add contrib/dotzlib [Ravn]
+- Update win32/DLL_FAQ.txt [Truta]
+- Update contrib/minizip [Vollant]
+- Move contrib/visual-basic.txt to old/ [Truta]
+- Fix assembler builds in projects/visualc6/ [Truta]
+
+Changes in 1.2.1.2 (9 September 2004)
+- Update INDEX file
+- Fix trees.c to update strm->data_type (no one ever noticed!)
+- Fix bug in error case in inflate.c, infback.c, and infback9.c [Brown]
+- Add "volatile" to crc table flag declaration (for DYNAMIC_CRC_TABLE)
+- Add limited multitasking protection to DYNAMIC_CRC_TABLE
+- Add NO_vsnprintf for VMS in zutil.h [Mozilla]
+- Don't declare strerror() under VMS [Mozilla]
+- Add comment to DYNAMIC_CRC_TABLE to use get_crc_table() to initialize
+- Update contrib/ada [Anisimkov]
+- Update contrib/minizip [Vollant]
+- Fix configure to not hardcode directories for Darwin [Peterson]
+- Fix gzio.c to not return error on empty files [Brown]
+- Fix indentation; update version in contrib/delphi/ZLib.pas and
+ contrib/pascal/zlibpas.pas [Truta]
+- Update mkasm.bat in contrib/masmx86 [Truta]
+- Update contrib/untgz [Truta]
+- Add projects/README.projects [Truta]
+- Add project for MS Visual C++ 6.0 in projects/visualc6 [Cadieux, Truta]
+- Update win32/DLL_FAQ.txt [Truta]
+- Update list of Z_PREFIX symbols in zconf.h [Randers-Pehrson, Truta]
+- Remove an unnecessary assignment to curr in inftrees.c [Truta]
+- Add OS/2 to exe builds in configure [Poltorak]
+- Remove err dummy parameter in zlib.h [Kientzle]
+
+Changes in 1.2.1.1 (9 January 2004)
+- Update email address in README
+- Several FAQ updates
+- Fix a big fat bug in inftrees.c that prevented decoding valid
+ dynamic blocks with only literals and no distance codes --
+ Thanks to "Hot Emu" for the bug report and sample file
+- Add a note to puff.c on no distance codes case.
+
+Changes in 1.2.1 (17 November 2003)
+- Remove a tab in contrib/gzappend/gzappend.c
+- Update some interfaces in contrib for new zlib functions
+- Update zlib version number in some contrib entries
+- Add Windows CE definition for ptrdiff_t in zutil.h [Mai, Truta]
+- Support shared libraries on Hurd and KFreeBSD [Brown]
+- Fix error in NO_DIVIDE option of adler32.c
+
+Changes in 1.2.0.8 (4 November 2003)
+- Update version in contrib/delphi/ZLib.pas and contrib/pascal/zlibpas.pas
+- Add experimental NO_DIVIDE #define in adler32.c
+ - Possibly faster on some processors (let me know if it is)
+- Correct Z_BLOCK to not return on first inflate call if no wrap
+- Fix strm->data_type on inflate() return to correctly indicate EOB
+- Add deflatePrime() function for appending in the middle of a byte
+- Add contrib/gzappend for an example of appending to a stream
+- Update win32/DLL_FAQ.txt [Truta]
+- Delete Turbo C comment in README [Truta]
+- Improve some indentation in zconf.h [Truta]
+- Fix infinite loop on bad input in configure script [Church]
+- Fix gzeof() for concatenated gzip files [Johnson]
+- Add example to contrib/visual-basic.txt [Michael B.]
+- Add -p to mkdir's in Makefile.in [vda]
+- Fix configure to properly detect presence or lack of printf functions
+- Add AS400 support [Monnerat]
+- Add a little Cygwin support [Wilson]
+
+Changes in 1.2.0.7 (21 September 2003)
+- Correct some debug formats in contrib/infback9
+- Cast a type in a debug statement in trees.c
+- Change search and replace delimiter in configure from % to # [Beebe]
+- Update contrib/untgz to 0.2 with various fixes [Truta]
+- Add build support for Amiga [Nikl]
+- Remove some directories in old that have been updated to 1.2
+- Add dylib building for Mac OS X in configure and Makefile.in
+- Remove old distribution stuff from Makefile
+- Update README to point to DLL_FAQ.txt, and add comment on Mac OS X
+- Update links in README
+
+Changes in 1.2.0.6 (13 September 2003)
+- Minor FAQ updates
+- Update contrib/minizip to 1.00 [Vollant]
+- Remove test of gz functions in example.c when GZ_COMPRESS defined [Truta]
+- Update POSTINC comment for 68060 [Nikl]
+- Add contrib/infback9 with deflate64 decoding (unsupported)
+- For MVS define NO_vsnprintf and undefine FAR [van Burik]
+- Add pragma for fdopen on MVS [van Burik]
+
+Changes in 1.2.0.5 (8 September 2003)
+- Add OF to inflateBackEnd() declaration in zlib.h
+- Remember start when using gzdopen in the middle of a file
+- Use internal off_t counters in gz* functions to properly handle seeks
+- Perform more rigorous check for distance-too-far in inffast.c
+- Add Z_BLOCK flush option to return from inflate at block boundary
+- Set strm->data_type on return from inflate
+ - Indicate bits unused, if at block boundary, and if in last block
+- Replace size_t with ptrdiff_t in crc32.c, and check for correct size
+- Add condition so old NO_DEFLATE define still works for compatibility
+- FAQ update regarding the Windows DLL [Truta]
+- INDEX update: add qnx entry, remove aix entry [Truta]
+- Install zlib.3 into mandir [Wilson]
+- Move contrib/zlib_dll_FAQ.txt to win32/DLL_FAQ.txt; update [Truta]
+- Adapt the zlib interface to the new DLL convention guidelines [Truta]
+- Introduce ZLIB_WINAPI macro to allow the export of functions using
+ the WINAPI calling convention, for Visual Basic [Vollant, Truta]
+- Update msdos and win32 scripts and makefiles [Truta]
+- Export symbols by name, not by ordinal, in win32/zlib.def [Truta]
+- Add contrib/ada [Anisimkov]
+- Move asm files from contrib/vstudio/vc70_32 to contrib/asm386 [Truta]
+- Rename contrib/asm386 to contrib/masmx86 [Truta, Vollant]
+- Add contrib/masm686 [Truta]
+- Fix offsets in contrib/inflate86 and contrib/masmx86/inffas32.asm
+ [Truta, Vollant]
+- Update contrib/delphi; rename to contrib/pascal; add example [Truta]
+- Remove contrib/delphi2; add a new contrib/delphi [Truta]
+- Avoid inclusion of the nonstandard <memory.h> in contrib/iostream,
+ and fix some method prototypes [Truta]
+- Fix the ZCR_SEED2 constant to avoid warnings in contrib/minizip
+ [Truta]
+- Avoid the use of backslash (\) in contrib/minizip [Vollant]
+- Fix file time handling in contrib/untgz; update makefiles [Truta]
+- Update contrib/vstudio/vc70_32 to comply with the new DLL guidelines
+ [Vollant]
+- Remove contrib/vstudio/vc15_16 [Vollant]
+- Rename contrib/vstudio/vc70_32 to contrib/vstudio/vc7 [Truta]
+- Update README.contrib [Truta]
+- Invert the assignment order of match_head and s->prev[...] in
+ INSERT_STRING [Truta]
+- Compare TOO_FAR with 32767 instead of 32768, to avoid 16-bit warnings
+ [Truta]
+- Compare function pointers with 0, not with NULL or Z_NULL [Truta]
+- Fix prototype of syncsearch in inflate.c [Truta]
+- Introduce ASMINF macro to be enabled when using an ASM implementation
+ of inflate_fast [Truta]
+- Change NO_DEFLATE to NO_GZCOMPRESS [Truta]
+- Modify test_gzio in example.c to take a single file name as a
+ parameter [Truta]
+- Exit the example.c program if gzopen fails [Truta]
+- Add type casts around strlen in example.c [Truta]
+- Remove casting to sizeof in minigzip.c; give a proper type
+ to the variable compared with SUFFIX_LEN [Truta]
+- Update definitions of STDC and STDC99 in zconf.h [Truta]
+- Synchronize zconf.h with the new Windows DLL interface [Truta]
+- Use SYS16BIT instead of __32BIT__ to distinguish between
+ 16- and 32-bit platforms [Truta]
+- Use far memory allocators in small 16-bit memory models for
+ Turbo C [Truta]
+- Add info about the use of ASMV, ASMINF and ZLIB_WINAPI in
+ zlibCompileFlags [Truta]
+- Cygwin has vsnprintf [Wilson]
+- In Windows16, OS_CODE is 0, as in MSDOS [Truta]
+- In Cygwin, OS_CODE is 3 (Unix), not 11 (Windows32) [Wilson]
+
+Changes in 1.2.0.4 (10 August 2003)
+- Minor FAQ updates
+- Be more strict when checking inflateInit2's windowBits parameter
+- Change NO_GUNZIP compile option to NO_GZIP to cover deflate as well
+- Add gzip wrapper option to deflateInit2 using windowBits
+- Add updated QNX rule in configure and qnx directory [Bonnefoy]
+- Make inflate distance-too-far checks more rigorous
+- Clean up FAR usage in inflate
+- Add casting to sizeof() in gzio.c and minigzip.c
+
+Changes in 1.2.0.3 (19 July 2003)
+- Fix silly error in gzungetc() implementation [Vollant]
+- Update contrib/minizip and contrib/vstudio [Vollant]
+- Fix printf format in example.c
+- Correct cdecl support in zconf.in.h [Anisimkov]
+- Minor FAQ updates
+
+Changes in 1.2.0.2 (13 July 2003)
+- Add ZLIB_VERNUM in zlib.h for numerical preprocessor comparisons
+- Attempt to avoid warnings in crc32.c for pointer-int conversion
+- Add AIX to configure, remove aix directory [Bakker]
+- Add some casts to minigzip.c
+- Improve checking after insecure sprintf() or vsprintf() calls
+- Remove #elif's from crc32.c
+- Change leave label to inf_leave in inflate.c and infback.c to avoid
+ library conflicts
+- Remove inflate gzip decoding by default--only enable gzip decoding by
+ special request for stricter backward compatibility
+- Add zlibCompileFlags() function to return compilation information
+- More typecasting in deflate.c to avoid warnings
+- Remove leading underscore from _Capital #defines [Truta]
+- Fix configure to link shared library when testing
+- Add some Windows CE target adjustments [Mai]
+- Remove #define ZLIB_DLL in zconf.h [Vollant]
+- Add zlib.3 [Rodgers]
+- Update RFC URL in deflate.c and algorithm.txt [Mai]
+- Add zlib_dll_FAQ.txt to contrib [Truta]
+- Add UL to some constants [Truta]
+- Update minizip and vstudio [Vollant]
+- Remove vestigial NEED_DUMMY_RETURN from zconf.in.h
+- Expand use of NO_DUMMY_DECL to avoid all dummy structures
+- Added iostream3 to contrib [Schwardt]
+- Replace rewind() with fseek() for WinCE [Truta]
+- Improve setting of zlib format compression level flags
+ - Report 0 for huffman and rle strategies and for level == 0 or 1
+ - Report 2 only for level == 6
+- Only deal with 64K limit when necessary at compile time [Truta]
+- Allow TOO_FAR check to be turned off at compile time [Truta]
+- Add gzclearerr() function [Souza]
+- Add gzungetc() function
+
+Changes in 1.2.0.1 (17 March 2003)
+- Add Z_RLE strategy for run-length encoding [Truta]
+ - When Z_RLE requested, restrict matches to distance one
+ - Update zlib.h, minigzip.c, gzopen(), gzdopen() for Z_RLE
+- Correct FASTEST compilation to allow level == 0
+- Clean up what gets compiled for FASTEST
+- Incorporate changes to zconf.in.h [Vollant]
+ - Refine detection of Turbo C need for dummy returns
+ - Refine ZLIB_DLL compilation
+ - Include additional header file on VMS for off_t typedef
+- Try to use _vsnprintf where it supplants vsprintf [Vollant]
+- Add some casts in inffast.c
+- Enchance comments in zlib.h on what happens if gzprintf() tries to
+ write more than 4095 bytes before compression
+- Remove unused state from inflateBackEnd()
+- Remove exit(0) from minigzip.c, example.c
+- Get rid of all those darn tabs
+- Add "check" target to Makefile.in that does the same thing as "test"
+- Add "mostlyclean" and "maintainer-clean" targets to Makefile.in
+- Update contrib/inflate86 [Anderson]
+- Update contrib/testzlib, contrib/vstudio, contrib/minizip [Vollant]
+- Add msdos and win32 directories with makefiles [Truta]
+- More additions and improvements to the FAQ
+
+Changes in 1.2.0 (9 March 2003)
+- New and improved inflate code
+ - About 20% faster
+ - Does not allocate 32K window unless and until needed
+ - Automatically detects and decompresses gzip streams
+ - Raw inflate no longer needs an extra dummy byte at end
+ - Added inflateBack functions using a callback interface--even faster
+ than inflate, useful for file utilities (gzip, zip)
+ - Added inflateCopy() function to record state for random access on
+ externally generated deflate streams (e.g. in gzip files)
+ - More readable code (I hope)
+- New and improved crc32()
+ - About 50% faster, thanks to suggestions from Rodney Brown
+- Add deflateBound() and compressBound() functions
+- Fix memory leak in deflateInit2()
+- Permit setting dictionary for raw deflate (for parallel deflate)
+- Fix const declaration for gzwrite()
+- Check for some malloc() failures in gzio.c
+- Fix bug in gzopen() on single-byte file 0x1f
+- Fix bug in gzread() on concatenated file with 0x1f at end of buffer
+ and next buffer doesn't start with 0x8b
+- Fix uncompress() to return Z_DATA_ERROR on truncated input
+- Free memory at end of example.c
+- Remove MAX #define in trees.c (conflicted with some libraries)
+- Fix static const's in deflate.c, gzio.c, and zutil.[ch]
+- Declare malloc() and free() in gzio.c if STDC not defined
+- Use malloc() instead of calloc() in zutil.c if int big enough
+- Define STDC for AIX
+- Add aix/ with approach for compiling shared library on AIX
+- Add HP-UX support for shared libraries in configure
+- Add OpenUNIX support for shared libraries in configure
+- Use $cc instead of gcc to build shared library
+- Make prefix directory if needed when installing
+- Correct Macintosh avoidance of typedef Byte in zconf.h
+- Correct Turbo C memory allocation when under Linux
+- Use libz.a instead of -lz in Makefile (assure use of compiled library)
+- Update configure to check for snprintf or vsnprintf functions and their
+ return value, warn during make if using an insecure function
+- Fix configure problem with compile-time knowledge of HAVE_UNISTD_H that
+ is lost when library is used--resolution is to build new zconf.h
+- Documentation improvements (in zlib.h):
+ - Document raw deflate and inflate
+ - Update RFCs URL
+ - Point out that zlib and gzip formats are different
+ - Note that Z_BUF_ERROR is not fatal
+ - Document string limit for gzprintf() and possible buffer overflow
+ - Note requirement on avail_out when flushing
+ - Note permitted values of flush parameter of inflate()
+- Add some FAQs (and even answers) to the FAQ
+- Add contrib/inflate86/ for x86 faster inflate
+- Add contrib/blast/ for PKWare Data Compression Library decompression
+- Add contrib/puff/ simple inflate for deflate format description
+
+Changes in 1.1.4 (11 March 2002)
+- ZFREE was repeated on same allocation on some error conditions.
+ This creates a security problem described in
+ http://www.zlib.org/advisory-2002-03-11.txt
+- Returned incorrect error (Z_MEM_ERROR) on some invalid data
+- Avoid accesses before window for invalid distances with inflate window
+ less than 32K.
+- force windowBits > 8 to avoid a bug in the encoder for a window size
+ of 256 bytes. (A complete fix will be available in 1.1.5).
+
+Changes in 1.1.3 (9 July 1998)
+- fix "an inflate input buffer bug that shows up on rare but persistent
+ occasions" (Mark)
+- fix gzread and gztell for concatenated .gz files (Didier Le Botlan)
+- fix gzseek(..., SEEK_SET) in write mode
+- fix crc check after a gzeek (Frank Faubert)
+- fix miniunzip when the last entry in a zip file is itself a zip file
+ (J Lillge)
+- add contrib/asm586 and contrib/asm686 (Brian Raiter)
+ See http://www.muppetlabs.com/~breadbox/software/assembly.html
+- add support for Delphi 3 in contrib/delphi (Bob Dellaca)
+- add support for C++Builder 3 and Delphi 3 in contrib/delphi2 (Davide Moretti)
+- do not exit prematurely in untgz if 0 at start of block (Magnus Holmgren)
+- use macro EXTERN instead of extern to support DLL for BeOS (Sander Stoks)
+- added a FAQ file
+
+- Support gzdopen on Mac with Metrowerks (Jason Linhart)
+- Do not redefine Byte on Mac (Brad Pettit & Jason Linhart)
+- define SEEK_END too if SEEK_SET is not defined (Albert Chin-A-Young)
+- avoid some warnings with Borland C (Tom Tanner)
+- fix a problem in contrib/minizip/zip.c for 16-bit MSDOS (Gilles Vollant)
+- emulate utime() for WIN32 in contrib/untgz (Gilles Vollant)
+- allow several arguments to configure (Tim Mooney, Frodo Looijaard)
+- use libdir and includedir in Makefile.in (Tim Mooney)
+- support shared libraries on OSF1 V4 (Tim Mooney)
+- remove so_locations in "make clean" (Tim Mooney)
+- fix maketree.c compilation error (Glenn, Mark)
+- Python interface to zlib now in Python 1.5 (Jeremy Hylton)
+- new Makefile.riscos (Rich Walker)
+- initialize static descriptors in trees.c for embedded targets (Nick Smith)
+- use "foo-gz" in example.c for RISCOS and VMS (Nick Smith)
+- add the OS/2 files in Makefile.in too (Andrew Zabolotny)
+- fix fdopen and halloc macros for Microsoft C 6.0 (Tom Lane)
+- fix maketree.c to allow clean compilation of inffixed.h (Mark)
+- fix parameter check in deflateCopy (Gunther Nikl)
+- cleanup trees.c, use compressed_len only in debug mode (Christian Spieler)
+- Many portability patches by Christian Spieler:
+ . zutil.c, zutil.h: added "const" for zmem*
+ . Make_vms.com: fixed some typos
+ . Make_vms.com: msdos/Makefile.*: removed zutil.h from some dependency lists
+ . msdos/Makefile.msc: remove "default rtl link library" info from obj files
+ . msdos/Makefile.*: use model-dependent name for the built zlib library
+ . msdos/Makefile.emx, nt/Makefile.emx, nt/Makefile.gcc:
+ new makefiles, for emx (DOS/OS2), emx&rsxnt and mingw32 (Windows 9x / NT)
+- use define instead of typedef for Bytef also for MSC small/medium (Tom Lane)
+- replace __far with _far for better portability (Christian Spieler, Tom Lane)
+- fix test for errno.h in configure (Tim Newsham)
+
+Changes in 1.1.2 (19 March 98)
+- added contrib/minzip, mini zip and unzip based on zlib (Gilles Vollant)
+ See http://www.winimage.com/zLibDll/unzip.html
+- preinitialize the inflate tables for fixed codes, to make the code
+ completely thread safe (Mark)
+- some simplifications and slight speed-up to the inflate code (Mark)
+- fix gzeof on non-compressed files (Allan Schrum)
+- add -std1 option in configure for OSF1 to fix gzprintf (Martin Mokrejs)
+- use default value of 4K for Z_BUFSIZE for 16-bit MSDOS (Tim Wegner + Glenn)
+- added os2/Makefile.def and os2/zlib.def (Andrew Zabolotny)
+- add shared lib support for UNIX_SV4.2MP (MATSUURA Takanori)
+- do not wrap extern "C" around system includes (Tom Lane)
+- mention zlib binding for TCL in README (Andreas Kupries)
+- added amiga/Makefile.pup for Amiga powerUP SAS/C PPC (Andreas Kleinert)
+- allow "make install prefix=..." even after configure (Glenn Randers-Pehrson)
+- allow "configure --prefix $HOME" (Tim Mooney)
+- remove warnings in example.c and gzio.c (Glenn Randers-Pehrson)
+- move Makefile.sas to amiga/Makefile.sas
+
+Changes in 1.1.1 (27 Feb 98)
+- fix macros _tr_tally_* in deflate.h for debug mode (Glenn Randers-Pehrson)
+- remove block truncation heuristic which had very marginal effect for zlib
+ (smaller lit_bufsize than in gzip 1.2.4) and degraded a little the
+ compression ratio on some files. This also allows inlining _tr_tally for
+ matches in deflate_slow.
+- added msdos/Makefile.w32 for WIN32 Microsoft Visual C++ (Bob Frazier)
+
+Changes in 1.1.0 (24 Feb 98)
+- do not return STREAM_END prematurely in inflate (John Bowler)
+- revert to the zlib 1.0.8 inflate to avoid the gcc 2.8.0 bug (Jeremy Buhler)
+- compile with -DFASTEST to get compression code optimized for speed only
+- in minigzip, try mmap'ing the input file first (Miguel Albrecht)
+- increase size of I/O buffers in minigzip.c and gzio.c (not a big gain
+ on Sun but significant on HP)
+
+- add a pointer to experimental unzip library in README (Gilles Vollant)
+- initialize variable gcc in configure (Chris Herborth)
+
+Changes in 1.0.9 (17 Feb 1998)
+- added gzputs and gzgets functions
+- do not clear eof flag in gzseek (Mark Diekhans)
+- fix gzseek for files in transparent mode (Mark Diekhans)
+- do not assume that vsprintf returns the number of bytes written (Jens Krinke)
+- replace EXPORT with ZEXPORT to avoid conflict with other programs
+- added compress2 in zconf.h, zlib.def, zlib.dnt
+- new asm code from Gilles Vollant in contrib/asm386
+- simplify the inflate code (Mark):
+ . Replace ZALLOC's in huft_build() with single ZALLOC in inflate_blocks_new()
+ . ZALLOC the length list in inflate_trees_fixed() instead of using stack
+ . ZALLOC the value area for huft_build() instead of using stack
+ . Simplify Z_FINISH check in inflate()
+
+- Avoid gcc 2.8.0 comparison bug a little differently than zlib 1.0.8
+- in inftrees.c, avoid cc -O bug on HP (Farshid Elahi)
+- in zconf.h move the ZLIB_DLL stuff earlier to avoid problems with
+ the declaration of FAR (Gilles VOllant)
+- install libz.so* with mode 755 (executable) instead of 644 (Marc Lehmann)
+- read_buf buf parameter of type Bytef* instead of charf*
+- zmemcpy parameters are of type Bytef*, not charf* (Joseph Strout)
+- do not redeclare unlink in minigzip.c for WIN32 (John Bowler)
+- fix check for presence of directories in "make install" (Ian Willis)
+
+Changes in 1.0.8 (27 Jan 1998)
+- fixed offsets in contrib/asm386/gvmat32.asm (Gilles Vollant)
+- fix gzgetc and gzputc for big endian systems (Markus Oberhumer)
+- added compress2() to allow setting the compression level
+- include sys/types.h to get off_t on some systems (Marc Lehmann & QingLong)
+- use constant arrays for the static trees in trees.c instead of computing
+ them at run time (thanks to Ken Raeburn for this suggestion). To create
+ trees.h, compile with GEN_TREES_H and run "make test".
+- check return code of example in "make test" and display result
+- pass minigzip command line options to file_compress
+- simplifying code of inflateSync to avoid gcc 2.8 bug
+
+- support CC="gcc -Wall" in configure -s (QingLong)
+- avoid a flush caused by ftell in gzopen for write mode (Ken Raeburn)
+- fix test for shared library support to avoid compiler warnings
+- zlib.lib -> zlib.dll in msdos/zlib.rc (Gilles Vollant)
+- check for TARGET_OS_MAC in addition to MACOS (Brad Pettit)
+- do not use fdopen for Metrowerks on Mac (Brad Pettit))
+- add checks for gzputc and gzputc in example.c
+- avoid warnings in gzio.c and deflate.c (Andreas Kleinert)
+- use const for the CRC table (Ken Raeburn)
+- fixed "make uninstall" for shared libraries
+- use Tracev instead of Trace in infblock.c
+- in example.c use correct compressed length for test_sync
+- suppress +vnocompatwarnings in configure for HPUX (not always supported)
+
+Changes in 1.0.7 (20 Jan 1998)
+- fix gzseek which was broken in write mode
+- return error for gzseek to negative absolute position
+- fix configure for Linux (Chun-Chung Chen)
+- increase stack space for MSC (Tim Wegner)
+- get_crc_table and inflateSyncPoint are EXPORTed (Gilles Vollant)
+- define EXPORTVA for gzprintf (Gilles Vollant)
+- added man page zlib.3 (Rick Rodgers)
+- for contrib/untgz, fix makedir() and improve Makefile
+
+- check gzseek in write mode in example.c
+- allocate extra buffer for seeks only if gzseek is actually called
+- avoid signed/unsigned comparisons (Tim Wegner, Gilles Vollant)
+- add inflateSyncPoint in zconf.h
+- fix list of exported functions in nt/zlib.dnt and mdsos/zlib.def
+
+Changes in 1.0.6 (19 Jan 1998)
+- add functions gzprintf, gzputc, gzgetc, gztell, gzeof, gzseek, gzrewind and
+ gzsetparams (thanks to Roland Giersig and Kevin Ruland for some of this code)
+- Fix a deflate bug occurring only with compression level 0 (thanks to
+ Andy Buckler for finding this one).
+- In minigzip, pass transparently also the first byte for .Z files.
+- return Z_BUF_ERROR instead of Z_OK if output buffer full in uncompress()
+- check Z_FINISH in inflate (thanks to Marc Schluper)
+- Implement deflateCopy (thanks to Adam Costello)
+- make static libraries by default in configure, add --shared option.
+- move MSDOS or Windows specific files to directory msdos
+- suppress the notion of partial flush to simplify the interface
+ (but the symbol Z_PARTIAL_FLUSH is kept for compatibility with 1.0.4)
+- suppress history buffer provided by application to simplify the interface
+ (this feature was not implemented anyway in 1.0.4)
+- next_in and avail_in must be initialized before calling inflateInit or
+ inflateInit2
+- add EXPORT in all exported functions (for Windows DLL)
+- added Makefile.nt (thanks to Stephen Williams)
+- added the unsupported "contrib" directory:
+ contrib/asm386/ by Gilles Vollant <info@winimage.com>
+ 386 asm code replacing longest_match().
+ contrib/iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
+ A C++ I/O streams interface to the zlib gz* functions
+ contrib/iostream2/ by Tyge Løvset <Tyge.Lovset@cmr.no>
+ Another C++ I/O streams interface
+ contrib/untgz/ by "Pedro A. Aranda Guti\irrez" <paag@tid.es>
+ A very simple tar.gz file extractor using zlib
+ contrib/visual-basic.txt by Carlos Rios <c_rios@sonda.cl>
+ How to use compress(), uncompress() and the gz* functions from VB.
+- pass params -f (filtered data), -h (huffman only), -1 to -9 (compression
+ level) in minigzip (thanks to Tom Lane)
+
+- use const for rommable constants in deflate
+- added test for gzseek and gztell in example.c
+- add undocumented function inflateSyncPoint() (hack for Paul Mackerras)
+- add undocumented function zError to convert error code to string
+ (for Tim Smithers)
+- Allow compilation of gzio with -DNO_DEFLATE to avoid the compression code.
+- Use default memcpy for Symantec MSDOS compiler.
+- Add EXPORT keyword for check_func (needed for Windows DLL)
+- add current directory to LD_LIBRARY_PATH for "make test"
+- create also a link for libz.so.1
+- added support for FUJITSU UXP/DS (thanks to Toshiaki Nomura)
+- use $(SHAREDLIB) instead of libz.so in Makefile.in (for HPUX)
+- added -soname for Linux in configure (Chun-Chung Chen,
+- assign numbers to the exported functions in zlib.def (for Windows DLL)
+- add advice in zlib.h for best usage of deflateSetDictionary
+- work around compiler bug on Atari (cast Z_NULL in call of s->checkfn)
+- allow compilation with ANSI keywords only enabled for TurboC in large model
+- avoid "versionString"[0] (Borland bug)
+- add NEED_DUMMY_RETURN for Borland
+- use variable z_verbose for tracing in debug mode (L. Peter Deutsch).
+- allow compilation with CC
+- defined STDC for OS/2 (David Charlap)
+- limit external names to 8 chars for MVS (Thomas Lund)
+- in minigzip.c, use static buffers only for 16-bit systems
+- fix suffix check for "minigzip -d foo.gz"
+- do not return an error for the 2nd of two consecutive gzflush() (Felix Lee)
+- use _fdopen instead of fdopen for MSC >= 6.0 (Thomas Fanslau)
+- added makelcc.bat for lcc-win32 (Tom St Denis)
+- in Makefile.dj2, use copy and del instead of install and rm (Frank Donahoe)
+- Avoid expanded $Id$. Use "rcs -kb" or "cvs admin -kb" to avoid Id expansion.
+- check for unistd.h in configure (for off_t)
+- remove useless check parameter in inflate_blocks_free
+- avoid useless assignment of s->check to itself in inflate_blocks_new
+- do not flush twice in gzclose (thanks to Ken Raeburn)
+- rename FOPEN as F_OPEN to avoid clash with /usr/include/sys/file.h
+- use NO_ERRNO_H instead of enumeration of operating systems with errno.h
+- work around buggy fclose on pipes for HP/UX
+- support zlib DLL with BORLAND C++ 5.0 (thanks to Glenn Randers-Pehrson)
+- fix configure if CC is already equal to gcc
+
+Changes in 1.0.5 (3 Jan 98)
+- Fix inflate to terminate gracefully when fed corrupted or invalid data
+- Use const for rommable constants in inflate
+- Eliminate memory leaks on error conditions in inflate
+- Removed some vestigial code in inflate
+- Update web address in README
+
+Changes in 1.0.4 (24 Jul 96)
+- In very rare conditions, deflate(s, Z_FINISH) could fail to produce an EOF
+ bit, so the decompressor could decompress all the correct data but went
+ on to attempt decompressing extra garbage data. This affected minigzip too.
+- zlibVersion and gzerror return const char* (needed for DLL)
+- port to RISCOS (no fdopen, no multiple dots, no unlink, no fileno)
+- use z_error only for DEBUG (avoid problem with DLLs)
+
+Changes in 1.0.3 (2 Jul 96)
+- use z_streamp instead of z_stream *, which is now a far pointer in MSDOS
+ small and medium models; this makes the library incompatible with previous
+ versions for these models. (No effect in large model or on other systems.)
+- return OK instead of BUF_ERROR if previous deflate call returned with
+ avail_out as zero but there is nothing to do
+- added memcmp for non STDC compilers
+- define NO_DUMMY_DECL for more Mac compilers (.h files merged incorrectly)
+- define __32BIT__ if __386__ or i386 is defined (pb. with Watcom and SCO)
+- better check for 16-bit mode MSC (avoids problem with Symantec)
+
+Changes in 1.0.2 (23 May 96)
+- added Windows DLL support
+- added a function zlibVersion (for the DLL support)
+- fixed declarations using Bytef in infutil.c (pb with MSDOS medium model)
+- Bytef is define's instead of typedef'd only for Borland C
+- avoid reading uninitialized memory in example.c
+- mention in README that the zlib format is now RFC1950
+- updated Makefile.dj2
+- added algorithm.doc
+
+Changes in 1.0.1 (20 May 96) [1.0 skipped to avoid confusion]
+- fix array overlay in deflate.c which sometimes caused bad compressed data
+- fix inflate bug with empty stored block
+- fix MSDOS medium model which was broken in 0.99
+- fix deflateParams() which could generate bad compressed data.
+- Bytef is define'd instead of typedef'ed (work around Borland bug)
+- added an INDEX file
+- new makefiles for DJGPP (Makefile.dj2), 32-bit Borland (Makefile.b32),
+ Watcom (Makefile.wat), Amiga SAS/C (Makefile.sas)
+- speed up adler32 for modern machines without auto-increment
+- added -ansi for IRIX in configure
+- static_init_done in trees.c is an int
+- define unlink as delete for VMS
+- fix configure for QNX
+- add configure branch for SCO and HPUX
+- avoid many warnings (unused variables, dead assignments, etc...)
+- no fdopen for BeOS
+- fix the Watcom fix for 32 bit mode (define FAR as empty)
+- removed redefinition of Byte for MKWERKS
+- work around an MWKERKS bug (incorrect merge of all .h files)
+
+Changes in 0.99 (27 Jan 96)
+- allow preset dictionary shared between compressor and decompressor
+- allow compression level 0 (no compression)
+- add deflateParams in zlib.h: allow dynamic change of compression level
+ and compression strategy.
+- test large buffers and deflateParams in example.c
+- add optional "configure" to build zlib as a shared library
+- suppress Makefile.qnx, use configure instead
+- fixed deflate for 64-bit systems (detected on Cray)
+- fixed inflate_blocks for 64-bit systems (detected on Alpha)
+- declare Z_DEFLATED in zlib.h (possible parameter for deflateInit2)
+- always return Z_BUF_ERROR when deflate() has nothing to do
+- deflateInit and inflateInit are now macros to allow version checking
+- prefix all global functions and types with z_ with -DZ_PREFIX
+- make falloc completely reentrant (inftrees.c)
+- fixed very unlikely race condition in ct_static_init
+- free in reverse order of allocation to help memory manager
+- use zlib-1.0/* instead of zlib/* inside the tar.gz
+- make zlib warning-free with "gcc -O3 -Wall -Wwrite-strings -Wpointer-arith
+ -Wconversion -Wstrict-prototypes -Wmissing-prototypes"
+- allow gzread on concatenated .gz files
+- deflateEnd now returns Z_DATA_ERROR if it was premature
+- deflate is finally (?) fully deterministic (no matches beyond end of input)
+- Document Z_SYNC_FLUSH
+- add uninstall in Makefile
+- Check for __cpluplus in zlib.h
+- Better test in ct_align for partial flush
+- avoid harmless warnings for Borland C++
+- initialize hash_head in deflate.c
+- avoid warning on fdopen (gzio.c) for HP cc -Aa
+- include stdlib.h for STDC compilers
+- include errno.h for Cray
+- ignore error if ranlib doesn't exist
+- call ranlib twice for NeXTSTEP
+- use exec_prefix instead of prefix for libz.a
+- renamed ct_* as _tr_* to avoid conflict with applications
+- clear z->msg in inflateInit2 before any error return
+- initialize opaque in example.c, gzio.c, deflate.c and inflate.c
+- fixed typo in zconf.h (_GNUC__ => __GNUC__)
+- check for WIN32 in zconf.h and zutil.c (avoid farmalloc in 32-bit mode)
+- fix typo in Make_vms.com (f$trnlnm -> f$getsyi)
+- in fcalloc, normalize pointer if size > 65520 bytes
+- don't use special fcalloc for 32 bit Borland C++
+- use STDC instead of __GO32__ to avoid redeclaring exit, calloc, etc...
+- use Z_BINARY instead of BINARY
+- document that gzclose after gzdopen will close the file
+- allow "a" as mode in gzopen.
+- fix error checking in gzread
+- allow skipping .gz extra-field on pipes
+- added reference to Perl interface in README
+- put the crc table in FAR data (I dislike more and more the medium model :)
+- added get_crc_table
+- added a dimension to all arrays (Borland C can't count).
+- workaround Borland C bug in declaration of inflate_codes_new & inflate_fast
+- guard against multiple inclusion of *.h (for precompiled header on Mac)
+- Watcom C pretends to be Microsoft C small model even in 32 bit mode.
+- don't use unsized arrays to avoid silly warnings by Visual C++:
+ warning C4746: 'inflate_mask' : unsized array treated as '__far'
+ (what's wrong with far data in far model?).
+- define enum out of inflate_blocks_state to allow compilation with C++
+
+Changes in 0.95 (16 Aug 95)
+- fix MSDOS small and medium model (now easier to adapt to any compiler)
+- inlined send_bits
+- fix the final (:-) bug for deflate with flush (output was correct but
+ not completely flushed in rare occasions).
+- default window size is same for compression and decompression
+ (it's now sufficient to set MAX_WBITS in zconf.h).
+- voidp -> voidpf and voidnp -> voidp (for consistency with other
+ typedefs and because voidnp was not near in large model).
+
+Changes in 0.94 (13 Aug 95)
+- support MSDOS medium model
+- fix deflate with flush (could sometimes generate bad output)
+- fix deflateReset (zlib header was incorrectly suppressed)
+- added support for VMS
+- allow a compression level in gzopen()
+- gzflush now calls fflush
+- For deflate with flush, flush even if no more input is provided.
+- rename libgz.a as libz.a
+- avoid complex expression in infcodes.c triggering Turbo C bug
+- work around a problem with gcc on Alpha (in INSERT_STRING)
+- don't use inline functions (problem with some gcc versions)
+- allow renaming of Byte, uInt, etc... with #define.
+- avoid warning about (unused) pointer before start of array in deflate.c
+- avoid various warnings in gzio.c, example.c, infblock.c, adler32.c, zutil.c
+- avoid reserved word 'new' in trees.c
+
+Changes in 0.93 (25 June 95)
+- temporarily disable inline functions
+- make deflate deterministic
+- give enough lookahead for PARTIAL_FLUSH
+- Set binary mode for stdin/stdout in minigzip.c for OS/2
+- don't even use signed char in inflate (not portable enough)
+- fix inflate memory leak for segmented architectures
+
+Changes in 0.92 (3 May 95)
+- don't assume that char is signed (problem on SGI)
+- Clear bit buffer when starting a stored block
+- no memcpy on Pyramid
+- suppressed inftest.c
+- optimized fill_window, put longest_match inline for gcc
+- optimized inflate on stored blocks.
+- untabify all sources to simplify patches
+
+Changes in 0.91 (2 May 95)
+- Default MEM_LEVEL is 8 (not 9 for Unix) as documented in zlib.h
+- Document the memory requirements in zconf.h
+- added "make install"
+- fix sync search logic in inflateSync
+- deflate(Z_FULL_FLUSH) now works even if output buffer too short
+- after inflateSync, don't scare people with just "lo world"
+- added support for DJGPP
+
+Changes in 0.9 (1 May 95)
+- don't assume that zalloc clears the allocated memory (the TurboC bug
+ was Mark's bug after all :)
+- let again gzread copy uncompressed data unchanged (was working in 0.71)
+- deflate(Z_FULL_FLUSH), inflateReset and inflateSync are now fully implemented
+- added a test of inflateSync in example.c
+- moved MAX_WBITS to zconf.h because users might want to change that.
+- document explicitly that zalloc(64K) on MSDOS must return a normalized
+ pointer (zero offset)
+- added Makefiles for Microsoft C, Turbo C, Borland C++
+- faster crc32()
+
+Changes in 0.8 (29 April 95)
+- added fast inflate (inffast.c)
+- deflate(Z_FINISH) now returns Z_STREAM_END when done. Warning: this
+ is incompatible with previous versions of zlib which returned Z_OK.
+- work around a TurboC compiler bug (bad code for b << 0, see infutil.h)
+ (actually that was not a compiler bug, see 0.81 above)
+- gzread no longer reads one extra byte in certain cases
+- In gzio destroy(), don't reference a freed structure
+- avoid many warnings for MSDOS
+- avoid the ERROR symbol which is used by MS Windows
+
+Changes in 0.71 (14 April 95)
+- Fixed more MSDOS compilation problems :( There is still a bug with
+ TurboC large model.
+
+Changes in 0.7 (14 April 95)
+- Added full inflate support.
+- Simplified the crc32() interface. The pre- and post-conditioning
+ (one's complement) is now done inside crc32(). WARNING: this is
+ incompatible with previous versions; see zlib.h for the new usage.
+
+Changes in 0.61 (12 April 95)
+- workaround for a bug in TurboC. example and minigzip now work on MSDOS.
+
+Changes in 0.6 (11 April 95)
+- added minigzip.c
+- added gzdopen to reopen a file descriptor as gzFile
+- added transparent reading of non-gziped files in gzread.
+- fixed bug in gzread (don't read crc as data)
+- fixed bug in destroy (gzio.c) (don't return Z_STREAM_END for gzclose).
+- don't allocate big arrays in the stack (for MSDOS)
+- fix some MSDOS compilation problems
+
+Changes in 0.5:
+- do real compression in deflate.c. Z_PARTIAL_FLUSH is supported but
+ not yet Z_FULL_FLUSH.
+- support decompression but only in a single step (forced Z_FINISH)
+- added opaque object for zalloc and zfree.
+- added deflateReset and inflateReset
+- added a variable zlib_version for consistency checking.
+- renamed the 'filter' parameter of deflateInit2 as 'strategy'.
+ Added Z_FILTERED and Z_HUFFMAN_ONLY constants.
+
+Changes in 0.4:
+- avoid "zip" everywhere, use zlib instead of ziplib.
+- suppress Z_BLOCK_FLUSH, interpret Z_PARTIAL_FLUSH as block flush
+ if compression method == 8.
+- added adler32 and crc32
+- renamed deflateOptions as deflateInit2, call one or the other but not both
+- added the method parameter for deflateInit2.
+- added inflateInit2
+- simplied considerably deflateInit and inflateInit by not supporting
+ user-provided history buffer. This is supported only in deflateInit2
+ and inflateInit2.
+
+Changes in 0.3:
+- prefix all macro names with Z_
+- use Z_FINISH instead of deflateEnd to finish compression.
+- added Z_HUFFMAN_ONLY
+- added gzerror()
diff --git a/zlib/FAQ b/zlib/FAQ
new file mode 100644
index 000000000..99b7cf92e
--- /dev/null
+++ b/zlib/FAQ
@@ -0,0 +1,368 @@
+
+ Frequently Asked Questions about zlib
+
+
+If your question is not there, please check the zlib home page
+http://zlib.net/ which may have more recent information.
+The lastest zlib FAQ is at http://zlib.net/zlib_faq.html
+
+
+ 1. Is zlib Y2K-compliant?
+
+ Yes. zlib doesn't handle dates.
+
+ 2. Where can I get a Windows DLL version?
+
+ The zlib sources can be compiled without change to produce a DLL. See the
+ file win32/DLL_FAQ.txt in the zlib distribution. Pointers to the
+ precompiled DLL are found in the zlib web site at http://zlib.net/ .
+
+ 3. Where can I get a Visual Basic interface to zlib?
+
+ See
+ * http://marknelson.us/1997/01/01/zlib-engine/
+ * win32/DLL_FAQ.txt in the zlib distribution
+
+ 4. compress() returns Z_BUF_ERROR.
+
+ Make sure that before the call of compress(), the length of the compressed
+ buffer is equal to the available size of the compressed buffer and not
+ zero. For Visual Basic, check that this parameter is passed by reference
+ ("as any"), not by value ("as long").
+
+ 5. deflate() or inflate() returns Z_BUF_ERROR.
+
+ Before making the call, make sure that avail_in and avail_out are not zero.
+ When setting the parameter flush equal to Z_FINISH, also make sure that
+ avail_out is big enough to allow processing all pending input. Note that a
+ Z_BUF_ERROR is not fatal--another call to deflate() or inflate() can be
+ made with more input or output space. A Z_BUF_ERROR may in fact be
+ unavoidable depending on how the functions are used, since it is not
+ possible to tell whether or not there is more output pending when
+ strm.avail_out returns with zero. See http://zlib.net/zlib_how.html for a
+ heavily annotated example.
+
+ 6. Where's the zlib documentation (man pages, etc.)?
+
+ It's in zlib.h . Examples of zlib usage are in the files test/example.c
+ and test/minigzip.c, with more in examples/ .
+
+ 7. Why don't you use GNU autoconf or libtool or ...?
+
+ Because we would like to keep zlib as a very small and simple package.
+ zlib is rather portable and doesn't need much configuration.
+
+ 8. I found a bug in zlib.
+
+ Most of the time, such problems are due to an incorrect usage of zlib.
+ Please try to reproduce the problem with a small program and send the
+ corresponding source to us at zlib@gzip.org . Do not send multi-megabyte
+ data files without prior agreement.
+
+ 9. Why do I get "undefined reference to gzputc"?
+
+ If "make test" produces something like
+
+ example.o(.text+0x154): undefined reference to `gzputc'
+
+ check that you don't have old files libz.* in /usr/lib, /usr/local/lib or
+ /usr/X11R6/lib. Remove any old versions, then do "make install".
+
+10. I need a Delphi interface to zlib.
+
+ See the contrib/delphi directory in the zlib distribution.
+
+11. Can zlib handle .zip archives?
+
+ Not by itself, no. See the directory contrib/minizip in the zlib
+ distribution.
+
+12. Can zlib handle .Z files?
+
+ No, sorry. You have to spawn an uncompress or gunzip subprocess, or adapt
+ the code of uncompress on your own.
+
+13. How can I make a Unix shared library?
+
+ By default a shared (and a static) library is built for Unix. So:
+
+ make distclean
+ ./configure
+ make
+
+14. How do I install a shared zlib library on Unix?
+
+ After the above, then:
+
+ make install
+
+ However, many flavors of Unix come with a shared zlib already installed.
+ Before going to the trouble of compiling a shared version of zlib and
+ trying to install it, you may want to check if it's already there! If you
+ can #include <zlib.h>, it's there. The -lz option will probably link to
+ it. You can check the version at the top of zlib.h or with the
+ ZLIB_VERSION symbol defined in zlib.h .
+
+15. I have a question about OttoPDF.
+
+ We are not the authors of OttoPDF. The real author is on the OttoPDF web
+ site: Joel Hainley, jhainley@myndkryme.com.
+
+16. Can zlib decode Flate data in an Adobe PDF file?
+
+ Yes. See http://www.pdflib.com/ . To modify PDF forms, see
+ http://sourceforge.net/projects/acroformtool/ .
+
+17. Why am I getting this "register_frame_info not found" error on Solaris?
+
+ After installing zlib 1.1.4 on Solaris 2.6, running applications using zlib
+ generates an error such as:
+
+ ld.so.1: rpm: fatal: relocation error: file /usr/local/lib/libz.so:
+ symbol __register_frame_info: referenced symbol not found
+
+ The symbol __register_frame_info is not part of zlib, it is generated by
+ the C compiler (cc or gcc). You must recompile applications using zlib
+ which have this problem. This problem is specific to Solaris. See
+ http://www.sunfreeware.com for Solaris versions of zlib and applications
+ using zlib.
+
+18. Why does gzip give an error on a file I make with compress/deflate?
+
+ The compress and deflate functions produce data in the zlib format, which
+ is different and incompatible with the gzip format. The gz* functions in
+ zlib on the other hand use the gzip format. Both the zlib and gzip formats
+ use the same compressed data format internally, but have different headers
+ and trailers around the compressed data.
+
+19. Ok, so why are there two different formats?
+
+ The gzip format was designed to retain the directory information about a
+ single file, such as the name and last modification date. The zlib format
+ on the other hand was designed for in-memory and communication channel
+ applications, and has a much more compact header and trailer and uses a
+ faster integrity check than gzip.
+
+20. Well that's nice, but how do I make a gzip file in memory?
+
+ You can request that deflate write the gzip format instead of the zlib
+ format using deflateInit2(). You can also request that inflate decode the
+ gzip format using inflateInit2(). Read zlib.h for more details.
+
+21. Is zlib thread-safe?
+
+ Yes. However any library routines that zlib uses and any application-
+ provided memory allocation routines must also be thread-safe. zlib's gz*
+ functions use stdio library routines, and most of zlib's functions use the
+ library memory allocation routines by default. zlib's *Init* functions
+ allow for the application to provide custom memory allocation routines.
+
+ Of course, you should only operate on any given zlib or gzip stream from a
+ single thread at a time.
+
+22. Can I use zlib in my commercial application?
+
+ Yes. Please read the license in zlib.h.
+
+23. Is zlib under the GNU license?
+
+ No. Please read the license in zlib.h.
+
+24. The license says that altered source versions must be "plainly marked". So
+ what exactly do I need to do to meet that requirement?
+
+ You need to change the ZLIB_VERSION and ZLIB_VERNUM #defines in zlib.h. In
+ particular, the final version number needs to be changed to "f", and an
+ identification string should be appended to ZLIB_VERSION. Version numbers
+ x.x.x.f are reserved for modifications to zlib by others than the zlib
+ maintainers. For example, if the version of the base zlib you are altering
+ is "1.2.3.4", then in zlib.h you should change ZLIB_VERNUM to 0x123f, and
+ ZLIB_VERSION to something like "1.2.3.f-zachary-mods-v3". You can also
+ update the version strings in deflate.c and inftrees.c.
+
+ For altered source distributions, you should also note the origin and
+ nature of the changes in zlib.h, as well as in ChangeLog and README, along
+ with the dates of the alterations. The origin should include at least your
+ name (or your company's name), and an email address to contact for help or
+ issues with the library.
+
+ Note that distributing a compiled zlib library along with zlib.h and
+ zconf.h is also a source distribution, and so you should change
+ ZLIB_VERSION and ZLIB_VERNUM and note the origin and nature of the changes
+ in zlib.h as you would for a full source distribution.
+
+25. Will zlib work on a big-endian or little-endian architecture, and can I
+ exchange compressed data between them?
+
+ Yes and yes.
+
+26. Will zlib work on a 64-bit machine?
+
+ Yes. It has been tested on 64-bit machines, and has no dependence on any
+ data types being limited to 32-bits in length. If you have any
+ difficulties, please provide a complete problem report to zlib@gzip.org
+
+27. Will zlib decompress data from the PKWare Data Compression Library?
+
+ No. The PKWare DCL uses a completely different compressed data format than
+ does PKZIP and zlib. However, you can look in zlib's contrib/blast
+ directory for a possible solution to your problem.
+
+28. Can I access data randomly in a compressed stream?
+
+ No, not without some preparation. If when compressing you periodically use
+ Z_FULL_FLUSH, carefully write all the pending data at those points, and
+ keep an index of those locations, then you can start decompression at those
+ points. You have to be careful to not use Z_FULL_FLUSH too often, since it
+ can significantly degrade compression. Alternatively, you can scan a
+ deflate stream once to generate an index, and then use that index for
+ random access. See examples/zran.c .
+
+29. Does zlib work on MVS, OS/390, CICS, etc.?
+
+ It has in the past, but we have not heard of any recent evidence. There
+ were working ports of zlib 1.1.4 to MVS, but those links no longer work.
+ If you know of recent, successful applications of zlib on these operating
+ systems, please let us know. Thanks.
+
+30. Is there some simpler, easier to read version of inflate I can look at to
+ understand the deflate format?
+
+ First off, you should read RFC 1951. Second, yes. Look in zlib's
+ contrib/puff directory.
+
+31. Does zlib infringe on any patents?
+
+ As far as we know, no. In fact, that was originally the whole point behind
+ zlib. Look here for some more information:
+
+ http://www.gzip.org/#faq11
+
+32. Can zlib work with greater than 4 GB of data?
+
+ Yes. inflate() and deflate() will process any amount of data correctly.
+ Each call of inflate() or deflate() is limited to input and output chunks
+ of the maximum value that can be stored in the compiler's "unsigned int"
+ type, but there is no limit to the number of chunks. Note however that the
+ strm.total_in and strm_total_out counters may be limited to 4 GB. These
+ counters are provided as a convenience and are not used internally by
+ inflate() or deflate(). The application can easily set up its own counters
+ updated after each call of inflate() or deflate() to count beyond 4 GB.
+ compress() and uncompress() may be limited to 4 GB, since they operate in a
+ single call. gzseek() and gztell() may be limited to 4 GB depending on how
+ zlib is compiled. See the zlibCompileFlags() function in zlib.h.
+
+ The word "may" appears several times above since there is a 4 GB limit only
+ if the compiler's "long" type is 32 bits. If the compiler's "long" type is
+ 64 bits, then the limit is 16 exabytes.
+
+33. Does zlib have any security vulnerabilities?
+
+ The only one that we are aware of is potentially in gzprintf(). If zlib is
+ compiled to use sprintf() or vsprintf(), then there is no protection
+ against a buffer overflow of an 8K string space (or other value as set by
+ gzbuffer()), other than the caller of gzprintf() assuring that the output
+ will not exceed 8K. On the other hand, if zlib is compiled to use
+ snprintf() or vsnprintf(), which should normally be the case, then there is
+ no vulnerability. The ./configure script will display warnings if an
+ insecure variation of sprintf() will be used by gzprintf(). Also the
+ zlibCompileFlags() function will return information on what variant of
+ sprintf() is used by gzprintf().
+
+ If you don't have snprintf() or vsnprintf() and would like one, you can
+ find a portable implementation here:
+
+ http://www.ijs.si/software/snprintf/
+
+ Note that you should be using the most recent version of zlib. Versions
+ 1.1.3 and before were subject to a double-free vulnerability, and versions
+ 1.2.1 and 1.2.2 were subject to an access exception when decompressing
+ invalid compressed data.
+
+34. Is there a Java version of zlib?
+
+ Probably what you want is to use zlib in Java. zlib is already included
+ as part of the Java SDK in the java.util.zip package. If you really want
+ a version of zlib written in the Java language, look on the zlib home
+ page for links: http://zlib.net/ .
+
+35. I get this or that compiler or source-code scanner warning when I crank it
+ up to maximally-pedantic. Can't you guys write proper code?
+
+ Many years ago, we gave up attempting to avoid warnings on every compiler
+ in the universe. It just got to be a waste of time, and some compilers
+ were downright silly as well as contradicted each other. So now, we simply
+ make sure that the code always works.
+
+36. Valgrind (or some similar memory access checker) says that deflate is
+ performing a conditional jump that depends on an uninitialized value.
+ Isn't that a bug?
+
+ No. That is intentional for performance reasons, and the output of deflate
+ is not affected. This only started showing up recently since zlib 1.2.x
+ uses malloc() by default for allocations, whereas earlier versions used
+ calloc(), which zeros out the allocated memory. Even though the code was
+ correct, versions 1.2.4 and later was changed to not stimulate these
+ checkers.
+
+37. Will zlib read the (insert any ancient or arcane format here) compressed
+ data format?
+
+ Probably not. Look in the comp.compression FAQ for pointers to various
+ formats and associated software.
+
+38. How can I encrypt/decrypt zip files with zlib?
+
+ zlib doesn't support encryption. The original PKZIP encryption is very
+ weak and can be broken with freely available programs. To get strong
+ encryption, use GnuPG, http://www.gnupg.org/ , which already includes zlib
+ compression. For PKZIP compatible "encryption", look at
+ http://www.info-zip.org/
+
+39. What's the difference between the "gzip" and "deflate" HTTP 1.1 encodings?
+
+ "gzip" is the gzip format, and "deflate" is the zlib format. They should
+ probably have called the second one "zlib" instead to avoid confusion with
+ the raw deflate compressed data format. While the HTTP 1.1 RFC 2616
+ correctly points to the zlib specification in RFC 1950 for the "deflate"
+ transfer encoding, there have been reports of servers and browsers that
+ incorrectly produce or expect raw deflate data per the deflate
+ specification in RFC 1951, most notably Microsoft. So even though the
+ "deflate" transfer encoding using the zlib format would be the more
+ efficient approach (and in fact exactly what the zlib format was designed
+ for), using the "gzip" transfer encoding is probably more reliable due to
+ an unfortunate choice of name on the part of the HTTP 1.1 authors.
+
+ Bottom line: use the gzip format for HTTP 1.1 encoding.
+
+40. Does zlib support the new "Deflate64" format introduced by PKWare?
+
+ No. PKWare has apparently decided to keep that format proprietary, since
+ they have not documented it as they have previous compression formats. In
+ any case, the compression improvements are so modest compared to other more
+ modern approaches, that it's not worth the effort to implement.
+
+41. I'm having a problem with the zip functions in zlib, can you help?
+
+ There are no zip functions in zlib. You are probably using minizip by
+ Giles Vollant, which is found in the contrib directory of zlib. It is not
+ part of zlib. In fact none of the stuff in contrib is part of zlib. The
+ files in there are not supported by the zlib authors. You need to contact
+ the authors of the respective contribution for help.
+
+42. The match.asm code in contrib is under the GNU General Public License.
+ Since it's part of zlib, doesn't that mean that all of zlib falls under the
+ GNU GPL?
+
+ No. The files in contrib are not part of zlib. They were contributed by
+ other authors and are provided as a convenience to the user within the zlib
+ distribution. Each item in contrib has its own license.
+
+43. Is zlib subject to export controls? What is its ECCN?
+
+ zlib is not subject to export controls, and so is classified as EAR99.
+
+44. Can you please sign these lengthy legal documents and fax them back to us
+ so that we can use your software in our product?
+
+ No. Go away. Shoo.
diff --git a/zlib/INDEX b/zlib/INDEX
new file mode 100644
index 000000000..2ba064120
--- /dev/null
+++ b/zlib/INDEX
@@ -0,0 +1,68 @@
+CMakeLists.txt cmake build file
+ChangeLog history of changes
+FAQ Frequently Asked Questions about zlib
+INDEX this file
+Makefile dummy Makefile that tells you to ./configure
+Makefile.in template for Unix Makefile
+README guess what
+configure configure script for Unix
+make_vms.com makefile for VMS
+test/example.c zlib usages examples for build testing
+test/minigzip.c minimal gzip-like functionality for build testing
+test/infcover.c inf*.c code coverage for build coverage testing
+treebuild.xml XML description of source file dependencies
+zconf.h.cmakein zconf.h template for cmake
+zconf.h.in zconf.h template for configure
+zlib.3 Man page for zlib
+zlib.3.pdf Man page in PDF format
+zlib.map Linux symbol information
+zlib.pc.in Template for pkg-config descriptor
+zlib.pc.cmakein zlib.pc template for cmake
+zlib2ansi perl script to convert source files for C++ compilation
+
+amiga/ makefiles for Amiga SAS C
+as400/ makefiles for AS/400
+doc/ documentation for formats and algorithms
+msdos/ makefiles for MSDOS
+nintendods/ makefile for Nintendo DS
+old/ makefiles for various architectures and zlib documentation
+ files that have not yet been updated for zlib 1.2.x
+qnx/ makefiles for QNX
+watcom/ makefiles for OpenWatcom
+win32/ makefiles for Windows
+
+ zlib public header files (required for library use):
+zconf.h
+zlib.h
+
+ private source files used to build the zlib library:
+adler32.c
+compress.c
+crc32.c
+crc32.h
+deflate.c
+deflate.h
+gzclose.c
+gzguts.h
+gzlib.c
+gzread.c
+gzwrite.c
+infback.c
+inffast.c
+inffast.h
+inffixed.h
+inflate.c
+inflate.h
+inftrees.c
+inftrees.h
+trees.c
+trees.h
+uncompr.c
+zutil.c
+zutil.h
+
+ source files for sample programs
+See examples/README.examples
+
+ unsupported contributions by third parties
+See contrib/README.contrib
diff --git a/zlib/Makefile b/zlib/Makefile
new file mode 100644
index 000000000..6bba86c73
--- /dev/null
+++ b/zlib/Makefile
@@ -0,0 +1,5 @@
+all:
+ -@echo "Please use ./configure first. Thank you."
+
+distclean:
+ make -f Makefile.in distclean
diff --git a/zlib/Makefile.in b/zlib/Makefile.in
new file mode 100644
index 000000000..5a77949ff
--- /dev/null
+++ b/zlib/Makefile.in
@@ -0,0 +1,410 @@
+# Makefile for zlib
+# Copyright (C) 1995-2017 Jean-loup Gailly, Mark Adler
+# For conditions of distribution and use, see copyright notice in zlib.h
+
+# To compile and test, type:
+# ./configure; make test
+# Normally configure builds both a static and a shared library.
+# If you want to build just a static library, use: ./configure --static
+
+# To use the asm code, type:
+# cp contrib/asm?86/match.S ./match.S
+# make LOC=-DASMV OBJA=match.o
+
+# To install /usr/local/lib/libz.* and /usr/local/include/zlib.h, type:
+# make install
+# To install in $HOME instead of /usr/local, use:
+# make install prefix=$HOME
+
+CC=cc
+
+CFLAGS=-O
+#CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7
+#CFLAGS=-g -DZLIB_DEBUG
+#CFLAGS=-O3 -Wall -Wwrite-strings -Wpointer-arith -Wconversion \
+# -Wstrict-prototypes -Wmissing-prototypes
+
+SFLAGS=-O
+LDFLAGS=
+TEST_LDFLAGS=-L. libz.a
+LDSHARED=$(CC)
+CPP=$(CC) -E
+
+STATICLIB=libz.a
+SHAREDLIB=libz.so
+SHAREDLIBV=libz.so.1.2.11
+SHAREDLIBM=libz.so.1
+LIBS=$(STATICLIB) $(SHAREDLIBV)
+
+AR=ar
+ARFLAGS=rc
+RANLIB=ranlib
+LDCONFIG=ldconfig
+LDSHAREDLIBC=-lc
+TAR=tar
+SHELL=/bin/sh
+EXE=
+
+prefix = /usr/local
+exec_prefix = ${prefix}
+libdir = ${exec_prefix}/lib
+sharedlibdir = ${libdir}
+includedir = ${prefix}/include
+mandir = ${prefix}/share/man
+man3dir = ${mandir}/man3
+pkgconfigdir = ${libdir}/pkgconfig
+SRCDIR=
+ZINC=
+ZINCOUT=-I.
+
+OBJZ = adler32.o crc32.o deflate.o infback.o inffast.o inflate.o inftrees.o trees.o zutil.o
+OBJG = compress.o uncompr.o gzclose.o gzlib.o gzread.o gzwrite.o
+OBJC = $(OBJZ) $(OBJG)
+
+PIC_OBJZ = adler32.lo crc32.lo deflate.lo infback.lo inffast.lo inflate.lo inftrees.lo trees.lo zutil.lo
+PIC_OBJG = compress.lo uncompr.lo gzclose.lo gzlib.lo gzread.lo gzwrite.lo
+PIC_OBJC = $(PIC_OBJZ) $(PIC_OBJG)
+
+# to use the asm code: make OBJA=match.o, PIC_OBJA=match.lo
+OBJA =
+PIC_OBJA =
+
+OBJS = $(OBJC) $(OBJA)
+
+PIC_OBJS = $(PIC_OBJC) $(PIC_OBJA)
+
+all: static shared
+
+static: example$(EXE) minigzip$(EXE)
+
+shared: examplesh$(EXE) minigzipsh$(EXE)
+
+all64: example64$(EXE) minigzip64$(EXE)
+
+check: test
+
+test: all teststatic testshared
+
+teststatic: static
+ @TMPST=tmpst_$$; \
+ if echo hello world | ./minigzip | ./minigzip -d && ./example $$TMPST ; then \
+ echo ' *** zlib test OK ***'; \
+ else \
+ echo ' *** zlib test FAILED ***'; false; \
+ fi; \
+ rm -f $$TMPST
+
+testshared: shared
+ @LD_LIBRARY_PATH=`pwd`:$(LD_LIBRARY_PATH) ; export LD_LIBRARY_PATH; \
+ LD_LIBRARYN32_PATH=`pwd`:$(LD_LIBRARYN32_PATH) ; export LD_LIBRARYN32_PATH; \
+ DYLD_LIBRARY_PATH=`pwd`:$(DYLD_LIBRARY_PATH) ; export DYLD_LIBRARY_PATH; \
+ SHLIB_PATH=`pwd`:$(SHLIB_PATH) ; export SHLIB_PATH; \
+ TMPSH=tmpsh_$$; \
+ if echo hello world | ./minigzipsh | ./minigzipsh -d && ./examplesh $$TMPSH; then \
+ echo ' *** zlib shared test OK ***'; \
+ else \
+ echo ' *** zlib shared test FAILED ***'; false; \
+ fi; \
+ rm -f $$TMPSH
+
+test64: all64
+ @TMP64=tmp64_$$; \
+ if echo hello world | ./minigzip64 | ./minigzip64 -d && ./example64 $$TMP64; then \
+ echo ' *** zlib 64-bit test OK ***'; \
+ else \
+ echo ' *** zlib 64-bit test FAILED ***'; false; \
+ fi; \
+ rm -f $$TMP64
+
+infcover.o: $(SRCDIR)test/infcover.c $(SRCDIR)zlib.h zconf.h
+ $(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/infcover.c
+
+infcover: infcover.o libz.a
+ $(CC) $(CFLAGS) -o $@ infcover.o libz.a
+
+cover: infcover
+ rm -f *.gcda
+ ./infcover
+ gcov inf*.c
+
+libz.a: $(OBJS)
+ $(AR) $(ARFLAGS) $@ $(OBJS)
+ -@ ($(RANLIB) $@ || true) >/dev/null 2>&1
+
+match.o: match.S
+ $(CPP) match.S > _match.s
+ $(CC) -c _match.s
+ mv _match.o match.o
+ rm -f _match.s
+
+match.lo: match.S
+ $(CPP) match.S > _match.s
+ $(CC) -c -fPIC _match.s
+ mv _match.o match.lo
+ rm -f _match.s
+
+example.o: $(SRCDIR)test/example.c $(SRCDIR)zlib.h zconf.h
+ $(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/example.c
+
+minigzip.o: $(SRCDIR)test/minigzip.c $(SRCDIR)zlib.h zconf.h
+ $(CC) $(CFLAGS) $(ZINCOUT) -c -o $@ $(SRCDIR)test/minigzip.c
+
+example64.o: $(SRCDIR)test/example.c $(SRCDIR)zlib.h zconf.h
+ $(CC) $(CFLAGS) $(ZINCOUT) -D_FILE_OFFSET_BITS=64 -c -o $@ $(SRCDIR)test/example.c
+
+minigzip64.o: $(SRCDIR)test/minigzip.c $(SRCDIR)zlib.h zconf.h
+ $(CC) $(CFLAGS) $(ZINCOUT) -D_FILE_OFFSET_BITS=64 -c -o $@ $(SRCDIR)test/minigzip.c
+
+
+adler32.o: $(SRCDIR)adler32.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)adler32.c
+
+crc32.o: $(SRCDIR)crc32.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)crc32.c
+
+deflate.o: $(SRCDIR)deflate.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)deflate.c
+
+infback.o: $(SRCDIR)infback.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)infback.c
+
+inffast.o: $(SRCDIR)inffast.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)inffast.c
+
+inflate.o: $(SRCDIR)inflate.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)inflate.c
+
+inftrees.o: $(SRCDIR)inftrees.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)inftrees.c
+
+trees.o: $(SRCDIR)trees.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)trees.c
+
+zutil.o: $(SRCDIR)zutil.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)zutil.c
+
+compress.o: $(SRCDIR)compress.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)compress.c
+
+uncompr.o: $(SRCDIR)uncompr.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)uncompr.c
+
+gzclose.o: $(SRCDIR)gzclose.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzclose.c
+
+gzlib.o: $(SRCDIR)gzlib.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzlib.c
+
+gzread.o: $(SRCDIR)gzread.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzread.c
+
+gzwrite.o: $(SRCDIR)gzwrite.c
+ $(CC) $(CFLAGS) $(ZINC) -c -o $@ $(SRCDIR)gzwrite.c
+
+
+adler32.lo: $(SRCDIR)adler32.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/adler32.o $(SRCDIR)adler32.c
+ -@mv objs/adler32.o $@
+
+crc32.lo: $(SRCDIR)crc32.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/crc32.o $(SRCDIR)crc32.c
+ -@mv objs/crc32.o $@
+
+deflate.lo: $(SRCDIR)deflate.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/deflate.o $(SRCDIR)deflate.c
+ -@mv objs/deflate.o $@
+
+infback.lo: $(SRCDIR)infback.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/infback.o $(SRCDIR)infback.c
+ -@mv objs/infback.o $@
+
+inffast.lo: $(SRCDIR)inffast.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/inffast.o $(SRCDIR)inffast.c
+ -@mv objs/inffast.o $@
+
+inflate.lo: $(SRCDIR)inflate.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/inflate.o $(SRCDIR)inflate.c
+ -@mv objs/inflate.o $@
+
+inftrees.lo: $(SRCDIR)inftrees.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/inftrees.o $(SRCDIR)inftrees.c
+ -@mv objs/inftrees.o $@
+
+trees.lo: $(SRCDIR)trees.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/trees.o $(SRCDIR)trees.c
+ -@mv objs/trees.o $@
+
+zutil.lo: $(SRCDIR)zutil.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/zutil.o $(SRCDIR)zutil.c
+ -@mv objs/zutil.o $@
+
+compress.lo: $(SRCDIR)compress.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/compress.o $(SRCDIR)compress.c
+ -@mv objs/compress.o $@
+
+uncompr.lo: $(SRCDIR)uncompr.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/uncompr.o $(SRCDIR)uncompr.c
+ -@mv objs/uncompr.o $@
+
+gzclose.lo: $(SRCDIR)gzclose.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzclose.o $(SRCDIR)gzclose.c
+ -@mv objs/gzclose.o $@
+
+gzlib.lo: $(SRCDIR)gzlib.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzlib.o $(SRCDIR)gzlib.c
+ -@mv objs/gzlib.o $@
+
+gzread.lo: $(SRCDIR)gzread.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzread.o $(SRCDIR)gzread.c
+ -@mv objs/gzread.o $@
+
+gzwrite.lo: $(SRCDIR)gzwrite.c
+ -@mkdir objs 2>/dev/null || test -d objs
+ $(CC) $(SFLAGS) $(ZINC) -DPIC -c -o objs/gzwrite.o $(SRCDIR)gzwrite.c
+ -@mv objs/gzwrite.o $@
+
+
+placebo $(SHAREDLIBV): $(PIC_OBJS) libz.a
+ $(LDSHARED) $(SFLAGS) -o $@ $(PIC_OBJS) $(LDSHAREDLIBC) $(LDFLAGS)
+ rm -f $(SHAREDLIB) $(SHAREDLIBM)
+ ln -s $@ $(SHAREDLIB)
+ ln -s $@ $(SHAREDLIBM)
+ -@rmdir objs
+
+example$(EXE): example.o $(STATICLIB)
+ $(CC) $(CFLAGS) -o $@ example.o $(TEST_LDFLAGS)
+
+minigzip$(EXE): minigzip.o $(STATICLIB)
+ $(CC) $(CFLAGS) -o $@ minigzip.o $(TEST_LDFLAGS)
+
+examplesh$(EXE): example.o $(SHAREDLIBV)
+ $(CC) $(CFLAGS) -o $@ example.o -L. $(SHAREDLIBV)
+
+minigzipsh$(EXE): minigzip.o $(SHAREDLIBV)
+ $(CC) $(CFLAGS) -o $@ minigzip.o -L. $(SHAREDLIBV)
+
+example64$(EXE): example64.o $(STATICLIB)
+ $(CC) $(CFLAGS) -o $@ example64.o $(TEST_LDFLAGS)
+
+minigzip64$(EXE): minigzip64.o $(STATICLIB)
+ $(CC) $(CFLAGS) -o $@ minigzip64.o $(TEST_LDFLAGS)
+
+install-libs: $(LIBS)
+ -@if [ ! -d $(DESTDIR)$(exec_prefix) ]; then mkdir -p $(DESTDIR)$(exec_prefix); fi
+ -@if [ ! -d $(DESTDIR)$(libdir) ]; then mkdir -p $(DESTDIR)$(libdir); fi
+ -@if [ ! -d $(DESTDIR)$(sharedlibdir) ]; then mkdir -p $(DESTDIR)$(sharedlibdir); fi
+ -@if [ ! -d $(DESTDIR)$(man3dir) ]; then mkdir -p $(DESTDIR)$(man3dir); fi
+ -@if [ ! -d $(DESTDIR)$(pkgconfigdir) ]; then mkdir -p $(DESTDIR)$(pkgconfigdir); fi
+ rm -f $(DESTDIR)$(libdir)/$(STATICLIB)
+ cp $(STATICLIB) $(DESTDIR)$(libdir)
+ chmod 644 $(DESTDIR)$(libdir)/$(STATICLIB)
+ -@($(RANLIB) $(DESTDIR)$(libdir)/libz.a || true) >/dev/null 2>&1
+ -@if test -n "$(SHAREDLIBV)"; then \
+ rm -f $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBV); \
+ cp $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir); \
+ echo "cp $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir)"; \
+ chmod 755 $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBV); \
+ echo "chmod 755 $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBV)"; \
+ rm -f $(DESTDIR)$(sharedlibdir)/$(SHAREDLIB) $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBM); \
+ ln -s $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir)/$(SHAREDLIB); \
+ ln -s $(SHAREDLIBV) $(DESTDIR)$(sharedlibdir)/$(SHAREDLIBM); \
+ ($(LDCONFIG) || true) >/dev/null 2>&1; \
+ fi
+ rm -f $(DESTDIR)$(man3dir)/zlib.3
+ cp $(SRCDIR)zlib.3 $(DESTDIR)$(man3dir)
+ chmod 644 $(DESTDIR)$(man3dir)/zlib.3
+ rm -f $(DESTDIR)$(pkgconfigdir)/zlib.pc
+ cp zlib.pc $(DESTDIR)$(pkgconfigdir)
+ chmod 644 $(DESTDIR)$(pkgconfigdir)/zlib.pc
+# The ranlib in install is needed on NeXTSTEP which checks file times
+# ldconfig is for Linux
+
+install: install-libs
+ -@if [ ! -d $(DESTDIR)$(includedir) ]; then mkdir -p $(DESTDIR)$(includedir); fi
+ rm -f $(DESTDIR)$(includedir)/zlib.h $(DESTDIR)$(includedir)/zconf.h
+ cp $(SRCDIR)zlib.h zconf.h $(DESTDIR)$(includedir)
+ chmod 644 $(DESTDIR)$(includedir)/zlib.h $(DESTDIR)$(includedir)/zconf.h
+
+uninstall:
+ cd $(DESTDIR)$(includedir) && rm -f zlib.h zconf.h
+ cd $(DESTDIR)$(libdir) && rm -f libz.a; \
+ if test -n "$(SHAREDLIBV)" -a -f $(SHAREDLIBV); then \
+ rm -f $(SHAREDLIBV) $(SHAREDLIB) $(SHAREDLIBM); \
+ fi
+ cd $(DESTDIR)$(man3dir) && rm -f zlib.3
+ cd $(DESTDIR)$(pkgconfigdir) && rm -f zlib.pc
+
+docs: zlib.3.pdf
+
+zlib.3.pdf: $(SRCDIR)zlib.3
+ groff -mandoc -f H -T ps $(SRCDIR)zlib.3 | ps2pdf - $@
+
+zconf.h.cmakein: $(SRCDIR)zconf.h.in
+ -@ TEMPFILE=zconfh_$$; \
+ echo "/#define ZCONF_H/ a\\\\\n#cmakedefine Z_PREFIX\\\\\n#cmakedefine Z_HAVE_UNISTD_H\n" >> $$TEMPFILE &&\
+ sed -f $$TEMPFILE $(SRCDIR)zconf.h.in > $@ &&\
+ touch -r $(SRCDIR)zconf.h.in $@ &&\
+ rm $$TEMPFILE
+
+zconf: $(SRCDIR)zconf.h.in
+ cp -p $(SRCDIR)zconf.h.in zconf.h
+
+mostlyclean: clean
+clean:
+ rm -f *.o *.lo *~ \
+ example$(EXE) minigzip$(EXE) examplesh$(EXE) minigzipsh$(EXE) \
+ example64$(EXE) minigzip64$(EXE) \
+ infcover \
+ libz.* foo.gz so_locations \
+ _match.s maketree contrib/infback9/*.o
+ rm -rf objs
+ rm -f *.gcda *.gcno *.gcov
+ rm -f contrib/infback9/*.gcda contrib/infback9/*.gcno contrib/infback9/*.gcov
+
+maintainer-clean: distclean
+distclean: clean zconf zconf.h.cmakein docs
+ rm -f Makefile zlib.pc configure.log
+ -@rm -f .DS_Store
+ @if [ -f Makefile.in ]; then \
+ printf 'all:\n\t-@echo "Please use ./configure first. Thank you."\n' > Makefile ; \
+ printf '\ndistclean:\n\tmake -f Makefile.in distclean\n' >> Makefile ; \
+ touch -r $(SRCDIR)Makefile.in Makefile ; fi
+ @if [ ! -f zconf.h.in ]; then rm -f zconf.h zconf.h.cmakein ; fi
+ @if [ ! -f zlib.3 ]; then rm -f zlib.3.pdf ; fi
+
+tags:
+ etags $(SRCDIR)*.[ch]
+
+adler32.o zutil.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
+gzclose.o gzlib.o gzread.o gzwrite.o: $(SRCDIR)zlib.h zconf.h $(SRCDIR)gzguts.h
+compress.o example.o minigzip.o uncompr.o: $(SRCDIR)zlib.h zconf.h
+crc32.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)crc32.h
+deflate.o: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
+infback.o inflate.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h $(SRCDIR)inffixed.h
+inffast.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h
+inftrees.o: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h
+trees.o: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)trees.h
+
+adler32.lo zutil.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
+gzclose.lo gzlib.lo gzread.lo gzwrite.lo: $(SRCDIR)zlib.h zconf.h $(SRCDIR)gzguts.h
+compress.lo example.lo minigzip.lo uncompr.lo: $(SRCDIR)zlib.h zconf.h
+crc32.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)crc32.h
+deflate.lo: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h
+infback.lo inflate.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h $(SRCDIR)inffixed.h
+inffast.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h $(SRCDIR)inflate.h $(SRCDIR)inffast.h
+inftrees.lo: $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)inftrees.h
+trees.lo: $(SRCDIR)deflate.h $(SRCDIR)zutil.h $(SRCDIR)zlib.h zconf.h $(SRCDIR)trees.h
diff --git a/zlib/README b/zlib/README
new file mode 100644
index 000000000..51106de47
--- /dev/null
+++ b/zlib/README
@@ -0,0 +1,115 @@
+ZLIB DATA COMPRESSION LIBRARY
+
+zlib 1.2.11 is a general purpose data compression library. All the code is
+thread safe. 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).
+
+All functions of the compression library are documented in the file zlib.h
+(volunteer to write man pages welcome, contact zlib@gzip.org). A usage example
+of the library is given in the file test/example.c which also tests that
+the library is working correctly. Another example is given in the file
+test/minigzip.c. The compression library itself is composed of all source
+files in the root directory.
+
+To compile all files and run the test program, follow the instructions given at
+the top of Makefile.in. In short "./configure; make test", and if that goes
+well, "make install" should work for most flavors of Unix. For Windows, use
+one of the special makefiles in win32/ or contrib/vstudio/ . For VMS, use
+make_vms.com.
+
+Questions about zlib should be sent to <zlib@gzip.org>, or to Gilles Vollant
+<info@winimage.com> for the Windows DLL version. The zlib home page is
+http://zlib.net/ . Before reporting a problem, please check this site to
+verify that you have the latest version of zlib; otherwise get the latest
+version and check whether the problem still exists or not.
+
+PLEASE read the zlib FAQ http://zlib.net/zlib_faq.html before asking for help.
+
+Mark Nelson <markn@ieee.org> wrote an article about zlib for the Jan. 1997
+issue of Dr. Dobb's Journal; a copy of the article is available at
+http://marknelson.us/1997/01/01/zlib-engine/ .
+
+The changes made in version 1.2.11 are documented in the file ChangeLog.
+
+Unsupported third party contributions are provided in directory contrib/ .
+
+zlib is available in Java using the java.util.zip package, documented at
+http://java.sun.com/developer/technicalArticles/Programming/compression/ .
+
+A Perl interface to zlib written by Paul Marquess <pmqs@cpan.org> is available
+at CPAN (Comprehensive Perl Archive Network) sites, including
+http://search.cpan.org/~pmqs/IO-Compress-Zlib/ .
+
+A Python interface to zlib written by A.M. Kuchling <amk@amk.ca> is
+available in Python 1.5 and later versions, see
+http://docs.python.org/library/zlib.html .
+
+zlib is built into tcl: http://wiki.tcl.tk/4610 .
+
+An experimental package to read and write files in .zip format, written on top
+of zlib by Gilles Vollant <info@winimage.com>, is available in the
+contrib/minizip directory of zlib.
+
+
+Notes for some targets:
+
+- For Windows DLL versions, please see win32/DLL_FAQ.txt
+
+- For 64-bit Irix, deflate.c must be compiled without any optimization. With
+ -O, one libpng test fails. The test works in 32 bit mode (with the -n32
+ compiler flag). The compiler bug has been reported to SGI.
+
+- zlib doesn't work with gcc 2.6.3 on a DEC 3000/300LX under OSF/1 2.1 it works
+ when compiled with cc.
+
+- On Digital Unix 4.0D (formely OSF/1) on AlphaServer, the cc option -std1 is
+ necessary to get gzprintf working correctly. This is done by configure.
+
+- zlib doesn't work on HP-UX 9.05 with some versions of /bin/cc. It works with
+ other compilers. Use "make test" to check your compiler.
+
+- gzdopen is not supported on RISCOS or BEOS.
+
+- For PalmOs, see http://palmzlib.sourceforge.net/
+
+
+Acknowledgments:
+
+ The deflate format used by zlib was defined by Phil Katz. The deflate and
+ zlib specifications were written by L. Peter Deutsch. Thanks to all the
+ people who reported problems and suggested various improvements in zlib; they
+ are too numerous to cite here.
+
+Copyright notice:
+
+ (C) 1995-2017 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
+
+If you use the zlib library in a product, we would appreciate *not* receiving
+lengthy legal documents to sign. The sources are provided for free but without
+warranty of any kind. The library has been entirely written by Jean-loup
+Gailly and Mark Adler; it does not include third-party code.
+
+If you redistribute modified sources, we would appreciate that you include in
+the file ChangeLog history information documenting your changes. Please read
+the FAQ for more information on the distribution of modified source versions.
diff --git a/zlib/adler32.c b/zlib/adler32.c
new file mode 100644
index 000000000..d0be4380a
--- /dev/null
+++ b/zlib/adler32.c
@@ -0,0 +1,186 @@
+/* adler32.c -- compute the Adler-32 checksum of a data stream
+ * Copyright (C) 1995-2011, 2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#include "zutil.h"
+
+local uLong adler32_combine_ OF((uLong adler1, uLong adler2, z_off64_t len2));
+
+#define BASE 65521U /* 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 long 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
+
+/* ========================================================================= */
+uLong ZEXPORT adler32_z(adler, buf, len)
+ uLong adler;
+ const Bytef *buf;
+ z_size_t len;
+{
+ unsigned long 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);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT adler32(adler, buf, len)
+ uLong adler;
+ const Bytef *buf;
+ uInt len;
+{
+ return adler32_z(adler, buf, len);
+}
+
+/* ========================================================================= */
+local uLong adler32_combine_(adler1, adler2, len2)
+ uLong adler1;
+ uLong adler2;
+ z_off64_t len2;
+{
+ unsigned long sum1;
+ unsigned long 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 >= ((unsigned long)BASE << 1)) sum2 -= ((unsigned long)BASE << 1);
+ if (sum2 >= BASE) sum2 -= BASE;
+ return sum1 | (sum2 << 16);
+}
+
+/* ========================================================================= */
+uLong ZEXPORT adler32_combine(adler1, adler2, len2)
+ uLong adler1;
+ uLong adler2;
+ z_off_t len2;
+{
+ return adler32_combine_(adler1, adler2, len2);
+}
+
+uLong ZEXPORT adler32_combine64(adler1, adler2, len2)
+ uLong adler1;
+ uLong 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 000000000..e2db404ab
--- /dev/null
+++ b/zlib/compress.c
@@ -0,0 +1,86 @@
+/* compress.c -- compress a memory buffer
+ * Copyright (C) 1995-2005, 2014, 2016 Jean-loup Gailly, Mark Adler
+ * 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;
+ uLongf *destLen;
+ const Bytef *source;
+ uLong sourceLen;
+ int level;
+{
+ z_stream stream;
+ int err;
+ const uInt max = (uInt)-1;
+ uLong left;
+
+ left = *destLen;
+ *destLen = 0;
+
+ stream.zalloc = (alloc_func)0;
+ stream.zfree = (free_func)0;
+ stream.opaque = (voidpf)0;
+
+ err = deflateInit(&stream, level);
+ if (err != Z_OK) return err;
+
+ stream.next_out = dest;
+ stream.avail_out = 0;
+ stream.next_in = (z_const Bytef *)source;
+ stream.avail_in = 0;
+
+ do {
+ if (stream.avail_out == 0) {
+ stream.avail_out = left > (uLong)max ? max : (uInt)left;
+ left -= stream.avail_out;
+ }
+ if (stream.avail_in == 0) {
+ stream.avail_in = sourceLen > (uLong)max ? max : (uInt)sourceLen;
+ sourceLen -= stream.avail_in;
+ }
+ err = deflate(&stream, sourceLen ? Z_NO_FLUSH : Z_FINISH);
+ } while (err == Z_OK);
+
+ *destLen = stream.total_out;
+ deflateEnd(&stream);
+ return err == Z_STREAM_END ? Z_OK : err;
+}
+
+/* ===========================================================================
+ */
+int ZEXPORT compress (dest, destLen, source, sourceLen)
+ Bytef *dest;
+ uLongf *destLen;
+ const Bytef *source;
+ uLong 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.
+ */
+uLong ZEXPORT compressBound (sourceLen)
+ uLong sourceLen;
+{
+ return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +
+ (sourceLen >> 25) + 13;
+}
diff --git a/zlib/configure b/zlib/configure
new file mode 100755
index 000000000..e974d1fd7
--- /dev/null
+++ b/zlib/configure
@@ -0,0 +1,921 @@
+#!/bin/sh
+# configure script for zlib.
+#
+# Normally configure builds both a static and a shared library.
+# If you want to build just a static library, use: ./configure --static
+#
+# To impose specific compiler or flags or install directory, use for example:
+# prefix=$HOME CC=cc CFLAGS="-O4" ./configure
+# or for csh/tcsh users:
+# (setenv prefix $HOME; setenv CC cc; setenv CFLAGS "-O4"; ./configure)
+
+# Incorrect settings of CC or CFLAGS may prevent creating a shared library.
+# If you have problems, try without defining CC and CFLAGS before reporting
+# an error.
+
+# start off configure.log
+echo -------------------- >> configure.log
+echo $0 $* >> configure.log
+date >> configure.log
+
+# get source directory
+SRCDIR=`dirname $0`
+if test $SRCDIR = "."; then
+ ZINC=""
+ ZINCOUT="-I."
+ SRCDIR=""
+else
+ ZINC='-include zconf.h'
+ ZINCOUT='-I. -I$(SRCDIR)'
+ SRCDIR="$SRCDIR/"
+fi
+
+# set command prefix for cross-compilation
+if [ -n "${CHOST}" ]; then
+ uname="`echo "${CHOST}" | sed -e 's/^[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)$/\1/' -e 's/^[^-]*-[^-]*-\([^-]*\)-.*$/\1/'`"
+ CROSS_PREFIX="${CHOST}-"
+fi
+
+# destination name for static library
+STATICLIB=libz.a
+
+# extract zlib version numbers from zlib.h
+VER=`sed -n -e '/VERSION "/s/.*"\(.*\)".*/\1/p' < ${SRCDIR}zlib.h`
+VER3=`sed -n -e '/VERSION "/s/.*"\([0-9]*\\.[0-9]*\\.[0-9]*\).*/\1/p' < ${SRCDIR}zlib.h`
+VER2=`sed -n -e '/VERSION "/s/.*"\([0-9]*\\.[0-9]*\)\\..*/\1/p' < ${SRCDIR}zlib.h`
+VER1=`sed -n -e '/VERSION "/s/.*"\([0-9]*\)\\..*/\1/p' < ${SRCDIR}zlib.h`
+
+# establish commands for library building
+if "${CROSS_PREFIX}ar" --version >/dev/null 2>/dev/null || test $? -lt 126; then
+ AR=${AR-"${CROSS_PREFIX}ar"}
+ test -n "${CROSS_PREFIX}" && echo Using ${AR} | tee -a configure.log
+else
+ AR=${AR-"ar"}
+ test -n "${CROSS_PREFIX}" && echo Using ${AR} | tee -a configure.log
+fi
+ARFLAGS=${ARFLAGS-"rc"}
+if "${CROSS_PREFIX}ranlib" --version >/dev/null 2>/dev/null || test $? -lt 126; then
+ RANLIB=${RANLIB-"${CROSS_PREFIX}ranlib"}
+ test -n "${CROSS_PREFIX}" && echo Using ${RANLIB} | tee -a configure.log
+else
+ RANLIB=${RANLIB-"ranlib"}
+fi
+if "${CROSS_PREFIX}nm" --version >/dev/null 2>/dev/null || test $? -lt 126; then
+ NM=${NM-"${CROSS_PREFIX}nm"}
+ test -n "${CROSS_PREFIX}" && echo Using ${NM} | tee -a configure.log
+else
+ NM=${NM-"nm"}
+fi
+
+# set defaults before processing command line options
+LDCONFIG=${LDCONFIG-"ldconfig"}
+LDSHAREDLIBC="${LDSHAREDLIBC--lc}"
+ARCHS=
+prefix=${prefix-/usr/local}
+exec_prefix=${exec_prefix-'${prefix}'}
+libdir=${libdir-'${exec_prefix}/lib'}
+sharedlibdir=${sharedlibdir-'${libdir}'}
+includedir=${includedir-'${prefix}/include'}
+mandir=${mandir-'${prefix}/share/man'}
+shared_ext='.so'
+shared=1
+solo=0
+cover=0
+zprefix=0
+zconst=0
+build64=0
+gcc=0
+warn=0
+debug=0
+old_cc="$CC"
+old_cflags="$CFLAGS"
+OBJC='$(OBJZ) $(OBJG)'
+PIC_OBJC='$(PIC_OBJZ) $(PIC_OBJG)'
+
+# leave this script, optionally in a bad way
+leave()
+{
+ if test "$*" != "0"; then
+ echo "** $0 aborting." | tee -a configure.log
+ fi
+ rm -f $test.[co] $test $test$shared_ext $test.gcno ./--version
+ echo -------------------- >> configure.log
+ echo >> configure.log
+ echo >> configure.log
+ exit $1
+}
+
+# process command line options
+while test $# -ge 1
+do
+case "$1" in
+ -h* | --help)
+ echo 'usage:' | tee -a configure.log
+ echo ' configure [--const] [--zprefix] [--prefix=PREFIX] [--eprefix=EXPREFIX]' | tee -a configure.log
+ echo ' [--static] [--64] [--libdir=LIBDIR] [--sharedlibdir=LIBDIR]' | tee -a configure.log
+ echo ' [--includedir=INCLUDEDIR] [--archs="-arch i386 -arch x86_64"]' | tee -a configure.log
+ exit 0 ;;
+ -p*=* | --prefix=*) prefix=`echo $1 | sed 's/.*=//'`; shift ;;
+ -e*=* | --eprefix=*) exec_prefix=`echo $1 | sed 's/.*=//'`; shift ;;
+ -l*=* | --libdir=*) libdir=`echo $1 | sed 's/.*=//'`; shift ;;
+ --sharedlibdir=*) sharedlibdir=`echo $1 | sed 's/.*=//'`; shift ;;
+ -i*=* | --includedir=*) includedir=`echo $1 | sed 's/.*=//'`;shift ;;
+ -u*=* | --uname=*) uname=`echo $1 | sed 's/.*=//'`;shift ;;
+ -p* | --prefix) prefix="$2"; shift; shift ;;
+ -e* | --eprefix) exec_prefix="$2"; shift; shift ;;
+ -l* | --libdir) libdir="$2"; shift; shift ;;
+ -i* | --includedir) includedir="$2"; shift; shift ;;
+ -s* | --shared | --enable-shared) shared=1; shift ;;
+ -t | --static) shared=0; shift ;;
+ --solo) solo=1; shift ;;
+ --cover) cover=1; shift ;;
+ -z* | --zprefix) zprefix=1; shift ;;
+ -6* | --64) build64=1; shift ;;
+ -a*=* | --archs=*) ARCHS=`echo $1 | sed 's/.*=//'`; shift ;;
+ --sysconfdir=*) echo "ignored option: --sysconfdir" | tee -a configure.log; shift ;;
+ --localstatedir=*) echo "ignored option: --localstatedir" | tee -a configure.log; shift ;;
+ -c* | --const) zconst=1; shift ;;
+ -w* | --warn) warn=1; shift ;;
+ -d* | --debug) debug=1; shift ;;
+ *)
+ echo "unknown option: $1" | tee -a configure.log
+ echo "$0 --help for help" | tee -a configure.log
+ leave 1;;
+ esac
+done
+
+# temporary file name
+test=ztest$$
+
+# put arguments in log, also put test file in log if used in arguments
+show()
+{
+ case "$*" in
+ *$test.c*)
+ echo === $test.c === >> configure.log
+ cat $test.c >> configure.log
+ echo === >> configure.log;;
+ esac
+ echo $* >> configure.log
+}
+
+# check for gcc vs. cc and set compile and link flags based on the system identified by uname
+cat > $test.c <<EOF
+extern int getchar();
+int hello() {return getchar();}
+EOF
+
+test -z "$CC" && echo Checking for ${CROSS_PREFIX}gcc... | tee -a configure.log
+cc=${CC-${CROSS_PREFIX}gcc}
+cflags=${CFLAGS-"-O3"}
+# to force the asm version use: CFLAGS="-O3 -DASMV" ./configure
+case "$cc" in
+ *gcc*) gcc=1 ;;
+ *clang*) gcc=1 ;;
+esac
+case `$cc -v 2>&1` in
+ *gcc*) gcc=1 ;;
+ *clang*) gcc=1 ;;
+esac
+
+show $cc -c $test.c
+if test "$gcc" -eq 1 && ($cc -c $test.c) >> configure.log 2>&1; then
+ echo ... using gcc >> configure.log
+ CC="$cc"
+ CFLAGS="${CFLAGS--O3}"
+ SFLAGS="${CFLAGS--O3} -fPIC"
+ if test "$ARCHS"; then
+ CFLAGS="${CFLAGS} ${ARCHS}"
+ LDFLAGS="${LDFLAGS} ${ARCHS}"
+ fi
+ if test $build64 -eq 1; then
+ CFLAGS="${CFLAGS} -m64"
+ SFLAGS="${SFLAGS} -m64"
+ fi
+ if test "$warn" -eq 1; then
+ if test "$zconst" -eq 1; then
+ CFLAGS="${CFLAGS} -Wall -Wextra -Wcast-qual -pedantic -DZLIB_CONST"
+ else
+ CFLAGS="${CFLAGS} -Wall -Wextra -pedantic"
+ fi
+ fi
+ if test $debug -eq 1; then
+ CFLAGS="${CFLAGS} -DZLIB_DEBUG"
+ SFLAGS="${SFLAGS} -DZLIB_DEBUG"
+ fi
+ if test -z "$uname"; then
+ uname=`(uname -s || echo unknown) 2>/dev/null`
+ fi
+ case "$uname" in
+ Linux* | linux* | GNU | GNU/* | solaris*)
+ LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,${SRCDIR}zlib.map"} ;;
+ *BSD | *bsd* | DragonFly)
+ LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1,--version-script,${SRCDIR}zlib.map"}
+ LDCONFIG="ldconfig -m" ;;
+ CYGWIN* | Cygwin* | cygwin* | OS/2*)
+ EXE='.exe' ;;
+ MINGW* | mingw*)
+# temporary bypass
+ rm -f $test.[co] $test $test$shared_ext
+ echo "Please use win32/Makefile.gcc instead." | tee -a configure.log
+ leave 1
+ LDSHARED=${LDSHARED-"$cc -shared"}
+ LDSHAREDLIBC=""
+ EXE='.exe' ;;
+ QNX*) # This is for QNX6. I suppose that the QNX rule below is for QNX2,QNX4
+ # (alain.bonnefoy@icbt.com)
+ LDSHARED=${LDSHARED-"$cc -shared -Wl,-hlibz.so.1"} ;;
+ HP-UX*)
+ LDSHARED=${LDSHARED-"$cc -shared $SFLAGS"}
+ case `(uname -m || echo unknown) 2>/dev/null` in
+ ia64)
+ shared_ext='.so'
+ SHAREDLIB='libz.so' ;;
+ *)
+ shared_ext='.sl'
+ SHAREDLIB='libz.sl' ;;
+ esac ;;
+ Darwin* | darwin*)
+ shared_ext='.dylib'
+ SHAREDLIB=libz$shared_ext
+ SHAREDLIBV=libz.$VER$shared_ext
+ SHAREDLIBM=libz.$VER1$shared_ext
+ LDSHARED=${LDSHARED-"$cc -dynamiclib -install_name $libdir/$SHAREDLIBM -compatibility_version $VER1 -current_version $VER3"}
+ if libtool -V 2>&1 | grep Apple > /dev/null; then
+ AR="libtool"
+ else
+ AR="/usr/bin/libtool"
+ fi
+ ARFLAGS="-o" ;;
+ *) LDSHARED=${LDSHARED-"$cc -shared"} ;;
+ esac
+else
+ # find system name and corresponding cc options
+ CC=${CC-cc}
+ gcc=0
+ echo ... using $CC >> configure.log
+ if test -z "$uname"; then
+ uname=`(uname -sr || echo unknown) 2>/dev/null`
+ fi
+ case "$uname" in
+ HP-UX*) SFLAGS=${CFLAGS-"-O +z"}
+ CFLAGS=${CFLAGS-"-O"}
+# LDSHARED=${LDSHARED-"ld -b +vnocompatwarnings"}
+ LDSHARED=${LDSHARED-"ld -b"}
+ case `(uname -m || echo unknown) 2>/dev/null` in
+ ia64)
+ shared_ext='.so'
+ SHAREDLIB='libz.so' ;;
+ *)
+ shared_ext='.sl'
+ SHAREDLIB='libz.sl' ;;
+ esac ;;
+ IRIX*) SFLAGS=${CFLAGS-"-ansi -O2 -rpath ."}
+ CFLAGS=${CFLAGS-"-ansi -O2"}
+ LDSHARED=${LDSHARED-"cc -shared -Wl,-soname,libz.so.1"} ;;
+ OSF1\ V4*) SFLAGS=${CFLAGS-"-O -std1"}
+ CFLAGS=${CFLAGS-"-O -std1"}
+ LDFLAGS="${LDFLAGS} -Wl,-rpath,."
+ LDSHARED=${LDSHARED-"cc -shared -Wl,-soname,libz.so -Wl,-msym -Wl,-rpath,$(libdir) -Wl,-set_version,${VER}:1.0"} ;;
+ OSF1*) SFLAGS=${CFLAGS-"-O -std1"}
+ CFLAGS=${CFLAGS-"-O -std1"}
+ LDSHARED=${LDSHARED-"cc -shared -Wl,-soname,libz.so.1"} ;;
+ QNX*) SFLAGS=${CFLAGS-"-4 -O"}
+ CFLAGS=${CFLAGS-"-4 -O"}
+ LDSHARED=${LDSHARED-"cc"}
+ RANLIB=${RANLIB-"true"}
+ AR="cc"
+ ARFLAGS="-A" ;;
+ SCO_SV\ 3.2*) SFLAGS=${CFLAGS-"-O3 -dy -KPIC "}
+ CFLAGS=${CFLAGS-"-O3"}
+ LDSHARED=${LDSHARED-"cc -dy -KPIC -G"} ;;
+ SunOS\ 5* | solaris*)
+ LDSHARED=${LDSHARED-"cc -G -h libz$shared_ext.$VER1"}
+ SFLAGS=${CFLAGS-"-fast -KPIC"}
+ CFLAGS=${CFLAGS-"-fast"}
+ if test $build64 -eq 1; then
+ # old versions of SunPRO/Workshop/Studio don't support -m64,
+ # but newer ones do. Check for it.
+ flag64=`$CC -flags | egrep -- '^-m64'`
+ if test x"$flag64" != x"" ; then
+ CFLAGS="${CFLAGS} -m64"
+ SFLAGS="${SFLAGS} -m64"
+ else
+ case `(uname -m || echo unknown) 2>/dev/null` in
+ i86*)
+ SFLAGS="$SFLAGS -xarch=amd64"
+ CFLAGS="$CFLAGS -xarch=amd64" ;;
+ *)
+ SFLAGS="$SFLAGS -xarch=v9"
+ CFLAGS="$CFLAGS -xarch=v9" ;;
+ esac
+ fi
+ fi
+ if test -n "$ZINC"; then
+ ZINC='-I- -I. -I$(SRCDIR)'
+ fi
+ ;;
+ SunOS\ 4*) SFLAGS=${CFLAGS-"-O2 -PIC"}
+ CFLAGS=${CFLAGS-"-O2"}
+ LDSHARED=${LDSHARED-"ld"} ;;
+ SunStudio\ 9*) SFLAGS=${CFLAGS-"-fast -xcode=pic32 -xtarget=ultra3 -xarch=v9b"}
+ CFLAGS=${CFLAGS-"-fast -xtarget=ultra3 -xarch=v9b"}
+ LDSHARED=${LDSHARED-"cc -xarch=v9b"} ;;
+ UNIX_System_V\ 4.2.0)
+ SFLAGS=${CFLAGS-"-KPIC -O"}
+ CFLAGS=${CFLAGS-"-O"}
+ LDSHARED=${LDSHARED-"cc -G"} ;;
+ UNIX_SV\ 4.2MP)
+ SFLAGS=${CFLAGS-"-Kconform_pic -O"}
+ CFLAGS=${CFLAGS-"-O"}
+ LDSHARED=${LDSHARED-"cc -G"} ;;
+ OpenUNIX\ 5)
+ SFLAGS=${CFLAGS-"-KPIC -O"}
+ CFLAGS=${CFLAGS-"-O"}
+ LDSHARED=${LDSHARED-"cc -G"} ;;
+ AIX*) # Courtesy of dbakker@arrayasolutions.com
+ SFLAGS=${CFLAGS-"-O -qmaxmem=8192"}
+ CFLAGS=${CFLAGS-"-O -qmaxmem=8192"}
+ LDSHARED=${LDSHARED-"xlc -G"} ;;
+ # send working options for other systems to zlib@gzip.org
+ *) SFLAGS=${CFLAGS-"-O"}
+ CFLAGS=${CFLAGS-"-O"}
+ LDSHARED=${LDSHARED-"cc -shared"} ;;
+ esac
+fi
+
+# destination names for shared library if not defined above
+SHAREDLIB=${SHAREDLIB-"libz$shared_ext"}
+SHAREDLIBV=${SHAREDLIBV-"libz$shared_ext.$VER"}
+SHAREDLIBM=${SHAREDLIBM-"libz$shared_ext.$VER1"}
+
+echo >> configure.log
+
+# define functions for testing compiler and library characteristics and logging the results
+
+cat > $test.c <<EOF
+#error error
+EOF
+if ($CC -c $CFLAGS $test.c) 2>/dev/null; then
+ try()
+ {
+ show $*
+ test "`( $* ) 2>&1 | tee -a configure.log`" = ""
+ }
+ echo - using any output from compiler to indicate an error >> configure.log
+else
+ try()
+ {
+ show $*
+ ( $* ) >> configure.log 2>&1
+ ret=$?
+ if test $ret -ne 0; then
+ echo "(exit code "$ret")" >> configure.log
+ fi
+ return $ret
+ }
+fi
+
+tryboth()
+{
+ show $*
+ got=`( $* ) 2>&1`
+ ret=$?
+ printf %s "$got" >> configure.log
+ if test $ret -ne 0; then
+ return $ret
+ fi
+ test "$got" = ""
+}
+
+cat > $test.c << EOF
+int foo() { return 0; }
+EOF
+echo "Checking for obsessive-compulsive compiler options..." >> configure.log
+if try $CC -c $CFLAGS $test.c; then
+ :
+else
+ echo "Compiler error reporting is too harsh for $0 (perhaps remove -Werror)." | tee -a configure.log
+ leave 1
+fi
+
+echo >> configure.log
+
+# see if shared library build supported
+cat > $test.c <<EOF
+extern int getchar();
+int hello() {return getchar();}
+EOF
+if test $shared -eq 1; then
+ echo Checking for shared library support... | tee -a configure.log
+ # we must test in two steps (cc then ld), required at least on SunOS 4.x
+ if try $CC -w -c $SFLAGS $test.c &&
+ try $LDSHARED $SFLAGS -o $test$shared_ext $test.o; then
+ echo Building shared library $SHAREDLIBV with $CC. | tee -a configure.log
+ elif test -z "$old_cc" -a -z "$old_cflags"; then
+ echo No shared library support. | tee -a configure.log
+ shared=0;
+ else
+ echo 'No shared library support; try without defining CC and CFLAGS' | tee -a configure.log
+ shared=0;
+ fi
+fi
+if test $shared -eq 0; then
+ LDSHARED="$CC"
+ ALL="static"
+ TEST="all teststatic"
+ SHAREDLIB=""
+ SHAREDLIBV=""
+ SHAREDLIBM=""
+ echo Building static library $STATICLIB version $VER with $CC. | tee -a configure.log
+else
+ ALL="static shared"
+ TEST="all teststatic testshared"
+fi
+
+# check for underscores in external names for use by assembler code
+CPP=${CPP-"$CC -E"}
+case $CFLAGS in
+ *ASMV*)
+ echo >> configure.log
+ show "$NM $test.o | grep _hello"
+ if test "`$NM $test.o | grep _hello | tee -a configure.log`" = ""; then
+ CPP="$CPP -DNO_UNDERLINE"
+ echo Checking for underline in external names... No. | tee -a configure.log
+ else
+ echo Checking for underline in external names... Yes. | tee -a configure.log
+ fi ;;
+esac
+
+echo >> configure.log
+
+# check for size_t
+cat > $test.c <<EOF
+#include <stdio.h>
+#include <stdlib.h>
+size_t dummy = 0;
+EOF
+if try $CC -c $CFLAGS $test.c; then
+ echo "Checking for size_t... Yes." | tee -a configure.log
+ need_sizet=0
+else
+ echo "Checking for size_t... No." | tee -a configure.log
+ need_sizet=1
+fi
+
+echo >> configure.log
+
+# find the size_t integer type, if needed
+if test $need_sizet -eq 1; then
+ cat > $test.c <<EOF
+long long dummy = 0;
+EOF
+ if try $CC -c $CFLAGS $test.c; then
+ echo "Checking for long long... Yes." | tee -a configure.log
+ cat > $test.c <<EOF
+#include <stdio.h>
+int main(void) {
+ if (sizeof(void *) <= sizeof(int)) puts("int");
+ else if (sizeof(void *) <= sizeof(long)) puts("long");
+ else puts("z_longlong");
+ return 0;
+}
+EOF
+ else
+ echo "Checking for long long... No." | tee -a configure.log
+ cat > $test.c <<EOF
+#include <stdio.h>
+int main(void) {
+ if (sizeof(void *) <= sizeof(int)) puts("int");
+ else puts("long");
+ return 0;
+}
+EOF
+ fi
+ if try $CC $CFLAGS -o $test $test.c; then
+ sizet=`./$test`
+ echo "Checking for a pointer-size integer type..." $sizet"." | tee -a configure.log
+ else
+ echo "Failed to find a pointer-size integer type." | tee -a configure.log
+ leave 1
+ fi
+fi
+
+if test $need_sizet -eq 1; then
+ CFLAGS="${CFLAGS} -DNO_SIZE_T=${sizet}"
+ SFLAGS="${SFLAGS} -DNO_SIZE_T=${sizet}"
+fi
+
+echo >> configure.log
+
+# check for large file support, and if none, check for fseeko()
+cat > $test.c <<EOF
+#include <sys/types.h>
+off64_t dummy = 0;
+EOF
+if try $CC -c $CFLAGS -D_LARGEFILE64_SOURCE=1 $test.c; then
+ CFLAGS="${CFLAGS} -D_LARGEFILE64_SOURCE=1"
+ SFLAGS="${SFLAGS} -D_LARGEFILE64_SOURCE=1"
+ ALL="${ALL} all64"
+ TEST="${TEST} test64"
+ echo "Checking for off64_t... Yes." | tee -a configure.log
+ echo "Checking for fseeko... Yes." | tee -a configure.log
+else
+ echo "Checking for off64_t... No." | tee -a configure.log
+ echo >> configure.log
+ cat > $test.c <<EOF
+#include <stdio.h>
+int main(void) {
+ fseeko(NULL, 0, 0);
+ return 0;
+}
+EOF
+ if try $CC $CFLAGS -o $test $test.c; then
+ echo "Checking for fseeko... Yes." | tee -a configure.log
+ else
+ CFLAGS="${CFLAGS} -DNO_FSEEKO"
+ SFLAGS="${SFLAGS} -DNO_FSEEKO"
+ echo "Checking for fseeko... No." | tee -a configure.log
+ fi
+fi
+
+echo >> configure.log
+
+# check for strerror() for use by gz* functions
+cat > $test.c <<EOF
+#include <string.h>
+#include <errno.h>
+int main() { return strlen(strerror(errno)); }
+EOF
+if try $CC $CFLAGS -o $test $test.c; then
+ echo "Checking for strerror... Yes." | tee -a configure.log
+else
+ CFLAGS="${CFLAGS} -DNO_STRERROR"
+ SFLAGS="${SFLAGS} -DNO_STRERROR"
+ echo "Checking for strerror... No." | tee -a configure.log
+fi
+
+# copy clean zconf.h for subsequent edits
+cp -p ${SRCDIR}zconf.h.in zconf.h
+
+echo >> configure.log
+
+# check for unistd.h and save result in zconf.h
+cat > $test.c <<EOF
+#include <unistd.h>
+int main() { return 0; }
+EOF
+if try $CC -c $CFLAGS $test.c; then
+ sed < zconf.h "/^#ifdef HAVE_UNISTD_H.* may be/s/def HAVE_UNISTD_H\(.*\) may be/ 1\1 was/" > zconf.temp.h
+ mv zconf.temp.h zconf.h
+ echo "Checking for unistd.h... Yes." | tee -a configure.log
+else
+ echo "Checking for unistd.h... No." | tee -a configure.log
+fi
+
+echo >> configure.log
+
+# check for stdarg.h and save result in zconf.h
+cat > $test.c <<EOF
+#include <stdarg.h>
+int main() { return 0; }
+EOF
+if try $CC -c $CFLAGS $test.c; then
+ sed < zconf.h "/^#ifdef HAVE_STDARG_H.* may be/s/def HAVE_STDARG_H\(.*\) may be/ 1\1 was/" > zconf.temp.h
+ mv zconf.temp.h zconf.h
+ echo "Checking for stdarg.h... Yes." | tee -a configure.log
+else
+ echo "Checking for stdarg.h... No." | tee -a configure.log
+fi
+
+# if the z_ prefix was requested, save that in zconf.h
+if test $zprefix -eq 1; then
+ sed < zconf.h "/#ifdef Z_PREFIX.* may be/s/def Z_PREFIX\(.*\) may be/ 1\1 was/" > zconf.temp.h
+ mv zconf.temp.h zconf.h
+ echo >> configure.log
+ echo "Using z_ prefix on all symbols." | tee -a configure.log
+fi
+
+# if --solo compilation was requested, save that in zconf.h and remove gz stuff from object lists
+if test $solo -eq 1; then
+ sed '/#define ZCONF_H/a\
+#define Z_SOLO
+
+' < zconf.h > zconf.temp.h
+ mv zconf.temp.h zconf.h
+OBJC='$(OBJZ)'
+PIC_OBJC='$(PIC_OBJZ)'
+fi
+
+# if code coverage testing was requested, use older gcc if defined, e.g. "gcc-4.2" on Mac OS X
+if test $cover -eq 1; then
+ CFLAGS="${CFLAGS} -fprofile-arcs -ftest-coverage"
+ if test -n "$GCC_CLASSIC"; then
+ CC=$GCC_CLASSIC
+ fi
+fi
+
+echo >> configure.log
+
+# conduct a series of tests to resolve eight possible cases of using "vs" or "s" printf functions
+# (using stdarg or not), with or without "n" (proving size of buffer), and with or without a
+# return value. The most secure result is vsnprintf() with a return value. snprintf() with a
+# return value is secure as well, but then gzprintf() will be limited to 20 arguments.
+cat > $test.c <<EOF
+#include <stdio.h>
+#include <stdarg.h>
+#include "zconf.h"
+int main()
+{
+#ifndef STDC
+ choke me
+#endif
+ return 0;
+}
+EOF
+if try $CC -c $CFLAGS $test.c; then
+ echo "Checking whether to use vs[n]printf() or s[n]printf()... using vs[n]printf()." | tee -a configure.log
+
+ echo >> configure.log
+ cat > $test.c <<EOF
+#include <stdio.h>
+#include <stdarg.h>
+int mytest(const char *fmt, ...)
+{
+ char buf[20];
+ va_list ap;
+ va_start(ap, fmt);
+ vsnprintf(buf, sizeof(buf), fmt, ap);
+ va_end(ap);
+ return 0;
+}
+int main()
+{
+ return (mytest("Hello%d\n", 1));
+}
+EOF
+ if try $CC $CFLAGS -o $test $test.c; then
+ echo "Checking for vsnprintf() in stdio.h... Yes." | tee -a configure.log
+
+ echo >> configure.log
+ cat >$test.c <<EOF
+#include <stdio.h>
+#include <stdarg.h>
+int mytest(const char *fmt, ...)
+{
+ int n;
+ char buf[20];
+ va_list ap;
+ va_start(ap, fmt);
+ n = vsnprintf(buf, sizeof(buf), fmt, ap);
+ va_end(ap);
+ return n;
+}
+int main()
+{
+ return (mytest("Hello%d\n", 1));
+}
+EOF
+
+ if try $CC -c $CFLAGS $test.c; then
+ echo "Checking for return value of vsnprintf()... Yes." | tee -a configure.log
+ else
+ CFLAGS="$CFLAGS -DHAS_vsnprintf_void"
+ SFLAGS="$SFLAGS -DHAS_vsnprintf_void"
+ echo "Checking for return value of vsnprintf()... No." | tee -a configure.log
+ echo " WARNING: apparently vsnprintf() does not return a value. zlib" | tee -a configure.log
+ echo " can build but will be open to possible string-format security" | tee -a configure.log
+ echo " vulnerabilities." | tee -a configure.log
+ fi
+ else
+ CFLAGS="$CFLAGS -DNO_vsnprintf"
+ SFLAGS="$SFLAGS -DNO_vsnprintf"
+ echo "Checking for vsnprintf() in stdio.h... No." | tee -a configure.log
+ echo " WARNING: vsnprintf() not found, falling back to vsprintf(). zlib" | tee -a configure.log
+ echo " can build but will be open to possible buffer-overflow security" | tee -a configure.log
+ echo " vulnerabilities." | tee -a configure.log
+
+ echo >> configure.log
+ cat >$test.c <<EOF
+#include <stdio.h>
+#include <stdarg.h>
+int mytest(const char *fmt, ...)
+{
+ int n;
+ char buf[20];
+ va_list ap;
+ va_start(ap, fmt);
+ n = vsprintf(buf, fmt, ap);
+ va_end(ap);
+ return n;
+}
+int main()
+{
+ return (mytest("Hello%d\n", 1));
+}
+EOF
+
+ if try $CC -c $CFLAGS $test.c; then
+ echo "Checking for return value of vsprintf()... Yes." | tee -a configure.log
+ else
+ CFLAGS="$CFLAGS -DHAS_vsprintf_void"
+ SFLAGS="$SFLAGS -DHAS_vsprintf_void"
+ echo "Checking for return value of vsprintf()... No." | tee -a configure.log
+ echo " WARNING: apparently vsprintf() does not return a value. zlib" | tee -a configure.log
+ echo " can build but will be open to possible string-format security" | tee -a configure.log
+ echo " vulnerabilities." | tee -a configure.log
+ fi
+ fi
+else
+ echo "Checking whether to use vs[n]printf() or s[n]printf()... using s[n]printf()." | tee -a configure.log
+
+ echo >> configure.log
+ cat >$test.c <<EOF
+#include <stdio.h>
+int mytest()
+{
+ char buf[20];
+ snprintf(buf, sizeof(buf), "%s", "foo");
+ return 0;
+}
+int main()
+{
+ return (mytest());
+}
+EOF
+
+ if try $CC $CFLAGS -o $test $test.c; then
+ echo "Checking for snprintf() in stdio.h... Yes." | tee -a configure.log
+
+ echo >> configure.log
+ cat >$test.c <<EOF
+#include <stdio.h>
+int mytest()
+{
+ char buf[20];
+ return snprintf(buf, sizeof(buf), "%s", "foo");
+}
+int main()
+{
+ return (mytest());
+}
+EOF
+
+ if try $CC -c $CFLAGS $test.c; then
+ echo "Checking for return value of snprintf()... Yes." | tee -a configure.log
+ else
+ CFLAGS="$CFLAGS -DHAS_snprintf_void"
+ SFLAGS="$SFLAGS -DHAS_snprintf_void"
+ echo "Checking for return value of snprintf()... No." | tee -a configure.log
+ echo " WARNING: apparently snprintf() does not return a value. zlib" | tee -a configure.log
+ echo " can build but will be open to possible string-format security" | tee -a configure.log
+ echo " vulnerabilities." | tee -a configure.log
+ fi
+ else
+ CFLAGS="$CFLAGS -DNO_snprintf"
+ SFLAGS="$SFLAGS -DNO_snprintf"
+ echo "Checking for snprintf() in stdio.h... No." | tee -a configure.log
+ echo " WARNING: snprintf() not found, falling back to sprintf(). zlib" | tee -a configure.log
+ echo " can build but will be open to possible buffer-overflow security" | tee -a configure.log
+ echo " vulnerabilities." | tee -a configure.log
+
+ echo >> configure.log
+ cat >$test.c <<EOF
+#include <stdio.h>
+int mytest()
+{
+ char buf[20];
+ return sprintf(buf, "%s", "foo");
+}
+int main()
+{
+ return (mytest());
+}
+EOF
+
+ if try $CC -c $CFLAGS $test.c; then
+ echo "Checking for return value of sprintf()... Yes." | tee -a configure.log
+ else
+ CFLAGS="$CFLAGS -DHAS_sprintf_void"
+ SFLAGS="$SFLAGS -DHAS_sprintf_void"
+ echo "Checking for return value of sprintf()... No." | tee -a configure.log
+ echo " WARNING: apparently sprintf() does not return a value. zlib" | tee -a configure.log
+ echo " can build but will be open to possible string-format security" | tee -a configure.log
+ echo " vulnerabilities." | tee -a configure.log
+ fi
+ fi
+fi
+
+# see if we can hide zlib internal symbols that are linked between separate source files
+if test "$gcc" -eq 1; then
+ echo >> configure.log
+ cat > $test.c <<EOF
+#define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
+int ZLIB_INTERNAL foo;
+int main()
+{
+ return 0;
+}
+EOF
+ if tryboth $CC -c $CFLAGS $test.c; then
+ CFLAGS="$CFLAGS -DHAVE_HIDDEN"
+ SFLAGS="$SFLAGS -DHAVE_HIDDEN"
+ echo "Checking for attribute(visibility) support... Yes." | tee -a configure.log
+ else
+ echo "Checking for attribute(visibility) support... No." | tee -a configure.log
+ fi
+fi
+
+# show the results in the log
+echo >> configure.log
+echo ALL = $ALL >> configure.log
+echo AR = $AR >> configure.log
+echo ARFLAGS = $ARFLAGS >> configure.log
+echo CC = $CC >> configure.log
+echo CFLAGS = $CFLAGS >> configure.log
+echo CPP = $CPP >> configure.log
+echo EXE = $EXE >> configure.log
+echo LDCONFIG = $LDCONFIG >> configure.log
+echo LDFLAGS = $LDFLAGS >> configure.log
+echo LDSHARED = $LDSHARED >> configure.log
+echo LDSHAREDLIBC = $LDSHAREDLIBC >> configure.log
+echo OBJC = $OBJC >> configure.log
+echo PIC_OBJC = $PIC_OBJC >> configure.log
+echo RANLIB = $RANLIB >> configure.log
+echo SFLAGS = $SFLAGS >> configure.log
+echo SHAREDLIB = $SHAREDLIB >> configure.log
+echo SHAREDLIBM = $SHAREDLIBM >> configure.log
+echo SHAREDLIBV = $SHAREDLIBV >> configure.log
+echo STATICLIB = $STATICLIB >> configure.log
+echo TEST = $TEST >> configure.log
+echo VER = $VER >> configure.log
+echo Z_U4 = $Z_U4 >> configure.log
+echo SRCDIR = $SRCDIR >> configure.log
+echo exec_prefix = $exec_prefix >> configure.log
+echo includedir = $includedir >> configure.log
+echo libdir = $libdir >> configure.log
+echo mandir = $mandir >> configure.log
+echo prefix = $prefix >> configure.log
+echo sharedlibdir = $sharedlibdir >> configure.log
+echo uname = $uname >> configure.log
+
+# udpate Makefile with the configure results
+sed < ${SRCDIR}Makefile.in "
+/^CC *=/s#=.*#=$CC#
+/^CFLAGS *=/s#=.*#=$CFLAGS#
+/^SFLAGS *=/s#=.*#=$SFLAGS#
+/^LDFLAGS *=/s#=.*#=$LDFLAGS#
+/^LDSHARED *=/s#=.*#=$LDSHARED#
+/^CPP *=/s#=.*#=$CPP#
+/^STATICLIB *=/s#=.*#=$STATICLIB#
+/^SHAREDLIB *=/s#=.*#=$SHAREDLIB#
+/^SHAREDLIBV *=/s#=.*#=$SHAREDLIBV#
+/^SHAREDLIBM *=/s#=.*#=$SHAREDLIBM#
+/^AR *=/s#=.*#=$AR#
+/^ARFLAGS *=/s#=.*#=$ARFLAGS#
+/^RANLIB *=/s#=.*#=$RANLIB#
+/^LDCONFIG *=/s#=.*#=$LDCONFIG#
+/^LDSHAREDLIBC *=/s#=.*#=$LDSHAREDLIBC#
+/^EXE *=/s#=.*#=$EXE#
+/^SRCDIR *=/s#=.*#=$SRCDIR#
+/^ZINC *=/s#=.*#=$ZINC#
+/^ZINCOUT *=/s#=.*#=$ZINCOUT#
+/^prefix *=/s#=.*#=$prefix#
+/^exec_prefix *=/s#=.*#=$exec_prefix#
+/^libdir *=/s#=.*#=$libdir#
+/^sharedlibdir *=/s#=.*#=$sharedlibdir#
+/^includedir *=/s#=.*#=$includedir#
+/^mandir *=/s#=.*#=$mandir#
+/^OBJC *=/s#=.*#= $OBJC#
+/^PIC_OBJC *=/s#=.*#= $PIC_OBJC#
+/^all: */s#:.*#: $ALL#
+/^test: */s#:.*#: $TEST#
+" > Makefile
+
+# create zlib.pc with the configure results
+sed < ${SRCDIR}zlib.pc.in "
+/^CC *=/s#=.*#=$CC#
+/^CFLAGS *=/s#=.*#=$CFLAGS#
+/^CPP *=/s#=.*#=$CPP#
+/^LDSHARED *=/s#=.*#=$LDSHARED#
+/^STATICLIB *=/s#=.*#=$STATICLIB#
+/^SHAREDLIB *=/s#=.*#=$SHAREDLIB#
+/^SHAREDLIBV *=/s#=.*#=$SHAREDLIBV#
+/^SHAREDLIBM *=/s#=.*#=$SHAREDLIBM#
+/^AR *=/s#=.*#=$AR#
+/^ARFLAGS *=/s#=.*#=$ARFLAGS#
+/^RANLIB *=/s#=.*#=$RANLIB#
+/^EXE *=/s#=.*#=$EXE#
+/^prefix *=/s#=.*#=$prefix#
+/^exec_prefix *=/s#=.*#=$exec_prefix#
+/^libdir *=/s#=.*#=$libdir#
+/^sharedlibdir *=/s#=.*#=$sharedlibdir#
+/^includedir *=/s#=.*#=$includedir#
+/^mandir *=/s#=.*#=$mandir#
+/^LDFLAGS *=/s#=.*#=$LDFLAGS#
+" | sed -e "
+s/\@VERSION\@/$VER/g;
+" > zlib.pc
+
+# done
+leave 0
diff --git a/zlib/contrib/README.contrib b/zlib/contrib/README.contrib
new file mode 100644
index 000000000..a411d5c39
--- /dev/null
+++ b/zlib/contrib/README.contrib
@@ -0,0 +1,78 @@
+All files under this contrib directory are UNSUPPORTED. There were
+provided by users of zlib and were not tested by the authors of zlib.
+Use at your own risk. Please contact the authors of the contributions
+for help about these, not the zlib authors. Thanks.
+
+
+ada/ by Dmitriy Anisimkov <anisimkov@yahoo.com>
+ Support for Ada
+ See http://zlib-ada.sourceforge.net/
+
+amd64/ by Mikhail Teterin <mi@ALDAN.algebra.com>
+ asm code for AMD64
+ See patch at http://www.freebsd.org/cgi/query-pr.cgi?pr=bin/96393
+
+asm686/ by Brian Raiter <breadbox@muppetlabs.com>
+ asm code for Pentium and PPro/PII, using the AT&T (GNU as) syntax
+ See http://www.muppetlabs.com/~breadbox/software/assembly.html
+
+blast/ by Mark Adler <madler@alumni.caltech.edu>
+ Decompressor for output of PKWare Data Compression Library (DCL)
+
+delphi/ by Cosmin Truta <cosmint@cs.ubbcluj.ro>
+ Support for Delphi and C++ Builder
+
+dotzlib/ by Henrik Ravn <henrik@ravn.com>
+ Support for Microsoft .Net and Visual C++ .Net
+
+gcc_gvmat64/by Gilles Vollant <info@winimage.com>
+ GCC Version of x86 64-bit (AMD64 and Intel EM64t) code for x64
+ assembler to replace longest_match() and inflate_fast()
+
+infback9/ by Mark Adler <madler@alumni.caltech.edu>
+ Unsupported diffs to infback to decode the deflate64 format
+
+inflate86/ by Chris Anderson <christop@charm.net>
+ Tuned x86 gcc asm code to replace inflate_fast()
+
+iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
+ A C++ I/O streams interface to the zlib gz* functions
+
+iostream2/ by Tyge Løvset <Tyge.Lovset@cmr.no>
+ Another C++ I/O streams interface
+
+iostream3/ by Ludwig Schwardt <schwardt@sun.ac.za>
+ and Kevin Ruland <kevin@rodin.wustl.edu>
+ Yet another C++ I/O streams interface
+
+masmx64/ by Gilles Vollant <info@winimage.com>
+ x86 64-bit (AMD64 and Intel EM64t) code for x64 assembler to
+ replace longest_match() and inflate_fast(), also masm x86
+ 64-bits translation of Chris Anderson inflate_fast()
+
+masmx86/ by Gilles Vollant <info@winimage.com>
+ x86 asm code to replace longest_match() and inflate_fast(),
+ for Visual C++ and MASM (32 bits).
+ Based on Brian Raiter (asm686) and Chris Anderson (inflate86)
+
+minizip/ by Gilles Vollant <info@winimage.com>
+ Mini zip and unzip based on zlib
+ Includes Zip64 support by Mathias Svensson <mathias@result42.com>
+ See http://www.winimage.com/zLibDll/minizip.html
+
+pascal/ by Bob Dellaca <bobdl@xtra.co.nz> et al.
+ Support for Pascal
+
+puff/ by Mark Adler <madler@alumni.caltech.edu>
+ Small, low memory usage inflate. Also serves to provide an
+ unambiguous description of the deflate format.
+
+testzlib/ by Gilles Vollant <info@winimage.com>
+ Example of the use of zlib
+
+untgz/ by Pedro A. Aranda Gutierrez <paag@tid.es>
+ A very simple tar.gz file extractor using zlib
+
+vstudio/ by Gilles Vollant <info@winimage.com>
+ Building a minizip-enhanced zlib with Microsoft Visual Studio
+ Includes vc11 from kreuzerkrieg and vc12 from davispuh
diff --git a/zlib/contrib/blast/Makefile b/zlib/contrib/blast/Makefile
new file mode 100644
index 000000000..9be80bafe
--- /dev/null
+++ b/zlib/contrib/blast/Makefile
@@ -0,0 +1,8 @@
+blast: blast.c blast.h
+ cc -DTEST -o blast blast.c
+
+test: blast
+ blast < test.pk | cmp - test.txt
+
+clean:
+ rm -f blast blast.o
diff --git a/zlib/contrib/blast/README b/zlib/contrib/blast/README
new file mode 100644
index 000000000..e3a60b3f5
--- /dev/null
+++ b/zlib/contrib/blast/README
@@ -0,0 +1,4 @@
+Read blast.h for purpose and usage.
+
+Mark Adler
+madler@alumni.caltech.edu
diff --git a/zlib/contrib/blast/blast.c b/zlib/contrib/blast/blast.c
new file mode 100644
index 000000000..e6e659073
--- /dev/null
+++ b/zlib/contrib/blast/blast.c
@@ -0,0 +1,466 @@
+/* blast.c
+ * Copyright (C) 2003, 2012, 2013 Mark Adler
+ * For conditions of distribution and use, see copyright notice in blast.h
+ * version 1.3, 24 Aug 2013
+ *
+ * blast.c decompresses data compressed by the PKWare Compression Library.
+ * This function provides functionality similar to the explode() function of
+ * the PKWare library, hence the name "blast".
+ *
+ * This decompressor is based on the excellent format description provided by
+ * Ben Rudiak-Gould in comp.compression on August 13, 2001. Interestingly, the
+ * example Ben provided in the post is incorrect. The distance 110001 should
+ * instead be 111000. When corrected, the example byte stream becomes:
+ *
+ * 00 04 82 24 25 8f 80 7f
+ *
+ * which decompresses to "AIAIAIAIAIAIA" (without the quotes).
+ */
+
+/*
+ * Change history:
+ *
+ * 1.0 12 Feb 2003 - First version
+ * 1.1 16 Feb 2003 - Fixed distance check for > 4 GB uncompressed data
+ * 1.2 24 Oct 2012 - Add note about using binary mode in stdio
+ * - Fix comparisons of differently signed integers
+ * 1.3 24 Aug 2013 - Return unused input from blast()
+ * - Fix test code to correctly report unused input
+ * - Enable the provision of initial input to blast()
+ */
+
+#include <stddef.h> /* for NULL */
+#include <setjmp.h> /* for setjmp(), longjmp(), and jmp_buf */
+#include "blast.h" /* prototype for blast() */
+
+#define local static /* for local function definitions */
+#define MAXBITS 13 /* maximum code length */
+#define MAXWIN 4096 /* maximum window size */
+
+/* input and output state */
+struct state {
+ /* input state */
+ blast_in infun; /* input function provided by user */
+ void *inhow; /* opaque information passed to infun() */
+ unsigned char *in; /* next input location */
+ unsigned left; /* available input at in */
+ int bitbuf; /* bit buffer */
+ int bitcnt; /* number of bits in bit buffer */
+
+ /* input limit error return state for bits() and decode() */
+ jmp_buf env;
+
+ /* output state */
+ blast_out outfun; /* output function provided by user */
+ void *outhow; /* opaque information passed to outfun() */
+ unsigned next; /* index of next write location in out[] */
+ int first; /* true to check distances (for first 4K) */
+ unsigned char out[MAXWIN]; /* output buffer and sliding window */
+};
+
+/*
+ * Return need bits from the input stream. This always leaves less than
+ * eight bits in the buffer. bits() works properly for need == 0.
+ *
+ * Format notes:
+ *
+ * - Bits are stored in bytes from the least significant bit to the most
+ * significant bit. Therefore bits are dropped from the bottom of the bit
+ * buffer, using shift right, and new bytes are appended to the top of the
+ * bit buffer, using shift left.
+ */
+local int bits(struct state *s, int need)
+{
+ int val; /* bit accumulator */
+
+ /* load at least need bits into val */
+ val = s->bitbuf;
+ while (s->bitcnt < need) {
+ if (s->left == 0) {
+ s->left = s->infun(s->inhow, &(s->in));
+ if (s->left == 0) longjmp(s->env, 1); /* out of input */
+ }
+ val |= (int)(*(s->in)++) << s->bitcnt; /* load eight bits */
+ s->left--;
+ s->bitcnt += 8;
+ }
+
+ /* drop need bits and update buffer, always zero to seven bits left */
+ s->bitbuf = val >> need;
+ s->bitcnt -= need;
+
+ /* return need bits, zeroing the bits above that */
+ return val & ((1 << need) - 1);
+}
+
+/*
+ * Huffman code decoding tables. count[1..MAXBITS] is the number of symbols of
+ * each length, which for a canonical code are stepped through in order.
+ * symbol[] are the symbol values in canonical order, where the number of
+ * entries is the sum of the counts in count[]. The decoding process can be
+ * seen in the function decode() below.
+ */
+struct huffman {
+ short *count; /* number of symbols of each length */
+ short *symbol; /* canonically ordered symbols */
+};
+
+/*
+ * Decode a code from the stream s using huffman table h. Return the symbol or
+ * a negative value if there is an error. If all of the lengths are zero, i.e.
+ * an empty code, or if the code is incomplete and an invalid code is received,
+ * then -9 is returned after reading MAXBITS bits.
+ *
+ * Format notes:
+ *
+ * - The codes as stored in the compressed data are bit-reversed relative to
+ * a simple integer ordering of codes of the same lengths. Hence below the
+ * bits are pulled from the compressed data one at a time and used to
+ * build the code value reversed from what is in the stream in order to
+ * permit simple integer comparisons for decoding.
+ *
+ * - The first code for the shortest length is all ones. Subsequent codes of
+ * the same length are simply integer decrements of the previous code. When
+ * moving up a length, a one bit is appended to the code. For a complete
+ * code, the last code of the longest length will be all zeros. To support
+ * this ordering, the bits pulled during decoding are inverted to apply the
+ * more "natural" ordering starting with all zeros and incrementing.
+ */
+local int decode(struct state *s, struct huffman *h)
+{
+ int len; /* current number of bits in code */
+ int code; /* len bits being decoded */
+ int first; /* first code of length len */
+ int count; /* number of codes of length len */
+ int index; /* index of first code of length len in symbol table */
+ int bitbuf; /* bits from stream */
+ int left; /* bits left in next or left to process */
+ short *next; /* next number of codes */
+
+ bitbuf = s->bitbuf;
+ left = s->bitcnt;
+ code = first = index = 0;
+ len = 1;
+ next = h->count + 1;
+ while (1) {
+ while (left--) {
+ code |= (bitbuf & 1) ^ 1; /* invert code */
+ bitbuf >>= 1;
+ count = *next++;
+ if (code < first + count) { /* if length len, return symbol */
+ s->bitbuf = bitbuf;
+ s->bitcnt = (s->bitcnt - len) & 7;
+ return h->symbol[index + (code - first)];
+ }
+ index += count; /* else update for next length */
+ first += count;
+ first <<= 1;
+ code <<= 1;
+ len++;
+ }
+ left = (MAXBITS+1) - len;
+ if (left == 0) break;
+ if (s->left == 0) {
+ s->left = s->infun(s->inhow, &(s->in));
+ if (s->left == 0) longjmp(s->env, 1); /* out of input */
+ }
+ bitbuf = *(s->in)++;
+ s->left--;
+ if (left > 8) left = 8;
+ }
+ return -9; /* ran out of codes */
+}
+
+/*
+ * Given a list of repeated code lengths rep[0..n-1], where each byte is a
+ * count (high four bits + 1) and a code length (low four bits), generate the
+ * list of code lengths. This compaction reduces the size of the object code.
+ * Then given the list of code lengths length[0..n-1] representing a canonical
+ * Huffman code for n symbols, construct the tables required to decode those
+ * codes. Those tables are the number of codes of each length, and the symbols
+ * sorted by length, retaining their original order within each length. The
+ * return value is zero for a complete code set, negative for an over-
+ * subscribed code set, and positive for an incomplete code set. The tables
+ * can be used if the return value is zero or positive, but they cannot be used
+ * if the return value is negative. If the return value is zero, it is not
+ * possible for decode() using that table to return an error--any stream of
+ * enough bits will resolve to a symbol. If the return value is positive, then
+ * it is possible for decode() using that table to return an error for received
+ * codes past the end of the incomplete lengths.
+ */
+local int construct(struct huffman *h, const unsigned char *rep, int n)
+{
+ int symbol; /* current symbol when stepping through length[] */
+ int len; /* current length when stepping through h->count[] */
+ int left; /* number of possible codes left of current length */
+ short offs[MAXBITS+1]; /* offsets in symbol table for each length */
+ short length[256]; /* code lengths */
+
+ /* convert compact repeat counts into symbol bit length list */
+ symbol = 0;
+ do {
+ len = *rep++;
+ left = (len >> 4) + 1;
+ len &= 15;
+ do {
+ length[symbol++] = len;
+ } while (--left);
+ } while (--n);
+ n = symbol;
+
+ /* count number of codes of each length */
+ for (len = 0; len <= MAXBITS; len++)
+ h->count[len] = 0;
+ for (symbol = 0; symbol < n; symbol++)
+ (h->count[length[symbol]])++; /* assumes lengths are within bounds */
+ if (h->count[0] == n) /* no codes! */
+ return 0; /* complete, but decode() will fail */
+
+ /* check for an over-subscribed or incomplete set of lengths */
+ left = 1; /* one possible code of zero length */
+ for (len = 1; len <= MAXBITS; len++) {
+ left <<= 1; /* one more bit, double codes left */
+ left -= h->count[len]; /* deduct count from possible codes */
+ if (left < 0) return left; /* over-subscribed--return negative */
+ } /* left > 0 means incomplete */
+
+ /* generate offsets into symbol table for each length for sorting */
+ offs[1] = 0;
+ for (len = 1; len < MAXBITS; len++)
+ offs[len + 1] = offs[len] + h->count[len];
+
+ /*
+ * put symbols in table sorted by length, by symbol order within each
+ * length
+ */
+ for (symbol = 0; symbol < n; symbol++)
+ if (length[symbol] != 0)
+ h->symbol[offs[length[symbol]]++] = symbol;
+
+ /* return zero for complete set, positive for incomplete set */
+ return left;
+}
+
+/*
+ * Decode PKWare Compression Library stream.
+ *
+ * Format notes:
+ *
+ * - First byte is 0 if literals are uncoded or 1 if they are coded. Second
+ * byte is 4, 5, or 6 for the number of extra bits in the distance code.
+ * This is the base-2 logarithm of the dictionary size minus six.
+ *
+ * - Compressed data is a combination of literals and length/distance pairs
+ * terminated by an end code. Literals are either Huffman coded or
+ * uncoded bytes. A length/distance pair is a coded length followed by a
+ * coded distance to represent a string that occurs earlier in the
+ * uncompressed data that occurs again at the current location.
+ *
+ * - A bit preceding a literal or length/distance pair indicates which comes
+ * next, 0 for literals, 1 for length/distance.
+ *
+ * - If literals are uncoded, then the next eight bits are the literal, in the
+ * normal bit order in the stream, i.e. no bit-reversal is needed. Similarly,
+ * no bit reversal is needed for either the length extra bits or the distance
+ * extra bits.
+ *
+ * - Literal bytes are simply written to the output. A length/distance pair is
+ * an instruction to copy previously uncompressed bytes to the output. The
+ * copy is from distance bytes back in the output stream, copying for length
+ * bytes.
+ *
+ * - Distances pointing before the beginning of the output data are not
+ * permitted.
+ *
+ * - Overlapped copies, where the length is greater than the distance, are
+ * allowed and common. For example, a distance of one and a length of 518
+ * simply copies the last byte 518 times. A distance of four and a length of
+ * twelve copies the last four bytes three times. A simple forward copy
+ * ignoring whether the length is greater than the distance or not implements
+ * this correctly.
+ */
+local int decomp(struct state *s)
+{
+ int lit; /* true if literals are coded */
+ int dict; /* log2(dictionary size) - 6 */
+ int symbol; /* decoded symbol, extra bits for distance */
+ int len; /* length for copy */
+ unsigned dist; /* distance for copy */
+ int copy; /* copy counter */
+ unsigned char *from, *to; /* copy pointers */
+ static int virgin = 1; /* build tables once */
+ static short litcnt[MAXBITS+1], litsym[256]; /* litcode memory */
+ static short lencnt[MAXBITS+1], lensym[16]; /* lencode memory */
+ static short distcnt[MAXBITS+1], distsym[64]; /* distcode memory */
+ static struct huffman litcode = {litcnt, litsym}; /* length code */
+ static struct huffman lencode = {lencnt, lensym}; /* length code */
+ static struct huffman distcode = {distcnt, distsym};/* distance code */
+ /* bit lengths of literal codes */
+ static const unsigned char litlen[] = {
+ 11, 124, 8, 7, 28, 7, 188, 13, 76, 4, 10, 8, 12, 10, 12, 10, 8, 23, 8,
+ 9, 7, 6, 7, 8, 7, 6, 55, 8, 23, 24, 12, 11, 7, 9, 11, 12, 6, 7, 22, 5,
+ 7, 24, 6, 11, 9, 6, 7, 22, 7, 11, 38, 7, 9, 8, 25, 11, 8, 11, 9, 12,
+ 8, 12, 5, 38, 5, 38, 5, 11, 7, 5, 6, 21, 6, 10, 53, 8, 7, 24, 10, 27,
+ 44, 253, 253, 253, 252, 252, 252, 13, 12, 45, 12, 45, 12, 61, 12, 45,
+ 44, 173};
+ /* bit lengths of length codes 0..15 */
+ static const unsigned char lenlen[] = {2, 35, 36, 53, 38, 23};
+ /* bit lengths of distance codes 0..63 */
+ static const unsigned char distlen[] = {2, 20, 53, 230, 247, 151, 248};
+ static const short base[16] = { /* base for length codes */
+ 3, 2, 4, 5, 6, 7, 8, 9, 10, 12, 16, 24, 40, 72, 136, 264};
+ static const char extra[16] = { /* extra bits for length codes */
+ 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8};
+
+ /* set up decoding tables (once--might not be thread-safe) */
+ if (virgin) {
+ construct(&litcode, litlen, sizeof(litlen));
+ construct(&lencode, lenlen, sizeof(lenlen));
+ construct(&distcode, distlen, sizeof(distlen));
+ virgin = 0;
+ }
+
+ /* read header */
+ lit = bits(s, 8);
+ if (lit > 1) return -1;
+ dict = bits(s, 8);
+ if (dict < 4 || dict > 6) return -2;
+
+ /* decode literals and length/distance pairs */
+ do {
+ if (bits(s, 1)) {
+ /* get length */
+ symbol = decode(s, &lencode);
+ len = base[symbol] + bits(s, extra[symbol]);
+ if (len == 519) break; /* end code */
+
+ /* get distance */
+ symbol = len == 2 ? 2 : dict;
+ dist = decode(s, &distcode) << symbol;
+ dist += bits(s, symbol);
+ dist++;
+ if (s->first && dist > s->next)
+ return -3; /* distance too far back */
+
+ /* copy length bytes from distance bytes back */
+ do {
+ to = s->out + s->next;
+ from = to - dist;
+ copy = MAXWIN;
+ if (s->next < dist) {
+ from += copy;
+ copy = dist;
+ }
+ copy -= s->next;
+ if (copy > len) copy = len;
+ len -= copy;
+ s->next += copy;
+ do {
+ *to++ = *from++;
+ } while (--copy);
+ if (s->next == MAXWIN) {
+ if (s->outfun(s->outhow, s->out, s->next)) return 1;
+ s->next = 0;
+ s->first = 0;
+ }
+ } while (len != 0);
+ }
+ else {
+ /* get literal and write it */
+ symbol = lit ? decode(s, &litcode) : bits(s, 8);
+ s->out[s->next++] = symbol;
+ if (s->next == MAXWIN) {
+ if (s->outfun(s->outhow, s->out, s->next)) return 1;
+ s->next = 0;
+ s->first = 0;
+ }
+ }
+ } while (1);
+ return 0;
+}
+
+/* See comments in blast.h */
+int blast(blast_in infun, void *inhow, blast_out outfun, void *outhow,
+ unsigned *left, unsigned char **in)
+{
+ struct state s; /* input/output state */
+ int err; /* return value */
+
+ /* initialize input state */
+ s.infun = infun;
+ s.inhow = inhow;
+ if (left != NULL && *left) {
+ s.left = *left;
+ s.in = *in;
+ }
+ else
+ s.left = 0;
+ s.bitbuf = 0;
+ s.bitcnt = 0;
+
+ /* initialize output state */
+ s.outfun = outfun;
+ s.outhow = outhow;
+ s.next = 0;
+ s.first = 1;
+
+ /* return if bits() or decode() tries to read past available input */
+ if (setjmp(s.env) != 0) /* if came back here via longjmp(), */
+ err = 2; /* then skip decomp(), return error */
+ else
+ err = decomp(&s); /* decompress */
+
+ /* return unused input */
+ if (left != NULL)
+ *left = s.left;
+ if (in != NULL)
+ *in = s.left ? s.in : NULL;
+
+ /* write any leftover output and update the error code if needed */
+ if (err != 1 && s.next && s.outfun(s.outhow, s.out, s.next) && err == 0)
+ err = 1;
+ return err;
+}
+
+#ifdef TEST
+/* Example of how to use blast() */
+#include <stdio.h>
+#include <stdlib.h>
+
+#define CHUNK 16384
+
+local unsigned inf(void *how, unsigned char **buf)
+{
+ static unsigned char hold[CHUNK];
+
+ *buf = hold;
+ return fread(hold, 1, CHUNK, (FILE *)how);
+}
+
+local int outf(void *how, unsigned char *buf, unsigned len)
+{
+ return fwrite(buf, 1, len, (FILE *)how) != len;
+}
+
+/* Decompress a PKWare Compression Library stream from stdin to stdout */
+int main(void)
+{
+ int ret;
+ unsigned left;
+
+ /* decompress to stdout */
+ left = 0;
+ ret = blast(inf, stdin, outf, stdout, &left, NULL);
+ if (ret != 0)
+ fprintf(stderr, "blast error: %d\n", ret);
+
+ /* count any leftover bytes */
+ while (getchar() != EOF)
+ left++;
+ if (left)
+ fprintf(stderr, "blast warning: %u unused bytes of input\n", left);
+
+ /* return blast() error code */
+ return ret;
+}
+#endif
diff --git a/zlib/contrib/blast/blast.h b/zlib/contrib/blast/blast.h
new file mode 100644
index 000000000..6cf65eda1
--- /dev/null
+++ b/zlib/contrib/blast/blast.h
@@ -0,0 +1,83 @@
+/* blast.h -- interface for blast.c
+ Copyright (C) 2003, 2012, 2013 Mark Adler
+ version 1.3, 24 Aug 2013
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the author 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.
+
+ Mark Adler madler@alumni.caltech.edu
+ */
+
+
+/*
+ * blast() decompresses the PKWare Data Compression Library (DCL) compressed
+ * format. It provides the same functionality as the explode() function in
+ * that library. (Note: PKWare overused the "implode" verb, and the format
+ * used by their library implode() function is completely different and
+ * incompatible with the implode compression method supported by PKZIP.)
+ *
+ * The binary mode for stdio functions should be used to assure that the
+ * compressed data is not corrupted when read or written. For example:
+ * fopen(..., "rb") and fopen(..., "wb").
+ */
+
+
+typedef unsigned (*blast_in)(void *how, unsigned char **buf);
+typedef int (*blast_out)(void *how, unsigned char *buf, unsigned len);
+/* Definitions for input/output functions passed to blast(). See below for
+ * what the provided functions need to do.
+ */
+
+
+int blast(blast_in infun, void *inhow, blast_out outfun, void *outhow,
+ unsigned *left, unsigned char **in);
+/* Decompress input to output using the provided infun() and outfun() calls.
+ * On success, the return value of blast() is zero. If there is an error in
+ * the source data, i.e. it is not in the proper format, then a negative value
+ * is returned. If there is not enough input available or there is not enough
+ * output space, then a positive error is returned.
+ *
+ * The input function is invoked: len = infun(how, &buf), where buf is set by
+ * infun() to point to the input buffer, and infun() returns the number of
+ * available bytes there. If infun() returns zero, then blast() returns with
+ * an input error. (blast() only asks for input if it needs it.) inhow is for
+ * use by the application to pass an input descriptor to infun(), if desired.
+ *
+ * If left and in are not NULL and *left is not zero when blast() is called,
+ * then the *left bytes are *in are consumed for input before infun() is used.
+ *
+ * The output function is invoked: err = outfun(how, buf, len), where the bytes
+ * to be written are buf[0..len-1]. If err is not zero, then blast() returns
+ * with an output error. outfun() is always called with len <= 4096. outhow
+ * is for use by the application to pass an output descriptor to outfun(), if
+ * desired.
+ *
+ * If there is any unused input, *left is set to the number of bytes that were
+ * read and *in points to them. Otherwise *left is set to zero and *in is set
+ * to NULL. If left or in are NULL, then they are not set.
+ *
+ * The return codes are:
+ *
+ * 2: ran out of input before completing decompression
+ * 1: output error before completing decompression
+ * 0: successful decompression
+ * -1: literal flag not zero or one
+ * -2: dictionary size not in 4..6
+ * -3: distance is too far back
+ *
+ * At the bottom of blast.c is an example program that uses blast() that can be
+ * compiled to produce a command-line decompression filter by defining TEST.
+ */
diff --git a/zlib/contrib/blast/test.pk b/zlib/contrib/blast/test.pk
new file mode 100644
index 0000000000000000000000000000000000000000..be10b2bbb251759ffdf6da49fadd1a3f137a54c1
GIT binary patch
literal 8
PcmZQzX;M+`Z>R?V2c!aC
literal 0
HcmV?d00001
diff --git a/zlib/contrib/blast/test.txt b/zlib/contrib/blast/test.txt
new file mode 100644
index 000000000..bfdf1c5dc
--- /dev/null
+++ b/zlib/contrib/blast/test.txt
@@ -0,0 +1 @@
+AIAIAIAIAIAIA
\ No newline at end of file
diff --git a/zlib/contrib/infback9/README b/zlib/contrib/infback9/README
new file mode 100644
index 000000000..e75ed1329
--- /dev/null
+++ b/zlib/contrib/infback9/README
@@ -0,0 +1 @@
+See infback9.h for what this is and how to use it.
diff --git a/zlib/contrib/infback9/infback9.c b/zlib/contrib/infback9/infback9.c
new file mode 100644
index 000000000..05fb3e338
--- /dev/null
+++ b/zlib/contrib/infback9/infback9.c
@@ -0,0 +1,615 @@
+/* infback9.c -- inflate deflate64 data using a call-back interface
+ * Copyright (C) 1995-2008 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "infback9.h"
+#include "inftree9.h"
+#include "inflate9.h"
+
+#define WSIZE 65536UL
+
+/*
+ strm provides memory allocation functions in zalloc and zfree, or
+ Z_NULL to use the library memory allocation functions.
+
+ window is a user-supplied window and output buffer that is 64K bytes.
+ */
+int ZEXPORT inflateBack9Init_(strm, window, version, stream_size)
+z_stream FAR *strm;
+unsigned char FAR *window;
+const char *version;
+int stream_size;
+{
+ 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 || window == Z_NULL)
+ return Z_STREAM_ERROR;
+ strm->msg = Z_NULL; /* in case we return an error */
+ if (strm->zalloc == (alloc_func)0) {
+ strm->zalloc = zcalloc;
+ strm->opaque = (voidpf)0;
+ }
+ if (strm->zfree == (free_func)0) strm->zfree = zcfree;
+ 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 = (voidpf)state;
+ state->window = window;
+ return Z_OK;
+}
+
+/*
+ Build and output length and distance decoding tables for fixed code
+ decoding.
+ */
+#ifdef MAKEFIXED
+#include <stdio.h>
+
+void makefixed9(void)
+{
+ unsigned sym, bits, low, size;
+ code *next, *lenfix, *distfix;
+ struct inflate_state state;
+ code fixed[544];
+
+ /* 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_table9(LENS, state.lens, 288, &(next), &(bits), state.work);
+
+ /* distance table */
+ sym = 0;
+ while (sym < 32) state.lens[sym++] = 5;
+ distfix = next;
+ bits = 5;
+ inflate_table9(DISTS, state.lens, 32, &(next), &(bits), state.work);
+
+ /* write tables */
+ puts(" /* inffix9.h -- table for decoding deflate64 fixed codes");
+ puts(" * Generated automatically by makefixed9().");
+ 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 % 6) == 0) printf("\n ");
+ printf("{%u,%u,%d}", lenfix[low].op, lenfix[low].bits,
+ lenfix[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 % 5) == 0) printf("\n ");
+ printf("{%u,%u,%d}", distfix[low].op, distfix[low].bits,
+ distfix[low].val);
+ if (++low == size) break;
+ putchar(',');
+ }
+ puts("\n };");
+}
+#endif /* MAKEFIXED */
+
+/* Macros for inflateBack(): */
+
+/* Clear the input bit accumulator */
+#define INITBITS() \
+ do { \
+ hold = 0; \
+ bits = 0; \
+ } while (0)
+
+/* Assure that some input is available. If input is requested, but denied,
+ then return a Z_BUF_ERROR from inflateBack(). */
+#define PULL() \
+ do { \
+ if (have == 0) { \
+ have = in(in_desc, &next); \
+ if (have == 0) { \
+ next = Z_NULL; \
+ ret = Z_BUF_ERROR; \
+ goto inf_leave; \
+ } \
+ } \
+ } while (0)
+
+/* Get a byte of input into the bit accumulator, or return from inflateBack()
+ with an error if there is no input available. */
+#define PULLBYTE() \
+ do { \
+ PULL(); \
+ have--; \
+ hold += (unsigned long)(*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 inflateBack() with
+ an error. */
+#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)
+
+/* Assure that some output space is available, by writing out the window
+ if it's full. If the write fails, return from inflateBack() with a
+ Z_BUF_ERROR. */
+#define ROOM() \
+ do { \
+ if (left == 0) { \
+ put = window; \
+ left = WSIZE; \
+ wrap = 1; \
+ if (out(out_desc, put, (unsigned)left)) { \
+ ret = Z_BUF_ERROR; \
+ goto inf_leave; \
+ } \
+ } \
+ } while (0)
+
+/*
+ strm provides the memory allocation functions and window buffer on input,
+ and provides information on the unused input on return. For Z_DATA_ERROR
+ returns, strm will also provide an error message.
+
+ in() and out() are the call-back input and output functions. When
+ inflateBack() needs more input, it calls in(). When inflateBack() has
+ filled the window with output, or when it completes with data in the
+ window, it calls out() to write out the data. The application must not
+ change the provided input until in() is called again or inflateBack()
+ returns. The application must not change the window/output buffer until
+ inflateBack() returns.
+
+ in() and out() are called with a descriptor parameter provided in the
+ inflateBack() call. This parameter can be a structure that provides the
+ information required to do the read or write, as well as accumulated
+ information on the input and output such as totals and check values.
+
+ in() should return zero on failure. out() should return non-zero on
+ failure. If either in() or out() fails, than inflateBack() returns a
+ Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it
+ was in() or out() that caused in the error. Otherwise, inflateBack()
+ returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
+ error, or Z_MEM_ERROR if it could not allocate memory for the state.
+ inflateBack() can also return Z_STREAM_ERROR if the input parameters
+ are not correct, i.e. strm is Z_NULL or the state was not initialized.
+ */
+int ZEXPORT inflateBack9(strm, in, in_desc, out, out_desc)
+z_stream FAR *strm;
+in_func in;
+void FAR *in_desc;
+out_func out;
+void FAR *out_desc;
+{
+ struct inflate_state FAR *state;
+ z_const unsigned char FAR *next; /* next input */
+ unsigned char FAR *put; /* next output */
+ unsigned have; /* available input */
+ unsigned long left; /* available output */
+ inflate_mode mode; /* current inflate mode */
+ int lastblock; /* true if processing last block */
+ int wrap; /* true if the window has wrapped */
+ unsigned char FAR *window; /* allocated sliding window, if needed */
+ unsigned long hold; /* bit buffer */
+ unsigned bits; /* bits in bit buffer */
+ unsigned extra; /* extra bits needed */
+ unsigned long length; /* literal or length of data to copy */
+ unsigned long offset; /* distance back to copy string from */
+ unsigned long copy; /* number of stored or match bytes to copy */
+ unsigned char FAR *from; /* where to copy match bytes from */
+ 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 */
+ 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 */
+ 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};
+#include "inffix9.h"
+
+ /* Check that the strm exists and that the state was initialized */
+ if (strm == Z_NULL || strm->state == Z_NULL)
+ return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+
+ /* Reset the state */
+ strm->msg = Z_NULL;
+ mode = TYPE;
+ lastblock = 0;
+ wrap = 0;
+ window = state->window;
+ next = strm->next_in;
+ have = next != Z_NULL ? strm->avail_in : 0;
+ hold = 0;
+ bits = 0;
+ put = window;
+ left = WSIZE;
+ lencode = Z_NULL;
+ distcode = Z_NULL;
+
+ /* Inflate until end of block marked as last */
+ for (;;)
+ switch (mode) {
+ case TYPE:
+ /* determine and dispatch block type */
+ if (lastblock) {
+ BYTEBITS();
+ mode = DONE;
+ break;
+ }
+ NEEDBITS(3);
+ lastblock = BITS(1);
+ DROPBITS(1);
+ switch (BITS(2)) {
+ case 0: /* stored block */
+ Tracev((stderr, "inflate: stored block%s\n",
+ lastblock ? " (last)" : ""));
+ mode = STORED;
+ break;
+ case 1: /* fixed block */
+ lencode = lenfix;
+ lenbits = 9;
+ distcode = distfix;
+ distbits = 5;
+ Tracev((stderr, "inflate: fixed codes block%s\n",
+ lastblock ? " (last)" : ""));
+ mode = LEN; /* decode codes */
+ break;
+ case 2: /* dynamic block */
+ Tracev((stderr, "inflate: dynamic codes block%s\n",
+ lastblock ? " (last)" : ""));
+ mode = TABLE;
+ break;
+ case 3:
+ strm->msg = (char *)"invalid block type";
+ mode = BAD;
+ }
+ DROPBITS(2);
+ break;
+
+ case STORED:
+ /* get and verify stored block length */
+ BYTEBITS(); /* go to byte boundary */
+ NEEDBITS(32);
+ if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
+ strm->msg = (char *)"invalid stored block lengths";
+ mode = BAD;
+ break;
+ }
+ length = (unsigned)hold & 0xffff;
+ Tracev((stderr, "inflate: stored length %lu\n",
+ length));
+ INITBITS();
+
+ /* copy stored block from input to output */
+ while (length != 0) {
+ copy = length;
+ PULL();
+ ROOM();
+ if (copy > have) copy = have;
+ if (copy > left) copy = left;
+ zmemcpy(put, next, copy);
+ have -= copy;
+ next += copy;
+ left -= copy;
+ put += copy;
+ length -= copy;
+ }
+ Tracev((stderr, "inflate: stored end\n"));
+ mode = TYPE;
+ break;
+
+ case TABLE:
+ /* get dynamic table entries descriptor */
+ NEEDBITS(14);
+ state->nlen = BITS(5) + 257;
+ DROPBITS(5);
+ state->ndist = BITS(5) + 1;
+ DROPBITS(5);
+ state->ncode = BITS(4) + 4;
+ DROPBITS(4);
+ if (state->nlen > 286) {
+ strm->msg = (char *)"too many length symbols";
+ mode = BAD;
+ break;
+ }
+ Tracev((stderr, "inflate: table sizes ok\n"));
+
+ /* get code length code lengths (not a typo) */
+ state->have = 0;
+ 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;
+ lencode = (code const FAR *)(state->next);
+ lenbits = 7;
+ ret = inflate_table9(CODES, state->lens, 19, &(state->next),
+ &(lenbits), state->work);
+ if (ret) {
+ strm->msg = (char *)"invalid code lengths set";
+ mode = BAD;
+ break;
+ }
+ Tracev((stderr, "inflate: code lengths ok\n"));
+
+ /* get length and distance code code lengths */
+ state->have = 0;
+ while (state->have < state->nlen + state->ndist) {
+ for (;;) {
+ here = lencode[BITS(lenbits)];
+ if ((unsigned)(here.bits) <= bits) break;
+ PULLBYTE();
+ }
+ if (here.val < 16) {
+ NEEDBITS(here.bits);
+ 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";
+ mode = BAD;
+ break;
+ }
+ len = (unsigned)(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";
+ mode = BAD;
+ break;
+ }
+ while (copy--)
+ state->lens[state->have++] = (unsigned short)len;
+ }
+ }
+
+ /* handle error breaks in while */
+ if (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";
+ mode = BAD;
+ break;
+ }
+
+ /* build code tables -- note: do not change the lenbits or distbits
+ values here (9 and 6) without reading the comments in inftree9.h
+ concerning the ENOUGH constants, which depend on those values */
+ state->next = state->codes;
+ lencode = (code const FAR *)(state->next);
+ lenbits = 9;
+ ret = inflate_table9(LENS, state->lens, state->nlen,
+ &(state->next), &(lenbits), state->work);
+ if (ret) {
+ strm->msg = (char *)"invalid literal/lengths set";
+ mode = BAD;
+ break;
+ }
+ distcode = (code const FAR *)(state->next);
+ distbits = 6;
+ ret = inflate_table9(DISTS, state->lens + state->nlen,
+ state->ndist, &(state->next), &(distbits),
+ state->work);
+ if (ret) {
+ strm->msg = (char *)"invalid distances set";
+ mode = BAD;
+ break;
+ }
+ Tracev((stderr, "inflate: codes ok\n"));
+ mode = LEN;
+
+ case LEN:
+ /* get a literal, length, or end-of-block code */
+ for (;;) {
+ here = lencode[BITS(lenbits)];
+ if ((unsigned)(here.bits) <= bits) break;
+ PULLBYTE();
+ }
+ if (here.op && (here.op & 0xf0) == 0) {
+ last = here;
+ for (;;) {
+ here = lencode[last.val +
+ (BITS(last.bits + last.op) >> last.bits)];
+ if ((unsigned)(last.bits + here.bits) <= bits) break;
+ PULLBYTE();
+ }
+ DROPBITS(last.bits);
+ }
+ DROPBITS(here.bits);
+ length = (unsigned)here.val;
+
+ /* process literal */
+ if (here.op == 0) {
+ Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
+ "inflate: literal '%c'\n" :
+ "inflate: literal 0x%02x\n", here.val));
+ ROOM();
+ *put++ = (unsigned char)(length);
+ left--;
+ mode = LEN;
+ break;
+ }
+
+ /* process end of block */
+ if (here.op & 32) {
+ Tracevv((stderr, "inflate: end of block\n"));
+ mode = TYPE;
+ break;
+ }
+
+ /* invalid code */
+ if (here.op & 64) {
+ strm->msg = (char *)"invalid literal/length code";
+ mode = BAD;
+ break;
+ }
+
+ /* length code -- get extra bits, if any */
+ extra = (unsigned)(here.op) & 31;
+ if (extra != 0) {
+ NEEDBITS(extra);
+ length += BITS(extra);
+ DROPBITS(extra);
+ }
+ Tracevv((stderr, "inflate: length %lu\n", length));
+
+ /* get distance code */
+ for (;;) {
+ here = distcode[BITS(distbits)];
+ if ((unsigned)(here.bits) <= bits) break;
+ PULLBYTE();
+ }
+ if ((here.op & 0xf0) == 0) {
+ last = here;
+ for (;;) {
+ here = distcode[last.val +
+ (BITS(last.bits + last.op) >> last.bits)];
+ if ((unsigned)(last.bits + here.bits) <= bits) break;
+ PULLBYTE();
+ }
+ DROPBITS(last.bits);
+ }
+ DROPBITS(here.bits);
+ if (here.op & 64) {
+ strm->msg = (char *)"invalid distance code";
+ mode = BAD;
+ break;
+ }
+ offset = (unsigned)here.val;
+
+ /* get distance extra bits, if any */
+ extra = (unsigned)(here.op) & 15;
+ if (extra != 0) {
+ NEEDBITS(extra);
+ offset += BITS(extra);
+ DROPBITS(extra);
+ }
+ if (offset > WSIZE - (wrap ? 0: left)) {
+ strm->msg = (char *)"invalid distance too far back";
+ mode = BAD;
+ break;
+ }
+ Tracevv((stderr, "inflate: distance %lu\n", offset));
+
+ /* copy match from window to output */
+ do {
+ ROOM();
+ copy = WSIZE - offset;
+ if (copy < left) {
+ from = put + copy;
+ copy = left - copy;
+ }
+ else {
+ from = put - offset;
+ copy = left;
+ }
+ if (copy > length) copy = length;
+ length -= copy;
+ left -= copy;
+ do {
+ *put++ = *from++;
+ } while (--copy);
+ } while (length != 0);
+ break;
+
+ case DONE:
+ /* inflate stream terminated properly -- write leftover output */
+ ret = Z_STREAM_END;
+ if (left < WSIZE) {
+ if (out(out_desc, window, (unsigned)(WSIZE - left)))
+ ret = Z_BUF_ERROR;
+ }
+ goto inf_leave;
+
+ case BAD:
+ ret = Z_DATA_ERROR;
+ goto inf_leave;
+
+ default: /* can't happen, but makes compilers happy */
+ ret = Z_STREAM_ERROR;
+ goto inf_leave;
+ }
+
+ /* Return unused input */
+ inf_leave:
+ strm->next_in = next;
+ strm->avail_in = have;
+ return ret;
+}
+
+int ZEXPORT inflateBack9End(strm)
+z_stream FAR *strm;
+{
+ if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
+ return Z_STREAM_ERROR;
+ ZFREE(strm, strm->state);
+ strm->state = Z_NULL;
+ Tracev((stderr, "inflate: end\n"));
+ return Z_OK;
+}
diff --git a/zlib/contrib/infback9/infback9.h b/zlib/contrib/infback9/infback9.h
new file mode 100644
index 000000000..1073c0a38
--- /dev/null
+++ b/zlib/contrib/infback9/infback9.h
@@ -0,0 +1,37 @@
+/* infback9.h -- header for using inflateBack9 functions
+ * Copyright (C) 2003 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ * This header file and associated patches provide a decoder for PKWare's
+ * undocumented deflate64 compression method (method 9). Use with infback9.c,
+ * inftree9.h, inftree9.c, and inffix9.h. These patches are not supported.
+ * This should be compiled with zlib, since it uses zutil.h and zutil.o.
+ * This code has not yet been tested on 16-bit architectures. See the
+ * comments in zlib.h for inflateBack() usage. These functions are used
+ * identically, except that there is no windowBits parameter, and a 64K
+ * window must be provided. Also if int's are 16 bits, then a zero for
+ * the third parameter of the "out" function actually means 65536UL.
+ * zlib.h must be included before this header file.
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+ZEXTERN int ZEXPORT inflateBack9 OF((z_stream FAR *strm,
+ in_func in, void FAR *in_desc,
+ out_func out, void FAR *out_desc));
+ZEXTERN int ZEXPORT inflateBack9End OF((z_stream FAR *strm));
+ZEXTERN int ZEXPORT inflateBack9Init_ OF((z_stream FAR *strm,
+ unsigned char FAR *window,
+ const char *version,
+ int stream_size));
+#define inflateBack9Init(strm, window) \
+ inflateBack9Init_((strm), (window), \
+ ZLIB_VERSION, sizeof(z_stream))
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/zlib/contrib/infback9/inffix9.h b/zlib/contrib/infback9/inffix9.h
new file mode 100644
index 000000000..ee5671d2d
--- /dev/null
+++ b/zlib/contrib/infback9/inffix9.h
@@ -0,0 +1,107 @@
+ /* inffix9.h -- table for decoding deflate64 fixed codes
+ * Generated automatically by makefixed9().
+ */
+
+ /* 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},{132,8,115},{130,7,31},{0,8,112},
+ {0,8,48},{0,9,192},{128,7,10},{0,8,96},{0,8,32},{0,9,160},
+ {0,8,0},{0,8,128},{0,8,64},{0,9,224},{128,7,6},{0,8,88},
+ {0,8,24},{0,9,144},{131,7,59},{0,8,120},{0,8,56},{0,9,208},
+ {129,7,17},{0,8,104},{0,8,40},{0,9,176},{0,8,8},{0,8,136},
+ {0,8,72},{0,9,240},{128,7,4},{0,8,84},{0,8,20},{133,8,227},
+ {131,7,43},{0,8,116},{0,8,52},{0,9,200},{129,7,13},{0,8,100},
+ {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},
+ {128,7,8},{0,8,92},{0,8,28},{0,9,152},{132,7,83},{0,8,124},
+ {0,8,60},{0,9,216},{130,7,23},{0,8,108},{0,8,44},{0,9,184},
+ {0,8,12},{0,8,140},{0,8,76},{0,9,248},{128,7,3},{0,8,82},
+ {0,8,18},{133,8,163},{131,7,35},{0,8,114},{0,8,50},{0,9,196},
+ {129,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},{0,8,130},
+ {0,8,66},{0,9,228},{128,7,7},{0,8,90},{0,8,26},{0,9,148},
+ {132,7,67},{0,8,122},{0,8,58},{0,9,212},{130,7,19},{0,8,106},
+ {0,8,42},{0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},
+ {128,7,5},{0,8,86},{0,8,22},{65,8,0},{131,7,51},{0,8,118},
+ {0,8,54},{0,9,204},{129,7,15},{0,8,102},{0,8,38},{0,9,172},
+ {0,8,6},{0,8,134},{0,8,70},{0,9,236},{128,7,9},{0,8,94},
+ {0,8,30},{0,9,156},{132,7,99},{0,8,126},{0,8,62},{0,9,220},
+ {130,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},{133,8,131},
+ {130,7,31},{0,8,113},{0,8,49},{0,9,194},{128,7,10},{0,8,97},
+ {0,8,33},{0,9,162},{0,8,1},{0,8,129},{0,8,65},{0,9,226},
+ {128,7,6},{0,8,89},{0,8,25},{0,9,146},{131,7,59},{0,8,121},
+ {0,8,57},{0,9,210},{129,7,17},{0,8,105},{0,8,41},{0,9,178},
+ {0,8,9},{0,8,137},{0,8,73},{0,9,242},{128,7,4},{0,8,85},
+ {0,8,21},{144,8,3},{131,7,43},{0,8,117},{0,8,53},{0,9,202},
+ {129,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},
+ {0,8,69},{0,9,234},{128,7,8},{0,8,93},{0,8,29},{0,9,154},
+ {132,7,83},{0,8,125},{0,8,61},{0,9,218},{130,7,23},{0,8,109},
+ {0,8,45},{0,9,186},{0,8,13},{0,8,141},{0,8,77},{0,9,250},
+ {128,7,3},{0,8,83},{0,8,19},{133,8,195},{131,7,35},{0,8,115},
+ {0,8,51},{0,9,198},{129,7,11},{0,8,99},{0,8,35},{0,9,166},
+ {0,8,3},{0,8,131},{0,8,67},{0,9,230},{128,7,7},{0,8,91},
+ {0,8,27},{0,9,150},{132,7,67},{0,8,123},{0,8,59},{0,9,214},
+ {130,7,19},{0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},
+ {0,8,75},{0,9,246},{128,7,5},{0,8,87},{0,8,23},{77,8,0},
+ {131,7,51},{0,8,119},{0,8,55},{0,9,206},{129,7,15},{0,8,103},
+ {0,8,39},{0,9,174},{0,8,7},{0,8,135},{0,8,71},{0,9,238},
+ {128,7,9},{0,8,95},{0,8,31},{0,9,158},{132,7,99},{0,8,127},
+ {0,8,63},{0,9,222},{130,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},{132,8,115},{130,7,31},{0,8,112},{0,8,48},{0,9,193},
+ {128,7,10},{0,8,96},{0,8,32},{0,9,161},{0,8,0},{0,8,128},
+ {0,8,64},{0,9,225},{128,7,6},{0,8,88},{0,8,24},{0,9,145},
+ {131,7,59},{0,8,120},{0,8,56},{0,9,209},{129,7,17},{0,8,104},
+ {0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},{0,9,241},
+ {128,7,4},{0,8,84},{0,8,20},{133,8,227},{131,7,43},{0,8,116},
+ {0,8,52},{0,9,201},{129,7,13},{0,8,100},{0,8,36},{0,9,169},
+ {0,8,4},{0,8,132},{0,8,68},{0,9,233},{128,7,8},{0,8,92},
+ {0,8,28},{0,9,153},{132,7,83},{0,8,124},{0,8,60},{0,9,217},
+ {130,7,23},{0,8,108},{0,8,44},{0,9,185},{0,8,12},{0,8,140},
+ {0,8,76},{0,9,249},{128,7,3},{0,8,82},{0,8,18},{133,8,163},
+ {131,7,35},{0,8,114},{0,8,50},{0,9,197},{129,7,11},{0,8,98},
+ {0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
+ {128,7,7},{0,8,90},{0,8,26},{0,9,149},{132,7,67},{0,8,122},
+ {0,8,58},{0,9,213},{130,7,19},{0,8,106},{0,8,42},{0,9,181},
+ {0,8,10},{0,8,138},{0,8,74},{0,9,245},{128,7,5},{0,8,86},
+ {0,8,22},{65,8,0},{131,7,51},{0,8,118},{0,8,54},{0,9,205},
+ {129,7,15},{0,8,102},{0,8,38},{0,9,173},{0,8,6},{0,8,134},
+ {0,8,70},{0,9,237},{128,7,9},{0,8,94},{0,8,30},{0,9,157},
+ {132,7,99},{0,8,126},{0,8,62},{0,9,221},{130,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},{133,8,131},{130,7,31},{0,8,113},
+ {0,8,49},{0,9,195},{128,7,10},{0,8,97},{0,8,33},{0,9,163},
+ {0,8,1},{0,8,129},{0,8,65},{0,9,227},{128,7,6},{0,8,89},
+ {0,8,25},{0,9,147},{131,7,59},{0,8,121},{0,8,57},{0,9,211},
+ {129,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},{0,8,137},
+ {0,8,73},{0,9,243},{128,7,4},{0,8,85},{0,8,21},{144,8,3},
+ {131,7,43},{0,8,117},{0,8,53},{0,9,203},{129,7,13},{0,8,101},
+ {0,8,37},{0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},
+ {128,7,8},{0,8,93},{0,8,29},{0,9,155},{132,7,83},{0,8,125},
+ {0,8,61},{0,9,219},{130,7,23},{0,8,109},{0,8,45},{0,9,187},
+ {0,8,13},{0,8,141},{0,8,77},{0,9,251},{128,7,3},{0,8,83},
+ {0,8,19},{133,8,195},{131,7,35},{0,8,115},{0,8,51},{0,9,199},
+ {129,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
+ {0,8,67},{0,9,231},{128,7,7},{0,8,91},{0,8,27},{0,9,151},
+ {132,7,67},{0,8,123},{0,8,59},{0,9,215},{130,7,19},{0,8,107},
+ {0,8,43},{0,9,183},{0,8,11},{0,8,139},{0,8,75},{0,9,247},
+ {128,7,5},{0,8,87},{0,8,23},{77,8,0},{131,7,51},{0,8,119},
+ {0,8,55},{0,9,207},{129,7,15},{0,8,103},{0,8,39},{0,9,175},
+ {0,8,7},{0,8,135},{0,8,71},{0,9,239},{128,7,9},{0,8,95},
+ {0,8,31},{0,9,159},{132,7,99},{0,8,127},{0,8,63},{0,9,223},
+ {130,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] = {
+ {128,5,1},{135,5,257},{131,5,17},{139,5,4097},{129,5,5},
+ {137,5,1025},{133,5,65},{141,5,16385},{128,5,3},{136,5,513},
+ {132,5,33},{140,5,8193},{130,5,9},{138,5,2049},{134,5,129},
+ {142,5,32769},{128,5,2},{135,5,385},{131,5,25},{139,5,6145},
+ {129,5,7},{137,5,1537},{133,5,97},{141,5,24577},{128,5,4},
+ {136,5,769},{132,5,49},{140,5,12289},{130,5,13},{138,5,3073},
+ {134,5,193},{142,5,49153}
+ };
diff --git a/zlib/contrib/infback9/inflate9.h b/zlib/contrib/infback9/inflate9.h
new file mode 100644
index 000000000..ee9a79394
--- /dev/null
+++ b/zlib/contrib/infback9/inflate9.h
@@ -0,0 +1,47 @@
+/* inflate9.h -- internal inflate state definition
+ * Copyright (C) 1995-2003 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.
+ */
+
+/* Possible inflate modes between inflate() calls */
+typedef enum {
+ TYPE, /* i: waiting for type bits, including last-flag bit */
+ STORED, /* i: waiting for stored size (length and complement) */
+ TABLE, /* i: waiting for dynamic block table lengths */
+ LEN, /* i: waiting for length/lit code */
+ DONE, /* finished check, done -- remain here until reset */
+ BAD /* got a data error -- remain here until reset */
+} inflate_mode;
+
+/*
+ State transitions between above modes -
+
+ (most modes can go to the BAD mode -- not shown for clarity)
+
+ Read deflate blocks:
+ TYPE -> STORED or TABLE or LEN or DONE
+ STORED -> TYPE
+ TABLE -> LENLENS -> CODELENS -> LEN
+ Read deflate codes:
+ LEN -> LEN or TYPE
+ */
+
+/* state maintained between inflate() calls. Approximately 7K bytes. */
+struct inflate_state {
+ /* sliding window */
+ unsigned char FAR *window; /* allocated sliding window, if needed */
+ /* 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 */
+};
diff --git a/zlib/contrib/infback9/inftree9.c b/zlib/contrib/infback9/inftree9.c
new file mode 100644
index 000000000..5f4a76798
--- /dev/null
+++ b/zlib/contrib/infback9/inftree9.c
@@ -0,0 +1,324 @@
+/* inftree9.c -- generate Huffman trees for efficient decoding
+ * Copyright (C) 1995-2017 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "zutil.h"
+#include "inftree9.h"
+
+#define MAXBITS 15
+
+const char inflate9_copyright[] =
+ " inflate9 1.2.11 Copyright 1995-2017 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 inflate_table9(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 this; /* 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, 3, 0, 0};
+ static const unsigned short lext[31] = { /* Length codes 257..285 extra */
+ 128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129,
+ 130, 130, 130, 130, 131, 131, 131, 131, 132, 132, 132, 132,
+ 133, 133, 133, 133, 144, 77, 202};
+ static const unsigned short dbase[32] = { /* Distance codes 0..31 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, 32769, 49153};
+ static const unsigned short dext[32] = { /* Distance codes 0..31 extra */
+ 128, 128, 128, 128, 129, 129, 130, 130, 131, 131, 132, 132,
+ 133, 133, 134, 134, 135, 135, 136, 136, 137, 137, 138, 138,
+ 139, 139, 140, 140, 141, 141, 142, 142};
+
+ /*
+ 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) return -1; /* no codes! */
+ for (min = 1; min <= MAXBITS; 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 inftree9.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 */
+ this.bits = (unsigned char)(len - drop);
+ if ((int)(work[sym]) < end) {
+ this.op = (unsigned char)0;
+ this.val = work[sym];
+ }
+ else if ((int)(work[sym]) > end) {
+ this.op = (unsigned char)(extra[work[sym]]);
+ this.val = base[work[sym]];
+ }
+ else {
+ this.op = (unsigned char)(32 + 64); /* end of block */
+ this.val = 0;
+ }
+
+ /* replicate for those indices with low len bits equal to huff */
+ incr = 1U << (len - drop);
+ fill = 1U << curr;
+ do {
+ fill -= incr;
+ next[(huff >> drop) + fill] = this;
+ } 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 += 1U << 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 rest of table for incomplete codes. This loop is similar to the
+ loop above in incrementing huff for table indices. It is assumed that
+ len is equal to curr + drop, so there is no loop needed to increment
+ through high index bits. When the current sub-table is filled, the loop
+ drops back to the root table to fill in any remaining entries there.
+ */
+ this.op = (unsigned char)64; /* invalid code marker */
+ this.bits = (unsigned char)(len - drop);
+ this.val = (unsigned short)0;
+ while (huff != 0) {
+ /* when done with sub-table, drop back to root table */
+ if (drop != 0 && (huff & mask) != low) {
+ drop = 0;
+ len = root;
+ next = *table;
+ curr = root;
+ this.bits = (unsigned char)len;
+ }
+
+ /* put invalid code marker in table */
+ next[huff >> drop] = this;
+
+ /* 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;
+ }
+
+ /* set return parameters */
+ *table += used;
+ *bits = root;
+ return 0;
+}
diff --git a/zlib/contrib/infback9/inftree9.h b/zlib/contrib/infback9/inftree9.h
new file mode 100644
index 000000000..5ab21f0c6
--- /dev/null
+++ b/zlib/contrib/infback9/inftree9.h
@@ -0,0 +1,61 @@
+/* inftree9.h -- header to use inftree9.c
+ * Copyright (C) 1995-2008 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
+ 100eeeee - 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
+ 1446, which is the sum of 852 for literal/length codes and 594 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 32 6 15" for distance codes returns 594.
+ The initial root table size (9 or 6) is found in the fifth argument of the
+ inflate_table() calls in infback9.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 594
+#define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS)
+
+/* Type of code to build for inflate_table9() */
+typedef enum {
+ CODES,
+ LENS,
+ DISTS
+} codetype;
+
+extern int inflate_table9 OF((codetype type, unsigned short FAR *lens,
+ unsigned codes, code FAR * FAR *table,
+ unsigned FAR *bits, unsigned short FAR *work));
diff --git a/zlib/contrib/minizip/Makefile b/zlib/contrib/minizip/Makefile
new file mode 100644
index 000000000..84eaad20d
--- /dev/null
+++ b/zlib/contrib/minizip/Makefile
@@ -0,0 +1,25 @@
+CC=cc
+CFLAGS=-O -I../..
+
+UNZ_OBJS = miniunz.o unzip.o ioapi.o ../../libz.a
+ZIP_OBJS = minizip.o zip.o ioapi.o ../../libz.a
+
+.c.o:
+ $(CC) -c $(CFLAGS) $*.c
+
+all: miniunz minizip
+
+miniunz: $(UNZ_OBJS)
+ $(CC) $(CFLAGS) -o $@ $(UNZ_OBJS)
+
+minizip: $(ZIP_OBJS)
+ $(CC) $(CFLAGS) -o $@ $(ZIP_OBJS)
+
+test: miniunz minizip
+ ./minizip test readme.txt
+ ./miniunz -l test.zip
+ mv readme.txt readme.old
+ ./miniunz test.zip
+
+clean:
+ /bin/rm -f *.o *~ minizip miniunz
diff --git a/zlib/contrib/minizip/Makefile.am b/zlib/contrib/minizip/Makefile.am
new file mode 100644
index 000000000..d343011eb
--- /dev/null
+++ b/zlib/contrib/minizip/Makefile.am
@@ -0,0 +1,45 @@
+lib_LTLIBRARIES = libminizip.la
+
+if COND_DEMOS
+bin_PROGRAMS = miniunzip minizip
+endif
+
+zlib_top_srcdir = $(top_srcdir)/../..
+zlib_top_builddir = $(top_builddir)/../..
+
+AM_CPPFLAGS = -I$(zlib_top_srcdir)
+AM_LDFLAGS = -L$(zlib_top_builddir)
+
+if WIN32
+iowin32_src = iowin32.c
+iowin32_h = iowin32.h
+endif
+
+libminizip_la_SOURCES = \
+ ioapi.c \
+ mztools.c \
+ unzip.c \
+ zip.c \
+ ${iowin32_src}
+
+libminizip_la_LDFLAGS = $(AM_LDFLAGS) -version-info 1:0:0 -lz
+
+minizip_includedir = $(includedir)/minizip
+minizip_include_HEADERS = \
+ crypt.h \
+ ioapi.h \
+ mztools.h \
+ unzip.h \
+ zip.h \
+ ${iowin32_h}
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = minizip.pc
+
+EXTRA_PROGRAMS = miniunzip minizip
+
+miniunzip_SOURCES = miniunz.c
+miniunzip_LDADD = libminizip.la
+
+minizip_SOURCES = minizip.c
+minizip_LDADD = libminizip.la -lz
diff --git a/zlib/contrib/minizip/MiniZip64_Changes.txt b/zlib/contrib/minizip/MiniZip64_Changes.txt
new file mode 100644
index 000000000..13a1bd91a
--- /dev/null
+++ b/zlib/contrib/minizip/MiniZip64_Changes.txt
@@ -0,0 +1,6 @@
+
+MiniZip 1.1 was derrived from MiniZip at version 1.01f
+
+Change in 1.0 (Okt 2009)
+ - **TODO - Add history**
+
diff --git a/zlib/contrib/minizip/MiniZip64_info.txt b/zlib/contrib/minizip/MiniZip64_info.txt
new file mode 100644
index 000000000..57d715242
--- /dev/null
+++ b/zlib/contrib/minizip/MiniZip64_info.txt
@@ -0,0 +1,74 @@
+MiniZip - Copyright (c) 1998-2010 - by Gilles Vollant - version 1.1 64 bits from Mathias Svensson
+
+Introduction
+---------------------
+MiniZip 1.1 is built from MiniZip 1.0 by Gilles Vollant ( http://www.winimage.com/zLibDll/minizip.html )
+
+When adding ZIP64 support into minizip it would result into risk of breaking compatibility with minizip 1.0.
+All possible work was done for compatibility.
+
+
+Background
+---------------------
+When adding ZIP64 support Mathias Svensson found that Even Rouault have added ZIP64
+support for unzip.c into minizip for a open source project called gdal ( http://www.gdal.org/ )
+
+That was used as a starting point. And after that ZIP64 support was added to zip.c
+some refactoring and code cleanup was also done.
+
+
+Changed from MiniZip 1.0 to MiniZip 1.1
+---------------------------------------
+* Added ZIP64 support for unzip ( by Even Rouault )
+* Added ZIP64 support for zip ( by Mathias Svensson )
+* Reverted some changed that Even Rouault did.
+* Bunch of patches received from Gulles Vollant that he received for MiniZip from various users.
+* Added unzip patch for BZIP Compression method (patch create by Daniel Borca)
+* Added BZIP Compress method for zip
+* Did some refactoring and code cleanup
+
+
+Credits
+
+ Gilles Vollant - Original MiniZip author
+ Even Rouault - ZIP64 unzip Support
+ Daniel Borca - BZip Compression method support in unzip
+ Mathias Svensson - ZIP64 zip support
+ Mathias Svensson - BZip Compression method support in zip
+
+ Resources
+
+ ZipLayout http://result42.com/projects/ZipFileLayout
+ Command line tool for Windows that shows the layout and information of the headers in a zip archive.
+ Used when debugging and validating the creation of zip files using MiniZip64
+
+
+ ZIP App Note http://www.pkware.com/documents/casestudies/APPNOTE.TXT
+ Zip File specification
+
+
+Notes.
+ * To be able to use BZip compression method in zip64.c or unzip64.c the BZIP2 lib is needed and HAVE_BZIP2 need to be defined.
+
+License
+----------------------------------------------------------
+ Condition of use and distribution are the same than zlib :
+
+ 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.
+
+----------------------------------------------------------
+
diff --git a/zlib/contrib/minizip/configure.ac b/zlib/contrib/minizip/configure.ac
new file mode 100644
index 000000000..5b1197097
--- /dev/null
+++ b/zlib/contrib/minizip/configure.ac
@@ -0,0 +1,32 @@
+# -*- Autoconf -*-
+# Process this file with autoconf to produce a configure script.
+
+AC_INIT([minizip], [1.2.11], [bugzilla.redhat.com])
+AC_CONFIG_SRCDIR([minizip.c])
+AM_INIT_AUTOMAKE([foreign])
+LT_INIT
+
+AC_MSG_CHECKING([whether to build example programs])
+AC_ARG_ENABLE([demos], AC_HELP_STRING([--enable-demos], [build example programs]))
+AM_CONDITIONAL([COND_DEMOS], [test "$enable_demos" = yes])
+if test "$enable_demos" = yes
+then
+ AC_MSG_RESULT([yes])
+else
+ AC_MSG_RESULT([no])
+fi
+
+case "${host}" in
+ *-mingw* | mingw*)
+ WIN32="yes"
+ ;;
+ *)
+ ;;
+esac
+AM_CONDITIONAL([WIN32], [test "${WIN32}" = "yes"])
+
+
+AC_SUBST([HAVE_UNISTD_H], [0])
+AC_CHECK_HEADER([unistd.h], [HAVE_UNISTD_H=1], [])
+AC_CONFIG_FILES([Makefile minizip.pc])
+AC_OUTPUT
diff --git a/zlib/contrib/minizip/crypt.h b/zlib/contrib/minizip/crypt.h
new file mode 100644
index 000000000..1e9e8200b
--- /dev/null
+++ b/zlib/contrib/minizip/crypt.h
@@ -0,0 +1,131 @@
+/* crypt.h -- base code for crypt/uncrypt ZIPfile
+
+
+ Version 1.01e, February 12th, 2005
+
+ Copyright (C) 1998-2005 Gilles Vollant
+
+ This code is a modified version of crypting code in Infozip distribution
+
+ The encryption/decryption parts of this source code (as opposed to the
+ non-echoing password parts) were originally written in Europe. The
+ whole source package can be freely distributed, including from the USA.
+ (Prior to January 2000, re-export from the US was a violation of US law.)
+
+ This encryption code is a direct transcription of the algorithm from
+ Roger Schlafly, described by Phil Katz in the file appnote.txt. This
+ file (appnote.txt) is distributed with the PKZIP program (even in the
+ version without encryption capabilities).
+
+ If you don't need crypting in your application, just define symbols
+ NOCRYPT and NOUNCRYPT.
+
+ This code support the "Traditional PKWARE Encryption".
+
+ The new AES encryption added on Zip format by Winzip (see the page
+ http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong
+ Encryption is not supported.
+*/
+
+#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
+
+/***********************************************************************
+ * Return the next byte in the pseudo-random sequence
+ */
+static int decrypt_byte(unsigned long* pkeys, const z_crc_t* pcrc_32_tab)
+{
+ unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an
+ * unpredictable manner on 16-bit systems; not a problem
+ * with any known compiler so far, though */
+
+ temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
+ return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
+}
+
+/***********************************************************************
+ * Update the encryption keys with the next byte of plain text
+ */
+static int update_keys(unsigned long* pkeys,const z_crc_t* pcrc_32_tab,int c)
+{
+ (*(pkeys+0)) = CRC32((*(pkeys+0)), c);
+ (*(pkeys+1)) += (*(pkeys+0)) & 0xff;
+ (*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
+ {
+ register int keyshift = (int)((*(pkeys+1)) >> 24);
+ (*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
+ }
+ return c;
+}
+
+
+/***********************************************************************
+ * Initialize the encryption keys and the random header according to
+ * the given password.
+ */
+static void init_keys(const char* passwd,unsigned long* pkeys,const z_crc_t* pcrc_32_tab)
+{
+ *(pkeys+0) = 305419896L;
+ *(pkeys+1) = 591751049L;
+ *(pkeys+2) = 878082192L;
+ while (*passwd != '\0') {
+ update_keys(pkeys,pcrc_32_tab,(int)*passwd);
+ passwd++;
+ }
+}
+
+#define zdecode(pkeys,pcrc_32_tab,c) \
+ (update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
+
+#define zencode(pkeys,pcrc_32_tab,c,t) \
+ (t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))
+
+#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
+
+#define RAND_HEAD_LEN 12
+ /* "last resort" source for second part of crypt seed pattern */
+# ifndef ZCR_SEED2
+# define ZCR_SEED2 3141592654UL /* use PI as default pattern */
+# endif
+
+static int crypthead(const char* passwd, /* password string */
+ unsigned char* buf, /* where to write header */
+ int bufSize,
+ unsigned long* pkeys,
+ const z_crc_t* pcrc_32_tab,
+ unsigned long crcForCrypting)
+{
+ int n; /* index in random header */
+ int t; /* temporary */
+ int c; /* random byte */
+ unsigned char header[RAND_HEAD_LEN-2]; /* random header */
+ static unsigned calls = 0; /* ensure different random header each time */
+
+ if (bufSize<RAND_HEAD_LEN)
+ return 0;
+
+ /* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
+ * output of rand() to get less predictability, since rand() is
+ * often poorly implemented.
+ */
+ if (++calls == 1)
+ {
+ srand((unsigned)(time(NULL) ^ ZCR_SEED2));
+ }
+ init_keys(passwd, pkeys, pcrc_32_tab);
+ for (n = 0; n < RAND_HEAD_LEN-2; n++)
+ {
+ c = (rand() >> 7) & 0xff;
+ header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
+ }
+ /* Encrypt random header (last two bytes is high word of crc) */
+ init_keys(passwd, pkeys, pcrc_32_tab);
+ for (n = 0; n < RAND_HEAD_LEN-2; n++)
+ {
+ buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
+ }
+ buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
+ buf[n++] = (unsigned char)zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
+ return n;
+}
+
+#endif
diff --git a/zlib/contrib/minizip/ioapi.c b/zlib/contrib/minizip/ioapi.c
new file mode 100644
index 000000000..7f5c191b2
--- /dev/null
+++ b/zlib/contrib/minizip/ioapi.c
@@ -0,0 +1,247 @@
+/* ioapi.h -- IO base function header for compress/uncompress .zip
+ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Modifications for Zip64 support
+ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+ For more info read MiniZip_info.txt
+
+*/
+
+#if defined(_WIN32) && (!(defined(_CRT_SECURE_NO_WARNINGS)))
+ #define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#if defined(__APPLE__) || defined(IOAPI_NO_64)
+// In darwin and perhaps other BSD variants off_t is a 64 bit value, hence no need for specific 64 bit functions
+#define FOPEN_FUNC(filename, mode) fopen(filename, mode)
+#define FTELLO_FUNC(stream) ftello(stream)
+#define FSEEKO_FUNC(stream, offset, origin) fseeko(stream, offset, origin)
+#else
+#define FOPEN_FUNC(filename, mode) fopen64(filename, mode)
+#define FTELLO_FUNC(stream) ftello64(stream)
+#define FSEEKO_FUNC(stream, offset, origin) fseeko64(stream, offset, origin)
+#endif
+
+
+#include "ioapi.h"
+
+voidpf call_zopen64 (const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode)
+{
+ if (pfilefunc->zfile_func64.zopen64_file != NULL)
+ return (*(pfilefunc->zfile_func64.zopen64_file)) (pfilefunc->zfile_func64.opaque,filename,mode);
+ else
+ {
+ return (*(pfilefunc->zopen32_file))(pfilefunc->zfile_func64.opaque,(const char*)filename,mode);
+ }
+}
+
+long call_zseek64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin)
+{
+ if (pfilefunc->zfile_func64.zseek64_file != NULL)
+ return (*(pfilefunc->zfile_func64.zseek64_file)) (pfilefunc->zfile_func64.opaque,filestream,offset,origin);
+ else
+ {
+ uLong offsetTruncated = (uLong)offset;
+ if (offsetTruncated != offset)
+ return -1;
+ else
+ return (*(pfilefunc->zseek32_file))(pfilefunc->zfile_func64.opaque,filestream,offsetTruncated,origin);
+ }
+}
+
+ZPOS64_T call_ztell64 (const zlib_filefunc64_32_def* pfilefunc,voidpf filestream)
+{
+ if (pfilefunc->zfile_func64.zseek64_file != NULL)
+ return (*(pfilefunc->zfile_func64.ztell64_file)) (pfilefunc->zfile_func64.opaque,filestream);
+ else
+ {
+ uLong tell_uLong = (*(pfilefunc->ztell32_file))(pfilefunc->zfile_func64.opaque,filestream);
+ if ((tell_uLong) == MAXU32)
+ return (ZPOS64_T)-1;
+ else
+ return tell_uLong;
+ }
+}
+
+void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32)
+{
+ p_filefunc64_32->zfile_func64.zopen64_file = NULL;
+ p_filefunc64_32->zopen32_file = p_filefunc32->zopen_file;
+ p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
+ p_filefunc64_32->zfile_func64.zread_file = p_filefunc32->zread_file;
+ p_filefunc64_32->zfile_func64.zwrite_file = p_filefunc32->zwrite_file;
+ p_filefunc64_32->zfile_func64.ztell64_file = NULL;
+ p_filefunc64_32->zfile_func64.zseek64_file = NULL;
+ p_filefunc64_32->zfile_func64.zclose_file = p_filefunc32->zclose_file;
+ p_filefunc64_32->zfile_func64.zerror_file = p_filefunc32->zerror_file;
+ p_filefunc64_32->zfile_func64.opaque = p_filefunc32->opaque;
+ p_filefunc64_32->zseek32_file = p_filefunc32->zseek_file;
+ p_filefunc64_32->ztell32_file = p_filefunc32->ztell_file;
+}
+
+
+
+static voidpf ZCALLBACK fopen_file_func OF((voidpf opaque, const char* filename, int mode));
+static uLong ZCALLBACK fread_file_func OF((voidpf opaque, voidpf stream, void* buf, uLong size));
+static uLong ZCALLBACK fwrite_file_func OF((voidpf opaque, voidpf stream, const void* buf,uLong size));
+static ZPOS64_T ZCALLBACK ftell64_file_func OF((voidpf opaque, voidpf stream));
+static long ZCALLBACK fseek64_file_func OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
+static int ZCALLBACK fclose_file_func OF((voidpf opaque, voidpf stream));
+static int ZCALLBACK ferror_file_func OF((voidpf opaque, voidpf stream));
+
+static voidpf ZCALLBACK fopen_file_func (voidpf opaque, const char* filename, int mode)
+{
+ FILE* file = NULL;
+ const char* mode_fopen = NULL;
+ if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
+ mode_fopen = "rb";
+ else
+ if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+ mode_fopen = "r+b";
+ else
+ if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+ mode_fopen = "wb";
+
+ if ((filename!=NULL) && (mode_fopen != NULL))
+ file = fopen(filename, mode_fopen);
+ return file;
+}
+
+static voidpf ZCALLBACK fopen64_file_func (voidpf opaque, const void* filename, int mode)
+{
+ FILE* file = NULL;
+ const char* mode_fopen = NULL;
+ if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
+ mode_fopen = "rb";
+ else
+ if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+ mode_fopen = "r+b";
+ else
+ if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+ mode_fopen = "wb";
+
+ if ((filename!=NULL) && (mode_fopen != NULL))
+ file = FOPEN_FUNC((const char*)filename, mode_fopen);
+ return file;
+}
+
+
+static uLong ZCALLBACK fread_file_func (voidpf opaque, voidpf stream, void* buf, uLong size)
+{
+ uLong ret;
+ ret = (uLong)fread(buf, 1, (size_t)size, (FILE *)stream);
+ return ret;
+}
+
+static uLong ZCALLBACK fwrite_file_func (voidpf opaque, voidpf stream, const void* buf, uLong size)
+{
+ uLong ret;
+ ret = (uLong)fwrite(buf, 1, (size_t)size, (FILE *)stream);
+ return ret;
+}
+
+static long ZCALLBACK ftell_file_func (voidpf opaque, voidpf stream)
+{
+ long ret;
+ ret = ftell((FILE *)stream);
+ return ret;
+}
+
+
+static ZPOS64_T ZCALLBACK ftell64_file_func (voidpf opaque, voidpf stream)
+{
+ ZPOS64_T ret;
+ ret = FTELLO_FUNC((FILE *)stream);
+ return ret;
+}
+
+static long ZCALLBACK fseek_file_func (voidpf opaque, voidpf stream, uLong offset, int origin)
+{
+ int fseek_origin=0;
+ long ret;
+ switch (origin)
+ {
+ case ZLIB_FILEFUNC_SEEK_CUR :
+ fseek_origin = SEEK_CUR;
+ break;
+ case ZLIB_FILEFUNC_SEEK_END :
+ fseek_origin = SEEK_END;
+ break;
+ case ZLIB_FILEFUNC_SEEK_SET :
+ fseek_origin = SEEK_SET;
+ break;
+ default: return -1;
+ }
+ ret = 0;
+ if (fseek((FILE *)stream, offset, fseek_origin) != 0)
+ ret = -1;
+ return ret;
+}
+
+static long ZCALLBACK fseek64_file_func (voidpf opaque, voidpf stream, ZPOS64_T offset, int origin)
+{
+ int fseek_origin=0;
+ long ret;
+ switch (origin)
+ {
+ case ZLIB_FILEFUNC_SEEK_CUR :
+ fseek_origin = SEEK_CUR;
+ break;
+ case ZLIB_FILEFUNC_SEEK_END :
+ fseek_origin = SEEK_END;
+ break;
+ case ZLIB_FILEFUNC_SEEK_SET :
+ fseek_origin = SEEK_SET;
+ break;
+ default: return -1;
+ }
+ ret = 0;
+
+ if(FSEEKO_FUNC((FILE *)stream, offset, fseek_origin) != 0)
+ ret = -1;
+
+ return ret;
+}
+
+
+static int ZCALLBACK fclose_file_func (voidpf opaque, voidpf stream)
+{
+ int ret;
+ ret = fclose((FILE *)stream);
+ return ret;
+}
+
+static int ZCALLBACK ferror_file_func (voidpf opaque, voidpf stream)
+{
+ int ret;
+ ret = ferror((FILE *)stream);
+ return ret;
+}
+
+void fill_fopen_filefunc (pzlib_filefunc_def)
+ zlib_filefunc_def* pzlib_filefunc_def;
+{
+ pzlib_filefunc_def->zopen_file = fopen_file_func;
+ pzlib_filefunc_def->zread_file = fread_file_func;
+ pzlib_filefunc_def->zwrite_file = fwrite_file_func;
+ pzlib_filefunc_def->ztell_file = ftell_file_func;
+ pzlib_filefunc_def->zseek_file = fseek_file_func;
+ pzlib_filefunc_def->zclose_file = fclose_file_func;
+ pzlib_filefunc_def->zerror_file = ferror_file_func;
+ pzlib_filefunc_def->opaque = NULL;
+}
+
+void fill_fopen64_filefunc (zlib_filefunc64_def* pzlib_filefunc_def)
+{
+ pzlib_filefunc_def->zopen64_file = fopen64_file_func;
+ pzlib_filefunc_def->zread_file = fread_file_func;
+ pzlib_filefunc_def->zwrite_file = fwrite_file_func;
+ pzlib_filefunc_def->ztell64_file = ftell64_file_func;
+ pzlib_filefunc_def->zseek64_file = fseek64_file_func;
+ pzlib_filefunc_def->zclose_file = fclose_file_func;
+ pzlib_filefunc_def->zerror_file = ferror_file_func;
+ pzlib_filefunc_def->opaque = NULL;
+}
diff --git a/zlib/contrib/minizip/ioapi.h b/zlib/contrib/minizip/ioapi.h
new file mode 100644
index 000000000..8dcbdb06e
--- /dev/null
+++ b/zlib/contrib/minizip/ioapi.h
@@ -0,0 +1,208 @@
+/* ioapi.h -- IO base function header for compress/uncompress .zip
+ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Modifications for Zip64 support
+ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+ For more info read MiniZip_info.txt
+
+ Changes
+
+ Oct-2009 - Defined ZPOS64_T to fpos_t on windows and u_int64_t on linux. (might need to find a better why for this)
+ Oct-2009 - Change to fseeko64, ftello64 and fopen64 so large files would work on linux.
+ More if/def section may be needed to support other platforms
+ Oct-2009 - Defined fxxxx64 calls to normal fopen/ftell/fseek so they would compile on windows.
+ (but you should use iowin32.c for windows instead)
+
+*/
+
+#ifndef _ZLIBIOAPI64_H
+#define _ZLIBIOAPI64_H
+
+#if (!defined(_WIN32)) && (!defined(WIN32)) && (!defined(__APPLE__))
+
+ // Linux needs this to support file operation on files larger then 4+GB
+ // But might need better if/def to select just the platforms that needs them.
+
+ #ifndef __USE_FILE_OFFSET64
+ #define __USE_FILE_OFFSET64
+ #endif
+ #ifndef __USE_LARGEFILE64
+ #define __USE_LARGEFILE64
+ #endif
+ #ifndef _LARGEFILE64_SOURCE
+ #define _LARGEFILE64_SOURCE
+ #endif
+ #ifndef _FILE_OFFSET_BIT
+ #define _FILE_OFFSET_BIT 64
+ #endif
+
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "zlib.h"
+
+#if defined(USE_FILE32API)
+#define fopen64 fopen
+#define ftello64 ftell
+#define fseeko64 fseek
+#else
+#ifdef __FreeBSD__
+#define fopen64 fopen
+#define ftello64 ftello
+#define fseeko64 fseeko
+#endif
+#ifdef _MSC_VER
+ #define fopen64 fopen
+ #if (_MSC_VER >= 1400) && (!(defined(NO_MSCVER_FILE64_FUNC)))
+ #define ftello64 _ftelli64
+ #define fseeko64 _fseeki64
+ #else // old MSC
+ #define ftello64 ftell
+ #define fseeko64 fseek
+ #endif
+#endif
+#endif
+
+/*
+#ifndef ZPOS64_T
+ #ifdef _WIN32
+ #define ZPOS64_T fpos_t
+ #else
+ #include <stdint.h>
+ #define ZPOS64_T uint64_t
+ #endif
+#endif
+*/
+
+#ifdef HAVE_MINIZIP64_CONF_H
+#include "mz64conf.h"
+#endif
+
+/* a type choosen by DEFINE */
+#ifdef HAVE_64BIT_INT_CUSTOM
+typedef 64BIT_INT_CUSTOM_TYPE ZPOS64_T;
+#else
+#ifdef HAS_STDINT_H
+#include "stdint.h"
+typedef uint64_t ZPOS64_T;
+#else
+
+/* Maximum unsigned 32-bit value used as placeholder for zip64 */
+#define MAXU32 0xffffffff
+
+#if defined(_MSC_VER) || defined(__BORLANDC__)
+typedef unsigned __int64 ZPOS64_T;
+#else
+typedef unsigned long long int ZPOS64_T;
+#endif
+#endif
+#endif
+
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#define ZLIB_FILEFUNC_SEEK_CUR (1)
+#define ZLIB_FILEFUNC_SEEK_END (2)
+#define ZLIB_FILEFUNC_SEEK_SET (0)
+
+#define ZLIB_FILEFUNC_MODE_READ (1)
+#define ZLIB_FILEFUNC_MODE_WRITE (2)
+#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
+
+#define ZLIB_FILEFUNC_MODE_EXISTING (4)
+#define ZLIB_FILEFUNC_MODE_CREATE (8)
+
+
+#ifndef ZCALLBACK
+ #if (defined(WIN32) || defined(_WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
+ #define ZCALLBACK CALLBACK
+ #else
+ #define ZCALLBACK
+ #endif
+#endif
+
+
+
+
+typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode));
+typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size));
+typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
+typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));
+typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
+
+typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
+typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));
+
+
+/* here is the "old" 32 bits structure structure */
+typedef struct zlib_filefunc_def_s
+{
+ open_file_func zopen_file;
+ read_file_func zread_file;
+ write_file_func zwrite_file;
+ tell_file_func ztell_file;
+ seek_file_func zseek_file;
+ close_file_func zclose_file;
+ testerror_file_func zerror_file;
+ voidpf opaque;
+} zlib_filefunc_def;
+
+typedef ZPOS64_T (ZCALLBACK *tell64_file_func) OF((voidpf opaque, voidpf stream));
+typedef long (ZCALLBACK *seek64_file_func) OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
+typedef voidpf (ZCALLBACK *open64_file_func) OF((voidpf opaque, const void* filename, int mode));
+
+typedef struct zlib_filefunc64_def_s
+{
+ open64_file_func zopen64_file;
+ read_file_func zread_file;
+ write_file_func zwrite_file;
+ tell64_file_func ztell64_file;
+ seek64_file_func zseek64_file;
+ close_file_func zclose_file;
+ testerror_file_func zerror_file;
+ voidpf opaque;
+} zlib_filefunc64_def;
+
+void fill_fopen64_filefunc OF((zlib_filefunc64_def* pzlib_filefunc_def));
+void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
+
+/* now internal definition, only for zip.c and unzip.h */
+typedef struct zlib_filefunc64_32_def_s
+{
+ zlib_filefunc64_def zfile_func64;
+ open_file_func zopen32_file;
+ tell_file_func ztell32_file;
+ seek_file_func zseek32_file;
+} zlib_filefunc64_32_def;
+
+
+#define ZREAD64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zread_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size))
+#define ZWRITE64(filefunc,filestream,buf,size) ((*((filefunc).zfile_func64.zwrite_file)) ((filefunc).zfile_func64.opaque,filestream,buf,size))
+//#define ZTELL64(filefunc,filestream) ((*((filefunc).ztell64_file)) ((filefunc).opaque,filestream))
+//#define ZSEEK64(filefunc,filestream,pos,mode) ((*((filefunc).zseek64_file)) ((filefunc).opaque,filestream,pos,mode))
+#define ZCLOSE64(filefunc,filestream) ((*((filefunc).zfile_func64.zclose_file)) ((filefunc).zfile_func64.opaque,filestream))
+#define ZERROR64(filefunc,filestream) ((*((filefunc).zfile_func64.zerror_file)) ((filefunc).zfile_func64.opaque,filestream))
+
+voidpf call_zopen64 OF((const zlib_filefunc64_32_def* pfilefunc,const void*filename,int mode));
+long call_zseek64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream, ZPOS64_T offset, int origin));
+ZPOS64_T call_ztell64 OF((const zlib_filefunc64_32_def* pfilefunc,voidpf filestream));
+
+void fill_zlib_filefunc64_32_def_from_filefunc32(zlib_filefunc64_32_def* p_filefunc64_32,const zlib_filefunc_def* p_filefunc32);
+
+#define ZOPEN64(filefunc,filename,mode) (call_zopen64((&(filefunc)),(filename),(mode)))
+#define ZTELL64(filefunc,filestream) (call_ztell64((&(filefunc)),(filestream)))
+#define ZSEEK64(filefunc,filestream,pos,mode) (call_zseek64((&(filefunc)),(filestream),(pos),(mode)))
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/zlib/contrib/minizip/iowin32.c b/zlib/contrib/minizip/iowin32.c
new file mode 100644
index 000000000..274f39eb1
--- /dev/null
+++ b/zlib/contrib/minizip/iowin32.c
@@ -0,0 +1,462 @@
+/* iowin32.c -- IO base function header for compress/uncompress .zip
+ Version 1.1, February 14h, 2010
+ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Modifications for Zip64 support
+ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+ For more info read MiniZip_info.txt
+
+*/
+
+#include <stdlib.h>
+
+#include "zlib.h"
+#include "ioapi.h"
+#include "iowin32.h"
+
+#ifndef INVALID_HANDLE_VALUE
+#define INVALID_HANDLE_VALUE (0xFFFFFFFF)
+#endif
+
+#ifndef INVALID_SET_FILE_POINTER
+#define INVALID_SET_FILE_POINTER ((DWORD)-1)
+#endif
+
+
+// see Include/shared/winapifamily.h in the Windows Kit
+#if defined(WINAPI_FAMILY_PARTITION) && (!(defined(IOWIN32_USING_WINRT_API)))
+#if WINAPI_FAMILY_ONE_PARTITION(WINAPI_FAMILY, WINAPI_PARTITION_APP)
+#define IOWIN32_USING_WINRT_API 1
+#endif
+#endif
+
+voidpf ZCALLBACK win32_open_file_func OF((voidpf opaque, const char* filename, int mode));
+uLong ZCALLBACK win32_read_file_func OF((voidpf opaque, voidpf stream, void* buf, uLong size));
+uLong ZCALLBACK win32_write_file_func OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
+ZPOS64_T ZCALLBACK win32_tell64_file_func OF((voidpf opaque, voidpf stream));
+long ZCALLBACK win32_seek64_file_func OF((voidpf opaque, voidpf stream, ZPOS64_T offset, int origin));
+int ZCALLBACK win32_close_file_func OF((voidpf opaque, voidpf stream));
+int ZCALLBACK win32_error_file_func OF((voidpf opaque, voidpf stream));
+
+typedef struct
+{
+ HANDLE hf;
+ int error;
+} WIN32FILE_IOWIN;
+
+
+static void win32_translate_open_mode(int mode,
+ DWORD* lpdwDesiredAccess,
+ DWORD* lpdwCreationDisposition,
+ DWORD* lpdwShareMode,
+ DWORD* lpdwFlagsAndAttributes)
+{
+ *lpdwDesiredAccess = *lpdwShareMode = *lpdwFlagsAndAttributes = *lpdwCreationDisposition = 0;
+
+ if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
+ {
+ *lpdwDesiredAccess = GENERIC_READ;
+ *lpdwCreationDisposition = OPEN_EXISTING;
+ *lpdwShareMode = FILE_SHARE_READ;
+ }
+ else if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
+ {
+ *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
+ *lpdwCreationDisposition = OPEN_EXISTING;
+ }
+ else if (mode & ZLIB_FILEFUNC_MODE_CREATE)
+ {
+ *lpdwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
+ *lpdwCreationDisposition = CREATE_ALWAYS;
+ }
+}
+
+static voidpf win32_build_iowin(HANDLE hFile)
+{
+ voidpf ret=NULL;
+
+ if ((hFile != NULL) && (hFile != INVALID_HANDLE_VALUE))
+ {
+ WIN32FILE_IOWIN w32fiow;
+ w32fiow.hf = hFile;
+ w32fiow.error = 0;
+ ret = malloc(sizeof(WIN32FILE_IOWIN));
+
+ if (ret==NULL)
+ CloseHandle(hFile);
+ else
+ *((WIN32FILE_IOWIN*)ret) = w32fiow;
+ }
+ return ret;
+}
+
+voidpf ZCALLBACK win32_open64_file_func (voidpf opaque,const void* filename,int mode)
+{
+ const char* mode_fopen = NULL;
+ DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
+ HANDLE hFile = NULL;
+
+ win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
+
+#ifdef IOWIN32_USING_WINRT_API
+#ifdef UNICODE
+ if ((filename!=NULL) && (dwDesiredAccess != 0))
+ hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
+#else
+ if ((filename!=NULL) && (dwDesiredAccess != 0))
+ {
+ WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
+ MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
+ hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
+ }
+#endif
+#else
+ if ((filename!=NULL) && (dwDesiredAccess != 0))
+ hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
+#endif
+
+ return win32_build_iowin(hFile);
+}
+
+
+voidpf ZCALLBACK win32_open64_file_funcA (voidpf opaque,const void* filename,int mode)
+{
+ const char* mode_fopen = NULL;
+ DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
+ HANDLE hFile = NULL;
+
+ win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
+
+#ifdef IOWIN32_USING_WINRT_API
+ if ((filename!=NULL) && (dwDesiredAccess != 0))
+ {
+ WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
+ MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
+ hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
+ }
+#else
+ if ((filename!=NULL) && (dwDesiredAccess != 0))
+ hFile = CreateFileA((LPCSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
+#endif
+
+ return win32_build_iowin(hFile);
+}
+
+
+voidpf ZCALLBACK win32_open64_file_funcW (voidpf opaque,const void* filename,int mode)
+{
+ const char* mode_fopen = NULL;
+ DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
+ HANDLE hFile = NULL;
+
+ win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
+
+#ifdef IOWIN32_USING_WINRT_API
+ if ((filename!=NULL) && (dwDesiredAccess != 0))
+ hFile = CreateFile2((LPCWSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition,NULL);
+#else
+ if ((filename!=NULL) && (dwDesiredAccess != 0))
+ hFile = CreateFileW((LPCWSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
+#endif
+
+ return win32_build_iowin(hFile);
+}
+
+
+voidpf ZCALLBACK win32_open_file_func (voidpf opaque,const char* filename,int mode)
+{
+ const char* mode_fopen = NULL;
+ DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
+ HANDLE hFile = NULL;
+
+ win32_translate_open_mode(mode,&dwDesiredAccess,&dwCreationDisposition,&dwShareMode,&dwFlagsAndAttributes);
+
+#ifdef IOWIN32_USING_WINRT_API
+#ifdef UNICODE
+ if ((filename!=NULL) && (dwDesiredAccess != 0))
+ hFile = CreateFile2((LPCTSTR)filename, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
+#else
+ if ((filename!=NULL) && (dwDesiredAccess != 0))
+ {
+ WCHAR filenameW[FILENAME_MAX + 0x200 + 1];
+ MultiByteToWideChar(CP_ACP,0,(const char*)filename,-1,filenameW,FILENAME_MAX + 0x200);
+ hFile = CreateFile2(filenameW, dwDesiredAccess, dwShareMode, dwCreationDisposition, NULL);
+ }
+#endif
+#else
+ if ((filename!=NULL) && (dwDesiredAccess != 0))
+ hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL, dwCreationDisposition, dwFlagsAndAttributes, NULL);
+#endif
+
+ return win32_build_iowin(hFile);
+}
+
+
+uLong ZCALLBACK win32_read_file_func (voidpf opaque, voidpf stream, void* buf,uLong size)
+{
+ uLong ret=0;
+ HANDLE hFile = NULL;
+ if (stream!=NULL)
+ hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+
+ if (hFile != NULL)
+ {
+ if (!ReadFile(hFile, buf, size, &ret, NULL))
+ {
+ DWORD dwErr = GetLastError();
+ if (dwErr == ERROR_HANDLE_EOF)
+ dwErr = 0;
+ ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
+ }
+ }
+
+ return ret;
+}
+
+
+uLong ZCALLBACK win32_write_file_func (voidpf opaque,voidpf stream,const void* buf,uLong size)
+{
+ uLong ret=0;
+ HANDLE hFile = NULL;
+ if (stream!=NULL)
+ hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+
+ if (hFile != NULL)
+ {
+ if (!WriteFile(hFile, buf, size, &ret, NULL))
+ {
+ DWORD dwErr = GetLastError();
+ if (dwErr == ERROR_HANDLE_EOF)
+ dwErr = 0;
+ ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
+ }
+ }
+
+ return ret;
+}
+
+static BOOL MySetFilePointerEx(HANDLE hFile, LARGE_INTEGER pos, LARGE_INTEGER *newPos, DWORD dwMoveMethod)
+{
+#ifdef IOWIN32_USING_WINRT_API
+ return SetFilePointerEx(hFile, pos, newPos, dwMoveMethod);
+#else
+ LONG lHigh = pos.HighPart;
+ DWORD dwNewPos = SetFilePointer(hFile, pos.LowPart, &lHigh, dwMoveMethod);
+ BOOL fOk = TRUE;
+ if (dwNewPos == 0xFFFFFFFF)
+ if (GetLastError() != NO_ERROR)
+ fOk = FALSE;
+ if ((newPos != NULL) && (fOk))
+ {
+ newPos->LowPart = dwNewPos;
+ newPos->HighPart = lHigh;
+ }
+ return fOk;
+#endif
+}
+
+long ZCALLBACK win32_tell_file_func (voidpf opaque,voidpf stream)
+{
+ long ret=-1;
+ HANDLE hFile = NULL;
+ if (stream!=NULL)
+ hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+ if (hFile != NULL)
+ {
+ LARGE_INTEGER pos;
+ pos.QuadPart = 0;
+
+ if (!MySetFilePointerEx(hFile, pos, &pos, FILE_CURRENT))
+ {
+ DWORD dwErr = GetLastError();
+ ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
+ ret = -1;
+ }
+ else
+ ret=(long)pos.LowPart;
+ }
+ return ret;
+}
+
+ZPOS64_T ZCALLBACK win32_tell64_file_func (voidpf opaque, voidpf stream)
+{
+ ZPOS64_T ret= (ZPOS64_T)-1;
+ HANDLE hFile = NULL;
+ if (stream!=NULL)
+ hFile = ((WIN32FILE_IOWIN*)stream)->hf;
+
+ if (hFile)
+ {
+ LARGE_INTEGER pos;
+ pos.QuadPart = 0;
+
+ if (!MySetFilePointerEx(hFile, pos, &pos, FILE_CURRENT))
+ {
+ DWORD dwErr = GetLastError();
+ ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
+ ret = (ZPOS64_T)-1;
+ }
+ else
+ ret=pos.QuadPart;
+ }
+ return ret;
+}
+
+
+long ZCALLBACK win32_seek_file_func (voidpf opaque,voidpf stream,uLong offset,int origin)
+{
+ DWORD dwMoveMethod=0xFFFFFFFF;
+ HANDLE hFile = NULL;
+
+ long ret=-1;
+ if (stream!=NULL)
+ hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+ switch (origin)
+ {
+ case ZLIB_FILEFUNC_SEEK_CUR :
+ dwMoveMethod = FILE_CURRENT;
+ break;
+ case ZLIB_FILEFUNC_SEEK_END :
+ dwMoveMethod = FILE_END;
+ break;
+ case ZLIB_FILEFUNC_SEEK_SET :
+ dwMoveMethod = FILE_BEGIN;
+ break;
+ default: return -1;
+ }
+
+ if (hFile != NULL)
+ {
+ LARGE_INTEGER pos;
+ pos.QuadPart = offset;
+ if (!MySetFilePointerEx(hFile, pos, NULL, dwMoveMethod))
+ {
+ DWORD dwErr = GetLastError();
+ ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
+ ret = -1;
+ }
+ else
+ ret=0;
+ }
+ return ret;
+}
+
+long ZCALLBACK win32_seek64_file_func (voidpf opaque, voidpf stream,ZPOS64_T offset,int origin)
+{
+ DWORD dwMoveMethod=0xFFFFFFFF;
+ HANDLE hFile = NULL;
+ long ret=-1;
+
+ if (stream!=NULL)
+ hFile = ((WIN32FILE_IOWIN*)stream)->hf;
+
+ switch (origin)
+ {
+ case ZLIB_FILEFUNC_SEEK_CUR :
+ dwMoveMethod = FILE_CURRENT;
+ break;
+ case ZLIB_FILEFUNC_SEEK_END :
+ dwMoveMethod = FILE_END;
+ break;
+ case ZLIB_FILEFUNC_SEEK_SET :
+ dwMoveMethod = FILE_BEGIN;
+ break;
+ default: return -1;
+ }
+
+ if (hFile)
+ {
+ LARGE_INTEGER pos;
+ pos.QuadPart = offset;
+ if (!MySetFilePointerEx(hFile, pos, NULL, dwMoveMethod))
+ {
+ DWORD dwErr = GetLastError();
+ ((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
+ ret = -1;
+ }
+ else
+ ret=0;
+ }
+ return ret;
+}
+
+int ZCALLBACK win32_close_file_func (voidpf opaque, voidpf stream)
+{
+ int ret=-1;
+
+ if (stream!=NULL)
+ {
+ HANDLE hFile;
+ hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
+ if (hFile != NULL)
+ {
+ CloseHandle(hFile);
+ ret=0;
+ }
+ free(stream);
+ }
+ return ret;
+}
+
+int ZCALLBACK win32_error_file_func (voidpf opaque,voidpf stream)
+{
+ int ret=-1;
+ if (stream!=NULL)
+ {
+ ret = ((WIN32FILE_IOWIN*)stream) -> error;
+ }
+ return ret;
+}
+
+void fill_win32_filefunc (zlib_filefunc_def* pzlib_filefunc_def)
+{
+ pzlib_filefunc_def->zopen_file = win32_open_file_func;
+ pzlib_filefunc_def->zread_file = win32_read_file_func;
+ pzlib_filefunc_def->zwrite_file = win32_write_file_func;
+ pzlib_filefunc_def->ztell_file = win32_tell_file_func;
+ pzlib_filefunc_def->zseek_file = win32_seek_file_func;
+ pzlib_filefunc_def->zclose_file = win32_close_file_func;
+ pzlib_filefunc_def->zerror_file = win32_error_file_func;
+ pzlib_filefunc_def->opaque = NULL;
+}
+
+void fill_win32_filefunc64(zlib_filefunc64_def* pzlib_filefunc_def)
+{
+ pzlib_filefunc_def->zopen64_file = win32_open64_file_func;
+ pzlib_filefunc_def->zread_file = win32_read_file_func;
+ pzlib_filefunc_def->zwrite_file = win32_write_file_func;
+ pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
+ pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
+ pzlib_filefunc_def->zclose_file = win32_close_file_func;
+ pzlib_filefunc_def->zerror_file = win32_error_file_func;
+ pzlib_filefunc_def->opaque = NULL;
+}
+
+
+void fill_win32_filefunc64A(zlib_filefunc64_def* pzlib_filefunc_def)
+{
+ pzlib_filefunc_def->zopen64_file = win32_open64_file_funcA;
+ pzlib_filefunc_def->zread_file = win32_read_file_func;
+ pzlib_filefunc_def->zwrite_file = win32_write_file_func;
+ pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
+ pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
+ pzlib_filefunc_def->zclose_file = win32_close_file_func;
+ pzlib_filefunc_def->zerror_file = win32_error_file_func;
+ pzlib_filefunc_def->opaque = NULL;
+}
+
+
+void fill_win32_filefunc64W(zlib_filefunc64_def* pzlib_filefunc_def)
+{
+ pzlib_filefunc_def->zopen64_file = win32_open64_file_funcW;
+ pzlib_filefunc_def->zread_file = win32_read_file_func;
+ pzlib_filefunc_def->zwrite_file = win32_write_file_func;
+ pzlib_filefunc_def->ztell64_file = win32_tell64_file_func;
+ pzlib_filefunc_def->zseek64_file = win32_seek64_file_func;
+ pzlib_filefunc_def->zclose_file = win32_close_file_func;
+ pzlib_filefunc_def->zerror_file = win32_error_file_func;
+ pzlib_filefunc_def->opaque = NULL;
+}
diff --git a/zlib/contrib/minizip/iowin32.h b/zlib/contrib/minizip/iowin32.h
new file mode 100644
index 000000000..0ca0969a7
--- /dev/null
+++ b/zlib/contrib/minizip/iowin32.h
@@ -0,0 +1,28 @@
+/* iowin32.h -- IO base function header for compress/uncompress .zip
+ Version 1.1, February 14h, 2010
+ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Modifications for Zip64 support
+ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+ For more info read MiniZip_info.txt
+
+*/
+
+#include <windows.h>
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
+void fill_win32_filefunc64 OF((zlib_filefunc64_def* pzlib_filefunc_def));
+void fill_win32_filefunc64A OF((zlib_filefunc64_def* pzlib_filefunc_def));
+void fill_win32_filefunc64W OF((zlib_filefunc64_def* pzlib_filefunc_def));
+
+#ifdef __cplusplus
+}
+#endif
diff --git a/zlib/contrib/minizip/make_vms.com b/zlib/contrib/minizip/make_vms.com
new file mode 100644
index 000000000..9ac13a98f
--- /dev/null
+++ b/zlib/contrib/minizip/make_vms.com
@@ -0,0 +1,25 @@
+$ if f$search("ioapi.h_orig") .eqs. "" then copy ioapi.h ioapi.h_orig
+$ open/write zdef vmsdefs.h
+$ copy sys$input: zdef
+$ deck
+#define unix
+#define fill_zlib_filefunc64_32_def_from_filefunc32 fillzffunc64from
+#define Write_Zip64EndOfCentralDirectoryLocator Write_Zip64EoDLocator
+#define Write_Zip64EndOfCentralDirectoryRecord Write_Zip64EoDRecord
+#define Write_EndOfCentralDirectoryRecord Write_EoDRecord
+$ eod
+$ close zdef
+$ copy vmsdefs.h,ioapi.h_orig ioapi.h
+$ cc/include=[--]/prefix=all ioapi.c
+$ cc/include=[--]/prefix=all miniunz.c
+$ cc/include=[--]/prefix=all unzip.c
+$ cc/include=[--]/prefix=all minizip.c
+$ cc/include=[--]/prefix=all zip.c
+$ link miniunz,unzip,ioapi,[--]libz.olb/lib
+$ link minizip,zip,ioapi,[--]libz.olb/lib
+$ mcr []minizip test minizip_info.txt
+$ mcr []miniunz -l test.zip
+$ rename minizip_info.txt; minizip_info.txt_old
+$ mcr []miniunz test.zip
+$ delete test.zip;*
+$exit
diff --git a/zlib/contrib/minizip/miniunz.c b/zlib/contrib/minizip/miniunz.c
new file mode 100644
index 000000000..3d65401be
--- /dev/null
+++ b/zlib/contrib/minizip/miniunz.c
@@ -0,0 +1,660 @@
+/*
+ miniunz.c
+ Version 1.1, February 14h, 2010
+ sample part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Modifications of Unzip for Zip64
+ Copyright (C) 2007-2008 Even Rouault
+
+ Modifications for Zip64 support on both zip and unzip
+ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+*/
+
+#if (!defined(_WIN32)) && (!defined(WIN32)) && (!defined(__APPLE__))
+ #ifndef __USE_FILE_OFFSET64
+ #define __USE_FILE_OFFSET64
+ #endif
+ #ifndef __USE_LARGEFILE64
+ #define __USE_LARGEFILE64
+ #endif
+ #ifndef _LARGEFILE64_SOURCE
+ #define _LARGEFILE64_SOURCE
+ #endif
+ #ifndef _FILE_OFFSET_BIT
+ #define _FILE_OFFSET_BIT 64
+ #endif
+#endif
+
+#ifdef __APPLE__
+// In darwin and perhaps other BSD variants off_t is a 64 bit value, hence no need for specific 64 bit functions
+#define FOPEN_FUNC(filename, mode) fopen(filename, mode)
+#define FTELLO_FUNC(stream) ftello(stream)
+#define FSEEKO_FUNC(stream, offset, origin) fseeko(stream, offset, origin)
+#else
+#define FOPEN_FUNC(filename, mode) fopen64(filename, mode)
+#define FTELLO_FUNC(stream) ftello64(stream)
+#define FSEEKO_FUNC(stream, offset, origin) fseeko64(stream, offset, origin)
+#endif
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+#include <fcntl.h>
+
+#ifdef _WIN32
+# include <direct.h>
+# include <io.h>
+#else
+# include <unistd.h>
+# include <utime.h>
+#endif
+
+
+#include "unzip.h"
+
+#define CASESENSITIVITY (0)
+#define WRITEBUFFERSIZE (8192)
+#define MAXFILENAME (256)
+
+#ifdef _WIN32
+#define USEWIN32IOAPI
+#include "iowin32.h"
+#endif
+/*
+ mini unzip, demo of unzip package
+
+ usage :
+ Usage : miniunz [-exvlo] file.zip [file_to_extract] [-d extractdir]
+
+ list the file in the zipfile, and print the content of FILE_ID.ZIP or README.TXT
+ if it exists
+*/
+
+
+/* change_file_date : change the date/time of a file
+ filename : the filename of the file where date/time must be modified
+ dosdate : the new date at the MSDos format (4 bytes)
+ tmu_date : the SAME new date at the tm_unz format */
+void change_file_date(filename,dosdate,tmu_date)
+ const char *filename;
+ uLong dosdate;
+ tm_unz tmu_date;
+{
+#ifdef _WIN32
+ HANDLE hFile;
+ FILETIME ftm,ftLocal,ftCreate,ftLastAcc,ftLastWrite;
+
+ hFile = CreateFileA(filename,GENERIC_READ | GENERIC_WRITE,
+ 0,NULL,OPEN_EXISTING,0,NULL);
+ GetFileTime(hFile,&ftCreate,&ftLastAcc,&ftLastWrite);
+ DosDateTimeToFileTime((WORD)(dosdate>>16),(WORD)dosdate,&ftLocal);
+ LocalFileTimeToFileTime(&ftLocal,&ftm);
+ SetFileTime(hFile,&ftm,&ftLastAcc,&ftm);
+ CloseHandle(hFile);
+#else
+#ifdef unix || __APPLE__
+ struct utimbuf ut;
+ struct tm newdate;
+ newdate.tm_sec = tmu_date.tm_sec;
+ newdate.tm_min=tmu_date.tm_min;
+ newdate.tm_hour=tmu_date.tm_hour;
+ newdate.tm_mday=tmu_date.tm_mday;
+ newdate.tm_mon=tmu_date.tm_mon;
+ if (tmu_date.tm_year > 1900)
+ newdate.tm_year=tmu_date.tm_year - 1900;
+ else
+ newdate.tm_year=tmu_date.tm_year ;
+ newdate.tm_isdst=-1;
+
+ ut.actime=ut.modtime=mktime(&newdate);
+ utime(filename,&ut);
+#endif
+#endif
+}
+
+
+/* mymkdir and change_file_date are not 100 % portable
+ As I don't know well Unix, I wait feedback for the unix portion */
+
+int mymkdir(dirname)
+ const char* dirname;
+{
+ int ret=0;
+#ifdef _WIN32
+ ret = _mkdir(dirname);
+#elif unix
+ ret = mkdir (dirname,0775);
+#elif __APPLE__
+ ret = mkdir (dirname,0775);
+#endif
+ return ret;
+}
+
+int makedir (newdir)
+ char *newdir;
+{
+ char *buffer ;
+ char *p;
+ int len = (int)strlen(newdir);
+
+ if (len <= 0)
+ return 0;
+
+ buffer = (char*)malloc(len+1);
+ if (buffer==NULL)
+ {
+ printf("Error allocating memory\n");
+ return UNZ_INTERNALERROR;
+ }
+ strcpy(buffer,newdir);
+
+ if (buffer[len-1] == '/') {
+ buffer[len-1] = '\0';
+ }
+ if (mymkdir(buffer) == 0)
+ {
+ free(buffer);
+ return 1;
+ }
+
+ p = buffer+1;
+ while (1)
+ {
+ char hold;
+
+ while(*p && *p != '\\' && *p != '/')
+ p++;
+ hold = *p;
+ *p = 0;
+ if ((mymkdir(buffer) == -1) && (errno == ENOENT))
+ {
+ printf("couldn't create directory %s\n",buffer);
+ free(buffer);
+ return 0;
+ }
+ if (hold == 0)
+ break;
+ *p++ = hold;
+ }
+ free(buffer);
+ return 1;
+}
+
+void do_banner()
+{
+ printf("MiniUnz 1.01b, demo of zLib + Unz package written by Gilles Vollant\n");
+ printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n");
+}
+
+void do_help()
+{
+ printf("Usage : miniunz [-e] [-x] [-v] [-l] [-o] [-p password] file.zip [file_to_extr.] [-d extractdir]\n\n" \
+ " -e Extract without pathname (junk paths)\n" \
+ " -x Extract with pathname\n" \
+ " -v list files\n" \
+ " -l list files\n" \
+ " -d directory to extract into\n" \
+ " -o overwrite files without prompting\n" \
+ " -p extract crypted file using password\n\n");
+}
+
+void Display64BitsSize(ZPOS64_T n, int size_char)
+{
+ /* to avoid compatibility problem , we do here the conversion */
+ char number[21];
+ int offset=19;
+ int pos_string = 19;
+ number[20]=0;
+ for (;;) {
+ number[offset]=(char)((n%10)+'0');
+ if (number[offset] != '0')
+ pos_string=offset;
+ n/=10;
+ if (offset==0)
+ break;
+ offset--;
+ }
+ {
+ int size_display_string = 19-pos_string;
+ while (size_char > size_display_string)
+ {
+ size_char--;
+ printf(" ");
+ }
+ }
+
+ printf("%s",&number[pos_string]);
+}
+
+int do_list(uf)
+ unzFile uf;
+{
+ uLong i;
+ unz_global_info64 gi;
+ int err;
+
+ err = unzGetGlobalInfo64(uf,&gi);
+ if (err!=UNZ_OK)
+ printf("error %d with zipfile in unzGetGlobalInfo \n",err);
+ printf(" Length Method Size Ratio Date Time CRC-32 Name\n");
+ printf(" ------ ------ ---- ----- ---- ---- ------ ----\n");
+ for (i=0;i<gi.number_entry;i++)
+ {
+ char filename_inzip[256];
+ unz_file_info64 file_info;
+ uLong ratio=0;
+ const char *string_method;
+ char charCrypt=' ';
+ err = unzGetCurrentFileInfo64(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
+ if (err!=UNZ_OK)
+ {
+ printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
+ break;
+ }
+ if (file_info.uncompressed_size>0)
+ ratio = (uLong)((file_info.compressed_size*100)/file_info.uncompressed_size);
+
+ /* display a '*' if the file is crypted */
+ if ((file_info.flag & 1) != 0)
+ charCrypt='*';
+
+ if (file_info.compression_method==0)
+ string_method="Stored";
+ else
+ if (file_info.compression_method==Z_DEFLATED)
+ {
+ uInt iLevel=(uInt)((file_info.flag & 0x6)/2);
+ if (iLevel==0)
+ string_method="Defl:N";
+ else if (iLevel==1)
+ string_method="Defl:X";
+ else if ((iLevel==2) || (iLevel==3))
+ string_method="Defl:F"; /* 2:fast , 3 : extra fast*/
+ }
+ else
+ if (file_info.compression_method==Z_BZIP2ED)
+ {
+ string_method="BZip2 ";
+ }
+ else
+ string_method="Unkn. ";
+
+ Display64BitsSize(file_info.uncompressed_size,7);
+ printf(" %6s%c",string_method,charCrypt);
+ Display64BitsSize(file_info.compressed_size,7);
+ printf(" %3lu%% %2.2lu-%2.2lu-%2.2lu %2.2lu:%2.2lu %8.8lx %s\n",
+ ratio,
+ (uLong)file_info.tmu_date.tm_mon + 1,
+ (uLong)file_info.tmu_date.tm_mday,
+ (uLong)file_info.tmu_date.tm_year % 100,
+ (uLong)file_info.tmu_date.tm_hour,(uLong)file_info.tmu_date.tm_min,
+ (uLong)file_info.crc,filename_inzip);
+ if ((i+1)<gi.number_entry)
+ {
+ err = unzGoToNextFile(uf);
+ if (err!=UNZ_OK)
+ {
+ printf("error %d with zipfile in unzGoToNextFile\n",err);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
+
+int do_extract_currentfile(uf,popt_extract_without_path,popt_overwrite,password)
+ unzFile uf;
+ const int* popt_extract_without_path;
+ int* popt_overwrite;
+ const char* password;
+{
+ char filename_inzip[256];
+ char* filename_withoutpath;
+ char* p;
+ int err=UNZ_OK;
+ FILE *fout=NULL;
+ void* buf;
+ uInt size_buf;
+
+ unz_file_info64 file_info;
+ uLong ratio=0;
+ err = unzGetCurrentFileInfo64(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
+
+ if (err!=UNZ_OK)
+ {
+ printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
+ return err;
+ }
+
+ size_buf = WRITEBUFFERSIZE;
+ buf = (void*)malloc(size_buf);
+ if (buf==NULL)
+ {
+ printf("Error allocating memory\n");
+ return UNZ_INTERNALERROR;
+ }
+
+ p = filename_withoutpath = filename_inzip;
+ while ((*p) != '\0')
+ {
+ if (((*p)=='/') || ((*p)=='\\'))
+ filename_withoutpath = p+1;
+ p++;
+ }
+
+ if ((*filename_withoutpath)=='\0')
+ {
+ if ((*popt_extract_without_path)==0)
+ {
+ printf("creating directory: %s\n",filename_inzip);
+ mymkdir(filename_inzip);
+ }
+ }
+ else
+ {
+ const char* write_filename;
+ int skip=0;
+
+ if ((*popt_extract_without_path)==0)
+ write_filename = filename_inzip;
+ else
+ write_filename = filename_withoutpath;
+
+ err = unzOpenCurrentFilePassword(uf,password);
+ if (err!=UNZ_OK)
+ {
+ printf("error %d with zipfile in unzOpenCurrentFilePassword\n",err);
+ }
+
+ if (((*popt_overwrite)==0) && (err==UNZ_OK))
+ {
+ char rep=0;
+ FILE* ftestexist;
+ ftestexist = FOPEN_FUNC(write_filename,"rb");
+ if (ftestexist!=NULL)
+ {
+ fclose(ftestexist);
+ do
+ {
+ char answer[128];
+ int ret;
+
+ printf("The file %s exists. Overwrite ? [y]es, [n]o, [A]ll: ",write_filename);
+ ret = scanf("%1s",answer);
+ if (ret != 1)
+ {
+ exit(EXIT_FAILURE);
+ }
+ rep = answer[0] ;
+ if ((rep>='a') && (rep<='z'))
+ rep -= 0x20;
+ }
+ while ((rep!='Y') && (rep!='N') && (rep!='A'));
+ }
+
+ if (rep == 'N')
+ skip = 1;
+
+ if (rep == 'A')
+ *popt_overwrite=1;
+ }
+
+ if ((skip==0) && (err==UNZ_OK))
+ {
+ fout=FOPEN_FUNC(write_filename,"wb");
+ /* some zipfile don't contain directory alone before file */
+ if ((fout==NULL) && ((*popt_extract_without_path)==0) &&
+ (filename_withoutpath!=(char*)filename_inzip))
+ {
+ char c=*(filename_withoutpath-1);
+ *(filename_withoutpath-1)='\0';
+ makedir(write_filename);
+ *(filename_withoutpath-1)=c;
+ fout=FOPEN_FUNC(write_filename,"wb");
+ }
+
+ if (fout==NULL)
+ {
+ printf("error opening %s\n",write_filename);
+ }
+ }
+
+ if (fout!=NULL)
+ {
+ printf(" extracting: %s\n",write_filename);
+
+ do
+ {
+ err = unzReadCurrentFile(uf,buf,size_buf);
+ if (err<0)
+ {
+ printf("error %d with zipfile in unzReadCurrentFile\n",err);
+ break;
+ }
+ if (err>0)
+ if (fwrite(buf,err,1,fout)!=1)
+ {
+ printf("error in writing extracted file\n");
+ err=UNZ_ERRNO;
+ break;
+ }
+ }
+ while (err>0);
+ if (fout)
+ fclose(fout);
+
+ if (err==0)
+ change_file_date(write_filename,file_info.dosDate,
+ file_info.tmu_date);
+ }
+
+ if (err==UNZ_OK)
+ {
+ err = unzCloseCurrentFile (uf);
+ if (err!=UNZ_OK)
+ {
+ printf("error %d with zipfile in unzCloseCurrentFile\n",err);
+ }
+ }
+ else
+ unzCloseCurrentFile(uf); /* don't lose the error */
+ }
+
+ free(buf);
+ return err;
+}
+
+
+int do_extract(uf,opt_extract_without_path,opt_overwrite,password)
+ unzFile uf;
+ int opt_extract_without_path;
+ int opt_overwrite;
+ const char* password;
+{
+ uLong i;
+ unz_global_info64 gi;
+ int err;
+ FILE* fout=NULL;
+
+ err = unzGetGlobalInfo64(uf,&gi);
+ if (err!=UNZ_OK)
+ printf("error %d with zipfile in unzGetGlobalInfo \n",err);
+
+ for (i=0;i<gi.number_entry;i++)
+ {
+ if (do_extract_currentfile(uf,&opt_extract_without_path,
+ &opt_overwrite,
+ password) != UNZ_OK)
+ break;
+
+ if ((i+1)<gi.number_entry)
+ {
+ err = unzGoToNextFile(uf);
+ if (err!=UNZ_OK)
+ {
+ printf("error %d with zipfile in unzGoToNextFile\n",err);
+ break;
+ }
+ }
+ }
+
+ return 0;
+}
+
+int do_extract_onefile(uf,filename,opt_extract_without_path,opt_overwrite,password)
+ unzFile uf;
+ const char* filename;
+ int opt_extract_without_path;
+ int opt_overwrite;
+ const char* password;
+{
+ int err = UNZ_OK;
+ if (unzLocateFile(uf,filename,CASESENSITIVITY)!=UNZ_OK)
+ {
+ printf("file %s not found in the zipfile\n",filename);
+ return 2;
+ }
+
+ if (do_extract_currentfile(uf,&opt_extract_without_path,
+ &opt_overwrite,
+ password) == UNZ_OK)
+ return 0;
+ else
+ return 1;
+}
+
+
+int main(argc,argv)
+ int argc;
+ char *argv[];
+{
+ const char *zipfilename=NULL;
+ const char *filename_to_extract=NULL;
+ const char *password=NULL;
+ char filename_try[MAXFILENAME+16] = "";
+ int i;
+ int ret_value=0;
+ int opt_do_list=0;
+ int opt_do_extract=1;
+ int opt_do_extract_withoutpath=0;
+ int opt_overwrite=0;
+ int opt_extractdir=0;
+ const char *dirname=NULL;
+ unzFile uf=NULL;
+
+ do_banner();
+ if (argc==1)
+ {
+ do_help();
+ return 0;
+ }
+ else
+ {
+ for (i=1;i<argc;i++)
+ {
+ if ((*argv[i])=='-')
+ {
+ const char *p=argv[i]+1;
+
+ while ((*p)!='\0')
+ {
+ char c=*(p++);;
+ if ((c=='l') || (c=='L'))
+ opt_do_list = 1;
+ if ((c=='v') || (c=='V'))
+ opt_do_list = 1;
+ if ((c=='x') || (c=='X'))
+ opt_do_extract = 1;
+ if ((c=='e') || (c=='E'))
+ opt_do_extract = opt_do_extract_withoutpath = 1;
+ if ((c=='o') || (c=='O'))
+ opt_overwrite=1;
+ if ((c=='d') || (c=='D'))
+ {
+ opt_extractdir=1;
+ dirname=argv[i+1];
+ }
+
+ if (((c=='p') || (c=='P')) && (i+1<argc))
+ {
+ password=argv[i+1];
+ i++;
+ }
+ }
+ }
+ else
+ {
+ if (zipfilename == NULL)
+ zipfilename = argv[i];
+ else if ((filename_to_extract==NULL) && (!opt_extractdir))
+ filename_to_extract = argv[i] ;
+ }
+ }
+ }
+
+ if (zipfilename!=NULL)
+ {
+
+# ifdef USEWIN32IOAPI
+ zlib_filefunc64_def ffunc;
+# endif
+
+ strncpy(filename_try, zipfilename,MAXFILENAME-1);
+ /* strncpy doesnt append the trailing NULL, of the string is too long. */
+ filename_try[ MAXFILENAME ] = '\0';
+
+# ifdef USEWIN32IOAPI
+ fill_win32_filefunc64A(&ffunc);
+ uf = unzOpen2_64(zipfilename,&ffunc);
+# else
+ uf = unzOpen64(zipfilename);
+# endif
+ if (uf==NULL)
+ {
+ strcat(filename_try,".zip");
+# ifdef USEWIN32IOAPI
+ uf = unzOpen2_64(filename_try,&ffunc);
+# else
+ uf = unzOpen64(filename_try);
+# endif
+ }
+ }
+
+ if (uf==NULL)
+ {
+ printf("Cannot open %s or %s.zip\n",zipfilename,zipfilename);
+ return 1;
+ }
+ printf("%s opened\n",filename_try);
+
+ if (opt_do_list==1)
+ ret_value = do_list(uf);
+ else if (opt_do_extract==1)
+ {
+#ifdef _WIN32
+ if (opt_extractdir && _chdir(dirname))
+#else
+ if (opt_extractdir && chdir(dirname))
+#endif
+ {
+ printf("Error changing into %s, aborting\n", dirname);
+ exit(-1);
+ }
+
+ if (filename_to_extract == NULL)
+ ret_value = do_extract(uf, opt_do_extract_withoutpath, opt_overwrite, password);
+ else
+ ret_value = do_extract_onefile(uf, filename_to_extract, opt_do_extract_withoutpath, opt_overwrite, password);
+ }
+
+ unzClose(uf);
+
+ return ret_value;
+}
diff --git a/zlib/contrib/minizip/miniunzip.1 b/zlib/contrib/minizip/miniunzip.1
new file mode 100644
index 000000000..111ac6919
--- /dev/null
+++ b/zlib/contrib/minizip/miniunzip.1
@@ -0,0 +1,63 @@
+.\" Hey, EMACS: -*- nroff -*-
+.TH miniunzip 1 "Nov 7, 2001"
+.\" Please adjust this date whenever revising the manpage.
+.\"
+.\" Some roff macros, for reference:
+.\" .nh disable hyphenation
+.\" .hy enable hyphenation
+.\" .ad l left justify
+.\" .ad b justify to both left and right margins
+.\" .nf disable filling
+.\" .fi enable filling
+.\" .br insert line break
+.\" .sp <n> insert n+1 empty lines
+.\" for manpage-specific macros, see man(7)
+.SH NAME
+miniunzip - uncompress and examine ZIP archives
+.SH SYNOPSIS
+.B miniunzip
+.RI [ -exvlo ]
+zipfile [ files_to_extract ] [-d tempdir]
+.SH DESCRIPTION
+.B minizip
+is a simple tool which allows the extraction of compressed file
+archives in the ZIP format used by the MS-DOS utility PKZIP. It was
+written as a demonstration of the
+.IR zlib (3)
+library and therefore lack many of the features of the
+.IR unzip (1)
+program.
+.SH OPTIONS
+A number of options are supported. With the exception of
+.BI \-d\ tempdir
+these must be supplied before any
+other arguments and are:
+.TP
+.BI \-l\ ,\ \-\-v
+List the files in the archive without extracting them.
+.TP
+.B \-o
+Overwrite files without prompting for confirmation.
+.TP
+.B \-x
+Extract files (default).
+.PP
+The
+.I zipfile
+argument is the name of the archive to process. The next argument can be used
+to specify a single file to extract from the archive.
+
+Lastly, the following option can be specified at the end of the command-line:
+.TP
+.BI \-d\ tempdir
+Extract the archive in the directory
+.I tempdir
+rather than the current directory.
+.SH SEE ALSO
+.BR minizip (1),
+.BR zlib (3),
+.BR unzip (1).
+.SH AUTHOR
+This program was written by Gilles Vollant. This manual page was
+written by Mark Brown <broonie@sirena.org.uk>. The -d tempdir option
+was added by Dirk Eddelbuettel <edd@debian.org>.
diff --git a/zlib/contrib/minizip/minizip.1 b/zlib/contrib/minizip/minizip.1
new file mode 100644
index 000000000..1154484c1
--- /dev/null
+++ b/zlib/contrib/minizip/minizip.1
@@ -0,0 +1,46 @@
+.\" Hey, EMACS: -*- nroff -*-
+.TH minizip 1 "May 2, 2001"
+.\" Please adjust this date whenever revising the manpage.
+.\"
+.\" Some roff macros, for reference:
+.\" .nh disable hyphenation
+.\" .hy enable hyphenation
+.\" .ad l left justify
+.\" .ad b justify to both left and right margins
+.\" .nf disable filling
+.\" .fi enable filling
+.\" .br insert line break
+.\" .sp <n> insert n+1 empty lines
+.\" for manpage-specific macros, see man(7)
+.SH NAME
+minizip - create ZIP archives
+.SH SYNOPSIS
+.B minizip
+.RI [ -o ]
+zipfile [ " files" ... ]
+.SH DESCRIPTION
+.B minizip
+is a simple tool which allows the creation of compressed file archives
+in the ZIP format used by the MS-DOS utility PKZIP. It was written as
+a demonstration of the
+.IR zlib (3)
+library and therefore lack many of the features of the
+.IR zip (1)
+program.
+.SH OPTIONS
+The first argument supplied is the name of the ZIP archive to create or
+.RI -o
+in which case it is ignored and the second argument treated as the
+name of the ZIP file. If the ZIP file already exists it will be
+overwritten.
+.PP
+Subsequent arguments specify a list of files to place in the ZIP
+archive. If none are specified then an empty archive will be created.
+.SH SEE ALSO
+.BR miniunzip (1),
+.BR zlib (3),
+.BR zip (1).
+.SH AUTHOR
+This program was written by Gilles Vollant. This manual page was
+written by Mark Brown <broonie@sirena.org.uk>.
+
diff --git a/zlib/contrib/minizip/minizip.c b/zlib/contrib/minizip/minizip.c
new file mode 100644
index 000000000..4288962ec
--- /dev/null
+++ b/zlib/contrib/minizip/minizip.c
@@ -0,0 +1,520 @@
+/*
+ minizip.c
+ Version 1.1, February 14h, 2010
+ sample part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Modifications of Unzip for Zip64
+ Copyright (C) 2007-2008 Even Rouault
+
+ Modifications for Zip64 support on both zip and unzip
+ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+*/
+
+
+#if (!defined(_WIN32)) && (!defined(WIN32)) && (!defined(__APPLE__))
+ #ifndef __USE_FILE_OFFSET64
+ #define __USE_FILE_OFFSET64
+ #endif
+ #ifndef __USE_LARGEFILE64
+ #define __USE_LARGEFILE64
+ #endif
+ #ifndef _LARGEFILE64_SOURCE
+ #define _LARGEFILE64_SOURCE
+ #endif
+ #ifndef _FILE_OFFSET_BIT
+ #define _FILE_OFFSET_BIT 64
+ #endif
+#endif
+
+#ifdef __APPLE__
+// In darwin and perhaps other BSD variants off_t is a 64 bit value, hence no need for specific 64 bit functions
+#define FOPEN_FUNC(filename, mode) fopen(filename, mode)
+#define FTELLO_FUNC(stream) ftello(stream)
+#define FSEEKO_FUNC(stream, offset, origin) fseeko(stream, offset, origin)
+#else
+#define FOPEN_FUNC(filename, mode) fopen64(filename, mode)
+#define FTELLO_FUNC(stream) ftello64(stream)
+#define FSEEKO_FUNC(stream, offset, origin) fseeko64(stream, offset, origin)
+#endif
+
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+#include <fcntl.h>
+
+#ifdef _WIN32
+# include <direct.h>
+# include <io.h>
+#else
+# include <unistd.h>
+# include <utime.h>
+# include <sys/types.h>
+# include <sys/stat.h>
+#endif
+
+#include "zip.h"
+
+#ifdef _WIN32
+ #define USEWIN32IOAPI
+ #include "iowin32.h"
+#endif
+
+
+
+#define WRITEBUFFERSIZE (16384)
+#define MAXFILENAME (256)
+
+#ifdef _WIN32
+uLong filetime(f, tmzip, dt)
+ char *f; /* name of file to get info on */
+ tm_zip *tmzip; /* return value: access, modific. and creation times */
+ uLong *dt; /* dostime */
+{
+ int ret = 0;
+ {
+ FILETIME ftLocal;
+ HANDLE hFind;
+ WIN32_FIND_DATAA ff32;
+
+ hFind = FindFirstFileA(f,&ff32);
+ if (hFind != INVALID_HANDLE_VALUE)
+ {
+ FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal);
+ FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0);
+ FindClose(hFind);
+ ret = 1;
+ }
+ }
+ return ret;
+}
+#else
+#ifdef unix || __APPLE__
+uLong filetime(f, tmzip, dt)
+ char *f; /* name of file to get info on */
+ tm_zip *tmzip; /* return value: access, modific. and creation times */
+ uLong *dt; /* dostime */
+{
+ int ret=0;
+ struct stat s; /* results of stat() */
+ struct tm* filedate;
+ time_t tm_t=0;
+
+ if (strcmp(f,"-")!=0)
+ {
+ char name[MAXFILENAME+1];
+ int len = strlen(f);
+ if (len > MAXFILENAME)
+ len = MAXFILENAME;
+
+ strncpy(name, f,MAXFILENAME-1);
+ /* strncpy doesnt append the trailing NULL, of the string is too long. */
+ name[ MAXFILENAME ] = '\0';
+
+ if (name[len - 1] == '/')
+ name[len - 1] = '\0';
+ /* not all systems allow stat'ing a file with / appended */
+ if (stat(name,&s)==0)
+ {
+ tm_t = s.st_mtime;
+ ret = 1;
+ }
+ }
+ filedate = localtime(&tm_t);
+
+ tmzip->tm_sec = filedate->tm_sec;
+ tmzip->tm_min = filedate->tm_min;
+ tmzip->tm_hour = filedate->tm_hour;
+ tmzip->tm_mday = filedate->tm_mday;
+ tmzip->tm_mon = filedate->tm_mon ;
+ tmzip->tm_year = filedate->tm_year;
+
+ return ret;
+}
+#else
+uLong filetime(f, tmzip, dt)
+ char *f; /* name of file to get info on */
+ tm_zip *tmzip; /* return value: access, modific. and creation times */
+ uLong *dt; /* dostime */
+{
+ return 0;
+}
+#endif
+#endif
+
+
+
+
+int check_exist_file(filename)
+ const char* filename;
+{
+ FILE* ftestexist;
+ int ret = 1;
+ ftestexist = FOPEN_FUNC(filename,"rb");
+ if (ftestexist==NULL)
+ ret = 0;
+ else
+ fclose(ftestexist);
+ return ret;
+}
+
+void do_banner()
+{
+ printf("MiniZip 1.1, demo of zLib + MiniZip64 package, written by Gilles Vollant\n");
+ printf("more info on MiniZip at http://www.winimage.com/zLibDll/minizip.html\n\n");
+}
+
+void do_help()
+{
+ printf("Usage : minizip [-o] [-a] [-0 to -9] [-p password] [-j] file.zip [files_to_add]\n\n" \
+ " -o Overwrite existing file.zip\n" \
+ " -a Append to existing file.zip\n" \
+ " -0 Store only\n" \
+ " -1 Compress faster\n" \
+ " -9 Compress better\n\n" \
+ " -j exclude path. store only the file name.\n\n");
+}
+
+/* calculate the CRC32 of a file,
+ because to encrypt a file, we need known the CRC32 of the file before */
+int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc)
+{
+ unsigned long calculate_crc=0;
+ int err=ZIP_OK;
+ FILE * fin = FOPEN_FUNC(filenameinzip,"rb");
+
+ unsigned long size_read = 0;
+ unsigned long total_read = 0;
+ if (fin==NULL)
+ {
+ err = ZIP_ERRNO;
+ }
+
+ if (err == ZIP_OK)
+ do
+ {
+ err = ZIP_OK;
+ size_read = (int)fread(buf,1,size_buf,fin);
+ if (size_read < size_buf)
+ if (feof(fin)==0)
+ {
+ printf("error in reading %s\n",filenameinzip);
+ err = ZIP_ERRNO;
+ }
+
+ if (size_read>0)
+ calculate_crc = crc32(calculate_crc,buf,size_read);
+ total_read += size_read;
+
+ } while ((err == ZIP_OK) && (size_read>0));
+
+ if (fin)
+ fclose(fin);
+
+ *result_crc=calculate_crc;
+ printf("file %s crc %lx\n", filenameinzip, calculate_crc);
+ return err;
+}
+
+int isLargeFile(const char* filename)
+{
+ int largeFile = 0;
+ ZPOS64_T pos = 0;
+ FILE* pFile = FOPEN_FUNC(filename, "rb");
+
+ if(pFile != NULL)
+ {
+ int n = FSEEKO_FUNC(pFile, 0, SEEK_END);
+ pos = FTELLO_FUNC(pFile);
+
+ printf("File : %s is %lld bytes\n", filename, pos);
+
+ if(pos >= 0xffffffff)
+ largeFile = 1;
+
+ fclose(pFile);
+ }
+
+ return largeFile;
+}
+
+int main(argc,argv)
+ int argc;
+ char *argv[];
+{
+ int i;
+ int opt_overwrite=0;
+ int opt_compress_level=Z_DEFAULT_COMPRESSION;
+ int opt_exclude_path=0;
+ int zipfilenamearg = 0;
+ char filename_try[MAXFILENAME+16];
+ int zipok;
+ int err=0;
+ int size_buf=0;
+ void* buf=NULL;
+ const char* password=NULL;
+
+
+ do_banner();
+ if (argc==1)
+ {
+ do_help();
+ return 0;
+ }
+ else
+ {
+ for (i=1;i<argc;i++)
+ {
+ if ((*argv[i])=='-')
+ {
+ const char *p=argv[i]+1;
+
+ while ((*p)!='\0')
+ {
+ char c=*(p++);;
+ if ((c=='o') || (c=='O'))
+ opt_overwrite = 1;
+ if ((c=='a') || (c=='A'))
+ opt_overwrite = 2;
+ if ((c>='0') && (c<='9'))
+ opt_compress_level = c-'0';
+ if ((c=='j') || (c=='J'))
+ opt_exclude_path = 1;
+
+ if (((c=='p') || (c=='P')) && (i+1<argc))
+ {
+ password=argv[i+1];
+ i++;
+ }
+ }
+ }
+ else
+ {
+ if (zipfilenamearg == 0)
+ {
+ zipfilenamearg = i ;
+ }
+ }
+ }
+ }
+
+ size_buf = WRITEBUFFERSIZE;
+ buf = (void*)malloc(size_buf);
+ if (buf==NULL)
+ {
+ printf("Error allocating memory\n");
+ return ZIP_INTERNALERROR;
+ }
+
+ if (zipfilenamearg==0)
+ {
+ zipok=0;
+ }
+ else
+ {
+ int i,len;
+ int dot_found=0;
+
+ zipok = 1 ;
+ strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1);
+ /* strncpy doesnt append the trailing NULL, of the string is too long. */
+ filename_try[ MAXFILENAME ] = '\0';
+
+ len=(int)strlen(filename_try);
+ for (i=0;i<len;i++)
+ if (filename_try[i]=='.')
+ dot_found=1;
+
+ if (dot_found==0)
+ strcat(filename_try,".zip");
+
+ if (opt_overwrite==2)
+ {
+ /* if the file don't exist, we not append file */
+ if (check_exist_file(filename_try)==0)
+ opt_overwrite=1;
+ }
+ else
+ if (opt_overwrite==0)
+ if (check_exist_file(filename_try)!=0)
+ {
+ char rep=0;
+ do
+ {
+ char answer[128];
+ int ret;
+ printf("The file %s exists. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try);
+ ret = scanf("%1s",answer);
+ if (ret != 1)
+ {
+ exit(EXIT_FAILURE);
+ }
+ rep = answer[0] ;
+ if ((rep>='a') && (rep<='z'))
+ rep -= 0x20;
+ }
+ while ((rep!='Y') && (rep!='N') && (rep!='A'));
+ if (rep=='N')
+ zipok = 0;
+ if (rep=='A')
+ opt_overwrite = 2;
+ }
+ }
+
+ if (zipok==1)
+ {
+ zipFile zf;
+ int errclose;
+# ifdef USEWIN32IOAPI
+ zlib_filefunc64_def ffunc;
+ fill_win32_filefunc64A(&ffunc);
+ zf = zipOpen2_64(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc);
+# else
+ zf = zipOpen64(filename_try,(opt_overwrite==2) ? 2 : 0);
+# endif
+
+ if (zf == NULL)
+ {
+ printf("error opening %s\n",filename_try);
+ err= ZIP_ERRNO;
+ }
+ else
+ printf("creating %s\n",filename_try);
+
+ for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++)
+ {
+ if (!((((*(argv[i]))=='-') || ((*(argv[i]))=='/')) &&
+ ((argv[i][1]=='o') || (argv[i][1]=='O') ||
+ (argv[i][1]=='a') || (argv[i][1]=='A') ||
+ (argv[i][1]=='p') || (argv[i][1]=='P') ||
+ ((argv[i][1]>='0') || (argv[i][1]<='9'))) &&
+ (strlen(argv[i]) == 2)))
+ {
+ FILE * fin;
+ int size_read;
+ const char* filenameinzip = argv[i];
+ const char *savefilenameinzip;
+ zip_fileinfo zi;
+ unsigned long crcFile=0;
+ int zip64 = 0;
+
+ zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
+ zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
+ zi.dosDate = 0;
+ zi.internal_fa = 0;
+ zi.external_fa = 0;
+ filetime(filenameinzip,&zi.tmz_date,&zi.dosDate);
+
+/*
+ err = zipOpenNewFileInZip(zf,filenameinzip,&zi,
+ NULL,0,NULL,0,NULL / * comment * /,
+ (opt_compress_level != 0) ? Z_DEFLATED : 0,
+ opt_compress_level);
+*/
+ if ((password != NULL) && (err==ZIP_OK))
+ err = getFileCrc(filenameinzip,buf,size_buf,&crcFile);
+
+ zip64 = isLargeFile(filenameinzip);
+
+ /* The path name saved, should not include a leading slash. */
+ /*if it did, windows/xp and dynazip couldn't read the zip file. */
+ savefilenameinzip = filenameinzip;
+ while( savefilenameinzip[0] == '\\' || savefilenameinzip[0] == '/' )
+ {
+ savefilenameinzip++;
+ }
+
+ /*should the zip file contain any path at all?*/
+ if( opt_exclude_path )
+ {
+ const char *tmpptr;
+ const char *lastslash = 0;
+ for( tmpptr = savefilenameinzip; *tmpptr; tmpptr++)
+ {
+ if( *tmpptr == '\\' || *tmpptr == '/')
+ {
+ lastslash = tmpptr;
+ }
+ }
+ if( lastslash != NULL )
+ {
+ savefilenameinzip = lastslash+1; // base filename follows last slash.
+ }
+ }
+
+ /**/
+ err = zipOpenNewFileInZip3_64(zf,savefilenameinzip,&zi,
+ NULL,0,NULL,0,NULL /* comment*/,
+ (opt_compress_level != 0) ? Z_DEFLATED : 0,
+ opt_compress_level,0,
+ /* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */
+ -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
+ password,crcFile, zip64);
+
+ if (err != ZIP_OK)
+ printf("error in opening %s in zipfile\n",filenameinzip);
+ else
+ {
+ fin = FOPEN_FUNC(filenameinzip,"rb");
+ if (fin==NULL)
+ {
+ err=ZIP_ERRNO;
+ printf("error in opening %s for reading\n",filenameinzip);
+ }
+ }
+
+ if (err == ZIP_OK)
+ do
+ {
+ err = ZIP_OK;
+ size_read = (int)fread(buf,1,size_buf,fin);
+ if (size_read < size_buf)
+ if (feof(fin)==0)
+ {
+ printf("error in reading %s\n",filenameinzip);
+ err = ZIP_ERRNO;
+ }
+
+ if (size_read>0)
+ {
+ err = zipWriteInFileInZip (zf,buf,size_read);
+ if (err<0)
+ {
+ printf("error in writing %s in the zipfile\n",
+ filenameinzip);
+ }
+
+ }
+ } while ((err == ZIP_OK) && (size_read>0));
+
+ if (fin)
+ fclose(fin);
+
+ if (err<0)
+ err=ZIP_ERRNO;
+ else
+ {
+ err = zipCloseFileInZip(zf);
+ if (err!=ZIP_OK)
+ printf("error in closing %s in the zipfile\n",
+ filenameinzip);
+ }
+ }
+ }
+ errclose = zipClose(zf,NULL);
+ if (errclose != ZIP_OK)
+ printf("error in closing %s\n",filename_try);
+ }
+ else
+ {
+ do_help();
+ }
+
+ free(buf);
+ return 0;
+}
diff --git a/zlib/contrib/minizip/minizip.pc.in b/zlib/contrib/minizip/minizip.pc.in
new file mode 100644
index 000000000..69b5b7fdc
--- /dev/null
+++ b/zlib/contrib/minizip/minizip.pc.in
@@ -0,0 +1,12 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@/minizip
+
+Name: minizip
+Description: Minizip zip file manipulation library
+Requires:
+Version: @PACKAGE_VERSION@
+Libs: -L${libdir} -lminizip
+Libs.private: -lz
+Cflags: -I${includedir}
diff --git a/zlib/contrib/minizip/mztools.c b/zlib/contrib/minizip/mztools.c
new file mode 100644
index 000000000..96891c2e0
--- /dev/null
+++ b/zlib/contrib/minizip/mztools.c
@@ -0,0 +1,291 @@
+/*
+ Additional tools for Minizip
+ Code: Xavier Roche '2004
+ License: Same as ZLIB (www.gzip.org)
+*/
+
+/* Code */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "zlib.h"
+#include "unzip.h"
+
+#define READ_8(adr) ((unsigned char)*(adr))
+#define READ_16(adr) ( READ_8(adr) | (READ_8(adr+1) << 8) )
+#define READ_32(adr) ( READ_16(adr) | (READ_16((adr)+2) << 16) )
+
+#define WRITE_8(buff, n) do { \
+ *((unsigned char*)(buff)) = (unsigned char) ((n) & 0xff); \
+} while(0)
+#define WRITE_16(buff, n) do { \
+ WRITE_8((unsigned char*)(buff), n); \
+ WRITE_8(((unsigned char*)(buff)) + 1, (n) >> 8); \
+} while(0)
+#define WRITE_32(buff, n) do { \
+ WRITE_16((unsigned char*)(buff), (n) & 0xffff); \
+ WRITE_16((unsigned char*)(buff) + 2, (n) >> 16); \
+} while(0)
+
+extern int ZEXPORT unzRepair(file, fileOut, fileOutTmp, nRecovered, bytesRecovered)
+const char* file;
+const char* fileOut;
+const char* fileOutTmp;
+uLong* nRecovered;
+uLong* bytesRecovered;
+{
+ int err = Z_OK;
+ FILE* fpZip = fopen(file, "rb");
+ FILE* fpOut = fopen(fileOut, "wb");
+ FILE* fpOutCD = fopen(fileOutTmp, "wb");
+ if (fpZip != NULL && fpOut != NULL) {
+ int entries = 0;
+ uLong totalBytes = 0;
+ char header[30];
+ char filename[1024];
+ char extra[1024];
+ int offset = 0;
+ int offsetCD = 0;
+ while ( fread(header, 1, 30, fpZip) == 30 ) {
+ int currentOffset = offset;
+
+ /* File entry */
+ if (READ_32(header) == 0x04034b50) {
+ unsigned int version = READ_16(header + 4);
+ unsigned int gpflag = READ_16(header + 6);
+ unsigned int method = READ_16(header + 8);
+ unsigned int filetime = READ_16(header + 10);
+ unsigned int filedate = READ_16(header + 12);
+ unsigned int crc = READ_32(header + 14); /* crc */
+ unsigned int cpsize = READ_32(header + 18); /* compressed size */
+ unsigned int uncpsize = READ_32(header + 22); /* uncompressed sz */
+ unsigned int fnsize = READ_16(header + 26); /* file name length */
+ unsigned int extsize = READ_16(header + 28); /* extra field length */
+ filename[0] = extra[0] = '\0';
+
+ /* Header */
+ if (fwrite(header, 1, 30, fpOut) == 30) {
+ offset += 30;
+ } else {
+ err = Z_ERRNO;
+ break;
+ }
+
+ /* Filename */
+ if (fnsize > 0) {
+ if (fnsize < sizeof(filename)) {
+ if (fread(filename, 1, fnsize, fpZip) == fnsize) {
+ if (fwrite(filename, 1, fnsize, fpOut) == fnsize) {
+ offset += fnsize;
+ } else {
+ err = Z_ERRNO;
+ break;
+ }
+ } else {
+ err = Z_ERRNO;
+ break;
+ }
+ } else {
+ err = Z_ERRNO;
+ break;
+ }
+ } else {
+ err = Z_STREAM_ERROR;
+ break;
+ }
+
+ /* Extra field */
+ if (extsize > 0) {
+ if (extsize < sizeof(extra)) {
+ if (fread(extra, 1, extsize, fpZip) == extsize) {
+ if (fwrite(extra, 1, extsize, fpOut) == extsize) {
+ offset += extsize;
+ } else {
+ err = Z_ERRNO;
+ break;
+ }
+ } else {
+ err = Z_ERRNO;
+ break;
+ }
+ } else {
+ err = Z_ERRNO;
+ break;
+ }
+ }
+
+ /* Data */
+ {
+ int dataSize = cpsize;
+ if (dataSize == 0) {
+ dataSize = uncpsize;
+ }
+ if (dataSize > 0) {
+ char* data = malloc(dataSize);
+ if (data != NULL) {
+ if ((int)fread(data, 1, dataSize, fpZip) == dataSize) {
+ if ((int)fwrite(data, 1, dataSize, fpOut) == dataSize) {
+ offset += dataSize;
+ totalBytes += dataSize;
+ } else {
+ err = Z_ERRNO;
+ }
+ } else {
+ err = Z_ERRNO;
+ }
+ free(data);
+ if (err != Z_OK) {
+ break;
+ }
+ } else {
+ err = Z_MEM_ERROR;
+ break;
+ }
+ }
+ }
+
+ /* Central directory entry */
+ {
+ char header[46];
+ char* comment = "";
+ int comsize = (int) strlen(comment);
+ WRITE_32(header, 0x02014b50);
+ WRITE_16(header + 4, version);
+ WRITE_16(header + 6, version);
+ WRITE_16(header + 8, gpflag);
+ WRITE_16(header + 10, method);
+ WRITE_16(header + 12, filetime);
+ WRITE_16(header + 14, filedate);
+ WRITE_32(header + 16, crc);
+ WRITE_32(header + 20, cpsize);
+ WRITE_32(header + 24, uncpsize);
+ WRITE_16(header + 28, fnsize);
+ WRITE_16(header + 30, extsize);
+ WRITE_16(header + 32, comsize);
+ WRITE_16(header + 34, 0); /* disk # */
+ WRITE_16(header + 36, 0); /* int attrb */
+ WRITE_32(header + 38, 0); /* ext attrb */
+ WRITE_32(header + 42, currentOffset);
+ /* Header */
+ if (fwrite(header, 1, 46, fpOutCD) == 46) {
+ offsetCD += 46;
+
+ /* Filename */
+ if (fnsize > 0) {
+ if (fwrite(filename, 1, fnsize, fpOutCD) == fnsize) {
+ offsetCD += fnsize;
+ } else {
+ err = Z_ERRNO;
+ break;
+ }
+ } else {
+ err = Z_STREAM_ERROR;
+ break;
+ }
+
+ /* Extra field */
+ if (extsize > 0) {
+ if (fwrite(extra, 1, extsize, fpOutCD) == extsize) {
+ offsetCD += extsize;
+ } else {
+ err = Z_ERRNO;
+ break;
+ }
+ }
+
+ /* Comment field */
+ if (comsize > 0) {
+ if ((int)fwrite(comment, 1, comsize, fpOutCD) == comsize) {
+ offsetCD += comsize;
+ } else {
+ err = Z_ERRNO;
+ break;
+ }
+ }
+
+
+ } else {
+ err = Z_ERRNO;
+ break;
+ }
+ }
+
+ /* Success */
+ entries++;
+
+ } else {
+ break;
+ }
+ }
+
+ /* Final central directory */
+ {
+ int entriesZip = entries;
+ char header[22];
+ char* comment = ""; // "ZIP File recovered by zlib/minizip/mztools";
+ int comsize = (int) strlen(comment);
+ if (entriesZip > 0xffff) {
+ entriesZip = 0xffff;
+ }
+ WRITE_32(header, 0x06054b50);
+ WRITE_16(header + 4, 0); /* disk # */
+ WRITE_16(header + 6, 0); /* disk # */
+ WRITE_16(header + 8, entriesZip); /* hack */
+ WRITE_16(header + 10, entriesZip); /* hack */
+ WRITE_32(header + 12, offsetCD); /* size of CD */
+ WRITE_32(header + 16, offset); /* offset to CD */
+ WRITE_16(header + 20, comsize); /* comment */
+
+ /* Header */
+ if (fwrite(header, 1, 22, fpOutCD) == 22) {
+
+ /* Comment field */
+ if (comsize > 0) {
+ if ((int)fwrite(comment, 1, comsize, fpOutCD) != comsize) {
+ err = Z_ERRNO;
+ }
+ }
+
+ } else {
+ err = Z_ERRNO;
+ }
+ }
+
+ /* Final merge (file + central directory) */
+ fclose(fpOutCD);
+ if (err == Z_OK) {
+ fpOutCD = fopen(fileOutTmp, "rb");
+ if (fpOutCD != NULL) {
+ int nRead;
+ char buffer[8192];
+ while ( (nRead = (int)fread(buffer, 1, sizeof(buffer), fpOutCD)) > 0) {
+ if ((int)fwrite(buffer, 1, nRead, fpOut) != nRead) {
+ err = Z_ERRNO;
+ break;
+ }
+ }
+ fclose(fpOutCD);
+ }
+ }
+
+ /* Close */
+ fclose(fpZip);
+ fclose(fpOut);
+
+ /* Wipe temporary file */
+ (void)remove(fileOutTmp);
+
+ /* Number of recovered entries */
+ if (err == Z_OK) {
+ if (nRecovered != NULL) {
+ *nRecovered = entries;
+ }
+ if (bytesRecovered != NULL) {
+ *bytesRecovered = totalBytes;
+ }
+ }
+ } else {
+ err = Z_STREAM_ERROR;
+ }
+ return err;
+}
diff --git a/zlib/contrib/minizip/mztools.h b/zlib/contrib/minizip/mztools.h
new file mode 100644
index 000000000..a49a426ec
--- /dev/null
+++ b/zlib/contrib/minizip/mztools.h
@@ -0,0 +1,37 @@
+/*
+ Additional tools for Minizip
+ Code: Xavier Roche '2004
+ License: Same as ZLIB (www.gzip.org)
+*/
+
+#ifndef _zip_tools_H
+#define _zip_tools_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _ZLIB_H
+#include "zlib.h"
+#endif
+
+#include "unzip.h"
+
+/* Repair a ZIP file (missing central directory)
+ file: file to recover
+ fileOut: output file after recovery
+ fileOutTmp: temporary file name used for recovery
+*/
+extern int ZEXPORT unzRepair(const char* file,
+ const char* fileOut,
+ const char* fileOutTmp,
+ uLong* nRecovered,
+ uLong* bytesRecovered);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif
diff --git a/zlib/contrib/minizip/unzip.c b/zlib/contrib/minizip/unzip.c
new file mode 100644
index 000000000..bcfb9416e
--- /dev/null
+++ b/zlib/contrib/minizip/unzip.c
@@ -0,0 +1,2125 @@
+/* unzip.c -- IO for uncompress .zip files using zlib
+ Version 1.1, February 14h, 2010
+ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Modifications of Unzip for Zip64
+ Copyright (C) 2007-2008 Even Rouault
+
+ Modifications for Zip64 support on both zip and unzip
+ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+ For more info read MiniZip_info.txt
+
+
+ ------------------------------------------------------------------------------------
+ Decryption code comes from crypt.c by Info-ZIP but has been greatly reduced in terms of
+ compatibility with older software. The following is from the original crypt.c.
+ Code woven in by Terry Thorsen 1/2003.
+
+ Copyright (c) 1990-2000 Info-ZIP. All rights reserved.
+
+ See the accompanying file LICENSE, version 2000-Apr-09 or later
+ (the contents of which are also included in zip.h) for terms of use.
+ If, for some reason, all these files are missing, the Info-ZIP license
+ also may be found at: ftp://ftp.info-zip.org/pub/infozip/license.html
+
+ crypt.c (full version) by Info-ZIP. Last revised: [see crypt.h]
+
+ The encryption/decryption parts of this source code (as opposed to the
+ non-echoing password parts) were originally written in Europe. The
+ whole source package can be freely distributed, including from the USA.
+ (Prior to January 2000, re-export from the US was a violation of US law.)
+
+ This encryption code is a direct transcription of the algorithm from
+ Roger Schlafly, described by Phil Katz in the file appnote.txt. This
+ file (appnote.txt) is distributed with the PKZIP program (even in the
+ version without encryption capabilities).
+
+ ------------------------------------------------------------------------------------
+
+ Changes in unzip.c
+
+ 2007-2008 - Even Rouault - Addition of cpl_unzGetCurrentFileZStreamPos
+ 2007-2008 - Even Rouault - Decoration of symbol names unz* -> cpl_unz*
+ 2007-2008 - Even Rouault - Remove old C style function prototypes
+ 2007-2008 - Even Rouault - Add unzip support for ZIP64
+
+ Copyright (C) 2007-2008 Even Rouault
+
+
+ Oct-2009 - Mathias Svensson - Removed cpl_* from symbol names (Even Rouault added them but since this is now moved to a new project (minizip64) I renamed them again).
+ Oct-2009 - Mathias Svensson - Fixed problem if uncompressed size was > 4G and compressed size was <4G
+ should only read the compressed/uncompressed size from the Zip64 format if
+ the size from normal header was 0xFFFFFFFF
+ Oct-2009 - Mathias Svensson - Applied some bug fixes from paches recived from Gilles Vollant
+ Oct-2009 - Mathias Svensson - Applied support to unzip files with compression mathod BZIP2 (bzip2 lib is required)
+ Patch created by Daniel Borca
+
+ Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer
+
+ Copyright (C) 1998 - 2010 Gilles Vollant, Even Rouault, Mathias Svensson
+
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifndef NOUNCRYPT
+ #define NOUNCRYPT
+#endif
+
+#include "zlib.h"
+#include "unzip.h"
+
+#ifdef STDC
+# include <stddef.h>
+# include <string.h>
+# include <stdlib.h>
+#endif
+#ifdef NO_ERRNO_H
+ extern int errno;
+#else
+# include <errno.h>
+#endif
+
+
+#ifndef local
+# define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+
+#ifndef CASESENSITIVITYDEFAULT_NO
+# if !defined(unix) && !defined(CASESENSITIVITYDEFAULT_YES)
+# define CASESENSITIVITYDEFAULT_NO
+# endif
+#endif
+
+
+#ifndef UNZ_BUFSIZE
+#define UNZ_BUFSIZE (16384)
+#endif
+
+#ifndef UNZ_MAXFILENAMEINZIP
+#define UNZ_MAXFILENAMEINZIP (256)
+#endif
+
+#ifndef ALLOC
+# define ALLOC(size) (malloc(size))
+#endif
+#ifndef TRYFREE
+# define TRYFREE(p) {if (p) free(p);}
+#endif
+
+#define SIZECENTRALDIRITEM (0x2e)
+#define SIZEZIPLOCALHEADER (0x1e)
+
+
+const char unz_copyright[] =
+ " unzip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
+
+/* unz_file_info_interntal contain internal info about a file in zipfile*/
+typedef struct unz_file_info64_internal_s
+{
+ ZPOS64_T offset_curfile;/* relative offset of local header 8 bytes */
+} unz_file_info64_internal;
+
+
+/* file_in_zip_read_info_s contain internal information about a file in zipfile,
+ when reading and decompress it */
+typedef struct
+{
+ char *read_buffer; /* internal buffer for compressed data */
+ z_stream stream; /* zLib stream structure for inflate */
+
+#ifdef HAVE_BZIP2
+ bz_stream bstream; /* bzLib stream structure for bziped */
+#endif
+
+ ZPOS64_T pos_in_zipfile; /* position in byte on the zipfile, for fseek*/
+ uLong stream_initialised; /* flag set if stream structure is initialised*/
+
+ ZPOS64_T offset_local_extrafield;/* offset of the local extra field */
+ uInt size_local_extrafield;/* size of the local extra field */
+ ZPOS64_T pos_local_extrafield; /* position in the local extra field in read*/
+ ZPOS64_T total_out_64;
+
+ uLong crc32; /* crc32 of all data uncompressed */
+ uLong crc32_wait; /* crc32 we must obtain after decompress all */
+ ZPOS64_T rest_read_compressed; /* number of byte to be decompressed */
+ ZPOS64_T rest_read_uncompressed;/*number of byte to be obtained after decomp*/
+ zlib_filefunc64_32_def z_filefunc;
+ voidpf filestream; /* io structore of the zipfile */
+ uLong compression_method; /* compression method (0==store) */
+ ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
+ int raw;
+} file_in_zip64_read_info_s;
+
+
+/* unz64_s contain internal information about the zipfile
+*/
+typedef struct
+{
+ zlib_filefunc64_32_def z_filefunc;
+ int is64bitOpenFunction;
+ voidpf filestream; /* io structore of the zipfile */
+ unz_global_info64 gi; /* public global information */
+ ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
+ ZPOS64_T num_file; /* number of the current file in the zipfile*/
+ ZPOS64_T pos_in_central_dir; /* pos of the current file in the central dir*/
+ ZPOS64_T current_file_ok; /* flag about the usability of the current file*/
+ ZPOS64_T central_pos; /* position of the beginning of the central dir*/
+
+ ZPOS64_T size_central_dir; /* size of the central directory */
+ ZPOS64_T offset_central_dir; /* offset of start of central directory with
+ respect to the starting disk number */
+
+ unz_file_info64 cur_file_info; /* public info about the current file in zip*/
+ unz_file_info64_internal cur_file_info_internal; /* private info about it*/
+ file_in_zip64_read_info_s* pfile_in_zip_read; /* structure about the current
+ file if we are decompressing it */
+ int encrypted;
+
+ int isZip64;
+
+# ifndef NOUNCRYPT
+ unsigned long keys[3]; /* keys defining the pseudo-random sequence */
+ const z_crc_t* pcrc_32_tab;
+# endif
+} unz64_s;
+
+
+#ifndef NOUNCRYPT
+#include "crypt.h"
+#endif
+
+/* ===========================================================================
+ Read a byte from a gz_stream; update next_in and avail_in. Return EOF
+ for end of file.
+ IN assertion: the stream s has been successfully opened for reading.
+*/
+
+
+local int unz64local_getByte OF((
+ const zlib_filefunc64_32_def* pzlib_filefunc_def,
+ voidpf filestream,
+ int *pi));
+
+local int unz64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi)
+{
+ unsigned char c;
+ int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1);
+ if (err==1)
+ {
+ *pi = (int)c;
+ return UNZ_OK;
+ }
+ else
+ {
+ if (ZERROR64(*pzlib_filefunc_def,filestream))
+ return UNZ_ERRNO;
+ else
+ return UNZ_EOF;
+ }
+}
+
+
+/* ===========================================================================
+ Reads a long in LSB order from the given gz_stream. Sets
+*/
+local int unz64local_getShort OF((
+ const zlib_filefunc64_32_def* pzlib_filefunc_def,
+ voidpf filestream,
+ uLong *pX));
+
+local int unz64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def,
+ voidpf filestream,
+ uLong *pX)
+{
+ uLong x ;
+ int i = 0;
+ int err;
+
+ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x = (uLong)i;
+
+ if (err==UNZ_OK)
+ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x |= ((uLong)i)<<8;
+
+ if (err==UNZ_OK)
+ *pX = x;
+ else
+ *pX = 0;
+ return err;
+}
+
+local int unz64local_getLong OF((
+ const zlib_filefunc64_32_def* pzlib_filefunc_def,
+ voidpf filestream,
+ uLong *pX));
+
+local int unz64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def,
+ voidpf filestream,
+ uLong *pX)
+{
+ uLong x ;
+ int i = 0;
+ int err;
+
+ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x = (uLong)i;
+
+ if (err==UNZ_OK)
+ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x |= ((uLong)i)<<8;
+
+ if (err==UNZ_OK)
+ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x |= ((uLong)i)<<16;
+
+ if (err==UNZ_OK)
+ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x += ((uLong)i)<<24;
+
+ if (err==UNZ_OK)
+ *pX = x;
+ else
+ *pX = 0;
+ return err;
+}
+
+local int unz64local_getLong64 OF((
+ const zlib_filefunc64_32_def* pzlib_filefunc_def,
+ voidpf filestream,
+ ZPOS64_T *pX));
+
+
+local int unz64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def,
+ voidpf filestream,
+ ZPOS64_T *pX)
+{
+ ZPOS64_T x ;
+ int i = 0;
+ int err;
+
+ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x = (ZPOS64_T)i;
+
+ if (err==UNZ_OK)
+ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x |= ((ZPOS64_T)i)<<8;
+
+ if (err==UNZ_OK)
+ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x |= ((ZPOS64_T)i)<<16;
+
+ if (err==UNZ_OK)
+ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x |= ((ZPOS64_T)i)<<24;
+
+ if (err==UNZ_OK)
+ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x |= ((ZPOS64_T)i)<<32;
+
+ if (err==UNZ_OK)
+ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x |= ((ZPOS64_T)i)<<40;
+
+ if (err==UNZ_OK)
+ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x |= ((ZPOS64_T)i)<<48;
+
+ if (err==UNZ_OK)
+ err = unz64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x |= ((ZPOS64_T)i)<<56;
+
+ if (err==UNZ_OK)
+ *pX = x;
+ else
+ *pX = 0;
+ return err;
+}
+
+/* My own strcmpi / strcasecmp */
+local int strcmpcasenosensitive_internal (const char* fileName1, const char* fileName2)
+{
+ for (;;)
+ {
+ char c1=*(fileName1++);
+ char c2=*(fileName2++);
+ if ((c1>='a') && (c1<='z'))
+ c1 -= 0x20;
+ if ((c2>='a') && (c2<='z'))
+ c2 -= 0x20;
+ if (c1=='\0')
+ return ((c2=='\0') ? 0 : -1);
+ if (c2=='\0')
+ return 1;
+ if (c1<c2)
+ return -1;
+ if (c1>c2)
+ return 1;
+ }
+}
+
+
+#ifdef CASESENSITIVITYDEFAULT_NO
+#define CASESENSITIVITYDEFAULTVALUE 2
+#else
+#define CASESENSITIVITYDEFAULTVALUE 1
+#endif
+
+#ifndef STRCMPCASENOSENTIVEFUNCTION
+#define STRCMPCASENOSENTIVEFUNCTION strcmpcasenosensitive_internal
+#endif
+
+/*
+ Compare two filename (fileName1,fileName2).
+ If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
+ If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
+ or strcasecmp)
+ If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
+ (like 1 on Unix, 2 on Windows)
+
+*/
+extern int ZEXPORT unzStringFileNameCompare (const char* fileName1,
+ const char* fileName2,
+ int iCaseSensitivity)
+
+{
+ if (iCaseSensitivity==0)
+ iCaseSensitivity=CASESENSITIVITYDEFAULTVALUE;
+
+ if (iCaseSensitivity==1)
+ return strcmp(fileName1,fileName2);
+
+ return STRCMPCASENOSENTIVEFUNCTION(fileName1,fileName2);
+}
+
+#ifndef BUFREADCOMMENT
+#define BUFREADCOMMENT (0x400)
+#endif
+
+/*
+ Locate the Central directory of a zipfile (at the end, just before
+ the global comment)
+*/
+local ZPOS64_T unz64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
+local ZPOS64_T unz64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
+{
+ unsigned char* buf;
+ ZPOS64_T uSizeFile;
+ ZPOS64_T uBackRead;
+ ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
+ ZPOS64_T uPosFound=0;
+
+ if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
+ return 0;
+
+
+ uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
+
+ if (uMaxBack>uSizeFile)
+ uMaxBack = uSizeFile;
+
+ buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
+ if (buf==NULL)
+ return 0;
+
+ uBackRead = 4;
+ while (uBackRead<uMaxBack)
+ {
+ uLong uReadSize;
+ ZPOS64_T uReadPos ;
+ int i;
+ if (uBackRead+BUFREADCOMMENT>uMaxBack)
+ uBackRead = uMaxBack;
+ else
+ uBackRead+=BUFREADCOMMENT;
+ uReadPos = uSizeFile-uBackRead ;
+
+ uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
+ (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
+ if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+ break;
+
+ if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
+ break;
+
+ for (i=(int)uReadSize-3; (i--)>0;)
+ if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
+ ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
+ {
+ uPosFound = uReadPos+i;
+ break;
+ }
+
+ if (uPosFound!=0)
+ break;
+ }
+ TRYFREE(buf);
+ return uPosFound;
+}
+
+
+/*
+ Locate the Central directory 64 of a zipfile (at the end, just before
+ the global comment)
+*/
+local ZPOS64_T unz64local_SearchCentralDir64 OF((
+ const zlib_filefunc64_32_def* pzlib_filefunc_def,
+ voidpf filestream));
+
+local ZPOS64_T unz64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def,
+ voidpf filestream)
+{
+ unsigned char* buf;
+ ZPOS64_T uSizeFile;
+ ZPOS64_T uBackRead;
+ ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
+ ZPOS64_T uPosFound=0;
+ uLong uL;
+ ZPOS64_T relativeOffset;
+
+ if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
+ return 0;
+
+
+ uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
+
+ if (uMaxBack>uSizeFile)
+ uMaxBack = uSizeFile;
+
+ buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
+ if (buf==NULL)
+ return 0;
+
+ uBackRead = 4;
+ while (uBackRead<uMaxBack)
+ {
+ uLong uReadSize;
+ ZPOS64_T uReadPos;
+ int i;
+ if (uBackRead+BUFREADCOMMENT>uMaxBack)
+ uBackRead = uMaxBack;
+ else
+ uBackRead+=BUFREADCOMMENT;
+ uReadPos = uSizeFile-uBackRead ;
+
+ uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
+ (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
+ if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+ break;
+
+ if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
+ break;
+
+ for (i=(int)uReadSize-3; (i--)>0;)
+ if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
+ ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07))
+ {
+ uPosFound = uReadPos+i;
+ break;
+ }
+
+ if (uPosFound!=0)
+ break;
+ }
+ TRYFREE(buf);
+ if (uPosFound == 0)
+ return 0;
+
+ /* Zip64 end of central directory locator */
+ if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0)
+ return 0;
+
+ /* the signature, already checked */
+ if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
+ return 0;
+
+ /* number of the disk with the start of the zip64 end of central directory */
+ if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
+ return 0;
+ if (uL != 0)
+ return 0;
+
+ /* relative offset of the zip64 end of central directory record */
+ if (unz64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=UNZ_OK)
+ return 0;
+
+ /* total number of disks */
+ if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
+ return 0;
+ if (uL != 1)
+ return 0;
+
+ /* Goto end of central directory record */
+ if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0)
+ return 0;
+
+ /* the signature */
+ if (unz64local_getLong(pzlib_filefunc_def,filestream,&uL)!=UNZ_OK)
+ return 0;
+
+ if (uL != 0x06064b50)
+ return 0;
+
+ return relativeOffset;
+}
+
+/*
+ Open a Zip file. path contain the full pathname (by example,
+ on a Windows NT computer "c:\\test\\zlib114.zip" or on an Unix computer
+ "zlib/zlib114.zip".
+ If the zipfile cannot be opened (file doesn't exist or in not valid), the
+ return value is NULL.
+ Else, the return value is a unzFile Handle, usable with other function
+ of this unzip package.
+*/
+local unzFile unzOpenInternal (const void *path,
+ zlib_filefunc64_32_def* pzlib_filefunc64_32_def,
+ int is64bitOpenFunction)
+{
+ unz64_s us;
+ unz64_s *s;
+ ZPOS64_T central_pos;
+ uLong uL;
+
+ uLong number_disk; /* number of the current dist, used for
+ spaning ZIP, unsupported, always 0*/
+ uLong number_disk_with_CD; /* number the the disk with central dir, used
+ for spaning ZIP, unsupported, always 0*/
+ ZPOS64_T number_entry_CD; /* total number of entries in
+ the central dir
+ (same than number_entry on nospan) */
+
+ int err=UNZ_OK;
+
+ if (unz_copyright[0]!=' ')
+ return NULL;
+
+ us.z_filefunc.zseek32_file = NULL;
+ us.z_filefunc.ztell32_file = NULL;
+ if (pzlib_filefunc64_32_def==NULL)
+ fill_fopen64_filefunc(&us.z_filefunc.zfile_func64);
+ else
+ us.z_filefunc = *pzlib_filefunc64_32_def;
+ us.is64bitOpenFunction = is64bitOpenFunction;
+
+
+
+ us.filestream = ZOPEN64(us.z_filefunc,
+ path,
+ ZLIB_FILEFUNC_MODE_READ |
+ ZLIB_FILEFUNC_MODE_EXISTING);
+ if (us.filestream==NULL)
+ return NULL;
+
+ central_pos = unz64local_SearchCentralDir64(&us.z_filefunc,us.filestream);
+ if (central_pos)
+ {
+ uLong uS;
+ ZPOS64_T uL64;
+
+ us.isZip64 = 1;
+
+ if (ZSEEK64(us.z_filefunc, us.filestream,
+ central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+ err=UNZ_ERRNO;
+
+ /* the signature, already checked */
+ if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
+ err=UNZ_ERRNO;
+
+ /* size of zip64 end of central directory record */
+ if (unz64local_getLong64(&us.z_filefunc, us.filestream,&uL64)!=UNZ_OK)
+ err=UNZ_ERRNO;
+
+ /* version made by */
+ if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)
+ err=UNZ_ERRNO;
+
+ /* version needed to extract */
+ if (unz64local_getShort(&us.z_filefunc, us.filestream,&uS)!=UNZ_OK)
+ err=UNZ_ERRNO;
+
+ /* number of this disk */
+ if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
+ err=UNZ_ERRNO;
+
+ /* number of the disk with the start of the central directory */
+ if (unz64local_getLong(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
+ err=UNZ_ERRNO;
+
+ /* total number of entries in the central directory on this disk */
+ if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.gi.number_entry)!=UNZ_OK)
+ err=UNZ_ERRNO;
+
+ /* total number of entries in the central directory */
+ if (unz64local_getLong64(&us.z_filefunc, us.filestream,&number_entry_CD)!=UNZ_OK)
+ err=UNZ_ERRNO;
+
+ if ((number_entry_CD!=us.gi.number_entry) ||
+ (number_disk_with_CD!=0) ||
+ (number_disk!=0))
+ err=UNZ_BADZIPFILE;
+
+ /* size of the central directory */
+ if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.size_central_dir)!=UNZ_OK)
+ err=UNZ_ERRNO;
+
+ /* offset of start of central directory with respect to the
+ starting disk number */
+ if (unz64local_getLong64(&us.z_filefunc, us.filestream,&us.offset_central_dir)!=UNZ_OK)
+ err=UNZ_ERRNO;
+
+ us.gi.size_comment = 0;
+ }
+ else
+ {
+ central_pos = unz64local_SearchCentralDir(&us.z_filefunc,us.filestream);
+ if (central_pos==0)
+ err=UNZ_ERRNO;
+
+ us.isZip64 = 0;
+
+ if (ZSEEK64(us.z_filefunc, us.filestream,
+ central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+ err=UNZ_ERRNO;
+
+ /* the signature, already checked */
+ if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
+ err=UNZ_ERRNO;
+
+ /* number of this disk */
+ if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk)!=UNZ_OK)
+ err=UNZ_ERRNO;
+
+ /* number of the disk with the start of the central directory */
+ if (unz64local_getShort(&us.z_filefunc, us.filestream,&number_disk_with_CD)!=UNZ_OK)
+ err=UNZ_ERRNO;
+
+ /* total number of entries in the central dir on this disk */
+ if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
+ err=UNZ_ERRNO;
+ us.gi.number_entry = uL;
+
+ /* total number of entries in the central dir */
+ if (unz64local_getShort(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
+ err=UNZ_ERRNO;
+ number_entry_CD = uL;
+
+ if ((number_entry_CD!=us.gi.number_entry) ||
+ (number_disk_with_CD!=0) ||
+ (number_disk!=0))
+ err=UNZ_BADZIPFILE;
+
+ /* size of the central directory */
+ if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
+ err=UNZ_ERRNO;
+ us.size_central_dir = uL;
+
+ /* offset of start of central directory with respect to the
+ starting disk number */
+ if (unz64local_getLong(&us.z_filefunc, us.filestream,&uL)!=UNZ_OK)
+ err=UNZ_ERRNO;
+ us.offset_central_dir = uL;
+
+ /* zipfile comment length */
+ if (unz64local_getShort(&us.z_filefunc, us.filestream,&us.gi.size_comment)!=UNZ_OK)
+ err=UNZ_ERRNO;
+ }
+
+ if ((central_pos<us.offset_central_dir+us.size_central_dir) &&
+ (err==UNZ_OK))
+ err=UNZ_BADZIPFILE;
+
+ if (err!=UNZ_OK)
+ {
+ ZCLOSE64(us.z_filefunc, us.filestream);
+ return NULL;
+ }
+
+ us.byte_before_the_zipfile = central_pos -
+ (us.offset_central_dir+us.size_central_dir);
+ us.central_pos = central_pos;
+ us.pfile_in_zip_read = NULL;
+ us.encrypted = 0;
+
+
+ s=(unz64_s*)ALLOC(sizeof(unz64_s));
+ if( s != NULL)
+ {
+ *s=us;
+ unzGoToFirstFile((unzFile)s);
+ }
+ return (unzFile)s;
+}
+
+
+extern unzFile ZEXPORT unzOpen2 (const char *path,
+ zlib_filefunc_def* pzlib_filefunc32_def)
+{
+ if (pzlib_filefunc32_def != NULL)
+ {
+ zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
+ fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);
+ return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 0);
+ }
+ else
+ return unzOpenInternal(path, NULL, 0);
+}
+
+extern unzFile ZEXPORT unzOpen2_64 (const void *path,
+ zlib_filefunc64_def* pzlib_filefunc_def)
+{
+ if (pzlib_filefunc_def != NULL)
+ {
+ zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
+ zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
+ zlib_filefunc64_32_def_fill.ztell32_file = NULL;
+ zlib_filefunc64_32_def_fill.zseek32_file = NULL;
+ return unzOpenInternal(path, &zlib_filefunc64_32_def_fill, 1);
+ }
+ else
+ return unzOpenInternal(path, NULL, 1);
+}
+
+extern unzFile ZEXPORT unzOpen (const char *path)
+{
+ return unzOpenInternal(path, NULL, 0);
+}
+
+extern unzFile ZEXPORT unzOpen64 (const void *path)
+{
+ return unzOpenInternal(path, NULL, 1);
+}
+
+/*
+ Close a ZipFile opened with unzOpen.
+ If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
+ these files MUST be closed with unzCloseCurrentFile before call unzClose.
+ return UNZ_OK if there is no problem. */
+extern int ZEXPORT unzClose (unzFile file)
+{
+ unz64_s* s;
+ if (file==NULL)
+ return UNZ_PARAMERROR;
+ s=(unz64_s*)file;
+
+ if (s->pfile_in_zip_read!=NULL)
+ unzCloseCurrentFile(file);
+
+ ZCLOSE64(s->z_filefunc, s->filestream);
+ TRYFREE(s);
+ return UNZ_OK;
+}
+
+
+/*
+ Write info about the ZipFile in the *pglobal_info structure.
+ No preparation of the structure is needed
+ return UNZ_OK if there is no problem. */
+extern int ZEXPORT unzGetGlobalInfo64 (unzFile file, unz_global_info64* pglobal_info)
+{
+ unz64_s* s;
+ if (file==NULL)
+ return UNZ_PARAMERROR;
+ s=(unz64_s*)file;
+ *pglobal_info=s->gi;
+ return UNZ_OK;
+}
+
+extern int ZEXPORT unzGetGlobalInfo (unzFile file, unz_global_info* pglobal_info32)
+{
+ unz64_s* s;
+ if (file==NULL)
+ return UNZ_PARAMERROR;
+ s=(unz64_s*)file;
+ /* to do : check if number_entry is not truncated */
+ pglobal_info32->number_entry = (uLong)s->gi.number_entry;
+ pglobal_info32->size_comment = s->gi.size_comment;
+ return UNZ_OK;
+}
+/*
+ Translate date/time from Dos format to tm_unz (readable more easilty)
+*/
+local void unz64local_DosDateToTmuDate (ZPOS64_T ulDosDate, tm_unz* ptm)
+{
+ ZPOS64_T uDate;
+ uDate = (ZPOS64_T)(ulDosDate>>16);
+ ptm->tm_mday = (uInt)(uDate&0x1f) ;
+ ptm->tm_mon = (uInt)((((uDate)&0x1E0)/0x20)-1) ;
+ ptm->tm_year = (uInt)(((uDate&0x0FE00)/0x0200)+1980) ;
+
+ ptm->tm_hour = (uInt) ((ulDosDate &0xF800)/0x800);
+ ptm->tm_min = (uInt) ((ulDosDate&0x7E0)/0x20) ;
+ ptm->tm_sec = (uInt) (2*(ulDosDate&0x1f)) ;
+}
+
+/*
+ Get Info about the current file in the zipfile, with internal only info
+*/
+local int unz64local_GetCurrentFileInfoInternal OF((unzFile file,
+ unz_file_info64 *pfile_info,
+ unz_file_info64_internal
+ *pfile_info_internal,
+ char *szFileName,
+ uLong fileNameBufferSize,
+ void *extraField,
+ uLong extraFieldBufferSize,
+ char *szComment,
+ uLong commentBufferSize));
+
+local int unz64local_GetCurrentFileInfoInternal (unzFile file,
+ unz_file_info64 *pfile_info,
+ unz_file_info64_internal
+ *pfile_info_internal,
+ char *szFileName,
+ uLong fileNameBufferSize,
+ void *extraField,
+ uLong extraFieldBufferSize,
+ char *szComment,
+ uLong commentBufferSize)
+{
+ unz64_s* s;
+ unz_file_info64 file_info;
+ unz_file_info64_internal file_info_internal;
+ int err=UNZ_OK;
+ uLong uMagic;
+ long lSeek=0;
+ uLong uL;
+
+ if (file==NULL)
+ return UNZ_PARAMERROR;
+ s=(unz64_s*)file;
+ if (ZSEEK64(s->z_filefunc, s->filestream,
+ s->pos_in_central_dir+s->byte_before_the_zipfile,
+ ZLIB_FILEFUNC_SEEK_SET)!=0)
+ err=UNZ_ERRNO;
+
+
+ /* we check the magic */
+ if (err==UNZ_OK)
+ {
+ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
+ err=UNZ_ERRNO;
+ else if (uMagic!=0x02014b50)
+ err=UNZ_BADZIPFILE;
+ }
+
+ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version) != UNZ_OK)
+ err=UNZ_ERRNO;
+
+ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.version_needed) != UNZ_OK)
+ err=UNZ_ERRNO;
+
+ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.flag) != UNZ_OK)
+ err=UNZ_ERRNO;
+
+ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.compression_method) != UNZ_OK)
+ err=UNZ_ERRNO;
+
+ if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.dosDate) != UNZ_OK)
+ err=UNZ_ERRNO;
+
+ unz64local_DosDateToTmuDate(file_info.dosDate,&file_info.tmu_date);
+
+ if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.crc) != UNZ_OK)
+ err=UNZ_ERRNO;
+
+ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
+ err=UNZ_ERRNO;
+ file_info.compressed_size = uL;
+
+ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
+ err=UNZ_ERRNO;
+ file_info.uncompressed_size = uL;
+
+ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_filename) != UNZ_OK)
+ err=UNZ_ERRNO;
+
+ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_extra) != UNZ_OK)
+ err=UNZ_ERRNO;
+
+ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.size_file_comment) != UNZ_OK)
+ err=UNZ_ERRNO;
+
+ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.disk_num_start) != UNZ_OK)
+ err=UNZ_ERRNO;
+
+ if (unz64local_getShort(&s->z_filefunc, s->filestream,&file_info.internal_fa) != UNZ_OK)
+ err=UNZ_ERRNO;
+
+ if (unz64local_getLong(&s->z_filefunc, s->filestream,&file_info.external_fa) != UNZ_OK)
+ err=UNZ_ERRNO;
+
+ // relative offset of local header
+ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
+ err=UNZ_ERRNO;
+ file_info_internal.offset_curfile = uL;
+
+ lSeek+=file_info.size_filename;
+ if ((err==UNZ_OK) && (szFileName!=NULL))
+ {
+ uLong uSizeRead ;
+ if (file_info.size_filename<fileNameBufferSize)
+ {
+ *(szFileName+file_info.size_filename)='\0';
+ uSizeRead = file_info.size_filename;
+ }
+ else
+ uSizeRead = fileNameBufferSize;
+
+ if ((file_info.size_filename>0) && (fileNameBufferSize>0))
+ if (ZREAD64(s->z_filefunc, s->filestream,szFileName,uSizeRead)!=uSizeRead)
+ err=UNZ_ERRNO;
+ lSeek -= uSizeRead;
+ }
+
+ // Read extrafield
+ if ((err==UNZ_OK) && (extraField!=NULL))
+ {
+ ZPOS64_T uSizeRead ;
+ if (file_info.size_file_extra<extraFieldBufferSize)
+ uSizeRead = file_info.size_file_extra;
+ else
+ uSizeRead = extraFieldBufferSize;
+
+ if (lSeek!=0)
+ {
+ if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
+ lSeek=0;
+ else
+ err=UNZ_ERRNO;
+ }
+
+ if ((file_info.size_file_extra>0) && (extraFieldBufferSize>0))
+ if (ZREAD64(s->z_filefunc, s->filestream,extraField,(uLong)uSizeRead)!=uSizeRead)
+ err=UNZ_ERRNO;
+
+ lSeek += file_info.size_file_extra - (uLong)uSizeRead;
+ }
+ else
+ lSeek += file_info.size_file_extra;
+
+
+ if ((err==UNZ_OK) && (file_info.size_file_extra != 0))
+ {
+ uLong acc = 0;
+
+ // since lSeek now points to after the extra field we need to move back
+ lSeek -= file_info.size_file_extra;
+
+ if (lSeek!=0)
+ {
+ if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
+ lSeek=0;
+ else
+ err=UNZ_ERRNO;
+ }
+
+ while(acc < file_info.size_file_extra)
+ {
+ uLong headerId;
+ uLong dataSize;
+
+ if (unz64local_getShort(&s->z_filefunc, s->filestream,&headerId) != UNZ_OK)
+ err=UNZ_ERRNO;
+
+ if (unz64local_getShort(&s->z_filefunc, s->filestream,&dataSize) != UNZ_OK)
+ err=UNZ_ERRNO;
+
+ /* ZIP64 extra fields */
+ if (headerId == 0x0001)
+ {
+ uLong uL;
+
+ if(file_info.uncompressed_size == MAXU32)
+ {
+ if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.uncompressed_size) != UNZ_OK)
+ err=UNZ_ERRNO;
+ }
+
+ if(file_info.compressed_size == MAXU32)
+ {
+ if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info.compressed_size) != UNZ_OK)
+ err=UNZ_ERRNO;
+ }
+
+ if(file_info_internal.offset_curfile == MAXU32)
+ {
+ /* Relative Header offset */
+ if (unz64local_getLong64(&s->z_filefunc, s->filestream,&file_info_internal.offset_curfile) != UNZ_OK)
+ err=UNZ_ERRNO;
+ }
+
+ if(file_info.disk_num_start == MAXU32)
+ {
+ /* Disk Start Number */
+ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uL) != UNZ_OK)
+ err=UNZ_ERRNO;
+ }
+
+ }
+ else
+ {
+ if (ZSEEK64(s->z_filefunc, s->filestream,dataSize,ZLIB_FILEFUNC_SEEK_CUR)!=0)
+ err=UNZ_ERRNO;
+ }
+
+ acc += 2 + 2 + dataSize;
+ }
+ }
+
+ if ((err==UNZ_OK) && (szComment!=NULL))
+ {
+ uLong uSizeRead ;
+ if (file_info.size_file_comment<commentBufferSize)
+ {
+ *(szComment+file_info.size_file_comment)='\0';
+ uSizeRead = file_info.size_file_comment;
+ }
+ else
+ uSizeRead = commentBufferSize;
+
+ if (lSeek!=0)
+ {
+ if (ZSEEK64(s->z_filefunc, s->filestream,lSeek,ZLIB_FILEFUNC_SEEK_CUR)==0)
+ lSeek=0;
+ else
+ err=UNZ_ERRNO;
+ }
+
+ if ((file_info.size_file_comment>0) && (commentBufferSize>0))
+ if (ZREAD64(s->z_filefunc, s->filestream,szComment,uSizeRead)!=uSizeRead)
+ err=UNZ_ERRNO;
+ lSeek+=file_info.size_file_comment - uSizeRead;
+ }
+ else
+ lSeek+=file_info.size_file_comment;
+
+
+ if ((err==UNZ_OK) && (pfile_info!=NULL))
+ *pfile_info=file_info;
+
+ if ((err==UNZ_OK) && (pfile_info_internal!=NULL))
+ *pfile_info_internal=file_info_internal;
+
+ return err;
+}
+
+
+
+/*
+ Write info about the ZipFile in the *pglobal_info structure.
+ No preparation of the structure is needed
+ return UNZ_OK if there is no problem.
+*/
+extern int ZEXPORT unzGetCurrentFileInfo64 (unzFile file,
+ unz_file_info64 * pfile_info,
+ char * szFileName, uLong fileNameBufferSize,
+ void *extraField, uLong extraFieldBufferSize,
+ char* szComment, uLong commentBufferSize)
+{
+ return unz64local_GetCurrentFileInfoInternal(file,pfile_info,NULL,
+ szFileName,fileNameBufferSize,
+ extraField,extraFieldBufferSize,
+ szComment,commentBufferSize);
+}
+
+extern int ZEXPORT unzGetCurrentFileInfo (unzFile file,
+ unz_file_info * pfile_info,
+ char * szFileName, uLong fileNameBufferSize,
+ void *extraField, uLong extraFieldBufferSize,
+ char* szComment, uLong commentBufferSize)
+{
+ int err;
+ unz_file_info64 file_info64;
+ err = unz64local_GetCurrentFileInfoInternal(file,&file_info64,NULL,
+ szFileName,fileNameBufferSize,
+ extraField,extraFieldBufferSize,
+ szComment,commentBufferSize);
+ if ((err==UNZ_OK) && (pfile_info != NULL))
+ {
+ pfile_info->version = file_info64.version;
+ pfile_info->version_needed = file_info64.version_needed;
+ pfile_info->flag = file_info64.flag;
+ pfile_info->compression_method = file_info64.compression_method;
+ pfile_info->dosDate = file_info64.dosDate;
+ pfile_info->crc = file_info64.crc;
+
+ pfile_info->size_filename = file_info64.size_filename;
+ pfile_info->size_file_extra = file_info64.size_file_extra;
+ pfile_info->size_file_comment = file_info64.size_file_comment;
+
+ pfile_info->disk_num_start = file_info64.disk_num_start;
+ pfile_info->internal_fa = file_info64.internal_fa;
+ pfile_info->external_fa = file_info64.external_fa;
+
+ pfile_info->tmu_date = file_info64.tmu_date,
+
+
+ pfile_info->compressed_size = (uLong)file_info64.compressed_size;
+ pfile_info->uncompressed_size = (uLong)file_info64.uncompressed_size;
+
+ }
+ return err;
+}
+/*
+ Set the current file of the zipfile to the first file.
+ return UNZ_OK if there is no problem
+*/
+extern int ZEXPORT unzGoToFirstFile (unzFile file)
+{
+ int err=UNZ_OK;
+ unz64_s* s;
+ if (file==NULL)
+ return UNZ_PARAMERROR;
+ s=(unz64_s*)file;
+ s->pos_in_central_dir=s->offset_central_dir;
+ s->num_file=0;
+ err=unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+ &s->cur_file_info_internal,
+ NULL,0,NULL,0,NULL,0);
+ s->current_file_ok = (err == UNZ_OK);
+ return err;
+}
+
+/*
+ Set the current file of the zipfile to the next file.
+ return UNZ_OK if there is no problem
+ return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
+*/
+extern int ZEXPORT unzGoToNextFile (unzFile file)
+{
+ unz64_s* s;
+ int err;
+
+ if (file==NULL)
+ return UNZ_PARAMERROR;
+ s=(unz64_s*)file;
+ if (!s->current_file_ok)
+ return UNZ_END_OF_LIST_OF_FILE;
+ if (s->gi.number_entry != 0xffff) /* 2^16 files overflow hack */
+ if (s->num_file+1==s->gi.number_entry)
+ return UNZ_END_OF_LIST_OF_FILE;
+
+ s->pos_in_central_dir += SIZECENTRALDIRITEM + s->cur_file_info.size_filename +
+ s->cur_file_info.size_file_extra + s->cur_file_info.size_file_comment ;
+ s->num_file++;
+ err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+ &s->cur_file_info_internal,
+ NULL,0,NULL,0,NULL,0);
+ s->current_file_ok = (err == UNZ_OK);
+ return err;
+}
+
+
+/*
+ Try locate the file szFileName in the zipfile.
+ For the iCaseSensitivity signification, see unzStringFileNameCompare
+
+ return value :
+ UNZ_OK if the file is found. It becomes the current file.
+ UNZ_END_OF_LIST_OF_FILE if the file is not found
+*/
+extern int ZEXPORT unzLocateFile (unzFile file, const char *szFileName, int iCaseSensitivity)
+{
+ unz64_s* s;
+ int err;
+
+ /* We remember the 'current' position in the file so that we can jump
+ * back there if we fail.
+ */
+ unz_file_info64 cur_file_infoSaved;
+ unz_file_info64_internal cur_file_info_internalSaved;
+ ZPOS64_T num_fileSaved;
+ ZPOS64_T pos_in_central_dirSaved;
+
+
+ if (file==NULL)
+ return UNZ_PARAMERROR;
+
+ if (strlen(szFileName)>=UNZ_MAXFILENAMEINZIP)
+ return UNZ_PARAMERROR;
+
+ s=(unz64_s*)file;
+ if (!s->current_file_ok)
+ return UNZ_END_OF_LIST_OF_FILE;
+
+ /* Save the current state */
+ num_fileSaved = s->num_file;
+ pos_in_central_dirSaved = s->pos_in_central_dir;
+ cur_file_infoSaved = s->cur_file_info;
+ cur_file_info_internalSaved = s->cur_file_info_internal;
+
+ err = unzGoToFirstFile(file);
+
+ while (err == UNZ_OK)
+ {
+ char szCurrentFileName[UNZ_MAXFILENAMEINZIP+1];
+ err = unzGetCurrentFileInfo64(file,NULL,
+ szCurrentFileName,sizeof(szCurrentFileName)-1,
+ NULL,0,NULL,0);
+ if (err == UNZ_OK)
+ {
+ if (unzStringFileNameCompare(szCurrentFileName,
+ szFileName,iCaseSensitivity)==0)
+ return UNZ_OK;
+ err = unzGoToNextFile(file);
+ }
+ }
+
+ /* We failed, so restore the state of the 'current file' to where we
+ * were.
+ */
+ s->num_file = num_fileSaved ;
+ s->pos_in_central_dir = pos_in_central_dirSaved ;
+ s->cur_file_info = cur_file_infoSaved;
+ s->cur_file_info_internal = cur_file_info_internalSaved;
+ return err;
+}
+
+
+/*
+///////////////////////////////////////////
+// Contributed by Ryan Haksi (mailto://cryogen@infoserve.net)
+// I need random access
+//
+// Further optimization could be realized by adding an ability
+// to cache the directory in memory. The goal being a single
+// comprehensive file read to put the file I need in a memory.
+*/
+
+/*
+typedef struct unz_file_pos_s
+{
+ ZPOS64_T pos_in_zip_directory; // offset in file
+ ZPOS64_T num_of_file; // # of file
+} unz_file_pos;
+*/
+
+extern int ZEXPORT unzGetFilePos64(unzFile file, unz64_file_pos* file_pos)
+{
+ unz64_s* s;
+
+ if (file==NULL || file_pos==NULL)
+ return UNZ_PARAMERROR;
+ s=(unz64_s*)file;
+ if (!s->current_file_ok)
+ return UNZ_END_OF_LIST_OF_FILE;
+
+ file_pos->pos_in_zip_directory = s->pos_in_central_dir;
+ file_pos->num_of_file = s->num_file;
+
+ return UNZ_OK;
+}
+
+extern int ZEXPORT unzGetFilePos(
+ unzFile file,
+ unz_file_pos* file_pos)
+{
+ unz64_file_pos file_pos64;
+ int err = unzGetFilePos64(file,&file_pos64);
+ if (err==UNZ_OK)
+ {
+ file_pos->pos_in_zip_directory = (uLong)file_pos64.pos_in_zip_directory;
+ file_pos->num_of_file = (uLong)file_pos64.num_of_file;
+ }
+ return err;
+}
+
+extern int ZEXPORT unzGoToFilePos64(unzFile file, const unz64_file_pos* file_pos)
+{
+ unz64_s* s;
+ int err;
+
+ if (file==NULL || file_pos==NULL)
+ return UNZ_PARAMERROR;
+ s=(unz64_s*)file;
+
+ /* jump to the right spot */
+ s->pos_in_central_dir = file_pos->pos_in_zip_directory;
+ s->num_file = file_pos->num_of_file;
+
+ /* set the current file */
+ err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+ &s->cur_file_info_internal,
+ NULL,0,NULL,0,NULL,0);
+ /* return results */
+ s->current_file_ok = (err == UNZ_OK);
+ return err;
+}
+
+extern int ZEXPORT unzGoToFilePos(
+ unzFile file,
+ unz_file_pos* file_pos)
+{
+ unz64_file_pos file_pos64;
+ if (file_pos == NULL)
+ return UNZ_PARAMERROR;
+
+ file_pos64.pos_in_zip_directory = file_pos->pos_in_zip_directory;
+ file_pos64.num_of_file = file_pos->num_of_file;
+ return unzGoToFilePos64(file,&file_pos64);
+}
+
+/*
+// Unzip Helper Functions - should be here?
+///////////////////////////////////////////
+*/
+
+/*
+ Read the local header of the current zipfile
+ Check the coherency of the local header and info in the end of central
+ directory about this file
+ store in *piSizeVar the size of extra info in local header
+ (filename and size of extra field data)
+*/
+local int unz64local_CheckCurrentFileCoherencyHeader (unz64_s* s, uInt* piSizeVar,
+ ZPOS64_T * poffset_local_extrafield,
+ uInt * psize_local_extrafield)
+{
+ uLong uMagic,uData,uFlags;
+ uLong size_filename;
+ uLong size_extra_field;
+ int err=UNZ_OK;
+
+ *piSizeVar = 0;
+ *poffset_local_extrafield = 0;
+ *psize_local_extrafield = 0;
+
+ if (ZSEEK64(s->z_filefunc, s->filestream,s->cur_file_info_internal.offset_curfile +
+ s->byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET)!=0)
+ return UNZ_ERRNO;
+
+
+ if (err==UNZ_OK)
+ {
+ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uMagic) != UNZ_OK)
+ err=UNZ_ERRNO;
+ else if (uMagic!=0x04034b50)
+ err=UNZ_BADZIPFILE;
+ }
+
+ if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
+ err=UNZ_ERRNO;
+/*
+ else if ((err==UNZ_OK) && (uData!=s->cur_file_info.wVersion))
+ err=UNZ_BADZIPFILE;
+*/
+ if (unz64local_getShort(&s->z_filefunc, s->filestream,&uFlags) != UNZ_OK)
+ err=UNZ_ERRNO;
+
+ if (unz64local_getShort(&s->z_filefunc, s->filestream,&uData) != UNZ_OK)
+ err=UNZ_ERRNO;
+ else if ((err==UNZ_OK) && (uData!=s->cur_file_info.compression_method))
+ err=UNZ_BADZIPFILE;
+
+ if ((err==UNZ_OK) && (s->cur_file_info.compression_method!=0) &&
+/* #ifdef HAVE_BZIP2 */
+ (s->cur_file_info.compression_method!=Z_BZIP2ED) &&
+/* #endif */
+ (s->cur_file_info.compression_method!=Z_DEFLATED))
+ err=UNZ_BADZIPFILE;
+
+ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* date/time */
+ err=UNZ_ERRNO;
+
+ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* crc */
+ err=UNZ_ERRNO;
+ else if ((err==UNZ_OK) && (uData!=s->cur_file_info.crc) && ((uFlags & 8)==0))
+ err=UNZ_BADZIPFILE;
+
+ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size compr */
+ err=UNZ_ERRNO;
+ else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.compressed_size) && ((uFlags & 8)==0))
+ err=UNZ_BADZIPFILE;
+
+ if (unz64local_getLong(&s->z_filefunc, s->filestream,&uData) != UNZ_OK) /* size uncompr */
+ err=UNZ_ERRNO;
+ else if (uData != 0xFFFFFFFF && (err==UNZ_OK) && (uData!=s->cur_file_info.uncompressed_size) && ((uFlags & 8)==0))
+ err=UNZ_BADZIPFILE;
+
+ if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_filename) != UNZ_OK)
+ err=UNZ_ERRNO;
+ else if ((err==UNZ_OK) && (size_filename!=s->cur_file_info.size_filename))
+ err=UNZ_BADZIPFILE;
+
+ *piSizeVar += (uInt)size_filename;
+
+ if (unz64local_getShort(&s->z_filefunc, s->filestream,&size_extra_field) != UNZ_OK)
+ err=UNZ_ERRNO;
+ *poffset_local_extrafield= s->cur_file_info_internal.offset_curfile +
+ SIZEZIPLOCALHEADER + size_filename;
+ *psize_local_extrafield = (uInt)size_extra_field;
+
+ *piSizeVar += (uInt)size_extra_field;
+
+ return err;
+}
+
+/*
+ Open for reading data the current file in the zipfile.
+ If there is no error and the file is opened, the return value is UNZ_OK.
+*/
+extern int ZEXPORT unzOpenCurrentFile3 (unzFile file, int* method,
+ int* level, int raw, const char* password)
+{
+ int err=UNZ_OK;
+ uInt iSizeVar;
+ unz64_s* s;
+ file_in_zip64_read_info_s* pfile_in_zip_read_info;
+ ZPOS64_T offset_local_extrafield; /* offset of the local extra field */
+ uInt size_local_extrafield; /* size of the local extra field */
+# ifndef NOUNCRYPT
+ char source[12];
+# else
+ if (password != NULL)
+ return UNZ_PARAMERROR;
+# endif
+
+ if (file==NULL)
+ return UNZ_PARAMERROR;
+ s=(unz64_s*)file;
+ if (!s->current_file_ok)
+ return UNZ_PARAMERROR;
+
+ if (s->pfile_in_zip_read != NULL)
+ unzCloseCurrentFile(file);
+
+ if (unz64local_CheckCurrentFileCoherencyHeader(s,&iSizeVar, &offset_local_extrafield,&size_local_extrafield)!=UNZ_OK)
+ return UNZ_BADZIPFILE;
+
+ pfile_in_zip_read_info = (file_in_zip64_read_info_s*)ALLOC(sizeof(file_in_zip64_read_info_s));
+ if (pfile_in_zip_read_info==NULL)
+ return UNZ_INTERNALERROR;
+
+ pfile_in_zip_read_info->read_buffer=(char*)ALLOC(UNZ_BUFSIZE);
+ pfile_in_zip_read_info->offset_local_extrafield = offset_local_extrafield;
+ pfile_in_zip_read_info->size_local_extrafield = size_local_extrafield;
+ pfile_in_zip_read_info->pos_local_extrafield=0;
+ pfile_in_zip_read_info->raw=raw;
+
+ if (pfile_in_zip_read_info->read_buffer==NULL)
+ {
+ TRYFREE(pfile_in_zip_read_info);
+ return UNZ_INTERNALERROR;
+ }
+
+ pfile_in_zip_read_info->stream_initialised=0;
+
+ if (method!=NULL)
+ *method = (int)s->cur_file_info.compression_method;
+
+ if (level!=NULL)
+ {
+ *level = 6;
+ switch (s->cur_file_info.flag & 0x06)
+ {
+ case 6 : *level = 1; break;
+ case 4 : *level = 2; break;
+ case 2 : *level = 9; break;
+ }
+ }
+
+ if ((s->cur_file_info.compression_method!=0) &&
+/* #ifdef HAVE_BZIP2 */
+ (s->cur_file_info.compression_method!=Z_BZIP2ED) &&
+/* #endif */
+ (s->cur_file_info.compression_method!=Z_DEFLATED))
+
+ err=UNZ_BADZIPFILE;
+
+ pfile_in_zip_read_info->crc32_wait=s->cur_file_info.crc;
+ pfile_in_zip_read_info->crc32=0;
+ pfile_in_zip_read_info->total_out_64=0;
+ pfile_in_zip_read_info->compression_method = s->cur_file_info.compression_method;
+ pfile_in_zip_read_info->filestream=s->filestream;
+ pfile_in_zip_read_info->z_filefunc=s->z_filefunc;
+ pfile_in_zip_read_info->byte_before_the_zipfile=s->byte_before_the_zipfile;
+
+ pfile_in_zip_read_info->stream.total_out = 0;
+
+ if ((s->cur_file_info.compression_method==Z_BZIP2ED) && (!raw))
+ {
+#ifdef HAVE_BZIP2
+ pfile_in_zip_read_info->bstream.bzalloc = (void *(*) (void *, int, int))0;
+ pfile_in_zip_read_info->bstream.bzfree = (free_func)0;
+ pfile_in_zip_read_info->bstream.opaque = (voidpf)0;
+ pfile_in_zip_read_info->bstream.state = (voidpf)0;
+
+ pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
+ pfile_in_zip_read_info->stream.zfree = (free_func)0;
+ pfile_in_zip_read_info->stream.opaque = (voidpf)0;
+ pfile_in_zip_read_info->stream.next_in = (voidpf)0;
+ pfile_in_zip_read_info->stream.avail_in = 0;
+
+ err=BZ2_bzDecompressInit(&pfile_in_zip_read_info->bstream, 0, 0);
+ if (err == Z_OK)
+ pfile_in_zip_read_info->stream_initialised=Z_BZIP2ED;
+ else
+ {
+ TRYFREE(pfile_in_zip_read_info);
+ return err;
+ }
+#else
+ pfile_in_zip_read_info->raw=1;
+#endif
+ }
+ else if ((s->cur_file_info.compression_method==Z_DEFLATED) && (!raw))
+ {
+ pfile_in_zip_read_info->stream.zalloc = (alloc_func)0;
+ pfile_in_zip_read_info->stream.zfree = (free_func)0;
+ pfile_in_zip_read_info->stream.opaque = (voidpf)0;
+ pfile_in_zip_read_info->stream.next_in = 0;
+ pfile_in_zip_read_info->stream.avail_in = 0;
+
+ err=inflateInit2(&pfile_in_zip_read_info->stream, -MAX_WBITS);
+ if (err == Z_OK)
+ pfile_in_zip_read_info->stream_initialised=Z_DEFLATED;
+ else
+ {
+ TRYFREE(pfile_in_zip_read_info);
+ return err;
+ }
+ /* windowBits is passed < 0 to tell that there is no zlib header.
+ * Note that in this case inflate *requires* an extra "dummy" byte
+ * after the compressed stream in order to complete decompression and
+ * return Z_STREAM_END.
+ * In unzip, i don't wait absolutely Z_STREAM_END because I known the
+ * size of both compressed and uncompressed data
+ */
+ }
+ pfile_in_zip_read_info->rest_read_compressed =
+ s->cur_file_info.compressed_size ;
+ pfile_in_zip_read_info->rest_read_uncompressed =
+ s->cur_file_info.uncompressed_size ;
+
+
+ pfile_in_zip_read_info->pos_in_zipfile =
+ s->cur_file_info_internal.offset_curfile + SIZEZIPLOCALHEADER +
+ iSizeVar;
+
+ pfile_in_zip_read_info->stream.avail_in = (uInt)0;
+
+ s->pfile_in_zip_read = pfile_in_zip_read_info;
+ s->encrypted = 0;
+
+# ifndef NOUNCRYPT
+ if (password != NULL)
+ {
+ int i;
+ s->pcrc_32_tab = get_crc_table();
+ init_keys(password,s->keys,s->pcrc_32_tab);
+ if (ZSEEK64(s->z_filefunc, s->filestream,
+ s->pfile_in_zip_read->pos_in_zipfile +
+ s->pfile_in_zip_read->byte_before_the_zipfile,
+ SEEK_SET)!=0)
+ return UNZ_INTERNALERROR;
+ if(ZREAD64(s->z_filefunc, s->filestream,source, 12)<12)
+ return UNZ_INTERNALERROR;
+
+ for (i = 0; i<12; i++)
+ zdecode(s->keys,s->pcrc_32_tab,source[i]);
+
+ s->pfile_in_zip_read->pos_in_zipfile+=12;
+ s->encrypted=1;
+ }
+# endif
+
+
+ return UNZ_OK;
+}
+
+extern int ZEXPORT unzOpenCurrentFile (unzFile file)
+{
+ return unzOpenCurrentFile3(file, NULL, NULL, 0, NULL);
+}
+
+extern int ZEXPORT unzOpenCurrentFilePassword (unzFile file, const char* password)
+{
+ return unzOpenCurrentFile3(file, NULL, NULL, 0, password);
+}
+
+extern int ZEXPORT unzOpenCurrentFile2 (unzFile file, int* method, int* level, int raw)
+{
+ return unzOpenCurrentFile3(file, method, level, raw, NULL);
+}
+
+/** Addition for GDAL : START */
+
+extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64( unzFile file)
+{
+ unz64_s* s;
+ file_in_zip64_read_info_s* pfile_in_zip_read_info;
+ s=(unz64_s*)file;
+ if (file==NULL)
+ return 0; //UNZ_PARAMERROR;
+ pfile_in_zip_read_info=s->pfile_in_zip_read;
+ if (pfile_in_zip_read_info==NULL)
+ return 0; //UNZ_PARAMERROR;
+ return pfile_in_zip_read_info->pos_in_zipfile +
+ pfile_in_zip_read_info->byte_before_the_zipfile;
+}
+
+/** Addition for GDAL : END */
+
+/*
+ Read bytes from the current file.
+ buf contain buffer where data must be copied
+ len the size of buf.
+
+ return the number of byte copied if somes bytes are copied
+ return 0 if the end of file was reached
+ return <0 with error code if there is an error
+ (UNZ_ERRNO for IO error, or zLib error for uncompress error)
+*/
+extern int ZEXPORT unzReadCurrentFile (unzFile file, voidp buf, unsigned len)
+{
+ int err=UNZ_OK;
+ uInt iRead = 0;
+ unz64_s* s;
+ file_in_zip64_read_info_s* pfile_in_zip_read_info;
+ if (file==NULL)
+ return UNZ_PARAMERROR;
+ s=(unz64_s*)file;
+ pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+ if (pfile_in_zip_read_info==NULL)
+ return UNZ_PARAMERROR;
+
+
+ if (pfile_in_zip_read_info->read_buffer == NULL)
+ return UNZ_END_OF_LIST_OF_FILE;
+ if (len==0)
+ return 0;
+
+ pfile_in_zip_read_info->stream.next_out = (Bytef*)buf;
+
+ pfile_in_zip_read_info->stream.avail_out = (uInt)len;
+
+ if ((len>pfile_in_zip_read_info->rest_read_uncompressed) &&
+ (!(pfile_in_zip_read_info->raw)))
+ pfile_in_zip_read_info->stream.avail_out =
+ (uInt)pfile_in_zip_read_info->rest_read_uncompressed;
+
+ if ((len>pfile_in_zip_read_info->rest_read_compressed+
+ pfile_in_zip_read_info->stream.avail_in) &&
+ (pfile_in_zip_read_info->raw))
+ pfile_in_zip_read_info->stream.avail_out =
+ (uInt)pfile_in_zip_read_info->rest_read_compressed+
+ pfile_in_zip_read_info->stream.avail_in;
+
+ while (pfile_in_zip_read_info->stream.avail_out>0)
+ {
+ if ((pfile_in_zip_read_info->stream.avail_in==0) &&
+ (pfile_in_zip_read_info->rest_read_compressed>0))
+ {
+ uInt uReadThis = UNZ_BUFSIZE;
+ if (pfile_in_zip_read_info->rest_read_compressed<uReadThis)
+ uReadThis = (uInt)pfile_in_zip_read_info->rest_read_compressed;
+ if (uReadThis == 0)
+ return UNZ_EOF;
+ if (ZSEEK64(pfile_in_zip_read_info->z_filefunc,
+ pfile_in_zip_read_info->filestream,
+ pfile_in_zip_read_info->pos_in_zipfile +
+ pfile_in_zip_read_info->byte_before_the_zipfile,
+ ZLIB_FILEFUNC_SEEK_SET)!=0)
+ return UNZ_ERRNO;
+ if (ZREAD64(pfile_in_zip_read_info->z_filefunc,
+ pfile_in_zip_read_info->filestream,
+ pfile_in_zip_read_info->read_buffer,
+ uReadThis)!=uReadThis)
+ return UNZ_ERRNO;
+
+
+# ifndef NOUNCRYPT
+ if(s->encrypted)
+ {
+ uInt i;
+ for(i=0;i<uReadThis;i++)
+ pfile_in_zip_read_info->read_buffer[i] =
+ zdecode(s->keys,s->pcrc_32_tab,
+ pfile_in_zip_read_info->read_buffer[i]);
+ }
+# endif
+
+
+ pfile_in_zip_read_info->pos_in_zipfile += uReadThis;
+
+ pfile_in_zip_read_info->rest_read_compressed-=uReadThis;
+
+ pfile_in_zip_read_info->stream.next_in =
+ (Bytef*)pfile_in_zip_read_info->read_buffer;
+ pfile_in_zip_read_info->stream.avail_in = (uInt)uReadThis;
+ }
+
+ if ((pfile_in_zip_read_info->compression_method==0) || (pfile_in_zip_read_info->raw))
+ {
+ uInt uDoCopy,i ;
+
+ if ((pfile_in_zip_read_info->stream.avail_in == 0) &&
+ (pfile_in_zip_read_info->rest_read_compressed == 0))
+ return (iRead==0) ? UNZ_EOF : iRead;
+
+ if (pfile_in_zip_read_info->stream.avail_out <
+ pfile_in_zip_read_info->stream.avail_in)
+ uDoCopy = pfile_in_zip_read_info->stream.avail_out ;
+ else
+ uDoCopy = pfile_in_zip_read_info->stream.avail_in ;
+
+ for (i=0;i<uDoCopy;i++)
+ *(pfile_in_zip_read_info->stream.next_out+i) =
+ *(pfile_in_zip_read_info->stream.next_in+i);
+
+ pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uDoCopy;
+
+ pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,
+ pfile_in_zip_read_info->stream.next_out,
+ uDoCopy);
+ pfile_in_zip_read_info->rest_read_uncompressed-=uDoCopy;
+ pfile_in_zip_read_info->stream.avail_in -= uDoCopy;
+ pfile_in_zip_read_info->stream.avail_out -= uDoCopy;
+ pfile_in_zip_read_info->stream.next_out += uDoCopy;
+ pfile_in_zip_read_info->stream.next_in += uDoCopy;
+ pfile_in_zip_read_info->stream.total_out += uDoCopy;
+ iRead += uDoCopy;
+ }
+ else if (pfile_in_zip_read_info->compression_method==Z_BZIP2ED)
+ {
+#ifdef HAVE_BZIP2
+ uLong uTotalOutBefore,uTotalOutAfter;
+ const Bytef *bufBefore;
+ uLong uOutThis;
+
+ pfile_in_zip_read_info->bstream.next_in = (char*)pfile_in_zip_read_info->stream.next_in;
+ pfile_in_zip_read_info->bstream.avail_in = pfile_in_zip_read_info->stream.avail_in;
+ pfile_in_zip_read_info->bstream.total_in_lo32 = pfile_in_zip_read_info->stream.total_in;
+ pfile_in_zip_read_info->bstream.total_in_hi32 = 0;
+ pfile_in_zip_read_info->bstream.next_out = (char*)pfile_in_zip_read_info->stream.next_out;
+ pfile_in_zip_read_info->bstream.avail_out = pfile_in_zip_read_info->stream.avail_out;
+ pfile_in_zip_read_info->bstream.total_out_lo32 = pfile_in_zip_read_info->stream.total_out;
+ pfile_in_zip_read_info->bstream.total_out_hi32 = 0;
+
+ uTotalOutBefore = pfile_in_zip_read_info->bstream.total_out_lo32;
+ bufBefore = (const Bytef *)pfile_in_zip_read_info->bstream.next_out;
+
+ err=BZ2_bzDecompress(&pfile_in_zip_read_info->bstream);
+
+ uTotalOutAfter = pfile_in_zip_read_info->bstream.total_out_lo32;
+ uOutThis = uTotalOutAfter-uTotalOutBefore;
+
+ pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis;
+
+ pfile_in_zip_read_info->crc32 = crc32(pfile_in_zip_read_info->crc32,bufBefore, (uInt)(uOutThis));
+ pfile_in_zip_read_info->rest_read_uncompressed -= uOutThis;
+ iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
+
+ pfile_in_zip_read_info->stream.next_in = (Bytef*)pfile_in_zip_read_info->bstream.next_in;
+ pfile_in_zip_read_info->stream.avail_in = pfile_in_zip_read_info->bstream.avail_in;
+ pfile_in_zip_read_info->stream.total_in = pfile_in_zip_read_info->bstream.total_in_lo32;
+ pfile_in_zip_read_info->stream.next_out = (Bytef*)pfile_in_zip_read_info->bstream.next_out;
+ pfile_in_zip_read_info->stream.avail_out = pfile_in_zip_read_info->bstream.avail_out;
+ pfile_in_zip_read_info->stream.total_out = pfile_in_zip_read_info->bstream.total_out_lo32;
+
+ if (err==BZ_STREAM_END)
+ return (iRead==0) ? UNZ_EOF : iRead;
+ if (err!=BZ_OK)
+ break;
+#endif
+ } // end Z_BZIP2ED
+ else
+ {
+ ZPOS64_T uTotalOutBefore,uTotalOutAfter;
+ const Bytef *bufBefore;
+ ZPOS64_T uOutThis;
+ int flush=Z_SYNC_FLUSH;
+
+ uTotalOutBefore = pfile_in_zip_read_info->stream.total_out;
+ bufBefore = pfile_in_zip_read_info->stream.next_out;
+
+ /*
+ if ((pfile_in_zip_read_info->rest_read_uncompressed ==
+ pfile_in_zip_read_info->stream.avail_out) &&
+ (pfile_in_zip_read_info->rest_read_compressed == 0))
+ flush = Z_FINISH;
+ */
+ err=inflate(&pfile_in_zip_read_info->stream,flush);
+
+ if ((err>=0) && (pfile_in_zip_read_info->stream.msg!=NULL))
+ err = Z_DATA_ERROR;
+
+ uTotalOutAfter = pfile_in_zip_read_info->stream.total_out;
+ uOutThis = uTotalOutAfter-uTotalOutBefore;
+
+ pfile_in_zip_read_info->total_out_64 = pfile_in_zip_read_info->total_out_64 + uOutThis;
+
+ pfile_in_zip_read_info->crc32 =
+ crc32(pfile_in_zip_read_info->crc32,bufBefore,
+ (uInt)(uOutThis));
+
+ pfile_in_zip_read_info->rest_read_uncompressed -=
+ uOutThis;
+
+ iRead += (uInt)(uTotalOutAfter - uTotalOutBefore);
+
+ if (err==Z_STREAM_END)
+ return (iRead==0) ? UNZ_EOF : iRead;
+ if (err!=Z_OK)
+ break;
+ }
+ }
+
+ if (err==Z_OK)
+ return iRead;
+ return err;
+}
+
+
+/*
+ Give the current position in uncompressed data
+*/
+extern z_off_t ZEXPORT unztell (unzFile file)
+{
+ unz64_s* s;
+ file_in_zip64_read_info_s* pfile_in_zip_read_info;
+ if (file==NULL)
+ return UNZ_PARAMERROR;
+ s=(unz64_s*)file;
+ pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+ if (pfile_in_zip_read_info==NULL)
+ return UNZ_PARAMERROR;
+
+ return (z_off_t)pfile_in_zip_read_info->stream.total_out;
+}
+
+extern ZPOS64_T ZEXPORT unztell64 (unzFile file)
+{
+
+ unz64_s* s;
+ file_in_zip64_read_info_s* pfile_in_zip_read_info;
+ if (file==NULL)
+ return (ZPOS64_T)-1;
+ s=(unz64_s*)file;
+ pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+ if (pfile_in_zip_read_info==NULL)
+ return (ZPOS64_T)-1;
+
+ return pfile_in_zip_read_info->total_out_64;
+}
+
+
+/*
+ return 1 if the end of file was reached, 0 elsewhere
+*/
+extern int ZEXPORT unzeof (unzFile file)
+{
+ unz64_s* s;
+ file_in_zip64_read_info_s* pfile_in_zip_read_info;
+ if (file==NULL)
+ return UNZ_PARAMERROR;
+ s=(unz64_s*)file;
+ pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+ if (pfile_in_zip_read_info==NULL)
+ return UNZ_PARAMERROR;
+
+ if (pfile_in_zip_read_info->rest_read_uncompressed == 0)
+ return 1;
+ else
+ return 0;
+}
+
+
+
+/*
+Read extra field from the current file (opened by unzOpenCurrentFile)
+This is the local-header version of the extra field (sometimes, there is
+more info in the local-header version than in the central-header)
+
+ if buf==NULL, it return the size of the local extra field that can be read
+
+ if buf!=NULL, len is the size of the buffer, the extra header is copied in
+ buf.
+ the return value is the number of bytes copied in buf, or (if <0)
+ the error code
+*/
+extern int ZEXPORT unzGetLocalExtrafield (unzFile file, voidp buf, unsigned len)
+{
+ unz64_s* s;
+ file_in_zip64_read_info_s* pfile_in_zip_read_info;
+ uInt read_now;
+ ZPOS64_T size_to_read;
+
+ if (file==NULL)
+ return UNZ_PARAMERROR;
+ s=(unz64_s*)file;
+ pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+ if (pfile_in_zip_read_info==NULL)
+ return UNZ_PARAMERROR;
+
+ size_to_read = (pfile_in_zip_read_info->size_local_extrafield -
+ pfile_in_zip_read_info->pos_local_extrafield);
+
+ if (buf==NULL)
+ return (int)size_to_read;
+
+ if (len>size_to_read)
+ read_now = (uInt)size_to_read;
+ else
+ read_now = (uInt)len ;
+
+ if (read_now==0)
+ return 0;
+
+ if (ZSEEK64(pfile_in_zip_read_info->z_filefunc,
+ pfile_in_zip_read_info->filestream,
+ pfile_in_zip_read_info->offset_local_extrafield +
+ pfile_in_zip_read_info->pos_local_extrafield,
+ ZLIB_FILEFUNC_SEEK_SET)!=0)
+ return UNZ_ERRNO;
+
+ if (ZREAD64(pfile_in_zip_read_info->z_filefunc,
+ pfile_in_zip_read_info->filestream,
+ buf,read_now)!=read_now)
+ return UNZ_ERRNO;
+
+ return (int)read_now;
+}
+
+/*
+ Close the file in zip opened with unzOpenCurrentFile
+ Return UNZ_CRCERROR if all the file was read but the CRC is not good
+*/
+extern int ZEXPORT unzCloseCurrentFile (unzFile file)
+{
+ int err=UNZ_OK;
+
+ unz64_s* s;
+ file_in_zip64_read_info_s* pfile_in_zip_read_info;
+ if (file==NULL)
+ return UNZ_PARAMERROR;
+ s=(unz64_s*)file;
+ pfile_in_zip_read_info=s->pfile_in_zip_read;
+
+ if (pfile_in_zip_read_info==NULL)
+ return UNZ_PARAMERROR;
+
+
+ if ((pfile_in_zip_read_info->rest_read_uncompressed == 0) &&
+ (!pfile_in_zip_read_info->raw))
+ {
+ if (pfile_in_zip_read_info->crc32 != pfile_in_zip_read_info->crc32_wait)
+ err=UNZ_CRCERROR;
+ }
+
+
+ TRYFREE(pfile_in_zip_read_info->read_buffer);
+ pfile_in_zip_read_info->read_buffer = NULL;
+ if (pfile_in_zip_read_info->stream_initialised == Z_DEFLATED)
+ inflateEnd(&pfile_in_zip_read_info->stream);
+#ifdef HAVE_BZIP2
+ else if (pfile_in_zip_read_info->stream_initialised == Z_BZIP2ED)
+ BZ2_bzDecompressEnd(&pfile_in_zip_read_info->bstream);
+#endif
+
+
+ pfile_in_zip_read_info->stream_initialised = 0;
+ TRYFREE(pfile_in_zip_read_info);
+
+ s->pfile_in_zip_read=NULL;
+
+ return err;
+}
+
+
+/*
+ Get the global comment string of the ZipFile, in the szComment buffer.
+ uSizeBuf is the size of the szComment buffer.
+ return the number of byte copied or an error code <0
+*/
+extern int ZEXPORT unzGetGlobalComment (unzFile file, char * szComment, uLong uSizeBuf)
+{
+ unz64_s* s;
+ uLong uReadThis ;
+ if (file==NULL)
+ return (int)UNZ_PARAMERROR;
+ s=(unz64_s*)file;
+
+ uReadThis = uSizeBuf;
+ if (uReadThis>s->gi.size_comment)
+ uReadThis = s->gi.size_comment;
+
+ if (ZSEEK64(s->z_filefunc,s->filestream,s->central_pos+22,ZLIB_FILEFUNC_SEEK_SET)!=0)
+ return UNZ_ERRNO;
+
+ if (uReadThis>0)
+ {
+ *szComment='\0';
+ if (ZREAD64(s->z_filefunc,s->filestream,szComment,uReadThis)!=uReadThis)
+ return UNZ_ERRNO;
+ }
+
+ if ((szComment != NULL) && (uSizeBuf > s->gi.size_comment))
+ *(szComment+s->gi.size_comment)='\0';
+ return (int)uReadThis;
+}
+
+/* Additions by RX '2004 */
+extern ZPOS64_T ZEXPORT unzGetOffset64(unzFile file)
+{
+ unz64_s* s;
+
+ if (file==NULL)
+ return 0; //UNZ_PARAMERROR;
+ s=(unz64_s*)file;
+ if (!s->current_file_ok)
+ return 0;
+ if (s->gi.number_entry != 0 && s->gi.number_entry != 0xffff)
+ if (s->num_file==s->gi.number_entry)
+ return 0;
+ return s->pos_in_central_dir;
+}
+
+extern uLong ZEXPORT unzGetOffset (unzFile file)
+{
+ ZPOS64_T offset64;
+
+ if (file==NULL)
+ return 0; //UNZ_PARAMERROR;
+ offset64 = unzGetOffset64(file);
+ return (uLong)offset64;
+}
+
+extern int ZEXPORT unzSetOffset64(unzFile file, ZPOS64_T pos)
+{
+ unz64_s* s;
+ int err;
+
+ if (file==NULL)
+ return UNZ_PARAMERROR;
+ s=(unz64_s*)file;
+
+ s->pos_in_central_dir = pos;
+ s->num_file = s->gi.number_entry; /* hack */
+ err = unz64local_GetCurrentFileInfoInternal(file,&s->cur_file_info,
+ &s->cur_file_info_internal,
+ NULL,0,NULL,0,NULL,0);
+ s->current_file_ok = (err == UNZ_OK);
+ return err;
+}
+
+extern int ZEXPORT unzSetOffset (unzFile file, uLong pos)
+{
+ return unzSetOffset64(file,pos);
+}
diff --git a/zlib/contrib/minizip/unzip.h b/zlib/contrib/minizip/unzip.h
new file mode 100644
index 000000000..2104e3915
--- /dev/null
+++ b/zlib/contrib/minizip/unzip.h
@@ -0,0 +1,437 @@
+/* unzip.h -- IO for uncompress .zip files using zlib
+ Version 1.1, February 14h, 2010
+ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Modifications of Unzip for Zip64
+ Copyright (C) 2007-2008 Even Rouault
+
+ Modifications for Zip64 support on both zip and unzip
+ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+ For more info read MiniZip_info.txt
+
+ ---------------------------------------------------------------------------------
+
+ Condition of use and distribution are the same than zlib :
+
+ 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.
+
+ ---------------------------------------------------------------------------------
+
+ Changes
+
+ See header of unzip64.c
+
+*/
+
+#ifndef _unz64_H
+#define _unz64_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef _ZLIB_H
+#include "zlib.h"
+#endif
+
+#ifndef _ZLIBIOAPI_H
+#include "ioapi.h"
+#endif
+
+#ifdef HAVE_BZIP2
+#include "bzlib.h"
+#endif
+
+#define Z_BZIP2ED 12
+
+#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
+/* like the STRICT of WIN32, we define a pointer that cannot be converted
+ from (void*) without cast */
+typedef struct TagunzFile__ { int unused; } unzFile__;
+typedef unzFile__ *unzFile;
+#else
+typedef voidp unzFile;
+#endif
+
+
+#define UNZ_OK (0)
+#define UNZ_END_OF_LIST_OF_FILE (-100)
+#define UNZ_ERRNO (Z_ERRNO)
+#define UNZ_EOF (0)
+#define UNZ_PARAMERROR (-102)
+#define UNZ_BADZIPFILE (-103)
+#define UNZ_INTERNALERROR (-104)
+#define UNZ_CRCERROR (-105)
+
+/* tm_unz contain date/time info */
+typedef struct tm_unz_s
+{
+ uInt tm_sec; /* seconds after the minute - [0,59] */
+ uInt tm_min; /* minutes after the hour - [0,59] */
+ uInt tm_hour; /* hours since midnight - [0,23] */
+ uInt tm_mday; /* day of the month - [1,31] */
+ uInt tm_mon; /* months since January - [0,11] */
+ uInt tm_year; /* years - [1980..2044] */
+} tm_unz;
+
+/* unz_global_info structure contain global data about the ZIPfile
+ These data comes from the end of central dir */
+typedef struct unz_global_info64_s
+{
+ ZPOS64_T number_entry; /* total number of entries in
+ the central dir on this disk */
+ uLong size_comment; /* size of the global comment of the zipfile */
+} unz_global_info64;
+
+typedef struct unz_global_info_s
+{
+ uLong number_entry; /* total number of entries in
+ the central dir on this disk */
+ uLong size_comment; /* size of the global comment of the zipfile */
+} unz_global_info;
+
+/* unz_file_info contain information about a file in the zipfile */
+typedef struct unz_file_info64_s
+{
+ uLong version; /* version made by 2 bytes */
+ uLong version_needed; /* version needed to extract 2 bytes */
+ uLong flag; /* general purpose bit flag 2 bytes */
+ uLong compression_method; /* compression method 2 bytes */
+ uLong dosDate; /* last mod file date in Dos fmt 4 bytes */
+ uLong crc; /* crc-32 4 bytes */
+ ZPOS64_T compressed_size; /* compressed size 8 bytes */
+ ZPOS64_T uncompressed_size; /* uncompressed size 8 bytes */
+ uLong size_filename; /* filename length 2 bytes */
+ uLong size_file_extra; /* extra field length 2 bytes */
+ uLong size_file_comment; /* file comment length 2 bytes */
+
+ uLong disk_num_start; /* disk number start 2 bytes */
+ uLong internal_fa; /* internal file attributes 2 bytes */
+ uLong external_fa; /* external file attributes 4 bytes */
+
+ tm_unz tmu_date;
+} unz_file_info64;
+
+typedef struct unz_file_info_s
+{
+ uLong version; /* version made by 2 bytes */
+ uLong version_needed; /* version needed to extract 2 bytes */
+ uLong flag; /* general purpose bit flag 2 bytes */
+ uLong compression_method; /* compression method 2 bytes */
+ uLong dosDate; /* last mod file date in Dos fmt 4 bytes */
+ uLong crc; /* crc-32 4 bytes */
+ uLong compressed_size; /* compressed size 4 bytes */
+ uLong uncompressed_size; /* uncompressed size 4 bytes */
+ uLong size_filename; /* filename length 2 bytes */
+ uLong size_file_extra; /* extra field length 2 bytes */
+ uLong size_file_comment; /* file comment length 2 bytes */
+
+ uLong disk_num_start; /* disk number start 2 bytes */
+ uLong internal_fa; /* internal file attributes 2 bytes */
+ uLong external_fa; /* external file attributes 4 bytes */
+
+ tm_unz tmu_date;
+} unz_file_info;
+
+extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
+ const char* fileName2,
+ int iCaseSensitivity));
+/*
+ Compare two filename (fileName1,fileName2).
+ If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
+ If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
+ or strcasecmp)
+ If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
+ (like 1 on Unix, 2 on Windows)
+*/
+
+
+extern unzFile ZEXPORT unzOpen OF((const char *path));
+extern unzFile ZEXPORT unzOpen64 OF((const void *path));
+/*
+ Open a Zip file. path contain the full pathname (by example,
+ on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer
+ "zlib/zlib113.zip".
+ If the zipfile cannot be opened (file don't exist or in not valid), the
+ return value is NULL.
+ Else, the return value is a unzFile Handle, usable with other function
+ of this unzip package.
+ the "64" function take a const void* pointer, because the path is just the
+ value passed to the open64_file_func callback.
+ Under Windows, if UNICODE is defined, using fill_fopen64_filefunc, the path
+ is a pointer to a wide unicode string (LPCTSTR is LPCWSTR), so const char*
+ does not describe the reality
+*/
+
+
+extern unzFile ZEXPORT unzOpen2 OF((const char *path,
+ zlib_filefunc_def* pzlib_filefunc_def));
+/*
+ Open a Zip file, like unzOpen, but provide a set of file low level API
+ for read/write the zip file (see ioapi.h)
+*/
+
+extern unzFile ZEXPORT unzOpen2_64 OF((const void *path,
+ zlib_filefunc64_def* pzlib_filefunc_def));
+/*
+ Open a Zip file, like unz64Open, but provide a set of file low level API
+ for read/write the zip file (see ioapi.h)
+*/
+
+extern int ZEXPORT unzClose OF((unzFile file));
+/*
+ Close a ZipFile opened with unzOpen.
+ If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
+ these files MUST be closed with unzCloseCurrentFile before call unzClose.
+ return UNZ_OK if there is no problem. */
+
+extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
+ unz_global_info *pglobal_info));
+
+extern int ZEXPORT unzGetGlobalInfo64 OF((unzFile file,
+ unz_global_info64 *pglobal_info));
+/*
+ Write info about the ZipFile in the *pglobal_info structure.
+ No preparation of the structure is needed
+ return UNZ_OK if there is no problem. */
+
+
+extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
+ char *szComment,
+ uLong uSizeBuf));
+/*
+ Get the global comment string of the ZipFile, in the szComment buffer.
+ uSizeBuf is the size of the szComment buffer.
+ return the number of byte copied or an error code <0
+*/
+
+
+/***************************************************************************/
+/* Unzip package allow you browse the directory of the zipfile */
+
+extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
+/*
+ Set the current file of the zipfile to the first file.
+ return UNZ_OK if there is no problem
+*/
+
+extern int ZEXPORT unzGoToNextFile OF((unzFile file));
+/*
+ Set the current file of the zipfile to the next file.
+ return UNZ_OK if there is no problem
+ return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
+*/
+
+extern int ZEXPORT unzLocateFile OF((unzFile file,
+ const char *szFileName,
+ int iCaseSensitivity));
+/*
+ Try locate the file szFileName in the zipfile.
+ For the iCaseSensitivity signification, see unzStringFileNameCompare
+
+ return value :
+ UNZ_OK if the file is found. It becomes the current file.
+ UNZ_END_OF_LIST_OF_FILE if the file is not found
+*/
+
+
+/* ****************************************** */
+/* Ryan supplied functions */
+/* unz_file_info contain information about a file in the zipfile */
+typedef struct unz_file_pos_s
+{
+ uLong pos_in_zip_directory; /* offset in zip file directory */
+ uLong num_of_file; /* # of file */
+} unz_file_pos;
+
+extern int ZEXPORT unzGetFilePos(
+ unzFile file,
+ unz_file_pos* file_pos);
+
+extern int ZEXPORT unzGoToFilePos(
+ unzFile file,
+ unz_file_pos* file_pos);
+
+typedef struct unz64_file_pos_s
+{
+ ZPOS64_T pos_in_zip_directory; /* offset in zip file directory */
+ ZPOS64_T num_of_file; /* # of file */
+} unz64_file_pos;
+
+extern int ZEXPORT unzGetFilePos64(
+ unzFile file,
+ unz64_file_pos* file_pos);
+
+extern int ZEXPORT unzGoToFilePos64(
+ unzFile file,
+ const unz64_file_pos* file_pos);
+
+/* ****************************************** */
+
+extern int ZEXPORT unzGetCurrentFileInfo64 OF((unzFile file,
+ unz_file_info64 *pfile_info,
+ char *szFileName,
+ uLong fileNameBufferSize,
+ void *extraField,
+ uLong extraFieldBufferSize,
+ char *szComment,
+ uLong commentBufferSize));
+
+extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
+ unz_file_info *pfile_info,
+ char *szFileName,
+ uLong fileNameBufferSize,
+ void *extraField,
+ uLong extraFieldBufferSize,
+ char *szComment,
+ uLong commentBufferSize));
+/*
+ Get Info about the current file
+ if pfile_info!=NULL, the *pfile_info structure will contain somes info about
+ the current file
+ if szFileName!=NULL, the filemane string will be copied in szFileName
+ (fileNameBufferSize is the size of the buffer)
+ if extraField!=NULL, the extra field information will be copied in extraField
+ (extraFieldBufferSize is the size of the buffer).
+ This is the Central-header version of the extra field
+ if szComment!=NULL, the comment string of the file will be copied in szComment
+ (commentBufferSize is the size of the buffer)
+*/
+
+
+/** Addition for GDAL : START */
+
+extern ZPOS64_T ZEXPORT unzGetCurrentFileZStreamPos64 OF((unzFile file));
+
+/** Addition for GDAL : END */
+
+
+/***************************************************************************/
+/* for reading the content of the current zipfile, you can open it, read data
+ from it, and close it (you can close it before reading all the file)
+ */
+
+extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
+/*
+ Open for reading data the current file in the zipfile.
+ If there is no error, the return value is UNZ_OK.
+*/
+
+extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
+ const char* password));
+/*
+ Open for reading data the current file in the zipfile.
+ password is a crypting password
+ If there is no error, the return value is UNZ_OK.
+*/
+
+extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
+ int* method,
+ int* level,
+ int raw));
+/*
+ Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
+ if raw==1
+ *method will receive method of compression, *level will receive level of
+ compression
+ note : you can set level parameter as NULL (if you did not want known level,
+ but you CANNOT set method parameter as NULL
+*/
+
+extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file,
+ int* method,
+ int* level,
+ int raw,
+ const char* password));
+/*
+ Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
+ if raw==1
+ *method will receive method of compression, *level will receive level of
+ compression
+ note : you can set level parameter as NULL (if you did not want known level,
+ but you CANNOT set method parameter as NULL
+*/
+
+
+extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
+/*
+ Close the file in zip opened with unzOpenCurrentFile
+ Return UNZ_CRCERROR if all the file was read but the CRC is not good
+*/
+
+extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
+ voidp buf,
+ unsigned len));
+/*
+ Read bytes from the current file (opened by unzOpenCurrentFile)
+ buf contain buffer where data must be copied
+ len the size of buf.
+
+ return the number of byte copied if somes bytes are copied
+ return 0 if the end of file was reached
+ return <0 with error code if there is an error
+ (UNZ_ERRNO for IO error, or zLib error for uncompress error)
+*/
+
+extern z_off_t ZEXPORT unztell OF((unzFile file));
+
+extern ZPOS64_T ZEXPORT unztell64 OF((unzFile file));
+/*
+ Give the current position in uncompressed data
+*/
+
+extern int ZEXPORT unzeof OF((unzFile file));
+/*
+ return 1 if the end of file was reached, 0 elsewhere
+*/
+
+extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
+ voidp buf,
+ unsigned len));
+/*
+ Read extra field from the current file (opened by unzOpenCurrentFile)
+ This is the local-header version of the extra field (sometimes, there is
+ more info in the local-header version than in the central-header)
+
+ if buf==NULL, it return the size of the local extra field
+
+ if buf!=NULL, len is the size of the buffer, the extra header is copied in
+ buf.
+ the return value is the number of bytes copied in buf, or (if <0)
+ the error code
+*/
+
+/***************************************************************************/
+
+/* Get the current file offset */
+extern ZPOS64_T ZEXPORT unzGetOffset64 (unzFile file);
+extern uLong ZEXPORT unzGetOffset (unzFile file);
+
+/* Set the current file offset */
+extern int ZEXPORT unzSetOffset64 (unzFile file, ZPOS64_T pos);
+extern int ZEXPORT unzSetOffset (unzFile file, uLong pos);
+
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _unz64_H */
diff --git a/zlib/contrib/minizip/zip.c b/zlib/contrib/minizip/zip.c
new file mode 100644
index 000000000..44e88a9cb
--- /dev/null
+++ b/zlib/contrib/minizip/zip.c
@@ -0,0 +1,2007 @@
+/* zip.c -- IO on .zip files using zlib
+ Version 1.1, February 14h, 2010
+ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Modifications for Zip64 support
+ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+ For more info read MiniZip_info.txt
+
+ Changes
+ Oct-2009 - Mathias Svensson - Remove old C style function prototypes
+ Oct-2009 - Mathias Svensson - Added Zip64 Support when creating new file archives
+ Oct-2009 - Mathias Svensson - Did some code cleanup and refactoring to get better overview of some functions.
+ Oct-2009 - Mathias Svensson - Added zipRemoveExtraInfoBlock to strip extra field data from its ZIP64 data
+ It is used when recreting zip archive with RAW when deleting items from a zip.
+ ZIP64 data is automatically added to items that needs it, and existing ZIP64 data need to be removed.
+ Oct-2009 - Mathias Svensson - Added support for BZIP2 as compression mode (bzip2 lib is required)
+ Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer
+
+*/
+
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include "zlib.h"
+#include "zip.h"
+
+#ifdef STDC
+# include <stddef.h>
+# include <string.h>
+# include <stdlib.h>
+#endif
+#ifdef NO_ERRNO_H
+ extern int errno;
+#else
+# include <errno.h>
+#endif
+
+
+#ifndef local
+# define local static
+#endif
+/* compile with -Dlocal if your debugger can't find static symbols */
+
+#ifndef VERSIONMADEBY
+# define VERSIONMADEBY (0x0) /* platform depedent */
+#endif
+
+#ifndef Z_BUFSIZE
+#define Z_BUFSIZE (64*1024) //(16384)
+#endif
+
+#ifndef Z_MAXFILENAMEINZIP
+#define Z_MAXFILENAMEINZIP (256)
+#endif
+
+#ifndef ALLOC
+# define ALLOC(size) (malloc(size))
+#endif
+#ifndef TRYFREE
+# define TRYFREE(p) {if (p) free(p);}
+#endif
+
+/*
+#define SIZECENTRALDIRITEM (0x2e)
+#define SIZEZIPLOCALHEADER (0x1e)
+*/
+
+/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
+
+
+// NOT sure that this work on ALL platform
+#define MAKEULONG64(a, b) ((ZPOS64_T)(((unsigned long)(a)) | ((ZPOS64_T)((unsigned long)(b))) << 32))
+
+#ifndef SEEK_CUR
+#define SEEK_CUR 1
+#endif
+
+#ifndef SEEK_END
+#define SEEK_END 2
+#endif
+
+#ifndef SEEK_SET
+#define SEEK_SET 0
+#endif
+
+#ifndef DEF_MEM_LEVEL
+#if MAX_MEM_LEVEL >= 8
+# define DEF_MEM_LEVEL 8
+#else
+# define DEF_MEM_LEVEL MAX_MEM_LEVEL
+#endif
+#endif
+const char zip_copyright[] =" zip 1.01 Copyright 1998-2004 Gilles Vollant - http://www.winimage.com/zLibDll";
+
+
+#define SIZEDATA_INDATABLOCK (4096-(4*4))
+
+#define LOCALHEADERMAGIC (0x04034b50)
+#define CENTRALHEADERMAGIC (0x02014b50)
+#define ENDHEADERMAGIC (0x06054b50)
+#define ZIP64ENDHEADERMAGIC (0x6064b50)
+#define ZIP64ENDLOCHEADERMAGIC (0x7064b50)
+
+#define FLAG_LOCALHEADER_OFFSET (0x06)
+#define CRC_LOCALHEADER_OFFSET (0x0e)
+
+#define SIZECENTRALHEADER (0x2e) /* 46 */
+
+typedef struct linkedlist_datablock_internal_s
+{
+ struct linkedlist_datablock_internal_s* next_datablock;
+ uLong avail_in_this_block;
+ uLong filled_in_this_block;
+ uLong unused; /* for future use and alignment */
+ unsigned char data[SIZEDATA_INDATABLOCK];
+} linkedlist_datablock_internal;
+
+typedef struct linkedlist_data_s
+{
+ linkedlist_datablock_internal* first_block;
+ linkedlist_datablock_internal* last_block;
+} linkedlist_data;
+
+
+typedef struct
+{
+ z_stream stream; /* zLib stream structure for inflate */
+#ifdef HAVE_BZIP2
+ bz_stream bstream; /* bzLib stream structure for bziped */
+#endif
+
+ int stream_initialised; /* 1 is stream is initialised */
+ uInt pos_in_buffered_data; /* last written byte in buffered_data */
+
+ ZPOS64_T pos_local_header; /* offset of the local header of the file
+ currenty writing */
+ char* central_header; /* central header data for the current file */
+ uLong size_centralExtra;
+ uLong size_centralheader; /* size of the central header for cur file */
+ uLong size_centralExtraFree; /* Extra bytes allocated to the centralheader but that are not used */
+ uLong flag; /* flag of the file currently writing */
+
+ int method; /* compression method of file currenty wr.*/
+ int raw; /* 1 for directly writing raw data */
+ Byte buffered_data[Z_BUFSIZE];/* buffer contain compressed data to be writ*/
+ uLong dosDate;
+ uLong crc32;
+ int encrypt;
+ int zip64; /* Add ZIP64 extened information in the extra field */
+ ZPOS64_T pos_zip64extrainfo;
+ ZPOS64_T totalCompressedData;
+ ZPOS64_T totalUncompressedData;
+#ifndef NOCRYPT
+ unsigned long keys[3]; /* keys defining the pseudo-random sequence */
+ const z_crc_t* pcrc_32_tab;
+ int crypt_header_size;
+#endif
+} curfile64_info;
+
+typedef struct
+{
+ zlib_filefunc64_32_def z_filefunc;
+ voidpf filestream; /* io structore of the zipfile */
+ linkedlist_data central_dir;/* datablock with central dir in construction*/
+ int in_opened_file_inzip; /* 1 if a file in the zip is currently writ.*/
+ curfile64_info ci; /* info on the file curretly writing */
+
+ ZPOS64_T begin_pos; /* position of the beginning of the zipfile */
+ ZPOS64_T add_position_when_writing_offset;
+ ZPOS64_T number_entry;
+
+#ifndef NO_ADDFILEINEXISTINGZIP
+ char *globalcomment;
+#endif
+
+} zip64_internal;
+
+
+#ifndef NOCRYPT
+#define INCLUDECRYPTINGCODE_IFCRYPTALLOWED
+#include "crypt.h"
+#endif
+
+local linkedlist_datablock_internal* allocate_new_datablock()
+{
+ linkedlist_datablock_internal* ldi;
+ ldi = (linkedlist_datablock_internal*)
+ ALLOC(sizeof(linkedlist_datablock_internal));
+ if (ldi!=NULL)
+ {
+ ldi->next_datablock = NULL ;
+ ldi->filled_in_this_block = 0 ;
+ ldi->avail_in_this_block = SIZEDATA_INDATABLOCK ;
+ }
+ return ldi;
+}
+
+local void free_datablock(linkedlist_datablock_internal* ldi)
+{
+ while (ldi!=NULL)
+ {
+ linkedlist_datablock_internal* ldinext = ldi->next_datablock;
+ TRYFREE(ldi);
+ ldi = ldinext;
+ }
+}
+
+local void init_linkedlist(linkedlist_data* ll)
+{
+ ll->first_block = ll->last_block = NULL;
+}
+
+local void free_linkedlist(linkedlist_data* ll)
+{
+ free_datablock(ll->first_block);
+ ll->first_block = ll->last_block = NULL;
+}
+
+
+local int add_data_in_datablock(linkedlist_data* ll, const void* buf, uLong len)
+{
+ linkedlist_datablock_internal* ldi;
+ const unsigned char* from_copy;
+
+ if (ll==NULL)
+ return ZIP_INTERNALERROR;
+
+ if (ll->last_block == NULL)
+ {
+ ll->first_block = ll->last_block = allocate_new_datablock();
+ if (ll->first_block == NULL)
+ return ZIP_INTERNALERROR;
+ }
+
+ ldi = ll->last_block;
+ from_copy = (unsigned char*)buf;
+
+ while (len>0)
+ {
+ uInt copy_this;
+ uInt i;
+ unsigned char* to_copy;
+
+ if (ldi->avail_in_this_block==0)
+ {
+ ldi->next_datablock = allocate_new_datablock();
+ if (ldi->next_datablock == NULL)
+ return ZIP_INTERNALERROR;
+ ldi = ldi->next_datablock ;
+ ll->last_block = ldi;
+ }
+
+ if (ldi->avail_in_this_block < len)
+ copy_this = (uInt)ldi->avail_in_this_block;
+ else
+ copy_this = (uInt)len;
+
+ to_copy = &(ldi->data[ldi->filled_in_this_block]);
+
+ for (i=0;i<copy_this;i++)
+ *(to_copy+i)=*(from_copy+i);
+
+ ldi->filled_in_this_block += copy_this;
+ ldi->avail_in_this_block -= copy_this;
+ from_copy += copy_this ;
+ len -= copy_this;
+ }
+ return ZIP_OK;
+}
+
+
+
+/****************************************************************************/
+
+#ifndef NO_ADDFILEINEXISTINGZIP
+/* ===========================================================================
+ Inputs a long in LSB order to the given file
+ nbByte == 1, 2 ,4 or 8 (byte, short or long, ZPOS64_T)
+*/
+
+local int zip64local_putValue OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte));
+local int zip64local_putValue (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T x, int nbByte)
+{
+ unsigned char buf[8];
+ int n;
+ for (n = 0; n < nbByte; n++)
+ {
+ buf[n] = (unsigned char)(x & 0xff);
+ x >>= 8;
+ }
+ if (x != 0)
+ { /* data overflow - hack for ZIP64 (X Roche) */
+ for (n = 0; n < nbByte; n++)
+ {
+ buf[n] = 0xff;
+ }
+ }
+
+ if (ZWRITE64(*pzlib_filefunc_def,filestream,buf,nbByte)!=(uLong)nbByte)
+ return ZIP_ERRNO;
+ else
+ return ZIP_OK;
+}
+
+local void zip64local_putValue_inmemory OF((void* dest, ZPOS64_T x, int nbByte));
+local void zip64local_putValue_inmemory (void* dest, ZPOS64_T x, int nbByte)
+{
+ unsigned char* buf=(unsigned char*)dest;
+ int n;
+ for (n = 0; n < nbByte; n++) {
+ buf[n] = (unsigned char)(x & 0xff);
+ x >>= 8;
+ }
+
+ if (x != 0)
+ { /* data overflow - hack for ZIP64 */
+ for (n = 0; n < nbByte; n++)
+ {
+ buf[n] = 0xff;
+ }
+ }
+}
+
+/****************************************************************************/
+
+
+local uLong zip64local_TmzDateToDosDate(const tm_zip* ptm)
+{
+ uLong year = (uLong)ptm->tm_year;
+ if (year>=1980)
+ year-=1980;
+ else if (year>=80)
+ year-=80;
+ return
+ (uLong) (((ptm->tm_mday) + (32 * (ptm->tm_mon+1)) + (512 * year)) << 16) |
+ ((ptm->tm_sec/2) + (32* ptm->tm_min) + (2048 * (uLong)ptm->tm_hour));
+}
+
+
+/****************************************************************************/
+
+local int zip64local_getByte OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, int *pi));
+
+local int zip64local_getByte(const zlib_filefunc64_32_def* pzlib_filefunc_def,voidpf filestream,int* pi)
+{
+ unsigned char c;
+ int err = (int)ZREAD64(*pzlib_filefunc_def,filestream,&c,1);
+ if (err==1)
+ {
+ *pi = (int)c;
+ return ZIP_OK;
+ }
+ else
+ {
+ if (ZERROR64(*pzlib_filefunc_def,filestream))
+ return ZIP_ERRNO;
+ else
+ return ZIP_EOF;
+ }
+}
+
+
+/* ===========================================================================
+ Reads a long in LSB order from the given gz_stream. Sets
+*/
+local int zip64local_getShort OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX));
+
+local int zip64local_getShort (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX)
+{
+ uLong x ;
+ int i = 0;
+ int err;
+
+ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x = (uLong)i;
+
+ if (err==ZIP_OK)
+ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x += ((uLong)i)<<8;
+
+ if (err==ZIP_OK)
+ *pX = x;
+ else
+ *pX = 0;
+ return err;
+}
+
+local int zip64local_getLong OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong *pX));
+
+local int zip64local_getLong (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, uLong* pX)
+{
+ uLong x ;
+ int i = 0;
+ int err;
+
+ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x = (uLong)i;
+
+ if (err==ZIP_OK)
+ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x += ((uLong)i)<<8;
+
+ if (err==ZIP_OK)
+ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x += ((uLong)i)<<16;
+
+ if (err==ZIP_OK)
+ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x += ((uLong)i)<<24;
+
+ if (err==ZIP_OK)
+ *pX = x;
+ else
+ *pX = 0;
+ return err;
+}
+
+local int zip64local_getLong64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX));
+
+
+local int zip64local_getLong64 (const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream, ZPOS64_T *pX)
+{
+ ZPOS64_T x;
+ int i = 0;
+ int err;
+
+ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x = (ZPOS64_T)i;
+
+ if (err==ZIP_OK)
+ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x += ((ZPOS64_T)i)<<8;
+
+ if (err==ZIP_OK)
+ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x += ((ZPOS64_T)i)<<16;
+
+ if (err==ZIP_OK)
+ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x += ((ZPOS64_T)i)<<24;
+
+ if (err==ZIP_OK)
+ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x += ((ZPOS64_T)i)<<32;
+
+ if (err==ZIP_OK)
+ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x += ((ZPOS64_T)i)<<40;
+
+ if (err==ZIP_OK)
+ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x += ((ZPOS64_T)i)<<48;
+
+ if (err==ZIP_OK)
+ err = zip64local_getByte(pzlib_filefunc_def,filestream,&i);
+ x += ((ZPOS64_T)i)<<56;
+
+ if (err==ZIP_OK)
+ *pX = x;
+ else
+ *pX = 0;
+
+ return err;
+}
+
+#ifndef BUFREADCOMMENT
+#define BUFREADCOMMENT (0x400)
+#endif
+/*
+ Locate the Central directory of a zipfile (at the end, just before
+ the global comment)
+*/
+local ZPOS64_T zip64local_SearchCentralDir OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
+
+local ZPOS64_T zip64local_SearchCentralDir(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
+{
+ unsigned char* buf;
+ ZPOS64_T uSizeFile;
+ ZPOS64_T uBackRead;
+ ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
+ ZPOS64_T uPosFound=0;
+
+ if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
+ return 0;
+
+
+ uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
+
+ if (uMaxBack>uSizeFile)
+ uMaxBack = uSizeFile;
+
+ buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
+ if (buf==NULL)
+ return 0;
+
+ uBackRead = 4;
+ while (uBackRead<uMaxBack)
+ {
+ uLong uReadSize;
+ ZPOS64_T uReadPos ;
+ int i;
+ if (uBackRead+BUFREADCOMMENT>uMaxBack)
+ uBackRead = uMaxBack;
+ else
+ uBackRead+=BUFREADCOMMENT;
+ uReadPos = uSizeFile-uBackRead ;
+
+ uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
+ (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
+ if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+ break;
+
+ if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
+ break;
+
+ for (i=(int)uReadSize-3; (i--)>0;)
+ if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) &&
+ ((*(buf+i+2))==0x05) && ((*(buf+i+3))==0x06))
+ {
+ uPosFound = uReadPos+i;
+ break;
+ }
+
+ if (uPosFound!=0)
+ break;
+ }
+ TRYFREE(buf);
+ return uPosFound;
+}
+
+/*
+Locate the End of Zip64 Central directory locator and from there find the CD of a zipfile (at the end, just before
+the global comment)
+*/
+local ZPOS64_T zip64local_SearchCentralDir64 OF((const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream));
+
+local ZPOS64_T zip64local_SearchCentralDir64(const zlib_filefunc64_32_def* pzlib_filefunc_def, voidpf filestream)
+{
+ unsigned char* buf;
+ ZPOS64_T uSizeFile;
+ ZPOS64_T uBackRead;
+ ZPOS64_T uMaxBack=0xffff; /* maximum size of global comment */
+ ZPOS64_T uPosFound=0;
+ uLong uL;
+ ZPOS64_T relativeOffset;
+
+ if (ZSEEK64(*pzlib_filefunc_def,filestream,0,ZLIB_FILEFUNC_SEEK_END) != 0)
+ return 0;
+
+ uSizeFile = ZTELL64(*pzlib_filefunc_def,filestream);
+
+ if (uMaxBack>uSizeFile)
+ uMaxBack = uSizeFile;
+
+ buf = (unsigned char*)ALLOC(BUFREADCOMMENT+4);
+ if (buf==NULL)
+ return 0;
+
+ uBackRead = 4;
+ while (uBackRead<uMaxBack)
+ {
+ uLong uReadSize;
+ ZPOS64_T uReadPos;
+ int i;
+ if (uBackRead+BUFREADCOMMENT>uMaxBack)
+ uBackRead = uMaxBack;
+ else
+ uBackRead+=BUFREADCOMMENT;
+ uReadPos = uSizeFile-uBackRead ;
+
+ uReadSize = ((BUFREADCOMMENT+4) < (uSizeFile-uReadPos)) ?
+ (BUFREADCOMMENT+4) : (uLong)(uSizeFile-uReadPos);
+ if (ZSEEK64(*pzlib_filefunc_def,filestream,uReadPos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+ break;
+
+ if (ZREAD64(*pzlib_filefunc_def,filestream,buf,uReadSize)!=uReadSize)
+ break;
+
+ for (i=(int)uReadSize-3; (i--)>0;)
+ {
+ // Signature "0x07064b50" Zip64 end of central directory locater
+ if (((*(buf+i))==0x50) && ((*(buf+i+1))==0x4b) && ((*(buf+i+2))==0x06) && ((*(buf+i+3))==0x07))
+ {
+ uPosFound = uReadPos+i;
+ break;
+ }
+ }
+
+ if (uPosFound!=0)
+ break;
+ }
+
+ TRYFREE(buf);
+ if (uPosFound == 0)
+ return 0;
+
+ /* Zip64 end of central directory locator */
+ if (ZSEEK64(*pzlib_filefunc_def,filestream, uPosFound,ZLIB_FILEFUNC_SEEK_SET)!=0)
+ return 0;
+
+ /* the signature, already checked */
+ if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
+ return 0;
+
+ /* number of the disk with the start of the zip64 end of central directory */
+ if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
+ return 0;
+ if (uL != 0)
+ return 0;
+
+ /* relative offset of the zip64 end of central directory record */
+ if (zip64local_getLong64(pzlib_filefunc_def,filestream,&relativeOffset)!=ZIP_OK)
+ return 0;
+
+ /* total number of disks */
+ if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
+ return 0;
+ if (uL != 1)
+ return 0;
+
+ /* Goto Zip64 end of central directory record */
+ if (ZSEEK64(*pzlib_filefunc_def,filestream, relativeOffset,ZLIB_FILEFUNC_SEEK_SET)!=0)
+ return 0;
+
+ /* the signature */
+ if (zip64local_getLong(pzlib_filefunc_def,filestream,&uL)!=ZIP_OK)
+ return 0;
+
+ if (uL != 0x06064b50) // signature of 'Zip64 end of central directory'
+ return 0;
+
+ return relativeOffset;
+}
+
+int LoadCentralDirectoryRecord(zip64_internal* pziinit)
+{
+ int err=ZIP_OK;
+ ZPOS64_T byte_before_the_zipfile;/* byte before the zipfile, (>0 for sfx)*/
+
+ ZPOS64_T size_central_dir; /* size of the central directory */
+ ZPOS64_T offset_central_dir; /* offset of start of central directory */
+ ZPOS64_T central_pos;
+ uLong uL;
+
+ uLong number_disk; /* number of the current dist, used for
+ spaning ZIP, unsupported, always 0*/
+ uLong number_disk_with_CD; /* number the the disk with central dir, used
+ for spaning ZIP, unsupported, always 0*/
+ ZPOS64_T number_entry;
+ ZPOS64_T number_entry_CD; /* total number of entries in
+ the central dir
+ (same than number_entry on nospan) */
+ uLong VersionMadeBy;
+ uLong VersionNeeded;
+ uLong size_comment;
+
+ int hasZIP64Record = 0;
+
+ // check first if we find a ZIP64 record
+ central_pos = zip64local_SearchCentralDir64(&pziinit->z_filefunc,pziinit->filestream);
+ if(central_pos > 0)
+ {
+ hasZIP64Record = 1;
+ }
+ else if(central_pos == 0)
+ {
+ central_pos = zip64local_SearchCentralDir(&pziinit->z_filefunc,pziinit->filestream);
+ }
+
+/* disable to allow appending to empty ZIP archive
+ if (central_pos==0)
+ err=ZIP_ERRNO;
+*/
+
+ if(hasZIP64Record)
+ {
+ ZPOS64_T sizeEndOfCentralDirectory;
+ if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos, ZLIB_FILEFUNC_SEEK_SET) != 0)
+ err=ZIP_ERRNO;
+
+ /* the signature, already checked */
+ if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK)
+ err=ZIP_ERRNO;
+
+ /* size of zip64 end of central directory record */
+ if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &sizeEndOfCentralDirectory)!=ZIP_OK)
+ err=ZIP_ERRNO;
+
+ /* version made by */
+ if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionMadeBy)!=ZIP_OK)
+ err=ZIP_ERRNO;
+
+ /* version needed to extract */
+ if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &VersionNeeded)!=ZIP_OK)
+ err=ZIP_ERRNO;
+
+ /* number of this disk */
+ if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK)
+ err=ZIP_ERRNO;
+
+ /* number of the disk with the start of the central directory */
+ if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK)
+ err=ZIP_ERRNO;
+
+ /* total number of entries in the central directory on this disk */
+ if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream, &number_entry)!=ZIP_OK)
+ err=ZIP_ERRNO;
+
+ /* total number of entries in the central directory */
+ if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&number_entry_CD)!=ZIP_OK)
+ err=ZIP_ERRNO;
+
+ if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0))
+ err=ZIP_BADZIPFILE;
+
+ /* size of the central directory */
+ if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&size_central_dir)!=ZIP_OK)
+ err=ZIP_ERRNO;
+
+ /* offset of start of central directory with respect to the
+ starting disk number */
+ if (zip64local_getLong64(&pziinit->z_filefunc, pziinit->filestream,&offset_central_dir)!=ZIP_OK)
+ err=ZIP_ERRNO;
+
+ // TODO..
+ // read the comment from the standard central header.
+ size_comment = 0;
+ }
+ else
+ {
+ // Read End of central Directory info
+ if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, central_pos,ZLIB_FILEFUNC_SEEK_SET)!=0)
+ err=ZIP_ERRNO;
+
+ /* the signature, already checked */
+ if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream,&uL)!=ZIP_OK)
+ err=ZIP_ERRNO;
+
+ /* number of this disk */
+ if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk)!=ZIP_OK)
+ err=ZIP_ERRNO;
+
+ /* number of the disk with the start of the central directory */
+ if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream,&number_disk_with_CD)!=ZIP_OK)
+ err=ZIP_ERRNO;
+
+ /* total number of entries in the central dir on this disk */
+ number_entry = 0;
+ if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
+ err=ZIP_ERRNO;
+ else
+ number_entry = uL;
+
+ /* total number of entries in the central dir */
+ number_entry_CD = 0;
+ if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
+ err=ZIP_ERRNO;
+ else
+ number_entry_CD = uL;
+
+ if ((number_entry_CD!=number_entry) || (number_disk_with_CD!=0) || (number_disk!=0))
+ err=ZIP_BADZIPFILE;
+
+ /* size of the central directory */
+ size_central_dir = 0;
+ if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
+ err=ZIP_ERRNO;
+ else
+ size_central_dir = uL;
+
+ /* offset of start of central directory with respect to the starting disk number */
+ offset_central_dir = 0;
+ if (zip64local_getLong(&pziinit->z_filefunc, pziinit->filestream, &uL)!=ZIP_OK)
+ err=ZIP_ERRNO;
+ else
+ offset_central_dir = uL;
+
+
+ /* zipfile global comment length */
+ if (zip64local_getShort(&pziinit->z_filefunc, pziinit->filestream, &size_comment)!=ZIP_OK)
+ err=ZIP_ERRNO;
+ }
+
+ if ((central_pos<offset_central_dir+size_central_dir) &&
+ (err==ZIP_OK))
+ err=ZIP_BADZIPFILE;
+
+ if (err!=ZIP_OK)
+ {
+ ZCLOSE64(pziinit->z_filefunc, pziinit->filestream);
+ return ZIP_ERRNO;
+ }
+
+ if (size_comment>0)
+ {
+ pziinit->globalcomment = (char*)ALLOC(size_comment+1);
+ if (pziinit->globalcomment)
+ {
+ size_comment = ZREAD64(pziinit->z_filefunc, pziinit->filestream, pziinit->globalcomment,size_comment);
+ pziinit->globalcomment[size_comment]=0;
+ }
+ }
+
+ byte_before_the_zipfile = central_pos - (offset_central_dir+size_central_dir);
+ pziinit->add_position_when_writing_offset = byte_before_the_zipfile;
+
+ {
+ ZPOS64_T size_central_dir_to_read = size_central_dir;
+ size_t buf_size = SIZEDATA_INDATABLOCK;
+ void* buf_read = (void*)ALLOC(buf_size);
+ if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir + byte_before_the_zipfile, ZLIB_FILEFUNC_SEEK_SET) != 0)
+ err=ZIP_ERRNO;
+
+ while ((size_central_dir_to_read>0) && (err==ZIP_OK))
+ {
+ ZPOS64_T read_this = SIZEDATA_INDATABLOCK;
+ if (read_this > size_central_dir_to_read)
+ read_this = size_central_dir_to_read;
+
+ if (ZREAD64(pziinit->z_filefunc, pziinit->filestream,buf_read,(uLong)read_this) != read_this)
+ err=ZIP_ERRNO;
+
+ if (err==ZIP_OK)
+ err = add_data_in_datablock(&pziinit->central_dir,buf_read, (uLong)read_this);
+
+ size_central_dir_to_read-=read_this;
+ }
+ TRYFREE(buf_read);
+ }
+ pziinit->begin_pos = byte_before_the_zipfile;
+ pziinit->number_entry = number_entry_CD;
+
+ if (ZSEEK64(pziinit->z_filefunc, pziinit->filestream, offset_central_dir+byte_before_the_zipfile,ZLIB_FILEFUNC_SEEK_SET) != 0)
+ err=ZIP_ERRNO;
+
+ return err;
+}
+
+
+#endif /* !NO_ADDFILEINEXISTINGZIP*/
+
+
+/************************************************************/
+extern zipFile ZEXPORT zipOpen3 (const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_32_def* pzlib_filefunc64_32_def)
+{
+ zip64_internal ziinit;
+ zip64_internal* zi;
+ int err=ZIP_OK;
+
+ ziinit.z_filefunc.zseek32_file = NULL;
+ ziinit.z_filefunc.ztell32_file = NULL;
+ if (pzlib_filefunc64_32_def==NULL)
+ fill_fopen64_filefunc(&ziinit.z_filefunc.zfile_func64);
+ else
+ ziinit.z_filefunc = *pzlib_filefunc64_32_def;
+
+ ziinit.filestream = ZOPEN64(ziinit.z_filefunc,
+ pathname,
+ (append == APPEND_STATUS_CREATE) ?
+ (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_CREATE) :
+ (ZLIB_FILEFUNC_MODE_READ | ZLIB_FILEFUNC_MODE_WRITE | ZLIB_FILEFUNC_MODE_EXISTING));
+
+ if (ziinit.filestream == NULL)
+ return NULL;
+
+ if (append == APPEND_STATUS_CREATEAFTER)
+ ZSEEK64(ziinit.z_filefunc,ziinit.filestream,0,SEEK_END);
+
+ ziinit.begin_pos = ZTELL64(ziinit.z_filefunc,ziinit.filestream);
+ ziinit.in_opened_file_inzip = 0;
+ ziinit.ci.stream_initialised = 0;
+ ziinit.number_entry = 0;
+ ziinit.add_position_when_writing_offset = 0;
+ init_linkedlist(&(ziinit.central_dir));
+
+
+
+ zi = (zip64_internal*)ALLOC(sizeof(zip64_internal));
+ if (zi==NULL)
+ {
+ ZCLOSE64(ziinit.z_filefunc,ziinit.filestream);
+ return NULL;
+ }
+
+ /* now we add file in a zipfile */
+# ifndef NO_ADDFILEINEXISTINGZIP
+ ziinit.globalcomment = NULL;
+ if (append == APPEND_STATUS_ADDINZIP)
+ {
+ // Read and Cache Central Directory Records
+ err = LoadCentralDirectoryRecord(&ziinit);
+ }
+
+ if (globalcomment)
+ {
+ *globalcomment = ziinit.globalcomment;
+ }
+# endif /* !NO_ADDFILEINEXISTINGZIP*/
+
+ if (err != ZIP_OK)
+ {
+# ifndef NO_ADDFILEINEXISTINGZIP
+ TRYFREE(ziinit.globalcomment);
+# endif /* !NO_ADDFILEINEXISTINGZIP*/
+ TRYFREE(zi);
+ return NULL;
+ }
+ else
+ {
+ *zi = ziinit;
+ return (zipFile)zi;
+ }
+}
+
+extern zipFile ZEXPORT zipOpen2 (const char *pathname, int append, zipcharpc* globalcomment, zlib_filefunc_def* pzlib_filefunc32_def)
+{
+ if (pzlib_filefunc32_def != NULL)
+ {
+ zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
+ fill_zlib_filefunc64_32_def_from_filefunc32(&zlib_filefunc64_32_def_fill,pzlib_filefunc32_def);
+ return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);
+ }
+ else
+ return zipOpen3(pathname, append, globalcomment, NULL);
+}
+
+extern zipFile ZEXPORT zipOpen2_64 (const void *pathname, int append, zipcharpc* globalcomment, zlib_filefunc64_def* pzlib_filefunc_def)
+{
+ if (pzlib_filefunc_def != NULL)
+ {
+ zlib_filefunc64_32_def zlib_filefunc64_32_def_fill;
+ zlib_filefunc64_32_def_fill.zfile_func64 = *pzlib_filefunc_def;
+ zlib_filefunc64_32_def_fill.ztell32_file = NULL;
+ zlib_filefunc64_32_def_fill.zseek32_file = NULL;
+ return zipOpen3(pathname, append, globalcomment, &zlib_filefunc64_32_def_fill);
+ }
+ else
+ return zipOpen3(pathname, append, globalcomment, NULL);
+}
+
+
+
+extern zipFile ZEXPORT zipOpen (const char* pathname, int append)
+{
+ return zipOpen3((const void*)pathname,append,NULL,NULL);
+}
+
+extern zipFile ZEXPORT zipOpen64 (const void* pathname, int append)
+{
+ return zipOpen3(pathname,append,NULL,NULL);
+}
+
+int Write_LocalFileHeader(zip64_internal* zi, const char* filename, uInt size_extrafield_local, const void* extrafield_local)
+{
+ /* write the local header */
+ int err;
+ uInt size_filename = (uInt)strlen(filename);
+ uInt size_extrafield = size_extrafield_local;
+
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)LOCALHEADERMAGIC, 4);
+
+ if (err==ZIP_OK)
+ {
+ if(zi->ci.zip64)
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);/* version needed to extract */
+ else
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)20,2);/* version needed to extract */
+ }
+
+ if (err==ZIP_OK)
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.flag,2);
+
+ if (err==ZIP_OK)
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.method,2);
+
+ if (err==ZIP_OK)
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->ci.dosDate,4);
+
+ // CRC / Compressed size / Uncompressed size will be filled in later and rewritten later
+ if (err==ZIP_OK)
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* crc 32, unknown */
+ if (err==ZIP_OK)
+ {
+ if(zi->ci.zip64)
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* compressed size, unknown */
+ else
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* compressed size, unknown */
+ }
+ if (err==ZIP_OK)
+ {
+ if(zi->ci.zip64)
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xFFFFFFFF,4); /* uncompressed size, unknown */
+ else
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4); /* uncompressed size, unknown */
+ }
+
+ if (err==ZIP_OK)
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_filename,2);
+
+ if(zi->ci.zip64)
+ {
+ size_extrafield += 20;
+ }
+
+ if (err==ZIP_OK)
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_extrafield,2);
+
+ if ((err==ZIP_OK) && (size_filename > 0))
+ {
+ if (ZWRITE64(zi->z_filefunc,zi->filestream,filename,size_filename)!=size_filename)
+ err = ZIP_ERRNO;
+ }
+
+ if ((err==ZIP_OK) && (size_extrafield_local > 0))
+ {
+ if (ZWRITE64(zi->z_filefunc, zi->filestream, extrafield_local, size_extrafield_local) != size_extrafield_local)
+ err = ZIP_ERRNO;
+ }
+
+
+ if ((err==ZIP_OK) && (zi->ci.zip64))
+ {
+ // write the Zip64 extended info
+ short HeaderID = 1;
+ short DataSize = 16;
+ ZPOS64_T CompressedSize = 0;
+ ZPOS64_T UncompressedSize = 0;
+
+ // Remember position of Zip64 extended info for the local file header. (needed when we update size after done with file)
+ zi->ci.pos_zip64extrainfo = ZTELL64(zi->z_filefunc,zi->filestream);
+
+ err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)HeaderID,2);
+ err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (short)DataSize,2);
+
+ err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)UncompressedSize,8);
+ err = zip64local_putValue(&zi->z_filefunc, zi->filestream, (ZPOS64_T)CompressedSize,8);
+ }
+
+ return err;
+}
+
+/*
+ NOTE.
+ When writing RAW the ZIP64 extended information in extrafield_local and extrafield_global needs to be stripped
+ before calling this function it can be done with zipRemoveExtraInfoBlock
+
+ It is not done here because then we need to realloc a new buffer since parameters are 'const' and I want to minimize
+ unnecessary allocations.
+ */
+extern int ZEXPORT zipOpenNewFileInZip4_64 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
+ const void* extrafield_local, uInt size_extrafield_local,
+ const void* extrafield_global, uInt size_extrafield_global,
+ const char* comment, int method, int level, int raw,
+ int windowBits,int memLevel, int strategy,
+ const char* password, uLong crcForCrypting,
+ uLong versionMadeBy, uLong flagBase, int zip64)
+{
+ zip64_internal* zi;
+ uInt size_filename;
+ uInt size_comment;
+ uInt i;
+ int err = ZIP_OK;
+
+# ifdef NOCRYPT
+ (crcForCrypting);
+ if (password != NULL)
+ return ZIP_PARAMERROR;
+# endif
+
+ if (file == NULL)
+ return ZIP_PARAMERROR;
+
+#ifdef HAVE_BZIP2
+ if ((method!=0) && (method!=Z_DEFLATED) && (method!=Z_BZIP2ED))
+ return ZIP_PARAMERROR;
+#else
+ if ((method!=0) && (method!=Z_DEFLATED))
+ return ZIP_PARAMERROR;
+#endif
+
+ zi = (zip64_internal*)file;
+
+ if (zi->in_opened_file_inzip == 1)
+ {
+ err = zipCloseFileInZip (file);
+ if (err != ZIP_OK)
+ return err;
+ }
+
+ if (filename==NULL)
+ filename="-";
+
+ if (comment==NULL)
+ size_comment = 0;
+ else
+ size_comment = (uInt)strlen(comment);
+
+ size_filename = (uInt)strlen(filename);
+
+ if (zipfi == NULL)
+ zi->ci.dosDate = 0;
+ else
+ {
+ if (zipfi->dosDate != 0)
+ zi->ci.dosDate = zipfi->dosDate;
+ else
+ zi->ci.dosDate = zip64local_TmzDateToDosDate(&zipfi->tmz_date);
+ }
+
+ zi->ci.flag = flagBase;
+ if ((level==8) || (level==9))
+ zi->ci.flag |= 2;
+ if (level==2)
+ zi->ci.flag |= 4;
+ if (level==1)
+ zi->ci.flag |= 6;
+ if (password != NULL)
+ zi->ci.flag |= 1;
+
+ zi->ci.crc32 = 0;
+ zi->ci.method = method;
+ zi->ci.encrypt = 0;
+ zi->ci.stream_initialised = 0;
+ zi->ci.pos_in_buffered_data = 0;
+ zi->ci.raw = raw;
+ zi->ci.pos_local_header = ZTELL64(zi->z_filefunc,zi->filestream);
+
+ zi->ci.size_centralheader = SIZECENTRALHEADER + size_filename + size_extrafield_global + size_comment;
+ zi->ci.size_centralExtraFree = 32; // Extra space we have reserved in case we need to add ZIP64 extra info data
+
+ zi->ci.central_header = (char*)ALLOC((uInt)zi->ci.size_centralheader + zi->ci.size_centralExtraFree);
+
+ zi->ci.size_centralExtra = size_extrafield_global;
+ zip64local_putValue_inmemory(zi->ci.central_header,(uLong)CENTRALHEADERMAGIC,4);
+ /* version info */
+ zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)versionMadeBy,2);
+ zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)20,2);
+ zip64local_putValue_inmemory(zi->ci.central_header+8,(uLong)zi->ci.flag,2);
+ zip64local_putValue_inmemory(zi->ci.central_header+10,(uLong)zi->ci.method,2);
+ zip64local_putValue_inmemory(zi->ci.central_header+12,(uLong)zi->ci.dosDate,4);
+ zip64local_putValue_inmemory(zi->ci.central_header+16,(uLong)0,4); /*crc*/
+ zip64local_putValue_inmemory(zi->ci.central_header+20,(uLong)0,4); /*compr size*/
+ zip64local_putValue_inmemory(zi->ci.central_header+24,(uLong)0,4); /*uncompr size*/
+ zip64local_putValue_inmemory(zi->ci.central_header+28,(uLong)size_filename,2);
+ zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)size_extrafield_global,2);
+ zip64local_putValue_inmemory(zi->ci.central_header+32,(uLong)size_comment,2);
+ zip64local_putValue_inmemory(zi->ci.central_header+34,(uLong)0,2); /*disk nm start*/
+
+ if (zipfi==NULL)
+ zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)0,2);
+ else
+ zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)zipfi->internal_fa,2);
+
+ if (zipfi==NULL)
+ zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)0,4);
+ else
+ zip64local_putValue_inmemory(zi->ci.central_header+38,(uLong)zipfi->external_fa,4);
+
+ if(zi->ci.pos_local_header >= 0xffffffff)
+ zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)0xffffffff,4);
+ else
+ zip64local_putValue_inmemory(zi->ci.central_header+42,(uLong)zi->ci.pos_local_header - zi->add_position_when_writing_offset,4);
+
+ for (i=0;i<size_filename;i++)
+ *(zi->ci.central_header+SIZECENTRALHEADER+i) = *(filename+i);
+
+ for (i=0;i<size_extrafield_global;i++)
+ *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+i) =
+ *(((const char*)extrafield_global)+i);
+
+ for (i=0;i<size_comment;i++)
+ *(zi->ci.central_header+SIZECENTRALHEADER+size_filename+
+ size_extrafield_global+i) = *(comment+i);
+ if (zi->ci.central_header == NULL)
+ return ZIP_INTERNALERROR;
+
+ zi->ci.zip64 = zip64;
+ zi->ci.totalCompressedData = 0;
+ zi->ci.totalUncompressedData = 0;
+ zi->ci.pos_zip64extrainfo = 0;
+
+ err = Write_LocalFileHeader(zi, filename, size_extrafield_local, extrafield_local);
+
+#ifdef HAVE_BZIP2
+ zi->ci.bstream.avail_in = (uInt)0;
+ zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;
+ zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
+ zi->ci.bstream.total_in_hi32 = 0;
+ zi->ci.bstream.total_in_lo32 = 0;
+ zi->ci.bstream.total_out_hi32 = 0;
+ zi->ci.bstream.total_out_lo32 = 0;
+#endif
+
+ zi->ci.stream.avail_in = (uInt)0;
+ zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
+ zi->ci.stream.next_out = zi->ci.buffered_data;
+ zi->ci.stream.total_in = 0;
+ zi->ci.stream.total_out = 0;
+ zi->ci.stream.data_type = Z_BINARY;
+
+#ifdef HAVE_BZIP2
+ if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED || zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
+#else
+ if ((err==ZIP_OK) && (zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+#endif
+ {
+ if(zi->ci.method == Z_DEFLATED)
+ {
+ zi->ci.stream.zalloc = (alloc_func)0;
+ zi->ci.stream.zfree = (free_func)0;
+ zi->ci.stream.opaque = (voidpf)0;
+
+ if (windowBits>0)
+ windowBits = -windowBits;
+
+ err = deflateInit2(&zi->ci.stream, level, Z_DEFLATED, windowBits, memLevel, strategy);
+
+ if (err==Z_OK)
+ zi->ci.stream_initialised = Z_DEFLATED;
+ }
+ else if(zi->ci.method == Z_BZIP2ED)
+ {
+#ifdef HAVE_BZIP2
+ // Init BZip stuff here
+ zi->ci.bstream.bzalloc = 0;
+ zi->ci.bstream.bzfree = 0;
+ zi->ci.bstream.opaque = (voidpf)0;
+
+ err = BZ2_bzCompressInit(&zi->ci.bstream, level, 0,35);
+ if(err == BZ_OK)
+ zi->ci.stream_initialised = Z_BZIP2ED;
+#endif
+ }
+
+ }
+
+# ifndef NOCRYPT
+ zi->ci.crypt_header_size = 0;
+ if ((err==Z_OK) && (password != NULL))
+ {
+ unsigned char bufHead[RAND_HEAD_LEN];
+ unsigned int sizeHead;
+ zi->ci.encrypt = 1;
+ zi->ci.pcrc_32_tab = get_crc_table();
+ /*init_keys(password,zi->ci.keys,zi->ci.pcrc_32_tab);*/
+
+ sizeHead=crypthead(password,bufHead,RAND_HEAD_LEN,zi->ci.keys,zi->ci.pcrc_32_tab,crcForCrypting);
+ zi->ci.crypt_header_size = sizeHead;
+
+ if (ZWRITE64(zi->z_filefunc,zi->filestream,bufHead,sizeHead) != sizeHead)
+ err = ZIP_ERRNO;
+ }
+# endif
+
+ if (err==Z_OK)
+ zi->in_opened_file_inzip = 1;
+ return err;
+}
+
+extern int ZEXPORT zipOpenNewFileInZip4 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
+ const void* extrafield_local, uInt size_extrafield_local,
+ const void* extrafield_global, uInt size_extrafield_global,
+ const char* comment, int method, int level, int raw,
+ int windowBits,int memLevel, int strategy,
+ const char* password, uLong crcForCrypting,
+ uLong versionMadeBy, uLong flagBase)
+{
+ return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+ extrafield_local, size_extrafield_local,
+ extrafield_global, size_extrafield_global,
+ comment, method, level, raw,
+ windowBits, memLevel, strategy,
+ password, crcForCrypting, versionMadeBy, flagBase, 0);
+}
+
+extern int ZEXPORT zipOpenNewFileInZip3 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
+ const void* extrafield_local, uInt size_extrafield_local,
+ const void* extrafield_global, uInt size_extrafield_global,
+ const char* comment, int method, int level, int raw,
+ int windowBits,int memLevel, int strategy,
+ const char* password, uLong crcForCrypting)
+{
+ return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+ extrafield_local, size_extrafield_local,
+ extrafield_global, size_extrafield_global,
+ comment, method, level, raw,
+ windowBits, memLevel, strategy,
+ password, crcForCrypting, VERSIONMADEBY, 0, 0);
+}
+
+extern int ZEXPORT zipOpenNewFileInZip3_64(zipFile file, const char* filename, const zip_fileinfo* zipfi,
+ const void* extrafield_local, uInt size_extrafield_local,
+ const void* extrafield_global, uInt size_extrafield_global,
+ const char* comment, int method, int level, int raw,
+ int windowBits,int memLevel, int strategy,
+ const char* password, uLong crcForCrypting, int zip64)
+{
+ return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+ extrafield_local, size_extrafield_local,
+ extrafield_global, size_extrafield_global,
+ comment, method, level, raw,
+ windowBits, memLevel, strategy,
+ password, crcForCrypting, VERSIONMADEBY, 0, zip64);
+}
+
+extern int ZEXPORT zipOpenNewFileInZip2(zipFile file, const char* filename, const zip_fileinfo* zipfi,
+ const void* extrafield_local, uInt size_extrafield_local,
+ const void* extrafield_global, uInt size_extrafield_global,
+ const char* comment, int method, int level, int raw)
+{
+ return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+ extrafield_local, size_extrafield_local,
+ extrafield_global, size_extrafield_global,
+ comment, method, level, raw,
+ -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
+ NULL, 0, VERSIONMADEBY, 0, 0);
+}
+
+extern int ZEXPORT zipOpenNewFileInZip2_64(zipFile file, const char* filename, const zip_fileinfo* zipfi,
+ const void* extrafield_local, uInt size_extrafield_local,
+ const void* extrafield_global, uInt size_extrafield_global,
+ const char* comment, int method, int level, int raw, int zip64)
+{
+ return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+ extrafield_local, size_extrafield_local,
+ extrafield_global, size_extrafield_global,
+ comment, method, level, raw,
+ -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
+ NULL, 0, VERSIONMADEBY, 0, zip64);
+}
+
+extern int ZEXPORT zipOpenNewFileInZip64 (zipFile file, const char* filename, const zip_fileinfo* zipfi,
+ const void* extrafield_local, uInt size_extrafield_local,
+ const void*extrafield_global, uInt size_extrafield_global,
+ const char* comment, int method, int level, int zip64)
+{
+ return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+ extrafield_local, size_extrafield_local,
+ extrafield_global, size_extrafield_global,
+ comment, method, level, 0,
+ -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
+ NULL, 0, VERSIONMADEBY, 0, zip64);
+}
+
+extern int ZEXPORT zipOpenNewFileInZip (zipFile file, const char* filename, const zip_fileinfo* zipfi,
+ const void* extrafield_local, uInt size_extrafield_local,
+ const void*extrafield_global, uInt size_extrafield_global,
+ const char* comment, int method, int level)
+{
+ return zipOpenNewFileInZip4_64 (file, filename, zipfi,
+ extrafield_local, size_extrafield_local,
+ extrafield_global, size_extrafield_global,
+ comment, method, level, 0,
+ -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
+ NULL, 0, VERSIONMADEBY, 0, 0);
+}
+
+local int zip64FlushWriteBuffer(zip64_internal* zi)
+{
+ int err=ZIP_OK;
+
+ if (zi->ci.encrypt != 0)
+ {
+#ifndef NOCRYPT
+ uInt i;
+ int t;
+ for (i=0;i<zi->ci.pos_in_buffered_data;i++)
+ zi->ci.buffered_data[i] = zencode(zi->ci.keys, zi->ci.pcrc_32_tab, zi->ci.buffered_data[i],t);
+#endif
+ }
+
+ if (ZWRITE64(zi->z_filefunc,zi->filestream,zi->ci.buffered_data,zi->ci.pos_in_buffered_data) != zi->ci.pos_in_buffered_data)
+ err = ZIP_ERRNO;
+
+ zi->ci.totalCompressedData += zi->ci.pos_in_buffered_data;
+
+#ifdef HAVE_BZIP2
+ if(zi->ci.method == Z_BZIP2ED)
+ {
+ zi->ci.totalUncompressedData += zi->ci.bstream.total_in_lo32;
+ zi->ci.bstream.total_in_lo32 = 0;
+ zi->ci.bstream.total_in_hi32 = 0;
+ }
+ else
+#endif
+ {
+ zi->ci.totalUncompressedData += zi->ci.stream.total_in;
+ zi->ci.stream.total_in = 0;
+ }
+
+
+ zi->ci.pos_in_buffered_data = 0;
+
+ return err;
+}
+
+extern int ZEXPORT zipWriteInFileInZip (zipFile file,const void* buf,unsigned int len)
+{
+ zip64_internal* zi;
+ int err=ZIP_OK;
+
+ if (file == NULL)
+ return ZIP_PARAMERROR;
+ zi = (zip64_internal*)file;
+
+ if (zi->in_opened_file_inzip == 0)
+ return ZIP_PARAMERROR;
+
+ zi->ci.crc32 = crc32(zi->ci.crc32,buf,(uInt)len);
+
+#ifdef HAVE_BZIP2
+ if(zi->ci.method == Z_BZIP2ED && (!zi->ci.raw))
+ {
+ zi->ci.bstream.next_in = (void*)buf;
+ zi->ci.bstream.avail_in = len;
+ err = BZ_RUN_OK;
+
+ while ((err==BZ_RUN_OK) && (zi->ci.bstream.avail_in>0))
+ {
+ if (zi->ci.bstream.avail_out == 0)
+ {
+ if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
+ err = ZIP_ERRNO;
+ zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;
+ zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
+ }
+
+
+ if(err != BZ_RUN_OK)
+ break;
+
+ if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
+ {
+ uLong uTotalOutBefore_lo = zi->ci.bstream.total_out_lo32;
+// uLong uTotalOutBefore_hi = zi->ci.bstream.total_out_hi32;
+ err=BZ2_bzCompress(&zi->ci.bstream, BZ_RUN);
+
+ zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore_lo) ;
+ }
+ }
+
+ if(err == BZ_RUN_OK)
+ err = ZIP_OK;
+ }
+ else
+#endif
+ {
+ zi->ci.stream.next_in = (Bytef*)buf;
+ zi->ci.stream.avail_in = len;
+
+ while ((err==ZIP_OK) && (zi->ci.stream.avail_in>0))
+ {
+ if (zi->ci.stream.avail_out == 0)
+ {
+ if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
+ err = ZIP_ERRNO;
+ zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
+ zi->ci.stream.next_out = zi->ci.buffered_data;
+ }
+
+
+ if(err != ZIP_OK)
+ break;
+
+ if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+ {
+ uLong uTotalOutBefore = zi->ci.stream.total_out;
+ err=deflate(&zi->ci.stream, Z_NO_FLUSH);
+ if(uTotalOutBefore > zi->ci.stream.total_out)
+ {
+ int bBreak = 0;
+ bBreak++;
+ }
+
+ zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
+ }
+ else
+ {
+ uInt copy_this,i;
+ if (zi->ci.stream.avail_in < zi->ci.stream.avail_out)
+ copy_this = zi->ci.stream.avail_in;
+ else
+ copy_this = zi->ci.stream.avail_out;
+
+ for (i = 0; i < copy_this; i++)
+ *(((char*)zi->ci.stream.next_out)+i) =
+ *(((const char*)zi->ci.stream.next_in)+i);
+ {
+ zi->ci.stream.avail_in -= copy_this;
+ zi->ci.stream.avail_out-= copy_this;
+ zi->ci.stream.next_in+= copy_this;
+ zi->ci.stream.next_out+= copy_this;
+ zi->ci.stream.total_in+= copy_this;
+ zi->ci.stream.total_out+= copy_this;
+ zi->ci.pos_in_buffered_data += copy_this;
+ }
+ }
+ }// while(...)
+ }
+
+ return err;
+}
+
+extern int ZEXPORT zipCloseFileInZipRaw (zipFile file, uLong uncompressed_size, uLong crc32)
+{
+ return zipCloseFileInZipRaw64 (file, uncompressed_size, crc32);
+}
+
+extern int ZEXPORT zipCloseFileInZipRaw64 (zipFile file, ZPOS64_T uncompressed_size, uLong crc32)
+{
+ zip64_internal* zi;
+ ZPOS64_T compressed_size;
+ uLong invalidValue = 0xffffffff;
+ short datasize = 0;
+ int err=ZIP_OK;
+
+ if (file == NULL)
+ return ZIP_PARAMERROR;
+ zi = (zip64_internal*)file;
+
+ if (zi->in_opened_file_inzip == 0)
+ return ZIP_PARAMERROR;
+ zi->ci.stream.avail_in = 0;
+
+ if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+ {
+ while (err==ZIP_OK)
+ {
+ uLong uTotalOutBefore;
+ if (zi->ci.stream.avail_out == 0)
+ {
+ if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
+ err = ZIP_ERRNO;
+ zi->ci.stream.avail_out = (uInt)Z_BUFSIZE;
+ zi->ci.stream.next_out = zi->ci.buffered_data;
+ }
+ uTotalOutBefore = zi->ci.stream.total_out;
+ err=deflate(&zi->ci.stream, Z_FINISH);
+ zi->ci.pos_in_buffered_data += (uInt)(zi->ci.stream.total_out - uTotalOutBefore) ;
+ }
+ }
+ else if ((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
+ {
+#ifdef HAVE_BZIP2
+ err = BZ_FINISH_OK;
+ while (err==BZ_FINISH_OK)
+ {
+ uLong uTotalOutBefore;
+ if (zi->ci.bstream.avail_out == 0)
+ {
+ if (zip64FlushWriteBuffer(zi) == ZIP_ERRNO)
+ err = ZIP_ERRNO;
+ zi->ci.bstream.avail_out = (uInt)Z_BUFSIZE;
+ zi->ci.bstream.next_out = (char*)zi->ci.buffered_data;
+ }
+ uTotalOutBefore = zi->ci.bstream.total_out_lo32;
+ err=BZ2_bzCompress(&zi->ci.bstream, BZ_FINISH);
+ if(err == BZ_STREAM_END)
+ err = Z_STREAM_END;
+
+ zi->ci.pos_in_buffered_data += (uInt)(zi->ci.bstream.total_out_lo32 - uTotalOutBefore);
+ }
+
+ if(err == BZ_FINISH_OK)
+ err = ZIP_OK;
+#endif
+ }
+
+ if (err==Z_STREAM_END)
+ err=ZIP_OK; /* this is normal */
+
+ if ((zi->ci.pos_in_buffered_data>0) && (err==ZIP_OK))
+ {
+ if (zip64FlushWriteBuffer(zi)==ZIP_ERRNO)
+ err = ZIP_ERRNO;
+ }
+
+ if ((zi->ci.method == Z_DEFLATED) && (!zi->ci.raw))
+ {
+ int tmp_err = deflateEnd(&zi->ci.stream);
+ if (err == ZIP_OK)
+ err = tmp_err;
+ zi->ci.stream_initialised = 0;
+ }
+#ifdef HAVE_BZIP2
+ else if((zi->ci.method == Z_BZIP2ED) && (!zi->ci.raw))
+ {
+ int tmperr = BZ2_bzCompressEnd(&zi->ci.bstream);
+ if (err==ZIP_OK)
+ err = tmperr;
+ zi->ci.stream_initialised = 0;
+ }
+#endif
+
+ if (!zi->ci.raw)
+ {
+ crc32 = (uLong)zi->ci.crc32;
+ uncompressed_size = zi->ci.totalUncompressedData;
+ }
+ compressed_size = zi->ci.totalCompressedData;
+
+# ifndef NOCRYPT
+ compressed_size += zi->ci.crypt_header_size;
+# endif
+
+ // update Current Item crc and sizes,
+ if(compressed_size >= 0xffffffff || uncompressed_size >= 0xffffffff || zi->ci.pos_local_header >= 0xffffffff)
+ {
+ /*version Made by*/
+ zip64local_putValue_inmemory(zi->ci.central_header+4,(uLong)45,2);
+ /*version needed*/
+ zip64local_putValue_inmemory(zi->ci.central_header+6,(uLong)45,2);
+
+ }
+
+ zip64local_putValue_inmemory(zi->ci.central_header+16,crc32,4); /*crc*/
+
+
+ if(compressed_size >= 0xffffffff)
+ zip64local_putValue_inmemory(zi->ci.central_header+20, invalidValue,4); /*compr size*/
+ else
+ zip64local_putValue_inmemory(zi->ci.central_header+20, compressed_size,4); /*compr size*/
+
+ /// set internal file attributes field
+ if (zi->ci.stream.data_type == Z_ASCII)
+ zip64local_putValue_inmemory(zi->ci.central_header+36,(uLong)Z_ASCII,2);
+
+ if(uncompressed_size >= 0xffffffff)
+ zip64local_putValue_inmemory(zi->ci.central_header+24, invalidValue,4); /*uncompr size*/
+ else
+ zip64local_putValue_inmemory(zi->ci.central_header+24, uncompressed_size,4); /*uncompr size*/
+
+ // Add ZIP64 extra info field for uncompressed size
+ if(uncompressed_size >= 0xffffffff)
+ datasize += 8;
+
+ // Add ZIP64 extra info field for compressed size
+ if(compressed_size >= 0xffffffff)
+ datasize += 8;
+
+ // Add ZIP64 extra info field for relative offset to local file header of current file
+ if(zi->ci.pos_local_header >= 0xffffffff)
+ datasize += 8;
+
+ if(datasize > 0)
+ {
+ char* p = NULL;
+
+ if((uLong)(datasize + 4) > zi->ci.size_centralExtraFree)
+ {
+ // we can not write more data to the buffer that we have room for.
+ return ZIP_BADZIPFILE;
+ }
+
+ p = zi->ci.central_header + zi->ci.size_centralheader;
+
+ // Add Extra Information Header for 'ZIP64 information'
+ zip64local_putValue_inmemory(p, 0x0001, 2); // HeaderID
+ p += 2;
+ zip64local_putValue_inmemory(p, datasize, 2); // DataSize
+ p += 2;
+
+ if(uncompressed_size >= 0xffffffff)
+ {
+ zip64local_putValue_inmemory(p, uncompressed_size, 8);
+ p += 8;
+ }
+
+ if(compressed_size >= 0xffffffff)
+ {
+ zip64local_putValue_inmemory(p, compressed_size, 8);
+ p += 8;
+ }
+
+ if(zi->ci.pos_local_header >= 0xffffffff)
+ {
+ zip64local_putValue_inmemory(p, zi->ci.pos_local_header, 8);
+ p += 8;
+ }
+
+ // Update how much extra free space we got in the memory buffer
+ // and increase the centralheader size so the new ZIP64 fields are included
+ // ( 4 below is the size of HeaderID and DataSize field )
+ zi->ci.size_centralExtraFree -= datasize + 4;
+ zi->ci.size_centralheader += datasize + 4;
+
+ // Update the extra info size field
+ zi->ci.size_centralExtra += datasize + 4;
+ zip64local_putValue_inmemory(zi->ci.central_header+30,(uLong)zi->ci.size_centralExtra,2);
+ }
+
+ if (err==ZIP_OK)
+ err = add_data_in_datablock(&zi->central_dir, zi->ci.central_header, (uLong)zi->ci.size_centralheader);
+
+ free(zi->ci.central_header);
+
+ if (err==ZIP_OK)
+ {
+ // Update the LocalFileHeader with the new values.
+
+ ZPOS64_T cur_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream);
+
+ if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_local_header + 14,ZLIB_FILEFUNC_SEEK_SET)!=0)
+ err = ZIP_ERRNO;
+
+ if (err==ZIP_OK)
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,crc32,4); /* crc 32, unknown */
+
+ if(uncompressed_size >= 0xffffffff || compressed_size >= 0xffffffff )
+ {
+ if(zi->ci.pos_zip64extrainfo > 0)
+ {
+ // Update the size in the ZIP64 extended field.
+ if (ZSEEK64(zi->z_filefunc,zi->filestream, zi->ci.pos_zip64extrainfo + 4,ZLIB_FILEFUNC_SEEK_SET)!=0)
+ err = ZIP_ERRNO;
+
+ if (err==ZIP_OK) /* compressed size, unknown */
+ err = zip64local_putValue(&zi->z_filefunc, zi->filestream, uncompressed_size, 8);
+
+ if (err==ZIP_OK) /* uncompressed size, unknown */
+ err = zip64local_putValue(&zi->z_filefunc, zi->filestream, compressed_size, 8);
+ }
+ else
+ err = ZIP_BADZIPFILE; // Caller passed zip64 = 0, so no room for zip64 info -> fatal
+ }
+ else
+ {
+ if (err==ZIP_OK) /* compressed size, unknown */
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,compressed_size,4);
+
+ if (err==ZIP_OK) /* uncompressed size, unknown */
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,uncompressed_size,4);
+ }
+
+ if (ZSEEK64(zi->z_filefunc,zi->filestream, cur_pos_inzip,ZLIB_FILEFUNC_SEEK_SET)!=0)
+ err = ZIP_ERRNO;
+ }
+
+ zi->number_entry ++;
+ zi->in_opened_file_inzip = 0;
+
+ return err;
+}
+
+extern int ZEXPORT zipCloseFileInZip (zipFile file)
+{
+ return zipCloseFileInZipRaw (file,0,0);
+}
+
+int Write_Zip64EndOfCentralDirectoryLocator(zip64_internal* zi, ZPOS64_T zip64eocd_pos_inzip)
+{
+ int err = ZIP_OK;
+ ZPOS64_T pos = zip64eocd_pos_inzip - zi->add_position_when_writing_offset;
+
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDLOCHEADERMAGIC,4);
+
+ /*num disks*/
+ if (err==ZIP_OK) /* number of the disk with the start of the central directory */
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);
+
+ /*relative offset*/
+ if (err==ZIP_OK) /* Relative offset to the Zip64EndOfCentralDirectory */
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream, pos,8);
+
+ /*total disks*/ /* Do not support spawning of disk so always say 1 here*/
+ if (err==ZIP_OK) /* number of the disk with the start of the central directory */
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)1,4);
+
+ return err;
+}
+
+int Write_Zip64EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip)
+{
+ int err = ZIP_OK;
+
+ uLong Zip64DataSize = 44;
+
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ZIP64ENDHEADERMAGIC,4);
+
+ if (err==ZIP_OK) /* size of this 'zip64 end of central directory' */
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)Zip64DataSize,8); // why ZPOS64_T of this ?
+
+ if (err==ZIP_OK) /* version made by */
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);
+
+ if (err==ZIP_OK) /* version needed */
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)45,2);
+
+ if (err==ZIP_OK) /* number of this disk */
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);
+
+ if (err==ZIP_OK) /* number of the disk with the start of the central directory */
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,4);
+
+ if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
+ err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8);
+
+ if (err==ZIP_OK) /* total number of entries in the central dir */
+ err = zip64local_putValue(&zi->z_filefunc, zi->filestream, zi->number_entry, 8);
+
+ if (err==ZIP_OK) /* size of the central directory */
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(ZPOS64_T)size_centraldir,8);
+
+ if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */
+ {
+ ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writing_offset;
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (ZPOS64_T)pos,8);
+ }
+ return err;
+}
+int Write_EndOfCentralDirectoryRecord(zip64_internal* zi, uLong size_centraldir, ZPOS64_T centraldir_pos_inzip)
+{
+ int err = ZIP_OK;
+
+ /*signature*/
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)ENDHEADERMAGIC,4);
+
+ if (err==ZIP_OK) /* number of this disk */
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
+
+ if (err==ZIP_OK) /* number of the disk with the start of the central directory */
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0,2);
+
+ if (err==ZIP_OK) /* total number of entries in the central dir on this disk */
+ {
+ {
+ if(zi->number_entry >= 0xFFFF)
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record
+ else
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
+ }
+ }
+
+ if (err==ZIP_OK) /* total number of entries in the central dir */
+ {
+ if(zi->number_entry >= 0xFFFF)
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)0xffff,2); // use value in ZIP64 record
+ else
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)zi->number_entry,2);
+ }
+
+ if (err==ZIP_OK) /* size of the central directory */
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_centraldir,4);
+
+ if (err==ZIP_OK) /* offset of start of central directory with respect to the starting disk number */
+ {
+ ZPOS64_T pos = centraldir_pos_inzip - zi->add_position_when_writing_offset;
+ if(pos >= 0xffffffff)
+ {
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)0xffffffff,4);
+ }
+ else
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream, (uLong)(centraldir_pos_inzip - zi->add_position_when_writing_offset),4);
+ }
+
+ return err;
+}
+
+int Write_GlobalComment(zip64_internal* zi, const char* global_comment)
+{
+ int err = ZIP_OK;
+ uInt size_global_comment = 0;
+
+ if(global_comment != NULL)
+ size_global_comment = (uInt)strlen(global_comment);
+
+ err = zip64local_putValue(&zi->z_filefunc,zi->filestream,(uLong)size_global_comment,2);
+
+ if (err == ZIP_OK && size_global_comment > 0)
+ {
+ if (ZWRITE64(zi->z_filefunc,zi->filestream, global_comment, size_global_comment) != size_global_comment)
+ err = ZIP_ERRNO;
+ }
+ return err;
+}
+
+extern int ZEXPORT zipClose (zipFile file, const char* global_comment)
+{
+ zip64_internal* zi;
+ int err = 0;
+ uLong size_centraldir = 0;
+ ZPOS64_T centraldir_pos_inzip;
+ ZPOS64_T pos;
+
+ if (file == NULL)
+ return ZIP_PARAMERROR;
+
+ zi = (zip64_internal*)file;
+
+ if (zi->in_opened_file_inzip == 1)
+ {
+ err = zipCloseFileInZip (file);
+ }
+
+#ifndef NO_ADDFILEINEXISTINGZIP
+ if (global_comment==NULL)
+ global_comment = zi->globalcomment;
+#endif
+
+ centraldir_pos_inzip = ZTELL64(zi->z_filefunc,zi->filestream);
+
+ if (err==ZIP_OK)
+ {
+ linkedlist_datablock_internal* ldi = zi->central_dir.first_block;
+ while (ldi!=NULL)
+ {
+ if ((err==ZIP_OK) && (ldi->filled_in_this_block>0))
+ {
+ if (ZWRITE64(zi->z_filefunc,zi->filestream, ldi->data, ldi->filled_in_this_block) != ldi->filled_in_this_block)
+ err = ZIP_ERRNO;
+ }
+
+ size_centraldir += ldi->filled_in_this_block;
+ ldi = ldi->next_datablock;
+ }
+ }
+ free_linkedlist(&(zi->central_dir));
+
+ pos = centraldir_pos_inzip - zi->add_position_when_writing_offset;
+ if(pos >= 0xffffffff || zi->number_entry > 0xFFFF)
+ {
+ ZPOS64_T Zip64EOCDpos = ZTELL64(zi->z_filefunc,zi->filestream);
+ Write_Zip64EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip);
+
+ Write_Zip64EndOfCentralDirectoryLocator(zi, Zip64EOCDpos);
+ }
+
+ if (err==ZIP_OK)
+ err = Write_EndOfCentralDirectoryRecord(zi, size_centraldir, centraldir_pos_inzip);
+
+ if(err == ZIP_OK)
+ err = Write_GlobalComment(zi, global_comment);
+
+ if (ZCLOSE64(zi->z_filefunc,zi->filestream) != 0)
+ if (err == ZIP_OK)
+ err = ZIP_ERRNO;
+
+#ifndef NO_ADDFILEINEXISTINGZIP
+ TRYFREE(zi->globalcomment);
+#endif
+ TRYFREE(zi);
+
+ return err;
+}
+
+extern int ZEXPORT zipRemoveExtraInfoBlock (char* pData, int* dataLen, short sHeader)
+{
+ char* p = pData;
+ int size = 0;
+ char* pNewHeader;
+ char* pTmp;
+ short header;
+ short dataSize;
+
+ int retVal = ZIP_OK;
+
+ if(pData == NULL || *dataLen < 4)
+ return ZIP_PARAMERROR;
+
+ pNewHeader = (char*)ALLOC(*dataLen);
+ pTmp = pNewHeader;
+
+ while(p < (pData + *dataLen))
+ {
+ header = *(short*)p;
+ dataSize = *(((short*)p)+1);
+
+ if( header == sHeader ) // Header found.
+ {
+ p += dataSize + 4; // skip it. do not copy to temp buffer
+ }
+ else
+ {
+ // Extra Info block should not be removed, So copy it to the temp buffer.
+ memcpy(pTmp, p, dataSize + 4);
+ p += dataSize + 4;
+ size += dataSize + 4;
+ }
+
+ }
+
+ if(size < *dataLen)
+ {
+ // clean old extra info block.
+ memset(pData,0, *dataLen);
+
+ // copy the new extra info block over the old
+ if(size > 0)
+ memcpy(pData, pNewHeader, size);
+
+ // set the new extra info size
+ *dataLen = size;
+
+ retVal = ZIP_OK;
+ }
+ else
+ retVal = ZIP_ERRNO;
+
+ TRYFREE(pNewHeader);
+
+ return retVal;
+}
diff --git a/zlib/contrib/minizip/zip.h b/zlib/contrib/minizip/zip.h
new file mode 100644
index 000000000..8aaebb623
--- /dev/null
+++ b/zlib/contrib/minizip/zip.h
@@ -0,0 +1,362 @@
+/* zip.h -- IO on .zip files using zlib
+ Version 1.1, February 14h, 2010
+ part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html )
+
+ Modifications for Zip64 support
+ Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
+
+ For more info read MiniZip_info.txt
+
+ ---------------------------------------------------------------------------
+
+ Condition of use and distribution are the same than zlib :
+
+ 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.
+
+ ---------------------------------------------------------------------------
+
+ Changes
+
+ See header of zip.h
+
+*/
+
+#ifndef _zip12_H
+#define _zip12_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+//#define HAVE_BZIP2
+
+#ifndef _ZLIB_H
+#include "zlib.h"
+#endif
+
+#ifndef _ZLIBIOAPI_H
+#include "ioapi.h"
+#endif
+
+#ifdef HAVE_BZIP2
+#include "bzlib.h"
+#endif
+
+#define Z_BZIP2ED 12
+
+#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
+/* like the STRICT of WIN32, we define a pointer that cannot be converted
+ from (void*) without cast */
+typedef struct TagzipFile__ { int unused; } zipFile__;
+typedef zipFile__ *zipFile;
+#else
+typedef voidp zipFile;
+#endif
+
+#define ZIP_OK (0)
+#define ZIP_EOF (0)
+#define ZIP_ERRNO (Z_ERRNO)
+#define ZIP_PARAMERROR (-102)
+#define ZIP_BADZIPFILE (-103)
+#define ZIP_INTERNALERROR (-104)
+
+#ifndef DEF_MEM_LEVEL
+# if MAX_MEM_LEVEL >= 8
+# define DEF_MEM_LEVEL 8
+# else
+# define DEF_MEM_LEVEL MAX_MEM_LEVEL
+# endif
+#endif
+/* default memLevel */
+
+/* tm_zip contain date/time info */
+typedef struct tm_zip_s
+{
+ uInt tm_sec; /* seconds after the minute - [0,59] */
+ uInt tm_min; /* minutes after the hour - [0,59] */
+ uInt tm_hour; /* hours since midnight - [0,23] */
+ uInt tm_mday; /* day of the month - [1,31] */
+ uInt tm_mon; /* months since January - [0,11] */
+ uInt tm_year; /* years - [1980..2044] */
+} tm_zip;
+
+typedef struct
+{
+ tm_zip tmz_date; /* date in understandable format */
+ uLong dosDate; /* if dos_date == 0, tmu_date is used */
+/* uLong flag; */ /* general purpose bit flag 2 bytes */
+
+ uLong internal_fa; /* internal file attributes 2 bytes */
+ uLong external_fa; /* external file attributes 4 bytes */
+} zip_fileinfo;
+
+typedef const char* zipcharpc;
+
+
+#define APPEND_STATUS_CREATE (0)
+#define APPEND_STATUS_CREATEAFTER (1)
+#define APPEND_STATUS_ADDINZIP (2)
+
+extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));
+extern zipFile ZEXPORT zipOpen64 OF((const void *pathname, int append));
+/*
+ Create a zipfile.
+ pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on
+ an Unix computer "zlib/zlib113.zip".
+ if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip
+ will be created at the end of the file.
+ (useful if the file contain a self extractor code)
+ if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will
+ add files in existing zip (be sure you don't add file that doesn't exist)
+ If the zipfile cannot be opened, the return value is NULL.
+ Else, the return value is a zipFile Handle, usable with other function
+ of this zip package.
+*/
+
+/* Note : there is no delete function into a zipfile.
+ If you want delete file into a zipfile, you must open a zipfile, and create another
+ Of couse, you can use RAW reading and writing to copy the file you did not want delte
+*/
+
+extern zipFile ZEXPORT zipOpen2 OF((const char *pathname,
+ int append,
+ zipcharpc* globalcomment,
+ zlib_filefunc_def* pzlib_filefunc_def));
+
+extern zipFile ZEXPORT zipOpen2_64 OF((const void *pathname,
+ int append,
+ zipcharpc* globalcomment,
+ zlib_filefunc64_def* pzlib_filefunc_def));
+
+extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
+ const char* filename,
+ const zip_fileinfo* zipfi,
+ const void* extrafield_local,
+ uInt size_extrafield_local,
+ const void* extrafield_global,
+ uInt size_extrafield_global,
+ const char* comment,
+ int method,
+ int level));
+
+extern int ZEXPORT zipOpenNewFileInZip64 OF((zipFile file,
+ const char* filename,
+ const zip_fileinfo* zipfi,
+ const void* extrafield_local,
+ uInt size_extrafield_local,
+ const void* extrafield_global,
+ uInt size_extrafield_global,
+ const char* comment,
+ int method,
+ int level,
+ int zip64));
+
+/*
+ Open a file in the ZIP for writing.
+ filename : the filename in zip (if NULL, '-' without quote will be used
+ *zipfi contain supplemental information
+ if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
+ contains the extrafield data the the local header
+ if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
+ contains the extrafield data the the local header
+ if comment != NULL, comment contain the comment string
+ method contain the compression method (0 for store, Z_DEFLATED for deflate)
+ level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
+ zip64 is set to 1 if a zip64 extended information block should be added to the local file header.
+ this MUST be '1' if the uncompressed size is >= 0xffffffff.
+
+*/
+
+
+extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
+ const char* filename,
+ const zip_fileinfo* zipfi,
+ const void* extrafield_local,
+ uInt size_extrafield_local,
+ const void* extrafield_global,
+ uInt size_extrafield_global,
+ const char* comment,
+ int method,
+ int level,
+ int raw));
+
+
+extern int ZEXPORT zipOpenNewFileInZip2_64 OF((zipFile file,
+ const char* filename,
+ const zip_fileinfo* zipfi,
+ const void* extrafield_local,
+ uInt size_extrafield_local,
+ const void* extrafield_global,
+ uInt size_extrafield_global,
+ const char* comment,
+ int method,
+ int level,
+ int raw,
+ int zip64));
+/*
+ Same than zipOpenNewFileInZip, except if raw=1, we write raw file
+ */
+
+extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
+ const char* filename,
+ const zip_fileinfo* zipfi,
+ const void* extrafield_local,
+ uInt size_extrafield_local,
+ const void* extrafield_global,
+ uInt size_extrafield_global,
+ const char* comment,
+ int method,
+ int level,
+ int raw,
+ int windowBits,
+ int memLevel,
+ int strategy,
+ const char* password,
+ uLong crcForCrypting));
+
+extern int ZEXPORT zipOpenNewFileInZip3_64 OF((zipFile file,
+ const char* filename,
+ const zip_fileinfo* zipfi,
+ const void* extrafield_local,
+ uInt size_extrafield_local,
+ const void* extrafield_global,
+ uInt size_extrafield_global,
+ const char* comment,
+ int method,
+ int level,
+ int raw,
+ int windowBits,
+ int memLevel,
+ int strategy,
+ const char* password,
+ uLong crcForCrypting,
+ int zip64
+ ));
+
+/*
+ Same than zipOpenNewFileInZip2, except
+ windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
+ password : crypting password (NULL for no crypting)
+ crcForCrypting : crc of file to compress (needed for crypting)
+ */
+
+extern int ZEXPORT zipOpenNewFileInZip4 OF((zipFile file,
+ const char* filename,
+ const zip_fileinfo* zipfi,
+ const void* extrafield_local,
+ uInt size_extrafield_local,
+ const void* extrafield_global,
+ uInt size_extrafield_global,
+ const char* comment,
+ int method,
+ int level,
+ int raw,
+ int windowBits,
+ int memLevel,
+ int strategy,
+ const char* password,
+ uLong crcForCrypting,
+ uLong versionMadeBy,
+ uLong flagBase
+ ));
+
+
+extern int ZEXPORT zipOpenNewFileInZip4_64 OF((zipFile file,
+ const char* filename,
+ const zip_fileinfo* zipfi,
+ const void* extrafield_local,
+ uInt size_extrafield_local,
+ const void* extrafield_global,
+ uInt size_extrafield_global,
+ const char* comment,
+ int method,
+ int level,
+ int raw,
+ int windowBits,
+ int memLevel,
+ int strategy,
+ const char* password,
+ uLong crcForCrypting,
+ uLong versionMadeBy,
+ uLong flagBase,
+ int zip64
+ ));
+/*
+ Same than zipOpenNewFileInZip4, except
+ versionMadeBy : value for Version made by field
+ flag : value for flag field (compression level info will be added)
+ */
+
+
+extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
+ const void* buf,
+ unsigned len));
+/*
+ Write data in the zipfile
+*/
+
+extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
+/*
+ Close the current file in the zipfile
+*/
+
+extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
+ uLong uncompressed_size,
+ uLong crc32));
+
+extern int ZEXPORT zipCloseFileInZipRaw64 OF((zipFile file,
+ ZPOS64_T uncompressed_size,
+ uLong crc32));
+
+/*
+ Close the current file in the zipfile, for file opened with
+ parameter raw=1 in zipOpenNewFileInZip2
+ uncompressed_size and crc32 are value for the uncompressed size
+*/
+
+extern int ZEXPORT zipClose OF((zipFile file,
+ const char* global_comment));
+/*
+ Close the zipfile
+*/
+
+
+extern int ZEXPORT zipRemoveExtraInfoBlock OF((char* pData, int* dataLen, short sHeader));
+/*
+ zipRemoveExtraInfoBlock - Added by Mathias Svensson
+
+ Remove extra information block from a extra information data for the local file header or central directory header
+
+ It is needed to remove ZIP64 extra information blocks when before data is written if using RAW mode.
+
+ 0x0001 is the signature header for the ZIP64 extra information blocks
+
+ usage.
+ Remove ZIP64 Extra information from a central director extra field data
+ zipRemoveExtraInfoBlock(pCenDirExtraFieldData, &nCenDirExtraFieldDataLen, 0x0001);
+
+ Remove ZIP64 Extra information from a Local File Header extra field data
+ zipRemoveExtraInfoBlock(pLocalHeaderExtraFieldData, &nLocalHeaderExtraFieldDataLen, 0x0001);
+*/
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _zip64_H */
diff --git a/zlib/contrib/puff/Makefile b/zlib/contrib/puff/Makefile
new file mode 100644
index 000000000..0e2594c80
--- /dev/null
+++ b/zlib/contrib/puff/Makefile
@@ -0,0 +1,42 @@
+CFLAGS=-O
+
+puff: puff.o pufftest.o
+
+puff.o: puff.h
+
+pufftest.o: puff.h
+
+test: puff
+ puff zeros.raw
+
+puft: puff.c puff.h pufftest.o
+ cc -fprofile-arcs -ftest-coverage -o puft puff.c pufftest.o
+
+# puff full coverage test (should say 100%)
+cov: puft
+ @rm -f *.gcov *.gcda
+ @puft -w zeros.raw 2>&1 | cat > /dev/null
+ @echo '04' | xxd -r -p | puft 2> /dev/null || test $$? -eq 2
+ @echo '00' | xxd -r -p | puft 2> /dev/null || test $$? -eq 2
+ @echo '00 00 00 00 00' | xxd -r -p | puft 2> /dev/null || test $$? -eq 254
+ @echo '00 01 00 fe ff' | xxd -r -p | puft 2> /dev/null || test $$? -eq 2
+ @echo '01 01 00 fe ff 0a' | xxd -r -p | puft -f 2>&1 | cat > /dev/null
+ @echo '02 7e ff ff' | xxd -r -p | puft 2> /dev/null || test $$? -eq 246
+ @echo '02' | xxd -r -p | puft 2> /dev/null || test $$? -eq 2
+ @echo '04 80 49 92 24 49 92 24 0f b4 ff ff c3 04' | xxd -r -p | puft 2> /dev/null || test $$? -eq 2
+ @echo '04 80 49 92 24 49 92 24 71 ff ff 93 11 00' | xxd -r -p | puft 2> /dev/null || test $$? -eq 249
+ @echo '04 c0 81 08 00 00 00 00 20 7f eb 0b 00 00' | xxd -r -p | puft 2> /dev/null || test $$? -eq 246
+ @echo '0b 00 00' | xxd -r -p | puft -f 2>&1 | cat > /dev/null
+ @echo '1a 07' | xxd -r -p | puft 2> /dev/null || test $$? -eq 246
+ @echo '0c c0 81 00 00 00 00 00 90 ff 6b 04' | xxd -r -p | puft 2> /dev/null || test $$? -eq 245
+ @puft -f zeros.raw 2>&1 | cat > /dev/null
+ @echo 'fc 00 00' | xxd -r -p | puft 2> /dev/null || test $$? -eq 253
+ @echo '04 00 fe ff' | xxd -r -p | puft 2> /dev/null || test $$? -eq 252
+ @echo '04 00 24 49' | xxd -r -p | puft 2> /dev/null || test $$? -eq 251
+ @echo '04 80 49 92 24 49 92 24 0f b4 ff ff c3 84' | xxd -r -p | puft 2> /dev/null || test $$? -eq 248
+ @echo '04 00 24 e9 ff ff' | xxd -r -p | puft 2> /dev/null || test $$? -eq 250
+ @echo '04 00 24 e9 ff 6d' | xxd -r -p | puft 2> /dev/null || test $$? -eq 247
+ @gcov -n puff.c
+
+clean:
+ rm -f puff puft *.o *.gc*
diff --git a/zlib/contrib/puff/README b/zlib/contrib/puff/README
new file mode 100644
index 000000000..bbc4cb595
--- /dev/null
+++ b/zlib/contrib/puff/README
@@ -0,0 +1,63 @@
+Puff -- A Simple Inflate
+3 Mar 2003
+Mark Adler
+madler@alumni.caltech.edu
+
+What this is --
+
+puff.c provides the routine puff() to decompress the deflate data format. It
+does so more slowly than zlib, but the code is about one-fifth the size of the
+inflate code in zlib, and written to be very easy to read.
+
+Why I wrote this --
+
+puff.c was written to document the deflate format unambiguously, by virtue of
+being working C code. It is meant to supplement RFC 1951, which formally
+describes the deflate format. I have received many questions on details of the
+deflate format, and I hope that reading this code will answer those questions.
+puff.c is heavily commented with details of the deflate format, especially
+those little nooks and cranies of the format that might not be obvious from a
+specification.
+
+puff.c may also be useful in applications where code size or memory usage is a
+very limited resource, and speed is not as important.
+
+How to use it --
+
+Well, most likely you should just be reading puff.c and using zlib for actual
+applications, but if you must ...
+
+Include puff.h in your code, which provides this prototype:
+
+int puff(unsigned char *dest, /* pointer to destination pointer */
+ unsigned long *destlen, /* amount of output space */
+ unsigned char *source, /* pointer to source data pointer */
+ unsigned long *sourcelen); /* amount of input available */
+
+Then you can call puff() to decompress a deflate stream that is in memory in
+its entirety at source, to a sufficiently sized block of memory for the
+decompressed data at dest. puff() is the only external symbol in puff.c The
+only C library functions that puff.c needs are setjmp() and longjmp(), which
+are used to simplify error checking in the code to improve readabilty. puff.c
+does no memory allocation, and uses less than 2K bytes off of the stack.
+
+If destlen is not enough space for the uncompressed data, then inflate will
+return an error without writing more than destlen bytes. Note that this means
+that in order to decompress the deflate data successfully, you need to know
+the size of the uncompressed data ahead of time.
+
+If needed, puff() can determine the size of the uncompressed data with no
+output space. This is done by passing dest equal to (unsigned char *)0. Then
+the initial value of *destlen is ignored and *destlen is set to the length of
+the uncompressed data. So if the size of the uncompressed data is not known,
+then two passes of puff() can be used--first to determine the size, and second
+to do the actual inflation after allocating the appropriate memory. Not
+pretty, but it works. (This is one of the reasons you should be using zlib.)
+
+The deflate format is self-terminating. If the deflate stream does not end
+in *sourcelen bytes, puff() will return an error without reading at or past
+endsource.
+
+On return, *sourcelen is updated to the amount of input data consumed, and
+*destlen is updated to the size of the uncompressed data. See the comments
+in puff.c for the possible return codes for puff().
diff --git a/zlib/contrib/puff/puff.c b/zlib/contrib/puff/puff.c
new file mode 100644
index 000000000..c6c90d714
--- /dev/null
+++ b/zlib/contrib/puff/puff.c
@@ -0,0 +1,840 @@
+/*
+ * puff.c
+ * Copyright (C) 2002-2013 Mark Adler
+ * For conditions of distribution and use, see copyright notice in puff.h
+ * version 2.3, 21 Jan 2013
+ *
+ * puff.c is a simple inflate written to be an unambiguous way to specify the
+ * deflate format. It is not written for speed but rather simplicity. As a
+ * side benefit, this code might actually be useful when small code is more
+ * important than speed, such as bootstrap applications. For typical deflate
+ * data, zlib's inflate() is about four times as fast as puff(). zlib's
+ * inflate compiles to around 20K on my machine, whereas puff.c compiles to
+ * around 4K on my machine (a PowerPC using GNU cc). If the faster decode()
+ * function here is used, then puff() is only twice as slow as zlib's
+ * inflate().
+ *
+ * All dynamically allocated memory comes from the stack. The stack required
+ * is less than 2K bytes. This code is compatible with 16-bit int's and
+ * assumes that long's are at least 32 bits. puff.c uses the short data type,
+ * assumed to be 16 bits, for arrays in order to conserve memory. The code
+ * works whether integers are stored big endian or little endian.
+ *
+ * In the comments below are "Format notes" that describe the inflate process
+ * and document some of the less obvious aspects of the format. This source
+ * code is meant to supplement RFC 1951, which formally describes the deflate
+ * format:
+ *
+ * http://www.zlib.org/rfc-deflate.html
+ */
+
+/*
+ * Change history:
+ *
+ * 1.0 10 Feb 2002 - First version
+ * 1.1 17 Feb 2002 - Clarifications of some comments and notes
+ * - Update puff() dest and source pointers on negative
+ * errors to facilitate debugging deflators
+ * - Remove longest from struct huffman -- not needed
+ * - Simplify offs[] index in construct()
+ * - Add input size and checking, using longjmp() to
+ * maintain easy readability
+ * - Use short data type for large arrays
+ * - Use pointers instead of long to specify source and
+ * destination sizes to avoid arbitrary 4 GB limits
+ * 1.2 17 Mar 2002 - Add faster version of decode(), doubles speed (!),
+ * but leave simple version for readabilty
+ * - Make sure invalid distances detected if pointers
+ * are 16 bits
+ * - Fix fixed codes table error
+ * - Provide a scanning mode for determining size of
+ * uncompressed data
+ * 1.3 20 Mar 2002 - Go back to lengths for puff() parameters [Gailly]
+ * - Add a puff.h file for the interface
+ * - Add braces in puff() for else do [Gailly]
+ * - Use indexes instead of pointers for readability
+ * 1.4 31 Mar 2002 - Simplify construct() code set check
+ * - Fix some comments
+ * - Add FIXLCODES #define
+ * 1.5 6 Apr 2002 - Minor comment fixes
+ * 1.6 7 Aug 2002 - Minor format changes
+ * 1.7 3 Mar 2003 - Added test code for distribution
+ * - Added zlib-like license
+ * 1.8 9 Jan 2004 - Added some comments on no distance codes case
+ * 1.9 21 Feb 2008 - Fix bug on 16-bit integer architectures [Pohland]
+ * - Catch missing end-of-block symbol error
+ * 2.0 25 Jul 2008 - Add #define to permit distance too far back
+ * - Add option in TEST code for puff to write the data
+ * - Add option in TEST code to skip input bytes
+ * - Allow TEST code to read from piped stdin
+ * 2.1 4 Apr 2010 - Avoid variable initialization for happier compilers
+ * - Avoid unsigned comparisons for even happier compilers
+ * 2.2 25 Apr 2010 - Fix bug in variable initializations [Oberhumer]
+ * - Add const where appropriate [Oberhumer]
+ * - Split if's and ?'s for coverage testing
+ * - Break out test code to separate file
+ * - Move NIL to puff.h
+ * - Allow incomplete code only if single code length is 1
+ * - Add full code coverage test to Makefile
+ * 2.3 21 Jan 2013 - Check for invalid code length codes in dynamic blocks
+ */
+
+#include <setjmp.h> /* for setjmp(), longjmp(), and jmp_buf */
+#include "puff.h" /* prototype for puff() */
+
+#define local static /* for local function definitions */
+
+/*
+ * Maximums for allocations and loops. It is not useful to change these --
+ * they are fixed by the deflate format.
+ */
+#define MAXBITS 15 /* maximum bits in a code */
+#define MAXLCODES 286 /* maximum number of literal/length codes */
+#define MAXDCODES 30 /* maximum number of distance codes */
+#define MAXCODES (MAXLCODES+MAXDCODES) /* maximum codes lengths to read */
+#define FIXLCODES 288 /* number of fixed literal/length codes */
+
+/* input and output state */
+struct state {
+ /* output state */
+ unsigned char *out; /* output buffer */
+ unsigned long outlen; /* available space at out */
+ unsigned long outcnt; /* bytes written to out so far */
+
+ /* input state */
+ const unsigned char *in; /* input buffer */
+ unsigned long inlen; /* available input at in */
+ unsigned long incnt; /* bytes read so far */
+ int bitbuf; /* bit buffer */
+ int bitcnt; /* number of bits in bit buffer */
+
+ /* input limit error return state for bits() and decode() */
+ jmp_buf env;
+};
+
+/*
+ * Return need bits from the input stream. This always leaves less than
+ * eight bits in the buffer. bits() works properly for need == 0.
+ *
+ * Format notes:
+ *
+ * - Bits are stored in bytes from the least significant bit to the most
+ * significant bit. Therefore bits are dropped from the bottom of the bit
+ * buffer, using shift right, and new bytes are appended to the top of the
+ * bit buffer, using shift left.
+ */
+local int bits(struct state *s, int need)
+{
+ long val; /* bit accumulator (can use up to 20 bits) */
+
+ /* load at least need bits into val */
+ val = s->bitbuf;
+ while (s->bitcnt < need) {
+ if (s->incnt == s->inlen)
+ longjmp(s->env, 1); /* out of input */
+ val |= (long)(s->in[s->incnt++]) << s->bitcnt; /* load eight bits */
+ s->bitcnt += 8;
+ }
+
+ /* drop need bits and update buffer, always zero to seven bits left */
+ s->bitbuf = (int)(val >> need);
+ s->bitcnt -= need;
+
+ /* return need bits, zeroing the bits above that */
+ return (int)(val & ((1L << need) - 1));
+}
+
+/*
+ * Process a stored block.
+ *
+ * Format notes:
+ *
+ * - After the two-bit stored block type (00), the stored block length and
+ * stored bytes are byte-aligned for fast copying. Therefore any leftover
+ * bits in the byte that has the last bit of the type, as many as seven, are
+ * discarded. The value of the discarded bits are not defined and should not
+ * be checked against any expectation.
+ *
+ * - The second inverted copy of the stored block length does not have to be
+ * checked, but it's probably a good idea to do so anyway.
+ *
+ * - A stored block can have zero length. This is sometimes used to byte-align
+ * subsets of the compressed data for random access or partial recovery.
+ */
+local int stored(struct state *s)
+{
+ unsigned len; /* length of stored block */
+
+ /* discard leftover bits from current byte (assumes s->bitcnt < 8) */
+ s->bitbuf = 0;
+ s->bitcnt = 0;
+
+ /* get length and check against its one's complement */
+ if (s->incnt + 4 > s->inlen)
+ return 2; /* not enough input */
+ len = s->in[s->incnt++];
+ len |= s->in[s->incnt++] << 8;
+ if (s->in[s->incnt++] != (~len & 0xff) ||
+ s->in[s->incnt++] != ((~len >> 8) & 0xff))
+ return -2; /* didn't match complement! */
+
+ /* copy len bytes from in to out */
+ if (s->incnt + len > s->inlen)
+ return 2; /* not enough input */
+ if (s->out != NIL) {
+ if (s->outcnt + len > s->outlen)
+ return 1; /* not enough output space */
+ while (len--)
+ s->out[s->outcnt++] = s->in[s->incnt++];
+ }
+ else { /* just scanning */
+ s->outcnt += len;
+ s->incnt += len;
+ }
+
+ /* done with a valid stored block */
+ return 0;
+}
+
+/*
+ * Huffman code decoding tables. count[1..MAXBITS] is the number of symbols of
+ * each length, which for a canonical code are stepped through in order.
+ * symbol[] are the symbol values in canonical order, where the number of
+ * entries is the sum of the counts in count[]. The decoding process can be
+ * seen in the function decode() below.
+ */
+struct huffman {
+ short *count; /* number of symbols of each length */
+ short *symbol; /* canonically ordered symbols */
+};
+
+/*
+ * Decode a code from the stream s using huffman table h. Return the symbol or
+ * a negative value if there is an error. If all of the lengths are zero, i.e.
+ * an empty code, or if the code is incomplete and an invalid code is received,
+ * then -10 is returned after reading MAXBITS bits.
+ *
+ * Format notes:
+ *
+ * - The codes as stored in the compressed data are bit-reversed relative to
+ * a simple integer ordering of codes of the same lengths. Hence below the
+ * bits are pulled from the compressed data one at a time and used to
+ * build the code value reversed from what is in the stream in order to
+ * permit simple integer comparisons for decoding. A table-based decoding
+ * scheme (as used in zlib) does not need to do this reversal.
+ *
+ * - The first code for the shortest length is all zeros. Subsequent codes of
+ * the same length are simply integer increments of the previous code. When
+ * moving up a length, a zero bit is appended to the code. For a complete
+ * code, the last code of the longest length will be all ones.
+ *
+ * - Incomplete codes are handled by this decoder, since they are permitted
+ * in the deflate format. See the format notes for fixed() and dynamic().
+ */
+#ifdef SLOW
+local int decode(struct state *s, const struct huffman *h)
+{
+ int len; /* current number of bits in code */
+ int code; /* len bits being decoded */
+ int first; /* first code of length len */
+ int count; /* number of codes of length len */
+ int index; /* index of first code of length len in symbol table */
+
+ code = first = index = 0;
+ for (len = 1; len <= MAXBITS; len++) {
+ code |= bits(s, 1); /* get next bit */
+ count = h->count[len];
+ if (code - count < first) /* if length len, return symbol */
+ return h->symbol[index + (code - first)];
+ index += count; /* else update for next length */
+ first += count;
+ first <<= 1;
+ code <<= 1;
+ }
+ return -10; /* ran out of codes */
+}
+
+/*
+ * A faster version of decode() for real applications of this code. It's not
+ * as readable, but it makes puff() twice as fast. And it only makes the code
+ * a few percent larger.
+ */
+#else /* !SLOW */
+local int decode(struct state *s, const struct huffman *h)
+{
+ int len; /* current number of bits in code */
+ int code; /* len bits being decoded */
+ int first; /* first code of length len */
+ int count; /* number of codes of length len */
+ int index; /* index of first code of length len in symbol table */
+ int bitbuf; /* bits from stream */
+ int left; /* bits left in next or left to process */
+ short *next; /* next number of codes */
+
+ bitbuf = s->bitbuf;
+ left = s->bitcnt;
+ code = first = index = 0;
+ len = 1;
+ next = h->count + 1;
+ while (1) {
+ while (left--) {
+ code |= bitbuf & 1;
+ bitbuf >>= 1;
+ count = *next++;
+ if (code - count < first) { /* if length len, return symbol */
+ s->bitbuf = bitbuf;
+ s->bitcnt = (s->bitcnt - len) & 7;
+ return h->symbol[index + (code - first)];
+ }
+ index += count; /* else update for next length */
+ first += count;
+ first <<= 1;
+ code <<= 1;
+ len++;
+ }
+ left = (MAXBITS+1) - len;
+ if (left == 0)
+ break;
+ if (s->incnt == s->inlen)
+ longjmp(s->env, 1); /* out of input */
+ bitbuf = s->in[s->incnt++];
+ if (left > 8)
+ left = 8;
+ }
+ return -10; /* ran out of codes */
+}
+#endif /* SLOW */
+
+/*
+ * Given the list of code lengths length[0..n-1] representing a canonical
+ * Huffman code for n symbols, construct the tables required to decode those
+ * codes. Those tables are the number of codes of each length, and the symbols
+ * sorted by length, retaining their original order within each length. The
+ * return value is zero for a complete code set, negative for an over-
+ * subscribed code set, and positive for an incomplete code set. The tables
+ * can be used if the return value is zero or positive, but they cannot be used
+ * if the return value is negative. If the return value is zero, it is not
+ * possible for decode() using that table to return an error--any stream of
+ * enough bits will resolve to a symbol. If the return value is positive, then
+ * it is possible for decode() using that table to return an error for received
+ * codes past the end of the incomplete lengths.
+ *
+ * Not used by decode(), but used for error checking, h->count[0] is the number
+ * of the n symbols not in the code. So n - h->count[0] is the number of
+ * codes. This is useful for checking for incomplete codes that have more than
+ * one symbol, which is an error in a dynamic block.
+ *
+ * Assumption: for all i in 0..n-1, 0 <= length[i] <= MAXBITS
+ * This is assured by the construction of the length arrays in dynamic() and
+ * fixed() and is not verified by construct().
+ *
+ * Format notes:
+ *
+ * - Permitted and expected examples of incomplete codes are one of the fixed
+ * codes and any code with a single symbol which in deflate is coded as one
+ * bit instead of zero bits. See the format notes for fixed() and dynamic().
+ *
+ * - Within a given code length, the symbols are kept in ascending order for
+ * the code bits definition.
+ */
+local int construct(struct huffman *h, const short *length, int n)
+{
+ int symbol; /* current symbol when stepping through length[] */
+ int len; /* current length when stepping through h->count[] */
+ int left; /* number of possible codes left of current length */
+ short offs[MAXBITS+1]; /* offsets in symbol table for each length */
+
+ /* count number of codes of each length */
+ for (len = 0; len <= MAXBITS; len++)
+ h->count[len] = 0;
+ for (symbol = 0; symbol < n; symbol++)
+ (h->count[length[symbol]])++; /* assumes lengths are within bounds */
+ if (h->count[0] == n) /* no codes! */
+ return 0; /* complete, but decode() will fail */
+
+ /* check for an over-subscribed or incomplete set of lengths */
+ left = 1; /* one possible code of zero length */
+ for (len = 1; len <= MAXBITS; len++) {
+ left <<= 1; /* one more bit, double codes left */
+ left -= h->count[len]; /* deduct count from possible codes */
+ if (left < 0)
+ return left; /* over-subscribed--return negative */
+ } /* left > 0 means incomplete */
+
+ /* generate offsets into symbol table for each length for sorting */
+ offs[1] = 0;
+ for (len = 1; len < MAXBITS; len++)
+ offs[len + 1] = offs[len] + h->count[len];
+
+ /*
+ * put symbols in table sorted by length, by symbol order within each
+ * length
+ */
+ for (symbol = 0; symbol < n; symbol++)
+ if (length[symbol] != 0)
+ h->symbol[offs[length[symbol]]++] = symbol;
+
+ /* return zero for complete set, positive for incomplete set */
+ return left;
+}
+
+/*
+ * Decode literal/length and distance codes until an end-of-block code.
+ *
+ * Format notes:
+ *
+ * - Compressed data that is after the block type if fixed or after the code
+ * description if dynamic is a combination of literals and length/distance
+ * pairs terminated by and end-of-block code. Literals are simply Huffman
+ * coded bytes. A length/distance pair is a coded length followed by a
+ * coded distance to represent a string that occurs earlier in the
+ * uncompressed data that occurs again at the current location.
+ *
+ * - Literals, lengths, and the end-of-block code are combined into a single
+ * code of up to 286 symbols. They are 256 literals (0..255), 29 length
+ * symbols (257..285), and the end-of-block symbol (256).
+ *
+ * - There are 256 possible lengths (3..258), and so 29 symbols are not enough
+ * to represent all of those. Lengths 3..10 and 258 are in fact represented
+ * by just a length symbol. Lengths 11..257 are represented as a symbol and
+ * some number of extra bits that are added as an integer to the base length
+ * of the length symbol. The number of extra bits is determined by the base
+ * length symbol. These are in the static arrays below, lens[] for the base
+ * lengths and lext[] for the corresponding number of extra bits.
+ *
+ * - The reason that 258 gets its own symbol is that the longest length is used
+ * often in highly redundant files. Note that 258 can also be coded as the
+ * base value 227 plus the maximum extra value of 31. While a good deflate
+ * should never do this, it is not an error, and should be decoded properly.
+ *
+ * - If a length is decoded, including its extra bits if any, then it is
+ * followed a distance code. There are up to 30 distance symbols. Again
+ * there are many more possible distances (1..32768), so extra bits are added
+ * to a base value represented by the symbol. The distances 1..4 get their
+ * own symbol, but the rest require extra bits. The base distances and
+ * corresponding number of extra bits are below in the static arrays dist[]
+ * and dext[].
+ *
+ * - Literal bytes are simply written to the output. A length/distance pair is
+ * an instruction to copy previously uncompressed bytes to the output. The
+ * copy is from distance bytes back in the output stream, copying for length
+ * bytes.
+ *
+ * - Distances pointing before the beginning of the output data are not
+ * permitted.
+ *
+ * - Overlapped copies, where the length is greater than the distance, are
+ * allowed and common. For example, a distance of one and a length of 258
+ * simply copies the last byte 258 times. A distance of four and a length of
+ * twelve copies the last four bytes three times. A simple forward copy
+ * ignoring whether the length is greater than the distance or not implements
+ * this correctly. You should not use memcpy() since its behavior is not
+ * defined for overlapped arrays. You should not use memmove() or bcopy()
+ * since though their behavior -is- defined for overlapping arrays, it is
+ * defined to do the wrong thing in this case.
+ */
+local int codes(struct state *s,
+ const struct huffman *lencode,
+ const struct huffman *distcode)
+{
+ int symbol; /* decoded symbol */
+ int len; /* length for copy */
+ unsigned dist; /* distance for copy */
+ static const short lens[29] = { /* Size base for length codes 257..285 */
+ 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};
+ static const short lext[29] = { /* Extra bits for length codes 257..285 */
+ 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};
+ static const short dists[30] = { /* Offset base for distance codes 0..29 */
+ 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};
+ static const short dext[30] = { /* Extra bits for distance codes 0..29 */
+ 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};
+
+ /* decode literals and length/distance pairs */
+ do {
+ symbol = decode(s, lencode);
+ if (symbol < 0)
+ return symbol; /* invalid symbol */
+ if (symbol < 256) { /* literal: symbol is the byte */
+ /* write out the literal */
+ if (s->out != NIL) {
+ if (s->outcnt == s->outlen)
+ return 1;
+ s->out[s->outcnt] = symbol;
+ }
+ s->outcnt++;
+ }
+ else if (symbol > 256) { /* length */
+ /* get and compute length */
+ symbol -= 257;
+ if (symbol >= 29)
+ return -10; /* invalid fixed code */
+ len = lens[symbol] + bits(s, lext[symbol]);
+
+ /* get and check distance */
+ symbol = decode(s, distcode);
+ if (symbol < 0)
+ return symbol; /* invalid symbol */
+ dist = dists[symbol] + bits(s, dext[symbol]);
+#ifndef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+ if (dist > s->outcnt)
+ return -11; /* distance too far back */
+#endif
+
+ /* copy length bytes from distance bytes back */
+ if (s->out != NIL) {
+ if (s->outcnt + len > s->outlen)
+ return 1;
+ while (len--) {
+ s->out[s->outcnt] =
+#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+ dist > s->outcnt ?
+ 0 :
+#endif
+ s->out[s->outcnt - dist];
+ s->outcnt++;
+ }
+ }
+ else
+ s->outcnt += len;
+ }
+ } while (symbol != 256); /* end of block symbol */
+
+ /* done with a valid fixed or dynamic block */
+ return 0;
+}
+
+/*
+ * Process a fixed codes block.
+ *
+ * Format notes:
+ *
+ * - This block type can be useful for compressing small amounts of data for
+ * which the size of the code descriptions in a dynamic block exceeds the
+ * benefit of custom codes for that block. For fixed codes, no bits are
+ * spent on code descriptions. Instead the code lengths for literal/length
+ * codes and distance codes are fixed. The specific lengths for each symbol
+ * can be seen in the "for" loops below.
+ *
+ * - The literal/length code is complete, but has two symbols that are invalid
+ * and should result in an error if received. This cannot be implemented
+ * simply as an incomplete code since those two symbols are in the "middle"
+ * of the code. They are eight bits long and the longest literal/length\
+ * code is nine bits. Therefore the code must be constructed with those
+ * symbols, and the invalid symbols must be detected after decoding.
+ *
+ * - The fixed distance codes also have two invalid symbols that should result
+ * in an error if received. Since all of the distance codes are the same
+ * length, this can be implemented as an incomplete code. Then the invalid
+ * codes are detected while decoding.
+ */
+local int fixed(struct state *s)
+{
+ static int virgin = 1;
+ static short lencnt[MAXBITS+1], lensym[FIXLCODES];
+ static short distcnt[MAXBITS+1], distsym[MAXDCODES];
+ static struct huffman lencode, distcode;
+
+ /* build fixed huffman tables if first call (may not be thread safe) */
+ if (virgin) {
+ int symbol;
+ short lengths[FIXLCODES];
+
+ /* construct lencode and distcode */
+ lencode.count = lencnt;
+ lencode.symbol = lensym;
+ distcode.count = distcnt;
+ distcode.symbol = distsym;
+
+ /* literal/length table */
+ for (symbol = 0; symbol < 144; symbol++)
+ lengths[symbol] = 8;
+ for (; symbol < 256; symbol++)
+ lengths[symbol] = 9;
+ for (; symbol < 280; symbol++)
+ lengths[symbol] = 7;
+ for (; symbol < FIXLCODES; symbol++)
+ lengths[symbol] = 8;
+ construct(&lencode, lengths, FIXLCODES);
+
+ /* distance table */
+ for (symbol = 0; symbol < MAXDCODES; symbol++)
+ lengths[symbol] = 5;
+ construct(&distcode, lengths, MAXDCODES);
+
+ /* do this just once */
+ virgin = 0;
+ }
+
+ /* decode data until end-of-block code */
+ return codes(s, &lencode, &distcode);
+}
+
+/*
+ * Process a dynamic codes block.
+ *
+ * Format notes:
+ *
+ * - A dynamic block starts with a description of the literal/length and
+ * distance codes for that block. New dynamic blocks allow the compressor to
+ * rapidly adapt to changing data with new codes optimized for that data.
+ *
+ * - The codes used by the deflate format are "canonical", which means that
+ * the actual bits of the codes are generated in an unambiguous way simply
+ * from the number of bits in each code. Therefore the code descriptions
+ * are simply a list of code lengths for each symbol.
+ *
+ * - The code lengths are stored in order for the symbols, so lengths are
+ * provided for each of the literal/length symbols, and for each of the
+ * distance symbols.
+ *
+ * - If a symbol is not used in the block, this is represented by a zero as
+ * as the code length. This does not mean a zero-length code, but rather
+ * that no code should be created for this symbol. There is no way in the
+ * deflate format to represent a zero-length code.
+ *
+ * - The maximum number of bits in a code is 15, so the possible lengths for
+ * any code are 1..15.
+ *
+ * - The fact that a length of zero is not permitted for a code has an
+ * interesting consequence. Normally if only one symbol is used for a given
+ * code, then in fact that code could be represented with zero bits. However
+ * in deflate, that code has to be at least one bit. So for example, if
+ * only a single distance base symbol appears in a block, then it will be
+ * represented by a single code of length one, in particular one 0 bit. This
+ * is an incomplete code, since if a 1 bit is received, it has no meaning,
+ * and should result in an error. So incomplete distance codes of one symbol
+ * should be permitted, and the receipt of invalid codes should be handled.
+ *
+ * - It is also possible to have a single literal/length code, but that code
+ * must be the end-of-block code, since every dynamic block has one. This
+ * is not the most efficient way to create an empty block (an empty fixed
+ * block is fewer bits), but it is allowed by the format. So incomplete
+ * literal/length codes of one symbol should also be permitted.
+ *
+ * - If there are only literal codes and no lengths, then there are no distance
+ * codes. This is represented by one distance code with zero bits.
+ *
+ * - The list of up to 286 length/literal lengths and up to 30 distance lengths
+ * are themselves compressed using Huffman codes and run-length encoding. In
+ * the list of code lengths, a 0 symbol means no code, a 1..15 symbol means
+ * that length, and the symbols 16, 17, and 18 are run-length instructions.
+ * Each of 16, 17, and 18 are follwed by extra bits to define the length of
+ * the run. 16 copies the last length 3 to 6 times. 17 represents 3 to 10
+ * zero lengths, and 18 represents 11 to 138 zero lengths. Unused symbols
+ * are common, hence the special coding for zero lengths.
+ *
+ * - The symbols for 0..18 are Huffman coded, and so that code must be
+ * described first. This is simply a sequence of up to 19 three-bit values
+ * representing no code (0) or the code length for that symbol (1..7).
+ *
+ * - A dynamic block starts with three fixed-size counts from which is computed
+ * the number of literal/length code lengths, the number of distance code
+ * lengths, and the number of code length code lengths (ok, you come up with
+ * a better name!) in the code descriptions. For the literal/length and
+ * distance codes, lengths after those provided are considered zero, i.e. no
+ * code. The code length code lengths are received in a permuted order (see
+ * the order[] array below) to make a short code length code length list more
+ * likely. As it turns out, very short and very long codes are less likely
+ * to be seen in a dynamic code description, hence what may appear initially
+ * to be a peculiar ordering.
+ *
+ * - Given the number of literal/length code lengths (nlen) and distance code
+ * lengths (ndist), then they are treated as one long list of nlen + ndist
+ * code lengths. Therefore run-length coding can and often does cross the
+ * boundary between the two sets of lengths.
+ *
+ * - So to summarize, the code description at the start of a dynamic block is
+ * three counts for the number of code lengths for the literal/length codes,
+ * the distance codes, and the code length codes. This is followed by the
+ * code length code lengths, three bits each. This is used to construct the
+ * code length code which is used to read the remainder of the lengths. Then
+ * the literal/length code lengths and distance lengths are read as a single
+ * set of lengths using the code length codes. Codes are constructed from
+ * the resulting two sets of lengths, and then finally you can start
+ * decoding actual compressed data in the block.
+ *
+ * - For reference, a "typical" size for the code description in a dynamic
+ * block is around 80 bytes.
+ */
+local int dynamic(struct state *s)
+{
+ int nlen, ndist, ncode; /* number of lengths in descriptor */
+ int index; /* index of lengths[] */
+ int err; /* construct() return value */
+ short lengths[MAXCODES]; /* descriptor code lengths */
+ short lencnt[MAXBITS+1], lensym[MAXLCODES]; /* lencode memory */
+ short distcnt[MAXBITS+1], distsym[MAXDCODES]; /* distcode memory */
+ struct huffman lencode, distcode; /* length and distance codes */
+ static const short order[19] = /* permutation of code length codes */
+ {16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
+
+ /* construct lencode and distcode */
+ lencode.count = lencnt;
+ lencode.symbol = lensym;
+ distcode.count = distcnt;
+ distcode.symbol = distsym;
+
+ /* get number of lengths in each table, check lengths */
+ nlen = bits(s, 5) + 257;
+ ndist = bits(s, 5) + 1;
+ ncode = bits(s, 4) + 4;
+ if (nlen > MAXLCODES || ndist > MAXDCODES)
+ return -3; /* bad counts */
+
+ /* read code length code lengths (really), missing lengths are zero */
+ for (index = 0; index < ncode; index++)
+ lengths[order[index]] = bits(s, 3);
+ for (; index < 19; index++)
+ lengths[order[index]] = 0;
+
+ /* build huffman table for code lengths codes (use lencode temporarily) */
+ err = construct(&lencode, lengths, 19);
+ if (err != 0) /* require complete code set here */
+ return -4;
+
+ /* read length/literal and distance code length tables */
+ index = 0;
+ while (index < nlen + ndist) {
+ int symbol; /* decoded value */
+ int len; /* last length to repeat */
+
+ symbol = decode(s, &lencode);
+ if (symbol < 0)
+ return symbol; /* invalid symbol */
+ if (symbol < 16) /* length in 0..15 */
+ lengths[index++] = symbol;
+ else { /* repeat instruction */
+ len = 0; /* assume repeating zeros */
+ if (symbol == 16) { /* repeat last length 3..6 times */
+ if (index == 0)
+ return -5; /* no last length! */
+ len = lengths[index - 1]; /* last length */
+ symbol = 3 + bits(s, 2);
+ }
+ else if (symbol == 17) /* repeat zero 3..10 times */
+ symbol = 3 + bits(s, 3);
+ else /* == 18, repeat zero 11..138 times */
+ symbol = 11 + bits(s, 7);
+ if (index + symbol > nlen + ndist)
+ return -6; /* too many lengths! */
+ while (symbol--) /* repeat last or zero symbol times */
+ lengths[index++] = len;
+ }
+ }
+
+ /* check for end-of-block code -- there better be one! */
+ if (lengths[256] == 0)
+ return -9;
+
+ /* build huffman table for literal/length codes */
+ err = construct(&lencode, lengths, nlen);
+ if (err && (err < 0 || nlen != lencode.count[0] + lencode.count[1]))
+ return -7; /* incomplete code ok only for single length 1 code */
+
+ /* build huffman table for distance codes */
+ err = construct(&distcode, lengths + nlen, ndist);
+ if (err && (err < 0 || ndist != distcode.count[0] + distcode.count[1]))
+ return -8; /* incomplete code ok only for single length 1 code */
+
+ /* decode data until end-of-block code */
+ return codes(s, &lencode, &distcode);
+}
+
+/*
+ * Inflate source to dest. On return, destlen and sourcelen are updated to the
+ * size of the uncompressed data and the size of the deflate data respectively.
+ * On success, the return value of puff() is zero. If there is an error in the
+ * source data, i.e. it is not in the deflate format, then a negative value is
+ * returned. If there is not enough input available or there is not enough
+ * output space, then a positive error is returned. In that case, destlen and
+ * sourcelen are not updated to facilitate retrying from the beginning with the
+ * provision of more input data or more output space. In the case of invalid
+ * inflate data (a negative error), the dest and source pointers are updated to
+ * facilitate the debugging of deflators.
+ *
+ * puff() also has a mode to determine the size of the uncompressed output with
+ * no output written. For this dest must be (unsigned char *)0. In this case,
+ * the input value of *destlen is ignored, and on return *destlen is set to the
+ * size of the uncompressed output.
+ *
+ * The return codes are:
+ *
+ * 2: available inflate data did not terminate
+ * 1: output space exhausted before completing inflate
+ * 0: successful inflate
+ * -1: invalid block type (type == 3)
+ * -2: stored block length did not match one's complement
+ * -3: dynamic block code description: too many length or distance codes
+ * -4: dynamic block code description: code lengths codes incomplete
+ * -5: dynamic block code description: repeat lengths with no first length
+ * -6: dynamic block code description: repeat more than specified lengths
+ * -7: dynamic block code description: invalid literal/length code lengths
+ * -8: dynamic block code description: invalid distance code lengths
+ * -9: dynamic block code description: missing end-of-block code
+ * -10: invalid literal/length or distance code in fixed or dynamic block
+ * -11: distance is too far back in fixed or dynamic block
+ *
+ * Format notes:
+ *
+ * - Three bits are read for each block to determine the kind of block and
+ * whether or not it is the last block. Then the block is decoded and the
+ * process repeated if it was not the last block.
+ *
+ * - The leftover bits in the last byte of the deflate data after the last
+ * block (if it was a fixed or dynamic block) are undefined and have no
+ * expected values to check.
+ */
+int puff(unsigned char *dest, /* pointer to destination pointer */
+ unsigned long *destlen, /* amount of output space */
+ const unsigned char *source, /* pointer to source data pointer */
+ unsigned long *sourcelen) /* amount of input available */
+{
+ struct state s; /* input/output state */
+ int last, type; /* block information */
+ int err; /* return value */
+
+ /* initialize output state */
+ s.out = dest;
+ s.outlen = *destlen; /* ignored if dest is NIL */
+ s.outcnt = 0;
+
+ /* initialize input state */
+ s.in = source;
+ s.inlen = *sourcelen;
+ s.incnt = 0;
+ s.bitbuf = 0;
+ s.bitcnt = 0;
+
+ /* return if bits() or decode() tries to read past available input */
+ if (setjmp(s.env) != 0) /* if came back here via longjmp() */
+ err = 2; /* then skip do-loop, return error */
+ else {
+ /* process blocks until last block or error */
+ do {
+ last = bits(&s, 1); /* one if last block */
+ type = bits(&s, 2); /* block type 0..3 */
+ err = type == 0 ?
+ stored(&s) :
+ (type == 1 ?
+ fixed(&s) :
+ (type == 2 ?
+ dynamic(&s) :
+ -1)); /* type == 3, invalid */
+ if (err != 0)
+ break; /* return with error */
+ } while (!last);
+ }
+
+ /* update the lengths and return */
+ if (err <= 0) {
+ *destlen = s.outcnt;
+ *sourcelen = s.incnt;
+ }
+ return err;
+}
diff --git a/zlib/contrib/puff/puff.h b/zlib/contrib/puff/puff.h
new file mode 100644
index 000000000..e23a24543
--- /dev/null
+++ b/zlib/contrib/puff/puff.h
@@ -0,0 +1,35 @@
+/* puff.h
+ Copyright (C) 2002-2013 Mark Adler, all rights reserved
+ version 2.3, 21 Jan 2013
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the author 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.
+
+ Mark Adler madler@alumni.caltech.edu
+ */
+
+
+/*
+ * See puff.c for purpose and usage.
+ */
+#ifndef NIL
+# define NIL ((unsigned char *)0) /* for no output option */
+#endif
+
+int puff(unsigned char *dest, /* pointer to destination pointer */
+ unsigned long *destlen, /* amount of output space */
+ const unsigned char *source, /* pointer to source data pointer */
+ unsigned long *sourcelen); /* amount of input available */
diff --git a/zlib/contrib/puff/pufftest.c b/zlib/contrib/puff/pufftest.c
new file mode 100644
index 000000000..776481488
--- /dev/null
+++ b/zlib/contrib/puff/pufftest.c
@@ -0,0 +1,165 @@
+/*
+ * pufftest.c
+ * Copyright (C) 2002-2013 Mark Adler
+ * For conditions of distribution and use, see copyright notice in puff.h
+ * version 2.3, 21 Jan 2013
+ */
+
+/* Example of how to use puff().
+
+ Usage: puff [-w] [-f] [-nnn] file
+ ... | puff [-w] [-f] [-nnn]
+
+ where file is the input file with deflate data, nnn is the number of bytes
+ of input to skip before inflating (e.g. to skip a zlib or gzip header), and
+ -w is used to write the decompressed data to stdout. -f is for coverage
+ testing, and causes pufftest to fail with not enough output space (-f does
+ a write like -w, so -w is not required). */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "puff.h"
+
+#if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__)
+# include <fcntl.h>
+# include <io.h>
+# define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
+#else
+# define SET_BINARY_MODE(file)
+#endif
+
+#define local static
+
+/* Return size times approximately the cube root of 2, keeping the result as 1,
+ 3, or 5 times a power of 2 -- the result is always > size, until the result
+ is the maximum value of an unsigned long, where it remains. This is useful
+ to keep reallocations less than ~33% over the actual data. */
+local size_t bythirds(size_t size)
+{
+ int n;
+ size_t m;
+
+ m = size;
+ for (n = 0; m; n++)
+ m >>= 1;
+ if (n < 3)
+ return size + 1;
+ n -= 3;
+ m = size >> n;
+ m += m == 6 ? 2 : 1;
+ m <<= n;
+ return m > size ? m : (size_t)(-1);
+}
+
+/* Read the input file *name, or stdin if name is NULL, into allocated memory.
+ Reallocate to larger buffers until the entire file is read in. Return a
+ pointer to the allocated data, or NULL if there was a memory allocation
+ failure. *len is the number of bytes of data read from the input file (even
+ if load() returns NULL). If the input file was empty or could not be opened
+ or read, *len is zero. */
+local void *load(const char *name, size_t *len)
+{
+ size_t size;
+ void *buf, *swap;
+ FILE *in;
+
+ *len = 0;
+ buf = malloc(size = 4096);
+ if (buf == NULL)
+ return NULL;
+ in = name == NULL ? stdin : fopen(name, "rb");
+ if (in != NULL) {
+ for (;;) {
+ *len += fread((char *)buf + *len, 1, size - *len, in);
+ if (*len < size) break;
+ size = bythirds(size);
+ if (size == *len || (swap = realloc(buf, size)) == NULL) {
+ free(buf);
+ buf = NULL;
+ break;
+ }
+ buf = swap;
+ }
+ fclose(in);
+ }
+ return buf;
+}
+
+int main(int argc, char **argv)
+{
+ int ret, put = 0, fail = 0;
+ unsigned skip = 0;
+ char *arg, *name = NULL;
+ unsigned char *source = NULL, *dest;
+ size_t len = 0;
+ unsigned long sourcelen, destlen;
+
+ /* process arguments */
+ while (arg = *++argv, --argc)
+ if (arg[0] == '-') {
+ if (arg[1] == 'w' && arg[2] == 0)
+ put = 1;
+ else if (arg[1] == 'f' && arg[2] == 0)
+ fail = 1, put = 1;
+ else if (arg[1] >= '0' && arg[1] <= '9')
+ skip = (unsigned)atoi(arg + 1);
+ else {
+ fprintf(stderr, "invalid option %s\n", arg);
+ return 3;
+ }
+ }
+ else if (name != NULL) {
+ fprintf(stderr, "only one file name allowed\n");
+ return 3;
+ }
+ else
+ name = arg;
+ source = load(name, &len);
+ if (source == NULL) {
+ fprintf(stderr, "memory allocation failure\n");
+ return 4;
+ }
+ if (len == 0) {
+ fprintf(stderr, "could not read %s, or it was empty\n",
+ name == NULL ? "<stdin>" : name);
+ free(source);
+ return 3;
+ }
+ if (skip >= len) {
+ fprintf(stderr, "skip request of %d leaves no input\n", skip);
+ free(source);
+ return 3;
+ }
+
+ /* test inflate data with offset skip */
+ len -= skip;
+ sourcelen = (unsigned long)len;
+ ret = puff(NIL, &destlen, source + skip, &sourcelen);
+ if (ret)
+ fprintf(stderr, "puff() failed with return code %d\n", ret);
+ else {
+ fprintf(stderr, "puff() succeeded uncompressing %lu bytes\n", destlen);
+ if (sourcelen < len) fprintf(stderr, "%lu compressed bytes unused\n",
+ len - sourcelen);
+ }
+
+ /* if requested, inflate again and write decompressd data to stdout */
+ if (put && ret == 0) {
+ if (fail)
+ destlen >>= 1;
+ dest = malloc(destlen);
+ if (dest == NULL) {
+ fprintf(stderr, "memory allocation failure\n");
+ free(source);
+ return 4;
+ }
+ puff(dest, &destlen, source + skip, &sourcelen);
+ SET_BINARY_MODE(stdout);
+ fwrite(dest, 1, destlen, stdout);
+ free(dest);
+ }
+
+ /* clean up */
+ free(source);
+ return ret;
+}
diff --git a/zlib/contrib/puff/zeros.raw b/zlib/contrib/puff/zeros.raw
new file mode 100644
index 0000000000000000000000000000000000000000..0a90e76b300205a44a0ecbf613e64aaaef2e51e7
GIT binary patch
literal 2517
zcmYdFkYHV$AkxzmXu#!mP=i#?5{3o^3jqcYc(h*%Opg+yAut*OqaiT#LSPd+y9&tF
zP5<`ixi4UXdB8xJfs^6ee;AkH?VUytyFsD;HLIJ(gg5bUnNh}Q2#kinXb22!2pr%5
E0JRq+;s5{u
literal 0
HcmV?d00001
diff --git a/zlib/contrib/testzlib/testzlib.c b/zlib/contrib/testzlib/testzlib.c
new file mode 100644
index 000000000..5f659dea0
--- /dev/null
+++ b/zlib/contrib/testzlib/testzlib.c
@@ -0,0 +1,275 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <windows.h>
+
+#include "zlib.h"
+
+
+void MyDoMinus64(LARGE_INTEGER *R,LARGE_INTEGER A,LARGE_INTEGER B)
+{
+ R->HighPart = A.HighPart - B.HighPart;
+ if (A.LowPart >= B.LowPart)
+ R->LowPart = A.LowPart - B.LowPart;
+ else
+ {
+ R->LowPart = A.LowPart - B.LowPart;
+ R->HighPart --;
+ }
+}
+
+#ifdef _M_X64
+// see http://msdn2.microsoft.com/library/twchhe95(en-us,vs.80).aspx for __rdtsc
+unsigned __int64 __rdtsc(void);
+void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
+{
+ // printf("rdtsc = %I64x\n",__rdtsc());
+ pbeginTime64->QuadPart=__rdtsc();
+}
+
+LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
+{
+ LARGE_INTEGER LIres;
+ unsigned _int64 res=__rdtsc()-((unsigned _int64)(beginTime64.QuadPart));
+ LIres.QuadPart=res;
+ // printf("rdtsc = %I64x\n",__rdtsc());
+ return LIres;
+}
+#else
+#ifdef _M_IX86
+void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
+{
+ DWORD dwEdx,dwEax;
+ _asm
+ {
+ rdtsc
+ mov dwEax,eax
+ mov dwEdx,edx
+ }
+ pbeginTime64->LowPart=dwEax;
+ pbeginTime64->HighPart=dwEdx;
+}
+
+void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
+{
+ myGetRDTSC32(pbeginTime64);
+}
+
+LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
+{
+ LARGE_INTEGER LIres,endTime64;
+ myGetRDTSC32(&endTime64);
+
+ LIres.LowPart=LIres.HighPart=0;
+ MyDoMinus64(&LIres,endTime64,beginTime64);
+ return LIres;
+}
+#else
+void myGetRDTSC32(LARGE_INTEGER * pbeginTime64)
+{
+}
+
+void BeginCountRdtsc(LARGE_INTEGER * pbeginTime64)
+{
+}
+
+LARGE_INTEGER GetResRdtsc(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
+{
+ LARGE_INTEGER lr;
+ lr.QuadPart=0;
+ return lr;
+}
+#endif
+#endif
+
+void BeginCountPerfCounter(LARGE_INTEGER * pbeginTime64,BOOL fComputeTimeQueryPerf)
+{
+ if ((!fComputeTimeQueryPerf) || (!QueryPerformanceCounter(pbeginTime64)))
+ {
+ pbeginTime64->LowPart = GetTickCount();
+ pbeginTime64->HighPart = 0;
+ }
+}
+
+DWORD GetMsecSincePerfCounter(LARGE_INTEGER beginTime64,BOOL fComputeTimeQueryPerf)
+{
+ LARGE_INTEGER endTime64,ticksPerSecond,ticks;
+ DWORDLONG ticksShifted,tickSecShifted;
+ DWORD dwLog=16+0;
+ DWORD dwRet;
+ if ((!fComputeTimeQueryPerf) || (!QueryPerformanceCounter(&endTime64)))
+ dwRet = (GetTickCount() - beginTime64.LowPart)*1;
+ else
+ {
+ MyDoMinus64(&ticks,endTime64,beginTime64);
+ QueryPerformanceFrequency(&ticksPerSecond);
+
+
+ {
+ ticksShifted = Int64ShrlMod32(*(DWORDLONG*)&ticks,dwLog);
+ tickSecShifted = Int64ShrlMod32(*(DWORDLONG*)&ticksPerSecond,dwLog);
+
+ }
+
+ dwRet = (DWORD)((((DWORD)ticksShifted)*1000)/(DWORD)(tickSecShifted));
+ dwRet *=1;
+ }
+ return dwRet;
+}
+
+int ReadFileMemory(const char* filename,long* plFileSize,unsigned char** pFilePtr)
+{
+ FILE* stream;
+ unsigned char* ptr;
+ int retVal=1;
+ stream=fopen(filename, "rb");
+ if (stream==NULL)
+ return 0;
+
+ fseek(stream,0,SEEK_END);
+
+ *plFileSize=ftell(stream);
+ fseek(stream,0,SEEK_SET);
+ ptr=malloc((*plFileSize)+1);
+ if (ptr==NULL)
+ retVal=0;
+ else
+ {
+ if (fread(ptr, 1, *plFileSize,stream) != (*plFileSize))
+ retVal=0;
+ }
+ fclose(stream);
+ *pFilePtr=ptr;
+ return retVal;
+}
+
+int main(int argc, char *argv[])
+{
+ int BlockSizeCompress=0x8000;
+ int BlockSizeUncompress=0x8000;
+ int cprLevel=Z_DEFAULT_COMPRESSION ;
+ long lFileSize;
+ unsigned char* FilePtr;
+ long lBufferSizeCpr;
+ long lBufferSizeUncpr;
+ long lCompressedSize=0;
+ unsigned char* CprPtr;
+ unsigned char* UncprPtr;
+ long lSizeCpr,lSizeUncpr;
+ DWORD dwGetTick,dwMsecQP;
+ LARGE_INTEGER li_qp,li_rdtsc,dwResRdtsc;
+
+ if (argc<=1)
+ {
+ printf("run TestZlib <File> [BlockSizeCompress] [BlockSizeUncompress] [compres. level]\n");
+ return 0;
+ }
+
+ if (ReadFileMemory(argv[1],&lFileSize,&FilePtr)==0)
+ {
+ printf("error reading %s\n",argv[1]);
+ return 1;
+ }
+ else printf("file %s read, %u bytes\n",argv[1],lFileSize);
+
+ if (argc>=3)
+ BlockSizeCompress=atol(argv[2]);
+
+ if (argc>=4)
+ BlockSizeUncompress=atol(argv[3]);
+
+ if (argc>=5)
+ cprLevel=(int)atol(argv[4]);
+
+ lBufferSizeCpr = lFileSize + (lFileSize/0x10) + 0x200;
+ lBufferSizeUncpr = lBufferSizeCpr;
+
+ CprPtr=(unsigned char*)malloc(lBufferSizeCpr + BlockSizeCompress);
+
+ BeginCountPerfCounter(&li_qp,TRUE);
+ dwGetTick=GetTickCount();
+ BeginCountRdtsc(&li_rdtsc);
+ {
+ z_stream zcpr;
+ int ret=Z_OK;
+ long lOrigToDo = lFileSize;
+ long lOrigDone = 0;
+ int step=0;
+ memset(&zcpr,0,sizeof(z_stream));
+ deflateInit(&zcpr,cprLevel);
+
+ zcpr.next_in = FilePtr;
+ zcpr.next_out = CprPtr;
+
+
+ do
+ {
+ long all_read_before = zcpr.total_in;
+ zcpr.avail_in = min(lOrigToDo,BlockSizeCompress);
+ zcpr.avail_out = BlockSizeCompress;
+ ret=deflate(&zcpr,(zcpr.avail_in==lOrigToDo) ? Z_FINISH : Z_SYNC_FLUSH);
+ lOrigDone += (zcpr.total_in-all_read_before);
+ lOrigToDo -= (zcpr.total_in-all_read_before);
+ step++;
+ } while (ret==Z_OK);
+
+ lSizeCpr=zcpr.total_out;
+ deflateEnd(&zcpr);
+ dwGetTick=GetTickCount()-dwGetTick;
+ dwMsecQP=GetMsecSincePerfCounter(li_qp,TRUE);
+ dwResRdtsc=GetResRdtsc(li_rdtsc,TRUE);
+ printf("total compress size = %u, in %u step\n",lSizeCpr,step);
+ printf("time = %u msec = %f sec\n",dwGetTick,dwGetTick/(double)1000.);
+ printf("defcpr time QP = %u msec = %f sec\n",dwMsecQP,dwMsecQP/(double)1000.);
+ printf("defcpr result rdtsc = %I64x\n\n",dwResRdtsc.QuadPart);
+ }
+
+ CprPtr=(unsigned char*)realloc(CprPtr,lSizeCpr);
+ UncprPtr=(unsigned char*)malloc(lBufferSizeUncpr + BlockSizeUncompress);
+
+ BeginCountPerfCounter(&li_qp,TRUE);
+ dwGetTick=GetTickCount();
+ BeginCountRdtsc(&li_rdtsc);
+ {
+ z_stream zcpr;
+ int ret=Z_OK;
+ long lOrigToDo = lSizeCpr;
+ long lOrigDone = 0;
+ int step=0;
+ memset(&zcpr,0,sizeof(z_stream));
+ inflateInit(&zcpr);
+
+ zcpr.next_in = CprPtr;
+ zcpr.next_out = UncprPtr;
+
+
+ do
+ {
+ long all_read_before = zcpr.total_in;
+ zcpr.avail_in = min(lOrigToDo,BlockSizeUncompress);
+ zcpr.avail_out = BlockSizeUncompress;
+ ret=inflate(&zcpr,Z_SYNC_FLUSH);
+ lOrigDone += (zcpr.total_in-all_read_before);
+ lOrigToDo -= (zcpr.total_in-all_read_before);
+ step++;
+ } while (ret==Z_OK);
+
+ lSizeUncpr=zcpr.total_out;
+ inflateEnd(&zcpr);
+ dwGetTick=GetTickCount()-dwGetTick;
+ dwMsecQP=GetMsecSincePerfCounter(li_qp,TRUE);
+ dwResRdtsc=GetResRdtsc(li_rdtsc,TRUE);
+ printf("total uncompress size = %u, in %u step\n",lSizeUncpr,step);
+ printf("time = %u msec = %f sec\n",dwGetTick,dwGetTick/(double)1000.);
+ printf("uncpr time QP = %u msec = %f sec\n",dwMsecQP,dwMsecQP/(double)1000.);
+ printf("uncpr result rdtsc = %I64x\n\n",dwResRdtsc.QuadPart);
+ }
+
+ if (lSizeUncpr==lFileSize)
+ {
+ if (memcmp(FilePtr,UncprPtr,lFileSize)==0)
+ printf("compare ok\n");
+
+ }
+
+ return 0;
+}
diff --git a/zlib/contrib/testzlib/testzlib.txt b/zlib/contrib/testzlib/testzlib.txt
new file mode 100644
index 000000000..62258f149
--- /dev/null
+++ b/zlib/contrib/testzlib/testzlib.txt
@@ -0,0 +1,10 @@
+To build testzLib with Visual Studio 2005:
+
+copy to a directory file from :
+- root of zLib tree
+- contrib/testzlib
+- contrib/masmx86
+- contrib/masmx64
+- contrib/vstudio/vc7
+
+and open testzlib8.sln
\ No newline at end of file
diff --git a/zlib/contrib/untgz/Makefile b/zlib/contrib/untgz/Makefile
new file mode 100644
index 000000000..b54266fba
--- /dev/null
+++ b/zlib/contrib/untgz/Makefile
@@ -0,0 +1,14 @@
+CC=cc
+CFLAGS=-g
+
+untgz: untgz.o ../../libz.a
+ $(CC) $(CFLAGS) -o untgz untgz.o -L../.. -lz
+
+untgz.o: untgz.c ../../zlib.h
+ $(CC) $(CFLAGS) -c -I../.. untgz.c
+
+../../libz.a:
+ cd ../..; ./configure; make
+
+clean:
+ rm -f untgz untgz.o *~
diff --git a/zlib/contrib/untgz/Makefile.msc b/zlib/contrib/untgz/Makefile.msc
new file mode 100644
index 000000000..77b860221
--- /dev/null
+++ b/zlib/contrib/untgz/Makefile.msc
@@ -0,0 +1,17 @@
+CC=cl
+CFLAGS=-MD
+
+untgz.exe: untgz.obj ..\..\zlib.lib
+ $(CC) $(CFLAGS) untgz.obj ..\..\zlib.lib
+
+untgz.obj: untgz.c ..\..\zlib.h
+ $(CC) $(CFLAGS) -c -I..\.. untgz.c
+
+..\..\zlib.lib:
+ cd ..\..
+ $(MAKE) -f win32\makefile.msc
+ cd contrib\untgz
+
+clean:
+ -del untgz.obj
+ -del untgz.exe
diff --git a/zlib/contrib/untgz/untgz.c b/zlib/contrib/untgz/untgz.c
new file mode 100644
index 000000000..2c391e598
--- /dev/null
+++ b/zlib/contrib/untgz/untgz.c
@@ -0,0 +1,674 @@
+/*
+ * untgz.c -- Display contents and extract files from a gzip'd TAR file
+ *
+ * written by Pedro A. Aranda Gutierrez <paag@tid.es>
+ * adaptation to Unix by Jean-loup Gailly <jloup@gzip.org>
+ * various fixes by Cosmin Truta <cosmint@cs.ubbcluj.ro>
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <errno.h>
+
+#include "zlib.h"
+
+#ifdef unix
+# include <unistd.h>
+#else
+# include <direct.h>
+# include <io.h>
+#endif
+
+#ifdef WIN32
+#include <windows.h>
+# ifndef F_OK
+# define F_OK 0
+# endif
+# define mkdir(dirname,mode) _mkdir(dirname)
+# ifdef _MSC_VER
+# define access(path,mode) _access(path,mode)
+# define chmod(path,mode) _chmod(path,mode)
+# define strdup(str) _strdup(str)
+# endif
+#else
+# include <utime.h>
+#endif
+
+
+/* values used in typeflag field */
+
+#define REGTYPE '0' /* regular file */
+#define AREGTYPE '\0' /* regular file */
+#define LNKTYPE '1' /* link */
+#define SYMTYPE '2' /* reserved */
+#define CHRTYPE '3' /* character special */
+#define BLKTYPE '4' /* block special */
+#define DIRTYPE '5' /* directory */
+#define FIFOTYPE '6' /* FIFO special */
+#define CONTTYPE '7' /* reserved */
+
+/* GNU tar extensions */
+
+#define GNUTYPE_DUMPDIR 'D' /* file names from dumped directory */
+#define GNUTYPE_LONGLINK 'K' /* long link name */
+#define GNUTYPE_LONGNAME 'L' /* long file name */
+#define GNUTYPE_MULTIVOL 'M' /* continuation of file from another volume */
+#define GNUTYPE_NAMES 'N' /* file name that does not fit into main hdr */
+#define GNUTYPE_SPARSE 'S' /* sparse file */
+#define GNUTYPE_VOLHDR 'V' /* tape/volume header */
+
+
+/* tar header */
+
+#define BLOCKSIZE 512
+#define SHORTNAMESIZE 100
+
+struct tar_header
+{ /* byte offset */
+ char name[100]; /* 0 */
+ char mode[8]; /* 100 */
+ char uid[8]; /* 108 */
+ char gid[8]; /* 116 */
+ char size[12]; /* 124 */
+ char mtime[12]; /* 136 */
+ char chksum[8]; /* 148 */
+ char typeflag; /* 156 */
+ char linkname[100]; /* 157 */
+ char magic[6]; /* 257 */
+ char version[2]; /* 263 */
+ char uname[32]; /* 265 */
+ char gname[32]; /* 297 */
+ char devmajor[8]; /* 329 */
+ char devminor[8]; /* 337 */
+ char prefix[155]; /* 345 */
+ /* 500 */
+};
+
+union tar_buffer
+{
+ char buffer[BLOCKSIZE];
+ struct tar_header header;
+};
+
+struct attr_item
+{
+ struct attr_item *next;
+ char *fname;
+ int mode;
+ time_t time;
+};
+
+enum { TGZ_EXTRACT, TGZ_LIST, TGZ_INVALID };
+
+char *TGZfname OF((const char *));
+void TGZnotfound OF((const char *));
+
+int getoct OF((char *, int));
+char *strtime OF((time_t *));
+int setfiletime OF((char *, time_t));
+void push_attr OF((struct attr_item **, char *, int, time_t));
+void restore_attr OF((struct attr_item **));
+
+int ExprMatch OF((char *, char *));
+
+int makedir OF((char *));
+int matchname OF((int, int, char **, char *));
+
+void error OF((const char *));
+int tar OF((gzFile, int, int, int, char **));
+
+void help OF((int));
+int main OF((int, char **));
+
+char *prog;
+
+const char *TGZsuffix[] = { "\0", ".tar", ".tar.gz", ".taz", ".tgz", NULL };
+
+/* return the file name of the TGZ archive */
+/* or NULL if it does not exist */
+
+char *TGZfname (const char *arcname)
+{
+ static char buffer[1024];
+ int origlen,i;
+
+ strcpy(buffer,arcname);
+ origlen = strlen(buffer);
+
+ for (i=0; TGZsuffix[i]; i++)
+ {
+ strcpy(buffer+origlen,TGZsuffix[i]);
+ if (access(buffer,F_OK) == 0)
+ return buffer;
+ }
+ return NULL;
+}
+
+
+/* error message for the filename */
+
+void TGZnotfound (const char *arcname)
+{
+ int i;
+
+ fprintf(stderr,"%s: Couldn't find ",prog);
+ for (i=0;TGZsuffix[i];i++)
+ fprintf(stderr,(TGZsuffix[i+1]) ? "%s%s, " : "or %s%s\n",
+ arcname,
+ TGZsuffix[i]);
+ exit(1);
+}
+
+
+/* convert octal digits to int */
+/* on error return -1 */
+
+int getoct (char *p,int width)
+{
+ int result = 0;
+ char c;
+
+ while (width--)
+ {
+ c = *p++;
+ if (c == 0)
+ break;
+ if (c == ' ')
+ continue;
+ if (c < '0' || c > '7')
+ return -1;
+ result = result * 8 + (c - '0');
+ }
+ return result;
+}
+
+
+/* convert time_t to string */
+/* use the "YYYY/MM/DD hh:mm:ss" format */
+
+char *strtime (time_t *t)
+{
+ struct tm *local;
+ static char result[32];
+
+ local = localtime(t);
+ sprintf(result,"%4d/%02d/%02d %02d:%02d:%02d",
+ local->tm_year+1900, local->tm_mon+1, local->tm_mday,
+ local->tm_hour, local->tm_min, local->tm_sec);
+ return result;
+}
+
+
+/* set file time */
+
+int setfiletime (char *fname,time_t ftime)
+{
+#ifdef WIN32
+ static int isWinNT = -1;
+ SYSTEMTIME st;
+ FILETIME locft, modft;
+ struct tm *loctm;
+ HANDLE hFile;
+ int result;
+
+ loctm = localtime(&ftime);
+ if (loctm == NULL)
+ return -1;
+
+ st.wYear = (WORD)loctm->tm_year + 1900;
+ st.wMonth = (WORD)loctm->tm_mon + 1;
+ st.wDayOfWeek = (WORD)loctm->tm_wday;
+ st.wDay = (WORD)loctm->tm_mday;
+ st.wHour = (WORD)loctm->tm_hour;
+ st.wMinute = (WORD)loctm->tm_min;
+ st.wSecond = (WORD)loctm->tm_sec;
+ st.wMilliseconds = 0;
+ if (!SystemTimeToFileTime(&st, &locft) ||
+ !LocalFileTimeToFileTime(&locft, &modft))
+ return -1;
+
+ if (isWinNT < 0)
+ isWinNT = (GetVersion() < 0x80000000) ? 1 : 0;
+ hFile = CreateFile(fname, GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
+ (isWinNT ? FILE_FLAG_BACKUP_SEMANTICS : 0),
+ NULL);
+ if (hFile == INVALID_HANDLE_VALUE)
+ return -1;
+ result = SetFileTime(hFile, NULL, NULL, &modft) ? 0 : -1;
+ CloseHandle(hFile);
+ return result;
+#else
+ struct utimbuf settime;
+
+ settime.actime = settime.modtime = ftime;
+ return utime(fname,&settime);
+#endif
+}
+
+
+/* push file attributes */
+
+void push_attr(struct attr_item **list,char *fname,int mode,time_t time)
+{
+ struct attr_item *item;
+
+ item = (struct attr_item *)malloc(sizeof(struct attr_item));
+ if (item == NULL)
+ error("Out of memory");
+ item->fname = strdup(fname);
+ item->mode = mode;
+ item->time = time;
+ item->next = *list;
+ *list = item;
+}
+
+
+/* restore file attributes */
+
+void restore_attr(struct attr_item **list)
+{
+ struct attr_item *item, *prev;
+
+ for (item = *list; item != NULL; )
+ {
+ setfiletime(item->fname,item->time);
+ chmod(item->fname,item->mode);
+ prev = item;
+ item = item->next;
+ free(prev);
+ }
+ *list = NULL;
+}
+
+
+/* match regular expression */
+
+#define ISSPECIAL(c) (((c) == '*') || ((c) == '/'))
+
+int ExprMatch (char *string,char *expr)
+{
+ while (1)
+ {
+ if (ISSPECIAL(*expr))
+ {
+ if (*expr == '/')
+ {
+ if (*string != '\\' && *string != '/')
+ return 0;
+ string ++; expr++;
+ }
+ else if (*expr == '*')
+ {
+ if (*expr ++ == 0)
+ return 1;
+ while (*++string != *expr)
+ if (*string == 0)
+ return 0;
+ }
+ }
+ else
+ {
+ if (*string != *expr)
+ return 0;
+ if (*expr++ == 0)
+ return 1;
+ string++;
+ }
+ }
+}
+
+
+/* recursive mkdir */
+/* abort on ENOENT; ignore other errors like "directory already exists" */
+/* return 1 if OK */
+/* 0 on error */
+
+int makedir (char *newdir)
+{
+ char *buffer = strdup(newdir);
+ char *p;
+ int len = strlen(buffer);
+
+ if (len <= 0) {
+ free(buffer);
+ return 0;
+ }
+ if (buffer[len-1] == '/') {
+ buffer[len-1] = '\0';
+ }
+ if (mkdir(buffer, 0755) == 0)
+ {
+ free(buffer);
+ return 1;
+ }
+
+ p = buffer+1;
+ while (1)
+ {
+ char hold;
+
+ while(*p && *p != '\\' && *p != '/')
+ p++;
+ hold = *p;
+ *p = 0;
+ if ((mkdir(buffer, 0755) == -1) && (errno == ENOENT))
+ {
+ fprintf(stderr,"%s: Couldn't create directory %s\n",prog,buffer);
+ free(buffer);
+ return 0;
+ }
+ if (hold == 0)
+ break;
+ *p++ = hold;
+ }
+ free(buffer);
+ return 1;
+}
+
+
+int matchname (int arg,int argc,char **argv,char *fname)
+{
+ if (arg == argc) /* no arguments given (untgz tgzarchive) */
+ return 1;
+
+ while (arg < argc)
+ if (ExprMatch(fname,argv[arg++]))
+ return 1;
+
+ return 0; /* ignore this for the moment being */
+}
+
+
+/* tar file list or extract */
+
+int tar (gzFile in,int action,int arg,int argc,char **argv)
+{
+ union tar_buffer buffer;
+ int len;
+ int err;
+ int getheader = 1;
+ int remaining = 0;
+ FILE *outfile = NULL;
+ char fname[BLOCKSIZE];
+ int tarmode;
+ time_t tartime;
+ struct attr_item *attributes = NULL;
+
+ if (action == TGZ_LIST)
+ printf(" date time size file\n"
+ " ---------- -------- --------- -------------------------------------\n");
+ while (1)
+ {
+ len = gzread(in, &buffer, BLOCKSIZE);
+ if (len < 0)
+ error(gzerror(in, &err));
+ /*
+ * Always expect complete blocks to process
+ * the tar information.
+ */
+ if (len != BLOCKSIZE)
+ {
+ action = TGZ_INVALID; /* force error exit */
+ remaining = 0; /* force I/O cleanup */
+ }
+
+ /*
+ * If we have to get a tar header
+ */
+ if (getheader >= 1)
+ {
+ /*
+ * if we met the end of the tar
+ * or the end-of-tar block,
+ * we are done
+ */
+ if (len == 0 || buffer.header.name[0] == 0)
+ break;
+
+ tarmode = getoct(buffer.header.mode,8);
+ tartime = (time_t)getoct(buffer.header.mtime,12);
+ if (tarmode == -1 || tartime == (time_t)-1)
+ {
+ buffer.header.name[0] = 0;
+ action = TGZ_INVALID;
+ }
+
+ if (getheader == 1)
+ {
+ strncpy(fname,buffer.header.name,SHORTNAMESIZE);
+ if (fname[SHORTNAMESIZE-1] != 0)
+ fname[SHORTNAMESIZE] = 0;
+ }
+ else
+ {
+ /*
+ * The file name is longer than SHORTNAMESIZE
+ */
+ if (strncmp(fname,buffer.header.name,SHORTNAMESIZE-1) != 0)
+ error("bad long name");
+ getheader = 1;
+ }
+
+ /*
+ * Act according to the type flag
+ */
+ switch (buffer.header.typeflag)
+ {
+ case DIRTYPE:
+ if (action == TGZ_LIST)
+ printf(" %s <dir> %s\n",strtime(&tartime),fname);
+ if (action == TGZ_EXTRACT)
+ {
+ makedir(fname);
+ push_attr(&attributes,fname,tarmode,tartime);
+ }
+ break;
+ case REGTYPE:
+ case AREGTYPE:
+ remaining = getoct(buffer.header.size,12);
+ if (remaining == -1)
+ {
+ action = TGZ_INVALID;
+ break;
+ }
+ if (action == TGZ_LIST)
+ printf(" %s %9d %s\n",strtime(&tartime),remaining,fname);
+ else if (action == TGZ_EXTRACT)
+ {
+ if (matchname(arg,argc,argv,fname))
+ {
+ outfile = fopen(fname,"wb");
+ if (outfile == NULL) {
+ /* try creating directory */
+ char *p = strrchr(fname, '/');
+ if (p != NULL) {
+ *p = '\0';
+ makedir(fname);
+ *p = '/';
+ outfile = fopen(fname,"wb");
+ }
+ }
+ if (outfile != NULL)
+ printf("Extracting %s\n",fname);
+ else
+ fprintf(stderr, "%s: Couldn't create %s",prog,fname);
+ }
+ else
+ outfile = NULL;
+ }
+ getheader = 0;
+ break;
+ case GNUTYPE_LONGLINK:
+ case GNUTYPE_LONGNAME:
+ remaining = getoct(buffer.header.size,12);
+ if (remaining < 0 || remaining >= BLOCKSIZE)
+ {
+ action = TGZ_INVALID;
+ break;
+ }
+ len = gzread(in, fname, BLOCKSIZE);
+ if (len < 0)
+ error(gzerror(in, &err));
+ if (fname[BLOCKSIZE-1] != 0 || (int)strlen(fname) > remaining)
+ {
+ action = TGZ_INVALID;
+ break;
+ }
+ getheader = 2;
+ break;
+ default:
+ if (action == TGZ_LIST)
+ printf(" %s <---> %s\n",strtime(&tartime),fname);
+ break;
+ }
+ }
+ else
+ {
+ unsigned int bytes = (remaining > BLOCKSIZE) ? BLOCKSIZE : remaining;
+
+ if (outfile != NULL)
+ {
+ if (fwrite(&buffer,sizeof(char),bytes,outfile) != bytes)
+ {
+ fprintf(stderr,
+ "%s: Error writing %s -- skipping\n",prog,fname);
+ fclose(outfile);
+ outfile = NULL;
+ remove(fname);
+ }
+ }
+ remaining -= bytes;
+ }
+
+ if (remaining == 0)
+ {
+ getheader = 1;
+ if (outfile != NULL)
+ {
+ fclose(outfile);
+ outfile = NULL;
+ if (action != TGZ_INVALID)
+ push_attr(&attributes,fname,tarmode,tartime);
+ }
+ }
+
+ /*
+ * Abandon if errors are found
+ */
+ if (action == TGZ_INVALID)
+ {
+ error("broken archive");
+ break;
+ }
+ }
+
+ /*
+ * Restore file modes and time stamps
+ */
+ restore_attr(&attributes);
+
+ if (gzclose(in) != Z_OK)
+ error("failed gzclose");
+
+ return 0;
+}
+
+
+/* ============================================================ */
+
+void help(int exitval)
+{
+ printf("untgz version 0.2.1\n"
+ " using zlib version %s\n\n",
+ zlibVersion());
+ printf("Usage: untgz file.tgz extract all files\n"
+ " untgz file.tgz fname ... extract selected files\n"
+ " untgz -l file.tgz list archive contents\n"
+ " untgz -h display this help\n");
+ exit(exitval);
+}
+
+void error(const char *msg)
+{
+ fprintf(stderr, "%s: %s\n", prog, msg);
+ exit(1);
+}
+
+
+/* ============================================================ */
+
+#if defined(WIN32) && defined(__GNUC__)
+int _CRT_glob = 0; /* disable argument globbing in MinGW */
+#endif
+
+int main(int argc,char **argv)
+{
+ int action = TGZ_EXTRACT;
+ int arg = 1;
+ char *TGZfile;
+ gzFile *f;
+
+ prog = strrchr(argv[0],'\\');
+ if (prog == NULL)
+ {
+ prog = strrchr(argv[0],'/');
+ if (prog == NULL)
+ {
+ prog = strrchr(argv[0],':');
+ if (prog == NULL)
+ prog = argv[0];
+ else
+ prog++;
+ }
+ else
+ prog++;
+ }
+ else
+ prog++;
+
+ if (argc == 1)
+ help(0);
+
+ if (strcmp(argv[arg],"-l") == 0)
+ {
+ action = TGZ_LIST;
+ if (argc == ++arg)
+ help(0);
+ }
+ else if (strcmp(argv[arg],"-h") == 0)
+ {
+ help(0);
+ }
+
+ if ((TGZfile = TGZfname(argv[arg])) == NULL)
+ TGZnotfound(argv[arg]);
+
+ ++arg;
+ if ((action == TGZ_LIST) && (arg != argc))
+ help(1);
+
+/*
+ * Process the TGZ file
+ */
+ switch(action)
+ {
+ case TGZ_LIST:
+ case TGZ_EXTRACT:
+ f = gzopen(TGZfile,"rb");
+ if (f == NULL)
+ {
+ fprintf(stderr,"%s: Couldn't gzopen %s\n",prog,TGZfile);
+ return 1;
+ }
+ exit(tar(f, action, arg, argc, argv));
+ break;
+
+ default:
+ error("Unknown option");
+ exit(1);
+ }
+
+ return 0;
+}
diff --git a/zlib/crc32.c b/zlib/crc32.c
new file mode 100644
index 000000000..9580440c0
--- /dev/null
+++ b/zlib/crc32.c
@@ -0,0 +1,442 @@
+/* crc32.c -- compute the CRC-32 of a data stream
+ * Copyright (C) 1995-2006, 2010, 2011, 2012, 2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ *
+ * Thanks to Rodney Brown <rbrown64@csc.com.au> 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 <stdio.h>
+# ifndef DYNAMIC_CRC_TABLE
+# define DYNAMIC_CRC_TABLE
+# endif /* !DYNAMIC_CRC_TABLE */
+#endif /* MAKECRCH */
+
+#include "zutil.h" /* for STDC and FAR definitions */
+
+/* Definitions for doing the crc four data bytes at a time. */
+#if !defined(NOBYFOUR) && defined(Z_U4)
+# define BYFOUR
+#endif
+#ifdef BYFOUR
+ local unsigned long crc32_little OF((unsigned long,
+ const unsigned char FAR *, z_size_t));
+ local unsigned long crc32_big OF((unsigned long,
+ const unsigned char FAR *, z_size_t));
+# define TBLS 8
+#else
+# define TBLS 1
+#endif /* BYFOUR */
+
+/* Local functions for crc concatenation */
+local unsigned long gf2_matrix_times OF((unsigned long *mat,
+ unsigned long vec));
+local void gf2_matrix_square OF((unsigned long *square, unsigned long *mat));
+local uLong crc32_combine_ OF((uLong crc1, uLong 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 long)(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 long ZEXPORT crc32_z(crc, buf, len)
+ unsigned long crc;
+ const unsigned char FAR *buf;
+ z_size_t 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;
+}
+
+/* ========================================================================= */
+unsigned long ZEXPORT crc32(crc, buf, len)
+ unsigned long crc;
+ const unsigned char FAR *buf;
+ uInt len;
+{
+ return crc32_z(crc, buf, len);
+}
+
+#ifdef BYFOUR
+
+/*
+ This BYFOUR code accesses the passed unsigned char * buffer with a 32-bit
+ integer pointer type. This violates the strict aliasing rule, where a
+ compiler can assume, for optimization purposes, that two pointers to
+ fundamentally different types won't ever point to the same memory. This can
+ manifest as a problem only if one of the pointers is written to. This code
+ only reads from those pointers. So long as this code remains isolated in
+ this compilation unit, there won't be a problem. For this reason, this code
+ should not be copied and pasted into a compilation unit in which other code
+ writes to the buffer that is passed to these routines.
+ */
+
+/* ========================================================================= */
+#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 long crc32_little(crc, buf, len)
+ unsigned long crc;
+ const unsigned char FAR *buf;
+ z_size_t 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 long)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 long crc32_big(crc, buf, len)
+ unsigned long crc;
+ const unsigned char FAR *buf;
+ z_size_t 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;
+ while (len >= 32) {
+ DOBIG32;
+ len -= 32;
+ }
+ while (len >= 4) {
+ DOBIG4;
+ len -= 4;
+ }
+ buf = (const unsigned char FAR *)buf4;
+
+ if (len) do {
+ c = crc_table[4][(c >> 24) ^ *buf++] ^ (c << 8);
+ } while (--len);
+ c = ~c;
+ return (unsigned long)(ZSWAP32(c));
+}
+
+#endif /* BYFOUR */
+
+#define GF2_DIM 32 /* dimension of GF(2) vectors (length of CRC) */
+
+/* ========================================================================= */
+local unsigned long gf2_matrix_times(mat, vec)
+ unsigned long *mat;
+ unsigned long vec;
+{
+ unsigned long sum;
+
+ sum = 0;
+ while (vec) {
+ if (vec & 1)
+ sum ^= *mat;
+ vec >>= 1;
+ mat++;
+ }
+ return sum;
+}
+
+/* ========================================================================= */
+local void gf2_matrix_square(square, mat)
+ unsigned long *square;
+ unsigned long *mat;
+{
+ int n;
+
+ for (n = 0; n < GF2_DIM; n++)
+ square[n] = gf2_matrix_times(mat, mat[n]);
+}
+
+/* ========================================================================= */
+local uLong crc32_combine_(crc1, crc2, len2)
+ uLong crc1;
+ uLong crc2;
+ z_off64_t len2;
+{
+ int n;
+ unsigned long row;
+ unsigned long even[GF2_DIM]; /* even-power-of-two zeros operator */
+ unsigned long 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;
+}
+
+/* ========================================================================= */
+uLong ZEXPORT crc32_combine(crc1, crc2, len2)
+ uLong crc1;
+ uLong crc2;
+ z_off_t len2;
+{
+ return crc32_combine_(crc1, crc2, len2);
+}
+
+uLong ZEXPORT crc32_combine64(crc1, crc2, len2)
+ uLong crc1;
+ uLong 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 000000000..9e0c77810
--- /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 000000000..1ec761448
--- /dev/null
+++ b/zlib/deflate.c
@@ -0,0 +1,2163 @@
+/* deflate.c -- compress data using the deflation algorithm
+ * Copyright (C) 1995-2017 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.11 Copyright 1995-2017 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 int deflateStateCheck OF((z_streamp strm));
+local void slide_hash OF((deflate_state *s));
+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 unsigned read_buf OF((z_streamp strm, Bytef *buf, unsigned size));
+#ifdef ASMV
+# pragma message("Assembler code may have bugs -- use at your own risk")
+ 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 ZLIB_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.
+ */
+
+/* rank Z_BLOCK between Z_NO_FLUSH and Z_PARTIAL_FLUSH */
+#define RANK(f) (((f) * 2) - ((f) > 4 ? 9 : 0))
+
+/* ===========================================================================
+ * Update a hash value with the given input byte
+ * IN assertion: all calls 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)<<s->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 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));
+
+/* ===========================================================================
+ * Slide the hash table when sliding the window down (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.
+ */
+local void slide_hash(s)
+ deflate_state *s;
+{
+ unsigned n, m;
+ Posf *p;
+ uInt wsize = s->w_size;
+
+ 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
+}
+
+/* ========================================================================= */
+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 || (windowBits == 8 && wrap != 1)) {
+ 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->status = INIT_STATE; /* to pass state test in deflateReset() */
+
+ s->wrap = wrap;
+ s->gzhead = Z_NULL;
+ s->w_bits = (uInt)windowBits;
+ s->w_size = 1 << s->w_bits;
+ s->w_mask = s->w_size - 1;
+
+ s->hash_bits = (uInt)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 = 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);
+}
+
+/* =========================================================================
+ * Check for a valid deflate stream state. Return 0 if ok, 1 if not.
+ */
+local int deflateStateCheck (strm)
+ z_streamp strm;
+{
+ deflate_state *s;
+ if (strm == Z_NULL ||
+ strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
+ return 1;
+ s = strm->state;
+ if (s == Z_NULL || s->strm != strm || (s->status != INIT_STATE &&
+#ifdef GZIP
+ s->status != GZIP_STATE &&
+#endif
+ s->status != EXTRA_STATE &&
+ s->status != NAME_STATE &&
+ s->status != COMMENT_STATE &&
+ s->status != HCRC_STATE &&
+ s->status != BUSY_STATE &&
+ s->status != FINISH_STATE))
+ return 1;
+ return 0;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateSetDictionary (strm, dictionary, dictLength)
+ z_streamp strm;
+ const Bytef *dictionary;
+ uInt dictLength;
+{
+ deflate_state *s;
+ uInt str, n;
+ int wrap;
+ unsigned avail;
+ z_const unsigned char *next;
+
+ if (deflateStateCheck(strm) || 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 = (z_const 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 = (long)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 deflateGetDictionary (strm, dictionary, dictLength)
+ z_streamp strm;
+ Bytef *dictionary;
+ uInt *dictLength;
+{
+ deflate_state *s;
+ uInt len;
+
+ if (deflateStateCheck(strm))
+ return Z_STREAM_ERROR;
+ s = strm->state;
+ len = s->strstart + s->lookahead;
+ if (len > s->w_size)
+ len = s->w_size;
+ if (dictionary != Z_NULL && len)
+ zmemcpy(dictionary, s->window + s->strstart + s->lookahead - len, len);
+ if (dictLength != Z_NULL)
+ *dictLength = len;
+ return Z_OK;
+}
+
+/* ========================================================================= */
+int ZEXPORT deflateResetKeep (strm)
+ z_streamp strm;
+{
+ deflate_state *s;
+
+ if (deflateStateCheck(strm)) {
+ 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 =
+#ifdef GZIP
+ s->wrap == 2 ? GZIP_STATE :
+#endif
+ 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 (deflateStateCheck(strm) || 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 (deflateStateCheck(strm)) 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 (deflateStateCheck(strm)) 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;
+
+ if (deflateStateCheck(strm)) 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) &&
+ s->high_water) {
+ /* Flush the last buffer: */
+ int err = deflate(strm, Z_BLOCK);
+ if (err == Z_STREAM_ERROR)
+ return err;
+ if (strm->avail_out == 0)
+ return Z_BUF_ERROR;
+ }
+ if (s->level != level) {
+ if (s->level == 0 && s->matches != 0) {
+ if (s->matches == 1)
+ slide_hash(s);
+ else
+ CLEAR_HASH(s);
+ s->matches = 0;
+ }
+ 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 Z_OK;
+}
+
+/* ========================================================================= */
+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 (deflateStateCheck(strm)) return Z_STREAM_ERROR;
+ s = strm->state;
+ s->good_match = (uInt)good_length;
+ s->max_lazy_match = (uInt)max_lazy;
+ s->nice_match = nice_length;
+ s->max_chain_length = (uInt)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.
+ */
+uLong ZEXPORT deflateBound(strm, sourceLen)
+ z_streamp strm;
+ uLong sourceLen;
+{
+ deflate_state *s;
+ uLong complen, wraplen;
+
+ /* 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 (deflateStateCheck(strm))
+ 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;
+#ifdef GZIP
+ case 2: /* gzip wrapper */
+ wraplen = 18;
+ if (s->gzhead != Z_NULL) { /* user-supplied gzip header */
+ Bytef *str;
+ 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;
+#endif
+ 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, except for
+ * some deflate_stored() 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;
+ }
+}
+
+/* ===========================================================================
+ * Update the header CRC with the bytes s->pending_buf[beg..s->pending - 1].
+ */
+#define HCRC_UPDATE(beg) \
+ do { \
+ if (s->gzhead->hcrc && s->pending > (beg)) \
+ strm->adler = crc32(strm->adler, s->pending_buf + (beg), \
+ s->pending - (beg)); \
+ } while (0)
+
+/* ========================================================================= */
+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 (deflateStateCheck(strm) || flush > Z_BLOCK || flush < 0) {
+ return Z_STREAM_ERROR;
+ }
+ s = strm->state;
+
+ if (strm->next_out == Z_NULL ||
+ (strm->avail_in != 0 && strm->next_in == Z_NULL) ||
+ (s->status == FINISH_STATE && flush != Z_FINISH)) {
+ ERR_RETURN(strm, Z_STREAM_ERROR);
+ }
+ if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);
+
+ old_flush = s->last_flush;
+ s->last_flush = flush;
+
+ /* 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);
+ }
+
+ /* Write the header */
+ if (s->status == INIT_STATE) {
+ /* zlib header */
+ 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);
+
+ 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);
+ s->status = BUSY_STATE;
+
+ /* Compression must start with an empty pending buffer */
+ flush_pending(strm);
+ if (s->pending != 0) {
+ s->last_flush = -1;
+ return Z_OK;
+ }
+ }
+#ifdef GZIP
+ if (s->status == GZIP_STATE) {
+ /* gzip header */
+ 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;
+
+ /* Compression must start with an empty pending buffer */
+ flush_pending(strm);
+ if (s->pending != 0) {
+ s->last_flush = -1;
+ return Z_OK;
+ }
+ }
+ 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;
+ }
+ }
+ if (s->status == EXTRA_STATE) {
+ if (s->gzhead->extra != Z_NULL) {
+ ulg beg = s->pending; /* start of bytes to update crc */
+ uInt left = (s->gzhead->extra_len & 0xffff) - s->gzindex;
+ while (s->pending + left > s->pending_buf_size) {
+ uInt copy = s->pending_buf_size - s->pending;
+ zmemcpy(s->pending_buf + s->pending,
+ s->gzhead->extra + s->gzindex, copy);
+ s->pending = s->pending_buf_size;
+ HCRC_UPDATE(beg);
+ s->gzindex += copy;
+ flush_pending(strm);
+ if (s->pending != 0) {
+ s->last_flush = -1;
+ return Z_OK;
+ }
+ beg = 0;
+ left -= copy;
+ }
+ zmemcpy(s->pending_buf + s->pending,
+ s->gzhead->extra + s->gzindex, left);
+ s->pending += left;
+ HCRC_UPDATE(beg);
+ s->gzindex = 0;
+ }
+ s->status = NAME_STATE;
+ }
+ if (s->status == NAME_STATE) {
+ if (s->gzhead->name != Z_NULL) {
+ ulg beg = s->pending; /* start of bytes to update crc */
+ int val;
+ do {
+ if (s->pending == s->pending_buf_size) {
+ HCRC_UPDATE(beg);
+ flush_pending(strm);
+ if (s->pending != 0) {
+ s->last_flush = -1;
+ return Z_OK;
+ }
+ beg = 0;
+ }
+ val = s->gzhead->name[s->gzindex++];
+ put_byte(s, val);
+ } while (val != 0);
+ HCRC_UPDATE(beg);
+ s->gzindex = 0;
+ }
+ s->status = COMMENT_STATE;
+ }
+ if (s->status == COMMENT_STATE) {
+ if (s->gzhead->comment != Z_NULL) {
+ ulg beg = s->pending; /* start of bytes to update crc */
+ int val;
+ do {
+ if (s->pending == s->pending_buf_size) {
+ HCRC_UPDATE(beg);
+ flush_pending(strm);
+ if (s->pending != 0) {
+ s->last_flush = -1;
+ return Z_OK;
+ }
+ beg = 0;
+ }
+ val = s->gzhead->comment[s->gzindex++];
+ put_byte(s, val);
+ } while (val != 0);
+ HCRC_UPDATE(beg);
+ }
+ 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 != 0) {
+ s->last_flush = -1;
+ return Z_OK;
+ }
+ }
+ 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;
+
+ /* Compression must start with an empty pending buffer */
+ flush_pending(strm);
+ if (s->pending != 0) {
+ s->last_flush = -1;
+ return Z_OK;
+ }
+ }
+#endif
+
+ /* 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->level == 0 ? deflate_stored(s, flush) :
+ 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;
+ }
+ }
+ }
+
+ 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 (deflateStateCheck(strm)) return Z_STREAM_ERROR;
+
+ status = strm->state->status;
+
+ /* 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 (deflateStateCheck(source) || dest == 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 unsigned 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 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 = (int)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 = (int)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 ZLIB_DEBUG
+
+#define EQUAL 0
+/* result of memcmp for equal strings */
+
+/* ===========================================================================
+ * 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 /* ZLIB_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;
+{
+ unsigned n;
+ 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 - more);
+ s->match_start -= wsize;
+ s->strstart -= wsize; /* we now have strstart >= MAX_DIST */
+ s->block_start -= (long) wsize;
+ slide_hash(s);
+ 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)((long)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; \
+}
+
+/* Maximum stored block length in deflate format (not including header). */
+#define MAX_STORED 65535
+
+/* Minimum of a and b. */
+#define MIN(a, b) ((a) > (b) ? (b) : (a))
+
+/* ===========================================================================
+ * Copy without compression as much as possible from the input stream, return
+ * the current block state.
+ *
+ * In case deflateParams() is used to later switch to a non-zero compression
+ * level, s->matches (otherwise unused when storing) keeps track of the number
+ * of hash table slides to perform. If s->matches is 1, then one hash table
+ * slide will be done when switching. If s->matches is 2, the maximum value
+ * allowed here, then the hash table will be cleared, since two or more slides
+ * is the same as a clear.
+ *
+ * deflate_stored() is written to minimize the number of times an input byte is
+ * copied. It is most efficient with large input and output buffers, which
+ * maximizes the opportunites to have a single copy from next_in to next_out.
+ */
+local block_state deflate_stored(s, flush)
+ deflate_state *s;
+ int flush;
+{
+ /* Smallest worthy block size when not flushing or finishing. By default
+ * this is 32K. This can be as small as 507 bytes for memLevel == 1. For
+ * large input and output buffers, the stored block size will be larger.
+ */
+ unsigned min_block = MIN(s->pending_buf_size - 5, s->w_size);
+
+ /* Copy as many min_block or larger stored blocks directly to next_out as
+ * possible. If flushing, copy the remaining available input to next_out as
+ * stored blocks, if there is enough space.
+ */
+ unsigned len, left, have, last = 0;
+ unsigned used = s->strm->avail_in;
+ do {
+ /* Set len to the maximum size block that we can copy directly with the
+ * available input data and output space. Set left to how much of that
+ * would be copied from what's left in the window.
+ */
+ len = MAX_STORED; /* maximum deflate stored block length */
+ have = (s->bi_valid + 42) >> 3; /* number of header bytes */
+ if (s->strm->avail_out < have) /* need room for header */
+ break;
+ /* maximum stored block length that will fit in avail_out: */
+ have = s->strm->avail_out - have;
+ left = s->strstart - s->block_start; /* bytes left in window */
+ if (len > (ulg)left + s->strm->avail_in)
+ len = left + s->strm->avail_in; /* limit len to the input */
+ if (len > have)
+ len = have; /* limit len to the output */
+
+ /* If the stored block would be less than min_block in length, or if
+ * unable to copy all of the available input when flushing, then try
+ * copying to the window and the pending buffer instead. Also don't
+ * write an empty block when flushing -- deflate() does that.
+ */
+ if (len < min_block && ((len == 0 && flush != Z_FINISH) ||
+ flush == Z_NO_FLUSH ||
+ len != left + s->strm->avail_in))
+ break;
+
+ /* Make a dummy stored block in pending to get the header bytes,
+ * including any pending bits. This also updates the debugging counts.
+ */
+ last = flush == Z_FINISH && len == left + s->strm->avail_in ? 1 : 0;
+ _tr_stored_block(s, (char *)0, 0L, last);
+
+ /* Replace the lengths in the dummy stored block with len. */
+ s->pending_buf[s->pending - 4] = len;
+ s->pending_buf[s->pending - 3] = len >> 8;
+ s->pending_buf[s->pending - 2] = ~len;
+ s->pending_buf[s->pending - 1] = ~len >> 8;
+
+ /* Write the stored block header bytes. */
+ flush_pending(s->strm);
+
+#ifdef ZLIB_DEBUG
+ /* Update debugging counts for the data about to be copied. */
+ s->compressed_len += len << 3;
+ s->bits_sent += len << 3;
+#endif
+
+ /* Copy uncompressed bytes from the window to next_out. */
+ if (left) {
+ if (left > len)
+ left = len;
+ zmemcpy(s->strm->next_out, s->window + s->block_start, left);
+ s->strm->next_out += left;
+ s->strm->avail_out -= left;
+ s->strm->total_out += left;
+ s->block_start += left;
+ len -= left;
+ }
+
+ /* Copy uncompressed bytes directly from next_in to next_out, updating
+ * the check value.
+ */
+ if (len) {
+ read_buf(s->strm, s->strm->next_out, len);
+ s->strm->next_out += len;
+ s->strm->avail_out -= len;
+ s->strm->total_out += len;
+ }
+ } while (last == 0);
+
+ /* Update the sliding window with the last s->w_size bytes of the copied
+ * data, or append all of the copied data to the existing window if less
+ * than s->w_size bytes were copied. Also update the number of bytes to
+ * insert in the hash tables, in the event that deflateParams() switches to
+ * a non-zero compression level.
+ */
+ used -= s->strm->avail_in; /* number of input bytes directly copied */
+ if (used) {
+ /* If any input was used, then no unused input remains in the window,
+ * therefore s->block_start == s->strstart.
+ */
+ if (used >= s->w_size) { /* supplant the previous history */
+ s->matches = 2; /* clear hash */
+ zmemcpy(s->window, s->strm->next_in - s->w_size, s->w_size);
+ s->strstart = s->w_size;
+ }
+ else {
+ if (s->window_size - s->strstart <= used) {
+ /* Slide the window down. */
+ s->strstart -= s->w_size;
+ zmemcpy(s->window, s->window + s->w_size, s->strstart);
+ if (s->matches < 2)
+ s->matches++; /* add a pending slide_hash() */
+ }
+ zmemcpy(s->window + s->strstart, s->strm->next_in - used, used);
+ s->strstart += used;
+ }
+ s->block_start = s->strstart;
+ s->insert += MIN(used, s->w_size - s->insert);
+ }
+ if (s->high_water < s->strstart)
+ s->high_water = s->strstart;
+
+ /* If the last block was written to next_out, then done. */
+ if (last)
+ return finish_done;
+
+ /* If flushing and all input has been consumed, then done. */
+ if (flush != Z_NO_FLUSH && flush != Z_FINISH &&
+ s->strm->avail_in == 0 && (long)s->strstart == s->block_start)
+ return block_done;
+
+ /* Fill the window with any remaining input. */
+ have = s->window_size - s->strstart - 1;
+ if (s->strm->avail_in > have && s->block_start >= (long)s->w_size) {
+ /* Slide the window down. */
+ s->block_start -= s->w_size;
+ s->strstart -= s->w_size;
+ zmemcpy(s->window, s->window + s->w_size, s->strstart);
+ if (s->matches < 2)
+ s->matches++; /* add a pending slide_hash() */
+ have += s->w_size; /* more space now */
+ }
+ if (have > s->strm->avail_in)
+ have = s->strm->avail_in;
+ if (have) {
+ read_buf(s->strm, s->window + s->strstart, have);
+ s->strstart += have;
+ }
+ if (s->high_water < s->strstart)
+ s->high_water = s->strstart;
+
+ /* There was not enough avail_out to write a complete worthy or flushed
+ * stored block to next_out. Write a stored block to pending instead, if we
+ * have enough input for a worthy block, or if flushing and there is enough
+ * room for the remaining input as a stored block in the pending buffer.
+ */
+ have = (s->bi_valid + 42) >> 3; /* number of header bytes */
+ /* maximum stored block length that will fit in pending: */
+ have = MIN(s->pending_buf_size - have, MAX_STORED);
+ min_block = MIN(have, s->w_size);
+ left = s->strstart - s->block_start;
+ if (left >= min_block ||
+ ((left || flush == Z_FINISH) && flush != Z_NO_FLUSH &&
+ s->strm->avail_in == 0 && left <= have)) {
+ len = MIN(left, have);
+ last = flush == Z_FINISH && s->strm->avail_in == 0 &&
+ len == left ? 1 : 0;
+ _tr_stored_block(s, (charf *)s->window + s->block_start, len, last);
+ s->block_start += len;
+ flush_pending(s->strm);
+ }
+
+ /* We've done all we can with the available input and output. */
+ return last ? finish_started : need_more;
+}
+
+/* ===========================================================================
+ * 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 - (uInt)(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 000000000..23ecdd312
--- /dev/null
+++ b/zlib/deflate.h
@@ -0,0 +1,349 @@
+/* deflate.h -- internal compression state
+ * Copyright (C) 1995-2016 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 /* zlib header -> BUSY_STATE */
+#ifdef GZIP
+# define GZIP_STATE 57 /* gzip header -> BUSY_STATE | EXTRA_STATE */
+#endif
+#define EXTRA_STATE 69 /* gzip extra block -> NAME_STATE */
+#define NAME_STATE 73 /* gzip file name -> COMMENT_STATE */
+#define COMMENT_STATE 91 /* gzip comment -> HCRC_STATE */
+#define HCRC_STATE 103 /* gzip header CRC -> BUSY_STATE */
+#define BUSY_STATE 113 /* deflate -> FINISH_STATE */
+#define FINISH_STATE 666 /* stream complete */
+/* 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 */
+ const 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 */
+ ulg 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 */
+ ulg gzindex; /* where in extra, name, or comment */
+ Byte method; /* can only be 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
+ */
+
+ long 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 ZLIB_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++] = (Bytef)(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 ZLIB_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 = (uch)(length); \
+ ush dist = (ush)(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/doc/algorithm.txt b/zlib/doc/algorithm.txt
new file mode 100644
index 000000000..c97f49502
--- /dev/null
+++ b/zlib/doc/algorithm.txt
@@ -0,0 +1,209 @@
+1. Compression algorithm (deflate)
+
+The deflation algorithm used by gzip (also zip and zlib) is a variation of
+LZ77 (Lempel-Ziv 1977, see reference below). It finds duplicated strings in
+the input data. The second occurrence of a string is replaced by a
+pointer to the previous string, in the form of a pair (distance,
+length). Distances are limited to 32K bytes, and lengths are limited
+to 258 bytes. When a string does not occur anywhere in the previous
+32K bytes, it is emitted as a sequence of literal bytes. (In this
+description, `string' must be taken as an arbitrary sequence of bytes,
+and is not restricted to printable characters.)
+
+Literals or match lengths are compressed with one Huffman tree, and
+match distances are compressed with another tree. The trees are stored
+in a compact form at the start of each block. The blocks can have any
+size (except that the compressed data for one block must fit in
+available memory). A block is terminated when deflate() determines that
+it would be useful to start another block with fresh trees. (This is
+somewhat similar to the behavior of LZW-based _compress_.)
+
+Duplicated strings are found using a hash table. All input strings of
+length 3 are inserted in the hash table. A hash index is computed for
+the next 3 bytes. If the hash chain for this index is not empty, all
+strings in the chain are compared with the current input string, and
+the longest match is selected.
+
+The hash chains are searched starting with the most recent strings, to
+favor small distances and thus take advantage of the Huffman encoding.
+The hash chains are singly linked. There are no deletions from the
+hash chains, the algorithm simply discards matches that are too old.
+
+To avoid a worst-case situation, very long hash chains are arbitrarily
+truncated at a certain length, determined by a runtime option (level
+parameter of deflateInit). So deflate() does not always find the longest
+possible match but generally finds a match which is long enough.
+
+deflate() also defers the selection of matches with a lazy evaluation
+mechanism. After a match of length N has been found, deflate() searches for
+a longer match at the next input byte. If a longer match is found, the
+previous match is truncated to a length of one (thus producing a single
+literal byte) and the process of lazy evaluation begins again. Otherwise,
+the original match is kept, and the next match search is attempted only N
+steps later.
+
+The lazy match evaluation is also subject to a runtime parameter. If
+the current match is long enough, deflate() reduces the search for a longer
+match, thus speeding up the whole process. If compression ratio is more
+important than speed, deflate() attempts a complete second search even if
+the first match is already long enough.
+
+The lazy match evaluation is not performed for the fastest compression
+modes (level parameter 1 to 3). For these fast modes, new strings
+are inserted in the hash table only when no match was found, or
+when the match is not too long. This degrades the compression ratio
+but saves time since there are both fewer insertions and fewer searches.
+
+
+2. Decompression algorithm (inflate)
+
+2.1 Introduction
+
+The key question is how to represent a Huffman code (or any prefix code) so
+that you can decode fast. The most important characteristic is that shorter
+codes are much more common than longer codes, so pay attention to decoding the
+short codes fast, and let the long codes take longer to decode.
+
+inflate() sets up a first level table that covers some number of bits of
+input less than the length of longest code. It gets that many bits from the
+stream, and looks it up in the table. The table will tell if the next
+code is that many bits or less and how many, and if it is, it will tell
+the value, else it will point to the next level table for which inflate()
+grabs more bits and tries to decode a longer code.
+
+How many bits to make the first lookup is a tradeoff between the time it
+takes to decode and the time it takes to build the table. If building the
+table took no time (and if you had infinite memory), then there would only
+be a first level table to cover all the way to the longest code. However,
+building the table ends up taking a lot longer for more bits since short
+codes are replicated many times in such a table. What inflate() does is
+simply to make the number of bits in the first table a variable, and then
+to set that variable for the maximum speed.
+
+For inflate, which has 286 possible codes for the literal/length tree, the size
+of the first table is nine bits. Also the distance trees have 30 possible
+values, and the size of the first table is six bits. Note that for each of
+those cases, the table ended up one bit longer than the ``average'' code
+length, i.e. the code length of an approximately flat code which would be a
+little more than eight bits for 286 symbols and a little less than five bits
+for 30 symbols.
+
+
+2.2 More details on the inflate table lookup
+
+Ok, you want to know what this cleverly obfuscated inflate tree actually
+looks like. You are correct that it's not a Huffman tree. It is simply a
+lookup table for the first, let's say, nine bits of a Huffman symbol. The
+symbol could be as short as one bit or as long as 15 bits. If a particular
+symbol is shorter than nine bits, then that symbol's translation is duplicated
+in all those entries that start with that symbol's bits. For example, if the
+symbol is four bits, then it's duplicated 32 times in a nine-bit table. If a
+symbol is nine bits long, it appears in the table once.
+
+If the symbol is longer than nine bits, then that entry in the table points
+to another similar table for the remaining bits. Again, there are duplicated
+entries as needed. The idea is that most of the time the symbol will be short
+and there will only be one table look up. (That's whole idea behind data
+compression in the first place.) For the less frequent long symbols, there
+will be two lookups. If you had a compression method with really long
+symbols, you could have as many levels of lookups as is efficient. For
+inflate, two is enough.
+
+So a table entry either points to another table (in which case nine bits in
+the above example are gobbled), or it contains the translation for the symbol
+and the number of bits to gobble. Then you start again with the next
+ungobbled bit.
+
+You may wonder: why not just have one lookup table for how ever many bits the
+longest symbol is? The reason is that if you do that, you end up spending
+more time filling in duplicate symbol entries than you do actually decoding.
+At least for deflate's output that generates new trees every several 10's of
+kbytes. You can imagine that filling in a 2^15 entry table for a 15-bit code
+would take too long if you're only decoding several thousand symbols. At the
+other extreme, you could make a new table for every bit in the code. In fact,
+that's essentially a Huffman tree. But then you spend too much time
+traversing the tree while decoding, even for short symbols.
+
+So the number of bits for the first lookup table is a trade of the time to
+fill out the table vs. the time spent looking at the second level and above of
+the table.
+
+Here is an example, scaled down:
+
+The code being decoded, with 10 symbols, from 1 to 6 bits long:
+
+A: 0
+B: 10
+C: 1100
+D: 11010
+E: 11011
+F: 11100
+G: 11101
+H: 11110
+I: 111110
+J: 111111
+
+Let's make the first table three bits long (eight entries):
+
+000: A,1
+001: A,1
+010: A,1
+011: A,1
+100: B,2
+101: B,2
+110: -> table X (gobble 3 bits)
+111: -> table Y (gobble 3 bits)
+
+Each entry is what the bits decode as and how many bits that is, i.e. how
+many bits to gobble. Or the entry points to another table, with the number of
+bits to gobble implicit in the size of the table.
+
+Table X is two bits long since the longest code starting with 110 is five bits
+long:
+
+00: C,1
+01: C,1
+10: D,2
+11: E,2
+
+Table Y is three bits long since the longest code starting with 111 is six
+bits long:
+
+000: F,2
+001: F,2
+010: G,2
+011: G,2
+100: H,2
+101: H,2
+110: I,3
+111: J,3
+
+So what we have here are three tables with a total of 20 entries that had to
+be constructed. That's compared to 64 entries for a single table. Or
+compared to 16 entries for a Huffman tree (six two entry tables and one four
+entry table). Assuming that the code ideally represents the probability of
+the symbols, it takes on the average 1.25 lookups per symbol. That's compared
+to one lookup for the single table, or 1.66 lookups per symbol for the
+Huffman tree.
+
+There, I think that gives you a picture of what's going on. For inflate, the
+meaning of a particular symbol is often more than just a letter. It can be a
+byte (a "literal"), or it can be either a length or a distance which
+indicates a base value and a number of bits to fetch after the code that is
+added to the base value. Or it might be the special end-of-block code. The
+data structures created in inftrees.c try to encode all that information
+compactly in the tables.
+
+
+Jean-loup Gailly Mark Adler
+jloup@gzip.org madler@alumni.caltech.edu
+
+
+References:
+
+[LZ77] Ziv J., Lempel A., ``A Universal Algorithm for Sequential Data
+Compression,'' IEEE Transactions on Information Theory, Vol. 23, No. 3,
+pp. 337-343.
+
+``DEFLATE Compressed Data Format Specification'' available in
+http://tools.ietf.org/html/rfc1951
diff --git a/zlib/doc/rfc1950.txt b/zlib/doc/rfc1950.txt
new file mode 100644
index 000000000..ce6428a0f
--- /dev/null
+++ b/zlib/doc/rfc1950.txt
@@ -0,0 +1,619 @@
+
+
+
+
+
+
+Network Working Group P. Deutsch
+Request for Comments: 1950 Aladdin Enterprises
+Category: Informational J-L. Gailly
+ Info-ZIP
+ May 1996
+
+
+ ZLIB Compressed Data Format Specification version 3.3
+
+Status of This Memo
+
+ This memo provides information for the Internet community. This memo
+ does not specify an Internet standard of any kind. Distribution of
+ this memo is unlimited.
+
+IESG Note:
+
+ The IESG takes no position on the validity of any Intellectual
+ Property Rights statements contained in this document.
+
+Notices
+
+ Copyright (c) 1996 L. Peter Deutsch and Jean-Loup Gailly
+
+ Permission is granted to copy and distribute this document for any
+ purpose and without charge, including translations into other
+ languages and incorporation into compilations, provided that the
+ copyright notice and this notice are preserved, and that any
+ substantive changes or deletions from the original are clearly
+ marked.
+
+ A pointer to the latest version of this and related documentation in
+ HTML format can be found at the URL
+ <ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html>.
+
+Abstract
+
+ This specification defines a lossless compressed data format. The
+ data can be produced or consumed, even for an arbitrarily long
+ sequentially presented input data stream, using only an a priori
+ bounded amount of intermediate storage. The format presently uses
+ the DEFLATE compression method but can be easily extended to use
+ other compression methods. It can be implemented readily in a manner
+ not covered by patents. This specification also defines the ADLER-32
+ checksum (an extension and improvement of the Fletcher checksum),
+ used for detection of data corruption, and provides an algorithm for
+ computing it.
+
+
+
+
+Deutsch & Gailly Informational [Page 1]
+
+RFC 1950 ZLIB Compressed Data Format Specification May 1996
+
+
+Table of Contents
+
+ 1. Introduction ................................................... 2
+ 1.1. Purpose ................................................... 2
+ 1.2. Intended audience ......................................... 3
+ 1.3. Scope ..................................................... 3
+ 1.4. Compliance ................................................ 3
+ 1.5. Definitions of terms and conventions used ................ 3
+ 1.6. Changes from previous versions ............................ 3
+ 2. Detailed specification ......................................... 3
+ 2.1. Overall conventions ....................................... 3
+ 2.2. Data format ............................................... 4
+ 2.3. Compliance ................................................ 7
+ 3. References ..................................................... 7
+ 4. Source code .................................................... 8
+ 5. Security Considerations ........................................ 8
+ 6. Acknowledgements ............................................... 8
+ 7. Authors' Addresses ............................................. 8
+ 8. Appendix: Rationale ............................................ 9
+ 9. Appendix: Sample code ..........................................10
+
+1. Introduction
+
+ 1.1. Purpose
+
+ The purpose of this specification is to define a lossless
+ compressed data format that:
+
+ * Is independent of CPU type, operating system, file system,
+ and character set, and hence can be used for interchange;
+
+ * Can be produced or consumed, even for an arbitrarily long
+ sequentially presented input data stream, using only an a
+ priori bounded amount of intermediate storage, and hence can
+ be used in data communications or similar structures such as
+ Unix filters;
+
+ * Can use a number of different compression methods;
+
+ * Can be implemented readily in a manner not covered by
+ patents, and hence can be practiced freely.
+
+ The data format defined by this specification does not attempt to
+ allow random access to compressed data.
+
+
+
+
+
+
+
+Deutsch & Gailly Informational [Page 2]
+
+RFC 1950 ZLIB Compressed Data Format Specification May 1996
+
+
+ 1.2. Intended audience
+
+ This specification is intended for use by implementors of software
+ to compress data into zlib format and/or decompress data from zlib
+ format.
+
+ The text of the specification assumes a basic background in
+ programming at the level of bits and other primitive data
+ representations.
+
+ 1.3. Scope
+
+ The specification specifies a compressed data format that can be
+ used for in-memory compression of a sequence of arbitrary bytes.
+
+ 1.4. Compliance
+
+ Unless otherwise indicated below, a compliant decompressor must be
+ able to accept and decompress any data set that conforms to all
+ the specifications presented here; a compliant compressor must
+ produce data sets that conform to all the specifications presented
+ here.
+
+ 1.5. Definitions of terms and conventions used
+
+ byte: 8 bits stored or transmitted as a unit (same as an octet).
+ (For this specification, a byte is exactly 8 bits, even on
+ machines which store a character on a number of bits different
+ from 8.) See below, for the numbering of bits within a byte.
+
+ 1.6. Changes from previous versions
+
+ Version 3.1 was the first public release of this specification.
+ In version 3.2, some terminology was changed and the Adler-32
+ sample code was rewritten for clarity. In version 3.3, the
+ support for a preset dictionary was introduced, and the
+ specification was converted to RFC style.
+
+2. Detailed specification
+
+ 2.1. Overall conventions
+
+ In the diagrams below, a box like this:
+
+ +---+
+ | | <-- the vertical bars might be missing
+ +---+
+
+
+
+
+Deutsch & Gailly Informational [Page 3]
+
+RFC 1950 ZLIB Compressed Data Format Specification May 1996
+
+
+ represents one byte; a box like this:
+
+ +==============+
+ | |
+ +==============+
+
+ represents a variable number of bytes.
+
+ Bytes stored within a computer do not have a "bit order", since
+ they are always treated as a unit. However, a byte considered as
+ an integer between 0 and 255 does have a most- and least-
+ significant bit, and since we write numbers with the most-
+ significant digit on the left, we also write bytes with the most-
+ significant bit on the left. In the diagrams below, we number the
+ bits of a byte so that bit 0 is the least-significant bit, i.e.,
+ the bits are numbered:
+
+ +--------+
+ |76543210|
+ +--------+
+
+ Within a computer, a number may occupy multiple bytes. All
+ multi-byte numbers in the format described here are stored with
+ the MOST-significant byte first (at the lower memory address).
+ For example, the decimal number 520 is stored as:
+
+ 0 1
+ +--------+--------+
+ |00000010|00001000|
+ +--------+--------+
+ ^ ^
+ | |
+ | + less significant byte = 8
+ + more significant byte = 2 x 256
+
+ 2.2. Data format
+
+ A zlib stream has the following structure:
+
+ 0 1
+ +---+---+
+ |CMF|FLG| (more-->)
+ +---+---+
+
+
+
+
+
+
+
+
+Deutsch & Gailly Informational [Page 4]
+
+RFC 1950 ZLIB Compressed Data Format Specification May 1996
+
+
+ (if FLG.FDICT set)
+
+ 0 1 2 3
+ +---+---+---+---+
+ | DICTID | (more-->)
+ +---+---+---+---+
+
+ +=====================+---+---+---+---+
+ |...compressed data...| ADLER32 |
+ +=====================+---+---+---+---+
+
+ Any data which may appear after ADLER32 are not part of the zlib
+ stream.
+
+ CMF (Compression Method and flags)
+ This byte is divided into a 4-bit compression method and a 4-
+ bit information field depending on the compression method.
+
+ bits 0 to 3 CM Compression method
+ bits 4 to 7 CINFO Compression info
+
+ CM (Compression method)
+ This identifies the compression method used in the file. CM = 8
+ denotes the "deflate" compression method with a window size up
+ to 32K. This is the method used by gzip and PNG (see
+ references [1] and [2] in Chapter 3, below, for the reference
+ documents). CM = 15 is reserved. It might be used in a future
+ version of this specification to indicate the presence of an
+ extra field before the compressed data.
+
+ CINFO (Compression info)
+ For CM = 8, CINFO is the base-2 logarithm of the LZ77 window
+ size, minus eight (CINFO=7 indicates a 32K window size). Values
+ of CINFO above 7 are not allowed in this version of the
+ specification. CINFO is not defined in this specification for
+ CM not equal to 8.
+
+ FLG (FLaGs)
+ This flag byte is divided as follows:
+
+ bits 0 to 4 FCHECK (check bits for CMF and FLG)
+ bit 5 FDICT (preset dictionary)
+ bits 6 to 7 FLEVEL (compression level)
+
+ The FCHECK value must be such that CMF and FLG, when viewed as
+ a 16-bit unsigned integer stored in MSB order (CMF*256 + FLG),
+ is a multiple of 31.
+
+
+
+
+Deutsch & Gailly Informational [Page 5]
+
+RFC 1950 ZLIB Compressed Data Format Specification May 1996
+
+
+ FDICT (Preset dictionary)
+ If FDICT is set, a DICT dictionary identifier is present
+ immediately after the FLG byte. The dictionary is a sequence of
+ bytes which are initially fed to the compressor without
+ producing any compressed output. DICT is the Adler-32 checksum
+ of this sequence of bytes (see the definition of ADLER32
+ below). The decompressor can use this identifier to determine
+ which dictionary has been used by the compressor.
+
+ FLEVEL (Compression level)
+ These flags are available for use by specific compression
+ methods. The "deflate" method (CM = 8) sets these flags as
+ follows:
+
+ 0 - compressor used fastest algorithm
+ 1 - compressor used fast algorithm
+ 2 - compressor used default algorithm
+ 3 - compressor used maximum compression, slowest algorithm
+
+ The information in FLEVEL is not needed for decompression; it
+ is there to indicate if recompression might be worthwhile.
+
+ compressed data
+ For compression method 8, the compressed data is stored in the
+ deflate compressed data format as described in the document
+ "DEFLATE Compressed Data Format Specification" by L. Peter
+ Deutsch. (See reference [3] in Chapter 3, below)
+
+ Other compressed data formats are not specified in this version
+ of the zlib specification.
+
+ ADLER32 (Adler-32 checksum)
+ This contains a checksum value of the uncompressed data
+ (excluding any dictionary data) computed according to Adler-32
+ algorithm. This algorithm is a 32-bit extension and improvement
+ of the Fletcher algorithm, used in the ITU-T X.224 / ISO 8073
+ standard. See references [4] and [5] in Chapter 3, below)
+
+ Adler-32 is composed of two sums accumulated per byte: s1 is
+ the sum of all bytes, s2 is the sum of all s1 values. Both sums
+ are done modulo 65521. s1 is initialized to 1, s2 to zero. The
+ Adler-32 checksum is stored as s2*65536 + s1 in most-
+ significant-byte first (network) order.
+
+
+
+
+
+
+
+
+Deutsch & Gailly Informational [Page 6]
+
+RFC 1950 ZLIB Compressed Data Format Specification May 1996
+
+
+ 2.3. Compliance
+
+ A compliant compressor must produce streams with correct CMF, FLG
+ and ADLER32, but need not support preset dictionaries. When the
+ zlib data format is used as part of another standard data format,
+ the compressor may use only preset dictionaries that are specified
+ by this other data format. If this other format does not use the
+ preset dictionary feature, the compressor must not set the FDICT
+ flag.
+
+ A compliant decompressor must check CMF, FLG, and ADLER32, and
+ provide an error indication if any of these have incorrect values.
+ A compliant decompressor must give an error indication if CM is
+ not one of the values defined in this specification (only the
+ value 8 is permitted in this version), since another value could
+ indicate the presence of new features that would cause subsequent
+ data to be interpreted incorrectly. A compliant decompressor must
+ give an error indication if FDICT is set and DICTID is not the
+ identifier of a known preset dictionary. A decompressor may
+ ignore FLEVEL and still be compliant. When the zlib data format
+ is being used as a part of another standard format, a compliant
+ decompressor must support all the preset dictionaries specified by
+ the other format. When the other format does not use the preset
+ dictionary feature, a compliant decompressor must reject any
+ stream in which the FDICT flag is set.
+
+3. References
+
+ [1] Deutsch, L.P.,"GZIP Compressed Data Format Specification",
+ available in ftp://ftp.uu.net/pub/archiving/zip/doc/
+
+ [2] Thomas Boutell, "PNG (Portable Network Graphics) specification",
+ available in ftp://ftp.uu.net/graphics/png/documents/
+
+ [3] Deutsch, L.P.,"DEFLATE Compressed Data Format Specification",
+ available in ftp://ftp.uu.net/pub/archiving/zip/doc/
+
+ [4] Fletcher, J. G., "An Arithmetic Checksum for Serial
+ Transmissions," IEEE Transactions on Communications, Vol. COM-30,
+ No. 1, January 1982, pp. 247-252.
+
+ [5] ITU-T Recommendation X.224, Annex D, "Checksum Algorithms,"
+ November, 1993, pp. 144, 145. (Available from
+ gopher://info.itu.ch). ITU-T X.244 is also the same as ISO 8073.
+
+
+
+
+
+
+
+Deutsch & Gailly Informational [Page 7]
+
+RFC 1950 ZLIB Compressed Data Format Specification May 1996
+
+
+4. Source code
+
+ Source code for a C language implementation of a "zlib" compliant
+ library is available at ftp://ftp.uu.net/pub/archiving/zip/zlib/.
+
+5. Security Considerations
+
+ A decoder that fails to check the ADLER32 checksum value may be
+ subject to undetected data corruption.
+
+6. Acknowledgements
+
+ Trademarks cited in this document are the property of their
+ respective owners.
+
+ Jean-Loup Gailly and Mark Adler designed the zlib format and wrote
+ the related software described in this specification. Glenn
+ Randers-Pehrson converted this document to RFC and HTML format.
+
+7. Authors' Addresses
+
+ L. Peter Deutsch
+ Aladdin Enterprises
+ 203 Santa Margarita Ave.
+ Menlo Park, CA 94025
+
+ Phone: (415) 322-0103 (AM only)
+ FAX: (415) 322-1734
+ EMail: <ghost@aladdin.com>
+
+
+ Jean-Loup Gailly
+
+ EMail: <gzip@prep.ai.mit.edu>
+
+ Questions about the technical content of this specification can be
+ sent by email to
+
+ Jean-Loup Gailly <gzip@prep.ai.mit.edu> and
+ Mark Adler <madler@alumni.caltech.edu>
+
+ Editorial comments on this specification can be sent by email to
+
+ L. Peter Deutsch <ghost@aladdin.com> and
+ Glenn Randers-Pehrson <randeg@alumni.rpi.edu>
+
+
+
+
+
+
+Deutsch & Gailly Informational [Page 8]
+
+RFC 1950 ZLIB Compressed Data Format Specification May 1996
+
+
+8. Appendix: Rationale
+
+ 8.1. Preset dictionaries
+
+ A preset dictionary is specially useful to compress short input
+ sequences. The compressor can take advantage of the dictionary
+ context to encode the input in a more compact manner. The
+ decompressor can be initialized with the appropriate context by
+ virtually decompressing a compressed version of the dictionary
+ without producing any output. However for certain compression
+ algorithms such as the deflate algorithm this operation can be
+ achieved without actually performing any decompression.
+
+ The compressor and the decompressor must use exactly the same
+ dictionary. The dictionary may be fixed or may be chosen among a
+ certain number of predefined dictionaries, according to the kind
+ of input data. The decompressor can determine which dictionary has
+ been chosen by the compressor by checking the dictionary
+ identifier. This document does not specify the contents of
+ predefined dictionaries, since the optimal dictionaries are
+ application specific. Standard data formats using this feature of
+ the zlib specification must precisely define the allowed
+ dictionaries.
+
+ 8.2. The Adler-32 algorithm
+
+ The Adler-32 algorithm is much faster than the CRC32 algorithm yet
+ still provides an extremely low probability of undetected errors.
+
+ The modulo on unsigned long accumulators can be delayed for 5552
+ bytes, so the modulo operation time is negligible. If the bytes
+ are a, b, c, the second sum is 3a + 2b + c + 3, and so is position
+ and order sensitive, unlike the first sum, which is just a
+ checksum. That 65521 is prime is important to avoid a possible
+ large class of two-byte errors that leave the check unchanged.
+ (The Fletcher checksum uses 255, which is not prime and which also
+ makes the Fletcher check insensitive to single byte changes 0 <->
+ 255.)
+
+ The sum s1 is initialized to 1 instead of zero to make the length
+ of the sequence part of s2, so that the length does not have to be
+ checked separately. (Any sequence of zeroes has a Fletcher
+ checksum of zero.)
+
+
+
+
+
+
+
+
+Deutsch & Gailly Informational [Page 9]
+
+RFC 1950 ZLIB Compressed Data Format Specification May 1996
+
+
+9. Appendix: Sample code
+
+ The following C code computes the Adler-32 checksum of a data buffer.
+ It is written for clarity, not for speed. The sample code is in the
+ ANSI C programming language. Non C users may find it easier to read
+ with these hints:
+
+ & Bitwise AND operator.
+ >> Bitwise right shift operator. When applied to an
+ unsigned quantity, as here, right shift inserts zero bit(s)
+ at the left.
+ << Bitwise left shift operator. Left shift inserts zero
+ bit(s) at the right.
+ ++ "n++" increments the variable n.
+ % modulo operator: a % b is the remainder of a divided by b.
+
+ #define BASE 65521 /* largest prime smaller than 65536 */
+
+ /*
+ Update a running Adler-32 checksum with the bytes buf[0..len-1]
+ and return the updated checksum. The Adler-32 checksum should be
+ initialized to 1.
+
+ Usage example:
+
+ unsigned long adler = 1L;
+
+ while (read_buffer(buffer, length) != EOF) {
+ adler = update_adler32(adler, buffer, length);
+ }
+ if (adler != original_adler) error();
+ */
+ unsigned long update_adler32(unsigned long adler,
+ unsigned char *buf, int len)
+ {
+ unsigned long s1 = adler & 0xffff;
+ unsigned long s2 = (adler >> 16) & 0xffff;
+ int n;
+
+ for (n = 0; n < len; n++) {
+ s1 = (s1 + buf[n]) % BASE;
+ s2 = (s2 + s1) % BASE;
+ }
+ return (s2 << 16) + s1;
+ }
+
+ /* Return the adler32 of the bytes buf[0..len-1] */
+
+
+
+
+Deutsch & Gailly Informational [Page 10]
+
+RFC 1950 ZLIB Compressed Data Format Specification May 1996
+
+
+ unsigned long adler32(unsigned char *buf, int len)
+ {
+ return update_adler32(1L, buf, len);
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Deutsch & Gailly Informational [Page 11]
+
diff --git a/zlib/doc/rfc1951.txt b/zlib/doc/rfc1951.txt
new file mode 100644
index 000000000..403c8c722
--- /dev/null
+++ b/zlib/doc/rfc1951.txt
@@ -0,0 +1,955 @@
+
+
+
+
+
+
+Network Working Group P. Deutsch
+Request for Comments: 1951 Aladdin Enterprises
+Category: Informational May 1996
+
+
+ DEFLATE Compressed Data Format Specification version 1.3
+
+Status of This Memo
+
+ This memo provides information for the Internet community. This memo
+ does not specify an Internet standard of any kind. Distribution of
+ this memo is unlimited.
+
+IESG Note:
+
+ The IESG takes no position on the validity of any Intellectual
+ Property Rights statements contained in this document.
+
+Notices
+
+ Copyright (c) 1996 L. Peter Deutsch
+
+ Permission is granted to copy and distribute this document for any
+ purpose and without charge, including translations into other
+ languages and incorporation into compilations, provided that the
+ copyright notice and this notice are preserved, and that any
+ substantive changes or deletions from the original are clearly
+ marked.
+
+ A pointer to the latest version of this and related documentation in
+ HTML format can be found at the URL
+ <ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html>.
+
+Abstract
+
+ This specification defines a lossless compressed data format that
+ compresses data using a combination of the LZ77 algorithm and Huffman
+ coding, with efficiency comparable to the best currently available
+ general-purpose compression methods. The data can be produced or
+ consumed, even for an arbitrarily long sequentially presented input
+ data stream, using only an a priori bounded amount of intermediate
+ storage. The format can be implemented readily in a manner not
+ covered by patents.
+
+
+
+
+
+
+
+
+Deutsch Informational [Page 1]
+
+RFC 1951 DEFLATE Compressed Data Format Specification May 1996
+
+
+Table of Contents
+
+ 1. Introduction ................................................... 2
+ 1.1. Purpose ................................................... 2
+ 1.2. Intended audience ......................................... 3
+ 1.3. Scope ..................................................... 3
+ 1.4. Compliance ................................................ 3
+ 1.5. Definitions of terms and conventions used ................ 3
+ 1.6. Changes from previous versions ............................ 4
+ 2. Compressed representation overview ............................. 4
+ 3. Detailed specification ......................................... 5
+ 3.1. Overall conventions ....................................... 5
+ 3.1.1. Packing into bytes .................................. 5
+ 3.2. Compressed block format ................................... 6
+ 3.2.1. Synopsis of prefix and Huffman coding ............... 6
+ 3.2.2. Use of Huffman coding in the "deflate" format ....... 7
+ 3.2.3. Details of block format ............................. 9
+ 3.2.4. Non-compressed blocks (BTYPE=00) ................... 11
+ 3.2.5. Compressed blocks (length and distance codes) ...... 11
+ 3.2.6. Compression with fixed Huffman codes (BTYPE=01) .... 12
+ 3.2.7. Compression with dynamic Huffman codes (BTYPE=10) .. 13
+ 3.3. Compliance ............................................... 14
+ 4. Compression algorithm details ................................. 14
+ 5. References .................................................... 16
+ 6. Security Considerations ....................................... 16
+ 7. Source code ................................................... 16
+ 8. Acknowledgements .............................................. 16
+ 9. Author's Address .............................................. 17
+
+1. Introduction
+
+ 1.1. Purpose
+
+ The purpose of this specification is to define a lossless
+ compressed data format that:
+ * Is independent of CPU type, operating system, file system,
+ and character set, and hence can be used for interchange;
+ * Can be produced or consumed, even for an arbitrarily long
+ sequentially presented input data stream, using only an a
+ priori bounded amount of intermediate storage, and hence
+ can be used in data communications or similar structures
+ such as Unix filters;
+ * Compresses data with efficiency comparable to the best
+ currently available general-purpose compression methods,
+ and in particular considerably better than the "compress"
+ program;
+ * Can be implemented readily in a manner not covered by
+ patents, and hence can be practiced freely;
+
+
+
+Deutsch Informational [Page 2]
+
+RFC 1951 DEFLATE Compressed Data Format Specification May 1996
+
+
+ * Is compatible with the file format produced by the current
+ widely used gzip utility, in that conforming decompressors
+ will be able to read data produced by the existing gzip
+ compressor.
+
+ The data format defined by this specification does not attempt to:
+
+ * Allow random access to compressed data;
+ * Compress specialized data (e.g., raster graphics) as well
+ as the best currently available specialized algorithms.
+
+ A simple counting argument shows that no lossless compression
+ algorithm can compress every possible input data set. For the
+ format defined here, the worst case expansion is 5 bytes per 32K-
+ byte block, i.e., a size increase of 0.015% for large data sets.
+ English text usually compresses by a factor of 2.5 to 3;
+ executable files usually compress somewhat less; graphical data
+ such as raster images may compress much more.
+
+ 1.2. Intended audience
+
+ This specification is intended for use by implementors of software
+ to compress data into "deflate" format and/or decompress data from
+ "deflate" format.
+
+ The text of the specification assumes a basic background in
+ programming at the level of bits and other primitive data
+ representations. Familiarity with the technique of Huffman coding
+ is helpful but not required.
+
+ 1.3. Scope
+
+ The specification specifies a method for representing a sequence
+ of bytes as a (usually shorter) sequence of bits, and a method for
+ packing the latter bit sequence into bytes.
+
+ 1.4. Compliance
+
+ Unless otherwise indicated below, a compliant decompressor must be
+ able to accept and decompress any data set that conforms to all
+ the specifications presented here; a compliant compressor must
+ produce data sets that conform to all the specifications presented
+ here.
+
+ 1.5. Definitions of terms and conventions used
+
+ Byte: 8 bits stored or transmitted as a unit (same as an octet).
+ For this specification, a byte is exactly 8 bits, even on machines
+
+
+
+Deutsch Informational [Page 3]
+
+RFC 1951 DEFLATE Compressed Data Format Specification May 1996
+
+
+ which store a character on a number of bits different from eight.
+ See below, for the numbering of bits within a byte.
+
+ String: a sequence of arbitrary bytes.
+
+ 1.6. Changes from previous versions
+
+ There have been no technical changes to the deflate format since
+ version 1.1 of this specification. In version 1.2, some
+ terminology was changed. Version 1.3 is a conversion of the
+ specification to RFC style.
+
+2. Compressed representation overview
+
+ A compressed data set consists of a series of blocks, corresponding
+ to successive blocks of input data. The block sizes are arbitrary,
+ except that non-compressible blocks are limited to 65,535 bytes.
+
+ Each block is compressed using a combination of the LZ77 algorithm
+ and Huffman coding. The Huffman trees for each block are independent
+ of those for previous or subsequent blocks; the LZ77 algorithm may
+ use a reference to a duplicated string occurring in a previous block,
+ up to 32K input bytes before.
+
+ Each block consists of two parts: a pair of Huffman code trees that
+ describe the representation of the compressed data part, and a
+ compressed data part. (The Huffman trees themselves are compressed
+ using Huffman encoding.) The compressed data consists of a series of
+ elements of two types: literal bytes (of strings that have not been
+ detected as duplicated within the previous 32K input bytes), and
+ pointers to duplicated strings, where a pointer is represented as a
+ pair <length, backward distance>. The representation used in the
+ "deflate" format limits distances to 32K bytes and lengths to 258
+ bytes, but does not limit the size of a block, except for
+ uncompressible blocks, which are limited as noted above.
+
+ Each type of value (literals, distances, and lengths) in the
+ compressed data is represented using a Huffman code, using one code
+ tree for literals and lengths and a separate code tree for distances.
+ The code trees for each block appear in a compact form just before
+ the compressed data for that block.
+
+
+
+
+
+
+
+
+
+
+Deutsch Informational [Page 4]
+
+RFC 1951 DEFLATE Compressed Data Format Specification May 1996
+
+
+3. Detailed specification
+
+ 3.1. Overall conventions In the diagrams below, a box like this:
+
+ +---+
+ | | <-- the vertical bars might be missing
+ +---+
+
+ represents one byte; a box like this:
+
+ +==============+
+ | |
+ +==============+
+
+ represents a variable number of bytes.
+
+ Bytes stored within a computer do not have a "bit order", since
+ they are always treated as a unit. However, a byte considered as
+ an integer between 0 and 255 does have a most- and least-
+ significant bit, and since we write numbers with the most-
+ significant digit on the left, we also write bytes with the most-
+ significant bit on the left. In the diagrams below, we number the
+ bits of a byte so that bit 0 is the least-significant bit, i.e.,
+ the bits are numbered:
+
+ +--------+
+ |76543210|
+ +--------+
+
+ Within a computer, a number may occupy multiple bytes. All
+ multi-byte numbers in the format described here are stored with
+ the least-significant byte first (at the lower memory address).
+ For example, the decimal number 520 is stored as:
+
+ 0 1
+ +--------+--------+
+ |00001000|00000010|
+ +--------+--------+
+ ^ ^
+ | |
+ | + more significant byte = 2 x 256
+ + less significant byte = 8
+
+ 3.1.1. Packing into bytes
+
+ This document does not address the issue of the order in which
+ bits of a byte are transmitted on a bit-sequential medium,
+ since the final data format described here is byte- rather than
+
+
+
+Deutsch Informational [Page 5]
+
+RFC 1951 DEFLATE Compressed Data Format Specification May 1996
+
+
+ bit-oriented. However, we describe the compressed block format
+ in below, as a sequence of data elements of various bit
+ lengths, not a sequence of bytes. We must therefore specify
+ how to pack these data elements into bytes to form the final
+ compressed byte sequence:
+
+ * Data elements are packed into bytes in order of
+ increasing bit number within the byte, i.e., starting
+ with the least-significant bit of the byte.
+ * Data elements other than Huffman codes are packed
+ starting with the least-significant bit of the data
+ element.
+ * Huffman codes are packed starting with the most-
+ significant bit of the code.
+
+ In other words, if one were to print out the compressed data as
+ a sequence of bytes, starting with the first byte at the
+ *right* margin and proceeding to the *left*, with the most-
+ significant bit of each byte on the left as usual, one would be
+ able to parse the result from right to left, with fixed-width
+ elements in the correct MSB-to-LSB order and Huffman codes in
+ bit-reversed order (i.e., with the first bit of the code in the
+ relative LSB position).
+
+ 3.2. Compressed block format
+
+ 3.2.1. Synopsis of prefix and Huffman coding
+
+ Prefix coding represents symbols from an a priori known
+ alphabet by bit sequences (codes), one code for each symbol, in
+ a manner such that different symbols may be represented by bit
+ sequences of different lengths, but a parser can always parse
+ an encoded string unambiguously symbol-by-symbol.
+
+ We define a prefix code in terms of a binary tree in which the
+ two edges descending from each non-leaf node are labeled 0 and
+ 1 and in which the leaf nodes correspond one-for-one with (are
+ labeled with) the symbols of the alphabet; then the code for a
+ symbol is the sequence of 0's and 1's on the edges leading from
+ the root to the leaf labeled with that symbol. For example:
+
+
+
+
+
+
+
+
+
+
+
+Deutsch Informational [Page 6]
+
+RFC 1951 DEFLATE Compressed Data Format Specification May 1996
+
+
+ /\ Symbol Code
+ 0 1 ------ ----
+ / \ A 00
+ /\ B B 1
+ 0 1 C 011
+ / \ D 010
+ A /\
+ 0 1
+ / \
+ D C
+
+ A parser can decode the next symbol from an encoded input
+ stream by walking down the tree from the root, at each step
+ choosing the edge corresponding to the next input bit.
+
+ Given an alphabet with known symbol frequencies, the Huffman
+ algorithm allows the construction of an optimal prefix code
+ (one which represents strings with those symbol frequencies
+ using the fewest bits of any possible prefix codes for that
+ alphabet). Such a code is called a Huffman code. (See
+ reference [1] in Chapter 5, references for additional
+ information on Huffman codes.)
+
+ Note that in the "deflate" format, the Huffman codes for the
+ various alphabets must not exceed certain maximum code lengths.
+ This constraint complicates the algorithm for computing code
+ lengths from symbol frequencies. Again, see Chapter 5,
+ references for details.
+
+ 3.2.2. Use of Huffman coding in the "deflate" format
+
+ The Huffman codes used for each alphabet in the "deflate"
+ format have two additional rules:
+
+ * All codes of a given bit length have lexicographically
+ consecutive values, in the same order as the symbols
+ they represent;
+
+ * Shorter codes lexicographically precede longer codes.
+
+
+
+
+
+
+
+
+
+
+
+
+Deutsch Informational [Page 7]
+
+RFC 1951 DEFLATE Compressed Data Format Specification May 1996
+
+
+ We could recode the example above to follow this rule as
+ follows, assuming that the order of the alphabet is ABCD:
+
+ Symbol Code
+ ------ ----
+ A 10
+ B 0
+ C 110
+ D 111
+
+ I.e., 0 precedes 10 which precedes 11x, and 110 and 111 are
+ lexicographically consecutive.
+
+ Given this rule, we can define the Huffman code for an alphabet
+ just by giving the bit lengths of the codes for each symbol of
+ the alphabet in order; this is sufficient to determine the
+ actual codes. In our example, the code is completely defined
+ by the sequence of bit lengths (2, 1, 3, 3). The following
+ algorithm generates the codes as integers, intended to be read
+ from most- to least-significant bit. The code lengths are
+ initially in tree[I].Len; the codes are produced in
+ tree[I].Code.
+
+ 1) Count the number of codes for each code length. Let
+ bl_count[N] be the number of codes of length N, N >= 1.
+
+ 2) Find the numerical value of the smallest code for each
+ code length:
+
+ code = 0;
+ bl_count[0] = 0;
+ for (bits = 1; bits <= MAX_BITS; bits++) {
+ code = (code + bl_count[bits-1]) << 1;
+ next_code[bits] = code;
+ }
+
+ 3) Assign numerical values to all codes, using consecutive
+ values for all codes of the same length with the base
+ values determined at step 2. Codes that are never used
+ (which have a bit length of zero) must not be assigned a
+ value.
+
+ for (n = 0; n <= max_code; n++) {
+ len = tree[n].Len;
+ if (len != 0) {
+ tree[n].Code = next_code[len];
+ next_code[len]++;
+ }
+
+
+
+Deutsch Informational [Page 8]
+
+RFC 1951 DEFLATE Compressed Data Format Specification May 1996
+
+
+ }
+
+ Example:
+
+ Consider the alphabet ABCDEFGH, with bit lengths (3, 3, 3, 3,
+ 3, 2, 4, 4). After step 1, we have:
+
+ N bl_count[N]
+ - -----------
+ 2 1
+ 3 5
+ 4 2
+
+ Step 2 computes the following next_code values:
+
+ N next_code[N]
+ - ------------
+ 1 0
+ 2 0
+ 3 2
+ 4 14
+
+ Step 3 produces the following code values:
+
+ Symbol Length Code
+ ------ ------ ----
+ A 3 010
+ B 3 011
+ C 3 100
+ D 3 101
+ E 3 110
+ F 2 00
+ G 4 1110
+ H 4 1111
+
+ 3.2.3. Details of block format
+
+ Each block of compressed data begins with 3 header bits
+ containing the following data:
+
+ first bit BFINAL
+ next 2 bits BTYPE
+
+ Note that the header bits do not necessarily begin on a byte
+ boundary, since a block does not necessarily occupy an integral
+ number of bytes.
+
+
+
+
+
+Deutsch Informational [Page 9]
+
+RFC 1951 DEFLATE Compressed Data Format Specification May 1996
+
+
+ BFINAL is set if and only if this is the last block of the data
+ set.
+
+ BTYPE specifies how the data are compressed, as follows:
+
+ 00 - no compression
+ 01 - compressed with fixed Huffman codes
+ 10 - compressed with dynamic Huffman codes
+ 11 - reserved (error)
+
+ The only difference between the two compressed cases is how the
+ Huffman codes for the literal/length and distance alphabets are
+ defined.
+
+ In all cases, the decoding algorithm for the actual data is as
+ follows:
+
+ do
+ read block header from input stream.
+ if stored with no compression
+ skip any remaining bits in current partially
+ processed byte
+ read LEN and NLEN (see next section)
+ copy LEN bytes of data to output
+ otherwise
+ if compressed with dynamic Huffman codes
+ read representation of code trees (see
+ subsection below)
+ loop (until end of block code recognized)
+ decode literal/length value from input stream
+ if value < 256
+ copy value (literal byte) to output stream
+ otherwise
+ if value = end of block (256)
+ break from loop
+ otherwise (value = 257..285)
+ decode distance from input stream
+
+ move backwards distance bytes in the output
+ stream, and copy length bytes from this
+ position to the output stream.
+ end loop
+ while not last block
+
+ Note that a duplicated string reference may refer to a string
+ in a previous block; i.e., the backward distance may cross one
+ or more block boundaries. However a distance cannot refer past
+ the beginning of the output stream. (An application using a
+
+
+
+Deutsch Informational [Page 10]
+
+RFC 1951 DEFLATE Compressed Data Format Specification May 1996
+
+
+ preset dictionary might discard part of the output stream; a
+ distance can refer to that part of the output stream anyway)
+ Note also that the referenced string may overlap the current
+ position; for example, if the last 2 bytes decoded have values
+ X and Y, a string reference with <length = 5, distance = 2>
+ adds X,Y,X,Y,X to the output stream.
+
+ We now specify each compression method in turn.
+
+ 3.2.4. Non-compressed blocks (BTYPE=00)
+
+ Any bits of input up to the next byte boundary are ignored.
+ The rest of the block consists of the following information:
+
+ 0 1 2 3 4...
+ +---+---+---+---+================================+
+ | LEN | NLEN |... LEN bytes of literal data...|
+ +---+---+---+---+================================+
+
+ LEN is the number of data bytes in the block. NLEN is the
+ one's complement of LEN.
+
+ 3.2.5. Compressed blocks (length and distance codes)
+
+ As noted above, encoded data blocks in the "deflate" format
+ consist of sequences of symbols drawn from three conceptually
+ distinct alphabets: either literal bytes, from the alphabet of
+ byte values (0..255), or <length, backward distance> pairs,
+ where the length is drawn from (3..258) and the distance is
+ drawn from (1..32,768). In fact, the literal and length
+ alphabets are merged into a single alphabet (0..285), where
+ values 0..255 represent literal bytes, the value 256 indicates
+ end-of-block, and values 257..285 represent length codes
+ (possibly in conjunction with extra bits following the symbol
+ code) as follows:
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Deutsch Informational [Page 11]
+
+RFC 1951 DEFLATE Compressed Data Format Specification May 1996
+
+
+ Extra Extra Extra
+ Code Bits Length(s) Code Bits Lengths Code Bits Length(s)
+ ---- ---- ------ ---- ---- ------- ---- ---- -------
+ 257 0 3 267 1 15,16 277 4 67-82
+ 258 0 4 268 1 17,18 278 4 83-98
+ 259 0 5 269 2 19-22 279 4 99-114
+ 260 0 6 270 2 23-26 280 4 115-130
+ 261 0 7 271 2 27-30 281 5 131-162
+ 262 0 8 272 2 31-34 282 5 163-194
+ 263 0 9 273 3 35-42 283 5 195-226
+ 264 0 10 274 3 43-50 284 5 227-257
+ 265 1 11,12 275 3 51-58 285 0 258
+ 266 1 13,14 276 3 59-66
+
+ The extra bits should be interpreted as a machine integer
+ stored with the most-significant bit first, e.g., bits 1110
+ represent the value 14.
+
+ Extra Extra Extra
+ Code Bits Dist Code Bits Dist Code Bits Distance
+ ---- ---- ---- ---- ---- ------ ---- ---- --------
+ 0 0 1 10 4 33-48 20 9 1025-1536
+ 1 0 2 11 4 49-64 21 9 1537-2048
+ 2 0 3 12 5 65-96 22 10 2049-3072
+ 3 0 4 13 5 97-128 23 10 3073-4096
+ 4 1 5,6 14 6 129-192 24 11 4097-6144
+ 5 1 7,8 15 6 193-256 25 11 6145-8192
+ 6 2 9-12 16 7 257-384 26 12 8193-12288
+ 7 2 13-16 17 7 385-512 27 12 12289-16384
+ 8 3 17-24 18 8 513-768 28 13 16385-24576
+ 9 3 25-32 19 8 769-1024 29 13 24577-32768
+
+ 3.2.6. Compression with fixed Huffman codes (BTYPE=01)
+
+ The Huffman codes for the two alphabets are fixed, and are not
+ represented explicitly in the data. The Huffman code lengths
+ for the literal/length alphabet are:
+
+ Lit Value Bits Codes
+ --------- ---- -----
+ 0 - 143 8 00110000 through
+ 10111111
+ 144 - 255 9 110010000 through
+ 111111111
+ 256 - 279 7 0000000 through
+ 0010111
+ 280 - 287 8 11000000 through
+ 11000111
+
+
+
+Deutsch Informational [Page 12]
+
+RFC 1951 DEFLATE Compressed Data Format Specification May 1996
+
+
+ The code lengths are sufficient to generate the actual codes,
+ as described above; we show the codes in the table for added
+ clarity. Literal/length values 286-287 will never actually
+ occur in the compressed data, but participate in the code
+ construction.
+
+ Distance codes 0-31 are represented by (fixed-length) 5-bit
+ codes, with possible additional bits as shown in the table
+ shown in Paragraph 3.2.5, above. Note that distance codes 30-
+ 31 will never actually occur in the compressed data.
+
+ 3.2.7. Compression with dynamic Huffman codes (BTYPE=10)
+
+ The Huffman codes for the two alphabets appear in the block
+ immediately after the header bits and before the actual
+ compressed data, first the literal/length code and then the
+ distance code. Each code is defined by a sequence of code
+ lengths, as discussed in Paragraph 3.2.2, above. For even
+ greater compactness, the code length sequences themselves are
+ compressed using a Huffman code. The alphabet for code lengths
+ is as follows:
+
+ 0 - 15: Represent code lengths of 0 - 15
+ 16: Copy the previous code length 3 - 6 times.
+ The next 2 bits indicate repeat length
+ (0 = 3, ... , 3 = 6)
+ Example: Codes 8, 16 (+2 bits 11),
+ 16 (+2 bits 10) will expand to
+ 12 code lengths of 8 (1 + 6 + 5)
+ 17: Repeat a code length of 0 for 3 - 10 times.
+ (3 bits of length)
+ 18: Repeat a code length of 0 for 11 - 138 times
+ (7 bits of length)
+
+ A code length of 0 indicates that the corresponding symbol in
+ the literal/length or distance alphabet will not occur in the
+ block, and should not participate in the Huffman code
+ construction algorithm given earlier. If only one distance
+ code is used, it is encoded using one bit, not zero bits; in
+ this case there is a single code length of one, with one unused
+ code. One distance code of zero bits means that there are no
+ distance codes used at all (the data is all literals).
+
+ We can now define the format of the block:
+
+ 5 Bits: HLIT, # of Literal/Length codes - 257 (257 - 286)
+ 5 Bits: HDIST, # of Distance codes - 1 (1 - 32)
+ 4 Bits: HCLEN, # of Code Length codes - 4 (4 - 19)
+
+
+
+Deutsch Informational [Page 13]
+
+RFC 1951 DEFLATE Compressed Data Format Specification May 1996
+
+
+ (HCLEN + 4) x 3 bits: code lengths for the code length
+ alphabet given just above, in the order: 16, 17, 18,
+ 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15
+
+ These code lengths are interpreted as 3-bit integers
+ (0-7); as above, a code length of 0 means the
+ corresponding symbol (literal/length or distance code
+ length) is not used.
+
+ HLIT + 257 code lengths for the literal/length alphabet,
+ encoded using the code length Huffman code
+
+ HDIST + 1 code lengths for the distance alphabet,
+ encoded using the code length Huffman code
+
+ The actual compressed data of the block,
+ encoded using the literal/length and distance Huffman
+ codes
+
+ The literal/length symbol 256 (end of data),
+ encoded using the literal/length Huffman code
+
+ The code length repeat codes can cross from HLIT + 257 to the
+ HDIST + 1 code lengths. In other words, all code lengths form
+ a single sequence of HLIT + HDIST + 258 values.
+
+ 3.3. Compliance
+
+ A compressor may limit further the ranges of values specified in
+ the previous section and still be compliant; for example, it may
+ limit the range of backward pointers to some value smaller than
+ 32K. Similarly, a compressor may limit the size of blocks so that
+ a compressible block fits in memory.
+
+ A compliant decompressor must accept the full range of possible
+ values defined in the previous section, and must accept blocks of
+ arbitrary size.
+
+4. Compression algorithm details
+
+ While it is the intent of this document to define the "deflate"
+ compressed data format without reference to any particular
+ compression algorithm, the format is related to the compressed
+ formats produced by LZ77 (Lempel-Ziv 1977, see reference [2] below);
+ since many variations of LZ77 are patented, it is strongly
+ recommended that the implementor of a compressor follow the general
+ algorithm presented here, which is known not to be patented per se.
+ The material in this section is not part of the definition of the
+
+
+
+Deutsch Informational [Page 14]
+
+RFC 1951 DEFLATE Compressed Data Format Specification May 1996
+
+
+ specification per se, and a compressor need not follow it in order to
+ be compliant.
+
+ The compressor terminates a block when it determines that starting a
+ new block with fresh trees would be useful, or when the block size
+ fills up the compressor's block buffer.
+
+ The compressor uses a chained hash table to find duplicated strings,
+ using a hash function that operates on 3-byte sequences. At any
+ given point during compression, let XYZ be the next 3 input bytes to
+ be examined (not necessarily all different, of course). First, the
+ compressor examines the hash chain for XYZ. If the chain is empty,
+ the compressor simply writes out X as a literal byte and advances one
+ byte in the input. If the hash chain is not empty, indicating that
+ the sequence XYZ (or, if we are unlucky, some other 3 bytes with the
+ same hash function value) has occurred recently, the compressor
+ compares all strings on the XYZ hash chain with the actual input data
+ sequence starting at the current point, and selects the longest
+ match.
+
+ The compressor searches the hash chains starting with the most recent
+ strings, to favor small distances and thus take advantage of the
+ Huffman encoding. The hash chains are singly linked. There are no
+ deletions from the hash chains; the algorithm simply discards matches
+ that are too old. To avoid a worst-case situation, very long hash
+ chains are arbitrarily truncated at a certain length, determined by a
+ run-time parameter.
+
+ To improve overall compression, the compressor optionally defers the
+ selection of matches ("lazy matching"): after a match of length N has
+ been found, the compressor searches for a longer match starting at
+ the next input byte. If it finds a longer match, it truncates the
+ previous match to a length of one (thus producing a single literal
+ byte) and then emits the longer match. Otherwise, it emits the
+ original match, and, as described above, advances N bytes before
+ continuing.
+
+ Run-time parameters also control this "lazy match" procedure. If
+ compression ratio is most important, the compressor attempts a
+ complete second search regardless of the length of the first match.
+ In the normal case, if the current match is "long enough", the
+ compressor reduces the search for a longer match, thus speeding up
+ the process. If speed is most important, the compressor inserts new
+ strings in the hash table only when no match was found, or when the
+ match is not "too long". This degrades the compression ratio but
+ saves time since there are both fewer insertions and fewer searches.
+
+
+
+
+
+Deutsch Informational [Page 15]
+
+RFC 1951 DEFLATE Compressed Data Format Specification May 1996
+
+
+5. References
+
+ [1] Huffman, D. A., "A Method for the Construction of Minimum
+ Redundancy Codes", Proceedings of the Institute of Radio
+ Engineers, September 1952, Volume 40, Number 9, pp. 1098-1101.
+
+ [2] Ziv J., Lempel A., "A Universal Algorithm for Sequential Data
+ Compression", IEEE Transactions on Information Theory, Vol. 23,
+ No. 3, pp. 337-343.
+
+ [3] Gailly, J.-L., and Adler, M., ZLIB documentation and sources,
+ available in ftp://ftp.uu.net/pub/archiving/zip/doc/
+
+ [4] Gailly, J.-L., and Adler, M., GZIP documentation and sources,
+ available as gzip-*.tar in ftp://prep.ai.mit.edu/pub/gnu/
+
+ [5] Schwartz, E. S., and Kallick, B. "Generating a canonical prefix
+ encoding." Comm. ACM, 7,3 (Mar. 1964), pp. 166-169.
+
+ [6] Hirschberg and Lelewer, "Efficient decoding of prefix codes,"
+ Comm. ACM, 33,4, April 1990, pp. 449-459.
+
+6. Security Considerations
+
+ Any data compression method involves the reduction of redundancy in
+ the data. Consequently, any corruption of the data is likely to have
+ severe effects and be difficult to correct. Uncompressed text, on
+ the other hand, will probably still be readable despite the presence
+ of some corrupted bytes.
+
+ It is recommended that systems using this data format provide some
+ means of validating the integrity of the compressed data. See
+ reference [3], for example.
+
+7. Source code
+
+ Source code for a C language implementation of a "deflate" compliant
+ compressor and decompressor is available within the zlib package at
+ ftp://ftp.uu.net/pub/archiving/zip/zlib/.
+
+8. Acknowledgements
+
+ Trademarks cited in this document are the property of their
+ respective owners.
+
+ Phil Katz designed the deflate format. Jean-Loup Gailly and Mark
+ Adler wrote the related software described in this specification.
+ Glenn Randers-Pehrson converted this document to RFC and HTML format.
+
+
+
+Deutsch Informational [Page 16]
+
+RFC 1951 DEFLATE Compressed Data Format Specification May 1996
+
+
+9. Author's Address
+
+ L. Peter Deutsch
+ Aladdin Enterprises
+ 203 Santa Margarita Ave.
+ Menlo Park, CA 94025
+
+ Phone: (415) 322-0103 (AM only)
+ FAX: (415) 322-1734
+ EMail: <ghost@aladdin.com>
+
+ Questions about the technical content of this specification can be
+ sent by email to:
+
+ Jean-Loup Gailly <gzip@prep.ai.mit.edu> and
+ Mark Adler <madler@alumni.caltech.edu>
+
+ Editorial comments on this specification can be sent by email to:
+
+ L. Peter Deutsch <ghost@aladdin.com> and
+ Glenn Randers-Pehrson <randeg@alumni.rpi.edu>
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+Deutsch Informational [Page 17]
+
diff --git a/zlib/doc/rfc1952.txt b/zlib/doc/rfc1952.txt
new file mode 100644
index 000000000..a8e51b456
--- /dev/null
+++ b/zlib/doc/rfc1952.txt
@@ -0,0 +1,675 @@
+
+
+
+
+
+
+Network Working Group P. Deutsch
+Request for Comments: 1952 Aladdin Enterprises
+Category: Informational May 1996
+
+
+ GZIP file format specification version 4.3
+
+Status of This Memo
+
+ This memo provides information for the Internet community. This memo
+ does not specify an Internet standard of any kind. Distribution of
+ this memo is unlimited.
+
+IESG Note:
+
+ The IESG takes no position on the validity of any Intellectual
+ Property Rights statements contained in this document.
+
+Notices
+
+ Copyright (c) 1996 L. Peter Deutsch
+
+ Permission is granted to copy and distribute this document for any
+ purpose and without charge, including translations into other
+ languages and incorporation into compilations, provided that the
+ copyright notice and this notice are preserved, and that any
+ substantive changes or deletions from the original are clearly
+ marked.
+
+ A pointer to the latest version of this and related documentation in
+ HTML format can be found at the URL
+ <ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html>.
+
+Abstract
+
+ This specification defines a lossless compressed data format that is
+ compatible with the widely used GZIP utility. The format includes a
+ cyclic redundancy check value for detecting data corruption. The
+ format presently uses the DEFLATE method of compression but can be
+ easily extended to use other compression methods. The format can be
+ implemented readily in a manner not covered by patents.
+
+
+
+
+
+
+
+
+
+
+Deutsch Informational [Page 1]
+
+RFC 1952 GZIP File Format Specification May 1996
+
+
+Table of Contents
+
+ 1. Introduction ................................................... 2
+ 1.1. Purpose ................................................... 2
+ 1.2. Intended audience ......................................... 3
+ 1.3. Scope ..................................................... 3
+ 1.4. Compliance ................................................ 3
+ 1.5. Definitions of terms and conventions used ................. 3
+ 1.6. Changes from previous versions ............................ 3
+ 2. Detailed specification ......................................... 4
+ 2.1. Overall conventions ....................................... 4
+ 2.2. File format ............................................... 5
+ 2.3. Member format ............................................. 5
+ 2.3.1. Member header and trailer ........................... 6
+ 2.3.1.1. Extra field ................................... 8
+ 2.3.1.2. Compliance .................................... 9
+ 3. References .................................................. 9
+ 4. Security Considerations .................................... 10
+ 5. Acknowledgements ........................................... 10
+ 6. Author's Address ........................................... 10
+ 7. Appendix: Jean-Loup Gailly's gzip utility .................. 11
+ 8. Appendix: Sample CRC Code .................................. 11
+
+1. Introduction
+
+ 1.1. Purpose
+
+ The purpose of this specification is to define a lossless
+ compressed data format that:
+
+ * Is independent of CPU type, operating system, file system,
+ and character set, and hence can be used for interchange;
+ * Can compress or decompress a data stream (as opposed to a
+ randomly accessible file) to produce another data stream,
+ using only an a priori bounded amount of intermediate
+ storage, and hence can be used in data communications or
+ similar structures such as Unix filters;
+ * Compresses data with efficiency comparable to the best
+ currently available general-purpose compression methods,
+ and in particular considerably better than the "compress"
+ program;
+ * Can be implemented readily in a manner not covered by
+ patents, and hence can be practiced freely;
+ * Is compatible with the file format produced by the current
+ widely used gzip utility, in that conforming decompressors
+ will be able to read data produced by the existing gzip
+ compressor.
+
+
+
+
+Deutsch Informational [Page 2]
+
+RFC 1952 GZIP File Format Specification May 1996
+
+
+ The data format defined by this specification does not attempt to:
+
+ * Provide random access to compressed data;
+ * Compress specialized data (e.g., raster graphics) as well as
+ the best currently available specialized algorithms.
+
+ 1.2. Intended audience
+
+ This specification is intended for use by implementors of software
+ to compress data into gzip format and/or decompress data from gzip
+ format.
+
+ The text of the specification assumes a basic background in
+ programming at the level of bits and other primitive data
+ representations.
+
+ 1.3. Scope
+
+ The specification specifies a compression method and a file format
+ (the latter assuming only that a file can store a sequence of
+ arbitrary bytes). It does not specify any particular interface to
+ a file system or anything about character sets or encodings
+ (except for file names and comments, which are optional).
+
+ 1.4. Compliance
+
+ Unless otherwise indicated below, a compliant decompressor must be
+ able to accept and decompress any file that conforms to all the
+ specifications presented here; a compliant compressor must produce
+ files that conform to all the specifications presented here. The
+ material in the appendices is not part of the specification per se
+ and is not relevant to compliance.
+
+ 1.5. Definitions of terms and conventions used
+
+ byte: 8 bits stored or transmitted as a unit (same as an octet).
+ (For this specification, a byte is exactly 8 bits, even on
+ machines which store a character on a number of bits different
+ from 8.) See below for the numbering of bits within a byte.
+
+ 1.6. Changes from previous versions
+
+ There have been no technical changes to the gzip format since
+ version 4.1 of this specification. In version 4.2, some
+ terminology was changed, and the sample CRC code was rewritten for
+ clarity and to eliminate the requirement for the caller to do pre-
+ and post-conditioning. Version 4.3 is a conversion of the
+ specification to RFC style.
+
+
+
+Deutsch Informational [Page 3]
+
+RFC 1952 GZIP File Format Specification May 1996
+
+
+2. Detailed specification
+
+ 2.1. Overall conventions
+
+ In the diagrams below, a box like this:
+
+ +---+
+ | | <-- the vertical bars might be missing
+ +---+
+
+ represents one byte; a box like this:
+
+ +==============+
+ | |
+ +==============+
+
+ represents a variable number of bytes.
+
+ Bytes stored within a computer do not have a "bit order", since
+ they are always treated as a unit. However, a byte considered as
+ an integer between 0 and 255 does have a most- and least-
+ significant bit, and since we write numbers with the most-
+ significant digit on the left, we also write bytes with the most-
+ significant bit on the left. In the diagrams below, we number the
+ bits of a byte so that bit 0 is the least-significant bit, i.e.,
+ the bits are numbered:
+
+ +--------+
+ |76543210|
+ +--------+
+
+ This document does not address the issue of the order in which
+ bits of a byte are transmitted on a bit-sequential medium, since
+ the data format described here is byte- rather than bit-oriented.
+
+ Within a computer, a number may occupy multiple bytes. All
+ multi-byte numbers in the format described here are stored with
+ the least-significant byte first (at the lower memory address).
+ For example, the decimal number 520 is stored as:
+
+ 0 1
+ +--------+--------+
+ |00001000|00000010|
+ +--------+--------+
+ ^ ^
+ | |
+ | + more significant byte = 2 x 256
+ + less significant byte = 8
+
+
+
+Deutsch Informational [Page 4]
+
+RFC 1952 GZIP File Format Specification May 1996
+
+
+ 2.2. File format
+
+ A gzip file consists of a series of "members" (compressed data
+ sets). The format of each member is specified in the following
+ section. The members simply appear one after another in the file,
+ with no additional information before, between, or after them.
+
+ 2.3. Member format
+
+ Each member has the following structure:
+
+ +---+---+---+---+---+---+---+---+---+---+
+ |ID1|ID2|CM |FLG| MTIME |XFL|OS | (more-->)
+ +---+---+---+---+---+---+---+---+---+---+
+
+ (if FLG.FEXTRA set)
+
+ +---+---+=================================+
+ | XLEN |...XLEN bytes of "extra field"...| (more-->)
+ +---+---+=================================+
+
+ (if FLG.FNAME set)
+
+ +=========================================+
+ |...original file name, zero-terminated...| (more-->)
+ +=========================================+
+
+ (if FLG.FCOMMENT set)
+
+ +===================================+
+ |...file comment, zero-terminated...| (more-->)
+ +===================================+
+
+ (if FLG.FHCRC set)
+
+ +---+---+
+ | CRC16 |
+ +---+---+
+
+ +=======================+
+ |...compressed blocks...| (more-->)
+ +=======================+
+
+ 0 1 2 3 4 5 6 7
+ +---+---+---+---+---+---+---+---+
+ | CRC32 | ISIZE |
+ +---+---+---+---+---+---+---+---+
+
+
+
+
+Deutsch Informational [Page 5]
+
+RFC 1952 GZIP File Format Specification May 1996
+
+
+ 2.3.1. Member header and trailer
+
+ ID1 (IDentification 1)
+ ID2 (IDentification 2)
+ These have the fixed values ID1 = 31 (0x1f, \037), ID2 = 139
+ (0x8b, \213), to identify the file as being in gzip format.
+
+ CM (Compression Method)
+ This identifies the compression method used in the file. CM
+ = 0-7 are reserved. CM = 8 denotes the "deflate"
+ compression method, which is the one customarily used by
+ gzip and which is documented elsewhere.
+
+ FLG (FLaGs)
+ This flag byte is divided into individual bits as follows:
+
+ bit 0 FTEXT
+ bit 1 FHCRC
+ bit 2 FEXTRA
+ bit 3 FNAME
+ bit 4 FCOMMENT
+ bit 5 reserved
+ bit 6 reserved
+ bit 7 reserved
+
+ If FTEXT is set, the file is probably ASCII text. This is
+ an optional indication, which the compressor may set by
+ checking a small amount of the input data to see whether any
+ non-ASCII characters are present. In case of doubt, FTEXT
+ is cleared, indicating binary data. For systems which have
+ different file formats for ascii text and binary data, the
+ decompressor can use FTEXT to choose the appropriate format.
+ We deliberately do not specify the algorithm used to set
+ this bit, since a compressor always has the option of
+ leaving it cleared and a decompressor always has the option
+ of ignoring it and letting some other program handle issues
+ of data conversion.
+
+ If FHCRC is set, a CRC16 for the gzip header is present,
+ immediately before the compressed data. The CRC16 consists
+ of the two least significant bytes of the CRC32 for all
+ bytes of the gzip header up to and not including the CRC16.
+ [The FHCRC bit was never set by versions of gzip up to
+ 1.2.4, even though it was documented with a different
+ meaning in gzip 1.2.4.]
+
+ If FEXTRA is set, optional extra fields are present, as
+ described in a following section.
+
+
+
+Deutsch Informational [Page 6]
+
+RFC 1952 GZIP File Format Specification May 1996
+
+
+ If FNAME is set, an original file name is present,
+ terminated by a zero byte. The name must consist of ISO
+ 8859-1 (LATIN-1) characters; on operating systems using
+ EBCDIC or any other character set for file names, the name
+ must be translated to the ISO LATIN-1 character set. This
+ is the original name of the file being compressed, with any
+ directory components removed, and, if the file being
+ compressed is on a file system with case insensitive names,
+ forced to lower case. There is no original file name if the
+ data was compressed from a source other than a named file;
+ for example, if the source was stdin on a Unix system, there
+ is no file name.
+
+ If FCOMMENT is set, a zero-terminated file comment is
+ present. This comment is not interpreted; it is only
+ intended for human consumption. The comment must consist of
+ ISO 8859-1 (LATIN-1) characters. Line breaks should be
+ denoted by a single line feed character (10 decimal).
+
+ Reserved FLG bits must be zero.
+
+ MTIME (Modification TIME)
+ This gives the most recent modification time of the original
+ file being compressed. The time is in Unix format, i.e.,
+ seconds since 00:00:00 GMT, Jan. 1, 1970. (Note that this
+ may cause problems for MS-DOS and other systems that use
+ local rather than Universal time.) If the compressed data
+ did not come from a file, MTIME is set to the time at which
+ compression started. MTIME = 0 means no time stamp is
+ available.
+
+ XFL (eXtra FLags)
+ These flags are available for use by specific compression
+ methods. The "deflate" method (CM = 8) sets these flags as
+ follows:
+
+ XFL = 2 - compressor used maximum compression,
+ slowest algorithm
+ XFL = 4 - compressor used fastest algorithm
+
+ OS (Operating System)
+ This identifies the type of file system on which compression
+ took place. This may be useful in determining end-of-line
+ convention for text files. The currently defined values are
+ as follows:
+
+
+
+
+
+
+Deutsch Informational [Page 7]
+
+RFC 1952 GZIP File Format Specification May 1996
+
+
+ 0 - FAT filesystem (MS-DOS, OS/2, NT/Win32)
+ 1 - Amiga
+ 2 - VMS (or OpenVMS)
+ 3 - Unix
+ 4 - VM/CMS
+ 5 - Atari TOS
+ 6 - HPFS filesystem (OS/2, NT)
+ 7 - Macintosh
+ 8 - Z-System
+ 9 - CP/M
+ 10 - TOPS-20
+ 11 - NTFS filesystem (NT)
+ 12 - QDOS
+ 13 - Acorn RISCOS
+ 255 - unknown
+
+ XLEN (eXtra LENgth)
+ If FLG.FEXTRA is set, this gives the length of the optional
+ extra field. See below for details.
+
+ CRC32 (CRC-32)
+ This contains a Cyclic Redundancy Check value of the
+ uncompressed data computed according to CRC-32 algorithm
+ used in the ISO 3309 standard and in section 8.1.1.6.2 of
+ ITU-T recommendation V.42. (See http://www.iso.ch for
+ ordering ISO documents. See gopher://info.itu.ch for an
+ online version of ITU-T V.42.)
+
+ ISIZE (Input SIZE)
+ This contains the size of the original (uncompressed) input
+ data modulo 2^32.
+
+ 2.3.1.1. Extra field
+
+ If the FLG.FEXTRA bit is set, an "extra field" is present in
+ the header, with total length XLEN bytes. It consists of a
+ series of subfields, each of the form:
+
+ +---+---+---+---+==================================+
+ |SI1|SI2| LEN |... LEN bytes of subfield data ...|
+ +---+---+---+---+==================================+
+
+ SI1 and SI2 provide a subfield ID, typically two ASCII letters
+ with some mnemonic value. Jean-Loup Gailly
+ <gzip@prep.ai.mit.edu> is maintaining a registry of subfield
+ IDs; please send him any subfield ID you wish to use. Subfield
+ IDs with SI2 = 0 are reserved for future use. The following
+ IDs are currently defined:
+
+
+
+Deutsch Informational [Page 8]
+
+RFC 1952 GZIP File Format Specification May 1996
+
+
+ SI1 SI2 Data
+ ---------- ---------- ----
+ 0x41 ('A') 0x70 ('P') Apollo file type information
+
+ LEN gives the length of the subfield data, excluding the 4
+ initial bytes.
+
+ 2.3.1.2. Compliance
+
+ A compliant compressor must produce files with correct ID1,
+ ID2, CM, CRC32, and ISIZE, but may set all the other fields in
+ the fixed-length part of the header to default values (255 for
+ OS, 0 for all others). The compressor must set all reserved
+ bits to zero.
+
+ A compliant decompressor must check ID1, ID2, and CM, and
+ provide an error indication if any of these have incorrect
+ values. It must examine FEXTRA/XLEN, FNAME, FCOMMENT and FHCRC
+ at least so it can skip over the optional fields if they are
+ present. It need not examine any other part of the header or
+ trailer; in particular, a decompressor may ignore FTEXT and OS
+ and always produce binary output, and still be compliant. A
+ compliant decompressor must give an error indication if any
+ reserved bit is non-zero, since such a bit could indicate the
+ presence of a new field that would cause subsequent data to be
+ interpreted incorrectly.
+
+3. References
+
+ [1] "Information Processing - 8-bit single-byte coded graphic
+ character sets - Part 1: Latin alphabet No.1" (ISO 8859-1:1987).
+ The ISO 8859-1 (Latin-1) character set is a superset of 7-bit
+ ASCII. Files defining this character set are available as
+ iso_8859-1.* in ftp://ftp.uu.net/graphics/png/documents/
+
+ [2] ISO 3309
+
+ [3] ITU-T recommendation V.42
+
+ [4] Deutsch, L.P.,"DEFLATE Compressed Data Format Specification",
+ available in ftp://ftp.uu.net/pub/archiving/zip/doc/
+
+ [5] Gailly, J.-L., GZIP documentation, available as gzip-*.tar in
+ ftp://prep.ai.mit.edu/pub/gnu/
+
+ [6] Sarwate, D.V., "Computation of Cyclic Redundancy Checks via Table
+ Look-Up", Communications of the ACM, 31(8), pp.1008-1013.
+
+
+
+
+Deutsch Informational [Page 9]
+
+RFC 1952 GZIP File Format Specification May 1996
+
+
+ [7] Schwaderer, W.D., "CRC Calculation", April 85 PC Tech Journal,
+ pp.118-133.
+
+ [8] ftp://ftp.adelaide.edu.au/pub/rocksoft/papers/crc_v3.txt,
+ describing the CRC concept.
+
+4. Security Considerations
+
+ Any data compression method involves the reduction of redundancy in
+ the data. Consequently, any corruption of the data is likely to have
+ severe effects and be difficult to correct. Uncompressed text, on
+ the other hand, will probably still be readable despite the presence
+ of some corrupted bytes.
+
+ It is recommended that systems using this data format provide some
+ means of validating the integrity of the compressed data, such as by
+ setting and checking the CRC-32 check value.
+
+5. Acknowledgements
+
+ Trademarks cited in this document are the property of their
+ respective owners.
+
+ Jean-Loup Gailly designed the gzip format and wrote, with Mark Adler,
+ the related software described in this specification. Glenn
+ Randers-Pehrson converted this document to RFC and HTML format.
+
+6. Author's Address
+
+ L. Peter Deutsch
+ Aladdin Enterprises
+ 203 Santa Margarita Ave.
+ Menlo Park, CA 94025
+
+ Phone: (415) 322-0103 (AM only)
+ FAX: (415) 322-1734
+ EMail: <ghost@aladdin.com>
+
+ Questions about the technical content of this specification can be
+ sent by email to:
+
+ Jean-Loup Gailly <gzip@prep.ai.mit.edu> and
+ Mark Adler <madler@alumni.caltech.edu>
+
+ Editorial comments on this specification can be sent by email to:
+
+ L. Peter Deutsch <ghost@aladdin.com> and
+ Glenn Randers-Pehrson <randeg@alumni.rpi.edu>
+
+
+
+Deutsch Informational [Page 10]
+
+RFC 1952 GZIP File Format Specification May 1996
+
+
+7. Appendix: Jean-Loup Gailly's gzip utility
+
+ The most widely used implementation of gzip compression, and the
+ original documentation on which this specification is based, were
+ created by Jean-Loup Gailly <gzip@prep.ai.mit.edu>. Since this
+ implementation is a de facto standard, we mention some more of its
+ features here. Again, the material in this section is not part of
+ the specification per se, and implementations need not follow it to
+ be compliant.
+
+ When compressing or decompressing a file, gzip preserves the
+ protection, ownership, and modification time attributes on the local
+ file system, since there is no provision for representing protection
+ attributes in the gzip file format itself. Since the file format
+ includes a modification time, the gzip decompressor provides a
+ command line switch that assigns the modification time from the file,
+ rather than the local modification time of the compressed input, to
+ the decompressed output.
+
+8. Appendix: Sample CRC Code
+
+ The following sample code represents a practical implementation of
+ the CRC (Cyclic Redundancy Check). (See also ISO 3309 and ITU-T V.42
+ for a formal specification.)
+
+ The sample code is in the ANSI C programming language. Non C users
+ may find it easier to read with these hints:
+
+ & Bitwise AND operator.
+ ^ Bitwise exclusive-OR operator.
+ >> Bitwise right shift operator. When applied to an
+ unsigned quantity, as here, right shift inserts zero
+ bit(s) at the left.
+ ! Logical NOT operator.
+ ++ "n++" increments the variable n.
+ 0xNNN 0x introduces a hexadecimal (base 16) constant.
+ Suffix L indicates a long value (at least 32 bits).
+
+ /* Table of CRCs of all 8-bit messages. */
+ unsigned long crc_table[256];
+
+ /* Flag: has the table been computed? Initially false. */
+ int crc_table_computed = 0;
+
+ /* Make the table for a fast CRC. */
+ void make_crc_table(void)
+ {
+ unsigned long c;
+
+
+
+Deutsch Informational [Page 11]
+
+RFC 1952 GZIP File Format Specification May 1996
+
+
+ int n, k;
+ for (n = 0; n < 256; n++) {
+ c = (unsigned long) n;
+ for (k = 0; k < 8; k++) {
+ if (c & 1) {
+ c = 0xedb88320L ^ (c >> 1);
+ } else {
+ c = c >> 1;
+ }
+ }
+ crc_table[n] = c;
+ }
+ crc_table_computed = 1;
+ }
+
+ /*
+ Update a running crc with the bytes buf[0..len-1] and return
+ the updated crc. The crc should be initialized to zero. Pre- and
+ post-conditioning (one's complement) is performed within this
+ function so it shouldn't be done by the caller. Usage example:
+
+ unsigned long crc = 0L;
+
+ while (read_buffer(buffer, length) != EOF) {
+ crc = update_crc(crc, buffer, length);
+ }
+ if (crc != original_crc) error();
+ */
+ unsigned long update_crc(unsigned long crc,
+ unsigned char *buf, int len)
+ {
+ unsigned long c = crc ^ 0xffffffffL;
+ int n;
+
+ if (!crc_table_computed)
+ make_crc_table();
+ for (n = 0; n < len; n++) {
+ c = crc_table[(c ^ buf[n]) & 0xff] ^ (c >> 8);
+ }
+ return c ^ 0xffffffffL;
+ }
+
+ /* Return the CRC of the bytes buf[0..len-1]. */
+ unsigned long crc(unsigned char *buf, int len)
+ {
+ return update_crc(0L, buf, len);
+ }
+
+
+
+
+Deutsch Informational [Page 12]
+
diff --git a/zlib/doc/txtvsbin.txt b/zlib/doc/txtvsbin.txt
new file mode 100644
index 000000000..3d0f0634f
--- /dev/null
+++ b/zlib/doc/txtvsbin.txt
@@ -0,0 +1,107 @@
+A Fast Method for Identifying Plain Text Files
+==============================================
+
+
+Introduction
+------------
+
+Given a file coming from an unknown source, it is sometimes desirable
+to find out whether the format of that file is plain text. Although
+this may appear like a simple task, a fully accurate detection of the
+file type requires heavy-duty semantic analysis on the file contents.
+It is, however, possible to obtain satisfactory results by employing
+various heuristics.
+
+Previous versions of PKZip and other zip-compatible compression tools
+were using a crude detection scheme: if more than 80% (4/5) of the bytes
+found in a certain buffer are within the range [7..127], the file is
+labeled as plain text, otherwise it is labeled as binary. A prominent
+limitation of this scheme is the restriction to Latin-based alphabets.
+Other alphabets, like Greek, Cyrillic or Asian, make extensive use of
+the bytes within the range [128..255], and texts using these alphabets
+are most often misidentified by this scheme; in other words, the rate
+of false negatives is sometimes too high, which means that the recall
+is low. Another weakness of this scheme is a reduced precision, due to
+the false positives that may occur when binary files containing large
+amounts of textual characters are misidentified as plain text.
+
+In this article we propose a new, simple detection scheme that features
+a much increased precision and a near-100% recall. This scheme is
+designed to work on ASCII, Unicode and other ASCII-derived alphabets,
+and it handles single-byte encodings (ISO-8859, MacRoman, KOI8, etc.)
+and variable-sized encodings (ISO-2022, UTF-8, etc.). Wider encodings
+(UCS-2/UTF-16 and UCS-4/UTF-32) are not handled, however.
+
+
+The Algorithm
+-------------
+
+The algorithm works by dividing the set of bytecodes [0..255] into three
+categories:
+- The white list of textual bytecodes:
+ 9 (TAB), 10 (LF), 13 (CR), 32 (SPACE) to 255.
+- The gray list of tolerated bytecodes:
+ 7 (BEL), 8 (BS), 11 (VT), 12 (FF), 26 (SUB), 27 (ESC).
+- The black list of undesired, non-textual bytecodes:
+ 0 (NUL) to 6, 14 to 31.
+
+If a file contains at least one byte that belongs to the white list and
+no byte that belongs to the black list, then the file is categorized as
+plain text; otherwise, it is categorized as binary. (The boundary case,
+when the file is empty, automatically falls into the latter category.)
+
+
+Rationale
+---------
+
+The idea behind this algorithm relies on two observations.
+
+The first observation is that, although the full range of 7-bit codes
+[0..127] is properly specified by the ASCII standard, most control
+characters in the range [0..31] are not used in practice. The only
+widely-used, almost universally-portable control codes are 9 (TAB),
+10 (LF) and 13 (CR). There are a few more control codes that are
+recognized on a reduced range of platforms and text viewers/editors:
+7 (BEL), 8 (BS), 11 (VT), 12 (FF), 26 (SUB) and 27 (ESC); but these
+codes are rarely (if ever) used alone, without being accompanied by
+some printable text. Even the newer, portable text formats such as
+XML avoid using control characters outside the list mentioned here.
+
+The second observation is that most of the binary files tend to contain
+control characters, especially 0 (NUL). Even though the older text
+detection schemes observe the presence of non-ASCII codes from the range
+[128..255], the precision rarely has to suffer if this upper range is
+labeled as textual, because the files that are genuinely binary tend to
+contain both control characters and codes from the upper range. On the
+other hand, the upper range needs to be labeled as textual, because it
+is used by virtually all ASCII extensions. In particular, this range is
+used for encoding non-Latin scripts.
+
+Since there is no counting involved, other than simply observing the
+presence or the absence of some byte values, the algorithm produces
+consistent results, regardless what alphabet encoding is being used.
+(If counting were involved, it could be possible to obtain different
+results on a text encoded, say, using ISO-8859-16 versus UTF-8.)
+
+There is an extra category of plain text files that are "polluted" with
+one or more black-listed codes, either by mistake or by peculiar design
+considerations. In such cases, a scheme that tolerates a small fraction
+of black-listed codes would provide an increased recall (i.e. more true
+positives). This, however, incurs a reduced precision overall, since
+false positives are more likely to appear in binary files that contain
+large chunks of textual data. Furthermore, "polluted" plain text should
+be regarded as binary by general-purpose text detection schemes, because
+general-purpose text processing algorithms might not be applicable.
+Under this premise, it is safe to say that our detection method provides
+a near-100% recall.
+
+Experiments have been run on many files coming from various platforms
+and applications. We tried plain text files, system logs, source code,
+formatted office documents, compiled object code, etc. The results
+confirm the optimistic assumptions about the capabilities of this
+algorithm.
+
+
+--
+Cosmin Truta
+Last updated: 2006-May-28
diff --git a/zlib/examples/README.examples b/zlib/examples/README.examples
new file mode 100644
index 000000000..56a31714e
--- /dev/null
+++ b/zlib/examples/README.examples
@@ -0,0 +1,49 @@
+This directory contains examples of the use of zlib and other relevant
+programs and documentation.
+
+enough.c
+ calculation and justification of ENOUGH parameter in inftrees.h
+ - calculates the maximum table space used in inflate tree
+ construction over all possible Huffman codes
+
+fitblk.c
+ compress just enough input to nearly fill a requested output size
+ - zlib isn't designed to do this, but fitblk does it anyway
+
+gun.c
+ uncompress a gzip file
+ - illustrates the use of inflateBack() for high speed file-to-file
+ decompression using call-back functions
+ - is approximately twice as fast as gzip -d
+ - also provides Unix uncompress functionality, again twice as fast
+
+gzappend.c
+ append to a gzip file
+ - illustrates the use of the Z_BLOCK flush parameter for inflate()
+ - illustrates the use of deflatePrime() to start at any bit
+
+gzjoin.c
+ join gzip files without recalculating the crc or recompressing
+ - illustrates the use of the Z_BLOCK flush parameter for inflate()
+ - illustrates the use of crc32_combine()
+
+gzlog.c
+gzlog.h
+ efficiently and robustly maintain a message log file in gzip format
+ - illustrates use of raw deflate, Z_PARTIAL_FLUSH, deflatePrime(),
+ and deflateSetDictionary()
+ - illustrates use of a gzip header extra field
+
+zlib_how.html
+ painfully comprehensive description of zpipe.c (see below)
+ - describes in excruciating detail the use of deflate() and inflate()
+
+zpipe.c
+ reads and writes zlib streams from stdin to stdout
+ - illustrates the proper use of deflate() and inflate()
+ - deeply commented in zlib_how.html (see above)
+
+zran.c
+ index a zlib or gzip stream and randomly access it
+ - illustrates the use of Z_BLOCK, inflatePrime(), and
+ inflateSetDictionary() to provide random access
diff --git a/zlib/examples/enough.c b/zlib/examples/enough.c
new file mode 100644
index 000000000..b99114430
--- /dev/null
+++ b/zlib/examples/enough.c
@@ -0,0 +1,572 @@
+/* enough.c -- determine the maximum size of inflate's Huffman code tables over
+ * all possible valid and complete Huffman codes, subject to a length limit.
+ * Copyright (C) 2007, 2008, 2012 Mark Adler
+ * Version 1.4 18 August 2012 Mark Adler
+ */
+
+/* Version history:
+ 1.0 3 Jan 2007 First version (derived from codecount.c version 1.4)
+ 1.1 4 Jan 2007 Use faster incremental table usage computation
+ Prune examine() search on previously visited states
+ 1.2 5 Jan 2007 Comments clean up
+ As inflate does, decrease root for short codes
+ Refuse cases where inflate would increase root
+ 1.3 17 Feb 2008 Add argument for initial root table size
+ Fix bug for initial root table size == max - 1
+ Use a macro to compute the history index
+ 1.4 18 Aug 2012 Avoid shifts more than bits in type (caused endless loop!)
+ Clean up comparisons of different types
+ Clean up code indentation
+ */
+
+/*
+ Examine all possible Huffman codes for a given number of symbols and a
+ maximum code length in bits to determine the maximum table size for zilb's
+ inflate. Only complete Huffman codes are counted.
+
+ Two codes are considered distinct if the vectors of the number of codes per
+ length are not identical. So permutations of the symbol assignments result
+ in the same code for the counting, as do permutations of the assignments of
+ the bit values to the codes (i.e. only canonical codes are counted).
+
+ We build a code from shorter to longer lengths, determining how many symbols
+ are coded at each length. At each step, we have how many symbols remain to
+ be coded, what the last code length used was, and how many bit patterns of
+ that length remain unused. Then we add one to the code length and double the
+ number of unused patterns to graduate to the next code length. We then
+ assign all portions of the remaining symbols to that code length that
+ preserve the properties of a correct and eventually complete code. Those
+ properties are: we cannot use more bit patterns than are available; and when
+ all the symbols are used, there are exactly zero possible bit patterns
+ remaining.
+
+ The inflate Huffman decoding algorithm uses two-level lookup tables for
+ speed. There is a single first-level table to decode codes up to root bits
+ in length (root == 9 in the current inflate implementation). The table
+ has 1 << root entries and is indexed by the next root bits of input. Codes
+ shorter than root bits have replicated table entries, so that the correct
+ entry is pointed to regardless of the bits that follow the short code. If
+ the code is longer than root bits, then the table entry points to a second-
+ level table. The size of that table is determined by the longest code with
+ that root-bit prefix. If that longest code has length len, then the table
+ has size 1 << (len - root), to index the remaining bits in that set of
+ codes. Each subsequent root-bit prefix then has its own sub-table. The
+ total number of table entries required by the code is calculated
+ incrementally as the number of codes at each bit length is populated. When
+ all of the codes are shorter than root bits, then root is reduced to the
+ longest code length, resulting in a single, smaller, one-level table.
+
+ The inflate algorithm also provides for small values of root (relative to
+ the log2 of the number of symbols), where the shortest code has more bits
+ than root. In that case, root is increased to the length of the shortest
+ code. This program, by design, does not handle that case, so it is verified
+ that the number of symbols is less than 2^(root + 1).
+
+ In order to speed up the examination (by about ten orders of magnitude for
+ the default arguments), the intermediate states in the build-up of a code
+ are remembered and previously visited branches are pruned. The memory
+ required for this will increase rapidly with the total number of symbols and
+ the maximum code length in bits. However this is a very small price to pay
+ for the vast speedup.
+
+ First, all of the possible Huffman codes are counted, and reachable
+ intermediate states are noted by a non-zero count in a saved-results array.
+ Second, the intermediate states that lead to (root + 1) bit or longer codes
+ are used to look at all sub-codes from those junctures for their inflate
+ memory usage. (The amount of memory used is not affected by the number of
+ codes of root bits or less in length.) Third, the visited states in the
+ construction of those sub-codes and the associated calculation of the table
+ size is recalled in order to avoid recalculating from the same juncture.
+ Beginning the code examination at (root + 1) bit codes, which is enabled by
+ identifying the reachable nodes, accounts for about six of the orders of
+ magnitude of improvement for the default arguments. About another four
+ orders of magnitude come from not revisiting previous states. Out of
+ approximately 2x10^16 possible Huffman codes, only about 2x10^6 sub-codes
+ need to be examined to cover all of the possible table memory usage cases
+ for the default arguments of 286 symbols limited to 15-bit codes.
+
+ Note that an unsigned long long type is used for counting. It is quite easy
+ to exceed the capacity of an eight-byte integer with a large number of
+ symbols and a large maximum code length, so multiple-precision arithmetic
+ would need to replace the unsigned long long arithmetic in that case. This
+ program will abort if an overflow occurs. The big_t type identifies where
+ the counting takes place.
+
+ An unsigned long long type is also used for calculating the number of
+ possible codes remaining at the maximum length. This limits the maximum
+ code length to the number of bits in a long long minus the number of bits
+ needed to represent the symbols in a flat code. The code_t type identifies
+ where the bit pattern counting takes place.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+
+#define local static
+
+/* special data types */
+typedef unsigned long long big_t; /* type for code counting */
+typedef unsigned long long code_t; /* type for bit pattern counting */
+struct tab { /* type for been here check */
+ size_t len; /* length of bit vector in char's */
+ char *vec; /* allocated bit vector */
+};
+
+/* The array for saving results, num[], is indexed with this triplet:
+
+ syms: number of symbols remaining to code
+ left: number of available bit patterns at length len
+ len: number of bits in the codes currently being assigned
+
+ Those indices are constrained thusly when saving results:
+
+ syms: 3..totsym (totsym == total symbols to code)
+ left: 2..syms - 1, but only the evens (so syms == 8 -> 2, 4, 6)
+ len: 1..max - 1 (max == maximum code length in bits)
+
+ syms == 2 is not saved since that immediately leads to a single code. left
+ must be even, since it represents the number of available bit patterns at
+ the current length, which is double the number at the previous length.
+ left ends at syms-1 since left == syms immediately results in a single code.
+ (left > sym is not allowed since that would result in an incomplete code.)
+ len is less than max, since the code completes immediately when len == max.
+
+ The offset into the array is calculated for the three indices with the
+ first one (syms) being outermost, and the last one (len) being innermost.
+ We build the array with length max-1 lists for the len index, with syms-3
+ of those for each symbol. There are totsym-2 of those, with each one
+ varying in length as a function of sym. See the calculation of index in
+ count() for the index, and the calculation of size in main() for the size
+ of the array.
+
+ For the deflate example of 286 symbols limited to 15-bit codes, the array
+ has 284,284 entries, taking up 2.17 MB for an 8-byte big_t. More than
+ half of the space allocated for saved results is actually used -- not all
+ possible triplets are reached in the generation of valid Huffman codes.
+ */
+
+/* The array for tracking visited states, done[], is itself indexed identically
+ to the num[] array as described above for the (syms, left, len) triplet.
+ Each element in the array is further indexed by the (mem, rem) doublet,
+ where mem is the amount of inflate table space used so far, and rem is the
+ remaining unused entries in the current inflate sub-table. Each indexed
+ element is simply one bit indicating whether the state has been visited or
+ not. Since the ranges for mem and rem are not known a priori, each bit
+ vector is of a variable size, and grows as needed to accommodate the visited
+ states. mem and rem are used to calculate a single index in a triangular
+ array. Since the range of mem is expected in the default case to be about
+ ten times larger than the range of rem, the array is skewed to reduce the
+ memory usage, with eight times the range for mem than for rem. See the
+ calculations for offset and bit in beenhere() for the details.
+
+ For the deflate example of 286 symbols limited to 15-bit codes, the bit
+ vectors grow to total approximately 21 MB, in addition to the 4.3 MB done[]
+ array itself.
+ */
+
+/* Globals to avoid propagating constants or constant pointers recursively */
+local int max; /* maximum allowed bit length for the codes */
+local int root; /* size of base code table in bits */
+local int large; /* largest code table so far */
+local size_t size; /* number of elements in num and done */
+local int *code; /* number of symbols assigned to each bit length */
+local big_t *num; /* saved results array for code counting */
+local struct tab *done; /* states already evaluated array */
+
+/* Index function for num[] and done[] */
+#define INDEX(i,j,k) (((size_t)((i-1)>>1)*((i-2)>>1)+(j>>1)-1)*(max-1)+k-1)
+
+/* Free allocated space. Uses globals code, num, and done. */
+local void cleanup(void)
+{
+ size_t n;
+
+ if (done != NULL) {
+ for (n = 0; n < size; n++)
+ if (done[n].len)
+ free(done[n].vec);
+ free(done);
+ }
+ if (num != NULL)
+ free(num);
+ if (code != NULL)
+ free(code);
+}
+
+/* Return the number of possible Huffman codes using bit patterns of lengths
+ len through max inclusive, coding syms symbols, with left bit patterns of
+ length len unused -- return -1 if there is an overflow in the counting.
+ Keep a record of previous results in num to prevent repeating the same
+ calculation. Uses the globals max and num. */
+local big_t count(int syms, int len, int left)
+{
+ big_t sum; /* number of possible codes from this juncture */
+ big_t got; /* value returned from count() */
+ int least; /* least number of syms to use at this juncture */
+ int most; /* most number of syms to use at this juncture */
+ int use; /* number of bit patterns to use in next call */
+ size_t index; /* index of this case in *num */
+
+ /* see if only one possible code */
+ if (syms == left)
+ return 1;
+
+ /* note and verify the expected state */
+ assert(syms > left && left > 0 && len < max);
+
+ /* see if we've done this one already */
+ index = INDEX(syms, left, len);
+ got = num[index];
+ if (got)
+ return got; /* we have -- return the saved result */
+
+ /* we need to use at least this many bit patterns so that the code won't be
+ incomplete at the next length (more bit patterns than symbols) */
+ least = (left << 1) - syms;
+ if (least < 0)
+ least = 0;
+
+ /* we can use at most this many bit patterns, lest there not be enough
+ available for the remaining symbols at the maximum length (if there were
+ no limit to the code length, this would become: most = left - 1) */
+ most = (((code_t)left << (max - len)) - syms) /
+ (((code_t)1 << (max - len)) - 1);
+
+ /* count all possible codes from this juncture and add them up */
+ sum = 0;
+ for (use = least; use <= most; use++) {
+ got = count(syms - use, len + 1, (left - use) << 1);
+ sum += got;
+ if (got == (big_t)0 - 1 || sum < got) /* overflow */
+ return (big_t)0 - 1;
+ }
+
+ /* verify that all recursive calls are productive */
+ assert(sum != 0);
+
+ /* save the result and return it */
+ num[index] = sum;
+ return sum;
+}
+
+/* Return true if we've been here before, set to true if not. Set a bit in a
+ bit vector to indicate visiting this state. Each (syms,len,left) state
+ has a variable size bit vector indexed by (mem,rem). The bit vector is
+ lengthened if needed to allow setting the (mem,rem) bit. */
+local int beenhere(int syms, int len, int left, int mem, int rem)
+{
+ size_t index; /* index for this state's bit vector */
+ size_t offset; /* offset in this state's bit vector */
+ int bit; /* mask for this state's bit */
+ size_t length; /* length of the bit vector in bytes */
+ char *vector; /* new or enlarged bit vector */
+
+ /* point to vector for (syms,left,len), bit in vector for (mem,rem) */
+ index = INDEX(syms, left, len);
+ mem -= 1 << root;
+ offset = (mem >> 3) + rem;
+ offset = ((offset * (offset + 1)) >> 1) + rem;
+ bit = 1 << (mem & 7);
+
+ /* see if we've been here */
+ length = done[index].len;
+ if (offset < length && (done[index].vec[offset] & bit) != 0)
+ return 1; /* done this! */
+
+ /* we haven't been here before -- set the bit to show we have now */
+
+ /* see if we need to lengthen the vector in order to set the bit */
+ if (length <= offset) {
+ /* if we have one already, enlarge it, zero out the appended space */
+ if (length) {
+ do {
+ length <<= 1;
+ } while (length <= offset);
+ vector = realloc(done[index].vec, length);
+ if (vector != NULL)
+ memset(vector + done[index].len, 0, length - done[index].len);
+ }
+
+ /* otherwise we need to make a new vector and zero it out */
+ else {
+ length = 1 << (len - root);
+ while (length <= offset)
+ length <<= 1;
+ vector = calloc(length, sizeof(char));
+ }
+
+ /* in either case, bail if we can't get the memory */
+ if (vector == NULL) {
+ fputs("abort: unable to allocate enough memory\n", stderr);
+ cleanup();
+ exit(1);
+ }
+
+ /* install the new vector */
+ done[index].len = length;
+ done[index].vec = vector;
+ }
+
+ /* set the bit */
+ done[index].vec[offset] |= bit;
+ return 0;
+}
+
+/* Examine all possible codes from the given node (syms, len, left). Compute
+ the amount of memory required to build inflate's decoding tables, where the
+ number of code structures used so far is mem, and the number remaining in
+ the current sub-table is rem. Uses the globals max, code, root, large, and
+ done. */
+local void examine(int syms, int len, int left, int mem, int rem)
+{
+ int least; /* least number of syms to use at this juncture */
+ int most; /* most number of syms to use at this juncture */
+ int use; /* number of bit patterns to use in next call */
+
+ /* see if we have a complete code */
+ if (syms == left) {
+ /* set the last code entry */
+ code[len] = left;
+
+ /* complete computation of memory used by this code */
+ while (rem < left) {
+ left -= rem;
+ rem = 1 << (len - root);
+ mem += rem;
+ }
+ assert(rem == left);
+
+ /* if this is a new maximum, show the entries used and the sub-code */
+ if (mem > large) {
+ large = mem;
+ printf("max %d: ", mem);
+ for (use = root + 1; use <= max; use++)
+ if (code[use])
+ printf("%d[%d] ", code[use], use);
+ putchar('\n');
+ fflush(stdout);
+ }
+
+ /* remove entries as we drop back down in the recursion */
+ code[len] = 0;
+ return;
+ }
+
+ /* prune the tree if we can */
+ if (beenhere(syms, len, left, mem, rem))
+ return;
+
+ /* we need to use at least this many bit patterns so that the code won't be
+ incomplete at the next length (more bit patterns than symbols) */
+ least = (left << 1) - syms;
+ if (least < 0)
+ least = 0;
+
+ /* we can use at most this many bit patterns, lest there not be enough
+ available for the remaining symbols at the maximum length (if there were
+ no limit to the code length, this would become: most = left - 1) */
+ most = (((code_t)left << (max - len)) - syms) /
+ (((code_t)1 << (max - len)) - 1);
+
+ /* occupy least table spaces, creating new sub-tables as needed */
+ use = least;
+ while (rem < use) {
+ use -= rem;
+ rem = 1 << (len - root);
+ mem += rem;
+ }
+ rem -= use;
+
+ /* examine codes from here, updating table space as we go */
+ for (use = least; use <= most; use++) {
+ code[len] = use;
+ examine(syms - use, len + 1, (left - use) << 1,
+ mem + (rem ? 1 << (len - root) : 0), rem << 1);
+ if (rem == 0) {
+ rem = 1 << (len - root);
+ mem += rem;
+ }
+ rem--;
+ }
+
+ /* remove entries as we drop back down in the recursion */
+ code[len] = 0;
+}
+
+/* Look at all sub-codes starting with root + 1 bits. Look at only the valid
+ intermediate code states (syms, left, len). For each completed code,
+ calculate the amount of memory required by inflate to build the decoding
+ tables. Find the maximum amount of memory required and show the code that
+ requires that maximum. Uses the globals max, root, and num. */
+local void enough(int syms)
+{
+ int n; /* number of remaing symbols for this node */
+ int left; /* number of unused bit patterns at this length */
+ size_t index; /* index of this case in *num */
+
+ /* clear code */
+ for (n = 0; n <= max; n++)
+ code[n] = 0;
+
+ /* look at all (root + 1) bit and longer codes */
+ large = 1 << root; /* base table */
+ if (root < max) /* otherwise, there's only a base table */
+ for (n = 3; n <= syms; n++)
+ for (left = 2; left < n; left += 2)
+ {
+ /* look at all reachable (root + 1) bit nodes, and the
+ resulting codes (complete at root + 2 or more) */
+ index = INDEX(n, left, root + 1);
+ if (root + 1 < max && num[index]) /* reachable node */
+ examine(n, root + 1, left, 1 << root, 0);
+
+ /* also look at root bit codes with completions at root + 1
+ bits (not saved in num, since complete), just in case */
+ if (num[index - 1] && n <= left << 1)
+ examine((n - left) << 1, root + 1, (n - left) << 1,
+ 1 << root, 0);
+ }
+
+ /* done */
+ printf("done: maximum of %d table entries\n", large);
+}
+
+/*
+ Examine and show the total number of possible Huffman codes for a given
+ maximum number of symbols, initial root table size, and maximum code length
+ in bits -- those are the command arguments in that order. The default
+ values are 286, 9, and 15 respectively, for the deflate literal/length code.
+ The possible codes are counted for each number of coded symbols from two to
+ the maximum. The counts for each of those and the total number of codes are
+ shown. The maximum number of inflate table entires is then calculated
+ across all possible codes. Each new maximum number of table entries and the
+ associated sub-code (starting at root + 1 == 10 bits) is shown.
+
+ To count and examine Huffman codes that are not length-limited, provide a
+ maximum length equal to the number of symbols minus one.
+
+ For the deflate literal/length code, use "enough". For the deflate distance
+ code, use "enough 30 6".
+
+ This uses the %llu printf format to print big_t numbers, which assumes that
+ big_t is an unsigned long long. If the big_t type is changed (for example
+ to a multiple precision type), the method of printing will also need to be
+ updated.
+ */
+int main(int argc, char **argv)
+{
+ int syms; /* total number of symbols to code */
+ int n; /* number of symbols to code for this run */
+ big_t got; /* return value of count() */
+ big_t sum; /* accumulated number of codes over n */
+ code_t word; /* for counting bits in code_t */
+
+ /* set up globals for cleanup() */
+ code = NULL;
+ num = NULL;
+ done = NULL;
+
+ /* get arguments -- default to the deflate literal/length code */
+ syms = 286;
+ root = 9;
+ max = 15;
+ if (argc > 1) {
+ syms = atoi(argv[1]);
+ if (argc > 2) {
+ root = atoi(argv[2]);
+ if (argc > 3)
+ max = atoi(argv[3]);
+ }
+ }
+ if (argc > 4 || syms < 2 || root < 1 || max < 1) {
+ fputs("invalid arguments, need: [sym >= 2 [root >= 1 [max >= 1]]]\n",
+ stderr);
+ return 1;
+ }
+
+ /* if not restricting the code length, the longest is syms - 1 */
+ if (max > syms - 1)
+ max = syms - 1;
+
+ /* determine the number of bits in a code_t */
+ for (n = 0, word = 1; word; n++, word <<= 1)
+ ;
+
+ /* make sure that the calculation of most will not overflow */
+ if (max > n || (code_t)(syms - 2) >= (((code_t)0 - 1) >> (max - 1))) {
+ fputs("abort: code length too long for internal types\n", stderr);
+ return 1;
+ }
+
+ /* reject impossible code requests */
+ if ((code_t)(syms - 1) > ((code_t)1 << max) - 1) {
+ fprintf(stderr, "%d symbols cannot be coded in %d bits\n",
+ syms, max);
+ return 1;
+ }
+
+ /* allocate code vector */
+ code = calloc(max + 1, sizeof(int));
+ if (code == NULL) {
+ fputs("abort: unable to allocate enough memory\n", stderr);
+ return 1;
+ }
+
+ /* determine size of saved results array, checking for overflows,
+ allocate and clear the array (set all to zero with calloc()) */
+ if (syms == 2) /* iff max == 1 */
+ num = NULL; /* won't be saving any results */
+ else {
+ size = syms >> 1;
+ if (size > ((size_t)0 - 1) / (n = (syms - 1) >> 1) ||
+ (size *= n, size > ((size_t)0 - 1) / (n = max - 1)) ||
+ (size *= n, size > ((size_t)0 - 1) / sizeof(big_t)) ||
+ (num = calloc(size, sizeof(big_t))) == NULL) {
+ fputs("abort: unable to allocate enough memory\n", stderr);
+ cleanup();
+ return 1;
+ }
+ }
+
+ /* count possible codes for all numbers of symbols, add up counts */
+ sum = 0;
+ for (n = 2; n <= syms; n++) {
+ got = count(n, 1, 2);
+ sum += got;
+ if (got == (big_t)0 - 1 || sum < got) { /* overflow */
+ fputs("abort: can't count that high!\n", stderr);
+ cleanup();
+ return 1;
+ }
+ printf("%llu %d-codes\n", got, n);
+ }
+ printf("%llu total codes for 2 to %d symbols", sum, syms);
+ if (max < syms - 1)
+ printf(" (%d-bit length limit)\n", max);
+ else
+ puts(" (no length limit)");
+
+ /* allocate and clear done array for beenhere() */
+ if (syms == 2)
+ done = NULL;
+ else if (size > ((size_t)0 - 1) / sizeof(struct tab) ||
+ (done = calloc(size, sizeof(struct tab))) == NULL) {
+ fputs("abort: unable to allocate enough memory\n", stderr);
+ cleanup();
+ return 1;
+ }
+
+ /* find and show maximum inflate table usage */
+ if (root > max) /* reduce root to max length */
+ root = max;
+ if ((code_t)syms < ((code_t)1 << (root + 1)))
+ enough(syms);
+ else
+ puts("cannot handle minimum code lengths > root");
+
+ /* done */
+ cleanup();
+ return 0;
+}
diff --git a/zlib/examples/fitblk.c b/zlib/examples/fitblk.c
new file mode 100644
index 000000000..c61de5c99
--- /dev/null
+++ b/zlib/examples/fitblk.c
@@ -0,0 +1,233 @@
+/* fitblk.c: example of fitting compressed output to a specified size
+ Not copyrighted -- provided to the public domain
+ Version 1.1 25 November 2004 Mark Adler */
+
+/* Version history:
+ 1.0 24 Nov 2004 First version
+ 1.1 25 Nov 2004 Change deflateInit2() to deflateInit()
+ Use fixed-size, stack-allocated raw buffers
+ Simplify code moving compression to subroutines
+ Use assert() for internal errors
+ Add detailed description of approach
+ */
+
+/* Approach to just fitting a requested compressed size:
+
+ fitblk performs three compression passes on a portion of the input
+ data in order to determine how much of that input will compress to
+ nearly the requested output block size. The first pass generates
+ enough deflate blocks to produce output to fill the requested
+ output size plus a specfied excess amount (see the EXCESS define
+ below). The last deflate block may go quite a bit past that, but
+ is discarded. The second pass decompresses and recompresses just
+ the compressed data that fit in the requested plus excess sized
+ buffer. The deflate process is terminated after that amount of
+ input, which is less than the amount consumed on the first pass.
+ The last deflate block of the result will be of a comparable size
+ to the final product, so that the header for that deflate block and
+ the compression ratio for that block will be about the same as in
+ the final product. The third compression pass decompresses the
+ result of the second step, but only the compressed data up to the
+ requested size minus an amount to allow the compressed stream to
+ complete (see the MARGIN define below). That will result in a
+ final compressed stream whose length is less than or equal to the
+ requested size. Assuming sufficient input and a requested size
+ greater than a few hundred bytes, the shortfall will typically be
+ less than ten bytes.
+
+ If the input is short enough that the first compression completes
+ before filling the requested output size, then that compressed
+ stream is return with no recompression.
+
+ EXCESS is chosen to be just greater than the shortfall seen in a
+ two pass approach similar to the above. That shortfall is due to
+ the last deflate block compressing more efficiently with a smaller
+ header on the second pass. EXCESS is set to be large enough so
+ that there is enough uncompressed data for the second pass to fill
+ out the requested size, and small enough so that the final deflate
+ block of the second pass will be close in size to the final deflate
+ block of the third and final pass. MARGIN is chosen to be just
+ large enough to assure that the final compression has enough room
+ to complete in all cases.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <assert.h>
+#include "zlib.h"
+
+#define local static
+
+/* print nastygram and leave */
+local void quit(char *why)
+{
+ fprintf(stderr, "fitblk abort: %s\n", why);
+ exit(1);
+}
+
+#define RAWLEN 4096 /* intermediate uncompressed buffer size */
+
+/* compress from file to def until provided buffer is full or end of
+ input reached; return last deflate() return value, or Z_ERRNO if
+ there was read error on the file */
+local int partcompress(FILE *in, z_streamp def)
+{
+ int ret, flush;
+ unsigned char raw[RAWLEN];
+
+ flush = Z_NO_FLUSH;
+ do {
+ def->avail_in = fread(raw, 1, RAWLEN, in);
+ if (ferror(in))
+ return Z_ERRNO;
+ def->next_in = raw;
+ if (feof(in))
+ flush = Z_FINISH;
+ ret = deflate(def, flush);
+ assert(ret != Z_STREAM_ERROR);
+ } while (def->avail_out != 0 && flush == Z_NO_FLUSH);
+ return ret;
+}
+
+/* recompress from inf's input to def's output; the input for inf and
+ the output for def are set in those structures before calling;
+ return last deflate() return value, or Z_MEM_ERROR if inflate()
+ was not able to allocate enough memory when it needed to */
+local int recompress(z_streamp inf, z_streamp def)
+{
+ int ret, flush;
+ unsigned char raw[RAWLEN];
+
+ flush = Z_NO_FLUSH;
+ do {
+ /* decompress */
+ inf->avail_out = RAWLEN;
+ inf->next_out = raw;
+ ret = inflate(inf, Z_NO_FLUSH);
+ assert(ret != Z_STREAM_ERROR && ret != Z_DATA_ERROR &&
+ ret != Z_NEED_DICT);
+ if (ret == Z_MEM_ERROR)
+ return ret;
+
+ /* compress what was decompresed until done or no room */
+ def->avail_in = RAWLEN - inf->avail_out;
+ def->next_in = raw;
+ if (inf->avail_out != 0)
+ flush = Z_FINISH;
+ ret = deflate(def, flush);
+ assert(ret != Z_STREAM_ERROR);
+ } while (ret != Z_STREAM_END && def->avail_out != 0);
+ return ret;
+}
+
+#define EXCESS 256 /* empirically determined stream overage */
+#define MARGIN 8 /* amount to back off for completion */
+
+/* compress from stdin to fixed-size block on stdout */
+int main(int argc, char **argv)
+{
+ int ret; /* return code */
+ unsigned size; /* requested fixed output block size */
+ unsigned have; /* bytes written by deflate() call */
+ unsigned char *blk; /* intermediate and final stream */
+ unsigned char *tmp; /* close to desired size stream */
+ z_stream def, inf; /* zlib deflate and inflate states */
+
+ /* get requested output size */
+ if (argc != 2)
+ quit("need one argument: size of output block");
+ ret = strtol(argv[1], argv + 1, 10);
+ if (argv[1][0] != 0)
+ quit("argument must be a number");
+ if (ret < 8) /* 8 is minimum zlib stream size */
+ quit("need positive size of 8 or greater");
+ size = (unsigned)ret;
+
+ /* allocate memory for buffers and compression engine */
+ blk = malloc(size + EXCESS);
+ def.zalloc = Z_NULL;
+ def.zfree = Z_NULL;
+ def.opaque = Z_NULL;
+ ret = deflateInit(&def, Z_DEFAULT_COMPRESSION);
+ if (ret != Z_OK || blk == NULL)
+ quit("out of memory");
+
+ /* compress from stdin until output full, or no more input */
+ def.avail_out = size + EXCESS;
+ def.next_out = blk;
+ ret = partcompress(stdin, &def);
+ if (ret == Z_ERRNO)
+ quit("error reading input");
+
+ /* if it all fit, then size was undersubscribed -- done! */
+ if (ret == Z_STREAM_END && def.avail_out >= EXCESS) {
+ /* write block to stdout */
+ have = size + EXCESS - def.avail_out;
+ if (fwrite(blk, 1, have, stdout) != have || ferror(stdout))
+ quit("error writing output");
+
+ /* clean up and print results to stderr */
+ ret = deflateEnd(&def);
+ assert(ret != Z_STREAM_ERROR);
+ free(blk);
+ fprintf(stderr,
+ "%u bytes unused out of %u requested (all input)\n",
+ size - have, size);
+ return 0;
+ }
+
+ /* it didn't all fit -- set up for recompression */
+ inf.zalloc = Z_NULL;
+ inf.zfree = Z_NULL;
+ inf.opaque = Z_NULL;
+ inf.avail_in = 0;
+ inf.next_in = Z_NULL;
+ ret = inflateInit(&inf);
+ tmp = malloc(size + EXCESS);
+ if (ret != Z_OK || tmp == NULL)
+ quit("out of memory");
+ ret = deflateReset(&def);
+ assert(ret != Z_STREAM_ERROR);
+
+ /* do first recompression close to the right amount */
+ inf.avail_in = size + EXCESS;
+ inf.next_in = blk;
+ def.avail_out = size + EXCESS;
+ def.next_out = tmp;
+ ret = recompress(&inf, &def);
+ if (ret == Z_MEM_ERROR)
+ quit("out of memory");
+
+ /* set up for next reocmpression */
+ ret = inflateReset(&inf);
+ assert(ret != Z_STREAM_ERROR);
+ ret = deflateReset(&def);
+ assert(ret != Z_STREAM_ERROR);
+
+ /* do second and final recompression (third compression) */
+ inf.avail_in = size - MARGIN; /* assure stream will complete */
+ inf.next_in = tmp;
+ def.avail_out = size;
+ def.next_out = blk;
+ ret = recompress(&inf, &def);
+ if (ret == Z_MEM_ERROR)
+ quit("out of memory");
+ assert(ret == Z_STREAM_END); /* otherwise MARGIN too small */
+
+ /* done -- write block to stdout */
+ have = size - def.avail_out;
+ if (fwrite(blk, 1, have, stdout) != have || ferror(stdout))
+ quit("error writing output");
+
+ /* clean up and print results to stderr */
+ free(tmp);
+ ret = inflateEnd(&inf);
+ assert(ret != Z_STREAM_ERROR);
+ ret = deflateEnd(&def);
+ assert(ret != Z_STREAM_ERROR);
+ free(blk);
+ fprintf(stderr,
+ "%u bytes unused out of %u requested (%lu input)\n",
+ size - have, size, def.total_in);
+ return 0;
+}
diff --git a/zlib/examples/gun.c b/zlib/examples/gun.c
new file mode 100644
index 000000000..be44fa51f
--- /dev/null
+++ b/zlib/examples/gun.c
@@ -0,0 +1,702 @@
+/* gun.c -- simple gunzip to give an example of the use of inflateBack()
+ * Copyright (C) 2003, 2005, 2008, 2010, 2012 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ Version 1.7 12 August 2012 Mark Adler */
+
+/* Version history:
+ 1.0 16 Feb 2003 First version for testing of inflateBack()
+ 1.1 21 Feb 2005 Decompress concatenated gzip streams
+ Remove use of "this" variable (C++ keyword)
+ Fix return value for in()
+ Improve allocation failure checking
+ Add typecasting for void * structures
+ Add -h option for command version and usage
+ Add a bunch of comments
+ 1.2 20 Mar 2005 Add Unix compress (LZW) decompression
+ Copy file attributes from input file to output file
+ 1.3 12 Jun 2005 Add casts for error messages [Oberhumer]
+ 1.4 8 Dec 2006 LZW decompression speed improvements
+ 1.5 9 Feb 2008 Avoid warning in latest version of gcc
+ 1.6 17 Jan 2010 Avoid signed/unsigned comparison warnings
+ 1.7 12 Aug 2012 Update for z_const usage in zlib 1.2.8
+ */
+
+/*
+ gun [ -t ] [ name ... ]
+
+ decompresses the data in the named gzip files. If no arguments are given,
+ gun will decompress from stdin to stdout. The names must end in .gz, -gz,
+ .z, -z, _z, or .Z. The uncompressed data will be written to a file name
+ with the suffix stripped. On success, the original file is deleted. On
+ failure, the output file is deleted. For most failures, the command will
+ continue to process the remaining names on the command line. A memory
+ allocation failure will abort the command. If -t is specified, then the
+ listed files or stdin will be tested as gzip files for integrity (without
+ checking for a proper suffix), no output will be written, and no files
+ will be deleted.
+
+ Like gzip, gun allows concatenated gzip streams and will decompress them,
+ writing all of the uncompressed data to the output. Unlike gzip, gun allows
+ an empty file on input, and will produce no error writing an empty output
+ file.
+
+ gun will also decompress files made by Unix compress, which uses LZW
+ compression. These files are automatically detected by virtue of their
+ magic header bytes. Since the end of Unix compress stream is marked by the
+ end-of-file, they cannot be concantenated. If a Unix compress stream is
+ encountered in an input file, it is the last stream in that file.
+
+ Like gunzip and uncompress, the file attributes of the original compressed
+ file are maintained in the final uncompressed file, to the extent that the
+ user permissions allow it.
+
+ On my Mac OS X PowerPC G4, gun is almost twice as fast as gunzip (version
+ 1.2.4) is on the same file, when gun is linked with zlib 1.2.2. Also the
+ LZW decompression provided by gun is about twice as fast as the standard
+ Unix uncompress command.
+ */
+
+/* external functions and related types and constants */
+#include <stdio.h> /* fprintf() */
+#include <stdlib.h> /* malloc(), free() */
+#include <string.h> /* strerror(), strcmp(), strlen(), memcpy() */
+#include <errno.h> /* errno */
+#include <fcntl.h> /* open() */
+#include <unistd.h> /* read(), write(), close(), chown(), unlink() */
+#include <sys/types.h>
+#include <sys/stat.h> /* stat(), chmod() */
+#include <utime.h> /* utime() */
+#include "zlib.h" /* inflateBackInit(), inflateBack(), */
+ /* inflateBackEnd(), crc32() */
+
+/* function declaration */
+#define local static
+
+/* buffer constants */
+#define SIZE 32768U /* input and output buffer sizes */
+#define PIECE 16384 /* limits i/o chunks for 16-bit int case */
+
+/* structure for infback() to pass to input function in() -- it maintains the
+ input file and a buffer of size SIZE */
+struct ind {
+ int infile;
+ unsigned char *inbuf;
+};
+
+/* Load input buffer, assumed to be empty, and return bytes loaded and a
+ pointer to them. read() is called until the buffer is full, or until it
+ returns end-of-file or error. Return 0 on error. */
+local unsigned in(void *in_desc, z_const unsigned char **buf)
+{
+ int ret;
+ unsigned len;
+ unsigned char *next;
+ struct ind *me = (struct ind *)in_desc;
+
+ next = me->inbuf;
+ *buf = next;
+ len = 0;
+ do {
+ ret = PIECE;
+ if ((unsigned)ret > SIZE - len)
+ ret = (int)(SIZE - len);
+ ret = (int)read(me->infile, next, ret);
+ if (ret == -1) {
+ len = 0;
+ break;
+ }
+ next += ret;
+ len += ret;
+ } while (ret != 0 && len < SIZE);
+ return len;
+}
+
+/* structure for infback() to pass to output function out() -- it maintains the
+ output file, a running CRC-32 check on the output and the total number of
+ bytes output, both for checking against the gzip trailer. (The length in
+ the gzip trailer is stored modulo 2^32, so it's ok if a long is 32 bits and
+ the output is greater than 4 GB.) */
+struct outd {
+ int outfile;
+ int check; /* true if checking crc and total */
+ unsigned long crc;
+ unsigned long total;
+};
+
+/* Write output buffer and update the CRC-32 and total bytes written. write()
+ is called until all of the output is written or an error is encountered.
+ On success out() returns 0. For a write failure, out() returns 1. If the
+ output file descriptor is -1, then nothing is written.
+ */
+local int out(void *out_desc, unsigned char *buf, unsigned len)
+{
+ int ret;
+ struct outd *me = (struct outd *)out_desc;
+
+ if (me->check) {
+ me->crc = crc32(me->crc, buf, len);
+ me->total += len;
+ }
+ if (me->outfile != -1)
+ do {
+ ret = PIECE;
+ if ((unsigned)ret > len)
+ ret = (int)len;
+ ret = (int)write(me->outfile, buf, ret);
+ if (ret == -1)
+ return 1;
+ buf += ret;
+ len -= ret;
+ } while (len != 0);
+ return 0;
+}
+
+/* next input byte macro for use inside lunpipe() and gunpipe() */
+#define NEXT() (have ? 0 : (have = in(indp, &next)), \
+ last = have ? (have--, (int)(*next++)) : -1)
+
+/* memory for gunpipe() and lunpipe() --
+ the first 256 entries of prefix[] and suffix[] are never used, could
+ have offset the index, but it's faster to waste the memory */
+unsigned char inbuf[SIZE]; /* input buffer */
+unsigned char outbuf[SIZE]; /* output buffer */
+unsigned short prefix[65536]; /* index to LZW prefix string */
+unsigned char suffix[65536]; /* one-character LZW suffix */
+unsigned char match[65280 + 2]; /* buffer for reversed match or gzip
+ 32K sliding window */
+
+/* throw out what's left in the current bits byte buffer (this is a vestigial
+ aspect of the compressed data format derived from an implementation that
+ made use of a special VAX machine instruction!) */
+#define FLUSHCODE() \
+ do { \
+ left = 0; \
+ rem = 0; \
+ if (chunk > have) { \
+ chunk -= have; \
+ have = 0; \
+ if (NEXT() == -1) \
+ break; \
+ chunk--; \
+ if (chunk > have) { \
+ chunk = have = 0; \
+ break; \
+ } \
+ } \
+ have -= chunk; \
+ next += chunk; \
+ chunk = 0; \
+ } while (0)
+
+/* Decompress a compress (LZW) file from indp to outfile. The compress magic
+ header (two bytes) has already been read and verified. There are have bytes
+ of buffered input at next. strm is used for passing error information back
+ to gunpipe().
+
+ lunpipe() will return Z_OK on success, Z_BUF_ERROR for an unexpected end of
+ file, read error, or write error (a write error indicated by strm->next_in
+ not equal to Z_NULL), or Z_DATA_ERROR for invalid input.
+ */
+local int lunpipe(unsigned have, z_const unsigned char *next, struct ind *indp,
+ int outfile, z_stream *strm)
+{
+ int last; /* last byte read by NEXT(), or -1 if EOF */
+ unsigned chunk; /* bytes left in current chunk */
+ int left; /* bits left in rem */
+ unsigned rem; /* unused bits from input */
+ int bits; /* current bits per code */
+ unsigned code; /* code, table traversal index */
+ unsigned mask; /* mask for current bits codes */
+ int max; /* maximum bits per code for this stream */
+ unsigned flags; /* compress flags, then block compress flag */
+ unsigned end; /* last valid entry in prefix/suffix tables */
+ unsigned temp; /* current code */
+ unsigned prev; /* previous code */
+ unsigned final; /* last character written for previous code */
+ unsigned stack; /* next position for reversed string */
+ unsigned outcnt; /* bytes in output buffer */
+ struct outd outd; /* output structure */
+ unsigned char *p;
+
+ /* set up output */
+ outd.outfile = outfile;
+ outd.check = 0;
+
+ /* process remainder of compress header -- a flags byte */
+ flags = NEXT();
+ if (last == -1)
+ return Z_BUF_ERROR;
+ if (flags & 0x60) {
+ strm->msg = (char *)"unknown lzw flags set";
+ return Z_DATA_ERROR;
+ }
+ max = flags & 0x1f;
+ if (max < 9 || max > 16) {
+ strm->msg = (char *)"lzw bits out of range";
+ return Z_DATA_ERROR;
+ }
+ if (max == 9) /* 9 doesn't really mean 9 */
+ max = 10;
+ flags &= 0x80; /* true if block compress */
+
+ /* clear table */
+ bits = 9;
+ mask = 0x1ff;
+ end = flags ? 256 : 255;
+
+ /* set up: get first 9-bit code, which is the first decompressed byte, but
+ don't create a table entry until the next code */
+ if (NEXT() == -1) /* no compressed data is ok */
+ return Z_OK;
+ final = prev = (unsigned)last; /* low 8 bits of code */
+ if (NEXT() == -1) /* missing a bit */
+ return Z_BUF_ERROR;
+ if (last & 1) { /* code must be < 256 */
+ strm->msg = (char *)"invalid lzw code";
+ return Z_DATA_ERROR;
+ }
+ rem = (unsigned)last >> 1; /* remaining 7 bits */
+ left = 7;
+ chunk = bits - 2; /* 7 bytes left in this chunk */
+ outbuf[0] = (unsigned char)final; /* write first decompressed byte */
+ outcnt = 1;
+
+ /* decode codes */
+ stack = 0;
+ for (;;) {
+ /* if the table will be full after this, increment the code size */
+ if (end >= mask && bits < max) {
+ FLUSHCODE();
+ bits++;
+ mask <<= 1;
+ mask++;
+ }
+
+ /* get a code of length bits */
+ if (chunk == 0) /* decrement chunk modulo bits */
+ chunk = bits;
+ code = rem; /* low bits of code */
+ if (NEXT() == -1) { /* EOF is end of compressed data */
+ /* write remaining buffered output */
+ if (outcnt && out(&outd, outbuf, outcnt)) {
+ strm->next_in = outbuf; /* signal write error */
+ return Z_BUF_ERROR;
+ }
+ return Z_OK;
+ }
+ code += (unsigned)last << left; /* middle (or high) bits of code */
+ left += 8;
+ chunk--;
+ if (bits > left) { /* need more bits */
+ if (NEXT() == -1) /* can't end in middle of code */
+ return Z_BUF_ERROR;
+ code += (unsigned)last << left; /* high bits of code */
+ left += 8;
+ chunk--;
+ }
+ code &= mask; /* mask to current code length */
+ left -= bits; /* number of unused bits */
+ rem = (unsigned)last >> (8 - left); /* unused bits from last byte */
+
+ /* process clear code (256) */
+ if (code == 256 && flags) {
+ FLUSHCODE();
+ bits = 9; /* initialize bits and mask */
+ mask = 0x1ff;
+ end = 255; /* empty table */
+ continue; /* get next code */
+ }
+
+ /* special code to reuse last match */
+ temp = code; /* save the current code */
+ if (code > end) {
+ /* Be picky on the allowed code here, and make sure that the code
+ we drop through (prev) will be a valid index so that random
+ input does not cause an exception. The code != end + 1 check is
+ empirically derived, and not checked in the original uncompress
+ code. If this ever causes a problem, that check could be safely
+ removed. Leaving this check in greatly improves gun's ability
+ to detect random or corrupted input after a compress header.
+ In any case, the prev > end check must be retained. */
+ if (code != end + 1 || prev > end) {
+ strm->msg = (char *)"invalid lzw code";
+ return Z_DATA_ERROR;
+ }
+ match[stack++] = (unsigned char)final;
+ code = prev;
+ }
+
+ /* walk through linked list to generate output in reverse order */
+ p = match + stack;
+ while (code >= 256) {
+ *p++ = suffix[code];
+ code = prefix[code];
+ }
+ stack = p - match;
+ match[stack++] = (unsigned char)code;
+ final = code;
+
+ /* link new table entry */
+ if (end < mask) {
+ end++;
+ prefix[end] = (unsigned short)prev;
+ suffix[end] = (unsigned char)final;
+ }
+
+ /* set previous code for next iteration */
+ prev = temp;
+
+ /* write output in forward order */
+ while (stack > SIZE - outcnt) {
+ while (outcnt < SIZE)
+ outbuf[outcnt++] = match[--stack];
+ if (out(&outd, outbuf, outcnt)) {
+ strm->next_in = outbuf; /* signal write error */
+ return Z_BUF_ERROR;
+ }
+ outcnt = 0;
+ }
+ p = match + stack;
+ do {
+ outbuf[outcnt++] = *--p;
+ } while (p > match);
+ stack = 0;
+
+ /* loop for next code with final and prev as the last match, rem and
+ left provide the first 0..7 bits of the next code, end is the last
+ valid table entry */
+ }
+}
+
+/* Decompress a gzip file from infile to outfile. strm is assumed to have been
+ successfully initialized with inflateBackInit(). The input file may consist
+ of a series of gzip streams, in which case all of them will be decompressed
+ to the output file. If outfile is -1, then the gzip stream(s) integrity is
+ checked and nothing is written.
+
+ The return value is a zlib error code: Z_MEM_ERROR if out of memory,
+ Z_DATA_ERROR if the header or the compressed data is invalid, or if the
+ trailer CRC-32 check or length doesn't match, Z_BUF_ERROR if the input ends
+ prematurely or a write error occurs, or Z_ERRNO if junk (not a another gzip
+ stream) follows a valid gzip stream.
+ */
+local int gunpipe(z_stream *strm, int infile, int outfile)
+{
+ int ret, first, last;
+ unsigned have, flags, len;
+ z_const unsigned char *next = NULL;
+ struct ind ind, *indp;
+ struct outd outd;
+
+ /* setup input buffer */
+ ind.infile = infile;
+ ind.inbuf = inbuf;
+ indp = &ind;
+
+ /* decompress concatenated gzip streams */
+ have = 0; /* no input data read in yet */
+ first = 1; /* looking for first gzip header */
+ strm->next_in = Z_NULL; /* so Z_BUF_ERROR means EOF */
+ for (;;) {
+ /* look for the two magic header bytes for a gzip stream */
+ if (NEXT() == -1) {
+ ret = Z_OK;
+ break; /* empty gzip stream is ok */
+ }
+ if (last != 31 || (NEXT() != 139 && last != 157)) {
+ strm->msg = (char *)"incorrect header check";
+ ret = first ? Z_DATA_ERROR : Z_ERRNO;
+ break; /* not a gzip or compress header */
+ }
+ first = 0; /* next non-header is junk */
+
+ /* process a compress (LZW) file -- can't be concatenated after this */
+ if (last == 157) {
+ ret = lunpipe(have, next, indp, outfile, strm);
+ break;
+ }
+
+ /* process remainder of gzip header */
+ ret = Z_BUF_ERROR;
+ if (NEXT() != 8) { /* only deflate method allowed */
+ if (last == -1) break;
+ strm->msg = (char *)"unknown compression method";
+ ret = Z_DATA_ERROR;
+ break;
+ }
+ flags = NEXT(); /* header flags */
+ NEXT(); /* discard mod time, xflgs, os */
+ NEXT();
+ NEXT();
+ NEXT();
+ NEXT();
+ NEXT();
+ if (last == -1) break;
+ if (flags & 0xe0) {
+ strm->msg = (char *)"unknown header flags set";
+ ret = Z_DATA_ERROR;
+ break;
+ }
+ if (flags & 4) { /* extra field */
+ len = NEXT();
+ len += (unsigned)(NEXT()) << 8;
+ if (last == -1) break;
+ while (len > have) {
+ len -= have;
+ have = 0;
+ if (NEXT() == -1) break;
+ len--;
+ }
+ if (last == -1) break;
+ have -= len;
+ next += len;
+ }
+ if (flags & 8) /* file name */
+ while (NEXT() != 0 && last != -1)
+ ;
+ if (flags & 16) /* comment */
+ while (NEXT() != 0 && last != -1)
+ ;
+ if (flags & 2) { /* header crc */
+ NEXT();
+ NEXT();
+ }
+ if (last == -1) break;
+
+ /* set up output */
+ outd.outfile = outfile;
+ outd.check = 1;
+ outd.crc = crc32(0L, Z_NULL, 0);
+ outd.total = 0;
+
+ /* decompress data to output */
+ strm->next_in = next;
+ strm->avail_in = have;
+ ret = inflateBack(strm, in, indp, out, &outd);
+ if (ret != Z_STREAM_END) break;
+ next = strm->next_in;
+ have = strm->avail_in;
+ strm->next_in = Z_NULL; /* so Z_BUF_ERROR means EOF */
+
+ /* check trailer */
+ ret = Z_BUF_ERROR;
+ if (NEXT() != (int)(outd.crc & 0xff) ||
+ NEXT() != (int)((outd.crc >> 8) & 0xff) ||
+ NEXT() != (int)((outd.crc >> 16) & 0xff) ||
+ NEXT() != (int)((outd.crc >> 24) & 0xff)) {
+ /* crc error */
+ if (last != -1) {
+ strm->msg = (char *)"incorrect data check";
+ ret = Z_DATA_ERROR;
+ }
+ break;
+ }
+ if (NEXT() != (int)(outd.total & 0xff) ||
+ NEXT() != (int)((outd.total >> 8) & 0xff) ||
+ NEXT() != (int)((outd.total >> 16) & 0xff) ||
+ NEXT() != (int)((outd.total >> 24) & 0xff)) {
+ /* length error */
+ if (last != -1) {
+ strm->msg = (char *)"incorrect length check";
+ ret = Z_DATA_ERROR;
+ }
+ break;
+ }
+
+ /* go back and look for another gzip stream */
+ }
+
+ /* clean up and return */
+ return ret;
+}
+
+/* Copy file attributes, from -> to, as best we can. This is best effort, so
+ no errors are reported. The mode bits, including suid, sgid, and the sticky
+ bit are copied (if allowed), the owner's user id and group id are copied
+ (again if allowed), and the access and modify times are copied. */
+local void copymeta(char *from, char *to)
+{
+ struct stat was;
+ struct utimbuf when;
+
+ /* get all of from's Unix meta data, return if not a regular file */
+ if (stat(from, &was) != 0 || (was.st_mode & S_IFMT) != S_IFREG)
+ return;
+
+ /* set to's mode bits, ignore errors */
+ (void)chmod(to, was.st_mode & 07777);
+
+ /* copy owner's user and group, ignore errors */
+ (void)chown(to, was.st_uid, was.st_gid);
+
+ /* copy access and modify times, ignore errors */
+ when.actime = was.st_atime;
+ when.modtime = was.st_mtime;
+ (void)utime(to, &when);
+}
+
+/* Decompress the file inname to the file outnname, of if test is true, just
+ decompress without writing and check the gzip trailer for integrity. If
+ inname is NULL or an empty string, read from stdin. If outname is NULL or
+ an empty string, write to stdout. strm is a pre-initialized inflateBack
+ structure. When appropriate, copy the file attributes from inname to
+ outname.
+
+ gunzip() returns 1 if there is an out-of-memory error or an unexpected
+ return code from gunpipe(). Otherwise it returns 0.
+ */
+local int gunzip(z_stream *strm, char *inname, char *outname, int test)
+{
+ int ret;
+ int infile, outfile;
+
+ /* open files */
+ if (inname == NULL || *inname == 0) {
+ inname = "-";
+ infile = 0; /* stdin */
+ }
+ else {
+ infile = open(inname, O_RDONLY, 0);
+ if (infile == -1) {
+ fprintf(stderr, "gun cannot open %s\n", inname);
+ return 0;
+ }
+ }
+ if (test)
+ outfile = -1;
+ else if (outname == NULL || *outname == 0) {
+ outname = "-";
+ outfile = 1; /* stdout */
+ }
+ else {
+ outfile = open(outname, O_CREAT | O_TRUNC | O_WRONLY, 0666);
+ if (outfile == -1) {
+ close(infile);
+ fprintf(stderr, "gun cannot create %s\n", outname);
+ return 0;
+ }
+ }
+ errno = 0;
+
+ /* decompress */
+ ret = gunpipe(strm, infile, outfile);
+ if (outfile > 2) close(outfile);
+ if (infile > 2) close(infile);
+
+ /* interpret result */
+ switch (ret) {
+ case Z_OK:
+ case Z_ERRNO:
+ if (infile > 2 && outfile > 2) {
+ copymeta(inname, outname); /* copy attributes */
+ unlink(inname);
+ }
+ if (ret == Z_ERRNO)
+ fprintf(stderr, "gun warning: trailing garbage ignored in %s\n",
+ inname);
+ break;
+ case Z_DATA_ERROR:
+ if (outfile > 2) unlink(outname);
+ fprintf(stderr, "gun data error on %s: %s\n", inname, strm->msg);
+ break;
+ case Z_MEM_ERROR:
+ if (outfile > 2) unlink(outname);
+ fprintf(stderr, "gun out of memory error--aborting\n");
+ return 1;
+ case Z_BUF_ERROR:
+ if (outfile > 2) unlink(outname);
+ if (strm->next_in != Z_NULL) {
+ fprintf(stderr, "gun write error on %s: %s\n",
+ outname, strerror(errno));
+ }
+ else if (errno) {
+ fprintf(stderr, "gun read error on %s: %s\n",
+ inname, strerror(errno));
+ }
+ else {
+ fprintf(stderr, "gun unexpected end of file on %s\n",
+ inname);
+ }
+ break;
+ default:
+ if (outfile > 2) unlink(outname);
+ fprintf(stderr, "gun internal error--aborting\n");
+ return 1;
+ }
+ return 0;
+}
+
+/* Process the gun command line arguments. See the command syntax near the
+ beginning of this source file. */
+int main(int argc, char **argv)
+{
+ int ret, len, test;
+ char *outname;
+ unsigned char *window;
+ z_stream strm;
+
+ /* initialize inflateBack state for repeated use */
+ window = match; /* reuse LZW match buffer */
+ strm.zalloc = Z_NULL;
+ strm.zfree = Z_NULL;
+ strm.opaque = Z_NULL;
+ ret = inflateBackInit(&strm, 15, window);
+ if (ret != Z_OK) {
+ fprintf(stderr, "gun out of memory error--aborting\n");
+ return 1;
+ }
+
+ /* decompress each file to the same name with the suffix removed */
+ argc--;
+ argv++;
+ test = 0;
+ if (argc && strcmp(*argv, "-h") == 0) {
+ fprintf(stderr, "gun 1.6 (17 Jan 2010)\n");
+ fprintf(stderr, "Copyright (C) 2003-2010 Mark Adler\n");
+ fprintf(stderr, "usage: gun [-t] [file1.gz [file2.Z ...]]\n");
+ return 0;
+ }
+ if (argc && strcmp(*argv, "-t") == 0) {
+ test = 1;
+ argc--;
+ argv++;
+ }
+ if (argc)
+ do {
+ if (test)
+ outname = NULL;
+ else {
+ len = (int)strlen(*argv);
+ if (strcmp(*argv + len - 3, ".gz") == 0 ||
+ strcmp(*argv + len - 3, "-gz") == 0)
+ len -= 3;
+ else if (strcmp(*argv + len - 2, ".z") == 0 ||
+ strcmp(*argv + len - 2, "-z") == 0 ||
+ strcmp(*argv + len - 2, "_z") == 0 ||
+ strcmp(*argv + len - 2, ".Z") == 0)
+ len -= 2;
+ else {
+ fprintf(stderr, "gun error: no gz type on %s--skipping\n",
+ *argv);
+ continue;
+ }
+ outname = malloc(len + 1);
+ if (outname == NULL) {
+ fprintf(stderr, "gun out of memory error--aborting\n");
+ ret = 1;
+ break;
+ }
+ memcpy(outname, *argv, len);
+ outname[len] = 0;
+ }
+ ret = gunzip(&strm, *argv, outname, test);
+ if (outname != NULL) free(outname);
+ if (ret) break;
+ } while (argv++, --argc);
+ else
+ ret = gunzip(&strm, NULL, NULL, test);
+
+ /* clean up */
+ inflateBackEnd(&strm);
+ return ret;
+}
diff --git a/zlib/examples/gzappend.c b/zlib/examples/gzappend.c
new file mode 100644
index 000000000..662dec379
--- /dev/null
+++ b/zlib/examples/gzappend.c
@@ -0,0 +1,504 @@
+/* gzappend -- command to append to a gzip file
+
+ Copyright (C) 2003, 2012 Mark Adler, all rights reserved
+ version 1.2, 11 Oct 2012
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the author 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.
+
+ Mark Adler madler@alumni.caltech.edu
+ */
+
+/*
+ * Change history:
+ *
+ * 1.0 19 Oct 2003 - First version
+ * 1.1 4 Nov 2003 - Expand and clarify some comments and notes
+ * - Add version and copyright to help
+ * - Send help to stdout instead of stderr
+ * - Add some preemptive typecasts
+ * - Add L to constants in lseek() calls
+ * - Remove some debugging information in error messages
+ * - Use new data_type definition for zlib 1.2.1
+ * - Simplfy and unify file operations
+ * - Finish off gzip file in gztack()
+ * - Use deflatePrime() instead of adding empty blocks
+ * - Keep gzip file clean on appended file read errors
+ * - Use in-place rotate instead of auxiliary buffer
+ * (Why you ask? Because it was fun to write!)
+ * 1.2 11 Oct 2012 - Fix for proper z_const usage
+ * - Check for input buffer malloc failure
+ */
+
+/*
+ gzappend takes a gzip file and appends to it, compressing files from the
+ command line or data from stdin. The gzip file is written to directly, to
+ avoid copying that file, in case it's large. Note that this results in the
+ unfriendly behavior that if gzappend fails, the gzip file is corrupted.
+
+ This program was written to illustrate the use of the new Z_BLOCK option of
+ zlib 1.2.x's inflate() function. This option returns from inflate() at each
+ block boundary to facilitate locating and modifying the last block bit at
+ the start of the final deflate block. Also whether using Z_BLOCK or not,
+ another required feature of zlib 1.2.x is that inflate() now provides the
+ number of unusued bits in the last input byte used. gzappend will not work
+ with versions of zlib earlier than 1.2.1.
+
+ gzappend first decompresses the gzip file internally, discarding all but
+ the last 32K of uncompressed data, and noting the location of the last block
+ bit and the number of unused bits in the last byte of the compressed data.
+ The gzip trailer containing the CRC-32 and length of the uncompressed data
+ is verified. This trailer will be later overwritten.
+
+ Then the last block bit is cleared by seeking back in the file and rewriting
+ the byte that contains it. Seeking forward, the last byte of the compressed
+ data is saved along with the number of unused bits to initialize deflate.
+
+ A deflate process is initialized, using the last 32K of the uncompressed
+ data from the gzip file to initialize the dictionary. If the total
+ uncompressed data was less than 32K, then all of it is used to initialize
+ the dictionary. The deflate output bit buffer is also initialized with the
+ last bits from the original deflate stream. From here on, the data to
+ append is simply compressed using deflate, and written to the gzip file.
+ When that is complete, the new CRC-32 and uncompressed length are written
+ as the trailer of the gzip file.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include "zlib.h"
+
+#define local static
+#define LGCHUNK 14
+#define CHUNK (1U << LGCHUNK)
+#define DSIZE 32768U
+
+/* print an error message and terminate with extreme prejudice */
+local void bye(char *msg1, char *msg2)
+{
+ fprintf(stderr, "gzappend error: %s%s\n", msg1, msg2);
+ exit(1);
+}
+
+/* return the greatest common divisor of a and b using Euclid's algorithm,
+ modified to be fast when one argument much greater than the other, and
+ coded to avoid unnecessary swapping */
+local unsigned gcd(unsigned a, unsigned b)
+{
+ unsigned c;
+
+ while (a && b)
+ if (a > b) {
+ c = b;
+ while (a - c >= c)
+ c <<= 1;
+ a -= c;
+ }
+ else {
+ c = a;
+ while (b - c >= c)
+ c <<= 1;
+ b -= c;
+ }
+ return a + b;
+}
+
+/* rotate list[0..len-1] left by rot positions, in place */
+local void rotate(unsigned char *list, unsigned len, unsigned rot)
+{
+ unsigned char tmp;
+ unsigned cycles;
+ unsigned char *start, *last, *to, *from;
+
+ /* normalize rot and handle degenerate cases */
+ if (len < 2) return;
+ if (rot >= len) rot %= len;
+ if (rot == 0) return;
+
+ /* pointer to last entry in list */
+ last = list + (len - 1);
+
+ /* do simple left shift by one */
+ if (rot == 1) {
+ tmp = *list;
+ memcpy(list, list + 1, len - 1);
+ *last = tmp;
+ return;
+ }
+
+ /* do simple right shift by one */
+ if (rot == len - 1) {
+ tmp = *last;
+ memmove(list + 1, list, len - 1);
+ *list = tmp;
+ return;
+ }
+
+ /* otherwise do rotate as a set of cycles in place */
+ cycles = gcd(len, rot); /* number of cycles */
+ do {
+ start = from = list + cycles; /* start index is arbitrary */
+ tmp = *from; /* save entry to be overwritten */
+ for (;;) {
+ to = from; /* next step in cycle */
+ from += rot; /* go right rot positions */
+ if (from > last) from -= len; /* (pointer better not wrap) */
+ if (from == start) break; /* all but one shifted */
+ *to = *from; /* shift left */
+ }
+ *to = tmp; /* complete the circle */
+ } while (--cycles);
+}
+
+/* structure for gzip file read operations */
+typedef struct {
+ int fd; /* file descriptor */
+ int size; /* 1 << size is bytes in buf */
+ unsigned left; /* bytes available at next */
+ unsigned char *buf; /* buffer */
+ z_const unsigned char *next; /* next byte in buffer */
+ char *name; /* file name for error messages */
+} file;
+
+/* reload buffer */
+local int readin(file *in)
+{
+ int len;
+
+ len = read(in->fd, in->buf, 1 << in->size);
+ if (len == -1) bye("error reading ", in->name);
+ in->left = (unsigned)len;
+ in->next = in->buf;
+ return len;
+}
+
+/* read from file in, exit if end-of-file */
+local int readmore(file *in)
+{
+ if (readin(in) == 0) bye("unexpected end of ", in->name);
+ return 0;
+}
+
+#define read1(in) (in->left == 0 ? readmore(in) : 0, \
+ in->left--, *(in->next)++)
+
+/* skip over n bytes of in */
+local void skip(file *in, unsigned n)
+{
+ unsigned bypass;
+
+ if (n > in->left) {
+ n -= in->left;
+ bypass = n & ~((1U << in->size) - 1);
+ if (bypass) {
+ if (lseek(in->fd, (off_t)bypass, SEEK_CUR) == -1)
+ bye("seeking ", in->name);
+ n -= bypass;
+ }
+ readmore(in);
+ if (n > in->left)
+ bye("unexpected end of ", in->name);
+ }
+ in->left -= n;
+ in->next += n;
+}
+
+/* read a four-byte unsigned integer, little-endian, from in */
+unsigned long read4(file *in)
+{
+ unsigned long val;
+
+ val = read1(in);
+ val += (unsigned)read1(in) << 8;
+ val += (unsigned long)read1(in) << 16;
+ val += (unsigned long)read1(in) << 24;
+ return val;
+}
+
+/* skip over gzip header */
+local void gzheader(file *in)
+{
+ int flags;
+ unsigned n;
+
+ if (read1(in) != 31 || read1(in) != 139) bye(in->name, " not a gzip file");
+ if (read1(in) != 8) bye("unknown compression method in", in->name);
+ flags = read1(in);
+ if (flags & 0xe0) bye("unknown header flags set in", in->name);
+ skip(in, 6);
+ if (flags & 4) {
+ n = read1(in);
+ n += (unsigned)(read1(in)) << 8;
+ skip(in, n);
+ }
+ if (flags & 8) while (read1(in) != 0) ;
+ if (flags & 16) while (read1(in) != 0) ;
+ if (flags & 2) skip(in, 2);
+}
+
+/* decompress gzip file "name", return strm with a deflate stream ready to
+ continue compression of the data in the gzip file, and return a file
+ descriptor pointing to where to write the compressed data -- the deflate
+ stream is initialized to compress using level "level" */
+local int gzscan(char *name, z_stream *strm, int level)
+{
+ int ret, lastbit, left, full;
+ unsigned have;
+ unsigned long crc, tot;
+ unsigned char *window;
+ off_t lastoff, end;
+ file gz;
+
+ /* open gzip file */
+ gz.name = name;
+ gz.fd = open(name, O_RDWR, 0);
+ if (gz.fd == -1) bye("cannot open ", name);
+ gz.buf = malloc(CHUNK);
+ if (gz.buf == NULL) bye("out of memory", "");
+ gz.size = LGCHUNK;
+ gz.left = 0;
+
+ /* skip gzip header */
+ gzheader(&gz);
+
+ /* prepare to decompress */
+ window = malloc(DSIZE);
+ if (window == NULL) bye("out of memory", "");
+ strm->zalloc = Z_NULL;
+ strm->zfree = Z_NULL;
+ strm->opaque = Z_NULL;
+ ret = inflateInit2(strm, -15);
+ if (ret != Z_OK) bye("out of memory", " or library mismatch");
+
+ /* decompress the deflate stream, saving append information */
+ lastbit = 0;
+ lastoff = lseek(gz.fd, 0L, SEEK_CUR) - gz.left;
+ left = 0;
+ strm->avail_in = gz.left;
+ strm->next_in = gz.next;
+ crc = crc32(0L, Z_NULL, 0);
+ have = full = 0;
+ do {
+ /* if needed, get more input */
+ if (strm->avail_in == 0) {
+ readmore(&gz);
+ strm->avail_in = gz.left;
+ strm->next_in = gz.next;
+ }
+
+ /* set up output to next available section of sliding window */
+ strm->avail_out = DSIZE - have;
+ strm->next_out = window + have;
+
+ /* inflate and check for errors */
+ ret = inflate(strm, Z_BLOCK);
+ if (ret == Z_STREAM_ERROR) bye("internal stream error!", "");
+ if (ret == Z_MEM_ERROR) bye("out of memory", "");
+ if (ret == Z_DATA_ERROR)
+ bye("invalid compressed data--format violated in", name);
+
+ /* update crc and sliding window pointer */
+ crc = crc32(crc, window + have, DSIZE - have - strm->avail_out);
+ if (strm->avail_out)
+ have = DSIZE - strm->avail_out;
+ else {
+ have = 0;
+ full = 1;
+ }
+
+ /* process end of block */
+ if (strm->data_type & 128) {
+ if (strm->data_type & 64)
+ left = strm->data_type & 0x1f;
+ else {
+ lastbit = strm->data_type & 0x1f;
+ lastoff = lseek(gz.fd, 0L, SEEK_CUR) - strm->avail_in;
+ }
+ }
+ } while (ret != Z_STREAM_END);
+ inflateEnd(strm);
+ gz.left = strm->avail_in;
+ gz.next = strm->next_in;
+
+ /* save the location of the end of the compressed data */
+ end = lseek(gz.fd, 0L, SEEK_CUR) - gz.left;
+
+ /* check gzip trailer and save total for deflate */
+ if (crc != read4(&gz))
+ bye("invalid compressed data--crc mismatch in ", name);
+ tot = strm->total_out;
+ if ((tot & 0xffffffffUL) != read4(&gz))
+ bye("invalid compressed data--length mismatch in", name);
+
+ /* if not at end of file, warn */
+ if (gz.left || readin(&gz))
+ fprintf(stderr,
+ "gzappend warning: junk at end of gzip file overwritten\n");
+
+ /* clear last block bit */
+ lseek(gz.fd, lastoff - (lastbit != 0), SEEK_SET);
+ if (read(gz.fd, gz.buf, 1) != 1) bye("reading after seek on ", name);
+ *gz.buf = (unsigned char)(*gz.buf ^ (1 << ((8 - lastbit) & 7)));
+ lseek(gz.fd, -1L, SEEK_CUR);
+ if (write(gz.fd, gz.buf, 1) != 1) bye("writing after seek to ", name);
+
+ /* if window wrapped, build dictionary from window by rotating */
+ if (full) {
+ rotate(window, DSIZE, have);
+ have = DSIZE;
+ }
+
+ /* set up deflate stream with window, crc, total_in, and leftover bits */
+ ret = deflateInit2(strm, level, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY);
+ if (ret != Z_OK) bye("out of memory", "");
+ deflateSetDictionary(strm, window, have);
+ strm->adler = crc;
+ strm->total_in = tot;
+ if (left) {
+ lseek(gz.fd, --end, SEEK_SET);
+ if (read(gz.fd, gz.buf, 1) != 1) bye("reading after seek on ", name);
+ deflatePrime(strm, 8 - left, *gz.buf);
+ }
+ lseek(gz.fd, end, SEEK_SET);
+
+ /* clean up and return */
+ free(window);
+ free(gz.buf);
+ return gz.fd;
+}
+
+/* append file "name" to gzip file gd using deflate stream strm -- if last
+ is true, then finish off the deflate stream at the end */
+local void gztack(char *name, int gd, z_stream *strm, int last)
+{
+ int fd, len, ret;
+ unsigned left;
+ unsigned char *in, *out;
+
+ /* open file to compress and append */
+ fd = 0;
+ if (name != NULL) {
+ fd = open(name, O_RDONLY, 0);
+ if (fd == -1)
+ fprintf(stderr, "gzappend warning: %s not found, skipping ...\n",
+ name);
+ }
+
+ /* allocate buffers */
+ in = malloc(CHUNK);
+ out = malloc(CHUNK);
+ if (in == NULL || out == NULL) bye("out of memory", "");
+
+ /* compress input file and append to gzip file */
+ do {
+ /* get more input */
+ len = read(fd, in, CHUNK);
+ if (len == -1) {
+ fprintf(stderr,
+ "gzappend warning: error reading %s, skipping rest ...\n",
+ name);
+ len = 0;
+ }
+ strm->avail_in = (unsigned)len;
+ strm->next_in = in;
+ if (len) strm->adler = crc32(strm->adler, in, (unsigned)len);
+
+ /* compress and write all available output */
+ do {
+ strm->avail_out = CHUNK;
+ strm->next_out = out;
+ ret = deflate(strm, last && len == 0 ? Z_FINISH : Z_NO_FLUSH);
+ left = CHUNK - strm->avail_out;
+ while (left) {
+ len = write(gd, out + CHUNK - strm->avail_out - left, left);
+ if (len == -1) bye("writing gzip file", "");
+ left -= (unsigned)len;
+ }
+ } while (strm->avail_out == 0 && ret != Z_STREAM_END);
+ } while (len != 0);
+
+ /* write trailer after last entry */
+ if (last) {
+ deflateEnd(strm);
+ out[0] = (unsigned char)(strm->adler);
+ out[1] = (unsigned char)(strm->adler >> 8);
+ out[2] = (unsigned char)(strm->adler >> 16);
+ out[3] = (unsigned char)(strm->adler >> 24);
+ out[4] = (unsigned char)(strm->total_in);
+ out[5] = (unsigned char)(strm->total_in >> 8);
+ out[6] = (unsigned char)(strm->total_in >> 16);
+ out[7] = (unsigned char)(strm->total_in >> 24);
+ len = 8;
+ do {
+ ret = write(gd, out + 8 - len, len);
+ if (ret == -1) bye("writing gzip file", "");
+ len -= ret;
+ } while (len);
+ close(gd);
+ }
+
+ /* clean up and return */
+ free(out);
+ free(in);
+ if (fd > 0) close(fd);
+}
+
+/* process the compression level option if present, scan the gzip file, and
+ append the specified files, or append the data from stdin if no other file
+ names are provided on the command line -- the gzip file must be writable
+ and seekable */
+int main(int argc, char **argv)
+{
+ int gd, level;
+ z_stream strm;
+
+ /* ignore command name */
+ argc--; argv++;
+
+ /* provide usage if no arguments */
+ if (*argv == NULL) {
+ printf(
+ "gzappend 1.2 (11 Oct 2012) Copyright (C) 2003, 2012 Mark Adler\n"
+ );
+ printf(
+ "usage: gzappend [-level] file.gz [ addthis [ andthis ... ]]\n");
+ return 0;
+ }
+
+ /* set compression level */
+ level = Z_DEFAULT_COMPRESSION;
+ if (argv[0][0] == '-') {
+ if (argv[0][1] < '0' || argv[0][1] > '9' || argv[0][2] != 0)
+ bye("invalid compression level", "");
+ level = argv[0][1] - '0';
+ if (*++argv == NULL) bye("no gzip file name after options", "");
+ }
+
+ /* prepare to append to gzip file */
+ gd = gzscan(*argv++, &strm, level);
+
+ /* append files on command line, or from stdin if none */
+ if (*argv == NULL)
+ gztack(NULL, gd, &strm, 1);
+ else
+ do {
+ gztack(*argv, gd, &strm, argv[1] == NULL);
+ } while (*++argv != NULL);
+ return 0;
+}
diff --git a/zlib/examples/gzjoin.c b/zlib/examples/gzjoin.c
new file mode 100644
index 000000000..89e809844
--- /dev/null
+++ b/zlib/examples/gzjoin.c
@@ -0,0 +1,449 @@
+/* gzjoin -- command to join gzip files into one gzip file
+
+ Copyright (C) 2004, 2005, 2012 Mark Adler, all rights reserved
+ version 1.2, 14 Aug 2012
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the author 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.
+
+ Mark Adler madler@alumni.caltech.edu
+ */
+
+/*
+ * Change history:
+ *
+ * 1.0 11 Dec 2004 - First version
+ * 1.1 12 Jun 2005 - Changed ssize_t to long for portability
+ * 1.2 14 Aug 2012 - Clean up for z_const usage
+ */
+
+/*
+ gzjoin takes one or more gzip files on the command line and writes out a
+ single gzip file that will uncompress to the concatenation of the
+ uncompressed data from the individual gzip files. gzjoin does this without
+ having to recompress any of the data and without having to calculate a new
+ crc32 for the concatenated uncompressed data. gzjoin does however have to
+ decompress all of the input data in order to find the bits in the compressed
+ data that need to be modified to concatenate the streams.
+
+ gzjoin does not do an integrity check on the input gzip files other than
+ checking the gzip header and decompressing the compressed data. They are
+ otherwise assumed to be complete and correct.
+
+ Each joint between gzip files removes at least 18 bytes of previous trailer
+ and subsequent header, and inserts an average of about three bytes to the
+ compressed data in order to connect the streams. The output gzip file
+ has a minimal ten-byte gzip header with no file name or modification time.
+
+ This program was written to illustrate the use of the Z_BLOCK option of
+ inflate() and the crc32_combine() function. gzjoin will not compile with
+ versions of zlib earlier than 1.2.3.
+ */
+
+#include <stdio.h> /* fputs(), fprintf(), fwrite(), putc() */
+#include <stdlib.h> /* exit(), malloc(), free() */
+#include <fcntl.h> /* open() */
+#include <unistd.h> /* close(), read(), lseek() */
+#include "zlib.h"
+ /* crc32(), crc32_combine(), inflateInit2(), inflate(), inflateEnd() */
+
+#define local static
+
+/* exit with an error (return a value to allow use in an expression) */
+local int bail(char *why1, char *why2)
+{
+ fprintf(stderr, "gzjoin error: %s%s, output incomplete\n", why1, why2);
+ exit(1);
+ return 0;
+}
+
+/* -- simple buffered file input with access to the buffer -- */
+
+#define CHUNK 32768 /* must be a power of two and fit in unsigned */
+
+/* bin buffered input file type */
+typedef struct {
+ char *name; /* name of file for error messages */
+ int fd; /* file descriptor */
+ unsigned left; /* bytes remaining at next */
+ unsigned char *next; /* next byte to read */
+ unsigned char *buf; /* allocated buffer of length CHUNK */
+} bin;
+
+/* close a buffered file and free allocated memory */
+local void bclose(bin *in)
+{
+ if (in != NULL) {
+ if (in->fd != -1)
+ close(in->fd);
+ if (in->buf != NULL)
+ free(in->buf);
+ free(in);
+ }
+}
+
+/* open a buffered file for input, return a pointer to type bin, or NULL on
+ failure */
+local bin *bopen(char *name)
+{
+ bin *in;
+
+ in = malloc(sizeof(bin));
+ if (in == NULL)
+ return NULL;
+ in->buf = malloc(CHUNK);
+ in->fd = open(name, O_RDONLY, 0);
+ if (in->buf == NULL || in->fd == -1) {
+ bclose(in);
+ return NULL;
+ }
+ in->left = 0;
+ in->next = in->buf;
+ in->name = name;
+ return in;
+}
+
+/* load buffer from file, return -1 on read error, 0 or 1 on success, with
+ 1 indicating that end-of-file was reached */
+local int bload(bin *in)
+{
+ long len;
+
+ if (in == NULL)
+ return -1;
+ if (in->left != 0)
+ return 0;
+ in->next = in->buf;
+ do {
+ len = (long)read(in->fd, in->buf + in->left, CHUNK - in->left);
+ if (len < 0)
+ return -1;
+ in->left += (unsigned)len;
+ } while (len != 0 && in->left < CHUNK);
+ return len == 0 ? 1 : 0;
+}
+
+/* get a byte from the file, bail if end of file */
+#define bget(in) (in->left ? 0 : bload(in), \
+ in->left ? (in->left--, *(in->next)++) : \
+ bail("unexpected end of file on ", in->name))
+
+/* get a four-byte little-endian unsigned integer from file */
+local unsigned long bget4(bin *in)
+{
+ unsigned long val;
+
+ val = bget(in);
+ val += (unsigned long)(bget(in)) << 8;
+ val += (unsigned long)(bget(in)) << 16;
+ val += (unsigned long)(bget(in)) << 24;
+ return val;
+}
+
+/* skip bytes in file */
+local void bskip(bin *in, unsigned skip)
+{
+ /* check pointer */
+ if (in == NULL)
+ return;
+
+ /* easy case -- skip bytes in buffer */
+ if (skip <= in->left) {
+ in->left -= skip;
+ in->next += skip;
+ return;
+ }
+
+ /* skip what's in buffer, discard buffer contents */
+ skip -= in->left;
+ in->left = 0;
+
+ /* seek past multiples of CHUNK bytes */
+ if (skip > CHUNK) {
+ unsigned left;
+
+ left = skip & (CHUNK - 1);
+ if (left == 0) {
+ /* exact number of chunks: seek all the way minus one byte to check
+ for end-of-file with a read */
+ lseek(in->fd, skip - 1, SEEK_CUR);
+ if (read(in->fd, in->buf, 1) != 1)
+ bail("unexpected end of file on ", in->name);
+ return;
+ }
+
+ /* skip the integral chunks, update skip with remainder */
+ lseek(in->fd, skip - left, SEEK_CUR);
+ skip = left;
+ }
+
+ /* read more input and skip remainder */
+ bload(in);
+ if (skip > in->left)
+ bail("unexpected end of file on ", in->name);
+ in->left -= skip;
+ in->next += skip;
+}
+
+/* -- end of buffered input functions -- */
+
+/* skip the gzip header from file in */
+local void gzhead(bin *in)
+{
+ int flags;
+
+ /* verify gzip magic header and compression method */
+ if (bget(in) != 0x1f || bget(in) != 0x8b || bget(in) != 8)
+ bail(in->name, " is not a valid gzip file");
+
+ /* get and verify flags */
+ flags = bget(in);
+ if ((flags & 0xe0) != 0)
+ bail("unknown reserved bits set in ", in->name);
+
+ /* skip modification time, extra flags, and os */
+ bskip(in, 6);
+
+ /* skip extra field if present */
+ if (flags & 4) {
+ unsigned len;
+
+ len = bget(in);
+ len += (unsigned)(bget(in)) << 8;
+ bskip(in, len);
+ }
+
+ /* skip file name if present */
+ if (flags & 8)
+ while (bget(in) != 0)
+ ;
+
+ /* skip comment if present */
+ if (flags & 16)
+ while (bget(in) != 0)
+ ;
+
+ /* skip header crc if present */
+ if (flags & 2)
+ bskip(in, 2);
+}
+
+/* write a four-byte little-endian unsigned integer to out */
+local void put4(unsigned long val, FILE *out)
+{
+ putc(val & 0xff, out);
+ putc((val >> 8) & 0xff, out);
+ putc((val >> 16) & 0xff, out);
+ putc((val >> 24) & 0xff, out);
+}
+
+/* Load up zlib stream from buffered input, bail if end of file */
+local void zpull(z_streamp strm, bin *in)
+{
+ if (in->left == 0)
+ bload(in);
+ if (in->left == 0)
+ bail("unexpected end of file on ", in->name);
+ strm->avail_in = in->left;
+ strm->next_in = in->next;
+}
+
+/* Write header for gzip file to out and initialize trailer. */
+local void gzinit(unsigned long *crc, unsigned long *tot, FILE *out)
+{
+ fwrite("\x1f\x8b\x08\0\0\0\0\0\0\xff", 1, 10, out);
+ *crc = crc32(0L, Z_NULL, 0);
+ *tot = 0;
+}
+
+/* Copy the compressed data from name, zeroing the last block bit of the last
+ block if clr is true, and adding empty blocks as needed to get to a byte
+ boundary. If clr is false, then the last block becomes the last block of
+ the output, and the gzip trailer is written. crc and tot maintains the
+ crc and length (modulo 2^32) of the output for the trailer. The resulting
+ gzip file is written to out. gzinit() must be called before the first call
+ of gzcopy() to write the gzip header and to initialize crc and tot. */
+local void gzcopy(char *name, int clr, unsigned long *crc, unsigned long *tot,
+ FILE *out)
+{
+ int ret; /* return value from zlib functions */
+ int pos; /* where the "last block" bit is in byte */
+ int last; /* true if processing the last block */
+ bin *in; /* buffered input file */
+ unsigned char *start; /* start of compressed data in buffer */
+ unsigned char *junk; /* buffer for uncompressed data -- discarded */
+ z_off_t len; /* length of uncompressed data (support > 4 GB) */
+ z_stream strm; /* zlib inflate stream */
+
+ /* open gzip file and skip header */
+ in = bopen(name);
+ if (in == NULL)
+ bail("could not open ", name);
+ gzhead(in);
+
+ /* allocate buffer for uncompressed data and initialize raw inflate
+ stream */
+ junk = malloc(CHUNK);
+ strm.zalloc = Z_NULL;
+ strm.zfree = Z_NULL;
+ strm.opaque = Z_NULL;
+ strm.avail_in = 0;
+ strm.next_in = Z_NULL;
+ ret = inflateInit2(&strm, -15);
+ if (junk == NULL || ret != Z_OK)
+ bail("out of memory", "");
+
+ /* inflate and copy compressed data, clear last-block bit if requested */
+ len = 0;
+ zpull(&strm, in);
+ start = in->next;
+ last = start[0] & 1;
+ if (last && clr)
+ start[0] &= ~1;
+ strm.avail_out = 0;
+ for (;;) {
+ /* if input used and output done, write used input and get more */
+ if (strm.avail_in == 0 && strm.avail_out != 0) {
+ fwrite(start, 1, strm.next_in - start, out);
+ start = in->buf;
+ in->left = 0;
+ zpull(&strm, in);
+ }
+
+ /* decompress -- return early when end-of-block reached */
+ strm.avail_out = CHUNK;
+ strm.next_out = junk;
+ ret = inflate(&strm, Z_BLOCK);
+ switch (ret) {
+ case Z_MEM_ERROR:
+ bail("out of memory", "");
+ case Z_DATA_ERROR:
+ bail("invalid compressed data in ", in->name);
+ }
+
+ /* update length of uncompressed data */
+ len += CHUNK - strm.avail_out;
+
+ /* check for block boundary (only get this when block copied out) */
+ if (strm.data_type & 128) {
+ /* if that was the last block, then done */
+ if (last)
+ break;
+
+ /* number of unused bits in last byte */
+ pos = strm.data_type & 7;
+
+ /* find the next last-block bit */
+ if (pos != 0) {
+ /* next last-block bit is in last used byte */
+ pos = 0x100 >> pos;
+ last = strm.next_in[-1] & pos;
+ if (last && clr)
+ in->buf[strm.next_in - in->buf - 1] &= ~pos;
+ }
+ else {
+ /* next last-block bit is in next unused byte */
+ if (strm.avail_in == 0) {
+ /* don't have that byte yet -- get it */
+ fwrite(start, 1, strm.next_in - start, out);
+ start = in->buf;
+ in->left = 0;
+ zpull(&strm, in);
+ }
+ last = strm.next_in[0] & 1;
+ if (last && clr)
+ in->buf[strm.next_in - in->buf] &= ~1;
+ }
+ }
+ }
+
+ /* update buffer with unused input */
+ in->left = strm.avail_in;
+ in->next = in->buf + (strm.next_in - in->buf);
+
+ /* copy used input, write empty blocks to get to byte boundary */
+ pos = strm.data_type & 7;
+ fwrite(start, 1, in->next - start - 1, out);
+ last = in->next[-1];
+ if (pos == 0 || !clr)
+ /* already at byte boundary, or last file: write last byte */
+ putc(last, out);
+ else {
+ /* append empty blocks to last byte */
+ last &= ((0x100 >> pos) - 1); /* assure unused bits are zero */
+ if (pos & 1) {
+ /* odd -- append an empty stored block */
+ putc(last, out);
+ if (pos == 1)
+ putc(0, out); /* two more bits in block header */
+ fwrite("\0\0\xff\xff", 1, 4, out);
+ }
+ else {
+ /* even -- append 1, 2, or 3 empty fixed blocks */
+ switch (pos) {
+ case 6:
+ putc(last | 8, out);
+ last = 0;
+ case 4:
+ putc(last | 0x20, out);
+ last = 0;
+ case 2:
+ putc(last | 0x80, out);
+ putc(0, out);
+ }
+ }
+ }
+
+ /* update crc and tot */
+ *crc = crc32_combine(*crc, bget4(in), len);
+ *tot += (unsigned long)len;
+
+ /* clean up */
+ inflateEnd(&strm);
+ free(junk);
+ bclose(in);
+
+ /* write trailer if this is the last gzip file */
+ if (!clr) {
+ put4(*crc, out);
+ put4(*tot, out);
+ }
+}
+
+/* join the gzip files on the command line, write result to stdout */
+int main(int argc, char **argv)
+{
+ unsigned long crc, tot; /* running crc and total uncompressed length */
+
+ /* skip command name */
+ argc--;
+ argv++;
+
+ /* show usage if no arguments */
+ if (argc == 0) {
+ fputs("gzjoin usage: gzjoin f1.gz [f2.gz [f3.gz ...]] > fjoin.gz\n",
+ stderr);
+ return 0;
+ }
+
+ /* join gzip files on command line and write to stdout */
+ gzinit(&crc, &tot, stdout);
+ while (argc--)
+ gzcopy(*argv++, argc, &crc, &tot, stdout);
+
+ /* done */
+ return 0;
+}
diff --git a/zlib/examples/gzlog.c b/zlib/examples/gzlog.c
new file mode 100644
index 000000000..b8c29274e
--- /dev/null
+++ b/zlib/examples/gzlog.c
@@ -0,0 +1,1059 @@
+/*
+ * gzlog.c
+ * Copyright (C) 2004, 2008, 2012, 2016 Mark Adler, all rights reserved
+ * For conditions of distribution and use, see copyright notice in gzlog.h
+ * version 2.2, 14 Aug 2012
+ */
+
+/*
+ gzlog provides a mechanism for frequently appending short strings to a gzip
+ file that is efficient both in execution time and compression ratio. The
+ strategy is to write the short strings in an uncompressed form to the end of
+ the gzip file, only compressing when the amount of uncompressed data has
+ reached a given threshold.
+
+ gzlog also provides protection against interruptions in the process due to
+ system crashes. The status of the operation is recorded in an extra field
+ in the gzip file, and is only updated once the gzip file is brought to a
+ valid state. The last data to be appended or compressed is saved in an
+ auxiliary file, so that if the operation is interrupted, it can be completed
+ the next time an append operation is attempted.
+
+ gzlog maintains another auxiliary file with the last 32K of data from the
+ compressed portion, which is preloaded for the compression of the subsequent
+ data. This minimizes the impact to the compression ratio of appending.
+ */
+
+/*
+ Operations Concept:
+
+ Files (log name "foo"):
+ foo.gz -- gzip file with the complete log
+ foo.add -- last message to append or last data to compress
+ foo.dict -- dictionary of the last 32K of data for next compression
+ foo.temp -- temporary dictionary file for compression after this one
+ foo.lock -- lock file for reading and writing the other files
+ foo.repairs -- log file for log file recovery operations (not compressed)
+
+ gzip file structure:
+ - fixed-length (no file name) header with extra field (see below)
+ - compressed data ending initially with empty stored block
+ - uncompressed data filling out originally empty stored block and
+ subsequent stored blocks as needed (16K max each)
+ - gzip trailer
+ - no junk at end (no other gzip streams)
+
+ When appending data, the information in the first three items above plus the
+ foo.add file are sufficient to recover an interrupted append operation. The
+ extra field has the necessary information to restore the start of the last
+ stored block and determine where to append the data in the foo.add file, as
+ well as the crc and length of the gzip data before the append operation.
+
+ The foo.add file is created before the gzip file is marked for append, and
+ deleted after the gzip file is marked as complete. So if the append
+ operation is interrupted, the data to add will still be there. If due to
+ some external force, the foo.add file gets deleted between when the append
+ operation was interrupted and when recovery is attempted, the gzip file will
+ still be restored, but without the appended data.
+
+ When compressing data, the information in the first two items above plus the
+ foo.add file are sufficient to recover an interrupted compress operation.
+ The extra field has the necessary information to find the end of the
+ compressed data, and contains both the crc and length of just the compressed
+ data and of the complete set of data including the contents of the foo.add
+ file.
+
+ Again, the foo.add file is maintained during the compress operation in case
+ of an interruption. If in the unlikely event the foo.add file with the data
+ to be compressed is missing due to some external force, a gzip file with
+ just the previous compressed data will be reconstructed. In this case, all
+ of the data that was to be compressed is lost (approximately one megabyte).
+ This will not occur if all that happened was an interruption of the compress
+ operation.
+
+ The third state that is marked is the replacement of the old dictionary with
+ the new dictionary after a compress operation. Once compression is
+ complete, the gzip file is marked as being in the replace state. This
+ completes the gzip file, so an interrupt after being so marked does not
+ result in recompression. Then the dictionary file is replaced, and the gzip
+ file is marked as completed. This state prevents the possibility of
+ restarting compression with the wrong dictionary file.
+
+ All three operations are wrapped by a lock/unlock procedure. In order to
+ gain exclusive access to the log files, first a foo.lock file must be
+ exclusively created. When all operations are complete, the lock is
+ released by deleting the foo.lock file. If when attempting to create the
+ lock file, it already exists and the modify time of the lock file is more
+ than five minutes old (set by the PATIENCE define below), then the old
+ lock file is considered stale and deleted, and the exclusive creation of
+ the lock file is retried. To assure that there are no false assessments
+ of the staleness of the lock file, the operations periodically touch the
+ lock file to update the modified date.
+
+ Following is the definition of the extra field with all of the information
+ required to enable the above append and compress operations and their
+ recovery if interrupted. Multi-byte values are stored little endian
+ (consistent with the gzip format). File pointers are eight bytes long.
+ The crc's and lengths for the gzip trailer are four bytes long. (Note that
+ the length at the end of a gzip file is used for error checking only, and
+ for large files is actually the length modulo 2^32.) The stored block
+ length is two bytes long. The gzip extra field two-byte identification is
+ "ap" for append. It is assumed that writing the extra field to the file is
+ an "atomic" operation. That is, either all of the extra field is written
+ to the file, or none of it is, if the operation is interrupted right at the
+ point of updating the extra field. This is a reasonable assumption, since
+ the extra field is within the first 52 bytes of the file, which is smaller
+ than any expected block size for a mass storage device (usually 512 bytes or
+ larger).
+
+ Extra field (35 bytes):
+ - Pointer to first stored block length -- this points to the two-byte length
+ of the first stored block, which is followed by the two-byte, one's
+ complement of that length. The stored block length is preceded by the
+ three-bit header of the stored block, which is the actual start of the
+ stored block in the deflate format. See the bit offset field below.
+ - Pointer to the last stored block length. This is the same as above, but
+ for the last stored block of the uncompressed data in the gzip file.
+ Initially this is the same as the first stored block length pointer.
+ When the stored block gets to 16K (see the MAX_STORE define), then a new
+ stored block as added, at which point the last stored block length pointer
+ is different from the first stored block length pointer. When they are
+ different, the first bit of the last stored block header is eight bits, or
+ one byte back from the block length.
+ - Compressed data crc and length. This is the crc and length of the data
+ that is in the compressed portion of the deflate stream. These are used
+ only in the event that the foo.add file containing the data to compress is
+ lost after a compress operation is interrupted.
+ - Total data crc and length. This is the crc and length of all of the data
+ stored in the gzip file, compressed and uncompressed. It is used to
+ reconstruct the gzip trailer when compressing, as well as when recovering
+ interrupted operations.
+ - Final stored block length. This is used to quickly find where to append,
+ and allows the restoration of the original final stored block state when
+ an append operation is interrupted.
+ - First stored block start as the number of bits back from the final stored
+ block first length byte. This value is in the range of 3..10, and is
+ stored as the low three bits of the final byte of the extra field after
+ subtracting three (0..7). This allows the last-block bit of the stored
+ block header to be updated when a new stored block is added, for the case
+ when the first stored block and the last stored block are the same. (When
+ they are different, the numbers of bits back is known to be eight.) This
+ also allows for new compressed data to be appended to the old compressed
+ data in the compress operation, overwriting the previous first stored
+ block, or for the compressed data to be terminated and a valid gzip file
+ reconstructed on the off chance that a compression operation was
+ interrupted and the data to compress in the foo.add file was deleted.
+ - The operation in process. This is the next two bits in the last byte (the
+ bits under the mask 0x18). The are interpreted as 0: nothing in process,
+ 1: append in process, 2: compress in process, 3: replace in process.
+ - The top three bits of the last byte in the extra field are reserved and
+ are currently set to zero.
+
+ Main procedure:
+ - Exclusively create the foo.lock file using the O_CREAT and O_EXCL modes of
+ the system open() call. If the modify time of an existing lock file is
+ more than PATIENCE seconds old, then the lock file is deleted and the
+ exclusive create is retried.
+ - Load the extra field from the foo.gz file, and see if an operation was in
+ progress but not completed. If so, apply the recovery procedure below.
+ - Perform the append procedure with the provided data.
+ - If the uncompressed data in the foo.gz file is 1MB or more, apply the
+ compress procedure.
+ - Delete the foo.lock file.
+
+ Append procedure:
+ - Put what to append in the foo.add file so that the operation can be
+ restarted if this procedure is interrupted.
+ - Mark the foo.gz extra field with the append operation in progress.
+ + Restore the original last-block bit and stored block length of the last
+ stored block from the information in the extra field, in case a previous
+ append operation was interrupted.
+ - Append the provided data to the last stored block, creating new stored
+ blocks as needed and updating the stored blocks last-block bits and
+ lengths.
+ - Update the crc and length with the new data, and write the gzip trailer.
+ - Write over the extra field (with a single write operation) with the new
+ pointers, lengths, and crc's, and mark the gzip file as not in process.
+ Though there is still a foo.add file, it will be ignored since nothing
+ is in process. If a foo.add file is leftover from a previously
+ completed operation, it is truncated when writing new data to it.
+ - Delete the foo.add file.
+
+ Compress and replace procedures:
+ - Read all of the uncompressed data in the stored blocks in foo.gz and write
+ it to foo.add. Also write foo.temp with the last 32K of that data to
+ provide a dictionary for the next invocation of this procedure.
+ - Rewrite the extra field marking foo.gz with a compression in process.
+ * If there is no data provided to compress (due to a missing foo.add file
+ when recovering), reconstruct and truncate the foo.gz file to contain
+ only the previous compressed data and proceed to the step after the next
+ one. Otherwise ...
+ - Compress the data with the dictionary in foo.dict, and write to the
+ foo.gz file starting at the bit immediately following the last previously
+ compressed block. If there is no foo.dict, proceed anyway with the
+ compression at slightly reduced efficiency. (For the foo.dict file to be
+ missing requires some external failure beyond simply the interruption of
+ a compress operation.) During this process, the foo.lock file is
+ periodically touched to assure that that file is not considered stale by
+ another process before we're done. The deflation is terminated with a
+ non-last empty static block (10 bits long), that is then located and
+ written over by a last-bit-set empty stored block.
+ - Append the crc and length of the data in the gzip file (previously
+ calculated during the append operations).
+ - Write over the extra field with the updated stored block offsets, bits
+ back, crc's, and lengths, and mark foo.gz as in process for a replacement
+ of the dictionary.
+ @ Delete the foo.add file.
+ - Replace foo.dict with foo.temp.
+ - Write over the extra field, marking foo.gz as complete.
+
+ Recovery procedure:
+ - If not a replace recovery, read in the foo.add file, and provide that data
+ to the appropriate recovery below. If there is no foo.add file, provide
+ a zero data length to the recovery. In that case, the append recovery
+ restores the foo.gz to the previous compressed + uncompressed data state.
+ For the the compress recovery, a missing foo.add file results in foo.gz
+ being restored to the previous compressed-only data state.
+ - Append recovery:
+ - Pick up append at + step above
+ - Compress recovery:
+ - Pick up compress at * step above
+ - Replace recovery:
+ - Pick up compress at @ step above
+ - Log the repair with a date stamp in foo.repairs
+ */
+
+#include <sys/types.h>
+#include <stdio.h> /* rename, fopen, fprintf, fclose */
+#include <stdlib.h> /* malloc, free */
+#include <string.h> /* strlen, strrchr, strcpy, strncpy, strcmp */
+#include <fcntl.h> /* open */
+#include <unistd.h> /* lseek, read, write, close, unlink, sleep, */
+ /* ftruncate, fsync */
+#include <errno.h> /* errno */
+#include <time.h> /* time, ctime */
+#include <sys/stat.h> /* stat */
+#include <sys/time.h> /* utimes */
+#include "zlib.h" /* crc32 */
+
+#include "gzlog.h" /* header for external access */
+
+#define local static
+typedef unsigned int uint;
+typedef unsigned long ulong;
+
+/* Macro for debugging to deterministically force recovery operations */
+#ifdef GZLOG_DEBUG
+ #include <setjmp.h> /* longjmp */
+ jmp_buf gzlog_jump; /* where to go back to */
+ int gzlog_bail = 0; /* which point to bail at (1..8) */
+ int gzlog_count = -1; /* number of times through to wait */
+# define BAIL(n) do { if (n == gzlog_bail && gzlog_count-- == 0) \
+ longjmp(gzlog_jump, gzlog_bail); } while (0)
+#else
+# define BAIL(n)
+#endif
+
+/* how old the lock file can be in seconds before considering it stale */
+#define PATIENCE 300
+
+/* maximum stored block size in Kbytes -- must be in 1..63 */
+#define MAX_STORE 16
+
+/* number of stored Kbytes to trigger compression (must be >= 32 to allow
+ dictionary construction, and <= 204 * MAX_STORE, in order for >> 10 to
+ discard the stored block headers contribution of five bytes each) */
+#define TRIGGER 1024
+
+/* size of a deflate dictionary (this cannot be changed) */
+#define DICT 32768U
+
+/* values for the operation (2 bits) */
+#define NO_OP 0
+#define APPEND_OP 1
+#define COMPRESS_OP 2
+#define REPLACE_OP 3
+
+/* macros to extract little-endian integers from an unsigned byte buffer */
+#define PULL2(p) ((p)[0]+((uint)((p)[1])<<8))
+#define PULL4(p) (PULL2(p)+((ulong)PULL2(p+2)<<16))
+#define PULL8(p) (PULL4(p)+((off_t)PULL4(p+4)<<32))
+
+/* macros to store integers into a byte buffer in little-endian order */
+#define PUT2(p,a) do {(p)[0]=a;(p)[1]=(a)>>8;} while(0)
+#define PUT4(p,a) do {PUT2(p,a);PUT2(p+2,a>>16);} while(0)
+#define PUT8(p,a) do {PUT4(p,a);PUT4(p+4,a>>32);} while(0)
+
+/* internal structure for log information */
+#define LOGID "\106\035\172" /* should be three non-zero characters */
+struct log {
+ char id[4]; /* contains LOGID to detect inadvertent overwrites */
+ int fd; /* file descriptor for .gz file, opened read/write */
+ char *path; /* allocated path, e.g. "/var/log/foo" or "foo" */
+ char *end; /* end of path, for appending suffices such as ".gz" */
+ off_t first; /* offset of first stored block first length byte */
+ int back; /* location of first block id in bits back from first */
+ uint stored; /* bytes currently in last stored block */
+ off_t last; /* offset of last stored block first length byte */
+ ulong ccrc; /* crc of compressed data */
+ ulong clen; /* length (modulo 2^32) of compressed data */
+ ulong tcrc; /* crc of total data */
+ ulong tlen; /* length (modulo 2^32) of total data */
+ time_t lock; /* last modify time of our lock file */
+};
+
+/* gzip header for gzlog */
+local unsigned char log_gzhead[] = {
+ 0x1f, 0x8b, /* magic gzip id */
+ 8, /* compression method is deflate */
+ 4, /* there is an extra field (no file name) */
+ 0, 0, 0, 0, /* no modification time provided */
+ 0, 0xff, /* no extra flags, no OS specified */
+ 39, 0, 'a', 'p', 35, 0 /* extra field with "ap" subfield */
+ /* 35 is EXTRA, 39 is EXTRA + 4 */
+};
+
+#define HEAD sizeof(log_gzhead) /* should be 16 */
+
+/* initial gzip extra field content (52 == HEAD + EXTRA + 1) */
+local unsigned char log_gzext[] = {
+ 52, 0, 0, 0, 0, 0, 0, 0, /* offset of first stored block length */
+ 52, 0, 0, 0, 0, 0, 0, 0, /* offset of last stored block length */
+ 0, 0, 0, 0, 0, 0, 0, 0, /* compressed data crc and length */
+ 0, 0, 0, 0, 0, 0, 0, 0, /* total data crc and length */
+ 0, 0, /* final stored block data length */
+ 5 /* op is NO_OP, last bit 8 bits back */
+};
+
+#define EXTRA sizeof(log_gzext) /* should be 35 */
+
+/* initial gzip data and trailer */
+local unsigned char log_gzbody[] = {
+ 1, 0, 0, 0xff, 0xff, /* empty stored block (last) */
+ 0, 0, 0, 0, /* crc */
+ 0, 0, 0, 0 /* uncompressed length */
+};
+
+#define BODY sizeof(log_gzbody)
+
+/* Exclusively create foo.lock in order to negotiate exclusive access to the
+ foo.* files. If the modify time of an existing lock file is greater than
+ PATIENCE seconds in the past, then consider the lock file to have been
+ abandoned, delete it, and try the exclusive create again. Save the lock
+ file modify time for verification of ownership. Return 0 on success, or -1
+ on failure, usually due to an access restriction or invalid path. Note that
+ if stat() or unlink() fails, it may be due to another process noticing the
+ abandoned lock file a smidge sooner and deleting it, so those are not
+ flagged as an error. */
+local int log_lock(struct log *log)
+{
+ int fd;
+ struct stat st;
+
+ strcpy(log->end, ".lock");
+ while ((fd = open(log->path, O_CREAT | O_EXCL, 0644)) < 0) {
+ if (errno != EEXIST)
+ return -1;
+ if (stat(log->path, &st) == 0 && time(NULL) - st.st_mtime > PATIENCE) {
+ unlink(log->path);
+ continue;
+ }
+ sleep(2); /* relinquish the CPU for two seconds while waiting */
+ }
+ close(fd);
+ if (stat(log->path, &st) == 0)
+ log->lock = st.st_mtime;
+ return 0;
+}
+
+/* Update the modify time of the lock file to now, in order to prevent another
+ task from thinking that the lock is stale. Save the lock file modify time
+ for verification of ownership. */
+local void log_touch(struct log *log)
+{
+ struct stat st;
+
+ strcpy(log->end, ".lock");
+ utimes(log->path, NULL);
+ if (stat(log->path, &st) == 0)
+ log->lock = st.st_mtime;
+}
+
+/* Check the log file modify time against what is expected. Return true if
+ this is not our lock. If it is our lock, touch it to keep it. */
+local int log_check(struct log *log)
+{
+ struct stat st;
+
+ strcpy(log->end, ".lock");
+ if (stat(log->path, &st) || st.st_mtime != log->lock)
+ return 1;
+ log_touch(log);
+ return 0;
+}
+
+/* Unlock a previously acquired lock, but only if it's ours. */
+local void log_unlock(struct log *log)
+{
+ if (log_check(log))
+ return;
+ strcpy(log->end, ".lock");
+ unlink(log->path);
+ log->lock = 0;
+}
+
+/* Check the gzip header and read in the extra field, filling in the values in
+ the log structure. Return op on success or -1 if the gzip header was not as
+ expected. op is the current operation in progress last written to the extra
+ field. This assumes that the gzip file has already been opened, with the
+ file descriptor log->fd. */
+local int log_head(struct log *log)
+{
+ int op;
+ unsigned char buf[HEAD + EXTRA];
+
+ if (lseek(log->fd, 0, SEEK_SET) < 0 ||
+ read(log->fd, buf, HEAD + EXTRA) != HEAD + EXTRA ||
+ memcmp(buf, log_gzhead, HEAD)) {
+ return -1;
+ }
+ log->first = PULL8(buf + HEAD);
+ log->last = PULL8(buf + HEAD + 8);
+ log->ccrc = PULL4(buf + HEAD + 16);
+ log->clen = PULL4(buf + HEAD + 20);
+ log->tcrc = PULL4(buf + HEAD + 24);
+ log->tlen = PULL4(buf + HEAD + 28);
+ log->stored = PULL2(buf + HEAD + 32);
+ log->back = 3 + (buf[HEAD + 34] & 7);
+ op = (buf[HEAD + 34] >> 3) & 3;
+ return op;
+}
+
+/* Write over the extra field contents, marking the operation as op. Use fsync
+ to assure that the device is written to, and in the requested order. This
+ operation, and only this operation, is assumed to be atomic in order to
+ assure that the log is recoverable in the event of an interruption at any
+ point in the process. Return -1 if the write to foo.gz failed. */
+local int log_mark(struct log *log, int op)
+{
+ int ret;
+ unsigned char ext[EXTRA];
+
+ PUT8(ext, log->first);
+ PUT8(ext + 8, log->last);
+ PUT4(ext + 16, log->ccrc);
+ PUT4(ext + 20, log->clen);
+ PUT4(ext + 24, log->tcrc);
+ PUT4(ext + 28, log->tlen);
+ PUT2(ext + 32, log->stored);
+ ext[34] = log->back - 3 + (op << 3);
+ fsync(log->fd);
+ ret = lseek(log->fd, HEAD, SEEK_SET) < 0 ||
+ write(log->fd, ext, EXTRA) != EXTRA ? -1 : 0;
+ fsync(log->fd);
+ return ret;
+}
+
+/* Rewrite the last block header bits and subsequent zero bits to get to a byte
+ boundary, setting the last block bit if last is true, and then write the
+ remainder of the stored block header (length and one's complement). Leave
+ the file pointer after the end of the last stored block data. Return -1 if
+ there is a read or write failure on the foo.gz file */
+local int log_last(struct log *log, int last)
+{
+ int back, len, mask;
+ unsigned char buf[6];
+
+ /* determine the locations of the bytes and bits to modify */
+ back = log->last == log->first ? log->back : 8;
+ len = back > 8 ? 2 : 1; /* bytes back from log->last */
+ mask = 0x80 >> ((back - 1) & 7); /* mask for block last-bit */
+
+ /* get the byte to modify (one or two back) into buf[0] -- don't need to
+ read the byte if the last-bit is eight bits back, since in that case
+ the entire byte will be modified */
+ buf[0] = 0;
+ if (back != 8 && (lseek(log->fd, log->last - len, SEEK_SET) < 0 ||
+ read(log->fd, buf, 1) != 1))
+ return -1;
+
+ /* change the last-bit of the last stored block as requested -- note
+ that all bits above the last-bit are set to zero, per the type bits
+ of a stored block being 00 and per the convention that the bits to
+ bring the stream to a byte boundary are also zeros */
+ buf[1] = 0;
+ buf[2 - len] = (*buf & (mask - 1)) + (last ? mask : 0);
+
+ /* write the modified stored block header and lengths, move the file
+ pointer to after the last stored block data */
+ PUT2(buf + 2, log->stored);
+ PUT2(buf + 4, log->stored ^ 0xffff);
+ return lseek(log->fd, log->last - len, SEEK_SET) < 0 ||
+ write(log->fd, buf + 2 - len, len + 4) != len + 4 ||
+ lseek(log->fd, log->stored, SEEK_CUR) < 0 ? -1 : 0;
+}
+
+/* Append len bytes from data to the locked and open log file. len may be zero
+ if recovering and no .add file was found. In that case, the previous state
+ of the foo.gz file is restored. The data is appended uncompressed in
+ deflate stored blocks. Return -1 if there was an error reading or writing
+ the foo.gz file. */
+local int log_append(struct log *log, unsigned char *data, size_t len)
+{
+ uint put;
+ off_t end;
+ unsigned char buf[8];
+
+ /* set the last block last-bit and length, in case recovering an
+ interrupted append, then position the file pointer to append to the
+ block */
+ if (log_last(log, 1))
+ return -1;
+
+ /* append, adding stored blocks and updating the offset of the last stored
+ block as needed, and update the total crc and length */
+ while (len) {
+ /* append as much as we can to the last block */
+ put = (MAX_STORE << 10) - log->stored;
+ if (put > len)
+ put = (uint)len;
+ if (put) {
+ if (write(log->fd, data, put) != put)
+ return -1;
+ BAIL(1);
+ log->tcrc = crc32(log->tcrc, data, put);
+ log->tlen += put;
+ log->stored += put;
+ data += put;
+ len -= put;
+ }
+
+ /* if we need to, add a new empty stored block */
+ if (len) {
+ /* mark current block as not last */
+ if (log_last(log, 0))
+ return -1;
+
+ /* point to new, empty stored block */
+ log->last += 4 + log->stored + 1;
+ log->stored = 0;
+ }
+
+ /* mark last block as last, update its length */
+ if (log_last(log, 1))
+ return -1;
+ BAIL(2);
+ }
+
+ /* write the new crc and length trailer, and truncate just in case (could
+ be recovering from partial append with a missing foo.add file) */
+ PUT4(buf, log->tcrc);
+ PUT4(buf + 4, log->tlen);
+ if (write(log->fd, buf, 8) != 8 ||
+ (end = lseek(log->fd, 0, SEEK_CUR)) < 0 || ftruncate(log->fd, end))
+ return -1;
+
+ /* write the extra field, marking the log file as done, delete .add file */
+ if (log_mark(log, NO_OP))
+ return -1;
+ strcpy(log->end, ".add");
+ unlink(log->path); /* ignore error, since may not exist */
+ return 0;
+}
+
+/* Replace the foo.dict file with the foo.temp file. Also delete the foo.add
+ file, since the compress operation may have been interrupted before that was
+ done. Returns 1 if memory could not be allocated, or -1 if reading or
+ writing foo.gz fails, or if the rename fails for some reason other than
+ foo.temp not existing. foo.temp not existing is a permitted error, since
+ the replace operation may have been interrupted after the rename is done,
+ but before foo.gz is marked as complete. */
+local int log_replace(struct log *log)
+{
+ int ret;
+ char *dest;
+
+ /* delete foo.add file */
+ strcpy(log->end, ".add");
+ unlink(log->path); /* ignore error, since may not exist */
+ BAIL(3);
+
+ /* rename foo.name to foo.dict, replacing foo.dict if it exists */
+ strcpy(log->end, ".dict");
+ dest = malloc(strlen(log->path) + 1);
+ if (dest == NULL)
+ return -2;
+ strcpy(dest, log->path);
+ strcpy(log->end, ".temp");
+ ret = rename(log->path, dest);
+ free(dest);
+ if (ret && errno != ENOENT)
+ return -1;
+ BAIL(4);
+
+ /* mark the foo.gz file as done */
+ return log_mark(log, NO_OP);
+}
+
+/* Compress the len bytes at data and append the compressed data to the
+ foo.gz deflate data immediately after the previous compressed data. This
+ overwrites the previous uncompressed data, which was stored in foo.add
+ and is the data provided in data[0..len-1]. If this operation is
+ interrupted, it picks up at the start of this routine, with the foo.add
+ file read in again. If there is no data to compress (len == 0), then we
+ simply terminate the foo.gz file after the previously compressed data,
+ appending a final empty stored block and the gzip trailer. Return -1 if
+ reading or writing the log.gz file failed, or -2 if there was a memory
+ allocation failure. */
+local int log_compress(struct log *log, unsigned char *data, size_t len)
+{
+ int fd;
+ uint got, max;
+ ssize_t dict;
+ off_t end;
+ z_stream strm;
+ unsigned char buf[DICT];
+
+ /* compress and append compressed data */
+ if (len) {
+ /* set up for deflate, allocating memory */
+ strm.zalloc = Z_NULL;
+ strm.zfree = Z_NULL;
+ strm.opaque = Z_NULL;
+ if (deflateInit2(&strm, Z_DEFAULT_COMPRESSION, Z_DEFLATED, -15, 8,
+ Z_DEFAULT_STRATEGY) != Z_OK)
+ return -2;
+
+ /* read in dictionary (last 32K of data that was compressed) */
+ strcpy(log->end, ".dict");
+ fd = open(log->path, O_RDONLY, 0);
+ if (fd >= 0) {
+ dict = read(fd, buf, DICT);
+ close(fd);
+ if (dict < 0) {
+ deflateEnd(&strm);
+ return -1;
+ }
+ if (dict)
+ deflateSetDictionary(&strm, buf, (uint)dict);
+ }
+ log_touch(log);
+
+ /* prime deflate with last bits of previous block, position write
+ pointer to write those bits and overwrite what follows */
+ if (lseek(log->fd, log->first - (log->back > 8 ? 2 : 1),
+ SEEK_SET) < 0 ||
+ read(log->fd, buf, 1) != 1 || lseek(log->fd, -1, SEEK_CUR) < 0) {
+ deflateEnd(&strm);
+ return -1;
+ }
+ deflatePrime(&strm, (8 - log->back) & 7, *buf);
+
+ /* compress, finishing with a partial non-last empty static block */
+ strm.next_in = data;
+ max = (((uint)0 - 1) >> 1) + 1; /* in case int smaller than size_t */
+ do {
+ strm.avail_in = len > max ? max : (uint)len;
+ len -= strm.avail_in;
+ do {
+ strm.avail_out = DICT;
+ strm.next_out = buf;
+ deflate(&strm, len ? Z_NO_FLUSH : Z_PARTIAL_FLUSH);
+ got = DICT - strm.avail_out;
+ if (got && write(log->fd, buf, got) != got) {
+ deflateEnd(&strm);
+ return -1;
+ }
+ log_touch(log);
+ } while (strm.avail_out == 0);
+ } while (len);
+ deflateEnd(&strm);
+ BAIL(5);
+
+ /* find start of empty static block -- scanning backwards the first one
+ bit is the second bit of the block, if the last byte is zero, then
+ we know the byte before that has a one in the top bit, since an
+ empty static block is ten bits long */
+ if ((log->first = lseek(log->fd, -1, SEEK_CUR)) < 0 ||
+ read(log->fd, buf, 1) != 1)
+ return -1;
+ log->first++;
+ if (*buf) {
+ log->back = 1;
+ while ((*buf & ((uint)1 << (8 - log->back++))) == 0)
+ ; /* guaranteed to terminate, since *buf != 0 */
+ }
+ else
+ log->back = 10;
+
+ /* update compressed crc and length */
+ log->ccrc = log->tcrc;
+ log->clen = log->tlen;
+ }
+ else {
+ /* no data to compress -- fix up existing gzip stream */
+ log->tcrc = log->ccrc;
+ log->tlen = log->clen;
+ }
+
+ /* complete and truncate gzip stream */
+ log->last = log->first;
+ log->stored = 0;
+ PUT4(buf, log->tcrc);
+ PUT4(buf + 4, log->tlen);
+ if (log_last(log, 1) || write(log->fd, buf, 8) != 8 ||
+ (end = lseek(log->fd, 0, SEEK_CUR)) < 0 || ftruncate(log->fd, end))
+ return -1;
+ BAIL(6);
+
+ /* mark as being in the replace operation */
+ if (log_mark(log, REPLACE_OP))
+ return -1;
+
+ /* execute the replace operation and mark the file as done */
+ return log_replace(log);
+}
+
+/* log a repair record to the .repairs file */
+local void log_log(struct log *log, int op, char *record)
+{
+ time_t now;
+ FILE *rec;
+
+ now = time(NULL);
+ strcpy(log->end, ".repairs");
+ rec = fopen(log->path, "a");
+ if (rec == NULL)
+ return;
+ fprintf(rec, "%.24s %s recovery: %s\n", ctime(&now), op == APPEND_OP ?
+ "append" : (op == COMPRESS_OP ? "compress" : "replace"), record);
+ fclose(rec);
+ return;
+}
+
+/* Recover the interrupted operation op. First read foo.add for recovering an
+ append or compress operation. Return -1 if there was an error reading or
+ writing foo.gz or reading an existing foo.add, or -2 if there was a memory
+ allocation failure. */
+local int log_recover(struct log *log, int op)
+{
+ int fd, ret = 0;
+ unsigned char *data = NULL;
+ size_t len = 0;
+ struct stat st;
+
+ /* log recovery */
+ log_log(log, op, "start");
+
+ /* load foo.add file if expected and present */
+ if (op == APPEND_OP || op == COMPRESS_OP) {
+ strcpy(log->end, ".add");
+ if (stat(log->path, &st) == 0 && st.st_size) {
+ len = (size_t)(st.st_size);
+ if ((off_t)len != st.st_size ||
+ (data = malloc(st.st_size)) == NULL) {
+ log_log(log, op, "allocation failure");
+ return -2;
+ }
+ if ((fd = open(log->path, O_RDONLY, 0)) < 0) {
+ log_log(log, op, ".add file read failure");
+ return -1;
+ }
+ ret = (size_t)read(fd, data, len) != len;
+ close(fd);
+ if (ret) {
+ log_log(log, op, ".add file read failure");
+ return -1;
+ }
+ log_log(log, op, "loaded .add file");
+ }
+ else
+ log_log(log, op, "missing .add file!");
+ }
+
+ /* recover the interrupted operation */
+ switch (op) {
+ case APPEND_OP:
+ ret = log_append(log, data, len);
+ break;
+ case COMPRESS_OP:
+ ret = log_compress(log, data, len);
+ break;
+ case REPLACE_OP:
+ ret = log_replace(log);
+ }
+
+ /* log status */
+ log_log(log, op, ret ? "failure" : "complete");
+
+ /* clean up */
+ if (data != NULL)
+ free(data);
+ return ret;
+}
+
+/* Close the foo.gz file (if open) and release the lock. */
+local void log_close(struct log *log)
+{
+ if (log->fd >= 0)
+ close(log->fd);
+ log->fd = -1;
+ log_unlock(log);
+}
+
+/* Open foo.gz, verify the header, and load the extra field contents, after
+ first creating the foo.lock file to gain exclusive access to the foo.*
+ files. If foo.gz does not exist or is empty, then write the initial header,
+ extra, and body content of an empty foo.gz log file. If there is an error
+ creating the lock file due to access restrictions, or an error reading or
+ writing the foo.gz file, or if the foo.gz file is not a proper log file for
+ this object (e.g. not a gzip file or does not contain the expected extra
+ field), then return true. If there is an error, the lock is released.
+ Otherwise, the lock is left in place. */
+local int log_open(struct log *log)
+{
+ int op;
+
+ /* release open file resource if left over -- can occur if lock lost
+ between gzlog_open() and gzlog_write() */
+ if (log->fd >= 0)
+ close(log->fd);
+ log->fd = -1;
+
+ /* negotiate exclusive access */
+ if (log_lock(log) < 0)
+ return -1;
+
+ /* open the log file, foo.gz */
+ strcpy(log->end, ".gz");
+ log->fd = open(log->path, O_RDWR | O_CREAT, 0644);
+ if (log->fd < 0) {
+ log_close(log);
+ return -1;
+ }
+
+ /* if new, initialize foo.gz with an empty log, delete old dictionary */
+ if (lseek(log->fd, 0, SEEK_END) == 0) {
+ if (write(log->fd, log_gzhead, HEAD) != HEAD ||
+ write(log->fd, log_gzext, EXTRA) != EXTRA ||
+ write(log->fd, log_gzbody, BODY) != BODY) {
+ log_close(log);
+ return -1;
+ }
+ strcpy(log->end, ".dict");
+ unlink(log->path);
+ }
+
+ /* verify log file and load extra field information */
+ if ((op = log_head(log)) < 0) {
+ log_close(log);
+ return -1;
+ }
+
+ /* check for interrupted process and if so, recover */
+ if (op != NO_OP && log_recover(log, op)) {
+ log_close(log);
+ return -1;
+ }
+
+ /* touch the lock file to prevent another process from grabbing it */
+ log_touch(log);
+ return 0;
+}
+
+/* See gzlog.h for the description of the external methods below */
+gzlog *gzlog_open(char *path)
+{
+ size_t n;
+ struct log *log;
+
+ /* check arguments */
+ if (path == NULL || *path == 0)
+ return NULL;
+
+ /* allocate and initialize log structure */
+ log = malloc(sizeof(struct log));
+ if (log == NULL)
+ return NULL;
+ strcpy(log->id, LOGID);
+ log->fd = -1;
+
+ /* save path and end of path for name construction */
+ n = strlen(path);
+ log->path = malloc(n + 9); /* allow for ".repairs" */
+ if (log->path == NULL) {
+ free(log);
+ return NULL;
+ }
+ strcpy(log->path, path);
+ log->end = log->path + n;
+
+ /* gain exclusive access and verify log file -- may perform a
+ recovery operation if needed */
+ if (log_open(log)) {
+ free(log->path);
+ free(log);
+ return NULL;
+ }
+
+ /* return pointer to log structure */
+ return log;
+}
+
+/* gzlog_compress() return values:
+ 0: all good
+ -1: file i/o error (usually access issue)
+ -2: memory allocation failure
+ -3: invalid log pointer argument */
+int gzlog_compress(gzlog *logd)
+{
+ int fd, ret;
+ uint block;
+ size_t len, next;
+ unsigned char *data, buf[5];
+ struct log *log = logd;
+
+ /* check arguments */
+ if (log == NULL || strcmp(log->id, LOGID))
+ return -3;
+
+ /* see if we lost the lock -- if so get it again and reload the extra
+ field information (it probably changed), recover last operation if
+ necessary */
+ if (log_check(log) && log_open(log))
+ return -1;
+
+ /* create space for uncompressed data */
+ len = ((size_t)(log->last - log->first) & ~(((size_t)1 << 10) - 1)) +
+ log->stored;
+ if ((data = malloc(len)) == NULL)
+ return -2;
+
+ /* do statement here is just a cheap trick for error handling */
+ do {
+ /* read in the uncompressed data */
+ if (lseek(log->fd, log->first - 1, SEEK_SET) < 0)
+ break;
+ next = 0;
+ while (next < len) {
+ if (read(log->fd, buf, 5) != 5)
+ break;
+ block = PULL2(buf + 1);
+ if (next + block > len ||
+ read(log->fd, (char *)data + next, block) != block)
+ break;
+ next += block;
+ }
+ if (lseek(log->fd, 0, SEEK_CUR) != log->last + 4 + log->stored)
+ break;
+ log_touch(log);
+
+ /* write the uncompressed data to the .add file */
+ strcpy(log->end, ".add");
+ fd = open(log->path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+ if (fd < 0)
+ break;
+ ret = (size_t)write(fd, data, len) != len;
+ if (ret | close(fd))
+ break;
+ log_touch(log);
+
+ /* write the dictionary for the next compress to the .temp file */
+ strcpy(log->end, ".temp");
+ fd = open(log->path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+ if (fd < 0)
+ break;
+ next = DICT > len ? len : DICT;
+ ret = (size_t)write(fd, (char *)data + len - next, next) != next;
+ if (ret | close(fd))
+ break;
+ log_touch(log);
+
+ /* roll back to compressed data, mark the compress in progress */
+ log->last = log->first;
+ log->stored = 0;
+ if (log_mark(log, COMPRESS_OP))
+ break;
+ BAIL(7);
+
+ /* compress and append the data (clears mark) */
+ ret = log_compress(log, data, len);
+ free(data);
+ return ret;
+ } while (0);
+
+ /* broke out of do above on i/o error */
+ free(data);
+ return -1;
+}
+
+/* gzlog_write() return values:
+ 0: all good
+ -1: file i/o error (usually access issue)
+ -2: memory allocation failure
+ -3: invalid log pointer argument */
+int gzlog_write(gzlog *logd, void *data, size_t len)
+{
+ int fd, ret;
+ struct log *log = logd;
+
+ /* check arguments */
+ if (log == NULL || strcmp(log->id, LOGID))
+ return -3;
+ if (data == NULL || len <= 0)
+ return 0;
+
+ /* see if we lost the lock -- if so get it again and reload the extra
+ field information (it probably changed), recover last operation if
+ necessary */
+ if (log_check(log) && log_open(log))
+ return -1;
+
+ /* create and write .add file */
+ strcpy(log->end, ".add");
+ fd = open(log->path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
+ if (fd < 0)
+ return -1;
+ ret = (size_t)write(fd, data, len) != len;
+ if (ret | close(fd))
+ return -1;
+ log_touch(log);
+
+ /* mark log file with append in progress */
+ if (log_mark(log, APPEND_OP))
+ return -1;
+ BAIL(8);
+
+ /* append data (clears mark) */
+ if (log_append(log, data, len))
+ return -1;
+
+ /* check to see if it's time to compress -- if not, then done */
+ if (((log->last - log->first) >> 10) + (log->stored >> 10) < TRIGGER)
+ return 0;
+
+ /* time to compress */
+ return gzlog_compress(log);
+}
+
+/* gzlog_close() return values:
+ 0: ok
+ -3: invalid log pointer argument */
+int gzlog_close(gzlog *logd)
+{
+ struct log *log = logd;
+
+ /* check arguments */
+ if (log == NULL || strcmp(log->id, LOGID))
+ return -3;
+
+ /* close the log file and release the lock */
+ log_close(log);
+
+ /* free structure and return */
+ if (log->path != NULL)
+ free(log->path);
+ strcpy(log->id, "bad");
+ free(log);
+ return 0;
+}
diff --git a/zlib/examples/gzlog.h b/zlib/examples/gzlog.h
new file mode 100644
index 000000000..86f0cecba
--- /dev/null
+++ b/zlib/examples/gzlog.h
@@ -0,0 +1,91 @@
+/* gzlog.h
+ Copyright (C) 2004, 2008, 2012 Mark Adler, all rights reserved
+ version 2.2, 14 Aug 2012
+
+ This software is provided 'as-is', without any express or implied
+ warranty. In no event will the author 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.
+
+ Mark Adler madler@alumni.caltech.edu
+ */
+
+/* Version History:
+ 1.0 26 Nov 2004 First version
+ 2.0 25 Apr 2008 Complete redesign for recovery of interrupted operations
+ Interface changed slightly in that now path is a prefix
+ Compression now occurs as needed during gzlog_write()
+ gzlog_write() now always leaves the log file as valid gzip
+ 2.1 8 Jul 2012 Fix argument checks in gzlog_compress() and gzlog_write()
+ 2.2 14 Aug 2012 Clean up signed comparisons
+ */
+
+/*
+ The gzlog object allows writing short messages to a gzipped log file,
+ opening the log file locked for small bursts, and then closing it. The log
+ object works by appending stored (uncompressed) data to the gzip file until
+ 1 MB has been accumulated. At that time, the stored data is compressed, and
+ replaces the uncompressed data in the file. The log file is truncated to
+ its new size at that time. After each write operation, the log file is a
+ valid gzip file that can decompressed to recover what was written.
+
+ The gzlog operations can be interupted at any point due to an application or
+ system crash, and the log file will be recovered the next time the log is
+ opened with gzlog_open().
+ */
+
+#ifndef GZLOG_H
+#define GZLOG_H
+
+/* gzlog object type */
+typedef void gzlog;
+
+/* Open a gzlog object, creating the log file if it does not exist. Return
+ NULL on error. Note that gzlog_open() could take a while to complete if it
+ has to wait to verify that a lock is stale (possibly for five minutes), or
+ if there is significant contention with other instantiations of this object
+ when locking the resource. path is the prefix of the file names created by
+ this object. If path is "foo", then the log file will be "foo.gz", and
+ other auxiliary files will be created and destroyed during the process:
+ "foo.dict" for a compression dictionary, "foo.temp" for a temporary (next)
+ dictionary, "foo.add" for data being added or compressed, "foo.lock" for the
+ lock file, and "foo.repairs" to log recovery operations performed due to
+ interrupted gzlog operations. A gzlog_open() followed by a gzlog_close()
+ will recover a previously interrupted operation, if any. */
+gzlog *gzlog_open(char *path);
+
+/* Write to a gzlog object. Return zero on success, -1 if there is a file i/o
+ error on any of the gzlog files (this should not happen if gzlog_open()
+ succeeded, unless the device has run out of space or leftover auxiliary
+ files have permissions or ownership that prevent their use), -2 if there is
+ a memory allocation failure, or -3 if the log argument is invalid (e.g. if
+ it was not created by gzlog_open()). This function will write data to the
+ file uncompressed, until 1 MB has been accumulated, at which time that data
+ will be compressed. The log file will be a valid gzip file upon successful
+ return. */
+int gzlog_write(gzlog *log, void *data, size_t len);
+
+/* Force compression of any uncompressed data in the log. This should be used
+ sparingly, if at all. The main application would be when a log file will
+ not be appended to again. If this is used to compress frequently while
+ appending, it will both significantly increase the execution time and
+ reduce the compression ratio. The return codes are the same as for
+ gzlog_write(). */
+int gzlog_compress(gzlog *log);
+
+/* Close a gzlog object. Return zero on success, -3 if the log argument is
+ invalid. The log object is freed, and so cannot be referenced again. */
+int gzlog_close(gzlog *log);
+
+#endif
diff --git a/zlib/examples/zlib_how.html b/zlib/examples/zlib_how.html
new file mode 100644
index 000000000..444ff1c9a
--- /dev/null
+++ b/zlib/examples/zlib_how.html
@@ -0,0 +1,545 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN"
+ "http://www.w3.org/TR/REC-html40/loose.dtd">
+<html>
+<head>
+<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
+<title>zlib Usage Example</title>
+<!-- Copyright (c) 2004, 2005 Mark Adler. -->
+</head>
+<body bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#00A000">
+<h2 align="center"> zlib Usage Example </h2>
+We often get questions about how the <tt>deflate()</tt> and <tt>inflate()</tt> functions should be used.
+Users wonder when they should provide more input, when they should use more output,
+what to do with a <tt>Z_BUF_ERROR</tt>, how to make sure the process terminates properly, and
+so on. So for those who have read <tt>zlib.h</tt> (a few times), and
+would like further edification, below is an annotated example in C of simple routines to compress and decompress
+from an input file to an output file using <tt>deflate()</tt> and <tt>inflate()</tt> respectively. The
+annotations are interspersed between lines of the code. So please read between the lines.
+We hope this helps explain some of the intricacies of <em>zlib</em>.
+<p>
+Without further adieu, here is the program <a href="zpipe.c"><tt>zpipe.c</tt></a>:
+<pre><b>
+/* zpipe.c: example of proper use of zlib's inflate() and deflate()
+ Not copyrighted -- provided to the public domain
+ Version 1.4 11 December 2005 Mark Adler */
+
+/* Version history:
+ 1.0 30 Oct 2004 First version
+ 1.1 8 Nov 2004 Add void casting for unused return values
+ Use switch statement for inflate() return values
+ 1.2 9 Nov 2004 Add assertions to document zlib guarantees
+ 1.3 6 Apr 2005 Remove incorrect assertion in inf()
+ 1.4 11 Dec 2005 Add hack to avoid MSDOS end-of-line conversions
+ Avoid some compiler warnings for input and output buffers
+ */
+</b></pre><!-- -->
+We now include the header files for the required definitions. From
+<tt>stdio.h</tt> we use <tt>fopen()</tt>, <tt>fread()</tt>, <tt>fwrite()</tt>,
+<tt>feof()</tt>, <tt>ferror()</tt>, and <tt>fclose()</tt> for file i/o, and
+<tt>fputs()</tt> for error messages. From <tt>string.h</tt> we use
+<tt>strcmp()</tt> for command line argument processing.
+From <tt>assert.h</tt> we use the <tt>assert()</tt> macro.
+From <tt>zlib.h</tt>
+we use the basic compression functions <tt>deflateInit()</tt>,
+<tt>deflate()</tt>, and <tt>deflateEnd()</tt>, and the basic decompression
+functions <tt>inflateInit()</tt>, <tt>inflate()</tt>, and
+<tt>inflateEnd()</tt>.
+<pre><b>
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include "zlib.h"
+</b></pre><!-- -->
+This is an ugly hack required to avoid corruption of the input and output data on
+Windows/MS-DOS systems. Without this, those systems would assume that the input and output
+files are text, and try to convert the end-of-line characters from one standard to
+another. That would corrupt binary data, and in particular would render the compressed data unusable.
+This sets the input and output to binary which suppresses the end-of-line conversions.
+<tt>SET_BINARY_MODE()</tt> will be used later on <tt>stdin</tt> and <tt>stdout</tt>, at the beginning of <tt>main()</tt>.
+<pre><b>
+#if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__)
+# include <fcntl.h>
+# include <io.h>
+# define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
+#else
+# define SET_BINARY_MODE(file)
+#endif
+</b></pre><!-- -->
+<tt>CHUNK</tt> is simply the buffer size for feeding data to and pulling data
+from the <em>zlib</em> routines. Larger buffer sizes would be more efficient,
+especially for <tt>inflate()</tt>. If the memory is available, buffers sizes
+on the order of 128K or 256K bytes should be used.
+<pre><b>
+#define CHUNK 16384
+</b></pre><!-- -->
+The <tt>def()</tt> routine compresses data from an input file to an output file. The output data
+will be in the <em>zlib</em> format, which is different from the <em>gzip</em> or <em>zip</em>
+formats. The <em>zlib</em> format has a very small header of only two bytes to identify it as
+a <em>zlib</em> stream and to provide decoding information, and a four-byte trailer with a fast
+check value to verify the integrity of the uncompressed data after decoding.
+<pre><b>
+/* Compress from file source to file dest until EOF on source.
+ def() returns Z_OK on success, Z_MEM_ERROR if memory could not be
+ allocated for processing, Z_STREAM_ERROR if an invalid compression
+ level is supplied, Z_VERSION_ERROR if the version of zlib.h and the
+ version of the library linked do not match, or Z_ERRNO if there is
+ an error reading or writing the files. */
+int def(FILE *source, FILE *dest, int level)
+{
+</b></pre>
+Here are the local variables for <tt>def()</tt>. <tt>ret</tt> will be used for <em>zlib</em>
+return codes. <tt>flush</tt> will keep track of the current flushing state for <tt>deflate()</tt>,
+which is either no flushing, or flush to completion after the end of the input file is reached.
+<tt>have</tt> is the amount of data returned from <tt>deflate()</tt>. The <tt>strm</tt> structure
+is used to pass information to and from the <em>zlib</em> routines, and to maintain the
+<tt>deflate()</tt> state. <tt>in</tt> and <tt>out</tt> are the input and output buffers for
+<tt>deflate()</tt>.
+<pre><b>
+ int ret, flush;
+ unsigned have;
+ z_stream strm;
+ unsigned char in[CHUNK];
+ unsigned char out[CHUNK];
+</b></pre><!-- -->
+The first thing we do is to initialize the <em>zlib</em> state for compression using
+<tt>deflateInit()</tt>. This must be done before the first use of <tt>deflate()</tt>.
+The <tt>zalloc</tt>, <tt>zfree</tt>, and <tt>opaque</tt> fields in the <tt>strm</tt>
+structure must be initialized before calling <tt>deflateInit()</tt>. Here they are
+set to the <em>zlib</em> constant <tt>Z_NULL</tt> to request that <em>zlib</em> use
+the default memory allocation routines. An application may also choose to provide
+custom memory allocation routines here. <tt>deflateInit()</tt> will allocate on the
+order of 256K bytes for the internal state.
+(See <a href="zlib_tech.html"><em>zlib Technical Details</em></a>.)
+<p>
+<tt>deflateInit()</tt> is called with a pointer to the structure to be initialized and
+the compression level, which is an integer in the range of -1 to 9. Lower compression
+levels result in faster execution, but less compression. Higher levels result in
+greater compression, but slower execution. The <em>zlib</em> constant Z_DEFAULT_COMPRESSION,
+equal to -1,
+provides a good compromise between compression and speed and is equivalent to level 6.
+Level 0 actually does no compression at all, and in fact expands the data slightly to produce
+the <em>zlib</em> format (it is not a byte-for-byte copy of the input).
+More advanced applications of <em>zlib</em>
+may use <tt>deflateInit2()</tt> here instead. Such an application may want to reduce how
+much memory will be used, at some price in compression. Or it may need to request a
+<em>gzip</em> header and trailer instead of a <em>zlib</em> header and trailer, or raw
+encoding with no header or trailer at all.
+<p>
+We must check the return value of <tt>deflateInit()</tt> against the <em>zlib</em> constant
+<tt>Z_OK</tt> to make sure that it was able to
+allocate memory for the internal state, and that the provided arguments were valid.
+<tt>deflateInit()</tt> will also check that the version of <em>zlib</em> that the <tt>zlib.h</tt>
+file came from matches the version of <em>zlib</em> actually linked with the program. This
+is especially important for environments in which <em>zlib</em> is a shared library.
+<p>
+Note that an application can initialize multiple, independent <em>zlib</em> streams, which can
+operate in parallel. The state information maintained in the structure allows the <em>zlib</em>
+routines to be reentrant.
+<pre><b>
+ /* allocate deflate state */
+ strm.zalloc = Z_NULL;
+ strm.zfree = Z_NULL;
+ strm.opaque = Z_NULL;
+ ret = deflateInit(&strm, level);
+ if (ret != Z_OK)
+ return ret;
+</b></pre><!-- -->
+With the pleasantries out of the way, now we can get down to business. The outer <tt>do</tt>-loop
+reads all of the input file and exits at the bottom of the loop once end-of-file is reached.
+This loop contains the only call of <tt>deflate()</tt>. So we must make sure that all of the
+input data has been processed and that all of the output data has been generated and consumed
+before we fall out of the loop at the bottom.
+<pre><b>
+ /* compress until end of file */
+ do {
+</b></pre>
+We start off by reading data from the input file. The number of bytes read is put directly
+into <tt>avail_in</tt>, and a pointer to those bytes is put into <tt>next_in</tt>. We also
+check to see if end-of-file on the input has been reached. If we are at the end of file, then <tt>flush</tt> is set to the
+<em>zlib</em> constant <tt>Z_FINISH</tt>, which is later passed to <tt>deflate()</tt> to
+indicate that this is the last chunk of input data to compress. We need to use <tt>feof()</tt>
+to check for end-of-file as opposed to seeing if fewer than <tt>CHUNK</tt> bytes have been read. The
+reason is that if the input file length is an exact multiple of <tt>CHUNK</tt>, we will miss
+the fact that we got to the end-of-file, and not know to tell <tt>deflate()</tt> to finish
+up the compressed stream. If we are not yet at the end of the input, then the <em>zlib</em>
+constant <tt>Z_NO_FLUSH</tt> will be passed to <tt>deflate</tt> to indicate that we are still
+in the middle of the uncompressed data.
+<p>
+If there is an error in reading from the input file, the process is aborted with
+<tt>deflateEnd()</tt> being called to free the allocated <em>zlib</em> state before returning
+the error. We wouldn't want a memory leak, now would we? <tt>deflateEnd()</tt> can be called
+at any time after the state has been initialized. Once that's done, <tt>deflateInit()</tt> (or
+<tt>deflateInit2()</tt>) would have to be called to start a new compression process. There is
+no point here in checking the <tt>deflateEnd()</tt> return code. The deallocation can't fail.
+<pre><b>
+ strm.avail_in = fread(in, 1, CHUNK, source);
+ if (ferror(source)) {
+ (void)deflateEnd(&strm);
+ return Z_ERRNO;
+ }
+ flush = feof(source) ? Z_FINISH : Z_NO_FLUSH;
+ strm.next_in = in;
+</b></pre><!-- -->
+The inner <tt>do</tt>-loop passes our chunk of input data to <tt>deflate()</tt>, and then
+keeps calling <tt>deflate()</tt> until it is done producing output. Once there is no more
+new output, <tt>deflate()</tt> is guaranteed to have consumed all of the input, i.e.,
+<tt>avail_in</tt> will be zero.
+<pre><b>
+ /* run deflate() on input until output buffer not full, finish
+ compression if all of source has been read in */
+ do {
+</b></pre>
+Output space is provided to <tt>deflate()</tt> by setting <tt>avail_out</tt> to the number
+of available output bytes and <tt>next_out</tt> to a pointer to that space.
+<pre><b>
+ strm.avail_out = CHUNK;
+ strm.next_out = out;
+</b></pre>
+Now we call the compression engine itself, <tt>deflate()</tt>. It takes as many of the
+<tt>avail_in</tt> bytes at <tt>next_in</tt> as it can process, and writes as many as
+<tt>avail_out</tt> bytes to <tt>next_out</tt>. Those counters and pointers are then
+updated past the input data consumed and the output data written. It is the amount of
+output space available that may limit how much input is consumed.
+Hence the inner loop to make sure that
+all of the input is consumed by providing more output space each time. Since <tt>avail_in</tt>
+and <tt>next_in</tt> are updated by <tt>deflate()</tt>, we don't have to mess with those
+between <tt>deflate()</tt> calls until it's all used up.
+<p>
+The parameters to <tt>deflate()</tt> are a pointer to the <tt>strm</tt> structure containing
+the input and output information and the internal compression engine state, and a parameter
+indicating whether and how to flush data to the output. Normally <tt>deflate</tt> will consume
+several K bytes of input data before producing any output (except for the header), in order
+to accumulate statistics on the data for optimum compression. It will then put out a burst of
+compressed data, and proceed to consume more input before the next burst. Eventually,
+<tt>deflate()</tt>
+must be told to terminate the stream, complete the compression with provided input data, and
+write out the trailer check value. <tt>deflate()</tt> will continue to compress normally as long
+as the flush parameter is <tt>Z_NO_FLUSH</tt>. Once the <tt>Z_FINISH</tt> parameter is provided,
+<tt>deflate()</tt> will begin to complete the compressed output stream. However depending on how
+much output space is provided, <tt>deflate()</tt> may have to be called several times until it
+has provided the complete compressed stream, even after it has consumed all of the input. The flush
+parameter must continue to be <tt>Z_FINISH</tt> for those subsequent calls.
+<p>
+There are other values of the flush parameter that are used in more advanced applications. You can
+force <tt>deflate()</tt> to produce a burst of output that encodes all of the input data provided
+so far, even if it wouldn't have otherwise, for example to control data latency on a link with
+compressed data. You can also ask that <tt>deflate()</tt> do that as well as erase any history up to
+that point so that what follows can be decompressed independently, for example for random access
+applications. Both requests will degrade compression by an amount depending on how often such
+requests are made.
+<p>
+<tt>deflate()</tt> has a return value that can indicate errors, yet we do not check it here. Why
+not? Well, it turns out that <tt>deflate()</tt> can do no wrong here. Let's go through
+<tt>deflate()</tt>'s return values and dispense with them one by one. The possible values are
+<tt>Z_OK</tt>, <tt>Z_STREAM_END</tt>, <tt>Z_STREAM_ERROR</tt>, or <tt>Z_BUF_ERROR</tt>. <tt>Z_OK</tt>
+is, well, ok. <tt>Z_STREAM_END</tt> is also ok and will be returned for the last call of
+<tt>deflate()</tt>. This is already guaranteed by calling <tt>deflate()</tt> with <tt>Z_FINISH</tt>
+until it has no more output. <tt>Z_STREAM_ERROR</tt> is only possible if the stream is not
+initialized properly, but we did initialize it properly. There is no harm in checking for
+<tt>Z_STREAM_ERROR</tt> here, for example to check for the possibility that some
+other part of the application inadvertently clobbered the memory containing the <em>zlib</em> state.
+<tt>Z_BUF_ERROR</tt> will be explained further below, but
+suffice it to say that this is simply an indication that <tt>deflate()</tt> could not consume
+more input or produce more output. <tt>deflate()</tt> can be called again with more output space
+or more available input, which it will be in this code.
+<pre><b>
+ ret = deflate(&strm, flush); /* no bad return value */
+ assert(ret != Z_STREAM_ERROR); /* state not clobbered */
+</b></pre>
+Now we compute how much output <tt>deflate()</tt> provided on the last call, which is the
+difference between how much space was provided before the call, and how much output space
+is still available after the call. Then that data, if any, is written to the output file.
+We can then reuse the output buffer for the next call of <tt>deflate()</tt>. Again if there
+is a file i/o error, we call <tt>deflateEnd()</tt> before returning to avoid a memory leak.
+<pre><b>
+ have = CHUNK - strm.avail_out;
+ if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
+ (void)deflateEnd(&strm);
+ return Z_ERRNO;
+ }
+</b></pre>
+The inner <tt>do</tt>-loop is repeated until the last <tt>deflate()</tt> call fails to fill the
+provided output buffer. Then we know that <tt>deflate()</tt> has done as much as it can with
+the provided input, and that all of that input has been consumed. We can then fall out of this
+loop and reuse the input buffer.
+<p>
+The way we tell that <tt>deflate()</tt> has no more output is by seeing that it did not fill
+the output buffer, leaving <tt>avail_out</tt> greater than zero. However suppose that
+<tt>deflate()</tt> has no more output, but just so happened to exactly fill the output buffer!
+<tt>avail_out</tt> is zero, and we can't tell that <tt>deflate()</tt> has done all it can.
+As far as we know, <tt>deflate()</tt>
+has more output for us. So we call it again. But now <tt>deflate()</tt> produces no output
+at all, and <tt>avail_out</tt> remains unchanged as <tt>CHUNK</tt>. That <tt>deflate()</tt> call
+wasn't able to do anything, either consume input or produce output, and so it returns
+<tt>Z_BUF_ERROR</tt>. (See, I told you I'd cover this later.) However this is not a problem at
+all. Now we finally have the desired indication that <tt>deflate()</tt> is really done,
+and so we drop out of the inner loop to provide more input to <tt>deflate()</tt>.
+<p>
+With <tt>flush</tt> set to <tt>Z_FINISH</tt>, this final set of <tt>deflate()</tt> calls will
+complete the output stream. Once that is done, subsequent calls of <tt>deflate()</tt> would return
+<tt>Z_STREAM_ERROR</tt> if the flush parameter is not <tt>Z_FINISH</tt>, and do no more processing
+until the state is reinitialized.
+<p>
+Some applications of <em>zlib</em> have two loops that call <tt>deflate()</tt>
+instead of the single inner loop we have here. The first loop would call
+without flushing and feed all of the data to <tt>deflate()</tt>. The second loop would call
+<tt>deflate()</tt> with no more
+data and the <tt>Z_FINISH</tt> parameter to complete the process. As you can see from this
+example, that can be avoided by simply keeping track of the current flush state.
+<pre><b>
+ } while (strm.avail_out == 0);
+ assert(strm.avail_in == 0); /* all input will be used */
+</b></pre><!-- -->
+Now we check to see if we have already processed all of the input file. That information was
+saved in the <tt>flush</tt> variable, so we see if that was set to <tt>Z_FINISH</tt>. If so,
+then we're done and we fall out of the outer loop. We're guaranteed to get <tt>Z_STREAM_END</tt>
+from the last <tt>deflate()</tt> call, since we ran it until the last chunk of input was
+consumed and all of the output was generated.
+<pre><b>
+ /* done when last data in file processed */
+ } while (flush != Z_FINISH);
+ assert(ret == Z_STREAM_END); /* stream will be complete */
+</b></pre><!-- -->
+The process is complete, but we still need to deallocate the state to avoid a memory leak
+(or rather more like a memory hemorrhage if you didn't do this). Then
+finally we can return with a happy return value.
+<pre><b>
+ /* clean up and return */
+ (void)deflateEnd(&strm);
+ return Z_OK;
+}
+</b></pre><!-- -->
+Now we do the same thing for decompression in the <tt>inf()</tt> routine. <tt>inf()</tt>
+decompresses what is hopefully a valid <em>zlib</em> stream from the input file and writes the
+uncompressed data to the output file. Much of the discussion above for <tt>def()</tt>
+applies to <tt>inf()</tt> as well, so the discussion here will focus on the differences between
+the two.
+<pre><b>
+/* Decompress from file source to file dest until stream ends or EOF.
+ inf() returns Z_OK on success, Z_MEM_ERROR if memory could not be
+ allocated for processing, Z_DATA_ERROR if the deflate data is
+ invalid or incomplete, Z_VERSION_ERROR if the version of zlib.h and
+ the version of the library linked do not match, or Z_ERRNO if there
+ is an error reading or writing the files. */
+int inf(FILE *source, FILE *dest)
+{
+</b></pre>
+The local variables have the same functionality as they do for <tt>def()</tt>. The
+only difference is that there is no <tt>flush</tt> variable, since <tt>inflate()</tt>
+can tell from the <em>zlib</em> stream itself when the stream is complete.
+<pre><b>
+ int ret;
+ unsigned have;
+ z_stream strm;
+ unsigned char in[CHUNK];
+ unsigned char out[CHUNK];
+</b></pre><!-- -->
+The initialization of the state is the same, except that there is no compression level,
+of course, and two more elements of the structure are initialized. <tt>avail_in</tt>
+and <tt>next_in</tt> must be initialized before calling <tt>inflateInit()</tt>. This
+is because the application has the option to provide the start of the zlib stream in
+order for <tt>inflateInit()</tt> to have access to information about the compression
+method to aid in memory allocation. In the current implementation of <em>zlib</em>
+(up through versions 1.2.x), the method-dependent memory allocations are deferred to the first call of
+<tt>inflate()</tt> anyway. However those fields must be initialized since later versions
+of <em>zlib</em> that provide more compression methods may take advantage of this interface.
+In any case, no decompression is performed by <tt>inflateInit()</tt>, so the
+<tt>avail_out</tt> and <tt>next_out</tt> fields do not need to be initialized before calling.
+<p>
+Here <tt>avail_in</tt> is set to zero and <tt>next_in</tt> is set to <tt>Z_NULL</tt> to
+indicate that no input data is being provided.
+<pre><b>
+ /* allocate inflate state */
+ strm.zalloc = Z_NULL;
+ strm.zfree = Z_NULL;
+ strm.opaque = Z_NULL;
+ strm.avail_in = 0;
+ strm.next_in = Z_NULL;
+ ret = inflateInit(&strm);
+ if (ret != Z_OK)
+ return ret;
+</b></pre><!-- -->
+The outer <tt>do</tt>-loop decompresses input until <tt>inflate()</tt> indicates
+that it has reached the end of the compressed data and has produced all of the uncompressed
+output. This is in contrast to <tt>def()</tt> which processes all of the input file.
+If end-of-file is reached before the compressed data self-terminates, then the compressed
+data is incomplete and an error is returned.
+<pre><b>
+ /* decompress until deflate stream ends or end of file */
+ do {
+</b></pre>
+We read input data and set the <tt>strm</tt> structure accordingly. If we've reached the
+end of the input file, then we leave the outer loop and report an error, since the
+compressed data is incomplete. Note that we may read more data than is eventually consumed
+by <tt>inflate()</tt>, if the input file continues past the <em>zlib</em> stream.
+For applications where <em>zlib</em> streams are embedded in other data, this routine would
+need to be modified to return the unused data, or at least indicate how much of the input
+data was not used, so the application would know where to pick up after the <em>zlib</em> stream.
+<pre><b>
+ strm.avail_in = fread(in, 1, CHUNK, source);
+ if (ferror(source)) {
+ (void)inflateEnd(&strm);
+ return Z_ERRNO;
+ }
+ if (strm.avail_in == 0)
+ break;
+ strm.next_in = in;
+</b></pre><!-- -->
+The inner <tt>do</tt>-loop has the same function it did in <tt>def()</tt>, which is to
+keep calling <tt>inflate()</tt> until has generated all of the output it can with the
+provided input.
+<pre><b>
+ /* run inflate() on input until output buffer not full */
+ do {
+</b></pre>
+Just like in <tt>def()</tt>, the same output space is provided for each call of <tt>inflate()</tt>.
+<pre><b>
+ strm.avail_out = CHUNK;
+ strm.next_out = out;
+</b></pre>
+Now we run the decompression engine itself. There is no need to adjust the flush parameter, since
+the <em>zlib</em> format is self-terminating. The main difference here is that there are
+return values that we need to pay attention to. <tt>Z_DATA_ERROR</tt>
+indicates that <tt>inflate()</tt> detected an error in the <em>zlib</em> compressed data format,
+which means that either the data is not a <em>zlib</em> stream to begin with, or that the data was
+corrupted somewhere along the way since it was compressed. The other error to be processed is
+<tt>Z_MEM_ERROR</tt>, which can occur since memory allocation is deferred until <tt>inflate()</tt>
+needs it, unlike <tt>deflate()</tt>, whose memory is allocated at the start by <tt>deflateInit()</tt>.
+<p>
+Advanced applications may use
+<tt>deflateSetDictionary()</tt> to prime <tt>deflate()</tt> with a set of likely data to improve the
+first 32K or so of compression. This is noted in the <em>zlib</em> header, so <tt>inflate()</tt>
+requests that that dictionary be provided before it can start to decompress. Without the dictionary,
+correct decompression is not possible. For this routine, we have no idea what the dictionary is,
+so the <tt>Z_NEED_DICT</tt> indication is converted to a <tt>Z_DATA_ERROR</tt>.
+<p>
+<tt>inflate()</tt> can also return <tt>Z_STREAM_ERROR</tt>, which should not be possible here,
+but could be checked for as noted above for <tt>def()</tt>. <tt>Z_BUF_ERROR</tt> does not need to be
+checked for here, for the same reasons noted for <tt>def()</tt>. <tt>Z_STREAM_END</tt> will be
+checked for later.
+<pre><b>
+ ret = inflate(&strm, Z_NO_FLUSH);
+ assert(ret != Z_STREAM_ERROR); /* state not clobbered */
+ switch (ret) {
+ case Z_NEED_DICT:
+ ret = Z_DATA_ERROR; /* and fall through */
+ case Z_DATA_ERROR:
+ case Z_MEM_ERROR:
+ (void)inflateEnd(&strm);
+ return ret;
+ }
+</b></pre>
+The output of <tt>inflate()</tt> is handled identically to that of <tt>deflate()</tt>.
+<pre><b>
+ have = CHUNK - strm.avail_out;
+ if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
+ (void)inflateEnd(&strm);
+ return Z_ERRNO;
+ }
+</b></pre>
+The inner <tt>do</tt>-loop ends when <tt>inflate()</tt> has no more output as indicated
+by not filling the output buffer, just as for <tt>deflate()</tt>. In this case, we cannot
+assert that <tt>strm.avail_in</tt> will be zero, since the deflate stream may end before the file
+does.
+<pre><b>
+ } while (strm.avail_out == 0);
+</b></pre><!-- -->
+The outer <tt>do</tt>-loop ends when <tt>inflate()</tt> reports that it has reached the
+end of the input <em>zlib</em> stream, has completed the decompression and integrity
+check, and has provided all of the output. This is indicated by the <tt>inflate()</tt>
+return value <tt>Z_STREAM_END</tt>. The inner loop is guaranteed to leave <tt>ret</tt>
+equal to <tt>Z_STREAM_END</tt> if the last chunk of the input file read contained the end
+of the <em>zlib</em> stream. So if the return value is not <tt>Z_STREAM_END</tt>, the
+loop continues to read more input.
+<pre><b>
+ /* done when inflate() says it's done */
+ } while (ret != Z_STREAM_END);
+</b></pre><!-- -->
+At this point, decompression successfully completed, or we broke out of the loop due to no
+more data being available from the input file. If the last <tt>inflate()</tt> return value
+is not <tt>Z_STREAM_END</tt>, then the <em>zlib</em> stream was incomplete and a data error
+is returned. Otherwise, we return with a happy return value. Of course, <tt>inflateEnd()</tt>
+is called first to avoid a memory leak.
+<pre><b>
+ /* clean up and return */
+ (void)inflateEnd(&strm);
+ return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR;
+}
+</b></pre><!-- -->
+That ends the routines that directly use <em>zlib</em>. The following routines make this
+a command-line program by running data through the above routines from <tt>stdin</tt> to
+<tt>stdout</tt>, and handling any errors reported by <tt>def()</tt> or <tt>inf()</tt>.
+<p>
+<tt>zerr()</tt> is used to interpret the possible error codes from <tt>def()</tt>
+and <tt>inf()</tt>, as detailed in their comments above, and print out an error message.
+Note that these are only a subset of the possible return values from <tt>deflate()</tt>
+and <tt>inflate()</tt>.
+<pre><b>
+/* report a zlib or i/o error */
+void zerr(int ret)
+{
+ fputs("zpipe: ", stderr);
+ switch (ret) {
+ case Z_ERRNO:
+ if (ferror(stdin))
+ fputs("error reading stdin\n", stderr);
+ if (ferror(stdout))
+ fputs("error writing stdout\n", stderr);
+ break;
+ case Z_STREAM_ERROR:
+ fputs("invalid compression level\n", stderr);
+ break;
+ case Z_DATA_ERROR:
+ fputs("invalid or incomplete deflate data\n", stderr);
+ break;
+ case Z_MEM_ERROR:
+ fputs("out of memory\n", stderr);
+ break;
+ case Z_VERSION_ERROR:
+ fputs("zlib version mismatch!\n", stderr);
+ }
+}
+</b></pre><!-- -->
+Here is the <tt>main()</tt> routine used to test <tt>def()</tt> and <tt>inf()</tt>. The
+<tt>zpipe</tt> command is simply a compression pipe from <tt>stdin</tt> to <tt>stdout</tt>, if
+no arguments are given, or it is a decompression pipe if <tt>zpipe -d</tt> is used. If any other
+arguments are provided, no compression or decompression is performed. Instead a usage
+message is displayed. Examples are <tt>zpipe < foo.txt > foo.txt.z</tt> to compress, and
+<tt>zpipe -d < foo.txt.z > foo.txt</tt> to decompress.
+<pre><b>
+/* compress or decompress from stdin to stdout */
+int main(int argc, char **argv)
+{
+ int ret;
+
+ /* avoid end-of-line conversions */
+ SET_BINARY_MODE(stdin);
+ SET_BINARY_MODE(stdout);
+
+ /* do compression if no arguments */
+ if (argc == 1) {
+ ret = def(stdin, stdout, Z_DEFAULT_COMPRESSION);
+ if (ret != Z_OK)
+ zerr(ret);
+ return ret;
+ }
+
+ /* do decompression if -d specified */
+ else if (argc == 2 && strcmp(argv[1], "-d") == 0) {
+ ret = inf(stdin, stdout);
+ if (ret != Z_OK)
+ zerr(ret);
+ return ret;
+ }
+
+ /* otherwise, report usage */
+ else {
+ fputs("zpipe usage: zpipe [-d] < source > dest\n", stderr);
+ return 1;
+ }
+}
+</b></pre>
+<hr>
+<i>Copyright (c) 2004, 2005 by Mark Adler<br>Last modified 11 December 2005</i>
+</body>
+</html>
diff --git a/zlib/examples/zpipe.c b/zlib/examples/zpipe.c
new file mode 100644
index 000000000..83535d169
--- /dev/null
+++ b/zlib/examples/zpipe.c
@@ -0,0 +1,205 @@
+/* zpipe.c: example of proper use of zlib's inflate() and deflate()
+ Not copyrighted -- provided to the public domain
+ Version 1.4 11 December 2005 Mark Adler */
+
+/* Version history:
+ 1.0 30 Oct 2004 First version
+ 1.1 8 Nov 2004 Add void casting for unused return values
+ Use switch statement for inflate() return values
+ 1.2 9 Nov 2004 Add assertions to document zlib guarantees
+ 1.3 6 Apr 2005 Remove incorrect assertion in inf()
+ 1.4 11 Dec 2005 Add hack to avoid MSDOS end-of-line conversions
+ Avoid some compiler warnings for input and output buffers
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <assert.h>
+#include "zlib.h"
+
+#if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__)
+# include <fcntl.h>
+# include <io.h>
+# define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
+#else
+# define SET_BINARY_MODE(file)
+#endif
+
+#define CHUNK 16384
+
+/* Compress from file source to file dest until EOF on source.
+ def() returns Z_OK on success, Z_MEM_ERROR if memory could not be
+ allocated for processing, Z_STREAM_ERROR if an invalid compression
+ level is supplied, Z_VERSION_ERROR if the version of zlib.h and the
+ version of the library linked do not match, or Z_ERRNO if there is
+ an error reading or writing the files. */
+int def(FILE *source, FILE *dest, int level)
+{
+ int ret, flush;
+ unsigned have;
+ z_stream strm;
+ unsigned char in[CHUNK];
+ unsigned char out[CHUNK];
+
+ /* allocate deflate state */
+ strm.zalloc = Z_NULL;
+ strm.zfree = Z_NULL;
+ strm.opaque = Z_NULL;
+ ret = deflateInit(&strm, level);
+ if (ret != Z_OK)
+ return ret;
+
+ /* compress until end of file */
+ do {
+ strm.avail_in = fread(in, 1, CHUNK, source);
+ if (ferror(source)) {
+ (void)deflateEnd(&strm);
+ return Z_ERRNO;
+ }
+ flush = feof(source) ? Z_FINISH : Z_NO_FLUSH;
+ strm.next_in = in;
+
+ /* run deflate() on input until output buffer not full, finish
+ compression if all of source has been read in */
+ do {
+ strm.avail_out = CHUNK;
+ strm.next_out = out;
+ ret = deflate(&strm, flush); /* no bad return value */
+ assert(ret != Z_STREAM_ERROR); /* state not clobbered */
+ have = CHUNK - strm.avail_out;
+ if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
+ (void)deflateEnd(&strm);
+ return Z_ERRNO;
+ }
+ } while (strm.avail_out == 0);
+ assert(strm.avail_in == 0); /* all input will be used */
+
+ /* done when last data in file processed */
+ } while (flush != Z_FINISH);
+ assert(ret == Z_STREAM_END); /* stream will be complete */
+
+ /* clean up and return */
+ (void)deflateEnd(&strm);
+ return Z_OK;
+}
+
+/* Decompress from file source to file dest until stream ends or EOF.
+ inf() returns Z_OK on success, Z_MEM_ERROR if memory could not be
+ allocated for processing, Z_DATA_ERROR if the deflate data is
+ invalid or incomplete, Z_VERSION_ERROR if the version of zlib.h and
+ the version of the library linked do not match, or Z_ERRNO if there
+ is an error reading or writing the files. */
+int inf(FILE *source, FILE *dest)
+{
+ int ret;
+ unsigned have;
+ z_stream strm;
+ unsigned char in[CHUNK];
+ unsigned char out[CHUNK];
+
+ /* allocate inflate state */
+ strm.zalloc = Z_NULL;
+ strm.zfree = Z_NULL;
+ strm.opaque = Z_NULL;
+ strm.avail_in = 0;
+ strm.next_in = Z_NULL;
+ ret = inflateInit(&strm);
+ if (ret != Z_OK)
+ return ret;
+
+ /* decompress until deflate stream ends or end of file */
+ do {
+ strm.avail_in = fread(in, 1, CHUNK, source);
+ if (ferror(source)) {
+ (void)inflateEnd(&strm);
+ return Z_ERRNO;
+ }
+ if (strm.avail_in == 0)
+ break;
+ strm.next_in = in;
+
+ /* run inflate() on input until output buffer not full */
+ do {
+ strm.avail_out = CHUNK;
+ strm.next_out = out;
+ ret = inflate(&strm, Z_NO_FLUSH);
+ assert(ret != Z_STREAM_ERROR); /* state not clobbered */
+ switch (ret) {
+ case Z_NEED_DICT:
+ ret = Z_DATA_ERROR; /* and fall through */
+ case Z_DATA_ERROR:
+ case Z_MEM_ERROR:
+ (void)inflateEnd(&strm);
+ return ret;
+ }
+ have = CHUNK - strm.avail_out;
+ if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
+ (void)inflateEnd(&strm);
+ return Z_ERRNO;
+ }
+ } while (strm.avail_out == 0);
+
+ /* done when inflate() says it's done */
+ } while (ret != Z_STREAM_END);
+
+ /* clean up and return */
+ (void)inflateEnd(&strm);
+ return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR;
+}
+
+/* report a zlib or i/o error */
+void zerr(int ret)
+{
+ fputs("zpipe: ", stderr);
+ switch (ret) {
+ case Z_ERRNO:
+ if (ferror(stdin))
+ fputs("error reading stdin\n", stderr);
+ if (ferror(stdout))
+ fputs("error writing stdout\n", stderr);
+ break;
+ case Z_STREAM_ERROR:
+ fputs("invalid compression level\n", stderr);
+ break;
+ case Z_DATA_ERROR:
+ fputs("invalid or incomplete deflate data\n", stderr);
+ break;
+ case Z_MEM_ERROR:
+ fputs("out of memory\n", stderr);
+ break;
+ case Z_VERSION_ERROR:
+ fputs("zlib version mismatch!\n", stderr);
+ }
+}
+
+/* compress or decompress from stdin to stdout */
+int main(int argc, char **argv)
+{
+ int ret;
+
+ /* avoid end-of-line conversions */
+ SET_BINARY_MODE(stdin);
+ SET_BINARY_MODE(stdout);
+
+ /* do compression if no arguments */
+ if (argc == 1) {
+ ret = def(stdin, stdout, Z_DEFAULT_COMPRESSION);
+ if (ret != Z_OK)
+ zerr(ret);
+ return ret;
+ }
+
+ /* do decompression if -d specified */
+ else if (argc == 2 && strcmp(argv[1], "-d") == 0) {
+ ret = inf(stdin, stdout);
+ if (ret != Z_OK)
+ zerr(ret);
+ return ret;
+ }
+
+ /* otherwise, report usage */
+ else {
+ fputs("zpipe usage: zpipe [-d] < source > dest\n", stderr);
+ return 1;
+ }
+}
diff --git a/zlib/examples/zran.c b/zlib/examples/zran.c
new file mode 100644
index 000000000..4fec6594a
--- /dev/null
+++ b/zlib/examples/zran.c
@@ -0,0 +1,409 @@
+/* zran.c -- example of zlib/gzip stream indexing and random access
+ * Copyright (C) 2005, 2012 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ Version 1.1 29 Sep 2012 Mark Adler */
+
+/* Version History:
+ 1.0 29 May 2005 First version
+ 1.1 29 Sep 2012 Fix memory reallocation error
+ */
+
+/* Illustrate the use of Z_BLOCK, inflatePrime(), and inflateSetDictionary()
+ for random access of a compressed file. A file containing a zlib or gzip
+ stream is provided on the command line. The compressed stream is decoded in
+ its entirety, and an index built with access points about every SPAN bytes
+ in the uncompressed output. The compressed file is left open, and can then
+ be read randomly, having to decompress on the average SPAN/2 uncompressed
+ bytes before getting to the desired block of data.
+
+ An access point can be created at the start of any deflate block, by saving
+ the starting file offset and bit of that block, and the 32K bytes of
+ uncompressed data that precede that block. Also the uncompressed offset of
+ that block is saved to provide a referece for locating a desired starting
+ point in the uncompressed stream. build_index() works by decompressing the
+ input zlib or gzip stream a block at a time, and at the end of each block
+ deciding if enough uncompressed data has gone by to justify the creation of
+ a new access point. If so, that point is saved in a data structure that
+ grows as needed to accommodate the points.
+
+ To use the index, an offset in the uncompressed data is provided, for which
+ the latest access point at or preceding that offset is located in the index.
+ The input file is positioned to the specified location in the index, and if
+ necessary the first few bits of the compressed data is read from the file.
+ inflate is initialized with those bits and the 32K of uncompressed data, and
+ the decompression then proceeds until the desired offset in the file is
+ reached. Then the decompression continues to read the desired uncompressed
+ data from the file.
+
+ Another approach would be to generate the index on demand. In that case,
+ requests for random access reads from the compressed data would try to use
+ the index, but if a read far enough past the end of the index is required,
+ then further index entries would be generated and added.
+
+ There is some fair bit of overhead to starting inflation for the random
+ access, mainly copying the 32K byte dictionary. So if small pieces of the
+ file are being accessed, it would make sense to implement a cache to hold
+ some lookahead and avoid many calls to extract() for small lengths.
+
+ Another way to build an index would be to use inflateCopy(). That would
+ not be constrained to have access points at block boundaries, but requires
+ more memory per access point, and also cannot be saved to file due to the
+ use of pointers in the state. The approach here allows for storage of the
+ index in a file.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include "zlib.h"
+
+#define local static
+
+#define SPAN 1048576L /* desired distance between access points */
+#define WINSIZE 32768U /* sliding window size */
+#define CHUNK 16384 /* file input buffer size */
+
+/* access point entry */
+struct point {
+ off_t out; /* corresponding offset in uncompressed data */
+ off_t in; /* offset in input file of first full byte */
+ int bits; /* number of bits (1-7) from byte at in - 1, or 0 */
+ unsigned char window[WINSIZE]; /* preceding 32K of uncompressed data */
+};
+
+/* access point list */
+struct access {
+ int have; /* number of list entries filled in */
+ int size; /* number of list entries allocated */
+ struct point *list; /* allocated list */
+};
+
+/* Deallocate an index built by build_index() */
+local void free_index(struct access *index)
+{
+ if (index != NULL) {
+ free(index->list);
+ free(index);
+ }
+}
+
+/* Add an entry to the access point list. If out of memory, deallocate the
+ existing list and return NULL. */
+local struct access *addpoint(struct access *index, int bits,
+ off_t in, off_t out, unsigned left, unsigned char *window)
+{
+ struct point *next;
+
+ /* if list is empty, create it (start with eight points) */
+ if (index == NULL) {
+ index = malloc(sizeof(struct access));
+ if (index == NULL) return NULL;
+ index->list = malloc(sizeof(struct point) << 3);
+ if (index->list == NULL) {
+ free(index);
+ return NULL;
+ }
+ index->size = 8;
+ index->have = 0;
+ }
+
+ /* if list is full, make it bigger */
+ else if (index->have == index->size) {
+ index->size <<= 1;
+ next = realloc(index->list, sizeof(struct point) * index->size);
+ if (next == NULL) {
+ free_index(index);
+ return NULL;
+ }
+ index->list = next;
+ }
+
+ /* fill in entry and increment how many we have */
+ next = index->list + index->have;
+ next->bits = bits;
+ next->in = in;
+ next->out = out;
+ if (left)
+ memcpy(next->window, window + WINSIZE - left, left);
+ if (left < WINSIZE)
+ memcpy(next->window + left, window, WINSIZE - left);
+ index->have++;
+
+ /* return list, possibly reallocated */
+ return index;
+}
+
+/* Make one entire pass through the compressed stream and build an index, with
+ access points about every span bytes of uncompressed output -- span is
+ chosen to balance the speed of random access against the memory requirements
+ of the list, about 32K bytes per access point. Note that data after the end
+ of the first zlib or gzip stream in the file is ignored. build_index()
+ returns the number of access points on success (>= 1), Z_MEM_ERROR for out
+ of memory, Z_DATA_ERROR for an error in the input file, or Z_ERRNO for a
+ file read error. On success, *built points to the resulting index. */
+local int build_index(FILE *in, off_t span, struct access **built)
+{
+ int ret;
+ off_t totin, totout; /* our own total counters to avoid 4GB limit */
+ off_t last; /* totout value of last access point */
+ struct access *index; /* access points being generated */
+ z_stream strm;
+ unsigned char input[CHUNK];
+ unsigned char window[WINSIZE];
+
+ /* initialize inflate */
+ strm.zalloc = Z_NULL;
+ strm.zfree = Z_NULL;
+ strm.opaque = Z_NULL;
+ strm.avail_in = 0;
+ strm.next_in = Z_NULL;
+ ret = inflateInit2(&strm, 47); /* automatic zlib or gzip decoding */
+ if (ret != Z_OK)
+ return ret;
+
+ /* inflate the input, maintain a sliding window, and build an index -- this
+ also validates the integrity of the compressed data using the check
+ information at the end of the gzip or zlib stream */
+ totin = totout = last = 0;
+ index = NULL; /* will be allocated by first addpoint() */
+ strm.avail_out = 0;
+ do {
+ /* get some compressed data from input file */
+ strm.avail_in = fread(input, 1, CHUNK, in);
+ if (ferror(in)) {
+ ret = Z_ERRNO;
+ goto build_index_error;
+ }
+ if (strm.avail_in == 0) {
+ ret = Z_DATA_ERROR;
+ goto build_index_error;
+ }
+ strm.next_in = input;
+
+ /* process all of that, or until end of stream */
+ do {
+ /* reset sliding window if necessary */
+ if (strm.avail_out == 0) {
+ strm.avail_out = WINSIZE;
+ strm.next_out = window;
+ }
+
+ /* inflate until out of input, output, or at end of block --
+ update the total input and output counters */
+ totin += strm.avail_in;
+ totout += strm.avail_out;
+ ret = inflate(&strm, Z_BLOCK); /* return at end of block */
+ totin -= strm.avail_in;
+ totout -= strm.avail_out;
+ if (ret == Z_NEED_DICT)
+ ret = Z_DATA_ERROR;
+ if (ret == Z_MEM_ERROR || ret == Z_DATA_ERROR)
+ goto build_index_error;
+ if (ret == Z_STREAM_END)
+ break;
+
+ /* if at end of block, consider adding an index entry (note that if
+ data_type indicates an end-of-block, then all of the
+ uncompressed data from that block has been delivered, and none
+ of the compressed data after that block has been consumed,
+ except for up to seven bits) -- the totout == 0 provides an
+ entry point after the zlib or gzip header, and assures that the
+ index always has at least one access point; we avoid creating an
+ access point after the last block by checking bit 6 of data_type
+ */
+ if ((strm.data_type & 128) && !(strm.data_type & 64) &&
+ (totout == 0 || totout - last > span)) {
+ index = addpoint(index, strm.data_type & 7, totin,
+ totout, strm.avail_out, window);
+ if (index == NULL) {
+ ret = Z_MEM_ERROR;
+ goto build_index_error;
+ }
+ last = totout;
+ }
+ } while (strm.avail_in != 0);
+ } while (ret != Z_STREAM_END);
+
+ /* clean up and return index (release unused entries in list) */
+ (void)inflateEnd(&strm);
+ index->list = realloc(index->list, sizeof(struct point) * index->have);
+ index->size = index->have;
+ *built = index;
+ return index->size;
+
+ /* return error */
+ build_index_error:
+ (void)inflateEnd(&strm);
+ if (index != NULL)
+ free_index(index);
+ return ret;
+}
+
+/* Use the index to read len bytes from offset into buf, return bytes read or
+ negative for error (Z_DATA_ERROR or Z_MEM_ERROR). If data is requested past
+ the end of the uncompressed data, then extract() will return a value less
+ than len, indicating how much as actually read into buf. This function
+ should not return a data error unless the file was modified since the index
+ was generated. extract() may also return Z_ERRNO if there is an error on
+ reading or seeking the input file. */
+local int extract(FILE *in, struct access *index, off_t offset,
+ unsigned char *buf, int len)
+{
+ int ret, skip;
+ z_stream strm;
+ struct point *here;
+ unsigned char input[CHUNK];
+ unsigned char discard[WINSIZE];
+
+ /* proceed only if something reasonable to do */
+ if (len < 0)
+ return 0;
+
+ /* find where in stream to start */
+ here = index->list;
+ ret = index->have;
+ while (--ret && here[1].out <= offset)
+ here++;
+
+ /* initialize file and inflate state to start there */
+ strm.zalloc = Z_NULL;
+ strm.zfree = Z_NULL;
+ strm.opaque = Z_NULL;
+ strm.avail_in = 0;
+ strm.next_in = Z_NULL;
+ ret = inflateInit2(&strm, -15); /* raw inflate */
+ if (ret != Z_OK)
+ return ret;
+ ret = fseeko(in, here->in - (here->bits ? 1 : 0), SEEK_SET);
+ if (ret == -1)
+ goto extract_ret;
+ if (here->bits) {
+ ret = getc(in);
+ if (ret == -1) {
+ ret = ferror(in) ? Z_ERRNO : Z_DATA_ERROR;
+ goto extract_ret;
+ }
+ (void)inflatePrime(&strm, here->bits, ret >> (8 - here->bits));
+ }
+ (void)inflateSetDictionary(&strm, here->window, WINSIZE);
+
+ /* skip uncompressed bytes until offset reached, then satisfy request */
+ offset -= here->out;
+ strm.avail_in = 0;
+ skip = 1; /* while skipping to offset */
+ do {
+ /* define where to put uncompressed data, and how much */
+ if (offset == 0 && skip) { /* at offset now */
+ strm.avail_out = len;
+ strm.next_out = buf;
+ skip = 0; /* only do this once */
+ }
+ if (offset > WINSIZE) { /* skip WINSIZE bytes */
+ strm.avail_out = WINSIZE;
+ strm.next_out = discard;
+ offset -= WINSIZE;
+ }
+ else if (offset != 0) { /* last skip */
+ strm.avail_out = (unsigned)offset;
+ strm.next_out = discard;
+ offset = 0;
+ }
+
+ /* uncompress until avail_out filled, or end of stream */
+ do {
+ if (strm.avail_in == 0) {
+ strm.avail_in = fread(input, 1, CHUNK, in);
+ if (ferror(in)) {
+ ret = Z_ERRNO;
+ goto extract_ret;
+ }
+ if (strm.avail_in == 0) {
+ ret = Z_DATA_ERROR;
+ goto extract_ret;
+ }
+ strm.next_in = input;
+ }
+ ret = inflate(&strm, Z_NO_FLUSH); /* normal inflate */
+ if (ret == Z_NEED_DICT)
+ ret = Z_DATA_ERROR;
+ if (ret == Z_MEM_ERROR || ret == Z_DATA_ERROR)
+ goto extract_ret;
+ if (ret == Z_STREAM_END)
+ break;
+ } while (strm.avail_out != 0);
+
+ /* if reach end of stream, then don't keep trying to get more */
+ if (ret == Z_STREAM_END)
+ break;
+
+ /* do until offset reached and requested data read, or stream ends */
+ } while (skip);
+
+ /* compute number of uncompressed bytes read after offset */
+ ret = skip ? 0 : len - strm.avail_out;
+
+ /* clean up and return bytes read or error */
+ extract_ret:
+ (void)inflateEnd(&strm);
+ return ret;
+}
+
+/* Demonstrate the use of build_index() and extract() by processing the file
+ provided on the command line, and the extracting 16K from about 2/3rds of
+ the way through the uncompressed output, and writing that to stdout. */
+int main(int argc, char **argv)
+{
+ int len;
+ off_t offset;
+ FILE *in;
+ struct access *index = NULL;
+ unsigned char buf[CHUNK];
+
+ /* open input file */
+ if (argc != 2) {
+ fprintf(stderr, "usage: zran file.gz\n");
+ return 1;
+ }
+ in = fopen(argv[1], "rb");
+ if (in == NULL) {
+ fprintf(stderr, "zran: could not open %s for reading\n", argv[1]);
+ return 1;
+ }
+
+ /* build index */
+ len = build_index(in, SPAN, &index);
+ if (len < 0) {
+ fclose(in);
+ switch (len) {
+ case Z_MEM_ERROR:
+ fprintf(stderr, "zran: out of memory\n");
+ break;
+ case Z_DATA_ERROR:
+ fprintf(stderr, "zran: compressed data error in %s\n", argv[1]);
+ break;
+ case Z_ERRNO:
+ fprintf(stderr, "zran: read error on %s\n", argv[1]);
+ break;
+ default:
+ fprintf(stderr, "zran: error %d while building index\n", len);
+ }
+ return 1;
+ }
+ fprintf(stderr, "zran: built index with %d access points\n", len);
+
+ /* use index by reading some bytes from an arbitrary offset */
+ offset = (index->list[index->have - 1].out << 1) / 3;
+ len = extract(in, index, offset, buf, CHUNK);
+ if (len < 0)
+ fprintf(stderr, "zran: extraction failed: %s error\n",
+ len == Z_MEM_ERROR ? "out of memory" : "input corrupted");
+ else {
+ fwrite(buf, 1, len, stdout);
+ fprintf(stderr, "zran: extracted %d bytes at %llu\n", len, offset);
+ }
+
+ /* clean up and exit */
+ free_index(index);
+ fclose(in);
+ return 0;
+}
diff --git a/zlib/gzclose.c b/zlib/gzclose.c
new file mode 100644
index 000000000..caeb99a31
--- /dev/null
+++ b/zlib/gzclose.c
@@ -0,0 +1,25 @@
+/* gzclose.c -- zlib gzclose() function
+ * Copyright (C) 2004, 2010 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "gzguts.h"
+
+/* gzclose() is in a separate file so that it is linked in only if it is used.
+ That way the other gzclose functions can be used instead to avoid linking in
+ unneeded compression or decompression routines. */
+int ZEXPORT gzclose(file)
+ gzFile file;
+{
+#ifndef NO_GZCOMPRESS
+ gz_statep state;
+
+ if (file == NULL)
+ return Z_STREAM_ERROR;
+ state = (gz_statep)file;
+
+ return state->mode == GZ_READ ? gzclose_r(file) : gzclose_w(file);
+#else
+ return gzclose_r(file);
+#endif
+}
diff --git a/zlib/gzguts.h b/zlib/gzguts.h
new file mode 100644
index 000000000..aefbbd887
--- /dev/null
+++ b/zlib/gzguts.h
@@ -0,0 +1,219 @@
+/* gzguts.h -- zlib internal header definitions for gz* operations
+ * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 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 <stdio.h>
+#include "zlib.h"
+#ifdef STDC
+# include <string.h>
+# include <stdlib.h>
+# include <limits.h>
+# include <unistd.h>
+#endif
+
+#ifndef _POSIX_SOURCE
+# define _POSIX_SOURCE
+#endif
+#include <fcntl.h>
+
+#ifdef _WIN32
+# include <stddef.h>
+#endif
+
+#if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32)
+# include <io.h>
+#endif
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+# define WIDECHAR
+#endif
+
+#ifdef WINAPI_FAMILY
+# define open _open
+# define read _read
+# define write _write
+# define close _close
+#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
+
+/* unlike snprintf (which is required in C99), _snprintf does not guarantee
+ null termination of the result -- however this is only used in gzlib.c where
+ the result is assured to fit in the space provided */
+#if defined(_MSC_VER) && _MSC_VER < 1900
+# define snprintf _snprintf
+#endif
+
+#ifndef local
+# define local static
+#endif
+/* since "static" is used to mean two completely different things in C, we
+ define "local" for the non-static meaning of "static", for readability
+ (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 <windows.h>
+# define zstrerror() gz_strwinerror((DWORD)GetLastError())
+#else
+# ifndef NO_STRERROR
+# include <errno.h>
+# 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 (this and
+ twice this must be able to fit in an unsigned type) */
+#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 (double-sized when writing) */
+ 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/gzlib.c b/zlib/gzlib.c
new file mode 100644
index 000000000..4105e6aff
--- /dev/null
+++ b/zlib/gzlib.c
@@ -0,0 +1,637 @@
+/* gzlib.c -- zlib functions common to reading and writing gzip files
+ * Copyright (C) 2004-2017 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "gzguts.h"
+
+#if defined(_WIN32) && !defined(__BORLANDC__) && !defined(__MINGW32__)
+# define LSEEK _lseeki64
+#else
+#if defined(_LARGEFILE64_SOURCE) && _LFS64_LARGEFILE-0
+# define LSEEK lseek64
+#else
+# define LSEEK lseek
+#endif
+#endif
+
+/* Local functions */
+local void gz_reset OF((gz_statep));
+local gzFile gz_open OF((const void *, int, const char *));
+
+#if defined UNDER_CE
+
+/* Map the Windows error number in ERROR to a locale-dependent error message
+ string and return a pointer to it. Typically, the values for ERROR come
+ from GetLastError.
+
+ The string pointed to shall not be modified by the application, but may be
+ overwritten by a subsequent call to gz_strwinerror
+
+ The gz_strwinerror function does not change the current setting of
+ GetLastError. */
+char ZLIB_INTERNAL *gz_strwinerror (error)
+ DWORD error;
+{
+ static char buf[1024];
+
+ wchar_t *msgbuf;
+ DWORD lasterr = GetLastError();
+ DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM
+ | FORMAT_MESSAGE_ALLOCATE_BUFFER,
+ NULL,
+ error,
+ 0, /* Default language */
+ (LPVOID)&msgbuf,
+ 0,
+ NULL);
+ if (chars != 0) {
+ /* If there is an \r\n appended, zap it. */
+ if (chars >= 2
+ && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') {
+ chars -= 2;
+ msgbuf[chars] = 0;
+ }
+
+ if (chars > sizeof (buf) - 1) {
+ chars = sizeof (buf) - 1;
+ msgbuf[chars] = 0;
+ }
+
+ wcstombs(buf, msgbuf, chars + 1);
+ LocalFree(msgbuf);
+ }
+ else {
+ sprintf(buf, "unknown win32 error (%ld)", error);
+ }
+
+ SetLastError(lasterr);
+ return buf;
+}
+
+#endif /* UNDER_CE */
+
+/* Reset gzip file state */
+local void gz_reset(state)
+ gz_statep state;
+{
+ state->x.have = 0; /* no output data available */
+ if (state->mode == GZ_READ) { /* for reading ... */
+ state->eof = 0; /* not at end of file */
+ state->past = 0; /* have not read past end yet */
+ state->how = LOOK; /* look for gzip header */
+ }
+ state->seek = 0; /* no seek request pending */
+ gz_error(state, Z_OK, NULL); /* clear error */
+ state->x.pos = 0; /* no uncompressed data yet */
+ state->strm.avail_in = 0; /* no input data yet */
+}
+
+/* Open a gzip file either by name or file descriptor. */
+local gzFile gz_open(path, fd, mode)
+ const void *path;
+ int fd;
+ const char *mode;
+{
+ gz_statep state;
+ z_size_t len;
+ int oflag;
+#ifdef O_CLOEXEC
+ int cloexec = 0;
+#endif
+#ifdef O_EXCL
+ int exclusive = 0;
+#endif
+
+ /* check input */
+ if (path == NULL)
+ return NULL;
+
+ /* allocate gzFile structure to return */
+ state = (gz_statep)malloc(sizeof(gz_state));
+ if (state == NULL)
+ return NULL;
+ state->size = 0; /* no buffers allocated yet */
+ state->want = GZBUFSIZE; /* requested buffer size */
+ state->msg = NULL; /* no error message yet */
+
+ /* interpret mode */
+ state->mode = GZ_NONE;
+ state->level = Z_DEFAULT_COMPRESSION;
+ state->strategy = Z_DEFAULT_STRATEGY;
+ state->direct = 0;
+ while (*mode) {
+ if (*mode >= '0' && *mode <= '9')
+ state->level = *mode - '0';
+ else
+ switch (*mode) {
+ case 'r':
+ state->mode = GZ_READ;
+ break;
+#ifndef NO_GZCOMPRESS
+ case 'w':
+ state->mode = GZ_WRITE;
+ break;
+ case 'a':
+ state->mode = GZ_APPEND;
+ break;
+#endif
+ case '+': /* can't read and write at the same time */
+ free(state);
+ return NULL;
+ case 'b': /* ignore -- will request binary anyway */
+ break;
+#ifdef O_CLOEXEC
+ case 'e':
+ cloexec = 1;
+ break;
+#endif
+#ifdef O_EXCL
+ case 'x':
+ exclusive = 1;
+ break;
+#endif
+ case 'f':
+ state->strategy = Z_FILTERED;
+ break;
+ case 'h':
+ state->strategy = Z_HUFFMAN_ONLY;
+ break;
+ case 'R':
+ state->strategy = Z_RLE;
+ break;
+ case 'F':
+ state->strategy = Z_FIXED;
+ break;
+ case 'T':
+ state->direct = 1;
+ break;
+ default: /* could consider as an error, but just ignore */
+ ;
+ }
+ mode++;
+ }
+
+ /* must provide an "r", "w", or "a" */
+ if (state->mode == GZ_NONE) {
+ free(state);
+ return NULL;
+ }
+
+ /* can't force transparent read */
+ if (state->mode == GZ_READ) {
+ if (state->direct) {
+ free(state);
+ return NULL;
+ }
+ state->direct = 1; /* for empty file */
+ }
+
+ /* save the path name for error messages */
+#ifdef WIDECHAR
+ if (fd == -2) {
+ len = wcstombs(NULL, path, 0);
+ if (len == (z_size_t)-1)
+ len = 0;
+ }
+ else
+#endif
+ len = strlen((const char *)path);
+ state->path = (char *)malloc(len + 1);
+ if (state->path == NULL) {
+ free(state);
+ return NULL;
+ }
+#ifdef WIDECHAR
+ if (fd == -2)
+ if (len)
+ wcstombs(state->path, path, len + 1);
+ else
+ *(state->path) = 0;
+ else
+#endif
+#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
+ (void)snprintf(state->path, len + 1, "%s", (const char *)path);
+#else
+ strcpy(state->path, path);
+#endif
+
+ /* compute the flags for open() */
+ oflag =
+#ifdef O_LARGEFILE
+ O_LARGEFILE |
+#endif
+#ifdef O_BINARY
+ O_BINARY |
+#endif
+#ifdef O_CLOEXEC
+ (cloexec ? O_CLOEXEC : 0) |
+#endif
+ (state->mode == GZ_READ ?
+ O_RDONLY :
+ (O_WRONLY | O_CREAT |
+#ifdef O_EXCL
+ (exclusive ? O_EXCL : 0) |
+#endif
+ (state->mode == GZ_WRITE ?
+ O_TRUNC :
+ O_APPEND)));
+
+ /* open the file with the appropriate flags (or just use fd) */
+ state->fd = fd > -1 ? fd : (
+#ifdef WIDECHAR
+ fd == -2 ? _wopen(path, oflag, 0666) :
+#endif
+ open((const char *)path, oflag, 0666));
+ if (state->fd == -1) {
+ free(state->path);
+ free(state);
+ return NULL;
+ }
+ if (state->mode == GZ_APPEND) {
+ LSEEK(state->fd, 0, SEEK_END); /* so gzoffset() is correct */
+ state->mode = GZ_WRITE; /* simplify later checks */
+ }
+
+ /* save the current position for rewinding (only if reading) */
+ if (state->mode == GZ_READ) {
+ state->start = LSEEK(state->fd, 0, SEEK_CUR);
+ if (state->start == -1) state->start = 0;
+ }
+
+ /* initialize stream */
+ gz_reset(state);
+
+ /* return stream */
+ return (gzFile)state;
+}
+
+/* -- see zlib.h -- */
+gzFile ZEXPORT gzopen(path, mode)
+ const char *path;
+ const char *mode;
+{
+ return gz_open(path, -1, mode);
+}
+
+/* -- see zlib.h -- */
+gzFile ZEXPORT gzopen64(path, mode)
+ const char *path;
+ const char *mode;
+{
+ return gz_open(path, -1, mode);
+}
+
+/* -- see zlib.h -- */
+gzFile ZEXPORT gzdopen(fd, mode)
+ int fd;
+ const char *mode;
+{
+ char *path; /* identifier for error messages */
+ gzFile gz;
+
+ if (fd == -1 || (path = (char *)malloc(7 + 3 * sizeof(int))) == NULL)
+ return NULL;
+#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
+ (void)snprintf(path, 7 + 3 * sizeof(int), "<fd:%d>", fd);
+#else
+ sprintf(path, "<fd:%d>", fd); /* for debugging */
+#endif
+ gz = gz_open(path, fd, mode);
+ free(path);
+ return gz;
+}
+
+/* -- see zlib.h -- */
+#ifdef WIDECHAR
+gzFile ZEXPORT gzopen_w(path, mode)
+ const wchar_t *path;
+ const char *mode;
+{
+ return gz_open(path, -2, mode);
+}
+#endif
+
+/* -- see zlib.h -- */
+int ZEXPORT gzbuffer(file, size)
+ gzFile file;
+ unsigned size;
+{
+ gz_statep state;
+
+ /* get internal structure and check integrity */
+ if (file == NULL)
+ return -1;
+ state = (gz_statep)file;
+ if (state->mode != GZ_READ && state->mode != GZ_WRITE)
+ return -1;
+
+ /* make sure we haven't already allocated memory */
+ if (state->size != 0)
+ return -1;
+
+ /* check and set requested size */
+ if ((size << 1) < size)
+ return -1; /* need to be able to double it */
+ if (size < 2)
+ size = 2; /* need two bytes to check magic header */
+ state->want = size;
+ return 0;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzrewind(file)
+ gzFile file;
+{
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return -1;
+ state = (gz_statep)file;
+
+ /* check that we're reading and that there's no error */
+ if (state->mode != GZ_READ ||
+ (state->err != Z_OK && state->err != Z_BUF_ERROR))
+ return -1;
+
+ /* back up and start over */
+ if (LSEEK(state->fd, state->start, SEEK_SET) == -1)
+ return -1;
+ gz_reset(state);
+ return 0;
+}
+
+/* -- see zlib.h -- */
+z_off64_t ZEXPORT gzseek64(file, offset, whence)
+ gzFile file;
+ z_off64_t offset;
+ int whence;
+{
+ unsigned n;
+ z_off64_t ret;
+ gz_statep state;
+
+ /* get internal structure and check integrity */
+ if (file == NULL)
+ return -1;
+ state = (gz_statep)file;
+ if (state->mode != GZ_READ && state->mode != GZ_WRITE)
+ return -1;
+
+ /* check that there's no error */
+ if (state->err != Z_OK && state->err != Z_BUF_ERROR)
+ return -1;
+
+ /* can only seek from start or relative to current position */
+ if (whence != SEEK_SET && whence != SEEK_CUR)
+ return -1;
+
+ /* normalize offset to a SEEK_CUR specification */
+ if (whence == SEEK_SET)
+ offset -= state->x.pos;
+ else if (state->seek)
+ offset += state->skip;
+ state->seek = 0;
+
+ /* if within raw area while reading, just go there */
+ if (state->mode == GZ_READ && state->how == COPY &&
+ state->x.pos + offset >= 0) {
+ ret = LSEEK(state->fd, offset - state->x.have, SEEK_CUR);
+ if (ret == -1)
+ return -1;
+ state->x.have = 0;
+ state->eof = 0;
+ state->past = 0;
+ state->seek = 0;
+ gz_error(state, Z_OK, NULL);
+ state->strm.avail_in = 0;
+ state->x.pos += offset;
+ return state->x.pos;
+ }
+
+ /* calculate skip amount, rewinding if needed for back seek when reading */
+ if (offset < 0) {
+ if (state->mode != GZ_READ) /* writing -- can't go backwards */
+ return -1;
+ offset += state->x.pos;
+ if (offset < 0) /* before start of file! */
+ return -1;
+ if (gzrewind(file) == -1) /* rewind, then skip to offset */
+ return -1;
+ }
+
+ /* if reading, skip what's in output buffer (one less gzgetc() check) */
+ if (state->mode == GZ_READ) {
+ n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > offset ?
+ (unsigned)offset : state->x.have;
+ state->x.have -= n;
+ state->x.next += n;
+ state->x.pos += n;
+ offset -= n;
+ }
+
+ /* request skip (if not zero) */
+ if (offset) {
+ state->seek = 1;
+ state->skip = offset;
+ }
+ return state->x.pos + offset;
+}
+
+/* -- see zlib.h -- */
+z_off_t ZEXPORT gzseek(file, offset, whence)
+ gzFile file;
+ z_off_t offset;
+ int whence;
+{
+ z_off64_t ret;
+
+ ret = gzseek64(file, (z_off64_t)offset, whence);
+ return ret == (z_off_t)ret ? (z_off_t)ret : -1;
+}
+
+/* -- see zlib.h -- */
+z_off64_t ZEXPORT gztell64(file)
+ gzFile file;
+{
+ gz_statep state;
+
+ /* get internal structure and check integrity */
+ if (file == NULL)
+ return -1;
+ state = (gz_statep)file;
+ if (state->mode != GZ_READ && state->mode != GZ_WRITE)
+ return -1;
+
+ /* return position */
+ return state->x.pos + (state->seek ? state->skip : 0);
+}
+
+/* -- see zlib.h -- */
+z_off_t ZEXPORT gztell(file)
+ gzFile file;
+{
+ z_off64_t ret;
+
+ ret = gztell64(file);
+ return ret == (z_off_t)ret ? (z_off_t)ret : -1;
+}
+
+/* -- see zlib.h -- */
+z_off64_t ZEXPORT gzoffset64(file)
+ gzFile file;
+{
+ z_off64_t offset;
+ gz_statep state;
+
+ /* get internal structure and check integrity */
+ if (file == NULL)
+ return -1;
+ state = (gz_statep)file;
+ if (state->mode != GZ_READ && state->mode != GZ_WRITE)
+ return -1;
+
+ /* compute and return effective offset in file */
+ offset = LSEEK(state->fd, 0, SEEK_CUR);
+ if (offset == -1)
+ return -1;
+ if (state->mode == GZ_READ) /* reading */
+ offset -= state->strm.avail_in; /* don't count buffered input */
+ return offset;
+}
+
+/* -- see zlib.h -- */
+z_off_t ZEXPORT gzoffset(file)
+ gzFile file;
+{
+ z_off64_t ret;
+
+ ret = gzoffset64(file);
+ return ret == (z_off_t)ret ? (z_off_t)ret : -1;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzeof(file)
+ gzFile file;
+{
+ gz_statep state;
+
+ /* get internal structure and check integrity */
+ if (file == NULL)
+ return 0;
+ state = (gz_statep)file;
+ if (state->mode != GZ_READ && state->mode != GZ_WRITE)
+ return 0;
+
+ /* return end-of-file state */
+ return state->mode == GZ_READ ? state->past : 0;
+}
+
+/* -- see zlib.h -- */
+const char * ZEXPORT gzerror(file, errnum)
+ gzFile file;
+ int *errnum;
+{
+ gz_statep state;
+
+ /* get internal structure and check integrity */
+ if (file == NULL)
+ return NULL;
+ state = (gz_statep)file;
+ if (state->mode != GZ_READ && state->mode != GZ_WRITE)
+ return NULL;
+
+ /* return error information */
+ if (errnum != NULL)
+ *errnum = state->err;
+ return state->err == Z_MEM_ERROR ? "out of memory" :
+ (state->msg == NULL ? "" : state->msg);
+}
+
+/* -- see zlib.h -- */
+void ZEXPORT gzclearerr(file)
+ gzFile file;
+{
+ gz_statep state;
+
+ /* get internal structure and check integrity */
+ if (file == NULL)
+ return;
+ state = (gz_statep)file;
+ if (state->mode != GZ_READ && state->mode != GZ_WRITE)
+ return;
+
+ /* clear error and end-of-file */
+ if (state->mode == GZ_READ) {
+ state->eof = 0;
+ state->past = 0;
+ }
+ gz_error(state, Z_OK, NULL);
+}
+
+/* Create an error message in allocated memory and set state->err and
+ state->msg accordingly. Free any previous error message already there. Do
+ not try to free or allocate space if the error is Z_MEM_ERROR (out of
+ memory). Simply save the error message as a static string. If there is an
+ allocation failure constructing the error message, then convert the error to
+ out of memory. */
+void ZLIB_INTERNAL gz_error(state, err, msg)
+ gz_statep state;
+ int err;
+ const char *msg;
+{
+ /* free previously allocated message and clear */
+ if (state->msg != NULL) {
+ if (state->err != Z_MEM_ERROR)
+ free(state->msg);
+ state->msg = NULL;
+ }
+
+ /* if fatal, set state->x.have to 0 so that the gzgetc() macro fails */
+ if (err != Z_OK && err != Z_BUF_ERROR)
+ state->x.have = 0;
+
+ /* set error code, and if no message, then done */
+ state->err = err;
+ if (msg == NULL)
+ return;
+
+ /* for an out of memory error, return literal string when requested */
+ if (err == Z_MEM_ERROR)
+ return;
+
+ /* construct error message with path */
+ if ((state->msg = (char *)malloc(strlen(state->path) + strlen(msg) + 3)) ==
+ NULL) {
+ state->err = Z_MEM_ERROR;
+ return;
+ }
+#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
+ (void)snprintf(state->msg, strlen(state->path) + strlen(msg) + 3,
+ "%s%s%s", state->path, ": ", msg);
+#else
+ strcpy(state->msg, state->path);
+ strcat(state->msg, ": ");
+ strcat(state->msg, msg);
+#endif
+}
+
+#ifndef INT_MAX
+/* portably return maximum value for an int (when limits.h presumed not
+ available) -- we need to do this to cover cases where 2's complement not
+ used, since C standard permits 1's complement and sign-bit representations,
+ otherwise we could just use ((unsigned)-1) >> 1 */
+unsigned ZLIB_INTERNAL gz_intmax()
+{
+ unsigned p, q;
+
+ p = 1;
+ do {
+ q = p;
+ p <<= 1;
+ p++;
+ } while (p > q);
+ return q >> 1;
+}
+#endif
diff --git a/zlib/gzread.c b/zlib/gzread.c
new file mode 100644
index 000000000..956b91ea7
--- /dev/null
+++ b/zlib/gzread.c
@@ -0,0 +1,654 @@
+/* gzread.c -- zlib functions for reading gzip files
+ * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "gzguts.h"
+
+/* Local functions */
+local int gz_load OF((gz_statep, unsigned char *, unsigned, unsigned *));
+local int gz_avail OF((gz_statep));
+local int gz_look OF((gz_statep));
+local int gz_decomp OF((gz_statep));
+local int gz_fetch OF((gz_statep));
+local int gz_skip OF((gz_statep, z_off64_t));
+local z_size_t gz_read OF((gz_statep, voidp, z_size_t));
+
+/* Use read() to load a buffer -- return -1 on error, otherwise 0. Read from
+ state->fd, and update state->eof, state->err, and state->msg as appropriate.
+ This function needs to loop on read(), since read() is not guaranteed to
+ read the number of bytes requested, depending on the type of descriptor. */
+local int gz_load(state, buf, len, have)
+ gz_statep state;
+ unsigned char *buf;
+ unsigned len;
+ unsigned *have;
+{
+ int ret;
+ unsigned get, max = ((unsigned)-1 >> 2) + 1;
+
+ *have = 0;
+ do {
+ get = len - *have;
+ if (get > max)
+ get = max;
+ ret = read(state->fd, buf + *have, get);
+ if (ret <= 0)
+ break;
+ *have += (unsigned)ret;
+ } while (*have < len);
+ if (ret < 0) {
+ gz_error(state, Z_ERRNO, zstrerror());
+ return -1;
+ }
+ if (ret == 0)
+ state->eof = 1;
+ return 0;
+}
+
+/* Load up input buffer and set eof flag if last data loaded -- return -1 on
+ error, 0 otherwise. Note that the eof flag is set when the end of the input
+ file is reached, even though there may be unused data in the buffer. Once
+ that data has been used, no more attempts will be made to read the file.
+ If strm->avail_in != 0, then the current data is moved to the beginning of
+ the input buffer, and then the remainder of the buffer is loaded with the
+ available data from the input file. */
+local int gz_avail(state)
+ gz_statep state;
+{
+ unsigned got;
+ z_streamp strm = &(state->strm);
+
+ if (state->err != Z_OK && state->err != Z_BUF_ERROR)
+ return -1;
+ if (state->eof == 0) {
+ if (strm->avail_in) { /* copy what's there to the start */
+ unsigned char *p = state->in;
+ unsigned const char *q = strm->next_in;
+ unsigned n = strm->avail_in;
+ do {
+ *p++ = *q++;
+ } while (--n);
+ }
+ if (gz_load(state, state->in + strm->avail_in,
+ state->size - strm->avail_in, &got) == -1)
+ return -1;
+ strm->avail_in += got;
+ strm->next_in = state->in;
+ }
+ return 0;
+}
+
+/* Look for gzip header, set up for inflate or copy. state->x.have must be 0.
+ If this is the first time in, allocate required memory. state->how will be
+ left unchanged if there is no more input data available, will be set to COPY
+ if there is no gzip header and direct copying will be performed, or it will
+ be set to GZIP for decompression. If direct copying, then leftover input
+ data from the input buffer will be copied to the output buffer. In that
+ case, all further file reads will be directly to either the output buffer or
+ a user buffer. If decompressing, the inflate state will be initialized.
+ gz_look() will return 0 on success or -1 on failure. */
+local int gz_look(state)
+ gz_statep state;
+{
+ z_streamp strm = &(state->strm);
+
+ /* allocate read buffers and inflate memory */
+ if (state->size == 0) {
+ /* allocate buffers */
+ state->in = (unsigned char *)malloc(state->want);
+ state->out = (unsigned char *)malloc(state->want << 1);
+ if (state->in == NULL || state->out == NULL) {
+ free(state->out);
+ free(state->in);
+ gz_error(state, Z_MEM_ERROR, "out of memory");
+ return -1;
+ }
+ state->size = state->want;
+
+ /* allocate inflate memory */
+ state->strm.zalloc = Z_NULL;
+ state->strm.zfree = Z_NULL;
+ state->strm.opaque = Z_NULL;
+ state->strm.avail_in = 0;
+ state->strm.next_in = Z_NULL;
+ if (inflateInit2(&(state->strm), 15 + 16) != Z_OK) { /* gunzip */
+ free(state->out);
+ free(state->in);
+ state->size = 0;
+ gz_error(state, Z_MEM_ERROR, "out of memory");
+ return -1;
+ }
+ }
+
+ /* get at least the magic bytes in the input buffer */
+ if (strm->avail_in < 2) {
+ if (gz_avail(state) == -1)
+ return -1;
+ if (strm->avail_in == 0)
+ return 0;
+ }
+
+ /* look for gzip magic bytes -- if there, do gzip decoding (note: there is
+ a logical dilemma here when considering the case of a partially written
+ gzip file, to wit, if a single 31 byte is written, then we cannot tell
+ whether this is a single-byte file, or just a partially written gzip
+ file -- for here we assume that if a gzip file is being written, then
+ the header will be written in a single operation, so that reading a
+ single byte is sufficient indication that it is not a gzip file) */
+ if (strm->avail_in > 1 &&
+ strm->next_in[0] == 31 && strm->next_in[1] == 139) {
+ inflateReset(strm);
+ state->how = GZIP;
+ state->direct = 0;
+ return 0;
+ }
+
+ /* no gzip header -- if we were decoding gzip before, then this is trailing
+ garbage. Ignore the trailing garbage and finish. */
+ if (state->direct == 0) {
+ strm->avail_in = 0;
+ state->eof = 1;
+ state->x.have = 0;
+ return 0;
+ }
+
+ /* doing raw i/o, copy any leftover input to output -- this assumes that
+ the output buffer is larger than the input buffer, which also assures
+ space for gzungetc() */
+ state->x.next = state->out;
+ if (strm->avail_in) {
+ memcpy(state->x.next, strm->next_in, strm->avail_in);
+ state->x.have = strm->avail_in;
+ strm->avail_in = 0;
+ }
+ state->how = COPY;
+ state->direct = 1;
+ return 0;
+}
+
+/* Decompress from input to the provided next_out and avail_out in the state.
+ On return, state->x.have and state->x.next point to the just decompressed
+ data. If the gzip stream completes, state->how is reset to LOOK to look for
+ the next gzip stream or raw data, once state->x.have is depleted. Returns 0
+ on success, -1 on failure. */
+local int gz_decomp(state)
+ gz_statep state;
+{
+ int ret = Z_OK;
+ unsigned had;
+ z_streamp strm = &(state->strm);
+
+ /* fill output buffer up to end of deflate stream */
+ had = strm->avail_out;
+ do {
+ /* get more input for inflate() */
+ if (strm->avail_in == 0 && gz_avail(state) == -1)
+ return -1;
+ if (strm->avail_in == 0) {
+ gz_error(state, Z_BUF_ERROR, "unexpected end of file");
+ break;
+ }
+
+ /* decompress and handle errors */
+ ret = inflate(strm, Z_NO_FLUSH);
+ if (ret == Z_STREAM_ERROR || ret == Z_NEED_DICT) {
+ gz_error(state, Z_STREAM_ERROR,
+ "internal error: inflate stream corrupt");
+ return -1;
+ }
+ if (ret == Z_MEM_ERROR) {
+ gz_error(state, Z_MEM_ERROR, "out of memory");
+ return -1;
+ }
+ if (ret == Z_DATA_ERROR) { /* deflate stream invalid */
+ gz_error(state, Z_DATA_ERROR,
+ strm->msg == NULL ? "compressed data error" : strm->msg);
+ return -1;
+ }
+ } while (strm->avail_out && ret != Z_STREAM_END);
+
+ /* update available output */
+ state->x.have = had - strm->avail_out;
+ state->x.next = strm->next_out - state->x.have;
+
+ /* if the gzip stream completed successfully, look for another */
+ if (ret == Z_STREAM_END)
+ state->how = LOOK;
+
+ /* good decompression */
+ return 0;
+}
+
+/* Fetch data and put it in the output buffer. Assumes state->x.have is 0.
+ Data is either copied from the input file or decompressed from the input
+ file depending on state->how. If state->how is LOOK, then a gzip header is
+ looked for to determine whether to copy or decompress. Returns -1 on error,
+ otherwise 0. gz_fetch() will leave state->how as COPY or GZIP unless the
+ end of the input file has been reached and all data has been processed. */
+local int gz_fetch(state)
+ gz_statep state;
+{
+ z_streamp strm = &(state->strm);
+
+ do {
+ switch(state->how) {
+ case LOOK: /* -> LOOK, COPY (only if never GZIP), or GZIP */
+ if (gz_look(state) == -1)
+ return -1;
+ if (state->how == LOOK)
+ return 0;
+ break;
+ case COPY: /* -> COPY */
+ if (gz_load(state, state->out, state->size << 1, &(state->x.have))
+ == -1)
+ return -1;
+ state->x.next = state->out;
+ return 0;
+ case GZIP: /* -> GZIP or LOOK (if end of gzip stream) */
+ strm->avail_out = state->size << 1;
+ strm->next_out = state->out;
+ if (gz_decomp(state) == -1)
+ return -1;
+ }
+ } while (state->x.have == 0 && (!state->eof || strm->avail_in));
+ return 0;
+}
+
+/* Skip len uncompressed bytes of output. Return -1 on error, 0 on success. */
+local int gz_skip(state, len)
+ gz_statep state;
+ z_off64_t len;
+{
+ unsigned n;
+
+ /* skip over len bytes or reach end-of-file, whichever comes first */
+ while (len)
+ /* skip over whatever is in output buffer */
+ if (state->x.have) {
+ n = GT_OFF(state->x.have) || (z_off64_t)state->x.have > len ?
+ (unsigned)len : state->x.have;
+ state->x.have -= n;
+ state->x.next += n;
+ state->x.pos += n;
+ len -= n;
+ }
+
+ /* output buffer empty -- return if we're at the end of the input */
+ else if (state->eof && state->strm.avail_in == 0)
+ break;
+
+ /* need more data to skip -- load up output buffer */
+ else {
+ /* get more output, looking for header if required */
+ if (gz_fetch(state) == -1)
+ return -1;
+ }
+ return 0;
+}
+
+/* Read len bytes into buf from file, or less than len up to the end of the
+ input. Return the number of bytes read. If zero is returned, either the
+ end of file was reached, or there was an error. state->err must be
+ consulted in that case to determine which. */
+local z_size_t gz_read(state, buf, len)
+ gz_statep state;
+ voidp buf;
+ z_size_t len;
+{
+ z_size_t got;
+ unsigned n;
+
+ /* if len is zero, avoid unnecessary operations */
+ if (len == 0)
+ return 0;
+
+ /* process a skip request */
+ if (state->seek) {
+ state->seek = 0;
+ if (gz_skip(state, state->skip) == -1)
+ return 0;
+ }
+
+ /* get len bytes to buf, or less than len if at the end */
+ got = 0;
+ do {
+ /* set n to the maximum amount of len that fits in an unsigned int */
+ n = -1;
+ if (n > len)
+ n = len;
+
+ /* first just try copying data from the output buffer */
+ if (state->x.have) {
+ if (state->x.have < n)
+ n = state->x.have;
+ memcpy(buf, state->x.next, n);
+ state->x.next += n;
+ state->x.have -= n;
+ }
+
+ /* output buffer empty -- return if we're at the end of the input */
+ else if (state->eof && state->strm.avail_in == 0) {
+ state->past = 1; /* tried to read past end */
+ break;
+ }
+
+ /* need output data -- for small len or new stream load up our output
+ buffer */
+ else if (state->how == LOOK || n < (state->size << 1)) {
+ /* get more output, looking for header if required */
+ if (gz_fetch(state) == -1)
+ return 0;
+ continue; /* no progress yet -- go back to copy above */
+ /* the copy above assures that we will leave with space in the
+ output buffer, allowing at least one gzungetc() to succeed */
+ }
+
+ /* large len -- read directly into user buffer */
+ else if (state->how == COPY) { /* read directly */
+ if (gz_load(state, (unsigned char *)buf, n, &n) == -1)
+ return 0;
+ }
+
+ /* large len -- decompress directly into user buffer */
+ else { /* state->how == GZIP */
+ state->strm.avail_out = n;
+ state->strm.next_out = (unsigned char *)buf;
+ if (gz_decomp(state) == -1)
+ return 0;
+ n = state->x.have;
+ state->x.have = 0;
+ }
+
+ /* update progress */
+ len -= n;
+ buf = (char *)buf + n;
+ got += n;
+ state->x.pos += n;
+ } while (len);
+
+ /* return number of bytes read into user buffer */
+ return got;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzread(file, buf, len)
+ gzFile file;
+ voidp buf;
+ unsigned len;
+{
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return -1;
+ state = (gz_statep)file;
+
+ /* check that we're reading and that there's no (serious) error */
+ if (state->mode != GZ_READ ||
+ (state->err != Z_OK && state->err != Z_BUF_ERROR))
+ return -1;
+
+ /* since an int is returned, make sure len fits in one, otherwise return
+ with an error (this avoids a flaw in the interface) */
+ if ((int)len < 0) {
+ gz_error(state, Z_STREAM_ERROR, "request does not fit in an int");
+ return -1;
+ }
+
+ /* read len or fewer bytes to buf */
+ len = gz_read(state, buf, len);
+
+ /* check for an error */
+ if (len == 0 && state->err != Z_OK && state->err != Z_BUF_ERROR)
+ return -1;
+
+ /* return the number of bytes read (this is assured to fit in an int) */
+ return (int)len;
+}
+
+/* -- see zlib.h -- */
+z_size_t ZEXPORT gzfread(buf, size, nitems, file)
+ voidp buf;
+ z_size_t size;
+ z_size_t nitems;
+ gzFile file;
+{
+ z_size_t len;
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return 0;
+ state = (gz_statep)file;
+
+ /* check that we're reading and that there's no (serious) error */
+ if (state->mode != GZ_READ ||
+ (state->err != Z_OK && state->err != Z_BUF_ERROR))
+ return 0;
+
+ /* compute bytes to read -- error on overflow */
+ len = nitems * size;
+ if (size && len / size != nitems) {
+ gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
+ return 0;
+ }
+
+ /* read len or fewer bytes to buf, return the number of full items read */
+ return len ? gz_read(state, buf, len) / size : 0;
+}
+
+/* -- see zlib.h -- */
+#ifdef Z_PREFIX_SET
+# undef z_gzgetc
+#else
+# undef gzgetc
+#endif
+int ZEXPORT gzgetc(file)
+ gzFile file;
+{
+ int ret;
+ unsigned char buf[1];
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return -1;
+ state = (gz_statep)file;
+
+ /* check that we're reading and that there's no (serious) error */
+ if (state->mode != GZ_READ ||
+ (state->err != Z_OK && state->err != Z_BUF_ERROR))
+ return -1;
+
+ /* try output buffer (no need to check for skip request) */
+ if (state->x.have) {
+ state->x.have--;
+ state->x.pos++;
+ return *(state->x.next)++;
+ }
+
+ /* nothing there -- try gz_read() */
+ ret = gz_read(state, buf, 1);
+ return ret < 1 ? -1 : buf[0];
+}
+
+int ZEXPORT gzgetc_(file)
+gzFile file;
+{
+ return gzgetc(file);
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzungetc(c, file)
+ int c;
+ gzFile file;
+{
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return -1;
+ state = (gz_statep)file;
+
+ /* check that we're reading and that there's no (serious) error */
+ if (state->mode != GZ_READ ||
+ (state->err != Z_OK && state->err != Z_BUF_ERROR))
+ return -1;
+
+ /* process a skip request */
+ if (state->seek) {
+ state->seek = 0;
+ if (gz_skip(state, state->skip) == -1)
+ return -1;
+ }
+
+ /* can't push EOF */
+ if (c < 0)
+ return -1;
+
+ /* if output buffer empty, put byte at end (allows more pushing) */
+ if (state->x.have == 0) {
+ state->x.have = 1;
+ state->x.next = state->out + (state->size << 1) - 1;
+ state->x.next[0] = (unsigned char)c;
+ state->x.pos--;
+ state->past = 0;
+ return c;
+ }
+
+ /* if no room, give up (must have already done a gzungetc()) */
+ if (state->x.have == (state->size << 1)) {
+ gz_error(state, Z_DATA_ERROR, "out of room to push characters");
+ return -1;
+ }
+
+ /* slide output data if needed and insert byte before existing data */
+ if (state->x.next == state->out) {
+ unsigned char *src = state->out + state->x.have;
+ unsigned char *dest = state->out + (state->size << 1);
+ while (src > state->out)
+ *--dest = *--src;
+ state->x.next = dest;
+ }
+ state->x.have++;
+ state->x.next--;
+ state->x.next[0] = (unsigned char)c;
+ state->x.pos--;
+ state->past = 0;
+ return c;
+}
+
+/* -- see zlib.h -- */
+char * ZEXPORT gzgets(file, buf, len)
+ gzFile file;
+ char *buf;
+ int len;
+{
+ unsigned left, n;
+ char *str;
+ unsigned char *eol;
+ gz_statep state;
+
+ /* check parameters and get internal structure */
+ if (file == NULL || buf == NULL || len < 1)
+ return NULL;
+ state = (gz_statep)file;
+
+ /* check that we're reading and that there's no (serious) error */
+ if (state->mode != GZ_READ ||
+ (state->err != Z_OK && state->err != Z_BUF_ERROR))
+ return NULL;
+
+ /* process a skip request */
+ if (state->seek) {
+ state->seek = 0;
+ if (gz_skip(state, state->skip) == -1)
+ return NULL;
+ }
+
+ /* copy output bytes up to new line or len - 1, whichever comes first --
+ append a terminating zero to the string (we don't check for a zero in
+ the contents, let the user worry about that) */
+ str = buf;
+ left = (unsigned)len - 1;
+ if (left) do {
+ /* assure that something is in the output buffer */
+ if (state->x.have == 0 && gz_fetch(state) == -1)
+ return NULL; /* error */
+ if (state->x.have == 0) { /* end of file */
+ state->past = 1; /* read past end */
+ break; /* return what we have */
+ }
+
+ /* look for end-of-line in current output buffer */
+ n = state->x.have > left ? left : state->x.have;
+ eol = (unsigned char *)memchr(state->x.next, '\n', n);
+ if (eol != NULL)
+ n = (unsigned)(eol - state->x.next) + 1;
+
+ /* copy through end-of-line, or remainder if not found */
+ memcpy(buf, state->x.next, n);
+ state->x.have -= n;
+ state->x.next += n;
+ state->x.pos += n;
+ left -= n;
+ buf += n;
+ } while (left && eol == NULL);
+
+ /* return terminated string, or if nothing, end of file */
+ if (buf == str)
+ return NULL;
+ buf[0] = 0;
+ return str;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzdirect(file)
+ gzFile file;
+{
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return 0;
+ state = (gz_statep)file;
+
+ /* if the state is not known, but we can find out, then do so (this is
+ mainly for right after a gzopen() or gzdopen()) */
+ if (state->mode == GZ_READ && state->how == LOOK && state->x.have == 0)
+ (void)gz_look(state);
+
+ /* return 1 if transparent, 0 if processing a gzip stream */
+ return state->direct;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzclose_r(file)
+ gzFile file;
+{
+ int ret, err;
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return Z_STREAM_ERROR;
+ state = (gz_statep)file;
+
+ /* check that we're reading */
+ if (state->mode != GZ_READ)
+ return Z_STREAM_ERROR;
+
+ /* free memory and close file */
+ if (state->size) {
+ inflateEnd(&(state->strm));
+ free(state->out);
+ free(state->in);
+ }
+ err = state->err == Z_BUF_ERROR ? Z_BUF_ERROR : Z_OK;
+ gz_error(state, Z_OK, NULL);
+ free(state->path);
+ ret = close(state->fd);
+ free(state);
+ return ret ? Z_ERRNO : err;
+}
diff --git a/zlib/gzwrite.c b/zlib/gzwrite.c
new file mode 100644
index 000000000..c7b5651d7
--- /dev/null
+++ b/zlib/gzwrite.c
@@ -0,0 +1,665 @@
+/* gzwrite.c -- zlib functions for writing gzip files
+ * Copyright (C) 2004-2017 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#include "gzguts.h"
+
+/* Local functions */
+local int gz_init OF((gz_statep));
+local int gz_comp OF((gz_statep, int));
+local int gz_zero OF((gz_statep, z_off64_t));
+local z_size_t gz_write OF((gz_statep, voidpc, z_size_t));
+
+/* Initialize state for writing a gzip file. Mark initialization by setting
+ state->size to non-zero. Return -1 on a memory allocation failure, or 0 on
+ success. */
+local int gz_init(state)
+ gz_statep state;
+{
+ int ret;
+ z_streamp strm = &(state->strm);
+
+ /* allocate input buffer (double size for gzprintf) */
+ state->in = (unsigned char *)malloc(state->want << 1);
+ if (state->in == NULL) {
+ gz_error(state, Z_MEM_ERROR, "out of memory");
+ return -1;
+ }
+
+ /* only need output buffer and deflate state if compressing */
+ if (!state->direct) {
+ /* allocate output buffer */
+ state->out = (unsigned char *)malloc(state->want);
+ if (state->out == NULL) {
+ free(state->in);
+ gz_error(state, Z_MEM_ERROR, "out of memory");
+ return -1;
+ }
+
+ /* allocate deflate memory, set up for gzip compression */
+ strm->zalloc = Z_NULL;
+ strm->zfree = Z_NULL;
+ strm->opaque = Z_NULL;
+ ret = deflateInit2(strm, state->level, Z_DEFLATED,
+ MAX_WBITS + 16, DEF_MEM_LEVEL, state->strategy);
+ if (ret != Z_OK) {
+ free(state->out);
+ free(state->in);
+ gz_error(state, Z_MEM_ERROR, "out of memory");
+ return -1;
+ }
+ strm->next_in = NULL;
+ }
+
+ /* mark state as initialized */
+ state->size = state->want;
+
+ /* initialize write buffer if compressing */
+ if (!state->direct) {
+ strm->avail_out = state->size;
+ strm->next_out = state->out;
+ state->x.next = strm->next_out;
+ }
+ return 0;
+}
+
+/* Compress whatever is at avail_in and next_in and write to the output file.
+ Return -1 if there is an error writing to the output file or if gz_init()
+ fails to allocate memory, otherwise 0. flush is assumed to be a valid
+ deflate() flush value. If flush is Z_FINISH, then the deflate() state is
+ reset to start a new gzip stream. If gz->direct is true, then simply write
+ to the output file without compressing, and ignore flush. */
+local int gz_comp(state, flush)
+ gz_statep state;
+ int flush;
+{
+ int ret, writ;
+ unsigned have, put, max = ((unsigned)-1 >> 2) + 1;
+ z_streamp strm = &(state->strm);
+
+ /* allocate memory if this is the first time through */
+ if (state->size == 0 && gz_init(state) == -1)
+ return -1;
+
+ /* write directly if requested */
+ if (state->direct) {
+ while (strm->avail_in) {
+ put = strm->avail_in > max ? max : strm->avail_in;
+ writ = write(state->fd, strm->next_in, put);
+ if (writ < 0) {
+ gz_error(state, Z_ERRNO, zstrerror());
+ return -1;
+ }
+ strm->avail_in -= (unsigned)writ;
+ strm->next_in += writ;
+ }
+ return 0;
+ }
+
+ /* run deflate() on provided input until it produces no more output */
+ ret = Z_OK;
+ do {
+ /* write out current buffer contents if full, or if flushing, but if
+ doing Z_FINISH then don't write until we get to Z_STREAM_END */
+ if (strm->avail_out == 0 || (flush != Z_NO_FLUSH &&
+ (flush != Z_FINISH || ret == Z_STREAM_END))) {
+ while (strm->next_out > state->x.next) {
+ put = strm->next_out - state->x.next > (int)max ? max :
+ (unsigned)(strm->next_out - state->x.next);
+ writ = write(state->fd, state->x.next, put);
+ if (writ < 0) {
+ gz_error(state, Z_ERRNO, zstrerror());
+ return -1;
+ }
+ state->x.next += writ;
+ }
+ if (strm->avail_out == 0) {
+ strm->avail_out = state->size;
+ strm->next_out = state->out;
+ state->x.next = state->out;
+ }
+ }
+
+ /* compress */
+ have = strm->avail_out;
+ ret = deflate(strm, flush);
+ if (ret == Z_STREAM_ERROR) {
+ gz_error(state, Z_STREAM_ERROR,
+ "internal error: deflate stream corrupt");
+ return -1;
+ }
+ have -= strm->avail_out;
+ } while (have);
+
+ /* if that completed a deflate stream, allow another to start */
+ if (flush == Z_FINISH)
+ deflateReset(strm);
+
+ /* all done, no errors */
+ return 0;
+}
+
+/* Compress len zeros to output. Return -1 on a write error or memory
+ allocation failure by gz_comp(), or 0 on success. */
+local int gz_zero(state, len)
+ gz_statep state;
+ z_off64_t len;
+{
+ int first;
+ unsigned n;
+ z_streamp strm = &(state->strm);
+
+ /* consume whatever's left in the input buffer */
+ if (strm->avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
+ return -1;
+
+ /* compress len zeros (len guaranteed > 0) */
+ first = 1;
+ while (len) {
+ n = GT_OFF(state->size) || (z_off64_t)state->size > len ?
+ (unsigned)len : state->size;
+ if (first) {
+ memset(state->in, 0, n);
+ first = 0;
+ }
+ strm->avail_in = n;
+ strm->next_in = state->in;
+ state->x.pos += n;
+ if (gz_comp(state, Z_NO_FLUSH) == -1)
+ return -1;
+ len -= n;
+ }
+ return 0;
+}
+
+/* Write len bytes from buf to file. Return the number of bytes written. If
+ the returned value is less than len, then there was an error. */
+local z_size_t gz_write(state, buf, len)
+ gz_statep state;
+ voidpc buf;
+ z_size_t len;
+{
+ z_size_t put = len;
+
+ /* if len is zero, avoid unnecessary operations */
+ if (len == 0)
+ return 0;
+
+ /* allocate memory if this is the first time through */
+ if (state->size == 0 && gz_init(state) == -1)
+ return 0;
+
+ /* check for seek request */
+ if (state->seek) {
+ state->seek = 0;
+ if (gz_zero(state, state->skip) == -1)
+ return 0;
+ }
+
+ /* for small len, copy to input buffer, otherwise compress directly */
+ if (len < state->size) {
+ /* copy to input buffer, compress when full */
+ do {
+ unsigned have, copy;
+
+ if (state->strm.avail_in == 0)
+ state->strm.next_in = state->in;
+ have = (unsigned)((state->strm.next_in + state->strm.avail_in) -
+ state->in);
+ copy = state->size - have;
+ if (copy > len)
+ copy = len;
+ memcpy(state->in + have, buf, copy);
+ state->strm.avail_in += copy;
+ state->x.pos += copy;
+ buf = (const char *)buf + copy;
+ len -= copy;
+ if (len && gz_comp(state, Z_NO_FLUSH) == -1)
+ return 0;
+ } while (len);
+ }
+ else {
+ /* consume whatever's left in the input buffer */
+ if (state->strm.avail_in && gz_comp(state, Z_NO_FLUSH) == -1)
+ return 0;
+
+ /* directly compress user buffer to file */
+ state->strm.next_in = (z_const Bytef *)buf;
+ do {
+ unsigned n = (unsigned)-1;
+ if (n > len)
+ n = len;
+ state->strm.avail_in = n;
+ state->x.pos += n;
+ if (gz_comp(state, Z_NO_FLUSH) == -1)
+ return 0;
+ len -= n;
+ } while (len);
+ }
+
+ /* input was all buffered or compressed */
+ return put;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzwrite(file, buf, len)
+ gzFile file;
+ voidpc buf;
+ unsigned len;
+{
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return 0;
+ state = (gz_statep)file;
+
+ /* check that we're writing and that there's no error */
+ if (state->mode != GZ_WRITE || state->err != Z_OK)
+ return 0;
+
+ /* since an int is returned, make sure len fits in one, otherwise return
+ with an error (this avoids a flaw in the interface) */
+ if ((int)len < 0) {
+ gz_error(state, Z_DATA_ERROR, "requested length does not fit in int");
+ return 0;
+ }
+
+ /* write len bytes from buf (the return value will fit in an int) */
+ return (int)gz_write(state, buf, len);
+}
+
+/* -- see zlib.h -- */
+z_size_t ZEXPORT gzfwrite(buf, size, nitems, file)
+ voidpc buf;
+ z_size_t size;
+ z_size_t nitems;
+ gzFile file;
+{
+ z_size_t len;
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return 0;
+ state = (gz_statep)file;
+
+ /* check that we're writing and that there's no error */
+ if (state->mode != GZ_WRITE || state->err != Z_OK)
+ return 0;
+
+ /* compute bytes to read -- error on overflow */
+ len = nitems * size;
+ if (size && len / size != nitems) {
+ gz_error(state, Z_STREAM_ERROR, "request does not fit in a size_t");
+ return 0;
+ }
+
+ /* write len bytes to buf, return the number of full items written */
+ return len ? gz_write(state, buf, len) / size : 0;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzputc(file, c)
+ gzFile file;
+ int c;
+{
+ unsigned have;
+ unsigned char buf[1];
+ gz_statep state;
+ z_streamp strm;
+
+ /* get internal structure */
+ if (file == NULL)
+ return -1;
+ state = (gz_statep)file;
+ strm = &(state->strm);
+
+ /* check that we're writing and that there's no error */
+ if (state->mode != GZ_WRITE || state->err != Z_OK)
+ return -1;
+
+ /* check for seek request */
+ if (state->seek) {
+ state->seek = 0;
+ if (gz_zero(state, state->skip) == -1)
+ return -1;
+ }
+
+ /* try writing to input buffer for speed (state->size == 0 if buffer not
+ initialized) */
+ if (state->size) {
+ if (strm->avail_in == 0)
+ strm->next_in = state->in;
+ have = (unsigned)((strm->next_in + strm->avail_in) - state->in);
+ if (have < state->size) {
+ state->in[have] = (unsigned char)c;
+ strm->avail_in++;
+ state->x.pos++;
+ return c & 0xff;
+ }
+ }
+
+ /* no room in buffer or not initialized, use gz_write() */
+ buf[0] = (unsigned char)c;
+ if (gz_write(state, buf, 1) != 1)
+ return -1;
+ return c & 0xff;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzputs(file, str)
+ gzFile file;
+ const char *str;
+{
+ int ret;
+ z_size_t len;
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return -1;
+ state = (gz_statep)file;
+
+ /* check that we're writing and that there's no error */
+ if (state->mode != GZ_WRITE || state->err != Z_OK)
+ return -1;
+
+ /* write string */
+ len = strlen(str);
+ ret = gz_write(state, str, len);
+ return ret == 0 && len != 0 ? -1 : ret;
+}
+
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#include <stdarg.h>
+
+/* -- see zlib.h -- */
+int ZEXPORTVA gzvprintf(gzFile file, const char *format, va_list va)
+{
+ int len;
+ unsigned left;
+ char *next;
+ gz_statep state;
+ z_streamp strm;
+
+ /* get internal structure */
+ if (file == NULL)
+ return Z_STREAM_ERROR;
+ state = (gz_statep)file;
+ strm = &(state->strm);
+
+ /* check that we're writing and that there's no error */
+ if (state->mode != GZ_WRITE || state->err != Z_OK)
+ return Z_STREAM_ERROR;
+
+ /* make sure we have some buffer space */
+ if (state->size == 0 && gz_init(state) == -1)
+ return state->err;
+
+ /* check for seek request */
+ if (state->seek) {
+ state->seek = 0;
+ if (gz_zero(state, state->skip) == -1)
+ return state->err;
+ }
+
+ /* do the printf() into the input buffer, put length in len -- the input
+ buffer is double-sized just for this function, so there is guaranteed to
+ be state->size bytes available after the current contents */
+ if (strm->avail_in == 0)
+ strm->next_in = state->in;
+ next = (char *)(state->in + (strm->next_in - state->in) + strm->avail_in);
+ next[state->size - 1] = 0;
+#ifdef NO_vsnprintf
+# ifdef HAS_vsprintf_void
+ (void)vsprintf(next, format, va);
+ for (len = 0; len < state->size; len++)
+ if (next[len] == 0) break;
+# else
+ len = vsprintf(next, format, va);
+# endif
+#else
+# ifdef HAS_vsnprintf_void
+ (void)vsnprintf(next, state->size, format, va);
+ len = strlen(next);
+# else
+ len = vsnprintf(next, state->size, format, va);
+# endif
+#endif
+
+ /* check that printf() results fit in buffer */
+ if (len == 0 || (unsigned)len >= state->size || next[state->size - 1] != 0)
+ return 0;
+
+ /* update buffer and position, compress first half if past that */
+ strm->avail_in += (unsigned)len;
+ state->x.pos += len;
+ if (strm->avail_in >= state->size) {
+ left = strm->avail_in - state->size;
+ strm->avail_in = state->size;
+ if (gz_comp(state, Z_NO_FLUSH) == -1)
+ return state->err;
+ memcpy(state->in, state->in + state->size, left);
+ strm->next_in = state->in;
+ strm->avail_in = left;
+ }
+ return len;
+}
+
+int ZEXPORTVA gzprintf(gzFile file, const char *format, ...)
+{
+ va_list va;
+ int ret;
+
+ va_start(va, format);
+ ret = gzvprintf(file, format, va);
+ va_end(va);
+ return ret;
+}
+
+#else /* !STDC && !Z_HAVE_STDARG_H */
+
+/* -- see zlib.h -- */
+int ZEXPORTVA gzprintf (file, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
+ a11, a12, a13, a14, a15, a16, a17, a18, a19, a20)
+ gzFile file;
+ const char *format;
+ int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10,
+ a11, a12, a13, a14, a15, a16, a17, a18, a19, a20;
+{
+ unsigned len, left;
+ char *next;
+ gz_statep state;
+ z_streamp strm;
+
+ /* get internal structure */
+ if (file == NULL)
+ return Z_STREAM_ERROR;
+ state = (gz_statep)file;
+ strm = &(state->strm);
+
+ /* check that can really pass pointer in ints */
+ if (sizeof(int) != sizeof(void *))
+ return Z_STREAM_ERROR;
+
+ /* check that we're writing and that there's no error */
+ if (state->mode != GZ_WRITE || state->err != Z_OK)
+ return Z_STREAM_ERROR;
+
+ /* make sure we have some buffer space */
+ if (state->size == 0 && gz_init(state) == -1)
+ return state->error;
+
+ /* check for seek request */
+ if (state->seek) {
+ state->seek = 0;
+ if (gz_zero(state, state->skip) == -1)
+ return state->error;
+ }
+
+ /* do the printf() into the input buffer, put length in len -- the input
+ buffer is double-sized just for this function, so there is guaranteed to
+ be state->size bytes available after the current contents */
+ if (strm->avail_in == 0)
+ strm->next_in = state->in;
+ next = (char *)(strm->next_in + strm->avail_in);
+ next[state->size - 1] = 0;
+#ifdef NO_snprintf
+# ifdef HAS_sprintf_void
+ sprintf(next, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12,
+ a13, a14, a15, a16, a17, a18, a19, a20);
+ for (len = 0; len < size; len++)
+ if (next[len] == 0)
+ break;
+# else
+ len = sprintf(next, format, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11,
+ a12, a13, a14, a15, a16, a17, a18, a19, a20);
+# endif
+#else
+# ifdef HAS_snprintf_void
+ snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8, a9,
+ a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+ len = strlen(next);
+# else
+ len = snprintf(next, state->size, format, a1, a2, a3, a4, a5, a6, a7, a8,
+ a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20);
+# endif
+#endif
+
+ /* check that printf() results fit in buffer */
+ if (len == 0 || len >= state->size || next[state->size - 1] != 0)
+ return 0;
+
+ /* update buffer and position, compress first half if past that */
+ strm->avail_in += len;
+ state->x.pos += len;
+ if (strm->avail_in >= state->size) {
+ left = strm->avail_in - state->size;
+ strm->avail_in = state->size;
+ if (gz_comp(state, Z_NO_FLUSH) == -1)
+ return state->err;
+ memcpy(state->in, state->in + state->size, left);
+ strm->next_in = state->in;
+ strm->avail_in = left;
+ }
+ return (int)len;
+}
+
+#endif
+
+/* -- see zlib.h -- */
+int ZEXPORT gzflush(file, flush)
+ gzFile file;
+ int flush;
+{
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return Z_STREAM_ERROR;
+ state = (gz_statep)file;
+
+ /* check that we're writing and that there's no error */
+ if (state->mode != GZ_WRITE || state->err != Z_OK)
+ return Z_STREAM_ERROR;
+
+ /* check flush parameter */
+ if (flush < 0 || flush > Z_FINISH)
+ return Z_STREAM_ERROR;
+
+ /* check for seek request */
+ if (state->seek) {
+ state->seek = 0;
+ if (gz_zero(state, state->skip) == -1)
+ return state->err;
+ }
+
+ /* compress remaining data with requested flush */
+ (void)gz_comp(state, flush);
+ return state->err;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzsetparams(file, level, strategy)
+ gzFile file;
+ int level;
+ int strategy;
+{
+ gz_statep state;
+ z_streamp strm;
+
+ /* get internal structure */
+ if (file == NULL)
+ return Z_STREAM_ERROR;
+ state = (gz_statep)file;
+ strm = &(state->strm);
+
+ /* check that we're writing and that there's no error */
+ if (state->mode != GZ_WRITE || state->err != Z_OK)
+ return Z_STREAM_ERROR;
+
+ /* if no change is requested, then do nothing */
+ if (level == state->level && strategy == state->strategy)
+ return Z_OK;
+
+ /* check for seek request */
+ if (state->seek) {
+ state->seek = 0;
+ if (gz_zero(state, state->skip) == -1)
+ return state->err;
+ }
+
+ /* change compression parameters for subsequent input */
+ if (state->size) {
+ /* flush previous input with previous parameters before changing */
+ if (strm->avail_in && gz_comp(state, Z_BLOCK) == -1)
+ return state->err;
+ deflateParams(strm, level, strategy);
+ }
+ state->level = level;
+ state->strategy = strategy;
+ return Z_OK;
+}
+
+/* -- see zlib.h -- */
+int ZEXPORT gzclose_w(file)
+ gzFile file;
+{
+ int ret = Z_OK;
+ gz_statep state;
+
+ /* get internal structure */
+ if (file == NULL)
+ return Z_STREAM_ERROR;
+ state = (gz_statep)file;
+
+ /* check that we're writing */
+ if (state->mode != GZ_WRITE)
+ return Z_STREAM_ERROR;
+
+ /* check for seek request */
+ if (state->seek) {
+ state->seek = 0;
+ if (gz_zero(state, state->skip) == -1)
+ ret = state->err;
+ }
+
+ /* flush, free memory, and close file */
+ if (gz_comp(state, Z_FINISH) == -1)
+ ret = state->err;
+ if (state->size) {
+ if (!state->direct) {
+ (void)deflateEnd(&(state->strm));
+ free(state->out);
+ }
+ free(state->in);
+ }
+ gz_error(state, Z_OK, NULL);
+ free(state->path);
+ if (close(state->fd) == -1)
+ ret = Z_ERRNO;
+ free(state);
+ return ret;
+}
diff --git a/zlib/infback.c b/zlib/infback.c
new file mode 100644
index 000000000..59679ecbf
--- /dev/null
+++ b/zlib/infback.c
@@ -0,0 +1,640 @@
+/* infback.c -- inflate using a call-back interface
+ * Copyright (C) 1995-2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ This code is largely copied from inflate.c. Normally either infback.o or
+ inflate.o would be linked into an application--not both. The interface
+ with inffast.c is retained so that optimized assembler-coded versions of
+ inflate_fast() can be used with either inflate.c or infback.c.
+ */
+
+#include "zutil.h"
+#include "inftrees.h"
+#include "inflate.h"
+#include "inffast.h"
+
+/* function prototypes */
+local void fixedtables OF((struct inflate_state FAR *state));
+
+/*
+ strm provides memory allocation functions in zalloc and zfree, or
+ Z_NULL to use the library memory allocation functions.
+
+ windowBits is in the range 8..15, and window is a user-supplied
+ window and output buffer that is 2**windowBits bytes.
+ */
+int ZEXPORT inflateBackInit_(strm, windowBits, window, version, stream_size)
+z_streamp strm;
+int windowBits;
+unsigned char FAR *window;
+const char *version;
+int stream_size;
+{
+ 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 || window == Z_NULL ||
+ windowBits < 8 || windowBits > 15)
+ 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->dmax = 32768U;
+ state->wbits = (uInt)windowBits;
+ state->wsize = 1U << windowBits;
+ state->window = window;
+ state->wnext = 0;
+ state->whave = 0;
+ 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;
+}
+
+/* Macros for inflateBack(): */
+
+/* Load returned state from inflate_fast() */
+#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)
+
+/* Set state from registers for inflate_fast() */
+#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)
+
+/* Assure that some input is available. If input is requested, but denied,
+ then return a Z_BUF_ERROR from inflateBack(). */
+#define PULL() \
+ do { \
+ if (have == 0) { \
+ have = in(in_desc, &next); \
+ if (have == 0) { \
+ next = Z_NULL; \
+ ret = Z_BUF_ERROR; \
+ goto inf_leave; \
+ } \
+ } \
+ } while (0)
+
+/* Get a byte of input into the bit accumulator, or return from inflateBack()
+ with an error if there is no input available. */
+#define PULLBYTE() \
+ do { \
+ PULL(); \
+ have--; \
+ hold += (unsigned long)(*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 inflateBack() with
+ an error. */
+#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)
+
+/* Assure that some output space is available, by writing out the window
+ if it's full. If the write fails, return from inflateBack() with a
+ Z_BUF_ERROR. */
+#define ROOM() \
+ do { \
+ if (left == 0) { \
+ put = state->window; \
+ left = state->wsize; \
+ state->whave = left; \
+ if (out(out_desc, put, left)) { \
+ ret = Z_BUF_ERROR; \
+ goto inf_leave; \
+ } \
+ } \
+ } while (0)
+
+/*
+ strm provides the memory allocation functions and window buffer on input,
+ and provides information on the unused input on return. For Z_DATA_ERROR
+ returns, strm will also provide an error message.
+
+ in() and out() are the call-back input and output functions. When
+ inflateBack() needs more input, it calls in(). When inflateBack() has
+ filled the window with output, or when it completes with data in the
+ window, it calls out() to write out the data. The application must not
+ change the provided input until in() is called again or inflateBack()
+ returns. The application must not change the window/output buffer until
+ inflateBack() returns.
+
+ in() and out() are called with a descriptor parameter provided in the
+ inflateBack() call. This parameter can be a structure that provides the
+ information required to do the read or write, as well as accumulated
+ information on the input and output such as totals and check values.
+
+ in() should return zero on failure. out() should return non-zero on
+ failure. If either in() or out() fails, than inflateBack() returns a
+ Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it
+ was in() or out() that caused in the error. Otherwise, inflateBack()
+ returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
+ error, or Z_MEM_ERROR if it could not allocate memory for the state.
+ inflateBack() can also return Z_STREAM_ERROR if the input parameters
+ are not correct, i.e. strm is Z_NULL or the state was not initialized.
+ */
+int ZEXPORT inflateBack(strm, in, in_desc, out, out_desc)
+z_streamp strm;
+in_func in;
+void FAR *in_desc;
+out_func out;
+void FAR *out_desc;
+{
+ struct inflate_state FAR *state;
+ z_const unsigned char FAR *next; /* next input */
+ unsigned char FAR *put; /* next output */
+ unsigned have, left; /* available input and output */
+ unsigned long hold; /* bit buffer */
+ unsigned bits; /* bits in bit buffer */
+ 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 */
+ 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};
+
+ /* Check that the strm exists and that the state was initialized */
+ if (strm == Z_NULL || strm->state == Z_NULL)
+ return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+
+ /* Reset the state */
+ strm->msg = Z_NULL;
+ state->mode = TYPE;
+ state->last = 0;
+ state->whave = 0;
+ next = strm->next_in;
+ have = next != Z_NULL ? strm->avail_in : 0;
+ hold = 0;
+ bits = 0;
+ put = state->window;
+ left = state->wsize;
+
+ /* Inflate until end of block marked as last */
+ for (;;)
+ switch (state->mode) {
+ case TYPE:
+ /* determine and dispatch block type */
+ if (state->last) {
+ BYTEBITS();
+ state->mode = DONE;
+ 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 */
+ 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:
+ /* get and verify stored block length */
+ 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();
+
+ /* copy stored block from input to output */
+ while (state->length != 0) {
+ copy = state->length;
+ PULL();
+ ROOM();
+ if (copy > have) copy = have;
+ if (copy > left) copy = left;
+ zmemcpy(put, next, copy);
+ have -= copy;
+ next += copy;
+ left -= copy;
+ put += copy;
+ state->length -= copy;
+ }
+ Tracev((stderr, "inflate: stored end\n"));
+ state->mode = TYPE;
+ break;
+
+ case TABLE:
+ /* get dynamic table entries descriptor */
+ 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"));
+
+ /* get code length code lengths (not a typo) */
+ state->have = 0;
+ 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"));
+
+ /* get length and distance code code lengths */
+ state->have = 0;
+ 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 = (unsigned)(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;
+
+ case LEN:
+ /* use inflate_fast() if we have enough input and output */
+ if (have >= 6 && left >= 258) {
+ RESTORE();
+ if (state->whave < state->wsize)
+ state->whave = state->wsize - left;
+ inflate_fast(strm, state->wsize);
+ LOAD();
+ break;
+ }
+
+ /* get a literal, length, or end-of-block code */
+ 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);
+ }
+ DROPBITS(here.bits);
+ state->length = (unsigned)here.val;
+
+ /* process literal */
+ if (here.op == 0) {
+ Tracevv((stderr, here.val >= 0x20 && here.val < 0x7f ?
+ "inflate: literal '%c'\n" :
+ "inflate: literal 0x%02x\n", here.val));
+ ROOM();
+ *put++ = (unsigned char)(state->length);
+ left--;
+ state->mode = LEN;
+ break;
+ }
+
+ /* process end of block */
+ if (here.op & 32) {
+ Tracevv((stderr, "inflate: end of block\n"));
+ state->mode = TYPE;
+ break;
+ }
+
+ /* invalid code */
+ if (here.op & 64) {
+ strm->msg = (char *)"invalid literal/length code";
+ state->mode = BAD;
+ break;
+ }
+
+ /* length code -- get extra bits, if any */
+ state->extra = (unsigned)(here.op) & 15;
+ if (state->extra != 0) {
+ NEEDBITS(state->extra);
+ state->length += BITS(state->extra);
+ DROPBITS(state->extra);
+ }
+ Tracevv((stderr, "inflate: length %u\n", state->length));
+
+ /* get distance code */
+ 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);
+ }
+ DROPBITS(here.bits);
+ if (here.op & 64) {
+ strm->msg = (char *)"invalid distance code";
+ state->mode = BAD;
+ break;
+ }
+ state->offset = (unsigned)here.val;
+
+ /* get distance extra bits, if any */
+ state->extra = (unsigned)(here.op) & 15;
+ if (state->extra != 0) {
+ NEEDBITS(state->extra);
+ state->offset += BITS(state->extra);
+ DROPBITS(state->extra);
+ }
+ if (state->offset > state->wsize - (state->whave < state->wsize ?
+ left : 0)) {
+ strm->msg = (char *)"invalid distance too far back";
+ state->mode = BAD;
+ break;
+ }
+ Tracevv((stderr, "inflate: distance %u\n", state->offset));
+
+ /* copy match from window to output */
+ do {
+ ROOM();
+ copy = state->wsize - state->offset;
+ if (copy < left) {
+ from = put + copy;
+ copy = left - copy;
+ }
+ else {
+ from = put - state->offset;
+ copy = left;
+ }
+ if (copy > state->length) copy = state->length;
+ state->length -= copy;
+ left -= copy;
+ do {
+ *put++ = *from++;
+ } while (--copy);
+ } while (state->length != 0);
+ break;
+
+ case DONE:
+ /* inflate stream terminated properly -- write leftover output */
+ ret = Z_STREAM_END;
+ if (left < state->wsize) {
+ if (out(out_desc, state->window, state->wsize - left))
+ ret = Z_BUF_ERROR;
+ }
+ goto inf_leave;
+
+ case BAD:
+ ret = Z_DATA_ERROR;
+ goto inf_leave;
+
+ default: /* can't happen, but makes compilers happy */
+ ret = Z_STREAM_ERROR;
+ goto inf_leave;
+ }
+
+ /* Return unused input */
+ inf_leave:
+ strm->next_in = next;
+ strm->avail_in = have;
+ return ret;
+}
+
+int ZEXPORT inflateBackEnd(strm)
+z_streamp strm;
+{
+ if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
+ return Z_STREAM_ERROR;
+ ZFREE(strm, strm->state);
+ strm->state = Z_NULL;
+ Tracev((stderr, "inflate: end\n"));
+ return Z_OK;
+}
diff --git a/zlib/inffast.c b/zlib/inffast.c
new file mode 100644
index 000000000..0dbd1dbc0
--- /dev/null
+++ b/zlib/inffast.c
@@ -0,0 +1,323 @@
+/* inffast.c -- fast decoding
+ * Copyright (C) 1995-2017 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"
+
+#ifdef ASMINF
+# pragma message("Assembler code may have bugs -- use at your own risk")
+#else
+
+/*
+ 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;
+ z_const unsigned char FAR *in; /* local strm->next_in */
+ z_const unsigned char FAR *last; /* have enough input while in < last */
+ 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 long 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;
+ last = in + (strm->avail_in - 5);
+ out = strm->next_out;
+ 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 long)(*in++) << bits;
+ bits += 8;
+ hold += (unsigned long)(*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));
+ *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 long)(*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 long)(*in++) << bits;
+ bits += 8;
+ hold += (unsigned long)(*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 long)(*in++) << bits;
+ bits += 8;
+ if (bits < op) {
+ hold += (unsigned long)(*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 {
+ *out++ = 0;
+ } while (--len);
+ continue;
+ }
+ len -= op - whave;
+ do {
+ *out++ = 0;
+ } while (--op > whave);
+ if (op == 0) {
+ from = out - dist;
+ do {
+ *out++ = *from++;
+ } while (--len);
+ continue;
+ }
+#endif
+ }
+ from = window;
+ if (wnext == 0) { /* very common case */
+ from += wsize - op;
+ if (op < len) { /* some from window */
+ len -= op;
+ do {
+ *out++ = *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 {
+ *out++ = *from++;
+ } while (--op);
+ from = window;
+ if (wnext < len) { /* some from start of window */
+ op = wnext;
+ len -= op;
+ do {
+ *out++ = *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 {
+ *out++ = *from++;
+ } while (--op);
+ from = out - dist; /* rest from output */
+ }
+ }
+ while (len > 2) {
+ *out++ = *from++;
+ *out++ = *from++;
+ *out++ = *from++;
+ len -= 3;
+ }
+ if (len) {
+ *out++ = *from++;
+ if (len > 1)
+ *out++ = *from++;
+ }
+ }
+ else {
+ from = out - dist; /* copy direct from output */
+ do { /* minimum length is three */
+ *out++ = *from++;
+ *out++ = *from++;
+ *out++ = *from++;
+ len -= 3;
+ } while (len > 2);
+ if (len) {
+ *out++ = *from++;
+ if (len > 1)
+ *out++ = *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;
+ strm->next_out = out;
+ 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 000000000..e5c1aa4ca
--- /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 000000000..d62832776
--- /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 000000000..ac333e8c2
--- /dev/null
+++ b/zlib/inflate.c
@@ -0,0 +1,1561 @@
+/* inflate.c -- zlib decompression
+ * Copyright (C) 1995-2016 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 int inflateStateCheck OF((z_streamp strm));
+local void fixedtables OF((struct inflate_state FAR *state));
+local int updatewindow OF((z_streamp strm, const unsigned char FAR *end,
+ unsigned copy));
+#ifdef BUILDFIXED
+ void makefixed OF((void));
+#endif
+local unsigned syncsearch OF((unsigned FAR *have, const unsigned char FAR *buf,
+ unsigned len));
+
+local int inflateStateCheck(strm)
+z_streamp strm;
+{
+ struct inflate_state FAR *state;
+ if (strm == Z_NULL ||
+ strm->zalloc == (alloc_func)0 || strm->zfree == (free_func)0)
+ return 1;
+ state = (struct inflate_state FAR *)strm->state;
+ if (state == Z_NULL || state->strm != strm ||
+ state->mode < HEAD || state->mode > SYNC)
+ return 1;
+ return 0;
+}
+
+int ZEXPORT inflateResetKeep(strm)
+z_streamp strm;
+{
+ struct inflate_state FAR *state;
+
+ if (inflateStateCheck(strm)) 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 (inflateStateCheck(strm)) 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 (inflateStateCheck(strm)) 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) + 5;
+#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->strm = strm;
+ state->window = Z_NULL;
+ state->mode = HEAD; /* to pass state test in inflateReset2() */
+ 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 (inflateStateCheck(strm)) 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 + (uInt)bits > 32) return Z_STREAM_ERROR;
+ value &= (1L << bits) - 1;
+ state->hold += (unsigned)value << state->bits;
+ state->bits += (uInt)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 <stdio.h>
+
+/*
+ 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, end, copy)
+z_streamp strm;
+const Bytef *end;
+unsigned copy;
+{
+ struct inflate_state FAR *state;
+ unsigned 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 */
+ if (copy >= state->wsize) {
+ zmemcpy(state->window, end - 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, end - copy, dist);
+ copy -= dist;
+ if (copy) {
+ zmemcpy(state->window, end - 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 long)(*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;
+ z_const unsigned char FAR *next; /* next input */
+ unsigned char FAR *put; /* next output */
+ unsigned have, left; /* available input and output */
+ unsigned long 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 (inflateStateCheck(strm) || 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 */
+ if (state->wbits == 0)
+ state->wbits = 15;
+ 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;
+ if (len > 15 || 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) && (state->wrap & 4))
+ 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) && (state->wrap & 4))
+ 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) && (state->wrap & 4))
+ 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) && (state->wrap & 4))
+ 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->wrap & 4))
+ 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++] = (Bytef)len;
+ } while (len && copy < have);
+ if ((state->flags & 0x0200) && (state->wrap & 4))
+ 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++] = (Bytef)len;
+ } while (len && copy < have);
+ if ((state->flags & 0x0200) && (state->wrap & 4))
+ 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 ((state->wrap & 4) && 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 = (const code 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 = (const code 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 = (const code 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 ((state->wrap & 4) && out)
+ strm->adler = state->check =
+ UPDATE(state->check, put - out, out);
+ out = left;
+ if ((state->wrap & 4) && (
+#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, strm->next_out, out - strm->avail_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 & 4) && out)
+ strm->adler = state->check =
+ UPDATE(state->check, strm->next_out - out, out);
+ strm->data_type = (int)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 (inflateStateCheck(strm))
+ 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 inflateGetDictionary(strm, dictionary, dictLength)
+z_streamp strm;
+Bytef *dictionary;
+uInt *dictLength;
+{
+ struct inflate_state FAR *state;
+
+ /* check state */
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+
+ /* copy dictionary */
+ if (state->whave && dictionary != Z_NULL) {
+ zmemcpy(dictionary, state->window + state->wnext,
+ state->whave - state->wnext);
+ zmemcpy(dictionary + state->whave - state->wnext,
+ state->window, state->wnext);
+ }
+ if (dictLength != Z_NULL)
+ *dictLength = state->whave;
+ return Z_OK;
+}
+
+int ZEXPORT inflateSetDictionary(strm, dictionary, dictLength)
+z_streamp strm;
+const Bytef *dictionary;
+uInt dictLength;
+{
+ struct inflate_state FAR *state;
+ unsigned long dictid;
+ int ret;
+
+ /* check state */
+ if (inflateStateCheck(strm)) 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 */
+ ret = updatewindow(strm, dictionary + dictLength, dictLength);
+ 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 (inflateStateCheck(strm)) 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;
+const 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 long 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 (inflateStateCheck(strm)) 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 (inflateStateCheck(strm)) 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 (inflateStateCheck(source) || dest == Z_NULL)
+ 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));
+ copy->strm = dest;
+ 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 (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+#ifdef INFLATE_ALLOW_INVALID_DISTANCE_TOOFAR_ARRR
+ state->sane = !subvert;
+ return Z_OK;
+#else
+ (void)subvert;
+ state->sane = 1;
+ return Z_DATA_ERROR;
+#endif
+}
+
+int ZEXPORT inflateValidate(strm, check)
+z_streamp strm;
+int check;
+{
+ struct inflate_state FAR *state;
+
+ if (inflateStateCheck(strm)) return Z_STREAM_ERROR;
+ state = (struct inflate_state FAR *)strm->state;
+ if (check)
+ state->wrap |= 4;
+ else
+ state->wrap &= ~4;
+ return Z_OK;
+}
+
+long ZEXPORT inflateMark(strm)
+z_streamp strm;
+{
+ struct inflate_state FAR *state;
+
+ if (inflateStateCheck(strm))
+ return -(1L << 16);
+ state = (struct inflate_state FAR *)strm->state;
+ return (long)(((unsigned long)((long)state->back)) << 16) +
+ (state->mode == COPY ? state->length :
+ (state->mode == MATCH ? state->was - state->length : 0));
+}
+
+unsigned long ZEXPORT inflateCodesUsed(strm)
+z_streamp strm;
+{
+ struct inflate_state FAR *state;
+ if (inflateStateCheck(strm)) return (unsigned long)-1;
+ state = (struct inflate_state FAR *)strm->state;
+ return (unsigned long)(state->next - state->codes);
+}
diff --git a/zlib/inflate.h b/zlib/inflate.h
new file mode 100644
index 000000000..a46cce6b6
--- /dev/null
+++ b/zlib/inflate.h
@@ -0,0 +1,125 @@
+/* inflate.h -- internal inflate state definition
+ * Copyright (C) 1995-2016 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 = 16180, /* 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 7K bytes, not
+ including the allocated sliding window, which is up to 32K bytes. */
+struct inflate_state {
+ z_streamp strm; /* pointer back to this zlib stream */
+ 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,
+ bit 2 true to validate check value */
+ 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 long check; /* protected copy of check value */
+ unsigned long 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 long 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 000000000..2ea08fc13
--- /dev/null
+++ b/zlib/inftrees.c
@@ -0,0 +1,304 @@
+/* inftrees.c -- generate Huffman trees for efficient decoding
+ * Copyright (C) 1995-2017 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.11 Copyright 1995-2017 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 */
+ unsigned match; /* use base and extra for symbol >= match */
+ 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, 77, 202};
+ 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 */
+ match = 20;
+ break;
+ case LENS:
+ base = lbase;
+ extra = lext;
+ match = 257;
+ break;
+ default: /* DISTS */
+ base = dbase;
+ extra = dext;
+ match = 0;
+ }
+
+ /* 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 (work[sym] + 1U < match) {
+ here.op = (unsigned char)0;
+ here.val = work[sym];
+ }
+ else if (work[sym] >= match) {
+ here.op = (unsigned char)(extra[work[sym] - match]);
+ here.val = base[work[sym] - match];
+ }
+ 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 000000000..baa53a0b1
--- /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/test/example.c b/zlib/test/example.c
new file mode 100644
index 000000000..eee17ce7c
--- /dev/null
+++ b/zlib/test/example.c
@@ -0,0 +1,602 @@
+/* example.c -- usage example of the zlib compression library
+ * Copyright (C) 1995-2006, 2011, 2016 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#include "zlib.h"
+#include <stdio.h>
+
+#ifdef STDC
+# include <string.h>
+# include <stdlib.h>
+#endif
+
+#if defined(VMS) || defined(RISCOS)
+# define TESTFILE "foo-gz"
+#else
+# define TESTFILE "foo.gz"
+#endif
+
+#define CHECK_ERR(err, msg) { \
+ if (err != Z_OK) { \
+ fprintf(stderr, "%s error: %d\n", msg, err); \
+ exit(1); \
+ } \
+}
+
+static z_const char hello[] = "hello, hello!";
+/* "hello world" would be more standard, but the repeated "hello"
+ * stresses the compression code better, sorry...
+ */
+
+static const char dictionary[] = "hello";
+static uLong dictId; /* Adler32 value of the dictionary */
+
+void test_deflate OF((Byte *compr, uLong comprLen));
+void test_inflate OF((Byte *compr, uLong comprLen,
+ Byte *uncompr, uLong uncomprLen));
+void test_large_deflate OF((Byte *compr, uLong comprLen,
+ Byte *uncompr, uLong uncomprLen));
+void test_large_inflate OF((Byte *compr, uLong comprLen,
+ Byte *uncompr, uLong uncomprLen));
+void test_flush OF((Byte *compr, uLong *comprLen));
+void test_sync OF((Byte *compr, uLong comprLen,
+ Byte *uncompr, uLong uncomprLen));
+void test_dict_deflate OF((Byte *compr, uLong comprLen));
+void test_dict_inflate OF((Byte *compr, uLong comprLen,
+ Byte *uncompr, uLong uncomprLen));
+int main OF((int argc, char *argv[]));
+
+
+#ifdef Z_SOLO
+
+void *myalloc OF((void *, unsigned, unsigned));
+void myfree OF((void *, void *));
+
+void *myalloc(q, n, m)
+ void *q;
+ unsigned n, m;
+{
+ (void)q;
+ return calloc(n, m);
+}
+
+void myfree(void *q, void *p)
+{
+ (void)q;
+ free(p);
+}
+
+static alloc_func zalloc = myalloc;
+static free_func zfree = myfree;
+
+#else /* !Z_SOLO */
+
+static alloc_func zalloc = (alloc_func)0;
+static free_func zfree = (free_func)0;
+
+void test_compress OF((Byte *compr, uLong comprLen,
+ Byte *uncompr, uLong uncomprLen));
+void test_gzio OF((const char *fname,
+ Byte *uncompr, uLong uncomprLen));
+
+/* ===========================================================================
+ * Test compress() and uncompress()
+ */
+void test_compress(compr, comprLen, uncompr, uncomprLen)
+ Byte *compr, *uncompr;
+ uLong comprLen, uncomprLen;
+{
+ int err;
+ uLong len = (uLong)strlen(hello)+1;
+
+ err = compress(compr, &comprLen, (const Bytef*)hello, len);
+ CHECK_ERR(err, "compress");
+
+ strcpy((char*)uncompr, "garbage");
+
+ err = uncompress(uncompr, &uncomprLen, compr, comprLen);
+ CHECK_ERR(err, "uncompress");
+
+ if (strcmp((char*)uncompr, hello)) {
+ fprintf(stderr, "bad uncompress\n");
+ exit(1);
+ } else {
+ printf("uncompress(): %s\n", (char *)uncompr);
+ }
+}
+
+/* ===========================================================================
+ * Test read/write of .gz files
+ */
+void test_gzio(fname, uncompr, uncomprLen)
+ const char *fname; /* compressed file name */
+ Byte *uncompr;
+ uLong uncomprLen;
+{
+#ifdef NO_GZCOMPRESS
+ fprintf(stderr, "NO_GZCOMPRESS -- gz* functions cannot compress\n");
+#else
+ int err;
+ int len = (int)strlen(hello)+1;
+ gzFile file;
+ z_off_t pos;
+
+ file = gzopen(fname, "wb");
+ if (file == NULL) {
+ fprintf(stderr, "gzopen error\n");
+ exit(1);
+ }
+ gzputc(file, 'h');
+ if (gzputs(file, "ello") != 4) {
+ fprintf(stderr, "gzputs err: %s\n", gzerror(file, &err));
+ exit(1);
+ }
+ if (gzprintf(file, ", %s!", "hello") != 8) {
+ fprintf(stderr, "gzprintf err: %s\n", gzerror(file, &err));
+ exit(1);
+ }
+ gzseek(file, 1L, SEEK_CUR); /* add one zero byte */
+ gzclose(file);
+
+ file = gzopen(fname, "rb");
+ if (file == NULL) {
+ fprintf(stderr, "gzopen error\n");
+ exit(1);
+ }
+ strcpy((char*)uncompr, "garbage");
+
+ if (gzread(file, uncompr, (unsigned)uncomprLen) != len) {
+ fprintf(stderr, "gzread err: %s\n", gzerror(file, &err));
+ exit(1);
+ }
+ if (strcmp((char*)uncompr, hello)) {
+ fprintf(stderr, "bad gzread: %s\n", (char*)uncompr);
+ exit(1);
+ } else {
+ printf("gzread(): %s\n", (char*)uncompr);
+ }
+
+ pos = gzseek(file, -8L, SEEK_CUR);
+ if (pos != 6 || gztell(file) != pos) {
+ fprintf(stderr, "gzseek error, pos=%ld, gztell=%ld\n",
+ (long)pos, (long)gztell(file));
+ exit(1);
+ }
+
+ if (gzgetc(file) != ' ') {
+ fprintf(stderr, "gzgetc error\n");
+ exit(1);
+ }
+
+ if (gzungetc(' ', file) != ' ') {
+ fprintf(stderr, "gzungetc error\n");
+ exit(1);
+ }
+
+ gzgets(file, (char*)uncompr, (int)uncomprLen);
+ if (strlen((char*)uncompr) != 7) { /* " hello!" */
+ fprintf(stderr, "gzgets err after gzseek: %s\n", gzerror(file, &err));
+ exit(1);
+ }
+ if (strcmp((char*)uncompr, hello + 6)) {
+ fprintf(stderr, "bad gzgets after gzseek\n");
+ exit(1);
+ } else {
+ printf("gzgets() after gzseek: %s\n", (char*)uncompr);
+ }
+
+ gzclose(file);
+#endif
+}
+
+#endif /* Z_SOLO */
+
+/* ===========================================================================
+ * Test deflate() with small buffers
+ */
+void test_deflate(compr, comprLen)
+ Byte *compr;
+ uLong comprLen;
+{
+ z_stream c_stream; /* compression stream */
+ int err;
+ uLong len = (uLong)strlen(hello)+1;
+
+ c_stream.zalloc = zalloc;
+ c_stream.zfree = zfree;
+ c_stream.opaque = (voidpf)0;
+
+ err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
+ CHECK_ERR(err, "deflateInit");
+
+ c_stream.next_in = (z_const unsigned char *)hello;
+ c_stream.next_out = compr;
+
+ while (c_stream.total_in != len && c_stream.total_out < comprLen) {
+ c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
+ err = deflate(&c_stream, Z_NO_FLUSH);
+ CHECK_ERR(err, "deflate");
+ }
+ /* Finish the stream, still forcing small buffers: */
+ for (;;) {
+ c_stream.avail_out = 1;
+ err = deflate(&c_stream, Z_FINISH);
+ if (err == Z_STREAM_END) break;
+ CHECK_ERR(err, "deflate");
+ }
+
+ err = deflateEnd(&c_stream);
+ CHECK_ERR(err, "deflateEnd");
+}
+
+/* ===========================================================================
+ * Test inflate() with small buffers
+ */
+void test_inflate(compr, comprLen, uncompr, uncomprLen)
+ Byte *compr, *uncompr;
+ uLong comprLen, uncomprLen;
+{
+ int err;
+ z_stream d_stream; /* decompression stream */
+
+ strcpy((char*)uncompr, "garbage");
+
+ d_stream.zalloc = zalloc;
+ d_stream.zfree = zfree;
+ d_stream.opaque = (voidpf)0;
+
+ d_stream.next_in = compr;
+ d_stream.avail_in = 0;
+ d_stream.next_out = uncompr;
+
+ err = inflateInit(&d_stream);
+ CHECK_ERR(err, "inflateInit");
+
+ while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) {
+ d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
+ err = inflate(&d_stream, Z_NO_FLUSH);
+ if (err == Z_STREAM_END) break;
+ CHECK_ERR(err, "inflate");
+ }
+
+ err = inflateEnd(&d_stream);
+ CHECK_ERR(err, "inflateEnd");
+
+ if (strcmp((char*)uncompr, hello)) {
+ fprintf(stderr, "bad inflate\n");
+ exit(1);
+ } else {
+ printf("inflate(): %s\n", (char *)uncompr);
+ }
+}
+
+/* ===========================================================================
+ * Test deflate() with large buffers and dynamic change of compression level
+ */
+void test_large_deflate(compr, comprLen, uncompr, uncomprLen)
+ Byte *compr, *uncompr;
+ uLong comprLen, uncomprLen;
+{
+ z_stream c_stream; /* compression stream */
+ int err;
+
+ c_stream.zalloc = zalloc;
+ c_stream.zfree = zfree;
+ c_stream.opaque = (voidpf)0;
+
+ err = deflateInit(&c_stream, Z_BEST_SPEED);
+ CHECK_ERR(err, "deflateInit");
+
+ c_stream.next_out = compr;
+ c_stream.avail_out = (uInt)comprLen;
+
+ /* At this point, uncompr is still mostly zeroes, so it should compress
+ * very well:
+ */
+ c_stream.next_in = uncompr;
+ c_stream.avail_in = (uInt)uncomprLen;
+ err = deflate(&c_stream, Z_NO_FLUSH);
+ CHECK_ERR(err, "deflate");
+ if (c_stream.avail_in != 0) {
+ fprintf(stderr, "deflate not greedy\n");
+ exit(1);
+ }
+
+ /* Feed in already compressed data and switch to no compression: */
+ deflateParams(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);
+ c_stream.next_in = compr;
+ c_stream.avail_in = (uInt)comprLen/2;
+ err = deflate(&c_stream, Z_NO_FLUSH);
+ CHECK_ERR(err, "deflate");
+
+ /* Switch back to compressing mode: */
+ deflateParams(&c_stream, Z_BEST_COMPRESSION, Z_FILTERED);
+ c_stream.next_in = uncompr;
+ c_stream.avail_in = (uInt)uncomprLen;
+ err = deflate(&c_stream, Z_NO_FLUSH);
+ CHECK_ERR(err, "deflate");
+
+ err = deflate(&c_stream, Z_FINISH);
+ if (err != Z_STREAM_END) {
+ fprintf(stderr, "deflate should report Z_STREAM_END\n");
+ exit(1);
+ }
+ err = deflateEnd(&c_stream);
+ CHECK_ERR(err, "deflateEnd");
+}
+
+/* ===========================================================================
+ * Test inflate() with large buffers
+ */
+void test_large_inflate(compr, comprLen, uncompr, uncomprLen)
+ Byte *compr, *uncompr;
+ uLong comprLen, uncomprLen;
+{
+ int err;
+ z_stream d_stream; /* decompression stream */
+
+ strcpy((char*)uncompr, "garbage");
+
+ d_stream.zalloc = zalloc;
+ d_stream.zfree = zfree;
+ d_stream.opaque = (voidpf)0;
+
+ d_stream.next_in = compr;
+ d_stream.avail_in = (uInt)comprLen;
+
+ err = inflateInit(&d_stream);
+ CHECK_ERR(err, "inflateInit");
+
+ for (;;) {
+ d_stream.next_out = uncompr; /* discard the output */
+ d_stream.avail_out = (uInt)uncomprLen;
+ err = inflate(&d_stream, Z_NO_FLUSH);
+ if (err == Z_STREAM_END) break;
+ CHECK_ERR(err, "large inflate");
+ }
+
+ err = inflateEnd(&d_stream);
+ CHECK_ERR(err, "inflateEnd");
+
+ if (d_stream.total_out != 2*uncomprLen + comprLen/2) {
+ fprintf(stderr, "bad large inflate: %ld\n", d_stream.total_out);
+ exit(1);
+ } else {
+ printf("large_inflate(): OK\n");
+ }
+}
+
+/* ===========================================================================
+ * Test deflate() with full flush
+ */
+void test_flush(compr, comprLen)
+ Byte *compr;
+ uLong *comprLen;
+{
+ z_stream c_stream; /* compression stream */
+ int err;
+ uInt len = (uInt)strlen(hello)+1;
+
+ c_stream.zalloc = zalloc;
+ c_stream.zfree = zfree;
+ c_stream.opaque = (voidpf)0;
+
+ err = deflateInit(&c_stream, Z_DEFAULT_COMPRESSION);
+ CHECK_ERR(err, "deflateInit");
+
+ c_stream.next_in = (z_const unsigned char *)hello;
+ c_stream.next_out = compr;
+ c_stream.avail_in = 3;
+ c_stream.avail_out = (uInt)*comprLen;
+ err = deflate(&c_stream, Z_FULL_FLUSH);
+ CHECK_ERR(err, "deflate");
+
+ compr[3]++; /* force an error in first compressed block */
+ c_stream.avail_in = len - 3;
+
+ err = deflate(&c_stream, Z_FINISH);
+ if (err != Z_STREAM_END) {
+ CHECK_ERR(err, "deflate");
+ }
+ err = deflateEnd(&c_stream);
+ CHECK_ERR(err, "deflateEnd");
+
+ *comprLen = c_stream.total_out;
+}
+
+/* ===========================================================================
+ * Test inflateSync()
+ */
+void test_sync(compr, comprLen, uncompr, uncomprLen)
+ Byte *compr, *uncompr;
+ uLong comprLen, uncomprLen;
+{
+ int err;
+ z_stream d_stream; /* decompression stream */
+
+ strcpy((char*)uncompr, "garbage");
+
+ d_stream.zalloc = zalloc;
+ d_stream.zfree = zfree;
+ d_stream.opaque = (voidpf)0;
+
+ d_stream.next_in = compr;
+ d_stream.avail_in = 2; /* just read the zlib header */
+
+ err = inflateInit(&d_stream);
+ CHECK_ERR(err, "inflateInit");
+
+ d_stream.next_out = uncompr;
+ d_stream.avail_out = (uInt)uncomprLen;
+
+ err = inflate(&d_stream, Z_NO_FLUSH);
+ CHECK_ERR(err, "inflate");
+
+ d_stream.avail_in = (uInt)comprLen-2; /* read all compressed data */
+ err = inflateSync(&d_stream); /* but skip the damaged part */
+ CHECK_ERR(err, "inflateSync");
+
+ err = inflate(&d_stream, Z_FINISH);
+ if (err != Z_DATA_ERROR) {
+ fprintf(stderr, "inflate should report DATA_ERROR\n");
+ /* Because of incorrect adler32 */
+ exit(1);
+ }
+ err = inflateEnd(&d_stream);
+ CHECK_ERR(err, "inflateEnd");
+
+ printf("after inflateSync(): hel%s\n", (char *)uncompr);
+}
+
+/* ===========================================================================
+ * Test deflate() with preset dictionary
+ */
+void test_dict_deflate(compr, comprLen)
+ Byte *compr;
+ uLong comprLen;
+{
+ z_stream c_stream; /* compression stream */
+ int err;
+
+ c_stream.zalloc = zalloc;
+ c_stream.zfree = zfree;
+ c_stream.opaque = (voidpf)0;
+
+ err = deflateInit(&c_stream, Z_BEST_COMPRESSION);
+ CHECK_ERR(err, "deflateInit");
+
+ err = deflateSetDictionary(&c_stream,
+ (const Bytef*)dictionary, (int)sizeof(dictionary));
+ CHECK_ERR(err, "deflateSetDictionary");
+
+ dictId = c_stream.adler;
+ c_stream.next_out = compr;
+ c_stream.avail_out = (uInt)comprLen;
+
+ c_stream.next_in = (z_const unsigned char *)hello;
+ c_stream.avail_in = (uInt)strlen(hello)+1;
+
+ err = deflate(&c_stream, Z_FINISH);
+ if (err != Z_STREAM_END) {
+ fprintf(stderr, "deflate should report Z_STREAM_END\n");
+ exit(1);
+ }
+ err = deflateEnd(&c_stream);
+ CHECK_ERR(err, "deflateEnd");
+}
+
+/* ===========================================================================
+ * Test inflate() with a preset dictionary
+ */
+void test_dict_inflate(compr, comprLen, uncompr, uncomprLen)
+ Byte *compr, *uncompr;
+ uLong comprLen, uncomprLen;
+{
+ int err;
+ z_stream d_stream; /* decompression stream */
+
+ strcpy((char*)uncompr, "garbage");
+
+ d_stream.zalloc = zalloc;
+ d_stream.zfree = zfree;
+ d_stream.opaque = (voidpf)0;
+
+ d_stream.next_in = compr;
+ d_stream.avail_in = (uInt)comprLen;
+
+ err = inflateInit(&d_stream);
+ CHECK_ERR(err, "inflateInit");
+
+ d_stream.next_out = uncompr;
+ d_stream.avail_out = (uInt)uncomprLen;
+
+ for (;;) {
+ err = inflate(&d_stream, Z_NO_FLUSH);
+ if (err == Z_STREAM_END) break;
+ if (err == Z_NEED_DICT) {
+ if (d_stream.adler != dictId) {
+ fprintf(stderr, "unexpected dictionary");
+ exit(1);
+ }
+ err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary,
+ (int)sizeof(dictionary));
+ }
+ CHECK_ERR(err, "inflate with dict");
+ }
+
+ err = inflateEnd(&d_stream);
+ CHECK_ERR(err, "inflateEnd");
+
+ if (strcmp((char*)uncompr, hello)) {
+ fprintf(stderr, "bad inflate with dict\n");
+ exit(1);
+ } else {
+ printf("inflate with dictionary: %s\n", (char *)uncompr);
+ }
+}
+
+/* ===========================================================================
+ * Usage: example [output.gz [input.gz]]
+ */
+
+int main(argc, argv)
+ int argc;
+ char *argv[];
+{
+ Byte *compr, *uncompr;
+ uLong comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */
+ uLong uncomprLen = comprLen;
+ static const char* myVersion = ZLIB_VERSION;
+
+ if (zlibVersion()[0] != myVersion[0]) {
+ fprintf(stderr, "incompatible zlib version\n");
+ exit(1);
+
+ } else if (strcmp(zlibVersion(), ZLIB_VERSION) != 0) {
+ fprintf(stderr, "warning: different zlib version\n");
+ }
+
+ printf("zlib version %s = 0x%04x, compile flags = 0x%lx\n",
+ ZLIB_VERSION, ZLIB_VERNUM, zlibCompileFlags());
+
+ compr = (Byte*)calloc((uInt)comprLen, 1);
+ uncompr = (Byte*)calloc((uInt)uncomprLen, 1);
+ /* compr and uncompr are cleared to avoid reading uninitialized
+ * data and to ensure that uncompr compresses well.
+ */
+ if (compr == Z_NULL || uncompr == Z_NULL) {
+ printf("out of memory\n");
+ exit(1);
+ }
+
+#ifdef Z_SOLO
+ (void)argc;
+ (void)argv;
+#else
+ test_compress(compr, comprLen, uncompr, uncomprLen);
+
+ test_gzio((argc > 1 ? argv[1] : TESTFILE),
+ uncompr, uncomprLen);
+#endif
+
+ test_deflate(compr, comprLen);
+ test_inflate(compr, comprLen, uncompr, uncomprLen);
+
+ test_large_deflate(compr, comprLen, uncompr, uncomprLen);
+ test_large_inflate(compr, comprLen, uncompr, uncomprLen);
+
+ test_flush(compr, &comprLen);
+ test_sync(compr, comprLen, uncompr, uncomprLen);
+ comprLen = uncomprLen;
+
+ test_dict_deflate(compr, comprLen);
+ test_dict_inflate(compr, comprLen, uncompr, uncomprLen);
+
+ free(compr);
+ free(uncompr);
+
+ return 0;
+}
diff --git a/zlib/test/infcover.c b/zlib/test/infcover.c
new file mode 100644
index 000000000..2be01646c
--- /dev/null
+++ b/zlib/test/infcover.c
@@ -0,0 +1,671 @@
+/* infcover.c -- test zlib's inflate routines with full code coverage
+ * Copyright (C) 2011, 2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* to use, do: ./configure --cover && make cover */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <assert.h>
+#include "zlib.h"
+
+/* get definition of internal structure so we can mess with it (see pull()),
+ and so we can call inflate_trees() (see cover5()) */
+#define ZLIB_INTERNAL
+#include "inftrees.h"
+#include "inflate.h"
+
+#define local static
+
+/* -- memory tracking routines -- */
+
+/*
+ These memory tracking routines are provided to zlib and track all of zlib's
+ allocations and deallocations, check for LIFO operations, keep a current
+ and high water mark of total bytes requested, optionally set a limit on the
+ total memory that can be allocated, and when done check for memory leaks.
+
+ They are used as follows:
+
+ z_stream strm;
+ mem_setup(&strm) initializes the memory tracking and sets the
+ zalloc, zfree, and opaque members of strm to use
+ memory tracking for all zlib operations on strm
+ mem_limit(&strm, limit) sets a limit on the total bytes requested -- a
+ request that exceeds this limit will result in an
+ allocation failure (returns NULL) -- setting the
+ limit to zero means no limit, which is the default
+ after mem_setup()
+ mem_used(&strm, "msg") prints to stderr "msg" and the total bytes used
+ mem_high(&strm, "msg") prints to stderr "msg" and the high water mark
+ mem_done(&strm, "msg") ends memory tracking, releases all allocations
+ for the tracking as well as leaked zlib blocks, if
+ any. If there was anything unusual, such as leaked
+ blocks, non-FIFO frees, or frees of addresses not
+ allocated, then "msg" and information about the
+ problem is printed to stderr. If everything is
+ normal, nothing is printed. mem_done resets the
+ strm members to Z_NULL to use the default memory
+ allocation routines on the next zlib initialization
+ using strm.
+ */
+
+/* these items are strung together in a linked list, one for each allocation */
+struct mem_item {
+ void *ptr; /* pointer to allocated memory */
+ size_t size; /* requested size of allocation */
+ struct mem_item *next; /* pointer to next item in list, or NULL */
+};
+
+/* this structure is at the root of the linked list, and tracks statistics */
+struct mem_zone {
+ struct mem_item *first; /* pointer to first item in list, or NULL */
+ size_t total, highwater; /* total allocations, and largest total */
+ size_t limit; /* memory allocation limit, or 0 if no limit */
+ int notlifo, rogue; /* counts of non-LIFO frees and rogue frees */
+};
+
+/* memory allocation routine to pass to zlib */
+local void *mem_alloc(void *mem, unsigned count, unsigned size)
+{
+ void *ptr;
+ struct mem_item *item;
+ struct mem_zone *zone = mem;
+ size_t len = count * (size_t)size;
+
+ /* induced allocation failure */
+ if (zone == NULL || (zone->limit && zone->total + len > zone->limit))
+ return NULL;
+
+ /* perform allocation using the standard library, fill memory with a
+ non-zero value to make sure that the code isn't depending on zeros */
+ ptr = malloc(len);
+ if (ptr == NULL)
+ return NULL;
+ memset(ptr, 0xa5, len);
+
+ /* create a new item for the list */
+ item = malloc(sizeof(struct mem_item));
+ if (item == NULL) {
+ free(ptr);
+ return NULL;
+ }
+ item->ptr = ptr;
+ item->size = len;
+
+ /* insert item at the beginning of the list */
+ item->next = zone->first;
+ zone->first = item;
+
+ /* update the statistics */
+ zone->total += item->size;
+ if (zone->total > zone->highwater)
+ zone->highwater = zone->total;
+
+ /* return the allocated memory */
+ return ptr;
+}
+
+/* memory free routine to pass to zlib */
+local void mem_free(void *mem, void *ptr)
+{
+ struct mem_item *item, *next;
+ struct mem_zone *zone = mem;
+
+ /* if no zone, just do a free */
+ if (zone == NULL) {
+ free(ptr);
+ return;
+ }
+
+ /* point next to the item that matches ptr, or NULL if not found -- remove
+ the item from the linked list if found */
+ next = zone->first;
+ if (next) {
+ if (next->ptr == ptr)
+ zone->first = next->next; /* first one is it, remove from list */
+ else {
+ do { /* search the linked list */
+ item = next;
+ next = item->next;
+ } while (next != NULL && next->ptr != ptr);
+ if (next) { /* if found, remove from linked list */
+ item->next = next->next;
+ zone->notlifo++; /* not a LIFO free */
+ }
+
+ }
+ }
+
+ /* if found, update the statistics and free the item */
+ if (next) {
+ zone->total -= next->size;
+ free(next);
+ }
+
+ /* if not found, update the rogue count */
+ else
+ zone->rogue++;
+
+ /* in any case, do the requested free with the standard library function */
+ free(ptr);
+}
+
+/* set up a controlled memory allocation space for monitoring, set the stream
+ parameters to the controlled routines, with opaque pointing to the space */
+local void mem_setup(z_stream *strm)
+{
+ struct mem_zone *zone;
+
+ zone = malloc(sizeof(struct mem_zone));
+ assert(zone != NULL);
+ zone->first = NULL;
+ zone->total = 0;
+ zone->highwater = 0;
+ zone->limit = 0;
+ zone->notlifo = 0;
+ zone->rogue = 0;
+ strm->opaque = zone;
+ strm->zalloc = mem_alloc;
+ strm->zfree = mem_free;
+}
+
+/* set a limit on the total memory allocation, or 0 to remove the limit */
+local void mem_limit(z_stream *strm, size_t limit)
+{
+ struct mem_zone *zone = strm->opaque;
+
+ zone->limit = limit;
+}
+
+/* show the current total requested allocations in bytes */
+local void mem_used(z_stream *strm, char *prefix)
+{
+ struct mem_zone *zone = strm->opaque;
+
+ fprintf(stderr, "%s: %lu allocated\n", prefix, zone->total);
+}
+
+/* show the high water allocation in bytes */
+local void mem_high(z_stream *strm, char *prefix)
+{
+ struct mem_zone *zone = strm->opaque;
+
+ fprintf(stderr, "%s: %lu high water mark\n", prefix, zone->highwater);
+}
+
+/* release the memory allocation zone -- if there are any surprises, notify */
+local void mem_done(z_stream *strm, char *prefix)
+{
+ int count = 0;
+ struct mem_item *item, *next;
+ struct mem_zone *zone = strm->opaque;
+
+ /* show high water mark */
+ mem_high(strm, prefix);
+
+ /* free leftover allocations and item structures, if any */
+ item = zone->first;
+ while (item != NULL) {
+ free(item->ptr);
+ next = item->next;
+ free(item);
+ item = next;
+ count++;
+ }
+
+ /* issue alerts about anything unexpected */
+ if (count || zone->total)
+ fprintf(stderr, "** %s: %lu bytes in %d blocks not freed\n",
+ prefix, zone->total, count);
+ if (zone->notlifo)
+ fprintf(stderr, "** %s: %d frees not LIFO\n", prefix, zone->notlifo);
+ if (zone->rogue)
+ fprintf(stderr, "** %s: %d frees not recognized\n",
+ prefix, zone->rogue);
+
+ /* free the zone and delete from the stream */
+ free(zone);
+ strm->opaque = Z_NULL;
+ strm->zalloc = Z_NULL;
+ strm->zfree = Z_NULL;
+}
+
+/* -- inflate test routines -- */
+
+/* Decode a hexadecimal string, set *len to length, in[] to the bytes. This
+ decodes liberally, in that hex digits can be adjacent, in which case two in
+ a row writes a byte. Or they can be delimited by any non-hex character,
+ where the delimiters are ignored except when a single hex digit is followed
+ by a delimiter, where that single digit writes a byte. The returned data is
+ allocated and must eventually be freed. NULL is returned if out of memory.
+ If the length is not needed, then len can be NULL. */
+local unsigned char *h2b(const char *hex, unsigned *len)
+{
+ unsigned char *in, *re;
+ unsigned next, val;
+
+ in = malloc((strlen(hex) + 1) >> 1);
+ if (in == NULL)
+ return NULL;
+ next = 0;
+ val = 1;
+ do {
+ if (*hex >= '0' && *hex <= '9')
+ val = (val << 4) + *hex - '0';
+ else if (*hex >= 'A' && *hex <= 'F')
+ val = (val << 4) + *hex - 'A' + 10;
+ else if (*hex >= 'a' && *hex <= 'f')
+ val = (val << 4) + *hex - 'a' + 10;
+ else if (val != 1 && val < 32) /* one digit followed by delimiter */
+ val += 240; /* make it look like two digits */
+ if (val > 255) { /* have two digits */
+ in[next++] = val & 0xff; /* save the decoded byte */
+ val = 1; /* start over */
+ }
+ } while (*hex++); /* go through the loop with the terminating null */
+ if (len != NULL)
+ *len = next;
+ re = realloc(in, next);
+ return re == NULL ? in : re;
+}
+
+/* generic inflate() run, where hex is the hexadecimal input data, what is the
+ text to include in an error message, step is how much input data to feed
+ inflate() on each call, or zero to feed it all, win is the window bits
+ parameter to inflateInit2(), len is the size of the output buffer, and err
+ is the error code expected from the first inflate() call (the second
+ inflate() call is expected to return Z_STREAM_END). If win is 47, then
+ header information is collected with inflateGetHeader(). If a zlib stream
+ is looking for a dictionary, then an empty dictionary is provided.
+ inflate() is run until all of the input data is consumed. */
+local void inf(char *hex, char *what, unsigned step, int win, unsigned len,
+ int err)
+{
+ int ret;
+ unsigned have;
+ unsigned char *in, *out;
+ z_stream strm, copy;
+ gz_header head;
+
+ mem_setup(&strm);
+ strm.avail_in = 0;
+ strm.next_in = Z_NULL;
+ ret = inflateInit2(&strm, win);
+ if (ret != Z_OK) {
+ mem_done(&strm, what);
+ return;
+ }
+ out = malloc(len); assert(out != NULL);
+ if (win == 47) {
+ head.extra = out;
+ head.extra_max = len;
+ head.name = out;
+ head.name_max = len;
+ head.comment = out;
+ head.comm_max = len;
+ ret = inflateGetHeader(&strm, &head); assert(ret == Z_OK);
+ }
+ in = h2b(hex, &have); assert(in != NULL);
+ if (step == 0 || step > have)
+ step = have;
+ strm.avail_in = step;
+ have -= step;
+ strm.next_in = in;
+ do {
+ strm.avail_out = len;
+ strm.next_out = out;
+ ret = inflate(&strm, Z_NO_FLUSH); assert(err == 9 || ret == err);
+ if (ret != Z_OK && ret != Z_BUF_ERROR && ret != Z_NEED_DICT)
+ break;
+ if (ret == Z_NEED_DICT) {
+ ret = inflateSetDictionary(&strm, in, 1);
+ assert(ret == Z_DATA_ERROR);
+ mem_limit(&strm, 1);
+ ret = inflateSetDictionary(&strm, out, 0);
+ assert(ret == Z_MEM_ERROR);
+ mem_limit(&strm, 0);
+ ((struct inflate_state *)strm.state)->mode = DICT;
+ ret = inflateSetDictionary(&strm, out, 0);
+ assert(ret == Z_OK);
+ ret = inflate(&strm, Z_NO_FLUSH); assert(ret == Z_BUF_ERROR);
+ }
+ ret = inflateCopy(©, &strm); assert(ret == Z_OK);
+ ret = inflateEnd(©); assert(ret == Z_OK);
+ err = 9; /* don't care next time around */
+ have += strm.avail_in;
+ strm.avail_in = step > have ? have : step;
+ have -= strm.avail_in;
+ } while (strm.avail_in);
+ free(in);
+ free(out);
+ ret = inflateReset2(&strm, -8); assert(ret == Z_OK);
+ ret = inflateEnd(&strm); assert(ret == Z_OK);
+ mem_done(&strm, what);
+}
+
+/* cover all of the lines in inflate.c up to inflate() */
+local void cover_support(void)
+{
+ int ret;
+ z_stream strm;
+
+ mem_setup(&strm);
+ strm.avail_in = 0;
+ strm.next_in = Z_NULL;
+ ret = inflateInit(&strm); assert(ret == Z_OK);
+ mem_used(&strm, "inflate init");
+ ret = inflatePrime(&strm, 5, 31); assert(ret == Z_OK);
+ ret = inflatePrime(&strm, -1, 0); assert(ret == Z_OK);
+ ret = inflateSetDictionary(&strm, Z_NULL, 0);
+ assert(ret == Z_STREAM_ERROR);
+ ret = inflateEnd(&strm); assert(ret == Z_OK);
+ mem_done(&strm, "prime");
+
+ inf("63 0", "force window allocation", 0, -15, 1, Z_OK);
+ inf("63 18 5", "force window replacement", 0, -8, 259, Z_OK);
+ inf("63 18 68 30 d0 0 0", "force split window update", 4, -8, 259, Z_OK);
+ inf("3 0", "use fixed blocks", 0, -15, 1, Z_STREAM_END);
+ inf("", "bad window size", 0, 1, 0, Z_STREAM_ERROR);
+
+ mem_setup(&strm);
+ strm.avail_in = 0;
+ strm.next_in = Z_NULL;
+ ret = inflateInit_(&strm, ZLIB_VERSION - 1, (int)sizeof(z_stream));
+ assert(ret == Z_VERSION_ERROR);
+ mem_done(&strm, "wrong version");
+
+ strm.avail_in = 0;
+ strm.next_in = Z_NULL;
+ ret = inflateInit(&strm); assert(ret == Z_OK);
+ ret = inflateEnd(&strm); assert(ret == Z_OK);
+ fputs("inflate built-in memory routines\n", stderr);
+}
+
+/* cover all inflate() header and trailer cases and code after inflate() */
+local void cover_wrap(void)
+{
+ int ret;
+ z_stream strm, copy;
+ unsigned char dict[257];
+
+ ret = inflate(Z_NULL, 0); assert(ret == Z_STREAM_ERROR);
+ ret = inflateEnd(Z_NULL); assert(ret == Z_STREAM_ERROR);
+ ret = inflateCopy(Z_NULL, Z_NULL); assert(ret == Z_STREAM_ERROR);
+ fputs("inflate bad parameters\n", stderr);
+
+ inf("1f 8b 0 0", "bad gzip method", 0, 31, 0, Z_DATA_ERROR);
+ inf("1f 8b 8 80", "bad gzip flags", 0, 31, 0, Z_DATA_ERROR);
+ inf("77 85", "bad zlib method", 0, 15, 0, Z_DATA_ERROR);
+ inf("8 99", "set window size from header", 0, 0, 0, Z_OK);
+ inf("78 9c", "bad zlib window size", 0, 8, 0, Z_DATA_ERROR);
+ inf("78 9c 63 0 0 0 1 0 1", "check adler32", 0, 15, 1, Z_STREAM_END);
+ inf("1f 8b 8 1e 0 0 0 0 0 0 1 0 0 0 0 0 0", "bad header crc", 0, 47, 1,
+ Z_DATA_ERROR);
+ inf("1f 8b 8 2 0 0 0 0 0 0 1d 26 3 0 0 0 0 0 0 0 0 0", "check gzip length",
+ 0, 47, 0, Z_STREAM_END);
+ inf("78 90", "bad zlib header check", 0, 47, 0, Z_DATA_ERROR);
+ inf("8 b8 0 0 0 1", "need dictionary", 0, 8, 0, Z_NEED_DICT);
+ inf("78 9c 63 0", "compute adler32", 0, 15, 1, Z_OK);
+
+ mem_setup(&strm);
+ strm.avail_in = 0;
+ strm.next_in = Z_NULL;
+ ret = inflateInit2(&strm, -8);
+ strm.avail_in = 2;
+ strm.next_in = (void *)"\x63";
+ strm.avail_out = 1;
+ strm.next_out = (void *)&ret;
+ mem_limit(&strm, 1);
+ ret = inflate(&strm, Z_NO_FLUSH); assert(ret == Z_MEM_ERROR);
+ ret = inflate(&strm, Z_NO_FLUSH); assert(ret == Z_MEM_ERROR);
+ mem_limit(&strm, 0);
+ memset(dict, 0, 257);
+ ret = inflateSetDictionary(&strm, dict, 257);
+ assert(ret == Z_OK);
+ mem_limit(&strm, (sizeof(struct inflate_state) << 1) + 256);
+ ret = inflatePrime(&strm, 16, 0); assert(ret == Z_OK);
+ strm.avail_in = 2;
+ strm.next_in = (void *)"\x80";
+ ret = inflateSync(&strm); assert(ret == Z_DATA_ERROR);
+ ret = inflate(&strm, Z_NO_FLUSH); assert(ret == Z_STREAM_ERROR);
+ strm.avail_in = 4;
+ strm.next_in = (void *)"\0\0\xff\xff";
+ ret = inflateSync(&strm); assert(ret == Z_OK);
+ (void)inflateSyncPoint(&strm);
+ ret = inflateCopy(©, &strm); assert(ret == Z_MEM_ERROR);
+ mem_limit(&strm, 0);
+ ret = inflateUndermine(&strm, 1); assert(ret == Z_DATA_ERROR);
+ (void)inflateMark(&strm);
+ ret = inflateEnd(&strm); assert(ret == Z_OK);
+ mem_done(&strm, "miscellaneous, force memory errors");
+}
+
+/* input and output functions for inflateBack() */
+local unsigned pull(void *desc, unsigned char **buf)
+{
+ static unsigned int next = 0;
+ static unsigned char dat[] = {0x63, 0, 2, 0};
+ struct inflate_state *state;
+
+ if (desc == Z_NULL) {
+ next = 0;
+ return 0; /* no input (already provided at next_in) */
+ }
+ state = (void *)((z_stream *)desc)->state;
+ if (state != Z_NULL)
+ state->mode = SYNC; /* force an otherwise impossible situation */
+ return next < sizeof(dat) ? (*buf = dat + next++, 1) : 0;
+}
+
+local int push(void *desc, unsigned char *buf, unsigned len)
+{
+ buf += len;
+ return desc != Z_NULL; /* force error if desc not null */
+}
+
+/* cover inflateBack() up to common deflate data cases and after those */
+local void cover_back(void)
+{
+ int ret;
+ z_stream strm;
+ unsigned char win[32768];
+
+ ret = inflateBackInit_(Z_NULL, 0, win, 0, 0);
+ assert(ret == Z_VERSION_ERROR);
+ ret = inflateBackInit(Z_NULL, 0, win); assert(ret == Z_STREAM_ERROR);
+ ret = inflateBack(Z_NULL, Z_NULL, Z_NULL, Z_NULL, Z_NULL);
+ assert(ret == Z_STREAM_ERROR);
+ ret = inflateBackEnd(Z_NULL); assert(ret == Z_STREAM_ERROR);
+ fputs("inflateBack bad parameters\n", stderr);
+
+ mem_setup(&strm);
+ ret = inflateBackInit(&strm, 15, win); assert(ret == Z_OK);
+ strm.avail_in = 2;
+ strm.next_in = (void *)"\x03";
+ ret = inflateBack(&strm, pull, Z_NULL, push, Z_NULL);
+ assert(ret == Z_STREAM_END);
+ /* force output error */
+ strm.avail_in = 3;
+ strm.next_in = (void *)"\x63\x00";
+ ret = inflateBack(&strm, pull, Z_NULL, push, &strm);
+ assert(ret == Z_BUF_ERROR);
+ /* force mode error by mucking with state */
+ ret = inflateBack(&strm, pull, &strm, push, Z_NULL);
+ assert(ret == Z_STREAM_ERROR);
+ ret = inflateBackEnd(&strm); assert(ret == Z_OK);
+ mem_done(&strm, "inflateBack bad state");
+
+ ret = inflateBackInit(&strm, 15, win); assert(ret == Z_OK);
+ ret = inflateBackEnd(&strm); assert(ret == Z_OK);
+ fputs("inflateBack built-in memory routines\n", stderr);
+}
+
+/* do a raw inflate of data in hexadecimal with both inflate and inflateBack */
+local int try(char *hex, char *id, int err)
+{
+ int ret;
+ unsigned len, size;
+ unsigned char *in, *out, *win;
+ char *prefix;
+ z_stream strm;
+
+ /* convert to hex */
+ in = h2b(hex, &len);
+ assert(in != NULL);
+
+ /* allocate work areas */
+ size = len << 3;
+ out = malloc(size);
+ assert(out != NULL);
+ win = malloc(32768);
+ assert(win != NULL);
+ prefix = malloc(strlen(id) + 6);
+ assert(prefix != NULL);
+
+ /* first with inflate */
+ strcpy(prefix, id);
+ strcat(prefix, "-late");
+ mem_setup(&strm);
+ strm.avail_in = 0;
+ strm.next_in = Z_NULL;
+ ret = inflateInit2(&strm, err < 0 ? 47 : -15);
+ assert(ret == Z_OK);
+ strm.avail_in = len;
+ strm.next_in = in;
+ do {
+ strm.avail_out = size;
+ strm.next_out = out;
+ ret = inflate(&strm, Z_TREES);
+ assert(ret != Z_STREAM_ERROR && ret != Z_MEM_ERROR);
+ if (ret == Z_DATA_ERROR || ret == Z_NEED_DICT)
+ break;
+ } while (strm.avail_in || strm.avail_out == 0);
+ if (err) {
+ assert(ret == Z_DATA_ERROR);
+ assert(strcmp(id, strm.msg) == 0);
+ }
+ inflateEnd(&strm);
+ mem_done(&strm, prefix);
+
+ /* then with inflateBack */
+ if (err >= 0) {
+ strcpy(prefix, id);
+ strcat(prefix, "-back");
+ mem_setup(&strm);
+ ret = inflateBackInit(&strm, 15, win);
+ assert(ret == Z_OK);
+ strm.avail_in = len;
+ strm.next_in = in;
+ ret = inflateBack(&strm, pull, Z_NULL, push, Z_NULL);
+ assert(ret != Z_STREAM_ERROR);
+ if (err) {
+ assert(ret == Z_DATA_ERROR);
+ assert(strcmp(id, strm.msg) == 0);
+ }
+ inflateBackEnd(&strm);
+ mem_done(&strm, prefix);
+ }
+
+ /* clean up */
+ free(prefix);
+ free(win);
+ free(out);
+ free(in);
+ return ret;
+}
+
+/* cover deflate data cases in both inflate() and inflateBack() */
+local void cover_inflate(void)
+{
+ try("0 0 0 0 0", "invalid stored block lengths", 1);
+ try("3 0", "fixed", 0);
+ try("6", "invalid block type", 1);
+ try("1 1 0 fe ff 0", "stored", 0);
+ try("fc 0 0", "too many length or distance symbols", 1);
+ try("4 0 fe ff", "invalid code lengths set", 1);
+ try("4 0 24 49 0", "invalid bit length repeat", 1);
+ try("4 0 24 e9 ff ff", "invalid bit length repeat", 1);
+ try("4 0 24 e9 ff 6d", "invalid code -- missing end-of-block", 1);
+ try("4 80 49 92 24 49 92 24 71 ff ff 93 11 0",
+ "invalid literal/lengths set", 1);
+ try("4 80 49 92 24 49 92 24 f b4 ff ff c3 84", "invalid distances set", 1);
+ try("4 c0 81 8 0 0 0 0 20 7f eb b 0 0", "invalid literal/length code", 1);
+ try("2 7e ff ff", "invalid distance code", 1);
+ try("c c0 81 0 0 0 0 0 90 ff 6b 4 0", "invalid distance too far back", 1);
+
+ /* also trailer mismatch just in inflate() */
+ try("1f 8b 8 0 0 0 0 0 0 0 3 0 0 0 0 1", "incorrect data check", -1);
+ try("1f 8b 8 0 0 0 0 0 0 0 3 0 0 0 0 0 0 0 0 1",
+ "incorrect length check", -1);
+ try("5 c0 21 d 0 0 0 80 b0 fe 6d 2f 91 6c", "pull 17", 0);
+ try("5 e0 81 91 24 cb b2 2c 49 e2 f 2e 8b 9a 47 56 9f fb fe ec d2 ff 1f",
+ "long code", 0);
+ try("ed c0 1 1 0 0 0 40 20 ff 57 1b 42 2c 4f", "length extra", 0);
+ try("ed cf c1 b1 2c 47 10 c4 30 fa 6f 35 1d 1 82 59 3d fb be 2e 2a fc f c",
+ "long distance and extra", 0);
+ try("ed c0 81 0 0 0 0 80 a0 fd a9 17 a9 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 "
+ "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 6", "window end", 0);
+ inf("2 8 20 80 0 3 0", "inflate_fast TYPE return", 0, -15, 258,
+ Z_STREAM_END);
+ inf("63 18 5 40 c 0", "window wrap", 3, -8, 300, Z_OK);
+}
+
+/* cover remaining lines in inftrees.c */
+local void cover_trees(void)
+{
+ int ret;
+ unsigned bits;
+ unsigned short lens[16], work[16];
+ code *next, table[ENOUGH_DISTS];
+
+ /* we need to call inflate_table() directly in order to manifest not-
+ enough errors, since zlib insures that enough is always enough */
+ for (bits = 0; bits < 15; bits++)
+ lens[bits] = (unsigned short)(bits + 1);
+ lens[15] = 15;
+ next = table;
+ bits = 15;
+ ret = inflate_table(DISTS, lens, 16, &next, &bits, work);
+ assert(ret == 1);
+ next = table;
+ bits = 1;
+ ret = inflate_table(DISTS, lens, 16, &next, &bits, work);
+ assert(ret == 1);
+ fputs("inflate_table not enough errors\n", stderr);
+}
+
+/* cover remaining inffast.c decoding and window copying */
+local void cover_fast(void)
+{
+ inf("e5 e0 81 ad 6d cb b2 2c c9 01 1e 59 63 ae 7d ee fb 4d fd b5 35 41 68"
+ " ff 7f 0f 0 0 0", "fast length extra bits", 0, -8, 258, Z_DATA_ERROR);
+ inf("25 fd 81 b5 6d 59 b6 6a 49 ea af 35 6 34 eb 8c b9 f6 b9 1e ef 67 49"
+ " 50 fe ff ff 3f 0 0", "fast distance extra bits", 0, -8, 258,
+ Z_DATA_ERROR);
+ inf("3 7e 0 0 0 0 0", "fast invalid distance code", 0, -8, 258,
+ Z_DATA_ERROR);
+ inf("1b 7 0 0 0 0 0", "fast invalid literal/length code", 0, -8, 258,
+ Z_DATA_ERROR);
+ inf("d c7 1 ae eb 38 c 4 41 a0 87 72 de df fb 1f b8 36 b1 38 5d ff ff 0",
+ "fast 2nd level codes and too far back", 0, -8, 258, Z_DATA_ERROR);
+ inf("63 18 5 8c 10 8 0 0 0 0", "very common case", 0, -8, 259, Z_OK);
+ inf("63 60 60 18 c9 0 8 18 18 18 26 c0 28 0 29 0 0 0",
+ "contiguous and wrap around window", 6, -8, 259, Z_OK);
+ inf("63 0 3 0 0 0 0 0", "copy direct from output", 0, -8, 259,
+ Z_STREAM_END);
+}
+
+int main(void)
+{
+ fprintf(stderr, "%s\n", zlibVersion());
+ cover_support();
+ cover_wrap();
+ cover_back();
+ cover_inflate();
+ cover_trees();
+ cover_fast();
+ return 0;
+}
diff --git a/zlib/test/minigzip.c b/zlib/test/minigzip.c
new file mode 100644
index 000000000..e22fb08c0
--- /dev/null
+++ b/zlib/test/minigzip.c
@@ -0,0 +1,651 @@
+/* minigzip.c -- simulate gzip using the zlib compression library
+ * Copyright (C) 1995-2006, 2010, 2011, 2016 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/*
+ * minigzip is a minimal implementation of the gzip utility. This is
+ * only an example of using zlib and isn't meant to replace the
+ * full-featured gzip. No attempt is made to deal with file systems
+ * limiting names to 14 or 8+3 characters, etc... Error checking is
+ * very limited. So use minigzip only for testing; use gzip for the
+ * real thing. On MSDOS, use only on file names without extension
+ * or in pipe mode.
+ */
+
+/* @(#) $Id$ */
+
+#include "zlib.h"
+#include <stdio.h>
+
+#ifdef STDC
+# include <string.h>
+# include <stdlib.h>
+#endif
+
+#ifdef USE_MMAP
+# include <sys/types.h>
+# include <sys/mman.h>
+# include <sys/stat.h>
+#endif
+
+#if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__)
+# include <fcntl.h>
+# include <io.h>
+# ifdef UNDER_CE
+# include <stdlib.h>
+# endif
+# define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
+#else
+# define SET_BINARY_MODE(file)
+#endif
+
+#if defined(_MSC_VER) && _MSC_VER < 1900
+# define snprintf _snprintf
+#endif
+
+#ifdef VMS
+# define unlink delete
+# define GZ_SUFFIX "-gz"
+#endif
+#ifdef RISCOS
+# define unlink remove
+# define GZ_SUFFIX "-gz"
+# define fileno(file) file->__file
+#endif
+#if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
+# include <unix.h> /* for fileno */
+#endif
+
+#if !defined(Z_HAVE_UNISTD_H) && !defined(_LARGEFILE64_SOURCE)
+#ifndef WIN32 /* unlink already in stdio.h for WIN32 */
+ extern int unlink OF((const char *));
+#endif
+#endif
+
+#if defined(UNDER_CE)
+# include <windows.h>
+# define perror(s) pwinerror(s)
+
+/* Map the Windows error number in ERROR to a locale-dependent error
+ message string and return a pointer to it. Typically, the values
+ for ERROR come from GetLastError.
+
+ The string pointed to shall not be modified by the application,
+ but may be overwritten by a subsequent call to strwinerror
+
+ The strwinerror function does not change the current setting
+ of GetLastError. */
+
+static char *strwinerror (error)
+ DWORD error;
+{
+ static char buf[1024];
+
+ wchar_t *msgbuf;
+ DWORD lasterr = GetLastError();
+ DWORD chars = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM
+ | FORMAT_MESSAGE_ALLOCATE_BUFFER,
+ NULL,
+ error,
+ 0, /* Default language */
+ (LPVOID)&msgbuf,
+ 0,
+ NULL);
+ if (chars != 0) {
+ /* If there is an \r\n appended, zap it. */
+ if (chars >= 2
+ && msgbuf[chars - 2] == '\r' && msgbuf[chars - 1] == '\n') {
+ chars -= 2;
+ msgbuf[chars] = 0;
+ }
+
+ if (chars > sizeof (buf) - 1) {
+ chars = sizeof (buf) - 1;
+ msgbuf[chars] = 0;
+ }
+
+ wcstombs(buf, msgbuf, chars + 1);
+ LocalFree(msgbuf);
+ }
+ else {
+ sprintf(buf, "unknown win32 error (%ld)", error);
+ }
+
+ SetLastError(lasterr);
+ return buf;
+}
+
+static void pwinerror (s)
+ const char *s;
+{
+ if (s && *s)
+ fprintf(stderr, "%s: %s\n", s, strwinerror(GetLastError ()));
+ else
+ fprintf(stderr, "%s\n", strwinerror(GetLastError ()));
+}
+
+#endif /* UNDER_CE */
+
+#ifndef GZ_SUFFIX
+# define GZ_SUFFIX ".gz"
+#endif
+#define SUFFIX_LEN (sizeof(GZ_SUFFIX)-1)
+
+#define BUFLEN 16384
+#define MAX_NAME_LEN 1024
+
+#ifdef MAXSEG_64K
+# define local static
+ /* Needed for systems with limitation on stack size. */
+#else
+# define local
+#endif
+
+#ifdef Z_SOLO
+/* for Z_SOLO, create simplified gz* functions using deflate and inflate */
+
+#if defined(Z_HAVE_UNISTD_H) || defined(Z_LARGE)
+# include <unistd.h> /* for unlink() */
+#endif
+
+void *myalloc OF((void *, unsigned, unsigned));
+void myfree OF((void *, void *));
+
+void *myalloc(q, n, m)
+ void *q;
+ unsigned n, m;
+{
+ (void)q;
+ return calloc(n, m);
+}
+
+void myfree(q, p)
+ void *q, *p;
+{
+ (void)q;
+ free(p);
+}
+
+typedef struct gzFile_s {
+ FILE *file;
+ int write;
+ int err;
+ char *msg;
+ z_stream strm;
+} *gzFile;
+
+gzFile gzopen OF((const char *, const char *));
+gzFile gzdopen OF((int, const char *));
+gzFile gz_open OF((const char *, int, const char *));
+
+gzFile gzopen(path, mode)
+const char *path;
+const char *mode;
+{
+ return gz_open(path, -1, mode);
+}
+
+gzFile gzdopen(fd, mode)
+int fd;
+const char *mode;
+{
+ return gz_open(NULL, fd, mode);
+}
+
+gzFile gz_open(path, fd, mode)
+ const char *path;
+ int fd;
+ const char *mode;
+{
+ gzFile gz;
+ int ret;
+
+ gz = malloc(sizeof(struct gzFile_s));
+ if (gz == NULL)
+ return NULL;
+ gz->write = strchr(mode, 'w') != NULL;
+ gz->strm.zalloc = myalloc;
+ gz->strm.zfree = myfree;
+ gz->strm.opaque = Z_NULL;
+ if (gz->write)
+ ret = deflateInit2(&(gz->strm), -1, 8, 15 + 16, 8, 0);
+ else {
+ gz->strm.next_in = 0;
+ gz->strm.avail_in = Z_NULL;
+ ret = inflateInit2(&(gz->strm), 15 + 16);
+ }
+ if (ret != Z_OK) {
+ free(gz);
+ return NULL;
+ }
+ gz->file = path == NULL ? fdopen(fd, gz->write ? "wb" : "rb") :
+ fopen(path, gz->write ? "wb" : "rb");
+ if (gz->file == NULL) {
+ gz->write ? deflateEnd(&(gz->strm)) : inflateEnd(&(gz->strm));
+ free(gz);
+ return NULL;
+ }
+ gz->err = 0;
+ gz->msg = "";
+ return gz;
+}
+
+int gzwrite OF((gzFile, const void *, unsigned));
+
+int gzwrite(gz, buf, len)
+ gzFile gz;
+ const void *buf;
+ unsigned len;
+{
+ z_stream *strm;
+ unsigned char out[BUFLEN];
+
+ if (gz == NULL || !gz->write)
+ return 0;
+ strm = &(gz->strm);
+ strm->next_in = (void *)buf;
+ strm->avail_in = len;
+ do {
+ strm->next_out = out;
+ strm->avail_out = BUFLEN;
+ (void)deflate(strm, Z_NO_FLUSH);
+ fwrite(out, 1, BUFLEN - strm->avail_out, gz->file);
+ } while (strm->avail_out == 0);
+ return len;
+}
+
+int gzread OF((gzFile, void *, unsigned));
+
+int gzread(gz, buf, len)
+ gzFile gz;
+ void *buf;
+ unsigned len;
+{
+ int ret;
+ unsigned got;
+ unsigned char in[1];
+ z_stream *strm;
+
+ if (gz == NULL || gz->write)
+ return 0;
+ if (gz->err)
+ return 0;
+ strm = &(gz->strm);
+ strm->next_out = (void *)buf;
+ strm->avail_out = len;
+ do {
+ got = fread(in, 1, 1, gz->file);
+ if (got == 0)
+ break;
+ strm->next_in = in;
+ strm->avail_in = 1;
+ ret = inflate(strm, Z_NO_FLUSH);
+ if (ret == Z_DATA_ERROR) {
+ gz->err = Z_DATA_ERROR;
+ gz->msg = strm->msg;
+ return 0;
+ }
+ if (ret == Z_STREAM_END)
+ inflateReset(strm);
+ } while (strm->avail_out);
+ return len - strm->avail_out;
+}
+
+int gzclose OF((gzFile));
+
+int gzclose(gz)
+ gzFile gz;
+{
+ z_stream *strm;
+ unsigned char out[BUFLEN];
+
+ if (gz == NULL)
+ return Z_STREAM_ERROR;
+ strm = &(gz->strm);
+ if (gz->write) {
+ strm->next_in = Z_NULL;
+ strm->avail_in = 0;
+ do {
+ strm->next_out = out;
+ strm->avail_out = BUFLEN;
+ (void)deflate(strm, Z_FINISH);
+ fwrite(out, 1, BUFLEN - strm->avail_out, gz->file);
+ } while (strm->avail_out == 0);
+ deflateEnd(strm);
+ }
+ else
+ inflateEnd(strm);
+ fclose(gz->file);
+ free(gz);
+ return Z_OK;
+}
+
+const char *gzerror OF((gzFile, int *));
+
+const char *gzerror(gz, err)
+ gzFile gz;
+ int *err;
+{
+ *err = gz->err;
+ return gz->msg;
+}
+
+#endif
+
+static char *prog;
+
+void error OF((const char *msg));
+void gz_compress OF((FILE *in, gzFile out));
+#ifdef USE_MMAP
+int gz_compress_mmap OF((FILE *in, gzFile out));
+#endif
+void gz_uncompress OF((gzFile in, FILE *out));
+void file_compress OF((char *file, char *mode));
+void file_uncompress OF((char *file));
+int main OF((int argc, char *argv[]));
+
+/* ===========================================================================
+ * Display error message and exit
+ */
+void error(msg)
+ const char *msg;
+{
+ fprintf(stderr, "%s: %s\n", prog, msg);
+ exit(1);
+}
+
+/* ===========================================================================
+ * Compress input to output then close both files.
+ */
+
+void gz_compress(in, out)
+ FILE *in;
+ gzFile out;
+{
+ local char buf[BUFLEN];
+ int len;
+ int err;
+
+#ifdef USE_MMAP
+ /* Try first compressing with mmap. If mmap fails (minigzip used in a
+ * pipe), use the normal fread loop.
+ */
+ if (gz_compress_mmap(in, out) == Z_OK) return;
+#endif
+ for (;;) {
+ len = (int)fread(buf, 1, sizeof(buf), in);
+ if (ferror(in)) {
+ perror("fread");
+ exit(1);
+ }
+ if (len == 0) break;
+
+ if (gzwrite(out, buf, (unsigned)len) != len) error(gzerror(out, &err));
+ }
+ fclose(in);
+ if (gzclose(out) != Z_OK) error("failed gzclose");
+}
+
+#ifdef USE_MMAP /* MMAP version, Miguel Albrecht <malbrech@eso.org> */
+
+/* Try compressing the input file at once using mmap. Return Z_OK if
+ * if success, Z_ERRNO otherwise.
+ */
+int gz_compress_mmap(in, out)
+ FILE *in;
+ gzFile out;
+{
+ int len;
+ int err;
+ int ifd = fileno(in);
+ caddr_t buf; /* mmap'ed buffer for the entire input file */
+ off_t buf_len; /* length of the input file */
+ struct stat sb;
+
+ /* Determine the size of the file, needed for mmap: */
+ if (fstat(ifd, &sb) < 0) return Z_ERRNO;
+ buf_len = sb.st_size;
+ if (buf_len <= 0) return Z_ERRNO;
+
+ /* Now do the actual mmap: */
+ buf = mmap((caddr_t) 0, buf_len, PROT_READ, MAP_SHARED, ifd, (off_t)0);
+ if (buf == (caddr_t)(-1)) return Z_ERRNO;
+
+ /* Compress the whole file at once: */
+ len = gzwrite(out, (char *)buf, (unsigned)buf_len);
+
+ if (len != (int)buf_len) error(gzerror(out, &err));
+
+ munmap(buf, buf_len);
+ fclose(in);
+ if (gzclose(out) != Z_OK) error("failed gzclose");
+ return Z_OK;
+}
+#endif /* USE_MMAP */
+
+/* ===========================================================================
+ * Uncompress input to output then close both files.
+ */
+void gz_uncompress(in, out)
+ gzFile in;
+ FILE *out;
+{
+ local char buf[BUFLEN];
+ int len;
+ int err;
+
+ for (;;) {
+ len = gzread(in, buf, sizeof(buf));
+ if (len < 0) error (gzerror(in, &err));
+ if (len == 0) break;
+
+ if ((int)fwrite(buf, 1, (unsigned)len, out) != len) {
+ error("failed fwrite");
+ }
+ }
+ if (fclose(out)) error("failed fclose");
+
+ if (gzclose(in) != Z_OK) error("failed gzclose");
+}
+
+
+/* ===========================================================================
+ * Compress the given file: create a corresponding .gz file and remove the
+ * original.
+ */
+void file_compress(file, mode)
+ char *file;
+ char *mode;
+{
+ local char outfile[MAX_NAME_LEN];
+ FILE *in;
+ gzFile out;
+
+ if (strlen(file) + strlen(GZ_SUFFIX) >= sizeof(outfile)) {
+ fprintf(stderr, "%s: filename too long\n", prog);
+ exit(1);
+ }
+
+#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
+ snprintf(outfile, sizeof(outfile), "%s%s", file, GZ_SUFFIX);
+#else
+ strcpy(outfile, file);
+ strcat(outfile, GZ_SUFFIX);
+#endif
+
+ in = fopen(file, "rb");
+ if (in == NULL) {
+ perror(file);
+ exit(1);
+ }
+ out = gzopen(outfile, mode);
+ if (out == NULL) {
+ fprintf(stderr, "%s: can't gzopen %s\n", prog, outfile);
+ exit(1);
+ }
+ gz_compress(in, out);
+
+ unlink(file);
+}
+
+
+/* ===========================================================================
+ * Uncompress the given file and remove the original.
+ */
+void file_uncompress(file)
+ char *file;
+{
+ local char buf[MAX_NAME_LEN];
+ char *infile, *outfile;
+ FILE *out;
+ gzFile in;
+ unsigned len = strlen(file);
+
+ if (len + strlen(GZ_SUFFIX) >= sizeof(buf)) {
+ fprintf(stderr, "%s: filename too long\n", prog);
+ exit(1);
+ }
+
+#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
+ snprintf(buf, sizeof(buf), "%s", file);
+#else
+ strcpy(buf, file);
+#endif
+
+ if (len > SUFFIX_LEN && strcmp(file+len-SUFFIX_LEN, GZ_SUFFIX) == 0) {
+ infile = file;
+ outfile = buf;
+ outfile[len-3] = '\0';
+ } else {
+ outfile = file;
+ infile = buf;
+#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
+ snprintf(buf + len, sizeof(buf) - len, "%s", GZ_SUFFIX);
+#else
+ strcat(infile, GZ_SUFFIX);
+#endif
+ }
+ in = gzopen(infile, "rb");
+ if (in == NULL) {
+ fprintf(stderr, "%s: can't gzopen %s\n", prog, infile);
+ exit(1);
+ }
+ out = fopen(outfile, "wb");
+ if (out == NULL) {
+ perror(file);
+ exit(1);
+ }
+
+ gz_uncompress(in, out);
+
+ unlink(infile);
+}
+
+
+/* ===========================================================================
+ * Usage: minigzip [-c] [-d] [-f] [-h] [-r] [-1 to -9] [files...]
+ * -c : write to standard output
+ * -d : decompress
+ * -f : compress with Z_FILTERED
+ * -h : compress with Z_HUFFMAN_ONLY
+ * -r : compress with Z_RLE
+ * -1 to -9 : compression level
+ */
+
+int main(argc, argv)
+ int argc;
+ char *argv[];
+{
+ int copyout = 0;
+ int uncompr = 0;
+ gzFile file;
+ char *bname, outmode[20];
+
+#if !defined(NO_snprintf) && !defined(NO_vsnprintf)
+ snprintf(outmode, sizeof(outmode), "%s", "wb6 ");
+#else
+ strcpy(outmode, "wb6 ");
+#endif
+
+ prog = argv[0];
+ bname = strrchr(argv[0], '/');
+ if (bname)
+ bname++;
+ else
+ bname = argv[0];
+ argc--, argv++;
+
+ if (!strcmp(bname, "gunzip"))
+ uncompr = 1;
+ else if (!strcmp(bname, "zcat"))
+ copyout = uncompr = 1;
+
+ while (argc > 0) {
+ if (strcmp(*argv, "-c") == 0)
+ copyout = 1;
+ else if (strcmp(*argv, "-d") == 0)
+ uncompr = 1;
+ else if (strcmp(*argv, "-f") == 0)
+ outmode[3] = 'f';
+ else if (strcmp(*argv, "-h") == 0)
+ outmode[3] = 'h';
+ else if (strcmp(*argv, "-r") == 0)
+ outmode[3] = 'R';
+ else if ((*argv)[0] == '-' && (*argv)[1] >= '1' && (*argv)[1] <= '9' &&
+ (*argv)[2] == 0)
+ outmode[2] = (*argv)[1];
+ else
+ break;
+ argc--, argv++;
+ }
+ if (outmode[3] == ' ')
+ outmode[3] = 0;
+ if (argc == 0) {
+ SET_BINARY_MODE(stdin);
+ SET_BINARY_MODE(stdout);
+ if (uncompr) {
+ file = gzdopen(fileno(stdin), "rb");
+ if (file == NULL) error("can't gzdopen stdin");
+ gz_uncompress(file, stdout);
+ } else {
+ file = gzdopen(fileno(stdout), outmode);
+ if (file == NULL) error("can't gzdopen stdout");
+ gz_compress(stdin, file);
+ }
+ } else {
+ if (copyout) {
+ SET_BINARY_MODE(stdout);
+ }
+ do {
+ if (uncompr) {
+ if (copyout) {
+ file = gzopen(*argv, "rb");
+ if (file == NULL)
+ fprintf(stderr, "%s: can't gzopen %s\n", prog, *argv);
+ else
+ gz_uncompress(file, stdout);
+ } else {
+ file_uncompress(*argv);
+ }
+ } else {
+ if (copyout) {
+ FILE * in = fopen(*argv, "rb");
+
+ if (in == NULL) {
+ perror(*argv);
+ } else {
+ file = gzdopen(fileno(stdout), outmode);
+ if (file == NULL) error("can't gzdopen stdout");
+
+ gz_compress(in, file);
+ }
+
+ } else {
+ file_compress(*argv, outmode);
+ }
+ }
+ } while (argv++, --argc);
+ }
+ return 0;
+}
diff --git a/zlib/treebuild.xml b/zlib/treebuild.xml
new file mode 100644
index 000000000..fd75525f9
--- /dev/null
+++ b/zlib/treebuild.xml
@@ -0,0 +1,116 @@
+<?xml version="1.0" ?>
+<package name="zlib" version="1.2.11">
+ <library name="zlib" dlversion="1.2.11" dlname="z">
+ <property name="description"> zip compression library </property>
+ <property name="include-target-dir" value="$(@PACKAGE/install-includedir)" />
+
+ <!-- fixme: not implemented yet -->
+ <property name="compiler/c/inline" value="yes" />
+
+ <include-file name="zlib.h" scope="public" mode="644" />
+ <include-file name="zconf.h" scope="public" mode="644" />
+
+ <source name="adler32.c">
+ <depend name="zlib.h" />
+ <depend name="zconf.h" />
+ </source>
+ <source name="compress.c">
+ <depend name="zlib.h" />
+ <depend name="zconf.h" />
+ </source>
+ <source name="crc32.c">
+ <depend name="zlib.h" />
+ <depend name="zconf.h" />
+ <depend name="crc32.h" />
+ </source>
+ <source name="gzclose.c">
+ <depend name="zlib.h" />
+ <depend name="zconf.h" />
+ <depend name="gzguts.h" />
+ </source>
+ <source name="gzlib.c">
+ <depend name="zlib.h" />
+ <depend name="zconf.h" />
+ <depend name="gzguts.h" />
+ </source>
+ <source name="gzread.c">
+ <depend name="zlib.h" />
+ <depend name="zconf.h" />
+ <depend name="gzguts.h" />
+ </source>
+ <source name="gzwrite.c">
+ <depend name="zlib.h" />
+ <depend name="zconf.h" />
+ <depend name="gzguts.h" />
+ </source>
+ <source name="uncompr.c">
+ <depend name="zlib.h" />
+ <depend name="zconf.h" />
+ </source>
+ <source name="deflate.c">
+ <depend name="zlib.h" />
+ <depend name="zconf.h" />
+ <depend name="zutil.h" />
+ <depend name="deflate.h" />
+ </source>
+ <source name="trees.c">
+ <depend name="zlib.h" />
+ <depend name="zconf.h" />
+ <depend name="zutil.h" />
+ <depend name="deflate.h" />
+ <depend name="trees.h" />
+ </source>
+ <source name="zutil.c">
+ <depend name="zlib.h" />
+ <depend name="zconf.h" />
+ <depend name="zutil.h" />
+ </source>
+ <source name="inflate.c">
+ <depend name="zlib.h" />
+ <depend name="zconf.h" />
+ <depend name="zutil.h" />
+ <depend name="inftrees.h" />
+ <depend name="inflate.h" />
+ <depend name="inffast.h" />
+ </source>
+ <source name="infback.c">
+ <depend name="zlib.h" />
+ <depend name="zconf.h" />
+ <depend name="zutil.h" />
+ <depend name="inftrees.h" />
+ <depend name="inflate.h" />
+ <depend name="inffast.h" />
+ </source>
+ <source name="inftrees.c">
+ <depend name="zlib.h" />
+ <depend name="zconf.h" />
+ <depend name="zutil.h" />
+ <depend name="inftrees.h" />
+ </source>
+ <source name="inffast.c">
+ <depend name="zlib.h" />
+ <depend name="zconf.h" />
+ <depend name="zutil.h" />
+ <depend name="inftrees.h" />
+ <depend name="inflate.h" />
+ <depend name="inffast.h" />
+ </source>
+ </library>
+</package>
+
+<!--
+CFLAGS=-O
+#CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7
+#CFLAGS=-g -DZLIB_DEBUG
+#CFLAGS=-O3 -Wall -Wwrite-strings -Wpointer-arith -Wconversion \
+# -Wstrict-prototypes -Wmissing-prototypes
+
+# OBJA =
+# to use the asm code: make OBJA=match.o
+#
+match.o: match.S
+ $(CPP) match.S > _match.s
+ $(CC) -c _match.s
+ mv _match.o match.o
+ rm -f _match.s
+-->
diff --git a/zlib/trees.c b/zlib/trees.c
new file mode 100644
index 000000000..50cf4b457
--- /dev/null
+++ b/zlib/trees.c
@@ -0,0 +1,1203 @@
+/* trees.c -- output deflated data using Huffman coding
+ * Copyright (C) 1995-2017 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 ZLIB_DEBUG
+# include <ctype.h>
+#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 const static_tree_desc static_l_desc =
+{static_ltree, extra_lbits, LITERALS+1, L_CODES, MAX_BITS};
+
+local const static_tree_desc static_d_desc =
+{static_dtree, extra_dbits, 0, D_CODES, MAX_BITS};
+
+local const 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, const ct_data *ltree,
+ const 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));
+
+#ifdef GEN_TREES_H
+local void gen_trees_header OF((void));
+#endif
+
+#ifndef ZLIB_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 /* !ZLIB_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 ZLIB_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 /* !ZLIB_DEBUG */
+
+#define send_bits(s, value, length) \
+{ int len = length;\
+ if (s->bi_valid > (int)Buf_size - len) {\
+ int val = (int)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 /* ZLIB_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<<extra_lbits[code]); n++) {
+ _length_code[length++] = (uch)code;
+ }
+ }
+ Assert (length == 256, "tr_static_init: length != 256");
+ /* Note that the length 255 (match length 258) can be represented
+ * in two different ways: code 284 + 5 bits or code 285, so we
+ * overwrite length_code[255] to use the best encoding:
+ */
+ _length_code[length-1] = (uch)code;
+
+ /* Initialize the mapping dist (0..32K) -> dist code (0..29) */
+ dist = 0;
+ for (code = 0 ; code < 16; code++) {
+ base_dist[code] = dist;
+ for (n = 0; n < (1<<extra_dbits[code]); n++) {
+ _dist_code[dist++] = (uch)code;
+ }
+ }
+ Assert (dist == 256, "tr_static_init: dist != 256");
+ dist >>= 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 ZLIB_DEBUG
+# include <stdio.h>
+# 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 ZLIB_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 * (unsigned)(bits + xbits);
+ if (stree) s->static_len += (ulg)f * (unsigned)(stree[n].Len + xbits);
+ }
+ if (overflow == 0) return;
+
+ Tracev((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) {
+ Tracev((stderr,"code %d bits %d->%d\n", m, tree[m].Len, bits));
+ s->opt_len += ((ulg)bits - tree[m].Len) * 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 */
+ unsigned 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++) {
+ code = (code + bl_count[bits-1]) << 1;
+ next_code[bits] = (ush)code;
+ }
+ /* 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<<MAX_BITS)-1,
+ "inconsistent bit counts");
+ Tracev((stderr,"\ngen_codes: max_code %d ", max_code));
+
+ for (n = 0; n <= max_code; n++) {
+ int len = tree[n].Len;
+ if (len == 0) continue;
+ /* Now reverse the bits */
+ tree[n].Code = (ush)bi_reverse(next_code[len]++, len);
+
+ Tracecv(tree != static_ltree, (stderr,"\nn %3d %c l %2d c %4x (%x) ",
+ n, (isgraph(n) ? n : ' '), len, tree[n].Code, next_code[len]-1));
+ }
+}
+
+/* ===========================================================================
+ * Construct one Huffman tree and assigns the code bit strings and lengths.
+ * Update the total bit length for the current block.
+ * IN assertion: the field freq is set for all tree elements.
+ * OUT assertions: the fields len and code are set to the optimal bit length
+ * and corresponding code. The length opt_len is updated; static_len is
+ * also updated if stree is not null. The field max_code is set.
+ */
+local void build_tree(s, desc)
+ deflate_state *s;
+ tree_desc *desc; /* the tree descriptor */
+{
+ ct_data *tree = desc->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*((ulg)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 */
+ bi_windup(s); /* align on byte boundary */
+ put_short(s, (ush)stored_len);
+ put_short(s, (ush)~stored_len);
+ zmemcpy(s->pending_buf + s->pending, (Bytef *)buf, stored_len);
+ s->pending += stored_len;
+#ifdef ZLIB_DEBUG
+ s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L;
+ s->compressed_len += (stored_len + 4) << 3;
+ s->bits_sent += 2*16;
+ s->bits_sent += stored_len<<3;
+#endif
+}
+
+/* ===========================================================================
+ * 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 ZLIB_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 write out the encoded block.
+ */
+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, (const ct_data *)static_ltree,
+ (const ct_data *)static_dtree);
+#ifdef ZLIB_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, (const ct_data *)s->dyn_ltree,
+ (const ct_data *)s->dyn_dtree);
+#ifdef ZLIB_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 uLong implemented on 32 bits.
+ */
+ init_block(s);
+
+ if (last) {
+ bi_windup(s);
+#ifdef ZLIB_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)((long)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;
+ const ct_data *ltree; /* literal tree */
+ const 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 -= (unsigned)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 long 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 ZLIB_DEBUG
+ s->bits_sent = (s->bits_sent+7) & ~7;
+#endif
+}
diff --git a/zlib/trees.h b/zlib/trees.h
new file mode 100644
index 000000000..d35639d82
--- /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/uncompr.c b/zlib/uncompr.c
new file mode 100644
index 000000000..f03a1a865
--- /dev/null
+++ b/zlib/uncompr.c
@@ -0,0 +1,93 @@
+/* uncompr.c -- decompress a memory buffer
+ * Copyright (C) 1995-2003, 2010, 2014, 2016 Jean-loup Gailly, Mark Adler
+ * 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 size of the decompressed data and *sourceLen is the number
+ of source bytes consumed. Upon return, source + *sourceLen points to the
+ first unused input byte.
+
+ 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, including if the input data is
+ an incomplete zlib stream.
+*/
+int ZEXPORT uncompress2 (dest, destLen, source, sourceLen)
+ Bytef *dest;
+ uLongf *destLen;
+ const Bytef *source;
+ uLong *sourceLen;
+{
+ z_stream stream;
+ int err;
+ const uInt max = (uInt)-1;
+ uLong len, left;
+ Byte buf[1]; /* for detection of incomplete stream when *destLen == 0 */
+
+ len = *sourceLen;
+ if (*destLen) {
+ left = *destLen;
+ *destLen = 0;
+ }
+ else {
+ left = 1;
+ dest = buf;
+ }
+
+ stream.next_in = (z_const Bytef *)source;
+ stream.avail_in = 0;
+ stream.zalloc = (alloc_func)0;
+ stream.zfree = (free_func)0;
+ stream.opaque = (voidpf)0;
+
+ err = inflateInit(&stream);
+ if (err != Z_OK) return err;
+
+ stream.next_out = dest;
+ stream.avail_out = 0;
+
+ do {
+ if (stream.avail_out == 0) {
+ stream.avail_out = left > (uLong)max ? max : (uInt)left;
+ left -= stream.avail_out;
+ }
+ if (stream.avail_in == 0) {
+ stream.avail_in = len > (uLong)max ? max : (uInt)len;
+ len -= stream.avail_in;
+ }
+ err = inflate(&stream, Z_NO_FLUSH);
+ } while (err == Z_OK);
+
+ *sourceLen -= len + stream.avail_in;
+ if (dest != buf)
+ *destLen = stream.total_out;
+ else if (stream.total_out && err == Z_BUF_ERROR)
+ left = 1;
+
+ inflateEnd(&stream);
+ return err == Z_STREAM_END ? Z_OK :
+ err == Z_NEED_DICT ? Z_DATA_ERROR :
+ err == Z_BUF_ERROR && left + stream.avail_out ? Z_DATA_ERROR :
+ err;
+}
+
+int ZEXPORT uncompress (dest, destLen, source, sourceLen)
+ Bytef *dest;
+ uLongf *destLen;
+ const Bytef *source;
+ uLong sourceLen;
+{
+ return uncompress2(dest, destLen, source, &sourceLen);
+}
diff --git a/zlib/zconf.h b/zlib/zconf.h
new file mode 100644
index 000000000..5e1d68a00
--- /dev/null
+++ b/zlib/zconf.h
@@ -0,0 +1,534 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
+ * 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 and init macros */
+# define _dist_code z__dist_code
+# define _length_code z__length_code
+# define _tr_align z__tr_align
+# define _tr_flush_bits z__tr_flush_bits
+# 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
+# define adler32_z z_adler32_z
+# 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 crc32_z z_crc32_z
+# define deflate z_deflate
+# define deflateBound z_deflateBound
+# define deflateCopy z_deflateCopy
+# define deflateEnd z_deflateEnd
+# define deflateGetDictionary z_deflateGetDictionary
+# define deflateInit z_deflateInit
+# define deflateInit2 z_deflateInit2
+# 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 gzfread z_gzfread
+# define gzfwrite z_gzfwrite
+# 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 gzvprintf z_gzvprintf
+# define gzwrite z_gzwrite
+# endif
+# define inflate z_inflate
+# define inflateBack z_inflateBack
+# define inflateBackEnd z_inflateBackEnd
+# define inflateBackInit z_inflateBackInit
+# define inflateBackInit_ z_inflateBackInit_
+# define inflateCodesUsed z_inflateCodesUsed
+# define inflateCopy z_inflateCopy
+# define inflateEnd z_inflateEnd
+# define inflateGetDictionary z_inflateGetDictionary
+# define inflateGetHeader z_inflateGetHeader
+# define inflateInit z_inflateInit
+# define inflateInit2 z_inflateInit2
+# 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 inflateResetKeep z_inflateResetKeep
+# define inflateSetDictionary z_inflateSetDictionary
+# define inflateSync z_inflateSync
+# define inflateSyncPoint z_inflateSyncPoint
+# define inflateUndermine z_inflateUndermine
+# define inflateValidate z_inflateValidate
+# 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
+# define uncompress2 z_uncompress2
+# 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 uLong z_uLong
+# define uLongf z_uLongf
+# 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
+
+#ifdef Z_SOLO
+ typedef unsigned long z_size_t;
+#else
+# define z_longlong long long
+# if defined(NO_SIZE_T)
+ typedef unsigned NO_SIZE_T z_size_t;
+# elif defined(STDC)
+# include <stddef.h>
+ typedef size_t z_size_t;
+# else
+ typedef unsigned long z_size_t;
+# endif
+# undef z_longlong
+#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 about 7 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 <windows.h>
+ /* 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 long uLong; /* 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 uLong FAR uLongf;
+
+#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
+
+#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
+# include <limits.h>
+# if (UINT_MAX == 0xffffffffUL)
+# define Z_U4 unsigned
+# elif (ULONG_MAX == 0xffffffffUL)
+# define Z_U4 unsigned long
+# elif (USHRT_MAX == 0xffffffffUL)
+# define Z_U4 unsigned short
+# endif
+#endif
+
+#ifdef Z_U4
+ typedef Z_U4 z_crc_t;
+#else
+ typedef unsigned long 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 <sys/types.h> /* for off_t */
+# endif
+#endif
+
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+# ifndef Z_SOLO
+# include <stdarg.h> /* for va_list */
+# endif
+#endif
+
+#ifdef _WIN32
+# ifndef Z_SOLO
+# include <stddef.h> /* for wchar_t */
+# endif
+#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 <unistd.h> /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
+# ifdef VMS
+# include <unixio.h> /* 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 long
+#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/zconf.h.cmakein b/zlib/zconf.h.cmakein
new file mode 100644
index 000000000..a7f24cce6
--- /dev/null
+++ b/zlib/zconf.h.cmakein
@@ -0,0 +1,536 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+#cmakedefine Z_PREFIX
+#cmakedefine Z_HAVE_UNISTD_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 and init macros */
+# define _dist_code z__dist_code
+# define _length_code z__length_code
+# define _tr_align z__tr_align
+# define _tr_flush_bits z__tr_flush_bits
+# 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
+# define adler32_z z_adler32_z
+# 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 crc32_z z_crc32_z
+# define deflate z_deflate
+# define deflateBound z_deflateBound
+# define deflateCopy z_deflateCopy
+# define deflateEnd z_deflateEnd
+# define deflateGetDictionary z_deflateGetDictionary
+# define deflateInit z_deflateInit
+# define deflateInit2 z_deflateInit2
+# 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 gzfread z_gzfread
+# define gzfwrite z_gzfwrite
+# 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 gzvprintf z_gzvprintf
+# define gzwrite z_gzwrite
+# endif
+# define inflate z_inflate
+# define inflateBack z_inflateBack
+# define inflateBackEnd z_inflateBackEnd
+# define inflateBackInit z_inflateBackInit
+# define inflateBackInit_ z_inflateBackInit_
+# define inflateCodesUsed z_inflateCodesUsed
+# define inflateCopy z_inflateCopy
+# define inflateEnd z_inflateEnd
+# define inflateGetDictionary z_inflateGetDictionary
+# define inflateGetHeader z_inflateGetHeader
+# define inflateInit z_inflateInit
+# define inflateInit2 z_inflateInit2
+# 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 inflateResetKeep z_inflateResetKeep
+# define inflateSetDictionary z_inflateSetDictionary
+# define inflateSync z_inflateSync
+# define inflateSyncPoint z_inflateSyncPoint
+# define inflateUndermine z_inflateUndermine
+# define inflateValidate z_inflateValidate
+# 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
+# define uncompress2 z_uncompress2
+# 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 uLong z_uLong
+# define uLongf z_uLongf
+# 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
+
+#ifdef Z_SOLO
+ typedef unsigned long z_size_t;
+#else
+# define z_longlong long long
+# if defined(NO_SIZE_T)
+ typedef unsigned NO_SIZE_T z_size_t;
+# elif defined(STDC)
+# include <stddef.h>
+ typedef size_t z_size_t;
+# else
+ typedef unsigned long z_size_t;
+# endif
+# undef z_longlong
+#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 about 7 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 <windows.h>
+ /* 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 long uLong; /* 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 uLong FAR uLongf;
+
+#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
+
+#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
+# include <limits.h>
+# if (UINT_MAX == 0xffffffffUL)
+# define Z_U4 unsigned
+# elif (ULONG_MAX == 0xffffffffUL)
+# define Z_U4 unsigned long
+# elif (USHRT_MAX == 0xffffffffUL)
+# define Z_U4 unsigned short
+# endif
+#endif
+
+#ifdef Z_U4
+ typedef Z_U4 z_crc_t;
+#else
+ typedef unsigned long 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 <sys/types.h> /* for off_t */
+# endif
+#endif
+
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+# ifndef Z_SOLO
+# include <stdarg.h> /* for va_list */
+# endif
+#endif
+
+#ifdef _WIN32
+# ifndef Z_SOLO
+# include <stddef.h> /* for wchar_t */
+# endif
+#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 <unistd.h> /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
+# ifdef VMS
+# include <unixio.h> /* 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 long
+#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/zconf.h.in b/zlib/zconf.h.in
new file mode 100644
index 000000000..5e1d68a00
--- /dev/null
+++ b/zlib/zconf.h.in
@@ -0,0 +1,534 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
+ * 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 and init macros */
+# define _dist_code z__dist_code
+# define _length_code z__length_code
+# define _tr_align z__tr_align
+# define _tr_flush_bits z__tr_flush_bits
+# 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
+# define adler32_z z_adler32_z
+# 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 crc32_z z_crc32_z
+# define deflate z_deflate
+# define deflateBound z_deflateBound
+# define deflateCopy z_deflateCopy
+# define deflateEnd z_deflateEnd
+# define deflateGetDictionary z_deflateGetDictionary
+# define deflateInit z_deflateInit
+# define deflateInit2 z_deflateInit2
+# 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 gzfread z_gzfread
+# define gzfwrite z_gzfwrite
+# 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 gzvprintf z_gzvprintf
+# define gzwrite z_gzwrite
+# endif
+# define inflate z_inflate
+# define inflateBack z_inflateBack
+# define inflateBackEnd z_inflateBackEnd
+# define inflateBackInit z_inflateBackInit
+# define inflateBackInit_ z_inflateBackInit_
+# define inflateCodesUsed z_inflateCodesUsed
+# define inflateCopy z_inflateCopy
+# define inflateEnd z_inflateEnd
+# define inflateGetDictionary z_inflateGetDictionary
+# define inflateGetHeader z_inflateGetHeader
+# define inflateInit z_inflateInit
+# define inflateInit2 z_inflateInit2
+# 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 inflateResetKeep z_inflateResetKeep
+# define inflateSetDictionary z_inflateSetDictionary
+# define inflateSync z_inflateSync
+# define inflateSyncPoint z_inflateSyncPoint
+# define inflateUndermine z_inflateUndermine
+# define inflateValidate z_inflateValidate
+# 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
+# define uncompress2 z_uncompress2
+# 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 uLong z_uLong
+# define uLongf z_uLongf
+# 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
+
+#ifdef Z_SOLO
+ typedef unsigned long z_size_t;
+#else
+# define z_longlong long long
+# if defined(NO_SIZE_T)
+ typedef unsigned NO_SIZE_T z_size_t;
+# elif defined(STDC)
+# include <stddef.h>
+ typedef size_t z_size_t;
+# else
+ typedef unsigned long z_size_t;
+# endif
+# undef z_longlong
+#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 about 7 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 <windows.h>
+ /* 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 long uLong; /* 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 uLong FAR uLongf;
+
+#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
+
+#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
+# include <limits.h>
+# if (UINT_MAX == 0xffffffffUL)
+# define Z_U4 unsigned
+# elif (ULONG_MAX == 0xffffffffUL)
+# define Z_U4 unsigned long
+# elif (USHRT_MAX == 0xffffffffUL)
+# define Z_U4 unsigned short
+# endif
+#endif
+
+#ifdef Z_U4
+ typedef Z_U4 z_crc_t;
+#else
+ typedef unsigned long 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 <sys/types.h> /* for off_t */
+# endif
+#endif
+
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+# ifndef Z_SOLO
+# include <stdarg.h> /* for va_list */
+# endif
+#endif
+
+#ifdef _WIN32
+# ifndef Z_SOLO
+# include <stddef.h> /* for wchar_t */
+# endif
+#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 <unistd.h> /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
+# ifdef VMS
+# include <unixio.h> /* 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 long
+#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.3 b/zlib/zlib.3
new file mode 100644
index 000000000..bda4eb073
--- /dev/null
+++ b/zlib/zlib.3
@@ -0,0 +1,149 @@
+.TH ZLIB 3 "15 Jan 2017"
+.SH NAME
+zlib \- compression/decompression library
+.SH SYNOPSIS
+[see
+.I zlib.h
+for full description]
+.SH DESCRIPTION
+The
+.I zlib
+library is a general purpose data compression library.
+The code is thread safe, assuming that the standard library functions
+used are thread safe, such as memory allocation routines.
+It 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 may be added later
+with the same stream interface.
+.LP
+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.
+.LP
+The library also supports reading and writing files in
+.IR gzip (1)
+(.gz) format
+with an interface similar to that of stdio.
+.LP
+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 the case of corrupted input.
+.LP
+All functions of the compression library are documented in the file
+.IR zlib.h .
+The distribution source includes examples of use of the library
+in the files
+.I test/example.c
+and
+.IR test/minigzip.c,
+as well as other examples in the
+.IR examples/
+directory.
+.LP
+Changes to this version are documented in the file
+.I ChangeLog
+that accompanies the source.
+.LP
+.I zlib
+is built in to many languages and operating systems, including but not limited to
+Java, Python, .NET, PHP, Perl, Ruby, Swift, and Go.
+.LP
+An experimental package to read and write files in the .zip format,
+written on top of
+.I zlib
+by Gilles Vollant (info@winimage.com),
+is available at:
+.IP
+http://www.winimage.com/zLibDll/minizip.html
+and also in the
+.I contrib/minizip
+directory of the main
+.I zlib
+source distribution.
+.SH "SEE ALSO"
+The
+.I zlib
+web site can be found at:
+.IP
+http://zlib.net/
+.LP
+The data format used by the
+.I zlib
+library is described by RFC
+(Request for Comments) 1950 to 1952 in the files:
+.IP
+http://tools.ietf.org/html/rfc1950 (for the zlib header and trailer format)
+.br
+http://tools.ietf.org/html/rfc1951 (for the deflate compressed data format)
+.br
+http://tools.ietf.org/html/rfc1952 (for the gzip header and trailer format)
+.LP
+Mark Nelson wrote an article about
+.I zlib
+for the Jan. 1997 issue of Dr. Dobb's Journal;
+a copy of the article is available at:
+.IP
+http://marknelson.us/1997/01/01/zlib-engine/
+.SH "REPORTING PROBLEMS"
+Before reporting a problem,
+please check the
+.I zlib
+web site to verify that you have the latest version of
+.IR zlib ;
+otherwise,
+obtain the latest version and see if the problem still exists.
+Please read the
+.I zlib
+FAQ at:
+.IP
+http://zlib.net/zlib_faq.html
+.LP
+before asking for help.
+Send questions and/or comments to zlib@gzip.org,
+or (for the Windows DLL version) to Gilles Vollant (info@winimage.com).
+.SH AUTHORS AND LICENSE
+Version 1.2.11
+.LP
+Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler
+.LP
+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.
+.LP
+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:
+.LP
+.nr step 1 1
+.IP \n[step]. 3
+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.
+.IP \n+[step].
+Altered source versions must be plainly marked as such, and must not be
+misrepresented as being the original software.
+.IP \n+[step].
+This notice may not be removed or altered from any source distribution.
+.LP
+Jean-loup Gailly Mark Adler
+.br
+jloup@gzip.org madler@alumni.caltech.edu
+.LP
+The deflate format used by
+.I zlib
+was defined by Phil Katz.
+The deflate and
+.I zlib
+specifications were written by L. Peter Deutsch.
+Thanks to all the people who reported problems and suggested various
+improvements in
+.IR zlib ;
+who are too numerous to cite here.
+.LP
+UNIX manual page by R. P. C. Rodgers,
+U.S. National Library of Medicine (rodgers@nlm.nih.gov).
+.\" end of man page
diff --git a/zlib/zlib.h b/zlib/zlib.h
new file mode 100644
index 000000000..f09cdaf1e
--- /dev/null
+++ b/zlib/zlib.h
@@ -0,0 +1,1912 @@
+/* zlib.h -- interface of the 'zlib' general purpose compression library
+ version 1.2.11, January 15th, 2017
+
+ Copyright (C) 1995-2017 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.11"
+#define ZLIB_VERNUM 0x12b0
+#define ZLIB_VER_MAJOR 1
+#define ZLIB_VER_MINOR 2
+#define ZLIB_VER_REVISION 11
+#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 and raw deflate 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 the 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 */
+ uLong total_in; /* total number of input bytes read so far */
+
+ Bytef *next_out; /* next output byte will go here */
+ uInt avail_out; /* remaining free space at next_out */
+ uLong 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
+ for deflate, or the decoding state for inflate */
+ uLong adler; /* Adler-32 or CRC-32 value of the uncompressed data */
+ uLong 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 */
+ uLong 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. In that case, zlib is thread-safe. When zalloc and zfree are
+ Z_NULL on entry to the initialization function, they are set to internal
+ routines that use the standard library functions malloc() and free().
+
+ 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 by 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 for deflate() */
+
+#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().
+
+ - Generate 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. Some output may be provided even if
+ flush is zero.
+
+ 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. See deflatePending(),
+ which can be used if desired to determine whether or not there is more ouput
+ in that case.
+
+ 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
+ codes 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 or Z_BUF_ERROR, 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 in the first deflate call after deflateInit if all the
+ compression is to be done in a single step. In order to complete in one
+ call, 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 Adler-32 checksum of all input read
+ so far (that is, total_in bytes). If a gzip stream is being generated, then
+ strm->adler will be the CRC-32 checksum of the input read so far. (See
+ deflateInit2 below.)
+
+ deflate() may update strm->data_type if it can make a good guess about
+ the input data type (Z_BINARY or Z_TEXT). If 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 or the state was inadvertently written over
+ by the application), or 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. In the current version of inflate, the provided input is not
+ read or consumed. The allocation of a sliding window will be deferred to
+ the first call of inflate (if the decompression does not complete on the
+ first call). 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.
+ Actual decompression will be done by inflate(). So next_in, and avail_in,
+ 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), then next_in and avail_in are updated
+ accordingly, and processing will resume at this point for the next call of
+ inflate().
+
+ - Generate 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. If the
+ caller of inflate() does not provide both available input and available
+ output space, it is possible that there will be no progress made. 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.
+ To assist in this, on return inflate() always sets 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 Adler-32
+ 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 unless inflateGetHeader() is used. When processing
+ gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output
+ produced so far. The CRC-32 is checked against the gzip trailer, as is the
+ uncompressed length, modulo 2^32.
+
+ 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, in which case strm->msg points to a string with a more specific
+ error), Z_STREAM_ERROR if the stream structure was inconsistent (for example
+ next_in or next_out was Z_NULL, or the state was inadvertently written over
+ by the application), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR
+ if no progress was 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 to be attempted.
+*/
+
+
+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, or Z_STREAM_ERROR if the stream state
+ was inconsistent.
+*/
+
+
+ /* 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.
+
+ For the current implementation of deflate(), a windowBits value of 8 (a
+ window size of 256 bytes) is not supported. As a result, a request for 8
+ will result in 9 (a 512-byte window). In that case, providing 8 to
+ inflateInit2() will result in an error when the zlib header with 9 is
+ checked against the initialization of inflate(). The remedy is to not use 8
+ with deflateInit2() with this initialization, or at least in that case use 9
+ with inflateInit2().
+
+ 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 a 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 the appropriate value,
+ if the operating system was determined at compile time. If a gzip stream is
+ being written, strm->adler is a CRC-32 instead of an Adler-32.
+
+ For raw deflate or gzip encoding, a request for a 256-byte window is
+ rejected as invalid, since only the zlib header provides a means of
+ transmitting the window size to the decompressor.
+
+ 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 Adler-32 value
+ of the dictionary; the decompressor may later use this value to determine
+ which dictionary has been used by the compressor. (The Adler-32 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
+ Adler-32 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 deflateGetDictionary OF((z_streamp strm,
+ Bytef *dictionary,
+ uInt *dictLength));
+/*
+ Returns the sliding dictionary being maintained by deflate. dictLength is
+ set to the number of bytes in the dictionary, and that many bytes are copied
+ to dictionary. dictionary must have enough space, where 32768 bytes is
+ always enough. If deflateGetDictionary() is called with dictionary equal to
+ Z_NULL, then only the dictionary length is returned, and nothing is copied.
+ Similary, if dictLength is Z_NULL, then it is not set.
+
+ deflateGetDictionary() may return a length less than the window size, even
+ when more than the window size in input has been provided. It may return up
+ to 258 bytes less in that case, due to how zlib's implementation of deflate
+ manages the sliding window and lookahead for matches, where matches can be
+ up to 258 bytes long. If the application needs the last window-size bytes of
+ input, then that would need to be saved by the application outside of zlib.
+
+ deflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
+ stream state is inconsistent.
+*/
+
+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 the internal compression state. The stream
+ will leave the compression level and any other attributes that may have been
+ set unchanged.
+
+ 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 approach (which is a function of the level) or the
+ strategy is changed, and if any input has been consumed in a previous
+ deflate() call, then the input available so far is compressed with the old
+ level and strategy using deflate(strm, Z_BLOCK). There are three approaches
+ for the compression levels 0, 1..3, and 4..9 respectively. The new level
+ and strategy will take effect at the next call of deflate().
+
+ If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does
+ not have enough output space to complete, then the parameter change will not
+ take effect. In this case, deflateParams() can be called again with the
+ same parameters and more output space to try again.
+
+ In order to assure a change in the parameters on the first try, the
+ deflate stream should be flushed using deflate() with Z_BLOCK or other flush
+ request until strm.avail_out is not zero, before calling deflateParams().
+ Then no more input data should be provided before the deflateParams() call.
+ If this is done, the old level and strategy will be applied to the data
+ compressed before deflateParams(), and the new level and strategy will be
+ applied to the the data compressed after deflateParams().
+
+ deflateParams returns Z_OK on success, Z_STREAM_ERROR if the source stream
+ state was inconsistent or if a parameter was invalid, or Z_BUF_ERROR if
+ there was not enough output space to complete the compression of the
+ available input data before a change in the strategy or approach. Note that
+ in the case of a Z_BUF_ERROR, the parameters are not changed. A return
+ value of Z_BUF_ERROR is not fatal, in which case deflateParams() can be
+ retried with more output space.
+*/
+
+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 uLong ZEXPORT deflateBound OF((z_streamp strm,
+ uLong sourceLen));
+/*
+ deflateBound() returns an upper bound on the compressed size after
+ deflation of sourceLen bytes. It must be called after deflateInit() or
+ deflateInit2(), 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 Adler-32 or a CRC-32 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
+ CRC-32 instead of an Adler-32. Unlike the gunzip utility and gzread() (see
+ below), inflate() will not automatically decode concatenated gzip streams.
+ inflate() will return Z_STREAM_END at the end of the gzip stream. The state
+ would need to be reset to continue decoding a subsequent gzip stream.
+
+ 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 Adler-32 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 Adler-32 value). inflateSetDictionary does not
+ perform any decompression: this will be done by subsequent calls of
+ inflate().
+*/
+
+ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm,
+ Bytef *dictionary,
+ uInt *dictLength));
+/*
+ Returns the sliding dictionary being maintained by inflate. dictLength is
+ set to the number of bytes in the dictionary, and that many bytes are copied
+ to dictionary. dictionary must have enough space, where 32768 bytes is
+ always enough. If inflateGetDictionary() is called with dictionary equal to
+ Z_NULL, then only the dictionary length is returned, and nothing is copied.
+ Similary, if dictLength is Z_NULL, then it is not set.
+
+ inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the
+ stream state is inconsistent.
+*/
+
+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 occurrences 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 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. If the window size is changed, then the
+ memory allocated for the window is freed, and the window will be reallocated
+ by inflate() if needed.
+
+ 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 long 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 -65536 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 *,
+ z_const 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 potentially 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. inflate() can be faster on modern CPUs when used with large
+ buffers. inflateBack() 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 default
+ behavior of inflate(), which expects a zlib 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 uLong ZEXPORT zlibCompileFlags OF((void));
+/* Return flags indicating compile-time options.
+
+ Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other:
+ 1.0: size of uInt
+ 3.2: size of uLong
+ 5.4: size of voidpf (pointer)
+ 7.6: size of z_off_t
+
+ Compiler, assembler, and debug options:
+ 8: ZLIB_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, uLongf *destLen,
+ const Bytef *source, uLong 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 data. compress() is equivalent to compress2() with a level
+ parameter of Z_DEFAULT_COMPRESSION.
+
+ 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, uLongf *destLen,
+ const Bytef *source, uLong 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 data.
+
+ compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
+ memory, Z_BUF_ERROR if there was not enough room in the output buffer,
+ Z_STREAM_ERROR if the level parameter is invalid.
+*/
+
+ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen));
+/*
+ compressBound() returns an upper bound on the compressed size after
+ compress() or compress2() on sourceLen bytes. It would be used before a
+ compress() or compress2() call to allocate the destination buffer.
+*/
+
+ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen,
+ const Bytef *source, uLong sourceLen));
+/*
+ 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 data.
+
+ 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.
+*/
+
+ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest, uLongf *destLen,
+ const Bytef *source, uLong *sourceLen));
+/*
+ Same as uncompress, except that sourceLen is a pointer, where the
+ length of the source is *sourceLen. On return, *sourceLen is the number of
+ source bytes consumed.
+*/
+
+ /* 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. Three times that size in buffer space is allocated. 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. Previously provided
+ data is flushed before the parameter change.
+
+ gzsetparams returns Z_OK if success, Z_STREAM_ERROR if the file was not
+ opened for writing, Z_ERRNO if there is an error writing the flushed data,
+ or Z_MEM_ERROR if there is a memory allocation error.
+*/
+
+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. If len is too large to fit in an int,
+ then nothing is read, -1 is returned, and the error state is set to
+ Z_STREAM_ERROR.
+*/
+
+ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems,
+ gzFile file));
+/*
+ Read up to nitems items of size size from file to buf, otherwise operating
+ as gzread() does. This duplicates the interface of stdio's fread(), with
+ size_t request and return types. If the library defines size_t, then
+ z_size_t is identical to size_t. If not, then z_size_t is an unsigned
+ integer type that can contain a pointer.
+
+ gzfread() returns the number of full items read of size size, or zero if
+ the end of the file was reached and a full item could not be read, or if
+ there was an error. gzerror() must be consulted if zero is returned in
+ order to determine if there was an error. If the multiplication of size and
+ nitems overflows, i.e. the product does not fit in a z_size_t, then nothing
+ is read, zero is returned, and the error state is set to Z_STREAM_ERROR.
+
+ In the event that the end of file is reached and only a partial item is
+ available at the end, i.e. the remaining uncompressed data length is not a
+ multiple of size, then the final partial item is nevetheless read into buf
+ and the end-of-file flag is set. The length of the partial item read is not
+ provided, but could be inferred from the result of gztell(). This behavior
+ is the same as the behavior of fread() implementations in common libraries,
+ but it prevents the direct use of gzfread() to read a concurrently written
+ file, reseting and retrying on end-of-file, when size is not 1.
+*/
+
+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 z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size,
+ z_size_t nitems, gzFile file));
+/*
+ gzfwrite() writes nitems items of size size from buf to file, duplicating
+ the interface of stdio's fwrite(), with size_t request and return types. If
+ the library defines size_t, then z_size_t is identical to size_t. If not,
+ then z_size_t is an unsigned integer type that can contain a pointer.
+
+ gzfwrite() returns the number of full items written of size size, or zero
+ if there was an error. If the multiplication of size and nitems overflows,
+ i.e. the product does not fit in a z_size_t, then nothing is written, zero
+ is returned, and the error state is set to Z_STREAM_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 a negative zlib error code 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
+ concatenated 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 uLong ZEXPORT adler32 OF((uLong 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 CRC-32 but can be computed
+ much faster.
+
+ Usage example:
+
+ uLong adler = adler32(0L, Z_NULL, 0);
+
+ while (read_buffer(buffer, length) != EOF) {
+ adler = adler32(adler, buffer, length);
+ }
+ if (adler != original_adler) error();
+*/
+
+ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef *buf,
+ z_size_t len));
+/*
+ Same as adler32(), but with a size_t length.
+*/
+
+/*
+ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong 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 uLong ZEXPORT crc32 OF((uLong 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:
+
+ uLong crc = crc32(0L, Z_NULL, 0);
+
+ while (read_buffer(buffer, length) != EOF) {
+ crc = crc32(crc, buffer, length);
+ }
+ if (crc != original_crc) error();
+*/
+
+ZEXTERN uLong ZEXPORT crc32_z OF((uLong adler, const Bytef *buf,
+ z_size_t len));
+/*
+ Same as crc32(), but with a size_t length.
+*/
+
+/*
+ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong 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));
+#ifdef Z_PREFIX_SET
+# define z_deflateInit(strm, level) \
+ deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
+# define z_inflateInit(strm) \
+ inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
+# define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+ deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+ (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
+# define z_inflateInit2(strm, windowBits) \
+ inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
+ (int)sizeof(z_stream))
+# define z_inflateBackInit(strm, windowBits, window) \
+ inflateBackInit_((strm), (windowBits), (window), \
+ ZLIB_VERSION, (int)sizeof(z_stream))
+#else
+# define deflateInit(strm, level) \
+ deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream))
+# define inflateInit(strm) \
+ inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream))
+# define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \
+ deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\
+ (strategy), ZLIB_VERSION, (int)sizeof(z_stream))
+# define inflateInit2(strm, windowBits) \
+ inflateInit2_((strm), (windowBits), ZLIB_VERSION, \
+ (int)sizeof(z_stream))
+# define inflateBackInit(strm, windowBits, window) \
+ inflateBackInit_((strm), (windowBits), (window), \
+ ZLIB_VERSION, (int)sizeof(z_stream))
+#endif
+
+#ifndef Z_SOLO
+
+/* gzgetc() macro and its supporting function and exposed data structure. 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 uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t));
+ ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, 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 uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
+ ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, 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 uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
+ ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
+#endif
+
+#else /* Z_SOLO */
+
+ ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t));
+ ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t));
+
+#endif /* !Z_SOLO */
+
+/* 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 inflateValidate OF((z_streamp, int));
+ZEXTERN unsigned long ZEXPORT inflateCodesUsed OF ((z_streamp));
+ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp));
+ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp));
+#if (defined(_WIN32) || defined(__CYGWIN__)) && !defined(Z_SOLO)
+ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path,
+ const char *mode));
+#endif
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+# ifndef Z_SOLO
+ZEXTERN int ZEXPORTVA gzvprintf Z_ARG((gzFile file,
+ const char *format,
+ va_list va));
+# endif
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* ZLIB_H */
diff --git a/zlib/zlib.map b/zlib/zlib.map
new file mode 100644
index 000000000..40fa9db2b
--- /dev/null
+++ b/zlib/zlib.map
@@ -0,0 +1,94 @@
+ZLIB_1.2.0 {
+ global:
+ compressBound;
+ deflateBound;
+ inflateBack;
+ inflateBackEnd;
+ inflateBackInit_;
+ inflateCopy;
+ local:
+ deflate_copyright;
+ inflate_copyright;
+ inflate_fast;
+ inflate_table;
+ zcalloc;
+ zcfree;
+ z_errmsg;
+ gz_error;
+ gz_intmax;
+ _*;
+};
+
+ZLIB_1.2.0.2 {
+ gzclearerr;
+ gzungetc;
+ zlibCompileFlags;
+} ZLIB_1.2.0;
+
+ZLIB_1.2.0.8 {
+ deflatePrime;
+} ZLIB_1.2.0.2;
+
+ZLIB_1.2.2 {
+ adler32_combine;
+ crc32_combine;
+ deflateSetHeader;
+ inflateGetHeader;
+} ZLIB_1.2.0.8;
+
+ZLIB_1.2.2.3 {
+ deflateTune;
+ gzdirect;
+} ZLIB_1.2.2;
+
+ZLIB_1.2.2.4 {
+ inflatePrime;
+} ZLIB_1.2.2.3;
+
+ZLIB_1.2.3.3 {
+ adler32_combine64;
+ crc32_combine64;
+ gzopen64;
+ gzseek64;
+ gztell64;
+ inflateUndermine;
+} ZLIB_1.2.2.4;
+
+ZLIB_1.2.3.4 {
+ inflateReset2;
+ inflateMark;
+} ZLIB_1.2.3.3;
+
+ZLIB_1.2.3.5 {
+ gzbuffer;
+ gzoffset;
+ gzoffset64;
+ gzclose_r;
+ gzclose_w;
+} ZLIB_1.2.3.4;
+
+ZLIB_1.2.5.1 {
+ deflatePending;
+} ZLIB_1.2.3.5;
+
+ZLIB_1.2.5.2 {
+ deflateResetKeep;
+ gzgetc_;
+ inflateResetKeep;
+} ZLIB_1.2.5.1;
+
+ZLIB_1.2.7.1 {
+ inflateGetDictionary;
+ gzvprintf;
+} ZLIB_1.2.5.2;
+
+ZLIB_1.2.9 {
+ inflateCodesUsed;
+ inflateValidate;
+ uncompress2;
+ gzfread;
+ gzfwrite;
+ deflateGetDictionary;
+ adler32_z;
+ crc32_z;
+} ZLIB_1.2.7.1;
diff --git a/zlib/zlib.pc.cmakein b/zlib/zlib.pc.cmakein
new file mode 100644
index 000000000..a5e642938
--- /dev/null
+++ b/zlib/zlib.pc.cmakein
@@ -0,0 +1,13 @@
+prefix=@CMAKE_INSTALL_PREFIX@
+exec_prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@INSTALL_LIB_DIR@
+sharedlibdir=@INSTALL_LIB_DIR@
+includedir=@INSTALL_INC_DIR@
+
+Name: zlib
+Description: zlib compression library
+Version: @VERSION@
+
+Requires:
+Libs: -L${libdir} -L${sharedlibdir} -lz
+Cflags: -I${includedir}
diff --git a/zlib/zlib.pc.in b/zlib/zlib.pc.in
new file mode 100644
index 000000000..7e5acf9c7
--- /dev/null
+++ b/zlib/zlib.pc.in
@@ -0,0 +1,13 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+sharedlibdir=@sharedlibdir@
+includedir=@includedir@
+
+Name: zlib
+Description: zlib compression library
+Version: @VERSION@
+
+Requires:
+Libs: -L${libdir} -L${sharedlibdir} -lz
+Cflags: -I${includedir}
diff --git a/zlib/zlib2ansi b/zlib/zlib2ansi
new file mode 100755
index 000000000..15e3e165f
--- /dev/null
+++ b/zlib/zlib2ansi
@@ -0,0 +1,152 @@
+#!/usr/bin/perl
+
+# Transform K&R C function definitions into ANSI equivalent.
+#
+# Author: Paul Marquess
+# Version: 1.0
+# Date: 3 October 2006
+
+# TODO
+#
+# Asumes no function pointer parameters. unless they are typedefed.
+# Assumes no literal strings that look like function definitions
+# Assumes functions start at the beginning of a line
+
+use strict;
+use warnings;
+
+local $/;
+$_ = <>;
+
+my $sp = qr{ \s* (?: /\* .*? \*/ )? \s* }x; # assume no nested comments
+
+my $d1 = qr{ $sp (?: [\w\*\s]+ $sp)* $sp \w+ $sp [\[\]\s]* $sp }x ;
+my $decl = qr{ $sp (?: \w+ $sp )+ $d1 }xo ;
+my $dList = qr{ $sp $decl (?: $sp , $d1 )* $sp ; $sp }xo ;
+
+
+while (s/^
+ ( # Start $1
+ ( # Start $2
+ .*? # Minimal eat content
+ ( ^ \w [\w\s\*]+ ) # $3 -- function name
+ \s* # optional whitespace
+ ) # $2 - Matched up to before parameter list
+
+ \( \s* # Literal "(" + optional whitespace
+ ( [^\)]+ ) # $4 - one or more anythings except ")"
+ \s* \) # optional whitespace surrounding a Literal ")"
+
+ ( (?: $dList )+ ) # $5
+
+ $sp ^ { # literal "{" at start of line
+ ) # Remember to $1
+ //xsom
+ )
+{
+ my $all = $1 ;
+ my $prefix = $2;
+ my $param_list = $4 ;
+ my $params = $5;
+
+ StripComments($params);
+ StripComments($param_list);
+ $param_list =~ s/^\s+//;
+ $param_list =~ s/\s+$//;
+
+ my $i = 0 ;
+ my %pList = map { $_ => $i++ }
+ split /\s*,\s*/, $param_list;
+ my $pMatch = '(\b' . join('|', keys %pList) . '\b)\W*$' ;
+
+ my @params = split /\s*;\s*/, $params;
+ my @outParams = ();
+ foreach my $p (@params)
+ {
+ if ($p =~ /,/)
+ {
+ my @bits = split /\s*,\s*/, $p;
+ my $first = shift @bits;
+ $first =~ s/^\s*//;
+ push @outParams, $first;
+ $first =~ /^(\w+\s*)/;
+ my $type = $1 ;
+ push @outParams, map { $type . $_ } @bits;
+ }
+ else
+ {
+ $p =~ s/^\s+//;
+ push @outParams, $p;
+ }
+ }
+
+
+ my %tmp = map { /$pMatch/; $_ => $pList{$1} }
+ @outParams ;
+
+ @outParams = map { " $_" }
+ sort { $tmp{$a} <=> $tmp{$b} }
+ @outParams ;
+
+ print $prefix ;
+ print "(\n" . join(",\n", @outParams) . ")\n";
+ print "{" ;
+
+}
+
+# Output any trailing code.
+print ;
+exit 0;
+
+
+sub StripComments
+{
+
+ no warnings;
+
+ # Strip C & C++ coments
+ # From the perlfaq
+ $_[0] =~
+
+ s{
+ /\* ## Start of /* ... */ comment
+ [^*]*\*+ ## Non-* followed by 1-or-more *'s
+ (
+ [^/*][^*]*\*+
+ )* ## 0-or-more things which don't start with /
+ ## but do end with '*'
+ / ## End of /* ... */ comment
+
+ | ## OR C++ Comment
+ // ## Start of C++ comment //
+ [^\n]* ## followed by 0-or-more non end of line characters
+
+ | ## OR various things which aren't comments:
+
+ (
+ " ## Start of " ... " string
+ (
+ \\. ## Escaped char
+ | ## OR
+ [^"\\] ## Non "\
+ )*
+ " ## End of " ... " string
+
+ | ## OR
+
+ ' ## Start of ' ... ' string
+ (
+ \\. ## Escaped char
+ | ## OR
+ [^'\\] ## Non '\
+ )*
+ ' ## End of ' ... ' string
+
+ | ## OR
+
+ . ## Anything other char
+ [^/"'\\]* ## Chars which doesn't start a comment, string or escape
+ )
+ }{$2}gxs;
+
+}
diff --git a/zlib/zutil.c b/zlib/zutil.c
new file mode 100644
index 000000000..a76c6b0c7
--- /dev/null
+++ b/zlib/zutil.c
@@ -0,0 +1,325 @@
+/* zutil.c -- target dependent utility functions for the compression library
+ * Copyright (C) 1995-2017 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#include "zutil.h"
+#ifndef Z_SOLO
+# include "gzguts.h"
+#endif
+
+z_const char * const z_errmsg[10] = {
+ (z_const char *)"need dictionary", /* Z_NEED_DICT 2 */
+ (z_const char *)"stream end", /* Z_STREAM_END 1 */
+ (z_const char *)"", /* Z_OK 0 */
+ (z_const char *)"file error", /* Z_ERRNO (-1) */
+ (z_const char *)"stream error", /* Z_STREAM_ERROR (-2) */
+ (z_const char *)"data error", /* Z_DATA_ERROR (-3) */
+ (z_const char *)"insufficient memory", /* Z_MEM_ERROR (-4) */
+ (z_const char *)"buffer error", /* Z_BUF_ERROR (-5) */
+ (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */
+ (z_const char *)""
+};
+
+
+const char * ZEXPORT zlibVersion()
+{
+ return ZLIB_VERSION;
+}
+
+uLong ZEXPORT zlibCompileFlags()
+{
+ uLong flags;
+
+ flags = 0;
+ switch ((int)(sizeof(uInt))) {
+ case 2: break;
+ case 4: flags += 1; break;
+ case 8: flags += 2; break;
+ default: flags += 3;
+ }
+ switch ((int)(sizeof(uLong))) {
+ case 2: break;
+ case 4: flags += 1 << 2; break;
+ case 8: flags += 2 << 2; break;
+ default: flags += 3 << 2;
+ }
+ switch ((int)(sizeof(voidpf))) {
+ case 2: break;
+ case 4: flags += 1 << 4; break;
+ case 8: flags += 2 << 4; break;
+ default: flags += 3 << 4;
+ }
+ switch ((int)(sizeof(z_off_t))) {
+ case 2: break;
+ case 4: flags += 1 << 6; break;
+ case 8: flags += 2 << 6; break;
+ default: flags += 3 << 6;
+ }
+#ifdef ZLIB_DEBUG
+ flags += 1 << 8;
+#endif
+#if defined(ASMV) || defined(ASMINF)
+ flags += 1 << 9;
+#endif
+#ifdef ZLIB_WINAPI
+ flags += 1 << 10;
+#endif
+#ifdef BUILDFIXED
+ flags += 1 << 12;
+#endif
+#ifdef DYNAMIC_CRC_TABLE
+ flags += 1 << 13;
+#endif
+#ifdef NO_GZCOMPRESS
+ flags += 1L << 16;
+#endif
+#ifdef NO_GZIP
+ flags += 1L << 17;
+#endif
+#ifdef PKZIP_BUG_WORKAROUND
+ flags += 1L << 20;
+#endif
+#ifdef FASTEST
+ flags += 1L << 21;
+#endif
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+# ifdef NO_vsnprintf
+ flags += 1L << 25;
+# ifdef HAS_vsprintf_void
+ flags += 1L << 26;
+# endif
+# else
+# ifdef HAS_vsnprintf_void
+ flags += 1L << 26;
+# endif
+# endif
+#else
+ flags += 1L << 24;
+# ifdef NO_snprintf
+ flags += 1L << 25;
+# ifdef HAS_sprintf_void
+ flags += 1L << 26;
+# endif
+# else
+# ifdef HAS_snprintf_void
+ flags += 1L << 26;
+# endif
+# endif
+#endif
+ return flags;
+}
+
+#ifdef ZLIB_DEBUG
+#include <stdlib.h>
+# ifndef verbose
+# define verbose 0
+# endif
+int ZLIB_INTERNAL z_verbose = verbose;
+
+void ZLIB_INTERNAL z_error (m)
+ char *m;
+{
+ fprintf(stderr, "%s\n", m);
+ exit(1);
+}
+#endif
+
+/* exported to allow conversion of error code to string for compress() and
+ * uncompress()
+ */
+const char * ZEXPORT zError(err)
+ int err;
+{
+ return ERR_MSG(err);
+}
+
+#if defined(_WIN32_WCE)
+ /* The Microsoft C Run-Time Library for Windows CE doesn't have
+ * errno. We define it as a global variable to simplify porting.
+ * Its value is always 0 and should not be used.
+ */
+ int errno = 0;
+#endif
+
+#ifndef HAVE_MEMCPY
+
+void ZLIB_INTERNAL zmemcpy(dest, source, len)
+ Bytef* dest;
+ const Bytef* source;
+ uInt len;
+{
+ if (len == 0) return;
+ do {
+ *dest++ = *source++; /* ??? to be unrolled */
+ } while (--len != 0);
+}
+
+int ZLIB_INTERNAL zmemcmp(s1, s2, len)
+ const Bytef* s1;
+ const Bytef* s2;
+ uInt len;
+{
+ uInt j;
+
+ for (j = 0; j < len; j++) {
+ if (s1[j] != s2[j]) return 2*(s1[j] > 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;
+ ulg bsize = (ulg)items*size;
+
+ (void)opaque;
+
+ /* 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;
+
+ (void)opaque;
+
+ 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;
+ }
+ 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)
+{
+ (void)opaque;
+ return _halloc((long)items, size);
+}
+
+void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
+{
+ (void)opaque;
+ _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;
+{
+ (void)opaque;
+ return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
+ (voidpf)calloc(items, size);
+}
+
+void ZLIB_INTERNAL zcfree (opaque, ptr)
+ voidpf opaque;
+ voidpf ptr;
+{
+ (void)opaque;
+ free(ptr);
+}
+
+#endif /* MY_ZCALLOC */
+
+#endif /* !Z_SOLO */
diff --git a/zlib/zutil.h b/zlib/zutil.h
new file mode 100644
index 000000000..b079ea6a8
--- /dev/null
+++ b/zlib/zutil.h
@@ -0,0 +1,271 @@
+/* zutil.h -- internal interface and configuration of the compression library
+ * Copyright (C) 1995-2016 Jean-loup Gailly, 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.
+ */
+
+/* @(#) $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 <stddef.h>
+# endif
+# include <string.h>
+# include <stdlib.h>
+#endif
+
+#ifdef Z_SOLO
+ typedef long ptrdiff_t; /* guess -- will be caught if guess is wrong */
+#endif
+
+#ifndef local
+# define local static
+#endif
+/* since "static" is used to mean two completely different things in C, we
+ define "local" for the non-static meaning of "static", for readability
+ (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 long ulg;
+
+extern z_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 = 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 long nbytes );
+# else
+# include <alloc.h>
+# endif
+# else /* MSC or DJGPP */
+# include <malloc.h>
+# endif
+# endif
+#endif
+
+#ifdef AMIGA
+# define OS_CODE 1
+#endif
+
+#if defined(VAXC) || defined(VMS)
+# define OS_CODE 2
+# define F_OPEN(name, mode) \
+ fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
+#endif
+
+#ifdef __370__
+# if __TARGET_LIB__ < 0x20000000
+# define OS_CODE 4
+# elif __TARGET_LIB__ < 0x40000000
+# define OS_CODE 11
+# else
+# define OS_CODE 8
+# endif
+#endif
+
+#if defined(ATARI) || defined(atarist)
+# define OS_CODE 5
+#endif
+
+#ifdef OS2
+# define OS_CODE 6
+# if defined(M_I86) && !defined(Z_SOLO)
+# include <malloc.h>
+# endif
+#endif
+
+#if defined(MACOS) || defined(TARGET_OS_MAC)
+# define OS_CODE 7
+# ifndef Z_SOLO
+# if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
+# include <unix.h> /* for fdopen */
+# else
+# ifndef fdopen
+# define fdopen(fd,mode) NULL /* No fdopen() */
+# endif
+# endif
+# endif
+#endif
+
+#ifdef __acorn
+# define OS_CODE 13
+#endif
+
+#if defined(WIN32) && !defined(__CYGWIN__)
+# define OS_CODE 10
+#endif
+
+#ifdef _BEOS_
+# define OS_CODE 16
+#endif
+
+#ifdef __TOS_OS400__
+# define OS_CODE 18
+#endif
+
+#ifdef __APPLE__
+# define OS_CODE 19
+#endif
+
+#if defined(_BEOS_) || defined(RISCOS)
+# define fdopen(fd,mode) NULL /* No fdopen() */
+#endif
+
+#if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX
+# if defined(_WIN32_WCE)
+# define fdopen(fd,mode) NULL /* No fdopen() */
+# ifndef _PTRDIFF_T_DEFINED
+ typedef int ptrdiff_t;
+# define _PTRDIFF_T_DEFINED
+# endif
+# else
+# define fdopen(fd,type) _fdopen(fd,type)
+# endif
+#endif
+
+#if defined(__BORLANDC__) && !defined(MSDOS)
+ #pragma warn -8004
+ #pragma warn -8008
+ #pragma warn -8066
+#endif
+
+/* provide prototypes for these when building zlib without LFS */
+#if !defined(_WIN32) && \
+ (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0)
+ ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
+ ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
+#endif
+
+ /* common defaults */
+
+#ifndef OS_CODE
+# define OS_CODE 3 /* 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 memcpy
+# define zmemcmp memcmp
+# define zmemzero(dest, len) memset(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 ZLIB_DEBUG
+# include <stdio.h>
+ 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 */
--
GitLab