mirror of
https://github.com/RetroDECK/Supermodel.git
synced 2025-03-06 14:27:44 +00:00
Original Supermodel code moved to tags/Original.
This commit is contained in:
Bart Trzynadlowski
parent
7260a4d953
commit
a390d45c77
722
zlib/ChangeLog
722
zlib/ChangeLog
|
|
@ -1,722 +0,0 @@
|
|||
|
||||
ChangeLog file for zlib
|
||||
|
||||
Changes in 1.2.1 (17 November 2003)
|
||||
- Remove a tab in contrib/gzappend/gzappend.c
|
||||
- Update some interfaces in contrib for new zlib functions
|
||||
- Update zlib version number in some contrib entries
|
||||
- Add Windows CE definition for ptrdiff_t in zutil.h [Mai, Truta]
|
||||
- Support shared libraries on Hurd and KFreeBSD [Brown]
|
||||
- Fix error in NO_DIVIDE option of adler32.c
|
||||
|
||||
Changes in 1.2.0.8 (4 November 2003)
|
||||
- Update version in contrib/delphi/ZLib.pas and contrib/pascal/zlibpas.pas
|
||||
- Add experimental NO_DIVIDE #define in adler32.c
|
||||
- Possibly faster on some processors (let me know if it is)
|
||||
- Correct Z_BLOCK to not return on first inflate call if no wrap
|
||||
- Fix strm->data_type on inflate() return to correctly indicate EOB
|
||||
- Add deflatePrime() function for appending in the middle of a byte
|
||||
- Add contrib/gzappend for an example of appending to a stream
|
||||
- Update win32/DLL_FAQ.txt [Truta]
|
||||
- Delete Turbo C comment in README [Truta]
|
||||
- Improve some indentation in zconf.h [Truta]
|
||||
- Fix infinite loop on bad input in configure script [Church]
|
||||
- Fix gzeof() for concatenated gzip files [Johnson]
|
||||
- Add example to contrib/visual-basic.txt [Michael B.]
|
||||
- Add -p to mkdir's in Makefile.in [vda]
|
||||
- Fix configure to properly detect presence or lack of printf functions
|
||||
- Add AS400 support [Monnerat]
|
||||
- Add a little Cygwin support [Wilson]
|
||||
|
||||
Changes in 1.2.0.7 (21 September 2003)
|
||||
- Correct some debug formats in contrib/infback9
|
||||
- Cast a type in a debug statement in trees.c
|
||||
- Change search and replace delimiter in configure from % to # [Beebe]
|
||||
- Update contrib/untgz to 0.2 with various fixes [Truta]
|
||||
- Add build support for Amiga [Nikl]
|
||||
- Remove some directories in old that have been updated to 1.2
|
||||
- Add dylib building for Mac OS X in configure and Makefile.in
|
||||
- Remove old distribution stuff from Makefile
|
||||
- Update README to point to DLL_FAQ.txt, and add comment on Mac OS X
|
||||
- Update links in README
|
||||
|
||||
Changes in 1.2.0.6 (13 September 2003)
|
||||
- Minor FAQ updates
|
||||
- Update contrib/minizip to 1.00 [Vollant]
|
||||
- Remove test of gz functions in example.c when GZ_COMPRESS defined [Truta]
|
||||
- Update POSTINC comment for 68060 [Nikl]
|
||||
- Add contrib/infback9 with deflate64 decoding (unsupported)
|
||||
- For MVS define NO_vsnprintf and undefine FAR [van Burik]
|
||||
- Add pragma for fdopen on MVS [van Burik]
|
||||
|
||||
Changes in 1.2.0.5 (8 September 2003)
|
||||
- Add OF to inflateBackEnd() declaration in zlib.h
|
||||
- Remember start when using gzdopen in the middle of a file
|
||||
- Use internal off_t counters in gz* functions to properly handle seeks
|
||||
- Perform more rigorous check for distance-too-far in inffast.c
|
||||
- Add Z_BLOCK flush option to return from inflate at block boundary
|
||||
- Set strm->data_type on return from inflate
|
||||
- Indicate bits unused, if at block boundary, and if in last block
|
||||
- Replace size_t with ptrdiff_t in crc32.c, and check for correct size
|
||||
- Add condition so old NO_DEFLATE define still works for compatibility
|
||||
- FAQ update regarding the Windows DLL [Truta]
|
||||
- INDEX update: add qnx entry, remove aix entry [Truta]
|
||||
- Install zlib.3 into mandir [Wilson]
|
||||
- Move contrib/zlib_dll_FAQ.txt to win32/DLL_FAQ.txt; update [Truta]
|
||||
- Adapt the zlib interface to the new DLL convention guidelines [Truta]
|
||||
- Introduce ZLIB_WINAPI macro to allow the export of functions using
|
||||
the WINAPI calling convention, for Visual Basic [Vollant, Truta]
|
||||
- Update msdos and win32 scripts and makefiles [Truta]
|
||||
- Export symbols by name, not by ordinal, in win32/zlib.def [Truta]
|
||||
- Add contrib/ada [Anisimkov]
|
||||
- Move asm files from contrib/vstudio/vc70_32 to contrib/asm386 [Truta]
|
||||
- Rename contrib/asm386 to contrib/masmx86 [Truta, Vollant]
|
||||
- Add contrib/masm686 [Truta]
|
||||
- Fix offsets in contrib/inflate86 and contrib/masmx86/inffas32.asm
|
||||
[Truta, Vollant]
|
||||
- Update contrib/delphi; rename to contrib/pascal; add example [Truta]
|
||||
- Remove contrib/delphi2; add a new contrib/delphi [Truta]
|
||||
- Avoid inclusion of the nonstandard <memory.h> in contrib/iostream,
|
||||
and fix some method prototypes [Truta]
|
||||
- Fix the ZCR_SEED2 constant to avoid warnings in contrib/minizip
|
||||
[Truta]
|
||||
- Avoid the use of backslash (\) in contrib/minizip [Vollant]
|
||||
- Fix file time handling in contrib/untgz; update makefiles [Truta]
|
||||
- Update contrib/vstudio/vc70_32 to comply with the new DLL guidelines
|
||||
[Vollant]
|
||||
- Remove contrib/vstudio/vc15_16 [Vollant]
|
||||
- Rename contrib/vstudio/vc70_32 to contrib/vstudio/vc7 [Truta]
|
||||
- Update README.contrib [Truta]
|
||||
- Invert the assignment order of match_head and s->prev[...] in
|
||||
INSERT_STRING [Truta]
|
||||
- Compare TOO_FAR with 32767 instead of 32768, to avoid 16-bit warnings
|
||||
[Truta]
|
||||
- Compare function pointers with 0, not with NULL or Z_NULL [Truta]
|
||||
- Fix prototype of syncsearch in inflate.c [Truta]
|
||||
- Introduce ASMINF macro to be enabled when using an ASM implementation
|
||||
of inflate_fast [Truta]
|
||||
- Change NO_DEFLATE to NO_GZCOMPRESS [Truta]
|
||||
- Modify test_gzio in example.c to take a single file name as a
|
||||
parameter [Truta]
|
||||
- Exit the example.c program if gzopen fails [Truta]
|
||||
- Add type casts around strlen in example.c [Truta]
|
||||
- Remove casting to sizeof in minigzip.c; give a proper type
|
||||
to the variable compared with SUFFIX_LEN [Truta]
|
||||
- Update definitions of STDC and STDC99 in zconf.h [Truta]
|
||||
- Synchronize zconf.h with the new Windows DLL interface [Truta]
|
||||
- Use SYS16BIT instead of __32BIT__ to distinguish between
|
||||
16- and 32-bit platforms [Truta]
|
||||
- Use far memory allocators in small 16-bit memory models for
|
||||
Turbo C [Truta]
|
||||
- Add info about the use of ASMV, ASMINF and ZLIB_WINAPI in
|
||||
zlibCompileFlags [Truta]
|
||||
- Cygwin has vsnprintf [Wilson]
|
||||
- In Windows16, OS_CODE is 0, as in MSDOS [Truta]
|
||||
- In Cygwin, OS_CODE is 3 (Unix), not 11 (Windows32) [Wilson]
|
||||
|
||||
Changes in 1.2.0.4 (10 August 2003)
|
||||
- Minor FAQ updates
|
||||
- Be more strict when checking inflateInit2's windowBits parameter
|
||||
- Change NO_GUNZIP compile option to NO_GZIP to cover deflate as well
|
||||
- Add gzip wrapper option to deflateInit2 using windowBits
|
||||
- Add updated QNX rule in configure and qnx directory [Bonnefoy]
|
||||
- Make inflate distance-too-far checks more rigorous
|
||||
- Clean up FAR usage in inflate
|
||||
- Add casting to sizeof() in gzio.c and minigzip.c
|
||||
|
||||
Changes in 1.2.0.3 (19 July 2003)
|
||||
- Fix silly error in gzungetc() implementation [Vollant]
|
||||
- Update contrib/minizip and contrib/vstudio [Vollant]
|
||||
- Fix printf format in example.c
|
||||
- Correct cdecl support in zconf.in.h [Anisimkov]
|
||||
- Minor FAQ updates
|
||||
|
||||
Changes in 1.2.0.2 (13 July 2003)
|
||||
- Add ZLIB_VERNUM in zlib.h for numerical preprocessor comparisons
|
||||
- Attempt to avoid warnings in crc32.c for pointer-int conversion
|
||||
- Add AIX to configure, remove aix directory [Bakker]
|
||||
- Add some casts to minigzip.c
|
||||
- Improve checking after insecure sprintf() or vsprintf() calls
|
||||
- Remove #elif's from crc32.c
|
||||
- Change leave label to inf_leave in inflate.c and infback.c to avoid
|
||||
library conflicts
|
||||
- Remove inflate gzip decoding by default--only enable gzip decoding by
|
||||
special request for stricter backward compatibility
|
||||
- Add zlibCompileFlags() function to return compilation information
|
||||
- More typecasting in deflate.c to avoid warnings
|
||||
- Remove leading underscore from _Capital #defines [Truta]
|
||||
- Fix configure to link shared library when testing
|
||||
- Add some Windows CE target adjustments [Mai]
|
||||
- Remove #define ZLIB_DLL in zconf.h [Vollant]
|
||||
- Add zlib.3 [Rodgers]
|
||||
- Update RFC URL in deflate.c and algorithm.txt [Mai]
|
||||
- Add zlib_dll_FAQ.txt to contrib [Truta]
|
||||
- Add UL to some constants [Truta]
|
||||
- Update minizip and vstudio [Vollant]
|
||||
- Remove vestigial NEED_DUMMY_RETURN from zconf.in.h
|
||||
- Expand use of NO_DUMMY_DECL to avoid all dummy structures
|
||||
- Added iostream3 to contrib [Schwardt]
|
||||
- Replace rewind() with fseek() for WinCE [Truta]
|
||||
- Improve setting of zlib format compression level flags
|
||||
- Report 0 for huffman and rle strategies and for level == 0 or 1
|
||||
- Report 2 only for level == 6
|
||||
- Only deal with 64K limit when necessary at compile time [Truta]
|
||||
- Allow TOO_FAR check to be turned off at compile time [Truta]
|
||||
- Add gzclearerr() function [Souza]
|
||||
- Add gzungetc() function
|
||||
|
||||
Changes in 1.2.0.1 (17 March 2003)
|
||||
- Add Z_RLE strategy for run-length encoding [Truta]
|
||||
- When Z_RLE requested, restrict matches to distance one
|
||||
- Update zlib.h, minigzip.c, gzopen(), gzdopen() for Z_RLE
|
||||
- Correct FASTEST compilation to allow level == 0
|
||||
- Clean up what gets compiled for FASTEST
|
||||
- Incorporate changes to zconf.in.h [Vollant]
|
||||
- Refine detection of Turbo C need for dummy returns
|
||||
- Refine ZLIB_DLL compilation
|
||||
- Include additional header file on VMS for off_t typedef
|
||||
- Try to use _vsnprintf where it supplants vsprintf [Vollant]
|
||||
- Add some casts in inffast.c
|
||||
- Enchance comments in zlib.h on what happens if gzprintf() tries to
|
||||
write more than 4095 bytes before compression
|
||||
- Remove unused state from inflateBackEnd()
|
||||
- Remove exit(0) from minigzip.c, example.c
|
||||
- Get rid of all those darn tabs
|
||||
- Add "check" target to Makefile.in that does the same thing as "test"
|
||||
- Add "mostlyclean" and "maintainer-clean" targets to Makefile.in
|
||||
- Update contrib/inflate86 [Anderson]
|
||||
- Update contrib/testzlib, contrib/vstudio, contrib/minizip [Vollant]
|
||||
- Add msdos and win32 directories with makefiles [Truta]
|
||||
- More additions and improvements to the FAQ
|
||||
|
||||
Changes in 1.2.0 (9 March 2003)
|
||||
- New and improved inflate code
|
||||
- About 20% faster
|
||||
- Does not allocate 32K window unless and until needed
|
||||
- Automatically detects and decompresses gzip streams
|
||||
- Raw inflate no longer needs an extra dummy byte at end
|
||||
- Added inflateBack functions using a callback interface--even faster
|
||||
than inflate, useful for file utilities (gzip, zip)
|
||||
- Added inflateCopy() function to record state for random access on
|
||||
externally generated deflate streams (e.g. in gzip files)
|
||||
- More readable code (I hope)
|
||||
- New and improved crc32()
|
||||
- About 50% faster, thanks to suggestions from Rodney Brown
|
||||
- Add deflateBound() and compressBound() functions
|
||||
- Fix memory leak in deflateInit2()
|
||||
- Permit setting dictionary for raw deflate (for parallel deflate)
|
||||
- Fix const declaration for gzwrite()
|
||||
- Check for some malloc() failures in gzio.c
|
||||
- Fix bug in gzopen() on single-byte file 0x1f
|
||||
- Fix bug in gzread() on concatenated file with 0x1f at end of buffer
|
||||
and next buffer doesn't start with 0x8b
|
||||
- Fix uncompress() to return Z_DATA_ERROR on truncated input
|
||||
- Free memory at end of example.c
|
||||
- Remove MAX #define in trees.c (conflicted with some libraries)
|
||||
- Fix static const's in deflate.c, gzio.c, and zutil.[ch]
|
||||
- Declare malloc() and free() in gzio.c if STDC not defined
|
||||
- Use malloc() instead of calloc() in zutil.c if int big enough
|
||||
- Define STDC for AIX
|
||||
- Add aix/ with approach for compiling shared library on AIX
|
||||
- Add HP-UX support for shared libraries in configure
|
||||
- Add OpenUNIX support for shared libraries in configure
|
||||
- Use $cc instead of gcc to build shared library
|
||||
- Make prefix directory if needed when installing
|
||||
- Correct Macintosh avoidance of typedef Byte in zconf.h
|
||||
- Correct Turbo C memory allocation when under Linux
|
||||
- Use libz.a instead of -lz in Makefile (assure use of compiled library)
|
||||
- Update configure to check for snprintf or vsnprintf functions and their
|
||||
return value, warn during make if using an insecure function
|
||||
- Fix configure problem with compile-time knowledge of HAVE_UNISTD_H that
|
||||
is lost when library is used--resolution is to build new zconf.h
|
||||
- Documentation improvements (in zlib.h):
|
||||
- Document raw deflate and inflate
|
||||
- Update RFCs URL
|
||||
- Point out that zlib and gzip formats are different
|
||||
- Note that Z_BUF_ERROR is not fatal
|
||||
- Document string limit for gzprintf() and possible buffer overflow
|
||||
- Note requirement on avail_out when flushing
|
||||
- Note permitted values of flush parameter of inflate()
|
||||
- Add some FAQs (and even answers) to the FAQ
|
||||
- Add contrib/inflate86/ for x86 faster inflate
|
||||
- Add contrib/blast/ for PKWare Data Compression Library decompression
|
||||
- Add contrib/puff/ simple inflate for deflate format description
|
||||
|
||||
Changes in 1.1.4 (11 March 2002)
|
||||
- ZFREE was repeated on same allocation on some error conditions.
|
||||
This creates a security problem described in
|
||||
http://www.zlib.org/advisory-2002-03-11.txt
|
||||
- Returned incorrect error (Z_MEM_ERROR) on some invalid data
|
||||
- Avoid accesses before window for invalid distances with inflate window
|
||||
less than 32K.
|
||||
- force windowBits > 8 to avoid a bug in the encoder for a window size
|
||||
of 256 bytes. (A complete fix will be available in 1.1.5).
|
||||
|
||||
Changes in 1.1.3 (9 July 1998)
|
||||
- fix "an inflate input buffer bug that shows up on rare but persistent
|
||||
occasions" (Mark)
|
||||
- fix gzread and gztell for concatenated .gz files (Didier Le Botlan)
|
||||
- fix gzseek(..., SEEK_SET) in write mode
|
||||
- fix crc check after a gzeek (Frank Faubert)
|
||||
- fix miniunzip when the last entry in a zip file is itself a zip file
|
||||
(J Lillge)
|
||||
- add contrib/asm586 and contrib/asm686 (Brian Raiter)
|
||||
See http://www.muppetlabs.com/~breadbox/software/assembly.html
|
||||
- add support for Delphi 3 in contrib/delphi (Bob Dellaca)
|
||||
- add support for C++Builder 3 and Delphi 3 in contrib/delphi2 (Davide Moretti)
|
||||
- do not exit prematurely in untgz if 0 at start of block (Magnus Holmgren)
|
||||
- use macro EXTERN instead of extern to support DLL for BeOS (Sander Stoks)
|
||||
- added a FAQ file
|
||||
|
||||
- Support gzdopen on Mac with Metrowerks (Jason Linhart)
|
||||
- Do not redefine Byte on Mac (Brad Pettit & Jason Linhart)
|
||||
- define SEEK_END too if SEEK_SET is not defined (Albert Chin-A-Young)
|
||||
- avoid some warnings with Borland C (Tom Tanner)
|
||||
- fix a problem in contrib/minizip/zip.c for 16-bit MSDOS (Gilles Vollant)
|
||||
- emulate utime() for WIN32 in contrib/untgz (Gilles Vollant)
|
||||
- allow several arguments to configure (Tim Mooney, Frodo Looijaard)
|
||||
- use libdir and includedir in Makefile.in (Tim Mooney)
|
||||
- support shared libraries on OSF1 V4 (Tim Mooney)
|
||||
- remove so_locations in "make clean" (Tim Mooney)
|
||||
- fix maketree.c compilation error (Glenn, Mark)
|
||||
- Python interface to zlib now in Python 1.5 (Jeremy Hylton)
|
||||
- new Makefile.riscos (Rich Walker)
|
||||
- initialize static descriptors in trees.c for embedded targets (Nick Smith)
|
||||
- use "foo-gz" in example.c for RISCOS and VMS (Nick Smith)
|
||||
- add the OS/2 files in Makefile.in too (Andrew Zabolotny)
|
||||
- fix fdopen and halloc macros for Microsoft C 6.0 (Tom Lane)
|
||||
- fix maketree.c to allow clean compilation of inffixed.h (Mark)
|
||||
- fix parameter check in deflateCopy (Gunther Nikl)
|
||||
- cleanup trees.c, use compressed_len only in debug mode (Christian Spieler)
|
||||
- Many portability patches by Christian Spieler:
|
||||
. zutil.c, zutil.h: added "const" for zmem*
|
||||
. Make_vms.com: fixed some typos
|
||||
. Make_vms.com: msdos/Makefile.*: removed zutil.h from some dependency lists
|
||||
. msdos/Makefile.msc: remove "default rtl link library" info from obj files
|
||||
. msdos/Makefile.*: use model-dependent name for the built zlib library
|
||||
. msdos/Makefile.emx, nt/Makefile.emx, nt/Makefile.gcc:
|
||||
new makefiles, for emx (DOS/OS2), emx&rsxnt and mingw32 (Windows 9x / NT)
|
||||
- use define instead of typedef for Bytef also for MSC small/medium (Tom Lane)
|
||||
- replace __far with _far for better portability (Christian Spieler, Tom Lane)
|
||||
- fix test for errno.h in configure (Tim Newsham)
|
||||
|
||||
Changes in 1.1.2 (19 March 98)
|
||||
- added contrib/minzip, mini zip and unzip based on zlib (Gilles Vollant)
|
||||
See http://www.winimage.com/zLibDll/unzip.html
|
||||
- preinitialize the inflate tables for fixed codes, to make the code
|
||||
completely thread safe (Mark)
|
||||
- some simplifications and slight speed-up to the inflate code (Mark)
|
||||
- fix gzeof on non-compressed files (Allan Schrum)
|
||||
- add -std1 option in configure for OSF1 to fix gzprintf (Martin Mokrejs)
|
||||
- use default value of 4K for Z_BUFSIZE for 16-bit MSDOS (Tim Wegner + Glenn)
|
||||
- added os2/Makefile.def and os2/zlib.def (Andrew Zabolotny)
|
||||
- add shared lib support for UNIX_SV4.2MP (MATSUURA Takanori)
|
||||
- do not wrap extern "C" around system includes (Tom Lane)
|
||||
- mention zlib binding for TCL in README (Andreas Kupries)
|
||||
- added amiga/Makefile.pup for Amiga powerUP SAS/C PPC (Andreas Kleinert)
|
||||
- allow "make install prefix=..." even after configure (Glenn Randers-Pehrson)
|
||||
- allow "configure --prefix $HOME" (Tim Mooney)
|
||||
- remove warnings in example.c and gzio.c (Glenn Randers-Pehrson)
|
||||
- move Makefile.sas to amiga/Makefile.sas
|
||||
|
||||
Changes in 1.1.1 (27 Feb 98)
|
||||
- fix macros _tr_tally_* in deflate.h for debug mode (Glenn Randers-Pehrson)
|
||||
- remove block truncation heuristic which had very marginal effect for zlib
|
||||
(smaller lit_bufsize than in gzip 1.2.4) and degraded a little the
|
||||
compression ratio on some files. This also allows inlining _tr_tally for
|
||||
matches in deflate_slow.
|
||||
- added msdos/Makefile.w32 for WIN32 Microsoft Visual C++ (Bob Frazier)
|
||||
|
||||
Changes in 1.1.0 (24 Feb 98)
|
||||
- do not return STREAM_END prematurely in inflate (John Bowler)
|
||||
- revert to the zlib 1.0.8 inflate to avoid the gcc 2.8.0 bug (Jeremy Buhler)
|
||||
- compile with -DFASTEST to get compression code optimized for speed only
|
||||
- in minigzip, try mmap'ing the input file first (Miguel Albrecht)
|
||||
- increase size of I/O buffers in minigzip.c and gzio.c (not a big gain
|
||||
on Sun but significant on HP)
|
||||
|
||||
- add a pointer to experimental unzip library in README (Gilles Vollant)
|
||||
- initialize variable gcc in configure (Chris Herborth)
|
||||
|
||||
Changes in 1.0.9 (17 Feb 1998)
|
||||
- added gzputs and gzgets functions
|
||||
- do not clear eof flag in gzseek (Mark Diekhans)
|
||||
- fix gzseek for files in transparent mode (Mark Diekhans)
|
||||
- do not assume that vsprintf returns the number of bytes written (Jens Krinke)
|
||||
- replace EXPORT with ZEXPORT to avoid conflict with other programs
|
||||
- added compress2 in zconf.h, zlib.def, zlib.dnt
|
||||
- new asm code from Gilles Vollant in contrib/asm386
|
||||
- simplify the inflate code (Mark):
|
||||
. Replace ZALLOC's in huft_build() with single ZALLOC in inflate_blocks_new()
|
||||
. ZALLOC the length list in inflate_trees_fixed() instead of using stack
|
||||
. ZALLOC the value area for huft_build() instead of using stack
|
||||
. Simplify Z_FINISH check in inflate()
|
||||
|
||||
- Avoid gcc 2.8.0 comparison bug a little differently than zlib 1.0.8
|
||||
- in inftrees.c, avoid cc -O bug on HP (Farshid Elahi)
|
||||
- in zconf.h move the ZLIB_DLL stuff earlier to avoid problems with
|
||||
the declaration of FAR (Gilles VOllant)
|
||||
- install libz.so* with mode 755 (executable) instead of 644 (Marc Lehmann)
|
||||
- read_buf buf parameter of type Bytef* instead of charf*
|
||||
- zmemcpy parameters are of type Bytef*, not charf* (Joseph Strout)
|
||||
- do not redeclare unlink in minigzip.c for WIN32 (John Bowler)
|
||||
- fix check for presence of directories in "make install" (Ian Willis)
|
||||
|
||||
Changes in 1.0.8 (27 Jan 1998)
|
||||
- fixed offsets in contrib/asm386/gvmat32.asm (Gilles Vollant)
|
||||
- fix gzgetc and gzputc for big endian systems (Markus Oberhumer)
|
||||
- added compress2() to allow setting the compression level
|
||||
- include sys/types.h to get off_t on some systems (Marc Lehmann & QingLong)
|
||||
- use constant arrays for the static trees in trees.c instead of computing
|
||||
them at run time (thanks to Ken Raeburn for this suggestion). To create
|
||||
trees.h, compile with GEN_TREES_H and run "make test".
|
||||
- check return code of example in "make test" and display result
|
||||
- pass minigzip command line options to file_compress
|
||||
- simplifying code of inflateSync to avoid gcc 2.8 bug
|
||||
|
||||
- support CC="gcc -Wall" in configure -s (QingLong)
|
||||
- avoid a flush caused by ftell in gzopen for write mode (Ken Raeburn)
|
||||
- fix test for shared library support to avoid compiler warnings
|
||||
- zlib.lib -> zlib.dll in msdos/zlib.rc (Gilles Vollant)
|
||||
- check for TARGET_OS_MAC in addition to MACOS (Brad Pettit)
|
||||
- do not use fdopen for Metrowerks on Mac (Brad Pettit))
|
||||
- add checks for gzputc and gzputc in example.c
|
||||
- avoid warnings in gzio.c and deflate.c (Andreas Kleinert)
|
||||
- use const for the CRC table (Ken Raeburn)
|
||||
- fixed "make uninstall" for shared libraries
|
||||
- use Tracev instead of Trace in infblock.c
|
||||
- in example.c use correct compressed length for test_sync
|
||||
- suppress +vnocompatwarnings in configure for HPUX (not always supported)
|
||||
|
||||
Changes in 1.0.7 (20 Jan 1998)
|
||||
- fix gzseek which was broken in write mode
|
||||
- return error for gzseek to negative absolute position
|
||||
- fix configure for Linux (Chun-Chung Chen)
|
||||
- increase stack space for MSC (Tim Wegner)
|
||||
- get_crc_table and inflateSyncPoint are EXPORTed (Gilles Vollant)
|
||||
- define EXPORTVA for gzprintf (Gilles Vollant)
|
||||
- added man page zlib.3 (Rick Rodgers)
|
||||
- for contrib/untgz, fix makedir() and improve Makefile
|
||||
|
||||
- check gzseek in write mode in example.c
|
||||
- allocate extra buffer for seeks only if gzseek is actually called
|
||||
- avoid signed/unsigned comparisons (Tim Wegner, Gilles Vollant)
|
||||
- add inflateSyncPoint in zconf.h
|
||||
- fix list of exported functions in nt/zlib.dnt and mdsos/zlib.def
|
||||
|
||||
Changes in 1.0.6 (19 Jan 1998)
|
||||
- add functions gzprintf, gzputc, gzgetc, gztell, gzeof, gzseek, gzrewind and
|
||||
gzsetparams (thanks to Roland Giersig and Kevin Ruland for some of this code)
|
||||
- Fix a deflate bug occuring only with compression level 0 (thanks to
|
||||
Andy Buckler for finding this one).
|
||||
- In minigzip, pass transparently also the first byte for .Z files.
|
||||
- return Z_BUF_ERROR instead of Z_OK if output buffer full in uncompress()
|
||||
- check Z_FINISH in inflate (thanks to Marc Schluper)
|
||||
- Implement deflateCopy (thanks to Adam Costello)
|
||||
- make static libraries by default in configure, add --shared option.
|
||||
- move MSDOS or Windows specific files to directory msdos
|
||||
- suppress the notion of partial flush to simplify the interface
|
||||
(but the symbol Z_PARTIAL_FLUSH is kept for compatibility with 1.0.4)
|
||||
- suppress history buffer provided by application to simplify the interface
|
||||
(this feature was not implemented anyway in 1.0.4)
|
||||
- next_in and avail_in must be initialized before calling inflateInit or
|
||||
inflateInit2
|
||||
- add EXPORT in all exported functions (for Windows DLL)
|
||||
- added Makefile.nt (thanks to Stephen Williams)
|
||||
- added the unsupported "contrib" directory:
|
||||
contrib/asm386/ by Gilles Vollant <info@winimage.com>
|
||||
386 asm code replacing longest_match().
|
||||
contrib/iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
|
||||
A C++ I/O streams interface to the zlib gz* functions
|
||||
contrib/iostream2/ by Tyge Løvset <Tyge.Lovset@cmr.no>
|
||||
Another C++ I/O streams interface
|
||||
contrib/untgz/ by "Pedro A. Aranda Guti\irrez" <paag@tid.es>
|
||||
A very simple tar.gz file extractor using zlib
|
||||
contrib/visual-basic.txt by Carlos Rios <c_rios@sonda.cl>
|
||||
How to use compress(), uncompress() and the gz* functions from VB.
|
||||
- pass params -f (filtered data), -h (huffman only), -1 to -9 (compression
|
||||
level) in minigzip (thanks to Tom Lane)
|
||||
|
||||
- use const for rommable constants in deflate
|
||||
- added test for gzseek and gztell in example.c
|
||||
- add undocumented function inflateSyncPoint() (hack for Paul Mackerras)
|
||||
- add undocumented function zError to convert error code to string
|
||||
(for Tim Smithers)
|
||||
- Allow compilation of gzio with -DNO_DEFLATE to avoid the compression code.
|
||||
- Use default memcpy for Symantec MSDOS compiler.
|
||||
- Add EXPORT keyword for check_func (needed for Windows DLL)
|
||||
- add current directory to LD_LIBRARY_PATH for "make test"
|
||||
- create also a link for libz.so.1
|
||||
- added support for FUJITSU UXP/DS (thanks to Toshiaki Nomura)
|
||||
- use $(SHAREDLIB) instead of libz.so in Makefile.in (for HPUX)
|
||||
- added -soname for Linux in configure (Chun-Chung Chen,
|
||||
- assign numbers to the exported functions in zlib.def (for Windows DLL)
|
||||
- add advice in zlib.h for best usage of deflateSetDictionary
|
||||
- work around compiler bug on Atari (cast Z_NULL in call of s->checkfn)
|
||||
- allow compilation with ANSI keywords only enabled for TurboC in large model
|
||||
- avoid "versionString"[0] (Borland bug)
|
||||
- add NEED_DUMMY_RETURN for Borland
|
||||
- use variable z_verbose for tracing in debug mode (L. Peter Deutsch).
|
||||
- allow compilation with CC
|
||||
- defined STDC for OS/2 (David Charlap)
|
||||
- limit external names to 8 chars for MVS (Thomas Lund)
|
||||
- in minigzip.c, use static buffers only for 16-bit systems
|
||||
- fix suffix check for "minigzip -d foo.gz"
|
||||
- do not return an error for the 2nd of two consecutive gzflush() (Felix Lee)
|
||||
- use _fdopen instead of fdopen for MSC >= 6.0 (Thomas Fanslau)
|
||||
- added makelcc.bat for lcc-win32 (Tom St Denis)
|
||||
- in Makefile.dj2, use copy and del instead of install and rm (Frank Donahoe)
|
||||
- Avoid expanded $Id$. Use "rcs -kb" or "cvs admin -kb" to avoid Id expansion.
|
||||
- check for unistd.h in configure (for off_t)
|
||||
- remove useless check parameter in inflate_blocks_free
|
||||
- avoid useless assignment of s->check to itself in inflate_blocks_new
|
||||
- do not flush twice in gzclose (thanks to Ken Raeburn)
|
||||
- rename FOPEN as F_OPEN to avoid clash with /usr/include/sys/file.h
|
||||
- use NO_ERRNO_H instead of enumeration of operating systems with errno.h
|
||||
- work around buggy fclose on pipes for HP/UX
|
||||
- support zlib DLL with BORLAND C++ 5.0 (thanks to Glenn Randers-Pehrson)
|
||||
- fix configure if CC is already equal to gcc
|
||||
|
||||
Changes in 1.0.5 (3 Jan 98)
|
||||
- Fix inflate to terminate gracefully when fed corrupted or invalid data
|
||||
- Use const for rommable constants in inflate
|
||||
- Eliminate memory leaks on error conditions in inflate
|
||||
- Removed some vestigial code in inflate
|
||||
- Update web address in README
|
||||
|
||||
Changes in 1.0.4 (24 Jul 96)
|
||||
- In very rare conditions, deflate(s, Z_FINISH) could fail to produce an EOF
|
||||
bit, so the decompressor could decompress all the correct data but went
|
||||
on to attempt decompressing extra garbage data. This affected minigzip too.
|
||||
- zlibVersion and gzerror return const char* (needed for DLL)
|
||||
- port to RISCOS (no fdopen, no multiple dots, no unlink, no fileno)
|
||||
- use z_error only for DEBUG (avoid problem with DLLs)
|
||||
|
||||
Changes in 1.0.3 (2 Jul 96)
|
||||
- use z_streamp instead of z_stream *, which is now a far pointer in MSDOS
|
||||
small and medium models; this makes the library incompatible with previous
|
||||
versions for these models. (No effect in large model or on other systems.)
|
||||
- return OK instead of BUF_ERROR if previous deflate call returned with
|
||||
avail_out as zero but there is nothing to do
|
||||
- added memcmp for non STDC compilers
|
||||
- define NO_DUMMY_DECL for more Mac compilers (.h files merged incorrectly)
|
||||
- define __32BIT__ if __386__ or i386 is defined (pb. with Watcom and SCO)
|
||||
- better check for 16-bit mode MSC (avoids problem with Symantec)
|
||||
|
||||
Changes in 1.0.2 (23 May 96)
|
||||
- added Windows DLL support
|
||||
- added a function zlibVersion (for the DLL support)
|
||||
- fixed declarations using Bytef in infutil.c (pb with MSDOS medium model)
|
||||
- Bytef is define's instead of typedef'd only for Borland C
|
||||
- avoid reading uninitialized memory in example.c
|
||||
- mention in README that the zlib format is now RFC1950
|
||||
- updated Makefile.dj2
|
||||
- added algorithm.doc
|
||||
|
||||
Changes in 1.0.1 (20 May 96) [1.0 skipped to avoid confusion]
|
||||
- fix array overlay in deflate.c which sometimes caused bad compressed data
|
||||
- fix inflate bug with empty stored block
|
||||
- fix MSDOS medium model which was broken in 0.99
|
||||
- fix deflateParams() which could generated bad compressed data.
|
||||
- Bytef is define'd instead of typedef'ed (work around Borland bug)
|
||||
- added an INDEX file
|
||||
- new makefiles for DJGPP (Makefile.dj2), 32-bit Borland (Makefile.b32),
|
||||
Watcom (Makefile.wat), Amiga SAS/C (Makefile.sas)
|
||||
- speed up adler32 for modern machines without auto-increment
|
||||
- added -ansi for IRIX in configure
|
||||
- static_init_done in trees.c is an int
|
||||
- define unlink as delete for VMS
|
||||
- fix configure for QNX
|
||||
- add configure branch for SCO and HPUX
|
||||
- avoid many warnings (unused variables, dead assignments, etc...)
|
||||
- no fdopen for BeOS
|
||||
- fix the Watcom fix for 32 bit mode (define FAR as empty)
|
||||
- removed redefinition of Byte for MKWERKS
|
||||
- work around an MWKERKS bug (incorrect merge of all .h files)
|
||||
|
||||
Changes in 0.99 (27 Jan 96)
|
||||
- allow preset dictionary shared between compressor and decompressor
|
||||
- allow compression level 0 (no compression)
|
||||
- add deflateParams in zlib.h: allow dynamic change of compression level
|
||||
and compression strategy.
|
||||
- test large buffers and deflateParams in example.c
|
||||
- add optional "configure" to build zlib as a shared library
|
||||
- suppress Makefile.qnx, use configure instead
|
||||
- fixed deflate for 64-bit systems (detected on Cray)
|
||||
- fixed inflate_blocks for 64-bit systems (detected on Alpha)
|
||||
- declare Z_DEFLATED in zlib.h (possible parameter for deflateInit2)
|
||||
- always return Z_BUF_ERROR when deflate() has nothing to do
|
||||
- deflateInit and inflateInit are now macros to allow version checking
|
||||
- prefix all global functions and types with z_ with -DZ_PREFIX
|
||||
- make falloc completely reentrant (inftrees.c)
|
||||
- fixed very unlikely race condition in ct_static_init
|
||||
- free in reverse order of allocation to help memory manager
|
||||
- use zlib-1.0/* instead of zlib/* inside the tar.gz
|
||||
- make zlib warning-free with "gcc -O3 -Wall -Wwrite-strings -Wpointer-arith
|
||||
-Wconversion -Wstrict-prototypes -Wmissing-prototypes"
|
||||
- allow gzread on concatenated .gz files
|
||||
- deflateEnd now returns Z_DATA_ERROR if it was premature
|
||||
- deflate is finally (?) fully deterministic (no matches beyond end of input)
|
||||
- Document Z_SYNC_FLUSH
|
||||
- add uninstall in Makefile
|
||||
- Check for __cpluplus in zlib.h
|
||||
- Better test in ct_align for partial flush
|
||||
- avoid harmless warnings for Borland C++
|
||||
- initialize hash_head in deflate.c
|
||||
- avoid warning on fdopen (gzio.c) for HP cc -Aa
|
||||
- include stdlib.h for STDC compilers
|
||||
- include errno.h for Cray
|
||||
- ignore error if ranlib doesn't exist
|
||||
- call ranlib twice for NeXTSTEP
|
||||
- use exec_prefix instead of prefix for libz.a
|
||||
- renamed ct_* as _tr_* to avoid conflict with applications
|
||||
- clear z->msg in inflateInit2 before any error return
|
||||
- initialize opaque in example.c, gzio.c, deflate.c and inflate.c
|
||||
- fixed typo in zconf.h (_GNUC__ => __GNUC__)
|
||||
- check for WIN32 in zconf.h and zutil.c (avoid farmalloc in 32-bit mode)
|
||||
- fix typo in Make_vms.com (f$trnlnm -> f$getsyi)
|
||||
- in fcalloc, normalize pointer if size > 65520 bytes
|
||||
- don't use special fcalloc for 32 bit Borland C++
|
||||
- use STDC instead of __GO32__ to avoid redeclaring exit, calloc, etc...
|
||||
- use Z_BINARY instead of BINARY
|
||||
- document that gzclose after gzdopen will close the file
|
||||
- allow "a" as mode in gzopen.
|
||||
- fix error checking in gzread
|
||||
- allow skipping .gz extra-field on pipes
|
||||
- added reference to Perl interface in README
|
||||
- put the crc table in FAR data (I dislike more and more the medium model :)
|
||||
- added get_crc_table
|
||||
- added a dimension to all arrays (Borland C can't count).
|
||||
- workaround Borland C bug in declaration of inflate_codes_new & inflate_fast
|
||||
- guard against multiple inclusion of *.h (for precompiled header on Mac)
|
||||
- Watcom C pretends to be Microsoft C small model even in 32 bit mode.
|
||||
- don't use unsized arrays to avoid silly warnings by Visual C++:
|
||||
warning C4746: 'inflate_mask' : unsized array treated as '__far'
|
||||
(what's wrong with far data in far model?).
|
||||
- define enum out of inflate_blocks_state to allow compilation with C++
|
||||
|
||||
Changes in 0.95 (16 Aug 95)
|
||||
- fix MSDOS small and medium model (now easier to adapt to any compiler)
|
||||
- inlined send_bits
|
||||
- fix the final (:-) bug for deflate with flush (output was correct but
|
||||
not completely flushed in rare occasions).
|
||||
- default window size is same for compression and decompression
|
||||
(it's now sufficient to set MAX_WBITS in zconf.h).
|
||||
- voidp -> voidpf and voidnp -> voidp (for consistency with other
|
||||
typedefs and because voidnp was not near in large model).
|
||||
|
||||
Changes in 0.94 (13 Aug 95)
|
||||
- support MSDOS medium model
|
||||
- fix deflate with flush (could sometimes generate bad output)
|
||||
- fix deflateReset (zlib header was incorrectly suppressed)
|
||||
- added support for VMS
|
||||
- allow a compression level in gzopen()
|
||||
- gzflush now calls fflush
|
||||
- For deflate with flush, flush even if no more input is provided.
|
||||
- rename libgz.a as libz.a
|
||||
- avoid complex expression in infcodes.c triggering Turbo C bug
|
||||
- work around a problem with gcc on Alpha (in INSERT_STRING)
|
||||
- don't use inline functions (problem with some gcc versions)
|
||||
- allow renaming of Byte, uInt, etc... with #define.
|
||||
- avoid warning about (unused) pointer before start of array in deflate.c
|
||||
- avoid various warnings in gzio.c, example.c, infblock.c, adler32.c, zutil.c
|
||||
- avoid reserved word 'new' in trees.c
|
||||
|
||||
Changes in 0.93 (25 June 95)
|
||||
- temporarily disable inline functions
|
||||
- make deflate deterministic
|
||||
- give enough lookahead for PARTIAL_FLUSH
|
||||
- Set binary mode for stdin/stdout in minigzip.c for OS/2
|
||||
- don't even use signed char in inflate (not portable enough)
|
||||
- fix inflate memory leak for segmented architectures
|
||||
|
||||
Changes in 0.92 (3 May 95)
|
||||
- don't assume that char is signed (problem on SGI)
|
||||
- Clear bit buffer when starting a stored block
|
||||
- no memcpy on Pyramid
|
||||
- suppressed inftest.c
|
||||
- optimized fill_window, put longest_match inline for gcc
|
||||
- optimized inflate on stored blocks.
|
||||
- untabify all sources to simplify patches
|
||||
|
||||
Changes in 0.91 (2 May 95)
|
||||
- Default MEM_LEVEL is 8 (not 9 for Unix) as documented in zlib.h
|
||||
- Document the memory requirements in zconf.h
|
||||
- added "make install"
|
||||
- fix sync search logic in inflateSync
|
||||
- deflate(Z_FULL_FLUSH) now works even if output buffer too short
|
||||
- after inflateSync, don't scare people with just "lo world"
|
||||
- added support for DJGPP
|
||||
|
||||
Changes in 0.9 (1 May 95)
|
||||
- don't assume that zalloc clears the allocated memory (the TurboC bug
|
||||
was Mark's bug after all :)
|
||||
- let again gzread copy uncompressed data unchanged (was working in 0.71)
|
||||
- deflate(Z_FULL_FLUSH), inflateReset and inflateSync are now fully implemented
|
||||
- added a test of inflateSync in example.c
|
||||
- moved MAX_WBITS to zconf.h because users might want to change that.
|
||||
- document explicitly that zalloc(64K) on MSDOS must return a normalized
|
||||
pointer (zero offset)
|
||||
- added Makefiles for Microsoft C, Turbo C, Borland C++
|
||||
- faster crc32()
|
||||
|
||||
Changes in 0.8 (29 April 95)
|
||||
- added fast inflate (inffast.c)
|
||||
- deflate(Z_FINISH) now returns Z_STREAM_END when done. Warning: this
|
||||
is incompatible with previous versions of zlib which returned Z_OK.
|
||||
- work around a TurboC compiler bug (bad code for b << 0, see infutil.h)
|
||||
(actually that was not a compiler bug, see 0.81 above)
|
||||
- gzread no longer reads one extra byte in certain cases
|
||||
- In gzio destroy(), don't reference a freed structure
|
||||
- avoid many warnings for MSDOS
|
||||
- avoid the ERROR symbol which is used by MS Windows
|
||||
|
||||
Changes in 0.71 (14 April 95)
|
||||
- Fixed more MSDOS compilation problems :( There is still a bug with
|
||||
TurboC large model.
|
||||
|
||||
Changes in 0.7 (14 April 95)
|
||||
- Added full inflate support.
|
||||
- Simplified the crc32() interface. The pre- and post-conditioning
|
||||
(one's complement) is now done inside crc32(). WARNING: this is
|
||||
incompatible with previous versions; see zlib.h for the new usage.
|
||||
|
||||
Changes in 0.61 (12 April 95)
|
||||
- workaround for a bug in TurboC. example and minigzip now work on MSDOS.
|
||||
|
||||
Changes in 0.6 (11 April 95)
|
||||
- added minigzip.c
|
||||
- added gzdopen to reopen a file descriptor as gzFile
|
||||
- added transparent reading of non-gziped files in gzread.
|
||||
- fixed bug in gzread (don't read crc as data)
|
||||
- fixed bug in destroy (gzio.c) (don't return Z_STREAM_END for gzclose).
|
||||
- don't allocate big arrays in the stack (for MSDOS)
|
||||
- fix some MSDOS compilation problems
|
||||
|
||||
Changes in 0.5:
|
||||
- do real compression in deflate.c. Z_PARTIAL_FLUSH is supported but
|
||||
not yet Z_FULL_FLUSH.
|
||||
- support decompression but only in a single step (forced Z_FINISH)
|
||||
- added opaque object for zalloc and zfree.
|
||||
- added deflateReset and inflateReset
|
||||
- added a variable zlib_version for consistency checking.
|
||||
- renamed the 'filter' parameter of deflateInit2 as 'strategy'.
|
||||
Added Z_FILTERED and Z_HUFFMAN_ONLY constants.
|
||||
|
||||
Changes in 0.4:
|
||||
- avoid "zip" everywhere, use zlib instead of ziplib.
|
||||
- suppress Z_BLOCK_FLUSH, interpret Z_PARTIAL_FLUSH as block flush
|
||||
if compression method == 8.
|
||||
- added adler32 and crc32
|
||||
- renamed deflateOptions as deflateInit2, call one or the other but not both
|
||||
- added the method parameter for deflateInit2.
|
||||
- added inflateInit2
|
||||
- simplied considerably deflateInit and inflateInit by not supporting
|
||||
user-provided history buffer. This is supported only in deflateInit2
|
||||
and inflateInit2.
|
||||
|
||||
Changes in 0.3:
|
||||
- prefix all macro names with Z_
|
||||
- use Z_FINISH instead of deflateEnd to finish compression.
|
||||
- added Z_HUFFMAN_ONLY
|
||||
- added gzerror()
|
||||
315
zlib/FAQ
315
zlib/FAQ
|
|
@ -1,315 +0,0 @@
|
|||
|
||||
Frequently Asked Questions about zlib
|
||||
|
||||
|
||||
If your question is not there, please check the zlib home page
|
||||
http://www.zlib.org which may have more recent information.
|
||||
The lastest zlib FAQ is at http://www.gzip.org/zlib/zlib_faq.html
|
||||
|
||||
|
||||
1. Is zlib Y2K-compliant?
|
||||
|
||||
Yes. zlib doesn't handle dates.
|
||||
|
||||
2. Where can I get a Windows DLL version?
|
||||
|
||||
The zlib sources can be compiled without change to produce a DLL.
|
||||
See the file win32/DLL_FAQ.txt in the zlib distribution.
|
||||
Pointers to the precompiled DLL are found in the zlib web site at
|
||||
http://www.zlib.org.
|
||||
|
||||
3. Where can I get a Visual Basic interface to zlib?
|
||||
|
||||
See
|
||||
* http://www.winimage.com/zLibDll/
|
||||
* http://www.dogma.net/markn/articles/zlibtool/zlibtool.htm
|
||||
* contrib/visual-basic.txt in the zlib distribution
|
||||
|
||||
4. compress() returns Z_BUF_ERROR
|
||||
|
||||
Make sure that before the call of compress, the length of the compressed
|
||||
buffer is equal to the total size of the compressed buffer and not
|
||||
zero. For Visual Basic, check that this parameter is passed by reference
|
||||
("as any"), not by value ("as long").
|
||||
|
||||
5. deflate() or inflate() returns Z_BUF_ERROR
|
||||
|
||||
Before making the call, make sure that avail_in and avail_out are not
|
||||
zero. When setting the parameter flush equal to Z_FINISH, also make sure
|
||||
that avail_out is big enough to allow processing all pending input.
|
||||
Note that a Z_BUF_ERROR is not fatal--another call to deflate() or
|
||||
inflate() can be made with more input or output space. A Z_BUF_ERROR
|
||||
may in fact be unavoidable depending on how the functions are used, since
|
||||
it is not possible to tell whether or not there is more output pending
|
||||
when strm.avail_out returns with zero.
|
||||
|
||||
6. Where's the zlib documentation (man pages, etc.)?
|
||||
|
||||
It's in zlib.h for the moment, and Francis S. Lin has converted it to a
|
||||
web page zlib.html. Volunteers to transform this to Unix-style man pages,
|
||||
please contact Jean-loup Gailly (jloup@gzip.org). Examples of zlib usage
|
||||
are in the files example.c and minigzip.c.
|
||||
|
||||
7. Why don't you use GNU autoconf or libtool or ...?
|
||||
|
||||
Because we would like to keep zlib as a very small and simple
|
||||
package. zlib is rather portable and doesn't need much configuration.
|
||||
|
||||
8. I found a bug in zlib.
|
||||
|
||||
Most of the time, such problems are due to an incorrect usage of
|
||||
zlib. Please try to reproduce the problem with a small program and send
|
||||
the corresponding source to us at zlib@gzip.org . Do not send
|
||||
multi-megabyte data files without prior agreement.
|
||||
|
||||
9. Why do I get "undefined reference to gzputc"?
|
||||
|
||||
If "make test" produces something like
|
||||
|
||||
example.o(.text+0x154): undefined reference to `gzputc'
|
||||
|
||||
check that you don't have old files libz.* in /usr/lib, /usr/local/lib or
|
||||
/usr/X11R6/lib. Remove any old versions, then do "make install".
|
||||
|
||||
10. I need a Delphi interface to zlib.
|
||||
|
||||
See the contrib/delphi directory in the zlib distribution.
|
||||
|
||||
11. Can zlib handle .zip archives?
|
||||
|
||||
See the directory contrib/minizip in the zlib distribution.
|
||||
|
||||
12. Can zlib handle .Z files?
|
||||
|
||||
No, sorry. You have to spawn an uncompress or gunzip subprocess, or adapt
|
||||
the code of uncompress on your own.
|
||||
|
||||
13. How can I make a Unix shared library?
|
||||
|
||||
make clean
|
||||
./configure -s
|
||||
make
|
||||
|
||||
14. How do I install a shared zlib library on Unix?
|
||||
|
||||
make install
|
||||
|
||||
However, many flavors of Unix come with a shared zlib already installed.
|
||||
Before going to the trouble of compiling a shared version of zlib and
|
||||
trying to install it, you may want to check if it's already there! If you
|
||||
can #include <zlib.h>, it's there. The -lz option will probably link to it.
|
||||
|
||||
15. I have a question about OttoPDF
|
||||
|
||||
We are not the authors of OttoPDF. The real author is on the OttoPDF web
|
||||
site Joel Hainley jhainley@myndkryme.com.
|
||||
|
||||
16. Why does gzip give an error on a file I make with compress/deflate?
|
||||
|
||||
The compress and deflate functions produce data in the zlib format, which
|
||||
is different and incompatible with the gzip format. The gz* functions in
|
||||
zlib on the other hand use the gzip format. Both the zlib and gzip
|
||||
formats use the same compressed data format internally, but have different
|
||||
headers and trailers around the compressed data.
|
||||
|
||||
17. Ok, so why are there two different formats?
|
||||
|
||||
The gzip format was designed to retain the directory information about
|
||||
a single file, such as the name and last modification date. The zlib
|
||||
format on the other hand was designed for in-memory and communication
|
||||
channel applications, and has a much more compact header and trailer and
|
||||
uses a faster integrity check than gzip.
|
||||
|
||||
18. Well that's nice, but how do I make a gzip file in memory?
|
||||
|
||||
You can request that deflate write the gzip format instead of the zlib
|
||||
format using deflateInit2(). You can also request that inflate decode
|
||||
the gzip format using inflateInit2(). Read zlib.h for more details.
|
||||
|
||||
Note that you cannot specify special gzip header contents (e.g. a file
|
||||
name or modification date), nor will inflate tell you what was in the
|
||||
gzip header. If you need to customize the header or see what's in it,
|
||||
you can use the raw deflate and inflate operations and the crc32()
|
||||
function and roll your own gzip encoding and decoding. Read the gzip
|
||||
RFC 1952 for details of the header and trailer format.
|
||||
|
||||
19. Is zlib thread-safe?
|
||||
|
||||
Yes. However any library routines that zlib uses and any application-
|
||||
provided memory allocation routines must also be thread-safe. zlib's gz*
|
||||
functions use stdio library routines, and most of zlib's functions use the
|
||||
library memory allocation routines by default. zlib's Init functions allow
|
||||
for the application to provide custom memory allocation routines.
|
||||
|
||||
Of course, you should only operate on any given zlib or gzip stream from a
|
||||
single thread at a time.
|
||||
|
||||
20. Can I use zlib in my commercial application?
|
||||
|
||||
Yes. Please read the license in zlib.h.
|
||||
|
||||
21. Is zlib under the GNU license?
|
||||
|
||||
No. Please read the license in zlib.h.
|
||||
|
||||
22. The license says that altered source versions must be "plainly marked". So
|
||||
what exactly do I need to do to meet that requirement?
|
||||
|
||||
You need to change the ZLIB_VERSION and ZLIB_VERNUM #defines in zlib.h. In
|
||||
particular, the final version number needs to be changed to "f", and an
|
||||
identification string should be appended to ZLIB_VERSION. Version numbers
|
||||
x.x.x.f are reserved for modifications to zlib by others than the zlib
|
||||
maintainers. For example, if the version of the base zlib you are altering
|
||||
is "1.2.3.4", then in zlib.h you should change ZLIB_VERNUM to 0x123f, and
|
||||
ZLIB_VERSION to something like "1.2.3.f-zachary-mods-v3". You can also
|
||||
update the version strings in deflate.c and inftrees.c.
|
||||
|
||||
For altered source distributions, you should also note the origin and
|
||||
nature of the changes in zlib.h, as well as in ChangeLog and README, along
|
||||
with the dates of the alterations. The origin should include at least your
|
||||
name (or your company's name), and an email address to contact for help or
|
||||
issues with the library.
|
||||
|
||||
Note that distributing a compiled zlib library along with zlib.h and
|
||||
zconf.h is also a source distribution, and so you should change
|
||||
ZLIB_VERSION and ZLIB_VERNUM and note the origin and nature of the changes
|
||||
in zlib.h as you would for a full source distribution.
|
||||
|
||||
23. Will zlib work on a big-endian or little-endian architecture, and can I
|
||||
exchange compressed data between them?
|
||||
|
||||
Yes and yes.
|
||||
|
||||
24. Will zlib work on a 64-bit machine?
|
||||
|
||||
It should. It has been tested on 64-bit machines, and has no dependence
|
||||
on any data types being limited to 32-bits in length. If you have any
|
||||
difficulties, please provide a complete problem report to zlib@gzip.org
|
||||
|
||||
25. Will zlib decompress data from the PKWare Data Compression Library?
|
||||
|
||||
No. The PKWare DCL uses a completely different compressed data format
|
||||
than does PKZIP and zlib. However, you can look in zlib's contrib/blast
|
||||
directory for a possible solution to your problem.
|
||||
|
||||
26. Can I access data randomly in a compressed stream?
|
||||
|
||||
No, not without some preparation. If when compressing you periodically
|
||||
use Z_FULL_FLUSH, carefully write all the pending data at those points,
|
||||
and keep an index of those locations, then you can start decompression
|
||||
at those points. You have to be careful to not use Z_FULL_FLUSH too
|
||||
often, since it can significantly degrade compression.
|
||||
|
||||
27. Does zlib work on MVS, OS/390, CICS, etc.?
|
||||
|
||||
We don't know for sure. We have heard occasional reports of success on
|
||||
these systems. If you do use it on one of these, please provide us with
|
||||
a report, instructions, and patches that we can reference when we get
|
||||
these questions. Thanks.
|
||||
|
||||
28. Is there some simpler, easier to read version of inflate I can look at
|
||||
to understand the deflate format?
|
||||
|
||||
First off, you should read RFC 1951. Second, yes. Look in zlib's
|
||||
contrib/puff directory.
|
||||
|
||||
29. Does zlib infringe on any patents?
|
||||
|
||||
As far as we know, no. In fact, that was originally the whole point behind
|
||||
zlib. Look here for some more information:
|
||||
|
||||
http://www.gzip.org/#faq11
|
||||
|
||||
30. Can zlib work with greater than 4 GB of data?
|
||||
|
||||
Yes. inflate() and deflate() will process any amount of data correctly.
|
||||
Each call of inflate() or deflate() is limited to input and output chunks
|
||||
of the maximum value that can be stored in the compiler's "unsigned int"
|
||||
type, but there is no limit to the number of chunks. Note however that the
|
||||
strm.total_in and strm_total_out counters may be limited to 4 GB. These
|
||||
counters are provided as a convenience and are not used internally by
|
||||
inflate() or deflate(). The application can easily set up its own counters
|
||||
updated after each call of inflate() or deflate() to count beyond 4 GB.
|
||||
compress() and uncompress() may be limited to 4 GB, since they operate in a
|
||||
single call. gzseek() and gztell() may be limited to 4 GB depending on how
|
||||
zlib is compiled. See the zlibCompileFlags() function in zlib.h.
|
||||
|
||||
The word "may" appears several times above since there is a 4 GB limit
|
||||
only if the compiler's "long" type is 32 bits. If the compiler's "long"
|
||||
type is 64 bits, then the limit is 16 exabytes.
|
||||
|
||||
31. Does zlib have any security vulnerabilities?
|
||||
|
||||
The only one that we are aware of is potentially in gzprintf(). If zlib
|
||||
is compiled to use sprintf() or vsprintf(), then there is no protection
|
||||
against a buffer overflow of a 4K string space, other than the caller of
|
||||
gzprintf() assuring that the output will not exceed 4K. On the other
|
||||
hand, if zlib is compiled to use snprintf() or vsnprintf(), which should
|
||||
normally be the case, then there is no vulnerability. The ./configure
|
||||
script will display warnings if an insecure variation of sprintf() will
|
||||
be used by gzprintf(). Also the zlibCompileFlags() function will return
|
||||
information on what variant of sprintf() is used by gzprintf().
|
||||
|
||||
If you don't have snprintf() or vsnprintf() and would like one, you can
|
||||
find a portable implementation here:
|
||||
|
||||
http://www.ijs.si/software/snprintf/
|
||||
|
||||
Note that you should be using the most recent version of zlib. Versions
|
||||
1.1.3 and before were subject to a double-free vulnerability.
|
||||
|
||||
32. Is there a Java version of zlib?
|
||||
|
||||
Probably what you want is to use zlib in Java. zlib is already included
|
||||
as part of the Java SDK in the java.util.zip package. If you really want
|
||||
a version of zlib written in the Java language, look on the zlib home
|
||||
page for links: http://www.zlib.org/
|
||||
|
||||
33. I get this or that compiler or source-code scanner warning when I crank it
|
||||
up to maximally-pendantic. Can't you guys write proper code?
|
||||
|
||||
Many years ago, we gave up attempting to avoid warnings on every compiler
|
||||
in the universe. It just got to be a waste of time, and some compilers
|
||||
were downright silly. So now, we simply make sure that the code always
|
||||
works.
|
||||
|
||||
34. Will zlib read the (insert any ancient or arcane format here) compressed
|
||||
data format?
|
||||
|
||||
Probably not. Look in the comp.compression FAQ for pointers to various
|
||||
formats and associated software.
|
||||
|
||||
35. How can I encrypt/decrypt zip files with zlib?
|
||||
|
||||
zlib doesn't support encryption. The original PKZIP encryption is very weak
|
||||
and can be broken with freely available programs. To get strong encryption,
|
||||
use gpg ( http://www.gnupg.org/ ) which already includes zlib compression.
|
||||
For PKZIP compatible "encryption", look at http://www.info-zip.org/
|
||||
|
||||
36. What's the difference between the "gzip" and "deflate" HTTP 1.1 encodings?
|
||||
|
||||
"gzip" is the gzip format, and "deflate" is the zlib format. They should
|
||||
probably have called the second one "zlib" instead to avoid confusion
|
||||
with the raw deflate compressed data format. While the HTTP 1.1 RFC 2616
|
||||
correctly points to the zlib specification in RFC 1950 for the "deflate"
|
||||
transfer encoding, there have been reports of servers and browsers that
|
||||
incorrectly produce or expect raw deflate data per the deflate
|
||||
specficiation in RFC 1951, most notably Microsoft. So even though the
|
||||
"deflate" transfer encoding using the zlib format would be the more
|
||||
efficient approach (and in fact exactly what the zlib format was designed
|
||||
for), using the "gzip" transfer encoding is probably more reliable due to
|
||||
an unfortunate choice of name on the part of the HTTP 1.1 authors.
|
||||
|
||||
Bottom line: use the gzip format for HTTP 1.1 encoding.
|
||||
|
||||
37. Does zlib support the new "Deflate64" format introduced by PKWare?
|
||||
|
||||
No. PKWare has apparently decided to keep that format proprietary, since
|
||||
they have not documented it as they have previous compression formats.
|
||||
In any case, the compression improvements are so modest compared to other
|
||||
more modern approaches, that it's not worth the effort to implement.
|
||||
|
||||
38. Can you please sign these lengthy legal documents and fax them back to us
|
||||
so that we can use your software in our product?
|
||||
|
||||
No. Go away. Shoo.
|
||||
48
zlib/INDEX
48
zlib/INDEX
|
|
@ -1,48 +0,0 @@
|
|||
ChangeLog history of changes
|
||||
FAQ Frequently Asked Questions about zlib
|
||||
INDEX this file
|
||||
Makefile makefile for Unix (generated by configure)
|
||||
Makefile.in makefile for Unix (template for configure)
|
||||
README guess what
|
||||
algorithm.txt description of the (de)compression algorithm
|
||||
configure configure script for Unix
|
||||
zconf.in.h template for zconf.h (used by configure)
|
||||
|
||||
msdos/ makefiles for MSDOS
|
||||
old/ makefiles for various architectures and zlib documentation
|
||||
files that have not yet been updated for zlib 1.2.x
|
||||
qnx/ makefiles for QNX
|
||||
win32/ makefiles for Windows
|
||||
|
||||
zlib public header files (must be kept):
|
||||
zconf.h
|
||||
zlib.h
|
||||
|
||||
private source files used to build the zlib library:
|
||||
adler32.c
|
||||
compress.c
|
||||
crc32.c
|
||||
crc32.h
|
||||
deflate.c
|
||||
deflate.h
|
||||
gzio.c
|
||||
infback.c
|
||||
inffast.c
|
||||
inffast.h
|
||||
inffixed.h
|
||||
inflate.c
|
||||
inflate.h
|
||||
inftrees.c
|
||||
inftrees.h
|
||||
trees.c
|
||||
trees.h
|
||||
uncompr.c
|
||||
zutil.c
|
||||
zutil.h
|
||||
|
||||
source files for sample programs:
|
||||
example.c
|
||||
minigzip.c
|
||||
|
||||
unsupported contribution by third parties
|
||||
See contrib/README.contrib
|
||||
154
zlib/Makefile
154
zlib/Makefile
|
|
@ -1,154 +0,0 @@
|
|||
# Makefile for zlib
|
||||
# Copyright (C) 1995-2003 Jean-loup Gailly.
|
||||
# For conditions of distribution and use, see copyright notice in zlib.h
|
||||
|
||||
# To compile and test, type:
|
||||
# ./configure; make test
|
||||
# The call of configure is optional if you don't have special requirements
|
||||
# If you wish to build zlib as a shared library, use: ./configure -s
|
||||
|
||||
# To use the asm code, type:
|
||||
# cp contrib/asm?86/match.S ./match.S
|
||||
# make LOC=-DASMV OBJA=match.o
|
||||
|
||||
# To install /usr/local/lib/libz.* and /usr/local/include/zlib.h, type:
|
||||
# make install
|
||||
# To install in $HOME instead of /usr/local, use:
|
||||
# make install prefix=$HOME
|
||||
|
||||
CC=cc
|
||||
|
||||
CFLAGS=-O
|
||||
#CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7
|
||||
#CFLAGS=-g -DDEBUG
|
||||
#CFLAGS=-O3 -Wall -Wwrite-strings -Wpointer-arith -Wconversion \
|
||||
# -Wstrict-prototypes -Wmissing-prototypes
|
||||
|
||||
LDFLAGS=libz.a
|
||||
LDSHARED=$(CC)
|
||||
CPP=$(CC) -E
|
||||
|
||||
LIBS=libz.a
|
||||
SHAREDLIB=libz.so
|
||||
SHAREDLIBV=libz.so.1.2.1
|
||||
SHAREDLIBM=libz.so.1
|
||||
|
||||
AR=ar rc
|
||||
RANLIB=ranlib
|
||||
TAR=tar
|
||||
SHELL=/bin/sh
|
||||
EXE=
|
||||
|
||||
prefix = /usr/local
|
||||
exec_prefix = ${prefix}
|
||||
libdir = ${exec_prefix}/lib
|
||||
includedir = ${prefix}/include
|
||||
mandir = ${prefix}/share/man
|
||||
man3dir = ${mandir}/man3
|
||||
|
||||
OBJS = adler32.o compress.o crc32.o gzio.o uncompr.o deflate.o trees.o \
|
||||
zutil.o inflate.o infback.o inftrees.o inffast.o
|
||||
|
||||
OBJA =
|
||||
# to use the asm code: make OBJA=match.o
|
||||
|
||||
TEST_OBJS = example.o minigzip.o
|
||||
|
||||
all: example$(EXE) minigzip$(EXE)
|
||||
|
||||
check: test
|
||||
test: all
|
||||
@LD_LIBRARY_PATH=.:$(LD_LIBRARY_PATH) ; export LD_LIBRARY_PATH; \
|
||||
echo hello world | ./minigzip | ./minigzip -d || \
|
||||
echo ' *** minigzip test FAILED ***' ; \
|
||||
if ./example; then \
|
||||
echo ' *** zlib test OK ***'; \
|
||||
else \
|
||||
echo ' *** zlib test FAILED ***'; \
|
||||
fi
|
||||
|
||||
libz.a: $(OBJS) $(OBJA)
|
||||
$(AR) $@ $(OBJS) $(OBJA)
|
||||
-@ ($(RANLIB) $@ || true) >/dev/null 2>&1
|
||||
|
||||
match.o: match.S
|
||||
$(CPP) match.S > _match.s
|
||||
$(CC) -c _match.s
|
||||
mv _match.o match.o
|
||||
rm -f _match.s
|
||||
|
||||
$(SHAREDLIBV): $(OBJS)
|
||||
$(LDSHARED) -o $@ $(OBJS)
|
||||
rm -f $(SHAREDLIB) $(SHAREDLIBM)
|
||||
ln -s $@ $(SHAREDLIB)
|
||||
ln -s $@ $(SHAREDLIBM)
|
||||
|
||||
example$(EXE): example.o $(LIBS)
|
||||
$(CC) $(CFLAGS) -o $@ example.o $(LDFLAGS)
|
||||
|
||||
minigzip$(EXE): minigzip.o $(LIBS)
|
||||
$(CC) $(CFLAGS) -o $@ minigzip.o $(LDFLAGS)
|
||||
|
||||
install: $(LIBS)
|
||||
-@if [ ! -d $(exec_prefix) ]; then mkdir -p $(exec_prefix); fi
|
||||
-@if [ ! -d $(includedir) ]; then mkdir -p $(includedir); fi
|
||||
-@if [ ! -d $(libdir) ]; then mkdir -p $(libdir); fi
|
||||
-@if [ ! -d $(man3dir) ]; then mkdir -p $(man3dir); fi
|
||||
cp zlib.h zconf.h $(includedir)
|
||||
chmod 644 $(includedir)/zlib.h $(includedir)/zconf.h
|
||||
cp $(LIBS) $(libdir)
|
||||
cd $(libdir); chmod 755 $(LIBS)
|
||||
-@(cd $(libdir); $(RANLIB) libz.a || true) >/dev/null 2>&1
|
||||
cd $(libdir); if test -f $(SHAREDLIBV); then \
|
||||
rm -f $(SHAREDLIB) $(SHAREDLIBM); \
|
||||
ln -s $(SHAREDLIBV) $(SHAREDLIB); \
|
||||
ln -s $(SHAREDLIBV) $(SHAREDLIBM); \
|
||||
(ldconfig || true) >/dev/null 2>&1; \
|
||||
fi
|
||||
cp zlib.3 $(man3dir)
|
||||
chmod 644 $(man3dir)/zlib.3
|
||||
# The ranlib in install is needed on NeXTSTEP which checks file times
|
||||
# ldconfig is for Linux
|
||||
|
||||
uninstall:
|
||||
cd $(includedir); \
|
||||
cd $(libdir); rm -f libz.a; \
|
||||
if test -f $(SHAREDLIBV); then \
|
||||
rm -f $(SHAREDLIBV) $(SHAREDLIB) $(SHAREDLIBM); \
|
||||
fi
|
||||
cd $(man3dir); rm -f zlib.3
|
||||
|
||||
mostlyclean: clean
|
||||
clean:
|
||||
rm -f *.o *~ example$(EXE) minigzip$(EXE) \
|
||||
libz.* foo.gz so_locations \
|
||||
_match.s maketree contrib/infback9/*.o
|
||||
|
||||
maintainer-clean: distclean
|
||||
distclean: clean
|
||||
cp -p Makefile.in Makefile
|
||||
cp -p zconf.in.h zconf.h
|
||||
rm -f .DS_Store
|
||||
|
||||
tags:
|
||||
etags *.[ch]
|
||||
|
||||
depend:
|
||||
makedepend -- $(CFLAGS) -- *.[ch]
|
||||
|
||||
# DO NOT DELETE THIS LINE -- make depend depends on it.
|
||||
|
||||
adler32.o: zlib.h zconf.h
|
||||
compress.o: zlib.h zconf.h
|
||||
crc32.o: crc32.h zlib.h zconf.h
|
||||
deflate.o: deflate.h zutil.h zlib.h zconf.h
|
||||
example.o: zlib.h zconf.h
|
||||
gzio.o: zutil.h zlib.h zconf.h
|
||||
inffast.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
|
||||
inflate.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
|
||||
infback.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
|
||||
inftrees.o: zutil.h zlib.h zconf.h inftrees.h
|
||||
minigzip.o: zlib.h zconf.h
|
||||
trees.o: deflate.h zutil.h zlib.h zconf.h trees.h
|
||||
uncompr.o: zlib.h zconf.h
|
||||
zutil.o: zutil.h zlib.h zconf.h
|
||||
154
zlib/Makefile.in
154
zlib/Makefile.in
|
|
@ -1,154 +0,0 @@
|
|||
# Makefile for zlib
|
||||
# Copyright (C) 1995-2003 Jean-loup Gailly.
|
||||
# For conditions of distribution and use, see copyright notice in zlib.h
|
||||
|
||||
# To compile and test, type:
|
||||
# ./configure; make test
|
||||
# The call of configure is optional if you don't have special requirements
|
||||
# If you wish to build zlib as a shared library, use: ./configure -s
|
||||
|
||||
# To use the asm code, type:
|
||||
# cp contrib/asm?86/match.S ./match.S
|
||||
# make LOC=-DASMV OBJA=match.o
|
||||
|
||||
# To install /usr/local/lib/libz.* and /usr/local/include/zlib.h, type:
|
||||
# make install
|
||||
# To install in $HOME instead of /usr/local, use:
|
||||
# make install prefix=$HOME
|
||||
|
||||
CC=cc
|
||||
|
||||
CFLAGS=-O
|
||||
#CFLAGS=-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7
|
||||
#CFLAGS=-g -DDEBUG
|
||||
#CFLAGS=-O3 -Wall -Wwrite-strings -Wpointer-arith -Wconversion \
|
||||
# -Wstrict-prototypes -Wmissing-prototypes
|
||||
|
||||
LDFLAGS=libz.a
|
||||
LDSHARED=$(CC)
|
||||
CPP=$(CC) -E
|
||||
|
||||
LIBS=libz.a
|
||||
SHAREDLIB=libz.so
|
||||
SHAREDLIBV=libz.so.1.2.1
|
||||
SHAREDLIBM=libz.so.1
|
||||
|
||||
AR=ar rc
|
||||
RANLIB=ranlib
|
||||
TAR=tar
|
||||
SHELL=/bin/sh
|
||||
EXE=
|
||||
|
||||
prefix = /usr/local
|
||||
exec_prefix = ${prefix}
|
||||
libdir = ${exec_prefix}/lib
|
||||
includedir = ${prefix}/include
|
||||
mandir = ${prefix}/share/man
|
||||
man3dir = ${mandir}/man3
|
||||
|
||||
OBJS = adler32.o compress.o crc32.o gzio.o uncompr.o deflate.o trees.o \
|
||||
zutil.o inflate.o infback.o inftrees.o inffast.o
|
||||
|
||||
OBJA =
|
||||
# to use the asm code: make OBJA=match.o
|
||||
|
||||
TEST_OBJS = example.o minigzip.o
|
||||
|
||||
all: example$(EXE) minigzip$(EXE)
|
||||
|
||||
check: test
|
||||
test: all
|
||||
@LD_LIBRARY_PATH=.:$(LD_LIBRARY_PATH) ; export LD_LIBRARY_PATH; \
|
||||
echo hello world | ./minigzip | ./minigzip -d || \
|
||||
echo ' *** minigzip test FAILED ***' ; \
|
||||
if ./example; then \
|
||||
echo ' *** zlib test OK ***'; \
|
||||
else \
|
||||
echo ' *** zlib test FAILED ***'; \
|
||||
fi
|
||||
|
||||
libz.a: $(OBJS) $(OBJA)
|
||||
$(AR) $@ $(OBJS) $(OBJA)
|
||||
-@ ($(RANLIB) $@ || true) >/dev/null 2>&1
|
||||
|
||||
match.o: match.S
|
||||
$(CPP) match.S > _match.s
|
||||
$(CC) -c _match.s
|
||||
mv _match.o match.o
|
||||
rm -f _match.s
|
||||
|
||||
$(SHAREDLIBV): $(OBJS)
|
||||
$(LDSHARED) -o $@ $(OBJS)
|
||||
rm -f $(SHAREDLIB) $(SHAREDLIBM)
|
||||
ln -s $@ $(SHAREDLIB)
|
||||
ln -s $@ $(SHAREDLIBM)
|
||||
|
||||
example$(EXE): example.o $(LIBS)
|
||||
$(CC) $(CFLAGS) -o $@ example.o $(LDFLAGS)
|
||||
|
||||
minigzip$(EXE): minigzip.o $(LIBS)
|
||||
$(CC) $(CFLAGS) -o $@ minigzip.o $(LDFLAGS)
|
||||
|
||||
install: $(LIBS)
|
||||
-@if [ ! -d $(exec_prefix) ]; then mkdir -p $(exec_prefix); fi
|
||||
-@if [ ! -d $(includedir) ]; then mkdir -p $(includedir); fi
|
||||
-@if [ ! -d $(libdir) ]; then mkdir -p $(libdir); fi
|
||||
-@if [ ! -d $(man3dir) ]; then mkdir -p $(man3dir); fi
|
||||
cp zlib.h zconf.h $(includedir)
|
||||
chmod 644 $(includedir)/zlib.h $(includedir)/zconf.h
|
||||
cp $(LIBS) $(libdir)
|
||||
cd $(libdir); chmod 755 $(LIBS)
|
||||
-@(cd $(libdir); $(RANLIB) libz.a || true) >/dev/null 2>&1
|
||||
cd $(libdir); if test -f $(SHAREDLIBV); then \
|
||||
rm -f $(SHAREDLIB) $(SHAREDLIBM); \
|
||||
ln -s $(SHAREDLIBV) $(SHAREDLIB); \
|
||||
ln -s $(SHAREDLIBV) $(SHAREDLIBM); \
|
||||
(ldconfig || true) >/dev/null 2>&1; \
|
||||
fi
|
||||
cp zlib.3 $(man3dir)
|
||||
chmod 644 $(man3dir)/zlib.3
|
||||
# The ranlib in install is needed on NeXTSTEP which checks file times
|
||||
# ldconfig is for Linux
|
||||
|
||||
uninstall:
|
||||
cd $(includedir); \
|
||||
cd $(libdir); rm -f libz.a; \
|
||||
if test -f $(SHAREDLIBV); then \
|
||||
rm -f $(SHAREDLIBV) $(SHAREDLIB) $(SHAREDLIBM); \
|
||||
fi
|
||||
cd $(man3dir); rm -f zlib.3
|
||||
|
||||
mostlyclean: clean
|
||||
clean:
|
||||
rm -f *.o *~ example$(EXE) minigzip$(EXE) \
|
||||
libz.* foo.gz so_locations \
|
||||
_match.s maketree contrib/infback9/*.o
|
||||
|
||||
maintainer-clean: distclean
|
||||
distclean: clean
|
||||
cp -p Makefile.in Makefile
|
||||
cp -p zconf.in.h zconf.h
|
||||
rm -f .DS_Store
|
||||
|
||||
tags:
|
||||
etags *.[ch]
|
||||
|
||||
depend:
|
||||
makedepend -- $(CFLAGS) -- *.[ch]
|
||||
|
||||
# DO NOT DELETE THIS LINE -- make depend depends on it.
|
||||
|
||||
adler32.o: zlib.h zconf.h
|
||||
compress.o: zlib.h zconf.h
|
||||
crc32.o: crc32.h zlib.h zconf.h
|
||||
deflate.o: deflate.h zutil.h zlib.h zconf.h
|
||||
example.o: zlib.h zconf.h
|
||||
gzio.o: zutil.h zlib.h zconf.h
|
||||
inffast.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
|
||||
inflate.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
|
||||
infback.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
|
||||
inftrees.o: zutil.h zlib.h zconf.h inftrees.h
|
||||
minigzip.o: zlib.h zconf.h
|
||||
trees.o: deflate.h zutil.h zlib.h zconf.h trees.h
|
||||
uncompr.o: zlib.h zconf.h
|
||||
zutil.o: zutil.h zlib.h zconf.h
|
||||
126
zlib/README
126
zlib/README
|
|
@ -1,126 +0,0 @@
|
|||
ZLIB DATA COMPRESSION LIBRARY
|
||||
|
||||
zlib 1.2.1 is a general purpose data compression library. All the code is
|
||||
thread safe. The data format used by the zlib library is described by RFCs
|
||||
(Request for Comments) 1950 to 1952 in the files
|
||||
http://www.ietf.org/rfc/rfc1950.txt (zlib format), rfc1951.txt (deflate format)
|
||||
and rfc1952.txt (gzip format). These documents are also available in other
|
||||
formats from ftp://ftp.uu.net/graphics/png/documents/zlib/zdoc-index.html
|
||||
|
||||
All functions of the compression library are documented in the file zlib.h
|
||||
(volunteer to write man pages welcome, contact zlib@gzip.org). A usage example
|
||||
of the library is given in the file example.c which also tests that the library
|
||||
is working correctly. Another example is given in the file minigzip.c. The
|
||||
compression library itself is composed of all source files except example.c and
|
||||
minigzip.c.
|
||||
|
||||
To compile all files and run the test program, follow the instructions given at
|
||||
the top of Makefile. In short "make test; make install" should work for most
|
||||
machines. For Unix: "./configure; make test; make install" For MSDOS, use one
|
||||
of the special makefiles such as Makefile.msc. For VMS, use Make_vms.com or
|
||||
descrip.mms.
|
||||
|
||||
Questions about zlib should be sent to <zlib@gzip.org>, or to Gilles Vollant
|
||||
<info@winimage.com> for the Windows DLL version. The zlib home page is
|
||||
http://www.zlib.org or http://www.gzip.org/zlib/ Before reporting a problem,
|
||||
please check this site to verify that you have the latest version of zlib;
|
||||
otherwise get the latest version and check whether the problem still exists or
|
||||
not.
|
||||
|
||||
PLEASE read the zlib FAQ http://www.gzip.org/zlib/zlib_faq.html before asking
|
||||
for help.
|
||||
|
||||
Mark Nelson <markn@ieee.org> wrote an article about zlib for the Jan. 1997
|
||||
issue of Dr. Dobb's Journal; a copy of the article is available in
|
||||
http://dogma.net/markn/articles/zlibtool/zlibtool.htm
|
||||
|
||||
The changes made in version 1.2.1 are documented in the file ChangeLog.
|
||||
|
||||
Unsupported third party contributions are provided in directory "contrib".
|
||||
|
||||
A Java implementation of zlib is available in the Java Development Kit
|
||||
http://java.sun.com/j2se/1.4.2/docs/api/java/util/zip/package-summary.html
|
||||
See the zlib home page http://www.zlib.org for details.
|
||||
|
||||
A Perl interface to zlib written by Paul Marquess <pmqs@cpan.org> is in the
|
||||
CPAN (Comprehensive Perl Archive Network) sites
|
||||
http://www.cpan.org/modules/by-module/Compress/
|
||||
|
||||
A Python interface to zlib written by A.M. Kuchling <amk@magnet.com> is
|
||||
available in Python 1.5 and later versions, see
|
||||
http://www.python.org/doc/lib/module-zlib.html
|
||||
|
||||
A zlib binding for TCL written by Andreas Kupries <a.kupries@westend.com> is
|
||||
availlable at http://www.oche.de/~akupries/soft/trf/trf_zip.html
|
||||
|
||||
An experimental package to read and write files in .zip format, written on top
|
||||
of zlib by Gilles Vollant <info@winimage.com>, is available in the
|
||||
contrib/minizip directory of zlib.
|
||||
|
||||
|
||||
Notes for some targets:
|
||||
|
||||
- For Windows DLL versions, please see win32/DLL_FAQ.txt
|
||||
|
||||
- For 64-bit Irix, deflate.c must be compiled without any optimization. With
|
||||
-O, one libpng test fails. The test works in 32 bit mode (with the -n32
|
||||
compiler flag). The compiler bug has been reported to SGI.
|
||||
|
||||
- zlib doesn't work with gcc 2.6.3 on a DEC 3000/300LX under OSF/1 2.1 it works
|
||||
when compiled with cc.
|
||||
|
||||
- On Digital Unix 4.0D (formely OSF/1) on AlphaServer, the cc option -std1 is
|
||||
necessary to get gzprintf working correctly. This is done by configure.
|
||||
|
||||
- zlib doesn't work on HP-UX 9.05 with some versions of /bin/cc. It works with
|
||||
other compilers. Use "make test" to check your compiler.
|
||||
|
||||
- gzdopen is not supported on RISCOS, BEOS and by some Mac compilers.
|
||||
|
||||
- For PalmOs, see http://palmzlib.sourceforge.net/
|
||||
|
||||
- When building a shared, i.e. dynamic library on Mac OS X, the library must be
|
||||
installed before testing (do "make install" before "make test"), since the
|
||||
library location is specified in the library.
|
||||
|
||||
|
||||
Acknowledgments:
|
||||
|
||||
The deflate format used by zlib was defined by Phil Katz. The deflate
|
||||
and zlib specifications were written by L. Peter Deutsch. Thanks to all the
|
||||
people who reported problems and suggested various improvements in zlib;
|
||||
they are too numerous to cite here.
|
||||
|
||||
Copyright notice:
|
||||
|
||||
(C) 1995-2003 Jean-loup Gailly and Mark Adler
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
|
||||
Jean-loup Gailly Mark Adler
|
||||
jloup@gzip.org madler@alumni.caltech.edu
|
||||
|
||||
If you use the zlib library in a product, we would appreciate *not*
|
||||
receiving lengthy legal documents to sign. The sources are provided
|
||||
for free but without warranty of any kind. The library has been
|
||||
entirely written by Jean-loup Gailly and Mark Adler; it does not
|
||||
include third-party code.
|
||||
|
||||
If you redistribute modified sources, we would appreciate that you include
|
||||
in the file ChangeLog history information documenting your changes. Please
|
||||
read the FAQ for more information on the distribution of modified source
|
||||
versions.
|
||||
|
|
@ -1,74 +0,0 @@
|
|||
/* adler32.c -- compute the Adler-32 checksum of a data stream
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
/* @(#) $Id$ */
|
||||
|
||||
#define ZLIB_INTERNAL
|
||||
#include "zlib.h"
|
||||
|
||||
#define BASE 65521UL /* largest prime smaller than 65536 */
|
||||
#define NMAX 5552
|
||||
/* NMAX is the largest n such that 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
|
||||
|
||||
#define DO1(buf,i) {s1 += buf[i]; s2 += s1;}
|
||||
#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1);
|
||||
#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2);
|
||||
#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4);
|
||||
#define DO16(buf) DO8(buf,0); DO8(buf,8);
|
||||
|
||||
#ifdef NO_DIVIDE
|
||||
# define MOD(a) \
|
||||
do { \
|
||||
if (a >= (BASE << 16)) a -= (BASE << 16); \
|
||||
if (a >= (BASE << 15)) a -= (BASE << 15); \
|
||||
if (a >= (BASE << 14)) a -= (BASE << 14); \
|
||||
if (a >= (BASE << 13)) a -= (BASE << 13); \
|
||||
if (a >= (BASE << 12)) a -= (BASE << 12); \
|
||||
if (a >= (BASE << 11)) a -= (BASE << 11); \
|
||||
if (a >= (BASE << 10)) a -= (BASE << 10); \
|
||||
if (a >= (BASE << 9)) a -= (BASE << 9); \
|
||||
if (a >= (BASE << 8)) a -= (BASE << 8); \
|
||||
if (a >= (BASE << 7)) a -= (BASE << 7); \
|
||||
if (a >= (BASE << 6)) a -= (BASE << 6); \
|
||||
if (a >= (BASE << 5)) a -= (BASE << 5); \
|
||||
if (a >= (BASE << 4)) a -= (BASE << 4); \
|
||||
if (a >= (BASE << 3)) a -= (BASE << 3); \
|
||||
if (a >= (BASE << 2)) a -= (BASE << 2); \
|
||||
if (a >= (BASE << 1)) a -= (BASE << 1); \
|
||||
if (a >= BASE) a -= BASE; \
|
||||
} while (0)
|
||||
#else
|
||||
# define MOD(a) a %= BASE
|
||||
#endif
|
||||
|
||||
/* ========================================================================= */
|
||||
uLong ZEXPORT adler32(adler, buf, len)
|
||||
uLong adler;
|
||||
const Bytef *buf;
|
||||
uInt len;
|
||||
{
|
||||
unsigned long s1 = adler & 0xffff;
|
||||
unsigned long s2 = (adler >> 16) & 0xffff;
|
||||
int k;
|
||||
|
||||
if (buf == Z_NULL) return 1L;
|
||||
|
||||
while (len > 0) {
|
||||
k = len < NMAX ? (int)len : NMAX;
|
||||
len -= k;
|
||||
while (k >= 16) {
|
||||
DO16(buf);
|
||||
buf += 16;
|
||||
k -= 16;
|
||||
}
|
||||
if (k != 0) do {
|
||||
s1 += *buf++;
|
||||
s2 += s1;
|
||||
} while (--k);
|
||||
MOD(s1);
|
||||
MOD(s2);
|
||||
}
|
||||
return (s2 << 16) | s1;
|
||||
}
|
||||
|
|
@ -1,209 +0,0 @@
|
|||
1. Compression algorithm (deflate)
|
||||
|
||||
The deflation algorithm used by gzip (also zip and zlib) is a variation of
|
||||
LZ77 (Lempel-Ziv 1977, see reference below). It finds duplicated strings in
|
||||
the input data. The second occurrence of a string is replaced by a
|
||||
pointer to the previous string, in the form of a pair (distance,
|
||||
length). Distances are limited to 32K bytes, and lengths are limited
|
||||
to 258 bytes. When a string does not occur anywhere in the previous
|
||||
32K bytes, it is emitted as a sequence of literal bytes. (In this
|
||||
description, `string' must be taken as an arbitrary sequence of bytes,
|
||||
and is not restricted to printable characters.)
|
||||
|
||||
Literals or match lengths are compressed with one Huffman tree, and
|
||||
match distances are compressed with another tree. The trees are stored
|
||||
in a compact form at the start of each block. The blocks can have any
|
||||
size (except that the compressed data for one block must fit in
|
||||
available memory). A block is terminated when deflate() determines that
|
||||
it would be useful to start another block with fresh trees. (This is
|
||||
somewhat similar to the behavior of LZW-based _compress_.)
|
||||
|
||||
Duplicated strings are found using a hash table. All input strings of
|
||||
length 3 are inserted in the hash table. A hash index is computed for
|
||||
the next 3 bytes. If the hash chain for this index is not empty, all
|
||||
strings in the chain are compared with the current input string, and
|
||||
the longest match is selected.
|
||||
|
||||
The hash chains are searched starting with the most recent strings, to
|
||||
favor small distances and thus take advantage of the Huffman encoding.
|
||||
The hash chains are singly linked. There are no deletions from the
|
||||
hash chains, the algorithm simply discards matches that are too old.
|
||||
|
||||
To avoid a worst-case situation, very long hash chains are arbitrarily
|
||||
truncated at a certain length, determined by a runtime option (level
|
||||
parameter of deflateInit). So deflate() does not always find the longest
|
||||
possible match but generally finds a match which is long enough.
|
||||
|
||||
deflate() also defers the selection of matches with a lazy evaluation
|
||||
mechanism. After a match of length N has been found, deflate() searches for
|
||||
a longer match at the next input byte. If a longer match is found, the
|
||||
previous match is truncated to a length of one (thus producing a single
|
||||
literal byte) and the process of lazy evaluation begins again. Otherwise,
|
||||
the original match is kept, and the next match search is attempted only N
|
||||
steps later.
|
||||
|
||||
The lazy match evaluation is also subject to a runtime parameter. If
|
||||
the current match is long enough, deflate() reduces the search for a longer
|
||||
match, thus speeding up the whole process. If compression ratio is more
|
||||
important than speed, deflate() attempts a complete second search even if
|
||||
the first match is already long enough.
|
||||
|
||||
The lazy match evaluation is not performed for the fastest compression
|
||||
modes (level parameter 1 to 3). For these fast modes, new strings
|
||||
are inserted in the hash table only when no match was found, or
|
||||
when the match is not too long. This degrades the compression ratio
|
||||
but saves time since there are both fewer insertions and fewer searches.
|
||||
|
||||
|
||||
2. Decompression algorithm (inflate)
|
||||
|
||||
2.1 Introduction
|
||||
|
||||
The key question is how to represent a Huffman code (or any prefix code) so
|
||||
that you can decode fast. The most important characteristic is that shorter
|
||||
codes are much more common than longer codes, so pay attention to decoding the
|
||||
short codes fast, and let the long codes take longer to decode.
|
||||
|
||||
inflate() sets up a first level table that covers some number of bits of
|
||||
input less than the length of longest code. It gets that many bits from the
|
||||
stream, and looks it up in the table. The table will tell if the next
|
||||
code is that many bits or less and how many, and if it is, it will tell
|
||||
the value, else it will point to the next level table for which inflate()
|
||||
grabs more bits and tries to decode a longer code.
|
||||
|
||||
How many bits to make the first lookup is a tradeoff between the time it
|
||||
takes to decode and the time it takes to build the table. If building the
|
||||
table took no time (and if you had infinite memory), then there would only
|
||||
be a first level table to cover all the way to the longest code. However,
|
||||
building the table ends up taking a lot longer for more bits since short
|
||||
codes are replicated many times in such a table. What inflate() does is
|
||||
simply to make the number of bits in the first table a variable, and then
|
||||
to set that variable for the maximum speed.
|
||||
|
||||
For inflate, which has 286 possible codes for the literal/length tree, the size
|
||||
of the first table is nine bits. Also the distance trees have 30 possible
|
||||
values, and the size of the first table is six bits. Note that for each of
|
||||
those cases, the table ended up one bit longer than the ``average'' code
|
||||
length, i.e. the code length of an approximately flat code which would be a
|
||||
little more than eight bits for 286 symbols and a little less than five bits
|
||||
for 30 symbols.
|
||||
|
||||
|
||||
2.2 More details on the inflate table lookup
|
||||
|
||||
Ok, you want to know what this cleverly obfuscated inflate tree actually
|
||||
looks like. You are correct that it's not a Huffman tree. It is simply a
|
||||
lookup table for the first, let's say, nine bits of a Huffman symbol. The
|
||||
symbol could be as short as one bit or as long as 15 bits. If a particular
|
||||
symbol is shorter than nine bits, then that symbol's translation is duplicated
|
||||
in all those entries that start with that symbol's bits. For example, if the
|
||||
symbol is four bits, then it's duplicated 32 times in a nine-bit table. If a
|
||||
symbol is nine bits long, it appears in the table once.
|
||||
|
||||
If the symbol is longer than nine bits, then that entry in the table points
|
||||
to another similar table for the remaining bits. Again, there are duplicated
|
||||
entries as needed. The idea is that most of the time the symbol will be short
|
||||
and there will only be one table look up. (That's whole idea behind data
|
||||
compression in the first place.) For the less frequent long symbols, there
|
||||
will be two lookups. If you had a compression method with really long
|
||||
symbols, you could have as many levels of lookups as is efficient. For
|
||||
inflate, two is enough.
|
||||
|
||||
So a table entry either points to another table (in which case nine bits in
|
||||
the above example are gobbled), or it contains the translation for the symbol
|
||||
and the number of bits to gobble. Then you start again with the next
|
||||
ungobbled bit.
|
||||
|
||||
You may wonder: why not just have one lookup table for how ever many bits the
|
||||
longest symbol is? The reason is that if you do that, you end up spending
|
||||
more time filling in duplicate symbol entries than you do actually decoding.
|
||||
At least for deflate's output that generates new trees every several 10's of
|
||||
kbytes. You can imagine that filling in a 2^15 entry table for a 15-bit code
|
||||
would take too long if you're only decoding several thousand symbols. At the
|
||||
other extreme, you could make a new table for every bit in the code. In fact,
|
||||
that's essentially a Huffman tree. But then you spend two much time
|
||||
traversing the tree while decoding, even for short symbols.
|
||||
|
||||
So the number of bits for the first lookup table is a trade of the time to
|
||||
fill out the table vs. the time spent looking at the second level and above of
|
||||
the table.
|
||||
|
||||
Here is an example, scaled down:
|
||||
|
||||
The code being decoded, with 10 symbols, from 1 to 6 bits long:
|
||||
|
||||
A: 0
|
||||
B: 10
|
||||
C: 1100
|
||||
D: 11010
|
||||
E: 11011
|
||||
F: 11100
|
||||
G: 11101
|
||||
H: 11110
|
||||
I: 111110
|
||||
J: 111111
|
||||
|
||||
Let's make the first table three bits long (eight entries):
|
||||
|
||||
000: A,1
|
||||
001: A,1
|
||||
010: A,1
|
||||
011: A,1
|
||||
100: B,2
|
||||
101: B,2
|
||||
110: -> table X (gobble 3 bits)
|
||||
111: -> table Y (gobble 3 bits)
|
||||
|
||||
Each entry is what the bits decode as and how many bits that is, i.e. how
|
||||
many bits to gobble. Or the entry points to another table, with the number of
|
||||
bits to gobble implicit in the size of the table.
|
||||
|
||||
Table X is two bits long since the longest code starting with 110 is five bits
|
||||
long:
|
||||
|
||||
00: C,1
|
||||
01: C,1
|
||||
10: D,2
|
||||
11: E,2
|
||||
|
||||
Table Y is three bits long since the longest code starting with 111 is six
|
||||
bits long:
|
||||
|
||||
000: F,2
|
||||
001: F,2
|
||||
010: G,2
|
||||
011: G,2
|
||||
100: H,2
|
||||
101: H,2
|
||||
110: I,3
|
||||
111: J,3
|
||||
|
||||
So what we have here are three tables with a total of 20 entries that had to
|
||||
be constructed. That's compared to 64 entries for a single table. Or
|
||||
compared to 16 entries for a Huffman tree (six two entry tables and one four
|
||||
entry table). Assuming that the code ideally represents the probability of
|
||||
the symbols, it takes on the average 1.25 lookups per symbol. That's compared
|
||||
to one lookup for the single table, or 1.66 lookups per symbol for the
|
||||
Huffman tree.
|
||||
|
||||
There, I think that gives you a picture of what's going on. For inflate, the
|
||||
meaning of a particular symbol is often more than just a letter. It can be a
|
||||
byte (a "literal"), or it can be either a length or a distance which
|
||||
indicates a base value and a number of bits to fetch after the code that is
|
||||
added to the base value. Or it might be the special end-of-block code. The
|
||||
data structures created in inftrees.c try to encode all that information
|
||||
compactly in the tables.
|
||||
|
||||
|
||||
Jean-loup Gailly Mark Adler
|
||||
jloup@gzip.org madler@alumni.caltech.edu
|
||||
|
||||
|
||||
References:
|
||||
|
||||
[LZ77] Ziv J., Lempel A., ``A Universal Algorithm for Sequential Data
|
||||
Compression,'' IEEE Transactions on Information Theory, Vol. 23, No. 3,
|
||||
pp. 337-343.
|
||||
|
||||
``DEFLATE Compressed Data Format Specification'' available in
|
||||
http://www.ietf.org/rfc/rfc1951.txt
|
||||
|
|
@ -1,66 +0,0 @@
|
|||
# Amiga powerUP (TM) Makefile
|
||||
# makefile for libpng and SAS C V6.58/7.00 PPC compiler
|
||||
# Copyright (C) 1998 by Andreas R. Kleinert
|
||||
|
||||
LIBNAME = libzip.a
|
||||
|
||||
CC = scppc
|
||||
CFLAGS = NOSTKCHK NOSINT OPTIMIZE OPTGO OPTPEEP OPTINLOCAL OPTINL \
|
||||
OPTLOOP OPTRDEP=8 OPTDEP=8 OPTCOMP=8 NOVER
|
||||
AR = ppc-amigaos-ar cr
|
||||
RANLIB = ppc-amigaos-ranlib
|
||||
LD = ppc-amigaos-ld -r
|
||||
LDFLAGS = -o
|
||||
LDLIBS = LIB:scppc.a LIB:end.o
|
||||
RM = delete quiet
|
||||
|
||||
OBJS = adler32.o compress.o crc32.o gzio.o uncompr.o deflate.o trees.o \
|
||||
zutil.o inflate.o infback.o inftrees.o inffast.o
|
||||
|
||||
TEST_OBJS = example.o minigzip.o
|
||||
|
||||
all: example minigzip
|
||||
|
||||
check: test
|
||||
test: all
|
||||
example
|
||||
echo hello world | minigzip | minigzip -d
|
||||
|
||||
$(LIBNAME): $(OBJS)
|
||||
$(AR) $@ $(OBJS)
|
||||
-$(RANLIB) $@
|
||||
|
||||
example: example.o $(LIBNAME)
|
||||
$(LD) $(LDFLAGS) $@ LIB:c_ppc.o $@.o $(LIBNAME) $(LDLIBS)
|
||||
|
||||
minigzip: minigzip.o $(LIBNAME)
|
||||
$(LD) $(LDFLAGS) $@ LIB:c_ppc.o $@.o $(LIBNAME) $(LDLIBS)
|
||||
|
||||
mostlyclean: clean
|
||||
clean:
|
||||
$(RM) *.o example minigzip $(LIBNAME) foo.gz
|
||||
|
||||
zip:
|
||||
zip -ul9 zlib README ChangeLog Makefile Make????.??? Makefile.?? \
|
||||
descrip.mms *.[ch]
|
||||
|
||||
tgz:
|
||||
cd ..; tar cfz zlib/zlib.tgz zlib/README zlib/ChangeLog zlib/Makefile \
|
||||
zlib/Make????.??? zlib/Makefile.?? zlib/descrip.mms zlib/*.[ch]
|
||||
|
||||
# DO NOT DELETE THIS LINE -- make depend depends on it.
|
||||
|
||||
adler32.o: zlib.h zconf.h
|
||||
compress.o: zlib.h zconf.h
|
||||
crc32.o: crc32.h zlib.h zconf.h
|
||||
deflate.o: deflate.h zutil.h zlib.h zconf.h
|
||||
example.o: zlib.h zconf.h
|
||||
gzio.o: zutil.h zlib.h zconf.h
|
||||
inffast.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
|
||||
inflate.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
|
||||
infback.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
|
||||
inftrees.o: zutil.h zlib.h zconf.h inftrees.h
|
||||
minigzip.o: zlib.h zconf.h
|
||||
trees.o: deflate.h zutil.h zlib.h zconf.h trees.h
|
||||
uncompr.o: zlib.h zconf.h
|
||||
zutil.o: zutil.h zlib.h zconf.h
|
||||
|
|
@ -1,65 +0,0 @@
|
|||
# SMakefile for zlib
|
||||
# Modified from the standard UNIX Makefile Copyright Jean-loup Gailly
|
||||
# Osma Ahvenlampi <Osma.Ahvenlampi@hut.fi>
|
||||
# Amiga, SAS/C 6.56 & Smake
|
||||
|
||||
CC=sc
|
||||
CFLAGS=OPT
|
||||
#CFLAGS=OPT CPU=68030
|
||||
#CFLAGS=DEBUG=LINE
|
||||
LDFLAGS=LIB z.lib
|
||||
|
||||
SCOPTIONS=OPTSCHED OPTINLINE OPTALIAS OPTTIME OPTINLOCAL STRMERGE \
|
||||
NOICONS PARMS=BOTH NOSTACKCHECK UTILLIB NOVERSION ERRORREXX \
|
||||
DEF=POSTINC
|
||||
|
||||
OBJS = adler32.o compress.o crc32.o gzio.o uncompr.o deflate.o trees.o \
|
||||
zutil.o inflate.o infback.o inftrees.o inffast.o
|
||||
|
||||
TEST_OBJS = example.o minigzip.o
|
||||
|
||||
all: SCOPTIONS example minigzip
|
||||
|
||||
check: test
|
||||
test: all
|
||||
example
|
||||
echo hello world | minigzip | minigzip -d
|
||||
|
||||
install: z.lib
|
||||
copy clone zlib.h zconf.h INCLUDE:
|
||||
copy clone z.lib LIB:
|
||||
|
||||
z.lib: $(OBJS)
|
||||
oml z.lib r $(OBJS)
|
||||
|
||||
example: example.o z.lib
|
||||
$(CC) $(CFLAGS) LINK TO $@ example.o $(LDFLAGS)
|
||||
|
||||
minigzip: minigzip.o z.lib
|
||||
$(CC) $(CFLAGS) LINK TO $@ minigzip.o $(LDFLAGS)
|
||||
|
||||
mostlyclean: clean
|
||||
clean:
|
||||
-delete force quiet example minigzip *.o z.lib foo.gz *.lnk SCOPTIONS
|
||||
|
||||
SCOPTIONS: Makefile.sas
|
||||
copy to $@ <from <
|
||||
$(SCOPTIONS)
|
||||
<
|
||||
|
||||
# DO NOT DELETE THIS LINE -- make depend depends on it.
|
||||
|
||||
adler32.o: zlib.h zconf.h
|
||||
compress.o: zlib.h zconf.h
|
||||
crc32.o: crc32.h zlib.h zconf.h
|
||||
deflate.o: deflate.h zutil.h zlib.h zconf.h
|
||||
example.o: zlib.h zconf.h
|
||||
gzio.o: zutil.h zlib.h zconf.h
|
||||
inffast.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
|
||||
inflate.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
|
||||
infback.o: zutil.h zlib.h zconf.h inftrees.h inflate.h inffast.h
|
||||
inftrees.o: zutil.h zlib.h zconf.h inftrees.h
|
||||
minigzip.o: zlib.h zconf.h
|
||||
trees.o: deflate.h zutil.h zlib.h zconf.h trees.h
|
||||
uncompr.o: zlib.h zconf.h
|
||||
zutil.o: zutil.h zlib.h zconf.h
|
||||
|
|
@ -1,132 +0,0 @@
|
|||
STRPGMEXP PGMLVL(*CURRENT) SIGNATURE('ZLIB')
|
||||
|
||||
/*@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@*/
|
||||
/* Version 1.1.3 entry points. */
|
||||
/*@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@*/
|
||||
|
||||
/********************************************************************/
|
||||
/* *MODULE ADLER32 ZLIB 01/02/01 00:15:09 */
|
||||
/********************************************************************/
|
||||
|
||||
EXPORT SYMBOL("adler32")
|
||||
|
||||
/********************************************************************/
|
||||
/* *MODULE COMPRESS ZLIB 01/02/01 00:15:09 */
|
||||
/********************************************************************/
|
||||
|
||||
EXPORT SYMBOL("compress")
|
||||
EXPORT SYMBOL("compress2")
|
||||
|
||||
/********************************************************************/
|
||||
/* *MODULE CRC32 ZLIB 01/02/01 00:15:09 */
|
||||
/********************************************************************/
|
||||
|
||||
EXPORT SYMBOL("crc32")
|
||||
EXPORT SYMBOL("get_crc_table")
|
||||
|
||||
/********************************************************************/
|
||||
/* *MODULE DEFLATE ZLIB 01/02/01 00:15:09 */
|
||||
/********************************************************************/
|
||||
|
||||
EXPORT SYMBOL("deflate")
|
||||
EXPORT SYMBOL("deflateEnd")
|
||||
EXPORT SYMBOL("deflateSetDictionary")
|
||||
EXPORT SYMBOL("deflateCopy")
|
||||
EXPORT SYMBOL("deflateReset")
|
||||
EXPORT SYMBOL("deflateParams")
|
||||
EXPORT SYMBOL("deflatePrime")
|
||||
EXPORT SYMBOL("deflateInit_")
|
||||
EXPORT SYMBOL("deflateInit2_")
|
||||
|
||||
/********************************************************************/
|
||||
/* *MODULE GZIO ZLIB 01/02/01 00:15:09 */
|
||||
/********************************************************************/
|
||||
|
||||
EXPORT SYMBOL("gzopen")
|
||||
EXPORT SYMBOL("gzdopen")
|
||||
EXPORT SYMBOL("gzsetparams")
|
||||
EXPORT SYMBOL("gzread")
|
||||
EXPORT SYMBOL("gzwrite")
|
||||
EXPORT SYMBOL("gzprintf")
|
||||
EXPORT SYMBOL("gzputs")
|
||||
EXPORT SYMBOL("gzgets")
|
||||
EXPORT SYMBOL("gzputc")
|
||||
EXPORT SYMBOL("gzgetc")
|
||||
EXPORT SYMBOL("gzflush")
|
||||
EXPORT SYMBOL("gzseek")
|
||||
EXPORT SYMBOL("gzrewind")
|
||||
EXPORT SYMBOL("gztell")
|
||||
EXPORT SYMBOL("gzeof")
|
||||
EXPORT SYMBOL("gzclose")
|
||||
EXPORT SYMBOL("gzerror")
|
||||
|
||||
/********************************************************************/
|
||||
/* *MODULE INFLATE ZLIB 01/02/01 00:15:09 */
|
||||
/********************************************************************/
|
||||
|
||||
EXPORT SYMBOL("inflate")
|
||||
EXPORT SYMBOL("inflateEnd")
|
||||
EXPORT SYMBOL("inflateSetDictionary")
|
||||
EXPORT SYMBOL("inflateSync")
|
||||
EXPORT SYMBOL("inflateReset")
|
||||
EXPORT SYMBOL("inflateInit_")
|
||||
EXPORT SYMBOL("inflateInit2_")
|
||||
EXPORT SYMBOL("inflateSyncPoint")
|
||||
|
||||
/********************************************************************/
|
||||
/* *MODULE UNCOMPR ZLIB 01/02/01 00:15:09 */
|
||||
/********************************************************************/
|
||||
|
||||
EXPORT SYMBOL("uncompress")
|
||||
|
||||
/********************************************************************/
|
||||
/* *MODULE ZUTIL ZLIB 01/02/01 00:15:09 */
|
||||
/********************************************************************/
|
||||
|
||||
EXPORT SYMBOL("zlibVersion")
|
||||
EXPORT SYMBOL("zError")
|
||||
|
||||
/*@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@*/
|
||||
/* Version 1.2.1 additional entry points. */
|
||||
/*@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@*/
|
||||
|
||||
/********************************************************************/
|
||||
/* *MODULE COMPRESS ZLIB 01/02/01 00:15:09 */
|
||||
/********************************************************************/
|
||||
|
||||
EXPORT SYMBOL("compressBound")
|
||||
|
||||
/********************************************************************/
|
||||
/* *MODULE DEFLATE ZLIB 01/02/01 00:15:09 */
|
||||
/********************************************************************/
|
||||
|
||||
EXPORT SYMBOL("deflateBound")
|
||||
|
||||
/********************************************************************/
|
||||
/* *MODULE GZIO ZLIB 01/02/01 00:15:09 */
|
||||
/********************************************************************/
|
||||
|
||||
EXPORT SYMBOL("gzungetc")
|
||||
EXPORT SYMBOL("gzclearerr")
|
||||
|
||||
/********************************************************************/
|
||||
/* *MODULE INFBACK ZLIB 01/02/01 00:15:09 */
|
||||
/********************************************************************/
|
||||
|
||||
EXPORT SYMBOL("inflateBack")
|
||||
EXPORT SYMBOL("inflateBackEnd")
|
||||
EXPORT SYMBOL("inflateBackInit_")
|
||||
|
||||
/********************************************************************/
|
||||
/* *MODULE INFLATE ZLIB 01/02/01 00:15:09 */
|
||||
/********************************************************************/
|
||||
|
||||
EXPORT SYMBOL("inflateCopy")
|
||||
|
||||
/********************************************************************/
|
||||
/* *MODULE ZUTIL ZLIB 01/02/01 00:15:09 */
|
||||
/********************************************************************/
|
||||
|
||||
EXPORT SYMBOL("zlibCompileFlags")
|
||||
|
||||
ENDPGMEXP
|
||||
|
|
@ -1,123 +0,0 @@
|
|||
/******************************************************************************/
|
||||
/* */
|
||||
/* ZLIB */
|
||||
/* */
|
||||
/* Compile sources into modules and link them into a service program. */
|
||||
/* */
|
||||
/******************************************************************************/
|
||||
|
||||
PGM
|
||||
|
||||
/* Configuration adjustable parameters. */
|
||||
|
||||
DCL VAR(&SRCLIB) TYPE(*CHAR) LEN(10) +
|
||||
VALUE('ZLIB') /* Source library. */
|
||||
DCL VAR(&SRCFILE) TYPE(*CHAR) LEN(10) +
|
||||
VALUE('SOURCES') /* Source member file. */
|
||||
DCL VAR(&CTLFILE) TYPE(*CHAR) LEN(10) +
|
||||
VALUE('TOOLS') /* Control member file. */
|
||||
|
||||
DCL VAR(&MODLIB) TYPE(*CHAR) LEN(10) +
|
||||
VALUE('ZLIB') /* Module library. */
|
||||
|
||||
DCL VAR(&SRVLIB) TYPE(*CHAR) LEN(10) +
|
||||
VALUE('LGPL') /* Service program library. */
|
||||
|
||||
DCL VAR(&CFLAGS) TYPE(*CHAR) +
|
||||
VALUE('OPTIMIZE(40)') /* Compile options. */
|
||||
|
||||
|
||||
/* Working storage. */
|
||||
|
||||
DCL VAR(&CMDLEN) TYPE(*DEC) LEN(15 5) VALUE(300) /* Command length. */
|
||||
DCL VAR(&CMD) TYPE(*CHAR) LEN(512)
|
||||
|
||||
|
||||
/* Compile sources into modules. */
|
||||
|
||||
CHGVAR VAR(&CMD) VALUE('CRTCMOD MODULE(' *TCAT &MODLIB *TCAT +
|
||||
'/ADLER32) SRCFILE(' *TCAT +
|
||||
&SRCLIB *TCAT '/' *TCAT &SRCFILE *TCAT +
|
||||
') SYSIFCOPT(*IFSIO)' *BCAT &CFLAGS)
|
||||
CALL PGM(QCMDEXC) PARM(&CMD &CMDLEN)
|
||||
|
||||
CHGVAR VAR(&CMD) VALUE('CRTCMOD MODULE(' *TCAT &MODLIB *TCAT +
|
||||
'/COMPRESS) SRCFILE(' *TCAT +
|
||||
&SRCLIB *TCAT '/' *TCAT &SRCFILE *TCAT +
|
||||
') SYSIFCOPT(*IFSIO)' *BCAT &CFLAGS)
|
||||
CALL PGM(QCMDEXC) PARM(&CMD &CMDLEN)
|
||||
|
||||
CHGVAR VAR(&CMD) VALUE('CRTCMOD MODULE(' *TCAT &MODLIB *TCAT +
|
||||
'/CRC32) SRCFILE(' *TCAT +
|
||||
&SRCLIB *TCAT '/' *TCAT &SRCFILE *TCAT +
|
||||
') SYSIFCOPT(*IFSIO)' *BCAT &CFLAGS)
|
||||
CALL PGM(QCMDEXC) PARM(&CMD &CMDLEN)
|
||||
|
||||
CHGVAR VAR(&CMD) VALUE('CRTCMOD MODULE(' *TCAT &MODLIB *TCAT +
|
||||
'/DEFLATE) SRCFILE(' *TCAT +
|
||||
&SRCLIB *TCAT '/' *TCAT &SRCFILE *TCAT +
|
||||
') SYSIFCOPT(*IFSIO)' *BCAT &CFLAGS)
|
||||
CALL PGM(QCMDEXC) PARM(&CMD &CMDLEN)
|
||||
|
||||
CHGVAR VAR(&CMD) VALUE('CRTCMOD MODULE(' *TCAT &MODLIB *TCAT +
|
||||
'/GZIO) SRCFILE(' *TCAT +
|
||||
&SRCLIB *TCAT '/' *TCAT &SRCFILE *TCAT +
|
||||
') SYSIFCOPT(*IFSIO)' *BCAT &CFLAGS)
|
||||
CALL PGM(QCMDEXC) PARM(&CMD &CMDLEN)
|
||||
|
||||
CHGVAR VAR(&CMD) VALUE('CRTCMOD MODULE(' *TCAT &MODLIB *TCAT +
|
||||
'/INFBACK) SRCFILE(' *TCAT +
|
||||
&SRCLIB *TCAT '/' *TCAT &SRCFILE *TCAT +
|
||||
') SYSIFCOPT(*IFSIO)' *BCAT &CFLAGS)
|
||||
CALL PGM(QCMDEXC) PARM(&CMD &CMDLEN)
|
||||
|
||||
CHGVAR VAR(&CMD) VALUE('CRTCMOD MODULE(' *TCAT &MODLIB *TCAT +
|
||||
'/INFFAST) SRCFILE(' *TCAT +
|
||||
&SRCLIB *TCAT '/' *TCAT &SRCFILE *TCAT +
|
||||
') SYSIFCOPT(*IFSIO)' *BCAT &CFLAGS)
|
||||
CALL PGM(QCMDEXC) PARM(&CMD &CMDLEN)
|
||||
|
||||
CHGVAR VAR(&CMD) VALUE('CRTCMOD MODULE(' *TCAT &MODLIB *TCAT +
|
||||
'/INFLATE) SRCFILE(' *TCAT +
|
||||
&SRCLIB *TCAT '/' *TCAT &SRCFILE *TCAT +
|
||||
') SYSIFCOPT(*IFSIO)' *BCAT &CFLAGS)
|
||||
CALL PGM(QCMDEXC) PARM(&CMD &CMDLEN)
|
||||
|
||||
CHGVAR VAR(&CMD) VALUE('CRTCMOD MODULE(' *TCAT &MODLIB *TCAT +
|
||||
'/INFTREES) SRCFILE(' *TCAT +
|
||||
&SRCLIB *TCAT '/' *TCAT &SRCFILE *TCAT +
|
||||
') SYSIFCOPT(*IFSIO)' *BCAT &CFLAGS)
|
||||
CALL PGM(QCMDEXC) PARM(&CMD &CMDLEN)
|
||||
|
||||
CHGVAR VAR(&CMD) VALUE('CRTCMOD MODULE(' *TCAT &MODLIB *TCAT +
|
||||
'/TREES) SRCFILE(' *TCAT +
|
||||
&SRCLIB *TCAT '/' *TCAT &SRCFILE *TCAT +
|
||||
') SYSIFCOPT(*IFSIO)' *BCAT &CFLAGS)
|
||||
CALL PGM(QCMDEXC) PARM(&CMD &CMDLEN)
|
||||
|
||||
CHGVAR VAR(&CMD) VALUE('CRTCMOD MODULE(' *TCAT &MODLIB *TCAT +
|
||||
'/UNCOMPR) SRCFILE(' *TCAT +
|
||||
&SRCLIB *TCAT '/' *TCAT &SRCFILE *TCAT +
|
||||
') SYSIFCOPT(*IFSIO)' *BCAT &CFLAGS)
|
||||
CALL PGM(QCMDEXC) PARM(&CMD &CMDLEN)
|
||||
|
||||
CHGVAR VAR(&CMD) VALUE('CRTCMOD MODULE(' *TCAT &MODLIB *TCAT +
|
||||
'/ZUTIL) SRCFILE(' *TCAT +
|
||||
&SRCLIB *TCAT '/' *TCAT &SRCFILE *TCAT +
|
||||
') SYSIFCOPT(*IFSIO)' *BCAT &CFLAGS)
|
||||
CALL PGM(QCMDEXC) PARM(&CMD &CMDLEN)
|
||||
|
||||
|
||||
/* Link modules into a service program. */
|
||||
|
||||
CRTSRVPGM SRVPGM(&SRVLIB/ZLIB) +
|
||||
MODULE(&MODLIB/ADLER32 &MODLIB/COMPRESS +
|
||||
&MODLIB/CRC32 &MODLIB/DEFLATE +
|
||||
&MODLIB/GZIO &MODLIB/INFBACK +
|
||||
&MODLIB/INFFAST &MODLIB/INFLATE +
|
||||
&MODLIB/INFTREES &MODLIB/TREES +
|
||||
&MODLIB/UNCOMPR &MODLIB/ZUTIL) +
|
||||
SRCFILE(&SRCLIB/&CTLFILE) SRCMBR(BNDSRC) +
|
||||
TEXT('ZLIB 1.2.1') TGTRLS(V4R4M0)
|
||||
|
||||
ENDPGM
|
||||
|
|
@ -1,111 +0,0 @@
|
|||
ZLIB version 1.2.1 for AS400 installation instructions
|
||||
|
||||
I) From an AS400 *SAVF file:
|
||||
|
||||
1) Unpacking archive to an AS400 save file
|
||||
|
||||
On the AS400:
|
||||
|
||||
_ Create the ZLIB AS400 library:
|
||||
|
||||
CRTLIB LIB(ZLIB) TYPE(PROD) TEXT('ZLIB compression API library')
|
||||
|
||||
_ Create a work save file, for example:
|
||||
|
||||
CRTSAVF FILE(ZLIB/ZLIBSAVF)
|
||||
|
||||
On a PC connected to the target AS400:
|
||||
|
||||
_ Unpack the save file image to a PC file "ZLIBSAVF"
|
||||
_ Upload this file into the save file on the AS400, for example
|
||||
using ftp in BINARY mode.
|
||||
|
||||
|
||||
2) Populating the ZLIB AS400 source library
|
||||
|
||||
On the AS400:
|
||||
|
||||
_ Extract the saved objects into the ZLIB AS400 library using:
|
||||
|
||||
RSTOBJ OBJ(*ALL) SAVLIB(ZLIB) DEV(*SAVF) SAVF(ZLIB/ZLIBSAVF) RSTLIB(ZLIB)
|
||||
|
||||
|
||||
3) Customize installation:
|
||||
|
||||
_ Edit CL member ZLIB/TOOLS(COMPILE) and change parameters if needed,
|
||||
according to the comments.
|
||||
|
||||
_ Compile this member with:
|
||||
|
||||
CRTCLPGM PGM(ZLIB/COMPILE) SRCFILE(ZLIB/TOOLS) SRCMBR(COMPILE)
|
||||
|
||||
|
||||
4) Compile and generate the service program:
|
||||
|
||||
_ This can now be done by executing:
|
||||
|
||||
CALL PGM(ZLIB/COMPILE)
|
||||
|
||||
|
||||
|
||||
II) From the original source distribution:
|
||||
|
||||
1) On the AS400, create the source library:
|
||||
|
||||
CRTLIB LIB(ZLIB) TYPE(PROD) TEXT('ZLIB compression API library')
|
||||
|
||||
2) Create the source files:
|
||||
|
||||
CRTSRCPF FILE(ZLIB/SOURCES) RCDLEN(112) TEXT('ZLIB library modules')
|
||||
CRTSRCPF FILE(ZLIB/H) RCDLEN(112) TEXT('ZLIB library includes')
|
||||
CRTSRCPF FILE(ZLIB/TOOLS) RCDLEN(112) TEXT('ZLIB library control utilities')
|
||||
|
||||
3) From the machine hosting the distribution files, upload them (with
|
||||
FTP in text mode, for example) according to the following table:
|
||||
|
||||
Original AS400 AS400 AS400 AS400
|
||||
file file member type description
|
||||
SOURCES Original ZLIB C subprogram sources
|
||||
adler32.c ADLER32 C ZLIB - Compute the Adler-32 checksum of a dta strm
|
||||
compress.c COMPRESS C ZLIB - Compress a memory buffer
|
||||
crc32.c CRC32 C ZLIB - Compute the CRC-32 of a data stream
|
||||
deflate.c DEFLATE C ZLIB - Compress data using the deflation algorithm
|
||||
gzio.c GZIO C ZLIB - IO on .gz files
|
||||
infback.c INFBACK C ZLIB - Inflate using a callback interface
|
||||
inffast.c INFFAST C ZLIB - Fast proc. literals & length/distance pairs
|
||||
inflate.c INFLATE C ZLIB - Interface to inflate modules
|
||||
inftrees.c INFTREES C ZLIB - Generate Huffman trees for efficient decode
|
||||
trees.c TREES C ZLIB - Output deflated data using Huffman coding
|
||||
uncompr.c UNCOMPR C ZLIB - Decompress a memory buffer
|
||||
zutil.c ZUTIL C ZLIB - Target dependent utility functions
|
||||
H Original ZLIB C and ILE/RPG include files
|
||||
crc32.h CRC32 C ZLIB - CRC32 tables
|
||||
deflate.h DEFLATE C ZLIB - Internal compression state
|
||||
inffast.h INFFAST C ZLIB - Header to use inffast.c
|
||||
inffixed.h INFFIXED C ZLIB - Table for decoding fixed codes
|
||||
inflate.h INFLATE C ZLIB - Internal inflate state definitions
|
||||
inftrees.h INFTREES C ZLIB - Header to use inftrees.c
|
||||
trees.h TREES C ZLIB - Created automatically with -DGEN_TREES_H
|
||||
zconf.h ZCONF C ZLIB - Compression library configuration
|
||||
zlib.h ZLIB C ZLIB - Compression library C user interface
|
||||
as400/zlib.inc ZLIB.INC RPGLE ZLIB - Compression library ILE RPG user interface
|
||||
zutil.h ZUTIL C ZLIB - Internal interface and configuration
|
||||
TOOLS Building source software & AS/400 README
|
||||
as400/bndsrc BNDSRC Entry point exportation list
|
||||
as400/compile.clp COMPILE CLP Compile sources & generate service program
|
||||
as400/readme.txt README TXT Installation instructions
|
||||
|
||||
4) Continue as in I)3).
|
||||
|
||||
|
||||
|
||||
|
||||
Notes: For AS400 ILE RPG programmers, a /copy member defining the ZLIB
|
||||
API prototypes for ILE RPG can be found in ZLIB/H(ZLIB.INC).
|
||||
Please read comments in this member for more information.
|
||||
|
||||
Remember that most foreign textual data are ASCII coded: this
|
||||
implementation does not handle conversion from/to ASCII, so
|
||||
text data code conversions must be done explicitely.
|
||||
|
||||
Always open zipped files in binary mode.
|
||||
|
|
@ -1,327 +0,0 @@
|
|||
* ZLIB.INC - Interface to the general purpose compression library
|
||||
*
|
||||
* ILE RPG400 version by Patrick Monnerat, DATASPHERE.
|
||||
* Version 1.2.1
|
||||
*
|
||||
*
|
||||
* WARNING:
|
||||
* Procedures inflateInit(), inflateInit2(), deflateInit(),
|
||||
* deflateInit2() and inflateBackInit() need to be called with
|
||||
* two additional arguments:
|
||||
* the package version string and the stream control structure.
|
||||
* size. This is needed because RPG lacks some macro feature.
|
||||
* Call these procedures as:
|
||||
* inflateInit(...: ZLIB_VERSION: %size(z_stream))
|
||||
*
|
||||
/if not defined(ZLIB_H_)
|
||||
/define ZLIB_H_
|
||||
*
|
||||
**************************************************************************
|
||||
* Constants
|
||||
**************************************************************************
|
||||
*
|
||||
D ZLIB_VERSION C '1.2.1' Header's version
|
||||
D ZLIB_VERNUM C X'1210'
|
||||
*
|
||||
D Z_NO_FLUSH C 0
|
||||
D Z_SYNC_FLUSH C 2
|
||||
D Z_FULL_FLUSH C 3
|
||||
D Z_FINISH C 4
|
||||
D Z_BLOCK C 5
|
||||
*
|
||||
D Z_OK C 0
|
||||
D Z_STREAM_END C 1
|
||||
D Z_NEED_DICT C 2
|
||||
D Z_ERRNO C -1
|
||||
D Z_STREAM_ERROR C -2
|
||||
D Z_DATA_ERROR C -3
|
||||
D Z_MEM_ERROR C -4
|
||||
D Z_BUF_ERROR C -5
|
||||
DZ_VERSION_ERROR C -6
|
||||
*
|
||||
D Z_NO_COMPRESSION...
|
||||
D C 0
|
||||
D Z_BEST_SPEED C 1
|
||||
D Z_BEST_COMPRESSION...
|
||||
D C 9
|
||||
D Z_DEFAULT_COMPRESSION...
|
||||
D C -1
|
||||
*
|
||||
D Z_FILTERED C 1
|
||||
D Z_HUFFMAN_ONLY C 2
|
||||
D Z_RLE C 3
|
||||
D Z_DEFAULT_STRATEGY...
|
||||
D C 0
|
||||
*
|
||||
D Z_BINARY C 0
|
||||
D Z_ASCII C 1
|
||||
D Z_UNKNOWN C 2
|
||||
*
|
||||
D Z_DEFLATED C 8
|
||||
*
|
||||
D Z_NULL C 0
|
||||
*
|
||||
**************************************************************************
|
||||
* Types
|
||||
**************************************************************************
|
||||
*
|
||||
D z_streamp S * Stream struct ptr
|
||||
D gzFile S * File pointer
|
||||
D z_off_t S 10i 0 Stream offsets
|
||||
*
|
||||
**************************************************************************
|
||||
* Structures
|
||||
**************************************************************************
|
||||
*
|
||||
* The GZIP encode/decode stream support structure.
|
||||
*
|
||||
D z_stream DS align based(z_streamp)
|
||||
D zs_next_in * Next input byte
|
||||
D zs_avail_in 10U 0 Byte cnt at next_in
|
||||
D zs_total_in 10U 0 Total bytes read
|
||||
D zs_next_out * Output buffer ptr
|
||||
D zs_avail_out 10U 0 Room left @ next_out
|
||||
D zs_total_out 10U 0 Total bytes written
|
||||
D zs_msg * Last errmsg or null
|
||||
D zs_state * Internal state
|
||||
D zs_zalloc * procptr Int. state allocator
|
||||
D zs_free * procptr Int. state dealloc.
|
||||
D zs_opaque * Private alloc. data
|
||||
D zs_data_type 10i 0 ASC/BIN best guess
|
||||
D zs_adler 10u 0 Uncompr. adler32 val
|
||||
D 10U 0 Reserved
|
||||
D 10U 0 Ptr. alignment
|
||||
*
|
||||
**************************************************************************
|
||||
* Utility function prototypes
|
||||
**************************************************************************
|
||||
*
|
||||
D compress PR 10I 0 extproc('compress')
|
||||
D dest 32767 options(*varsize) Destination buffer
|
||||
D destLen 10U 0 Destination length
|
||||
D source 32767 const options(*varsize) Source buffer
|
||||
D sourceLen 10u 0 value Source length
|
||||
*
|
||||
D compress2 PR 10I 0 extproc('compress2')
|
||||
D dest 32767 options(*varsize) Destination buffer
|
||||
D destLen 10U 0 Destination length
|
||||
D source 32767 const options(*varsize) Source buffer
|
||||
D sourceLen 10U 0 value Source length
|
||||
D level 10I 0 value Compression level
|
||||
*
|
||||
D compressBound PR 10U 0 extproc('compressBound')
|
||||
D sourceLen 10U 0 value
|
||||
*
|
||||
D uncompress PR 10I 0 extproc('uncompress')
|
||||
D dest 32767 options(*varsize) Destination buffer
|
||||
D destLen 10U 0 Destination length
|
||||
D source 32767 const options(*varsize) Source buffer
|
||||
D sourceLen 10U 0 value Source length
|
||||
*
|
||||
D gzopen PR extproc('gzopen')
|
||||
D like(gzFile)
|
||||
D path * value options(*string) File pathname
|
||||
D mode * value options(*string) Open mode
|
||||
*
|
||||
D gzdopen PR extproc('gzdopen')
|
||||
D like(gzFile)
|
||||
D fd 10i 0 value File descriptor
|
||||
D mode * value options(*string) Open mode
|
||||
*
|
||||
D gzsetparams PR 10I 0 extproc('gzsetparams')
|
||||
D file value like(gzFile) File pointer
|
||||
D level 10I 0 value
|
||||
D strategy 10i 0 value
|
||||
*
|
||||
D gzread PR 10I 0 extproc('gzread')
|
||||
D file value like(gzFile) File pointer
|
||||
D buf 32767 options(*varsize) Buffer
|
||||
D len 10u 0 value Buffer length
|
||||
*
|
||||
D gzwrite PR 10I 0 extproc('gzwrite')
|
||||
D file value like(gzFile) File pointer
|
||||
D buf 32767 const options(*varsize) Buffer
|
||||
D len 10u 0 value Buffer length
|
||||
*
|
||||
D gzputs PR 10I 0 extproc('gzputs')
|
||||
D file value like(gzFile) File pointer
|
||||
D s * value options(*string) String to output
|
||||
*
|
||||
D gzgets PR * extproc('gzgets')
|
||||
D file value like(gzFile) File pointer
|
||||
D buf 32767 options(*varsize) Read buffer
|
||||
D len 10i 0 value Buffer length
|
||||
*
|
||||
D gzflush PR 10i 0 extproc('gzflush')
|
||||
D file value like(gzFile) File pointer
|
||||
D flush 10I 0 value Type of flush
|
||||
*
|
||||
D gzseek PR extproc('gzseek')
|
||||
D like(z_off_t)
|
||||
D file value like(gzFile) File pointer
|
||||
D offset value like(z_off_t) Offset
|
||||
D whence 10i 0 value Origin
|
||||
*
|
||||
D gzrewind PR 10i 0 extproc('gzrewind')
|
||||
D file value like(gzFile) File pointer
|
||||
*
|
||||
D gztell PR extproc('gztell')
|
||||
D like(z_off_t)
|
||||
D file value like(gzFile) File pointer
|
||||
*
|
||||
D gzeof PR 10i 0 extproc('gzeof')
|
||||
D file value like(gzFile) File pointer
|
||||
*
|
||||
D gzclose PR 10i 0 extproc('gzclose')
|
||||
D file value like(gzFile) File pointer
|
||||
*
|
||||
D gzerror PR * extproc('gzerror') Error string
|
||||
D file value like(gzFile) File pointer
|
||||
D errnum 10I 0 Error code
|
||||
*
|
||||
D gzclearerr PR extproc('gzclearerr')
|
||||
D file value like(gzFile) File pointer
|
||||
*
|
||||
**************************************************************************
|
||||
* Basic function prototypes
|
||||
**************************************************************************
|
||||
*
|
||||
D zlibVersion PR * extproc('zlibVersion') Version string
|
||||
*
|
||||
D deflateInit PR 10I 0 extproc('deflateInit_') Init. compression
|
||||
D strm like(z_stream) Compression stream
|
||||
D level 10I 0 value Compression level
|
||||
D version * value options(*string) Version string
|
||||
D stream_size 10i 0 value Stream struct. size
|
||||
*
|
||||
D deflate PR 10I 0 extproc('deflate') Compress data
|
||||
D strm like(z_stream) Compression stream
|
||||
D flush 10I 0 value Flush type required
|
||||
*
|
||||
D deflateEnd PR 10I 0 extproc('deflateEnd') Termin. compression
|
||||
D strm like(z_stream) Compression stream
|
||||
*
|
||||
D inflateInit PR 10I 0 extproc('inflateInit_') Init. expansion
|
||||
D strm like(z_stream) Expansion stream
|
||||
D version * value options(*string) Version string
|
||||
D stream_size 10i 0 value Stream struct. size
|
||||
*
|
||||
D inflate PR 10I 0 extproc('inflate') Expand data
|
||||
D strm like(z_stream) Expansion stream
|
||||
D flush 10I 0 value Flush type required
|
||||
*
|
||||
D inflateEnd PR 10I 0 extproc('inflateEnd') Termin. expansion
|
||||
D strm like(z_stream) Expansion stream
|
||||
*
|
||||
**************************************************************************
|
||||
* Advanced function prototypes
|
||||
**************************************************************************
|
||||
*
|
||||
D deflateInit2 PR 10I 0 extproc('deflateInit2_') Init. compression
|
||||
D strm like(z_stream) Compression stream
|
||||
D level 10I 0 value Compression level
|
||||
D method 10I 0 value Compression method
|
||||
D windowBits 10I 0 value log2(window size)
|
||||
D memLevel 10I 0 value Mem/cmpress tradeoff
|
||||
D strategy 10I 0 value Compression stategy
|
||||
D version * value options(*string) Version string
|
||||
D stream_size 10i 0 value Stream struct. size
|
||||
*
|
||||
D deflateSetDictionary...
|
||||
D PR 10I 0 extproc('deflateSetDictionary') Init. dictionary
|
||||
D strm like(z_stream) Compression stream
|
||||
D dictionary 32767 const options(*varsize) Dictionary bytes
|
||||
D dictLength 10U 0 value Dictionary length
|
||||
*
|
||||
D deflateCopy PR 10I 0 extproc('deflateCopy') Compress strm 2 strm
|
||||
D dest like(z_stream) Destination stream
|
||||
D source like(z_stream) Source stream
|
||||
*
|
||||
D deflateReset PR 10I 0 extproc('deflateReset') End and init. stream
|
||||
D strm like(z_stream) Compression stream
|
||||
*
|
||||
D deflateParams PR 10I 0 extproc('deflateParams') Change level & strat
|
||||
D strm like(z_stream) Compression stream
|
||||
D level 10I 0 value Compression level
|
||||
D strategy 10I 0 value Compression stategy
|
||||
*
|
||||
D deflateBound PR 10U 0 extproc('deflateBound') Change level & strat
|
||||
D strm like(z_stream) Compression stream
|
||||
D sourcelen 10U 0 value Compression level
|
||||
*
|
||||
D deflatePrime PR 10I 0 extproc('deflatePrime') Change level & strat
|
||||
D strm like(z_stream) Compression stream
|
||||
D bits 10I 0 value Number of bits to insert
|
||||
D value 10I 0 value Bits to insert
|
||||
*
|
||||
D inflateInit2 PR 10I 0 extproc('inflateInit2_') Init. expansion
|
||||
D strm like(z_stream) Expansion stream
|
||||
D windowBits 10I 0 value log2(window size)
|
||||
D version * value options(*string) Version string
|
||||
D stream_size 10i 0 value Stream struct. size
|
||||
*
|
||||
D inflateSetDictionary...
|
||||
D PR 10I 0 extproc('inflateSetDictionary') Init. dictionary
|
||||
D strm like(z_stream) Expansion stream
|
||||
D dictionary 32767 const options(*varsize) Dictionary bytes
|
||||
D dictLength 10U 0 value Dictionary length
|
||||
*
|
||||
D inflateSync PR 10I 0 extproc('inflateSync') Sync. expansion
|
||||
D strm like(z_stream) Expansion stream
|
||||
*
|
||||
D inflateCopy PR 10I 0 extproc('inflateCopy')
|
||||
D dest like(z_stream) Destination stream
|
||||
D source like(z_stream) Source stream
|
||||
*
|
||||
D inflateReset PR 10I 0 extproc('inflateReset') End and init. stream
|
||||
D strm like(z_stream) Expansion stream
|
||||
*
|
||||
D inflateBackInit...
|
||||
D PR 10I 0 extproc('inflateBackInit_')
|
||||
D strm like(z_stream) Expansion stream
|
||||
D windowBits 10I 0 value Log2(buffer size)
|
||||
D window 32767 options(*varsize) Buffer
|
||||
D version * value options(*string) Version string
|
||||
D stream_size 10i 0 value Stream struct. size
|
||||
*
|
||||
D inflateBack PR 10I 0 extproc('inflateBack')
|
||||
D strm like(z_stream) Expansion stream
|
||||
D in * value procptr Input function
|
||||
D in_desc * value Input descriptor
|
||||
D out * value procptr Output function
|
||||
D out_desc * value Output descriptor
|
||||
*
|
||||
D inflateBackEnd PR 10I 0 extproc('inflateBackEnd')
|
||||
D strm like(z_stream) Expansion stream
|
||||
*
|
||||
D zlibCompileFlags...
|
||||
D PR 10U 0 extproc('zlibCompileFlags')
|
||||
*
|
||||
**************************************************************************
|
||||
* Checksum function prototypes
|
||||
**************************************************************************
|
||||
*
|
||||
D adler32 PR 10U 0 extproc('adler32') New checksum
|
||||
D adler 10U 0 value Old checksum
|
||||
D buf 32767 const options(*varsize) Bytes to accumulate
|
||||
D len 10U 0 value Buffer length
|
||||
*
|
||||
D crc32 PR 10U 0 extproc('crc32') New checksum
|
||||
D crc 10U 0 value Old checksum
|
||||
D buf 32767 const options(*varsize) Bytes to accumulate
|
||||
D len 10U 0 value Buffer length
|
||||
*
|
||||
**************************************************************************
|
||||
* Miscellaneous function prototypes
|
||||
**************************************************************************
|
||||
*
|
||||
D zError PR * extproc('zError') Error string
|
||||
D err 10I 0 value Error code
|
||||
*
|
||||
D inflateSyncPoint...
|
||||
D PR 10I 0 extproc('inflateSyncPoint')
|
||||
D strm like(z_stream) Expansion stream
|
||||
*
|
||||
D get_crc_table PR * extproc('get_crc_table') Ptr to ulongs
|
||||
*
|
||||
/endif
|
||||
|
|
@ -1,79 +0,0 @@
|
|||
/* compress.c -- compress a memory buffer
|
||||
* Copyright (C) 1995-2002 Jean-loup Gailly.
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
/* @(#) $Id$ */
|
||||
|
||||
#define ZLIB_INTERNAL
|
||||
#include "zlib.h"
|
||||
|
||||
/* ===========================================================================
|
||||
Compresses the source buffer into the destination buffer. The level
|
||||
parameter has the same meaning as in deflateInit. sourceLen is the byte
|
||||
length of the source buffer. Upon entry, destLen is the total size of the
|
||||
destination buffer, which must be at least 0.1% larger than sourceLen plus
|
||||
12 bytes. Upon exit, destLen is the actual size of the compressed buffer.
|
||||
|
||||
compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
||||
memory, Z_BUF_ERROR if there was not enough room in the output buffer,
|
||||
Z_STREAM_ERROR if the level parameter is invalid.
|
||||
*/
|
||||
int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
|
||||
Bytef *dest;
|
||||
uLongf *destLen;
|
||||
const Bytef *source;
|
||||
uLong sourceLen;
|
||||
int level;
|
||||
{
|
||||
z_stream stream;
|
||||
int err;
|
||||
|
||||
stream.next_in = (Bytef*)source;
|
||||
stream.avail_in = (uInt)sourceLen;
|
||||
#ifdef MAXSEG_64K
|
||||
/* Check for source > 64K on 16-bit machine: */
|
||||
if ((uLong)stream.avail_in != sourceLen) return Z_BUF_ERROR;
|
||||
#endif
|
||||
stream.next_out = dest;
|
||||
stream.avail_out = (uInt)*destLen;
|
||||
if ((uLong)stream.avail_out != *destLen) return Z_BUF_ERROR;
|
||||
|
||||
stream.zalloc = (alloc_func)0;
|
||||
stream.zfree = (free_func)0;
|
||||
stream.opaque = (voidpf)0;
|
||||
|
||||
err = deflateInit(&stream, level);
|
||||
if (err != Z_OK) return err;
|
||||
|
||||
err = deflate(&stream, Z_FINISH);
|
||||
if (err != Z_STREAM_END) {
|
||||
deflateEnd(&stream);
|
||||
return err == Z_OK ? Z_BUF_ERROR : err;
|
||||
}
|
||||
*destLen = stream.total_out;
|
||||
|
||||
err = deflateEnd(&stream);
|
||||
return err;
|
||||
}
|
||||
|
||||
/* ===========================================================================
|
||||
*/
|
||||
int ZEXPORT compress (dest, destLen, source, sourceLen)
|
||||
Bytef *dest;
|
||||
uLongf *destLen;
|
||||
const Bytef *source;
|
||||
uLong sourceLen;
|
||||
{
|
||||
return compress2(dest, destLen, source, sourceLen, Z_DEFAULT_COMPRESSION);
|
||||
}
|
||||
|
||||
/* ===========================================================================
|
||||
If the default memLevel or windowBits for deflateInit() is changed, then
|
||||
this function needs to be updated.
|
||||
*/
|
||||
uLong ZEXPORT compressBound (sourceLen)
|
||||
uLong sourceLen;
|
||||
{
|
||||
return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + 11;
|
||||
}
|
||||
445
zlib/configure
vendored
445
zlib/configure
vendored
|
|
@ -1,445 +0,0 @@
|
|||
#!/bin/sh
|
||||
# configure script for zlib. This script is needed only if
|
||||
# you wish to build a shared library and your system supports them,
|
||||
# of if you need special compiler, flags or install directory.
|
||||
# Otherwise, you can just use directly "make test; make install"
|
||||
#
|
||||
# To create a shared library, use "configure --shared"; by default a static
|
||||
# library is created. If the primitive shared library support provided here
|
||||
# does not work, use ftp://prep.ai.mit.edu/pub/gnu/libtool-*.tar.gz
|
||||
#
|
||||
# To impose specific compiler or flags or install directory, use for example:
|
||||
# prefix=$HOME CC=cc CFLAGS="-O4" ./configure
|
||||
# or for csh/tcsh users:
|
||||
# (setenv prefix $HOME; setenv CC cc; setenv CFLAGS "-O4"; ./configure)
|
||||
# LDSHARED is the command to be used to create a shared library
|
||||
|
||||
# Incorrect settings of CC or CFLAGS may prevent creating a shared library.
|
||||
# If you have problems, try without defining CC and CFLAGS before reporting
|
||||
# an error.
|
||||
|
||||
LIBS=libz.a
|
||||
LDFLAGS="-L. ${LIBS}"
|
||||
VER=`sed -n -e '/VERSION "/s/.*"\(.*\)".*/\1/p' < zlib.h`
|
||||
VER2=`sed -n -e '/VERSION "/s/.*"\([0-9]*\\.[0-9]*\)\\..*/\1/p' < zlib.h`
|
||||
VER1=`sed -n -e '/VERSION "/s/.*"\([0-9]*\)\\..*/\1/p' < zlib.h`
|
||||
AR=${AR-"ar rc"}
|
||||
RANLIB=${RANLIB-"ranlib"}
|
||||
prefix=${prefix-/usr/local}
|
||||
exec_prefix=${exec_prefix-'${prefix}'}
|
||||
libdir=${libdir-'${exec_prefix}/lib'}
|
||||
includedir=${includedir-'${prefix}/include'}
|
||||
mandir=${mandir-'${prefix}/share/man'}
|
||||
shared_ext='.so'
|
||||
shared=0
|
||||
gcc=0
|
||||
old_cc="$CC"
|
||||
old_cflags="$CFLAGS"
|
||||
|
||||
while test $# -ge 1
|
||||
do
|
||||
case "$1" in
|
||||
-h* | --h*)
|
||||
echo 'usage:'
|
||||
echo ' configure [--shared] [--prefix=PREFIX] [--exec_prefix=EXPREFIX]'
|
||||
echo ' [--libdir=LIBDIR] [--includedir=INCLUDEDIR]'
|
||||
exit 0;;
|
||||
-p*=* | --p*=*) prefix=`echo $1 | sed 's/[-a-z_]*=//'`; shift;;
|
||||
-e*=* | --e*=*) exec_prefix=`echo $1 | sed 's/[-a-z_]*=//'`; shift;;
|
||||
-l*=* | --libdir=*) libdir=`echo $1 | sed 's/[-a-z_]*=//'`; shift;;
|
||||
-i*=* | --includedir=*) includedir=`echo $1 | sed 's/[-a-z_]*=//'`;shift;;
|
||||
-p* | --p*) prefix="$2"; shift; shift;;
|
||||
-e* | --e*) exec_prefix="$2"; shift; shift;;
|
||||
-l* | --l*) libdir="$2"; shift; shift;;
|
||||
-i* | --i*) includedir="$2"; shift; shift;;
|
||||
-s* | --s*) shared=1; shift;;
|
||||
*) echo "unknown option: $1"; echo "$0 --help for help"; exit 1;;
|
||||
esac
|
||||
done
|
||||
|
||||
test=ztest$$
|
||||
cat > $test.c <<EOF
|
||||
extern int getchar();
|
||||
int hello() {return getchar();}
|
||||
EOF
|
||||
|
||||
test -z "$CC" && echo Checking for gcc...
|
||||
cc=${CC-gcc}
|
||||
cflags=${CFLAGS-"-O3"}
|
||||
# to force the asm version use: CFLAGS="-O3 -DASMV" ./configure
|
||||
case "$cc" in
|
||||
*gcc*) gcc=1;;
|
||||
esac
|
||||
|
||||
if test "$gcc" -eq 1 && ($cc -c $cflags $test.c) 2>/dev/null; then
|
||||
CC="$cc"
|
||||
SFLAGS=${CFLAGS-"-fPIC -O3"}
|
||||
CFLAGS="$cflags"
|
||||
case `(uname -s || echo unknown) 2>/dev/null` in
|
||||
Linux | linux | GNU | GNU/*) LDSHARED=${LDSHARED-"$cc -shared -Wl,-soname,libz.so.1"};;
|
||||
CYGWIN* | Cygwin* | cygwin* )
|
||||
EXE='.exe';;
|
||||
QNX*) # This is for QNX6. I suppose that the QNX rule below is for QNX2,QNX4
|
||||
# (alain.bonnefoy@icbt.com)
|
||||
LDSHARED=${LDSHARED-"$cc -shared -Wl,-hlibz.so.1"};;
|
||||
HP-UX*) LDSHARED=${LDSHARED-"$cc -shared $SFLAGS"}
|
||||
shared_ext='.sl'
|
||||
SHAREDLIB='libz.sl';;
|
||||
Darwin*) shared_ext='.dylib'
|
||||
SHAREDLIB=libz$shared_ext
|
||||
SHAREDLIBV=libz.$VER$shared_ext
|
||||
SHAREDLIBM=libz.$VER1$shared_ext
|
||||
LDSHARED=${LDSHARED-"$cc -dynamiclib -install_name /usr/lib/$SHAREDLIBV -compatibility_version $VER2 -current_version $VER"}
|
||||
libdir='/usr/lib'
|
||||
includedir='/usr/include';;
|
||||
*) LDSHARED=${LDSHARED-"$cc -shared"};;
|
||||
esac
|
||||
else
|
||||
# find system name and corresponding cc options
|
||||
CC=${CC-cc}
|
||||
case `(uname -sr || echo unknown) 2>/dev/null` in
|
||||
HP-UX*) SFLAGS=${CFLAGS-"-O +z"}
|
||||
CFLAGS=${CFLAGS-"-O"}
|
||||
# LDSHARED=${LDSHARED-"ld -b +vnocompatwarnings"}
|
||||
LDSHARED=${LDSHARED-"ld -b"}
|
||||
shared_ext='.sl'
|
||||
SHAREDLIB='libz.sl';;
|
||||
IRIX*) SFLAGS=${CFLAGS-"-ansi -O2 -rpath ."}
|
||||
CFLAGS=${CFLAGS-"-ansi -O2"}
|
||||
LDSHARED=${LDSHARED-"cc -shared"};;
|
||||
OSF1\ V4*) SFLAGS=${CFLAGS-"-O -std1"}
|
||||
CFLAGS=${CFLAGS-"-O -std1"}
|
||||
LDSHARED=${LDSHARED-"cc -shared -Wl,-soname,libz.so -Wl,-msym -Wl,-rpath,$(libdir) -Wl,-set_version,${VER}:1.0"};;
|
||||
OSF1*) SFLAGS=${CFLAGS-"-O -std1"}
|
||||
CFLAGS=${CFLAGS-"-O -std1"}
|
||||
LDSHARED=${LDSHARED-"cc -shared"};;
|
||||
QNX*) SFLAGS=${CFLAGS-"-4 -O"}
|
||||
CFLAGS=${CFLAGS-"-4 -O"}
|
||||
LDSHARED=${LDSHARED-"cc"}
|
||||
RANLIB=${RANLIB-"true"}
|
||||
AR="cc -A";;
|
||||
SCO_SV\ 3.2*) SFLAGS=${CFLAGS-"-O3 -dy -KPIC "}
|
||||
CFLAGS=${CFLAGS-"-O3"}
|
||||
LDSHARED=${LDSHARED-"cc -dy -KPIC -G"};;
|
||||
SunOS\ 5*) SFLAGS=${CFLAGS-"-fast -xcg89 -KPIC -R."}
|
||||
CFLAGS=${CFLAGS-"-fast -xcg89"}
|
||||
LDSHARED=${LDSHARED-"cc -G"};;
|
||||
SunOS\ 4*) SFLAGS=${CFLAGS-"-O2 -PIC"}
|
||||
CFLAGS=${CFLAGS-"-O2"}
|
||||
LDSHARED=${LDSHARED-"ld"};;
|
||||
UNIX_System_V\ 4.2.0)
|
||||
SFLAGS=${CFLAGS-"-KPIC -O"}
|
||||
CFLAGS=${CFLAGS-"-O"}
|
||||
LDSHARED=${LDSHARED-"cc -G"};;
|
||||
UNIX_SV\ 4.2MP)
|
||||
SFLAGS=${CFLAGS-"-Kconform_pic -O"}
|
||||
CFLAGS=${CFLAGS-"-O"}
|
||||
LDSHARED=${LDSHARED-"cc -G"};;
|
||||
OpenUNIX\ 5)
|
||||
SFLAGS=${CFLAGS-"-KPIC -O"}
|
||||
CFLAGS=${CFLAGS-"-O"}
|
||||
LDSHARED=${LDSHARED-"cc -G"};;
|
||||
AIX*) # Courtesy of dbakker@arrayasolutions.com
|
||||
SFLAGS=${CFLAGS-"-O -qmaxmem=8192"}
|
||||
CFLAGS=${CFLAGS-"-O -qmaxmem=8192"}
|
||||
LDSHARED=${LDSHARED-"xlc -G"};;
|
||||
# send working options for other systems to support@gzip.org
|
||||
*) SFLAGS=${CFLAGS-"-O"}
|
||||
CFLAGS=${CFLAGS-"-O"}
|
||||
LDSHARED=${LDSHARED-"cc -shared"};;
|
||||
esac
|
||||
fi
|
||||
|
||||
SHAREDLIB=${SHAREDLIB-"libz$shared_ext"}
|
||||
SHAREDLIBV=${SHAREDLIBV-"libz$shared_ext.$VER"}
|
||||
SHAREDLIBM=${SHAREDLIBM-"libz$shared_ext.$VER1"}
|
||||
|
||||
if test $shared -eq 1; then
|
||||
echo Checking for shared library support...
|
||||
# we must test in two steps (cc then ld), required at least on SunOS 4.x
|
||||
if test "`($CC -c $SFLAGS $test.c) 2>&1`" = "" &&
|
||||
test "`($LDSHARED -o $test$shared_ext $test.o) 2>&1`" = ""; then
|
||||
CFLAGS="$SFLAGS"
|
||||
LIBS="$SHAREDLIBV"
|
||||
echo Building shared library $SHAREDLIBV with $CC.
|
||||
elif test -z "$old_cc" -a -z "$old_cflags"; then
|
||||
echo No shared library support.
|
||||
shared=0;
|
||||
else
|
||||
echo 'No shared library support; try without defining CC and CFLAGS'
|
||||
shared=0;
|
||||
fi
|
||||
fi
|
||||
if test $shared -eq 0; then
|
||||
LDSHARED="$CC"
|
||||
echo Building static library $LIBS version $VER with $CC.
|
||||
else
|
||||
LDFLAGS="-L. ${SHAREDLIBV}"
|
||||
fi
|
||||
|
||||
cat > $test.c <<EOF
|
||||
#include <unistd.h>
|
||||
int main() { return 0; }
|
||||
EOF
|
||||
if test "`($CC -c $CFLAGS $test.c) 2>&1`" = ""; then
|
||||
sed < zconf.in.h "/HAVE_UNISTD_H/s%0%1%" > zconf.h
|
||||
echo "Checking for unistd.h... Yes."
|
||||
else
|
||||
cp -p zconf.in.h zconf.h
|
||||
echo "Checking for unistd.h... No."
|
||||
fi
|
||||
|
||||
cat > $test.c <<EOF
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
#include "zconf.h"
|
||||
|
||||
int main()
|
||||
{
|
||||
#ifndef STDC
|
||||
choke me
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
}
|
||||
EOF
|
||||
|
||||
if test "`($CC -c $CFLAGS $test.c) 2>&1`" = ""; then
|
||||
echo "Checking whether to use vs[n]printf() or s[n]printf()... using vs[n]printf()"
|
||||
|
||||
cat > $test.c <<EOF
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
int mytest(char *fmt, ...)
|
||||
{
|
||||
char buf[20];
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
vsnprintf(buf, sizeof(buf), fmt, ap);
|
||||
va_end(ap);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
return (mytest("Hello%d\n", 1));
|
||||
}
|
||||
EOF
|
||||
|
||||
if test "`($CC $CFLAGS -o $test $test.c) 2>&1`" = ""; then
|
||||
echo "Checking for vsnprintf() in stdio.h... Yes."
|
||||
|
||||
cat >$test.c <<EOF
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
int mytest(char *fmt, ...)
|
||||
{
|
||||
int n;
|
||||
char buf[20];
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
n = vsnprintf(buf, sizeof(buf), fmt, ap);
|
||||
va_end(ap);
|
||||
return n;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
return (mytest("Hello%d\n", 1));
|
||||
}
|
||||
EOF
|
||||
|
||||
if test "`($CC -c $CFLAGS $test.c) 2>&1`" = ""; then
|
||||
echo "Checking for return value of vsnprintf()... Yes."
|
||||
else
|
||||
CFLAGS="$CFLAGS -DHAS_vsnprintf_void"
|
||||
echo "Checking for return value of vsnprintf()... No."
|
||||
echo " WARNING: apparently vsnprintf() does not return a value. zlib"
|
||||
echo " can build but will be open to possible string-format security"
|
||||
echo " vulnerabilities."
|
||||
fi
|
||||
else
|
||||
CFLAGS="$CFLAGS -DNO_vsnprintf"
|
||||
echo "Checking for vsnprintf() in stdio.h... No."
|
||||
echo " WARNING: vsnprintf() not found, falling back to vsprintf(). zlib"
|
||||
echo " can build but will be open to possible buffer-overflow security"
|
||||
echo " vulnerabilities."
|
||||
|
||||
cat >$test.c <<EOF
|
||||
#include <stdio.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
int mytest(char *fmt, ...)
|
||||
{
|
||||
int n;
|
||||
char buf[20];
|
||||
va_list ap;
|
||||
|
||||
va_start(ap, fmt);
|
||||
n = vsprintf(buf, fmt, ap);
|
||||
va_end(ap);
|
||||
return n;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
return (mytest("Hello%d\n", 1));
|
||||
}
|
||||
EOF
|
||||
|
||||
if test "`($CC -c $CFLAGS $test.c) 2>&1`" = ""; then
|
||||
echo "Checking for return value of vsprintf()... Yes."
|
||||
else
|
||||
CFLAGS="$CFLAGS -DHAS_vsprintf_void"
|
||||
echo "Checking for return value of vsprintf()... No."
|
||||
echo " WARNING: apparently vsprintf() does not return a value. zlib"
|
||||
echo " can build but will be open to possible string-format security"
|
||||
echo " vulnerabilities."
|
||||
fi
|
||||
fi
|
||||
else
|
||||
echo "Checking whether to use vs[n]printf() or s[n]printf()... using s[n]printf()"
|
||||
|
||||
cat >$test.c <<EOF
|
||||
#include <stdio.h>
|
||||
|
||||
int mytest()
|
||||
{
|
||||
char buf[20];
|
||||
|
||||
snprintf(buf, sizeof(buf), "%s", "foo");
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
return (mytest());
|
||||
}
|
||||
EOF
|
||||
|
||||
if test "`($CC $CFLAGS -o $test $test.c) 2>&1`" = ""; then
|
||||
echo "Checking for snprintf() in stdio.h... Yes."
|
||||
|
||||
cat >$test.c <<EOF
|
||||
#include <stdio.h>
|
||||
|
||||
int mytest()
|
||||
{
|
||||
char buf[20];
|
||||
|
||||
return snprintf(buf, sizeof(buf), "%s", "foo");
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
return (mytest());
|
||||
}
|
||||
EOF
|
||||
|
||||
if test "`($CC -c $CFLAGS $test.c) 2>&1`" = ""; then
|
||||
echo "Checking for return value of snprintf()... Yes."
|
||||
else
|
||||
CFLAGS="$CFLAGS -DHAS_snprintf_void"
|
||||
echo "Checking for return value of snprintf()... No."
|
||||
echo " WARNING: apparently snprintf() does not return a value. zlib"
|
||||
echo " can build but will be open to possible string-format security"
|
||||
echo " vulnerabilities."
|
||||
fi
|
||||
else
|
||||
CFLAGS="$CFLAGS -DNO_snprintf"
|
||||
echo "Checking for snprintf() in stdio.h... No."
|
||||
echo " WARNING: snprintf() not found, falling back to sprintf(). zlib"
|
||||
echo " can build but will be open to possible buffer-overflow security"
|
||||
echo " vulnerabilities."
|
||||
|
||||
cat >$test.c <<EOF
|
||||
#include <stdio.h>
|
||||
|
||||
int mytest()
|
||||
{
|
||||
char buf[20];
|
||||
|
||||
return sprintf(buf, "%s", "foo");
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
return (mytest());
|
||||
}
|
||||
EOF
|
||||
|
||||
if test "`($CC -c $CFLAGS $test.c) 2>&1`" = ""; then
|
||||
echo "Checking for return value of sprintf()... Yes."
|
||||
else
|
||||
CFLAGS="$CFLAGS -DHAS_sprintf_void"
|
||||
echo "Checking for return value of sprintf()... No."
|
||||
echo " WARNING: apparently sprintf() does not return a value. zlib"
|
||||
echo " can build but will be open to possible string-format security"
|
||||
echo " vulnerabilities."
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
cat >$test.c <<EOF
|
||||
#include <errno.h>
|
||||
int main() { return 0; }
|
||||
EOF
|
||||
if test "`($CC -c $CFLAGS $test.c) 2>&1`" = ""; then
|
||||
echo "Checking for errno.h... Yes."
|
||||
else
|
||||
echo "Checking for errno.h... No."
|
||||
CFLAGS="$CFLAGS -DNO_ERRNO_H"
|
||||
fi
|
||||
|
||||
cat > $test.c <<EOF
|
||||
#include <sys/types.h>
|
||||
#include <sys/mman.h>
|
||||
#include <sys/stat.h>
|
||||
caddr_t hello() {
|
||||
return mmap((caddr_t)0, (off_t)0, PROT_READ, MAP_SHARED, 0, (off_t)0);
|
||||
}
|
||||
EOF
|
||||
if test "`($CC -c $CFLAGS $test.c) 2>&1`" = ""; then
|
||||
CFLAGS="$CFLAGS -DUSE_MMAP"
|
||||
echo Checking for mmap support... Yes.
|
||||
else
|
||||
echo Checking for mmap support... No.
|
||||
fi
|
||||
|
||||
CPP=${CPP-"$CC -E"}
|
||||
case $CFLAGS in
|
||||
*ASMV*)
|
||||
if test "`nm $test.o | grep _hello`" = ""; then
|
||||
CPP="$CPP -DNO_UNDERLINE"
|
||||
echo Checking for underline in external names... No.
|
||||
else
|
||||
echo Checking for underline in external names... Yes.
|
||||
fi;;
|
||||
esac
|
||||
|
||||
rm -f $test.[co] $test $test$shared_ext
|
||||
|
||||
# udpate Makefile
|
||||
sed < Makefile.in "
|
||||
/^CC *=/s#=.*#=$CC#
|
||||
/^CFLAGS *=/s#=.*#=$CFLAGS#
|
||||
/^CPP *=/s#=.*#=$CPP#
|
||||
/^LDSHARED *=/s#=.*#=$LDSHARED#
|
||||
/^LIBS *=/s#=.*#=$LIBS#
|
||||
/^SHAREDLIB *=/s#=.*#=$SHAREDLIB#
|
||||
/^SHAREDLIBV *=/s#=.*#=$SHAREDLIBV#
|
||||
/^SHAREDLIBM *=/s#=.*#=$SHAREDLIBM#
|
||||
/^AR *=/s#=.*#=$AR#
|
||||
/^RANLIB *=/s#=.*#=$RANLIB#
|
||||
/^EXE *=/s#=.*#=$EXE#
|
||||
/^prefix *=/s#=.*#=$prefix#
|
||||
/^exec_prefix *=/s#=.*#=$exec_prefix#
|
||||
/^libdir *=/s#=.*#=$libdir#
|
||||
/^includedir *=/s#=.*#=$includedir#
|
||||
/^mandir *=/s#=.*#=$mandir#
|
||||
/^LDFLAGS *=/s#=.*#=$LDFLAGS#
|
||||
" > Makefile
|
||||
|
|
@ -1,70 +0,0 @@
|
|||
All files under this contrib directory are UNSUPPORTED. There were
|
||||
provided by users of zlib and were not tested by the authors of zlib.
|
||||
Use at your own risk. Please contact the authors of the contributions
|
||||
for help about these, not the zlib authors. Thanks.
|
||||
|
||||
|
||||
ada/ by Dmitriy Anisimkov <anisimkov@yahoo.com>
|
||||
Support for Ada
|
||||
See http://zlib-ada.sourceforge.net/
|
||||
|
||||
asm586/
|
||||
asm686/ by Brian Raiter <breadbox@muppetlabs.com>
|
||||
asm code for Pentium and PPro/PII, using the AT&T (GNU as) syntax
|
||||
See http://www.muppetlabs.com/~breadbox/software/assembly.html
|
||||
|
||||
blast/ by Mark Adler <madler@alumni.caltech.edu>
|
||||
Decompressor for output of PKWare Data Compression Library (DCL)
|
||||
|
||||
delphi/ by Cosmin Truta <cosmint@cs.ubbcluj.ro>
|
||||
Support for Delphi and C++ Builder
|
||||
|
||||
gzappend/ by Mark Adler <madler@alumni.caltech.edu>
|
||||
append to a gzip file -- illustrates the use of Z_BLOCK
|
||||
|
||||
infback9/ by Mark Adler <madler@alumni.caltech.edu>
|
||||
Unsupported diffs to infback to decode the deflate64 format
|
||||
|
||||
inflate86/ by Chris Anderson <christop@charm.net>
|
||||
Tuned x86 gcc asm code to replace inflate_fast()
|
||||
|
||||
iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
|
||||
A C++ I/O streams interface to the zlib gz* functions
|
||||
|
||||
iostream2/ by Tyge Løvset <Tyge.Lovset@cmr.no>
|
||||
Another C++ I/O streams interface
|
||||
|
||||
iostream3/ by Ludwig Schwardt <schwardt@sun.ac.za>
|
||||
and Kevin Ruland <kevin@rodin.wustl.edu>
|
||||
Yet another C++ I/O streams interface
|
||||
|
||||
masm686/ by Dan Higdon <hdan@kinesoft.com>
|
||||
and Chuck Walbourn <chuckw@kinesoft.com>
|
||||
asm code for Pentium Pro/PII, using the MASM syntax
|
||||
|
||||
masmx86/ by Gilles Vollant <info@winimage.com>
|
||||
x86 asm code to replace longest_match() and inflate_fast(),
|
||||
for Visual C++ and MASM
|
||||
|
||||
minizip/ by Gilles Vollant <info@winimage.com>
|
||||
Mini zip and unzip based on zlib
|
||||
See http://www.winimage.com/zLibDll/unzip.html
|
||||
|
||||
pascal/ by Bob Dellaca <bobdl@xtra.co.nz> et al.
|
||||
Support for Pascal
|
||||
|
||||
puff/ by Mark Adler <madler@alumni.caltech.edu>
|
||||
Small, low memory usage inflate. Also serves to provide an
|
||||
unambiguous description of the deflate format.
|
||||
|
||||
testzlib/ by Gilles Vollant <info@winimage.com>
|
||||
Example of the use of zlib
|
||||
|
||||
untgz/ by "Pedro A. Aranda Guti\irrez" <paag@tid.es>
|
||||
A very simple tar.gz file extractor using zlib
|
||||
|
||||
visual-basic.txt by Carlos Rios <c_rios@sonda.cl>
|
||||
How to use compress(), uncompress() and the gz* functions from VB
|
||||
|
||||
vstudio/ by Gilles Vollant <info@winimage.com>
|
||||
Building zlib with Visual Studio .NET
|
||||
|
|
@ -1,153 +0,0 @@
|
|||
----------------------------------------------------------------
|
||||
-- ZLib for Ada thick binding. --
|
||||
-- --
|
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov --
|
||||
-- --
|
||||
-- Open source license information is in the zlib.ads file. --
|
||||
----------------------------------------------------------------
|
||||
-- Continuous test for ZLib multithreading. If the test is fail
|
||||
-- Wou should provide thread safe allocation routines for the Z_Stream.
|
||||
--
|
||||
-- $Id: mtest.adb,v 1.2 2003/08/12 12:11:05 vagul Exp $
|
||||
|
||||
with ZLib;
|
||||
with Ada.Streams;
|
||||
with Ada.Numerics.Discrete_Random;
|
||||
with Ada.Text_IO;
|
||||
with Ada.Exceptions;
|
||||
with Ada.Task_Identification;
|
||||
|
||||
procedure MTest is
|
||||
use Ada.Streams;
|
||||
use ZLib;
|
||||
|
||||
Stop : Boolean := False;
|
||||
|
||||
pragma Atomic (Stop);
|
||||
|
||||
subtype Visible_Symbols is Stream_Element range 16#20# .. 16#7E#;
|
||||
|
||||
package Random_Elements is
|
||||
new Ada.Numerics.Discrete_Random (Visible_Symbols);
|
||||
|
||||
task type Test_Task;
|
||||
|
||||
task body Test_Task is
|
||||
Buffer : Stream_Element_Array (1 .. 100_000);
|
||||
Gen : Random_Elements.Generator;
|
||||
|
||||
Buffer_First : Stream_Element_Offset;
|
||||
Compare_First : Stream_Element_Offset;
|
||||
|
||||
Deflate : Filter_Type;
|
||||
Inflate : Filter_Type;
|
||||
|
||||
procedure Further (Item : in Stream_Element_Array);
|
||||
|
||||
procedure Read_Buffer
|
||||
(Item : out Ada.Streams.Stream_Element_Array;
|
||||
Last : out Ada.Streams.Stream_Element_Offset);
|
||||
|
||||
-------------
|
||||
-- Further --
|
||||
-------------
|
||||
|
||||
procedure Further (Item : in Stream_Element_Array) is
|
||||
|
||||
procedure Compare (Item : in Stream_Element_Array);
|
||||
|
||||
-------------
|
||||
-- Compare --
|
||||
-------------
|
||||
|
||||
procedure Compare (Item : in Stream_Element_Array) is
|
||||
Next_First : Stream_Element_Offset := Compare_First + Item'Length;
|
||||
begin
|
||||
if Buffer (Compare_First .. Next_First - 1) /= Item then
|
||||
raise Program_Error;
|
||||
end if;
|
||||
|
||||
Compare_First := Next_First;
|
||||
end Compare;
|
||||
|
||||
procedure Compare_Write is new ZLib.Write (Write => Compare);
|
||||
begin
|
||||
Compare_Write (Inflate, Item, No_Flush);
|
||||
end Further;
|
||||
|
||||
-----------------
|
||||
-- Read_Buffer --
|
||||
-----------------
|
||||
|
||||
procedure Read_Buffer
|
||||
(Item : out Ada.Streams.Stream_Element_Array;
|
||||
Last : out Ada.Streams.Stream_Element_Offset)
|
||||
is
|
||||
Buff_Diff : Stream_Element_Offset := Buffer'Last - Buffer_First;
|
||||
Next_First : Stream_Element_Offset;
|
||||
begin
|
||||
if Item'Length <= Buff_Diff then
|
||||
Last := Item'Last;
|
||||
|
||||
Next_First := Buffer_First + Item'Length;
|
||||
|
||||
Item := Buffer (Buffer_First .. Next_First - 1);
|
||||
|
||||
Buffer_First := Next_First;
|
||||
else
|
||||
Last := Item'First + Buff_Diff;
|
||||
Item (Item'First .. Last) := Buffer (Buffer_First .. Buffer'Last);
|
||||
Buffer_First := Buffer'Last + 1;
|
||||
end if;
|
||||
end Read_Buffer;
|
||||
|
||||
procedure Translate is new Generic_Translate
|
||||
(Data_In => Read_Buffer,
|
||||
Data_Out => Further);
|
||||
|
||||
begin
|
||||
Random_Elements.Reset (Gen);
|
||||
|
||||
Buffer := (others => 20);
|
||||
|
||||
Main : loop
|
||||
for J in Buffer'Range loop
|
||||
Buffer (J) := Random_Elements.Random (Gen);
|
||||
|
||||
Deflate_Init (Deflate);
|
||||
Inflate_Init (Inflate);
|
||||
|
||||
Buffer_First := Buffer'First;
|
||||
Compare_First := Buffer'First;
|
||||
|
||||
Translate (Deflate);
|
||||
|
||||
if Compare_First /= Buffer'Last + 1 then
|
||||
raise Program_Error;
|
||||
end if;
|
||||
|
||||
Ada.Text_IO.Put_Line
|
||||
(Ada.Task_Identification.Image
|
||||
(Ada.Task_Identification.Current_Task)
|
||||
& Stream_Element_Offset'Image (J)
|
||||
& ZLib.Count'Image (Total_Out (Deflate)));
|
||||
|
||||
Close (Deflate);
|
||||
Close (Inflate);
|
||||
|
||||
exit Main when Stop;
|
||||
end loop;
|
||||
end loop Main;
|
||||
exception
|
||||
when E : others =>
|
||||
Ada.Text_IO.Put_Line (Ada.Exceptions.Exception_Information (E));
|
||||
Stop := True;
|
||||
end Test_Task;
|
||||
|
||||
Test : array (1 .. 4) of Test_Task;
|
||||
|
||||
pragma Unreferenced (Test);
|
||||
|
||||
begin
|
||||
null;
|
||||
end MTest;
|
||||
|
|
@ -1,151 +0,0 @@
|
|||
----------------------------------------------------------------
|
||||
-- ZLib for Ada thick binding. --
|
||||
-- --
|
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov --
|
||||
-- --
|
||||
-- Open source license information is in the zlib.ads file. --
|
||||
----------------------------------------------------------------
|
||||
|
||||
-- $Id: read.adb,v 1.7 2003/08/12 12:12:35 vagul Exp $
|
||||
|
||||
-- Test/demo program for the generic read interface.
|
||||
|
||||
with Ada.Numerics.Discrete_Random;
|
||||
with Ada.Streams;
|
||||
with Ada.Text_IO;
|
||||
|
||||
with ZLib;
|
||||
|
||||
procedure Read is
|
||||
|
||||
use Ada.Streams;
|
||||
|
||||
------------------------------------
|
||||
-- Test configuration parameters --
|
||||
------------------------------------
|
||||
|
||||
File_Size : Stream_Element_Offset := 100_000;
|
||||
|
||||
Continuous : constant Boolean := False;
|
||||
-- If this constant is True, the test would be repeated again and again,
|
||||
-- with increment File_Size for every iteration.
|
||||
|
||||
Header : constant ZLib.Header_Type := ZLib.Default;
|
||||
-- Do not use Header other than Default in ZLib versions 1.1.4 and older.
|
||||
|
||||
Init_Random : constant := 8;
|
||||
-- We are using the same random sequence, in case of we catch bug,
|
||||
-- so we would be able to reproduce it.
|
||||
|
||||
-- End --
|
||||
|
||||
Pack_Size : Stream_Element_Offset;
|
||||
Offset : Stream_Element_Offset;
|
||||
|
||||
Filter : ZLib.Filter_Type;
|
||||
|
||||
subtype Visible_Symbols
|
||||
is Stream_Element range 16#20# .. 16#7E#;
|
||||
|
||||
package Random_Elements is new
|
||||
Ada.Numerics.Discrete_Random (Visible_Symbols);
|
||||
|
||||
Gen : Random_Elements.Generator;
|
||||
Period : constant Stream_Element_Offset := 200;
|
||||
-- Period constant variable for random generator not to be very random.
|
||||
-- Bigger period, harder random.
|
||||
|
||||
Read_Buffer : Stream_Element_Array (1 .. 2048);
|
||||
Read_First : Stream_Element_Offset;
|
||||
Read_Last : Stream_Element_Offset;
|
||||
|
||||
procedure Reset;
|
||||
|
||||
procedure Read
|
||||
(Item : out Stream_Element_Array;
|
||||
Last : out Stream_Element_Offset);
|
||||
-- this procedure is for generic instantiation of
|
||||
-- ZLib.Read
|
||||
-- reading data from the File_In.
|
||||
|
||||
procedure Read is new ZLib.Read (Read, Read_Buffer, Read_First, Read_Last);
|
||||
|
||||
----------
|
||||
-- Read --
|
||||
----------
|
||||
|
||||
procedure Read
|
||||
(Item : out Stream_Element_Array;
|
||||
Last : out Stream_Element_Offset) is
|
||||
begin
|
||||
Last := Stream_Element_Offset'Min
|
||||
(Item'Last,
|
||||
Item'First + File_Size - Offset);
|
||||
|
||||
for J in Item'First .. Last loop
|
||||
if J < Item'First + Period then
|
||||
Item (J) := Random_Elements.Random (Gen);
|
||||
else
|
||||
Item (J) := Item (J - Period);
|
||||
end if;
|
||||
|
||||
Offset := Offset + 1;
|
||||
end loop;
|
||||
end Read;
|
||||
|
||||
-----------
|
||||
-- Reset --
|
||||
-----------
|
||||
|
||||
procedure Reset is
|
||||
begin
|
||||
Random_Elements.Reset (Gen, Init_Random);
|
||||
Pack_Size := 0;
|
||||
Offset := 1;
|
||||
Read_First := Read_Buffer'Last + 1;
|
||||
end Reset;
|
||||
|
||||
begin
|
||||
Ada.Text_IO.Put_Line ("ZLib " & ZLib.Version);
|
||||
|
||||
loop
|
||||
for Level in ZLib.Compression_Level'Range loop
|
||||
|
||||
Ada.Text_IO.Put ("Level ="
|
||||
& ZLib.Compression_Level'Image (Level));
|
||||
|
||||
-- Deflate using generic instantiation.
|
||||
|
||||
ZLib.Deflate_Init
|
||||
(Filter,
|
||||
Level,
|
||||
Header => Header);
|
||||
|
||||
Reset;
|
||||
|
||||
Ada.Text_IO.Put
|
||||
(Stream_Element_Offset'Image (File_Size) & " ->");
|
||||
|
||||
loop
|
||||
declare
|
||||
Buffer : Stream_Element_Array (1 .. 1024);
|
||||
Last : Stream_Element_Offset;
|
||||
begin
|
||||
Read (Filter, Buffer, Last);
|
||||
|
||||
Pack_Size := Pack_Size + Last - Buffer'First + 1;
|
||||
|
||||
exit when Last < Buffer'Last;
|
||||
end;
|
||||
end loop;
|
||||
|
||||
Ada.Text_IO.Put_Line (Stream_Element_Offset'Image (Pack_Size));
|
||||
|
||||
ZLib.Close (Filter);
|
||||
end loop;
|
||||
|
||||
exit when not Continuous;
|
||||
|
||||
File_Size := File_Size + 1;
|
||||
end loop;
|
||||
end Read;
|
||||
|
|
@ -1,52 +0,0 @@
|
|||
|
||||
ZLib for Ada thick binding (ZLib.Ada)
|
||||
Release 1.2
|
||||
|
||||
ZLib.Ada is a thick binding interface to the popular ZLib data
|
||||
compression library, available at http://www.gzip.org/zlib/.
|
||||
It provides Ada-style access to the ZLib C library.
|
||||
|
||||
|
||||
Here are the main changes since ZLib.Ada 1.1:
|
||||
|
||||
- The default header type has a name "Default" now. Auto is used only for
|
||||
automatic GZip/ZLib header detection.
|
||||
|
||||
- Added test for multitasking mtest.adb.
|
||||
|
||||
- Added GNAT project file zlib.gpr.
|
||||
|
||||
|
||||
How to build ZLib.Ada under GNAT
|
||||
|
||||
You should have the ZLib library already build on your computer, before
|
||||
building ZLib.Ada. Make the directory of ZLib.Ada sources current and
|
||||
issue the command:
|
||||
|
||||
gnatmake test -largs -L<directory where libz.a is> -lz
|
||||
|
||||
Or use the GNAT project file build for GNAT 3.15 or later:
|
||||
|
||||
gnatmake -Pzlib.gpr -L<directory where libz.a is>
|
||||
|
||||
|
||||
How to build ZLib.Ada under Aonix ObjectAda for Win32 7.2.2
|
||||
|
||||
1. Make a project with all *.ads and *.adb files from the distribution.
|
||||
2. Build the libz.a library from the ZLib C sources.
|
||||
3. Rename libz.a to z.lib.
|
||||
4. Add the library z.lib to the project.
|
||||
5. Add the libc.lib library from the ObjectAda distribution to the project.
|
||||
6. Build the executable using test.adb as a main procedure.
|
||||
|
||||
|
||||
How to use ZLib.Ada
|
||||
|
||||
The source files test.adb and read.adb are small demo programs that show
|
||||
the main functionality of ZLib.Ada.
|
||||
|
||||
The routines from the package specifications are commented.
|
||||
|
||||
|
||||
Homepage: http://zlib-ada.sourceforge.net/
|
||||
Author: Dmitriy Anisimkov <anisimkov@yahoo.com>
|
||||
|
|
@ -1,463 +0,0 @@
|
|||
----------------------------------------------------------------
|
||||
-- ZLib for Ada thick binding. --
|
||||
-- --
|
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov --
|
||||
-- --
|
||||
-- Open source license information is in the zlib.ads file. --
|
||||
----------------------------------------------------------------
|
||||
|
||||
-- $Id: test.adb,v 1.17 2003/08/12 12:13:30 vagul Exp $
|
||||
|
||||
-- The program has a few aims.
|
||||
-- 1. Test ZLib.Ada95 thick binding functionality.
|
||||
-- 2. Show the example of use main functionality of the ZLib.Ada95 binding.
|
||||
-- 3. Build this program automatically compile all ZLib.Ada95 packages under
|
||||
-- GNAT Ada95 compiler.
|
||||
|
||||
with ZLib.Streams;
|
||||
with Ada.Streams.Stream_IO;
|
||||
with Ada.Numerics.Discrete_Random;
|
||||
|
||||
with Ada.Text_IO;
|
||||
|
||||
with Ada.Calendar;
|
||||
|
||||
procedure Test is
|
||||
|
||||
use Ada.Streams;
|
||||
use Stream_IO;
|
||||
|
||||
------------------------------------
|
||||
-- Test configuration parameters --
|
||||
------------------------------------
|
||||
|
||||
File_Size : Count := 100_000;
|
||||
Continuous : constant Boolean := False;
|
||||
|
||||
Header : constant ZLib.Header_Type := ZLib.Default;
|
||||
-- ZLib.None;
|
||||
-- ZLib.Auto;
|
||||
-- ZLib.GZip;
|
||||
-- Do not use Header other then Default in ZLib versions 1.1.4
|
||||
-- and older.
|
||||
|
||||
Strategy : constant ZLib.Strategy_Type := ZLib.Default_Strategy;
|
||||
Init_Random : constant := 10;
|
||||
|
||||
-- End --
|
||||
|
||||
In_File_Name : constant String := "testzlib.in";
|
||||
-- Name of the input file
|
||||
|
||||
Z_File_Name : constant String := "testzlib.zlb";
|
||||
-- Name of the compressed file.
|
||||
|
||||
Out_File_Name : constant String := "testzlib.out";
|
||||
-- Name of the decompressed file.
|
||||
|
||||
File_In : File_Type;
|
||||
File_Out : File_Type;
|
||||
File_Back : File_Type;
|
||||
File_Z : ZLib.Streams.Stream_Type;
|
||||
|
||||
Filter : ZLib.Filter_Type;
|
||||
|
||||
Time_Stamp : Ada.Calendar.Time;
|
||||
|
||||
procedure Generate_File;
|
||||
-- Generate file of spetsified size with some random data.
|
||||
-- The random data is repeatable, for the good compression.
|
||||
|
||||
procedure Compare_Streams
|
||||
(Left, Right : in out Root_Stream_Type'Class);
|
||||
-- The procedure compearing data in 2 streams.
|
||||
-- It is for compare data before and after compression/decompression.
|
||||
|
||||
procedure Compare_Files (Left, Right : String);
|
||||
-- Compare files. Based on the Compare_Streams.
|
||||
|
||||
procedure Copy_Streams
|
||||
(Source, Target : in out Root_Stream_Type'Class;
|
||||
Buffer_Size : in Stream_Element_Offset := 1024);
|
||||
-- Copying data from one stream to another. It is for test stream
|
||||
-- interface of the library.
|
||||
|
||||
procedure Data_In
|
||||
(Item : out Stream_Element_Array;
|
||||
Last : out Stream_Element_Offset);
|
||||
-- this procedure is for generic instantiation of
|
||||
-- ZLib.Generic_Translate.
|
||||
-- reading data from the File_In.
|
||||
|
||||
procedure Data_Out (Item : in Stream_Element_Array);
|
||||
-- this procedure is for generic instantiation of
|
||||
-- ZLib.Generic_Translate.
|
||||
-- writing data to the File_Out.
|
||||
|
||||
procedure Stamp;
|
||||
-- Store the timestamp to the local variable.
|
||||
|
||||
procedure Print_Statistic (Msg : String; Data_Size : ZLib.Count);
|
||||
-- Print the time statistic with the message.
|
||||
|
||||
procedure Translate is new ZLib.Generic_Translate
|
||||
(Data_In => Data_In,
|
||||
Data_Out => Data_Out);
|
||||
-- This procedure is moving data from File_In to File_Out
|
||||
-- with compression or decompression, depend on initialization of
|
||||
-- Filter parameter.
|
||||
|
||||
-------------------
|
||||
-- Compare_Files --
|
||||
-------------------
|
||||
|
||||
procedure Compare_Files (Left, Right : String) is
|
||||
Left_File, Right_File : File_Type;
|
||||
begin
|
||||
Open (Left_File, In_File, Left);
|
||||
Open (Right_File, In_File, Right);
|
||||
Compare_Streams (Stream (Left_File).all, Stream (Right_File).all);
|
||||
Close (Left_File);
|
||||
Close (Right_File);
|
||||
end Compare_Files;
|
||||
|
||||
---------------------
|
||||
-- Compare_Streams --
|
||||
---------------------
|
||||
|
||||
procedure Compare_Streams
|
||||
(Left, Right : in out Ada.Streams.Root_Stream_Type'Class)
|
||||
is
|
||||
Left_Buffer, Right_Buffer : Stream_Element_Array (0 .. 16#FFF#);
|
||||
Left_Last, Right_Last : Stream_Element_Offset;
|
||||
begin
|
||||
loop
|
||||
Read (Left, Left_Buffer, Left_Last);
|
||||
Read (Right, Right_Buffer, Right_Last);
|
||||
|
||||
if Left_Last /= Right_Last then
|
||||
Ada.Text_IO.Put_Line ("Compare error :"
|
||||
& Stream_Element_Offset'Image (Left_Last)
|
||||
& " /= "
|
||||
& Stream_Element_Offset'Image (Right_Last));
|
||||
|
||||
raise Constraint_Error;
|
||||
|
||||
elsif Left_Buffer (0 .. Left_Last)
|
||||
/= Right_Buffer (0 .. Right_Last)
|
||||
then
|
||||
Ada.Text_IO.Put_Line ("ERROR: IN and OUT files is not equal.");
|
||||
raise Constraint_Error;
|
||||
|
||||
end if;
|
||||
|
||||
exit when Left_Last < Left_Buffer'Last;
|
||||
end loop;
|
||||
end Compare_Streams;
|
||||
|
||||
------------------
|
||||
-- Copy_Streams --
|
||||
------------------
|
||||
|
||||
procedure Copy_Streams
|
||||
(Source, Target : in out Ada.Streams.Root_Stream_Type'Class;
|
||||
Buffer_Size : in Stream_Element_Offset := 1024)
|
||||
is
|
||||
Buffer : Stream_Element_Array (1 .. Buffer_Size);
|
||||
Last : Stream_Element_Offset;
|
||||
begin
|
||||
loop
|
||||
Read (Source, Buffer, Last);
|
||||
Write (Target, Buffer (1 .. Last));
|
||||
|
||||
exit when Last < Buffer'Last;
|
||||
end loop;
|
||||
end Copy_Streams;
|
||||
|
||||
-------------
|
||||
-- Data_In --
|
||||
-------------
|
||||
|
||||
procedure Data_In
|
||||
(Item : out Stream_Element_Array;
|
||||
Last : out Stream_Element_Offset) is
|
||||
begin
|
||||
Read (File_In, Item, Last);
|
||||
end Data_In;
|
||||
|
||||
--------------
|
||||
-- Data_Out --
|
||||
--------------
|
||||
|
||||
procedure Data_Out (Item : in Stream_Element_Array) is
|
||||
begin
|
||||
Write (File_Out, Item);
|
||||
end Data_Out;
|
||||
|
||||
-------------------
|
||||
-- Generate_File --
|
||||
-------------------
|
||||
|
||||
procedure Generate_File is
|
||||
subtype Visible_Symbols is Stream_Element range 16#20# .. 16#7E#;
|
||||
|
||||
package Random_Elements is
|
||||
new Ada.Numerics.Discrete_Random (Visible_Symbols);
|
||||
|
||||
Gen : Random_Elements.Generator;
|
||||
Buffer : Stream_Element_Array := (1 .. 77 => 16#20#) & 10;
|
||||
|
||||
Buffer_Count : constant Count := File_Size / Buffer'Length;
|
||||
-- Number of same buffers in the packet.
|
||||
|
||||
Density : constant Count := 30; -- from 0 to Buffer'Length - 2;
|
||||
|
||||
procedure Fill_Buffer (J, D : in Count);
|
||||
-- Change the part of the buffer.
|
||||
|
||||
-----------------
|
||||
-- Fill_Buffer --
|
||||
-----------------
|
||||
|
||||
procedure Fill_Buffer (J, D : in Count) is
|
||||
begin
|
||||
for K in 0 .. D loop
|
||||
Buffer
|
||||
(Stream_Element_Offset ((J + K) mod (Buffer'Length - 1) + 1))
|
||||
:= Random_Elements.Random (Gen);
|
||||
|
||||
end loop;
|
||||
end Fill_Buffer;
|
||||
|
||||
begin
|
||||
Random_Elements.Reset (Gen, Init_Random);
|
||||
|
||||
Create (File_In, Out_File, In_File_Name);
|
||||
|
||||
Fill_Buffer (1, Buffer'Length - 2);
|
||||
|
||||
for J in 1 .. Buffer_Count loop
|
||||
Write (File_In, Buffer);
|
||||
|
||||
Fill_Buffer (J, Density);
|
||||
end loop;
|
||||
|
||||
-- fill remain size.
|
||||
|
||||
Write
|
||||
(File_In,
|
||||
Buffer
|
||||
(1 .. Stream_Element_Offset
|
||||
(File_Size - Buffer'Length * Buffer_Count)));
|
||||
|
||||
Flush (File_In);
|
||||
Close (File_In);
|
||||
end Generate_File;
|
||||
|
||||
---------------------
|
||||
-- Print_Statistic --
|
||||
---------------------
|
||||
|
||||
procedure Print_Statistic (Msg : String; Data_Size : ZLib.Count) is
|
||||
use Ada.Calendar;
|
||||
use Ada.Text_IO;
|
||||
|
||||
package Count_IO is new Integer_IO (ZLib.Count);
|
||||
|
||||
Curr_Dur : Duration := Clock - Time_Stamp;
|
||||
begin
|
||||
Put (Msg);
|
||||
|
||||
Set_Col (20);
|
||||
Ada.Text_IO.Put ("size =");
|
||||
|
||||
Count_IO.Put
|
||||
(Data_Size,
|
||||
Width => Stream_IO.Count'Image (File_Size)'Length);
|
||||
|
||||
Put_Line (" duration =" & Duration'Image (Curr_Dur));
|
||||
end Print_Statistic;
|
||||
|
||||
-----------
|
||||
-- Stamp --
|
||||
-----------
|
||||
|
||||
procedure Stamp is
|
||||
begin
|
||||
Time_Stamp := Ada.Calendar.Clock;
|
||||
end Stamp;
|
||||
|
||||
begin
|
||||
Ada.Text_IO.Put_Line ("ZLib " & ZLib.Version);
|
||||
|
||||
loop
|
||||
Generate_File;
|
||||
|
||||
for Level in ZLib.Compression_Level'Range loop
|
||||
|
||||
Ada.Text_IO.Put_Line ("Level ="
|
||||
& ZLib.Compression_Level'Image (Level));
|
||||
|
||||
-- Test generic interface.
|
||||
Open (File_In, In_File, In_File_Name);
|
||||
Create (File_Out, Out_File, Z_File_Name);
|
||||
|
||||
Stamp;
|
||||
|
||||
-- Deflate using generic instantiation.
|
||||
|
||||
ZLib.Deflate_Init
|
||||
(Filter => Filter,
|
||||
Level => Level,
|
||||
Strategy => Strategy,
|
||||
Header => Header);
|
||||
|
||||
Translate (Filter);
|
||||
Print_Statistic ("Generic compress", ZLib.Total_Out (Filter));
|
||||
ZLib.Close (Filter);
|
||||
|
||||
Close (File_In);
|
||||
Close (File_Out);
|
||||
|
||||
Open (File_In, In_File, Z_File_Name);
|
||||
Create (File_Out, Out_File, Out_File_Name);
|
||||
|
||||
Stamp;
|
||||
|
||||
-- Inflate using generic instantiation.
|
||||
|
||||
ZLib.Inflate_Init (Filter, Header => Header);
|
||||
|
||||
Translate (Filter);
|
||||
Print_Statistic ("Generic decompress", ZLib.Total_Out (Filter));
|
||||
|
||||
ZLib.Close (Filter);
|
||||
|
||||
Close (File_In);
|
||||
Close (File_Out);
|
||||
|
||||
Compare_Files (In_File_Name, Out_File_Name);
|
||||
|
||||
-- Test stream interface.
|
||||
|
||||
-- Compress to the back stream.
|
||||
|
||||
Open (File_In, In_File, In_File_Name);
|
||||
Create (File_Back, Out_File, Z_File_Name);
|
||||
|
||||
Stamp;
|
||||
|
||||
ZLib.Streams.Create
|
||||
(Stream => File_Z,
|
||||
Mode => ZLib.Streams.Out_Stream,
|
||||
Back => ZLib.Streams.Stream_Access
|
||||
(Stream (File_Back)),
|
||||
Back_Compressed => True,
|
||||
Level => Level,
|
||||
Strategy => Strategy,
|
||||
Header => Header);
|
||||
|
||||
Copy_Streams
|
||||
(Source => Stream (File_In).all,
|
||||
Target => File_Z);
|
||||
|
||||
-- Flushing internal buffers to the back stream.
|
||||
|
||||
ZLib.Streams.Flush (File_Z, ZLib.Finish);
|
||||
|
||||
Print_Statistic ("Write compress",
|
||||
ZLib.Streams.Write_Total_Out (File_Z));
|
||||
|
||||
ZLib.Streams.Close (File_Z);
|
||||
|
||||
Close (File_In);
|
||||
Close (File_Back);
|
||||
|
||||
-- Compare reading from original file and from
|
||||
-- decompression stream.
|
||||
|
||||
Open (File_In, In_File, In_File_Name);
|
||||
Open (File_Back, In_File, Z_File_Name);
|
||||
|
||||
ZLib.Streams.Create
|
||||
(Stream => File_Z,
|
||||
Mode => ZLib.Streams.In_Stream,
|
||||
Back => ZLib.Streams.Stream_Access
|
||||
(Stream (File_Back)),
|
||||
Back_Compressed => True,
|
||||
Header => Header);
|
||||
|
||||
Stamp;
|
||||
Compare_Streams (Stream (File_In).all, File_Z);
|
||||
|
||||
Print_Statistic ("Read decompress",
|
||||
ZLib.Streams.Read_Total_Out (File_Z));
|
||||
|
||||
ZLib.Streams.Close (File_Z);
|
||||
Close (File_In);
|
||||
Close (File_Back);
|
||||
|
||||
-- Compress by reading from compression stream.
|
||||
|
||||
Open (File_Back, In_File, In_File_Name);
|
||||
Create (File_Out, Out_File, Z_File_Name);
|
||||
|
||||
ZLib.Streams.Create
|
||||
(Stream => File_Z,
|
||||
Mode => ZLib.Streams.In_Stream,
|
||||
Back => ZLib.Streams.Stream_Access
|
||||
(Stream (File_Back)),
|
||||
Back_Compressed => False,
|
||||
Level => Level,
|
||||
Strategy => Strategy,
|
||||
Header => Header);
|
||||
|
||||
Stamp;
|
||||
Copy_Streams
|
||||
(Source => File_Z,
|
||||
Target => Stream (File_Out).all);
|
||||
|
||||
Print_Statistic ("Read compress",
|
||||
ZLib.Streams.Read_Total_Out (File_Z));
|
||||
|
||||
ZLib.Streams.Close (File_Z);
|
||||
|
||||
Close (File_Out);
|
||||
Close (File_Back);
|
||||
|
||||
-- Decompress to decompression stream.
|
||||
|
||||
Open (File_In, In_File, Z_File_Name);
|
||||
Create (File_Back, Out_File, Out_File_Name);
|
||||
|
||||
ZLib.Streams.Create
|
||||
(Stream => File_Z,
|
||||
Mode => ZLib.Streams.Out_Stream,
|
||||
Back => ZLib.Streams.Stream_Access
|
||||
(Stream (File_Back)),
|
||||
Back_Compressed => False,
|
||||
Header => Header);
|
||||
|
||||
Stamp;
|
||||
|
||||
Copy_Streams
|
||||
(Source => Stream (File_In).all,
|
||||
Target => File_Z);
|
||||
|
||||
Print_Statistic ("Write decompress",
|
||||
ZLib.Streams.Write_Total_Out (File_Z));
|
||||
|
||||
ZLib.Streams.Close (File_Z);
|
||||
Close (File_In);
|
||||
Close (File_Back);
|
||||
|
||||
Compare_Files (In_File_Name, Out_File_Name);
|
||||
end loop;
|
||||
|
||||
Ada.Text_IO.Put_Line (Count'Image (File_Size) & " Ok.");
|
||||
|
||||
exit when not Continuous;
|
||||
|
||||
File_Size := File_Size + 1;
|
||||
end loop;
|
||||
end Test;
|
||||
|
|
@ -1,215 +0,0 @@
|
|||
----------------------------------------------------------------
|
||||
-- ZLib for Ada thick binding. --
|
||||
-- --
|
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov --
|
||||
-- --
|
||||
-- Open source license information is in the zlib.ads file. --
|
||||
----------------------------------------------------------------
|
||||
|
||||
-- $Id: zlib-streams.adb,v 1.9 2003/08/12 13:15:31 vagul Exp $
|
||||
|
||||
with Ada.Unchecked_Deallocation;
|
||||
|
||||
package body ZLib.Streams is
|
||||
|
||||
-----------
|
||||
-- Close --
|
||||
-----------
|
||||
|
||||
procedure Close (Stream : in out Stream_Type) is
|
||||
procedure Free is new Ada.Unchecked_Deallocation
|
||||
(Stream_Element_Array, Buffer_Access);
|
||||
begin
|
||||
if Stream.Mode = Out_Stream or Stream.Mode = Duplex then
|
||||
-- We should flush the data written by the writer.
|
||||
|
||||
Flush (Stream, Finish);
|
||||
|
||||
Close (Stream.Writer);
|
||||
end if;
|
||||
|
||||
if Stream.Mode = In_Stream or Stream.Mode = Duplex then
|
||||
Close (Stream.Reader);
|
||||
Free (Stream.Buffer);
|
||||
end if;
|
||||
end Close;
|
||||
|
||||
------------
|
||||
-- Create --
|
||||
------------
|
||||
|
||||
procedure Create
|
||||
(Stream : out Stream_Type;
|
||||
Mode : in Stream_Mode;
|
||||
Back : in Stream_Access;
|
||||
Back_Compressed : in Boolean;
|
||||
Level : in Compression_Level := Default_Compression;
|
||||
Strategy : in Strategy_Type := Default_Strategy;
|
||||
Header : in Header_Type := Default;
|
||||
Read_Buffer_Size : in Ada.Streams.Stream_Element_Offset
|
||||
:= Default_Buffer_Size;
|
||||
Write_Buffer_Size : in Ada.Streams.Stream_Element_Offset
|
||||
:= Default_Buffer_Size)
|
||||
is
|
||||
|
||||
subtype Buffer_Subtype is Stream_Element_Array (1 .. Read_Buffer_Size);
|
||||
|
||||
procedure Init_Filter
|
||||
(Filter : in out Filter_Type;
|
||||
Compress : in Boolean);
|
||||
|
||||
-----------------
|
||||
-- Init_Filter --
|
||||
-----------------
|
||||
|
||||
procedure Init_Filter
|
||||
(Filter : in out Filter_Type;
|
||||
Compress : in Boolean) is
|
||||
begin
|
||||
if Compress then
|
||||
Deflate_Init
|
||||
(Filter, Level, Strategy, Header => Header);
|
||||
else
|
||||
Inflate_Init (Filter, Header => Header);
|
||||
end if;
|
||||
end Init_Filter;
|
||||
|
||||
begin
|
||||
Stream.Back := Back;
|
||||
Stream.Mode := Mode;
|
||||
|
||||
if Mode = Out_Stream or Mode = Duplex then
|
||||
Init_Filter (Stream.Writer, Back_Compressed);
|
||||
Stream.Buffer_Size := Write_Buffer_Size;
|
||||
else
|
||||
Stream.Buffer_Size := 0;
|
||||
end if;
|
||||
|
||||
if Mode = In_Stream or Mode = Duplex then
|
||||
Init_Filter (Stream.Reader, not Back_Compressed);
|
||||
|
||||
Stream.Buffer := new Buffer_Subtype;
|
||||
Stream.Rest_First := Stream.Buffer'Last + 1;
|
||||
end if;
|
||||
end Create;
|
||||
|
||||
-----------
|
||||
-- Flush --
|
||||
-----------
|
||||
|
||||
procedure Flush
|
||||
(Stream : in out Stream_Type;
|
||||
Mode : in Flush_Mode := Sync_Flush)
|
||||
is
|
||||
Buffer : Stream_Element_Array (1 .. Stream.Buffer_Size);
|
||||
Last : Stream_Element_Offset;
|
||||
begin
|
||||
loop
|
||||
Flush (Stream.Writer, Buffer, Last, Mode);
|
||||
|
||||
Ada.Streams.Write (Stream.Back.all, Buffer (1 .. Last));
|
||||
|
||||
exit when Last < Buffer'Last;
|
||||
end loop;
|
||||
end Flush;
|
||||
|
||||
----------
|
||||
-- Read --
|
||||
----------
|
||||
|
||||
procedure Read
|
||||
(Stream : in out Stream_Type;
|
||||
Item : out Stream_Element_Array;
|
||||
Last : out Stream_Element_Offset)
|
||||
is
|
||||
|
||||
procedure Read
|
||||
(Item : out Stream_Element_Array;
|
||||
Last : out Stream_Element_Offset);
|
||||
|
||||
----------
|
||||
-- Read --
|
||||
----------
|
||||
|
||||
procedure Read
|
||||
(Item : out Stream_Element_Array;
|
||||
Last : out Stream_Element_Offset) is
|
||||
begin
|
||||
Ada.Streams.Read (Stream.Back.all, Item, Last);
|
||||
end Read;
|
||||
|
||||
procedure Read is new ZLib.Read
|
||||
(Read => Read,
|
||||
Buffer => Stream.Buffer.all,
|
||||
Rest_First => Stream.Rest_First,
|
||||
Rest_Last => Stream.Rest_Last);
|
||||
|
||||
begin
|
||||
Read (Stream.Reader, Item, Last);
|
||||
end Read;
|
||||
|
||||
-------------------
|
||||
-- Read_Total_In --
|
||||
-------------------
|
||||
|
||||
function Read_Total_In (Stream : in Stream_Type) return Count is
|
||||
begin
|
||||
return Total_In (Stream.Reader);
|
||||
end Read_Total_In;
|
||||
|
||||
--------------------
|
||||
-- Read_Total_Out --
|
||||
--------------------
|
||||
|
||||
function Read_Total_Out (Stream : in Stream_Type) return Count is
|
||||
begin
|
||||
return Total_Out (Stream.Reader);
|
||||
end Read_Total_Out;
|
||||
|
||||
-----------
|
||||
-- Write --
|
||||
-----------
|
||||
|
||||
procedure Write
|
||||
(Stream : in out Stream_Type;
|
||||
Item : in Stream_Element_Array)
|
||||
is
|
||||
|
||||
procedure Write (Item : in Stream_Element_Array);
|
||||
|
||||
-----------
|
||||
-- Write --
|
||||
-----------
|
||||
|
||||
procedure Write (Item : in Stream_Element_Array) is
|
||||
begin
|
||||
Ada.Streams.Write (Stream.Back.all, Item);
|
||||
end Write;
|
||||
|
||||
procedure Write is new ZLib.Write
|
||||
(Write => Write,
|
||||
Buffer_Size => Stream.Buffer_Size);
|
||||
|
||||
begin
|
||||
Write (Stream.Writer, Item, No_Flush);
|
||||
end Write;
|
||||
|
||||
--------------------
|
||||
-- Write_Total_In --
|
||||
--------------------
|
||||
|
||||
function Write_Total_In (Stream : in Stream_Type) return Count is
|
||||
begin
|
||||
return Total_In (Stream.Writer);
|
||||
end Write_Total_In;
|
||||
|
||||
---------------------
|
||||
-- Write_Total_Out --
|
||||
---------------------
|
||||
|
||||
function Write_Total_Out (Stream : in Stream_Type) return Count is
|
||||
begin
|
||||
return Total_Out (Stream.Writer);
|
||||
end Write_Total_Out;
|
||||
|
||||
end ZLib.Streams;
|
||||
|
|
@ -1,112 +0,0 @@
|
|||
----------------------------------------------------------------
|
||||
-- ZLib for Ada thick binding. --
|
||||
-- --
|
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov --
|
||||
-- --
|
||||
-- Open source license information is in the zlib.ads file. --
|
||||
----------------------------------------------------------------
|
||||
|
||||
-- $Id: zlib-streams.ads,v 1.11 2003/08/12 13:15:31 vagul Exp $
|
||||
|
||||
package ZLib.Streams is
|
||||
|
||||
type Stream_Mode is (In_Stream, Out_Stream, Duplex);
|
||||
|
||||
type Stream_Access is access all Ada.Streams.Root_Stream_Type'Class;
|
||||
|
||||
type Stream_Type is
|
||||
new Ada.Streams.Root_Stream_Type with private;
|
||||
|
||||
procedure Read
|
||||
(Stream : in out Stream_Type;
|
||||
Item : out Ada.Streams.Stream_Element_Array;
|
||||
Last : out Ada.Streams.Stream_Element_Offset);
|
||||
|
||||
procedure Write
|
||||
(Stream : in out Stream_Type;
|
||||
Item : in Ada.Streams.Stream_Element_Array);
|
||||
|
||||
procedure Flush
|
||||
(Stream : in out Stream_Type;
|
||||
Mode : in Flush_Mode := Sync_Flush);
|
||||
-- Flush the written data to the back stream,
|
||||
-- all data placed to the compressor is flushing to the Back stream.
|
||||
-- Should not be used untill necessary, becouse it is decreasing
|
||||
-- compression.
|
||||
|
||||
function Read_Total_In (Stream : in Stream_Type) return Count;
|
||||
pragma Inline (Read_Total_In);
|
||||
-- Return total number of bytes read from back stream so far.
|
||||
|
||||
function Read_Total_Out (Stream : in Stream_Type) return Count;
|
||||
pragma Inline (Read_Total_Out);
|
||||
-- Return total number of bytes read so far.
|
||||
|
||||
function Write_Total_In (Stream : in Stream_Type) return Count;
|
||||
pragma Inline (Write_Total_In);
|
||||
-- Return total number of bytes written so far.
|
||||
|
||||
function Write_Total_Out (Stream : in Stream_Type) return Count;
|
||||
pragma Inline (Write_Total_Out);
|
||||
-- Return total number of bytes written to the back stream.
|
||||
|
||||
procedure Create
|
||||
(Stream : out Stream_Type;
|
||||
Mode : in Stream_Mode;
|
||||
Back : in Stream_Access;
|
||||
Back_Compressed : in Boolean;
|
||||
Level : in Compression_Level := Default_Compression;
|
||||
Strategy : in Strategy_Type := Default_Strategy;
|
||||
Header : in Header_Type := Default;
|
||||
Read_Buffer_Size : in Ada.Streams.Stream_Element_Offset
|
||||
:= Default_Buffer_Size;
|
||||
Write_Buffer_Size : in Ada.Streams.Stream_Element_Offset
|
||||
:= Default_Buffer_Size);
|
||||
-- Create the Comression/Decompression stream.
|
||||
-- If mode is In_Stream then Write operation is disabled.
|
||||
-- If mode is Out_Stream then Read operation is disabled.
|
||||
|
||||
-- If Back_Compressed is true then
|
||||
-- Data written to the Stream is compressing to the Back stream
|
||||
-- and data read from the Stream is decompressed data from the Back stream.
|
||||
|
||||
-- If Back_Compressed is false then
|
||||
-- Data written to the Stream is decompressing to the Back stream
|
||||
-- and data read from the Stream is compressed data from the Back stream.
|
||||
|
||||
-- !!! When the Need_Header is False ZLib-Ada is using undocumented
|
||||
-- ZLib 1.1.4 functionality to do not create/wait for ZLib headers.
|
||||
|
||||
procedure Close (Stream : in out Stream_Type);
|
||||
|
||||
private
|
||||
|
||||
use Ada.Streams;
|
||||
|
||||
type Buffer_Access is access all Stream_Element_Array;
|
||||
|
||||
type Stream_Type
|
||||
is new Root_Stream_Type with
|
||||
record
|
||||
Mode : Stream_Mode;
|
||||
|
||||
Buffer : Buffer_Access;
|
||||
Rest_First : Stream_Element_Offset;
|
||||
Rest_Last : Stream_Element_Offset;
|
||||
-- Buffer for Read operation.
|
||||
-- We need to have this buffer in the record
|
||||
-- becouse not all read data from back stream
|
||||
-- could be processed during the read operation.
|
||||
|
||||
Buffer_Size : Stream_Element_Offset;
|
||||
-- Buffer size for write operation.
|
||||
-- We do not need to have this buffer
|
||||
-- in the record becouse all data could be
|
||||
-- processed in the write operation.
|
||||
|
||||
Back : Stream_Access;
|
||||
Reader : Filter_Type;
|
||||
Writer : Filter_Type;
|
||||
end record;
|
||||
|
||||
end ZLib.Streams;
|
||||
|
|
@ -1,185 +0,0 @@
|
|||
----------------------------------------------------------------
|
||||
-- ZLib for Ada thick binding. --
|
||||
-- --
|
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov --
|
||||
-- --
|
||||
-- Open source license information is in the zlib.ads file. --
|
||||
----------------------------------------------------------------
|
||||
|
||||
-- $Id: zlib-thin.adb,v 1.6 2003/01/21 15:26:37 vagul Exp $
|
||||
|
||||
package body ZLib.Thin is
|
||||
|
||||
ZLIB_VERSION : constant Chars_Ptr :=
|
||||
Interfaces.C.Strings.New_String ("1.1.4");
|
||||
|
||||
Z_Stream_Size : constant Int := Z_Stream'Size / System.Storage_Unit;
|
||||
|
||||
--------------
|
||||
-- Avail_In --
|
||||
--------------
|
||||
|
||||
function Avail_In (Strm : in Z_Stream) return UInt is
|
||||
begin
|
||||
return Strm.Avail_In;
|
||||
end Avail_In;
|
||||
|
||||
---------------
|
||||
-- Avail_Out --
|
||||
---------------
|
||||
|
||||
function Avail_Out (Strm : in Z_Stream) return UInt is
|
||||
begin
|
||||
return Strm.Avail_Out;
|
||||
end Avail_Out;
|
||||
|
||||
------------------
|
||||
-- Deflate_Init --
|
||||
------------------
|
||||
|
||||
function Deflate_Init
|
||||
(strm : in Z_Streamp;
|
||||
level : in Int := Z_DEFAULT_COMPRESSION)
|
||||
return Int is
|
||||
begin
|
||||
return deflateInit (strm, level, ZLIB_VERSION, Z_Stream_Size);
|
||||
end Deflate_Init;
|
||||
|
||||
function Deflate_Init
|
||||
(strm : Z_Streamp;
|
||||
level : Int;
|
||||
method : Int;
|
||||
windowBits : Int;
|
||||
memLevel : Int;
|
||||
strategy : Int)
|
||||
return Int is
|
||||
begin
|
||||
return deflateInit2
|
||||
(strm,
|
||||
level,
|
||||
method,
|
||||
windowBits,
|
||||
memLevel,
|
||||
strategy,
|
||||
ZLIB_VERSION,
|
||||
Z_Stream_Size);
|
||||
end Deflate_Init;
|
||||
|
||||
------------------
|
||||
-- Inflate_Init --
|
||||
------------------
|
||||
|
||||
function Inflate_Init (strm : Z_Streamp) return Int is
|
||||
begin
|
||||
return inflateInit (strm, ZLIB_VERSION, Z_Stream_Size);
|
||||
end Inflate_Init;
|
||||
|
||||
function Inflate_Init (strm : Z_Streamp; windowBits : Int) return Int is
|
||||
begin
|
||||
return inflateInit2 (strm, windowBits, ZLIB_VERSION, Z_Stream_Size);
|
||||
end Inflate_Init;
|
||||
|
||||
function Last_Error_Message (Strm : in Z_Stream) return String is
|
||||
use Interfaces.C.Strings;
|
||||
begin
|
||||
if Strm.msg = Null_Ptr then
|
||||
return "";
|
||||
else
|
||||
return Value (Strm.msg);
|
||||
end if;
|
||||
end Last_Error_Message;
|
||||
|
||||
-------------
|
||||
-- Need_In --
|
||||
-------------
|
||||
|
||||
function Need_In (strm : Z_Stream) return Boolean is
|
||||
begin
|
||||
return strm.Avail_In = 0;
|
||||
end Need_In;
|
||||
|
||||
--------------
|
||||
-- Need_Out --
|
||||
--------------
|
||||
|
||||
function Need_Out (strm : Z_Stream) return Boolean is
|
||||
begin
|
||||
return strm.Avail_Out = 0;
|
||||
end Need_Out;
|
||||
|
||||
------------
|
||||
-- Set_In --
|
||||
------------
|
||||
|
||||
procedure Set_In
|
||||
(Strm : in out Z_Stream;
|
||||
Buffer : in Byte_Access;
|
||||
Size : in UInt) is
|
||||
begin
|
||||
Strm.Next_In := Buffer;
|
||||
Strm.Avail_In := Size;
|
||||
end Set_In;
|
||||
|
||||
procedure Set_In
|
||||
(Strm : in out Z_Stream;
|
||||
Buffer : in Voidp;
|
||||
Size : in UInt) is
|
||||
begin
|
||||
Set_In (Strm, Bytes.To_Pointer (Buffer), Size);
|
||||
end Set_In;
|
||||
|
||||
------------------
|
||||
-- Set_Mem_Func --
|
||||
------------------
|
||||
|
||||
procedure Set_Mem_Func
|
||||
(Strm : in out Z_Stream;
|
||||
Opaque : in Voidp;
|
||||
Alloc : in alloc_func;
|
||||
Free : in free_func) is
|
||||
begin
|
||||
Strm.opaque := Opaque;
|
||||
Strm.zalloc := Alloc;
|
||||
Strm.zfree := Free;
|
||||
end Set_Mem_Func;
|
||||
|
||||
-------------
|
||||
-- Set_Out --
|
||||
-------------
|
||||
|
||||
procedure Set_Out
|
||||
(Strm : in out Z_Stream;
|
||||
Buffer : in Byte_Access;
|
||||
Size : in UInt) is
|
||||
begin
|
||||
Strm.Next_Out := Buffer;
|
||||
Strm.Avail_Out := Size;
|
||||
end Set_Out;
|
||||
|
||||
procedure Set_Out
|
||||
(Strm : in out Z_Stream;
|
||||
Buffer : in Voidp;
|
||||
Size : in UInt) is
|
||||
begin
|
||||
Set_Out (Strm, Bytes.To_Pointer (Buffer), Size);
|
||||
end Set_Out;
|
||||
|
||||
--------------
|
||||
-- Total_In --
|
||||
--------------
|
||||
|
||||
function Total_In (Strm : in Z_Stream) return ULong is
|
||||
begin
|
||||
return Strm.Total_In;
|
||||
end Total_In;
|
||||
|
||||
---------------
|
||||
-- Total_Out --
|
||||
---------------
|
||||
|
||||
function Total_Out (Strm : in Z_Stream) return ULong is
|
||||
begin
|
||||
return Strm.Total_Out;
|
||||
end Total_Out;
|
||||
|
||||
end ZLib.Thin;
|
||||
|
|
@ -1,485 +0,0 @@
|
|||
----------------------------------------------------------------
|
||||
-- ZLib for Ada thick binding. --
|
||||
-- --
|
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov --
|
||||
-- --
|
||||
-- Open source license information is in the zlib.ads file. --
|
||||
----------------------------------------------------------------
|
||||
|
||||
-- $Id: zlib-thin.ads,v 1.8 2003/08/12 13:16:51 vagul Exp $
|
||||
|
||||
with Interfaces.C.Strings;
|
||||
with System.Address_To_Access_Conversions;
|
||||
|
||||
private package ZLib.Thin is
|
||||
|
||||
-- From zconf.h
|
||||
|
||||
MAX_MEM_LEVEL : constant := 9; -- zconf.h:105
|
||||
-- zconf.h:105
|
||||
MAX_WBITS : constant := 15; -- zconf.h:115
|
||||
-- 32K LZ77 window
|
||||
-- zconf.h:115
|
||||
SEEK_SET : constant := 8#0000#; -- zconf.h:244
|
||||
-- Seek from beginning of file.
|
||||
-- zconf.h:244
|
||||
SEEK_CUR : constant := 1; -- zconf.h:245
|
||||
-- Seek from current position.
|
||||
-- zconf.h:245
|
||||
SEEK_END : constant := 2; -- zconf.h:246
|
||||
-- Set file pointer to EOF plus "offset"
|
||||
-- zconf.h:246
|
||||
|
||||
type Byte is new Interfaces.C.unsigned_char; -- 8 bits
|
||||
-- zconf.h:214
|
||||
type UInt is new Interfaces.C.unsigned; -- 16 bits or more
|
||||
-- zconf.h:216
|
||||
type Int is new Interfaces.C.int;
|
||||
|
||||
type ULong is new Interfaces.C.unsigned; -- 32 bits or more
|
||||
-- zconf.h:217
|
||||
subtype Chars_Ptr is Interfaces.C.Strings.chars_ptr;
|
||||
|
||||
type ULong_Access is access ULong;
|
||||
type Int_Access is access Int;
|
||||
subtype Voidp is System.Address; -- zconf.h:232
|
||||
|
||||
package Bytes is new System.Address_To_Access_Conversions (Byte);
|
||||
|
||||
subtype Byte_Access is Bytes.Object_Pointer;
|
||||
|
||||
-- end from zconf
|
||||
|
||||
Z_NO_FLUSH : constant := 8#0000#; -- zlib.h:125
|
||||
-- zlib.h:125
|
||||
Z_PARTIAL_FLUSH : constant := 1; -- zlib.h:126
|
||||
-- will be removed, use
|
||||
-- Z_SYNC_FLUSH instead
|
||||
-- zlib.h:126
|
||||
Z_SYNC_FLUSH : constant := 2; -- zlib.h:127
|
||||
-- zlib.h:127
|
||||
Z_FULL_FLUSH : constant := 3; -- zlib.h:128
|
||||
-- zlib.h:128
|
||||
Z_FINISH : constant := 4; -- zlib.h:129
|
||||
-- zlib.h:129
|
||||
Z_OK : constant := 8#0000#; -- zlib.h:132
|
||||
-- zlib.h:132
|
||||
Z_STREAM_END : constant := 1; -- zlib.h:133
|
||||
-- zlib.h:133
|
||||
Z_NEED_DICT : constant := 2; -- zlib.h:134
|
||||
-- zlib.h:134
|
||||
Z_ERRNO : constant := -1; -- zlib.h:135
|
||||
-- zlib.h:135
|
||||
Z_STREAM_ERROR : constant := -2; -- zlib.h:136
|
||||
-- zlib.h:136
|
||||
Z_DATA_ERROR : constant := -3; -- zlib.h:137
|
||||
-- zlib.h:137
|
||||
Z_MEM_ERROR : constant := -4; -- zlib.h:138
|
||||
-- zlib.h:138
|
||||
Z_BUF_ERROR : constant := -5; -- zlib.h:139
|
||||
-- zlib.h:139
|
||||
Z_VERSION_ERROR : constant := -6; -- zlib.h:140
|
||||
-- zlib.h:140
|
||||
Z_NO_COMPRESSION : constant := 8#0000#; -- zlib.h:145
|
||||
-- zlib.h:145
|
||||
Z_BEST_SPEED : constant := 1; -- zlib.h:146
|
||||
-- zlib.h:146
|
||||
Z_BEST_COMPRESSION : constant := 9; -- zlib.h:147
|
||||
-- zlib.h:147
|
||||
Z_DEFAULT_COMPRESSION : constant := -1; -- zlib.h:148
|
||||
-- zlib.h:148
|
||||
Z_FILTERED : constant := 1; -- zlib.h:151
|
||||
-- zlib.h:151
|
||||
Z_HUFFMAN_ONLY : constant := 2; -- zlib.h:152
|
||||
-- zlib.h:152
|
||||
Z_DEFAULT_STRATEGY : constant := 8#0000#; -- zlib.h:153
|
||||
-- zlib.h:153
|
||||
Z_BINARY : constant := 8#0000#; -- zlib.h:156
|
||||
-- zlib.h:156
|
||||
Z_ASCII : constant := 1; -- zlib.h:157
|
||||
-- zlib.h:157
|
||||
Z_UNKNOWN : constant := 2; -- zlib.h:158
|
||||
-- zlib.h:158
|
||||
Z_DEFLATED : constant := 8; -- zlib.h:161
|
||||
-- zlib.h:161
|
||||
Z_NULL : constant := 8#0000#; -- zlib.h:164
|
||||
-- for initializing zalloc, zfree, opaque
|
||||
-- zlib.h:164
|
||||
type gzFile is new Voidp; -- zlib.h:646
|
||||
|
||||
type Z_Stream is private;
|
||||
|
||||
type Z_Streamp is access all Z_Stream; -- zlib.h:89
|
||||
|
||||
type alloc_func is access function
|
||||
(Opaque : Voidp;
|
||||
Items : UInt;
|
||||
Size : UInt)
|
||||
return Voidp; -- zlib.h:63
|
||||
|
||||
type free_func is access procedure (opaque : Voidp; address : Voidp);
|
||||
|
||||
function zlibVersion return Chars_Ptr;
|
||||
|
||||
function Deflate (strm : Z_Streamp; flush : Int) return Int;
|
||||
|
||||
function DeflateEnd (strm : Z_Streamp) return Int;
|
||||
|
||||
function Inflate (strm : Z_Streamp; flush : Int) return Int;
|
||||
|
||||
function InflateEnd (strm : Z_Streamp) return Int;
|
||||
|
||||
function deflateSetDictionary
|
||||
(strm : Z_Streamp;
|
||||
dictionary : Byte_Access;
|
||||
dictLength : UInt)
|
||||
return Int;
|
||||
|
||||
function deflateCopy (dest : Z_Streamp; source : Z_Streamp) return Int;
|
||||
-- zlib.h:478
|
||||
|
||||
function deflateReset (strm : Z_Streamp) return Int; -- zlib.h:495
|
||||
|
||||
function deflateParams
|
||||
(strm : Z_Streamp;
|
||||
level : Int;
|
||||
strategy : Int)
|
||||
return Int; -- zlib.h:506
|
||||
|
||||
function inflateSetDictionary
|
||||
(strm : Z_Streamp;
|
||||
dictionary : Byte_Access;
|
||||
dictLength : UInt)
|
||||
return Int; -- zlib.h:548
|
||||
|
||||
function inflateSync (strm : Z_Streamp) return Int; -- zlib.h:565
|
||||
|
||||
function inflateReset (strm : Z_Streamp) return Int; -- zlib.h:580
|
||||
|
||||
function compress
|
||||
(dest : Byte_Access;
|
||||
destLen : ULong_Access;
|
||||
source : Byte_Access;
|
||||
sourceLen : ULong)
|
||||
return Int; -- zlib.h:601
|
||||
|
||||
function compress2
|
||||
(dest : Byte_Access;
|
||||
destLen : ULong_Access;
|
||||
source : Byte_Access;
|
||||
sourceLen : ULong;
|
||||
level : Int)
|
||||
return Int; -- zlib.h:615
|
||||
|
||||
function uncompress
|
||||
(dest : Byte_Access;
|
||||
destLen : ULong_Access;
|
||||
source : Byte_Access;
|
||||
sourceLen : ULong)
|
||||
return Int;
|
||||
|
||||
function gzopen (path : Chars_Ptr; mode : Chars_Ptr) return gzFile;
|
||||
|
||||
function gzdopen (fd : Int; mode : Chars_Ptr) return gzFile;
|
||||
|
||||
function gzsetparams
|
||||
(file : gzFile;
|
||||
level : Int;
|
||||
strategy : Int)
|
||||
return Int;
|
||||
|
||||
function gzread
|
||||
(file : gzFile;
|
||||
buf : Voidp;
|
||||
len : UInt)
|
||||
return Int;
|
||||
|
||||
function gzwrite
|
||||
(file : in gzFile;
|
||||
buf : in Voidp;
|
||||
len : in UInt)
|
||||
return Int;
|
||||
|
||||
function gzprintf (file : in gzFile; format : in Chars_Ptr) return Int;
|
||||
|
||||
function gzputs (file : in gzFile; s : in Chars_Ptr) return Int;
|
||||
|
||||
function gzgets
|
||||
(file : gzFile;
|
||||
buf : Chars_Ptr;
|
||||
len : Int)
|
||||
return Chars_Ptr;
|
||||
|
||||
function gzputc (file : gzFile; char : Int) return Int;
|
||||
|
||||
function gzgetc (file : gzFile) return Int;
|
||||
|
||||
function gzflush (file : gzFile; flush : Int) return Int;
|
||||
|
||||
function gzseek
|
||||
(file : gzFile;
|
||||
offset : Int;
|
||||
whence : Int)
|
||||
return Int;
|
||||
|
||||
function gzrewind (file : gzFile) return Int;
|
||||
|
||||
function gztell (file : gzFile) return Int;
|
||||
|
||||
function gzeof (file : gzFile) return Int;
|
||||
|
||||
function gzclose (file : gzFile) return Int;
|
||||
|
||||
function gzerror (file : gzFile; errnum : Int_Access) return Chars_Ptr;
|
||||
|
||||
function adler32
|
||||
(adler : ULong;
|
||||
buf : Byte_Access;
|
||||
len : UInt)
|
||||
return ULong;
|
||||
|
||||
function crc32
|
||||
(crc : ULong;
|
||||
buf : Byte_Access;
|
||||
len : UInt)
|
||||
return ULong;
|
||||
|
||||
function deflateInit
|
||||
(strm : Z_Streamp;
|
||||
level : Int;
|
||||
version : Chars_Ptr;
|
||||
stream_size : Int)
|
||||
return Int;
|
||||
|
||||
function Deflate_Init
|
||||
(strm : in Z_Streamp;
|
||||
level : in Int := Z_DEFAULT_COMPRESSION)
|
||||
return Int;
|
||||
pragma Inline (Deflate_Init);
|
||||
|
||||
function deflateInit2
|
||||
(strm : Z_Streamp;
|
||||
level : Int;
|
||||
method : Int;
|
||||
windowBits : Int;
|
||||
memLevel : Int;
|
||||
strategy : Int;
|
||||
version : Chars_Ptr;
|
||||
stream_size : Int)
|
||||
return Int;
|
||||
|
||||
function Deflate_Init
|
||||
(strm : Z_Streamp;
|
||||
level : Int;
|
||||
method : Int;
|
||||
windowBits : Int;
|
||||
memLevel : Int;
|
||||
strategy : Int)
|
||||
return Int;
|
||||
pragma Inline (Deflate_Init);
|
||||
|
||||
function inflateInit
|
||||
(strm : Z_Streamp;
|
||||
version : Chars_Ptr;
|
||||
stream_size : Int)
|
||||
return Int;
|
||||
|
||||
function Inflate_Init (strm : Z_Streamp) return Int;
|
||||
pragma Inline (Inflate_Init);
|
||||
|
||||
function inflateInit2
|
||||
(strm : in Z_Streamp;
|
||||
windowBits : in Int;
|
||||
version : in Chars_Ptr;
|
||||
stream_size : in Int)
|
||||
return Int;
|
||||
|
||||
function inflateBackInit
|
||||
(strm : in Z_Streamp;
|
||||
windowBits : in Int;
|
||||
window : in Byte_Access;
|
||||
version : in Chars_Ptr;
|
||||
stream_size : in Int)
|
||||
return Int;
|
||||
-- Size of window have to be 2**windowBits.
|
||||
|
||||
function Inflate_Init (strm : Z_Streamp; windowBits : Int) return Int;
|
||||
pragma Inline (Inflate_Init);
|
||||
|
||||
function zError (err : Int) return Chars_Ptr;
|
||||
|
||||
function inflateSyncPoint (z : Z_Streamp) return Int;
|
||||
|
||||
function get_crc_table return ULong_Access;
|
||||
|
||||
-- Interface to the available fields of the z_stream structure.
|
||||
-- The application must update next_in and avail_in when avail_in has
|
||||
-- dropped to zero. It must update next_out and avail_out when avail_out
|
||||
-- has dropped to zero. The application must initialize zalloc, zfree and
|
||||
-- opaque before calling the init function.
|
||||
|
||||
function Need_In (strm : in Z_Stream) return Boolean;
|
||||
-- return true when we do not need to setup Next_In and Avail_In fields.
|
||||
pragma Inline (Need_In);
|
||||
|
||||
function Need_Out (strm : in Z_Stream) return Boolean;
|
||||
-- return true when we do not need to setup Next_Out and Avail_Out field.
|
||||
pragma Inline (Need_Out);
|
||||
|
||||
procedure Set_In
|
||||
(Strm : in out Z_Stream;
|
||||
Buffer : in Byte_Access;
|
||||
Size : in UInt);
|
||||
pragma Inline (Set_In);
|
||||
|
||||
procedure Set_In
|
||||
(Strm : in out Z_Stream;
|
||||
Buffer : in Voidp;
|
||||
Size : in UInt);
|
||||
pragma Inline (Set_In);
|
||||
|
||||
procedure Set_Out
|
||||
(Strm : in out Z_Stream;
|
||||
Buffer : in Byte_Access;
|
||||
Size : in UInt);
|
||||
pragma Inline (Set_Out);
|
||||
|
||||
procedure Set_Out
|
||||
(Strm : in out Z_Stream;
|
||||
Buffer : in Voidp;
|
||||
Size : in UInt);
|
||||
pragma Inline (Set_Out);
|
||||
|
||||
procedure Set_Mem_Func
|
||||
(Strm : in out Z_Stream;
|
||||
Opaque : in Voidp;
|
||||
Alloc : in alloc_func;
|
||||
Free : in free_func);
|
||||
pragma Inline (Set_Mem_Func);
|
||||
|
||||
function Last_Error_Message (Strm : in Z_Stream) return String;
|
||||
pragma Inline (Last_Error_Message);
|
||||
|
||||
function Avail_Out (Strm : in Z_Stream) return UInt;
|
||||
pragma Inline (Avail_Out);
|
||||
|
||||
function Avail_In (Strm : in Z_Stream) return UInt;
|
||||
pragma Inline (Avail_In);
|
||||
|
||||
function Total_In (Strm : in Z_Stream) return ULong;
|
||||
pragma Inline (Total_In);
|
||||
|
||||
function Total_Out (Strm : in Z_Stream) return ULong;
|
||||
pragma Inline (Total_Out);
|
||||
|
||||
function inflateCopy
|
||||
(dest : in Z_Streamp;
|
||||
Source : in Z_Streamp)
|
||||
return Int;
|
||||
|
||||
function compressBound (Source_Len : in ULong) return ULong;
|
||||
|
||||
function deflateBound
|
||||
(Strm : in Z_Streamp;
|
||||
Source_Len : in ULong)
|
||||
return ULong;
|
||||
|
||||
function gzungetc (C : in Int; File : in gzFile) return Int;
|
||||
|
||||
function zlibCompileFlags return ULong;
|
||||
|
||||
function deflatePrime
|
||||
(strm : Z_Streamp;
|
||||
bits : Int;
|
||||
value : Int)
|
||||
return Int;
|
||||
|
||||
private
|
||||
|
||||
type Z_Stream is record -- zlib.h:68
|
||||
Next_In : Byte_Access; -- next input byte
|
||||
Avail_In : UInt := 0; -- number of bytes available at next_in
|
||||
Total_In : ULong := 0; -- total nb of input bytes read so far
|
||||
Next_Out : Byte_Access; -- next output byte should be put there
|
||||
Avail_Out : UInt := 0; -- remaining free space at next_out
|
||||
Total_Out : ULong := 0; -- total nb of bytes output so far
|
||||
msg : Chars_Ptr; -- last error message, NULL if no error
|
||||
state : Voidp; -- not visible by applications
|
||||
zalloc : alloc_func := null; -- used to allocate the internal state
|
||||
zfree : free_func := null; -- used to free the internal state
|
||||
opaque : Voidp; -- private data object passed to
|
||||
-- zalloc and zfree
|
||||
data_type : Int; -- best guess about the data type:
|
||||
-- ascii or binary
|
||||
adler : ULong; -- adler32 value of the uncompressed
|
||||
-- data
|
||||
reserved : ULong; -- reserved for future use
|
||||
end record;
|
||||
|
||||
pragma Convention (C, Z_Stream);
|
||||
|
||||
pragma Import (C, zlibVersion, "zlibVersion");
|
||||
pragma Import (C, Deflate, "deflate");
|
||||
pragma Import (C, DeflateEnd, "deflateEnd");
|
||||
pragma Import (C, Inflate, "inflate");
|
||||
pragma Import (C, InflateEnd, "inflateEnd");
|
||||
pragma Import (C, deflateSetDictionary, "deflateSetDictionary");
|
||||
pragma Import (C, deflateCopy, "deflateCopy");
|
||||
pragma Import (C, deflateReset, "deflateReset");
|
||||
pragma Import (C, deflateParams, "deflateParams");
|
||||
pragma Import (C, inflateSetDictionary, "inflateSetDictionary");
|
||||
pragma Import (C, inflateSync, "inflateSync");
|
||||
pragma Import (C, inflateReset, "inflateReset");
|
||||
pragma Import (C, compress, "compress");
|
||||
pragma Import (C, compress2, "compress2");
|
||||
pragma Import (C, uncompress, "uncompress");
|
||||
pragma Import (C, gzopen, "gzopen");
|
||||
pragma Import (C, gzdopen, "gzdopen");
|
||||
pragma Import (C, gzsetparams, "gzsetparams");
|
||||
pragma Import (C, gzread, "gzread");
|
||||
pragma Import (C, gzwrite, "gzwrite");
|
||||
pragma Import (C, gzprintf, "gzprintf");
|
||||
pragma Import (C, gzputs, "gzputs");
|
||||
pragma Import (C, gzgets, "gzgets");
|
||||
pragma Import (C, gzputc, "gzputc");
|
||||
pragma Import (C, gzgetc, "gzgetc");
|
||||
pragma Import (C, gzflush, "gzflush");
|
||||
pragma Import (C, gzseek, "gzseek");
|
||||
pragma Import (C, gzrewind, "gzrewind");
|
||||
pragma Import (C, gztell, "gztell");
|
||||
pragma Import (C, gzeof, "gzeof");
|
||||
pragma Import (C, gzclose, "gzclose");
|
||||
pragma Import (C, gzerror, "gzerror");
|
||||
pragma Import (C, adler32, "adler32");
|
||||
pragma Import (C, crc32, "crc32");
|
||||
pragma Import (C, deflateInit, "deflateInit_");
|
||||
pragma Import (C, inflateInit, "inflateInit_");
|
||||
pragma Import (C, deflateInit2, "deflateInit2_");
|
||||
pragma Import (C, inflateInit2, "inflateInit2_");
|
||||
pragma Import (C, zError, "zError");
|
||||
pragma Import (C, inflateSyncPoint, "inflateSyncPoint");
|
||||
pragma Import (C, get_crc_table, "get_crc_table");
|
||||
|
||||
-- added in zlib 1.2.1:
|
||||
|
||||
pragma Import (C, inflateCopy, "inflateCopy");
|
||||
pragma Import (C, compressBound, "compressBound");
|
||||
pragma Import (C, deflateBound, "deflateBound");
|
||||
pragma Import (C, gzungetc, "gzungetc");
|
||||
pragma Import (C, zlibCompileFlags, "zlibCompileFlags");
|
||||
pragma Import (C, deflatePrime, "deflatePrime");
|
||||
|
||||
pragma Import (C, inflateBackInit, "inflateBackInit_");
|
||||
|
||||
-- I stopped binding the inflateBack routines, becouse realize that
|
||||
-- it does not support zlib and gzip headers for now, and have no
|
||||
-- symmetric deflateBack routines.
|
||||
-- ZLib-Ada is symmetric regarding deflate/inflate data transformation
|
||||
-- and has a similar generic callback interface for the
|
||||
-- deflate/inflate transformation based on the regular Deflate/Inflate
|
||||
-- routines.
|
||||
|
||||
-- pragma Import (C, inflateBack, "inflateBack");
|
||||
-- pragma Import (C, inflateBackEnd, "inflateBackEnd");
|
||||
|
||||
end ZLib.Thin;
|
||||
|
|
@ -1,674 +0,0 @@
|
|||
----------------------------------------------------------------
|
||||
-- ZLib for Ada thick binding. --
|
||||
-- --
|
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov --
|
||||
-- --
|
||||
-- Open source license information is in the zlib.ads file. --
|
||||
----------------------------------------------------------------
|
||||
|
||||
-- $Id: zlib.adb,v 1.19 2003/07/13 16:02:19 vagul Exp $
|
||||
|
||||
with Ada.Exceptions;
|
||||
with Ada.Unchecked_Conversion;
|
||||
with Ada.Unchecked_Deallocation;
|
||||
|
||||
with Interfaces.C.Strings;
|
||||
|
||||
with ZLib.Thin;
|
||||
|
||||
package body ZLib is
|
||||
|
||||
use type Thin.Int;
|
||||
|
||||
type Z_Stream is new Thin.Z_Stream;
|
||||
|
||||
type Return_Code_Enum is
|
||||
(OK,
|
||||
STREAM_END,
|
||||
NEED_DICT,
|
||||
ERRNO,
|
||||
STREAM_ERROR,
|
||||
DATA_ERROR,
|
||||
MEM_ERROR,
|
||||
BUF_ERROR,
|
||||
VERSION_ERROR);
|
||||
|
||||
type Flate_Step_Function is access
|
||||
function (Strm : Thin.Z_Streamp; flush : Thin.Int) return Thin.Int;
|
||||
pragma Convention (C, Flate_Step_Function);
|
||||
|
||||
type Flate_End_Function is access
|
||||
function (Ctrm : in Thin.Z_Streamp) return Thin.Int;
|
||||
pragma Convention (C, Flate_End_Function);
|
||||
|
||||
type Flate_Type is record
|
||||
Step : Flate_Step_Function;
|
||||
Done : Flate_End_Function;
|
||||
end record;
|
||||
|
||||
subtype Footer_Array is Stream_Element_Array (1 .. 8);
|
||||
|
||||
Simple_GZip_Header : constant Stream_Element_Array (1 .. 10)
|
||||
:= (16#1f#, 16#8b#, -- Magic header
|
||||
16#08#, -- Z_DEFLATED
|
||||
16#00#, -- Flags
|
||||
16#00#, 16#00#, 16#00#, 16#00#, -- Time
|
||||
16#00#, -- XFlags
|
||||
16#03# -- OS code
|
||||
);
|
||||
-- The simplest gzip header is not for informational, but just for
|
||||
-- gzip format compatibility.
|
||||
-- Note that some code below is using assumption
|
||||
-- Simple_GZip_Header'Last > Footer_Array'Last, so do not make
|
||||
-- Simple_GZip_Header'Last <= Footer_Array'Last.
|
||||
|
||||
Return_Code : constant array (Thin.Int range <>) of Return_Code_Enum
|
||||
:= (0 => OK,
|
||||
1 => STREAM_END,
|
||||
2 => NEED_DICT,
|
||||
-1 => ERRNO,
|
||||
-2 => STREAM_ERROR,
|
||||
-3 => DATA_ERROR,
|
||||
-4 => MEM_ERROR,
|
||||
-5 => BUF_ERROR,
|
||||
-6 => VERSION_ERROR);
|
||||
|
||||
Flate : constant array (Boolean) of Flate_Type
|
||||
:= (True => (Step => Thin.Deflate'Access,
|
||||
Done => Thin.DeflateEnd'Access),
|
||||
False => (Step => Thin.Inflate'Access,
|
||||
Done => Thin.InflateEnd'Access));
|
||||
|
||||
Flush_Finish : constant array (Boolean) of Flush_Mode
|
||||
:= (True => Finish, False => No_Flush);
|
||||
|
||||
procedure Raise_Error (Stream : Z_Stream);
|
||||
pragma Inline (Raise_Error);
|
||||
|
||||
procedure Raise_Error (Message : String);
|
||||
pragma Inline (Raise_Error);
|
||||
|
||||
procedure Check_Error (Stream : Z_Stream; Code : Thin.Int);
|
||||
|
||||
procedure Free is new Ada.Unchecked_Deallocation
|
||||
(Z_Stream, Z_Stream_Access);
|
||||
|
||||
function To_Thin_Access is new Ada.Unchecked_Conversion
|
||||
(Z_Stream_Access, Thin.Z_Streamp);
|
||||
|
||||
procedure Translate_GZip
|
||||
(Filter : in out Filter_Type;
|
||||
In_Data : in Ada.Streams.Stream_Element_Array;
|
||||
In_Last : out Ada.Streams.Stream_Element_Offset;
|
||||
Out_Data : out Ada.Streams.Stream_Element_Array;
|
||||
Out_Last : out Ada.Streams.Stream_Element_Offset;
|
||||
Flush : in Flush_Mode);
|
||||
-- Separate translate routine for make gzip header.
|
||||
|
||||
procedure Translate_Auto
|
||||
(Filter : in out Filter_Type;
|
||||
In_Data : in Ada.Streams.Stream_Element_Array;
|
||||
In_Last : out Ada.Streams.Stream_Element_Offset;
|
||||
Out_Data : out Ada.Streams.Stream_Element_Array;
|
||||
Out_Last : out Ada.Streams.Stream_Element_Offset;
|
||||
Flush : in Flush_Mode);
|
||||
-- translate routine without additional headers.
|
||||
|
||||
-----------------
|
||||
-- Check_Error --
|
||||
-----------------
|
||||
|
||||
procedure Check_Error (Stream : Z_Stream; Code : Thin.Int) is
|
||||
use type Thin.Int;
|
||||
begin
|
||||
if Code /= Thin.Z_OK then
|
||||
Raise_Error
|
||||
(Return_Code_Enum'Image (Return_Code (Code))
|
||||
& ": " & Last_Error_Message (Stream));
|
||||
end if;
|
||||
end Check_Error;
|
||||
|
||||
-----------
|
||||
-- Close --
|
||||
-----------
|
||||
|
||||
procedure Close
|
||||
(Filter : in out Filter_Type;
|
||||
Ignore_Error : in Boolean := False)
|
||||
is
|
||||
Code : Thin.Int;
|
||||
begin
|
||||
Code := Flate (Filter.Compression).Done
|
||||
(To_Thin_Access (Filter.Strm));
|
||||
|
||||
Filter.Opened := False;
|
||||
|
||||
if Ignore_Error or else Code = Thin.Z_OK then
|
||||
Free (Filter.Strm);
|
||||
else
|
||||
declare
|
||||
Error_Message : constant String
|
||||
:= Last_Error_Message (Filter.Strm.all);
|
||||
begin
|
||||
Free (Filter.Strm);
|
||||
Ada.Exceptions.Raise_Exception
|
||||
(ZLib_Error'Identity,
|
||||
Return_Code_Enum'Image (Return_Code (Code))
|
||||
& ": " & Error_Message);
|
||||
end;
|
||||
end if;
|
||||
end Close;
|
||||
|
||||
-----------
|
||||
-- CRC32 --
|
||||
-----------
|
||||
|
||||
function CRC32
|
||||
(CRC : in Unsigned_32;
|
||||
Data : in Ada.Streams.Stream_Element_Array)
|
||||
return Unsigned_32
|
||||
is
|
||||
use Thin;
|
||||
begin
|
||||
return Unsigned_32 (crc32
|
||||
(ULong (CRC),
|
||||
Bytes.To_Pointer (Data'Address),
|
||||
Data'Length));
|
||||
end CRC32;
|
||||
|
||||
procedure CRC32
|
||||
(CRC : in out Unsigned_32;
|
||||
Data : in Ada.Streams.Stream_Element_Array) is
|
||||
begin
|
||||
CRC := CRC32 (CRC, Data);
|
||||
end CRC32;
|
||||
|
||||
------------------
|
||||
-- Deflate_Init --
|
||||
------------------
|
||||
|
||||
procedure Deflate_Init
|
||||
(Filter : in out Filter_Type;
|
||||
Level : in Compression_Level := Default_Compression;
|
||||
Strategy : in Strategy_Type := Default_Strategy;
|
||||
Method : in Compression_Method := Deflated;
|
||||
Window_Bits : in Window_Bits_Type := 15;
|
||||
Memory_Level : in Memory_Level_Type := 8;
|
||||
Header : in Header_Type := Default)
|
||||
is
|
||||
use type Thin.Int;
|
||||
Win_Bits : Thin.Int := Thin.Int (Window_Bits);
|
||||
begin
|
||||
-- We allow ZLib to make header only in case of default header type.
|
||||
-- Otherwise we would either do header by ourselfs, or do not do
|
||||
-- header at all.
|
||||
|
||||
if Header = None or else Header = GZip then
|
||||
Win_Bits := -Win_Bits;
|
||||
end if;
|
||||
|
||||
-- For the GZip CRC calculation and make headers.
|
||||
|
||||
if Header = GZip then
|
||||
Filter.CRC := 0;
|
||||
Filter.Offset := Simple_GZip_Header'First;
|
||||
else
|
||||
Filter.Offset := Simple_GZip_Header'Last + 1;
|
||||
end if;
|
||||
|
||||
Filter.Strm := new Z_Stream;
|
||||
Filter.Compression := True;
|
||||
Filter.Stream_End := False;
|
||||
Filter.Opened := True;
|
||||
Filter.Header := Header;
|
||||
|
||||
if Thin.Deflate_Init
|
||||
(To_Thin_Access (Filter.Strm),
|
||||
Level => Thin.Int (Level),
|
||||
method => Thin.Int (Method),
|
||||
windowBits => Win_Bits,
|
||||
memLevel => Thin.Int (Memory_Level),
|
||||
strategy => Thin.Int (Strategy)) /= Thin.Z_OK
|
||||
then
|
||||
Raise_Error (Filter.Strm.all);
|
||||
end if;
|
||||
end Deflate_Init;
|
||||
|
||||
-----------
|
||||
-- Flush --
|
||||
-----------
|
||||
|
||||
procedure Flush
|
||||
(Filter : in out Filter_Type;
|
||||
Out_Data : out Ada.Streams.Stream_Element_Array;
|
||||
Out_Last : out Ada.Streams.Stream_Element_Offset;
|
||||
Flush : in Flush_Mode)
|
||||
is
|
||||
No_Data : Stream_Element_Array := (1 .. 0 => 0);
|
||||
Last : Stream_Element_Offset;
|
||||
begin
|
||||
Translate (Filter, No_Data, Last, Out_Data, Out_Last, Flush);
|
||||
end Flush;
|
||||
|
||||
-----------------------
|
||||
-- Generic_Translate --
|
||||
-----------------------
|
||||
|
||||
procedure Generic_Translate
|
||||
(Filter : in out ZLib.Filter_Type;
|
||||
In_Buffer_Size : Integer := Default_Buffer_Size;
|
||||
Out_Buffer_Size : Integer := Default_Buffer_Size)
|
||||
is
|
||||
In_Buffer : Stream_Element_Array
|
||||
(1 .. Stream_Element_Offset (In_Buffer_Size));
|
||||
Out_Buffer : Stream_Element_Array
|
||||
(1 .. Stream_Element_Offset (Out_Buffer_Size));
|
||||
Last : Stream_Element_Offset;
|
||||
In_Last : Stream_Element_Offset;
|
||||
In_First : Stream_Element_Offset;
|
||||
Out_Last : Stream_Element_Offset;
|
||||
begin
|
||||
Main : loop
|
||||
Data_In (In_Buffer, Last);
|
||||
|
||||
In_First := In_Buffer'First;
|
||||
|
||||
loop
|
||||
Translate
|
||||
(Filter,
|
||||
In_Buffer (In_First .. Last),
|
||||
In_Last,
|
||||
Out_Buffer,
|
||||
Out_Last,
|
||||
Flush_Finish (Last < In_Buffer'First));
|
||||
|
||||
Data_Out (Out_Buffer (Out_Buffer'First .. Out_Last));
|
||||
|
||||
exit Main when Stream_End (Filter);
|
||||
|
||||
-- The end of in buffer.
|
||||
exit when In_Last = Last;
|
||||
|
||||
In_First := In_Last + 1;
|
||||
end loop;
|
||||
end loop Main;
|
||||
|
||||
end Generic_Translate;
|
||||
|
||||
------------------
|
||||
-- Inflate_Init --
|
||||
------------------
|
||||
|
||||
procedure Inflate_Init
|
||||
(Filter : in out Filter_Type;
|
||||
Window_Bits : in Window_Bits_Type := 15;
|
||||
Header : in Header_Type := Default)
|
||||
is
|
||||
use type Thin.Int;
|
||||
Win_Bits : Thin.Int := Thin.Int (Window_Bits);
|
||||
|
||||
procedure Check_Version;
|
||||
-- Check the latest header types compatibility.
|
||||
|
||||
procedure Check_Version is
|
||||
begin
|
||||
if Version <= "1.1.4" then
|
||||
Raise_Error
|
||||
("Inflate header type " & Header_Type'Image (Header)
|
||||
& " incompatible with ZLib version " & Version);
|
||||
end if;
|
||||
end Check_Version;
|
||||
|
||||
begin
|
||||
case Header is
|
||||
when None =>
|
||||
Check_Version;
|
||||
|
||||
-- Inflate data without headers determined
|
||||
-- by negative Win_Bits.
|
||||
|
||||
Win_Bits := -Win_Bits;
|
||||
when GZip =>
|
||||
Check_Version;
|
||||
|
||||
-- Inflate gzip data defined by flag 16.
|
||||
|
||||
Win_Bits := Win_Bits + 16;
|
||||
when Auto =>
|
||||
Check_Version;
|
||||
|
||||
-- Inflate with automatic detection
|
||||
-- of gzip or native header defined by flag 32.
|
||||
|
||||
Win_Bits := Win_Bits + 32;
|
||||
when Default => null;
|
||||
end case;
|
||||
|
||||
Filter.Strm := new Z_Stream;
|
||||
Filter.Compression := False;
|
||||
Filter.Stream_End := False;
|
||||
Filter.Opened := True;
|
||||
Filter.Header := Header;
|
||||
|
||||
if Thin.Inflate_Init
|
||||
(To_Thin_Access (Filter.Strm), Win_Bits) /= Thin.Z_OK
|
||||
then
|
||||
Raise_Error (Filter.Strm.all);
|
||||
end if;
|
||||
end Inflate_Init;
|
||||
|
||||
-----------------
|
||||
-- Raise_Error --
|
||||
-----------------
|
||||
|
||||
procedure Raise_Error (Message : String) is
|
||||
begin
|
||||
Ada.Exceptions.Raise_Exception (ZLib_Error'Identity, Message);
|
||||
end Raise_Error;
|
||||
|
||||
procedure Raise_Error (Stream : Z_Stream) is
|
||||
begin
|
||||
Raise_Error (Last_Error_Message (Stream));
|
||||
end Raise_Error;
|
||||
|
||||
----------
|
||||
-- Read --
|
||||
----------
|
||||
|
||||
procedure Read
|
||||
(Filter : in out Filter_Type;
|
||||
Item : out Ada.Streams.Stream_Element_Array;
|
||||
Last : out Ada.Streams.Stream_Element_Offset)
|
||||
is
|
||||
In_Last : Stream_Element_Offset;
|
||||
Item_First : Ada.Streams.Stream_Element_Offset := Item'First;
|
||||
|
||||
begin
|
||||
pragma Assert (Rest_First in Buffer'First .. Buffer'Last + 1);
|
||||
|
||||
loop
|
||||
if Rest_First > Buffer'Last then
|
||||
Read (Buffer, Rest_Last);
|
||||
Rest_First := Buffer'First;
|
||||
end if;
|
||||
|
||||
pragma Assert (Rest_Last in Buffer'First - 1 .. Buffer'Last);
|
||||
|
||||
Translate
|
||||
(Filter => Filter,
|
||||
In_Data => Buffer (Rest_First .. Rest_Last),
|
||||
In_Last => In_Last,
|
||||
Out_Data => Item (Item_First .. Item'Last),
|
||||
Out_Last => Last,
|
||||
Flush => Flush_Finish (Rest_Last < Rest_First));
|
||||
|
||||
Rest_First := In_Last + 1;
|
||||
|
||||
exit when Last = Item'Last or else Stream_End (Filter);
|
||||
|
||||
Item_First := Last + 1;
|
||||
end loop;
|
||||
end Read;
|
||||
|
||||
----------------
|
||||
-- Stream_End --
|
||||
----------------
|
||||
|
||||
function Stream_End (Filter : in Filter_Type) return Boolean is
|
||||
begin
|
||||
if Filter.Header = GZip and Filter.Compression then
|
||||
return Filter.Stream_End
|
||||
and then Filter.Offset = Footer_Array'Last + 1;
|
||||
else
|
||||
return Filter.Stream_End;
|
||||
end if;
|
||||
end Stream_End;
|
||||
|
||||
--------------
|
||||
-- Total_In --
|
||||
--------------
|
||||
|
||||
function Total_In (Filter : in Filter_Type) return Count is
|
||||
begin
|
||||
return Count (Thin.Total_In (To_Thin_Access (Filter.Strm).all));
|
||||
end Total_In;
|
||||
|
||||
---------------
|
||||
-- Total_Out --
|
||||
---------------
|
||||
|
||||
function Total_Out (Filter : in Filter_Type) return Count is
|
||||
begin
|
||||
return Count (Thin.Total_Out (To_Thin_Access (Filter.Strm).all));
|
||||
end Total_Out;
|
||||
|
||||
---------------
|
||||
-- Translate --
|
||||
---------------
|
||||
|
||||
procedure Translate
|
||||
(Filter : in out Filter_Type;
|
||||
In_Data : in Ada.Streams.Stream_Element_Array;
|
||||
In_Last : out Ada.Streams.Stream_Element_Offset;
|
||||
Out_Data : out Ada.Streams.Stream_Element_Array;
|
||||
Out_Last : out Ada.Streams.Stream_Element_Offset;
|
||||
Flush : in Flush_Mode) is
|
||||
begin
|
||||
if Filter.Header = GZip and then Filter.Compression then
|
||||
Translate_GZip
|
||||
(Filter => Filter,
|
||||
In_Data => In_Data,
|
||||
In_Last => In_Last,
|
||||
Out_Data => Out_Data,
|
||||
Out_Last => Out_Last,
|
||||
Flush => Flush);
|
||||
else
|
||||
Translate_Auto
|
||||
(Filter => Filter,
|
||||
In_Data => In_Data,
|
||||
In_Last => In_Last,
|
||||
Out_Data => Out_Data,
|
||||
Out_Last => Out_Last,
|
||||
Flush => Flush);
|
||||
end if;
|
||||
end Translate;
|
||||
|
||||
--------------------
|
||||
-- Translate_Auto --
|
||||
--------------------
|
||||
|
||||
procedure Translate_Auto
|
||||
(Filter : in out Filter_Type;
|
||||
In_Data : in Ada.Streams.Stream_Element_Array;
|
||||
In_Last : out Ada.Streams.Stream_Element_Offset;
|
||||
Out_Data : out Ada.Streams.Stream_Element_Array;
|
||||
Out_Last : out Ada.Streams.Stream_Element_Offset;
|
||||
Flush : in Flush_Mode)
|
||||
is
|
||||
use type Thin.Int;
|
||||
Code : Thin.Int;
|
||||
|
||||
begin
|
||||
if Filter.Opened = False then
|
||||
raise ZLib_Error;
|
||||
end if;
|
||||
|
||||
if Out_Data'Length = 0 then
|
||||
raise Constraint_Error;
|
||||
end if;
|
||||
|
||||
Set_Out (Filter.Strm.all, Out_Data'Address, Out_Data'Length);
|
||||
Set_In (Filter.Strm.all, In_Data'Address, In_Data'Length);
|
||||
|
||||
Code := Flate (Filter.Compression).Step
|
||||
(To_Thin_Access (Filter.Strm),
|
||||
Thin.Int (Flush));
|
||||
|
||||
if Code = Thin.Z_STREAM_END then
|
||||
Filter.Stream_End := True;
|
||||
else
|
||||
Check_Error (Filter.Strm.all, Code);
|
||||
end if;
|
||||
|
||||
In_Last := In_Data'Last
|
||||
- Stream_Element_Offset (Avail_In (Filter.Strm.all));
|
||||
Out_Last := Out_Data'Last
|
||||
- Stream_Element_Offset (Avail_Out (Filter.Strm.all));
|
||||
|
||||
end Translate_Auto;
|
||||
|
||||
--------------------
|
||||
-- Translate_GZip --
|
||||
--------------------
|
||||
|
||||
procedure Translate_GZip
|
||||
(Filter : in out Filter_Type;
|
||||
In_Data : in Ada.Streams.Stream_Element_Array;
|
||||
In_Last : out Ada.Streams.Stream_Element_Offset;
|
||||
Out_Data : out Ada.Streams.Stream_Element_Array;
|
||||
Out_Last : out Ada.Streams.Stream_Element_Offset;
|
||||
Flush : in Flush_Mode)
|
||||
is
|
||||
Out_First : Stream_Element_Offset;
|
||||
|
||||
procedure Add_Data (Data : in Stream_Element_Array);
|
||||
-- Add data to stream from the Filter.Offset till necessary,
|
||||
-- used for add gzip headr/footer.
|
||||
|
||||
procedure Put_32
|
||||
(Item : in out Stream_Element_Array;
|
||||
Data : in Unsigned_32);
|
||||
pragma Inline (Put_32);
|
||||
|
||||
--------------
|
||||
-- Add_Data --
|
||||
--------------
|
||||
|
||||
procedure Add_Data (Data : in Stream_Element_Array) is
|
||||
Data_First : Stream_Element_Offset renames Filter.Offset;
|
||||
Data_Last : Stream_Element_Offset;
|
||||
Data_Len : Stream_Element_Offset; -- -1
|
||||
Out_Len : Stream_Element_Offset; -- -1
|
||||
begin
|
||||
Out_First := Out_Last + 1;
|
||||
|
||||
if Data_First > Data'Last then
|
||||
return;
|
||||
end if;
|
||||
|
||||
Data_Len := Data'Last - Data_First;
|
||||
Out_Len := Out_Data'Last - Out_First;
|
||||
|
||||
if Data_Len <= Out_Len then
|
||||
Out_Last := Out_First + Data_Len;
|
||||
Data_Last := Data'Last;
|
||||
else
|
||||
Out_Last := Out_Data'Last;
|
||||
Data_Last := Data_First + Out_Len;
|
||||
end if;
|
||||
|
||||
Out_Data (Out_First .. Out_Last) := Data (Data_First .. Data_Last);
|
||||
|
||||
Data_First := Data_Last + 1;
|
||||
Out_First := Out_Last + 1;
|
||||
end Add_Data;
|
||||
|
||||
------------
|
||||
-- Put_32 --
|
||||
------------
|
||||
|
||||
procedure Put_32
|
||||
(Item : in out Stream_Element_Array;
|
||||
Data : in Unsigned_32)
|
||||
is
|
||||
D : Unsigned_32 := Data;
|
||||
begin
|
||||
for J in Item'First .. Item'First + 3 loop
|
||||
Item (J) := Stream_Element (D and 16#FF#);
|
||||
D := Shift_Right (D, 8);
|
||||
end loop;
|
||||
end Put_32;
|
||||
|
||||
begin
|
||||
Out_Last := Out_Data'First - 1;
|
||||
|
||||
if not Filter.Stream_End then
|
||||
Add_Data (Simple_GZip_Header);
|
||||
|
||||
Translate_Auto
|
||||
(Filter => Filter,
|
||||
In_Data => In_Data,
|
||||
In_Last => In_Last,
|
||||
Out_Data => Out_Data (Out_First .. Out_Data'Last),
|
||||
Out_Last => Out_Last,
|
||||
Flush => Flush);
|
||||
|
||||
CRC32 (Filter.CRC, In_Data (In_Data'First .. In_Last));
|
||||
|
||||
end if;
|
||||
|
||||
if Filter.Stream_End and then Out_Last <= Out_Data'Last then
|
||||
-- This detection method would work only when
|
||||
-- Simple_GZip_Header'Last > Footer_Array'Last
|
||||
|
||||
if Filter.Offset = Simple_GZip_Header'Last + 1 then
|
||||
Filter.Offset := Footer_Array'First;
|
||||
end if;
|
||||
|
||||
declare
|
||||
Footer : Footer_Array;
|
||||
begin
|
||||
Put_32 (Footer, Filter.CRC);
|
||||
Put_32 (Footer (Footer'First + 4 .. Footer'Last),
|
||||
Unsigned_32 (Total_In (Filter)));
|
||||
Add_Data (Footer);
|
||||
end;
|
||||
end if;
|
||||
end Translate_GZip;
|
||||
|
||||
-------------
|
||||
-- Version --
|
||||
-------------
|
||||
|
||||
function Version return String is
|
||||
begin
|
||||
return Interfaces.C.Strings.Value (Thin.zlibVersion);
|
||||
end Version;
|
||||
|
||||
-----------
|
||||
-- Write --
|
||||
-----------
|
||||
|
||||
procedure Write
|
||||
(Filter : in out Filter_Type;
|
||||
Item : in Ada.Streams.Stream_Element_Array;
|
||||
Flush : in Flush_Mode)
|
||||
is
|
||||
Buffer : Stream_Element_Array (1 .. Buffer_Size);
|
||||
In_Last, Out_Last : Stream_Element_Offset;
|
||||
In_First : Stream_Element_Offset := Item'First;
|
||||
begin
|
||||
if Item'Length = 0 and Flush = No_Flush then
|
||||
return;
|
||||
end if;
|
||||
|
||||
loop
|
||||
Translate
|
||||
(Filter => Filter,
|
||||
In_Data => Item (In_First .. Item'Last),
|
||||
In_Last => In_Last,
|
||||
Out_Data => Buffer,
|
||||
Out_Last => Out_Last,
|
||||
Flush => Flush);
|
||||
|
||||
if Out_Last >= Buffer'First then
|
||||
Write (Buffer (1 .. Out_Last));
|
||||
end if;
|
||||
|
||||
exit when In_Last = Item'Last or Stream_End (Filter);
|
||||
|
||||
In_First := In_Last + 1;
|
||||
end loop;
|
||||
end Write;
|
||||
|
||||
end ZLib;
|
||||
|
|
@ -1,311 +0,0 @@
|
|||
------------------------------------------------------------------------------
|
||||
-- ZLib for Ada thick binding. --
|
||||
-- --
|
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov --
|
||||
-- --
|
||||
-- This library is free software; you can redistribute it and/or modify --
|
||||
-- it under the terms of the GNU General Public License as published by --
|
||||
-- the Free Software Foundation; either version 2 of the License, or (at --
|
||||
-- your option) any later version. --
|
||||
-- --
|
||||
-- This library is distributed in the hope that it will be useful, but --
|
||||
-- WITHOUT ANY WARRANTY; without even the implied warranty of --
|
||||
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU --
|
||||
-- General Public License for more details. --
|
||||
-- --
|
||||
-- You should have received a copy of the GNU General Public License --
|
||||
-- along with this library; if not, write to the Free Software Foundation, --
|
||||
-- Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. --
|
||||
-- --
|
||||
-- As a special exception, if other files instantiate generics from this --
|
||||
-- unit, or you link this unit with other files to produce an executable, --
|
||||
-- this unit does not by itself cause the resulting executable to be --
|
||||
-- covered by the GNU General Public License. This exception does not --
|
||||
-- however invalidate any other reasons why the executable file might be --
|
||||
-- covered by the GNU Public License. --
|
||||
------------------------------------------------------------------------------
|
||||
|
||||
-- $Id: zlib.ads,v 1.17 2003/08/12 13:19:07 vagul Exp $
|
||||
|
||||
with Ada.Streams;
|
||||
|
||||
with Interfaces;
|
||||
|
||||
package ZLib is
|
||||
|
||||
ZLib_Error : exception;
|
||||
|
||||
type Compression_Level is new Integer range -1 .. 9;
|
||||
|
||||
type Flush_Mode is private;
|
||||
|
||||
type Compression_Method is private;
|
||||
|
||||
type Window_Bits_Type is new Integer range 8 .. 15;
|
||||
|
||||
type Memory_Level_Type is new Integer range 1 .. 9;
|
||||
|
||||
type Unsigned_32 is new Interfaces.Unsigned_32;
|
||||
|
||||
type Strategy_Type is private;
|
||||
|
||||
type Header_Type is (None, Auto, Default, GZip);
|
||||
-- Header type usage have a some limitation for inflate.
|
||||
-- See comment for Inflate_Init.
|
||||
|
||||
subtype Count is Ada.Streams.Stream_Element_Count;
|
||||
|
||||
----------------------------------
|
||||
-- Compression method constants --
|
||||
----------------------------------
|
||||
|
||||
Deflated : constant Compression_Method;
|
||||
-- Only one method allowed in this ZLib version.
|
||||
|
||||
---------------------------------
|
||||
-- Compression level constants --
|
||||
---------------------------------
|
||||
|
||||
No_Compression : constant Compression_Level := 0;
|
||||
Best_Speed : constant Compression_Level := 1;
|
||||
Best_Compression : constant Compression_Level := 9;
|
||||
Default_Compression : constant Compression_Level := -1;
|
||||
|
||||
--------------------------
|
||||
-- Flush mode constants --
|
||||
--------------------------
|
||||
|
||||
No_Flush : constant Flush_Mode;
|
||||
-- Regular way for compression, no flush
|
||||
|
||||
Partial_Flush : constant Flush_Mode;
|
||||
-- will be removed, use Z_SYNC_FLUSH instead
|
||||
|
||||
Sync_Flush : constant Flush_Mode;
|
||||
-- all pending output is flushed to the output buffer and the output
|
||||
-- is aligned on a byte boundary, so that the decompressor can get all
|
||||
-- input data available so far. (In particular avail_in is zero after the
|
||||
-- call if enough output space has been provided before the call.)
|
||||
-- Flushing may degrade compression for some compression algorithms and so
|
||||
-- it should be used only when necessary.
|
||||
|
||||
Full_Flush : constant Flush_Mode;
|
||||
-- all output is flushed as with SYNC_FLUSH, and the compression state
|
||||
-- is reset so that decompression can restart from this point if previous
|
||||
-- compressed data has been damaged or if random access is desired. Using
|
||||
-- FULL_FLUSH too often can seriously degrade the compression.
|
||||
|
||||
Finish : constant Flush_Mode;
|
||||
-- Just for tell the compressor that input data is complete.
|
||||
|
||||
------------------------------------
|
||||
-- Compression strategy constants --
|
||||
------------------------------------
|
||||
|
||||
-- RLE stategy could be used only in version 1.2.0 and later.
|
||||
|
||||
Filtered : constant Strategy_Type;
|
||||
Huffman_Only : constant Strategy_Type;
|
||||
RLE : constant Strategy_Type;
|
||||
Default_Strategy : constant Strategy_Type;
|
||||
|
||||
Default_Buffer_Size : constant := 4096;
|
||||
|
||||
type Filter_Type is limited private;
|
||||
-- The filter is for compression and for decompression.
|
||||
-- The usage of the type is depend of its initialization.
|
||||
|
||||
function Version return String;
|
||||
pragma Inline (Version);
|
||||
-- Return string representation of the ZLib version.
|
||||
|
||||
procedure Deflate_Init
|
||||
(Filter : in out Filter_Type;
|
||||
Level : in Compression_Level := Default_Compression;
|
||||
Strategy : in Strategy_Type := Default_Strategy;
|
||||
Method : in Compression_Method := Deflated;
|
||||
Window_Bits : in Window_Bits_Type := 15;
|
||||
Memory_Level : in Memory_Level_Type := 8;
|
||||
Header : in Header_Type := Default);
|
||||
-- Compressor initialization.
|
||||
-- When Header parameter is Auto or Default, then default zlib header
|
||||
-- would be provided for compressed data.
|
||||
-- When Header is GZip, then gzip header would be set instead of
|
||||
-- default header.
|
||||
-- When Header is None, no header would be set for compressed data.
|
||||
|
||||
procedure Inflate_Init
|
||||
(Filter : in out Filter_Type;
|
||||
Window_Bits : in Window_Bits_Type := 15;
|
||||
Header : in Header_Type := Default);
|
||||
-- Decompressor initialization.
|
||||
-- Default header type mean that ZLib default header is expecting in the
|
||||
-- input compressed stream.
|
||||
-- Header type None mean that no header is expecting in the input stream.
|
||||
-- GZip header type mean that GZip header is expecting in the
|
||||
-- input compressed stream.
|
||||
-- Auto header type mean that header type (GZip or Native) would be
|
||||
-- detected automatically in the input stream.
|
||||
-- Note that header types parameter values None, GZip and Auto is
|
||||
-- supporting for inflate routine only in ZLib versions 1.2.0.2 and later.
|
||||
-- Deflate_Init is supporting all header types.
|
||||
|
||||
procedure Close
|
||||
(Filter : in out Filter_Type;
|
||||
Ignore_Error : in Boolean := False);
|
||||
-- Closing the compression or decompressor.
|
||||
-- If stream is closing before the complete and Ignore_Error is False,
|
||||
-- The exception would be raised.
|
||||
|
||||
generic
|
||||
with procedure Data_In
|
||||
(Item : out Ada.Streams.Stream_Element_Array;
|
||||
Last : out Ada.Streams.Stream_Element_Offset);
|
||||
with procedure Data_Out
|
||||
(Item : in Ada.Streams.Stream_Element_Array);
|
||||
procedure Generic_Translate
|
||||
(Filter : in out Filter_Type;
|
||||
In_Buffer_Size : in Integer := Default_Buffer_Size;
|
||||
Out_Buffer_Size : in Integer := Default_Buffer_Size);
|
||||
-- Compressing/decompressing data arrived from Data_In routine
|
||||
-- to the Data_Out routine. User should provide Data_In and Data_Out
|
||||
-- for compression/decompression data flow.
|
||||
-- Compression or decompression depend on initialization of Filter.
|
||||
|
||||
function Total_In (Filter : in Filter_Type) return Count;
|
||||
pragma Inline (Total_In);
|
||||
-- Return total number of input bytes read so far.
|
||||
|
||||
function Total_Out (Filter : in Filter_Type) return Count;
|
||||
pragma Inline (Total_Out);
|
||||
-- Return total number of bytes output so far.
|
||||
|
||||
function CRC32
|
||||
(CRC : in Unsigned_32;
|
||||
Data : in Ada.Streams.Stream_Element_Array)
|
||||
return Unsigned_32;
|
||||
pragma Inline (CRC32);
|
||||
-- Calculate CRC32, it could be necessary for make gzip format.
|
||||
|
||||
procedure CRC32
|
||||
(CRC : in out Unsigned_32;
|
||||
Data : in Ada.Streams.Stream_Element_Array);
|
||||
pragma Inline (CRC32);
|
||||
-- Calculate CRC32, it could be necessary for make gzip format.
|
||||
|
||||
-------------------------------------------------
|
||||
-- Below is more complex low level routines. --
|
||||
-------------------------------------------------
|
||||
|
||||
procedure Translate
|
||||
(Filter : in out Filter_Type;
|
||||
In_Data : in Ada.Streams.Stream_Element_Array;
|
||||
In_Last : out Ada.Streams.Stream_Element_Offset;
|
||||
Out_Data : out Ada.Streams.Stream_Element_Array;
|
||||
Out_Last : out Ada.Streams.Stream_Element_Offset;
|
||||
Flush : in Flush_Mode);
|
||||
-- Compressing/decompressing the datas from In_Data buffer to the
|
||||
-- Out_Data buffer.
|
||||
-- In_Data is incoming data portion,
|
||||
-- In_Last is the index of last element from In_Data accepted by the
|
||||
-- Filter.
|
||||
-- Out_Data is the buffer for output data from the filter.
|
||||
-- Out_Last is the last element of the received data from Filter.
|
||||
-- To tell the filter that incoming data is complete put the
|
||||
-- Flush parameter to FINISH.
|
||||
|
||||
function Stream_End (Filter : in Filter_Type) return Boolean;
|
||||
pragma Inline (Stream_End);
|
||||
-- Return the true when the stream is complete.
|
||||
|
||||
procedure Flush
|
||||
(Filter : in out Filter_Type;
|
||||
Out_Data : out Ada.Streams.Stream_Element_Array;
|
||||
Out_Last : out Ada.Streams.Stream_Element_Offset;
|
||||
Flush : in Flush_Mode);
|
||||
pragma Inline (Flush);
|
||||
-- Flushing the data from the compressor.
|
||||
|
||||
generic
|
||||
with procedure Write
|
||||
(Item : in Ada.Streams.Stream_Element_Array);
|
||||
-- User should provide this routine for accept
|
||||
-- compressed/decompressed data.
|
||||
|
||||
Buffer_Size : in Ada.Streams.Stream_Element_Offset
|
||||
:= Default_Buffer_Size;
|
||||
-- Buffer size for Write user routine.
|
||||
|
||||
procedure Write
|
||||
(Filter : in out Filter_Type;
|
||||
Item : in Ada.Streams.Stream_Element_Array;
|
||||
Flush : in Flush_Mode);
|
||||
-- Compressing/Decompressing data from Item to the
|
||||
-- generic parameter procedure Write.
|
||||
-- Output buffer size could be set in Buffer_Size generic parameter.
|
||||
|
||||
generic
|
||||
with procedure Read
|
||||
(Item : out Ada.Streams.Stream_Element_Array;
|
||||
Last : out Ada.Streams.Stream_Element_Offset);
|
||||
-- User should provide data for compression/decompression
|
||||
-- thru this routine.
|
||||
|
||||
Buffer : in out Ada.Streams.Stream_Element_Array;
|
||||
-- Buffer for keep remaining data from the previous
|
||||
-- back read.
|
||||
|
||||
Rest_First, Rest_Last : in out Ada.Streams.Stream_Element_Offset;
|
||||
-- Rest_First have to be initialized to Buffer'Last + 1
|
||||
-- before usage.
|
||||
|
||||
procedure Read
|
||||
(Filter : in out Filter_Type;
|
||||
Item : out Ada.Streams.Stream_Element_Array;
|
||||
Last : out Ada.Streams.Stream_Element_Offset);
|
||||
-- Compressing/Decompressing data from generic parameter
|
||||
-- procedure Read to the Item.
|
||||
-- User should provide Buffer for the operation
|
||||
-- and Rest_First variable first time initialized to the Buffer'Last + 1.
|
||||
|
||||
private
|
||||
|
||||
use Ada.Streams;
|
||||
|
||||
type Flush_Mode is new Integer range 0 .. 4;
|
||||
|
||||
type Compression_Method is new Integer range 8 .. 8;
|
||||
|
||||
type Strategy_Type is new Integer range 0 .. 3;
|
||||
|
||||
No_Flush : constant Flush_Mode := 0;
|
||||
Sync_Flush : constant Flush_Mode := 2;
|
||||
Full_Flush : constant Flush_Mode := 3;
|
||||
Finish : constant Flush_Mode := 4;
|
||||
Partial_Flush : constant Flush_Mode := 1;
|
||||
-- will be removed, use Z_SYNC_FLUSH instead
|
||||
|
||||
Filtered : constant Strategy_Type := 1;
|
||||
Huffman_Only : constant Strategy_Type := 2;
|
||||
RLE : constant Strategy_Type := 3;
|
||||
Default_Strategy : constant Strategy_Type := 0;
|
||||
|
||||
Deflated : constant Compression_Method := 8;
|
||||
|
||||
type Z_Stream;
|
||||
|
||||
type Z_Stream_Access is access all Z_Stream;
|
||||
|
||||
type Filter_Type is record
|
||||
Strm : Z_Stream_Access;
|
||||
Compression : Boolean;
|
||||
Stream_End : Boolean;
|
||||
Header : Header_Type;
|
||||
CRC : Unsigned_32;
|
||||
Offset : Stream_Element_Offset;
|
||||
-- Offset for gzip header/footer output.
|
||||
|
||||
Opened : Boolean := False;
|
||||
end record;
|
||||
|
||||
end ZLib;
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
project Zlib is
|
||||
|
||||
for Languages use ("Ada");
|
||||
for Source_Dirs use (".");
|
||||
for Object_Dir use ".";
|
||||
for Main use ("test.adb", "mtest.adb", "read.adb");
|
||||
|
||||
package Compiler is
|
||||
for Default_Switches ("ada") use ("-gnatwbcfilopru", "-gnatVcdfimorst", "-gnatyabcefhiklmnoprst");
|
||||
end Compiler;
|
||||
|
||||
package Linker is
|
||||
for Default_Switches ("ada") use ("-lz");
|
||||
end Linker;
|
||||
|
||||
package Builder is
|
||||
for Default_Switches ("ada") use ("-s", "-gnatQ");
|
||||
end Builder;
|
||||
|
||||
end Zlib;
|
||||
|
||||
|
|
@ -1,43 +0,0 @@
|
|||
This is a patched version of zlib modified to use
|
||||
Pentium-optimized assembly code in the deflation algorithm. The files
|
||||
changed/added by this patch are:
|
||||
|
||||
README.586
|
||||
match.S
|
||||
|
||||
The effectiveness of these modifications is a bit marginal, as the the
|
||||
program's bottleneck seems to be mostly L1-cache contention, for which
|
||||
there is no real way to work around without rewriting the basic
|
||||
algorithm. The speedup on average is around 5-10% (which is generally
|
||||
less than the amount of variance between subsequent executions).
|
||||
However, when used at level 9 compression, the cache contention can
|
||||
drop enough for the assembly version to achieve 10-20% speedup (and
|
||||
sometimes more, depending on the amount of overall redundancy in the
|
||||
files). Even here, though, cache contention can still be the limiting
|
||||
factor, depending on the nature of the program using the zlib library.
|
||||
This may also mean that better improvements will be seen on a Pentium
|
||||
with MMX, which suffers much less from L1-cache contention, but I have
|
||||
not yet verified this.
|
||||
|
||||
Note that this code has been tailored for the Pentium in particular,
|
||||
and will not perform well on the Pentium Pro (due to the use of a
|
||||
partial register in the inner loop).
|
||||
|
||||
If you are using an assembler other than GNU as, you will have to
|
||||
translate match.S to use your assembler's syntax. (Have fun.)
|
||||
|
||||
Brian Raiter
|
||||
breadbox@muppetlabs.com
|
||||
April, 1998
|
||||
|
||||
|
||||
Added for zlib 1.1.3:
|
||||
|
||||
The patches come from
|
||||
http://www.muppetlabs.com/~breadbox/software/assembly.html
|
||||
|
||||
To compile zlib with this asm file, copy match.S to the zlib directory
|
||||
then do:
|
||||
|
||||
CFLAGS="-O3 -DASMV" ./configure
|
||||
make OBJA=match.o
|
||||
|
|
@ -1,354 +0,0 @@
|
|||
/* match.s -- Pentium-optimized version of longest_match()
|
||||
* Written for zlib 1.1.2
|
||||
* Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com>
|
||||
*
|
||||
* This is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License.
|
||||
*/
|
||||
|
||||
#ifndef NO_UNDERLINE
|
||||
#define match_init _match_init
|
||||
#define longest_match _longest_match
|
||||
#endif
|
||||
|
||||
#define MAX_MATCH (258)
|
||||
#define MIN_MATCH (3)
|
||||
#define MIN_LOOKAHEAD (MAX_MATCH + MIN_MATCH + 1)
|
||||
#define MAX_MATCH_8 ((MAX_MATCH + 7) & ~7)
|
||||
|
||||
/* stack frame offsets */
|
||||
|
||||
#define wmask 0 /* local copy of s->wmask */
|
||||
#define window 4 /* local copy of s->window */
|
||||
#define windowbestlen 8 /* s->window + bestlen */
|
||||
#define chainlenscanend 12 /* high word: current chain len */
|
||||
/* low word: last bytes sought */
|
||||
#define scanstart 16 /* first two bytes of string */
|
||||
#define scanalign 20 /* dword-misalignment of string */
|
||||
#define nicematch 24 /* a good enough match size */
|
||||
#define bestlen 28 /* size of best match so far */
|
||||
#define scan 32 /* ptr to string wanting match */
|
||||
|
||||
#define LocalVarsSize (36)
|
||||
/* saved ebx 36 */
|
||||
/* saved edi 40 */
|
||||
/* saved esi 44 */
|
||||
/* saved ebp 48 */
|
||||
/* return address 52 */
|
||||
#define deflatestate 56 /* the function arguments */
|
||||
#define curmatch 60
|
||||
|
||||
/* Offsets for fields in the deflate_state structure. These numbers
|
||||
* are calculated from the definition of deflate_state, with the
|
||||
* assumption that the compiler will dword-align the fields. (Thus,
|
||||
* changing the definition of deflate_state could easily cause this
|
||||
* program to crash horribly, without so much as a warning at
|
||||
* compile time. Sigh.)
|
||||
*/
|
||||
#define dsWSize 36
|
||||
#define dsWMask 44
|
||||
#define dsWindow 48
|
||||
#define dsPrev 56
|
||||
#define dsMatchLen 88
|
||||
#define dsPrevMatch 92
|
||||
#define dsStrStart 100
|
||||
#define dsMatchStart 104
|
||||
#define dsLookahead 108
|
||||
#define dsPrevLen 112
|
||||
#define dsMaxChainLen 116
|
||||
#define dsGoodMatch 132
|
||||
#define dsNiceMatch 136
|
||||
|
||||
|
||||
.file "match.S"
|
||||
|
||||
.globl match_init, longest_match
|
||||
|
||||
.text
|
||||
|
||||
/* uInt longest_match(deflate_state *deflatestate, IPos curmatch) */
|
||||
|
||||
longest_match:
|
||||
|
||||
/* Save registers that the compiler may be using, and adjust %esp to */
|
||||
/* make room for our stack frame. */
|
||||
|
||||
pushl %ebp
|
||||
pushl %edi
|
||||
pushl %esi
|
||||
pushl %ebx
|
||||
subl $LocalVarsSize, %esp
|
||||
|
||||
/* Retrieve the function arguments. %ecx will hold cur_match */
|
||||
/* throughout the entire function. %edx will hold the pointer to the */
|
||||
/* deflate_state structure during the function's setup (before */
|
||||
/* entering the main loop). */
|
||||
|
||||
movl deflatestate(%esp), %edx
|
||||
movl curmatch(%esp), %ecx
|
||||
|
||||
/* if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; */
|
||||
|
||||
movl dsNiceMatch(%edx), %eax
|
||||
movl dsLookahead(%edx), %ebx
|
||||
cmpl %eax, %ebx
|
||||
jl LookaheadLess
|
||||
movl %eax, %ebx
|
||||
LookaheadLess: movl %ebx, nicematch(%esp)
|
||||
|
||||
/* register Bytef *scan = s->window + s->strstart; */
|
||||
|
||||
movl dsWindow(%edx), %esi
|
||||
movl %esi, window(%esp)
|
||||
movl dsStrStart(%edx), %ebp
|
||||
lea (%esi,%ebp), %edi
|
||||
movl %edi, scan(%esp)
|
||||
|
||||
/* Determine how many bytes the scan ptr is off from being */
|
||||
/* dword-aligned. */
|
||||
|
||||
movl %edi, %eax
|
||||
negl %eax
|
||||
andl $3, %eax
|
||||
movl %eax, scanalign(%esp)
|
||||
|
||||
/* IPos limit = s->strstart > (IPos)MAX_DIST(s) ? */
|
||||
/* s->strstart - (IPos)MAX_DIST(s) : NIL; */
|
||||
|
||||
movl dsWSize(%edx), %eax
|
||||
subl $MIN_LOOKAHEAD, %eax
|
||||
subl %eax, %ebp
|
||||
jg LimitPositive
|
||||
xorl %ebp, %ebp
|
||||
LimitPositive:
|
||||
|
||||
/* unsigned chain_length = s->max_chain_length; */
|
||||
/* if (s->prev_length >= s->good_match) { */
|
||||
/* chain_length >>= 2; */
|
||||
/* } */
|
||||
|
||||
movl dsPrevLen(%edx), %eax
|
||||
movl dsGoodMatch(%edx), %ebx
|
||||
cmpl %ebx, %eax
|
||||
movl dsMaxChainLen(%edx), %ebx
|
||||
jl LastMatchGood
|
||||
shrl $2, %ebx
|
||||
LastMatchGood:
|
||||
|
||||
/* chainlen is decremented once beforehand so that the function can */
|
||||
/* use the sign flag instead of the zero flag for the exit test. */
|
||||
/* It is then shifted into the high word, to make room for the scanend */
|
||||
/* scanend value, which it will always accompany. */
|
||||
|
||||
decl %ebx
|
||||
shll $16, %ebx
|
||||
|
||||
/* int best_len = s->prev_length; */
|
||||
|
||||
movl dsPrevLen(%edx), %eax
|
||||
movl %eax, bestlen(%esp)
|
||||
|
||||
/* Store the sum of s->window + best_len in %esi locally, and in %esi. */
|
||||
|
||||
addl %eax, %esi
|
||||
movl %esi, windowbestlen(%esp)
|
||||
|
||||
/* register ush scan_start = *(ushf*)scan; */
|
||||
/* register ush scan_end = *(ushf*)(scan+best_len-1); */
|
||||
|
||||
movw (%edi), %bx
|
||||
movw %bx, scanstart(%esp)
|
||||
movw -1(%edi,%eax), %bx
|
||||
movl %ebx, chainlenscanend(%esp)
|
||||
|
||||
/* Posf *prev = s->prev; */
|
||||
/* uInt wmask = s->w_mask; */
|
||||
|
||||
movl dsPrev(%edx), %edi
|
||||
movl dsWMask(%edx), %edx
|
||||
mov %edx, wmask(%esp)
|
||||
|
||||
/* Jump into the main loop. */
|
||||
|
||||
jmp LoopEntry
|
||||
|
||||
.balign 16
|
||||
|
||||
/* do {
|
||||
* match = s->window + cur_match;
|
||||
* if (*(ushf*)(match+best_len-1) != scan_end ||
|
||||
* *(ushf*)match != scan_start) continue;
|
||||
* [...]
|
||||
* } while ((cur_match = prev[cur_match & wmask]) > limit
|
||||
* && --chain_length != 0);
|
||||
*
|
||||
* Here is the inner loop of the function. The function will spend the
|
||||
* majority of its time in this loop, and majority of that time will
|
||||
* be spent in the first ten instructions.
|
||||
*
|
||||
* Within this loop:
|
||||
* %ebx = chainlenscanend - i.e., ((chainlen << 16) | scanend)
|
||||
* %ecx = curmatch
|
||||
* %edx = curmatch & wmask
|
||||
* %esi = windowbestlen - i.e., (window + bestlen)
|
||||
* %edi = prev
|
||||
* %ebp = limit
|
||||
*
|
||||
* Two optimization notes on the choice of instructions:
|
||||
*
|
||||
* The first instruction uses a 16-bit address, which costs an extra,
|
||||
* unpairable cycle. This is cheaper than doing a 32-bit access and
|
||||
* zeroing the high word, due to the 3-cycle misalignment penalty which
|
||||
* would occur half the time. This also turns out to be cheaper than
|
||||
* doing two separate 8-bit accesses, as the memory is so rarely in the
|
||||
* L1 cache.
|
||||
*
|
||||
* The window buffer, however, apparently spends a lot of time in the
|
||||
* cache, and so it is faster to retrieve the word at the end of the
|
||||
* match string with two 8-bit loads. The instructions that test the
|
||||
* word at the beginning of the match string, however, are executed
|
||||
* much less frequently, and there it was cheaper to use 16-bit
|
||||
* instructions, which avoided the necessity of saving off and
|
||||
* subsequently reloading one of the other registers.
|
||||
*/
|
||||
LookupLoop:
|
||||
/* 1 U & V */
|
||||
movw (%edi,%edx,2), %cx /* 2 U pipe */
|
||||
movl wmask(%esp), %edx /* 2 V pipe */
|
||||
cmpl %ebp, %ecx /* 3 U pipe */
|
||||
jbe LeaveNow /* 3 V pipe */
|
||||
subl $0x00010000, %ebx /* 4 U pipe */
|
||||
js LeaveNow /* 4 V pipe */
|
||||
LoopEntry: movb -1(%esi,%ecx), %al /* 5 U pipe */
|
||||
andl %ecx, %edx /* 5 V pipe */
|
||||
cmpb %bl, %al /* 6 U pipe */
|
||||
jnz LookupLoop /* 6 V pipe */
|
||||
movb (%esi,%ecx), %ah
|
||||
cmpb %bh, %ah
|
||||
jnz LookupLoop
|
||||
movl window(%esp), %eax
|
||||
movw (%eax,%ecx), %ax
|
||||
cmpw scanstart(%esp), %ax
|
||||
jnz LookupLoop
|
||||
|
||||
/* Store the current value of chainlen. */
|
||||
|
||||
movl %ebx, chainlenscanend(%esp)
|
||||
|
||||
/* Point %edi to the string under scrutiny, and %esi to the string we */
|
||||
/* are hoping to match it up with. In actuality, %esi and %edi are */
|
||||
/* both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and %edx is */
|
||||
/* initialized to -(MAX_MATCH_8 - scanalign). */
|
||||
|
||||
movl window(%esp), %esi
|
||||
movl scan(%esp), %edi
|
||||
addl %ecx, %esi
|
||||
movl scanalign(%esp), %eax
|
||||
movl $(-MAX_MATCH_8), %edx
|
||||
lea MAX_MATCH_8(%edi,%eax), %edi
|
||||
lea MAX_MATCH_8(%esi,%eax), %esi
|
||||
|
||||
/* Test the strings for equality, 8 bytes at a time. At the end,
|
||||
* adjust %edx so that it is offset to the exact byte that mismatched.
|
||||
*
|
||||
* We already know at this point that the first three bytes of the
|
||||
* strings match each other, and they can be safely passed over before
|
||||
* starting the compare loop. So what this code does is skip over 0-3
|
||||
* bytes, as much as necessary in order to dword-align the %edi
|
||||
* pointer. (%esi will still be misaligned three times out of four.)
|
||||
*
|
||||
* It should be confessed that this loop usually does not represent
|
||||
* much of the total running time. Replacing it with a more
|
||||
* straightforward "rep cmpsb" would not drastically degrade
|
||||
* performance.
|
||||
*/
|
||||
LoopCmps:
|
||||
movl (%esi,%edx), %eax
|
||||
movl (%edi,%edx), %ebx
|
||||
xorl %ebx, %eax
|
||||
jnz LeaveLoopCmps
|
||||
movl 4(%esi,%edx), %eax
|
||||
movl 4(%edi,%edx), %ebx
|
||||
xorl %ebx, %eax
|
||||
jnz LeaveLoopCmps4
|
||||
addl $8, %edx
|
||||
jnz LoopCmps
|
||||
jmp LenMaximum
|
||||
LeaveLoopCmps4: addl $4, %edx
|
||||
LeaveLoopCmps: testl $0x0000FFFF, %eax
|
||||
jnz LenLower
|
||||
addl $2, %edx
|
||||
shrl $16, %eax
|
||||
LenLower: subb $1, %al
|
||||
adcl $0, %edx
|
||||
|
||||
/* Calculate the length of the match. If it is longer than MAX_MATCH, */
|
||||
/* then automatically accept it as the best possible match and leave. */
|
||||
|
||||
lea (%edi,%edx), %eax
|
||||
movl scan(%esp), %edi
|
||||
subl %edi, %eax
|
||||
cmpl $MAX_MATCH, %eax
|
||||
jge LenMaximum
|
||||
|
||||
/* If the length of the match is not longer than the best match we */
|
||||
/* have so far, then forget it and return to the lookup loop. */
|
||||
|
||||
movl deflatestate(%esp), %edx
|
||||
movl bestlen(%esp), %ebx
|
||||
cmpl %ebx, %eax
|
||||
jg LongerMatch
|
||||
movl chainlenscanend(%esp), %ebx
|
||||
movl windowbestlen(%esp), %esi
|
||||
movl dsPrev(%edx), %edi
|
||||
movl wmask(%esp), %edx
|
||||
andl %ecx, %edx
|
||||
jmp LookupLoop
|
||||
|
||||
/* s->match_start = cur_match; */
|
||||
/* best_len = len; */
|
||||
/* if (len >= nice_match) break; */
|
||||
/* scan_end = *(ushf*)(scan+best_len-1); */
|
||||
|
||||
LongerMatch: movl nicematch(%esp), %ebx
|
||||
movl %eax, bestlen(%esp)
|
||||
movl %ecx, dsMatchStart(%edx)
|
||||
cmpl %ebx, %eax
|
||||
jge LeaveNow
|
||||
movl window(%esp), %esi
|
||||
addl %eax, %esi
|
||||
movl %esi, windowbestlen(%esp)
|
||||
movl chainlenscanend(%esp), %ebx
|
||||
movw -1(%edi,%eax), %bx
|
||||
movl dsPrev(%edx), %edi
|
||||
movl %ebx, chainlenscanend(%esp)
|
||||
movl wmask(%esp), %edx
|
||||
andl %ecx, %edx
|
||||
jmp LookupLoop
|
||||
|
||||
/* Accept the current string, with the maximum possible length. */
|
||||
|
||||
LenMaximum: movl deflatestate(%esp), %edx
|
||||
movl $MAX_MATCH, bestlen(%esp)
|
||||
movl %ecx, dsMatchStart(%edx)
|
||||
|
||||
/* if ((uInt)best_len <= s->lookahead) return (uInt)best_len; */
|
||||
/* return s->lookahead; */
|
||||
|
||||
LeaveNow:
|
||||
movl deflatestate(%esp), %edx
|
||||
movl bestlen(%esp), %ebx
|
||||
movl dsLookahead(%edx), %eax
|
||||
cmpl %eax, %ebx
|
||||
jg LookaheadRet
|
||||
movl %ebx, %eax
|
||||
LookaheadRet:
|
||||
|
||||
/* Restore the stack and return from whence we came. */
|
||||
|
||||
addl $LocalVarsSize, %esp
|
||||
popl %ebx
|
||||
popl %esi
|
||||
popl %edi
|
||||
popl %ebp
|
||||
match_init: ret
|
||||
|
|
@ -1,34 +0,0 @@
|
|||
This is a patched version of zlib, modified to use
|
||||
Pentium-Pro-optimized assembly code in the deflation algorithm. The
|
||||
files changed/added by this patch are:
|
||||
|
||||
README.686
|
||||
match.S
|
||||
|
||||
The speedup that this patch provides varies, depending on whether the
|
||||
compiler used to build the original version of zlib falls afoul of the
|
||||
PPro's speed traps. My own tests show a speedup of around 10-20% at
|
||||
the default compression level, and 20-30% using -9, against a version
|
||||
compiled using gcc 2.7.2.3. Your mileage may vary.
|
||||
|
||||
Note that this code has been tailored for the PPro/PII in particular,
|
||||
and will not perform particuarly well on a Pentium.
|
||||
|
||||
If you are using an assembler other than GNU as, you will have to
|
||||
translate match.S to use your assembler's syntax. (Have fun.)
|
||||
|
||||
Brian Raiter
|
||||
breadbox@muppetlabs.com
|
||||
April, 1998
|
||||
|
||||
|
||||
Added for zlib 1.1.3:
|
||||
|
||||
The patches come from
|
||||
http://www.muppetlabs.com/~breadbox/software/assembly.html
|
||||
|
||||
To compile zlib with this asm file, copy match.S to the zlib directory
|
||||
then do:
|
||||
|
||||
CFLAGS="-O3 -DASMV" ./configure
|
||||
make OBJA=match.o
|
||||
|
|
@ -1,327 +0,0 @@
|
|||
/* match.s -- Pentium-Pro-optimized version of longest_match()
|
||||
* Written for zlib 1.1.2
|
||||
* Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com>
|
||||
*
|
||||
* This is free software; you can redistribute it and/or modify it
|
||||
* under the terms of the GNU General Public License.
|
||||
*/
|
||||
|
||||
#ifndef NO_UNDERLINE
|
||||
#define match_init _match_init
|
||||
#define longest_match _longest_match
|
||||
#endif
|
||||
|
||||
#define MAX_MATCH (258)
|
||||
#define MIN_MATCH (3)
|
||||
#define MIN_LOOKAHEAD (MAX_MATCH + MIN_MATCH + 1)
|
||||
#define MAX_MATCH_8 ((MAX_MATCH + 7) & ~7)
|
||||
|
||||
/* stack frame offsets */
|
||||
|
||||
#define chainlenwmask 0 /* high word: current chain len */
|
||||
/* low word: s->wmask */
|
||||
#define window 4 /* local copy of s->window */
|
||||
#define windowbestlen 8 /* s->window + bestlen */
|
||||
#define scanstart 16 /* first two bytes of string */
|
||||
#define scanend 12 /* last two bytes of string */
|
||||
#define scanalign 20 /* dword-misalignment of string */
|
||||
#define nicematch 24 /* a good enough match size */
|
||||
#define bestlen 28 /* size of best match so far */
|
||||
#define scan 32 /* ptr to string wanting match */
|
||||
|
||||
#define LocalVarsSize (36)
|
||||
/* saved ebx 36 */
|
||||
/* saved edi 40 */
|
||||
/* saved esi 44 */
|
||||
/* saved ebp 48 */
|
||||
/* return address 52 */
|
||||
#define deflatestate 56 /* the function arguments */
|
||||
#define curmatch 60
|
||||
|
||||
/* Offsets for fields in the deflate_state structure. These numbers
|
||||
* are calculated from the definition of deflate_state, with the
|
||||
* assumption that the compiler will dword-align the fields. (Thus,
|
||||
* changing the definition of deflate_state could easily cause this
|
||||
* program to crash horribly, without so much as a warning at
|
||||
* compile time. Sigh.)
|
||||
*/
|
||||
#define dsWSize 36
|
||||
#define dsWMask 44
|
||||
#define dsWindow 48
|
||||
#define dsPrev 56
|
||||
#define dsMatchLen 88
|
||||
#define dsPrevMatch 92
|
||||
#define dsStrStart 100
|
||||
#define dsMatchStart 104
|
||||
#define dsLookahead 108
|
||||
#define dsPrevLen 112
|
||||
#define dsMaxChainLen 116
|
||||
#define dsGoodMatch 132
|
||||
#define dsNiceMatch 136
|
||||
|
||||
|
||||
.file "match.S"
|
||||
|
||||
.globl match_init, longest_match
|
||||
|
||||
.text
|
||||
|
||||
/* uInt longest_match(deflate_state *deflatestate, IPos curmatch) */
|
||||
|
||||
longest_match:
|
||||
|
||||
/* Save registers that the compiler may be using, and adjust %esp to */
|
||||
/* make room for our stack frame. */
|
||||
|
||||
pushl %ebp
|
||||
pushl %edi
|
||||
pushl %esi
|
||||
pushl %ebx
|
||||
subl $LocalVarsSize, %esp
|
||||
|
||||
/* Retrieve the function arguments. %ecx will hold cur_match */
|
||||
/* throughout the entire function. %edx will hold the pointer to the */
|
||||
/* deflate_state structure during the function's setup (before */
|
||||
/* entering the main loop). */
|
||||
|
||||
movl deflatestate(%esp), %edx
|
||||
movl curmatch(%esp), %ecx
|
||||
|
||||
/* uInt wmask = s->w_mask; */
|
||||
/* unsigned chain_length = s->max_chain_length; */
|
||||
/* if (s->prev_length >= s->good_match) { */
|
||||
/* chain_length >>= 2; */
|
||||
/* } */
|
||||
|
||||
movl dsPrevLen(%edx), %eax
|
||||
movl dsGoodMatch(%edx), %ebx
|
||||
cmpl %ebx, %eax
|
||||
movl dsWMask(%edx), %eax
|
||||
movl dsMaxChainLen(%edx), %ebx
|
||||
jl LastMatchGood
|
||||
shrl $2, %ebx
|
||||
LastMatchGood:
|
||||
|
||||
/* chainlen is decremented once beforehand so that the function can */
|
||||
/* use the sign flag instead of the zero flag for the exit test. */
|
||||
/* It is then shifted into the high word, to make room for the wmask */
|
||||
/* value, which it will always accompany. */
|
||||
|
||||
decl %ebx
|
||||
shll $16, %ebx
|
||||
orl %eax, %ebx
|
||||
movl %ebx, chainlenwmask(%esp)
|
||||
|
||||
/* if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead; */
|
||||
|
||||
movl dsNiceMatch(%edx), %eax
|
||||
movl dsLookahead(%edx), %ebx
|
||||
cmpl %eax, %ebx
|
||||
jl LookaheadLess
|
||||
movl %eax, %ebx
|
||||
LookaheadLess: movl %ebx, nicematch(%esp)
|
||||
|
||||
/* register Bytef *scan = s->window + s->strstart; */
|
||||
|
||||
movl dsWindow(%edx), %esi
|
||||
movl %esi, window(%esp)
|
||||
movl dsStrStart(%edx), %ebp
|
||||
lea (%esi,%ebp), %edi
|
||||
movl %edi, scan(%esp)
|
||||
|
||||
/* Determine how many bytes the scan ptr is off from being */
|
||||
/* dword-aligned. */
|
||||
|
||||
movl %edi, %eax
|
||||
negl %eax
|
||||
andl $3, %eax
|
||||
movl %eax, scanalign(%esp)
|
||||
|
||||
/* IPos limit = s->strstart > (IPos)MAX_DIST(s) ? */
|
||||
/* s->strstart - (IPos)MAX_DIST(s) : NIL; */
|
||||
|
||||
movl dsWSize(%edx), %eax
|
||||
subl $MIN_LOOKAHEAD, %eax
|
||||
subl %eax, %ebp
|
||||
jg LimitPositive
|
||||
xorl %ebp, %ebp
|
||||
LimitPositive:
|
||||
|
||||
/* int best_len = s->prev_length; */
|
||||
|
||||
movl dsPrevLen(%edx), %eax
|
||||
movl %eax, bestlen(%esp)
|
||||
|
||||
/* Store the sum of s->window + best_len in %esi locally, and in %esi. */
|
||||
|
||||
addl %eax, %esi
|
||||
movl %esi, windowbestlen(%esp)
|
||||
|
||||
/* register ush scan_start = *(ushf*)scan; */
|
||||
/* register ush scan_end = *(ushf*)(scan+best_len-1); */
|
||||
/* Posf *prev = s->prev; */
|
||||
|
||||
movzwl (%edi), %ebx
|
||||
movl %ebx, scanstart(%esp)
|
||||
movzwl -1(%edi,%eax), %ebx
|
||||
movl %ebx, scanend(%esp)
|
||||
movl dsPrev(%edx), %edi
|
||||
|
||||
/* Jump into the main loop. */
|
||||
|
||||
movl chainlenwmask(%esp), %edx
|
||||
jmp LoopEntry
|
||||
|
||||
.balign 16
|
||||
|
||||
/* do {
|
||||
* match = s->window + cur_match;
|
||||
* if (*(ushf*)(match+best_len-1) != scan_end ||
|
||||
* *(ushf*)match != scan_start) continue;
|
||||
* [...]
|
||||
* } while ((cur_match = prev[cur_match & wmask]) > limit
|
||||
* && --chain_length != 0);
|
||||
*
|
||||
* Here is the inner loop of the function. The function will spend the
|
||||
* majority of its time in this loop, and majority of that time will
|
||||
* be spent in the first ten instructions.
|
||||
*
|
||||
* Within this loop:
|
||||
* %ebx = scanend
|
||||
* %ecx = curmatch
|
||||
* %edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)
|
||||
* %esi = windowbestlen - i.e., (window + bestlen)
|
||||
* %edi = prev
|
||||
* %ebp = limit
|
||||
*/
|
||||
LookupLoop:
|
||||
andl %edx, %ecx
|
||||
movzwl (%edi,%ecx,2), %ecx
|
||||
cmpl %ebp, %ecx
|
||||
jbe LeaveNow
|
||||
subl $0x00010000, %edx
|
||||
js LeaveNow
|
||||
LoopEntry: movzwl -1(%esi,%ecx), %eax
|
||||
cmpl %ebx, %eax
|
||||
jnz LookupLoop
|
||||
movl window(%esp), %eax
|
||||
movzwl (%eax,%ecx), %eax
|
||||
cmpl scanstart(%esp), %eax
|
||||
jnz LookupLoop
|
||||
|
||||
/* Store the current value of chainlen. */
|
||||
|
||||
movl %edx, chainlenwmask(%esp)
|
||||
|
||||
/* Point %edi to the string under scrutiny, and %esi to the string we */
|
||||
/* are hoping to match it up with. In actuality, %esi and %edi are */
|
||||
/* both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and %edx is */
|
||||
/* initialized to -(MAX_MATCH_8 - scanalign). */
|
||||
|
||||
movl window(%esp), %esi
|
||||
movl scan(%esp), %edi
|
||||
addl %ecx, %esi
|
||||
movl scanalign(%esp), %eax
|
||||
movl $(-MAX_MATCH_8), %edx
|
||||
lea MAX_MATCH_8(%edi,%eax), %edi
|
||||
lea MAX_MATCH_8(%esi,%eax), %esi
|
||||
|
||||
/* Test the strings for equality, 8 bytes at a time. At the end,
|
||||
* adjust %edx so that it is offset to the exact byte that mismatched.
|
||||
*
|
||||
* We already know at this point that the first three bytes of the
|
||||
* strings match each other, and they can be safely passed over before
|
||||
* starting the compare loop. So what this code does is skip over 0-3
|
||||
* bytes, as much as necessary in order to dword-align the %edi
|
||||
* pointer. (%esi will still be misaligned three times out of four.)
|
||||
*
|
||||
* It should be confessed that this loop usually does not represent
|
||||
* much of the total running time. Replacing it with a more
|
||||
* straightforward "rep cmpsb" would not drastically degrade
|
||||
* performance.
|
||||
*/
|
||||
LoopCmps:
|
||||
movl (%esi,%edx), %eax
|
||||
xorl (%edi,%edx), %eax
|
||||
jnz LeaveLoopCmps
|
||||
movl 4(%esi,%edx), %eax
|
||||
xorl 4(%edi,%edx), %eax
|
||||
jnz LeaveLoopCmps4
|
||||
addl $8, %edx
|
||||
jnz LoopCmps
|
||||
jmp LenMaximum
|
||||
LeaveLoopCmps4: addl $4, %edx
|
||||
LeaveLoopCmps: testl $0x0000FFFF, %eax
|
||||
jnz LenLower
|
||||
addl $2, %edx
|
||||
shrl $16, %eax
|
||||
LenLower: subb $1, %al
|
||||
adcl $0, %edx
|
||||
|
||||
/* Calculate the length of the match. If it is longer than MAX_MATCH, */
|
||||
/* then automatically accept it as the best possible match and leave. */
|
||||
|
||||
lea (%edi,%edx), %eax
|
||||
movl scan(%esp), %edi
|
||||
subl %edi, %eax
|
||||
cmpl $MAX_MATCH, %eax
|
||||
jge LenMaximum
|
||||
|
||||
/* If the length of the match is not longer than the best match we */
|
||||
/* have so far, then forget it and return to the lookup loop. */
|
||||
|
||||
movl deflatestate(%esp), %edx
|
||||
movl bestlen(%esp), %ebx
|
||||
cmpl %ebx, %eax
|
||||
jg LongerMatch
|
||||
movl windowbestlen(%esp), %esi
|
||||
movl dsPrev(%edx), %edi
|
||||
movl scanend(%esp), %ebx
|
||||
movl chainlenwmask(%esp), %edx
|
||||
jmp LookupLoop
|
||||
|
||||
/* s->match_start = cur_match; */
|
||||
/* best_len = len; */
|
||||
/* if (len >= nice_match) break; */
|
||||
/* scan_end = *(ushf*)(scan+best_len-1); */
|
||||
|
||||
LongerMatch: movl nicematch(%esp), %ebx
|
||||
movl %eax, bestlen(%esp)
|
||||
movl %ecx, dsMatchStart(%edx)
|
||||
cmpl %ebx, %eax
|
||||
jge LeaveNow
|
||||
movl window(%esp), %esi
|
||||
addl %eax, %esi
|
||||
movl %esi, windowbestlen(%esp)
|
||||
movzwl -1(%edi,%eax), %ebx
|
||||
movl dsPrev(%edx), %edi
|
||||
movl %ebx, scanend(%esp)
|
||||
movl chainlenwmask(%esp), %edx
|
||||
jmp LookupLoop
|
||||
|
||||
/* Accept the current string, with the maximum possible length. */
|
||||
|
||||
LenMaximum: movl deflatestate(%esp), %edx
|
||||
movl $MAX_MATCH, bestlen(%esp)
|
||||
movl %ecx, dsMatchStart(%edx)
|
||||
|
||||
/* if ((uInt)best_len <= s->lookahead) return (uInt)best_len; */
|
||||
/* return s->lookahead; */
|
||||
|
||||
LeaveNow:
|
||||
movl deflatestate(%esp), %edx
|
||||
movl bestlen(%esp), %ebx
|
||||
movl dsLookahead(%edx), %eax
|
||||
cmpl %eax, %ebx
|
||||
jg LookaheadRet
|
||||
movl %ebx, %eax
|
||||
LookaheadRet:
|
||||
|
||||
/* Restore the stack and return from whence we came. */
|
||||
|
||||
addl $LocalVarsSize, %esp
|
||||
popl %ebx
|
||||
popl %esi
|
||||
popl %edi
|
||||
popl %ebp
|
||||
match_init: ret
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
blast: blast.c blast.h
|
||||
cc -DTEST -o blast blast.c
|
||||
|
||||
test: blast
|
||||
blast < test.pk | cmp - test.txt
|
||||
|
||||
clean:
|
||||
rm -f blast blast.o
|
||||
|
|
@ -1,4 +0,0 @@
|
|||
Read blast.h for purpose and usage.
|
||||
|
||||
Mark Adler
|
||||
madler@alumni.caltech.edu
|
||||
|
|
@ -1,444 +0,0 @@
|
|||
/* blast.c
|
||||
* Copyright (C) 2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in blast.h
|
||||
* version 1.1, 16 Feb 2003
|
||||
*
|
||||
* blast.c decompresses data compressed by the PKWare Compression Library.
|
||||
* This function provides functionality similar to the explode() function of
|
||||
* the PKWare library, hence the name "blast".
|
||||
*
|
||||
* This decompressor is based on the excellent format description provided by
|
||||
* Ben Rudiak-Gould in comp.compression on August 13, 2001. Interestingly, the
|
||||
* example Ben provided in the post is incorrect. The distance 110001 should
|
||||
* instead be 111000. When corrected, the example byte stream becomes:
|
||||
*
|
||||
* 00 04 82 24 25 8f 80 7f
|
||||
*
|
||||
* which decompresses to "AIAIAIAIAIAIA" (without the quotes).
|
||||
*/
|
||||
|
||||
/*
|
||||
* Change history:
|
||||
*
|
||||
* 1.0 12 Feb 2003 - First version
|
||||
* 1.1 16 Feb 2003 - Fixed distance check for > 4 GB uncompressed data
|
||||
*/
|
||||
|
||||
#include <setjmp.h> /* for setjmp(), longjmp(), and jmp_buf */
|
||||
#include "blast.h" /* prototype for blast() */
|
||||
|
||||
#define local static /* for local function definitions */
|
||||
#define MAXBITS 13 /* maximum code length */
|
||||
#define MAXWIN 4096 /* maximum window size */
|
||||
|
||||
/* input and output state */
|
||||
struct state {
|
||||
/* input state */
|
||||
blast_in infun; /* input function provided by user */
|
||||
void *inhow; /* opaque information passed to infun() */
|
||||
unsigned char *in; /* next input location */
|
||||
unsigned left; /* available input at in */
|
||||
int bitbuf; /* bit buffer */
|
||||
int bitcnt; /* number of bits in bit buffer */
|
||||
|
||||
/* input limit error return state for bits() and decode() */
|
||||
jmp_buf env;
|
||||
|
||||
/* output state */
|
||||
blast_out outfun; /* output function provided by user */
|
||||
void *outhow; /* opaque information passed to outfun() */
|
||||
unsigned next; /* index of next write location in out[] */
|
||||
int first; /* true to check distances (for first 4K) */
|
||||
unsigned char out[MAXWIN]; /* output buffer and sliding window */
|
||||
};
|
||||
|
||||
/*
|
||||
* Return need bits from the input stream. This always leaves less than
|
||||
* eight bits in the buffer. bits() works properly for need == 0.
|
||||
*
|
||||
* Format notes:
|
||||
*
|
||||
* - Bits are stored in bytes from the least significant bit to the most
|
||||
* significant bit. Therefore bits are dropped from the bottom of the bit
|
||||
* buffer, using shift right, and new bytes are appended to the top of the
|
||||
* bit buffer, using shift left.
|
||||
*/
|
||||
local int bits(struct state *s, int need)
|
||||
{
|
||||
int val; /* bit accumulator */
|
||||
|
||||
/* load at least need bits into val */
|
||||
val = s->bitbuf;
|
||||
while (s->bitcnt < need) {
|
||||
if (s->left == 0) {
|
||||
s->left = s->infun(s->inhow, &(s->in));
|
||||
if (s->left == 0) longjmp(s->env, 1); /* out of input */
|
||||
}
|
||||
val |= (int)(*(s->in)++) << s->bitcnt; /* load eight bits */
|
||||
s->left--;
|
||||
s->bitcnt += 8;
|
||||
}
|
||||
|
||||
/* drop need bits and update buffer, always zero to seven bits left */
|
||||
s->bitbuf = val >> need;
|
||||
s->bitcnt -= need;
|
||||
|
||||
/* return need bits, zeroing the bits above that */
|
||||
return val & ((1 << need) - 1);
|
||||
}
|
||||
|
||||
/*
|
||||
* Huffman code decoding tables. count[1..MAXBITS] is the number of symbols of
|
||||
* each length, which for a canonical code are stepped through in order.
|
||||
* symbol[] are the symbol values in canonical order, where the number of
|
||||
* entries is the sum of the counts in count[]. The decoding process can be
|
||||
* seen in the function decode() below.
|
||||
*/
|
||||
struct huffman {
|
||||
short *count; /* number of symbols of each length */
|
||||
short *symbol; /* canonically ordered symbols */
|
||||
};
|
||||
|
||||
/*
|
||||
* Decode a code from the stream s using huffman table h. Return the symbol or
|
||||
* a negative value if there is an error. If all of the lengths are zero, i.e.
|
||||
* an empty code, or if the code is incomplete and an invalid code is received,
|
||||
* then -9 is returned after reading MAXBITS bits.
|
||||
*
|
||||
* Format notes:
|
||||
*
|
||||
* - The codes as stored in the compressed data are bit-reversed relative to
|
||||
* a simple integer ordering of codes of the same lengths. Hence below the
|
||||
* bits are pulled from the compressed data one at a time and used to
|
||||
* build the code value reversed from what is in the stream in order to
|
||||
* permit simple integer comparisons for decoding.
|
||||
*
|
||||
* - The first code for the shortest length is all ones. Subsequent codes of
|
||||
* the same length are simply integer decrements of the previous code. When
|
||||
* moving up a length, a one bit is appended to the code. For a complete
|
||||
* code, the last code of the longest length will be all zeros. To support
|
||||
* this ordering, the bits pulled during decoding are inverted to apply the
|
||||
* more "natural" ordering starting with all zeros and incrementing.
|
||||
*/
|
||||
local int decode(struct state *s, struct huffman *h)
|
||||
{
|
||||
int len; /* current number of bits in code */
|
||||
int code; /* len bits being decoded */
|
||||
int first; /* first code of length len */
|
||||
int count; /* number of codes of length len */
|
||||
int index; /* index of first code of length len in symbol table */
|
||||
int bitbuf; /* bits from stream */
|
||||
int left; /* bits left in next or left to process */
|
||||
short *next; /* next number of codes */
|
||||
|
||||
bitbuf = s->bitbuf;
|
||||
left = s->bitcnt;
|
||||
code = first = index = 0;
|
||||
len = 1;
|
||||
next = h->count + 1;
|
||||
while (1) {
|
||||
while (left--) {
|
||||
code |= (bitbuf & 1) ^ 1; /* invert code */
|
||||
bitbuf >>= 1;
|
||||
count = *next++;
|
||||
if (code < first + count) { /* if length len, return symbol */
|
||||
s->bitbuf = bitbuf;
|
||||
s->bitcnt = (s->bitcnt - len) & 7;
|
||||
return h->symbol[index + (code - first)];
|
||||
}
|
||||
index += count; /* else update for next length */
|
||||
first += count;
|
||||
first <<= 1;
|
||||
code <<= 1;
|
||||
len++;
|
||||
}
|
||||
left = (MAXBITS+1) - len;
|
||||
if (left == 0) break;
|
||||
if (s->left == 0) {
|
||||
s->left = s->infun(s->inhow, &(s->in));
|
||||
if (s->left == 0) longjmp(s->env, 1); /* out of input */
|
||||
}
|
||||
bitbuf = *(s->in)++;
|
||||
s->left--;
|
||||
if (left > 8) left = 8;
|
||||
}
|
||||
return -9; /* ran out of codes */
|
||||
}
|
||||
|
||||
/*
|
||||
* Given a list of repeated code lengths rep[0..n-1], where each byte is a
|
||||
* count (high four bits + 1) and a code length (low four bits), generate the
|
||||
* list of code lengths. This compaction reduces the size of the object code.
|
||||
* Then given the list of code lengths length[0..n-1] representing a canonical
|
||||
* Huffman code for n symbols, construct the tables required to decode those
|
||||
* codes. Those tables are the number of codes of each length, and the symbols
|
||||
* sorted by length, retaining their original order within each length. The
|
||||
* return value is zero for a complete code set, negative for an over-
|
||||
* subscribed code set, and positive for an incomplete code set. The tables
|
||||
* can be used if the return value is zero or positive, but they cannot be used
|
||||
* if the return value is negative. If the return value is zero, it is not
|
||||
* possible for decode() using that table to return an error--any stream of
|
||||
* enough bits will resolve to a symbol. If the return value is positive, then
|
||||
* it is possible for decode() using that table to return an error for received
|
||||
* codes past the end of the incomplete lengths.
|
||||
*/
|
||||
local int construct(struct huffman *h, const unsigned char *rep, int n)
|
||||
{
|
||||
int symbol; /* current symbol when stepping through length[] */
|
||||
int len; /* current length when stepping through h->count[] */
|
||||
int left; /* number of possible codes left of current length */
|
||||
short offs[MAXBITS+1]; /* offsets in symbol table for each length */
|
||||
short length[256]; /* code lengths */
|
||||
|
||||
/* convert compact repeat counts into symbol bit length list */
|
||||
symbol = 0;
|
||||
do {
|
||||
len = *rep++;
|
||||
left = (len >> 4) + 1;
|
||||
len &= 15;
|
||||
do {
|
||||
length[symbol++] = len;
|
||||
} while (--left);
|
||||
} while (--n);
|
||||
n = symbol;
|
||||
|
||||
/* count number of codes of each length */
|
||||
for (len = 0; len <= MAXBITS; len++)
|
||||
h->count[len] = 0;
|
||||
for (symbol = 0; symbol < n; symbol++)
|
||||
(h->count[length[symbol]])++; /* assumes lengths are within bounds */
|
||||
if (h->count[0] == n) /* no codes! */
|
||||
return 0; /* complete, but decode() will fail */
|
||||
|
||||
/* check for an over-subscribed or incomplete set of lengths */
|
||||
left = 1; /* one possible code of zero length */
|
||||
for (len = 1; len <= MAXBITS; len++) {
|
||||
left <<= 1; /* one more bit, double codes left */
|
||||
left -= h->count[len]; /* deduct count from possible codes */
|
||||
if (left < 0) return left; /* over-subscribed--return negative */
|
||||
} /* left > 0 means incomplete */
|
||||
|
||||
/* generate offsets into symbol table for each length for sorting */
|
||||
offs[1] = 0;
|
||||
for (len = 1; len < MAXBITS; len++)
|
||||
offs[len + 1] = offs[len] + h->count[len];
|
||||
|
||||
/*
|
||||
* put symbols in table sorted by length, by symbol order within each
|
||||
* length
|
||||
*/
|
||||
for (symbol = 0; symbol < n; symbol++)
|
||||
if (length[symbol] != 0)
|
||||
h->symbol[offs[length[symbol]]++] = symbol;
|
||||
|
||||
/* return zero for complete set, positive for incomplete set */
|
||||
return left;
|
||||
}
|
||||
|
||||
/*
|
||||
* Decode PKWare Compression Library stream.
|
||||
*
|
||||
* Format notes:
|
||||
*
|
||||
* - First byte is 0 if literals are uncoded or 1 if they are coded. Second
|
||||
* byte is 4, 5, or 6 for the number of extra bits in the distance code.
|
||||
* This is the base-2 logarithm of the dictionary size minus six.
|
||||
*
|
||||
* - Compressed data is a combination of literals and length/distance pairs
|
||||
* terminated by an end code. Literals are either Huffman coded or
|
||||
* uncoded bytes. A length/distance pair is a coded length followed by a
|
||||
* coded distance to represent a string that occurs earlier in the
|
||||
* uncompressed data that occurs again at the current location.
|
||||
*
|
||||
* - A bit preceding a literal or length/distance pair indicates which comes
|
||||
* next, 0 for literals, 1 for length/distance.
|
||||
*
|
||||
* - If literals are uncoded, then the next eight bits are the literal, in the
|
||||
* normal bit order in th stream, i.e. no bit-reversal is needed. Similarly,
|
||||
* no bit reversal is needed for either the length extra bits or the distance
|
||||
* extra bits.
|
||||
*
|
||||
* - Literal bytes are simply written to the output. A length/distance pair is
|
||||
* an instruction to copy previously uncompressed bytes to the output. The
|
||||
* copy is from distance bytes back in the output stream, copying for length
|
||||
* bytes.
|
||||
*
|
||||
* - Distances pointing before the beginning of the output data are not
|
||||
* permitted.
|
||||
*
|
||||
* - Overlapped copies, where the length is greater than the distance, are
|
||||
* allowed and common. For example, a distance of one and a length of 518
|
||||
* simply copies the last byte 518 times. A distance of four and a length of
|
||||
* twelve copies the last four bytes three times. A simple forward copy
|
||||
* ignoring whether the length is greater than the distance or not implements
|
||||
* this correctly.
|
||||
*/
|
||||
local int decomp(struct state *s)
|
||||
{
|
||||
int lit; /* true if literals are coded */
|
||||
int dict; /* log2(dictionary size) - 6 */
|
||||
int symbol; /* decoded symbol, extra bits for distance */
|
||||
int len; /* length for copy */
|
||||
int dist; /* distance for copy */
|
||||
int copy; /* copy counter */
|
||||
unsigned char *from, *to; /* copy pointers */
|
||||
static int virgin = 1; /* build tables once */
|
||||
static short litcnt[MAXBITS+1], litsym[256]; /* litcode memory */
|
||||
static short lencnt[MAXBITS+1], lensym[16]; /* lencode memory */
|
||||
static short distcnt[MAXBITS+1], distsym[64]; /* distcode memory */
|
||||
static struct huffman litcode = {litcnt, litsym}; /* length code */
|
||||
static struct huffman lencode = {lencnt, lensym}; /* length code */
|
||||
static struct huffman distcode = {distcnt, distsym};/* distance code */
|
||||
/* bit lengths of literal codes */
|
||||
static const unsigned char litlen[] = {
|
||||
11, 124, 8, 7, 28, 7, 188, 13, 76, 4, 10, 8, 12, 10, 12, 10, 8, 23, 8,
|
||||
9, 7, 6, 7, 8, 7, 6, 55, 8, 23, 24, 12, 11, 7, 9, 11, 12, 6, 7, 22, 5,
|
||||
7, 24, 6, 11, 9, 6, 7, 22, 7, 11, 38, 7, 9, 8, 25, 11, 8, 11, 9, 12,
|
||||
8, 12, 5, 38, 5, 38, 5, 11, 7, 5, 6, 21, 6, 10, 53, 8, 7, 24, 10, 27,
|
||||
44, 253, 253, 253, 252, 252, 252, 13, 12, 45, 12, 45, 12, 61, 12, 45,
|
||||
44, 173};
|
||||
/* bit lengths of length codes 0..15 */
|
||||
static const unsigned char lenlen[] = {2, 35, 36, 53, 38, 23};
|
||||
/* bit lengths of distance codes 0..63 */
|
||||
static const unsigned char distlen[] = {2, 20, 53, 230, 247, 151, 248};
|
||||
static const short base[16] = { /* base for length codes */
|
||||
3, 2, 4, 5, 6, 7, 8, 9, 10, 12, 16, 24, 40, 72, 136, 264};
|
||||
static const char extra[16] = { /* extra bits for length codes */
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8};
|
||||
|
||||
/* set up decoding tables (once--might not be thread-safe) */
|
||||
if (virgin) {
|
||||
construct(&litcode, litlen, sizeof(litlen));
|
||||
construct(&lencode, lenlen, sizeof(lenlen));
|
||||
construct(&distcode, distlen, sizeof(distlen));
|
||||
virgin = 0;
|
||||
}
|
||||
|
||||
/* read header */
|
||||
lit = bits(s, 8);
|
||||
if (lit > 1) return -1;
|
||||
dict = bits(s, 8);
|
||||
if (dict < 4 || dict > 6) return -2;
|
||||
|
||||
/* decode literals and length/distance pairs */
|
||||
do {
|
||||
if (bits(s, 1)) {
|
||||
/* get length */
|
||||
symbol = decode(s, &lencode);
|
||||
len = base[symbol] + bits(s, extra[symbol]);
|
||||
if (len == 519) break; /* end code */
|
||||
|
||||
/* get distance */
|
||||
symbol = len == 2 ? 2 : dict;
|
||||
dist = decode(s, &distcode) << symbol;
|
||||
dist += bits(s, symbol);
|
||||
dist++;
|
||||
if (s->first && dist > s->next)
|
||||
return -3; /* distance too far back */
|
||||
|
||||
/* copy length bytes from distance bytes back */
|
||||
do {
|
||||
to = s->out + s->next;
|
||||
from = to - dist;
|
||||
copy = MAXWIN;
|
||||
if (s->next < dist) {
|
||||
from += copy;
|
||||
copy = dist;
|
||||
}
|
||||
copy -= s->next;
|
||||
if (copy > len) copy = len;
|
||||
len -= copy;
|
||||
s->next += copy;
|
||||
do {
|
||||
*to++ = *from++;
|
||||
} while (--copy);
|
||||
if (s->next == MAXWIN) {
|
||||
if (s->outfun(s->outhow, s->out, s->next)) return 1;
|
||||
s->next = 0;
|
||||
s->first = 0;
|
||||
}
|
||||
} while (len != 0);
|
||||
}
|
||||
else {
|
||||
/* get literal and write it */
|
||||
symbol = lit ? decode(s, &litcode) : bits(s, 8);
|
||||
s->out[s->next++] = symbol;
|
||||
if (s->next == MAXWIN) {
|
||||
if (s->outfun(s->outhow, s->out, s->next)) return 1;
|
||||
s->next = 0;
|
||||
s->first = 0;
|
||||
}
|
||||
}
|
||||
} while (1);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* See comments in blast.h */
|
||||
int blast(blast_in infun, void *inhow, blast_out outfun, void *outhow)
|
||||
{
|
||||
struct state s; /* input/output state */
|
||||
int err; /* return value */
|
||||
|
||||
/* initialize input state */
|
||||
s.infun = infun;
|
||||
s.inhow = inhow;
|
||||
s.left = 0;
|
||||
s.bitbuf = 0;
|
||||
s.bitcnt = 0;
|
||||
|
||||
/* initialize output state */
|
||||
s.outfun = outfun;
|
||||
s.outhow = outhow;
|
||||
s.next = 0;
|
||||
s.first = 1;
|
||||
|
||||
/* return if bits() or decode() tries to read past available input */
|
||||
if (setjmp(s.env) != 0) /* if came back here via longjmp(), */
|
||||
err = 2; /* then skip decomp(), return error */
|
||||
else
|
||||
err = decomp(&s); /* decompress */
|
||||
|
||||
/* write any leftover output and update the error code if needed */
|
||||
if (err != 1 && s.next && s.outfun(s.outhow, s.out, s.next) && err == 0)
|
||||
err = 1;
|
||||
return err;
|
||||
}
|
||||
|
||||
#ifdef TEST
|
||||
/* Example of how to use blast() */
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#define CHUNK 16384
|
||||
|
||||
local unsigned inf(void *how, unsigned char **buf)
|
||||
{
|
||||
static unsigned char hold[CHUNK];
|
||||
|
||||
*buf = hold;
|
||||
return fread(hold, 1, CHUNK, (FILE *)how);
|
||||
}
|
||||
|
||||
local int outf(void *how, unsigned char *buf, unsigned len)
|
||||
{
|
||||
return fwrite(buf, 1, len, (FILE *)how) != len;
|
||||
}
|
||||
|
||||
/* Decompress a PKWare Compression Library stream from stdin to stdout */
|
||||
int main(void)
|
||||
{
|
||||
int ret, n;
|
||||
|
||||
/* decompress to stdout */
|
||||
ret = blast(inf, stdin, outf, stdout);
|
||||
if (ret != 0) fprintf(stderr, "blast error: %d\n", ret);
|
||||
|
||||
/* see if there are any leftover bytes */
|
||||
n = 0;
|
||||
while (getchar() != EOF) n++;
|
||||
if (n) fprintf(stderr, "blast warning: %d unused bytes of input\n", n);
|
||||
|
||||
/* return blast() error code */
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,71 +0,0 @@
|
|||
/* blast.h -- interface for blast.c
|
||||
Copyright (C) 2003 Mark Adler
|
||||
version 1.1, 16 Feb 2003
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the author be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
|
||||
Mark Adler madler@alumni.caltech.edu
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* blast() decompresses the PKWare Data Compression Library (DCL) compressed
|
||||
* format. It provides the same functionality as the explode() function in
|
||||
* that library. (Note: PKWare overused the "implode" verb, and the format
|
||||
* used by their library implode() function is completely different and
|
||||
* incompatible with the implode compression method supported by PKZIP.)
|
||||
*/
|
||||
|
||||
|
||||
typedef unsigned (*blast_in)(void *how, unsigned char **buf);
|
||||
typedef int (*blast_out)(void *how, unsigned char *buf, unsigned len);
|
||||
/* Definitions for input/output functions passed to blast(). See below for
|
||||
* what the provided functions need to do.
|
||||
*/
|
||||
|
||||
|
||||
int blast(blast_in infun, void *inhow, blast_out outfun, void *outhow);
|
||||
/* Decompress input to output using the provided infun() and outfun() calls.
|
||||
* On success, the return value of blast() is zero. If there is an error in
|
||||
* the source data, i.e. it is not in the proper format, then a negative value
|
||||
* is returned. If there is not enough input available or there is not enough
|
||||
* output space, then a positive error is returned.
|
||||
*
|
||||
* The input function is invoked: len = infun(how, &buf), where buf is set by
|
||||
* infun() to point to the input buffer, and infun() returns the number of
|
||||
* available bytes there. If infun() returns zero, then blast() returns with
|
||||
* an input error. (blast() only asks for input if it needs it.) inhow is for
|
||||
* use by the application to pass an input descriptor to infun(), if desired.
|
||||
*
|
||||
* The output function is invoked: err = outfun(how, buf, len), where the bytes
|
||||
* to be written are buf[0..len-1]. If err is not zero, then blast() returns
|
||||
* with an output error. outfun() is always called with len <= 4096. outhow
|
||||
* is for use by the application to pass an output descriptor to outfun(), if
|
||||
* desired.
|
||||
*
|
||||
* The return codes are:
|
||||
*
|
||||
* 2: ran out of input before completing decompression
|
||||
* 1: output error before completing decompression
|
||||
* 0: successful decompression
|
||||
* -1: literal flag not zero or one
|
||||
* -2: dictionary size not in 4..6
|
||||
* -3: distance is too far back
|
||||
*
|
||||
* At the bottom of blast.c is an example program that uses blast() that can be
|
||||
* compiled to produce a command-line decompression filter by defining TEST.
|
||||
*/
|
||||
Binary file not shown.
|
|
@ -1 +0,0 @@
|
|||
AIAIAIAIAIAIA
|
||||
|
|
@ -1,557 +0,0 @@
|
|||
{*******************************************************}
|
||||
{ }
|
||||
{ Borland Delphi Supplemental Components }
|
||||
{ ZLIB Data Compression Interface Unit }
|
||||
{ }
|
||||
{ Copyright (c) 1997,99 Borland Corporation }
|
||||
{ }
|
||||
{*******************************************************}
|
||||
|
||||
{ Updated for zlib 1.2.x by Cosmin Truta <cosmint@cs.ubbcluj.ro> }
|
||||
|
||||
unit ZLib;
|
||||
|
||||
interface
|
||||
|
||||
uses SysUtils, Classes;
|
||||
|
||||
type
|
||||
TAlloc = function (AppData: Pointer; Items, Size: Integer): Pointer; cdecl;
|
||||
TFree = procedure (AppData, Block: Pointer); cdecl;
|
||||
|
||||
// Internal structure. Ignore.
|
||||
TZStreamRec = packed record
|
||||
next_in: PChar; // next input byte
|
||||
avail_in: Integer; // number of bytes available at next_in
|
||||
total_in: Longint; // total nb of input bytes read so far
|
||||
|
||||
next_out: PChar; // next output byte should be put here
|
||||
avail_out: Integer; // remaining free space at next_out
|
||||
total_out: Longint; // total nb of bytes output so far
|
||||
|
||||
msg: PChar; // last error message, NULL if no error
|
||||
internal: Pointer; // not visible by applications
|
||||
|
||||
zalloc: TAlloc; // used to allocate the internal state
|
||||
zfree: TFree; // used to free the internal state
|
||||
AppData: Pointer; // private data object passed to zalloc and zfree
|
||||
|
||||
data_type: Integer; // best guess about the data type: ascii or binary
|
||||
adler: Longint; // adler32 value of the uncompressed data
|
||||
reserved: Longint; // reserved for future use
|
||||
end;
|
||||
|
||||
// Abstract ancestor class
|
||||
TCustomZlibStream = class(TStream)
|
||||
private
|
||||
FStrm: TStream;
|
||||
FStrmPos: Integer;
|
||||
FOnProgress: TNotifyEvent;
|
||||
FZRec: TZStreamRec;
|
||||
FBuffer: array [Word] of Char;
|
||||
protected
|
||||
procedure Progress(Sender: TObject); dynamic;
|
||||
property OnProgress: TNotifyEvent read FOnProgress write FOnProgress;
|
||||
constructor Create(Strm: TStream);
|
||||
end;
|
||||
|
||||
{ TCompressionStream compresses data on the fly as data is written to it, and
|
||||
stores the compressed data to another stream.
|
||||
|
||||
TCompressionStream is write-only and strictly sequential. Reading from the
|
||||
stream will raise an exception. Using Seek to move the stream pointer
|
||||
will raise an exception.
|
||||
|
||||
Output data is cached internally, written to the output stream only when
|
||||
the internal output buffer is full. All pending output data is flushed
|
||||
when the stream is destroyed.
|
||||
|
||||
The Position property returns the number of uncompressed bytes of
|
||||
data that have been written to the stream so far.
|
||||
|
||||
CompressionRate returns the on-the-fly percentage by which the original
|
||||
data has been compressed: (1 - (CompressedBytes / UncompressedBytes)) * 100
|
||||
If raw data size = 100 and compressed data size = 25, the CompressionRate
|
||||
is 75%
|
||||
|
||||
The OnProgress event is called each time the output buffer is filled and
|
||||
written to the output stream. This is useful for updating a progress
|
||||
indicator when you are writing a large chunk of data to the compression
|
||||
stream in a single call.}
|
||||
|
||||
|
||||
TCompressionLevel = (clNone, clFastest, clDefault, clMax);
|
||||
|
||||
TCompressionStream = class(TCustomZlibStream)
|
||||
private
|
||||
function GetCompressionRate: Single;
|
||||
public
|
||||
constructor Create(CompressionLevel: TCompressionLevel; Dest: TStream);
|
||||
destructor Destroy; override;
|
||||
function Read(var Buffer; Count: Longint): Longint; override;
|
||||
function Write(const Buffer; Count: Longint): Longint; override;
|
||||
function Seek(Offset: Longint; Origin: Word): Longint; override;
|
||||
property CompressionRate: Single read GetCompressionRate;
|
||||
property OnProgress;
|
||||
end;
|
||||
|
||||
{ TDecompressionStream decompresses data on the fly as data is read from it.
|
||||
|
||||
Compressed data comes from a separate source stream. TDecompressionStream
|
||||
is read-only and unidirectional; you can seek forward in the stream, but not
|
||||
backwards. The special case of setting the stream position to zero is
|
||||
allowed. Seeking forward decompresses data until the requested position in
|
||||
the uncompressed data has been reached. Seeking backwards, seeking relative
|
||||
to the end of the stream, requesting the size of the stream, and writing to
|
||||
the stream will raise an exception.
|
||||
|
||||
The Position property returns the number of bytes of uncompressed data that
|
||||
have been read from the stream so far.
|
||||
|
||||
The OnProgress event is called each time the internal input buffer of
|
||||
compressed data is exhausted and the next block is read from the input stream.
|
||||
This is useful for updating a progress indicator when you are reading a
|
||||
large chunk of data from the decompression stream in a single call.}
|
||||
|
||||
TDecompressionStream = class(TCustomZlibStream)
|
||||
public
|
||||
constructor Create(Source: TStream);
|
||||
destructor Destroy; override;
|
||||
function Read(var Buffer; Count: Longint): Longint; override;
|
||||
function Write(const Buffer; Count: Longint): Longint; override;
|
||||
function Seek(Offset: Longint; Origin: Word): Longint; override;
|
||||
property OnProgress;
|
||||
end;
|
||||
|
||||
|
||||
|
||||
{ CompressBuf compresses data, buffer to buffer, in one call.
|
||||
In: InBuf = ptr to compressed data
|
||||
InBytes = number of bytes in InBuf
|
||||
Out: OutBuf = ptr to newly allocated buffer containing decompressed data
|
||||
OutBytes = number of bytes in OutBuf }
|
||||
procedure CompressBuf(const InBuf: Pointer; InBytes: Integer;
|
||||
out OutBuf: Pointer; out OutBytes: Integer);
|
||||
|
||||
|
||||
{ DecompressBuf decompresses data, buffer to buffer, in one call.
|
||||
In: InBuf = ptr to compressed data
|
||||
InBytes = number of bytes in InBuf
|
||||
OutEstimate = zero, or est. size of the decompressed data
|
||||
Out: OutBuf = ptr to newly allocated buffer containing decompressed data
|
||||
OutBytes = number of bytes in OutBuf }
|
||||
procedure DecompressBuf(const InBuf: Pointer; InBytes: Integer;
|
||||
OutEstimate: Integer; out OutBuf: Pointer; out OutBytes: Integer);
|
||||
|
||||
{ DecompressToUserBuf decompresses data, buffer to buffer, in one call.
|
||||
In: InBuf = ptr to compressed data
|
||||
InBytes = number of bytes in InBuf
|
||||
Out: OutBuf = ptr to user-allocated buffer to contain decompressed data
|
||||
BufSize = number of bytes in OutBuf }
|
||||
procedure DecompressToUserBuf(const InBuf: Pointer; InBytes: Integer;
|
||||
const OutBuf: Pointer; BufSize: Integer);
|
||||
|
||||
const
|
||||
zlib_version = '1.2.1';
|
||||
|
||||
type
|
||||
EZlibError = class(Exception);
|
||||
ECompressionError = class(EZlibError);
|
||||
EDecompressionError = class(EZlibError);
|
||||
|
||||
implementation
|
||||
|
||||
uses ZLibConst;
|
||||
|
||||
const
|
||||
Z_NO_FLUSH = 0;
|
||||
Z_PARTIAL_FLUSH = 1;
|
||||
Z_SYNC_FLUSH = 2;
|
||||
Z_FULL_FLUSH = 3;
|
||||
Z_FINISH = 4;
|
||||
|
||||
Z_OK = 0;
|
||||
Z_STREAM_END = 1;
|
||||
Z_NEED_DICT = 2;
|
||||
Z_ERRNO = (-1);
|
||||
Z_STREAM_ERROR = (-2);
|
||||
Z_DATA_ERROR = (-3);
|
||||
Z_MEM_ERROR = (-4);
|
||||
Z_BUF_ERROR = (-5);
|
||||
Z_VERSION_ERROR = (-6);
|
||||
|
||||
Z_NO_COMPRESSION = 0;
|
||||
Z_BEST_SPEED = 1;
|
||||
Z_BEST_COMPRESSION = 9;
|
||||
Z_DEFAULT_COMPRESSION = (-1);
|
||||
|
||||
Z_FILTERED = 1;
|
||||
Z_HUFFMAN_ONLY = 2;
|
||||
Z_RLE = 3;
|
||||
Z_DEFAULT_STRATEGY = 0;
|
||||
|
||||
Z_BINARY = 0;
|
||||
Z_ASCII = 1;
|
||||
Z_UNKNOWN = 2;
|
||||
|
||||
Z_DEFLATED = 8;
|
||||
|
||||
|
||||
{$L adler32.obj}
|
||||
{$L compress.obj}
|
||||
{$L crc32.obj}
|
||||
{$L deflate.obj}
|
||||
{$L infback.obj}
|
||||
{$L inffast.obj}
|
||||
{$L inflate.obj}
|
||||
{$L inftrees.obj}
|
||||
{$L trees.obj}
|
||||
{$L uncompr.obj}
|
||||
{$L zutil.obj}
|
||||
|
||||
procedure adler32; external;
|
||||
procedure compressBound; external;
|
||||
procedure crc32; external;
|
||||
procedure deflateInit2_; external;
|
||||
procedure deflateParams; external;
|
||||
|
||||
function _malloc(Size: Integer): Pointer; cdecl;
|
||||
begin
|
||||
Result := AllocMem(Size);
|
||||
end;
|
||||
|
||||
procedure _free(Block: Pointer); cdecl;
|
||||
begin
|
||||
FreeMem(Block);
|
||||
end;
|
||||
|
||||
procedure _memset(P: Pointer; B: Byte; count: Integer); cdecl;
|
||||
begin
|
||||
FillChar(P^, count, B);
|
||||
end;
|
||||
|
||||
procedure _memcpy(dest, source: Pointer; count: Integer); cdecl;
|
||||
begin
|
||||
Move(source^, dest^, count);
|
||||
end;
|
||||
|
||||
|
||||
|
||||
// deflate compresses data
|
||||
function deflateInit_(var strm: TZStreamRec; level: Integer; version: PChar;
|
||||
recsize: Integer): Integer; external;
|
||||
function deflate(var strm: TZStreamRec; flush: Integer): Integer; external;
|
||||
function deflateEnd(var strm: TZStreamRec): Integer; external;
|
||||
|
||||
// inflate decompresses data
|
||||
function inflateInit_(var strm: TZStreamRec; version: PChar;
|
||||
recsize: Integer): Integer; external;
|
||||
function inflate(var strm: TZStreamRec; flush: Integer): Integer; external;
|
||||
function inflateEnd(var strm: TZStreamRec): Integer; external;
|
||||
function inflateReset(var strm: TZStreamRec): Integer; external;
|
||||
|
||||
|
||||
function zlibAllocMem(AppData: Pointer; Items, Size: Integer): Pointer; cdecl;
|
||||
begin
|
||||
// GetMem(Result, Items*Size);
|
||||
Result := AllocMem(Items * Size);
|
||||
end;
|
||||
|
||||
procedure zlibFreeMem(AppData, Block: Pointer); cdecl;
|
||||
begin
|
||||
FreeMem(Block);
|
||||
end;
|
||||
|
||||
{function zlibCheck(code: Integer): Integer;
|
||||
begin
|
||||
Result := code;
|
||||
if code < 0 then
|
||||
raise EZlibError.Create('error'); //!!
|
||||
end;}
|
||||
|
||||
function CCheck(code: Integer): Integer;
|
||||
begin
|
||||
Result := code;
|
||||
if code < 0 then
|
||||
raise ECompressionError.Create('error'); //!!
|
||||
end;
|
||||
|
||||
function DCheck(code: Integer): Integer;
|
||||
begin
|
||||
Result := code;
|
||||
if code < 0 then
|
||||
raise EDecompressionError.Create('error'); //!!
|
||||
end;
|
||||
|
||||
procedure CompressBuf(const InBuf: Pointer; InBytes: Integer;
|
||||
out OutBuf: Pointer; out OutBytes: Integer);
|
||||
var
|
||||
strm: TZStreamRec;
|
||||
P: Pointer;
|
||||
begin
|
||||
FillChar(strm, sizeof(strm), 0);
|
||||
strm.zalloc := zlibAllocMem;
|
||||
strm.zfree := zlibFreeMem;
|
||||
OutBytes := ((InBytes + (InBytes div 10) + 12) + 255) and not 255;
|
||||
GetMem(OutBuf, OutBytes);
|
||||
try
|
||||
strm.next_in := InBuf;
|
||||
strm.avail_in := InBytes;
|
||||
strm.next_out := OutBuf;
|
||||
strm.avail_out := OutBytes;
|
||||
CCheck(deflateInit_(strm, Z_BEST_COMPRESSION, zlib_version, sizeof(strm)));
|
||||
try
|
||||
while CCheck(deflate(strm, Z_FINISH)) <> Z_STREAM_END do
|
||||
begin
|
||||
P := OutBuf;
|
||||
Inc(OutBytes, 256);
|
||||
ReallocMem(OutBuf, OutBytes);
|
||||
strm.next_out := PChar(Integer(OutBuf) + (Integer(strm.next_out) - Integer(P)));
|
||||
strm.avail_out := 256;
|
||||
end;
|
||||
finally
|
||||
CCheck(deflateEnd(strm));
|
||||
end;
|
||||
ReallocMem(OutBuf, strm.total_out);
|
||||
OutBytes := strm.total_out;
|
||||
except
|
||||
FreeMem(OutBuf);
|
||||
raise
|
||||
end;
|
||||
end;
|
||||
|
||||
|
||||
procedure DecompressBuf(const InBuf: Pointer; InBytes: Integer;
|
||||
OutEstimate: Integer; out OutBuf: Pointer; out OutBytes: Integer);
|
||||
var
|
||||
strm: TZStreamRec;
|
||||
P: Pointer;
|
||||
BufInc: Integer;
|
||||
begin
|
||||
FillChar(strm, sizeof(strm), 0);
|
||||
strm.zalloc := zlibAllocMem;
|
||||
strm.zfree := zlibFreeMem;
|
||||
BufInc := (InBytes + 255) and not 255;
|
||||
if OutEstimate = 0 then
|
||||
OutBytes := BufInc
|
||||
else
|
||||
OutBytes := OutEstimate;
|
||||
GetMem(OutBuf, OutBytes);
|
||||
try
|
||||
strm.next_in := InBuf;
|
||||
strm.avail_in := InBytes;
|
||||
strm.next_out := OutBuf;
|
||||
strm.avail_out := OutBytes;
|
||||
DCheck(inflateInit_(strm, zlib_version, sizeof(strm)));
|
||||
try
|
||||
while DCheck(inflate(strm, Z_FINISH)) <> Z_STREAM_END do
|
||||
begin
|
||||
P := OutBuf;
|
||||
Inc(OutBytes, BufInc);
|
||||
ReallocMem(OutBuf, OutBytes);
|
||||
strm.next_out := PChar(Integer(OutBuf) + (Integer(strm.next_out) - Integer(P)));
|
||||
strm.avail_out := BufInc;
|
||||
end;
|
||||
finally
|
||||
DCheck(inflateEnd(strm));
|
||||
end;
|
||||
ReallocMem(OutBuf, strm.total_out);
|
||||
OutBytes := strm.total_out;
|
||||
except
|
||||
FreeMem(OutBuf);
|
||||
raise
|
||||
end;
|
||||
end;
|
||||
|
||||
procedure DecompressToUserBuf(const InBuf: Pointer; InBytes: Integer;
|
||||
const OutBuf: Pointer; BufSize: Integer);
|
||||
var
|
||||
strm: TZStreamRec;
|
||||
begin
|
||||
FillChar(strm, sizeof(strm), 0);
|
||||
strm.zalloc := zlibAllocMem;
|
||||
strm.zfree := zlibFreeMem;
|
||||
strm.next_in := InBuf;
|
||||
strm.avail_in := InBytes;
|
||||
strm.next_out := OutBuf;
|
||||
strm.avail_out := BufSize;
|
||||
DCheck(inflateInit_(strm, zlib_version, sizeof(strm)));
|
||||
try
|
||||
if DCheck(inflate(strm, Z_FINISH)) <> Z_STREAM_END then
|
||||
raise EZlibError.CreateRes(@sTargetBufferTooSmall);
|
||||
finally
|
||||
DCheck(inflateEnd(strm));
|
||||
end;
|
||||
end;
|
||||
|
||||
// TCustomZlibStream
|
||||
|
||||
constructor TCustomZLibStream.Create(Strm: TStream);
|
||||
begin
|
||||
inherited Create;
|
||||
FStrm := Strm;
|
||||
FStrmPos := Strm.Position;
|
||||
FZRec.zalloc := zlibAllocMem;
|
||||
FZRec.zfree := zlibFreeMem;
|
||||
end;
|
||||
|
||||
procedure TCustomZLibStream.Progress(Sender: TObject);
|
||||
begin
|
||||
if Assigned(FOnProgress) then FOnProgress(Sender);
|
||||
end;
|
||||
|
||||
|
||||
// TCompressionStream
|
||||
|
||||
constructor TCompressionStream.Create(CompressionLevel: TCompressionLevel;
|
||||
Dest: TStream);
|
||||
const
|
||||
Levels: array [TCompressionLevel] of ShortInt =
|
||||
(Z_NO_COMPRESSION, Z_BEST_SPEED, Z_DEFAULT_COMPRESSION, Z_BEST_COMPRESSION);
|
||||
begin
|
||||
inherited Create(Dest);
|
||||
FZRec.next_out := FBuffer;
|
||||
FZRec.avail_out := sizeof(FBuffer);
|
||||
CCheck(deflateInit_(FZRec, Levels[CompressionLevel], zlib_version, sizeof(FZRec)));
|
||||
end;
|
||||
|
||||
destructor TCompressionStream.Destroy;
|
||||
begin
|
||||
FZRec.next_in := nil;
|
||||
FZRec.avail_in := 0;
|
||||
try
|
||||
if FStrm.Position <> FStrmPos then FStrm.Position := FStrmPos;
|
||||
while (CCheck(deflate(FZRec, Z_FINISH)) <> Z_STREAM_END)
|
||||
and (FZRec.avail_out = 0) do
|
||||
begin
|
||||
FStrm.WriteBuffer(FBuffer, sizeof(FBuffer));
|
||||
FZRec.next_out := FBuffer;
|
||||
FZRec.avail_out := sizeof(FBuffer);
|
||||
end;
|
||||
if FZRec.avail_out < sizeof(FBuffer) then
|
||||
FStrm.WriteBuffer(FBuffer, sizeof(FBuffer) - FZRec.avail_out);
|
||||
finally
|
||||
deflateEnd(FZRec);
|
||||
end;
|
||||
inherited Destroy;
|
||||
end;
|
||||
|
||||
function TCompressionStream.Read(var Buffer; Count: Longint): Longint;
|
||||
begin
|
||||
raise ECompressionError.CreateRes(@sInvalidStreamOp);
|
||||
end;
|
||||
|
||||
function TCompressionStream.Write(const Buffer; Count: Longint): Longint;
|
||||
begin
|
||||
FZRec.next_in := @Buffer;
|
||||
FZRec.avail_in := Count;
|
||||
if FStrm.Position <> FStrmPos then FStrm.Position := FStrmPos;
|
||||
while (FZRec.avail_in > 0) do
|
||||
begin
|
||||
CCheck(deflate(FZRec, 0));
|
||||
if FZRec.avail_out = 0 then
|
||||
begin
|
||||
FStrm.WriteBuffer(FBuffer, sizeof(FBuffer));
|
||||
FZRec.next_out := FBuffer;
|
||||
FZRec.avail_out := sizeof(FBuffer);
|
||||
FStrmPos := FStrm.Position;
|
||||
Progress(Self);
|
||||
end;
|
||||
end;
|
||||
Result := Count;
|
||||
end;
|
||||
|
||||
function TCompressionStream.Seek(Offset: Longint; Origin: Word): Longint;
|
||||
begin
|
||||
if (Offset = 0) and (Origin = soFromCurrent) then
|
||||
Result := FZRec.total_in
|
||||
else
|
||||
raise ECompressionError.CreateRes(@sInvalidStreamOp);
|
||||
end;
|
||||
|
||||
function TCompressionStream.GetCompressionRate: Single;
|
||||
begin
|
||||
if FZRec.total_in = 0 then
|
||||
Result := 0
|
||||
else
|
||||
Result := (1.0 - (FZRec.total_out / FZRec.total_in)) * 100.0;
|
||||
end;
|
||||
|
||||
|
||||
// TDecompressionStream
|
||||
|
||||
constructor TDecompressionStream.Create(Source: TStream);
|
||||
begin
|
||||
inherited Create(Source);
|
||||
FZRec.next_in := FBuffer;
|
||||
FZRec.avail_in := 0;
|
||||
DCheck(inflateInit_(FZRec, zlib_version, sizeof(FZRec)));
|
||||
end;
|
||||
|
||||
destructor TDecompressionStream.Destroy;
|
||||
begin
|
||||
FStrm.Seek(-FZRec.avail_in, 1);
|
||||
inflateEnd(FZRec);
|
||||
inherited Destroy;
|
||||
end;
|
||||
|
||||
function TDecompressionStream.Read(var Buffer; Count: Longint): Longint;
|
||||
begin
|
||||
FZRec.next_out := @Buffer;
|
||||
FZRec.avail_out := Count;
|
||||
if FStrm.Position <> FStrmPos then FStrm.Position := FStrmPos;
|
||||
while (FZRec.avail_out > 0) do
|
||||
begin
|
||||
if FZRec.avail_in = 0 then
|
||||
begin
|
||||
FZRec.avail_in := FStrm.Read(FBuffer, sizeof(FBuffer));
|
||||
if FZRec.avail_in = 0 then
|
||||
begin
|
||||
Result := Count - FZRec.avail_out;
|
||||
Exit;
|
||||
end;
|
||||
FZRec.next_in := FBuffer;
|
||||
FStrmPos := FStrm.Position;
|
||||
Progress(Self);
|
||||
end;
|
||||
CCheck(inflate(FZRec, 0));
|
||||
end;
|
||||
Result := Count;
|
||||
end;
|
||||
|
||||
function TDecompressionStream.Write(const Buffer; Count: Longint): Longint;
|
||||
begin
|
||||
raise EDecompressionError.CreateRes(@sInvalidStreamOp);
|
||||
end;
|
||||
|
||||
function TDecompressionStream.Seek(Offset: Longint; Origin: Word): Longint;
|
||||
var
|
||||
I: Integer;
|
||||
Buf: array [0..4095] of Char;
|
||||
begin
|
||||
if (Offset = 0) and (Origin = soFromBeginning) then
|
||||
begin
|
||||
DCheck(inflateReset(FZRec));
|
||||
FZRec.next_in := FBuffer;
|
||||
FZRec.avail_in := 0;
|
||||
FStrm.Position := 0;
|
||||
FStrmPos := 0;
|
||||
end
|
||||
else if ( (Offset >= 0) and (Origin = soFromCurrent)) or
|
||||
( ((Offset - FZRec.total_out) > 0) and (Origin = soFromBeginning)) then
|
||||
begin
|
||||
if Origin = soFromBeginning then Dec(Offset, FZRec.total_out);
|
||||
if Offset > 0 then
|
||||
begin
|
||||
for I := 1 to Offset div sizeof(Buf) do
|
||||
ReadBuffer(Buf, sizeof(Buf));
|
||||
ReadBuffer(Buf, Offset mod sizeof(Buf));
|
||||
end;
|
||||
end
|
||||
else
|
||||
raise EDecompressionError.CreateRes(@sInvalidStreamOp);
|
||||
Result := FZRec.total_out;
|
||||
end;
|
||||
|
||||
|
||||
end.
|
||||
|
|
@ -1,11 +0,0 @@
|
|||
unit ZLibConst;
|
||||
|
||||
interface
|
||||
|
||||
resourcestring
|
||||
sTargetBufferTooSmall = 'ZLib error: target buffer may be too small';
|
||||
sInvalidStreamOp = 'Invalid stream operation';
|
||||
|
||||
implementation
|
||||
|
||||
end.
|
||||
|
|
@ -1,76 +0,0 @@
|
|||
|
||||
Overview
|
||||
========
|
||||
|
||||
This directory contains an update to the ZLib interface unit,
|
||||
distributed by Borland as a Delphi supplemental component.
|
||||
|
||||
The original ZLib unit is Copyright (c) 1997,99 Borland Corp.,
|
||||
and is based on zlib version 1.0.4. There are a series of bugs
|
||||
and security problems associated with that old zlib version, and
|
||||
we recommend the users to update their ZLib unit.
|
||||
|
||||
|
||||
Summary of modifications
|
||||
========================
|
||||
|
||||
- Improved makefile, adapted to zlib version 1.2.1.
|
||||
|
||||
- Some field types from TZStreamRec are changed from Integer to
|
||||
Longint, for consistency with the zlib.h header, and for 64-bit
|
||||
readiness.
|
||||
|
||||
- The zlib_version constant is updated.
|
||||
|
||||
- The new Z_RLE strategy has its corresponding symbolic constant.
|
||||
|
||||
- The allocation and deallocation functions and function types
|
||||
(TAlloc, TFree, zlibAllocMem and zlibFreeMem) are now cdecl,
|
||||
and _malloc and _free are added as C RTL stubs. As a result,
|
||||
the original C sources of zlib can be compiled out of the box,
|
||||
and linked to the ZLib unit.
|
||||
|
||||
|
||||
Suggestions for improvements
|
||||
============================
|
||||
|
||||
Currently, the ZLib unit provides only a limited wrapper around
|
||||
the zlib library, and much of the original zlib functionality is
|
||||
missing. Handling compressed file formats like ZIP/GZIP or PNG
|
||||
cannot be implemented without having this functionality.
|
||||
Applications that handle these formats are either using their own,
|
||||
duplicated code, or not using the ZLib unit at all.
|
||||
|
||||
Here are a few suggestions:
|
||||
|
||||
- Checksum class wrappers around adler32() and crc32(), similar
|
||||
to the Java classes that implement the java.util.zip.Checksum
|
||||
interface.
|
||||
|
||||
- The ability to read and write raw deflate streams, without the
|
||||
zlib stream header and trailer. Raw deflate streams are used
|
||||
in the ZIP file format.
|
||||
|
||||
- The ability to read and write gzip streams, used in the GZIP
|
||||
file format, and normally produced by the gzip program.
|
||||
|
||||
- The ability to select a different compression strategy, useful
|
||||
to PNG and MNG image compression, and to multimedia compression
|
||||
in general. Besides the compression level
|
||||
|
||||
TCompressionLevel = (clNone, clFastest, clDefault, clMax);
|
||||
|
||||
which, in fact, could have used the 'z' prefix and avoided
|
||||
TColor-like symbols
|
||||
|
||||
TCompressionLevel = (zcNone, zcFastest, zcDefault, zcMax);
|
||||
|
||||
there could be a compression strategy
|
||||
|
||||
TCompressionStrategy = (zsDefault, zsFiltered, zsHuffmanOnly, zsRle);
|
||||
|
||||
- ZIP and GZIP stream handling via TStreams.
|
||||
|
||||
|
||||
--
|
||||
Cosmin Truta <cosmint@cs.ubbcluj.ro>
|
||||
|
|
@ -1,93 +0,0 @@
|
|||
# Makefile for zlib
|
||||
# For use with Delphi and C++ Builder under Win32
|
||||
# Updated for zlib 1.2.x by Cosmin Truta
|
||||
|
||||
# ------------ Borland C++ ------------
|
||||
|
||||
# This project uses the Delphi (fastcall/register) calling convention:
|
||||
LOC = -DZEXPORT=__fastcall -DZEXPORTVA=__cdecl
|
||||
|
||||
CC = bcc32
|
||||
LD = bcc32
|
||||
AR = tlib
|
||||
# do not use "-pr" in CFLAGS
|
||||
CFLAGS = -a -d -k- -O2 $(LOC)
|
||||
LDFLAGS =
|
||||
|
||||
|
||||
# variables
|
||||
ZLIB_LIB = zlib.lib
|
||||
|
||||
OBJ1 = adler32.obj compress.obj crc32.obj deflate.obj gzio.obj infback.obj
|
||||
OBJ2 = inffast.obj inflate.obj inftrees.obj trees.obj uncompr.obj zutil.obj
|
||||
OBJP1 = +adler32.obj+compress.obj+crc32.obj+deflate.obj+gzio.obj+infback.obj
|
||||
OBJP2 = +inffast.obj+inflate.obj+inftrees.obj+trees.obj+uncompr.obj+zutil.obj
|
||||
|
||||
|
||||
# targets
|
||||
all: $(ZLIB_LIB) example.exe minigzip.exe
|
||||
|
||||
.c.obj:
|
||||
$(CC) -c $(CFLAGS) $*.c
|
||||
|
||||
adler32.obj: adler32.c zlib.h zconf.h
|
||||
|
||||
compress.obj: compress.c zlib.h zconf.h
|
||||
|
||||
crc32.obj: crc32.c zlib.h zconf.h crc32.h
|
||||
|
||||
deflate.obj: deflate.c deflate.h zutil.h zlib.h zconf.h
|
||||
|
||||
gzio.obj: gzio.c zutil.h zlib.h zconf.h
|
||||
|
||||
infback.obj: infback.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
|
||||
inffast.h inffixed.h
|
||||
|
||||
inffast.obj: inffast.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
|
||||
inffast.h
|
||||
|
||||
inflate.obj: inflate.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
|
||||
inffast.h inffixed.h
|
||||
|
||||
inftrees.obj: inftrees.c zutil.h zlib.h zconf.h inftrees.h
|
||||
|
||||
trees.obj: trees.c zutil.h zlib.h zconf.h deflate.h trees.h
|
||||
|
||||
uncompr.obj: uncompr.c zlib.h zconf.h
|
||||
|
||||
zutil.obj: zutil.c zutil.h zlib.h zconf.h
|
||||
|
||||
example.obj: example.c zlib.h zconf.h
|
||||
|
||||
minigzip.obj: minigzip.c zlib.h zconf.h
|
||||
|
||||
|
||||
# For the sake of the old Borland make,
|
||||
# the command line is cut to fit in the MS-DOS 128 byte limit:
|
||||
$(ZLIB_LIB): $(OBJ1) $(OBJ2)
|
||||
-del $(ZLIB_LIB)
|
||||
$(AR) $(ZLIB_LIB) $(OBJP1)
|
||||
$(AR) $(ZLIB_LIB) $(OBJP2)
|
||||
|
||||
|
||||
# testing
|
||||
test: example.exe minigzip.exe
|
||||
example
|
||||
echo hello world | minigzip | minigzip -d
|
||||
|
||||
example.exe: example.obj $(ZLIB_LIB)
|
||||
$(LD) $(LDFLAGS) example.obj $(ZLIB_LIB)
|
||||
|
||||
minigzip.exe: minigzip.obj $(ZLIB_LIB)
|
||||
$(LD) $(LDFLAGS) minigzip.obj $(ZLIB_LIB)
|
||||
|
||||
|
||||
# cleanup
|
||||
clean:
|
||||
-del *.obj
|
||||
-del *.exe
|
||||
-del *.lib
|
||||
-del *.tds
|
||||
-del zlib.bak
|
||||
-del foo.gz
|
||||
|
||||
|
|
@ -1,500 +0,0 @@
|
|||
/* gzappend -- command to append to a gzip file
|
||||
|
||||
Copyright (C) 2003 Mark Adler, all rights reserved
|
||||
version 1.1, 4 Nov 2003
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the author be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
|
||||
Mark Adler madler@alumni.caltech.edu
|
||||
*/
|
||||
|
||||
/*
|
||||
* Change history:
|
||||
*
|
||||
* 1.0 19 Oct 2003 - First version
|
||||
* 1.1 4 Nov 2003 - Expand and clarify some comments and notes
|
||||
* - Add version and copyright to help
|
||||
* - Send help to stdout instead of stderr
|
||||
* - Add some preemptive typecasts
|
||||
* - Add L to constants in lseek() calls
|
||||
* - Remove some debugging information in error messages
|
||||
* - Use new data_type definition for zlib 1.2.1
|
||||
* - Simplfy and unify file operations
|
||||
* - Finish off gzip file in gztack()
|
||||
* - Use deflatePrime() instead of adding empty blocks
|
||||
* - Keep gzip file clean on appended file read errors
|
||||
* - Use in-place rotate instead of auxiliary buffer
|
||||
* (Why you ask? Because it was fun to write!)
|
||||
*/
|
||||
|
||||
/*
|
||||
gzappend takes a gzip file and appends to it, compressing files from the
|
||||
command line or data from stdin. The gzip file is written to directly, to
|
||||
avoid copying that file, in case it's large. Note that this results in the
|
||||
unfriendly behavior that if gzappend fails, the gzip file is corrupted.
|
||||
|
||||
This program was written to illustrate the use of the new Z_BLOCK option of
|
||||
zlib 1.2.1's inflate() function. This option returns from inflate() at each
|
||||
block boundary to facilitate locating and modifying the last block bit at
|
||||
the start of the final deflate block. Also whether using Z_BLOCK or not,
|
||||
another required feature of zlib 1.2.1 is that inflate() now provides the
|
||||
number of unusued bits in the last input byte used. gzappend will not work
|
||||
with versions of zlib earlier than 1.2.1.
|
||||
|
||||
gzappend first decompresses the gzip file internally, discarding all but
|
||||
the last 32K of uncompressed data, and noting the location of the last block
|
||||
bit and the number of unused bits in the last byte of the compressed data.
|
||||
The gzip trailer containing the CRC-32 and length of the uncompressed data
|
||||
is verified. This trailer will be later overwritten.
|
||||
|
||||
Then the last block bit is cleared by seeking back in the file and rewriting
|
||||
the byte that contains it. Seeking forward, the last byte of the compressed
|
||||
data is saved along with the number of unused bits to initialize deflate.
|
||||
|
||||
A deflate process is initialized, using the last 32K of the uncompressed
|
||||
data from the gzip file to initialize the dictionary. If the total
|
||||
uncompressed data was less than 32K, then all of it is used to initialize
|
||||
the dictionary. The deflate output bit buffer is also initialized with the
|
||||
last bits from the original deflate stream. From here on, the data to
|
||||
append is simply compressed using deflate, and written to the gzip file.
|
||||
When that is complete, the new CRC-32 and uncompressed length are written
|
||||
as the trailer of the gzip file.
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <fcntl.h>
|
||||
#include <unistd.h>
|
||||
#include "zlib.h"
|
||||
|
||||
#define local static
|
||||
#define LGCHUNK 14
|
||||
#define CHUNK (1U << LGCHUNK)
|
||||
#define DSIZE 32768U
|
||||
|
||||
/* print an error message and terminate with extreme prejudice */
|
||||
local void bye(char *msg1, char *msg2)
|
||||
{
|
||||
fprintf(stderr, "gzappend error: %s%s\n", msg1, msg2);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
/* return the greatest common divisor of a and b using Euclid's algorithm,
|
||||
modified to be fast when one argument much greater than the other, and
|
||||
coded to avoid unnecessary swapping */
|
||||
local unsigned gcd(unsigned a, unsigned b)
|
||||
{
|
||||
unsigned c;
|
||||
|
||||
while (a && b)
|
||||
if (a > b) {
|
||||
c = b;
|
||||
while (a - c >= c)
|
||||
c <<= 1;
|
||||
a -= c;
|
||||
}
|
||||
else {
|
||||
c = a;
|
||||
while (b - c >= c)
|
||||
c <<= 1;
|
||||
b -= c;
|
||||
}
|
||||
return a + b;
|
||||
}
|
||||
|
||||
/* rotate list[0..len-1] left by rot positions, in place */
|
||||
local void rotate(unsigned char *list, unsigned len, unsigned rot)
|
||||
{
|
||||
unsigned char tmp;
|
||||
unsigned cycles;
|
||||
unsigned char *start, *last, *to, *from;
|
||||
|
||||
/* normalize rot and handle degenerate cases */
|
||||
if (len < 2) return;
|
||||
if (rot >= len) rot %= len;
|
||||
if (rot == 0) return;
|
||||
|
||||
/* pointer to last entry in list */
|
||||
last = list + (len - 1);
|
||||
|
||||
/* do simple left shift by one */
|
||||
if (rot == 1) {
|
||||
tmp = *list;
|
||||
memcpy(list, list + 1, len - 1);
|
||||
*last = tmp;
|
||||
return;
|
||||
}
|
||||
|
||||
/* do simple right shift by one */
|
||||
if (rot == len - 1) {
|
||||
tmp = *last;
|
||||
memmove(list + 1, list, len - 1);
|
||||
*list = tmp;
|
||||
return;
|
||||
}
|
||||
|
||||
/* otherwise do rotate as a set of cycles in place */
|
||||
cycles = gcd(len, rot); /* number of cycles */
|
||||
do {
|
||||
start = from = list + cycles; /* start index is arbitrary */
|
||||
tmp = *from; /* save entry to be overwritten */
|
||||
for (;;) {
|
||||
to = from; /* next step in cycle */
|
||||
from += rot; /* go right rot positions */
|
||||
if (from > last) from -= len; /* (pointer better not wrap) */
|
||||
if (from == start) break; /* all but one shifted */
|
||||
*to = *from; /* shift left */
|
||||
}
|
||||
*to = tmp; /* complete the circle */
|
||||
} while (--cycles);
|
||||
}
|
||||
|
||||
/* structure for gzip file read operations */
|
||||
typedef struct {
|
||||
int fd; /* file descriptor */
|
||||
int size; /* 1 << size is bytes in buf */
|
||||
unsigned left; /* bytes available at next */
|
||||
unsigned char *buf; /* buffer */
|
||||
unsigned char *next; /* next byte in buffer */
|
||||
char *name; /* file name for error messages */
|
||||
} file;
|
||||
|
||||
/* reload buffer */
|
||||
local int readin(file *in)
|
||||
{
|
||||
int len;
|
||||
|
||||
len = read(in->fd, in->buf, 1 << in->size);
|
||||
if (len == -1) bye("error reading ", in->name);
|
||||
in->left = (unsigned)len;
|
||||
in->next = in->buf;
|
||||
return len;
|
||||
}
|
||||
|
||||
/* read from file in, exit if end-of-file */
|
||||
local int readmore(file *in)
|
||||
{
|
||||
if (readin(in) == 0) bye("unexpected end of ", in->name);
|
||||
return 0;
|
||||
}
|
||||
|
||||
#define read1(in) (in->left == 0 ? readmore(in) : 0, \
|
||||
in->left--, *(in->next)++)
|
||||
|
||||
/* skip over n bytes of in */
|
||||
local void skip(file *in, unsigned n)
|
||||
{
|
||||
unsigned bypass;
|
||||
|
||||
if (n > in->left) {
|
||||
n -= in->left;
|
||||
bypass = n & ~((1U << in->size) - 1);
|
||||
if (bypass) {
|
||||
if (lseek(in->fd, (off_t)bypass, SEEK_CUR) == -1)
|
||||
bye("seeking ", in->name);
|
||||
n -= bypass;
|
||||
}
|
||||
readmore(in);
|
||||
if (n > in->left)
|
||||
bye("unexpected end of ", in->name);
|
||||
}
|
||||
in->left -= n;
|
||||
in->next += n;
|
||||
}
|
||||
|
||||
/* read a four-byte unsigned integer, little-endian, from in */
|
||||
unsigned long read4(file *in)
|
||||
{
|
||||
unsigned long val;
|
||||
|
||||
val = read1(in);
|
||||
val += (unsigned)read1(in) << 8;
|
||||
val += (unsigned long)read1(in) << 16;
|
||||
val += (unsigned long)read1(in) << 24;
|
||||
return val;
|
||||
}
|
||||
|
||||
/* skip over gzip header */
|
||||
local void gzheader(file *in)
|
||||
{
|
||||
int flags;
|
||||
unsigned n;
|
||||
|
||||
if (read1(in) != 31 || read1(in) != 139) bye(in->name, " not a gzip file");
|
||||
if (read1(in) != 8) bye("unknown compression method in", in->name);
|
||||
flags = read1(in);
|
||||
if (flags & 0xe0) bye("unknown header flags set in", in->name);
|
||||
skip(in, 6);
|
||||
if (flags & 4) {
|
||||
n = read1(in);
|
||||
n += (unsigned)(read1(in)) << 8;
|
||||
skip(in, n);
|
||||
}
|
||||
if (flags & 8) while (read1(in) != 0) ;
|
||||
if (flags & 16) while (read1(in) != 0) ;
|
||||
if (flags & 2) skip(in, 2);
|
||||
}
|
||||
|
||||
/* decompress gzip file "name", return strm with a deflate stream ready to
|
||||
continue compression of the data in the gzip file, and return a file
|
||||
descriptor pointing to where to write the compressed data -- the deflate
|
||||
stream is initialized to compress using level "level" */
|
||||
local int gzscan(char *name, z_stream *strm, int level)
|
||||
{
|
||||
int ret, lastbit, left, full;
|
||||
unsigned have;
|
||||
unsigned long crc, tot;
|
||||
unsigned char *window;
|
||||
off_t lastoff, end;
|
||||
file gz;
|
||||
|
||||
/* open gzip file */
|
||||
gz.name = name;
|
||||
gz.fd = open(name, O_RDWR, 0);
|
||||
if (gz.fd == -1) bye("cannot open ", name);
|
||||
gz.buf = malloc(CHUNK);
|
||||
if (gz.buf == NULL) bye("out of memory", "");
|
||||
gz.size = LGCHUNK;
|
||||
gz.left = 0;
|
||||
|
||||
/* skip gzip header */
|
||||
gzheader(&gz);
|
||||
|
||||
/* prepare to decompress */
|
||||
window = malloc(DSIZE);
|
||||
if (window == NULL) bye("out of memory", "");
|
||||
strm->zalloc = Z_NULL;
|
||||
strm->zfree = Z_NULL;
|
||||
strm->opaque = Z_NULL;
|
||||
ret = inflateInit2(strm, -15);
|
||||
if (ret != Z_OK) bye("out of memory", " or library mismatch");
|
||||
|
||||
/* decompress the deflate stream, saving append information */
|
||||
lastbit = 0;
|
||||
lastoff = lseek(gz.fd, 0L, SEEK_CUR) - gz.left;
|
||||
left = 0;
|
||||
strm->avail_in = gz.left;
|
||||
strm->next_in = gz.next;
|
||||
crc = crc32(0L, Z_NULL, 0);
|
||||
have = full = 0;
|
||||
do {
|
||||
/* if needed, get more input */
|
||||
if (strm->avail_in == 0) {
|
||||
readmore(&gz);
|
||||
strm->avail_in = gz.left;
|
||||
strm->next_in = gz.next;
|
||||
}
|
||||
|
||||
/* set up output to next available section of sliding window */
|
||||
strm->avail_out = DSIZE - have;
|
||||
strm->next_out = window + have;
|
||||
|
||||
/* inflate and check for errors */
|
||||
ret = inflate(strm, Z_BLOCK);
|
||||
if (ret == Z_STREAM_ERROR) bye("internal stream error!", "");
|
||||
if (ret == Z_MEM_ERROR) bye("out of memory", "");
|
||||
if (ret == Z_DATA_ERROR)
|
||||
bye("invalid compressed data--format violated in", name);
|
||||
|
||||
/* update crc and sliding window pointer */
|
||||
crc = crc32(crc, window + have, DSIZE - have - strm->avail_out);
|
||||
if (strm->avail_out)
|
||||
have = DSIZE - strm->avail_out;
|
||||
else {
|
||||
have = 0;
|
||||
full = 1;
|
||||
}
|
||||
|
||||
/* process end of block */
|
||||
if (strm->data_type & 128) {
|
||||
if (strm->data_type & 64)
|
||||
left = strm->data_type & 0x1f;
|
||||
else {
|
||||
lastbit = strm->data_type & 0x1f;
|
||||
lastoff = lseek(gz.fd, 0L, SEEK_CUR) - strm->avail_in;
|
||||
}
|
||||
}
|
||||
} while (ret != Z_STREAM_END);
|
||||
inflateEnd(strm);
|
||||
gz.left = strm->avail_in;
|
||||
gz.next = strm->next_in;
|
||||
|
||||
/* save the location of the end of the compressed data */
|
||||
end = lseek(gz.fd, 0L, SEEK_CUR) - gz.left;
|
||||
|
||||
/* check gzip trailer and save total for deflate */
|
||||
if (crc != read4(&gz))
|
||||
bye("invalid compressed data--crc mismatch in ", name);
|
||||
tot = strm->total_out;
|
||||
if ((tot & 0xffffffffUL) != read4(&gz))
|
||||
bye("invalid compressed data--length mismatch in", name);
|
||||
|
||||
/* if not at end of file, warn */
|
||||
if (gz.left || readin(&gz))
|
||||
fprintf(stderr,
|
||||
"gzappend warning: junk at end of gzip file overwritten\n");
|
||||
|
||||
/* clear last block bit */
|
||||
lseek(gz.fd, lastoff - (lastbit != 0), SEEK_SET);
|
||||
if (read(gz.fd, gz.buf, 1) != 1) bye("reading after seek on ", name);
|
||||
*gz.buf = (unsigned char)(*gz.buf ^ (1 << ((8 - lastbit) & 7)));
|
||||
lseek(gz.fd, -1L, SEEK_CUR);
|
||||
if (write(gz.fd, gz.buf, 1) != 1) bye("writing after seek to ", name);
|
||||
|
||||
/* if window wrapped, build dictionary from window by rotating */
|
||||
if (full) {
|
||||
rotate(window, DSIZE, have);
|
||||
have = DSIZE;
|
||||
}
|
||||
|
||||
/* set up deflate stream with window, crc, total_in, and leftover bits */
|
||||
ret = deflateInit2(strm, level, Z_DEFLATED, -15, 8, Z_DEFAULT_STRATEGY);
|
||||
if (ret != Z_OK) bye("out of memory", "");
|
||||
deflateSetDictionary(strm, window, have);
|
||||
strm->adler = crc;
|
||||
strm->total_in = tot;
|
||||
if (left) {
|
||||
lseek(gz.fd, --end, SEEK_SET);
|
||||
if (read(gz.fd, gz.buf, 1) != 1) bye("reading after seek on ", name);
|
||||
deflatePrime(strm, 8 - left, *gz.buf);
|
||||
}
|
||||
lseek(gz.fd, end, SEEK_SET);
|
||||
|
||||
/* clean up and return */
|
||||
free(window);
|
||||
free(gz.buf);
|
||||
return gz.fd;
|
||||
}
|
||||
|
||||
/* append file "name" to gzip file gd using deflate stream strm -- if last
|
||||
is true, then finish off the deflate stream at the end */
|
||||
local void gztack(char *name, int gd, z_stream *strm, int last)
|
||||
{
|
||||
int fd, len, ret;
|
||||
unsigned left;
|
||||
unsigned char *in, *out;
|
||||
|
||||
/* open file to compress and append */
|
||||
fd = 0;
|
||||
if (name != NULL) {
|
||||
fd = open(name, O_RDONLY, 0);
|
||||
if (fd == -1)
|
||||
fprintf(stderr, "gzappend warning: %s not found, skipping ...\n",
|
||||
name);
|
||||
}
|
||||
|
||||
/* allocate buffers */
|
||||
in = fd == -1 ? NULL : malloc(CHUNK);
|
||||
out = malloc(CHUNK);
|
||||
if (out == NULL) bye("out of memory", "");
|
||||
|
||||
/* compress input file and append to gzip file */
|
||||
do {
|
||||
/* get more input */
|
||||
len = fd == -1 ? 0 : read(fd, in, CHUNK);
|
||||
if (len == -1) {
|
||||
fprintf(stderr,
|
||||
"gzappend warning: error reading %s, skipping rest ...\n",
|
||||
name);
|
||||
len = 0;
|
||||
}
|
||||
strm->avail_in = (unsigned)len;
|
||||
strm->next_in = in;
|
||||
if (len) strm->adler = crc32(strm->adler, in, (unsigned)len);
|
||||
|
||||
/* compress and write all available output */
|
||||
do {
|
||||
strm->avail_out = CHUNK;
|
||||
strm->next_out = out;
|
||||
ret = deflate(strm, last && len == 0 ? Z_FINISH : Z_NO_FLUSH);
|
||||
left = CHUNK - strm->avail_out;
|
||||
while (left) {
|
||||
len = write(gd, out + CHUNK - strm->avail_out - left, left);
|
||||
if (len == -1) bye("writing gzip file", "");
|
||||
left -= (unsigned)len;
|
||||
}
|
||||
} while (strm->avail_out == 0 && ret != Z_STREAM_END);
|
||||
} while (len != 0);
|
||||
|
||||
/* write trailer after last entry */
|
||||
if (last) {
|
||||
deflateEnd(strm);
|
||||
out[0] = (unsigned char)(strm->adler);
|
||||
out[1] = (unsigned char)(strm->adler >> 8);
|
||||
out[2] = (unsigned char)(strm->adler >> 16);
|
||||
out[3] = (unsigned char)(strm->adler >> 24);
|
||||
out[4] = (unsigned char)(strm->total_in);
|
||||
out[5] = (unsigned char)(strm->total_in >> 8);
|
||||
out[6] = (unsigned char)(strm->total_in >> 16);
|
||||
out[7] = (unsigned char)(strm->total_in >> 24);
|
||||
len = 8;
|
||||
do {
|
||||
ret = write(gd, out + 8 - len, len);
|
||||
if (ret == -1) bye("writing gzip file", "");
|
||||
len -= ret;
|
||||
} while (len);
|
||||
close(gd);
|
||||
}
|
||||
|
||||
/* clean up and return */
|
||||
free(out);
|
||||
if (in != NULL) free(in);
|
||||
if (fd > 0) close(fd);
|
||||
}
|
||||
|
||||
/* process the compression level option if present, scan the gzip file, and
|
||||
append the specified files, or append the data from stdin if no other file
|
||||
names are provided on the command line -- the gzip file must be writable
|
||||
and seekable */
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
int gd, level;
|
||||
z_stream strm;
|
||||
|
||||
/* ignore command name */
|
||||
argv++;
|
||||
|
||||
/* provide usage if no arguments */
|
||||
if (*argv == NULL) {
|
||||
printf("gzappend 1.1 (4 Nov 2003) Copyright (C) 2003 Mark Adler\n");
|
||||
printf(
|
||||
"usage: gzappend [-level] file.gz [ addthis [ andthis ... ]]\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* set compression level */
|
||||
level = Z_DEFAULT_COMPRESSION;
|
||||
if (argv[0][0] == '-') {
|
||||
if (argv[0][1] < '0' || argv[0][1] > '9' || argv[0][2] != 0)
|
||||
bye("invalid compression level", "");
|
||||
level = argv[0][1] - '0';
|
||||
if (*++argv == NULL) bye("no gzip file name after options", "");
|
||||
}
|
||||
|
||||
/* prepare to append to gzip file */
|
||||
gd = gzscan(*argv++, &strm, level);
|
||||
|
||||
/* append files on command line, or from stdin if none */
|
||||
if (*argv == NULL)
|
||||
gztack(NULL, gd, &strm, 1);
|
||||
else
|
||||
do {
|
||||
gztack(*argv, gd, &strm, argv[1] == NULL);
|
||||
} while (*++argv != NULL);
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1 +0,0 @@
|
|||
See infback9.h for what this is and how to use it.
|
||||
|
|
@ -1,605 +0,0 @@
|
|||
/* infback9.c -- inflate deflate64 data using a call-back interface
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
#include "zutil.h"
|
||||
#include "infback9.h"
|
||||
#include "inftree9.h"
|
||||
#include "inflate9.h"
|
||||
|
||||
#define WSIZE 65536UL
|
||||
|
||||
/*
|
||||
strm provides memory allocation functions in zalloc and zfree, or
|
||||
Z_NULL to use the library memory allocation functions.
|
||||
|
||||
window is a user-supplied window and output buffer that is 64K bytes.
|
||||
*/
|
||||
int ZEXPORT inflateBack9Init_(strm, window, version, stream_size)
|
||||
z_stream FAR *strm;
|
||||
unsigned char FAR *window;
|
||||
const char *version;
|
||||
int stream_size;
|
||||
{
|
||||
struct inflate_state FAR *state;
|
||||
|
||||
if (version == Z_NULL || version[0] != ZLIB_VERSION[0] ||
|
||||
stream_size != (int)(sizeof(z_stream)))
|
||||
return Z_VERSION_ERROR;
|
||||
if (strm == Z_NULL || window == Z_NULL)
|
||||
return Z_STREAM_ERROR;
|
||||
strm->msg = Z_NULL; /* in case we return an error */
|
||||
if (strm->zalloc == (alloc_func)0) {
|
||||
strm->zalloc = zcalloc;
|
||||
strm->opaque = (voidpf)0;
|
||||
}
|
||||
if (strm->zfree == (free_func)0) strm->zfree = zcfree;
|
||||
state = (struct inflate_state FAR *)ZALLOC(strm, 1,
|
||||
sizeof(struct inflate_state));
|
||||
if (state == Z_NULL) return Z_MEM_ERROR;
|
||||
Tracev((stderr, "inflate: allocated\n"));
|
||||
strm->state = (voidpf)state;
|
||||
state->window = window;
|
||||
return Z_OK;
|
||||
}
|
||||
|
||||
/*
|
||||
Build and output length and distance decoding tables for fixed code
|
||||
decoding.
|
||||
*/
|
||||
#ifdef MAKEFIXED
|
||||
#include <stdio.h>
|
||||
|
||||
void makefixed9(void)
|
||||
{
|
||||
unsigned sym, bits, low, size;
|
||||
code *next, *lenfix, *distfix;
|
||||
struct inflate_state state;
|
||||
code fixed[544];
|
||||
|
||||
/* literal/length table */
|
||||
sym = 0;
|
||||
while (sym < 144) state.lens[sym++] = 8;
|
||||
while (sym < 256) state.lens[sym++] = 9;
|
||||
while (sym < 280) state.lens[sym++] = 7;
|
||||
while (sym < 288) state.lens[sym++] = 8;
|
||||
next = fixed;
|
||||
lenfix = next;
|
||||
bits = 9;
|
||||
inflate_table9(LENS, state.lens, 288, &(next), &(bits), state.work);
|
||||
|
||||
/* distance table */
|
||||
sym = 0;
|
||||
while (sym < 32) state.lens[sym++] = 5;
|
||||
distfix = next;
|
||||
bits = 5;
|
||||
inflate_table9(DISTS, state.lens, 32, &(next), &(bits), state.work);
|
||||
|
||||
/* write tables */
|
||||
puts(" /* inffix9.h -- table for decoding deflate64 fixed codes");
|
||||
puts(" * Generated automatically by makefixed9().");
|
||||
puts(" */");
|
||||
puts("");
|
||||
puts(" /* WARNING: this file should *not* be used by applications.");
|
||||
puts(" It is part of the implementation of this library and is");
|
||||
puts(" subject to change. Applications should only use zlib.h.");
|
||||
puts(" */");
|
||||
puts("");
|
||||
size = 1U << 9;
|
||||
printf(" static const code lenfix[%u] = {", size);
|
||||
low = 0;
|
||||
for (;;) {
|
||||
if ((low % 6) == 0) printf("\n ");
|
||||
printf("{%u,%u,%d}", lenfix[low].op, lenfix[low].bits,
|
||||
lenfix[low].val);
|
||||
if (++low == size) break;
|
||||
putchar(',');
|
||||
}
|
||||
puts("\n };");
|
||||
size = 1U << 5;
|
||||
printf("\n static const code distfix[%u] = {", size);
|
||||
low = 0;
|
||||
for (;;) {
|
||||
if ((low % 5) == 0) printf("\n ");
|
||||
printf("{%u,%u,%d}", distfix[low].op, distfix[low].bits,
|
||||
distfix[low].val);
|
||||
if (++low == size) break;
|
||||
putchar(',');
|
||||
}
|
||||
puts("\n };");
|
||||
}
|
||||
#endif /* MAKEFIXED */
|
||||
|
||||
/* Macros for inflateBack(): */
|
||||
|
||||
/* Clear the input bit accumulator */
|
||||
#define INITBITS() \
|
||||
do { \
|
||||
hold = 0; \
|
||||
bits = 0; \
|
||||
} while (0)
|
||||
|
||||
/* Assure that some input is available. If input is requested, but denied,
|
||||
then return a Z_BUF_ERROR from inflateBack(). */
|
||||
#define PULL() \
|
||||
do { \
|
||||
if (have == 0) { \
|
||||
have = in(in_desc, &next); \
|
||||
if (have == 0) { \
|
||||
next = Z_NULL; \
|
||||
ret = Z_BUF_ERROR; \
|
||||
goto inf_leave; \
|
||||
} \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
/* Get a byte of input into the bit accumulator, or return from inflateBack()
|
||||
with an error if there is no input available. */
|
||||
#define PULLBYTE() \
|
||||
do { \
|
||||
PULL(); \
|
||||
have--; \
|
||||
hold += (unsigned long)(*next++) << bits; \
|
||||
bits += 8; \
|
||||
} while (0)
|
||||
|
||||
/* Assure that there are at least n bits in the bit accumulator. If there is
|
||||
not enough available input to do that, then return from inflateBack() with
|
||||
an error. */
|
||||
#define NEEDBITS(n) \
|
||||
do { \
|
||||
while (bits < (unsigned)(n)) \
|
||||
PULLBYTE(); \
|
||||
} while (0)
|
||||
|
||||
/* Return the low n bits of the bit accumulator (n <= 16) */
|
||||
#define BITS(n) \
|
||||
((unsigned)hold & ((1U << (n)) - 1))
|
||||
|
||||
/* Remove n bits from the bit accumulator */
|
||||
#define DROPBITS(n) \
|
||||
do { \
|
||||
hold >>= (n); \
|
||||
bits -= (unsigned)(n); \
|
||||
} while (0)
|
||||
|
||||
/* Remove zero to seven bits as needed to go to a byte boundary */
|
||||
#define BYTEBITS() \
|
||||
do { \
|
||||
hold >>= bits & 7; \
|
||||
bits -= bits & 7; \
|
||||
} while (0)
|
||||
|
||||
/* Assure that some output space is available, by writing out the window
|
||||
if it's full. If the write fails, return from inflateBack() with a
|
||||
Z_BUF_ERROR. */
|
||||
#define ROOM() \
|
||||
do { \
|
||||
if (left == 0) { \
|
||||
put = window; \
|
||||
left = WSIZE; \
|
||||
wrap = 1; \
|
||||
if (out(out_desc, put, (unsigned)left)) { \
|
||||
ret = Z_BUF_ERROR; \
|
||||
goto inf_leave; \
|
||||
} \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
/*
|
||||
strm provides the memory allocation functions and window buffer on input,
|
||||
and provides information on the unused input on return. For Z_DATA_ERROR
|
||||
returns, strm will also provide an error message.
|
||||
|
||||
in() and out() are the call-back input and output functions. When
|
||||
inflateBack() needs more input, it calls in(). When inflateBack() has
|
||||
filled the window with output, or when it completes with data in the
|
||||
window, it calls out() to write out the data. The application must not
|
||||
change the provided input until in() is called again or inflateBack()
|
||||
returns. The application must not change the window/output buffer until
|
||||
inflateBack() returns.
|
||||
|
||||
in() and out() are called with a descriptor parameter provided in the
|
||||
inflateBack() call. This parameter can be a structure that provides the
|
||||
information required to do the read or write, as well as accumulated
|
||||
information on the input and output such as totals and check values.
|
||||
|
||||
in() should return zero on failure. out() should return non-zero on
|
||||
failure. If either in() or out() fails, than inflateBack() returns a
|
||||
Z_BUF_ERROR. strm->next_in can be checked for Z_NULL to see whether it
|
||||
was in() or out() that caused in the error. Otherwise, inflateBack()
|
||||
returns Z_STREAM_END on success, Z_DATA_ERROR for an deflate format
|
||||
error, or Z_MEM_ERROR if it could not allocate memory for the state.
|
||||
inflateBack() can also return Z_STREAM_ERROR if the input parameters
|
||||
are not correct, i.e. strm is Z_NULL or the state was not initialized.
|
||||
*/
|
||||
int ZEXPORT inflateBack9(strm, in, in_desc, out, out_desc)
|
||||
z_stream FAR *strm;
|
||||
in_func in;
|
||||
void FAR *in_desc;
|
||||
out_func out;
|
||||
void FAR *out_desc;
|
||||
{
|
||||
struct inflate_state FAR *state;
|
||||
unsigned char FAR *next; /* next input */
|
||||
unsigned char FAR *put; /* next output */
|
||||
unsigned have; /* available input */
|
||||
unsigned long left; /* available output */
|
||||
inflate_mode mode; /* current inflate mode */
|
||||
int lastblock; /* true if processing last block */
|
||||
int wrap; /* true if the window has wrapped */
|
||||
unsigned long write; /* window write index */
|
||||
unsigned char FAR *window; /* allocated sliding window, if needed */
|
||||
unsigned long hold; /* bit buffer */
|
||||
unsigned bits; /* bits in bit buffer */
|
||||
unsigned extra; /* extra bits needed */
|
||||
unsigned long length; /* literal or length of data to copy */
|
||||
unsigned long offset; /* distance back to copy string from */
|
||||
unsigned long copy; /* number of stored or match bytes to copy */
|
||||
unsigned char FAR *from; /* where to copy match bytes from */
|
||||
code const FAR *lencode; /* starting table for length/literal codes */
|
||||
code const FAR *distcode; /* starting table for distance codes */
|
||||
unsigned lenbits; /* index bits for lencode */
|
||||
unsigned distbits; /* index bits for distcode */
|
||||
code this; /* current decoding table entry */
|
||||
code last; /* parent table entry */
|
||||
unsigned len; /* length to copy for repeats, bits to drop */
|
||||
int ret; /* return code */
|
||||
static const unsigned short order[19] = /* permutation of code lengths */
|
||||
{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
|
||||
#include "inffix9.h"
|
||||
|
||||
/* Check that the strm exists and that the state was initialized */
|
||||
if (strm == Z_NULL || strm->state == Z_NULL)
|
||||
return Z_STREAM_ERROR;
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
|
||||
/* Reset the state */
|
||||
strm->msg = Z_NULL;
|
||||
mode = TYPE;
|
||||
lastblock = 0;
|
||||
write = 0;
|
||||
wrap = 0;
|
||||
window = state->window;
|
||||
next = strm->next_in;
|
||||
have = next != Z_NULL ? strm->avail_in : 0;
|
||||
hold = 0;
|
||||
bits = 0;
|
||||
put = window;
|
||||
left = WSIZE;
|
||||
lencode = Z_NULL;
|
||||
distcode = Z_NULL;
|
||||
|
||||
/* Inflate until end of block marked as last */
|
||||
for (;;)
|
||||
switch (mode) {
|
||||
case TYPE:
|
||||
/* determine and dispatch block type */
|
||||
if (lastblock) {
|
||||
BYTEBITS();
|
||||
mode = DONE;
|
||||
break;
|
||||
}
|
||||
NEEDBITS(3);
|
||||
lastblock = BITS(1);
|
||||
DROPBITS(1);
|
||||
switch (BITS(2)) {
|
||||
case 0: /* stored block */
|
||||
Tracev((stderr, "inflate: stored block%s\n",
|
||||
lastblock ? " (last)" : ""));
|
||||
mode = STORED;
|
||||
break;
|
||||
case 1: /* fixed block */
|
||||
lencode = lenfix;
|
||||
lenbits = 9;
|
||||
distcode = distfix;
|
||||
distbits = 5;
|
||||
Tracev((stderr, "inflate: fixed codes block%s\n",
|
||||
lastblock ? " (last)" : ""));
|
||||
mode = LEN; /* decode codes */
|
||||
break;
|
||||
case 2: /* dynamic block */
|
||||
Tracev((stderr, "inflate: dynamic codes block%s\n",
|
||||
lastblock ? " (last)" : ""));
|
||||
mode = TABLE;
|
||||
break;
|
||||
case 3:
|
||||
strm->msg = (char *)"invalid block type";
|
||||
mode = BAD;
|
||||
}
|
||||
DROPBITS(2);
|
||||
break;
|
||||
|
||||
case STORED:
|
||||
/* get and verify stored block length */
|
||||
BYTEBITS(); /* go to byte boundary */
|
||||
NEEDBITS(32);
|
||||
if ((hold & 0xffff) != ((hold >> 16) ^ 0xffff)) {
|
||||
strm->msg = (char *)"invalid stored block lengths";
|
||||
mode = BAD;
|
||||
break;
|
||||
}
|
||||
length = (unsigned)hold & 0xffff;
|
||||
Tracev((stderr, "inflate: stored length %lu\n",
|
||||
length));
|
||||
INITBITS();
|
||||
|
||||
/* copy stored block from input to output */
|
||||
while (length != 0) {
|
||||
copy = length;
|
||||
PULL();
|
||||
ROOM();
|
||||
if (copy > have) copy = have;
|
||||
if (copy > left) copy = left;
|
||||
zmemcpy(put, next, copy);
|
||||
have -= copy;
|
||||
next += copy;
|
||||
left -= copy;
|
||||
put += copy;
|
||||
length -= copy;
|
||||
}
|
||||
Tracev((stderr, "inflate: stored end\n"));
|
||||
mode = TYPE;
|
||||
break;
|
||||
|
||||
case TABLE:
|
||||
/* get dynamic table entries descriptor */
|
||||
NEEDBITS(14);
|
||||
state->nlen = BITS(5) + 257;
|
||||
DROPBITS(5);
|
||||
state->ndist = BITS(5) + 1;
|
||||
DROPBITS(5);
|
||||
state->ncode = BITS(4) + 4;
|
||||
DROPBITS(4);
|
||||
if (state->nlen > 286) {
|
||||
strm->msg = (char *)"too many length symbols";
|
||||
mode = BAD;
|
||||
break;
|
||||
}
|
||||
Tracev((stderr, "inflate: table sizes ok\n"));
|
||||
|
||||
/* get code length code lengths (not a typo) */
|
||||
state->have = 0;
|
||||
while (state->have < state->ncode) {
|
||||
NEEDBITS(3);
|
||||
state->lens[order[state->have++]] = (unsigned short)BITS(3);
|
||||
DROPBITS(3);
|
||||
}
|
||||
while (state->have < 19)
|
||||
state->lens[order[state->have++]] = 0;
|
||||
state->next = state->codes;
|
||||
lencode = (code const FAR *)(state->next);
|
||||
lenbits = 7;
|
||||
ret = inflate_table9(CODES, state->lens, 19, &(state->next),
|
||||
&(lenbits), state->work);
|
||||
if (ret) {
|
||||
strm->msg = (char *)"invalid code lengths set";
|
||||
mode = BAD;
|
||||
break;
|
||||
}
|
||||
Tracev((stderr, "inflate: code lengths ok\n"));
|
||||
|
||||
/* get length and distance code code lengths */
|
||||
state->have = 0;
|
||||
while (state->have < state->nlen + state->ndist) {
|
||||
for (;;) {
|
||||
this = lencode[BITS(lenbits)];
|
||||
if ((unsigned)(this.bits) <= bits) break;
|
||||
PULLBYTE();
|
||||
}
|
||||
if (this.val < 16) {
|
||||
NEEDBITS(this.bits);
|
||||
DROPBITS(this.bits);
|
||||
state->lens[state->have++] = this.val;
|
||||
}
|
||||
else {
|
||||
if (this.val == 16) {
|
||||
NEEDBITS(this.bits + 2);
|
||||
DROPBITS(this.bits);
|
||||
if (state->have == 0) {
|
||||
strm->msg = (char *)"invalid bit length repeat";
|
||||
mode = BAD;
|
||||
break;
|
||||
}
|
||||
len = (unsigned)(state->lens[state->have - 1]);
|
||||
copy = 3 + BITS(2);
|
||||
DROPBITS(2);
|
||||
}
|
||||
else if (this.val == 17) {
|
||||
NEEDBITS(this.bits + 3);
|
||||
DROPBITS(this.bits);
|
||||
len = 0;
|
||||
copy = 3 + BITS(3);
|
||||
DROPBITS(3);
|
||||
}
|
||||
else {
|
||||
NEEDBITS(this.bits + 7);
|
||||
DROPBITS(this.bits);
|
||||
len = 0;
|
||||
copy = 11 + BITS(7);
|
||||
DROPBITS(7);
|
||||
}
|
||||
if (state->have + copy > state->nlen + state->ndist) {
|
||||
strm->msg = (char *)"invalid bit length repeat";
|
||||
mode = BAD;
|
||||
break;
|
||||
}
|
||||
while (copy--)
|
||||
state->lens[state->have++] = (unsigned short)len;
|
||||
}
|
||||
}
|
||||
|
||||
/* build code tables */
|
||||
state->next = state->codes;
|
||||
lencode = (code const FAR *)(state->next);
|
||||
lenbits = 9;
|
||||
ret = inflate_table9(LENS, state->lens, state->nlen,
|
||||
&(state->next), &(lenbits), state->work);
|
||||
if (ret) {
|
||||
strm->msg = (char *)"invalid literal/lengths set";
|
||||
mode = BAD;
|
||||
break;
|
||||
}
|
||||
distcode = (code const FAR *)(state->next);
|
||||
distbits = 6;
|
||||
ret = inflate_table9(DISTS, state->lens + state->nlen,
|
||||
state->ndist, &(state->next), &(distbits),
|
||||
state->work);
|
||||
if (ret) {
|
||||
strm->msg = (char *)"invalid distances set";
|
||||
mode = BAD;
|
||||
break;
|
||||
}
|
||||
Tracev((stderr, "inflate: codes ok\n"));
|
||||
mode = LEN;
|
||||
|
||||
case LEN:
|
||||
/* get a literal, length, or end-of-block code */
|
||||
for (;;) {
|
||||
this = lencode[BITS(lenbits)];
|
||||
if ((unsigned)(this.bits) <= bits) break;
|
||||
PULLBYTE();
|
||||
}
|
||||
if (this.op && (this.op & 0xf0) == 0) {
|
||||
last = this;
|
||||
for (;;) {
|
||||
this = lencode[last.val +
|
||||
(BITS(last.bits + last.op) >> last.bits)];
|
||||
if ((unsigned)(last.bits + this.bits) <= bits) break;
|
||||
PULLBYTE();
|
||||
}
|
||||
DROPBITS(last.bits);
|
||||
}
|
||||
DROPBITS(this.bits);
|
||||
length = (unsigned)this.val;
|
||||
|
||||
/* process literal */
|
||||
if (this.op == 0) {
|
||||
Tracevv((stderr, this.val >= 0x20 && this.val < 0x7f ?
|
||||
"inflate: literal '%c'\n" :
|
||||
"inflate: literal 0x%02x\n", this.val));
|
||||
ROOM();
|
||||
*put++ = (unsigned char)(length);
|
||||
left--;
|
||||
mode = LEN;
|
||||
break;
|
||||
}
|
||||
|
||||
/* process end of block */
|
||||
if (this.op & 32) {
|
||||
Tracevv((stderr, "inflate: end of block\n"));
|
||||
mode = TYPE;
|
||||
break;
|
||||
}
|
||||
|
||||
/* invalid code */
|
||||
if (this.op & 64) {
|
||||
strm->msg = (char *)"invalid literal/length code";
|
||||
mode = BAD;
|
||||
break;
|
||||
}
|
||||
|
||||
/* length code -- get extra bits, if any */
|
||||
extra = (unsigned)(this.op) & 31;
|
||||
if (extra != 0) {
|
||||
NEEDBITS(extra);
|
||||
length += BITS(extra);
|
||||
DROPBITS(extra);
|
||||
}
|
||||
Tracevv((stderr, "inflate: length %lu\n", length));
|
||||
|
||||
/* get distance code */
|
||||
for (;;) {
|
||||
this = distcode[BITS(distbits)];
|
||||
if ((unsigned)(this.bits) <= bits) break;
|
||||
PULLBYTE();
|
||||
}
|
||||
if ((this.op & 0xf0) == 0) {
|
||||
last = this;
|
||||
for (;;) {
|
||||
this = distcode[last.val +
|
||||
(BITS(last.bits + last.op) >> last.bits)];
|
||||
if ((unsigned)(last.bits + this.bits) <= bits) break;
|
||||
PULLBYTE();
|
||||
}
|
||||
DROPBITS(last.bits);
|
||||
}
|
||||
DROPBITS(this.bits);
|
||||
if (this.op & 64) {
|
||||
strm->msg = (char *)"invalid distance code";
|
||||
mode = BAD;
|
||||
break;
|
||||
}
|
||||
offset = (unsigned)this.val;
|
||||
|
||||
/* get distance extra bits, if any */
|
||||
extra = (unsigned)(this.op) & 15;
|
||||
if (extra != 0) {
|
||||
NEEDBITS(extra);
|
||||
offset += BITS(extra);
|
||||
DROPBITS(extra);
|
||||
}
|
||||
if (offset > WSIZE - (wrap ? 0: left)) {
|
||||
strm->msg = (char *)"invalid distance too far back";
|
||||
mode = BAD;
|
||||
break;
|
||||
}
|
||||
Tracevv((stderr, "inflate: distance %lu\n", offset));
|
||||
|
||||
/* copy match from window to output */
|
||||
do {
|
||||
ROOM();
|
||||
copy = WSIZE - offset;
|
||||
if (copy < left) {
|
||||
from = put + copy;
|
||||
copy = left - copy;
|
||||
}
|
||||
else {
|
||||
from = put - offset;
|
||||
copy = left;
|
||||
}
|
||||
if (copy > length) copy = length;
|
||||
length -= copy;
|
||||
left -= copy;
|
||||
do {
|
||||
*put++ = *from++;
|
||||
} while (--copy);
|
||||
} while (length != 0);
|
||||
break;
|
||||
|
||||
case DONE:
|
||||
/* inflate stream terminated properly -- write leftover output */
|
||||
ret = Z_STREAM_END;
|
||||
if (left < WSIZE) {
|
||||
if (out(out_desc, window, (unsigned)(WSIZE - left)))
|
||||
ret = Z_BUF_ERROR;
|
||||
}
|
||||
goto inf_leave;
|
||||
|
||||
case BAD:
|
||||
ret = Z_DATA_ERROR;
|
||||
goto inf_leave;
|
||||
|
||||
default: /* can't happen, but makes compilers happy */
|
||||
ret = Z_STREAM_ERROR;
|
||||
goto inf_leave;
|
||||
}
|
||||
|
||||
/* Return unused input */
|
||||
inf_leave:
|
||||
strm->next_in = next;
|
||||
strm->avail_in = have;
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ZEXPORT inflateBack9End(strm)
|
||||
z_stream FAR *strm;
|
||||
{
|
||||
if (strm == Z_NULL || strm->state == Z_NULL || strm->zfree == (free_func)0)
|
||||
return Z_STREAM_ERROR;
|
||||
ZFREE(strm, strm->state);
|
||||
strm->state = Z_NULL;
|
||||
Tracev((stderr, "inflate: end\n"));
|
||||
return Z_OK;
|
||||
}
|
||||
|
|
@ -1,29 +0,0 @@
|
|||
/* infback9.h -- header for using inflateBack9 functions
|
||||
* Copyright (C) 2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
/*
|
||||
* This header file and associated patches provide a decoder for PKWare's
|
||||
* undocumented deflate64 compression method (method 9). Use with infback9.c,
|
||||
* inftree9.h, inftree9.c, and inffix9.h. These patches are not supported.
|
||||
* This should be compiled with zlib, since it uses zutil.h and zutil.o.
|
||||
* This code has not yet been tested on 16-bit architectures. See the
|
||||
* comments in zlib.h for inflateBack() usage. These functions are used
|
||||
* identically, except that there is no windowBits parameter, and a 64K
|
||||
* window must be provided. Also if int's are 16 bits, then a zero for
|
||||
* the third parameter of the "out" function actually means 65536UL.
|
||||
* zlib.h must be included before this header file.
|
||||
*/
|
||||
|
||||
ZEXTERN int ZEXPORT inflateBack9 OF((z_stream FAR *strm,
|
||||
in_func in, void FAR *in_desc,
|
||||
out_func out, void FAR *out_desc));
|
||||
ZEXTERN int ZEXPORT inflateBack9End OF((z_stream FAR *strm));
|
||||
ZEXTERN int ZEXPORT inflateBack9Init_ OF((z_stream FAR *strm,
|
||||
unsigned char FAR *window,
|
||||
const char *version,
|
||||
int stream_size));
|
||||
#define inflateBack9Init(strm, window) \
|
||||
inflateBack9Init_((strm), (window), \
|
||||
ZLIB_VERSION, sizeof(z_stream))
|
||||
|
|
@ -1,107 +0,0 @@
|
|||
/* inffix9.h -- table for decoding deflate64 fixed codes
|
||||
* Generated automatically by makefixed9().
|
||||
*/
|
||||
|
||||
/* WARNING: this file should *not* be used by applications.
|
||||
It is part of the implementation of this library and is
|
||||
subject to change. Applications should only use zlib.h.
|
||||
*/
|
||||
|
||||
static const code lenfix[512] = {
|
||||
{96,7,0},{0,8,80},{0,8,16},{132,8,115},{130,7,31},{0,8,112},
|
||||
{0,8,48},{0,9,192},{128,7,10},{0,8,96},{0,8,32},{0,9,160},
|
||||
{0,8,0},{0,8,128},{0,8,64},{0,9,224},{128,7,6},{0,8,88},
|
||||
{0,8,24},{0,9,144},{131,7,59},{0,8,120},{0,8,56},{0,9,208},
|
||||
{129,7,17},{0,8,104},{0,8,40},{0,9,176},{0,8,8},{0,8,136},
|
||||
{0,8,72},{0,9,240},{128,7,4},{0,8,84},{0,8,20},{133,8,227},
|
||||
{131,7,43},{0,8,116},{0,8,52},{0,9,200},{129,7,13},{0,8,100},
|
||||
{0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},
|
||||
{128,7,8},{0,8,92},{0,8,28},{0,9,152},{132,7,83},{0,8,124},
|
||||
{0,8,60},{0,9,216},{130,7,23},{0,8,108},{0,8,44},{0,9,184},
|
||||
{0,8,12},{0,8,140},{0,8,76},{0,9,248},{128,7,3},{0,8,82},
|
||||
{0,8,18},{133,8,163},{131,7,35},{0,8,114},{0,8,50},{0,9,196},
|
||||
{129,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},{0,8,130},
|
||||
{0,8,66},{0,9,228},{128,7,7},{0,8,90},{0,8,26},{0,9,148},
|
||||
{132,7,67},{0,8,122},{0,8,58},{0,9,212},{130,7,19},{0,8,106},
|
||||
{0,8,42},{0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},
|
||||
{128,7,5},{0,8,86},{0,8,22},{65,8,0},{131,7,51},{0,8,118},
|
||||
{0,8,54},{0,9,204},{129,7,15},{0,8,102},{0,8,38},{0,9,172},
|
||||
{0,8,6},{0,8,134},{0,8,70},{0,9,236},{128,7,9},{0,8,94},
|
||||
{0,8,30},{0,9,156},{132,7,99},{0,8,126},{0,8,62},{0,9,220},
|
||||
{130,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
|
||||
{0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{133,8,131},
|
||||
{130,7,31},{0,8,113},{0,8,49},{0,9,194},{128,7,10},{0,8,97},
|
||||
{0,8,33},{0,9,162},{0,8,1},{0,8,129},{0,8,65},{0,9,226},
|
||||
{128,7,6},{0,8,89},{0,8,25},{0,9,146},{131,7,59},{0,8,121},
|
||||
{0,8,57},{0,9,210},{129,7,17},{0,8,105},{0,8,41},{0,9,178},
|
||||
{0,8,9},{0,8,137},{0,8,73},{0,9,242},{128,7,4},{0,8,85},
|
||||
{0,8,21},{144,8,3},{131,7,43},{0,8,117},{0,8,53},{0,9,202},
|
||||
{129,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},
|
||||
{0,8,69},{0,9,234},{128,7,8},{0,8,93},{0,8,29},{0,9,154},
|
||||
{132,7,83},{0,8,125},{0,8,61},{0,9,218},{130,7,23},{0,8,109},
|
||||
{0,8,45},{0,9,186},{0,8,13},{0,8,141},{0,8,77},{0,9,250},
|
||||
{128,7,3},{0,8,83},{0,8,19},{133,8,195},{131,7,35},{0,8,115},
|
||||
{0,8,51},{0,9,198},{129,7,11},{0,8,99},{0,8,35},{0,9,166},
|
||||
{0,8,3},{0,8,131},{0,8,67},{0,9,230},{128,7,7},{0,8,91},
|
||||
{0,8,27},{0,9,150},{132,7,67},{0,8,123},{0,8,59},{0,9,214},
|
||||
{130,7,19},{0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},
|
||||
{0,8,75},{0,9,246},{128,7,5},{0,8,87},{0,8,23},{77,8,0},
|
||||
{131,7,51},{0,8,119},{0,8,55},{0,9,206},{129,7,15},{0,8,103},
|
||||
{0,8,39},{0,9,174},{0,8,7},{0,8,135},{0,8,71},{0,9,238},
|
||||
{128,7,9},{0,8,95},{0,8,31},{0,9,158},{132,7,99},{0,8,127},
|
||||
{0,8,63},{0,9,222},{130,7,27},{0,8,111},{0,8,47},{0,9,190},
|
||||
{0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},
|
||||
{0,8,16},{132,8,115},{130,7,31},{0,8,112},{0,8,48},{0,9,193},
|
||||
{128,7,10},{0,8,96},{0,8,32},{0,9,161},{0,8,0},{0,8,128},
|
||||
{0,8,64},{0,9,225},{128,7,6},{0,8,88},{0,8,24},{0,9,145},
|
||||
{131,7,59},{0,8,120},{0,8,56},{0,9,209},{129,7,17},{0,8,104},
|
||||
{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},{0,9,241},
|
||||
{128,7,4},{0,8,84},{0,8,20},{133,8,227},{131,7,43},{0,8,116},
|
||||
{0,8,52},{0,9,201},{129,7,13},{0,8,100},{0,8,36},{0,9,169},
|
||||
{0,8,4},{0,8,132},{0,8,68},{0,9,233},{128,7,8},{0,8,92},
|
||||
{0,8,28},{0,9,153},{132,7,83},{0,8,124},{0,8,60},{0,9,217},
|
||||
{130,7,23},{0,8,108},{0,8,44},{0,9,185},{0,8,12},{0,8,140},
|
||||
{0,8,76},{0,9,249},{128,7,3},{0,8,82},{0,8,18},{133,8,163},
|
||||
{131,7,35},{0,8,114},{0,8,50},{0,9,197},{129,7,11},{0,8,98},
|
||||
{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
|
||||
{128,7,7},{0,8,90},{0,8,26},{0,9,149},{132,7,67},{0,8,122},
|
||||
{0,8,58},{0,9,213},{130,7,19},{0,8,106},{0,8,42},{0,9,181},
|
||||
{0,8,10},{0,8,138},{0,8,74},{0,9,245},{128,7,5},{0,8,86},
|
||||
{0,8,22},{65,8,0},{131,7,51},{0,8,118},{0,8,54},{0,9,205},
|
||||
{129,7,15},{0,8,102},{0,8,38},{0,9,173},{0,8,6},{0,8,134},
|
||||
{0,8,70},{0,9,237},{128,7,9},{0,8,94},{0,8,30},{0,9,157},
|
||||
{132,7,99},{0,8,126},{0,8,62},{0,9,221},{130,7,27},{0,8,110},
|
||||
{0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},
|
||||
{96,7,0},{0,8,81},{0,8,17},{133,8,131},{130,7,31},{0,8,113},
|
||||
{0,8,49},{0,9,195},{128,7,10},{0,8,97},{0,8,33},{0,9,163},
|
||||
{0,8,1},{0,8,129},{0,8,65},{0,9,227},{128,7,6},{0,8,89},
|
||||
{0,8,25},{0,9,147},{131,7,59},{0,8,121},{0,8,57},{0,9,211},
|
||||
{129,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},{0,8,137},
|
||||
{0,8,73},{0,9,243},{128,7,4},{0,8,85},{0,8,21},{144,8,3},
|
||||
{131,7,43},{0,8,117},{0,8,53},{0,9,203},{129,7,13},{0,8,101},
|
||||
{0,8,37},{0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},
|
||||
{128,7,8},{0,8,93},{0,8,29},{0,9,155},{132,7,83},{0,8,125},
|
||||
{0,8,61},{0,9,219},{130,7,23},{0,8,109},{0,8,45},{0,9,187},
|
||||
{0,8,13},{0,8,141},{0,8,77},{0,9,251},{128,7,3},{0,8,83},
|
||||
{0,8,19},{133,8,195},{131,7,35},{0,8,115},{0,8,51},{0,9,199},
|
||||
{129,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
|
||||
{0,8,67},{0,9,231},{128,7,7},{0,8,91},{0,8,27},{0,9,151},
|
||||
{132,7,67},{0,8,123},{0,8,59},{0,9,215},{130,7,19},{0,8,107},
|
||||
{0,8,43},{0,9,183},{0,8,11},{0,8,139},{0,8,75},{0,9,247},
|
||||
{128,7,5},{0,8,87},{0,8,23},{77,8,0},{131,7,51},{0,8,119},
|
||||
{0,8,55},{0,9,207},{129,7,15},{0,8,103},{0,8,39},{0,9,175},
|
||||
{0,8,7},{0,8,135},{0,8,71},{0,9,239},{128,7,9},{0,8,95},
|
||||
{0,8,31},{0,9,159},{132,7,99},{0,8,127},{0,8,63},{0,9,223},
|
||||
{130,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},
|
||||
{0,8,79},{0,9,255}
|
||||
};
|
||||
|
||||
static const code distfix[32] = {
|
||||
{128,5,1},{135,5,257},{131,5,17},{139,5,4097},{129,5,5},
|
||||
{137,5,1025},{133,5,65},{141,5,16385},{128,5,3},{136,5,513},
|
||||
{132,5,33},{140,5,8193},{130,5,9},{138,5,2049},{134,5,129},
|
||||
{142,5,32769},{128,5,2},{135,5,385},{131,5,25},{139,5,6145},
|
||||
{129,5,7},{137,5,1537},{133,5,97},{141,5,24577},{128,5,4},
|
||||
{136,5,769},{132,5,49},{140,5,12289},{130,5,13},{138,5,3073},
|
||||
{134,5,193},{142,5,49153}
|
||||
};
|
||||
|
|
@ -1,47 +0,0 @@
|
|||
/* inflate9.h -- internal inflate state definition
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the compression library and is
|
||||
subject to change. Applications should only use zlib.h.
|
||||
*/
|
||||
|
||||
/* Possible inflate modes between inflate() calls */
|
||||
typedef enum {
|
||||
TYPE, /* i: waiting for type bits, including last-flag bit */
|
||||
STORED, /* i: waiting for stored size (length and complement) */
|
||||
TABLE, /* i: waiting for dynamic block table lengths */
|
||||
LEN, /* i: waiting for length/lit code */
|
||||
DONE, /* finished check, done -- remain here until reset */
|
||||
BAD /* got a data error -- remain here until reset */
|
||||
} inflate_mode;
|
||||
|
||||
/*
|
||||
State transitions between above modes -
|
||||
|
||||
(most modes can go to the BAD mode -- not shown for clarity)
|
||||
|
||||
Read deflate blocks:
|
||||
TYPE -> STORED or TABLE or LEN or DONE
|
||||
STORED -> TYPE
|
||||
TABLE -> LENLENS -> CODELENS -> LEN
|
||||
Read deflate codes:
|
||||
LEN -> LEN or TYPE
|
||||
*/
|
||||
|
||||
/* state maintained between inflate() calls. Approximately 7K bytes. */
|
||||
struct inflate_state {
|
||||
/* sliding window */
|
||||
unsigned char FAR *window; /* allocated sliding window, if needed */
|
||||
/* dynamic table building */
|
||||
unsigned ncode; /* number of code length code lengths */
|
||||
unsigned nlen; /* number of length code lengths */
|
||||
unsigned ndist; /* number of distance code lengths */
|
||||
unsigned have; /* number of code lengths in lens[] */
|
||||
code FAR *next; /* next available space in codes[] */
|
||||
unsigned short lens[320]; /* temporary storage for code lengths */
|
||||
unsigned short work[288]; /* work area for code table building */
|
||||
code codes[ENOUGH]; /* space for code tables */
|
||||
};
|
||||
|
|
@ -1,323 +0,0 @@
|
|||
/* inftree9.c -- generate Huffman trees for efficient decoding
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
#include "zutil.h"
|
||||
#include "inftree9.h"
|
||||
|
||||
#define MAXBITS 15
|
||||
|
||||
const char inflate9_copyright[] =
|
||||
" inflate9 1.2.1 Copyright 1995-2003 Mark Adler ";
|
||||
/*
|
||||
If you use the zlib library in a product, an acknowledgment is welcome
|
||||
in the documentation of your product. If for some reason you cannot
|
||||
include such an acknowledgment, I would appreciate that you keep this
|
||||
copyright string in the executable of your product.
|
||||
*/
|
||||
|
||||
/*
|
||||
Build a set of tables to decode the provided canonical Huffman code.
|
||||
The code lengths are lens[0..codes-1]. The result starts at *table,
|
||||
whose indices are 0..2^bits-1. work is a writable array of at least
|
||||
lens shorts, which is used as a work area. type is the type of code
|
||||
to be generated, CODES, LENS, or DISTS. On return, zero is success,
|
||||
-1 is an invalid code, and +1 means that ENOUGH isn't enough. table
|
||||
on return points to the next available entry's address. bits is the
|
||||
requested root table index bits, and on return it is the actual root
|
||||
table index bits. It will differ if the request is greater than the
|
||||
longest code or if it is less than the shortest code.
|
||||
*/
|
||||
int inflate_table9(type, lens, codes, table, bits, work)
|
||||
codetype type;
|
||||
unsigned short FAR *lens;
|
||||
unsigned codes;
|
||||
code FAR * FAR *table;
|
||||
unsigned FAR *bits;
|
||||
unsigned short FAR *work;
|
||||
{
|
||||
unsigned len; /* a code's length in bits */
|
||||
unsigned sym; /* index of code symbols */
|
||||
unsigned min, max; /* minimum and maximum code lengths */
|
||||
unsigned root; /* number of index bits for root table */
|
||||
unsigned curr; /* number of index bits for current table */
|
||||
unsigned drop; /* code bits to drop for sub-table */
|
||||
int left; /* number of prefix codes available */
|
||||
unsigned used; /* code entries in table used */
|
||||
unsigned huff; /* Huffman code */
|
||||
unsigned incr; /* for incrementing code, index */
|
||||
unsigned fill; /* index for replicating entries */
|
||||
unsigned low; /* low bits for current root entry */
|
||||
unsigned mask; /* mask for low root bits */
|
||||
code this; /* table entry for duplication */
|
||||
code FAR *next; /* next available space in table */
|
||||
const unsigned short FAR *base; /* base value table to use */
|
||||
const unsigned short FAR *extra; /* extra bits table to use */
|
||||
int end; /* use base and extra for symbol > end */
|
||||
unsigned short count[MAXBITS+1]; /* number of codes of each length */
|
||||
unsigned short offs[MAXBITS+1]; /* offsets in table for each length */
|
||||
static const unsigned short lbase[31] = { /* Length codes 257..285 base */
|
||||
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17,
|
||||
19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115,
|
||||
131, 163, 195, 227, 3, 0, 0};
|
||||
static const unsigned short lext[31] = { /* Length codes 257..285 extra */
|
||||
128, 128, 128, 128, 128, 128, 128, 128, 129, 129, 129, 129,
|
||||
130, 130, 130, 130, 131, 131, 131, 131, 132, 132, 132, 132,
|
||||
133, 133, 133, 133, 144, 76, 66};
|
||||
static const unsigned short dbase[32] = { /* Distance codes 0..31 base */
|
||||
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49,
|
||||
65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073,
|
||||
4097, 6145, 8193, 12289, 16385, 24577, 32769, 49153};
|
||||
static const unsigned short dext[32] = { /* Distance codes 0..31 extra */
|
||||
128, 128, 128, 128, 129, 129, 130, 130, 131, 131, 132, 132,
|
||||
133, 133, 134, 134, 135, 135, 136, 136, 137, 137, 138, 138,
|
||||
139, 139, 140, 140, 141, 141, 142, 142};
|
||||
|
||||
/*
|
||||
Process a set of code lengths to create a canonical Huffman code. The
|
||||
code lengths are lens[0..codes-1]. Each length corresponds to the
|
||||
symbols 0..codes-1. The Huffman code is generated by first sorting the
|
||||
symbols by length from short to long, and retaining the symbol order
|
||||
for codes with equal lengths. Then the code starts with all zero bits
|
||||
for the first code of the shortest length, and the codes are integer
|
||||
increments for the same length, and zeros are appended as the length
|
||||
increases. For the deflate format, these bits are stored backwards
|
||||
from their more natural integer increment ordering, and so when the
|
||||
decoding tables are built in the large loop below, the integer codes
|
||||
are incremented backwards.
|
||||
|
||||
This routine assumes, but does not check, that all of the entries in
|
||||
lens[] are in the range 0..MAXBITS. The caller must assure this.
|
||||
1..MAXBITS is interpreted as that code length. zero means that that
|
||||
symbol does not occur in this code.
|
||||
|
||||
The codes are sorted by computing a count of codes for each length,
|
||||
creating from that a table of starting indices for each length in the
|
||||
sorted table, and then entering the symbols in order in the sorted
|
||||
table. The sorted table is work[], with that space being provided by
|
||||
the caller.
|
||||
|
||||
The length counts are used for other purposes as well, i.e. finding
|
||||
the minimum and maximum length codes, determining if there are any
|
||||
codes at all, checking for a valid set of lengths, and looking ahead
|
||||
at length counts to determine sub-table sizes when building the
|
||||
decoding tables.
|
||||
*/
|
||||
|
||||
/* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
|
||||
for (len = 0; len <= MAXBITS; len++)
|
||||
count[len] = 0;
|
||||
for (sym = 0; sym < codes; sym++)
|
||||
count[lens[sym]]++;
|
||||
|
||||
/* bound code lengths, force root to be within code lengths */
|
||||
root = *bits;
|
||||
for (max = MAXBITS; max >= 1; max--)
|
||||
if (count[max] != 0) break;
|
||||
if (root > max) root = max;
|
||||
if (max == 0) return -1; /* no codes! */
|
||||
for (min = 1; min <= MAXBITS; min++)
|
||||
if (count[min] != 0) break;
|
||||
if (root < min) root = min;
|
||||
|
||||
/* check for an over-subscribed or incomplete set of lengths */
|
||||
left = 1;
|
||||
for (len = 1; len <= MAXBITS; len++) {
|
||||
left <<= 1;
|
||||
left -= count[len];
|
||||
if (left < 0) return -1; /* over-subscribed */
|
||||
}
|
||||
if (left > 0 && (type == CODES || (codes - count[0] != 1)))
|
||||
return -1; /* incomplete set */
|
||||
|
||||
/* generate offsets into symbol table for each length for sorting */
|
||||
offs[1] = 0;
|
||||
for (len = 1; len < MAXBITS; len++)
|
||||
offs[len + 1] = offs[len] + count[len];
|
||||
|
||||
/* sort symbols by length, by symbol order within each length */
|
||||
for (sym = 0; sym < codes; sym++)
|
||||
if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
|
||||
|
||||
/*
|
||||
Create and fill in decoding tables. In this loop, the table being
|
||||
filled is at next and has curr index bits. The code being used is huff
|
||||
with length len. That code is converted to an index by dropping drop
|
||||
bits off of the bottom. For codes where len is less than drop + curr,
|
||||
those top drop + curr - len bits are incremented through all values to
|
||||
fill the table with replicated entries.
|
||||
|
||||
root is the number of index bits for the root table. When len exceeds
|
||||
root, sub-tables are created pointed to by the root entry with an index
|
||||
of the low root bits of huff. This is saved in low to check for when a
|
||||
new sub-table should be started. drop is zero when the root table is
|
||||
being filled, and drop is root when sub-tables are being filled.
|
||||
|
||||
When a new sub-table is needed, it is necessary to look ahead in the
|
||||
code lengths to determine what size sub-table is needed. The length
|
||||
counts are used for this, and so count[] is decremented as codes are
|
||||
entered in the tables.
|
||||
|
||||
used keeps track of how many table entries have been allocated from the
|
||||
provided *table space. It is checked when a LENS table is being made
|
||||
against the space in *table, ENOUGH, minus the maximum space needed by
|
||||
the worst case distance code, MAXD. This should never happen, but the
|
||||
sufficiency of ENOUGH has not been proven exhaustively, hence the check.
|
||||
This assumes that when type == LENS, bits == 9.
|
||||
|
||||
sym increments through all symbols, and the loop terminates when
|
||||
all codes of length max, i.e. all codes, have been processed. This
|
||||
routine permits incomplete codes, so another loop after this one fills
|
||||
in the rest of the decoding tables with invalid code markers.
|
||||
*/
|
||||
|
||||
/* set up for code type */
|
||||
switch (type) {
|
||||
case CODES:
|
||||
base = extra = work; /* dummy value--not used */
|
||||
end = 19;
|
||||
break;
|
||||
case LENS:
|
||||
base = lbase;
|
||||
base -= 257;
|
||||
extra = lext;
|
||||
extra -= 257;
|
||||
end = 256;
|
||||
break;
|
||||
default: /* DISTS */
|
||||
base = dbase;
|
||||
extra = dext;
|
||||
end = -1;
|
||||
}
|
||||
|
||||
/* initialize state for loop */
|
||||
huff = 0; /* starting code */
|
||||
sym = 0; /* starting code symbol */
|
||||
len = min; /* starting code length */
|
||||
next = *table; /* current table to fill in */
|
||||
curr = root; /* current table index bits */
|
||||
drop = 0; /* current bits to drop from code for index */
|
||||
low = (unsigned)(-1); /* trigger new sub-table when len > root */
|
||||
used = 1U << root; /* use root table entries */
|
||||
mask = used - 1; /* mask for comparing low */
|
||||
|
||||
/* check available table space */
|
||||
if (type == LENS && used >= ENOUGH - MAXD)
|
||||
return 1;
|
||||
|
||||
/* process all codes and make table entries */
|
||||
for (;;) {
|
||||
/* create table entry */
|
||||
this.bits = (unsigned char)(len - drop);
|
||||
if ((int)(work[sym]) < end) {
|
||||
this.op = (unsigned char)0;
|
||||
this.val = work[sym];
|
||||
}
|
||||
else if ((int)(work[sym]) > end) {
|
||||
this.op = (unsigned char)(extra[work[sym]]);
|
||||
this.val = base[work[sym]];
|
||||
}
|
||||
else {
|
||||
this.op = (unsigned char)(32 + 64); /* end of block */
|
||||
this.val = 0;
|
||||
}
|
||||
|
||||
/* replicate for those indices with low len bits equal to huff */
|
||||
incr = 1U << (len - drop);
|
||||
fill = 1U << curr;
|
||||
do {
|
||||
fill -= incr;
|
||||
next[(huff >> drop) + fill] = this;
|
||||
} while (fill != 0);
|
||||
|
||||
/* backwards increment the len-bit code huff */
|
||||
incr = 1U << (len - 1);
|
||||
while (huff & incr)
|
||||
incr >>= 1;
|
||||
if (incr != 0) {
|
||||
huff &= incr - 1;
|
||||
huff += incr;
|
||||
}
|
||||
else
|
||||
huff = 0;
|
||||
|
||||
/* go to next symbol, update count, len */
|
||||
sym++;
|
||||
if (--(count[len]) == 0) {
|
||||
if (len == max) break;
|
||||
len = lens[work[sym]];
|
||||
}
|
||||
|
||||
/* create new sub-table if needed */
|
||||
if (len > root && (huff & mask) != low) {
|
||||
/* if first time, transition to sub-tables */
|
||||
if (drop == 0)
|
||||
drop = root;
|
||||
|
||||
/* increment past last table */
|
||||
next += 1U << curr;
|
||||
|
||||
/* determine length of next table */
|
||||
curr = len - drop;
|
||||
left = (int)(1 << curr);
|
||||
while (curr + drop < max) {
|
||||
left -= count[curr + drop];
|
||||
if (left <= 0) break;
|
||||
curr++;
|
||||
left <<= 1;
|
||||
}
|
||||
|
||||
/* check for enough space */
|
||||
used += 1U << curr;
|
||||
if (type == LENS && used >= ENOUGH - MAXD)
|
||||
return 1;
|
||||
|
||||
/* point entry in root table to sub-table */
|
||||
low = huff & mask;
|
||||
(*table)[low].op = (unsigned char)curr;
|
||||
(*table)[low].bits = (unsigned char)root;
|
||||
(*table)[low].val = (unsigned short)(next - *table);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
Fill in rest of table for incomplete codes. This loop is similar to the
|
||||
loop above in incrementing huff for table indices. It is assumed that
|
||||
len is equal to curr + drop, so there is no loop needed to increment
|
||||
through high index bits. When the current sub-table is filled, the loop
|
||||
drops back to the root table to fill in any remaining entries there.
|
||||
*/
|
||||
this.op = (unsigned char)64; /* invalid code marker */
|
||||
this.bits = (unsigned char)(len - drop);
|
||||
this.val = (unsigned short)0;
|
||||
while (huff != 0) {
|
||||
/* when done with sub-table, drop back to root table */
|
||||
if (drop != 0 && (huff & mask) != low) {
|
||||
drop = 0;
|
||||
len = root;
|
||||
next = *table;
|
||||
curr = root;
|
||||
this.bits = (unsigned char)len;
|
||||
}
|
||||
|
||||
/* put invalid code marker in table */
|
||||
next[huff >> drop] = this;
|
||||
|
||||
/* backwards increment the len-bit code huff */
|
||||
incr = 1U << (len - 1);
|
||||
while (huff & incr)
|
||||
incr >>= 1;
|
||||
if (incr != 0) {
|
||||
huff &= incr - 1;
|
||||
huff += incr;
|
||||
}
|
||||
else
|
||||
huff = 0;
|
||||
}
|
||||
|
||||
/* set return parameters */
|
||||
*table += used;
|
||||
*bits = root;
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,55 +0,0 @@
|
|||
/* inftree9.h -- header to use inftree9.c
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the compression library and is
|
||||
subject to change. Applications should only use zlib.h.
|
||||
*/
|
||||
|
||||
/* Structure for decoding tables. Each entry provides either the
|
||||
information needed to do the operation requested by the code that
|
||||
indexed that table entry, or it provides a pointer to another
|
||||
table that indexes more bits of the code. op indicates whether
|
||||
the entry is a pointer to another table, a literal, a length or
|
||||
distance, an end-of-block, or an invalid code. For a table
|
||||
pointer, the low four bits of op is the number of index bits of
|
||||
that table. For a length or distance, the low four bits of op
|
||||
is the number of extra bits to get after the code. bits is
|
||||
the number of bits in this code or part of the code to drop off
|
||||
of the bit buffer. val is the actual byte to output in the case
|
||||
of a literal, the base length or distance, or the offset from
|
||||
the current table to the next table. Each entry is four bytes. */
|
||||
typedef struct {
|
||||
unsigned char op; /* operation, extra bits, table bits */
|
||||
unsigned char bits; /* bits in this part of the code */
|
||||
unsigned short val; /* offset in table or code value */
|
||||
} code;
|
||||
|
||||
/* op values as set by inflate_table():
|
||||
00000000 - literal
|
||||
0000tttt - table link, tttt != 0 is the number of table index bits
|
||||
100eeeee - length or distance, eeee is the number of extra bits
|
||||
01100000 - end of block
|
||||
01000000 - invalid code
|
||||
*/
|
||||
|
||||
/* Maximum size of dynamic tree. The maximum found in a long but non-
|
||||
exhaustive search was 1004 code structures (850 for length/literals
|
||||
and 154 for distances, the latter actually the result of an
|
||||
exhaustive search). The true maximum is not known, but the value
|
||||
below is more than safe. */
|
||||
#define ENOUGH 1440
|
||||
#define MAXD 154
|
||||
|
||||
/* Type of code to build for inftable() */
|
||||
typedef enum {
|
||||
CODES,
|
||||
LENS,
|
||||
DISTS
|
||||
} codetype;
|
||||
|
||||
extern int inflate_table9 OF((codetype type, unsigned short FAR *lens,
|
||||
unsigned codes, code FAR * FAR *table,
|
||||
unsigned FAR *bits, unsigned short FAR *work));
|
||||
|
|
@ -1,783 +0,0 @@
|
|||
/* inffas86.c is a hand tuned assembler version of
|
||||
*
|
||||
* inffast.c -- fast decoding
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*
|
||||
* Copyright (C) 2003 Chris Anderson <christop@charm.net>
|
||||
* Please use the copyright conditions above.
|
||||
*
|
||||
* Mar-13-2003 -- Most of this is derived from inffast.S which is derived from
|
||||
* the gcc -S output of zlib-1.2.0/inffast.c. Zlib-1.2.0 is in beta release at
|
||||
* the moment. I have successfully compiled and tested this code with gcc2.96,
|
||||
* gcc3.2, icc5.0, msvc6.0. It is very close to the speed of inffast.S
|
||||
* compiled with gcc -DNO_MMX, but inffast.S is still faster on the P3 with MMX
|
||||
* enabled. I will attempt to merge the MMX code into this version. Newer
|
||||
* versions of this and inffast.S can be found at
|
||||
* http://www.eetbeetee.com/zlib/ and http://www.charm.net/~christop/zlib/
|
||||
*/
|
||||
|
||||
#include "zutil.h"
|
||||
#include "inftrees.h"
|
||||
#include "inflate.h"
|
||||
#include "inffast.h"
|
||||
|
||||
/* Mark Adler's comments from inffast.c: */
|
||||
|
||||
/*
|
||||
Decode literal, length, and distance codes and write out the resulting
|
||||
literal and match bytes until either not enough input or output is
|
||||
available, an end-of-block is encountered, or a data error is encountered.
|
||||
When large enough input and output buffers are supplied to inflate(), for
|
||||
example, a 16K input buffer and a 64K output buffer, more than 95% of the
|
||||
inflate execution time is spent in this routine.
|
||||
|
||||
Entry assumptions:
|
||||
|
||||
state->mode == LEN
|
||||
strm->avail_in >= 6
|
||||
strm->avail_out >= 258
|
||||
start >= strm->avail_out
|
||||
state->bits < 8
|
||||
|
||||
On return, state->mode is one of:
|
||||
|
||||
LEN -- ran out of enough output space or enough available input
|
||||
TYPE -- reached end of block code, inflate() to interpret next block
|
||||
BAD -- error in block data
|
||||
|
||||
Notes:
|
||||
|
||||
- The maximum input bits used by a length/distance pair is 15 bits for the
|
||||
length code, 5 bits for the length extra, 15 bits for the distance code,
|
||||
and 13 bits for the distance extra. This totals 48 bits, or six bytes.
|
||||
Therefore if strm->avail_in >= 6, then there is enough input to avoid
|
||||
checking for available input while decoding.
|
||||
|
||||
- The maximum bytes that a single length/distance pair can output is 258
|
||||
bytes, which is the maximum length that can be coded. inflate_fast()
|
||||
requires strm->avail_out >= 258 for each loop to avoid checking for
|
||||
output space.
|
||||
*/
|
||||
void inflate_fast(strm, start)
|
||||
z_streamp strm;
|
||||
unsigned start; /* inflate()'s starting value for strm->avail_out */
|
||||
{
|
||||
struct inflate_state FAR *state;
|
||||
struct inffast_ar {
|
||||
void *esp; /* esp save */
|
||||
unsigned char FAR *in; /* local strm->next_in */
|
||||
unsigned char FAR *last; /* while in < last, enough input available */
|
||||
unsigned char FAR *out; /* local strm->next_out */
|
||||
unsigned char FAR *beg; /* inflate()'s initial strm->next_out */
|
||||
unsigned char FAR *end; /* while out < end, enough space available */
|
||||
unsigned wsize; /* window size or zero if not using window */
|
||||
unsigned write; /* window write index */
|
||||
unsigned char FAR *window; /* allocated sliding window, if wsize != 0 */
|
||||
unsigned long hold; /* local strm->hold */
|
||||
unsigned bits; /* local strm->bits */
|
||||
code const FAR *lcode; /* local strm->lencode */
|
||||
code const FAR *dcode; /* local strm->distcode */
|
||||
unsigned lmask; /* mask for first level of length codes */
|
||||
unsigned dmask; /* mask for first level of distance codes */
|
||||
unsigned len; /* match length, unused bytes */
|
||||
unsigned dist; /* match distance */
|
||||
unsigned status; /* this is set when state changes */
|
||||
} ar;
|
||||
|
||||
/* copy state to local variables */
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
ar.in = strm->next_in;
|
||||
ar.last = ar.in + (strm->avail_in - 5);
|
||||
ar.out = strm->next_out;
|
||||
ar.beg = ar.out - (start - strm->avail_out);
|
||||
ar.end = ar.out + (strm->avail_out - 257);
|
||||
ar.wsize = state->wsize;
|
||||
ar.write = state->write;
|
||||
ar.window = state->window;
|
||||
ar.hold = state->hold;
|
||||
ar.bits = state->bits;
|
||||
ar.lcode = state->lencode;
|
||||
ar.dcode = state->distcode;
|
||||
ar.lmask = (1U << state->lenbits) - 1;
|
||||
ar.dmask = (1U << state->distbits) - 1;
|
||||
|
||||
/* decode literals and length/distances until end-of-block or not enough
|
||||
input data or output space */
|
||||
|
||||
/* align in on 2 byte boundary */
|
||||
if (((unsigned long)(void *)ar.in & 0x1) != 0) {
|
||||
ar.hold += (unsigned long)*ar.in++ << ar.bits;
|
||||
ar.bits += 8;
|
||||
}
|
||||
|
||||
#if defined( __GNUC__ ) || defined( __ICC )
|
||||
__asm__ __volatile__ (
|
||||
" leal %0, %%eax\n"
|
||||
" pushf\n"
|
||||
" pushl %%ebp\n"
|
||||
" movl %%esp, (%%eax)\n"
|
||||
" movl %%eax, %%esp\n"
|
||||
" movl 4(%%esp), %%esi\n" /* esi = in */
|
||||
" movl 12(%%esp), %%edi\n" /* edi = out */
|
||||
" movl 36(%%esp), %%edx\n" /* edx = hold */
|
||||
" movl 40(%%esp), %%ebx\n" /* ebx = bits */
|
||||
" movl 44(%%esp), %%ebp\n" /* ebp = lcode */
|
||||
|
||||
" cld\n"
|
||||
" jmp .L_do_loop\n"
|
||||
|
||||
".L_while_test:\n"
|
||||
" cmpl %%edi, 20(%%esp)\n"
|
||||
" jbe .L_break_loop\n"
|
||||
" cmpl %%esi, 8(%%esp)\n"
|
||||
" jbe .L_break_loop\n"
|
||||
|
||||
".L_do_loop:\n"
|
||||
" cmpb $15, %%bl\n"
|
||||
" ja .L_get_length_code\n" /* if (15 < bits) */
|
||||
|
||||
" xorl %%eax, %%eax\n"
|
||||
" lodsw\n" /* al = *(ushort *)in++ */
|
||||
" movb %%bl, %%cl\n" /* cl = bits, needs it for shifting */
|
||||
" addb $16, %%bl\n" /* bits += 16 */
|
||||
" shll %%cl, %%eax\n"
|
||||
" orl %%eax, %%edx\n" /* hold |= *((ushort *)in)++ << bits */
|
||||
|
||||
".L_get_length_code:\n"
|
||||
" movl 52(%%esp), %%eax\n" /* eax = lmask */
|
||||
" andl %%edx, %%eax\n" /* eax &= hold */
|
||||
" movl (%%ebp,%%eax,4), %%eax\n" /* eax = lcode[hold & lmask] */
|
||||
|
||||
".L_dolen:\n"
|
||||
" movb %%ah, %%cl\n" /* cl = this.bits */
|
||||
" subb %%ah, %%bl\n" /* bits -= this.bits */
|
||||
" shrl %%cl, %%edx\n" /* hold >>= this.bits */
|
||||
|
||||
" testb %%al, %%al\n"
|
||||
" jnz .L_test_for_length_base\n" /* if (op != 0) 45.7% */
|
||||
|
||||
" shrl $16, %%eax\n" /* output this.val char */
|
||||
" stosb\n"
|
||||
" jmp .L_while_test\n"
|
||||
|
||||
".L_test_for_length_base:\n"
|
||||
" movl %%eax, %%ecx\n" /* len = this */
|
||||
" shrl $16, %%ecx\n" /* len = this.val */
|
||||
" movl %%ecx, 60(%%esp)\n" /* len = this */
|
||||
" movb %%al, %%cl\n"
|
||||
|
||||
" testb $16, %%al\n"
|
||||
" jz .L_test_for_second_level_length\n" /* if ((op & 16) == 0) 8% */
|
||||
" andb $15, %%cl\n" /* op &= 15 */
|
||||
" jz .L_decode_distance\n" /* if (!op) */
|
||||
" cmpb %%cl, %%bl\n"
|
||||
" jae .L_add_bits_to_len\n" /* if (op <= bits) */
|
||||
|
||||
" movb %%cl, %%ch\n" /* stash op in ch, freeing cl */
|
||||
" xorl %%eax, %%eax\n"
|
||||
" lodsw\n" /* al = *(ushort *)in++ */
|
||||
" movb %%bl, %%cl\n" /* cl = bits, needs it for shifting */
|
||||
" addb $16, %%bl\n" /* bits += 16 */
|
||||
" shll %%cl, %%eax\n"
|
||||
" orl %%eax, %%edx\n" /* hold |= *((ushort *)in)++ << bits */
|
||||
" movb %%ch, %%cl\n" /* move op back to ecx */
|
||||
|
||||
".L_add_bits_to_len:\n"
|
||||
" movl $1, %%eax\n"
|
||||
" shll %%cl, %%eax\n"
|
||||
" decl %%eax\n"
|
||||
" subb %%cl, %%bl\n"
|
||||
" andl %%edx, %%eax\n" /* eax &= hold */
|
||||
" shrl %%cl, %%edx\n"
|
||||
" addl %%eax, 60(%%esp)\n" /* len += hold & mask[op] */
|
||||
|
||||
".L_decode_distance:\n"
|
||||
" cmpb $15, %%bl\n"
|
||||
" ja .L_get_distance_code\n" /* if (15 < bits) */
|
||||
|
||||
" xorl %%eax, %%eax\n"
|
||||
" lodsw\n" /* al = *(ushort *)in++ */
|
||||
" movb %%bl, %%cl\n" /* cl = bits, needs it for shifting */
|
||||
" addb $16, %%bl\n" /* bits += 16 */
|
||||
" shll %%cl, %%eax\n"
|
||||
" orl %%eax, %%edx\n" /* hold |= *((ushort *)in)++ << bits */
|
||||
|
||||
".L_get_distance_code:\n"
|
||||
" movl 56(%%esp), %%eax\n" /* eax = dmask */
|
||||
" movl 48(%%esp), %%ecx\n" /* ecx = dcode */
|
||||
" andl %%edx, %%eax\n" /* eax &= hold */
|
||||
" movl (%%ecx,%%eax,4), %%eax\n"/* eax = dcode[hold & dmask] */
|
||||
|
||||
".L_dodist:\n"
|
||||
" movl %%eax, %%ebp\n" /* dist = this */
|
||||
" shrl $16, %%ebp\n" /* dist = this.val */
|
||||
" movb %%ah, %%cl\n"
|
||||
" subb %%ah, %%bl\n" /* bits -= this.bits */
|
||||
" shrl %%cl, %%edx\n" /* hold >>= this.bits */
|
||||
" movb %%al, %%cl\n" /* cl = this.op */
|
||||
|
||||
" testb $16, %%al\n" /* if ((op & 16) == 0) */
|
||||
" jz .L_test_for_second_level_dist\n"
|
||||
" andb $15, %%cl\n" /* op &= 15 */
|
||||
" jz .L_check_dist_one\n"
|
||||
" cmpb %%cl, %%bl\n"
|
||||
" jae .L_add_bits_to_dist\n" /* if (op <= bits) 97.6% */
|
||||
|
||||
" movb %%cl, %%ch\n" /* stash op in ch, freeing cl */
|
||||
" xorl %%eax, %%eax\n"
|
||||
" lodsw\n" /* al = *(ushort *)in++ */
|
||||
" movb %%bl, %%cl\n" /* cl = bits, needs it for shifting */
|
||||
" addb $16, %%bl\n" /* bits += 16 */
|
||||
" shll %%cl, %%eax\n"
|
||||
" orl %%eax, %%edx\n" /* hold |= *((ushort *)in)++ << bits */
|
||||
" movb %%ch, %%cl\n" /* move op back to ecx */
|
||||
|
||||
".L_add_bits_to_dist:\n"
|
||||
" movl $1, %%eax\n"
|
||||
" shll %%cl, %%eax\n"
|
||||
" decl %%eax\n" /* (1 << op) - 1 */
|
||||
" subb %%cl, %%bl\n"
|
||||
" andl %%edx, %%eax\n" /* eax &= hold */
|
||||
" shrl %%cl, %%edx\n"
|
||||
" addl %%eax, %%ebp\n" /* dist += hold & ((1 << op) - 1) */
|
||||
|
||||
".L_check_window:\n"
|
||||
" movl %%esi, 4(%%esp)\n" /* save in so from can use it's reg */
|
||||
" movl %%edi, %%eax\n"
|
||||
" subl 16(%%esp), %%eax\n" /* nbytes = out - beg */
|
||||
|
||||
" cmpl %%ebp, %%eax\n"
|
||||
" jb .L_clip_window\n" /* if (dist > nbytes) 4.2% */
|
||||
|
||||
" movl 60(%%esp), %%ecx\n"
|
||||
" movl %%edi, %%esi\n"
|
||||
" subl %%ebp, %%esi\n" /* from = out - dist */
|
||||
|
||||
" subl $3, %%ecx\n" /* copy from to out */
|
||||
" movb (%%esi), %%al\n"
|
||||
" movb %%al, (%%edi)\n"
|
||||
" movb 1(%%esi), %%al\n"
|
||||
" movb 2(%%esi), %%ah\n"
|
||||
" addl $3, %%esi\n"
|
||||
" movb %%al, 1(%%edi)\n"
|
||||
" movb %%ah, 2(%%edi)\n"
|
||||
" addl $3, %%edi\n"
|
||||
" rep movsb\n"
|
||||
|
||||
" movl 4(%%esp), %%esi\n" /* move in back to %esi, toss from */
|
||||
" movl 44(%%esp), %%ebp\n" /* ebp = lcode */
|
||||
" jmp .L_while_test\n"
|
||||
|
||||
".L_check_dist_one:\n"
|
||||
" cmpl $1, %%ebp\n" /* if dist 1, is a memset */
|
||||
" jne .L_check_window\n"
|
||||
" cmpl %%edi, 16(%%esp)\n"
|
||||
" je .L_check_window\n"
|
||||
|
||||
" decl %%edi\n"
|
||||
" movl 60(%%esp), %%ecx\n"
|
||||
" movb (%%edi), %%al\n"
|
||||
" subl $3, %%ecx\n"
|
||||
|
||||
" movb %%al, 1(%%edi)\n" /* memset out with from[-1] */
|
||||
" movb %%al, 2(%%edi)\n"
|
||||
" movb %%al, 3(%%edi)\n"
|
||||
" addl $4, %%edi\n"
|
||||
" rep stosb\n"
|
||||
" movl 44(%%esp), %%ebp\n" /* ebp = lcode */
|
||||
" jmp .L_while_test\n"
|
||||
|
||||
".L_test_for_second_level_length:\n"
|
||||
" testb $64, %%al\n"
|
||||
" jnz .L_test_for_end_of_block\n" /* if ((op & 64) != 0) */
|
||||
|
||||
" movl $1, %%eax\n"
|
||||
" shll %%cl, %%eax\n"
|
||||
" decl %%eax\n"
|
||||
" andl %%edx, %%eax\n" /* eax &= hold */
|
||||
" addl 60(%%esp), %%eax\n" /* eax += this.val */
|
||||
" movl (%%ebp,%%eax,4), %%eax\n" /* eax = lcode[val+(hold&mask[op])]*/
|
||||
" jmp .L_dolen\n"
|
||||
|
||||
".L_test_for_second_level_dist:\n"
|
||||
" testb $64, %%al\n"
|
||||
" jnz .L_invalid_distance_code\n" /* if ((op & 64) != 0) */
|
||||
|
||||
" movl $1, %%eax\n"
|
||||
" shll %%cl, %%eax\n"
|
||||
" decl %%eax\n"
|
||||
" andl %%edx, %%eax\n" /* eax &= hold */
|
||||
" addl %%ebp, %%eax\n" /* eax += this.val */
|
||||
" movl 48(%%esp), %%ecx\n" /* ecx = dcode */
|
||||
" movl (%%ecx,%%eax,4), %%eax\n" /* eax = dcode[val+(hold&mask[op])]*/
|
||||
" jmp .L_dodist\n"
|
||||
|
||||
".L_clip_window:\n"
|
||||
" movl %%eax, %%ecx\n"
|
||||
" movl 24(%%esp), %%eax\n" /* prepare for dist compare */
|
||||
" negl %%ecx\n" /* nbytes = -nbytes */
|
||||
" movl 32(%%esp), %%esi\n" /* from = window */
|
||||
|
||||
" cmpl %%ebp, %%eax\n"
|
||||
" jb .L_invalid_distance_too_far\n" /* if (dist > wsize) */
|
||||
|
||||
" addl %%ebp, %%ecx\n" /* nbytes = dist - nbytes */
|
||||
" cmpl $0, 28(%%esp)\n"
|
||||
" jne .L_wrap_around_window\n" /* if (write != 0) */
|
||||
|
||||
" subl %%ecx, %%eax\n"
|
||||
" addl %%eax, %%esi\n" /* from += wsize - nbytes */
|
||||
|
||||
" movl 60(%%esp), %%eax\n"
|
||||
" cmpl %%ecx, %%eax\n"
|
||||
" jbe .L_do_copy1\n" /* if (nbytes >= len) */
|
||||
|
||||
" subl %%ecx, %%eax\n" /* len -= nbytes */
|
||||
" rep movsb\n"
|
||||
" movl %%edi, %%esi\n"
|
||||
" subl %%ebp, %%esi\n" /* from = out - dist */
|
||||
" jmp .L_do_copy1\n"
|
||||
|
||||
" cmpl %%ecx, %%eax\n"
|
||||
" jbe .L_do_copy1\n" /* if (nbytes >= len) */
|
||||
|
||||
" subl %%ecx, %%eax\n" /* len -= nbytes */
|
||||
" rep movsb\n"
|
||||
" movl %%edi, %%esi\n"
|
||||
" subl %%ebp, %%esi\n" /* from = out - dist */
|
||||
" jmp .L_do_copy1\n"
|
||||
|
||||
".L_wrap_around_window:\n"
|
||||
" movl 28(%%esp), %%eax\n"
|
||||
" cmpl %%eax, %%ecx\n"
|
||||
" jbe .L_contiguous_in_window\n" /* if (write >= nbytes) */
|
||||
|
||||
" addl 24(%%esp), %%esi\n"
|
||||
" addl %%eax, %%esi\n"
|
||||
" subl %%ecx, %%esi\n" /* from += wsize + write - nbytes */
|
||||
" subl %%eax, %%ecx\n" /* nbytes -= write */
|
||||
|
||||
" movl 60(%%esp), %%eax\n"
|
||||
" cmpl %%ecx, %%eax\n"
|
||||
" jbe .L_do_copy1\n" /* if (nbytes >= len) */
|
||||
|
||||
" subl %%ecx, %%eax\n" /* len -= nbytes */
|
||||
" rep movsb\n"
|
||||
" movl 32(%%esp), %%esi\n" /* from = window */
|
||||
" movl 28(%%esp), %%ecx\n" /* nbytes = write */
|
||||
" cmpl %%ecx, %%eax\n"
|
||||
" jbe .L_do_copy1\n" /* if (nbytes >= len) */
|
||||
|
||||
" subl %%ecx, %%eax\n" /* len -= nbytes */
|
||||
" rep movsb\n"
|
||||
" movl %%edi, %%esi\n"
|
||||
" subl %%ebp, %%esi\n" /* from = out - dist */
|
||||
" jmp .L_do_copy1\n"
|
||||
|
||||
".L_contiguous_in_window:\n"
|
||||
" addl %%eax, %%esi\n"
|
||||
" subl %%ecx, %%esi\n" /* from += write - nbytes */
|
||||
|
||||
" movl 60(%%esp), %%eax\n"
|
||||
" cmpl %%ecx, %%eax\n"
|
||||
" jbe .L_do_copy1\n" /* if (nbytes >= len) */
|
||||
|
||||
" subl %%ecx, %%eax\n" /* len -= nbytes */
|
||||
" rep movsb\n"
|
||||
" movl %%edi, %%esi\n"
|
||||
" subl %%ebp, %%esi\n" /* from = out - dist */
|
||||
|
||||
".L_do_copy1:\n"
|
||||
" movl %%eax, %%ecx\n"
|
||||
" rep movsb\n"
|
||||
|
||||
" movl 4(%%esp), %%esi\n" /* move in back to %esi, toss from */
|
||||
" movl 44(%%esp), %%ebp\n" /* ebp = lcode */
|
||||
" jmp .L_while_test\n"
|
||||
|
||||
".L_test_for_end_of_block:\n"
|
||||
" testb $32, %%al\n"
|
||||
" jz .L_invalid_literal_length_code\n"
|
||||
" movl $1, 68(%%esp)\n"
|
||||
" jmp .L_break_loop_with_status\n"
|
||||
|
||||
".L_invalid_literal_length_code:\n"
|
||||
" movl $2, 68(%%esp)\n"
|
||||
" jmp .L_break_loop_with_status\n"
|
||||
|
||||
".L_invalid_distance_code:\n"
|
||||
" movl $3, 68(%%esp)\n"
|
||||
" jmp .L_break_loop_with_status\n"
|
||||
|
||||
".L_invalid_distance_too_far:\n"
|
||||
" movl 4(%%esp), %%esi\n"
|
||||
" movl $4, 68(%%esp)\n"
|
||||
" jmp .L_break_loop_with_status\n"
|
||||
|
||||
".L_break_loop:\n"
|
||||
" movl $0, 68(%%esp)\n"
|
||||
|
||||
".L_break_loop_with_status:\n"
|
||||
/* put in, out, bits, and hold back into ar and pop esp */
|
||||
" movl %%esi, 4(%%esp)\n"
|
||||
" movl %%edi, 12(%%esp)\n"
|
||||
" movl %%ebx, 40(%%esp)\n"
|
||||
" movl %%edx, 36(%%esp)\n"
|
||||
" movl (%%esp), %%esp\n"
|
||||
" popl %%ebp\n"
|
||||
" popf\n"
|
||||
:
|
||||
: "m" (ar)
|
||||
: "memory", "%eax", "%ebx", "%ecx", "%edx", "%esi", "%edi"
|
||||
);
|
||||
#elif defined( _MSC_VER )
|
||||
__asm {
|
||||
lea eax, ar
|
||||
pushfd
|
||||
push ebp
|
||||
mov [eax], esp
|
||||
mov esp, eax
|
||||
mov esi, [esp+4] /* esi = in */
|
||||
mov edi, [esp+12] /* edi = out */
|
||||
mov edx, [esp+36] /* edx = hold */
|
||||
mov ebx, [esp+40] /* ebx = bits */
|
||||
mov ebp, [esp+44] /* ebp = lcode */
|
||||
|
||||
cld
|
||||
jmp L_do_loop
|
||||
|
||||
L_while_test:
|
||||
cmp [esp+20], edi
|
||||
jbe L_break_loop
|
||||
cmp [esp+8], esi
|
||||
jbe L_break_loop
|
||||
|
||||
L_do_loop:
|
||||
cmp bl, 15
|
||||
ja L_get_length_code /* if (15 < bits) */
|
||||
|
||||
xor eax, eax
|
||||
lodsw /* al = *(ushort *)in++ */
|
||||
mov cl, bl /* cl = bits, needs it for shifting */
|
||||
add bl, 16 /* bits += 16 */
|
||||
shl eax, cl
|
||||
or edx, eax /* hold |= *((ushort *)in)++ << bits */
|
||||
|
||||
L_get_length_code:
|
||||
mov eax, [esp+52] /* eax = lmask */
|
||||
and eax, edx /* eax &= hold */
|
||||
mov eax, [ebp+eax*4] /* eax = lcode[hold & lmask] */
|
||||
|
||||
L_dolen:
|
||||
mov cl, ah /* cl = this.bits */
|
||||
sub bl, ah /* bits -= this.bits */
|
||||
shr edx, cl /* hold >>= this.bits */
|
||||
|
||||
test al, al
|
||||
jnz L_test_for_length_base /* if (op != 0) 45.7% */
|
||||
|
||||
shr eax, 16 /* output this.val char */
|
||||
stosb
|
||||
jmp L_while_test
|
||||
|
||||
L_test_for_length_base:
|
||||
mov ecx, eax /* len = this */
|
||||
shr ecx, 16 /* len = this.val */
|
||||
mov [esp+60], ecx /* len = this */
|
||||
mov cl, al
|
||||
|
||||
test al, 16
|
||||
jz L_test_for_second_level_length /* if ((op & 16) == 0) 8% */
|
||||
and cl, 15 /* op &= 15 */
|
||||
jz L_decode_distance /* if (!op) */
|
||||
cmp bl, cl
|
||||
jae L_add_bits_to_len /* if (op <= bits) */
|
||||
|
||||
mov ch, cl /* stash op in ch, freeing cl */
|
||||
xor eax, eax
|
||||
lodsw /* al = *(ushort *)in++ */
|
||||
mov cl, bl /* cl = bits, needs it for shifting */
|
||||
add bl, 16 /* bits += 16 */
|
||||
shl eax, cl
|
||||
or edx, eax /* hold |= *((ushort *)in)++ << bits */
|
||||
mov cl, ch /* move op back to ecx */
|
||||
|
||||
L_add_bits_to_len:
|
||||
mov eax, 1
|
||||
shl eax, cl
|
||||
dec eax
|
||||
sub bl, cl
|
||||
and eax, edx /* eax &= hold */
|
||||
shr edx, cl
|
||||
add [esp+60], eax /* len += hold & mask[op] */
|
||||
|
||||
L_decode_distance:
|
||||
cmp bl, 15
|
||||
ja L_get_distance_code /* if (15 < bits) */
|
||||
|
||||
xor eax, eax
|
||||
lodsw /* al = *(ushort *)in++ */
|
||||
mov cl, bl /* cl = bits, needs it for shifting */
|
||||
add bl, 16 /* bits += 16 */
|
||||
shl eax, cl
|
||||
or edx, eax /* hold |= *((ushort *)in)++ << bits */
|
||||
|
||||
L_get_distance_code:
|
||||
mov eax, [esp+56] /* eax = dmask */
|
||||
mov ecx, [esp+48] /* ecx = dcode */
|
||||
and eax, edx /* eax &= hold */
|
||||
mov eax, [ecx+eax*4]/* eax = dcode[hold & dmask] */
|
||||
|
||||
L_dodist:
|
||||
mov ebp, eax /* dist = this */
|
||||
shr ebp, 16 /* dist = this.val */
|
||||
mov cl, ah
|
||||
sub bl, ah /* bits -= this.bits */
|
||||
shr edx, cl /* hold >>= this.bits */
|
||||
mov cl, al /* cl = this.op */
|
||||
|
||||
test al, 16 /* if ((op & 16) == 0) */
|
||||
jz L_test_for_second_level_dist
|
||||
and cl, 15 /* op &= 15 */
|
||||
jz L_check_dist_one
|
||||
cmp bl, cl
|
||||
jae L_add_bits_to_dist /* if (op <= bits) 97.6% */
|
||||
|
||||
mov ch, cl /* stash op in ch, freeing cl */
|
||||
xor eax, eax
|
||||
lodsw /* al = *(ushort *)in++ */
|
||||
mov cl, bl /* cl = bits, needs it for shifting */
|
||||
add bl, 16 /* bits += 16 */
|
||||
shl eax, cl
|
||||
or edx, eax /* hold |= *((ushort *)in)++ << bits */
|
||||
mov cl, ch /* move op back to ecx */
|
||||
|
||||
L_add_bits_to_dist:
|
||||
mov eax, 1
|
||||
shl eax, cl
|
||||
dec eax /* (1 << op) - 1 */
|
||||
sub bl, cl
|
||||
and eax, edx /* eax &= hold */
|
||||
shr edx, cl
|
||||
add ebp, eax /* dist += hold & ((1 << op) - 1) */
|
||||
|
||||
L_check_window:
|
||||
mov [esp+4], esi /* save in so from can use it's reg */
|
||||
mov eax, edi
|
||||
sub eax, [esp+16] /* nbytes = out - beg */
|
||||
|
||||
cmp eax, ebp
|
||||
jb L_clip_window /* if (dist > nbytes) 4.2% */
|
||||
|
||||
mov ecx, [esp+60]
|
||||
mov esi, edi
|
||||
sub esi, ebp /* from = out - dist */
|
||||
|
||||
sub ecx, 3 /* copy from to out */
|
||||
mov al, [esi]
|
||||
mov [edi], al
|
||||
mov al, [esi+1]
|
||||
mov ah, [esi+2]
|
||||
add esi, 3
|
||||
mov [edi+1], al
|
||||
mov [edi+2], ah
|
||||
add edi, 3
|
||||
rep movsb
|
||||
|
||||
mov esi, [esp+4] /* move in back to %esi, toss from */
|
||||
mov ebp, [esp+44] /* ebp = lcode */
|
||||
jmp L_while_test
|
||||
|
||||
L_check_dist_one:
|
||||
cmp ebp, 1 /* if dist 1, is a memset */
|
||||
jne L_check_window
|
||||
cmp [esp+16], edi
|
||||
je L_check_window
|
||||
|
||||
dec edi
|
||||
mov ecx, [esp+60]
|
||||
mov al, [edi]
|
||||
sub ecx, 3
|
||||
|
||||
mov [edi+1], al /* memset out with from[-1] */
|
||||
mov [edi+2], al
|
||||
mov [edi+3], al
|
||||
add edi, 4
|
||||
rep stosb
|
||||
mov ebp, [esp+44] /* ebp = lcode */
|
||||
jmp L_while_test
|
||||
|
||||
L_test_for_second_level_length:
|
||||
test al, 64
|
||||
jnz L_test_for_end_of_block /* if ((op & 64) != 0) */
|
||||
|
||||
mov eax, 1
|
||||
shl eax, cl
|
||||
dec eax
|
||||
and eax, edx /* eax &= hold */
|
||||
add eax, [esp+60] /* eax += this.val */
|
||||
mov eax, [ebp+eax*4] /* eax = lcode[val+(hold&mask[op])]*/
|
||||
jmp L_dolen
|
||||
|
||||
L_test_for_second_level_dist:
|
||||
test al, 64
|
||||
jnz L_invalid_distance_code /* if ((op & 64) != 0) */
|
||||
|
||||
mov eax, 1
|
||||
shl eax, cl
|
||||
dec eax
|
||||
and eax, edx /* eax &= hold */
|
||||
add eax, ebp /* eax += this.val */
|
||||
mov ecx, [esp+48] /* ecx = dcode */
|
||||
mov eax, [ecx+eax*4] /* eax = dcode[val+(hold&mask[op])]*/
|
||||
jmp L_dodist
|
||||
|
||||
L_clip_window:
|
||||
mov ecx, eax
|
||||
mov eax, [esp+24] /* prepare for dist compare */
|
||||
neg ecx /* nbytes = -nbytes */
|
||||
mov esi, [esp+32] /* from = window */
|
||||
|
||||
cmp eax, ebp
|
||||
jb L_invalid_distance_too_far /* if (dist > wsize) */
|
||||
|
||||
add ecx, ebp /* nbytes = dist - nbytes */
|
||||
cmp dword ptr [esp+28], 0
|
||||
jne L_wrap_around_window /* if (write != 0) */
|
||||
|
||||
sub eax, ecx
|
||||
add esi, eax /* from += wsize - nbytes */
|
||||
|
||||
mov eax, [esp+60]
|
||||
cmp eax, ecx
|
||||
jbe L_do_copy1 /* if (nbytes >= len) */
|
||||
|
||||
sub eax, ecx /* len -= nbytes */
|
||||
rep movsb
|
||||
mov esi, edi
|
||||
sub esi, ebp /* from = out - dist */
|
||||
jmp L_do_copy1
|
||||
|
||||
cmp eax, ecx
|
||||
jbe L_do_copy1 /* if (nbytes >= len) */
|
||||
|
||||
sub eax, ecx /* len -= nbytes */
|
||||
rep movsb
|
||||
mov esi, edi
|
||||
sub esi, ebp /* from = out - dist */
|
||||
jmp L_do_copy1
|
||||
|
||||
L_wrap_around_window:
|
||||
mov eax, [esp+28]
|
||||
cmp ecx, eax
|
||||
jbe L_contiguous_in_window /* if (write >= nbytes) */
|
||||
|
||||
add esi, [esp+24]
|
||||
add esi, eax
|
||||
sub esi, ecx /* from += wsize + write - nbytes */
|
||||
sub ecx, eax /* nbytes -= write */
|
||||
|
||||
mov eax, [esp+60]
|
||||
cmp eax, ecx
|
||||
jbe L_do_copy1 /* if (nbytes >= len) */
|
||||
|
||||
sub eax, ecx /* len -= nbytes */
|
||||
rep movsb
|
||||
mov esi, [esp+32] /* from = window */
|
||||
mov ecx, [esp+28] /* nbytes = write */
|
||||
cmp eax, ecx
|
||||
jbe L_do_copy1 /* if (nbytes >= len) */
|
||||
|
||||
sub eax, ecx /* len -= nbytes */
|
||||
rep movsb
|
||||
mov esi, edi
|
||||
sub esi, ebp /* from = out - dist */
|
||||
jmp L_do_copy1
|
||||
|
||||
L_contiguous_in_window:
|
||||
add esi, eax
|
||||
sub esi, ecx /* from += write - nbytes */
|
||||
|
||||
mov eax, [esp+60]
|
||||
cmp eax, ecx
|
||||
jbe L_do_copy1 /* if (nbytes >= len) */
|
||||
|
||||
sub eax, ecx /* len -= nbytes */
|
||||
rep movsb
|
||||
mov esi, edi
|
||||
sub esi, ebp /* from = out - dist */
|
||||
|
||||
L_do_copy1:
|
||||
mov ecx, eax
|
||||
rep movsb
|
||||
|
||||
mov esi, [esp+4] /* move in back to %esi, toss from */
|
||||
mov ebp, [esp+44] /* ebp = lcode */
|
||||
jmp L_while_test
|
||||
|
||||
L_test_for_end_of_block:
|
||||
test al, 32
|
||||
jz L_invalid_literal_length_code
|
||||
mov dword ptr [esp+68], 1
|
||||
jmp L_break_loop_with_status
|
||||
|
||||
L_invalid_literal_length_code:
|
||||
mov dword ptr [esp+68], 2
|
||||
jmp L_break_loop_with_status
|
||||
|
||||
L_invalid_distance_code:
|
||||
mov dword ptr [esp+68], 3
|
||||
jmp L_break_loop_with_status
|
||||
|
||||
L_invalid_distance_too_far:
|
||||
mov esi, [esp+4]
|
||||
mov dword ptr [esp+68], 4
|
||||
jmp L_break_loop_with_status
|
||||
|
||||
L_break_loop:
|
||||
mov dword ptr [esp+68], 0
|
||||
|
||||
L_break_loop_with_status:
|
||||
/* put in, out, bits, and hold back into ar and pop esp */
|
||||
mov [esp+4], esi
|
||||
mov [esp+12], edi
|
||||
mov [esp+40], ebx
|
||||
mov [esp+36], edx
|
||||
mov esp, [esp]
|
||||
pop ebp
|
||||
popfd
|
||||
}
|
||||
#endif
|
||||
|
||||
if (ar.status > 1) {
|
||||
if (ar.status == 2)
|
||||
strm->msg = "invalid literal/length code";
|
||||
else if (ar.status == 3)
|
||||
strm->msg = "invalid distance code";
|
||||
else
|
||||
strm->msg = "invalid distance too far back";
|
||||
state->mode = BAD;
|
||||
}
|
||||
else if ( ar.status == 1 ) {
|
||||
state->mode = TYPE;
|
||||
}
|
||||
|
||||
/* return unused bytes (on entry, bits < 8, so in won't go too far back) */
|
||||
ar.len = ar.bits >> 3;
|
||||
ar.in -= ar.len;
|
||||
ar.bits -= ar.len << 3;
|
||||
ar.hold &= (1U << ar.bits) - 1;
|
||||
|
||||
/* update state and return */
|
||||
strm->next_in = ar.in;
|
||||
strm->next_out = ar.out;
|
||||
strm->avail_in = (unsigned)(ar.in < ar.last ? 5 + (ar.last - ar.in) :
|
||||
5 - (ar.in - ar.last));
|
||||
strm->avail_out = (unsigned)(ar.out < ar.end ? 257 + (ar.end - ar.out) :
|
||||
257 - (ar.out - ar.end));
|
||||
state->hold = ar.hold;
|
||||
state->bits = ar.bits;
|
||||
return;
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,24 +0,0 @@
|
|||
|
||||
#include "zfstream.h"
|
||||
|
||||
int main() {
|
||||
|
||||
// Construct a stream object with this filebuffer. Anything sent
|
||||
// to this stream will go to standard out.
|
||||
gzofstream os( 1, ios::out );
|
||||
|
||||
// This text is getting compressed and sent to stdout.
|
||||
// To prove this, run 'test | zcat'.
|
||||
os << "Hello, Mommy" << endl;
|
||||
|
||||
os << setcompressionlevel( Z_NO_COMPRESSION );
|
||||
os << "hello, hello, hi, ho!" << endl;
|
||||
|
||||
setcompressionlevel( os, Z_DEFAULT_COMPRESSION )
|
||||
<< "I'm compressing again" << endl;
|
||||
|
||||
os.close();
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
|
@ -1,329 +0,0 @@
|
|||
|
||||
#include "zfstream.h"
|
||||
|
||||
gzfilebuf::gzfilebuf() :
|
||||
file(NULL),
|
||||
mode(0),
|
||||
own_file_descriptor(0)
|
||||
{ }
|
||||
|
||||
gzfilebuf::~gzfilebuf() {
|
||||
|
||||
sync();
|
||||
if ( own_file_descriptor )
|
||||
close();
|
||||
|
||||
}
|
||||
|
||||
gzfilebuf *gzfilebuf::open( const char *name,
|
||||
int io_mode ) {
|
||||
|
||||
if ( is_open() )
|
||||
return NULL;
|
||||
|
||||
char char_mode[10];
|
||||
char *p = char_mode;
|
||||
|
||||
if ( io_mode & ios::in ) {
|
||||
mode = ios::in;
|
||||
*p++ = 'r';
|
||||
} else if ( io_mode & ios::app ) {
|
||||
mode = ios::app;
|
||||
*p++ = 'a';
|
||||
} else {
|
||||
mode = ios::out;
|
||||
*p++ = 'w';
|
||||
}
|
||||
|
||||
if ( io_mode & ios::binary ) {
|
||||
mode |= ios::binary;
|
||||
*p++ = 'b';
|
||||
}
|
||||
|
||||
// Hard code the compression level
|
||||
if ( io_mode & (ios::out|ios::app )) {
|
||||
*p++ = '9';
|
||||
}
|
||||
|
||||
// Put the end-of-string indicator
|
||||
*p = '\0';
|
||||
|
||||
if ( (file = gzopen(name, char_mode)) == NULL )
|
||||
return NULL;
|
||||
|
||||
own_file_descriptor = 1;
|
||||
|
||||
return this;
|
||||
|
||||
}
|
||||
|
||||
gzfilebuf *gzfilebuf::attach( int file_descriptor,
|
||||
int io_mode ) {
|
||||
|
||||
if ( is_open() )
|
||||
return NULL;
|
||||
|
||||
char char_mode[10];
|
||||
char *p = char_mode;
|
||||
|
||||
if ( io_mode & ios::in ) {
|
||||
mode = ios::in;
|
||||
*p++ = 'r';
|
||||
} else if ( io_mode & ios::app ) {
|
||||
mode = ios::app;
|
||||
*p++ = 'a';
|
||||
} else {
|
||||
mode = ios::out;
|
||||
*p++ = 'w';
|
||||
}
|
||||
|
||||
if ( io_mode & ios::binary ) {
|
||||
mode |= ios::binary;
|
||||
*p++ = 'b';
|
||||
}
|
||||
|
||||
// Hard code the compression level
|
||||
if ( io_mode & (ios::out|ios::app )) {
|
||||
*p++ = '9';
|
||||
}
|
||||
|
||||
// Put the end-of-string indicator
|
||||
*p = '\0';
|
||||
|
||||
if ( (file = gzdopen(file_descriptor, char_mode)) == NULL )
|
||||
return NULL;
|
||||
|
||||
own_file_descriptor = 0;
|
||||
|
||||
return this;
|
||||
|
||||
}
|
||||
|
||||
gzfilebuf *gzfilebuf::close() {
|
||||
|
||||
if ( is_open() ) {
|
||||
|
||||
sync();
|
||||
gzclose( file );
|
||||
file = NULL;
|
||||
|
||||
}
|
||||
|
||||
return this;
|
||||
|
||||
}
|
||||
|
||||
int gzfilebuf::setcompressionlevel( int comp_level ) {
|
||||
|
||||
return gzsetparams(file, comp_level, -2);
|
||||
|
||||
}
|
||||
|
||||
int gzfilebuf::setcompressionstrategy( int comp_strategy ) {
|
||||
|
||||
return gzsetparams(file, -2, comp_strategy);
|
||||
|
||||
}
|
||||
|
||||
|
||||
streampos gzfilebuf::seekoff( streamoff off, ios::seek_dir dir, int which ) {
|
||||
|
||||
return streampos(EOF);
|
||||
|
||||
}
|
||||
|
||||
int gzfilebuf::underflow() {
|
||||
|
||||
// If the file hasn't been opened for reading, error.
|
||||
if ( !is_open() || !(mode & ios::in) )
|
||||
return EOF;
|
||||
|
||||
// if a buffer doesn't exists, allocate one.
|
||||
if ( !base() ) {
|
||||
|
||||
if ( (allocate()) == EOF )
|
||||
return EOF;
|
||||
setp(0,0);
|
||||
|
||||
} else {
|
||||
|
||||
if ( in_avail() )
|
||||
return (unsigned char) *gptr();
|
||||
|
||||
if ( out_waiting() ) {
|
||||
if ( flushbuf() == EOF )
|
||||
return EOF;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// Attempt to fill the buffer.
|
||||
|
||||
int result = fillbuf();
|
||||
if ( result == EOF ) {
|
||||
// disable get area
|
||||
setg(0,0,0);
|
||||
return EOF;
|
||||
}
|
||||
|
||||
return (unsigned char) *gptr();
|
||||
|
||||
}
|
||||
|
||||
int gzfilebuf::overflow( int c ) {
|
||||
|
||||
if ( !is_open() || !(mode & ios::out) )
|
||||
return EOF;
|
||||
|
||||
if ( !base() ) {
|
||||
if ( allocate() == EOF )
|
||||
return EOF;
|
||||
setg(0,0,0);
|
||||
} else {
|
||||
if (in_avail()) {
|
||||
return EOF;
|
||||
}
|
||||
if (out_waiting()) {
|
||||
if (flushbuf() == EOF)
|
||||
return EOF;
|
||||
}
|
||||
}
|
||||
|
||||
int bl = blen();
|
||||
setp( base(), base() + bl);
|
||||
|
||||
if ( c != EOF ) {
|
||||
|
||||
*pptr() = c;
|
||||
pbump(1);
|
||||
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
||||
int gzfilebuf::sync() {
|
||||
|
||||
if ( !is_open() )
|
||||
return EOF;
|
||||
|
||||
if ( out_waiting() )
|
||||
return flushbuf();
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
||||
int gzfilebuf::flushbuf() {
|
||||
|
||||
int n;
|
||||
char *q;
|
||||
|
||||
q = pbase();
|
||||
n = pptr() - q;
|
||||
|
||||
if ( gzwrite( file, q, n) < n )
|
||||
return EOF;
|
||||
|
||||
setp(0,0);
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
||||
int gzfilebuf::fillbuf() {
|
||||
|
||||
int required;
|
||||
char *p;
|
||||
|
||||
p = base();
|
||||
|
||||
required = blen();
|
||||
|
||||
int t = gzread( file, p, required );
|
||||
|
||||
if ( t <= 0) return EOF;
|
||||
|
||||
setg( base(), base(), base()+t);
|
||||
|
||||
return t;
|
||||
|
||||
}
|
||||
|
||||
gzfilestream_common::gzfilestream_common() :
|
||||
ios( gzfilestream_common::rdbuf() )
|
||||
{ }
|
||||
|
||||
gzfilestream_common::~gzfilestream_common()
|
||||
{ }
|
||||
|
||||
void gzfilestream_common::attach( int fd, int io_mode ) {
|
||||
|
||||
if ( !buffer.attach( fd, io_mode) )
|
||||
clear( ios::failbit | ios::badbit );
|
||||
else
|
||||
clear();
|
||||
|
||||
}
|
||||
|
||||
void gzfilestream_common::open( const char *name, int io_mode ) {
|
||||
|
||||
if ( !buffer.open( name, io_mode ) )
|
||||
clear( ios::failbit | ios::badbit );
|
||||
else
|
||||
clear();
|
||||
|
||||
}
|
||||
|
||||
void gzfilestream_common::close() {
|
||||
|
||||
if ( !buffer.close() )
|
||||
clear( ios::failbit | ios::badbit );
|
||||
|
||||
}
|
||||
|
||||
gzfilebuf *gzfilestream_common::rdbuf()
|
||||
{
|
||||
return &buffer;
|
||||
}
|
||||
|
||||
gzifstream::gzifstream() :
|
||||
ios( gzfilestream_common::rdbuf() )
|
||||
{
|
||||
clear( ios::badbit );
|
||||
}
|
||||
|
||||
gzifstream::gzifstream( const char *name, int io_mode ) :
|
||||
ios( gzfilestream_common::rdbuf() )
|
||||
{
|
||||
gzfilestream_common::open( name, io_mode );
|
||||
}
|
||||
|
||||
gzifstream::gzifstream( int fd, int io_mode ) :
|
||||
ios( gzfilestream_common::rdbuf() )
|
||||
{
|
||||
gzfilestream_common::attach( fd, io_mode );
|
||||
}
|
||||
|
||||
gzifstream::~gzifstream() { }
|
||||
|
||||
gzofstream::gzofstream() :
|
||||
ios( gzfilestream_common::rdbuf() )
|
||||
{
|
||||
clear( ios::badbit );
|
||||
}
|
||||
|
||||
gzofstream::gzofstream( const char *name, int io_mode ) :
|
||||
ios( gzfilestream_common::rdbuf() )
|
||||
{
|
||||
gzfilestream_common::open( name, io_mode );
|
||||
}
|
||||
|
||||
gzofstream::gzofstream( int fd, int io_mode ) :
|
||||
ios( gzfilestream_common::rdbuf() )
|
||||
{
|
||||
gzfilestream_common::attach( fd, io_mode );
|
||||
}
|
||||
|
||||
gzofstream::~gzofstream() { }
|
||||
|
|
@ -1,128 +0,0 @@
|
|||
|
||||
#ifndef zfstream_h
|
||||
#define zfstream_h
|
||||
|
||||
#include <fstream.h>
|
||||
#include "zlib.h"
|
||||
|
||||
class gzfilebuf : public streambuf {
|
||||
|
||||
public:
|
||||
|
||||
gzfilebuf( );
|
||||
virtual ~gzfilebuf();
|
||||
|
||||
gzfilebuf *open( const char *name, int io_mode );
|
||||
gzfilebuf *attach( int file_descriptor, int io_mode );
|
||||
gzfilebuf *close();
|
||||
|
||||
int setcompressionlevel( int comp_level );
|
||||
int setcompressionstrategy( int comp_strategy );
|
||||
|
||||
inline int is_open() const { return (file !=NULL); }
|
||||
|
||||
virtual streampos seekoff( streamoff, ios::seek_dir, int );
|
||||
|
||||
virtual int sync();
|
||||
|
||||
protected:
|
||||
|
||||
virtual int underflow();
|
||||
virtual int overflow( int = EOF );
|
||||
|
||||
private:
|
||||
|
||||
gzFile file;
|
||||
short mode;
|
||||
short own_file_descriptor;
|
||||
|
||||
int flushbuf();
|
||||
int fillbuf();
|
||||
|
||||
};
|
||||
|
||||
class gzfilestream_common : virtual public ios {
|
||||
|
||||
friend class gzifstream;
|
||||
friend class gzofstream;
|
||||
friend gzofstream &setcompressionlevel( gzofstream &, int );
|
||||
friend gzofstream &setcompressionstrategy( gzofstream &, int );
|
||||
|
||||
public:
|
||||
virtual ~gzfilestream_common();
|
||||
|
||||
void attach( int fd, int io_mode );
|
||||
void open( const char *name, int io_mode );
|
||||
void close();
|
||||
|
||||
protected:
|
||||
gzfilestream_common();
|
||||
|
||||
private:
|
||||
gzfilebuf *rdbuf();
|
||||
|
||||
gzfilebuf buffer;
|
||||
|
||||
};
|
||||
|
||||
class gzifstream : public gzfilestream_common, public istream {
|
||||
|
||||
public:
|
||||
|
||||
gzifstream();
|
||||
gzifstream( const char *name, int io_mode = ios::in );
|
||||
gzifstream( int fd, int io_mode = ios::in );
|
||||
|
||||
virtual ~gzifstream();
|
||||
|
||||
};
|
||||
|
||||
class gzofstream : public gzfilestream_common, public ostream {
|
||||
|
||||
public:
|
||||
|
||||
gzofstream();
|
||||
gzofstream( const char *name, int io_mode = ios::out );
|
||||
gzofstream( int fd, int io_mode = ios::out );
|
||||
|
||||
virtual ~gzofstream();
|
||||
|
||||
};
|
||||
|
||||
template<class T> class gzomanip {
|
||||
friend gzofstream &operator<<(gzofstream &, const gzomanip<T> &);
|
||||
public:
|
||||
gzomanip(gzofstream &(*f)(gzofstream &, T), T v) : func(f), val(v) { }
|
||||
private:
|
||||
gzofstream &(*func)(gzofstream &, T);
|
||||
T val;
|
||||
};
|
||||
|
||||
template<class T> gzofstream &operator<<(gzofstream &s, const gzomanip<T> &m)
|
||||
{
|
||||
return (*m.func)(s, m.val);
|
||||
}
|
||||
|
||||
inline gzofstream &setcompressionlevel( gzofstream &s, int l )
|
||||
{
|
||||
(s.rdbuf())->setcompressionlevel(l);
|
||||
return s;
|
||||
}
|
||||
|
||||
inline gzofstream &setcompressionstrategy( gzofstream &s, int l )
|
||||
{
|
||||
(s.rdbuf())->setcompressionstrategy(l);
|
||||
return s;
|
||||
}
|
||||
|
||||
inline gzomanip<int> setcompressionlevel(int l)
|
||||
{
|
||||
return gzomanip<int>(&setcompressionlevel,l);
|
||||
}
|
||||
|
||||
inline gzomanip<int> setcompressionstrategy(int l)
|
||||
{
|
||||
return gzomanip<int>(&setcompressionstrategy,l);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,307 +0,0 @@
|
|||
/*
|
||||
*
|
||||
* Copyright (c) 1997
|
||||
* Christian Michelsen Research AS
|
||||
* Advanced Computing
|
||||
* Fantoftvegen 38, 5036 BERGEN, Norway
|
||||
* http://www.cmr.no
|
||||
*
|
||||
* Permission to use, copy, modify, distribute and sell this software
|
||||
* and its documentation for any purpose is hereby granted without fee,
|
||||
* provided that the above copyright notice appear in all copies and
|
||||
* that both that copyright notice and this permission notice appear
|
||||
* in supporting documentation. Christian Michelsen Research AS makes no
|
||||
* representations about the suitability of this software for any
|
||||
* purpose. It is provided "as is" without express or implied warranty.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef ZSTREAM__H
|
||||
#define ZSTREAM__H
|
||||
|
||||
/*
|
||||
* zstream.h - C++ interface to the 'zlib' general purpose compression library
|
||||
* $Id: zstream.h 1.1 1997-06-25 12:00:56+02 tyge Exp tyge $
|
||||
*/
|
||||
|
||||
#include <strstream.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include "zlib.h"
|
||||
|
||||
#if defined(_WIN32)
|
||||
# include <fcntl.h>
|
||||
# include <io.h>
|
||||
# define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
|
||||
#else
|
||||
# define SET_BINARY_MODE(file)
|
||||
#endif
|
||||
|
||||
class zstringlen {
|
||||
public:
|
||||
zstringlen(class izstream&);
|
||||
zstringlen(class ozstream&, const char*);
|
||||
size_t value() const { return val.word; }
|
||||
private:
|
||||
struct Val { unsigned char byte; size_t word; } val;
|
||||
};
|
||||
|
||||
// ----------------------------- izstream -----------------------------
|
||||
|
||||
class izstream
|
||||
{
|
||||
public:
|
||||
izstream() : m_fp(0) {}
|
||||
izstream(FILE* fp) : m_fp(0) { open(fp); }
|
||||
izstream(const char* name) : m_fp(0) { open(name); }
|
||||
~izstream() { close(); }
|
||||
|
||||
/* Opens a gzip (.gz) file for reading.
|
||||
* open() can be used to read a file which is not in gzip format;
|
||||
* in this case read() will directly read from the file without
|
||||
* decompression. errno can be checked to distinguish two error
|
||||
* cases (if errno is zero, the zlib error is Z_MEM_ERROR).
|
||||
*/
|
||||
void open(const char* name) {
|
||||
if (m_fp) close();
|
||||
m_fp = ::gzopen(name, "rb");
|
||||
}
|
||||
|
||||
void open(FILE* fp) {
|
||||
SET_BINARY_MODE(fp);
|
||||
if (m_fp) close();
|
||||
m_fp = ::gzdopen(fileno(fp), "rb");
|
||||
}
|
||||
|
||||
/* Flushes all pending input if necessary, closes the compressed file
|
||||
* and deallocates all the (de)compression state. The return value is
|
||||
* the zlib error number (see function error() below).
|
||||
*/
|
||||
int close() {
|
||||
int r = ::gzclose(m_fp);
|
||||
m_fp = 0; return r;
|
||||
}
|
||||
|
||||
/* Binary read the given number of bytes from the compressed file.
|
||||
*/
|
||||
int read(void* buf, size_t len) {
|
||||
return ::gzread(m_fp, buf, len);
|
||||
}
|
||||
|
||||
/* Returns the error message for the last error which occurred on the
|
||||
* given compressed file. errnum is set to zlib error number. If an
|
||||
* error occurred in the file system and not in the compression library,
|
||||
* errnum is set to Z_ERRNO and the application may consult errno
|
||||
* to get the exact error code.
|
||||
*/
|
||||
const char* error(int* errnum) {
|
||||
return ::gzerror(m_fp, errnum);
|
||||
}
|
||||
|
||||
gzFile fp() { return m_fp; }
|
||||
|
||||
private:
|
||||
gzFile m_fp;
|
||||
};
|
||||
|
||||
/*
|
||||
* Binary read the given (array of) object(s) from the compressed file.
|
||||
* If the input file was not in gzip format, read() copies the objects number
|
||||
* of bytes into the buffer.
|
||||
* returns the number of uncompressed bytes actually read
|
||||
* (0 for end of file, -1 for error).
|
||||
*/
|
||||
template <class T, class Items>
|
||||
inline int read(izstream& zs, T* x, Items items) {
|
||||
return ::gzread(zs.fp(), x, items*sizeof(T));
|
||||
}
|
||||
|
||||
/*
|
||||
* Binary input with the '>' operator.
|
||||
*/
|
||||
template <class T>
|
||||
inline izstream& operator>(izstream& zs, T& x) {
|
||||
::gzread(zs.fp(), &x, sizeof(T));
|
||||
return zs;
|
||||
}
|
||||
|
||||
|
||||
inline zstringlen::zstringlen(izstream& zs) {
|
||||
zs > val.byte;
|
||||
if (val.byte == 255) zs > val.word;
|
||||
else val.word = val.byte;
|
||||
}
|
||||
|
||||
/*
|
||||
* Read length of string + the string with the '>' operator.
|
||||
*/
|
||||
inline izstream& operator>(izstream& zs, char* x) {
|
||||
zstringlen len(zs);
|
||||
::gzread(zs.fp(), x, len.value());
|
||||
x[len.value()] = '\0';
|
||||
return zs;
|
||||
}
|
||||
|
||||
inline char* read_string(izstream& zs) {
|
||||
zstringlen len(zs);
|
||||
char* x = new char[len.value()+1];
|
||||
::gzread(zs.fp(), x, len.value());
|
||||
x[len.value()] = '\0';
|
||||
return x;
|
||||
}
|
||||
|
||||
// ----------------------------- ozstream -----------------------------
|
||||
|
||||
class ozstream
|
||||
{
|
||||
public:
|
||||
ozstream() : m_fp(0), m_os(0) {
|
||||
}
|
||||
ozstream(FILE* fp, int level = Z_DEFAULT_COMPRESSION)
|
||||
: m_fp(0), m_os(0) {
|
||||
open(fp, level);
|
||||
}
|
||||
ozstream(const char* name, int level = Z_DEFAULT_COMPRESSION)
|
||||
: m_fp(0), m_os(0) {
|
||||
open(name, level);
|
||||
}
|
||||
~ozstream() {
|
||||
close();
|
||||
}
|
||||
|
||||
/* Opens a gzip (.gz) file for writing.
|
||||
* The compression level parameter should be in 0..9
|
||||
* errno can be checked to distinguish two error cases
|
||||
* (if errno is zero, the zlib error is Z_MEM_ERROR).
|
||||
*/
|
||||
void open(const char* name, int level = Z_DEFAULT_COMPRESSION) {
|
||||
char mode[4] = "wb\0";
|
||||
if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
|
||||
if (m_fp) close();
|
||||
m_fp = ::gzopen(name, mode);
|
||||
}
|
||||
|
||||
/* open from a FILE pointer.
|
||||
*/
|
||||
void open(FILE* fp, int level = Z_DEFAULT_COMPRESSION) {
|
||||
SET_BINARY_MODE(fp);
|
||||
char mode[4] = "wb\0";
|
||||
if (level != Z_DEFAULT_COMPRESSION) mode[2] = '0'+level;
|
||||
if (m_fp) close();
|
||||
m_fp = ::gzdopen(fileno(fp), mode);
|
||||
}
|
||||
|
||||
/* Flushes all pending output if necessary, closes the compressed file
|
||||
* and deallocates all the (de)compression state. The return value is
|
||||
* the zlib error number (see function error() below).
|
||||
*/
|
||||
int close() {
|
||||
if (m_os) {
|
||||
::gzwrite(m_fp, m_os->str(), m_os->pcount());
|
||||
delete[] m_os->str(); delete m_os; m_os = 0;
|
||||
}
|
||||
int r = ::gzclose(m_fp); m_fp = 0; return r;
|
||||
}
|
||||
|
||||
/* Binary write the given number of bytes into the compressed file.
|
||||
*/
|
||||
int write(const void* buf, size_t len) {
|
||||
return ::gzwrite(m_fp, (voidp) buf, len);
|
||||
}
|
||||
|
||||
/* Flushes all pending output into the compressed file. The parameter
|
||||
* _flush is as in the deflate() function. The return value is the zlib
|
||||
* error number (see function gzerror below). flush() returns Z_OK if
|
||||
* the flush_ parameter is Z_FINISH and all output could be flushed.
|
||||
* flush() should be called only when strictly necessary because it can
|
||||
* degrade compression.
|
||||
*/
|
||||
int flush(int _flush) {
|
||||
os_flush();
|
||||
return ::gzflush(m_fp, _flush);
|
||||
}
|
||||
|
||||
/* Returns the error message for the last error which occurred on the
|
||||
* given compressed file. errnum is set to zlib error number. If an
|
||||
* error occurred in the file system and not in the compression library,
|
||||
* errnum is set to Z_ERRNO and the application may consult errno
|
||||
* to get the exact error code.
|
||||
*/
|
||||
const char* error(int* errnum) {
|
||||
return ::gzerror(m_fp, errnum);
|
||||
}
|
||||
|
||||
gzFile fp() { return m_fp; }
|
||||
|
||||
ostream& os() {
|
||||
if (m_os == 0) m_os = new ostrstream;
|
||||
return *m_os;
|
||||
}
|
||||
|
||||
void os_flush() {
|
||||
if (m_os && m_os->pcount()>0) {
|
||||
ostrstream* oss = new ostrstream;
|
||||
oss->fill(m_os->fill());
|
||||
oss->flags(m_os->flags());
|
||||
oss->precision(m_os->precision());
|
||||
oss->width(m_os->width());
|
||||
::gzwrite(m_fp, m_os->str(), m_os->pcount());
|
||||
delete[] m_os->str(); delete m_os; m_os = oss;
|
||||
}
|
||||
}
|
||||
|
||||
private:
|
||||
gzFile m_fp;
|
||||
ostrstream* m_os;
|
||||
};
|
||||
|
||||
/*
|
||||
* Binary write the given (array of) object(s) into the compressed file.
|
||||
* returns the number of uncompressed bytes actually written
|
||||
* (0 in case of error).
|
||||
*/
|
||||
template <class T, class Items>
|
||||
inline int write(ozstream& zs, const T* x, Items items) {
|
||||
return ::gzwrite(zs.fp(), (voidp) x, items*sizeof(T));
|
||||
}
|
||||
|
||||
/*
|
||||
* Binary output with the '<' operator.
|
||||
*/
|
||||
template <class T>
|
||||
inline ozstream& operator<(ozstream& zs, const T& x) {
|
||||
::gzwrite(zs.fp(), (voidp) &x, sizeof(T));
|
||||
return zs;
|
||||
}
|
||||
|
||||
inline zstringlen::zstringlen(ozstream& zs, const char* x) {
|
||||
val.byte = 255; val.word = ::strlen(x);
|
||||
if (val.word < 255) zs < (val.byte = val.word);
|
||||
else zs < val;
|
||||
}
|
||||
|
||||
/*
|
||||
* Write length of string + the string with the '<' operator.
|
||||
*/
|
||||
inline ozstream& operator<(ozstream& zs, const char* x) {
|
||||
zstringlen len(zs, x);
|
||||
::gzwrite(zs.fp(), (voidp) x, len.value());
|
||||
return zs;
|
||||
}
|
||||
|
||||
#ifdef _MSC_VER
|
||||
inline ozstream& operator<(ozstream& zs, char* const& x) {
|
||||
return zs < (const char*) x;
|
||||
}
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Ascii write with the << operator;
|
||||
*/
|
||||
template <class T>
|
||||
inline ostream& operator<<(ozstream& zs, const T& x) {
|
||||
zs.os_flush();
|
||||
return zs.os() << x;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,25 +0,0 @@
|
|||
#include "zstream.h"
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <iomanip.h>
|
||||
|
||||
void main() {
|
||||
char h[256] = "Hello";
|
||||
char* g = "Goodbye";
|
||||
ozstream out("temp.gz");
|
||||
out < "This works well" < h < g;
|
||||
out.close();
|
||||
|
||||
izstream in("temp.gz"); // read it back
|
||||
char *x = read_string(in), *y = new char[256], z[256];
|
||||
in > y > z;
|
||||
in.close();
|
||||
cout << x << endl << y << endl << z << endl;
|
||||
|
||||
out.open("temp.gz"); // try ascii output; zcat temp.gz to see the results
|
||||
out << setw(50) << setfill('#') << setprecision(20) << x << endl << y << endl << z << endl;
|
||||
out << z << endl << y << endl << x << endl;
|
||||
out << 1.1234567890123456789 << endl;
|
||||
|
||||
delete[] x; delete[] y;
|
||||
}
|
||||
|
|
@ -1,35 +0,0 @@
|
|||
These classes provide a C++ stream interface to the zlib library. It allows you
|
||||
to do things like:
|
||||
|
||||
gzofstream outf("blah.gz");
|
||||
outf << "These go into the gzip file " << 123 << endl;
|
||||
|
||||
It does this by deriving a specialized stream buffer for gzipped files, which is
|
||||
the way Stroustrup would have done it. :->
|
||||
|
||||
The gzifstream and gzofstream classes were originally written by Kevin Ruland
|
||||
and made available in the zlib contrib/iostream directory. The older version still
|
||||
compiles under gcc 2.xx, but not under gcc 3.xx, which sparked the development of
|
||||
this version.
|
||||
|
||||
The new classes are as standard-compliant as possible, closely following the
|
||||
approach of the standard library's fstream classes. It compiles under gcc versions
|
||||
3.2 and 3.3, but not under gcc 2.xx. This is mainly due to changes in the standard
|
||||
library naming scheme. The new version of gzifstream/gzofstream/gzfilebuf differs
|
||||
from the previous one in the following respects:
|
||||
- added showmanyc
|
||||
- added setbuf, with support for unbuffered output via setbuf(0,0)
|
||||
- a few bug fixes of stream behavior
|
||||
- gzipped output file opened with default compression level instead of maximum level
|
||||
- setcompressionlevel()/strategy() members replaced by single setcompression()
|
||||
|
||||
The code is provided "as is", with the permission to use, copy, modify, distribute
|
||||
and sell it for any purpose without fee.
|
||||
|
||||
Ludwig Schwardt
|
||||
<schwardt@sun.ac.za>
|
||||
|
||||
DSP Lab
|
||||
Electrical & Electronic Engineering Department
|
||||
University of Stellenbosch
|
||||
South Africa
|
||||
|
|
@ -1,17 +0,0 @@
|
|||
Possible upgrades to gzfilebuf:
|
||||
|
||||
- The ability to do putback (e.g. putbackfail)
|
||||
|
||||
- The ability to seek (zlib supports this, but could be slow/tricky)
|
||||
|
||||
- Simultaneous read/write access (does it make sense?)
|
||||
|
||||
- Support for ios_base::ate open mode
|
||||
|
||||
- Locale support?
|
||||
|
||||
- Check public interface to see which calls give problems
|
||||
(due to dependence on library internals)
|
||||
|
||||
- Override operator<<(ostream&, gzfilebuf*) to allow direct copying
|
||||
of stream buffer to stream ( i.e. os << is.rdbuf(); )
|
||||
|
|
@ -1,50 +0,0 @@
|
|||
/*
|
||||
* Test program for gzifstream and gzofstream
|
||||
*
|
||||
* by Ludwig Schwardt <schwardt@sun.ac.za>
|
||||
* original version by Kevin Ruland <kevin@rodin.wustl.edu>
|
||||
*/
|
||||
|
||||
#include "zfstream.h"
|
||||
#include <iostream> // for cout
|
||||
|
||||
int main() {
|
||||
|
||||
gzofstream outf;
|
||||
gzifstream inf;
|
||||
char buf[80];
|
||||
|
||||
outf.open("test1.txt.gz");
|
||||
outf << "The quick brown fox sidestepped the lazy canine\n"
|
||||
<< 1.3 << "\nPlan " << 9 << std::endl;
|
||||
outf.close();
|
||||
std::cout << "Wrote the following message to 'test1.txt.gz' (check with zcat or zless):\n"
|
||||
<< "The quick brown fox sidestepped the lazy canine\n"
|
||||
<< 1.3 << "\nPlan " << 9 << std::endl;
|
||||
|
||||
std::cout << "\nReading 'test1.txt.gz' (buffered) produces:\n";
|
||||
inf.open("test1.txt.gz");
|
||||
while (inf.getline(buf,80,'\n')) {
|
||||
std::cout << buf << "\t(" << inf.rdbuf()->in_avail() << " chars left in buffer)\n";
|
||||
}
|
||||
inf.close();
|
||||
|
||||
outf.rdbuf()->pubsetbuf(0,0);
|
||||
outf.open("test2.txt.gz");
|
||||
outf << setcompression(Z_NO_COMPRESSION)
|
||||
<< "The quick brown fox sidestepped the lazy canine\n"
|
||||
<< 1.3 << "\nPlan " << 9 << std::endl;
|
||||
outf.close();
|
||||
std::cout << "\nWrote the same message to 'test2.txt.gz' in uncompressed form";
|
||||
|
||||
std::cout << "\nReading 'test2.txt.gz' (unbuffered) produces:\n";
|
||||
inf.rdbuf()->pubsetbuf(0,0);
|
||||
inf.open("test2.txt.gz");
|
||||
while (inf.getline(buf,80,'\n')) {
|
||||
std::cout << buf << "\t(" << inf.rdbuf()->in_avail() << " chars left in buffer)\n";
|
||||
}
|
||||
inf.close();
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
|
@ -1,479 +0,0 @@
|
|||
/*
|
||||
* A C++ I/O streams interface to the zlib gz* functions
|
||||
*
|
||||
* by Ludwig Schwardt <schwardt@sun.ac.za>
|
||||
* original version by Kevin Ruland <kevin@rodin.wustl.edu>
|
||||
*
|
||||
* This version is standard-compliant and compatible with gcc 3.x.
|
||||
*/
|
||||
|
||||
#include "zfstream.h"
|
||||
#include <cstring> // for strcpy, strcat, strlen (mode strings)
|
||||
#include <cstdio> // for BUFSIZ
|
||||
|
||||
// Internal buffer sizes (default and "unbuffered" versions)
|
||||
#define BIGBUFSIZE BUFSIZ
|
||||
#define SMALLBUFSIZE 1
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
// Default constructor
|
||||
gzfilebuf::gzfilebuf()
|
||||
: file(NULL), io_mode(std::ios_base::openmode(0)), own_fd(false),
|
||||
buffer(NULL), buffer_size(BIGBUFSIZE), own_buffer(true)
|
||||
{
|
||||
// No buffers to start with
|
||||
this->disable_buffer();
|
||||
}
|
||||
|
||||
// Destructor
|
||||
gzfilebuf::~gzfilebuf()
|
||||
{
|
||||
// Sync output buffer and close only if responsible for file
|
||||
// (i.e. attached streams should be left open at this stage)
|
||||
this->sync();
|
||||
if (own_fd)
|
||||
this->close();
|
||||
// Make sure internal buffer is deallocated
|
||||
this->disable_buffer();
|
||||
}
|
||||
|
||||
// Set compression level and strategy
|
||||
int
|
||||
gzfilebuf::setcompression(int comp_level,
|
||||
int comp_strategy)
|
||||
{
|
||||
return gzsetparams(file, comp_level, comp_strategy);
|
||||
}
|
||||
|
||||
// Open gzipped file
|
||||
gzfilebuf*
|
||||
gzfilebuf::open(const char *name,
|
||||
std::ios_base::openmode mode)
|
||||
{
|
||||
// Fail if file already open
|
||||
if (this->is_open())
|
||||
return NULL;
|
||||
// Don't support simultaneous read/write access (yet)
|
||||
if ((mode & std::ios_base::in) && (mode & std::ios_base::out))
|
||||
return NULL;
|
||||
|
||||
// Build mode string for gzopen and check it [27.8.1.3.2]
|
||||
char char_mode[6] = "\0\0\0\0\0";
|
||||
if (!this->open_mode(mode, char_mode))
|
||||
return NULL;
|
||||
|
||||
// Attempt to open file
|
||||
if ((file = gzopen(name, char_mode)) == NULL)
|
||||
return NULL;
|
||||
|
||||
// On success, allocate internal buffer and set flags
|
||||
this->enable_buffer();
|
||||
io_mode = mode;
|
||||
own_fd = true;
|
||||
return this;
|
||||
}
|
||||
|
||||
// Attach to gzipped file
|
||||
gzfilebuf*
|
||||
gzfilebuf::attach(int fd,
|
||||
std::ios_base::openmode mode)
|
||||
{
|
||||
// Fail if file already open
|
||||
if (this->is_open())
|
||||
return NULL;
|
||||
// Don't support simultaneous read/write access (yet)
|
||||
if ((mode & std::ios_base::in) && (mode & std::ios_base::out))
|
||||
return NULL;
|
||||
|
||||
// Build mode string for gzdopen and check it [27.8.1.3.2]
|
||||
char char_mode[6] = "\0\0\0\0\0";
|
||||
if (!this->open_mode(mode, char_mode))
|
||||
return NULL;
|
||||
|
||||
// Attempt to attach to file
|
||||
if ((file = gzdopen(fd, char_mode)) == NULL)
|
||||
return NULL;
|
||||
|
||||
// On success, allocate internal buffer and set flags
|
||||
this->enable_buffer();
|
||||
io_mode = mode;
|
||||
own_fd = false;
|
||||
return this;
|
||||
}
|
||||
|
||||
// Close gzipped file
|
||||
gzfilebuf*
|
||||
gzfilebuf::close()
|
||||
{
|
||||
// Fail immediately if no file is open
|
||||
if (!this->is_open())
|
||||
return NULL;
|
||||
// Assume success
|
||||
gzfilebuf* retval = this;
|
||||
// Attempt to sync and close gzipped file
|
||||
if (this->sync() == -1)
|
||||
retval = NULL;
|
||||
if (gzclose(file) < 0)
|
||||
retval = NULL;
|
||||
// File is now gone anyway (postcondition [27.8.1.3.8])
|
||||
file = NULL;
|
||||
own_fd = false;
|
||||
// Destroy internal buffer if it exists
|
||||
this->disable_buffer();
|
||||
return retval;
|
||||
}
|
||||
|
||||
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
||||
|
||||
// Convert int open mode to mode string
|
||||
bool
|
||||
gzfilebuf::open_mode(std::ios_base::openmode mode,
|
||||
char* c_mode) const
|
||||
{
|
||||
bool testb = mode & std::ios_base::binary;
|
||||
bool testi = mode & std::ios_base::in;
|
||||
bool testo = mode & std::ios_base::out;
|
||||
bool testt = mode & std::ios_base::trunc;
|
||||
bool testa = mode & std::ios_base::app;
|
||||
|
||||
// Check for valid flag combinations - see [27.8.1.3.2] (Table 92)
|
||||
// Original zfstream hardcoded the compression level to maximum here...
|
||||
// Double the time for less than 1% size improvement seems
|
||||
// excessive though - keeping it at the default level
|
||||
// To change back, just append "9" to the next three mode strings
|
||||
if (!testi && testo && !testt && !testa)
|
||||
strcpy(c_mode, "w");
|
||||
if (!testi && testo && !testt && testa)
|
||||
strcpy(c_mode, "a");
|
||||
if (!testi && testo && testt && !testa)
|
||||
strcpy(c_mode, "w");
|
||||
if (testi && !testo && !testt && !testa)
|
||||
strcpy(c_mode, "r");
|
||||
// No read/write mode yet
|
||||
// if (testi && testo && !testt && !testa)
|
||||
// strcpy(c_mode, "r+");
|
||||
// if (testi && testo && testt && !testa)
|
||||
// strcpy(c_mode, "w+");
|
||||
|
||||
// Mode string should be empty for invalid combination of flags
|
||||
if (strlen(c_mode) == 0)
|
||||
return false;
|
||||
if (testb)
|
||||
strcat(c_mode, "b");
|
||||
return true;
|
||||
}
|
||||
|
||||
// Determine number of characters in internal get buffer
|
||||
std::streamsize
|
||||
gzfilebuf::showmanyc()
|
||||
{
|
||||
// Calls to underflow will fail if file not opened for reading
|
||||
if (!this->is_open() || !(io_mode & std::ios_base::in))
|
||||
return -1;
|
||||
// Make sure get area is in use
|
||||
if (this->gptr() && (this->gptr() < this->egptr()))
|
||||
return std::streamsize(this->egptr() - this->gptr());
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Fill get area from gzipped file
|
||||
gzfilebuf::int_type
|
||||
gzfilebuf::underflow()
|
||||
{
|
||||
// If something is left in the get area by chance, return it
|
||||
// (this shouldn't normally happen, as underflow is only supposed
|
||||
// to be called when gptr >= egptr, but it serves as error check)
|
||||
if (this->gptr() && (this->gptr() < this->egptr()))
|
||||
return traits_type::to_int_type(*(this->gptr()));
|
||||
|
||||
// If the file hasn't been opened for reading, produce error
|
||||
if (!this->is_open() || !(io_mode & std::ios_base::in))
|
||||
return traits_type::eof();
|
||||
|
||||
// Attempt to fill internal buffer from gzipped file
|
||||
// (buffer must be guaranteed to exist...)
|
||||
int bytes_read = gzread(file, buffer, buffer_size);
|
||||
// Indicates error or EOF
|
||||
if (bytes_read <= 0)
|
||||
{
|
||||
// Reset get area
|
||||
this->setg(buffer, buffer, buffer);
|
||||
return traits_type::eof();
|
||||
}
|
||||
// Make all bytes read from file available as get area
|
||||
this->setg(buffer, buffer, buffer + bytes_read);
|
||||
|
||||
// Return next character in get area
|
||||
return traits_type::to_int_type(*(this->gptr()));
|
||||
}
|
||||
|
||||
// Write put area to gzipped file
|
||||
gzfilebuf::int_type
|
||||
gzfilebuf::overflow(int_type c)
|
||||
{
|
||||
// Determine whether put area is in use
|
||||
if (this->pbase())
|
||||
{
|
||||
// Double-check pointer range
|
||||
if (this->pptr() > this->epptr() || this->pptr() < this->pbase())
|
||||
return traits_type::eof();
|
||||
// Add extra character to buffer if not EOF
|
||||
if (!traits_type::eq_int_type(c, traits_type::eof()))
|
||||
{
|
||||
*(this->pptr()) = traits_type::to_char_type(c);
|
||||
this->pbump(1);
|
||||
}
|
||||
// Number of characters to write to file
|
||||
int bytes_to_write = this->pptr() - this->pbase();
|
||||
// Overflow doesn't fail if nothing is to be written
|
||||
if (bytes_to_write > 0)
|
||||
{
|
||||
// If the file hasn't been opened for writing, produce error
|
||||
if (!this->is_open() || !(io_mode & std::ios_base::out))
|
||||
return traits_type::eof();
|
||||
// If gzipped file won't accept all bytes written to it, fail
|
||||
if (gzwrite(file, this->pbase(), bytes_to_write) != bytes_to_write)
|
||||
return traits_type::eof();
|
||||
// Reset next pointer to point to pbase on success
|
||||
this->pbump(-bytes_to_write);
|
||||
}
|
||||
}
|
||||
// Write extra character to file if not EOF
|
||||
else if (!traits_type::eq_int_type(c, traits_type::eof()))
|
||||
{
|
||||
// If the file hasn't been opened for writing, produce error
|
||||
if (!this->is_open() || !(io_mode & std::ios_base::out))
|
||||
return traits_type::eof();
|
||||
// Impromptu char buffer (allows "unbuffered" output)
|
||||
char_type last_char = traits_type::to_char_type(c);
|
||||
// If gzipped file won't accept this character, fail
|
||||
if (gzwrite(file, &last_char, 1) != 1)
|
||||
return traits_type::eof();
|
||||
}
|
||||
|
||||
// If you got here, you have succeeded (even if c was EOF)
|
||||
// The return value should therefore be non-EOF
|
||||
if (traits_type::eq_int_type(c, traits_type::eof()))
|
||||
return traits_type::not_eof(c);
|
||||
else
|
||||
return c;
|
||||
}
|
||||
|
||||
// Assign new buffer
|
||||
std::streambuf*
|
||||
gzfilebuf::setbuf(char_type* p,
|
||||
std::streamsize n)
|
||||
{
|
||||
// First make sure stuff is sync'ed, for safety
|
||||
if (this->sync() == -1)
|
||||
return NULL;
|
||||
// If buffering is turned off on purpose via setbuf(0,0), still allocate one...
|
||||
// "Unbuffered" only really refers to put [27.8.1.4.10], while get needs at
|
||||
// least a buffer of size 1 (very inefficient though, therefore make it bigger?)
|
||||
// This follows from [27.5.2.4.3]/12 (gptr needs to point at something, it seems)
|
||||
if (!p || !n)
|
||||
{
|
||||
// Replace existing buffer (if any) with small internal buffer
|
||||
this->disable_buffer();
|
||||
buffer = NULL;
|
||||
buffer_size = 0;
|
||||
own_buffer = true;
|
||||
this->enable_buffer();
|
||||
}
|
||||
else
|
||||
{
|
||||
// Replace existing buffer (if any) with external buffer
|
||||
this->disable_buffer();
|
||||
buffer = p;
|
||||
buffer_size = n;
|
||||
own_buffer = false;
|
||||
this->enable_buffer();
|
||||
}
|
||||
return this;
|
||||
}
|
||||
|
||||
// Write put area to gzipped file (i.e. ensures that put area is empty)
|
||||
int
|
||||
gzfilebuf::sync()
|
||||
{
|
||||
return traits_type::eq_int_type(this->overflow(), traits_type::eof()) ? -1 : 0;
|
||||
}
|
||||
|
||||
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
|
||||
|
||||
// Allocate internal buffer
|
||||
void
|
||||
gzfilebuf::enable_buffer()
|
||||
{
|
||||
// If internal buffer required, allocate one
|
||||
if (own_buffer && !buffer)
|
||||
{
|
||||
// Check for buffered vs. "unbuffered"
|
||||
if (buffer_size > 0)
|
||||
{
|
||||
// Allocate internal buffer
|
||||
buffer = new char_type[buffer_size];
|
||||
// Get area starts empty and will be expanded by underflow as need arises
|
||||
this->setg(buffer, buffer, buffer);
|
||||
// Setup entire internal buffer as put area.
|
||||
// The one-past-end pointer actually points to the last element of the buffer,
|
||||
// so that overflow(c) can safely add the extra character c to the sequence.
|
||||
// These pointers remain in place for the duration of the buffer
|
||||
this->setp(buffer, buffer + buffer_size - 1);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Even in "unbuffered" case, (small?) get buffer is still required
|
||||
buffer_size = SMALLBUFSIZE;
|
||||
buffer = new char_type[buffer_size];
|
||||
this->setg(buffer, buffer, buffer);
|
||||
// "Unbuffered" means no put buffer
|
||||
this->setp(0, 0);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
// If buffer already allocated, reset buffer pointers just to make sure no
|
||||
// stale chars are lying around
|
||||
this->setg(buffer, buffer, buffer);
|
||||
this->setp(buffer, buffer + buffer_size - 1);
|
||||
}
|
||||
}
|
||||
|
||||
// Destroy internal buffer
|
||||
void
|
||||
gzfilebuf::disable_buffer()
|
||||
{
|
||||
// If internal buffer exists, deallocate it
|
||||
if (own_buffer && buffer)
|
||||
{
|
||||
// Preserve unbuffered status by zeroing size
|
||||
if (!this->pbase())
|
||||
buffer_size = 0;
|
||||
delete[] buffer;
|
||||
buffer = NULL;
|
||||
this->setg(0, 0, 0);
|
||||
this->setp(0, 0);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Reset buffer pointers to initial state if external buffer exists
|
||||
this->setg(buffer, buffer, buffer);
|
||||
if (buffer)
|
||||
this->setp(buffer, buffer + buffer_size - 1);
|
||||
else
|
||||
this->setp(0, 0);
|
||||
}
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
// Default constructor initializes stream buffer
|
||||
gzifstream::gzifstream()
|
||||
: std::istream(NULL), sb()
|
||||
{ this->init(&sb); }
|
||||
|
||||
// Initialize stream buffer and open file
|
||||
gzifstream::gzifstream(const char* name,
|
||||
std::ios_base::openmode mode)
|
||||
: std::istream(NULL), sb()
|
||||
{
|
||||
this->init(&sb);
|
||||
this->open(name, mode);
|
||||
}
|
||||
|
||||
// Initialize stream buffer and attach to file
|
||||
gzifstream::gzifstream(int fd,
|
||||
std::ios_base::openmode mode)
|
||||
: std::istream(NULL), sb()
|
||||
{
|
||||
this->init(&sb);
|
||||
this->attach(fd, mode);
|
||||
}
|
||||
|
||||
// Open file and go into fail() state if unsuccessful
|
||||
void
|
||||
gzifstream::open(const char* name,
|
||||
std::ios_base::openmode mode)
|
||||
{
|
||||
if (!sb.open(name, mode | std::ios_base::in))
|
||||
this->setstate(std::ios_base::failbit);
|
||||
else
|
||||
this->clear();
|
||||
}
|
||||
|
||||
// Attach to file and go into fail() state if unsuccessful
|
||||
void
|
||||
gzifstream::attach(int fd,
|
||||
std::ios_base::openmode mode)
|
||||
{
|
||||
if (!sb.attach(fd, mode | std::ios_base::in))
|
||||
this->setstate(std::ios_base::failbit);
|
||||
else
|
||||
this->clear();
|
||||
}
|
||||
|
||||
// Close file
|
||||
void
|
||||
gzifstream::close()
|
||||
{
|
||||
if (!sb.close())
|
||||
this->setstate(std::ios_base::failbit);
|
||||
}
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
// Default constructor initializes stream buffer
|
||||
gzofstream::gzofstream()
|
||||
: std::ostream(NULL), sb()
|
||||
{ this->init(&sb); }
|
||||
|
||||
// Initialize stream buffer and open file
|
||||
gzofstream::gzofstream(const char* name,
|
||||
std::ios_base::openmode mode)
|
||||
: std::ostream(NULL), sb()
|
||||
{
|
||||
this->init(&sb);
|
||||
this->open(name, mode);
|
||||
}
|
||||
|
||||
// Initialize stream buffer and attach to file
|
||||
gzofstream::gzofstream(int fd,
|
||||
std::ios_base::openmode mode)
|
||||
: std::ostream(NULL), sb()
|
||||
{
|
||||
this->init(&sb);
|
||||
this->attach(fd, mode);
|
||||
}
|
||||
|
||||
// Open file and go into fail() state if unsuccessful
|
||||
void
|
||||
gzofstream::open(const char* name,
|
||||
std::ios_base::openmode mode)
|
||||
{
|
||||
if (!sb.open(name, mode | std::ios_base::out))
|
||||
this->setstate(std::ios_base::failbit);
|
||||
else
|
||||
this->clear();
|
||||
}
|
||||
|
||||
// Attach to file and go into fail() state if unsuccessful
|
||||
void
|
||||
gzofstream::attach(int fd,
|
||||
std::ios_base::openmode mode)
|
||||
{
|
||||
if (!sb.attach(fd, mode | std::ios_base::out))
|
||||
this->setstate(std::ios_base::failbit);
|
||||
else
|
||||
this->clear();
|
||||
}
|
||||
|
||||
// Close file
|
||||
void
|
||||
gzofstream::close()
|
||||
{
|
||||
if (!sb.close())
|
||||
this->setstate(std::ios_base::failbit);
|
||||
}
|
||||
|
|
@ -1,466 +0,0 @@
|
|||
/*
|
||||
* A C++ I/O streams interface to the zlib gz* functions
|
||||
*
|
||||
* by Ludwig Schwardt <schwardt@sun.ac.za>
|
||||
* original version by Kevin Ruland <kevin@rodin.wustl.edu>
|
||||
*
|
||||
* This version is standard-compliant and compatible with gcc 3.x.
|
||||
*/
|
||||
|
||||
#ifndef ZFSTREAM_H
|
||||
#define ZFSTREAM_H
|
||||
|
||||
#include <istream> // not iostream, since we don't need cin/cout
|
||||
#include <ostream>
|
||||
#include "zlib.h"
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
/**
|
||||
* @brief Gzipped file stream buffer class.
|
||||
*
|
||||
* This class implements basic_filebuf for gzipped files. It doesn't yet support
|
||||
* seeking (allowed by zlib but slow/limited), putback and read/write access
|
||||
* (tricky). Otherwise, it attempts to be a drop-in replacement for the standard
|
||||
* file streambuf.
|
||||
*/
|
||||
class gzfilebuf : public std::streambuf
|
||||
{
|
||||
public:
|
||||
// Default constructor.
|
||||
gzfilebuf();
|
||||
|
||||
// Destructor.
|
||||
virtual
|
||||
~gzfilebuf();
|
||||
|
||||
/**
|
||||
* @brief Set compression level and strategy on the fly.
|
||||
* @param comp_level Compression level (see zlib.h for allowed values)
|
||||
* @param comp_strategy Compression strategy (see zlib.h for allowed values)
|
||||
* @return Z_OK on success, Z_STREAM_ERROR otherwise.
|
||||
*
|
||||
* Unfortunately, these parameters cannot be modified separately, as the
|
||||
* previous zfstream version assumed. Since the strategy is seldom changed,
|
||||
* it can default and setcompression(level) then becomes like the old
|
||||
* setcompressionlevel(level).
|
||||
*/
|
||||
int
|
||||
setcompression(int comp_level,
|
||||
int comp_strategy = Z_DEFAULT_STRATEGY);
|
||||
|
||||
/**
|
||||
* @brief Check if file is open.
|
||||
* @return True if file is open.
|
||||
*/
|
||||
bool
|
||||
is_open() const { return (file != NULL); }
|
||||
|
||||
/**
|
||||
* @brief Open gzipped file.
|
||||
* @param name File name.
|
||||
* @param mode Open mode flags.
|
||||
* @return @c this on success, NULL on failure.
|
||||
*/
|
||||
gzfilebuf*
|
||||
open(const char* name,
|
||||
std::ios_base::openmode mode);
|
||||
|
||||
/**
|
||||
* @brief Attach to already open gzipped file.
|
||||
* @param fd File descriptor.
|
||||
* @param mode Open mode flags.
|
||||
* @return @c this on success, NULL on failure.
|
||||
*/
|
||||
gzfilebuf*
|
||||
attach(int fd,
|
||||
std::ios_base::openmode mode);
|
||||
|
||||
/**
|
||||
* @brief Close gzipped file.
|
||||
* @return @c this on success, NULL on failure.
|
||||
*/
|
||||
gzfilebuf*
|
||||
close();
|
||||
|
||||
protected:
|
||||
/**
|
||||
* @brief Convert ios open mode int to mode string used by zlib.
|
||||
* @return True if valid mode flag combination.
|
||||
*/
|
||||
bool
|
||||
open_mode(std::ios_base::openmode mode,
|
||||
char* c_mode) const;
|
||||
|
||||
/**
|
||||
* @brief Number of characters available in stream buffer.
|
||||
* @return Number of characters.
|
||||
*
|
||||
* This indicates number of characters in get area of stream buffer.
|
||||
* These characters can be read without accessing the gzipped file.
|
||||
*/
|
||||
virtual std::streamsize
|
||||
showmanyc();
|
||||
|
||||
/**
|
||||
* @brief Fill get area from gzipped file.
|
||||
* @return First character in get area on success, EOF on error.
|
||||
*
|
||||
* This actually reads characters from gzipped file to stream
|
||||
* buffer. Always buffered.
|
||||
*/
|
||||
virtual int_type
|
||||
underflow();
|
||||
|
||||
/**
|
||||
* @brief Write put area to gzipped file.
|
||||
* @param c Extra character to add to buffer contents.
|
||||
* @return Non-EOF on success, EOF on error.
|
||||
*
|
||||
* This actually writes characters in stream buffer to
|
||||
* gzipped file. With unbuffered output this is done one
|
||||
* character at a time.
|
||||
*/
|
||||
virtual int_type
|
||||
overflow(int_type c = traits_type::eof());
|
||||
|
||||
/**
|
||||
* @brief Installs external stream buffer.
|
||||
* @param p Pointer to char buffer.
|
||||
* @param n Size of external buffer.
|
||||
* @return @c this on success, NULL on failure.
|
||||
*
|
||||
* Call setbuf(0,0) to enable unbuffered output.
|
||||
*/
|
||||
virtual std::streambuf*
|
||||
setbuf(char_type* p,
|
||||
std::streamsize n);
|
||||
|
||||
/**
|
||||
* @brief Flush stream buffer to file.
|
||||
* @return 0 on success, -1 on error.
|
||||
*
|
||||
* This calls underflow(EOF) to do the job.
|
||||
*/
|
||||
virtual int
|
||||
sync();
|
||||
|
||||
//
|
||||
// Some future enhancements
|
||||
//
|
||||
// virtual int_type uflow();
|
||||
// virtual int_type pbackfail(int_type c = traits_type::eof());
|
||||
// virtual pos_type
|
||||
// seekoff(off_type off,
|
||||
// std::ios_base::seekdir way,
|
||||
// std::ios_base::openmode mode = std::ios_base::in|std::ios_base::out);
|
||||
// virtual pos_type
|
||||
// seekpos(pos_type sp,
|
||||
// std::ios_base::openmode mode = std::ios_base::in|std::ios_base::out);
|
||||
|
||||
private:
|
||||
/**
|
||||
* @brief Allocate internal buffer.
|
||||
*
|
||||
* This function is safe to call multiple times. It will ensure
|
||||
* that a proper internal buffer exists if it is required. If the
|
||||
* buffer already exists or is external, the buffer pointers will be
|
||||
* reset to their original state.
|
||||
*/
|
||||
void
|
||||
enable_buffer();
|
||||
|
||||
/**
|
||||
* @brief Destroy internal buffer.
|
||||
*
|
||||
* This function is safe to call multiple times. It will ensure
|
||||
* that the internal buffer is deallocated if it exists. In any
|
||||
* case, it will also reset the buffer pointers.
|
||||
*/
|
||||
void
|
||||
disable_buffer();
|
||||
|
||||
/**
|
||||
* Underlying file pointer.
|
||||
*/
|
||||
gzFile file;
|
||||
|
||||
/**
|
||||
* Mode in which file was opened.
|
||||
*/
|
||||
std::ios_base::openmode io_mode;
|
||||
|
||||
/**
|
||||
* @brief True if this object owns file descriptor.
|
||||
*
|
||||
* This makes the class responsible for closing the file
|
||||
* upon destruction.
|
||||
*/
|
||||
bool own_fd;
|
||||
|
||||
/**
|
||||
* @brief Stream buffer.
|
||||
*
|
||||
* For simplicity this remains allocated on the free store for the
|
||||
* entire life span of the gzfilebuf object, unless replaced by setbuf.
|
||||
*/
|
||||
char_type* buffer;
|
||||
|
||||
/**
|
||||
* @brief Stream buffer size.
|
||||
*
|
||||
* Defaults to system default buffer size (typically 8192 bytes).
|
||||
* Modified by setbuf.
|
||||
*/
|
||||
std::streamsize buffer_size;
|
||||
|
||||
/**
|
||||
* @brief True if this object owns stream buffer.
|
||||
*
|
||||
* This makes the class responsible for deleting the buffer
|
||||
* upon destruction.
|
||||
*/
|
||||
bool own_buffer;
|
||||
};
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
/**
|
||||
* @brief Gzipped file input stream class.
|
||||
*
|
||||
* This class implements ifstream for gzipped files. Seeking and putback
|
||||
* is not supported yet.
|
||||
*/
|
||||
class gzifstream : public std::istream
|
||||
{
|
||||
public:
|
||||
// Default constructor
|
||||
gzifstream();
|
||||
|
||||
/**
|
||||
* @brief Construct stream on gzipped file to be opened.
|
||||
* @param name File name.
|
||||
* @param mode Open mode flags (forced to contain ios::in).
|
||||
*/
|
||||
explicit
|
||||
gzifstream(const char* name,
|
||||
std::ios_base::openmode mode = std::ios_base::in);
|
||||
|
||||
/**
|
||||
* @brief Construct stream on already open gzipped file.
|
||||
* @param fd File descriptor.
|
||||
* @param mode Open mode flags (forced to contain ios::in).
|
||||
*/
|
||||
explicit
|
||||
gzifstream(int fd,
|
||||
std::ios_base::openmode mode = std::ios_base::in);
|
||||
|
||||
/**
|
||||
* Obtain underlying stream buffer.
|
||||
*/
|
||||
gzfilebuf*
|
||||
rdbuf() const
|
||||
{ return const_cast<gzfilebuf*>(&sb); }
|
||||
|
||||
/**
|
||||
* @brief Check if file is open.
|
||||
* @return True if file is open.
|
||||
*/
|
||||
bool
|
||||
is_open() { return sb.is_open(); }
|
||||
|
||||
/**
|
||||
* @brief Open gzipped file.
|
||||
* @param name File name.
|
||||
* @param mode Open mode flags (forced to contain ios::in).
|
||||
*
|
||||
* Stream will be in state good() if file opens successfully;
|
||||
* otherwise in state fail(). This differs from the behavior of
|
||||
* ifstream, which never sets the state to good() and therefore
|
||||
* won't allow you to reuse the stream for a second file unless
|
||||
* you manually clear() the state. The choice is a matter of
|
||||
* convenience.
|
||||
*/
|
||||
void
|
||||
open(const char* name,
|
||||
std::ios_base::openmode mode = std::ios_base::in);
|
||||
|
||||
/**
|
||||
* @brief Attach to already open gzipped file.
|
||||
* @param fd File descriptor.
|
||||
* @param mode Open mode flags (forced to contain ios::in).
|
||||
*
|
||||
* Stream will be in state good() if attach succeeded; otherwise
|
||||
* in state fail().
|
||||
*/
|
||||
void
|
||||
attach(int fd,
|
||||
std::ios_base::openmode mode = std::ios_base::in);
|
||||
|
||||
/**
|
||||
* @brief Close gzipped file.
|
||||
*
|
||||
* Stream will be in state fail() if close failed.
|
||||
*/
|
||||
void
|
||||
close();
|
||||
|
||||
private:
|
||||
/**
|
||||
* Underlying stream buffer.
|
||||
*/
|
||||
gzfilebuf sb;
|
||||
};
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
/**
|
||||
* @brief Gzipped file output stream class.
|
||||
*
|
||||
* This class implements ofstream for gzipped files. Seeking and putback
|
||||
* is not supported yet.
|
||||
*/
|
||||
class gzofstream : public std::ostream
|
||||
{
|
||||
public:
|
||||
// Default constructor
|
||||
gzofstream();
|
||||
|
||||
/**
|
||||
* @brief Construct stream on gzipped file to be opened.
|
||||
* @param name File name.
|
||||
* @param mode Open mode flags (forced to contain ios::out).
|
||||
*/
|
||||
explicit
|
||||
gzofstream(const char* name,
|
||||
std::ios_base::openmode mode = std::ios_base::out);
|
||||
|
||||
/**
|
||||
* @brief Construct stream on already open gzipped file.
|
||||
* @param fd File descriptor.
|
||||
* @param mode Open mode flags (forced to contain ios::out).
|
||||
*/
|
||||
explicit
|
||||
gzofstream(int fd,
|
||||
std::ios_base::openmode mode = std::ios_base::out);
|
||||
|
||||
/**
|
||||
* Obtain underlying stream buffer.
|
||||
*/
|
||||
gzfilebuf*
|
||||
rdbuf() const
|
||||
{ return const_cast<gzfilebuf*>(&sb); }
|
||||
|
||||
/**
|
||||
* @brief Check if file is open.
|
||||
* @return True if file is open.
|
||||
*/
|
||||
bool
|
||||
is_open() { return sb.is_open(); }
|
||||
|
||||
/**
|
||||
* @brief Open gzipped file.
|
||||
* @param name File name.
|
||||
* @param mode Open mode flags (forced to contain ios::out).
|
||||
*
|
||||
* Stream will be in state good() if file opens successfully;
|
||||
* otherwise in state fail(). This differs from the behavior of
|
||||
* ofstream, which never sets the state to good() and therefore
|
||||
* won't allow you to reuse the stream for a second file unless
|
||||
* you manually clear() the state. The choice is a matter of
|
||||
* convenience.
|
||||
*/
|
||||
void
|
||||
open(const char* name,
|
||||
std::ios_base::openmode mode = std::ios_base::out);
|
||||
|
||||
/**
|
||||
* @brief Attach to already open gzipped file.
|
||||
* @param fd File descriptor.
|
||||
* @param mode Open mode flags (forced to contain ios::out).
|
||||
*
|
||||
* Stream will be in state good() if attach succeeded; otherwise
|
||||
* in state fail().
|
||||
*/
|
||||
void
|
||||
attach(int fd,
|
||||
std::ios_base::openmode mode = std::ios_base::out);
|
||||
|
||||
/**
|
||||
* @brief Close gzipped file.
|
||||
*
|
||||
* Stream will be in state fail() if close failed.
|
||||
*/
|
||||
void
|
||||
close();
|
||||
|
||||
private:
|
||||
/**
|
||||
* Underlying stream buffer.
|
||||
*/
|
||||
gzfilebuf sb;
|
||||
};
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
/**
|
||||
* @brief Gzipped file output stream manipulator class.
|
||||
*
|
||||
* This class defines a two-argument manipulator for gzofstream. It is used
|
||||
* as base for the setcompression(int,int) manipulator.
|
||||
*/
|
||||
template<typename T1, typename T2>
|
||||
class gzomanip2
|
||||
{
|
||||
public:
|
||||
// Allows insertor to peek at internals
|
||||
template <typename Ta, typename Tb>
|
||||
friend gzofstream&
|
||||
operator<<(gzofstream&,
|
||||
const gzomanip2<Ta,Tb>&);
|
||||
|
||||
// Constructor
|
||||
gzomanip2(gzofstream& (*f)(gzofstream&, T1, T2),
|
||||
T1 v1,
|
||||
T2 v2);
|
||||
private:
|
||||
// Underlying manipulator function
|
||||
gzofstream&
|
||||
(*func)(gzofstream&, T1, T2);
|
||||
|
||||
// Arguments for manipulator function
|
||||
T1 val1;
|
||||
T2 val2;
|
||||
};
|
||||
|
||||
/*****************************************************************************/
|
||||
|
||||
// Manipulator function thunks through to stream buffer
|
||||
inline gzofstream&
|
||||
setcompression(gzofstream &gzs, int l, int s = Z_DEFAULT_STRATEGY)
|
||||
{
|
||||
(gzs.rdbuf())->setcompression(l, s);
|
||||
return gzs;
|
||||
}
|
||||
|
||||
// Manipulator constructor stores arguments
|
||||
template<typename T1, typename T2>
|
||||
inline
|
||||
gzomanip2<T1,T2>::gzomanip2(gzofstream &(*f)(gzofstream &, T1, T2),
|
||||
T1 v1,
|
||||
T2 v2)
|
||||
: func(f), val1(v1), val2(v2)
|
||||
{ }
|
||||
|
||||
// Insertor applies underlying manipulator function to stream
|
||||
template<typename T1, typename T2>
|
||||
inline gzofstream&
|
||||
operator<<(gzofstream& s, const gzomanip2<T1,T2>& m)
|
||||
{ return (*m.func)(s, m.val1, m.val2); }
|
||||
|
||||
// Insert this onto stream to simplify setting of compression level
|
||||
inline gzomanip2<int,int>
|
||||
setcompression(int l, int s = Z_DEFAULT_STRATEGY)
|
||||
{ return gzomanip2<int,int>(&setcompression, l, s); }
|
||||
|
||||
#endif // ZFSTREAM_H
|
||||
|
|
@ -1,408 +0,0 @@
|
|||
|
||||
; match.asm -- Pentium-Pro optimized version of longest_match()
|
||||
;
|
||||
; Updated for zlib 1.1.3 and converted to MASM 6.1x
|
||||
; Copyright (C) 2000 Dan Higdon <hdan@kinesoft.com>
|
||||
; and Chuck Walbourn <chuckw@kinesoft.com>
|
||||
; Corrections by Cosmin Truta <cosmint@cs.ubbcluj.ro>
|
||||
;
|
||||
; This is free software; you can redistribute it and/or modify it
|
||||
; under the terms of the GNU General Public License.
|
||||
|
||||
; Based on match.S
|
||||
; Written for zlib 1.1.2
|
||||
; Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com>
|
||||
|
||||
.686P
|
||||
.MODEL FLAT
|
||||
|
||||
;===========================================================================
|
||||
; EQUATES
|
||||
;===========================================================================
|
||||
|
||||
MAX_MATCH EQU 258
|
||||
MIN_MATCH EQU 3
|
||||
MIN_LOOKAHEAD EQU (MAX_MATCH + MIN_MATCH + 1)
|
||||
MAX_MATCH_8 EQU ((MAX_MATCH + 7) AND (NOT 7))
|
||||
|
||||
;===========================================================================
|
||||
; STRUCTURES
|
||||
;===========================================================================
|
||||
|
||||
; This STRUCT assumes a 4-byte alignment
|
||||
|
||||
DEFLATE_STATE STRUCT
|
||||
ds_strm dd ?
|
||||
ds_status dd ?
|
||||
ds_pending_buf dd ?
|
||||
ds_pending_buf_size dd ?
|
||||
ds_pending_out dd ?
|
||||
ds_pending dd ?
|
||||
ds_wrap dd ?
|
||||
ds_data_type db ?
|
||||
ds_method db ?
|
||||
db ? ; padding
|
||||
db ? ; padding
|
||||
ds_last_flush dd ?
|
||||
ds_w_size dd ? ; used
|
||||
ds_w_bits dd ?
|
||||
ds_w_mask dd ? ; used
|
||||
ds_window dd ? ; used
|
||||
ds_window_size dd ?
|
||||
ds_prev dd ? ; used
|
||||
ds_head dd ?
|
||||
ds_ins_h dd ?
|
||||
ds_hash_size dd ?
|
||||
ds_hash_bits dd ?
|
||||
ds_hash_mask dd ?
|
||||
ds_hash_shift dd ?
|
||||
ds_block_start dd ?
|
||||
ds_match_length dd ? ; used
|
||||
ds_prev_match dd ? ; used
|
||||
ds_match_available dd ?
|
||||
ds_strstart dd ? ; used
|
||||
ds_match_start dd ? ; used
|
||||
ds_lookahead dd ? ; used
|
||||
ds_prev_length dd ? ; used
|
||||
ds_max_chain_length dd ? ; used
|
||||
ds_max_laxy_match dd ?
|
||||
ds_level dd ?
|
||||
ds_strategy dd ?
|
||||
ds_good_match dd ? ; used
|
||||
ds_nice_match dd ? ; used
|
||||
|
||||
; Don't need anymore of the struct for match
|
||||
DEFLATE_STATE ENDS
|
||||
|
||||
;===========================================================================
|
||||
; CODE
|
||||
;===========================================================================
|
||||
_TEXT SEGMENT
|
||||
|
||||
;---------------------------------------------------------------------------
|
||||
; match_init
|
||||
;---------------------------------------------------------------------------
|
||||
ALIGN 4
|
||||
PUBLIC _match_init
|
||||
_match_init PROC
|
||||
; no initialization needed
|
||||
ret
|
||||
_match_init ENDP
|
||||
|
||||
;---------------------------------------------------------------------------
|
||||
; uInt longest_match(deflate_state *deflatestate, IPos curmatch)
|
||||
;---------------------------------------------------------------------------
|
||||
ALIGN 4
|
||||
|
||||
PUBLIC _longest_match
|
||||
_longest_match PROC
|
||||
|
||||
; Since this code uses EBP for a scratch register, the stack frame must
|
||||
; be manually constructed and referenced relative to the ESP register.
|
||||
|
||||
; Stack image
|
||||
; Variables
|
||||
chainlenwmask = 0 ; high word: current chain len
|
||||
; low word: s->wmask
|
||||
window = 4 ; local copy of s->window
|
||||
windowbestlen = 8 ; s->window + bestlen
|
||||
scanend = 12 ; last two bytes of string
|
||||
scanstart = 16 ; first two bytes of string
|
||||
scanalign = 20 ; dword-misalignment of string
|
||||
nicematch = 24 ; a good enough match size
|
||||
bestlen = 28 ; size of best match so far
|
||||
scan = 32 ; ptr to string wanting match
|
||||
varsize = 36 ; number of bytes (also offset to last saved register)
|
||||
|
||||
; Saved Registers (actually pushed into place)
|
||||
ebx_save = 36
|
||||
edi_save = 40
|
||||
esi_save = 44
|
||||
ebp_save = 48
|
||||
|
||||
; Parameters
|
||||
retaddr = 52
|
||||
deflatestate = 56
|
||||
curmatch = 60
|
||||
|
||||
; Save registers that the compiler may be using
|
||||
push ebp
|
||||
push edi
|
||||
push esi
|
||||
push ebx
|
||||
|
||||
; Allocate local variable space
|
||||
sub esp,varsize
|
||||
|
||||
; Retrieve the function arguments. ecx will hold cur_match
|
||||
; throughout the entire function. edx will hold the pointer to the
|
||||
; deflate_state structure during the function's setup (before
|
||||
; entering the main loop).
|
||||
|
||||
mov edx, [esp+deflatestate]
|
||||
ASSUME edx:PTR DEFLATE_STATE
|
||||
|
||||
mov ecx, [esp+curmatch]
|
||||
|
||||
; uInt wmask = s->w_mask;
|
||||
; unsigned chain_length = s->max_chain_length;
|
||||
; if (s->prev_length >= s->good_match) {
|
||||
; chain_length >>= 2;
|
||||
; }
|
||||
|
||||
mov eax, [edx].ds_prev_length
|
||||
mov ebx, [edx].ds_good_match
|
||||
cmp eax, ebx
|
||||
mov eax, [edx].ds_w_mask
|
||||
mov ebx, [edx].ds_max_chain_length
|
||||
jl SHORT LastMatchGood
|
||||
shr ebx, 2
|
||||
LastMatchGood:
|
||||
|
||||
; chainlen is decremented once beforehand so that the function can
|
||||
; use the sign flag instead of the zero flag for the exit test.
|
||||
; It is then shifted into the high word, to make room for the wmask
|
||||
; value, which it will always accompany.
|
||||
|
||||
dec ebx
|
||||
shl ebx, 16
|
||||
or ebx, eax
|
||||
mov [esp+chainlenwmask], ebx
|
||||
|
||||
; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
|
||||
|
||||
mov eax, [edx].ds_nice_match
|
||||
mov ebx, [edx].ds_lookahead
|
||||
cmp ebx, eax
|
||||
jl SHORT LookaheadLess
|
||||
mov ebx, eax
|
||||
LookaheadLess:
|
||||
mov [esp+nicematch], ebx
|
||||
|
||||
;/* register Bytef *scan = s->window + s->strstart; */
|
||||
|
||||
mov esi, [edx].ds_window
|
||||
mov [esp+window], esi
|
||||
mov ebp, [edx].ds_strstart
|
||||
lea edi, [esi+ebp]
|
||||
mov [esp+scan],edi
|
||||
|
||||
;/* Determine how many bytes the scan ptr is off from being */
|
||||
;/* dword-aligned. */
|
||||
|
||||
mov eax, edi
|
||||
neg eax
|
||||
and eax, 3
|
||||
mov [esp+scanalign], eax
|
||||
|
||||
;/* IPos limit = s->strstart > (IPos)MAX_DIST(s) ? */
|
||||
;/* s->strstart - (IPos)MAX_DIST(s) : NIL; */
|
||||
|
||||
mov eax, [edx].ds_w_size
|
||||
sub eax, MIN_LOOKAHEAD
|
||||
sub ebp, eax
|
||||
jg SHORT LimitPositive
|
||||
xor ebp, ebp
|
||||
LimitPositive:
|
||||
|
||||
;/* int best_len = s->prev_length; */
|
||||
|
||||
mov eax, [edx].ds_prev_length
|
||||
mov [esp+bestlen], eax
|
||||
|
||||
;/* Store the sum of s->window + best_len in %esi locally, and in %esi. */
|
||||
|
||||
add esi, eax
|
||||
mov [esp+windowbestlen], esi
|
||||
|
||||
;/* register ush scan_start = *(ushf*)scan; */
|
||||
;/* register ush scan_end = *(ushf*)(scan+best_len-1); */
|
||||
;/* Posf *prev = s->prev; */
|
||||
|
||||
movzx ebx, WORD PTR[edi]
|
||||
mov [esp+scanstart], ebx
|
||||
movzx ebx, WORD PTR[eax+edi-1]
|
||||
mov [esp+scanend], ebx
|
||||
mov edi, [edx].ds_prev
|
||||
|
||||
;/* Jump into the main loop. */
|
||||
|
||||
mov edx, [esp+chainlenwmask]
|
||||
jmp SHORT LoopEntry
|
||||
|
||||
;/* do {
|
||||
; * match = s->window + cur_match;
|
||||
; * if (*(ushf*)(match+best_len-1) != scan_end ||
|
||||
; * *(ushf*)match != scan_start) continue;
|
||||
; * [...]
|
||||
; * } while ((cur_match = prev[cur_match & wmask]) > limit
|
||||
; * && --chain_length != 0);
|
||||
; *
|
||||
; * Here is the inner loop of the function. The function will spend the
|
||||
; * majority of its time in this loop, and majority of that time will
|
||||
; * be spent in the first ten instructions.
|
||||
; *
|
||||
; * Within this loop:
|
||||
; * %ebx = scanend
|
||||
; * %ecx = curmatch
|
||||
; * %edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)
|
||||
; * %esi = windowbestlen - i.e., (window + bestlen)
|
||||
; * %edi = prev
|
||||
; * %ebp = limit
|
||||
; */
|
||||
|
||||
ALIGN 4
|
||||
LookupLoop:
|
||||
and ecx, edx
|
||||
movzx ecx, WORD PTR[edi+ecx*2]
|
||||
cmp ecx, ebp
|
||||
jbe LeaveNow
|
||||
sub edx, 000010000H
|
||||
js LeaveNow
|
||||
|
||||
LoopEntry:
|
||||
movzx eax, WORD PTR[esi+ecx-1]
|
||||
cmp eax, ebx
|
||||
jnz SHORT LookupLoop
|
||||
|
||||
mov eax, [esp+window]
|
||||
movzx eax, WORD PTR[eax+ecx]
|
||||
cmp eax, [esp+scanstart]
|
||||
jnz SHORT LookupLoop
|
||||
|
||||
;/* Store the current value of chainlen. */
|
||||
|
||||
mov [esp+chainlenwmask], edx
|
||||
|
||||
;/* Point %edi to the string under scrutiny, and %esi to the string we */
|
||||
;/* are hoping to match it up with. In actuality, %esi and %edi are */
|
||||
;/* both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and %edx is */
|
||||
;/* initialized to -(MAX_MATCH_8 - scanalign). */
|
||||
|
||||
mov esi, [esp+window]
|
||||
mov edi, [esp+scan]
|
||||
add esi, ecx
|
||||
mov eax, [esp+scanalign]
|
||||
mov edx, -MAX_MATCH_8
|
||||
lea edi, [edi+eax+MAX_MATCH_8]
|
||||
lea esi, [esi+eax+MAX_MATCH_8]
|
||||
|
||||
;/* Test the strings for equality, 8 bytes at a time. At the end,
|
||||
; * adjust %edx so that it is offset to the exact byte that mismatched.
|
||||
; *
|
||||
; * We already know at this point that the first three bytes of the
|
||||
; * strings match each other, and they can be safely passed over before
|
||||
; * starting the compare loop. So what this code does is skip over 0-3
|
||||
; * bytes, as much as necessary in order to dword-align the %edi
|
||||
; * pointer. (%esi will still be misaligned three times out of four.)
|
||||
; *
|
||||
; * It should be confessed that this loop usually does not represent
|
||||
; * much of the total running time. Replacing it with a more
|
||||
; * straightforward "rep cmpsb" would not drastically degrade
|
||||
; * performance.
|
||||
; */
|
||||
|
||||
LoopCmps:
|
||||
mov eax, DWORD PTR[esi+edx]
|
||||
xor eax, DWORD PTR[edi+edx]
|
||||
jnz SHORT LeaveLoopCmps
|
||||
|
||||
mov eax, DWORD PTR[esi+edx+4]
|
||||
xor eax, DWORD PTR[edi+edx+4]
|
||||
jnz SHORT LeaveLoopCmps4
|
||||
|
||||
add edx, 8
|
||||
jnz SHORT LoopCmps
|
||||
jmp LenMaximum
|
||||
ALIGN 4
|
||||
|
||||
LeaveLoopCmps4:
|
||||
add edx, 4
|
||||
|
||||
LeaveLoopCmps:
|
||||
test eax, 00000FFFFH
|
||||
jnz SHORT LenLower
|
||||
|
||||
add edx, 2
|
||||
shr eax, 16
|
||||
|
||||
LenLower:
|
||||
sub al, 1
|
||||
adc edx, 0
|
||||
|
||||
;/* Calculate the length of the match. If it is longer than MAX_MATCH, */
|
||||
;/* then automatically accept it as the best possible match and leave. */
|
||||
|
||||
lea eax, [edi+edx]
|
||||
mov edi, [esp+scan]
|
||||
sub eax, edi
|
||||
cmp eax, MAX_MATCH
|
||||
jge SHORT LenMaximum
|
||||
|
||||
;/* If the length of the match is not longer than the best match we */
|
||||
;/* have so far, then forget it and return to the lookup loop. */
|
||||
|
||||
mov edx, [esp+deflatestate]
|
||||
mov ebx, [esp+bestlen]
|
||||
cmp eax, ebx
|
||||
jg SHORT LongerMatch
|
||||
mov esi, [esp+windowbestlen]
|
||||
mov edi, [edx].ds_prev
|
||||
mov ebx, [esp+scanend]
|
||||
mov edx, [esp+chainlenwmask]
|
||||
jmp LookupLoop
|
||||
ALIGN 4
|
||||
|
||||
;/* s->match_start = cur_match; */
|
||||
;/* best_len = len; */
|
||||
;/* if (len >= nice_match) break; */
|
||||
;/* scan_end = *(ushf*)(scan+best_len-1); */
|
||||
|
||||
LongerMatch:
|
||||
mov ebx, [esp+nicematch]
|
||||
mov [esp+bestlen], eax
|
||||
mov [edx].ds_match_start, ecx
|
||||
cmp eax, ebx
|
||||
jge SHORT LeaveNow
|
||||
mov esi, [esp+window]
|
||||
add esi, eax
|
||||
mov [esp+windowbestlen], esi
|
||||
movzx ebx, WORD PTR[edi+eax-1]
|
||||
mov edi, [edx].ds_prev
|
||||
mov [esp+scanend], ebx
|
||||
mov edx, [esp+chainlenwmask]
|
||||
jmp LookupLoop
|
||||
ALIGN 4
|
||||
|
||||
;/* Accept the current string, with the maximum possible length. */
|
||||
|
||||
LenMaximum:
|
||||
mov edx, [esp+deflatestate]
|
||||
mov DWORD PTR[esp+bestlen], MAX_MATCH
|
||||
mov [edx].ds_match_start, ecx
|
||||
|
||||
;/* if ((uInt)best_len <= s->lookahead) return (uInt)best_len; */
|
||||
;/* return s->lookahead; */
|
||||
|
||||
LeaveNow:
|
||||
mov edx, [esp+deflatestate]
|
||||
mov ebx, [esp+bestlen]
|
||||
mov eax, [edx].ds_lookahead
|
||||
cmp ebx, eax
|
||||
jg SHORT LookaheadRet
|
||||
mov eax, ebx
|
||||
LookaheadRet:
|
||||
|
||||
; Restore the stack and return from whence we came.
|
||||
|
||||
add esp, varsize
|
||||
pop ebx
|
||||
pop esi
|
||||
pop edi
|
||||
pop ebp
|
||||
ret
|
||||
|
||||
_longest_match ENDP
|
||||
|
||||
_TEXT ENDS
|
||||
END
|
||||
|
|
@ -1,905 +0,0 @@
|
|||
;
|
||||
; gvmat32.asm -- Asm portion of the optimized longest_match for 32 bits x86
|
||||
; Copyright (C) 1995-1996 Jean-loup Gailly and Gilles Vollant.
|
||||
; File written by Gilles Vollant, by modifiying the longest_match
|
||||
; from Jean-loup Gailly in deflate.c
|
||||
; It need wmask == 0x7fff
|
||||
; (assembly code is faster with a fixed wmask)
|
||||
;
|
||||
; For Visual C++ 4.2 and ML 6.11c (version in directory \MASM611C of Win95 DDK)
|
||||
; I compile with : "ml /coff /Zi /c gvmat32.asm"
|
||||
;
|
||||
|
||||
;uInt longest_match_7fff(s, cur_match)
|
||||
; deflate_state *s;
|
||||
; IPos cur_match; /* current match */
|
||||
|
||||
NbStack equ 76
|
||||
cur_match equ dword ptr[esp+NbStack-0]
|
||||
str_s equ dword ptr[esp+NbStack-4]
|
||||
; 5 dword on top (ret,ebp,esi,edi,ebx)
|
||||
adrret equ dword ptr[esp+NbStack-8]
|
||||
pushebp equ dword ptr[esp+NbStack-12]
|
||||
pushedi equ dword ptr[esp+NbStack-16]
|
||||
pushesi equ dword ptr[esp+NbStack-20]
|
||||
pushebx equ dword ptr[esp+NbStack-24]
|
||||
|
||||
chain_length equ dword ptr [esp+NbStack-28]
|
||||
limit equ dword ptr [esp+NbStack-32]
|
||||
best_len equ dword ptr [esp+NbStack-36]
|
||||
window equ dword ptr [esp+NbStack-40]
|
||||
prev equ dword ptr [esp+NbStack-44]
|
||||
scan_start equ word ptr [esp+NbStack-48]
|
||||
wmask equ dword ptr [esp+NbStack-52]
|
||||
match_start_ptr equ dword ptr [esp+NbStack-56]
|
||||
nice_match equ dword ptr [esp+NbStack-60]
|
||||
scan equ dword ptr [esp+NbStack-64]
|
||||
|
||||
windowlen equ dword ptr [esp+NbStack-68]
|
||||
match_start equ dword ptr [esp+NbStack-72]
|
||||
strend equ dword ptr [esp+NbStack-76]
|
||||
NbStackAdd equ (NbStack-24)
|
||||
|
||||
.386p
|
||||
|
||||
name gvmatch
|
||||
.MODEL FLAT
|
||||
|
||||
|
||||
|
||||
; all the +4 offsets are due to the addition of pending_buf_size (in zlib
|
||||
; in the deflate_state structure since the asm code was first written
|
||||
; (if you compile with zlib 1.0.4 or older, remove the +4).
|
||||
; Note : these value are good with a 8 bytes boundary pack structure
|
||||
dep_chain_length equ 70h+4
|
||||
dep_window equ 2ch+4
|
||||
dep_strstart equ 60h+4
|
||||
dep_prev_length equ 6ch+4
|
||||
dep_nice_match equ 84h+4
|
||||
dep_w_size equ 20h+4
|
||||
dep_prev equ 34h+4
|
||||
dep_w_mask equ 28h+4
|
||||
dep_good_match equ 80h+4
|
||||
dep_match_start equ 64h+4
|
||||
dep_lookahead equ 68h+4
|
||||
|
||||
|
||||
_TEXT segment
|
||||
|
||||
IFDEF NOUNDERLINE
|
||||
public longest_match_7fff
|
||||
public longest_match_686
|
||||
; public match_init
|
||||
ELSE
|
||||
public _longest_match_7fff
|
||||
public _longest_match_686
|
||||
; public _match_init
|
||||
ENDIF
|
||||
|
||||
MAX_MATCH equ 258
|
||||
MIN_MATCH equ 3
|
||||
MIN_LOOKAHEAD equ (MAX_MATCH+MIN_MATCH+1)
|
||||
|
||||
|
||||
|
||||
IFDEF NOUNDERLINE
|
||||
;match_init proc near
|
||||
; ret
|
||||
;match_init endp
|
||||
ELSE
|
||||
;_match_init proc near
|
||||
; ret
|
||||
;_match_init endp
|
||||
ENDIF
|
||||
|
||||
|
||||
IFDEF NOUNDERLINE
|
||||
longest_match_7fff proc near
|
||||
ELSE
|
||||
_longest_match_7fff proc near
|
||||
ENDIF
|
||||
|
||||
mov edx,[esp+4]
|
||||
|
||||
|
||||
|
||||
push ebp
|
||||
push edi
|
||||
push esi
|
||||
push ebx
|
||||
|
||||
sub esp,NbStackAdd
|
||||
|
||||
; initialize or check the variables used in match.asm.
|
||||
mov ebp,edx
|
||||
|
||||
; chain_length = s->max_chain_length
|
||||
; if (prev_length>=good_match) chain_length >>= 2
|
||||
mov edx,[ebp+dep_chain_length]
|
||||
mov ebx,[ebp+dep_prev_length]
|
||||
cmp [ebp+dep_good_match],ebx
|
||||
ja noshr
|
||||
shr edx,2
|
||||
noshr:
|
||||
; we increment chain_length because in the asm, the --chain_lenght is in the beginning of the loop
|
||||
inc edx
|
||||
mov edi,[ebp+dep_nice_match]
|
||||
mov chain_length,edx
|
||||
mov eax,[ebp+dep_lookahead]
|
||||
cmp eax,edi
|
||||
; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
|
||||
jae nolookaheadnicematch
|
||||
mov edi,eax
|
||||
nolookaheadnicematch:
|
||||
; best_len = s->prev_length
|
||||
mov best_len,ebx
|
||||
|
||||
; window = s->window
|
||||
mov esi,[ebp+dep_window]
|
||||
mov ecx,[ebp+dep_strstart]
|
||||
mov window,esi
|
||||
|
||||
mov nice_match,edi
|
||||
; scan = window + strstart
|
||||
add esi,ecx
|
||||
mov scan,esi
|
||||
; dx = *window
|
||||
mov dx,word ptr [esi]
|
||||
; bx = *(window+best_len-1)
|
||||
mov bx,word ptr [esi+ebx-1]
|
||||
add esi,MAX_MATCH-1
|
||||
; scan_start = *scan
|
||||
mov scan_start,dx
|
||||
; strend = scan + MAX_MATCH-1
|
||||
mov strend,esi
|
||||
; bx = scan_end = *(window+best_len-1)
|
||||
|
||||
; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
|
||||
; s->strstart - (IPos)MAX_DIST(s) : NIL;
|
||||
|
||||
mov esi,[ebp+dep_w_size]
|
||||
sub esi,MIN_LOOKAHEAD
|
||||
; here esi = MAX_DIST(s)
|
||||
sub ecx,esi
|
||||
ja nodist
|
||||
xor ecx,ecx
|
||||
nodist:
|
||||
mov limit,ecx
|
||||
|
||||
; prev = s->prev
|
||||
mov edx,[ebp+dep_prev]
|
||||
mov prev,edx
|
||||
|
||||
;
|
||||
mov edx,dword ptr [ebp+dep_match_start]
|
||||
mov bp,scan_start
|
||||
mov eax,cur_match
|
||||
mov match_start,edx
|
||||
|
||||
mov edx,window
|
||||
mov edi,edx
|
||||
add edi,best_len
|
||||
mov esi,prev
|
||||
dec edi
|
||||
; windowlen = window + best_len -1
|
||||
mov windowlen,edi
|
||||
|
||||
jmp beginloop2
|
||||
align 4
|
||||
|
||||
; here, in the loop
|
||||
; eax = ax = cur_match
|
||||
; ecx = limit
|
||||
; bx = scan_end
|
||||
; bp = scan_start
|
||||
; edi = windowlen (window + best_len -1)
|
||||
; esi = prev
|
||||
|
||||
|
||||
;// here; chain_length <=16
|
||||
normalbeg0add16:
|
||||
add chain_length,16
|
||||
jz exitloop
|
||||
normalbeg0:
|
||||
cmp word ptr[edi+eax],bx
|
||||
je normalbeg2noroll
|
||||
rcontlabnoroll:
|
||||
; cur_match = prev[cur_match & wmask]
|
||||
and eax,7fffh
|
||||
mov ax,word ptr[esi+eax*2]
|
||||
; if cur_match > limit, go to exitloop
|
||||
cmp ecx,eax
|
||||
jnb exitloop
|
||||
; if --chain_length != 0, go to exitloop
|
||||
dec chain_length
|
||||
jnz normalbeg0
|
||||
jmp exitloop
|
||||
|
||||
normalbeg2noroll:
|
||||
; if (scan_start==*(cur_match+window)) goto normalbeg2
|
||||
cmp bp,word ptr[edx+eax]
|
||||
jne rcontlabnoroll
|
||||
jmp normalbeg2
|
||||
|
||||
contloop3:
|
||||
mov edi,windowlen
|
||||
|
||||
; cur_match = prev[cur_match & wmask]
|
||||
and eax,7fffh
|
||||
mov ax,word ptr[esi+eax*2]
|
||||
; if cur_match > limit, go to exitloop
|
||||
cmp ecx,eax
|
||||
jnbexitloopshort1:
|
||||
jnb exitloop
|
||||
; if --chain_length != 0, go to exitloop
|
||||
|
||||
|
||||
; begin the main loop
|
||||
beginloop2:
|
||||
sub chain_length,16+1
|
||||
; if chain_length <=16, don't use the unrolled loop
|
||||
jna normalbeg0add16
|
||||
|
||||
do16:
|
||||
cmp word ptr[edi+eax],bx
|
||||
je normalbeg2dc0
|
||||
|
||||
maccn MACRO lab
|
||||
and eax,7fffh
|
||||
mov ax,word ptr[esi+eax*2]
|
||||
cmp ecx,eax
|
||||
jnb exitloop
|
||||
cmp word ptr[edi+eax],bx
|
||||
je lab
|
||||
ENDM
|
||||
|
||||
rcontloop0:
|
||||
maccn normalbeg2dc1
|
||||
|
||||
rcontloop1:
|
||||
maccn normalbeg2dc2
|
||||
|
||||
rcontloop2:
|
||||
maccn normalbeg2dc3
|
||||
|
||||
rcontloop3:
|
||||
maccn normalbeg2dc4
|
||||
|
||||
rcontloop4:
|
||||
maccn normalbeg2dc5
|
||||
|
||||
rcontloop5:
|
||||
maccn normalbeg2dc6
|
||||
|
||||
rcontloop6:
|
||||
maccn normalbeg2dc7
|
||||
|
||||
rcontloop7:
|
||||
maccn normalbeg2dc8
|
||||
|
||||
rcontloop8:
|
||||
maccn normalbeg2dc9
|
||||
|
||||
rcontloop9:
|
||||
maccn normalbeg2dc10
|
||||
|
||||
rcontloop10:
|
||||
maccn short normalbeg2dc11
|
||||
|
||||
rcontloop11:
|
||||
maccn short normalbeg2dc12
|
||||
|
||||
rcontloop12:
|
||||
maccn short normalbeg2dc13
|
||||
|
||||
rcontloop13:
|
||||
maccn short normalbeg2dc14
|
||||
|
||||
rcontloop14:
|
||||
maccn short normalbeg2dc15
|
||||
|
||||
rcontloop15:
|
||||
and eax,7fffh
|
||||
mov ax,word ptr[esi+eax*2]
|
||||
cmp ecx,eax
|
||||
jnb exitloop
|
||||
|
||||
sub chain_length,16
|
||||
ja do16
|
||||
jmp normalbeg0add16
|
||||
|
||||
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
|
||||
|
||||
normbeg MACRO rcontlab,valsub
|
||||
; if we are here, we know that *(match+best_len-1) == scan_end
|
||||
cmp bp,word ptr[edx+eax]
|
||||
; if (match != scan_start) goto rcontlab
|
||||
jne rcontlab
|
||||
; calculate the good chain_length, and we'll compare scan and match string
|
||||
add chain_length,16-valsub
|
||||
jmp iseq
|
||||
ENDM
|
||||
|
||||
|
||||
normalbeg2dc11:
|
||||
normbeg rcontloop11,11
|
||||
|
||||
normalbeg2dc12:
|
||||
normbeg short rcontloop12,12
|
||||
|
||||
normalbeg2dc13:
|
||||
normbeg short rcontloop13,13
|
||||
|
||||
normalbeg2dc14:
|
||||
normbeg short rcontloop14,14
|
||||
|
||||
normalbeg2dc15:
|
||||
normbeg short rcontloop15,15
|
||||
|
||||
normalbeg2dc10:
|
||||
normbeg rcontloop10,10
|
||||
|
||||
normalbeg2dc9:
|
||||
normbeg rcontloop9,9
|
||||
|
||||
normalbeg2dc8:
|
||||
normbeg rcontloop8,8
|
||||
|
||||
normalbeg2dc7:
|
||||
normbeg rcontloop7,7
|
||||
|
||||
normalbeg2dc6:
|
||||
normbeg rcontloop6,6
|
||||
|
||||
normalbeg2dc5:
|
||||
normbeg rcontloop5,5
|
||||
|
||||
normalbeg2dc4:
|
||||
normbeg rcontloop4,4
|
||||
|
||||
normalbeg2dc3:
|
||||
normbeg rcontloop3,3
|
||||
|
||||
normalbeg2dc2:
|
||||
normbeg rcontloop2,2
|
||||
|
||||
normalbeg2dc1:
|
||||
normbeg rcontloop1,1
|
||||
|
||||
normalbeg2dc0:
|
||||
normbeg rcontloop0,0
|
||||
|
||||
|
||||
; we go in normalbeg2 because *(ushf*)(match+best_len-1) == scan_end
|
||||
|
||||
normalbeg2:
|
||||
mov edi,window
|
||||
|
||||
cmp bp,word ptr[edi+eax]
|
||||
jne contloop3 ; if *(ushf*)match != scan_start, continue
|
||||
|
||||
iseq:
|
||||
; if we are here, we know that *(match+best_len-1) == scan_end
|
||||
; and (match == scan_start)
|
||||
|
||||
mov edi,edx
|
||||
mov esi,scan ; esi = scan
|
||||
add edi,eax ; edi = window + cur_match = match
|
||||
|
||||
mov edx,[esi+3] ; compare manually dword at match+3
|
||||
xor edx,[edi+3] ; and scan +3
|
||||
|
||||
jz begincompare ; if equal, go to long compare
|
||||
|
||||
; we will determine the unmatch byte and calculate len (in esi)
|
||||
or dl,dl
|
||||
je eq1rr
|
||||
mov esi,3
|
||||
jmp trfinval
|
||||
eq1rr:
|
||||
or dx,dx
|
||||
je eq1
|
||||
|
||||
mov esi,4
|
||||
jmp trfinval
|
||||
eq1:
|
||||
and edx,0ffffffh
|
||||
jz eq11
|
||||
mov esi,5
|
||||
jmp trfinval
|
||||
eq11:
|
||||
mov esi,6
|
||||
jmp trfinval
|
||||
|
||||
begincompare:
|
||||
; here we now scan and match begin same
|
||||
add edi,6
|
||||
add esi,6
|
||||
mov ecx,(MAX_MATCH-(2+4))/4 ; scan for at most MAX_MATCH bytes
|
||||
repe cmpsd ; loop until mismatch
|
||||
|
||||
je trfin ; go to trfin if not unmatch
|
||||
; we determine the unmatch byte
|
||||
sub esi,4
|
||||
mov edx,[edi-4]
|
||||
xor edx,[esi]
|
||||
|
||||
or dl,dl
|
||||
jnz trfin
|
||||
inc esi
|
||||
|
||||
or dx,dx
|
||||
jnz trfin
|
||||
inc esi
|
||||
|
||||
and edx,0ffffffh
|
||||
jnz trfin
|
||||
inc esi
|
||||
|
||||
trfin:
|
||||
sub esi,scan ; esi = len
|
||||
trfinval:
|
||||
; here we have finised compare, and esi contain len of equal string
|
||||
cmp esi,best_len ; if len > best_len, go newbestlen
|
||||
ja short newbestlen
|
||||
; now we restore edx, ecx and esi, for the big loop
|
||||
mov esi,prev
|
||||
mov ecx,limit
|
||||
mov edx,window
|
||||
jmp contloop3
|
||||
|
||||
newbestlen:
|
||||
mov best_len,esi ; len become best_len
|
||||
|
||||
mov match_start,eax ; save new position as match_start
|
||||
cmp esi,nice_match ; if best_len >= nice_match, exit
|
||||
jae exitloop
|
||||
mov ecx,scan
|
||||
mov edx,window ; restore edx=window
|
||||
add ecx,esi
|
||||
add esi,edx
|
||||
|
||||
dec esi
|
||||
mov windowlen,esi ; windowlen = window + best_len-1
|
||||
mov bx,[ecx-1] ; bx = *(scan+best_len-1) = scan_end
|
||||
|
||||
; now we restore ecx and esi, for the big loop :
|
||||
mov esi,prev
|
||||
mov ecx,limit
|
||||
jmp contloop3
|
||||
|
||||
exitloop:
|
||||
; exit : s->match_start=match_start
|
||||
mov ebx,match_start
|
||||
mov ebp,str_s
|
||||
mov ecx,best_len
|
||||
mov dword ptr [ebp+dep_match_start],ebx
|
||||
mov eax,dword ptr [ebp+dep_lookahead]
|
||||
cmp ecx,eax
|
||||
ja minexlo
|
||||
mov eax,ecx
|
||||
minexlo:
|
||||
; return min(best_len,s->lookahead)
|
||||
|
||||
; restore stack and register ebx,esi,edi,ebp
|
||||
add esp,NbStackAdd
|
||||
|
||||
pop ebx
|
||||
pop esi
|
||||
pop edi
|
||||
pop ebp
|
||||
ret
|
||||
InfoAuthor:
|
||||
; please don't remove this string !
|
||||
; Your are free use gvmat32 in any fre or commercial apps if you don't remove the string in the binary!
|
||||
db 0dh,0ah,"GVMat32 optimised assembly code written 1996-98 by Gilles Vollant",0dh,0ah
|
||||
|
||||
|
||||
|
||||
IFDEF NOUNDERLINE
|
||||
longest_match_7fff endp
|
||||
ELSE
|
||||
_longest_match_7fff endp
|
||||
ENDIF
|
||||
|
||||
|
||||
IFDEF NOUNDERLINE
|
||||
cpudetect32 proc near
|
||||
ELSE
|
||||
_cpudetect32 proc near
|
||||
ENDIF
|
||||
|
||||
push ebx
|
||||
|
||||
pushfd ; push original EFLAGS
|
||||
pop eax ; get original EFLAGS
|
||||
mov ecx, eax ; save original EFLAGS
|
||||
xor eax, 40000h ; flip AC bit in EFLAGS
|
||||
push eax ; save new EFLAGS value on stack
|
||||
popfd ; replace current EFLAGS value
|
||||
pushfd ; get new EFLAGS
|
||||
pop eax ; store new EFLAGS in EAX
|
||||
xor eax, ecx ; can’t toggle AC bit, processor=80386
|
||||
jz end_cpu_is_386 ; jump if 80386 processor
|
||||
push ecx
|
||||
popfd ; restore AC bit in EFLAGS first
|
||||
|
||||
pushfd
|
||||
pushfd
|
||||
pop ecx
|
||||
|
||||
mov eax, ecx ; get original EFLAGS
|
||||
xor eax, 200000h ; flip ID bit in EFLAGS
|
||||
push eax ; save new EFLAGS value on stack
|
||||
popfd ; replace current EFLAGS value
|
||||
pushfd ; get new EFLAGS
|
||||
pop eax ; store new EFLAGS in EAX
|
||||
popfd ; restore original EFLAGS
|
||||
xor eax, ecx ; can’t toggle ID bit,
|
||||
je is_old_486 ; processor=old
|
||||
|
||||
mov eax,1
|
||||
db 0fh,0a2h ;CPUID
|
||||
|
||||
exitcpudetect:
|
||||
pop ebx
|
||||
ret
|
||||
|
||||
end_cpu_is_386:
|
||||
mov eax,0300h
|
||||
jmp exitcpudetect
|
||||
|
||||
is_old_486:
|
||||
mov eax,0400h
|
||||
jmp exitcpudetect
|
||||
|
||||
IFDEF NOUNDERLINE
|
||||
cpudetect32 endp
|
||||
ELSE
|
||||
_cpudetect32 endp
|
||||
ENDIF
|
||||
|
||||
|
||||
|
||||
|
||||
MAX_MATCH equ 258
|
||||
MIN_MATCH equ 3
|
||||
MIN_LOOKAHEAD equ (MAX_MATCH + MIN_MATCH + 1)
|
||||
MAX_MATCH_8_ equ ((MAX_MATCH + 7) AND 0FFF0h)
|
||||
|
||||
|
||||
;;; stack frame offsets
|
||||
|
||||
chainlenwmask equ esp + 0 ; high word: current chain len
|
||||
; low word: s->wmask
|
||||
window equ esp + 4 ; local copy of s->window
|
||||
windowbestlen equ esp + 8 ; s->window + bestlen
|
||||
scanstart equ esp + 16 ; first two bytes of string
|
||||
scanend equ esp + 12 ; last two bytes of string
|
||||
scanalign equ esp + 20 ; dword-misalignment of string
|
||||
nicematch equ esp + 24 ; a good enough match size
|
||||
bestlen equ esp + 28 ; size of best match so far
|
||||
scan equ esp + 32 ; ptr to string wanting match
|
||||
|
||||
LocalVarsSize equ 36
|
||||
; saved ebx byte esp + 36
|
||||
; saved edi byte esp + 40
|
||||
; saved esi byte esp + 44
|
||||
; saved ebp byte esp + 48
|
||||
; return address byte esp + 52
|
||||
deflatestate equ esp + 56 ; the function arguments
|
||||
curmatch equ esp + 60
|
||||
|
||||
;;; Offsets for fields in the deflate_state structure. These numbers
|
||||
;;; are calculated from the definition of deflate_state, with the
|
||||
;;; assumption that the compiler will dword-align the fields. (Thus,
|
||||
;;; changing the definition of deflate_state could easily cause this
|
||||
;;; program to crash horribly, without so much as a warning at
|
||||
;;; compile time. Sigh.)
|
||||
|
||||
dsWSize equ 36
|
||||
dsWMask equ 44
|
||||
dsWindow equ 48
|
||||
dsPrev equ 56
|
||||
dsMatchLen equ 88
|
||||
dsPrevMatch equ 92
|
||||
dsStrStart equ 100
|
||||
dsMatchStart equ 104
|
||||
dsLookahead equ 108
|
||||
dsPrevLen equ 112
|
||||
dsMaxChainLen equ 116
|
||||
dsGoodMatch equ 132
|
||||
dsNiceMatch equ 136
|
||||
|
||||
|
||||
;;; match.asm -- Pentium-Pro-optimized version of longest_match()
|
||||
;;; Written for zlib 1.1.2
|
||||
;;; Copyright (C) 1998 Brian Raiter <breadbox@muppetlabs.com>
|
||||
;;; You can look at http://www.muppetlabs.com/~breadbox/software/assembly.html
|
||||
;;;
|
||||
;;; This is free software; you can redistribute it and/or modify it
|
||||
;;; under the terms of the GNU General Public License.
|
||||
|
||||
;GLOBAL _longest_match, _match_init
|
||||
|
||||
|
||||
;SECTION .text
|
||||
|
||||
;;; uInt longest_match(deflate_state *deflatestate, IPos curmatch)
|
||||
|
||||
;_longest_match:
|
||||
IFDEF NOUNDERLINE
|
||||
longest_match_686 proc near
|
||||
ELSE
|
||||
_longest_match_686 proc near
|
||||
ENDIF
|
||||
|
||||
|
||||
;;; Save registers that the compiler may be using, and adjust esp to
|
||||
;;; make room for our stack frame.
|
||||
|
||||
push ebp
|
||||
push edi
|
||||
push esi
|
||||
push ebx
|
||||
sub esp, LocalVarsSize
|
||||
|
||||
;;; Retrieve the function arguments. ecx will hold cur_match
|
||||
;;; throughout the entire function. edx will hold the pointer to the
|
||||
;;; deflate_state structure during the function's setup (before
|
||||
;;; entering the main loop.
|
||||
|
||||
mov edx, [deflatestate]
|
||||
mov ecx, [curmatch]
|
||||
|
||||
;;; uInt wmask = s->w_mask;
|
||||
;;; unsigned chain_length = s->max_chain_length;
|
||||
;;; if (s->prev_length >= s->good_match) {
|
||||
;;; chain_length >>= 2;
|
||||
;;; }
|
||||
|
||||
mov eax, [edx + dsPrevLen]
|
||||
mov ebx, [edx + dsGoodMatch]
|
||||
cmp eax, ebx
|
||||
mov eax, [edx + dsWMask]
|
||||
mov ebx, [edx + dsMaxChainLen]
|
||||
jl LastMatchGood
|
||||
shr ebx, 2
|
||||
LastMatchGood:
|
||||
|
||||
;;; chainlen is decremented once beforehand so that the function can
|
||||
;;; use the sign flag instead of the zero flag for the exit test.
|
||||
;;; It is then shifted into the high word, to make room for the wmask
|
||||
;;; value, which it will always accompany.
|
||||
|
||||
dec ebx
|
||||
shl ebx, 16
|
||||
or ebx, eax
|
||||
mov [chainlenwmask], ebx
|
||||
|
||||
;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
|
||||
|
||||
mov eax, [edx + dsNiceMatch]
|
||||
mov ebx, [edx + dsLookahead]
|
||||
cmp ebx, eax
|
||||
jl LookaheadLess
|
||||
mov ebx, eax
|
||||
LookaheadLess: mov [nicematch], ebx
|
||||
|
||||
;;; register Bytef *scan = s->window + s->strstart;
|
||||
|
||||
mov esi, [edx + dsWindow]
|
||||
mov [window], esi
|
||||
mov ebp, [edx + dsStrStart]
|
||||
lea edi, [esi + ebp]
|
||||
mov [scan], edi
|
||||
|
||||
;;; Determine how many bytes the scan ptr is off from being
|
||||
;;; dword-aligned.
|
||||
|
||||
mov eax, edi
|
||||
neg eax
|
||||
and eax, 3
|
||||
mov [scanalign], eax
|
||||
|
||||
;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
|
||||
;;; s->strstart - (IPos)MAX_DIST(s) : NIL;
|
||||
|
||||
mov eax, [edx + dsWSize]
|
||||
sub eax, MIN_LOOKAHEAD
|
||||
sub ebp, eax
|
||||
jg LimitPositive
|
||||
xor ebp, ebp
|
||||
LimitPositive:
|
||||
|
||||
;;; int best_len = s->prev_length;
|
||||
|
||||
mov eax, [edx + dsPrevLen]
|
||||
mov [bestlen], eax
|
||||
|
||||
;;; Store the sum of s->window + best_len in esi locally, and in esi.
|
||||
|
||||
add esi, eax
|
||||
mov [windowbestlen], esi
|
||||
|
||||
;;; register ush scan_start = *(ushf*)scan;
|
||||
;;; register ush scan_end = *(ushf*)(scan+best_len-1);
|
||||
;;; Posf *prev = s->prev;
|
||||
|
||||
movzx ebx, word ptr [edi]
|
||||
mov [scanstart], ebx
|
||||
movzx ebx, word ptr [edi + eax - 1]
|
||||
mov [scanend], ebx
|
||||
mov edi, [edx + dsPrev]
|
||||
|
||||
;;; Jump into the main loop.
|
||||
|
||||
mov edx, [chainlenwmask]
|
||||
jmp short LoopEntry
|
||||
|
||||
align 4
|
||||
|
||||
;;; do {
|
||||
;;; match = s->window + cur_match;
|
||||
;;; if (*(ushf*)(match+best_len-1) != scan_end ||
|
||||
;;; *(ushf*)match != scan_start) continue;
|
||||
;;; [...]
|
||||
;;; } while ((cur_match = prev[cur_match & wmask]) > limit
|
||||
;;; && --chain_length != 0);
|
||||
;;;
|
||||
;;; Here is the inner loop of the function. The function will spend the
|
||||
;;; majority of its time in this loop, and majority of that time will
|
||||
;;; be spent in the first ten instructions.
|
||||
;;;
|
||||
;;; Within this loop:
|
||||
;;; ebx = scanend
|
||||
;;; ecx = curmatch
|
||||
;;; edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)
|
||||
;;; esi = windowbestlen - i.e., (window + bestlen)
|
||||
;;; edi = prev
|
||||
;;; ebp = limit
|
||||
|
||||
LookupLoop:
|
||||
and ecx, edx
|
||||
movzx ecx, word ptr [edi + ecx*2]
|
||||
cmp ecx, ebp
|
||||
jbe LeaveNow
|
||||
sub edx, 00010000h
|
||||
js LeaveNow
|
||||
LoopEntry: movzx eax, word ptr [esi + ecx - 1]
|
||||
cmp eax, ebx
|
||||
jnz LookupLoop
|
||||
mov eax, [window]
|
||||
movzx eax, word ptr [eax + ecx]
|
||||
cmp eax, [scanstart]
|
||||
jnz LookupLoop
|
||||
|
||||
;;; Store the current value of chainlen.
|
||||
|
||||
mov [chainlenwmask], edx
|
||||
|
||||
;;; Point edi to the string under scrutiny, and esi to the string we
|
||||
;;; are hoping to match it up with. In actuality, esi and edi are
|
||||
;;; both pointed (MAX_MATCH_8 - scanalign) bytes ahead, and edx is
|
||||
;;; initialized to -(MAX_MATCH_8 - scanalign).
|
||||
|
||||
mov esi, [window]
|
||||
mov edi, [scan]
|
||||
add esi, ecx
|
||||
mov eax, [scanalign]
|
||||
mov edx, 0fffffef8h; -(MAX_MATCH_8)
|
||||
lea edi, [edi + eax + 0108h] ;MAX_MATCH_8]
|
||||
lea esi, [esi + eax + 0108h] ;MAX_MATCH_8]
|
||||
|
||||
;;; Test the strings for equality, 8 bytes at a time. At the end,
|
||||
;;; adjust edx so that it is offset to the exact byte that mismatched.
|
||||
;;;
|
||||
;;; We already know at this point that the first three bytes of the
|
||||
;;; strings match each other, and they can be safely passed over before
|
||||
;;; starting the compare loop. So what this code does is skip over 0-3
|
||||
;;; bytes, as much as necessary in order to dword-align the edi
|
||||
;;; pointer. (esi will still be misaligned three times out of four.)
|
||||
;;;
|
||||
;;; It should be confessed that this loop usually does not represent
|
||||
;;; much of the total running time. Replacing it with a more
|
||||
;;; straightforward "rep cmpsb" would not drastically degrade
|
||||
;;; performance.
|
||||
|
||||
LoopCmps:
|
||||
mov eax, [esi + edx]
|
||||
xor eax, [edi + edx]
|
||||
jnz LeaveLoopCmps
|
||||
mov eax, [esi + edx + 4]
|
||||
xor eax, [edi + edx + 4]
|
||||
jnz LeaveLoopCmps4
|
||||
add edx, 8
|
||||
jnz LoopCmps
|
||||
jmp short LenMaximum
|
||||
LeaveLoopCmps4: add edx, 4
|
||||
LeaveLoopCmps: test eax, 0000FFFFh
|
||||
jnz LenLower
|
||||
add edx, 2
|
||||
shr eax, 16
|
||||
LenLower: sub al, 1
|
||||
adc edx, 0
|
||||
|
||||
;;; Calculate the length of the match. If it is longer than MAX_MATCH,
|
||||
;;; then automatically accept it as the best possible match and leave.
|
||||
|
||||
lea eax, [edi + edx]
|
||||
mov edi, [scan]
|
||||
sub eax, edi
|
||||
cmp eax, MAX_MATCH
|
||||
jge LenMaximum
|
||||
|
||||
;;; If the length of the match is not longer than the best match we
|
||||
;;; have so far, then forget it and return to the lookup loop.
|
||||
|
||||
mov edx, [deflatestate]
|
||||
mov ebx, [bestlen]
|
||||
cmp eax, ebx
|
||||
jg LongerMatch
|
||||
mov esi, [windowbestlen]
|
||||
mov edi, [edx + dsPrev]
|
||||
mov ebx, [scanend]
|
||||
mov edx, [chainlenwmask]
|
||||
jmp LookupLoop
|
||||
|
||||
;;; s->match_start = cur_match;
|
||||
;;; best_len = len;
|
||||
;;; if (len >= nice_match) break;
|
||||
;;; scan_end = *(ushf*)(scan+best_len-1);
|
||||
|
||||
LongerMatch: mov ebx, [nicematch]
|
||||
mov [bestlen], eax
|
||||
mov [edx + dsMatchStart], ecx
|
||||
cmp eax, ebx
|
||||
jge LeaveNow
|
||||
mov esi, [window]
|
||||
add esi, eax
|
||||
mov [windowbestlen], esi
|
||||
movzx ebx, word ptr [edi + eax - 1]
|
||||
mov edi, [edx + dsPrev]
|
||||
mov [scanend], ebx
|
||||
mov edx, [chainlenwmask]
|
||||
jmp LookupLoop
|
||||
|
||||
;;; Accept the current string, with the maximum possible length.
|
||||
|
||||
LenMaximum: mov edx, [deflatestate]
|
||||
mov dword ptr [bestlen], MAX_MATCH
|
||||
mov [edx + dsMatchStart], ecx
|
||||
|
||||
;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
|
||||
;;; return s->lookahead;
|
||||
|
||||
LeaveNow:
|
||||
mov edx, [deflatestate]
|
||||
mov ebx, [bestlen]
|
||||
mov eax, [edx + dsLookahead]
|
||||
cmp ebx, eax
|
||||
jg LookaheadRet
|
||||
mov eax, ebx
|
||||
LookaheadRet:
|
||||
|
||||
;;; Restore the stack and return from whence we came.
|
||||
|
||||
add esp, LocalVarsSize
|
||||
pop ebx
|
||||
pop esi
|
||||
pop edi
|
||||
pop ebp
|
||||
|
||||
ret
|
||||
; please don't remove this string !
|
||||
; Your can freely use gvmat32 in any free or commercial app if you don't remove the string in the binary!
|
||||
db 0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998",0dh,0ah
|
||||
|
||||
IFDEF NOUNDERLINE
|
||||
longest_match_686 endp
|
||||
ELSE
|
||||
_longest_match_686 endp
|
||||
ENDIF
|
||||
|
||||
_TEXT ends
|
||||
end
|
||||
|
|
@ -1,206 +0,0 @@
|
|||
/* gvmat32.c -- C portion of the optimized longest_match for 32 bits x86
|
||||
* Copyright (C) 1995-1996 Jean-loup Gailly and Gilles Vollant.
|
||||
* File written by Gilles Vollant, by modifiying the longest_match
|
||||
* from Jean-loup Gailly in deflate.c
|
||||
* it prepare all parameters and call the assembly longest_match_gvasm
|
||||
* longest_match execute standard C code is wmask != 0x7fff
|
||||
* (assembly code is faster with a fixed wmask)
|
||||
*
|
||||
*/
|
||||
|
||||
#include "deflate.h"
|
||||
|
||||
#ifdef ASMV
|
||||
#define NIL 0
|
||||
|
||||
#define UNALIGNED_OK
|
||||
|
||||
|
||||
/* if your C compiler don't add underline before function name,
|
||||
define ADD_UNDERLINE_ASMFUNC */
|
||||
#ifdef ADD_UNDERLINE_ASMFUNC
|
||||
#define longest_match_7fff _longest_match_7fff
|
||||
#define longest_match_686 _longest_match_686
|
||||
#define cpudetect32 _cpudetect32
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
void match_init()
|
||||
{
|
||||
}
|
||||
|
||||
unsigned long cpudetect32();
|
||||
|
||||
uInt longest_match_c(
|
||||
deflate_state *s,
|
||||
IPos cur_match); /* current match */
|
||||
|
||||
|
||||
uInt longest_match_7fff(
|
||||
deflate_state *s,
|
||||
IPos cur_match); /* current match */
|
||||
|
||||
uInt longest_match_686(
|
||||
deflate_state *s,
|
||||
IPos cur_match); /* current match */
|
||||
|
||||
uInt longest_match(
|
||||
deflate_state *s,
|
||||
IPos cur_match) /* current match */
|
||||
{
|
||||
static uInt iIsPPro=2;
|
||||
|
||||
if ((s->w_mask == 0x7fff) && (iIsPPro==0))
|
||||
return longest_match_7fff(s,cur_match);
|
||||
|
||||
if (iIsPPro==1)
|
||||
return longest_match_686(s,cur_match);
|
||||
|
||||
if (iIsPPro==2)
|
||||
iIsPPro = (((cpudetect32()/0x100)&0xf)>=6) ? 1 : 0;
|
||||
|
||||
return longest_match_c(s,cur_match);
|
||||
}
|
||||
|
||||
|
||||
|
||||
uInt longest_match_c(s, cur_match)
|
||||
deflate_state *s;
|
||||
IPos cur_match; /* current match */
|
||||
{
|
||||
unsigned chain_length = s->max_chain_length;/* max hash chain length */
|
||||
register Bytef *scan = s->window + s->strstart; /* current string */
|
||||
register Bytef *match; /* matched string */
|
||||
register int len; /* length of current match */
|
||||
int best_len = s->prev_length; /* best match length so far */
|
||||
int nice_match = s->nice_match; /* stop if match long enough */
|
||||
IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
|
||||
s->strstart - (IPos)MAX_DIST(s) : NIL;
|
||||
/* Stop when cur_match becomes <= limit. To simplify the code,
|
||||
* we prevent matches with the string of window index 0.
|
||||
*/
|
||||
Posf *prev = s->prev;
|
||||
uInt wmask = s->w_mask;
|
||||
|
||||
#ifdef UNALIGNED_OK
|
||||
/* Compare two bytes at a time. Note: this is not always beneficial.
|
||||
* Try with and without -DUNALIGNED_OK to check.
|
||||
*/
|
||||
register Bytef *strend = s->window + s->strstart + MAX_MATCH - 1;
|
||||
register ush scan_start = *(ushf*)scan;
|
||||
register ush scan_end = *(ushf*)(scan+best_len-1);
|
||||
#else
|
||||
register Bytef *strend = s->window + s->strstart + MAX_MATCH;
|
||||
register Byte scan_end1 = scan[best_len-1];
|
||||
register Byte scan_end = scan[best_len];
|
||||
#endif
|
||||
|
||||
/* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16.
|
||||
* It is easy to get rid of this optimization if necessary.
|
||||
*/
|
||||
Assert(s->hash_bits >= 8 && MAX_MATCH == 258, "Code too clever");
|
||||
|
||||
/* Do not waste too much time if we already have a good match: */
|
||||
if (s->prev_length >= s->good_match) {
|
||||
chain_length >>= 2;
|
||||
}
|
||||
/* Do not look for matches beyond the end of the input. This is necessary
|
||||
* to make deflate deterministic.
|
||||
*/
|
||||
if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
|
||||
|
||||
Assert((ulg)s->strstart <= s->window_size-MIN_LOOKAHEAD, "need lookahead");
|
||||
|
||||
do {
|
||||
Assert(cur_match < s->strstart, "no future");
|
||||
match = s->window + cur_match;
|
||||
|
||||
/* Skip to next match if the match length cannot increase
|
||||
* or if the match length is less than 2:
|
||||
*/
|
||||
#if (defined(UNALIGNED_OK) && MAX_MATCH == 258)
|
||||
/* This code assumes sizeof(unsigned short) == 2. Do not use
|
||||
* UNALIGNED_OK if your compiler uses a different size.
|
||||
*/
|
||||
if (*(ushf*)(match+best_len-1) != scan_end ||
|
||||
*(ushf*)match != scan_start) continue;
|
||||
|
||||
/* It is not necessary to compare scan[2] and match[2] since they are
|
||||
* always equal when the other bytes match, given that the hash keys
|
||||
* are equal and that HASH_BITS >= 8. Compare 2 bytes at a time at
|
||||
* strstart+3, +5, ... up to strstart+257. We check for insufficient
|
||||
* lookahead only every 4th comparison; the 128th check will be made
|
||||
* at strstart+257. If MAX_MATCH-2 is not a multiple of 8, it is
|
||||
* necessary to put more guard bytes at the end of the window, or
|
||||
* to check more often for insufficient lookahead.
|
||||
*/
|
||||
Assert(scan[2] == match[2], "scan[2]?");
|
||||
scan++, match++;
|
||||
do {
|
||||
} while (*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
|
||||
*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
|
||||
*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
|
||||
*(ushf*)(scan+=2) == *(ushf*)(match+=2) &&
|
||||
scan < strend);
|
||||
/* The funny "do {}" generates better code on most compilers */
|
||||
|
||||
/* Here, scan <= window+strstart+257 */
|
||||
Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
|
||||
if (*scan == *match) scan++;
|
||||
|
||||
len = (MAX_MATCH - 1) - (int)(strend-scan);
|
||||
scan = strend - (MAX_MATCH-1);
|
||||
|
||||
#else /* UNALIGNED_OK */
|
||||
|
||||
if (match[best_len] != scan_end ||
|
||||
match[best_len-1] != scan_end1 ||
|
||||
*match != *scan ||
|
||||
*++match != scan[1]) continue;
|
||||
|
||||
/* The check at best_len-1 can be removed because it will be made
|
||||
* again later. (This heuristic is not always a win.)
|
||||
* It is not necessary to compare scan[2] and match[2] since they
|
||||
* are always equal when the other bytes match, given that
|
||||
* the hash keys are equal and that HASH_BITS >= 8.
|
||||
*/
|
||||
scan += 2, match++;
|
||||
Assert(*scan == *match, "match[2]?");
|
||||
|
||||
/* We check for insufficient lookahead only every 8th comparison;
|
||||
* the 256th check will be made at strstart+258.
|
||||
*/
|
||||
do {
|
||||
} while (*++scan == *++match && *++scan == *++match &&
|
||||
*++scan == *++match && *++scan == *++match &&
|
||||
*++scan == *++match && *++scan == *++match &&
|
||||
*++scan == *++match && *++scan == *++match &&
|
||||
scan < strend);
|
||||
|
||||
Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan");
|
||||
|
||||
len = MAX_MATCH - (int)(strend - scan);
|
||||
scan = strend - MAX_MATCH;
|
||||
|
||||
#endif /* UNALIGNED_OK */
|
||||
|
||||
if (len > best_len) {
|
||||
s->match_start = cur_match;
|
||||
best_len = len;
|
||||
if (len >= nice_match) break;
|
||||
#ifdef UNALIGNED_OK
|
||||
scan_end = *(ushf*)(scan+best_len-1);
|
||||
#else
|
||||
scan_end1 = scan[best_len-1];
|
||||
scan_end = scan[best_len];
|
||||
#endif
|
||||
}
|
||||
} while ((cur_match = prev[cur_match & wmask]) > limit
|
||||
&& --chain_length != 0);
|
||||
|
||||
if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
|
||||
return s->lookahead;
|
||||
}
|
||||
|
||||
#endif /* ASMV */
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,3 +0,0 @@
|
|||
cl /I..\.. /O2 /c gvmat32c.c
|
||||
ml /coff /Zi /c /Flgvmat32.lst gvmat32.asm
|
||||
ml /coff /Zi /c /Flinffas32.lst inffas32.asm
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
|
||||
Summary
|
||||
-------
|
||||
This directory contains ASM implementations of the functions
|
||||
longest_match() and inflate_fast().
|
||||
|
||||
|
||||
Use instructions
|
||||
----------------
|
||||
Copy these files into the zlib source directory, then run the
|
||||
appropriate makefile, as suggested below.
|
||||
|
||||
|
||||
Build instructions
|
||||
------------------
|
||||
* With Microsoft C and MASM:
|
||||
nmake -f win32/Makefile.msc LOC="-DASMV -DASMINF" OBJA="gvmat32c.obj gvmat32.obj inffas32.obj"
|
||||
|
||||
* With Borland C and TASM:
|
||||
make -f win32/Makefile.bor LOCAL_ZLIB="-DASMV -DASMINF" OBJA="gvmat32c.obj gvmat32.obj inffas32.obj" OBJPA="+gvmat32c.obj+gvmat32.obj+inffas32.obj"
|
||||
|
||||
|
|
@ -1,55 +0,0 @@
|
|||
Change in 1.00: (10 sept 03)
|
||||
- rename to 1.00
|
||||
- cosmetic code change
|
||||
|
||||
Change in 0.22: (19 May 03)
|
||||
- crypting support (unless you define NOCRYPT)
|
||||
- append file in existing zipfile
|
||||
|
||||
Change in 0.21: (10 Mar 03)
|
||||
- bug fixes
|
||||
|
||||
Change in 0.17: (27 Jan 02)
|
||||
- bug fixes
|
||||
|
||||
Change in 0.16: (19 Jan 02)
|
||||
- Support of ioapi for virtualize zip file access
|
||||
|
||||
Change in 0.15: (19 Mar 98)
|
||||
- fix memory leak in minizip.c
|
||||
|
||||
Change in 0.14: (10 Mar 98)
|
||||
- fix bugs in minizip.c sample for zipping big file
|
||||
- fix problem in month in date handling
|
||||
- fix bug in unzlocal_GetCurrentFileInfoInternal in unzip.c for
|
||||
comment handling
|
||||
|
||||
Change in 0.13: (6 Mar 98)
|
||||
- fix bugs in zip.c
|
||||
- add real minizip sample
|
||||
|
||||
Change in 0.12: (4 Mar 98)
|
||||
- add zip.c and zip.h for creates .zip file
|
||||
- fix change_file_date in miniunz.c for Unix (Jean-loup Gailly)
|
||||
- fix miniunz.c for file without specific record for directory
|
||||
|
||||
Change in 0.11: (3 Mar 98)
|
||||
- fix bug in unzGetCurrentFileInfo for get extra field and comment
|
||||
- enhance miniunz sample, remove the bad unztst.c sample
|
||||
|
||||
Change in 0.10: (2 Mar 98)
|
||||
- fix bug in unzReadCurrentFile
|
||||
- rename unzip* to unz* function and structure
|
||||
- remove Windows-like hungary notation variable name
|
||||
- modify some structure in unzip.h
|
||||
- add somes comment in source
|
||||
- remove unzipGetcCurrentFile function
|
||||
- replace ZUNZEXPORT by ZEXPORT
|
||||
- add unzGetLocalExtrafield for get the local extrafield info
|
||||
- add a new sample, miniunz.c
|
||||
|
||||
Change in 0.4: (25 Feb 98)
|
||||
- suppress the type unzipFileInZip.
|
||||
Only on file in the zipfile can be open at the same time
|
||||
- fix somes typo in code
|
||||
- added tm_unz structure in unzip_file_info (date/time in readable format)
|
||||
|
|
@ -1,25 +0,0 @@
|
|||
CC=cc
|
||||
CFLAGS=-O -I../..
|
||||
|
||||
UNZ_OBJS = miniunz.o unzip.o ioapi.o ../../libz.a
|
||||
ZIP_OBJS = minizip.o zip.o ioapi.o ../../libz.a
|
||||
|
||||
.c.o:
|
||||
$(CC) -c $(CFLAGS) $*.c
|
||||
|
||||
all: miniunz minizip
|
||||
|
||||
miniunz: $(UNZ_OBJS)
|
||||
$(CC) $(CFLAGS) -o $@ $(UNZ_OBJS)
|
||||
|
||||
minizip: $(ZIP_OBJS)
|
||||
$(CC) $(CFLAGS) -o $@ $(ZIP_OBJS)
|
||||
|
||||
test: miniunz minizip
|
||||
./minizip test readme.txt
|
||||
./miniunz -l test.zip
|
||||
mv readme.txt readme.old
|
||||
./miniunz test.zip
|
||||
|
||||
clean:
|
||||
/bin/rm -f *.o *~ minizip miniunz
|
||||
|
|
@ -1,132 +0,0 @@
|
|||
/* crypt.h -- base code for crypt/uncrypt ZIPfile
|
||||
|
||||
|
||||
Version 1.00, September 10th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
|
||||
This code is a modified version of crypting code in Infozip distribution
|
||||
|
||||
The encryption/decryption parts of this source code (as opposed to the
|
||||
non-echoing password parts) were originally written in Europe. The
|
||||
whole source package can be freely distributed, including from the USA.
|
||||
(Prior to January 2000, re-export from the US was a violation of US law.)
|
||||
|
||||
This encryption code is a direct transcription of the algorithm from
|
||||
Roger Schlafly, described by Phil Katz in the file appnote.txt. This
|
||||
file (appnote.txt) is distributed with the PKZIP program (even in the
|
||||
version without encryption capabilities).
|
||||
|
||||
If you don't need crypting in your application, just define symbols
|
||||
NOCRYPT and NOUNCRYPT.
|
||||
|
||||
This code support the "Traditional PKWARE Encryption".
|
||||
|
||||
The new AES encryption added on Zip format by Winzip (see the page
|
||||
http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong
|
||||
Encryption is not supported.
|
||||
*/
|
||||
|
||||
#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
|
||||
|
||||
/***********************************************************************
|
||||
* Return the next byte in the pseudo-random sequence
|
||||
*/
|
||||
static int decrypt_byte(unsigned long* pkeys, const unsigned long* pcrc_32_tab)
|
||||
{
|
||||
unsigned temp; /* POTENTIAL BUG: temp*(temp^1) may overflow in an
|
||||
* unpredictable manner on 16-bit systems; not a problem
|
||||
* with any known compiler so far, though */
|
||||
|
||||
temp = ((unsigned)(*(pkeys+2)) & 0xffff) | 2;
|
||||
return (int)(((temp * (temp ^ 1)) >> 8) & 0xff);
|
||||
}
|
||||
|
||||
/***********************************************************************
|
||||
* Update the encryption keys with the next byte of plain text
|
||||
*/
|
||||
static int update_keys(unsigned long* pkeys,const unsigned long* pcrc_32_tab,int c)
|
||||
{
|
||||
(*(pkeys+0)) = CRC32((*(pkeys+0)), c);
|
||||
(*(pkeys+1)) += (*(pkeys+0)) & 0xff;
|
||||
(*(pkeys+1)) = (*(pkeys+1)) * 134775813L + 1;
|
||||
{
|
||||
register int keyshift = (int)((*(pkeys+1)) >> 24);
|
||||
(*(pkeys+2)) = CRC32((*(pkeys+2)), keyshift);
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
|
||||
/***********************************************************************
|
||||
* Initialize the encryption keys and the random header according to
|
||||
* the given password.
|
||||
*/
|
||||
static void init_keys(const char* passwd,unsigned long* pkeys,const unsigned long* pcrc_32_tab)
|
||||
{
|
||||
*(pkeys+0) = 305419896L;
|
||||
*(pkeys+1) = 591751049L;
|
||||
*(pkeys+2) = 878082192L;
|
||||
while (*passwd != '\0') {
|
||||
update_keys(pkeys,pcrc_32_tab,(int)*passwd);
|
||||
passwd++;
|
||||
}
|
||||
}
|
||||
|
||||
#define zdecode(pkeys,pcrc_32_tab,c) \
|
||||
(update_keys(pkeys,pcrc_32_tab,c ^= decrypt_byte(pkeys,pcrc_32_tab)))
|
||||
|
||||
#define zencode(pkeys,pcrc_32_tab,c,t) \
|
||||
(t=decrypt_byte(pkeys,pcrc_32_tab), update_keys(pkeys,pcrc_32_tab,c), t^(c))
|
||||
|
||||
#ifdef INCLUDECRYPTINGCODE_IFCRYPTALLOWED
|
||||
|
||||
#define RAND_HEAD_LEN 12
|
||||
/* "last resort" source for second part of crypt seed pattern */
|
||||
# ifndef ZCR_SEED2
|
||||
# define ZCR_SEED2 3141592654UL /* use PI as default pattern */
|
||||
# endif
|
||||
|
||||
static int crypthead(passwd, buf, bufSize, pkeys, pcrc_32_tab, crcForCrypting)
|
||||
const char *passwd; /* password string */
|
||||
unsigned char *buf; /* where to write header */
|
||||
int bufSize;
|
||||
unsigned long* pkeys;
|
||||
const unsigned long* pcrc_32_tab;
|
||||
unsigned long crcForCrypting;
|
||||
{
|
||||
int n; /* index in random header */
|
||||
int t; /* temporary */
|
||||
int c; /* random byte */
|
||||
unsigned char header[RAND_HEAD_LEN-2]; /* random header */
|
||||
static unsigned calls = 0; /* ensure different random header each time */
|
||||
|
||||
if (bufSize<RAND_HEAD_LEN)
|
||||
return 0;
|
||||
|
||||
/* First generate RAND_HEAD_LEN-2 random bytes. We encrypt the
|
||||
* output of rand() to get less predictability, since rand() is
|
||||
* often poorly implemented.
|
||||
*/
|
||||
if (++calls == 1)
|
||||
{
|
||||
srand((unsigned)(time(NULL) ^ ZCR_SEED2));
|
||||
}
|
||||
init_keys(passwd, pkeys, pcrc_32_tab);
|
||||
for (n = 0; n < RAND_HEAD_LEN-2; n++)
|
||||
{
|
||||
c = (rand() >> 7) & 0xff;
|
||||
header[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, c, t);
|
||||
}
|
||||
/* Encrypt random header (last two bytes is high word of crc) */
|
||||
init_keys(passwd, pkeys, pcrc_32_tab);
|
||||
for (n = 0; n < RAND_HEAD_LEN-2; n++)
|
||||
{
|
||||
buf[n] = (unsigned char)zencode(pkeys, pcrc_32_tab, header[n], t);
|
||||
}
|
||||
buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 16) & 0xff, t);
|
||||
buf[n++] = zencode(pkeys, pcrc_32_tab, (int)(crcForCrypting >> 24) & 0xff, t);
|
||||
return n;
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
@ -1,177 +0,0 @@
|
|||
/* ioapi.c -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API
|
||||
|
||||
Version 1.00, September 10th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "zlib.h"
|
||||
#include "ioapi.h"
|
||||
|
||||
|
||||
|
||||
/* I've found an old Unix (a SunOS 4.1.3_U1) without all SEEK_* defined.... */
|
||||
|
||||
#ifndef SEEK_CUR
|
||||
#define SEEK_CUR 1
|
||||
#endif
|
||||
|
||||
#ifndef SEEK_END
|
||||
#define SEEK_END 2
|
||||
#endif
|
||||
|
||||
#ifndef SEEK_SET
|
||||
#define SEEK_SET 0
|
||||
#endif
|
||||
|
||||
voidpf ZCALLBACK fopen_file_func OF((
|
||||
voidpf opaque,
|
||||
const char* filename,
|
||||
int mode));
|
||||
|
||||
uLong ZCALLBACK fread_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream,
|
||||
void* buf,
|
||||
uLong size));
|
||||
|
||||
uLong ZCALLBACK fwrite_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream,
|
||||
const void* buf,
|
||||
uLong size));
|
||||
|
||||
long ZCALLBACK ftell_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream));
|
||||
|
||||
long ZCALLBACK fseek_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream,
|
||||
uLong offset,
|
||||
int origin));
|
||||
|
||||
int ZCALLBACK fclose_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream));
|
||||
|
||||
int ZCALLBACK ferror_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream));
|
||||
|
||||
|
||||
voidpf ZCALLBACK fopen_file_func (opaque, filename, mode)
|
||||
voidpf opaque;
|
||||
const char* filename;
|
||||
int mode;
|
||||
{
|
||||
FILE* file = NULL;
|
||||
const char* mode_fopen = NULL;
|
||||
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
|
||||
mode_fopen = "rb";
|
||||
else
|
||||
if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
|
||||
mode_fopen = "r+b";
|
||||
else
|
||||
if (mode & ZLIB_FILEFUNC_MODE_CREATE)
|
||||
mode_fopen = "wb";
|
||||
|
||||
if ((filename!=NULL) && (mode_fopen != NULL))
|
||||
file = fopen(filename, mode_fopen);
|
||||
return file;
|
||||
}
|
||||
|
||||
|
||||
uLong ZCALLBACK fread_file_func (opaque, stream, buf, size)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
void* buf;
|
||||
uLong size;
|
||||
{
|
||||
uLong ret;
|
||||
ret = fread(buf, 1, (size_t)size, (FILE *)stream);
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
uLong ZCALLBACK fwrite_file_func (opaque, stream, buf, size)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
const void* buf;
|
||||
uLong size;
|
||||
{
|
||||
uLong ret;
|
||||
ret = fwrite(buf, 1, (size_t)size, (FILE *)stream);
|
||||
return ret;
|
||||
}
|
||||
|
||||
long ZCALLBACK ftell_file_func (opaque, stream)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
{
|
||||
long ret;
|
||||
ret = ftell((FILE *)stream);
|
||||
return ret;
|
||||
}
|
||||
|
||||
long ZCALLBACK fseek_file_func (opaque, stream, offset, origin)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
uLong offset;
|
||||
int origin;
|
||||
{
|
||||
int fseek_origin=0;
|
||||
long ret;
|
||||
switch (origin)
|
||||
{
|
||||
case ZLIB_FILEFUNC_SEEK_CUR :
|
||||
fseek_origin = SEEK_CUR;
|
||||
break;
|
||||
case ZLIB_FILEFUNC_SEEK_END :
|
||||
fseek_origin = SEEK_END;
|
||||
break;
|
||||
case ZLIB_FILEFUNC_SEEK_SET :
|
||||
fseek_origin = SEEK_SET;
|
||||
break;
|
||||
default: return -1;
|
||||
}
|
||||
ret = 0;
|
||||
fseek((FILE *)stream, offset, fseek_origin);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ZCALLBACK fclose_file_func (opaque, stream)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
{
|
||||
int ret;
|
||||
ret = fclose((FILE *)stream);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ZCALLBACK ferror_file_func (opaque, stream)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
{
|
||||
int ret;
|
||||
ret = ferror((FILE *)stream);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void fill_fopen_filefunc (pzlib_filefunc_def)
|
||||
zlib_filefunc_def* pzlib_filefunc_def;
|
||||
{
|
||||
pzlib_filefunc_def->zopen_file = fopen_file_func;
|
||||
pzlib_filefunc_def->zread_file = fread_file_func;
|
||||
pzlib_filefunc_def->zwrite_file = fwrite_file_func;
|
||||
pzlib_filefunc_def->ztell_file = ftell_file_func;
|
||||
pzlib_filefunc_def->zseek_file = fseek_file_func;
|
||||
pzlib_filefunc_def->zclose_file = fclose_file_func;
|
||||
pzlib_filefunc_def->zerror_file = ferror_file_func;
|
||||
pzlib_filefunc_def->opaque = NULL;
|
||||
}
|
||||
|
|
@ -1,75 +0,0 @@
|
|||
/* ioapi.h -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API
|
||||
|
||||
Version 1.00, September 10th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
*/
|
||||
|
||||
#ifndef _ZLIBIOAPI_H
|
||||
#define _ZLIBIOAPI_H
|
||||
|
||||
|
||||
#define ZLIB_FILEFUNC_SEEK_CUR (1)
|
||||
#define ZLIB_FILEFUNC_SEEK_END (2)
|
||||
#define ZLIB_FILEFUNC_SEEK_SET (0)
|
||||
|
||||
#define ZLIB_FILEFUNC_MODE_READ (1)
|
||||
#define ZLIB_FILEFUNC_MODE_WRITE (2)
|
||||
#define ZLIB_FILEFUNC_MODE_READWRITEFILTER (3)
|
||||
|
||||
#define ZLIB_FILEFUNC_MODE_EXISTING (4)
|
||||
#define ZLIB_FILEFUNC_MODE_CREATE (8)
|
||||
|
||||
|
||||
#ifndef ZCALLBACK
|
||||
|
||||
#if (defined(WIN32) || defined (WINDOWS) || defined (_WINDOWS)) && defined(CALLBACK) && defined (USEWINDOWS_CALLBACK)
|
||||
#define ZCALLBACK CALLBACK
|
||||
#else
|
||||
#define ZCALLBACK
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef voidpf (ZCALLBACK *open_file_func) OF((voidpf opaque, const char* filename, int mode));
|
||||
typedef uLong (ZCALLBACK *read_file_func) OF((voidpf opaque, voidpf stream, void* buf, uLong size));
|
||||
typedef uLong (ZCALLBACK *write_file_func) OF((voidpf opaque, voidpf stream, const void* buf, uLong size));
|
||||
typedef long (ZCALLBACK *tell_file_func) OF((voidpf opaque, voidpf stream));
|
||||
typedef long (ZCALLBACK *seek_file_func) OF((voidpf opaque, voidpf stream, uLong offset, int origin));
|
||||
typedef int (ZCALLBACK *close_file_func) OF((voidpf opaque, voidpf stream));
|
||||
typedef int (ZCALLBACK *testerror_file_func) OF((voidpf opaque, voidpf stream));
|
||||
|
||||
typedef struct zlib_filefunc_def_s
|
||||
{
|
||||
open_file_func zopen_file;
|
||||
read_file_func zread_file;
|
||||
write_file_func zwrite_file;
|
||||
tell_file_func ztell_file;
|
||||
seek_file_func zseek_file;
|
||||
close_file_func zclose_file;
|
||||
testerror_file_func zerror_file;
|
||||
voidpf opaque;
|
||||
} zlib_filefunc_def;
|
||||
|
||||
|
||||
|
||||
void fill_fopen_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
|
||||
|
||||
#define ZREAD(filefunc,filestream,buf,size) ((*((filefunc).zread_file))((filefunc).opaque,filestream,buf,size))
|
||||
#define ZWRITE(filefunc,filestream,buf,size) ((*((filefunc).zwrite_file))((filefunc).opaque,filestream,buf,size))
|
||||
#define ZTELL(filefunc,filestream) ((*((filefunc).ztell_file))((filefunc).opaque,filestream))
|
||||
#define ZSEEK(filefunc,filestream,pos,mode) ((*((filefunc).zseek_file))((filefunc).opaque,filestream,pos,mode))
|
||||
#define ZCLOSE(filefunc,filestream) ((*((filefunc).zclose_file))((filefunc).opaque,filestream))
|
||||
#define ZERROR(filefunc,filestream) ((*((filefunc).zerror_file))((filefunc).opaque,filestream))
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
|
@ -1,270 +0,0 @@
|
|||
/* iowin32.c -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API
|
||||
This IO API version uses the Win32 API (for Microsoft Windows)
|
||||
|
||||
Version 1.00, September 10th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
#include "zlib.h"
|
||||
#include "ioapi.h"
|
||||
#include "iowin32.h"
|
||||
|
||||
#ifndef INVALID_HANDLE_VALUE
|
||||
#define INVALID_HANDLE_VALUE (0xFFFFFFFF)
|
||||
#endif
|
||||
|
||||
#ifndef INVALID_SET_FILE_POINTER
|
||||
#define INVALID_SET_FILE_POINTER ((DWORD)-1)
|
||||
#endif
|
||||
|
||||
voidpf ZCALLBACK win32_open_file_func OF((
|
||||
voidpf opaque,
|
||||
const char* filename,
|
||||
int mode));
|
||||
|
||||
uLong ZCALLBACK win32_read_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream,
|
||||
void* buf,
|
||||
uLong size));
|
||||
|
||||
uLong ZCALLBACK win32_write_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream,
|
||||
const void* buf,
|
||||
uLong size));
|
||||
|
||||
long ZCALLBACK win32_tell_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream));
|
||||
|
||||
long ZCALLBACK win32_seek_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream,
|
||||
uLong offset,
|
||||
int origin));
|
||||
|
||||
int ZCALLBACK win32_close_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream));
|
||||
|
||||
int ZCALLBACK win32_error_file_func OF((
|
||||
voidpf opaque,
|
||||
voidpf stream));
|
||||
|
||||
typedef struct
|
||||
{
|
||||
HANDLE hf;
|
||||
int error;
|
||||
} WIN32FILE_IOWIN;
|
||||
|
||||
voidpf ZCALLBACK win32_open_file_func (opaque, filename, mode)
|
||||
voidpf opaque;
|
||||
const char* filename;
|
||||
int mode;
|
||||
{
|
||||
const char* mode_fopen = NULL;
|
||||
DWORD dwDesiredAccess,dwCreationDisposition,dwShareMode,dwFlagsAndAttributes ;
|
||||
HANDLE hFile = 0;
|
||||
voidpf ret=NULL;
|
||||
|
||||
dwDesiredAccess = dwShareMode = dwFlagsAndAttributes = 0;
|
||||
|
||||
if ((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ)
|
||||
{
|
||||
dwDesiredAccess = GENERIC_READ;
|
||||
dwCreationDisposition = OPEN_EXISTING;
|
||||
dwShareMode = FILE_SHARE_READ;
|
||||
}
|
||||
else
|
||||
if (mode & ZLIB_FILEFUNC_MODE_EXISTING)
|
||||
{
|
||||
dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
|
||||
dwCreationDisposition = OPEN_EXISTING;
|
||||
}
|
||||
else
|
||||
if (mode & ZLIB_FILEFUNC_MODE_CREATE)
|
||||
{
|
||||
dwDesiredAccess = GENERIC_WRITE | GENERIC_READ;
|
||||
dwCreationDisposition = CREATE_ALWAYS;
|
||||
}
|
||||
|
||||
if ((filename!=NULL) && (dwDesiredAccess != 0))
|
||||
hFile = CreateFile((LPCTSTR)filename, dwDesiredAccess, dwShareMode, NULL,
|
||||
dwCreationDisposition, dwFlagsAndAttributes, NULL);
|
||||
|
||||
if (hFile == INVALID_HANDLE_VALUE)
|
||||
hFile = NULL;
|
||||
|
||||
if (hFile != NULL)
|
||||
{
|
||||
WIN32FILE_IOWIN w32fiow;
|
||||
w32fiow.hf = hFile;
|
||||
w32fiow.error = 0;
|
||||
ret = malloc(sizeof(WIN32FILE_IOWIN));
|
||||
if (ret==NULL)
|
||||
CloseHandle(hFile);
|
||||
else *((WIN32FILE_IOWIN*)ret) = w32fiow;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
uLong ZCALLBACK win32_read_file_func (opaque, stream, buf, size)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
void* buf;
|
||||
uLong size;
|
||||
{
|
||||
uLong ret=0;
|
||||
HANDLE hFile = NULL;
|
||||
if (stream!=NULL)
|
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
|
||||
if (hFile != NULL)
|
||||
if (!ReadFile(hFile, buf, size, &ret, NULL))
|
||||
{
|
||||
DWORD dwErr = GetLastError();
|
||||
if (dwErr == ERROR_HANDLE_EOF)
|
||||
dwErr = 0;
|
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
||||
uLong ZCALLBACK win32_write_file_func (opaque, stream, buf, size)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
const void* buf;
|
||||
uLong size;
|
||||
{
|
||||
uLong ret=0;
|
||||
HANDLE hFile = NULL;
|
||||
if (stream!=NULL)
|
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
|
||||
|
||||
if (hFile !=NULL)
|
||||
if (!WriteFile(hFile, buf, size, &ret, NULL))
|
||||
{
|
||||
DWORD dwErr = GetLastError();
|
||||
if (dwErr == ERROR_HANDLE_EOF)
|
||||
dwErr = 0;
|
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
long ZCALLBACK win32_tell_file_func (opaque, stream)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
{
|
||||
long ret=-1;
|
||||
HANDLE hFile = NULL;
|
||||
if (stream!=NULL)
|
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
|
||||
if (hFile != NULL)
|
||||
{
|
||||
DWORD dwSet = SetFilePointer(hFile, 0, NULL, FILE_CURRENT);
|
||||
if (dwSet == INVALID_SET_FILE_POINTER)
|
||||
{
|
||||
DWORD dwErr = GetLastError();
|
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
|
||||
ret = -1;
|
||||
}
|
||||
else
|
||||
ret=(long)dwSet;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
long ZCALLBACK win32_seek_file_func (opaque, stream, offset, origin)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
uLong offset;
|
||||
int origin;
|
||||
{
|
||||
DWORD dwMoveMethod=0xFFFFFFFF;
|
||||
HANDLE hFile = NULL;
|
||||
|
||||
long ret=-1;
|
||||
if (stream!=NULL)
|
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
|
||||
switch (origin)
|
||||
{
|
||||
case ZLIB_FILEFUNC_SEEK_CUR :
|
||||
dwMoveMethod = FILE_CURRENT;
|
||||
break;
|
||||
case ZLIB_FILEFUNC_SEEK_END :
|
||||
dwMoveMethod = FILE_END;
|
||||
break;
|
||||
case ZLIB_FILEFUNC_SEEK_SET :
|
||||
dwMoveMethod = FILE_BEGIN;
|
||||
break;
|
||||
default: return -1;
|
||||
}
|
||||
|
||||
if (hFile != NULL)
|
||||
{
|
||||
DWORD dwSet = SetFilePointer(hFile, offset, NULL, dwMoveMethod);
|
||||
if (dwSet == INVALID_SET_FILE_POINTER)
|
||||
{
|
||||
DWORD dwErr = GetLastError();
|
||||
((WIN32FILE_IOWIN*)stream) -> error=(int)dwErr;
|
||||
ret = -1;
|
||||
}
|
||||
else
|
||||
ret=0;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ZCALLBACK win32_close_file_func (opaque, stream)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
{
|
||||
int ret=-1;
|
||||
|
||||
if (stream!=NULL)
|
||||
{
|
||||
HANDLE hFile;
|
||||
hFile = ((WIN32FILE_IOWIN*)stream) -> hf;
|
||||
if (hFile != NULL)
|
||||
{
|
||||
CloseHandle(hFile);
|
||||
ret=0;
|
||||
}
|
||||
free(stream);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int ZCALLBACK win32_error_file_func (opaque, stream)
|
||||
voidpf opaque;
|
||||
voidpf stream;
|
||||
{
|
||||
int ret=-1;
|
||||
if (stream!=NULL)
|
||||
{
|
||||
ret = ((WIN32FILE_IOWIN*)stream) -> error;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
void fill_win32_filefunc (pzlib_filefunc_def)
|
||||
zlib_filefunc_def* pzlib_filefunc_def;
|
||||
{
|
||||
pzlib_filefunc_def->zopen_file = win32_open_file_func;
|
||||
pzlib_filefunc_def->zread_file = win32_read_file_func;
|
||||
pzlib_filefunc_def->zwrite_file = win32_write_file_func;
|
||||
pzlib_filefunc_def->ztell_file = win32_tell_file_func;
|
||||
pzlib_filefunc_def->zseek_file = win32_seek_file_func;
|
||||
pzlib_filefunc_def->zclose_file = win32_close_file_func;
|
||||
pzlib_filefunc_def->zerror_file = win32_error_file_func;
|
||||
pzlib_filefunc_def->opaque=NULL;
|
||||
}
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
/* iowin32.h -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API
|
||||
This IO API version uses the Win32 API (for Microsoft Windows)
|
||||
|
||||
Version 1.00, September 10th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
*/
|
||||
|
||||
#include <windows.h>
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
void fill_win32_filefunc OF((zlib_filefunc_def* pzlib_filefunc_def));
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,556 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
#ifdef unix
|
||||
# include <unistd.h>
|
||||
# include <utime.h>
|
||||
#else
|
||||
# include <direct.h>
|
||||
# include <io.h>
|
||||
#endif
|
||||
|
||||
#include "unzip.h"
|
||||
|
||||
#define CASESENSITIVITY (0)
|
||||
#define WRITEBUFFERSIZE (8192)
|
||||
#define MAXFILENAME (256)
|
||||
|
||||
#ifdef WIN32
|
||||
#define USEWIN32IOAPI
|
||||
#include "iowin32.h"
|
||||
#endif
|
||||
/*
|
||||
mini unzip, demo of unzip package
|
||||
|
||||
usage :
|
||||
Usage : miniunz [-exvlo] file.zip [file_to_extract]
|
||||
|
||||
list the file in the zipfile, and print the content of FILE_ID.ZIP or README.TXT
|
||||
if it exists
|
||||
*/
|
||||
|
||||
|
||||
/* change_file_date : change the date/time of a file
|
||||
filename : the filename of the file where date/time must be modified
|
||||
dosdate : the new date at the MSDos format (4 bytes)
|
||||
tmu_date : the SAME new date at the tm_unz format */
|
||||
void change_file_date(filename,dosdate,tmu_date)
|
||||
const char *filename;
|
||||
uLong dosdate;
|
||||
tm_unz tmu_date;
|
||||
{
|
||||
#ifdef WIN32
|
||||
HANDLE hFile;
|
||||
FILETIME ftm,ftLocal,ftCreate,ftLastAcc,ftLastWrite;
|
||||
|
||||
hFile = CreateFile(filename,GENERIC_READ | GENERIC_WRITE,
|
||||
0,NULL,OPEN_EXISTING,0,NULL);
|
||||
GetFileTime(hFile,&ftCreate,&ftLastAcc,&ftLastWrite);
|
||||
DosDateTimeToFileTime((WORD)(dosdate>>16),(WORD)dosdate,&ftLocal);
|
||||
LocalFileTimeToFileTime(&ftLocal,&ftm);
|
||||
SetFileTime(hFile,&ftm,&ftLastAcc,&ftm);
|
||||
CloseHandle(hFile);
|
||||
#else
|
||||
#ifdef unix
|
||||
struct utimbuf ut;
|
||||
struct tm newdate;
|
||||
newdate.tm_sec = tmu_date.tm_sec;
|
||||
newdate.tm_min=tmu_date.tm_min;
|
||||
newdate.tm_hour=tmu_date.tm_hour;
|
||||
newdate.tm_mday=tmu_date.tm_mday;
|
||||
newdate.tm_mon=tmu_date.tm_mon;
|
||||
if (tmu_date.tm_year > 1900)
|
||||
newdate.tm_year=tmu_date.tm_year - 1900;
|
||||
else
|
||||
newdate.tm_year=tmu_date.tm_year ;
|
||||
newdate.tm_isdst=-1;
|
||||
|
||||
ut.actime=ut.modtime=mktime(&newdate);
|
||||
utime(filename,&ut);
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/* mymkdir and change_file_date are not 100 % portable
|
||||
As I don't know well Unix, I wait feedback for the unix portion */
|
||||
|
||||
int mymkdir(dirname)
|
||||
const char* dirname;
|
||||
{
|
||||
int ret=0;
|
||||
#ifdef WIN32
|
||||
ret = mkdir(dirname);
|
||||
#else
|
||||
#ifdef unix
|
||||
ret = mkdir (dirname,0775);
|
||||
#endif
|
||||
#endif
|
||||
return ret;
|
||||
}
|
||||
|
||||
int makedir (newdir)
|
||||
char *newdir;
|
||||
{
|
||||
char *buffer ;
|
||||
char *p;
|
||||
int len = (int)strlen(newdir);
|
||||
|
||||
if (len <= 0)
|
||||
return 0;
|
||||
|
||||
buffer = (char*)malloc(len+1);
|
||||
strcpy(buffer,newdir);
|
||||
|
||||
if (buffer[len-1] == '/') {
|
||||
buffer[len-1] = '\0';
|
||||
}
|
||||
if (mymkdir(buffer) == 0)
|
||||
{
|
||||
free(buffer);
|
||||
return 1;
|
||||
}
|
||||
|
||||
p = buffer+1;
|
||||
while (1)
|
||||
{
|
||||
char hold;
|
||||
|
||||
while(*p && *p != '\\' && *p != '/')
|
||||
p++;
|
||||
hold = *p;
|
||||
*p = 0;
|
||||
if ((mymkdir(buffer) == -1) && (errno == ENOENT))
|
||||
{
|
||||
printf("couldn't create directory %s\n",buffer);
|
||||
free(buffer);
|
||||
return 0;
|
||||
}
|
||||
if (hold == 0)
|
||||
break;
|
||||
*p++ = hold;
|
||||
}
|
||||
free(buffer);
|
||||
return 1;
|
||||
}
|
||||
|
||||
void do_banner()
|
||||
{
|
||||
printf("MiniUnz 1.00, demo of zLib + Unz package written by Gilles Vollant\n");
|
||||
printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n");
|
||||
}
|
||||
|
||||
void do_help()
|
||||
{
|
||||
printf("Usage : miniunz [-e] [-x] [-v] [-l] [-o] [-p password] file.zip [file_to_extr.]\n\n" \
|
||||
" -e Extract without pathname (junk paths)\n" \
|
||||
" -x Extract with pathname\n" \
|
||||
" -v list files\n" \
|
||||
" -l list files\n" \
|
||||
" -o overwrite files without prompting\n" \
|
||||
" -p extract crypted file using password\n\n");
|
||||
}
|
||||
|
||||
|
||||
int do_list(uf)
|
||||
unzFile uf;
|
||||
{
|
||||
uLong i;
|
||||
unz_global_info gi;
|
||||
int err;
|
||||
|
||||
err = unzGetGlobalInfo (uf,&gi);
|
||||
if (err!=UNZ_OK)
|
||||
printf("error %d with zipfile in unzGetGlobalInfo \n",err);
|
||||
printf(" Length Method Size Ratio Date Time CRC-32 Name\n");
|
||||
printf(" ------ ------ ---- ----- ---- ---- ------ ----\n");
|
||||
for (i=0;i<gi.number_entry;i++)
|
||||
{
|
||||
char filename_inzip[256];
|
||||
unz_file_info file_info;
|
||||
uLong ratio=0;
|
||||
const char *string_method;
|
||||
char charCrypt=' ';
|
||||
err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
|
||||
if (err!=UNZ_OK)
|
||||
{
|
||||
printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
|
||||
break;
|
||||
}
|
||||
if (file_info.uncompressed_size>0)
|
||||
ratio = (file_info.compressed_size*100)/file_info.uncompressed_size;
|
||||
|
||||
/* display a '*' if the file is crypted */
|
||||
if ((file_info.flag & 1) != 0)
|
||||
charCrypt='*';
|
||||
|
||||
if (file_info.compression_method==0)
|
||||
string_method="Stored";
|
||||
else
|
||||
if (file_info.compression_method==Z_DEFLATED)
|
||||
{
|
||||
uInt iLevel=(uInt)((file_info.flag & 0x6)/2);
|
||||
if (iLevel==0)
|
||||
string_method="Defl:N";
|
||||
else if (iLevel==1)
|
||||
string_method="Defl:X";
|
||||
else if ((iLevel==2) || (iLevel==3))
|
||||
string_method="Defl:F"; /* 2:fast , 3 : extra fast*/
|
||||
}
|
||||
else
|
||||
string_method="Unkn. ";
|
||||
|
||||
printf("%7lu %6s%c%7lu %3lu%% %2.2lu-%2.2lu-%2.2lu %2.2lu:%2.2lu %8.8lx %s\n",
|
||||
file_info.uncompressed_size,string_method,
|
||||
charCrypt,
|
||||
file_info.compressed_size,
|
||||
ratio,
|
||||
(uLong)file_info.tmu_date.tm_mon + 1,
|
||||
(uLong)file_info.tmu_date.tm_mday,
|
||||
(uLong)file_info.tmu_date.tm_year % 100,
|
||||
(uLong)file_info.tmu_date.tm_hour,(uLong)file_info.tmu_date.tm_min,
|
||||
(uLong)file_info.crc,filename_inzip);
|
||||
if ((i+1)<gi.number_entry)
|
||||
{
|
||||
err = unzGoToNextFile(uf);
|
||||
if (err!=UNZ_OK)
|
||||
{
|
||||
printf("error %d with zipfile in unzGoToNextFile\n",err);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int do_extract_currentfile(uf,popt_extract_without_path,popt_overwrite,password)
|
||||
unzFile uf;
|
||||
const int* popt_extract_without_path;
|
||||
int* popt_overwrite;
|
||||
const char* password;
|
||||
{
|
||||
char filename_inzip[256];
|
||||
char* filename_withoutpath;
|
||||
char* p;
|
||||
int err=UNZ_OK;
|
||||
FILE *fout=NULL;
|
||||
void* buf;
|
||||
uInt size_buf;
|
||||
|
||||
unz_file_info file_info;
|
||||
uLong ratio=0;
|
||||
err = unzGetCurrentFileInfo(uf,&file_info,filename_inzip,sizeof(filename_inzip),NULL,0,NULL,0);
|
||||
|
||||
if (err!=UNZ_OK)
|
||||
{
|
||||
printf("error %d with zipfile in unzGetCurrentFileInfo\n",err);
|
||||
return err;
|
||||
}
|
||||
|
||||
size_buf = WRITEBUFFERSIZE;
|
||||
buf = (void*)malloc(size_buf);
|
||||
if (buf==NULL)
|
||||
{
|
||||
printf("Error allocating memory\n");
|
||||
return UNZ_INTERNALERROR;
|
||||
}
|
||||
|
||||
p = filename_withoutpath = filename_inzip;
|
||||
while ((*p) != '\0')
|
||||
{
|
||||
if (((*p)=='/') || ((*p)=='\\'))
|
||||
filename_withoutpath = p+1;
|
||||
p++;
|
||||
}
|
||||
|
||||
if ((*filename_withoutpath)=='\0')
|
||||
{
|
||||
if ((*popt_extract_without_path)==0)
|
||||
{
|
||||
printf("creating directory: %s\n",filename_inzip);
|
||||
mymkdir(filename_inzip);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
const char* write_filename;
|
||||
int skip=0;
|
||||
|
||||
if ((*popt_extract_without_path)==0)
|
||||
write_filename = filename_inzip;
|
||||
else
|
||||
write_filename = filename_withoutpath;
|
||||
|
||||
err = unzOpenCurrentFilePassword(uf,password);
|
||||
if (err!=UNZ_OK)
|
||||
{
|
||||
printf("error %d with zipfile in unzOpenCurrentFilePassword\n",err);
|
||||
}
|
||||
|
||||
if (((*popt_overwrite)==0) && (err==UNZ_OK))
|
||||
{
|
||||
char rep=0;
|
||||
FILE* ftestexist;
|
||||
ftestexist = fopen(write_filename,"rb");
|
||||
if (ftestexist!=NULL)
|
||||
{
|
||||
fclose(ftestexist);
|
||||
do
|
||||
{
|
||||
char answer[128];
|
||||
printf("The file %s exist. Overwrite ? [y]es, [n]o, [A]ll: ",write_filename);
|
||||
scanf("%1s",answer);
|
||||
rep = answer[0] ;
|
||||
if ((rep>='a') && (rep<='z'))
|
||||
rep -= 0x20;
|
||||
}
|
||||
while ((rep!='Y') && (rep!='N') && (rep!='A'));
|
||||
}
|
||||
|
||||
if (rep == 'N')
|
||||
skip = 1;
|
||||
|
||||
if (rep == 'A')
|
||||
*popt_overwrite=1;
|
||||
}
|
||||
|
||||
if ((skip==0) && (err==UNZ_OK))
|
||||
{
|
||||
fout=fopen(write_filename,"wb");
|
||||
|
||||
/* some zipfile don't contain directory alone before file */
|
||||
if ((fout==NULL) && ((*popt_extract_without_path)==0) &&
|
||||
(filename_withoutpath!=(char*)filename_inzip))
|
||||
{
|
||||
char c=*(filename_withoutpath-1);
|
||||
*(filename_withoutpath-1)='\0';
|
||||
makedir(write_filename);
|
||||
*(filename_withoutpath-1)=c;
|
||||
fout=fopen(write_filename,"wb");
|
||||
}
|
||||
|
||||
if (fout==NULL)
|
||||
{
|
||||
printf("error opening %s\n",write_filename);
|
||||
}
|
||||
}
|
||||
|
||||
if (fout!=NULL)
|
||||
{
|
||||
printf(" extracting: %s\n",write_filename);
|
||||
|
||||
do
|
||||
{
|
||||
err = unzReadCurrentFile(uf,buf,size_buf);
|
||||
if (err<0)
|
||||
{
|
||||
printf("error %d with zipfile in unzReadCurrentFile\n",err);
|
||||
break;
|
||||
}
|
||||
if (err>0)
|
||||
if (fwrite(buf,err,1,fout)!=1)
|
||||
{
|
||||
printf("error in writing extracted file\n");
|
||||
err=UNZ_ERRNO;
|
||||
break;
|
||||
}
|
||||
}
|
||||
while (err>0);
|
||||
if (fout)
|
||||
fclose(fout);
|
||||
|
||||
if (err==0)
|
||||
change_file_date(write_filename,file_info.dosDate,
|
||||
file_info.tmu_date);
|
||||
}
|
||||
|
||||
if (err==UNZ_OK)
|
||||
{
|
||||
err = unzCloseCurrentFile (uf);
|
||||
if (err!=UNZ_OK)
|
||||
{
|
||||
printf("error %d with zipfile in unzCloseCurrentFile\n",err);
|
||||
}
|
||||
}
|
||||
else
|
||||
unzCloseCurrentFile(uf); /* don't lose the error */
|
||||
}
|
||||
|
||||
free(buf);
|
||||
return err;
|
||||
}
|
||||
|
||||
|
||||
int do_extract(uf,opt_extract_without_path,opt_overwrite,password)
|
||||
unzFile uf;
|
||||
int opt_extract_without_path;
|
||||
int opt_overwrite;
|
||||
const char* password;
|
||||
{
|
||||
uLong i;
|
||||
unz_global_info gi;
|
||||
int err;
|
||||
FILE* fout=NULL;
|
||||
|
||||
err = unzGetGlobalInfo (uf,&gi);
|
||||
if (err!=UNZ_OK)
|
||||
printf("error %d with zipfile in unzGetGlobalInfo \n",err);
|
||||
|
||||
for (i=0;i<gi.number_entry;i++)
|
||||
{
|
||||
if (do_extract_currentfile(uf,&opt_extract_without_path,
|
||||
&opt_overwrite,
|
||||
password) != UNZ_OK)
|
||||
break;
|
||||
|
||||
if ((i+1)<gi.number_entry)
|
||||
{
|
||||
err = unzGoToNextFile(uf);
|
||||
if (err!=UNZ_OK)
|
||||
{
|
||||
printf("error %d with zipfile in unzGoToNextFile\n",err);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int do_extract_onefile(uf,filename,opt_extract_without_path,opt_overwrite,password)
|
||||
unzFile uf;
|
||||
const char* filename;
|
||||
int opt_extract_without_path;
|
||||
int opt_overwrite;
|
||||
const char* password;
|
||||
{
|
||||
int err = UNZ_OK;
|
||||
if (unzLocateFile(uf,filename,CASESENSITIVITY)!=UNZ_OK)
|
||||
{
|
||||
printf("file %s not found in the zipfile\n",filename);
|
||||
return 2;
|
||||
}
|
||||
|
||||
if (do_extract_currentfile(uf,&opt_extract_without_path,
|
||||
&opt_overwrite,
|
||||
password) == UNZ_OK)
|
||||
return 0;
|
||||
else
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int main(argc,argv)
|
||||
int argc;
|
||||
char *argv[];
|
||||
{
|
||||
const char *zipfilename=NULL;
|
||||
const char *filename_to_extract=NULL;
|
||||
const char *password=NULL;
|
||||
char filename_try[MAXFILENAME+16] = "";
|
||||
int i;
|
||||
int opt_do_list=0;
|
||||
int opt_do_extract=1;
|
||||
int opt_do_extract_withoutpath=0;
|
||||
int opt_overwrite=0;
|
||||
unzFile uf=NULL;
|
||||
|
||||
do_banner();
|
||||
if (argc==1)
|
||||
{
|
||||
do_help();
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i=1;i<argc;i++)
|
||||
{
|
||||
if ((*argv[i])=='-')
|
||||
{
|
||||
const char *p=argv[i]+1;
|
||||
|
||||
while ((*p)!='\0')
|
||||
{
|
||||
char c=*(p++);;
|
||||
if ((c=='l') || (c=='L'))
|
||||
opt_do_list = 1;
|
||||
if ((c=='v') || (c=='V'))
|
||||
opt_do_list = 1;
|
||||
if ((c=='x') || (c=='X'))
|
||||
opt_do_extract = 1;
|
||||
if ((c=='e') || (c=='E'))
|
||||
opt_do_extract = opt_do_extract_withoutpath = 1;
|
||||
if ((c=='o') || (c=='O'))
|
||||
opt_overwrite=1;
|
||||
if (((c=='p') || (c=='P')) && (i+1<argc))
|
||||
{
|
||||
password=argv[i+1];
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (zipfilename == NULL)
|
||||
zipfilename = argv[i];
|
||||
else if (filename_to_extract==NULL)
|
||||
filename_to_extract = argv[i] ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (zipfilename!=NULL)
|
||||
{
|
||||
|
||||
# ifdef USEWIN32IOAPI
|
||||
zlib_filefunc_def ffunc;
|
||||
# endif
|
||||
|
||||
strncpy(filename_try, zipfilename,MAXFILENAME-1);
|
||||
/* strncpy doesnt append the trailing NULL, of the string is too long. */
|
||||
filename_try[ MAXFILENAME ] = '\0';
|
||||
|
||||
# ifdef USEWIN32IOAPI
|
||||
fill_win32_filefunc(&ffunc);
|
||||
uf = unzOpen2(zipfilename,&ffunc);
|
||||
# else
|
||||
uf = unzOpen(zipfilename);
|
||||
# endif
|
||||
if (uf==NULL)
|
||||
{
|
||||
strcat(filename_try,".zip");
|
||||
# ifdef USEWIN32IOAPI
|
||||
uf = unzOpen2(filename_try,&ffunc);
|
||||
# else
|
||||
uf = unzOpen(filename_try);
|
||||
# endif
|
||||
}
|
||||
}
|
||||
|
||||
if (uf==NULL)
|
||||
{
|
||||
printf("Cannot open %s or %s.zip\n",zipfilename,zipfilename);
|
||||
return 1;
|
||||
}
|
||||
printf("%s opened\n",filename_try);
|
||||
|
||||
if (opt_do_list==1)
|
||||
return do_list(uf);
|
||||
else if (opt_do_extract==1)
|
||||
{
|
||||
if (filename_to_extract == NULL)
|
||||
return do_extract(uf,opt_do_extract_withoutpath,opt_overwrite,password);
|
||||
else
|
||||
return do_extract_onefile(uf,filename_to_extract,
|
||||
opt_do_extract_withoutpath,opt_overwrite,password);
|
||||
}
|
||||
unzCloseCurrentFile(uf);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,397 +0,0 @@
|
|||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <errno.h>
|
||||
#include <fcntl.h>
|
||||
|
||||
#ifdef unix
|
||||
# include <unistd.h>
|
||||
# include <utime.h>
|
||||
# include <sys/types.h>
|
||||
# include <sys/stat.h>
|
||||
#else
|
||||
# include <direct.h>
|
||||
# include <io.h>
|
||||
#endif
|
||||
|
||||
#include "zip.h"
|
||||
|
||||
#ifdef WIN32
|
||||
#define USEWIN32IOAPI
|
||||
#include "iowin32.h"
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
#define WRITEBUFFERSIZE (16384)
|
||||
#define MAXFILENAME (256)
|
||||
|
||||
#ifdef WIN32
|
||||
uLong filetime(f, tmzip, dt)
|
||||
char *f; /* name of file to get info on */
|
||||
tm_zip *tmzip; /* return value: access, modific. and creation times */
|
||||
uLong *dt; /* dostime */
|
||||
{
|
||||
int ret = 0;
|
||||
{
|
||||
FILETIME ftLocal;
|
||||
HANDLE hFind;
|
||||
WIN32_FIND_DATA ff32;
|
||||
|
||||
hFind = FindFirstFile(f,&ff32);
|
||||
if (hFind != INVALID_HANDLE_VALUE)
|
||||
{
|
||||
FileTimeToLocalFileTime(&(ff32.ftLastWriteTime),&ftLocal);
|
||||
FileTimeToDosDateTime(&ftLocal,((LPWORD)dt)+1,((LPWORD)dt)+0);
|
||||
FindClose(hFind);
|
||||
ret = 1;
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
#else
|
||||
#ifdef unix
|
||||
uLong filetime(f, tmzip, dt)
|
||||
char *f; /* name of file to get info on */
|
||||
tm_zip *tmzip; /* return value: access, modific. and creation times */
|
||||
uLong *dt; /* dostime */
|
||||
{
|
||||
int ret=0;
|
||||
struct stat s; /* results of stat() */
|
||||
struct tm* filedate;
|
||||
time_t tm_t=0;
|
||||
|
||||
if (strcmp(f,"-")!=0)
|
||||
{
|
||||
char name[MAXFILENAME+1];
|
||||
int len = strlen(f);
|
||||
|
||||
strncpy(name, f,MAXFILENAME-1);
|
||||
/* strncpy doesnt append the trailing NULL, of the string is too long. */
|
||||
name[ MAXFILENAME ] = '\0';
|
||||
|
||||
if (name[len - 1] == '/')
|
||||
name[len - 1] = '\0';
|
||||
/* not all systems allow stat'ing a file with / appended */
|
||||
if (stat(name,&s)==0)
|
||||
{
|
||||
tm_t = s.st_mtime;
|
||||
ret = 1;
|
||||
}
|
||||
}
|
||||
filedate = localtime(&tm_t);
|
||||
|
||||
tmzip->tm_sec = filedate->tm_sec;
|
||||
tmzip->tm_min = filedate->tm_min;
|
||||
tmzip->tm_hour = filedate->tm_hour;
|
||||
tmzip->tm_mday = filedate->tm_mday;
|
||||
tmzip->tm_mon = filedate->tm_mon ;
|
||||
tmzip->tm_year = filedate->tm_year;
|
||||
|
||||
return ret;
|
||||
}
|
||||
#else
|
||||
uLong filetime(f, tmzip, dt)
|
||||
char *f; /* name of file to get info on */
|
||||
tm_zip *tmzip; /* return value: access, modific. and creation times */
|
||||
uLong *dt; /* dostime */
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
|
||||
int check_exist_file(filename)
|
||||
const char* filename;
|
||||
{
|
||||
FILE* ftestexist;
|
||||
int ret = 1;
|
||||
ftestexist = fopen(filename,"rb");
|
||||
if (ftestexist==NULL)
|
||||
ret = 0;
|
||||
else
|
||||
fclose(ftestexist);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void do_banner()
|
||||
{
|
||||
printf("MiniZip 1.00, demo of zLib + Zip package written by Gilles Vollant\n");
|
||||
printf("more info at http://www.winimage.com/zLibDll/unzip.html\n\n");
|
||||
}
|
||||
|
||||
void do_help()
|
||||
{
|
||||
printf("Usage : minizip [-o] [-a] [-0 to -9] [-p password] file.zip [files_to_add]\n\n" \
|
||||
" -o Overwrite existing file.zip\n" \
|
||||
" -a Append to existing file.zip\n" \
|
||||
" -0 Store only\n" \
|
||||
" -1 Compress faster\n" \
|
||||
" -9 Compress better\n\n");
|
||||
}
|
||||
|
||||
/* calculate the CRC32 of a file,
|
||||
because to encrypt a file, we need known the CRC32 of the file before */
|
||||
int getFileCrc(const char* filenameinzip,void*buf,unsigned long size_buf,unsigned long* result_crc)
|
||||
{
|
||||
unsigned long calculate_crc=0;
|
||||
int err=ZIP_OK;
|
||||
FILE * fin = fopen(filenameinzip,"rb");
|
||||
unsigned long size_read = 0;
|
||||
unsigned long total_read = 0;
|
||||
if (fin==NULL)
|
||||
{
|
||||
err = ZIP_ERRNO;
|
||||
}
|
||||
|
||||
if (err == ZIP_OK)
|
||||
do
|
||||
{
|
||||
err = ZIP_OK;
|
||||
size_read = (int)fread(buf,1,size_buf,fin);
|
||||
if (size_read < size_buf)
|
||||
if (feof(fin)==0)
|
||||
{
|
||||
printf("error in reading %s\n",filenameinzip);
|
||||
err = ZIP_ERRNO;
|
||||
}
|
||||
|
||||
if (size_read>0)
|
||||
calculate_crc = crc32(calculate_crc,buf,size_read);
|
||||
total_read += size_read;
|
||||
|
||||
} while ((err == ZIP_OK) && (size_read>0));
|
||||
|
||||
if (fin)
|
||||
fclose(fin);
|
||||
|
||||
*result_crc=calculate_crc;
|
||||
printf("file %s crc %x\n",filenameinzip,calculate_crc);
|
||||
return err;
|
||||
}
|
||||
|
||||
int main(argc,argv)
|
||||
int argc;
|
||||
char *argv[];
|
||||
{
|
||||
int i;
|
||||
int opt_overwrite=0;
|
||||
int opt_compress_level=Z_DEFAULT_COMPRESSION;
|
||||
int zipfilenamearg = 0;
|
||||
char filename_try[MAXFILENAME+16];
|
||||
int zipok;
|
||||
int err=0;
|
||||
int size_buf=0;
|
||||
void* buf=NULL;
|
||||
const char* password=NULL;
|
||||
|
||||
|
||||
do_banner();
|
||||
if (argc==1)
|
||||
{
|
||||
do_help();
|
||||
return 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
for (i=1;i<argc;i++)
|
||||
{
|
||||
if ((*argv[i])=='-')
|
||||
{
|
||||
const char *p=argv[i]+1;
|
||||
|
||||
while ((*p)!='\0')
|
||||
{
|
||||
char c=*(p++);;
|
||||
if ((c=='o') || (c=='O'))
|
||||
opt_overwrite = 1;
|
||||
if ((c=='a') || (c=='A'))
|
||||
opt_overwrite = 2;
|
||||
if ((c>='0') && (c<='9'))
|
||||
opt_compress_level = c-'0';
|
||||
|
||||
if (((c=='p') || (c=='P')) && (i+1<argc))
|
||||
{
|
||||
password=argv[i+1];
|
||||
i++;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
if (zipfilenamearg == 0)
|
||||
zipfilenamearg = i ;
|
||||
}
|
||||
}
|
||||
|
||||
size_buf = WRITEBUFFERSIZE;
|
||||
buf = (void*)malloc(size_buf);
|
||||
if (buf==NULL)
|
||||
{
|
||||
printf("Error allocating memory\n");
|
||||
return ZIP_INTERNALERROR;
|
||||
}
|
||||
|
||||
if (zipfilenamearg==0)
|
||||
zipok=0;
|
||||
else
|
||||
{
|
||||
int i,len;
|
||||
int dot_found=0;
|
||||
|
||||
zipok = 1 ;
|
||||
strncpy(filename_try, argv[zipfilenamearg],MAXFILENAME-1);
|
||||
/* strncpy doesnt append the trailing NULL, of the string is too long. */
|
||||
filename_try[ MAXFILENAME ] = '\0';
|
||||
|
||||
len=(int)strlen(filename_try);
|
||||
for (i=0;i<len;i++)
|
||||
if (filename_try[i]=='.')
|
||||
dot_found=1;
|
||||
|
||||
if (dot_found==0)
|
||||
strcat(filename_try,".zip");
|
||||
|
||||
if (opt_overwrite==2)
|
||||
{
|
||||
/* if the file don't exist, we not append file */
|
||||
if (check_exist_file(filename_try)==0)
|
||||
opt_overwrite=1;
|
||||
}
|
||||
else
|
||||
if (opt_overwrite==0)
|
||||
if (check_exist_file(filename_try)!=0)
|
||||
{
|
||||
char rep=0;
|
||||
do
|
||||
{
|
||||
char answer[128];
|
||||
printf("The file %s exist. Overwrite ? [y]es, [n]o, [a]ppend : ",filename_try);
|
||||
scanf("%1s",answer);
|
||||
rep = answer[0] ;
|
||||
if ((rep>='a') && (rep<='z'))
|
||||
rep -= 0x20;
|
||||
}
|
||||
while ((rep!='Y') && (rep!='N') && (rep!='A'));
|
||||
if (rep=='N')
|
||||
zipok = 0;
|
||||
if (rep=='A')
|
||||
opt_overwrite = 2;
|
||||
}
|
||||
}
|
||||
|
||||
if (zipok==1)
|
||||
{
|
||||
zipFile zf;
|
||||
int errclose;
|
||||
# ifdef USEWIN32IOAPI
|
||||
zlib_filefunc_def ffunc;
|
||||
fill_win32_filefunc(&ffunc);
|
||||
zf = zipOpen2(filename_try,(opt_overwrite==2) ? 2 : 0,NULL,&ffunc);
|
||||
# else
|
||||
zf = zipOpen(filename_try,(opt_overwrite==2) ? 2 : 0);
|
||||
# endif
|
||||
|
||||
if (zf == NULL)
|
||||
{
|
||||
printf("error opening %s\n",filename_try);
|
||||
err= ZIP_ERRNO;
|
||||
}
|
||||
else
|
||||
printf("creating %s\n",filename_try);
|
||||
|
||||
for (i=zipfilenamearg+1;(i<argc) && (err==ZIP_OK);i++)
|
||||
{
|
||||
if (((*(argv[i]))!='-') && ((*(argv[i]))!='/'))
|
||||
{
|
||||
FILE * fin;
|
||||
int size_read;
|
||||
const char* filenameinzip = argv[i];
|
||||
zip_fileinfo zi;
|
||||
unsigned long crcFile=0;
|
||||
|
||||
zi.tmz_date.tm_sec = zi.tmz_date.tm_min = zi.tmz_date.tm_hour =
|
||||
zi.tmz_date.tm_mday = zi.tmz_date.tm_mon = zi.tmz_date.tm_year = 0;
|
||||
zi.dosDate = 0;
|
||||
zi.internal_fa = 0;
|
||||
zi.external_fa = 0;
|
||||
filetime(filenameinzip,&zi.tmz_date,&zi.dosDate);
|
||||
|
||||
/*
|
||||
err = zipOpenNewFileInZip(zf,filenameinzip,&zi,
|
||||
NULL,0,NULL,0,NULL / * comment * /,
|
||||
(opt_compress_level != 0) ? Z_DEFLATED : 0,
|
||||
opt_compress_level);
|
||||
*/
|
||||
if ((password != NULL) && (err==ZIP_OK))
|
||||
err = getFileCrc(filenameinzip,buf,size_buf,&crcFile);
|
||||
|
||||
err = zipOpenNewFileInZip3(zf,filenameinzip,&zi,
|
||||
NULL,0,NULL,0,NULL /* comment*/,
|
||||
(opt_compress_level != 0) ? Z_DEFLATED : 0,
|
||||
opt_compress_level,0,
|
||||
/* -MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY, */
|
||||
-MAX_WBITS, DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY,
|
||||
password,crcFile);
|
||||
|
||||
if (err != ZIP_OK)
|
||||
printf("error in opening %s in zipfile\n",filenameinzip);
|
||||
else
|
||||
{
|
||||
fin = fopen(filenameinzip,"rb");
|
||||
if (fin==NULL)
|
||||
{
|
||||
err=ZIP_ERRNO;
|
||||
printf("error in opening %s for reading\n",filenameinzip);
|
||||
}
|
||||
}
|
||||
|
||||
if (err == ZIP_OK)
|
||||
do
|
||||
{
|
||||
err = ZIP_OK;
|
||||
size_read = (int)fread(buf,1,size_buf,fin);
|
||||
if (size_read < size_buf)
|
||||
if (feof(fin)==0)
|
||||
{
|
||||
printf("error in reading %s\n",filenameinzip);
|
||||
err = ZIP_ERRNO;
|
||||
}
|
||||
|
||||
if (size_read>0)
|
||||
{
|
||||
err = zipWriteInFileInZip (zf,buf,size_read);
|
||||
if (err<0)
|
||||
{
|
||||
printf("error in writing %s in the zipfile\n",
|
||||
filenameinzip);
|
||||
}
|
||||
|
||||
}
|
||||
} while ((err == ZIP_OK) && (size_read>0));
|
||||
|
||||
if (fin)
|
||||
fclose(fin);
|
||||
|
||||
if (err<0)
|
||||
err=ZIP_ERRNO;
|
||||
else
|
||||
{
|
||||
err = zipCloseFileInZip(zf);
|
||||
if (err!=ZIP_OK)
|
||||
printf("error in closing %s in the zipfile\n",
|
||||
filenameinzip);
|
||||
}
|
||||
}
|
||||
}
|
||||
errclose = zipClose(zf,NULL);
|
||||
if (errclose != ZIP_OK)
|
||||
printf("error in closing %s\n",filename_try);
|
||||
}
|
||||
|
||||
free(buf);
|
||||
return 0;
|
||||
}
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,342 +0,0 @@
|
|||
/* unzip.h -- IO for uncompress .zip files using zlib
|
||||
Version 1.00, September 10th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
|
||||
This unzip package allow extract file from .ZIP file, compatible with PKZip 2.04g
|
||||
WinZip, InfoZip tools and compatible.
|
||||
Encryption and multi volume ZipFile (span) are not supported.
|
||||
Old compressions used by old PKZip 1.x are not supported
|
||||
|
||||
|
||||
I WAIT FEEDBACK at mail info@winimage.com
|
||||
Visit also http://www.winimage.com/zLibDll/unzip.htm for evolution
|
||||
|
||||
Condition of use and distribution are the same than zlib :
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
|
||||
|
||||
*/
|
||||
|
||||
/* for more info about .ZIP format, see
|
||||
http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
|
||||
http://www.info-zip.org/pub/infozip/doc/
|
||||
PkWare has also a specification at :
|
||||
ftp://ftp.pkware.com/probdesc.zip
|
||||
*/
|
||||
|
||||
#ifndef _unz_H
|
||||
#define _unz_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef _ZLIB_H
|
||||
#include "zlib.h"
|
||||
#endif
|
||||
|
||||
#ifndef _ZLIBIOAPI_H
|
||||
#include "ioapi.h"
|
||||
#endif
|
||||
|
||||
#if defined(STRICTUNZIP) || defined(STRICTZIPUNZIP)
|
||||
/* like the STRICT of WIN32, we define a pointer that cannot be converted
|
||||
from (void*) without cast */
|
||||
typedef struct TagunzFile__ { int unused; } unzFile__;
|
||||
typedef unzFile__ *unzFile;
|
||||
#else
|
||||
typedef voidp unzFile;
|
||||
#endif
|
||||
|
||||
|
||||
#define UNZ_OK (0)
|
||||
#define UNZ_END_OF_LIST_OF_FILE (-100)
|
||||
#define UNZ_ERRNO (Z_ERRNO)
|
||||
#define UNZ_EOF (0)
|
||||
#define UNZ_PARAMERROR (-102)
|
||||
#define UNZ_BADZIPFILE (-103)
|
||||
#define UNZ_INTERNALERROR (-104)
|
||||
#define UNZ_CRCERROR (-105)
|
||||
|
||||
/* tm_unz contain date/time info */
|
||||
typedef struct tm_unz_s
|
||||
{
|
||||
uInt tm_sec; /* seconds after the minute - [0,59] */
|
||||
uInt tm_min; /* minutes after the hour - [0,59] */
|
||||
uInt tm_hour; /* hours since midnight - [0,23] */
|
||||
uInt tm_mday; /* day of the month - [1,31] */
|
||||
uInt tm_mon; /* months since January - [0,11] */
|
||||
uInt tm_year; /* years - [1980..2044] */
|
||||
} tm_unz;
|
||||
|
||||
/* unz_global_info structure contain global data about the ZIPfile
|
||||
These data comes from the end of central dir */
|
||||
typedef struct unz_global_info_s
|
||||
{
|
||||
uLong number_entry; /* total number of entries in
|
||||
the central dir on this disk */
|
||||
uLong size_comment; /* size of the global comment of the zipfile */
|
||||
} unz_global_info;
|
||||
|
||||
|
||||
/* unz_file_info contain information about a file in the zipfile */
|
||||
typedef struct unz_file_info_s
|
||||
{
|
||||
uLong version; /* version made by 2 bytes */
|
||||
uLong version_needed; /* version needed to extract 2 bytes */
|
||||
uLong flag; /* general purpose bit flag 2 bytes */
|
||||
uLong compression_method; /* compression method 2 bytes */
|
||||
uLong dosDate; /* last mod file date in Dos fmt 4 bytes */
|
||||
uLong crc; /* crc-32 4 bytes */
|
||||
uLong compressed_size; /* compressed size 4 bytes */
|
||||
uLong uncompressed_size; /* uncompressed size 4 bytes */
|
||||
uLong size_filename; /* filename length 2 bytes */
|
||||
uLong size_file_extra; /* extra field length 2 bytes */
|
||||
uLong size_file_comment; /* file comment length 2 bytes */
|
||||
|
||||
uLong disk_num_start; /* disk number start 2 bytes */
|
||||
uLong internal_fa; /* internal file attributes 2 bytes */
|
||||
uLong external_fa; /* external file attributes 4 bytes */
|
||||
|
||||
tm_unz tmu_date;
|
||||
} unz_file_info;
|
||||
|
||||
extern int ZEXPORT unzStringFileNameCompare OF ((const char* fileName1,
|
||||
const char* fileName2,
|
||||
int iCaseSensitivity));
|
||||
/*
|
||||
Compare two filename (fileName1,fileName2).
|
||||
If iCaseSenisivity = 1, comparision is case sensitivity (like strcmp)
|
||||
If iCaseSenisivity = 2, comparision is not case sensitivity (like strcmpi
|
||||
or strcasecmp)
|
||||
If iCaseSenisivity = 0, case sensitivity is defaut of your operating system
|
||||
(like 1 on Unix, 2 on Windows)
|
||||
*/
|
||||
|
||||
|
||||
extern unzFile ZEXPORT unzOpen OF((const char *path));
|
||||
/*
|
||||
Open a Zip file. path contain the full pathname (by example,
|
||||
on a Windows XP computer "c:\\zlib\\zlib113.zip" or on an Unix computer
|
||||
"zlib/zlib113.zip".
|
||||
If the zipfile cannot be opened (file don't exist or in not valid), the
|
||||
return value is NULL.
|
||||
Else, the return value is a unzFile Handle, usable with other function
|
||||
of this unzip package.
|
||||
*/
|
||||
|
||||
extern unzFile ZEXPORT unzOpen2 OF((const char *path,
|
||||
zlib_filefunc_def* pzlib_filefunc_def));
|
||||
/*
|
||||
Open a Zip file, like unzOpen, but provide a set of file low level API
|
||||
for read/write the zip file (see ioapi.h)
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzClose OF((unzFile file));
|
||||
/*
|
||||
Close a ZipFile opened with unzipOpen.
|
||||
If there is files inside the .Zip opened with unzOpenCurrentFile (see later),
|
||||
these files MUST be closed with unzipCloseCurrentFile before call unzipClose.
|
||||
return UNZ_OK if there is no problem. */
|
||||
|
||||
extern int ZEXPORT unzGetGlobalInfo OF((unzFile file,
|
||||
unz_global_info *pglobal_info));
|
||||
/*
|
||||
Write info about the ZipFile in the *pglobal_info structure.
|
||||
No preparation of the structure is needed
|
||||
return UNZ_OK if there is no problem. */
|
||||
|
||||
|
||||
extern int ZEXPORT unzGetGlobalComment OF((unzFile file,
|
||||
char *szComment,
|
||||
uLong uSizeBuf));
|
||||
/*
|
||||
Get the global comment string of the ZipFile, in the szComment buffer.
|
||||
uSizeBuf is the size of the szComment buffer.
|
||||
return the number of byte copied or an error code <0
|
||||
*/
|
||||
|
||||
|
||||
/***************************************************************************/
|
||||
/* Unzip package allow you browse the directory of the zipfile */
|
||||
|
||||
extern int ZEXPORT unzGoToFirstFile OF((unzFile file));
|
||||
/*
|
||||
Set the current file of the zipfile to the first file.
|
||||
return UNZ_OK if there is no problem
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzGoToNextFile OF((unzFile file));
|
||||
/*
|
||||
Set the current file of the zipfile to the next file.
|
||||
return UNZ_OK if there is no problem
|
||||
return UNZ_END_OF_LIST_OF_FILE if the actual file was the latest.
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzLocateFile OF((unzFile file,
|
||||
const char *szFileName,
|
||||
int iCaseSensitivity));
|
||||
/*
|
||||
Try locate the file szFileName in the zipfile.
|
||||
For the iCaseSensitivity signification, see unzStringFileNameCompare
|
||||
|
||||
return value :
|
||||
UNZ_OK if the file is found. It becomes the current file.
|
||||
UNZ_END_OF_LIST_OF_FILE if the file is not found
|
||||
*/
|
||||
|
||||
|
||||
/* ****************************************** */
|
||||
/* Ryan supplied functions */
|
||||
/* unz_file_info contain information about a file in the zipfile */
|
||||
typedef struct unz_file_pos_s
|
||||
{
|
||||
uLong pos_in_zip_directory; /* offset in zip file directory */
|
||||
uLong num_of_file; /* # of file */
|
||||
} unz_file_pos;
|
||||
|
||||
extern int ZEXPORT unzGetFilePos(
|
||||
unzFile file,
|
||||
unz_file_pos* file_pos);
|
||||
|
||||
extern int ZEXPORT unzGoToFilePos(
|
||||
unzFile file,
|
||||
unz_file_pos* file_pos);
|
||||
|
||||
/* ****************************************** */
|
||||
|
||||
extern int ZEXPORT unzGetCurrentFileInfo OF((unzFile file,
|
||||
unz_file_info *pfile_info,
|
||||
char *szFileName,
|
||||
uLong fileNameBufferSize,
|
||||
void *extraField,
|
||||
uLong extraFieldBufferSize,
|
||||
char *szComment,
|
||||
uLong commentBufferSize));
|
||||
/*
|
||||
Get Info about the current file
|
||||
if pfile_info!=NULL, the *pfile_info structure will contain somes info about
|
||||
the current file
|
||||
if szFileName!=NULL, the filemane string will be copied in szFileName
|
||||
(fileNameBufferSize is the size of the buffer)
|
||||
if extraField!=NULL, the extra field information will be copied in extraField
|
||||
(extraFieldBufferSize is the size of the buffer).
|
||||
This is the Central-header version of the extra field
|
||||
if szComment!=NULL, the comment string of the file will be copied in szComment
|
||||
(commentBufferSize is the size of the buffer)
|
||||
*/
|
||||
|
||||
/***************************************************************************/
|
||||
/* for reading the content of the current zipfile, you can open it, read data
|
||||
from it, and close it (you can close it before reading all the file)
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzOpenCurrentFile OF((unzFile file));
|
||||
/*
|
||||
Open for reading data the current file in the zipfile.
|
||||
If there is no error, the return value is UNZ_OK.
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzOpenCurrentFilePassword OF((unzFile file,
|
||||
const char* password));
|
||||
/*
|
||||
Open for reading data the current file in the zipfile.
|
||||
password is a crypting password
|
||||
If there is no error, the return value is UNZ_OK.
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzOpenCurrentFile2 OF((unzFile file,
|
||||
int* method,
|
||||
int* level,
|
||||
int raw));
|
||||
/*
|
||||
Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
|
||||
if raw==1
|
||||
*method will receive method of compression, *level will receive level of
|
||||
compression
|
||||
note : you can set level parameter as NULL (if you did not want known level,
|
||||
but you CANNOT set method parameter as NULL
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzOpenCurrentFile3 OF((unzFile file,
|
||||
int* method,
|
||||
int* level,
|
||||
int raw,
|
||||
const char* password));
|
||||
/*
|
||||
Same than unzOpenCurrentFile, but open for read raw the file (not uncompress)
|
||||
if raw==1
|
||||
*method will receive method of compression, *level will receive level of
|
||||
compression
|
||||
note : you can set level parameter as NULL (if you did not want known level,
|
||||
but you CANNOT set method parameter as NULL
|
||||
*/
|
||||
|
||||
|
||||
extern int ZEXPORT unzCloseCurrentFile OF((unzFile file));
|
||||
/*
|
||||
Close the file in zip opened with unzOpenCurrentFile
|
||||
Return UNZ_CRCERROR if all the file was read but the CRC is not good
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzReadCurrentFile OF((unzFile file,
|
||||
voidp buf,
|
||||
unsigned len));
|
||||
/*
|
||||
Read bytes from the current file (opened by unzOpenCurrentFile)
|
||||
buf contain buffer where data must be copied
|
||||
len the size of buf.
|
||||
|
||||
return the number of byte copied if somes bytes are copied
|
||||
return 0 if the end of file was reached
|
||||
return <0 with error code if there is an error
|
||||
(UNZ_ERRNO for IO error, or zLib error for uncompress error)
|
||||
*/
|
||||
|
||||
extern z_off_t ZEXPORT unztell OF((unzFile file));
|
||||
/*
|
||||
Give the current position in uncompressed data
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzeof OF((unzFile file));
|
||||
/*
|
||||
return 1 if the end of file was reached, 0 elsewhere
|
||||
*/
|
||||
|
||||
extern int ZEXPORT unzGetLocalExtrafield OF((unzFile file,
|
||||
voidp buf,
|
||||
unsigned len));
|
||||
/*
|
||||
Read extra field from the current file (opened by unzOpenCurrentFile)
|
||||
This is the local-header version of the extra field (sometimes, there is
|
||||
more info in the local-header version than in the central-header)
|
||||
|
||||
if buf==NULL, it return the size of the local extra field
|
||||
|
||||
if buf!=NULL, len is the size of the buffer, the extra header is copied in
|
||||
buf.
|
||||
the return value is the number of bytes copied in buf, or (if <0)
|
||||
the error code
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _unz_H */
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,235 +0,0 @@
|
|||
/* zip.h -- IO for compress .zip files using zlib
|
||||
Version 1.00, September 10th, 2003
|
||||
|
||||
Copyright (C) 1998-2003 Gilles Vollant
|
||||
|
||||
This unzip package allow creates .ZIP file, compatible with PKZip 2.04g
|
||||
WinZip, InfoZip tools and compatible.
|
||||
Encryption and multi volume ZipFile (span) are not supported.
|
||||
Old compressions used by old PKZip 1.x are not supported
|
||||
|
||||
For uncompress .zip file, look at unzip.h
|
||||
|
||||
|
||||
I WAIT FEEDBACK at mail info@winimage.com
|
||||
Visit also http://www.winimage.com/zLibDll/unzip.html for evolution
|
||||
|
||||
Condition of use and distribution are the same than zlib :
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the authors be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
|
||||
|
||||
*/
|
||||
|
||||
/* for more info about .ZIP format, see
|
||||
http://www.info-zip.org/pub/infozip/doc/appnote-981119-iz.zip
|
||||
http://www.info-zip.org/pub/infozip/doc/
|
||||
PkWare has also a specification at :
|
||||
ftp://ftp.pkware.com/probdesc.zip
|
||||
*/
|
||||
|
||||
#ifndef _zip_H
|
||||
#define _zip_H
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#ifndef _ZLIB_H
|
||||
#include "zlib.h"
|
||||
#endif
|
||||
|
||||
#ifndef _ZLIBIOAPI_H
|
||||
#include "ioapi.h"
|
||||
#endif
|
||||
|
||||
#if defined(STRICTZIP) || defined(STRICTZIPUNZIP)
|
||||
/* like the STRICT of WIN32, we define a pointer that cannot be converted
|
||||
from (void*) without cast */
|
||||
typedef struct TagzipFile__ { int unused; } zipFile__;
|
||||
typedef zipFile__ *zipFile;
|
||||
#else
|
||||
typedef voidp zipFile;
|
||||
#endif
|
||||
|
||||
#define ZIP_OK (0)
|
||||
#define ZIP_EOF (0)
|
||||
#define ZIP_ERRNO (Z_ERRNO)
|
||||
#define ZIP_PARAMERROR (-102)
|
||||
#define ZIP_BADZIPFILE (-103)
|
||||
#define ZIP_INTERNALERROR (-104)
|
||||
|
||||
#ifndef DEF_MEM_LEVEL
|
||||
# if MAX_MEM_LEVEL >= 8
|
||||
# define DEF_MEM_LEVEL 8
|
||||
# else
|
||||
# define DEF_MEM_LEVEL MAX_MEM_LEVEL
|
||||
# endif
|
||||
#endif
|
||||
/* default memLevel */
|
||||
|
||||
/* tm_zip contain date/time info */
|
||||
typedef struct tm_zip_s
|
||||
{
|
||||
uInt tm_sec; /* seconds after the minute - [0,59] */
|
||||
uInt tm_min; /* minutes after the hour - [0,59] */
|
||||
uInt tm_hour; /* hours since midnight - [0,23] */
|
||||
uInt tm_mday; /* day of the month - [1,31] */
|
||||
uInt tm_mon; /* months since January - [0,11] */
|
||||
uInt tm_year; /* years - [1980..2044] */
|
||||
} tm_zip;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
tm_zip tmz_date; /* date in understandable format */
|
||||
uLong dosDate; /* if dos_date == 0, tmu_date is used */
|
||||
/* uLong flag; */ /* general purpose bit flag 2 bytes */
|
||||
|
||||
uLong internal_fa; /* internal file attributes 2 bytes */
|
||||
uLong external_fa; /* external file attributes 4 bytes */
|
||||
} zip_fileinfo;
|
||||
|
||||
typedef const char* zipcharpc;
|
||||
|
||||
|
||||
#define APPEND_STATUS_CREATE (0)
|
||||
#define APPEND_STATUS_CREATEAFTER (1)
|
||||
#define APPEND_STATUS_ADDINZIP (2)
|
||||
|
||||
extern zipFile ZEXPORT zipOpen OF((const char *pathname, int append));
|
||||
/*
|
||||
Create a zipfile.
|
||||
pathname contain on Windows XP a filename like "c:\\zlib\\zlib113.zip" or on
|
||||
an Unix computer "zlib/zlib113.zip".
|
||||
if the file pathname exist and append==APPEND_STATUS_CREATEAFTER, the zip
|
||||
will be created at the end of the file.
|
||||
(useful if the file contain a self extractor code)
|
||||
if the file pathname exist and append==APPEND_STATUS_ADDINZIP, we will
|
||||
add files in existing zip (be sure you don't add file that doesn't exist)
|
||||
If the zipfile cannot be opened, the return value is NULL.
|
||||
Else, the return value is a zipFile Handle, usable with other function
|
||||
of this zip package.
|
||||
*/
|
||||
|
||||
/* Note : there is no delete function into a zipfile.
|
||||
If you want delete file into a zipfile, you must open a zipfile, and create another
|
||||
Of couse, you can use RAW reading and writing to copy the file you did not want delte
|
||||
*/
|
||||
|
||||
extern zipFile ZEXPORT zipOpen2 OF((const char *pathname,
|
||||
int append,
|
||||
zipcharpc* globalcomment,
|
||||
zlib_filefunc_def* pzlib_filefunc_def));
|
||||
|
||||
extern int ZEXPORT zipOpenNewFileInZip OF((zipFile file,
|
||||
const char* filename,
|
||||
const zip_fileinfo* zipfi,
|
||||
const void* extrafield_local,
|
||||
uInt size_extrafield_local,
|
||||
const void* extrafield_global,
|
||||
uInt size_extrafield_global,
|
||||
const char* comment,
|
||||
int method,
|
||||
int level));
|
||||
/*
|
||||
Open a file in the ZIP for writing.
|
||||
filename : the filename in zip (if NULL, '-' without quote will be used
|
||||
*zipfi contain supplemental information
|
||||
if extrafield_local!=NULL and size_extrafield_local>0, extrafield_local
|
||||
contains the extrafield data the the local header
|
||||
if extrafield_global!=NULL and size_extrafield_global>0, extrafield_global
|
||||
contains the extrafield data the the local header
|
||||
if comment != NULL, comment contain the comment string
|
||||
method contain the compression method (0 for store, Z_DEFLATED for deflate)
|
||||
level contain the level of compression (can be Z_DEFAULT_COMPRESSION)
|
||||
*/
|
||||
|
||||
|
||||
extern int ZEXPORT zipOpenNewFileInZip2 OF((zipFile file,
|
||||
const char* filename,
|
||||
const zip_fileinfo* zipfi,
|
||||
const void* extrafield_local,
|
||||
uInt size_extrafield_local,
|
||||
const void* extrafield_global,
|
||||
uInt size_extrafield_global,
|
||||
const char* comment,
|
||||
int method,
|
||||
int level,
|
||||
int raw));
|
||||
|
||||
/*
|
||||
Same than zipOpenNewFileInZip, except if raw=1, we write raw file
|
||||
*/
|
||||
|
||||
extern int ZEXPORT zipOpenNewFileInZip3 OF((zipFile file,
|
||||
const char* filename,
|
||||
const zip_fileinfo* zipfi,
|
||||
const void* extrafield_local,
|
||||
uInt size_extrafield_local,
|
||||
const void* extrafield_global,
|
||||
uInt size_extrafield_global,
|
||||
const char* comment,
|
||||
int method,
|
||||
int level,
|
||||
int raw,
|
||||
int windowBits,
|
||||
int memLevel,
|
||||
int strategy,
|
||||
const char* password,
|
||||
uLong crcForCtypting));
|
||||
|
||||
/*
|
||||
Same than zipOpenNewFileInZip2, except
|
||||
windowBits,memLevel,,strategy : see parameter strategy in deflateInit2
|
||||
password : crypting password (NULL for no crypting)
|
||||
crcForCtypting : crc of file to compress (needed for crypting)
|
||||
*/
|
||||
|
||||
|
||||
extern int ZEXPORT zipWriteInFileInZip OF((zipFile file,
|
||||
const void* buf,
|
||||
unsigned len));
|
||||
/*
|
||||
Write data in the zipfile
|
||||
*/
|
||||
|
||||
extern int ZEXPORT zipCloseFileInZip OF((zipFile file));
|
||||
/*
|
||||
Close the current file in the zipfile
|
||||
*/
|
||||
|
||||
|
||||
extern int ZEXPORT zipCloseFileInZipRaw OF((zipFile file,
|
||||
uLong uncompressed_size,
|
||||
uLong crc32));
|
||||
/*
|
||||
Close the current file in the zipfile, for fiel opened with
|
||||
parameter raw=1 in zipOpenNewFileInZip2
|
||||
uncompressed_size and crc32 are value for the uncompressed size
|
||||
*/
|
||||
|
||||
extern int ZEXPORT zipClose OF((zipFile file,
|
||||
const char* global_comment));
|
||||
/*
|
||||
Close the zipfile
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif /* _zip_H */
|
||||
|
|
@ -1,599 +0,0 @@
|
|||
(* example.c -- usage example of the zlib compression library
|
||||
* Copyright (C) 1995-2003 Jean-loup Gailly.
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*
|
||||
* Pascal translation
|
||||
* Copyright (C) 1998 by Jacques Nomssi Nzali.
|
||||
* For conditions of distribution and use, see copyright notice in readme.txt
|
||||
*
|
||||
* Adaptation to the zlibpas interface
|
||||
* Copyright (C) 2003 by Cosmin Truta.
|
||||
* For conditions of distribution and use, see copyright notice in readme.txt
|
||||
*)
|
||||
|
||||
program example;
|
||||
|
||||
{$DEFINE TEST_COMPRESS}
|
||||
{DO NOT $DEFINE TEST_GZIO}
|
||||
{$DEFINE TEST_DEFLATE}
|
||||
{$DEFINE TEST_INFLATE}
|
||||
{$DEFINE TEST_FLUSH}
|
||||
{$DEFINE TEST_SYNC}
|
||||
{$DEFINE TEST_DICT}
|
||||
|
||||
uses SysUtils, zlibpas;
|
||||
|
||||
const TESTFILE = 'foo.gz';
|
||||
|
||||
(* "hello world" would be more standard, but the repeated "hello"
|
||||
* stresses the compression code better, sorry...
|
||||
*)
|
||||
const hello: PChar = 'hello, hello!';
|
||||
|
||||
const dictionary: PChar = 'hello';
|
||||
|
||||
var dictId: LongInt; (* Adler32 value of the dictionary *)
|
||||
|
||||
procedure CHECK_ERR(err: Integer; msg: String);
|
||||
begin
|
||||
if err <> Z_OK then
|
||||
begin
|
||||
WriteLn(msg, ' error: ', err);
|
||||
Halt(1);
|
||||
end;
|
||||
end;
|
||||
|
||||
procedure EXIT_ERR(const msg: String);
|
||||
begin
|
||||
WriteLn('Error: ', msg);
|
||||
Halt(1);
|
||||
end;
|
||||
|
||||
(* ===========================================================================
|
||||
* Test compress and uncompress
|
||||
*)
|
||||
{$IFDEF TEST_COMPRESS}
|
||||
procedure test_compress(compr: Pointer; comprLen: LongInt;
|
||||
uncompr: Pointer; uncomprLen: LongInt);
|
||||
var err: Integer;
|
||||
len: LongInt;
|
||||
begin
|
||||
len := StrLen(hello)+1;
|
||||
|
||||
err := compress(compr, comprLen, hello, len);
|
||||
CHECK_ERR(err, 'compress');
|
||||
|
||||
StrCopy(PChar(uncompr), 'garbage');
|
||||
|
||||
err := uncompress(uncompr, uncomprLen, compr, comprLen);
|
||||
CHECK_ERR(err, 'uncompress');
|
||||
|
||||
if StrComp(PChar(uncompr), hello) <> 0 then
|
||||
EXIT_ERR('bad uncompress')
|
||||
else
|
||||
WriteLn('uncompress(): ', PChar(uncompr));
|
||||
end;
|
||||
{$ENDIF}
|
||||
|
||||
(* ===========================================================================
|
||||
* Test read/write of .gz files
|
||||
*)
|
||||
{$IFDEF TEST_GZIO}
|
||||
procedure test_gzio(const fname: PChar; (* compressed file name *)
|
||||
uncompr: Pointer;
|
||||
uncomprLen: LongInt);
|
||||
var err: Integer;
|
||||
len: Integer;
|
||||
zfile: gzFile;
|
||||
pos: LongInt;
|
||||
begin
|
||||
len := StrLen(hello)+1;
|
||||
|
||||
zfile := gzopen(fname, 'wb');
|
||||
if zfile = NIL then
|
||||
begin
|
||||
WriteLn('gzopen error');
|
||||
Halt(1);
|
||||
end;
|
||||
gzputc(zfile, 'h');
|
||||
if gzputs(zfile, 'ello') <> 4 then
|
||||
begin
|
||||
WriteLn('gzputs err: ', gzerror(zfile, err));
|
||||
Halt(1);
|
||||
end;
|
||||
{$IFDEF GZ_FORMAT_STRING}
|
||||
if gzprintf(zfile, ', %s!', 'hello') <> 8 then
|
||||
begin
|
||||
WriteLn('gzprintf err: ', gzerror(zfile, err));
|
||||
Halt(1);
|
||||
end;
|
||||
{$ELSE}
|
||||
if gzputs(zfile, ', hello!') <> 8 then
|
||||
begin
|
||||
WriteLn('gzputs err: ', gzerror(zfile, err));
|
||||
Halt(1);
|
||||
end;
|
||||
{$ENDIF}
|
||||
gzseek(zfile, 1, SEEK_CUR); (* add one zero byte *)
|
||||
gzclose(zfile);
|
||||
|
||||
zfile := gzopen(fname, 'rb');
|
||||
if zfile = NIL then
|
||||
begin
|
||||
WriteLn('gzopen error');
|
||||
Halt(1);
|
||||
end;
|
||||
|
||||
StrCopy(PChar(uncompr), 'garbage');
|
||||
|
||||
if gzread(zfile, uncompr, uncomprLen) <> len then
|
||||
begin
|
||||
WriteLn('gzread err: ', gzerror(zfile, err));
|
||||
Halt(1);
|
||||
end;
|
||||
if StrComp(PChar(uncompr), hello) <> 0 then
|
||||
begin
|
||||
WriteLn('bad gzread: ', PChar(uncompr));
|
||||
Halt(1);
|
||||
end
|
||||
else
|
||||
WriteLn('gzread(): ', PChar(uncompr));
|
||||
|
||||
pos := gzseek(zfile, -8, SEEK_CUR);
|
||||
if (pos <> 6) or (gztell(zfile) <> pos) then
|
||||
begin
|
||||
WriteLn('gzseek error, pos=', pos, ', gztell=', gztell(zfile));
|
||||
Halt(1);
|
||||
end;
|
||||
|
||||
if gzgetc(zfile) <> ' ' then
|
||||
begin
|
||||
WriteLn('gzgetc error');
|
||||
Halt(1);
|
||||
end;
|
||||
|
||||
if gzungetc(' ', zfile) <> ' ' then
|
||||
begin
|
||||
WriteLn('gzungetc error');
|
||||
Halt(1);
|
||||
end;
|
||||
|
||||
gzgets(zfile, PChar(uncompr), uncomprLen);
|
||||
uncomprLen := StrLen(PChar(uncompr));
|
||||
if uncomprLen <> 7 then (* " hello!" *)
|
||||
begin
|
||||
WriteLn('gzgets err after gzseek: ', gzerror(zfile, err));
|
||||
Halt(1);
|
||||
end;
|
||||
if StrComp(PChar(uncompr), hello + 6) <> 0 then
|
||||
begin
|
||||
WriteLn('bad gzgets after gzseek');
|
||||
Halt(1);
|
||||
end
|
||||
else
|
||||
WriteLn('gzgets() after gzseek: ', PChar(uncompr));
|
||||
|
||||
gzclose(zfile);
|
||||
end;
|
||||
{$ENDIF}
|
||||
|
||||
(* ===========================================================================
|
||||
* Test deflate with small buffers
|
||||
*)
|
||||
{$IFDEF TEST_DEFLATE}
|
||||
procedure test_deflate(compr: Pointer; comprLen: LongInt);
|
||||
var c_stream: z_stream; (* compression stream *)
|
||||
err: Integer;
|
||||
len: LongInt;
|
||||
begin
|
||||
len := StrLen(hello)+1;
|
||||
|
||||
c_stream.zalloc := NIL;
|
||||
c_stream.zfree := NIL;
|
||||
c_stream.opaque := NIL;
|
||||
|
||||
err := deflateInit(c_stream, Z_DEFAULT_COMPRESSION);
|
||||
CHECK_ERR(err, 'deflateInit');
|
||||
|
||||
c_stream.next_in := hello;
|
||||
c_stream.next_out := compr;
|
||||
|
||||
while (c_stream.total_in <> len) and
|
||||
(c_stream.total_out < comprLen) do
|
||||
begin
|
||||
c_stream.avail_out := 1; { force small buffers }
|
||||
c_stream.avail_in := 1;
|
||||
err := deflate(c_stream, Z_NO_FLUSH);
|
||||
CHECK_ERR(err, 'deflate');
|
||||
end;
|
||||
|
||||
(* Finish the stream, still forcing small buffers: *)
|
||||
while TRUE do
|
||||
begin
|
||||
c_stream.avail_out := 1;
|
||||
err := deflate(c_stream, Z_FINISH);
|
||||
if err = Z_STREAM_END then
|
||||
break;
|
||||
CHECK_ERR(err, 'deflate');
|
||||
end;
|
||||
|
||||
err := deflateEnd(c_stream);
|
||||
CHECK_ERR(err, 'deflateEnd');
|
||||
end;
|
||||
{$ENDIF}
|
||||
|
||||
(* ===========================================================================
|
||||
* Test inflate with small buffers
|
||||
*)
|
||||
{$IFDEF TEST_INFLATE}
|
||||
procedure test_inflate(compr: Pointer; comprLen : LongInt;
|
||||
uncompr: Pointer; uncomprLen : LongInt);
|
||||
var err: Integer;
|
||||
d_stream: z_stream; (* decompression stream *)
|
||||
begin
|
||||
StrCopy(PChar(uncompr), 'garbage');
|
||||
|
||||
d_stream.zalloc := NIL;
|
||||
d_stream.zfree := NIL;
|
||||
d_stream.opaque := NIL;
|
||||
|
||||
d_stream.next_in := compr;
|
||||
d_stream.avail_in := 0;
|
||||
d_stream.next_out := uncompr;
|
||||
|
||||
err := inflateInit(d_stream);
|
||||
CHECK_ERR(err, 'inflateInit');
|
||||
|
||||
while (d_stream.total_out < uncomprLen) and
|
||||
(d_stream.total_in < comprLen) do
|
||||
begin
|
||||
d_stream.avail_out := 1; (* force small buffers *)
|
||||
d_stream.avail_in := 1;
|
||||
err := inflate(d_stream, Z_NO_FLUSH);
|
||||
if err = Z_STREAM_END then
|
||||
break;
|
||||
CHECK_ERR(err, 'inflate');
|
||||
end;
|
||||
|
||||
err := inflateEnd(d_stream);
|
||||
CHECK_ERR(err, 'inflateEnd');
|
||||
|
||||
if StrComp(PChar(uncompr), hello) <> 0 then
|
||||
EXIT_ERR('bad inflate')
|
||||
else
|
||||
WriteLn('inflate(): ', PChar(uncompr));
|
||||
end;
|
||||
{$ENDIF}
|
||||
|
||||
(* ===========================================================================
|
||||
* Test deflate with large buffers and dynamic change of compression level
|
||||
*)
|
||||
{$IFDEF TEST_DEFLATE}
|
||||
procedure test_large_deflate(compr: Pointer; comprLen: LongInt;
|
||||
uncompr: Pointer; uncomprLen: LongInt);
|
||||
var c_stream: z_stream; (* compression stream *)
|
||||
err: Integer;
|
||||
begin
|
||||
c_stream.zalloc := NIL;
|
||||
c_stream.zfree := NIL;
|
||||
c_stream.opaque := NIL;
|
||||
|
||||
err := deflateInit(c_stream, Z_BEST_SPEED);
|
||||
CHECK_ERR(err, 'deflateInit');
|
||||
|
||||
c_stream.next_out := compr;
|
||||
c_stream.avail_out := Integer(comprLen);
|
||||
|
||||
(* At this point, uncompr is still mostly zeroes, so it should compress
|
||||
* very well:
|
||||
*)
|
||||
c_stream.next_in := uncompr;
|
||||
c_stream.avail_in := Integer(uncomprLen);
|
||||
err := deflate(c_stream, Z_NO_FLUSH);
|
||||
CHECK_ERR(err, 'deflate');
|
||||
if c_stream.avail_in <> 0 then
|
||||
EXIT_ERR('deflate not greedy');
|
||||
|
||||
(* Feed in already compressed data and switch to no compression: *)
|
||||
deflateParams(c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);
|
||||
c_stream.next_in := compr;
|
||||
c_stream.avail_in := Integer(comprLen div 2);
|
||||
err := deflate(c_stream, Z_NO_FLUSH);
|
||||
CHECK_ERR(err, 'deflate');
|
||||
|
||||
(* Switch back to compressing mode: *)
|
||||
deflateParams(c_stream, Z_BEST_COMPRESSION, Z_FILTERED);
|
||||
c_stream.next_in := uncompr;
|
||||
c_stream.avail_in := Integer(uncomprLen);
|
||||
err := deflate(c_stream, Z_NO_FLUSH);
|
||||
CHECK_ERR(err, 'deflate');
|
||||
|
||||
err := deflate(c_stream, Z_FINISH);
|
||||
if err <> Z_STREAM_END then
|
||||
EXIT_ERR('deflate should report Z_STREAM_END');
|
||||
|
||||
err := deflateEnd(c_stream);
|
||||
CHECK_ERR(err, 'deflateEnd');
|
||||
end;
|
||||
{$ENDIF}
|
||||
|
||||
(* ===========================================================================
|
||||
* Test inflate with large buffers
|
||||
*)
|
||||
{$IFDEF TEST_INFLATE}
|
||||
procedure test_large_inflate(compr: Pointer; comprLen: LongInt;
|
||||
uncompr: Pointer; uncomprLen: LongInt);
|
||||
var err: Integer;
|
||||
d_stream: z_stream; (* decompression stream *)
|
||||
begin
|
||||
StrCopy(PChar(uncompr), 'garbage');
|
||||
|
||||
d_stream.zalloc := NIL;
|
||||
d_stream.zfree := NIL;
|
||||
d_stream.opaque := NIL;
|
||||
|
||||
d_stream.next_in := compr;
|
||||
d_stream.avail_in := Integer(comprLen);
|
||||
|
||||
err := inflateInit(d_stream);
|
||||
CHECK_ERR(err, 'inflateInit');
|
||||
|
||||
while TRUE do
|
||||
begin
|
||||
d_stream.next_out := uncompr; (* discard the output *)
|
||||
d_stream.avail_out := Integer(uncomprLen);
|
||||
err := inflate(d_stream, Z_NO_FLUSH);
|
||||
if err = Z_STREAM_END then
|
||||
break;
|
||||
CHECK_ERR(err, 'large inflate');
|
||||
end;
|
||||
|
||||
err := inflateEnd(d_stream);
|
||||
CHECK_ERR(err, 'inflateEnd');
|
||||
|
||||
if d_stream.total_out <> 2 * uncomprLen + comprLen div 2 then
|
||||
begin
|
||||
WriteLn('bad large inflate: ', d_stream.total_out);
|
||||
Halt(1);
|
||||
end
|
||||
else
|
||||
WriteLn('large_inflate(): OK');
|
||||
end;
|
||||
{$ENDIF}
|
||||
|
||||
(* ===========================================================================
|
||||
* Test deflate with full flush
|
||||
*)
|
||||
{$IFDEF TEST_FLUSH}
|
||||
procedure test_flush(compr: Pointer; var comprLen : LongInt);
|
||||
var c_stream: z_stream; (* compression stream *)
|
||||
err: Integer;
|
||||
len: Integer;
|
||||
begin
|
||||
len := StrLen(hello)+1;
|
||||
|
||||
c_stream.zalloc := NIL;
|
||||
c_stream.zfree := NIL;
|
||||
c_stream.opaque := NIL;
|
||||
|
||||
err := deflateInit(c_stream, Z_DEFAULT_COMPRESSION);
|
||||
CHECK_ERR(err, 'deflateInit');
|
||||
|
||||
c_stream.next_in := hello;
|
||||
c_stream.next_out := compr;
|
||||
c_stream.avail_in := 3;
|
||||
c_stream.avail_out := Integer(comprLen);
|
||||
err := deflate(c_stream, Z_FULL_FLUSH);
|
||||
CHECK_ERR(err, 'deflate');
|
||||
|
||||
Inc(PByteArray(compr)^[3]); (* force an error in first compressed block *)
|
||||
c_stream.avail_in := len - 3;
|
||||
|
||||
err := deflate(c_stream, Z_FINISH);
|
||||
if err <> Z_STREAM_END then
|
||||
CHECK_ERR(err, 'deflate');
|
||||
|
||||
err := deflateEnd(c_stream);
|
||||
CHECK_ERR(err, 'deflateEnd');
|
||||
|
||||
comprLen := c_stream.total_out;
|
||||
end;
|
||||
{$ENDIF}
|
||||
|
||||
(* ===========================================================================
|
||||
* Test inflateSync()
|
||||
*)
|
||||
{$IFDEF TEST_SYNC}
|
||||
procedure test_sync(compr: Pointer; comprLen: LongInt;
|
||||
uncompr: Pointer; uncomprLen : LongInt);
|
||||
var err: Integer;
|
||||
d_stream: z_stream; (* decompression stream *)
|
||||
begin
|
||||
StrCopy(PChar(uncompr), 'garbage');
|
||||
|
||||
d_stream.zalloc := NIL;
|
||||
d_stream.zfree := NIL;
|
||||
d_stream.opaque := NIL;
|
||||
|
||||
d_stream.next_in := compr;
|
||||
d_stream.avail_in := 2; (* just read the zlib header *)
|
||||
|
||||
err := inflateInit(d_stream);
|
||||
CHECK_ERR(err, 'inflateInit');
|
||||
|
||||
d_stream.next_out := uncompr;
|
||||
d_stream.avail_out := Integer(uncomprLen);
|
||||
|
||||
inflate(d_stream, Z_NO_FLUSH);
|
||||
CHECK_ERR(err, 'inflate');
|
||||
|
||||
d_stream.avail_in := Integer(comprLen-2); (* read all compressed data *)
|
||||
err := inflateSync(d_stream); (* but skip the damaged part *)
|
||||
CHECK_ERR(err, 'inflateSync');
|
||||
|
||||
err := inflate(d_stream, Z_FINISH);
|
||||
if err <> Z_DATA_ERROR then
|
||||
EXIT_ERR('inflate should report DATA_ERROR');
|
||||
(* Because of incorrect adler32 *)
|
||||
|
||||
err := inflateEnd(d_stream);
|
||||
CHECK_ERR(err, 'inflateEnd');
|
||||
|
||||
WriteLn('after inflateSync(): hel', PChar(uncompr));
|
||||
end;
|
||||
{$ENDIF}
|
||||
|
||||
(* ===========================================================================
|
||||
* Test deflate with preset dictionary
|
||||
*)
|
||||
{$IFDEF TEST_DICT}
|
||||
procedure test_dict_deflate(compr: Pointer; comprLen: LongInt);
|
||||
var c_stream: z_stream; (* compression stream *)
|
||||
err: Integer;
|
||||
begin
|
||||
c_stream.zalloc := NIL;
|
||||
c_stream.zfree := NIL;
|
||||
c_stream.opaque := NIL;
|
||||
|
||||
err := deflateInit(c_stream, Z_BEST_COMPRESSION);
|
||||
CHECK_ERR(err, 'deflateInit');
|
||||
|
||||
err := deflateSetDictionary(c_stream, dictionary, StrLen(dictionary));
|
||||
CHECK_ERR(err, 'deflateSetDictionary');
|
||||
|
||||
dictId := c_stream.adler;
|
||||
c_stream.next_out := compr;
|
||||
c_stream.avail_out := Integer(comprLen);
|
||||
|
||||
c_stream.next_in := hello;
|
||||
c_stream.avail_in := StrLen(hello)+1;
|
||||
|
||||
err := deflate(c_stream, Z_FINISH);
|
||||
if err <> Z_STREAM_END then
|
||||
EXIT_ERR('deflate should report Z_STREAM_END');
|
||||
|
||||
err := deflateEnd(c_stream);
|
||||
CHECK_ERR(err, 'deflateEnd');
|
||||
end;
|
||||
{$ENDIF}
|
||||
|
||||
(* ===========================================================================
|
||||
* Test inflate with a preset dictionary
|
||||
*)
|
||||
{$IFDEF TEST_DICT}
|
||||
procedure test_dict_inflate(compr: Pointer; comprLen: LongInt;
|
||||
uncompr: Pointer; uncomprLen: LongInt);
|
||||
var err: Integer;
|
||||
d_stream: z_stream; (* decompression stream *)
|
||||
begin
|
||||
StrCopy(PChar(uncompr), 'garbage');
|
||||
|
||||
d_stream.zalloc := NIL;
|
||||
d_stream.zfree := NIL;
|
||||
d_stream.opaque := NIL;
|
||||
|
||||
d_stream.next_in := compr;
|
||||
d_stream.avail_in := Integer(comprLen);
|
||||
|
||||
err := inflateInit(d_stream);
|
||||
CHECK_ERR(err, 'inflateInit');
|
||||
|
||||
d_stream.next_out := uncompr;
|
||||
d_stream.avail_out := Integer(uncomprLen);
|
||||
|
||||
while TRUE do
|
||||
begin
|
||||
err := inflate(d_stream, Z_NO_FLUSH);
|
||||
if err = Z_STREAM_END then
|
||||
break;
|
||||
if err = Z_NEED_DICT then
|
||||
begin
|
||||
if d_stream.adler <> dictId then
|
||||
EXIT_ERR('unexpected dictionary');
|
||||
err := inflateSetDictionary(d_stream, dictionary, StrLen(dictionary));
|
||||
end;
|
||||
CHECK_ERR(err, 'inflate with dict');
|
||||
end;
|
||||
|
||||
err := inflateEnd(d_stream);
|
||||
CHECK_ERR(err, 'inflateEnd');
|
||||
|
||||
if StrComp(PChar(uncompr), hello) <> 0 then
|
||||
EXIT_ERR('bad inflate with dict')
|
||||
else
|
||||
WriteLn('inflate with dictionary: ', PChar(uncompr));
|
||||
end;
|
||||
{$ENDIF}
|
||||
|
||||
var compr, uncompr: Pointer;
|
||||
comprLen, uncomprLen: LongInt;
|
||||
|
||||
begin
|
||||
if zlibVersion^ <> ZLIB_VERSION[1] then
|
||||
EXIT_ERR('Incompatible zlib version');
|
||||
|
||||
WriteLn('zlib version: ', zlibVersion);
|
||||
WriteLn('zlib compile flags: ', Format('0x%x', [zlibCompileFlags]));
|
||||
|
||||
comprLen := 10000 * SizeOf(Integer); (* don't overflow on MSDOS *)
|
||||
uncomprLen := comprLen;
|
||||
GetMem(compr, comprLen);
|
||||
GetMem(uncompr, uncomprLen);
|
||||
if (compr = NIL) or (uncompr = NIL) then
|
||||
EXIT_ERR('Out of memory');
|
||||
(* compr and uncompr are cleared to avoid reading uninitialized
|
||||
* data and to ensure that uncompr compresses well.
|
||||
*)
|
||||
FillChar(compr^, comprLen, 0);
|
||||
FillChar(uncompr^, uncomprLen, 0);
|
||||
|
||||
{$IFDEF TEST_COMPRESS}
|
||||
WriteLn('** Testing compress');
|
||||
test_compress(compr, comprLen, uncompr, uncomprLen);
|
||||
{$ENDIF}
|
||||
|
||||
{$IFDEF TEST_GZIO}
|
||||
WriteLn('** Testing gzio');
|
||||
if ParamCount >= 1 then
|
||||
test_gzio(ParamStr(1), uncompr, uncomprLen)
|
||||
else
|
||||
test_gzio(TESTFILE, uncompr, uncomprLen);
|
||||
{$ENDIF}
|
||||
|
||||
{$IFDEF TEST_DEFLATE}
|
||||
WriteLn('** Testing deflate with small buffers');
|
||||
test_deflate(compr, comprLen);
|
||||
{$ENDIF}
|
||||
{$IFDEF TEST_INFLATE}
|
||||
WriteLn('** Testing inflate with small buffers');
|
||||
test_inflate(compr, comprLen, uncompr, uncomprLen);
|
||||
{$ENDIF}
|
||||
|
||||
{$IFDEF TEST_DEFLATE}
|
||||
WriteLn('** Testing deflate with large buffers');
|
||||
test_large_deflate(compr, comprLen, uncompr, uncomprLen);
|
||||
{$ENDIF}
|
||||
{$IFDEF TEST_INFLATE}
|
||||
WriteLn('** Testing inflate with large buffers');
|
||||
test_large_inflate(compr, comprLen, uncompr, uncomprLen);
|
||||
{$ENDIF}
|
||||
|
||||
{$IFDEF TEST_FLUSH}
|
||||
WriteLn('** Testing deflate with full flush');
|
||||
test_flush(compr, comprLen);
|
||||
{$ENDIF}
|
||||
{$IFDEF TEST_SYNC}
|
||||
WriteLn('** Testing inflateSync');
|
||||
test_sync(compr, comprLen, uncompr, uncomprLen);
|
||||
{$ENDIF}
|
||||
comprLen := uncomprLen;
|
||||
|
||||
{$IFDEF TEST_DICT}
|
||||
WriteLn('** Testing deflate and inflate with preset dictionary');
|
||||
test_dict_deflate(compr, comprLen);
|
||||
test_dict_inflate(compr, comprLen, uncompr, uncomprLen);
|
||||
{$ENDIF}
|
||||
|
||||
FreeMem(compr, comprLen);
|
||||
FreeMem(uncompr, uncomprLen);
|
||||
end.
|
||||
|
|
@ -1,76 +0,0 @@
|
|||
|
||||
This directory contains a Pascal (Delphi, Kylix) interface to the
|
||||
zlib data compression library.
|
||||
|
||||
|
||||
Directory listing
|
||||
=================
|
||||
|
||||
zlibd32.mak makefile for Borland C++
|
||||
example.pas usage example of zlib
|
||||
zlibpas.pas the Pascal interface to zlib
|
||||
readme.txt this file
|
||||
|
||||
|
||||
Compatibility notes
|
||||
===================
|
||||
|
||||
- Although the name "zlib" would have been more normal for the
|
||||
zlibpas unit, this name is already taken by Borland's ZLib unit.
|
||||
This is somehow unfortunate, because that unit is not a genuine
|
||||
interface to the full-fledged zlib functionality, but a suite of
|
||||
class wrappers around zlib streams. Other essential features,
|
||||
such as checksums, are missing.
|
||||
It would have been more appropriate for that unit to have a name
|
||||
like "ZStreams", or something similar.
|
||||
|
||||
- The C and zlib-supplied types int, uInt, long, uLong, etc. are
|
||||
translated directly into Pascal types of similar sizes (Integer,
|
||||
LongInt, etc.), to avoid namespace pollution. In particular,
|
||||
there is no conversion of unsigned int into a Pascal unsigned
|
||||
integer. The Word type is non-portable and has the same size
|
||||
(16 bits) both in a 16-bit and in a 32-bit environment, unlike
|
||||
Integer. Even if there is a 32-bit Cardinal type, there is no
|
||||
real need for unsigned int in zlib under a 32-bit environment.
|
||||
|
||||
- Except for the callbacks, the zlib function interfaces are
|
||||
assuming the calling convention normally used in Pascal
|
||||
(__pascal for DOS and Windows16, __fastcall for Windows32).
|
||||
Since the cdecl keyword is used, the old Turbo Pascal does
|
||||
not work with this interface.
|
||||
|
||||
- The gz* function interfaces are not translated, to avoid
|
||||
interfacing problems with the C runtime library. Besides,
|
||||
gzprintf(gzFile file, const char *format, ...)
|
||||
cannot be translated into Pascal.
|
||||
|
||||
|
||||
Legal issues
|
||||
============
|
||||
|
||||
The zlibpas interface is:
|
||||
Copyright (C) 1995-2003 Jean-loup Gailly and Mark Adler.
|
||||
Copyright (C) 1998 by Bob Dellaca.
|
||||
Copyright (C) 2003 by Cosmin Truta.
|
||||
|
||||
The example program is:
|
||||
Copyright (C) 1995-2003 by Jean-loup Gailly.
|
||||
Copyright (C) 1998,1999,2000 by Jacques Nomssi Nzali.
|
||||
Copyright (C) 2003 by Cosmin Truta.
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the author be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
|
||||
|
|
@ -1,93 +0,0 @@
|
|||
# Makefile for zlib
|
||||
# For use with Delphi and C++ Builder under Win32
|
||||
# Updated for zlib 1.2.x by Cosmin Truta
|
||||
|
||||
# ------------ Borland C++ ------------
|
||||
|
||||
# This project uses the Delphi (fastcall/register) calling convention:
|
||||
LOC = -DZEXPORT=__fastcall -DZEXPORTVA=__cdecl
|
||||
|
||||
CC = bcc32
|
||||
LD = bcc32
|
||||
AR = tlib
|
||||
# do not use "-pr" in CFLAGS
|
||||
CFLAGS = -a -d -k- -O2 $(LOC)
|
||||
LDFLAGS =
|
||||
|
||||
|
||||
# variables
|
||||
ZLIB_LIB = zlib.lib
|
||||
|
||||
OBJ1 = adler32.obj compress.obj crc32.obj deflate.obj gzio.obj infback.obj
|
||||
OBJ2 = inffast.obj inflate.obj inftrees.obj trees.obj uncompr.obj zutil.obj
|
||||
OBJP1 = +adler32.obj+compress.obj+crc32.obj+deflate.obj+gzio.obj+infback.obj
|
||||
OBJP2 = +inffast.obj+inflate.obj+inftrees.obj+trees.obj+uncompr.obj+zutil.obj
|
||||
|
||||
|
||||
# targets
|
||||
all: $(ZLIB_LIB) example.exe minigzip.exe
|
||||
|
||||
.c.obj:
|
||||
$(CC) -c $(CFLAGS) $*.c
|
||||
|
||||
adler32.obj: adler32.c zlib.h zconf.h
|
||||
|
||||
compress.obj: compress.c zlib.h zconf.h
|
||||
|
||||
crc32.obj: crc32.c zlib.h zconf.h crc32.h
|
||||
|
||||
deflate.obj: deflate.c deflate.h zutil.h zlib.h zconf.h
|
||||
|
||||
gzio.obj: gzio.c zutil.h zlib.h zconf.h
|
||||
|
||||
infback.obj: infback.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
|
||||
inffast.h inffixed.h
|
||||
|
||||
inffast.obj: inffast.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
|
||||
inffast.h
|
||||
|
||||
inflate.obj: inflate.c zutil.h zlib.h zconf.h inftrees.h inflate.h \
|
||||
inffast.h inffixed.h
|
||||
|
||||
inftrees.obj: inftrees.c zutil.h zlib.h zconf.h inftrees.h
|
||||
|
||||
trees.obj: trees.c zutil.h zlib.h zconf.h deflate.h trees.h
|
||||
|
||||
uncompr.obj: uncompr.c zlib.h zconf.h
|
||||
|
||||
zutil.obj: zutil.c zutil.h zlib.h zconf.h
|
||||
|
||||
example.obj: example.c zlib.h zconf.h
|
||||
|
||||
minigzip.obj: minigzip.c zlib.h zconf.h
|
||||
|
||||
|
||||
# For the sake of the old Borland make,
|
||||
# the command line is cut to fit in the MS-DOS 128 byte limit:
|
||||
$(ZLIB_LIB): $(OBJ1) $(OBJ2)
|
||||
-del $(ZLIB_LIB)
|
||||
$(AR) $(ZLIB_LIB) $(OBJP1)
|
||||
$(AR) $(ZLIB_LIB) $(OBJP2)
|
||||
|
||||
|
||||
# testing
|
||||
test: example.exe minigzip.exe
|
||||
example
|
||||
echo hello world | minigzip | minigzip -d
|
||||
|
||||
example.exe: example.obj $(ZLIB_LIB)
|
||||
$(LD) $(LDFLAGS) example.obj $(ZLIB_LIB)
|
||||
|
||||
minigzip.exe: minigzip.obj $(ZLIB_LIB)
|
||||
$(LD) $(LDFLAGS) minigzip.obj $(ZLIB_LIB)
|
||||
|
||||
|
||||
# cleanup
|
||||
clean:
|
||||
-del *.obj
|
||||
-del *.exe
|
||||
-del *.lib
|
||||
-del *.tds
|
||||
-del zlib.bak
|
||||
-del foo.gz
|
||||
|
||||
|
|
@ -1,236 +0,0 @@
|
|||
(* zlibpas -- Pascal interface to the zlib data compression library
|
||||
*
|
||||
* Copyright (C) 2003 Cosmin Truta.
|
||||
* Derived from original sources by Bob Dellaca.
|
||||
* For conditions of distribution and use, see copyright notice in readme.txt
|
||||
*)
|
||||
|
||||
unit zlibpas;
|
||||
|
||||
interface
|
||||
|
||||
const
|
||||
ZLIB_VERSION = '1.2.1';
|
||||
|
||||
type
|
||||
alloc_func = function(opaque: Pointer; items, size: Integer): Pointer;
|
||||
cdecl;
|
||||
free_func = procedure(opaque, address: Pointer);
|
||||
cdecl;
|
||||
|
||||
in_func = function(opaque: Pointer; var buf: PByte): Integer;
|
||||
cdecl;
|
||||
out_func = function(opaque: Pointer; buf: PByte; size: Integer): Integer;
|
||||
cdecl;
|
||||
|
||||
z_streamp = ^z_stream;
|
||||
z_stream = packed record
|
||||
next_in: PChar; (* next input byte *)
|
||||
avail_in: Integer; (* number of bytes available at next_in *)
|
||||
total_in: LongInt; (* total nb of input bytes read so far *)
|
||||
|
||||
next_out: PChar; (* next output byte should be put there *)
|
||||
avail_out: Integer; (* remaining free space at next_out *)
|
||||
total_out: LongInt; (* total nb of bytes output so far *)
|
||||
|
||||
msg: PChar; (* last error message, NULL if no error *)
|
||||
state: Pointer; (* not visible by applications *)
|
||||
|
||||
zalloc: alloc_func; (* used to allocate the internal state *)
|
||||
zfree: free_func; (* used to free the internal state *)
|
||||
opaque: Pointer; (* private data object passed to zalloc and zfree *)
|
||||
|
||||
data_type: Integer; (* best guess about the data type: ascii or binary *)
|
||||
adler: LongInt; (* adler32 value of the uncompressed data *)
|
||||
reserved: LongInt; (* reserved for future use *)
|
||||
end;
|
||||
|
||||
(* constants *)
|
||||
const
|
||||
Z_NO_FLUSH = 0;
|
||||
Z_PARTIAL_FLUSH = 1;
|
||||
Z_SYNC_FLUSH = 2;
|
||||
Z_FULL_FLUSH = 3;
|
||||
Z_FINISH = 4;
|
||||
|
||||
Z_OK = 0;
|
||||
Z_STREAM_END = 1;
|
||||
Z_NEED_DICT = 2;
|
||||
Z_ERRNO = -1;
|
||||
Z_STREAM_ERROR = -2;
|
||||
Z_DATA_ERROR = -3;
|
||||
Z_MEM_ERROR = -4;
|
||||
Z_BUF_ERROR = -5;
|
||||
Z_VERSION_ERROR = -6;
|
||||
|
||||
Z_NO_COMPRESSION = 0;
|
||||
Z_BEST_SPEED = 1;
|
||||
Z_BEST_COMPRESSION = 9;
|
||||
Z_DEFAULT_COMPRESSION = -1;
|
||||
|
||||
Z_FILTERED = 1;
|
||||
Z_HUFFMAN_ONLY = 2;
|
||||
Z_RLE = 3;
|
||||
Z_DEFAULT_STRATEGY = 0;
|
||||
|
||||
Z_BINARY = 0;
|
||||
Z_ASCII = 1;
|
||||
Z_UNKNOWN = 2;
|
||||
|
||||
Z_DEFLATED = 8;
|
||||
|
||||
(* basic functions *)
|
||||
function zlibVersion: PChar;
|
||||
function deflateInit(var strm: z_stream; level: Integer): Integer;
|
||||
function deflate(var strm: z_stream; flush: Integer): Integer;
|
||||
function deflateEnd(var strm: z_stream): Integer;
|
||||
function inflateInit(var strm: z_stream): Integer;
|
||||
function inflate(var strm: z_stream; flush: Integer): Integer;
|
||||
function inflateEnd(var strm: z_stream): Integer;
|
||||
|
||||
(* advanced functions *)
|
||||
function deflateInit2(var strm: z_stream; level, method, windowBits,
|
||||
memLevel, strategy: Integer): Integer;
|
||||
function deflateSetDictionary(var strm: z_stream; const dictionary: PChar;
|
||||
dictLength: Integer): Integer;
|
||||
function deflateCopy(var dest, source: z_stream): Integer;
|
||||
function deflateReset(var strm: z_stream): Integer;
|
||||
function deflateParams(var strm: z_stream; level, strategy: Integer): Integer;
|
||||
function deflateBound(var strm: z_stream; sourceLen: LongInt): LongInt;
|
||||
function deflatePrime(var strm: z_stream; bits, value: Integer): Integer;
|
||||
function inflateInit2(var strm: z_stream; windowBits: Integer): Integer;
|
||||
function inflateSetDictionary(var strm: z_stream; const dictionary: PChar;
|
||||
dictLength: Integer): Integer;
|
||||
function inflateSync(var strm: z_stream): Integer;
|
||||
function inflateCopy(var dest, source: z_stream): Integer;
|
||||
function inflateReset(var strm: z_stream): Integer;
|
||||
function inflateBackInit(var strm: z_stream;
|
||||
windowBits: Integer; window: PChar): Integer;
|
||||
function inflateBack(var strm: z_stream; in_fn: in_func; in_desc: Pointer;
|
||||
out_fn: out_func; out_desc: Pointer): Integer;
|
||||
function inflateBackEnd(var strm: z_stream): Integer;
|
||||
function zlibCompileFlags: LongInt;
|
||||
|
||||
(* utility functions *)
|
||||
function compress(dest: PChar; var destLen: LongInt;
|
||||
const source: PChar; sourceLen: LongInt): Integer;
|
||||
function compress2(dest: PChar; var destLen: LongInt;
|
||||
const source: PChar; sourceLen: LongInt;
|
||||
level: Integer): Integer;
|
||||
function compressBound(sourceLen: LongInt): LongInt;
|
||||
function uncompress(dest: PChar; var destLen: LongInt;
|
||||
const source: PChar; sourceLen: LongInt): Integer;
|
||||
|
||||
(* checksum functions *)
|
||||
function adler32(adler: LongInt; const buf: PChar; len: Integer): LongInt;
|
||||
function crc32(crc: LongInt; const buf: PChar; len: Integer): LongInt;
|
||||
|
||||
(* various hacks, don't look :) *)
|
||||
function deflateInit_(var strm: z_stream; level: Integer;
|
||||
const version: PChar; stream_size: Integer): Integer;
|
||||
function inflateInit_(var strm: z_stream; const version: PChar;
|
||||
stream_size: Integer): Integer;
|
||||
function deflateInit2_(var strm: z_stream;
|
||||
level, method, windowBits, memLevel, strategy: Integer;
|
||||
const version: PChar; stream_size: Integer): Integer;
|
||||
function inflateInit2_(var strm: z_stream; windowBits: Integer;
|
||||
const version: PChar; stream_size: Integer): Integer;
|
||||
function inflateBackInit_(var strm: z_stream;
|
||||
windowBits: Integer; window: PChar;
|
||||
const version: PChar; stream_size: Integer): Integer;
|
||||
|
||||
|
||||
implementation
|
||||
|
||||
{$L adler32.obj}
|
||||
{$L compress.obj}
|
||||
{$L crc32.obj}
|
||||
{$L deflate.obj}
|
||||
{$L infback.obj}
|
||||
{$L inffast.obj}
|
||||
{$L inflate.obj}
|
||||
{$L inftrees.obj}
|
||||
{$L trees.obj}
|
||||
{$L uncompr.obj}
|
||||
{$L zutil.obj}
|
||||
|
||||
function adler32; external;
|
||||
function compress; external;
|
||||
function compress2; external;
|
||||
function compressBound; external;
|
||||
function crc32; external;
|
||||
function deflate; external;
|
||||
function deflateBound; external;
|
||||
function deflateCopy; external;
|
||||
function deflateEnd; external;
|
||||
function deflateInit_; external;
|
||||
function deflateInit2_; external;
|
||||
function deflateParams; external;
|
||||
function deflatePrime; external;
|
||||
function deflateReset; external;
|
||||
function deflateSetDictionary; external;
|
||||
function inflate; external;
|
||||
function inflateBack; external;
|
||||
function inflateBackEnd; external;
|
||||
function inflateBackInit_; external;
|
||||
function inflateCopy; external;
|
||||
function inflateEnd; external;
|
||||
function inflateInit_; external;
|
||||
function inflateInit2_; external;
|
||||
function inflateReset; external;
|
||||
function inflateSetDictionary; external;
|
||||
function inflateSync; external;
|
||||
function uncompress; external;
|
||||
function zlibCompileFlags; external;
|
||||
function zlibVersion; external;
|
||||
|
||||
function deflateInit(var strm: z_stream; level: Integer): Integer;
|
||||
begin
|
||||
Result := deflateInit_(strm, level, ZLIB_VERSION, sizeof(z_stream));
|
||||
end;
|
||||
|
||||
function deflateInit2(var strm: z_stream; level, method, windowBits, memLevel,
|
||||
strategy: Integer): Integer;
|
||||
begin
|
||||
Result := deflateInit2_(strm, level, method, windowBits, memLevel, strategy,
|
||||
ZLIB_VERSION, sizeof(z_stream));
|
||||
end;
|
||||
|
||||
function inflateInit(var strm: z_stream): Integer;
|
||||
begin
|
||||
Result := inflateInit_(strm, ZLIB_VERSION, sizeof(z_stream));
|
||||
end;
|
||||
|
||||
function inflateInit2(var strm: z_stream; windowBits: Integer): Integer;
|
||||
begin
|
||||
Result := inflateInit2_(strm, windowBits, ZLIB_VERSION, sizeof(z_stream));
|
||||
end;
|
||||
|
||||
function inflateBackInit(var strm: z_stream;
|
||||
windowBits: Integer; window: PChar): Integer;
|
||||
begin
|
||||
Result := inflateBackInit_(strm, windowBits, window,
|
||||
ZLIB_VERSION, sizeof(z_stream));
|
||||
end;
|
||||
|
||||
function _malloc(Size: Integer): Pointer; cdecl;
|
||||
begin
|
||||
GetMem(Result, Size);
|
||||
end;
|
||||
|
||||
procedure _free(Block: Pointer); cdecl;
|
||||
begin
|
||||
FreeMem(Block);
|
||||
end;
|
||||
|
||||
procedure _memset(P: Pointer; B: Byte; count: Integer); cdecl;
|
||||
begin
|
||||
FillChar(P^, count, B);
|
||||
end;
|
||||
|
||||
procedure _memcpy(dest, source: Pointer; count: Integer); cdecl;
|
||||
begin
|
||||
Move(source^, dest^, count);
|
||||
end;
|
||||
|
||||
end.
|
||||
|
|
@ -1,8 +0,0 @@
|
|||
puff: puff.c puff.h
|
||||
cc -DTEST -o puff puff.c
|
||||
|
||||
test: puff
|
||||
puff zeros.raw
|
||||
|
||||
clean:
|
||||
rm -f puff puff.o
|
||||
|
|
@ -1,63 +0,0 @@
|
|||
Puff -- A Simple Inflate
|
||||
3 Mar 2003
|
||||
Mark Adler
|
||||
madler@alumni.caltech.edu
|
||||
|
||||
What this is --
|
||||
|
||||
puff.c provides the routine puff() to decompress the deflate data format. It
|
||||
does so more slowly than zlib, but the code is about one-fifth the size of the
|
||||
inflate code in zlib, and written to be very easy to read.
|
||||
|
||||
Why I wrote this --
|
||||
|
||||
puff.c was written to document the deflate format unambiguously, by virtue of
|
||||
being working C code. It is meant to supplement RFC 1951, which formally
|
||||
describes the deflate format. I have received many questions on details of the
|
||||
deflate format, and I hope that reading this code will answer those questions.
|
||||
puff.c is heavily commented with details of the deflate format, especially
|
||||
those little nooks and cranies of the format that might not be obvious from a
|
||||
specification.
|
||||
|
||||
puff.c may also be useful in applications where code size or memory usage is a
|
||||
very limited resource, and speed is not as important.
|
||||
|
||||
How to use it --
|
||||
|
||||
Well, most likely you should just be reading puff.c and using zlib for actual
|
||||
applications, but if you must ...
|
||||
|
||||
Include puff.h in your code, which provides this prototype:
|
||||
|
||||
int puff(unsigned char *dest, /* pointer to destination pointer */
|
||||
unsigned long *destlen, /* amount of output space */
|
||||
unsigned char *source, /* pointer to source data pointer */
|
||||
unsigned long *sourcelen); /* amount of input available */
|
||||
|
||||
Then you can call puff() to decompress a deflate stream that is in memory in
|
||||
its entirety at source, to a sufficiently sized block of memory for the
|
||||
decompressed data at dest. puff() is the only external symbol in puff.c The
|
||||
only C library functions that puff.c needs are setjmp() and longjmp(), which
|
||||
are used to simplify error checking in the code to improve readabilty. puff.c
|
||||
does no memory allocation, and uses less than 2K bytes off of the stack.
|
||||
|
||||
If destlen is not enough space for the uncompressed data, then inflate will
|
||||
return an error without writing more than destlen bytes. Note that this means
|
||||
that in order to decompress the deflate data successfully, you need to know
|
||||
the size of the uncompressed data ahead of time.
|
||||
|
||||
If needed, puff() can determine the size of the uncompressed data with no
|
||||
output space. This is done by passing dest equal to (unsigned char *)0. Then
|
||||
the initial value of *destlen is ignored and *destlen is set to the length of
|
||||
the uncompressed data. So if the size of the uncompressed data is not known,
|
||||
then two passes of puff() can be used--first to determine the size, and second
|
||||
to do the actual inflation after allocating the appropriate memory. Not
|
||||
pretty, but it works. (This is one of the reasons you should be using zlib.)
|
||||
|
||||
The deflate format is self-terminating. If the deflate stream does not end
|
||||
in *sourcelen bytes, puff() will return an error without reading at or past
|
||||
endsource.
|
||||
|
||||
On return, *sourcelen is updated to the amount of input data consumed, and
|
||||
*destlen is updated to the size of the uncompressed data. See the comments
|
||||
in puff.c for the possible return codes for puff().
|
||||
|
|
@ -1,833 +0,0 @@
|
|||
/*
|
||||
* puff.c
|
||||
* Copyright (C) 2002, 2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in puff.h
|
||||
* version 1.7, 3 Mar 2003
|
||||
*
|
||||
* puff.c is a simple inflate written to be an unambiguous way to specify the
|
||||
* deflate format. It is not written for speed but rather simplicity. As a
|
||||
* side benefit, this code might actually be useful when small code is more
|
||||
* important than speed, such as bootstrap applications. For typical deflate
|
||||
* data, zlib's inflate() is about four times as fast as puff(). zlib's
|
||||
* inflate compiles to around 20K on my machine, whereas puff.c compiles to
|
||||
* around 4K on my machine (a PowerPC using GNU cc). If the faster decode()
|
||||
* function here is used, then puff() is only twice as slow as zlib's
|
||||
* inflate().
|
||||
*
|
||||
* All dynamically allocated memory comes from the stack. The stack required
|
||||
* is less than 2K bytes. This code is compatible with 16-bit int's and
|
||||
* assumes that long's are at least 32 bits. puff.c uses the short data type,
|
||||
* assumed to be 16 bits, for arrays in order to to conserve memory. The code
|
||||
* works whether integers are stored big endian or little endian.
|
||||
*
|
||||
* In the comments below are "Format notes" that describe the inflate process
|
||||
* and document some of the less obvious aspects of the format. This source
|
||||
* code is meant to supplement RFC 1951, which formally describes the deflate
|
||||
* format:
|
||||
*
|
||||
* http://www.zlib.org/rfc-deflate.html
|
||||
*/
|
||||
|
||||
/*
|
||||
* Change history:
|
||||
*
|
||||
* 1.0 10 Feb 2002 - First version
|
||||
* 1.1 17 Feb 2002 - Clarifications of some comments and notes
|
||||
* - Update puff() dest and source pointers on negative
|
||||
* errors to facilitate debugging deflators
|
||||
* - Remove longest from struct huffman -- not needed
|
||||
* - Simplify offs[] index in construct()
|
||||
* - Add input size and checking, using longjmp() to
|
||||
* maintain easy readability
|
||||
* - Use short data type for large arrays
|
||||
* - Use pointers instead of long to specify source and
|
||||
* destination sizes to avoid arbitrary 4 GB limits
|
||||
* 1.2 17 Mar 2002 - Add faster version of decode(), doubles speed (!),
|
||||
* but leave simple version for readabilty
|
||||
* - Make sure invalid distances detected if pointers
|
||||
* are 16 bits
|
||||
* - Fix fixed codes table error
|
||||
* - Provide a scanning mode for determining size of
|
||||
* uncompressed data
|
||||
* 1.3 20 Mar 2002 - Go back to lengths for puff() parameters [Jean-loup]
|
||||
* - Add a puff.h file for the interface
|
||||
* - Add braces in puff() for else do [Jean-loup]
|
||||
* - Use indexes instead of pointers for readability
|
||||
* 1.4 31 Mar 2002 - Simplify construct() code set check
|
||||
* - Fix some comments
|
||||
* - Add FIXLCODES #define
|
||||
* 1.5 6 Apr 2002 - Minor comment fixes
|
||||
* 1.6 7 Aug 2002 - Minor format changes
|
||||
* 1.7 3 Mar 2003 - Added test code for distribution
|
||||
* - Added zlib-like license
|
||||
*/
|
||||
|
||||
#include <setjmp.h> /* for setjmp(), longjmp(), and jmp_buf */
|
||||
#include "puff.h" /* prototype for puff() */
|
||||
|
||||
#define local static /* for local function definitions */
|
||||
#define NIL ((unsigned char *)0) /* for no output option */
|
||||
|
||||
/*
|
||||
* Maximums for allocations and loops. It is not useful to change these --
|
||||
* they are fixed by the deflate format.
|
||||
*/
|
||||
#define MAXBITS 15 /* maximum bits in a code */
|
||||
#define MAXLCODES 286 /* maximum number of literal/length codes */
|
||||
#define MAXDCODES 30 /* maximum number of distance codes */
|
||||
#define MAXCODES (MAXLCODES+MAXDCODES) /* maximum codes lengths to read */
|
||||
#define FIXLCODES 288 /* number of fixed literal/length codes */
|
||||
|
||||
/* input and output state */
|
||||
struct state {
|
||||
/* output state */
|
||||
unsigned char *out; /* output buffer */
|
||||
unsigned long outlen; /* available space at out */
|
||||
unsigned long outcnt; /* bytes written to out so far */
|
||||
|
||||
/* input state */
|
||||
unsigned char *in; /* input buffer */
|
||||
unsigned long inlen; /* available input at in */
|
||||
unsigned long incnt; /* bytes read so far */
|
||||
int bitbuf; /* bit buffer */
|
||||
int bitcnt; /* number of bits in bit buffer */
|
||||
|
||||
/* input limit error return state for bits() and decode() */
|
||||
jmp_buf env;
|
||||
};
|
||||
|
||||
/*
|
||||
* Return need bits from the input stream. This always leaves less than
|
||||
* eight bits in the buffer. bits() works properly for need == 0.
|
||||
*
|
||||
* Format notes:
|
||||
*
|
||||
* - Bits are stored in bytes from the least significant bit to the most
|
||||
* significant bit. Therefore bits are dropped from the bottom of the bit
|
||||
* buffer, using shift right, and new bytes are appended to the top of the
|
||||
* bit buffer, using shift left.
|
||||
*/
|
||||
local int bits(struct state *s, int need)
|
||||
{
|
||||
long val; /* bit accumulator (can use up to 20 bits) */
|
||||
|
||||
/* load at least need bits into val */
|
||||
val = s->bitbuf;
|
||||
while (s->bitcnt < need) {
|
||||
if (s->incnt == s->inlen) longjmp(s->env, 1); /* out of input */
|
||||
val |= (long)(s->in[s->incnt++]) << s->bitcnt; /* load eight bits */
|
||||
s->bitcnt += 8;
|
||||
}
|
||||
|
||||
/* drop need bits and update buffer, always zero to seven bits left */
|
||||
s->bitbuf = (int)(val >> need);
|
||||
s->bitcnt -= need;
|
||||
|
||||
/* return need bits, zeroing the bits above that */
|
||||
return (int)(val & ((1L << need) - 1));
|
||||
}
|
||||
|
||||
/*
|
||||
* Process a stored block.
|
||||
*
|
||||
* Format notes:
|
||||
*
|
||||
* - After the two-bit stored block type (00), the stored block length and
|
||||
* stored bytes are byte-aligned for fast copying. Therefore any leftover
|
||||
* bits in the byte that has the last bit of the type, as many as seven, are
|
||||
* discarded. The value of the discarded bits are not defined and should not
|
||||
* be checked against any expectation.
|
||||
*
|
||||
* - The second inverted copy of the stored block length does not have to be
|
||||
* checked, but it's probably a good idea to do so anyway.
|
||||
*
|
||||
* - A stored block can have zero length. This is sometimes used to byte-align
|
||||
* subsets of the compressed data for random access or partial recovery.
|
||||
*/
|
||||
local int stored(struct state *s)
|
||||
{
|
||||
unsigned len; /* length of stored block */
|
||||
|
||||
/* discard leftover bits from current byte (assumes s->bitcnt < 8) */
|
||||
s->bitbuf = 0;
|
||||
s->bitcnt = 0;
|
||||
|
||||
/* get length and check against its one's complement */
|
||||
if (s->incnt + 4 > s->inlen) return 2; /* not enough input */
|
||||
len = s->in[s->incnt++];
|
||||
len |= s->in[s->incnt++] << 8;
|
||||
if (s->in[s->incnt++] != (~len & 0xff) ||
|
||||
s->in[s->incnt++] != ((~len >> 8) & 0xff))
|
||||
return -2; /* didn't match complement! */
|
||||
|
||||
/* copy len bytes from in to out */
|
||||
if (s->incnt + len > s->inlen) return 2; /* not enough input */
|
||||
if (s->out != NIL) {
|
||||
if (s->outcnt + len > s->outlen)
|
||||
return 1; /* not enough output space */
|
||||
while (len--)
|
||||
s->out[s->outcnt++] = s->in[s->incnt++];
|
||||
}
|
||||
else { /* just scanning */
|
||||
s->outcnt += len;
|
||||
s->incnt += len;
|
||||
}
|
||||
|
||||
/* done with a valid stored block */
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Huffman code decoding tables. count[1..MAXBITS] is the number of symbols of
|
||||
* each length, which for a canonical code are stepped through in order.
|
||||
* symbol[] are the symbol values in canonical order, where the number of
|
||||
* entries is the sum of the counts in count[]. The decoding process can be
|
||||
* seen in the function decode() below.
|
||||
*/
|
||||
struct huffman {
|
||||
short *count; /* number of symbols of each length */
|
||||
short *symbol; /* canonically ordered symbols */
|
||||
};
|
||||
|
||||
/*
|
||||
* Decode a code from the stream s using huffman table h. Return the symbol or
|
||||
* a negative value if there is an error. If all of the lengths are zero, i.e.
|
||||
* an empty code, or if the code is incomplete and an invalid code is received,
|
||||
* then -9 is returned after reading MAXBITS bits.
|
||||
*
|
||||
* Format notes:
|
||||
*
|
||||
* - The codes as stored in the compressed data are bit-reversed relative to
|
||||
* a simple integer ordering of codes of the same lengths. Hence below the
|
||||
* bits are pulled from the compressed data one at a time and used to
|
||||
* build the code value reversed from what is in the stream in order to
|
||||
* permit simple integer comparisons for decoding. A table-based decoding
|
||||
* scheme (as used in zlib) does not need to do this reversal.
|
||||
*
|
||||
* - The first code for the shortest length is all zeros. Subsequent codes of
|
||||
* the same length are simply integer increments of the previous code. When
|
||||
* moving up a length, a zero bit is appended to the code. For a complete
|
||||
* code, the last code of the longest length will be all ones.
|
||||
*
|
||||
* - Incomplete codes are handled by this decoder, since they are permitted
|
||||
* in the deflate format. See the format notes for fixed() and dynamic().
|
||||
*/
|
||||
#ifdef SLOW
|
||||
local int decode(struct state *s, struct huffman *h)
|
||||
{
|
||||
int len; /* current number of bits in code */
|
||||
int code; /* len bits being decoded */
|
||||
int first; /* first code of length len */
|
||||
int count; /* number of codes of length len */
|
||||
int index; /* index of first code of length len in symbol table */
|
||||
|
||||
code = first = index = 0;
|
||||
for (len = 1; len <= MAXBITS; len++) {
|
||||
code |= bits(s, 1); /* get next bit */
|
||||
count = h->count[len];
|
||||
if (code < first + count) /* if length len, return symbol */
|
||||
return h->symbol[index + (code - first)];
|
||||
index += count; /* else update for next length */
|
||||
first += count;
|
||||
first <<= 1;
|
||||
code <<= 1;
|
||||
}
|
||||
return -9; /* ran out of codes */
|
||||
}
|
||||
|
||||
/*
|
||||
* A faster version of decode() for real applications of this code. It's not
|
||||
* as readable, but it makes puff() twice as fast. And it only makes the code
|
||||
* a few percent larger.
|
||||
*/
|
||||
#else /* !SLOW */
|
||||
local int decode(struct state *s, struct huffman *h)
|
||||
{
|
||||
int len; /* current number of bits in code */
|
||||
int code; /* len bits being decoded */
|
||||
int first; /* first code of length len */
|
||||
int count; /* number of codes of length len */
|
||||
int index; /* index of first code of length len in symbol table */
|
||||
int bitbuf; /* bits from stream */
|
||||
int left; /* bits left in next or left to process */
|
||||
short *next; /* next number of codes */
|
||||
|
||||
bitbuf = s->bitbuf;
|
||||
left = s->bitcnt;
|
||||
code = first = index = 0;
|
||||
len = 1;
|
||||
next = h->count + 1;
|
||||
while (1) {
|
||||
while (left--) {
|
||||
code |= bitbuf & 1;
|
||||
bitbuf >>= 1;
|
||||
count = *next++;
|
||||
if (code < first + count) { /* if length len, return symbol */
|
||||
s->bitbuf = bitbuf;
|
||||
s->bitcnt = (s->bitcnt - len) & 7;
|
||||
return h->symbol[index + (code - first)];
|
||||
}
|
||||
index += count; /* else update for next length */
|
||||
first += count;
|
||||
first <<= 1;
|
||||
code <<= 1;
|
||||
len++;
|
||||
}
|
||||
left = (MAXBITS+1) - len;
|
||||
if (left == 0) break;
|
||||
if (s->incnt == s->inlen) longjmp(s->env, 1); /* out of input */
|
||||
bitbuf = s->in[s->incnt++];
|
||||
if (left > 8) left = 8;
|
||||
}
|
||||
return -9; /* ran out of codes */
|
||||
}
|
||||
#endif /* SLOW */
|
||||
|
||||
/*
|
||||
* Given the list of code lengths length[0..n-1] representing a canonical
|
||||
* Huffman code for n symbols, construct the tables required to decode those
|
||||
* codes. Those tables are the number of codes of each length, and the symbols
|
||||
* sorted by length, retaining their original order within each length. The
|
||||
* return value is zero for a complete code set, negative for an over-
|
||||
* subscribed code set, and positive for an incomplete code set. The tables
|
||||
* can be used if the return value is zero or positive, but they cannot be used
|
||||
* if the return value is negative. If the return value is zero, it is not
|
||||
* possible for decode() using that table to return an error--any stream of
|
||||
* enough bits will resolve to a symbol. If the return value is positive, then
|
||||
* it is possible for decode() using that table to return an error for received
|
||||
* codes past the end of the incomplete lengths.
|
||||
*
|
||||
* Not used by decode(), but used for error checking, h->count[0] is the number
|
||||
* of the n symbols not in the code. So n - h->count[0] is the number of
|
||||
* codes. This is useful for checking for incomplete codes that have more than
|
||||
* one symbol, which is an error in a dynamic block.
|
||||
*
|
||||
* Assumption: for all i in 0..n-1, 0 <= length[i] <= MAXBITS
|
||||
* This is assured by the construction of the length arrays in dynamic() and
|
||||
* fixed() and is not verified by construct().
|
||||
*
|
||||
* Format notes:
|
||||
*
|
||||
* - Permitted and expected examples of incomplete codes are one of the fixed
|
||||
* codes and any code with a single symbol which in deflate is coded as one
|
||||
* bit instead of zero bits. See the format notes for fixed() and dynamic().
|
||||
*
|
||||
* - Within a given code length, the symbols are kept in ascending order for
|
||||
* the code bits definition.
|
||||
*/
|
||||
local int construct(struct huffman *h, short *length, int n)
|
||||
{
|
||||
int symbol; /* current symbol when stepping through length[] */
|
||||
int len; /* current length when stepping through h->count[] */
|
||||
int left; /* number of possible codes left of current length */
|
||||
short offs[MAXBITS+1]; /* offsets in symbol table for each length */
|
||||
|
||||
/* count number of codes of each length */
|
||||
for (len = 0; len <= MAXBITS; len++)
|
||||
h->count[len] = 0;
|
||||
for (symbol = 0; symbol < n; symbol++)
|
||||
(h->count[length[symbol]])++; /* assumes lengths are within bounds */
|
||||
if (h->count[0] == n) /* no codes! */
|
||||
return 0; /* complete, but decode() will fail */
|
||||
|
||||
/* check for an over-subscribed or incomplete set of lengths */
|
||||
left = 1; /* one possible code of zero length */
|
||||
for (len = 1; len <= MAXBITS; len++) {
|
||||
left <<= 1; /* one more bit, double codes left */
|
||||
left -= h->count[len]; /* deduct count from possible codes */
|
||||
if (left < 0) return left; /* over-subscribed--return negative */
|
||||
} /* left > 0 means incomplete */
|
||||
|
||||
/* generate offsets into symbol table for each length for sorting */
|
||||
offs[1] = 0;
|
||||
for (len = 1; len < MAXBITS; len++)
|
||||
offs[len + 1] = offs[len] + h->count[len];
|
||||
|
||||
/*
|
||||
* put symbols in table sorted by length, by symbol order within each
|
||||
* length
|
||||
*/
|
||||
for (symbol = 0; symbol < n; symbol++)
|
||||
if (length[symbol] != 0)
|
||||
h->symbol[offs[length[symbol]]++] = symbol;
|
||||
|
||||
/* return zero for complete set, positive for incomplete set */
|
||||
return left;
|
||||
}
|
||||
|
||||
/*
|
||||
* Decode literal/length and distance codes until an end-of-block code.
|
||||
*
|
||||
* Format notes:
|
||||
*
|
||||
* - Compressed data that is after the block type if fixed or after the code
|
||||
* description if dynamic is a combination of literals and length/distance
|
||||
* pairs terminated by and end-of-block code. Literals are simply Huffman
|
||||
* coded bytes. A length/distance pair is a coded length followed by a
|
||||
* coded distance to represent a string that occurs earlier in the
|
||||
* uncompressed data that occurs again at the current location.
|
||||
*
|
||||
* - Literals, lengths, and the end-of-block code are combined into a single
|
||||
* code of up to 286 symbols. They are 256 literals (0..255), 29 length
|
||||
* symbols (257..285), and the end-of-block symbol (256).
|
||||
*
|
||||
* - There are 256 possible lengths (3..258), and so 29 symbols are not enough
|
||||
* to represent all of those. Lengths 3..10 and 258 are in fact represented
|
||||
* by just a length symbol. Lengths 11..257 are represented as a symbol and
|
||||
* some number of extra bits that are added as an integer to the base length
|
||||
* of the length symbol. The number of extra bits is determined by the base
|
||||
* length symbol. These are in the static arrays below, lens[] for the base
|
||||
* lengths and lext[] for the corresponding number of extra bits.
|
||||
*
|
||||
* - The reason that 258 gets its own symbol is that the longest length is used
|
||||
* often in highly redundant files. Note that 258 can also be coded as the
|
||||
* base value 227 plus the maximum extra value of 31. While a good deflate
|
||||
* should never do this, it is not an error, and should be decoded properly.
|
||||
*
|
||||
* - If a length is decoded, including its extra bits if any, then it is
|
||||
* followed a distance code. There are up to 30 distance symbols. Again
|
||||
* there are many more possible distances (1..32768), so extra bits are added
|
||||
* to a base value represented by the symbol. The distances 1..4 get their
|
||||
* own symbol, but the rest require extra bits. The base distances and
|
||||
* corresponding number of extra bits are below in the static arrays dist[]
|
||||
* and dext[].
|
||||
*
|
||||
* - Literal bytes are simply written to the output. A length/distance pair is
|
||||
* an instruction to copy previously uncompressed bytes to the output. The
|
||||
* copy is from distance bytes back in the output stream, copying for length
|
||||
* bytes.
|
||||
*
|
||||
* - Distances pointing before the beginning of the output data are not
|
||||
* permitted.
|
||||
*
|
||||
* - Overlapped copies, where the length is greater than the distance, are
|
||||
* allowed and common. For example, a distance of one and a length of 258
|
||||
* simply copies the last byte 258 times. A distance of four and a length of
|
||||
* twelve copies the last four bytes three times. A simple forward copy
|
||||
* ignoring whether the length is greater than the distance or not implements
|
||||
* this correctly. You should not use memcpy() since its behavior is not
|
||||
* defined for overlapped arrays. You should not use memmove() or bcopy()
|
||||
* since though their behavior -is- defined for overlapping arrays, it is
|
||||
* defined to do the wrong thing in this case.
|
||||
*/
|
||||
local int codes(struct state *s,
|
||||
struct huffman *lencode,
|
||||
struct huffman *distcode)
|
||||
{
|
||||
int symbol; /* decoded symbol */
|
||||
int len; /* length for copy */
|
||||
unsigned dist; /* distance for copy */
|
||||
static const short lens[29] = { /* Size base for length codes 257..285 */
|
||||
3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31,
|
||||
35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258};
|
||||
static const short lext[29] = { /* Extra bits for length codes 257..285 */
|
||||
0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2,
|
||||
3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0};
|
||||
static const short dists[30] = { /* Offset base for distance codes 0..29 */
|
||||
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193,
|
||||
257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145,
|
||||
8193, 12289, 16385, 24577};
|
||||
static const short dext[30] = { /* Extra bits for distance codes 0..29 */
|
||||
0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6,
|
||||
7, 7, 8, 8, 9, 9, 10, 10, 11, 11,
|
||||
12, 12, 13, 13};
|
||||
|
||||
/* decode literals and length/distance pairs */
|
||||
do {
|
||||
symbol = decode(s, lencode);
|
||||
if (symbol < 0) return symbol; /* invalid symbol */
|
||||
if (symbol < 256) { /* literal: symbol is the byte */
|
||||
/* write out the literal */
|
||||
if (s->out != NIL) {
|
||||
if (s->outcnt == s->outlen) return 1;
|
||||
s->out[s->outcnt] = symbol;
|
||||
}
|
||||
s->outcnt++;
|
||||
}
|
||||
else if (symbol > 256) { /* length */
|
||||
/* get and compute length */
|
||||
symbol -= 257;
|
||||
if (symbol >= 29) return -9; /* invalid fixed code */
|
||||
len = lens[symbol] + bits(s, lext[symbol]);
|
||||
|
||||
/* get and check distance */
|
||||
symbol = decode(s, distcode);
|
||||
if (symbol < 0) return symbol; /* invalid symbol */
|
||||
dist = dists[symbol] + bits(s, dext[symbol]);
|
||||
if (dist > s->outcnt)
|
||||
return -10; /* distance too far back */
|
||||
|
||||
/* copy length bytes from distance bytes back */
|
||||
if (s->out != NIL) {
|
||||
if (s->outcnt + len > s->outlen) return 1;
|
||||
while (len--) {
|
||||
s->out[s->outcnt] = s->out[s->outcnt - dist];
|
||||
s->outcnt++;
|
||||
}
|
||||
}
|
||||
else
|
||||
s->outcnt += len;
|
||||
}
|
||||
} while (symbol != 256); /* end of block symbol */
|
||||
|
||||
/* done with a valid fixed or dynamic block */
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
* Process a fixed codes block.
|
||||
*
|
||||
* Format notes:
|
||||
*
|
||||
* - This block type can be useful for compressing small amounts of data for
|
||||
* which the size of the code descriptions in a dynamic block exceeds the
|
||||
* benefit of custom codes for that block. For fixed codes, no bits are
|
||||
* spent on code descriptions. Instead the code lengths for literal/length
|
||||
* codes and distance codes are fixed. The specific lengths for each symbol
|
||||
* can be seen in the "for" loops below.
|
||||
*
|
||||
* - The literal/length code is complete, but has two symbols that are invalid
|
||||
* and should result in an error if received. This cannot be implemented
|
||||
* simply as an incomplete code since those two symbols are in the "middle"
|
||||
* of the code. They are eight bits long and the longest literal/length\
|
||||
* code is nine bits. Therefore the code must be constructed with those
|
||||
* symbols, and the invalid symbols must be detected after decoding.
|
||||
*
|
||||
* - The fixed distance codes also have two invalid symbols that should result
|
||||
* in an error if received. Since all of the distance codes are the same
|
||||
* length, this can be implemented as an incomplete code. Then the invalid
|
||||
* codes are detected while decoding.
|
||||
*/
|
||||
local int fixed(struct state *s)
|
||||
{
|
||||
static int virgin = 1;
|
||||
static short lencnt[MAXBITS+1], lensym[FIXLCODES];
|
||||
static short distcnt[MAXBITS+1], distsym[MAXDCODES];
|
||||
static struct huffman lencode = {lencnt, lensym};
|
||||
static struct huffman distcode = {distcnt, distsym};
|
||||
|
||||
/* build fixed huffman tables if first call (may not be thread safe) */
|
||||
if (virgin) {
|
||||
int symbol;
|
||||
short lengths[FIXLCODES];
|
||||
|
||||
/* literal/length table */
|
||||
for (symbol = 0; symbol < 144; symbol++)
|
||||
lengths[symbol] = 8;
|
||||
for (; symbol < 256; symbol++)
|
||||
lengths[symbol] = 9;
|
||||
for (; symbol < 280; symbol++)
|
||||
lengths[symbol] = 7;
|
||||
for (; symbol < FIXLCODES; symbol++)
|
||||
lengths[symbol] = 8;
|
||||
construct(&lencode, lengths, FIXLCODES);
|
||||
|
||||
/* distance table */
|
||||
for (symbol = 0; symbol < MAXDCODES; symbol++)
|
||||
lengths[symbol] = 5;
|
||||
construct(&distcode, lengths, MAXDCODES);
|
||||
|
||||
/* do this just once */
|
||||
virgin = 0;
|
||||
}
|
||||
|
||||
/* decode data until end-of-block code */
|
||||
return codes(s, &lencode, &distcode);
|
||||
}
|
||||
|
||||
/*
|
||||
* Process a dynamic codes block.
|
||||
*
|
||||
* Format notes:
|
||||
*
|
||||
* - A dynamic block starts with a description of the literal/length and
|
||||
* distance codes for that block. New dynamic blocks allow the compressor to
|
||||
* rapidly adapt to changing data with new codes optimized for that data.
|
||||
*
|
||||
* - The codes used by the deflate format are "canonical", which means that
|
||||
* the actual bits of the codes are generated in an unambiguous way simply
|
||||
* from the number of bits in each code. Therefore the code descriptions
|
||||
* are simply a list of code lengths for each symbol.
|
||||
*
|
||||
* - The code lengths are stored in order for the symbols, so lengths are
|
||||
* provided for each of the literal/length symbols, and for each of the
|
||||
* distance symbols.
|
||||
*
|
||||
* - If a symbol is not used in the block, this is represented by a zero as
|
||||
* as the code length. This does not mean a zero-length code, but rather
|
||||
* that no code should be created for this symbol. There is no way in the
|
||||
* deflate format to represent a zero-length code.
|
||||
*
|
||||
* - The maximum number of bits in a code is 15, so the possible lengths for
|
||||
* any code are 1..15.
|
||||
*
|
||||
* - The fact that a length of zero is not permitted for a code has an
|
||||
* interesting consequence. Normally if only one symbol is used for a given
|
||||
* code, then in fact that code could be represented with zero bits. However
|
||||
* in deflate, that code has to be at least one bit. So for example, if
|
||||
* only a single distance base symbol appears in a block, then it will be
|
||||
* represented by a single code of length one, in particular one 0 bit. This
|
||||
* is an incomplete code, since if a 1 bit is received, it has no meaning,
|
||||
* and should result in an error. So incomplete distance codes of one symbol
|
||||
* should be permitted, and the receipt of invalid codes should be handled.
|
||||
*
|
||||
* - It is also possible to have a single literal/length code, but that code
|
||||
* must be the end-of-block code, since every dynamic block has one. This
|
||||
* is not the most efficient way to create an empty block (an empty fixed
|
||||
* block is fewer bits), but it is allowed by the format. So incomplete
|
||||
* literal/length codes of one symbol should also be permitted.
|
||||
*
|
||||
* - The list of up to 286 length/literal lengths and up to 30 distance lengths
|
||||
* are themselves compressed using Huffman codes and run-length encoding. In
|
||||
* the list of code lengths, a 0 symbol means no code, a 1..15 symbol means
|
||||
* that length, and the symbols 16, 17, and 18 are run-length instructions.
|
||||
* Each of 16, 17, and 18 are follwed by extra bits to define the length of
|
||||
* the run. 16 copies the last length 3 to 6 times. 17 represents 3 to 10
|
||||
* zero lengths, and 18 represents 11 to 138 zero lengths. Unused symbols
|
||||
* are common, hence the special coding for zero lengths.
|
||||
*
|
||||
* - The symbols for 0..18 are Huffman coded, and so that code must be
|
||||
* described first. This is simply a sequence of up to 19 three-bit values
|
||||
* representing no code (0) or the code length for that symbol (1..7).
|
||||
*
|
||||
* - A dynamic block starts with three fixed-size counts from which is computed
|
||||
* the number of literal/length code lengths, the number of distance code
|
||||
* lengths, and the number of code length code lengths (ok, you come up with
|
||||
* a better name!) in the code descriptions. For the literal/length and
|
||||
* distance codes, lengths after those provided are considered zero, i.e. no
|
||||
* code. The code length code lengths are received in a permuted order (see
|
||||
* the order[] array below) to make a short code length code length list more
|
||||
* likely. As it turns out, very short and very long codes are less likely
|
||||
* to be seen in a dynamic code description, hence what may appear initially
|
||||
* to be a peculiar ordering.
|
||||
*
|
||||
* - Given the number of literal/length code lengths (nlen) and distance code
|
||||
* lengths (ndist), then they are treated as one long list of nlen + ndist
|
||||
* code lengths. Therefore run-length coding can and often does cross the
|
||||
* boundary between the two sets of lengths.
|
||||
*
|
||||
* - So to summarize, the code description at the start of a dynamic block is
|
||||
* three counts for the number of code lengths for the literal/length codes,
|
||||
* the distance codes, and the code length codes. This is followed by the
|
||||
* code length code lengths, three bits each. This is used to construct the
|
||||
* code length code which is used to read the remainder of the lengths. Then
|
||||
* the literal/length code lengths and distance lengths are read as a single
|
||||
* set of lengths using the code length codes. Codes are constructed from
|
||||
* the resulting two sets of lengths, and then finally you can start
|
||||
* decoding actual compressed data in the block.
|
||||
*
|
||||
* - For reference, a "typical" size for the code description in a dynamic
|
||||
* block is around 80 bytes.
|
||||
*/
|
||||
local int dynamic(struct state *s)
|
||||
{
|
||||
int nlen, ndist, ncode; /* number of lengths in descriptor */
|
||||
int index; /* index of lengths[] */
|
||||
int err; /* construct() return value */
|
||||
short lengths[MAXCODES]; /* descriptor code lengths */
|
||||
short lencnt[MAXBITS+1], lensym[MAXLCODES]; /* lencode memory */
|
||||
short distcnt[MAXBITS+1], distsym[MAXDCODES]; /* distcode memory */
|
||||
struct huffman lencode = {lencnt, lensym}; /* length code */
|
||||
struct huffman distcode = {distcnt, distsym}; /* distance code */
|
||||
static const short order[19] = /* permutation of code length codes */
|
||||
{16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15};
|
||||
|
||||
/* get number of lengths in each table, check lengths */
|
||||
nlen = bits(s, 5) + 257;
|
||||
ndist = bits(s, 5) + 1;
|
||||
ncode = bits(s, 4) + 4;
|
||||
if (nlen > MAXLCODES || ndist > MAXDCODES)
|
||||
return -3; /* bad counts */
|
||||
|
||||
/* read code length code lengths (really), missing lengths are zero */
|
||||
for (index = 0; index < ncode; index++)
|
||||
lengths[order[index]] = bits(s, 3);
|
||||
for (; index < 19; index++)
|
||||
lengths[order[index]] = 0;
|
||||
|
||||
/* build huffman table for code lengths codes (use lencode temporarily) */
|
||||
err = construct(&lencode, lengths, 19);
|
||||
if (err != 0) return -4; /* require complete code set here */
|
||||
|
||||
/* read length/literal and distance code length tables */
|
||||
index = 0;
|
||||
while (index < nlen + ndist) {
|
||||
int symbol; /* decoded value */
|
||||
int len; /* last length to repeat */
|
||||
|
||||
symbol = decode(s, &lencode);
|
||||
if (symbol < 16) /* length in 0..15 */
|
||||
lengths[index++] = symbol;
|
||||
else { /* repeat instruction */
|
||||
len = 0; /* assume repeating zeros */
|
||||
if (symbol == 16) { /* repeat last length 3..6 times */
|
||||
if (index == 0) return -5; /* no last length! */
|
||||
len = lengths[index - 1]; /* last length */
|
||||
symbol = 3 + bits(s, 2);
|
||||
}
|
||||
else if (symbol == 17) /* repeat zero 3..10 times */
|
||||
symbol = 3 + bits(s, 3);
|
||||
else /* == 18, repeat zero 11..138 times */
|
||||
symbol = 11 + bits(s, 7);
|
||||
if (index + symbol > nlen + ndist)
|
||||
return -6; /* too many lengths! */
|
||||
while (symbol--) /* repeat last or zero symbol times */
|
||||
lengths[index++] = len;
|
||||
}
|
||||
}
|
||||
|
||||
/* build huffman table for literal/length codes */
|
||||
err = construct(&lencode, lengths, nlen);
|
||||
if (err < 0 || (err > 0 && nlen - lencode.count[0] != 1))
|
||||
return -7; /* only allow incomplete codes if just one code */
|
||||
|
||||
/* build huffman table for distance codes */
|
||||
err = construct(&distcode, lengths + nlen, ndist);
|
||||
if (err < 0 || (err > 0 && ndist - distcode.count[0] != 1))
|
||||
return -8; /* only allow incomplete codes if just one code */
|
||||
|
||||
/* decode data until end-of-block code */
|
||||
return codes(s, &lencode, &distcode);
|
||||
}
|
||||
|
||||
/*
|
||||
* Inflate source to dest. On return, destlen and sourcelen are updated to the
|
||||
* size of the uncompressed data and the size of the deflate data respectively.
|
||||
* On success, the return value of puff() is zero. If there is an error in the
|
||||
* source data, i.e. it is not in the deflate format, then a negative value is
|
||||
* returned. If there is not enough input available or there is not enough
|
||||
* output space, then a positive error is returned. In that case, destlen and
|
||||
* sourcelen are not updated to facilitate retrying from the beginning with the
|
||||
* provision of more input data or more output space. In the case of invalid
|
||||
* inflate data (a negative error), the dest and source pointers are updated to
|
||||
* facilitate the debugging of deflators.
|
||||
*
|
||||
* puff() also has a mode to determine the size of the uncompressed output with
|
||||
* no output written. For this dest must be (unsigned char *)0. In this case,
|
||||
* the input value of *destlen is ignored, and on return *destlen is set to the
|
||||
* size of the uncompressed output.
|
||||
*
|
||||
* The return codes are:
|
||||
*
|
||||
* 2: available inflate data did not terminate
|
||||
* 1: output space exhausted before completing inflate
|
||||
* 0: successful inflate
|
||||
* -1: invalid block type (type == 3)
|
||||
* -2: stored block length did not match one's complement
|
||||
* -3: dynamic block code description: too many length or distance codes
|
||||
* -4: dynamic block code description: code lengths codes incomplete
|
||||
* -5: dynamic block code description: repeat lengths with no first length
|
||||
* -6: dynamic block code description: repeat more than specified lengths
|
||||
* -7: dynamic block code description: invalid literal/length code lengths
|
||||
* -8: dynamic block code description: invalid distance code lengths
|
||||
* -9: invalid literal/length or distance code in fixed or dynamic block
|
||||
* -10: distance is too far back in fixed or dynamic block
|
||||
*
|
||||
* Format notes:
|
||||
*
|
||||
* - Three bits are read for each block to determine the kind of block and
|
||||
* whether or not it is the last block. Then the block is decoded and the
|
||||
* process repeated if it was not the last block.
|
||||
*
|
||||
* - The leftover bits in the last byte of the deflate data after the last
|
||||
* block (if it was a fixed or dynamic block) are undefined and have no
|
||||
* expected values to check.
|
||||
*/
|
||||
int puff(unsigned char *dest, /* pointer to destination pointer */
|
||||
unsigned long *destlen, /* amount of output space */
|
||||
unsigned char *source, /* pointer to source data pointer */
|
||||
unsigned long *sourcelen) /* amount of input available */
|
||||
{
|
||||
struct state s; /* input/output state */
|
||||
int last, type; /* block information */
|
||||
int err; /* return value */
|
||||
|
||||
/* initialize output state */
|
||||
s.out = dest;
|
||||
s.outlen = *destlen; /* ignored if dest is NIL */
|
||||
s.outcnt = 0;
|
||||
|
||||
/* initialize input state */
|
||||
s.in = source;
|
||||
s.inlen = *sourcelen;
|
||||
s.incnt = 0;
|
||||
s.bitbuf = 0;
|
||||
s.bitcnt = 0;
|
||||
|
||||
/* return if bits() or decode() tries to read past available input */
|
||||
if (setjmp(s.env) != 0) /* if came back here via longjmp() */
|
||||
err = 2; /* then skip do-loop, return error */
|
||||
else {
|
||||
/* process blocks until last block or error */
|
||||
do {
|
||||
last = bits(&s, 1); /* one if last block */
|
||||
type = bits(&s, 2); /* block type 0..3 */
|
||||
err = type == 0 ? stored(&s) :
|
||||
(type == 1 ? fixed(&s) :
|
||||
(type == 2 ? dynamic(&s) :
|
||||
-1)); /* type == 3, invalid */
|
||||
if (err != 0) break; /* return with error */
|
||||
} while (!last);
|
||||
}
|
||||
|
||||
/* update the lengths and return */
|
||||
if (err <= 0) {
|
||||
*destlen = s.outcnt;
|
||||
*sourcelen = s.incnt;
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
#ifdef TEST
|
||||
/* Example of how to use puff() */
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/stat.h>
|
||||
|
||||
local unsigned char *yank(char *name, unsigned long *len)
|
||||
{
|
||||
unsigned long size;
|
||||
unsigned char *buf;
|
||||
FILE *in;
|
||||
struct stat s;
|
||||
|
||||
*len = 0;
|
||||
if (stat(name, &s)) return NULL;
|
||||
if ((s.st_mode & S_IFMT) != S_IFREG) return NULL;
|
||||
size = (unsigned long)(s.st_size);
|
||||
if (size == 0 || (off_t)size != s.st_size) return NULL;
|
||||
in = fopen(name, "r");
|
||||
if (in == NULL) return NULL;
|
||||
buf = malloc(size);
|
||||
if (buf != NULL && fread(buf, 1, size, in) != size) {
|
||||
free(buf);
|
||||
buf = NULL;
|
||||
}
|
||||
fclose(in);
|
||||
*len = size;
|
||||
return buf;
|
||||
}
|
||||
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
int ret;
|
||||
unsigned char *source;
|
||||
unsigned long len, sourcelen, destlen;
|
||||
|
||||
if (argc < 2) return 2;
|
||||
source = yank(argv[1], &len);
|
||||
if (source == NULL) return 2;
|
||||
sourcelen = len;
|
||||
ret = puff(NIL, &destlen, source, &sourcelen);
|
||||
if (ret)
|
||||
printf("puff() failed with return code %d\n", ret);
|
||||
else {
|
||||
printf("puff() succeeded uncompressing %lu bytes\n", destlen);
|
||||
if (sourcelen < len) printf("%lu compressed bytes unused\n",
|
||||
len - sourcelen);
|
||||
}
|
||||
free(source);
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
|
@ -1,31 +0,0 @@
|
|||
/* puff.h
|
||||
Copyright (C) 2002, 2003 Mark Adler, all rights reserved
|
||||
version 1.7, 3 Mar 2002
|
||||
|
||||
This software is provided 'as-is', without any express or implied
|
||||
warranty. In no event will the author be held liable for any damages
|
||||
arising from the use of this software.
|
||||
|
||||
Permission is granted to anyone to use this software for any purpose,
|
||||
including commercial applications, and to alter it and redistribute it
|
||||
freely, subject to the following restrictions:
|
||||
|
||||
1. The origin of this software must not be misrepresented; you must not
|
||||
claim that you wrote the original software. If you use this software
|
||||
in a product, an acknowledgment in the product documentation would be
|
||||
appreciated but is not required.
|
||||
2. Altered source versions must be plainly marked as such, and must not be
|
||||
misrepresented as being the original software.
|
||||
3. This notice may not be removed or altered from any source distribution.
|
||||
|
||||
Mark Adler madler@alumni.caltech.edu
|
||||
*/
|
||||
|
||||
|
||||
/*
|
||||
* See puff.c for purpose and usage.
|
||||
*/
|
||||
int puff(unsigned char *dest, /* pointer to destination pointer */
|
||||
unsigned long *destlen, /* amount of output space */
|
||||
unsigned char *source, /* pointer to source data pointer */
|
||||
unsigned long *sourcelen); /* amount of input available */
|
||||
Binary file not shown.
|
|
@ -1,149 +0,0 @@
|
|||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <windows.h>
|
||||
#include "zlib.h"
|
||||
|
||||
int ReadFileMemory(const char* filename,long* plFileSize,void** pFilePtr)
|
||||
{
|
||||
FILE* stream;
|
||||
void* ptr;
|
||||
int retVal=1;
|
||||
stream=fopen(filename, "rb");
|
||||
if (stream==NULL)
|
||||
return 0;
|
||||
|
||||
fseek(stream,0,SEEK_END);
|
||||
|
||||
*plFileSize=ftell(stream);
|
||||
fseek(stream,0,SEEK_SET);
|
||||
ptr=malloc((*plFileSize)+1);
|
||||
if (ptr==NULL)
|
||||
retVal=0;
|
||||
else
|
||||
{
|
||||
if (fread(ptr, 1, *plFileSize,stream) != (*plFileSize))
|
||||
retVal=0;
|
||||
}
|
||||
fclose(stream);
|
||||
*pFilePtr=ptr;
|
||||
return retVal;
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
int BlockSizeCompress=0x8000;
|
||||
int BlockSizeUncompress=0x8000;
|
||||
int cprLevel=Z_DEFAULT_COMPRESSION ;
|
||||
long lFileSize;
|
||||
unsigned char* FilePtr;
|
||||
long lBufferSizeCpr;
|
||||
long lBufferSizeUncpr;
|
||||
long lCompressedSize=0;
|
||||
unsigned char* CprPtr;
|
||||
unsigned char* UncprPtr;
|
||||
long lSizeCpr,lSizeUncpr;
|
||||
DWORD dwGetTick;
|
||||
|
||||
if (argc<=1)
|
||||
{
|
||||
printf("run TestZlib <File> [BlockSizeCompress] [BlockSizeUncompress] [compres. level]\n");
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (ReadFileMemory(argv[1],&lFileSize,&FilePtr)==0)
|
||||
{
|
||||
printf("error reading %s\n",argv[1]);
|
||||
return 1;
|
||||
}
|
||||
else printf("file %s read, %u bytes\n",argv[1],lFileSize);
|
||||
|
||||
if (argc>=3)
|
||||
BlockSizeCompress=atol(argv[2]);
|
||||
|
||||
if (argc>=4)
|
||||
BlockSizeUncompress=atol(argv[3]);
|
||||
|
||||
if (argc>=5)
|
||||
cprLevel=(int)atol(argv[4]);
|
||||
|
||||
lBufferSizeCpr = lFileSize + (lFileSize/0x10) + 0x200;
|
||||
lBufferSizeUncpr = lBufferSizeCpr;
|
||||
|
||||
CprPtr=(unsigned char*)malloc(lBufferSizeCpr + BlockSizeCompress);
|
||||
UncprPtr=(unsigned char*)malloc(lBufferSizeUncpr + BlockSizeUncompress);
|
||||
|
||||
dwGetTick=GetTickCount();
|
||||
{
|
||||
z_stream zcpr;
|
||||
int ret=Z_OK;
|
||||
long lOrigToDo = lFileSize;
|
||||
long lOrigDone = 0;
|
||||
int step=0;
|
||||
memset(&zcpr,0,sizeof(z_stream));
|
||||
deflateInit(&zcpr,cprLevel);
|
||||
|
||||
zcpr.next_in = FilePtr;
|
||||
zcpr.next_out = CprPtr;
|
||||
|
||||
|
||||
do
|
||||
{
|
||||
long all_read_before = zcpr.total_in;
|
||||
zcpr.avail_in = min(lOrigToDo,BlockSizeCompress);
|
||||
zcpr.avail_out = BlockSizeCompress;
|
||||
ret=deflate(&zcpr,(zcpr.avail_in==lOrigToDo) ? Z_FINISH : Z_SYNC_FLUSH);
|
||||
lOrigDone += (zcpr.total_in-all_read_before);
|
||||
lOrigToDo -= (zcpr.total_in-all_read_before);
|
||||
step++;
|
||||
} while (ret==Z_OK);
|
||||
|
||||
lSizeCpr=zcpr.total_out;
|
||||
deflateEnd(&zcpr);
|
||||
dwGetTick=GetTickCount()-dwGetTick;
|
||||
printf("total compress size = %u, in %u step\n",lSizeCpr,step);
|
||||
printf("time = %u msec = %f sec\n\n",dwGetTick,dwGetTick/(double)1000.);
|
||||
}
|
||||
|
||||
dwGetTick=GetTickCount();
|
||||
{
|
||||
z_stream zcpr;
|
||||
int ret=Z_OK;
|
||||
long lOrigToDo = lSizeCpr;
|
||||
long lOrigDone = 0;
|
||||
int step=0;
|
||||
memset(&zcpr,0,sizeof(z_stream));
|
||||
inflateInit(&zcpr);
|
||||
|
||||
zcpr.next_in = CprPtr;
|
||||
zcpr.next_out = UncprPtr;
|
||||
|
||||
|
||||
do
|
||||
{
|
||||
long all_read_before = zcpr.total_in;
|
||||
zcpr.avail_in = min(lOrigToDo,BlockSizeUncompress);
|
||||
zcpr.avail_out = BlockSizeUncompress;
|
||||
ret=inflate(&zcpr,Z_SYNC_FLUSH);
|
||||
lOrigDone += (zcpr.total_in-all_read_before);
|
||||
lOrigToDo -= (zcpr.total_in-all_read_before);
|
||||
step++;
|
||||
} while (ret==Z_OK);
|
||||
|
||||
lSizeUncpr=zcpr.total_out;
|
||||
inflateEnd(&zcpr);
|
||||
dwGetTick=GetTickCount()-dwGetTick;
|
||||
printf("total uncompress size = %u, in %u step\n",lSizeUncpr,step);
|
||||
printf("time = %u msec = %f sec\n\n",dwGetTick,dwGetTick/(double)1000.);
|
||||
}
|
||||
|
||||
if (lSizeUncpr==lFileSize)
|
||||
{
|
||||
if (memcmp(FilePtr,UncprPtr,lFileSize)==0)
|
||||
printf("compare ok\n");
|
||||
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
}
|
||||
|
|
@ -1,21 +0,0 @@
|
|||
Microsoft Visual Studio Solution File, Format Version 7.00
|
||||
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "testzlib", "testzlib.vcproj", "{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}"
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfiguration) = preSolution
|
||||
ConfigName.0 = Debug
|
||||
ConfigName.1 = Release
|
||||
EndGlobalSection
|
||||
GlobalSection(ProjectDependencies) = postSolution
|
||||
EndGlobalSection
|
||||
GlobalSection(ProjectConfiguration) = postSolution
|
||||
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Debug.ActiveCfg = Debug|Win32
|
||||
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Debug.Build.0 = Debug|Win32
|
||||
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Release.ActiveCfg = Release|Win32
|
||||
{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}.Release.Build.0 = Release|Win32
|
||||
EndGlobalSection
|
||||
GlobalSection(ExtensibilityGlobals) = postSolution
|
||||
EndGlobalSection
|
||||
GlobalSection(ExtensibilityAddIns) = postSolution
|
||||
EndGlobalSection
|
||||
EndGlobal
|
||||
|
|
@ -1,124 +0,0 @@
|
|||
<?xml version="1.0" encoding = "Windows-1252"?>
|
||||
<VisualStudioProject
|
||||
ProjectType="Visual C++"
|
||||
Version="7.00"
|
||||
Name="testzlib"
|
||||
ProjectGUID="{AA6666AA-E09F-4135-9C0C-4FE50C3C654B}"
|
||||
Keyword="Win32Proj">
|
||||
<Platforms>
|
||||
<Platform
|
||||
Name="Win32"/>
|
||||
</Platforms>
|
||||
<Configurations>
|
||||
<Configuration
|
||||
Name="Debug|Win32"
|
||||
OutputDirectory="Debug"
|
||||
IntermediateDirectory="Debug"
|
||||
ConfigurationType="1"
|
||||
CharacterSet="2">
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
Optimization="0"
|
||||
PreprocessorDefinitions="WIN32;ZLIB_WINAPI;_DEBUG;_CONSOLE"
|
||||
MinimalRebuild="TRUE"
|
||||
BasicRuntimeChecks="3"
|
||||
RuntimeLibrary="5"
|
||||
UsePrecompiledHeader="0"
|
||||
WarningLevel="3"
|
||||
Detect64BitPortabilityProblems="TRUE"
|
||||
DebugInformationFormat="4"/>
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"/>
|
||||
<Tool
|
||||
Name="VCLinkerTool"
|
||||
OutputFile="$(OutDir)/testzlib.exe"
|
||||
LinkIncremental="2"
|
||||
GenerateDebugInformation="TRUE"
|
||||
ProgramDatabaseFile="$(OutDir)/testzlib.pdb"
|
||||
SubSystem="1"
|
||||
TargetMachine="1"/>
|
||||
<Tool
|
||||
Name="VCMIDLTool"/>
|
||||
<Tool
|
||||
Name="VCPostBuildEventTool"/>
|
||||
<Tool
|
||||
Name="VCPreBuildEventTool"/>
|
||||
<Tool
|
||||
Name="VCPreLinkEventTool"/>
|
||||
<Tool
|
||||
Name="VCResourceCompilerTool"/>
|
||||
<Tool
|
||||
Name="VCWebServiceProxyGeneratorTool"/>
|
||||
<Tool
|
||||
Name="VCWebDeploymentTool"/>
|
||||
</Configuration>
|
||||
<Configuration
|
||||
Name="Release|Win32"
|
||||
OutputDirectory="Release"
|
||||
IntermediateDirectory="Release"
|
||||
ConfigurationType="1"
|
||||
CharacterSet="2">
|
||||
<Tool
|
||||
Name="VCCLCompilerTool"
|
||||
Optimization="2"
|
||||
InlineFunctionExpansion="1"
|
||||
OmitFramePointers="TRUE"
|
||||
PreprocessorDefinitions="WIN32;ZLIB_WINAPI;NDEBUG;_CONSOLE"
|
||||
StringPooling="TRUE"
|
||||
RuntimeLibrary="4"
|
||||
EnableFunctionLevelLinking="TRUE"
|
||||
UsePrecompiledHeader="0"
|
||||
WarningLevel="3"
|
||||
Detect64BitPortabilityProblems="TRUE"
|
||||
DebugInformationFormat="3"/>
|
||||
<Tool
|
||||
Name="VCCustomBuildTool"/>
|
||||
<Tool
|
||||
Name="VCLinkerTool"
|
||||
OutputFile="$(OutDir)/testzlib.exe"
|
||||
LinkIncremental="1"
|
||||
GenerateDebugInformation="TRUE"
|
||||
SubSystem="1"
|
||||
OptimizeReferences="2"
|
||||
EnableCOMDATFolding="2"
|
||||
OptimizeForWindows98="1"
|
||||
TargetMachine="1"/>
|
||||
<Tool
|
||||
Name="VCMIDLTool"/>
|
||||
<Tool
|
||||
Name="VCPostBuildEventTool"/>
|
||||
<Tool
|
||||
Name="VCPreBuildEventTool"/>
|
||||
<Tool
|
||||
Name="VCPreLinkEventTool"/>
|
||||
<Tool
|
||||
Name="VCResourceCompilerTool"/>
|
||||
<Tool
|
||||
Name="VCWebServiceProxyGeneratorTool"/>
|
||||
<Tool
|
||||
Name="VCWebDeploymentTool"/>
|
||||
</Configuration>
|
||||
</Configurations>
|
||||
<Files>
|
||||
<Filter
|
||||
Name="Source Files"
|
||||
Filter="cpp;c;cxx;def;odl;idl;hpj;bat;asm">
|
||||
<File
|
||||
RelativePath="testzlib.c">
|
||||
</File>
|
||||
</Filter>
|
||||
<Filter
|
||||
Name="Header Files"
|
||||
Filter="h;hpp;hxx;hm;inl;inc">
|
||||
</Filter>
|
||||
<Filter
|
||||
Name="Resource Files"
|
||||
Filter="rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe">
|
||||
</Filter>
|
||||
<File
|
||||
RelativePath="zlibwapi.lib">
|
||||
</File>
|
||||
</Files>
|
||||
<Globals>
|
||||
</Globals>
|
||||
</VisualStudioProject>
|
||||
|
|
@ -1,14 +0,0 @@
|
|||
CC=cc
|
||||
CFLAGS=-g
|
||||
|
||||
untgz: untgz.o ../../libz.a
|
||||
$(CC) $(CFLAGS) -o untgz untgz.o -L../.. -lz
|
||||
|
||||
untgz.o: untgz.c ../../zlib.h
|
||||
$(CC) $(CFLAGS) -c -I../.. untgz.c
|
||||
|
||||
../../libz.a:
|
||||
cd ../..; ./configure; make
|
||||
|
||||
clean:
|
||||
rm -f untgz untgz.o *~
|
||||
|
|
@ -1,17 +0,0 @@
|
|||
CC=cl
|
||||
CFLAGS=-MD
|
||||
|
||||
untgz.exe: untgz.obj ..\..\zlib.lib
|
||||
$(CC) $(CFLAGS) untgz.obj ..\..\zlib.lib
|
||||
|
||||
untgz.obj: untgz.c ..\..\zlib.h
|
||||
$(CC) $(CFLAGS) -c -I..\.. untgz.c
|
||||
|
||||
..\..\zlib.lib:
|
||||
cd ..\..
|
||||
$(MAKE) -f win32\makefile.msc
|
||||
cd contrib\untgz
|
||||
|
||||
clean:
|
||||
-del untgz.obj
|
||||
-del untgz.exe
|
||||
|
|
@ -1,569 +0,0 @@
|
|||
/*
|
||||
* untgz.c -- Display contents and extract files from a gzip'd TAR file
|
||||
*
|
||||
* written by "Pedro A. Aranda Guti\irrez" <paag@tid.es>
|
||||
* adaptation to Unix by Jean-loup Gailly <jloup@gzip.org>
|
||||
* various fixes by Cosmin Truta <cosmint@cs.ubbcluj.ro>
|
||||
*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <time.h>
|
||||
#include <errno.h>
|
||||
|
||||
#include "zlib.h"
|
||||
|
||||
#ifdef unix
|
||||
# include <unistd.h>
|
||||
#else
|
||||
# include <direct.h>
|
||||
# include <io.h>
|
||||
#endif
|
||||
|
||||
#ifdef WIN32
|
||||
#include <windows.h>
|
||||
# ifndef F_OK
|
||||
# define F_OK 0
|
||||
# endif
|
||||
# define mkdir(dirname,mode) _mkdir(dirname)
|
||||
# ifdef _MSC_VER
|
||||
# define strdup(str) _strdup(str)
|
||||
# define access(path,mode) _access(path,mode)
|
||||
# endif
|
||||
#else
|
||||
# include <utime.h>
|
||||
#endif
|
||||
|
||||
|
||||
/* values used in typeflag field */
|
||||
|
||||
#define REGTYPE '0' /* regular file */
|
||||
#define AREGTYPE '\0' /* regular file */
|
||||
#define LNKTYPE '1' /* link */
|
||||
#define SYMTYPE '2' /* reserved */
|
||||
#define CHRTYPE '3' /* character special */
|
||||
#define BLKTYPE '4' /* block special */
|
||||
#define DIRTYPE '5' /* directory */
|
||||
#define FIFOTYPE '6' /* FIFO special */
|
||||
#define CONTTYPE '7' /* reserved */
|
||||
|
||||
#define BLOCKSIZE 512
|
||||
|
||||
struct tar_header
|
||||
{ /* byte offset */
|
||||
char name[100]; /* 0 */
|
||||
char mode[8]; /* 100 */
|
||||
char uid[8]; /* 108 */
|
||||
char gid[8]; /* 116 */
|
||||
char size[12]; /* 124 */
|
||||
char mtime[12]; /* 136 */
|
||||
char chksum[8]; /* 148 */
|
||||
char typeflag; /* 156 */
|
||||
char linkname[100]; /* 157 */
|
||||
char magic[6]; /* 257 */
|
||||
char version[2]; /* 263 */
|
||||
char uname[32]; /* 265 */
|
||||
char gname[32]; /* 297 */
|
||||
char devmajor[8]; /* 329 */
|
||||
char devminor[8]; /* 337 */
|
||||
char prefix[155]; /* 345 */
|
||||
/* 500 */
|
||||
};
|
||||
|
||||
union tar_buffer {
|
||||
char buffer[BLOCKSIZE];
|
||||
struct tar_header header;
|
||||
};
|
||||
|
||||
enum { TGZ_EXTRACT, TGZ_LIST, TGZ_INVALID };
|
||||
|
||||
char *TGZfname OF((const char *));
|
||||
void TGZnotfound OF((const char *));
|
||||
|
||||
int getoct OF((char *, int));
|
||||
char *strtime OF((time_t *));
|
||||
int setfiletime OF((char *, time_t));
|
||||
int ExprMatch OF((char *, char *));
|
||||
|
||||
int makedir OF((char *));
|
||||
int matchname OF((int, int, char **, char *));
|
||||
|
||||
void error OF((const char *));
|
||||
int tar OF((gzFile, int, int, int, char **));
|
||||
|
||||
void help OF((int));
|
||||
int main OF((int, char **));
|
||||
|
||||
char *prog;
|
||||
|
||||
const char *TGZsuffix[] = { "\0", ".tar", ".tar.gz", ".taz", ".tgz", NULL };
|
||||
|
||||
/* return the file name of the TGZ archive */
|
||||
/* or NULL if it does not exist */
|
||||
|
||||
char *TGZfname (const char *arcname)
|
||||
{
|
||||
static char buffer[1024];
|
||||
int origlen,i;
|
||||
|
||||
strcpy(buffer,arcname);
|
||||
origlen = strlen(buffer);
|
||||
|
||||
for (i=0; TGZsuffix[i]; i++)
|
||||
{
|
||||
strcpy(buffer+origlen,TGZsuffix[i]);
|
||||
if (access(buffer,F_OK) == 0)
|
||||
return buffer;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
||||
/* error message for the filename */
|
||||
|
||||
void TGZnotfound (const char *arcname)
|
||||
{
|
||||
int i;
|
||||
|
||||
fprintf(stderr,"%s: Couldn't find ",prog);
|
||||
for (i=0;TGZsuffix[i];i++)
|
||||
fprintf(stderr,(TGZsuffix[i+1]) ? "%s%s, " : "or %s%s\n",
|
||||
arcname,
|
||||
TGZsuffix[i]);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
|
||||
/* convert octal digits to int */
|
||||
/* on error return -1 */
|
||||
|
||||
int getoct (char *p,int width)
|
||||
{
|
||||
int result = 0;
|
||||
char c;
|
||||
|
||||
while (width--)
|
||||
{
|
||||
c = *p++;
|
||||
if (c == 0)
|
||||
break;
|
||||
if (c == ' ')
|
||||
continue;
|
||||
if (c < '0' || c > '7')
|
||||
return -1;
|
||||
result = result * 8 + (c - '0');
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/* convert time_t to string */
|
||||
/* use the "YYYY/MM/DD hh:mm:ss" format */
|
||||
|
||||
char *strtime (time_t *t)
|
||||
{
|
||||
struct tm *local;
|
||||
static char result[32];
|
||||
|
||||
local = localtime(t);
|
||||
sprintf(result,"%4d/%02d/%02d %02d:%02d:%02d",
|
||||
local->tm_year+1900, local->tm_mon+1, local->tm_mday,
|
||||
local->tm_hour, local->tm_min, local->tm_sec);
|
||||
return result;
|
||||
}
|
||||
|
||||
|
||||
/* set file time */
|
||||
|
||||
int setfiletime (char *fname,time_t ftime)
|
||||
{
|
||||
#ifdef WIN32
|
||||
static int isWinNT = -1;
|
||||
SYSTEMTIME st;
|
||||
FILETIME locft, modft;
|
||||
struct tm *loctm;
|
||||
HANDLE hFile;
|
||||
int result;
|
||||
|
||||
loctm = localtime(&ftime);
|
||||
if (loctm == NULL)
|
||||
return -1;
|
||||
|
||||
st.wYear = (WORD)loctm->tm_year + 1900;
|
||||
st.wMonth = (WORD)loctm->tm_mon + 1;
|
||||
st.wDayOfWeek = (WORD)loctm->tm_wday;
|
||||
st.wDay = (WORD)loctm->tm_mday;
|
||||
st.wHour = (WORD)loctm->tm_hour;
|
||||
st.wMinute = (WORD)loctm->tm_min;
|
||||
st.wSecond = (WORD)loctm->tm_sec;
|
||||
st.wMilliseconds = 0;
|
||||
if (!SystemTimeToFileTime(&st, &locft) ||
|
||||
!LocalFileTimeToFileTime(&locft, &modft))
|
||||
return -1;
|
||||
|
||||
if (isWinNT < 0)
|
||||
isWinNT = (GetVersion() < 0x80000000) ? 1 : 0;
|
||||
hFile = CreateFile(fname, GENERIC_WRITE, 0, NULL, OPEN_EXISTING,
|
||||
(isWinNT ? FILE_FLAG_BACKUP_SEMANTICS : 0),
|
||||
NULL);
|
||||
if (hFile == INVALID_HANDLE_VALUE)
|
||||
return -1;
|
||||
result = SetFileTime(hFile, NULL, NULL, &modft) ? 0 : -1;
|
||||
CloseHandle(hFile);
|
||||
return result;
|
||||
#else
|
||||
struct utimbuf settime;
|
||||
|
||||
settime.actime = settime.modtime = ftime;
|
||||
return utime(fname,&settime);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
/* regular expression matching */
|
||||
|
||||
#define ISSPECIAL(c) (((c) == '*') || ((c) == '/'))
|
||||
|
||||
int ExprMatch (char *string,char *expr)
|
||||
{
|
||||
while (1)
|
||||
{
|
||||
if (ISSPECIAL(*expr))
|
||||
{
|
||||
if (*expr == '/')
|
||||
{
|
||||
if (*string != '\\' && *string != '/')
|
||||
return 0;
|
||||
string ++; expr++;
|
||||
}
|
||||
else if (*expr == '*')
|
||||
{
|
||||
if (*expr ++ == 0)
|
||||
return 1;
|
||||
while (*++string != *expr)
|
||||
if (*string == 0)
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if (*string != *expr)
|
||||
return 0;
|
||||
if (*expr++ == 0)
|
||||
return 1;
|
||||
string++;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* recursive mkdir */
|
||||
/* abort on ENOENT; ignore other errors like "directory already exists" */
|
||||
/* return 1 if OK */
|
||||
/* 0 on error */
|
||||
|
||||
int makedir (char *newdir)
|
||||
{
|
||||
char *buffer = strdup(newdir);
|
||||
char *p;
|
||||
int len = strlen(buffer);
|
||||
|
||||
if (len <= 0) {
|
||||
free(buffer);
|
||||
return 0;
|
||||
}
|
||||
if (buffer[len-1] == '/') {
|
||||
buffer[len-1] = '\0';
|
||||
}
|
||||
if (mkdir(buffer, 0755) == 0)
|
||||
{
|
||||
free(buffer);
|
||||
return 1;
|
||||
}
|
||||
|
||||
p = buffer+1;
|
||||
while (1)
|
||||
{
|
||||
char hold;
|
||||
|
||||
while(*p && *p != '\\' && *p != '/')
|
||||
p++;
|
||||
hold = *p;
|
||||
*p = 0;
|
||||
if ((mkdir(buffer, 0755) == -1) && (errno == ENOENT))
|
||||
{
|
||||
fprintf(stderr,"%s: Couldn't create directory %s\n",prog,buffer);
|
||||
free(buffer);
|
||||
return 0;
|
||||
}
|
||||
if (hold == 0)
|
||||
break;
|
||||
*p++ = hold;
|
||||
}
|
||||
free(buffer);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
int matchname (int arg,int argc,char **argv,char *fname)
|
||||
{
|
||||
if (arg == argc) /* no arguments given (untgz tgzarchive) */
|
||||
return 1;
|
||||
|
||||
while (arg < argc)
|
||||
if (ExprMatch(fname,argv[arg++]))
|
||||
return 1;
|
||||
|
||||
return 0; /* ignore this for the moment being */
|
||||
}
|
||||
|
||||
|
||||
/* tar file list or extract */
|
||||
|
||||
int tar (gzFile in,int action,int arg,int argc,char **argv)
|
||||
{
|
||||
union tar_buffer buffer;
|
||||
int len;
|
||||
int err;
|
||||
int getheader = 1;
|
||||
int remaining = 0;
|
||||
FILE *outfile = NULL;
|
||||
char fname[BLOCKSIZE];
|
||||
int tarmode;
|
||||
time_t tartime;
|
||||
|
||||
if (action == TGZ_LIST)
|
||||
printf(" date time size file\n"
|
||||
" ---------- -------- --------- -------------------------------------\n");
|
||||
while (1)
|
||||
{
|
||||
len = gzread(in, &buffer, BLOCKSIZE);
|
||||
if (len < 0)
|
||||
error(gzerror(in, &err));
|
||||
/*
|
||||
* Always expect complete blocks to process
|
||||
* the tar information.
|
||||
*/
|
||||
if (len != BLOCKSIZE)
|
||||
{
|
||||
action = TGZ_INVALID; /* force error exit */
|
||||
remaining = 0; /* force I/O cleanup */
|
||||
}
|
||||
|
||||
/*
|
||||
* If we have to get a tar header
|
||||
*/
|
||||
if (getheader == 1)
|
||||
{
|
||||
/*
|
||||
* if we met the end of the tar
|
||||
* or the end-of-tar block,
|
||||
* we are done
|
||||
*/
|
||||
if ((len == 0) || (buffer.header.name[0] == 0)) break;
|
||||
|
||||
tarmode = getoct(buffer.header.mode,8);
|
||||
tartime = (time_t)getoct(buffer.header.mtime,12);
|
||||
if (tarmode == -1 || tartime == (time_t)-1)
|
||||
{
|
||||
buffer.header.name[0] = 0;
|
||||
action = TGZ_INVALID;
|
||||
}
|
||||
|
||||
strcpy(fname,buffer.header.name);
|
||||
|
||||
switch (buffer.header.typeflag)
|
||||
{
|
||||
case DIRTYPE:
|
||||
if (action == TGZ_LIST)
|
||||
printf(" %s <dir> %s\n",strtime(&tartime),fname);
|
||||
if (action == TGZ_EXTRACT)
|
||||
{
|
||||
makedir(fname);
|
||||
setfiletime(fname,tartime);
|
||||
}
|
||||
break;
|
||||
case REGTYPE:
|
||||
case AREGTYPE:
|
||||
remaining = getoct(buffer.header.size,12);
|
||||
if (remaining == -1)
|
||||
{
|
||||
action = TGZ_INVALID;
|
||||
break;
|
||||
}
|
||||
if (action == TGZ_LIST)
|
||||
printf(" %s %9d %s\n",strtime(&tartime),remaining,fname);
|
||||
else if (action == TGZ_EXTRACT)
|
||||
{
|
||||
if (matchname(arg,argc,argv,fname))
|
||||
{
|
||||
outfile = fopen(fname,"wb");
|
||||
if (outfile == NULL) {
|
||||
/* try creating directory */
|
||||
char *p = strrchr(fname, '/');
|
||||
if (p != NULL) {
|
||||
*p = '\0';
|
||||
makedir(fname);
|
||||
*p = '/';
|
||||
outfile = fopen(fname,"wb");
|
||||
}
|
||||
}
|
||||
if (outfile != NULL)
|
||||
printf("Extracting %s\n",fname);
|
||||
else
|
||||
fprintf(stderr, "%s: Couldn't create %s",prog,fname);
|
||||
}
|
||||
else
|
||||
outfile = NULL;
|
||||
}
|
||||
getheader = 0;
|
||||
break;
|
||||
default:
|
||||
if (action == TGZ_LIST)
|
||||
printf(" %s <---> %s\n",strtime(&tartime),fname);
|
||||
break;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
unsigned int bytes = (remaining > BLOCKSIZE) ? BLOCKSIZE : remaining;
|
||||
|
||||
if (outfile != NULL)
|
||||
{
|
||||
if (fwrite(&buffer,sizeof(char),bytes,outfile) != bytes)
|
||||
{
|
||||
fprintf(stderr,"%s: Error writing %s -- skipping\n",prog,fname);
|
||||
fclose(outfile);
|
||||
outfile = NULL;
|
||||
remove(fname);
|
||||
}
|
||||
}
|
||||
remaining -= bytes;
|
||||
}
|
||||
|
||||
if (remaining == 0)
|
||||
{
|
||||
getheader = 1;
|
||||
if (outfile != NULL)
|
||||
{
|
||||
fclose(outfile);
|
||||
outfile = NULL;
|
||||
if (action != TGZ_INVALID)
|
||||
setfiletime(fname,tartime);
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Abandon if errors are found
|
||||
*/
|
||||
if (action == TGZ_INVALID)
|
||||
{
|
||||
error("broken archive");
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (gzclose(in) != Z_OK)
|
||||
error("failed gzclose");
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/* ============================================================ */
|
||||
|
||||
void help(int exitval)
|
||||
{
|
||||
printf("untgz version 0.2\n"
|
||||
" using zlib version %s\n\n",
|
||||
zlibVersion());
|
||||
printf("Usage: untgz file.tgz extract all files\n"
|
||||
" untgz file.tgz fname ... extract selected files\n"
|
||||
" untgz -l file.tgz list archive contents\n"
|
||||
" untgz -h display this help\n");
|
||||
exit(exitval);
|
||||
}
|
||||
|
||||
void error(const char *msg)
|
||||
{
|
||||
fprintf(stderr, "%s: %s\n", prog, msg);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
|
||||
/* ============================================================ */
|
||||
|
||||
#if defined(WIN32) && defined(__GNUC__)
|
||||
int _CRT_glob = 0; /* disable argument globbing in MinGW */
|
||||
#endif
|
||||
|
||||
int main(int argc,char **argv)
|
||||
{
|
||||
int action = TGZ_EXTRACT;
|
||||
int arg = 1;
|
||||
char *TGZfile;
|
||||
gzFile *f;
|
||||
|
||||
prog = strrchr(argv[0],'\\');
|
||||
if (prog == NULL)
|
||||
{
|
||||
prog = strrchr(argv[0],'/');
|
||||
if (prog == NULL)
|
||||
{
|
||||
prog = strrchr(argv[0],':');
|
||||
if (prog == NULL)
|
||||
prog = argv[0];
|
||||
else
|
||||
prog++;
|
||||
}
|
||||
else
|
||||
prog++;
|
||||
}
|
||||
else
|
||||
prog++;
|
||||
|
||||
if (argc == 1)
|
||||
help(0);
|
||||
|
||||
if (strcmp(argv[arg],"-l") == 0)
|
||||
{
|
||||
action = TGZ_LIST;
|
||||
if (argc == ++arg)
|
||||
help(0);
|
||||
}
|
||||
else if (strcmp(argv[arg],"-h") == 0)
|
||||
{
|
||||
help(0);
|
||||
}
|
||||
|
||||
if ((TGZfile = TGZfname(argv[arg])) == NULL)
|
||||
TGZnotfound(argv[arg]);
|
||||
|
||||
++arg;
|
||||
if ((action == TGZ_LIST) && (arg != argc))
|
||||
help(1);
|
||||
|
||||
/*
|
||||
* Process the TGZ file
|
||||
*/
|
||||
switch(action)
|
||||
{
|
||||
case TGZ_LIST:
|
||||
case TGZ_EXTRACT:
|
||||
f = gzopen(TGZfile,"rb");
|
||||
if (f == NULL)
|
||||
{
|
||||
fprintf(stderr,"%s: Couldn't gzopen %s\n",prog,TGZfile);
|
||||
return 1;
|
||||
}
|
||||
exit(tar(f, action, arg, argc, argv));
|
||||
break;
|
||||
|
||||
default:
|
||||
error("Unknown option");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -1,160 +0,0 @@
|
|||
See below some functions declarations for Visual Basic.
|
||||
|
||||
Frequently Asked Question:
|
||||
|
||||
Q: Each time I use the compress function I get the -5 error (not enough
|
||||
room in the output buffer).
|
||||
|
||||
A: Make sure that the length of the compressed buffer is passed by
|
||||
reference ("as any"), not by value ("as long"). Also check that
|
||||
before the call of compress this length is equal to the total size of
|
||||
the compressed buffer and not zero.
|
||||
|
||||
|
||||
From: "Jon Caruana" <jon-net@usa.net>
|
||||
Subject: Re: How to port zlib declares to vb?
|
||||
Date: Mon, 28 Oct 1996 18:33:03 -0600
|
||||
|
||||
Got the answer! (I haven't had time to check this but it's what I got, and
|
||||
looks correct):
|
||||
|
||||
He has the following routines working:
|
||||
compress
|
||||
uncompress
|
||||
gzopen
|
||||
gzwrite
|
||||
gzread
|
||||
gzclose
|
||||
|
||||
Declares follow: (Quoted from Carlos Rios <c_rios@sonda.cl>, in Vb4 form)
|
||||
|
||||
#If Win16 Then 'Use Win16 calls.
|
||||
Declare Function compress Lib "ZLIB.DLL" (ByVal compr As
|
||||
String, comprLen As Any, ByVal buf As String, ByVal buflen
|
||||
As Long) As Integer
|
||||
Declare Function uncompress Lib "ZLIB.DLL" (ByVal uncompr
|
||||
As String, uncomprLen As Any, ByVal compr As String, ByVal
|
||||
lcompr As Long) As Integer
|
||||
Declare Function gzopen Lib "ZLIB.DLL" (ByVal filePath As
|
||||
String, ByVal mode As String) As Long
|
||||
Declare Function gzread Lib "ZLIB.DLL" (ByVal file As
|
||||
Long, ByVal uncompr As String, ByVal uncomprLen As Integer)
|
||||
As Integer
|
||||
Declare Function gzwrite Lib "ZLIB.DLL" (ByVal file As
|
||||
Long, ByVal uncompr As String, ByVal uncomprLen As Integer)
|
||||
As Integer
|
||||
Declare Function gzclose Lib "ZLIB.DLL" (ByVal file As
|
||||
Long) As Integer
|
||||
#Else
|
||||
Declare Function compress Lib "ZLIB32.DLL"
|
||||
(ByVal compr As String, comprLen As Any, ByVal buf As
|
||||
String, ByVal buflen As Long) As Integer
|
||||
Declare Function uncompress Lib "ZLIB32.DLL"
|
||||
(ByVal uncompr As String, uncomprLen As Any, ByVal compr As
|
||||
String, ByVal lcompr As Long) As Long
|
||||
Declare Function gzopen Lib "ZLIB32.DLL"
|
||||
(ByVal file As String, ByVal mode As String) As Long
|
||||
Declare Function gzread Lib "ZLIB32.DLL"
|
||||
(ByVal file As Long, ByVal uncompr As String, ByVal
|
||||
uncomprLen As Long) As Long
|
||||
Declare Function gzwrite Lib "ZLIB32.DLL"
|
||||
(ByVal file As Long, ByVal uncompr As String, ByVal
|
||||
uncomprLen As Long) As Long
|
||||
Declare Function gzclose Lib "ZLIB32.DLL"
|
||||
(ByVal file As Long) As Long
|
||||
#End If
|
||||
|
||||
-Jon Caruana
|
||||
jon-net@usa.net
|
||||
Microsoft Sitebuilder Network Level 1 Member - HTML Writer's Guild Member
|
||||
|
||||
|
||||
Here is another example from Michael <michael_borgsys@hotmail.com> that he
|
||||
says conforms to the VB guidelines, and that solves the problem of not
|
||||
knowing the uncompressed size by storing it at the end of the file:
|
||||
|
||||
'Calling the functions:
|
||||
'bracket meaning: <parameter> [optional] {Range of possible values}
|
||||
'Call subCompressFile(<path with filename to compress> [, <path with
|
||||
filename to write to>, [level of compression {1..9}]])
|
||||
'Call subUncompressFile(<path with filename to compress>)
|
||||
|
||||
Option Explicit
|
||||
Private lngpvtPcnSml As Long 'Stores value for 'lngPercentSmaller'
|
||||
Private Const SUCCESS As Long = 0
|
||||
Private Const strFilExt As String = ".cpr"
|
||||
Private Declare Function lngfncCpr Lib "zlib.dll" Alias "compress2" (ByRef
|
||||
dest As Any, ByRef destLen As Any, ByRef src As Any, ByVal srcLen As Long,
|
||||
ByVal level As Integer) As Long
|
||||
Private Declare Function lngfncUcp Lib "zlib.dll" Alias "uncompress" (ByRef
|
||||
dest As Any, ByRef destLen As Any, ByRef src As Any, ByVal srcLen As Long)
|
||||
As Long
|
||||
|
||||
Public Sub subCompressFile(ByVal strargOriFilPth As String, Optional ByVal
|
||||
strargCprFilPth As String, Optional ByVal intLvl As Integer = 9)
|
||||
Dim strCprPth As String
|
||||
Dim lngOriSiz As Long
|
||||
Dim lngCprSiz As Long
|
||||
Dim bytaryOri() As Byte
|
||||
Dim bytaryCpr() As Byte
|
||||
lngOriSiz = FileLen(strargOriFilPth)
|
||||
ReDim bytaryOri(lngOriSiz - 1)
|
||||
Open strargOriFilPth For Binary Access Read As #1
|
||||
Get #1, , bytaryOri()
|
||||
Close #1
|
||||
strCprPth = IIf(strargCprFilPth = "", strargOriFilPth, strargCprFilPth)
|
||||
'Select file path and name
|
||||
strCprPth = strCprPth & IIf(Right(strCprPth, Len(strFilExt)) =
|
||||
strFilExt, "", strFilExt) 'Add file extension if not exists
|
||||
lngCprSiz = (lngOriSiz * 1.01) + 12 'Compression needs temporary a bit
|
||||
more space then original file size
|
||||
ReDim bytaryCpr(lngCprSiz - 1)
|
||||
If lngfncCpr(bytaryCpr(0), lngCprSiz, bytaryOri(0), lngOriSiz, intLvl) =
|
||||
SUCCESS Then
|
||||
lngpvtPcnSml = (1# - (lngCprSiz / lngOriSiz)) * 100
|
||||
ReDim Preserve bytaryCpr(lngCprSiz - 1)
|
||||
Open strCprPth For Binary Access Write As #1
|
||||
Put #1, , bytaryCpr()
|
||||
Put #1, , lngOriSiz 'Add the the original size value to the end
|
||||
(last 4 bytes)
|
||||
Close #1
|
||||
Else
|
||||
MsgBox "Compression error"
|
||||
End If
|
||||
Erase bytaryCpr
|
||||
Erase bytaryOri
|
||||
End Sub
|
||||
|
||||
Public Sub subUncompressFile(ByVal strargFilPth As String)
|
||||
Dim bytaryCpr() As Byte
|
||||
Dim bytaryOri() As Byte
|
||||
Dim lngOriSiz As Long
|
||||
Dim lngCprSiz As Long
|
||||
Dim strOriPth As String
|
||||
lngCprSiz = FileLen(strargFilPth)
|
||||
ReDim bytaryCpr(lngCprSiz - 1)
|
||||
Open strargFilPth For Binary Access Read As #1
|
||||
Get #1, , bytaryCpr()
|
||||
Close #1
|
||||
'Read the original file size value:
|
||||
lngOriSiz = bytaryCpr(lngCprSiz - 1) * (2 ^ 24) _
|
||||
+ bytaryCpr(lngCprSiz - 2) * (2 ^ 16) _
|
||||
+ bytaryCpr(lngCprSiz - 3) * (2 ^ 8) _
|
||||
+ bytaryCpr(lngCprSiz - 4)
|
||||
ReDim Preserve bytaryCpr(lngCprSiz - 5) 'Cut of the original size value
|
||||
ReDim bytaryOri(lngOriSiz - 1)
|
||||
If lngfncUcp(bytaryOri(0), lngOriSiz, bytaryCpr(0), lngCprSiz) = SUCCESS
|
||||
Then
|
||||
strOriPth = Left(strargFilPth, Len(strargFilPth) - Len(strFilExt))
|
||||
Open strOriPth For Binary Access Write As #1
|
||||
Put #1, , bytaryOri()
|
||||
Close #1
|
||||
Else
|
||||
MsgBox "Uncompression error"
|
||||
End If
|
||||
Erase bytaryCpr
|
||||
Erase bytaryOri
|
||||
End Sub
|
||||
Public Property Get lngPercentSmaller() As Long
|
||||
lngPercentSmaller = lngpvtPcnSml
|
||||
End Property
|
||||
|
|
@ -1,55 +0,0 @@
|
|||
Building instructions for the DLL versions of Zlib 1.21
|
||||
=======================================================
|
||||
|
||||
This directory contains projects that build zlib and minizip using
|
||||
Microsoft Visual C++ 7.0/7.1.
|
||||
|
||||
You don't need to build these projects yourself. You can download the
|
||||
binaries from:
|
||||
http://www.winimage.com/zLibDll
|
||||
|
||||
More information can be found at this site.
|
||||
|
||||
|
||||
Build instructions
|
||||
------------------
|
||||
- Unzip zlib*.zip and copy the files from contrib\vstudio\vc7,
|
||||
from contrib\vstudio\masmx86 and from contrib\minizip into the same
|
||||
directory.
|
||||
- Download the crtdll library from
|
||||
http://www.winimage.com/zLibDll/crtdll.zip
|
||||
Unzip crtdll.zip to extract crtdll.lib.
|
||||
- If you are using x86, use the Release target.
|
||||
- Open zlibvc.sln with Microsoft Visual C++ 7.0 or 7.1
|
||||
(Visual Studio .Net 2002 or 2003).
|
||||
|
||||
|
||||
Important
|
||||
---------
|
||||
- To use zlibwapi.dll in your application, you must define the
|
||||
macro ZLIB_WINAPI when compiling your application's source files.
|
||||
|
||||
|
||||
Additional notes
|
||||
----------------
|
||||
- This DLL, named zlibwapi.dll, is compatible to the old zlib.dll built
|
||||
by Gilles Vollant from the zlib 1.1.x sources, and distributed at
|
||||
http://www.winimage.com/zLibDll
|
||||
It uses the WINAPI calling convention for the exported functions, and
|
||||
includes the minizip functionality. If your application needs that
|
||||
particular build of zlib.dll, you can rename zlibwapi.dll to zlib.dll.
|
||||
|
||||
- The new DLL was renamed because there exist several incompatible
|
||||
versions of zlib.dll on the Internet.
|
||||
|
||||
- There is also an official DLL build of zlib, named zlib1.dll. This one
|
||||
is exporting the functions using the CDECL convention. See the file
|
||||
win32\DLL_FAQ.txt found in this zlib distribution.
|
||||
|
||||
- There used to be a ZLIB_DLL macro in zlib 1.1.x, but now this symbol
|
||||
has a slightly different effect. To avoid compatibility problems, do
|
||||
not define it here.
|
||||
|
||||
|
||||
Gilles Vollant
|
||||
info@winimage.com
|
||||
Binary file not shown.
Binary file not shown.
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue