diff options
| author | Mark Adler <madler@alumni.caltech.edu> | 2011-09-09 23:14:39 -0700 |
|---|---|---|
| committer | Mark Adler <madler@alumni.caltech.edu> | 2011-09-09 23:14:39 -0700 |
| commit | 423eb40306489f9c88f7dba32c2f69179166730b (patch) | |
| tree | b5a83b0b1e52bbe0de973dcbc7ec008c1d7cf7d9 | |
| parent | 8a2acbffc86012de3523ecf91db2c4ea1b1c4ea2 (diff) | |
| download | zlib-423eb40306489f9c88f7dba32c2f69179166730b.tar.gz zlib-423eb40306489f9c88f7dba32c2f69179166730b.tar.bz2 zlib-423eb40306489f9c88f7dba32c2f69179166730b.zip | |
zlib 1.0.1v1.0.1
Diffstat (limited to '')
| -rw-r--r-- | ChangeLog | 68 | ||||
| -rw-r--r-- | INDEX | 46 | ||||
| -rw-r--r-- | Makefile | 120 | ||||
| -rw-r--r-- | Makefile.b32 | 104 | ||||
| -rw-r--r-- | Makefile.bor | 2 | ||||
| -rw-r--r-- | Makefile.dj2 | 79 | ||||
| -rw-r--r-- | Makefile.in | 129 | ||||
| -rw-r--r-- | Makefile.qnx | 75 | ||||
| -rw-r--r-- | Makefile.sas | 64 | ||||
| -rw-r--r-- | Makefile.wat | 103 | ||||
| -rw-r--r-- | README | 91 | ||||
| -rw-r--r-- | adler32.c | 20 | ||||
| -rw-r--r-- | compress.c | 8 | ||||
| -rwxr-xr-x | configure | 86 | ||||
| -rw-r--r-- | crc32.c | 62 | ||||
| -rw-r--r-- | deflate.c | 230 | ||||
| -rw-r--r-- | deflate.h | 27 | ||||
| -rw-r--r-- | example.c | 170 | ||||
| -rw-r--r-- | gzio.c | 369 | ||||
| -rw-r--r-- | infblock.c | 33 | ||||
| -rw-r--r-- | infblock.h | 7 | ||||
| -rw-r--r-- | infcodes.c | 9 | ||||
| -rw-r--r-- | infcodes.h | 2 | ||||
| -rw-r--r-- | inffast.c | 9 | ||||
| -rw-r--r-- | inffast.h | 2 | ||||
| -rw-r--r-- | inflate.c | 96 | ||||
| -rw-r--r-- | inftrees.c | 31 | ||||
| -rw-r--r-- | inftrees.h | 2 | ||||
| -rw-r--r-- | infutil.c | 8 | ||||
| -rw-r--r-- | infutil.h | 30 | ||||
| -rw-r--r-- | minigzip.c | 19 | ||||
| -rw-r--r-- | trees.c | 36 | ||||
| -rw-r--r-- | uncompr.c | 8 | ||||
| -rw-r--r-- | zconf.h | 67 | ||||
| -rw-r--r-- | zlib.h | 213 | ||||
| -rw-r--r-- | zutil.c | 44 | ||||
| -rw-r--r-- | zutil.h | 26 |
37 files changed, 1814 insertions, 681 deletions
| @@ -1,20 +1,54 @@ | |||
| 1 | 1 | ||
| 2 | ChangeLog file for zlib | 2 | ChangeLog file for zlib |
| 3 | 3 | ||
| 4 | Changes in 1.0 (15 Jan 96) | 4 | Changes in 1.0.1 (20 May 96) [1.0 skipped to avoid confusion] |
| 5 | - fix array overlay in deflate.c which sometimes caused bad compressed data | ||
| 6 | - fix inflate bug with empty stored block | ||
| 7 | - fix MSDOS medium model which was broken in 0.99 | ||
| 8 | - fix deflateParams() which could generated bad compressed data. | ||
| 9 | - Bytef is define'd instead of typedef'ed (work around Borland bug) | ||
| 10 | - added an INDEX file | ||
| 11 | - new makefiles for DJGPP (Makefile.dj2), 32-bit Borland (Makefile.b32), | ||
| 12 | Watcom (Makefile.wat), Amiga SAS/C (Makefile.sas) | ||
| 13 | - speed up adler32 for modern machines without auto-increment | ||
| 14 | - added -ansi for IRIX in configure | ||
| 15 | - static_init_done in trees.c is an int | ||
| 16 | - define unlink as delete for VMS | ||
| 17 | - fix configure for QNX | ||
| 18 | - add configure branch for SCO and HPUX | ||
| 19 | - avoid many warnings (unused variables, dead assignments, etc...) | ||
| 20 | - no fdopen for BeOS | ||
| 21 | - fix the Watcom fix for 32 bit mode (define FAR as empty) | ||
| 22 | - removed redefinition of Byte for MKWERKS | ||
| 23 | - work around an MWKERKS bug (incorrect merge of all .h files) | ||
| 24 | |||
| 25 | Changes in 0.99 (27 Jan 96) | ||
| 26 | - allow preset dictionary shared between compressor and decompressor | ||
| 27 | - allow compression level 0 (no compression) | ||
| 28 | - add deflateParams in zlib.h: allow dynamic change of compression level | ||
| 29 | and compression strategy. | ||
| 30 | - test large buffers and deflateParams in example.c | ||
| 31 | - add optional "configure" to build zlib as a shared library | ||
| 32 | - suppress Makefile.qnx, use configure instead | ||
| 5 | - fixed deflate for 64-bit systems (detected on Cray) | 33 | - fixed deflate for 64-bit systems (detected on Cray) |
| 6 | - fixed inflate_blocks for 64-bit systems (detected on Alpha) | 34 | - fixed inflate_blocks for 64-bit systems (detected on Alpha) |
| 35 | - declare Z_DEFLATED in zlib.h (possible parameter for deflateInit2) | ||
| 36 | - always return Z_BUF_ERROR when deflate() has nothing to do | ||
| 37 | - deflateInit and inflateInit are now macros to allow version checking | ||
| 38 | - prefix all global functions and types with z_ with -DZ_PREFIX | ||
| 7 | - make falloc completely reentrant (inftrees.c) | 39 | - make falloc completely reentrant (inftrees.c) |
| 8 | - fixed very unlikely race condition in ct_static_init | 40 | - fixed very unlikely race condition in ct_static_init |
| 9 | - always return Z_BUF_ERROR when deflate() has nothing to do | ||
| 10 | - add deflateParams in zlib.h. | ||
| 11 | - test large buffers and deflateParams in example.c | ||
| 12 | - declare Z_DEFLATED in zlib.h (possible parameter for deflateInit2) | ||
| 13 | - Document Z_SYNC_FLUSH | ||
| 14 | - added deflateGetAdler32 and deflateSetAdler32 | ||
| 15 | - free in reverse order of allocation to help memory manager | 41 | - free in reverse order of allocation to help memory manager |
| 42 | - use zlib-1.0/* instead of zlib/* inside the tar.gz | ||
| 43 | - make zlib warning-free with "gcc -O3 -Wall -Wwrite-strings -Wpointer-arith | ||
| 44 | -Wconversion -Wstrict-prototypes -Wmissing-prototypes" | ||
| 45 | - allow gzread on concatenated .gz files | ||
| 46 | - deflateEnd now returns Z_DATA_ERROR if it was premature | ||
| 47 | - deflate is finally (?) fully deterministic (no matches beyond end of input) | ||
| 48 | - Document Z_SYNC_FLUSH | ||
| 49 | - add uninstall in Makefile | ||
| 16 | - Check for __cpluplus in zlib.h | 50 | - Check for __cpluplus in zlib.h |
| 17 | - Finer test in ct_align for partial flush | 51 | - Better test in ct_align for partial flush |
| 18 | - avoid harmless warnings for Borland C++ | 52 | - avoid harmless warnings for Borland C++ |
| 19 | - initialize hash_head in deflate.c | 53 | - initialize hash_head in deflate.c |
| 20 | - avoid warning on fdopen (gzio.c) for HP cc -Aa | 54 | - avoid warning on fdopen (gzio.c) for HP cc -Aa |
| @@ -23,7 +57,7 @@ Changes in 1.0 (15 Jan 96) | |||
| 23 | - ignore error if ranlib doesn't exist | 57 | - ignore error if ranlib doesn't exist |
| 24 | - call ranlib twice for NeXTSTEP | 58 | - call ranlib twice for NeXTSTEP |
| 25 | - use exec_prefix instead of prefix for libz.a | 59 | - use exec_prefix instead of prefix for libz.a |
| 26 | - renamed ct_* as tr_* to avoid conflict with another application. | 60 | - renamed ct_* as _tr_* to avoid conflict with applications |
| 27 | - clear z->msg in inflateInit2 before any error return | 61 | - clear z->msg in inflateInit2 before any error return |
| 28 | - initialize opaque in example.c, gzio.c, deflate.c and inflate.c | 62 | - initialize opaque in example.c, gzio.c, deflate.c and inflate.c |
| 29 | - fixed typo in zconf.h (_GNUC__ => __GNUC__) | 63 | - fixed typo in zconf.h (_GNUC__ => __GNUC__) |
| @@ -32,6 +66,22 @@ Changes in 1.0 (15 Jan 96) | |||
| 32 | - in fcalloc, normalize pointer if size > 65520 bytes | 66 | - in fcalloc, normalize pointer if size > 65520 bytes |
| 33 | - don't use special fcalloc for 32 bit Borland C++ | 67 | - don't use special fcalloc for 32 bit Borland C++ |
| 34 | - use STDC instead of __GO32__ to avoid redeclaring exit, calloc, etc... | 68 | - use STDC instead of __GO32__ to avoid redeclaring exit, calloc, etc... |
| 69 | - use Z_BINARY instead of BINARY | ||
| 70 | - document that gzclose after gzdopen will close the file | ||
| 71 | - allow "a" as mode in gzopen. | ||
| 72 | - fix error checking in gzread | ||
| 73 | - allow skipping .gz extra-field on pipes | ||
| 74 | - added reference to Perl interface in README | ||
| 75 | - put the crc table in FAR data (I dislike more and more the medium model :) | ||
| 76 | - added get_crc_table | ||
| 77 | - added a dimension to all arrays (Borland C can't count). | ||
| 78 | - workaround Borland C bug in declaration of inflate_codes_new & inflate_fast | ||
| 79 | - guard against multiple inclusion of *.h (for precompiled header on Mac) | ||
| 80 | - Watcom C pretends to be Microsoft C small model even in 32 bit mode. | ||
| 81 | - don't use unsized arrays to avoid silly warnings by Visual C++: | ||
| 82 | warning C4746: 'inflate_mask' : unsized array treated as '__far' | ||
| 83 | (what's wrong with far data in far model?). | ||
| 84 | - define enum out of inflate_blocks_state to allow compilation with C++ | ||
| 35 | 85 | ||
| 36 | Changes in 0.95 (16 Aug 95) | 86 | Changes in 0.95 (16 Aug 95) |
| 37 | - fix MSDOS small and medium model (now easier to adapt to any compiler) | 87 | - fix MSDOS small and medium model (now easier to adapt to any compiler) |
| @@ -0,0 +1,46 @@ | |||
| 1 | ChangeLog history of changes | ||
| 2 | INDEX this file | ||
| 3 | Make_vms.com script for Vax/VMS | ||
| 4 | Makefile makefile for Unix (generated by configure) | ||
| 5 | Makefile.b32 makefile for Borland C++ 32-bit | ||
| 6 | Makefile.bor makefile for Borland C/C++ 16-bit | ||
| 7 | Makefile.dj2 makefile for DJGPP 2.x | ||
| 8 | Makefile.in makefile for Unix (template for configure) | ||
| 9 | Makefile.msc makefile for Microsoft C 16-bit | ||
| 10 | Makefile.sas makefile for Amiga SAS/C | ||
| 11 | Makefile.tc makefile for Turbo C | ||
| 12 | Makefile.wat makefile for Watcom C | ||
| 13 | README guess what | ||
| 14 | configure configure script for Unix | ||
| 15 | descrip.mms makefile for Vax/VMS | ||
| 16 | |||
| 17 | zlib public header files (must be kept): | ||
| 18 | zconf.h | ||
| 19 | zlib.h | ||
| 20 | |||
| 21 | private source files used to build the zlib library: | ||
| 22 | adler32.c | ||
| 23 | compress.c | ||
| 24 | crc32.c | ||
| 25 | deflate.c | ||
| 26 | deflate.h | ||
| 27 | gzio.c | ||
| 28 | infblock.c | ||
| 29 | infblock.h | ||
| 30 | infcodes.c | ||
| 31 | infcodes.h | ||
| 32 | inffast.c | ||
| 33 | inffast.h | ||
| 34 | inflate.c | ||
| 35 | inftrees.c | ||
| 36 | inftrees.h | ||
| 37 | infutil.c | ||
| 38 | infutil.h | ||
| 39 | trees.c | ||
| 40 | uncompr.c | ||
| 41 | zutil.c | ||
| 42 | zutil.h | ||
| 43 | |||
| 44 | source files for sample programs: | ||
| 45 | example.c | ||
| 46 | minigzip.c | ||
| @@ -2,78 +2,128 @@ | |||
| 2 | # Copyright (C) 1995-1996 Jean-loup Gailly. | 2 | # Copyright (C) 1995-1996 Jean-loup Gailly. |
| 3 | # For conditions of distribution and use, see copyright notice in zlib.h | 3 | # For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | 4 | ||
| 5 | # To compile and test, type: | ||
| 6 | # ./configure; make test | ||
| 7 | # The call of configure is optional if you don't have special requirements | ||
| 8 | |||
| 9 | # To install /usr/local/lib/libz.* and /usr/local/include/zlib.h, type: | ||
| 10 | # make install | ||
| 11 | # To install in $HOME instead of /usr/local, use: | ||
| 12 | # make install prefix=$HOME | ||
| 13 | |||
| 5 | CC=cc | 14 | CC=cc |
| 15 | |||
| 6 | CFLAGS=-O | 16 | CFLAGS=-O |
| 7 | #use -O3 for gcc | 17 | #CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7 |
| 8 | #CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" | ||
| 9 | #CFLAGS=-g -DDEBUG | 18 | #CFLAGS=-g -DDEBUG |
| 19 | #CFLAGS=-O3 -Wall -Wwrite-strings -Wpointer-arith -Wconversion \ | ||
| 20 | # -Wstrict-prototypes -Wmissing-prototypes | ||
| 21 | |||
| 10 | LDFLAGS=-L. -lz | 22 | LDFLAGS=-L. -lz |
| 23 | LDSHARED=$(CC) | ||
| 11 | 24 | ||
| 25 | VER=1.0.1 | ||
| 26 | LIBS=libz.a | ||
| 27 | |||
| 28 | AR=ar rc | ||
| 12 | RANLIB=ranlib | 29 | RANLIB=ranlib |
| 30 | TAR=tar | ||
| 13 | 31 | ||
| 14 | prefix=/usr/local | 32 | prefix=/usr/local |
| 15 | exec_prefix = ${prefix} | 33 | exec_prefix = $(prefix) |
| 16 | 34 | ||
| 17 | OBJS = adler32.o compress.o crc32.o gzio.o uncompr.o deflate.o trees.o \ | 35 | OBJS = adler32.o compress.o crc32.o gzio.o uncompr.o deflate.o trees.o \ |
| 18 | zutil.o inflate.o infblock.o inftrees.o infcodes.o infutil.o inffast.o | 36 | zutil.o inflate.o infblock.o inftrees.o infcodes.o infutil.o inffast.o |
| 19 | 37 | ||
| 20 | TEST_OBJS = example.o minigzip.o | 38 | TEST_OBJS = example.o minigzip.o |
| 21 | 39 | ||
| 40 | DISTFILES = README INDEX ChangeLog configure Make*[a-z0-9] descrip.mms *.[ch] | ||
| 41 | |||
| 22 | all: example minigzip | 42 | all: example minigzip |
| 23 | 43 | ||
| 24 | test: all | 44 | test: all |
| 25 | ./example | 45 | ./example |
| 26 | echo hello world | ./minigzip | ./minigzip -d | 46 | echo hello world | ./minigzip | ./minigzip -d |
| 27 | 47 | ||
| 28 | install: libz.a | ||
| 29 | -@mkdir $(prefix)/include | ||
| 30 | -@mkdir $(exec_prefix)/lib | ||
| 31 | cp zlib.h zconf.h $(prefix)/include | ||
| 32 | chmod 644 $(prefix)/include/zlib.h $(prefix)/include/zconf.h | ||
| 33 | cp libz.a $(exec_prefix)/lib | ||
| 34 | chmod 644 $(exec_prefix)/lib/libz.a | ||
| 35 | -@$(RANLIB) $(prefix)/lib/libz.a | ||
| 36 | # This second ranlib is needed on NeXTSTEP which checks file times | ||
| 37 | |||
| 38 | libz.a: $(OBJS) | 48 | libz.a: $(OBJS) |
| 39 | ar rc $@ $(OBJS) | 49 | $(AR) $@ $(OBJS) |
| 40 | -@$(RANLIB) $@ | 50 | -@ ($(RANLIB) $@ || true) 2>/dev/null |
| 51 | |||
| 52 | libz.so.$(VER): $(OBJS) | ||
| 53 | $(LDSHARED) -o $@ $(OBJS) | ||
| 54 | rm -f libz.so; ln -s $@ libz.so | ||
| 41 | 55 | ||
| 42 | example: example.o libz.a | 56 | example: example.o $(LIBS) |
| 43 | $(CC) $(CFLAGS) -o $@ example.o $(LDFLAGS) | 57 | $(CC) $(CFLAGS) -o $@ example.o $(LDFLAGS) |
| 44 | 58 | ||
| 45 | minigzip: minigzip.o libz.a | 59 | minigzip: minigzip.o $(LIBS) |
| 46 | $(CC) $(CFLAGS) -o $@ minigzip.o $(LDFLAGS) | 60 | $(CC) $(CFLAGS) -o $@ minigzip.o $(LDFLAGS) |
| 47 | 61 | ||
| 62 | install: $(LIBS) | ||
| 63 | -@if [ ! $(prefix)/include ]; then mkdir $(prefix)/include; fi | ||
| 64 | -@if [ ! $(exec_prefix)/lib ]; then mkdir $(exec_prefix)/lib; fi | ||
| 65 | cp zlib.h zconf.h $(prefix)/include | ||
| 66 | chmod 644 $(prefix)/include/zlib.h $(prefix)/include/zconf.h | ||
| 67 | cp $(LIBS) $(exec_prefix)/lib | ||
| 68 | cd $(exec_prefix)/lib; chmod 644 $(LIBS) | ||
| 69 | -@(cd $(exec_prefix)/lib; $(RANLIB) libz.a || true) >/dev/null 2>&1 | ||
| 70 | cd $(exec_prefix)/lib; if test -f libz.so.$(VER); then \ | ||
| 71 | ln -s libz.so.$(VER) libz.so; \ | ||
| 72 | fi | ||
| 73 | # The ranlib in install is needed on NeXTSTEP which checks file times | ||
| 74 | |||
| 75 | uninstall: | ||
| 76 | cd $(exec_prefix)/lib; rm -f $(LIBS); \ | ||
| 77 | if test -f libz.so; then \ | ||
| 78 | v=`sed -n '/VERSION "/s/.*"\(.*\)".*/\1/p'<$(prefix)/include/zlib.h`;\ | ||
| 79 | rm -f libz.so.$$v libz.so; \ | ||
| 80 | fi | ||
| 81 | cd $(prefix)/include; rm -f zlib.h zconf.h | ||
| 82 | |||
| 48 | clean: | 83 | clean: |
| 49 | rm -f *.o example minigzip libz.a foo.gz | 84 | rm -f *.o *~ example minigzip libz.a libz.so* foo.gz |
| 50 | 85 | ||
| 51 | zip: | 86 | zip: |
| 52 | zip -ul9 zlib README ChangeLog Makefile Make????.??? Makefile.?? \ | 87 | mv Makefile Makefile~; cp -p Makefile.in Makefile |
| 53 | descrip.mms *.[ch] | 88 | v=`sed -n -e 's/\./-/g' -e '/VERSION "/s/.*"\(.*\)".*/\1/p' < zlib.h`;\ |
| 54 | 89 | zip -ul9 zlib-$$v $(DISTFILES) | |
| 55 | tgz: | 90 | mv Makefile~ Makefile |
| 56 | cd ..; tar cfz zlib/zlib.tgz zlib/README zlib/ChangeLog zlib/Makefile \ | 91 | |
| 57 | zlib/Make????.??? zlib/Makefile.?? zlib/descrip.mms zlib/*.[ch] | 92 | dist: |
| 58 | 93 | mv Makefile Makefile~; cp -p Makefile.in Makefile | |
| 59 | TAGS: | 94 | d=zlib-`sed -n '/VERSION "/s/.*"\(.*\)".*/\1/p' < zlib.h`;\ |
| 95 | rm -f $$d.tar.gz; \ | ||
| 96 | if test ! -d ../$$d; then rm -f ../$$d; ln -s `pwd` ../$$d; fi; \ | ||
| 97 | files=""; \ | ||
| 98 | for f in $(DISTFILES); do files="$$files $$d/$$f"; done; \ | ||
| 99 | cd ..; \ | ||
| 100 | GZIP=-9 $(TAR) chofz $$d/$$d.tar.gz $$files; \ | ||
| 101 | if test ! -d $$d; then rm -f $$d; fi | ||
| 102 | mv Makefile~ Makefile | ||
| 103 | |||
| 104 | tags: | ||
| 60 | etags *.[ch] | 105 | etags *.[ch] |
| 61 | 106 | ||
| 107 | depend: | ||
| 108 | makedepend -- $(CFLAGS) -- *.[ch] | ||
| 109 | |||
| 62 | # DO NOT DELETE THIS LINE -- make depend depends on it. | 110 | # DO NOT DELETE THIS LINE -- make depend depends on it. |
| 63 | 111 | ||
| 64 | adler32.o: zutil.h zlib.h zconf.h | 112 | adler32.o: zlib.h zconf.h |
| 65 | compress.o: zlib.h zconf.h | 113 | compress.o: zlib.h zconf.h |
| 66 | crc32.o: zutil.h zlib.h zconf.h | 114 | crc32.o: zlib.h zconf.h |
| 67 | deflate.o: deflate.h zutil.h zlib.h zconf.h | 115 | deflate.o: deflate.h zutil.h zlib.h zconf.h |
| 68 | example.o: zlib.h zconf.h | 116 | example.o: zlib.h zconf.h |
| 69 | gzio.o: zutil.h zlib.h zconf.h | 117 | gzio.o: zutil.h zlib.h zconf.h |
| 70 | infblock.o: zutil.h zlib.h zconf.h infblock.h inftrees.h infcodes.h infutil.h | 118 | infblock.o: infblock.h inftrees.h infcodes.h infutil.h zutil.h zlib.h zconf.h |
| 71 | infcodes.o: zutil.h zlib.h zconf.h inftrees.h infutil.h infcodes.h inffast.h | 119 | infcodes.o: zutil.h zlib.h zconf.h |
| 72 | inffast.o: zutil.h zlib.h zconf.h inftrees.h infutil.h inffast.h | 120 | infcodes.o: inftrees.h infblock.h infcodes.h infutil.h inffast.h |
| 121 | inffast.o: zutil.h zlib.h zconf.h inftrees.h | ||
| 122 | inffast.o: infblock.h infcodes.h infutil.h inffast.h | ||
| 73 | inflate.o: zutil.h zlib.h zconf.h infblock.h | 123 | inflate.o: zutil.h zlib.h zconf.h infblock.h |
| 74 | inftrees.o: zutil.h zlib.h zconf.h inftrees.h | 124 | inftrees.o: zutil.h zlib.h zconf.h inftrees.h |
| 75 | infutil.o: zutil.h zlib.h zconf.h inftrees.h infutil.h | 125 | infutil.o: zutil.h zlib.h zconf.h infblock.h inftrees.h infcodes.h infutil.h |
| 76 | minigzip.o: zlib.h zconf.h | 126 | minigzip.o: zlib.h zconf.h |
| 77 | trees.o: deflate.h zutil.h zlib.h zconf.h | 127 | trees.o: deflate.h zutil.h zlib.h zconf.h |
| 78 | uncompr.o: zlib.h zconf.h | 128 | uncompr.o: zlib.h zconf.h |
| 79 | zutil.o: zutil.h zlib.h zconf.h | 129 | zutil.o: zutil.h zlib.h zconf.h |
diff --git a/Makefile.b32 b/Makefile.b32 new file mode 100644 index 0000000..fc3ac68 --- /dev/null +++ b/Makefile.b32 | |||
| @@ -0,0 +1,104 @@ | |||
| 1 | # Makefile for zlib | ||
| 2 | # Borland C++ | ||
| 3 | |||
| 4 | # This version of the zlib makefile was adapted by Chris Young for use | ||
| 5 | # with Borland C 4.5x with the Dos Power Pack for a 32-bit protected mode | ||
| 6 | # flat memory model. It was created for use with POV-Ray ray tracer and | ||
| 7 | # you may choose to edit the CFLAGS to suit your needs but the | ||
| 8 | # switches -WX and -DMSDOS are required. | ||
| 9 | # -- Chris Young 76702.1655@compuserve.com | ||
| 10 | |||
| 11 | # To use, do "make -fmakefile.b32" | ||
| 12 | |||
| 13 | # See zconf.h for details about the memory requirements. | ||
| 14 | |||
| 15 | # ------------- Borland C++ ------------- | ||
| 16 | MODEL=-WX | ||
| 17 | CFLAGS= $(MODEL) -P-C -K -N- -k- -d -3 -r- -v- -f -DMSDOS | ||
| 18 | CC=bcc32 | ||
| 19 | LD=bcc32 | ||
| 20 | LIB=tlib | ||
| 21 | LDFLAGS= $(MODEL) | ||
| 22 | O=.obj | ||
| 23 | |||
| 24 | # variables | ||
| 25 | OBJ1 = adler32$(O) compress$(O) crc32$(O) gzio$(O) uncompr$(O) deflate$(O) \ | ||
| 26 | trees$(O) | ||
| 27 | OBJP1 = adler32$(O)+compress$(O)+crc32$(O)+gzio$(O)+uncompr$(O)+deflate$(O)+\ | ||
| 28 | trees$(O) | ||
| 29 | OBJ2 = zutil$(O) inflate$(O) infblock$(O) inftrees$(O) infcodes$(O) \ | ||
| 30 | infutil$(O) inffast$(O) | ||
| 31 | OBJP2 = zutil$(O)+inflate$(O)+infblock$(O)+inftrees$(O)+infcodes$(O)+\ | ||
| 32 | infutil$(O)+inffast$(O) | ||
| 33 | |||
| 34 | all: test | ||
| 35 | |||
| 36 | adler32.obj: adler32.c zutil.h zlib.h zconf.h | ||
| 37 | $(CC) -c $(CFLAGS) $*.c | ||
| 38 | |||
| 39 | compress.obj: compress.c zlib.h zconf.h | ||
| 40 | $(CC) -c $(CFLAGS) $*.c | ||
| 41 | |||
| 42 | crc32.obj: crc32.c zutil.h zlib.h zconf.h | ||
| 43 | $(CC) -c $(CFLAGS) $*.c | ||
| 44 | |||
| 45 | deflate.obj: deflate.c deflate.h zutil.h zlib.h zconf.h | ||
| 46 | $(CC) -c $(CFLAGS) $*.c | ||
| 47 | |||
| 48 | gzio.obj: gzio.c zutil.h zlib.h zconf.h | ||
| 49 | $(CC) -c $(CFLAGS) $*.c | ||
| 50 | |||
| 51 | infblock.obj: infblock.c zutil.h zlib.h zconf.h infblock.h inftrees.h\ | ||
| 52 | infcodes.h infutil.h | ||
| 53 | $(CC) -c $(CFLAGS) $*.c | ||
| 54 | |||
| 55 | infcodes.obj: infcodes.c zutil.h zlib.h zconf.h inftrees.h infutil.h\ | ||
| 56 | infcodes.h inffast.h | ||
| 57 | $(CC) -c $(CFLAGS) $*.c | ||
| 58 | |||
| 59 | inflate.obj: inflate.c zutil.h zlib.h zconf.h infblock.h | ||
| 60 | $(CC) -c $(CFLAGS) $*.c | ||
| 61 | |||
| 62 | inftrees.obj: inftrees.c zutil.h zlib.h zconf.h inftrees.h | ||
| 63 | $(CC) -c $(CFLAGS) $*.c | ||
| 64 | |||
| 65 | infutil.obj: infutil.c zutil.h zlib.h zconf.h inftrees.h infutil.h | ||
| 66 | $(CC) -c $(CFLAGS) $*.c | ||
| 67 | |||
| 68 | inffast.obj: inffast.c zutil.h zlib.h zconf.h inftrees.h infutil.h inffast.h | ||
| 69 | $(CC) -c $(CFLAGS) $*.c | ||
| 70 | |||
| 71 | trees.obj: trees.c deflate.h zutil.h zlib.h zconf.h | ||
| 72 | $(CC) -c $(CFLAGS) $*.c | ||
| 73 | |||
| 74 | uncompr.obj: uncompr.c zlib.h zconf.h | ||
| 75 | $(CC) -c $(CFLAGS) $*.c | ||
| 76 | |||
| 77 | zutil.obj: zutil.c zutil.h zlib.h zconf.h | ||
| 78 | $(CC) -c $(CFLAGS) $*.c | ||
| 79 | |||
| 80 | example.obj: example.c zlib.h zconf.h | ||
| 81 | $(CC) -c $(CFLAGS) $*.c | ||
| 82 | |||
| 83 | minigzip.obj: minigzip.c zlib.h zconf.h | ||
| 84 | $(CC) -c $(CFLAGS) $*.c | ||
| 85 | |||
| 86 | # we must cut the command line to fit in the MS/DOS 128 byte limit: | ||
| 87 | zlib.lib: $(OBJ1) $(OBJ2) | ||
| 88 | del zlib.lib | ||
| 89 | $(LIB) zlib +$(OBJP1) | ||
| 90 | $(LIB) zlib +$(OBJP2) | ||
| 91 | |||
| 92 | example.exe: example.obj zlib.lib | ||
| 93 | $(LD) $(LDFLAGS) example.obj zlib.lib | ||
| 94 | |||
| 95 | minigzip.exe: minigzip.obj zlib.lib | ||
| 96 | $(LD) $(LDFLAGS) minigzip.obj zlib.lib | ||
| 97 | |||
| 98 | test: example.exe minigzip.exe | ||
| 99 | example | ||
| 100 | echo hello world | minigzip | minigzip -d | ||
| 101 | |||
| 102 | #clean: | ||
| 103 | # del *.obj | ||
| 104 | # del *.exe | ||
diff --git a/Makefile.bor b/Makefile.bor index 536b76d..2116563 100644 --- a/Makefile.bor +++ b/Makefile.bor | |||
| @@ -18,7 +18,7 @@ CFLAGS=-O2 -Z $(MODEL) | |||
| 18 | CC=bcc | 18 | CC=bcc |
| 19 | LD=bcc | 19 | LD=bcc |
| 20 | LIB=tlib | 20 | LIB=tlib |
| 21 | # replace bcc with tcc for Turbo C++ 1.0 | 21 | # replace bcc with tcc for Turbo C++ 1.0, with bcc32 for the 32 bit version |
| 22 | LDFLAGS=$(MODEL) | 22 | LDFLAGS=$(MODEL) |
| 23 | O=.obj | 23 | O=.obj |
| 24 | 24 | ||
diff --git a/Makefile.dj2 b/Makefile.dj2 new file mode 100644 index 0000000..82f55ea --- /dev/null +++ b/Makefile.dj2 | |||
| @@ -0,0 +1,79 @@ | |||
| 1 | # Makefile for zlib. Modified for djgpp v2.0 by F. J. Donahoe, 3/15/96. | ||
| 2 | # Copyright (C) 1995-1996 Jean-loup Gailly. | ||
| 3 | # For conditions of distribution and use, see copyright notice in zlib.h | ||
| 4 | |||
| 5 | # To compile and test, type: | ||
| 6 | # make -fmakefile.dj2; make test -fmakefile.dj2 | ||
| 7 | |||
| 8 | # To install libz.a, zconf.h and zlib.h in the djgpp directories, type: | ||
| 9 | # make install -fmakefile.dj2 | ||
| 10 | # after first defining LIBRARY_PATH and INCLUDE_PATH in djgpp.env for [make]. | ||
| 11 | # Alternately these variables may be defined below. | ||
| 12 | |||
| 13 | CC=gcc | ||
| 14 | |||
| 15 | #CFLAGS=-MMD -O | ||
| 16 | #CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7 | ||
| 17 | #CFLAGS=-MMD -g -DDEBUG | ||
| 18 | CFLAGS=-MMD -O3 -Wall -Wwrite-strings -Wpointer-arith -Wconversion \ | ||
| 19 | -Wstrict-prototypes -Wmissing-prototypes | ||
| 20 | INSTALL=install | ||
| 21 | LDLIBS=-L. -lz | ||
| 22 | LD=$(CC) -s -o | ||
| 23 | LDSHARED=$(CC) | ||
| 24 | |||
| 25 | VER=1.0 | ||
| 26 | LIBS=libz.a | ||
| 27 | |||
| 28 | AR=ar rcs | ||
| 29 | # The default value of RM is "rm -f." If "rm.exe" is not found, uncomment: | ||
| 30 | # RM=del | ||
| 31 | |||
| 32 | prefix=/usr/local | ||
| 33 | exec_prefix = $(prefix) | ||
| 34 | |||
| 35 | OBJS = adler32.o compress.o crc32.o gzio.o uncompr.o deflate.o trees.o \ | ||
| 36 | zutil.o inflate.o infblock.o inftrees.o infcodes.o infutil.o inffast.o | ||
| 37 | |||
| 38 | TEST_OBJS = example.o minigzip.o | ||
| 39 | |||
| 40 | DISTFILES = README Change.Log configur Makefile.in Makefile Makefile.msc \ | ||
| 41 | Makefile.bor Makefile.tc Make_vms.com descrip.mms zlib099.pat \ | ||
| 42 | *.bak *.old *.[ch] | ||
| 43 | |||
| 44 | all: example.exe minigzip.exe | ||
| 45 | |||
| 46 | test: all | ||
| 47 | ./example | ||
| 48 | echo hello world | .\minigzip | .\minigzip -d | ||
| 49 | |||
| 50 | %.o : %.c | ||
| 51 | $(CC) $(CFLAGS) -c $< -o $@ | ||
| 52 | |||
| 53 | libz.a: $(OBJS) | ||
| 54 | $(AR) $@ $(OBJS) | ||
| 55 | |||
| 56 | libz.so.$(VER): $(OBJS) | ||
| 57 | $(LDSHARED) -o $@ $(OBJS) | ||
| 58 | rm -f libz.so; ln -s $@ libz.so | ||
| 59 | |||
| 60 | %.exe : %.o $(LIBS) | ||
| 61 | $(LD) $@ $< $(LDLIBS) | ||
| 62 | |||
| 63 | # INCLUDE_PATH and LIBRARY_PATH were set for [make] in djgpp.env | ||
| 64 | |||
| 65 | install: $(LIBS) | ||
| 66 | $(INSTALL) zlib.h zconf.h $(INCLUDE_PATH) | ||
| 67 | $(INSTALL) $(LIBS) $(LIBRARY_PATH) | ||
| 68 | |||
| 69 | uninstall: | ||
| 70 | $(RM) $(LIBRARY_PATH)/$(LIBS) | ||
| 71 | $(RM) $(INCLUDE_PATH)/zlib.h $(INCLUDE_PATH)/zconf.h | ||
| 72 | |||
| 73 | clean: | ||
| 74 | $(RM) *.d *.o *.~ *.exe libz.a libz.so* foo.gz | ||
| 75 | |||
| 76 | DEPS := $(wildcard *.d) | ||
| 77 | ifneq ($(DEPS),) | ||
| 78 | include $(DEPS) | ||
| 79 | endif | ||
diff --git a/Makefile.in b/Makefile.in new file mode 100644 index 0000000..3b41059 --- /dev/null +++ b/Makefile.in | |||
| @@ -0,0 +1,129 @@ | |||
| 1 | # Makefile for zlib | ||
| 2 | # Copyright (C) 1995-1996 Jean-loup Gailly. | ||
| 3 | # For conditions of distribution and use, see copyright notice in zlib.h | ||
| 4 | |||
| 5 | # To compile and test, type: | ||
| 6 | # ./configure; make test | ||
| 7 | # The call of configure is optional if you don't have special requirements | ||
| 8 | |||
| 9 | # To install /usr/local/lib/libz.* and /usr/local/include/zlib.h, type: | ||
| 10 | # make install | ||
| 11 | # To install in $HOME instead of /usr/local, use: | ||
| 12 | # make install prefix=$HOME | ||
| 13 | |||
| 14 | CC=cc | ||
| 15 | |||
| 16 | CFLAGS=-O | ||
| 17 | #CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7 | ||
| 18 | #CFLAGS=-g -DDEBUG | ||
| 19 | #CFLAGS=-O3 -Wall -Wwrite-strings -Wpointer-arith -Wconversion \ | ||
| 20 | # -Wstrict-prototypes -Wmissing-prototypes | ||
| 21 | |||
| 22 | LDFLAGS=-L. -lz | ||
| 23 | LDSHARED=$(CC) | ||
| 24 | |||
| 25 | VER=1.0.1 | ||
| 26 | LIBS=libz.a | ||
| 27 | |||
| 28 | AR=ar rc | ||
| 29 | RANLIB=ranlib | ||
| 30 | TAR=tar | ||
| 31 | |||
| 32 | prefix=/usr/local | ||
| 33 | exec_prefix = $(prefix) | ||
| 34 | |||
| 35 | OBJS = adler32.o compress.o crc32.o gzio.o uncompr.o deflate.o trees.o \ | ||
| 36 | zutil.o inflate.o infblock.o inftrees.o infcodes.o infutil.o inffast.o | ||
| 37 | |||
| 38 | TEST_OBJS = example.o minigzip.o | ||
| 39 | |||
| 40 | DISTFILES = README INDEX ChangeLog configure Make*[a-z0-9] descrip.mms *.[ch] | ||
| 41 | |||
| 42 | all: example minigzip | ||
| 43 | |||
| 44 | test: all | ||
| 45 | ./example | ||
| 46 | echo hello world | ./minigzip | ./minigzip -d | ||
| 47 | |||
| 48 | libz.a: $(OBJS) | ||
| 49 | $(AR) $@ $(OBJS) | ||
| 50 | -@ ($(RANLIB) $@ || true) 2>/dev/null | ||
| 51 | |||
| 52 | libz.so.$(VER): $(OBJS) | ||
| 53 | $(LDSHARED) -o $@ $(OBJS) | ||
| 54 | rm -f libz.so; ln -s $@ libz.so | ||
| 55 | |||
| 56 | example: example.o $(LIBS) | ||
| 57 | $(CC) $(CFLAGS) -o $@ example.o $(LDFLAGS) | ||
| 58 | |||
| 59 | minigzip: minigzip.o $(LIBS) | ||
| 60 | $(CC) $(CFLAGS) -o $@ minigzip.o $(LDFLAGS) | ||
| 61 | |||
| 62 | install: $(LIBS) | ||
| 63 | -@if [ ! $(prefix)/include ]; then mkdir $(prefix)/include; fi | ||
| 64 | -@if [ ! $(exec_prefix)/lib ]; then mkdir $(exec_prefix)/lib; fi | ||
| 65 | cp zlib.h zconf.h $(prefix)/include | ||
| 66 | chmod 644 $(prefix)/include/zlib.h $(prefix)/include/zconf.h | ||
| 67 | cp $(LIBS) $(exec_prefix)/lib | ||
| 68 | cd $(exec_prefix)/lib; chmod 644 $(LIBS) | ||
| 69 | -@(cd $(exec_prefix)/lib; $(RANLIB) libz.a || true) >/dev/null 2>&1 | ||
| 70 | cd $(exec_prefix)/lib; if test -f libz.so.$(VER); then \ | ||
| 71 | ln -s libz.so.$(VER) libz.so; \ | ||
| 72 | fi | ||
| 73 | # The ranlib in install is needed on NeXTSTEP which checks file times | ||
| 74 | |||
| 75 | uninstall: | ||
| 76 | cd $(exec_prefix)/lib; rm -f $(LIBS); \ | ||
| 77 | if test -f libz.so; then \ | ||
| 78 | v=`sed -n '/VERSION "/s/.*"\(.*\)".*/\1/p'<$(prefix)/include/zlib.h`;\ | ||
| 79 | rm -f libz.so.$$v libz.so; \ | ||
| 80 | fi | ||
| 81 | cd $(prefix)/include; rm -f zlib.h zconf.h | ||
| 82 | |||
| 83 | clean: | ||
| 84 | rm -f *.o *~ example minigzip libz.a libz.so* foo.gz | ||
| 85 | |||
| 86 | zip: | ||
| 87 | mv Makefile Makefile~; cp -p Makefile.in Makefile | ||
| 88 | v=`sed -n -e 's/\./-/g' -e '/VERSION "/s/.*"\(.*\)".*/\1/p' < zlib.h`;\ | ||
| 89 | zip -ul9 zlib-$$v $(DISTFILES) | ||
| 90 | mv Makefile~ Makefile | ||
| 91 | |||
| 92 | dist: | ||
| 93 | mv Makefile Makefile~; cp -p Makefile.in Makefile | ||
| 94 | d=zlib-`sed -n '/VERSION "/s/.*"\(.*\)".*/\1/p' < zlib.h`;\ | ||
| 95 | rm -f $$d.tar.gz; \ | ||
| 96 | if test ! -d ../$$d; then rm -f ../$$d; ln -s `pwd` ../$$d; fi; \ | ||
| 97 | files=""; \ | ||
| 98 | for f in $(DISTFILES); do files="$$files $$d/$$f"; done; \ | ||
| 99 | cd ..; \ | ||
| 100 | GZIP=-9 $(TAR) chofz $$d/$$d.tar.gz $$files; \ | ||
| 101 | if test ! -d $$d; then rm -f $$d; fi | ||
| 102 | mv Makefile~ Makefile | ||
| 103 | |||
| 104 | tags: | ||
| 105 | etags *.[ch] | ||
| 106 | |||
| 107 | depend: | ||
| 108 | makedepend -- $(CFLAGS) -- *.[ch] | ||
| 109 | |||
| 110 | # DO NOT DELETE THIS LINE -- make depend depends on it. | ||
| 111 | |||
| 112 | adler32.o: zlib.h zconf.h | ||
| 113 | compress.o: zlib.h zconf.h | ||
| 114 | crc32.o: zlib.h zconf.h | ||
| 115 | deflate.o: deflate.h zutil.h zlib.h zconf.h | ||
| 116 | example.o: zlib.h zconf.h | ||
| 117 | gzio.o: zutil.h zlib.h zconf.h | ||
| 118 | infblock.o: infblock.h inftrees.h infcodes.h infutil.h zutil.h zlib.h zconf.h | ||
| 119 | infcodes.o: zutil.h zlib.h zconf.h | ||
| 120 | infcodes.o: inftrees.h infblock.h infcodes.h infutil.h inffast.h | ||
| 121 | inffast.o: zutil.h zlib.h zconf.h inftrees.h | ||
| 122 | inffast.o: infblock.h infcodes.h infutil.h inffast.h | ||
| 123 | inflate.o: zutil.h zlib.h zconf.h infblock.h | ||
| 124 | inftrees.o: zutil.h zlib.h zconf.h inftrees.h | ||
| 125 | infutil.o: zutil.h zlib.h zconf.h infblock.h inftrees.h infcodes.h infutil.h | ||
| 126 | minigzip.o: zlib.h zconf.h | ||
| 127 | trees.o: deflate.h zutil.h zlib.h zconf.h | ||
| 128 | uncompr.o: zlib.h zconf.h | ||
| 129 | zutil.o: zutil.h zlib.h zconf.h | ||
diff --git a/Makefile.qnx b/Makefile.qnx deleted file mode 100644 index 22b1a23..0000000 --- a/Makefile.qnx +++ /dev/null | |||
| @@ -1,75 +0,0 @@ | |||
| 1 | # Makefile for zlib | ||
| 2 | # Copyright (C) 1995 Jean-loup Gailly. | ||
| 3 | # For conditions of distribution and use, see copyright notice in zlib.h | ||
| 4 | |||
| 5 | # Modified slightly for QNX by Chris Herborth (chrish@qnx.com) | ||
| 6 | |||
| 7 | CC=cc | ||
| 8 | CFLAGS=-4 -O -Q | ||
| 9 | #use -O3 for gcc to take advantage of inlining | ||
| 10 | #CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" | ||
| 11 | #CFLAGS=-g -DDEBUG | ||
| 12 | LDFLAGS=-L. -lz | ||
| 13 | |||
| 14 | #RANLIB=ranlib | ||
| 15 | |||
| 16 | prefix=/usr/local | ||
| 17 | |||
| 18 | OBJS = adler32.o compress.o crc32.o gzio.o uncompr.o deflate.o trees.o \ | ||
| 19 | zutil.o inflate.o infblock.o inftrees.o infcodes.o infutil.o inffast.o | ||
| 20 | |||
| 21 | TEST_OBJS = example.o minigzip.o | ||
| 22 | |||
| 23 | all: example minigzip | ||
| 24 | |||
| 25 | test: all | ||
| 26 | ./example | ||
| 27 | echo hello world | ./minigzip | ./minigzip -d | ||
| 28 | |||
| 29 | install: zlib.lib | ||
| 30 | -@mkdir $(prefix)/include | ||
| 31 | -@mkdir $(prefix)/lib | ||
| 32 | cp zlib.h zconf.h $(prefix)/include | ||
| 33 | chmod 644 $(prefix)/include/zlib.h $(prefix)/include/zconf.h | ||
| 34 | cp zlib.lib $(prefix)/lib | ||
| 35 | chmod 644 $(prefix)/lib/zlib.lib | ||
| 36 | |||
| 37 | zlib.lib: $(OBJS) | ||
| 38 | cc -A $@ $(OBJS) | ||
| 39 | # ar rc $@ $(OBJS) | ||
| 40 | # $(RANLIB) $@ | ||
| 41 | |||
| 42 | example: example.o zlib.lib | ||
| 43 | $(CC) $(CFLAGS) -o $@ example.o $(LDFLAGS) | ||
| 44 | |||
| 45 | minigzip: minigzip.o zlib.lib | ||
| 46 | $(CC) $(CFLAGS) -o $@ minigzip.o $(LDFLAGS) | ||
| 47 | |||
| 48 | clean: | ||
| 49 | rm -f *.o example minigzip zlib.lib foo.gz | ||
| 50 | |||
| 51 | zip: | ||
| 52 | zip -ul9 zlib README ChangeLog Makefile Makefile.??? Makefile.?? *.[ch] | ||
| 53 | |||
| 54 | tgz: | ||
| 55 | cd ..; tar cfz zlib/zlib.tgz zlib/README zlib/ChangeLog zlib/Makefile \ | ||
| 56 | zlib/Makefile.??? zlib/Makefile.?? zlib/*.[ch] | ||
| 57 | |||
| 58 | # DO NOT DELETE THIS LINE -- make depend depends on it. | ||
| 59 | |||
| 60 | adler32.o: zutil.h zlib.h zconf.h | ||
| 61 | compress.o: zlib.h zconf.h | ||
| 62 | crc32.o: zutil.h zlib.h zconf.h | ||
| 63 | deflate.o: deflate.h zutil.h zlib.h zconf.h | ||
| 64 | example.o: zlib.h zconf.h | ||
| 65 | gzio.o: zutil.h zlib.h zconf.h | ||
| 66 | infblock.o: zutil.h zlib.h zconf.h infblock.h inftrees.h infcodes.h infutil.h | ||
| 67 | infcodes.o: zutil.h zlib.h zconf.h inftrees.h infutil.h infcodes.h inffast.h | ||
| 68 | inffast.o: zutil.h zlib.h zconf.h inftrees.h infutil.h inffast.h | ||
| 69 | inflate.o: zutil.h zlib.h zconf.h infblock.h | ||
| 70 | inftrees.o: zutil.h zlib.h zconf.h inftrees.h | ||
| 71 | infutil.o: zutil.h zlib.h zconf.h inftrees.h infutil.h | ||
| 72 | minigzip.o: zlib.h zconf.h | ||
| 73 | trees.o: deflate.h zutil.h zlib.h zconf.h | ||
| 74 | uncompr.o: zlib.h zconf.h | ||
| 75 | zutil.o: zutil.h zlib.h zconf.h | ||
diff --git a/Makefile.sas b/Makefile.sas new file mode 100644 index 0000000..5323e82 --- /dev/null +++ b/Makefile.sas | |||
| @@ -0,0 +1,64 @@ | |||
| 1 | # SMakefile for zlib | ||
| 2 | # Modified from the standard UNIX Makefile Copyright Jean-loup Gailly | ||
| 3 | # Osma Ahvenlampi <Osma.Ahvenlampi@hut.fi> | ||
| 4 | # Amiga, SAS/C 6.56 & Smake | ||
| 5 | |||
| 6 | CC=sc | ||
| 7 | CFLAGS=OPT | ||
| 8 | #CFLAGS=OPT CPU=68030 | ||
| 9 | #CFLAGS=DEBUG=LINE | ||
| 10 | LDFLAGS=LIB z.lib | ||
| 11 | |||
| 12 | SCOPTIONS=OPTSCHED OPTINLINE OPTALIAS OPTTIME OPTINLOCAL STRMERGE \ | ||
| 13 | NOICONS PARMS=BOTH NOSTACKCHECK UTILLIB NOVERSION ERRORREXX | ||
| 14 | |||
| 15 | OBJS = adler32.o compress.o crc32.o gzio.o uncompr.o deflate.o trees.o \ | ||
| 16 | zutil.o inflate.o infblock.o inftrees.o infcodes.o infutil.o inffast.o | ||
| 17 | |||
| 18 | TEST_OBJS = example.o minigzip.o | ||
| 19 | |||
| 20 | all: SCOPTIONS example minigzip | ||
| 21 | |||
| 22 | test: all | ||
| 23 | `cd`/example | ||
| 24 | echo hello world | minigzip | minigzip -d | ||
| 25 | |||
| 26 | install: z.lib | ||
| 27 | copy zlib.h zconf.h INCLUDE: clone | ||
| 28 | copy z.lib LIB: clone | ||
| 29 | |||
| 30 | z.lib: $(OBJS) | ||
| 31 | oml z.lib r $(OBJS) | ||
| 32 | |||
| 33 | example: example.o z.lib | ||
| 34 | $(CC) $(CFLAGS) LINK TO $@ example.o $(LDFLAGS) | ||
| 35 | |||
| 36 | minigzip: minigzip.o z.lib | ||
| 37 | $(CC) $(CFLAGS) LINK TO $@ minigzip.o $(LDFLAGS) | ||
| 38 | |||
| 39 | clean: | ||
| 40 | -delete force quiet *.o example minigzip z.lib foo.gz *.lnk SCOPTIONS | ||
| 41 | |||
| 42 | SCOPTIONS: Smakefile | ||
| 43 | copy to $@ <from < | ||
| 44 | $(SCOPTIONS) | ||
| 45 | < | ||
| 46 | |||
| 47 | # DO NOT DELETE THIS LINE -- make depend depends on it. | ||
| 48 | |||
| 49 | adler32.o: zutil.h zlib.h zconf.h | ||
| 50 | compress.o: zlib.h zconf.h | ||
| 51 | crc32.o: zutil.h zlib.h zconf.h | ||
| 52 | deflate.o: deflate.h zutil.h zlib.h zconf.h | ||
| 53 | example.o: zlib.h zconf.h | ||
| 54 | gzio.o: zutil.h zlib.h zconf.h | ||
| 55 | infblock.o: zutil.h zlib.h zconf.h infblock.h inftrees.h infcodes.h infutil.h | ||
| 56 | infcodes.o: zutil.h zlib.h zconf.h inftrees.h infutil.h infcodes.h inffast.h | ||
| 57 | inffast.o: zutil.h zlib.h zconf.h inftrees.h infutil.h inffast.h | ||
| 58 | inflate.o: zutil.h zlib.h zconf.h infblock.h | ||
| 59 | inftrees.o: zutil.h zlib.h zconf.h inftrees.h | ||
| 60 | infutil.o: zutil.h zlib.h zconf.h inftrees.h infutil.h | ||
| 61 | minigzip.o: zlib.h zconf.h | ||
| 62 | trees.o: deflate.h zutil.h zlib.h zconf.h | ||
| 63 | uncompr.o: zlib.h zconf.h | ||
| 64 | zutil.o: zutil.h zlib.h zconf.h | ||
diff --git a/Makefile.wat b/Makefile.wat new file mode 100644 index 0000000..2a3b629 --- /dev/null +++ b/Makefile.wat | |||
| @@ -0,0 +1,103 @@ | |||
| 1 | # Makefile for zlib | ||
| 2 | # Watcom 10a | ||
| 3 | |||
| 4 | # This version of the zlib makefile was adapted by Chris Young for use | ||
| 5 | # with Watcom 10a 32-bit protected mode flat memory model. It was created | ||
| 6 | # for use with POV-Ray ray tracer and you may choose to edit the CFLAGS to | ||
| 7 | # suit your needs but the -DMSDOS is required. | ||
| 8 | # -- Chris Young 76702.1655@compuserve.com | ||
| 9 | |||
| 10 | # To use, do "wmake -f makefile.wat" | ||
| 11 | |||
| 12 | # See zconf.h for details about the memory requirements. | ||
| 13 | |||
| 14 | # ------------- Watcom 10a ------------- | ||
| 15 | MODEL=-mf | ||
| 16 | CFLAGS= $(MODEL) -fpi87 -fp5 -zp4 -5r -w5 -oneatx -DMSDOS | ||
| 17 | CC=wcc386 | ||
| 18 | LD=wcl386 | ||
| 19 | LIB=wlib -b -c | ||
| 20 | LDFLAGS= | ||
| 21 | O=.obj | ||
| 22 | |||
| 23 | # variables | ||
| 24 | OBJ1=adler32$(O) compress$(O) crc32$(O) gzio$(O) uncompr$(O) deflate$(O) | ||
| 25 | OBJ2=trees$(O) zutil$(O) inflate$(O) infblock$(O) inftrees$(O) infcodes$(O) | ||
| 26 | OBJ3=infutil$(O) inffast$(O) | ||
| 27 | OBJP1=adler32$(O)+compress$(O)+crc32$(O)+gzio$(O)+uncompr$(O)+deflate$(O) | ||
| 28 | OBJP2=trees$(O)+zutil$(O)+inflate$(O)+infblock$(O)+inftrees$(O)+infcodes$(O) | ||
| 29 | OBJP3=infutil$(O)+inffast$(O) | ||
| 30 | |||
| 31 | all: test | ||
| 32 | |||
| 33 | adler32.obj: adler32.c zutil.h zlib.h zconf.h | ||
| 34 | $(CC) $(CFLAGS) $*.c | ||
| 35 | |||
| 36 | compress.obj: compress.c zlib.h zconf.h | ||
| 37 | $(CC) $(CFLAGS) $*.c | ||
| 38 | |||
| 39 | crc32.obj: crc32.c zutil.h zlib.h zconf.h | ||
| 40 | $(CC) $(CFLAGS) $*.c | ||
| 41 | |||
| 42 | deflate.obj: deflate.c deflate.h zutil.h zlib.h zconf.h | ||
| 43 | $(CC) $(CFLAGS) $*.c | ||
| 44 | |||
| 45 | gzio.obj: gzio.c zutil.h zlib.h zconf.h | ||
| 46 | $(CC) $(CFLAGS) $*.c | ||
| 47 | |||
| 48 | infblock.obj: infblock.c zutil.h zlib.h zconf.h infblock.h inftrees.h & | ||
| 49 | infcodes.h infutil.h | ||
| 50 | $(CC) $(CFLAGS) $*.c | ||
| 51 | |||
| 52 | infcodes.obj: infcodes.c zutil.h zlib.h zconf.h inftrees.h infutil.h & | ||
| 53 | infcodes.h inffast.h | ||
| 54 | $(CC) $(CFLAGS) $*.c | ||
| 55 | |||
| 56 | inflate.obj: inflate.c zutil.h zlib.h zconf.h infblock.h | ||
| 57 | $(CC) $(CFLAGS) $*.c | ||
| 58 | |||
| 59 | inftrees.obj: inftrees.c zutil.h zlib.h zconf.h inftrees.h | ||
| 60 | $(CC) $(CFLAGS) $*.c | ||
| 61 | |||
| 62 | infutil.obj: infutil.c zutil.h zlib.h zconf.h inftrees.h infutil.h | ||
| 63 | $(CC) $(CFLAGS) $*.c | ||
| 64 | |||
| 65 | inffast.obj: inffast.c zutil.h zlib.h zconf.h inftrees.h infutil.h inffast.h | ||
| 66 | $(CC) $(CFLAGS) $*.c | ||
| 67 | |||
| 68 | trees.obj: trees.c deflate.h zutil.h zlib.h zconf.h | ||
| 69 | $(CC) $(CFLAGS) $*.c | ||
| 70 | |||
| 71 | uncompr.obj: uncompr.c zlib.h zconf.h | ||
| 72 | $(CC) $(CFLAGS) $*.c | ||
| 73 | |||
| 74 | zutil.obj: zutil.c zutil.h zlib.h zconf.h | ||
| 75 | $(CC) $(CFLAGS) $*.c | ||
| 76 | |||
| 77 | example.obj: example.c zlib.h zconf.h | ||
| 78 | $(CC) $(CFLAGS) $*.c | ||
| 79 | |||
| 80 | minigzip.obj: minigzip.c zlib.h zconf.h | ||
| 81 | $(CC) $(CFLAGS) $*.c | ||
| 82 | |||
| 83 | # we must cut the command line to fit in the MS/DOS 128 byte limit: | ||
| 84 | zlib.lib: $(OBJ1) $(OBJ2) $(OBJ3) | ||
| 85 | del zlib.lib | ||
| 86 | $(LIB) zlib.lib +$(OBJP1) | ||
| 87 | $(LIB) zlib.lib +$(OBJP2) | ||
| 88 | $(LIB) zlib.lib +$(OBJP3) | ||
| 89 | |||
| 90 | example.exe: example.obj zlib.lib | ||
| 91 | $(LD) $(LDFLAGS) example.obj zlib.lib | ||
| 92 | |||
| 93 | minigzip.exe: minigzip.obj zlib.lib | ||
| 94 | $(LD) $(LDFLAGS) minigzip.obj zlib.lib | ||
| 95 | |||
| 96 | test: minigzip.exe example.exe | ||
| 97 | example | ||
| 98 | echo hello world | minigzip | minigzip -d >test | ||
| 99 | type test | ||
| 100 | |||
| 101 | #clean: | ||
| 102 | # del *.obj | ||
| 103 | # del *.exe | ||
| @@ -1,55 +1,62 @@ | |||
| 1 | zlib 1.0 is a general purpose data compression library. | 1 | zlib 1.0.1 is a general purpose data compression library. All the code |
| 2 | All the code is reentrant (thread safe). | 2 | is reentrant (thread safe). The data format used by the zlib library |
| 3 | 3 | is described in the files zlib-3.3.doc, deflate-1.3.doc and | |
| 4 | The data format used by the zlib library is described in the | 4 | gzip-4.3.doc, available in various formats from |
| 5 | files zlib-3.2.doc, deflate-1.2.doc and gzip-4.2.doc, available | 5 | ftp://swrinde.nde.swri.edu/pub/png/documents/zlib/ |
| 6 | in ftp://ftp.uu.net/pub/archiving/zip/doc | ||
| 7 | 6 | ||
| 8 | All functions of the compression library are documented in the file | 7 | All functions of the compression library are documented in the file |
| 9 | zlib.h. A usage example of the library is given in the file example.c | 8 | zlib.h. A usage example of the library is given in the file example.c |
| 10 | which also tests that the library is working correctly. Another | 9 | which also tests that the library is working correctly. Another |
| 11 | example is given in the file minigzip.c. | 10 | example is given in the file minigzip.c. The compression library itself |
| 12 | 11 | is composed of all source files except example.c and minigzip.c. | |
| 13 | To compile all files and run the test program, just type: make test | 12 | |
| 14 | (For MSDOS, use one of the special makefiles such as Makefile.msc; | 13 | To compile all files and run the test program, follow the instructions |
| 15 | for VMS, use Make_vms.com or descrip.mms.) | 14 | given at the top of Makefile. In short "make test; make install" |
| 16 | To install the zlib library (libz.a) in /usr/local/lib, type: make install | 15 | should work for most machines. For MSDOS, use one of the special |
| 17 | To install in a different directory, use for example: | 16 | makefiles such as Makefile.msc; for VMS, use Make_vms.com or descrip.mms. |
| 18 | make install prefix=$HOME | 17 | |
| 19 | This will install in $HOME/lib instead of /usr/local/lib. | 18 | Questions about zlib should be sent to <zlib@quest.jpl.nasa.gov> or, |
| 20 | 19 | if this fails, to the addresses given below in the Copyright section. | |
| 21 | Questions about zlib should be sent to <zlib@quest.jpl.nasa.gov>. | 20 | |
| 22 | 21 | The changes made in version 1.0.1 are documented in the file ChangeLog. | |
| 23 | The changes made in version 1.0 are documented in the file ChangeLog. | 22 | Version number 1.0 was skipped to avoid confusion with version 0.99 |
| 24 | The main changes since 0.95 are: | 23 | which had some references to 1.0 already. The main changes since 0.99 are: |
| 25 | - allow compression level 0 (no compression) | 24 | |
| 26 | - add deflateParams in zlib.h: allow dynamic change of compression level | 25 | - fix array overlay in deflate.c which sometimes caused bad compressed data |
| 27 | and compression strategy. | 26 | - fix inflate bug with empty stored block |
| 28 | - test large buffers and deflateParams in example.c | 27 | - fix MSDOS medium model which was broken in 0.99 |
| 29 | - declare Z_DEFLATED in zlib.h (possible parameter for deflateInit2) | 28 | - fix deflateParams() which could generated bad compressed data. |
| 30 | - fixes for 64-bit systems (needed for Alpha and Cray) | 29 | - added an INDEX file |
| 31 | - always return Z_BUF_ERROR when deflate() has nothing to do | 30 | - new makefiles for DJGPP (Makefile.dj2), 32-bit Borland (Makefile.b32), |
| 32 | - fix some very unlikely race conditions. | 31 | Watcom (Makefile.wat), Amiga SAS/C (Makefile.sas) |
| 33 | - several minor fixes for better portability | 32 | - several portability improvements |
| 34 | - free in reverse order of allocation to help memory manager | ||
| 35 | 33 | ||
| 36 | Notes for some targets: | 34 | Notes for some targets: |
| 37 | 35 | ||
| 38 | - For MSDOS, the small and medium models have been tested only with | 36 | - For Turbo C the small model is supported only with reduced performance to |
| 39 | Microsoft C. (This should work for Borland C also, but I don't have | 37 | avoid any far allocation; it was tested with -DMAX_WBITS=11 -DMAX_MEM_LEVEL=3 |
| 40 | a Borland compiler to test with.) The small model was tested with | ||
| 41 | Turbo C but only with reduced performance to avoid any far | ||
| 42 | allocation; it was tested with -DMAX_WBITS=11 -DMAX_MEM_LEVEL=3 | ||
| 43 | |||
| 44 | MS Visual C++1.5 in far model gives: | ||
| 45 | warning C4746: 'z_errmsg' : unsized array treated as '__far' | ||
| 46 | warning C4746: 'inflate_mask' : unsized array treated as '__far' | ||
| 47 | Ignore those warnings. | ||
| 48 | 38 | ||
| 49 | - For 64-bit Iris, deflate.c must be compiled without any optimization. | 39 | - For 64-bit Iris, deflate.c must be compiled without any optimization. |
| 50 | With -O, one libpng test fails. The test works in 32 bit mode (with the | 40 | With -O, one libpng test fails. The test works in 32 bit mode (with |
| 51 | -32 compiler flag). | 41 | the -32 compiler flag). |
| 42 | |||
| 43 | - zlib doesn't work with gcc 2.6.3 on a DEC 3000/300LX under OSF/1 2.1 | ||
| 44 | it works when compiled with cc. | ||
| 45 | |||
| 46 | - zlib doesn't work on HP-UX 9.05 with one cc compiler (the one not | ||
| 47 | accepting the -O option). It works with the other cc compiler. | ||
| 48 | |||
| 49 | A Perl interface to zlib written by Paul Marquess <pmarquess@bfsec.bt.co.uk> | ||
| 50 | is in the CPAN (Comprehensive Perl Archive Network) sites, such as: | ||
| 51 | ftp://ftp.cis.ufl.edu/pub/perl/CPAN/modules/by-module/Compress/Compress-Zlib* | ||
| 52 | |||
| 53 | |||
| 54 | Acknowledgments: | ||
| 52 | 55 | ||
| 56 | The deflate format used by zlib was defined by Phil Katz. The deflate | ||
| 57 | and zlib specifications were written by Peter Deutsch. Thanks to all the | ||
| 58 | people who reported problems and suggested various improvements in zlib; | ||
| 59 | they are too numerous to cite here. | ||
| 53 | 60 | ||
| 54 | Copyright notice: | 61 | Copyright notice: |
| 55 | 62 | ||
| @@ -1,9 +1,9 @@ | |||
| 1 | /* adler32.c -- compute the Adler-32 checksum of a data stream | 1 | /* adler32.c -- compute the Adler-32 checksum of a data stream |
| 2 | * Copyright (C) 1995 Mark Adler | 2 | * Copyright (C) 1995-1996 Mark Adler |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| 6 | /* $Id: adler32.c,v 1.6 1995/05/03 17:27:08 jloup Exp $ */ | 6 | /* $Id: adler32.c,v 1.9 1996/01/30 21:59:09 me Exp $ */ |
| 7 | 7 | ||
| 8 | #include "zlib.h" | 8 | #include "zlib.h" |
| 9 | 9 | ||
| @@ -11,16 +11,16 @@ | |||
| 11 | #define NMAX 5552 | 11 | #define NMAX 5552 |
| 12 | /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ | 12 | /* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */ |
| 13 | 13 | ||
| 14 | #define DO1(buf) {s1 += *buf++; s2 += s1;} | 14 | #define DO1(buf,i) {s1 += buf[i]; s2 += s1;} |
| 15 | #define DO2(buf) DO1(buf); DO1(buf); | 15 | #define DO2(buf,i) DO1(buf,i); DO1(buf,i+1); |
| 16 | #define DO4(buf) DO2(buf); DO2(buf); | 16 | #define DO4(buf,i) DO2(buf,i); DO2(buf,i+2); |
| 17 | #define DO8(buf) DO4(buf); DO4(buf); | 17 | #define DO8(buf,i) DO4(buf,i); DO4(buf,i+4); |
| 18 | #define DO16(buf) DO8(buf); DO8(buf); | 18 | #define DO16(buf) DO8(buf,0); DO8(buf,8); |
| 19 | 19 | ||
| 20 | /* ========================================================================= */ | 20 | /* ========================================================================= */ |
| 21 | uLong adler32(adler, buf, len) | 21 | uLong adler32(adler, buf, len) |
| 22 | uLong adler; | 22 | uLong adler; |
| 23 | Bytef *buf; | 23 | const Bytef *buf; |
| 24 | uInt len; | 24 | uInt len; |
| 25 | { | 25 | { |
| 26 | unsigned long s1 = adler & 0xffff; | 26 | unsigned long s1 = adler & 0xffff; |
| @@ -34,10 +34,12 @@ uLong adler32(adler, buf, len) | |||
| 34 | len -= k; | 34 | len -= k; |
| 35 | while (k >= 16) { | 35 | while (k >= 16) { |
| 36 | DO16(buf); | 36 | DO16(buf); |
| 37 | buf += 16; | ||
| 37 | k -= 16; | 38 | k -= 16; |
| 38 | } | 39 | } |
| 39 | if (k != 0) do { | 40 | if (k != 0) do { |
| 40 | DO1(buf); | 41 | s1 += *buf++; |
| 42 | s2 += s1; | ||
| 41 | } while (--k); | 43 | } while (--k); |
| 42 | s1 %= BASE; | 44 | s1 %= BASE; |
| 43 | s2 %= BASE; | 45 | s2 %= BASE; |
| @@ -1,9 +1,9 @@ | |||
| 1 | /* compress.c -- compress a memory buffer | 1 | /* compress.c -- compress a memory buffer |
| 2 | * Copyright (C) 1995 Jean-loup Gailly. | 2 | * Copyright (C) 1995-1996 Jean-loup Gailly. |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| 6 | /* $Id: compress.c,v 1.6 1995/05/03 17:27:08 jloup Exp $ */ | 6 | /* $Id: compress.c,v 1.9 1996/01/30 21:59:09 me Exp $ */ |
| 7 | 7 | ||
| 8 | #include "zlib.h" | 8 | #include "zlib.h" |
| 9 | 9 | ||
| @@ -22,13 +22,13 @@ | |||
| 22 | int compress (dest, destLen, source, sourceLen) | 22 | int compress (dest, destLen, source, sourceLen) |
| 23 | Bytef *dest; | 23 | Bytef *dest; |
| 24 | uLongf *destLen; | 24 | uLongf *destLen; |
| 25 | Bytef *source; | 25 | const Bytef *source; |
| 26 | uLong sourceLen; | 26 | uLong sourceLen; |
| 27 | { | 27 | { |
| 28 | z_stream stream; | 28 | z_stream stream; |
| 29 | int err; | 29 | int err; |
| 30 | 30 | ||
| 31 | stream.next_in = source; | 31 | stream.next_in = (Bytef*)source; |
| 32 | stream.avail_in = (uInt)sourceLen; | 32 | stream.avail_in = (uInt)sourceLen; |
| 33 | /* Check for source > 64K on 16-bit machine: */ | 33 | /* Check for source > 64K on 16-bit machine: */ |
| 34 | if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; | 34 | if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; |
diff --git a/configure b/configure new file mode 100755 index 0000000..a354e4c --- /dev/null +++ b/configure | |||
| @@ -0,0 +1,86 @@ | |||
| 1 | #!/bin/sh | ||
| 2 | # configure script for zlib. This script is needed only if | ||
| 3 | # you wish to build a shared library and your system supports them, | ||
| 4 | # of if you need special compiler, flags or install directory. | ||
| 5 | # Otherwise, you can just use directly "make test; make install" | ||
| 6 | # | ||
| 7 | # To impose specific compiler or flags or install directory, use for example: | ||
| 8 | # prefix=$HOME CC=cc CFLAGS="-O4" ./configure | ||
| 9 | # or for csh/tcsh users: | ||
| 10 | # (setenv prefix $HOME; setenv CC cc; setenv CFLAGS "-O4"; ./configure) | ||
| 11 | # LDSHARED is the command to be used to create a shared library | ||
| 12 | |||
| 13 | LIBS=libz.a | ||
| 14 | VER=`sed -n -e '/VERSION "/s/.*"\(.*\)".*/\1/p' < zlib.h` | ||
| 15 | AR=${AR-"ar rc"} | ||
| 16 | RANLIB=${RANLIB-"ranlib"} | ||
| 17 | prefix=${prefix-/usr/local} | ||
| 18 | exec_prefix=${exec_prefix-$prefix} | ||
| 19 | |||
| 20 | test -z "$CC" && echo Checking for gcc... | ||
| 21 | test=ztest$$ | ||
| 22 | cat > $test.c <<EOF | ||
| 23 | int hello() { printf("hello\n"); } | ||
| 24 | EOF | ||
| 25 | if test -z "$CC" && (gcc -c -O3 $test.c) 2>/dev/null; then | ||
| 26 | CC=gcc | ||
| 27 | SFLAGS=${CFLAGS-"-fPIC -O3"} | ||
| 28 | CFLAGS=${CFLAGS-"-O3"} | ||
| 29 | LDSHARED=${LDSHARED-"gcc -shared"} | ||
| 30 | else | ||
| 31 | # find system name and corresponding cc options | ||
| 32 | CC=${CC-cc} | ||
| 33 | case `(uname -sr || echo unknown) 2>/dev/null` in | ||
| 34 | SunOS\ 5*) SFLAGS=${CFLAGS-"-fast -xcg89 -KPIC -R."} | ||
| 35 | CFLAGS=${CFLAGS-"-fast -xcg89"} | ||
| 36 | LDSHARED=${LDSHARED-"cc -G"};; | ||
| 37 | SunOS\ 4*) SFLAGS=${CFLAGS-"-O2 -PIC"} | ||
| 38 | CFLAGS=${CFLAGS-"-O2"} | ||
| 39 | LDSHARED=${LDSHARED-"ld"};; | ||
| 40 | IRIX*) SFLAGS=${CFLAGS-"-ansi -O2 -rpath ."} | ||
| 41 | CFLAGS=${CFLAGS-"-ansi -O2"} | ||
| 42 | LDSHARED=${LDSHARED-"cc -shared"};; | ||
| 43 | QNX*) SFLAGS=${CFLAGS-"-4 -O"} | ||
| 44 | CFLAGS=${CFLAGS-"-4 -O"} | ||
| 45 | LDSHARED=${LDSHARED-"cc"} | ||
| 46 | RANLIB=${RANLIB-"true"} | ||
| 47 | AR="cc -A";; | ||
| 48 | SCO_SV\ 3.2*) SFLAGS=${CFLAGS-"-O3 -dy -KPIC "} | ||
| 49 | CFLAGS=${CFLAGS-"-O3"} | ||
| 50 | LDSHARED=${LDSHARED-"cc -dy -KPIC -G"};; | ||
| 51 | HP-UX*) SFLAGS=${CFLAGS-"-O +z"} | ||
| 52 | CFLAGS=${CFLAGS-"-O"} | ||
| 53 | LDSHARED=${LDSHARED-"ld -b"} | ||
| 54 | SHAREDLIBS='libz.sl';; | ||
| 55 | # send working options for other systems to gzip@prep.ai.mit.edu | ||
| 56 | *) SFLAGS=${CFLAGS-"-O"} | ||
| 57 | CFLAGS=${CFLAGS-"-O"} | ||
| 58 | LDSHARED=${LDSHARED-"cc -shared"};; | ||
| 59 | esac | ||
| 60 | fi | ||
| 61 | |||
| 62 | echo Checking for shared library support... | ||
| 63 | # we must test in two steps (cc then ld), required at least on SunOS 4.x | ||
| 64 | if test "`($CC -c $SFLAGS $test.c) 2>&1`" = "" && | ||
| 65 | test "`($LDSHARED -o $test.so $test.o) 2>&1`" = ""; then | ||
| 66 | CFLAGS="$SFLAGS" | ||
| 67 | LIBS='libz.so.$(VER)' | ||
| 68 | echo Building shared library libz.so.$VER with $CC. | ||
| 69 | else | ||
| 70 | LDSHARED="$CC" | ||
| 71 | echo Building static library $LIBS version $VER with $CC. | ||
| 72 | fi | ||
| 73 | rm -f $test.[co] $test.so | ||
| 74 | |||
| 75 | # udpate Makefile | ||
| 76 | sed < Makefile.in " | ||
| 77 | /^CC *=/s/=.*/=$CC/ | ||
| 78 | /^CFLAGS *=/s/=.*/=$CFLAGS/ | ||
| 79 | /^LDSHARED *=/s/=.*/=$LDSHARED/ | ||
| 80 | /^LIBS *=/s,=.*,=$LIBS, | ||
| 81 | /^AR *=/s/=.*/=$AR/ | ||
| 82 | /^RANLIB *=/s,=.*,=$RANLIB, | ||
| 83 | /^VER *=/s/=.*/=$VER/ | ||
| 84 | /^prefix *=/s,=.*,=$prefix, | ||
| 85 | /^exec_prefix *=/s,=.*,=$exec_prefix, | ||
| 86 | " > Makefile | ||
| @@ -1,32 +1,62 @@ | |||
| 1 | /* crc32.c -- compute the CRC-32 of a data stream | 1 | /* crc32.c -- compute the CRC-32 of a data stream |
| 2 | * Copyright (C) 1995 Mark Adler | 2 | * Copyright (C) 1995-1996 Mark Adler |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| 6 | /* $Id: crc32.c,v 1.4 1995/04/14 14:55:12 jloup Exp $ */ | 6 | /* $Id: crc32.c,v 1.8 1996/01/30 21:59:10 me Exp $ */ |
| 7 | 7 | ||
| 8 | #include "zlib.h" | 8 | #include "zlib.h" |
| 9 | 9 | ||
| 10 | #define local static | 10 | #define local static |
| 11 | 11 | ||
| 12 | #ifdef DYNAMIC_CRC_TABLE | 12 | #ifdef DYNAMIC_CRC_TABLE |
| 13 | /* ========================================================================= | 13 | |
| 14 | * Make the crc table. This function is needed only if you want to compute | ||
| 15 | * the table dynamically. | ||
| 16 | */ | ||
| 17 | local int crc_table_empty = 1; | 14 | local int crc_table_empty = 1; |
| 18 | local uLong crc_table[256]; | 15 | local uLongf crc_table[256]; |
| 16 | local void make_crc_table OF((void)); | ||
| 17 | |||
| 18 | /* | ||
| 19 | Generate a table for a byte-wise 32-bit CRC calculation on the polynomial: | ||
| 20 | x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x+1. | ||
| 19 | 21 | ||
| 22 | Polynomials over GF(2) are represented in binary, one bit per coefficient, | ||
| 23 | with the lowest powers in the most significant bit. Then adding polynomials | ||
| 24 | is just exclusive-or, and multiplying a polynomial by x is a right shift by | ||
| 25 | one. If we call the above polynomial p, and represent a byte as the | ||
| 26 | polynomial q, also with the lowest power in the most significant bit (so the | ||
| 27 | byte 0xb1 is the polynomial x^7+x^3+x+1), then the CRC is (q*x^32) mod p, | ||
| 28 | where a mod b means the remainder after dividing a by b. | ||
| 29 | |||
| 30 | This calculation is done using the shift-register method of multiplying and | ||
| 31 | taking the remainder. The register is initialized to zero, and for each | ||
| 32 | incoming bit, x^32 is added mod p to the register if the bit is a one (where | ||
| 33 | x^32 mod p is p+x^32 = x^26+...+1), and the register is multiplied mod p by | ||
| 34 | x (which is shifting right by one and adding x^32 mod p if the bit shifted | ||
| 35 | out is a one). We start with the highest power (least significant bit) of | ||
| 36 | q and repeat for all eight bits of q. | ||
| 37 | |||
| 38 | The table is simply the CRC of all possible eight bit values. This is all | ||
| 39 | the information needed to generate CRC's on data a byte at a time for all | ||
| 40 | combinations of CRC register values and incoming bytes. | ||
| 41 | */ | ||
| 20 | local void make_crc_table() | 42 | local void make_crc_table() |
| 21 | { | 43 | { |
| 22 | uLong c; | 44 | uLong c; |
| 23 | int n, k; | 45 | int n, k; |
| 46 | uLong poly; /* polynomial exclusive-or pattern */ | ||
| 47 | /* terms of polynomial defining this crc (except x^32): */ | ||
| 48 | static Byte p[] = {0,1,2,4,5,7,8,10,11,12,16,22,23,26}; | ||
| 49 | |||
| 50 | /* make exclusive-or pattern from polynomial (0xedb88320L) */ | ||
| 51 | poly = 0L; | ||
| 52 | for (n = 0; n < sizeof(p)/sizeof(Byte); n++) | ||
| 53 | poly |= 1L << (31 - p[n]); | ||
| 24 | 54 | ||
| 25 | for (n = 0; n < 256; n++) | 55 | for (n = 0; n < 256; n++) |
| 26 | { | 56 | { |
| 27 | c = (uLong)n; | 57 | c = (uLong)n; |
| 28 | for (k = 0; k < 8; k++) | 58 | for (k = 0; k < 8; k++) |
| 29 | c = c & 1 ? 0xedb88320L ^ (c >> 1) : c >> 1; | 59 | c = c & 1 ? poly ^ (c >> 1) : c >> 1; |
| 30 | crc_table[n] = c; | 60 | crc_table[n] = c; |
| 31 | } | 61 | } |
| 32 | crc_table_empty = 0; | 62 | crc_table_empty = 0; |
| @@ -35,7 +65,7 @@ local void make_crc_table() | |||
| 35 | /* ======================================================================== | 65 | /* ======================================================================== |
| 36 | * Table of CRC-32's of all single-byte values (made by make_crc_table) | 66 | * Table of CRC-32's of all single-byte values (made by make_crc_table) |
| 37 | */ | 67 | */ |
| 38 | local uLong crc_table[] = { | 68 | local uLongf crc_table[256] = { |
| 39 | 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, | 69 | 0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL, 0x076dc419L, |
| 40 | 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, | 70 | 0x706af48fL, 0xe963a535L, 0x9e6495a3L, 0x0edb8832L, 0x79dcb8a4L, |
| 41 | 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, | 71 | 0xe0d5e91eL, 0x97d2d988L, 0x09b64c2bL, 0x7eb17cbdL, 0xe7b82d07L, |
| @@ -91,6 +121,18 @@ local uLong crc_table[] = { | |||
| 91 | }; | 121 | }; |
| 92 | #endif | 122 | #endif |
| 93 | 123 | ||
| 124 | /* ========================================================================= | ||
| 125 | * This function can be used by asm versions of crc32() | ||
| 126 | */ | ||
| 127 | uLongf *get_crc_table() | ||
| 128 | { | ||
| 129 | #ifdef DYNAMIC_CRC_TABLE | ||
| 130 | if (crc_table_empty) make_crc_table(); | ||
| 131 | #endif | ||
| 132 | return (uLongf *)crc_table; | ||
| 133 | } | ||
| 134 | |||
| 135 | /* ========================================================================= */ | ||
| 94 | #define DO1(buf) crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8); | 136 | #define DO1(buf) crc = crc_table[((int)crc ^ (*buf++)) & 0xff] ^ (crc >> 8); |
| 95 | #define DO2(buf) DO1(buf); DO1(buf); | 137 | #define DO2(buf) DO1(buf); DO1(buf); |
| 96 | #define DO4(buf) DO2(buf); DO2(buf); | 138 | #define DO4(buf) DO2(buf); DO2(buf); |
| @@ -99,7 +141,7 @@ local uLong crc_table[] = { | |||
| 99 | /* ========================================================================= */ | 141 | /* ========================================================================= */ |
| 100 | uLong crc32(crc, buf, len) | 142 | uLong crc32(crc, buf, len) |
| 101 | uLong crc; | 143 | uLong crc; |
| 102 | Bytef *buf; | 144 | const Bytef *buf; |
| 103 | uInt len; | 145 | uInt len; |
| 104 | { | 146 | { |
| 105 | if (buf == Z_NULL) return 0L; | 147 | if (buf == Z_NULL) return 0L; |
| @@ -1,5 +1,5 @@ | |||
| 1 | /* deflate.c -- compress data using the deflation algorithm | 1 | /* deflate.c -- compress data using the deflation algorithm |
| 2 | * Copyright (C) 1995 Jean-loup Gailly. | 2 | * Copyright (C) 1995-1996 Jean-loup Gailly. |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| @@ -47,11 +47,11 @@ | |||
| 47 | * | 47 | * |
| 48 | */ | 48 | */ |
| 49 | 49 | ||
| 50 | /* $Id: deflate.c,v 1.8 1995/05/03 17:27:08 jloup Exp $ */ | 50 | /* $Id: deflate.c,v 1.12 1996/01/30 21:59:11 me Exp $ */ |
| 51 | 51 | ||
| 52 | #include "deflate.h" | 52 | #include "deflate.h" |
| 53 | 53 | ||
| 54 | char deflate_copyright[] = " deflate 1.0 Copyright 1995 Jean-loup Gailly "; | 54 | char deflate_copyright[] = " deflate 1.0.1 Copyright 1995-1996 Jean-loup Gailly "; |
| 55 | /* | 55 | /* |
| 56 | If you use the zlib library in a product, an acknowledgment is welcome | 56 | If you use the zlib library in a product, an acknowledgment is welcome |
| 57 | in the documentation of your product. If for some reason you cannot | 57 | in the documentation of your product. If for some reason you cannot |
| @@ -60,15 +60,14 @@ char deflate_copyright[] = " deflate 1.0 Copyright 1995 Jean-loup Gailly "; | |||
| 60 | */ | 60 | */ |
| 61 | 61 | ||
| 62 | /* =========================================================================== | 62 | /* =========================================================================== |
| 63 | * Prototypes for local functions. | 63 | * Function prototypes. |
| 64 | */ | 64 | */ |
| 65 | |||
| 66 | local void fill_window OF((deflate_state *s)); | 65 | local void fill_window OF((deflate_state *s)); |
| 67 | local int deflate_stored OF((deflate_state *s, int flush)); | 66 | local int deflate_stored OF((deflate_state *s, int flush)); |
| 68 | local int deflate_fast OF((deflate_state *s, int flush)); | 67 | local int deflate_fast OF((deflate_state *s, int flush)); |
| 69 | local int deflate_slow OF((deflate_state *s, int flush)); | 68 | local int deflate_slow OF((deflate_state *s, int flush)); |
| 70 | local void lm_init OF((deflate_state *s)); | 69 | local void lm_init OF((deflate_state *s)); |
| 71 | local int longest_match OF((deflate_state *s, IPos cur_match)); | 70 | local uInt longest_match OF((deflate_state *s, IPos cur_match)); |
| 72 | local void putShortMSB OF((deflate_state *s, uInt b)); | 71 | local void putShortMSB OF((deflate_state *s, uInt b)); |
| 73 | local void flush_pending OF((z_stream *strm)); | 72 | local void flush_pending OF((z_stream *strm)); |
| 74 | local int read_buf OF((z_stream *strm, charf *buf, unsigned size)); | 73 | local int read_buf OF((z_stream *strm, charf *buf, unsigned size)); |
| @@ -158,7 +157,7 @@ struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ | |||
| 158 | #define INSERT_STRING(s, str, match_head) \ | 157 | #define INSERT_STRING(s, str, match_head) \ |
| 159 | (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ | 158 | (UPDATE_HASH(s, s->ins_h, s->window[(str) + (MIN_MATCH-1)]), \ |
| 160 | s->prev[(str) & s->w_mask] = match_head = s->head[s->ins_h], \ | 159 | s->prev[(str) & s->w_mask] = match_head = s->head[s->ins_h], \ |
| 161 | s->head[s->ins_h] = (str)) | 160 | s->head[s->ins_h] = (Pos)(str)) |
| 162 | 161 | ||
| 163 | /* =========================================================================== | 162 | /* =========================================================================== |
| 164 | * Initialize the hash table (avoiding 64K overflow for 16 bit systems). | 163 | * Initialize the hash table (avoiding 64K overflow for 16 bit systems). |
| @@ -169,26 +168,41 @@ struct static_tree_desc_s {int dummy;}; /* for buggy compilers */ | |||
| 169 | zmemzero((charf *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); | 168 | zmemzero((charf *)s->head, (unsigned)(s->hash_size-1)*sizeof(*s->head)); |
| 170 | 169 | ||
| 171 | /* ========================================================================= */ | 170 | /* ========================================================================= */ |
| 172 | int deflateInit (strm, level) | 171 | int deflateInit_(strm, level, version, stream_size) |
| 173 | z_stream *strm; | 172 | z_stream *strm; |
| 174 | int level; | 173 | int level; |
| 174 | const char *version; | ||
| 175 | int stream_size; | ||
| 175 | { | 176 | { |
| 176 | return deflateInit2 (strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, 0); | 177 | return deflateInit2_(strm, level, Z_DEFLATED, MAX_WBITS, DEF_MEM_LEVEL, |
| 178 | Z_DEFAULT_STRATEGY, version, stream_size); | ||
| 177 | /* To do: ignore strm->next_in if we use it as window */ | 179 | /* To do: ignore strm->next_in if we use it as window */ |
| 178 | } | 180 | } |
| 179 | 181 | ||
| 180 | /* ========================================================================= */ | 182 | /* ========================================================================= */ |
| 181 | int deflateInit2 (strm, level, method, windowBits, memLevel, strategy) | 183 | int deflateInit2_(strm, level, method, windowBits, memLevel, strategy, |
| 184 | version, stream_size) | ||
| 182 | z_stream *strm; | 185 | z_stream *strm; |
| 183 | int level; | 186 | int level; |
| 184 | int method; | 187 | int method; |
| 185 | int windowBits; | 188 | int windowBits; |
| 186 | int memLevel; | 189 | int memLevel; |
| 187 | int strategy; | 190 | int strategy; |
| 191 | const char *version; | ||
| 192 | int stream_size; | ||
| 188 | { | 193 | { |
| 189 | deflate_state *s; | 194 | deflate_state *s; |
| 190 | int noheader = 0; | 195 | int noheader = 0; |
| 191 | 196 | ||
| 197 | ushf *overlay; | ||
| 198 | /* We overlay pending_buf and d_buf+l_buf. This works since the average | ||
| 199 | * output size for (length,distance) codes is <= 24 bits. | ||
| 200 | */ | ||
| 201 | |||
| 202 | if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || | ||
| 203 | stream_size != sizeof(z_stream)) { | ||
| 204 | return Z_VERSION_ERROR; | ||
| 205 | } | ||
| 192 | if (strm == Z_NULL) return Z_STREAM_ERROR; | 206 | if (strm == Z_NULL) return Z_STREAM_ERROR; |
| 193 | 207 | ||
| 194 | strm->msg = Z_NULL; | 208 | strm->msg = Z_NULL; |
| @@ -230,20 +244,17 @@ int deflateInit2 (strm, level, method, windowBits, memLevel, strategy) | |||
| 230 | 244 | ||
| 231 | s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ | 245 | s->lit_bufsize = 1 << (memLevel + 6); /* 16K elements by default */ |
| 232 | 246 | ||
| 233 | s->pending_buf = (uchf *) ZALLOC(strm, s->lit_bufsize, 2*sizeof(ush)); | 247 | overlay = (ushf *) ZALLOC(strm, s->lit_bufsize, sizeof(ush)+2); |
| 248 | s->pending_buf = (uchf *) overlay; | ||
| 234 | 249 | ||
| 235 | if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || | 250 | if (s->window == Z_NULL || s->prev == Z_NULL || s->head == Z_NULL || |
| 236 | s->pending_buf == Z_NULL) { | 251 | s->pending_buf == Z_NULL) { |
| 237 | strm->msg = z_errmsg[1-Z_MEM_ERROR]; | 252 | strm->msg = ERR_MSG(Z_MEM_ERROR); |
| 238 | deflateEnd (strm); | 253 | deflateEnd (strm); |
| 239 | return Z_MEM_ERROR; | 254 | return Z_MEM_ERROR; |
| 240 | } | 255 | } |
| 241 | s->l_buf = (uchf *) &(s->pending_buf[s->lit_bufsize]); | 256 | s->d_buf = overlay + s->lit_bufsize/sizeof(ush); |
| 242 | s->d_buf = (ushf *) &(s->pending_buf[2*s->lit_bufsize]); | 257 | s->l_buf = s->pending_buf + (1+sizeof(ush))*s->lit_bufsize; |
| 243 | /* We overlay pending_buf and d_buf+l_buf. This works since the average | ||
| 244 | * output size for (length,distance) codes is <= 32 bits (worst case | ||
| 245 | * is 15+15+13=33). d_buf is put last in case sizeof(short)>2. | ||
| 246 | */ | ||
| 247 | 258 | ||
| 248 | s->level = level; | 259 | s->level = level; |
| 249 | s->strategy = strategy; | 260 | s->strategy = strategy; |
| @@ -252,32 +263,42 @@ int deflateInit2 (strm, level, method, windowBits, memLevel, strategy) | |||
| 252 | return deflateReset(strm); | 263 | return deflateReset(strm); |
| 253 | } | 264 | } |
| 254 | 265 | ||
| 255 | /* ========================================================================= | 266 | /* ========================================================================= */ |
| 256 | * Undocumented function to return the Adler32 of a stream. It can be | 267 | int deflateSetDictionary (strm, dictionary, dictLength) |
| 257 | * called immediately after a flush with Z_SYNC_FLUSH, to allow later | ||
| 258 | * resumption of the compressor with deflateSetAdler32. | ||
| 259 | */ | ||
| 260 | uLong deflateGetAdler32 (strm) | ||
| 261 | z_stream *strm; | 268 | z_stream *strm; |
| 269 | const Bytef *dictionary; | ||
| 270 | uInt dictLength; | ||
| 262 | { | 271 | { |
| 263 | if (strm == Z_NULL || strm->state == Z_NULL) return (uLong)Z_STREAM_ERROR; | 272 | deflate_state *s; |
| 264 | /* Z_STREAM_ERROR happens to be an invalid Adler32 value. */ | 273 | uInt length = dictLength; |
| 274 | uInt n; | ||
| 275 | IPos hash_head = 0; | ||
| 265 | 276 | ||
| 266 | return strm->state->adler; | 277 | if (strm == Z_NULL || strm->state == Z_NULL || dictionary == Z_NULL || |
| 267 | } | 278 | strm->state->status != INIT_STATE) return Z_STREAM_ERROR; |
| 268 | 279 | ||
| 269 | /* ========================================================================= | 280 | s = strm->state; |
| 270 | * Undocumented function to set the Adler32 of a stream. It can be called | 281 | strm->adler = adler32(strm->adler, dictionary, dictLength); |
| 271 | * immediately after deflateInit to reset the Adler32 of a compression | ||
| 272 | * stream which had been interrupted. | ||
| 273 | */ | ||
| 274 | int deflateSetAdler32 (strm, adler) | ||
| 275 | z_stream *strm; | ||
| 276 | uLong adler; | ||
| 277 | { | ||
| 278 | if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; | ||
| 279 | 282 | ||
| 280 | strm->state->adler = adler; | 283 | if (length < MIN_MATCH) return Z_OK; |
| 284 | if (length > MAX_DIST(s)) { | ||
| 285 | length = MAX_DIST(s); | ||
| 286 | dictionary += dictLength - length; | ||
| 287 | } | ||
| 288 | zmemcpy((charf *)s->window, dictionary, length); | ||
| 289 | s->strstart = length; | ||
| 290 | s->block_start = (long)length; | ||
| 291 | |||
| 292 | /* Insert all strings in the hash table (except for the last two bytes). | ||
| 293 | * s->lookahead stays null, so s->ins_h will be recomputed at the next | ||
| 294 | * call of fill_window. | ||
| 295 | */ | ||
| 296 | s->ins_h = s->window[0]; | ||
| 297 | UPDATE_HASH(s, s->ins_h, s->window[1]); | ||
| 298 | for (n = 0; n <= length - MIN_MATCH; n++) { | ||
| 299 | INSERT_STRING(s, n, hash_head); | ||
| 300 | } | ||
| 301 | if (hash_head) hash_head = 0; /* to make compiler happy */ | ||
| 281 | return Z_OK; | 302 | return Z_OK; |
| 282 | } | 303 | } |
| 283 | 304 | ||
| @@ -302,10 +323,10 @@ int deflateReset (strm) | |||
| 302 | s->noheader = 0; /* was set to -1 by deflate(..., Z_FINISH); */ | 323 | s->noheader = 0; /* was set to -1 by deflate(..., Z_FINISH); */ |
| 303 | } | 324 | } |
| 304 | s->status = s->noheader ? BUSY_STATE : INIT_STATE; | 325 | s->status = s->noheader ? BUSY_STATE : INIT_STATE; |
| 305 | s->adler = 1; | 326 | strm->adler = 1; |
| 306 | s->last_flush = Z_NO_FLUSH; | 327 | s->last_flush = Z_NO_FLUSH; |
| 307 | 328 | ||
| 308 | tr_init(s); | 329 | _tr_init(s); |
| 309 | lm_init(s); | 330 | lm_init(s); |
| 310 | 331 | ||
| 311 | return Z_OK; | 332 | return Z_OK; |
| @@ -319,6 +340,7 @@ int deflateParams(strm, level, strategy) | |||
| 319 | { | 340 | { |
| 320 | deflate_state *s; | 341 | deflate_state *s; |
| 321 | compress_func func; | 342 | compress_func func; |
| 343 | int err = Z_OK; | ||
| 322 | 344 | ||
| 323 | if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; | 345 | if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
| 324 | s = strm->state; | 346 | s = strm->state; |
| @@ -331,11 +353,9 @@ int deflateParams(strm, level, strategy) | |||
| 331 | } | 353 | } |
| 332 | func = configuration_table[s->level].func; | 354 | func = configuration_table[s->level].func; |
| 333 | 355 | ||
| 334 | if (func != configuration_table[level].func | 356 | if (func != configuration_table[level].func && strm->total_in != 0) { |
| 335 | && strm->state->lookahead != 0) { | ||
| 336 | |||
| 337 | /* Flush the last buffer: */ | 357 | /* Flush the last buffer: */ |
| 338 | (void)(*func)(strm->state, Z_PARTIAL_FLUSH); | 358 | err = deflate(strm, Z_PARTIAL_FLUSH); |
| 339 | } | 359 | } |
| 340 | if (s->level != level) { | 360 | if (s->level != level) { |
| 341 | s->level = level; | 361 | s->level = level; |
| @@ -345,7 +365,7 @@ int deflateParams(strm, level, strategy) | |||
| 345 | s->max_chain_length = configuration_table[level].max_chain; | 365 | s->max_chain_length = configuration_table[level].max_chain; |
| 346 | } | 366 | } |
| 347 | s->strategy = strategy; | 367 | s->strategy = strategy; |
| 348 | return Z_OK; | 368 | return err; |
| 349 | } | 369 | } |
| 350 | 370 | ||
| 351 | /* ========================================================================= | 371 | /* ========================================================================= |
| @@ -392,36 +412,47 @@ int deflate (strm, flush) | |||
| 392 | int flush; | 412 | int flush; |
| 393 | { | 413 | { |
| 394 | int old_flush; /* value of flush param for previous deflate call */ | 414 | int old_flush; /* value of flush param for previous deflate call */ |
| 415 | deflate_state *s; | ||
| 395 | 416 | ||
| 396 | if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; | 417 | if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
| 397 | 418 | ||
| 419 | s = strm->state; | ||
| 420 | |||
| 398 | if (strm->next_out == Z_NULL || | 421 | if (strm->next_out == Z_NULL || |
| 399 | (strm->next_in == Z_NULL && strm->avail_in != 0) || | 422 | (strm->next_in == Z_NULL && strm->avail_in != 0) || |
| 400 | (strm->state->status == FINISH_STATE && flush != Z_FINISH)) { | 423 | (s->status == FINISH_STATE && flush != Z_FINISH)) { |
| 401 | ERR_RETURN(strm, Z_STREAM_ERROR); | 424 | ERR_RETURN(strm, Z_STREAM_ERROR); |
| 402 | } | 425 | } |
| 403 | if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR); | 426 | if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR); |
| 404 | 427 | ||
| 405 | strm->state->strm = strm; /* just in case */ | 428 | s->strm = strm; /* just in case */ |
| 406 | old_flush = strm->state->last_flush; | 429 | old_flush = s->last_flush; |
| 407 | strm->state->last_flush = flush; | 430 | s->last_flush = flush; |
| 408 | 431 | ||
| 409 | /* Write the zlib header */ | 432 | /* Write the zlib header */ |
| 410 | if (strm->state->status == INIT_STATE) { | 433 | if (s->status == INIT_STATE) { |
| 411 | 434 | ||
| 412 | uInt header = (Z_DEFLATED + ((strm->state->w_bits-8)<<4)) << 8; | 435 | uInt header = (Z_DEFLATED + ((s->w_bits-8)<<4)) << 8; |
| 413 | uInt level_flags = (strm->state->level-1) >> 1; | 436 | uInt level_flags = (s->level-1) >> 1; |
| 414 | 437 | ||
| 415 | if (level_flags > 3) level_flags = 3; | 438 | if (level_flags > 3) level_flags = 3; |
| 416 | header |= (level_flags << 6); | 439 | header |= (level_flags << 6); |
| 440 | if (s->strstart != 0) header |= PRESET_DICT; | ||
| 417 | header += 31 - (header % 31); | 441 | header += 31 - (header % 31); |
| 418 | 442 | ||
| 419 | strm->state->status = BUSY_STATE; | 443 | s->status = BUSY_STATE; |
| 420 | putShortMSB(strm->state, header); | 444 | putShortMSB(s, header); |
| 445 | |||
| 446 | /* Save the adler32 of the preset dictionary: */ | ||
| 447 | if (s->strstart != 0) { | ||
| 448 | putShortMSB(s, (uInt)(strm->adler >> 16)); | ||
| 449 | putShortMSB(s, (uInt)(strm->adler & 0xffff)); | ||
| 450 | strm->adler = 1L; | ||
| 451 | } | ||
| 421 | } | 452 | } |
| 422 | 453 | ||
| 423 | /* Flush as much pending output as possible */ | 454 | /* Flush as much pending output as possible */ |
| 424 | if (strm->state->pending != 0) { | 455 | if (s->pending != 0) { |
| 425 | flush_pending(strm); | 456 | flush_pending(strm); |
| 426 | if (strm->avail_out == 0) return Z_OK; | 457 | if (strm->avail_out == 0) return Z_OK; |
| 427 | 458 | ||
| @@ -435,21 +466,20 @@ int deflate (strm, flush) | |||
| 435 | } | 466 | } |
| 436 | 467 | ||
| 437 | /* User must not provide more input after the first FINISH: */ | 468 | /* User must not provide more input after the first FINISH: */ |
| 438 | if (strm->state->status == FINISH_STATE && strm->avail_in != 0) { | 469 | if (s->status == FINISH_STATE && strm->avail_in != 0) { |
| 439 | ERR_RETURN(strm, Z_BUF_ERROR); | 470 | ERR_RETURN(strm, Z_BUF_ERROR); |
| 440 | } | 471 | } |
| 441 | 472 | ||
| 442 | /* Start a new block or continue the current one. | 473 | /* Start a new block or continue the current one. |
| 443 | */ | 474 | */ |
| 444 | if (strm->avail_in != 0 || strm->state->lookahead != 0 || | 475 | if (strm->avail_in != 0 || s->lookahead != 0 || |
| 445 | (flush != Z_NO_FLUSH && strm->state->status != FINISH_STATE)) { | 476 | (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) { |
| 446 | int quit; | 477 | int quit; |
| 447 | 478 | ||
| 448 | if (flush == Z_FINISH) { | 479 | if (flush == Z_FINISH) { |
| 449 | strm->state->status = FINISH_STATE; | 480 | s->status = FINISH_STATE; |
| 450 | } | 481 | } |
| 451 | quit = (*(configuration_table[strm->state->level].func)) | 482 | quit = (*(configuration_table[s->level].func))(s, flush); |
| 452 | (strm->state, flush); | ||
| 453 | 483 | ||
| 454 | if (quit || strm->avail_out == 0) return Z_OK; | 484 | if (quit || strm->avail_out == 0) return Z_OK; |
| 455 | /* If flush != Z_NO_FLUSH && avail_out == 0, the next call | 485 | /* If flush != Z_NO_FLUSH && avail_out == 0, the next call |
| @@ -461,14 +491,14 @@ int deflate (strm, flush) | |||
| 461 | */ | 491 | */ |
| 462 | if (flush != Z_NO_FLUSH && flush != Z_FINISH) { | 492 | if (flush != Z_NO_FLUSH && flush != Z_FINISH) { |
| 463 | if (flush == Z_PARTIAL_FLUSH) { | 493 | if (flush == Z_PARTIAL_FLUSH) { |
| 464 | tr_align(strm->state); | 494 | _tr_align(s); |
| 465 | } else { /* FULL_FLUSH or SYNC_FLUSH */ | 495 | } else { /* FULL_FLUSH or SYNC_FLUSH */ |
| 466 | tr_stored_block(strm->state, (char*)0, 0L, 0); | 496 | _tr_stored_block(s, (char*)0, 0L, 0); |
| 467 | /* For a full flush, this empty block will be recognized | 497 | /* For a full flush, this empty block will be recognized |
| 468 | * as a special marker by inflate_sync(). | 498 | * as a special marker by inflate_sync(). |
| 469 | */ | 499 | */ |
| 470 | if (flush == Z_FULL_FLUSH) { | 500 | if (flush == Z_FULL_FLUSH) { |
| 471 | CLEAR_HASH(strm->state); /* forget history */ | 501 | CLEAR_HASH(s); /* forget history */ |
| 472 | } | 502 | } |
| 473 | } | 503 | } |
| 474 | flush_pending(strm); | 504 | flush_pending(strm); |
| @@ -478,23 +508,25 @@ int deflate (strm, flush) | |||
| 478 | Assert(strm->avail_out > 0, "bug2"); | 508 | Assert(strm->avail_out > 0, "bug2"); |
| 479 | 509 | ||
| 480 | if (flush != Z_FINISH) return Z_OK; | 510 | if (flush != Z_FINISH) return Z_OK; |
| 481 | if (strm->state->noheader) return Z_STREAM_END; | 511 | if (s->noheader) return Z_STREAM_END; |
| 482 | 512 | ||
| 483 | /* Write the zlib trailer (adler32) */ | 513 | /* Write the zlib trailer (adler32) */ |
| 484 | putShortMSB(strm->state, (uInt)(strm->state->adler >> 16)); | 514 | putShortMSB(s, (uInt)(strm->adler >> 16)); |
| 485 | putShortMSB(strm->state, (uInt)(strm->state->adler & 0xffff)); | 515 | putShortMSB(s, (uInt)(strm->adler & 0xffff)); |
| 486 | flush_pending(strm); | 516 | flush_pending(strm); |
| 487 | /* If avail_out is zero, the application will call deflate again | 517 | /* If avail_out is zero, the application will call deflate again |
| 488 | * to flush the rest. | 518 | * to flush the rest. |
| 489 | */ | 519 | */ |
| 490 | strm->state->noheader = -1; /* write the trailer only once! */ | 520 | s->noheader = -1; /* write the trailer only once! */ |
| 491 | return strm->state->pending != 0 ? Z_OK : Z_STREAM_END; | 521 | return s->pending != 0 ? Z_OK : Z_STREAM_END; |
| 492 | } | 522 | } |
| 493 | 523 | ||
| 494 | /* ========================================================================= */ | 524 | /* ========================================================================= */ |
| 495 | int deflateEnd (strm) | 525 | int deflateEnd (strm) |
| 496 | z_stream *strm; | 526 | z_stream *strm; |
| 497 | { | 527 | { |
| 528 | int status; | ||
| 529 | |||
| 498 | if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; | 530 | if (strm == Z_NULL || strm->state == Z_NULL) return Z_STREAM_ERROR; |
| 499 | 531 | ||
| 500 | /* Deallocate in reverse order of allocations: */ | 532 | /* Deallocate in reverse order of allocations: */ |
| @@ -503,10 +535,11 @@ int deflateEnd (strm) | |||
| 503 | TRY_FREE(strm, strm->state->prev); | 535 | TRY_FREE(strm, strm->state->prev); |
| 504 | TRY_FREE(strm, strm->state->window); | 536 | TRY_FREE(strm, strm->state->window); |
| 505 | 537 | ||
| 538 | status = strm->state->status; | ||
| 506 | ZFREE(strm, strm->state); | 539 | ZFREE(strm, strm->state); |
| 507 | strm->state = Z_NULL; | 540 | strm->state = Z_NULL; |
| 508 | 541 | ||
| 509 | return Z_OK; | 542 | return status == BUSY_STATE ? Z_DATA_ERROR : Z_OK; |
| 510 | } | 543 | } |
| 511 | 544 | ||
| 512 | /* ========================================================================= */ | 545 | /* ========================================================================= */ |
| @@ -549,7 +582,7 @@ local int read_buf(strm, buf, size) | |||
| 549 | strm->avail_in -= len; | 582 | strm->avail_in -= len; |
| 550 | 583 | ||
| 551 | if (!strm->state->noheader) { | 584 | if (!strm->state->noheader) { |
| 552 | strm->state->adler = adler32(strm->state->adler, strm->next_in, len); | 585 | strm->adler = adler32(strm->adler, strm->next_in, len); |
| 553 | } | 586 | } |
| 554 | zmemcpy(buf, strm->next_in, len); | 587 | zmemcpy(buf, strm->next_in, len); |
| 555 | strm->next_in += len; | 588 | strm->next_in += len; |
| @@ -593,12 +626,13 @@ local void lm_init (s) | |||
| 593 | * garbage. | 626 | * garbage. |
| 594 | * IN assertions: cur_match is the head of the hash chain for the current | 627 | * IN assertions: cur_match is the head of the hash chain for the current |
| 595 | * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 | 628 | * string (strstart) and its distance is <= MAX_DIST, and prev_length >= 1 |
| 629 | * OUT assertion: the match length is not greater than s->lookahead. | ||
| 596 | */ | 630 | */ |
| 597 | #ifndef ASMV | 631 | #ifndef ASMV |
| 598 | /* For 80x86 and 680x0, an optimized version will be provided in match.asm or | 632 | /* For 80x86 and 680x0, an optimized version will be provided in match.asm or |
| 599 | * match.S. The code will be functionally equivalent. | 633 | * match.S. The code will be functionally equivalent. |
| 600 | */ | 634 | */ |
| 601 | local int longest_match(s, cur_match) | 635 | local uInt longest_match(s, cur_match) |
| 602 | deflate_state *s; | 636 | deflate_state *s; |
| 603 | IPos cur_match; /* current match */ | 637 | IPos cur_match; /* current match */ |
| 604 | { | 638 | { |
| @@ -607,6 +641,7 @@ local int longest_match(s, cur_match) | |||
| 607 | register Bytef *match; /* matched string */ | 641 | register Bytef *match; /* matched string */ |
| 608 | register int len; /* length of current match */ | 642 | register int len; /* length of current match */ |
| 609 | int best_len = s->prev_length; /* best match length so far */ | 643 | int best_len = s->prev_length; /* best match length so far */ |
| 644 | int nice_match = s->nice_match; /* stop if match long enough */ | ||
| 610 | IPos limit = s->strstart > (IPos)MAX_DIST(s) ? | 645 | IPos limit = s->strstart > (IPos)MAX_DIST(s) ? |
| 611 | s->strstart - (IPos)MAX_DIST(s) : NIL; | 646 | s->strstart - (IPos)MAX_DIST(s) : NIL; |
| 612 | /* Stop when cur_match becomes <= limit. To simplify the code, | 647 | /* Stop when cur_match becomes <= limit. To simplify the code, |
| @@ -637,6 +672,11 @@ local int longest_match(s, cur_match) | |||
| 637 | if (s->prev_length >= s->good_match) { | 672 | if (s->prev_length >= s->good_match) { |
| 638 | chain_length >>= 2; | 673 | chain_length >>= 2; |
| 639 | } | 674 | } |
| 675 | /* Do not look for matches beyond the end of the input. This is necessary | ||
| 676 | * to make deflate deterministic. | ||
| 677 | */ | ||
| 678 | if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; | ||
| 679 | |||
| 640 | Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); | 680 | Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead"); |
| 641 | 681 | ||
| 642 | do { | 682 | do { |
| @@ -715,7 +755,7 @@ local int longest_match(s, cur_match) | |||
| 715 | if (len > best_len) { | 755 | if (len > best_len) { |
| 716 | s->match_start = cur_match; | 756 | s->match_start = cur_match; |
| 717 | best_len = len; | 757 | best_len = len; |
| 718 | if (len >= s->nice_match) break; | 758 | if (len >= nice_match) break; |
| 719 | #ifdef UNALIGNED_OK | 759 | #ifdef UNALIGNED_OK |
| 720 | scan_end = *(ushf*)(scan+best_len-1); | 760 | scan_end = *(ushf*)(scan+best_len-1); |
| 721 | #else | 761 | #else |
| @@ -726,7 +766,8 @@ local int longest_match(s, cur_match) | |||
| 726 | } while ((cur_match = prev[cur_match & wmask]) > limit | 766 | } while ((cur_match = prev[cur_match & wmask]) > limit |
| 727 | && --chain_length != 0); | 767 | && --chain_length != 0); |
| 728 | 768 | ||
| 729 | return best_len; | 769 | if ((uInt)best_len <= s->lookahead) return best_len; |
| 770 | return s->lookahead; | ||
| 730 | } | 771 | } |
| 731 | #endif /* ASMV */ | 772 | #endif /* ASMV */ |
| 732 | 773 | ||
| @@ -740,13 +781,13 @@ local void check_match(s, start, match, length) | |||
| 740 | int length; | 781 | int length; |
| 741 | { | 782 | { |
| 742 | /* check that the match is indeed a match */ | 783 | /* check that the match is indeed a match */ |
| 743 | if (memcmp((charf *)s->window + match, | 784 | if (zmemcmp((charf *)s->window + match, |
| 744 | (charf *)s->window + start, length) != EQUAL) { | 785 | (charf *)s->window + start, length) != EQUAL) { |
| 745 | fprintf(stderr, | 786 | fprintf(stderr, " start %u, match %u, length %d\n", |
| 746 | " start %u, match %u, length %d\n", | 787 | start, match, length); |
| 747 | start, match, length); | 788 | do { |
| 748 | do { fprintf(stderr, "%c%c", s->window[match++], | 789 | fprintf(stderr, "%c%c", s->window[match++], s->window[start++]); |
| 749 | s->window[start++]); } while (--length != 0); | 790 | } while (--length != 0); |
| 750 | z_error("invalid match"); | 791 | z_error("invalid match"); |
| 751 | } | 792 | } |
| 752 | if (verbose > 1) { | 793 | if (verbose > 1) { |
| @@ -862,9 +903,11 @@ local void fill_window(s) | |||
| 862 | * IN assertion: strstart is set to the end of the current match. | 903 | * IN assertion: strstart is set to the end of the current match. |
| 863 | */ | 904 | */ |
| 864 | #define FLUSH_BLOCK_ONLY(s, eof) { \ | 905 | #define FLUSH_BLOCK_ONLY(s, eof) { \ |
| 865 | tr_flush_block(s, (s->block_start >= 0L ? \ | 906 | _tr_flush_block(s, (s->block_start >= 0L ? \ |
| 866 | (charf *)&s->window[(unsigned)s->block_start] : \ | 907 | (charf *)&s->window[(unsigned)s->block_start] : \ |
| 867 | (charf *)Z_NULL), (long)s->strstart - s->block_start, (eof)); \ | 908 | (charf *)Z_NULL), \ |
| 909 | (ulg)((long)s->strstart - s->block_start), \ | ||
| 910 | (eof)); \ | ||
| 868 | s->block_start = s->strstart; \ | 911 | s->block_start = s->strstart; \ |
| 869 | flush_pending(s->strm); \ | 912 | flush_pending(s->strm); \ |
| 870 | Tracev((stderr,"[FLUSH]")); \ | 913 | Tracev((stderr,"[FLUSH]")); \ |
| @@ -906,7 +949,7 @@ local int deflate_stored(s, flush) | |||
| 906 | s->lookahead = 0; | 949 | s->lookahead = 0; |
| 907 | 950 | ||
| 908 | /* Stored blocks are limited to 0xffff bytes: */ | 951 | /* Stored blocks are limited to 0xffff bytes: */ |
| 909 | if (s->strstart == 0 || s->strstart > 0xffff) { | 952 | if (s->strstart == 0 || s->strstart > 0xfffe) { |
| 910 | /* strstart == 0 is possible when wraparound on 16-bit machine */ | 953 | /* strstart == 0 is possible when wraparound on 16-bit machine */ |
| 911 | s->lookahead = s->strstart - 0xffff; | 954 | s->lookahead = s->strstart - 0xffff; |
| 912 | s->strstart = 0xffff; | 955 | s->strstart = 0xffff; |
| @@ -967,14 +1010,12 @@ local int deflate_fast(s, flush) | |||
| 967 | s->match_length = longest_match (s, hash_head); | 1010 | s->match_length = longest_match (s, hash_head); |
| 968 | } | 1011 | } |
| 969 | /* longest_match() sets match_start */ | 1012 | /* longest_match() sets match_start */ |
| 970 | |||
| 971 | if (s->match_length > s->lookahead) s->match_length = s->lookahead; | ||
| 972 | } | 1013 | } |
| 973 | if (s->match_length >= MIN_MATCH) { | 1014 | if (s->match_length >= MIN_MATCH) { |
| 974 | check_match(s, s->strstart, s->match_start, s->match_length); | 1015 | check_match(s, s->strstart, s->match_start, s->match_length); |
| 975 | 1016 | ||
| 976 | bflush = tr_tally(s, s->strstart - s->match_start, | 1017 | bflush = _tr_tally(s, s->strstart - s->match_start, |
| 977 | s->match_length - MIN_MATCH); | 1018 | s->match_length - MIN_MATCH); |
| 978 | 1019 | ||
| 979 | s->lookahead -= s->match_length; | 1020 | s->lookahead -= s->match_length; |
| 980 | 1021 | ||
| @@ -1007,7 +1048,7 @@ local int deflate_fast(s, flush) | |||
| 1007 | } else { | 1048 | } else { |
| 1008 | /* No match, output a literal byte */ | 1049 | /* No match, output a literal byte */ |
| 1009 | Tracevv((stderr,"%c", s->window[s->strstart])); | 1050 | Tracevv((stderr,"%c", s->window[s->strstart])); |
| 1010 | bflush = tr_tally (s, 0, s->window[s->strstart]); | 1051 | bflush = _tr_tally (s, 0, s->window[s->strstart]); |
| 1011 | s->lookahead--; | 1052 | s->lookahead--; |
| 1012 | s->strstart++; | 1053 | s->strstart++; |
| 1013 | } | 1054 | } |
| @@ -1065,7 +1106,6 @@ local int deflate_slow(s, flush) | |||
| 1065 | s->match_length = longest_match (s, hash_head); | 1106 | s->match_length = longest_match (s, hash_head); |
| 1066 | } | 1107 | } |
| 1067 | /* longest_match() sets match_start */ | 1108 | /* longest_match() sets match_start */ |
| 1068 | if (s->match_length > s->lookahead) s->match_length = s->lookahead; | ||
| 1069 | 1109 | ||
| 1070 | if (s->match_length <= 5 && (s->strategy == Z_FILTERED || | 1110 | if (s->match_length <= 5 && (s->strategy == Z_FILTERED || |
| 1071 | (s->match_length == MIN_MATCH && | 1111 | (s->match_length == MIN_MATCH && |
| @@ -1086,8 +1126,8 @@ local int deflate_slow(s, flush) | |||
| 1086 | 1126 | ||
| 1087 | check_match(s, s->strstart-1, s->prev_match, s->prev_length); | 1127 | check_match(s, s->strstart-1, s->prev_match, s->prev_length); |
| 1088 | 1128 | ||
| 1089 | bflush = tr_tally(s, s->strstart -1 - s->prev_match, | 1129 | bflush = _tr_tally(s, s->strstart -1 - s->prev_match, |
| 1090 | s->prev_length - MIN_MATCH); | 1130 | s->prev_length - MIN_MATCH); |
| 1091 | 1131 | ||
| 1092 | /* Insert in hash table all strings up to the end of the match. | 1132 | /* Insert in hash table all strings up to the end of the match. |
| 1093 | * strstart-1 and strstart are already inserted. If there is not | 1133 | * strstart-1 and strstart are already inserted. If there is not |
| @@ -1113,7 +1153,7 @@ local int deflate_slow(s, flush) | |||
| 1113 | * is longer, truncate the previous match to a single literal. | 1153 | * is longer, truncate the previous match to a single literal. |
| 1114 | */ | 1154 | */ |
| 1115 | Tracevv((stderr,"%c", s->window[s->strstart-1])); | 1155 | Tracevv((stderr,"%c", s->window[s->strstart-1])); |
| 1116 | if (tr_tally (s, 0, s->window[s->strstart-1])) { | 1156 | if (_tr_tally (s, 0, s->window[s->strstart-1])) { |
| 1117 | FLUSH_BLOCK_ONLY(s, 0); | 1157 | FLUSH_BLOCK_ONLY(s, 0); |
| 1118 | } | 1158 | } |
| 1119 | s->strstart++; | 1159 | s->strstart++; |
| @@ -1131,7 +1171,7 @@ local int deflate_slow(s, flush) | |||
| 1131 | Assert (flush != Z_NO_FLUSH, "no flush?"); | 1171 | Assert (flush != Z_NO_FLUSH, "no flush?"); |
| 1132 | if (s->match_available) { | 1172 | if (s->match_available) { |
| 1133 | Tracevv((stderr,"%c", s->window[s->strstart-1])); | 1173 | Tracevv((stderr,"%c", s->window[s->strstart-1])); |
| 1134 | tr_tally (s, 0, s->window[s->strstart-1]); | 1174 | _tr_tally (s, 0, s->window[s->strstart-1]); |
| 1135 | s->match_available = 0; | 1175 | s->match_available = 0; |
| 1136 | } | 1176 | } |
| 1137 | FLUSH_BLOCK(s, flush == Z_FINISH); | 1177 | FLUSH_BLOCK(s, flush == Z_FINISH); |
| @@ -1,5 +1,5 @@ | |||
| 1 | /* deflate.h -- internal compression state | 1 | /* deflate.h -- internal compression state |
| 2 | * Copyright (C) 1995 Jean-loup Gailly | 2 | * Copyright (C) 1995-1996 Jean-loup Gailly |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| @@ -8,7 +8,10 @@ | |||
| 8 | subject to change. Applications should only use zlib.h. | 8 | subject to change. Applications should only use zlib.h. |
| 9 | */ | 9 | */ |
| 10 | 10 | ||
| 11 | /* $Id: deflate.h,v 1.5 1995/05/03 17:27:09 jloup Exp $ */ | 11 | /* $Id: deflate.h,v 1.9 1996/01/30 21:59:13 me Exp $ */ |
| 12 | |||
| 13 | #ifndef _DEFLATE_H | ||
| 14 | #define _DEFLATE_H | ||
| 12 | 15 | ||
| 13 | #include "zutil.h" | 16 | #include "zutil.h" |
| 14 | 17 | ||
| @@ -16,11 +19,6 @@ | |||
| 16 | * Internal compression state. | 19 | * Internal compression state. |
| 17 | */ | 20 | */ |
| 18 | 21 | ||
| 19 | /* Data type */ | ||
| 20 | #define BINARY 0 | ||
| 21 | #define ASCII 1 | ||
| 22 | #define UNKNOWN 2 | ||
| 23 | |||
| 24 | #define LENGTH_CODES 29 | 22 | #define LENGTH_CODES 29 |
| 25 | /* number of length codes, not counting the special END_BLOCK code */ | 23 | /* number of length codes, not counting the special END_BLOCK code */ |
| 26 | 24 | ||
| @@ -87,7 +85,6 @@ typedef struct internal_state { | |||
| 87 | Bytef *pending_buf; /* output still pending */ | 85 | Bytef *pending_buf; /* output still pending */ |
| 88 | Bytef *pending_out; /* next pending byte to output to the stream */ | 86 | Bytef *pending_out; /* next pending byte to output to the stream */ |
| 89 | int pending; /* nb of bytes in the pending buffer */ | 87 | int pending; /* nb of bytes in the pending buffer */ |
| 90 | uLong adler; /* adler32 of uncompressed data */ | ||
| 91 | int noheader; /* suppress zlib header and adler32 */ | 88 | int noheader; /* suppress zlib header and adler32 */ |
| 92 | Byte data_type; /* UNKNOWN, BINARY or ASCII */ | 89 | Byte data_type; /* UNKNOWN, BINARY or ASCII */ |
| 93 | Byte method; /* STORED (for zip only) or DEFLATED */ | 90 | Byte method; /* STORED (for zip only) or DEFLATED */ |
| @@ -268,9 +265,11 @@ typedef struct internal_state { | |||
| 268 | */ | 265 | */ |
| 269 | 266 | ||
| 270 | /* in trees.c */ | 267 | /* in trees.c */ |
| 271 | void tr_init OF((deflate_state *s)); | 268 | void _tr_init OF((deflate_state *s)); |
| 272 | int tr_tally OF((deflate_state *s, int dist, int lc)); | 269 | int _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc)); |
| 273 | ulg tr_flush_block OF((deflate_state *s, charf *buf, ulg stored_len, int eof)); | 270 | ulg _tr_flush_block OF((deflate_state *s, charf *buf, ulg stored_len, |
| 274 | void tr_align OF((deflate_state *s)); | 271 | int eof)); |
| 275 | void tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len, | 272 | void _tr_align OF((deflate_state *s)); |
| 276 | int eof)); | 273 | void _tr_stored_block OF((deflate_state *s, charf *buf, ulg stored_len, |
| 274 | int eof)); | ||
| 275 | #endif | ||
| @@ -1,9 +1,9 @@ | |||
| 1 | /* example.c -- usage example of the zlib compression library | 1 | /* example.c -- usage example of the zlib compression library |
| 2 | * Copyright (C) 1995 Jean-loup Gailly. | 2 | * Copyright (C) 1995-1996 Jean-loup Gailly. |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| 6 | /* $Id: example.c,v 1.9 1995/05/03 17:27:09 jloup Exp $ */ | 6 | /* $Id: example.c,v 1.13 1996/01/30 21:59:13 me Exp $ */ |
| 7 | 7 | ||
| 8 | #include <stdio.h> | 8 | #include <stdio.h> |
| 9 | #include "zlib.h" | 9 | #include "zlib.h" |
| @@ -22,38 +22,44 @@ | |||
| 22 | } \ | 22 | } \ |
| 23 | } | 23 | } |
| 24 | 24 | ||
| 25 | char *hello = "hello, hello!"; | 25 | const char hello[] = "hello, hello!"; |
| 26 | /* "hello world" would be more standard, but the repeated "hello" | 26 | /* "hello world" would be more standard, but the repeated "hello" |
| 27 | * stresses the compression code better, sorry... | 27 | * stresses the compression code better, sorry... |
| 28 | */ | 28 | */ |
| 29 | 29 | ||
| 30 | void test_compress OF((Bytef *compr, uLong comprLen, | 30 | const char dictionary[] = "hello"; |
| 31 | Bytef *uncompr, uLong uncomprLen)); | 31 | uLong dictId; /* Adler32 value of the dictionary */ |
| 32 | void test_gzio OF((char *out, char *in, | 32 | |
| 33 | Bytef *uncompr, int uncomprLen)); | 33 | void test_compress OF((Byte *compr, uLong comprLen, |
| 34 | void test_deflate OF((Bytef *compr, uLong comprLen)); | 34 | Byte *uncompr, uLong uncomprLen)); |
| 35 | void test_inflate OF((Bytef *compr, uLong comprLen, | 35 | void test_gzio OF((const char *out, const char *in, |
| 36 | Bytef *uncompr, uLong uncomprLen)); | 36 | Byte *uncompr, int uncomprLen)); |
| 37 | void test_large_deflate OF((Bytef *compr, uLong comprLen, | 37 | void test_deflate OF((Byte *compr, uLong comprLen)); |
| 38 | Bytef *uncompr, uLong uncomprLen)); | 38 | void test_inflate OF((Byte *compr, uLong comprLen, |
| 39 | void test_large_inflate OF((Bytef *compr, uLong comprLen, | 39 | Byte *uncompr, uLong uncomprLen)); |
| 40 | Bytef *uncompr, uLong uncomprLen)); | 40 | void test_large_deflate OF((Byte *compr, uLong comprLen, |
| 41 | void test_flush OF((Bytef *compr, uLong comprLen)); | 41 | Byte *uncompr, uLong uncomprLen)); |
| 42 | void test_sync OF((Bytef *compr, uLong comprLen, | 42 | void test_large_inflate OF((Byte *compr, uLong comprLen, |
| 43 | Bytef *uncompr, uLong uncomprLen)); | 43 | Byte *uncompr, uLong uncomprLen)); |
| 44 | void test_flush OF((Byte *compr, uLong comprLen)); | ||
| 45 | void test_sync OF((Byte *compr, uLong comprLen, | ||
| 46 | Byte *uncompr, uLong uncomprLen)); | ||
| 47 | void test_dict_deflate OF((Byte *compr, uLong comprLen)); | ||
| 48 | void test_dict_inflate OF((Byte *compr, uLong comprLen, | ||
| 49 | Byte *uncompr, uLong uncomprLen)); | ||
| 44 | int main OF((int argc, char *argv[])); | 50 | int main OF((int argc, char *argv[])); |
| 45 | 51 | ||
| 46 | /* =========================================================================== | 52 | /* =========================================================================== |
| 47 | * Test compress() and uncompress() | 53 | * Test compress() and uncompress() |
| 48 | */ | 54 | */ |
| 49 | void test_compress(compr, comprLen, uncompr, uncomprLen) | 55 | void test_compress(compr, comprLen, uncompr, uncomprLen) |
| 50 | Bytef *compr, *uncompr; | 56 | Byte *compr, *uncompr; |
| 51 | uLong comprLen, uncomprLen; | 57 | uLong comprLen, uncomprLen; |
| 52 | { | 58 | { |
| 53 | int err; | 59 | int err; |
| 54 | uLong len = strlen(hello)+1; | 60 | uLong len = strlen(hello)+1; |
| 55 | 61 | ||
| 56 | err = compress(compr, &comprLen, (Byte*)hello, len); | 62 | err = compress(compr, &comprLen, (const Bytef*)hello, len); |
| 57 | CHECK_ERR(err, "compress"); | 63 | CHECK_ERR(err, "compress"); |
| 58 | 64 | ||
| 59 | strcpy((char*)uncompr, "garbage"); | 65 | strcpy((char*)uncompr, "garbage"); |
| @@ -72,9 +78,9 @@ void test_compress(compr, comprLen, uncompr, uncomprLen) | |||
| 72 | * Test read/write of .gz files | 78 | * Test read/write of .gz files |
| 73 | */ | 79 | */ |
| 74 | void test_gzio(out, in, uncompr, uncomprLen) | 80 | void test_gzio(out, in, uncompr, uncomprLen) |
| 75 | char *out; /* output file */ | 81 | const char *out; /* output file */ |
| 76 | char *in; /* input file */ | 82 | const char *in; /* input file */ |
| 77 | Bytef *uncompr; | 83 | Byte *uncompr; |
| 78 | int uncomprLen; | 84 | int uncomprLen; |
| 79 | { | 85 | { |
| 80 | int err; | 86 | int err; |
| @@ -87,7 +93,7 @@ void test_gzio(out, in, uncompr, uncomprLen) | |||
| 87 | exit(1); | 93 | exit(1); |
| 88 | } | 94 | } |
| 89 | 95 | ||
| 90 | if (gzwrite(file, hello, len) != len) { | 96 | if (gzwrite(file, (const voidp)hello, (unsigned)len) != len) { |
| 91 | fprintf(stderr, "gzwrite err: %s\n", gzerror(file, &err)); | 97 | fprintf(stderr, "gzwrite err: %s\n", gzerror(file, &err)); |
| 92 | } | 98 | } |
| 93 | gzclose(file); | 99 | gzclose(file); |
| @@ -98,7 +104,7 @@ void test_gzio(out, in, uncompr, uncomprLen) | |||
| 98 | } | 104 | } |
| 99 | strcpy((char*)uncompr, "garbage"); | 105 | strcpy((char*)uncompr, "garbage"); |
| 100 | 106 | ||
| 101 | uncomprLen = gzread(file, uncompr, uncomprLen); | 107 | uncomprLen = gzread(file, uncompr, (unsigned)uncomprLen); |
| 102 | if (uncomprLen != len) { | 108 | if (uncomprLen != len) { |
| 103 | fprintf(stderr, "gzread err: %s\n", gzerror(file, &err)); | 109 | fprintf(stderr, "gzread err: %s\n", gzerror(file, &err)); |
| 104 | } | 110 | } |
| @@ -115,7 +121,7 @@ void test_gzio(out, in, uncompr, uncomprLen) | |||
| 115 | * Test deflate() with small buffers | 121 | * Test deflate() with small buffers |
| 116 | */ | 122 | */ |
| 117 | void test_deflate(compr, comprLen) | 123 | void test_deflate(compr, comprLen) |
| 118 | Bytef *compr; | 124 | Byte *compr; |
| 119 | uLong comprLen; | 125 | uLong comprLen; |
| 120 | { | 126 | { |
| 121 | z_stream c_stream; /* compression stream */ | 127 | z_stream c_stream; /* compression stream */ |
| @@ -153,7 +159,7 @@ void test_deflate(compr, comprLen) | |||
| 153 | * Test inflate() with small buffers | 159 | * Test inflate() with small buffers |
| 154 | */ | 160 | */ |
| 155 | void test_inflate(compr, comprLen, uncompr, uncomprLen) | 161 | void test_inflate(compr, comprLen, uncompr, uncomprLen) |
| 156 | Bytef *compr, *uncompr; | 162 | Byte *compr, *uncompr; |
| 157 | uLong comprLen, uncomprLen; | 163 | uLong comprLen, uncomprLen; |
| 158 | { | 164 | { |
| 159 | int err; | 165 | int err; |
| @@ -171,7 +177,7 @@ void test_inflate(compr, comprLen, uncompr, uncomprLen) | |||
| 171 | d_stream.next_in = compr; | 177 | d_stream.next_in = compr; |
| 172 | d_stream.next_out = uncompr; | 178 | d_stream.next_out = uncompr; |
| 173 | 179 | ||
| 174 | while (d_stream.total_out < uncomprLen) { | 180 | while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) { |
| 175 | d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */ | 181 | d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */ |
| 176 | err = inflate(&d_stream, Z_NO_FLUSH); | 182 | err = inflate(&d_stream, Z_NO_FLUSH); |
| 177 | if (err == Z_STREAM_END) break; | 183 | if (err == Z_STREAM_END) break; |
| @@ -192,7 +198,7 @@ void test_inflate(compr, comprLen, uncompr, uncomprLen) | |||
| 192 | * Test deflate() with large buffers and dynamic change of compression level | 198 | * Test deflate() with large buffers and dynamic change of compression level |
| 193 | */ | 199 | */ |
| 194 | void test_large_deflate(compr, comprLen, uncompr, uncomprLen) | 200 | void test_large_deflate(compr, comprLen, uncompr, uncomprLen) |
| 195 | Bytef *compr, *uncompr; | 201 | Byte *compr, *uncompr; |
| 196 | uLong comprLen, uncomprLen; | 202 | uLong comprLen, uncomprLen; |
| 197 | { | 203 | { |
| 198 | z_stream c_stream; /* compression stream */ | 204 | z_stream c_stream; /* compression stream */ |
| @@ -206,7 +212,7 @@ void test_large_deflate(compr, comprLen, uncompr, uncomprLen) | |||
| 206 | CHECK_ERR(err, "deflateInit"); | 212 | CHECK_ERR(err, "deflateInit"); |
| 207 | 213 | ||
| 208 | c_stream.next_out = compr; | 214 | c_stream.next_out = compr; |
| 209 | c_stream.avail_out = comprLen; | 215 | c_stream.avail_out = (uInt)comprLen; |
| 210 | 216 | ||
| 211 | /* At this point, uncompr is still mostly zeroes, so it should compress | 217 | /* At this point, uncompr is still mostly zeroes, so it should compress |
| 212 | * very well: | 218 | * very well: |
| @@ -245,7 +251,7 @@ void test_large_deflate(compr, comprLen, uncompr, uncomprLen) | |||
| 245 | * Test inflate() with large buffers | 251 | * Test inflate() with large buffers |
| 246 | */ | 252 | */ |
| 247 | void test_large_inflate(compr, comprLen, uncompr, uncomprLen) | 253 | void test_large_inflate(compr, comprLen, uncompr, uncomprLen) |
| 248 | Bytef *compr, *uncompr; | 254 | Byte *compr, *uncompr; |
| 249 | uLong comprLen, uncomprLen; | 255 | uLong comprLen, uncomprLen; |
| 250 | { | 256 | { |
| 251 | int err; | 257 | int err; |
| @@ -265,7 +271,7 @@ void test_large_inflate(compr, comprLen, uncompr, uncomprLen) | |||
| 265 | 271 | ||
| 266 | for (;;) { | 272 | for (;;) { |
| 267 | d_stream.next_out = uncompr; /* discard the output */ | 273 | d_stream.next_out = uncompr; /* discard the output */ |
| 268 | d_stream.avail_out = uncomprLen; | 274 | d_stream.avail_out = (uInt)uncomprLen; |
| 269 | err = inflate(&d_stream, Z_NO_FLUSH); | 275 | err = inflate(&d_stream, Z_NO_FLUSH); |
| 270 | if (err == Z_STREAM_END) break; | 276 | if (err == Z_STREAM_END) break; |
| 271 | CHECK_ERR(err, "large inflate"); | 277 | CHECK_ERR(err, "large inflate"); |
| @@ -285,7 +291,7 @@ void test_large_inflate(compr, comprLen, uncompr, uncomprLen) | |||
| 285 | * Test deflate() with full flush | 291 | * Test deflate() with full flush |
| 286 | */ | 292 | */ |
| 287 | void test_flush(compr, comprLen) | 293 | void test_flush(compr, comprLen) |
| 288 | Bytef *compr; | 294 | Byte *compr; |
| 289 | uLong comprLen; | 295 | uLong comprLen; |
| 290 | { | 296 | { |
| 291 | z_stream c_stream; /* compression stream */ | 297 | z_stream c_stream; /* compression stream */ |
| @@ -321,7 +327,7 @@ void test_flush(compr, comprLen) | |||
| 321 | * Test inflateSync() | 327 | * Test inflateSync() |
| 322 | */ | 328 | */ |
| 323 | void test_sync(compr, comprLen, uncompr, uncomprLen) | 329 | void test_sync(compr, comprLen, uncompr, uncomprLen) |
| 324 | Bytef *compr, *uncompr; | 330 | Byte *compr, *uncompr; |
| 325 | uLong comprLen, uncomprLen; | 331 | uLong comprLen, uncomprLen; |
| 326 | { | 332 | { |
| 327 | int err; | 333 | int err; |
| @@ -344,7 +350,7 @@ void test_sync(compr, comprLen, uncompr, uncomprLen) | |||
| 344 | inflate(&d_stream, Z_NO_FLUSH); | 350 | inflate(&d_stream, Z_NO_FLUSH); |
| 345 | CHECK_ERR(err, "inflate"); | 351 | CHECK_ERR(err, "inflate"); |
| 346 | 352 | ||
| 347 | d_stream.avail_in = (uInt)uncomprLen-2; /* read all compressed data */ | 353 | d_stream.avail_in = (uInt)comprLen-2; /* read all compressed data */ |
| 348 | err = inflateSync(&d_stream); /* but skip the damaged part */ | 354 | err = inflateSync(&d_stream); /* but skip the damaged part */ |
| 349 | CHECK_ERR(err, "inflateSync"); | 355 | CHECK_ERR(err, "inflateSync"); |
| 350 | 356 | ||
| @@ -360,6 +366,91 @@ void test_sync(compr, comprLen, uncompr, uncomprLen) | |||
| 360 | } | 366 | } |
| 361 | 367 | ||
| 362 | /* =========================================================================== | 368 | /* =========================================================================== |
| 369 | * Test deflate() with preset dictionary | ||
| 370 | */ | ||
| 371 | void test_dict_deflate(compr, comprLen) | ||
| 372 | Byte *compr; | ||
| 373 | uLong comprLen; | ||
| 374 | { | ||
| 375 | z_stream c_stream; /* compression stream */ | ||
| 376 | int err; | ||
| 377 | |||
| 378 | c_stream.zalloc = (alloc_func)0; | ||
| 379 | c_stream.zfree = (free_func)0; | ||
| 380 | c_stream.opaque = (voidpf)0; | ||
| 381 | |||
| 382 | err = deflateInit(&c_stream, Z_BEST_COMPRESSION); | ||
| 383 | CHECK_ERR(err, "deflateInit"); | ||
| 384 | |||
| 385 | err = deflateSetDictionary(&c_stream, | ||
| 386 | (const Bytef*)dictionary, sizeof(dictionary)); | ||
| 387 | CHECK_ERR(err, "deflateSetDictionary"); | ||
| 388 | |||
| 389 | dictId = c_stream.adler; | ||
| 390 | c_stream.next_out = compr; | ||
| 391 | c_stream.avail_out = (uInt)comprLen; | ||
| 392 | |||
| 393 | c_stream.next_in = (Bytef*)hello; | ||
| 394 | c_stream.avail_in = (uInt)strlen(hello)+1; | ||
| 395 | |||
| 396 | err = deflate(&c_stream, Z_FINISH); | ||
| 397 | if (err != Z_STREAM_END) { | ||
| 398 | fprintf(stderr, "deflate should report Z_STREAM_END\n"); | ||
| 399 | } | ||
| 400 | err = deflateEnd(&c_stream); | ||
| 401 | CHECK_ERR(err, "deflateEnd"); | ||
| 402 | } | ||
| 403 | |||
| 404 | /* =========================================================================== | ||
| 405 | * Test inflate() with a preset dictionary | ||
| 406 | */ | ||
| 407 | void test_dict_inflate(compr, comprLen, uncompr, uncomprLen) | ||
| 408 | Byte *compr, *uncompr; | ||
| 409 | uLong comprLen, uncomprLen; | ||
| 410 | { | ||
| 411 | int err; | ||
| 412 | z_stream d_stream; /* decompression stream */ | ||
| 413 | |||
| 414 | strcpy((char*)uncompr, "garbage"); | ||
| 415 | |||
| 416 | d_stream.zalloc = (alloc_func)0; | ||
| 417 | d_stream.zfree = (free_func)0; | ||
| 418 | d_stream.opaque = (voidpf)0; | ||
| 419 | |||
| 420 | err = inflateInit(&d_stream); | ||
| 421 | CHECK_ERR(err, "inflateInit"); | ||
| 422 | |||
| 423 | d_stream.next_in = compr; | ||
| 424 | d_stream.avail_in = (uInt)comprLen; | ||
| 425 | |||
| 426 | d_stream.next_out = uncompr; | ||
| 427 | d_stream.avail_out = (uInt)uncomprLen; | ||
| 428 | |||
| 429 | for (;;) { | ||
| 430 | err = inflate(&d_stream, Z_NO_FLUSH); | ||
| 431 | if (err == Z_STREAM_END) break; | ||
| 432 | if (err == Z_NEED_DICT) { | ||
| 433 | if (d_stream.adler != dictId) { | ||
| 434 | fprintf(stderr, "unexpected dictionary"); | ||
| 435 | exit(1); | ||
| 436 | } | ||
| 437 | err = inflateSetDictionary(&d_stream, (const Bytef*)dictionary, | ||
| 438 | sizeof(dictionary)); | ||
| 439 | } | ||
| 440 | CHECK_ERR(err, "inflate with dict"); | ||
| 441 | } | ||
| 442 | |||
| 443 | err = inflateEnd(&d_stream); | ||
| 444 | CHECK_ERR(err, "inflateEnd"); | ||
| 445 | |||
| 446 | if (strcmp((char*)uncompr, hello)) { | ||
| 447 | fprintf(stderr, "bad inflate with dict\n"); | ||
| 448 | } else { | ||
| 449 | printf("inflate with dictionary: %s\n", uncompr); | ||
| 450 | } | ||
| 451 | } | ||
| 452 | |||
| 453 | /* =========================================================================== | ||
| 363 | * Usage: example [output.gz [input.gz]] | 454 | * Usage: example [output.gz [input.gz]] |
| 364 | */ | 455 | */ |
| 365 | 456 | ||
| @@ -367,8 +458,8 @@ int main(argc, argv) | |||
| 367 | int argc; | 458 | int argc; |
| 368 | char *argv[]; | 459 | char *argv[]; |
| 369 | { | 460 | { |
| 370 | Bytef *compr, *uncompr; | 461 | Byte *compr, *uncompr; |
| 371 | uLong comprLen = 32750*sizeof(int); /* don't overflow on MSDOS */ | 462 | uLong comprLen = 10000*sizeof(int); /* don't overflow on MSDOS */ |
| 372 | uLong uncomprLen = comprLen; | 463 | uLong uncomprLen = comprLen; |
| 373 | 464 | ||
| 374 | if (zlib_version[0] != ZLIB_VERSION[0]) { | 465 | if (zlib_version[0] != ZLIB_VERSION[0]) { |
| @@ -379,8 +470,8 @@ int main(argc, argv) | |||
| 379 | fprintf(stderr, "warning: different zlib version\n"); | 470 | fprintf(stderr, "warning: different zlib version\n"); |
| 380 | } | 471 | } |
| 381 | 472 | ||
| 382 | compr = (Bytef*)malloc(comprLen); | 473 | compr = (Byte*)malloc((uInt)comprLen); |
| 383 | uncompr = (Bytef*)calloc(uncomprLen, 1); /* must be cleared initially */ | 474 | uncompr = (Byte*)calloc((uInt)uncomprLen, 1); /* must be cleared */ |
| 384 | if (compr == Z_NULL || uncompr == Z_NULL) { | 475 | if (compr == Z_NULL || uncompr == Z_NULL) { |
| 385 | printf("out of memory\n"); | 476 | printf("out of memory\n"); |
| 386 | exit(1); | 477 | exit(1); |
| @@ -401,6 +492,9 @@ int main(argc, argv) | |||
| 401 | test_flush(compr, comprLen); | 492 | test_flush(compr, comprLen); |
| 402 | test_sync(compr, comprLen, uncompr, uncomprLen); | 493 | test_sync(compr, comprLen, uncompr, uncomprLen); |
| 403 | 494 | ||
| 495 | test_dict_deflate(compr, comprLen); | ||
| 496 | test_dict_inflate(compr, comprLen, uncompr, uncomprLen); | ||
| 497 | |||
| 404 | exit(0); | 498 | exit(0); |
| 405 | return 0; /* to avoid warning */ | 499 | return 0; /* to avoid warning */ |
| 406 | } | 500 | } |
| @@ -1,9 +1,9 @@ | |||
| 1 | /* gzio.c -- IO on .gz files | 1 | /* gzio.c -- IO on .gz files |
| 2 | * Copyright (C) 1995 Jean-loup Gailly. | 2 | * Copyright (C) 1995-1996 Jean-loup Gailly. |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| 6 | /* $Id: gzio.c,v 1.8 1995/05/03 17:27:09 jloup Exp $ */ | 6 | /* $Id: gzio.c,v 1.12 1996/01/30 21:59:14 me Exp $ */ |
| 7 | 7 | ||
| 8 | #include <stdio.h> | 8 | #include <stdio.h> |
| 9 | 9 | ||
| @@ -16,8 +16,7 @@ struct internal_state {int dummy;}; /* for buggy compilers */ | |||
| 16 | #define ALLOC(size) malloc(size) | 16 | #define ALLOC(size) malloc(size) |
| 17 | #define TRYFREE(p) {if (p) free(p);} | 17 | #define TRYFREE(p) {if (p) free(p);} |
| 18 | 18 | ||
| 19 | #define GZ_MAGIC_1 0x1f | 19 | static int gz_magic[2] = {0x1f, 0x8b}; /* gzip magic header */ |
| 20 | #define GZ_MAGIC_2 0x8b | ||
| 21 | 20 | ||
| 22 | /* gzip flag byte */ | 21 | /* gzip flag byte */ |
| 23 | #define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ | 22 | #define ASCII_FLAG 0x01 /* bit 0 set: file probably ascii text */ |
| @@ -27,10 +26,6 @@ struct internal_state {int dummy;}; /* for buggy compilers */ | |||
| 27 | #define COMMENT 0x10 /* bit 4 set: file comment present */ | 26 | #define COMMENT 0x10 /* bit 4 set: file comment present */ |
| 28 | #define RESERVED 0xE0 /* bits 5..7: reserved */ | 27 | #define RESERVED 0xE0 /* bits 5..7: reserved */ |
| 29 | 28 | ||
| 30 | #ifndef SEEK_CUR | ||
| 31 | # define SEEK_CUR 1 | ||
| 32 | #endif | ||
| 33 | |||
| 34 | typedef struct gz_stream { | 29 | typedef struct gz_stream { |
| 35 | z_stream stream; | 30 | z_stream stream; |
| 36 | int z_err; /* error code for last stream operation */ | 31 | int z_err; /* error code for last stream operation */ |
| @@ -46,40 +41,12 @@ typedef struct gz_stream { | |||
| 46 | } gz_stream; | 41 | } gz_stream; |
| 47 | 42 | ||
| 48 | 43 | ||
| 49 | local int destroy OF((gz_stream *s)); | 44 | local gzFile gz_open OF((const char *path, const char *mode, int fd)); |
| 50 | local gzFile gz_open OF((char *path, char *mode, int fd)); | 45 | local int get_byte OF((gz_stream *s)); |
| 51 | local void putLong OF((FILE *file, uLong x)); | 46 | local void check_header OF((gz_stream *s)); |
| 52 | local uLong getLong OF((Bytef *buf)); | 47 | local int destroy OF((gz_stream *s)); |
| 53 | 48 | local void putLong OF((FILE *file, uLong x)); | |
| 54 | /* =========================================================================== | 49 | local uLong getLong OF((gz_stream *s)); |
| 55 | * Cleanup then free the given gz_stream. Return a zlib error code. | ||
| 56 | */ | ||
| 57 | local int destroy (s) | ||
| 58 | gz_stream *s; | ||
| 59 | { | ||
| 60 | int err = Z_OK; | ||
| 61 | |||
| 62 | if (!s) return Z_STREAM_ERROR; | ||
| 63 | |||
| 64 | TRYFREE(s->inbuf); | ||
| 65 | TRYFREE(s->outbuf); | ||
| 66 | TRYFREE(s->path); | ||
| 67 | TRYFREE(s->msg); | ||
| 68 | |||
| 69 | if (s->stream.state != NULL) { | ||
| 70 | if (s->mode == 'w') { | ||
| 71 | err = deflateEnd(&(s->stream)); | ||
| 72 | } else if (s->mode == 'r') { | ||
| 73 | err = inflateEnd(&(s->stream)); | ||
| 74 | } | ||
| 75 | } | ||
| 76 | if (s->file != NULL && fclose(s->file)) { | ||
| 77 | err = Z_ERRNO; | ||
| 78 | } | ||
| 79 | if (s->z_err < 0) err = s->z_err; | ||
| 80 | TRYFREE(s); | ||
| 81 | return err; | ||
| 82 | } | ||
| 83 | 50 | ||
| 84 | /* =========================================================================== | 51 | /* =========================================================================== |
| 85 | Opens a gzip (.gz) file for reading or writing. The mode parameter | 52 | Opens a gzip (.gz) file for reading or writing. The mode parameter |
| @@ -91,15 +58,20 @@ local int destroy (s) | |||
| 91 | zlib error is Z_MEM_ERROR). | 58 | zlib error is Z_MEM_ERROR). |
| 92 | */ | 59 | */ |
| 93 | local gzFile gz_open (path, mode, fd) | 60 | local gzFile gz_open (path, mode, fd) |
| 94 | char *path; | 61 | const char *path; |
| 95 | char *mode; | 62 | const char *mode; |
| 96 | int fd; | 63 | int fd; |
| 97 | { | 64 | { |
| 98 | int err; | 65 | int err; |
| 99 | int level = Z_DEFAULT_COMPRESSION; /* compression level */ | 66 | int level = Z_DEFAULT_COMPRESSION; /* compression level */ |
| 100 | char *p = mode; | 67 | char *p = (char*)mode; |
| 101 | gz_stream *s = (gz_stream *)ALLOC(sizeof(gz_stream)); | 68 | gz_stream *s; |
| 69 | char fmode[80]; /* copy of mode, without the compression level */ | ||
| 70 | char *m = fmode; | ||
| 71 | |||
| 72 | if (!path || !mode) return Z_NULL; | ||
| 102 | 73 | ||
| 74 | s = (gz_stream *)ALLOC(sizeof(gz_stream)); | ||
| 103 | if (!s) return Z_NULL; | 75 | if (!s) return Z_NULL; |
| 104 | 76 | ||
| 105 | s->stream.zalloc = (alloc_func)0; | 77 | s->stream.zalloc = (alloc_func)0; |
| @@ -124,9 +96,13 @@ local gzFile gz_open (path, mode, fd) | |||
| 124 | s->mode = '\0'; | 96 | s->mode = '\0'; |
| 125 | do { | 97 | do { |
| 126 | if (*p == 'r') s->mode = 'r'; | 98 | if (*p == 'r') s->mode = 'r'; |
| 127 | if (*p == 'w') s->mode = 'w'; | 99 | if (*p == 'w' || *p == 'a') s->mode = 'w'; |
| 128 | if (*p >= '1' && *p <= '9') level = *p - '0'; | 100 | if (*p >= '0' && *p <= '9') { |
| 129 | } while (*p++); | 101 | level = *p - '0'; |
| 102 | } else { | ||
| 103 | *m++ = *p; /* copy the mode */ | ||
| 104 | } | ||
| 105 | } while (*p++ && m != fmode + sizeof(fmode)); | ||
| 130 | if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL; | 106 | if (s->mode == '\0') return destroy(s), (gzFile)Z_NULL; |
| 131 | 107 | ||
| 132 | if (s->mode == 'w') { | 108 | if (s->mode == 'w') { |
| @@ -150,7 +126,7 @@ local gzFile gz_open (path, mode, fd) | |||
| 150 | s->stream.avail_out = Z_BUFSIZE; | 126 | s->stream.avail_out = Z_BUFSIZE; |
| 151 | 127 | ||
| 152 | errno = 0; | 128 | errno = 0; |
| 153 | s->file = fd < 0 ? FOPEN(path, mode) : (FILE*)fdopen(fd, mode); | 129 | s->file = fd < 0 ? FOPEN(path, fmode) : (FILE*)fdopen(fd, fmode); |
| 154 | 130 | ||
| 155 | if (s->file == NULL) { | 131 | if (s->file == NULL) { |
| 156 | return destroy(s), (gzFile)Z_NULL; | 132 | return destroy(s), (gzFile)Z_NULL; |
| @@ -158,50 +134,10 @@ local gzFile gz_open (path, mode, fd) | |||
| 158 | if (s->mode == 'w') { | 134 | if (s->mode == 'w') { |
| 159 | /* Write a very simple .gz header: | 135 | /* Write a very simple .gz header: |
| 160 | */ | 136 | */ |
| 161 | fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", GZ_MAGIC_1, GZ_MAGIC_2, | 137 | fprintf(s->file, "%c%c%c%c%c%c%c%c%c%c", gz_magic[0], gz_magic[1], |
| 162 | Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE); | 138 | Z_DEFLATED, 0 /*flags*/, 0,0,0,0 /*time*/, 0 /*xflags*/, OS_CODE); |
| 163 | } else { | 139 | } else { |
| 164 | /* Check and skip the header: | 140 | check_header(s); /* skip the .gz header */ |
| 165 | */ | ||
| 166 | Byte c1 = 0, c2 = 0; | ||
| 167 | Byte method = 0; | ||
| 168 | Byte flags = 0; | ||
| 169 | Byte xflags = 0; | ||
| 170 | Byte time[4]; | ||
| 171 | Byte osCode; | ||
| 172 | int c; | ||
| 173 | |||
| 174 | s->stream.avail_in = fread(s->inbuf, 1, 2, s->file); | ||
| 175 | if (s->stream.avail_in != 2 || s->inbuf[0] != GZ_MAGIC_1 | ||
| 176 | || s->inbuf[1] != GZ_MAGIC_2) { | ||
| 177 | s->transparent = 1; | ||
| 178 | return (gzFile)s; | ||
| 179 | } | ||
| 180 | s->stream.avail_in = 0; | ||
| 181 | fscanf(s->file,"%c%c%4c%c%c", &method, &flags, time, &xflags, &osCode); | ||
| 182 | |||
| 183 | if (method != Z_DEFLATED || feof(s->file) || (flags & RESERVED) != 0) { | ||
| 184 | s->z_err = Z_DATA_ERROR; | ||
| 185 | return (gzFile)s; | ||
| 186 | } | ||
| 187 | if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */ | ||
| 188 | long len; | ||
| 189 | fscanf(s->file, "%c%c", &c1, &c2); | ||
| 190 | len = c1 + ((long)c2<<8); | ||
| 191 | fseek(s->file, len, SEEK_CUR); | ||
| 192 | } | ||
| 193 | if ((flags & ORIG_NAME) != 0) { /* skip the original file name */ | ||
| 194 | while ((c = getc(s->file)) != 0 && c != EOF) ; | ||
| 195 | } | ||
| 196 | if ((flags & COMMENT) != 0) { /* skip the .gz file comment */ | ||
| 197 | while ((c = getc(s->file)) != 0 && c != EOF) ; | ||
| 198 | } | ||
| 199 | if ((flags & HEAD_CRC) != 0) { /* skip the header crc */ | ||
| 200 | fscanf(s->file, "%c%c", &c1, &c2); | ||
| 201 | } | ||
| 202 | if (feof(s->file)) { | ||
| 203 | s->z_err = Z_DATA_ERROR; | ||
| 204 | } | ||
| 205 | } | 141 | } |
| 206 | return (gzFile)s; | 142 | return (gzFile)s; |
| 207 | } | 143 | } |
| @@ -210,26 +146,139 @@ local gzFile gz_open (path, mode, fd) | |||
| 210 | Opens a gzip (.gz) file for reading or writing. | 146 | Opens a gzip (.gz) file for reading or writing. |
| 211 | */ | 147 | */ |
| 212 | gzFile gzopen (path, mode) | 148 | gzFile gzopen (path, mode) |
| 213 | char *path; | 149 | const char *path; |
| 214 | char *mode; | 150 | const char *mode; |
| 215 | { | 151 | { |
| 216 | return gz_open (path, mode, -1); | 152 | return gz_open (path, mode, -1); |
| 217 | } | 153 | } |
| 218 | 154 | ||
| 219 | /* =========================================================================== | 155 | /* =========================================================================== |
| 220 | Associate a gzFile with the file descriptor fd. | 156 | Associate a gzFile with the file descriptor fd. fd is not dup'ed here |
| 157 | to mimic the behavio(u)r of fdopen. | ||
| 221 | */ | 158 | */ |
| 222 | gzFile gzdopen (fd, mode) | 159 | gzFile gzdopen (fd, mode) |
| 223 | int fd; | 160 | int fd; |
| 224 | char *mode; | 161 | const char *mode; |
| 225 | { | 162 | { |
| 226 | char name[20]; | 163 | char name[20]; |
| 164 | |||
| 165 | if (fd < 0) return (gzFile)Z_NULL; | ||
| 227 | sprintf(name, "<fd:%d>", fd); /* for debugging */ | 166 | sprintf(name, "<fd:%d>", fd); /* for debugging */ |
| 228 | 167 | ||
| 229 | return gz_open (name, mode, fd); | 168 | return gz_open (name, mode, fd); |
| 230 | } | 169 | } |
| 231 | 170 | ||
| 232 | /* =========================================================================== | 171 | /* =========================================================================== |
| 172 | Read a byte from a gz_stream; update next_in and avail_in. Return EOF | ||
| 173 | for end of file. | ||
| 174 | IN assertion: the stream s has been sucessfully opened for reading. | ||
| 175 | */ | ||
| 176 | local int get_byte(s) | ||
| 177 | gz_stream *s; | ||
| 178 | { | ||
| 179 | if (s->z_eof) return EOF; | ||
| 180 | if (s->stream.avail_in == 0) { | ||
| 181 | errno = 0; | ||
| 182 | s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file); | ||
| 183 | if (s->stream.avail_in == 0) { | ||
| 184 | s->z_eof = 1; | ||
| 185 | if (ferror(s->file)) s->z_err = Z_ERRNO; | ||
| 186 | return EOF; | ||
| 187 | } | ||
| 188 | s->stream.next_in = s->inbuf; | ||
| 189 | } | ||
| 190 | s->stream.avail_in--; | ||
| 191 | return *(s->stream.next_in)++; | ||
| 192 | } | ||
| 193 | |||
| 194 | /* =========================================================================== | ||
| 195 | Check the gzip header of a gz_stream opened for reading. Set the stream | ||
| 196 | mode to transparent if the gzip magic header is not present; set s->err | ||
| 197 | to Z_DATA_ERROR if the magic header is present but the rest of the header | ||
| 198 | is incorrect. | ||
| 199 | IN assertion: the stream s has already been created sucessfully; | ||
| 200 | s->stream.avail_in is zero for the first time, but may be non-zero | ||
| 201 | for concatenated .gz files. | ||
| 202 | */ | ||
| 203 | local void check_header(s) | ||
| 204 | gz_stream *s; | ||
| 205 | { | ||
| 206 | int method; /* method byte */ | ||
| 207 | int flags; /* flags byte */ | ||
| 208 | uInt len; | ||
| 209 | int c; | ||
| 210 | |||
| 211 | /* Check the gzip magic header */ | ||
| 212 | for (len = 0; len < 2; len++) { | ||
| 213 | c = get_byte(s); | ||
| 214 | if (c != gz_magic[len]) { | ||
| 215 | s->transparent = 1; | ||
| 216 | if (c != EOF) s->stream.avail_in++, s->stream.next_in--; | ||
| 217 | s->z_err = s->stream.avail_in != 0 ? Z_OK : Z_STREAM_END; | ||
| 218 | return; | ||
| 219 | } | ||
| 220 | } | ||
| 221 | method = get_byte(s); | ||
| 222 | flags = get_byte(s); | ||
| 223 | if (method != Z_DEFLATED || (flags & RESERVED) != 0) { | ||
| 224 | s->z_err = Z_DATA_ERROR; | ||
| 225 | return; | ||
| 226 | } | ||
| 227 | |||
| 228 | /* Discard time, xflags and OS code: */ | ||
| 229 | for (len = 0; len < 6; len++) (void)get_byte(s); | ||
| 230 | |||
| 231 | if ((flags & EXTRA_FIELD) != 0) { /* skip the extra field */ | ||
| 232 | len = (uInt)get_byte(s); | ||
| 233 | len += ((uInt)get_byte(s))<<8; | ||
| 234 | /* len is garbage if EOF but the loop below will quit anyway */ | ||
| 235 | while (len-- != 0 && get_byte(s) != EOF) ; | ||
| 236 | } | ||
| 237 | if ((flags & ORIG_NAME) != 0) { /* skip the original file name */ | ||
| 238 | while ((c = get_byte(s)) != 0 && c != EOF) ; | ||
| 239 | } | ||
| 240 | if ((flags & COMMENT) != 0) { /* skip the .gz file comment */ | ||
| 241 | while ((c = get_byte(s)) != 0 && c != EOF) ; | ||
| 242 | } | ||
| 243 | if ((flags & HEAD_CRC) != 0) { /* skip the header crc */ | ||
| 244 | for (len = 0; len < 2; len++) (void)get_byte(s); | ||
| 245 | } | ||
| 246 | s->z_err = s->z_eof ? Z_DATA_ERROR : Z_OK; | ||
| 247 | } | ||
| 248 | |||
| 249 | /* =========================================================================== | ||
| 250 | * Cleanup then free the given gz_stream. Return a zlib error code. | ||
| 251 | Try freeing in the reverse order of allocations. | ||
| 252 | */ | ||
| 253 | local int destroy (s) | ||
| 254 | gz_stream *s; | ||
| 255 | { | ||
| 256 | int err = Z_OK; | ||
| 257 | |||
| 258 | if (!s) return Z_STREAM_ERROR; | ||
| 259 | |||
| 260 | TRYFREE(s->msg); | ||
| 261 | |||
| 262 | if (s->stream.state != NULL) { | ||
| 263 | if (s->mode == 'w') { | ||
| 264 | err = deflateEnd(&(s->stream)); | ||
| 265 | } else if (s->mode == 'r') { | ||
| 266 | err = inflateEnd(&(s->stream)); | ||
| 267 | } | ||
| 268 | } | ||
| 269 | if (s->file != NULL && fclose(s->file)) { | ||
| 270 | err = Z_ERRNO; | ||
| 271 | } | ||
| 272 | if (s->z_err < 0) err = s->z_err; | ||
| 273 | |||
| 274 | TRYFREE(s->inbuf); | ||
| 275 | TRYFREE(s->outbuf); | ||
| 276 | TRYFREE(s->path); | ||
| 277 | TRYFREE(s); | ||
| 278 | return err; | ||
| 279 | } | ||
| 280 | |||
| 281 | /* =========================================================================== | ||
| 233 | Reads the given number of uncompressed bytes from the compressed file. | 282 | Reads the given number of uncompressed bytes from the compressed file. |
| 234 | gzread returns the number of bytes actually read (0 for end of file). | 283 | gzread returns the number of bytes actually read (0 for end of file). |
| 235 | */ | 284 | */ |
| @@ -239,52 +288,73 @@ int gzread (file, buf, len) | |||
| 239 | unsigned len; | 288 | unsigned len; |
| 240 | { | 289 | { |
| 241 | gz_stream *s = (gz_stream*)file; | 290 | gz_stream *s = (gz_stream*)file; |
| 291 | Bytef *start = buf; /* starting point for crc computation */ | ||
| 292 | Byte *next_out; /* == stream.next_out but not forced far (for MSDOS) */ | ||
| 242 | 293 | ||
| 243 | if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR; | 294 | if (s == NULL || s->mode != 'r') return Z_STREAM_ERROR; |
| 244 | 295 | ||
| 245 | if (s->transparent) { | 296 | if (s->z_err == Z_DATA_ERROR || s->z_err == Z_ERRNO) return -1; |
| 246 | int n = 0; | 297 | if (s->z_err == Z_STREAM_END) return 0; /* EOF */ |
| 247 | Byte *b = (Byte*)buf; | ||
| 248 | /* Copy the first two (non-magic) bytes if not done already */ | ||
| 249 | while (s->stream.avail_in > 0 && len > 0) { | ||
| 250 | *b++ = *s->stream.next_in++; | ||
| 251 | s->stream.avail_in--; | ||
| 252 | len--; n++; | ||
| 253 | } | ||
| 254 | if (len == 0) return n; | ||
| 255 | return n + fread(b, 1, len, s->file); | ||
| 256 | } | ||
| 257 | if (s->z_err == Z_DATA_ERROR) return -1; /* bad .gz file */ | ||
| 258 | if (s->z_err == Z_STREAM_END) return 0; /* don't read crc as data */ | ||
| 259 | 298 | ||
| 260 | s->stream.next_out = buf; | 299 | s->stream.next_out = next_out = buf; |
| 261 | s->stream.avail_out = len; | 300 | s->stream.avail_out = len; |
| 262 | 301 | ||
| 263 | while (s->stream.avail_out != 0) { | 302 | while (s->stream.avail_out != 0) { |
| 264 | 303 | ||
| 304 | if (s->transparent) { | ||
| 305 | /* Copy first the lookahead bytes: */ | ||
| 306 | uInt n = s->stream.avail_in; | ||
| 307 | if (n > s->stream.avail_out) n = s->stream.avail_out; | ||
| 308 | if (n > 0) { | ||
| 309 | zmemcpy(s->stream.next_out, s->stream.next_in, n); | ||
| 310 | next_out += n; | ||
| 311 | s->stream.next_out = next_out; | ||
| 312 | s->stream.next_in += n; | ||
| 313 | s->stream.avail_out -= n; | ||
| 314 | s->stream.avail_in -= n; | ||
| 315 | } | ||
| 316 | if (s->stream.avail_out > 0) { | ||
| 317 | s->stream.avail_out -= fread(next_out, 1, s->stream.avail_out, | ||
| 318 | s->file); | ||
| 319 | } | ||
| 320 | return (int)(len - s->stream.avail_out); | ||
| 321 | } | ||
| 265 | if (s->stream.avail_in == 0 && !s->z_eof) { | 322 | if (s->stream.avail_in == 0 && !s->z_eof) { |
| 266 | 323 | ||
| 267 | errno = 0; | 324 | errno = 0; |
| 268 | s->stream.avail_in = | 325 | s->stream.avail_in = fread(s->inbuf, 1, Z_BUFSIZE, s->file); |
| 269 | fread(s->inbuf, 1, Z_BUFSIZE, s->file); | ||
| 270 | if (s->stream.avail_in == 0) { | 326 | if (s->stream.avail_in == 0) { |
| 271 | s->z_eof = 1; | 327 | s->z_eof = 1; |
| 272 | } else if (s->stream.avail_in == (uInt)EOF) { | 328 | if (ferror(s->file)) { |
| 273 | s->stream.avail_in = 0; | 329 | s->z_err = Z_ERRNO; |
| 274 | s->z_eof = 1; | 330 | break; |
| 275 | s->z_err = Z_ERRNO; | 331 | } |
| 276 | break; | ||
| 277 | } | 332 | } |
| 278 | s->stream.next_in = s->inbuf; | 333 | s->stream.next_in = s->inbuf; |
| 279 | } | 334 | } |
| 280 | s->z_err = inflate(&(s->stream), Z_NO_FLUSH); | 335 | s->z_err = inflate(&(s->stream), Z_NO_FLUSH); |
| 281 | 336 | ||
| 282 | if (s->z_err == Z_STREAM_END || | 337 | if (s->z_err == Z_STREAM_END) { |
| 283 | s->z_err != Z_OK || s->z_eof) break; | 338 | /* Check CRC and original size */ |
| 339 | s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start)); | ||
| 340 | start = s->stream.next_out; | ||
| 341 | |||
| 342 | if (getLong(s) != s->crc || getLong(s) != s->stream.total_out) { | ||
| 343 | s->z_err = Z_DATA_ERROR; | ||
| 344 | } else { | ||
| 345 | /* Check for concatenated .gz files: */ | ||
| 346 | check_header(s); | ||
| 347 | if (s->z_err == Z_OK) { | ||
| 348 | inflateReset(&(s->stream)); | ||
| 349 | s->crc = crc32(0L, Z_NULL, 0); | ||
| 350 | } | ||
| 351 | } | ||
| 352 | } | ||
| 353 | if (s->z_err != Z_OK || s->z_eof) break; | ||
| 284 | } | 354 | } |
| 285 | len -= s->stream.avail_out; | 355 | s->crc = crc32(s->crc, start, (uInt)(s->stream.next_out - start)); |
| 286 | s->crc = crc32(s->crc, buf, len); | 356 | |
| 287 | return (int)len; | 357 | return (int)(len - s->stream.avail_out); |
| 288 | } | 358 | } |
| 289 | 359 | ||
| 290 | /* =========================================================================== | 360 | /* =========================================================================== |
| @@ -293,7 +363,7 @@ int gzread (file, buf, len) | |||
| 293 | */ | 363 | */ |
| 294 | int gzwrite (file, buf, len) | 364 | int gzwrite (file, buf, len) |
| 295 | gzFile file; | 365 | gzFile file; |
| 296 | voidp buf; | 366 | const voidp buf; |
| 297 | unsigned len; | 367 | unsigned len; |
| 298 | { | 368 | { |
| 299 | gz_stream *s = (gz_stream*)file; | 369 | gz_stream *s = (gz_stream*)file; |
| @@ -344,7 +414,7 @@ int gzflush (file, flush) | |||
| 344 | len = Z_BUFSIZE - s->stream.avail_out; | 414 | len = Z_BUFSIZE - s->stream.avail_out; |
| 345 | 415 | ||
| 346 | if (len != 0) { | 416 | if (len != 0) { |
| 347 | if (fwrite(s->outbuf, 1, len, s->file) != len) { | 417 | if ((uInt)fwrite(s->outbuf, 1, len, s->file) != len) { |
| 348 | s->z_err = Z_ERRNO; | 418 | s->z_err = Z_ERRNO; |
| 349 | return Z_ERRNO; | 419 | return Z_ERRNO; |
| 350 | } | 420 | } |
| @@ -380,18 +450,19 @@ local void putLong (file, x) | |||
| 380 | } | 450 | } |
| 381 | 451 | ||
| 382 | /* =========================================================================== | 452 | /* =========================================================================== |
| 383 | Reads a long in LSB order from the given buffer | 453 | Reads a long in LSB order from the given gz_stream. Sets |
| 384 | */ | 454 | */ |
| 385 | local uLong getLong (buf) | 455 | local uLong getLong (s) |
| 386 | Bytef *buf; | 456 | gz_stream *s; |
| 387 | { | 457 | { |
| 388 | uLong x = 0; | 458 | uLong x = (uLong)get_byte(s); |
| 389 | Bytef *p = buf+4; | 459 | int c; |
| 390 | 460 | ||
| 391 | do { | 461 | x += ((uLong)get_byte(s))<<8; |
| 392 | x <<= 8; | 462 | x += ((uLong)get_byte(s))<<16; |
| 393 | x |= *--p; | 463 | c = get_byte(s); |
| 394 | } while (p != buf); | 464 | if (c == EOF) s->z_err = Z_DATA_ERROR; |
| 465 | x += ((uLong)c)<<24; | ||
| 395 | return x; | 466 | return x; |
| 396 | } | 467 | } |
| 397 | 468 | ||
| @@ -402,7 +473,6 @@ local uLong getLong (buf) | |||
| 402 | int gzclose (file) | 473 | int gzclose (file) |
| 403 | gzFile file; | 474 | gzFile file; |
| 404 | { | 475 | { |
| 405 | uInt n; | ||
| 406 | int err; | 476 | int err; |
| 407 | gz_stream *s = (gz_stream*)file; | 477 | gz_stream *s = (gz_stream*)file; |
| 408 | 478 | ||
| @@ -415,25 +485,6 @@ int gzclose (file) | |||
| 415 | putLong (s->file, s->crc); | 485 | putLong (s->file, s->crc); |
| 416 | putLong (s->file, s->stream.total_in); | 486 | putLong (s->file, s->stream.total_in); |
| 417 | 487 | ||
| 418 | } else if (s->mode == 'r' && s->z_err == Z_STREAM_END) { | ||
| 419 | |||
| 420 | /* slide CRC and original size if they are at the end of inbuf */ | ||
| 421 | if ((n = s->stream.avail_in) < 8 && !s->z_eof) { | ||
| 422 | Byte *p = s->inbuf; | ||
| 423 | Bytef *q = s->stream.next_in; | ||
| 424 | while (n--) { *p++ = *q++; }; | ||
| 425 | |||
| 426 | n = s->stream.avail_in; | ||
| 427 | n += fread(p, 1, 8, s->file); | ||
| 428 | s->stream.next_in = s->inbuf; | ||
| 429 | } | ||
| 430 | /* check CRC and original size */ | ||
| 431 | if (n < 8 || | ||
| 432 | getLong(s->stream.next_in) != s->crc || | ||
| 433 | getLong(s->stream.next_in + 4) != s->stream.total_out) { | ||
| 434 | |||
| 435 | s->z_err = Z_DATA_ERROR; | ||
| 436 | } | ||
| 437 | } | 488 | } |
| 438 | return destroy(file); | 489 | return destroy(file); |
| 439 | } | 490 | } |
| @@ -454,14 +505,14 @@ char* gzerror (file, errnum) | |||
| 454 | 505 | ||
| 455 | if (s == NULL) { | 506 | if (s == NULL) { |
| 456 | *errnum = Z_STREAM_ERROR; | 507 | *errnum = Z_STREAM_ERROR; |
| 457 | return z_errmsg[1-Z_STREAM_ERROR]; | 508 | return ERR_MSG(Z_STREAM_ERROR); |
| 458 | } | 509 | } |
| 459 | *errnum = s->z_err; | 510 | *errnum = s->z_err; |
| 460 | if (*errnum == Z_OK) return ""; | 511 | if (*errnum == Z_OK) return (char*)""; |
| 461 | 512 | ||
| 462 | m = *errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg; | 513 | m = (char*)(*errnum == Z_ERRNO ? zstrerror(errno) : s->stream.msg); |
| 463 | 514 | ||
| 464 | if (m == NULL || *m == '\0') m = z_errmsg[1-s->z_err]; | 515 | if (m == NULL || *m == '\0') m = ERR_MSG(s->z_err); |
| 465 | 516 | ||
| 466 | TRYFREE(s->msg); | 517 | TRYFREE(s->msg); |
| 467 | s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3); | 518 | s->msg = (char*)ALLOC(strlen(s->path) + strlen(m) + 3); |
| @@ -1,5 +1,5 @@ | |||
| 1 | /* infblock.c -- interpret and process block types to last block | 1 | /* infblock.c -- interpret and process block types to last block |
| 2 | * Copyright (C) 1995 Mark Adler | 2 | * Copyright (C) 1995-1996 Mark Adler |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| @@ -81,7 +81,7 @@ uLongf *c; | |||
| 81 | s->bitb = 0; | 81 | s->bitb = 0; |
| 82 | s->read = s->write = s->window; | 82 | s->read = s->write = s->window; |
| 83 | if (s->checkfn != Z_NULL) | 83 | if (s->checkfn != Z_NULL) |
| 84 | s->check = (*s->checkfn)(0L, Z_NULL, 0); | 84 | z->adler = s->check = (*s->checkfn)(0L, Z_NULL, 0); |
| 85 | Trace((stderr, "inflate: blocks reset\n")); | 85 | Trace((stderr, "inflate: blocks reset\n")); |
| 86 | } | 86 | } |
| 87 | 87 | ||
| @@ -110,6 +110,9 @@ uInt w; | |||
| 110 | } | 110 | } |
| 111 | 111 | ||
| 112 | 112 | ||
| 113 | #ifdef DEBUG | ||
| 114 | extern uInt inflate_hufts; | ||
| 115 | #endif | ||
| 113 | int inflate_blocks(s, z, r) | 116 | int inflate_blocks(s, z, r) |
| 114 | inflate_blocks_statef *s; | 117 | inflate_blocks_statef *s; |
| 115 | z_stream *z; | 118 | z_stream *z; |
| @@ -172,7 +175,7 @@ int r; | |||
| 172 | case 3: /* illegal */ | 175 | case 3: /* illegal */ |
| 173 | DUMPBITS(3) | 176 | DUMPBITS(3) |
| 174 | s->mode = BAD; | 177 | s->mode = BAD; |
| 175 | z->msg = "invalid block type"; | 178 | z->msg = (char*)"invalid block type"; |
| 176 | r = Z_DATA_ERROR; | 179 | r = Z_DATA_ERROR; |
| 177 | LEAVE | 180 | LEAVE |
| 178 | } | 181 | } |
| @@ -182,14 +185,14 @@ int r; | |||
| 182 | if ((((~b) >> 16) & 0xffff) != (b & 0xffff)) | 185 | if ((((~b) >> 16) & 0xffff) != (b & 0xffff)) |
| 183 | { | 186 | { |
| 184 | s->mode = BAD; | 187 | s->mode = BAD; |
| 185 | z->msg = "invalid stored block lengths"; | 188 | z->msg = (char*)"invalid stored block lengths"; |
| 186 | r = Z_DATA_ERROR; | 189 | r = Z_DATA_ERROR; |
| 187 | LEAVE | 190 | LEAVE |
| 188 | } | 191 | } |
| 189 | s->sub.left = (uInt)b & 0xffff; | 192 | s->sub.left = (uInt)b & 0xffff; |
| 190 | b = k = 0; /* dump bits */ | 193 | b = k = 0; /* dump bits */ |
| 191 | Tracev((stderr, "inflate: stored length %u\n", s->sub.left)); | 194 | Tracev((stderr, "inflate: stored length %u\n", s->sub.left)); |
| 192 | s->mode = s->sub.left ? STORED : TYPE; | 195 | s->mode = s->sub.left ? STORED : (s->last ? DRY : TYPE); |
| 193 | break; | 196 | break; |
| 194 | case STORED: | 197 | case STORED: |
| 195 | if (n == 0) | 198 | if (n == 0) |
| @@ -215,7 +218,7 @@ int r; | |||
| 215 | if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29) | 218 | if ((t & 0x1f) > 29 || ((t >> 5) & 0x1f) > 29) |
| 216 | { | 219 | { |
| 217 | s->mode = BAD; | 220 | s->mode = BAD; |
| 218 | z->msg = "too many length or distance symbols"; | 221 | z->msg = (char*)"too many length or distance symbols"; |
| 219 | r = Z_DATA_ERROR; | 222 | r = Z_DATA_ERROR; |
| 220 | LEAVE | 223 | LEAVE |
| 221 | } | 224 | } |
| @@ -285,7 +288,7 @@ int r; | |||
| 285 | (c == 16 && i < 1)) | 288 | (c == 16 && i < 1)) |
| 286 | { | 289 | { |
| 287 | s->mode = BAD; | 290 | s->mode = BAD; |
| 288 | z->msg = "invalid bit length repeat"; | 291 | z->msg = (char*)"invalid bit length repeat"; |
| 289 | r = Z_DATA_ERROR; | 292 | r = Z_DATA_ERROR; |
| 290 | LEAVE | 293 | LEAVE |
| 291 | } | 294 | } |
| @@ -306,6 +309,9 @@ int r; | |||
| 306 | bl = 9; /* must be <= 9 for lookahead assumptions */ | 309 | bl = 9; /* must be <= 9 for lookahead assumptions */ |
| 307 | bd = 6; /* must be <= 9 for lookahead assumptions */ | 310 | bd = 6; /* must be <= 9 for lookahead assumptions */ |
| 308 | t = s->sub.trees.table; | 311 | t = s->sub.trees.table; |
| 312 | #ifdef DEBUG | ||
| 313 | inflate_hufts = 0; | ||
| 314 | #endif | ||
| 309 | t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f), | 315 | t = inflate_trees_dynamic(257 + (t & 0x1f), 1 + ((t >> 5) & 0x1f), |
| 310 | s->sub.trees.blens, &bl, &bd, &tl, &td, z); | 316 | s->sub.trees.blens, &bl, &bd, &tl, &td, z); |
| 311 | if (t != Z_OK) | 317 | if (t != Z_OK) |
| @@ -315,7 +321,8 @@ int r; | |||
| 315 | r = t; | 321 | r = t; |
| 316 | LEAVE | 322 | LEAVE |
| 317 | } | 323 | } |
| 318 | Tracev((stderr, "inflate: trees ok\n")); | 324 | Tracev((stderr, "inflate: trees ok, %d * %d bytes used\n", |
| 325 | inflate_hufts, sizeof(inflate_huft))); | ||
| 319 | if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL) | 326 | if ((c = inflate_codes_new(bl, bd, tl, td, z)) == Z_NULL) |
| 320 | { | 327 | { |
| 321 | inflate_trees_free(td, z); | 328 | inflate_trees_free(td, z); |
| @@ -383,3 +390,13 @@ uLongf *c; | |||
| 383 | Trace((stderr, "inflate: blocks freed\n")); | 390 | Trace((stderr, "inflate: blocks freed\n")); |
| 384 | return Z_OK; | 391 | return Z_OK; |
| 385 | } | 392 | } |
| 393 | |||
| 394 | |||
| 395 | void inflate_set_dictionary(s, d, n) | ||
| 396 | inflate_blocks_statef *s; | ||
| 397 | const Bytef *d; | ||
| 398 | uInt n; | ||
| 399 | { | ||
| 400 | zmemcpy((charf *)s->window, d, n); | ||
| 401 | s->read = s->write = s->window + n; | ||
| 402 | } | ||
| @@ -1,5 +1,5 @@ | |||
| 1 | /* infblock.h -- header to use infblock.c | 1 | /* infblock.h -- header to use infblock.c |
| 2 | * Copyright (C) 1995 Mark Adler | 2 | * Copyright (C) 1995-1996 Mark Adler |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| @@ -30,3 +30,8 @@ extern int inflate_blocks_free OF(( | |||
| 30 | inflate_blocks_statef *, | 30 | inflate_blocks_statef *, |
| 31 | z_stream *, | 31 | z_stream *, |
| 32 | uLongf *)); /* check value on output */ | 32 | uLongf *)); /* check value on output */ |
| 33 | |||
| 34 | extern void inflate_set_dictionary OF(( | ||
| 35 | inflate_blocks_statef *s, | ||
| 36 | const Bytef *d, /* dictionary */ | ||
| 37 | uInt n)); /* dictionary length */ | ||
| @@ -1,5 +1,5 @@ | |||
| 1 | /* infcodes.c -- process literals and length/distance pairs | 1 | /* infcodes.c -- process literals and length/distance pairs |
| 2 | * Copyright (C) 1995 Mark Adler | 2 | * Copyright (C) 1995-1996 Mark Adler |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| @@ -58,7 +58,8 @@ struct inflate_codes_state { | |||
| 58 | 58 | ||
| 59 | inflate_codes_statef *inflate_codes_new(bl, bd, tl, td, z) | 59 | inflate_codes_statef *inflate_codes_new(bl, bd, tl, td, z) |
| 60 | uInt bl, bd; | 60 | uInt bl, bd; |
| 61 | inflate_huft *tl, *td; | 61 | inflate_huft *tl; |
| 62 | inflate_huft *td; /* need separate declaration for Borland C++ */ | ||
| 62 | z_stream *z; | 63 | z_stream *z; |
| 63 | { | 64 | { |
| 64 | inflate_codes_statef *c; | 65 | inflate_codes_statef *c; |
| @@ -152,7 +153,7 @@ int r; | |||
| 152 | break; | 153 | break; |
| 153 | } | 154 | } |
| 154 | c->mode = BADCODE; /* invalid code */ | 155 | c->mode = BADCODE; /* invalid code */ |
| 155 | z->msg = "invalid literal/length code"; | 156 | z->msg = (char*)"invalid literal/length code"; |
| 156 | r = Z_DATA_ERROR; | 157 | r = Z_DATA_ERROR; |
| 157 | LEAVE | 158 | LEAVE |
| 158 | case LENEXT: /* i: getting length extra (have base) */ | 159 | case LENEXT: /* i: getting length extra (have base) */ |
| @@ -184,7 +185,7 @@ int r; | |||
| 184 | break; | 185 | break; |
| 185 | } | 186 | } |
| 186 | c->mode = BADCODE; /* invalid code */ | 187 | c->mode = BADCODE; /* invalid code */ |
| 187 | z->msg = "invalid distance code"; | 188 | z->msg = (char*)"invalid distance code"; |
| 188 | r = Z_DATA_ERROR; | 189 | r = Z_DATA_ERROR; |
| 189 | LEAVE | 190 | LEAVE |
| 190 | case DISTEXT: /* i: getting distance extra */ | 191 | case DISTEXT: /* i: getting distance extra */ |
| @@ -1,5 +1,5 @@ | |||
| 1 | /* infcodes.h -- header to use infcodes.c | 1 | /* infcodes.h -- header to use infcodes.c |
| 2 | * Copyright (C) 1995 Mark Adler | 2 | * Copyright (C) 1995-1996 Mark Adler |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| @@ -1,5 +1,5 @@ | |||
| 1 | /* inffast.c -- process literals and length/distance pairs fast | 1 | /* inffast.c -- process literals and length/distance pairs fast |
| 2 | * Copyright (C) 1995 Mark Adler | 2 | * Copyright (C) 1995-1996 Mark Adler |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| @@ -29,7 +29,8 @@ struct inflate_codes_state {int dummy;}; /* for buggy compilers */ | |||
| 29 | 29 | ||
| 30 | int inflate_fast(bl, bd, tl, td, s, z) | 30 | int inflate_fast(bl, bd, tl, td, s, z) |
| 31 | uInt bl, bd; | 31 | uInt bl, bd; |
| 32 | inflate_huft *tl, *td; | 32 | inflate_huft *tl; |
| 33 | inflate_huft *td; /* need separate declaration for Borland C++ */ | ||
| 33 | inflate_blocks_statef *s; | 34 | inflate_blocks_statef *s; |
| 34 | z_stream *z; | 35 | z_stream *z; |
| 35 | { | 36 | { |
| @@ -122,7 +123,7 @@ z_stream *z; | |||
| 122 | e = (t = t->next + ((uInt)b & inflate_mask[e]))->exop; | 123 | e = (t = t->next + ((uInt)b & inflate_mask[e]))->exop; |
| 123 | else | 124 | else |
| 124 | { | 125 | { |
| 125 | z->msg = "invalid distance code"; | 126 | z->msg = (char*)"invalid distance code"; |
| 126 | UNGRAB | 127 | UNGRAB |
| 127 | UPDATE | 128 | UPDATE |
| 128 | return Z_DATA_ERROR; | 129 | return Z_DATA_ERROR; |
| @@ -152,7 +153,7 @@ z_stream *z; | |||
| 152 | } | 153 | } |
| 153 | else | 154 | else |
| 154 | { | 155 | { |
| 155 | z->msg = "invalid literal/length code"; | 156 | z->msg = (char*)"invalid literal/length code"; |
| 156 | UNGRAB | 157 | UNGRAB |
| 157 | UPDATE | 158 | UPDATE |
| 158 | return Z_DATA_ERROR; | 159 | return Z_DATA_ERROR; |
| @@ -1,5 +1,5 @@ | |||
| 1 | /* inffast.h -- header to use inffast.c | 1 | /* inffast.h -- header to use inffast.c |
| 2 | * Copyright (C) 1995 Mark Adler | 2 | * Copyright (C) 1995-1996 Mark Adler |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| @@ -1,5 +1,5 @@ | |||
| 1 | /* inflate.c -- zlib interface to inflate modules | 1 | /* inflate.c -- zlib interface to inflate modules |
| 2 | * Copyright (C) 1995 Mark Adler | 2 | * Copyright (C) 1995-1996 Mark Adler |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| @@ -15,6 +15,11 @@ struct internal_state { | |||
| 15 | enum { | 15 | enum { |
| 16 | METHOD, /* waiting for method byte */ | 16 | METHOD, /* waiting for method byte */ |
| 17 | FLAG, /* waiting for flag byte */ | 17 | FLAG, /* waiting for flag byte */ |
| 18 | DICT4, /* four dictionary check bytes to go */ | ||
| 19 | DICT3, /* three dictionary check bytes to go */ | ||
| 20 | DICT2, /* two dictionary check bytes to go */ | ||
| 21 | DICT1, /* one dictionary check byte to go */ | ||
| 22 | DICT0, /* waiting for inflateSetDictionary */ | ||
| 18 | BLOCKS, /* decompressing blocks */ | 23 | BLOCKS, /* decompressing blocks */ |
| 19 | CHECK4, /* four check bytes to go */ | 24 | CHECK4, /* four check bytes to go */ |
| 20 | CHECK3, /* three check bytes to go */ | 25 | CHECK3, /* three check bytes to go */ |
| @@ -75,10 +80,16 @@ z_stream *z; | |||
| 75 | } | 80 | } |
| 76 | 81 | ||
| 77 | 82 | ||
| 78 | int inflateInit2(z, w) | 83 | int inflateInit2_(z, w, version, stream_size) |
| 79 | z_stream *z; | 84 | z_stream *z; |
| 80 | int w; | 85 | int w; |
| 86 | const char *version; | ||
| 87 | int stream_size; | ||
| 81 | { | 88 | { |
| 89 | if (version == Z_NULL || version[0] != ZLIB_VERSION[0] || | ||
| 90 | stream_size != sizeof(z_stream)) | ||
| 91 | return Z_VERSION_ERROR; | ||
| 92 | |||
| 82 | /* initialize state */ | 93 | /* initialize state */ |
| 83 | if (z == Z_NULL) | 94 | if (z == Z_NULL) |
| 84 | return Z_STREAM_ERROR; | 95 | return Z_STREAM_ERROR; |
| @@ -112,7 +123,7 @@ int w; | |||
| 112 | 123 | ||
| 113 | /* create inflate_blocks state */ | 124 | /* create inflate_blocks state */ |
| 114 | if ((z->state->blocks = | 125 | if ((z->state->blocks = |
| 115 | inflate_blocks_new(z, z->state->nowrap ? Z_NULL : adler32, 1 << w)) | 126 | inflate_blocks_new(z, z->state->nowrap ? Z_NULL : adler32, (uInt)1 << w)) |
| 116 | == Z_NULL) | 127 | == Z_NULL) |
| 117 | { | 128 | { |
| 118 | inflateEnd(z); | 129 | inflateEnd(z); |
| @@ -126,10 +137,12 @@ int w; | |||
| 126 | } | 137 | } |
| 127 | 138 | ||
| 128 | 139 | ||
| 129 | int inflateInit(z) | 140 | int inflateInit_(z, version, stream_size) |
| 130 | z_stream *z; | 141 | z_stream *z; |
| 142 | const char *version; | ||
| 143 | int stream_size; | ||
| 131 | { | 144 | { |
| 132 | return inflateInit2(z, DEF_WBITS); | 145 | return inflateInit2_(z, DEF_WBITS, version, stream_size); |
| 133 | } | 146 | } |
| 134 | 147 | ||
| 135 | 148 | ||
| @@ -140,10 +153,10 @@ int inflate(z, f) | |||
| 140 | z_stream *z; | 153 | z_stream *z; |
| 141 | int f; | 154 | int f; |
| 142 | { | 155 | { |
| 143 | int r = f; /* to avoid warning about unused f */ | 156 | int r; |
| 144 | uInt b; | 157 | uInt b; |
| 145 | 158 | ||
| 146 | if (z == Z_NULL || z->next_in == Z_NULL) | 159 | if (z == Z_NULL || z->state == Z_NULL || z->next_in == Z_NULL || f < 0) |
| 147 | return Z_STREAM_ERROR; | 160 | return Z_STREAM_ERROR; |
| 148 | r = Z_BUF_ERROR; | 161 | r = Z_BUF_ERROR; |
| 149 | while (1) switch (z->state->mode) | 162 | while (1) switch (z->state->mode) |
| @@ -153,36 +166,58 @@ int f; | |||
| 153 | if (((z->state->sub.method = NEXTBYTE) & 0xf) != Z_DEFLATED) | 166 | if (((z->state->sub.method = NEXTBYTE) & 0xf) != Z_DEFLATED) |
| 154 | { | 167 | { |
| 155 | z->state->mode = BAD; | 168 | z->state->mode = BAD; |
| 156 | z->msg = "unknown compression method"; | 169 | z->msg = (char*)"unknown compression method"; |
| 157 | z->state->sub.marker = 5; /* can't try inflateSync */ | 170 | z->state->sub.marker = 5; /* can't try inflateSync */ |
| 158 | break; | 171 | break; |
| 159 | } | 172 | } |
| 160 | if ((z->state->sub.method >> 4) + 8 > z->state->wbits) | 173 | if ((z->state->sub.method >> 4) + 8 > z->state->wbits) |
| 161 | { | 174 | { |
| 162 | z->state->mode = BAD; | 175 | z->state->mode = BAD; |
| 163 | z->msg = "invalid window size"; | 176 | z->msg = (char*)"invalid window size"; |
| 164 | z->state->sub.marker = 5; /* can't try inflateSync */ | 177 | z->state->sub.marker = 5; /* can't try inflateSync */ |
| 165 | break; | 178 | break; |
| 166 | } | 179 | } |
| 167 | z->state->mode = FLAG; | 180 | z->state->mode = FLAG; |
| 168 | case FLAG: | 181 | case FLAG: |
| 169 | NEEDBYTE | 182 | NEEDBYTE |
| 170 | if ((b = NEXTBYTE) & 0x20) | 183 | b = NEXTBYTE; |
| 171 | { | ||
| 172 | z->state->mode = BAD; | ||
| 173 | z->msg = "invalid reserved bit"; | ||
| 174 | z->state->sub.marker = 5; /* can't try inflateSync */ | ||
| 175 | break; | ||
| 176 | } | ||
| 177 | if (((z->state->sub.method << 8) + b) % 31) | 184 | if (((z->state->sub.method << 8) + b) % 31) |
| 178 | { | 185 | { |
| 179 | z->state->mode = BAD; | 186 | z->state->mode = BAD; |
| 180 | z->msg = "incorrect header check"; | 187 | z->msg = (char*)"incorrect header check"; |
| 181 | z->state->sub.marker = 5; /* can't try inflateSync */ | 188 | z->state->sub.marker = 5; /* can't try inflateSync */ |
| 182 | break; | 189 | break; |
| 183 | } | 190 | } |
| 184 | Trace((stderr, "inflate: zlib header ok\n")); | 191 | Trace((stderr, "inflate: zlib header ok\n")); |
| 185 | z->state->mode = BLOCKS; | 192 | if (!(b & PRESET_DICT)) |
| 193 | { | ||
| 194 | z->state->mode = BLOCKS; | ||
| 195 | break; | ||
| 196 | } | ||
| 197 | z->state->mode = DICT4; | ||
| 198 | case DICT4: | ||
| 199 | NEEDBYTE | ||
| 200 | z->state->sub.check.need = (uLong)NEXTBYTE << 24; | ||
| 201 | z->state->mode = DICT3; | ||
| 202 | case DICT3: | ||
| 203 | NEEDBYTE | ||
| 204 | z->state->sub.check.need += (uLong)NEXTBYTE << 16; | ||
| 205 | z->state->mode = DICT2; | ||
| 206 | case DICT2: | ||
| 207 | NEEDBYTE | ||
| 208 | z->state->sub.check.need += (uLong)NEXTBYTE << 8; | ||
| 209 | z->state->mode = DICT1; | ||
| 210 | case DICT1: | ||
| 211 | NEEDBYTE | ||
| 212 | z->state->sub.check.need += (uLong)NEXTBYTE; | ||
| 213 | z->adler = z->state->sub.check.need; | ||
| 214 | z->state->mode = DICT0; | ||
| 215 | return Z_NEED_DICT; | ||
| 216 | case DICT0: | ||
| 217 | z->state->mode = BAD; | ||
| 218 | z->msg = (char*)"need dictionary"; | ||
| 219 | z->state->sub.marker = 0; /* can try inflateSync */ | ||
| 220 | return Z_STREAM_ERROR; | ||
| 186 | case BLOCKS: | 221 | case BLOCKS: |
| 187 | r = inflate_blocks(z->state->blocks, z, r); | 222 | r = inflate_blocks(z->state->blocks, z, r); |
| 188 | if (r == Z_DATA_ERROR) | 223 | if (r == Z_DATA_ERROR) |
| @@ -220,7 +255,7 @@ int f; | |||
| 220 | if (z->state->sub.check.was != z->state->sub.check.need) | 255 | if (z->state->sub.check.was != z->state->sub.check.need) |
| 221 | { | 256 | { |
| 222 | z->state->mode = BAD; | 257 | z->state->mode = BAD; |
| 223 | z->msg = "incorrect data check"; | 258 | z->msg = (char*)"incorrect data check"; |
| 224 | z->state->sub.marker = 5; /* can't try inflateSync */ | 259 | z->state->sub.marker = 5; /* can't try inflateSync */ |
| 225 | break; | 260 | break; |
| 226 | } | 261 | } |
| @@ -236,6 +271,29 @@ int f; | |||
| 236 | } | 271 | } |
| 237 | 272 | ||
| 238 | 273 | ||
| 274 | int inflateSetDictionary(z, dictionary, dictLength) | ||
| 275 | z_stream *z; | ||
| 276 | const Bytef *dictionary; | ||
| 277 | uInt dictLength; | ||
| 278 | { | ||
| 279 | uInt length = dictLength; | ||
| 280 | |||
| 281 | if (z == Z_NULL || z->state == Z_NULL || z->state->mode != DICT0) | ||
| 282 | return Z_STREAM_ERROR; | ||
| 283 | if (adler32(1L, dictionary, dictLength) != z->adler) return Z_DATA_ERROR; | ||
| 284 | z->adler = 1L; | ||
| 285 | |||
| 286 | if (length >= ((uInt)1<<z->state->wbits)) | ||
| 287 | { | ||
| 288 | length = (1<<z->state->wbits)-1; | ||
| 289 | dictionary += dictLength - length; | ||
| 290 | } | ||
| 291 | inflate_set_dictionary(z->state->blocks, dictionary, length); | ||
| 292 | z->state->mode = BLOCKS; | ||
| 293 | return Z_OK; | ||
| 294 | } | ||
| 295 | |||
| 296 | |||
| 239 | int inflateSync(z) | 297 | int inflateSync(z) |
| 240 | z_stream *z; | 298 | z_stream *z; |
| 241 | { | 299 | { |
| @@ -1,12 +1,12 @@ | |||
| 1 | /* inftrees.c -- generate Huffman trees for efficient decoding | 1 | /* inftrees.c -- generate Huffman trees for efficient decoding |
| 2 | * Copyright (C) 1995 Mark Adler | 2 | * Copyright (C) 1995-1996 Mark Adler |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| 6 | #include "zutil.h" | 6 | #include "zutil.h" |
| 7 | #include "inftrees.h" | 7 | #include "inftrees.h" |
| 8 | 8 | ||
| 9 | char inflate_copyright[] = " inflate 1.0 Copyright 1995 Mark Adler "; | 9 | char inflate_copyright[] = " inflate 1.0.1 Copyright 1995-1996 Mark Adler "; |
| 10 | /* | 10 | /* |
| 11 | If you use the zlib library in a product, an acknowledgment is welcome | 11 | If you use the zlib library in a product, an acknowledgment is welcome |
| 12 | in the documentation of your product. If for some reason you cannot | 12 | in the documentation of your product. If for some reason you cannot |
| @@ -38,18 +38,18 @@ local voidpf falloc OF(( | |||
| 38 | uInt)); /* size of item */ | 38 | uInt)); /* size of item */ |
| 39 | 39 | ||
| 40 | /* Tables for deflate from PKZIP's appnote.txt. */ | 40 | /* Tables for deflate from PKZIP's appnote.txt. */ |
| 41 | local uInt cplens[] = { /* Copy lengths for literal codes 257..285 */ | 41 | local uInt cplens[31] = { /* Copy lengths for literal codes 257..285 */ |
| 42 | 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, | 42 | 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, |
| 43 | 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; | 43 | 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; |
| 44 | /* actually lengths - 2; also see note #13 above about 258 */ | 44 | /* actually lengths - 2; also see note #13 above about 258 */ |
| 45 | local uInt cplext[] = { /* Extra bits for literal codes 257..285 */ | 45 | local uInt cplext[31] = { /* Extra bits for literal codes 257..285 */ |
| 46 | 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, | 46 | 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, |
| 47 | 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 192, 192}; /* 192==invalid */ | 47 | 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0, 192, 192}; /* 192==invalid */ |
| 48 | local uInt cpdist[] = { /* Copy offsets for distance codes 0..29 */ | 48 | local uInt cpdist[30] = { /* Copy offsets for distance codes 0..29 */ |
| 49 | 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, | 49 | 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, |
| 50 | 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, | 50 | 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, |
| 51 | 8193, 12289, 16385, 24577}; | 51 | 8193, 12289, 16385, 24577}; |
| 52 | local uInt cpdext[] = { /* Extra bits for distance codes */ | 52 | local uInt cpdext[30] = { /* Extra bits for distance codes */ |
| 53 | 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, | 53 | 0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, |
| 54 | 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, | 54 | 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, |
| 55 | 12, 12, 13, 13}; | 55 | 12, 12, 13, 13}; |
| @@ -215,7 +215,8 @@ z_stream *zs; /* for zalloc function */ | |||
| 215 | w += l; /* previous table always l bits */ | 215 | w += l; /* previous table always l bits */ |
| 216 | 216 | ||
| 217 | /* compute minimum size table less than or equal to l bits */ | 217 | /* compute minimum size table less than or equal to l bits */ |
| 218 | z = (z = g - w) > (uInt)l ? l : z; /* table size upper limit */ | 218 | z = g - w; |
| 219 | z = z > (uInt)l ? l : z; /* table size upper limit */ | ||
| 219 | if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w bit table */ | 220 | if ((f = 1 << (j = k - w)) > a + 1) /* try a k-w bit table */ |
| 220 | { /* too few codes for k-w bit table */ | 221 | { /* too few codes for k-w bit table */ |
| 221 | f -= a + 1; /* deduct codes from patterns left */ | 222 | f -= a + 1; /* deduct codes from patterns left */ |
| @@ -268,7 +269,7 @@ z_stream *zs; /* for zalloc function */ | |||
| 268 | } | 269 | } |
| 269 | else | 270 | else |
| 270 | { | 271 | { |
| 271 | r.exop = (Byte)e[*p - s] + 16 + 64; /* non-simple--look up in lists */ | 272 | r.exop = (Byte)(e[*p - s] + 16 + 64);/* non-simple--look up in lists */ |
| 272 | r.base = d[*p++ - s]; | 273 | r.base = d[*p++ - s]; |
| 273 | } | 274 | } |
| 274 | 275 | ||
| @@ -307,11 +308,11 @@ z_stream *z; /* for zfree function */ | |||
| 307 | 308 | ||
| 308 | r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL, tb, bb, z); | 309 | r = huft_build(c, 19, 19, (uIntf*)Z_NULL, (uIntf*)Z_NULL, tb, bb, z); |
| 309 | if (r == Z_DATA_ERROR) | 310 | if (r == Z_DATA_ERROR) |
| 310 | z->msg = "oversubscribed dynamic bit lengths tree"; | 311 | z->msg = (char*)"oversubscribed dynamic bit lengths tree"; |
| 311 | else if (r == Z_BUF_ERROR) | 312 | else if (r == Z_BUF_ERROR) |
| 312 | { | 313 | { |
| 313 | inflate_trees_free(*tb, z); | 314 | inflate_trees_free(*tb, z); |
| 314 | z->msg = "incomplete dynamic bit lengths tree"; | 315 | z->msg = (char*)"incomplete dynamic bit lengths tree"; |
| 315 | r = Z_DATA_ERROR; | 316 | r = Z_DATA_ERROR; |
| 316 | } | 317 | } |
| 317 | return r; | 318 | return r; |
| @@ -334,11 +335,11 @@ z_stream *z; /* for zfree function */ | |||
| 334 | if ((r = huft_build(c, nl, 257, cplens, cplext, tl, bl, z)) != Z_OK) | 335 | if ((r = huft_build(c, nl, 257, cplens, cplext, tl, bl, z)) != Z_OK) |
| 335 | { | 336 | { |
| 336 | if (r == Z_DATA_ERROR) | 337 | if (r == Z_DATA_ERROR) |
| 337 | z->msg = "oversubscribed literal/length tree"; | 338 | z->msg = (char*)"oversubscribed literal/length tree"; |
| 338 | else if (r == Z_BUF_ERROR) | 339 | else if (r == Z_BUF_ERROR) |
| 339 | { | 340 | { |
| 340 | inflate_trees_free(*tl, z); | 341 | inflate_trees_free(*tl, z); |
| 341 | z->msg = "incomplete literal/length tree"; | 342 | z->msg = (char*)"incomplete literal/length tree"; |
| 342 | r = Z_DATA_ERROR; | 343 | r = Z_DATA_ERROR; |
| 343 | } | 344 | } |
| 344 | return r; | 345 | return r; |
| @@ -348,14 +349,14 @@ z_stream *z; /* for zfree function */ | |||
| 348 | if ((r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, z)) != Z_OK) | 349 | if ((r = huft_build(c + nl, nd, 0, cpdist, cpdext, td, bd, z)) != Z_OK) |
| 349 | { | 350 | { |
| 350 | if (r == Z_DATA_ERROR) | 351 | if (r == Z_DATA_ERROR) |
| 351 | z->msg = "oversubscribed literal/length tree"; | 352 | z->msg = (char*)"oversubscribed literal/length tree"; |
| 352 | else if (r == Z_BUF_ERROR) { | 353 | else if (r == Z_BUF_ERROR) { |
| 353 | #ifdef PKZIP_BUG_WORKAROUND | 354 | #ifdef PKZIP_BUG_WORKAROUND |
| 354 | r = Z_OK; | 355 | r = Z_OK; |
| 355 | } | 356 | } |
| 356 | #else | 357 | #else |
| 357 | inflate_trees_free(*td, z); | 358 | inflate_trees_free(*td, z); |
| 358 | z->msg = "incomplete literal/length tree"; | 359 | z->msg = (char*)"incomplete literal/length tree"; |
| 359 | r = Z_DATA_ERROR; | 360 | r = Z_DATA_ERROR; |
| 360 | } | 361 | } |
| 361 | inflate_trees_free(*tl, z); | 362 | inflate_trees_free(*tl, z); |
| @@ -385,7 +386,7 @@ uInt s; /* size of item */ | |||
| 385 | { | 386 | { |
| 386 | Assert(s == sizeof(inflate_huft) && n <= *(intf *)q, | 387 | Assert(s == sizeof(inflate_huft) && n <= *(intf *)q, |
| 387 | "inflate_trees falloc overflow"); | 388 | "inflate_trees falloc overflow"); |
| 388 | *(intf *)q -= n; | 389 | *(intf *)q -= n+s-s; /* s-s to avoid warning */ |
| 389 | return (voidpf)(fixed_mem + *(intf *)q); | 390 | return (voidpf)(fixed_mem + *(intf *)q); |
| 390 | } | 391 | } |
| 391 | 392 | ||
| @@ -1,5 +1,5 @@ | |||
| 1 | /* inftrees.h -- header to use inftrees.c | 1 | /* inftrees.h -- header to use inftrees.c |
| 2 | * Copyright (C) 1995 Mark Adler | 2 | * Copyright (C) 1995-1996 Mark Adler |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| @@ -1,5 +1,5 @@ | |||
| 1 | /* inflate_util.c -- data and routines common to blocks and codes | 1 | /* inflate_util.c -- data and routines common to blocks and codes |
| 2 | * Copyright (C) 1995 Mark Adler | 2 | * Copyright (C) 1995-1996 Mark Adler |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| @@ -12,7 +12,7 @@ | |||
| 12 | struct inflate_codes_state {int dummy;}; /* for buggy compilers */ | 12 | struct inflate_codes_state {int dummy;}; /* for buggy compilers */ |
| 13 | 13 | ||
| 14 | /* And'ing with mask[n] masks the lower n bits */ | 14 | /* And'ing with mask[n] masks the lower n bits */ |
| 15 | uInt inflate_mask[] = { | 15 | uInt inflate_mask[17] = { |
| 16 | 0x0000, | 16 | 0x0000, |
| 17 | 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff, | 17 | 0x0001, 0x0003, 0x0007, 0x000f, 0x001f, 0x003f, 0x007f, 0x00ff, |
| 18 | 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff | 18 | 0x01ff, 0x03ff, 0x07ff, 0x0fff, 0x1fff, 0x3fff, 0x7fff, 0xffff |
| @@ -43,7 +43,7 @@ int r; | |||
| 43 | 43 | ||
| 44 | /* update check information */ | 44 | /* update check information */ |
| 45 | if (s->checkfn != Z_NULL) | 45 | if (s->checkfn != Z_NULL) |
| 46 | s->check = (*s->checkfn)(s->check, q, n); | 46 | z->adler = s->check = (*s->checkfn)(s->check, q, n); |
| 47 | 47 | ||
| 48 | /* copy as far as end of window */ | 48 | /* copy as far as end of window */ |
| 49 | zmemcpy(p, q, n); | 49 | zmemcpy(p, q, n); |
| @@ -69,7 +69,7 @@ int r; | |||
| 69 | 69 | ||
| 70 | /* update check information */ | 70 | /* update check information */ |
| 71 | if (s->checkfn != Z_NULL) | 71 | if (s->checkfn != Z_NULL) |
| 72 | s->check = (*s->checkfn)(s->check, q, n); | 72 | z->adler = s->check = (*s->checkfn)(s->check, q, n); |
| 73 | 73 | ||
| 74 | /* copy */ | 74 | /* copy */ |
| 75 | zmemcpy(p, q, n); | 75 | zmemcpy(p, q, n); |
| @@ -1,5 +1,5 @@ | |||
| 1 | /* infutil.h -- types and macros common to blocks and codes | 1 | /* infutil.h -- types and macros common to blocks and codes |
| 2 | * Copyright (C) 1995 Mark Adler | 2 | * Copyright (C) 1995-1996 Mark Adler |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| @@ -8,11 +8,10 @@ | |||
| 8 | subject to change. Applications should only use zlib.h. | 8 | subject to change. Applications should only use zlib.h. |
| 9 | */ | 9 | */ |
| 10 | 10 | ||
| 11 | /* inflate blocks semi-private state */ | 11 | #ifndef _INFUTIL_H |
| 12 | struct inflate_blocks_state { | 12 | #define _INFUTIL_H |
| 13 | 13 | ||
| 14 | /* mode */ | 14 | typedef enum { |
| 15 | enum { | ||
| 16 | TYPE, /* get type bits (3, including end bit) */ | 15 | TYPE, /* get type bits (3, including end bit) */ |
| 17 | LENS, /* get lengths for stored */ | 16 | LENS, /* get lengths for stored */ |
| 18 | STORED, /* processing stored block */ | 17 | STORED, /* processing stored block */ |
| @@ -23,7 +22,13 @@ struct inflate_blocks_state { | |||
| 23 | DRY, /* output remaining window bytes */ | 22 | DRY, /* output remaining window bytes */ |
| 24 | DONE, /* finished last block, done */ | 23 | DONE, /* finished last block, done */ |
| 25 | BAD} /* got a data error--stuck here */ | 24 | BAD} /* got a data error--stuck here */ |
| 26 | mode; /* current inflate_block mode */ | 25 | inflate_block_mode; |
| 26 | |||
| 27 | /* inflate blocks semi-private state */ | ||
| 28 | struct inflate_blocks_state { | ||
| 29 | |||
| 30 | /* mode */ | ||
| 31 | inflate_block_mode mode; /* current inflate_block mode */ | ||
| 27 | 32 | ||
| 28 | /* mode dependent information */ | 33 | /* mode dependent information */ |
| 29 | union { | 34 | union { |
| @@ -36,7 +41,8 @@ struct inflate_blocks_state { | |||
| 36 | inflate_huft *tb; /* bit length decoding tree */ | 41 | inflate_huft *tb; /* bit length decoding tree */ |
| 37 | } trees; /* if DTREE, decoding info for trees */ | 42 | } trees; /* if DTREE, decoding info for trees */ |
| 38 | struct { | 43 | struct { |
| 39 | inflate_huft *tl, *td; /* trees to free */ | 44 | inflate_huft *tl; |
| 45 | inflate_huft *td; /* trees to free */ | ||
| 40 | inflate_codes_statef | 46 | inflate_codes_statef |
| 41 | *codes; | 47 | *codes; |
| 42 | } decode; /* if CODES, current state */ | 48 | } decode; /* if CODES, current state */ |
| @@ -71,16 +77,16 @@ struct inflate_blocks_state { | |||
| 71 | #define DUMPBITS(j) {b>>=(j);k-=(j);} | 77 | #define DUMPBITS(j) {b>>=(j);k-=(j);} |
| 72 | /* output bytes */ | 78 | /* output bytes */ |
| 73 | #define WAVAIL (uInt)(q<s->read?s->read-q-1:s->end-q) | 79 | #define WAVAIL (uInt)(q<s->read?s->read-q-1:s->end-q) |
| 74 | #define LOADOUT {q=s->write;m=WAVAIL;} | 80 | #define LOADOUT {q=s->write;m=(uInt)WAVAIL;} |
| 75 | #define WRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=WAVAIL;}} | 81 | #define WRAP {if(q==s->end&&s->read!=s->window){q=s->window;m=(uInt)WAVAIL;}} |
| 76 | #define FLUSH {UPDOUT r=inflate_flush(s,z,r); LOADOUT} | 82 | #define FLUSH {UPDOUT r=inflate_flush(s,z,r); LOADOUT} |
| 77 | #define NEEDOUT {if(m==0){WRAP if(m==0){FLUSH WRAP if(m==0) LEAVE}}r=Z_OK;} | 83 | #define NEEDOUT {if(m==0){WRAP if(m==0){FLUSH WRAP if(m==0) LEAVE}}r=Z_OK;} |
| 78 | #define OUTBYTE(a) {*q++=(Byte)(a);m--;} | 84 | #define OUTBYTE(a) {*q++=(Byte)(a);m--;} |
| 79 | /* load local pointers */ | 85 | /* load local pointers */ |
| 80 | #define LOAD {LOADIN LOADOUT} | 86 | #define LOAD {LOADIN LOADOUT} |
| 81 | 87 | ||
| 82 | /* masks for lower bits */ | 88 | /* masks for lower bits (size given to avoid silly warnings with Visual C++) */ |
| 83 | extern uInt inflate_mask[]; | 89 | extern uInt inflate_mask[17]; |
| 84 | 90 | ||
| 85 | /* copy as much as possible from the sliding window to the output area */ | 91 | /* copy as much as possible from the sliding window to the output area */ |
| 86 | extern int inflate_flush OF(( | 92 | extern int inflate_flush OF(( |
| @@ -89,3 +95,5 @@ extern int inflate_flush OF(( | |||
| 89 | int)); | 95 | int)); |
| 90 | 96 | ||
| 91 | struct internal_state {int dummy;}; /* for buggy compilers */ | 97 | struct internal_state {int dummy;}; /* for buggy compilers */ |
| 98 | |||
| 99 | #endif | ||
| @@ -1,5 +1,5 @@ | |||
| 1 | /* minigzip.c -- simulate gzip using the zlib compression library | 1 | /* minigzip.c -- simulate gzip using the zlib compression library |
| 2 | * Copyright (C) 1995 Jean-loup Gailly. | 2 | * Copyright (C) 1995-1996 Jean-loup Gailly. |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| @@ -13,7 +13,7 @@ | |||
| 13 | * or in pipe mode. | 13 | * or in pipe mode. |
| 14 | */ | 14 | */ |
| 15 | 15 | ||
| 16 | /* $Id: minigzip.c,v 1.5 1995/05/03 17:27:11 jloup Exp $ */ | 16 | /* $Id: minigzip.c,v 1.8 1996/01/30 21:59:23 me Exp $ */ |
| 17 | 17 | ||
| 18 | #include <stdio.h> | 18 | #include <stdio.h> |
| 19 | #include "zlib.h" | 19 | #include "zlib.h" |
| @@ -24,7 +24,7 @@ | |||
| 24 | #else | 24 | #else |
| 25 | extern void exit OF((int)); | 25 | extern void exit OF((int)); |
| 26 | #endif | 26 | #endif |
| 27 | extern int unlink OF((const char *)); | 27 | |
| 28 | 28 | ||
| 29 | #if defined(MSDOS) || defined(OS2) || defined(WIN32) | 29 | #if defined(MSDOS) || defined(OS2) || defined(WIN32) |
| 30 | # include <fcntl.h> | 30 | # include <fcntl.h> |
| @@ -35,12 +35,15 @@ extern int unlink OF((const char *)); | |||
| 35 | #endif | 35 | #endif |
| 36 | 36 | ||
| 37 | #ifdef VMS | 37 | #ifdef VMS |
| 38 | # define unlink delete | ||
| 38 | # define GZ_SUFFIX "-gz" | 39 | # define GZ_SUFFIX "-gz" |
| 39 | #else | 40 | #else |
| 40 | # define GZ_SUFFIX ".gz" | 41 | # define GZ_SUFFIX ".gz" |
| 41 | #endif | 42 | #endif |
| 42 | #define SUFFIX_LEN sizeof(GZ_SUFFIX) | 43 | #define SUFFIX_LEN sizeof(GZ_SUFFIX) |
| 43 | 44 | ||
| 45 | extern int unlink OF((const char *)); | ||
| 46 | |||
| 44 | #define BUFLEN 4096 | 47 | #define BUFLEN 4096 |
| 45 | #define MAX_NAME_LEN 1024 | 48 | #define MAX_NAME_LEN 1024 |
| 46 | 49 | ||
| @@ -52,7 +55,7 @@ extern int unlink OF((const char *)); | |||
| 52 | 55 | ||
| 53 | char *prog; | 56 | char *prog; |
| 54 | 57 | ||
| 55 | void error OF((char *msg)); | 58 | void error OF((const char *msg)); |
| 56 | void gz_compress OF((FILE *in, gzFile out)); | 59 | void gz_compress OF((FILE *in, gzFile out)); |
| 57 | void gz_uncompress OF((gzFile in, FILE *out)); | 60 | void gz_uncompress OF((gzFile in, FILE *out)); |
| 58 | void file_compress OF((char *file)); | 61 | void file_compress OF((char *file)); |
| @@ -63,7 +66,7 @@ int main OF((int argc, char *argv[])); | |||
| 63 | * Display error message and exit | 66 | * Display error message and exit |
| 64 | */ | 67 | */ |
| 65 | void error(msg) | 68 | void error(msg) |
| 66 | char *msg; | 69 | const char *msg; |
| 67 | { | 70 | { |
| 68 | fprintf(stderr, "%s: %s\n", prog, msg); | 71 | fprintf(stderr, "%s: %s\n", prog, msg); |
| 69 | exit(1); | 72 | exit(1); |
| @@ -88,7 +91,7 @@ void gz_compress(in, out) | |||
| 88 | } | 91 | } |
| 89 | if (len == 0) break; | 92 | if (len == 0) break; |
| 90 | 93 | ||
| 91 | if (gzwrite(out, buf, len) != len) error(gzerror(out, &err)); | 94 | if (gzwrite(out, buf, (unsigned)len) != len) error(gzerror(out, &err)); |
| 92 | } | 95 | } |
| 93 | fclose(in); | 96 | fclose(in); |
| 94 | if (gzclose(out) != Z_OK) error("failed gzclose"); | 97 | if (gzclose(out) != Z_OK) error("failed gzclose"); |
| @@ -110,7 +113,9 @@ void gz_uncompress(in, out) | |||
| 110 | if (len < 0) error (gzerror(in, &err)); | 113 | if (len < 0) error (gzerror(in, &err)); |
| 111 | if (len == 0) break; | 114 | if (len == 0) break; |
| 112 | 115 | ||
| 113 | if (fwrite(buf, 1, len, out) != (uInt)len) error("failed fwrite"); | 116 | if ((int)fwrite(buf, 1, (unsigned)len, out) != len) { |
| 117 | error("failed fwrite"); | ||
| 118 | } | ||
| 114 | } | 119 | } |
| 115 | if (fclose(out)) error("failed fclose"); | 120 | if (fclose(out)) error("failed fclose"); |
| 116 | 121 | ||
| @@ -1,5 +1,5 @@ | |||
| 1 | /* trees.c -- output deflated data using Huffman coding | 1 | /* trees.c -- output deflated data using Huffman coding |
| 2 | * Copyright (C) 1995 Jean-loup Gailly | 2 | * Copyright (C) 1995-1996 Jean-loup Gailly |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| @@ -83,7 +83,7 @@ local uch bl_order[BL_CODES] | |||
| 83 | local ct_data static_ltree[L_CODES+2]; | 83 | local ct_data static_ltree[L_CODES+2]; |
| 84 | /* The static literal tree. Since the bit lengths are imposed, there is no | 84 | /* The static literal tree. Since the bit lengths are imposed, there is no |
| 85 | * need for the L_CODES extra codes used during heap construction. However | 85 | * need for the L_CODES extra codes used during heap construction. However |
| 86 | * The codes 286 and 287 are needed to build a canonical tree (see tr_init | 86 | * The codes 286 and 287 are needed to build a canonical tree (see _tr_init |
| 87 | * below). | 87 | * below). |
| 88 | */ | 88 | */ |
| 89 | 89 | ||
| @@ -232,7 +232,7 @@ local void send_bits(s, value, length) | |||
| 232 | */ | 232 | */ |
| 233 | local void tr_static_init() | 233 | local void tr_static_init() |
| 234 | { | 234 | { |
| 235 | static static_init_done = 0; | 235 | static int static_init_done = 0; |
| 236 | int n; /* iterates over tree elements */ | 236 | int n; /* iterates over tree elements */ |
| 237 | int bits; /* bit counter */ | 237 | int bits; /* bit counter */ |
| 238 | int length; /* length value */ | 238 | int length; /* length value */ |
| @@ -292,7 +292,7 @@ local void tr_static_init() | |||
| 292 | /* The static distance tree is trivial: */ | 292 | /* The static distance tree is trivial: */ |
| 293 | for (n = 0; n < D_CODES; n++) { | 293 | for (n = 0; n < D_CODES; n++) { |
| 294 | static_dtree[n].Len = 5; | 294 | static_dtree[n].Len = 5; |
| 295 | static_dtree[n].Code = bi_reverse(n, 5); | 295 | static_dtree[n].Code = bi_reverse((unsigned)n, 5); |
| 296 | } | 296 | } |
| 297 | static_init_done = 1; | 297 | static_init_done = 1; |
| 298 | } | 298 | } |
| @@ -300,7 +300,7 @@ local void tr_static_init() | |||
| 300 | /* =========================================================================== | 300 | /* =========================================================================== |
| 301 | * Initialize the tree data structures for a new zlib stream. | 301 | * Initialize the tree data structures for a new zlib stream. |
| 302 | */ | 302 | */ |
| 303 | void tr_init(s) | 303 | void _tr_init(s) |
| 304 | deflate_state *s; | 304 | deflate_state *s; |
| 305 | { | 305 | { |
| 306 | tr_static_init(); | 306 | tr_static_init(); |
| @@ -785,14 +785,14 @@ local void send_all_trees(s, lcodes, dcodes, blcodes) | |||
| 785 | /* =========================================================================== | 785 | /* =========================================================================== |
| 786 | * Send a stored block | 786 | * Send a stored block |
| 787 | */ | 787 | */ |
| 788 | void tr_stored_block(s, buf, stored_len, eof) | 788 | void _tr_stored_block(s, buf, stored_len, eof) |
| 789 | deflate_state *s; | 789 | deflate_state *s; |
| 790 | charf *buf; /* input block */ | 790 | charf *buf; /* input block */ |
| 791 | ulg stored_len; /* length of input block */ | 791 | ulg stored_len; /* length of input block */ |
| 792 | int eof; /* true if this is the last block for a file */ | 792 | int eof; /* true if this is the last block for a file */ |
| 793 | { | 793 | { |
| 794 | send_bits(s, (STORED_BLOCK<<1)+eof, 3); /* send block type */ | 794 | send_bits(s, (STORED_BLOCK<<1)+eof, 3); /* send block type */ |
| 795 | s->compressed_len = (s->compressed_len + 3 + 7) & ~7L; | 795 | s->compressed_len = (s->compressed_len + 3 + 7) & (ulg)~7L; |
| 796 | s->compressed_len += (stored_len + 4) << 3; | 796 | s->compressed_len += (stored_len + 4) << 3; |
| 797 | 797 | ||
| 798 | copy_block(s, buf, (unsigned)stored_len, 1); /* with header */ | 798 | copy_block(s, buf, (unsigned)stored_len, 1); /* with header */ |
| @@ -809,7 +809,7 @@ void tr_stored_block(s, buf, stored_len, eof) | |||
| 809 | * To simplify the code, we assume the worst case of last real code encoded | 809 | * To simplify the code, we assume the worst case of last real code encoded |
| 810 | * on one bit only. | 810 | * on one bit only. |
| 811 | */ | 811 | */ |
| 812 | void tr_align(s) | 812 | void _tr_align(s) |
| 813 | deflate_state *s; | 813 | deflate_state *s; |
| 814 | { | 814 | { |
| 815 | send_bits(s, STATIC_TREES<<1, 3); | 815 | send_bits(s, STATIC_TREES<<1, 3); |
| @@ -835,20 +835,20 @@ void tr_align(s) | |||
| 835 | * trees or store, and output the encoded block to the zip file. This function | 835 | * trees or store, and output the encoded block to the zip file. This function |
| 836 | * returns the total compressed length for the file so far. | 836 | * returns the total compressed length for the file so far. |
| 837 | */ | 837 | */ |
| 838 | ulg tr_flush_block(s, buf, stored_len, eof) | 838 | ulg _tr_flush_block(s, buf, stored_len, eof) |
| 839 | deflate_state *s; | 839 | deflate_state *s; |
| 840 | charf *buf; /* input block, or NULL if too old */ | 840 | charf *buf; /* input block, or NULL if too old */ |
| 841 | ulg stored_len; /* length of input block */ | 841 | ulg stored_len; /* length of input block */ |
| 842 | int eof; /* true if this is the last block for a file */ | 842 | int eof; /* true if this is the last block for a file */ |
| 843 | { | 843 | { |
| 844 | ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ | 844 | ulg opt_lenb, static_lenb; /* opt_len and static_len in bytes */ |
| 845 | int max_blindex; /* index of last bit length code of non zero freq */ | 845 | int max_blindex = 0; /* index of last bit length code of non zero freq */ |
| 846 | 846 | ||
| 847 | /* Build the Huffman trees unless a stored block is forced */ | 847 | /* Build the Huffman trees unless a stored block is forced */ |
| 848 | if (s->level > 0) { | 848 | if (s->level > 0) { |
| 849 | 849 | ||
| 850 | /* Check if the file is ascii or binary */ | 850 | /* Check if the file is ascii or binary */ |
| 851 | if (s->data_type == UNKNOWN) set_data_type(s); | 851 | if (s->data_type == Z_UNKNOWN) set_data_type(s); |
| 852 | 852 | ||
| 853 | /* Construct the literal and distance trees */ | 853 | /* Construct the literal and distance trees */ |
| 854 | build_tree(s, (tree_desc *)(&(s->l_desc))); | 854 | build_tree(s, (tree_desc *)(&(s->l_desc))); |
| @@ -879,7 +879,7 @@ ulg tr_flush_block(s, buf, stored_len, eof) | |||
| 879 | 879 | ||
| 880 | } else { | 880 | } else { |
| 881 | Assert(buf != (char*)0, "lost buf"); | 881 | Assert(buf != (char*)0, "lost buf"); |
| 882 | opt_lenb = stored_len + 5; /* force a stored block */ | 882 | opt_lenb = static_lenb = stored_len + 5; /* force a stored block */ |
| 883 | } | 883 | } |
| 884 | 884 | ||
| 885 | /* If compression failed and this is the first and last block, | 885 | /* If compression failed and this is the first and last block, |
| @@ -913,7 +913,7 @@ ulg tr_flush_block(s, buf, stored_len, eof) | |||
| 913 | * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to | 913 | * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to |
| 914 | * transform a block into a stored block. | 914 | * transform a block into a stored block. |
| 915 | */ | 915 | */ |
| 916 | tr_stored_block(s, buf, stored_len, eof); | 916 | _tr_stored_block(s, buf, stored_len, eof); |
| 917 | 917 | ||
| 918 | #ifdef FORCE_STATIC | 918 | #ifdef FORCE_STATIC |
| 919 | } else if (static_lenb >= 0) { /* force static trees */ | 919 | } else if (static_lenb >= 0) { /* force static trees */ |
| @@ -947,10 +947,10 @@ ulg tr_flush_block(s, buf, stored_len, eof) | |||
| 947 | * Save the match info and tally the frequency counts. Return true if | 947 | * Save the match info and tally the frequency counts. Return true if |
| 948 | * the current block must be flushed. | 948 | * the current block must be flushed. |
| 949 | */ | 949 | */ |
| 950 | int tr_tally (s, dist, lc) | 950 | int _tr_tally (s, dist, lc) |
| 951 | deflate_state *s; | 951 | deflate_state *s; |
| 952 | int dist; /* distance of matched string */ | 952 | unsigned dist; /* distance of matched string */ |
| 953 | int lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ | 953 | unsigned lc; /* match length-MIN_MATCH or unmatched char (if dist==0) */ |
| 954 | { | 954 | { |
| 955 | s->d_buf[s->last_lit] = (ush)dist; | 955 | s->d_buf[s->last_lit] = (ush)dist; |
| 956 | s->l_buf[s->last_lit++] = (uch)lc; | 956 | s->l_buf[s->last_lit++] = (uch)lc; |
| @@ -963,7 +963,7 @@ int tr_tally (s, dist, lc) | |||
| 963 | dist--; /* dist = match distance - 1 */ | 963 | dist--; /* dist = match distance - 1 */ |
| 964 | Assert((ush)dist < (ush)MAX_DIST(s) && | 964 | Assert((ush)dist < (ush)MAX_DIST(s) && |
| 965 | (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && | 965 | (ush)lc <= (ush)(MAX_MATCH-MIN_MATCH) && |
| 966 | (ush)d_code(dist) < (ush)D_CODES, "tr_tally: bad match"); | 966 | (ush)d_code(dist) < (ush)D_CODES, "_tr_tally: bad match"); |
| 967 | 967 | ||
| 968 | s->dyn_ltree[length_code[lc]+LITERALS+1].Freq++; | 968 | s->dyn_ltree[length_code[lc]+LITERALS+1].Freq++; |
| 969 | s->dyn_dtree[d_code(dist)].Freq++; | 969 | s->dyn_dtree[d_code(dist)].Freq++; |
| @@ -1057,7 +1057,7 @@ local void set_data_type(s) | |||
| 1057 | while (n < 7) bin_freq += s->dyn_ltree[n++].Freq; | 1057 | while (n < 7) bin_freq += s->dyn_ltree[n++].Freq; |
| 1058 | while (n < 128) ascii_freq += s->dyn_ltree[n++].Freq; | 1058 | while (n < 128) ascii_freq += s->dyn_ltree[n++].Freq; |
| 1059 | while (n < LITERALS) bin_freq += s->dyn_ltree[n++].Freq; | 1059 | while (n < LITERALS) bin_freq += s->dyn_ltree[n++].Freq; |
| 1060 | s->data_type = (Byte)(bin_freq > (ascii_freq >> 2) ? BINARY : ASCII); | 1060 | s->data_type = (Byte)(bin_freq > (ascii_freq >> 2) ? Z_BINARY : Z_ASCII); |
| 1061 | } | 1061 | } |
| 1062 | 1062 | ||
| 1063 | /* =========================================================================== | 1063 | /* =========================================================================== |
| @@ -1,9 +1,9 @@ | |||
| 1 | /* uncompr.c -- decompress a memory buffer | 1 | /* uncompr.c -- decompress a memory buffer |
| 2 | * Copyright (C) 1995 Jean-loup Gailly. | 2 | * Copyright (C) 1995-1996 Jean-loup Gailly. |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| 6 | /* $Id: uncompr.c,v 1.5 1995/05/03 17:27:12 jloup Exp $ */ | 6 | /* $Id: uncompr.c,v 1.8 1996/01/30 21:59:26 me Exp $ */ |
| 7 | 7 | ||
| 8 | #include "zlib.h" | 8 | #include "zlib.h" |
| 9 | 9 | ||
| @@ -25,13 +25,13 @@ | |||
| 25 | int uncompress (dest, destLen, source, sourceLen) | 25 | int uncompress (dest, destLen, source, sourceLen) |
| 26 | Bytef *dest; | 26 | Bytef *dest; |
| 27 | uLongf *destLen; | 27 | uLongf *destLen; |
| 28 | Bytef *source; | 28 | const Bytef *source; |
| 29 | uLong sourceLen; | 29 | uLong sourceLen; |
| 30 | { | 30 | { |
| 31 | z_stream stream; | 31 | z_stream stream; |
| 32 | int err; | 32 | int err; |
| 33 | 33 | ||
| 34 | stream.next_in = source; | 34 | stream.next_in = (Bytef*)source; |
| 35 | stream.avail_in = (uInt)sourceLen; | 35 | stream.avail_in = (uInt)sourceLen; |
| 36 | /* Check for source > 64K on 16-bit machine: */ | 36 | /* Check for source > 64K on 16-bit machine: */ |
| 37 | if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; | 37 | if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR; |
| @@ -1,5 +1,5 @@ | |||
| 1 | /* zconf.h -- configuration of the zlib compression library | 1 | /* zconf.h -- configuration of the zlib compression library |
| 2 | * Copyright (C) 1995 Jean-loup Gailly. | 2 | * Copyright (C) 1995-1996 Jean-loup Gailly. |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| @@ -9,11 +9,42 @@ | |||
| 9 | #define _ZCONF_H | 9 | #define _ZCONF_H |
| 10 | 10 | ||
| 11 | /* | 11 | /* |
| 12 | The library does not install any signal handler. It is recommended to | 12 | * If you *really* need a unique prefix for all types and library functions, |
| 13 | add at least a handler for SIGSEGV when decompressing; the library checks | 13 | * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. |
| 14 | the consistency of the input data whenever possible but may go nuts | ||
| 15 | for some forms of corrupted input. | ||
| 16 | */ | 14 | */ |
| 15 | #ifdef Z_PREFIX | ||
| 16 | # define deflateInit_ z_deflateInit_ | ||
| 17 | # define deflate z_deflate | ||
| 18 | # define deflateEnd z_deflateEnd | ||
| 19 | # define inflateInit_ z_inflateInit_ | ||
| 20 | # define inflate z_inflate | ||
| 21 | # define inflateEnd z_inflateEnd | ||
| 22 | # define deflateInit2_ z_deflateInit2_ | ||
| 23 | # define deflateSetDictionary z_deflateSetDictionary | ||
| 24 | # define deflateCopy z_deflateCopy | ||
| 25 | # define deflateReset z_deflateReset | ||
| 26 | # define deflateParams z_deflateParams | ||
| 27 | # define inflateInit2_ z_inflateInit2_ | ||
| 28 | # define inflateSetDictionary z_inflateSetDictionary | ||
| 29 | # define inflateSync z_inflateSync | ||
| 30 | # define inflateReset z_inflateReset | ||
| 31 | # define compress z_compress | ||
| 32 | # define uncompress z_uncompress | ||
| 33 | # define adler32 z_adler32 | ||
| 34 | # define crc32 z_crc32 | ||
| 35 | # define get_crc_table z_get_crc_table | ||
| 36 | |||
| 37 | # define Byte z_Byte | ||
| 38 | # define uInt z_uInt | ||
| 39 | # define uLong z_uLong | ||
| 40 | /* # define Bytef z_Bytef */ | ||
| 41 | # define charf z_charf | ||
| 42 | # define intf z_intf | ||
| 43 | # define uIntf z_uIntf | ||
| 44 | # define uLongf z_uLongf | ||
| 45 | # define voidpf z_voidpf | ||
| 46 | # define voidp z_voidp | ||
| 47 | #endif | ||
| 17 | 48 | ||
| 18 | #if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32) | 49 | #if (defined(_WIN32) || defined(__WIN32__)) && !defined(WIN32) |
| 19 | # define WIN32 | 50 | # define WIN32 |
| @@ -43,12 +74,15 @@ | |||
| 43 | # define STDC | 74 | # define STDC |
| 44 | #endif | 75 | #endif |
| 45 | 76 | ||
| 46 | #if !defined(STDC) && !defined(const) | 77 | #ifndef STDC |
| 47 | # define const | 78 | # ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ |
| 79 | # define const | ||
| 80 | # endif | ||
| 48 | #endif | 81 | #endif |
| 49 | 82 | ||
| 50 | #ifdef __MWERKS__ /* Metrowerks CodeWarrior declares fileno() in unix.h */ | 83 | #ifdef __MWERKS__ /* Metrowerks CodeWarrior declares fileno() in unix.h */ |
| 51 | # include <unix.h> | 84 | # include <unix.h> |
| 85 | # define NO_DUMMY_DECL /* buggy compiler merges all .h files incorrectly */ | ||
| 52 | #endif | 86 | #endif |
| 53 | 87 | ||
| 54 | /* Maximum value for memLevel in deflateInit2 */ | 88 | /* Maximum value for memLevel in deflateInit2 */ |
| @@ -95,6 +129,7 @@ | |||
| 95 | * just define FAR to be empty. | 129 | * just define FAR to be empty. |
| 96 | */ | 130 | */ |
| 97 | #if defined(M_I86SM) || defined(M_I86MM) /* MSC small or medium model */ | 131 | #if defined(M_I86SM) || defined(M_I86MM) /* MSC small or medium model */ |
| 132 | # define SMALL_MEDIUM | ||
| 98 | # ifdef _MSC_VER | 133 | # ifdef _MSC_VER |
| 99 | # define FAR __far | 134 | # define FAR __far |
| 100 | # else | 135 | # else |
| @@ -102,20 +137,28 @@ | |||
| 102 | # endif | 137 | # endif |
| 103 | #endif | 138 | #endif |
| 104 | #if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__)) | 139 | #if defined(__BORLANDC__) && (defined(__SMALL__) || defined(__MEDIUM__)) |
| 105 | # define FAR _far /* completely untested, just a best guess */ | 140 | # define SMALL_MEDIUM |
| 141 | # define FAR __far | ||
| 106 | #endif | 142 | #endif |
| 107 | #ifndef FAR | 143 | #ifndef FAR |
| 108 | # define FAR | 144 | # define FAR |
| 109 | #endif | 145 | #endif |
| 146 | /* The Watcom compiler defines M_I86SM and __SMALL__ even in 32 bit mode */ | ||
| 147 | #if defined(__WATCOMC__) && defined(__386__) | ||
| 148 | # undef FAR | ||
| 149 | # define FAR | ||
| 150 | # undef SMALL_MEDIUM | ||
| 151 | #endif | ||
| 110 | 152 | ||
| 111 | typedef unsigned char Byte; /* 8 bits */ | 153 | typedef unsigned char Byte; /* 8 bits */ |
| 112 | typedef unsigned int uInt; /* 16 bits or more */ | 154 | typedef unsigned int uInt; /* 16 bits or more */ |
| 113 | typedef unsigned long uLong; /* 32 bits or more */ | 155 | typedef unsigned long uLong; /* 32 bits or more */ |
| 114 | 156 | ||
| 115 | typedef Byte FAR Bytef; | 157 | /* "typedef Byte FAR Bytef;" doesn't work with Borland C/C++ */ |
| 116 | typedef char FAR charf; | 158 | #define Bytef Byte FAR |
| 117 | typedef int FAR intf; | 159 | typedef char FAR charf; |
| 118 | typedef uInt FAR uIntf; | 160 | typedef int FAR intf; |
| 161 | typedef uInt FAR uIntf; | ||
| 119 | typedef uLong FAR uLongf; | 162 | typedef uLong FAR uLongf; |
| 120 | 163 | ||
| 121 | #ifdef STDC | 164 | #ifdef STDC |
| @@ -1,5 +1,5 @@ | |||
| 1 | /* zlib.h -- interface of the 'zlib' general purpose compression library | 1 | /* zlib.h -- interface of the 'zlib' general purpose compression library |
| 2 | version 1.0, Jan 14th, 1996. | 2 | version 1.0.1, May 20th, 1996. |
| 3 | 3 | ||
| 4 | Copyright (C) 1995-1996 Jean-loup Gailly and Mark Adler | 4 | Copyright (C) 1995-1996 Jean-loup Gailly and Mark Adler |
| 5 | 5 | ||
| @@ -32,7 +32,7 @@ extern "C" { | |||
| 32 | 32 | ||
| 33 | #include "zconf.h" | 33 | #include "zconf.h" |
| 34 | 34 | ||
| 35 | #define ZLIB_VERSION "1.0" | 35 | #define ZLIB_VERSION "1.0.1" |
| 36 | 36 | ||
| 37 | /* | 37 | /* |
| 38 | The 'zlib' compression library provides in-memory compression and | 38 | The 'zlib' compression library provides in-memory compression and |
| @@ -51,6 +51,11 @@ extern "C" { | |||
| 51 | repeated calls of the compression function. In the latter case, the | 51 | repeated calls of the compression function. In the latter case, the |
| 52 | application must provide more input and/or consume the output | 52 | application must provide more input and/or consume the output |
| 53 | (providing more output space) before each call. | 53 | (providing more output space) before each call. |
| 54 | |||
| 55 | The library does not install any signal handler. It is recommended to | ||
| 56 | add at least a handler for SIGSEGV when decompressing; the library checks | ||
| 57 | the consistency of the input data whenever possible but may go nuts | ||
| 58 | for some forms of corrupted input. | ||
| 54 | */ | 59 | */ |
| 55 | 60 | ||
| 56 | typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); | 61 | typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); |
| @@ -74,8 +79,9 @@ typedef struct z_stream_s { | |||
| 74 | free_func zfree; /* used to free the internal state */ | 79 | free_func zfree; /* used to free the internal state */ |
| 75 | voidpf opaque; /* private data object passed to zalloc and zfree */ | 80 | voidpf opaque; /* private data object passed to zalloc and zfree */ |
| 76 | 81 | ||
| 77 | Byte data_type; /* best guess about the data type: ascii or binary */ | 82 | int data_type; /* best guess about the data type: ascii or binary */ |
| 78 | 83 | uLong adler; /* adler32 value of the uncompressed data */ | |
| 84 | uLong reserved; /* reserved for future use */ | ||
| 79 | } z_stream; | 85 | } z_stream; |
| 80 | 86 | ||
| 81 | /* | 87 | /* |
| @@ -118,12 +124,16 @@ typedef struct z_stream_s { | |||
| 118 | 124 | ||
| 119 | #define Z_OK 0 | 125 | #define Z_OK 0 |
| 120 | #define Z_STREAM_END 1 | 126 | #define Z_STREAM_END 1 |
| 127 | #define Z_NEED_DICT 2 | ||
| 121 | #define Z_ERRNO (-1) | 128 | #define Z_ERRNO (-1) |
| 122 | #define Z_STREAM_ERROR (-2) | 129 | #define Z_STREAM_ERROR (-2) |
| 123 | #define Z_DATA_ERROR (-3) | 130 | #define Z_DATA_ERROR (-3) |
| 124 | #define Z_MEM_ERROR (-4) | 131 | #define Z_MEM_ERROR (-4) |
| 125 | #define Z_BUF_ERROR (-5) | 132 | #define Z_BUF_ERROR (-5) |
| 126 | /* error codes for the compression/decompression functions */ | 133 | #define Z_VERSION_ERROR (-6) |
| 134 | /* Return codes for the compression/decompression functions. Negative | ||
| 135 | * values are errors, positive values are used for special but normal events. | ||
| 136 | */ | ||
| 127 | 137 | ||
| 128 | #define Z_NO_COMPRESSION 0 | 138 | #define Z_NO_COMPRESSION 0 |
| 129 | #define Z_BEST_SPEED 1 | 139 | #define Z_BEST_SPEED 1 |
| @@ -134,18 +144,19 @@ typedef struct z_stream_s { | |||
| 134 | #define Z_FILTERED 1 | 144 | #define Z_FILTERED 1 |
| 135 | #define Z_HUFFMAN_ONLY 2 | 145 | #define Z_HUFFMAN_ONLY 2 |
| 136 | #define Z_DEFAULT_STRATEGY 0 | 146 | #define Z_DEFAULT_STRATEGY 0 |
| 147 | /* compression strategy; see deflateInit2() below for details */ | ||
| 137 | 148 | ||
| 138 | #define Z_BINARY 0 | 149 | #define Z_BINARY 0 |
| 139 | #define Z_ASCII 1 | 150 | #define Z_ASCII 1 |
| 140 | #define Z_UNKNOWN 2 | 151 | #define Z_UNKNOWN 2 |
| 141 | /* Used to set the data_type field */ | 152 | /* Possible values of the data_type field */ |
| 142 | 153 | ||
| 143 | #define Z_DEFLATED 8 | 154 | #define Z_DEFLATED 8 |
| 144 | /* The deflate compression method (the only one supported in this version) */ | 155 | /* The deflate compression method (the only one supported in this version) */ |
| 145 | 156 | ||
| 146 | #define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ | 157 | #define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ |
| 147 | 158 | ||
| 148 | extern char *zlib_version; | 159 | extern const char *zlib_version; |
| 149 | /* The application can compare zlib_version and ZLIB_VERSION for consistency. | 160 | /* The application can compare zlib_version and ZLIB_VERSION for consistency. |
| 150 | If the first character differs, the library code actually used is | 161 | If the first character differs, the library code actually used is |
| 151 | not compatible with the zlib.h header file used by the application. | 162 | not compatible with the zlib.h header file used by the application. |
| @@ -153,8 +164,9 @@ extern char *zlib_version; | |||
| 153 | 164 | ||
| 154 | /* basic functions */ | 165 | /* basic functions */ |
| 155 | 166 | ||
| 156 | extern int deflateInit OF((z_stream *strm, int level)); | ||
| 157 | /* | 167 | /* |
| 168 | extern int deflateInit OF((z_stream *strm, int level)); | ||
| 169 | |||
| 158 | Initializes the internal stream state for compression. The fields | 170 | Initializes the internal stream state for compression. The fields |
| 159 | zalloc, zfree and opaque must be initialized before by the caller. | 171 | zalloc, zfree and opaque must be initialized before by the caller. |
| 160 | If zalloc and zfree are set to Z_NULL, deflateInit updates them to | 172 | If zalloc and zfree are set to Z_NULL, deflateInit updates them to |
| @@ -167,7 +179,9 @@ extern int deflateInit OF((z_stream *strm, int level)); | |||
| 167 | compression (currently equivalent to level 6). | 179 | compression (currently equivalent to level 6). |
| 168 | 180 | ||
| 169 | deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not | 181 | deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not |
| 170 | enough memory, Z_STREAM_ERROR if level is not a valid compression level. | 182 | enough memory, Z_STREAM_ERROR if level is not a valid compression level, |
| 183 | Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible | ||
| 184 | with the version assumed by the caller (ZLIB_VERSION). | ||
| 171 | msg is set to null if there is no error message. deflateInit does not | 185 | msg is set to null if there is no error message. deflateInit does not |
| 172 | perform any compression: this will be done by deflate(). | 186 | perform any compression: this will be done by deflate(). |
| 173 | */ | 187 | */ |
| @@ -193,7 +207,9 @@ extern int deflate OF((z_stream *strm, int flush)); | |||
| 193 | more output, and updating avail_in or avail_out accordingly; avail_out | 207 | more output, and updating avail_in or avail_out accordingly; avail_out |
| 194 | should never be zero before the call. The application can consume the | 208 | should never be zero before the call. The application can consume the |
| 195 | compressed output when it wants, for example when the output buffer is full | 209 | compressed output when it wants, for example when the output buffer is full |
| 196 | (avail_out == 0), or after each call of deflate(). | 210 | (avail_out == 0), or after each call of deflate(). If deflate returns Z_OK |
| 211 | and with zero avail_out, it must be called again after making room in the | ||
| 212 | output buffer because there might be more output pending. | ||
| 197 | 213 | ||
| 198 | If the parameter flush is set to Z_PARTIAL_FLUSH, the current compression | 214 | If the parameter flush is set to Z_PARTIAL_FLUSH, the current compression |
| 199 | block is terminated and flushed to the output buffer so that the | 215 | block is terminated and flushed to the output buffer so that the |
| @@ -247,22 +263,26 @@ extern int deflateEnd OF((z_stream *strm)); | |||
| 247 | pending output. | 263 | pending output. |
| 248 | 264 | ||
| 249 | deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the | 265 | deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the |
| 250 | stream state was inconsistent. In the error case, msg may be set | 266 | stream state was inconsistent, Z_DATA_ERROR if the stream was freed |
| 251 | but then points to a static string (which must not be deallocated). | 267 | prematurely (some input or output was discarded). In the error case, |
| 268 | msg may be set but then points to a static string (which must not be | ||
| 269 | deallocated). | ||
| 252 | */ | 270 | */ |
| 253 | 271 | ||
| 254 | 272 | ||
| 255 | extern int inflateInit OF((z_stream *strm)); | ||
| 256 | /* | 273 | /* |
| 274 | extern int inflateInit OF((z_stream *strm)); | ||
| 275 | |||
| 257 | Initializes the internal stream state for decompression. The fields | 276 | Initializes the internal stream state for decompression. The fields |
| 258 | zalloc, zfree and opaque must be initialized before by the caller. If | 277 | zalloc, zfree and opaque must be initialized before by the caller. If |
| 259 | zalloc and zfree are set to Z_NULL, inflateInit updates them to use default | 278 | zalloc and zfree are set to Z_NULL, inflateInit updates them to use default |
| 260 | allocation functions. | 279 | allocation functions. |
| 261 | 280 | ||
| 262 | inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not | 281 | inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not |
| 263 | enough memory. msg is set to null if there is no error message. | 282 | enough memory, Z_VERSION_ERROR if the zlib library version is incompatible |
| 264 | inflateInit does not perform any decompression: this will be done by | 283 | with the version assumed by the caller. msg is set to null if there is no |
| 265 | inflate(). | 284 | error message. inflateInit does not perform any decompression: this will be |
| 285 | done by inflate(). | ||
| 266 | */ | 286 | */ |
| 267 | 287 | ||
| 268 | 288 | ||
| @@ -276,15 +296,18 @@ extern int inflate OF((z_stream *strm, int flush)); | |||
| 276 | will resume at this point for the next call of inflate(). | 296 | will resume at this point for the next call of inflate(). |
| 277 | 297 | ||
| 278 | - Provide more output starting at next_out and update next_out and avail_out | 298 | - Provide more output starting at next_out and update next_out and avail_out |
| 279 | accordingly. inflate() always provides as much output as possible | 299 | accordingly. inflate() provides as much output as possible, until there |
| 280 | (until there is no more input data or no more space in the output buffer). | 300 | is no more input data or no more space in the output buffer (see below |
| 301 | about the flush parameter). | ||
| 281 | 302 | ||
| 282 | Before the call of inflate(), the application should ensure that at least | 303 | Before the call of inflate(), the application should ensure that at least |
| 283 | one of the actions is possible, by providing more input and/or consuming | 304 | one of the actions is possible, by providing more input and/or consuming |
| 284 | more output, and updating the next_* and avail_* values accordingly. | 305 | more output, and updating the next_* and avail_* values accordingly. |
| 285 | The application can consume the uncompressed output when it wants, for | 306 | The application can consume the uncompressed output when it wants, for |
| 286 | example when the output buffer is full (avail_out == 0), or after each | 307 | example when the output buffer is full (avail_out == 0), or after each |
| 287 | call of inflate(). | 308 | call of inflate(). If inflate returns Z_OK and with zero avail_out, it |
| 309 | must be called again after making room in the output buffer because there | ||
| 310 | might be more output pending. | ||
| 288 | 311 | ||
| 289 | If the parameter flush is set to Z_PARTIAL_FLUSH, inflate flushes as much | 312 | If the parameter flush is set to Z_PARTIAL_FLUSH, inflate flushes as much |
| 290 | output as possible to the output buffer. The flushing behavior of inflate is | 313 | output as possible to the output buffer. The flushing behavior of inflate is |
| @@ -306,12 +329,15 @@ extern int inflate OF((z_stream *strm, int flush)); | |||
| 306 | inflate() returns Z_OK if some progress has been made (more input | 329 | inflate() returns Z_OK if some progress has been made (more input |
| 307 | processed or more output produced), Z_STREAM_END if the end of the | 330 | processed or more output produced), Z_STREAM_END if the end of the |
| 308 | compressed data has been reached and all uncompressed output has been | 331 | compressed data has been reached and all uncompressed output has been |
| 309 | produced, Z_DATA_ERROR if the input data was corrupted, Z_STREAM_ERROR if | 332 | produced, Z_NEED_DICT if a preset dictionary is needed at this point (see |
| 310 | the stream structure was inconsistent (for example if next_in or next_out | 333 | inflateSetDictionary below), Z_DATA_ERROR if the input data was corrupted, |
| 311 | was NULL), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR if no | 334 | Z_STREAM_ERROR if the stream structure was inconsistent (for example if |
| 312 | progress is possible or if there was not enough room in the output buffer | 335 | next_in or next_out was NULL), Z_MEM_ERROR if there was not enough memory, |
| 313 | when Z_FINISH is used. In the Z_DATA_ERROR case, the application may then | 336 | Z_BUF_ERROR if no progress is possible or if there was not enough room in |
| 314 | call inflateSync to look for a good compression block. | 337 | the output buffer when Z_FINISH is used. In the Z_DATA_ERROR case, the |
| 338 | application may then call inflateSync to look for a good compression block. | ||
| 339 | In the Z_NEED_DICT case, strm->adler is set to the Adler32 value of the | ||
| 340 | dictionary chosen by the compressor. | ||
| 315 | */ | 341 | */ |
| 316 | 342 | ||
| 317 | 343 | ||
| @@ -326,19 +352,20 @@ extern int inflateEnd OF((z_stream *strm)); | |||
| 326 | static string (which must not be deallocated). | 352 | static string (which must not be deallocated). |
| 327 | */ | 353 | */ |
| 328 | 354 | ||
| 329 | /* advanced functions */ | 355 | /* Advanced functions */ |
| 330 | 356 | ||
| 331 | /* | 357 | /* |
| 332 | The following functions are needed only in some special applications. | 358 | The following functions are needed only in some special applications. |
| 333 | */ | 359 | */ |
| 334 | 360 | ||
| 361 | /* | ||
| 335 | extern int deflateInit2 OF((z_stream *strm, | 362 | extern int deflateInit2 OF((z_stream *strm, |
| 336 | int level, | 363 | int level, |
| 337 | int method, | 364 | int method, |
| 338 | int windowBits, | 365 | int windowBits, |
| 339 | int memLevel, | 366 | int memLevel, |
| 340 | int strategy)); | 367 | int strategy)); |
| 341 | /* | 368 | |
| 342 | This is another version of deflateInit with more compression options. The | 369 | This is another version of deflateInit with more compression options. The |
| 343 | fields next_in, zalloc, zfree and opaque must be initialized before by | 370 | fields next_in, zalloc, zfree and opaque must be initialized before by |
| 344 | the caller. | 371 | the caller. |
| @@ -353,20 +380,22 @@ extern int deflateInit2 OF((z_stream *strm, | |||
| 353 | values of this parameter result in better compression at the expense of | 380 | values of this parameter result in better compression at the expense of |
| 354 | memory usage. The default value is 15 if deflateInit is used instead. | 381 | memory usage. The default value is 15 if deflateInit is used instead. |
| 355 | 382 | ||
| 356 | The memLevel parameter specifies how much memory should be allocated | 383 | The memLevel parameter specifies how much memory should be allocated |
| 357 | for the internal compression state. memLevel=1 uses minimum memory but | 384 | for the internal compression state. memLevel=1 uses minimum memory but |
| 358 | is slow and reduces compression ratio; memLevel=9 uses maximum memory | 385 | is slow and reduces compression ratio; memLevel=9 uses maximum memory |
| 359 | for optimal speed. The default value is 8. See zconf.h for total memory | 386 | for optimal speed. The default value is 8. See zconf.h for total memory |
| 360 | usage as a function of windowBits and memLevel. | 387 | usage as a function of windowBits and memLevel. |
| 361 | 388 | ||
| 362 | The strategy parameter is used to tune the compression algorithm. Use | 389 | The strategy parameter is used to tune the compression algorithm. Use the |
| 363 | the value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data | 390 | value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a |
| 364 | produced by a filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman | 391 | filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no |
| 365 | encoding only (no string match). Filtered data consists mostly of small | 392 | string match). Filtered data consists mostly of small values with a |
| 366 | values with a somewhat random distribution. In this case, the | 393 | somewhat random distribution. In this case, the compression algorithm is |
| 367 | compression algorithm is tuned to compress them better. The strategy | 394 | tuned to compress them better. The effect of Z_FILTERED is to force more |
| 368 | parameter only affects the compression ratio but not the correctness of | 395 | Huffman coding and less string matching; it is somewhat intermediate |
| 369 | the compressed output even if it is not set appropriately. | 396 | between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects |
| 397 | the compression ratio but not the correctness of the compressed output even | ||
| 398 | if it is not set appropriately. | ||
| 370 | 399 | ||
| 371 | If next_in is not null, the library will use this buffer to hold also | 400 | If next_in is not null, the library will use this buffer to hold also |
| 372 | some history information; the buffer must either hold the entire input | 401 | some history information; the buffer must either hold the entire input |
| @@ -385,9 +414,38 @@ extern int deflateInit2 OF((z_stream *strm, | |||
| 385 | not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as | 414 | not enough memory, Z_STREAM_ERROR if a parameter is invalid (such as |
| 386 | an invalid method). msg is set to null if there is no error message. | 415 | an invalid method). msg is set to null if there is no error message. |
| 387 | deflateInit2 does not perform any compression: this will be done by | 416 | deflateInit2 does not perform any compression: this will be done by |
| 388 | deflate(). | 417 | deflate(). |
| 389 | */ | 418 | */ |
| 390 | 419 | ||
| 420 | extern int deflateSetDictionary OF((z_stream *strm, | ||
| 421 | const Bytef *dictionary, | ||
| 422 | uInt dictLength)); | ||
| 423 | /* | ||
| 424 | Initializes the compression dictionary (history buffer) from the given | ||
| 425 | byte sequence without producing any compressed output. This function must | ||
| 426 | be called immediately after deflateInit or deflateInit2, before any call | ||
| 427 | of deflate. The compressor and decompressor must use exactly the same | ||
| 428 | dictionary (see inflateSetDictionary). | ||
| 429 | The dictionary should consist of strings (byte sequences) that are likely | ||
| 430 | to be encountered later in the data to be compressed, with the most commonly | ||
| 431 | used strings preferably put towards the end of the dictionary. Using a | ||
| 432 | dictionary is most useful when the data to be compressed is short and | ||
| 433 | can be predicted with good accuracy; the data can then be compressed better | ||
| 434 | than with the default empty dictionary. In this version of the library, | ||
| 435 | only the last 32K bytes of the dictionary are used. | ||
| 436 | Upon return of this function, strm->adler is set to the Adler32 value | ||
| 437 | of the dictionary; the decompressor may later use this value to determine | ||
| 438 | which dictionary has been used by the compressor. (The Adler32 value | ||
| 439 | applies to the whole dictionary even if only a subset of the dictionary is | ||
| 440 | actually used by the compressor.) | ||
| 441 | |||
| 442 | deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a | ||
| 443 | parameter is invalid (such as NULL dictionary) or the stream state | ||
| 444 | is inconsistent (for example if deflate has already been called for this | ||
| 445 | stream). deflateSetDictionary does not perform any compression: this will | ||
| 446 | be done by deflate(). | ||
| 447 | */ | ||
| 448 | |||
| 391 | extern int deflateCopy OF((z_stream *dest, | 449 | extern int deflateCopy OF((z_stream *dest, |
| 392 | z_stream *source)); | 450 | z_stream *source)); |
| 393 | /* | 451 | /* |
| @@ -398,14 +456,14 @@ extern int deflateCopy OF((z_stream *dest, | |||
| 398 | application to provide the correct values of next_out and avail_out for the | 456 | application to provide the correct values of next_out and avail_out for the |
| 399 | next call of deflate. | 457 | next call of deflate. |
| 400 | 458 | ||
| 401 | This function is useful when several compression strategies will be | 459 | This function can be useful when several compression strategies will be |
| 402 | tried, for example when there are several ways of pre-processing the input | 460 | tried, for example when there are several ways of pre-processing the input |
| 403 | data with a filter. The streams that will be discarded should then be freed | 461 | data with a filter. The streams that will be discarded should then be freed |
| 404 | by calling deflateEnd. Note that deflateCopy duplicates the internal | 462 | by calling deflateEnd. Note that deflateCopy duplicates the internal |
| 405 | compression state which can be quite large, so this strategy is slow and | 463 | compression state which can be quite large, so this strategy is slow and |
| 406 | can consume lots of memory. | 464 | can consume lots of memory. |
| 407 | 465 | ||
| 408 | deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not | 466 | deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not |
| 409 | enough memory, Z_STREAM_ERROR if the source stream state was inconsistent | 467 | enough memory, Z_STREAM_ERROR if the source stream state was inconsistent |
| 410 | (such as zalloc being NULL). msg is left unchanged in both source and | 468 | (such as zalloc being NULL). msg is left unchanged in both source and |
| 411 | destination. | 469 | destination. |
| @@ -431,13 +489,19 @@ extern int deflateParams OF((z_stream *strm, int level, int strategy)); | |||
| 431 | available so far is compressed with the old level (and may be flushed); | 489 | available so far is compressed with the old level (and may be flushed); |
| 432 | the new level will take effect only at the next call of deflate(). | 490 | the new level will take effect only at the next call of deflate(). |
| 433 | 491 | ||
| 492 | Before the call of deflateParams, the stream state must be set as for | ||
| 493 | a call of deflate(), since the currently available input may have to | ||
| 494 | be compressed and flushed. In particular, strm->avail_out must be non-zero. | ||
| 495 | |||
| 434 | deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source | 496 | deflateParams returns Z_OK if success, Z_STREAM_ERROR if the source |
| 435 | stream state was inconsistent or if a parameter was invalid. | 497 | stream state was inconsistent or if a parameter was invalid, Z_BUF_ERROR |
| 498 | if strm->avail_out was zero. | ||
| 436 | */ | 499 | */ |
| 437 | 500 | ||
| 501 | /* | ||
| 438 | extern int inflateInit2 OF((z_stream *strm, | 502 | extern int inflateInit2 OF((z_stream *strm, |
| 439 | int windowBits)); | 503 | int windowBits)); |
| 440 | /* | 504 | |
| 441 | This is another version of inflateInit with more compression options. The | 505 | This is another version of inflateInit with more compression options. The |
| 442 | fields next_out, zalloc, zfree and opaque must be initialized before by | 506 | fields next_out, zalloc, zfree and opaque must be initialized before by |
| 443 | the caller. | 507 | the caller. |
| @@ -469,6 +533,25 @@ extern int inflateInit2 OF((z_stream *strm, | |||
| 469 | inflate(). | 533 | inflate(). |
| 470 | */ | 534 | */ |
| 471 | 535 | ||
| 536 | extern int inflateSetDictionary OF((z_stream *strm, | ||
| 537 | const Bytef *dictionary, | ||
| 538 | uInt dictLength)); | ||
| 539 | /* | ||
| 540 | Initializes the decompression dictionary (history buffer) from the given | ||
| 541 | uncompressed byte sequence. This function must be called immediately after | ||
| 542 | a call of inflate if this call returned Z_NEED_DICT. The dictionary chosen | ||
| 543 | by the compressor can be determined from the Adler32 value returned by this | ||
| 544 | call of inflate. The compressor and decompressor must use exactly the same | ||
| 545 | dictionary (see deflateSetDictionary). | ||
| 546 | |||
| 547 | inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a | ||
| 548 | parameter is invalid (such as NULL dictionary) or the stream state is | ||
| 549 | inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the | ||
| 550 | expected one (incorrect Adler32 value). inflateSetDictionary does not | ||
| 551 | perform any decompression: this will be done by subsequent calls of | ||
| 552 | inflate(). | ||
| 553 | */ | ||
| 554 | |||
| 472 | extern int inflateSync OF((z_stream *strm)); | 555 | extern int inflateSync OF((z_stream *strm)); |
| 473 | /* | 556 | /* |
| 474 | Skips invalid compressed data until the special marker (see deflate() | 557 | Skips invalid compressed data until the special marker (see deflate() |
| @@ -506,7 +589,7 @@ extern int inflateReset OF((z_stream *strm)); | |||
| 506 | */ | 589 | */ |
| 507 | 590 | ||
| 508 | extern int compress OF((Bytef *dest, uLongf *destLen, | 591 | extern int compress OF((Bytef *dest, uLongf *destLen, |
| 509 | Bytef *source, uLong sourceLen)); | 592 | const Bytef *source, uLong sourceLen)); |
| 510 | /* | 593 | /* |
| 511 | Compresses the source buffer into the destination buffer. sourceLen is | 594 | Compresses the source buffer into the destination buffer. sourceLen is |
| 512 | the byte length of the source buffer. Upon entry, destLen is the total | 595 | the byte length of the source buffer. Upon entry, destLen is the total |
| @@ -521,7 +604,7 @@ extern int compress OF((Bytef *dest, uLongf *destLen, | |||
| 521 | */ | 604 | */ |
| 522 | 605 | ||
| 523 | extern int uncompress OF((Bytef *dest, uLongf *destLen, | 606 | extern int uncompress OF((Bytef *dest, uLongf *destLen, |
| 524 | Bytef *source, uLong sourceLen)); | 607 | const Bytef *source, uLong sourceLen)); |
| 525 | /* | 608 | /* |
| 526 | Decompresses the source buffer into the destination buffer. sourceLen is | 609 | Decompresses the source buffer into the destination buffer. sourceLen is |
| 527 | the byte length of the source buffer. Upon entry, destLen is the total | 610 | the byte length of the source buffer. Upon entry, destLen is the total |
| @@ -541,7 +624,7 @@ extern int uncompress OF((Bytef *dest, uLongf *destLen, | |||
| 541 | 624 | ||
| 542 | typedef voidp gzFile; | 625 | typedef voidp gzFile; |
| 543 | 626 | ||
| 544 | extern gzFile gzopen OF((char *path, char *mode)); | 627 | extern gzFile gzopen OF((const char *path, const char *mode)); |
| 545 | /* | 628 | /* |
| 546 | Opens a gzip (.gz) file for reading or writing. The mode parameter | 629 | Opens a gzip (.gz) file for reading or writing. The mode parameter |
| 547 | is as in fopen ("rb" or "wb") but can also include a compression level | 630 | is as in fopen ("rb" or "wb") but can also include a compression level |
| @@ -553,12 +636,15 @@ extern gzFile gzopen OF((char *path, char *mode)); | |||
| 553 | zlib error is Z_MEM_ERROR). | 636 | zlib error is Z_MEM_ERROR). |
| 554 | */ | 637 | */ |
| 555 | 638 | ||
| 556 | extern gzFile gzdopen OF((int fd, char *mode)); | 639 | extern gzFile gzdopen OF((int fd, const char *mode)); |
| 557 | /* | 640 | /* |
| 558 | gzdopen() associates a gzFile with the file descriptor fd. File | 641 | gzdopen() associates a gzFile with the file descriptor fd. File |
| 559 | descriptors are obtained from calls like open, dup, creat, pipe or | 642 | descriptors are obtained from calls like open, dup, creat, pipe or |
| 560 | fileno (in the file has been previously opened with fopen). | 643 | fileno (in the file has been previously opened with fopen). |
| 561 | The mode parameter is as in fopen ("rb" or "wb"). | 644 | The mode parameter is as in gzopen. |
| 645 | The next call of gzclose on the returned gzFile will also close the | ||
| 646 | file descriptor fd, just like fclose(fdopen(fd), mode) closes the file | ||
| 647 | descriptor fd. If you want to keep fd open, use gzdopen(dup(fd), mode). | ||
| 562 | gzdopen returns NULL if there was insufficient memory to allocate | 648 | gzdopen returns NULL if there was insufficient memory to allocate |
| 563 | the (de)compression state. | 649 | the (de)compression state. |
| 564 | */ | 650 | */ |
| @@ -571,7 +657,7 @@ extern int gzread OF((gzFile file, voidp buf, unsigned len)); | |||
| 571 | gzread returns the number of uncompressed bytes actually read (0 for | 657 | gzread returns the number of uncompressed bytes actually read (0 for |
| 572 | end of file, -1 for error). */ | 658 | end of file, -1 for error). */ |
| 573 | 659 | ||
| 574 | extern int gzwrite OF((gzFile file, voidp buf, unsigned len)); | 660 | extern int gzwrite OF((gzFile file, const voidp buf, unsigned len)); |
| 575 | /* | 661 | /* |
| 576 | Writes the given number of uncompressed bytes into the compressed file. | 662 | Writes the given number of uncompressed bytes into the compressed file. |
| 577 | gzwrite returns the number of uncompressed bytes actually written | 663 | gzwrite returns the number of uncompressed bytes actually written |
| @@ -612,7 +698,7 @@ extern char* gzerror OF((gzFile file, int *errnum)); | |||
| 612 | compression library. | 698 | compression library. |
| 613 | */ | 699 | */ |
| 614 | 700 | ||
| 615 | extern uLong adler32 OF((uLong adler, Bytef *buf, uInt len)); | 701 | extern uLong adler32 OF((uLong adler, const Bytef *buf, uInt len)); |
| 616 | 702 | ||
| 617 | /* | 703 | /* |
| 618 | Update a running Adler-32 checksum with the bytes buf[0..len-1] and | 704 | Update a running Adler-32 checksum with the bytes buf[0..len-1] and |
| @@ -629,7 +715,7 @@ extern uLong adler32 OF((uLong adler, Bytef *buf, uInt len)); | |||
| 629 | if (adler != original_adler) error(); | 715 | if (adler != original_adler) error(); |
| 630 | */ | 716 | */ |
| 631 | 717 | ||
| 632 | extern uLong crc32 OF((uLong crc, Bytef *buf, uInt len)); | 718 | extern uLong crc32 OF((uLong crc, const Bytef *buf, uInt len)); |
| 633 | /* | 719 | /* |
| 634 | Update a running crc with the bytes buf[0..len-1] and return the updated | 720 | Update a running crc with the bytes buf[0..len-1] and return the updated |
| 635 | crc. If buf is NULL, this function returns the required initial value | 721 | crc. If buf is NULL, this function returns the required initial value |
| @@ -645,10 +731,37 @@ extern uLong crc32 OF((uLong crc, Bytef *buf, uInt len)); | |||
| 645 | if (crc != original_crc) error(); | 731 | if (crc != original_crc) error(); |
| 646 | */ | 732 | */ |
| 647 | 733 | ||
| 648 | #ifndef _Z_UTIL_H | 734 | |
| 735 | /* various hacks, don't look :) */ | ||
| 736 | |||
| 737 | /* deflateInit and inflateInit are macros to allow checking the zlib version | ||
| 738 | * and the compiler's view of z_stream: | ||
| 739 | */ | ||
| 740 | extern int deflateInit_ OF((z_stream *strm, int level, | ||
| 741 | const char *version, int stream_size)); | ||
| 742 | extern int inflateInit_ OF((z_stream *strm, | ||
| 743 | const char *version, int stream_size)); | ||
| 744 | extern int deflateInit2_ OF((z_stream *strm, int level, int method, | ||
| 745 | int windowBits, int memLevel, int strategy, | ||
| 746 | const char *version, int stream_size)); | ||
| 747 | extern int inflateInit2_ OF((z_stream *strm, int windowBits, | ||
| 748 | const char *version, int stream_size)); | ||
| 749 | #define deflateInit(strm, level) \ | ||
| 750 | deflateInit_((strm), (level), ZLIB_VERSION, sizeof(z_stream)) | ||
| 751 | #define inflateInit(strm) \ | ||
| 752 | inflateInit_((strm), ZLIB_VERSION, sizeof(z_stream)) | ||
| 753 | #define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ | ||
| 754 | deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ | ||
| 755 | (strategy), ZLIB_VERSION, sizeof(z_stream)) | ||
| 756 | #define inflateInit2(strm, windowBits) \ | ||
| 757 | inflateInit2_((strm), (windowBits), ZLIB_VERSION, sizeof(z_stream)) | ||
| 758 | |||
| 759 | #if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL) | ||
| 649 | struct internal_state {int dummy;}; /* hack for buggy compilers */ | 760 | struct internal_state {int dummy;}; /* hack for buggy compilers */ |
| 650 | #endif | 761 | #endif |
| 651 | 762 | ||
| 763 | uLongf *get_crc_table OF((void)); /* can be used by asm versions of crc32() */ | ||
| 764 | |||
| 652 | #ifdef __cplusplus | 765 | #ifdef __cplusplus |
| 653 | } | 766 | } |
| 654 | #endif | 767 | #endif |
| @@ -1,9 +1,9 @@ | |||
| 1 | /* zutil.c -- target dependent utility functions for the compression library | 1 | /* zutil.c -- target dependent utility functions for the compression library |
| 2 | * Copyright (C) 1995 Jean-loup Gailly. | 2 | * Copyright (C) 1995-1996 Jean-loup Gailly. |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| 6 | /* $Id: zutil.c,v 1.8 1995/05/03 17:27:12 jloup Exp $ */ | 6 | /* $Id: zutil.c,v 1.12 1996/01/30 21:59:29 me Exp $ */ |
| 7 | 7 | ||
| 8 | #include <stdio.h> | 8 | #include <stdio.h> |
| 9 | 9 | ||
| @@ -15,16 +15,18 @@ struct internal_state {int dummy;}; /* for buggy compilers */ | |||
| 15 | extern void exit OF((int)); | 15 | extern void exit OF((int)); |
| 16 | #endif | 16 | #endif |
| 17 | 17 | ||
| 18 | char *zlib_version = ZLIB_VERSION; | 18 | const char *zlib_version = ZLIB_VERSION; |
| 19 | 19 | ||
| 20 | char *z_errmsg[] = { | 20 | const char *z_errmsg[10] = { |
| 21 | "stream end", /* Z_STREAM_END 1 */ | 21 | "need dictionary", /* Z_NEED_DICT 2 */ |
| 22 | "", /* Z_OK 0 */ | 22 | "stream end", /* Z_STREAM_END 1 */ |
| 23 | "file error", /* Z_ERRNO (-1) */ | 23 | "", /* Z_OK 0 */ |
| 24 | "stream error", /* Z_STREAM_ERROR (-2) */ | 24 | "file error", /* Z_ERRNO (-1) */ |
| 25 | "data error", /* Z_DATA_ERROR (-3) */ | 25 | "stream error", /* Z_STREAM_ERROR (-2) */ |
| 26 | "insufficient memory", /* Z_MEM_ERROR (-4) */ | 26 | "data error", /* Z_DATA_ERROR (-3) */ |
| 27 | "buffer error", /* Z_BUF_ERROR (-5) */ | 27 | "insufficient memory", /* Z_MEM_ERROR (-4) */ |
| 28 | "buffer error", /* Z_BUF_ERROR (-5) */ | ||
| 29 | "incompatible version",/* Z_VERSION_ERROR (-6) */ | ||
| 28 | ""}; | 30 | ""}; |
| 29 | 31 | ||
| 30 | 32 | ||
| @@ -60,9 +62,9 @@ void zmemzero(dest, len) | |||
| 60 | #endif | 62 | #endif |
| 61 | 63 | ||
| 62 | #ifdef __TURBOC__ | 64 | #ifdef __TURBOC__ |
| 63 | #if !defined(__SMALL__) && !defined(__MEDIUM__) && !defined(__32BIT__) | 65 | #if (defined( __BORLANDC__) || !defined(SMALL_MEDIUM)) && !defined(__32BIT__) |
| 64 | /* Small and medium model are for now limited to near allocation with | 66 | /* Small and medium model in Turbo C are for now limited to near allocation |
| 65 | * reduced MAX_WBITS and MAX_MEM_LEVEL | 67 | * with reduced MAX_WBITS and MAX_MEM_LEVEL |
| 66 | */ | 68 | */ |
| 67 | # define MY_ZCALLOC | 69 | # define MY_ZCALLOC |
| 68 | 70 | ||
| @@ -100,9 +102,6 @@ voidpf zcalloc (voidpf opaque, unsigned items, unsigned size) | |||
| 100 | */ | 102 | */ |
| 101 | if (bsize < 65520L) { | 103 | if (bsize < 65520L) { |
| 102 | buf = farmalloc(bsize); | 104 | buf = farmalloc(bsize); |
| 103 | #ifdef DEBUG | ||
| 104 | zmemzero(buf, (uInt)bsize); | ||
| 105 | #endif | ||
| 106 | if (*(ush*)&buf != 0) return buf; | 105 | if (*(ush*)&buf != 0) return buf; |
| 107 | } else { | 106 | } else { |
| 108 | buf = farmalloc(bsize + 16L); | 107 | buf = farmalloc(bsize + 16L); |
| @@ -114,10 +113,6 @@ voidpf zcalloc (voidpf opaque, unsigned items, unsigned size) | |||
| 114 | *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4; | 113 | *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4; |
| 115 | *(ush*)&buf = 0; | 114 | *(ush*)&buf = 0; |
| 116 | table[next_ptr++].new_ptr = buf; | 115 | table[next_ptr++].new_ptr = buf; |
| 117 | #ifdef DEBUG | ||
| 118 | zmemzero(buf, (uInt)65535); | ||
| 119 | ((uch*)buf)[65535] = 0; | ||
| 120 | #endif | ||
| 121 | return buf; | 116 | return buf; |
| 122 | } | 117 | } |
| 123 | 118 | ||
| @@ -146,7 +141,8 @@ void zcfree (voidpf opaque, voidpf ptr) | |||
| 146 | #endif /* __TURBOC__ */ | 141 | #endif /* __TURBOC__ */ |
| 147 | 142 | ||
| 148 | 143 | ||
| 149 | #ifdef M_I86 /* Microsoft C */ | 144 | #if defined(M_I86) && !(defined(__WATCOMC__) && defined(__386__)) |
| 145 | /* Microsoft C */ | ||
| 150 | 146 | ||
| 151 | # define MY_ZCALLOC | 147 | # define MY_ZCALLOC |
| 152 | 148 | ||
| @@ -182,6 +178,7 @@ voidpf zcalloc (opaque, items, size) | |||
| 182 | unsigned items; | 178 | unsigned items; |
| 183 | unsigned size; | 179 | unsigned size; |
| 184 | { | 180 | { |
| 181 | if (opaque) items += size - size; /* make compiler happy */ | ||
| 185 | return (voidpf)calloc(items, size); | 182 | return (voidpf)calloc(items, size); |
| 186 | } | 183 | } |
| 187 | 184 | ||
| @@ -190,6 +187,7 @@ void zcfree (opaque, ptr) | |||
| 190 | voidpf ptr; | 187 | voidpf ptr; |
| 191 | { | 188 | { |
| 192 | free(ptr); | 189 | free(ptr); |
| 190 | if (opaque) return; /* make compiler happy */ | ||
| 193 | } | 191 | } |
| 194 | 192 | ||
| 195 | #endif /* MY_ZCALLOC */ | 193 | #endif /* MY_ZCALLOC */ |
| @@ -1,5 +1,5 @@ | |||
| 1 | /* zutil.h -- internal interface and configuration of the compression library | 1 | /* zutil.h -- internal interface and configuration of the compression library |
| 2 | * Copyright (C) 1995 Jean-loup Gailly. | 2 | * Copyright (C) 1995-1996 Jean-loup Gailly. |
| 3 | * For conditions of distribution and use, see copyright notice in zlib.h | 3 | * For conditions of distribution and use, see copyright notice in zlib.h |
| 4 | */ | 4 | */ |
| 5 | 5 | ||
| @@ -8,14 +8,14 @@ | |||
| 8 | subject to change. Applications should only use zlib.h. | 8 | subject to change. Applications should only use zlib.h. |
| 9 | */ | 9 | */ |
| 10 | 10 | ||
| 11 | /* $Id: zutil.h,v 1.9 1995/05/03 17:27:12 jloup Exp $ */ | 11 | /* $Id: zutil.h,v 1.13 1996/01/30 21:59:29 me Exp $ */ |
| 12 | 12 | ||
| 13 | #ifndef _Z_UTIL_H | 13 | #ifndef _Z_UTIL_H |
| 14 | #define _Z_UTIL_H | 14 | #define _Z_UTIL_H |
| 15 | 15 | ||
| 16 | #include "zlib.h" | 16 | #include "zlib.h" |
| 17 | 17 | ||
| 18 | #if defined(MSDOS) || defined(VMS) || defined(CRAY) | 18 | #if defined(MSDOS) || defined(VMS) || defined(CRAY) || defined(WIN32) |
| 19 | # include <stddef.h> | 19 | # include <stddef.h> |
| 20 | # include <errno.h> | 20 | # include <errno.h> |
| 21 | #else | 21 | #else |
| @@ -37,9 +37,13 @@ typedef unsigned short ush; | |||
| 37 | typedef ush FAR ushf; | 37 | typedef ush FAR ushf; |
| 38 | typedef unsigned long ulg; | 38 | typedef unsigned long ulg; |
| 39 | 39 | ||
| 40 | extern char *z_errmsg[]; /* indexed by 1-zlib_error */ | 40 | extern const char *z_errmsg[10]; /* indexed by 2-zlib_error */ |
| 41 | /* (size given to avoid silly warnings with Visual C++) */ | ||
| 41 | 42 | ||
| 42 | #define ERR_RETURN(strm,err) return (strm->msg = z_errmsg[1-(err)], (err)) | 43 | #define ERR_MSG(err) (char*)z_errmsg[Z_NEED_DICT-(err)] |
| 44 | |||
| 45 | #define ERR_RETURN(strm,err) \ | ||
| 46 | return (strm->msg = ERR_MSG(err), (err)) | ||
| 43 | /* To be used only when the state is known to be valid */ | 47 | /* To be used only when the state is known to be valid */ |
| 44 | 48 | ||
| 45 | /* common constants */ | 49 | /* common constants */ |
| @@ -65,6 +69,8 @@ extern char *z_errmsg[]; /* indexed by 1-zlib_error */ | |||
| 65 | #define MAX_MATCH 258 | 69 | #define MAX_MATCH 258 |
| 66 | /* The minimum and maximum match lengths */ | 70 | /* The minimum and maximum match lengths */ |
| 67 | 71 | ||
| 72 | #define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */ | ||
| 73 | |||
| 68 | /* target dependencies */ | 74 | /* target dependencies */ |
| 69 | 75 | ||
| 70 | #ifdef MSDOS | 76 | #ifdef MSDOS |
| @@ -110,6 +116,10 @@ extern char *z_errmsg[]; /* indexed by 1-zlib_error */ | |||
| 110 | # define OS_CODE 0x0a | 116 | # define OS_CODE 0x0a |
| 111 | #endif | 117 | #endif |
| 112 | 118 | ||
| 119 | #ifdef _BEOS_ | ||
| 120 | # define fdopen(fd,mode) NULL /* No fdopen() */ | ||
| 121 | #endif | ||
| 122 | |||
| 113 | /* Common defaults */ | 123 | /* Common defaults */ |
| 114 | 124 | ||
| 115 | #ifndef OS_CODE | 125 | #ifndef OS_CODE |
| @@ -142,11 +152,13 @@ extern char *z_errmsg[]; /* indexed by 1-zlib_error */ | |||
| 142 | # define HAVE_MEMCPY | 152 | # define HAVE_MEMCPY |
| 143 | #endif | 153 | #endif |
| 144 | #ifdef HAVE_MEMCPY | 154 | #ifdef HAVE_MEMCPY |
| 145 | # if defined(M_I86SM) || defined(M_I86MM) /* MSC small or medium model */ | 155 | # ifdef SMALL_MEDIUM /* MSDOS small or medium model */ |
| 146 | # define zmemcpy _fmemcpy | 156 | # define zmemcpy _fmemcpy |
| 157 | # define zmemcmp _fmemcmp | ||
| 147 | # define zmemzero(dest, len) _fmemset(dest, 0, len) | 158 | # define zmemzero(dest, len) _fmemset(dest, 0, len) |
| 148 | # else | 159 | # else |
| 149 | # define zmemcpy memcpy | 160 | # define zmemcpy memcpy |
| 161 | # define zmemcmp memcmp | ||
| 150 | # define zmemzero(dest, len) memset(dest, 0, len) | 162 | # define zmemzero(dest, len) memset(dest, 0, len) |
| 151 | # endif | 163 | # endif |
| 152 | #else | 164 | #else |
| @@ -176,7 +188,7 @@ extern char *z_errmsg[]; /* indexed by 1-zlib_error */ | |||
| 176 | #endif | 188 | #endif |
| 177 | 189 | ||
| 178 | 190 | ||
| 179 | typedef uLong (*check_func) OF((uLong check, Bytef *buf, uInt len)); | 191 | typedef uLong (*check_func) OF((uLong check, const Bytef *buf, uInt len)); |
| 180 | 192 | ||
| 181 | extern void z_error OF((char *m)); | 193 | extern void z_error OF((char *m)); |
| 182 | 194 | ||
