zlib 1.2.2 -> 1.2.3
This commit is contained in:
parent
902785d4e5
commit
533eb3acfd
203 changed files with 54654 additions and 1 deletions
|
@ -4,7 +4,7 @@
|
|||
# See ansi/Makefile for a further explanation.
|
||||
|
||||
MAKE = exec make -$(MAKEFLAGS)
|
||||
ZLIB=zlib-1.2.2
|
||||
ZLIB=zlib-1.2.3
|
||||
|
||||
usage:
|
||||
@echo "Usage: make all" >&2 # Compile all library functions" >&2
|
||||
|
|
855
lib/zlib-1.2.3/ChangeLog
Normal file
855
lib/zlib-1.2.3/ChangeLog
Normal file
|
@ -0,0 +1,855 @@
|
|||
|
||||
ChangeLog file for zlib
|
||||
|
||||
Changes in 1.2.3 (18 July 2005)
|
||||
- Apply security vulnerability fixes to contrib/infback9 as well
|
||||
- Clean up some text files (carriage returns, trailing space)
|
||||
- Update testzlib, vstudio, masmx64, and masmx86 in contrib [Vollant]
|
||||
|
||||
Changes in 1.2.2.4 (11 July 2005)
|
||||
- Add inflatePrime() function for starting inflation at bit boundary
|
||||
- Avoid some Visual C warnings in deflate.c
|
||||
- Avoid more silly Visual C warnings in inflate.c and inftrees.c for 64-bit
|
||||
compile
|
||||
- Fix some spelling errors in comments [Betts]
|
||||
- Correct inflateInit2() error return documentation in zlib.h
|
||||
- Added zran.c example of compressed data random access to examples
|
||||
directory, shows use of inflatePrime()
|
||||
- Fix cast for assignments to strm->state in inflate.c and infback.c
|
||||
- Fix zlibCompileFlags() in zutil.c to use 1L for long shifts [Oberhumer]
|
||||
- Move declarations of gf2 functions to right place in crc32.c [Oberhumer]
|
||||
- Add cast in trees.c t avoid a warning [Oberhumer]
|
||||
- Avoid some warnings in fitblk.c, gun.c, gzjoin.c in examples [Oberhumer]
|
||||
- Update make_vms.com [Zinser]
|
||||
- Initialize state->write in inflateReset() since copied in inflate_fast()
|
||||
- Be more strict on incomplete code sets in inflate_table() and increase
|
||||
ENOUGH and MAXD -- this repairs a possible security vulnerability for
|
||||
invalid inflate input. Thanks to Tavis Ormandy and Markus Oberhumer for
|
||||
discovering the vulnerability and providing test cases.
|
||||
- Add ia64 support to configure for HP-UX [Smith]
|
||||
- Add error return to gzread() for format or i/o error [Levin]
|
||||
- Use malloc.h for OS/2 [Necasek]
|
||||
|
||||
Changes in 1.2.2.3 (27 May 2005)
|
||||
- Replace 1U constants in inflate.c and inftrees.c for 64-bit compile
|
||||
- Typecast fread() return values in gzio.c [Vollant]
|
||||
- Remove trailing space in minigzip.c outmode (VC++ can't deal with it)
|
||||
- Fix crc check bug in gzread() after gzungetc() [Heiner]
|
||||
- Add the deflateTune() function to adjust internal compression parameters
|
||||
- Add a fast gzip decompressor, gun.c, to examples (use of inflateBack)
|
||||
- Remove an incorrect assertion in examples/zpipe.c
|
||||
- Add C++ wrapper in infback9.h [Donais]
|
||||
- Fix bug in inflateCopy() when decoding fixed codes
|
||||
- Note in zlib.h how much deflateSetDictionary() actually uses
|
||||
- Remove USE_DICT_HEAD in deflate.c (would mess up inflate if used)
|
||||
- Add _WIN32_WCE to define WIN32 in zconf.in.h [Spencer]
|
||||
- Don't include stderr.h or errno.h for _WIN32_WCE in zutil.h [Spencer]
|
||||
- Add gzdirect() function to indicate transparent reads
|
||||
- Update contrib/minizip [Vollant]
|
||||
- Fix compilation of deflate.c when both ASMV and FASTEST [Oberhumer]
|
||||
- Add casts in crc32.c to avoid warnings [Oberhumer]
|
||||
- Add contrib/masmx64 [Vollant]
|
||||
- Update contrib/asm586, asm686, masmx86, testzlib, vstudio [Vollant]
|
||||
|
||||
Changes in 1.2.2.2 (30 December 2004)
|
||||
- Replace structure assignments in deflate.c and inflate.c with zmemcpy to
|
||||
avoid implicit memcpy calls (portability for no-library compilation)
|
||||
- Increase sprintf() buffer size in gzdopen() to allow for large numbers
|
||||
- Add INFLATE_STRICT to check distances against zlib header
|
||||
- Improve WinCE errno handling and comments [Chang]
|
||||
- Remove comment about no gzip header processing in FAQ
|
||||
- Add Z_FIXED strategy option to deflateInit2() to force fixed trees
|
||||
- Add updated make_vms.com [Coghlan], update README
|
||||
- Create a new "examples" directory, move gzappend.c there, add zpipe.c,
|
||||
fitblk.c, gzlog.[ch], gzjoin.c, and zlib_how.html.
|
||||
- Add FAQ entry and comments in deflate.c on uninitialized memory access
|
||||
- Add Solaris 9 make options in configure [Gilbert]
|
||||
- Allow strerror() usage in gzio.c for STDC
|
||||
- Fix DecompressBuf in contrib/delphi/ZLib.pas [ManChesTer]
|
||||
- Update contrib/masmx86/inffas32.asm and gvmat32.asm [Vollant]
|
||||
- Use z_off_t for adler32_combine() and crc32_combine() lengths
|
||||
- Make adler32() much faster for small len
|
||||
- Use OS_CODE in deflate() default gzip header
|
||||
|
||||
Changes in 1.2.2.1 (31 October 2004)
|
||||
- Allow inflateSetDictionary() call for raw inflate
|
||||
- Fix inflate header crc check bug for file names and comments
|
||||
- Add deflateSetHeader() and gz_header structure for custom gzip headers
|
||||
- Add inflateGetheader() to retrieve gzip headers
|
||||
- Add crc32_combine() and adler32_combine() functions
|
||||
- Add alloc_func, free_func, in_func, out_func to Z_PREFIX list
|
||||
- Use zstreamp consistently in zlib.h (inflate_back functions)
|
||||
- Remove GUNZIP condition from definition of inflate_mode in inflate.h
|
||||
and in contrib/inflate86/inffast.S [Truta, Anderson]
|
||||
- Add support for AMD64 in contrib/inflate86/inffas86.c [Anderson]
|
||||
- Update projects/README.projects and projects/visualc6 [Truta]
|
||||
- Update win32/DLL_FAQ.txt [Truta]
|
||||
- Avoid warning under NO_GZCOMPRESS in gzio.c; fix typo [Truta]
|
||||
- Deprecate Z_ASCII; use Z_TEXT instead [Truta]
|
||||
- Use a new algorithm for setting strm->data_type in trees.c [Truta]
|
||||
- Do not define an exit() prototype in zutil.c unless DEBUG defined
|
||||
- Remove prototype of exit() from zutil.c, example.c, minigzip.c [Truta]
|
||||
- Add comment in zlib.h for Z_NO_FLUSH parameter to deflate()
|
||||
- Fix Darwin build version identification [Peterson]
|
||||
|
||||
Changes in 1.2.2 (3 October 2004)
|
||||
- Update zlib.h comments on gzip in-memory processing
|
||||
- Set adler to 1 in inflateReset() to support Java test suite [Walles]
|
||||
- Add contrib/dotzlib [Ravn]
|
||||
- Update win32/DLL_FAQ.txt [Truta]
|
||||
- Update contrib/minizip [Vollant]
|
||||
- Move contrib/visual-basic.txt to old/ [Truta]
|
||||
- Fix assembler builds in projects/visualc6/ [Truta]
|
||||
|
||||
Changes in 1.2.1.2 (9 September 2004)
|
||||
- Update INDEX file
|
||||
- Fix trees.c to update strm->data_type (no one ever noticed!)
|
||||
- Fix bug in error case in inflate.c, infback.c, and infback9.c [Brown]
|
||||
- Add "volatile" to crc table flag declaration (for DYNAMIC_CRC_TABLE)
|
||||
- Add limited multitasking protection to DYNAMIC_CRC_TABLE
|
||||
- Add NO_vsnprintf for VMS in zutil.h [Mozilla]
|
||||
- Don't declare strerror() under VMS [Mozilla]
|
||||
- Add comment to DYNAMIC_CRC_TABLE to use get_crc_table() to initialize
|
||||
- Update contrib/ada [Anisimkov]
|
||||
- Update contrib/minizip [Vollant]
|
||||
- Fix configure to not hardcode directories for Darwin [Peterson]
|
||||
- Fix gzio.c to not return error on empty files [Brown]
|
||||
- Fix indentation; update version in contrib/delphi/ZLib.pas and
|
||||
contrib/pascal/zlibpas.pas [Truta]
|
||||
- Update mkasm.bat in contrib/masmx86 [Truta]
|
||||
- Update contrib/untgz [Truta]
|
||||
- Add projects/README.projects [Truta]
|
||||
- Add project for MS Visual C++ 6.0 in projects/visualc6 [Cadieux, Truta]
|
||||
- Update win32/DLL_FAQ.txt [Truta]
|
||||
- Update list of Z_PREFIX symbols in zconf.h [Randers-Pehrson, Truta]
|
||||
- Remove an unnecessary assignment to curr in inftrees.c [Truta]
|
||||
- Add OS/2 to exe builds in configure [Poltorak]
|
||||
- Remove err dummy parameter in zlib.h [Kientzle]
|
||||
|
||||
Changes in 1.2.1.1 (9 January 2004)
|
||||
- Update email address in README
|
||||
- Several FAQ updates
|
||||
- Fix a big fat bug in inftrees.c that prevented decoding valid
|
||||
dynamic blocks with only literals and no distance codes --
|
||||
Thanks to "Hot Emu" for the bug report and sample file
|
||||
- Add a note to puff.c on no distance codes case.
|
||||
|
||||
Changes in 1.2.1 (17 November 2003)
|
||||
- Remove a tab in contrib/gzappend/gzappend.c
|
||||
- Update some interfaces in contrib for new zlib functions
|
||||
- Update zlib version number in some contrib entries
|
||||
- Add Windows CE definition for ptrdiff_t in zutil.h [Mai, Truta]
|
||||
- Support shared libraries on Hurd and KFreeBSD [Brown]
|
||||
- Fix error in NO_DIVIDE option of adler32.c
|
||||
|
||||
Changes in 1.2.0.8 (4 November 2003)
|
||||
- Update version in contrib/delphi/ZLib.pas and contrib/pascal/zlibpas.pas
|
||||
- Add experimental NO_DIVIDE #define in adler32.c
|
||||
- Possibly faster on some processors (let me know if it is)
|
||||
- Correct Z_BLOCK to not return on first inflate call if no wrap
|
||||
- Fix strm->data_type on inflate() return to correctly indicate EOB
|
||||
- Add deflatePrime() function for appending in the middle of a byte
|
||||
- Add contrib/gzappend for an example of appending to a stream
|
||||
- Update win32/DLL_FAQ.txt [Truta]
|
||||
- Delete Turbo C comment in README [Truta]
|
||||
- Improve some indentation in zconf.h [Truta]
|
||||
- Fix infinite loop on bad input in configure script [Church]
|
||||
- Fix gzeof() for concatenated gzip files [Johnson]
|
||||
- Add example to contrib/visual-basic.txt [Michael B.]
|
||||
- Add -p to mkdir's in Makefile.in [vda]
|
||||
- Fix configure to properly detect presence or lack of printf functions
|
||||
- Add AS400 support [Monnerat]
|
||||
- Add a little Cygwin support [Wilson]
|
||||
|
||||
Changes in 1.2.0.7 (21 September 2003)
|
||||
- Correct some debug formats in contrib/infback9
|
||||
- Cast a type in a debug statement in trees.c
|
||||
- Change search and replace delimiter in configure from % to # [Beebe]
|
||||
- Update contrib/untgz to 0.2 with various fixes [Truta]
|
||||
- Add build support for Amiga [Nikl]
|
||||
- Remove some directories in old that have been updated to 1.2
|
||||
- Add dylib building for Mac OS X in configure and Makefile.in
|
||||
- Remove old distribution stuff from Makefile
|
||||
- Update README to point to DLL_FAQ.txt, and add comment on Mac OS X
|
||||
- Update links in README
|
||||
|
||||
Changes in 1.2.0.6 (13 September 2003)
|
||||
- Minor FAQ updates
|
||||
- Update contrib/minizip to 1.00 [Vollant]
|
||||
- Remove test of gz functions in example.c when GZ_COMPRESS defined [Truta]
|
||||
- Update POSTINC comment for 68060 [Nikl]
|
||||
- Add contrib/infback9 with deflate64 decoding (unsupported)
|
||||
- For MVS define NO_vsnprintf and undefine FAR [van Burik]
|
||||
- Add pragma for fdopen on MVS [van Burik]
|
||||
|
||||
Changes in 1.2.0.5 (8 September 2003)
|
||||
- Add OF to inflateBackEnd() declaration in zlib.h
|
||||
- Remember start when using gzdopen in the middle of a file
|
||||
- Use internal off_t counters in gz* functions to properly handle seeks
|
||||
- Perform more rigorous check for distance-too-far in inffast.c
|
||||
- Add Z_BLOCK flush option to return from inflate at block boundary
|
||||
- Set strm->data_type on return from inflate
|
||||
- Indicate bits unused, if at block boundary, and if in last block
|
||||
- Replace size_t with ptrdiff_t in crc32.c, and check for correct size
|
||||
- Add condition so old NO_DEFLATE define still works for compatibility
|
||||
- FAQ update regarding the Windows DLL [Truta]
|
||||
- INDEX update: add qnx entry, remove aix entry [Truta]
|
||||
- Install zlib.3 into mandir [Wilson]
|
||||
- Move contrib/zlib_dll_FAQ.txt to win32/DLL_FAQ.txt; update [Truta]
|
||||
- Adapt the zlib interface to the new DLL convention guidelines [Truta]
|
||||
- Introduce ZLIB_WINAPI macro to allow the export of functions using
|
||||
the WINAPI calling convention, for Visual Basic [Vollant, Truta]
|
||||
- Update msdos and win32 scripts and makefiles [Truta]
|
||||
- Export symbols by name, not by ordinal, in win32/zlib.def [Truta]
|
||||
- Add contrib/ada [Anisimkov]
|
||||
- Move asm files from contrib/vstudio/vc70_32 to contrib/asm386 [Truta]
|
||||
- Rename contrib/asm386 to contrib/masmx86 [Truta, Vollant]
|
||||
- Add contrib/masm686 [Truta]
|
||||
- Fix offsets in contrib/inflate86 and contrib/masmx86/inffas32.asm
|
||||
[Truta, Vollant]
|
||||
- Update contrib/delphi; rename to contrib/pascal; add example [Truta]
|
||||
- Remove contrib/delphi2; add a new contrib/delphi [Truta]
|
||||
- Avoid inclusion of the nonstandard <memory.h> in contrib/iostream,
|
||||
and fix some method prototypes [Truta]
|
||||
- Fix the ZCR_SEED2 constant to avoid warnings in contrib/minizip
|
||||
[Truta]
|
||||
- Avoid the use of backslash (\) in contrib/minizip [Vollant]
|
||||
- Fix file time handling in contrib/untgz; update makefiles [Truta]
|
||||
- Update contrib/vstudio/vc70_32 to comply with the new DLL guidelines
|
||||
[Vollant]
|
||||
- Remove contrib/vstudio/vc15_16 [Vollant]
|
||||
- Rename contrib/vstudio/vc70_32 to contrib/vstudio/vc7 [Truta]
|
||||
- Update README.contrib [Truta]
|
||||
- Invert the assignment order of match_head and s->prev[...] in
|
||||
INSERT_STRING [Truta]
|
||||
- Compare TOO_FAR with 32767 instead of 32768, to avoid 16-bit warnings
|
||||
[Truta]
|
||||
- Compare function pointers with 0, not with NULL or Z_NULL [Truta]
|
||||
- Fix prototype of syncsearch in inflate.c [Truta]
|
||||
- Introduce ASMINF macro to be enabled when using an ASM implementation
|
||||
of inflate_fast [Truta]
|
||||
- Change NO_DEFLATE to NO_GZCOMPRESS [Truta]
|
||||
- Modify test_gzio in example.c to take a single file name as a
|
||||
parameter [Truta]
|
||||
- Exit the example.c program if gzopen fails [Truta]
|
||||
- Add type casts around strlen in example.c [Truta]
|
||||
- Remove casting to sizeof in minigzip.c; give a proper type
|
||||
to the variable compared with SUFFIX_LEN [Truta]
|
||||
- Update definitions of STDC and STDC99 in zconf.h [Truta]
|
||||
- Synchronize zconf.h with the new Windows DLL interface [Truta]
|
||||
- Use SYS16BIT instead of __32BIT__ to distinguish between
|
||||
16- and 32-bit platforms [Truta]
|
||||
- Use far memory allocators in small 16-bit memory models for
|
||||
Turbo C [Truta]
|
||||
- Add info about the use of ASMV, ASMINF and ZLIB_WINAPI in
|
||||
zlibCompileFlags [Truta]
|
||||
- Cygwin has vsnprintf [Wilson]
|
||||
- In Windows16, OS_CODE is 0, as in MSDOS [Truta]
|
||||
- In Cygwin, OS_CODE is 3 (Unix), not 11 (Windows32) [Wilson]
|
||||
|
||||
Changes in 1.2.0.4 (10 August 2003)
|
||||
- Minor FAQ updates
|
||||
- Be more strict when checking inflateInit2's windowBits parameter
|
||||
- Change NO_GUNZIP compile option to NO_GZIP to cover deflate as well
|
||||
- Add gzip wrapper option to deflateInit2 using windowBits
|
||||
- Add updated QNX rule in configure and qnx directory [Bonnefoy]
|
||||
- Make inflate distance-too-far checks more rigorous
|
||||
- Clean up FAR usage in inflate
|
||||
- Add casting to sizeof() in gzio.c and minigzip.c
|
||||
|
||||
Changes in 1.2.0.3 (19 July 2003)
|
||||
- Fix silly error in gzungetc() implementation [Vollant]
|
||||
- Update contrib/minizip and contrib/vstudio [Vollant]
|
||||
- Fix printf format in example.c
|
||||
- Correct cdecl support in zconf.in.h [Anisimkov]
|
||||
- Minor FAQ updates
|
||||
|
||||
Changes in 1.2.0.2 (13 July 2003)
|
||||
- Add ZLIB_VERNUM in zlib.h for numerical preprocessor comparisons
|
||||
- Attempt to avoid warnings in crc32.c for pointer-int conversion
|
||||
- Add AIX to configure, remove aix directory [Bakker]
|
||||
- Add some casts to minigzip.c
|
||||
- Improve checking after insecure sprintf() or vsprintf() calls
|
||||
- Remove #elif's from crc32.c
|
||||
- Change leave label to inf_leave in inflate.c and infback.c to avoid
|
||||
library conflicts
|
||||
- Remove inflate gzip decoding by default--only enable gzip decoding by
|
||||
special request for stricter backward compatibility
|
||||
- Add zlibCompileFlags() function to return compilation information
|
||||
- More typecasting in deflate.c to avoid warnings
|
||||
- Remove leading underscore from _Capital #defines [Truta]
|
||||
- Fix configure to link shared library when testing
|
||||
- Add some Windows CE target adjustments [Mai]
|
||||
- Remove #define ZLIB_DLL in zconf.h [Vollant]
|
||||
- Add zlib.3 [Rodgers]
|
||||
- Update RFC URL in deflate.c and algorithm.txt [Mai]
|
||||
- Add zlib_dll_FAQ.txt to contrib [Truta]
|
||||
- Add UL to some constants [Truta]
|
||||
- Update minizip and vstudio [Vollant]
|
||||
- Remove vestigial NEED_DUMMY_RETURN from zconf.in.h
|
||||
- Expand use of NO_DUMMY_DECL to avoid all dummy structures
|
||||
- Added iostream3 to contrib [Schwardt]
|
||||
- Replace rewind() with fseek() for WinCE [Truta]
|
||||
- Improve setting of zlib format compression level flags
|
||||
- Report 0 for huffman and rle strategies and for level == 0 or 1
|
||||
- Report 2 only for level == 6
|
||||
- Only deal with 64K limit when necessary at compile time [Truta]
|
||||
- Allow TOO_FAR check to be turned off at compile time [Truta]
|
||||
- Add gzclearerr() function [Souza]
|
||||
- Add gzungetc() function
|
||||
|
||||
Changes in 1.2.0.1 (17 March 2003)
|
||||
- Add Z_RLE strategy for run-length encoding [Truta]
|
||||
- When Z_RLE requested, restrict matches to distance one
|
||||
- Update zlib.h, minigzip.c, gzopen(), gzdopen() for Z_RLE
|
||||
- Correct FASTEST compilation to allow level == 0
|
||||
- Clean up what gets compiled for FASTEST
|
||||
- Incorporate changes to zconf.in.h [Vollant]
|
||||
- Refine detection of Turbo C need for dummy returns
|
||||
- Refine ZLIB_DLL compilation
|
||||
- Include additional header file on VMS for off_t typedef
|
||||
- Try to use _vsnprintf where it supplants vsprintf [Vollant]
|
||||
- Add some casts in inffast.c
|
||||
- Enchance comments in zlib.h on what happens if gzprintf() tries to
|
||||
write more than 4095 bytes before compression
|
||||
- Remove unused state from inflateBackEnd()
|
||||
- Remove exit(0) from minigzip.c, example.c
|
||||
- Get rid of all those darn tabs
|
||||
- Add "check" target to Makefile.in that does the same thing as "test"
|
||||
- Add "mostlyclean" and "maintainer-clean" targets to Makefile.in
|
||||
- Update contrib/inflate86 [Anderson]
|
||||
- Update contrib/testzlib, contrib/vstudio, contrib/minizip [Vollant]
|
||||
- Add msdos and win32 directories with makefiles [Truta]
|
||||
- More additions and improvements to the FAQ
|
||||
|
||||
Changes in 1.2.0 (9 March 2003)
|
||||
- New and improved inflate code
|
||||
- About 20% faster
|
||||
- Does not allocate 32K window unless and until needed
|
||||
- Automatically detects and decompresses gzip streams
|
||||
- Raw inflate no longer needs an extra dummy byte at end
|
||||
- Added inflateBack functions using a callback interface--even faster
|
||||
than inflate, useful for file utilities (gzip, zip)
|
||||
- Added inflateCopy() function to record state for random access on
|
||||
externally generated deflate streams (e.g. in gzip files)
|
||||
- More readable code (I hope)
|
||||
- New and improved crc32()
|
||||
- About 50% faster, thanks to suggestions from Rodney Brown
|
||||
- Add deflateBound() and compressBound() functions
|
||||
- Fix memory leak in deflateInit2()
|
||||
- Permit setting dictionary for raw deflate (for parallel deflate)
|
||||
- Fix const declaration for gzwrite()
|
||||
- Check for some malloc() failures in gzio.c
|
||||
- Fix bug in gzopen() on single-byte file 0x1f
|
||||
- Fix bug in gzread() on concatenated file with 0x1f at end of buffer
|
||||
and next buffer doesn't start with 0x8b
|
||||
- Fix uncompress() to return Z_DATA_ERROR on truncated input
|
||||
- Free memory at end of example.c
|
||||
- Remove MAX #define in trees.c (conflicted with some libraries)
|
||||
- Fix static const's in deflate.c, gzio.c, and zutil.[ch]
|
||||
- Declare malloc() and free() in gzio.c if STDC not defined
|
||||
- Use malloc() instead of calloc() in zutil.c if int big enough
|
||||
- Define STDC for AIX
|
||||
- Add aix/ with approach for compiling shared library on AIX
|
||||
- Add HP-UX support for shared libraries in configure
|
||||
- Add OpenUNIX support for shared libraries in configure
|
||||
- Use $cc instead of gcc to build shared library
|
||||
- Make prefix directory if needed when installing
|
||||
- Correct Macintosh avoidance of typedef Byte in zconf.h
|
||||
- Correct Turbo C memory allocation when under Linux
|
||||
- Use libz.a instead of -lz in Makefile (assure use of compiled library)
|
||||
- Update configure to check for snprintf or vsnprintf functions and their
|
||||
return value, warn during make if using an insecure function
|
||||
- Fix configure problem with compile-time knowledge of HAVE_UNISTD_H that
|
||||
is lost when library is used--resolution is to build new zconf.h
|
||||
- Documentation improvements (in zlib.h):
|
||||
- Document raw deflate and inflate
|
||||
- Update RFCs URL
|
||||
- Point out that zlib and gzip formats are different
|
||||
- Note that Z_BUF_ERROR is not fatal
|
||||
- Document string limit for gzprintf() and possible buffer overflow
|
||||
- Note requirement on avail_out when flushing
|
||||
- Note permitted values of flush parameter of inflate()
|
||||
- Add some FAQs (and even answers) to the FAQ
|
||||
- Add contrib/inflate86/ for x86 faster inflate
|
||||
- Add contrib/blast/ for PKWare Data Compression Library decompression
|
||||
- Add contrib/puff/ simple inflate for deflate format description
|
||||
|
||||
Changes in 1.1.4 (11 March 2002)
|
||||
- ZFREE was repeated on same allocation on some error conditions.
|
||||
This creates a security problem described in
|
||||
http://www.zlib.org/advisory-2002-03-11.txt
|
||||
- Returned incorrect error (Z_MEM_ERROR) on some invalid data
|
||||
- Avoid accesses before window for invalid distances with inflate window
|
||||
less than 32K.
|
||||
- force windowBits > 8 to avoid a bug in the encoder for a window size
|
||||
of 256 bytes. (A complete fix will be available in 1.1.5).
|
||||
|
||||
Changes in 1.1.3 (9 July 1998)
|
||||
- fix "an inflate input buffer bug that shows up on rare but persistent
|
||||
occasions" (Mark)
|
||||
- fix gzread and gztell for concatenated .gz files (Didier Le Botlan)
|
||||
- fix gzseek(..., SEEK_SET) in write mode
|
||||
- fix crc check after a gzeek (Frank Faubert)
|
||||
- fix miniunzip when the last entry in a zip file is itself a zip file
|
||||
(J Lillge)
|
||||
- add contrib/asm586 and contrib/asm686 (Brian Raiter)
|
||||
See http://www.muppetlabs.com/~breadbox/software/assembly.html
|
||||
- add support for Delphi 3 in contrib/delphi (Bob Dellaca)
|
||||
- add support for C++Builder 3 and Delphi 3 in contrib/delphi2 (Davide Moretti)
|
||||
- do not exit prematurely in untgz if 0 at start of block (Magnus Holmgren)
|
||||
- use macro EXTERN instead of extern to support DLL for BeOS (Sander Stoks)
|
||||
- added a FAQ file
|
||||
|
||||
- Support gzdopen on Mac with Metrowerks (Jason Linhart)
|
||||
- Do not redefine Byte on Mac (Brad Pettit & Jason Linhart)
|
||||
- define SEEK_END too if SEEK_SET is not defined (Albert Chin-A-Young)
|
||||
- avoid some warnings with Borland C (Tom Tanner)
|
||||
- fix a problem in contrib/minizip/zip.c for 16-bit MSDOS (Gilles Vollant)
|
||||
- emulate utime() for WIN32 in contrib/untgz (Gilles Vollant)
|
||||
- allow several arguments to configure (Tim Mooney, Frodo Looijaard)
|
||||
- use libdir and includedir in Makefile.in (Tim Mooney)
|
||||
- support shared libraries on OSF1 V4 (Tim Mooney)
|
||||
- remove so_locations in "make clean" (Tim Mooney)
|
||||
- fix maketree.c compilation error (Glenn, Mark)
|
||||
- Python interface to zlib now in Python 1.5 (Jeremy Hylton)
|
||||
- new Makefile.riscos (Rich Walker)
|
||||
- initialize static descriptors in trees.c for embedded targets (Nick Smith)
|
||||
- use "foo-gz" in example.c for RISCOS and VMS (Nick Smith)
|
||||
- add the OS/2 files in Makefile.in too (Andrew Zabolotny)
|
||||
- fix fdopen and halloc macros for Microsoft C 6.0 (Tom Lane)
|
||||
- fix maketree.c to allow clean compilation of inffixed.h (Mark)
|
||||
- fix parameter check in deflateCopy (Gunther Nikl)
|
||||
- cleanup trees.c, use compressed_len only in debug mode (Christian Spieler)
|
||||
- Many portability patches by Christian Spieler:
|
||||
. zutil.c, zutil.h: added "const" for zmem*
|
||||
. Make_vms.com: fixed some typos
|
||||
. Make_vms.com: msdos/Makefile.*: removed zutil.h from some dependency lists
|
||||
. msdos/Makefile.msc: remove "default rtl link library" info from obj files
|
||||
. msdos/Makefile.*: use model-dependent name for the built zlib library
|
||||
. msdos/Makefile.emx, nt/Makefile.emx, nt/Makefile.gcc:
|
||||
new makefiles, for emx (DOS/OS2), emx&rsxnt and mingw32 (Windows 9x / NT)
|
||||
- use define instead of typedef for Bytef also for MSC small/medium (Tom Lane)
|
||||
- replace __far with _far for better portability (Christian Spieler, Tom Lane)
|
||||
- fix test for errno.h in configure (Tim Newsham)
|
||||
|
||||
Changes in 1.1.2 (19 March 98)
|
||||
- added contrib/minzip, mini zip and unzip based on zlib (Gilles Vollant)
|
||||
See http://www.winimage.com/zLibDll/unzip.html
|
||||
- preinitialize the inflate tables for fixed codes, to make the code
|
||||
completely thread safe (Mark)
|
||||
- some simplifications and slight speed-up to the inflate code (Mark)
|
||||
- fix gzeof on non-compressed files (Allan Schrum)
|
||||
- add -std1 option in configure for OSF1 to fix gzprintf (Martin Mokrejs)
|
||||
- use default value of 4K for Z_BUFSIZE for 16-bit MSDOS (Tim Wegner + Glenn)
|
||||
- added os2/Makefile.def and os2/zlib.def (Andrew Zabolotny)
|
||||
- add shared lib support for UNIX_SV4.2MP (MATSUURA Takanori)
|
||||
- do not wrap extern "C" around system includes (Tom Lane)
|
||||
- mention zlib binding for TCL in README (Andreas Kupries)
|
||||
- added amiga/Makefile.pup for Amiga powerUP SAS/C PPC (Andreas Kleinert)
|
||||
- allow "make install prefix=..." even after configure (Glenn Randers-Pehrson)
|
||||
- allow "configure --prefix $HOME" (Tim Mooney)
|
||||
- remove warnings in example.c and gzio.c (Glenn Randers-Pehrson)
|
||||
- move Makefile.sas to amiga/Makefile.sas
|
||||
|
||||
Changes in 1.1.1 (27 Feb 98)
|
||||
- fix macros _tr_tally_* in deflate.h for debug mode (Glenn Randers-Pehrson)
|
||||
- remove block truncation heuristic which had very marginal effect for zlib
|
||||
(smaller lit_bufsize than in gzip 1.2.4) and degraded a little the
|
||||
compression ratio on some files. This also allows inlining _tr_tally for
|
||||
matches in deflate_slow.
|
||||
- added msdos/Makefile.w32 for WIN32 Microsoft Visual C++ (Bob Frazier)
|
||||
|
||||
Changes in 1.1.0 (24 Feb 98)
|
||||
- do not return STREAM_END prematurely in inflate (John Bowler)
|
||||
- revert to the zlib 1.0.8 inflate to avoid the gcc 2.8.0 bug (Jeremy Buhler)
|
||||
- compile with -DFASTEST to get compression code optimized for speed only
|
||||
- in minigzip, try mmap'ing the input file first (Miguel Albrecht)
|
||||
- increase size of I/O buffers in minigzip.c and gzio.c (not a big gain
|
||||
on Sun but significant on HP)
|
||||
|
||||
- add a pointer to experimental unzip library in README (Gilles Vollant)
|
||||
- initialize variable gcc in configure (Chris Herborth)
|
||||
|
||||
Changes in 1.0.9 (17 Feb 1998)
|
||||
- added gzputs and gzgets functions
|
||||
- do not clear eof flag in gzseek (Mark Diekhans)
|
||||
- fix gzseek for files in transparent mode (Mark Diekhans)
|
||||
- do not assume that vsprintf returns the number of bytes written (Jens Krinke)
|
||||
- replace EXPORT with ZEXPORT to avoid conflict with other programs
|
||||
- added compress2 in zconf.h, zlib.def, zlib.dnt
|
||||
- new asm code from Gilles Vollant in contrib/asm386
|
||||
- simplify the inflate code (Mark):
|
||||
. Replace ZALLOC's in huft_build() with single ZALLOC in inflate_blocks_new()
|
||||
. ZALLOC the length list in inflate_trees_fixed() instead of using stack
|
||||
. ZALLOC the value area for huft_build() instead of using stack
|
||||
. Simplify Z_FINISH check in inflate()
|
||||
|
||||
- Avoid gcc 2.8.0 comparison bug a little differently than zlib 1.0.8
|
||||
- in inftrees.c, avoid cc -O bug on HP (Farshid Elahi)
|
||||
- in zconf.h move the ZLIB_DLL stuff earlier to avoid problems with
|
||||
the declaration of FAR (Gilles VOllant)
|
||||
- install libz.so* with mode 755 (executable) instead of 644 (Marc Lehmann)
|
||||
- read_buf buf parameter of type Bytef* instead of charf*
|
||||
- zmemcpy parameters are of type Bytef*, not charf* (Joseph Strout)
|
||||
- do not redeclare unlink in minigzip.c for WIN32 (John Bowler)
|
||||
- fix check for presence of directories in "make install" (Ian Willis)
|
||||
|
||||
Changes in 1.0.8 (27 Jan 1998)
|
||||
- fixed offsets in contrib/asm386/gvmat32.asm (Gilles Vollant)
|
||||
- fix gzgetc and gzputc for big endian systems (Markus Oberhumer)
|
||||
- added compress2() to allow setting the compression level
|
||||
- include sys/types.h to get off_t on some systems (Marc Lehmann & QingLong)
|
||||
- use constant arrays for the static trees in trees.c instead of computing
|
||||
them at run time (thanks to Ken Raeburn for this suggestion). To create
|
||||
trees.h, compile with GEN_TREES_H and run "make test".
|
||||
- check return code of example in "make test" and display result
|
||||
- pass minigzip command line options to file_compress
|
||||
- simplifying code of inflateSync to avoid gcc 2.8 bug
|
||||
|
||||
- support CC="gcc -Wall" in configure -s (QingLong)
|
||||
- avoid a flush caused by ftell in gzopen for write mode (Ken Raeburn)
|
||||
- fix test for shared library support to avoid compiler warnings
|
||||
- zlib.lib -> zlib.dll in msdos/zlib.rc (Gilles Vollant)
|
||||
- check for TARGET_OS_MAC in addition to MACOS (Brad Pettit)
|
||||
- do not use fdopen for Metrowerks on Mac (Brad Pettit))
|
||||
- add checks for gzputc and gzputc in example.c
|
||||
- avoid warnings in gzio.c and deflate.c (Andreas Kleinert)
|
||||
- use const for the CRC table (Ken Raeburn)
|
||||
- fixed "make uninstall" for shared libraries
|
||||
- use Tracev instead of Trace in infblock.c
|
||||
- in example.c use correct compressed length for test_sync
|
||||
- suppress +vnocompatwarnings in configure for HPUX (not always supported)
|
||||
|
||||
Changes in 1.0.7 (20 Jan 1998)
|
||||
- fix gzseek which was broken in write mode
|
||||
- return error for gzseek to negative absolute position
|
||||
- fix configure for Linux (Chun-Chung Chen)
|
||||
- increase stack space for MSC (Tim Wegner)
|
||||
- get_crc_table and inflateSyncPoint are EXPORTed (Gilles Vollant)
|
||||
- define EXPORTVA for gzprintf (Gilles Vollant)
|
||||
- added man page zlib.3 (Rick Rodgers)
|
||||
- for contrib/untgz, fix makedir() and improve Makefile
|
||||
|
||||
- check gzseek in write mode in example.c
|
||||
- allocate extra buffer for seeks only if gzseek is actually called
|
||||
- avoid signed/unsigned comparisons (Tim Wegner, Gilles Vollant)
|
||||
- add inflateSyncPoint in zconf.h
|
||||
- fix list of exported functions in nt/zlib.dnt and mdsos/zlib.def
|
||||
|
||||
Changes in 1.0.6 (19 Jan 1998)
|
||||
- add functions gzprintf, gzputc, gzgetc, gztell, gzeof, gzseek, gzrewind and
|
||||
gzsetparams (thanks to Roland Giersig and Kevin Ruland for some of this code)
|
||||
- Fix a deflate bug occurring only with compression level 0 (thanks to
|
||||
Andy Buckler for finding this one).
|
||||
- In minigzip, pass transparently also the first byte for .Z files.
|
||||
- return Z_BUF_ERROR instead of Z_OK if output buffer full in uncompress()
|
||||
- check Z_FINISH in inflate (thanks to Marc Schluper)
|
||||
- Implement deflateCopy (thanks to Adam Costello)
|
||||
- make static libraries by default in configure, add --shared option.
|
||||
- move MSDOS or Windows specific files to directory msdos
|
||||
- suppress the notion of partial flush to simplify the interface
|
||||
(but the symbol Z_PARTIAL_FLUSH is kept for compatibility with 1.0.4)
|
||||
- suppress history buffer provided by application to simplify the interface
|
||||
(this feature was not implemented anyway in 1.0.4)
|
||||
- next_in and avail_in must be initialized before calling inflateInit or
|
||||
inflateInit2
|
||||
- add EXPORT in all exported functions (for Windows DLL)
|
||||
- added Makefile.nt (thanks to Stephen Williams)
|
||||
- added the unsupported "contrib" directory:
|
||||
contrib/asm386/ by Gilles Vollant <info@winimage.com>
|
||||
386 asm code replacing longest_match().
|
||||
contrib/iostream/ by Kevin Ruland <kevin@rodin.wustl.edu>
|
||||
A C++ I/O streams interface to the zlib gz* functions
|
||||
contrib/iostream2/ by Tyge Løvset <Tyge.Lovset@cmr.no>
|
||||
Another C++ I/O streams interface
|
||||
contrib/untgz/ by "Pedro A. Aranda Guti\irrez" <paag@tid.es>
|
||||
A very simple tar.gz file extractor using zlib
|
||||
contrib/visual-basic.txt by Carlos Rios <c_rios@sonda.cl>
|
||||
How to use compress(), uncompress() and the gz* functions from VB.
|
||||
- pass params -f (filtered data), -h (huffman only), -1 to -9 (compression
|
||||
level) in minigzip (thanks to Tom Lane)
|
||||
|
||||
- use const for rommable constants in deflate
|
||||
- added test for gzseek and gztell in example.c
|
||||
- add undocumented function inflateSyncPoint() (hack for Paul Mackerras)
|
||||
- add undocumented function zError to convert error code to string
|
||||
(for Tim Smithers)
|
||||
- Allow compilation of gzio with -DNO_DEFLATE to avoid the compression code.
|
||||
- Use default memcpy for Symantec MSDOS compiler.
|
||||
- Add EXPORT keyword for check_func (needed for Windows DLL)
|
||||
- add current directory to LD_LIBRARY_PATH for "make test"
|
||||
- create also a link for libz.so.1
|
||||
- added support for FUJITSU UXP/DS (thanks to Toshiaki Nomura)
|
||||
- use $(SHAREDLIB) instead of libz.so in Makefile.in (for HPUX)
|
||||
- added -soname for Linux in configure (Chun-Chung Chen,
|
||||
- assign numbers to the exported functions in zlib.def (for Windows DLL)
|
||||
- add advice in zlib.h for best usage of deflateSetDictionary
|
||||
- work around compiler bug on Atari (cast Z_NULL in call of s->checkfn)
|
||||
- allow compilation with ANSI keywords only enabled for TurboC in large model
|
||||
- avoid "versionString"[0] (Borland bug)
|
||||
- add NEED_DUMMY_RETURN for Borland
|
||||
- use variable z_verbose for tracing in debug mode (L. Peter Deutsch).
|
||||
- allow compilation with CC
|
||||
- defined STDC for OS/2 (David Charlap)
|
||||
- limit external names to 8 chars for MVS (Thomas Lund)
|
||||
- in minigzip.c, use static buffers only for 16-bit systems
|
||||
- fix suffix check for "minigzip -d foo.gz"
|
||||
- do not return an error for the 2nd of two consecutive gzflush() (Felix Lee)
|
||||
- use _fdopen instead of fdopen for MSC >= 6.0 (Thomas Fanslau)
|
||||
- added makelcc.bat for lcc-win32 (Tom St Denis)
|
||||
- in Makefile.dj2, use copy and del instead of install and rm (Frank Donahoe)
|
||||
- Avoid expanded $Id$. Use "rcs -kb" or "cvs admin -kb" to avoid Id expansion.
|
||||
- check for unistd.h in configure (for off_t)
|
||||
- remove useless check parameter in inflate_blocks_free
|
||||
- avoid useless assignment of s->check to itself in inflate_blocks_new
|
||||
- do not flush twice in gzclose (thanks to Ken Raeburn)
|
||||
- rename FOPEN as F_OPEN to avoid clash with /usr/include/sys/file.h
|
||||
- use NO_ERRNO_H instead of enumeration of operating systems with errno.h
|
||||
- work around buggy fclose on pipes for HP/UX
|
||||
- support zlib DLL with BORLAND C++ 5.0 (thanks to Glenn Randers-Pehrson)
|
||||
- fix configure if CC is already equal to gcc
|
||||
|
||||
Changes in 1.0.5 (3 Jan 98)
|
||||
- Fix inflate to terminate gracefully when fed corrupted or invalid data
|
||||
- Use const for rommable constants in inflate
|
||||
- Eliminate memory leaks on error conditions in inflate
|
||||
- Removed some vestigial code in inflate
|
||||
- Update web address in README
|
||||
|
||||
Changes in 1.0.4 (24 Jul 96)
|
||||
- In very rare conditions, deflate(s, Z_FINISH) could fail to produce an EOF
|
||||
bit, so the decompressor could decompress all the correct data but went
|
||||
on to attempt decompressing extra garbage data. This affected minigzip too.
|
||||
- zlibVersion and gzerror return const char* (needed for DLL)
|
||||
- port to RISCOS (no fdopen, no multiple dots, no unlink, no fileno)
|
||||
- use z_error only for DEBUG (avoid problem with DLLs)
|
||||
|
||||
Changes in 1.0.3 (2 Jul 96)
|
||||
- use z_streamp instead of z_stream *, which is now a far pointer in MSDOS
|
||||
small and medium models; this makes the library incompatible with previous
|
||||
versions for these models. (No effect in large model or on other systems.)
|
||||
- return OK instead of BUF_ERROR if previous deflate call returned with
|
||||
avail_out as zero but there is nothing to do
|
||||
- added memcmp for non STDC compilers
|
||||
- define NO_DUMMY_DECL for more Mac compilers (.h files merged incorrectly)
|
||||
- define __32BIT__ if __386__ or i386 is defined (pb. with Watcom and SCO)
|
||||
- better check for 16-bit mode MSC (avoids problem with Symantec)
|
||||
|
||||
Changes in 1.0.2 (23 May 96)
|
||||
- added Windows DLL support
|
||||
- added a function zlibVersion (for the DLL support)
|
||||
- fixed declarations using Bytef in infutil.c (pb with MSDOS medium model)
|
||||
- Bytef is define's instead of typedef'd only for Borland C
|
||||
- avoid reading uninitialized memory in example.c
|
||||
- mention in README that the zlib format is now RFC1950
|
||||
- updated Makefile.dj2
|
||||
- added algorithm.doc
|
||||
|
||||
Changes in 1.0.1 (20 May 96) [1.0 skipped to avoid confusion]
|
||||
- fix array overlay in deflate.c which sometimes caused bad compressed data
|
||||
- fix inflate bug with empty stored block
|
||||
- fix MSDOS medium model which was broken in 0.99
|
||||
- fix deflateParams() which could 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()
|
339
lib/zlib-1.2.3/FAQ
Normal file
339
lib/zlib-1.2.3/FAQ
Normal file
|
@ -0,0 +1,339 @@
|
|||
|
||||
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.dogma.net/markn/articles/zlibtool/zlibtool.htm
|
||||
* contrib/visual-basic.txt in the zlib distribution
|
||||
* win32/DLL_FAQ.txt in the zlib distribution
|
||||
|
||||
4. compress() returns Z_BUF_ERROR.
|
||||
|
||||
Make sure that before the call of compress, the length of the compressed
|
||||
buffer is equal to the 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 us (zlib@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?
|
||||
|
||||
Not by itself, no. See the directory contrib/minizip in the zlib
|
||||
distribution.
|
||||
|
||||
12. Can zlib handle .Z files?
|
||||
|
||||
No, sorry. You have to spawn an uncompress or gunzip subprocess, or adapt
|
||||
the code of uncompress on your own.
|
||||
|
||||
13. How can I make a Unix shared library?
|
||||
|
||||
make clean
|
||||
./configure -s
|
||||
make
|
||||
|
||||
14. How do I install a shared zlib library on Unix?
|
||||
|
||||
After the above, then:
|
||||
|
||||
make install
|
||||
|
||||
However, many flavors of Unix come with a shared zlib already installed.
|
||||
Before going to the trouble of compiling a shared version of zlib and
|
||||
trying to install it, you may want to check if it's already there! If you
|
||||
can #include <zlib.h>, it's there. The -lz option will probably link to it.
|
||||
|
||||
15. I have a question about OttoPDF.
|
||||
|
||||
We are not the authors of OttoPDF. The real author is on the OttoPDF web
|
||||
site: Joel Hainley, jhainley@myndkryme.com.
|
||||
|
||||
16. Can zlib decode Flate data in an Adobe PDF file?
|
||||
|
||||
Yes. See http://www.fastio.com/ (ClibPDF), or http://www.pdflib.com/ .
|
||||
To modify PDF forms, see http://sourceforge.net/projects/acroformtool/ .
|
||||
|
||||
17. Why am I getting this "register_frame_info not found" error on Solaris?
|
||||
|
||||
After installing zlib 1.1.4 on Solaris 2.6, running applications using zlib
|
||||
generates an error such as:
|
||||
|
||||
ld.so.1: rpm: fatal: relocation error: file /usr/local/lib/libz.so:
|
||||
symbol __register_frame_info: referenced symbol not found
|
||||
|
||||
The symbol __register_frame_info is not part of zlib, it is generated by
|
||||
the C compiler (cc or gcc). You must recompile applications using zlib
|
||||
which have this problem. This problem is specific to Solaris. See
|
||||
http://www.sunfreeware.com for Solaris versions of zlib and applications
|
||||
using zlib.
|
||||
|
||||
18. Why does gzip give an error on a file I make with compress/deflate?
|
||||
|
||||
The compress and deflate functions produce data in the zlib format, which
|
||||
is different and incompatible with the gzip format. The gz* functions in
|
||||
zlib on the other hand use the gzip format. Both the zlib and gzip
|
||||
formats use the same compressed data format internally, but have different
|
||||
headers and trailers around the compressed data.
|
||||
|
||||
19. Ok, so why are there two different formats?
|
||||
|
||||
The gzip format was designed to retain the directory information about
|
||||
a single file, such as the name and last modification date. The zlib
|
||||
format on the other hand was designed for in-memory and communication
|
||||
channel applications, and has a much more compact header and trailer and
|
||||
uses a faster integrity check than gzip.
|
||||
|
||||
20. Well that's nice, but how do I make a gzip file in memory?
|
||||
|
||||
You can request that deflate write the gzip format instead of the zlib
|
||||
format using deflateInit2(). You can also request that inflate decode
|
||||
the gzip format using inflateInit2(). Read zlib.h for more details.
|
||||
|
||||
21. Is zlib thread-safe?
|
||||
|
||||
Yes. However any library routines that zlib uses and any application-
|
||||
provided memory allocation routines must also be thread-safe. zlib's gz*
|
||||
functions use stdio library routines, and most of zlib's functions use the
|
||||
library memory allocation routines by default. zlib's Init functions allow
|
||||
for the application to provide custom memory allocation routines.
|
||||
|
||||
Of course, you should only operate on any given zlib or gzip stream from a
|
||||
single thread at a time.
|
||||
|
||||
22. Can I use zlib in my commercial application?
|
||||
|
||||
Yes. Please read the license in zlib.h.
|
||||
|
||||
23. Is zlib under the GNU license?
|
||||
|
||||
No. Please read the license in zlib.h.
|
||||
|
||||
24. The license says that altered source versions must be "plainly marked". So
|
||||
what exactly do I need to do to meet that requirement?
|
||||
|
||||
You need to change the ZLIB_VERSION and ZLIB_VERNUM #defines in zlib.h. In
|
||||
particular, the final version number needs to be changed to "f", and an
|
||||
identification string should be appended to ZLIB_VERSION. Version numbers
|
||||
x.x.x.f are reserved for modifications to zlib by others than the zlib
|
||||
maintainers. For example, if the version of the base zlib you are altering
|
||||
is "1.2.3.4", then in zlib.h you should change ZLIB_VERNUM to 0x123f, and
|
||||
ZLIB_VERSION to something like "1.2.3.f-zachary-mods-v3". You can also
|
||||
update the version strings in deflate.c and inftrees.c.
|
||||
|
||||
For altered source distributions, you should also note the origin and
|
||||
nature of the changes in zlib.h, as well as in ChangeLog and README, along
|
||||
with the dates of the alterations. The origin should include at least your
|
||||
name (or your company's name), and an email address to contact for help or
|
||||
issues with the library.
|
||||
|
||||
Note that distributing a compiled zlib library along with zlib.h and
|
||||
zconf.h is also a source distribution, and so you should change
|
||||
ZLIB_VERSION and ZLIB_VERNUM and note the origin and nature of the changes
|
||||
in zlib.h as you would for a full source distribution.
|
||||
|
||||
25. Will zlib work on a big-endian or little-endian architecture, and can I
|
||||
exchange compressed data between them?
|
||||
|
||||
Yes and yes.
|
||||
|
||||
26. Will zlib work on a 64-bit machine?
|
||||
|
||||
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
|
||||
|
||||
27. Will zlib decompress data from the PKWare Data Compression Library?
|
||||
|
||||
No. The PKWare DCL uses a completely different compressed data format
|
||||
than does PKZIP and zlib. However, you can look in zlib's contrib/blast
|
||||
directory for a possible solution to your problem.
|
||||
|
||||
28. Can I access data randomly in a compressed stream?
|
||||
|
||||
No, not without some preparation. If when compressing you periodically
|
||||
use Z_FULL_FLUSH, carefully write all the pending data at those points,
|
||||
and keep an index of those locations, then you can start decompression
|
||||
at those points. You have to be careful to not use Z_FULL_FLUSH too
|
||||
often, since it can significantly degrade compression.
|
||||
|
||||
29. 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.
|
||||
|
||||
30. Is there some simpler, easier to read version of inflate I can look at
|
||||
to understand the deflate format?
|
||||
|
||||
First off, you should read RFC 1951. Second, yes. Look in zlib's
|
||||
contrib/puff directory.
|
||||
|
||||
31. Does zlib infringe on any patents?
|
||||
|
||||
As far as we know, no. In fact, that was originally the whole point behind
|
||||
zlib. Look here for some more information:
|
||||
|
||||
http://www.gzip.org/#faq11
|
||||
|
||||
32. Can zlib work with greater than 4 GB of data?
|
||||
|
||||
Yes. inflate() and deflate() will process any amount of data correctly.
|
||||
Each call of inflate() or deflate() is limited to input and output chunks
|
||||
of the maximum value that can be stored in the compiler's "unsigned int"
|
||||
type, but there is no limit to the number of chunks. Note however that the
|
||||
strm.total_in and strm_total_out counters may be limited to 4 GB. These
|
||||
counters are provided as a convenience and are not used internally by
|
||||
inflate() or deflate(). The application can easily set up its own counters
|
||||
updated after each call of inflate() or deflate() to count beyond 4 GB.
|
||||
compress() and uncompress() may be limited to 4 GB, since they operate in a
|
||||
single call. gzseek() and gztell() may be limited to 4 GB depending on how
|
||||
zlib is compiled. See the zlibCompileFlags() function in zlib.h.
|
||||
|
||||
The word "may" appears several times above since there is a 4 GB limit
|
||||
only if the compiler's "long" type is 32 bits. If the compiler's "long"
|
||||
type is 64 bits, then the limit is 16 exabytes.
|
||||
|
||||
33. Does zlib have any security vulnerabilities?
|
||||
|
||||
The only one that we are aware of is potentially in gzprintf(). If zlib
|
||||
is compiled to use sprintf() or vsprintf(), then there is no protection
|
||||
against a buffer overflow of 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.
|
||||
|
||||
34. Is there a Java version of zlib?
|
||||
|
||||
Probably what you want is to use zlib in Java. zlib is already included
|
||||
as part of the Java SDK in the java.util.zip package. If you really want
|
||||
a version of zlib written in the Java language, look on the zlib home
|
||||
page for links: http://www.zlib.org/
|
||||
|
||||
35. I get this or that compiler or source-code scanner warning when I crank it
|
||||
up to maximally-pedantic. Can't you guys write proper code?
|
||||
|
||||
Many years ago, we gave up attempting to avoid warnings on every compiler
|
||||
in the universe. It just got to be a waste of time, and some compilers
|
||||
were downright silly. So now, we simply make sure that the code always
|
||||
works.
|
||||
|
||||
36. Valgrind (or some similar memory access checker) says that deflate is
|
||||
performing a conditional jump that depends on an uninitialized value.
|
||||
Isn't that a bug?
|
||||
|
||||
No. That is intentional for performance reasons, and the output of
|
||||
deflate is not affected. This only started showing up recently since
|
||||
zlib 1.2.x uses malloc() by default for allocations, whereas earlier
|
||||
versions used calloc(), which zeros out the allocated memory.
|
||||
|
||||
37. Will zlib read the (insert any ancient or arcane format here) compressed
|
||||
data format?
|
||||
|
||||
Probably not. Look in the comp.compression FAQ for pointers to various
|
||||
formats and associated software.
|
||||
|
||||
38. How can I encrypt/decrypt zip files with zlib?
|
||||
|
||||
zlib doesn't support encryption. The original PKZIP encryption is very weak
|
||||
and can be broken with freely available programs. To get strong encryption,
|
||||
use GnuPG, http://www.gnupg.org/ , which already includes zlib compression.
|
||||
For PKZIP compatible "encryption", look at http://www.info-zip.org/
|
||||
|
||||
39. What's the difference between the "gzip" and "deflate" HTTP 1.1 encodings?
|
||||
|
||||
"gzip" is the gzip format, and "deflate" is the zlib format. They should
|
||||
probably have called the second one "zlib" instead to avoid confusion
|
||||
with the raw deflate compressed data format. While the HTTP 1.1 RFC 2616
|
||||
correctly points to the zlib specification in RFC 1950 for the "deflate"
|
||||
transfer encoding, there have been reports of servers and browsers that
|
||||
incorrectly produce or expect raw deflate data per the deflate
|
||||
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.
|
||||
|
||||
40. Does zlib support the new "Deflate64" format introduced by PKWare?
|
||||
|
||||
No. PKWare has apparently decided to keep that format proprietary, since
|
||||
they have not documented it as they have previous compression formats.
|
||||
In any case, the compression improvements are so modest compared to other
|
||||
more modern approaches, that it's not worth the effort to implement.
|
||||
|
||||
41. 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.
|
51
lib/zlib-1.2.3/INDEX
Normal file
51
lib/zlib-1.2.3/INDEX
Normal file
|
@ -0,0 +1,51 @@
|
|||
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)
|
||||
|
||||
amiga/ makefiles for Amiga SAS C
|
||||
as400/ makefiles for IBM AS/400
|
||||
msdos/ makefiles for MSDOS
|
||||
old/ makefiles for various architectures and zlib documentation
|
||||
files that have not yet been updated for zlib 1.2.x
|
||||
projects/ projects for various Integrated Development Environments
|
||||
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
lib/zlib-1.2.3/Makefile
Normal file
154
lib/zlib-1.2.3/Makefile
Normal file
|
@ -0,0 +1,154 @@
|
|||
# Makefile for zlib
|
||||
# Copyright (C) 1995-2005 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 -DNO_snprintf -DHAS_sprintf_void -DNO_ERRNO_H
|
||||
#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=-L. libz.a
|
||||
LDSHARED=cc
|
||||
CPP=cc -E
|
||||
|
||||
LIBS=libz.a
|
||||
SHAREDLIB=libz.so
|
||||
SHAREDLIBV=libz.so.1.2.3
|
||||
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
lib/zlib-1.2.3/Makefile.in
Normal file
154
lib/zlib-1.2.3/Makefile.in
Normal file
|
@ -0,0 +1,154 @@
|
|||
# Makefile for zlib
|
||||
# Copyright (C) 1995-2005 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.3
|
||||
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
|
125
lib/zlib-1.2.3/README
Normal file
125
lib/zlib-1.2.3/README
Normal file
|
@ -0,0 +1,125 @@
|
|||
ZLIB DATA COMPRESSION LIBRARY
|
||||
|
||||
zlib 1.2.3 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.
|
||||
|
||||
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.3 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@amk.ca> 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-2004 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.
|
149
lib/zlib-1.2.3/adler32.c
Normal file
149
lib/zlib-1.2.3/adler32.c
Normal file
|
@ -0,0 +1,149 @@
|
|||
/* adler32.c -- compute the Adler-32 checksum of a data stream
|
||||
* Copyright (C) 1995-2004 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) {adler += (buf)[i]; sum2 += adler;}
|
||||
#define DO2(buf,i) DO1(buf,i); DO1(buf,i+1);
|
||||
#define DO4(buf,i) DO2(buf,i); DO2(buf,i+2);
|
||||
#define DO8(buf,i) DO4(buf,i); DO4(buf,i+4);
|
||||
#define DO16(buf) DO8(buf,0); DO8(buf,8);
|
||||
|
||||
/* use NO_DIVIDE if your processor does not do division in hardware */
|
||||
#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)
|
||||
# define MOD4(a) \
|
||||
do { \
|
||||
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
|
||||
# define MOD4(a) a %= BASE
|
||||
#endif
|
||||
|
||||
/* ========================================================================= */
|
||||
uLong ZEXPORT adler32(adler, buf, len)
|
||||
uLong adler;
|
||||
const Bytef *buf;
|
||||
uInt len;
|
||||
{
|
||||
unsigned long sum2;
|
||||
unsigned n;
|
||||
|
||||
/* split Adler-32 into component sums */
|
||||
sum2 = (adler >> 16) & 0xffff;
|
||||
adler &= 0xffff;
|
||||
|
||||
/* in case user likes doing a byte at a time, keep it fast */
|
||||
if (len == 1) {
|
||||
adler += buf[0];
|
||||
if (adler >= BASE)
|
||||
adler -= BASE;
|
||||
sum2 += adler;
|
||||
if (sum2 >= BASE)
|
||||
sum2 -= BASE;
|
||||
return adler | (sum2 << 16);
|
||||
}
|
||||
|
||||
/* initial Adler-32 value (deferred check for len == 1 speed) */
|
||||
if (buf == Z_NULL)
|
||||
return 1L;
|
||||
|
||||
/* in case short lengths are provided, keep it somewhat fast */
|
||||
if (len < 16) {
|
||||
while (len--) {
|
||||
adler += *buf++;
|
||||
sum2 += adler;
|
||||
}
|
||||
if (adler >= BASE)
|
||||
adler -= BASE;
|
||||
MOD4(sum2); /* only added so many BASE's */
|
||||
return adler | (sum2 << 16);
|
||||
}
|
||||
|
||||
/* do length NMAX blocks -- requires just one modulo operation */
|
||||
while (len >= NMAX) {
|
||||
len -= NMAX;
|
||||
n = NMAX / 16; /* NMAX is divisible by 16 */
|
||||
do {
|
||||
DO16(buf); /* 16 sums unrolled */
|
||||
buf += 16;
|
||||
} while (--n);
|
||||
MOD(adler);
|
||||
MOD(sum2);
|
||||
}
|
||||
|
||||
/* do remaining bytes (less than NMAX, still just one modulo) */
|
||||
if (len) { /* avoid modulos if none remaining */
|
||||
while (len >= 16) {
|
||||
len -= 16;
|
||||
DO16(buf);
|
||||
buf += 16;
|
||||
}
|
||||
while (len--) {
|
||||
adler += *buf++;
|
||||
sum2 += adler;
|
||||
}
|
||||
MOD(adler);
|
||||
MOD(sum2);
|
||||
}
|
||||
|
||||
/* return recombined sums */
|
||||
return adler | (sum2 << 16);
|
||||
}
|
||||
|
||||
/* ========================================================================= */
|
||||
uLong ZEXPORT adler32_combine(adler1, adler2, len2)
|
||||
uLong adler1;
|
||||
uLong adler2;
|
||||
z_off_t len2;
|
||||
{
|
||||
unsigned long sum1;
|
||||
unsigned long sum2;
|
||||
unsigned rem;
|
||||
|
||||
/* the derivation of this formula is left as an exercise for the reader */
|
||||
rem = (unsigned)(len2 % BASE);
|
||||
sum1 = adler1 & 0xffff;
|
||||
sum2 = rem * sum1;
|
||||
MOD(sum2);
|
||||
sum1 += (adler2 & 0xffff) + BASE - 1;
|
||||
sum2 += ((adler1 >> 16) & 0xffff) + ((adler2 >> 16) & 0xffff) + BASE - rem;
|
||||
if (sum1 > BASE) sum1 -= BASE;
|
||||
if (sum1 > BASE) sum1 -= BASE;
|
||||
if (sum2 > (BASE << 1)) sum2 -= (BASE << 1);
|
||||
if (sum2 > BASE) sum2 -= BASE;
|
||||
return sum1 | (sum2 << 16);
|
||||
}
|
209
lib/zlib-1.2.3/algorithm.txt
Normal file
209
lib/zlib-1.2.3/algorithm.txt
Normal file
|
@ -0,0 +1,209 @@
|
|||
1. Compression algorithm (deflate)
|
||||
|
||||
The deflation algorithm used by gzip (also zip and zlib) is a variation of
|
||||
LZ77 (Lempel-Ziv 1977, see reference below). It finds duplicated strings in
|
||||
the input data. The second occurrence of a string is replaced by a
|
||||
pointer to the previous string, in the form of a pair (distance,
|
||||
length). Distances are limited to 32K bytes, and lengths are limited
|
||||
to 258 bytes. When a string does not occur anywhere in the previous
|
||||
32K bytes, it is emitted as a sequence of literal bytes. (In this
|
||||
description, `string' must be taken as an arbitrary sequence of bytes,
|
||||
and is not restricted to printable characters.)
|
||||
|
||||
Literals or match lengths are compressed with one Huffman tree, and
|
||||
match distances are compressed with another tree. The trees are stored
|
||||
in a compact form at the start of each block. The blocks can have any
|
||||
size (except that the compressed data for one block must fit in
|
||||
available memory). A block is terminated when deflate() determines that
|
||||
it would be useful to start another block with fresh trees. (This is
|
||||
somewhat similar to the behavior of LZW-based _compress_.)
|
||||
|
||||
Duplicated strings are found using a hash table. All input strings of
|
||||
length 3 are inserted in the hash table. A hash index is computed for
|
||||
the next 3 bytes. If the hash chain for this index is not empty, all
|
||||
strings in the chain are compared with the current input string, and
|
||||
the longest match is selected.
|
||||
|
||||
The hash chains are searched starting with the most recent strings, to
|
||||
favor small distances and thus take advantage of the Huffman encoding.
|
||||
The hash chains are singly linked. There are no deletions from the
|
||||
hash chains, the algorithm simply discards matches that are too old.
|
||||
|
||||
To avoid a worst-case situation, very long hash chains are arbitrarily
|
||||
truncated at a certain length, determined by a runtime option (level
|
||||
parameter of deflateInit). So deflate() does not always find the longest
|
||||
possible match but generally finds a match which is long enough.
|
||||
|
||||
deflate() also defers the selection of matches with a lazy evaluation
|
||||
mechanism. After a match of length N has been found, deflate() searches for
|
||||
a longer match at the next input byte. If a longer match is found, the
|
||||
previous match is truncated to a length of one (thus producing a single
|
||||
literal byte) and the process of lazy evaluation begins again. Otherwise,
|
||||
the original match is kept, and the next match search is attempted only N
|
||||
steps later.
|
||||
|
||||
The lazy match evaluation is also subject to a runtime parameter. If
|
||||
the current match is long enough, deflate() reduces the search for a longer
|
||||
match, thus speeding up the whole process. If compression ratio is more
|
||||
important than speed, deflate() attempts a complete second search even if
|
||||
the first match is already long enough.
|
||||
|
||||
The lazy match evaluation is not performed for the fastest compression
|
||||
modes (level parameter 1 to 3). For these fast modes, new strings
|
||||
are inserted in the hash table only when no match was found, or
|
||||
when the match is not too long. This degrades the compression ratio
|
||||
but saves time since there are both fewer insertions and fewer searches.
|
||||
|
||||
|
||||
2. Decompression algorithm (inflate)
|
||||
|
||||
2.1 Introduction
|
||||
|
||||
The key question is how to represent a Huffman code (or any prefix code) so
|
||||
that you can decode fast. The most important characteristic is that shorter
|
||||
codes are much more common than longer codes, so pay attention to decoding the
|
||||
short codes fast, and let the long codes take longer to decode.
|
||||
|
||||
inflate() sets up a first level table that covers some number of bits of
|
||||
input less than the length of longest code. It gets that many bits from the
|
||||
stream, and looks it up in the table. The table will tell if the next
|
||||
code is that many bits or less and how many, and if it is, it will tell
|
||||
the value, else it will point to the next level table for which inflate()
|
||||
grabs more bits and tries to decode a longer code.
|
||||
|
||||
How many bits to make the first lookup is a tradeoff between the time it
|
||||
takes to decode and the time it takes to build the table. If building the
|
||||
table took no time (and if you had infinite memory), then there would only
|
||||
be a first level table to cover all the way to the longest code. However,
|
||||
building the table ends up taking a lot longer for more bits since short
|
||||
codes are replicated many times in such a table. What inflate() does is
|
||||
simply to make the number of bits in the first table a variable, and then
|
||||
to set that variable for the maximum speed.
|
||||
|
||||
For inflate, which has 286 possible codes for the literal/length tree, the size
|
||||
of the first table is nine bits. Also the distance trees have 30 possible
|
||||
values, and the size of the first table is six bits. Note that for each of
|
||||
those cases, the table ended up one bit longer than the ``average'' code
|
||||
length, i.e. the code length of an approximately flat code which would be a
|
||||
little more than eight bits for 286 symbols and a little less than five bits
|
||||
for 30 symbols.
|
||||
|
||||
|
||||
2.2 More details on the inflate table lookup
|
||||
|
||||
Ok, you want to know what this cleverly obfuscated inflate tree actually
|
||||
looks like. You are correct that it's not a Huffman tree. It is simply a
|
||||
lookup table for the first, let's say, nine bits of a Huffman symbol. The
|
||||
symbol could be as short as one bit or as long as 15 bits. If a particular
|
||||
symbol is shorter than nine bits, then that symbol's translation is duplicated
|
||||
in all those entries that start with that symbol's bits. For example, if the
|
||||
symbol is four bits, then it's duplicated 32 times in a nine-bit table. If a
|
||||
symbol is nine bits long, it appears in the table once.
|
||||
|
||||
If the symbol is longer than nine bits, then that entry in the table points
|
||||
to another similar table for the remaining bits. Again, there are duplicated
|
||||
entries as needed. The idea is that most of the time the symbol will be short
|
||||
and there will only be one table look up. (That's whole idea behind data
|
||||
compression in the first place.) For the less frequent long symbols, there
|
||||
will be two lookups. If you had a compression method with really long
|
||||
symbols, you could have as many levels of lookups as is efficient. For
|
||||
inflate, two is enough.
|
||||
|
||||
So a table entry either points to another table (in which case nine bits in
|
||||
the above example are gobbled), or it contains the translation for the symbol
|
||||
and the number of bits to gobble. Then you start again with the next
|
||||
ungobbled bit.
|
||||
|
||||
You may wonder: why not just have one lookup table for how ever many bits the
|
||||
longest symbol is? The reason is that if you do that, you end up spending
|
||||
more time filling in duplicate symbol entries than you do actually decoding.
|
||||
At least for deflate's output that generates new trees every several 10's of
|
||||
kbytes. You can imagine that filling in a 2^15 entry table for a 15-bit code
|
||||
would take too long if you're only decoding several thousand symbols. At the
|
||||
other extreme, you could make a new table for every bit in the code. In fact,
|
||||
that's essentially a Huffman tree. But then you spend 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
|
66
lib/zlib-1.2.3/amiga/Makefile.pup
Normal file
66
lib/zlib-1.2.3/amiga/Makefile.pup
Normal file
|
@ -0,0 +1,66 @@
|
|||
# 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
|
65
lib/zlib-1.2.3/amiga/Makefile.sas
Normal file
65
lib/zlib-1.2.3/amiga/Makefile.sas
Normal file
|
@ -0,0 +1,65 @@
|
|||
# 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
|
132
lib/zlib-1.2.3/as400/bndsrc
Normal file
132
lib/zlib-1.2.3/as400/bndsrc
Normal file
|
@ -0,0 +1,132 @@
|
|||
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
|
123
lib/zlib-1.2.3/as400/compile.clp
Normal file
123
lib/zlib-1.2.3/as400/compile.clp
Normal file
|
@ -0,0 +1,123 @@
|
|||
/******************************************************************************/
|
||||
/* */
|
||||
/* 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.3') TGTRLS(V4R4M0)
|
||||
|
||||
ENDPGM
|
111
lib/zlib-1.2.3/as400/readme.txt
Normal file
111
lib/zlib-1.2.3/as400/readme.txt
Normal file
|
@ -0,0 +1,111 @@
|
|||
ZLIB version 1.2.3 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.
|
331
lib/zlib-1.2.3/as400/zlib.inc
Normal file
331
lib/zlib-1.2.3/as400/zlib.inc
Normal file
|
@ -0,0 +1,331 @@
|
|||
* ZLIB.INC - Interface to the general purpose compression library
|
||||
*
|
||||
* ILE RPG400 version by Patrick Monnerat, DATASPHERE.
|
||||
* Version 1.2.3
|
||||
*
|
||||
*
|
||||
* 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
|
||||
**************************************************************************
|
||||
*
|
||||
* Versioning information.
|
||||
*
|
||||
D ZLIB_VERSION C '1.2.3'
|
||||
D ZLIB_VERNUM C X'1230'
|
||||
*
|
||||
* Other equates.
|
||||
*
|
||||
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
|
79
lib/zlib-1.2.3/compress.c
Normal file
79
lib/zlib-1.2.3/compress.c
Normal file
|
@ -0,0 +1,79 @@
|
|||
/* compress.c -- compress a memory buffer
|
||||
* Copyright (C) 1995-2003 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;
|
||||
}
|
459
lib/zlib-1.2.3/configure
vendored
Executable file
459
lib/zlib-1.2.3/configure
vendored
Executable file
|
@ -0,0 +1,459 @@
|
|||
#!/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* | OS/2* )
|
||||
EXE='.exe';;
|
||||
QNX*) # This is for QNX6. I suppose that the QNX rule below is for QNX2,QNX4
|
||||
# (alain.bonnefoy@icbt.com)
|
||||
LDSHARED=${LDSHARED-"$cc -shared -Wl,-hlibz.so.1"};;
|
||||
HP-UX*)
|
||||
LDSHARED=${LDSHARED-"$cc -shared $SFLAGS"}
|
||||
case `(uname -m || echo unknown) 2>/dev/null` in
|
||||
ia64)
|
||||
shared_ext='.so'
|
||||
SHAREDLIB='libz.so';;
|
||||
*)
|
||||
shared_ext='.sl'
|
||||
SHAREDLIB='libz.sl';;
|
||||
esac;;
|
||||
Darwin*) shared_ext='.dylib'
|
||||
SHAREDLIB=libz$shared_ext
|
||||
SHAREDLIBV=libz.$VER$shared_ext
|
||||
SHAREDLIBM=libz.$VER1$shared_ext
|
||||
LDSHARED=${LDSHARED-"$cc -dynamiclib -install_name $libdir/$SHAREDLIBM -compatibility_version $VER1 -current_version $VER"};;
|
||||
*) 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"}
|
||||
case `(uname -m || echo unknown) 2>/dev/null` in
|
||||
ia64)
|
||||
shared_ext='.so'
|
||||
SHAREDLIB='libz.so';;
|
||||
*)
|
||||
shared_ext='.sl'
|
||||
SHAREDLIB='libz.sl';;
|
||||
esac;;
|
||||
IRIX*) SFLAGS=${CFLAGS-"-ansi -O2 -rpath ."}
|
||||
CFLAGS=${CFLAGS-"-ansi -O2"}
|
||||
LDSHARED=${LDSHARED-"cc -shared"};;
|
||||
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"};;
|
||||
SunStudio\ 9*) SFLAGS=${CFLAGS-"-DUSE_MMAP -fast -xcode=pic32 -xtarget=ultra3 -xarch=v9b"}
|
||||
CFLAGS=${CFLAGS-"-DUSE_MMAP -fast -xtarget=ultra3 -xarch=v9b"}
|
||||
LDSHARED=${LDSHARED-"cc -xarch=v9b"};;
|
||||
UNIX_System_V\ 4.2.0)
|
||||
SFLAGS=${CFLAGS-"-KPIC -O"}
|
||||
CFLAGS=${CFLAGS-"-O"}
|
||||
LDSHARED=${LDSHARED-"cc -G"};;
|
||||
UNIX_SV\ 4.2MP)
|
||||
SFLAGS=${CFLAGS-"-Kconform_pic -O"}
|
||||
CFLAGS=${CFLAGS-"-O"}
|
||||
LDSHARED=${LDSHARED-"cc -G"};;
|
||||
OpenUNIX\ 5)
|
||||
SFLAGS=${CFLAGS-"-KPIC -O"}
|
||||
CFLAGS=${CFLAGS-"-O"}
|
||||
LDSHARED=${LDSHARED-"cc -G"};;
|
||||
AIX*) # Courtesy of dbakker@arrayasolutions.com
|
||||
SFLAGS=${CFLAGS-"-O -qmaxmem=8192"}
|
||||
CFLAGS=${CFLAGS-"-O -qmaxmem=8192"}
|
||||
LDSHARED=${LDSHARED-"xlc -G"};;
|
||||
# send working options for other systems to 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
|
71
lib/zlib-1.2.3/contrib/README.contrib
Normal file
71
lib/zlib-1.2.3/contrib/README.contrib
Normal file
|
@ -0,0 +1,71 @@
|
|||
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
|
||||
|
||||
dotzlib/ by Henrik Ravn <henrik@ravn.com>
|
||||
Support for Microsoft .Net and Visual C++ .Net
|
||||
|
||||
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
|
||||
|
||||
masmx64/ by Gilles Vollant <info@winimage.com>
|
||||
x86 64-bit (AMD64 and Intel EM64t) code for x64 assembler to
|
||||
replace longest_match() and inflate_fast()
|
||||
|
||||
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 Gutierrez <paag@tid.es>
|
||||
A very simple tar.gz file extractor using zlib
|
||||
|
||||
vstudio/ by Gilles Vollant <info@winimage.com>
|
||||
Building a minizip-enhanced zlib with Microsoft Visual Studio
|
106
lib/zlib-1.2.3/contrib/ada/buffer_demo.adb
Normal file
106
lib/zlib-1.2.3/contrib/ada/buffer_demo.adb
Normal file
|
@ -0,0 +1,106 @@
|
|||
----------------------------------------------------------------
|
||||
-- ZLib for Ada thick binding. --
|
||||
-- --
|
||||
-- Copyright (C) 2002-2004 Dmitriy Anisimkov --
|
||||
-- --
|
||||
-- Open source license information is in the zlib.ads file. --
|
||||
----------------------------------------------------------------
|
||||
--
|
||||
-- $Id$
|
||||
|
||||
-- This demo program provided by Dr Steve Sangwine <sjs@essex.ac.uk>
|
||||
--
|
||||
-- Demonstration of a problem with Zlib-Ada (already fixed) when a buffer
|
||||
-- of exactly the correct size is used for decompressed data, and the last
|
||||
-- few bytes passed in to Zlib are checksum bytes.
|
||||
|
||||
-- This program compresses a string of text, and then decompresses the
|
||||
-- compressed text into a buffer of the same size as the original text.
|
||||
|
||||
with Ada.Streams; use Ada.Streams;
|
||||
with Ada.Text_IO;
|
||||
|
||||
with ZLib; use ZLib;
|
||||
|
||||
procedure Buffer_Demo is
|
||||
EOL : Character renames ASCII.LF;
|
||||
Text : constant String
|
||||
:= "Four score and seven years ago our fathers brought forth," & EOL &
|
||||
"upon this continent, a new nation, conceived in liberty," & EOL &
|
||||
"and dedicated to the proposition that `all men are created equal'.";
|
||||
|
||||
Source : Stream_Element_Array (1 .. Text'Length);
|
||||
for Source'Address use Text'Address;
|
||||
|
||||
begin
|
||||
Ada.Text_IO.Put (Text);
|
||||
Ada.Text_IO.New_Line;
|
||||
Ada.Text_IO.Put_Line
|
||||
("Uncompressed size : " & Positive'Image (Text'Length) & " bytes");
|
||||
|
||||
declare
|
||||
Compressed_Data : Stream_Element_Array (1 .. Text'Length);
|
||||
L : Stream_Element_Offset;
|
||||
begin
|
||||
Compress : declare
|
||||
Compressor : Filter_Type;
|
||||
I : Stream_Element_Offset;
|
||||
begin
|
||||
Deflate_Init (Compressor);
|
||||
|
||||
-- Compress the whole of T at once.
|
||||
|
||||
Translate (Compressor, Source, I, Compressed_Data, L, Finish);
|
||||
pragma Assert (I = Source'Last);
|
||||
|
||||
Close (Compressor);
|
||||
|
||||
Ada.Text_IO.Put_Line
|
||||
("Compressed size : "
|
||||
& Stream_Element_Offset'Image (L) & " bytes");
|
||||
end Compress;
|
||||
|
||||
-- Now we decompress the data, passing short blocks of data to Zlib
|
||||
-- (because this demonstrates the problem - the last block passed will
|
||||
-- contain checksum information and there will be no output, only a
|
||||
-- check inside Zlib that the checksum is correct).
|
||||
|
||||
Decompress : declare
|
||||
Decompressor : Filter_Type;
|
||||
|
||||
Uncompressed_Data : Stream_Element_Array (1 .. Text'Length);
|
||||
|
||||
Block_Size : constant := 4;
|
||||
-- This makes sure that the last block contains
|
||||
-- only Adler checksum data.
|
||||
|
||||
P : Stream_Element_Offset := Compressed_Data'First - 1;
|
||||
O : Stream_Element_Offset;
|
||||
begin
|
||||
Inflate_Init (Decompressor);
|
||||
|
||||
loop
|
||||
Translate
|
||||
(Decompressor,
|
||||
Compressed_Data
|
||||
(P + 1 .. Stream_Element_Offset'Min (P + Block_Size, L)),
|
||||
P,
|
||||
Uncompressed_Data
|
||||
(Total_Out (Decompressor) + 1 .. Uncompressed_Data'Last),
|
||||
O,
|
||||
No_Flush);
|
||||
|
||||
Ada.Text_IO.Put_Line
|
||||
("Total in : " & Count'Image (Total_In (Decompressor)) &
|
||||
", out : " & Count'Image (Total_Out (Decompressor)));
|
||||
|
||||
exit when P = L;
|
||||
end loop;
|
||||
|
||||
Ada.Text_IO.New_Line;
|
||||
Ada.Text_IO.Put_Line
|
||||
("Decompressed text matches original text : "
|
||||
& Boolean'Image (Uncompressed_Data = Source));
|
||||
end Decompress;
|
||||
end;
|
||||
end Buffer_Demo;
|
156
lib/zlib-1.2.3/contrib/ada/mtest.adb
Normal file
156
lib/zlib-1.2.3/contrib/ada/mtest.adb
Normal file
|
@ -0,0 +1,156 @@
|
|||
----------------------------------------------------------------
|
||||
-- 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 would fail
|
||||
-- we should provide thread safe allocation routines for the Z_Stream.
|
||||
--
|
||||
-- $Id$
|
||||
|
||||
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);
|
||||
|
||||
Dummy : Character;
|
||||
|
||||
begin
|
||||
Ada.Text_IO.Get_Immediate (Dummy);
|
||||
Stop := True;
|
||||
end MTest;
|
156
lib/zlib-1.2.3/contrib/ada/read.adb
Normal file
156
lib/zlib-1.2.3/contrib/ada/read.adb
Normal file
|
@ -0,0 +1,156 @@
|
|||
----------------------------------------------------------------
|
||||
-- ZLib for Ada thick binding. --
|
||||
-- --
|
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov --
|
||||
-- --
|
||||
-- Open source license information is in the zlib.ads file. --
|
||||
----------------------------------------------------------------
|
||||
|
||||
-- $Id$
|
||||
|
||||
-- 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,
|
||||
Rest_First => Read_First,
|
||||
Rest_Last => 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;
|
||||
Read_Last := Read_Buffer'Last;
|
||||
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;
|
65
lib/zlib-1.2.3/contrib/ada/readme.txt
Normal file
65
lib/zlib-1.2.3/contrib/ada/readme.txt
Normal file
|
@ -0,0 +1,65 @@
|
|||
ZLib for Ada thick binding (ZLib.Ada)
|
||||
Release 1.3
|
||||
|
||||
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.2:
|
||||
|
||||
- Attension: ZLib.Read generic routine have a initialization requirement
|
||||
for Read_Last parameter now. It is a bit incompartible with previous version,
|
||||
but extends functionality, we could use new parameters Allow_Read_Some and
|
||||
Flush now.
|
||||
|
||||
- Added Is_Open routines to ZLib and ZLib.Streams packages.
|
||||
|
||||
- Add pragma Assert to check Stream_Element is 8 bit.
|
||||
|
||||
- Fix extraction to buffer with exact known decompressed size. Error reported by
|
||||
Steve Sangwine.
|
||||
|
||||
- Fix definition of ULong (changed to unsigned_long), fix regression on 64 bits
|
||||
computers. Patch provided by Pascal Obry.
|
||||
|
||||
- Add Status_Error exception definition.
|
||||
|
||||
- Add pragma Assertion that Ada.Streams.Stream_Element size is 8 bit.
|
||||
|
||||
|
||||
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>
|
||||
|
||||
Contributors: Pascal Obry <pascal@obry.org>, Steve Sangwine <sjs@essex.ac.uk>
|
463
lib/zlib-1.2.3/contrib/ada/test.adb
Normal file
463
lib/zlib-1.2.3/contrib/ada/test.adb
Normal file
|
@ -0,0 +1,463 @@
|
|||
----------------------------------------------------------------
|
||||
-- ZLib for Ada thick binding. --
|
||||
-- --
|
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov --
|
||||
-- --
|
||||
-- Open source license information is in the zlib.ads file. --
|
||||
----------------------------------------------------------------
|
||||
|
||||
-- $Id$
|
||||
|
||||
-- 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;
|
225
lib/zlib-1.2.3/contrib/ada/zlib-streams.adb
Normal file
225
lib/zlib-1.2.3/contrib/ada/zlib-streams.adb
Normal file
|
@ -0,0 +1,225 @@
|
|||
----------------------------------------------------------------
|
||||
-- ZLib for Ada thick binding. --
|
||||
-- --
|
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov --
|
||||
-- --
|
||||
-- Open source license information is in the zlib.ads file. --
|
||||
----------------------------------------------------------------
|
||||
|
||||
-- $Id$
|
||||
|
||||
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;
|
||||
Stream.Rest_Last := Stream.Buffer'Last;
|
||||
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;
|
||||
|
||||
-------------
|
||||
-- Is_Open --
|
||||
-------------
|
||||
|
||||
function Is_Open (Stream : Stream_Type) return Boolean is
|
||||
begin
|
||||
return Is_Open (Stream.Reader) or else Is_Open (Stream.Writer);
|
||||
end Is_Open;
|
||||
|
||||
----------
|
||||
-- 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;
|
114
lib/zlib-1.2.3/contrib/ada/zlib-streams.ads
Normal file
114
lib/zlib-1.2.3/contrib/ada/zlib-streams.ads
Normal file
|
@ -0,0 +1,114 @@
|
|||
----------------------------------------------------------------
|
||||
-- ZLib for Ada thick binding. --
|
||||
-- --
|
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov --
|
||||
-- --
|
||||
-- Open source license information is in the zlib.ads file. --
|
||||
----------------------------------------------------------------
|
||||
|
||||
-- $Id$
|
||||
|
||||
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.
|
||||
|
||||
function Is_Open (Stream : Stream_Type) return Boolean;
|
||||
|
||||
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;
|
141
lib/zlib-1.2.3/contrib/ada/zlib-thin.adb
Normal file
141
lib/zlib-1.2.3/contrib/ada/zlib-thin.adb
Normal file
|
@ -0,0 +1,141 @@
|
|||
----------------------------------------------------------------
|
||||
-- ZLib for Ada thick binding. --
|
||||
-- --
|
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov --
|
||||
-- --
|
||||
-- Open source license information is in the zlib.ads file. --
|
||||
----------------------------------------------------------------
|
||||
|
||||
-- $Id$
|
||||
|
||||
package body ZLib.Thin is
|
||||
|
||||
ZLIB_VERSION : constant Chars_Ptr := zlibVersion;
|
||||
|
||||
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 : 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; windowBits : Int) return Int is
|
||||
begin
|
||||
return inflateInit2 (strm, windowBits, ZLIB_VERSION, Z_Stream_Size);
|
||||
end Inflate_Init;
|
||||
|
||||
------------------------
|
||||
-- Last_Error_Message --
|
||||
------------------------
|
||||
|
||||
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;
|
||||
|
||||
------------
|
||||
-- Set_In --
|
||||
------------
|
||||
|
||||
procedure Set_In
|
||||
(Strm : in out Z_Stream;
|
||||
Buffer : in Voidp;
|
||||
Size : in UInt) is
|
||||
begin
|
||||
Strm.Next_In := Buffer;
|
||||
Strm.Avail_In := 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 Voidp;
|
||||
Size : in UInt) is
|
||||
begin
|
||||
Strm.Next_Out := Buffer;
|
||||
Strm.Avail_Out := 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;
|
450
lib/zlib-1.2.3/contrib/ada/zlib-thin.ads
Normal file
450
lib/zlib-1.2.3/contrib/ada/zlib-thin.ads
Normal file
|
@ -0,0 +1,450 @@
|
|||
----------------------------------------------------------------
|
||||
-- ZLib for Ada thick binding. --
|
||||
-- --
|
||||
-- Copyright (C) 2002-2003 Dmitriy Anisimkov --
|
||||
-- --
|
||||
-- Open source license information is in the zlib.ads file. --
|
||||
----------------------------------------------------------------
|
||||
|
||||
-- $Id$
|
||||
|
||||
with Interfaces.C.Strings;
|
||||
|
||||
with System;
|
||||
|
||||
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_long; -- 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
|
||||
|
||||
subtype Byte_Access is Voidp;
|
||||
|
||||
Nul : constant Voidp := System.Null_Address;
|
||||
-- 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 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 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.
|
||||
|
||||
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 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;
|
||||
|
||||
private
|
||||
|
||||
type Z_Stream is record -- zlib.h:68
|
||||
Next_In : Voidp := Nul; -- 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 : Voidp := Nul; -- 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");
|
||||
|
||||
-- since zlib 1.2.0:
|
||||
|
||||
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, 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;
|
701
lib/zlib-1.2.3/contrib/ada/zlib.adb
Normal file
701
lib/zlib-1.2.3/contrib/ada/zlib.adb
Normal file
|
@ -0,0 +1,701 @@
|
|||
----------------------------------------------------------------
|
||||
-- ZLib for Ada thick binding. --
|
||||
-- --
|
||||
-- Copyright (C) 2002-2004 Dmitriy Anisimkov --
|
||||
-- --
|
||||
-- Open source license information is in the zlib.ads file. --
|
||||
----------------------------------------------------------------
|
||||
|
||||
-- $Id$
|
||||
|
||||
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 : in Thin.Z_Streamp; Flush : in 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 : in Z_Stream);
|
||||
pragma Inline (Raise_Error);
|
||||
|
||||
procedure Raise_Error (Message : in String);
|
||||
pragma Inline (Raise_Error);
|
||||
|
||||
procedure Check_Error (Stream : in Z_Stream; Code : in 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 : in Z_Stream; Code : in 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
|
||||
if not Ignore_Error and then not Is_Open (Filter) then
|
||||
raise Status_Error;
|
||||
end if;
|
||||
|
||||
Code := Flate (Filter.Compression).Done (To_Thin_Access (Filter.Strm));
|
||||
|
||||
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),
|
||||
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 := Default_Window_Bits;
|
||||
Memory_Level : in Memory_Level_Type := Default_Memory_Level;
|
||||
Header : in Header_Type := Default)
|
||||
is
|
||||
use type Thin.Int;
|
||||
Win_Bits : Thin.Int := Thin.Int (Window_Bits);
|
||||
begin
|
||||
if Is_Open (Filter) then
|
||||
raise Status_Error;
|
||||
end if;
|
||||
|
||||
-- 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.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 : in Integer := Default_Buffer_Size;
|
||||
Out_Buffer_Size : in 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 => Filter,
|
||||
In_Data => In_Buffer (In_First .. Last),
|
||||
In_Last => In_Last,
|
||||
Out_Data => Out_Buffer,
|
||||
Out_Last => Out_Last,
|
||||
Flush => Flush_Finish (Last < In_Buffer'First));
|
||||
|
||||
if Out_Buffer'First <= Out_Last then
|
||||
Data_Out (Out_Buffer (Out_Buffer'First .. Out_Last));
|
||||
end if;
|
||||
|
||||
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 := Default_Window_Bits;
|
||||
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
|
||||
if Is_Open (Filter) then
|
||||
raise Status_Error;
|
||||
end if;
|
||||
|
||||
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.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;
|
||||
|
||||
-------------
|
||||
-- Is_Open --
|
||||
-------------
|
||||
|
||||
function Is_Open (Filter : in Filter_Type) return Boolean is
|
||||
begin
|
||||
return Filter.Strm /= null;
|
||||
end Is_Open;
|
||||
|
||||
-----------------
|
||||
-- Raise_Error --
|
||||
-----------------
|
||||
|
||||
procedure Raise_Error (Message : in String) is
|
||||
begin
|
||||
Ada.Exceptions.Raise_Exception (ZLib_Error'Identity, Message);
|
||||
end Raise_Error;
|
||||
|
||||
procedure Raise_Error (Stream : in 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;
|
||||
Flush : in Flush_Mode := No_Flush)
|
||||
is
|
||||
In_Last : Stream_Element_Offset;
|
||||
Item_First : Ada.Streams.Stream_Element_Offset := Item'First;
|
||||
V_Flush : Flush_Mode := Flush;
|
||||
|
||||
begin
|
||||
pragma Assert (Rest_First in Buffer'First .. Buffer'Last + 1);
|
||||
pragma Assert (Rest_Last in Buffer'First - 1 .. Buffer'Last);
|
||||
|
||||
loop
|
||||
if Rest_Last = Buffer'First - 1 then
|
||||
V_Flush := Finish;
|
||||
|
||||
elsif Rest_First > Rest_Last then
|
||||
Read (Buffer, Rest_Last);
|
||||
Rest_First := Buffer'First;
|
||||
|
||||
if Rest_Last < Buffer'First then
|
||||
V_Flush := Finish;
|
||||
end if;
|
||||
end if;
|
||||
|
||||
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 => V_Flush);
|
||||
|
||||
Rest_First := In_Last + 1;
|
||||
|
||||
exit when Stream_End (Filter)
|
||||
or else Last = Item'Last
|
||||
or else (Last >= Item'First and then Allow_Read_Some);
|
||||
|
||||
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 not Is_Open (Filter) then
|
||||
raise Status_Error;
|
||||
end if;
|
||||
|
||||
if Out_Data'Length = 0 and then In_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 := No_Flush)
|
||||
is
|
||||
Buffer : Stream_Element_Array (1 .. Buffer_Size);
|
||||
In_Last : Stream_Element_Offset;
|
||||
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;
|
328
lib/zlib-1.2.3/contrib/ada/zlib.ads
Normal file
328
lib/zlib-1.2.3/contrib/ada/zlib.ads
Normal file
|
@ -0,0 +1,328 @@
|
|||
------------------------------------------------------------------------------
|
||||
-- ZLib for Ada thick binding. --
|
||||
-- --
|
||||
-- Copyright (C) 2002-2004 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$
|
||||
|
||||
with Ada.Streams;
|
||||
|
||||
with Interfaces;
|
||||
|
||||
package ZLib is
|
||||
|
||||
ZLib_Error : exception;
|
||||
Status_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;
|
||||
|
||||
Default_Memory_Level : constant Memory_Level_Type := 8;
|
||||
Default_Window_Bits : constant Window_Bits_Type := 15;
|
||||
|
||||
----------------------------------
|
||||
-- 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.
|
||||
|
||||
Block_Flush : constant Flush_Mode;
|
||||
-- Z_BLOCK requests that inflate() stop
|
||||
-- if and when it get to the next deflate block boundary. When decoding the
|
||||
-- zlib or gzip format, this will cause inflate() to return immediately
|
||||
-- after the header and before the first block. When doing a raw inflate,
|
||||
-- inflate() will go ahead and process the first block, and will return
|
||||
-- when it gets to the end of that block, or when it runs out of data.
|
||||
|
||||
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 tagged 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 := Default_Window_Bits;
|
||||
Memory_Level : in Memory_Level_Type := Default_Memory_Level;
|
||||
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 := Default_Window_Bits;
|
||||
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 are
|
||||
-- supported for inflate routine only in ZLib versions 1.2.0.2 and later.
|
||||
-- Deflate_Init is supporting all header types.
|
||||
|
||||
function Is_Open (Filter : in Filter_Type) return Boolean;
|
||||
pragma Inline (Is_Open);
|
||||
-- Is the filter opened for compression or decompression.
|
||||
|
||||
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);
|
||||
-- Compress/decompress data fetch from Data_In routine and pass the result
|
||||
-- to the Data_Out routine. User should provide Data_In and Data_Out
|
||||
-- for compression/decompression data flow.
|
||||
-- Compression or decompression depend on Filter initialization.
|
||||
|
||||
function Total_In (Filter : in Filter_Type) return Count;
|
||||
pragma Inline (Total_In);
|
||||
-- Returns total number of input bytes read so far
|
||||
|
||||
function Total_Out (Filter : in Filter_Type) return Count;
|
||||
pragma Inline (Total_Out);
|
||||
-- Returns 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);
|
||||
-- Compute 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);
|
||||
-- Compute 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);
|
||||
-- Compress/decompress the In_Data buffer and place the result into
|
||||
-- Out_Data. In_Last is the index of last element from In_Data accepted by
|
||||
-- the Filter. Out_Last is the last element of the received data from
|
||||
-- Filter. To tell the filter that incoming data are 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 := No_Flush);
|
||||
-- Compress/Decompress 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
|
||||
-- Rest_Last have to be initialized to Buffer'Last
|
||||
-- before usage.
|
||||
|
||||
Allow_Read_Some : in Boolean := False;
|
||||
-- Is it allowed to return Last < Item'Last before end of data.
|
||||
|
||||
procedure Read
|
||||
(Filter : in out Filter_Type;
|
||||
Item : out Ada.Streams.Stream_Element_Array;
|
||||
Last : out Ada.Streams.Stream_Element_Offset;
|
||||
Flush : in Flush_Mode := No_Flush);
|
||||
-- Compress/Decompress data from generic parameter procedure Read to the
|
||||
-- Item. User should provide Buffer and initialized Rest_First, Rest_Last
|
||||
-- indicators. If Allow_Read_Some is True, Read routines could return
|
||||
-- Last < Item'Last only at end of stream.
|
||||
|
||||
private
|
||||
|
||||
use Ada.Streams;
|
||||
|
||||
pragma Assert (Ada.Streams.Stream_Element'Size = 8);
|
||||
pragma Assert (Ada.Streams.Stream_Element'Modulus = 2**8);
|
||||
|
||||
type Flush_Mode is new Integer range 0 .. 5;
|
||||
|
||||
type Compression_Method is new Integer range 8 .. 8;
|
||||
|
||||
type Strategy_Type is new Integer range 0 .. 3;
|
||||
|
||||
No_Flush : constant Flush_Mode := 0;
|
||||
Partial_Flush : constant Flush_Mode := 1;
|
||||
Sync_Flush : constant Flush_Mode := 2;
|
||||
Full_Flush : constant Flush_Mode := 3;
|
||||
Finish : constant Flush_Mode := 4;
|
||||
Block_Flush : constant Flush_Mode := 5;
|
||||
|
||||
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 tagged limited 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.
|
||||
end record;
|
||||
|
||||
end ZLib;
|
20
lib/zlib-1.2.3/contrib/ada/zlib.gpr
Normal file
20
lib/zlib-1.2.3/contrib/ada/zlib.gpr
Normal file
|
@ -0,0 +1,20 @@
|
|||
project Zlib is
|
||||
|
||||
for Languages use ("Ada");
|
||||
for Source_Dirs use (".");
|
||||
for Object_Dir use ".";
|
||||
for Main use ("test.adb", "mtest.adb", "read.adb", "buffer_demo");
|
||||
|
||||
package Compiler is
|
||||
for Default_Switches ("ada") use ("-gnatwcfilopru", "-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;
|
43
lib/zlib-1.2.3/contrib/asm586/README.586
Normal file
43
lib/zlib-1.2.3/contrib/asm586/README.586
Normal file
|
@ -0,0 +1,43 @@
|
|||
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
|
364
lib/zlib-1.2.3/contrib/asm586/match.S
Normal file
364
lib/zlib-1.2.3/contrib/asm586/match.S
Normal file
|
@ -0,0 +1,364 @@
|
|||
/* 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.)
|
||||
*/
|
||||
|
||||
/* All the +zlib1222add offsets are due to the addition of fields
|
||||
* in zlib in the deflate_state structure since the asm code was first written
|
||||
* (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
|
||||
* (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
|
||||
* if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
|
||||
*/
|
||||
|
||||
#define zlib1222add (8)
|
||||
|
||||
#define dsWSize (36+zlib1222add)
|
||||
#define dsWMask (44+zlib1222add)
|
||||
#define dsWindow (48+zlib1222add)
|
||||
#define dsPrev (56+zlib1222add)
|
||||
#define dsMatchLen (88+zlib1222add)
|
||||
#define dsPrevMatch (92+zlib1222add)
|
||||
#define dsStrStart (100+zlib1222add)
|
||||
#define dsMatchStart (104+zlib1222add)
|
||||
#define dsLookahead (108+zlib1222add)
|
||||
#define dsPrevLen (112+zlib1222add)
|
||||
#define dsMaxChainLen (116+zlib1222add)
|
||||
#define dsGoodMatch (132+zlib1222add)
|
||||
#define dsNiceMatch (136+zlib1222add)
|
||||
|
||||
|
||||
.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
|
34
lib/zlib-1.2.3/contrib/asm686/README.686
Normal file
34
lib/zlib-1.2.3/contrib/asm686/README.686
Normal file
|
@ -0,0 +1,34 @@
|
|||
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
|
329
lib/zlib-1.2.3/contrib/asm686/match.S
Normal file
329
lib/zlib-1.2.3/contrib/asm686/match.S
Normal file
|
@ -0,0 +1,329 @@
|
|||
/* 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
|
||||
|
||||
/* All the +zlib1222add offsets are due to the addition of fields
|
||||
* in zlib in the deflate_state structure since the asm code was first written
|
||||
* (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
|
||||
* (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
|
||||
* if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
|
||||
*/
|
||||
|
||||
#define zlib1222add (8)
|
||||
|
||||
#define dsWSize (36+zlib1222add)
|
||||
#define dsWMask (44+zlib1222add)
|
||||
#define dsWindow (48+zlib1222add)
|
||||
#define dsPrev (56+zlib1222add)
|
||||
#define dsMatchLen (88+zlib1222add)
|
||||
#define dsPrevMatch (92+zlib1222add)
|
||||
#define dsStrStart (100+zlib1222add)
|
||||
#define dsMatchStart (104+zlib1222add)
|
||||
#define dsLookahead (108+zlib1222add)
|
||||
#define dsPrevLen (112+zlib1222add)
|
||||
#define dsMaxChainLen (116+zlib1222add)
|
||||
#define dsGoodMatch (132+zlib1222add)
|
||||
#define dsNiceMatch (136+zlib1222add)
|
||||
|
||||
|
||||
.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
|
8
lib/zlib-1.2.3/contrib/blast/Makefile
Normal file
8
lib/zlib-1.2.3/contrib/blast/Makefile
Normal file
|
@ -0,0 +1,8 @@
|
|||
blast: blast.c blast.h
|
||||
cc -DTEST -o blast blast.c
|
||||
|
||||
test: blast
|
||||
blast < test.pk | cmp - test.txt
|
||||
|
||||
clean:
|
||||
rm -f blast blast.o
|
4
lib/zlib-1.2.3/contrib/blast/README
Normal file
4
lib/zlib-1.2.3/contrib/blast/README
Normal file
|
@ -0,0 +1,4 @@
|
|||
Read blast.h for purpose and usage.
|
||||
|
||||
Mark Adler
|
||||
madler@alumni.caltech.edu
|
444
lib/zlib-1.2.3/contrib/blast/blast.c
Normal file
444
lib/zlib-1.2.3/contrib/blast/blast.c
Normal file
|
@ -0,0 +1,444 @@
|
|||
/* 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
|
71
lib/zlib-1.2.3/contrib/blast/blast.h
Normal file
71
lib/zlib-1.2.3/contrib/blast/blast.h
Normal file
|
@ -0,0 +1,71 @@
|
|||
/* 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.
|
||||
*/
|
BIN
lib/zlib-1.2.3/contrib/blast/test.pk
Normal file
BIN
lib/zlib-1.2.3/contrib/blast/test.pk
Normal file
Binary file not shown.
1
lib/zlib-1.2.3/contrib/blast/test.txt
Normal file
1
lib/zlib-1.2.3/contrib/blast/test.txt
Normal file
|
@ -0,0 +1 @@
|
|||
AIAIAIAIAIAIA
|
557
lib/zlib-1.2.3/contrib/delphi/ZLib.pas
Normal file
557
lib/zlib-1.2.3/contrib/delphi/ZLib.pas
Normal file
|
@ -0,0 +1,557 @@
|
|||
{*******************************************************}
|
||||
{ }
|
||||
{ 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.3';
|
||||
|
||||
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_NO_FLUSH)) <> 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.
|
11
lib/zlib-1.2.3/contrib/delphi/ZLibConst.pas
Normal file
11
lib/zlib-1.2.3/contrib/delphi/ZLibConst.pas
Normal file
|
@ -0,0 +1,11 @@
|
|||
unit ZLibConst;
|
||||
|
||||
interface
|
||||
|
||||
resourcestring
|
||||
sTargetBufferTooSmall = 'ZLib error: target buffer may be too small';
|
||||
sInvalidStreamOp = 'Invalid stream operation';
|
||||
|
||||
implementation
|
||||
|
||||
end.
|
76
lib/zlib-1.2.3/contrib/delphi/readme.txt
Normal file
76
lib/zlib-1.2.3/contrib/delphi/readme.txt
Normal file
|
@ -0,0 +1,76 @@
|
|||
|
||||
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>
|
93
lib/zlib-1.2.3/contrib/delphi/zlibd32.mak
Normal file
93
lib/zlib-1.2.3/contrib/delphi/zlibd32.mak
Normal file
|
@ -0,0 +1,93 @@
|
|||
# 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
|
||||
|
33
lib/zlib-1.2.3/contrib/dotzlib/DotZLib.build
Normal file
33
lib/zlib-1.2.3/contrib/dotzlib/DotZLib.build
Normal file
|
@ -0,0 +1,33 @@
|
|||
<?xml version="1.0" encoding="utf-8" ?>
|
||||
<project name="DotZLib" default="build" basedir="./DotZLib">
|
||||
<description>A .Net wrapper library around ZLib1.dll</description>
|
||||
|
||||
<property name="nunit.location" value="c:/program files/NUnit V2.1/bin" />
|
||||
<property name="build.root" value="bin" />
|
||||
|
||||
<property name="debug" value="true" />
|
||||
<property name="nunit" value="true" />
|
||||
|
||||
<property name="build.folder" value="${build.root}/debug/" if="${debug}" />
|
||||
<property name="build.folder" value="${build.root}/release/" unless="${debug}" />
|
||||
|
||||
<target name="clean" description="Remove all generated files">
|
||||
<delete dir="${build.root}" failonerror="false" />
|
||||
</target>
|
||||
|
||||
<target name="build" description="compiles the source code">
|
||||
|
||||
<mkdir dir="${build.folder}" />
|
||||
<csc target="library" output="${build.folder}DotZLib.dll" debug="${debug}">
|
||||
<references basedir="${nunit.location}">
|
||||
<includes if="${nunit}" name="nunit.framework.dll" />
|
||||
</references>
|
||||
<sources>
|
||||
<includes name="*.cs" />
|
||||
<excludes name="UnitTests.cs" unless="${nunit}" />
|
||||
</sources>
|
||||
<arg value="/d:nunit" if="${nunit}" />
|
||||
</csc>
|
||||
</target>
|
||||
|
||||
</project>
|
BIN
lib/zlib-1.2.3/contrib/dotzlib/DotZLib.chm
Normal file
BIN
lib/zlib-1.2.3/contrib/dotzlib/DotZLib.chm
Normal file
Binary file not shown.
21
lib/zlib-1.2.3/contrib/dotzlib/DotZLib.sln
Normal file
21
lib/zlib-1.2.3/contrib/dotzlib/DotZLib.sln
Normal file
|
@ -0,0 +1,21 @@
|
|||
Microsoft Visual Studio Solution File, Format Version 8.00
|
||||
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "DotZLib", "DotZLib\DotZLib.csproj", "{BB1EE0B1-1808-46CB-B786-949D91117FC5}"
|
||||
ProjectSection(ProjectDependencies) = postProject
|
||||
EndProjectSection
|
||||
EndProject
|
||||
Global
|
||||
GlobalSection(SolutionConfiguration) = preSolution
|
||||
Debug = Debug
|
||||
Release = Release
|
||||
EndGlobalSection
|
||||
GlobalSection(ProjectConfiguration) = postSolution
|
||||
{BB1EE0B1-1808-46CB-B786-949D91117FC5}.Debug.ActiveCfg = Debug|.NET
|
||||
{BB1EE0B1-1808-46CB-B786-949D91117FC5}.Debug.Build.0 = Debug|.NET
|
||||
{BB1EE0B1-1808-46CB-B786-949D91117FC5}.Release.ActiveCfg = Release|.NET
|
||||
{BB1EE0B1-1808-46CB-B786-949D91117FC5}.Release.Build.0 = Release|.NET
|
||||
EndGlobalSection
|
||||
GlobalSection(ExtensibilityGlobals) = postSolution
|
||||
EndGlobalSection
|
||||
GlobalSection(ExtensibilityAddIns) = postSolution
|
||||
EndGlobalSection
|
||||
EndGlobal
|
58
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/AssemblyInfo.cs
Normal file
58
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/AssemblyInfo.cs
Normal file
|
@ -0,0 +1,58 @@
|
|||
using System.Reflection;
|
||||
using System.Runtime.CompilerServices;
|
||||
|
||||
//
|
||||
// General Information about an assembly is controlled through the following
|
||||
// set of attributes. Change these attribute values to modify the information
|
||||
// associated with an assembly.
|
||||
//
|
||||
[assembly: AssemblyTitle("DotZLib")]
|
||||
[assembly: AssemblyDescription(".Net bindings for ZLib compression dll 1.2.x")]
|
||||
[assembly: AssemblyConfiguration("")]
|
||||
[assembly: AssemblyCompany("Henrik Ravn")]
|
||||
[assembly: AssemblyProduct("")]
|
||||
[assembly: AssemblyCopyright("(c) 2004 by Henrik Ravn")]
|
||||
[assembly: AssemblyTrademark("")]
|
||||
[assembly: AssemblyCulture("")]
|
||||
|
||||
//
|
||||
// Version information for an assembly consists of the following four values:
|
||||
//
|
||||
// Major Version
|
||||
// Minor Version
|
||||
// Build Number
|
||||
// Revision
|
||||
//
|
||||
// You can specify all the values or you can default the Revision and Build Numbers
|
||||
// by using the '*' as shown below:
|
||||
|
||||
[assembly: AssemblyVersion("1.0.*")]
|
||||
|
||||
//
|
||||
// In order to sign your assembly you must specify a key to use. Refer to the
|
||||
// Microsoft .NET Framework documentation for more information on assembly signing.
|
||||
//
|
||||
// Use the attributes below to control which key is used for signing.
|
||||
//
|
||||
// Notes:
|
||||
// (*) If no key is specified, the assembly is not signed.
|
||||
// (*) KeyName refers to a key that has been installed in the Crypto Service
|
||||
// Provider (CSP) on your machine. KeyFile refers to a file which contains
|
||||
// a key.
|
||||
// (*) If the KeyFile and the KeyName values are both specified, the
|
||||
// following processing occurs:
|
||||
// (1) If the KeyName can be found in the CSP, that key is used.
|
||||
// (2) If the KeyName does not exist and the KeyFile does exist, the key
|
||||
// in the KeyFile is installed into the CSP and used.
|
||||
// (*) In order to create a KeyFile, you can use the sn.exe (Strong Name) utility.
|
||||
// When specifying the KeyFile, the location of the KeyFile should be
|
||||
// relative to the project output directory which is
|
||||
// %Project Directory%\obj\<configuration>. For example, if your KeyFile is
|
||||
// located in the project directory, you would specify the AssemblyKeyFile
|
||||
// attribute as [assembly: AssemblyKeyFile("..\\..\\mykey.snk")]
|
||||
// (*) Delay Signing is an advanced option - see the Microsoft .NET Framework
|
||||
// documentation for more information on this.
|
||||
//
|
||||
[assembly: AssemblyDelaySign(false)]
|
||||
[assembly: AssemblyKeyFile("")]
|
||||
[assembly: AssemblyKeyName("")]
|
202
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/ChecksumImpl.cs
Normal file
202
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/ChecksumImpl.cs
Normal file
|
@ -0,0 +1,202 @@
|
|||
//
|
||||
// © Copyright Henrik Ravn 2004
|
||||
//
|
||||
// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
using System;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
|
||||
|
||||
namespace DotZLib
|
||||
{
|
||||
#region ChecksumGeneratorBase
|
||||
/// <summary>
|
||||
/// Implements the common functionality needed for all <see cref="ChecksumGenerator"/>s
|
||||
/// </summary>
|
||||
/// <example></example>
|
||||
public abstract class ChecksumGeneratorBase : ChecksumGenerator
|
||||
{
|
||||
/// <summary>
|
||||
/// The value of the current checksum
|
||||
/// </summary>
|
||||
protected uint _current;
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the checksum generator base - the current checksum is
|
||||
/// set to zero
|
||||
/// </summary>
|
||||
public ChecksumGeneratorBase()
|
||||
{
|
||||
_current = 0;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the checksum generator basewith a specified value
|
||||
/// </summary>
|
||||
/// <param name="initialValue">The value to set the current checksum to</param>
|
||||
public ChecksumGeneratorBase(uint initialValue)
|
||||
{
|
||||
_current = initialValue;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Resets the current checksum to zero
|
||||
/// </summary>
|
||||
public void Reset() { _current = 0; }
|
||||
|
||||
/// <summary>
|
||||
/// Gets the current checksum value
|
||||
/// </summary>
|
||||
public uint Value { get { return _current; } }
|
||||
|
||||
/// <summary>
|
||||
/// Updates the current checksum with part of an array of bytes
|
||||
/// </summary>
|
||||
/// <param name="data">The data to update the checksum with</param>
|
||||
/// <param name="offset">Where in <c>data</c> to start updating</param>
|
||||
/// <param name="count">The number of bytes from <c>data</c> to use</param>
|
||||
/// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception>
|
||||
/// <exception cref="NullReferenceException"><c>data</c> is a null reference</exception>
|
||||
/// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception>
|
||||
/// <remarks>All the other <c>Update</c> methods are implmeneted in terms of this one.
|
||||
/// This is therefore the only method a derived class has to implement</remarks>
|
||||
public abstract void Update(byte[] data, int offset, int count);
|
||||
|
||||
/// <summary>
|
||||
/// Updates the current checksum with an array of bytes.
|
||||
/// </summary>
|
||||
/// <param name="data">The data to update the checksum with</param>
|
||||
public void Update(byte[] data)
|
||||
{
|
||||
Update(data, 0, data.Length);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Updates the current checksum with the data from a string
|
||||
/// </summary>
|
||||
/// <param name="data">The string to update the checksum with</param>
|
||||
/// <remarks>The characters in the string are converted by the UTF-8 encoding</remarks>
|
||||
public void Update(string data)
|
||||
{
|
||||
Update(Encoding.UTF8.GetBytes(data));
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Updates the current checksum with the data from a string, using a specific encoding
|
||||
/// </summary>
|
||||
/// <param name="data">The string to update the checksum with</param>
|
||||
/// <param name="encoding">The encoding to use</param>
|
||||
public void Update(string data, Encoding encoding)
|
||||
{
|
||||
Update(encoding.GetBytes(data));
|
||||
}
|
||||
|
||||
}
|
||||
#endregion
|
||||
|
||||
#region CRC32
|
||||
/// <summary>
|
||||
/// Implements a CRC32 checksum generator
|
||||
/// </summary>
|
||||
public sealed class CRC32Checksum : ChecksumGeneratorBase
|
||||
{
|
||||
#region DLL imports
|
||||
|
||||
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
|
||||
private static extern uint crc32(uint crc, int data, uint length);
|
||||
|
||||
#endregion
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the CRC32 checksum generator
|
||||
/// </summary>
|
||||
public CRC32Checksum() : base() {}
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the CRC32 checksum generator with a specified value
|
||||
/// </summary>
|
||||
/// <param name="initialValue">The value to set the current checksum to</param>
|
||||
public CRC32Checksum(uint initialValue) : base(initialValue) {}
|
||||
|
||||
/// <summary>
|
||||
/// Updates the current checksum with part of an array of bytes
|
||||
/// </summary>
|
||||
/// <param name="data">The data to update the checksum with</param>
|
||||
/// <param name="offset">Where in <c>data</c> to start updating</param>
|
||||
/// <param name="count">The number of bytes from <c>data</c> to use</param>
|
||||
/// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception>
|
||||
/// <exception cref="NullReferenceException"><c>data</c> is a null reference</exception>
|
||||
/// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception>
|
||||
public override void Update(byte[] data, int offset, int count)
|
||||
{
|
||||
if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException();
|
||||
if ((offset+count) > data.Length) throw new ArgumentException();
|
||||
GCHandle hData = GCHandle.Alloc(data, GCHandleType.Pinned);
|
||||
try
|
||||
{
|
||||
_current = crc32(_current, hData.AddrOfPinnedObject().ToInt32()+offset, (uint)count);
|
||||
}
|
||||
finally
|
||||
{
|
||||
hData.Free();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
#endregion
|
||||
|
||||
#region Adler
|
||||
/// <summary>
|
||||
/// Implements a checksum generator that computes the Adler checksum on data
|
||||
/// </summary>
|
||||
public sealed class AdlerChecksum : ChecksumGeneratorBase
|
||||
{
|
||||
#region DLL imports
|
||||
|
||||
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
|
||||
private static extern uint adler32(uint adler, int data, uint length);
|
||||
|
||||
#endregion
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the Adler checksum generator
|
||||
/// </summary>
|
||||
public AdlerChecksum() : base() {}
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the Adler checksum generator with a specified value
|
||||
/// </summary>
|
||||
/// <param name="initialValue">The value to set the current checksum to</param>
|
||||
public AdlerChecksum(uint initialValue) : base(initialValue) {}
|
||||
|
||||
/// <summary>
|
||||
/// Updates the current checksum with part of an array of bytes
|
||||
/// </summary>
|
||||
/// <param name="data">The data to update the checksum with</param>
|
||||
/// <param name="offset">Where in <c>data</c> to start updating</param>
|
||||
/// <param name="count">The number of bytes from <c>data</c> to use</param>
|
||||
/// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception>
|
||||
/// <exception cref="NullReferenceException"><c>data</c> is a null reference</exception>
|
||||
/// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception>
|
||||
public override void Update(byte[] data, int offset, int count)
|
||||
{
|
||||
if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException();
|
||||
if ((offset+count) > data.Length) throw new ArgumentException();
|
||||
GCHandle hData = GCHandle.Alloc(data, GCHandleType.Pinned);
|
||||
try
|
||||
{
|
||||
_current = adler32(_current, hData.AddrOfPinnedObject().ToInt32()+offset, (uint)count);
|
||||
}
|
||||
finally
|
||||
{
|
||||
hData.Free();
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
#endregion
|
||||
|
||||
}
|
83
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/CircularBuffer.cs
Normal file
83
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/CircularBuffer.cs
Normal file
|
@ -0,0 +1,83 @@
|
|||
//
|
||||
// © Copyright Henrik Ravn 2004
|
||||
//
|
||||
// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
using System;
|
||||
using System.Diagnostics;
|
||||
|
||||
namespace DotZLib
|
||||
{
|
||||
|
||||
/// <summary>
|
||||
/// This class implements a circular buffer
|
||||
/// </summary>
|
||||
internal class CircularBuffer
|
||||
{
|
||||
#region Private data
|
||||
private int _capacity;
|
||||
private int _head;
|
||||
private int _tail;
|
||||
private int _size;
|
||||
private byte[] _buffer;
|
||||
#endregion
|
||||
|
||||
public CircularBuffer(int capacity)
|
||||
{
|
||||
Debug.Assert( capacity > 0 );
|
||||
_buffer = new byte[capacity];
|
||||
_capacity = capacity;
|
||||
_head = 0;
|
||||
_tail = 0;
|
||||
_size = 0;
|
||||
}
|
||||
|
||||
public int Size { get { return _size; } }
|
||||
|
||||
public int Put(byte[] source, int offset, int count)
|
||||
{
|
||||
Debug.Assert( count > 0 );
|
||||
int trueCount = Math.Min(count, _capacity - Size);
|
||||
for (int i = 0; i < trueCount; ++i)
|
||||
_buffer[(_tail+i) % _capacity] = source[offset+i];
|
||||
_tail += trueCount;
|
||||
_tail %= _capacity;
|
||||
_size += trueCount;
|
||||
return trueCount;
|
||||
}
|
||||
|
||||
public bool Put(byte b)
|
||||
{
|
||||
if (Size == _capacity) // no room
|
||||
return false;
|
||||
_buffer[_tail++] = b;
|
||||
_tail %= _capacity;
|
||||
++_size;
|
||||
return true;
|
||||
}
|
||||
|
||||
public int Get(byte[] destination, int offset, int count)
|
||||
{
|
||||
int trueCount = Math.Min(count,Size);
|
||||
for (int i = 0; i < trueCount; ++i)
|
||||
destination[offset + i] = _buffer[(_head+i) % _capacity];
|
||||
_head += trueCount;
|
||||
_head %= _capacity;
|
||||
_size -= trueCount;
|
||||
return trueCount;
|
||||
}
|
||||
|
||||
public int Get()
|
||||
{
|
||||
if (Size == 0)
|
||||
return -1;
|
||||
|
||||
int result = (int)_buffer[_head++ % _capacity];
|
||||
--_size;
|
||||
return result;
|
||||
}
|
||||
|
||||
}
|
||||
}
|
198
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/CodecBase.cs
Normal file
198
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/CodecBase.cs
Normal file
|
@ -0,0 +1,198 @@
|
|||
//
|
||||
// © Copyright Henrik Ravn 2004
|
||||
//
|
||||
// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
using System;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace DotZLib
|
||||
{
|
||||
/// <summary>
|
||||
/// Implements the common functionality needed for all <see cref="Codec"/>s
|
||||
/// </summary>
|
||||
public abstract class CodecBase : Codec, IDisposable
|
||||
{
|
||||
|
||||
#region Data members
|
||||
|
||||
/// <summary>
|
||||
/// Instance of the internal zlib buffer structure that is
|
||||
/// passed to all functions in the zlib dll
|
||||
/// </summary>
|
||||
internal ZStream _ztream = new ZStream();
|
||||
|
||||
/// <summary>
|
||||
/// True if the object instance has been disposed, false otherwise
|
||||
/// </summary>
|
||||
protected bool _isDisposed = false;
|
||||
|
||||
/// <summary>
|
||||
/// The size of the internal buffers
|
||||
/// </summary>
|
||||
protected const int kBufferSize = 16384;
|
||||
|
||||
private byte[] _outBuffer = new byte[kBufferSize];
|
||||
private byte[] _inBuffer = new byte[kBufferSize];
|
||||
|
||||
private GCHandle _hInput;
|
||||
private GCHandle _hOutput;
|
||||
|
||||
private uint _checksum = 0;
|
||||
|
||||
#endregion
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the <c>CodeBase</c> class.
|
||||
/// </summary>
|
||||
public CodecBase()
|
||||
{
|
||||
try
|
||||
{
|
||||
_hInput = GCHandle.Alloc(_inBuffer, GCHandleType.Pinned);
|
||||
_hOutput = GCHandle.Alloc(_outBuffer, GCHandleType.Pinned);
|
||||
}
|
||||
catch (Exception)
|
||||
{
|
||||
CleanUp(false);
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#region Codec Members
|
||||
|
||||
/// <summary>
|
||||
/// Occurs when more processed data are available.
|
||||
/// </summary>
|
||||
public event DataAvailableHandler DataAvailable;
|
||||
|
||||
/// <summary>
|
||||
/// Fires the <see cref="DataAvailable"/> event
|
||||
/// </summary>
|
||||
protected void OnDataAvailable()
|
||||
{
|
||||
if (_ztream.total_out > 0)
|
||||
{
|
||||
if (DataAvailable != null)
|
||||
DataAvailable( _outBuffer, 0, (int)_ztream.total_out);
|
||||
resetOutput();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Adds more data to the codec to be processed.
|
||||
/// </summary>
|
||||
/// <param name="data">Byte array containing the data to be added to the codec</param>
|
||||
/// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
|
||||
public void Add(byte[] data)
|
||||
{
|
||||
Add(data,0,data.Length);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Adds more data to the codec to be processed.
|
||||
/// </summary>
|
||||
/// <param name="data">Byte array containing the data to be added to the codec</param>
|
||||
/// <param name="offset">The index of the first byte to add from <c>data</c></param>
|
||||
/// <param name="count">The number of bytes to add</param>
|
||||
/// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
|
||||
/// <remarks>This must be implemented by a derived class</remarks>
|
||||
public abstract void Add(byte[] data, int offset, int count);
|
||||
|
||||
/// <summary>
|
||||
/// Finishes up any pending data that needs to be processed and handled.
|
||||
/// </summary>
|
||||
/// <remarks>This must be implemented by a derived class</remarks>
|
||||
public abstract void Finish();
|
||||
|
||||
/// <summary>
|
||||
/// Gets the checksum of the data that has been added so far
|
||||
/// </summary>
|
||||
public uint Checksum { get { return _checksum; } }
|
||||
|
||||
#endregion
|
||||
|
||||
#region Destructor & IDisposable stuff
|
||||
|
||||
/// <summary>
|
||||
/// Destroys this instance
|
||||
/// </summary>
|
||||
~CodecBase()
|
||||
{
|
||||
CleanUp(false);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Releases any unmanaged resources and calls the <see cref="CleanUp()"/> method of the derived class
|
||||
/// </summary>
|
||||
public void Dispose()
|
||||
{
|
||||
CleanUp(true);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Performs any codec specific cleanup
|
||||
/// </summary>
|
||||
/// <remarks>This must be implemented by a derived class</remarks>
|
||||
protected abstract void CleanUp();
|
||||
|
||||
// performs the release of the handles and calls the dereived CleanUp()
|
||||
private void CleanUp(bool isDisposing)
|
||||
{
|
||||
if (!_isDisposed)
|
||||
{
|
||||
CleanUp();
|
||||
if (_hInput.IsAllocated)
|
||||
_hInput.Free();
|
||||
if (_hOutput.IsAllocated)
|
||||
_hOutput.Free();
|
||||
|
||||
_isDisposed = true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
#endregion
|
||||
|
||||
#region Helper methods
|
||||
|
||||
/// <summary>
|
||||
/// Copies a number of bytes to the internal codec buffer - ready for proccesing
|
||||
/// </summary>
|
||||
/// <param name="data">The byte array that contains the data to copy</param>
|
||||
/// <param name="startIndex">The index of the first byte to copy</param>
|
||||
/// <param name="count">The number of bytes to copy from <c>data</c></param>
|
||||
protected void copyInput(byte[] data, int startIndex, int count)
|
||||
{
|
||||
Array.Copy(data, startIndex, _inBuffer,0, count);
|
||||
_ztream.next_in = _hInput.AddrOfPinnedObject();
|
||||
_ztream.total_in = 0;
|
||||
_ztream.avail_in = (uint)count;
|
||||
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Resets the internal output buffers to a known state - ready for processing
|
||||
/// </summary>
|
||||
protected void resetOutput()
|
||||
{
|
||||
_ztream.total_out = 0;
|
||||
_ztream.avail_out = kBufferSize;
|
||||
_ztream.next_out = _hOutput.AddrOfPinnedObject();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Updates the running checksum property
|
||||
/// </summary>
|
||||
/// <param name="newSum">The new checksum value</param>
|
||||
protected void setChecksum(uint newSum)
|
||||
{
|
||||
_checksum = newSum;
|
||||
}
|
||||
#endregion
|
||||
|
||||
}
|
||||
}
|
106
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/Deflater.cs
Normal file
106
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/Deflater.cs
Normal file
|
@ -0,0 +1,106 @@
|
|||
//
|
||||
// © Copyright Henrik Ravn 2004
|
||||
//
|
||||
// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
using System;
|
||||
using System.Diagnostics;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace DotZLib
|
||||
{
|
||||
|
||||
/// <summary>
|
||||
/// Implements a data compressor, using the deflate algorithm in the ZLib dll
|
||||
/// </summary>
|
||||
public sealed class Deflater : CodecBase
|
||||
{
|
||||
#region Dll imports
|
||||
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl, CharSet=CharSet.Ansi)]
|
||||
private static extern int deflateInit_(ref ZStream sz, int level, string vs, int size);
|
||||
|
||||
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
|
||||
private static extern int deflate(ref ZStream sz, int flush);
|
||||
|
||||
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
|
||||
private static extern int deflateReset(ref ZStream sz);
|
||||
|
||||
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
|
||||
private static extern int deflateEnd(ref ZStream sz);
|
||||
#endregion
|
||||
|
||||
/// <summary>
|
||||
/// Constructs an new instance of the <c>Deflater</c>
|
||||
/// </summary>
|
||||
/// <param name="level">The compression level to use for this <c>Deflater</c></param>
|
||||
public Deflater(CompressLevel level) : base()
|
||||
{
|
||||
int retval = deflateInit_(ref _ztream, (int)level, Info.Version, Marshal.SizeOf(_ztream));
|
||||
if (retval != 0)
|
||||
throw new ZLibException(retval, "Could not initialize deflater");
|
||||
|
||||
resetOutput();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Adds more data to the codec to be processed.
|
||||
/// </summary>
|
||||
/// <param name="data">Byte array containing the data to be added to the codec</param>
|
||||
/// <param name="offset">The index of the first byte to add from <c>data</c></param>
|
||||
/// <param name="count">The number of bytes to add</param>
|
||||
/// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
|
||||
public override void Add(byte[] data, int offset, int count)
|
||||
{
|
||||
if (data == null) throw new ArgumentNullException();
|
||||
if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException();
|
||||
if ((offset+count) > data.Length) throw new ArgumentException();
|
||||
|
||||
int total = count;
|
||||
int inputIndex = offset;
|
||||
int err = 0;
|
||||
|
||||
while (err >= 0 && inputIndex < total)
|
||||
{
|
||||
copyInput(data, inputIndex, Math.Min(total - inputIndex, kBufferSize));
|
||||
while (err >= 0 && _ztream.avail_in > 0)
|
||||
{
|
||||
err = deflate(ref _ztream, (int)FlushTypes.None);
|
||||
if (err == 0)
|
||||
while (_ztream.avail_out == 0)
|
||||
{
|
||||
OnDataAvailable();
|
||||
err = deflate(ref _ztream, (int)FlushTypes.None);
|
||||
}
|
||||
inputIndex += (int)_ztream.total_in;
|
||||
}
|
||||
}
|
||||
setChecksum( _ztream.adler );
|
||||
}
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Finishes up any pending data that needs to be processed and handled.
|
||||
/// </summary>
|
||||
public override void Finish()
|
||||
{
|
||||
int err;
|
||||
do
|
||||
{
|
||||
err = deflate(ref _ztream, (int)FlushTypes.Finish);
|
||||
OnDataAvailable();
|
||||
}
|
||||
while (err == 0);
|
||||
setChecksum( _ztream.adler );
|
||||
deflateReset(ref _ztream);
|
||||
resetOutput();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Closes the internal zlib deflate stream
|
||||
/// </summary>
|
||||
protected override void CleanUp() { deflateEnd(ref _ztream); }
|
||||
|
||||
}
|
||||
}
|
288
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/DotZLib.cs
Normal file
288
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/DotZLib.cs
Normal file
|
@ -0,0 +1,288 @@
|
|||
//
|
||||
// © Copyright Henrik Ravn 2004
|
||||
//
|
||||
// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
|
||||
|
||||
namespace DotZLib
|
||||
{
|
||||
|
||||
#region Internal types
|
||||
|
||||
/// <summary>
|
||||
/// Defines constants for the various flush types used with zlib
|
||||
/// </summary>
|
||||
internal enum FlushTypes
|
||||
{
|
||||
None, Partial, Sync, Full, Finish, Block
|
||||
}
|
||||
|
||||
#region ZStream structure
|
||||
// internal mapping of the zlib zstream structure for marshalling
|
||||
[StructLayoutAttribute(LayoutKind.Sequential, Pack=4, Size=0, CharSet=CharSet.Ansi)]
|
||||
internal struct ZStream
|
||||
{
|
||||
public IntPtr next_in;
|
||||
public uint avail_in;
|
||||
public uint total_in;
|
||||
|
||||
public IntPtr next_out;
|
||||
public uint avail_out;
|
||||
public uint total_out;
|
||||
|
||||
[MarshalAs(UnmanagedType.LPStr)]
|
||||
string msg;
|
||||
uint state;
|
||||
|
||||
uint zalloc;
|
||||
uint zfree;
|
||||
uint opaque;
|
||||
|
||||
int data_type;
|
||||
public uint adler;
|
||||
uint reserved;
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#endregion
|
||||
|
||||
#region Public enums
|
||||
/// <summary>
|
||||
/// Defines constants for the available compression levels in zlib
|
||||
/// </summary>
|
||||
public enum CompressLevel : int
|
||||
{
|
||||
/// <summary>
|
||||
/// The default compression level with a reasonable compromise between compression and speed
|
||||
/// </summary>
|
||||
Default = -1,
|
||||
/// <summary>
|
||||
/// No compression at all. The data are passed straight through.
|
||||
/// </summary>
|
||||
None = 0,
|
||||
/// <summary>
|
||||
/// The maximum compression rate available.
|
||||
/// </summary>
|
||||
Best = 9,
|
||||
/// <summary>
|
||||
/// The fastest available compression level.
|
||||
/// </summary>
|
||||
Fastest = 1
|
||||
}
|
||||
#endregion
|
||||
|
||||
#region Exception classes
|
||||
/// <summary>
|
||||
/// The exception that is thrown when an error occurs on the zlib dll
|
||||
/// </summary>
|
||||
public class ZLibException : ApplicationException
|
||||
{
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the <see cref="ZLibException"/> class with a specified
|
||||
/// error message and error code
|
||||
/// </summary>
|
||||
/// <param name="errorCode">The zlib error code that caused the exception</param>
|
||||
/// <param name="msg">A message that (hopefully) describes the error</param>
|
||||
public ZLibException(int errorCode, string msg) : base(String.Format("ZLib error {0} {1}", errorCode, msg))
|
||||
{
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Initializes a new instance of the <see cref="ZLibException"/> class with a specified
|
||||
/// error code
|
||||
/// </summary>
|
||||
/// <param name="errorCode">The zlib error code that caused the exception</param>
|
||||
public ZLibException(int errorCode) : base(String.Format("ZLib error {0}", errorCode))
|
||||
{
|
||||
}
|
||||
}
|
||||
#endregion
|
||||
|
||||
#region Interfaces
|
||||
|
||||
/// <summary>
|
||||
/// Declares methods and properties that enables a running checksum to be calculated
|
||||
/// </summary>
|
||||
public interface ChecksumGenerator
|
||||
{
|
||||
/// <summary>
|
||||
/// Gets the current value of the checksum
|
||||
/// </summary>
|
||||
uint Value { get; }
|
||||
|
||||
/// <summary>
|
||||
/// Clears the current checksum to 0
|
||||
/// </summary>
|
||||
void Reset();
|
||||
|
||||
/// <summary>
|
||||
/// Updates the current checksum with an array of bytes
|
||||
/// </summary>
|
||||
/// <param name="data">The data to update the checksum with</param>
|
||||
void Update(byte[] data);
|
||||
|
||||
/// <summary>
|
||||
/// Updates the current checksum with part of an array of bytes
|
||||
/// </summary>
|
||||
/// <param name="data">The data to update the checksum with</param>
|
||||
/// <param name="offset">Where in <c>data</c> to start updating</param>
|
||||
/// <param name="count">The number of bytes from <c>data</c> to use</param>
|
||||
/// <exception cref="ArgumentException">The sum of offset and count is larger than the length of <c>data</c></exception>
|
||||
/// <exception cref="ArgumentNullException"><c>data</c> is a null reference</exception>
|
||||
/// <exception cref="ArgumentOutOfRangeException">Offset or count is negative.</exception>
|
||||
void Update(byte[] data, int offset, int count);
|
||||
|
||||
/// <summary>
|
||||
/// Updates the current checksum with the data from a string
|
||||
/// </summary>
|
||||
/// <param name="data">The string to update the checksum with</param>
|
||||
/// <remarks>The characters in the string are converted by the UTF-8 encoding</remarks>
|
||||
void Update(string data);
|
||||
|
||||
/// <summary>
|
||||
/// Updates the current checksum with the data from a string, using a specific encoding
|
||||
/// </summary>
|
||||
/// <param name="data">The string to update the checksum with</param>
|
||||
/// <param name="encoding">The encoding to use</param>
|
||||
void Update(string data, Encoding encoding);
|
||||
}
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Represents the method that will be called from a codec when new data
|
||||
/// are available.
|
||||
/// </summary>
|
||||
/// <paramref name="data">The byte array containing the processed data</paramref>
|
||||
/// <paramref name="startIndex">The index of the first processed byte in <c>data</c></paramref>
|
||||
/// <paramref name="count">The number of processed bytes available</paramref>
|
||||
/// <remarks>On return from this method, the data may be overwritten, so grab it while you can.
|
||||
/// You cannot assume that startIndex will be zero.
|
||||
/// </remarks>
|
||||
public delegate void DataAvailableHandler(byte[] data, int startIndex, int count);
|
||||
|
||||
/// <summary>
|
||||
/// Declares methods and events for implementing compressors/decompressors
|
||||
/// </summary>
|
||||
public interface Codec
|
||||
{
|
||||
/// <summary>
|
||||
/// Occurs when more processed data are available.
|
||||
/// </summary>
|
||||
event DataAvailableHandler DataAvailable;
|
||||
|
||||
/// <summary>
|
||||
/// Adds more data to the codec to be processed.
|
||||
/// </summary>
|
||||
/// <param name="data">Byte array containing the data to be added to the codec</param>
|
||||
/// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
|
||||
void Add(byte[] data);
|
||||
|
||||
/// <summary>
|
||||
/// Adds more data to the codec to be processed.
|
||||
/// </summary>
|
||||
/// <param name="data">Byte array containing the data to be added to the codec</param>
|
||||
/// <param name="offset">The index of the first byte to add from <c>data</c></param>
|
||||
/// <param name="count">The number of bytes to add</param>
|
||||
/// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
|
||||
void Add(byte[] data, int offset, int count);
|
||||
|
||||
/// <summary>
|
||||
/// Finishes up any pending data that needs to be processed and handled.
|
||||
/// </summary>
|
||||
void Finish();
|
||||
|
||||
/// <summary>
|
||||
/// Gets the checksum of the data that has been added so far
|
||||
/// </summary>
|
||||
uint Checksum { get; }
|
||||
|
||||
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
#region Classes
|
||||
/// <summary>
|
||||
/// Encapsulates general information about the ZLib library
|
||||
/// </summary>
|
||||
public class Info
|
||||
{
|
||||
#region DLL imports
|
||||
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
|
||||
private static extern uint zlibCompileFlags();
|
||||
|
||||
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
|
||||
private static extern string zlibVersion();
|
||||
#endregion
|
||||
|
||||
#region Private stuff
|
||||
private uint _flags;
|
||||
|
||||
// helper function that unpacks a bitsize mask
|
||||
private static int bitSize(uint bits)
|
||||
{
|
||||
switch (bits)
|
||||
{
|
||||
case 0: return 16;
|
||||
case 1: return 32;
|
||||
case 2: return 64;
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
#endregion
|
||||
|
||||
/// <summary>
|
||||
/// Constructs an instance of the <c>Info</c> class.
|
||||
/// </summary>
|
||||
public Info()
|
||||
{
|
||||
_flags = zlibCompileFlags();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// True if the library is compiled with debug info
|
||||
/// </summary>
|
||||
public bool HasDebugInfo { get { return 0 != (_flags & 0x100); } }
|
||||
|
||||
/// <summary>
|
||||
/// True if the library is compiled with assembly optimizations
|
||||
/// </summary>
|
||||
public bool UsesAssemblyCode { get { return 0 != (_flags & 0x200); } }
|
||||
|
||||
/// <summary>
|
||||
/// Gets the size of the unsigned int that was compiled into Zlib
|
||||
/// </summary>
|
||||
public int SizeOfUInt { get { return bitSize(_flags & 3); } }
|
||||
|
||||
/// <summary>
|
||||
/// Gets the size of the unsigned long that was compiled into Zlib
|
||||
/// </summary>
|
||||
public int SizeOfULong { get { return bitSize((_flags >> 2) & 3); } }
|
||||
|
||||
/// <summary>
|
||||
/// Gets the size of the pointers that were compiled into Zlib
|
||||
/// </summary>
|
||||
public int SizeOfPointer { get { return bitSize((_flags >> 4) & 3); } }
|
||||
|
||||
/// <summary>
|
||||
/// Gets the size of the z_off_t type that was compiled into Zlib
|
||||
/// </summary>
|
||||
public int SizeOfOffset { get { return bitSize((_flags >> 6) & 3); } }
|
||||
|
||||
/// <summary>
|
||||
/// Gets the version of ZLib as a string, e.g. "1.2.1"
|
||||
/// </summary>
|
||||
public static string Version { get { return zlibVersion(); } }
|
||||
}
|
||||
|
||||
#endregion
|
||||
|
||||
}
|
141
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/DotZLib.csproj
Normal file
141
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/DotZLib.csproj
Normal file
|
@ -0,0 +1,141 @@
|
|||
<VisualStudioProject>
|
||||
<CSHARP
|
||||
ProjectType = "Local"
|
||||
ProductVersion = "7.10.3077"
|
||||
SchemaVersion = "2.0"
|
||||
ProjectGuid = "{BB1EE0B1-1808-46CB-B786-949D91117FC5}"
|
||||
>
|
||||
<Build>
|
||||
<Settings
|
||||
ApplicationIcon = ""
|
||||
AssemblyKeyContainerName = ""
|
||||
AssemblyName = "DotZLib"
|
||||
AssemblyOriginatorKeyFile = ""
|
||||
DefaultClientScript = "JScript"
|
||||
DefaultHTMLPageLayout = "Grid"
|
||||
DefaultTargetSchema = "IE50"
|
||||
DelaySign = "false"
|
||||
OutputType = "Library"
|
||||
PreBuildEvent = ""
|
||||
PostBuildEvent = ""
|
||||
RootNamespace = "DotZLib"
|
||||
RunPostBuildEvent = "OnBuildSuccess"
|
||||
StartupObject = ""
|
||||
>
|
||||
<Config
|
||||
Name = "Debug"
|
||||
AllowUnsafeBlocks = "false"
|
||||
BaseAddress = "285212672"
|
||||
CheckForOverflowUnderflow = "false"
|
||||
ConfigurationOverrideFile = ""
|
||||
DefineConstants = "DEBUG;TRACE"
|
||||
DocumentationFile = "docs\DotZLib.xml"
|
||||
DebugSymbols = "true"
|
||||
FileAlignment = "4096"
|
||||
IncrementalBuild = "false"
|
||||
NoStdLib = "false"
|
||||
NoWarn = "1591"
|
||||
Optimize = "false"
|
||||
OutputPath = "bin\Debug\"
|
||||
RegisterForComInterop = "false"
|
||||
RemoveIntegerChecks = "false"
|
||||
TreatWarningsAsErrors = "false"
|
||||
WarningLevel = "4"
|
||||
/>
|
||||
<Config
|
||||
Name = "Release"
|
||||
AllowUnsafeBlocks = "false"
|
||||
BaseAddress = "285212672"
|
||||
CheckForOverflowUnderflow = "false"
|
||||
ConfigurationOverrideFile = ""
|
||||
DefineConstants = "TRACE"
|
||||
DocumentationFile = "docs\DotZLib.xml"
|
||||
DebugSymbols = "false"
|
||||
FileAlignment = "4096"
|
||||
IncrementalBuild = "false"
|
||||
NoStdLib = "false"
|
||||
NoWarn = ""
|
||||
Optimize = "true"
|
||||
OutputPath = "bin\Release\"
|
||||
RegisterForComInterop = "false"
|
||||
RemoveIntegerChecks = "false"
|
||||
TreatWarningsAsErrors = "false"
|
||||
WarningLevel = "4"
|
||||
/>
|
||||
</Settings>
|
||||
<References>
|
||||
<Reference
|
||||
Name = "System"
|
||||
AssemblyName = "System"
|
||||
HintPath = "C:\WINNT\Microsoft.NET\Framework\v1.1.4322\System.dll"
|
||||
/>
|
||||
<Reference
|
||||
Name = "System.Data"
|
||||
AssemblyName = "System.Data"
|
||||
HintPath = "C:\WINNT\Microsoft.NET\Framework\v1.1.4322\System.Data.dll"
|
||||
/>
|
||||
<Reference
|
||||
Name = "System.XML"
|
||||
AssemblyName = "System.Xml"
|
||||
HintPath = "C:\WINNT\Microsoft.NET\Framework\v1.1.4322\System.XML.dll"
|
||||
/>
|
||||
<Reference
|
||||
Name = "nunit.framework"
|
||||
AssemblyName = "nunit.framework"
|
||||
HintPath = "E:\apps\NUnit V2.1\\bin\nunit.framework.dll"
|
||||
AssemblyFolderKey = "hklm\dn\nunit.framework"
|
||||
/>
|
||||
</References>
|
||||
</Build>
|
||||
<Files>
|
||||
<Include>
|
||||
<File
|
||||
RelPath = "AssemblyInfo.cs"
|
||||
SubType = "Code"
|
||||
BuildAction = "Compile"
|
||||
/>
|
||||
<File
|
||||
RelPath = "ChecksumImpl.cs"
|
||||
SubType = "Code"
|
||||
BuildAction = "Compile"
|
||||
/>
|
||||
<File
|
||||
RelPath = "CircularBuffer.cs"
|
||||
SubType = "Code"
|
||||
BuildAction = "Compile"
|
||||
/>
|
||||
<File
|
||||
RelPath = "CodecBase.cs"
|
||||
SubType = "Code"
|
||||
BuildAction = "Compile"
|
||||
/>
|
||||
<File
|
||||
RelPath = "Deflater.cs"
|
||||
SubType = "Code"
|
||||
BuildAction = "Compile"
|
||||
/>
|
||||
<File
|
||||
RelPath = "DotZLib.cs"
|
||||
SubType = "Code"
|
||||
BuildAction = "Compile"
|
||||
/>
|
||||
<File
|
||||
RelPath = "GZipStream.cs"
|
||||
SubType = "Code"
|
||||
BuildAction = "Compile"
|
||||
/>
|
||||
<File
|
||||
RelPath = "Inflater.cs"
|
||||
SubType = "Code"
|
||||
BuildAction = "Compile"
|
||||
/>
|
||||
<File
|
||||
RelPath = "UnitTests.cs"
|
||||
SubType = "Code"
|
||||
BuildAction = "Compile"
|
||||
/>
|
||||
</Include>
|
||||
</Files>
|
||||
</CSHARP>
|
||||
</VisualStudioProject>
|
||||
|
301
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/GZipStream.cs
Normal file
301
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/GZipStream.cs
Normal file
|
@ -0,0 +1,301 @@
|
|||
//
|
||||
// © Copyright Henrik Ravn 2004
|
||||
//
|
||||
// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
using System;
|
||||
using System.IO;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace DotZLib
|
||||
{
|
||||
/// <summary>
|
||||
/// Implements a compressed <see cref="Stream"/>, in GZip (.gz) format.
|
||||
/// </summary>
|
||||
public class GZipStream : Stream, IDisposable
|
||||
{
|
||||
#region Dll Imports
|
||||
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl, CharSet=CharSet.Ansi)]
|
||||
private static extern IntPtr gzopen(string name, string mode);
|
||||
|
||||
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
|
||||
private static extern int gzclose(IntPtr gzFile);
|
||||
|
||||
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
|
||||
private static extern int gzwrite(IntPtr gzFile, int data, int length);
|
||||
|
||||
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
|
||||
private static extern int gzread(IntPtr gzFile, int data, int length);
|
||||
|
||||
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
|
||||
private static extern int gzgetc(IntPtr gzFile);
|
||||
|
||||
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
|
||||
private static extern int gzputc(IntPtr gzFile, int c);
|
||||
|
||||
#endregion
|
||||
|
||||
#region Private data
|
||||
private IntPtr _gzFile;
|
||||
private bool _isDisposed = false;
|
||||
private bool _isWriting;
|
||||
#endregion
|
||||
|
||||
#region Constructors
|
||||
/// <summary>
|
||||
/// Creates a new file as a writeable GZipStream
|
||||
/// </summary>
|
||||
/// <param name="fileName">The name of the compressed file to create</param>
|
||||
/// <param name="level">The compression level to use when adding data</param>
|
||||
/// <exception cref="ZLibException">If an error occurred in the internal zlib function</exception>
|
||||
public GZipStream(string fileName, CompressLevel level)
|
||||
{
|
||||
_isWriting = true;
|
||||
_gzFile = gzopen(fileName, String.Format("wb{0}", (int)level));
|
||||
if (_gzFile == IntPtr.Zero)
|
||||
throw new ZLibException(-1, "Could not open " + fileName);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Opens an existing file as a readable GZipStream
|
||||
/// </summary>
|
||||
/// <param name="fileName">The name of the file to open</param>
|
||||
/// <exception cref="ZLibException">If an error occurred in the internal zlib function</exception>
|
||||
public GZipStream(string fileName)
|
||||
{
|
||||
_isWriting = false;
|
||||
_gzFile = gzopen(fileName, "rb");
|
||||
if (_gzFile == IntPtr.Zero)
|
||||
throw new ZLibException(-1, "Could not open " + fileName);
|
||||
|
||||
}
|
||||
#endregion
|
||||
|
||||
#region Access properties
|
||||
/// <summary>
|
||||
/// Returns true of this stream can be read from, false otherwise
|
||||
/// </summary>
|
||||
public override bool CanRead
|
||||
{
|
||||
get
|
||||
{
|
||||
return !_isWriting;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Returns false.
|
||||
/// </summary>
|
||||
public override bool CanSeek
|
||||
{
|
||||
get
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Returns true if this tsream is writeable, false otherwise
|
||||
/// </summary>
|
||||
public override bool CanWrite
|
||||
{
|
||||
get
|
||||
{
|
||||
return _isWriting;
|
||||
}
|
||||
}
|
||||
#endregion
|
||||
|
||||
#region Destructor & IDispose stuff
|
||||
|
||||
/// <summary>
|
||||
/// Destroys this instance
|
||||
/// </summary>
|
||||
~GZipStream()
|
||||
{
|
||||
cleanUp(false);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Closes the external file handle
|
||||
/// </summary>
|
||||
public void Dispose()
|
||||
{
|
||||
cleanUp(true);
|
||||
}
|
||||
|
||||
// Does the actual closing of the file handle.
|
||||
private void cleanUp(bool isDisposing)
|
||||
{
|
||||
if (!_isDisposed)
|
||||
{
|
||||
gzclose(_gzFile);
|
||||
_isDisposed = true;
|
||||
}
|
||||
}
|
||||
#endregion
|
||||
|
||||
#region Basic reading and writing
|
||||
/// <summary>
|
||||
/// Attempts to read a number of bytes from the stream.
|
||||
/// </summary>
|
||||
/// <param name="buffer">The destination data buffer</param>
|
||||
/// <param name="offset">The index of the first destination byte in <c>buffer</c></param>
|
||||
/// <param name="count">The number of bytes requested</param>
|
||||
/// <returns>The number of bytes read</returns>
|
||||
/// <exception cref="ArgumentNullException">If <c>buffer</c> is null</exception>
|
||||
/// <exception cref="ArgumentOutOfRangeException">If <c>count</c> or <c>offset</c> are negative</exception>
|
||||
/// <exception cref="ArgumentException">If <c>offset</c> + <c>count</c> is > buffer.Length</exception>
|
||||
/// <exception cref="NotSupportedException">If this stream is not readable.</exception>
|
||||
/// <exception cref="ObjectDisposedException">If this stream has been disposed.</exception>
|
||||
public override int Read(byte[] buffer, int offset, int count)
|
||||
{
|
||||
if (!CanRead) throw new NotSupportedException();
|
||||
if (buffer == null) throw new ArgumentNullException();
|
||||
if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException();
|
||||
if ((offset+count) > buffer.Length) throw new ArgumentException();
|
||||
if (_isDisposed) throw new ObjectDisposedException("GZipStream");
|
||||
|
||||
GCHandle h = GCHandle.Alloc(buffer, GCHandleType.Pinned);
|
||||
int result;
|
||||
try
|
||||
{
|
||||
result = gzread(_gzFile, h.AddrOfPinnedObject().ToInt32() + offset, count);
|
||||
if (result < 0)
|
||||
throw new IOException();
|
||||
}
|
||||
finally
|
||||
{
|
||||
h.Free();
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Attempts to read a single byte from the stream.
|
||||
/// </summary>
|
||||
/// <returns>The byte that was read, or -1 in case of error or End-Of-File</returns>
|
||||
public override int ReadByte()
|
||||
{
|
||||
if (!CanRead) throw new NotSupportedException();
|
||||
if (_isDisposed) throw new ObjectDisposedException("GZipStream");
|
||||
return gzgetc(_gzFile);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Writes a number of bytes to the stream
|
||||
/// </summary>
|
||||
/// <param name="buffer"></param>
|
||||
/// <param name="offset"></param>
|
||||
/// <param name="count"></param>
|
||||
/// <exception cref="ArgumentNullException">If <c>buffer</c> is null</exception>
|
||||
/// <exception cref="ArgumentOutOfRangeException">If <c>count</c> or <c>offset</c> are negative</exception>
|
||||
/// <exception cref="ArgumentException">If <c>offset</c> + <c>count</c> is > buffer.Length</exception>
|
||||
/// <exception cref="NotSupportedException">If this stream is not writeable.</exception>
|
||||
/// <exception cref="ObjectDisposedException">If this stream has been disposed.</exception>
|
||||
public override void Write(byte[] buffer, int offset, int count)
|
||||
{
|
||||
if (!CanWrite) throw new NotSupportedException();
|
||||
if (buffer == null) throw new ArgumentNullException();
|
||||
if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException();
|
||||
if ((offset+count) > buffer.Length) throw new ArgumentException();
|
||||
if (_isDisposed) throw new ObjectDisposedException("GZipStream");
|
||||
|
||||
GCHandle h = GCHandle.Alloc(buffer, GCHandleType.Pinned);
|
||||
try
|
||||
{
|
||||
int result = gzwrite(_gzFile, h.AddrOfPinnedObject().ToInt32() + offset, count);
|
||||
if (result < 0)
|
||||
throw new IOException();
|
||||
}
|
||||
finally
|
||||
{
|
||||
h.Free();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Writes a single byte to the stream
|
||||
/// </summary>
|
||||
/// <param name="value">The byte to add to the stream.</param>
|
||||
/// <exception cref="NotSupportedException">If this stream is not writeable.</exception>
|
||||
/// <exception cref="ObjectDisposedException">If this stream has been disposed.</exception>
|
||||
public override void WriteByte(byte value)
|
||||
{
|
||||
if (!CanWrite) throw new NotSupportedException();
|
||||
if (_isDisposed) throw new ObjectDisposedException("GZipStream");
|
||||
|
||||
int result = gzputc(_gzFile, (int)value);
|
||||
if (result < 0)
|
||||
throw new IOException();
|
||||
}
|
||||
#endregion
|
||||
|
||||
#region Position & length stuff
|
||||
/// <summary>
|
||||
/// Not supported.
|
||||
/// </summary>
|
||||
/// <param name="value"></param>
|
||||
/// <exception cref="NotSupportedException">Always thrown</exception>
|
||||
public override void SetLength(long value)
|
||||
{
|
||||
throw new NotSupportedException();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Not suppported.
|
||||
/// </summary>
|
||||
/// <param name="offset"></param>
|
||||
/// <param name="origin"></param>
|
||||
/// <returns></returns>
|
||||
/// <exception cref="NotSupportedException">Always thrown</exception>
|
||||
public override long Seek(long offset, SeekOrigin origin)
|
||||
{
|
||||
throw new NotSupportedException();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Flushes the <c>GZipStream</c>.
|
||||
/// </summary>
|
||||
/// <remarks>In this implementation, this method does nothing. This is because excessive
|
||||
/// flushing may degrade the achievable compression rates.</remarks>
|
||||
public override void Flush()
|
||||
{
|
||||
// left empty on purpose
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets/sets the current position in the <c>GZipStream</c>. Not suppported.
|
||||
/// </summary>
|
||||
/// <remarks>In this implementation this property is not supported</remarks>
|
||||
/// <exception cref="NotSupportedException">Always thrown</exception>
|
||||
public override long Position
|
||||
{
|
||||
get
|
||||
{
|
||||
throw new NotSupportedException();
|
||||
}
|
||||
set
|
||||
{
|
||||
throw new NotSupportedException();
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the size of the stream. Not suppported.
|
||||
/// </summary>
|
||||
/// <remarks>In this implementation this property is not supported</remarks>
|
||||
/// <exception cref="NotSupportedException">Always thrown</exception>
|
||||
public override long Length
|
||||
{
|
||||
get
|
||||
{
|
||||
throw new NotSupportedException();
|
||||
}
|
||||
}
|
||||
#endregion
|
||||
}
|
||||
}
|
105
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/Inflater.cs
Normal file
105
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/Inflater.cs
Normal file
|
@ -0,0 +1,105 @@
|
|||
//
|
||||
// © Copyright Henrik Ravn 2004
|
||||
//
|
||||
// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
using System;
|
||||
using System.Diagnostics;
|
||||
using System.Runtime.InteropServices;
|
||||
|
||||
namespace DotZLib
|
||||
{
|
||||
|
||||
/// <summary>
|
||||
/// Implements a data decompressor, using the inflate algorithm in the ZLib dll
|
||||
/// </summary>
|
||||
public class Inflater : CodecBase
|
||||
{
|
||||
#region Dll imports
|
||||
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl, CharSet=CharSet.Ansi)]
|
||||
private static extern int inflateInit_(ref ZStream sz, string vs, int size);
|
||||
|
||||
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
|
||||
private static extern int inflate(ref ZStream sz, int flush);
|
||||
|
||||
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
|
||||
private static extern int inflateReset(ref ZStream sz);
|
||||
|
||||
[DllImport("ZLIB1.dll", CallingConvention=CallingConvention.Cdecl)]
|
||||
private static extern int inflateEnd(ref ZStream sz);
|
||||
#endregion
|
||||
|
||||
/// <summary>
|
||||
/// Constructs an new instance of the <c>Inflater</c>
|
||||
/// </summary>
|
||||
public Inflater() : base()
|
||||
{
|
||||
int retval = inflateInit_(ref _ztream, Info.Version, Marshal.SizeOf(_ztream));
|
||||
if (retval != 0)
|
||||
throw new ZLibException(retval, "Could not initialize inflater");
|
||||
|
||||
resetOutput();
|
||||
}
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Adds more data to the codec to be processed.
|
||||
/// </summary>
|
||||
/// <param name="data">Byte array containing the data to be added to the codec</param>
|
||||
/// <param name="offset">The index of the first byte to add from <c>data</c></param>
|
||||
/// <param name="count">The number of bytes to add</param>
|
||||
/// <remarks>Adding data may, or may not, raise the <c>DataAvailable</c> event</remarks>
|
||||
public override void Add(byte[] data, int offset, int count)
|
||||
{
|
||||
if (data == null) throw new ArgumentNullException();
|
||||
if (offset < 0 || count < 0) throw new ArgumentOutOfRangeException();
|
||||
if ((offset+count) > data.Length) throw new ArgumentException();
|
||||
|
||||
int total = count;
|
||||
int inputIndex = offset;
|
||||
int err = 0;
|
||||
|
||||
while (err >= 0 && inputIndex < total)
|
||||
{
|
||||
copyInput(data, inputIndex, Math.Min(total - inputIndex, kBufferSize));
|
||||
err = inflate(ref _ztream, (int)FlushTypes.None);
|
||||
if (err == 0)
|
||||
while (_ztream.avail_out == 0)
|
||||
{
|
||||
OnDataAvailable();
|
||||
err = inflate(ref _ztream, (int)FlushTypes.None);
|
||||
}
|
||||
|
||||
inputIndex += (int)_ztream.total_in;
|
||||
}
|
||||
setChecksum( _ztream.adler );
|
||||
}
|
||||
|
||||
|
||||
/// <summary>
|
||||
/// Finishes up any pending data that needs to be processed and handled.
|
||||
/// </summary>
|
||||
public override void Finish()
|
||||
{
|
||||
int err;
|
||||
do
|
||||
{
|
||||
err = inflate(ref _ztream, (int)FlushTypes.Finish);
|
||||
OnDataAvailable();
|
||||
}
|
||||
while (err == 0);
|
||||
setChecksum( _ztream.adler );
|
||||
inflateReset(ref _ztream);
|
||||
resetOutput();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Closes the internal zlib inflate stream
|
||||
/// </summary>
|
||||
protected override void CleanUp() { inflateEnd(ref _ztream); }
|
||||
|
||||
|
||||
}
|
||||
}
|
274
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/UnitTests.cs
Normal file
274
lib/zlib-1.2.3/contrib/dotzlib/DotZLib/UnitTests.cs
Normal file
|
@ -0,0 +1,274 @@
|
|||
//
|
||||
// © Copyright Henrik Ravn 2004
|
||||
//
|
||||
// Use, modification and distribution are subject to the Boost Software License, Version 1.0.
|
||||
// (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
||||
//
|
||||
|
||||
using System;
|
||||
using System.Collections;
|
||||
using System.IO;
|
||||
|
||||
// uncomment the define below to include unit tests
|
||||
//#define nunit
|
||||
#if nunit
|
||||
using NUnit.Framework;
|
||||
|
||||
// Unit tests for the DotZLib class library
|
||||
// ----------------------------------------
|
||||
//
|
||||
// Use this with NUnit 2 from http://www.nunit.org
|
||||
//
|
||||
|
||||
namespace DotZLibTests
|
||||
{
|
||||
using DotZLib;
|
||||
|
||||
// helper methods
|
||||
internal class Utils
|
||||
{
|
||||
public static bool byteArrEqual( byte[] lhs, byte[] rhs )
|
||||
{
|
||||
if (lhs.Length != rhs.Length)
|
||||
return false;
|
||||
for (int i = lhs.Length-1; i >= 0; --i)
|
||||
if (lhs[i] != rhs[i])
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
[TestFixture]
|
||||
public class CircBufferTests
|
||||
{
|
||||
#region Circular buffer tests
|
||||
[Test]
|
||||
public void SinglePutGet()
|
||||
{
|
||||
CircularBuffer buf = new CircularBuffer(10);
|
||||
Assert.AreEqual( 0, buf.Size );
|
||||
Assert.AreEqual( -1, buf.Get() );
|
||||
|
||||
Assert.IsTrue(buf.Put( 1 ));
|
||||
Assert.AreEqual( 1, buf.Size );
|
||||
Assert.AreEqual( 1, buf.Get() );
|
||||
Assert.AreEqual( 0, buf.Size );
|
||||
Assert.AreEqual( -1, buf.Get() );
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void BlockPutGet()
|
||||
{
|
||||
CircularBuffer buf = new CircularBuffer(10);
|
||||
byte[] arr = {1,2,3,4,5,6,7,8,9,10};
|
||||
Assert.AreEqual( 10, buf.Put(arr,0,10) );
|
||||
Assert.AreEqual( 10, buf.Size );
|
||||
Assert.IsFalse( buf.Put(11) );
|
||||
Assert.AreEqual( 1, buf.Get() );
|
||||
Assert.IsTrue( buf.Put(11) );
|
||||
|
||||
byte[] arr2 = (byte[])arr.Clone();
|
||||
Assert.AreEqual( 9, buf.Get(arr2,1,9) );
|
||||
Assert.IsTrue( Utils.byteArrEqual(arr,arr2) );
|
||||
}
|
||||
|
||||
#endregion
|
||||
}
|
||||
|
||||
[TestFixture]
|
||||
public class ChecksumTests
|
||||
{
|
||||
#region CRC32 Tests
|
||||
[Test]
|
||||
public void CRC32_Null()
|
||||
{
|
||||
CRC32Checksum crc32 = new CRC32Checksum();
|
||||
Assert.AreEqual( 0, crc32.Value );
|
||||
|
||||
crc32 = new CRC32Checksum(1);
|
||||
Assert.AreEqual( 1, crc32.Value );
|
||||
|
||||
crc32 = new CRC32Checksum(556);
|
||||
Assert.AreEqual( 556, crc32.Value );
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void CRC32_Data()
|
||||
{
|
||||
CRC32Checksum crc32 = new CRC32Checksum();
|
||||
byte[] data = { 1,2,3,4,5,6,7 };
|
||||
crc32.Update(data);
|
||||
Assert.AreEqual( 0x70e46888, crc32.Value );
|
||||
|
||||
crc32 = new CRC32Checksum();
|
||||
crc32.Update("penguin");
|
||||
Assert.AreEqual( 0x0e5c1a120, crc32.Value );
|
||||
|
||||
crc32 = new CRC32Checksum(1);
|
||||
crc32.Update("penguin");
|
||||
Assert.AreEqual(0x43b6aa94, crc32.Value);
|
||||
|
||||
}
|
||||
#endregion
|
||||
|
||||
#region Adler tests
|
||||
|
||||
[Test]
|
||||
public void Adler_Null()
|
||||
{
|
||||
AdlerChecksum adler = new AdlerChecksum();
|
||||
Assert.AreEqual(0, adler.Value);
|
||||
|
||||
adler = new AdlerChecksum(1);
|
||||
Assert.AreEqual( 1, adler.Value );
|
||||
|
||||
adler = new AdlerChecksum(556);
|
||||
Assert.AreEqual( 556, adler.Value );
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Adler_Data()
|
||||
{
|
||||
AdlerChecksum adler = new AdlerChecksum(1);
|
||||
byte[] data = { 1,2,3,4,5,6,7 };
|
||||
adler.Update(data);
|
||||
Assert.AreEqual( 0x5b001d, adler.Value );
|
||||
|
||||
adler = new AdlerChecksum();
|
||||
adler.Update("penguin");
|
||||
Assert.AreEqual(0x0bcf02f6, adler.Value );
|
||||
|
||||
adler = new AdlerChecksum(1);
|
||||
adler.Update("penguin");
|
||||
Assert.AreEqual(0x0bd602f7, adler.Value);
|
||||
|
||||
}
|
||||
#endregion
|
||||
}
|
||||
|
||||
[TestFixture]
|
||||
public class InfoTests
|
||||
{
|
||||
#region Info tests
|
||||
[Test]
|
||||
public void Info_Version()
|
||||
{
|
||||
Info info = new Info();
|
||||
Assert.AreEqual("1.2.3", Info.Version);
|
||||
Assert.AreEqual(32, info.SizeOfUInt);
|
||||
Assert.AreEqual(32, info.SizeOfULong);
|
||||
Assert.AreEqual(32, info.SizeOfPointer);
|
||||
Assert.AreEqual(32, info.SizeOfOffset);
|
||||
}
|
||||
#endregion
|
||||
}
|
||||
|
||||
[TestFixture]
|
||||
public class DeflateInflateTests
|
||||
{
|
||||
#region Deflate tests
|
||||
[Test]
|
||||
public void Deflate_Init()
|
||||
{
|
||||
using (Deflater def = new Deflater(CompressLevel.Default))
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
private ArrayList compressedData = new ArrayList();
|
||||
private uint adler1;
|
||||
|
||||
private ArrayList uncompressedData = new ArrayList();
|
||||
private uint adler2;
|
||||
|
||||
public void CDataAvail(byte[] data, int startIndex, int count)
|
||||
{
|
||||
for (int i = 0; i < count; ++i)
|
||||
compressedData.Add(data[i+startIndex]);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Deflate_Compress()
|
||||
{
|
||||
compressedData.Clear();
|
||||
|
||||
byte[] testData = new byte[35000];
|
||||
for (int i = 0; i < testData.Length; ++i)
|
||||
testData[i] = 5;
|
||||
|
||||
using (Deflater def = new Deflater((CompressLevel)5))
|
||||
{
|
||||
def.DataAvailable += new DataAvailableHandler(CDataAvail);
|
||||
def.Add(testData);
|
||||
def.Finish();
|
||||
adler1 = def.Checksum;
|
||||
}
|
||||
}
|
||||
#endregion
|
||||
|
||||
#region Inflate tests
|
||||
[Test]
|
||||
public void Inflate_Init()
|
||||
{
|
||||
using (Inflater inf = new Inflater())
|
||||
{
|
||||
}
|
||||
}
|
||||
|
||||
private void DDataAvail(byte[] data, int startIndex, int count)
|
||||
{
|
||||
for (int i = 0; i < count; ++i)
|
||||
uncompressedData.Add(data[i+startIndex]);
|
||||
}
|
||||
|
||||
[Test]
|
||||
public void Inflate_Expand()
|
||||
{
|
||||
uncompressedData.Clear();
|
||||
|
||||
using (Inflater inf = new Inflater())
|
||||
{
|
||||
inf.DataAvailable += new DataAvailableHandler(DDataAvail);
|
||||
inf.Add((byte[])compressedData.ToArray(typeof(byte)));
|
||||
inf.Finish();
|
||||
adler2 = inf.Checksum;
|
||||
}
|
||||
Assert.AreEqual( adler1, adler2 );
|
||||
}
|
||||
#endregion
|
||||
}
|
||||
|
||||
[TestFixture]
|
||||
public class GZipStreamTests
|
||||
{
|
||||
#region GZipStream test
|
||||
[Test]
|
||||
public void GZipStream_WriteRead()
|
||||
{
|
||||
using (GZipStream gzOut = new GZipStream("gzstream.gz", CompressLevel.Best))
|
||||
{
|
||||
BinaryWriter writer = new BinaryWriter(gzOut);
|
||||
writer.Write("hi there");
|
||||
writer.Write(Math.PI);
|
||||
writer.Write(42);
|
||||
}
|
||||
|
||||
using (GZipStream gzIn = new GZipStream("gzstream.gz"))
|
||||
{
|
||||
BinaryReader reader = new BinaryReader(gzIn);
|
||||
string s = reader.ReadString();
|
||||
Assert.AreEqual("hi there",s);
|
||||
double d = reader.ReadDouble();
|
||||
Assert.AreEqual(Math.PI, d);
|
||||
int i = reader.ReadInt32();
|
||||
Assert.AreEqual(42,i);
|
||||
}
|
||||
|
||||
}
|
||||
#endregion
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
23
lib/zlib-1.2.3/contrib/dotzlib/LICENSE_1_0.txt
Normal file
23
lib/zlib-1.2.3/contrib/dotzlib/LICENSE_1_0.txt
Normal file
|
@ -0,0 +1,23 @@
|
|||
Boost Software License - Version 1.0 - August 17th, 2003
|
||||
|
||||
Permission is hereby granted, free of charge, to any person or organization
|
||||
obtaining a copy of the software and accompanying documentation covered by
|
||||
this license (the "Software") to use, reproduce, display, distribute,
|
||||
execute, and transmit the Software, and to prepare derivative works of the
|
||||
Software, and to permit third-parties to whom the Software is furnished to
|
||||
do so, all subject to the following:
|
||||
|
||||
The copyright notices in the Software and this entire statement, including
|
||||
the above license grant, this restriction and the following disclaimer,
|
||||
must be included in all copies of the Software, in whole or in part, and
|
||||
all derivative works of the Software, unless such copies or derivative
|
||||
works are solely in the form of machine-executable object code generated by
|
||||
a source language processor.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
|
||||
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
|
||||
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
|
||||
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
||||
DEALINGS IN THE SOFTWARE.
|
58
lib/zlib-1.2.3/contrib/dotzlib/readme.txt
Normal file
58
lib/zlib-1.2.3/contrib/dotzlib/readme.txt
Normal file
|
@ -0,0 +1,58 @@
|
|||
This directory contains a .Net wrapper class library for the ZLib1.dll
|
||||
|
||||
The wrapper includes support for inflating/deflating memory buffers,
|
||||
.Net streaming wrappers for the gz streams part of zlib, and wrappers
|
||||
for the checksum parts of zlib. See DotZLib/UnitTests.cs for examples.
|
||||
|
||||
Directory structure:
|
||||
--------------------
|
||||
|
||||
LICENSE_1_0.txt - License file.
|
||||
readme.txt - This file.
|
||||
DotZLib.chm - Class library documentation
|
||||
DotZLib.build - NAnt build file
|
||||
DotZLib.sln - Microsoft Visual Studio 2003 solution file
|
||||
|
||||
DotZLib\*.cs - Source files for the class library
|
||||
|
||||
Unit tests:
|
||||
-----------
|
||||
The file DotZLib/UnitTests.cs contains unit tests for use with NUnit 2.1 or higher.
|
||||
To include unit tests in the build, define nunit before building.
|
||||
|
||||
|
||||
Build instructions:
|
||||
-------------------
|
||||
|
||||
1. Using Visual Studio.Net 2003:
|
||||
Open DotZLib.sln in VS.Net and build from there. Output file (DotZLib.dll)
|
||||
will be found ./DotZLib/bin/release or ./DotZLib/bin/debug, depending on
|
||||
you are building the release or debug version of the library. Check
|
||||
DotZLib/UnitTests.cs for instructions on how to include unit tests in the
|
||||
build.
|
||||
|
||||
2. Using NAnt:
|
||||
Open a command prompt with access to the build environment and run nant
|
||||
in the same directory as the DotZLib.build file.
|
||||
You can define 2 properties on the nant command-line to control the build:
|
||||
debug={true|false} to toggle between release/debug builds (default=true).
|
||||
nunit={true|false} to include or esclude unit tests (default=true).
|
||||
Also the target clean will remove binaries.
|
||||
Output file (DotZLib.dll) will be found in either ./DotZLib/bin/release
|
||||
or ./DotZLib/bin/debug, depending on whether you are building the release
|
||||
or debug version of the library.
|
||||
|
||||
Examples:
|
||||
nant -D:debug=false -D:nunit=false
|
||||
will build a release mode version of the library without unit tests.
|
||||
nant
|
||||
will build a debug version of the library with unit tests
|
||||
nant clean
|
||||
will remove all previously built files.
|
||||
|
||||
|
||||
---------------------------------
|
||||
Copyright (c) Henrik Ravn 2004
|
||||
|
||||
Use, modification and distribution are subject to the Boost Software License, Version 1.0.
|
||||
(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
|
1
lib/zlib-1.2.3/contrib/infback9/README
Normal file
1
lib/zlib-1.2.3/contrib/infback9/README
Normal file
|
@ -0,0 +1 @@
|
|||
See infback9.h for what this is and how to use it.
|
608
lib/zlib-1.2.3/contrib/infback9/infback9.c
Normal file
608
lib/zlib-1.2.3/contrib/infback9/infback9.c
Normal file
|
@ -0,0 +1,608 @@
|
|||
/* 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;
|
||||
}
|
||||
}
|
||||
|
||||
/* handle error breaks in while */
|
||||
if (mode == BAD) break;
|
||||
|
||||
/* 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;
|
||||
}
|
37
lib/zlib-1.2.3/contrib/infback9/infback9.h
Normal file
37
lib/zlib-1.2.3/contrib/infback9/infback9.h
Normal file
|
@ -0,0 +1,37 @@
|
|||
/* infback9.h -- header for using inflateBack9 functions
|
||||
* Copyright (C) 2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
/*
|
||||
* This header file and associated patches provide a decoder for PKWare's
|
||||
* undocumented deflate64 compression method (method 9). Use with infback9.c,
|
||||
* inftree9.h, inftree9.c, and inffix9.h. These patches are not supported.
|
||||
* This should be compiled with zlib, since it uses zutil.h and zutil.o.
|
||||
* This code has not yet been tested on 16-bit architectures. See the
|
||||
* comments in zlib.h for inflateBack() usage. These functions are used
|
||||
* identically, except that there is no windowBits parameter, and a 64K
|
||||
* window must be provided. Also if int's are 16 bits, then a zero for
|
||||
* the third parameter of the "out" function actually means 65536UL.
|
||||
* zlib.h must be included before this header file.
|
||||
*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
ZEXTERN int ZEXPORT inflateBack9 OF((z_stream FAR *strm,
|
||||
in_func in, void FAR *in_desc,
|
||||
out_func out, void FAR *out_desc));
|
||||
ZEXTERN int ZEXPORT inflateBack9End OF((z_stream FAR *strm));
|
||||
ZEXTERN int ZEXPORT inflateBack9Init_ OF((z_stream FAR *strm,
|
||||
unsigned char FAR *window,
|
||||
const char *version,
|
||||
int stream_size));
|
||||
#define inflateBack9Init(strm, window) \
|
||||
inflateBack9Init_((strm), (window), \
|
||||
ZLIB_VERSION, sizeof(z_stream))
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
107
lib/zlib-1.2.3/contrib/infback9/inffix9.h
Normal file
107
lib/zlib-1.2.3/contrib/infback9/inffix9.h
Normal file
|
@ -0,0 +1,107 @@
|
|||
/* inffix9.h -- table for decoding deflate64 fixed codes
|
||||
* Generated automatically by makefixed9().
|
||||
*/
|
||||
|
||||
/* WARNING: this file should *not* be used by applications.
|
||||
It is part of the implementation of this library and is
|
||||
subject to change. Applications should only use zlib.h.
|
||||
*/
|
||||
|
||||
static const code lenfix[512] = {
|
||||
{96,7,0},{0,8,80},{0,8,16},{132,8,115},{130,7,31},{0,8,112},
|
||||
{0,8,48},{0,9,192},{128,7,10},{0,8,96},{0,8,32},{0,9,160},
|
||||
{0,8,0},{0,8,128},{0,8,64},{0,9,224},{128,7,6},{0,8,88},
|
||||
{0,8,24},{0,9,144},{131,7,59},{0,8,120},{0,8,56},{0,9,208},
|
||||
{129,7,17},{0,8,104},{0,8,40},{0,9,176},{0,8,8},{0,8,136},
|
||||
{0,8,72},{0,9,240},{128,7,4},{0,8,84},{0,8,20},{133,8,227},
|
||||
{131,7,43},{0,8,116},{0,8,52},{0,9,200},{129,7,13},{0,8,100},
|
||||
{0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},
|
||||
{128,7,8},{0,8,92},{0,8,28},{0,9,152},{132,7,83},{0,8,124},
|
||||
{0,8,60},{0,9,216},{130,7,23},{0,8,108},{0,8,44},{0,9,184},
|
||||
{0,8,12},{0,8,140},{0,8,76},{0,9,248},{128,7,3},{0,8,82},
|
||||
{0,8,18},{133,8,163},{131,7,35},{0,8,114},{0,8,50},{0,9,196},
|
||||
{129,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},{0,8,130},
|
||||
{0,8,66},{0,9,228},{128,7,7},{0,8,90},{0,8,26},{0,9,148},
|
||||
{132,7,67},{0,8,122},{0,8,58},{0,9,212},{130,7,19},{0,8,106},
|
||||
{0,8,42},{0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},
|
||||
{128,7,5},{0,8,86},{0,8,22},{65,8,0},{131,7,51},{0,8,118},
|
||||
{0,8,54},{0,9,204},{129,7,15},{0,8,102},{0,8,38},{0,9,172},
|
||||
{0,8,6},{0,8,134},{0,8,70},{0,9,236},{128,7,9},{0,8,94},
|
||||
{0,8,30},{0,9,156},{132,7,99},{0,8,126},{0,8,62},{0,9,220},
|
||||
{130,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
|
||||
{0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{133,8,131},
|
||||
{130,7,31},{0,8,113},{0,8,49},{0,9,194},{128,7,10},{0,8,97},
|
||||
{0,8,33},{0,9,162},{0,8,1},{0,8,129},{0,8,65},{0,9,226},
|
||||
{128,7,6},{0,8,89},{0,8,25},{0,9,146},{131,7,59},{0,8,121},
|
||||
{0,8,57},{0,9,210},{129,7,17},{0,8,105},{0,8,41},{0,9,178},
|
||||
{0,8,9},{0,8,137},{0,8,73},{0,9,242},{128,7,4},{0,8,85},
|
||||
{0,8,21},{144,8,3},{131,7,43},{0,8,117},{0,8,53},{0,9,202},
|
||||
{129,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},
|
||||
{0,8,69},{0,9,234},{128,7,8},{0,8,93},{0,8,29},{0,9,154},
|
||||
{132,7,83},{0,8,125},{0,8,61},{0,9,218},{130,7,23},{0,8,109},
|
||||
{0,8,45},{0,9,186},{0,8,13},{0,8,141},{0,8,77},{0,9,250},
|
||||
{128,7,3},{0,8,83},{0,8,19},{133,8,195},{131,7,35},{0,8,115},
|
||||
{0,8,51},{0,9,198},{129,7,11},{0,8,99},{0,8,35},{0,9,166},
|
||||
{0,8,3},{0,8,131},{0,8,67},{0,9,230},{128,7,7},{0,8,91},
|
||||
{0,8,27},{0,9,150},{132,7,67},{0,8,123},{0,8,59},{0,9,214},
|
||||
{130,7,19},{0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},
|
||||
{0,8,75},{0,9,246},{128,7,5},{0,8,87},{0,8,23},{77,8,0},
|
||||
{131,7,51},{0,8,119},{0,8,55},{0,9,206},{129,7,15},{0,8,103},
|
||||
{0,8,39},{0,9,174},{0,8,7},{0,8,135},{0,8,71},{0,9,238},
|
||||
{128,7,9},{0,8,95},{0,8,31},{0,9,158},{132,7,99},{0,8,127},
|
||||
{0,8,63},{0,9,222},{130,7,27},{0,8,111},{0,8,47},{0,9,190},
|
||||
{0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},
|
||||
{0,8,16},{132,8,115},{130,7,31},{0,8,112},{0,8,48},{0,9,193},
|
||||
{128,7,10},{0,8,96},{0,8,32},{0,9,161},{0,8,0},{0,8,128},
|
||||
{0,8,64},{0,9,225},{128,7,6},{0,8,88},{0,8,24},{0,9,145},
|
||||
{131,7,59},{0,8,120},{0,8,56},{0,9,209},{129,7,17},{0,8,104},
|
||||
{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},{0,9,241},
|
||||
{128,7,4},{0,8,84},{0,8,20},{133,8,227},{131,7,43},{0,8,116},
|
||||
{0,8,52},{0,9,201},{129,7,13},{0,8,100},{0,8,36},{0,9,169},
|
||||
{0,8,4},{0,8,132},{0,8,68},{0,9,233},{128,7,8},{0,8,92},
|
||||
{0,8,28},{0,9,153},{132,7,83},{0,8,124},{0,8,60},{0,9,217},
|
||||
{130,7,23},{0,8,108},{0,8,44},{0,9,185},{0,8,12},{0,8,140},
|
||||
{0,8,76},{0,9,249},{128,7,3},{0,8,82},{0,8,18},{133,8,163},
|
||||
{131,7,35},{0,8,114},{0,8,50},{0,9,197},{129,7,11},{0,8,98},
|
||||
{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
|
||||
{128,7,7},{0,8,90},{0,8,26},{0,9,149},{132,7,67},{0,8,122},
|
||||
{0,8,58},{0,9,213},{130,7,19},{0,8,106},{0,8,42},{0,9,181},
|
||||
{0,8,10},{0,8,138},{0,8,74},{0,9,245},{128,7,5},{0,8,86},
|
||||
{0,8,22},{65,8,0},{131,7,51},{0,8,118},{0,8,54},{0,9,205},
|
||||
{129,7,15},{0,8,102},{0,8,38},{0,9,173},{0,8,6},{0,8,134},
|
||||
{0,8,70},{0,9,237},{128,7,9},{0,8,94},{0,8,30},{0,9,157},
|
||||
{132,7,99},{0,8,126},{0,8,62},{0,9,221},{130,7,27},{0,8,110},
|
||||
{0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},
|
||||
{96,7,0},{0,8,81},{0,8,17},{133,8,131},{130,7,31},{0,8,113},
|
||||
{0,8,49},{0,9,195},{128,7,10},{0,8,97},{0,8,33},{0,9,163},
|
||||
{0,8,1},{0,8,129},{0,8,65},{0,9,227},{128,7,6},{0,8,89},
|
||||
{0,8,25},{0,9,147},{131,7,59},{0,8,121},{0,8,57},{0,9,211},
|
||||
{129,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},{0,8,137},
|
||||
{0,8,73},{0,9,243},{128,7,4},{0,8,85},{0,8,21},{144,8,3},
|
||||
{131,7,43},{0,8,117},{0,8,53},{0,9,203},{129,7,13},{0,8,101},
|
||||
{0,8,37},{0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},
|
||||
{128,7,8},{0,8,93},{0,8,29},{0,9,155},{132,7,83},{0,8,125},
|
||||
{0,8,61},{0,9,219},{130,7,23},{0,8,109},{0,8,45},{0,9,187},
|
||||
{0,8,13},{0,8,141},{0,8,77},{0,9,251},{128,7,3},{0,8,83},
|
||||
{0,8,19},{133,8,195},{131,7,35},{0,8,115},{0,8,51},{0,9,199},
|
||||
{129,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
|
||||
{0,8,67},{0,9,231},{128,7,7},{0,8,91},{0,8,27},{0,9,151},
|
||||
{132,7,67},{0,8,123},{0,8,59},{0,9,215},{130,7,19},{0,8,107},
|
||||
{0,8,43},{0,9,183},{0,8,11},{0,8,139},{0,8,75},{0,9,247},
|
||||
{128,7,5},{0,8,87},{0,8,23},{77,8,0},{131,7,51},{0,8,119},
|
||||
{0,8,55},{0,9,207},{129,7,15},{0,8,103},{0,8,39},{0,9,175},
|
||||
{0,8,7},{0,8,135},{0,8,71},{0,9,239},{128,7,9},{0,8,95},
|
||||
{0,8,31},{0,9,159},{132,7,99},{0,8,127},{0,8,63},{0,9,223},
|
||||
{130,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},
|
||||
{0,8,79},{0,9,255}
|
||||
};
|
||||
|
||||
static const code distfix[32] = {
|
||||
{128,5,1},{135,5,257},{131,5,17},{139,5,4097},{129,5,5},
|
||||
{137,5,1025},{133,5,65},{141,5,16385},{128,5,3},{136,5,513},
|
||||
{132,5,33},{140,5,8193},{130,5,9},{138,5,2049},{134,5,129},
|
||||
{142,5,32769},{128,5,2},{135,5,385},{131,5,25},{139,5,6145},
|
||||
{129,5,7},{137,5,1537},{133,5,97},{141,5,24577},{128,5,4},
|
||||
{136,5,769},{132,5,49},{140,5,12289},{130,5,13},{138,5,3073},
|
||||
{134,5,193},{142,5,49153}
|
||||
};
|
47
lib/zlib-1.2.3/contrib/infback9/inflate9.h
Normal file
47
lib/zlib-1.2.3/contrib/infback9/inflate9.h
Normal file
|
@ -0,0 +1,47 @@
|
|||
/* inflate9.h -- internal inflate state definition
|
||||
* Copyright (C) 1995-2003 Mark Adler
|
||||
* For conditions of distribution and use, see copyright notice in zlib.h
|
||||
*/
|
||||
|
||||
/* WARNING: this file should *not* be used by applications. It is
|
||||
part of the implementation of the compression library and is
|
||||
subject to change. Applications should only use zlib.h.
|
||||
*/
|
||||
|
||||
/* Possible inflate modes between inflate() calls */
|
||||
typedef enum {
|
||||
TYPE, /* i: waiting for type bits, including last-flag bit */
|
||||
STORED, /* i: waiting for stored size (length and complement) */
|
||||
TABLE, /* i: waiting for dynamic block table lengths */
|
||||
LEN, /* i: waiting for length/lit code */
|
||||
DONE, /* finished check, done -- remain here until reset */
|
||||
BAD /* got a data error -- remain here until reset */
|
||||
} inflate_mode;
|
||||
|
||||
/*
|
||||
State transitions between above modes -
|
||||
|
||||
(most modes can go to the BAD mode -- not shown for clarity)
|
||||
|
||||
Read deflate blocks:
|
||||
TYPE -> STORED or TABLE or LEN or DONE
|
||||
STORED -> TYPE
|
||||
TABLE -> LENLENS -> CODELENS -> LEN
|
||||
Read deflate codes:
|
||||
LEN -> LEN or TYPE
|
||||
*/
|
||||
|
||||
/* state maintained between inflate() calls. Approximately 7K bytes. */
|
||||
struct inflate_state {
|
||||
/* sliding window */
|
||||
unsigned char FAR *window; /* allocated sliding window, if needed */
|
||||
/* dynamic table building */
|
||||
unsigned ncode; /* number of code length code lengths */
|
||||
unsigned nlen; /* number of length code lengths */
|
||||
unsigned ndist; /* number of distance code lengths */
|
||||
unsigned have; /* number of code lengths in lens[] */
|
||||
code FAR *next; /* next available space in codes[] */
|
||||
unsigned short lens[320]; /* temporary storage for code lengths */
|
||||
unsigned short work[288]; /* work area for code table building */
|
||||
code codes[ENOUGH]; /* space for code tables */
|
||||
};
|
323
lib/zlib-1.2.3/contrib/infback9/inftree9.c
Normal file
323
lib/zlib-1.2.3/contrib/infback9/inftree9.c
Normal file
|
@ -0,0 +1,323 @@
|
|||
/* inftree9.c -- generate Huffman trees for efficient decoding
|
||||
* Copyright (C) 1995-2005 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.3 Copyright 1995-2005 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, 201, 196};
|
||||
static const unsigned short dbase[32] = { /* Distance codes 0..31 base */
|
||||
1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49,
|
||||
65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073,
|
||||
4097, 6145, 8193, 12289, 16385, 24577, 32769, 49153};
|
||||
static const unsigned short dext[32] = { /* Distance codes 0..31 extra */
|
||||
128, 128, 128, 128, 129, 129, 130, 130, 131, 131, 132, 132,
|
||||
133, 133, 134, 134, 135, 135, 136, 136, 137, 137, 138, 138,
|
||||
139, 139, 140, 140, 141, 141, 142, 142};
|
||||
|
||||
/*
|
||||
Process a set of code lengths to create a canonical Huffman code. The
|
||||
code lengths are lens[0..codes-1]. Each length corresponds to the
|
||||
symbols 0..codes-1. The Huffman code is generated by first sorting the
|
||||
symbols by length from short to long, and retaining the symbol order
|
||||
for codes with equal lengths. Then the code starts with all zero bits
|
||||
for the first code of the shortest length, and the codes are integer
|
||||
increments for the same length, and zeros are appended as the length
|
||||
increases. For the deflate format, these bits are stored backwards
|
||||
from their more natural integer increment ordering, and so when the
|
||||
decoding tables are built in the large loop below, the integer codes
|
||||
are incremented backwards.
|
||||
|
||||
This routine assumes, but does not check, that all of the entries in
|
||||
lens[] are in the range 0..MAXBITS. The caller must assure this.
|
||||
1..MAXBITS is interpreted as that code length. zero means that that
|
||||
symbol does not occur in this code.
|
||||
|
||||
The codes are sorted by computing a count of codes for each length,
|
||||
creating from that a table of starting indices for each length in the
|
||||
sorted table, and then entering the symbols in order in the sorted
|
||||
table. The sorted table is work[], with that space being provided by
|
||||
the caller.
|
||||
|
||||
The length counts are used for other purposes as well, i.e. finding
|
||||
the minimum and maximum length codes, determining if there are any
|
||||
codes at all, checking for a valid set of lengths, and looking ahead
|
||||
at length counts to determine sub-table sizes when building the
|
||||
decoding tables.
|
||||
*/
|
||||
|
||||
/* accumulate lengths for codes (assumes lens[] all in 0..MAXBITS) */
|
||||
for (len = 0; len <= MAXBITS; len++)
|
||||
count[len] = 0;
|
||||
for (sym = 0; sym < codes; sym++)
|
||||
count[lens[sym]]++;
|
||||
|
||||
/* bound code lengths, force root to be within code lengths */
|
||||
root = *bits;
|
||||
for (max = MAXBITS; max >= 1; max--)
|
||||
if (count[max] != 0) break;
|
||||
if (root > max) root = max;
|
||||
if (max == 0) return -1; /* no codes! */
|
||||
for (min = 1; min <= MAXBITS; min++)
|
||||
if (count[min] != 0) break;
|
||||
if (root < min) root = min;
|
||||
|
||||
/* check for an over-subscribed or incomplete set of lengths */
|
||||
left = 1;
|
||||
for (len = 1; len <= MAXBITS; len++) {
|
||||
left <<= 1;
|
||||
left -= count[len];
|
||||
if (left < 0) return -1; /* over-subscribed */
|
||||
}
|
||||
if (left > 0 && (type == CODES || max != 1))
|
||||
return -1; /* incomplete set */
|
||||
|
||||
/* generate offsets into symbol table for each length for sorting */
|
||||
offs[1] = 0;
|
||||
for (len = 1; len < MAXBITS; len++)
|
||||
offs[len + 1] = offs[len] + count[len];
|
||||
|
||||
/* sort symbols by length, by symbol order within each length */
|
||||
for (sym = 0; sym < codes; sym++)
|
||||
if (lens[sym] != 0) work[offs[lens[sym]]++] = (unsigned short)sym;
|
||||
|
||||
/*
|
||||
Create and fill in decoding tables. In this loop, the table being
|
||||
filled is at next and has curr index bits. The code being used is huff
|
||||
with length len. That code is converted to an index by dropping drop
|
||||
bits off of the bottom. For codes where len is less than drop + curr,
|
||||
those top drop + curr - len bits are incremented through all values to
|
||||
fill the table with replicated entries.
|
||||
|
||||
root is the number of index bits for the root table. When len exceeds
|
||||
root, sub-tables are created pointed to by the root entry with an index
|
||||
of the low root bits of huff. This is saved in low to check for when a
|
||||
new sub-table should be started. drop is zero when the root table is
|
||||
being filled, and drop is root when sub-tables are being filled.
|
||||
|
||||
When a new sub-table is needed, it is necessary to look ahead in the
|
||||
code lengths to determine what size sub-table is needed. The length
|
||||
counts are used for this, and so count[] is decremented as codes are
|
||||
entered in the tables.
|
||||
|
||||
used keeps track of how many table entries have been allocated from the
|
||||
provided *table space. It is checked 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;
|
||||
}
|
55
lib/zlib-1.2.3/contrib/infback9/inftree9.h
Normal file
55
lib/zlib-1.2.3/contrib/infback9/inftree9.h
Normal file
|
@ -0,0 +1,55 @@
|
|||
/* 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 1444 code structures (852 for length/literals
|
||||
and 592 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 2048
|
||||
#define MAXD 592
|
||||
|
||||
/* 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));
|
1157
lib/zlib-1.2.3/contrib/inflate86/inffas86.c
Normal file
1157
lib/zlib-1.2.3/contrib/inflate86/inffas86.c
Normal file
File diff suppressed because it is too large
Load diff
1368
lib/zlib-1.2.3/contrib/inflate86/inffast.S
Normal file
1368
lib/zlib-1.2.3/contrib/inflate86/inffast.S
Normal file
File diff suppressed because it is too large
Load diff
24
lib/zlib-1.2.3/contrib/iostream/test.cpp
Normal file
24
lib/zlib-1.2.3/contrib/iostream/test.cpp
Normal file
|
@ -0,0 +1,24 @@
|
|||
|
||||
#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;
|
||||
|
||||
}
|
329
lib/zlib-1.2.3/contrib/iostream/zfstream.cpp
Normal file
329
lib/zlib-1.2.3/contrib/iostream/zfstream.cpp
Normal file
|
@ -0,0 +1,329 @@
|
|||
|
||||
#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() { }
|
128
lib/zlib-1.2.3/contrib/iostream/zfstream.h
Normal file
128
lib/zlib-1.2.3/contrib/iostream/zfstream.h
Normal file
|
@ -0,0 +1,128 @@
|
|||
|
||||
#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
|
307
lib/zlib-1.2.3/contrib/iostream2/zstream.h
Normal file
307
lib/zlib-1.2.3/contrib/iostream2/zstream.h
Normal file
|
@ -0,0 +1,307 @@
|
|||
/*
|
||||
*
|
||||
* 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$
|
||||
*/
|
||||
|
||||
#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
|
25
lib/zlib-1.2.3/contrib/iostream2/zstream_test.cpp
Normal file
25
lib/zlib-1.2.3/contrib/iostream2/zstream_test.cpp
Normal file
|
@ -0,0 +1,25 @@
|
|||
#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;
|
||||
}
|
35
lib/zlib-1.2.3/contrib/iostream3/README
Normal file
35
lib/zlib-1.2.3/contrib/iostream3/README
Normal file
|
@ -0,0 +1,35 @@
|
|||
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
|
17
lib/zlib-1.2.3/contrib/iostream3/TODO
Normal file
17
lib/zlib-1.2.3/contrib/iostream3/TODO
Normal file
|
@ -0,0 +1,17 @@
|
|||
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(); )
|
50
lib/zlib-1.2.3/contrib/iostream3/test.cc
Normal file
50
lib/zlib-1.2.3/contrib/iostream3/test.cc
Normal file
|
@ -0,0 +1,50 @@
|
|||
/*
|
||||
* 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;
|
||||
|
||||
}
|
479
lib/zlib-1.2.3/contrib/iostream3/zfstream.cc
Normal file
479
lib/zlib-1.2.3/contrib/iostream3/zfstream.cc
Normal file
|
@ -0,0 +1,479 @@
|
|||
/*
|
||||
* 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);
|
||||
}
|
466
lib/zlib-1.2.3/contrib/iostream3/zfstream.h
Normal file
466
lib/zlib-1.2.3/contrib/iostream3/zfstream.h
Normal file
|
@ -0,0 +1,466 @@
|
|||
/*
|
||||
* 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
|
413
lib/zlib-1.2.3/contrib/masm686/match.asm
Normal file
413
lib/zlib-1.2.3/contrib/masm686/match.asm
Normal file
|
@ -0,0 +1,413 @@
|
|||
|
||||
; 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>
|
||||
;
|
||||
; Modified by Gilles Vollant (2005) for add gzhead and gzindex
|
||||
|
||||
.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 ?
|
||||
; gzhead and gzindex are added in zlib 1.2.2.2 (see deflate.h)
|
||||
ds_gzhead dd ?
|
||||
ds_gzindex 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
|
2
lib/zlib-1.2.3/contrib/masmx64/bld_ml64.bat
Normal file
2
lib/zlib-1.2.3/contrib/masmx64/bld_ml64.bat
Normal file
|
@ -0,0 +1,2 @@
|
|||
ml64.exe /Flinffasx64 /c /Zi inffasx64.asm
|
||||
ml64.exe /Flgvmat64 /c /Zi gvmat64.asm
|
513
lib/zlib-1.2.3/contrib/masmx64/gvmat64.asm
Normal file
513
lib/zlib-1.2.3/contrib/masmx64/gvmat64.asm
Normal file
|
@ -0,0 +1,513 @@
|
|||
;uInt longest_match_x64(
|
||||
; deflate_state *s,
|
||||
; IPos cur_match); /* current match */
|
||||
|
||||
; gvmat64.asm -- Asm portion of the optimized longest_match for 32 bits x86
|
||||
; Copyright (C) 1995-2005 Jean-loup Gailly, Brian Raiter and Gilles Vollant.
|
||||
;
|
||||
; File written by Gilles Vollant, by converting to assembly the longest_match
|
||||
; from Jean-loup Gailly in deflate.c of zLib and infoZip zip.
|
||||
;
|
||||
; and by taking inspiration on asm686 with masm, optimised assembly code
|
||||
; from Brian Raiter, written 1998
|
||||
;
|
||||
; http://www.zlib.net
|
||||
; http://www.winimage.com/zLibDll
|
||||
; http://www.muppetlabs.com/~breadbox/software/assembly.html
|
||||
;
|
||||
; to compile this file for infozip Zip, I use option:
|
||||
; ml64.exe /Flgvmat64 /c /Zi /DINFOZIP gvmat64.asm
|
||||
;
|
||||
; to compile this file for zLib, I use option:
|
||||
; ml64.exe /Flgvmat64 /c /Zi gvmat64.asm
|
||||
; Be carrefull to adapt zlib1222add below to your version of zLib
|
||||
; (if you use a version of zLib before 1.0.4 or after 1.2.2.2, change
|
||||
; value of zlib1222add later)
|
||||
;
|
||||
; This file compile with Microsoft Macro Assembler (x64) for AMD64
|
||||
;
|
||||
; ml64.exe is given with Visual Studio 2005 and Windows 2003 server DDK
|
||||
;
|
||||
; (you can get Windows 2003 server DDK with ml64 and cl for AMD64 from
|
||||
; http://www.microsoft.com/whdc/devtools/ddk/default.mspx for low price)
|
||||
;
|
||||
|
||||
|
||||
;uInt longest_match(s, cur_match)
|
||||
; deflate_state *s;
|
||||
; IPos cur_match; /* current match */
|
||||
.code
|
||||
longest_match PROC
|
||||
|
||||
|
||||
;LocalVarsSize equ 88
|
||||
LocalVarsSize equ 72
|
||||
|
||||
; register used : rax,rbx,rcx,rdx,rsi,rdi,r8,r9,r10,r11,r12
|
||||
; free register : r14,r15
|
||||
; register can be saved : rsp
|
||||
|
||||
chainlenwmask equ rsp + 8 - LocalVarsSize ; high word: current chain len
|
||||
; low word: s->wmask
|
||||
;window equ rsp + xx - LocalVarsSize ; local copy of s->window ; stored in r10
|
||||
;windowbestlen equ rsp + xx - LocalVarsSize ; s->window + bestlen , use r10+r11
|
||||
;scanstart equ rsp + xx - LocalVarsSize ; first two bytes of string ; stored in r12w
|
||||
;scanend equ rsp + xx - LocalVarsSize ; last two bytes of string use ebx
|
||||
;scanalign equ rsp + xx - LocalVarsSize ; dword-misalignment of string r13
|
||||
;bestlen equ rsp + xx - LocalVarsSize ; size of best match so far -> r11d
|
||||
;scan equ rsp + xx - LocalVarsSize ; ptr to string wanting match -> r9
|
||||
IFDEF INFOZIP
|
||||
ELSE
|
||||
nicematch equ (rsp + 16 - LocalVarsSize) ; a good enough match size
|
||||
ENDIF
|
||||
|
||||
save_rdi equ rsp + 24 - LocalVarsSize
|
||||
save_rsi equ rsp + 32 - LocalVarsSize
|
||||
save_rbx equ rsp + 40 - LocalVarsSize
|
||||
save_rbp equ rsp + 48 - LocalVarsSize
|
||||
save_r12 equ rsp + 56 - LocalVarsSize
|
||||
save_r13 equ rsp + 64 - LocalVarsSize
|
||||
;save_r14 equ rsp + 72 - LocalVarsSize
|
||||
;save_r15 equ rsp + 80 - LocalVarsSize
|
||||
|
||||
|
||||
|
||||
; 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
|
||||
|
||||
|
||||
MAX_MATCH equ 258
|
||||
MIN_MATCH equ 3
|
||||
MIN_LOOKAHEAD equ (MAX_MATCH+MIN_MATCH+1)
|
||||
|
||||
|
||||
;;; 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.)
|
||||
|
||||
; all the +zlib1222add offsets are due to the addition of fields
|
||||
; in zlib in the deflate_state structure since the asm code was first written
|
||||
; (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
|
||||
; (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
|
||||
; if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
|
||||
|
||||
|
||||
IFDEF INFOZIP
|
||||
|
||||
_DATA SEGMENT
|
||||
COMM window_size:DWORD
|
||||
; WMask ; 7fff
|
||||
COMM window:BYTE:010040H
|
||||
COMM prev:WORD:08000H
|
||||
; MatchLen : unused
|
||||
; PrevMatch : unused
|
||||
COMM strstart:DWORD
|
||||
COMM match_start:DWORD
|
||||
; Lookahead : ignore
|
||||
COMM prev_length:DWORD ; PrevLen
|
||||
COMM max_chain_length:DWORD
|
||||
COMM good_match:DWORD
|
||||
COMM nice_match:DWORD
|
||||
prev_ad equ OFFSET prev
|
||||
window_ad equ OFFSET window
|
||||
nicematch equ nice_match
|
||||
_DATA ENDS
|
||||
WMask equ 07fffh
|
||||
|
||||
ELSE
|
||||
|
||||
IFNDEF zlib1222add
|
||||
zlib1222add equ 8
|
||||
ENDIF
|
||||
dsWSize equ 56+zlib1222add+(zlib1222add/2)
|
||||
dsWMask equ 64+zlib1222add+(zlib1222add/2)
|
||||
dsWindow equ 72+zlib1222add
|
||||
dsPrev equ 88+zlib1222add
|
||||
dsMatchLen equ 128+zlib1222add
|
||||
dsPrevMatch equ 132+zlib1222add
|
||||
dsStrStart equ 140+zlib1222add
|
||||
dsMatchStart equ 144+zlib1222add
|
||||
dsLookahead equ 148+zlib1222add
|
||||
dsPrevLen equ 152+zlib1222add
|
||||
dsMaxChainLen equ 156+zlib1222add
|
||||
dsGoodMatch equ 172+zlib1222add
|
||||
dsNiceMatch equ 176+zlib1222add
|
||||
|
||||
window_size equ [ rcx + dsWSize]
|
||||
WMask equ [ rcx + dsWMask]
|
||||
window_ad equ [ rcx + dsWindow]
|
||||
prev_ad equ [ rcx + dsPrev]
|
||||
strstart equ [ rcx + dsStrStart]
|
||||
match_start equ [ rcx + dsMatchStart]
|
||||
Lookahead equ [ rcx + dsLookahead] ; 0ffffffffh on infozip
|
||||
prev_length equ [ rcx + dsPrevLen]
|
||||
max_chain_length equ [ rcx + dsMaxChainLen]
|
||||
good_match equ [ rcx + dsGoodMatch]
|
||||
nice_match equ [ rcx + dsNiceMatch]
|
||||
ENDIF
|
||||
|
||||
; parameter 1 in r8(deflate state s), param 2 in rdx (cur match)
|
||||
|
||||
; see http://weblogs.asp.net/oldnewthing/archive/2004/01/14/58579.aspx and
|
||||
; http://msdn.microsoft.com/library/en-us/kmarch/hh/kmarch/64bitAMD_8e951dd2-ee77-4728-8702-55ce4b5dd24a.xml.asp
|
||||
;
|
||||
; All registers must be preserved across the call, except for
|
||||
; rax, rcx, rdx, r8, r9, r10, and r11, which are scratch.
|
||||
|
||||
|
||||
|
||||
;;; Save registers that the compiler may be using, and adjust esp to
|
||||
;;; make room for our stack frame.
|
||||
|
||||
|
||||
;;; Retrieve the function arguments. r8d 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.
|
||||
|
||||
; parameter 1 in rcx (deflate_state* s), param 2 in edx -> r8 (cur match)
|
||||
|
||||
; this clear high 32 bits of r8, which can be garbage in both r8 and rdx
|
||||
|
||||
mov [save_rdi],rdi
|
||||
mov [save_rsi],rsi
|
||||
mov [save_rbx],rbx
|
||||
mov [save_rbp],rbp
|
||||
IFDEF INFOZIP
|
||||
mov r8d,ecx
|
||||
ELSE
|
||||
mov r8d,edx
|
||||
ENDIF
|
||||
mov [save_r12],r12
|
||||
mov [save_r13],r13
|
||||
; mov [save_r14],r14
|
||||
; mov [save_r15],r15
|
||||
|
||||
|
||||
;;; uInt wmask = s->w_mask;
|
||||
;;; unsigned chain_length = s->max_chain_length;
|
||||
;;; if (s->prev_length >= s->good_match) {
|
||||
;;; chain_length >>= 2;
|
||||
;;; }
|
||||
|
||||
mov edi, prev_length
|
||||
mov esi, good_match
|
||||
mov eax, WMask
|
||||
mov ebx, max_chain_length
|
||||
cmp edi, esi
|
||||
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
|
||||
|
||||
;;; on zlib only
|
||||
;;; if ((uInt)nice_match > s->lookahead) nice_match = s->lookahead;
|
||||
|
||||
IFDEF INFOZIP
|
||||
mov [chainlenwmask], ebx
|
||||
; on infozip nice_match = [nice_match]
|
||||
ELSE
|
||||
mov eax, nice_match
|
||||
mov [chainlenwmask], ebx
|
||||
mov r10d, Lookahead
|
||||
cmp r10d, eax
|
||||
cmovnl r10d, eax
|
||||
mov [nicematch],r10d
|
||||
ENDIF
|
||||
|
||||
;;; register Bytef *scan = s->window + s->strstart;
|
||||
mov r10, window_ad
|
||||
mov ebp, strstart
|
||||
lea r13, [r10 + rbp]
|
||||
|
||||
;;; Determine how many bytes the scan ptr is off from being
|
||||
;;; dword-aligned.
|
||||
|
||||
mov r9,r13
|
||||
neg r13
|
||||
and r13,3
|
||||
|
||||
;;; IPos limit = s->strstart > (IPos)MAX_DIST(s) ?
|
||||
;;; s->strstart - (IPos)MAX_DIST(s) : NIL;
|
||||
IFDEF INFOZIP
|
||||
mov eax,07efah ; MAX_DIST = (WSIZE-MIN_LOOKAHEAD) (0x8000-(3+8+1))
|
||||
ELSE
|
||||
mov eax, window_size
|
||||
sub eax, MIN_LOOKAHEAD
|
||||
ENDIF
|
||||
xor edi,edi
|
||||
sub ebp, eax
|
||||
|
||||
mov r11d, prev_length
|
||||
|
||||
cmovng ebp,edi
|
||||
|
||||
;;; int best_len = s->prev_length;
|
||||
|
||||
|
||||
;;; Store the sum of s->window + best_len in esi locally, and in esi.
|
||||
|
||||
lea rsi,[r10+r11]
|
||||
|
||||
;;; register ush scan_start = *(ushf*)scan;
|
||||
;;; register ush scan_end = *(ushf*)(scan+best_len-1);
|
||||
;;; Posf *prev = s->prev;
|
||||
|
||||
movzx r12d,word ptr [r9]
|
||||
movzx ebx, word ptr [r9 + r11 - 1]
|
||||
|
||||
mov rdi, prev_ad
|
||||
|
||||
;;; Jump into the main loop.
|
||||
|
||||
mov edx, [chainlenwmask]
|
||||
|
||||
cmp bx,word ptr [rsi + r8 - 1]
|
||||
jz LookupLoopIsZero
|
||||
|
||||
LookupLoop1:
|
||||
and r8d, edx
|
||||
|
||||
movzx r8d, word ptr [rdi + r8*2]
|
||||
cmp r8d, ebp
|
||||
jbe LeaveNow
|
||||
sub edx, 00010000h
|
||||
js LeaveNow
|
||||
|
||||
LoopEntry1:
|
||||
cmp bx,word ptr [rsi + r8 - 1]
|
||||
jz LookupLoopIsZero
|
||||
|
||||
LookupLoop2:
|
||||
and r8d, edx
|
||||
|
||||
movzx r8d, word ptr [rdi + r8*2]
|
||||
cmp r8d, ebp
|
||||
jbe LeaveNow
|
||||
sub edx, 00010000h
|
||||
js LeaveNow
|
||||
|
||||
LoopEntry2:
|
||||
cmp bx,word ptr [rsi + r8 - 1]
|
||||
jz LookupLoopIsZero
|
||||
|
||||
LookupLoop4:
|
||||
and r8d, edx
|
||||
|
||||
movzx r8d, word ptr [rdi + r8*2]
|
||||
cmp r8d, ebp
|
||||
jbe LeaveNow
|
||||
sub edx, 00010000h
|
||||
js LeaveNow
|
||||
|
||||
LoopEntry4:
|
||||
|
||||
cmp bx,word ptr [rsi + r8 - 1]
|
||||
jnz LookupLoop1
|
||||
jmp LookupLoopIsZero
|
||||
|
||||
|
||||
;;; 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
|
||||
;;; r8d = curmatch
|
||||
;;; edx = chainlenwmask - i.e., ((chainlen << 16) | wmask)
|
||||
;;; esi = windowbestlen - i.e., (window + bestlen)
|
||||
;;; edi = prev
|
||||
;;; ebp = limit
|
||||
|
||||
LookupLoop:
|
||||
and r8d, edx
|
||||
|
||||
movzx r8d, word ptr [rdi + r8*2]
|
||||
cmp r8d, ebp
|
||||
jbe LeaveNow
|
||||
sub edx, 00010000h
|
||||
js LeaveNow
|
||||
|
||||
LoopEntry:
|
||||
|
||||
cmp bx,word ptr [rsi + r8 - 1]
|
||||
jnz LookupLoop1
|
||||
LookupLoopIsZero:
|
||||
cmp r12w, word ptr [r10 + r8]
|
||||
jnz LookupLoop1
|
||||
|
||||
|
||||
;;; 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).
|
||||
|
||||
lea rsi,[r8+r10]
|
||||
mov rdx, 0fffffffffffffef8h; -(MAX_MATCH_8)
|
||||
lea rsi, [rsi + r13 + 0108h] ;MAX_MATCH_8]
|
||||
lea rdi, [r9 + r13 + 0108h] ;MAX_MATCH_8]
|
||||
|
||||
prefetcht1 [rsi+rdx]
|
||||
prefetcht1 [rdi+rdx]
|
||||
|
||||
|
||||
;;; Test the strings for equality, 8 bytes at a time. At the end,
|
||||
;;; adjust rdx 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. (rsi 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 rax, [rsi + rdx]
|
||||
xor rax, [rdi + rdx]
|
||||
jnz LeaveLoopCmps
|
||||
|
||||
mov rax, [rsi + rdx + 8]
|
||||
xor rax, [rdi + rdx + 8]
|
||||
jnz LeaveLoopCmps8
|
||||
|
||||
|
||||
mov rax, [rsi + rdx + 8+8]
|
||||
xor rax, [rdi + rdx + 8+8]
|
||||
jnz LeaveLoopCmps16
|
||||
|
||||
add rdx,8+8+8
|
||||
|
||||
jmp short LoopCmps
|
||||
LeaveLoopCmps16: add rdx,8
|
||||
LeaveLoopCmps8: add rdx,8
|
||||
LeaveLoopCmps:
|
||||
|
||||
test eax, 0000FFFFh
|
||||
jnz LenLower
|
||||
|
||||
test eax,0ffffffffh
|
||||
|
||||
jnz LenLower32
|
||||
|
||||
add rdx,4
|
||||
shr rax,32
|
||||
or ax,ax
|
||||
jnz LenLower
|
||||
|
||||
LenLower32:
|
||||
shr eax,16
|
||||
add rdx,2
|
||||
LenLower: sub al, 1
|
||||
adc rdx, 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 rax, [rdi + rdx]
|
||||
sub rax, r9
|
||||
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.
|
||||
;///////////////////////////////////
|
||||
|
||||
cmp eax, r11d
|
||||
jg LongerMatch
|
||||
|
||||
lea rsi,[r10+r11]
|
||||
|
||||
mov rdi, prev_ad
|
||||
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 r11d, eax
|
||||
mov match_start, r8d
|
||||
cmp eax, [nicematch]
|
||||
jge LeaveNow
|
||||
|
||||
lea rsi,[r10+rax]
|
||||
|
||||
movzx ebx, word ptr [r9 + rax - 1]
|
||||
mov rdi, prev_ad
|
||||
mov edx, [chainlenwmask]
|
||||
jmp LookupLoop
|
||||
|
||||
;;; Accept the current string, with the maximum possible length.
|
||||
|
||||
LenMaximum:
|
||||
mov r11d,MAX_MATCH
|
||||
mov match_start, r8d
|
||||
|
||||
;;; if ((uInt)best_len <= s->lookahead) return (uInt)best_len;
|
||||
;;; return s->lookahead;
|
||||
|
||||
LeaveNow:
|
||||
IFDEF INFOZIP
|
||||
mov eax,r11d
|
||||
ELSE
|
||||
mov eax, Lookahead
|
||||
cmp r11d, eax
|
||||
cmovng eax, r11d
|
||||
ENDIF
|
||||
|
||||
;;; Restore the stack and return from whence we came.
|
||||
|
||||
|
||||
mov rsi,[save_rsi]
|
||||
mov rdi,[save_rdi]
|
||||
mov rbx,[save_rbx]
|
||||
mov rbp,[save_rbp]
|
||||
mov r12,[save_r12]
|
||||
mov r13,[save_r13]
|
||||
; mov r14,[save_r14]
|
||||
; mov r15,[save_r15]
|
||||
|
||||
|
||||
ret 0
|
||||
; please don't remove this string !
|
||||
; Your can freely use gvmat64 in any free or commercial app
|
||||
; but it is far better don't remove the string in the binary!
|
||||
db 0dh,0ah,"asm686 with masm, optimised assembly code from Brian Raiter, written 1998, converted to amd 64 by Gilles Vollant 2005",0dh,0ah,0
|
||||
longest_match ENDP
|
||||
|
||||
match_init PROC
|
||||
ret 0
|
||||
match_init ENDP
|
||||
|
||||
|
||||
END
|
BIN
lib/zlib-1.2.3/contrib/masmx64/gvmat64.obj
Normal file
BIN
lib/zlib-1.2.3/contrib/masmx64/gvmat64.obj
Normal file
Binary file not shown.
186
lib/zlib-1.2.3/contrib/masmx64/inffas8664.c
Normal file
186
lib/zlib-1.2.3/contrib/masmx64/inffas8664.c
Normal file
|
@ -0,0 +1,186 @@
|
|||
/* inffas8664.c is a hand tuned assembler version of inffast.c - fast decoding
|
||||
* version for AMD64 on Windows using Microsoft C compiler
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
* 2005 - Adaptation to Microsoft C Compiler for AMD64 by Gilles Vollant
|
||||
*
|
||||
* inffas8664.c call function inffas8664fnc in inffasx64.asm
|
||||
* inffasx64.asm is automatically convert from AMD64 portion of inffas86.c
|
||||
*
|
||||
* Dec-29-2003 -- I added AMD64 inflate asm support. This version is also
|
||||
* slightly quicker on x86 systems because, instead of using rep movsb to copy
|
||||
* data, it uses rep movsw, which moves data in 2-byte chunks instead of single
|
||||
* bytes. I've tested the AMD64 code on a Fedora Core 1 + the x86_64 updates
|
||||
* from http://fedora.linux.duke.edu/fc1_x86_64
|
||||
* which is running on an Athlon 64 3000+ / Gigabyte GA-K8VT800M system with
|
||||
* 1GB ram. The 64-bit version is about 4% faster than the 32-bit version,
|
||||
* when decompressing mozilla-source-1.3.tar.gz.
|
||||
*
|
||||
* 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 <stdio.h>
|
||||
#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.
|
||||
*/
|
||||
|
||||
|
||||
|
||||
typedef struct inffast_ar {
|
||||
/* 64 32 x86 x86_64 */
|
||||
/* ar offset register */
|
||||
/* 0 0 */ void *esp; /* esp save */
|
||||
/* 8 4 */ void *ebp; /* ebp save */
|
||||
/* 16 8 */ unsigned char FAR *in; /* esi rsi local strm->next_in */
|
||||
/* 24 12 */ unsigned char FAR *last; /* r9 while in < last */
|
||||
/* 32 16 */ unsigned char FAR *out; /* edi rdi local strm->next_out */
|
||||
/* 40 20 */ unsigned char FAR *beg; /* inflate()'s init next_out */
|
||||
/* 48 24 */ unsigned char FAR *end; /* r10 while out < end */
|
||||
/* 56 28 */ unsigned char FAR *window;/* size of window, wsize!=0 */
|
||||
/* 64 32 */ code const FAR *lcode; /* ebp rbp local strm->lencode */
|
||||
/* 72 36 */ code const FAR *dcode; /* r11 local strm->distcode */
|
||||
/* 80 40 */ size_t /*unsigned long */hold; /* edx rdx local strm->hold */
|
||||
/* 88 44 */ unsigned bits; /* ebx rbx local strm->bits */
|
||||
/* 92 48 */ unsigned wsize; /* window size */
|
||||
/* 96 52 */ unsigned write; /* window write index */
|
||||
/*100 56 */ unsigned lmask; /* r12 mask for lcode */
|
||||
/*104 60 */ unsigned dmask; /* r13 mask for dcode */
|
||||
/*108 64 */ unsigned len; /* r14 match length */
|
||||
/*112 68 */ unsigned dist; /* r15 match distance */
|
||||
/*116 72 */ unsigned status; /* set when state chng*/
|
||||
} type_ar;
|
||||
#ifdef ASMINF
|
||||
|
||||
void inflate_fast(strm, start)
|
||||
z_streamp strm;
|
||||
unsigned start; /* inflate()'s starting value for strm->avail_out */
|
||||
{
|
||||
struct inflate_state FAR *state;
|
||||
type_ar ar;
|
||||
void inffas8664fnc(struct inffast_ar * par);
|
||||
|
||||
|
||||
|
||||
#if (defined( __GNUC__ ) && defined( __amd64__ ) && ! defined( __i386 )) || (defined(_MSC_VER) && defined(_M_AMD64))
|
||||
#define PAD_AVAIL_IN 6
|
||||
#define PAD_AVAIL_OUT 258
|
||||
#else
|
||||
#define PAD_AVAIL_IN 5
|
||||
#define PAD_AVAIL_OUT 257
|
||||
#endif
|
||||
|
||||
/* copy state to local variables */
|
||||
state = (struct inflate_state FAR *)strm->state;
|
||||
|
||||
ar.in = strm->next_in;
|
||||
ar.last = ar.in + (strm->avail_in - PAD_AVAIL_IN);
|
||||
ar.out = strm->next_out;
|
||||
ar.beg = ar.out - (start - strm->avail_out);
|
||||
ar.end = ar.out + (strm->avail_out - PAD_AVAIL_OUT);
|
||||
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 1/2 hold size boundary */
|
||||
while (((size_t)(void *)ar.in & (sizeof(ar.hold) / 2 - 1)) != 0) {
|
||||
ar.hold += (unsigned long)*ar.in++ << ar.bits;
|
||||
ar.bits += 8;
|
||||
}
|
||||
|
||||
inffas8664fnc(&ar);
|
||||
|
||||
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 ?
|
||||
PAD_AVAIL_IN + (ar.last - ar.in) :
|
||||
PAD_AVAIL_IN - (ar.in - ar.last));
|
||||
strm->avail_out = (unsigned)(ar.out < ar.end ?
|
||||
PAD_AVAIL_OUT + (ar.end - ar.out) :
|
||||
PAD_AVAIL_OUT - (ar.out - ar.end));
|
||||
state->hold = (unsigned long)ar.hold;
|
||||
state->bits = ar.bits;
|
||||
return;
|
||||
}
|
||||
|
||||
#endif
|
392
lib/zlib-1.2.3/contrib/masmx64/inffasx64.asm
Normal file
392
lib/zlib-1.2.3/contrib/masmx64/inffasx64.asm
Normal file
|
@ -0,0 +1,392 @@
|
|||
; inffasx64.asm is a hand tuned assembler version of inffast.c - fast decoding
|
||||
; version for AMD64 on Windows using Microsoft C compiler
|
||||
;
|
||||
; inffasx64.asm is automatically convert from AMD64 portion of inffas86.c
|
||||
; inffasx64.asm is called by inffas8664.c, which contain more info.
|
||||
|
||||
|
||||
; to compile this file, I use option
|
||||
; ml64.exe /Flinffasx64 /c /Zi inffasx64.asm
|
||||
; with Microsoft Macro Assembler (x64) for AMD64
|
||||
;
|
||||
; ml64.exe is given with Visual Studio 2005, Windows 2003 server DDK
|
||||
;
|
||||
; (you can get Windows 2003 server DDK with ml64 and cl.exe for AMD64 from
|
||||
; http://www.microsoft.com/whdc/devtools/ddk/default.mspx for low price)
|
||||
;
|
||||
|
||||
.code
|
||||
inffas8664fnc PROC
|
||||
|
||||
; see http://weblogs.asp.net/oldnewthing/archive/2004/01/14/58579.aspx and
|
||||
; http://msdn.microsoft.com/library/en-us/kmarch/hh/kmarch/64bitAMD_8e951dd2-ee77-4728-8702-55ce4b5dd24a.xml.asp
|
||||
;
|
||||
; All registers must be preserved across the call, except for
|
||||
; rax, rcx, rdx, r8, r-9, r10, and r11, which are scratch.
|
||||
|
||||
|
||||
mov [rsp-8],rsi
|
||||
mov [rsp-16],rdi
|
||||
mov [rsp-24],r12
|
||||
mov [rsp-32],r13
|
||||
mov [rsp-40],r14
|
||||
mov [rsp-48],r15
|
||||
mov [rsp-56],rbx
|
||||
|
||||
mov rax,rcx
|
||||
|
||||
mov [rax+8], rbp ; /* save regs rbp and rsp */
|
||||
mov [rax], rsp
|
||||
|
||||
mov rsp, rax ; /* make rsp point to &ar */
|
||||
|
||||
mov rsi, [rsp+16] ; /* rsi = in */
|
||||
mov rdi, [rsp+32] ; /* rdi = out */
|
||||
mov r9, [rsp+24] ; /* r9 = last */
|
||||
mov r10, [rsp+48] ; /* r10 = end */
|
||||
mov rbp, [rsp+64] ; /* rbp = lcode */
|
||||
mov r11, [rsp+72] ; /* r11 = dcode */
|
||||
mov rdx, [rsp+80] ; /* rdx = hold */
|
||||
mov ebx, [rsp+88] ; /* ebx = bits */
|
||||
mov r12d, [rsp+100] ; /* r12d = lmask */
|
||||
mov r13d, [rsp+104] ; /* r13d = dmask */
|
||||
; /* r14d = len */
|
||||
; /* r15d = dist */
|
||||
|
||||
|
||||
cld
|
||||
cmp r10, rdi
|
||||
je L_one_time ; /* if only one decode left */
|
||||
cmp r9, rsi
|
||||
|
||||
jne L_do_loop
|
||||
|
||||
|
||||
L_one_time:
|
||||
mov r8, r12 ; /* r8 = lmask */
|
||||
cmp bl, 32
|
||||
ja L_get_length_code_one_time
|
||||
|
||||
lodsd ; /* eax = *(uint *)in++ */
|
||||
mov cl, bl ; /* cl = bits, needs it for shifting */
|
||||
add bl, 32 ; /* bits += 32 */
|
||||
shl rax, cl
|
||||
or rdx, rax ; /* hold |= *((uint *)in)++ << bits */
|
||||
jmp L_get_length_code_one_time
|
||||
|
||||
ALIGN 4
|
||||
L_while_test:
|
||||
cmp r10, rdi
|
||||
jbe L_break_loop
|
||||
cmp r9, rsi
|
||||
jbe L_break_loop
|
||||
|
||||
L_do_loop:
|
||||
mov r8, r12 ; /* r8 = lmask */
|
||||
cmp bl, 32
|
||||
ja L_get_length_code ; /* if (32 < bits) */
|
||||
|
||||
lodsd ; /* eax = *(uint *)in++ */
|
||||
mov cl, bl ; /* cl = bits, needs it for shifting */
|
||||
add bl, 32 ; /* bits += 32 */
|
||||
shl rax, cl
|
||||
or rdx, rax ; /* hold |= *((uint *)in)++ << bits */
|
||||
|
||||
L_get_length_code:
|
||||
and r8, rdx ; /* r8 &= hold */
|
||||
mov eax, [rbp+r8*4] ; /* eax = lcode[hold & lmask] */
|
||||
|
||||
mov cl, ah ; /* cl = this.bits */
|
||||
sub bl, ah ; /* bits -= this.bits */
|
||||
shr rdx, cl ; /* hold >>= this.bits */
|
||||
|
||||
test al, al
|
||||
jnz L_test_for_length_base ; /* if (op != 0) 45.7% */
|
||||
|
||||
mov r8, r12 ; /* r8 = lmask */
|
||||
shr eax, 16 ; /* output this.val char */
|
||||
stosb
|
||||
|
||||
L_get_length_code_one_time:
|
||||
and r8, rdx ; /* r8 &= hold */
|
||||
mov eax, [rbp+r8*4] ; /* eax = lcode[hold & lmask] */
|
||||
|
||||
L_dolen:
|
||||
mov cl, ah ; /* cl = this.bits */
|
||||
sub bl, ah ; /* bits -= this.bits */
|
||||
shr rdx, 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
|
||||
|
||||
ALIGN 4
|
||||
L_test_for_length_base:
|
||||
mov r14d, eax ; /* len = this */
|
||||
shr r14d, 16 ; /* len = this.val */
|
||||
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) */
|
||||
|
||||
L_add_bits_to_len:
|
||||
sub bl, cl
|
||||
xor eax, eax
|
||||
inc eax
|
||||
shl eax, cl
|
||||
dec eax
|
||||
and eax, edx ; /* eax &= hold */
|
||||
shr rdx, cl
|
||||
add r14d, eax ; /* len += hold & mask[op] */
|
||||
|
||||
L_decode_distance:
|
||||
mov r8, r13 ; /* r8 = dmask */
|
||||
cmp bl, 32
|
||||
ja L_get_distance_code ; /* if (32 < bits) */
|
||||
|
||||
lodsd ; /* eax = *(uint *)in++ */
|
||||
mov cl, bl ; /* cl = bits, needs it for shifting */
|
||||
add bl, 32 ; /* bits += 32 */
|
||||
shl rax, cl
|
||||
or rdx, rax ; /* hold |= *((uint *)in)++ << bits */
|
||||
|
||||
L_get_distance_code:
|
||||
and r8, rdx ; /* r8 &= hold */
|
||||
mov eax, [r11+r8*4] ; /* eax = dcode[hold & dmask] */
|
||||
|
||||
L_dodist:
|
||||
mov r15d, eax ; /* dist = this */
|
||||
shr r15d, 16 ; /* dist = this.val */
|
||||
mov cl, ah
|
||||
sub bl, ah ; /* bits -= this.bits */
|
||||
shr rdx, 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
|
||||
|
||||
L_add_bits_to_dist:
|
||||
sub bl, cl
|
||||
xor eax, eax
|
||||
inc eax
|
||||
shl eax, cl
|
||||
dec eax ; /* (1 << op) - 1 */
|
||||
and eax, edx ; /* eax &= hold */
|
||||
shr rdx, cl
|
||||
add r15d, eax ; /* dist += hold & ((1 << op) - 1) */
|
||||
|
||||
L_check_window:
|
||||
mov r8, rsi ; /* save in so from can use it's reg */
|
||||
mov rax, rdi
|
||||
sub rax, [rsp+40] ; /* nbytes = out - beg */
|
||||
|
||||
cmp eax, r15d
|
||||
jb L_clip_window ; /* if (dist > nbytes) 4.2% */
|
||||
|
||||
mov ecx, r14d ; /* ecx = len */
|
||||
mov rsi, rdi
|
||||
sub rsi, r15 ; /* from = out - dist */
|
||||
|
||||
sar ecx, 1
|
||||
jnc L_copy_two ; /* if len % 2 == 0 */
|
||||
|
||||
rep movsw
|
||||
mov al, [rsi]
|
||||
mov [rdi], al
|
||||
inc rdi
|
||||
|
||||
mov rsi, r8 ; /* move in back to %rsi, toss from */
|
||||
jmp L_while_test
|
||||
|
||||
L_copy_two:
|
||||
rep movsw
|
||||
mov rsi, r8 ; /* move in back to %rsi, toss from */
|
||||
jmp L_while_test
|
||||
|
||||
ALIGN 4
|
||||
L_check_dist_one:
|
||||
cmp r15d, 1 ; /* if dist 1, is a memset */
|
||||
jne L_check_window
|
||||
cmp [rsp+40], rdi ; /* if out == beg, outside window */
|
||||
je L_check_window
|
||||
|
||||
mov ecx, r14d ; /* ecx = len */
|
||||
mov al, [rdi-1]
|
||||
mov ah, al
|
||||
|
||||
sar ecx, 1
|
||||
jnc L_set_two
|
||||
mov [rdi], al
|
||||
inc rdi
|
||||
|
||||
L_set_two:
|
||||
rep stosw
|
||||
jmp L_while_test
|
||||
|
||||
ALIGN 4
|
||||
L_test_for_second_level_length:
|
||||
test al, 64
|
||||
jnz L_test_for_end_of_block ; /* if ((op & 64) != 0) */
|
||||
|
||||
xor eax, eax
|
||||
inc eax
|
||||
shl eax, cl
|
||||
dec eax
|
||||
and eax, edx ; /* eax &= hold */
|
||||
add eax, r14d ; /* eax += len */
|
||||
mov eax, [rbp+rax*4] ; /* eax = lcode[val+(hold&mask[op])]*/
|
||||
jmp L_dolen
|
||||
|
||||
ALIGN 4
|
||||
L_test_for_second_level_dist:
|
||||
test al, 64
|
||||
jnz L_invalid_distance_code ; /* if ((op & 64) != 0) */
|
||||
|
||||
xor eax, eax
|
||||
inc eax
|
||||
shl eax, cl
|
||||
dec eax
|
||||
and eax, edx ; /* eax &= hold */
|
||||
add eax, r15d ; /* eax += dist */
|
||||
mov eax, [r11+rax*4] ; /* eax = dcode[val+(hold&mask[op])]*/
|
||||
jmp L_dodist
|
||||
|
||||
ALIGN 4
|
||||
L_clip_window:
|
||||
mov ecx, eax ; /* ecx = nbytes */
|
||||
mov eax, [rsp+92] ; /* eax = wsize, prepare for dist cmp */
|
||||
neg ecx ; /* nbytes = -nbytes */
|
||||
|
||||
cmp eax, r15d
|
||||
jb L_invalid_distance_too_far ; /* if (dist > wsize) */
|
||||
|
||||
add ecx, r15d ; /* nbytes = dist - nbytes */
|
||||
cmp dword ptr [rsp+96], 0
|
||||
jne L_wrap_around_window ; /* if (write != 0) */
|
||||
|
||||
mov rsi, [rsp+56] ; /* from = window */
|
||||
sub eax, ecx ; /* eax -= nbytes */
|
||||
add rsi, rax ; /* from += wsize - nbytes */
|
||||
|
||||
mov eax, r14d ; /* eax = len */
|
||||
cmp r14d, ecx
|
||||
jbe L_do_copy ; /* if (nbytes >= len) */
|
||||
|
||||
sub eax, ecx ; /* eax -= nbytes */
|
||||
rep movsb
|
||||
mov rsi, rdi
|
||||
sub rsi, r15 ; /* from = &out[ -dist ] */
|
||||
jmp L_do_copy
|
||||
|
||||
ALIGN 4
|
||||
L_wrap_around_window:
|
||||
mov eax, [rsp+96] ; /* eax = write */
|
||||
cmp ecx, eax
|
||||
jbe L_contiguous_in_window ; /* if (write >= nbytes) */
|
||||
|
||||
mov esi, [rsp+92] ; /* from = wsize */
|
||||
add rsi, [rsp+56] ; /* from += window */
|
||||
add rsi, rax ; /* from += write */
|
||||
sub rsi, rcx ; /* from -= nbytes */
|
||||
sub ecx, eax ; /* nbytes -= write */
|
||||
|
||||
mov eax, r14d ; /* eax = len */
|
||||
cmp eax, ecx
|
||||
jbe L_do_copy ; /* if (nbytes >= len) */
|
||||
|
||||
sub eax, ecx ; /* len -= nbytes */
|
||||
rep movsb
|
||||
mov rsi, [rsp+56] ; /* from = window */
|
||||
mov ecx, [rsp+96] ; /* nbytes = write */
|
||||
cmp eax, ecx
|
||||
jbe L_do_copy ; /* if (nbytes >= len) */
|
||||
|
||||
sub eax, ecx ; /* len -= nbytes */
|
||||
rep movsb
|
||||
mov rsi, rdi
|
||||
sub rsi, r15 ; /* from = out - dist */
|
||||
jmp L_do_copy
|
||||
|
||||
ALIGN 4
|
||||
L_contiguous_in_window:
|
||||
mov rsi, [rsp+56] ; /* rsi = window */
|
||||
add rsi, rax
|
||||
sub rsi, rcx ; /* from += write - nbytes */
|
||||
|
||||
mov eax, r14d ; /* eax = len */
|
||||
cmp eax, ecx
|
||||
jbe L_do_copy ; /* if (nbytes >= len) */
|
||||
|
||||
sub eax, ecx ; /* len -= nbytes */
|
||||
rep movsb
|
||||
mov rsi, rdi
|
||||
sub rsi, r15 ; /* from = out - dist */
|
||||
jmp L_do_copy ; /* if (nbytes >= len) */
|
||||
|
||||
ALIGN 4
|
||||
L_do_copy:
|
||||
mov ecx, eax ; /* ecx = len */
|
||||
rep movsb
|
||||
|
||||
mov rsi, r8 ; /* move in back to %esi, toss from */
|
||||
jmp L_while_test
|
||||
|
||||
L_test_for_end_of_block:
|
||||
test al, 32
|
||||
jz L_invalid_literal_length_code
|
||||
mov dword ptr [rsp+116], 1
|
||||
jmp L_break_loop_with_status
|
||||
|
||||
L_invalid_literal_length_code:
|
||||
mov dword ptr [rsp+116], 2
|
||||
jmp L_break_loop_with_status
|
||||
|
||||
L_invalid_distance_code:
|
||||
mov dword ptr [rsp+116], 3
|
||||
jmp L_break_loop_with_status
|
||||
|
||||
L_invalid_distance_too_far:
|
||||
mov dword ptr [rsp+116], 4
|
||||
jmp L_break_loop_with_status
|
||||
|
||||
L_break_loop:
|
||||
mov dword ptr [rsp+116], 0
|
||||
|
||||
L_break_loop_with_status:
|
||||
; /* put in, out, bits, and hold back into ar and pop esp */
|
||||
mov [rsp+16], rsi ; /* in */
|
||||
mov [rsp+32], rdi ; /* out */
|
||||
mov [rsp+88], ebx ; /* bits */
|
||||
mov [rsp+80], rdx ; /* hold */
|
||||
|
||||
mov rax, [rsp] ; /* restore rbp and rsp */
|
||||
mov rbp, [rsp+8]
|
||||
mov rsp, rax
|
||||
|
||||
|
||||
|
||||
mov rsi,[rsp-8]
|
||||
mov rdi,[rsp-16]
|
||||
mov r12,[rsp-24]
|
||||
mov r13,[rsp-32]
|
||||
mov r14,[rsp-40]
|
||||
mov r15,[rsp-48]
|
||||
mov rbx,[rsp-56]
|
||||
|
||||
ret 0
|
||||
; :
|
||||
; : "m" (ar)
|
||||
; : "memory", "%rax", "%rbx", "%rcx", "%rdx", "%rsi", "%rdi",
|
||||
; "%r8", "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15"
|
||||
; );
|
||||
|
||||
inffas8664fnc ENDP
|
||||
;_TEXT ENDS
|
||||
END
|
BIN
lib/zlib-1.2.3/contrib/masmx64/inffasx64.obj
Normal file
BIN
lib/zlib-1.2.3/contrib/masmx64/inffasx64.obj
Normal file
Binary file not shown.
28
lib/zlib-1.2.3/contrib/masmx64/readme.txt
Normal file
28
lib/zlib-1.2.3/contrib/masmx64/readme.txt
Normal file
|
@ -0,0 +1,28 @@
|
|||
Summary
|
||||
-------
|
||||
This directory contains ASM implementations of the functions
|
||||
longest_match() and inflate_fast(), for 64 bits x86 (both AMD64 and Intel EM64t),
|
||||
for use with Microsoft Macro Assembler (x64) for AMD64 and Microsoft C++ 64 bits.
|
||||
|
||||
gvmat64.asm is written by Gilles Vollant (2005), by using Brian Raiter 686/32 bits
|
||||
assembly optimized version from Jean-loup Gailly original longest_match function
|
||||
|
||||
inffasx64.asm and inffas8664.c were written by Chris Anderson, by optimizing
|
||||
original function from Mark Adler
|
||||
|
||||
Use instructions
|
||||
----------------
|
||||
Copy these files into the zlib source directory.
|
||||
|
||||
define ASMV and ASMINF in your project. Include inffas8664.c in your source tree,
|
||||
and inffasx64.obj and gvmat64.obj as object to link.
|
||||
|
||||
|
||||
Build instructions
|
||||
------------------
|
||||
run bld_64.bat with Microsoft Macro Assembler (x64) for AMD64 (ml64.exe)
|
||||
|
||||
ml64.exe is given with Visual Studio 2005, Windows 2003 server DDK
|
||||
|
||||
You can get Windows 2003 server DDK with ml64 and cl for AMD64 from
|
||||
http://www.microsoft.com/whdc/devtools/ddk/default.mspx for low price)
|
2
lib/zlib-1.2.3/contrib/masmx86/bld_ml32.bat
Normal file
2
lib/zlib-1.2.3/contrib/masmx86/bld_ml32.bat
Normal file
|
@ -0,0 +1,2 @@
|
|||
ml /coff /Zi /c /Flgvmat32.lst gvmat32.asm
|
||||
ml /coff /Zi /c /Flinffas32.lst inffas32.asm
|
972
lib/zlib-1.2.3/contrib/masmx86/gvmat32.asm
Normal file
972
lib/zlib-1.2.3/contrib/masmx86/gvmat32.asm
Normal file
|
@ -0,0 +1,972 @@
|
|||
; 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
|
||||
;
|
||||
; http://www.zlib.net
|
||||
; http://www.winimage.com/zLibDll
|
||||
; http://www.muppetlabs.com/~breadbox/software/assembly.html
|
||||
;
|
||||
; For Visual C++ 4.x and higher and ML 6.x and higher
|
||||
; ml.exe is in directory \MASM611C of Win95 DDK
|
||||
; ml.exe is also distributed in http://www.masm32.com/masmdl.htm
|
||||
; and in VC++2003 toolkit at http://msdn.microsoft.com/visualc/vctoolkit2003/
|
||||
;
|
||||
; this file contain two implementation of longest_match
|
||||
;
|
||||
; longest_match_7fff : written 1996 by Gilles Vollant optimized for
|
||||
; first Pentium. Assume s->w_mask == 0x7fff
|
||||
; longest_match_686 : written by Brian raiter (1998), optimized for Pentium Pro
|
||||
;
|
||||
; for using an seembly version of longest_match, you need define ASMV in project
|
||||
; There is two way in using gvmat32.asm
|
||||
;
|
||||
; A) Suggested method
|
||||
; if you want include both longest_match_7fff and longest_match_686
|
||||
; compile the asm file running
|
||||
; ml /coff /Zi /Flgvmat32.lst /c gvmat32.asm
|
||||
; and include gvmat32c.c in your project
|
||||
; if you have an old cpu (386,486 or first Pentium) and s->w_mask==0x7fff,
|
||||
; longest_match_7fff will be used
|
||||
; if you have a more modern CPU (Pentium Pro, II and higher)
|
||||
; longest_match_686 will be used
|
||||
; on old cpu with s->w_mask!=0x7fff, longest_match_686 will be used,
|
||||
; but this is not a sitation you'll find often
|
||||
;
|
||||
; B) Alternative
|
||||
; if you are not interresed in old cpu performance and want the smaller
|
||||
; binaries possible
|
||||
;
|
||||
; compile the asm file running
|
||||
; ml /coff /Zi /c /Flgvmat32.lst /DNOOLDPENTIUMCODE gvmat32.asm
|
||||
; and do not include gvmat32c.c in your project (ou define also
|
||||
; NOOLDPENTIUMCODE)
|
||||
;
|
||||
; note : as I known, longest_match_686 is very faster than longest_match_7fff
|
||||
; on pentium Pro/II/III, faster (but less) in P4, but it seem
|
||||
; longest_match_7fff can be faster (very very litte) on AMD Athlon64/K8
|
||||
;
|
||||
; see below : zlib1222add must be adjuster if you use a zlib version < 1.2.2.2
|
||||
|
||||
;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 +zlib1222add offsets are due to the addition of fields
|
||||
; in zlib in the deflate_state structure since the asm code was first written
|
||||
; (if you compile with zlib 1.0.4 or older, use "zlib1222add equ (-4)").
|
||||
; (if you compile with zlib between 1.0.5 and 1.2.2.1, use "zlib1222add equ 0").
|
||||
; if you compile with zlib 1.2.2.2 or later , use "zlib1222add equ 8").
|
||||
|
||||
zlib1222add equ 8
|
||||
|
||||
; Note : these value are good with a 8 bytes boundary pack structure
|
||||
dep_chain_length equ 74h+zlib1222add
|
||||
dep_window equ 30h+zlib1222add
|
||||
dep_strstart equ 64h+zlib1222add
|
||||
dep_prev_length equ 70h+zlib1222add
|
||||
dep_nice_match equ 88h+zlib1222add
|
||||
dep_w_size equ 24h+zlib1222add
|
||||
dep_prev equ 38h+zlib1222add
|
||||
dep_w_mask equ 2ch+zlib1222add
|
||||
dep_good_match equ 84h+zlib1222add
|
||||
dep_match_start equ 68h+zlib1222add
|
||||
dep_lookahead equ 6ch+zlib1222add
|
||||
|
||||
|
||||
_TEXT segment
|
||||
|
||||
IFDEF NOUNDERLINE
|
||||
IFDEF NOOLDPENTIUMCODE
|
||||
public longest_match
|
||||
public match_init
|
||||
ELSE
|
||||
public longest_match_7fff
|
||||
public cpudetect32
|
||||
public longest_match_686
|
||||
ENDIF
|
||||
ELSE
|
||||
IFDEF NOOLDPENTIUMCODE
|
||||
public _longest_match
|
||||
public _match_init
|
||||
ELSE
|
||||
public _longest_match_7fff
|
||||
public _cpudetect32
|
||||
public _longest_match_686
|
||||
ENDIF
|
||||
ENDIF
|
||||
|
||||
MAX_MATCH equ 258
|
||||
MIN_MATCH equ 3
|
||||
MIN_LOOKAHEAD equ (MAX_MATCH+MIN_MATCH+1)
|
||||
|
||||
|
||||
|
||||
IFNDEF NOOLDPENTIUMCODE
|
||||
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
|
||||
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+zlib1222add
|
||||
dsWMask equ 44+zlib1222add
|
||||
dsWindow equ 48+zlib1222add
|
||||
dsPrev equ 56+zlib1222add
|
||||
dsMatchLen equ 88+zlib1222add
|
||||
dsPrevMatch equ 92+zlib1222add
|
||||
dsStrStart equ 100+zlib1222add
|
||||
dsMatchStart equ 104+zlib1222add
|
||||
dsLookahead equ 108+zlib1222add
|
||||
dsPrevLen equ 112+zlib1222add
|
||||
dsMaxChainLen equ 116+zlib1222add
|
||||
dsGoodMatch equ 132+zlib1222add
|
||||
dsNiceMatch equ 136+zlib1222add
|
||||
|
||||
|
||||
;;; 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 NOOLDPENTIUMCODE
|
||||
IFDEF NOUNDERLINE
|
||||
longest_match proc near
|
||||
ELSE
|
||||
_longest_match proc near
|
||||
ENDIF
|
||||
ELSE
|
||||
IFDEF NOUNDERLINE
|
||||
longest_match_686 proc near
|
||||
ELSE
|
||||
_longest_match_686 proc near
|
||||
ENDIF
|
||||
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 NOOLDPENTIUMCODE
|
||||
IFDEF NOUNDERLINE
|
||||
longest_match endp
|
||||
ELSE
|
||||
_longest_match endp
|
||||
ENDIF
|
||||
|
||||
IFDEF NOUNDERLINE
|
||||
match_init proc near
|
||||
ret
|
||||
match_init endp
|
||||
ELSE
|
||||
_match_init proc near
|
||||
ret
|
||||
_match_init endp
|
||||
ENDIF
|
||||
ELSE
|
||||
IFDEF NOUNDERLINE
|
||||
longest_match_686 endp
|
||||
ELSE
|
||||
_longest_match_686 endp
|
||||
ENDIF
|
||||
ENDIF
|
||||
|
||||
_TEXT ends
|
||||
end
|
BIN
lib/zlib-1.2.3/contrib/masmx86/gvmat32.obj
Normal file
BIN
lib/zlib-1.2.3/contrib/masmx86/gvmat32.obj
Normal file
Binary file not shown.
62
lib/zlib-1.2.3/contrib/masmx86/gvmat32c.c
Normal file
62
lib/zlib-1.2.3/contrib/masmx86/gvmat32c.c
Normal file
|
@ -0,0 +1,62 @@
|
|||
/* 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)
|
||||
*
|
||||
* Read comment at beginning of gvmat32.asm for more information
|
||||
*/
|
||||
|
||||
#if defined(ASMV) && (!defined(NOOLDPENTIUMCODE))
|
||||
#include "deflate.h"
|
||||
|
||||
/* 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
|
||||
|
||||
|
||||
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 */
|
||||
|
||||
|
||||
static uInt iIsPPro=2;
|
||||
|
||||
void match_init ()
|
||||
{
|
||||
iIsPPro = (((cpudetect32()/0x100)&0xf)>=6) ? 1 : 0;
|
||||
}
|
||||
|
||||
uInt longest_match(
|
||||
deflate_state *s,
|
||||
IPos cur_match) /* current match */
|
||||
{
|
||||
if (iIsPPro!=0)
|
||||
return longest_match_686(s,cur_match);
|
||||
|
||||
if (s->w_mask != 0x7fff)
|
||||
return longest_match_686(s,cur_match);
|
||||
|
||||
/* now ((s->w_mask == 0x7fff) && (iIsPPro==0)) */
|
||||
return longest_match_7fff(s,cur_match);
|
||||
}
|
||||
|
||||
|
||||
#endif /* defined(ASMV) && (!defined(NOOLDPENTIUMCODE)) */
|
1083
lib/zlib-1.2.3/contrib/masmx86/inffas32.asm
Normal file
1083
lib/zlib-1.2.3/contrib/masmx86/inffas32.asm
Normal file
File diff suppressed because it is too large
Load diff
BIN
lib/zlib-1.2.3/contrib/masmx86/inffas32.obj
Normal file
BIN
lib/zlib-1.2.3/contrib/masmx86/inffas32.obj
Normal file
Binary file not shown.
3
lib/zlib-1.2.3/contrib/masmx86/mkasm.bat
Executable file
3
lib/zlib-1.2.3/contrib/masmx86/mkasm.bat
Executable file
|
@ -0,0 +1,3 @@
|
|||
cl /DASMV /I..\.. /O2 /c gvmat32c.c
|
||||
ml /coff /Zi /c /Flgvmat32.lst gvmat32.asm
|
||||
ml /coff /Zi /c /Flinffas32.lst inffas32.asm
|
21
lib/zlib-1.2.3/contrib/masmx86/readme.txt
Normal file
21
lib/zlib-1.2.3/contrib/masmx86/readme.txt
Normal file
|
@ -0,0 +1,21 @@
|
|||
|
||||
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"
|
||||
|
67
lib/zlib-1.2.3/contrib/minizip/ChangeLogUnzip
Normal file
67
lib/zlib-1.2.3/contrib/minizip/ChangeLogUnzip
Normal file
|
@ -0,0 +1,67 @@
|
|||
Change in 1.01e (12 feb 05)
|
||||
- Fix in zipOpen2 for globalcomment (Rolf Kalbermatter)
|
||||
- Fix possible memory leak in unzip.c (Zoran Stevanovic)
|
||||
|
||||
Change in 1.01b (20 may 04)
|
||||
- Integrate patch from Debian package (submited by Mark Brown)
|
||||
- Add tools mztools from Xavier Roche
|
||||
|
||||
Change in 1.01 (8 may 04)
|
||||
- fix buffer overrun risk in unzip.c (Xavier Roche)
|
||||
- fix a minor buffer insecurity in minizip.c (Mike Whittaker)
|
||||
|
||||
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)
|
25
lib/zlib-1.2.3/contrib/minizip/Makefile
Normal file
25
lib/zlib-1.2.3/contrib/minizip/Makefile
Normal file
|
@ -0,0 +1,25 @@
|
|||
CC=cc
|
||||
CFLAGS=-O -I../..
|
||||
|
||||
UNZ_OBJS = miniunz.o unzip.o ioapi.o ../../libz.a
|
||||
ZIP_OBJS = minizip.o zip.o ioapi.o ../../libz.a
|
||||
|
||||
.c.o:
|
||||
$(CC) -c $(CFLAGS) $*.c
|
||||
|
||||
all: miniunz minizip
|
||||
|
||||
miniunz: $(UNZ_OBJS)
|
||||
$(CC) $(CFLAGS) -o $@ $(UNZ_OBJS)
|
||||
|
||||
minizip: $(ZIP_OBJS)
|
||||
$(CC) $(CFLAGS) -o $@ $(ZIP_OBJS)
|
||||
|
||||
test: miniunz minizip
|
||||
./minizip test readme.txt
|
||||
./miniunz -l test.zip
|
||||
mv readme.txt readme.old
|
||||
./miniunz test.zip
|
||||
|
||||
clean:
|
||||
/bin/rm -f *.o *~ minizip miniunz
|
132
lib/zlib-1.2.3/contrib/minizip/crypt.h
Normal file
132
lib/zlib-1.2.3/contrib/minizip/crypt.h
Normal file
|
@ -0,0 +1,132 @@
|
|||
/* crypt.h -- base code for crypt/uncrypt ZIPfile
|
||||
|
||||
|
||||
Version 1.01e, February 12th, 2005
|
||||
|
||||
Copyright (C) 1998-2005 Gilles Vollant
|
||||
|
||||
This code is a modified version of crypting code in Infozip distribution
|
||||
|
||||
The encryption/decryption parts of this source code (as opposed to the
|
||||
non-echoing password parts) were originally written in Europe. The
|
||||
whole source package can be freely distributed, including from the USA.
|
||||
(Prior to January 2000, re-export from the US was a violation of US law.)
|
||||
|
||||
This encryption code is a direct transcription of the algorithm from
|
||||
Roger Schlafly, described by Phil Katz in the file appnote.txt. This
|
||||
file (appnote.txt) is distributed with the PKZIP program (even in the
|
||||
version without encryption capabilities).
|
||||
|
||||
If you don't need crypting in your application, just define symbols
|
||||
NOCRYPT and NOUNCRYPT.
|
||||
|
||||
This code support the "Traditional PKWARE Encryption".
|
||||
|
||||
The new AES encryption added on Zip format by Winzip (see the page
|
||||
http://www.winzip.com/aes_info.htm ) and PKWare PKZip 5.x Strong
|
||||
Encryption is not supported.
|
||||
*/
|
||||
|
||||
#define CRC32(c, b) ((*(pcrc_32_tab+(((int)(c) ^ (b)) & 0xff))) ^ ((c) >> 8))
|
||||
|
||||
/***********************************************************************
|
||||
* Return the next byte in the pseudo-random sequence
|
||||
*/
|
||||
static int decrypt_byte(unsigned long* pkeys, const 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
|
177
lib/zlib-1.2.3/contrib/minizip/ioapi.c
Normal file
177
lib/zlib-1.2.3/contrib/minizip/ioapi.c
Normal file
|
@ -0,0 +1,177 @@
|
|||
/* ioapi.c -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API
|
||||
|
||||
Version 1.01e, February 12th, 2005
|
||||
|
||||
Copyright (C) 1998-2005 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 = (uLong)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 = (uLong)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;
|
||||
}
|
75
lib/zlib-1.2.3/contrib/minizip/ioapi.h
Normal file
75
lib/zlib-1.2.3/contrib/minizip/ioapi.h
Normal file
|
@ -0,0 +1,75 @@
|
|||
/* ioapi.h -- IO base function header for compress/uncompress .zip
|
||||
files using zlib + zip or unzip API
|
||||
|
||||
Version 1.01e, February 12th, 2005
|
||||
|
||||
Copyright (C) 1998-2005 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
|
||||
|
270
lib/zlib-1.2.3/contrib/minizip/iowin32.c
Normal file
270
lib/zlib-1.2.3/contrib/minizip/iowin32.c
Normal file
|
@ -0,0 +1,270 @@
|
|||
/* 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.01e, February 12th, 2005
|
||||
|
||||
Copyright (C) 1998-2005 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;
|
||||
}
|
Some files were not shown because too many files have changed in this diff Show more
Loading…
Reference in a new issue