From 687207e4c4f2d16fa06f32e9924eacbe464103a2 Mon Sep 17 00:00:00 2001 From: yaha <1143990204@qq.com> Date: Fri, 2 Jun 2023 14:53:48 +0800 Subject: [PATCH] build mac-arm --- Makefile | 407 ++++++- configure.log | 181 ++++ output/include/zconf.h | 547 ++++++++++ output/include/zlib.h | 1935 ++++++++++++++++++++++++++++++++++ output/lib/libz.1.2.13.dylib | Bin 0 -> 106185 bytes output/lib/libz.1.dylib | 1 + output/lib/libz.a | Bin 0 -> 103464 bytes output/lib/libz.dylib | 1 + output/lib/pkgconfig/zlib.pc | 13 + output/share/man/man3/zlib.3 | 149 +++ zconf.h | 4 +- zlib.pc | 13 + 12 files changed, 3245 insertions(+), 6 deletions(-) create mode 100644 configure.log create mode 100644 output/include/zconf.h create mode 100644 output/include/zlib.h create mode 100755 output/lib/libz.1.2.13.dylib create mode 120000 output/lib/libz.1.dylib create mode 100644 output/lib/libz.a create mode 120000 output/lib/libz.dylib create mode 100644 output/lib/pkgconfig/zlib.pc create mode 100644 output/share/man/man3/zlib.3 create mode 100644 zlib.pc diff --git a/Makefile b/Makefile index 6bba86c..7a90ad0 100644 --- a/Makefile +++ b/Makefile @@ -1,5 +1,404 @@ -all: - -@echo "Please use ./configure first. Thank you." +# Makefile for zlib +# Copyright (C) 1995-2017 Jean-loup Gailly, Mark Adler +# For conditions of distribution and use, see copyright notice in zlib.h -distclean: - make -f Makefile.in distclean +# 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 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=gcc + +CFLAGS=-O3 -DHAVE_HIDDEN +#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=-O3 -fPIC -DHAVE_HIDDEN +LDFLAGS= +TEST_LDFLAGS=$(LDFLAGS) -L. libz.a +LDSHARED=gcc -dynamiclib -install_name ${exec_prefix}/lib/libz.1.dylib -compatibility_version 1 -current_version 1.2.13 +CPP= + +STATICLIB=libz.a +SHAREDLIB=libz.dylib +SHAREDLIBV=libz.1.2.13.dylib +SHAREDLIBM=libz.1.dylib +LIBS=$(STATICLIB) $(SHAREDLIBV) + +AR=libtool +ARFLAGS=-o +RANLIB=ranlib +LDCONFIG=ldconfig +LDSHAREDLIBC=-lc +TAR=tar +SHELL=/bin/sh +EXE= + +prefix =./output +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 | ${QEMU_RUN} ./minigzip | ${QEMU_RUN} ./minigzip -d && ${QEMU_RUN} ./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 | ${QEMU_RUN} ./minigzipsh | ${QEMU_RUN} ./minigzipsh -d && ${QEMU_RUN} ./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 | ${QEMU_RUN} ./minigzip64 | ${QEMU_RUN} ./minigzip64 -d && ${QEMU_RUN} ./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 + ${QEMU_RUN} ./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 $(LDFLAGS) -L. $(SHAREDLIBV) + +minigzipsh$(EXE): minigzip.o $(SHAREDLIBV) + $(CC) $(CFLAGS) -o $@ minigzip.o $(LDFLAGS) -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 + 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 + +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/configure.log b/configure.log new file mode 100644 index 0000000..3056d80 --- /dev/null +++ b/configure.log @@ -0,0 +1,181 @@ +-------------------- +./configure --prefix=./output +Fri Jun 2 14:52:45 CST 2023 +Checking for gcc... +=== ztest12417.c === +extern int getchar(); +int hello() {return getchar();} +=== +gcc -c ztest12417.c +... using gcc + +Checking for obsessive-compulsive compiler options... +=== ztest12417.c === +int foo() { return 0; } +=== +gcc -c -O3 ztest12417.c + +Checking for shared library support... +=== ztest12417.c === +extern int getchar(); +int hello() {return getchar();} +=== +gcc -w -c -O3 -fPIC ztest12417.c +gcc -dynamiclib -install_name ${exec_prefix}/lib/libz.1.dylib -compatibility_version 1 -current_version 1.2.13 -O3 -fPIC -o ztest12417.dylib ztest12417.o +Building shared library libz.1.2.13.dylib with gcc. + +=== ztest12417.c === +#include +#include +size_t dummy = 0; +=== +gcc -c -O3 ztest12417.c +Checking for size_t... Yes. + +=== ztest12417.c === +#include +off64_t dummy = 0; +=== +gcc -c -O3 -D_LARGEFILE64_SOURCE=1 ztest12417.c +ztest12417.c:2:1: error: unknown type name 'off64_t'; did you mean 'off_t'? +off64_t dummy = 0; +^~~~~~~ +off_t +/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/usr/include/sys/_types/_off_t.h:31:33: note: 'off_t' declared here +typedef __darwin_off_t off_t; + ^ +1 error generated. +(exit code 1) +Checking for off64_t... No. + +=== ztest12417.c === +#include +int main(void) { + fseeko(NULL, 0, 0); + return 0; +} +=== +gcc -O3 -o ztest12417 ztest12417.c +Checking for fseeko... Yes. + +=== ztest12417.c === +#include +#include +int main() { return strlen(strerror(errno)); } +=== +gcc -O3 -o ztest12417 ztest12417.c +Checking for strerror... Yes. + +=== ztest12417.c === +#include +int main() { return 0; } +=== +gcc -c -O3 ztest12417.c +Checking for unistd.h... Yes. + +=== ztest12417.c === +#include +int main() { return 0; } +=== +gcc -c -O3 ztest12417.c +Checking for stdarg.h... Yes. + +=== ztest12417.c === +#include +#include +#include "zconf.h" +int main() +{ +#ifndef STDC + choke me +#endif + return 0; +} +=== +gcc -c -O3 ztest12417.c +Checking whether to use vs[n]printf() or s[n]printf()... using vs[n]printf(). + +=== ztest12417.c === +#include +#include +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)); +} +=== +gcc -O3 -o ztest12417 ztest12417.c +Checking for vsnprintf() in stdio.h... Yes. + +=== ztest12417.c === +#include +#include +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)); +} +=== +gcc -c -O3 ztest12417.c +Checking for return value of vsnprintf()... Yes. + +=== ztest12417.c === +#define ZLIB_INTERNAL __attribute__((visibility ("hidden"))) +int ZLIB_INTERNAL foo; +int main() +{ + return 0; +} +=== +gcc -c -O3 ztest12417.c +Checking for attribute(visibility) support... Yes. + +ALL = static shared +AR = libtool +ARFLAGS = -o +CC = gcc +CFLAGS = -O3 -DHAVE_HIDDEN +CPP = +EXE = +LDCONFIG = ldconfig +LDFLAGS = +LDSHARED = gcc -dynamiclib -install_name ${exec_prefix}/lib/libz.1.dylib -compatibility_version 1 -current_version 1.2.13 +LDSHAREDLIBC = -lc +OBJC = $(OBJZ) $(OBJG) +PIC_OBJC = $(PIC_OBJZ) $(PIC_OBJG) +RANLIB = ranlib +SFLAGS = -O3 -fPIC -DHAVE_HIDDEN +SHAREDLIB = libz.dylib +SHAREDLIBM = libz.1.dylib +SHAREDLIBV = libz.1.2.13.dylib +STATICLIB = libz.a +TEST = all teststatic testshared +VER = 1.2.13 +SRCDIR = +exec_prefix = ${prefix} +includedir = ${prefix}/include +libdir = ${exec_prefix}/lib +mandir = ${prefix}/share/man +prefix = ./output +sharedlibdir = ${libdir} +uname = Darwin +-------------------- + + diff --git a/output/include/zconf.h b/output/include/zconf.h new file mode 100644 index 0000000..622afa0 --- /dev/null +++ b/output/include/zconf.h @@ -0,0 +1,547 @@ +/* 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_combine_gen z_crc32_combine_gen +# define crc32_combine_gen64 z_crc32_combine_gen64 +# define crc32_combine_op z_crc32_combine_op +# 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 + 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 +# ifndef WIN32_LEAN_AND_MEAN +# define WIN32_LEAN_AND_MEAN +# endif +# include + /* No need for _export, use ZLIB.DEF instead. */ + /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR CDECL +# endif +# endif +#endif + +#if defined (__BEOS__) +# ifdef ZLIB_DLL +# ifdef ZLIB_INTERNAL +# define ZEXPORT __declspec(dllexport) +# define ZEXPORTVA __declspec(dllexport) +# else +# define ZEXPORT __declspec(dllimport) +# define ZEXPORTVA __declspec(dllimport) +# endif +# endif +#endif + +#ifndef ZEXTERN +# define ZEXTERN extern +#endif +#ifndef ZEXPORT +# define ZEXPORT +#endif +#ifndef ZEXPORTVA +# define ZEXPORTVA +#endif + +#ifndef FAR +# define FAR +#endif + +#if !defined(__MACTYPES__) +typedef unsigned char Byte; /* 8 bits */ +#endif +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned 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 +# 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 + +#if 1 /* was set to #if 1 by ./configure */ +# define Z_HAVE_UNISTD_H +#endif + +#if 1 /* was set to #if 1 by ./configure */ +# define Z_HAVE_STDARG_H +#endif + +#ifdef STDC +# ifndef Z_SOLO +# include /* for off_t */ +# endif +#endif + +#if defined(STDC) || defined(Z_HAVE_STDARG_H) +# ifndef Z_SOLO +# include /* for va_list */ +# endif +#endif + +#ifdef _WIN32 +# ifndef Z_SOLO +# include /* 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 + +#ifndef Z_HAVE_UNISTD_H +# ifdef __WATCOMC__ +# define Z_HAVE_UNISTD_H +# endif +#endif +#ifndef Z_HAVE_UNISTD_H +# if defined(_LARGEFILE64_SOURCE) && !defined(_WIN32) +# define Z_HAVE_UNISTD_H +# endif +#endif +#ifndef Z_SOLO +# if defined(Z_HAVE_UNISTD_H) +# include /* for SEEK_*, off_t, and _LFS64_LARGEFILE */ +# ifdef VMS +# include /* for off_t */ +# endif +# ifndef z_off_t +# define z_off_t off_t +# endif +# endif +#endif + +#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0 +# define Z_LFS64 +#endif + +#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64) +# define Z_LARGE64 +#endif + +#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64) +# define Z_WANT64 +#endif + +#if !defined(SEEK_SET) && !defined(Z_SOLO) +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +#endif + +#ifndef z_off_t +# define z_off_t 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/output/include/zlib.h b/output/include/zlib.h new file mode 100644 index 0000000..953cb50 --- /dev/null +++ b/output/include/zlib.h @@ -0,0 +1,1935 @@ +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.2.13, October 13th, 2022 + + Copyright (C) 1995-2022 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.13" +#define ZLIB_VERNUM 0x12d0 +#define ZLIB_VER_MAJOR 1 +#define ZLIB_VER_MINOR 2 +#define ZLIB_VER_REVISION 13 +#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 output + 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 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. + Similarly, 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 there have been any deflate() calls since the + state was initialized or reset, 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 members. + inflate() will return Z_STREAM_END at the end of the gzip member. The state + would need to be reset to continue decoding a subsequent gzip member. This + *must* be done if there is more data after a gzip member, in order for the + decompression to be compliant with the gzip standard (RFC 1952). + + 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. + Similarly, 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)); + + Open the gzip (.gz) file at path for reading and decompressing, or + compressing and 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)); +/* + Associate 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 for file to + size. 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 and strategy for file. See the + description of deflateInit2 for the meaning of these parameters. Previously + provided data is flushed before applying the parameter changes. + + 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)); +/* + Read and decompress up to len uncompressed bytes from file into buf. 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 and decompress up to nitems items of size size from file into 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 nevertheless 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, resetting and retrying on end-of-file, when size is not 1. +*/ + +ZEXTERN int ZEXPORT gzwrite OF((gzFile file, voidpc buf, unsigned len)); +/* + Compress and write the len uncompressed bytes at buf to 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)); +/* + Compress and write 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, ...)); +/* + Convert, format, compress, and write the arguments (...) to file under + control of the string format, 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)); +/* + Compress and write the given null-terminated string s to 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)); +/* + Read and decompress bytes from file into buf, until len-1 characters are + read, or until 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 + is one, the string is terminated with a null character. If no characters + are read due to an end-of-file or len is less than one, 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)); +/* + Compress and write c, converted to an unsigned char, into file. gzputc + returns the value that was written, or -1 in case of error. +*/ + +ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); +/* + Read and decompress one byte from 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 c back onto the stream for file to be read as the first character on + the next read. At least one character of push-back is always 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)); +/* + Flush all pending output to 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)); + + Set the starting position to offset relative to whence for the next gzread + or gzwrite on 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)); +/* + Rewind 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)); + + Return the starting position for the next gzread or gzwrite on 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)); + + Return the current compressed (actual) read or write offset of file. 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)); +/* + Return true (1) if the end-of-file indicator for file 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)); +/* + Return 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)); +/* + Flush all pending output for file, if necessary, close file and + deallocate 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)); +/* + Return the error message for the last error which occurred on 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)); +/* + Clear 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. An Adler-32 value is in the range of a 32-bit + unsigned integer. 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. A CRC-32 value is in the range of a 32-bit unsigned integer. + 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 crc, 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. +*/ + +/* +ZEXTERN uLong ZEXPORT crc32_combine_gen OF((z_off_t len2)); + + Return the operator corresponding to length len2, to be used with + crc32_combine_op(). +*/ + +ZEXTERN uLong ZEXPORT crc32_combine_op OF((uLong crc1, uLong crc2, uLong op)); +/* + Give the same result as crc32_combine(), using op in place of len2. op is + is generated from len2 by crc32_combine_gen(). This will be faster than + crc32_combine() if the generated op is used more than once. +*/ + + + /* 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)); + ZEXTERN uLong ZEXPORT crc32_combine_gen64 OF((z_off64_t)); +#endif + +#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) +# ifdef Z_PREFIX_SET +# define z_gzopen z_gzopen64 +# define z_gzseek z_gzseek64 +# define z_gztell z_gztell64 +# define z_gzoffset z_gzoffset64 +# define z_adler32_combine z_adler32_combine64 +# define z_crc32_combine z_crc32_combine64 +# define z_crc32_combine_gen z_crc32_combine_gen64 +# else +# define gzopen gzopen64 +# define gzseek gzseek64 +# define gztell gztell64 +# define gzoffset gzoffset64 +# define adler32_combine adler32_combine64 +# define crc32_combine crc32_combine64 +# define crc32_combine_gen crc32_combine_gen64 +# endif +# ifndef Z_LARGE64 + ZEXTERN gzFile ZEXPORT gzopen64 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)); + ZEXTERN uLong ZEXPORT crc32_combine_gen64 OF((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)); + ZEXTERN uLong ZEXPORT crc32_combine_gen OF((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)); + ZEXTERN uLong ZEXPORT crc32_combine_gen OF((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(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/output/lib/libz.1.2.13.dylib b/output/lib/libz.1.2.13.dylib new file mode 100755 index 0000000000000000000000000000000000000000..6f1792144a6f47e9206b91a64e4cc175bf089238 GIT binary patch literal 106185 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 literal 0 HcmV?d00001 diff --git a/output/lib/libz.1.dylib b/output/lib/libz.1.dylib new file mode 120000 index 0000000..4d69db0 --- /dev/null +++ b/output/lib/libz.1.dylib @@ -0,0 +1 @@ +libz.1.2.13.dylib \ No newline at end of file diff --git a/output/lib/libz.a b/output/lib/libz.a new file mode 100644 index 0000000000000000000000000000000000000000..361572b3ef2dde949b96ed994fceccbca235f588 GIT binary patch literal 103464 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